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 #define wxMAC_DEBUG_REDRAW 0
  47 #ifndef wxMAC_DEBUG_REDRAW
  48 #define wxMAC_DEBUG_REDRAW 0
  49 #endif
  50
  51 // ----------------------------------------------------------------------------
  52 // globals
  53 // ----------------------------------------------------------------------------
  54
  55 // list of all frames and modeless dialogs
  56 wxWindowList       wxModelessWindows;
  57
  58 // double click testing
  59 static   Point     gs_lastWhere;
  60 static   long      gs_lastWhen = 0;
  61
  62 // ============================================================================
  63 // wxTopLevelWindowMac implementation
  64 // ============================================================================
  65
  66 // ---------------------------------------------------------------------------
  67 // Carbon Events
  68 // ---------------------------------------------------------------------------
  69
  70 #if TARGET_CARBON
  71
  72 extern long wxMacTranslateKey(unsigned char key, unsigned char code) ;
  73
  74 static const EventTypeSpec eventList[] =
  75 {
  76     { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
  77
  78     { kEventClassKeyboard, kEventRawKeyDown } ,
  79     { kEventClassKeyboard, kEventRawKeyRepeat } ,
  80     { kEventClassKeyboard, kEventRawKeyUp } ,
  81     { kEventClassKeyboard, kEventRawKeyModifiersChanged } ,
  82
  83     { kEventClassWindow , kEventWindowUpdate } ,
  84     { kEventClassWindow , kEventWindowActivated } ,
  85     { kEventClassWindow , kEventWindowDeactivated } ,
  86     { kEventClassWindow , kEventWindowBoundsChanging } ,
  87     { kEventClassWindow , kEventWindowBoundsChanged } ,
  88     { kEventClassWindow , kEventWindowClose } ,
  89
  90     { kEventClassMouse , kEventMouseDown } ,
  91     { kEventClassMouse , kEventMouseUp } ,
  92     { kEventClassMouse , kEventMouseMoved } ,
  93     { kEventClassMouse , kEventMouseDragged } ,
  94
  95 } ;
  96
  97 static pascal OSStatus TextInputEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
  98 {
  99     OSStatus result = eventNotHandledErr ;
 100
 101     wxWindow* focus = wxWindow::FindFocus() ;
 102     char charCode ;
 103     UInt32 keyCode ;
 104     UInt32 modifiers ;
 105     Point point ;
 106     UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
 107
 108     EventRef rawEvent ;
 109
 110     GetEventParameter( event , kEventParamTextInputSendKeyboardEvent ,typeEventRef,NULL,sizeof(rawEvent),NULL,&rawEvent ) ;
 111
 112     GetEventParameter( rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL,sizeof(char), NULL,&charCode );
 113     GetEventParameter( rawEvent, kEventParamKeyCode, typeUInt32, NULL,  sizeof(UInt32), NULL, &keyCode );
 114        GetEventParameter( rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
 115     GetEventParameter( rawEvent, kEventParamMouseLocation, typeQDPoint, NULL,
 116         sizeof( Point ), NULL, &point );
 117
 118     UInt32 message = (keyCode << 8) + charCode;
 119
 120     switch ( GetEventKind( event ) )
 121     {
 122         case kEventTextInputUnicodeForKeyEvent :
 123             if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
 124                 focus , message , modifiers , when , point.h , point.v ) )
 125             {
 126                 result = noErr ;
 127             }
 128             break ;
 129     }
 130
 131     return result ;
 132 }
 133
 134 static pascal OSStatus KeyboardEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 135 {
 136     OSStatus result = eventNotHandledErr ;
 137
 138     wxWindow* focus = wxWindow::FindFocus() ;
 139     char charCode ;
 140     UInt32 keyCode ;
 141     UInt32 modifiers ;
 142     Point point ;
 143     UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
 144
 145     GetEventParameter( event, kEventParamKeyMacCharCodes, typeChar, NULL,sizeof(char), NULL,&charCode );
 146     GetEventParameter( event, kEventParamKeyCode, typeUInt32, NULL,  sizeof(UInt32), NULL, &keyCode );
 147        GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
 148     GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
 149         sizeof( Point ), NULL, &point );
 150
 151     UInt32 message = (keyCode << 8) + charCode;
 152     switch( GetEventKind( event ) )
 153     {
 154         case kEventRawKeyRepeat :
 155         case kEventRawKeyDown :
 156             if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
 157                 focus , message , modifiers , when , point.h , point.v ) )
 158             {
 159                 result = noErr ;
 160             }
 161             break ;
 162         case kEventRawKeyUp :
 163             if ( (focus != NULL) && wxTheApp->MacSendKeyUpEvent(
 164                 focus , message , modifiers , when , point.h , point.v ) )
 165             {
 166                 result = noErr ;
 167             }
 168             break ;
 169         case kEventRawKeyModifiersChanged :
 170             {
 171                 wxKeyEvent event(wxEVT_KEY_DOWN);
 172
 173                 event.m_shiftDown = modifiers & shiftKey;
 174                 event.m_controlDown = modifiers & controlKey;
 175                 event.m_altDown = modifiers & optionKey;
 176                 event.m_metaDown = modifiers & cmdKey;
 177
 178                 event.m_x = point.h;
 179                 event.m_y = point.v;
 180                 event.m_timeStamp = when;
 181                 wxWindow* focus = wxWindow::FindFocus() ;
 182                 event.SetEventObject(focus);
 183
 184                 if ( (modifiers ^ wxTheApp->s_lastModifiers ) & controlKey )
 185                 {
 186                     event.m_keyCode = WXK_CONTROL ;
 187                     event.SetEventType( ( modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 188                     focus->GetEventHandler()->ProcessEvent( event ) ;
 189                 }
 190                 if ( (modifiers ^ wxTheApp->s_lastModifiers ) & shiftKey )
 191                 {
 192                     event.m_keyCode = WXK_SHIFT ;
 193                     event.SetEventType( ( modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 194                     focus->GetEventHandler()->ProcessEvent( event ) ;
 195                 }
 196                 if ( (modifiers ^ wxTheApp->s_lastModifiers ) & optionKey )
 197                 {
 198                     event.m_keyCode = WXK_ALT ;
 199                     event.SetEventType( ( modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 200                     focus->GetEventHandler()->ProcessEvent( event ) ;
 201                 }
 202                 wxTheApp->s_lastModifiers = modifiers ;
 203             }
 204              break ;
 205     }
 206
 207     return result ;
 208 }
 209
 210 static pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 211 {
 212     OSStatus result = eventNotHandledErr ;
 213
 214     wxTopLevelWindowMac* toplevelWindow = (wxTopLevelWindowMac*) data ;
 215     Point point ;
 216     UInt32 modifiers = 0;
 217     EventMouseButton button = 0 ;
 218     UInt32 click = 0 ;
 219
 220     GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
 221         sizeof( Point ), NULL, &point );
 222     GetEventParameter( event, kEventParamKeyModifiers, typeUInt32, NULL,
 223         sizeof( UInt32 ), NULL, &modifiers );
 224     GetEventParameter( event, kEventParamMouseButton, typeMouseButton, NULL,
 225         sizeof( EventMouseButton ), NULL, &button );
 226     GetEventParameter( event, kEventParamClickCount, typeUInt32, NULL,
 227         sizeof( UInt32 ), NULL, &click );
 228
 229     if ( button == 0 || GetEventKind( event ) == kEventMouseUp )
 230         modifiers += btnState ;
 231
 232     WindowRef window ;
 233     short windowPart = ::FindWindow(point, &window);
 234
 235     if ( IsWindowActive(window) && windowPart == inContent )
 236     {
 237         switch ( GetEventKind( event ) )
 238         {
 239             case kEventMouseDown :
 240                 toplevelWindow->MacFireMouseEvent( mouseDown , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
 241                 result = noErr ;
 242                 break ;
 243             case kEventMouseUp :
 244                 toplevelWindow->MacFireMouseEvent( mouseUp , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
 245                 result = noErr ;
 246                 break ;
 247             case kEventMouseMoved :
 248                 toplevelWindow->MacFireMouseEvent( nullEvent , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
 249                 result = noErr ;
 250                 break ;
 251             case kEventMouseDragged :
 252                 toplevelWindow->MacFireMouseEvent( nullEvent , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
 253                 result = noErr ;
 254                 break ;
 255             default :
 256                 break ;
 257         }
 258     }
 259
 260     return result ;
 261
 262
 263 }
 264 static pascal OSStatus WindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 265 {
 266     OSStatus result = eventNotHandledErr ;
 267     OSStatus err = noErr ;
 268
 269     UInt32        attributes;
 270     WindowRef windowRef ;
 271     wxTopLevelWindowMac* toplevelWindow = (wxTopLevelWindowMac*) data ;
 272
 273     GetEventParameter( event, kEventParamDirectObject, typeWindowRef, NULL,
 274         sizeof( WindowRef ), NULL, &windowRef );
 275
 276     switch( GetEventKind( event ) )
 277     {
 278         case kEventWindowUpdate :
 279             if ( !wxPendingDelete.Member(toplevelWindow) )
 280                 toplevelWindow->MacUpdate( EventTimeToTicks( GetEventTime( event ) ) ) ;
 281             result = noErr ;
 282             break ;
 283         case kEventWindowActivated :
 284                 toplevelWindow->MacActivate( EventTimeToTicks( GetEventTime( event ) ) , true) ;
 285             result = noErr ;
 286             break ;
 287         case kEventWindowDeactivated :
 288                 toplevelWindow->MacActivate( EventTimeToTicks( GetEventTime( event ) ) , false) ;
 289             result = noErr ;
 290             break ;
 291         case kEventWindowClose :
 292                 toplevelWindow->Close() ;
 293             result = noErr ;
 294             break ;
 295         case kEventWindowBoundsChanged :
 296             err = GetEventParameter( event, kEventParamAttributes, typeUInt32,
 297                         NULL, sizeof( UInt32 ), NULL, &attributes );
 298             if ( err == noErr )
 299             {
 300                 Rect newContentRect ;
 301
 302                 GetEventParameter( event, kEventParamCurrentBounds, typeQDRectangle, NULL,
 303                     sizeof( newContentRect ), NULL, &newContentRect );
 304
 305                 toplevelWindow->SetSize( newContentRect.left , newContentRect.top ,
 306                     newContentRect.right - newContentRect.left ,
 307                     newContentRect.bottom - newContentRect.top, wxSIZE_USE_EXISTING);
 308
 309                 result = noErr;
 310             }
 311             break ;
 312         default :
 313             break ;
 314     }
 315     return result ;
 316 }
 317
 318 pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 319 {
 320     OSStatus result = eventNotHandledErr ;
 321
 322     switch ( GetEventClass( event ) )
 323     {
 324         case kEventClassKeyboard :
 325             result = KeyboardEventHandler( handler, event , data ) ;
 326             break ;
 327         case kEventClassTextInput :
 328             result = TextInputEventHandler( handler, event , data ) ;
 329             break ;
 330         case kEventClassWindow :
 331             result = WindowEventHandler( handler, event , data ) ;
 332             break ;
 333         case kEventClassMouse :
 334             result = MouseEventHandler( handler, event , data ) ;
 335             break ;
 336         default :
 337             break ;
 338     }
 339     return result ;
 340 }
 341
 342 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacWindowEventHandler )
 343
 344 #endif
 345
 346 // ---------------------------------------------------------------------------
 347 // wxWindowMac utility functions
 348 // ---------------------------------------------------------------------------
 349
 350 // Find an item given the Macintosh Window Reference
 351
 352 wxList *wxWinMacWindowList = NULL;
 353 wxTopLevelWindowMac *wxFindWinFromMacWindow(WXWindow inWindowRef)
 354 {
 355     wxNode *node = wxWinMacWindowList->Find((long)inWindowRef);
 356     if (!node)
 357         return NULL;
 358     return (wxTopLevelWindowMac *)node->GetData();
 359 }
 360
 361 void wxAssociateWinWithMacWindow(WXWindow inWindowRef, wxTopLevelWindowMac *win)
 362 {
 363     // adding NULL WindowRef is (first) surely a result of an error and
 364     // (secondly) breaks menu command processing
 365     wxCHECK_RET( inWindowRef != (WindowRef) NULL, wxT("attempt to add a NULL WindowRef to window list") );
 366
 367     if ( !wxWinMacWindowList->Find((long)inWindowRef) )
 368         wxWinMacWindowList->Append((long)inWindowRef, win);
 369 }
 370
 371 void wxRemoveMacWindowAssociation(wxTopLevelWindowMac *win)
 372 {
 373     wxWinMacWindowList->DeleteObject(win);
 374 }
 375
 376
 377 // ----------------------------------------------------------------------------
 378 // wxTopLevelWindowMac creation
 379 // ----------------------------------------------------------------------------
 380
 381 WXHWND wxTopLevelWindowMac::s_macWindowInUpdate = NULL;
 382
 383 void wxTopLevelWindowMac::Init()
 384 {
 385     m_iconized =
 386     m_maximizeOnShow = FALSE;
 387     m_macNoEraseUpdateRgn = NewRgn() ;
 388     m_macNeedsErasing = false ;
 389     m_macWindow = NULL ;
 390 #if TARGET_CARBON
 391     m_macEventHandler = NULL ;
 392  #endif
 393 }
 394
 395 class wxMacDeferredWindowDeleter : public wxObject
 396 {
 397 public :
 398     wxMacDeferredWindowDeleter( WindowRef windowRef )
 399     {
 400         m_macWindow = windowRef ;
 401     }
 402     virtual ~wxMacDeferredWindowDeleter()
 403     {
 404         UMADisposeWindow( (WindowRef) m_macWindow ) ;
 405     }
 406  protected :
 407     WindowRef m_macWindow ;
 408 } ;
 409
 410 bool wxTopLevelWindowMac::Create(wxWindow *parent,
 411                                  wxWindowID id,
 412                                  const wxString& title,
 413                                  const wxPoint& pos,
 414                                  const wxSize& size,
 415                                  long style,
 416                                  const wxString& name)
 417 {
 418     // init our fields
 419     Init();
 420
 421     m_windowStyle = style;
 422
 423     SetName(name);
 424
 425     m_windowId = id == -1 ? NewControlId() : id;
 426
 427     wxTopLevelWindows.Append(this);
 428
 429     if ( parent )
 430         parent->AddChild(this);
 431
 432     return TRUE;
 433 }
 434
 435 wxTopLevelWindowMac::~wxTopLevelWindowMac()
 436 {
 437     if ( m_macWindow )
 438     {
 439         wxToolTip::NotifyWindowDelete(m_macWindow) ;
 440         wxPendingDelete.Append( new wxMacDeferredWindowDeleter( (WindowRef) m_macWindow ) ) ;
 441     }
 442
 443 #if TARGET_CARBON
 444     if ( m_macEventHandler )
 445     {
 446         ::RemoveEventHandler((EventHandlerRef) m_macEventHandler);
 447         m_macEventHandler = NULL ;
 448     }
 449 #endif
 450
 451     wxRemoveMacWindowAssociation( this ) ;
 452
 453     if ( wxModelessWindows.Find(this) )
 454         wxModelessWindows.DeleteObject(this);
 455
 456     DisposeRgn( (RgnHandle) m_macNoEraseUpdateRgn ) ;
 457 }
 458
 459
 460 // ----------------------------------------------------------------------------
 461 // wxTopLevelWindowMac maximize/minimize
 462 // ----------------------------------------------------------------------------
 463
 464 void wxTopLevelWindowMac::Maximize(bool maximize)
 465 {
 466     // not available on mac
 467 }
 468
 469 bool wxTopLevelWindowMac::IsMaximized() const
 470 {
 471     return false ;
 472 }
 473
 474 void wxTopLevelWindowMac::Iconize(bool iconize)
 475 {
 476     // not available on mac
 477 }
 478
 479 bool wxTopLevelWindowMac::IsIconized() const
 480 {
 481     // mac dialogs cannot be iconized
 482     return FALSE;
 483 }
 484
 485 void wxTopLevelWindowMac::Restore()
 486 {
 487     // not available on mac
 488 }
 489
 490 // ----------------------------------------------------------------------------
 491 // wxTopLevelWindowMac misc
 492 // ----------------------------------------------------------------------------
 493
 494 void wxTopLevelWindowMac::SetIcon(const wxIcon& icon)
 495 {
 496     // this sets m_icon
 497     wxTopLevelWindowBase::SetIcon(icon);
 498 }
 499
 500 void  wxTopLevelWindowMac::MacCreateRealWindow( const wxString& title,
 501            const wxPoint& pos,
 502            const wxSize& size,
 503            long style,
 504            const wxString& name )
 505 {
 506     SetName(name);
 507     m_windowStyle = style;
 508     m_isShown = FALSE;
 509
 510     // create frame.
 511
 512     Rect theBoundsRect;
 513
 514     m_x = (int)pos.x;
 515     m_y = (int)pos.y;
 516     if ( m_y < 50 )
 517         m_y = 50 ;
 518     if ( m_x < 20 )
 519         m_x = 20 ;
 520
 521     m_width = size.x;
 522     if (m_width == -1)
 523         m_width = 20;
 524     m_height = size.y;
 525     if (m_height == -1)
 526         m_height = 20;
 527
 528     ::SetRect(&theBoundsRect, m_x, m_y , m_x + m_width, m_y + m_height);
 529
 530     // translate the window attributes in the appropriate window class and attributes
 531
 532     WindowClass wclass = 0;
 533     WindowAttributes attr = kWindowNoAttributes ;
 534
 535     if ( HasFlag( wxFRAME_TOOL_WINDOW) )
 536     {
 537         if (
 538             HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) ||
 539             HasFlag( wxSYSTEM_MENU ) || HasFlag( wxCAPTION ) ||
 540             HasFlag(wxTINY_CAPTION_HORIZ) ||  HasFlag(wxTINY_CAPTION_VERT)
 541             )
 542         {
 543             wclass = kFloatingWindowClass ;
 544             if ( HasFlag(wxTINY_CAPTION_VERT) )
 545             {
 546                 attr |= kWindowSideTitlebarAttribute ;
 547             }
 548         }
 549         else
 550         {
 551 #if TARGET_CARBON
 552             wclass = kPlainWindowClass ;
 553 #else
 554             wclass = kFloatingWindowClass ;
 555 #endif
 556         }
 557     }
 558     else if ( HasFlag( wxCAPTION ) )
 559     {
 560         wclass = kDocumentWindowClass ;
 561     }
 562     else
 563     {
 564         if ( HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) ||
 565             HasFlag( wxSYSTEM_MENU ) )
 566         {
 567             wclass = kDocumentWindowClass ;
 568         }
 569         else
 570         {
 571 #if TARGET_CARBON
 572             wclass = kPlainWindowClass ;
 573 #else
 574             wclass = kModalWindowClass ;
 575 #endif
 576         }
 577     }
 578
 579     if ( HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) )
 580     {
 581         attr |= kWindowFullZoomAttribute ;
 582         attr |= kWindowCollapseBoxAttribute ;
 583     }
 584     if ( HasFlag( wxRESIZE_BORDER ) )
 585     {
 586         attr |= kWindowResizableAttribute ;
 587     }
 588     if ( HasFlag( wxSYSTEM_MENU ) )
 589     {
 590         attr |= kWindowCloseBoxAttribute ;
 591     }
 592
 593     ::CreateNewWindow( wclass , attr , &theBoundsRect , (WindowRef*)&m_macWindow ) ;
 594     wxAssociateWinWithMacWindow( m_macWindow , this ) ;
 595     UMASetWTitle( (WindowRef)m_macWindow , title ) ;
 596     ::CreateRootControl( (WindowRef)m_macWindow , (ControlHandle*)&m_macRootControl ) ;
 597 #if TARGET_CARBON
 598     InstallStandardEventHandler( GetWindowEventTarget(MAC_WXHWND(m_macWindow)) ) ;
 599     InstallWindowEventHandler(MAC_WXHWND(m_macWindow), GetwxMacWindowEventHandlerUPP(),
 600         GetEventTypeCount(eventList), eventList, this, &((EventHandlerRef)m_macEventHandler));
 601 #endif
 602     m_macFocus = NULL ;
 603 }
 604
 605 void wxTopLevelWindowMac::MacGetPortParams(WXPOINTPTR localOrigin, WXRECTPTR clipRect, WXHWND *window  , wxWindowMac** rootwin)
 606 {
 607     ((Point*)localOrigin)->h = 0;
 608     ((Point*)localOrigin)->v = 0;
 609     ((Rect*)clipRect)->left = 0;
 610     ((Rect*)clipRect)->top = 0;
 611     ((Rect*)clipRect)->right = m_width;
 612     ((Rect*)clipRect)->bottom = m_height;
 613     *window = m_macWindow ;
 614     *rootwin = this ;
 615 }
 616
 617 void wxTopLevelWindowMac::Clear()
 618 {
 619     wxWindow::Clear() ;
 620 }
 621
 622 WXWidget wxTopLevelWindowMac::MacGetContainerForEmbedding()
 623 {
 624     return m_macRootControl ;
 625 }
 626
 627
 628 void wxTopLevelWindowMac::MacUpdate( long timestamp)
 629 {
 630     wxMacPortStateHelper help( (GrafPtr) GetWindowPort( (WindowRef) m_macWindow) ) ;
 631
 632     BeginUpdate( (WindowRef)m_macWindow ) ;
 633
 634     RgnHandle       updateRgn = NewRgn();
 635     RgnHandle       diffRgn = NewRgn() ;
 636     if ( updateRgn && diffRgn )
 637     {
 638         GetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), updateRgn );
 639         DiffRgn( updateRgn , (RgnHandle) m_macNoEraseUpdateRgn , diffRgn ) ;
 640         if ( !EmptyRgn( updateRgn ) )
 641         {
 642             MacRedraw( updateRgn , timestamp , m_macNeedsErasing || !EmptyRgn( diffRgn )  ) ;
 643         }
 644     }
 645     if ( updateRgn )
 646         DisposeRgn( updateRgn );
 647     if ( diffRgn )
 648         DisposeRgn( diffRgn );
 649     EndUpdate( (WindowRef)m_macWindow ) ;
 650     SetEmptyRgn( (RgnHandle) m_macNoEraseUpdateRgn ) ;
 651     m_macNeedsErasing = false ;
 652 }
 653
 654
 655 // Raise the window to the top of the Z order
 656 void wxTopLevelWindowMac::Raise()
 657 {
 658     ::SelectWindow( (WindowRef)m_macWindow ) ;
 659 }
 660
 661 // Lower the window to the bottom of the Z order
 662 void wxTopLevelWindowMac::Lower()
 663 {
 664     ::SendBehind( (WindowRef)m_macWindow , NULL ) ;
 665 }
 666
 667 void wxTopLevelWindowMac::MacFireMouseEvent(
 668     wxUint16 kind , wxInt32 x , wxInt32 y ,wxUint32 modifiers , long timestamp )
 669 {
 670     wxMouseEvent event(wxEVT_LEFT_DOWN);
 671     bool isDown = !(modifiers & btnState) ; // 1 is for up
 672     bool controlDown = modifiers & controlKey ; // for simulating right mouse
 673
 674     event.m_leftDown = isDown && !controlDown;
 675
 676     event.m_middleDown = FALSE;
 677     event.m_rightDown = isDown && controlDown;
 678
 679     if ( kind == mouseDown )
 680     {
 681         if ( controlDown )
 682             event.SetEventType(wxEVT_RIGHT_DOWN ) ;
 683         else
 684             event.SetEventType(wxEVT_LEFT_DOWN ) ;
 685     }
 686     else if ( kind == mouseUp )
 687     {
 688         if ( controlDown )
 689             event.SetEventType(wxEVT_RIGHT_UP ) ;
 690         else
 691             event.SetEventType(wxEVT_LEFT_UP ) ;
 692     }
 693     else
 694     {
 695         event.SetEventType(wxEVT_MOTION ) ;
 696     }
 697
 698     event.m_shiftDown = modifiers & shiftKey;
 699     event.m_controlDown = modifiers & controlKey;
 700     event.m_altDown = modifiers & optionKey;
 701     event.m_metaDown = modifiers & cmdKey;
 702
 703     Point       localwhere ;
 704     localwhere.h = x ;
 705     localwhere.v = y ;
 706
 707     GrafPtr     port ;
 708     ::GetPort( &port ) ;
 709     ::SetPort( UMAGetWindowPort( (WindowRef)m_macWindow ) ) ;
 710     ::GlobalToLocal( &localwhere ) ;
 711     ::SetPort( port ) ;
 712
 713     if ( kind == mouseDown )
 714     {
 715         if ( timestamp - gs_lastWhen <= GetDblTime() )
 716         {
 717             if ( abs( localwhere.h - gs_lastWhere.h ) < 3 && abs( localwhere.v - gs_lastWhere.v ) < 3 )
 718             {
 719                 // This is not right if the second mouse down
 720                 // event occured in a differen window. We
 721                 // correct this in MacDispatchMouseEvent.
 722                 if ( controlDown )
 723                     event.SetEventType(wxEVT_RIGHT_DCLICK ) ;
 724                 else
 725                     event.SetEventType(wxEVT_LEFT_DCLICK ) ;
 726             }
 727             gs_lastWhen = 0 ;
 728         }
 729         else
 730         {
 731             gs_lastWhen = timestamp ;
 732         }
 733         gs_lastWhere = localwhere ;
 734     }
 735
 736     event.m_x = localwhere.h;
 737     event.m_y = localwhere.v;
 738     event.m_x += m_x;
 739     event.m_y += m_y;
 740
 741     event.m_timeStamp = timestamp;
 742     event.SetEventObject(this);
 743     if ( wxTheApp->s_captureWindow )
 744     {
 745         int x = event.m_x ;
 746         int y = event.m_y ;
 747         wxTheApp->s_captureWindow->ScreenToClient( &x , &y ) ;
 748         event.m_x = x ;
 749         event.m_y = y ;
 750         event.SetEventObject( wxTheApp->s_captureWindow ) ;
 751         wxTheApp->s_captureWindow->GetEventHandler()->ProcessEvent( event ) ;
 752
 753         if ( kind == mouseUp )
 754         {
 755             wxTheApp->s_captureWindow = NULL ;
 756             if ( !wxIsBusy() )
 757             {
 758                 m_cursor.MacInstall() ;
 759             }
 760         }
 761     }
 762     else
 763     {
 764         MacDispatchMouseEvent( event ) ;
 765     }
 766 }
 767
 768 #if !TARGET_CARBON
 769
 770 void wxTopLevelWindowMac::MacMouseDown( WXEVENTREF ev , short part)
 771 {
 772     MacFireMouseEvent( mouseDown , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
 773         ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
 774 }
 775
 776 void wxTopLevelWindowMac::MacMouseUp( WXEVENTREF ev , short part)
 777 {
 778     switch (part)
 779     {
 780         case inContent:
 781             {
 782                 MacFireMouseEvent( mouseUp , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
 783                     ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
 784             }
 785             break ;
 786     }
 787 }
 788
 789 void wxTopLevelWindowMac::MacMouseMoved( WXEVENTREF ev , short part)
 790 {
 791     switch (part)
 792     {
 793         case inContent:
 794             {
 795                 MacFireMouseEvent( nullEvent /*moved*/ , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
 796                     ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
 797             }
 798             break ;
 799     }
 800 }
 801
 802 #endif
 803
 804 void wxTopLevelWindowMac::MacActivate( long timestamp , bool inIsActivating )
 805 {
 806     wxActivateEvent event(wxEVT_ACTIVATE, inIsActivating , m_windowId);
 807     event.m_timeStamp = timestamp ;
 808     event.SetEventObject(this);
 809
 810     GetEventHandler()->ProcessEvent(event);
 811
 812     UMAHighlightAndActivateWindow( (WindowRef)m_macWindow , inIsActivating ) ;
 813
 814     // Early versions of MacOS X don't refresh backgrounds properly,
 815     // so refresh the whole window on activation and deactivation.
 816     long osVersion = UMAGetSystemVersion();
 817     if (osVersion >= 0x1000 && osVersion < 0x1020)
 818         Refresh(TRUE);
 819     else
 820         MacSuperEnabled( inIsActivating ) ;
 821 }
 822
 823 #if !TARGET_CARBON
 824
 825 void wxTopLevelWindowMac::MacKeyDown( WXEVENTREF ev )
 826 {
 827 }
 828
 829 #endif
 830
 831 void wxTopLevelWindowMac::SetTitle(const wxString& title)
 832 {
 833     wxWindow::SetTitle( title ) ;
 834     UMASetWTitle( (WindowRef)m_macWindow , title ) ;
 835 }
 836
 837 bool wxTopLevelWindowMac::Show(bool show)
 838 {
 839     if ( !wxWindow::Show(show) )
 840         return FALSE;
 841
 842     if (show)
 843     {
 844       ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowShowTransitionAction,nil);
 845       ::SelectWindow( (WindowRef)m_macWindow ) ;
 846       // no need to generate events here, they will get them triggered by macos
 847       // actually they should be , but apparently they are not
 848       wxSize size(m_width, m_height);
 849       wxSizeEvent event(size, m_windowId);
 850       event.SetEventObject(this);
 851       GetEventHandler()->ProcessEvent(event);
 852     }
 853     else
 854     {
 855       ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowHideTransitionAction,nil);
 856     }
 857
 858     if ( !show )
 859     {
 860     }
 861     else
 862     {
 863         Refresh() ;
 864     }
 865
 866     return TRUE;
 867 }
 868
 869 void wxTopLevelWindowMac::DoMoveWindow(int x, int y, int width, int height)
 870 {
 871     int former_x = m_x ;
 872     int former_y = m_y ;
 873     int former_w = m_width ;
 874     int former_h = m_height ;
 875
 876     int actualWidth = width;
 877     int actualHeight = height;
 878     int actualX = x;
 879     int actualY = y;
 880
 881     if ((m_minWidth != -1) && (actualWidth < m_minWidth))
 882         actualWidth = m_minWidth;
 883     if ((m_minHeight != -1) && (actualHeight < m_minHeight))
 884         actualHeight = m_minHeight;
 885     if ((m_maxWidth != -1) && (actualWidth > m_maxWidth))
 886         actualWidth = m_maxWidth;
 887     if ((m_maxHeight != -1) && (actualHeight > m_maxHeight))
 888         actualHeight = m_maxHeight;
 889
 890     bool doMove = false ;
 891     bool doResize = false ;
 892
 893     if ( actualX != former_x || actualY != former_y )
 894     {
 895         doMove = true ;
 896     }
 897     if ( actualWidth != former_w || actualHeight != former_h )
 898     {
 899         doResize = true ;
 900     }
 901
 902     if ( doMove || doResize )
 903     {
 904         m_x = actualX ;
 905         m_y = actualY ;
 906         m_width = actualWidth ;
 907         m_height = actualHeight ;
 908
 909         if ( doMove )
 910             ::MoveWindow((WindowRef)m_macWindow, m_x, m_y  , false); // don't make frontmost
 911
 912         if ( doResize )
 913             ::SizeWindow((WindowRef)m_macWindow, m_width, m_height  , true);
 914
 915         // the OS takes care of invalidating and erasing the new area so we only have to
 916         // take care of refreshing for full repaints
 917
 918         if ( doResize && !HasFlag(wxNO_FULL_REPAINT_ON_RESIZE) )
 919             Refresh() ;
 920
 921
 922         if ( IsKindOf( CLASSINFO( wxFrame ) ) )
 923         {
 924             wxFrame* frame = (wxFrame*) this ;
 925             frame->PositionStatusBar();
 926             frame->PositionToolBar();
 927         }
 928         if ( doMove )
 929             wxWindowMac::MacTopLevelWindowChangedPosition() ; // like this only children will be notified
 930
 931         MacRepositionScrollBars() ;
 932         if ( doMove )
 933         {
 934             wxPoint point(m_x, m_y);
 935             wxMoveEvent event(point, m_windowId);
 936             event.SetEventObject(this);
 937             GetEventHandler()->ProcessEvent(event) ;
 938         }
 939         if ( doResize )
 940         {
 941              MacRepositionScrollBars() ;
 942              wxSize size(m_width, m_height);
 943              wxSizeEvent event(size, m_windowId);
 944              event.SetEventObject(this);
 945              GetEventHandler()->ProcessEvent(event);
 946         }
 947     }
 948
 949 }
 950
 951 /*
 952  * Invalidation Mechanism
 953  *
 954  * The update mechanism reflects exactely the windows mechanism
 955  * the rect gets added to the window invalidate region, if the eraseBackground flag
 956  * has been true for any part of the update rgn the background is erased in the entire region
 957  * not just in the specified rect.
 958  *
 959  * In order to achive this, we also have an internal m_macNoEraseUpdateRgn, all rects that have
 960  * the eraseBackground flag set to false are also added to this rgn. upon receiving an update event
 961  * the update rgn is compared to the m_macNoEraseUpdateRgn and in case they differ, every window
 962  * will get the eraseBackground event first
 963  */
 964
 965 void wxTopLevelWindowMac::MacInvalidate( const WXRECTPTR rect, bool eraseBackground )
 966 {
 967     GrafPtr formerPort ;
 968     GetPort( &formerPort ) ;
 969     SetPortWindowPort( (WindowRef)m_macWindow ) ;
 970
 971     m_macNeedsErasing |= eraseBackground ;
 972
 973     // if we already know that we will have to erase, there's no need to track the rest
 974     if ( !m_macNeedsErasing)
 975     {
 976         // we end only here if eraseBackground is false
 977         // if we already have a difference between m_macNoEraseUpdateRgn and UpdateRgn
 978         // we will have to erase anyway
 979
 980         RgnHandle       updateRgn = NewRgn();
 981         RgnHandle       diffRgn = NewRgn() ;
 982         if ( updateRgn && diffRgn )
 983         {
 984             GetWindowUpdateRgn( (WindowRef)m_macWindow , updateRgn );
 985             Point pt = {0,0} ;
 986             LocalToGlobal( &pt ) ;
 987             OffsetRgn( updateRgn , -pt.h , -pt.v ) ;
 988             DiffRgn( updateRgn , (RgnHandle) m_macNoEraseUpdateRgn , diffRgn ) ;
 989             if ( !EmptyRgn( diffRgn ) )
 990             {
 991                 m_macNeedsErasing = true ;
 992             }
 993         }
 994         if ( updateRgn )
 995             DisposeRgn( updateRgn );
 996         if ( diffRgn )
 997             DisposeRgn( diffRgn );
 998
 999         if ( !m_macNeedsErasing )
1000         {
1001             RgnHandle rectRgn = NewRgn() ;
1002             SetRectRgn( rectRgn , ((Rect*)rect)->left , ((Rect*)rect)->top , ((Rect*)rect)->right , ((Rect*)rect)->bottom ) ;
1003             UnionRgn( (RgnHandle) m_macNoEraseUpdateRgn , rectRgn , (RgnHandle) m_macNoEraseUpdateRgn ) ;
1004             DisposeRgn( rectRgn ) ;
1005         }
1006     }
1007     InvalWindowRect( (WindowRef)m_macWindow , (Rect*)rect ) ;
1008     // turn this on to debug the refreshing cycle
1009 #if wxMAC_DEBUG_REDRAW
1010     PaintRect( rect ) ;
1011 #endif
1012     SetPort( formerPort ) ;
1013 }
1014
1015 bool wxTopLevelWindowMac::SetShape(const wxRegion& region)
1016 {
1017     return FALSE;
1018 }