renamed wxDynamicThisCast to wxDynamicCastThis, removed 1st parameter, and documented

[wxWidgets.git] / src / os2 / frame.cpp

diff --git a/src/os2/frame.cpp b/src/os2/frame.cpp
index 4c0870f57707e00e505a16c977306d67dc44f872..f21c945ae65d5bf4306eaa2cd4eda96dff0edf68 100644 (file)
--- a/src/os2/frame.cpp
+++ b/src/os2/frame.cpp
@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        frame.cpp
 /////////////////////////////////////////////////////////////////////////////
 // Name:        frame.cpp

-// Purpose:     wxFrame
+// Purpose:     wxFrameOS2

 // Author:      David Webster
 // Modified by:
 // Created:     10/27/99
 // Author:      David Webster
 // Modified by:
 // Created:     10/27/99


@@ -63,12 +63,16 @@ extern void  wxAssociateWinWithHandle( HWND      hWnd
 // event tables
 // ----------------------------------------------------------------------------
 
 // event tables
 // ----------------------------------------------------------------------------
 

-BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
-    EVT_ACTIVATE(wxFrame::OnActivate)
-    EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
+BEGIN_EVENT_TABLE(wxFrameOS2, wxFrameBase)
+    EVT_ACTIVATE(wxFrameOS2::OnActivate)
+    EVT_SYS_COLOUR_CHANGED(wxFrameOS2::OnSysColourChanged)

 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 

-IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
+IMPLEMENT_DYNAMIC_CLASS(wxFrameOS2, wxWindow)
+
+#ifndef __WXUNIVERSAL__
+IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxFrameMSW)
+#endif

 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation


@@ -80,9 +84,9 @@ IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
 #if wxUSE_STATUSBAR
 
 #if wxUSE_NATIVE_STATUSBAR
 #if wxUSE_STATUSBAR
 
 #if wxUSE_NATIVE_STATUSBAR

-    bool wxFrame::m_bUseNativeStatusBar = TRUE;
+    bool wxFrameOS2::m_bUseNativeStatusBar = TRUE;

 #else
 #else

-    bool wxFrame::m_bUseNativeStatusBar = FALSE;
+    bool wxFrameOS2::m_bUseNativeStatusBar = FALSE;

 #endif
 
 #endif //wxUSE_STATUSBAR
 #endif
 
 #endif //wxUSE_STATUSBAR


@@ -91,7 +95,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
 // creation/destruction
 // ----------------------------------------------------------------------------
 
 // creation/destruction
 // ----------------------------------------------------------------------------
 

-void wxFrame::Init()
+void wxFrameOS2::Init()

 {
     m_bIconized = FALSE;
 
 {
     m_bIconized = FALSE;
 


@@ -125,9 +129,9 @@ void wxFrame::Init()
     memset(&m_vSwpVScroll, 0, sizeof(SWP));
     memset(&m_vSwpStatusBar, 0, sizeof(SWP));
     memset(&m_vSwpToolBar, 0, sizeof(SWP));
     memset(&m_vSwpVScroll, 0, sizeof(SWP));
     memset(&m_vSwpStatusBar, 0, sizeof(SWP));
     memset(&m_vSwpToolBar, 0, sizeof(SWP));

-} // end of wxFrame::Init
+} // end of wxFrameOS2::Init

 
 

-bool wxFrame::Create(
+bool wxFrameOS2::Create(

   wxWindow*                         pParent
 , wxWindowID                        vId
 , const wxString&                   rsTitle
   wxWindow*                         pParent
 , wxWindowID                        vId
 , const wxString&                   rsTitle


@@ -187,9 +191,9 @@ bool wxFrame::Create(
         wxModelessWindows.Append(this);
     }
     return(bOk);
         wxModelessWindows.Append(this);
     }
     return(bOk);

-} // end of wxFrame::Create
+} // end of wxFrameOS2::Create

 
 

-wxFrame::~wxFrame()
+wxFrameOS2::~wxFrameOS2()

 {
     m_isBeingDeleted = TRUE;
 
 {
     m_isBeingDeleted = TRUE;
 


@@ -231,29 +235,36 @@ wxFrame::~wxFrame()
                              );
         }
     }
                              );
         }
     }

-} // end of wxFrame::~wxFrame
+} // end of wxFrameOS2::~wxFrame

 
 //
 // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
 //
 
 //
 // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
 //

