[wxWidgets.git] / include / wx / os2 / window.h

/////////////////////////////////////////////////////////////////////////////
// Name:        window.h
// Purpose:     wxWindow class
// Author:      David Webster
// Modified by:
// Created:     10/12/99
// RCS-ID:      $Id$
// Copyright:   (c) David Webster
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef _WX_WINDOW_H_
#define _WX_WINDOW_H_

#define wxUSE_MOUSEEVENT_HACK 0

// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------
#define INCL_DOS
#define INCL_PM
#define INCL_GPI
#include <os2.h>


// ---------------------------------------------------------------------------
// forward declarations
// ---------------------------------------------------------------------------

class WXDLLEXPORT wxButton;

// ---------------------------------------------------------------------------
// constants
// ---------------------------------------------------------------------------

// FIXME does anybody use those? they're unused by wxWindows...
enum
{
    wxKEY_SHIFT = 1,
    wxKEY_CTRL  = 2
};

// ---------------------------------------------------------------------------
// wxWindow declaration for OS/2 PM
// ---------------------------------------------------------------------------

class WXDLLEXPORT wxWindow : public wxWindowBase
{
public:
    wxWindow()
    {
        Init();
    }

    wxWindow( 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
              );
    }

    virtual ~wxWindow();

    bool Create( wxWindow*       pParent
                ,wxWindowID      vId
                ,const wxPoint&  rPos = wxDefaultPosition
                ,const wxSize&   rSize = wxDefaultSize
                ,long            lStyle = 0
                ,const wxString& rName = wxPanelNameStr
               );

    // implement base class pure virtuals
    virtual void     SetTitle(const wxString& rTitle);
    virtual wxString GetTitle(void) const;
    virtual void     Raise(void);
    virtual void     Lower(void);
    virtual bool     Show(bool bShow = TRUE);
    virtual bool     Enable(bool bEnable = TRUE);
    virtual void     SetFocus(void);
    virtual bool     Reparent(wxWindow* pNewParent);
    virtual void     WarpPointer( int x
                                 ,int y
                                );
    virtual void     CaptureMouse(void);
    virtual void     ReleaseMouse(void);
    virtual void     Refresh( bool          bEraseBackground = TRUE
                             ,const wxRect* pRect = (const wxRect *)NULL
                            );
    virtual void     Clear(void);
    virtual bool     SetCursor(const wxCursor& rCursor);
    virtual bool     SetFont(const wxFont& rFont);
    virtual int      GetCharHeight(void) const;
    virtual int      GetCharWidth(void) const;
    virtual void     GetTextExtent( const wxString& rString
                                   ,int*            pX
                                   ,int*            pY
                                   ,int*            pDescent = (int *)NULL
                                   ,int*            pExternalLeading = (int *)NULL
                                   ,const wxFont*   pTheFont = (const wxFont *)NULL
                                  ) const;
    virtual bool     DoPopupMenu( wxMenu* pMenu
                                 ,int     nX
                                 ,int     nY
                                );

    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 = (wxRect *)NULL
                                 );

#if wxUSE_DRAG_AND_DROP
    virtual void SetDropTarget(wxDropTarget* pDropTarget);
#endif // wxUSE_DRAG_AND_DROP

    // Accept files for dragging
    virtual void DragAcceptFiles(bool bAccept);

#if WXWIN_COMPATIBILITY
    // Set/get scroll attributes
    virtual void SetScrollRange( int  nOrient
                                ,int  nRange
                                ,bool bRefresh = TRUE
                               );
    virtual void SetScrollPage( int  nOrient
                               ,int  nPage
                               ,bool bRefresh = TRUE
                              );
    virtual int  OldGetScrollRange(int nOrient) const;
    virtual int  GetScrollPage(int nOrient) const;

    //
    // event handlers
    //
        // Handle a control command
    virtual void OnCommand( wxWindow&       rWin
                           ,wxCommandEvent& rEvent
                          );

        // Override to define new behaviour for default action (e.g. double
        // clicking on a listbox)
    virtual void OnDefaultAction(wxControl* WXUNUSED(pInitiatingItem)) { }
#endif // WXWIN_COMPATIBILITY

#if wxUSE_CARET && WXWIN_COMPATIBILITY
    void CreateCaret( int nWidth
                     ,int nHeight
                    );
    void CreateCaret(const wxBitmap* pBitmap);
    void DestroyCaret(void);
    void ShowCaret(bool bShow);
    void SetCaretPos( int nX
                     ,int nY
                    );
    void GetCaretPos( int* pX
                     ,int* pY
                    ) const;
