don't show the accels on the controls if the system is configured to hide them initia...

[wxWidgets.git] / src / mac / toplevel.cpp

diff --git a/src/mac/toplevel.cpp b/src/mac/toplevel.cpp
index 92cbb42606b862f0df376f26ff603017e9ecc485..31cdcb791300aae2b2dbca5573377545a77f68fa 100644 (file)
--- a/src/mac/toplevel.cpp
+++ b/src/mac/toplevel.cpp
@@ -1,11 +1,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        mac/toplevel.cpp
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        mac/toplevel.cpp

-// Purpose:     implements wxTopLevelWindow for MSW
-// Author:      Vadim Zeitlin
+// Purpose:     implements wxTopLevelWindow for Mac
+// Author:      Stefan Csomor

 // Modified by:
 // Created:     24.09.01
 // RCS-ID:      $Id$
 // Modified by:
 // Created:     24.09.01
 // RCS-ID:      $Id$

-// Copyright:   (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
+// Copyright:   (c) 2001-2004 Stefan Csomor

 // License:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // License:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 


@@ -42,6 +42,9 @@
 #include "wx/app.h"
 #include "wx/tooltip.h"
 #include "wx/dnd.h"
 #include "wx/app.h"
 #include "wx/tooltip.h"
 #include "wx/dnd.h"

+#if wxUSE_SYSTEM_OPTIONS
+    #include "wx/sysopt.h"
+#endif

 
 #include "ToolUtils.h"
 
 
 #include "ToolUtils.h"
 


@@ -97,6 +100,7 @@ static const EventTypeSpec eventList[] =
 
     { kEventClassMouse , kEventMouseDown } ,
     { kEventClassMouse , kEventMouseUp } ,
 
     { kEventClassMouse , kEventMouseDown } ,
     { kEventClassMouse , kEventMouseUp } ,

+    { kEventClassMouse , kEventMouseWheelMoved } ,

     { kEventClassMouse , kEventMouseMoved } ,
     { kEventClassMouse , kEventMouseDragged } ,
 
     { kEventClassMouse , kEventMouseMoved } ,
     { kEventClassMouse , kEventMouseDragged } ,
 