-void wxFrame::DoGetClientSize(
+void wxFrameOS2::DoGetClientSize(

   int*                              pX
 , int*                              pY
 ) const
 {
     RECTL                           vRect;
     ::WinQueryWindowRect(GetHwnd(), &vRect);
   int*                              pX
 , int*                              pY
 ) const
 {
     RECTL                           vRect;
     ::WinQueryWindowRect(GetHwnd(), &vRect);

+
+    //
+    // No need to use statusbar code as in WIN32 as the FORMATFRAME
+    // window procedure ensures PM knows about the new frame client
+    // size internally.  A ::WinQueryWindowRect is all that is needed!
+    //
+

     if (pX)
         *pX = vRect.xRight - vRect.xLeft;
     if (pY)
         *pY = vRect.yTop - vRect.yBottom;
     if (pX)
         *pX = vRect.xRight - vRect.xLeft;
     if (pY)
         *pY = vRect.yTop - vRect.yBottom;

-} // end of wxFrame::DoGetClientSize
+} // end of wxFrameOS2::DoGetClientSize

 
 //
 // Set the client size (i.e. leave the calculation of borders etc.
 // to wxWindows)
 //
 
 //
 // Set the client size (i.e. leave the calculation of borders etc.
 // to wxWindows)
 //

-void wxFrame::DoSetClientSize(
+void wxFrameOS2::DoSetClientSize(

   int                               nWidth
 , int                               nHeight
 )
   int                               nWidth
 , int                               nHeight
 )


@@ -311,9 +322,9 @@ void wxFrame::DoSetClientSize(
                                           );
     vEvent.SetEventObject(this);
     GetEventHandler()->ProcessEvent(vEvent);
                                           );
     vEvent.SetEventObject(this);
     GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxFrame::DoSetClientSize
+} // end of wxFrameOS2::DoSetClientSize

 
 

-void wxFrame::DoGetSize(
+void wxFrameOS2::DoGetSize(

   int*                              pWidth
 , int*                              pHeight
 ) const
   int*                              pWidth
 , int*                              pHeight
 ) const


@@ -323,9 +334,9 @@ void wxFrame::DoGetSize(
     ::WinQueryWindowRect(m_hFrame, &vRect);
     *pWidth = vRect.xRight - vRect.xLeft;
     *pHeight = vRect.yTop - vRect.yBottom;
     ::WinQueryWindowRect(m_hFrame, &vRect);
     *pWidth = vRect.xRight - vRect.xLeft;
     *pHeight = vRect.yTop - vRect.yBottom;

-} // end of wxFrame::DoGetSize
+} // end of wxFrameOS2::DoGetSize

 
 

-void wxFrame::DoGetPosition(
+void wxFrameOS2::DoGetPosition(

   int*                              pX
 , int*                              pY
 ) const
   int*                              pX
 , int*                              pY
 ) const


@@ -334,30 +345,24 @@ void wxFrame::DoGetPosition(
     POINTL                          vPoint;
 
     ::WinQueryWindowRect(m_hFrame, &vRect);
     POINTL                          vPoint;
 
     ::WinQueryWindowRect(m_hFrame, &vRect);

-    vPoint.x = vRect.xLeft;

 
 

-    //
-    // OS/2 is backwards [WIN32 it is vRect.yTop]
-    //
-    vPoint.y = vRect.yBottom;
-
-    *pX = vPoint.x;
-    *pY = vPoint.y;
-} // end of wxFrame::DoGetPosition
+    *pX = vRect.xRight - vRect.xLeft;
+    *pY = vRect.yTop - vRect.yBottom;
+} // end of wxFrameOS2::DoGetPosition

 
 // ----------------------------------------------------------------------------
 // variations around ::ShowWindow()
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // variations around ::ShowWindow()
 // ----------------------------------------------------------------------------
 

-void wxFrame::DoShowWindow(
+void wxFrameOS2::DoShowWindow(

   int                               bShowCmd
 )
 {
     ::WinShowWindow(m_hFrame, (BOOL)bShowCmd);
     m_bIconized = bShowCmd == SWP_MINIMIZE;
   int                               bShowCmd
 )
 {
     ::WinShowWindow(m_hFrame, (BOOL)bShowCmd);
     m_bIconized = bShowCmd == SWP_MINIMIZE;

-} // end of wxFrame::DoShowWindow
+} // end of wxFrameOS2::DoShowWindow

 
 

-bool wxFrame::Show(
+bool wxFrameOS2::Show(

   bool                              bShow
 )
 {
   bool                              bShow
 )
 {


@@ -400,27 +405,27 @@ bool wxFrame::Show(
         }
     }
     return TRUE;
         }
     }
     return TRUE;

