]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/os2/window.h
Fix missing documentation for several GDI functions.
[wxWidgets.git] / include / wx / os2 / window.h
index 12d2e8d66b1c6ae24240c9c3e54c08823d4e0605..bd6193b209facda0052df92e2cdec259bbdd3141 100644 (file)
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        window.h
+// Name:        wx/os2/window.h
 // Purpose:     wxWindow class
 // Author:      David Webster
 // Modified by:
 // Purpose:     wxWindow class
 // Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     10/12/99
 // RCS-ID:      $Id$
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
-// Licence:    wxWindows licence
+// Copyright:   (c) David Webster
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_WINDOW_H_
 #define _WX_WINDOW_H_
 
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_WINDOW_H_
 #define _WX_WINDOW_H_
 
-#ifdef __GNUG__
-#pragma interface "window.h"
-#endif
+#define wxUSE_MOUSEEVENT_HACK 0
 
 
+// ---------------------------------------------------------------------------
+// headers
+// ---------------------------------------------------------------------------
 #define INCL_DOS
 #define INCL_PM
 #define INCL_DOS
 #define INCL_PM
+#define INCL_GPI
 #include <os2.h>
 
 #include <os2.h>
 
-#define wxKEY_SHIFT     1
-#define wxKEY_CTRL      2
 
 // ---------------------------------------------------------------------------
 // forward declarations
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // forward declarations
 // ---------------------------------------------------------------------------
-
-class WXDLLEXPORT wxWindow;
-class WXDLLEXPORT wxButton;
-
-#if wxUSE_DRAG_AND_DROP
-class WXDLLEXPORT wxDropTarget;
+#ifndef CW_USEDEFAULT
+#  define  CW_USEDEFAULT ((int)0x80000000)
 #endif
 
 #endif
 