@@ -111,7 +115,6 @@ static pascal OSStatus TextInputEventHandler( EventHandlerCallRef handler , Even
     UInt32 keyCode ;
     UInt32 modifiers ;
     Point point ;
     UInt32 keyCode ;
     UInt32 modifiers ;
     Point point ;

-    UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;

 
     EventRef rawEvent ;
 
 
     EventRef rawEvent ;
 


@@ -123,16 +126,32 @@ static pascal OSStatus TextInputEventHandler( EventHandlerCallRef handler , Even
     GetEventParameter( rawEvent, kEventParamMouseLocation, typeQDPoint, NULL,
         sizeof( Point ), NULL, &point );
 
     GetEventParameter( rawEvent, kEventParamMouseLocation, typeQDPoint, NULL,
         sizeof( Point ), NULL, &point );
 

-    UInt32 message = (keyCode << 8) + charCode;
-

     switch ( GetEventKind( event ) )
     {
         case kEventTextInputUnicodeForKeyEvent :
     switch ( GetEventKind( event ) )
     {
         case kEventTextInputUnicodeForKeyEvent :

+            // this is only called when no default handler has jumped in, eg a wxControl on a floater window does not
+            // get its own kEventTextInputUnicodeForKeyEvent, so we route back the
+            wxControl* control = wxDynamicCast( focus , wxControl ) ;
+            if ( control )
+            {
+                ControlHandle macControl = (ControlHandle) control->GetMacControl() ;
+                if ( macControl )
+                {
+                    ::HandleControlKey( macControl , keyCode , charCode , modifiers ) ;
+                    result = noErr ;
+                }
+            }
+            /*
+            // this may lead to double events sent to a window in case all handlers have skipped the key down event
+            UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
+            UInt32 message = (keyCode << 8) + charCode;
+

             if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
                 focus , message , modifiers , when , point.h , point.v ) )
             {
                 result = noErr ;
             }
             if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
                 focus , message , modifiers , when , point.h , point.v ) )
             {
                 result = noErr ;
             }

+            */

             break ;
     }
 
             break ;
     }
 


@@ -161,10 +180,16 @@ static pascal OSStatus KeyboardEventHandler( EventHandlerCallRef handler , Event
     {
         case kEventRawKeyRepeat :
         case kEventRawKeyDown :
     {
         case kEventRawKeyRepeat :
         case kEventRawKeyDown :

-            if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
-                focus , message , modifiers , when , point.h , point.v ) )

             {
             {

-                result = noErr ;
+                WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
+                WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
+                wxTheApp->MacSetCurrentEvent( event , handler ) ;
+                if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
+                    focus , message , modifiers , when , point.h , point.v ) )
+                {
+                    result = noErr ;
+                }
+                wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;

             }
             break ;
         case kEventRawKeyUp :
             }
             break ;
         case kEventRawKeyUp :


@@ -207,6 +232,12 @@ static pascal OSStatus KeyboardEventHandler( EventHandlerCallRef handler , Event
                     event.SetEventType( ( modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
                     focus->GetEventHandler()->ProcessEvent( event ) ;
                 }
                     event.SetEventType( ( modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
                     focus->GetEventHandler()->ProcessEvent( event ) ;
                 }

+                if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & cmdKey )
+                {
+                    event.m_keyCode = WXK_COMMAND ;
+                    event.SetEventType( ( modifiers & cmdKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
+                    focus->GetEventHandler()->ProcessEvent( event ) ;
+                }

                 wxTheApp->s_lastModifiers = modifiers ;
             }
              break ;
                 wxTheApp->s_lastModifiers = modifiers ;
             }
              break ;


@@ -215,7 +246,7 @@ static pascal OSStatus KeyboardEventHandler( EventHandlerCallRef handler , Event
     return result ;
 }
 
     return result ;
 }
 

-static pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef event , void *data )

 {
     OSStatus result = eventNotHandledErr ;
 
 {
     OSStatus result = eventNotHandledErr ;
 


@@ -237,10 +268,18 @@ static pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef
     if ( button == 0 || GetEventKind( event ) == kEventMouseUp )
         modifiers += btnState ;
 
     if ( button == 0 || GetEventKind( event ) == kEventMouseUp )
         modifiers += btnState ;
 

+       // temporary hack to support true two button mouse
+       if ( button == kEventMouseButtonSecondary )
+       {
+               modifiers |= controlKey ;
+       }

     WindowRef window ;
     short windowPart = ::FindWindow(point, &window);
 
     WindowRef window ;
     short windowPart = ::FindWindow(point, &window);
 

-    if ( IsWindowActive(window) && windowPart == inContent )
+    // either we really are active or we are capturing mouse events
+
+    if ( (IsWindowActive(window) && windowPart == inContent) || 
+        (wxTheApp->s_captureWindow && wxTheApp->s_captureWindow->MacGetTopLevelWindow() == toplevelWindow) )

     {
         switch ( GetEventKind( event ) )
         {
     {
         switch ( GetEventKind( event ) )
         {


@@ -253,13 +292,46 @@ static pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef
                 result = noErr ;
                 break ;
             case kEventMouseMoved :
                 result = noErr ;
                 break ;
             case kEventMouseMoved :

-                toplevelWindow->MacFireMouseEvent( nullEvent , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
+                wxTheApp->MacHandleMouseMovedEvent( point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;

                 result = noErr ;
                 break ;
             case kEventMouseDragged :
                 toplevelWindow->MacFireMouseEvent( nullEvent , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
                 result = noErr ;
                 break ;
                 result = noErr ;
                 break ;
             case kEventMouseDragged :
                 toplevelWindow->MacFireMouseEvent( nullEvent , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
                 result = noErr ;
                 break ;

+            case kEventMouseWheelMoved :
+                {
+                    //bClearTooltip = false;
+                    EventMouseWheelAxis axis = kEventMouseWheelAxisY;
+                    SInt32 delta = 0;
+                    Point mouseLoc = {0, 0};
+                    if (::GetEventParameter(event, kEventParamMouseWheelAxis, typeMouseWheelAxis,
+                                        NULL, sizeof(EventMouseWheelAxis), NULL, &axis) == noErr &&
+                        ::GetEventParameter(event, kEventParamMouseWheelDelta, typeLongInteger,
+                                        NULL, sizeof(SInt32), NULL, &delta) == noErr &&
+                        ::GetEventParameter(event, kEventParamMouseLocation, typeQDPoint,
+                                        NULL, sizeof(Point), NULL, &mouseLoc) == noErr)
+                    {
+                        wxMouseEvent wheelEvent(wxEVT_MOUSEWHEEL);
+                       
+                        wheelEvent.m_x = mouseLoc.h;
+                        wheelEvent.m_y = mouseLoc.v;
+                       
+                        wheelEvent.m_wheelRotation = delta;
+                        wheelEvent.m_wheelDelta = 1;
+                        wheelEvent.m_linesPerAction = 1;
+
+                        wxWindow* currentMouseWindow = NULL;
+                        wxWindow::MacGetWindowFromPoint(wxPoint(mouseLoc.h, mouseLoc.v), &currentMouseWindow);
+                       
+                        if (currentMouseWindow)
+                        {
+                            currentMouseWindow->GetEventHandler()->ProcessEvent(wheelEvent);
+                            result = noErr;
+                        }
+                    }
+                }
+                break ;

             default :
                 break ;
         }
             default :
                 break ;
         }


@@ -317,6 +389,40 @@ static pascal OSStatus WindowEventHandler( EventHandlerCallRef handler , EventRe
                 result = noErr;
             }
             break ;
                 result = noErr;
             }
             break ;

+        case kEventWindowBoundsChanging :
+            err = GetEventParameter( event, kEventParamAttributes, typeUInt32,
+                        NULL, sizeof( UInt32 ), NULL, &attributes );
+            if ( err == noErr )
+            {
+                Rect newContentRect ;
+
+                GetEventParameter( event, kEventParamCurrentBounds, typeQDRectangle, NULL,
+                    sizeof( newContentRect ), NULL, &newContentRect );
+
+                wxSize formerSize = toplevelWindow->GetSize() ;
+
+                if ( (attributes & kWindowBoundsChangeSizeChanged ) || 
+                    ( attributes & kWindowBoundsChangeOriginChanged ) )
+                    toplevelWindow->SetSize( newContentRect.left , newContentRect.top ,
+                        newContentRect.right - newContentRect.left ,
+                        newContentRect.bottom - newContentRect.top, wxSIZE_USE_EXISTING);
+    
+                int x , y , w , h ;
+                toplevelWindow->GetPosition( &x , &y ) ;
+                toplevelWindow->GetSize( &w , &h ) ;
+                Rect adjustedRect  = { y , x , y + h , x + w } ;
+
+                if ( !EqualRect( &newContentRect , &adjustedRect ) )
+                {
+                    SetEventParameter( event , kEventParamCurrentBounds , typeQDRectangle, sizeof( adjustedRect ) , &adjustedRect ) ;
+                }
+                
+                if ( toplevelWindow->GetSize() != formerSize )
+                    toplevelWindow->Update() ;
+        
+                result = noErr ;
+            }
+            break ;

         default :
             break ;
     }
         default :
             break ;
     }


@@ -360,6 +466,8 @@ DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacWindowEventHandler )
 wxList *wxWinMacWindowList = NULL;
 wxTopLevelWindowMac *wxFindWinFromMacWindow(WXWindow inWindowRef)
 {
 wxList *wxWinMacWindowList = NULL;
 wxTopLevelWindowMac *wxFindWinFromMacWindow(WXWindow inWindowRef)
 {

+    if ( wxWinMacWindowList == NULL )
+        return NULL ;

     wxNode *node = wxWinMacWindowList->Find((long)inWindowRef);
     if (!node)
         return NULL;
     wxNode *node = wxWinMacWindowList->Find((long)inWindowRef);
     if (!node)
         return NULL;


@@ -387,6 +495,8 @@ void wxRemoveMacWindowAssociation(wxTopLevelWindowMac *win)
 // ----------------------------------------------------------------------------
 
 WXHWND wxTopLevelWindowMac::s_macWindowInUpdate = NULL;
 // ----------------------------------------------------------------------------
 
 WXHWND wxTopLevelWindowMac::s_macWindowInUpdate = NULL;

+wxTopLevelWindowMac *wxTopLevelWindowMac::s_macDeactivateWindow = NULL;
+bool wxTopLevelWindowMac::s_macWindowCompositing = FALSE;

 
 void wxTopLevelWindowMac::Init()
 {
 
 void wxTopLevelWindowMac::Init()
 {


@@ -395,6 +505,7 @@ void wxTopLevelWindowMac::Init()
     m_macNoEraseUpdateRgn = NewRgn() ;
     m_macNeedsErasing = false ;
     m_macWindow = NULL ;
     m_macNoEraseUpdateRgn = NewRgn() ;
     m_macNeedsErasing = false ;
     m_macWindow = NULL ;

+    m_macUsesCompositing = FALSE ;

 #if TARGET_CARBON
     m_macEventHandler = NULL ;
  #endif
 #if TARGET_CARBON
     m_macEventHandler = NULL ;
  #endif


@@ -471,23 +582,37 @@ wxTopLevelWindowMac::~wxTopLevelWindowMac()
 
 void wxTopLevelWindowMac::Maximize(bool maximize)
 {
 
 void wxTopLevelWindowMac::Maximize(bool maximize)
 {

-    // not available on mac
+    wxMacPortStateHelper help( (GrafPtr) GetWindowPort( (WindowRef) m_macWindow) ) ;
+    wxMacWindowClipper clip (this);
+    ZoomWindow( (WindowRef)m_macWindow , maximize ? inZoomOut : inZoomIn , false ) ;
+
+    Rect tempRect ;
+    GrafPtr port ;
+    GetPort( &port ) ;
+    Point pt = { 0, 0 } ;
+    SetPortWindowPort((WindowRef)m_macWindow) ;
+    LocalToGlobal( &pt ) ;
+    SetPort( port ) ;
+
+    GetWindowPortBounds((WindowRef)m_macWindow, &tempRect ) ;
+    SetSize( pt.h , pt.v , tempRect.right-tempRect.left ,
+        tempRect.bottom-tempRect.top, wxSIZE_USE_EXISTING);

 }
 
 bool wxTopLevelWindowMac::IsMaximized() const
 {
 }
 
 bool wxTopLevelWindowMac::IsMaximized() const
 {

-    return false ;
+    return IsWindowInStandardState(  (WindowRef)m_macWindow , NULL , NULL ) ;

 }
 
 void wxTopLevelWindowMac::Iconize(bool iconize)
 {
 }
 
 void wxTopLevelWindowMac::Iconize(bool iconize)
 {

-    // not available on mac
+    if ( IsWindowCollapsable((WindowRef)m_macWindow) )
+        CollapseWindow((WindowRef)m_macWindow , iconize ) ;

 }
 
 bool wxTopLevelWindowMac::IsIconized() const
 {
 }
 
 bool wxTopLevelWindowMac::IsIconized() const
 {

-    // mac dialogs cannot be iconized
-    return FALSE;
+    return IsWindowCollapsed((WindowRef)m_macWindow ) ;

 }
 
 void wxTopLevelWindowMac::Restore()
 }
 
 void wxTopLevelWindowMac::Restore()


@@ -511,6 +636,7 @@ void  wxTopLevelWindowMac::MacCreateRealWindow( const wxString& title,
            long style,
            const wxString& name )
 {
            long style,
            const wxString& name )
 {

+    OSStatus err = noErr ;

     SetName(name);
     m_windowStyle = style;
     m_isShown = FALSE;
     SetName(name);
     m_windowStyle = style;
     m_isShown = FALSE;


@@ -570,7 +696,7 @@ void  wxTopLevelWindowMac::MacCreateRealWindow( const wxString& title,
     else
     {
         if ( HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) ||
     else
     {
         if ( HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) ||

-            HasFlag( wxSYSTEM_MENU ) )
+            HasFlag( wxCLOSE_BOX ) || HasFlag( wxSYSTEM_MENU ) )

         {
             wclass = kDocumentWindowClass ;
         }
         {
             wclass = kDocumentWindowClass ;
         }


@@ -584,27 +710,51 @@ void  wxTopLevelWindowMac::MacCreateRealWindow( const wxString& title,
         }
     }
 
         }
     }
 

-    if ( HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) )
+    if ( HasFlag( wxMINIMIZE_BOX ) )

     {
     {

-        attr |= kWindowFullZoomAttribute ;

         attr |= kWindowCollapseBoxAttribute ;
     }
         attr |= kWindowCollapseBoxAttribute ;
     }

+    if ( HasFlag( wxMAXIMIZE_BOX ) )
+    {
+        attr |= kWindowFullZoomAttribute ;
+    }

     if ( HasFlag( wxRESIZE_BORDER ) )
     {
         attr |= kWindowResizableAttribute ;
     }
     if ( HasFlag( wxRESIZE_BORDER ) )
     {
         attr |= kWindowResizableAttribute ;
     }

-    if ( HasFlag( wxSYSTEM_MENU ) )
+    if ( HasFlag( wxCLOSE_BOX) )

     {
         attr |= kWindowCloseBoxAttribute ;
     }
 
     {
         attr |= kWindowCloseBoxAttribute ;
     }
 

+    if (UMAGetSystemVersion() >= 0x1000)
+    {
+        //turn on live resizing (OS X only)
+        attr |= kWindowLiveResizeAttribute;
+    }
+

 #if TARGET_CARBON
 #if 0 //  having problems right now with that
     if (HasFlag(wxSTAY_ON_TOP))
 #if TARGET_CARBON
 #if 0 //  having problems right now with that
     if (HasFlag(wxSTAY_ON_TOP))

-       wclass = kUtilityWindowClass;
+        wclass = kUtilityWindowClass;

 #endif
 #endif
 
 #endif
 #endif
 

+    //this setup lets us have compositing and non-compositing 
+    //windows in the same application. 
+  
+#if UNIVERSAL_INTERFACES_VERSION >= 0x0400  
+    if ( wxTopLevelWindowMac::s_macWindowCompositing )
+    {
+        attr |= kWindowCompositingAttribute;
+        m_macUsesCompositing = TRUE;
+    }
+    else
+#endif
+    {
+        m_macUsesCompositing = FALSE;
+    }
+    

 #if TARGET_CARBON
     if ( HasFlag(wxFRAME_SHAPED) )
     {
 #if TARGET_CARBON
     if ( HasFlag(wxFRAME_SHAPED) )
     {


@@ -612,23 +762,31 @@ void  wxTopLevelWindowMac::MacCreateRealWindow( const wxString& title,
         customWindowDefSpec.defType = kWindowDefProcPtr;
         customWindowDefSpec.u.defProc = NewWindowDefUPP(wxShapedMacWindowDef);
 
         customWindowDefSpec.defType = kWindowDefProcPtr;
         customWindowDefSpec.u.defProc = NewWindowDefUPP(wxShapedMacWindowDef);
 

-        ::CreateCustomWindow( &customWindowDefSpec, wclass,
+        err = ::CreateCustomWindow( &customWindowDefSpec, wclass,

                               attr, &theBoundsRect,
                               (WindowRef*) &m_macWindow);
     }
     else
 #endif
     {
                               attr, &theBoundsRect,
                               (WindowRef*) &m_macWindow);
     }
     else
 #endif
     {

-        ::CreateNewWindow( wclass , attr , &theBoundsRect , (WindowRef*)&m_macWindow ) ;
+        err = ::CreateNewWindow( wclass , attr , &theBoundsRect , (WindowRef*)&m_macWindow ) ;

     }
 
     }
 

+    wxCHECK_RET( err == noErr, wxT("Mac OS error when trying to create new window") );

     wxAssociateWinWithMacWindow( m_macWindow , this ) ;
     UMASetWTitle( (WindowRef)m_macWindow , title ) ;
     wxAssociateWinWithMacWindow( m_macWindow , this ) ;
     UMASetWTitle( (WindowRef)m_macWindow , title ) ;

-    ::CreateRootControl( (WindowRef)m_macWindow , (ControlHandle*)&m_macRootControl ) ;
+    if ( wxTopLevelWindowMac::s_macWindowCompositing )
+    {
+        ::GetRootControl( (WindowRef)m_macWindow, (ControlHandle*)&m_macRootControl ) ;
+    }
+    else
+    {
+        ::CreateRootControl( (WindowRef)m_macWindow , (ControlHandle*)&m_macRootControl ) ;
+    }

 #if TARGET_CARBON
     InstallStandardEventHandler( GetWindowEventTarget(MAC_WXHWND(m_macWindow)) ) ;
     InstallWindowEventHandler(MAC_WXHWND(m_macWindow), GetwxMacWindowEventHandlerUPP(),
 #if TARGET_CARBON
     InstallStandardEventHandler( GetWindowEventTarget(MAC_WXHWND(m_macWindow)) ) ;
     InstallWindowEventHandler(MAC_WXHWND(m_macWindow), GetwxMacWindowEventHandlerUPP(),

-        GetEventTypeCount(eventList), eventList, this, &((EventHandlerRef)m_macEventHandler));
+        GetEventTypeCount(eventList), eventList, this, (EventHandlerRef *)&m_macEventHandler);

 #endif
     m_macFocus = NULL ;
 
 #endif
     m_macFocus = NULL ;
 


@@ -641,6 +799,16 @@ void  wxTopLevelWindowMac::MacCreateRealWindow( const wxString& title,
         SetShape(rgn);
     }
 #endif
         SetShape(rgn);
     }
 #endif

+
+    wxWindowCreateEvent event(this);
+    GetEventHandler()->ProcessEvent(event);
+}
+
+bool wxTopLevelWindowMac::MacEnableCompositing( bool useCompositing )
+{
+    bool oldval = s_macWindowCompositing;
+    s_macWindowCompositing = useCompositing; 
+    return oldval; 

 }
 
 void wxTopLevelWindowMac::MacGetPortParams(WXPOINTPTR localOrigin, WXRECTPTR clipRect, WXHWND *window  , wxWindowMac** rootwin)
 }
 
 void wxTopLevelWindowMac::MacGetPortParams(WXPOINTPTR localOrigin, WXRECTPTR clipRect, WXHWND *window  , wxWindowMac** rootwin)


@@ -655,9 +823,9 @@ void wxTopLevelWindowMac::MacGetPortParams(WXPOINTPTR localOrigin, WXRECTPTR cli
     *rootwin = this ;
 }
 
     *rootwin = this ;
 }
 

-void wxTopLevelWindowMac::Clear()
+void wxTopLevelWindowMac::ClearBackground()

 {
 {

-    wxWindow::Clear() ;
+    wxWindow::ClearBackground() ;

 }
 
 WXWidget wxTopLevelWindowMac::MacGetContainerForEmbedding()
 }
 
 WXWidget wxTopLevelWindowMac::MacGetContainerForEmbedding()


@@ -708,7 +876,7 @@ void wxTopLevelWindowMac::MacUpdate( long timestamp)
         DisposeRgn( diffRgn );
     if ( visRgn )
         DisposeRgn( visRgn ) ;
         DisposeRgn( diffRgn );
     if ( visRgn )
         DisposeRgn( visRgn ) ;

-        
+

     EndUpdate( (WindowRef)m_macWindow ) ;
     SetEmptyRgn( (RgnHandle) m_macNoEraseUpdateRgn ) ;
     m_macNeedsErasing = false ;
     EndUpdate( (WindowRef)m_macWindow ) ;
     SetEmptyRgn( (RgnHandle) m_macNoEraseUpdateRgn ) ;
     m_macNeedsErasing = false ;


@@ -775,7 +943,7 @@ void wxTopLevelWindowMac::MacFireMouseEvent(
 
     if ( kind == mouseDown )
     {
 
     if ( kind == mouseDown )
     {

-        if ( timestamp - gs_lastWhen <= GetDblTime() )
+        if ( timestamp - gs_lastWhen <= (long) GetDblTime() )

         {
             if ( abs( localwhere.h - gs_lastWhere.h ) < 3 && abs( localwhere.v - gs_lastWhere.v ) < 3 )
             {
         {
             if ( abs( localwhere.h - gs_lastWhere.h ) < 3 && abs( localwhere.v - gs_lastWhere.v ) < 3 )
             {


@@ -864,8 +1032,22 @@ void wxTopLevelWindowMac::MacMouseMoved( WXEVENTREF ev , short part)
 
 #endif
 
 
 #endif
 

+void wxTopLevelWindowMac::MacDelayedDeactivation(long timestamp)
+{
+    if(s_macDeactivateWindow)
+    {
+        wxLogDebug(wxT("Doing delayed deactivation of %p"),s_macDeactivateWindow);
+        s_macDeactivateWindow->MacActivate(timestamp, false);
+    }
+}
+

 void wxTopLevelWindowMac::MacActivate( long timestamp , bool inIsActivating )
 {
 void wxTopLevelWindowMac::MacActivate( long timestamp , bool inIsActivating )
 {

+    // wxLogDebug(wxT("TopLevel=%p::MacActivate"),this);
+
+    if(s_macDeactivateWindow==this)
+        s_macDeactivateWindow=NULL;
+    MacDelayedDeactivation(timestamp);

     wxActivateEvent event(wxEVT_ACTIVATE, inIsActivating , m_windowId);
     event.m_timeStamp = timestamp ;
     event.SetEventObject(this);
     wxActivateEvent event(wxEVT_ACTIVATE, inIsActivating , m_windowId);
     event.m_timeStamp = timestamp ;
     event.SetEventObject(this);


@@ -910,18 +1092,36 @@ bool wxTopLevelWindowMac::Show(bool show)
 
     if (show)
     {
 
     if (show)
     {

-      ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowShowTransitionAction,nil);
-      ::SelectWindow( (WindowRef)m_macWindow ) ;
-      // no need to generate events here, they will get them triggered by macos
-      // actually they should be , but apparently they are not
-      wxSize size(m_width, m_height);
-      wxSizeEvent event(size, m_windowId);
-      event.SetEventObject(this);
-      GetEventHandler()->ProcessEvent(event);
+        #if wxUSE_SYSTEM_OPTIONS       //code contributed by Ryan Wilcox December 18, 2003
+        if ( (wxSystemOptions::HasOption(wxMAC_WINDOW_PLAIN_TRANSITION) ) && ( wxSystemOptions::GetOptionInt( wxMAC_WINDOW_PLAIN_TRANSITION ) == 1) )
+        {
+           ::ShowWindow( (WindowRef)m_macWindow );
+        }
+        else
+        #endif
+        {
+           ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowShowTransitionAction,nil);
+        }
+        ::SelectWindow( (WindowRef)m_macWindow ) ;
+        // no need to generate events here, they will get them triggered by macos
+        // actually they should be , but apparently they are not
+        wxSize size(m_width, m_height);
+        wxSizeEvent event(size, m_windowId);
+        event.SetEventObject(this);
+        GetEventHandler()->ProcessEvent(event);

     }
     else
     {
     }
     else
     {

-      ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowHideTransitionAction,nil);
+        #if wxUSE_SYSTEM_OPTIONS
+        if ( (wxSystemOptions::HasOption(wxMAC_WINDOW_PLAIN_TRANSITION) ) && ( wxSystemOptions::GetOptionInt( wxMAC_WINDOW_PLAIN_TRANSITION ) == 1) )
+        {
+           ::HideWindow((WindowRef) m_macWindow );
+        }
+        else
+        #endif
+        {
+           ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowHideTransitionAction,nil);
+        }

     }
 
     if ( !show )
     }
 
     if ( !show )


@@ -937,6 +1137,9 @@ bool wxTopLevelWindowMac::Show(bool show)
 
 void wxTopLevelWindowMac::DoMoveWindow(int x, int y, int width, int height)
 {
 
 void wxTopLevelWindowMac::DoMoveWindow(int x, int y, int width, int height)
 {

+    wxMacPortStateHelper help( (GrafPtr) GetWindowPort( (WindowRef) m_macWindow) ) ;
+    wxMacWindowClipper clip (this);
+

     int former_x = m_x ;
     int former_y = m_y ;
     int former_w = m_width ;
     int former_x = m_x ;
     int former_y = m_y ;
     int former_w = m_width ;


@@ -972,27 +1175,32 @@ void wxTopLevelWindowMac::DoMoveWindow(int x, int y, int width, int height)
     {
         m_x = actualX ;
         m_y = actualY ;
     {
         m_x = actualX ;
         m_y = actualY ;

-        m_width = actualWidth ;
-        m_height = actualHeight ;

 
         if ( doMove )
             ::MoveWindow((WindowRef)m_macWindow, m_x, m_y  , false); // don't make frontmost
 
 
         if ( doMove )
             ::MoveWindow((WindowRef)m_macWindow, m_x, m_y  , false); // don't make frontmost
 

+        m_width = actualWidth ;
+        m_height = actualHeight ;
+

         if ( doResize )
             ::SizeWindow((WindowRef)m_macWindow, m_width, m_height  , true);
 
         // the OS takes care of invalidating and erasing the new area so we only have to
         // take care of refreshing for full repaints
 
         if ( doResize )
             ::SizeWindow((WindowRef)m_macWindow, m_width, m_height  , true);
 
         // the OS takes care of invalidating and erasing the new area so we only have to
         // take care of refreshing for full repaints
 

-        if ( doResize && !HasFlag(wxNO_FULL_REPAINT_ON_RESIZE) )
+        if ( doResize && HasFlag(wxFULL_REPAINT_ON_RESIZE) )

             Refresh() ;
 
 
         if ( IsKindOf( CLASSINFO( wxFrame ) ) )
         {
             wxFrame* frame = (wxFrame*) this ;
             Refresh() ;
 
 
         if ( IsKindOf( CLASSINFO( wxFrame ) ) )
         {
             wxFrame* frame = (wxFrame*) this ;

+#if wxUSE_STATUSBAR

             frame->PositionStatusBar();
             frame->PositionStatusBar();

+#endif            
+#if wxUSE_TOOLBAR

             frame->PositionToolBar();
             frame->PositionToolBar();

+#endif            

         }
         if ( doMove )
             wxWindowMac::MacTopLevelWindowChangedPosition() ; // like this only children will be notified
         }
         if ( doMove )
             wxWindowMac::MacTopLevelWindowChangedPosition() ; // like this only children will be notified