-} // end of wxFrame::Show
+} // end of wxFrameOS2::Show

 
 

-void wxFrame::Iconize(
+void wxFrameOS2::Iconize(

   bool                              bIconize
 )
 {
     DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
   bool                              bIconize
 )
 {
     DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);

-} // end of wxFrame::Iconize
+} // end of wxFrameOS2::Iconize

 
 

-void wxFrame::Maximize(
+void wxFrameOS2::Maximize(

   bool                              bMaximize)
 {
     DoShowWindow(bMaximize ? SWP_MAXIMIZE : SWP_RESTORE);
   bool                              bMaximize)
 {
     DoShowWindow(bMaximize ? SWP_MAXIMIZE : SWP_RESTORE);

-} // end of wxFrame::Maximize
+} // end of wxFrameOS2::Maximize

 
 

-void wxFrame::Restore()
+void wxFrameOS2::Restore()

 {
     DoShowWindow(SWP_RESTORE);
 {
     DoShowWindow(SWP_RESTORE);

-} // end of wxFrame::Restore
+} // end of wxFrameOS2::Restore

 
 

-bool wxFrame::IsIconized() const
+bool wxFrameOS2::IsIconized() const

 {
     SWP                             vSwp;
 
 {
     SWP                             vSwp;
 


@@ -431,19 +436,19 @@ bool wxFrame::IsIconized() const
     else
         ((wxFrame*)this)->m_bIconized = FALSE;
     return m_bIconized;
     else
         ((wxFrame*)this)->m_bIconized = FALSE;
     return m_bIconized;

-} // end of wxFrame::IsIconized
+} // end of wxFrameOS2::IsIconized

 
 // Is it maximized?
 
 // Is it maximized?

-bool wxFrame::IsMaximized() const
+bool wxFrameOS2::IsMaximized() const

 {
     SWP                             vSwp;
     bool                            bIconic;
 
     ::WinQueryWindowPos(m_hFrame, &vSwp);
     return (vSwp.fl & SWP_MAXIMIZE);
 {
     SWP                             vSwp;
     bool                            bIconic;
 
     ::WinQueryWindowPos(m_hFrame, &vSwp);
     return (vSwp.fl & SWP_MAXIMIZE);

-} // end of wxFrame::IsMaximized
+} // end of wxFrameOS2::IsMaximized

 
 

-void wxFrame::SetIcon(
+void wxFrameOS2::SetIcon(

   const wxIcon&                     rIcon
 )
 {
   const wxIcon&                     rIcon
 )
 {


@@ -462,10 +467,10 @@ void wxFrame::SetIcon(
                      ,(MPARAM)0
                     );
     }
                      ,(MPARAM)0
                     );
     }

-} // end of wxFrame::SetIcon
+} // end of wxFrameOS2::SetIcon

 
 #if wxUSE_STATUSBAR
 
 #if wxUSE_STATUSBAR

-wxStatusBar* wxFrame::OnCreateStatusBar(
+wxStatusBar* wxFrameOS2::OnCreateStatusBar(

   int                               nNumber
 , long                              lulStyle
 , wxWindowID                        vId
   int                               nNumber
 , long                              lulStyle
 , wxWindowID                        vId


@@ -500,9 +505,9 @@ wxStatusBar* wxFrame::OnCreateStatusBar(
         ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
 
     return pStatusBar;
         ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
 
     return pStatusBar;

-} // end of wxFrame::OnCreateStatusBar
+} // end of wxFrameOS2::OnCreateStatusBar

 
 

-void wxFrame::PositionStatusBar()
+void wxFrameOS2::PositionStatusBar()

 {
     SWP                             vSwp;
     ERRORID                         vError;
 {
     SWP                             vSwp;
     ERRORID                         vError;


@@ -547,19 +552,19 @@ void wxFrame::PositionStatusBar()
             return;
         }
     }
             return;
         }
     }

-} // end of wxFrame::PositionStatusBar
+} // end of wxFrameOS2::PositionStatusBar

 #endif // wxUSE_STATUSBAR
 
 #endif // wxUSE_STATUSBAR
 

-void wxFrame::DetachMenuBar()
+void wxFrameOS2::DetachMenuBar()

 {
     if (m_frameMenuBar)
     {
         m_frameMenuBar->Detach();
         m_frameMenuBar = NULL;
     }
 {
     if (m_frameMenuBar)
     {
         m_frameMenuBar->Detach();
         m_frameMenuBar = NULL;
     }

-} // end of wxFrame::DetachMenuBar
+} // end of wxFrameOS2::DetachMenuBar

 
 

