[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 bool     SetCursor(const wxCursor& rCursor);
    virtual bool     SetFont(const wxFont& rFont);
    virtual int      GetCharHeight(void) const;
    virtual int      GetCharWidth(void) const;
    virtual void     GetTextExtent( const wxString& rString
                                   ,int*            pX
                                   ,int*            pY
                                   ,int*            pDescent = (int *)NULL
                                   ,int*            pExternalLeading = (int *)NULL
                                   ,const wxFont*   pTheFont = (const wxFont *)NULL
                                  ) const;
    virtual bool     DoPopupMenu( wxMenu* pMenu
                                 ,int     nX
                                 ,int     nY
                                );

    virtual void     SetScrollbar( int  nOrient
                                  ,int  nPos
                                  ,int  nThumbVisible
                                  ,int  nRange
                                  ,bool bRefresh = TRUE
                                 );
    virtual void     SetScrollPos( int  nOrient
                                  ,int  nPos
                                  ,bool bRefresh = TRUE
                                 );
    virtual int      GetScrollPos(int nOrient) const;
    virtual int      GetScrollThumb(int nOrient) const;
    virtual int      GetScrollRange(int nOrient) const;
    virtual void     ScrollWindow( int           nDx
                                  ,int           nDy
                                  ,const wxRect* pRect = (wxRect *)NULL
                                 );

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

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

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

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

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

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

    // Native resource loading (implemented in src/os2/nativdlg.cpp)
    // FIXME: should they really be all virtual?
    virtual bool LoadNativeDialog( wxWindow*   pParent
                                  ,wxWindowID& vId
                                 );
    virtual bool LoadNativeDialog( wxWindow*       pParent
                                  ,const wxString& rName
                                 );
    wxWindow*    GetWindowChild1(wxWindowID vId);
    wxWindow*    GetWindowChild(wxWindowID vId);

    // implementation from now on
    // --------------------------

    // simple accessors
    // ----------------

    WXHWND           GetHWND(void) const { return m_hWnd; }
    void             SetHWND(WXHWND hWnd) { m_hWnd = hWnd; }
    virtual WXWidget GetHandle(void) const { return GetHWND(); }
    bool             GetUseCtl3D(void) const { return m_bUseCtl3D; }
    bool             GetTransparentBackground(void) const { return m_bBackgroundTransparent; }
    void             SetTransparent(bool bT = TRUE) { m_bBackgroundTransparent = bT; }

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

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

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

    // Create an appropriate wxWindow from a HWND
    virtual wxWindow* CreateWindowFromHWND( wxWindow* pParent
                                           ,WXHWND    hWnd
                                          );

    // Make sure the window style reflects the HWND style (roughly)
    virtual void AdoptAttributesFromHWND(void);

    // Setup background and foreground colours correctly
    virtual void SetupColours(void);

    // ------------------------------------------------------------------------
    // helpers for message handlers: these perform the same function as the
    // message crackers from <windowsx.h> - they unpack WPARAM and LPARAM into
    // the correct parameters
    // ------------------------------------------------------------------------

    void UnpackCommand( WXWPARAM wParam
                       ,WXLPARAM lParam,
                        WXWORD*  pId
                       ,WXHWND*  pHwnd
                       ,WXWORD*  pCmd
                      );
    void UnpackActivate( WXWPARAM wParam
                        ,WXLPARAM lParam
                        ,WXWORD*  pState
                        ,WXHWND*  pHwnd
                       );
    void UnpackScroll( WXWPARAM wParam
                      ,WXLPARAM lParam
                      ,WXWORD*  pCode
                      ,WXWORD*  pPos
                      ,WXHWND*  pHwnd
                     );
    void UnpackMenuSelect( WXWPARAM wParam
                          ,WXLPARAM lParam
                          ,WXWORD*  pTtem
                          ,WXWORD*  pFlags
                          ,WXHMENU* pHmenu
                         );

    // ------------------------------------------------------------------------
    // internal handlers for OS2 messages: all handlers return a boolen value:
    // TRUE means that the handler processed the event and FALSE that it didn't
    // ------------------------------------------------------------------------

    // there are several cases where we have virtual functions for PM
    // message processing: this is because these messages often require to be
    // processed in a different manner in the derived classes. For all other
    // messages, however, we do *not* have corresponding OS2OnXXX() function
    // and if the derived class wants to process them, it should override
    // OS2WindowProc() directly.

    // scroll event (both horizontal and vertical)
    virtual bool OS2OnScroll( int    nOrientation
                             ,WXWORD nSBCode
                             ,WXWORD pos
                             ,WXHWND control
                            );

    // owner-drawn controls need to process these messages
    virtual bool OS2OnDrawItem( int               nId
                               ,WXDRAWITEMSTRUCT* pItem
                              );
    virtual bool OS2OnMeasureItem( int                  nId
                                  ,WXMEASUREITEMSTRUCT* pItem
                                 );

    // the rest are not virtual
    bool HandleCreate( WXLPCREATESTRUCT vCs
                      ,bool*            pMayCreate
                     );
    bool HandleInitDialog(WXHWND hWndFocus);
    bool HandleDestroy(void);
    bool HandlePaint(void);
    bool HandleEraseBkgnd(WXHDC vDC);
    bool HandleMinimize(void);
    bool HandleMaximize(void);
    bool HandleSize( int    nX
                    ,int    nY
                    ,WXUINT uFlag
                   );
    bool HandleGetMinMaxInfo(PSWP pMmInfo);
    bool HandleShow( bool bShow
                    ,int  nStatus
                   );
    bool HandleActivate( int    nFlag
                        ,WXHWND hActivate
                       );
    bool HandleCommand( WXWORD nId
                       ,WXWORD nCmd
                       ,WXHWND hControl
                      );
    bool HandleSysCommand( WXWPARAM wParam
                          ,WXLPARAM lParam
                         );
    bool HandleWindowParams( PWNDPARAMS pParams
                            ,WXLPARAM   lParam
                           );
    bool HandlePaletteChanged();
    bool HandlePresParamChanged(WXWPARAM wParam);
    bool HandleSysColorChange(void);
    bool HandleCtlColor(WXHBRUSH* hBrush);
    bool HandleSetFocus(WXHWND hWnd);
    bool HandleKillFocus(WXHWND hWnd);
    bool HandleEndDrag(WXWPARAM wParam);
    bool HandleMouseEvent( WXUINT uMsg
                          ,int    nX
                          ,int    nY
                          ,WXUINT uFlags
                         );
    bool HandleMouseMove( int    nX
                         ,int    nY
                         ,WXUINT uFlags
                        );
    bool HandleChar( WXWORD   wParam
                    ,WXLPARAM lParam
                    ,bool     bIsASCII = FALSE
                   );
    bool HandleKeyDown( WXWORD   wParam
                       ,WXLPARAM lParam
                      );
    bool HandleKeyUp( WXWORD   wParam
                     ,WXLPARAM lParam
                    );
    bool HandleQueryDragIcon(WXHICON* phIcon);
    bool HandleSetCursor( USHORT vId
                         ,WXHWND hWnd
                        );

    // Window procedure
    virtual MRESULT OS2WindowProc( WXUINT   uMsg
                                  ,WXWPARAM wParam
                                  ,WXLPARAM lParam
                                 );

    // Calls an appropriate default window procedure
    virtual MRESULT OS2DefWindowProc( WXUINT   uMsg
                                     ,WXWPARAM wParam
                                     ,WXLPARAM lParam
                                    );
    virtual bool    OS2ProcessMessage(WXMSG* pMsg);
    virtual bool    OS2TranslateMessage(WXMSG* pMsg);
    virtual void    OS2DestroyWindow(void);

    // Detach "Window" menu from menu bar so it doesn't get deleted
    void OS2DetachWindowMenu(void);

    // this function should return the brush to paint the window background
    // with or 0 for the default brush
    virtual WXHBRUSH OnCtlColor( WXHDC    hDC
                                ,WXHWND   hWnd
                                ,WXUINT   uCtlColor
                                ,WXUINT   uMessage
                                ,WXWPARAM wParam
                                ,WXLPARAM lParam
                               );

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

    // Responds to colour changes: passes event on to children.
    void OnSysColourChanged(wxSysColourChangedEvent& rEvent);

    // initialize various fields of wxMouseEvent (common part of OS2OnMouseXXX)
    void InitMouseEvent( wxMouseEvent& rEvent
                        ,int           nX
                        ,int           nY
                        ,WXUINT        uFlags
                       );

protected:
    // PM can't create some MSW styles natively but can perform these after
    // creation by sending messages
    typedef enum extra_flags { kFrameToolWindow = 0x0001
                              ,kVertCaption     = 0x0002
                              ,kHorzCaption     = 0x0004
                             } EExtraFlags;
    // Some internal sizeing id's to make it easy for event handlers
    typedef enum size_types { kSizeNormal
                             ,kSizeMax
                             ,kSizeMin
                            } ESizeTypes;
    // the window handle
    WXHWND                          m_hWnd;

    // the old window proc (we subclass all windows)
    WXFARPROC                       m_fnOldWndProc;

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

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

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