// 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/validate.h" // for wxDefaultValidator (always include it)
#if wxUSE_PALETTE
- #include "wx/dcclient.h"
- #include "wx/palette.h"
+ #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__
class WXDLLEXPORT wxWindowBase;
class WXDLLEXPORT wxWindow;
+#if wxUSE_ACCESSIBILITY
+class WXDLLEXPORT wxAccessible;
+#endif
+
// ----------------------------------------------------------------------------
// (pseudo)template list classes
// ----------------------------------------------------------------------------
*h = s.y;
}
- // the generic centre function - centers the window on parent by
+ // 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 );
// 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; }
// 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
// ------------
// 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 */;
virtual wxWindow *SetDefaultItem(wxWindow * WXUNUSED(child))
{ return NULL; }
+ // set this child as temporary default
+ virtual void SetTmpDefaultItem(wxWindow * WXUNUSED(win)) { }
+
// parent/children relations
// -------------------------
// 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( 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 id, 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
// -------------------
// sizers
void SetSizer(wxSizer *sizer, bool deleteOld = TRUE );
+ void SetSizerAndFit( wxSizer *sizer, bool deleteOld = TRUE );
+
wxSizer *GetSizer() const { return m_windowSizer; }
// Track if this window is a member of a sizer
void SetContainingSizer(wxSizer* sizer) { m_containingSizer = sizer; }
wxSizer *GetContainingSizer() const { return m_containingSizer; }
+ // 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
// ----------------------
#if WXWIN_COMPATIBILITY
#endif // wxUSE_PALETTE
protected:
+#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()
bool m_hasCustomPalette;
#endif // wxUSE_PALETTE
-protected:
+#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;
// common part of all ctors: it is not virtual because it is called from
// ctor
// 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();
// 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
+// ----------------------------------------------------------------------------
+
+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* childId);
+
+ // 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_
-// vi:sts=4:sw=4:et
projects / wxWidgets.git / blobdiff