///////////////////////////////////////////////////////////////////////////////
-// 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
#ifndef _WX_WINDOW_H_BASE_
#define _WX_WINDOW_H_BASE_
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "windowbase.h"
#endif
#include "wx/font.h" // so we can't do without them
#include "wx/colour.h"
#include "wx/region.h"
+#include "wx/utils.h"
+
+#include "wx/validate.h" // for wxDefaultValidator (always include it)
+
+#if wxUSE_PALETTE
+ #include "wx/palette.h"
+#endif // wxUSE_PALETTE
#if wxUSE_ACCEL
#include "wx/accel.h"
#endif // wxUSE_ACCEL
+#if wxUSE_ACCESSIBILITY
+#include "wx/access.h"
+#endif
+
+// 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;
class WXDLLEXPORT wxResourceTable;
class WXDLLEXPORT wxSizer;
class WXDLLEXPORT wxToolTip;
-class WXDLLEXPORT wxValidator;
class WXDLLEXPORT wxWindowBase;
class WXDLLEXPORT wxWindow;
+#if wxUSE_ACCESSIBILITY
+class WXDLLEXPORT wxAccessible;
+#endif
+
// ----------------------------------------------------------------------------
// (pseudo)template list classes
// ----------------------------------------------------------------------------
-WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode);
+WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode, class WXDLLEXPORT);
// ----------------------------------------------------------------------------
// global variables
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.
class WXDLLEXPORT wxWindowBase : public wxEvtHandler
{
- DECLARE_ABSTRACT_CLASS(wxWindowBase);
-
public:
// creating the window
// -------------------
// pseudo ctor (can't be virtual, called from ctor)
bool CreateBase(wxWindowBase *parent,
- wxWindowID id,
+ wxWindowID winid,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxPanelNameStr);
virtual ~wxWindowBase();
-#if wxUSE_WX_RESOURCES
- // these functions are implemented in resource.cpp and resourc2.cpp
- virtual bool LoadFromResource(wxWindow *parent,
- const wxString& resourceName,
- const wxResourceTable *table = (const wxResourceTable *) NULL);
- virtual wxControl *CreateItem(const wxItemResource* childResource,
- const wxItemResource* parentResource,
- const wxResourceTable *table = (const wxResourceTable *) NULL);
-#endif // wxUSE_WX_RESOURCES
-
// deleting the window
// -------------------
// 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)
// window id uniquely identifies the window among its siblings unless
// it is -1 which means "don't care"
- void SetId( wxWindowID id ) { m_windowId = id; }
+ void SetId( wxWindowID winid ) { m_windowId = winid; }
wxWindowID GetId() const { return m_windowId; }
// generate a control id for the controls which were not given one by
static int NewControlId() { return --ms_lastControlId; }
// get the id of the control following the one with the given
// (autogenerated) id
- static int NextControlId(int id) { return id - 1; }
+ static int NextControlId(int winid) { return winid - 1; }
// get the id of the control preceding the one with the given
// (autogenerated) id
- static int PrevControlId(int id) { return id + 1; }
+ static int PrevControlId(int winid) { return winid + 1; }
// moving/resizing
// ---------------
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;
return wxSize(w, h);
}
- // centre with respect to the the parent window
+ // 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(); }
+ void GetBestSize(int *w, int *h) const
+ {
+ wxSize s = DoGetBestSize();
+ if ( w )
+ *w = s.x;
+ if ( h )
+ *h = s.y;
+ }
+
+ // There are times (and windows) where 'Best' size and 'Min' size
+ // are vastly out of sync. This should be remedied somehow, but in
+ // the meantime, this method will return the larger of BestSize
+ // (the window's smallest legible size), and any user specified
+ // MinSize hint.
+ wxSize GetAdjustedBestSize() const
+ {
+ wxSize s( DoGetBestSize() );
+ return wxSize( wxMax( s.x, GetMinWidth() ), wxMax( s.y, GetMinHeight() ) );
+ }
+
+ // 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();
+ // set virtual size to satisfy children
+ virtual void FitInside();
+
// set min/max size of the window
virtual void SetSizeHints( int minW, int minH,
int maxW = -1, int maxH = -1,
int incW = -1, int incH = -1 );
+ 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; }
+
+ // Return the largest of ClientSize and BestSize (as determined
+ // by a sizer, interior children, or other means)
+
+ virtual wxSize GetBestVirtualSize() const
+ {
+ wxSize client( GetClientSize() );
+ wxSize best( GetBestSize() );
+
+ return wxSize( wxMax( client.x, best.x ), wxMax( client.y, best.y ) );
+ }
+
// window state
// ------------
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 <Enter>
+ virtual wxWindow *GetDefaultItem() const { return NULL; }
+
+ // set this child as default, return the old default
+ virtual wxWindow *SetDefaultItem(wxWindow * WXUNUSED(child))
+ { return NULL; }
+
+ // set this child as temporary default
+ virtual void SetTmpDefaultItem(wxWindow * WXUNUSED(win)) { }
+
// parent/children relations
// -------------------------
inline wxWindow *GetGrandParent() const;
// is this window a top level one?
- bool IsTopLevel() const;
+ virtual bool IsTopLevel() const;
// it doesn't really change parent, use ReParent() instead
void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; }
// was changed, FALSE otherwise (error or newParent == oldParent)
virtual bool Reparent( wxWindowBase *newParent );
+ // implementation mostly
+ virtual void AddChild( wxWindowBase *child );
+ virtual void RemoveChild( wxWindowBase *child );
+
+ // looking for windows
+ // -------------------
+
// find window among the descendants of this one either by id or by
// name (return NULL if not found)
- wxWindow *FindWindow( long id );
+ wxWindow *FindWindow( long winid );
wxWindow *FindWindow( const wxString& name );
- // implementation mostly
- virtual void AddChild( wxWindowBase *child );
- virtual void RemoveChild( wxWindowBase *child );
+ // Find a window among any window (all return NULL if not found)
+ static wxWindow *FindWindowById( long winid, const wxWindow *parent = NULL );
+ static wxWindow *FindWindowByName( const wxString& name,
+ const wxWindow *parent = NULL );
+ static wxWindow *FindWindowByLabel( const wxString& label,
+ const wxWindow *parent = NULL );
// event handler stuff
// -------------------
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
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
- virtual void SetClientObject( wxClientData *data )
- {
- if ( m_clientObject )
- delete m_clientObject;
-
- m_clientObject = data;
- }
- virtual wxClientData *GetClientObject() const { return m_clientObject; }
-
- virtual void SetClientData( void *data ) { m_clientData = data; }
- virtual void *GetClientData() const { return m_clientData; }
// dialog oriented functions
// -------------------------
{ m_acceleratorTable = accel; }
wxAcceleratorTable *GetAcceleratorTable()
{ return &m_acceleratorTable; }
+
#endif // wxUSE_ACCEL
+#if wxUSE_HOTKEY
+ // hot keys (system wide accelerators)
+ // -----------------------------------
+
+ virtual bool RegisterHotKey(int hotkeyId, int modifiers, int keycode);
+ virtual bool UnregisterHotKey(int hotkeyId);
+#endif // wxUSE_HOTKEY
+
+
// dialog units translations
// -------------------------
// 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
// -------------------
// 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) ) { }
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;
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;
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
// ----
- void UpdateWindowUI();
+ // get the window border style from the given flags: this is different from
+ // simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to
+ // translate wxBORDER_DEFAULT to something reasonable
+ wxBorder GetBorder(long flags) const;
+ // get border for the flags of this window
+ wxBorder GetBorder() const { return GetBorder(GetWindowStyleFlag()); }
+
+ // send wxUpdateUIEvents to this window, and children if recurse is TRUE
+ virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE);
+
+ // do the window-specific processing after processing the update event
+ virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ;
+
+#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;
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 );
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
virtual void SetConstraintSizes(bool recurse = TRUE);
virtual bool LayoutPhase1(int *noChanges);
virtual bool LayoutPhase2(int *noChanges);
- virtual bool DoPhase(int);
+ virtual bool DoPhase(int phase);
// these methods are virtual but normally won't be overridden
- virtual void TransformSizerToActual(int *x, int *y) const ;
virtual void SetSizeConstraint(int x, int y, int w, int h);
virtual void MoveConstraint(int x, int y);
virtual void GetSizeConstraint(int *w, int *h) const ;
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; }
- void SetSizerParent( wxWindowBase *win ) { m_sizerParent = win; }
- wxWindowBase *GetSizerParent() const { return m_sizerParent; }
+ // Track if this window is a member of a sizer
+ void SetContainingSizer(wxSizer* sizer) { m_containingSizer = sizer; }
+ wxSizer *GetContainingSizer() const { return m_containingSizer; }
- virtual void SizerSetSize(int x, int y, int w, int h);
- virtual void SizerMove(int x, int y);
-#endif // wxUSE_CONSTRAINTS
+ // accessibility
+ // ----------------------
+#if wxUSE_ACCESSIBILITY
+ // Override to create a specific accessible object.
+ virtual wxAccessible* CreateAccessible();
+
+ // Sets the accessible object.
+ void SetAccessible(wxAccessible* accessible) ;
+
+ // Returns the accessible object.
+ wxAccessible* GetAccessible() { return m_accessible; };
+
+ // Returns the accessible object, creating if necessary.
+ wxAccessible* GetOrCreateAccessible() ;
+#endif
// backward compatibility
// ----------------------
// event handlers
void OnSysColourChanged( wxSysColourChangedEvent& event );
void OnInitDialog( wxInitDialogEvent &event );
+ void OnMiddleClick( wxMouseEvent& event );
+#if wxUSE_HELP
+ void OnHelp(wxHelpEvent& event);
+#endif // wxUSE_HELP
+
+ // virtual function for implementing internal idle
+ // behaviour
+ virtual void OnInternalIdle() {}
+
+ // call internal idle recursively
+// void ProcessInternalIdle() ;
- // get the haqndle of the window for the underlying window system: this
+ // get the handle 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:
+ // event handling specific to wxWindow
+#if wxUSE_VALIDATORS
+ virtual bool TryValidator(wxEvent& event);
+#endif // wxUSE_VALIDATORS
+ virtual bool TryParent(wxEvent& event);
+
+
+#if wxUSE_CONSTRAINTS
+ // satisfy the constraints for the windows but don't set the window sizes
+ void SatisfyConstraints();
+#endif // wxUSE_CONSTRAINTS
+
+ // Send the wxWindowDestroyEvent
+ void SendDestroyEvent();
+
// the window id - a number which uniquely identifies a window among
// its siblings unless it is -1
wxWindowID m_windowId;
// the minimal allowed size for the window (no minimal size if variable(s)
// contain(s) -1)
- int m_minWidth, m_minHeight, m_maxWidth, m_maxHeight;
+ int m_minWidth,
+ m_minHeight,
+ m_maxWidth,
+ m_maxHeight;
// event handler for this window: usually is just 'this' but may be
// changed with SetEventHandler()
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
- wxClientData *m_clientObject;
- void *m_clientData;
-
// the tooltip for this window (may be NULL)
#if wxUSE_TOOLTIPS
wxToolTip *m_tooltip;
// 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
+
+#if wxUSE_ACCESSIBILITY
+ wxAccessible* m_accessible;
+#endif
+ // 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; }
+ // 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
+ //
+ // This function is rather unfortunately named.. it's really just a
+ // smarter SetSize / convenience function for expanding wxDefaultSize.
+ // Note that it does not influence the value returned by GetBestSize
+ // at all.
+ void SetBestSize(const wxSize& size)
+ {
+ // the size only needs to be changed if the current size is incomplete,
+ // i.e. one of the components was specified as default -- so if both
+ // were given, simply don't do anything
+ if ( size.x == -1 || size.y == -1 )
+ {
+ wxSize sizeBest = DoGetBestSize();
+ if ( size.x != -1 )
+ sizeBest.x = size.x;
+ if ( size.y != -1 )
+ sizeBest.y = size.y;
+
+ SetSize(sizeBest);
+ }
+ }
+
// more pure virtual functions
// ---------------------------
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;
virtual void DoGetClientSize( int *width, int *height ) const = 0;
+ // get the size which best suits the window: for a control, it would be
+ // the minimal size which doesn't truncate the control, for a panel - the
+ // same size as it would have after a call to Fit()
+ virtual wxSize DoGetBestSize() const;
+
// this is the virtual function to be overriden in any derived class which
// wants to change how SetSize() or Move() works - it is called by all
// versions of these functions in the base class
// same as DoSetSize() for the client size
virtual void DoSetClientSize(int width, int height) = 0;
+ // move the window to the specified location and resize it: this is called
+ // from both DoSetSize() and DoSetClientSize() and would usually just
+ // reposition this window except for composite controls which will want to
+ // arrange themselves inside the given rectangle
+ virtual void DoMoveWindow(int x, int y, int width, int height) = 0;
+
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip );
#endif // wxUSE_TOOLTIPS
+#if wxUSE_MENUS
virtual bool DoPopupMenu( wxMenu *menu, int x, int y ) = 0;
+#endif // wxUSE_MENUS
+
+ // 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;
+
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()
};
// 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(__WXCOCOA__)
+ #ifdef __WXUNIVERSAL__
+ #define wxWindowNative wxWindowCocoa
+ #else // !wxUniv
+ #define wxWindowCocoa wxWindow
+ #define sm_classwxWindowCocoa sm_classwxWindow
+ #endif // wxUniv
+ #include "wx/cocoa/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<platform>,
+// 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
}
// ----------------------------------------------------------------------------
-// global function
+// global functions
+// ----------------------------------------------------------------------------
+
+// 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 int NewControlId() { return wxWindowBase::NewControlId(); }
+
+#if wxUSE_ACCESSIBILITY
+// ----------------------------------------------------------------------------
+// accessible object for windows
// ----------------------------------------------------------------------------
-WXDLLEXPORT extern wxWindow* wxGetActiveWindow();
-inline WXDLLEXPORT int NewControlId() { return wxWindowBase::NewControlId(); }
+class WXDLLEXPORT wxWindowAccessible: public wxAccessible
+{
+public:
+ wxWindowAccessible(wxWindow* win): wxAccessible(win) { if (win) win->SetAccessible(this); }
+ virtual ~wxWindowAccessible() {};
+
+// Overridables
+
+ // Can return either a child object, or an integer
+ // representing the child element, starting from 1.
+ virtual wxAccStatus HitTest(const wxPoint& pt, int* childId, wxAccessible** childObject);
+
+ // Returns the rectangle for this object (id = 0) or a child element (id > 0).
+ virtual wxAccStatus GetLocation(wxRect& rect, int elementId);
+
+ // Navigates from fromId to toId/toObject.
+ virtual wxAccStatus Navigate(wxNavDir navDir, int fromId,
+ int* toId, wxAccessible** toObject);
+
+ // Gets the name of the specified object.
+ virtual wxAccStatus GetName(int childId, wxString* name);
+
+ // Gets the number of children.
+ virtual wxAccStatus GetChildCount(int* childCount);
+
+ // Gets the specified child (starting from 1).
+ // If *child is NULL and return value is wxACC_OK,
+ // this means that the child is a simple element and
+ // not an accessible object.
+ virtual wxAccStatus GetChild(int childId, wxAccessible** child);
+
+ // Gets the parent, or NULL.
+ virtual wxAccStatus GetParent(wxAccessible** parent);
+
+ // Performs the default action. childId is 0 (the action for this object)
+ // or > 0 (the action for a child).
+ // Return wxACC_NOT_SUPPORTED if there is no default action for this
+ // window (e.g. an edit control).
+ virtual wxAccStatus DoDefaultAction(int childId);
+
+ // Gets the default action for this object (0) or > 0 (the action for a child).
+ // Return wxACC_OK even if there is no action. actionName is the action, or the empty
+ // string if there is no action.
+ // The retrieved string describes the action that is performed on an object,
+ // not what the object does as a result. For example, a toolbar button that prints
+ // a document has a default action of "Press" rather than "Prints the current document."
+ virtual wxAccStatus GetDefaultAction(int childId, wxString* actionName);
+
+ // Returns the description for this object or a child.
+ virtual wxAccStatus GetDescription(int childId, wxString* description);
+
+ // Returns help text for this object or a child, similar to tooltip text.
+ virtual wxAccStatus GetHelpText(int childId, wxString* helpText);
+
+ // Returns the keyboard shortcut for this object or child.
+ // Return e.g. ALT+K
+ virtual wxAccStatus GetKeyboardShortcut(int childId, wxString* shortcut);
+
+ // Returns a role constant.
+ virtual wxAccStatus GetRole(int childId, wxAccRole* role);
+
+ // Returns a state constant.
+ virtual wxAccStatus GetState(int childId, long* state);
+
+ // Returns a localized string representing the value for the object
+ // or child.
+ virtual wxAccStatus GetValue(int childId, wxString* strValue);
+
+ // Selects the object or child.
+ virtual wxAccStatus Select(int childId, wxAccSelectionFlags selectFlags);
+
+ // Gets the window with the keyboard focus.
+ // If childId is 0 and child is NULL, no object in
+ // this subhierarchy has the focus.
+ // If this object has the focus, child should be 'this'.
+ virtual wxAccStatus GetFocus(int* childId, wxAccessible** child);
+
+ // Gets a variant representing the selected children
+ // of this object.
+ // Acceptable values:
+ // - a null variant (IsNull() returns TRUE)
+ // - a list variant (GetType() == wxT("list")
+ // - an integer representing the selected child element,
+ // or 0 if this object is selected (GetType() == wxT("long")
+ // - a "void*" pointer to a wxAccessible child object
+ virtual wxAccStatus GetSelections(wxVariant* selections);
+};
+
+#endif // wxUSE_ACCESSIBILITY
+
#endif
// _WX_WINDOW_H_BASE_
+
projects / wxWidgets.git / blobdiff