X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4b7f2165565bb33b149baf1272e28f9a61d579d3..3f0fb1d4165f622ab392a28c1a08a975aa7c5378:/include/wx/window.h?ds=sidebyside diff --git a/include/wx/window.h b/include/wx/window.h index f707a1c24a..94f9919e5d 100644 --- a/include/wx/window.h +++ b/include/wx/window.h @@ -1,8 +1,8 @@ /////////////////////////////////////////////////////////////////////////////// -// Name: window.h +// Name: wx/window.h // Purpose: wxWindowBase class - the interface of wxWindow // Author: Vadim Zeitlin -// Modified by: +// Modified by: Ron Lee // Created: 01/02/97 // RCS-ID: $Id$ // Copyright: (c) wxWindows team @@ -32,16 +32,28 @@ #include "wx/validate.h" // for wxDefaultValidator (always include it) +#if wxUSE_PALETTE + #include "wx/dcclient.h" + #include "wx/palette.h" +#endif // wxUSE_PALETTE + #if wxUSE_ACCEL #include "wx/accel.h" #endif // wxUSE_ACCEL +// when building wxUniv/Foo we don't want the code for native menu use to be +// compiled in - it should only be used when building real wxFoo +#ifdef __WXUNIVERSAL__ + #define wxUSE_MENUS_NATIVE 0 +#else // __WXMSW__ + #define wxUSE_MENUS_NATIVE wxUSE_MENUS +#endif // __WXUNIVERSAL__/__WXMSW__ + // ---------------------------------------------------------------------------- // forward declarations // ---------------------------------------------------------------------------- class WXDLLEXPORT wxCaret; -class WXDLLEXPORT wxClientData; class WXDLLEXPORT wxControl; class WXDLLEXPORT wxCursor; class WXDLLEXPORT wxDC; @@ -58,7 +70,7 @@ class WXDLLEXPORT wxWindow; // (pseudo)template list classes // ---------------------------------------------------------------------------- -WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode); +WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode, class WXDLLEXPORT); // ---------------------------------------------------------------------------- // global variables @@ -66,31 +78,6 @@ WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode); WXDLLEXPORT_DATA(extern wxWindowList) wxTopLevelWindows; -// ---------------------------------------------------------------------------- -// helper classes used by [SG]etClientObject/Data -// -// TODO move into a separate header? -// ---------------------------------------------------------------------------- - -class wxClientData -{ -public: - wxClientData() { } - virtual ~wxClientData() { } -}; - -class wxStringClientData : public wxClientData -{ -public: - wxStringClientData() { } - wxStringClientData( const wxString &data ) : m_data(data) { } - void SetData( const wxString &data ) { m_data = data; } - const wxString& GetData() const { return m_data; } - -private: - wxString m_data; -}; - // ---------------------------------------------------------------------------- // wxWindowBase is the base class for all GUI controls/widgets, this is the public // interface of this class. @@ -104,8 +91,6 @@ private: class WXDLLEXPORT wxWindowBase : public wxEvtHandler { - DECLARE_ABSTRACT_CLASS(wxWindowBase); - public: // creating the window // ------------------- @@ -156,10 +141,14 @@ public: // window attributes // ----------------- + // NB: in future versions of wxWindows Set/GetTitle() will only work + // with the top level windows (such as dialogs and frames) and + // Set/GetLabel() only with the other ones (i.e. all controls). + // the title (or label, see below) of the window: the text which the // window shows - virtual void SetTitle( const wxString & WXUNUSED(title) ) { } - virtual wxString GetTitle() const { return ""; } + virtual void SetTitle( const wxString& WXUNUSED(title) ) {} + virtual wxString GetTitle() const { return wxEmptyString; } // label is just the same as the title (but for, e.g., buttons it // makes more sense to speak about labels) @@ -203,11 +192,11 @@ public: void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO) { DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); } - void Move( int x, int y ) - { DoSetSize( x, y, -1, -1, wxSIZE_USE_EXISTING ); } + void Move(int x, int y, int flags = wxSIZE_USE_EXISTING) + { DoSetSize(x, y, -1, -1, flags); } - void Move(const wxPoint& pt) - { Move(pt.x, pt.y); } + void Move(const wxPoint& pt, int flags = wxSIZE_USE_EXISTING) + { Move(pt.x, pt.y, flags); } // Z-order virtual void Raise() = 0; @@ -259,6 +248,17 @@ public: return wxSize(w, h); } + // get the origin of the client area of the window relative to the + // window top left corner (the client area may be shifted because of + // the borders, scrollbars, other decorations...) + virtual wxPoint GetClientAreaOrigin() const; + + // get the client rectangle in window (i.e. client) coordinates + wxRect GetClientRect() const + { + return wxRect(GetClientAreaOrigin(), GetClientSize()); + } + // get the size best suited for the window (in fact, minimal // acceptable size using which it will still look "nice") wxSize GetBestSize() const { return DoGetBestSize(); } @@ -271,11 +271,19 @@ public: *h = s.y; } - // centre with respect to the the parent window + // the generic centre function - centers the window on parent by + // default or on screen if it doesn't have parent or + // wxCENTER_ON_SCREEN flag is given void Centre( int direction = wxBOTH ); void Center( int direction = wxBOTH ) { Centre(direction); } - void CentreOnParent( int dir = wxBOTH ) { Centre(dir | wxCENTER_FRAME); } - void CenterOnParent( int dir = wxBOTH ) { Centre(dir | wxCENTER_FRAME); } + + // centre on screen (only works for top level windows) + void CentreOnScreen(int dir = wxBOTH) { Centre(dir | wxCENTER_ON_SCREEN); } + void CenterOnScreen(int dir = wxBOTH) { CentreOnScreen(dir); } + + // centre with respect to the the parent window + void CentreOnParent(int dir = wxBOTH) { Centre(dir | wxCENTER_FRAME); } + void CenterOnParent(int dir = wxBOTH) { CentreOnParent(dir); } // set window size to wrap around its children virtual void Fit(); @@ -285,11 +293,44 @@ public: int maxW = -1, int maxH = -1, int incW = -1, int incH = -1 ); - int GetMinWidth() const { return m_minWidth; } - int GetMinHeight() const { return m_minHeight; } + virtual void SetVirtualSizeHints( int minW, int minH, + int maxW = -1, int maxH = -1 ); + + virtual int GetMinWidth() const { return m_minWidth; } + virtual int GetMinHeight() const { return m_minHeight; } int GetMaxWidth() const { return m_maxWidth; } int GetMaxHeight() const { return m_maxHeight; } + // Override this method to control the values given to Sizers etc. + virtual wxSize GetMaxSize() const { return wxSize( m_maxWidth, m_maxHeight ); } + + // Methods for accessing the virtual size of a window. For most + // windows this is just the client area of the window, but for + // some like scrolled windows it is more or less independent of + // the screen window size. You may override the DoXXXVirtual + // methods below for classes where that is is the case. + + void SetVirtualSize( const wxSize &size ) { DoSetVirtualSize( size.x, size.y ); } + void SetVirtualSize( int x, int y ) { DoSetVirtualSize( x, y ); } + + wxSize GetVirtualSize() const { return DoGetVirtualSize(); } + void GetVirtualSize( int *x, int *y ) const + { + wxSize s( DoGetVirtualSize() ); + + if( x ) + *x = s.GetWidth(); + if( y ) + *y = s.GetHeight(); + } + + // Override these methods for windows that have a virtual size + // independent of their client size. eg. the virtual area of a + // wxScrolledWindow. Default is to alias VirtualSize to ClientSize. + + virtual void DoSetVirtualSize( int x, int y ); + virtual wxSize DoGetVirtualSize() const; // { return m_virtualSize; } + // window state // ------------ @@ -315,25 +356,50 @@ public: long GetWindowStyle() const { return GetWindowStyleFlag(); } bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; } + virtual bool IsRetained() const { return HasFlag(wxRETAINED); } - virtual bool IsRetained() const - { return (m_windowStyle & wxRETAINED) != 0; } + // extra style: the less often used style bits which can't be set with + // SetWindowStyleFlag() + virtual void SetExtraStyle(long exStyle) { m_exStyle = exStyle; } + long GetExtraStyle() const { return m_exStyle; } // make the window modal (all other windows unresponsive) virtual void MakeModal(bool modal = TRUE); - // focus handling - // -------------- + virtual void SetThemeEnabled(bool enableTheme) { m_themeEnabled = enableTheme; } + virtual bool GetThemeEnabled() const { return m_themeEnabled; } + + // focus and keyboard handling + // --------------------------- // set focus to this window virtual void SetFocus() = 0; + // set focus to this window as the result of a keyboard action + virtual void SetFocusFromKbd() { SetFocus(); } + // return the window which currently has the focus or NULL static wxWindow *FindFocus() /* = 0: implement in derived classes */; // can this window have focus? virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); } + // can this window be given focus by keyboard navigation? if not, the + // only way to give it focus (provided it accepts it at all) is to + // click it + virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); } + + // NB: these methods really don't belong here but with the current + // class hierarchy there is no other place for them :-( + + // get the default child of this parent, i.e. the one which is + // activated by pressing + virtual wxWindow *GetDefaultItem() const { return NULL; } + + // set this child as default, return the old default + virtual wxWindow *SetDefaultItem(wxWindow * WXUNUSED(child)) + { return NULL; } + // parent/children relations // ------------------------- @@ -378,8 +444,15 @@ public: void PushEventHandler( wxEvtHandler *handler ); wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE ); - // validators and client data - // -------------------------- + // find the given handler in the event handler chain and remove (but + // not delete) it from the event handler chain, return TRUE if it was + // found and FALSE otherwise (this also results in an assert failure so + // this function should only be called when the handler is supposed to + // be there) + bool RemoveEventHandler(wxEvtHandler *handler); + + // validators + // ---------- #if wxUSE_VALIDATORS // a window may have an associated validator which is used to control @@ -388,15 +461,6 @@ public: virtual wxValidator *GetValidator() { return m_windowValidator; } #endif // wxUSE_VALIDATORS - // each window may have associated client data: either a pointer to - // wxClientData object in which case it is managed by the window (i.e. - // it will delete the data when it's destroyed) or an untyped pointer - // which won't be deleted by the window - but not both of them - void SetClientObject( wxClientData *data ) { DoSetClientObject(data); } - wxClientData *GetClientObject() const { return DoGetClientObject(); } - - void SetClientData( void *data ) { DoSetClientData(data); } - void *GetClientData() const { return DoGetClientData(); } // dialog oriented functions // ------------------------- @@ -444,9 +508,19 @@ public: // move the mouse to the specified position virtual void WarpPointer(int x, int y) = 0; - // start or end mouse capture - virtual void CaptureMouse() = 0; - virtual void ReleaseMouse() = 0; + // start or end mouse capture, these functions maintain the stack of + // windows having captured the mouse and after calling ReleaseMouse() + // the mouse is not released but returns to the window which had had + // captured it previously (if any) + void CaptureMouse(); + void ReleaseMouse(); + + // get the window which currently captures the mouse or NULL + static wxWindow *GetCapture(); + + // does this window have the capture? + virtual bool HasCapture() const + { return (wxWindow *)this == GetCapture(); } // painting the window // ------------------- @@ -455,9 +529,22 @@ public: // will be repainted virtual void Refresh( bool eraseBackground = TRUE, const wxRect *rect = (const wxRect *) NULL ) = 0; + + // a less awkward wrapper for Refresh + void RefreshRect(const wxRect& rect) { Refresh(TRUE, &rect); } + + // repaint all invalid areas of the window immediately + virtual void Update() { } + // clear the window entirely virtual void Clear() = 0; + // freeze the window: don't redraw it until it is thawed + virtual void Freeze() { } + + // thaw the window: redraw it after it had been frozen + virtual void Thaw() { } + // adjust DC for drawing on this window virtual void PrepareDC( wxDC & WXUNUSED(dc) ) { } @@ -466,6 +553,9 @@ public: const wxRegion& GetUpdateRegion() const { return m_updateRegion; } wxRegion& GetUpdateRegion() { return m_updateRegion; } + // get the update rectangleregion bounding box in client coords + wxRect GetUpdateClientRect() const; + // these functions verify whether the given point/rectangle belongs to // (or at least intersects with) the update region bool IsExposed( int x, int y ) const; @@ -519,11 +609,16 @@ public: const wxFont *theFont = (const wxFont *) NULL) const = 0; + // client <-> screen coords + // ------------------------ + // translate to/from screen/client coordinates (pointers may be NULL) void ClientToScreen( int *x, int *y ) const { DoClientToScreen(x, y); } void ScreenToClient( int *x, int *y ) const { DoScreenToClient(x, y); } + + // wxPoint interface to do the same thing wxPoint ClientToScreen(const wxPoint& pt) const { int x = pt.x, y = pt.y; @@ -540,23 +635,43 @@ public: return wxPoint(x, y); } + // test where the given (in client coords) point lies + wxHitTest HitTest(wxCoord x, wxCoord y) const + { return DoHitTest(x, y); } + + wxHitTest HitTest(const wxPoint& pt) const + { return DoHitTest(pt.x, pt.y); } + // misc // ---- + // get the window border style: uses the current style and falls back to + // the default style for this class otherwise (see GetDefaultBorder()) + wxBorder GetBorder() const; + void UpdateWindowUI(); +#if wxUSE_MENUS bool PopupMenu( wxMenu *menu, const wxPoint& pos ) { return DoPopupMenu(menu, pos.x, pos.y); } bool PopupMenu( wxMenu *menu, int x, int y ) { return DoPopupMenu(menu, x, y); } +#endif // wxUSE_MENUS // scrollbars // ---------- + // does the window have the scrollbar for this orientation? + bool HasScrollbar(int orient) const + { + return (m_windowStyle & + (orient == wxHORIZONTAL ? wxHSCROLL : wxVSCROLL)) != 0; + } + // configure the window scrollbars virtual void SetScrollbar( int orient, int pos, - int thumbVisible, + int thumbvisible, int range, bool refresh = TRUE ) = 0; virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE ) = 0; @@ -568,8 +683,36 @@ public: virtual void ScrollWindow( int dx, int dy, const wxRect* rect = (wxRect *) NULL ) = 0; + // scrolls window by line/page: note that not all controls support this + // + // return TRUE if the position changed, FALSE otherwise + virtual bool ScrollLines(int WXUNUSED(lines)) { return FALSE; } + virtual bool ScrollPages(int WXUNUSED(pages)) { return FALSE; } + + // convenient wrappers for ScrollLines/Pages + bool LineUp() { return ScrollLines(-1); } + bool LineDown() { return ScrollLines(1); } + bool PageUp() { return ScrollPages(-1); } + bool PageDown() { return ScrollPages(1); } + + // context-sensitive help + // ---------------------- + + // these are the convenience functions wrapping wxHelpProvider methods + +#if wxUSE_HELP + // associate this help text with this window + void SetHelpText(const wxString& text); + // associate this help text with all windows with the same id as this + // one + void SetHelpTextForId(const wxString& text); + // get the help string associated with this window (may be empty) + wxString GetHelpText() const; +#endif // wxUSE_HELP + // tooltips // -------- + #if wxUSE_TOOLTIPS // the easiest way to set a tooltip for a window is to use this method void SetToolTip( const wxString &tip ); @@ -595,15 +738,6 @@ public: void SetConstraints( wxLayoutConstraints *constraints ); wxLayoutConstraints *GetConstraints() const { return m_constraints; } - // when using constraints, it makes sense to update children positions - // automatically whenever the window is resized - this is done if - // autoLayout is on - void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; } - bool GetAutoLayout() const { return m_autoLayout; } - - // do layout the window and its children - virtual bool Layout(); - // implementation only void UnsetConstraints(wxLayoutConstraints *c); wxWindowList *GetConstraintsInvolvedIn() const @@ -626,11 +760,26 @@ public: virtual void GetClientSizeConstraint(int *w, int *h) const ; virtual void GetPositionConstraint(int *x, int *y) const ; +#endif // wxUSE_CONSTRAINTS + + // when using constraints or sizers, it makes sense to update + // children positions automatically whenever the window is resized + // - this is done if autoLayout is on + void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; } + bool GetAutoLayout() const { return m_autoLayout; } + + // lay out the window and its children + virtual bool Layout(); + // sizers - // TODO: what are they and how do they work?? - void SetSizer( wxSizer *sizer ); + void SetSizer(wxSizer *sizer, bool deleteOld = TRUE ); + void SetSizerAndFit( wxSizer *sizer, bool deleteOld = TRUE ); + wxSizer *GetSizer() const { return m_windowSizer; } -#endif // wxUSE_CONSTRAINTS + + // Track if this window is a member of a sizer + void SetContainingSizer(wxSizer* sizer) { m_containingSizer = sizer; } + wxSizer *GetContainingSizer() const { return m_containingSizer; } // backward compatibility // ---------------------- @@ -649,13 +798,34 @@ public: // event handlers void OnSysColourChanged( wxSysColourChangedEvent& event ); void OnInitDialog( wxInitDialogEvent &event ); + void OnMiddleClick( wxMouseEvent& event ); +#if wxUSE_HELP + void OnHelp(wxHelpEvent& event); +#endif // wxUSE_HELP // get the haqndle of the window for the underlying window system: this // is only used for wxWin itself or for user code which wants to call // platform-specific APIs virtual WXWidget GetHandle() const = 0; +#if wxUSE_PALETTE + // Store the palette used by DCs in wxWindow so that the dcs can share + // a palette. And we can respond to palette messages. + wxPalette GetPalette() const { return m_palette; } + + // When palette is changed tell the DC to set the system palette to the + // new one. + void SetPalette(const wxPalette& pal); + + // return true if we have a specific palette + bool HasCustomPalette() const { return m_hasCustomPalette; } + + // return the first parent window with a custom palette or NULL + wxWindow *GetAncestorWithCustomPalette() const; +#endif // wxUSE_PALETTE + protected: + // the window id - a number which uniquely identifies a window among // its siblings unless it is -1 wxWindowID m_windowId; @@ -700,17 +870,6 @@ protected: wxAcceleratorTable m_acceleratorTable; #endif // wxUSE_ACCEL - // user data associated with the window: either an object which will be - // deleted by the window when it's deleted or some raw pointer which we do - // nothing with - only one type of data can be used with the given window - // (i.e. you cannot set the void data and then associate the window with - // wxClientData or vice versa) - union - { - wxClientData *m_clientObject; - void *m_clientData; - }; - // the tooltip for this window (may be NULL) #if wxUSE_TOOLTIPS wxToolTip *m_tooltip; @@ -723,52 +882,73 @@ protected: // constraints this window is involved in wxWindowList *m_constraintsInvolvedIn; +#endif // wxUSE_CONSTRAINTS - // top level and the parent sizers - // TODO what's this and how does it work?) + // this window's sizer wxSizer *m_windowSizer; - wxWindowBase *m_sizerParent; + + // The sizer this window is a member of, if any + wxSizer *m_containingSizer; // Layout() window automatically when its size changes? bool m_autoLayout:1; -#endif // wxUSE_CONSTRAINTS // window state bool m_isShown:1; bool m_isEnabled:1; bool m_isBeingDeleted:1; + // was the window colours/font explicitly changed by user? + bool m_hasBgCol:1; + bool m_hasFgCol:1; + bool m_hasFont:1; + // window attributes - long m_windowStyle; + long m_windowStyle, + m_exStyle; wxString m_windowName; + bool m_themeEnabled; + +#if wxUSE_PALETTE + wxPalette m_palette; + bool m_hasCustomPalette; +#endif // wxUSE_PALETTE + + // Virtual size (scrolling) + wxSize m_virtualSize; + + int m_minVirtualWidth; // VirtualSizeHints + int m_minVirtualHeight; + int m_maxVirtualWidth; + int m_maxVirtualHeight; -protected: // common part of all ctors: it is not virtual because it is called from // ctor void InitBase(); + // override this to change the default (i.e. used when no style is + // specified) border for the window class + virtual wxBorder GetDefaultBorder() const; + // get the default size for the new window if no explicit size given // FIXME why 20 and not 30, 10 or ...? static int WidthDefault(int w) { return w == -1 ? 20 : w; } static int HeightDefault(int h) { return h == -1 ? 20 : h; } - // sets the size to be size but take width and/or height from - // DoGetBestSize() if width/height of size is -1 - // - // NB: when calling this function from the ctor, the DoGetBestSize() of - // the class with the same name as the ctor, not the real (most - // derived) one - but this is what we usually want - void SetSizeOrDefault(const wxSize& size = wxDefaultSize) + // set the best size for the control if the default size was given: + // replaces the fields of size == -1 with the best values for them and + // calls SetSize() if needed + void SetBestSize(const wxSize& size) { if ( size.x == -1 || size.y == -1 ) { - wxSize sizeDef = GetBestSize(); - SetSize( size.x == -1 ? sizeDef.x : size.x, - size.y == -1 ? sizeDef.y : size.y); - } - else - { - SetSize(size); + wxSize sizeBest = DoGetBestSize(); + if ( size.x != -1 ) + sizeBest.x = size.x; + if ( size.y != -1 ) + sizeBest.y = size.y; + + SetSize(sizeBest); } } @@ -788,6 +968,12 @@ protected: virtual void DoClientToScreen( int *x, int *y ) const = 0; virtual void DoScreenToClient( int *x, int *y ) const = 0; + virtual wxHitTest DoHitTest(wxCoord x, wxCoord y) const; + + // capture/release the mouse, used by Capture/ReleaseMouse() + virtual void DoCaptureMouse() = 0; + virtual void DoReleaseMouse() = 0; + // retrieve the position/size of the window virtual void DoGetPosition( int *x, int *y ) const = 0; virtual void DoGetSize( int *width, int *height ) const = 0; @@ -818,28 +1004,25 @@ protected: virtual void DoSetToolTip( wxToolTip *tip ); #endif // wxUSE_TOOLTIPS +#if wxUSE_MENUS virtual bool DoPopupMenu( wxMenu *menu, int x, int y ) = 0; +#endif // wxUSE_MENUS - // client data accessors - virtual void DoSetClientObject( wxClientData *data ); - virtual wxClientData *DoGetClientObject() const; + // Makes an adjustment to the window position (for example, a frame that has + // a toolbar that it manages itself). + virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) const; - virtual void DoSetClientData( void *data ); - virtual void *DoGetClientData() const; - - // what kind of data do we have? - enum wxClientDataType - { - ClientData_None, // we don't know yet because we don't have it at all - ClientData_Object, // our client data is typed and we own it - ClientData_Void // client data is untyped and we don't own it - } m_clientDataType; private: + // contains the last id generated by NewControlId static int ms_lastControlId; - DECLARE_NO_COPY_CLASS(wxWindowBase); + // the stack of windows which have captured the mouse + static struct WXDLLEXPORT wxWindowNext *ms_winCaptureNext; + + DECLARE_ABSTRACT_CLASS(wxWindowBase) + DECLARE_NO_COPY_CLASS(wxWindowBase) DECLARE_EVENT_TABLE() }; @@ -847,20 +1030,69 @@ private: // now include the declaration of wxWindow class // ---------------------------------------------------------------------------- +// include the declaration of the platform-specific class #if defined(__WXMSW__) + #ifdef __WXUNIVERSAL__ + #define wxWindowNative wxWindowMSW + #else // !wxUniv + #define wxWindowMSW wxWindow + #define sm_classwxWindowMSW sm_classwxWindow + #endif // wxUniv/!wxUniv #include "wx/msw/window.h" #elif defined(__WXMOTIF__) #include "wx/motif/window.h" #elif defined(__WXGTK__) + #ifdef __WXUNIVERSAL__ + #define wxWindowNative wxWindowGTK + #else // !wxUniv + #define wxWindowGTK wxWindow + #define sm_classwxWindowGTK sm_classwxWindow + #endif // wxUniv #include "wx/gtk/window.h" -#elif defined(__WXQT__) - #include "wx/qt/window.h" +#elif defined(__WXX11__) + #ifdef __WXUNIVERSAL__ + #define wxWindowNative wxWindowX11 + #else // !wxUniv + #define wxWindowX11 wxWindow + #define sm_classwxWindowX11 sm_classwxWindow + #endif // wxUniv + #include "wx/x11/window.h" +#elif defined(__WXMGL__) + #ifdef __WXUNIVERSAL__ + #define wxWindowNative wxWindowMGL + #else // !wxUniv + #define wxWindowMGL wxWindow + #define sm_classwxWindowMGL sm_classwxWindow + #endif // wxUniv + #include "wx/mgl/window.h" #elif defined(__WXMAC__) + #ifdef __WXUNIVERSAL__ + #define wxWindowNative wxWindowMac + #else // !wxUniv + #define wxWindowMac wxWindow + #define sm_classwxWindowMac sm_classwxWindow + #endif // wxUniv #include "wx/mac/window.h" #elif defined(__WXPM__) + #ifdef __WXUNIVERSAL__ + #define wxWindowNative wxWindowOS2 + #else // !wxUniv + #define wxWindowOS2 wxWindow + #define sm_classwxWindowOS2 sm_classwxWindow + #endif // wxUniv/!wxUniv #include "wx/os2/window.h" #endif +// for wxUniversal, we now derive the real wxWindow from wxWindow, +// for the native ports we already have defined it above +#if defined(__WXUNIVERSAL__) + #ifndef wxWindowNative + #error "wxWindowNative must be defined above!" + #endif + + #include "wx/univ/window.h" +#endif // wxUniv + // ---------------------------------------------------------------------------- // inline functions which couldn't be declared in the class body because of // forward dependencies @@ -872,13 +1104,25 @@ inline wxWindow *wxWindowBase::GetGrandParent() const } // ---------------------------------------------------------------------------- -// global function +// global functions // ---------------------------------------------------------------------------- -WXDLLEXPORT extern wxWindow* wxGetActiveWindow(); +// Find the wxWindow at the current mouse position, also returning the mouse +// position. +WXDLLEXPORT extern wxWindow* wxFindWindowAtPointer(wxPoint& pt); + +// Get the current mouse position. +WXDLLEXPORT extern wxPoint wxGetMousePosition(); + +// get the currently active window of this application or NULL +WXDLLEXPORT extern wxWindow *wxGetActiveWindow(); + +// get the (first) top level parent window +WXDLLEXPORT wxWindow* wxGetTopLevelParent(wxWindow *win); // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId() -inline WXDLLEXPORT int NewControlId() { return wxWindowBase::NewControlId(); } +inline int NewControlId() { return wxWindowBase::NewControlId(); } #endif // _WX_WINDOW_H_BASE_ +