#endif // wxUSE_CARET

    // 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);

    // 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             SetTransparent(bool bT = TRUE) { m_bBackgroundTransparent = bT; }

    // event handlers
    // --------------
    void OnSetFocus(wxFocusEvent& rEvent);
    void OnEraseBackground(wxEraseEvent& rEvent);
    void OnIdle(wxIdleEvent& rEvent);

public:
    // For implementation purposes - sometimes decorations make the client area
    // smaller
    virtual wxPoint GetClientAreaOrigin(void) const;

    // Makes an adjustment to the window position (for example, a frame that has
    // a toolbar that it manages itself).
    virtual void AdjustForParentClientOrigin( int& rX
                                             ,int& rY
                                             ,int  nSizeFlags
                                            );

    // Windows subclassing
    void SubclassWin(WXHWND hWnd);
    void UnsubclassWin(void);

    WXFARPROC OS2GetOldWndProc(void) const { return m_fnOldWndProc; }
    void OS2SetOldWndProc(WXFARPROC fnProc) { m_fnOldWndProc = fnProc; }

    wxWindow* FindItem(long lId) const;
    wxWindow* FindItemByHWND( WXHWND hWnd
                             ,bool   bControlOnly = FALSE
                            ) const;

    // Make a Windows extended style from the given wxWindows window style ?? applicable to OS/2??
    static WXDWORD MakeExtendedStyle( long lStyle
                                     ,bool bEliminateBorders = TRUE
                                    );
    // Determine whether 3D effects are wanted
    WXDWORD Determine3DEffects( WXDWORD dwDefaultBorderStyle
                               ,bool*   pbWant3D
                              ) const;

    // PM only: TRUE if this control is part of the main control
    virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return FALSE; };

    // returns TRUE if the window has been created
    bool OS2Create( WXHWND        hParent
                   ,PSZ           zClass
                   ,const wxChar* zTitle
                   ,WXDWORD       dwStyle
                   ,long          lX
                   ,long          lY
                   ,long          lWidth
                   ,long          lHeight
                   ,WXHWND        hOwner
                   ,WXHWND        hZOrder
                   ,unsigned long lId
                   ,void*         pCtlData = NULL
                   ,void*         pPresParams = NULL
                  );
    virtual bool OS2Command( WXUINT uParam
                            ,WXWORD nId
                           );

#if WXWIN_COMPATIBILITY
    wxObject*    GetChild(int nNumber) const;
    virtual void OS2DeviceToLogical( float* pfX
                                    ,float* pfY
                                   ) const;
#endif // WXWIN_COMPATIBILITY

    // 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);

    // 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 bool OS2OnMeasureItem( int                  nId
                                  ,WXMEASUREITEMSTRUCT* pItem
                                 );

    // 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 HandleWindowParams( PWNDPARAMS pParams
                            ,WXLPARAM   lParam
                           );
    bool HandlePaletteChanged();
    bool HandlePresParamChanged(WXWPARAM wParam);
    bool HandleSysColorChange(void);
    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( WXWORD   wParam
                    ,WXLPARAM lParam
                    ,bool     bIsASCII = FALSE
                   );
    bool HandleKeyDown( WXWORD   wParam
                       ,WXLPARAM lParam
                      );
    bool HandleKeyUp( WXWORD   wParam
                     ,WXLPARAM lParam
                    );
    bool HandleQueryDragIcon(WXHICON* phIcon);
    bool HandleSetCursor( USHORT vId
                         ,WXHWND hWnd
                        );

    // 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    OS2TranslateMessage(WXMSG* pMsg);
    virtual void    OS2DestroyWindow(void);

    // Detach "Window" menu from menu bar so it doesn't get deleted
    void OS2DetachWindowMenu(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
                               );

#if WXWIN_COMPATIBILITY
    void SetShowing(bool bShow) { (void)Show(show); }
    bool IsUserEnabled(void) const { return IsEnabled(); }
#endif // WXWIN_COMPATIBILITY

    // 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
                       );

protected:
    // 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 (MSW specific) flags
    bool                            m_bUseCtl3D:1; // Using CTL3D for this control
    bool                            m_bBackgroundTransparent:1;
    bool                            m_bMouseInWindow:1;
    bool                            m_bDoubleClickAllowed:1;
    bool                            m_bWinCaptured:1;

    // 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 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
                                );

    // 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
                             );

