Last correction for makefile.g95: win32 mkdir does not like forward slashes as directory

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

diff --git a/src/os2/window.cpp b/src/os2/window.cpp
index fc19d433724e3f34d04dfa3c40ca54bc5ed2c21f..846ed5696f5a2c0a5ae410293f3b9b9bfeba781c 100644 (file)
--- a/src/os2/window.cpp
+++ b/src/os2/window.cpp
@@ -33,15 +33,11 @@
     #include "wx/listbox.h"
     #include "wx/button.h"
     #include "wx/msgdlg.h"
     #include "wx/listbox.h"
     #include "wx/button.h"
     #include "wx/msgdlg.h"

+    #include "wx/scrolwin.h"

 
     #include <stdio.h>
 #endif
 
 
     #include <stdio.h>
 #endif
 

-#define DEBUG_PRINTF(NAME)   { static int raz=0; \
-  printf( #NAME " %i\n",raz); fflush(stdout);       \
-   raz++;                                        \
- }
-

 #if     wxUSE_OWNER_DRAWN
     #include "wx/ownerdrw.h"
 #endif
 #if     wxUSE_OWNER_DRAWN
     #include "wx/ownerdrw.h"
 #endif


@@ -98,12 +94,14 @@
 // ---------------------------------------------------------------------------
 
 //
 // ---------------------------------------------------------------------------
 
 //

-// The last Windows message we got (MT-UNSAFE)
+// The last PM message we got (MT-UNSAFE)

 //
 QMSG                      s_currentMsg;
 
 //
 QMSG                      s_currentMsg;
 

+#if wxUSE_MENUS_NATIVE

 wxMenu*                   wxCurrentPopupMenu = NULL;
 wxMenu*                   wxCurrentPopupMenu = NULL;

-extern wxList WXDLLEXPORT wxPendingDelete;
+#endif // wxUSE_MENUS_NATIVE
+

 #if !defined(__VISAGECPP__) || (__IBMCPP__ < 400)
 extern wxChar             wxCanvasClassName[];
 #endif
 #if !defined(__VISAGECPP__) || (__IBMCPP__ < 400)
 extern wxChar             wxCanvasClassName[];
 #endif


@@ -126,9 +124,9 @@ MRESULT EXPENTRY wxWndProc( HWND hWnd
     const char *wxGetMessageName(int message);
 #endif  //__WXDEBUG__
 
     const char *wxGetMessageName(int message);
 #endif  //__WXDEBUG__
 

-void      wxRemoveHandleAssociation(wxWindow* pWin);
-void      wxAssociateWinWithHandle( HWND      hWnd
-                                   ,wxWindow* pWin
+void      wxRemoveHandleAssociation(wxWindowOS2* pWin);
+void      wxAssociateWinWithHandle( HWND         hWnd
+                                   ,wxWindowOS2* pWin

                                   );
 wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 
                                   );
 wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 


@@ -136,12 +134,14 @@ wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 // This magical function is used to translate VK_APPS key presses to right
 // mouse clicks
 //
 // This magical function is used to translate VK_APPS key presses to right
 // mouse clicks
 //

+// Unused?
+#if 0

 static void TranslateKbdEventToMouse( wxWindow* pWin
                                      ,int*      pX
                                      ,int*      pY
                                      ,MPARAM*   pFlags
                                     );
 static void TranslateKbdEventToMouse( wxWindow* pWin
                                      ,int*      pX
                                      ,int*      pY
                                      ,MPARAM*   pFlags
                                     );

-
+#endif

 //
 // get the current state of SHIFT/CTRL keys
 //
 //
 // get the current state of SHIFT/CTRL keys
 //


@@ -151,42 +151,55 @@ static inline bool IsCtrlDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_CTRL
 // event tables
 // ---------------------------------------------------------------------------
 
 // event tables
 // ---------------------------------------------------------------------------
 

+// in wxUniv-OS/2 this class is abstract because it doesn't have DoPopupMenu()
+// method
+#ifdef __WXUNIVERSAL__
+    IMPLEMENT_ABSTRACT_CLASS(wxWindowOS2, wxWindowBase)
+#else // __WXPM__

     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)

-
-BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
-    EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
-    EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
-    EVT_INIT_DIALOG(wxWindow::OnInitDialog)
-    EVT_IDLE(wxWindow::OnIdle)
-    EVT_SET_FOCUS(wxWindow::OnSetFocus)
+#endif // __WXUNIVERSAL__/__WXPM__
+
+BEGIN_EVENT_TABLE(wxWindowOS2, wxWindowBase)
+    EVT_ERASE_BACKGROUND(wxWindowOS2::OnEraseBackground)
+    EVT_SYS_COLOUR_CHANGED(wxWindowOS2::OnSysColourChanged)
+    EVT_INIT_DIALOG(wxWindowOS2::OnInitDialog)
+    EVT_IDLE(wxWindowOS2::OnIdle)
+    EVT_SET_FOCUS(wxWindowOS2::OnSetFocus)

 END_EVENT_TABLE()
 
 // ===========================================================================
 // implementation
 // ===========================================================================
 
 END_EVENT_TABLE()
 
 // ===========================================================================
 // implementation
 // ===========================================================================
 

+// ---------------------------------------------------------------------------
+// wxWindow utility functions
+// ---------------------------------------------------------------------------
+

 //
 // Find an item given the PM Window id
 //
 //
 // Find an item given the PM Window id
 //

-wxWindow* wxWindow::FindItem(
+wxWindow* wxWindowOS2::FindItem(

   long                              lId
 ) const
 {
   long                              lId
 ) const
 {

-    wxControl*                      pItem = wxDynamicCast( this
-                                                          ,wxControl
-                                                         );
+#if wxUSE_CONTROLS
+    wxControl*                      pItem = wxDynamicCast(this, wxControl);

 
     if (pItem)
     {
         //
         // I it we or one of our "internal" children?
         //
 
     if (pItem)
     {
         //
         // I it we or one of our "internal" children?
         //

-        if (pItem->GetId() == lId ||
-             (pItem->GetSubcontrols().Index(lId) != wxNOT_FOUND))
+        if (pItem->GetId() == lId
+#ifndef __WXUNIVERSAL__
+            || (pItem->GetSubcontrols().Index(lId) != wxNOT_FOUND)
+#endif
+            )

         {
             return pItem;
         }
     }
         {
             return pItem;
         }
     }

+#endif // wxUSE_CONTROLS

 
     wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
 
 
     wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
 


@@ -201,12 +214,12 @@ wxWindow* wxWindow::FindItem(
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);

-} // end of wxWindow::FindItem
+} // end of wxWindowOS2::FindItem

 
 //
 // Find an item given the PM Window handle
 //
 
 //
 // Find an item given the PM Window handle
 //

-wxWindow* wxWindow::FindItemByHWND(
+wxWindow* wxWindowOS2::FindItemByHWND(

   WXHWND                            hWnd
 , bool                              bControlOnly
 ) const
   WXHWND                            hWnd
 , bool                              bControlOnly
 ) const


@@ -225,7 +238,11 @@ wxWindow* wxWindow::FindItemByHWND(
         if (pWnd)
             return(pWnd);
 
         if (pWnd)
             return(pWnd);
 

-        if (!bControlOnly || pParent->IsKindOf(CLASSINFO(wxControl)))
+        if (!bControlOnly
+#if wxUSE_CONTROLS
+            || pParent->IsKindOf(CLASSINFO(wxControl))
+#endif // wxUSE_CONTROLS
+            )

         {
             wxWindow*               pItem = pCurrent->GetData();
 
         {
             wxWindow*               pItem = pCurrent->GetData();
 


@@ -240,19 +257,16 @@ wxWindow* wxWindow::FindItemByHWND(
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);

-} // end of wxWindow::FindItemByHWND
+} // end of wxWindowOS2::FindItemByHWND

 
 //
 // Default command handler
 //
 
 //
 // Default command handler
 //

-bool wxWindow::OS2Command(
+bool wxWindowOS2::OS2Command(

   WXUINT                            WXUNUSED(uParam)
 , WXWORD                            WXUNUSED(uId)
 )
 {
   WXUINT                            WXUNUSED(uParam)
 , WXWORD                            WXUNUSED(uId)
 )
 {

-
-DEBUG_PRINTF(wxWindow::OS2Command);
-

     return(FALSE);
 }
 
     return(FALSE);
 }
 


@@ -260,7 +274,7 @@ DEBUG_PRINTF(wxWindow::OS2Command);
 // constructors and such
 // ----------------------------------------------------------------------------
 
 // constructors and such
 // ----------------------------------------------------------------------------
 

-void wxWindow::Init()
+void wxWindowOS2::Init()

 {
     //
     // Generic
 {
     //
     // Generic


@@ -281,8 +295,10 @@ void wxWindow::Init()
     //
     // wxWnd
     //
     //
     // wxWnd
     //

-    m_hMenu = 0;
-    m_hWnd = 0;
+    m_hMenu             = 0L;
+    m_hWnd              = 0L;
+    m_hWndScrollBarHorz = 0L;
+    m_hWndScrollBarVert = 0L;

 
     //
     // Pass WM_GETDLGCODE to DefWindowProc()
 
     //
     // Pass WM_GETDLGCODE to DefWindowProc()


@@ -302,23 +318,31 @@ void wxWindow::Init()
     m_lLastMouseY = -1;
     m_nLastMouseEvent = -1;
 #endif // wxUSE_MOUSEEVENT_HACK
     m_lLastMouseY = -1;
     m_nLastMouseEvent = -1;
 #endif // wxUSE_MOUSEEVENT_HACK

-
-DEBUG_PRINTF(wxWindow::Init-End);
-
-} // wxWindow::Init
+} // wxWindowOS2::Init

 
 //
 // Destructor
 //
 
 //
 // Destructor
 //

-wxWindow::~wxWindow()
+wxWindowOS2::~wxWindowOS2()

 {
 {

-DEBUG_PRINTF(wxWindow::~wxWindow-Start);

     m_isBeingDeleted = TRUE;
 
     OS2DetachWindowMenu();
     m_isBeingDeleted = TRUE;
 
     OS2DetachWindowMenu();

+    for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent())
+    {
+        wxFrame*                    pFrame = wxDynamicCast(pWin, wxFrame);
+
+        if (pFrame)
+        {
+            if (pFrame->GetLastFocus() == this)
+                pFrame->SetLastFocus((wxWindow*)NULL);
+        }
+    }
+
+    DestroyChildren();
+

     if (m_parent)
         m_parent->RemoveChild(this);
     if (m_parent)
         m_parent->RemoveChild(this);

-    DestroyChildren();

 
     if (m_hWnd)
     {
 
     if (m_hWnd)
     {


@@ -329,10 +353,10 @@ DEBUG_PRINTF(wxWindow::~wxWindow-Start);
         //
         wxRemoveHandleAssociation(this);
     }
         //
         wxRemoveHandleAssociation(this);
     }

-DEBUG_PRINTF(wxWindow::~wxWindow-End);
-} // end of wxWindow::~wxWindow
+} // end of wxWindowOS2::~wxWindowOS2

 
 

-bool wxWindow::Create(
+// real construction (Init() must have been called before!)
+bool wxWindowOS2::Create(

   wxWindow*                         pParent
 , wxWindowID                        vId
 , const wxPoint&                    rPos
   wxWindow*                         pParent
 , wxWindowID                        vId
 , const wxPoint&                    rPos


@@ -342,6 +366,9 @@ bool wxWindow::Create(
 )
 {
     HWND                            hParent = NULLHANDLE;
 )
 {
     HWND                            hParent = NULLHANDLE;

+    wxPoint                         vPos = rPos; // The OS/2 position
+    ULONG                           ulCreateFlags = 0;
+    WXDWORD                         dwExStyle = 0;

 
     wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
 
 
     wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
 


@@ -357,14 +384,16 @@ bool wxWindow::Create(
 
     if (pParent)
     {
 
     if (pParent)
     {

+        int                         nTempy;
+

         pParent->AddChild(this);
         hParent = GetWinHwnd(pParent);
         pParent->AddChild(this);
         hParent = GetWinHwnd(pParent);

-    }
-    else
-       hParent = HWND_DESKTOP;
-
-    ULONG                           ulCreateFlags = 0L;

 
 

+        if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
+             pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
+           )
+            ulCreateFlags |= WS_CLIPSIBLINGS;
+    }

 
     //
     // Most wxSTYLES are really PM Class specific styles and will be
 
     //
     // Most wxSTYLES are really PM Class specific styles and will be


@@ -374,18 +403,40 @@ bool wxWindow::Create(
     ulCreateFlags |=  WS_VISIBLE;
 
 
     ulCreateFlags |=  WS_VISIBLE;
 
 

-    if ( lStyle & wxCLIP_SIBLINGS )
+#ifdef __WXUNIVERSAL__
+    // no 3d effects, we draw them ourselves
+    WXDWORD exStyle = 0;
+#else // !wxUniversal
+    if (lStyle & wxCLIP_SIBLINGS)

         ulCreateFlags |= WS_CLIPSIBLINGS;
 
     if (lStyle & wxCLIP_CHILDREN )
         ulCreateFlags |= WS_CLIPCHILDREN;
 
     //
         ulCreateFlags |= WS_CLIPSIBLINGS;
 
     if (lStyle & wxCLIP_CHILDREN )
         ulCreateFlags |= WS_CLIPCHILDREN;
 
     //

-    // Empty stuff for now since PM has no custome 3D effects
-    // Doesn't mean someone cannot make some up though
+    //

     //
     bool                            bWant3D;
     //
     bool                            bWant3D;

-    WXDWORD                         dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D);
+    dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D);
+
+#endif
+
+    //
+    // Add the simple border style as we'll use this to draw borders
+    //
+    if (lStyle & wxSIMPLE_BORDER)
+        dwExStyle |= wxSIMPLE_BORDER;
+
+    if (lStyle & wxPOPUP_WINDOW)
+    {
+        // a popup window floats on top of everything
+//TODO: fix this...
+//        exStyle |= WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
+
+        // it is also created hidden as other top level windows
+        ulCreateFlags &= ~WS_VISIBLE;
+        m_isShown = FALSE;
+    }

 
     //
     // Generic OS/2 Windows are created with no owner, no Z Order, no Control data,
 
     //
     // Generic OS/2 Windows are created with no owner, no Z Order, no Control data,


@@ -395,29 +446,33 @@ bool wxWindow::Create(
               ,(PSZ)wxCanvasClassName
               ,rName.c_str()
               ,ulCreateFlags
               ,(PSZ)wxCanvasClassName
               ,rName.c_str()
               ,ulCreateFlags

-              ,rPos.x
-              ,rPos.y
+              ,vPos.x
+              ,vPos.y

               ,WidthDefault(rSize.x)
               ,HeightDefault(rSize.y)
               ,NULLHANDLE
               ,NULLHANDLE
               ,m_windowId
               ,WidthDefault(rSize.x)
               ,HeightDefault(rSize.y)
               ,NULLHANDLE
               ,NULLHANDLE
               ,m_windowId

+              ,NULL
+              ,NULL
+              ,dwExStyle

              );
 
     return(TRUE);
              );
 
     return(TRUE);

-} // end of wxWindow::Create
+} // end of wxWindowOS2::Create

 
 // ---------------------------------------------------------------------------
 // basic operations
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // basic operations
 // ---------------------------------------------------------------------------
 

-void wxWindow::SetFocus()
+void wxWindowOS2::SetFocus()

 {
     HWND                            hWnd = GetHwnd();
 {
     HWND                            hWnd = GetHwnd();

+    wxCHECK_RET( hWnd, _T("can't set focus to invalid window") );

 
     if (hWnd)
         ::WinSetFocus(HWND_DESKTOP, hWnd);
 
     if (hWnd)
         ::WinSetFocus(HWND_DESKTOP, hWnd);

-} // end of wxWindow::SetFocus
+} // end of wxWindowOS2::SetFocus

 
 wxWindow* wxWindowBase::FindFocus()
 {
 
 wxWindow* wxWindowBase::FindFocus()
 {


@@ -430,7 +485,7 @@ wxWindow* wxWindowBase::FindFocus()
     return NULL;
 } // wxWindowBase::FindFocus
 
     return NULL;
 } // wxWindowBase::FindFocus
 

-bool wxWindow::Enable(
+bool wxWindowOS2::Enable(

   bool                              bEnable
 )
 {
   bool                              bEnable
 )
 {


@@ -451,10 +506,10 @@ bool wxWindow::Enable(
         pChild->Enable(bEnable);
         pNode = pNode->GetNext();
     }
         pChild->Enable(bEnable);
         pNode = pNode->GetNext();
     }

-    return(TRUE);
-} // end of wxWindow::Enable
+    return TRUE;
+} // end of wxWindowOS2::Enable

 
 

-bool wxWindow::Show(
+bool wxWindowOS2::Show(

   bool                              bShow
 )
 {
   bool                              bShow
 )
 {


@@ -469,32 +524,32 @@ bool wxWindow::Show(
     {
         ::WinSetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER);
     }
     {
         ::WinSetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER);
     }

-    return(TRUE);
-} // end of wxWindow::Show
+    return TRUE;
+} // end of wxWindowOS2::Show

 
 