-#if wxUSE_WX_RESOURCES
-class WXDLLEXPORT wxResourceTable;
-class WXDLLEXPORT wxItemResource;
-#endif
+// ---------------------------------------------------------------------------
+// forward declarations
+// ---------------------------------------------------------------------------
 
 
-WXDLLEXPORT_DATA(extern const char*) wxPanelNameStr;
+class WXDLLIMPEXP_FWD_CORE wxButton;
 
 
-WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize;
-WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition;
+// ---------------------------------------------------------------------------
+// wxWindow declaration for OS/2 PM
+// ---------------------------------------------------------------------------
 
 
-class WXDLLEXPORT wxWindow: public wxWindowBase
+class WXDLLIMPEXP_CORE wxWindowOS2 : public wxWindowBase
 {
 {
-    DECLARE_ABSTRACT_CLASS(wxWindow)
-
-    friend class wxDC;
-    friend class wxPaintDC;
-
 public:
 public:
-    wxWindow() { Init(); };
-    inline wxWindow( wxWindow*       parent
-                    ,wxWindowID      id
-                    ,const wxPoint&  pos = wxDefaultPosition
-                    ,const wxSize&   size = wxDefaultSize
-                    ,long            style = 0
-                    ,const wxString& name = wxPanelNameStr
-                   )
+    wxWindowOS2()
     {
         Init();
     {
         Init();
-        Create(parent, id, pos, size, style, name);
     }
 
     }
 
-    virtual ~wxWindow();
-
-    bool Create( wxWindow*       parent
-                ,wxWindowID      id
-                ,const wxPoint&  pos = wxDefaultPosition
-                ,const wxSize&   size = wxDefaultSize
-                ,long            style = 0
-                ,const wxString& name = wxPanelNameStr
-               );
+    wxWindowOS2( wxWindow*       pParent
+                ,wxWindowID      vId
+                ,const wxPoint&  rPos = wxDefaultPosition
+                ,const wxSize&   rSize = wxDefaultSize
+                ,long            lStyle = 0
+                ,const wxString& rName = wxPanelNameStr
+               )
+    {
+        Init();
+        Create( pParent
+               ,vId
+               ,rPos
+               ,rSize
+               ,lStyle
+               ,rName
+              );
+    }
 
 
-// ---------------------------------------------------------------------------
-// wxWindowBase pure virtual implementations
-// ---------------------------------------------------------------------------
+    virtual ~wxWindowOS2();
 
 
-    // Z order
-    virtual void Raise();
-    virtual void Lower();
-    // Set the focus to this window
-    virtual void SetFocus();
-    // Warp the pointer the given position
-    virtual void WarpPointer(int x_pos, int y_pos) ;
-    // Capture/release mouse
-    virtual void CaptureMouse();
-    virtual void ReleaseMouse();
-    // Send the window a refresh event
-    virtual void Refresh(bool eraseBack = TRUE, const wxRect *rect = NULL);
-    // Clear the window
-    virtual void Clear();
-    // Set window's font
-    virtual bool SetFont(const wxFont& f);
-    // Get character size
-    virtual int  GetCharHeight() const;
-    virtual int  GetCharWidth() const;
-    virtual void GetTextExtent( const wxString& string
-                               ,int*            x
-                               ,int*            y
-                               ,int*            descent = NULL
-                               ,int*            externalLeading = NULL
-                               ,const wxFont*   theFont = NULL
-                              ) const;
+    bool Create( wxWindow*       pParent
+                ,wxWindowID      vId
+                ,const wxPoint&  rPos = wxDefaultPosition
+                ,const wxSize&   rSize = wxDefaultSize
+                ,long            lStyle = 0
+                ,const wxString& rName = wxPanelNameStr
+               );
 
 
-    // Configure the window's scrollbar
-    virtual void SetScrollbar( int  orient
-                              ,int  pos
-                              ,int  thumbVisible
-                              ,int  range
-                              ,bool refresh = TRUE
-                             );
-    virtual void SetScrollPos( int  orient
-                              ,int  pos
-                              ,bool refresh = TRUE
-                             );
-    virtual int  GetScrollPos(int orient) const;
-    virtual int  GetScrollRange(int orient) const;
-    virtual int  GetScrollThumb(int orient) const;
-    virtual void ScrollWindow( int           dx
-                              ,int           dy
-                              ,const wxRect* rect = NULL
-                             );
+    // implement base class pure virtuals
+    virtual void     SetLabel(const wxString& label);
+    virtual wxString GetLabel(void) const;
+    virtual void     Raise(void);
+    virtual void     Lower(void);
+    virtual bool     Show(bool bShow = true);
+    virtual void     DoEnable(bool bEnable);
+    virtual void     SetFocus(void);
+    virtual void     SetFocusFromKbd(void);
+    virtual bool     Reparent(wxWindowBase* pNewParent);
+    virtual void     WarpPointer( int x
+                                 ,int y
+                                );
+    virtual void     Refresh( bool          bEraseBackground = true
+                             ,const wxRect* pRect = (const wxRect *)NULL
+                            );
+    virtual void     Update(void);
+    virtual void     SetWindowStyleFlag(long lStyle);
+    virtual bool     SetCursor(const wxCursor& rCursor);
+    virtual bool     SetFont(const wxFont& rFont);
+    virtual int      GetCharHeight(void) const;
+    virtual int      GetCharWidth(void) const;
+
+    virtual void     SetScrollbar( int  nOrient
+                                  ,int  nPos
+                                  ,int  nThumbVisible
+                                  ,int  nRange
+                                  ,bool bRefresh = true
+                                 );
+    virtual void     SetScrollPos( int  nOrient
+                                  ,int  nPos
+                                  ,bool bRefresh = true
+                                 );
+    virtual int      GetScrollPos(int nOrient) const;
+    virtual int      GetScrollThumb(int nOrient) const;
+    virtual int      GetScrollRange(int nOrient) const;
+    virtual void     ScrollWindow( int           nDx
+                                  ,int           nDy
+                                  ,const wxRect* pRect = NULL
+                                 );
+
+    inline HWND                   GetScrollBarHorz(void) const {return m_hWndScrollBarHorz;}
+    inline HWND                   GetScrollBarVert(void) const {return m_hWndScrollBarVert;}
 #if wxUSE_DRAG_AND_DROP
 #if wxUSE_DRAG_AND_DROP
-    void         SetDropTarget(wxDropTarget *pDropTarget);
-#endif
-    // coordinates translation
-    virtual void DoClientToScreen( int *x, int *y ) const;
-    virtual void DoScreenToClient( int *x, int *y ) const;
-
-    // retrieve the position/size of the window
-    virtual void DoGetPosition( int *x, int *y ) const;
-    virtual void DoGetSize( int *width, int *height ) const;
-    virtual void DoGetClientSize( int *width, int *height ) const;
-
-    // this is the virtual function to be overriden in any derived class which
-    // wants to change how SetSize() or Move() works - it is called by all
-    // versions of these functions in the base class
-    virtual void DoSetSize(int x, int y,
-                           int width, int height,
-                           int sizeFlags = wxSIZE_AUTO);
-
-    // same as DoSetSize() for the client size
-    virtual void DoSetClientSize(int width, int height);
-    virtual bool DoPopupMenu( wxMenu *menu, int x, int y );
-
-// ---------------------------------------------------------------------------
-// wxWindowBase virtual implementations that need to be overriden
-// ---------------------------------------------------------------------------
-
-    // Fit the window around the items
-    virtual void            Fit();
-    // Show or hide the window
-    virtual bool            Show(bool show); // check if base implementation is OK
-    // Enable or disable the window
-    virtual bool            Enable(bool enable); // check if base implementation is OK
-    // Set the cursor
-    virtual bool            SetCursor(const wxCursor& cursor); // check if base implementation is OK
-
-// ---------------------------------------------------------------------------
-// additional functions
-// ---------------------------------------------------------------------------
-
-    // Dialog support: override these and call
-    // base class members to add functionality
-    // that can't be done using validators.
-    void SetClientSize( int width, int height )
-        { DoSetClientSize(width, height); }
-
-    void SetClientSize( const wxSize& size )
-        { DoSetClientSize(size.x, size.y); }
-
-    void SetClientSize(const wxRect& rect)
-        { SetClientSize( rect.width, rect.height ); }
-
-    // Validate controls. If returns FALSE,
-    // validation failed: don't quit
-    virtual bool Validate();
-
-    // Return code for dialogs
-    inline void SetReturnCode(int retCode);
-    inline int GetReturnCode();
+    virtual void SetDropTarget(wxDropTarget* pDropTarget);
+#endif // wxUSE_DRAG_AND_DROP
 
 
+    // Accept files for dragging
+    virtual void DragAcceptFiles(bool bAccept);
+
+#ifndef __WXUNIVERSAL__
+    // Native resource loading (implemented in src/os2/nativdlg.cpp)
+    // FIXME: should they really be all virtual?
+    virtual bool LoadNativeDialog( wxWindow*   pParent
+                                  ,wxWindowID& vId
+                                 );
+    virtual bool LoadNativeDialog( wxWindow*       pParent
+                                  ,const wxString& rName
+                                 );
+    wxWindow*    GetWindowChild1(wxWindowID vId);
+    wxWindow*    GetWindowChild(wxWindowID vId);
+#endif //__WXUNIVERSAL__
+
+    // implementation from now on
+    // --------------------------
+
+    // simple accessors
+    // ----------------
+
+    WXHWND           GetHWND(void) const { return m_hWnd; }
+    void             SetHWND(WXHWND hWnd) { m_hWnd = hWnd; }
+    virtual WXWidget GetHandle(void) const { return GetHWND(); }
+    bool             GetUseCtl3D(void) const { return m_bUseCtl3D; }
+    bool             GetTransparentBackground(void) const { return m_bBackgroundTransparent; }
+    void             SetTransparentBackground(bool bT = true) { m_bBackgroundTransparent = bT; }
+
+    // event handlers
+    // --------------
+    void OnSetFocus(wxFocusEvent& rEvent);
+    void OnEraseBackground(wxEraseEvent& rEvent);
+    void OnIdle(wxIdleEvent& rEvent);
 
 
-    // Get the window with the focus
-    static wxWindow *FindFocus();
+public:
 
 
-    // Accept files for dragging
-    virtual void DragAcceptFiles(bool accept);
-
-    // Most windows have the concept of a label; for frames, this is the
-    // title; for items, this is the label or button text.
-    inline virtual wxString GetLabel() const { return GetTitle(); }
-
-#if wxUSE_CARET && WXWIN_COMPATIBILITY
-    // Caret manipulation
-    virtual void CreateCaret(int w, int h);
-    virtual void CreateCaret(const wxBitmap *bitmap);
-    virtual void DestroyCaret();
-    virtual void ShowCaret(bool show);
-    virtual void SetCaretPos(int x, int y);
-    virtual void GetCaretPos(int *x, int *y) const;
+    // Windows subclassing
+    void SubclassWin(WXHWND hWnd);
+    void UnsubclassWin(void);
+
+    WXFARPROC OS2GetOldWndProc(void) const { return m_fnOldWndProc; }
+    void OS2SetOldWndProc(WXFARPROC fnProc) { m_fnOldWndProc = fnProc; }
+    //
+    // Return true if the window is of a standard (i.e. not wxWidgets') class
+    //
+    bool IsOfStandardClass(void) const { return m_fnOldWndProc != NULL; }
+
+    wxWindow* FindItem(long lId) const;
+    wxWindow* FindItemByHWND( WXHWND hWnd
+                             ,bool   bControlOnly = false
+                            ) const;
+
+    // Make a Windows extended style from the given wxWidgets window style ?? applicable to OS/2??
+    static WXDWORD MakeExtendedStyle( long lStyle
+                                     ,bool bEliminateBorders = true
+                                    );
+
+    // PM only: true if this control is part of the main control
+    virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return false; }
+
+    // translate wxWidgets style flags for this control into the PM style
+    // and optional extended style for the corresponding native control
+    //
+    // this is the function that should be overridden in the derived classes,
+    // but you will mostly use OS2GetCreateWindowFlags() below
+    virtual WXDWORD OS2GetStyle( long     lFlags
+                                ,WXDWORD* pdwExstyle = NULL
+                               ) const;
+
+    // get the MSW window flags corresponding to wxWidgets ones
+    //
+    // the functions returns the flags (WS_XXX) directly and puts the ext
+    // (WS_EX_XXX) flags into the provided pointer if not NULL
+    WXDWORD OS2GetCreateWindowFlags(WXDWORD* pdwExflags = NULL) const
+        { return OS2GetStyle(GetWindowStyle(), pdwExflags); }
+
+
+    // get the HWND to be used as parent of this window with CreateWindow()
+    virtual WXHWND OS2GetParent(void) const;
+
+    // returns true if the window has been created
+    bool         OS2Create( PSZ            zClass
+                           ,const wxChar*  zTitle
+                           ,WXDWORD        dwStyle
+                           ,const wxPoint& rPos
+                           ,const wxSize&  rSize
+                           ,void*          pCtlData
+                           ,WXDWORD        dwExStyle
+                           ,bool           bIsChild
+                          );
+    virtual bool OS2Command( WXUINT uParam
+                            ,WXWORD nId
+                           );
+
+#ifndef __WXUNIVERSAL__
+    // Create an appropriate wxWindow from a HWND
+    virtual wxWindow* CreateWindowFromHWND( wxWindow* pParent
+                                           ,WXHWND    hWnd
+                                          );
+
+    // Make sure the window style reflects the HWND style (roughly)
+    virtual void AdoptAttributesFromHWND(void);
 #endif
 
 #endif
 
-    // Handle a control command
-    virtual void OnCommand(wxWindow& win, wxCommandEvent& event);
+    // Setup background and foreground colours correctly
+    virtual void SetupColours(void);
+
+    // ------------------------------------------------------------------------
+    // helpers for message handlers: these perform the same function as the
+    // message crackers from <windowsx.h> - they unpack WPARAM and LPARAM into
+    // the correct parameters
+    // ------------------------------------------------------------------------
+
+    void UnpackCommand( WXWPARAM wParam
+                       ,WXLPARAM lParam,
+                        WXWORD*  pId
+                       ,WXHWND*  pHwnd
+                       ,WXWORD*  pCmd
+                      );
+    void UnpackActivate( WXWPARAM wParam
+                        ,WXLPARAM lParam
+                        ,WXWORD*  pState
+                        ,WXHWND*  pHwnd
+                       );
+    void UnpackScroll( WXWPARAM wParam
+                      ,WXLPARAM lParam
+                      ,WXWORD*  pCode
+                      ,WXWORD*  pPos
+                      ,WXHWND*  pHwnd
+                     );
+    void UnpackMenuSelect( WXWPARAM wParam
+                          ,WXLPARAM lParam
+                          ,WXWORD*  pTtem
+                          ,WXWORD*  pFlags
+                          ,WXHMENU* pHmenu
+                         );
+
+    // ------------------------------------------------------------------------
+    // internal handlers for OS2 messages: all handlers return a boolen value:
+    // true means that the handler processed the event and false that it didn't
+    // ------------------------------------------------------------------------
+
+    // there are several cases where we have virtual functions for PM
+    // message processing: this is because these messages often require to be
+    // processed in a different manner in the derived classes. For all other
+    // messages, however, we do *not* have corresponding OS2OnXXX() function
+    // and if the derived class wants to process them, it should override
+    // OS2WindowProc() directly.
+
+    // scroll event (both horizontal and vertical)
+    virtual bool OS2OnScroll( int    nOrientation
+                             ,WXWORD nSBCode
+                             ,WXWORD pos
+                             ,WXHWND control
+                            );
+
+    // owner-drawn controls need to process these messages
+    virtual bool OS2OnDrawItem( int               nId
+                               ,WXDRAWITEMSTRUCT* pItem
+                              );
+    virtual long OS2OnMeasureItem( int                  nId
+                                  ,WXMEASUREITEMSTRUCT* pItem
+                                 );
+
+    virtual void OnPaint(wxPaintEvent& rEvent);
+
+    // the rest are not virtual
+    bool HandleCreate( WXLPCREATESTRUCT vCs
+                      ,bool*            pMayCreate
+                     );
+    bool HandleInitDialog(WXHWND hWndFocus);
+    bool HandleDestroy(void);
+    bool HandlePaint(void);
+    bool HandleEraseBkgnd(WXHDC vDC);
+    bool HandleMinimize(void);
+    bool HandleMaximize(void);
+    bool HandleSize( int    nX
+                    ,int    nY
+                    ,WXUINT uFlag
+                   );
+    bool HandleGetMinMaxInfo(PSWP pMmInfo);
+    bool HandleShow( bool bShow
+                    ,int  nStatus
+                   );
+    bool HandleActivate( int    nFlag
+                        ,WXHWND hActivate
+                       );
+    bool HandleCommand( WXWORD nId
+                       ,WXWORD nCmd
+                       ,WXHWND hControl
+                      );
+    bool HandleSysCommand( WXWPARAM wParam
+                          ,WXLPARAM lParam
+                         );
+    bool HandlePaletteChanged(void);
+    bool HandleQueryNewPalette(void);
+    bool HandleSysColorChange(void);
+    bool HandleDisplayChange(void);
+    bool HandleCaptureChanged(WXHWND hBainedCapture);
+
+    bool HandleCtlColor(WXHBRUSH* hBrush);
+    bool HandleSetFocus(WXHWND hWnd);
+    bool HandleKillFocus(WXHWND hWnd);
+    bool HandleEndDrag(WXWPARAM wParam);
+    bool HandleMouseEvent( WXUINT uMsg
+                          ,int    nX
+                          ,int    nY
+                          ,WXUINT uFlags
+                         );
+    bool HandleMouseMove( int    nX
+                         ,int    nY
+                         ,WXUINT uFlags
+                        );
+    bool HandleChar( WXWPARAM wParam
+                    ,WXLPARAM lParam
+                    ,bool     bIsASCII = false
+                   );
+    bool HandleKeyDown( WXWPARAM wParam
+                       ,WXLPARAM lParam
+                      );
+    bool HandleKeyUp( WXWPARAM wParam
+                     ,WXLPARAM lParam
+                    );
+    bool HandleQueryDragIcon(WXHICON* phIcon);
+    bool HandleSetCursor( USHORT vId
+                         ,WXHWND hWnd
+                        );
+
+    bool IsMouseInWindow(void) const;
+    bool OS2GetCreateWindowCoords( const wxPoint& rPos
+                                  ,const wxSize&  rSize
+                                  ,int&           rnX
+                                  ,int&           rnY
+                                  ,int&           rnWidth
+                                  ,int&           rnHeight
+                                 ) const;
+
+    // Window procedure
+    virtual MRESULT OS2WindowProc( WXUINT   uMsg
+                                  ,WXWPARAM wParam
+                                  ,WXLPARAM lParam
+                                 );
+
+    // Calls an appropriate default window procedure
+    virtual MRESULT OS2DefWindowProc( WXUINT   uMsg
+                                     ,WXWPARAM wParam
+                                     ,WXLPARAM lParam
+                                    );
+    virtual bool    OS2ProcessMessage(WXMSG* pMsg);
+    virtual bool    OS2ShouldPreProcessMessage(WXMSG* pMsg);
+    virtual bool    OS2TranslateMessage(WXMSG* pMsg);
+    virtual void    OS2DestroyWindow(void);
+
+    // this function should return the brush to paint the window background
+    // with or 0 for the default brush
+    virtual WXHBRUSH OnCtlColor( WXHDC    hDC
+                                ,WXHWND   hWnd
+                                ,WXUINT   uCtlColor
+                                ,WXUINT   uMessage
+                                ,WXWPARAM wParam
+                                ,WXLPARAM lParam
+                               );
+
+    // Responds to colour changes: passes event on to children.
+    void OnSysColourChanged(wxSysColourChangedEvent& rEvent);
+
+    // initialize various fields of wxMouseEvent (common part of OS2OnMouseXXX)
+    void InitMouseEvent( wxMouseEvent& rEvent
+                        ,int           nX
+                        ,int           nY
+                        ,WXUINT        uFlags
+                       );
+
+    void MoveChildren(int nDiff);
+    PSWP GetSwp(void) {return &m_vWinSwp;}
 
 
-    // Get the default button, if there is one
-    inline virtual wxButton *GetDefaultItem() const;
-    inline virtual void SetDefaultItem(wxButton *but);
+protected:
+    virtual void     DoFreeze(void);
+    virtual void     DoThaw(void);
+
+    // PM can't create some MSW styles natively but can perform these after
+    // creation by sending messages
+    typedef enum extra_flags { kFrameToolWindow = 0x0001
+                              ,kVertCaption     = 0x0002
+                              ,kHorzCaption     = 0x0004
+                             } EExtraFlags;
+    // Some internal sizeing id's to make it easy for event handlers
+    typedef enum size_types { kSizeNormal
+                             ,kSizeMax
+                             ,kSizeMin
+                            } ESizeTypes;
+    // the window handle
+    WXHWND                          m_hWnd;
+
+    // the old window proc (we subclass all windows)
+    WXFARPROC                       m_fnOldWndProc;
+
+    // additional (OS2 specific) flags
+    bool                            m_bUseCtl3D:1; // Using CTL3D for this control
+    bool                            m_bBackgroundTransparent:1;
+    bool                            m_bMouseInWindow:1;
+    bool                            m_bLastKeydownProcessed:1;
+    bool                            m_bWinCaptured:1;
+    WXDWORD                         m_dwExStyle;
 
 
-    // Override to define new behaviour for default action (e.g. double clicking
-    // on a listbox)
-    virtual void OnDefaultAction(wxControl *initiatingItem);
+    // the size of one page for scrolling
+    int                             m_nXThumbSize;
+    int                             m_nYThumbSize;
+
+#if wxUSE_MOUSEEVENT_HACK
+    // the coordinates of the last mouse event and the type of it
+    long                            m_lLastMouseX,
+    long                            m_lLastMouseY;
+    int                             m_nLastMouseEvent;
+#endif // wxUSE_MOUSEEVENT_HACK
+
+    WXHMENU                         m_hMenu; // Menu, if any
+    unsigned long                   m_ulMenubarId; // it's Id, if any
+
+    // the return value of WM_GETDLGCODE handler
+    long                            m_lDlgCode;
+
+    // implement the base class pure virtuals
+    virtual void     GetTextExtent( const wxString& rString
+                                   ,int*            pX
+                                   ,int*            pY
+                                   ,int*            pDescent = NULL
+                                   ,int*            pExternalLeading = NULL
+                                   ,const wxFont*   pTheFont = NULL
+                                  ) const;
+#if wxUSE_MENUS_NATIVE
+    virtual bool     DoPopupMenu( wxMenu* pMenu
+                                 ,int     nX
+                                 ,int     nY
+                                );
+#endif // wxUSE_MENUS_NATIVE
+    virtual void DoClientToScreen( int* pX
+                                  ,int* pY
+                                 ) const;
+    virtual void DoScreenToClient( int* pX
+                                  ,int* pY
+                                 ) const;
+    virtual void DoGetPosition( int* pX
+                               ,int* pY
+                              ) const;
+    virtual void DoGetSize( int* pWidth
+                           ,int* pHeight
+                          ) const;
+    virtual void DoGetClientSize( int* pWidth
+                                 ,int* pHeight
+                                ) const;
+    virtual void DoSetSize( int nX
+                           ,int nY
+                           ,int nWidth
+                           ,int nHeight
+                           ,int nSizeFlags = wxSIZE_AUTO
+                          );
+    virtual void DoSetClientSize( int nWidth
+                                 ,int nHeight
+                                );
+
+    virtual void     DoCaptureMouse(void);
+    virtual void     DoReleaseMouse(void);
+
+    // move the window to the specified location and resize it: this is called
+    // from both DoSetSize() and DoSetClientSize() and would usually just call
+    // ::WinSetWindowPos() except for composite controls which will want to arrange
+    // themselves inside the given rectangle
+    virtual void DoMoveWindow( int nX
+                              ,int nY
+                              ,int nWidth
+                              ,int nHeight
+                             );
 
 
-    // EventHandlers
-    void OnEraseBackground(wxEraseEvent& event);
-    void OnChar(wxKeyEvent& event);
-    void OnKeyDown(wxKeyEvent& event);
-    void OnKeyUp(wxKeyEvent& event);
-    void OnPaint(wxPaintEvent& event);
-    void OnIdle(wxIdleEvent& event);
+#if wxUSE_TOOLTIPS
+    virtual void DoSetToolTip(wxToolTip* pTip);
+#endif // wxUSE_TOOLTIPS
 
 
+    int  GetOS2ParentHeight(wxWindowOS2* pParent);
 
 
+private:
+    // common part of all ctors
+    void Init(void);
+
+    // the (non-virtual) handlers for the events
+    bool HandleMove( int nX
+                    ,int nY
+                   );
+    bool HandleJoystickEvent( WXUINT uMsg
+                             ,int    pX
+                             ,int    pY
+                             ,WXUINT uFlags
+                            );
+
+    bool HandleNotify( int       nIdCtrl
+                      ,WXLPARAM  lParam
+                      ,WXLPARAM* pResult
+                     );
+    // the helper functions used by HandleChar/KeyXXX methods
+    wxKeyEvent CreateKeyEvent( wxEventType evType
+                              ,int         nId
+                              ,WXLPARAM    lParam = 0
+                              ,WXWPARAM    wParam = 0
+                             ) const;
+
+    HWND                            m_hWndScrollBarHorz;
+    HWND                            m_hWndScrollBarVert;
+    SWP                             m_vWinSwp;
+
+    DECLARE_DYNAMIC_CLASS(wxWindowOS2);
+    wxDECLARE_NO_COPY_CLASS(wxWindowOS2);
+    DECLARE_EVENT_TABLE()
+}; // end of wxWindow
+
+class wxWindowCreationHook
+{
 public:
 public:
+    wxWindowCreationHook(wxWindow* pWinBeingCreated);
+    ~wxWindowCreationHook();
+}; // end of CLASS wxWindowCreationHook
+
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
-// IMPLEMENTATION
+// global functions
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 
-    // For implementation purposes - sometimes decorations make the client area
-    // smaller
-    virtual wxPoint GetClientAreaOrigin() const;
+// kbd code translation
+WXDLLIMPEXP_CORE int wxCharCodeOS2ToWX(int nKeySym);
+WXDLLIMPEXP_CORE int wxCharCodeWXToOS2( int   nId
+                                  ,bool* pbIsVirtual = NULL
+                                 );
 
 
-    // Makes an adjustment to the window position (for example, a frame that has
-    // a toolbar that it manages itself).
-    virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags);
+// ----------------------------------------------------------------------------
+// global objects
+// ----------------------------------------------------------------------------
 
 
-    // Executes the default message
-    virtual long Default();
+// notice that this hash must be defined after wxWindow declaration as it
+// needs to "see" its dtor and not just forward declaration
+#include "wx/hash.h"
 
 
-/* TODO: you may need something like this
-  // Determine whether 3D effects are wanted
-  virtual WXDWORD Determine3DEffects(WXDWORD defaultBorderStyle, bool *want3D);
-*/
+// pseudo-template HWND <-> wxWindow hash table
+WX_DECLARE_HASH(wxWindowOS2, wxWindowList, wxWinHashTable);
 
 
-    // Constraint implementation
-    void UnsetConstraints(wxLayoutConstraints *c);
-    // Back-pointer to other windows we're involved with, so if we delete
-    // this window, we must delete any constraints we're involved with.
+extern wxWinHashTable *wxWinHandleHash;
 
 
-    wxObject *GetChild(int number) const ;
-
-    // Transfers data to any child controls
-    void OnInitDialog(wxInitDialogEvent& event);
-
-protected:
-
-    // Caret data
-    int                   m_caretWidth;
-    int                   m_caretHeight;
-    bool                  m_caretEnabled;
-    bool                  m_caretShown;
-
-    wxButton *            m_defaultItem;
-
-public:
-    int                   m_returnCode;
-    bool                  m_isBeingDeleted;
-    bool                  m_isShown;
-    bool                  m_winCaptured;
-    bool                  m_mouseInWindow;
-    bool                  m_backgroundTransparent;
-    // handles
-    WXHWND                m_hWnd;
-    WXHMENU               m_hMenu; // Menu, if any
-
-    // the size of one page for scrolling
-    int                   m_xThumbSize;
-    int                   m_yThumbSize;
-    long                  m_lDlgCode;
-
-DECLARE_EVENT_TABLE()
-private:
-    void   Init();
-    void   PMDetachWindowMenu();
-    WXHWND GetHwnd() const { return m_hWnd; }
-    void   SetHwnd(WXHWND hWnd) { m_hWnd = hWnd; }
-};
-
-////////////////////////////////////////////////////////////////////////
-//// INLINES
-
-inline wxButton *wxWindow::GetDefaultItem() const { return m_defaultItem; }
-inline void wxWindow::SetDefaultItem(wxButton *but) { m_defaultItem = but; }
-inline void wxWindow::SetReturnCode(int retCode) { m_returnCode = retCode; }
-inline int wxWindow::GetReturnCode() { return m_returnCode; }
-
-// Get the active window.
-wxWindow* WXDLLEXPORT wxGetActiveWindow();
-
-#endif
-    // _WX_WINDOW_H_
+#endif // _WX_WINDOW_H_