#if wxUSE_TOOLTIPS
    virtual void DoSetToolTip(wxToolTip* pTip);
#endif // wxUSE_TOOLTIPS

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 id, WXLPARAM lp) const;

    DECLARE_DYNAMIC_CLASS(wxWindow);
    DECLARE_NO_COPY_CLASS(wxWindow);
    DECLARE_EVENT_TABLE()
private:
    // Virtual function hiding supression
    inline virtual bool Reparent(wxWindowBase* pNewParent)
    { return(wxWindowBase::Reparent(pNewParent));};
}; // end of wxWindow

// ---------------------------------------------------------------------------
// global functions
// ---------------------------------------------------------------------------

// kbd code translation
WXDLLEXPORT int wxCharCodeOS2ToWX(int nKeySym);
WXDLLEXPORT int wxCharCodeWXToOS2( int   nId
                                  ,bool* pbIsVirtual
                                 );
#endif
    // _WX_WINDOW_H_
Commit	Line	Data
0e320a79 DW	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: window.h
	3	// Purpose: wxWindow class
54da4255	4	// Author: David Webster
0e320a79	5	// Modified by:
cdf1e714	6	// Created: 10/12/99
0e320a79	7	// RCS-ID: $Id$
cdf1e714 DW	8	// Copyright: (c) David Webster
cdf1e714 DW	9	// Licence: wxWindows licence
0e320a79 DW	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifndef _WX_WINDOW_H_
	13	#define _WX_WINDOW_H_
	14
cdf1e714	15	#define wxUSE_MOUSEEVENT_HACK 0
0e320a79	16
cdf1e714 DW	17	// ---------------------------------------------------------------------------
	18	// headers
	19	// ---------------------------------------------------------------------------
63415778 DW	20	#define INCL_DOS
	21	#define INCL_PM
	22	#define INCL_GPI
	23	#include <os2.h>
	24
0e320a79 DW	25
	26	// ---------------------------------------------------------------------------
	27	// forward declarations
	28	// ---------------------------------------------------------------------------
	29
	30	class WXDLLEXPORT wxButton;
	31
cdf1e714 DW	32	// ---------------------------------------------------------------------------
	33	// constants
	34	// ---------------------------------------------------------------------------
0e320a79	35
cdf1e714 DW	36	// FIXME does anybody use those? they're unused by wxWindows...
	37	enum
	38	{
	39	wxKEY_SHIFT = 1,
	40	wxKEY_CTRL = 2
	41	};
54da4255	42
cdf1e714 DW	43	// ---------------------------------------------------------------------------
	44	// wxWindow declaration for OS/2 PM
	45	// ---------------------------------------------------------------------------
