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

/////////////////////////////////////////////////////////////////////////////
// Name:        wx/os2/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
// ---------------------------------------------------------------------------
#ifndef CW_USEDEFAULT
#  define  CW_USEDEFAULT ((int)0x80000000)
#endif

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

class WXDLLIMPEXP_FWD_CORE wxButton;

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

class WXDLLIMPEXP_CORE 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     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(wxWindow* 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     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
                                 );

    inline HWND                   GetScrollBarHorz(void) const {return m_hWndScrollBarHorz;}
    inline HWND                   GetScrollBarVert(void) const {return m_hWndScrollBarVert;};
#if wxUSE_DRAG_AND_DROP
    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);

public:

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

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

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;

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

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

#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);
    DECLARE_NO_COPY_CLASS(wxWindowOS2)
    DECLARE_EVENT_TABLE()

    //
    // 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
WXDLLIMPEXP_CORE int wxCharCodeOS2ToWX(int nKeySym);
WXDLLIMPEXP_CORE int wxCharCodeWXToOS2( int   nId
                                  ,bool* pbIsVirtual = NULL
                                 );

// ----------------------------------------------------------------------------
// global objects
// ----------------------------------------------------------------------------

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

// pseudo-template HWND <-> wxWindow hash table
WX_DECLARE_HASH(wxWindowOS2, wxWindowList, wxWinHashTable);

extern wxWinHashTable *wxWinHandleHash;

#endif // _WX_WINDOW_H_
Commit	Line	Data
0e320a79	1	/////////////////////////////////////////////////////////////////////////////
743e24aa	2	// Name: wx/os2/window.h
0e320a79	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	8	// Copyright: (c) David Webster
65571936	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	25
3011bf2b DW	26	// ---------------------------------------------------------------------------
	27	// forward declarations
	28	// ---------------------------------------------------------------------------
	29	#ifndef CW_USEDEFAULT
	30	# define CW_USEDEFAULT ((int)0x80000000)
	31	#endif
	32
0e320a79 DW	33	// ---------------------------------------------------------------------------
	34	// forward declarations
	35	// ---------------------------------------------------------------------------
	36
b5dbe15d	37	class WXDLLIMPEXP_FWD_CORE wxButton;
0e320a79	38
cdf1e714 DW	39	// ---------------------------------------------------------------------------
	40	// wxWindow declaration for OS/2 PM
	41	// ---------------------------------------------------------------------------