-void wxFrame::SetMenuBar(
+void wxFrameOS2::SetMenuBar(

   wxMenuBar*                        pMenuBar
 )
 {
   wxMenuBar*                        pMenuBar
 )
 {


@@ -608,11 +613,48 @@ void wxFrame::SetMenuBar(
         }
         InternalSetMenuBar();
         m_frameMenuBar = pMenuBar;
         }
         InternalSetMenuBar();
         m_frameMenuBar = pMenuBar;

-        pMenuBar->Attach(this);
+        pMenuBar->Attach((wxFrame*)this);
+    }
+} // end of wxFrameOS2::SetMenuBar
+
+void wxFrameOS2::AttachMenuBar(
+  wxMenuBar*                        pMenubar
+)
+{
+    m_frameMenuBar = pMenubar;
+
+    if (!pMenubar)
+    {
+        //
+        // Actually remove the menu from the frame
+        //
+        m_hMenu = (WXHMENU)0;
+        InternalSetMenuBar();

     }
     }

-} // end of wxFrame::SetMenuBar
+    else // Set new non NULL menu bar
+    {
+        //
+        // Can set a menubar several times.
+        //
+        if (pMenubar->GetHMenu())
+        {
+            m_hMenu = pMenubar->GetHMenu();
+        }
+        else
+        {
+            if (pMenubar->IsAttached())
+                pMenubar->Detach();
+
+            m_hMenu = pMenubar->Create();
+
+            if (!m_hMenu)
+                return;
+        }
+        InternalSetMenuBar();
+    }
+} // end of wxFrameOS2::AttachMenuBar

 
 

-void wxFrame::InternalSetMenuBar()
+void wxFrameOS2::InternalSetMenuBar()

 {
     ERRORID                         vError;
     wxString                        sError;
 {
     ERRORID                         vError;
     wxString                        sError;


@@ -633,12 +675,12 @@ void wxFrame::InternalSetMenuBar()
         wxLogError("Error setting parent for submenu. Error: %s\n", sError);
     }
     ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
         wxLogError("Error setting parent for submenu. Error: %s\n", sError);
     }
     ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);

-} // end of wxFrame::InternalSetMenuBar
+} // end of wxFrameOS2::InternalSetMenuBar

 
 //
 // Responds to colour changes, and passes event on to children
 //
 
 //
 // Responds to colour changes, and passes event on to children
 //

-void wxFrame::OnSysColourChanged(
+void wxFrameOS2::OnSysColourChanged(

   wxSysColourChangedEvent&          rEvent
 )
 {
   wxSysColourChangedEvent&          rEvent
 )
 {


@@ -659,10 +701,10 @@ void wxFrame::OnSysColourChanged(
     // Propagate the event to the non-top-level children
     //
     wxWindow::OnSysColourChanged(rEvent);
     // Propagate the event to the non-top-level children
     //
     wxWindow::OnSysColourChanged(rEvent);

-} // end of wxFrame::OnSysColourChanged
+} // end of wxFrameOS2::OnSysColourChanged

 
 // Pass TRUE to show full screen, FALSE to restore.
 
 // Pass TRUE to show full screen, FALSE to restore.

-bool wxFrame::ShowFullScreen(
+bool wxFrameOS2::ShowFullScreen(

   bool                              bShow
 , long                              lStyle
 )
   bool                              bShow
 , long                              lStyle
 )


@@ -849,12 +891,12 @@ bool wxFrame::ShowFullScreen(
                          );
         return TRUE;
     }
                          );
         return TRUE;
     }

-} // end of wxFrame::ShowFullScreen
+} // end of wxFrameOS2::ShowFullScreen

 
 //
 // Frame window
 //
 
 //
 // Frame window
 //

