delay getting the default editor and renderer (by data type) until

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

diff --git a/src/os2/window.cpp b/src/os2/window.cpp
index fb16810ccc1c0c9a823e9dfb72e730b4164fd4fd..8170ce44bdcf8136c681df9e10037cb791392ced 100644 (file)
--- a/src/os2/window.cpp
+++ b/src/os2/window.cpp
@@ -9,7 +9,9 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

+//

 // For compilers that support precompilation, includes "wx.h".
 // For compilers that support precompilation, includes "wx.h".

+//

 #include "wx/wxprec.h"
 
 #ifndef WX_PRECOMP
 #include "wx/wxprec.h"
 
 #ifndef WX_PRECOMP


@@ -64,14 +66,21 @@
 
 #include <string.h>
 
 
 #include <string.h>
 

-// place compiler, OS specific includes here
-
+//
+// Place compiler, OS specific includes here
+//

 
 

-// standard macros -- these are for OS/2 PM, but most GUI's have something similar
+//
+// Standard macros -- these are for OS/2 PM, but most GUI's have something similar
+//

 #ifndef GET_X_LPARAM
 #ifndef GET_X_LPARAM

+//

 //  SHORT1FROMMP -- LOWORD
 //  SHORT1FROMMP -- LOWORD

+//

     #define GET_X_LPARAM(mp) ((unsigned short)(unsigned long)(mp))
     #define GET_X_LPARAM(mp) ((unsigned short)(unsigned long)(mp))

+//

 //  SHORT2FROMMP -- HIWORD
 //  SHORT2FROMMP -- HIWORD

+//

     #define GET_Y_LPARAM(mp) ((unsigned short)(unsigned long)(mp >> 16))
 #endif // GET_X_LPARAM
 
     #define GET_Y_LPARAM(mp) ((unsigned short)(unsigned long)(mp >> 16))
 #endif // GET_X_LPARAM
 


@@ -79,18 +88,23 @@
 // global variables
 // ---------------------------------------------------------------------------
 
 // global variables
 // ---------------------------------------------------------------------------
 

-// the last Windows message we got (MT-UNSAFE)
-extern WXMSGID s_currentMsg;
-extern wxList WXDLLEXPORT wxPendingDelete;
-extern wxChar wxCanvasClassName[];
+//
+// The last Windows message we got (MT-UNSAFE)
+//
+extern WXMSGID            s_currentMsg;

 
 

-wxMenu *wxCurrentPopupMenu = NULL;
-wxList *wxWinHandleList = NULL;
+wxMenu*                   wxCurrentPopupMenu = NULL;
+extern wxList WXDLLEXPORT wxPendingDelete;
+extern wxChar*            wxCanvasClassName;
+wxList*                   wxWinHandleList = NULL;

 
 // ---------------------------------------------------------------------------
 // private functions
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // private functions
 // ---------------------------------------------------------------------------

+
+//

 // the window proc for all our windows; most gui's have something similar
 // the window proc for all our windows; most gui's have something similar

+//

 MRESULT wxWndProc( HWND hWnd
                   ,ULONG message
                   ,MPARAM mp1
 MRESULT wxWndProc( HWND hWnd
                   ,ULONG message
                   ,MPARAM mp1


@@ -101,17 +115,32 @@ MRESULT wxWndProc( HWND hWnd
     const char *wxGetMessageName(int message);
 #endif  //__WXDEBUG__
 
     const char *wxGetMessageName(int message);
 #endif  //__WXDEBUG__
 

-void wxRemoveHandleAssociation(wxWindow *win);
-void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
-wxWindow *wxFindWinFromHandle(WXHWND hWnd);
+void      wxRemoveHandleAssociation(wxWindow* pWin);
+void      wxAssociateWinWithHandle( HWND      hWnd
+                                   ,wxWindow* pWin
+                                  );
+wxWindow* wxFindWinFromHandle(WXHWND hWnd);

 
 

+//
+// This magical function is used to translate VK_APPS key presses to right
+// mouse clicks
+//
+static void TranslateKbdEventToMouse( wxWindow* pWin
+                                     ,int*      pX
+                                     ,int*      pY
+                                     ,MPARAM*   pFlags
+                                    );
+
+//
+// get the current state of SHIFT/CTRL keys
+//
+static inline bool IsShiftDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x8000) != 0; }
+static inline bool IsCtrlDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000) != 0; }

 // ---------------------------------------------------------------------------
 // event tables
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // event tables
 // ---------------------------------------------------------------------------
 

-#if !USE_SHARED_LIBRARY

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

-#endif

 
 BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
     EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
 
 BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
     EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)


@@ -124,40 +153,47 @@ END_EVENT_TABLE()
 // implementation
 // ===========================================================================
 
 // implementation
 // ===========================================================================
 

+//

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