54da4255	42
53a2db12	43	class WXDLLIMPEXP_CORE wxWindowOS2 : public wxWindowBase
0e320a79	44	{
0e320a79	45	public:
210a651b	46	wxWindowOS2()
3e282d33 DW	47	{
	48	Init();
	49	}
cdf1e714	50
210a651b DW	51	wxWindowOS2( wxWindow* pParent
	52	,wxWindowID vId
	53	,const wxPoint& rPos = wxDefaultPosition
	54	,const wxSize& rSize = wxDefaultSize
	55	,long lStyle = 0
	56	,const wxString& rName = wxPanelNameStr
	57	)
0e320a79 DW	58	{
0e320a79 DW	59	Init();
776d87d5 DW	60	Create( pParent
	61	,vId
	62	,rPos
	63	,rSize
	64	,lStyle
	65	,rName
	66	);
0e320a79 DW	67	}
0e320a79 DW	68
210a651b	69	virtual ~wxWindowOS2();
0e320a79	70
776d87d5 DW	71	bool Create( wxWindow* pParent
	72	,wxWindowID vId
	73	,const wxPoint& rPos = wxDefaultPosition
	74	,const wxSize& rSize = wxDefaultSize
	75	,long lStyle = 0
	76	,const wxString& rName = wxPanelNameStr
	77	);
0e320a79	78
cdf1e714	79	// implement base class pure virtuals
743e24aa WS	80	virtual void SetLabel(const wxString& label);
743e24aa WS	81	virtual wxString GetLabel(void) const;
776d87d5 DW	82	virtual void Raise(void);
776d87d5 DW	83	virtual void Lower(void);
e951b8e4	84	virtual bool Show(bool bShow = true);
47a8a4d5	85	virtual void DoEnable(bool bEnable);
776d87d5	86	virtual void SetFocus(void);
1cee3f60	87	virtual void SetFocusFromKbd(void);
776d87d5 DW	88	virtual bool Reparent(wxWindow* pNewParent);
	89	virtual void WarpPointer( int x
	90	,int y
	91	);
e951b8e4	92	virtual void Refresh( bool bEraseBackground = true
776d87d5 DW	93	,const wxRect* pRect = (const wxRect *)NULL
776d87d5 DW	94	);
06519806	95	virtual void Update(void);
b9b1d6c8	96	virtual void SetWindowStyleFlag(long lStyle);
776d87d5 DW	97	virtual bool SetCursor(const wxCursor& rCursor);
	98	virtual bool SetFont(const wxFont& rFont);
	99	virtual int GetCharHeight(void) const;
	100	virtual int GetCharWidth(void) const;
	101	virtual void GetTextExtent( const wxString& rString
	102	,int* pX
	103	,int* pY
	104	,int* pDescent = (int *)NULL
	105	,int* pExternalLeading = (int *)NULL
	106	,const wxFont* pTheFont = (const wxFont *)NULL
	107	) const;
19193a2c	108	#if wxUSE_MENUS_NATIVE
776d87d5 DW	109	virtual bool DoPopupMenu( wxMenu* pMenu
	110	,int nX
	111	,int nY
	112	);
19193a2c	113	#endif // wxUSE_MENUS_NATIVE
776d87d5 DW	114
	115	virtual void SetScrollbar( int nOrient
	116	,int nPos
	117	,int nThumbVisible
	118	,int nRange
e951b8e4	119	,bool bRefresh = true
776d87d5 DW	120	);
	121	virtual void SetScrollPos( int nOrient
	122	,int nPos
e951b8e4	123	,bool bRefresh = true
776d87d5 DW	124	);
	125	virtual int GetScrollPos(int nOrient) const;
	126	virtual int GetScrollThumb(int nOrient) const;
	127	virtual int GetScrollRange(int nOrient) const;
	128	virtual void ScrollWindow( int nDx
	129	,int nDy
	130	,const wxRect* pRect = (wxRect *)NULL
	131	);
0e320a79	132
45e0dc94 DW	133	inline HWND GetScrollBarHorz(void) const {return m_hWndScrollBarHorz;}
45e0dc94 DW	134	inline HWND GetScrollBarVert(void) const {return m_hWndScrollBarVert;};
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
19193a2c	142	#ifndef __WXUNIVERSAL__
776d87d5	143	// Native resource loading (implemented in src/os2/nativdlg.cpp)
cdf1e714	144	// FIXME: should they really be all virtual?
776d87d5 DW	145	virtual bool LoadNativeDialog( wxWindow* pParent
	146	,wxWindowID& vId
	147	);
	148	virtual bool LoadNativeDialog( wxWindow* pParent
	149	,const wxString& rName
	150	);
	151	wxWindow* GetWindowChild1(wxWindowID vId);
	152	wxWindow* GetWindowChild(wxWindowID vId);
19193a2c	153	#endif //__WXUNIVERSAL__
cdf1e714 DW	154
	155	// implementation from now on
	156	// --------------------------
	157
	158	// simple accessors
	159	// ----------------
86de7616	160
776d87d5 DW	161	WXHWND GetHWND(void) const { return m_hWnd; }
	162	void SetHWND(WXHWND hWnd) { m_hWnd = hWnd; }
	163	virtual WXWidget GetHandle(void) const { return GetHWND(); }
	164	bool GetUseCtl3D(void) const { return m_bUseCtl3D; }
	165	bool GetTransparentBackground(void) const { return m_bBackgroundTransparent; }
09fe7dc6	166	void SetTransparentBackground(bool bT = true) { m_bBackgroundTransparent = bT; }
54da4255	167
cdf1e714 DW	168	// event handlers
cdf1e714 DW	169	// --------------
a885d89a	170	void OnSetFocus(wxFocusEvent& rEvent);
776d87d5 DW	171	void OnEraseBackground(wxEraseEvent& rEvent);
776d87d5 DW	172	void OnIdle(wxIdleEvent& rEvent);
cdf1e714 DW	173
cdf1e714 DW	174	public:
f289196b	175
86de7616 DW	176	// Windows subclassing
86de7616 DW	177	void SubclassWin(WXHWND hWnd);
776d87d5	178	void UnsubclassWin(void);
86de7616	179
776d87d5 DW	180	WXFARPROC OS2GetOldWndProc(void) const { return m_fnOldWndProc; }
776d87d5 DW	181	void OS2SetOldWndProc(WXFARPROC fnProc) { m_fnOldWndProc = fnProc; }
47df2b8c	182	//
e951b8e4	183	// Return true if the window is of a standard (i.e. not wxWidgets') class
47df2b8c DW	184	//
47df2b8c DW	185	bool IsOfStandardClass(void) const { return m_fnOldWndProc != NULL; }
86de7616	186
776d87d5 DW	187	wxWindow* FindItem(long lId) const;
776d87d5 DW	188	wxWindow* FindItemByHWND( WXHWND hWnd
e951b8e4	189	,bool bControlOnly = false
776d87d5	190	) const;
86de7616	191
77ffb593	192	// Make a Windows extended style from the given wxWidgets window style ?? applicable to OS/2??
776d87d5	193	static WXDWORD MakeExtendedStyle( long lStyle
e951b8e4	194	,bool bEliminateBorders = true
776d87d5	195	);
86de7616	196
e951b8e4 WS	197	// PM only: true if this control is part of the main control
e951b8e4 WS	198	virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return false; };
86de7616	199
77ffb593	200	// translate wxWidgets style flags for this control into the PM style
b9b1d6c8 DW	201	// and optional extended style for the corresponding native control
	202	//
	203	// this is the function that should be overridden in the derived classes,
	204	// but you will mostly use OS2GetCreateWindowFlags() below
	205	virtual WXDWORD OS2GetStyle( long lFlags
	206	,WXDWORD* pdwExstyle = NULL
	207	) const;
	208
