]> git.saurik.com Git - wxWidgets.git/blob - src/mac/classic/uma.cpp
uninitialized variable warning fixed (modified patch 1434065)
[wxWidgets.git] / src / mac / classic / uma.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: uma.cpp
3 // Purpose: UMA support
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Stefan Csomor
9 // Licence: The wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/defs.h"
13
14 #if wxUSE_GUI
15
16 #include "wx/dc.h"
17 #include <MacTextEditor.h>
18
19 #ifndef __DARWIN__
20 # include <Navigation.h>
21 # if defined(TARGET_CARBON)
22 # if PM_USE_SESSION_APIS
23 # include <PMCore.h>
24 # endif
25 # include <PMApplication.h>
26 # else
27 # include <Printing.h>
28 # endif
29 #endif
30
31 #ifndef __DARWIN__
32 #include <Scrap.h>
33 #endif
34 #include "wx/mac/uma.h"
35
36
37 // since we have decided that we only support 8.6 upwards we are
38 // checking for these minimum requirements in the startup code of
39 // the application so all wxWidgets code can safely assume that appearance 1.1
40 // windows manager, control manager, navigation services etc. are
41 // present
42
43 static bool sUMAHasAppearance = false ;
44 static long sUMAAppearanceVersion = 0 ;
45 static long sUMASystemVersion = 0 ;
46 static bool sUMAHasAquaLayout = false ;
47
48 static bool sUMAHasInittedAppearance = false;
49
50 extern int gAGABackgroundColor ;
51 bool UMAHasAppearance() { return sUMAHasAppearance ; }
52 long UMAGetAppearanceVersion() { return sUMAAppearanceVersion ; }
53 long UMAGetSystemVersion() { return sUMASystemVersion ; }
54
55 static bool sUMAHasWindowManager = false ;
56 static long sUMAWindowManagerAttr = 0 ;
57
58 bool UMAHasWindowManager() { return sUMAHasWindowManager ; }
59 long UMAGetWindowManagerAttr() { return sUMAWindowManagerAttr ; }
60 bool UMAHasAquaLayout() { return sUMAHasAquaLayout ; }
61
62
63 void UMACleanupToolbox()
64 {
65 if (sUMAHasInittedAppearance)
66 {
67 UnregisterAppearanceClient() ;
68 }
69 if ( NavServicesAvailable() )
70 {
71 NavUnload() ;
72 }
73 if ( TXNTerminateTextension != (void*) kUnresolvedCFragSymbolAddress )
74 TXNTerminateTextension( ) ;
75 }
76 void UMAInitToolbox( UInt16 inMoreMastersCalls, bool isEmbedded )
77 {
78 #if !TARGET_CARBON
79 ::MaxApplZone();
80 for (long i = 1; i <= inMoreMastersCalls; i++)
81 ::MoreMasters();
82
83 if (!isEmbedded)
84 {
85 ::InitGraf(&qd.thePort);
86 ::InitFonts();
87 ::InitMenus();
88 ::TEInit();
89 ::InitDialogs(0L);
90 ::FlushEvents(everyEvent, 0);
91 }
92
93 long total,contig;
94 PurgeSpace(&total, &contig);
95 #endif
96
97 ::InitCursor();
98
99 if ( Gestalt(gestaltSystemVersion, &sUMASystemVersion) != noErr)
100 sUMASystemVersion = 0x0000 ;
101
102 long theAppearance ;
103 if ( Gestalt( gestaltAppearanceAttr, &theAppearance ) == noErr )
104 {
105 sUMAHasAppearance = true ;
106 OSStatus status = RegisterAppearanceClient();
107 // If status equals appearanceProcessRegisteredErr it means the
108 // appearance client already was registered (For example if we run
109 // embedded, the host might have registered it). In such a case
110 // we don't unregister it later on.
111 if (status != appearanceProcessRegisteredErr)
112 {
113 // Appearance client wasn't registered yet.
114 sUMAHasInittedAppearance = true;
115 }
116
117 if ( Gestalt( gestaltAppearanceVersion, &theAppearance ) == noErr )
118 {
119 sUMAAppearanceVersion = theAppearance ;
120 }
121 else
122 {
123 sUMAAppearanceVersion = 0x0100 ;
124 }
125 }
126 if ( Gestalt( gestaltWindowMgrAttr, &sUMAWindowManagerAttr ) == noErr )
127 {
128 sUMAHasWindowManager = sUMAWindowManagerAttr & gestaltWindowMgrPresent ;
129 }
130
131 #if TARGET_CARBON
132 // Call currently implicitely done : InitFloatingWindows() ;
133 #else
134 if (!isEmbedded)
135 {
136 if ( sUMAHasWindowManager )
137 InitFloatingWindows() ;
138 else
139 InitWindows();
140 }
141 #endif
142
143 if ( NavServicesAvailable() )
144 {
145 NavLoad() ;
146 }
147
148 long menuMgrAttr ;
149 Gestalt( gestaltMenuMgrAttr , &menuMgrAttr ) ;
150 if ( menuMgrAttr & gestaltMenuMgrAquaLayoutMask )
151 sUMAHasAquaLayout = true ;
152
153 if ( TXNInitTextension != (void*) kUnresolvedCFragSymbolAddress )
154 {
155 FontFamilyID fontId ;
156 Str255 fontName ;
157 SInt16 fontSize ;
158 Style fontStyle ;
159 GetThemeFont(kThemeSmallSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
160 GetFNum( fontName, &fontId );
161
162 TXNMacOSPreferredFontDescription fontDescriptions[] =
163 {
164 { fontId , (fontSize << 16) ,kTXNDefaultFontStyle, kTXNSystemDefaultEncoding }
165 } ;
166 int noOfFontDescriptions = sizeof( fontDescriptions ) / sizeof(TXNMacOSPreferredFontDescription) ;
167
168 // kTXNAlwaysUseQuickDrawTextMask might be desirable because of speed increases but it crashes the app under OS X upon key stroke
169 #if 0
170 // leads to unexpected content for clients, TODO configurable
171 OptionBits options = kTXNWantMoviesMask | kTXNWantSoundMask | kTXNWantGraphicsMask ;
172 #else
173 OptionBits options = 0 ;
174 #endif
175
176 #if TARGET_CARBON
177 if ( !UMAHasAquaLayout() )
178 #endif
179 {
180 options |= kTXNAlwaysUseQuickDrawTextMask ;
181 }
182 TXNInitTextension(fontDescriptions, noOfFontDescriptions, options );
183 }
184
185
186 UMASetSystemIsInitialized(true);
187
188 }
189
190 /*
191 Boolean CanUseATSUI()
192 {
193 long result;
194 OSErr err = Gestalt(gestaltATSUVersion, &result);
195 return (err == noErr);
196 }
197 */
198 // process manager
199 long UMAGetProcessMode()
200 {
201 OSErr err ;
202 ProcessInfoRec processinfo;
203 ProcessSerialNumber procno ;
204
205 procno.highLongOfPSN = NULL ;
206 procno.lowLongOfPSN = kCurrentProcess ;
207 processinfo.processInfoLength = sizeof(ProcessInfoRec);
208 processinfo.processName = NULL;
209 processinfo.processAppSpec = NULL;
210
211 err = ::GetProcessInformation( &procno , &processinfo ) ;
212 wxASSERT( err == noErr ) ;
213 return processinfo.processMode ;
214 }
215
216 bool UMAGetProcessModeDoesActivateOnFGSwitch()
217 {
218 return UMAGetProcessMode() & modeDoesActivateOnFGSwitch ;
219 }
220
221 // menu manager
222
223 MenuRef UMANewMenu( SInt16 id , const wxString& title , wxFontEncoding encoding )
224 {
225 wxString str = wxStripMenuCodes( title ) ;
226 MenuRef menu ;
227 #if TARGET_CARBON
228 CreateNewMenu( id , 0 , &menu ) ;
229 SetMenuTitleWithCFString( menu , wxMacCFStringHolder(str , encoding ) ) ;
230 #else
231 Str255 ptitle ;
232 wxMacStringToPascal( str , ptitle ) ;
233 menu = ::NewMenu( id , ptitle ) ;
234 #endif
235 return menu ;
236 }
237
238 void UMASetMenuTitle( MenuRef menu , const wxString& title , wxFontEncoding encoding)
239 {
240 wxString str = wxStripMenuCodes( title ) ;
241 #if TARGET_CARBON
242 SetMenuTitleWithCFString( menu , wxMacCFStringHolder(str , encoding) ) ;
243 #else
244 Str255 ptitle ;
245 wxMacStringToPascal( str , ptitle ) ;
246 SetMenuTitle( menu , ptitle ) ;
247 #endif
248 }
249
250 void UMASetMenuItemText( MenuRef menu, MenuItemIndex item, const wxString& title , wxFontEncoding encoding)
251 {
252 wxString str = wxStripMenuCodes( title ) ;
253 #if TARGET_CARBON
254 SetMenuItemTextWithCFString( menu , item , wxMacCFStringHolder(str , encoding) ) ;
255 #else
256 Str255 ptitle ;
257 wxMacStringToPascal( str , ptitle ) ;
258 SetMenuItemText( menu , item , ptitle ) ;
259 #endif
260 }
261
262
263 UInt32 UMAMenuEvent( EventRecord *inEvent )
264 {
265 return MenuEvent( inEvent ) ;
266 }
267
268 void UMAEnableMenuItem( MenuRef inMenu , MenuItemIndex inItem , bool enable)
269 {
270 if ( enable )
271 EnableMenuItem( inMenu , inItem ) ;
272 else
273 DisableMenuItem( inMenu , inItem ) ;
274 }
275
276 void UMAAppendSubMenuItem( MenuRef menu , const wxString& title, wxFontEncoding encoding , SInt16 id )
277 {
278 MacAppendMenu(menu, "\pA");
279 UMASetMenuItemText(menu, (SInt16) ::CountMenuItems(menu), title , encoding );
280 SetMenuItemHierarchicalID( menu , CountMenuItems( menu ) , id ) ;
281 }
282
283 void UMAInsertSubMenuItem( MenuRef menu , const wxString& title, wxFontEncoding encoding , MenuItemIndex item , SInt16 id )
284 {
285 MacInsertMenuItem(menu, "\pA" , item);
286 UMASetMenuItemText(menu, item , title , encoding);
287 SetMenuItemHierarchicalID( menu , item , id ) ;
288 }
289
290 void UMASetMenuItemShortcut( MenuRef menu , MenuItemIndex item , wxAcceleratorEntry *entry )
291 {
292 if ( !entry )
293 return ;
294
295 UInt8 modifiers = 0 ;
296 SInt16 key = entry->GetKeyCode() ;
297 if ( key )
298 {
299 bool explicitCommandKey = false ;
300
301 if ( entry->GetFlags() & wxACCEL_CTRL )
302 {
303 explicitCommandKey = true ;
304 }
305
306 if (entry->GetFlags() & wxACCEL_ALT )
307 {
308 modifiers |= kMenuOptionModifier ;
309 }
310
311 if (entry->GetFlags() & wxACCEL_SHIFT)
312 {
313 modifiers |= kMenuShiftModifier ;
314 }
315
316 SInt16 glyph = 0 ;
317 SInt16 macKey = key ;
318 if ( key >= WXK_F1 && key <= WXK_F15 )
319 {
320 // for some reasons this must be 0 right now
321 // everything else leads to just the first function key item
322 // to be selected. Thanks to Ryan Wilcox for finding out.
323 macKey = 0 ;
324 glyph = kMenuF1Glyph + ( key - WXK_F1 ) ;
325 if ( key >= WXK_F13 )
326 glyph += 13 ;
327 if ( !explicitCommandKey )
328 modifiers |= kMenuNoCommandModifier ;
329 }
330 else
331 {
332 switch( key )
333 {
334 case WXK_BACK :
335 macKey = kBackspaceCharCode ;
336 glyph = kMenuDeleteLeftGlyph ;
337 break ;
338 case WXK_TAB :
339 macKey = kTabCharCode ;
340 glyph = kMenuTabRightGlyph ;
341 break ;
342 case kEnterCharCode :
343 macKey = kEnterCharCode ;
344 glyph = kMenuEnterGlyph ;
345 break ;
346 case WXK_RETURN :
347 macKey = kReturnCharCode ;
348 glyph = kMenuReturnGlyph ;
349 break ;
350 case WXK_ESCAPE :
351 macKey = kEscapeCharCode ;
352 glyph = kMenuEscapeGlyph ;
353 break ;
354 case WXK_SPACE :
355 macKey = ' ' ;
356 glyph = kMenuSpaceGlyph ;
357 break ;
358 case WXK_DELETE :
359 macKey = kDeleteCharCode ;
360 glyph = kMenuDeleteRightGlyph ;
361 break ;
362 case WXK_CLEAR :
363 macKey = kClearCharCode ;
364 glyph = kMenuClearGlyph ;
365 break ;
366 case WXK_PRIOR : // PAGE UP
367 macKey = kPageUpCharCode ;
368 glyph = kMenuPageUpGlyph ;
369 break ;
370 case WXK_NEXT :
371 macKey = kPageDownCharCode ;
372 glyph = kMenuPageDownGlyph ;
373 break ;
374 case WXK_LEFT :
375 macKey = kLeftArrowCharCode ;
376 glyph = kMenuLeftArrowGlyph ;
377 break ;
378 case WXK_UP :
379 macKey = kUpArrowCharCode ;
380 glyph = kMenuUpArrowGlyph ;
381 break ;
382 case WXK_RIGHT :
383 macKey = kRightArrowCharCode ;
384 glyph = kMenuRightArrowGlyph ;
385 break ;
386 case WXK_DOWN :
387 macKey = kDownArrowCharCode ;
388 glyph = kMenuDownArrowGlyph ;
389 break ;
390 }
391 }
392
393 SetItemCmd( menu, item , macKey );
394 SetMenuItemModifiers(menu, item , modifiers ) ;
395
396 if ( glyph )
397 SetMenuItemKeyGlyph(menu, item , glyph ) ;
398 }
399 }
400
401 void UMAAppendMenuItem( MenuRef menu , const wxString& title, wxFontEncoding encoding , wxAcceleratorEntry *entry )
402 {
403 MacAppendMenu(menu, "\pA");
404 UMASetMenuItemText(menu, (SInt16) ::CountMenuItems(menu), title , encoding );
405 UMASetMenuItemShortcut( menu , (SInt16) ::CountMenuItems(menu), entry ) ;
406 }
407
408 void UMAInsertMenuItem( MenuRef menu , const wxString& title, wxFontEncoding encoding , MenuItemIndex item , wxAcceleratorEntry *entry )
409 {
410 MacInsertMenuItem( menu , "\pA" , item) ;
411 UMASetMenuItemText(menu, item+1 , title , encoding );
412 UMASetMenuItemShortcut( menu , item+1 , entry ) ;
413 }
414
415 // quickdraw
416
417 #if !TARGET_CARBON
418
419 int gPrOpenCounter = 0 ;
420
421 OSStatus UMAPrOpen()
422 {
423 OSErr err = noErr ;
424 ++gPrOpenCounter ;
425 if ( gPrOpenCounter == 1 )
426 {
427 PrOpen() ;
428 err = PrError() ;
429 wxASSERT( err == noErr ) ;
430 }
431 return err ;
432 }
433
434 OSStatus UMAPrClose()
435 {
436 OSErr err = noErr ;
437 wxASSERT( gPrOpenCounter >= 1 ) ;
438 if ( gPrOpenCounter == 1 )
439 {
440 PrClose() ;
441 err = PrError() ;
442 wxASSERT( err == noErr ) ;
443 }
444 --gPrOpenCounter ;
445 return err ;
446 }
447
448 pascal QDGlobalsPtr GetQDGlobalsPtr (void) ;
449 pascal QDGlobalsPtr GetQDGlobalsPtr (void)
450 {
451 return QDGlobalsPtr (* (Ptr*) LMGetCurrentA5 ( ) - 0xCA);
452 }
453
454 #endif
455
456 void UMAShowWatchCursor()
457 {
458 OSErr err = noErr;
459
460 CursHandle watchFob = GetCursor (watchCursor);
461
462 if (!watchFob)
463 err = nilHandleErr;
464 else
465 {
466 #if TARGET_CARBON
467 // Cursor preservedArrow;
468 // GetQDGlobalsArrow (&preservedArrow);
469 // SetQDGlobalsArrow (*watchFob);
470 // InitCursor ( );
471 // SetQDGlobalsArrow (&preservedArrow);
472 SetCursor (*watchFob);
473 #else
474 SetCursor (*watchFob);
475 #endif
476 }
477 }
478
479 void UMAShowArrowCursor()
480 {
481 #if TARGET_CARBON
482 Cursor arrow;
483 SetCursor (GetQDGlobalsArrow (&arrow));
484 #else
485 SetCursor (&(qd.arrow));
486 #endif
487 }
488
489 // window manager
490
491 GrafPtr UMAGetWindowPort( WindowRef inWindowRef )
492 {
493 wxASSERT( inWindowRef != NULL ) ;
494 #if TARGET_CARBON
495 return (GrafPtr) GetWindowPort( inWindowRef ) ;
496 #else
497 return (GrafPtr) inWindowRef ;
498 #endif
499 }
500
501 void UMADisposeWindow( WindowRef inWindowRef )
502 {
503 wxASSERT( inWindowRef != NULL ) ;
504 DisposeWindow( inWindowRef ) ;
505 }
506
507 void UMASetWTitle( WindowRef inWindowRef , const wxString& title , wxFontEncoding encoding)
508 {
509 #if TARGET_CARBON
510 SetWindowTitleWithCFString( inWindowRef , wxMacCFStringHolder(title , encoding) ) ;
511 #else
512 Str255 ptitle ;
513 wxMacStringToPascal( title , ptitle ) ;
514 SetWTitle( inWindowRef , ptitle ) ;
515 #endif
516 }
517
518 // appearance additions
519
520 void UMASetControlTitle( ControlHandle inControl , const wxString& title , wxFontEncoding encoding)
521 {
522 #if TARGET_CARBON
523 SetControlTitleWithCFString( inControl , wxMacCFStringHolder(title , encoding) ) ;
524 #else
525 Str255 ptitle ;
526 wxMacStringToPascal( title , ptitle ) ;
527 SetControlTitle( inControl , ptitle ) ;
528 #endif
529 }
530
531 void UMAActivateControl( ControlHandle inControl )
532 {
533 // we have to add the control after again to the update rgn
534 // otherwise updates get lost
535 if ( !IsControlActive( inControl ) )
536 {
537 bool visible = IsControlVisible( inControl ) ;
538 if ( visible )
539 SetControlVisibility( inControl , false , false ) ;
540 ::ActivateControl( inControl ) ;
541 if ( visible ) {
542 SetControlVisibility( inControl , true , false ) ;
543 Rect ctrlBounds ;
544 InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
545 }
546 }
547 }
548
549 void UMADrawControl( ControlHandle inControl )
550 {
551 WindowRef theWindow = GetControlOwner(inControl) ;
552 wxMacPortStateHelper help( (GrafPtr) GetWindowPort(theWindow) ) ;
553 RgnHandle updateRgn = NewRgn() ;
554 GetWindowUpdateRgn( theWindow , updateRgn ) ;
555 Point zero = { 0 , 0 } ;
556 LocalToGlobal( &zero ) ;
557 OffsetRgn( updateRgn , -zero.h , -zero.v ) ;
558 ::DrawControlInCurrentPort( inControl ) ;
559 InvalWindowRgn( theWindow, updateRgn) ;
560 DisposeRgn( updateRgn ) ;
561 }
562
563 void UMAMoveControl( ControlHandle inControl , short x , short y )
564 {
565 bool visible = IsControlVisible( inControl ) ;
566 if ( visible ) {
567 SetControlVisibility( inControl , false , false ) ;
568 Rect ctrlBounds ;
569 InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
570 }
571 ::MoveControl( inControl , x , y ) ;
572 if ( visible ) {
573 SetControlVisibility( inControl , true , false ) ;
574 Rect ctrlBounds ;
575 InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
576 }
577 }
578
579 void UMASizeControl( ControlHandle inControl , short x , short y )
580 {
581 bool visible = IsControlVisible( inControl ) ;
582 if ( visible ) {
583 SetControlVisibility( inControl , false , false ) ;
584 Rect ctrlBounds ;
585 InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
586 }
587 ::SizeControl( inControl , x , y ) ;
588 if ( visible ) {
589 SetControlVisibility( inControl , true , false ) ;
590 Rect ctrlBounds ;
591 InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
592 }
593 }
594
595 void UMADeactivateControl( ControlHandle inControl )
596 {
597 // we have to add the control after again to the update rgn
598 // otherwise updates get lost
599 bool visible = IsControlVisible( inControl ) ;
600 if ( visible )
601 SetControlVisibility( inControl , false , false ) ;
602 ::DeactivateControl( inControl ) ;
603 if ( visible ) {
604 SetControlVisibility( inControl , true , false ) ;
605 Rect ctrlBounds ;
606 InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
607 }
608 }
609 // shows the control and adds the region to the update region
610 void UMAShowControl (ControlHandle inControl)
611 {
612 SetControlVisibility( inControl , true , false ) ;
613 Rect ctrlBounds ;
614 InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
615 }
616
617 // shows the control and adds the region to the update region
618 void UMAHideControl (ControlHandle inControl)
619 {
620 SetControlVisibility( inControl , false , false ) ;
621 Rect ctrlBounds ;
622 InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
623 }
624 // keyboard focus
625 OSErr UMASetKeyboardFocus (WindowPtr inWindow,
626 ControlHandle inControl,
627 ControlFocusPart inPart)
628 {
629 OSErr err = noErr;
630 GrafPtr port ;
631 GetPort( &port ) ;
632
633 SetPortWindowPort( inWindow ) ;
634
635 err = SetKeyboardFocus( inWindow , inControl , inPart ) ;
636 SetPort( port ) ;
637 return err ;
638 }
639
640
641 // events
642 void UMAUpdateControls( WindowPtr inWindow , RgnHandle inRgn )
643 {
644 wxMacPortStateHelper help( (GrafPtr) GetWindowPort( (WindowRef) inWindow) ) ;
645 RgnHandle updateRgn = NewRgn() ;
646 GetWindowUpdateRgn( inWindow , updateRgn ) ;
647
648 Point zero = { 0 , 0 } ;
649 LocalToGlobal( &zero ) ;
650 OffsetRgn( updateRgn , -zero.h , -zero.v ) ;
651
652 UpdateControls( inWindow , inRgn ) ;
653 InvalWindowRgn( inWindow, updateRgn) ;
654 DisposeRgn( updateRgn ) ;
655 }
656
657 bool UMAIsWindowFloating( WindowRef inWindow )
658 {
659 WindowClass cl ;
660
661 GetWindowClass( inWindow , &cl ) ;
662 return cl == kFloatingWindowClass ;
663 }
664
665 bool UMAIsWindowModal( WindowRef inWindow )
666 {
667 WindowClass cl ;
668
669 GetWindowClass( inWindow , &cl ) ;
670 return cl < kFloatingWindowClass ;
671 }
672
673 // others
674
675 void UMAHighlightAndActivateWindow( WindowRef inWindowRef , bool inActivate )
676 {
677 if ( inWindowRef )
678 {
679 // bool isHighlighted = IsWindowHighlited( inWindowRef ) ;
680 // if ( inActivate != isHightlited )
681 GrafPtr port ;
682 GetPort( &port ) ;
683 SetPortWindowPort( inWindowRef ) ;
684 HiliteWindow( inWindowRef , inActivate ) ;
685 ControlHandle control = NULL ;
686 ::GetRootControl( inWindowRef , & control ) ;
687 if ( control )
688 {
689 if ( inActivate )
690 UMAActivateControl( control ) ;
691 else
692 UMADeactivateControl( control ) ;
693 }
694 SetPort( port ) ;
695 }
696 }
697
698 OSStatus UMADrawThemePlacard( const Rect *inRect , ThemeDrawState inState )
699 {
700 return ::DrawThemePlacard( inRect , inState ) ;
701 }
702
703 #if !TARGET_CARBON
704 static OSStatus helpMenuStatus = noErr ;
705 static MenuItemIndex firstCustomItemIndex = 0 ;
706 #endif
707
708 OSStatus UMAGetHelpMenu(
709 MenuRef * outHelpMenu,
710 MenuItemIndex * outFirstCustomItemIndex)
711 {
712 #if TARGET_CARBON
713 return HMGetHelpMenu( outHelpMenu , outFirstCustomItemIndex ) ;
714 #else
715 MenuRef helpMenuHandle ;
716 helpMenuStatus = HMGetHelpMenuHandle( &helpMenuHandle ) ;
717 if ( firstCustomItemIndex == 0 && helpMenuStatus == noErr )
718 {
719 firstCustomItemIndex = CountMenuItems( helpMenuHandle ) + 1 ;
720 }
721 if ( outFirstCustomItemIndex )
722 {
723 *outFirstCustomItemIndex = firstCustomItemIndex ;
724 }
725 *outHelpMenu = helpMenuHandle ;
726 return helpMenuStatus ;
727 #endif
728 }
729
730 wxMacPortStateHelper::wxMacPortStateHelper( GrafPtr newport)
731 {
732 m_clip = NULL ;
733 Setup( newport ) ;
734 }
735
736 wxMacPortStateHelper::wxMacPortStateHelper()
737 {
738 m_clip = NULL ;
739 }
740
741 void wxMacPortStateHelper::Setup( GrafPtr newport )
742 {
743 GetPort( &m_oldPort ) ;
744 SetPort( newport ) ;
745 SetOrigin(0,0);
746 wxASSERT_MSG( m_clip == NULL , wxT("Cannot call setup twice") ) ;
747 m_clip = NewRgn() ;
748 GetClip( m_clip );
749 m_textFont = GetPortTextFont( (CGrafPtr) newport);
750 m_textSize = GetPortTextSize( (CGrafPtr) newport);
751 m_textStyle = GetPortTextFace( (CGrafPtr) newport);
752 m_textMode = GetPortTextMode( (CGrafPtr) newport);
753 GetThemeDrawingState( &m_drawingState ) ;
754 m_currentPort = newport ;
755 }
756 void wxMacPortStateHelper::Clear()
757 {
758 if ( m_clip )
759 {
760 DisposeRgn( m_clip ) ;
761 DisposeThemeDrawingState( m_drawingState ) ;
762 m_clip = NULL ;
763 }
764 }
765
766 wxMacPortStateHelper::~wxMacPortStateHelper()
767 {
768 if ( m_clip )
769 {
770 SetPort( m_currentPort ) ;
771 SetClip( m_clip ) ;
772 DisposeRgn( m_clip ) ;
773 TextFont( m_textFont );
774 TextSize( m_textSize );
775 TextFace( m_textStyle );
776 TextMode( m_textMode );
777 SetThemeDrawingState( m_drawingState , true ) ;
778 SetPort( m_oldPort ) ;
779 }
780 }
781
782 OSStatus UMAPutScrap( Size size , OSType type , void *data )
783 {
784 OSStatus err = noErr ;
785 #if !TARGET_CARBON
786 err = PutScrap( size , type , data ) ;
787 #else
788 ScrapRef scrap;
789 err = GetCurrentScrap (&scrap);
790 if ( !err )
791 {
792 err = PutScrapFlavor (scrap, type , 0, size, data);
793 }
794 #endif
795 return err ;
796 }
797
798 #endif // wxUSE_GUI
799
800 #if wxUSE_BASE
801
802 static bool sUMASystemInitialized = false ;
803
804 bool UMASystemIsInitialized()
805 {
806 return sUMASystemInitialized ;
807 }
808
809 void UMASetSystemIsInitialized(bool val)
810 {
811 sUMASystemInitialized = val;
812 }
813
814
815 #endif // wxUSE_BASE