54da4255	46
cdf1e714	47	class WXDLLEXPORT wxWindow : public wxWindowBase
0e320a79	48	{
0e320a79	49	public:
3e282d33 DW	50	wxWindow()
	51	{
	52	Init();
	53	}
cdf1e714	54
776d87d5 DW	55	wxWindow( wxWindow* pParent
	56	,wxWindowID vId
	57	,const wxPoint& rPos = wxDefaultPosition
	58	,const wxSize& rSize = wxDefaultSize
	59	,long lStyle = 0
	60	,const wxString& rName = wxPanelNameStr
	61	)
0e320a79 DW	62	{
0e320a79 DW	63	Init();
776d87d5 DW	64	Create( pParent
	65	,vId
	66	,rPos
	67	,rSize
	68	,lStyle
	69	,rName
	70	);
0e320a79 DW	71	}
	72
	73	virtual ~wxWindow();
	74
776d87d5 DW	75	bool Create( wxWindow* pParent
	76	,wxWindowID vId
	77	,const wxPoint& rPos = wxDefaultPosition
	78	,const wxSize& rSize = wxDefaultSize
	79	,long lStyle = 0
	80	,const wxString& rName = wxPanelNameStr
	81	);
0e320a79	82
cdf1e714	83	// implement base class pure virtuals
776d87d5 DW	84	virtual void SetTitle(const wxString& rTitle);
	85	virtual wxString GetTitle(void) const;
	86	virtual void Raise(void);
	87	virtual void Lower(void);
	88	virtual bool Show(bool bShow = TRUE);
	89	virtual bool Enable(bool bEnable = TRUE);
	90	virtual void SetFocus(void);
	91	virtual bool Reparent(wxWindow* pNewParent);
	92	virtual void WarpPointer( int x
	93	,int y
	94	);
	95	virtual void CaptureMouse(void);
	96	virtual void ReleaseMouse(void);
	97	virtual void Refresh( bool bEraseBackground = TRUE
	98	,const wxRect* pRect = (const wxRect *)NULL
	99	);
	100	virtual void Clear(void);
	101	virtual bool SetCursor(const wxCursor& rCursor);
	102	virtual bool SetFont(const wxFont& rFont);
	103	virtual int GetCharHeight(void) const;
	104	virtual int GetCharWidth(void) const;
	105	virtual void GetTextExtent( const wxString& rString
	106	,int* pX
	107	,int* pY
	108	,int* pDescent = (int *)NULL
	109	,int* pExternalLeading = (int *)NULL
	110	,const wxFont* pTheFont = (const wxFont *)NULL
	111	) const;
	112	virtual bool DoPopupMenu( wxMenu* pMenu
	113	,int nX
	114	,int nY
	115	);
	116
	117	virtual void SetScrollbar( int nOrient
	118	,int nPos
	119	,int nThumbVisible
	120	,int nRange
	121	,bool bRefresh = TRUE
	122	);
	123	virtual void SetScrollPos( int nOrient
	124	,int nPos
	125	,bool bRefresh = TRUE
	126	);
	127	virtual int GetScrollPos(int nOrient) const;
	128	virtual int GetScrollThumb(int nOrient) const;
	129	virtual int GetScrollRange(int nOrient) const;
	130	virtual void ScrollWindow( int nDx
	131	,int nDy
	132	,const wxRect* pRect = (wxRect *)NULL
	133	);
0e320a79	134
cdf1e714	135	#if wxUSE_DRAG_AND_DROP
776d87d5	136	virtual void SetDropTarget(wxDropTarget* pDropTarget);
cdf1e714	137	#endif // wxUSE_DRAG_AND_DROP
0e320a79 DW	138
0e320a79 DW	139	// Accept files for dragging
776d87d5	140	virtual void DragAcceptFiles(bool bAccept);
0e320a79	141
cdf1e714 DW	142	#if WXWIN_COMPATIBILITY
cdf1e714 DW	143	// Set/get scroll attributes
776d87d5 DW	144	virtual void SetScrollRange( int nOrient
	145	,int nRange
	146	,bool bRefresh = TRUE
	147	);
	148	virtual void SetScrollPage( int nOrient
	149	,int nPage
	150	,bool bRefresh = TRUE
	151	);
	152	virtual int OldGetScrollRange(int nOrient) const;
	153	virtual int GetScrollPage(int nOrient) const;
	154
	155	//
cdf1e714	156	// event handlers
776d87d5	157	//
cdf1e714	158	// Handle a control command
776d87d5 DW	159	virtual void OnCommand( wxWindow& rWin
	160	,wxCommandEvent& rEvent
	161	);
0e320a79	162
cdf1e714 DW	163	// Override to define new behaviour for default action (e.g. double
cdf1e714 DW	164	// clicking on a listbox)
776d87d5	165	virtual void OnDefaultAction(wxControl* WXUNUSED(pInitiatingItem)) { }
cdf1e714	166	#endif // WXWIN_COMPATIBILITY
0e320a79	167
cdf1e714	168	#if wxUSE_CARET && WXWIN_COMPATIBILITY
776d87d5 DW	169	void CreateCaret( int nWidth
	170	,int nHeight
	171	);
	172	void CreateCaret(const wxBitmap* pBitmap);
	173	void DestroyCaret(void);
	174	void ShowCaret(bool bShow);
	175	void SetCaretPos( int nX
	176	,int nY
	177	);
	178	void GetCaretPos( int* pX
	179	,int* pY
	180	) const;
cdf1e714 DW	181	#endif // wxUSE_CARET
cdf1e714 DW	182
776d87d5	183	// Native resource loading (implemented in src/os2/nativdlg.cpp)
cdf1e714	184	// FIXME: should they really be all virtual?
776d87d5 DW	185	virtual bool LoadNativeDialog( wxWindow* pParent
	186	,wxWindowID& vId
	187	);
	188	virtual bool LoadNativeDialog( wxWindow* pParent
	189	,const wxString& rName
	190	);
	191	wxWindow* GetWindowChild1(wxWindowID vId);
	192	wxWindow* GetWindowChild(wxWindowID vId);
cdf1e714 DW	193
	194	// implementation from now on
	195	// --------------------------
	196
	197	// simple accessors
	198	// ----------------
86de7616	199
776d87d5 DW	200	WXHWND GetHWND(void) const { return m_hWnd; }
	201	void SetHWND(WXHWND hWnd) { m_hWnd = hWnd; }
	202	virtual WXWidget GetHandle(void) const { return GetHWND(); }
	203	bool GetUseCtl3D(void) const { return m_bUseCtl3D; }
	204	bool GetTransparentBackground(void) const { return m_bBackgroundTransparent; }
	205	void SetTransparent(bool bT = TRUE) { m_bBackgroundTransparent = bT; }
54da4255	206
cdf1e714 DW	207	// event handlers
cdf1e714 DW	208	// --------------
a885d89a	209	void OnSetFocus(wxFocusEvent& rEvent);
776d87d5 DW	210	void OnEraseBackground(wxEraseEvent& rEvent);
776d87d5 DW	211	void OnIdle(wxIdleEvent& rEvent);
cdf1e714 DW	212
cdf1e714 DW	213	public:
0e320a79 DW	214	// For implementation purposes - sometimes decorations make the client area
0e320a79 DW	215	// smaller
776d87d5	216	virtual wxPoint GetClientAreaOrigin(void) const;
0e320a79 DW	217
	218	// Makes an adjustment to the window position (for example, a frame that has
	219	// a toolbar that it manages itself).
776d87d5 DW	220	virtual void AdjustForParentClientOrigin( int& rX
	221	,int& rY
	222	,int nSizeFlags
	223	);
0e320a79	224
86de7616 DW	225	// Windows subclassing
86de7616 DW	226	void SubclassWin(WXHWND hWnd);
776d87d5	227	void UnsubclassWin(void);
86de7616	228
776d87d5 DW	229	WXFARPROC OS2GetOldWndProc(void) const { return m_fnOldWndProc; }
776d87d5 DW	230	void OS2SetOldWndProc(WXFARPROC fnProc) { m_fnOldWndProc = fnProc; }
86de7616	231
776d87d5 DW	232	wxWindow* FindItem(long lId) const;
	233	wxWindow* FindItemByHWND( WXHWND hWnd
	234	,bool bControlOnly = FALSE
	235	) const;
86de7616	236
776d87d5 DW	237	// Make a Windows extended style from the given wxWindows window style ?? applicable to OS/2??
	238	static WXDWORD MakeExtendedStyle( long lStyle
	239	,bool bEliminateBorders = TRUE
	240	);
86de7616	241	// Determine whether 3D effects are wanted
776d87d5 DW	242	WXDWORD Determine3DEffects( WXDWORD dwDefaultBorderStyle
	243	,bool* pbWant3D
	244	) const;
86de7616	245
776d87d5	246	// PM only: TRUE if this control is part of the main control
86de7616 DW	247	virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return FALSE; };
86de7616 DW	248
cdf1e714	249	// returns TRUE if the window has been created
3e282d33 DW	250	bool OS2Create( WXHWND hParent
3e282d33 DW	251	,PSZ zClass
776d87d5	252	,const wxChar* zTitle
776d87d5	253	,WXDWORD dwStyle
3e282d33 DW	254	,long lX
	255	,long lY
	256	,long lWidth
	257	,long lHeight
	258	,WXHWND hOwner
	259	,WXHWND hZOrder
	260	,unsigned long lId
	261	,void* pCtlData = NULL
	262	,void* pPresParams = NULL
776d87d5 DW	263	);
	264	virtual bool OS2Command( WXUINT uParam
	265	,WXWORD nId
	266	);