-bool wxFrame::OS2Create(
+bool wxFrameOS2::OS2Create(

   int                               nId
 , wxWindow*                         pParent
 , const wxChar*                     zWclass
   int                               nId
 , wxWindow*                         pParent
 , const wxChar*                     zWclass


@@ -984,6 +1026,22 @@ bool wxFrame::OS2Create(
     wxAssociateWinWithHandle(m_hWnd, this);
     wxAssociateWinWithHandle(m_hFrame, this);
 
     wxAssociateWinWithHandle(m_hWnd, this);
     wxAssociateWinWithHandle(m_hFrame, this);
 

+    m_backgroundColour.Set(wxString("GREY"));
+
+    LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
+
+    if (!::WinSetPresParam( m_hWnd
+                           ,PP_BACKGROUNDCOLOR
+                           ,sizeof(LONG)
+                           ,(PVOID)&lColor
+                          ))
+    {
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+        wxLogError("Error creating frame. Error: %s\n", sError);
+        return FALSE;
+    }
+

     //
     // Now need to subclass window.  Instead of calling the SubClassWin in wxWindow
     // we manually subclass here because we don't want to use the main wxWndProc
     //
     // Now need to subclass window.  Instead of calling the SubClassWin in wxWindow
     // we manually subclass here because we don't want to use the main wxWndProc


@@ -1014,10 +1072,10 @@ bool wxFrame::OS2Create(
     //
     if (!::WinSetWindowPos( m_hWnd
                            ,HWND_TOP
     //
     if (!::WinSetWindowPos( m_hWnd
                            ,HWND_TOP

-                           ,nX + 20
-                           ,nY + 20
-                           ,nWidth - 60
-                           ,nHeight - 60
+                           ,nX // + 20
+                           ,nY // + 20
+                           ,nWidth // - 60
+                           ,nHeight // - 60

                            ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
                           ))
     {
                            ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
                           ))
     {


@@ -1026,55 +1084,65 @@ bool wxFrame::OS2Create(
         wxLogError("Error sizing client. Error: %s\n", sError);
         return FALSE;
     }
         wxLogError("Error sizing client. Error: %s\n", sError);
         return FALSE;
     }

-
-/*
-    uCtlCount = SHORT1FROMMP(::WinSendMsg(GetHWND(), WM_FORMATFRAME, (MPARAM)vSwp, (MPARAM)vRect));
-    for (int i = 0; i < uCtlCount; i++)
-    {
-        if (vSwp[i].hwnd == GetHWND())
-            memcpy(&m_vSwp, &vSwp[i], sizeof(SWP));
-        else if (vSwp[i].hwnd == m_hVScroll)
-            memcpy(&m_vSwpVScroll, &vSwp[i], sizeof(SWP));
-        else if (vSwp[i].hwnd == m_hHScroll)
-            memcpy(&m_vSwpVScroll, &vSwp[i], sizeof(SWP));
-        else if (vSwp[i].hwnd == m_hTitleBar)
-            memcpy(&m_vSwpTitleBar, &vSwp[i], sizeof(SWP));
-    }*/

     return TRUE;
     return TRUE;

-} // end of wxFrame::OS2Create
+} // end of wxFrameOS2::OS2Create

 
 //
 // Default activation behaviour - set the focus for the first child
 // subwindow found.
 //
 
 //
 // Default activation behaviour - set the focus for the first child
 // subwindow found.
 //

-void wxFrame::OnActivate(
+void wxFrameOS2::OnActivate(

   wxActivateEvent&                  rEvent
 )
 {
   wxActivateEvent&                  rEvent
 )
 {

-    for (wxWindowList::Node* pNode = GetChildren().GetFirst();
-         pNode;
-         pNode = pNode->GetNext())
+    if ( rEvent.GetActive() )
+    {
+        // restore focus to the child which was last focused
+        wxLogTrace(_T("focus"), _T("wxFrame %08x activated."), m_hWnd);
+
+        wxWindow*                           pParent = m_pWinLastFocused ? m_pWinLastFocused->GetParent()
+                                            : NULL;
+        if (!pParent)
+        {
+            pParent = this;
+        }
+
+        wxSetFocusToChild( pParent
+                          ,&m_pWinLastFocused
+                         );
+    }
+    else // deactivating

     {
     {

-        // FIXME all this is totally bogus - we need to do the same as wxPanel,
-        //       but how to do it without duplicating the code?
+        //
+        // Remember the last focused child if it is our child
+        //
+        m_pWinLastFocused = FindFocus();
+
+        for (wxWindowList::Node* pNode = GetChildren().GetFirst();
+             pNode;
+             pNode = pNode->GetNext())
+        {
+            // FIXME all this is totally bogus - we need to do the same as wxPanel,
+            //       but how to do it without duplicating the code?

 
 

-        // restore focus
-        wxWindow*                   pChild = pNode->GetData();
+            // restore focus
+            wxWindow*                   pChild = pNode->GetData();

 
 

-        if (!pChild->IsTopLevel()
+            if (!pChild->IsTopLevel()

 #if wxUSE_TOOLBAR
 #if wxUSE_TOOLBAR

-             && !wxDynamicCast(pChild, wxToolBar)
+                 && !wxDynamicCast(pChild, wxToolBar)

 #endif // wxUSE_TOOLBAR
 #if wxUSE_STATUSBAR
 #endif // wxUSE_TOOLBAR
 #if wxUSE_STATUSBAR

-             && !wxDynamicCast(pChild, wxStatusBar)
+                 && !wxDynamicCast(pChild, wxStatusBar)

 #endif // wxUSE_STATUSBAR
 #endif // wxUSE_STATUSBAR

-           )
-        {
-            pChild->SetFocus();
-            return;
+               )
+            {
+                pChild->SetFocus();
+                return;
+            }

         }
     }
         }
     }

-} // end of wxFrame::OnActivate
+} // end of wxFrameOS2::OnActivate

 
 // ----------------------------------------------------------------------------
 // wxFrame size management: we exclude the areas taken by menu/status/toolbars
 
 // ----------------------------------------------------------------------------
 // wxFrame size management: we exclude the areas taken by menu/status/toolbars


@@ -1083,7 +1151,7 @@ void wxFrame::OnActivate(
 // ----------------------------------------------------------------------------
 
 // Checks if there is a toolbar, and returns the first free client position
 // ----------------------------------------------------------------------------
 
 // Checks if there is a toolbar, and returns the first free client position

-wxPoint wxFrame::GetClientAreaOrigin() const
+wxPoint wxFrameOS2::GetClientAreaOrigin() const

 {
     wxPoint                         vPoint(0, 0);
 
 {
     wxPoint                         vPoint(0, 0);
 


@@ -1109,7 +1177,7 @@ wxPoint wxFrame::GetClientAreaOrigin() const
     }
 #endif //wxUSE_TOOLBAR
     return vPoint;
     }
 #endif //wxUSE_TOOLBAR
     return vPoint;

-} // end of wxFrame::GetClientAreaOrigin
+} // end of wxFrameOS2::GetClientAreaOrigin

 
 // ----------------------------------------------------------------------------
 // tool/status bar stuff
 
 // ----------------------------------------------------------------------------
 // tool/status bar stuff


@@ -1117,7 +1185,7 @@ wxPoint wxFrame::GetClientAreaOrigin() const
 
 #if wxUSE_TOOLBAR
 
 
 #if wxUSE_TOOLBAR
 

-wxToolBar* wxFrame::CreateToolBar(
+wxToolBar* wxFrameOS2::CreateToolBar(

   long                              lStyle
 , wxWindowID                        vId
 , const wxString&                   rName
   long                              lStyle
 , wxWindowID                        vId
 , const wxString&                   rName


@@ -1131,9 +1199,9 @@ wxToolBar* wxFrame::CreateToolBar(
         PositionToolBar();
     }
     return m_frameToolBar;
         PositionToolBar();
     }
     return m_frameToolBar;

-} // end of wxFrame::CreateToolBar
+} // end of wxFrameOS2::CreateToolBar

 
 

-void wxFrame::PositionToolBar()
+void wxFrameOS2::PositionToolBar()

 {
     HWND                            hWndClient;
     RECTL                           vRect;
 {
     HWND                            hWndClient;
     RECTL                           vRect;


@@ -1154,12 +1222,12 @@ void wxFrame::PositionToolBar()
     }
 #endif // wxUSE_STATUSBAR
 
     }
 #endif // wxUSE_STATUSBAR
 

-    if ( GetToolBar() )
+    if ( m_frameToolBar )

     {
         int                         nToolbarWidth;
         int                         nToolbarHeight;
 
     {
         int                         nToolbarWidth;
         int                         nToolbarHeight;
 

-        GetToolBar()->GetSize( &nToolbarWidth
+        m_frameToolBar->GetSize( &nToolbarWidth

                               ,&nToolbarHeight
                              );
 
                               ,&nToolbarHeight
                              );
 


@@ -1182,7 +1250,7 @@ void wxFrame::PositionToolBar()
                               ,wxSIZE_NO_ADJUSTMENTS
                              );
     }
                               ,wxSIZE_NO_ADJUSTMENTS
                              );
     }

