src/mac/carbon/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 license
  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, "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         if ( HasFlag( wxDIALOG_MODAL ) )
 561         {
 562             wclass = kDocumentWindowClass ; // kMovableModalWindowClass ;
 563         }
 564         else
 565         {
 566             wclass = kDocumentWindowClass ;
 567         }
 568     }
 569     else
 570     {
 571         if ( HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) ||
 572              HasFlag( wxSYSTEM_MENU ) )
 573         {
 574             wclass = kDocumentWindowClass ;
 575         }
 576         else
 577         {
 578 #if TARGET_CARBON
 579             wclass = kPlainWindowClass ;
 580 #else
 581             wclass = kModalWindowClass ;
 582 #endif
 583         }
 584     }
 585
 586     if ( HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) )
 587     {
 588         attr |= kWindowFullZoomAttribute ;
 589         attr |= kWindowCollapseBoxAttribute ;
 590     }
 591     if ( HasFlag( wxRESIZE_BORDER ) )
 592     {
 593         attr |= kWindowResizableAttribute ;
 594     }
 595     if ( HasFlag( wxSYSTEM_MENU ) )
 596     {
 597         attr |= kWindowCloseBoxAttribute ;
 598     }
 599
 600     ::CreateNewWindow( wclass , attr , &theBoundsRect , (WindowRef*)&m_macWindow ) ;
 601     wxAssociateWinWithMacWindow( m_macWindow , this ) ;
 602     wxString label ;
 603     if( wxApp::s_macDefaultEncodingIsPC )
 604         label = wxMacMakeMacStringFromPC( title ) ;
 605     else
 606         label = title ;
 607     UMASetWTitleC( (WindowRef)m_macWindow , label ) ;
 608     ::CreateRootControl( (WindowRef)m_macWindow , (ControlHandle*)&m_macRootControl ) ;
 609 #if TARGET_CARBON
 610         InstallStandardEventHandler( GetWindowEventTarget(MAC_WXHWND(m_macWindow)) ) ;
 611         InstallWindowEventHandler(MAC_WXHWND(m_macWindow), GetwxMacWindowEventHandlerUPP(),
 612                 GetEventTypeCount(eventList), eventList, this, &((EventHandlerRef)m_macEventHandler));
 613 #endif
 614     m_macFocus = NULL ;
 615 }
 616
 617 void wxTopLevelWindowMac::MacGetPortParams(WXPOINTPTR localOrigin, WXRECTPTR clipRect, WXHWND *window  , wxWindowMac** rootwin)
 618 {
 619     ((Point*)localOrigin)->h = 0;
 620     ((Point*)localOrigin)->v = 0;
 621     ((Rect*)clipRect)->left = 0;
 622     ((Rect*)clipRect)->top = 0;
 623     ((Rect*)clipRect)->right = m_width;
 624     ((Rect*)clipRect)->bottom = m_height;
 625     *window = m_macWindow ;
 626     *rootwin = this ;
 627 }
 628
 629 void wxTopLevelWindowMac::Clear()
 630 {
 631   wxWindow::Clear() ;
 632 }
 633
 634 WXWidget wxTopLevelWindowMac::MacGetContainerForEmbedding()
 635 {
 636     return m_macRootControl ;
 637 }
 638
 639
 640 void wxTopLevelWindowMac::MacUpdate( long timestamp)
 641 {
 642
 643     wxMacPortStateHelper help( (GrafPtr) GetWindowPort( (WindowRef) m_macWindow) ) ;
 644
 645     BeginUpdate( (WindowRef)m_macWindow ) ;
 646
 647     RgnHandle       updateRgn = NewRgn();
 648     RgnHandle       diffRgn = NewRgn() ;
 649     if ( updateRgn && diffRgn )
 650     {
 651         GetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), updateRgn );
 652         DiffRgn( updateRgn , (RgnHandle) m_macNoEraseUpdateRgn , diffRgn ) ;
 653         if ( !EmptyRgn( updateRgn ) )
 654         {
 655             MacRedraw( updateRgn , timestamp , m_macNeedsErasing || !EmptyRgn( diffRgn )  ) ;
 656         }
 657     }
 658     if ( updateRgn )
 659         DisposeRgn( updateRgn );
 660     if ( diffRgn )
 661         DisposeRgn( diffRgn );
 662     EndUpdate( (WindowRef)m_macWindow ) ;
 663     SetEmptyRgn( (RgnHandle) m_macNoEraseUpdateRgn ) ;
 664     m_macNeedsErasing = false ;
 665 }
 666
 667
 668 // Raise the window to the top of the Z order
 669 void wxTopLevelWindowMac::Raise()
 670 {
 671     ::SelectWindow( (WindowRef)m_macWindow ) ;
 672 }
 673
 674 // Lower the window to the bottom of the Z order
 675 void wxTopLevelWindowMac::Lower()
 676 {
 677     ::SendBehind( (WindowRef)m_macWindow , NULL ) ;
 678 }
 679
 680 void wxTopLevelWindowMac::MacFireMouseEvent(
 681         wxUint16 kind , wxInt32 x , wxInt32 y ,wxUint32 modifiers , long timestamp )
 682 {
 683     wxMouseEvent event(wxEVT_LEFT_DOWN);
 684     bool isDown = !(modifiers & btnState) ; // 1 is for up
 685     bool controlDown = modifiers & controlKey ; // for simulating right mouse
 686
 687     event.m_leftDown = isDown && !controlDown;
 688
 689     event.m_middleDown = FALSE;
 690     event.m_rightDown = isDown && controlDown;
 691
 692     if ( kind == mouseDown )
 693     {
 694         if ( controlDown )
 695             event.SetEventType(wxEVT_RIGHT_DOWN ) ;
 696         else
 697             event.SetEventType(wxEVT_LEFT_DOWN ) ;
 698     }
 699     else if ( kind == mouseUp )
 700     {
 701         if ( controlDown )
 702             event.SetEventType(wxEVT_RIGHT_UP ) ;
 703         else
 704             event.SetEventType(wxEVT_LEFT_UP ) ;
 705     }
 706     else
 707     {
 708         event.SetEventType(wxEVT_MOTION ) ;
 709     }
 710
 711     event.m_shiftDown = modifiers & shiftKey;
 712     event.m_controlDown = modifiers & controlKey;
 713     event.m_altDown = modifiers & optionKey;
 714     event.m_metaDown = modifiers & cmdKey;
 715
 716     Point       localwhere ;
 717     localwhere.h = x ;
 718     localwhere.v = y ;
 719
 720     GrafPtr     port ;
 721     ::GetPort( &port ) ;
 722     ::SetPort( UMAGetWindowPort( (WindowRef)m_macWindow ) ) ;
 723     ::GlobalToLocal( &localwhere ) ;
 724     ::SetPort( port ) ;
 725
 726     if ( kind == mouseDown )
 727     {
 728         if ( timestamp - gs_lastWhen <= GetDblTime() )
 729         {
 730             if ( abs( localwhere.h - gs_lastWhere.h ) < 3 && abs( localwhere.v - gs_lastWhere.v ) < 3 )
 731             {
 732                 // This is not right if the second mouse down
 733                 // event occured in a differen window. We
 734                 // correct this in MacDispatchMouseEvent.
 735                 if ( controlDown )
 736                     event.SetEventType(wxEVT_RIGHT_DCLICK ) ;
 737                 else
 738                     event.SetEventType(wxEVT_LEFT_DCLICK ) ;
 739             }
 740             gs_lastWhen = 0 ;
 741         }
 742         else
 743         {
 744             gs_lastWhen = timestamp ;
 745         }
 746         gs_lastWhere = localwhere ;
 747     }
 748
 749     event.m_x = localwhere.h;
 750     event.m_y = localwhere.v;
 751     event.m_x += m_x;
 752     event.m_y += m_y;
 753
 754     event.m_timeStamp = timestamp;
 755     event.SetEventObject(this);
 756     if ( wxTheApp->s_captureWindow )
 757     {
 758         int x = event.m_x ;
 759         int y = event.m_y ;
 760         wxTheApp->s_captureWindow->ScreenToClient( &x , &y ) ;
 761         event.m_x = x ;
 762         event.m_y = y ;
 763         event.SetEventObject( wxTheApp->s_captureWindow ) ;
 764         wxTheApp->s_captureWindow->GetEventHandler()->ProcessEvent( event ) ;
 765
 766         if ( kind == mouseUp )
 767         {
 768             wxTheApp->s_captureWindow = NULL ;
 769             if ( !wxIsBusy() )
 770             {
 771                 m_cursor.MacInstall() ;
 772             }
 773         }
 774     }
 775     else
 776     {
 777         MacDispatchMouseEvent( event ) ;
 778     }
 779 }
 780 #if !TARGET_CARBON
 781
 782 void wxTopLevelWindowMac::MacMouseDown( WXEVENTREF ev , short part)
 783 {
 784     MacFireMouseEvent( mouseDown , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
 785         ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
 786 }
 787
 788 void wxTopLevelWindowMac::MacMouseUp( WXEVENTREF ev , short part)
 789 {
 790     switch (part)
 791     {
 792         case inContent:
 793             {
 794                             MacFireMouseEvent( mouseUp , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
 795                                 ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
 796             }
 797             break ;
 798     }
 799 }
 800
 801 void wxTopLevelWindowMac::MacMouseMoved( WXEVENTREF ev , short part)
 802 {
 803     switch (part)
 804     {
 805         case inContent:
 806             {
 807                             MacFireMouseEvent( nullEvent /*moved*/ , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
 808                                 ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
 809             }
 810             break ;
 811     }
 812 }
 813
 814 #endif
 815
 816 void wxTopLevelWindowMac::MacActivate( long timestamp , bool inIsActivating )
 817 {
 818     wxActivateEvent event(wxEVT_ACTIVATE, inIsActivating , m_windowId);
 819     event.m_timeStamp = timestamp ;
 820     event.SetEventObject(this);
 821
 822     GetEventHandler()->ProcessEvent(event);
 823
 824     UMAHighlightAndActivateWindow( (WindowRef)m_macWindow , inIsActivating ) ;
 825
 826     // Early versions of MacOS X don't refresh backgrounds properly,
 827     // so refresh the whole window on activation and deactivation.
 828     long osVersion = UMAGetSystemVersion();
 829     if (osVersion >= 0x1000 && osVersion < 0x1020)
 830         Refresh(TRUE);
 831     else
 832         MacSuperEnabled( inIsActivating ) ;
 833 }
 834
 835 #if !TARGET_CARBON
 836
 837 void wxTopLevelWindowMac::MacKeyDown( WXEVENTREF ev )
 838 {
 839 }
 840
 841 #endif
 842
 843 void wxTopLevelWindowMac::SetTitle(const wxString& title)
 844 {
 845     wxWindow::SetTitle( title ) ;
 846
 847     wxString label ;
 848
 849     if( wxApp::s_macDefaultEncodingIsPC )
 850         label = wxMacMakeMacStringFromPC( m_label ) ;
 851     else
 852         label = m_label ;
 853
 854     UMASetWTitleC( (WindowRef)m_macWindow , label ) ;
 855 }
 856
 857 bool wxTopLevelWindowMac::Show(bool show)
 858 {
 859     if ( !wxWindow::Show(show) )
 860         return FALSE;
 861
 862     if (show)
 863     {
 864       ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowShowTransitionAction,nil);
 865       ::SelectWindow( (WindowRef)m_macWindow ) ;
 866       // no need to generate events here, they will get them triggered by macos
 867       // actually they should be , but apparently they are not
 868       wxSize size(m_width, m_height);
 869       wxSizeEvent event(size, m_windowId);
 870       event.SetEventObject(this);
 871       GetEventHandler()->ProcessEvent(event);
 872     }
 873     else
 874     {
 875       ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowHideTransitionAction,nil);
 876     }
 877
 878     if ( !show )
 879     {
 880     }
 881     else
 882     {
 883         Refresh() ;
 884     }
 885
 886     return TRUE;
 887 }
 888
 889 void wxTopLevelWindowMac::DoMoveWindow(int x, int y, int width, int height)
 890 {
 891     int former_x = m_x ;
 892     int former_y = m_y ;
 893     int former_w = m_width ;
 894     int former_h = m_height ;
 895
 896   int actualWidth = width;
 897   int actualHeight = height;
 898   int actualX = x;
 899   int actualY = y;
 900
 901     if ((m_minWidth != -1) && (actualWidth < m_minWidth))
 902         actualWidth = m_minWidth;
 903     if ((m_minHeight != -1) && (actualHeight < m_minHeight))
 904         actualHeight = m_minHeight;
 905     if ((m_maxWidth != -1) && (actualWidth > m_maxWidth))
 906         actualWidth = m_maxWidth;
 907     if ((m_maxHeight != -1) && (actualHeight > m_maxHeight))
 908         actualHeight = m_maxHeight;
 909
 910     bool doMove = false ;
 911     bool doResize = false ;
 912
 913     if ( actualX != former_x || actualY != former_y )
 914     {
 915         doMove = true ;
 916     }
 917     if ( actualWidth != former_w || actualHeight != former_h )
 918     {
 919         doResize = true ;
 920     }
 921
 922     if ( doMove || doResize )
 923     {
 924         m_x = actualX ;
 925         m_y = actualY ;
 926         m_width = actualWidth ;
 927         m_height = actualHeight ;
 928
 929         if ( doMove )
 930             ::MoveWindow((WindowRef)m_macWindow, m_x, m_y  , false); // don't make frontmost
 931
 932         if ( doResize )
 933             ::SizeWindow((WindowRef)m_macWindow, m_width, m_height  , true);
 934
 935         // the OS takes care of invalidating and erasing the new area so we only have to
 936         // take care of refreshing for full repaints
 937
 938         if ( doResize && !HasFlag(wxNO_FULL_REPAINT_ON_RESIZE) )
 939             Refresh() ;
 940
 941
 942         if ( IsKindOf( CLASSINFO( wxFrame ) ) )
 943         {
 944             wxFrame* frame = (wxFrame*) this ;
 945             frame->PositionStatusBar();
 946             frame->PositionToolBar();
 947         }
 948         if ( doMove )
 949             wxWindowMac::MacTopLevelWindowChangedPosition() ; // like this only children will be notified
 950
 951         MacRepositionScrollBars() ;
 952         if ( doMove )
 953         {
 954             wxPoint point(m_x, m_y);
 955             wxMoveEvent event(point, m_windowId);
 956             event.SetEventObject(this);
 957             GetEventHandler()->ProcessEvent(event) ;
 958         }
 959         if ( doResize )
 960         {
 961              MacRepositionScrollBars() ;
 962              wxSize size(m_width, m_height);
 963              wxSizeEvent event(size, m_windowId);
 964              event.SetEventObject(this);
 965              GetEventHandler()->ProcessEvent(event);
 966         }
 967     }
 968
 969 }
 970
 971 /*
 972  * Invalidation Mechanism
 973  *
 974  * The update mechanism reflects exactely the windows mechanism
 975  * the rect gets added to the window invalidate region, if the eraseBackground flag
 976  * has been true for any part of the update rgn the background is erased in the entire region
 977  * not just in the specified rect.
 978  *
 979  * In order to achive this, we also have an internal m_macNoEraseUpdateRgn, all rects that have
 980  * the eraseBackground flag set to false are also added to this rgn. upon receiving an update event
 981  * the update rgn is compared to the m_macNoEraseUpdateRgn and in case they differ, every window
 982  * will get the eraseBackground event first
 983  */
 984
 985 void wxTopLevelWindowMac::MacInvalidate( const WXRECTPTR rect, bool eraseBackground )
 986 {
 987   GrafPtr formerPort ;
 988   GetPort( &formerPort ) ;
 989   SetPortWindowPort( (WindowRef)m_macWindow ) ;
 990
 991   m_macNeedsErasing |= eraseBackground ;
 992
 993   // if we already know that we will have to erase, there's no need to track the rest
 994   if ( !m_macNeedsErasing)
 995   {
 996     // we end only here if eraseBackground is false
 997     // if we already have a difference between m_macNoEraseUpdateRgn and UpdateRgn
 998     // we will have to erase anyway
 999
1000     RgnHandle       updateRgn = NewRgn();
1001     RgnHandle       diffRgn = NewRgn() ;
1002     if ( updateRgn && diffRgn )
1003     {
1004         GetWindowUpdateRgn( (WindowRef)m_macWindow , updateRgn );
1005         Point pt = {0,0} ;
1006         LocalToGlobal( &pt ) ;
1007         OffsetRgn( updateRgn , -pt.h , -pt.v ) ;
1008         DiffRgn( updateRgn , (RgnHandle) m_macNoEraseUpdateRgn , diffRgn ) ;
1009         if ( !EmptyRgn( diffRgn ) )
1010         {
1011             m_macNeedsErasing = true ;
1012         }
1013     }
1014     if ( updateRgn )
1015         DisposeRgn( updateRgn );
1016     if ( diffRgn )
1017         DisposeRgn( diffRgn );
1018
1019     if ( !m_macNeedsErasing )
1020     {
1021       RgnHandle rectRgn = NewRgn() ;
1022       SetRectRgn( rectRgn , ((Rect*)rect)->left , ((Rect*)rect)->top , ((Rect*)rect)->right , ((Rect*)rect)->bottom ) ;
1023       UnionRgn( (RgnHandle) m_macNoEraseUpdateRgn , rectRgn , (RgnHandle) m_macNoEraseUpdateRgn ) ;
1024       DisposeRgn( rectRgn ) ;
1025     }
1026   }
1027   InvalWindowRect( (WindowRef)m_macWindow , (Rect*)rect ) ;
1028   // turn this on to debug the refreshing cycle
1029 #if wxMAC_DEBUG_REDRAW
1030   PaintRect( rect ) ;
1031 #endif
1032   SetPort( formerPort ) ;
1033 }
1034