include/wx/os2/window.h

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