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