-void wxWindow::Raise()
+void wxWindowOS2::Raise()

 {
     ::WinSetWindowPos(GetHwnd(), HWND_TOP, 0, 0, 0, 0, SWP_ZORDER | SWP_ACTIVATE);
 {
     ::WinSetWindowPos(GetHwnd(), HWND_TOP, 0, 0, 0, 0, SWP_ZORDER | SWP_ACTIVATE);

-} // end of wxWindow::Raise
+} // end of wxWindowOS2::Raise

 
 

-void wxWindow::Lower()
+void wxWindowOS2::Lower()

 {
     ::WinSetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_ZORDER | SWP_DEACTIVATE);
 {
     ::WinSetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_ZORDER | SWP_DEACTIVATE);

-} // end of wxWindow::Lower
+} // end of wxWindowOS2::Lower

 
 

-void wxWindow::SetTitle(
+void wxWindowOS2::SetTitle(

   const wxString&                   rTitle
 )
 {
     ::WinSetWindowText(GetHwnd(), rTitle.c_str());
   const wxString&                   rTitle
 )
 {
     ::WinSetWindowText(GetHwnd(), rTitle.c_str());

-} // end of wxWindow::SetTitle
+} // end of wxWindowOS2::SetTitle

 
 

-wxString wxWindow::GetTitle() const
+wxString wxWindowOS2::GetTitle() const

 {
     return wxGetWindowText(GetHWND());
 {
     return wxGetWindowText(GetHWND());

-} // end of wxWindow::GetTitle
+} // end of wxWindowOS2::GetTitle

 
 

-void wxWindow::CaptureMouse()
+void wxWindowOS2::CaptureMouse()

 {
     HWND                            hWnd = GetHwnd();
 
 {
     HWND                            hWnd = GetHwnd();
 


@@ -503,22 +558,27 @@ void wxWindow::CaptureMouse()
         ::WinSetCapture(HWND_DESKTOP, hWnd);
         m_bWinCaptured = TRUE;
     }
         ::WinSetCapture(HWND_DESKTOP, hWnd);
         m_bWinCaptured = TRUE;
     }

-} // end of wxWindow::GetTitle
+} // end of wxWindowOS2::GetTitle

 
 

-void wxWindow::ReleaseMouse()
+void wxWindowOS2::ReleaseMouse()

 {
     if (m_bWinCaptured)
     {
         ::WinSetCapture(HWND_DESKTOP, NULLHANDLE);
         m_bWinCaptured = FALSE;
     }
 {
     if (m_bWinCaptured)
     {
         ::WinSetCapture(HWND_DESKTOP, NULLHANDLE);
         m_bWinCaptured = FALSE;
     }

-} // end of wxWindow::ReleaseMouse
+} // end of wxWindowOS2::ReleaseMouse
+
+/* static */ wxWindow* wxWindowBase::GetCapture()
+{
+    HWND hwnd = ::WinQueryCapture(HWND_DESKTOP);
+    return hwnd ? wxFindWinFromHandle((WXHWND)hwnd) : (wxWindow *)NULL;
+} // end of wxWindowBase::GetCapture

 
 

-bool wxWindow::SetFont(
+bool wxWindowOS2::SetFont(

   const wxFont&                     rFont
 )
 {
   const wxFont&                     rFont
 )
 {

-DEBUG_PRINTF(wxWindow::SetFont);

     if (!wxWindowBase::SetFont(rFont))
     {
         // nothing to do
     if (!wxWindowBase::SetFont(rFont))
     {
         // nothing to do


@@ -529,15 +589,77 @@ DEBUG_PRINTF(wxWindow::SetFont);
 
     if (hWnd != 0)
     {
 
     if (hWnd != 0)
     {

-        wxChar                      zFont[128];
+        char                        zFont[128];
+        char                        zFacename[30];
+        char                        zWeight[30];
+        char                        zStyle[30];
+
+        //
+        // The fonts available for Presentation Params are just three
+        // outline fonts, the rest are available to the GPI, so we must
+        // map the families to one of these three
+        //
+        switch(rFont.GetFamily())
+        {
+            case wxSCRIPT:
+            case wxDECORATIVE:
+            case wxROMAN:
+                strcpy(zFacename,"Times New Roman");
+                break;
+
+            case wxTELETYPE:
+            case wxMODERN:
+                strcpy(zFacename, "Courier");
+                break;
+
+            case wxSWISS:
+            case wxDEFAULT:
+            default:
+                strcpy(zFacename, "Helvetica");
+                break;
+        }
+
+        switch(rFont.GetWeight())
+        {
+            default:
+            case wxNORMAL:
+            case wxLIGHT:
+                zWeight[0] = '\0';
+                break;
+
+            case wxBOLD:
+            case wxFONTWEIGHT_MAX:
+                strcpy(zWeight, "Bold");
+                break;
+        }
+        switch(rFont.GetStyle())
+        {
+            case wxITALIC:
+            case wxSLANT:
+                strcpy(zStyle, "Italic");
+                break;

 
 

-        sprintf(zFont, "%d.%s", rFont.GetPointSize(), rFont.GetFaceName().c_str());
-        return(::WinSetPresParam(hWnd, PP_FONTNAMESIZE, strlen(zFont), (PVOID)zFont));
+            default:
+                zStyle[0] = '\0';
+                break;
+        }
+        sprintf(zFont, "%d.%s", rFont.GetPointSize(), zFacename);
+        if (zWeight[0] != '\0')
+        {
+            strcat(zFont, " ");
+            strcat(zFont, zWeight);
+        }
+        if (zStyle[0] != '\0')
+        {
+            strcat(zFont, " ");
+            strcat(zFont, zStyle);
+        }
+        ::WinSetPresParam(hWnd, PP_FONTNAMESIZE, strlen(zFont) + 1, (PVOID)zFont);

     }
     return(TRUE);
 }
 
     }
     return(TRUE);
 }
 

-bool wxWindow::SetCursor(
+bool wxWindowOS2::SetCursor(

   const wxCursor&                   rCursor
 ) // check if base implementation is OK
 {
   const wxCursor&                   rCursor
 ) // check if base implementation is OK
 {


@@ -547,30 +669,23 @@ bool wxWindow::SetCursor(
         return FALSE;
     }
 
         return FALSE;
     }
 

-    wxASSERT_MSG( m_cursor.Ok(),
-                  wxT("cursor must be valid after call to the base version"));
-
-    HWND                            hWnd = GetHwnd();
-    POINTL                          vPoint;
-    RECTL                           vRect;
-    HPS                             hPS;
-    HRGN                            hRGN;
-
-    hPS = ::WinGetPS(hWnd);
-
-    ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
-    ::WinQueryWindowRect(hWnd, &vRect);
+    if ( m_cursor.Ok() ) {
+        HWND                            hWnd = GetHwnd();
+        POINTL                          vPoint;
+        RECTL                           vRect;

 
 

-    hRGN = ::GpiCreateRegion(hPS, 1L, &vRect);
+        ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
+        ::WinQueryWindowRect(hWnd, &vRect);

 
 

-    if ((::GpiPtInRegion(hPS, hRGN, &vPoint) == PRGN_INSIDE) && !wxIsBusy())
-    {
-        ::WinSetPointer(HWND_DESKTOP, (HPOINTER)m_cursor.GetHCURSOR());
+        if (::WinPtInRect(vHabmain, &vRect, &vPoint) && !wxIsBusy())
+        {
+            ::WinSetPointer(HWND_DESKTOP, (HPOINTER)m_cursor.GetHCURSOR());
+        }

     }
     return TRUE;
     }
     return TRUE;

-} // end of wxWindow::SetCursor
+} // end of wxWindowOS2::SetCursor

 
 

-void wxWindow::WarpPointer(
+void wxWindowOS2::WarpPointer(

   int                               nXPos
 , int                               nYPos
 )
   int                               nXPos
 , int                               nYPos
 )


@@ -584,10 +699,10 @@ void wxWindow::WarpPointer(
     nY += vRect.yBottom;
 
     ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY));
     nY += vRect.yBottom;
 
     ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY));

-} // end of wxWindow::WarpPointer
+} // end of wxWindowOS2::WarpPointer

 
 #if WXWIN_COMPATIBILITY
 
 #if WXWIN_COMPATIBILITY

-void wxWindow::OS2DeviceToLogical (float *x, float *y) const
+void wxWindowOS2::OS2DeviceToLogical (float *x, float *y) const

 {
 }
 #endif // WXWIN_COMPATIBILITY
 {
 }
 #endif // WXWIN_COMPATIBILITY


@@ -597,28 +712,45 @@ void wxWindow::OS2DeviceToLogical (float *x, float *y) const
 // ---------------------------------------------------------------------------
 
 #if WXWIN_COMPATIBILITY
 // ---------------------------------------------------------------------------
 
 #if WXWIN_COMPATIBILITY

-void wxWindow::SetScrollRange(
+void wxWindowOS2::SetScrollRange(

   int                               nOrient
 , int                               nRange
 , bool                              bRefresh
 )
 {
   int                               nOrient
 , int                               nRange
 , bool                              bRefresh
 )
 {

-    ::WinSendMsg(GetHwnd(), SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, nRange));
-} // end of wxWindow::SetScrollRange
+    int                             nRange1 = nRange;
+    int                             nPageSize = GetScrollPage(nOrient);

 
 

-void wxWindow::SetScrollPage(
+    if (nPpageSize > 1 && nRange > 0)
+    {
+        nRange1 += (nPageSize - 1);
+    }
+
+    if (nOrient == wxHORIZONTAL)
+    {
+        ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1));
+        ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+    }
+    else
+    {
+        ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1));
+        ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+    }
+} // end of wxWindowOS2::SetScrollRange
+
+void wxWindowOS2::SetScrollPage(

   int                               nOrient
 , int                               nPage
 , bool                              bRefresh
 )
 {
   int                               nOrient
 , int                               nPage
 , bool                              bRefresh
 )
 {

-    if ( orient == wxHORIZONTAL )
-        m_xThumbSize = page;
+    if (nOrient == wxHORIZONTAL )
+        m_nXThumbSize = nPage;

     else
     else

-        m_yThumbSize = page;
-}
+        m_nYThumbSize = nPage;
+} // end of wxWindowOS2::SetScrollPage

 
 

-int wxWindow::OldGetScrollRange(
+int wxWindowOS2::OldGetScrollRange(

   int                               nOrient
 ) const
 {
   int                               nOrient
 ) const
 {


@@ -631,9 +763,9 @@ int wxWindow::OldGetScrollRange(
         return(SHORT2FROMMR(mRc));
      }
      return 0;
         return(SHORT2FROMMR(mRc));
      }
      return 0;

-} // end of wxWindow::OldGetScrollRange
+} // end of wxWindowOS2::OldGetScrollRange

 
 

-int  wxWindow::GetScrollPage(
+int  wxWindowOS2::GetScrollPage(

   int                               nOrient
 ) const
 {
   int                               nOrient
 ) const
 {


@@ -641,93 +773,283 @@ int  wxWindow::GetScrollPage(
         return m_nXThumbSize;
     else
         return m_nYThumbSize;
         return m_nXThumbSize;
     else
         return m_nYThumbSize;

-} // end of wxWindow::GetScrollPage
+} // end of wxWindowOS2::GetScrollPage

 #endif // WXWIN_COMPATIBILITY
 
 #endif // WXWIN_COMPATIBILITY
 

-int  wxWindow::GetScrollPos(
+int  wxWindowOS2::GetScrollPos(

   int                               nOrient
 ) const
 {
   int                               nOrient
 ) const
 {

-    return((int)::WinSendMsg(GetHwnd(), SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
-} // end of wxWindow::GetScrollPos
+    if (nOrient == wxHORIZONTAL)
+        return((int)::WinSendMsg(m_hWndScrollBarHorz, SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
+    else
+        return((int)::WinSendMsg(m_hWndScrollBarVert, SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
+} // end of wxWindowOS2::GetScrollPos

 
 

-int wxWindow::GetScrollRange(
+int wxWindowOS2::GetScrollRange(

   int                               nOrient
 ) const
 {
     MRESULT                         mr;
 
   int                               nOrient
 ) const
 {
     MRESULT                         mr;
 

-    mr = ::WinSendMsg(GetHwnd(), SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
+    if (nOrient == wxHORIZONTAL)
+        mr = ::WinSendMsg(m_hWndScrollBarHorz, SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
+    else
+        mr = ::WinSendMsg(m_hWndScrollBarVert, SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);

     return((int)SHORT2FROMMR(mr));
     return((int)SHORT2FROMMR(mr));

-} // end of wxWindow::GetScrollRange
+} // end of wxWindowOS2::GetScrollRange

 
 

-int wxWindow::GetScrollThumb(
+int wxWindowOS2::GetScrollThumb(

   int                               nOrient
 ) const
 {
   int                               nOrient
 ) const
 {

-    WNDPARAMS                       vWndParams;
-    PSBCDATA                        pSbcd;
-
-    ::WinSendMsg(GetHwnd(), WM_QUERYWINDOWPARAMS, (MPARAM)&vWndParams, (MPARAM)NULL);
-    pSbcd = (PSBCDATA)vWndParams.pCtlData;
-    return((int)pSbcd->posThumb);
-} // end of wxWindow::GetScrollThumb
+    if (nOrient == wxHORIZONTAL )
+        return m_nXThumbSize;
+    else
+        return m_nYThumbSize;
+} // end of wxWindowOS2::GetScrollThumb

 
 

-void wxWindow::SetScrollPos(
+void wxWindowOS2::SetScrollPos(

   int                               nOrient
 , int                               nPos
   int                               nOrient
 , int                               nPos

-, bool                              bRefresh
+, bool                              WXUNUSED(bRefresh)

 )
 {
 )
 {

-    ::WinSendMsg(GetHwnd(), SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
-} // end of wxWindow::SetScrollPos(
+    if (nOrient == wxHORIZONTAL )
+        ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
+    else
+        ::WinSendMsg(m_hWndScrollBarVert, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
+} // end of wxWindowOS2::SetScrollPos

 
 

-void wxWindow::SetScrollbar(
+void wxWindowOS2::SetScrollbar(

   int                               nOrient
 , int                               nPos
 , int                               nThumbVisible
 , int                               nRange
   int                               nOrient
 , int                               nPos
 , int                               nThumbVisible
 , int                               nRange

-, bool                              bRefresh
+, bool                              WXUNUSED(bRefresh)

 )
 {
 )
 {

-    ::WinSendMsg(GetHwnd(), SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, nRange));
-    if (nOrient == wxHORIZONTAL)
+    int                             nOldRange = nRange - nThumbVisible;
+    int                             nRange1 = nOldRange;
+    int                             nPageSize = nThumbVisible;
+    SBCDATA                         vInfo;
+    HWND                            hWnd = GetHwnd();
+    ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;
+    RECTL                           vRect;
+
+    ::WinQueryWindowRect(hWnd, &vRect);
+    if (nPageSize > 1 && nRange > 0)
+    {
+        nRange1 += (nPageSize - 1);
+    }
+
+    vInfo.cb = sizeof(SBCDATA);
+    vInfo.posFirst = 0;
+    vInfo.posLast = (SHORT)nRange1;
+    vInfo.posThumb = nPos;
+
+    if (nOrient == wxHORIZONTAL )

     {
     {

-        m_nXThumbSize = nThumbVisible;
+        ulStyle |= SBS_HORZ;
+        if (m_hWndScrollBarHorz == 0L)
+        {
+            //
+            // We create the scrollbars with the desktop so that they are not
+            // registered as child windows of the window in order that child
+            // windows may be scrolled without scrolling the scrollbars themselves!
+            //
+            m_hWndScrollBarHorz = ::WinCreateWindow( hWnd
+                                                    ,WC_SCROLLBAR
+                                                    ,(PSZ)NULL
+                                                    ,ulStyle
+                                                    ,vRect.xLeft
+                                                    ,vRect.yBottom
+                                                    ,vRect.xRight - vRect.xLeft
+                                                    ,20
+                                                    ,hWnd
+                                                    ,HWND_TOP
+                                                    ,FID_HORZSCROLL
+                                                    ,&vInfo
+                                                    ,NULL
+                                                   );
+        }
+        else
+        {
+            RECTL                   vRect2;
+
+            //
+            // Only want to resize the scrollbar if it changes, otherwise
+            // we'd probably end up in a recursive loop until we crash the call stack
+            // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE
+            // generates those events.
+            //
+            ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect2);
+            if (!(vRect2.xLeft == vRect.xLeft     &&
+                  vRect2.xRight == vRect.xRight   &&
+                  vRect2.yBottom == vRect.yBottom &&
+                  vRect2.yTop == vRect.yTop
+                ) )
+            {
+                ::WinSetWindowPos( m_hWndScrollBarHorz
+                                  ,HWND_TOP
+                                  ,vRect.xLeft
+                                  ,vRect.yBottom
+                                  ,vRect.xRight - vRect.xLeft
+                                  ,20
+                                  ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
+                                 );
+            }
+            ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
+            ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+        }

     }
     else
     {
     }
     else
     {

+        ulStyle |= SBS_VERT;
+        if (m_hWndScrollBarVert == 0L)
+        {
+            m_hWndScrollBarVert = ::WinCreateWindow( hWnd
+                                                    ,WC_SCROLLBAR
+                                                    ,(PSZ)NULL
+                                                    ,ulStyle
+                                                    ,vRect.xRight - 20
+                                                    ,vRect.yBottom + 20
+                                                    ,20
+                                                    ,vRect.yTop - (vRect.yBottom + 20)
+                                                    ,hWnd
+                                                    ,HWND_TOP
+                                                    ,FID_VERTSCROLL
+                                                    ,&vInfo
+                                                    ,NULL
+                                                   );
+        }
+        else
+        {
+            RECTL                   vRect2;
+
+            //
+            // Only want to resize the scrollbar if it changes, otherwise
+            // we'd probably end up in a recursive loop until we crash the call stack
+            // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE
+            // generates those events.
+            //
+            ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect2);
+            if (!(vRect2.xLeft == vRect.xLeft     &&
+                  vRect2.xRight == vRect.xRight   &&
+                  vRect2.yBottom == vRect.yBottom &&
+                  vRect2.yTop == vRect.yTop
+                ) )
+            {
+                ::WinSetWindowPos( m_hWndScrollBarVert
+                                  ,HWND_TOP
+                                  ,vRect.xRight - 20
+                                  ,vRect.yBottom + 20
+                                  ,20
+                                  ,vRect.yTop - (vRect.yBottom + 20)
+                                  ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
+                                 );
+            }
+            ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
+            ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+        }

         m_nYThumbSize = nThumbVisible;
     }
         m_nYThumbSize = nThumbVisible;
     }

-} // end of wxWindow::SetScrollbar
+} // end of wxWindowOS2::SetScrollbar

 
 

-void wxWindow::ScrollWindow(
+void wxWindowOS2::ScrollWindow(

   int                               nDx
 , int                               nDy
 , const wxRect*                     pRect
 )
 {
   int                               nDx
 , int                               nDy
 , const wxRect*                     pRect
 )
 {

+    RECTL                           vRect;

     RECTL                           vRect2;
 
     RECTL                           vRect2;
 

+    nDy *= -1; // flip the sign of Dy as OS/2 is opposite wxWin.

     if (pRect)
     {
         vRect2.xLeft   = pRect->x;
     if (pRect)
     {
         vRect2.xLeft   = pRect->x;

-        vRect2.yTop    = pRect->y;
+        vRect2.yTop    = pRect->y + pRect->height;

         vRect2.xRight  = pRect->x + pRect->width;
         vRect2.xRight  = pRect->x + pRect->width;

-        vRect2.yBottom = pRect->y + pRect->height;
+        vRect2.yBottom = pRect->y;

     }
     }

+    else
+    {
+        ::WinQueryWindowRect(GetHwnd(), &vRect2);
+        ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect);
+        vRect2.yBottom += vRect.yTop - vRect.yBottom;
+        ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect);
+        vRect2.xRight -= vRect.xRight - vRect.xLeft;

 
 

+    }

     if (pRect)
     if (pRect)

-        ::WinScrollWindow(GetHwnd(), (LONG)nDx, (LONG)nDy, &vRect2, NULL, NULLHANDLE, NULL, 0L);
+        ::WinScrollWindow( GetHwnd()
+                          ,(LONG)nDx
+                          ,(LONG)nDy
+                          ,&vRect2
+                          ,NULL
+                          ,NULLHANDLE
+                          ,NULL
+                          ,SW_INVALIDATERGN
+                         );

     else
     else

-        ::WinScrollWindow(GetHwnd(), nDx, nDy, NULL, NULL, NULLHANDLE, NULL, 0L);
-} // end of wxWindow::ScrollWindow
+        ::WinScrollWindow( GetHwnd()
+                          ,nDx
+                          ,nDy
+                          ,NULL
+                          ,NULL
+                          ,NULLHANDLE
+                          ,NULL
+                          ,SW_INVALIDATERGN
+                         );
+
+    //
+    // Move the children
+    wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
+    SWP                             vSwp;
+
+    while (pCurrent)
+    {
+        wxWindow*                   pChildWin = pCurrent->GetData();
+
+        if (pChildWin->GetHWND() != NULLHANDLE)
+        {
+            ::WinQueryWindowPos(pChildWin->GetHWND(), &vSwp);
+            ::WinQueryWindowRect(pChildWin->GetHWND(), &vRect);
+            if (pChildWin->GetHWND() == m_hWndScrollBarVert ||
+                pChildWin->GetHWND() == m_hWndScrollBarHorz)
+            {
+                ::WinSetWindowPos( pChildWin->GetHWND()
+                                  ,HWND_TOP
+                                  ,vSwp.x + nDx
+                                  ,vSwp.y + nDy
+                                  ,0
+                                  ,0
+                                  ,SWP_MOVE | SWP_SHOW | SWP_ZORDER
+                                 );
+            }
+            else
+            {
+                ::WinSetWindowPos( pChildWin->GetHWND()
+                                  ,HWND_BOTTOM
+                                  ,vSwp.x + nDx
+                                  ,vSwp.y + nDy
+                                  ,0
+                                  ,0
+                                  ,SWP_MOVE | SWP_ZORDER
+                                 );
+                ::WinInvalidateRect(pChildWin->GetHWND(), &vRect, FALSE);
+            }
+        }
+        pCurrent = pCurrent->GetNext();
+    }
+} // end of wxWindowOS2::ScrollWindow

 
 // ---------------------------------------------------------------------------
 // subclassing
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // subclassing
 // ---------------------------------------------------------------------------
 

-void wxWindow::SubclassWin(
+void wxWindowOS2::SubclassWin(

   WXHWND                            hWnd
 )
 {
   WXHWND                            hWnd
 )
 {


@@ -736,9 +1058,9 @@ void wxWindow::SubclassWin(
     wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
     wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );
     m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);
     wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
     wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );
     m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);

-} // end of wxWindow::SubclassWin
+} // end of wxWindowOS2::SubclassWin

 
 

-void wxWindow::UnsubclassWin()
+void wxWindowOS2::UnsubclassWin()

 {
     //
     // Restore old Window proc
 {
     //
     // Restore old Window proc


@@ -757,29 +1079,45 @@ void wxWindow::UnsubclassWin()
             m_fnOldWndProc = 0;
         }
     }
             m_fnOldWndProc = 0;
         }
     }

-} // end of wxWindow::UnsubclassWin
+} // end of wxWindowOS2::UnsubclassWin

 
 //
 // Make a Windows extended style from the given wxWindows window style
 //
 
 //
 // Make a Windows extended style from the given wxWindows window style
 //