cdf1e714 DW	267
cdf1e714 DW	268	#if WXWIN_COMPATIBILITY
776d87d5 DW	269	wxObject* GetChild(int nNumber) const;
	270	virtual void OS2DeviceToLogical( float* pfX
	271	,float* pfY
	272	) const;
cdf1e714 DW	273	#endif // WXWIN_COMPATIBILITY
	274
	275	// Create an appropriate wxWindow from a HWND
776d87d5 DW	276	virtual wxWindow* CreateWindowFromHWND( wxWindow* pParent
	277	,WXHWND hWnd
	278	);
cdf1e714 DW	279
cdf1e714 DW	280	// Make sure the window style reflects the HWND style (roughly)
776d87d5	281	virtual void AdoptAttributesFromHWND(void);
cdf1e714 DW	282
cdf1e714 DW	283	// Setup background and foreground colours correctly
776d87d5	284	virtual void SetupColours(void);
cdf1e714 DW	285
	286	// ------------------------------------------------------------------------
	287	// helpers for message handlers: these perform the same function as the
	288	// message crackers from <windowsx.h> - they unpack WPARAM and LPARAM into
	289	// the correct parameters
	290	// ------------------------------------------------------------------------
	291
776d87d5 DW	292	void UnpackCommand( WXWPARAM wParam
	293	,WXLPARAM lParam,
	294	WXWORD* pId
	295	,WXHWND* pHwnd
	296	,WXWORD* pCmd
	297	);
	298	void UnpackActivate( WXWPARAM wParam
	299	,WXLPARAM lParam
	300	,WXWORD* pState
776d87d5 DW	301	,WXHWND* pHwnd
	302	);
	303	void UnpackScroll( WXWPARAM wParam
	304	,WXLPARAM lParam
	305	,WXWORD* pCode
	306	,WXWORD* pPos
	307	,WXHWND* pHwnd
	308	);
