[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 wxWindowOS2 : public wxWindowBase
{
public:
    wxWindowOS2()
    {
        Init();
    }

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

    virtual ~wxWindowOS2();

    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 void     Freeze(void);
    virtual void     Update(void);
    virtual void     Thaw(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;
#if wxUSE_MENUS_NATIVE
    virtual bool     DoPopupMenu( wxMenu* pMenu
                                 ,int     nX
                                 ,int     nY
                                );
#endif // wxUSE_MENUS_NATIVE

    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

#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             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;

    // 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
                   ,WXDWORD       dwExStyle = 0L
                  );
    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

#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

    // 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 HandlePaletteChanged();
    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( WXDWORD  wParam
                    ,WXLPARAM lParam
                    ,bool     bIsASCII = FALSE
                   );
    bool HandleKeyDown( WXWORD   wParam
                       ,WXLPARAM lParam
                      );
    bool HandleKeyUp( WXDWORD  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    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
                       );

    void MoveChildren(int nDiff);

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 (OS2 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;
    WXDWORD                         m_dwExStyle;

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

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

    DECLARE_DYNAMIC_CLASS(wxWindowOS2);
    DECLARE_NO_COPY_CLASS(wxWindowOS2)
    DECLARE_EVENT_TABLE()
private:
    HWND                            m_hWndScrollBarHorz;
    HWND                            m_hWndScrollBarVert;

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

class wxWindowCreationHook
{
public:
    wxWindowCreationHook(wxWindow* pWinBeingCreated);
    ~wxWindowCreationHook();
}; // end of CLASS wxWindowCreationHook

// ---------------------------------------------------------------------------
// 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
210a651b	47	class WXDLLEXPORT wxWindowOS2 : public wxWindowBase
0e320a79	48	{
0e320a79	49	public:
210a651b	50	wxWindowOS2()
3e282d33 DW	51	{
	52	Init();
	53	}
cdf1e714	54
210a651b DW	55	wxWindowOS2( 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	}
0e320a79 DW	72
210a651b	73	virtual ~wxWindowOS2();
0e320a79	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);
06519806 DW	101	virtual void Freeze(void);
	102	virtual void Update(void);
	103	virtual void Thaw(void);
776d87d5 DW	104	virtual bool SetCursor(const wxCursor& rCursor);
	105	virtual bool SetFont(const wxFont& rFont);
	106	virtual int GetCharHeight(void) const;
	107	virtual int GetCharWidth(void) const;
	108	virtual void GetTextExtent( const wxString& rString
	109	,int* pX
	110	,int* pY
	111	,int* pDescent = (int *)NULL
	112	,int* pExternalLeading = (int *)NULL
	113	,const wxFont* pTheFont = (const wxFont *)NULL
	114	) const;
19193a2c	115	#if wxUSE_MENUS_NATIVE
776d87d5 DW	116	virtual bool DoPopupMenu( wxMenu* pMenu
	117	,int nX
	118	,int nY
	119	);
19193a2c	120	#endif // wxUSE_MENUS_NATIVE
776d87d5 DW	121
	122	virtual void SetScrollbar( int nOrient
	123	,int nPos
	124	,int nThumbVisible
	125	,int nRange
	126	,bool bRefresh = TRUE
	127	);
	128	virtual void SetScrollPos( int nOrient
	129	,int nPos
	130	,bool bRefresh = TRUE
	131	);
	132	virtual int GetScrollPos(int nOrient) const;
	133	virtual int GetScrollThumb(int nOrient) const;
	134	virtual int GetScrollRange(int nOrient) const;
	135	virtual void ScrollWindow( int nDx
	136	,int nDy
	137	,const wxRect* pRect = (wxRect *)NULL
	138	);
0e320a79	139
cdf1e714	140	#if wxUSE_DRAG_AND_DROP
776d87d5	141	virtual void SetDropTarget(wxDropTarget* pDropTarget);
cdf1e714	142	#endif // wxUSE_DRAG_AND_DROP
0e320a79 DW	143
0e320a79 DW	144	// Accept files for dragging
776d87d5	145	virtual void DragAcceptFiles(bool bAccept);
0e320a79	146
cdf1e714 DW	147	#if WXWIN_COMPATIBILITY
cdf1e714 DW	148	// Set/get scroll attributes
776d87d5 DW	149	virtual void SetScrollRange( int nOrient
	150	,int nRange
	151	,bool bRefresh = TRUE
	152	);
	153	virtual void SetScrollPage( int nOrient
	154	,int nPage
	155	,bool bRefresh = TRUE
	156	);
	157	virtual int OldGetScrollRange(int nOrient) const;
	158	virtual int GetScrollPage(int nOrient) const;
	159
	160	//
cdf1e714	161	// event handlers
776d87d5	162	//
cdf1e714	163	// Handle a control command
776d87d5 DW	164	virtual void OnCommand( wxWindow& rWin
	165	,wxCommandEvent& rEvent
	166	);
0e320a79	167
cdf1e714 DW	168	// Override to define new behaviour for default action (e.g. double
cdf1e714 DW	169	// clicking on a listbox)
776d87d5	170	virtual void OnDefaultAction(wxControl* WXUNUSED(pInitiatingItem)) { }
cdf1e714	171	#endif // WXWIN_COMPATIBILITY
0e320a79	172
cdf1e714	173	#if wxUSE_CARET && WXWIN_COMPATIBILITY
776d87d5 DW	174	void CreateCaret( int nWidth
	175	,int nHeight
	176	);
	177	void CreateCaret(const wxBitmap* pBitmap);
	178	void DestroyCaret(void);
	179	void ShowCaret(bool bShow);
	180	void SetCaretPos( int nX
	181	,int nY
	182	);
	183	void GetCaretPos( int* pX
	184	,int* pY
	185	) const;
cdf1e714 DW	186	#endif // wxUSE_CARET
cdf1e714 DW	187
19193a2c	188	#ifndef __WXUNIVERSAL__
776d87d5	189	// Native resource loading (implemented in src/os2/nativdlg.cpp)
cdf1e714	190	// FIXME: should they really be all virtual?
776d87d5 DW	191	virtual bool LoadNativeDialog( wxWindow* pParent
	192	,wxWindowID& vId
	193	);
	194	virtual bool LoadNativeDialog( wxWindow* pParent
	195	,const wxString& rName
	196	);
	197	wxWindow* GetWindowChild1(wxWindowID vId);
	198	wxWindow* GetWindowChild(wxWindowID vId);
19193a2c	199	#endif //__WXUNIVERSAL__
cdf1e714 DW	200
	201	// implementation from now on
	202	// --------------------------
	203
	204	// simple accessors
	205	// ----------------
86de7616	206
776d87d5 DW	207	WXHWND GetHWND(void) const { return m_hWnd; }
	208	void SetHWND(WXHWND hWnd) { m_hWnd = hWnd; }
	209	virtual WXWidget GetHandle(void) const { return GetHWND(); }
	210	bool GetUseCtl3D(void) const { return m_bUseCtl3D; }
	211	bool GetTransparentBackground(void) const { return m_bBackgroundTransparent; }
	212	void SetTransparent(bool bT = TRUE) { m_bBackgroundTransparent = bT; }
54da4255	213
cdf1e714 DW	214	// event handlers
cdf1e714 DW	215	// --------------
a885d89a	216	void OnSetFocus(wxFocusEvent& rEvent);
776d87d5 DW	217	void OnEraseBackground(wxEraseEvent& rEvent);
776d87d5 DW	218	void OnIdle(wxIdleEvent& rEvent);
cdf1e714 DW	219
cdf1e714 DW	220	public:
0e320a79 DW	221	// For implementation purposes - sometimes decorations make the client area
0e320a79 DW	222	// smaller
776d87d5	223	virtual wxPoint GetClientAreaOrigin(void) const;
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
008089f6	263	,WXDWORD dwExStyle = 0L
776d87d5 DW	264	);
	265	virtual bool OS2Command( WXUINT uParam
	266	,WXWORD nId
	267	);
cdf1e714 DW	268
cdf1e714 DW	269	#if WXWIN_COMPATIBILITY
776d87d5 DW	270	wxObject* GetChild(int nNumber) const;
	271	virtual void OS2DeviceToLogical( float* pfX
	272	,float* pfY
	273	) const;
cdf1e714 DW	274	#endif // WXWIN_COMPATIBILITY
cdf1e714 DW	275
19193a2c	276	#ifndef __WXUNIVERSAL__
cdf1e714	277	// Create an appropriate wxWindow from a HWND
776d87d5 DW	278	virtual wxWindow* CreateWindowFromHWND( wxWindow* pParent
	279	,WXHWND hWnd
	280	);
cdf1e714 DW	281
cdf1e714 DW	282	// Make sure the window style reflects the HWND style (roughly)
776d87d5	283	virtual void AdoptAttributesFromHWND(void);
19193a2c	284	#endif
cdf1e714 DW	285
cdf1e714 DW	286	// Setup background and foreground colours correctly
776d87d5	287	virtual void SetupColours(void);
cdf1e714 DW	288
	289	// ------------------------------------------------------------------------
	290	// helpers for message handlers: these perform the same function as the
	291	// message crackers from <windowsx.h> - they unpack WPARAM and LPARAM into
	292	// the correct parameters
	293	// ------------------------------------------------------------------------
	294
776d87d5 DW	295	void UnpackCommand( WXWPARAM wParam
	296	,WXLPARAM lParam,
	297	WXWORD* pId
	298	,WXHWND* pHwnd
	299	,WXWORD* pCmd
	300	);
	301	void UnpackActivate( WXWPARAM wParam
	302	,WXLPARAM lParam
	303	,WXWORD* pState
776d87d5 DW	304	,WXHWND* pHwnd
	305	);
	306	void UnpackScroll( WXWPARAM wParam
	307	,WXLPARAM lParam
	308	,WXWORD* pCode
	309	,WXWORD* pPos
	310	,WXHWND* pHwnd
	311	);
776d87d5 DW	312	void UnpackMenuSelect( WXWPARAM wParam
	313	,WXLPARAM lParam
	314	,WXWORD* pTtem
	315	,WXWORD* pFlags
	316	,WXHMENU* pHmenu
	317	);
cdf1e714 DW	318
cdf1e714 DW	319	// ------------------------------------------------------------------------
776d87d5	320	// internal handlers for OS2 messages: all handlers return a boolen value:
cdf1e714 DW	321	// TRUE means that the handler processed the event and FALSE that it didn't
	322	// ------------------------------------------------------------------------
	323
776d87d5	324	// there are several cases where we have virtual functions for PM
cdf1e714 DW	325	// message processing: this is because these messages often require to be
cdf1e714 DW	326	// processed in a different manner in the derived classes. For all other
776d87d5	327	// messages, however, we do not have corresponding OS2OnXXX() function
cdf1e714	328	// and if the derived class wants to process them, it should override
776d87d5	329	// OS2WindowProc() directly.
cdf1e714 DW	330
cdf1e714 DW	331	// scroll event (both horizontal and vertical)
776d87d5 DW	332	virtual bool OS2OnScroll( int nOrientation
	333	,WXWORD nSBCode
	334	,WXWORD pos
	335	,WXHWND control
	336	);
cdf1e714	337
cdf1e714	338	// owner-drawn controls need to process these messages
776d87d5 DW	339	virtual bool OS2OnDrawItem( int nId
	340	,WXDRAWITEMSTRUCT* pItem
	341	);
	342	virtual bool OS2OnMeasureItem( int nId
	343	,WXMEASUREITEMSTRUCT* pItem
	344	);
cdf1e714 DW	345
cdf1e714 DW	346	// the rest are not virtual
776d87d5 DW	347	bool HandleCreate( WXLPCREATESTRUCT vCs
	348	,bool* pMayCreate
	349	);
cdf1e714	350	bool HandleInitDialog(WXHWND hWndFocus);
776d87d5 DW	351	bool HandleDestroy(void);
	352	bool HandlePaint(void);
	353	bool HandleEraseBkgnd(WXHDC vDC);
	354	bool HandleMinimize(void);
	355	bool HandleMaximize(void);
	356	bool HandleSize( int nX
	357	,int nY
	358	,WXUINT uFlag
	359	);
61243a51	360	bool HandleGetMinMaxInfo(PSWP pMmInfo);
776d87d5 DW	361	bool HandleShow( bool bShow
	362	,int nStatus
	363	);
	364	bool HandleActivate( int nFlag
776d87d5 DW	365	,WXHWND hActivate
	366	);
	367	bool HandleCommand( WXWORD nId
	368	,WXWORD nCmd
	369	,WXHWND hControl
	370	);
	371	bool HandleSysCommand( WXWPARAM wParam
	372	,WXLPARAM lParam
	373	);
61243a51	374	bool HandlePaletteChanged();
776d87d5	375	bool HandleSysColorChange(void);
61243a51	376	bool HandleCtlColor(WXHBRUSH* hBrush);
776d87d5 DW	377	bool HandleSetFocus(WXHWND hWnd);
776d87d5 DW	378	bool HandleKillFocus(WXHWND hWnd);
61243a51	379	bool HandleEndDrag(WXWPARAM wParam);
776d87d5 DW	380	bool HandleMouseEvent( WXUINT uMsg
	381	,int nX
	382	,int nY
	383	,WXUINT uFlags
	384	);
	385	bool HandleMouseMove( int nX
	386	,int nY
	387	,WXUINT uFlags
	388	);
afa59b4e	389	bool HandleChar( WXDWORD wParam
776d87d5 DW	390	,WXLPARAM lParam
	391	,bool bIsASCII = FALSE
	392	);
	393	bool HandleKeyDown( WXWORD wParam
	394	,WXLPARAM lParam
	395	);
afa59b4e	396	bool HandleKeyUp( WXDWORD wParam
776d87d5 DW	397	,WXLPARAM lParam
	398	);
	399	bool HandleQueryDragIcon(WXHICON* phIcon);
61243a51 DW	400	bool HandleSetCursor( USHORT vId
61243a51 DW	401	,WXHWND hWnd
776d87d5	402	);
0e320a79	403
f9efbe3a DW	404	bool IsMouseInWindow(void) const;
	405	bool OS2GetCreateWindowCoords( const wxPoint& rPos
	406	,const wxSize& rSize
	407	,int& rnX
	408	,int& rnY
	409	,int& rnWidth
	410	,int& rnHeight
	411	) const;
	412
cdf1e714	413	// Window procedure
a885d89a	414	virtual MRESULT OS2WindowProc( WXUINT uMsg
776d87d5 DW	415	,WXWPARAM wParam
	416	,WXLPARAM lParam
	417	);
0e320a79	418
cdf1e714	419	// Calls an appropriate default window procedure
a885d89a	420	virtual MRESULT OS2DefWindowProc( WXUINT uMsg
776d87d5 DW	421	,WXWPARAM wParam
	422	,WXLPARAM lParam
	423	);
	424	virtual bool OS2ProcessMessage(WXMSG* pMsg);
	425	virtual bool OS2TranslateMessage(WXMSG* pMsg);
	426	virtual void OS2DestroyWindow(void);
0e320a79	427
cdf1e714	428	// Detach "Window" menu from menu bar so it doesn't get deleted
776d87d5	429	void OS2DetachWindowMenu(void);
27476f73	430
cdf1e714 DW	431	// this function should return the brush to paint the window background
cdf1e714 DW	432	// with or 0 for the default brush
776d87d5 DW	433	virtual WXHBRUSH OnCtlColor( WXHDC hDC
	434	,WXHWND hWnd
	435	,WXUINT uCtlColor
	436	,WXUINT uMessage
	437	,WXWPARAM wParam
	438	,WXLPARAM lParam
	439	);
27476f73	440
cdf1e714	441	#if WXWIN_COMPATIBILITY
776d87d5 DW	442	void SetShowing(bool bShow) { (void)Show(show); }
776d87d5 DW	443	bool IsUserEnabled(void) const { return IsEnabled(); }
cdf1e714	444	#endif // WXWIN_COMPATIBILITY
0e320a79	445
cdf1e714	446	// Responds to colour changes: passes event on to children.
776d87d5	447	void OnSysColourChanged(wxSysColourChangedEvent& rEvent);
0e320a79	448
776d87d5 DW	449	// initialize various fields of wxMouseEvent (common part of OS2OnMouseXXX)
	450	void InitMouseEvent( wxMouseEvent& rEvent
	451	,int nX
	452	,int nY
	453	,WXUINT uFlags
	454	);
0e320a79	455
3a50d19c DW	456	void MoveChildren(int nDiff);
3a50d19c DW	457
cdf1e714	458	protected:
a885d89a DW	459	// PM can't create some MSW styles natively but can perform these after
	460	// creation by sending messages
	461	typedef enum extra_flags { kFrameToolWindow = 0x0001
	462	,kVertCaption = 0x0002
	463	,kHorzCaption = 0x0004
	464	} EExtraFlags;
	465	// Some internal sizeing id's to make it easy for event handlers
	466	typedef enum size_types { kSizeNormal
	467	,kSizeMax
	468	,kSizeMin
	469	} ESizeTypes;
cdf1e714	470	// the window handle
776d87d5	471	WXHWND m_hWnd;
cdf1e714 DW	472
cdf1e714 DW	473	// the old window proc (we subclass all windows)
776d87d5	474	WXFARPROC m_fnOldWndProc;
cdf1e714	475
008089f6	476	// additional (OS2 specific) flags
776d87d5 DW	477	bool m_bUseCtl3D:1; // Using CTL3D for this control
	478	bool m_bBackgroundTransparent:1;
	479	bool m_bMouseInWindow:1;
	480	bool m_bDoubleClickAllowed:1;
	481	bool m_bWinCaptured:1;
008089f6	482	WXDWORD m_dwExStyle;
849949b1 DW	483
849949b1 DW	484	// the size of one page for scrolling
776d87d5 DW	485	int m_nXThumbSize;
776d87d5 DW	486	int m_nYThumbSize;
0e320a79	487
cdf1e714 DW	488	#if wxUSE_MOUSEEVENT_HACK
cdf1e714 DW	489	// the coordinates of the last mouse event and the type of it
776d87d5 DW	490	long m_lLastMouseX,
	491	long m_lLastMouseY;
	492	int m_nLastMouseEvent;
cdf1e714 DW	493	#endif // wxUSE_MOUSEEVENT_HACK
cdf1e714 DW	494
776d87d5	495	WXHMENU m_hMenu; // Menu, if any
0fe536e3	496	unsigned long m_ulMenubarId; // it's Id, if any
cdf1e714 DW	497
cdf1e714 DW	498	// the return value of WM_GETDLGCODE handler
776d87d5	499	long m_lDlgCode;
cdf1e714 DW	500
cdf1e714 DW	501	// implement the base class pure virtuals
776d87d5 DW	502	virtual void DoClientToScreen( int* pX
	503	,int* pY
	504	) const;
	505	virtual void DoScreenToClient( int* pX
	506	,int* pY
	507	) const;
	508	virtual void DoGetPosition( int* pX
	509	,int* pY
	510	) const;
	511	virtual void DoGetSize( int* pWidth
	512	,int* pHeight
	513	) const;
	514	virtual void DoGetClientSize( int* pWidth
	515	,int* pHeight
	516	) const;
	517	virtual void DoSetSize( int nX
	518	,int nY
	519	,int nWidth
	520	,int nHeight
	521	,int nSizeFlags = wxSIZE_AUTO
	522	);
	523	virtual void DoSetClientSize( int nWidth
	524	,int nHeight
	525	);
cdf1e714	526
cdf1e714 DW	527	// move the window to the specified location and resize it: this is called
cdf1e714 DW	528	// from both DoSetSize() and DoSetClientSize() and would usually just call
3e282d33	529	// ::WinSetWindowPos() except for composite controls which will want to arrange
cdf1e714	530	// themselves inside the given rectangle
776d87d5 DW	531	virtual void DoMoveWindow( int nX
	532	,int nY
	533	,int nWidth
	534	,int nHeight
	535	);
cdf1e714 DW	536
cdf1e714 DW	537	#if wxUSE_TOOLTIPS
776d87d5	538	virtual void DoSetToolTip(wxToolTip* pTip);
cdf1e714 DW	539	#endif // wxUSE_TOOLTIPS
cdf1e714 DW	540
3a50d19c DW	541	int GetOS2ParentHeight(wxWindowOS2* pParent);
3a50d19c DW	542
0e320a79	543	private:
cdf1e714	544	// common part of all ctors
776d87d5	545	void Init(void);
0e320a79	546
cdf1e714	547	// the (non-virtual) handlers for the events
776d87d5 DW	548	bool HandleMove( int nX
	549	,int nY
	550	);
	551	bool HandleJoystickEvent( WXUINT uMsg
	552	,int pX
	553	,int pY
	554	,WXUINT uFlags
	555	);
	556
	557	bool HandleNotify( int nIdCtrl
	558	,WXLPARAM lParam
	559	,WXLPARAM* pResult
	560	);
a885d89a DW	561	// the helper functions used by HandleChar/KeyXXX methods
	562	wxKeyEvent CreateKeyEvent(wxEventType evType, int id, WXLPARAM lp) const;
	563
210a651b DW	564	DECLARE_DYNAMIC_CLASS(wxWindowOS2);
210a651b DW	565	DECLARE_NO_COPY_CLASS(wxWindowOS2)
cdf1e714	566	DECLARE_EVENT_TABLE()
63415778	567	private:
c8b5f745 DW	568	HWND m_hWndScrollBarHorz;
c8b5f745 DW	569	HWND m_hWndScrollBarVert;
1c84ee88	570
63415778	571	// Virtual function hiding supression
776d87d5 DW	572	inline virtual bool Reparent(wxWindowBase* pNewParent)
776d87d5 DW	573	{ return(wxWindowBase::Reparent(pNewParent));};
a885d89a	574	}; // end of wxWindow
0e320a79	575
06519806 DW	576	class wxWindowCreationHook
	577	{
	578	public:
	579	wxWindowCreationHook(wxWindow* pWinBeingCreated);
	580	~wxWindowCreationHook();
	581	}; // end of CLASS wxWindowCreationHook
	582
cdf1e714 DW	583	// ---------------------------------------------------------------------------
	584	// global functions
	585	// ---------------------------------------------------------------------------
0e320a79	586
cdf1e714	587	// kbd code translation
776d87d5 DW	588	WXDLLEXPORT int wxCharCodeOS2ToWX(int nKeySym);
	589	WXDLLEXPORT int wxCharCodeWXToOS2( int nId
	590	,bool* pbIsVirtual
	591	);
0e320a79 DW	592	#endif
0e320a79 DW	593	// _WX_WINDOW_H_