[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
// ---------------------------------------------------------------------------
#ifndef CW_USEDEFAULT
#  define  CW_USEDEFAULT ((int)0x80000000)
#endif

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

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

    // translate wxWindows 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 wxWindows 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); }


    // returns TRUE if the window has been created
    bool         OS2Create( PSZ            zClass
                           ,const char*    zTitle
                           ,WXDWORD        dwStyle
                           ,const wxPoint& rPos
                           ,const wxSize&  rSize
                           ,void*          pCtlData
                           ,WXDWORD        dwExStyle
                           ,bool           bIsChild
                          );
    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    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
                               );

#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);
    PSWP GetSwp(void) {return &m_vWinSwp;}

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

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


    DECLARE_DYNAMIC_CLASS(wxWindowOS2);
    DECLARE_NO_COPY_CLASS(wxWindowOS2)
    DECLARE_EVENT_TABLE()

private:
    HWND                            m_hWndScrollBarHorz;
    HWND                            m_hWndScrollBarVert;
    SWP                             m_vWinSwp;

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