77ffb593	209	// get the MSW window flags corresponding to wxWidgets ones
b9b1d6c8 DW	210	//
	211	// the functions returns the flags (WS_XXX) directly and puts the ext
	212	// (WS_EX_XXX) flags into the provided pointer if not NULL
	213	WXDWORD OS2GetCreateWindowFlags(WXDWORD* pdwExflags = NULL) const
	214	{ return OS2GetStyle(GetWindowStyle(), pdwExflags); }
	215
	216
6ed98c6a DW	217	// get the HWND to be used as parent of this window with CreateWindow()
	218	virtual WXHWND OS2GetParent(void) const;
	219
e951b8e4	220	// returns true if the window has been created
3011bf2b	221	bool OS2Create( PSZ zClass
edf1dfa1	222	,const wxChar* zTitle
3011bf2b DW	223	,WXDWORD dwStyle
	224	,const wxPoint& rPos
	225	,const wxSize& rSize
	226	,void* pCtlData
	227	,WXDWORD dwExStyle
	228	,bool bIsChild
	229	);
776d87d5 DW	230	virtual bool OS2Command( WXUINT uParam
	231	,WXWORD nId
	232	);
cdf1e714	233
19193a2c	234	#ifndef __WXUNIVERSAL__
cdf1e714	235	// Create an appropriate wxWindow from a HWND
776d87d5 DW	236	virtual wxWindow* CreateWindowFromHWND( wxWindow* pParent
	237	,WXHWND hWnd
	238	);