-} // end of wxFrame::PositionToolBar
+} // end of wxFrameOS2::PositionToolBar

 #endif // wxUSE_TOOLBAR
 
 // ----------------------------------------------------------------------------
 #endif // wxUSE_TOOLBAR
 
 // ----------------------------------------------------------------------------


@@ -1194,7 +1262,7 @@ void wxFrame::PositionToolBar()
 // Windows behaviour where child frames float independently of the parent one
 // on the desktop, but are iconized/restored with it
 //
 // Windows behaviour where child frames float independently of the parent one
 // on the desktop, but are iconized/restored with it
 //

-void wxFrame::IconizeChildFrames(
+void wxFrameOS2::IconizeChildFrames(

   bool                              bIconize
 )
 {
   bool                              bIconize
 )
 {


@@ -1209,7 +1277,7 @@ void wxFrame::IconizeChildFrames(
             ((wxFrame *)pWin)->Iconize(bIconize);
         }
     }
             ((wxFrame *)pWin)->Iconize(bIconize);
         }
     }

-} // end of wxFrame::IconizeChildFrames
+} // end of wxFrameOS2::IconizeChildFrames

 
 // ===========================================================================
 // message processing
 
 // ===========================================================================
 // message processing


@@ -1218,7 +1286,7 @@ void wxFrame::IconizeChildFrames(
 // ---------------------------------------------------------------------------
 // preprocessing
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // preprocessing
 // ---------------------------------------------------------------------------

-bool wxFrame::OS2TranslateMessage(
+bool wxFrameOS2::OS2TranslateMessage(

   WXMSG*                            pMsg
 )
 {
   WXMSG*                            pMsg
 )
 {


@@ -1236,12 +1304,12 @@ bool wxFrame::OS2TranslateMessage(
 #else
     return FALSE;
 #endif //wxUSE_ACCEL
 #else
     return FALSE;
 #endif //wxUSE_ACCEL

-} // end of wxFrame::OS2TranslateMessage
+} // end of wxFrameOS2::OS2TranslateMessage

 
 // ---------------------------------------------------------------------------
 // our private (non virtual) message handlers
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // our private (non virtual) message handlers
 // ---------------------------------------------------------------------------

-bool wxFrame::HandlePaint()
+bool wxFrameOS2::HandlePaint()

 {
     RECTL                           vRect;
 
 {
     RECTL                           vRect;
 


@@ -1290,7 +1358,7 @@ bool wxFrame::HandlePaint()
         }
         else
         {
         }
         else
         {

-            return wxWindow::HandlePaint();
+            return(wxWindow::HandlePaint());

         }
     }
     else
         }
     }
     else


