]>
Commit | Line | Data |
---|---|---|
1 | #include "wx/defs.h" | |
2 | #include "wx/dc.h" | |
3 | #include "wx/mac/uma.h" | |
4 | #include "wx/mac/aga.h" | |
5 | ||
6 | #ifdef __UNIX__ | |
7 | #include <Carbon/Carbon.h> | |
8 | #else | |
9 | #include <Navigation.h> | |
10 | #endif | |
11 | ||
12 | // init | |
13 | ||
14 | static bool sUMAHasAppearance = false ; | |
15 | static long sUMAAppearanceVersion = 0 ; | |
16 | extern int gAGABackgroundColor ; | |
17 | bool UMAHasAppearance() { return sUMAHasAppearance ; } | |
18 | long UMAGetAppearanceVersion() { return sUMAAppearanceVersion ; } | |
19 | ||
20 | static bool sUMAHasWindowManager = false ; | |
21 | static long sUMAWindowManagerAttr = 0 ; | |
22 | ||
23 | bool UMAHasWindowManager() { return sUMAHasWindowManager ; } | |
24 | long UMAGetWindowManagerAttr() { return sUMAWindowManagerAttr ; } | |
25 | void UMACleanupToolbox() | |
26 | { | |
27 | #if UMA_USE_APPEARANCE | |
28 | if ( sUMAHasAppearance ) | |
29 | { | |
30 | UnregisterAppearanceClient() ; | |
31 | } | |
32 | #endif | |
33 | if ( NavServicesAvailable() ) | |
34 | { | |
35 | NavUnload() ; | |
36 | } | |
37 | } | |
38 | void UMAInitToolbox( UInt16 inMoreMastersCalls ) | |
39 | { | |
40 | #if !TARGET_CARBON | |
41 | ::MaxApplZone(); | |
42 | for (long i = 1; i <= inMoreMastersCalls; i++) | |
43 | ::MoreMasters(); | |
44 | ||
45 | ::InitGraf(&qd.thePort); | |
46 | ::InitFonts(); | |
47 | ::InitMenus(); | |
48 | ::TEInit(); | |
49 | ::InitDialogs(0L); | |
50 | ::FlushEvents(everyEvent, 0); | |
51 | ::InitCursor(); | |
52 | long total,contig; | |
53 | PurgeSpace(&total, &contig); | |
54 | #else | |
55 | InitCursor(); | |
56 | #endif | |
57 | ||
58 | #if UMA_USE_APPEARANCE | |
59 | long theAppearance ; | |
60 | if ( Gestalt( gestaltAppearanceAttr, &theAppearance ) == noErr ) | |
61 | { | |
62 | sUMAHasAppearance = true ; | |
63 | RegisterAppearanceClient(); | |
64 | if ( Gestalt( gestaltAppearanceVersion, &theAppearance ) == noErr ) | |
65 | { | |
66 | sUMAAppearanceVersion = theAppearance ; | |
67 | } | |
68 | else | |
69 | { | |
70 | sUMAAppearanceVersion = 0x0100 ; | |
71 | } | |
72 | } | |
73 | #endif // UMA_USE_APPEARANCE | |
74 | #if UMA_USE_8_6 | |
75 | #if UMA_USE_WINDOWMGR | |
76 | if ( Gestalt( gestaltWindowMgrAttr, &sUMAWindowManagerAttr ) == noErr ) | |
77 | { | |
78 | sUMAHasWindowManager = sUMAWindowManagerAttr & gestaltWindowMgrPresent ; | |
79 | } | |
80 | #endif // UMA_USE_WINDOWMGR | |
81 | #endif | |
82 | ||
83 | #ifndef __UNIX__ | |
84 | #if TARGET_CARBON | |
85 | // Call currently implicitely done : InitFloatingWindows() ; | |
86 | #else | |
87 | if ( sUMAHasWindowManager ) | |
88 | InitFloatingWindows() ; | |
89 | else | |
90 | InitWindows(); | |
91 | #endif | |
92 | #endif | |
93 | ||
94 | if ( NavServicesAvailable() ) | |
95 | { | |
96 | NavLoad() ; | |
97 | } | |
98 | } | |
99 | ||
100 | // process manager | |
101 | long UMAGetProcessMode() | |
102 | { | |
103 | OSErr err ; | |
104 | ProcessInfoRec processinfo; | |
105 | ProcessSerialNumber procno ; | |
106 | ||
107 | procno.highLongOfPSN = NULL ; | |
108 | procno.lowLongOfPSN = kCurrentProcess ; | |
109 | processinfo.processInfoLength = sizeof(ProcessInfoRec); | |
110 | processinfo.processName = NULL; | |
111 | processinfo.processAppSpec = NULL; | |
112 | ||
113 | err = ::GetProcessInformation( &procno , &processinfo ) ; | |
114 | wxASSERT( err == noErr ) ; | |
115 | return processinfo.processMode ; | |
116 | } | |
117 | ||
118 | bool UMAGetProcessModeDoesActivateOnFGSwitch() | |
119 | { | |
120 | return UMAGetProcessMode() & modeDoesActivateOnFGSwitch ; | |
121 | } | |
122 | ||
123 | // menu manager | |
124 | ||
125 | void UMASetMenuTitle( MenuRef menu , StringPtr title ) | |
126 | { | |
127 | #if !TARGET_CARBON | |
128 | long size = GetHandleSize( (Handle) menu ) ; | |
129 | const long headersize = 14 ; | |
130 | int oldlen = (**menu).menuData[0] + 1; | |
131 | int newlen = title[0] + 1 ; | |
132 | ||
133 | if ( oldlen < newlen ) | |
134 | { | |
135 | // enlarge before adjusting | |
136 | SetHandleSize( (Handle) menu , size + (newlen - oldlen ) ); | |
137 | } | |
138 | ||
139 | if ( oldlen != newlen ) | |
140 | memmove( (char*) (**menu).menuData + newlen , (char*) (**menu).menuData + oldlen , size - headersize - oldlen ) ; | |
141 | ||
142 | memcpy( (char*) (**menu).menuData , title , newlen ) ; | |
143 | if ( oldlen > newlen ) | |
144 | { | |
145 | // shrink after | |
146 | SetHandleSize( (Handle) menu , size + (newlen - oldlen ) ) ; | |
147 | } | |
148 | #else | |
149 | SetMenuTitle( menu , title ) ; | |
150 | #endif | |
151 | } | |
152 | ||
153 | UInt32 UMAMenuEvent( EventRecord *inEvent ) | |
154 | { | |
155 | #if UMA_USE_APPEARANCE | |
156 | if ( UMAHasAppearance() ) | |
157 | { | |
158 | return MenuEvent( inEvent ) ; | |
159 | } | |
160 | else | |
161 | #endif | |
162 | { | |
163 | if ( inEvent->what == keyDown && inEvent->modifiers & cmdKey) | |
164 | { | |
165 | return MenuKey( inEvent->message & charCodeMask ) ; | |
166 | } | |
167 | return NULL ; | |
168 | } | |
169 | } | |
170 | ||
171 | void UMAEnableMenuItem( MenuRef inMenu , MenuItemIndex inItem ) | |
172 | { | |
173 | #if UMA_USE_8_6 || TARGET_CARBON | |
174 | EnableMenuItem( inMenu , inItem ) ; | |
175 | #else | |
176 | EnableItem( inMenu , inItem ) ; | |
177 | #endif | |
178 | } | |
179 | ||
180 | void UMADisableMenuItem( MenuRef inMenu , MenuItemIndex inItem ) | |
181 | { | |
182 | #if UMA_USE_8_6 || TARGET_CARBON | |
183 | DisableMenuItem( inMenu , inItem ) ; | |
184 | #else | |
185 | DisableItem( inMenu , inItem ) ; | |
186 | #endif | |
187 | } | |
188 | ||
189 | void UMAAppendSubMenuItem( MenuRef menu , StringPtr l , SInt16 id ) | |
190 | { | |
191 | Str255 label ; | |
192 | memcpy( label , l , l[0]+1 ) ; | |
193 | // hardcoded adding of the submenu combination for mac | |
194 | ||
195 | int theEnd = label[0] + 1; | |
196 | if (theEnd > 251) | |
197 | theEnd = 251; // mac allows only 255 characters | |
198 | label[theEnd++] = '/'; | |
199 | label[theEnd++] = hMenuCmd; | |
200 | label[theEnd++] = '!'; | |
201 | label[theEnd++] = id ; | |
202 | label[theEnd] = 0x00; | |
203 | label[0] = theEnd; | |
204 | MacAppendMenu(menu, label); | |
205 | } | |
206 | ||
207 | void UMAInsertSubMenuItem( MenuRef menu , StringPtr l , MenuItemIndex item , SInt16 id ) | |
208 | { | |
209 | Str255 label ; | |
210 | memcpy( label , l , l[0]+1 ) ; | |
211 | // hardcoded adding of the submenu combination for mac | |
212 | ||
213 | int theEnd = label[0] + 1; | |
214 | if (theEnd > 251) | |
215 | theEnd = 251; // mac allows only 255 characters | |
216 | label[theEnd++] = '/'; | |
217 | label[theEnd++] = hMenuCmd; | |
218 | label[theEnd++] = '!'; | |
219 | label[theEnd++] = id; | |
220 | label[theEnd] = 0x00; | |
221 | label[0] = theEnd; | |
222 | MacInsertMenuItem(menu, label , item); | |
223 | } | |
224 | ||
225 | void UMAAppendMenuItem( MenuRef menu , StringPtr l , SInt16 key, UInt8 modifiers ) | |
226 | { | |
227 | Str255 label ; | |
228 | memcpy( label , l , l[0]+1 ) ; | |
229 | if ( key ) | |
230 | { | |
231 | int pos = label[0] ; | |
232 | label[++pos] = '/'; | |
233 | label[++pos] = toupper( key ); | |
234 | label[0] = pos ; | |
235 | } | |
236 | MacAppendMenu( menu , label ) ; | |
237 | } | |
238 | ||
239 | void UMAInsertMenuItem( MenuRef menu , StringPtr l , MenuItemIndex item , SInt16 key, UInt8 modifiers ) | |
240 | { | |
241 | Str255 label ; | |
242 | memcpy( label , l , l[0]+1 ) ; | |
243 | if ( key ) | |
244 | { | |
245 | int pos = label[0] ; | |
246 | label[++pos] = '/'; | |
247 | label[++pos] = toupper( key ); | |
248 | label[0] = pos ; | |
249 | } | |
250 | MacInsertMenuItem( menu , label , item) ; | |
251 | } | |
252 | ||
253 | void UMADrawMenuBar() | |
254 | { | |
255 | DrawMenuBar() ; | |
256 | } | |
257 | ||
258 | ||
259 | void UMASetMenuItemText( MenuRef menu , MenuItemIndex item , StringPtr label ) | |
260 | { | |
261 | ::SetMenuItemText( menu , item , label ) ; | |
262 | } | |
263 | ||
264 | MenuRef UMANewMenu( SInt16 menuid , StringPtr label ) | |
265 | { | |
266 | return ::NewMenu(menuid, label); | |
267 | } | |
268 | ||
269 | void UMADisposeMenu( MenuRef menu ) | |
270 | { | |
271 | DisposeMenu( menu ) ; | |
272 | } | |
273 | void UMADeleteMenu( SInt16 menuId ) | |
274 | { | |
275 | ::DeleteMenu( menuId ) ; | |
276 | } | |
277 | ||
278 | void UMAInsertMenu( MenuRef insertMenu , SInt16 afterId ) | |
279 | { | |
280 | ::InsertMenu( insertMenu , afterId ) ; | |
281 | } | |
282 | ||
283 | ||
284 | // quickdraw | |
285 | ||
286 | int gPrOpenCounter = 0 ; | |
287 | ||
288 | OSStatus UMAPrOpen() | |
289 | { | |
290 | #if !TARGET_CARBON | |
291 | OSErr err = noErr ; | |
292 | ++gPrOpenCounter ; | |
293 | if ( gPrOpenCounter == 1 ) | |
294 | { | |
295 | PrOpen() ; | |
296 | err = PrError() ; | |
297 | wxASSERT( err == noErr ) ; | |
298 | } | |
299 | return err ; | |
300 | #else | |
301 | OSStatus err = noErr ; | |
302 | ++gPrOpenCounter ; | |
303 | if ( gPrOpenCounter == 1 ) | |
304 | { | |
305 | err = PMBegin() ; | |
306 | wxASSERT( err == noErr ) ; | |
307 | } | |
308 | return err ; | |
309 | #endif | |
310 | } | |
311 | ||
312 | OSStatus UMAPrClose() | |
313 | { | |
314 | #if !TARGET_CARBON | |
315 | OSErr err = noErr ; | |
316 | wxASSERT( gPrOpenCounter >= 1 ) ; | |
317 | if ( gPrOpenCounter == 1 ) | |
318 | { | |
319 | PrClose() ; | |
320 | err = PrError() ; | |
321 | wxASSERT( err == noErr ) ; | |
322 | } | |
323 | --gPrOpenCounter ; | |
324 | return err ; | |
325 | #else | |
326 | OSStatus err = noErr ; | |
327 | wxASSERT( gPrOpenCounter >= 1 ) ; | |
328 | if ( gPrOpenCounter == 1 ) | |
329 | { | |
330 | err = PMEnd() ; | |
331 | } | |
332 | --gPrOpenCounter ; | |
333 | return err ; | |
334 | #endif | |
335 | } | |
336 | ||
337 | #if !TARGET_CARBON | |
338 | ||
339 | pascal QDGlobalsPtr GetQDGlobalsPtr (void) | |
340 | { | |
341 | return QDGlobalsPtr (* (Ptr*) LMGetCurrentA5 ( ) - 0xCA); | |
342 | } | |
343 | ||
344 | #endif | |
345 | ||
346 | void UMAShowWatchCursor() | |
347 | { | |
348 | OSErr err = noErr; | |
349 | ||
350 | CursHandle watchFob = GetCursor (watchCursor); | |
351 | ||
352 | if (!watchFob) | |
353 | err = nilHandleErr; | |
354 | else | |
355 | { | |
356 | #if TARGET_CARBON | |
357 | Cursor preservedArrow; | |
358 | GetQDGlobalsArrow (&preservedArrow); | |
359 | SetQDGlobalsArrow (*watchFob); | |
360 | InitCursor ( ); | |
361 | SetQDGlobalsArrow (&preservedArrow); | |
362 | #else | |
363 | SetCursor (*watchFob); | |
364 | #endif | |
365 | } | |
366 | } | |
367 | ||
368 | void UMAShowArrowCursor() | |
369 | { | |
370 | #if TARGET_CARBON | |
371 | Cursor arrow; | |
372 | SetCursor (GetQDGlobalsArrow (&arrow)); | |
373 | #else | |
374 | SetCursor (&(qd.arrow)); | |
375 | #endif | |
376 | } | |
377 | ||
378 | // window manager | |
379 | ||
380 | GrafPtr UMAGetWindowPort( WindowRef inWindowRef ) | |
381 | { | |
382 | wxASSERT( inWindowRef != NULL ) ; | |
383 | #if TARGET_CARBON | |
384 | return GetWindowPort( inWindowRef ) ; | |
385 | #else | |
386 | return (GrafPtr) inWindowRef ; | |
387 | #endif | |
388 | } | |
389 | ||
390 | void UMADisposeWindow( WindowRef inWindowRef ) | |
391 | { | |
392 | wxASSERT( inWindowRef != NULL ) ; | |
393 | DisposeWindow( inWindowRef ) ; | |
394 | } | |
395 | ||
396 | void UMASetWTitleC( WindowRef inWindowRef , const char *title ) | |
397 | { | |
398 | Str255 ptitle ; | |
399 | strncpy( (char*)ptitle , title , 96 ) ; | |
400 | ptitle[96] = 0 ; | |
401 | #if TARGET_CARBON | |
402 | c2pstrcpy( ptitle, (char *)ptitle ) ; | |
403 | #else | |
404 | c2pstr( (char*)ptitle ) ; | |
405 | #endif | |
406 | SetWTitle( inWindowRef , ptitle ) ; | |
407 | } | |
408 | ||
409 | void UMAGetWTitleC( WindowRef inWindowRef , char *title ) | |
410 | { | |
411 | GetWTitle( inWindowRef , (unsigned char*)title ) ; | |
412 | #if TARGET_CARBON | |
413 | p2cstrcpy( title, (unsigned char *)title ) ; | |
414 | #else | |
415 | p2cstr( (unsigned char*)title ) ; | |
416 | #endif | |
417 | } | |
418 | ||
419 | void UMAShowWindow( WindowRef inWindowRef ) | |
420 | { | |
421 | ShowWindow( inWindowRef ) ; | |
422 | } | |
423 | ||
424 | void UMAHideWindow( WindowRef inWindowRef ) | |
425 | { | |
426 | HideWindow( inWindowRef) ; | |
427 | } | |
428 | ||
429 | void UMASelectWindow( WindowRef inWindowRef ) | |
430 | { | |
431 | SelectWindow( inWindowRef ) ; | |
432 | } | |
433 | ||
434 | void UMABringToFront( WindowRef inWindowRef ) | |
435 | { | |
436 | BringToFront( inWindowRef ) ; | |
437 | } | |
438 | ||
439 | void UMASendBehind( WindowRef inWindowRef , WindowRef behindWindow ) | |
440 | { | |
441 | SendBehind( inWindowRef , behindWindow ) ; | |
442 | } | |
443 | ||
444 | void UMACloseWindow(WindowRef inWindowRef) | |
445 | { | |
446 | #if TARGET_CARBON | |
447 | #else | |
448 | CloseWindow( inWindowRef ) ; | |
449 | #endif | |
450 | } | |
451 | ||
452 | // appearance additions | |
453 | ||
454 | void UMAActivateControl( ControlHandle inControl ) | |
455 | { | |
456 | #if UMA_USE_APPEARANCE | |
457 | if ( UMAHasAppearance() ) | |
458 | { | |
459 | ::ActivateControl( inControl ) ; | |
460 | } | |
461 | else | |
462 | #endif | |
463 | #if !TARGET_CARBON | |
464 | { | |
465 | AGAActivateControl( inControl ) ; | |
466 | } | |
467 | #else | |
468 | { | |
469 | } | |
470 | #endif | |
471 | } | |
472 | ||
473 | void UMADrawControl( ControlHandle inControl ) | |
474 | { | |
475 | #if UMA_USE_APPEARANCE | |
476 | if ( UMAHasAppearance() ) | |
477 | { | |
478 | ::DrawControlInCurrentPort( inControl ) ; | |
479 | } | |
480 | else | |
481 | #endif | |
482 | #if !TARGET_CARBON | |
483 | { | |
484 | AGADrawControl( inControl ) ; | |
485 | } | |
486 | #else | |
487 | { | |
488 | } | |
489 | #endif | |
490 | } | |
491 | ||
492 | void UMAMoveControl( ControlHandle inControl , short x , short y ) | |
493 | { | |
494 | #if UMA_USE_APPEARANCE | |
495 | if ( UMAHasAppearance() ) | |
496 | { | |
497 | ::MoveControl( inControl , x , y ) ; | |
498 | } | |
499 | else | |
500 | #endif | |
501 | #if !TARGET_CARBON | |
502 | { | |
503 | AGAMoveControl( inControl , x ,y ) ; | |
504 | } | |
505 | #else | |
506 | { | |
507 | } | |
508 | #endif | |
509 | } | |
510 | ||
511 | void UMASizeControl( ControlHandle inControl , short x , short y ) | |
512 | { | |
513 | #if UMA_USE_APPEARANCE | |
514 | if ( UMAHasAppearance() ) | |
515 | { | |
516 | ::SizeControl( inControl , x , y ) ; | |
517 | } | |
518 | else | |
519 | #endif | |
520 | #if !TARGET_CARBON | |
521 | { | |
522 | AGASizeControl( inControl , x ,y ) ; | |
523 | } | |
524 | #else | |
525 | { | |
526 | } | |
527 | #endif | |
528 | } | |
529 | ||
530 | void UMADeactivateControl( ControlHandle inControl ) | |
531 | { | |
532 | #if UMA_USE_APPEARANCE | |
533 | if ( UMAHasAppearance() ) | |
534 | { | |
535 | ::DeactivateControl( inControl ) ; | |
536 | } | |
537 | else | |
538 | #endif | |
539 | #if !TARGET_CARBON | |
540 | { | |
541 | AGADeactivateControl( inControl ) ; | |
542 | } | |
543 | #else | |
544 | { | |
545 | } | |
546 | #endif | |
547 | } | |
548 | ||
549 | void UMASetThemeWindowBackground (WindowRef inWindow, | |
550 | ThemeBrush inBrush, | |
551 | Boolean inUpdate) | |
552 | { | |
553 | #if UMA_USE_APPEARANCE | |
554 | if ( UMAHasAppearance() ) | |
555 | { | |
556 | ::SetThemeWindowBackground( inWindow ,inBrush , inUpdate ) ; | |
557 | } | |
558 | else | |
559 | #endif | |
560 | #if !TARGET_CARBON | |
561 | { | |
562 | AGASetThemeWindowBackground( inWindow , inBrush , inUpdate ) ; | |
563 | } | |
564 | #else | |
565 | { | |
566 | } | |
567 | #endif | |
568 | } | |
569 | ||
570 | void UMAApplyThemeBackground (ThemeBackgroundKind inKind, | |
571 | const Rect * bounds, | |
572 | ThemeDrawState inState, | |
573 | SInt16 inDepth, | |
574 | Boolean inColorDev) | |
575 | { | |
576 | #if UMA_USE_APPEARANCE | |
577 | if ( UMAHasAppearance() ) | |
578 | { | |
579 | /* | |
580 | if ( sUMAAppearanceVersion >= 0x0110 ) | |
581 | ::ApplyThemeBackground( inKind ,bounds , inState , inDepth , inColorDev ) ; | |
582 | */ | |
583 | } | |
584 | else | |
585 | #endif | |
586 | #if !TARGET_CARBON | |
587 | { | |
588 | AGAApplyThemeBackground( inKind ,bounds , inState , inDepth , inColorDev ) ; | |
589 | } | |
590 | #else | |
591 | { | |
592 | } | |
593 | #endif | |
594 | } | |
595 | ||
596 | ControlHandle UMANewControl(WindowPtr owningWindow, | |
597 | const Rect * boundsRect, | |
598 | ConstStr255Param controlTitle, | |
599 | Boolean initiallyVisible, | |
600 | SInt16 initialValue, | |
601 | SInt16 minimumValue, | |
602 | SInt16 maximumValue, | |
603 | SInt16 procID, | |
604 | SInt32 controlReference) | |
605 | { | |
606 | ControlHandle theControl = NULL ; | |
607 | #if UMA_USE_APPEARANCE | |
608 | if ( UMAHasAppearance() ) | |
609 | { | |
610 | theControl = NewControl( owningWindow , boundsRect , controlTitle , initiallyVisible , | |
611 | initialValue , minimumValue , maximumValue , procID , controlReference ) ; | |
612 | } | |
613 | else | |
614 | #endif | |
615 | #if !TARGET_CARBON | |
616 | { | |
617 | theControl = AGANewControl( owningWindow , boundsRect , controlTitle , initiallyVisible , | |
618 | initialValue , minimumValue , maximumValue , procID , controlReference ) ; | |
619 | } | |
620 | #else | |
621 | { | |
622 | } | |
623 | #endif | |
624 | return theControl ; | |
625 | } | |
626 | ||
627 | void UMADisposeControl (ControlHandle theControl) | |
628 | { | |
629 | if ( UMAHasAppearance() ) | |
630 | { | |
631 | ::DisposeControl( theControl ) ; | |
632 | } | |
633 | else | |
634 | { | |
635 | ::DisposeControl( theControl ) ; | |
636 | } | |
637 | } | |
638 | ||
639 | ||
640 | void UMAHiliteControl (ControlHandle theControl, | |
641 | ControlPartCode hiliteState) | |
642 | { | |
643 | if ( UMAHasAppearance() ) | |
644 | { | |
645 | ::HiliteControl( theControl , hiliteState ) ; | |
646 | } | |
647 | else | |
648 | { | |
649 | ::HiliteControl( theControl , hiliteState ) ; | |
650 | } | |
651 | } | |
652 | ||
653 | ||
654 | void UMAShowControl (ControlHandle theControl) | |
655 | { | |
656 | if ( UMAHasAppearance() ) | |
657 | { | |
658 | ::ShowControl( theControl ) ; | |
659 | } | |
660 | else | |
661 | { | |
662 | ::ShowControl( theControl ) ; | |
663 | } | |
664 | } | |
665 | ||
666 | ||
667 | void UMAHideControl (ControlHandle theControl) | |
668 | { | |
669 | if ( UMAHasAppearance() ) | |
670 | { | |
671 | ::HideControl( theControl ) ; | |
672 | } | |
673 | else | |
674 | { | |
675 | ::HideControl( theControl ) ; | |
676 | } | |
677 | } | |
678 | ||
679 | ||
680 | void UMASetControlVisibility (ControlHandle inControl, | |
681 | Boolean inIsVisible, | |
682 | Boolean inDoDraw) | |
683 | { | |
684 | if ( UMAHasAppearance() ) | |
685 | { | |
686 | #if UMA_USE_APPEARANCE | |
687 | ::SetControlVisibility( inControl , inIsVisible, inDoDraw ) ; | |
688 | #endif | |
689 | } | |
690 | } | |
691 | ||
692 | ||
693 | ||
694 | bool UMAIsControlActive (ControlHandle inControl) | |
695 | { | |
696 | #if TARGET_CARBON | |
697 | return IsControlActive( inControl ) ; | |
698 | #else | |
699 | #if UMA_USE_APPEARANCE | |
700 | if ( UMAHasAppearance() ) | |
701 | { | |
702 | return IsControlActive( inControl ) ; | |
703 | } | |
704 | else | |
705 | #endif | |
706 | return (**inControl).contrlHilite == 0 ; | |
707 | #endif | |
708 | } | |
709 | ||
710 | ||
711 | bool UMAIsControlVisible (ControlHandle inControl) | |
712 | { | |
713 | #if UMA_USE_APPEARANCE | |
714 | if ( UMAHasAppearance() ) | |
715 | { | |
716 | return IsControlVisible( inControl ) ; | |
717 | } | |
718 | #endif | |
719 | return true ; | |
720 | } | |
721 | ||
722 | OSErr UMAGetBestControlRect (ControlHandle inControl, | |
723 | Rect * outRect, | |
724 | SInt16 * outBaseLineOffset) | |
725 | { | |
726 | #if UMA_USE_APPEARANCE | |
727 | if ( UMAHasAppearance() ) | |
728 | { | |
729 | return GetBestControlRect( inControl , outRect , outBaseLineOffset ) ; | |
730 | } | |
731 | else | |
732 | #endif | |
733 | #if !TARGET_CARBON | |
734 | { | |
735 | return AGAGetBestControlRect( inControl , outRect , outBaseLineOffset ) ; | |
736 | } | |
737 | #else | |
738 | { | |
739 | return noErr ; | |
740 | } | |
741 | #endif | |
742 | } | |
743 | ||
744 | ||
745 | OSErr UMASetControlFontStyle (ControlHandle inControl, | |
746 | const ControlFontStyleRec * inStyle) | |
747 | { | |
748 | #if UMA_USE_APPEARANCE | |
749 | if ( UMAHasAppearance() ) | |
750 | { | |
751 | return ::SetControlFontStyle( inControl , inStyle ) ; | |
752 | } | |
753 | else | |
754 | #endif | |
755 | #if !TARGET_CARBON | |
756 | return AGASetControlFontStyle( inControl , inStyle ) ; | |
757 | #else | |
758 | { | |
759 | return noErr ; | |
760 | } | |
761 | #endif | |
762 | } | |
763 | ||
764 | ||
765 | ||
766 | // control hierarchy | |
767 | ||
768 | OSErr UMACreateRootControl (WindowPtr inWindow, | |
769 | ControlHandle * outControl) | |
770 | { | |
771 | #if UMA_USE_APPEARANCE | |
772 | if ( UMAHasAppearance() ) | |
773 | { | |
774 | return CreateRootControl( inWindow , outControl ) ; | |
775 | } | |
776 | else | |
777 | #endif | |
778 | #if !TARGET_CARBON | |
779 | return AGACreateRootControl( inWindow , outControl ) ; | |
780 | #else | |
781 | { | |
782 | return noErr ; | |
783 | } | |
784 | #endif | |
785 | } | |
786 | ||
787 | ||
788 | ||
789 | OSErr UMAEmbedControl (ControlHandle inControl, | |
790 | ControlHandle inContainer) | |
791 | { | |
792 | #if UMA_USE_APPEARANCE | |
793 | if ( UMAHasAppearance() ) | |
794 | { | |
795 | return EmbedControl( inControl , inContainer ) ; | |
796 | } | |
797 | else | |
798 | #endif | |
799 | #if !TARGET_CARBON | |
800 | return AGAEmbedControl( inControl , inContainer ) ; ; | |
801 | #else | |
802 | { | |
803 | return noErr ; | |
804 | } | |
805 | #endif | |
806 | } | |
807 | ||
808 | ||
809 | ||
810 | // keyboard focus | |
811 | OSErr UMASetKeyboardFocus (WindowPtr inWindow, | |
812 | ControlHandle inControl, | |
813 | ControlFocusPart inPart) | |
814 | { | |
815 | OSErr err = noErr; | |
816 | GrafPtr port ; | |
817 | GetPort( &port ) ; | |
818 | #if TARGET_CARBON | |
819 | SetPort( GetWindowPort( inWindow ) ) ; | |
820 | #else | |
821 | SetPort( inWindow ) ; | |
822 | #endif | |
823 | SetOrigin( 0 , 0 ) ; | |
824 | #if UMA_USE_APPEARANCE | |
825 | if ( UMAHasAppearance() ) | |
826 | { | |
827 | err = SetKeyboardFocus( inWindow , inControl , inPart ) ; | |
828 | } | |
829 | else | |
830 | #endif | |
831 | #if !TARGET_CARBON | |
832 | err = AGASetKeyboardFocus( inWindow , inControl , inPart ) ; | |
833 | #else | |
834 | { | |
835 | } | |
836 | #endif | |
837 | SetPort( port ) ; | |
838 | wxDC::MacInvalidateSetup() ; | |
839 | return err ; | |
840 | } | |
841 | ||
842 | ||
843 | ||
844 | ||
845 | // events | |
846 | ||
847 | ControlPartCode UMAHandleControlClick (ControlHandle inControl, | |
848 | Point inWhere, | |
849 | SInt16 inModifiers, | |
850 | ControlActionUPP inAction) | |
851 | { | |
852 | #if UMA_USE_APPEARANCE | |
853 | if ( UMAHasAppearance() ) | |
854 | { | |
855 | return HandleControlClick( inControl , inWhere , inModifiers , inAction ) ; | |
856 | } | |
857 | else | |
858 | #endif | |
859 | #if !TARGET_CARBON | |
860 | { | |
861 | return AGAHandleControlClick( inControl , inWhere , inModifiers , inAction ) ; | |
862 | } | |
863 | #else | |
864 | { | |
865 | return noErr ; | |
866 | } | |
867 | #endif | |
868 | } | |
869 | ||
870 | ||
871 | SInt16 UMAHandleControlKey (ControlHandle inControl, | |
872 | SInt16 inKeyCode, | |
873 | SInt16 inCharCode, | |
874 | SInt16 inModifiers) | |
875 | { | |
876 | #if UMA_USE_APPEARANCE | |
877 | if ( UMAHasAppearance() ) | |
878 | { | |
879 | return HandleControlKey( inControl , inKeyCode , inCharCode , inModifiers ) ; | |
880 | } | |
881 | else | |
882 | #endif | |
883 | #if !TARGET_CARBON | |
884 | { | |
885 | return AGAHandleControlKey(inControl , inKeyCode , inCharCode , inModifiers ) ; | |
886 | } | |
887 | #else | |
888 | { | |
889 | return noErr ; | |
890 | } | |
891 | #endif | |
892 | } | |
893 | ||
894 | ||
895 | ||
896 | void UMAIdleControls (WindowPtr inWindow) | |
897 | { | |
898 | #if UMA_USE_APPEARANCE | |
899 | if ( UMAHasAppearance() ) | |
900 | { | |
901 | IdleControls( inWindow ) ; | |
902 | } | |
903 | else | |
904 | #endif | |
905 | #if !TARGET_CARBON | |
906 | { | |
907 | AGAIdleControls( inWindow ) ; | |
908 | } | |
909 | #else | |
910 | { | |
911 | } | |
912 | #endif | |
913 | } | |
914 | ||
915 | void UMAUpdateControls( WindowPtr inWindow , RgnHandle inRgn ) | |
916 | { | |
917 | #if UMA_USE_APPEARANCE | |
918 | if ( UMAHasAppearance() ) | |
919 | { | |
920 | UpdateControls( inWindow , inRgn ) ; | |
921 | } | |
922 | else | |
923 | #endif | |
924 | #if !TARGET_CARBON | |
925 | { | |
926 | AGAUpdateControls( inWindow , inRgn ) ; | |
927 | } | |
928 | #else | |
929 | { | |
930 | } | |
931 | #endif | |
932 | } | |
933 | ||
934 | OSErr UMAGetRootControl( WindowPtr inWindow , ControlHandle *outControl ) | |
935 | { | |
936 | #if UMA_USE_APPEARANCE | |
937 | if ( UMAHasAppearance() ) | |
938 | { | |
939 | return GetRootControl( inWindow , outControl ) ; | |
940 | } | |
941 | else | |
942 | #endif | |
943 | #if !TARGET_CARBON | |
944 | { | |
945 | return AGAGetRootControl( inWindow , outControl ) ; | |
946 | } | |
947 | #else | |
948 | { | |
949 | return noErr ; | |
950 | } | |
951 | #endif | |
952 | } | |
953 | ||
954 | ||
955 | // handling control data | |
956 | ||
957 | OSErr UMASetControlData (ControlHandle inControl, | |
958 | ControlPartCode inPart, | |
959 | ResType inTagName, | |
960 | Size inSize, | |
961 | Ptr inData) | |
962 | { | |
963 | #if UMA_USE_APPEARANCE | |
964 | if ( UMAHasAppearance() ) | |
965 | { | |
966 | return SetControlData( inControl , inPart , inTagName , inSize , inData ) ; | |
967 | } | |
968 | else | |
969 | #endif | |
970 | #if !TARGET_CARBON | |
971 | return AGASetControlData( inControl , inPart , inTagName , inSize , inData ) ; | |
972 | #else | |
973 | { | |
974 | return noErr ; | |
975 | } | |
976 | #endif | |
977 | } | |
978 | ||
979 | ||
980 | ||
981 | OSErr UMAGetControlData (ControlHandle inControl, | |
982 | ControlPartCode inPart, | |
983 | ResType inTagName, | |
984 | Size inBufferSize, | |
985 | Ptr outBuffer, | |
986 | Size * outActualSize) | |
987 | { | |
988 | #if UMA_USE_APPEARANCE | |
989 | if ( UMAHasAppearance() ) | |
990 | { | |
991 | return ::GetControlData( inControl , inPart , inTagName , inBufferSize , outBuffer , outActualSize ) ; | |
992 | } | |
993 | else | |
994 | #endif | |
995 | #if !TARGET_CARBON | |
996 | { | |
997 | return AGAGetControlData( inControl , inPart , inTagName , inBufferSize , outBuffer , outActualSize ) ; | |
998 | } | |
999 | #else | |
1000 | { | |
1001 | return noErr ; | |
1002 | } | |
1003 | #endif | |
1004 | } | |
1005 | ||
1006 | ||
1007 | OSErr UMAGetControlDataSize (ControlHandle inControl, | |
1008 | ControlPartCode inPart, | |
1009 | ResType inTagName, | |
1010 | Size * outMaxSize) | |
1011 | { | |
1012 | #if UMA_USE_APPEARANCE | |
1013 | if ( UMAHasAppearance() ) | |
1014 | { | |
1015 | return GetControlDataSize( inControl , inPart , inTagName , outMaxSize ) ; | |
1016 | } | |
1017 | else | |
1018 | #endif | |
1019 | #if !TARGET_CARBON | |
1020 | { | |
1021 | return AGAGetControlDataSize( inControl , inPart , inTagName , outMaxSize ) ; | |
1022 | } | |
1023 | #else | |
1024 | { | |
1025 | return noErr ; | |
1026 | } | |
1027 | #endif | |
1028 | } | |
1029 | ||
1030 | ||
1031 | ||
1032 | ||
1033 | ||
1034 | // system 8.0 changes | |
1035 | ||
1036 | short UMAFindWindow( Point inPoint , WindowRef *outWindow ) | |
1037 | { | |
1038 | // todo add the additional area codes | |
1039 | return FindWindow( inPoint , outWindow ) ; | |
1040 | } | |
1041 | ||
1042 | OSStatus UMAGetWindowFeatures( WindowRef inWindowRef , UInt32 *outFeatures ) | |
1043 | { | |
1044 | #if UMA_USE_WINDOWMGR | |
1045 | return GetWindowFeatures( inWindowRef , outFeatures ) ; | |
1046 | #else | |
1047 | return 0 ; | |
1048 | #endif | |
1049 | } | |
1050 | ||
1051 | OSStatus UMAGetWindowRegion( WindowRef inWindowRef , WindowRegionCode inRegionCode , RgnHandle ioWinRgn ) | |
1052 | { | |
1053 | #if UMA_USE_WINDOWMGR | |
1054 | return GetWindowRegion( inWindowRef , inRegionCode , ioWinRgn ) ; | |
1055 | #else | |
1056 | return 0 ; | |
1057 | #endif | |
1058 | } | |
1059 | ||
1060 | void UMADrawGrowIcon( WindowRef inWindowRef ) | |
1061 | { | |
1062 | DrawGrowIcon( inWindowRef ) ; | |
1063 | } | |
1064 | ||
1065 | OSStatus UMACollapseWindow( WindowRef inWindowRef , Boolean inCollapseIt ) | |
1066 | { | |
1067 | return CollapseWindow( inWindowRef , inCollapseIt ) ; | |
1068 | } | |
1069 | ||
1070 | OSStatus UMACollapseAllWindows( Boolean inCollapseEm ) | |
1071 | { | |
1072 | return CollapseAllWindows( inCollapseEm ) ; | |
1073 | } | |
1074 | ||
1075 | Boolean UMAIsWindowCollapsed( WindowRef inWindowRef ) | |
1076 | { | |
1077 | return IsWindowCollapsed( inWindowRef ) ; | |
1078 | } | |
1079 | ||
1080 | Boolean UMAIsWindowCollapsable( WindowRef inWindowRef ) | |
1081 | { | |
1082 | return IsWindowCollapsable( inWindowRef ) ; | |
1083 | } | |
1084 | ||
1085 | // system 8.5 changes<MacWindows.h> | |
1086 | OSStatus UMACreateNewWindow( WindowClass windowClass , WindowAttributes attributes , const Rect *bounds, WindowRef *outWindow ) | |
1087 | { | |
1088 | #if UMA_USE_WINDOWMGR | |
1089 | if ( UMAHasWindowManager() ) | |
1090 | { | |
1091 | return CreateNewWindow( windowClass , attributes, bounds, outWindow ) ; | |
1092 | } | |
1093 | else | |
1094 | #endif | |
1095 | { | |
1096 | short procID ; | |
1097 | if ( UMAHasAppearance() ) | |
1098 | { | |
1099 | switch( windowClass ) | |
1100 | { | |
1101 | case kMovableModalWindowClass : | |
1102 | procID = kWindowMovableModalDialogProc; | |
1103 | break ; | |
1104 | case kModalWindowClass : | |
1105 | procID = kWindowShadowDialogProc; | |
1106 | break ; | |
1107 | case kFloatingWindowClass : | |
1108 | if ( attributes & kWindowSideTitlebarAttribute ) | |
1109 | { | |
1110 | if( ( attributes & kWindowResizableAttribute ) && | |
1111 | ( attributes & kWindowFullZoomAttribute ) ) | |
1112 | { | |
1113 | procID = kWindowFloatSideFullZoomGrowProc ; | |
1114 | } | |
1115 | else if( attributes & kWindowFullZoomAttribute ) | |
1116 | { | |
1117 | procID = kWindowFloatSideFullZoomProc; | |
1118 | } | |
1119 | else if ( attributes & kWindowResizableAttribute ) | |
1120 | { | |
1121 | procID = kWindowFloatSideGrowProc; | |
1122 | } | |
1123 | else | |
1124 | { | |
1125 | procID = kWindowFloatSideProc; | |
1126 | } | |
1127 | } | |
1128 | else | |
1129 | { | |
1130 | if( ( attributes & kWindowResizableAttribute ) && | |
1131 | ( attributes & kWindowFullZoomAttribute ) ) | |
1132 | { | |
1133 | procID = kWindowFloatFullZoomGrowProc ; | |
1134 | } | |
1135 | else if( attributes & kWindowFullZoomAttribute ) | |
1136 | { | |
1137 | procID = kWindowFloatFullZoomProc; | |
1138 | } | |
1139 | else if ( attributes & kWindowResizableAttribute ) | |
1140 | { | |
1141 | procID = kWindowFloatGrowProc; | |
1142 | } | |
1143 | else | |
1144 | { | |
1145 | procID = kWindowFloatProc; | |
1146 | } | |
1147 | } | |
1148 | break ; | |
1149 | case kDocumentWindowClass : | |
1150 | default : | |
1151 | if( ( attributes & kWindowResizableAttribute ) && | |
1152 | ( attributes & kWindowFullZoomAttribute ) ) | |
1153 | { | |
1154 | procID = kWindowFullZoomGrowDocumentProc; | |
1155 | } | |
1156 | else if( attributes & kWindowFullZoomAttribute ) | |
1157 | { | |
1158 | procID = kWindowFullZoomDocumentProc; | |
1159 | } | |
1160 | else if ( attributes & kWindowResizableAttribute ) | |
1161 | { | |
1162 | procID = kWindowGrowDocumentProc; | |
1163 | } | |
1164 | else | |
1165 | { | |
1166 | procID = kWindowDocumentProc; | |
1167 | } | |
1168 | break ; | |
1169 | } | |
1170 | } | |
1171 | else | |
1172 | { | |
1173 | switch( windowClass ) | |
1174 | { | |
1175 | case kMovableModalWindowClass : | |
1176 | procID = movableDBoxProc; | |
1177 | break ; | |
1178 | case kModalWindowClass : | |
1179 | procID = altDBoxProc; | |
1180 | break ; | |
1181 | case kFloatingWindowClass : | |
1182 | if ( attributes & kWindowSideTitlebarAttribute ) | |
1183 | { | |
1184 | if( ( attributes & kWindowResizableAttribute ) && | |
1185 | ( attributes & kWindowFullZoomAttribute ) ) | |
1186 | { | |
1187 | procID = floatSideZoomGrowProc ; | |
1188 | } | |
1189 | else if( attributes & kWindowFullZoomAttribute ) | |
1190 | { | |
1191 | procID = floatSideZoomProc; | |
1192 | } | |
1193 | else if ( attributes & kWindowResizableAttribute ) | |
1194 | { | |
1195 | procID = floatSideGrowProc; | |
1196 | } | |
1197 | else | |
1198 | { | |
1199 | procID = floatSideProc; | |
1200 | } | |
1201 | } | |
1202 | else | |
1203 | { | |
1204 | if( ( attributes & kWindowResizableAttribute ) && | |
1205 | ( attributes & kWindowFullZoomAttribute ) ) | |
1206 | { | |
1207 | procID = floatZoomGrowProc ; | |
1208 | } | |
1209 | else if( attributes & kWindowFullZoomAttribute ) | |
1210 | { | |
1211 | procID = floatZoomProc; | |
1212 | } | |
1213 | else if ( attributes & kWindowResizableAttribute ) | |
1214 | { | |
1215 | procID = floatGrowProc; | |
1216 | } | |
1217 | else | |
1218 | { | |
1219 | procID = floatProc; | |
1220 | } | |
1221 | } | |
1222 | break ; | |
1223 | case kDocumentWindowClass : | |
1224 | default : | |
1225 | if( ( attributes & kWindowResizableAttribute ) && | |
1226 | ( attributes & kWindowFullZoomAttribute ) ) | |
1227 | { | |
1228 | procID = zoomDocProc; | |
1229 | } | |
1230 | else if( attributes & kWindowFullZoomAttribute ) | |
1231 | { | |
1232 | procID = zoomNoGrow; | |
1233 | } | |
1234 | else if ( attributes & kWindowResizableAttribute ) | |
1235 | { | |
1236 | procID = documentProc; | |
1237 | } | |
1238 | else | |
1239 | { | |
1240 | procID = noGrowDocProc; | |
1241 | } | |
1242 | break ; | |
1243 | break ; | |
1244 | } | |
1245 | } | |
1246 | *outWindow = NewCWindow(nil, bounds, "\p", false, procID, (WindowRef) -1 /*behind*/, | |
1247 | attributes & kWindowCloseBoxAttribute , (long)NULL); | |
1248 | return noErr ; | |
1249 | } | |
1250 | } | |
1251 | ||
1252 | OSStatus UMAGetWindowClass( WindowRef inWindowRef , WindowClass *outWindowClass ) | |
1253 | { | |
1254 | #if UMA_USE_WINDOWMGR | |
1255 | if ( UMAHasWindowManager() ) | |
1256 | { | |
1257 | return GetWindowClass( inWindowRef , outWindowClass ) ; | |
1258 | } | |
1259 | else | |
1260 | #endif | |
1261 | return kDocumentWindowClass ; | |
1262 | } | |
1263 | ||
1264 | OSStatus UMAGetWindowAttributes( WindowRef inWindowRef , WindowAttributes *outAttributes ) | |
1265 | { | |
1266 | #if UMA_USE_WINDOWMGR | |
1267 | if ( UMAHasWindowManager() ) | |
1268 | { | |
1269 | return GetWindowAttributes( inWindowRef , outAttributes ) ; | |
1270 | } | |
1271 | #endif | |
1272 | return kWindowNoAttributes ; | |
1273 | } | |
1274 | ||
1275 | void UMAShowFloatingWindows() | |
1276 | { | |
1277 | #if UMA_USE_WINDOWMGR | |
1278 | if ( UMAHasWindowManager() ) | |
1279 | { | |
1280 | ShowFloatingWindows() ; | |
1281 | } | |
1282 | #endif | |
1283 | } | |
1284 | ||
1285 | void UMAHideFloatingWindows() | |
1286 | { | |
1287 | #if UMA_USE_WINDOWMGR | |
1288 | if ( UMAHasWindowManager() ) | |
1289 | { | |
1290 | HideFloatingWindows() ; | |
1291 | } | |
1292 | #endif | |
1293 | } | |
1294 | ||
1295 | Boolean UMAAreFloatingWindowsVisible() | |
1296 | { | |
1297 | #if UMA_USE_WINDOWMGR | |
1298 | if ( UMAHasWindowManager() ) | |
1299 | { | |
1300 | return AreFloatingWindowsVisible() ; | |
1301 | } | |
1302 | #endif | |
1303 | return false ; | |
1304 | } | |
1305 | ||
1306 | WindowRef UMAFrontNonFloatingWindow() | |
1307 | { | |
1308 | #if UMA_USE_WINDOWMGR | |
1309 | if ( UMAHasWindowManager() ) | |
1310 | { | |
1311 | return FrontNonFloatingWindow() ; | |
1312 | } | |
1313 | else | |
1314 | #endif | |
1315 | { | |
1316 | return FrontWindow() ; | |
1317 | } | |
1318 | } | |
1319 | ||
1320 | WindowRef UMAFrontWindow() | |
1321 | { | |
1322 | #if UMA_USE_WINDOWMGR | |
1323 | if ( UMAHasWindowManager() ) | |
1324 | { | |
1325 | return FrontWindow() ; | |
1326 | } | |
1327 | else | |
1328 | #endif | |
1329 | { | |
1330 | return FrontWindow() ; | |
1331 | } | |
1332 | } | |
1333 | ||
1334 | WindowRef UMAGetActiveNonFloatingWindow() | |
1335 | { | |
1336 | return NULL ; | |
1337 | } | |
1338 | ||
1339 | bool UMAIsWindowFloating( WindowRef inWindow ) | |
1340 | { | |
1341 | WindowClass cl ; | |
1342 | ||
1343 | UMAGetWindowClass( inWindow , &cl ) ; | |
1344 | return cl == kFloatingWindowClass ; | |
1345 | } | |
1346 | ||
1347 | bool UMAIsWindowModal( WindowRef inWindow ) | |
1348 | { | |
1349 | WindowClass cl ; | |
1350 | ||
1351 | UMAGetWindowClass( inWindow , &cl ) ; | |
1352 | return cl < kFloatingWindowClass ; | |
1353 | } | |
1354 | ||
1355 | // others | |
1356 | ||
1357 | void UMAHighlightAndActivateWindow( WindowRef inWindowRef , bool inActivate ) | |
1358 | { | |
1359 | if ( inWindowRef ) | |
1360 | { | |
1361 | // bool isHighlighted = IsWindowHighlited( inWindowRef ) ; | |
1362 | // if ( inActivate != isHightlited ) | |
1363 | GrafPtr port ; | |
1364 | GetPort( &port ) ; | |
1365 | #if TARGET_CARBON | |
1366 | SetPort( GetWindowPort( inWindowRef ) ) ; | |
1367 | #else | |
1368 | SetPort( inWindowRef ) ; | |
1369 | #endif | |
1370 | SetOrigin( 0 , 0 ) ; | |
1371 | HiliteWindow( inWindowRef , inActivate ) ; | |
1372 | ControlHandle control = NULL ; | |
1373 | UMAGetRootControl( inWindowRef , & control ) ; | |
1374 | if ( control ) | |
1375 | { | |
1376 | if ( inActivate ) | |
1377 | UMAActivateControl( control ) ; | |
1378 | else | |
1379 | UMADeactivateControl( control ) ; | |
1380 | } | |
1381 | SetPort( port ) ; | |
1382 | wxDC::MacInvalidateSetup() ; | |
1383 | } | |
1384 | } | |
1385 | OSStatus UMADrawThemePlacard( const Rect *inRect , ThemeDrawState inState ) | |
1386 | { | |
1387 | #if UMA_USE_APPEARANCE | |
1388 | if ( UMAHasAppearance() ) | |
1389 | { | |
1390 | ::DrawThemePlacard( inRect , inState ) ; | |
1391 | } | |
1392 | else | |
1393 | #endif | |
1394 | #if !TARGET_CARBON | |
1395 | { | |
1396 | } | |
1397 | #else | |
1398 | { | |
1399 | } | |
1400 | #endif | |
1401 | } | |
1402 |