cdf1e714 DW	239
cdf1e714 DW	240	// Make sure the window style reflects the HWND style (roughly)
776d87d5	241	virtual void AdoptAttributesFromHWND(void);
19193a2c	242	#endif
cdf1e714 DW	243
cdf1e714 DW	244	// Setup background and foreground colours correctly
776d87d5	245	virtual void SetupColours(void);
cdf1e714 DW	246
	247	// ------------------------------------------------------------------------
	248	// helpers for message handlers: these perform the same function as the
	249	// message crackers from <windowsx.h> - they unpack WPARAM and LPARAM into
	250	// the correct parameters
	251	// ------------------------------------------------------------------------
	252
776d87d5 DW	253	void UnpackCommand( WXWPARAM wParam
	254	,WXLPARAM lParam,
	255	WXWORD* pId
	256	,WXHWND* pHwnd
	257	,WXWORD* pCmd
	258	);
	259	void UnpackActivate( WXWPARAM wParam
	260	,WXLPARAM lParam
	261	,WXWORD* pState
776d87d5 DW	262	,WXHWND* pHwnd
	263	);
	264	void UnpackScroll( WXWPARAM wParam
	265	,WXLPARAM lParam
	266	,WXWORD* pCode
	267	,WXWORD* pPos
	268	,WXHWND* pHwnd
	269	);
776d87d5 DW	270	void UnpackMenuSelect( WXWPARAM wParam
	271	,WXLPARAM lParam
	272	,WXWORD* pTtem
	273	,WXWORD* pFlags
	274	,WXHMENU* pHmenu
	275	);
cdf1e714 DW	276
cdf1e714 DW	277	// ------------------------------------------------------------------------
776d87d5	278	// internal handlers for OS2 messages: all handlers return a boolen value:
e951b8e4	279	// true means that the handler processed the event and false that it didn't
cdf1e714 DW	280	// ------------------------------------------------------------------------
cdf1e714 DW	281
776d87d5	282	// there are several cases where we have virtual functions for PM
cdf1e714 DW	283	// message processing: this is because these messages often require to be
cdf1e714 DW	284	// processed in a different manner in the derived classes. For all other
776d87d5	285	// messages, however, we do not have corresponding OS2OnXXX() function
cdf1e714	286	// and if the derived class wants to process them, it should override
776d87d5	287	// OS2WindowProc() directly.
cdf1e714 DW	288
cdf1e714 DW	289	// scroll event (both horizontal and vertical)
776d87d5 DW	290	virtual bool OS2OnScroll( int nOrientation
	291	,WXWORD nSBCode
	292	,WXWORD pos
	293	,WXHWND control
	294	);
cdf1e714	295
cdf1e714	296	// owner-drawn controls need to process these messages
776d87d5 DW	297	virtual bool OS2OnDrawItem( int nId
	298	,WXDRAWITEMSTRUCT* pItem
	299	);
f5ea767e	300	virtual long OS2OnMeasureItem( int nId
776d87d5 DW	301	,WXMEASUREITEMSTRUCT* pItem
776d87d5 DW	302	);
cdf1e714	303
9794cae1 DW	304	virtual void OnPaint(wxPaintEvent& rEvent);
9794cae1 DW	305
cdf1e714	306	// the rest are not virtual
776d87d5 DW	307	bool HandleCreate( WXLPCREATESTRUCT vCs
	308	,bool* pMayCreate
	309	);
cdf1e714	310	bool HandleInitDialog(WXHWND hWndFocus);
776d87d5 DW	311	bool HandleDestroy(void);
	312	bool HandlePaint(void);
	313	bool HandleEraseBkgnd(WXHDC vDC);
	314	bool HandleMinimize(void);
	315	bool HandleMaximize(void);
	316	bool HandleSize( int nX
	317	,int nY
	318	,WXUINT uFlag
	319	);