776d87d5 DW	309	void UnpackMenuSelect( WXWPARAM wParam
	310	,WXLPARAM lParam
	311	,WXWORD* pTtem
	312	,WXWORD* pFlags
	313	,WXHMENU* pHmenu
	314	);
cdf1e714 DW	315
cdf1e714 DW	316	// ------------------------------------------------------------------------
776d87d5	317	// internal handlers for OS2 messages: all handlers return a boolen value:
cdf1e714 DW	318	// TRUE means that the handler processed the event and FALSE that it didn't
	319	// ------------------------------------------------------------------------
	320
776d87d5	321	// there are several cases where we have virtual functions for PM
cdf1e714 DW	322	// message processing: this is because these messages often require to be
cdf1e714 DW	323	// processed in a different manner in the derived classes. For all other
776d87d5	324	// messages, however, we do not have corresponding OS2OnXXX() function
cdf1e714	325	// and if the derived class wants to process them, it should override
776d87d5	326	// OS2WindowProc() directly.
cdf1e714 DW	327
cdf1e714 DW	328	// scroll event (both horizontal and vertical)
776d87d5 DW	329	virtual bool OS2OnScroll( int nOrientation
	330	,WXWORD nSBCode
	331	,WXWORD pos
	332	,WXHWND control
	333	);
cdf1e714	334
cdf1e714	335	// owner-drawn controls need to process these messages
776d87d5 DW	336	virtual bool OS2OnDrawItem( int nId
	337	,WXDRAWITEMSTRUCT* pItem
	338	);
	339	virtual bool OS2OnMeasureItem( int nId
	340	,WXMEASUREITEMSTRUCT* pItem
	341	);
cdf1e714 DW	342
cdf1e714 DW	343	// the rest are not virtual
776d87d5 DW	344	bool HandleCreate( WXLPCREATESTRUCT vCs
	345	,bool* pMayCreate
	346	);
cdf1e714	347	bool HandleInitDialog(WXHWND hWndFocus);
776d87d5 DW	348	bool HandleDestroy(void);
	349	bool HandlePaint(void);
	350	bool HandleEraseBkgnd(WXHDC vDC);
	351	bool HandleMinimize(void);
	352	bool HandleMaximize(void);
	353	bool HandleSize( int nX
	354	,int nY
	355	,WXUINT uFlag
	356	);
61243a51	357	bool HandleGetMinMaxInfo(PSWP pMmInfo);
776d87d5 DW	358	bool HandleShow( bool bShow
	359	,int nStatus
	360	);
	361	bool HandleActivate( int nFlag
776d87d5 DW	362	,WXHWND hActivate
	363	);
	364	bool HandleCommand( WXWORD nId
	365	,WXWORD nCmd
	366	,WXHWND hControl
	367	);
	368	bool HandleSysCommand( WXWPARAM wParam
	369	,WXLPARAM lParam
	370	);
61243a51 DW	371	bool HandleWindowParams( PWNDPARAMS pParams
	372	,WXLPARAM lParam
	373	);
	374	bool HandlePaletteChanged();
	375	bool HandlePresParamChanged(WXWPARAM wParam);