+//

 wxWindow* wxWindow::FindItem(
 wxWindow* wxWindow::FindItem(

-  long                              ulId
+  long                              lId

 ) const
 {
 ) const
 {

+    wxControl*                      pItem = wxDynamicCast( this
+                                                          ,wxControl
+                                                         );
+
+    if (pItem)
+    {
+        //
+        // I it we or one of our "internal" children?
+        //
+        if (pItem->GetId() == lId ||
+             (pItem->GetSubcontrols().Index(lId) != wxNOT_FOUND))
+        {
+            return pItem;
+        }
+    }
+

     wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
 
     while (pCurrent)
     {
         wxWindow*                   pChildWin = pCurrent->GetData();
     wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
 
     while (pCurrent)
     {
         wxWindow*                   pChildWin = pCurrent->GetData();

-        wxWindow*                   pWnd = pChildWin->FindItem(ulId);
+        wxWindow*                   pWnd = pChildWin->FindItem(lId);

 
         if (pWnd)
             return pWnd;
 
 
         if (pWnd)
             return pWnd;
 

-        if (pChildWin->IsKindOf(CLASSINFO(wxControl)))
-        {
-            wxControl*              pItem = (wxControl *)pChildWin;
-
-            if (pItem->GetId() == ulId)
-                return(pItem);
-            else
-            {
-                // In case it's a 'virtual' control (e.g. radiobox)
-                if (pItem->GetSubcontrols().Member((wxObject *)ulId))
-                    return(pItem);
-            }
-        }

         pCurrent = pCurrent->GetNext();
     }
     return(NULL);
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);

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

 
 

+//

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

+//

 wxWindow* wxWindow::FindItemByHWND(
   WXHWND                            hWnd
 , bool                              bControlOnly
 wxWindow* wxWindow::FindItemByHWND(
   WXHWND                            hWnd
 , bool                              bControlOnly


@@ -169,7 +205,9 @@ wxWindow* wxWindow::FindItemByHWND(
     {
         wxWindow*                   pParent = pCurrent->GetData();
 
     {
         wxWindow*                   pParent = pCurrent->GetData();
 

+        //

         // Do a recursive search.
         // Do a recursive search.

+        //

         wxWindow*                   pWnd = pParent->FindItemByHWND(hWnd);
 
         if (pWnd)
         wxWindow*                   pWnd = pParent->FindItemByHWND(hWnd);
 
         if (pWnd)


@@ -190,9 +228,11 @@ wxWindow* wxWindow::FindItemByHWND(
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);

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

 
 

+//

 // Default command handler
 // Default command handler

+//

 bool wxWindow::OS2Command(
   WXUINT                            WXUNUSED(uParam)
 , WXWORD                            WXUNUSED(uId)
 bool wxWindow::OS2Command(
   WXUINT                            WXUNUSED(uParam)
 , WXWORD                            WXUNUSED(uId)


@@ -207,10 +247,14 @@ bool wxWindow::OS2Command(
 
 void wxWindow::Init()
 {
 
 void wxWindow::Init()
 {

-    // generic
+    //
+    // Generic
+    //

     InitBase();
 
     InitBase();
 

+    //

     // PM specific
     // PM specific

+    //

     m_bDoubleClickAllowed = 0;
     m_bWinCaptured = FALSE;
 
     m_bDoubleClickAllowed = 0;
     m_bWinCaptured = FALSE;
 


@@ -219,19 +263,23 @@ void wxWindow::Init()
     m_bUseCtl3D = FALSE;
     m_bMouseInWindow = FALSE;
 
     m_bUseCtl3D = FALSE;
     m_bMouseInWindow = FALSE;
 

+    //

     // wxWnd
     // wxWnd

+    //

     m_hMenu = 0;
     m_hMenu = 0;

-

     m_hWnd = 0;
 
     m_hWnd = 0;
 

-    // pass WM_GETDLGCODE to DefWindowProc()
+    //
+    // Pass WM_GETDLGCODE to DefWindowProc()

     m_lDlgCode = 0;
 
     m_nXThumbSize = 0;
     m_nYThumbSize = 0;
     m_bBackgroundTransparent = FALSE;
 
     m_lDlgCode = 0;
 
     m_nXThumbSize = 0;
     m_nYThumbSize = 0;
     m_bBackgroundTransparent = FALSE;
 

-    // as all windows are created with WS_VISIBLE style...
+    //
+    // As all windows are created with WS_VISIBLE style...
+    //

     m_isShown = TRUE;
 
 #if wxUSE_MOUSEEVENT_HACK
     m_isShown = TRUE;
 
 #if wxUSE_MOUSEEVENT_HACK


@@ -239,26 +287,29 @@ void wxWindow::Init()
     m_lLastMouseY = -1;
     m_nLastMouseEvent = -1;
 #endif // wxUSE_MOUSEEVENT_HACK
     m_lLastMouseY = -1;
     m_nLastMouseEvent = -1;
 #endif // wxUSE_MOUSEEVENT_HACK

-}
+} // wxWindow::Init

 
 

+//

 // Destructor
 // Destructor

+//

 wxWindow::~wxWindow()
 {
     m_isBeingDeleted = TRUE;
 
     OS2DetachWindowMenu();
 wxWindow::~wxWindow()
 {
     m_isBeingDeleted = TRUE;
 
     OS2DetachWindowMenu();

-    // delete handlers?

     if (m_parent)
         m_parent->RemoveChild(this);
     DestroyChildren();
     if (m_hWnd)
     {
     if (m_parent)
         m_parent->RemoveChild(this);
     DestroyChildren();
     if (m_hWnd)
     {

-        if(!WinDestroyWindow(GetHWND()))
+        if(!::WinDestroyWindow(GetHWND()))

             wxLogLastError(wxT("DestroyWindow"));
             wxLogLastError(wxT("DestroyWindow"));

+        //

         // remove hWnd <-> wxWindow association
         // remove hWnd <-> wxWindow association

+        //

         wxRemoveHandleAssociation(this);
     }
         wxRemoveHandleAssociation(this);
     }

-}
+} // end of wxWindow::~wxWindow

 
 bool wxWindow::Create(
   wxWindow*                         pParent
 
 bool wxWindow::Create(
   wxWindow*                         pParent


@@ -283,10 +334,39 @@ bool wxWindow::Create(
 
     pParent->AddChild(this);
 
 
     pParent->AddChild(this);
 

+    ULONG                           ulFlags = 0L;
+
+    //
+    // Frame windows and their derivatives only
+    //
+    if (lStyle & wxBORDER)
+        ulFlags |= FCF_BORDER;
+    if (lStyle & wxTHICK_FRAME )
+        ulFlags |= FCF_SIZEBORDER;
+
+    //
+    // Some generic window styles
+    //
+    ulFlags |= WS_VISIBLE;
+    if (lStyle & wxCLIP_CHILDREN )
+        ulFlags |= WS_CLIPCHILDREN;
+

     bool                            bWant3D;
     WXDWORD                         dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D);
     bool                            bWant3D;
     WXDWORD                         dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D);

-    DWORD                           ulFlags = 0L;

 
 

+    //
+    // OS/2 PM doesn't have "extended" styles but if the library specifies
+    // them and we are creating a frame window then at least give it a border
+    //
+    if ( bWant3D ||
+        (m_windowStyle & wxSIMPLE_BORDER) ||
+        (m_windowStyle & wxRAISED_BORDER ) ||
+        (m_windowStyle & wxSUNKEN_BORDER) ||
+        (m_windowStyle & wxDOUBLE_BORDER)
+       )
+    {
+        ulFlags |= FCF_BORDER;
+    }

     OS2Create( m_windowId
               ,pParent
               ,wxCanvasClassName
     OS2Create( m_windowId
               ,pParent
               ,wxCanvasClassName


@@ -301,7 +381,7 @@ bool wxWindow::Create(
               ,dwExStyle
              );
     return(TRUE);
               ,dwExStyle
              );
     return(TRUE);

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

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


@@ -309,74 +389,177 @@ bool wxWindow::Create(
 
 void wxWindow::SetFocus()
 {
 
 void wxWindow::SetFocus()
 {

-    // TODO:
-}
+    HWND                            hWnd = GetHwnd();
+
+    if (hWnd)
+        ::WinSetFocus(HWND_DESKTOP, hWnd);
+} // end of wxWindow::SetFocus

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

-    wxWindow*                       window = NULL;
-    // TODO:
-    return(window);
-}
+    HWND                            hWnd = ::WinQueryFocus(HWND_DESKTOP);

 
 

-bool wxWindow::Enable(bool enable) // check if base implementation is OK
+    if (hWnd)
+    {
+        return wxFindWinFromHandle((WXHWND)hWnd);
+    }
+    return NULL;
+} // wxWindowBase::FindFocus
+
+bool wxWindow::Enable(
+  bool                              bEnable
+)

 {
 {

-    // TODO:
+    if (!wxWindowBase::Enable(bEnable))
+        return(FALSE);
+
+    HWND                            hWnd = GetHwnd();
+
+    if ( hWnd )
+        ::WinEnableWindow(hWnd, (BOOL)bEnable);
+
+    wxWindowList::Node*             pNode = GetChildren().GetFirst();
+
+    while (pNode)
+    {
+        wxWindow*                   pChild = pNode->GetData();
+
+        pChild->Enable(bEnable);
+        pNode = pNode->GetNext();
+    }

     return(TRUE);
     return(TRUE);

-}
+} // end of wxWindow::Enable

 
 

-bool wxWindow::Show(bool show) // check if base implementation is OK
+bool wxWindow::Show(
+  bool                              bShow
+)

 {
 {

-    // TODO:
+    if (!wxWindowBase::Show(bShow))
+        return(FALSE);
+
+    HWND                            hWnd = GetHwnd();
+
+    ::WinShowWindow(hWnd, bShow);
+
+    if (bShow)
+    {
+        ::WinSetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER);
+    }

     return(TRUE);
     return(TRUE);

-}
+} // end of wxWindow::Show

 
 void wxWindow::Raise()
 {
 
 void wxWindow::Raise()
 {

-    // TODO:
-}
+    ::WinSetWindowPos(GetHwnd(), HWND_TOP, 0, 0, 0, 0, SWP_ZORDER | SWP_ACTIVATE);
+} // end of wxWindow::Raise

 
 void wxWindow::Lower()
 {
 
 void wxWindow::Lower()
 {

-    // TODO:
-}
+    ::WinSetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_ZORDER | SWP_DEACTIVATE);
+} // end of wxWindow::Lower

 
 

-void wxWindow::SetTitle( const wxString& title)
+void wxWindow::SetTitle(
+  const wxString&                   rTitle
+)

 {
 {

-// TODO:    SetWindowText(GetHwnd(), title.c_str());
-}
+    ::WinSetWindowText(GetHwnd(), rTitle.c_str());
+} // end of wxWindow::SetTitle

 
 wxString wxWindow::GetTitle() const
 {
     return wxGetWindowText(GetHWND());
 
 wxString wxWindow::GetTitle() const
 {
     return wxGetWindowText(GetHWND());

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

 
 void wxWindow::CaptureMouse()
 {
 
 void wxWindow::CaptureMouse()
 {

-    // TODO:
-}
+    HWND                            hWnd = GetHwnd();
+
+    if (hWnd && !m_bWinCaptured)
+    {
+        ::WinSetCapture(HWND_DESKTOP, hWnd);
+        m_bWinCaptured = TRUE;
+    }
+} // end of wxWindow::GetTitle

 
 void wxWindow::ReleaseMouse()
 {
 
 void wxWindow::ReleaseMouse()
 {

-    // TODO:
-}
+    if (m_bWinCaptured)
+    {
+        ::WinSetCapture(HWND_DESKTOP, NULLHANDLE);
+        m_bWinCaptured = FALSE;
+    }
+} // end of wxWindow::ReleaseMouse

 
 

-bool wxWindow::SetFont(const wxFont& f)
+bool wxWindow::SetFont(
+  const wxFont&                     rFont
+)

 {
 {

-    // TODO:
+    if (!wxWindowBase::SetFont(rFont))
+    {
+        // nothing to do
+        return(FALSE);
+    }
+
+    HWND                            hWnd = GetHwnd();
+
+    if (hWnd != 0)
+    {
+        wxChar                      zFont[128];
+
+        sprintf(zFont, "%d.%s", rFont.GetPointSize(), rFont.GetFaceName().c_str());
+        return(::WinSetPresParam(hWnd, PP_FONTNAMESIZE, strlen(zFont), (PVOID)zFont));
+    }

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

-bool wxWindow::SetCursor(const wxCursor& cursor) // check if base implementation is OK
+bool wxWindow::SetCursor(
+  const wxCursor&                   rCursor
+) // check if base implementation is OK

 {
 {

-    // TODO:
-    return(TRUE);
-}
+    if ( !wxWindowBase::SetCursor(rCursor))
+    {
+        // no change
+        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);
+
+    hRGN = ::GpiCreateRegion(hPS, 1L, &vRect);

 
 

-void wxWindow::WarpPointer(int x_pos, int y_pos)
+    if ((::GpiPtInRegion(hPS, hRGN, &vPoint) == PRGN_INSIDE) && !wxIsBusy())
+    {
+        ::WinSetPointer(HWND_DESKTOP, (HPOINTER)m_cursor.GetHCURSOR());
+    }
+    return TRUE;
+} // end of wxWindow::SetCursor
+
+void wxWindow::WarpPointer(
+  int                               nXPos
+, int                               nYPos
+)

 {
 {

-    // TODO:
-}
+    int                             nX = nXPos;
+    int                             nY = nYPos;
+    RECTL                           vRect;
+
+    ::WinQueryWindowRect(GetHwnd(), &vRect);
+    nX += vRect.xLeft;
+    nY += vRect.yBottom;
+
+    ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY));
+} // end of wxWindow::WarpPointer

 
 #if WXWIN_COMPATIBILITY
 void wxWindow::OS2DeviceToLogical (float *x, float *y) const
 
 #if WXWIN_COMPATIBILITY
 void wxWindow::OS2DeviceToLogical (float *x, float *y) const


@@ -389,271 +572,389 @@ void wxWindow::OS2DeviceToLogical (float *x, float *y) const
 // ---------------------------------------------------------------------------
 
 #if WXWIN_COMPATIBILITY
 // ---------------------------------------------------------------------------
 
 #if WXWIN_COMPATIBILITY

-void wxWindow::SetScrollRange(int orient, int range, bool refresh)
+void wxWindow::SetScrollRange(
+  int                               nOrient
+, int                               nRange
+, bool                              bRefresh
+)

 {
 {

-   // TODO:
-}
+    ::WinSendMsg(GetHwnd(), SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, nRange));
+} // end of wxWindow::SetScrollRange

 
 

-void wxWindow::SetScrollPage(int orient, int page, bool refresh)
+void wxWindow::SetScrollPage(
+  int                               nOrient
+, int                               nPage
+, bool                              bRefresh
+)

 {
 {

-   // TODO:
+    if ( orient == wxHORIZONTAL )
+        m_xThumbSize = page;
+    else
+        m_yThumbSize = page;

 }
 
 }
 

-int wxWindow::OldGetScrollRange(int orient) const
+int wxWindow::OldGetScrollRange(
+  int                               nOrient
+) const

 {
 {

-   // TODO:
-   return 0;
-}
+    MRESULT                         mRc;
+    HWND                            hWnd = GetHwnd();

 
 

-int  wxWindow::GetScrollPage(int orient) const
+    if (hWnd)
+    {
+        mRc = WinSendMsg(hWnd, SBM_QUERYRANGE, (MPARAM)0L, (MPARAM)0L);
+        return(SHORT2FROMMR(mRc));
+     }
+     return 0;
+} // end of wxWindow::OldGetScrollRange
+
+int  wxWindow::GetScrollPage(
+  int                               nOrient
+) const

 {
 {

-    // TODO:
-    return(1);
-}
+    if (nOrient == wxHORIZONTAL)
+        return m_nXThumbSize;
+    else
+        return m_nYThumbSize;
+} // end of wxWindow::GetScrollPage

 #endif // WXWIN_COMPATIBILITY
 
 #endif // WXWIN_COMPATIBILITY
 

-int  wxWindow::GetScrollPos(int orient) const
+int  wxWindow::GetScrollPos(
+  int                               nOrient
+) const

 {
 {

-    // TODO:
-    return(1);
-}
+    return((int)::WinSendMsg(GetHwnd(), SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
+} // end of wxWindow::GetScrollPos

 
 

-int  wxWindow::GetScrollRange(int orient) const
+int wxWindow::GetScrollRange(
+  int                               nOrient
+) const

 {
 {

-    // TODO:
-    return(1);
-}
+    MRESULT                         mr;
+
+    mr = ::WinSendMsg(GetHwnd(), SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
+    return((int)SHORT2FROMMR(mr));
+} // end of wxWindow::GetScrollRange

 
 

-int  wxWindow::GetScrollThumb(int orient) const
+int wxWindow::GetScrollThumb(
+  int                               nOrient
+) const

 {
 {

-    // TODO:
-    return(1);
-}
+    WNDPARAMS                       vWndParams;
+    PSBCDATA                        pSbcd;
+
+    ::WinSendMsg(GetHwnd(), WM_QUERYWINDOWPARAMS, (MPARAM)&vWndParams, (MPARAM)NULL);
+    pSbcd = (PSBCDATA)vWndParams.pCtlData;
+    return((int)pSbcd->posThumb);
+} // end of wxWindow::GetScrollThumb

 
 

-void wxWindow::SetScrollPos( int  orient
-                            ,int  pos
-                            ,bool refresh
-                           )
+void wxWindow::SetScrollPos(
+  int                               nOrient
+, int                               nPos
+, bool                              bRefresh
+)

 {
 {

-    // TODO:
-}
+    ::WinSendMsg(GetHwnd(), SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
+} // end of wxWindow::SetScrollPos(

 
 

-void wxWindow::SetScrollbar( int  orient
-                            ,int  pos
-                            ,int  thumbVisible
-                            ,int  range
-                            ,bool refresh
-                           )
+void wxWindow::SetScrollbar(
+  int                               nOrient
+, int                               nPos
+, int                               nThumbVisible
+, int                               nRange
+, bool                              bRefresh
+)

 {
 {

-    // TODO:
-}
+    ::WinSendMsg(GetHwnd(), SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, nRange));
+    if (nOrient == wxHORIZONTAL)
+    {
+        m_nXThumbSize = nThumbVisible;
+    }
+    else
+    {
+        m_nYThumbSize = nThumbVisible;
+    }
+} // end of wxWindow::SetScrollbar

 
 

-void wxWindow::ScrollWindow( int           dx
-                            ,int           dy
-                            ,const wxRect* rect
-                           )
+void wxWindow::ScrollWindow(
+  int                               nDx
+, int                               nDy
+, const wxRect*                     pRect
+)

 {
 {

-    // TODO:
-}
+    RECTL                           vRect2;
+
+    if (pRect)
+    {
+        vRect2.xLeft   = pRect->x;
+        vRect2.yTop    = pRect->y;
+        vRect2.xRight  = pRect->x + pRect->width;
+        vRect2.yBottom = pRect->y + pRect->height;
+    }
+
+    if (pRect)
+        ::WinScrollWindow(GetHwnd(), (LONG)nDx, (LONG)nDy, &vRect2, NULL, NULLHANDLE, NULL, 0L);
+    else
+        ::WinScrollWindow(GetHwnd(), nDx, nDy, NULL, NULL, NULLHANDLE, NULL, 0L);
+} // end of wxWindow::ScrollWindow

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

-void wxWindow::SubclassWin(WXHWND hWnd)
+void wxWindow::SubclassWin(
+  WXHWND                            hWnd
+)

 {
 {

+    HAB                             hab;
+    HWND                            hwnd = (HWND)hWnd;
+

     wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
 
     wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
 

-    HWND hwnd = (HWND)hWnd;
-/*
-* TODO: implement something like this:
-*   wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in SubclassWin") );
-*
-*   wxAssociateWinWithHandle(hwnd, this);
-*
-*   m_oldWndProc = (WXFARPROC) GetWindowLong(hwnd, GWL_WNDPROC);
-*   SetWindowLong(hwnd, GWL_WNDPROC, (LONG) wxWndProc);
-*/
-}
+    wxCHECK_RET(::WinIsWindow(hab, hwnd), wxT("invalid HWND in SubclassWin") );
+
+    wxAssociateWinWithHandle(hwnd, this);
+
+    m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, wxWndProc);
+    ::WinSetWindowULong(hwnd, QWS_USER, wxWndProc);
+} // end of wxWindow::SubclassWin

 
 void wxWindow::UnsubclassWin()
 {
 
 void wxWindow::UnsubclassWin()
 {

-/*
-* TODO:
+    HAB                             hab;

 
     wxRemoveHandleAssociation(this);
 
 
     wxRemoveHandleAssociation(this);
 

+    //

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

-    HWND hwnd = GetHwnd();
-    if ( hwnd )
+    //
+    HWND                            hwnd = GetHwnd();
+
+    if (hwnd)

     {
         m_hWnd = 0;
 
     {
         m_hWnd = 0;
 

-        wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in UnsubclassWin") );
+        wxCHECK_RET( ::WinIsWindow(hab, hwnd), wxT("invalid HWND in UnsubclassWin") );

 
 

-        FARPROC farProc = (FARPROC) GetWindowLong(hwnd, GWL_WNDPROC);
-        if ( (m_oldWndProc != 0) && (farProc != (FARPROC) m_oldWndProc) )
+        PFNWP                       fnProc = (PFNWP)::WinQueryWindowULong(hwnd, QWS_USER);
+        if ( (m_fnOldWndProc != 0) && (fnProc != (PFNWP) m_fnOldWndProc))

         {
         {

-            SetWindowLong(hwnd, GWL_WNDPROC, (LONG) m_oldWndProc);
-            m_oldWndProc = 0;
+            WinSubclassWindow(hwnd, (PFNWP)m_fnOldWndProc);
+            m_fnOldWndProc = 0;

         }
     }
         }
     }

-*/
-}
+} // end of wxWindow::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(long style, bool eliminateBorders)
+//
+WXDWORD wxWindow::MakeExtendedStyle(
+  long                              lStyle
+, bool                              bEliminateBorders
+)

 {
 {

-   // TODO:
-    WXDWORD exStyle = 0;
-/*
-    if ( style & wxTRANSPARENT_WINDOW )
-        exStyle |= WS_EX_TRANSPARENT;
-
-    if ( !eliminateBorders )
-    {
-        if ( style & wxSUNKEN_BORDER )
-            exStyle |= WS_EX_CLIENTEDGE;
-        if ( style & wxDOUBLE_BORDER )
-            exStyle |= WS_EX_DLGMODALFRAME;
-        if ( style & wxRAISED_BORDER )
-            exStyle |= WS_EX_WINDOWEDGE;
-        if ( style & wxSTATIC_BORDER )
-            exStyle |= WS_EX_STATICEDGE;
-    }
-*/
+   //
+   // PM does not support extended style
+   //
+    WXDWORD                         exStyle = 0;

     return exStyle;
     return exStyle;

-}
+} // end of wxWindow::MakeExtendedStyle

 
 

+//

 // Determines whether native 3D effects or CTL3D should be used,
 // applying a default border style if required, and returning an extended
 // style to pass to CreateWindowEx.
 // Determines whether native 3D effects or CTL3D should be used,
 // applying a default border style if required, and returning an extended
 // style to pass to CreateWindowEx.

-WXDWORD wxWindow::Determine3DEffects(WXDWORD defaultBorderStyle,
-                                     bool *want3D) const
+//
+WXDWORD wxWindow::Determine3DEffects(
+  WXDWORD                           dwDefaultBorderStyle
+, YBool*                            pbWant3D
+) const

 {
 {

-   DWORD exStyle; // remove after implementation doe
-/* TODO:  this ought to be fun
-*
-    // 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) )
-    {
-        *want3D = FALSE;
-        return MakeExtendedStyle(m_windowStyle, FALSE);
-    }
-
-    // Determine whether we should be using 3D effects or not.
-    bool nativeBorder = FALSE; // by default, we don't want a Win95 effect
-
-    // 1) App can specify global 3D effects
-    *want3D = wxTheApp->GetAuto3D();
-
-    // 2) If the parent is being drawn with user colours, or simple border specified,
-    // switch effects off. TODO: replace wxUSER_COLOURS with wxNO_3D
-    if ( GetParent() && (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS) || (m_windowStyle & wxSIMPLE_BORDER) )
-        *want3D = FALSE;
-
-    // 3) Control can override this global setting by defining
-    // a border style, e.g. wxSUNKEN_BORDER
-    if ( m_windowStyle & wxSUNKEN_BORDER  )
-        *want3D = TRUE;
-
-    // 4) If it's a special border, CTL3D can't cope so we want a native border
-    if ( (m_windowStyle & wxDOUBLE_BORDER) || (m_windowStyle & wxRAISED_BORDER) ||
-        (m_windowStyle & wxSTATIC_BORDER) )
-    {
-        *want3D = TRUE;
-        nativeBorder = TRUE;
-    }
-
-    // 5) If this isn't a Win95 app, and we are using CTL3D, remove border
-    // effects from extended style
-#if wxUSE_CTL3D
-    if ( *want3D )
-        nativeBorder = FALSE;
-#endif
-
-    DWORD exStyle = MakeExtendedStyle(m_windowStyle, !nativeBorder);
-
-    // If we want 3D, but haven't specified a border here,
-    // apply the default border style specified.
-    // TODO what about non-Win95 WIN32? Does it have borders?
-#if defined(__WIN95__) && !wxUSE_CTL3D
-    if ( defaultBorderStyle && (*want3D) && ! ((m_windowStyle & wxDOUBLE_BORDER) || (m_windowStyle & wxRAISED_BORDER ) ||
-        (m_windowStyle & wxSTATIC_BORDER) || (m_windowStyle & wxSIMPLE_BORDER) ))
-        exStyle |= defaultBorderStyle; // WS_EX_CLIENTEDGE;
-#endif
-*/
-    return exStyle;
-}
+    WXDWORD                         dwStyle = 0L; 
+   
+    //
+    // Native PM does not have any specialize 3D effects like WIN32 does
+    //
+    *pbWant3D = FALSE;
+    return dwStyle;
+} // end of wxWindow::Determine3DEffects

 
 #if WXWIN_COMPATIBILITY
 
 #if WXWIN_COMPATIBILITY

-void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event)
+void wxWindow::OnCommand(
+  wxWindow&                         rWin
+, wxCommandEvent&                   rEvent
+)

 {
 {

-    // TODO:
-}
+    if (GetEventHandler()->ProcessEvent(rEvent))
+        return;
+    if (m_parent)
+        m_parent->GetEventHandler()->OnCommand( rWin
+                                               ,rEvent
+                                              );
+} // end of wxWindow::OnCommand

 
 

-wxObject* wxWindow::GetChild(int number) const
+wxObject* wxWindow::GetChild(
+  int                               nNumber
+) const

 {
 {

-    // TODO:
-    return((wxObject*)this);
-}
+    //
+    // Return a pointer to the Nth object in the Panel
+    //
+    wxNode*                         pNode = GetChildren().First();
+    int                             n = nNumber;

 
 

-void wxWindow::OnDefaultAction(wxControl *initiatingItem)
-{
-    // TODO:
-}
+    while (pNode && n--)
+        pNode = pNode->Next();
+    if (pNode)
+    {
+        wxObject*                   pObj = (wxObject*)pNode->Data();
+        return(pObj);
+    }
+    else
+        return NULL;
+} // end of wxWindow::GetChild

 
 #endif // WXWIN_COMPATIBILITY
 
 
 #endif // WXWIN_COMPATIBILITY
 

+//

 // Setup background and foreground colours correctly
 // Setup background and foreground colours correctly

+//

 void wxWindow::SetupColours()
 {
     if ( GetParent() )
         SetBackgroundColour(GetParent()->GetBackgroundColour());
 void wxWindow::SetupColours()
 {
     if ( GetParent() )
         SetBackgroundColour(GetParent()->GetBackgroundColour());

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

 
 

-void wxWindow::OnIdle(wxIdleEvent& event)
+void wxWindow::OnIdle(
+  wxIdleEvent&                      rEvent
+)

 {
 {

-    // TODO:
-}
+    //
+    // Check if we need to send a LEAVE event
+    //
+    if (m_bMouseInWindow)
+    {
+        POINTL                      vPoint;
+
+        ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
+        if (::WinWindowFromPoint(HWND_DESKTOP, &vPoint, FALSE) != (HWND)GetHwnd())
+        {
+            //
+            // Generate a LEAVE event
+            //
+            m_bMouseInWindow = FALSE;
+
+            //
+            // Unfortunately the mouse button and keyboard state may have changed
+            // by the time the OnIdle function is called, so 'state' may be
+            // meaningless.
+            //
+            int                     nState = 0;
+
+            if (::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) != 0)
+                nState |= VK_SHIFT;
+            if (::WinGetKeyState(HWND_DESKTOP, VK_CTRL) != 0;
+                nState |= VK_CTRL;
+
+            wxMouseEvent            rEvent(wxEVT_LEAVE_WINDOW);
+
+            InitMouseEvent( rEvent
+                           ,vPoint.x
+                           ,vPoint.y
+                           ,nState
+                          );
+            (void)GetEventHandler()->ProcessEvent(event);
+        }
+    }
+    UpdateWindowUI();
+} // end of wxWindow::OnIdle

 
 

+//

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

-bool wxWindow::Reparent(wxWindow *parent)
+//
+bool wxWindow::Reparent(
+  wxWindow*                         pParent
+)

 {
 {

-    if ( !wxWindowBase::Reparent(parent) )
+    if (!wxWindowBase::Reparent(pParent))

         return FALSE;
         return FALSE;

-   // TODO:
-    return FALSE;
-}
+
+    HWND                            hWndChild = GetHwnd();
+    HWND                            hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
+
+    ::WinSetParent(hWndChild, hWndParent, TRUE);
+    return TRUE;
+} // end of wxWindow::Reparent

 
 void wxWindow::Clear()
 {
 
 void wxWindow::Clear()
 {

-    // TODO:
-}
+    wxClientDC                      vDc(this);
+    wxBrush                         vBrush( GetBackgroundColour()
+                                           ,wxSOLID
+                                          );
+
+    vDc.SetBackground(vBrush);
+    vDc.Clear();
+} // end of wxWindow::Clear

 
 

-void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
+void wxWindow::Refresh(
+  bool                              bEraseBack
+, const wxRect*                     pRect
+)

 {
 {

-    // TODO:
-}
+    HWND                            hWnd = GetHwnd();
+
+    if (hWnd)
+    {
+        if (pRect)
+        {
+            RECTL                   vOs2Rect;
+
+            vOs2Rect.xLeft   = pRect->x;
+            vOS2Rect.yTop    = pRect->y;
+            vOs2Rect.xRight  = pRect->x + pRect->width;
+            vOs2Rect.yBottom = pRect->y + pRect->height;
+
+            ::WinInvalidateRect(hWnd, &vOs2Rect, bEraseBack);
+        }
+        else
+            ::WinInvalidateRect(hWnd, NULL, bEraseBack);
+    }
+} // end of wxWindow::Refresh

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

-void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
+void wxWindow::SetDropTarget(
+  wxDropTarget*                     pDropTarget
+)

 {
 {

-    // TODO:
-}
+    if (m_dropTarget != 0) 
+    {
+        m_dropTarget->Revoke(m_hWnd);
+        delete m_dropTarget;
+    }
+    m_dropTarget = pDropTarget;
+    if (m_dropTarget != 0)
+        m_dropTarget->Register(m_hWnd);
+} // end of wxWindow::SetDropTarget

 #endif
 
 #endif
 

+//

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

-void wxWindow::DragAcceptFiles(bool accept)
+//
+void wxWindow::DragAcceptFiles(
+  bool                              bAccept
+)

 {
 {

-    // TODO:
-}
+    HWND                            hWnd = GetHwnd();
+
+    if (hWnd && bAccept)
+        ::DragAcceptDroppedFiles(hWnd, NULL, NULL, DO_COPY, 0L);
+} // end of wxWindow::DragAcceptFiles

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


@@ -661,13 +962,15 @@ void wxWindow::DragAcceptFiles(bool accept)
 
 #if wxUSE_TOOLTIPS
 
 
 #if wxUSE_TOOLTIPS
 

-void wxWindow::DoSetToolTip(wxToolTip *tooltip)
+void wxWindow::DoSetToolTip(
+  wxToolTip*                        pTooltip
+)

 {
 {

-    wxWindowBase::DoSetToolTip(tooltip);
+    wxWindowBase::DoSetToolTip(pTooltip);

 
 

-    if ( m_tooltip )
+    if (m_pTooltip)

         m_tooltip->SetWindow(this);
         m_tooltip->SetWindow(this);

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

 
 #endif // wxUSE_TOOLTIPS
 
 
 #endif // wxUSE_TOOLTIPS
 


@@ -678,36 +981,112 @@ void wxWindow::DoSetToolTip(wxToolTip *tooltip)
 // Get total size
 void wxWindow::DoGetSize( int *width, int *height ) const
 {
 // Get total size
 void wxWindow::DoGetSize( int *width, int *height ) const
 {

-    // TODO:
+    HWND hWnd = GetHwnd();
+    RECT rect;
+    GetWindowRect(hWnd, &rect);
+
+    if ( x )
+        *x = rect.right - rect.left;
+    if ( y )
+        *y = rect.bottom - rect.top;

 }
 
 void wxWindow::DoGetPosition( int *x, int *y ) const
 {
 }
 
 void wxWindow::DoGetPosition( int *x, int *y ) const
 {

-    // TODO:
+    HWND hWnd = GetHwnd();
+
+    RECT rect;
+    GetWindowRect(hWnd, &rect);
+
+    POINT point;
+    point.x = rect.left;
+    point.y = rect.top;
+
+    // we do the adjustments with respect to the parent only for the "real"
+    // children, not for the dialogs/frames
+    if ( !IsTopLevel() )
+    {
+        HWND hParentWnd = 0;
+        wxWindow *parent = GetParent();
+        if ( parent )
+            hParentWnd = GetWinHwnd(parent);
+
+        // Since we now have the absolute screen coords, if there's a parent we
+        // must subtract its top left corner
+        if ( hParentWnd )
+        {
+            ::ScreenToClient(hParentWnd, &point);
+        }
+
+        // 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 pt(parent->GetClientAreaOrigin());
+        point.x -= pt.x;
+        point.y -= pt.y;
+    }
+
+    if ( x )
+        *x = point.x;
+    if ( y )
+        *y = point.y;

 }
 
 void wxWindow::DoScreenToClient( int *x, int *y ) const
 {
 }
 
 void wxWindow::DoScreenToClient( int *x, int *y ) const
 {

-    // TODO:
+    POINT pt;
+    if ( x )
+        pt.x = *x;
+    if ( y )
+        pt.y = *y;
+
+    HWND hWnd = GetHwnd();
+    ::ScreenToClient(hWnd, &pt);
+
+    if ( x )
+        *x = pt.x;
+    if ( y )
+        *y = pt.y;

 }
 
 void wxWindow::DoClientToScreen( int *x, int *y ) const
 {
 }
 
 void wxWindow::DoClientToScreen( int *x, int *y ) const
 {

-    // TODO:
+    POINT pt;
+    if ( x )
+        pt.x = *x;
+    if ( y )
+        pt.y = *y;
+
+    HWND hWnd = GetHwnd();
+    ::ClientToScreen(hWnd, &pt);
+
+    if ( x )
+        *x = pt.x;
+    if ( y )
+        *y = pt.y;

 }
 
 // Get size *available for subwindows* i.e. excluding menu bar etc.
 void wxWindow::DoGetClientSize( int *width, int *height ) const
 {
 }
 
 // Get size *available for subwindows* i.e. excluding menu bar etc.
 void wxWindow::DoGetClientSize( int *width, int *height ) const
 {

-    // TODO:
+    HWND hWnd = GetHwnd();
+    RECT rect;
+    ::GetClientRect(hWnd, &rect);
+    if ( x )
+        *x = rect.right;
+    if ( y )
+        *y = rect.bottom;

 }
 
 void wxWindow::DoMoveWindow(int x, int y, int width, int height)
 {
 }
 
 void wxWindow::DoMoveWindow(int x, int y, int width, int height)
 {

-   // TODO:
+    if ( !::MoveWindow(GetHwnd(), x, y, width, height, TRUE) )
+    {
+        wxLogLastError("MoveWindow");
+    }

 }
 
 }
 

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

 // but if any of them is equal to -1, it means that we must find the value for
 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
 // which case -1 is a valid value for x and y)
 // but if any of them is equal to -1, it means that we must find the value for
 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
 // which case -1 is a valid value for x and y)


@@ -715,22 +1094,104 @@ void wxWindow::DoMoveWindow(int x, int y, int width, int height)
 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
 // the width/height to best suit our contents, otherwise we reuse the current
 // width/height
 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
 // the width/height to best suit our contents, otherwise we reuse the current
 // width/height

+//

 void wxWindow::DoSetSize(int x, int y,
                          int width, int height,
                          int sizeFlags)
 {
 void wxWindow::DoSetSize(int x, int y,
                          int width, int height,
                          int sizeFlags)
 {

-    // TODO:
-}
+    // get the current size and position...
+    int currentX, currentY;
+    GetPosition(&currentX, &currentY);
+    int currentW,currentH;
+    GetSize(&currentW, &currentH);

 
 

-// for a generic window there is no natural best size - just use the current one
-wxSize wxWindow::DoGetBestSize()
-{
-    return GetSize();
+    // ... and don't do anything (avoiding flicker) if it's already ok
+    if ( x == currentX && y == currentY &&
+         width == currentW && height == currentH )
+    {
+        return;
+    }
+
+    if ( x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
+        x = currentX;
+    if ( y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
+        y = currentY;
+
+    AdjustForParentClientOrigin(x, y, sizeFlags);
+
+    wxSize size(-1, -1);
+    if ( width == -1 )
+    {
+        if ( sizeFlags & wxSIZE_AUTO_WIDTH )
+        {
+            size = DoGetBestSize();
+            width = size.x;
+        }
+        else
+        {
+            // just take the current one
+            width = currentW;
+        }
+    }
+
+    if ( height == -1 )
+    {
+        if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
+        {
+            if ( size.x == -1 )
+            {
+                size = DoGetBestSize();
+            }
+            //else: already called DoGetBestSize() above
+
+            height = size.y;
+        }
+        else
+        {
+            // just take the current one
+            height = currentH;
+        }
+    }
+
+    DoMoveWindow(x, y, width, height);

 }
 
 void wxWindow::DoSetClientSize(int width, int height)
 {
 }
 
 void wxWindow::DoSetClientSize(int width, int height)
 {

-    // TODO:
+    wxWindow *parent = GetParent();
+    HWND hWnd = GetHwnd();
+    HWND hParentWnd = (HWND) 0;
+    if ( parent )
+        hParentWnd = (HWND) parent->GetHWND();
+
+    RECT rect;
+    ::GetClientRect(hWnd, &rect);
+
+    RECT rect2;
+    GetWindowRect(hWnd, &rect2);
+
+    // 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
+    int actual_width = rect2.right - rect2.left - rect.right + width;
+    int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
+
+    // If there's a parent, must subtract the parent's top left corner
+    // since MoveWindow moves relative to the parent
+
+    POINT point;
+    point.x = rect2.left;
+    point.y = rect2.top;
+    if ( parent )
+    {
+        ::ScreenToClient(hParentWnd, &point);
+    }
+
+    DoMoveWindow(point.x, point.y, actual_width, actual_height);
+
+    wxSizeEvent event(wxSize(width, height), m_windowId);
+    event.SetEventObject(this);
+    GetEventHandler()->ProcessEvent(event);

 }
 
 wxPoint wxWindow::GetClientAreaOrigin() const
 }
 
 wxPoint wxWindow::GetClientAreaOrigin() const


@@ -740,7 +1201,17 @@ wxPoint wxWindow::GetClientAreaOrigin() const
 
 void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
 {
 
 void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
 {

-    // TODO:
+    // don't do it for the dialogs/frames - they float independently of their
+    // parent
+    if ( !IsTopLevel() )
+    {
+        wxWindow *parent = GetParent();
+        if ( !(sizeFlags & wxSIZE_NO_ADJUSTMENTS) && parent )
+        {
+            wxPoint pt(parent->GetClientAreaOrigin());
+            x += pt.x; y += pt.y;
+        }
+    }

 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------


@@ -821,7 +1292,7 @@ bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
 // pre/post message processing
 // ===========================================================================
 
 // pre/post message processing
 // ===========================================================================
 

-MRESULT wxWindow::OS2DefWindowProc(HWND hwnd, WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+MRESULT wxWindow::OS2DefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)

 {
    // TODO:
    return (MRESULT)0;
 {
    // TODO:
    return (MRESULT)0;


@@ -891,7 +1362,7 @@ void wxWindow::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
 wxWindow *wxWndHook = NULL;
 
 // Main window proc
 wxWindow *wxWndHook = NULL;
 
 // Main window proc

-MRESULT wxWndProc(HWND hWnd, UINT message, MPARAM wParam, MPARAM lParam)
+MRESULT wxWndProc(HWND hWnd, ULONG message, MPARAM wParam, MPARAM lParam)

 {
     // trace all messages - useful for the debugging
 #ifdef __WXDEBUG__
 {
     // trace all messages - useful for the debugging
 #ifdef __WXDEBUG__


@@ -924,13 +1395,13 @@ MRESULT wxWndProc(HWND hWnd, UINT message, MPARAM wParam, MPARAM lParam)
     {
         // FIXME: why do we do this?
         wnd->SetHWND((WXHWND) hWnd);
     {
         // FIXME: why do we do this?
         wnd->SetHWND((WXHWND) hWnd);

-        rc = wnd->OS2DefWindowProc(hWnd, message, wParam, lParam );
+        rc = wnd->OS2DefWindowProc(message, wParam, lParam );

         wnd->SetHWND(0);
     }
     else
     {
         if ( wnd )
         wnd->SetHWND(0);
     }
     else
     {
         if ( wnd )

-            rc = wnd->OS2WindowProc(hWnd, message, wParam, lParam);
+            rc = wnd->OS2WindowProc(message, wParam, lParam);

         else
             rc = 0; //TODO: DefWindowProc( hWnd, message, wParam, lParam );
     }
         else
             rc = 0; //TODO: DefWindowProc( hWnd, message, wParam, lParam );
     }


@@ -938,7 +1409,7 @@ MRESULT wxWndProc(HWND hWnd, UINT message, MPARAM wParam, MPARAM lParam)
     return rc;
 }
 
     return rc;
 }
 

-MRESULT wxWindow::OS2WindowProc(HWND hWnd, WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
+MRESULT wxWindow::OS2WindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)

 {
     // did we process the message?
     bool processed = FALSE;
 {
     // did we process the message?
     bool processed = FALSE;