61243a51	320	bool HandleGetMinMaxInfo(PSWP pMmInfo);
776d87d5 DW	321	bool HandleShow( bool bShow
	322	,int nStatus
	323	);
	324	bool HandleActivate( int nFlag
776d87d5 DW	325	,WXHWND hActivate
	326	);
	327	bool HandleCommand( WXWORD nId
	328	,WXWORD nCmd
	329	,WXHWND hControl
	330	);
	331	bool HandleSysCommand( WXWPARAM wParam
	332	,WXLPARAM lParam
	333	);
1d0edc0f DW	334	bool HandlePaletteChanged(void);
1d0edc0f DW	335	bool HandleQueryNewPalette(void);
776d87d5	336	bool HandleSysColorChange(void);
1d0edc0f DW	337	bool HandleDisplayChange(void);
	338	bool HandleCaptureChanged(WXHWND hBainedCapture);
	339
61243a51	340	bool HandleCtlColor(WXHBRUSH* hBrush);
776d87d5 DW	341	bool HandleSetFocus(WXHWND hWnd);
776d87d5 DW	342	bool HandleKillFocus(WXHWND hWnd);
61243a51	343	bool HandleEndDrag(WXWPARAM wParam);
776d87d5 DW	344	bool HandleMouseEvent( WXUINT uMsg
	345	,int nX
	346	,int nY
	347	,WXUINT uFlags
	348	);
	349	bool HandleMouseMove( int nX
	350	,int nY
	351	,WXUINT uFlags
	352	);
598d8cac	353	bool HandleChar( WXWPARAM wParam
776d87d5	354	,WXLPARAM lParam
e951b8e4	355	,bool bIsASCII = false
776d87d5	356	);
a086de98	357	bool HandleKeyDown( WXWPARAM wParam
776d87d5 DW	358	,WXLPARAM lParam
776d87d5 DW	359	);
a086de98	360	bool HandleKeyUp( WXWPARAM wParam
776d87d5 DW	361	,WXLPARAM lParam
	362	);
	363	bool HandleQueryDragIcon(WXHICON* phIcon);
61243a51 DW	364	bool HandleSetCursor( USHORT vId
61243a51 DW	365	,WXHWND hWnd
776d87d5	366	);
0e320a79	367
f9efbe3a DW	368	bool IsMouseInWindow(void) const;
	369	bool OS2GetCreateWindowCoords( const wxPoint& rPos
	370	,const wxSize& rSize
	371	,int& rnX
	372	,int& rnY
	373	,int& rnWidth
	374	,int& rnHeight
	375	) const;
	376
cdf1e714	377	// Window procedure
a885d89a	378	virtual MRESULT OS2WindowProc( WXUINT uMsg
776d87d5 DW	379	,WXWPARAM wParam
	380	,WXLPARAM lParam
	381	);
0e320a79	382
cdf1e714	383	// Calls an appropriate default window procedure
a885d89a	384	virtual MRESULT OS2DefWindowProc( WXUINT uMsg
776d87d5 DW	385	,WXWPARAM wParam
	386	,WXLPARAM lParam
	387	);
	388	virtual bool OS2ProcessMessage(WXMSG* pMsg);
f140b352	389	virtual bool OS2ShouldPreProcessMessage(WXMSG* pMsg);
776d87d5 DW	390	virtual bool OS2TranslateMessage(WXMSG* pMsg);
776d87d5 DW	391	virtual void OS2DestroyWindow(void);
0e320a79	392
cdf1e714 DW	393	// this function should return the brush to paint the window background
cdf1e714 DW	394	// with or 0 for the default brush
776d87d5 DW	395	virtual WXHBRUSH OnCtlColor( WXHDC hDC
	396	,WXHWND hWnd
	397	,WXUINT uCtlColor
	398	,WXUINT uMessage
	399	,WXWPARAM wParam
	400	,WXLPARAM lParam
	401	);