@@ -1299,9 +1367,9 @@ bool wxFrame::HandlePaint()
         return TRUE;
     }
     return FALSE;
         return TRUE;
     }
     return FALSE;

-} // end of wxFrame::HandlePaint
+} // end of wxFrameOS2::HandlePaint

 
 

-bool wxFrame::HandleSize(
+bool wxFrameOS2::HandleSize(

   int                               nX
 , int                               nY
 , WXUINT                            nId
   int                               nX
 , int                               nY
 , WXUINT                            nId


@@ -1323,6 +1391,7 @@ bool wxFrame::HandleSize(
             // restore all child frames too
             //
             IconizeChildFrames(FALSE);
             // restore all child frames too
             //
             IconizeChildFrames(FALSE);

+            (void)SendIconizeEvent(FALSE);

 
             //
             // fall through
 
             //
             // fall through


@@ -1337,6 +1406,7 @@ bool wxFrame::HandleSize(
             // Iconize all child frames too
             //
             IconizeChildFrames(TRUE);
             // Iconize all child frames too
             //
             IconizeChildFrames(TRUE);

+            (void)SendIconizeEvent();

             m_bIconized = TRUE;
             break;
     }
             m_bIconized = TRUE;
             break;
     }


@@ -1375,9 +1445,9 @@ bool wxFrame::HandleSize(
         bProcessed = GetEventHandler()->ProcessEvent(vEvent);
     }
     return bProcessed;
         bProcessed = GetEventHandler()->ProcessEvent(vEvent);
     }
     return bProcessed;

-} // end of wxFrame::HandleSize
+} // end of wxFrameOS2::HandleSize

 
 

-bool wxFrame::HandleCommand(
+bool wxFrameOS2::HandleCommand(

   WXWORD                            nId
 , WXWORD                            nCmd
 , WXHWND                            hControl
   WXWORD                            nId
 , WXWORD                            nCmd
 , WXHWND                            hControl


@@ -1418,9 +1488,9 @@ bool wxFrame::HandleCommand(
         }
     }
     return FALSE;
         }
     }
     return FALSE;

-} // end of wxFrame::HandleCommand
+} // end of wxFrameOS2::HandleCommand

 
 

