]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/carbon/uma.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Got rid of some wierd VisualAge debug nonsense that had appeared in this after the...
[wxWidgets.git] / src / mac / carbon / uma.cpp
... / ...
CommitLineData
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
14static bool sUMAHasAppearance = false ;
15static long sUMAAppearanceVersion = 0 ;
16extern int gAGABackgroundColor ;
17bool UMAHasAppearance() { return sUMAHasAppearance ; }
18long UMAGetAppearanceVersion() { return sUMAAppearanceVersion ; }
19
20static bool sUMAHasWindowManager = false ;
21static long sUMAWindowManagerAttr = 0 ;
22
23bool UMAHasWindowManager() { return sUMAHasWindowManager ; }
24long UMAGetWindowManagerAttr() { return sUMAWindowManagerAttr ; }
25void UMACleanupToolbox()
26{
27#if UMA_USE_APPEARANCE
28 if ( sUMAHasAppearance )
29 {
30 UnregisterAppearanceClient() ;
31 }
32#endif
33 if ( NavServicesAvailable() )
34 {
35 NavUnload() ;
36 }
37}
38void 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
101long 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
118bool UMAGetProcessModeDoesActivateOnFGSwitch()
119{
120 return UMAGetProcessMode() & modeDoesActivateOnFGSwitch ;
121}
122
123// menu manager
124
125void 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
153UInt32 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
171void 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
180void 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
189void 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
207void 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
225void 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
239void 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
253void UMADrawMenuBar()
254{
255 DrawMenuBar() ;
256}
257
258
259void UMASetMenuItemText( MenuRef menu , MenuItemIndex item , StringPtr label )
260{
261 ::SetMenuItemText( menu , item , label ) ;
262}
263
264MenuRef UMANewMenu( SInt16 menuid , StringPtr label )
265{
266 return ::NewMenu(menuid, label);
267}
268
269void UMADisposeMenu( MenuRef menu )
270{
271 DisposeMenu( menu ) ;
272}
273void UMADeleteMenu( SInt16 menuId )
274{
275 ::DeleteMenu( menuId ) ;
276}
277
278void UMAInsertMenu( MenuRef insertMenu , SInt16 afterId )
279{
280 ::InsertMenu( insertMenu , afterId ) ;
281}
282
283
284// quickdraw
285
286int gPrOpenCounter = 0 ;
287
288OSStatus 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
312OSStatus 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
339pascal QDGlobalsPtr GetQDGlobalsPtr (void)
340{
341 return QDGlobalsPtr (* (Ptr*) LMGetCurrentA5 ( ) - 0xCA);
342}
343
344#endif
345
346void 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
368void 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
380GrafPtr 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
390void UMADisposeWindow( WindowRef inWindowRef )
391{
392 wxASSERT( inWindowRef != NULL ) ;
393 DisposeWindow( inWindowRef ) ;
394}
395
396void 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
409void 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
419void UMAShowWindow( WindowRef inWindowRef )
420{
421 ShowWindow( inWindowRef ) ;
422}
423
424void UMAHideWindow( WindowRef inWindowRef )
425{
426 HideWindow( inWindowRef) ;
427}
428
429void UMASelectWindow( WindowRef inWindowRef )
430{
431 SelectWindow( inWindowRef ) ;
432}
433
434void UMABringToFront( WindowRef inWindowRef )
435{
436 BringToFront( inWindowRef ) ;
437}
438
439void UMASendBehind( WindowRef inWindowRef , WindowRef behindWindow )
440{
441 SendBehind( inWindowRef , behindWindow ) ;
442}
443
444void UMACloseWindow(WindowRef inWindowRef)
445{
446#if TARGET_CARBON
447#else
448 CloseWindow( inWindowRef ) ;
449#endif
450}
451
452// appearance additions
453
454void 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
473void 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
492void 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
511void 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
530void 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
549void 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
570void 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
596ControlHandle 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
627void UMADisposeControl (ControlHandle theControl)
628{
629 if ( UMAHasAppearance() )
630 {
631 ::DisposeControl( theControl ) ;
632 }
633 else
634 {
635 ::DisposeControl( theControl ) ;
636 }
637}
638
639
640void 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
654void UMAShowControl (ControlHandle theControl)
655{
656 if ( UMAHasAppearance() )
657 {
658 ::ShowControl( theControl ) ;
659 }
660 else
661 {
662 ::ShowControl( theControl ) ;
663 }
664}
665
666
667void UMAHideControl (ControlHandle theControl)
668{
669 if ( UMAHasAppearance() )
670 {
671 ::HideControl( theControl ) ;
672 }
673 else
674 {
675 ::HideControl( theControl ) ;
676 }
677}
678
679
680void 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
694bool 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
711bool 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
722OSErr 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
745OSErr 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
768OSErr 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
789OSErr 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
811OSErr 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
847ControlPartCode 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
871SInt16 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
896void 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
915void 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
934OSErr 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
957OSErr 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
981OSErr 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
1007OSErr 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
1036short UMAFindWindow( Point inPoint , WindowRef *outWindow )
1037{
1038 // todo add the additional area codes
1039 return FindWindow( inPoint , outWindow ) ;
1040}
1041
1042OSStatus 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
1051OSStatus 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
1060void UMADrawGrowIcon( WindowRef inWindowRef )
1061{
1062 DrawGrowIcon( inWindowRef ) ;
1063}
1064
1065OSStatus UMACollapseWindow( WindowRef inWindowRef , Boolean inCollapseIt )
1066{
1067 return CollapseWindow( inWindowRef , inCollapseIt ) ;
1068}
1069
1070OSStatus UMACollapseAllWindows( Boolean inCollapseEm )
1071{
1072 return CollapseAllWindows( inCollapseEm ) ;
1073}
1074
1075Boolean UMAIsWindowCollapsed( WindowRef inWindowRef )
1076{
1077 return IsWindowCollapsed( inWindowRef ) ;
1078}
1079
1080Boolean UMAIsWindowCollapsable( WindowRef inWindowRef )
1081{
1082 return IsWindowCollapsable( inWindowRef ) ;
1083}
1084
1085// system 8.5 changes<MacWindows.h>
1086OSStatus 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
1252OSStatus 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
1264OSStatus 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
1275void UMAShowFloatingWindows()
1276{
1277#if UMA_USE_WINDOWMGR
1278 if ( UMAHasWindowManager() )
1279 {
1280 ShowFloatingWindows() ;
1281 }
1282#endif
1283}
1284
1285void UMAHideFloatingWindows()
1286{
1287#if UMA_USE_WINDOWMGR
1288 if ( UMAHasWindowManager() )
1289 {
1290 HideFloatingWindows() ;
1291 }
1292#endif
1293}
1294
1295Boolean UMAAreFloatingWindowsVisible()
1296{
1297#if UMA_USE_WINDOWMGR
1298 if ( UMAHasWindowManager() )
1299 {
1300 return AreFloatingWindowsVisible() ;
1301 }
1302#endif
1303 return false ;
1304}
1305
1306WindowRef 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
1320WindowRef 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
1334WindowRef UMAGetActiveNonFloatingWindow()
1335{
1336 return NULL ;
1337}
1338
1339bool UMAIsWindowFloating( WindowRef inWindow )
1340{
1341 WindowClass cl ;
1342
1343 UMAGetWindowClass( inWindow , &cl ) ;
1344 return cl == kFloatingWindowClass ;
1345}
1346
1347bool UMAIsWindowModal( WindowRef inWindow )
1348{
1349 WindowClass cl ;
1350
1351 UMAGetWindowClass( inWindow , &cl ) ;
1352 return cl < kFloatingWindowClass ;
1353}
1354
1355// others
1356
1357void 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}
1385OSStatus 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
wxWidgets (Impactor)