Fix HTML help on Mac.

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

diff --git a/src/os2/frame.cpp b/src/os2/frame.cpp
index 2921ea42dccf18665eccd7a40fe319f3ea9d88fa..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,41 +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);

-#if wxUSE_STATUSBAR
-    if ( GetStatusBar() && GetStatusBar()->IsShown() )
-    {
-        int                         nStatusX
-        int                         nStatusY;

 
 

-        GetStatusBar()->GetClientSize( &nStatusX
-                                      ,&nStatusY
-                                     );
-        vRect.yBottom += nStatusY;
-    }
-#endif // wxUSE_STATUSBAR
+    //
+    // 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
 )


@@ -323,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


@@ -335,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


@@ -346,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
 )
 {


@@ -412,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;
 


@@ -443,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
 )
 {


@@ -474,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


@@ -512,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;


@@ -559,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
 )
 {


@@ -620,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();
+    }
+    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 wxFrame::SetMenuBar
+} // end of wxFrameOS2::AttachMenuBar

 
 

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

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


@@ -645,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
 )
 {


@@ -671,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
 )


@@ -861,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


@@ -1055,13 +1085,13 @@ bool wxFrame::OS2Create(
         return FALSE;
     }
     return TRUE;
         return FALSE;
     }
     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
 )
 {


@@ -1112,7 +1142,7 @@ void wxFrame::OnActivate(
             }
         }
     }
             }
         }
     }

-} // 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


@@ -1121,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);
 


@@ -1147,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


@@ -1155,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


@@ -1169,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;


@@ -1192,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
                              );
 


@@ -1220,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
 
 // ----------------------------------------------------------------------------


@@ -1232,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
 )
 {


@@ -1247,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


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

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

   WXMSG*                            pMsg
 )
 {
   WXMSG*                            pMsg
 )
 {


@@ -1274,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;
 


@@ -1337,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


@@ -1361,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


@@ -1375,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;
     }


@@ -1413,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


@@ -1456,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


@@ -1480,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


@@ -1616,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


@@ -1726,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
 )
 {


@@ -1783,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));
 }