-bool wxFrame::HandleMenuSelect(
+bool wxFrameOS2::HandleMenuSelect(

   WXWORD                            nItem
 , WXWORD                            nFlags
 , WXHMENU                           hMenu
   WXWORD                            nItem
 , WXWORD                            nFlags
 , WXHMENU                           hMenu


@@ -1442,7 +1512,7 @@ bool wxFrame::HandleMenuSelect(
         }
     }
     return TRUE;
         }
     }
     return TRUE;

-} // end of wxFrame::HandleMenuSelect
+} // end of wxFrameOS2::HandleMenuSelect

 
 // ---------------------------------------------------------------------------
 // Main Frame window proc
 
 // ---------------------------------------------------------------------------
 // Main Frame window proc


@@ -1578,7 +1648,7 @@ MRESULT EXPENTRY wxFrameWndProc(
     return rc;
 } // end of wxFrameWndProc
 
     return rc;
 } // end of wxFrameWndProc
 

-MRESULT wxFrame::OS2WindowProc(
+MRESULT wxFrameOS2::OS2WindowProc(

   WXUINT                            uMessage
 , WXWPARAM                          wParam
 , WXLPARAM                          lParam
   WXUINT                            uMessage
 , WXWPARAM                          wParam
 , WXLPARAM                          lParam


@@ -1598,23 +1668,22 @@ MRESULT wxFrame::OS2WindowProc(
             break;
 
         case WM_PAINT:
             break;
 
         case WM_PAINT:

-            {
-                HPS                             hPS;
-                RECTL                           vRect;
-                wxPaintEvent                    vEvent;
-
-                hPS = WinBeginPaint(m_hWnd, 0L, &vRect);
-                ::WinFillRect(hPS, &vRect,  CLR_BLUE  /* SYSCLR_WINDOW */);
-                ::WinEndPaint(hPS);
+            bProcessed = HandlePaint();
+            mRc = (MRESULT)FALSE;
+            break;

 
 

-                mRc = (MRESULT)FALSE;
-                vEvent.SetEventObject(this);
-                GetEventHandler()->ProcessEvent(vEvent);
-                bProcessed = TRUE;
-            }
+         case WM_ERASEBACKGROUND:
+            //
+            // Returning TRUE to requests PM to paint the window background
+            // in SYSCLR_WINDOW. We capture this here because the PS returned
+            // in Frames is the PS for the whole frame, which we can't really
+            // use at all. If you want to paint a different background, do it
+            // in an OnPaint using a wxPaintDC.
+            //
+            mRc = (MRESULT)(TRUE);

             break;
 
             break;
 

-        case WM_COMMAND:
+      case WM_COMMAND:

             {
                 WORD                wId;
                 WORD                wCmd;
             {
                 WORD                wId;
                 WORD                wCmd;


@@ -1669,15 +1738,6 @@ MRESULT wxFrame::OS2WindowProc(
             mRc = (MRESULT)FALSE;
             break;
 
             mRc = (MRESULT)FALSE;
             break;
 

-        case WM_ERASEBACKGROUND:
-            //
-            // Return TRUE to request PM to paint the window background
-            // in SYSCLR_WINDOW.
-            //
-            bProcessed = TRUE;
-            mRc = (MRESULT)(TRUE);
-            break;
-

         case CM_QUERYDRAGIMAGE:
             {
                 HPOINTER                hIcon;
         case CM_QUERYDRAGIMAGE:
             {
                 HPOINTER                hIcon;


@@ -1698,14 +1758,14 @@ MRESULT wxFrame::OS2WindowProc(
                                       ,lParam
                                      );
     return (MRESULT)mRc;
                                       ,lParam
                                      );
     return (MRESULT)mRc;

-} // wxFrame::OS2WindowProc
+} // wxFrameOS2::OS2WindowProc

 
 

-void wxFrame::SetClient(WXHWND c_Hwnd)
+void wxFrameOS2::SetClient(WXHWND c_Hwnd)

 {
    // Duh...nothing to do under OS/2
 }
 
 {
    // Duh...nothing to do under OS/2
 }
 

-void wxFrame::SetClient(
+void wxFrameOS2::SetClient(

   wxWindow*                         pWindow
 )
 {
   wxWindow*                         pWindow
 )
 {


@@ -1755,7 +1815,7 @@ void wxFrame::SetClient(
     }
 }
 
     }
 }
 

-wxWindow* wxFrame::GetClient()
+wxWindow* wxFrameOS2::GetClient()

 {
     return wxFindWinFromHandle((WXHWND)::WinWindowFromID(m_hFrame, FID_CLIENT));
 }
 {
     return wxFindWinFromHandle((WXHWND)::WinWindowFromID(m_hFrame, FID_CLIENT));
 }