00001
00002
00003
00004
00005
00006
00007
00008
00009 #ifndef ADOBE_UI_CORE_OS_UTILITIES_HPP
00010 #define ADOBE_UI_CORE_OS_UTILITIES_HPP
00011
00012
00013
00014 #if !defined(__LP64__)
00015
00016
00017
00018 #include <adobe/config.hpp>
00019
00020 #include <iterator>
00021
00022 #include <adobe/algorithm/set.hpp>
00023 #include <adobe/dictionary_set.hpp>
00024 #include <adobe/extents.hpp>
00025 #include <adobe/future/macintosh_error.hpp>
00026 #include <adobe/future/macintosh_events.hpp>
00027 #include <adobe/istream.hpp>
00028 #include <adobe/macintosh_memory.hpp>
00029 #include <adobe/macintosh_string.hpp>
00030 #include <adobe/name.hpp>
00031 #include <adobe/unicode.hpp>
00032 #include <adobe/widget_attributes.hpp>
00033 #include <adobe/layout_attributes.hpp>
00034 #include <adobe/table_index.hpp>
00035
00036 #include <adobe/future/widgets/headers/platform_metrics.hpp>
00037 #include <adobe/future/widgets/headers/macintosh_metric_extractor.hpp>
00038
00039 #include <boost/noncopyable.hpp>
00040 #include <boost/filesystem/path.hpp>
00041
00042 #include <stdexcept>
00043
00044
00045
00046 namespace adobe {
00047
00048
00049
00050 typedef ::WindowRef keyboard_handler_type;
00051
00052
00053
00054 namespace implementation {
00055
00056
00057
00058 typedef ::ControlRef platform_control_type;
00059
00060
00061
00062 extern aggregate_name_t k_attribute_theme;
00063 extern aggregate_name_t k_attribute_theme_large;
00064 extern aggregate_name_t k_attribute_theme_normal;
00065 extern aggregate_name_t k_attribute_theme_small;
00066 extern aggregate_name_t k_attribute_theme_mini;
00067
00068 extern aggregate_name_t k_metric_gap;
00069
00070 extern aggregate_name_t k_metric_size;
00071 extern aggregate_name_t k_metric_adjust_position;
00072 extern aggregate_name_t k_metric_adjust_size;
00073 extern aggregate_name_t k_metric_adjust_baseline;
00074 extern aggregate_name_t k_metric_outset;
00075 extern aggregate_name_t k_metric_frame;
00076 extern aggregate_name_t k_metric_inset;
00077 extern aggregate_name_t k_metric_spacing;
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087 template <typename T>
00088 bool get_widget_data(::ControlRef widget, ::ControlPartCode part, ::ResType tag, T& data, bool throwing = true)
00089 {
00090 ::Size t_size(sizeof(T));
00091 ::Size actual_size(0);
00092 ::OSStatus result(::GetControlData(widget, part, tag, t_size, &data, &actual_size));
00093
00094 if (!throwing)
00095 return result == noErr;
00096
00097 ::ADOBE_REQUIRE_STATUS(result);
00098
00099 return t_size == actual_size;
00100 }
00101
00102
00103
00104 inline unsigned long get_current_tick_time()
00105 {
00106 return ::EventTimeToTicks(::GetLastUserEventTime());
00107 }
00108
00109
00110
00111 template <typename Widget>
00112 inline boost::uint32_t get_value(const Widget& widget)
00113 {
00114 return get_value< ::ControlRef >(widget.control_m);
00115 }
00116
00117
00118
00119 template <>
00120 inline boost::uint32_t get_value< ::ControlRef >(const ::ControlRef& control)
00121 {
00122 if (!control) return 0;
00123
00124 return ::GetControl32BitValue(control);
00125 }
00126
00127
00128
00129 template <typename T>
00130 void get_bounds(const T& widget, ::Rect& bounds, bool absolute = false);
00131
00132
00133
00134 template <>
00135 void get_bounds< ::ControlRef >(const ::ControlRef& control, ::Rect& bounds, bool absolute);
00136
00137
00138
00139 template <>
00140 inline void get_bounds<auto_control_t>(const auto_control_t& control, ::Rect& bounds, bool absolute)
00141 { return get_bounds(control.get(), bounds, absolute); }
00142
00143
00144
00145
00146
00147
00148
00149
00150
00154
00155 template <typename T>
00156 std::string get_field_text(const T&);
00157
00158
00159
00160 template <>
00161 std::string get_field_text< ::ControlRef >(const ::ControlRef& control);
00162
00163
00164
00165 template <>
00166 inline std::string get_field_text<auto_control_t>(const auto_control_t& control)
00167 { return get_field_text(control.get()); }
00168
00169
00170
00171
00172
00173
00174
00175
00176
00180
00181 template <typename Widget>
00182 std::string get_name(const Widget& widget)
00183 {
00184 return get_name(widget.control_m);
00185 }
00186
00187
00188
00189 template <>
00190 std::string get_name< ::ControlRef >(const ::ControlRef& control);
00191
00192
00193
00194 template <>
00195 std::string get_name< ::WindowRef >(const ::WindowRef& window);
00196
00197
00198
00199 template <>
00200 inline std::string get_name<auto_control_t>(const auto_control_t& control)
00201 { return get_name(control.get()); }
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211 inline ::ATSUFontID get_atsui_font_id(const char* font_name, std::size_t name_length)
00212 {
00213 ::ATSUFontID atsui_font_id;
00214
00215 ::ADOBE_REQUIRE_STATUS(::ATSUFindFontFromName( font_name,
00216 name_length,
00217 static_cast<unsigned long>(kFontNoName),
00218 kFontNoPlatformCode,
00219 kFontNoScriptCode,
00220 kFontNoLanguageCode,
00221 &atsui_font_id));
00222
00223 return atsui_font_id;
00224 }
00225
00226
00227
00228 inline ::ATSUFontID get_atsui_font_id(const char* font_name)
00229 {
00230 return get_atsui_font_id(font_name, std::strlen(font_name));
00231 }
00232
00233
00234
00235 ::FMFontFamily get_classic_font_id(const char* font_name, std::size_t name_length);
00236
00237
00238
00239 inline ::FMFontFamily get_classic_font_id(const char* font_name)
00240 {
00241 return get_classic_font_id(font_name, std::strlen(font_name));
00242 }
00243
00244
00245
00246 inline ::FMFontFamily get_classic_font_id(Str255 font_name)
00247 {
00248 const char* first(reinterpret_cast<char*>(&font_name[1]));
00249 const char* last(first + font_name[0]);
00250 std::string font_name_c(first, last);
00251
00252 return get_classic_font_id(font_name_c.c_str(), font_name_c.size());
00253 }
00254
00255
00256
00257 inline ::ThemeFontID theme_to_ThemeFontID(const theme_t& style)
00258 {
00259 theme_t masked = static_cast<theme_t>(style & theme_mask_s);
00260 ::ThemeFontID font_id(kThemeSystemFont);
00261
00262 switch (masked)
00263 {
00264 case theme_mini_s: font_id = kThemeMiniSystemFont; break;
00265 case theme_small_s: font_id = kThemeSmallSystemFont; break;
00266 case theme_large_s:
00267 case theme_normal_s:
00268 default: font_id = kThemeSystemFont; break;
00269 }
00270
00271 return font_id;
00272 }
00273
00274
00275
00276 template <typename T>
00277 void atsu_set_attribute(::ATSUStyle style, ::ATSUAttributeTag tag, T value)
00278 {
00279 ::ByteCount size = sizeof(value);
00280 ::ATSUAttributeValuePtr ptr = &value;
00281
00282 ADOBE_REQUIRE_STATUS(::ATSUSetAttributes(style, 1, &tag, &size, &ptr));
00283 }
00284
00285
00286
00287
00288
00289
00290 extents_t get_text_dimensions(const std::string& text, theme_t theme);
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300 void theme_to_rec(const theme_t& style, ControlFontStyleRec& style_rec);
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310 template <typename T>
00311 bool set_widget_data(::ControlRef widget, ::ControlPartCode part, ::ResType tag, const T& data, bool throwing = true)
00312 {
00313 ::OSStatus result(::SetControlData(widget, part, tag, sizeof(T), &data));
00314
00315 if (!throwing)
00316 return result == noErr;
00317
00318 ::ADOBE_REQUIRE_STATUS(result);
00319
00320 return true;
00321 }
00322
00323
00324
00325 void set_popup_with_text(ControlRef control, const std::string& text, unsigned long cur_time);
00326
00327
00328
00330
00331 template <typename T>
00332 void set_selection(T& control, std::size_t start_pos, std::size_t end_pos);
00333
00334
00335
00336 template <>
00337 inline void set_selection< ::TXNObject >( ::TXNObject& control,
00338 std::size_t start_pos,
00339 std::size_t end_pos)
00340 {
00341 ::ADOBE_REQUIRE_STATUS(::TXNSetSelection(control, start_pos, end_pos));
00342 }
00343
00344
00345
00346 template <typename Widget>
00347 void set_focus(Widget& widget, bool make_focused)
00348 {
00349 set_focus< ::ControlRef >(widget.control_m, make_focused);
00350 }
00351
00352
00353
00354 template <>
00355 void set_focus< ::ControlRef >(::ControlRef& control, bool make_focused);
00356
00357
00358
00359 template <typename T>
00360 void set_refresh(const T& widget);
00361
00362
00363
00364 template <>
00365 inline void set_refresh< ::ControlRef >(const ::ControlRef& control)
00366 {
00367 assert(control);
00368
00369 ADOBE_REQUIRE_STATUS(::HIViewSetNeedsDisplay(control, true));
00370 }
00371
00372
00373
00374 template <>
00375 inline void set_refresh<auto_control_t>(const auto_control_t& control)
00376 { set_refresh(control.get()); }
00377
00378
00379
00380 template <typename T>
00381 void set_bounds(T& x, const ::Rect& new_bounds);
00382
00383
00384
00385 template <>
00386 void set_bounds< ::ControlRef >(::ControlRef& control, const ::Rect& new_bounds);
00387
00388
00389
00390 template <>
00391 inline void set_bounds<auto_control_t>(auto_control_t& control, const ::Rect& new_bounds)
00392 { ::ControlRef temp(control.get()); set_bounds(temp, new_bounds); }
00393
00394
00395 #if 0
00396 template <>
00397 inline void set_bounds<const auto_control_t>(const auto_control_t& control, const ::Rect& new_bounds)
00398 { ::ControlRef temp(control.get()); set_bounds(temp, new_bounds); }
00399 #endif
00400
00401
00402
00403
00404
00405
00406
00407
00408 template <typename Widget>
00409 inline const std::string& widget_tag(const Widget&)
00410 { static const std::string value_s("<xstr id='metric_unknown'/>{ }</xstr>"); return value_s; }
00411
00412 template <typename Widget>
00413 inline dictionary_t extra_widget_context(const Widget&)
00414 { return dictionary_t(); }
00415
00416 #define ADOBE_WIDGET_TAG_BOILERPLATE(widgettype, static_tag) \
00417 namespace implementation { \
00418 template <> inline const std::string& widget_tag< widgettype >(const widgettype&) \
00419 { static const std::string value_s(static_tag); return value_s; } \
00420 } // namespace implementation
00421
00422
00423
00424 template <typename Widget>
00425 void set_metric_extractor(Widget& w)
00426 {
00427
00428
00429 if (!w.metrics_m.empty())
00430 return;
00431
00432 name_t attribute_theme_value(static_name_t("unknown"));
00433 dictionary_t context;
00434
00435 switch (w.theme_m & theme_mask_s)
00436 {
00437 case theme_large_s: attribute_theme_value = k_attribute_theme_large; break;
00438 case theme_normal_s: attribute_theme_value = k_attribute_theme_normal; break;
00439 case theme_small_s: attribute_theme_value = k_attribute_theme_small; break;
00440 case theme_mini_s: attribute_theme_value = k_attribute_theme_mini; break;
00441 default: break;
00442 }
00443
00444 context.insert(std::make_pair(k_attribute_theme, any_regular_t(attribute_theme_value)));
00445
00446 w.metrics_m = metric_extractor_t(widget_metrics(widget_tag(w),
00447 dictionary_union(extra_widget_context(w), context)));
00448 }
00449
00450
00451
00452 template <typename T>
00453 inline void set_origin(T& x, float left, float top);
00454
00455
00456 #if 0
00457 template <>
00458 inline void set_origin<const auto_control_t>(const auto_control_t& x, float left, float top)
00459 {
00460 assert(false);
00461 }
00462 #endif
00463
00464
00465 template <>
00466 inline void set_origin< ::ControlRef >(::ControlRef& control, float left, float top)
00467 { ADOBE_REQUIRE_STATUS(::HIViewSetBoundsOrigin(control, left, top)); }
00468
00469
00470
00471 template <>
00472 inline void set_origin<auto_control_t>(auto_control_t& control, float left, float top)
00473 { ::ControlRef temp(control.get()); set_origin(temp, left, top); }
00474
00475
00476
00477 template <typename Widget>
00478 void shed_fudges(Widget& control, place_data_t& place_data)
00479 {
00480 height(place_data) += control.metrics_m(k_metric_adjust_size, metric_extractor_t::index_height);
00481 width(place_data) += control.metrics_m(k_metric_adjust_size, metric_extractor_t::index_width);
00482
00483 long fudge_left(control.metrics_m(k_metric_adjust_position, metric_extractor_t::index_left));
00484 long fudge_top(control.metrics_m(k_metric_adjust_position, metric_extractor_t::index_top));
00485
00486 left(place_data) += fudge_left;
00487 top(place_data) += fudge_top;
00488
00489
00490
00491
00492
00493
00494
00495
00496 float left_shift(fudge_left - place_data.horizontal().outset_m.first);
00497 float top_shift(fudge_top - place_data.vertical().outset_m.first);
00498
00499 if (left_shift != 0 || top_shift != 0)
00500 set_origin(control.control_m, left_shift, top_shift);
00501 }
00502
00503
00504
00505 template <typename Widget>
00506 extents_t apply_fudges(const Widget& w, const extents_t& dimensions)
00507 {
00508 extents_t result(dimensions);
00509
00510 set_metric_extractor(w);
00511
00512 result.height() -= w.metrics_m(k_metric_adjust_size, metric_extractor_t::index_height);
00513 result.width() -= w.metrics_m(k_metric_adjust_size, metric_extractor_t::index_width);
00514
00515
00516
00517 result.horizontal().outset_m.first += w.metrics_m(k_metric_outset, metric_extractor_t::index_left);
00518 result.horizontal().outset_m.second += w.metrics_m(k_metric_outset, metric_extractor_t::index_right);
00519 result.vertical().outset_m.first += w.metrics_m(k_metric_outset, metric_extractor_t::index_top);
00520 result.vertical().outset_m.second += w.metrics_m(k_metric_outset, metric_extractor_t::index_bottom);
00521
00522 result.horizontal().frame_m.first += w.metrics_m(k_metric_frame, metric_extractor_t::index_left);
00523 result.horizontal().frame_m.second += w.metrics_m(k_metric_frame, metric_extractor_t::index_right);
00524 result.vertical().frame_m.first += w.metrics_m(k_metric_frame, metric_extractor_t::index_top);
00525 result.vertical().frame_m.second += w.metrics_m(k_metric_frame, metric_extractor_t::index_bottom);
00526
00527 result.horizontal().inset_m.first += w.metrics_m(k_metric_inset, metric_extractor_t::index_left);
00528 result.horizontal().inset_m.second += w.metrics_m(k_metric_inset, metric_extractor_t::index_right);
00529 result.vertical().inset_m.first += w.metrics_m(k_metric_inset, metric_extractor_t::index_top);
00530 result.vertical().inset_m.second += w.metrics_m(k_metric_inset, metric_extractor_t::index_bottom);
00531
00532 if (!result.vertical().guide_set_m.empty())
00533
00534 result.vertical().guide_set_m[0] += w.metrics_m(implementation::k_metric_adjust_baseline);
00535
00536 return result;
00537 }
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547 extents_t::slice_t merge_slices_with(const extents_t& src_retangle1,
00548 const metric_extractor_t& metrics1,
00549 const extents_t& src_retangle2,
00550 const metric_extractor_t& metrics2,
00551 extents_slices_t::slice_select_t slice);
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561 extern aggregate_name_t k_metric_gap;
00562
00563 extern aggregate_name_t k_metric_size;
00564 extern aggregate_name_t k_metric_adjust_position;
00565 extern aggregate_name_t k_metric_adjust_size;
00566 extern aggregate_name_t k_metric_adjust_baseline;
00567 extern aggregate_name_t k_metric_outset;
00568 extern aggregate_name_t k_metric_frame;
00569 extern aggregate_name_t k_metric_inset;
00570 extern aggregate_name_t k_metric_spacing;
00571
00572 const metric_extractor_t& global_metrics();
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582 template <typename Widget>
00583 extents_t measure(const Widget& widget)
00584 { return apply_fudges(widget, measure(widget.control_m)); }
00585
00586
00587
00588 template <>
00589 extents_t measure< ::ControlRef >(const ::ControlRef& control);
00590
00591
00592
00593 template <>
00594 inline extents_t measure<auto_control_t>(const auto_control_t& control)
00595 { return measure(control.get()); }
00596
00597
00598
00599
00600 extents_t measure_theme_text(const std::string& text, theme_t theme);
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610 template <typename Widget>
00611 void set_bounds(Widget& widget, const place_data_t& place_data)
00612 {
00613 assert(widget.control_m);
00614
00615 place_data_t placement(place_data);
00616
00617 implementation::shed_fudges(widget, placement);
00618
00619 ::Rect new_bounds =
00620 {
00621 static_cast<short>(top(placement)),
00622 static_cast<short>(left(placement)),
00623 static_cast<short>(bottom(placement)),
00624 static_cast<short>(right(placement))
00625 };
00626
00627 set_bounds(widget.control_m, new_bounds);
00628 }
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638 inline void set_name(::ControlRef& control, const std::string& name)
00639 {
00640 assert(control);
00641
00642 ADOBE_REQUIRE_STATUS(::SetControlTitleWithCFString(control, explicit_cast<auto_cfstring_t>(name).get()));
00643 }
00644
00645
00646
00648
00649 template <typename Widget>
00650 void set_name(Widget& widget, const std::string& name)
00651 {
00652 set_name(widget.control_m, name);
00653 }
00654
00655
00656
00657
00658
00659
00660
00661
00662
00664
00665 template <typename T>
00666 void set_field_text(T&, const std::string& name);
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676 template <typename Widget>
00677 void set_theme(Widget& widget, theme_t theme)
00678 {
00679 assert(widget.control_m);
00680
00681 widget.theme_m = theme;
00682
00683 set_theme(widget.control_m, theme);
00684 }
00685
00686
00687
00688 template <>
00689 void set_theme< ::ControlRef >(::ControlRef& control, theme_t theme);
00690
00691
00692
00693 template <>
00694 void set_theme< ::TXNObject >(::TXNObject& hitextview, theme_t theme);
00695
00696
00697
00698 template <>
00699 inline void set_theme<auto_control_t>(auto_control_t& control, theme_t theme)
00700 { ::ControlRef temp(control.get()); set_theme(temp, theme); }
00701
00702
00703
00704 template <typename Widget>
00705 void adorn_theme(Widget& widget, theme_t theme)
00706 {
00707 theme_t current(widget.theme_m);
00708
00709
00710 if (theme & theme_mask_s)
00711 current &= ~theme_mask_s;
00712
00713 current |= theme;
00714
00715 set_theme(widget, current);
00716 }
00717
00718
00719
00720 template <typename Widget>
00721 void unadorn_theme(Widget& widget, theme_t theme)
00722 {
00723 theme_t current(widget.theme_m);
00724
00725 current &= ~theme;
00726
00727
00728 if (!(current & theme_mask_s))
00729 current |= theme_normal_s;
00730
00731 set_theme(widget, current);
00732 }
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742 template <typename T>
00743 void set_active(T&, bool make_active);
00744
00745
00746
00747 template <>
00748 void set_active< ::ControlRef >(::ControlRef& control, bool make_active);
00749
00750
00751
00752 template <>
00753 inline void set_active< auto_control_t >(auto_control_t& control, bool make_active)
00754 { ::ControlRef temp(control.get()); set_active(temp, make_active); }
00755
00756
00757
00758 template <typename T>
00759 void set_visible(T&, bool make_visible);
00760
00761
00762
00763 template <>
00764 inline void set_visible< ::ControlRef >(::ControlRef& control, bool make_visible)
00765 {
00766 assert(control);
00767
00768 ADOBE_REQUIRE_STATUS(::HIViewSetVisible(control, make_visible));
00769 }
00770
00771
00772
00773 template <typename T>
00774 void set_focused(T&, bool make_focused);
00775
00776
00777
00778 template <>
00779 inline void set_focused< ::ControlRef >(::ControlRef& control, bool make_focused)
00780 {
00781 assert(control);
00782
00783 set_focus(control, make_focused);
00784 }
00785
00786
00787
00788 template <typename T>
00789 inline bool is_focused(T& control)
00790 { return is_focused(control.control_m); }
00791
00792
00793
00794 template <>
00795 inline bool is_focused< ::ControlRef >(::ControlRef& control)
00796 {
00797 assert(control);
00798
00799 ::ControlRef cur_focus;
00800
00801 ADOBE_REQUIRE_STATUS(::GetKeyboardFocus(::GetControlOwner(control), &cur_focus));
00802
00803 return cur_focus == control;
00804 }
00805
00806 template <>
00807 inline bool is_focused< auto_control_t >(auto_control_t& control)
00808 { ::ControlRef temp(control.get()); return is_focused(temp); }
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818 template <typename Widget>
00819 extents_t widget_best_bounds(Widget& w, const std::string* first, const std::string* last)
00820 {
00821 extents_t result;
00822 int text_height(0);
00823 int text_width(0);
00824 int text_baseline(-1);
00825 std::size_t longest_line_len(0);
00826 std::string placeholder(implementation::get_name(w));
00827
00828 implementation::set_metric_extractor(w);
00829
00830 for (; first != last; ++first)
00831 {
00832 longest_line_len = std::max(longest_line_len, first->size());
00833
00834 implementation::set_name(w, *first);
00835
00836
00837
00838 extents_t extents(implementation::measure(w.control_m));
00839 guide_set_t& poi(extents.vertical().guide_set_m);
00840
00841 text_height = std::max(text_height, extents.height());
00842 text_width = std::max(text_width, extents.width());
00843
00844 if (!poi.empty())
00845 text_baseline = std::max<int>(text_baseline, poi[0]);
00846 }
00847
00848 result.width() = text_width;
00849 result.height() = text_height;
00850
00851
00852
00853
00854 if (longest_line_len)
00855 result.width() += w.metrics_m(implementation::k_metric_spacing);
00856 else
00857 {
00858
00859
00860
00861
00862 implementation::set_name(w, std::string("X"));
00863
00864 extents_t extents(implementation::measure(w.control_m));
00865 guide_set_t& poi(extents.vertical().guide_set_m);
00866
00867 if (!poi.empty())
00868 text_baseline = std::max<int>(text_baseline, poi[0]);
00869 }
00870
00871 if (text_baseline != -1)
00872 result.vertical().guide_set_m.push_back(text_baseline);
00873
00874 implementation::set_name(w, placeholder);
00875
00876 return implementation::apply_fudges(w, result);
00877 }
00878
00879
00880
00881 template <typename Widget>
00882 inline extents_t widget_best_bounds(Widget& w, const std::string& name)
00883 {
00884 const std::string* first(&name);
00885
00886 return widget_best_bounds(w, first, first + 1);
00887 }
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897 std::string convert_utf(::UniChar* buffer, std::size_t size);
00898
00899
00900
00901 std::string convert_utf(UniChar* buffer);
00902
00903
00904
00905 modifiers_t convert_modifiers(::UInt32 os_modifiers);
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915 bool context_menu(::WindowRef parent,
00916 long x, long y,
00917 const name_t* first,
00918 const name_t* last,
00919 name_t& result);
00920
00921
00922
00923
00924
00925
00926
00927
00928
00929 boost::filesystem::path fsref_to_path(const ::FSRef& location);
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939 typedef boost::function<void (boost::uint32_t)> context_slider_callback_t;
00940
00941 void context_slider(boost::uint32_t left,
00942 boost::uint32_t top,
00943 boost::uint32_t width,
00944 boost::uint32_t height,
00945 boost::uint32_t value_min,
00946 boost::uint32_t value_init,
00947 boost::uint32_t value_max,
00948 const context_slider_callback_t& proc);
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958 }
00959
00960
00961
00962 class mouse_in_out_event_tag_t { } ;
00963
00964 struct mouse_in_out_event_handler_t
00965 {
00966 mouse_in_out_event_handler_t()
00967 {
00968 handler_m.insert(kEventClassMouse, kEventMouseEntered);
00969 handler_m.insert(kEventClassMouse, kEventMouseExited);
00970
00971 handler_m.monitor_proc_m = boost::bind(&mouse_in_out_event_handler_t::handle_event,
00972 boost::ref(*this), _1, _2);
00973 }
00974
00975 ::OSStatus handle_event(::EventHandlerCallRef,
00976 ::EventRef event)
00977 {
00978 UInt32 event_class(::GetEventClass(event));
00979 UInt32 event_kind(::GetEventKind(event));
00980
00981 if (event_class != kEventClassMouse)
00982 return eventNotHandledErr;
00983
00984 if (event_kind == kEventMouseEntered)
00985 ADOBE_REQUIRE_STATUS(::SetThemeCursor(kThemeIBeamCursor));
00986 else if (event_kind == kEventMouseExited)
00987 ADOBE_REQUIRE_STATUS(::SetThemeCursor(kThemeArrowCursor));
00988 else
00989 return eventNotHandledErr;
00990
00991 return noErr;
00992 }
00993
00994 event_handler_t handler_m;
00995 mouse_in_out_event_tag_t tag_m;
00996 };
00997
00998
00999
01000 }
01001
01002
01003
01004 #endif
01005
01006
01007
01008 #endif
01009
01010
