src/mac/toplevel.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        mac/toplevel.cpp
   3 // Purpose:     implements wxTopLevelWindow for MSW
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     24.09.01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
   9 // License:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "toplevel.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/app.h"
  33     #include "wx/toplevel.h"
  34     #include "wx/frame.h"
  35     #include "wx/string.h"
  36     #include "wx/log.h"
  37     #include "wx/intl.h"
  38 #endif //WX_PRECOMP
  39
  40 #include "wx/mac/uma.h"
  41 #include "wx/mac/aga.h"
  42 #include "wx/app.h"
  43 #include "wx/tooltip.h"
  44 #include "wx/dnd.h"
  45
  46 #include "ToolUtils.h"
  47
  48
  49 #define wxMAC_DEBUG_REDRAW 0
  50 #ifndef wxMAC_DEBUG_REDRAW
  51 #define wxMAC_DEBUG_REDRAW 0
  52 #endif
  53
  54 // ----------------------------------------------------------------------------
  55 // globals
  56 // ----------------------------------------------------------------------------
  57
  58 // list of all frames and modeless dialogs
  59 wxWindowList       wxModelessWindows;
  60
  61 // double click testing
  62 static   Point     gs_lastWhere;
  63 static   long      gs_lastWhen = 0;
  64
  65
  66 #if TARGET_CARBON
  67 static pascal long wxShapedMacWindowDef(short varCode, WindowRef window, SInt16 message, SInt32 param);
  68 #endif
  69
  70 // ============================================================================
  71 // wxTopLevelWindowMac implementation
  72 // ============================================================================
  73
  74 // ---------------------------------------------------------------------------
  75 // Carbon Events
  76 // ---------------------------------------------------------------------------
  77
  78 #if TARGET_CARBON
  79
  80 extern long wxMacTranslateKey(unsigned char key, unsigned char code) ;
  81
  82 static const EventTypeSpec eventList[] =
  83 {
  84     { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
  85
  86     { kEventClassKeyboard, kEventRawKeyDown } ,
  87     { kEventClassKeyboard, kEventRawKeyRepeat } ,
  88     { kEventClassKeyboard, kEventRawKeyUp } ,
  89     { kEventClassKeyboard, kEventRawKeyModifiersChanged } ,
  90
  91     { kEventClassWindow , kEventWindowUpdate } ,
  92     { kEventClassWindow , kEventWindowActivated } ,
  93     { kEventClassWindow , kEventWindowDeactivated } ,
  94     { kEventClassWindow , kEventWindowBoundsChanging } ,
  95     { kEventClassWindow , kEventWindowBoundsChanged } ,
  96     { kEventClassWindow , kEventWindowClose } ,
  97
  98     { kEventClassMouse , kEventMouseDown } ,
  99     { kEventClassMouse , kEventMouseUp } ,
 100     { kEventClassMouse , kEventMouseMoved } ,
 101     { kEventClassMouse , kEventMouseDragged } ,
 102
 103 } ;
 104
 105 static pascal OSStatus TextInputEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 106 {
 107     OSStatus result = eventNotHandledErr ;
 108
 109     wxWindow* focus = wxWindow::FindFocus() ;
 110     char charCode ;
 111     UInt32 keyCode ;
 112     UInt32 modifiers ;
 113     Point point ;
 114     UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
 115
 116     EventRef rawEvent ;
 117
 118     GetEventParameter( event , kEventParamTextInputSendKeyboardEvent ,typeEventRef,NULL,sizeof(rawEvent),NULL,&rawEvent ) ;
 119
 120     GetEventParameter( rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL,sizeof(char), NULL,&charCode );
 121     GetEventParameter( rawEvent, kEventParamKeyCode, typeUInt32, NULL,  sizeof(UInt32), NULL, &keyCode );
 122        GetEventParameter( rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
 123     GetEventParameter( rawEvent, kEventParamMouseLocation, typeQDPoint, NULL,
 124         sizeof( Point ), NULL, &point );
 125
 126     UInt32 message = (keyCode << 8) + charCode;
 127
 128     switch ( GetEventKind( event ) )
 129     {
 130         case kEventTextInputUnicodeForKeyEvent :
 131             if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
 132                 focus , message , modifiers , when , point.h , point.v ) )
 133             {
 134                 result = noErr ;
 135             }
 136             break ;
 137     }
 138
 139     return result ;
 140 }
 141
 142 static pascal OSStatus KeyboardEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 143 {
 144     OSStatus result = eventNotHandledErr ;
 145
 146     wxWindow* focus = wxWindow::FindFocus() ;
 147     char charCode ;
 148     UInt32 keyCode ;
 149     UInt32 modifiers ;
 150     Point point ;
 151     UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
 152
 153     GetEventParameter( event, kEventParamKeyMacCharCodes, typeChar, NULL,sizeof(char), NULL,&charCode );
 154     GetEventParameter( event, kEventParamKeyCode, typeUInt32, NULL,  sizeof(UInt32), NULL, &keyCode );
 155        GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
 156     GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
 157         sizeof( Point ), NULL, &point );
 158
 159     UInt32 message = (keyCode << 8) + charCode;
 160     switch( GetEventKind( event ) )
 161     {
 162         case kEventRawKeyRepeat :
 163         case kEventRawKeyDown :
 164             if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
 165                 focus , message , modifiers , when , point.h , point.v ) )
 166             {
 167                 result = noErr ;
 168             }
 169             break ;
 170         case kEventRawKeyUp :
 171             if ( (focus != NULL) && wxTheApp->MacSendKeyUpEvent(
 172                 focus , message , modifiers , when , point.h , point.v ) )
 173             {
 174                 result = noErr ;
 175             }
 176             break ;
 177         case kEventRawKeyModifiersChanged :
 178             {
 179                 wxKeyEvent event(wxEVT_KEY_DOWN);
 180
 181                 event.m_shiftDown = modifiers & shiftKey;
 182                 event.m_controlDown = modifiers & controlKey;
 183                 event.m_altDown = modifiers & optionKey;
 184                 event.m_metaDown = modifiers & cmdKey;
 185
 186                 event.m_x = point.h;
 187                 event.m_y = point.v;
 188                 event.m_timeStamp = when;
 189                 wxWindow* focus = wxWindow::FindFocus() ;
 190                 event.SetEventObject(focus);
 191
 192                 if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & controlKey )
 193                 {
 194                     event.m_keyCode = WXK_CONTROL ;
 195                     event.SetEventType( ( modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 196                     focus->GetEventHandler()->ProcessEvent( event ) ;
 197                 }
 198                 if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & shiftKey )
 199                 {
 200                     event.m_keyCode = WXK_SHIFT ;
 201                     event.SetEventType( ( modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 202                     focus->GetEventHandler()->ProcessEvent( event ) ;
 203                 }
 204                 if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & optionKey )
 205                 {
 206                     event.m_keyCode = WXK_ALT ;
 207                     event.SetEventType( ( modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 208                     focus->GetEventHandler()->ProcessEvent( event ) ;
 209                 }
 210                 wxTheApp->s_lastModifiers = modifiers ;
 211             }
 212              break ;
 213     }
 214
 215     return result ;
 216 }
 217
 218 static pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 219 {
 220     OSStatus result = eventNotHandledErr ;
 221
 222     wxTopLevelWindowMac* toplevelWindow = (wxTopLevelWindowMac*) data ;
 223     Point point ;
 224     UInt32 modifiers = 0;
 225     EventMouseButton button = 0 ;
 226     UInt32 click = 0 ;
 227
 228     GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
 229         sizeof( Point ), NULL, &point );
 230     GetEventParameter( event, kEventParamKeyModifiers, typeUInt32, NULL,
 231         sizeof( UInt32 ), NULL, &modifiers );
 232     GetEventParameter( event, kEventParamMouseButton, typeMouseButton, NULL,
 233         sizeof( EventMouseButton ), NULL, &button );
 234     GetEventParameter( event, kEventParamClickCount, typeUInt32, NULL,
 235         sizeof( UInt32 ), NULL, &click );
 236
 237     if ( button == 0 || GetEventKind( event ) == kEventMouseUp )
 238         modifiers += btnState ;
 239
 240     WindowRef window ;
 241     short windowPart = ::FindWindow(point, &window);
 242
 243     if ( IsWindowActive(window) && windowPart == inContent )
 244     {
 245         switch ( GetEventKind( event ) )
 246         {
 247             case kEventMouseDown :
 248                 toplevelWindow->MacFireMouseEvent( mouseDown , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
 249                 result = noErr ;
 250                 break ;
 251             case kEventMouseUp :
 252                 toplevelWindow->MacFireMouseEvent( mouseUp , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
 253                 result = noErr ;
 254                 break ;
 255             case kEventMouseMoved :
 256                 toplevelWindow->MacFireMouseEvent( nullEvent , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
 257                 result = noErr ;
 258                 break ;
 259             case kEventMouseDragged :
 260                 toplevelWindow->MacFireMouseEvent( nullEvent , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
 261                 result = noErr ;
 262                 break ;
 263             default :
 264                 break ;
 265         }
 266     }
 267
 268     return result ;
 269
 270
 271 }
 272 static pascal OSStatus WindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 273 {
 274     OSStatus result = eventNotHandledErr ;
 275     OSStatus err = noErr ;
 276
 277     UInt32        attributes;
 278     WindowRef windowRef ;
 279     wxTopLevelWindowMac* toplevelWindow = (wxTopLevelWindowMac*) data ;
 280
 281     GetEventParameter( event, kEventParamDirectObject, typeWindowRef, NULL,
 282         sizeof( WindowRef ), NULL, &windowRef );
 283
 284     switch( GetEventKind( event ) )
 285     {
 286         case kEventWindowUpdate :
 287             if ( !wxPendingDelete.Member(toplevelWindow) )
 288                 toplevelWindow->MacUpdate( EventTimeToTicks( GetEventTime( event ) ) ) ;
 289             result = noErr ;
 290             break ;
 291         case kEventWindowActivated :
 292                 toplevelWindow->MacActivate( EventTimeToTicks( GetEventTime( event ) ) , true) ;
 293             result = noErr ;
 294             break ;
 295         case kEventWindowDeactivated :
 296                 toplevelWindow->MacActivate( EventTimeToTicks( GetEventTime( event ) ) , false) ;
 297             result = noErr ;
 298             break ;
 299         case kEventWindowClose :
 300                 toplevelWindow->Close() ;
 301             result = noErr ;
 302             break ;
 303         case kEventWindowBoundsChanged :
 304             err = GetEventParameter( event, kEventParamAttributes, typeUInt32,
 305                         NULL, sizeof( UInt32 ), NULL, &attributes );
 306             if ( err == noErr )
 307             {
 308                 Rect newContentRect ;
 309
 310                 GetEventParameter( event, kEventParamCurrentBounds, typeQDRectangle, NULL,
 311                     sizeof( newContentRect ), NULL, &newContentRect );
 312
 313                 toplevelWindow->SetSize( newContentRect.left , newContentRect.top ,
 314                     newContentRect.right - newContentRect.left ,
 315                     newContentRect.bottom - newContentRect.top, wxSIZE_USE_EXISTING);
 316
 317                 result = noErr;
 318             }
 319             break ;
 320         default :
 321             break ;
 322     }
 323     return result ;
 324 }
 325
 326 pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 327 {
 328     OSStatus result = eventNotHandledErr ;
 329
 330     switch ( GetEventClass( event ) )
 331     {
 332         case kEventClassKeyboard :
 333             result = KeyboardEventHandler( handler, event , data ) ;
 334             break ;
 335         case kEventClassTextInput :
 336             result = TextInputEventHandler( handler, event , data ) ;
 337             break ;
 338         case kEventClassWindow :
 339             result = WindowEventHandler( handler, event , data ) ;
 340             break ;
 341         case kEventClassMouse :
 342             result = MouseEventHandler( handler, event , data ) ;
 343             break ;
 344         default :
 345             break ;
 346     }
 347     return result ;
 348 }
 349
 350 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacWindowEventHandler )
 351
 352 // Patch 531199 defined a window event handler, as follows.
 353 // TODO: merge the moving/sizing event handling with the event
 354 // handler above.
 355 #if 0
 356 static pascal OSStatus
 357 WindowHandler( EventHandlerCallRef inHandler, EventRef inEvent, void* userData )
 358 {
 359     Rect                bounds;
 360     SInt16              height, width;
 361     UInt32              attributes;
 362     OSStatus    result = eventNotHandledErr;
 363
 364     GetEventParameter( inEvent, kEventParamAttributes, typeUInt32, NULL, sizeof( UInt32 ), NULL, &attributes );
 365
 366     if ((attributes & (kWindowBoundsChangeSizeChanged | kWindowBoundsChangeOriginChanged)) != 0)
 367     {
 368         // Extract the current bounds. This is the paramter you get to modify to
 369         // alter the window position or size during a window resizing.
 370         GetEventParameter( inEvent, kEventParamCurrentBounds, typeQDRectangle, NULL, sizeof( bounds ), NULL, &bounds );
 371
 372         wxRect rect;
 373         rect.SetLeft(bounds.left);
 374         rect.SetTop(bounds.top);
 375         rect.SetRight(bounds.right);
 376         rect.SetBottom(bounds.bottom);
 377
 378         bool rc;
 379         wxWindowMac *pWindow = (wxWindowMac*)userData;
 380         if ((attributes & kWindowBoundsChangeSizeChanged) != 0) {
 381             wxSizeEvent event(rect, pWindow->GetId());
 382             event.SetEventObject(pWindow);
 383             rc = pWindow->GetEventHandler()->ProcessEvent(event);
 384             rect = event.GetRect();
 385         }
 386         else {
 387             wxMoveEvent event(rect, pWindow->GetId());
 388             event.SetEventObject(pWindow);
 389             rc = pWindow->GetEventHandler()->ProcessEvent(event);
 390             rect = event.GetRect();
 391         }
 392
 393         if (rc) {
 394             bounds.left = rect.GetLeft();
 395             bounds.top = rect.GetTop();
 396             bounds.right = rect.GetRight();
 397             bounds.bottom = rect.GetBottom();
 398         }
 399
 400         // Set the current bounds parameter to our adjusted bounds. Return
 401         // noErr to indicate we handled this event.
 402         SetEventParameter( inEvent, kEventParamCurrentBounds, typeQDRectangle, sizeof( bounds ), &bounds );
 403         result = noErr;
 404     }
 405     return result;
 406 }
 407 #endif
 408     // WindowHandler
 409
 410 #endif
 411
 412 // ---------------------------------------------------------------------------
 413 // wxWindowMac utility functions
 414 // ---------------------------------------------------------------------------
 415
 416 // Find an item given the Macintosh Window Reference
 417
 418 wxList *wxWinMacWindowList = NULL;
 419 wxTopLevelWindowMac *wxFindWinFromMacWindow(WXWindow inWindowRef)
 420 {
 421     wxNode *node = wxWinMacWindowList->Find((long)inWindowRef);
 422     if (!node)
 423         return NULL;
 424     return (wxTopLevelWindowMac *)node->GetData();
 425 }
 426
 427 void wxAssociateWinWithMacWindow(WXWindow inWindowRef, wxTopLevelWindowMac *win)
 428 {
 429     // adding NULL WindowRef is (first) surely a result of an error and
 430     // (secondly) breaks menu command processing
 431     wxCHECK_RET( inWindowRef != (WindowRef) NULL, wxT("attempt to add a NULL WindowRef to window list") );
 432
 433     if ( !wxWinMacWindowList->Find((long)inWindowRef) )
 434         wxWinMacWindowList->Append((long)inWindowRef, win);
 435 }
 436
 437 void wxRemoveMacWindowAssociation(wxTopLevelWindowMac *win)
 438 {
 439     wxWinMacWindowList->DeleteObject(win);
 440 }
 441
 442
 443 // ----------------------------------------------------------------------------
 444 // wxTopLevelWindowMac creation
 445 // ----------------------------------------------------------------------------
 446
 447 WXHWND wxTopLevelWindowMac::s_macWindowInUpdate = NULL;
 448
 449 void wxTopLevelWindowMac::Init()
 450 {
 451     m_iconized =
 452     m_maximizeOnShow = FALSE;
 453     m_macNoEraseUpdateRgn = NewRgn() ;
 454     m_macNeedsErasing = false ;
 455     m_macWindow = NULL ;
 456 #if TARGET_CARBON
 457     m_macEventHandler = NULL ;
 458  #endif
 459 }
 460
 461 class wxMacDeferredWindowDeleter : public wxObject
 462 {
 463 public :
 464     wxMacDeferredWindowDeleter( WindowRef windowRef )
 465     {
 466         m_macWindow = windowRef ;
 467     }
 468     virtual ~wxMacDeferredWindowDeleter()
 469     {
 470         UMADisposeWindow( (WindowRef) m_macWindow ) ;
 471     }
 472  protected :
 473     WindowRef m_macWindow ;
 474 } ;
 475
 476 bool wxTopLevelWindowMac::Create(wxWindow *parent,
 477                                  wxWindowID id,
 478                                  const wxString& title,
 479                                  const wxPoint& pos,
 480                                  const wxSize& size,
 481                                  long style,
 482                                  const wxString& name)
 483 {
 484     // init our fields
 485     Init();
 486
 487     m_windowStyle = style;
 488
 489     SetName(name);
 490
 491     m_windowId = id == -1 ? NewControlId() : id;
 492
 493     wxTopLevelWindows.Append(this);
 494
 495     if ( parent )
 496         parent->AddChild(this);
 497
 498     return TRUE;
 499 }
 500
 501 wxTopLevelWindowMac::~wxTopLevelWindowMac()
 502 {
 503     if ( m_macWindow )
 504     {
 505         wxToolTip::NotifyWindowDelete(m_macWindow) ;
 506         wxPendingDelete.Append( new wxMacDeferredWindowDeleter( (WindowRef) m_macWindow ) ) ;
 507     }
 508
 509 #if TARGET_CARBON
 510     if ( m_macEventHandler )
 511     {
 512         ::RemoveEventHandler((EventHandlerRef) m_macEventHandler);
 513         m_macEventHandler = NULL ;
 514     }
 515 #endif
 516
 517     wxRemoveMacWindowAssociation( this ) ;
 518
 519     if ( wxModelessWindows.Find(this) )
 520         wxModelessWindows.DeleteObject(this);
 521
 522     DisposeRgn( (RgnHandle) m_macNoEraseUpdateRgn ) ;
 523 }
 524
 525
 526 // ----------------------------------------------------------------------------
 527 // wxTopLevelWindowMac maximize/minimize
 528 // ----------------------------------------------------------------------------
 529
 530 void wxTopLevelWindowMac::Maximize(bool maximize)
 531 {
 532     // not available on mac
 533 }
 534
 535 bool wxTopLevelWindowMac::IsMaximized() const
 536 {
 537     return false ;
 538 }
 539
 540 void wxTopLevelWindowMac::Iconize(bool iconize)
 541 {
 542     // not available on mac
 543 }
 544
 545 bool wxTopLevelWindowMac::IsIconized() const
 546 {
 547     // mac dialogs cannot be iconized
 548     return FALSE;
 549 }
 550
 551 void wxTopLevelWindowMac::Restore()
 552 {
 553     // not available on mac
 554 }
 555
 556 // ----------------------------------------------------------------------------
 557 // wxTopLevelWindowMac misc
 558 // ----------------------------------------------------------------------------
 559
 560 void wxTopLevelWindowMac::SetIcon(const wxIcon& icon)
 561 {
 562     // this sets m_icon
 563     wxTopLevelWindowBase::SetIcon(icon);
 564 }
 565
 566 void  wxTopLevelWindowMac::MacCreateRealWindow( const wxString& title,
 567            const wxPoint& pos,
 568            const wxSize& size,
 569            long style,
 570            const wxString& name )
 571 {
 572     SetName(name);
 573     m_windowStyle = style;
 574     m_isShown = FALSE;
 575
 576     // create frame.
 577
 578     Rect theBoundsRect;
 579
 580     m_x = (int)pos.x;
 581     m_y = (int)pos.y;
 582     if ( m_y < 50 )
 583         m_y = 50 ;
 584     if ( m_x < 20 )
 585         m_x = 20 ;
 586
 587     m_width = size.x;
 588     if (m_width == -1)
 589         m_width = 20;
 590     m_height = size.y;
 591     if (m_height == -1)
 592         m_height = 20;
 593
 594     ::SetRect(&theBoundsRect, m_x, m_y , m_x + m_width, m_y + m_height);
 595
 596     // translate the window attributes in the appropriate window class and attributes
 597
 598     WindowClass wclass = 0;
 599     WindowAttributes attr = kWindowNoAttributes ;
 600
 601     if ( HasFlag( wxFRAME_TOOL_WINDOW) )
 602     {
 603         if (
 604             HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) ||
 605             HasFlag( wxSYSTEM_MENU ) || HasFlag( wxCAPTION ) ||
 606             HasFlag(wxTINY_CAPTION_HORIZ) ||  HasFlag(wxTINY_CAPTION_VERT)
 607             )
 608         {
 609             wclass = kFloatingWindowClass ;
 610             if ( HasFlag(wxTINY_CAPTION_VERT) )
 611             {
 612                 attr |= kWindowSideTitlebarAttribute ;
 613             }
 614         }
 615         else
 616         {
 617 #if TARGET_CARBON
 618             wclass = kPlainWindowClass ;
 619 #else
 620             wclass = kFloatingWindowClass ;
 621 #endif
 622         }
 623     }
 624     else if ( HasFlag( wxCAPTION ) )
 625     {
 626         wclass = kDocumentWindowClass ;
 627     }
 628     else
 629     {
 630         if ( HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) ||
 631             HasFlag( wxSYSTEM_MENU ) )
 632         {
 633             wclass = kDocumentWindowClass ;
 634         }
 635         else
 636         {
 637 #if TARGET_CARBON
 638             wclass = kPlainWindowClass ;
 639 #else
 640             wclass = kModalWindowClass ;
 641 #endif
 642         }
 643     }
 644
 645     if ( HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) )
 646     {
 647         attr |= kWindowFullZoomAttribute ;
 648         attr |= kWindowCollapseBoxAttribute ;
 649     }
 650     if ( HasFlag( wxRESIZE_BORDER ) )
 651     {
 652         attr |= kWindowResizableAttribute ;
 653     }
 654     if ( HasFlag( wxSYSTEM_MENU ) )
 655     {
 656         attr |= kWindowCloseBoxAttribute ;
 657     }
 658
 659 #if TARGET_CARBON
 660 #if 0 //  having problems right now with that
 661     if (HasFlag(wxSTAY_ON_TOP))
 662         wclass = kUtilityWindowClass;
 663 #endif
 664 #endif
 665
 666 #if TARGET_CARBON
 667     if ( HasFlag(wxFRAME_SHAPED) )
 668     {
 669         WindowDefSpec customWindowDefSpec;
 670         customWindowDefSpec.defType = kWindowDefProcPtr;
 671         customWindowDefSpec.u.defProc = NewWindowDefUPP(wxShapedMacWindowDef);
 672
 673         ::CreateCustomWindow( &customWindowDefSpec, wclass,
 674                               attr, &theBoundsRect,
 675                               (WindowRef*) &m_macWindow);
 676     }
 677     else
 678 #endif
 679     {
 680         ::CreateNewWindow( wclass , attr , &theBoundsRect , (WindowRef*)&m_macWindow ) ;
 681     }
 682
 683     wxAssociateWinWithMacWindow( m_macWindow , this ) ;
 684     UMASetWTitle( (WindowRef)m_macWindow , title ) ;
 685     ::CreateRootControl( (WindowRef)m_macWindow , (ControlHandle*)&m_macRootControl ) ;
 686 #if TARGET_CARBON
 687     InstallStandardEventHandler( GetWindowEventTarget(MAC_WXHWND(m_macWindow)) ) ;
 688     InstallWindowEventHandler(MAC_WXHWND(m_macWindow), GetwxMacWindowEventHandlerUPP(),
 689         GetEventTypeCount(eventList), eventList, this, &((EventHandlerRef)m_macEventHandler));
 690
 691     // Patch 531199 also defined a window event handler, as follows:
 692 #if 0
 693     // install a window event handler to send wxEVT_MOVING and wxEVT_SIZING events
 694     EventTypeSpec events[] = { { kEventClassWindow, kEventWindowBoundsChanging } };
 695     EventHandlerUPP     handlerProc = NewEventHandlerUPP( WindowHandler );
 696     EventHandlerRef eventHandlerRef;
 697     InstallWindowEventHandler( m_macWindowData->m_macWindow, handlerProc, GetEventTypeCount(events),
 698         events, (void*)this, &eventHandlerRef);
 699 #endif
 700
 701 #endif
 702     m_macFocus = NULL ;
 703
 704
 705 #if TARGET_CARBON
 706     if ( HasFlag(wxFRAME_SHAPED) )
 707     {
 708         // default shape matches the window size
 709         wxRegion rgn(0, 0, m_width, m_height);
 710         SetShape(rgn);
 711     }
 712 #endif
 713 }
 714
 715 void wxTopLevelWindowMac::MacGetPortParams(WXPOINTPTR localOrigin, WXRECTPTR clipRect, WXHWND *window  , wxWindowMac** rootwin)
 716 {
 717     ((Point*)localOrigin)->h = 0;
 718     ((Point*)localOrigin)->v = 0;
 719     ((Rect*)clipRect)->left = 0;
 720     ((Rect*)clipRect)->top = 0;
 721     ((Rect*)clipRect)->right = m_width;
 722     ((Rect*)clipRect)->bottom = m_height;
 723     *window = m_macWindow ;
 724     *rootwin = this ;
 725 }
 726
 727 void wxTopLevelWindowMac::Clear()
 728 {
 729     wxWindow::Clear() ;
 730 }
 731
 732 WXWidget wxTopLevelWindowMac::MacGetContainerForEmbedding()
 733 {
 734     return m_macRootControl ;
 735 }
 736
 737
 738 void wxTopLevelWindowMac::MacUpdate( long timestamp)
 739 {
 740     wxMacPortStateHelper help( (GrafPtr) GetWindowPort( (WindowRef) m_macWindow) ) ;
 741
 742     RgnHandle       visRgn = NewRgn() ;
 743     GetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), visRgn );
 744     BeginUpdate( (WindowRef)m_macWindow ) ;
 745
 746     RgnHandle       updateRgn = NewRgn();
 747     RgnHandle       diffRgn = NewRgn() ;
 748
 749     if ( updateRgn && diffRgn )
 750     {
 751 #if 1
 752         // macos internal control redraws clean up areas we'd like to redraw ourselves
 753         // therefore we pick the boundary rect and make sure we can redraw it
 754         // this has to be intersected by the visRgn in order to avoid drawing over its own
 755         // boundaries
 756         RgnHandle trueUpdateRgn = NewRgn() ;
 757         Rect trueUpdateRgnBoundary ;
 758         GetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), trueUpdateRgn );
 759         GetRegionBounds( trueUpdateRgn , &trueUpdateRgnBoundary ) ;
 760         RectRgn( updateRgn , &trueUpdateRgnBoundary ) ;
 761         SectRgn( updateRgn , visRgn , updateRgn ) ;
 762         if ( trueUpdateRgn )
 763             DisposeRgn( trueUpdateRgn ) ;
 764         SetPortVisibleRegion(  GetWindowPort( (WindowRef)m_macWindow ), updateRgn ) ;
 765 #else
 766         GetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), updateRgn );
 767 #endif
 768         DiffRgn( updateRgn , (RgnHandle) m_macNoEraseUpdateRgn , diffRgn ) ;
 769         if ( !EmptyRgn( updateRgn ) )
 770         {
 771             MacRedraw( updateRgn , timestamp , m_macNeedsErasing || !EmptyRgn( diffRgn )  ) ;
 772         }
 773     }
 774     if ( updateRgn )
 775         DisposeRgn( updateRgn );
 776     if ( diffRgn )
 777         DisposeRgn( diffRgn );
 778     if ( visRgn )
 779         DisposeRgn( visRgn ) ;
 780
 781     EndUpdate( (WindowRef)m_macWindow ) ;
 782     SetEmptyRgn( (RgnHandle) m_macNoEraseUpdateRgn ) ;
 783     m_macNeedsErasing = false ;
 784 }
 785
 786
 787 // Raise the window to the top of the Z order
 788 void wxTopLevelWindowMac::Raise()
 789 {
 790     ::SelectWindow( (WindowRef)m_macWindow ) ;
 791 }
 792
 793 // Lower the window to the bottom of the Z order
 794 void wxTopLevelWindowMac::Lower()
 795 {
 796     ::SendBehind( (WindowRef)m_macWindow , NULL ) ;
 797 }
 798
 799 void wxTopLevelWindowMac::MacFireMouseEvent(
 800     wxUint16 kind , wxInt32 x , wxInt32 y ,wxUint32 modifiers , long timestamp )
 801 {
 802     wxMouseEvent event(wxEVT_LEFT_DOWN);
 803     bool isDown = !(modifiers & btnState) ; // 1 is for up
 804     bool controlDown = modifiers & controlKey ; // for simulating right mouse
 805
 806     event.m_leftDown = isDown && !controlDown;
 807
 808     event.m_middleDown = FALSE;
 809     event.m_rightDown = isDown && controlDown;
 810
 811     if ( kind == mouseDown )
 812     {
 813         if ( controlDown )
 814             event.SetEventType(wxEVT_RIGHT_DOWN ) ;
 815         else
 816             event.SetEventType(wxEVT_LEFT_DOWN ) ;
 817     }
 818     else if ( kind == mouseUp )
 819     {
 820         if ( controlDown )
 821             event.SetEventType(wxEVT_RIGHT_UP ) ;
 822         else
 823             event.SetEventType(wxEVT_LEFT_UP ) ;
 824     }
 825     else
 826     {
 827         event.SetEventType(wxEVT_MOTION ) ;
 828     }
 829
 830     event.m_shiftDown = modifiers & shiftKey;
 831     event.m_controlDown = modifiers & controlKey;
 832     event.m_altDown = modifiers & optionKey;
 833     event.m_metaDown = modifiers & cmdKey;
 834
 835     Point       localwhere ;
 836     localwhere.h = x ;
 837     localwhere.v = y ;
 838
 839     GrafPtr     port ;
 840     ::GetPort( &port ) ;
 841     ::SetPort( UMAGetWindowPort( (WindowRef)m_macWindow ) ) ;
 842     ::GlobalToLocal( &localwhere ) ;
 843     ::SetPort( port ) ;
 844
 845     if ( kind == mouseDown )
 846     {
 847         if ( timestamp - gs_lastWhen <= GetDblTime() )
 848         {
 849             if ( abs( localwhere.h - gs_lastWhere.h ) < 3 && abs( localwhere.v - gs_lastWhere.v ) < 3 )
 850             {
 851                 // This is not right if the second mouse down
 852                 // event occured in a differen window. We
 853                 // correct this in MacDispatchMouseEvent.
 854                 if ( controlDown )
 855                     event.SetEventType(wxEVT_RIGHT_DCLICK ) ;
 856                 else
 857                     event.SetEventType(wxEVT_LEFT_DCLICK ) ;
 858             }
 859             gs_lastWhen = 0 ;
 860         }
 861         else
 862         {
 863             gs_lastWhen = timestamp ;
 864         }
 865         gs_lastWhere = localwhere ;
 866     }
 867
 868     event.m_x = localwhere.h;
 869     event.m_y = localwhere.v;
 870     event.m_x += m_x;
 871     event.m_y += m_y;
 872
 873     event.m_timeStamp = timestamp;
 874     event.SetEventObject(this);
 875     if ( wxTheApp->s_captureWindow )
 876     {
 877         int x = event.m_x ;
 878         int y = event.m_y ;
 879         wxTheApp->s_captureWindow->ScreenToClient( &x , &y ) ;
 880         event.m_x = x ;
 881         event.m_y = y ;
 882         event.SetEventObject( wxTheApp->s_captureWindow ) ;
 883         wxTheApp->s_captureWindow->GetEventHandler()->ProcessEvent( event ) ;
 884
 885         if ( kind == mouseUp )
 886         {
 887             wxTheApp->s_captureWindow = NULL ;
 888             if ( !wxIsBusy() )
 889             {
 890                 m_cursor.MacInstall() ;
 891             }
 892         }
 893     }
 894     else
 895     {
 896         MacDispatchMouseEvent( event ) ;
 897     }
 898 }
 899
 900 #if !TARGET_CARBON
 901
 902 void wxTopLevelWindowMac::MacMouseDown( WXEVENTREF ev , short part)
 903 {
 904     MacFireMouseEvent( mouseDown , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
 905         ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
 906 }
 907
 908 void wxTopLevelWindowMac::MacMouseUp( WXEVENTREF ev , short part)
 909 {
 910     switch (part)
 911     {
 912         case inContent:
 913             {
 914                 MacFireMouseEvent( mouseUp , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
 915                     ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
 916             }
 917             break ;
 918     }
 919 }
 920
 921 void wxTopLevelWindowMac::MacMouseMoved( WXEVENTREF ev , short part)
 922 {
 923     switch (part)
 924     {
 925         case inContent:
 926             {
 927                 MacFireMouseEvent( nullEvent /*moved*/ , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
 928                     ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
 929             }
 930             break ;
 931     }
 932 }
 933
 934 #endif
 935
 936 void wxTopLevelWindowMac::MacActivate( long timestamp , bool inIsActivating )
 937 {
 938     wxActivateEvent event(wxEVT_ACTIVATE, inIsActivating , m_windowId);
 939     event.m_timeStamp = timestamp ;
 940     event.SetEventObject(this);
 941
 942     GetEventHandler()->ProcessEvent(event);
 943
 944     UMAHighlightAndActivateWindow( (WindowRef)m_macWindow , inIsActivating ) ;
 945
 946     // Early versions of MacOS X don't refresh backgrounds properly,
 947     // so refresh the whole window on activation and deactivation.
 948     long osVersion = UMAGetSystemVersion();
 949     if (osVersion >= 0x1000 && osVersion < 0x1020 )
 950     {
 951         Refresh(TRUE);
 952     }
 953     else
 954     {
 955         // for the moment we have to resolve some redrawing issues like this
 956         // the OS is stealing some redrawing areas as soon as it draws a control
 957         Refresh(TRUE);
 958     }
 959 }
 960
 961 #if !TARGET_CARBON
 962
 963 void wxTopLevelWindowMac::MacKeyDown( WXEVENTREF ev )
 964 {
 965 }
 966
 967 #endif
 968
 969 void wxTopLevelWindowMac::SetTitle(const wxString& title)
 970 {
 971     wxWindow::SetTitle( title ) ;
 972     UMASetWTitle( (WindowRef)m_macWindow , title ) ;
 973 }
 974
 975 bool wxTopLevelWindowMac::Show(bool show)
 976 {
 977     if ( !wxWindow::Show(show) )
 978         return FALSE;
 979
 980     if (show)
 981     {
 982       ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowShowTransitionAction,nil);
 983       ::SelectWindow( (WindowRef)m_macWindow ) ;
 984       // no need to generate events here, they will get them triggered by macos
 985       // actually they should be , but apparently they are not
 986       wxSize size(m_width, m_height);
 987       wxSizeEvent event(size, m_windowId);
 988       event.SetEventObject(this);
 989       GetEventHandler()->ProcessEvent(event);
 990     }
 991     else
 992     {
 993       ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowHideTransitionAction,nil);
 994     }
 995
 996     if ( !show )
 997     {
 998     }
 999     else
1000     {
1001         Refresh() ;
1002     }
1003
1004     return TRUE;
1005 }
1006
1007 void wxTopLevelWindowMac::DoMoveWindow(int x, int y, int width, int height)
1008 {
1009     int former_x = m_x ;
1010     int former_y = m_y ;
1011     int former_w = m_width ;
1012     int former_h = m_height ;
1013
1014     int actualWidth = width;
1015     int actualHeight = height;
1016     int actualX = x;
1017     int actualY = y;
1018
1019     if ((m_minWidth != -1) && (actualWidth < m_minWidth))
1020         actualWidth = m_minWidth;
1021     if ((m_minHeight != -1) && (actualHeight < m_minHeight))
1022         actualHeight = m_minHeight;
1023     if ((m_maxWidth != -1) && (actualWidth > m_maxWidth))
1024         actualWidth = m_maxWidth;
1025     if ((m_maxHeight != -1) && (actualHeight > m_maxHeight))
1026         actualHeight = m_maxHeight;
1027
1028     bool doMove = false ;
1029     bool doResize = false ;
1030
1031     if ( actualX != former_x || actualY != former_y )
1032     {
1033         doMove = true ;
1034     }
1035     if ( actualWidth != former_w || actualHeight != former_h )
1036     {
1037         doResize = true ;
1038     }
1039
1040     if ( doMove || doResize )
1041     {
1042         m_x = actualX ;
1043         m_y = actualY ;
1044         m_width = actualWidth ;
1045         m_height = actualHeight ;
1046
1047         if ( doMove )
1048             ::MoveWindow((WindowRef)m_macWindow, m_x, m_y  , false); // don't make frontmost
1049
1050         if ( doResize )
1051             ::SizeWindow((WindowRef)m_macWindow, m_width, m_height  , true);
1052
1053         // the OS takes care of invalidating and erasing the new area so we only have to
1054         // take care of refreshing for full repaints
1055
1056         if ( doResize && !HasFlag(wxNO_FULL_REPAINT_ON_RESIZE) )
1057             Refresh() ;
1058
1059
1060         if ( IsKindOf( CLASSINFO( wxFrame ) ) )
1061         {
1062             wxFrame* frame = (wxFrame*) this ;
1063             frame->PositionStatusBar();
1064             frame->PositionToolBar();
1065         }
1066         if ( doMove )
1067             wxWindowMac::MacTopLevelWindowChangedPosition() ; // like this only children will be notified
1068
1069         MacRepositionScrollBars() ;
1070         if ( doMove )
1071         {
1072             wxPoint point(m_x, m_y);
1073             wxMoveEvent event(point, m_windowId);
1074             event.SetEventObject(this);
1075             GetEventHandler()->ProcessEvent(event) ;
1076         }
1077         if ( doResize )
1078         {
1079              MacRepositionScrollBars() ;
1080              wxSize size(m_width, m_height);
1081              wxSizeEvent event(size, m_windowId);
1082              event.SetEventObject(this);
1083              GetEventHandler()->ProcessEvent(event);
1084         }
1085     }
1086
1087 }
1088
1089 /*
1090  * Invalidation Mechanism
1091  *
1092  * The update mechanism reflects exactely the windows mechanism
1093  * the rect gets added to the window invalidate region, if the eraseBackground flag
1094  * has been true for any part of the update rgn the background is erased in the entire region
1095  * not just in the specified rect.
1096  *
1097  * In order to achive this, we also have an internal m_macNoEraseUpdateRgn, all rects that have
1098  * the eraseBackground flag set to false are also added to this rgn. upon receiving an update event
1099  * the update rgn is compared to the m_macNoEraseUpdateRgn and in case they differ, every window
1100  * will get the eraseBackground event first
1101  */
1102
1103 void wxTopLevelWindowMac::MacInvalidate( const WXRECTPTR rect, bool eraseBackground )
1104 {
1105     GrafPtr formerPort ;
1106     GetPort( &formerPort ) ;
1107     SetPortWindowPort( (WindowRef)m_macWindow ) ;
1108
1109     m_macNeedsErasing |= eraseBackground ;
1110
1111     // if we already know that we will have to erase, there's no need to track the rest
1112     if ( !m_macNeedsErasing)
1113     {
1114         // we end only here if eraseBackground is false
1115         // if we already have a difference between m_macNoEraseUpdateRgn and UpdateRgn
1116         // we will have to erase anyway
1117
1118         RgnHandle       updateRgn = NewRgn();
1119         RgnHandle       diffRgn = NewRgn() ;
1120         if ( updateRgn && diffRgn )
1121         {
1122             GetWindowUpdateRgn( (WindowRef)m_macWindow , updateRgn );
1123             Point pt = {0,0} ;
1124             LocalToGlobal( &pt ) ;
1125             OffsetRgn( updateRgn , -pt.h , -pt.v ) ;
1126             DiffRgn( updateRgn , (RgnHandle) m_macNoEraseUpdateRgn , diffRgn ) ;
1127             if ( !EmptyRgn( diffRgn ) )
1128             {
1129                 m_macNeedsErasing = true ;
1130             }
1131         }
1132         if ( updateRgn )
1133             DisposeRgn( updateRgn );
1134         if ( diffRgn )
1135             DisposeRgn( diffRgn );
1136
1137         if ( !m_macNeedsErasing )
1138         {
1139             RgnHandle rectRgn = NewRgn() ;
1140             SetRectRgn( rectRgn , ((Rect*)rect)->left , ((Rect*)rect)->top , ((Rect*)rect)->right , ((Rect*)rect)->bottom ) ;
1141             UnionRgn( (RgnHandle) m_macNoEraseUpdateRgn , rectRgn , (RgnHandle) m_macNoEraseUpdateRgn ) ;
1142             DisposeRgn( rectRgn ) ;
1143         }
1144     }
1145     InvalWindowRect( (WindowRef)m_macWindow , (Rect*)rect ) ;
1146     // turn this on to debug the refreshing cycle
1147 #if wxMAC_DEBUG_REDRAW
1148     PaintRect( rect ) ;
1149 #endif
1150     SetPort( formerPort ) ;
1151 }
1152
1153
1154 bool wxTopLevelWindowMac::SetShape(const wxRegion& region)
1155 {
1156     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE,
1157                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1158
1159 #if TARGET_CARBON
1160     // The empty region signifies that the shape should be removed from the
1161     // window.
1162     if ( region.IsEmpty() )
1163     {
1164         wxSize sz = GetClientSize();
1165         wxRegion rgn(0, 0, sz.x, sz.y);
1166         return SetShape(rgn);
1167     }
1168
1169     // Make a copy of the region
1170     RgnHandle  shapeRegion = NewRgn();
1171     CopyRgn( (RgnHandle)region.GetWXHRGN(), shapeRegion );
1172
1173     // Dispose of any shape region we may already have
1174     RgnHandle oldRgn = (RgnHandle)GetWRefCon( (WindowRef)MacGetWindowRef() );
1175     if ( oldRgn )
1176         DisposeRgn(oldRgn);
1177
1178     // Save the region so we can use it later
1179     SetWRefCon((WindowRef)MacGetWindowRef(), (SInt32)shapeRegion);
1180
1181     // Tell the window manager that the window has changed shape
1182     ReshapeCustomWindow((WindowRef)MacGetWindowRef());
1183     return TRUE;
1184 #else
1185     return FALSE;
1186 #endif
1187 }
1188
1189 // ---------------------------------------------------------------------------
1190 // Support functions for shaped windows, based on Apple's CustomWindow sample at
1191 // http://developer.apple.com/samplecode/Sample_Code/Human_Interface_Toolbox/Mac_OS_High_Level_Toolbox/CustomWindow.htm
1192 // ---------------------------------------------------------------------------
1193
1194 #if TARGET_CARBON
1195
1196 static void wxShapedMacWindowGetPos(WindowRef window, Rect* inRect)
1197 {
1198     GetWindowPortBounds(window, inRect);
1199     Point pt = {inRect->left, inRect->top};
1200     SetPort((GrafPtr) GetWindowPort(window));
1201     LocalToGlobal(&pt);
1202     inRect->top = pt.v;
1203     inRect->left = pt.h;
1204     inRect->bottom += pt.v;
1205     inRect->right += pt.h;
1206 }
1207
1208
1209 static SInt32 wxShapedMacWindowGetFeatures(WindowRef window, SInt32 param)
1210 {
1211     /*------------------------------------------------------
1212         Define which options your custom window supports.
1213     --------------------------------------------------------*/
1214     //just enable everything for our demo
1215     *(OptionBits*)param=//kWindowCanGrow|
1216                         //kWindowCanZoom|
1217                         //kWindowCanCollapse|
1218                         //kWindowCanGetWindowRegion|
1219                         //kWindowHasTitleBar|
1220                         //kWindowSupportsDragHilite|
1221                         kWindowCanDrawInCurrentPort|
1222                         //kWindowCanMeasureTitle|
1223                         kWindowWantsDisposeAtProcessDeath|
1224                         kWindowSupportsSetGrowImageRegion|
1225                         kWindowDefSupportsColorGrafPort;
1226     return 1;
1227 }
1228
1229 // The content region is left as a rectangle matching the window size, this is
1230 // so the origin in the paint event, and etc. still matches what the
1231 // programmer expects.
1232 static void wxShapedMacWindowContentRegion(WindowRef window, RgnHandle rgn)
1233 {
1234     SetEmptyRgn(rgn);
1235     wxTopLevelWindowMac* win = wxFindWinFromMacWindow(window);
1236     if (win)
1237     {
1238         wxRect r = win->GetRect();
1239         SetRectRgn(rgn, r.GetLeft(), r.GetTop(), r.GetRight(), r.GetBottom());
1240     }
1241 }
1242
1243 // The structure region is set to the shape given to the SetShape method.
1244 static void wxShapedMacWindowStructureRegion(WindowRef window, RgnHandle rgn)
1245 {
1246     RgnHandle cachedRegion = (RgnHandle) GetWRefCon(window);
1247
1248     SetEmptyRgn(rgn);
1249     if (cachedRegion)
1250     {
1251         Rect windowRect;
1252         wxShapedMacWindowGetPos(window, &windowRect);   //how big is the window
1253         CopyRgn(cachedRegion, rgn);             //make a copy of our cached region
1254         OffsetRgn(rgn, windowRect.left, windowRect.top); // position it over window
1255         //MapRgn(rgn, &mMaskSize, &windowRect); //scale it to our actual window size
1256     }
1257 }
1258
1259
1260
1261 static SInt32 wxShapedMacWindowGetRegion(WindowRef window, SInt32 param)
1262 {
1263     GetWindowRegionPtr rgnRec=(GetWindowRegionPtr)param;
1264
1265     switch(rgnRec->regionCode)
1266     {
1267         case kWindowStructureRgn:
1268             wxShapedMacWindowStructureRegion(window, rgnRec->winRgn);
1269             break;
1270         case kWindowContentRgn:
1271             wxShapedMacWindowContentRegion(window, rgnRec->winRgn);
1272             break;
1273         default:
1274             SetEmptyRgn(rgnRec->winRgn);
1275     }  //switch
1276
1277     return noErr;
1278 }
1279
1280
1281 static SInt32 wxShapedMacWindowHitTest(WindowRef window,SInt32 param)
1282 {
1283     /*------------------------------------------------------
1284         Determine the region of the window which was hit
1285     --------------------------------------------------------*/
1286     Point hitPoint;
1287     static RgnHandle tempRgn=nil;
1288
1289     if(!tempRgn)
1290         tempRgn=NewRgn();
1291
1292     SetPt(&hitPoint,LoWord(param),HiWord(param));//get the point clicked
1293
1294      //Mac OS 8.5 or later
1295     wxShapedMacWindowStructureRegion(window, tempRgn);
1296     if (PtInRgn(hitPoint, tempRgn)) //in window content region?
1297         return wInContent;
1298
1299     return wNoHit;//no significant area was hit.
1300 }
1301
1302
1303 static pascal long wxShapedMacWindowDef(short varCode, WindowRef window, SInt16 message, SInt32 param)
1304 {
1305     switch(message)
1306     {
1307         case kWindowMsgHitTest:
1308             return wxShapedMacWindowHitTest(window,param);
1309
1310         case kWindowMsgGetFeatures:
1311             return wxShapedMacWindowGetFeatures(window,param);
1312
1313         // kWindowMsgGetRegion is sent during CreateCustomWindow and ReshapeCustomWindow
1314         case kWindowMsgGetRegion:
1315             return wxShapedMacWindowGetRegion(window,param);
1316     }
1317
1318     return 0;
1319 }
1320
1321 #endif
1322 // ---------------------------------------------------------------------------
1323