27476f73	402
cdf1e714	403	// Responds to colour changes: passes event on to children.
776d87d5	404	void OnSysColourChanged(wxSysColourChangedEvent& rEvent);
0e320a79	405
776d87d5 DW	406	// initialize various fields of wxMouseEvent (common part of OS2OnMouseXXX)
	407	void InitMouseEvent( wxMouseEvent& rEvent
	408	,int nX
	409	,int nY
	410	,WXUINT uFlags
	411	);
0e320a79	412
3a50d19c	413	void MoveChildren(int nDiff);
1b7735e1	414	PSWP GetSwp(void) {return &m_vWinSwp;}
3a50d19c	415
cdf1e714	416	protected:
17808a75 VZ	417	virtual void DoFreeze(void);
	418	virtual void DoThaw(void);
	419
a885d89a DW	420	// PM can't create some MSW styles natively but can perform these after
	421	// creation by sending messages
	422	typedef enum extra_flags { kFrameToolWindow = 0x0001
	423	,kVertCaption = 0x0002
	424	,kHorzCaption = 0x0004
	425	} EExtraFlags;
	426	// Some internal sizeing id's to make it easy for event handlers
	427	typedef enum size_types { kSizeNormal
	428	,kSizeMax
	429	,kSizeMin
	430	} ESizeTypes;
cdf1e714	431	// the window handle
776d87d5	432	WXHWND m_hWnd;
cdf1e714 DW	433
cdf1e714 DW	434	// the old window proc (we subclass all windows)
776d87d5	435	WXFARPROC m_fnOldWndProc;
cdf1e714	436
008089f6	437	// additional (OS2 specific) flags
776d87d5 DW	438	bool m_bUseCtl3D:1; // Using CTL3D for this control
	439	bool m_bBackgroundTransparent:1;
	440	bool m_bMouseInWindow:1;
3437f881	441	bool m_bLastKeydownProcessed:1;
776d87d5	442	bool m_bWinCaptured:1;
008089f6	443	WXDWORD m_dwExStyle;
849949b1 DW	444
849949b1 DW	445	// the size of one page for scrolling
776d87d5 DW	446	int m_nXThumbSize;
776d87d5 DW	447	int m_nYThumbSize;
0e320a79	448
cdf1e714 DW	449	#if wxUSE_MOUSEEVENT_HACK
cdf1e714 DW	450	// the coordinates of the last mouse event and the type of it
776d87d5 DW	451	long m_lLastMouseX,
	452	long m_lLastMouseY;
	453	int m_nLastMouseEvent;
cdf1e714 DW	454	#endif // wxUSE_MOUSEEVENT_HACK
cdf1e714 DW	455
776d87d5	456	WXHMENU m_hMenu; // Menu, if any
0fe536e3	457	unsigned long m_ulMenubarId; // it's Id, if any
cdf1e714 DW	458
cdf1e714 DW	459	// the return value of WM_GETDLGCODE handler
776d87d5	460	long m_lDlgCode;
cdf1e714 DW	461
cdf1e714 DW	462	// implement the base class pure virtuals
776d87d5 DW	463	virtual void DoClientToScreen( int* pX
	464	,int* pY
	465	) const;
	466	virtual void DoScreenToClient( int* pX
	467	,int* pY
	468	) const;
	469	virtual void DoGetPosition( int* pX
	470	,int* pY
	471	) const;
	472	virtual void DoGetSize( int* pWidth
	473	,int* pHeight
	474	) const;
	475	virtual void DoGetClientSize( int* pWidth
	476	,int* pHeight
	477	) const;
	478	virtual void DoSetSize( int nX
	479	,int nY
	480	,int nWidth
	481	,int nHeight
	482	,int nSizeFlags = wxSIZE_AUTO
	483	);
	484	virtual void DoSetClientSize( int nWidth
	485	,int nHeight
	486	);
