src/mac/carbon/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 wxWindows 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     OptionBits options = 0 ;
 169
 170     if ( UMAGetSystemVersion() < 0x1000 )
 171     {
 172         options |= kTXNAlwaysUseQuickDrawTextMask ;
 173     }
 174     TXNInitTextension(fontDescriptions,  noOfFontDescriptions, options );
 175   }
 176
 177
 178   UMASetSystemIsInitialized(true);
 179
 180 }
 181
 182 /*
 183 Boolean CanUseATSUI()
 184     {
 185     long result;
 186     OSErr err = Gestalt(gestaltATSUVersion, &result);
 187     return (err == noErr);
 188     }
 189 */
 190 // process manager
 191 long UMAGetProcessMode()
 192 {
 193     OSErr err ;
 194     ProcessInfoRec processinfo;
 195     ProcessSerialNumber procno ;
 196
 197     procno.highLongOfPSN = NULL ;
 198     procno.lowLongOfPSN = kCurrentProcess ;
 199     processinfo.processInfoLength = sizeof(ProcessInfoRec);
 200     processinfo.processName = NULL;
 201     processinfo.processAppSpec = NULL;
 202
 203     err = ::GetProcessInformation( &procno , &processinfo ) ;
 204     wxASSERT( err == noErr ) ;
 205     return processinfo.processMode ;
 206 }
 207
 208 bool UMAGetProcessModeDoesActivateOnFGSwitch()
 209 {
 210     return UMAGetProcessMode() & modeDoesActivateOnFGSwitch ;
 211 }
 212
 213 // menu manager
 214
 215 MenuRef UMANewMenu( SInt16 id , const wxString& title , wxFontEncoding encoding )
 216 {
 217     wxString str = wxStripMenuCodes( title ) ;
 218     MenuRef menu ;
 219 #if TARGET_CARBON
 220     CreateNewMenu( id , 0 , &menu ) ;
 221     SetMenuTitleWithCFString( menu , wxMacCFStringHolder(str , encoding ) ) ;
 222 #else
 223     Str255 ptitle ;
 224     wxMacStringToPascal( str , ptitle ) ;
 225     menu = ::NewMenu( id , ptitle ) ;
 226 #endif
 227     return menu ;
 228 }
 229
 230 void UMASetMenuTitle( MenuRef menu , const wxString& title , wxFontEncoding encoding)
 231 {
 232     wxString str = wxStripMenuCodes( title ) ;
 233 #if TARGET_CARBON
 234     SetMenuTitleWithCFString( menu , wxMacCFStringHolder(str , encoding) ) ;
 235 #else
 236     Str255 ptitle ;
 237     wxMacStringToPascal( str , ptitle ) ;
 238     SetMenuTitle( menu , ptitle ) ;
 239 #endif
 240 }
 241
 242 void UMASetMenuItemText(  MenuRef menu,  MenuItemIndex item, const wxString& title , wxFontEncoding encoding)
 243 {
 244     wxString str = wxStripMenuCodes( title ) ;
 245 #if TARGET_CARBON
 246     SetMenuItemTextWithCFString( menu , item , wxMacCFStringHolder(str , encoding) ) ;
 247 #else
 248     Str255 ptitle ;
 249     wxMacStringToPascal( str , ptitle ) ;
 250     SetMenuItemText( menu , item , ptitle ) ;
 251 #endif
 252 }
 253
 254
 255 UInt32 UMAMenuEvent( EventRecord *inEvent )
 256 {
 257         return MenuEvent( inEvent ) ;
 258 }
 259
 260 void UMAEnableMenuItem( MenuRef inMenu , MenuItemIndex inItem , bool enable)
 261 {
 262     if ( enable )
 263         EnableMenuItem( inMenu , inItem ) ;
 264     else
 265         DisableMenuItem( inMenu , inItem ) ;
 266 }
 267
 268 void UMAAppendSubMenuItem( MenuRef menu , const wxString& title, wxFontEncoding encoding , SInt16 id )
 269 {
 270     MacAppendMenu(menu, "\pA");
 271     UMASetMenuItemText(menu, (SInt16) ::CountMenuItems(menu), title , encoding );
 272     SetMenuItemHierarchicalID( menu , CountMenuItems( menu ) , id ) ;
 273 }
 274
 275 void UMAInsertSubMenuItem( MenuRef menu , const wxString& title, wxFontEncoding encoding , MenuItemIndex item , SInt16 id  )
 276 {
 277     MacInsertMenuItem(menu, "\pA" , item);
 278     UMASetMenuItemText(menu, item , title , encoding);
 279     SetMenuItemHierarchicalID( menu , item , id ) ;
 280 }
 281
 282 void UMASetMenuItemShortcut( MenuRef menu , MenuItemIndex item , wxAcceleratorEntry *entry )
 283 {
 284     if ( !entry )
 285         return ;
 286
 287     UInt8 modifiers = 0 ;
 288     SInt16 key = entry->GetKeyCode() ;
 289     if ( key )
 290     {
 291         bool explicitCommandKey = false ;
 292
 293         if ( entry->GetFlags() & wxACCEL_CTRL )
 294         {
 295             explicitCommandKey = true ;
 296         }
 297
 298         if (entry->GetFlags() & wxACCEL_ALT )
 299         {
 300             modifiers |= kMenuOptionModifier ;
 301         }
 302
 303         if (entry->GetFlags() & wxACCEL_SHIFT)
 304         {
 305             modifiers |= kMenuShiftModifier ;
 306         }
 307
 308         SInt16 glyph = 0 ;
 309         SInt16 macKey = key ;
 310         if ( key >= WXK_F1 && key <= WXK_F15 )
 311         {
 312             // for some reasons this must be 0 right now
 313             // everything else leads to just the first function key item
 314             // to be selected. Thanks to Ryan Wilcox for finding out.
 315             macKey = 0 ;
 316             glyph = kMenuF1Glyph + ( key - WXK_F1 ) ;
 317             if ( key >= WXK_F13 )
 318                 glyph += 13 ;
 319             if ( !explicitCommandKey )
 320                 modifiers |= kMenuNoCommandModifier ;
 321           }
 322         else
 323         {
 324             switch( key )
 325             {
 326                 case WXK_BACK :
 327                     macKey = kBackspaceCharCode ;
 328                     glyph = kMenuDeleteLeftGlyph ;
 329                     break ;
 330                 case WXK_TAB :
 331                     macKey = kTabCharCode ;
 332                     glyph = kMenuTabRightGlyph ;
 333                     break ;
 334                 case kEnterCharCode :
 335                     macKey = kEnterCharCode ;
 336                     glyph = kMenuEnterGlyph ;
 337                     break ;
 338                 case WXK_RETURN :
 339                     macKey = kReturnCharCode ;
 340                     glyph = kMenuReturnGlyph ;
 341                     break ;
 342                 case WXK_ESCAPE :
 343                     macKey = kEscapeCharCode ;
 344                     glyph = kMenuEscapeGlyph ;
 345                     break ;
 346                 case WXK_SPACE :
 347                     macKey = ' ' ;
 348                     glyph = kMenuSpaceGlyph ;
 349                     break ;
 350                 case WXK_DELETE :
 351                     macKey = kDeleteCharCode ;
 352                     glyph = kMenuDeleteRightGlyph ;
 353                     break ;
 354                 case WXK_CLEAR :
 355                     macKey = kClearCharCode ;
 356                     glyph = kMenuClearGlyph ;
 357                     break ;
 358                 case WXK_PRIOR : // PAGE UP
 359                     macKey = kPageUpCharCode ;
 360                     glyph = kMenuPageUpGlyph ;
 361                     break ;
 362                 case WXK_NEXT :
 363                     macKey = kPageDownCharCode ;
 364                     glyph = kMenuPageDownGlyph ;
 365                     break ;
 366                 case WXK_LEFT :
 367                     macKey = kLeftArrowCharCode ;
 368                     glyph = kMenuLeftArrowGlyph ;
 369                     break ;
 370                 case WXK_UP :
 371                     macKey = kUpArrowCharCode ;
 372                     glyph = kMenuUpArrowGlyph ;
 373                     break ;
 374                 case WXK_RIGHT :
 375                     macKey = kRightArrowCharCode ;
 376                     glyph = kMenuRightArrowGlyph ;
 377                     break ;
 378                 case WXK_DOWN :
 379                     macKey = kDownArrowCharCode ;
 380                     glyph = kMenuDownArrowGlyph ;
 381                     break ;
 382             }
 383         }
 384
 385         SetItemCmd( menu, item , macKey );
 386         SetMenuItemModifiers(menu, item , modifiers ) ;
 387
 388         if ( glyph )
 389             SetMenuItemKeyGlyph(menu, item , glyph ) ;
 390     }
 391 }
 392
 393 void UMAAppendMenuItem( MenuRef menu , const wxString& title, wxFontEncoding encoding , wxAcceleratorEntry *entry )
 394 {
 395     MacAppendMenu(menu, "\pA");
 396     UMASetMenuItemText(menu, (SInt16) ::CountMenuItems(menu), title , encoding );
 397     UMASetMenuItemShortcut( menu ,  (SInt16) ::CountMenuItems(menu), entry ) ;
 398 }
 399
 400 void UMAInsertMenuItem( MenuRef menu , const wxString& title, wxFontEncoding encoding , MenuItemIndex item , wxAcceleratorEntry *entry )
 401 {
 402     MacInsertMenuItem( menu , "\pA" , item) ;
 403     UMASetMenuItemText(menu, item+1 , title , encoding );
 404     UMASetMenuItemShortcut( menu , item+1 , entry ) ;
 405 }
 406
 407 // quickdraw
 408
 409 #if !TARGET_CARBON
 410
 411 int gPrOpenCounter = 0 ;
 412
 413 OSStatus UMAPrOpen()
 414 {
 415     OSErr err = noErr ;
 416     ++gPrOpenCounter ;
 417     if ( gPrOpenCounter == 1 )
 418     {
 419         PrOpen() ;
 420         err = PrError() ;
 421         wxASSERT( err == noErr ) ;
 422     }
 423     return err ;
 424 }
 425
 426 OSStatus UMAPrClose()
 427 {
 428     OSErr err = noErr ;
 429     wxASSERT( gPrOpenCounter >= 1 ) ;
 430     if ( gPrOpenCounter == 1 )
 431     {
 432         PrClose() ;
 433         err = PrError() ;
 434         wxASSERT( err == noErr ) ;
 435     }
 436     --gPrOpenCounter ;
 437     return err ;
 438 }
 439
 440 pascal QDGlobalsPtr GetQDGlobalsPtr (void) ;
 441 pascal QDGlobalsPtr GetQDGlobalsPtr (void)
 442 {
 443     return QDGlobalsPtr (* (Ptr*) LMGetCurrentA5 ( ) - 0xCA);
 444 }
 445
 446 #endif
 447
 448 void UMAShowWatchCursor()
 449 {
 450     OSErr err = noErr;
 451
 452     CursHandle watchFob = GetCursor (watchCursor);
 453
 454     if (!watchFob)
 455         err = nilHandleErr;
 456     else
 457     {
 458     #if TARGET_CARBON
 459 //        Cursor preservedArrow;
 460 //        GetQDGlobalsArrow (&preservedArrow);
 461 //        SetQDGlobalsArrow (*watchFob);
 462 //        InitCursor ( );
 463 //        SetQDGlobalsArrow (&preservedArrow);
 464         SetCursor (*watchFob);
 465     #else
 466         SetCursor (*watchFob);
 467     #endif
 468     }
 469 }
 470
 471 void            UMAShowArrowCursor()
 472 {
 473 #if TARGET_CARBON
 474     Cursor arrow;
 475     SetCursor (GetQDGlobalsArrow (&arrow));
 476 #else
 477     SetCursor (&(qd.arrow));
 478 #endif
 479 }
 480
 481 // window manager
 482
 483 GrafPtr        UMAGetWindowPort( WindowRef inWindowRef )
 484 {
 485     wxASSERT( inWindowRef != NULL ) ;
 486 #if TARGET_CARBON
 487     return (GrafPtr) GetWindowPort( inWindowRef ) ;
 488 #else
 489     return (GrafPtr) inWindowRef ;
 490 #endif
 491 }
 492
 493 void             UMADisposeWindow( WindowRef inWindowRef )
 494 {
 495     wxASSERT( inWindowRef != NULL ) ;
 496     DisposeWindow( inWindowRef ) ;
 497 }
 498
 499 void UMASetWTitle( WindowRef inWindowRef , const wxString& title , wxFontEncoding encoding)
 500 {
 501 #if TARGET_CARBON
 502     SetWindowTitleWithCFString( inWindowRef , wxMacCFStringHolder(title , encoding) ) ;
 503 #else
 504     Str255 ptitle ;
 505     wxMacStringToPascal( title , ptitle ) ;
 506     SetWTitle( inWindowRef , ptitle ) ;
 507 #endif
 508 }
 509
 510 // appearance additions
 511
 512 void UMASetControlTitle( ControlRef inControl , const wxString& title , wxFontEncoding encoding)
 513 {
 514 #if TARGET_CARBON
 515     SetControlTitleWithCFString( inControl , wxMacCFStringHolder(title , encoding) ) ;
 516 #else
 517     Str255 ptitle ;
 518     wxMacStringToPascal( title , ptitle ) ;
 519     SetControlTitle( inControl , ptitle ) ;
 520 #endif
 521 }
 522
 523 void UMAActivateControl( ControlRef inControl )
 524 {
 525 #if !TARGET_API_MAC_OSX
 526     // we have to add the control after again to the update rgn
 527     // otherwise updates get lost
 528     if ( !IsControlActive( inControl ) )
 529     {
 530         bool visible = IsControlVisible( inControl ) ;
 531         if ( visible )
 532             SetControlVisibility( inControl , false , false ) ;
 533 #endif
 534         ::ActivateControl( inControl ) ;
 535 #if !TARGET_API_MAC_OSX
 536         if ( visible ) {
 537             SetControlVisibility( inControl , true , false ) ;
 538
 539             Rect ctrlBounds ;
 540             InvalWindowRect(GetControlOwner(inControl),UMAGetControlBoundsInWindowCoords(inControl,&ctrlBounds) ) ;
 541         }
 542     }
 543 #endif
 544 }
 545
 546 void UMADrawControl( ControlRef inControl )
 547 {
 548 #if TARGET_API_MAC_CARBON
 549     ::Draw1Control( inControl );
 550 #else
 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 #endif
 562 }
 563
 564 void UMAMoveControl( ControlRef inControl , short x , short y )
 565 {
 566 #if !TARGET_API_MAC_OSX
 567     bool visible = IsControlVisible( inControl ) ;
 568     if ( visible ) {
 569         SetControlVisibility( inControl , false , false ) ;
 570         Rect ctrlBounds ;
 571         InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
 572     }
 573 #endif
 574     ::MoveControl( inControl , x , y ) ;
 575 #if !TARGET_API_MAC_OSX
 576     if ( visible ) {
 577         SetControlVisibility( inControl , true , false ) ;
 578         Rect ctrlBounds ;
 579         InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
 580     }
 581 #endif
 582 }
 583
 584 void UMASizeControl( ControlRef inControl , short x , short y )
 585 {
 586 #if !TARGET_API_MAC_OSX
 587     bool visible = IsControlVisible( inControl ) ;
 588     if ( visible ) {
 589         SetControlVisibility( inControl , false , false ) ;
 590         Rect ctrlBounds ;
 591         InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
 592     }
 593 #endif
 594     ::SizeControl( inControl , x , y ) ;
 595 #if !TARGET_API_MAC_OSX
 596     if ( visible ) {
 597         SetControlVisibility( inControl , true , false ) ;
 598         Rect ctrlBounds ;
 599         InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
 600     }
 601 #endif
 602 }
 603
 604 void UMADeactivateControl( ControlRef inControl )
 605 {
 606 #if !TARGET_API_MAC_OSX
 607     // we have to add the control after again to the update rgn
 608     // otherwise updates get lost
 609     bool visible = IsControlVisible( inControl ) ;
 610     if ( visible )
 611         SetControlVisibility( inControl , false , false ) ;
 612 #endif
 613     ::DeactivateControl( inControl ) ;
 614 #if !TARGET_API_MAC_OSX
 615     if ( visible ) {
 616         SetControlVisibility( inControl , true , false ) ;
 617         Rect ctrlBounds ;
 618         InvalWindowRect(GetControlOwner(inControl),UMAGetControlBoundsInWindowCoords(inControl,&ctrlBounds) ) ;
 619     }
 620 #endif
 621 }
 622 // shows the control and adds the region to the update region
 623 void UMAShowControl                        (ControlRef             inControl)
 624 {
 625     SetControlVisibility( inControl , true , false ) ;
 626     Rect ctrlBounds ;
 627     InvalWindowRect(GetControlOwner(inControl),UMAGetControlBoundsInWindowCoords(inControl,&ctrlBounds) ) ;
 628 }
 629
 630 // hides the control and adds the region to the update region
 631 void UMAHideControl                        (ControlRef             inControl)
 632 {
 633     SetControlVisibility( inControl , false , false ) ;
 634     Rect ctrlBounds ;
 635     InvalWindowRect(GetControlOwner(inControl),UMAGetControlBoundsInWindowCoords(inControl,&ctrlBounds) ) ;
 636 }
 637 // keyboard focus
 638 OSErr UMASetKeyboardFocus                (WindowPtr                 inWindow,
 639                                  ControlRef             inControl,
 640                                  ControlFocusPart         inPart)
 641 {
 642     OSErr err = noErr;
 643     GrafPtr port ;
 644     GetPort( &port ) ;
 645
 646     SetPortWindowPort( inWindow ) ;
 647
 648     err = SetKeyboardFocus( inWindow , inControl , inPart ) ;
 649     SetPort( port ) ;
 650     return err ;
 651 }
 652
 653 // events
 654 void UMAUpdateControls( WindowPtr inWindow , RgnHandle inRgn )
 655 {
 656     wxMacPortStateHelper help( (GrafPtr) GetWindowPort( (WindowRef) inWindow) ) ;
 657     RgnHandle updateRgn = NewRgn() ;
 658     GetWindowUpdateRgn( inWindow , updateRgn ) ;
 659
 660     Point zero = { 0 , 0 } ;
 661     LocalToGlobal( &zero ) ;
 662     OffsetRgn( updateRgn , -zero.h , -zero.v ) ;
 663
 664     UpdateControls( inWindow , inRgn ) ;
 665     InvalWindowRgn( inWindow, updateRgn) ;
 666     DisposeRgn( updateRgn ) ;
 667 }
 668
 669 bool UMAIsWindowFloating( WindowRef inWindow )
 670 {
 671     WindowClass cl ;
 672
 673     GetWindowClass( inWindow , &cl ) ;
 674     return cl == kFloatingWindowClass ;
 675 }
 676
 677 bool UMAIsWindowModal( WindowRef inWindow )
 678 {
 679     WindowClass cl ;
 680
 681     GetWindowClass( inWindow , &cl ) ;
 682     return cl < kFloatingWindowClass ;
 683 }
 684
 685 // others
 686
 687 void UMAHighlightAndActivateWindow( WindowRef inWindowRef , bool inActivate )
 688 {
 689     if ( inWindowRef )
 690     {
 691 //        bool isHighlighted = IsWindowHighlited( inWindowRef ) ;
 692 //        if ( inActivate != isHightlited )
 693         GrafPtr port ;
 694         GetPort( &port ) ;
 695         SetPortWindowPort( inWindowRef ) ;
 696         HiliteWindow( inWindowRef , inActivate ) ;
 697         ControlRef control = NULL ;
 698         ::GetRootControl( inWindowRef , & control ) ;
 699         if ( control )
 700         {
 701             if ( inActivate )
 702                 UMAActivateControl( control ) ;
 703             else
 704                 UMADeactivateControl( control ) ;
 705         }
 706         SetPort( port ) ;
 707     }
 708 }
 709
 710 OSStatus UMADrawThemePlacard( const Rect *inRect , ThemeDrawState inState )
 711 {
 712     return ::DrawThemePlacard( inRect , inState ) ;
 713 }
 714
 715 #if !TARGET_CARBON
 716 static OSStatus helpMenuStatus = noErr ;
 717 static MenuItemIndex firstCustomItemIndex = 0 ;
 718 #endif
 719
 720 OSStatus UMAGetHelpMenu(
 721   MenuRef *        outHelpMenu,
 722   MenuItemIndex *  outFirstCustomItemIndex)
 723 {
 724 #if TARGET_CARBON
 725     return HMGetHelpMenu( outHelpMenu , outFirstCustomItemIndex ) ;
 726 #else
 727     MenuRef helpMenuHandle ;
 728     helpMenuStatus = HMGetHelpMenuHandle( &helpMenuHandle ) ;
 729     if ( firstCustomItemIndex == 0 && helpMenuStatus == noErr )
 730     {
 731         firstCustomItemIndex = CountMenuItems( helpMenuHandle ) + 1 ;
 732     }
 733     if ( outFirstCustomItemIndex )
 734     {
 735         *outFirstCustomItemIndex = firstCustomItemIndex ;
 736     }
 737     *outHelpMenu = helpMenuHandle ;
 738     return helpMenuStatus ;
 739 #endif
 740 }
 741
 742 wxMacPortStateHelper::wxMacPortStateHelper( GrafPtr newport)
 743 {
 744     m_clip = NULL ;
 745     Setup( newport ) ;
 746 }
 747
 748 wxMacPortStateHelper::wxMacPortStateHelper()
 749 {
 750     m_clip = NULL ;
 751 }
 752
 753 void wxMacPortStateHelper::Setup( GrafPtr newport )
 754 {
 755     GetPort( &m_oldPort ) ;
 756     SetPort( newport ) ;
 757     SetOrigin(0,0);
 758     wxASSERT_MSG( m_clip == NULL , wxT("Cannot call setup twice") ) ;
 759     m_clip = NewRgn() ;
 760     GetClip( m_clip );
 761     m_textFont = GetPortTextFont( (CGrafPtr) newport);
 762     m_textSize = GetPortTextSize( (CGrafPtr) newport);
 763     m_textStyle = GetPortTextFace( (CGrafPtr) newport);
 764     m_textMode = GetPortTextMode( (CGrafPtr) newport);
 765     GetThemeDrawingState( &m_drawingState ) ;
 766     m_currentPort = newport ;
 767 }
 768 void wxMacPortStateHelper::Clear()
 769 {
 770     if ( m_clip )
 771     {
 772         DisposeRgn( m_clip ) ;
 773         DisposeThemeDrawingState( m_drawingState ) ;
 774         m_clip = NULL ;
 775     }
 776 }
 777
 778 wxMacPortStateHelper::~wxMacPortStateHelper()
 779 {
 780     if ( m_clip )
 781     {
 782         SetPort( m_currentPort ) ;
 783         SetClip( m_clip ) ;
 784         DisposeRgn( m_clip ) ;
 785         TextFont( m_textFont );
 786         TextSize( m_textSize );
 787         TextFace( m_textStyle );
 788         TextMode( m_textMode );
 789         SetThemeDrawingState( m_drawingState , true ) ;
 790         SetPort( m_oldPort ) ;
 791     }
 792 }
 793
 794 OSStatus UMAPutScrap( Size size , OSType type , void *data )
 795 {
 796     OSStatus err = noErr ;
 797 #if !TARGET_CARBON
 798     err = PutScrap( size , type , data ) ;
 799 #else
 800     ScrapRef    scrap;
 801     err = GetCurrentScrap (&scrap);
 802     if ( !err )
 803     {
 804         err = PutScrapFlavor (scrap, type , 0, size, data);
 805     }
 806 #endif
 807     return err ;
 808 }
 809
 810 Rect* UMAGetControlBoundsInWindowCoords(ControlRef theControl, Rect *bounds)
 811 {
 812     wxWindow* win = wxFindControlFromMacControl( theControl ) ;
 813
 814     GetControlBounds( theControl , bounds ) ;
 815 #if TARGET_API_MAC_OSX
 816     if ( win != NULL && win->MacGetTopLevelWindow() != NULL )
 817     {
 818         int x , y ;
 819         x = 0 ;
 820         y = 0 ;
 821
 822         win->GetParent()->MacWindowToRootWindow( &x , & y ) ;
 823         bounds->left += x ;
 824         bounds->right += x ;
 825         bounds->top += y ;
 826         bounds->bottom += y ;
 827     }
 828 #endif
 829     return bounds ;
 830 }
 831
 832
 833 #endif  // wxUSE_GUI
 834
 835 #if wxUSE_BASE
 836
 837 static bool sUMASystemInitialized = false ;
 838
 839 bool UMASystemIsInitialized()
 840 {
 841     return sUMASystemInitialized ;
 842 }
 843
 844 void UMASetSystemIsInitialized(bool val)
 845 {
 846     sUMASystemInitialized = val;
 847 }
 848
 849
 850 #endif // wxUSE_BASE