src/mac/carbon/uma.cpp

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