cdf1e714	487
4116c221 VZ	488	virtual void DoCaptureMouse(void);
4116c221 VZ	489	virtual void DoReleaseMouse(void);
b9b1d6c8	490
cdf1e714 DW	491	// move the window to the specified location and resize it: this is called
cdf1e714 DW	492	// from both DoSetSize() and DoSetClientSize() and would usually just call
3e282d33	493	// ::WinSetWindowPos() except for composite controls which will want to arrange
cdf1e714	494	// themselves inside the given rectangle
776d87d5 DW	495	virtual void DoMoveWindow( int nX
	496	,int nY
	497	,int nWidth
	498	,int nHeight
	499	);
cdf1e714 DW	500
cdf1e714 DW	501	#if wxUSE_TOOLTIPS
776d87d5	502	virtual void DoSetToolTip(wxToolTip* pTip);
cdf1e714 DW	503	#endif // wxUSE_TOOLTIPS
cdf1e714 DW	504
3a50d19c DW	505	int GetOS2ParentHeight(wxWindowOS2* pParent);
3a50d19c DW	506
0e320a79	507	private:
cdf1e714	508	// common part of all ctors
776d87d5	509	void Init(void);
0e320a79	510
cdf1e714	511	// the (non-virtual) handlers for the events
776d87d5 DW	512	bool HandleMove( int nX
	513	,int nY
	514	);
	515	bool HandleJoystickEvent( WXUINT uMsg
	516	,int pX
	517	,int pY
	518	,WXUINT uFlags
	519	);
	520
	521	bool HandleNotify( int nIdCtrl
	522	,WXLPARAM lParam
	523	,WXLPARAM* pResult
	524	);
a885d89a	525	// the helper functions used by HandleChar/KeyXXX methods
a086de98 DW	526	wxKeyEvent CreateKeyEvent( wxEventType evType
	527	,int nId
	528	,WXLPARAM lParam = 0
	529	,WXWPARAM wParam = 0
	530	) const;
a885d89a	531
c8b5f745 DW	532	HWND m_hWndScrollBarHorz;
c8b5f745 DW	533	HWND m_hWndScrollBarVert;
1b7735e1	534	SWP m_vWinSwp;
1c84ee88	535
018d3030 DW	536	DECLARE_DYNAMIC_CLASS(wxWindowOS2);
	537	DECLARE_NO_COPY_CLASS(wxWindowOS2)
	538	DECLARE_EVENT_TABLE()
	539
	540	//
63415778	541	// Virtual function hiding supression
018d3030	542	//
776d87d5	543	inline virtual bool Reparent(wxWindowBase* pNewParent)
018d3030	544	{ return(wxWindowBase::Reparent(pNewParent));}
a885d89a	545	}; // end of wxWindow
0e320a79	546
06519806 DW	547	class wxWindowCreationHook
	548	{
	549	public:
	550	wxWindowCreationHook(wxWindow* pWinBeingCreated);
	551	~wxWindowCreationHook();
	552	}; // end of CLASS wxWindowCreationHook
	553
cdf1e714 DW	554	// ---------------------------------------------------------------------------
	555	// global functions
	556	// ---------------------------------------------------------------------------
0e320a79	557
cdf1e714	558	// kbd code translation
53a2db12 FM	559	WXDLLIMPEXP_CORE int wxCharCodeOS2ToWX(int nKeySym);
53a2db12 FM	560	WXDLLIMPEXP_CORE int wxCharCodeWXToOS2( int nId
8e372bbe	561	,bool* pbIsVirtual = NULL
776d87d5	562	);
2461cfa0 SN	563
	564	// ----------------------------------------------------------------------------
	565	// global objects
	566	// ----------------------------------------------------------------------------
	567
	568	// notice that this hash must be defined after wxWindow declaration as it
	569	// needs to "see" its dtor and not just forward declaration
	570	#include "wx/hash.h"
	571
	572	// pseudo-template HWND <-> wxWindow hash table
	573	WX_DECLARE_HASH(wxWindowOS2, wxWindowList, wxWinHashTable);
	574
	575	extern wxWinHashTable *wxWinHandleHash;
	576
743e24aa	577	#endif // _WX_WINDOW_H_