776d87d5	376	bool HandleSysColorChange(void);
61243a51	377	bool HandleCtlColor(WXHBRUSH* hBrush);
776d87d5 DW	378	bool HandleSetFocus(WXHWND hWnd);
776d87d5 DW	379	bool HandleKillFocus(WXHWND hWnd);
61243a51	380	bool HandleEndDrag(WXWPARAM wParam);
776d87d5 DW	381	bool HandleMouseEvent( WXUINT uMsg
	382	,int nX
	383	,int nY
	384	,WXUINT uFlags
	385	);
	386	bool HandleMouseMove( int nX
	387	,int nY
	388	,WXUINT uFlags
	389	);
	390	bool HandleChar( WXWORD wParam
	391	,WXLPARAM lParam
	392	,bool bIsASCII = FALSE
	393	);
	394	bool HandleKeyDown( WXWORD wParam
	395	,WXLPARAM lParam
	396	);
	397	bool HandleKeyUp( WXWORD wParam
	398	,WXLPARAM lParam
	399	);
	400	bool HandleQueryDragIcon(WXHICON* phIcon);
61243a51 DW	401	bool HandleSetCursor( USHORT vId
61243a51 DW	402	,WXHWND hWnd
776d87d5	403	);
0e320a79	404
cdf1e714	405	// Window procedure
a885d89a	406	virtual MRESULT OS2WindowProc( WXUINT uMsg
776d87d5 DW	407	,WXWPARAM wParam
	408	,WXLPARAM lParam
	409	);
0e320a79	410
cdf1e714	411	// Calls an appropriate default window procedure
a885d89a	412	virtual MRESULT OS2DefWindowProc( WXUINT uMsg
776d87d5 DW	413	,WXWPARAM wParam
	414	,WXLPARAM lParam
	415	);
	416	virtual bool OS2ProcessMessage(WXMSG* pMsg);
	417	virtual bool OS2TranslateMessage(WXMSG* pMsg);
	418	virtual void OS2DestroyWindow(void);
0e320a79	419
cdf1e714	420	// Detach "Window" menu from menu bar so it doesn't get deleted
776d87d5	421	void OS2DetachWindowMenu(void);
27476f73	422
cdf1e714 DW	423	// this function should return the brush to paint the window background
cdf1e714 DW	424	// with or 0 for the default brush
776d87d5 DW	425	virtual WXHBRUSH OnCtlColor( WXHDC hDC
	426	,WXHWND hWnd
	427	,WXUINT uCtlColor
	428	,WXUINT uMessage
	429	,WXWPARAM wParam
	430	,WXLPARAM lParam
	431	);
27476f73	432
cdf1e714	433	#if WXWIN_COMPATIBILITY
776d87d5 DW	434	void SetShowing(bool bShow) { (void)Show(show); }
776d87d5 DW	435	bool IsUserEnabled(void) const { return IsEnabled(); }
cdf1e714	436	#endif // WXWIN_COMPATIBILITY
0e320a79	437
cdf1e714	438	// Responds to colour changes: passes event on to children.
776d87d5	439	void OnSysColourChanged(wxSysColourChangedEvent& rEvent);
0e320a79	440
776d87d5 DW	441	// initialize various fields of wxMouseEvent (common part of OS2OnMouseXXX)
	442	void InitMouseEvent( wxMouseEvent& rEvent
	443	,int nX
	444	,int nY
	445	,WXUINT uFlags
	446	);
0e320a79	447
cdf1e714	448	protected:
a885d89a DW	449	// PM can't create some MSW styles natively but can perform these after
	450	// creation by sending messages
	451	typedef enum extra_flags { kFrameToolWindow = 0x0001
	452	,kVertCaption = 0x0002
	453	,kHorzCaption = 0x0004
	454	} EExtraFlags;
	455	// Some internal sizeing id's to make it easy for event handlers
	456	typedef enum size_types { kSizeNormal
	457	,kSizeMax
	458	,kSizeMin
	459	} ESizeTypes;
cdf1e714	460	// the window handle
776d87d5	461	WXHWND m_hWnd;
cdf1e714 DW	462
cdf1e714 DW	463	// the old window proc (we subclass all windows)
776d87d5	464	WXFARPROC m_fnOldWndProc;
cdf1e714 DW	465
cdf1e714 DW	466	// additional (MSW specific) flags
776d87d5 DW	467	bool m_bUseCtl3D:1; // Using CTL3D for this control
	468	bool m_bBackgroundTransparent:1;
	469	bool m_bMouseInWindow:1;
	470	bool m_bDoubleClickAllowed:1;
	471	bool m_bWinCaptured:1;