-WXDWORD wxWindow::MakeExtendedStyle(
+WXDWORD wxWindowOS2::MakeExtendedStyle(

   long                              lStyle
 , bool                              bEliminateBorders
 )
 {
    //
   long                              lStyle
 , bool                              bEliminateBorders
 )
 {
    //

-   // PM does not support extended style
+   // Simply fill out with wxWindow extended styles.  We'll conjure
+   // something up in OS2Create and all window redrawing pieces later

    //
    //

-    WXDWORD                         exStyle = 0;
-    return exStyle;
-} // end of wxWindow::MakeExtendedStyle
+    WXDWORD                         dwStyle = 0;
+
+    if (lStyle & wxTRANSPARENT_WINDOW )
+        dwStyle |= wxTRANSPARENT_WINDOW;
+
+    if (!bEliminateBorders)
+    {
+        if (lStyle & wxSUNKEN_BORDER)
+            dwStyle |= wxSUNKEN_BORDER;
+        if (lStyle & wxDOUBLE_BORDER)
+            dwStyle |= wxDOUBLE_BORDER;
+        if (lStyle & wxRAISED_BORDER )
+            dwStyle |= wxRAISED_BORDER;
+        if (lStyle & wxSTATIC_BORDER)
+            dwStyle |= wxSTATIC_BORDER;
+    }
+    return dwStyle;
+} // end of wxWindowOS2::MakeExtendedStyle

 
 //
 
 //

-// Determines whether native 3D effects or CTL3D should be used,
+// Determines whether simulated 3D effects or CTL3D should be used,

 // applying a default border style if required, and returning an extended
 // applying a default border style if required, and returning an extended

-// style to pass to CreateWindowEx.
+// style to pass to OS2Create.

 //
 //

-WXDWORD wxWindow::Determine3DEffects(
+WXDWORD wxWindowOS2::Determine3DEffects(

   WXDWORD                           dwDefaultBorderStyle
 , bool*                             pbWant3D
 ) const
   WXDWORD                           dwDefaultBorderStyle
 , bool*                             pbWant3D
 ) const


@@ -787,14 +1125,70 @@ WXDWORD wxWindow::Determine3DEffects(
     WXDWORD                         dwStyle = 0L;
 
     //
     WXDWORD                         dwStyle = 0L;
 
     //

-    // Native PM does not have any specialize 3D effects like WIN32 does
+    // Native PM does not have any specialize 3D effects like WIN32 does,
+    // so we have to try and invent them.
+    //
+
+    //
+    // If matches certain criteria, then assume no 3D effects
+    // unless specifically requested (dealt with in MakeExtendedStyle)
+    //
+    if (!GetParent()                    ||
+        !IsKindOf(CLASSINFO(wxControl)) ||
+        (m_windowStyle & wxNO_BORDER)
+       )
+    {
+        *pbWant3D = FALSE;
+        return MakeExtendedStyle(m_windowStyle, FALSE);
+    }
+
+    //
+    // 1) App can specify global 3D effects

     //
     //

-    *pbWant3D = FALSE;
+    *pbWant3D = wxTheApp->GetAuto3D();
+
+    //
+    // 2) If the parent is being drawn with user colours, or simple border
+    //    specified, switch effects off.
+    //
+    if (GetParent() &&
+        (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS) ||
+        (m_windowStyle & wxSIMPLE_BORDER)
+       )
+        *pbWant3D = FALSE;
+
+    //
+    // 3) Control can override this global setting by defining
+    //    a border style, e.g. wxSUNKEN_BORDER
+    //
+    if ((m_windowStyle & wxDOUBLE_BORDER) ||
+        (m_windowStyle & wxRAISED_BORDER) ||
+        (m_windowStyle & wxSTATIC_BORDER) ||
+        (m_windowStyle & wxSUNKEN_BORDER)
+       )
+        *pbWant3D = TRUE;
+
+    dwStyle = MakeExtendedStyle( m_windowStyle
+                                ,FALSE
+                               );
+
+    //
+    // If we want 3D, but haven't specified a border here,
+    // apply the default border style specified.
+    //
+    if (dwDefaultBorderStyle && (*pbWant3D) &&
+        !((m_windowStyle & wxDOUBLE_BORDER) ||
+          (m_windowStyle & wxRAISED_BORDER) ||
+          (m_windowStyle & wxSTATIC_BORDER) ||
+          (m_windowStyle & wxSIMPLE_BORDER)
+         )
+        )
+        dwStyle |= dwDefaultBorderStyle;

     return dwStyle;
     return dwStyle;

-} // end of wxWindow::Determine3DEffects
+} // end of wxWindowOS2::Determine3DEffects

 
 #if WXWIN_COMPATIBILITY
 
 #if WXWIN_COMPATIBILITY

-void wxWindow::OnCommand(
+void wxWindowOS2::OnCommand(

   wxWindow&                         rWin
 , wxCommandEvent&                   rEvent
 )
   wxWindow&                         rWin
 , wxCommandEvent&                   rEvent
 )


@@ -805,9 +1199,9 @@ void wxWindow::OnCommand(
         m_parent->GetEventHandler()->OnCommand( rWin
                                                ,rEvent
                                               );
         m_parent->GetEventHandler()->OnCommand( rWin
                                                ,rEvent
                                               );

-} // end of wxWindow::OnCommand
+} // end of wxWindowOS2::OnCommand

 
 

-wxObject* wxWindow::GetChild(
+wxObject* wxWindowOS2::GetChild(

   int                               nNumber
 ) const
 {
   int                               nNumber
 ) const
 {


@@ -826,21 +1220,21 @@ wxObject* wxWindow::GetChild(
     }
     else
         return NULL;
     }
     else
         return NULL;

-} // end of wxWindow::GetChild
+} // end of wxWindowOS2::GetChild

 
 #endif // WXWIN_COMPATIBILITY
 
 //
 // Setup background and foreground colours correctly
 //
 
 #endif // WXWIN_COMPATIBILITY
 
 //
 // Setup background and foreground colours correctly
 //

-void wxWindow::SetupColours()
+void wxWindowOS2::SetupColours()

 {
     if ( GetParent() )
         SetBackgroundColour(GetParent()->GetBackgroundColour());
 {
     if ( GetParent() )
         SetBackgroundColour(GetParent()->GetBackgroundColour());

-} // end of wxWindow::SetupColours
+} // end of wxWindowOS2::SetupColours

 
 

-void wxWindow::OnIdle(
-  wxIdleEvent&                      rEvent
+void wxWindowOS2::OnIdle(
+  wxIdleEvent&                      WXUNUSED(rEvent)

 )
 {
     //
 )
 {
     //


@@ -881,12 +1275,12 @@ void wxWindow::OnIdle(
         }
     }
     UpdateWindowUI();
         }
     }
     UpdateWindowUI();

-} // end of wxWindow::OnIdle
+} // end of wxWindowOS2::OnIdle

 
 //
 // Set this window to be the child of 'parent'.
 //
 
 //
 // Set this window to be the child of 'parent'.
 //

-bool wxWindow::Reparent(
+bool wxWindowOS2::Reparent(

   wxWindow*                         pParent
 )
 {
   wxWindow*                         pParent
 )
 {


@@ -898,20 +1292,20 @@ bool wxWindow::Reparent(
 
     ::WinSetParent(hWndChild, hWndParent, TRUE);
     return TRUE;
 
     ::WinSetParent(hWndChild, hWndParent, TRUE);
     return TRUE;

-} // end of wxWindow::Reparent
+} // end of wxWindowOS2::Reparent

 
 

-void wxWindow::Clear()
+void wxWindowOS2::Clear()

 {
 {

-    wxClientDC                      vDc(this);
+    wxClientDC                      vDc((wxWindow*)this);

     wxBrush                         vBrush( GetBackgroundColour()
                                            ,wxSOLID
                                           );
 
     vDc.SetBackground(vBrush);
     vDc.Clear();
     wxBrush                         vBrush( GetBackgroundColour()
                                            ,wxSOLID
                                           );
 
     vDc.SetBackground(vBrush);
     vDc.Clear();

-} // end of wxWindow::Clear
+} // end of wxWindowOS2::Clear

 
 

-void wxWindow::Refresh(
+void wxWindowOS2::Refresh(

   bool                              bEraseBack
 , const wxRect*                     pRect
 )
   bool                              bEraseBack
 , const wxRect*                     pRect
 )


@@ -934,14 +1328,14 @@ void wxWindow::Refresh(
         else
             ::WinInvalidateRect(hWnd, NULL, bEraseBack);
     }
         else
             ::WinInvalidateRect(hWnd, NULL, bEraseBack);
     }

-} // end of wxWindow::Refresh
+} // end of wxWindowOS2::Refresh

 
 // ---------------------------------------------------------------------------
 // drag and drop
 // ---------------------------------------------------------------------------
 
 #if wxUSE_DRAG_AND_DROP
 
 // ---------------------------------------------------------------------------
 // drag and drop
 // ---------------------------------------------------------------------------
 
 #if wxUSE_DRAG_AND_DROP

