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