849949b1 DW	472
849949b1 DW	473	// the size of one page for scrolling
776d87d5 DW	474	int m_nXThumbSize;
776d87d5 DW	475	int m_nYThumbSize;
0e320a79	476
cdf1e714 DW	477	#if wxUSE_MOUSEEVENT_HACK
cdf1e714 DW	478	// the coordinates of the last mouse event and the type of it
776d87d5 DW	479	long m_lLastMouseX,
	480	long m_lLastMouseY;
	481	int m_nLastMouseEvent;
cdf1e714 DW	482	#endif // wxUSE_MOUSEEVENT_HACK
cdf1e714 DW	483
776d87d5	484	WXHMENU m_hMenu; // Menu, if any
0fe536e3	485	unsigned long m_ulMenubarId; // it's Id, if any
cdf1e714 DW	486
cdf1e714 DW	487	// the return value of WM_GETDLGCODE handler
776d87d5	488	long m_lDlgCode;
cdf1e714 DW	489
cdf1e714 DW	490	// implement the base class pure virtuals
776d87d5 DW	491	virtual void DoClientToScreen( int* pX
	492	,int* pY
	493	) const;
	494	virtual void DoScreenToClient( int* pX
	495	,int* pY
	496	) const;
	497	virtual void DoGetPosition( int* pX
	498	,int* pY
	499	) const;
	500	virtual void DoGetSize( int* pWidth
	501	,int* pHeight
	502	) const;
	503	virtual void DoGetClientSize( int* pWidth
	504	,int* pHeight
	505	) const;
	506	virtual void DoSetSize( int nX
	507	,int nY
	508	,int nWidth
	509	,int nHeight
	510	,int nSizeFlags = wxSIZE_AUTO
	511	);
	512	virtual void DoSetClientSize( int nWidth
	513	,int nHeight
	514	);
cdf1e714	515
cdf1e714 DW	516	// move the window to the specified location and resize it: this is called
cdf1e714 DW	517	// from both DoSetSize() and DoSetClientSize() and would usually just call
3e282d33	518	// ::WinSetWindowPos() except for composite controls which will want to arrange
cdf1e714	519	// themselves inside the given rectangle
776d87d5 DW	520	virtual void DoMoveWindow( int nX
	521	,int nY
	522	,int nWidth
	523	,int nHeight
	524	);
cdf1e714 DW	525
cdf1e714 DW	526	#if wxUSE_TOOLTIPS
776d87d5	527	virtual void DoSetToolTip(wxToolTip* pTip);
cdf1e714 DW	528	#endif // wxUSE_TOOLTIPS
cdf1e714 DW	529
0e320a79	530	private:
cdf1e714	531	// common part of all ctors
776d87d5	532	void Init(void);
0e320a79	533
cdf1e714	534	// the (non-virtual) handlers for the events
776d87d5 DW	535	bool HandleMove( int nX
	536	,int nY
	537	);
	538	bool HandleJoystickEvent( WXUINT uMsg
	539	,int pX
	540	,int pY
	541	,WXUINT uFlags
	542	);
	543
	544	bool HandleNotify( int nIdCtrl
	545	,WXLPARAM lParam
	546	,WXLPARAM* pResult
	547	);
a885d89a DW	548	// the helper functions used by HandleChar/KeyXXX methods
	549	wxKeyEvent CreateKeyEvent(wxEventType evType, int id, WXLPARAM lp) const;
	550
	551	DECLARE_DYNAMIC_CLASS(wxWindow);
cdf1e714 DW	552	DECLARE_NO_COPY_CLASS(wxWindow);
cdf1e714 DW	553	DECLARE_EVENT_TABLE()
63415778 DW	554	private:
63415778 DW	555	// Virtual function hiding supression
776d87d5 DW	556	inline virtual bool Reparent(wxWindowBase* pNewParent)
776d87d5 DW	557	{ return(wxWindowBase::Reparent(pNewParent));};
a885d89a	558	}; // end of wxWindow
0e320a79	559
cdf1e714 DW	560	// ---------------------------------------------------------------------------
	561	// global functions
	562	// ---------------------------------------------------------------------------
0e320a79	563
cdf1e714	564	// kbd code translation
776d87d5 DW	565	WXDLLEXPORT int wxCharCodeOS2ToWX(int nKeySym);
	566	WXDLLEXPORT int wxCharCodeWXToOS2( int nId
	567	,bool* pbIsVirtual
	568	);
0e320a79 DW	569	#endif
0e320a79 DW	570	// _WX_WINDOW_H_