-void wxWindow::SetDropTarget(
+void wxWindowOS2::SetDropTarget(

   wxDropTarget*                     pDropTarget
 )
 {
   wxDropTarget*                     pDropTarget
 )
 {


@@ -953,14 +1347,14 @@ void wxWindow::SetDropTarget(
     m_dropTarget = pDropTarget;
     if (m_dropTarget != 0)
         m_dropTarget->Register(m_hWnd);
     m_dropTarget = pDropTarget;
     if (m_dropTarget != 0)
         m_dropTarget->Register(m_hWnd);

-} // end of wxWindow::SetDropTarget
+} // end of wxWindowOS2::SetDropTarget

 #endif
 
 //
 // old style file-manager drag&drop support: we retain the old-style
 // DragAcceptFiles in parallel with SetDropTarget.
 //
 #endif
 
 //
 // old style file-manager drag&drop support: we retain the old-style
 // DragAcceptFiles in parallel with SetDropTarget.
 //

-void wxWindow::DragAcceptFiles(
+void wxWindowOS2::DragAcceptFiles(

   bool                              bAccept
 )
 {
   bool                              bAccept
 )
 {


@@ -968,7 +1362,7 @@ void wxWindow::DragAcceptFiles(
 
     if (hWnd && bAccept)
         ::DrgAcceptDroppedFiles(hWnd, NULL, NULL, DO_COPY, 0L);
 
     if (hWnd && bAccept)
         ::DrgAcceptDroppedFiles(hWnd, NULL, NULL, DO_COPY, 0L);

-} // end of wxWindow::DragAcceptFiles
+} // end of wxWindowOS2::DragAcceptFiles

 
 // ----------------------------------------------------------------------------
 // tooltips
 
 // ----------------------------------------------------------------------------
 // tooltips


@@ -976,7 +1370,7 @@ void wxWindow::DragAcceptFiles(
 
 #if wxUSE_TOOLTIPS
 
 
 #if wxUSE_TOOLTIPS
 

-void wxWindow::DoSetToolTip(
+void wxWindowOS2::DoSetToolTip(

   wxToolTip*                        pTooltip
 )
 {
   wxToolTip*                        pTooltip
 )
 {


@@ -984,7 +1378,7 @@ void wxWindow::DoSetToolTip(
 
     if (m_tooltip)
         m_tooltip->SetWindow(this);
 
     if (m_tooltip)
         m_tooltip->SetWindow(this);

-} // end of wxWindow::DoSetToolTip
+} // end of wxWindowOS2::DoSetToolTip

 
 #endif // wxUSE_TOOLTIPS
 
 
 #endif // wxUSE_TOOLTIPS
 


@@ -993,7 +1387,7 @@ void wxWindow::DoSetToolTip(
 // ---------------------------------------------------------------------------
 
 // Get total size
 // ---------------------------------------------------------------------------
 
 // Get total size

-void wxWindow::DoGetSize(
+void wxWindowOS2::DoGetSize(

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


@@ -1008,51 +1402,40 @@ void wxWindow::DoGetSize(
     if (pHeight )
         // OS/2 PM is backwards from windows
         *pHeight = vRect.yTop - vRect.yBottom;
     if (pHeight )
         // OS/2 PM is backwards from windows
         *pHeight = vRect.yTop - vRect.yBottom;

-} // end of wxWindow::DoGetSize
+} // end of wxWindowOS2::DoGetSize

 
 

-void wxWindow::DoGetPosition(
+void wxWindowOS2::DoGetPosition(

   int*                              pX
 , int*                              pY
 ) const
 {
     HWND                            hWnd = GetHwnd();
   int*                              pX
 , int*                              pY
 ) const
 {
     HWND                            hWnd = GetHwnd();

-    RECT                            vRect;
+    SWP                             vSwp;

     POINTL                          vPoint;
     POINTL                          vPoint;

+    wxWindow*                       pParent = GetParent();

 
 

-    ::WinQueryWindowRect(hWnd, &vRect);
+    //
+    // It would seem that WinQueryWindowRect would be the correlary to
+    // the WIN32 WinGetRect, but unlike WinGetRect which returns the window
+    // origin position in screen coordinates, WinQueryWindowRect returns it
+    // relative to itself, i.e. (0,0).  To get the same under PM we must
+    // us WinQueryWindowPos.  This call, unlike the WIN32 call, however,
+    // returns a position relative to it's parent, so no parent adujstments
+    // are needed under OS/2.  Also, windows should be created using
+    // wxWindow coordinates, i.e 0,0 is the TOP left so vSwp will already
+    // reflect that.
+    //
+    ::WinQueryWindowPos(hWnd, &vSwp);

 
 

-    vPoint.x = vRect.xLeft;
-    vPoint.y = vRect.yBottom;
+    vPoint.x = vSwp.x;
+    vPoint.y = vSwp.y;

 
     //
 
     //

-    // We do the adjustments with respect to the parent only for the "real"
-    // children, not for the dialogs/frames
+    // We may be faking the client origin. So a window that's really at (0,
+    // 30) may appear (to wxWin apps) to be at (0, 0).

     //
     //

-    if (!IsTopLevel())
+    if (pParent)

     {
     {

-        HWND                        hParentWnd = 0;
-        wxWindow*                   pParent = GetParent();
-
-        if (pParent)
-            hParentWnd = GetWinHwnd(pParent);
-
-        //
-        // Since we now have the absolute screen coords, if there's a parent we
-        // must subtract its bottom left corner
-        //
-        if (hParentWnd)
-        {
-            RECTL                   vRect2;
-
-            ::WinQueryWindowRect(hParentWnd, &vRect2);
-            vPoint.x -= vRect.xLeft;
-            vPoint.y -= vRect.yBottom;
-        }
-
-        //
-        // We may be faking the client origin. So a window that's really at (0,
-        // 30) may appear (to wxWin apps) to be at (0, 0).
-        //

         wxPoint                     vPt(pParent->GetClientAreaOrigin());
 
         vPoint.x -= vPt.x;
         wxPoint                     vPt(pParent->GetClientAreaOrigin());
 
         vPoint.x -= vPt.x;


@@ -1063,9 +1446,9 @@ void wxWindow::DoGetPosition(
         *pX = vPoint.x;
     if  (pY)
         *pY = vPoint.y;
         *pX = vPoint.x;
     if  (pY)
         *pY = vPoint.y;

-} // end of wxWindow::DoGetPosition
+} // end of wxWindowOS2::DoGetPosition

 
 

-void wxWindow::DoScreenToClient(
+void wxWindowOS2::DoScreenToClient(

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


@@ -1076,12 +1459,12 @@ void wxWindow::DoScreenToClient(
     ::WinQueryWindowPos(hWnd, &vSwp);
 
     if (pX)
     ::WinQueryWindowPos(hWnd, &vSwp);
 
     if (pX)

-        *pX -= vSwp.x;
+        *pX += vSwp.x;

     if (pY)
     if (pY)

-        *pY -= vSwp.y;
-} // end of wxWindow::DoScreenToClient
+        *pY += vSwp.y;
+} // end of wxWindowOS2::DoScreenToClient

 
 

-void wxWindow::DoClientToScreen(
+void wxWindowOS2::DoClientToScreen(

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


@@ -1095,13 +1478,13 @@ void wxWindow::DoClientToScreen(
         *pX += vSwp.x;
     if (pY)
         *pY += vSwp.y;
         *pX += vSwp.x;
     if (pY)
         *pY += vSwp.y;

-} // end of wxWindow::DoClientToScreen
+} // end of wxWindowOS2::DoClientToScreen

 
 //
 // Get size *available for subwindows* i.e. excluding menu bar etc.
 // Must be a frame type window
 //
 
 //
 // Get size *available for subwindows* i.e. excluding menu bar etc.
 // Must be a frame type window
 //

-void wxWindow::DoGetClientSize(
+void wxWindowOS2::DoGetClientSize(

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


@@ -1110,7 +1493,10 @@ void wxWindow::DoGetClientSize(
     HWND                            hWndClient;
     RECTL                           vRect;
 
     HWND                            hWndClient;
     RECTL                           vRect;
 

-    hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
+    if (IsKindOf(CLASSINFO(wxFrame)))
+        hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
+    else
+        hWndClient = NULLHANDLE;

     if( hWndClient == NULLHANDLE)
        ::WinQueryWindowRect(GetHwnd(), &vRect);
     else
     if( hWndClient == NULLHANDLE)
        ::WinQueryWindowRect(GetHwnd(), &vRect);
     else


@@ -1120,27 +1506,51 @@ void wxWindow::DoGetClientSize(
         *pWidth  = vRect.xRight;
     if (pHeight)
         *pHeight = vRect.yTop;
         *pWidth  = vRect.xRight;
     if (pHeight)
         *pHeight = vRect.yTop;

-} // end of wxWindow::DoGetClientSize
+} // end of wxWindowOS2::DoGetClientSize

 
 

-void wxWindow::DoMoveWindow(
+void wxWindowOS2::DoMoveWindow(

   int                               nX
 , int                               nY
 , int                               nWidth
 , int                               nHeight
 )
 {
   int                               nX
 , int                               nY
 , int                               nWidth
 , int                               nHeight
 )
 {

-    if ( !::WinSetWindowPos( GetHwnd()
-                            ,HWND_TOP
-                            ,(LONG)nX
-                            ,(LONG)nY
-                            ,(LONG)nWidth
-                            ,(LONG)nHeight
-                            ,SWP_SIZE | SWP_MOVE
-                           ))
+    RECTL                           vRect;
+    HWND                            hParent;
+    wxWindow*                       pParent = GetParent();
+
+    if (pParent)
+    {
+        hParent = GetWinHwnd(pParent);
+        if (pParent->IsKindOf(CLASSINFO(wxFrame)))
+        {
+            if (IsKindOf(CLASSINFO(wxStatusBar)) ||
+                IsKindOf(CLASSINFO(wxMenuBar)) ||
+                IsKindOf(CLASSINFO(wxToolBar))
+               )
+                nY = pParent->GetSize().y - (nY + nHeight);
+            else
+                nY = pParent->GetClientSize().y - (nY + nHeight);
+        }
+        else
+            nY = pParent->GetSize().y - (nY + nHeight);
+    }
+    else

     {
     {

-        wxLogLastError("MoveWindow");
+        RECTL                       vRect;
+
+        ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
+        nY = vRect.yTop - (nY + nHeight);

     }
     }

-} // end of wxWindow::DoMoveWindow
+    ::WinSetWindowPos( GetHwnd()
+                      ,HWND_TOP
+                      ,(LONG)nX
+                      ,(LONG)nY
+                      ,(LONG)nWidth
+                      ,(LONG)nHeight
+                      ,SWP_ZORDER | SWP_SIZE | SWP_MOVE | SWP_SHOW
+                     );
+} // end of wxWindowOS2::DoMoveWindow

 
 //
 // Set the size of the window: if the dimensions are positive, just use them,
 
 //
 // Set the size of the window: if the dimensions are positive, just use them,


@@ -1152,7 +1562,7 @@ void wxWindow::DoMoveWindow(
 // the width/height to best suit our contents, otherwise we reuse the current
 // width/height
 //
 // the width/height to best suit our contents, otherwise we reuse the current
 // width/height
 //

-void wxWindow::DoSetSize(
+void wxWindowOS2::DoSetSize(

   int                               nX
 , int                               nY
 , int                               nWidth
   int                               nX
 , int                               nY
 , int                               nWidth


@@ -1169,21 +1579,12 @@ void wxWindow::DoSetSize(
     int                             nCurrentHeight;
     wxSize                          vSize(-1, -1);
 
     int                             nCurrentHeight;
     wxSize                          vSize(-1, -1);
 

-    GetPosition( &nCurrentX
-                ,&nCurrentY
-               );
-    GetSize( &nCurrentWidth
-            ,&nCurrentHeight
-           );
+    GetPosition(&nCurrentX, &nCurrentY);
+    GetSize(&nCurrentWidth, &nCurrentHeight);

 
 

-    //

     // ... and don't do anything (avoiding flicker) if it's already ok
     // ... and don't do anything (avoiding flicker) if it's already ok

-    //
-    if ( nX == nCurrentX &&
-         nY == nCurrentY &&
-         nWidth == nCurrentWidth &&
-         nHeight == nCurrentHeight
-       )
+    if (nX == nCurrentX && nY == nCurrentY &&
+        nWidth == nCurrentWidth && nHeight == nCurrentHeight)

     {
         return;
     }
     {
         return;
     }


@@ -1193,10 +1594,7 @@ void wxWindow::DoSetSize(
     if (nY == -1 && !(nSizeFlags & wxSIZE_ALLOW_MINUS_ONE))
         nY = nCurrentY;
 
     if (nY == -1 && !(nSizeFlags & wxSIZE_ALLOW_MINUS_ONE))
         nY = nCurrentY;
 

-    AdjustForParentClientOrigin( nX
-                                ,nY
-                                ,nSizeFlags
-                               );
+    AdjustForParentClientOrigin(nX, nY, nSizeFlags);

 
     if (nWidth == -1)
     {
 
     if (nWidth == -1)
     {


@@ -1236,9 +1634,9 @@ void wxWindow::DoSetSize(
                  ,nWidth
                  ,nHeight
                 );
                  ,nWidth
                  ,nHeight
                 );

-} // end of wxWindow::DoSetSize
+} // end of wxWindowOS2::DoSetSize

 
 

-void wxWindow::DoSetClientSize(
+void wxWindowOS2::DoSetClientSize(

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


@@ -1246,33 +1644,20 @@ void wxWindow::DoSetClientSize(
     wxWindow*                       pParent = GetParent();
     HWND                            hWnd = GetHwnd();
     HWND                            hParentWnd = (HWND)0;
     wxWindow*                       pParent = GetParent();
     HWND                            hWnd = GetHwnd();
     HWND                            hParentWnd = (HWND)0;

-    HWND                            hClientWnd = (HWND)0;
+    POINTL                          vPoint;

     RECTL                           vRect;
     RECTL                           vRect;

-    RECT                            vRect2;
-    RECT                            vRect3;
+    RECTL                           vRect2;
+    RECTL                           vRect3;
+    HWND                            hClientWnd = (HWND)0;

 
 

-    hClientWnd = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
+    hClientWnd = ::WinWindowFromID(hWnd, FID_CLIENT);

     ::WinQueryWindowRect(hClientWnd, &vRect2);
     ::WinQueryWindowRect(hClientWnd, &vRect2);

-
-    if (pParent)
-        hParentWnd = (HWND) pParent->GetHWND();
-

     ::WinQueryWindowRect(hWnd, &vRect);
     ::WinQueryWindowRect(hParentWnd, &vRect3);
     ::WinQueryWindowRect(hWnd, &vRect);
     ::WinQueryWindowRect(hParentWnd, &vRect3);

-    //
-    // Find the difference between the entire window (title bar and all)
-    // and the client area; add this to the new client size to move the
-    // window. OS/2 is backward from windows on height
-    //
+

     int                             nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth;
     int                             nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight;
 
     int                             nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth;
     int                             nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight;
 

-    //
-    // If there's a parent, must subtract the parent's bottom left corner
-    // since MoveWindow moves relative to the parent
-    //
-    POINTL                          vPoint;
-

     vPoint.x = vRect2.xLeft;
     vPoint.y = vRect2.yBottom;
     if (pParent)
     vPoint.x = vRect2.xLeft;
     vPoint.y = vRect2.yBottom;
     if (pParent)


@@ -1281,70 +1666,39 @@ void wxWindow::DoSetClientSize(
         vPoint.y -= vRect3.yBottom;
     }
 
         vPoint.y -= vRect3.yBottom;
     }
 

-    DoMoveWindow( vPoint.x
-                 ,vPoint.y
-                 ,nActualWidth
-                 ,nActualHeight
-                );
-
-    wxSizeEvent                     vEvent( wxSize( nWidth
-                                                  ,nHeight
-                                                 )
-                                           ,m_windowId
-                                          );
+    DoMoveWindow(vPoint.x, vPoint.y, nActualWidth, nActualHeight);

 
 

+    wxSizeEvent                     vEvent(wxSize(nWidth, nHeight), m_windowId);

     vEvent.SetEventObject(this);
     GetEventHandler()->ProcessEvent(vEvent);
     vEvent.SetEventObject(this);
     GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::DoSetClientSize
+} // end of wxWindowOS2::DoSetClientSize

 
 

-wxPoint wxWindow::GetClientAreaOrigin() const
+wxPoint wxWindowOS2::GetClientAreaOrigin() const

 {
     return wxPoint(0, 0);
 {
     return wxPoint(0, 0);

-} // end of wxWindow::GetClientAreaOrigin
-
-void wxWindow::AdjustForParentClientOrigin(
-  int&                              rX
-, int&                              rY
-, int                               nSizeFlags
-)
-{
-    //
-    // Don't do it for the dialogs/frames - they float independently of their
-    // parent
-    //
-    if (!IsTopLevel())
-    {
-        wxWindow*                   pParent = GetParent();
-
-        if (!(nSizeFlags & wxSIZE_NO_ADJUSTMENTS) && pParent)
-        {
-            wxPoint                 vPoint(pParent->GetClientAreaOrigin());
-            rX += vPoint.x;
-            rY += vPoint.y;
-        }
-    }
-} // end of wxWindow::AdjustForParentClientOrigin
+} // end of wxWindowOS2::GetClientAreaOrigin

 
 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------
 

-int wxWindow::GetCharHeight() const
+int wxWindowOS2::GetCharHeight() const

 {
     HPS                             hPs;
     FONTMETRICS                     vFontMetrics;
 {
     HPS                             hPs;
     FONTMETRICS                     vFontMetrics;

-    BOOL                            bRc;

 
     hPs = ::WinGetPS(GetHwnd());
 
     if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics))
 
     hPs = ::WinGetPS(GetHwnd());
 
     if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics))

+    {
+        ::WinReleasePS(hPs);

         return (0);
         return (0);

-    else
-        return(vFontMetrics.lMaxAscender + vFontMetrics.lMaxDescender);
+    }

     ::WinReleasePS(hPs);
     ::WinReleasePS(hPs);

-} // end of wxWindow::GetCharHeight
+    return(vFontMetrics.lMaxAscender + vFontMetrics.lMaxDescender);
+} // end of wxWindowOS2::GetCharHeight

 
 

-int wxWindow::GetCharWidth() const
+int wxWindowOS2::GetCharWidth() const

 {
     HPS                             hPs;
     FONTMETRICS                     vFontMetrics;
 {
     HPS                             hPs;
     FONTMETRICS                     vFontMetrics;


@@ -1352,13 +1706,15 @@ int wxWindow::GetCharWidth() const
     hPs = ::WinGetPS(GetHwnd());
 
     if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics))
     hPs = ::WinGetPS(GetHwnd());
 
     if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics))

+    {
+        ::WinReleasePS(hPs);

         return (0);
         return (0);

-    else
-        return(vFontMetrics.lAveCharWidth);
+    }

     ::WinReleasePS(hPs);
     ::WinReleasePS(hPs);

-} // end of wxWindow::GetCharWidth
+    return(vFontMetrics.lAveCharWidth);
+} // end of wxWindowOS2::GetCharWidth

 
 

-void wxWindow::GetTextExtent(
+void wxWindowOS2::GetTextExtent(

   const wxString&                   rString
 , int*                              pX
 , int*                              pY
   const wxString&                   rString
 , int*                              pX
 , int*                              pY


@@ -1367,55 +1723,101 @@ void wxWindow::GetTextExtent(
 , const wxFont*                     pTheFont
 ) const
 {
 , const wxFont*                     pTheFont
 ) const
 {

-    const wxFont*                   pFontToUse = pTheFont;
-    HPS                             hPs;
+    POINTL                          avPoint[TXTBOX_COUNT];
+    POINTL                          vPtMin;
+    POINTL                          vPtMax;
+    int                             i;
+    int                             l;
+    FONTMETRICS                     vFM; // metrics structure
+    BOOL                            bRc;
+    char*                           pStr;
+    ERRORID                         vErrorCode; // last error id code
+    HPS                             hPS;

 
 

-    hPs = ::WinGetPS(GetHwnd());
-/*
-// TODO: Will have to play with fonts later

 
 

-    if (!pFontToUse)
-        pFontToUse = &m_font;
+    hPS = ::WinGetPS(GetHwnd());

 
 

-    HFONT                           hFnt = 0;
-    HFONT                           hFfontOld = 0;
+    l = rString.Length();
+    if (l > 0L)
+    {
+        pStr = (PCH)rString.c_str();

 
 

-    if (pFontToUse && pFontToUse->Ok())
+        //
+        // In world coordinates.
+        //
+        bRc = ::GpiQueryTextBox( hPS
+                                ,l
+                                ,pStr
+                                ,TXTBOX_COUNT // return maximum information
+                                ,avPoint      // array of coordinates points
+                               );
+        if (bRc)
+        {
+            vPtMin.x = avPoint[0].x;
+            vPtMax.x = avPoint[0].x;
+            vPtMin.y = avPoint[0].y;
+            vPtMax.y = avPoint[0].y;
+            for (i = 1; i < 4; i++)
+            {
+                if(vPtMin.x > avPoint[i].x) vPtMin.x = avPoint[i].x;
+                if(vPtMin.y > avPoint[i].y) vPtMin.y = avPoint[i].y;
+                if(vPtMax.x < avPoint[i].x) vPtMax.x = avPoint[i].x;
+                if(vPtMax.y < avPoint[i].y) vPtMax.y = avPoint[i].y;
+            }
+            bRc = ::GpiQueryFontMetrics( hPS
+                                        ,sizeof(FONTMETRICS)
+                                        ,&vFM
+                                       );
+            if (!bRc)
+            {
+                vPtMin.x = 0;
+                vPtMin.y = 0;
+                vPtMax.x = 0;
+                vPtMax.y = 0;
+            }
+        }
+        else
+        {
+            vPtMin.x = 0;
+            vPtMin.y = 0;
+            vPtMax.x = 0;
+            vPtMax.y = 0;
+        }
+    }
+    else

     {
     {

-        ::GpiCreateLog
-        hFnt = (HFONT)((wxFont *)pFontToUse)->GetResourceHandle(); // const_cast
-        if (hFnt)
-            hFontOld = (HFONT)SelectObject(dc,fnt);
+        vPtMin.x = 0;
+        vPtMin.y = 0;
+        vPtMax.x = 0;
+        vPtMax.y = 0;

     }
     }

-
-    SIZE sizeRect;
-    TEXTMETRIC tm;
-    GetTextExtentPoint(dc, string, (int)string.Length(), &sizeRect);
-    GetTextMetrics(dc, &tm);
-
-    if ( fontToUse && fnt && hfontOld )
-        SelectObject(dc, hfontOld);
-
-    ReleaseDC(hWnd, dc);
-
-    if ( x )
-        *x = sizeRect.cx;
-    if ( y )
-        *y = sizeRect.cy;
-    if ( descent )
-        *descent = tm.tmDescent;
-    if ( externalLeading )
-        *externalLeading = tm.tmExternalLeading;
-*/
-    ::WinReleasePS(hPs);
-}
+    if (pX)
+        *pX = (vPtMax.x - vPtMin.x + 1);
+    if (pY)
+        *pY = (vPtMax.y - vPtMin.y + 1);
+    if (pDescent)
+    {
+        if (bRc)
+            *pDescent = vFM.lMaxDescender;
+        else
+            *pDescent = 0;
+    }
+    if (pExternalLeading)
+    {
+        if (bRc)
+            *pExternalLeading = vFM.lExternalLeading;
+        else
+            *pExternalLeading = 0;
+    }
+    ::WinReleasePS(hPS);
+} // end of wxWindow::GetTextExtent

 
 #if wxUSE_CARET && WXWIN_COMPATIBILITY
 // ---------------------------------------------------------------------------
 // Caret manipulation
 // ---------------------------------------------------------------------------
 
 
 #if wxUSE_CARET && WXWIN_COMPATIBILITY
 // ---------------------------------------------------------------------------
 // Caret manipulation
 // ---------------------------------------------------------------------------
 

-void wxWindow::CreateCaret(
+void wxWindowOS2::CreateCaret(

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


@@ -1424,30 +1826,30 @@ void wxWindow::CreateCaret(
                          ,nWidth
                          ,nHeight
                         ));
                          ,nWidth
                          ,nHeight
                         ));

-} // end of wxWindow::CreateCaret
+} // end of wxWindowOS2::CreateCaret

 
 

-void wxWindow::CreateCaret(
+void wxWindowOS2::CreateCaret(

   const wxBitmap*                   pBitmap
 )
 {
     wxFAIL_MSG("not implemented");
   const wxBitmap*                   pBitmap
 )
 {
     wxFAIL_MSG("not implemented");

-} // end of wxWindow::CreateCaret
+} // end of wxWindowOS2::CreateCaret

 
 

-void wxWindow::ShowCaret(
+void wxWindowOS2::ShowCaret(

   bool                              bShow
 )
 {
     wxCHECK_RET( m_caret, "no caret to show" );
 
     m_caret->Show(bShow);
   bool                              bShow
 )
 {
     wxCHECK_RET( m_caret, "no caret to show" );
 
     m_caret->Show(bShow);

-} // end of wxWindow::ShowCaret
+} // end of wxWindowOS2::ShowCaret

 
 

-void wxWindow::DestroyCaret()
+void wxWindowOS2::DestroyCaret()

 {
     SetCaret(NULL);
 {
     SetCaret(NULL);

-} // end of wxWindow::DestroyCaret
+} // end of wxWindowOS2::DestroyCaret

 
 

-void wxWindow::SetCaretPos(
+void wxWindowOS2::SetCaretPos(

   int                               nX
 , int                               nY)
 {
   int                               nX
 , int                               nY)
 {


@@ -1456,9 +1858,9 @@ void wxWindow::SetCaretPos(
     m_caret->Move( nX
                   ,nY
                  );
     m_caret->Move( nX
                   ,nY
                  );

-} // end of wxWindow::SetCaretPos
+} // end of wxWindowOS2::SetCaretPos

 
 

-void wxWindow::GetCaretPos(
+void wxWindowOS2::GetCaretPos(

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


@@ -1468,15 +1870,33 @@ void wxWindow::GetCaretPos(
     m_caret->GetPosition( pX
                          ,pY
                         );
     m_caret->GetPosition( pX
                          ,pY
                         );

-} // end of wxWindow::GetCaretPos
+} // end of wxWindowOS2::GetCaretPos

 
 #endif //wxUSE_CARET
 
 // ---------------------------------------------------------------------------
 // popup menu
 // ---------------------------------------------------------------------------
 
 #endif //wxUSE_CARET
 
 // ---------------------------------------------------------------------------
 // popup menu
 // ---------------------------------------------------------------------------

+//
+#if wxUSE_MENUS_NATIVE
+static void wxYieldForCommandsOnly()
+{
+    //
+    // Peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
+    // want to process it here)
+    //
+    QMSG                            vMsg;

 
 

-bool wxWindow::DoPopupMenu(
+    while (::WinPeekMsg(vHabmain, &vMsg, (HWND)0, WM_COMMAND,
+           WM_COMMAND,PM_REMOVE) && vMsg.msg != WM_QUIT)
+    {
+        wxTheApp->DoMessage((WXMSG*)&vMsg);
+    }
+}
+#endif // wxUSE_MENUS_NATIVE
+
+#if wxUSE_MENUS_NATIVE
+bool wxWindowOS2::DoPopupMenu(

   wxMenu*                           pMenu
 , int                               nX
 , int                               nY
   wxMenu*                           pMenu
 , int                               nX
 , int                               nY


@@ -1502,35 +1922,43 @@ bool wxWindow::DoPopupMenu(
                    ,0L
                    ,PU_MOUSEBUTTON2DOWN | PU_MOUSEBUTTON2 | PU_KEYBOARD
                   );
                    ,0L
                    ,PU_MOUSEBUTTON2DOWN | PU_MOUSEBUTTON2 | PU_KEYBOARD
                   );

-    wxYield();
+    // we need to do it righ now as otherwise the events are never going to be
+    // sent to wxCurrentPopupMenu from ;()
+    //
+    // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
+    // help and we'd still need wxYieldForCommandsOnly() as the menu may be
+    // destroyed as soon as we return (it can be a local variable in the caller
+    // for example) and so we do need to process the event immediately
+    wxYieldForCommandsOnly();

     wxCurrentPopupMenu = NULL;
 
     pMenu->SetInvokingWindow(NULL);
     return TRUE;
     wxCurrentPopupMenu = NULL;
 
     pMenu->SetInvokingWindow(NULL);
     return TRUE;

-} // end of wxWindow::DoPopupMenu
+} // end of wxWindowOS2::DoPopupMenu
+#endif // wxUSE_MENUS_NATIVE

 
 // ===========================================================================
 // pre/post message processing
 // ===========================================================================
 
 
 // ===========================================================================
 // pre/post message processing
 // ===========================================================================
 

-MRESULT wxWindow::OS2DefWindowProc(
+MRESULT wxWindowOS2::OS2DefWindowProc(

   WXUINT                            uMsg
 , WXWPARAM                          wParam
 , WXLPARAM                          lParam
 )
 {
   WXUINT                            uMsg
 , WXWPARAM                          wParam
 , WXLPARAM                          lParam
 )
 {

-DEBUG_PRINTF(wxWindow::OS2DefWindowProc);
-

     if (m_fnOldWndProc)
     if (m_fnOldWndProc)

-        return (MRESULT)m_fnOldWndProc(GetHWND(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam);
+        return (MRESULT)m_fnOldWndProc(GetHWND(), uMsg, (MPARAM)wParam, (MPARAM)lParam);

     else
     else

-        return ::WinDefWindowProc(GetHWND(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam);
-} // end of wxWindow::OS2DefWindowProc
+        return ::WinDefWindowProc(GetHWND(), uMsg, (MPARAM)wParam, (MPARAM)lParam);
+} // end of wxWindowOS2::OS2DefWindowProc

 
 

-bool wxWindow::OS2ProcessMessage(
+bool wxWindowOS2::OS2ProcessMessage(

   WXMSG*                            pMsg
 )
 {
   WXMSG*                            pMsg
 )
 {

+// wxUniversal implements tab traversal itself
+#ifndef __WXUNIVERSAL__

     QMSG*                           pQMsg = (QMSG*)pMsg;
 
     if (m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL))
     QMSG*                           pQMsg = (QMSG*)pMsg;
 
     if (m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL))


@@ -1640,17 +2068,9 @@ bool wxWindow::OS2ProcessMessage(
                         }
                         else
                         {
                         }
                         else
                         {

-                            wxPanel*    pPanel = wxDynamicCast(this, wxPanel);
-                            wxButton*   pBtn = NULL;
-
-                            if (pPanel)
-                            {
-                                //
-                                // Panel may have a default button which should
-                                // be activated by Enter
-                                //
-                                pBtn = pPanel->GetDefaultItem();
-                            }
+                            wxButton*   pBtn = wxDynamicCast( GetDefaultItem()
+                                                             ,wxButton
+                                                            );

 
                             if (pBtn && pBtn->IsEnabled())
                             {
 
                             if (pBtn && pBtn->IsEnabled())
                             {


@@ -1700,6 +2120,9 @@ bool wxWindow::OS2ProcessMessage(
         if (::WinSendMsg(pQMsg->hwnd, WM_QUERYDLGCODE, pQMsg, 0));
             return TRUE;
     }
         if (::WinSendMsg(pQMsg->hwnd, WM_QUERYDLGCODE, pQMsg, 0));
             return TRUE;
     }

+#else
+    pMsg = pMsg; // just shut up the compiler
+#endif // __WXUNIVERSAL__

 
 #if wxUSE_TOOLTIPS
     if ( m_tooltip )
 
 #if wxUSE_TOOLTIPS
     if ( m_tooltip )


@@ -1713,24 +2136,25 @@ bool wxWindow::OS2ProcessMessage(
 #endif // wxUSE_TOOLTIPS
 
     return FALSE;
 #endif // wxUSE_TOOLTIPS
 
     return FALSE;

-} // end of wxWindow::OS2ProcessMessage
+} // end of wxWindowOS2::OS2ProcessMessage

 
 

-bool wxWindow::OS2TranslateMessage(
+bool wxWindowOS2::OS2TranslateMessage(

   WXMSG*                            pMsg
 )
 {
   WXMSG*                            pMsg
 )
 {

-#if wxUSE_ACCEL
+#if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)

   return m_acceleratorTable.Translate(m_hWnd, pMsg);
 #else
   return m_acceleratorTable.Translate(m_hWnd, pMsg);
 #else

+  pMsg = pMsg;

   return FALSE;
 #endif //wxUSE_ACCEL
   return FALSE;
 #endif //wxUSE_ACCEL

-} // end of wxWindow::OS2TranslateMessage
+} // end of wxWindowOS2::OS2TranslateMessage

 
 // ---------------------------------------------------------------------------
 // message params unpackers
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // message params unpackers
 // ---------------------------------------------------------------------------
 

-void wxWindow::UnpackCommand(
+void wxWindowOS2::UnpackCommand(

   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WORD*                             pId
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WORD*                             pId


@@ -1741,9 +2165,9 @@ void wxWindow::UnpackCommand(
     *pId = LOWORD(wParam);
     *phWnd = NULL;  // or may be GetHWND() ?
     *pCmd = LOWORD(lParam);
     *pId = LOWORD(wParam);
     *phWnd = NULL;  // or may be GetHWND() ?
     *pCmd = LOWORD(lParam);

-} // end of wxWindow::UnpackCommand
+} // end of wxWindowOS2::UnpackCommand

 
 

-void wxWindow::UnpackActivate(
+void wxWindowOS2::UnpackActivate(

   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pState
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pState


@@ -1752,9 +2176,9 @@ void wxWindow::UnpackActivate(
 {
     *pState     = LOWORD(wParam);
     *phWnd      = (WXHWND)lParam;
 {
     *pState     = LOWORD(wParam);
     *phWnd      = (WXHWND)lParam;

-} // end of wxWindow::UnpackActivate
+} // end of wxWindowOS2::UnpackActivate

 
 

-void wxWindow::UnpackScroll(
+void wxWindowOS2::UnpackScroll(

   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pCode
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pCode


@@ -1762,12 +2186,21 @@ void wxWindow::UnpackScroll(
 , WXHWND*                           phWnd
 )
 {
 , WXHWND*                           phWnd
 )
 {

-    *pCode = LOWORD(wParam);
-    *pPos  = HIWORD(wParam);
-    *phWnd = (WXHWND)lParam;
-} // end of wxWindow::UnpackScroll
+    ULONG                           ulId;
+    HWND                            hWnd;

 
 

-void wxWindow::UnpackMenuSelect(
+    ulId    = (ULONG)LONGFROMMP(wParam);
+    hWnd = ::WinWindowFromID(GetHwnd(), ulId);
+    if (hWnd == m_hWndScrollBarHorz || hWnd == m_hWndScrollBarVert)
+        *phWnd = NULLHANDLE;
+    else
+        *phWnd = hWnd;
+
+    *pPos  = SHORT1FROMMP(lParam);
+    *pCode = SHORT2FROMMP(lParam);
+} // end of wxWindowOS2::UnpackScroll
+
+void wxWindowOS2::UnpackMenuSelect(

   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pItem
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pItem


@@ -1778,7 +2211,7 @@ void wxWindow::UnpackMenuSelect(
     *pItem = (WXWORD)LOWORD(wParam);
     *pFlags = HIWORD(wParam);
     *phMenu = (WXHMENU)lParam;
     *pItem = (WXWORD)LOWORD(wParam);
     *pFlags = HIWORD(wParam);
     *phMenu = (WXHMENU)lParam;

-} // end of wxWindow::UnpackMenuSelect
+} // end of wxWindowOS2::UnpackMenuSelect

 
 // ---------------------------------------------------------------------------
 // Main wxWindows window proc and the window proc for wxWindow
 
 // ---------------------------------------------------------------------------
 // Main wxWindows window proc and the window proc for wxWindow


@@ -1788,7 +2221,7 @@ void wxWindow::UnpackMenuSelect(
 // Hook for new window just as it's being created, when the window isn't yet
 // associated with the handle
 //
 // Hook for new window just as it's being created, when the window isn't yet
 // associated with the handle
 //

-wxWindow*                           wxWndHook = NULL;
+wxWindowOS2*                         wxWndHook = NULL;

 
 //
 // Main window proc
 
 //
 // Main window proc


@@ -1804,12 +2237,11 @@ MRESULT EXPENTRY wxWndProc(
     // Trace all ulMsgs - useful for the debugging
     //
 #ifdef __WXDEBUG__
     // Trace all ulMsgs - useful for the debugging
     //
 #ifdef __WXDEBUG__

-DEBUG_PRINTF(__WXDEBUG__wxWndProc);

     wxLogTrace(wxTraceMessages, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
                wxGetMessageName(ulMsg), wParam, lParam);
 #endif // __WXDEBUG__
 
     wxLogTrace(wxTraceMessages, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
                wxGetMessageName(ulMsg), wParam, lParam);
 #endif // __WXDEBUG__
 

-    wxWindow*                       pWnd = wxFindWinFromHandle((WXHWND)hWnd);
+    wxWindowOS2*                    pWnd = wxFindWinFromHandle((WXHWND)hWnd);

 
     //
     // When we get the first message for the HWND we just created, we associate
 
     //
     // When we get the first message for the HWND we just created, we associate


@@ -1850,7 +2282,7 @@ DEBUG_PRINTF(__WXDEBUG__wxWndProc);
 // We will add (or delete) messages we need to handle at this default
 // level as we go
 //
 // We will add (or delete) messages we need to handle at this default
 // level as we go
 //

-MRESULT wxWindow::OS2WindowProc(
+MRESULT wxWindowOS2::OS2WindowProc(

   WXUINT                            uMsg
 , WXWPARAM                          wParam
 , WXLPARAM                          lParam
   WXUINT                            uMsg
 , WXWPARAM                          wParam
 , WXLPARAM                          lParam


@@ -1860,10 +2292,7 @@ MRESULT wxWindow::OS2WindowProc(
     // Did we process the uMsg?
     //
     bool                            bProcessed = FALSE;
     // Did we process the uMsg?
     //
     bool                            bProcessed = FALSE;

-    bool                            bAllow;

     MRESULT                         mResult;
     MRESULT                         mResult;

-    WXHICON                         hIcon;
-    WXHBRUSH                        hBrush;

 
     //
     // For most messages we should return 0 when we do process the message
 
     //
     // For most messages we should return 0 when we do process the message


@@ -1933,7 +2362,6 @@ MRESULT wxWindow::OS2WindowProc(
             break;
 
         case WM_PAINT:
             break;
 
         case WM_PAINT:

-DEBUG_PRINTF(WM_PAINT)

             bProcessed = HandlePaint();
             break;
 
             bProcessed = HandlePaint();
             break;
 


@@ -1944,11 +2372,9 @@ DEBUG_PRINTF(WM_PAINT)
             //
             bProcessed = TRUE;
             mResult = (MRESULT)TRUE;
             //
             bProcessed = TRUE;
             mResult = (MRESULT)TRUE;

-DEBUG_PRINTF(WM_CLOSE)

             break;
 
         case WM_SHOW:
             break;
 
         case WM_SHOW:

-DEBUG_PRINTF(WM_SHOW)

             bProcessed = HandleShow(wParam != 0, (int)lParam);
             break;
 
             bProcessed = HandleShow(wParam != 0, (int)lParam);
             break;
 


@@ -1987,11 +2413,9 @@ DEBUG_PRINTF(WM_SHOW)
             {
                 WORD id, cmd;
                 WXHWND hwnd;
             {
                 WORD id, cmd;
                 WXHWND hwnd;

-DEBUG_PRINTF(WM_COMMAND-in)

                 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
 
                 bProcessed = HandleCommand(id, cmd, hwnd);
                 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
 
                 bProcessed = HandleCommand(id, cmd, hwnd);

-DEBUG_PRINTF(WM_COMMAND-out)

             }
             break;
 
             }
             break;
 


@@ -2001,15 +2425,16 @@ DEBUG_PRINTF(WM_COMMAND-out)
         case WM_DRAWITEM:
         case WM_MEASUREITEM:
             {
         case WM_DRAWITEM:
         case WM_MEASUREITEM:
             {

-                int idCtrl = (UINT)wParam;
+                int                 nIdCtrl = (UINT)wParam;
+

                 if ( uMsg == WM_DRAWITEM )
                 {
                 if ( uMsg == WM_DRAWITEM )
                 {

-                    bProcessed = OS2OnDrawItem(idCtrl,
+                    bProcessed = OS2OnDrawItem(nIdCtrl,

                                               (WXDRAWITEMSTRUCT *)lParam);
                 }
                 else
                 {
                                               (WXDRAWITEMSTRUCT *)lParam);
                 }
                 else
                 {

-                    bProcessed = OS2OnMeasureItem(idCtrl,
+                    bProcessed = OS2OnMeasureItem(nIdCtrl,

                                                  (WXMEASUREITEMSTRUCT *)lParam);
                 }
 
                                                  (WXMEASUREITEMSTRUCT *)lParam);
                 }
 


@@ -2039,6 +2464,7 @@ DEBUG_PRINTF(WM_COMMAND-out)
 
                 if (uKeyFlags & KC_KEYUP)
                 {
 
                 if (uKeyFlags & KC_KEYUP)
                 {

+                    //TODO: check if the cast to WXWORD isn't causing trouble

                     bProcessed = HandleKeyUp((WXDWORD)wParam, lParam);
                     break;
                 }
                     bProcessed = HandleKeyUp((WXDWORD)wParam, lParam);
                     break;
                 }


@@ -2124,18 +2550,13 @@ DEBUG_PRINTF(WM_COMMAND-out)
             }
             break;
 #endif
             }
             break;
 #endif

-        //
-        // Instead of CTLCOLOR messages PM sends QUERYWINDOWPARAMS to
-        // things such as colors and fonts and such
-        //
-        case WM_QUERYWINDOWPARAMS:
-            {
-                PWNDPARAMS          pWndParams = (PWNDPARAMS)wParam;
-
-                bProcessed = HandleWindowParams( pWndParams
-                                                ,lParam
-                                               );
-            }
+        case WM_ERASEBACKGROUND:
+            //
+            // Returning TRUE to requestw PM to paint the window background
+            // in SYSCLR_WINDOW. We don't really want that
+            //
+            bProcessed = HandleEraseBkgnd((WXHDC)(HPS)wParam);
+            mResult = (MRESULT)(FALSE);

             break;
 
             // the return value for this message is ignored
             break;
 
             // the return value for this message is ignored


@@ -2147,22 +2568,6 @@ DEBUG_PRINTF(WM_COMMAND-out)
             bProcessed = HandlePaletteChanged();
             break;
 
             bProcessed = HandlePaletteChanged();
             break;
 

-        case WM_PRESPARAMCHANGED:
-            bProcessed = HandlePresParamChanged(wParam);
-            break;
-
-        // move this to wxFrame
-        case WM_ERASEBACKGROUND:
-            bProcessed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
-            if (bProcessed)
-            {
-                //
-                // We processed the message, i.e. erased the background
-                //
-                mResult = (MRESULT)TRUE;
-            }
-            break;
-

         // move all drag and drops to wxDrg
         case WM_ENDDRAG:
             bProcessed = HandleEndDrag(wParam);
         // move all drag and drops to wxDrg
         case WM_ENDDRAG:
             bProcessed = HandleEndDrag(wParam);


@@ -2218,16 +2623,16 @@ DEBUG_PRINTF(WM_COMMAND-out)
             mResult = OS2DefWindowProc(uMsg, wParam, lParam);
     }
     return mResult;
             mResult = OS2DefWindowProc(uMsg, wParam, lParam);
     }
     return mResult;

-} // end of wxWindow::OS2WindowProc
+} // end of wxWindowOS2::OS2WindowProc

 
 //
 // Dialog window proc
 //
 MRESULT wxDlgProc(
 
 //
 // Dialog window proc
 //
 MRESULT wxDlgProc(

-  HWND                              hWnd
+  HWND                              WXUNUSED(hWnd)

 , UINT                              uMsg
 , UINT                              uMsg

-, MPARAM                            wParam
-, MPARAM                            lParam)
+, MPARAM                            WXUNUSED(wParam)
+, MPARAM                            WXUNUSED(lParam))

 {
     if (uMsg == WM_INITDLG)
     {
 {
     if (uMsg == WM_INITDLG)
     {


@@ -2260,7 +2665,7 @@ wxWindow* wxFindWinFromHandle(
 
 void wxAssociateWinWithHandle(
   HWND                              hWnd
 
 void wxAssociateWinWithHandle(
   HWND                              hWnd

-, wxWindow*                         pWin
+, wxWindowOS2*                      pWin

 )
 {
     //
 )
 {
     //


@@ -2290,7 +2695,7 @@ void wxAssociateWinWithHandle(
 } // end of wxAssociateWinWithHandle
 
 void wxRemoveHandleAssociation(
 } // end of wxAssociateWinWithHandle
 
 void wxRemoveHandleAssociation(

-  wxWindow*                         pWin
+  wxWindowOS2*                      pWin

 )
 {
     wxWinHandleList->DeleteObject(pWin);
 )
 {
     wxWinHandleList->DeleteObject(pWin);


@@ -2300,12 +2705,13 @@ void wxRemoveHandleAssociation(
 // Default destroyer - override if you destroy it in some other way
 // (e.g. with MDI child windows)
 //
 // Default destroyer - override if you destroy it in some other way
 // (e.g. with MDI child windows)
 //

-void wxWindow::OS2DestroyWindow()
+void wxWindowOS2::OS2DestroyWindow()

 {
 }
 
 {
 }
 

-void wxWindow::OS2DetachWindowMenu()
+void wxWindowOS2::OS2DetachWindowMenu()

 {
 {

+#ifndef __WXUNIVERSAL__

     if (m_hMenu)
     {
         HMENU                       hMenu = (HMENU)m_hMenu;
     if (m_hMenu)
     {
         HMENU                       hMenu = (HMENU)m_hMenu;


@@ -2334,9 +2740,10 @@ void wxWindow::OS2DetachWindowMenu()
             }
         }
     }
             }
         }
     }

-} // end of wxWindow::OS2DetachWindowMenu
+#endif // __WXUNIVERSAL__
+} // end of wxWindowOS2::OS2DetachWindowMenu

 
 

-bool wxWindow::OS2Create(
+bool wxWindowOS2::OS2Create(

   WXHWND                            hParent
 , PSZ                               zClass
 , const wxChar*                     zTitle
   WXHWND                            hParent
 , PSZ                               zClass
 , const wxChar*                     zTitle


@@ -2346,10 +2753,11 @@ bool wxWindow::OS2Create(
 , long                              lWidth
 , long                              lHeight
 , WXHWND                            hOwner
 , long                              lWidth
 , long                              lHeight
 , WXHWND                            hOwner

-, WXHWND                            hZOrder
+, WXHWND                            WXUNUSED(hZOrder)

 , unsigned long                     ulId
 , void*                             pCtlData
 , void*                             pPresParams
 , unsigned long                     ulId
 , void*                             pCtlData
 , void*                             pPresParams

+, WXDWORD                           dwExStyle

 )
 {
     ERRORID                         vError;
 )
 {
     ERRORID                         vError;


@@ -2366,13 +2774,8 @@ bool wxWindow::OS2Create(
     // Find parent's size, if it exists, to set up a possible default
     // panel size the size of the parent window
     //
     // Find parent's size, if it exists, to set up a possible default
     // panel size the size of the parent window
     //

-    RECTL                           vParentRect;
-    HWND                            hWndClient;
-
-    if (lX > -1L)
-        lX1 = lX;
-    if (lY > -1L)
-        lY1 = lY;
+    lX1 = lX;
+    lY1 = lY;

     if (lWidth > -1L)
         lWidth1 = lWidth;
     if (lHeight > -1L)
     if (lWidth > -1L)
         lWidth1 = lWidth;
     if (lHeight > -1L)


@@ -2416,23 +2819,32 @@ bool wxWindow::OS2Create(
         }
     }
 
         }
     }
 

+   HWND parent;
+   if ( GetWindowStyleFlag() & wxPOPUP_WINDOW )
+   {
+       // popup windows should have desktop as parent because they shouldn't
+       // be limited to the parents client area as child windows usually are
+       parent = HWND_DESKTOP;
+   }
+   else if ( hParent )
+   {
+       parent = hParent;
+   }
+   else
+   {
+       // top level window
+       parent = NULL;
+   }
+

     //
     // We will either have a registered class via string name or a standard PM Class via a long
     //
     //
     // We will either have a registered class via string name or a standard PM Class via a long
     //

-    m_hWnd = (WXHWND)::WinCreateWindow( (HWND)hParent
-                                       ,zClass
-                                       ,(PSZ)zTitle ? zTitle : wxT("")
-                                       ,(ULONG)dwStyle
-                                       ,(LONG)lX1
-                                       ,(LONG)lY1
-                                       ,(LONG)lWidth
-                                       ,(LONG)lHeight
-                                       ,hOwner
-                                       ,HWND_TOP
-                                       ,(ULONG)nControlId
-                                       ,pCtlData
-                                       ,pPresParams
-                                      );
+    m_hWnd = (WXHWND)::WinCreateWindow(parent, zClass,
+                                       (PSZ)zTitle ? zTitle : wxT(""),
+                                       dwStyle, lX1, lY1, lWidth, lHeight,
+                                       hOwner, HWND_TOP, (ULONG)nControlId,
+                                       pCtlData, pPresParams);
+

     if (!m_hWnd)
     {
         vError = ::WinGetLastError(vHabmain);
     if (!m_hWnd)
     {
         vError = ::WinGetLastError(vHabmain);


@@ -2440,6 +2852,7 @@ bool wxWindow::OS2Create(
         wxLogError("Can't create window of class %s!. Error: %s\n", zClass, sError);
         return FALSE;
     }
         wxLogError("Can't create window of class %s!. Error: %s\n", zClass, sError);
         return FALSE;
     }

+    m_dwExStyle = dwExStyle;

     ::WinSetWindowULong(m_hWnd, QWL_USER, (ULONG) this);
     wxWndHook = NULL;
 
     ::WinSetWindowULong(m_hWnd, QWL_USER, (ULONG) this);
     wxWndHook = NULL;
 


@@ -2472,7 +2885,7 @@ bool wxWindow::OS2Create(
         SubclassWin(GetHWND());
     }
     return TRUE;
         SubclassWin(GetHWND());
     }
     return TRUE;

-} // end of wxWindow::OS2Create
+} // end of wxWindowOS2::OS2Create

 
 // ===========================================================================
 // OS2 PM message handlers
 
 // ===========================================================================
 // OS2 PM message handlers


@@ -2482,21 +2895,21 @@ bool wxWindow::OS2Create(
 // window creation/destruction
 // ---------------------------------------------------------------------------
 
 // window creation/destruction
 // ---------------------------------------------------------------------------
 

-bool wxWindow::HandleCreate(
-  WXLPCREATESTRUCT                  vCs
+bool wxWindowOS2::HandleCreate(
+  WXLPCREATESTRUCT                  WXUNUSED(vCs)

 , bool*                             pbMayCreate
 )
 {
 , bool*                             pbMayCreate
 )
 {

-    wxWindowCreateEvent             vEvent(this);
+    wxWindowCreateEvent             vEvent((wxWindow*)this);

 
     (void)GetEventHandler()->ProcessEvent(vEvent);
     *pbMayCreate = TRUE;
     return TRUE;
 
     (void)GetEventHandler()->ProcessEvent(vEvent);
     *pbMayCreate = TRUE;
     return TRUE;

-} // end of wxWindow::HandleCreate
+} // end of wxWindowOS2::HandleCreate

 
 

-bool wxWindow::HandleDestroy()
+bool wxWindowOS2::HandleDestroy()

 {
 {

-    wxWindowDestroyEvent            vEvent(this);
+    wxWindowDestroyEvent            vEvent((wxWindow*)this);

 
     (void)GetEventHandler()->ProcessEvent(vEvent);
 
 
     (void)GetEventHandler()->ProcessEvent(vEvent);
 


@@ -2516,45 +2929,19 @@ bool wxWindow::HandleDestroy()
     // WM_DESTROY handled
     //
     return TRUE;
     // WM_DESTROY handled
     //
     return TRUE;

-} // end of wxWindow::HandleDestroy
+} // end of wxWindowOS2::HandleDestroy

 
 // ---------------------------------------------------------------------------
 // activation/focus
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // activation/focus
 // ---------------------------------------------------------------------------

-void wxWindow::OnSetFocus(
+void wxWindowOS2::OnSetFocus(

   wxFocusEvent&                     rEvent
 )
 {
   wxFocusEvent&                     rEvent
 )
 {

-    //
-    // Panel wants to track the window which was the last to have focus in it,
-    // so we want to set ourselves as the window which last had focus
-    //
-    // Notice that it's also important to do it upwards the tree becaus
-    // otherwise when the top level panel gets focus, it won't set it back to
-    // us, but to some other sibling
-    //
-    wxWindow*                       pWin = this;
-
-    while (pWin)
-    {
-        wxWindow*                   pParent = pWin->GetParent();
-        wxPanel*                    pPanel = wxDynamicCast( pParent
-                                                           ,wxPanel
-                                                          );
-        if (pPanel)
-        {
-            pPanel->SetLastFocus(pWin);
-        }
-        pWin = pParent;
-    }
-
-    wxLogTrace(_T("focus"), _T("%s (0x%08x) gets focus"),
-               GetClassInfo()->GetClassName(), GetHandle());
-

     rEvent.Skip();
     rEvent.Skip();

-} // end of wxWindow::OnSetFocus
+} // end of wxWindowOS2::OnSetFocus

 
 

-bool wxWindow::HandleActivate(
+bool wxWindowOS2::HandleActivate(

   int                               nState
 , WXHWND                            WXUNUSED(hActivate)
 )
   int                               nState
 , WXHWND                            WXUNUSED(hActivate)
 )


@@ -2565,9 +2952,9 @@ bool wxWindow::HandleActivate(
                                           );
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
                                           );
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleActivate
+} // end of wxWindowOS2::HandleActivate

 
 

-bool wxWindow::HandleSetFocus(
+bool wxWindowOS2::HandleSetFocus(

   WXHWND                            WXUNUSED(hWnd)
 )
 {
   WXHWND                            WXUNUSED(hWnd)
 )
 {


@@ -2581,24 +2968,22 @@ bool wxWindow::HandleSetFocus(
     }
 #endif // wxUSE_CARET
 
     }
 #endif // wxUSE_CARET
 

-    //
-    // Panel wants to track the window which was the last to have focus in it
-    //
-    wxPanel*                        pPanel = wxDynamicCast( GetParent()
-                                                           ,wxPanel
-                                                          );
-    if (pPanel)
+#if wxUSE_TEXTCTRL
+    // If it's a wxTextCtrl don't send the event as it will be done
+    // after the control gets to process it from EN_FOCUS handler
+    if ( wxDynamicCastThis(wxTextCtrl) )

     {
     {

-        pPanel->SetLastFocus(this);
+        return FALSE;

     }
     }

+#endif // wxUSE_TEXTCTRL

 
     wxFocusEvent                    vEvent(wxEVT_SET_FOCUS, m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 
     wxFocusEvent                    vEvent(wxEVT_SET_FOCUS, m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleSetFocus
+} // end of wxWindowOS2::HandleSetFocus

 
 

-bool wxWindow::HandleKillFocus(
+bool wxWindowOS2::HandleKillFocus(

   WXHWND                            WXUNUSED(hWnd)
 )
 {
   WXHWND                            WXUNUSED(hWnd)
 )
 {


@@ -2618,26 +3003,24 @@ bool wxWindow::HandleKillFocus(
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleKillFocus
+} // end of wxWindowOS2::HandleKillFocus

 
 // ---------------------------------------------------------------------------
 // miscellaneous
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // miscellaneous
 // ---------------------------------------------------------------------------
 

-bool wxWindow::HandleShow(
+bool wxWindowOS2::HandleShow(

   bool                              bShow
   bool                              bShow

-, int                               nStatus
+, int                               WXUNUSED(nStatus)

 )
 {
 )
 {

-    wxShowEvent                     vEvent( GetId()
-                                           ,bShow
-                                          );
+    wxShowEvent                     vEvent(GetId(), bShow);

 
     vEvent.m_eventObject = this;
     return GetEventHandler()->ProcessEvent(vEvent);
 
     vEvent.m_eventObject = this;
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleShow
+} // end of wxWindowOS2::HandleShow

 
 

-bool wxWindow::HandleInitDialog(
+bool wxWindowOS2::HandleInitDialog(

   WXHWND                            WXUNUSED(hWndFocus)
 )
 {
   WXHWND                            WXUNUSED(hWndFocus)
 )
 {


@@ -2645,16 +3028,16 @@ bool wxWindow::HandleInitDialog(
 
     vEvent.m_eventObject = this;
     return GetEventHandler()->ProcessEvent(vEvent);
 
     vEvent.m_eventObject = this;
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleInitDialog
+} // end of wxWindowOS2::HandleInitDialog

 
 

-bool wxWindow::HandleEndDrag(WXWPARAM wParam)
+bool wxWindowOS2::HandleEndDrag(WXWPARAM WXUNUSED(wParam))

 {
    // TODO: We'll handle drag and drop later
     return FALSE;
 }
 
 {
    // TODO: We'll handle drag and drop later
     return FALSE;
 }
 

-bool wxWindow::HandleSetCursor(
-  USHORT                            vId
+bool wxWindowOS2::HandleSetCursor(
+  USHORT                            WXUNUSED(vId)

 , WXHWND                            hPointer
 )
 {
 , WXHWND                            hPointer
 )
 {


@@ -2664,88 +3047,214 @@ bool wxWindow::HandleSetCursor(
     //
     ::WinSetPointer(HWND_DESKTOP, (HPOINTER)hPointer);
     return TRUE;
     //
     ::WinSetPointer(HWND_DESKTOP, (HPOINTER)hPointer);
     return TRUE;

-} // end of wxWindow::HandleSetCursor
+} // end of wxWindowOS2::HandleSetCursor

 
 // ---------------------------------------------------------------------------
 // owner drawn stuff
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // owner drawn stuff
 // ---------------------------------------------------------------------------

-bool wxWindow::OS2OnDrawItem(
+bool wxWindowOS2::OS2OnDrawItem(

   int                               vId
 , WXDRAWITEMSTRUCT*                 pItemStruct
 )
 {
   int                               vId
 , WXDRAWITEMSTRUCT*                 pItemStruct
 )
 {

-    //
-    // I'll get to owner drawn stuff later
-    //
+#if wxUSE_OWNER_DRAWN
+    wxDC                            vDc;

 
 

+#if wxUSE_MENUS_NATIVE

     //
     //

-    // is it a menu item or control?
+    // Is it a menu item?

     //
     //

-    wxWindow*                       pItem = FindItem(vId);
-
-#if wxUSE_OWNER_DRAWN
-    if (pItem && pItem->IsKindOf(CLASSINFO(wxControl)))
+    if (vId == 0)

     {
     {

-        return ((wxControl *)pItem)->OS2OnDraw(pItemStruct);
-    }
-    else if (pItem && pItem->IsKindOf(CLASSINFO(wxMenu)))
-    {
-        /*
-        // TODO: draw a menu item
+        ERRORID                     vError;
+        wxString                    sError;
+        POWNERITEM                  pMeasureStruct = (POWNERITEM)pItemStruct;
+        wxFrame*                    pFrame = (wxFrame*)this;
+        wxMenuItem*                 pMenuItem = pFrame->GetMenuBar()->FindItem(pMeasureStruct->idItem, pMeasureStruct->hItem);
+        HDC                         hDC = ::GpiQueryDevice(pMeasureStruct->hps);
+        wxRect                      vRect( pMeasureStruct->rclItem.xLeft
+                                          ,pMeasureStruct->rclItem.yBottom
+                                          ,pMeasureStruct->rclItem.xRight - pMeasureStruct->rclItem.xLeft
+                                          ,pMeasureStruct->rclItem.yTop - pMeasureStruct->rclItem.yBottom
+                                         );
+        vDc.SetHDC( hDC
+                   ,FALSE
+                  );
+        vDc.SetHPS(pMeasureStruct->hps);

         //
         //

-        POWNERITEM                  pDrawStruct = (OWNERITEM *)pItemStruct;
-        wxMenuItem*                 pMenuItem = (wxMenuItem *)(pDrawStruct->pItemData);
+        // Load the wxWindows Pallete and set to RGB mode
+        //
+        if (!::GpiCreateLogColorTable( pMeasureStruct->hps
+                                      ,0L
+                                      ,LCOLF_CONSECRGB
+                                      ,0L
+                                      ,(LONG)wxTheColourDatabase->m_nSize
+                                      ,(PLONG)wxTheColourDatabase->m_palTable
+                                     ))
+        {
+            vError = ::WinGetLastError(vHabmain);
+            sError = wxPMErrorToStr(vError);
+            wxLogError("Unable to set current color table. Error: %s\n", sError);
+        }
+        //
+        // Set the color table to RGB mode
+        //
+        if (!::GpiCreateLogColorTable( pMeasureStruct->hps
+                                      ,0L
+                                      ,LCOLF_RGB
+                                      ,0L
+                                      ,0L
+                                      ,NULL
+                                     ))
+        {
+            vError = ::WinGetLastError(vHabmain);
+            sError = wxPMErrorToStr(vError);
+            wxLogError("Unable to set current color table. Error: %s\n", sError);
+        }

 
 

-        wxCHECK(pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE);
+        wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );

 
 

+
+        int                         eAction = 0;
+        int                         eStatus = 0;
+
+        if (pMeasureStruct->fsAttribute == pMeasureStruct->fsAttributeOld)
+        {
+            //
+            // Entire Item needs to be redrawn (either it has reappeared from
+            // behind another window or is being displayed for the first time
+            //
+            eAction = wxOwnerDrawn::wxODDrawAll;
+
+            if (pMeasureStruct->fsAttribute & MIA_HILITED)
+            {
+                //
+                // If it is currently selected we let the system handle it
+                //
+                eStatus |= wxOwnerDrawn::wxODSelected;
+            }
+            if (pMeasureStruct->fsAttribute & MIA_CHECKED)
+            {
+                //
+                // If it is currently checked we draw our own
+                //
+                eStatus |= wxOwnerDrawn::wxODChecked;
+                pMeasureStruct->fsAttributeOld = pMeasureStruct->fsAttribute &= ~MIA_CHECKED;
+            }
+            if (pMeasureStruct->fsAttribute & MIA_DISABLED)
+            {
+                //
+                // If it is currently disabled we let the system handle it
+                //
+                eStatus |= wxOwnerDrawn::wxODDisabled;
+            }
+            //
+            // Don't really care about framed (indicationg focus) or NoDismiss
+            //
+        }
+        else
+        {
+            if (pMeasureStruct->fsAttribute & MIA_HILITED)
+            {
+                eAction = wxOwnerDrawn::wxODDrawAll;
+                eStatus |= wxOwnerDrawn::wxODSelected;
+                //
+                // Keep the system from trying to highlight with its bogus colors
+                //
+                pMeasureStruct->fsAttributeOld = pMeasureStruct->fsAttribute &= ~MIA_HILITED;
+            }
+            else if (!(pMeasureStruct->fsAttribute & MIA_HILITED))
+            {
+                eAction = wxOwnerDrawn::wxODDrawAll;
+                eStatus = 0;
+                //
+                // Keep the system from trying to highlight with its bogus colors
+                //
+                pMeasureStruct->fsAttribute = pMeasureStruct->fsAttributeOld &= ~MIA_HILITED;
+            }
+            else
+            {
+                //
+                // For now we don't care about anything else
+                // just ignore the entire message!
+                //
+                return TRUE;
+            }
+        }

         //
         //

-        // Prepare to call OnDrawItem()
+        // Now redraw the item
+        //
+        return(pMenuItem->OnDrawItem( vDc
+                                     ,vRect
+                                     ,(wxOwnerDrawn::wxODAction)eAction
+                                     ,(wxOwnerDrawn::wxODStatus)eStatus
+                                    ));
+        //
+        // leave the fsAttribute and fsOldAttribute unchanged.  If different,
+        // the system will do the highlight or fraeming or disabling for us,
+        // otherwise, we'd have to do it ourselves.

         //
         //

-        HPSdc;
-        dc.SetHDC((WXHDC)pDrawStruct->hDC, FALSE);
-        wxRect rect(pDrawStruct->rcItem.left, pDrawStruct->rcItem.top,
-                    pDrawStruct->rcItem.right - pDrawStruct->rcItem.left,
-                    pDrawStruct->rcItem.bottom - pDrawStruct->rcItem.top);
-
-        return pMenuItem->OnDrawItem
-                          (
-                            dc, rect,
-                            (wxOwnerDrawn::wxODAction)pDrawStruct->itemAction,
-                            (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
-                          );
-        */

     }
     }

+#endif // wxUSE_MENUS_NATIVE

 
 

-    else
-        return FALSE;
+    wxWindow*                       pItem = FindItem(vId);
+
+    if (pItem && pItem->IsKindOf(CLASSINFO(wxControl)))
+    {
+        return ((wxControl *)pItem)->OS2OnDraw(pItemStruct);
+    }
+#else
+    vId = vId;
+    pItemStruct = pItemStruct;

 #endif
 #endif

-    return TRUE;
-} // end of wxWindow::OS2OnDrawItem
+    return FALSE;
+} // end of wxWindowOS2::OS2OnDrawItem

 
 

-bool wxWindow::OS2OnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
+bool wxWindowOS2::OS2OnMeasureItem(
+  int                               lId
+, WXMEASUREITEMSTRUCT*              pItemStruct
+)

 {
 {

-   // TODO: more owner drawn menu related stuff, get to it later
-/*

 #if wxUSE_OWNER_DRAWN
 #if wxUSE_OWNER_DRAWN

-    // is it a menu item?
-    if ( id == 0 )
+    //
+    // Is it a menu item?
+    //
+    if (lId == 65536) // I really don't like this...has to be a better indicator

     {
     {

-        MEASUREITEMSTRUCT *pMeasureStruct = (MEASUREITEMSTRUCT *)itemStruct;
-        wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
-
-        wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
-
-        return pMenuItem->OnMeasureItem(&pMeasureStruct->itemWidth,
-                                        &pMeasureStruct->itemHeight);
+        if (IsKindOf(CLASSINFO(wxFrame))) // we'll assume if Frame then a menu
+        {
+            size_t                  nWidth;
+            size_t                  nHeight;
+            POWNERITEM              pMeasureStruct = (POWNERITEM)pItemStruct;
+            wxFrame*                pFrame = (wxFrame*)this;
+            wxMenuItem*             pMenuItem = pFrame->GetMenuBar()->FindItem(pMeasureStruct->idItem, pMeasureStruct->hItem);
+
+            wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
+            nWidth  = 0L;
+            nHeight = 0L;
+            if (pMenuItem->OnMeasureItem( &nWidth
+                                         ,&nHeight
+                                        ))
+            {
+                pMeasureStruct->rclItem.xRight  = nWidth;
+                pMeasureStruct->rclItem.xLeft   = 0L;
+                pMeasureStruct->rclItem.yTop    = nHeight;
+                pMeasureStruct->rclItem.yBottom = 0L;
+                return TRUE;
+            }
+            return FALSE;
+        }

     }
     }

+    wxWindow*                      pItem = FindItem(lId);

 
 

-    wxWindow *item = FindItem(id);
-    if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
+    if (pItem && pItem->IsKindOf(CLASSINFO(wxControl)))

     {
     {

-        return ((wxControl *)item)->MSWOnMeasure(itemStruct);
+        return ((wxControl *)pItem)->OS2OnMeasure(pItemStruct);

     }
     }

-#endif  // owner-drawn menus
-*/
+#else
+    lId = lId;
+    pItemStruct = pItemStruct;
+#endif // wxUSE_OWNER_DRAWN

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -2753,45 +3262,37 @@ bool wxWindow::OS2OnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
 // colours and palettes
 // ---------------------------------------------------------------------------
 
 // colours and palettes
 // ---------------------------------------------------------------------------
 

-bool wxWindow::HandleSysColorChange()
+bool wxWindowOS2::HandleSysColorChange()

 {
     wxSysColourChangedEvent         vEvent;
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 {
     wxSysColourChangedEvent         vEvent;
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleSysColorChange
+} // end of wxWindowOS2::HandleSysColorChange

 
 

-bool wxWindow::HandleCtlColor(
-  WXHBRUSH*                         phBrush
+bool wxWindowOS2::HandleCtlColor(
+  WXHBRUSH*                         WXUNUSED(phBrush)

 )
 {
     //
     // Not much provided with message. So not sure I can do anything with it
     //
     return TRUE;
 )
 {
     //
     // Not much provided with message. So not sure I can do anything with it
     //
     return TRUE;

-} // end of wxWindow::HandleCtlColor
+} // end of wxWindowOS2::HandleCtlColor

 
 

-bool wxWindow::HandleWindowParams(
-  PWNDPARAMS                        pWndParams
-, WXLPARAM                          lParam
-)
-{
-// TODO: I'll do something here, just not sure what yet
-    return TRUE;
-}

 
 // Define for each class of dialog and control
 
 // Define for each class of dialog and control

-WXHBRUSH wxWindow::OnCtlColor(WXHDC hDC,
-                              WXHWND hWnd,
-                              WXUINT nCtlColor,
-                              WXUINT message,
-                              WXWPARAM wParam,
-                              WXLPARAM lParam)
+WXHBRUSH wxWindowOS2::OnCtlColor(WXHDC WXUNUSED(hDC),
+                                 WXHWND WXUNUSED(hWnd),
+                                 WXUINT WXUNUSED(nCtlColor),
+                                 WXUINT WXUNUSED(message),
+                                 WXWPARAM WXUNUSED(wParam),
+                                 WXLPARAM WXUNUSED(lParam))

 {
     return (WXHBRUSH)0;
 }
 
 {
     return (WXHBRUSH)0;
 }
 

-bool wxWindow::HandlePaletteChanged()
+bool wxWindowOS2::HandlePaletteChanged()

 {
     // need to set this to something first
     WXHWND                          hWndPalChange = NULLHANDLE;
 {
     // need to set this to something first
     WXHWND                          hWndPalChange = NULLHANDLE;


@@ -2802,27 +3303,12 @@ bool wxWindow::HandlePaletteChanged()
     vEvent.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
 
     return GetEventHandler()->ProcessEvent(vEvent);
     vEvent.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
 
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandlePaletteChanged
-
-bool wxWindow::HandlePresParamChanged(
-  WXWPARAM                          wParam
-)
-{
-    //
-    // TODO:  Once again I'll do something here when I need it
-    //
-    //wxQueryNewPaletteEvent event(GetId());
-    //event.SetEventObject(this);
-    // if the background is erased
-//            bProcessed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
-
-    return FALSE; //GetEventHandler()->ProcessEvent(event) && event.GetPaletteRealized();
-}
+} // end of wxWindowOS2::HandlePaletteChanged

 
 //
 // Responds to colour changes: passes event on to children.
 //
 
 //
 // Responds to colour changes: passes event on to children.
 //

-void wxWindow::OnSysColourChanged(
+void wxWindowOS2::OnSysColourChanged(

   wxSysColourChangedEvent&          rEvent
 )
 {
   wxSysColourChangedEvent&          rEvent
 )
 {


@@ -2844,127 +3330,124 @@ void wxWindow::OnSysColourChanged(
         }
         pNode = pNode->Next();
     }
         }
         pNode = pNode->Next();
     }

-} // end of wxWindow::OnSysColourChanged
+} // end of wxWindowOS2::OnSysColourChanged

 
 // ---------------------------------------------------------------------------
 // painting
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // painting
 // ---------------------------------------------------------------------------
 

-bool wxWindow::HandlePaint()
+bool wxWindowOS2::HandlePaint()

 {
 {

-    HRGN                            hRgn = NULLHANDLE;
-    wxPaintEvent                    vEvent;
+    HRGN                            hRgn;
+    wxPaintEvent                    vEvent(m_windowId);

     HPS                             hPS;
     RECTL                           vRect;
     HPS                             hPS;
     RECTL                           vRect;

+    bool                            bProcessed;

 
 

-    if (::WinQueryUpdateRegion(GetHwnd(), hRgn) == RGN_NULL)
+    // Create empty region
+    // TODO: get HPS somewhere else if possible
+    hPS  = ::WinGetPS(GetHwnd());
+    hRgn = ::GpiCreateRegion(hPS, 0, NULL);
+
+    if (::WinQueryUpdateRegion(GetHwnd(), hRgn) == RGN_ERROR)

     {
          wxLogLastError("CreateRectRgn");
          return FALSE;
     }
     {
          wxLogLastError("CreateRectRgn");
          return FALSE;
     }

-    //
-    // Debug code
-    //
-#ifdef __WXDEBUG__
-    {
-        HWND                        hWnd;
-        HWND                        hWnd0 = NULLHANDLE;

 
 

-        hWnd = GetHwnd();
-        if(hWnd != hWnd0)
-            printf("HandlePaint hWnd=%x  ",hWnd);
-    }
-#endif
+    m_updateRegion = wxRegion(hRgn, hPS);

 
 

-    m_updateRegion = wxRegion(hRgn);

     vEvent.SetEventObject(this);
     vEvent.SetEventObject(this);

-    return (GetEventHandler()->ProcessEvent(vEvent));
-} // end of wxWindow::HandlePaint
+    bProcessed = GetEventHandler()->ProcessEvent(vEvent);

 
 

-bool wxWindow::HandleEraseBkgnd(WXHDC hdc)
+    return GetEventHandler()->ProcessEvent(vEvent); //bProcessed;
+} // end of wxWindowOS2::HandlePaint
+
+bool wxWindowOS2::HandleEraseBkgnd(
+  WXHDC                             hDC
+)

 {
 {

-    // TODO:  will have to worry about this later as part of
-    //        the handling of changed presentation parameters
-    /*
-    if ( ::IsIconic(GetHwnd()) )
+    SWP                             vSwp;
+    bool                            rc;
+
+    ::WinQueryWindowPos(GetHwnd(), &vSwp);
+    if (vSwp.fl & SWP_MINIMIZE)

         return TRUE;
 
         return TRUE;
 

-    wxDC dc;
+    wxDC                            vDC;

 
 

-    dc.SetHDC(hdc);
-    dc.SetWindow(this);
-    dc.BeginDrawing();
+    vDC.m_hPS = (HPS)hDC; // this is really a PS
+    vDC.SetWindow((wxWindow*)this);
+    vDC.BeginDrawing();

 
 

-    wxEraseEvent event(m_windowId, &dc);
-    event.SetEventObject(this);
-    bool rc = GetEventHandler()->ProcessEvent(event);
+    wxEraseEvent                    vEvent(m_windowId, &vDC);
+
+    vEvent.SetEventObject(this);

 
 

-    dc.EndDrawing();
-    dc.SelectOldObjects(hdc);
-    dc.SetHDC((WXHDC) NULL);
-    */
+    rc = GetEventHandler()->ProcessEvent(vEvent);
+
+    vDC.EndDrawing();
+    vDC.m_hPS = NULLHANDLE;

     return TRUE;
     return TRUE;

-} // end of wxWindow::HandleEraseBkgnd
+} // end of wxWindowOS2::HandleEraseBkgnd

 
 

-void wxWindow::OnEraseBackground(
+void wxWindowOS2::OnEraseBackground(

   wxEraseEvent&                     rEvent
 )
 {
   wxEraseEvent&                     rEvent
 )
 {

-    // TODO:
-}  // end of wxWindow::OnEraseBackground
+    RECTL                           vRect;
+    HPS                             hPS = rEvent.m_dc->m_hPS;
+    APIRET                          rc;
+    LONG                            lColor = m_backgroundColour.GetPixel();
+
+    rc = ::WinQueryWindowRect(GetHwnd(), &vRect);
+    rc = ::WinFillRect(hPS, &vRect, lColor);
+}  // end of wxWindowOS2::OnEraseBackground

 
 // ---------------------------------------------------------------------------
 // moving and resizing
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // moving and resizing
 // ---------------------------------------------------------------------------
 

-bool wxWindow::HandleMinimize()
+bool wxWindowOS2::HandleMinimize()

 {
     wxIconizeEvent                  vEvent(m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 {
     wxIconizeEvent                  vEvent(m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleMinimize
+} // end of wxWindowOS2::HandleMinimize

 
 

-bool wxWindow::HandleMaximize()
+bool wxWindowOS2::HandleMaximize()

 {
     wxMaximizeEvent                 vEvent(m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 {
     wxMaximizeEvent                 vEvent(m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleMaximize
+} // end of wxWindowOS2::HandleMaximize

 
 

-bool wxWindow::HandleMove(
+bool wxWindowOS2::HandleMove(

   int                               nX
 , int                               nY
 )
 {
   int                               nX
 , int                               nY
 )
 {

-    wxMoveEvent                     vEvent( wxPoint( nX
-                                                    ,nY
-                                                   )
-                                           ,m_windowId
-                                          );
+    wxMoveEvent                     vEvent(wxPoint(nX, nY), m_windowId);

 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-}  // end of wxWindow::HandleMove
+}  // end of wxWindowOS2::HandleMove

 
 

-bool wxWindow::HandleSize(
+bool wxWindowOS2::HandleSize(

   int                               nWidth
 , int                               nHeight
 , WXUINT                            WXUNUSED(nFlag)
 )
 {
   int                               nWidth
 , int                               nHeight
 , WXUINT                            WXUNUSED(nFlag)
 )
 {

-    wxSizeEvent                     vEvent( wxSize( nWidth
-                                                   ,nHeight
-                                                  )
-                                           ,m_windowId
-                                          );
+    wxSizeEvent                     vEvent(wxSize(nWidth, nHeight), m_windowId);

 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleSize
+} // end of wxWindowOS2::HandleSize

 
 

-bool wxWindow::HandleGetMinMaxInfo(
+bool wxWindowOS2::HandleGetMinMaxInfo(

   PSWP                              pSwp
 )
 {
   PSWP                              pSwp
 )
 {


@@ -2989,17 +3472,18 @@ bool wxWindow::HandleGetMinMaxInfo(
             return FALSE;
     }
     return TRUE;
             return FALSE;
     }
     return TRUE;

-} // end of wxWindow::HandleGetMinMaxInfo
+} // end of wxWindowOS2::HandleGetMinMaxInfo

 
 // ---------------------------------------------------------------------------
 // command messages
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // command messages
 // ---------------------------------------------------------------------------

-bool wxWindow::HandleCommand(
+bool wxWindowOS2::HandleCommand(

   WXWORD                            wId
 , WXWORD                            wCmd
 , WXHWND                            hControl
 )
 {
   WXWORD                            wId
 , WXWORD                            wCmd
 , WXHWND                            hControl
 )
 {

+#if wxUSE_MENUS_NATIVE

     if (wxCurrentPopupMenu)
     {
         wxMenu*                     pPopupMenu = wxCurrentPopupMenu;
     if (wxCurrentPopupMenu)
     {
         wxMenu*                     pPopupMenu = wxCurrentPopupMenu;


@@ -3007,6 +3491,7 @@ bool wxWindow::HandleCommand(
         wxCurrentPopupMenu = NULL;
         return pPopupMenu->OS2Command(wCmd, wId);
     }
         wxCurrentPopupMenu = NULL;
         return pPopupMenu->OS2Command(wCmd, wId);
     }

+#endif // wxUSE_MENUS_NATIVE

 
     wxWindow*                       pWin = FindItem(wId);
 
 
     wxWindow*                       pWin = FindItem(wId);
 


@@ -3016,15 +3501,14 @@ bool wxWindow::HandleCommand(
     }
 
     if (pWin)
     }
 
     if (pWin)

-        return pWin->OS2Command( wCmd
-                                ,wId
-                               );
+        return pWin->OS2Command(wCmd, wId);
+

     return FALSE;
     return FALSE;

-} // end of wxWindow::HandleCommand
+} // end of wxWindowOS2::HandleCommand

 
 

-bool wxWindow::HandleSysCommand(
+bool wxWindowOS2::HandleSysCommand(

   WXWPARAM                          wParam
   WXWPARAM                          wParam

-, WXLPARAM                          lParam
+, WXLPARAM                          WXUNUSED(lParam)

 )
 {
     //
 )
 {
     //


@@ -3039,13 +3523,13 @@ bool wxWindow::HandleSysCommand(
             return HandleMinimize();
     }
     return FALSE;
             return HandleMinimize();
     }
     return FALSE;

-} // end of wxWindow::HandleSysCommand
+} // end of wxWindowOS2::HandleSysCommand

 
 // ---------------------------------------------------------------------------
 // mouse events
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // mouse events
 // ---------------------------------------------------------------------------

-
-void wxWindow::InitMouseEvent(
+//TODO!!! check against MSW
+void wxWindowOS2::InitMouseEvent(

   wxMouseEvent&                     rEvent
 , int                               nX
 , int                               nY
   wxMouseEvent&                     rEvent
 , int                               nX
 , int                               nY


@@ -3067,9 +3551,9 @@ void wxWindow::InitMouseEvent(
     m_lastMouseY = nY;
     m_lastMouseEvent = rEvent.GetEventType();
 #endif // wxUSE_MOUSEEVENT_HACK
     m_lastMouseY = nY;
     m_lastMouseEvent = rEvent.GetEventType();
 #endif // wxUSE_MOUSEEVENT_HACK

-} // end of wxWindow::InitMouseEvent
+} // end of wxWindowOS2::InitMouseEvent

 
 

-bool wxWindow::HandleMouseEvent(
+bool wxWindowOS2::HandleMouseEvent(

   WXUINT                            uMsg
 , int                               nX
 , int                               nY
   WXUINT                            uMsg
 , int                               nX
 , int                               nY


@@ -3105,9 +3589,9 @@ bool wxWindow::HandleMouseEvent(
                   );
 
     return GetEventHandler()->ProcessEvent(vEvent);
                   );
 
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleMouseEvent
+} // end of wxWindowOS2::HandleMouseEvent

 
 

-bool wxWindow::HandleMouseMove(
+bool wxWindowOS2::HandleMouseMove(

   int                               nX
 , int                               nY
 , WXUINT                            uFlags
   int                               nX
 , int                               nY
 , WXUINT                            uFlags


@@ -3135,7 +3619,7 @@ bool wxWindow::HandleMouseMove(
                             ,nY
                             ,uFlags
                            );
                             ,nY
                             ,uFlags
                            );

-} // end of wxWindow::HandleMouseMove
+} // end of wxWindowOS2::HandleMouseMove

 
 // ---------------------------------------------------------------------------
 // keyboard handling
 
 // ---------------------------------------------------------------------------
 // keyboard handling


@@ -3145,7 +3629,7 @@ bool wxWindow::HandleMouseMove(
 // Create the key event of the given type for the given key - used by
 // HandleChar and HandleKeyDown/Up
 //
 // Create the key event of the given type for the given key - used by
 // HandleChar and HandleKeyDown/Up
 //

-wxKeyEvent wxWindow::CreateKeyEvent(
+wxKeyEvent wxWindowOS2::CreateKeyEvent(

   wxEventType                       eType
 , int                               nId
 , WXLPARAM                          lParam
   wxEventType                       eType
 , int                               nId
 , WXLPARAM                          lParam


@@ -3180,14 +3664,14 @@ wxKeyEvent wxWindow::CreateKeyEvent(
     vEvent.m_y = vPoint.y;
 
     return vEvent;
     vEvent.m_y = vPoint.y;
 
     return vEvent;

-} // end of wxWindow::CreateKeyEvent
+} // end of wxWindowOS2::CreateKeyEvent

 
 //
 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
 // WM_KEYDOWN one
 //
 
 //
 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
 // WM_KEYDOWN one
 //

-bool wxWindow::HandleChar(
-  WXWORD                            wParam
+bool wxWindowOS2::HandleChar(
+  WXDWORD                           wParam

 , WXLPARAM                          lParam
 , bool                              isASCII
 )
 , WXLPARAM                          lParam
 , bool                              isASCII
 )


@@ -3250,7 +3734,7 @@ bool wxWindow::HandleChar(
     return FALSE;
 }
 
     return FALSE;
 }
 

-bool wxWindow::HandleKeyDown(
+bool wxWindowOS2::HandleKeyDown(

   WXWORD                            wParam
 , WXLPARAM                          lParam
 )
   WXWORD                            wParam
 , WXLPARAM                          lParam
 )


@@ -3278,10 +3762,10 @@ bool wxWindow::HandleKeyDown(
         }
     }
     return FALSE;
         }
     }
     return FALSE;

-} // end of wxWindow::HandleKeyDown
+} // end of wxWindowOS2::HandleKeyDown

 
 

-bool wxWindow::HandleKeyUp(
-  WXWORD                            wParam
+bool wxWindowOS2::HandleKeyUp(
+  WXDWORD                           wParam

 , WXLPARAM                          lParam
 )
 {
 , WXLPARAM                          lParam
 )
 {


@@ -3306,7 +3790,7 @@ bool wxWindow::HandleKeyUp(
             return TRUE;
     }
     return FALSE;
             return TRUE;
     }
     return FALSE;

-} // end of wxWindow::HandleKeyUp
+} // end of wxWindowOS2::HandleKeyUp

 
 // ---------------------------------------------------------------------------
 // joystick
 
 // ---------------------------------------------------------------------------
 // joystick


@@ -3316,7 +3800,7 @@ bool wxWindow::HandleKeyUp(
 // scrolling
 // ---------------------------------------------------------------------------
 
 // scrolling
 // ---------------------------------------------------------------------------
 

-bool wxWindow::OS2OnScroll(
+bool wxWindowOS2::OS2OnScroll(

   int                               nOrientation
 , WXWORD                            wParam
 , WXWORD                            wPos
   int                               nOrientation
 , WXWORD                            wParam
 , WXWORD                            wPos


@@ -3371,7 +3855,7 @@ bool wxWindow::OS2OnScroll(
             return FALSE;
     }
     return GetEventHandler()->ProcessEvent(vEvent);
             return FALSE;
     }
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::OS2OnScroll
+} // end of wxWindowOS2::OS2OnScroll

 
 // ===========================================================================
 // global functions
 
 // ===========================================================================
 // global functions


@@ -3381,10 +3865,31 @@ void wxGetCharSize(
   WXHWND                            hWnd
 , int*                              pX
 , int*                              pY
   WXHWND                            hWnd
 , int*                              pX
 , int*                              pY

-,wxFont*                            pTheFont
+,wxFont*                            WXUNUSED(pTheFont)

 )
 {
 )
 {

-  // TODO: we'll do this later
+    FONTMETRICS                     vFM;
+    HPS                             hPS;
+    BOOL                            rc;
+
+    hPS =::WinGetPS(hWnd);
+
+    rc = ::GpiQueryFontMetrics(hPS, sizeof(FONTMETRICS), &vFM);
+    if (rc)
+    {
+        if (pX)
+            *pX = vFM.lAveCharWidth;
+        if (pY)
+            *pY = vFM.lEmHeight + vFM.lExternalLeading;
+    }
+    else
+    {
+        if (pX)
+            *pX = 10;
+        if (pY)
+            *pY = 15;
+    }
+    ::WinReleasePS(hPS);

 } // end of wxGetCharSize
 
 //
 } // end of wxGetCharSize
 
 //


@@ -3987,6 +4492,8 @@ const char* wxGetMessageName(
 
 #endif // __WXDEBUG__
 
 
 #endif // __WXDEBUG__
 

+// Unused?
+#if 0

 static void TranslateKbdEventToMouse(
   wxWindow*                         pWin
 , int*                              pX
 static void TranslateKbdEventToMouse(
   wxWindow*                         pWin
 , int*                              pX


@@ -4015,11 +4522,12 @@ static void TranslateKbdEventToMouse(
 
     pWin->ScreenToClient(pX, pY);
 } // end of TranslateKbdEventToMouse
 
     pWin->ScreenToClient(pX, pY);
 } // end of TranslateKbdEventToMouse

+#endif

 
 // Find the wxWindow at the current mouse position, returning the mouse
 // position.
 wxWindow* wxFindWindowAtPointer(
 
 // Find the wxWindow at the current mouse position, returning the mouse
 // position.
 wxWindow* wxFindWindowAtPointer(

-  wxPoint&                          rPt
+  wxPoint&                          WXUNUSED(rPt)

 )
 {
     return wxFindWindowAtPoint(wxGetMousePosition());
 )
 {
     return wxFindWindowAtPoint(wxGetMousePosition());