X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3f562374f11048ff0005b7229683b3804d2208d2..ad05b1880e5b7047b1de265f48fb104f73564119:/src/common/wincmn.cpp diff --git a/src/common/wincmn.cpp b/src/common/wincmn.cpp index 5b677218c7..34bb9d4924 100644 --- a/src/common/wincmn.cpp +++ b/src/common/wincmn.cpp @@ -6,7 +6,7 @@ // Created: 13/07/98 // RCS-ID: $Id$ // Copyright: (c) wxWindows team -// Licence: wxWindows license +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -17,7 +17,7 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) #pragma implementation "windowbase.h" #endif @@ -38,22 +38,33 @@ #include "wx/control.h" #include "wx/checkbox.h" #include "wx/radiobut.h" + #include "wx/statbox.h" #include "wx/textctrl.h" #include "wx/settings.h" #include "wx/dialog.h" #include "wx/msgdlg.h" #include "wx/statusbr.h" + #include "wx/dcclient.h" #endif //WX_PRECOMP +#if defined(__WXMAC__) && wxUSE_SCROLLBAR + #include "wx/scrolbar.h" +#endif + #if wxUSE_CONSTRAINTS #include "wx/layout.h" - #include "wx/sizer.h" #endif // wxUSE_CONSTRAINTS +#include "wx/sizer.h" + #if wxUSE_DRAG_AND_DROP #include "wx/dnd.h" #endif // wxUSE_DRAG_AND_DROP +#if wxUSE_ACCESSIBILITY + #include "wx/access.h" +#endif + #if wxUSE_HELP #include "wx/cshelp.h" #endif // wxUSE_HELP @@ -70,7 +81,11 @@ // static data // ---------------------------------------------------------------------------- +#if defined(__WXPM__) +int wxWindowBase::ms_lastControlId = 2000; +#else int wxWindowBase::ms_lastControlId = -200; +#endif IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler) @@ -84,7 +99,7 @@ BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler) EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick) #if wxUSE_HELP - EVT_HELP(-1, wxWindowBase::OnHelp) + EVT_HELP(wxID_ANY, wxWindowBase::OnHelp) #endif // wxUSE_HELP END_EVENT_TABLE() @@ -98,12 +113,11 @@ END_EVENT_TABLE() // ---------------------------------------------------------------------------- // the default initialization -void wxWindowBase::InitBase() +wxWindowBase::wxWindowBase() { // no window yet, no parent nor children m_parent = (wxWindow *)NULL; - m_windowId = -1; - m_children.DeleteContents( FALSE ); // don't auto delete node data + m_windowId = wxID_ANY; // no constraints on the minimal window size m_minWidth = @@ -111,9 +125,9 @@ void wxWindowBase::InitBase() m_maxWidth = m_maxHeight = -1; - // window is created enabled but it's not visible yet - m_isShown = FALSE; - m_isEnabled = TRUE; + // window are created enabled and visible by default + m_isShown = + m_isEnabled = true; // the default event handler is just this window m_eventHandler = this; @@ -123,38 +137,26 @@ void wxWindowBase::InitBase() m_windowValidator = (wxValidator *) NULL; #endif // wxUSE_VALIDATORS - // use the system default colours - m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE); - m_foregroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT); - - // don't set the font here for wxMSW as we don't call WM_SETFONT here and - // so the font is *not* really set - but calls to SetFont() later won't do - // anything because m_font appears to be already set! -#ifndef __WXMSW__ - m_font = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT); -#endif // __WXMSW__ - - // the colours/fonts are default for now + // the colours/fonts are default for now, so leave m_font, + // m_backgroundColour and m_foregroundColour uninitialized and set those m_hasBgCol = m_hasFgCol = - m_hasFont = FALSE; + m_hasFont = false; // no style bits m_exStyle = m_windowStyle = 0; - // an optimization for the event processing: checking this flag is much - // faster than using IsKindOf(CLASSINFO(wxWindow)) - m_isWindow = TRUE; - #if wxUSE_CONSTRAINTS // no constraints whatsoever m_constraints = (wxLayoutConstraints *) NULL; m_constraintsInvolvedIn = (wxWindowList *) NULL; - m_windowSizer = (wxSizer *) NULL; - m_autoLayout = FALSE; #endif // wxUSE_CONSTRAINTS + m_windowSizer = (wxSizer *) NULL; + m_containingSizer = (wxSizer *) NULL; + m_autoLayout = false; + #if wxUSE_DRAG_AND_DROP m_dropTarget = (wxDropTarget *)NULL; #endif // wxUSE_DRAG_AND_DROP @@ -167,8 +169,28 @@ void wxWindowBase::InitBase() m_caret = (wxCaret *)NULL; #endif // wxUSE_CARET +#if wxUSE_PALETTE + m_hasCustomPalette = false; +#endif // wxUSE_PALETTE + +#if wxUSE_ACCESSIBILITY + m_accessible = NULL; +#endif + + m_virtualSize = wxDefaultSize; + + m_minVirtualWidth = + m_minVirtualHeight = + m_maxVirtualWidth = + m_maxVirtualHeight = -1; + + m_windowVariant = wxWINDOW_VARIANT_NORMAL; + // Whether we're using the current theme for this window (wxGTK only for now) - m_themeEnabled = FALSE; + m_themeEnabled = false; + + // VZ: this one shouldn't exist... + m_isBeingDeleted = false; } // common part of window creation process @@ -177,16 +199,28 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent, const wxPoint& WXUNUSED(pos), const wxSize& WXUNUSED(size), long style, - const wxValidator& validator, + const wxValidator& wxVALIDATOR_PARAM(validator), const wxString& name) { - // m_isWindow is set to TRUE in wxWindowBase::Init() as well as many other - // member variables - check that it has been called (will catch the case - // when a new ctor is added which doesn't call InitWindow) - wxASSERT_MSG( m_isWindow, wxT("Init() must have been called before!") ); +#if wxUSE_STATBOX + // wxGTK doesn't allow to create controls with static box as the parent so + // this will result in a crash when the program is ported to wxGTK so warn + // the user about it + + // if you get this assert, the correct solution is to create the controls + // as siblings of the static box + wxASSERT_MSG( !parent || !wxDynamicCast(parent, wxStaticBox), + _T("wxStaticBox can't be used as a window parent!") ); +#endif // wxUSE_STATBOX + + // ids are limited to 16 bits under MSW so if you care about portability, + // it's not a good idea to use ids out of this range (and negative ids are + // reserved for wxWindows own usage) + wxASSERT_MSG( id == wxID_ANY || (id >= 0 && id < 32767), + _T("invalid id value") ); // generate a new id if the user doesn't care about it - m_windowId = id == -1 ? NewControlId() : id; + m_windowId = id == wxID_ANY ? NewControlId() : id; SetName(name); SetWindowStyleFlag(style); @@ -201,10 +235,10 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent, // dialog/frame and all children will inherit it by defult if ( parent && (parent->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) ) { - SetExtraStyle(wxWS_EX_VALIDATE_RECURSIVELY); + SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY); } - return TRUE; + return true; } // ---------------------------------------------------------------------------- @@ -214,6 +248,8 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent, // common clean up wxWindowBase::~wxWindowBase() { + wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") ); + // FIXME if these 2 cases result from programming errors in the user code // we should probably assert here instead of silently fixing them @@ -223,18 +259,27 @@ wxWindowBase::~wxWindowBase() // Just in case we've loaded a top-level window via LoadNativeDialog but // we weren't a dialog class - wxTopLevelWindows.DeleteObject(this); + wxTopLevelWindows.DeleteObject((wxWindow*)this); wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") ); + // reset the dangling pointer our parent window may keep to us + if ( m_parent ) + { + if ( m_parent->GetDefaultItem() == this ) + { + m_parent->SetDefaultItem(NULL); + } + + m_parent->RemoveChild(this); + } + #if wxUSE_CARET - if ( m_caret ) - delete m_caret; + delete m_caret; #endif // wxUSE_CARET #if wxUSE_VALIDATORS - if ( m_windowValidator ) - delete m_windowValidator; + delete m_windowValidator; #endif // wxUSE_VALIDATORS #if wxUSE_CONSTRAINTS @@ -250,53 +295,47 @@ wxWindowBase::~wxWindowBase() delete m_constraints; m_constraints = NULL; } +#endif // wxUSE_CONSTRAINTS - if ( m_windowSizer ) - delete m_windowSizer; + if ( m_containingSizer ) + m_containingSizer->Detach( (wxWindow*)this ); -#endif // wxUSE_CONSTRAINTS + delete m_windowSizer; #if wxUSE_DRAG_AND_DROP - if ( m_dropTarget ) - delete m_dropTarget; + delete m_dropTarget; #endif // wxUSE_DRAG_AND_DROP #if wxUSE_TOOLTIPS - if ( m_tooltip ) - delete m_tooltip; + delete m_tooltip; #endif // wxUSE_TOOLTIPS - // reset the dangling pointer our parent window may keep to us - if ( m_parent && m_parent->GetDefaultItem() == this ) - { - m_parent->SetDefaultItem(NULL); - } +#if wxUSE_ACCESSIBILITY + delete m_accessible; +#endif } bool wxWindowBase::Destroy() { delete this; - return TRUE; + return true; } bool wxWindowBase::Close(bool force) { wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId); event.SetEventObject(this); -#if WXWIN_COMPATIBILITY - event.SetForce(force); -#endif // WXWIN_COMPATIBILITY event.SetCanVeto(!force); - // return FALSE if window wasn't closed because the application vetoed the + // return false if window wasn't closed because the application vetoed the // close event return GetEventHandler()->ProcessEvent(event) && !event.GetVeto(); } bool wxWindowBase::DestroyChildren() { - wxWindowList::Node *node; + wxWindowList::compatibility_iterator node; for ( ;; ) { // we iterate until the list becomes empty @@ -306,16 +345,17 @@ bool wxWindowBase::DestroyChildren() wxWindow *child = node->GetData(); - wxASSERT_MSG( child, wxT("children list contains empty nodes") ); - - child->Show(FALSE); + // note that we really want to call delete and not ->Destroy() here + // because we want to delete the child immediately, before we are + // deleted, and delayed deletion would result in problems as our (top + // level) child could outlive its parent delete child; wxASSERT_MSG( !GetChildren().Find(child), wxT("child didn't remove itself using RemoveChild()") ); } - return TRUE; + return true; } // ---------------------------------------------------------------------------- @@ -345,6 +385,20 @@ void wxWindowBase::Centre(int direction) } } + // there is no wxTopLevelWindow under wxMotif yet +#ifndef __WXMOTIF__ + // we shouldn't center the dialog on the iconized window: under + // Windows, for example, this places it completely off the screen + if ( parent ) + { + wxTopLevelWindow *winTop = wxDynamicCast(parent, wxTopLevelWindow); + if ( winTop && winTop->IsIconized() ) + { + parent = NULL; + } + } +#endif // __WXMOTIF__ + // did we find the parent? if ( !parent ) { @@ -395,14 +449,18 @@ void wxWindowBase::Centre(int direction) wxRect rect = wxGetClientDisplayRect(); wxSize size (rect.width,rect.height); - if (posParent.x >= 0) // if parent is on the main display + // NB: in wxMSW, negative position may not neccessary mean "out of screen", + // but it may mean that the window is placed on other than the main + // display. Therefore we only make sure centered window is on the main display + // if the parent is at least partially present here. + if (posParent.x + widthParent >= 0) // if parent is (partially) on the main display { if (xNew < 0) xNew = 0; else if (xNew+width > size.x) xNew = size.x-width-1; } - if (posParent.y >= 0) // if parent is on the main display + if (posParent.y + heightParent >= 0) // if parent is (partially) on the main display { if (yNew+height > size.y) yNew = size.y-height-1; @@ -424,33 +482,98 @@ void wxWindowBase::Fit() { if ( GetChildren().GetCount() > 0 ) { - wxSize size = DoGetBestSize(); + SetClientSize(DoGetBestSize()); + } + //else: do nothing if we have no children +} - // for compatibility with the old versions and because it really looks - // slightly more pretty like this, add a pad - size.x += 7; - size.y += 14; +// fits virtual size (ie. scrolled area etc.) around children +void wxWindowBase::FitInside() +{ + if ( GetChildren().GetCount() > 0 ) + { + SetVirtualSize( GetBestVirtualSize() ); + } +} - SetClientSize(size); +// On Mac, scrollbars are explicitly children. +#ifdef __WXMAC__ +static bool wxHasRealChildren(const wxWindowBase* win) +{ + int realChildCount = 0; + + for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); + node; + node = node->GetNext() ) + { + wxWindow *win = node->GetData(); + if ( !win->IsTopLevel() && win->IsShown() && !win->IsKindOf(CLASSINFO(wxScrollBar))) + realChildCount ++; } - //else: do nothing if we have no children + return (realChildCount > 0); } +#endif // return the size best suited for the current window wxSize wxWindowBase::DoGetBestSize() const { - if ( GetChildren().GetCount() > 0 ) + if ( m_windowSizer ) + { + return m_windowSizer->GetMinSize(); + } +#if wxUSE_CONSTRAINTS + else if ( m_constraints ) { + wxConstCast(this, wxWindowBase)->SatisfyConstraints(); + // our minimal acceptable size is such that all our windows fit inside int maxX = 0, maxY = 0; - for ( wxWindowList::Node *node = GetChildren().GetFirst(); + for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); + node; + node = node->GetNext() ) + { + wxLayoutConstraints *c = node->GetData()->GetConstraints(); + if ( !c ) + { + // it's not normal that we have an unconstrained child, but + // what can we do about it? + continue; + } + + int x = c->right.GetValue(), + y = c->bottom.GetValue(); + + if ( x > maxX ) + maxX = x; + + if ( y > maxY ) + maxY = y; + + // TODO: we must calculate the overlaps somehow, otherwise we + // will never return a size bigger than the current one :-( + } + + return wxSize(maxX, maxY); + } +#endif // wxUSE_CONSTRAINTS + else if ( !GetChildren().empty() +#ifdef __WXMAC__ + && wxHasRealChildren(this) +#endif + ) + { + // our minimal acceptable size is such that all our visible child windows fit inside + int maxX = 0, + maxY = 0; + + for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext() ) { wxWindow *win = node->GetData(); - if ( win->IsTopLevel() + if ( win->IsTopLevel() || ( ! win->IsShown() ) #if wxUSE_STATUSBAR || wxDynamicCast(win, wxStatusBar) #endif // wxUSE_STATUSBAR @@ -479,14 +602,49 @@ wxSize wxWindowBase::DoGetBestSize() const maxY = wy + wh; } + // for compatibility with the old versions and because it really looks + // slightly more pretty like this, add a pad + maxX += 7; + maxY += 14; + return wxSize(maxX, maxY); } - else + else // ! has children + { + // for a generic window there is no natural best size - just use either the + // minimum size if there is one, or the current size + if ( GetMinSize().IsFullySpecified() ) + return GetMinSize(); + else + return GetSize(); + } +} + +void wxWindowBase::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 and in particular don't call + // potentially expensive DoGetBestSize() + wxSize sizeBest; + if ( size.x == -1 || size.y == -1 ) + { + sizeBest = DoGetBestSize(); + if ( size.x != -1 ) + sizeBest.x = size.x; + if ( size.y != -1 ) + sizeBest.y = size.y; + + SetSize(sizeBest); + } + else // have explicit size { - // for a generic window there is no natural best size - just use the - // current one - return GetSize(); + sizeBest = size; } + + // don't shrink the control below its best size + m_minWidth = sizeBest.x; + m_minHeight = sizeBest.y; } // by default the origin is not shifted @@ -500,12 +658,94 @@ void wxWindowBase::SetSizeHints(int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH)) { + // setting min width greater than max width leads to infinite loops under + // X11 and generally doesn't make any sense, so don't allow it + wxCHECK_RET( (minW == -1 || maxW == -1 || minW <= maxW) && + (minH == -1 || maxH == -1 || minH <= maxH), + _T("min width/height must be less than max width/height!") ); + m_minWidth = minW; m_maxWidth = maxW; m_minHeight = minH; m_maxHeight = maxH; } +void wxWindowBase::SetWindowVariant( wxWindowVariant variant ) +{ + if ( m_windowVariant != variant ) + { + m_windowVariant = variant; + + DoSetWindowVariant(variant); + } +} + +void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant ) +{ + // adjust the font height to correspond to our new variant (notice that + // we're only called if something really changed) + wxFont font = GetFont(); + int size = font.GetPointSize(); + switch ( variant ) + { + case wxWINDOW_VARIANT_NORMAL: + break; + + case wxWINDOW_VARIANT_SMALL: + size *= 3; + size /= 4; + break; + + case wxWINDOW_VARIANT_MINI: + size *= 2; + size /= 3; + break; + + case wxWINDOW_VARIANT_LARGE: + size *= 5; + size /= 4; + break; + + default: + wxFAIL_MSG(_T("unexpected window variant")); + break; + } + + font.SetPointSize(size); + SetFont(font); +} + +void wxWindowBase::SetVirtualSizeHints( int minW, int minH, + int maxW, int maxH ) +{ + m_minVirtualWidth = minW; + m_maxVirtualWidth = maxW; + m_minVirtualHeight = minH; + m_maxVirtualHeight = maxH; +} + +void wxWindowBase::DoSetVirtualSize( int x, int y ) +{ + if ( m_minVirtualWidth != -1 && m_minVirtualWidth > x ) + x = m_minVirtualWidth; + if ( m_maxVirtualWidth != -1 && m_maxVirtualWidth < x ) + x = m_maxVirtualWidth; + if ( m_minVirtualHeight != -1 && m_minVirtualHeight > y ) + y = m_minVirtualHeight; + if ( m_maxVirtualHeight != -1 && m_maxVirtualHeight < y ) + y = m_maxVirtualHeight; + + m_virtualSize = wxSize(x, y); +} + +wxSize wxWindowBase::DoGetVirtualSize() const +{ + wxSize s( GetClientSize() ); + + return wxSize( wxMax( m_virtualSize.GetWidth(), s.GetWidth() ), + wxMax( m_virtualSize.GetHeight(), s.GetHeight() ) ); +} + // ---------------------------------------------------------------------------- // show/hide/enable/disable the window // ---------------------------------------------------------------------------- @@ -516,11 +756,11 @@ bool wxWindowBase::Show(bool show) { m_isShown = show; - return TRUE; + return true; } else { - return FALSE; + return false; } } @@ -530,11 +770,11 @@ bool wxWindowBase::Enable(bool enable) { m_isEnabled = enable; - return TRUE; + return true; } else { - return FALSE; + return false; } } // ---------------------------------------------------------------------------- @@ -543,7 +783,7 @@ bool wxWindowBase::Enable(bool enable) bool wxWindowBase::IsTopLevel() const { - return FALSE; + return false; } // ---------------------------------------------------------------------------- @@ -557,9 +797,9 @@ void wxWindowBase::AddChild(wxWindowBase *child) // this should never happen and it will lead to a crash later if it does // because RemoveChild() will remove only one node from the children list // and the other(s) one(s) will be left with dangling pointers in them - wxASSERT_MSG( !GetChildren().Find(child), _T("AddChild() called twice") ); + wxASSERT_MSG( !GetChildren().Find((wxWindow*)child), _T("AddChild() called twice") ); - GetChildren().Append(child); + GetChildren().Append((wxWindow*)child); child->SetParent(this); } @@ -567,8 +807,8 @@ void wxWindowBase::RemoveChild(wxWindowBase *child) { wxCHECK_RET( child, wxT("can't remove a NULL child") ); - GetChildren().DeleteObject(child); - child->SetParent((wxWindow *)NULL); + GetChildren().DeleteObject((wxWindow *)child); + child->SetParent(NULL); } bool wxWindowBase::Reparent(wxWindowBase *newParent) @@ -577,7 +817,7 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent) if ( newParent == oldParent ) { // nothing done - return FALSE; + return false; } // unlink this window from the existing parent. @@ -587,7 +827,7 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent) } else { - wxTopLevelWindows.DeleteObject(this); + wxTopLevelWindows.DeleteObject((wxWindow *)this); } // add it to the new one @@ -597,10 +837,10 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent) } else { - wxTopLevelWindows.Append(this); + wxTopLevelWindows.Append((wxWindow *)this); } - return TRUE; + return true; } // ---------------------------------------------------------------------------- @@ -609,7 +849,13 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent) void wxWindowBase::PushEventHandler(wxEvtHandler *handler) { - handler->SetNextHandler(GetEventHandler()); + wxEvtHandler *handlerOld = GetEventHandler(); + + handler->SetNextHandler(handlerOld); + + if ( handlerOld ) + GetEventHandler()->SetPreviousHandler(handler); + SetEventHandler(handler); } @@ -620,7 +866,11 @@ wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler) { wxEvtHandler *handlerB = handlerA->GetNextHandler(); handlerA->SetNextHandler((wxEvtHandler *)NULL); + + if ( handlerB ) + handlerB->SetPreviousHandler((wxEvtHandler *)NULL); SetEventHandler(handlerB); + if ( deleteHandler ) { delete handlerA; @@ -631,32 +881,153 @@ wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler) return handlerA; } +bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler) +{ + wxCHECK_MSG( handler, false, _T("RemoveEventHandler(NULL) called") ); + + wxEvtHandler *handlerPrev = NULL, + *handlerCur = GetEventHandler(); + while ( handlerCur ) + { + wxEvtHandler *handlerNext = handlerCur->GetNextHandler(); + + if ( handlerCur == handler ) + { + if ( handlerPrev ) + { + handlerPrev->SetNextHandler(handlerNext); + } + else + { + SetEventHandler(handlerNext); + } + + if ( handlerNext ) + { + handlerNext->SetPreviousHandler ( handlerPrev ); + } + + handler->SetNextHandler(NULL); + handler->SetPreviousHandler(NULL); + + return true; + } + + handlerPrev = handlerCur; + handlerCur = handlerNext; + } + + wxFAIL_MSG( _T("where has the event handler gone?") ); + + return false; +} + // ---------------------------------------------------------------------------- -// cursors, fonts &c +// colours, fonts &c // ---------------------------------------------------------------------------- +void wxWindowBase::InheritAttributes() +{ + const wxWindowBase * const parent = GetParent(); + if ( !parent ) + return; + + // we only inherit attributes which had been explicitly set for the parent + // which ensures that this only happens if the user really wants it and + // not by default which wouldn't make any sense in modern GUIs where the + // controls don't all use the same fonts (nor colours) + if ( parent->m_hasFont && !m_hasFont ) + SetFont(parent->GetFont()); + + // in addition, there is a possibility to explicitly forbid inheriting + // colours at each class level by overriding ShouldInheritColours() + if ( ShouldInheritColours() ) + { + if ( parent->m_hasFgCol && !m_hasFgCol ) + SetForegroundColour(parent->GetForegroundColour()); + + if ( parent->m_hasBgCol && !m_hasBgCol ) + SetBackgroundColour(parent->GetBackgroundColour()); + } +} + +/* static */ wxVisualAttributes +wxWindowBase::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant)) +{ + // it is important to return valid values for all attributes from here, + // GetXXX() below rely on this + wxVisualAttributes attrs; + attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); + attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT); + attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE); + + return attrs; +} + +wxColour wxWindowBase::GetBackgroundColour() const +{ + if ( !m_backgroundColour.Ok() ) + { + wxASSERT_MSG( !m_hasBgCol, _T("we have invalid explicit bg colour?") ); + + // get our default background colour + wxColour colBg = GetDefaultAttributes().colBg; + + // we must return some valid colour to avoid redoing this every time + // and also to avoid surprizing the applications written for older + // wxWindows versions where GetBackgroundColour() always returned + // something -- so give them something even if it doesn't make sense + // for this window (e.g. it has a themed background) + if ( !colBg.Ok() ) + colBg = GetClassDefaultAttributes().colBg; + + // cache it for the next call + wxConstCast(this, wxWindowBase)->m_backgroundColour = colBg; + } + + return m_backgroundColour; +} + +wxColour wxWindowBase::GetForegroundColour() const +{ + // logic is the same as above + if ( !m_hasFgCol && !m_foregroundColour.Ok() ) + { + wxASSERT_MSG( !m_hasFgCol, _T("we have invalid explicit fg colour?") ); + + wxColour colFg = GetDefaultAttributes().colFg; + + if ( !colFg.Ok() ) + colFg = GetClassDefaultAttributes().colFg; + + wxConstCast(this, wxWindowBase)->m_foregroundColour = colFg; + } + + return m_foregroundColour; +} + bool wxWindowBase::SetBackgroundColour( const wxColour &colour ) { if ( !colour.Ok() || (colour == m_backgroundColour) ) - return FALSE; + return false; m_backgroundColour = colour; - m_hasBgCol = TRUE; + m_hasBgCol = true; - return TRUE; + return true; } bool wxWindowBase::SetForegroundColour( const wxColour &colour ) { if ( !colour.Ok() || (colour == m_foregroundColour) ) - return FALSE; + return false; m_foregroundColour = colour; - m_hasFgCol = TRUE; + m_hasFgCol = true; - return TRUE; + return true; } bool wxWindowBase::SetCursor(const wxCursor& cursor) @@ -666,32 +1037,75 @@ bool wxWindowBase::SetCursor(const wxCursor& cursor) if ( m_cursor == cursor ) { // no change - return FALSE; + return false; } m_cursor = cursor; - return TRUE; + return true; +} + +wxFont& wxWindowBase::DoGetFont() const +{ + // logic is the same as in GetBackgroundColour() + if ( !m_font.Ok() ) + { + wxASSERT_MSG( !m_hasFont, _T("we have invalid explicit font?") ); + + wxFont font = GetDefaultAttributes().font; + if ( !font.Ok() ) + font = GetClassDefaultAttributes().font; + + wxConstCast(this, wxWindowBase)->m_font = font; + } + + // cast is here for non-const GetFont() convenience + return wxConstCast(this, wxWindowBase)->m_font; } bool wxWindowBase::SetFont(const wxFont& font) { - // don't try to set invalid font, always fall back to the default - const wxFont& fontOk = font.Ok() ? font : *wxSWISS_FONT; + if ( !font.Ok() ) + return false; - if ( fontOk == m_font ) + if ( font == m_font ) { // no change - return FALSE; + return false; } - m_font = fontOk; + m_font = font; + + m_hasFont = true; + + return true; +} + +#if wxUSE_PALETTE + +void wxWindowBase::SetPalette(const wxPalette& pal) +{ + m_hasCustomPalette = true; + m_palette = pal; + + // VZ: can anyone explain me what do we do here? + wxWindowDC d((wxWindow *) this); + d.SetPalette(pal); +} - m_hasFont = TRUE; +wxWindow *wxWindowBase::GetAncestorWithCustomPalette() const +{ + wxWindow *win = (wxWindow *)this; + while ( win && !win->HasCustomPalette() ) + { + win = win->GetParent(); + } - return TRUE; + return win; } +#endif // wxUSE_PALETTE + #if wxUSE_CARET void wxWindowBase::SetCaret(wxCaret *caret) { @@ -723,7 +1137,7 @@ void wxWindowBase::SetValidator(const wxValidator& validator) m_windowValidator = (wxValidator *)validator.Clone(); if ( m_windowValidator ) - m_windowValidator->SetWindow(this) ; + m_windowValidator->SetWindow(this); } #endif // wxUSE_VALIDATORS @@ -753,8 +1167,19 @@ bool wxWindowBase::IsExposed(int x, int y, int w, int h) const return m_updateRegion.Contains(x, y, w, h) != wxOutRegion; } +void wxWindowBase::ClearBackground() +{ + // wxGTK uses its own version, no need to add never used code +#ifndef __WXGTK__ + wxClientDC dc((wxWindow *)this); + wxBrush brush(GetBackgroundColour(), wxSOLID); + dc.SetBackground(brush); + dc.Clear(); +#endif // __WXGTK__ +} + // ---------------------------------------------------------------------------- -// find window by id or name +// find child window by id or name // ---------------------------------------------------------------------------- wxWindow *wxWindowBase::FindWindow( long id ) @@ -763,7 +1188,7 @@ wxWindow *wxWindowBase::FindWindow( long id ) return (wxWindow *)this; wxWindowBase *res = (wxWindow *)NULL; - wxWindowList::Node *node; + wxWindowList::compatibility_iterator node; for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() ) { wxWindowBase *child = node->GetData(); @@ -779,7 +1204,7 @@ wxWindow *wxWindowBase::FindWindow( const wxString& name ) return (wxWindow *)this; wxWindowBase *res = (wxWindow *)NULL; - wxWindowList::Node *node; + wxWindowList::compatibility_iterator node; for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() ) { wxWindow *child = node->GetData(); @@ -789,68 +1214,189 @@ wxWindow *wxWindowBase::FindWindow( const wxString& name ) return (wxWindow *)res; } -// ---------------------------------------------------------------------------- -// dialog oriented functions -// ---------------------------------------------------------------------------- -void wxWindowBase::MakeModal(bool modal) +// find any window by id or name or label: If parent is non-NULL, look through +// children for a label or title matching the specified string. If NULL, look +// through all top-level windows. +// +// to avoid duplicating code we reuse the same helper function but with +// different comparators + +typedef bool (*wxFindWindowCmp)(const wxWindow *win, + const wxString& label, long id); + +static +bool wxFindWindowCmpLabels(const wxWindow *win, const wxString& label, + long WXUNUSED(id)) { - // Disable all other windows - if ( IsTopLevel() ) - { - wxWindowList::Node *node = wxTopLevelWindows.GetFirst(); - while (node) - { - wxWindow *win = node->GetData(); - if (win != this) - win->Enable(!modal); + return win->GetLabel() == label; +} - node = node->GetNext(); - } - } +static +bool wxFindWindowCmpNames(const wxWindow *win, const wxString& label, + long WXUNUSED(id)) +{ + return win->GetName() == label; } -bool wxWindowBase::Validate() +static +bool wxFindWindowCmpIds(const wxWindow *win, const wxString& WXUNUSED(label), + long id) { -#if wxUSE_VALIDATORS - bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0; + return win->GetId() == id; +} - wxWindowList::Node *node; - for ( node = m_children.GetFirst(); node; node = node->GetNext() ) +// recursive helper for the FindWindowByXXX() functions +static +wxWindow *wxFindWindowRecursively(const wxWindow *parent, + const wxString& label, + long id, + wxFindWindowCmp cmp) +{ + if ( parent ) { - wxWindowBase *child = node->GetData(); - wxValidator *validator = child->GetValidator(); - if ( validator && !validator->Validate((wxWindow *)this) ) - { - return FALSE; - } + // see if this is the one we're looking for + if ( (*cmp)(parent, label, id) ) + return (wxWindow *)parent; - if ( recurse && !child->Validate() ) + // It wasn't, so check all its children + for ( wxWindowList::compatibility_iterator node = parent->GetChildren().GetFirst(); + node; + node = node->GetNext() ) { - return FALSE; + // recursively check each child + wxWindow *win = (wxWindow *)node->GetData(); + wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp); + if (retwin) + return retwin; } } -#endif // wxUSE_VALIDATORS - return TRUE; + // Not found + return NULL; } -bool wxWindowBase::TransferDataToWindow() +// helper for FindWindowByXXX() +static +wxWindow *wxFindWindowHelper(const wxWindow *parent, + const wxString& label, + long id, + wxFindWindowCmp cmp) { -#if wxUSE_VALIDATORS - bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0; - - wxWindowList::Node *node; - for ( node = m_children.GetFirst(); node; node = node->GetNext() ) + if ( parent ) + { + // just check parent and all its children + return wxFindWindowRecursively(parent, label, id, cmp); + } + + // start at very top of wx's windows + for ( wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst(); + node; + node = node->GetNext() ) + { + // recursively check each window & its children + wxWindow *win = node->GetData(); + wxWindow *retwin = wxFindWindowRecursively(win, label, id, cmp); + if (retwin) + return retwin; + } + + return NULL; +} + +/* static */ +wxWindow * +wxWindowBase::FindWindowByLabel(const wxString& title, const wxWindow *parent) +{ + return wxFindWindowHelper(parent, title, 0, wxFindWindowCmpLabels); +} + +/* static */ +wxWindow * +wxWindowBase::FindWindowByName(const wxString& title, const wxWindow *parent) +{ + wxWindow *win = wxFindWindowHelper(parent, title, 0, wxFindWindowCmpNames); + + if ( !win ) + { + // fall back to the label + win = FindWindowByLabel(title, parent); + } + + return win; +} + +/* static */ +wxWindow * +wxWindowBase::FindWindowById( long id, const wxWindow* parent ) +{ + return wxFindWindowHelper(parent, _T(""), id, wxFindWindowCmpIds); +} + +// ---------------------------------------------------------------------------- +// dialog oriented functions +// ---------------------------------------------------------------------------- + +void wxWindowBase::MakeModal(bool modal) +{ + // Disable all other windows + if ( IsTopLevel() ) + { + wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst(); + while (node) + { + wxWindow *win = node->GetData(); + if (win != this) + win->Enable(!modal); + + node = node->GetNext(); + } + } +} + +bool wxWindowBase::Validate() +{ +#if wxUSE_VALIDATORS + bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0; + + wxWindowList::compatibility_iterator node; + for ( node = m_children.GetFirst(); node; node = node->GetNext() ) + { + wxWindowBase *child = node->GetData(); + wxValidator *validator = child->GetValidator(); + if ( validator && !validator->Validate((wxWindow *)this) ) + { + return false; + } + + if ( recurse && !child->Validate() ) + { + return false; + } + } +#endif // wxUSE_VALIDATORS + + return true; +} + +bool wxWindowBase::TransferDataToWindow() +{ +#if wxUSE_VALIDATORS + bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0; + + wxWindowList::compatibility_iterator node; + for ( node = m_children.GetFirst(); node; node = node->GetNext() ) { wxWindowBase *child = node->GetData(); wxValidator *validator = child->GetValidator(); if ( validator && !validator->TransferToWindow() ) { wxLogWarning(_("Could not transfer data to window")); +#if wxUSE_LOG wxLog::FlushActive(); +#endif // wxUSE_LOG - return FALSE; + return false; } if ( recurse ) @@ -858,13 +1404,13 @@ bool wxWindowBase::TransferDataToWindow() if ( !child->TransferDataToWindow() ) { // warning already given - return FALSE; + return false; } } } #endif // wxUSE_VALIDATORS - return TRUE; + return true; } bool wxWindowBase::TransferDataFromWindow() @@ -872,7 +1418,7 @@ bool wxWindowBase::TransferDataFromWindow() #if wxUSE_VALIDATORS bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0; - wxWindowList::Node *node; + wxWindowList::compatibility_iterator node; for ( node = m_children.GetFirst(); node; node = node->GetNext() ) { wxWindow *child = node->GetData(); @@ -882,7 +1428,7 @@ bool wxWindowBase::TransferDataFromWindow() // nop warning here because the application is supposed to give // one itself - we don't know here what might have gone wrongly - return FALSE; + return false; } if ( recurse ) @@ -890,13 +1436,13 @@ bool wxWindowBase::TransferDataFromWindow() if ( !child->TransferDataFromWindow() ) { // warning already given - return FALSE; + return false; } } } #endif // wxUSE_VALIDATORS - return TRUE; + return true; } void wxWindowBase::InitDialog() @@ -965,7 +1511,7 @@ void wxWindowBase::OnHelp(wxHelpEvent& event) #endif // wxUSE_HELP // ---------------------------------------------------------------------------- -// tooltips +// tooltipsroot.Replace("\\", "/"); // ---------------------------------------------------------------------------- #if wxUSE_TOOLTIPS @@ -1063,15 +1609,15 @@ void wxWindowBase::AddConstraintReference(wxWindowBase *otherWin) { if ( !m_constraintsInvolvedIn ) m_constraintsInvolvedIn = new wxWindowList; - if ( !m_constraintsInvolvedIn->Find(otherWin) ) - m_constraintsInvolvedIn->Append(otherWin); + if ( !m_constraintsInvolvedIn->Find((wxWindow *)otherWin) ) + m_constraintsInvolvedIn->Append((wxWindow *)otherWin); } // REMOVE back-pointer to other windows we're involved with. void wxWindowBase::RemoveConstraintReference(wxWindowBase *otherWin) { if ( m_constraintsInvolvedIn ) - m_constraintsInvolvedIn->DeleteObject(otherWin); + m_constraintsInvolvedIn->DeleteObject((wxWindow *)otherWin); } // Reset any constraints that mention this window @@ -1079,7 +1625,7 @@ void wxWindowBase::DeleteRelatedConstraints() { if ( m_constraintsInvolvedIn ) { - wxWindowList::Node *node = m_constraintsInvolvedIn->GetFirst(); + wxWindowList::compatibility_iterator node = m_constraintsInvolvedIn->GetFirst(); while (node) { wxWindow *win = node->GetData(); @@ -1098,8 +1644,8 @@ void wxWindowBase::DeleteRelatedConstraints() constr->centreY.ResetIfWin(this); } - wxWindowList::Node *next = node->GetNext(); - delete node; + wxWindowList::compatibility_iterator next = node->GetNext(); + m_constraintsInvolvedIn->Erase(node); node = next; } @@ -1108,115 +1654,163 @@ void wxWindowBase::DeleteRelatedConstraints() } } -void wxWindowBase::SetSizer(wxSizer *sizer) +#endif // wxUSE_CONSTRAINTS + +void wxWindowBase::SetSizer(wxSizer *sizer, bool deleteOld) { - if (m_windowSizer) delete m_windowSizer; + if ( sizer == m_windowSizer) + return; + + if ( deleteOld ) + delete m_windowSizer; m_windowSizer = sizer; + + SetAutoLayout( sizer != NULL ); } +void wxWindowBase::SetSizerAndFit(wxSizer *sizer, bool deleteOld) +{ + SetSizer( sizer, deleteOld ); + sizer->SetSizeHints( (wxWindow*) this ); +} + + +void wxWindowBase::SetContainingSizer(wxSizer* sizer) +{ + // adding a window to a sizer twice is going to result in fatal and + // hard to debug problems later because when deleting the second + // associated wxSizerItem we're going to dereference a dangling + // pointer; so try to detect this as early as possible + wxASSERT_MSG( !sizer || m_containingSizer != sizer, + _T("Adding a window to the same sizer twice?") ); + + m_containingSizer = sizer; +} + +#if wxUSE_CONSTRAINTS + +void wxWindowBase::SatisfyConstraints() +{ + wxLayoutConstraints *constr = GetConstraints(); + bool wasOk = constr && constr->AreSatisfied(); + + ResetConstraints(); // Mark all constraints as unevaluated + + int noChanges = 1; + + // if we're a top level panel (i.e. our parent is frame/dialog), our + // own constraints will never be satisfied any more unless we do it + // here + if ( wasOk ) + { + while ( noChanges > 0 ) + { + LayoutPhase1(&noChanges); + } + } + + LayoutPhase2(&noChanges); +} + +#endif // wxUSE_CONSTRAINTS + bool wxWindowBase::Layout() { // If there is a sizer, use it instead of the constraints if ( GetSizer() ) { int w, h; - GetClientSize(&w, &h); - + GetVirtualSize(&w, &h); GetSizer()->SetDimension( 0, 0, w, h ); } +#if wxUSE_CONSTRAINTS else { - wxLayoutConstraints *constr = GetConstraints(); - bool wasOk = constr && constr->AreSatisfied(); - - ResetConstraints(); // Mark all constraints as unevaluated - - // if we're a top level panel (i.e. our parent is frame/dialog), our - // own constraints will never be satisfied any more unless we do it - // here - if ( wasOk ) - { - int noChanges = 1; - while ( noChanges > 0 ) - { - constr->SatisfyConstraints(this, &noChanges); - } - } - - DoPhase(1); // Layout children - DoPhase(2); // Layout grand children + SatisfyConstraints(); // Find the right constraints values SetConstraintSizes(); // Recursively set the real window sizes } +#endif - return TRUE; + return true; } +#if wxUSE_CONSTRAINTS -// Do a phase of evaluating constraints: the default behaviour. wxSizers may -// do a similar thing, but also impose their own 'constraints' and order the -// evaluation differently. +// first phase of the constraints evaluation: set our own constraints bool wxWindowBase::LayoutPhase1(int *noChanges) { wxLayoutConstraints *constr = GetConstraints(); - if ( constr ) - { - return constr->SatisfyConstraints(this, noChanges); - } - else - return TRUE; + + return !constr || constr->SatisfyConstraints(this, noChanges); } +// second phase: set the constraints for our children bool wxWindowBase::LayoutPhase2(int *noChanges) { *noChanges = 0; // Layout children DoPhase(1); + + // Layout grand children DoPhase(2); - return TRUE; + + return true; } // Do a phase of evaluating child constraints bool wxWindowBase::DoPhase(int phase) { - int noIterations = 0; - int maxIterations = 500; - int noChanges = 1; - int noFailures = 0; + // the list containing the children for which the constraints are already + // set correctly wxWindowList succeeded; - while ((noChanges > 0) && (noIterations < maxIterations)) + + // the max number of iterations we loop before concluding that we can't set + // the constraints + static const int maxIterations = 500; + + for ( int noIterations = 0; noIterations < maxIterations; noIterations++ ) { - noChanges = 0; - noFailures = 0; - wxWindowList::Node *node = GetChildren().GetFirst(); - while (node) + int noChanges = 0; + + // loop over all children setting their constraints + for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); + node; + node = node->GetNext() ) { wxWindow *child = node->GetData(); - if ( !child->IsTopLevel() ) + if ( child->IsTopLevel() ) { - wxLayoutConstraints *constr = child->GetConstraints(); - if ( constr ) - { - if ( !succeeded.Find(child) ) - { - int tempNoChanges = 0; - bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ; - noChanges += tempNoChanges; - if ( success ) - { - succeeded.Append(child); - } - } - } + // top level children are not inside our client area + continue; + } + + if ( !child->GetConstraints() || succeeded.Find(child) ) + { + // this one is either already ok or nothing we can do about it + continue; + } + + int tempNoChanges = 0; + bool success = phase == 1 ? child->LayoutPhase1(&tempNoChanges) + : child->LayoutPhase2(&tempNoChanges); + noChanges += tempNoChanges; + + if ( success ) + { + succeeded.Append(child); } - node = node->GetNext(); } - noIterations++; + if ( !noChanges ) + { + // constraints are set + break; + } } - return TRUE; + return true; } void wxWindowBase::ResetConstraints() @@ -1224,17 +1818,17 @@ void wxWindowBase::ResetConstraints() wxLayoutConstraints *constr = GetConstraints(); if ( constr ) { - constr->left.SetDone(FALSE); - constr->top.SetDone(FALSE); - constr->right.SetDone(FALSE); - constr->bottom.SetDone(FALSE); - constr->width.SetDone(FALSE); - constr->height.SetDone(FALSE); - constr->centreX.SetDone(FALSE); - constr->centreY.SetDone(FALSE); + constr->left.SetDone(false); + constr->top.SetDone(false); + constr->right.SetDone(false); + constr->bottom.SetDone(false); + constr->width.SetDone(false); + constr->height.SetDone(false); + constr->centreX.SetDone(false); + constr->centreY.SetDone(false); } - wxWindowList::Node *node = GetChildren().GetFirst(); + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); while (node) { wxWindow *win = node->GetData(); @@ -1276,7 +1870,7 @@ void wxWindowBase::SetConstraintSizes(bool recurse) if ( recurse ) { - wxWindowList::Node *node = GetChildren().GetFirst(); + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); while (node) { wxWindow *win = node->GetData(); @@ -1296,22 +1890,22 @@ void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h) if ( x != -1 ) { constr->left.SetValue(x); - constr->left.SetDone(TRUE); + constr->left.SetDone(true); } if ( y != -1 ) { constr->top.SetValue(y); - constr->top.SetDone(TRUE); + constr->top.SetDone(true); } if ( w != -1 ) { constr->width.SetValue(w); - constr->width.SetDone(TRUE); + constr->width.SetDone(true); } if ( h != -1 ) { constr->height.SetValue(h); - constr->height.SetDone(TRUE); + constr->height.SetDone(true); } } } @@ -1324,12 +1918,12 @@ void wxWindowBase::MoveConstraint(int x, int y) if ( x != -1 ) { constr->left.SetValue(x); - constr->left.SetDone(TRUE); + constr->left.SetDone(true); } if ( y != -1 ) { constr->top.SetValue(y); - constr->top.SetDone(TRUE); + constr->top.SetDone(true); } } } @@ -1358,7 +1952,21 @@ void wxWindowBase::GetClientSizeConstraint(int *w, int *h) const GetClientSize(w, h); } -void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) +void wxWindowBase::GetPositionConstraint(int *x, int *y) const +{ + wxLayoutConstraints *constr = GetConstraints(); + if ( constr ) + { + *x = constr->left.GetValue(); + *y = constr->top.GetValue(); + } + else + GetPosition(x, y); +} + +#endif // wxUSE_CONSTRAINTS + +void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) const { // don't do it for the dialogs/frames - they float independently of their // parent @@ -1374,55 +1982,50 @@ void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) } } - -void wxWindowBase::GetPositionConstraint(int *x, int *y) const -{ - wxLayoutConstraints *constr = GetConstraints(); - if ( constr ) - { - *x = constr->left.GetValue(); - *y = constr->top.GetValue(); - } - else - GetPosition(x, y); -} - -#endif // wxUSE_CONSTRAINTS - // ---------------------------------------------------------------------------- // do Update UI processing for child controls // ---------------------------------------------------------------------------- -// TODO: should this be implemented for the child window rather -// than the parent? Then you can override it e.g. for wxCheckBox -// to do the Right Thing rather than having to assume a fixed number -// of control classes. -void wxWindowBase::UpdateWindowUI() +void wxWindowBase::UpdateWindowUI(long flags) { -#if wxUSE_CONTROLS wxUpdateUIEvent event(GetId()); event.m_eventObject = this; if ( GetEventHandler()->ProcessEvent(event) ) { - if ( event.GetSetEnabled() ) - Enable(event.GetEnabled()); + DoUpdateWindowUI(event); + } - if ( event.GetSetText() ) + if (flags & wxUPDATE_UI_RECURSE) + { + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); + while (node) { - wxControl *control = wxDynamicCastThis(wxControl); - if ( control ) - { -#if wxUSE_TEXTCTRL - wxTextCtrl *text = wxDynamicCast(control, wxTextCtrl); - if ( text ) - text->SetValue(event.GetText()); - else -#endif // wxUSE_TEXTCTRL - control->SetLabel(event.GetText()); - } + wxWindow* child = (wxWindow*) node->GetData(); + child->UpdateWindowUI(flags); + node = node->GetNext(); } + } +} +// do the window-specific processing after processing the update event +// TODO: take specific knowledge out of this function and +// put in each control's base class. Unfortunately we don't +// yet have base implementation files for wxCheckBox and wxRadioButton. +void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event) +{ + if ( event.GetSetEnabled() ) + Enable(event.GetEnabled()); + +#if wxUSE_CONTROLS + if ( event.GetSetText() ) + { + wxControl *control = wxDynamicCastThis(wxControl); + if ( control ) + { + if ( event.GetText() != control->GetLabel() ) + control->SetLabel(event.GetText()); + } #if wxUSE_CHECKBOX wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox); if ( checkbox ) @@ -1441,9 +2044,26 @@ void wxWindowBase::UpdateWindowUI() } #endif // wxUSE_RADIOBTN } -#endif // wxUSE_CONTROLS +#endif } +#if 0 +// call internal idle recursively +// may be obsolete (wait until OnIdle scheme stabilises) +void wxWindowBase::ProcessInternalIdle() +{ + OnInternalIdle(); + + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); + while (node) + { + wxWindow *child = node->GetData(); + child->ProcessInternalIdle(); + node = node->GetNext(); + } +} +#endif + // ---------------------------------------------------------------------------- // dialog units translations // ---------------------------------------------------------------------------- @@ -1454,9 +2074,9 @@ wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt) int charHeight = GetCharHeight(); wxPoint pt2(-1, -1); if (pt.x != -1) - pt2.x = (int) ((pt.x * 4) / charWidth) ; + pt2.x = (int) ((pt.x * 4) / charWidth); if (pt.y != -1) - pt2.y = (int) ((pt.y * 8) / charHeight) ; + pt2.y = (int) ((pt.y * 8) / charHeight); return pt2; } @@ -1467,9 +2087,9 @@ wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt) int charHeight = GetCharHeight(); wxPoint pt2(-1, -1); if (pt.x != -1) - pt2.x = (int) ((pt.x * charWidth) / 4) ; + pt2.x = (int) ((pt.x * charWidth) / 4); if (pt.y != -1) - pt2.y = (int) ((pt.y * charHeight) / 8) ; + pt2.y = (int) ((pt.y * charHeight) / 8); return pt2; } @@ -1481,7 +2101,7 @@ wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt) // propagate the colour change event to the subwindows void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event) { - wxWindowList::Node *node = GetChildren().GetFirst(); + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); while ( node ) { // Only propagate to non-top-level windows @@ -1497,10 +2117,15 @@ void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event) } } -// the default action is to populate dialog with data when it's created +// the default action is to populate dialog with data when it's created, +// and nudge the UI into displaying itself correctly in case +// we've turned the wxUpdateUIEvents frequency down low. void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) ) { TransferDataToWindow(); + + // Update the UI at this point + UpdateWindowUI(wxUPDATE_UI_RECURSE); } // process Ctrl-Alt-mclick @@ -1511,34 +2136,39 @@ void wxWindowBase::OnMiddleClick( wxMouseEvent& event ) { // don't translate these strings wxString port; + +#ifdef __WXUNIVERSAL__ + port = _T("Univ/"); +#endif // __WXUNIVERSAL__ + switch ( wxGetOsVersion() ) { - case wxMOTIF_X: port = _T("Motif"); break; + case wxMOTIF_X: port += _T("Motif"); break; case wxMAC: - case wxMAC_DARWIN: port = _T("Mac"); break; - case wxBEOS: port = _T("BeOS"); break; + case wxMAC_DARWIN: port += _T("Mac"); break; + case wxBEOS: port += _T("BeOS"); break; case wxGTK: case wxGTK_WIN32: case wxGTK_OS2: - case wxGTK_BEOS: port = _T("GTK"); break; + case wxGTK_BEOS: port += _T("GTK"); break; case wxWINDOWS: case wxPENWINDOWS: case wxWINDOWS_NT: case wxWIN32S: case wxWIN95: - case wxWIN386: port = _T("MS Windows"); break; + case wxWIN386: port += _T("MS Windows"); break; case wxMGL_UNIX: case wxMGL_X: case wxMGL_WIN32: - case wxMGL_OS2: port = _T("MGL"); break; + case wxMGL_OS2: port += _T("MGL"); break; case wxWINDOWS_OS2: - case wxOS2_PM: port = _T("OS/2"); break; - default: port = _T("unknown"); break; + case wxOS2_PM: port += _T("OS/2"); break; + default: port += _T("unknown"); break; } wxMessageBox(wxString::Format( _T( - " wxWindows Library (%s port)\nVersion %u.%u.%u%s, compiled at %s %s\n Copyright (c) 1995-2001 wxWindows team" + " wxWindows Library (%s port)\nVersion %u.%u.%u%s, compiled at %s %s\n Copyright (c) 1995-2002 wxWindows team" ), port.c_str(), wxMAJOR_VERSION, @@ -1563,6 +2193,37 @@ void wxWindowBase::OnMiddleClick( wxMouseEvent& event ) } } +// ---------------------------------------------------------------------------- +// accessibility +// ---------------------------------------------------------------------------- + +#if wxUSE_ACCESSIBILITY +void wxWindowBase::SetAccessible(wxAccessible* accessible) +{ + if (m_accessible && (accessible != m_accessible)) + delete m_accessible; + m_accessible = accessible; + if (m_accessible) + m_accessible->SetWindow((wxWindow*) this); +} + +// Returns the accessible object, creating if necessary. +wxAccessible* wxWindowBase::GetOrCreateAccessible() +{ + if (!m_accessible) + m_accessible = CreateAccessible(); + return m_accessible; +} + +// Override to create a specific accessible object. +wxAccessible* wxWindowBase::CreateAccessible() +{ + return new wxWindowAccessible((wxWindow*) this); +} + +#endif + +#if !wxUSE_STL // ---------------------------------------------------------------------------- // list classes implementation // ---------------------------------------------------------------------------- @@ -1571,14 +2232,15 @@ void wxWindowListNode::DeleteData() { delete (wxWindow *)GetData(); } +#endif // ---------------------------------------------------------------------------- // borders // ---------------------------------------------------------------------------- -wxBorder wxWindowBase::GetBorder() const +wxBorder wxWindowBase::GetBorder(long flags) const { - wxBorder border = (wxBorder)(m_windowStyle & wxBORDER_MASK); + wxBorder border = (wxBorder)(flags & wxBORDER_MASK); if ( border == wxBORDER_DEFAULT ) { border = GetDefaultBorder(); @@ -1612,3 +2274,562 @@ wxHitTest wxWindowBase::DoHitTest(wxCoord x, wxCoord y) const return outside ? wxHT_WINDOW_OUTSIDE : wxHT_WINDOW_INSIDE; } +// ---------------------------------------------------------------------------- +// mouse capture +// ---------------------------------------------------------------------------- + +struct WXDLLEXPORT wxWindowNext +{ + wxWindow *win; + wxWindowNext *next; +} *wxWindowBase::ms_winCaptureNext = NULL; + +void wxWindowBase::CaptureMouse() +{ + wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), this); + + wxWindow *winOld = GetCapture(); + if ( winOld ) + { + ((wxWindowBase*) winOld)->DoReleaseMouse(); + + // save it on stack + wxWindowNext *item = new wxWindowNext; + item->win = winOld; + item->next = ms_winCaptureNext; + ms_winCaptureNext = item; + } + //else: no mouse capture to save + + DoCaptureMouse(); +} + +void wxWindowBase::ReleaseMouse() +{ + wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), this); + + wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") ); + + DoReleaseMouse(); + + if ( ms_winCaptureNext ) + { + ((wxWindowBase*)ms_winCaptureNext->win)->DoCaptureMouse(); + + wxWindowNext *item = ms_winCaptureNext; + ms_winCaptureNext = item->next; + delete item; + } + //else: stack is empty, no previous capture + + wxLogTrace(_T("mousecapture"), + (const wxChar *) _T("After ReleaseMouse() mouse is captured by %p"), + GetCapture()); +} + +#if wxUSE_HOTKEY + +bool +wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId), + int WXUNUSED(modifiers), + int WXUNUSED(keycode)) +{ + // not implemented + return false; +} + +bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId)) +{ + // not implemented + return false; +} + +#endif // wxUSE_HOTKEY + +void wxWindowBase::SendDestroyEvent() +{ + wxWindowDestroyEvent event; + event.SetEventObject(this); + event.SetId(GetId()); + GetEventHandler()->ProcessEvent(event); +} + +// ---------------------------------------------------------------------------- +// event processing +// ---------------------------------------------------------------------------- + +bool wxWindowBase::TryValidator(wxEvent& wxVALIDATOR_PARAM(event)) +{ +#if wxUSE_VALIDATORS + // Can only use the validator of the window which + // is receiving the event + if ( event.GetEventObject() == this ) + { + wxValidator *validator = GetValidator(); + if ( validator && validator->ProcessEvent(event) ) + { + return true; + } + } +#endif // wxUSE_VALIDATORS + + return false; +} + +bool wxWindowBase::TryParent(wxEvent& event) +{ + // carry on up the parent-child hierarchy if the propgation count hasn't + // reached zero yet + if ( event.ShouldPropagate() ) + { + // honour the requests to stop propagation at this window: this is + // used by the dialogs, for example, to prevent processing the events + // from the dialog controls in the parent frame which rarely, if ever, + // makes sense + if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS) ) + { + wxWindow *parent = GetParent(); + if ( parent && !parent->IsBeingDeleted() ) + { + wxPropagateOnce propagateOnce(event); + + return parent->GetEventHandler()->ProcessEvent(event); + } + } + } + + return wxEvtHandler::TryParent(event); +} + +// ---------------------------------------------------------------------------- +// global functions +// ---------------------------------------------------------------------------- + +wxWindow* wxGetTopLevelParent(wxWindow *win) +{ + while ( win && !win->IsTopLevel() ) + win = win->GetParent(); + + return win; +} + +#if wxUSE_ACCESSIBILITY +// ---------------------------------------------------------------------------- +// accessible object for windows +// ---------------------------------------------------------------------------- + +// Can return either a child object, or an integer +// representing the child element, starting from 1. +wxAccStatus wxWindowAccessible::HitTest(const wxPoint& WXUNUSED(pt), int* WXUNUSED(childId), wxAccessible** WXUNUSED(childObject)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// Returns the rectangle for this object (id = 0) or a child element (id > 0). +wxAccStatus wxWindowAccessible::GetLocation(wxRect& rect, int elementId) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + wxWindow* win = NULL; + if (elementId == 0) + { + win = GetWindow(); + } + else + { + if (elementId <= (int) GetWindow()->GetChildren().GetCount()) + { + win = GetWindow()->GetChildren().Item(elementId-1)->GetData(); + } + else + return wxACC_FAIL; + } + if (win) + { + rect = win->GetRect(); + if (win->GetParent() && !win->IsKindOf(CLASSINFO(wxTopLevelWindow))) + rect.SetPosition(win->GetParent()->ClientToScreen(rect.GetPosition())); + return wxACC_OK; + } + + return wxACC_NOT_IMPLEMENTED; +} + +// Navigates from fromId to toId/toObject. +wxAccStatus wxWindowAccessible::Navigate(wxNavDir navDir, int fromId, + int* WXUNUSED(toId), wxAccessible** toObject) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + switch (navDir) + { + case wxNAVDIR_FIRSTCHILD: + { + if (GetWindow()->GetChildren().GetCount() == 0) + return wxACC_FALSE; + wxWindow* childWindow = (wxWindow*) GetWindow()->GetChildren().GetFirst()->GetData(); + *toObject = childWindow->GetOrCreateAccessible(); + + return wxACC_OK; + } + case wxNAVDIR_LASTCHILD: + { + if (GetWindow()->GetChildren().GetCount() == 0) + return wxACC_FALSE; + wxWindow* childWindow = (wxWindow*) GetWindow()->GetChildren().GetLast()->GetData(); + *toObject = childWindow->GetOrCreateAccessible(); + + return wxACC_OK; + } + case wxNAVDIR_RIGHT: + case wxNAVDIR_DOWN: + case wxNAVDIR_NEXT: + { + wxWindowList::compatibility_iterator node = + wxWindowList::compatibility_iterator(); + if (fromId == 0) + { + // Can't navigate to sibling of this window + // if we're a top-level window. + if (!GetWindow()->GetParent()) + return wxACC_NOT_IMPLEMENTED; + + node = GetWindow()->GetParent()->GetChildren().Find(GetWindow()); + } + else + { + if (fromId <= (int) GetWindow()->GetChildren().GetCount()) + node = GetWindow()->GetChildren().Item(fromId-1); + } + + if (node && node->GetNext()) + { + wxWindow* nextWindow = node->GetNext()->GetData(); + *toObject = nextWindow->GetOrCreateAccessible(); + return wxACC_OK; + } + else + return wxACC_FALSE; + } + case wxNAVDIR_LEFT: + case wxNAVDIR_UP: + case wxNAVDIR_PREVIOUS: + { + wxWindowList::compatibility_iterator node = + wxWindowList::compatibility_iterator(); + if (fromId == 0) + { + // Can't navigate to sibling of this window + // if we're a top-level window. + if (!GetWindow()->GetParent()) + return wxACC_NOT_IMPLEMENTED; + + node = GetWindow()->GetParent()->GetChildren().Find(GetWindow()); + } + else + { + if (fromId <= (int) GetWindow()->GetChildren().GetCount()) + node = GetWindow()->GetChildren().Item(fromId-1); + } + + if (node && node->GetPrevious()) + { + wxWindow* previousWindow = node->GetPrevious()->GetData(); + *toObject = previousWindow->GetOrCreateAccessible(); + return wxACC_OK; + } + else + return wxACC_FALSE; + } + } + + return wxACC_NOT_IMPLEMENTED; +} + +// Gets the name of the specified object. +wxAccStatus wxWindowAccessible::GetName(int childId, wxString* name) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + wxString title; + + // If a child, leave wxWindows to call the function on the actual + // child object. + if (childId > 0) + return wxACC_NOT_IMPLEMENTED; + + // This will eventually be replaced by specialised + // accessible classes, one for each kind of wxWindows + // control or window. + if (GetWindow()->IsKindOf(CLASSINFO(wxButton))) + title = ((wxButton*) GetWindow())->GetLabel(); + else + title = GetWindow()->GetName(); + + if (!title.IsEmpty()) + { + *name = title; + return wxACC_OK; + } + else + return wxACC_NOT_IMPLEMENTED; +} + +// Gets the number of children. +wxAccStatus wxWindowAccessible::GetChildCount(int* childId) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + *childId = (int) GetWindow()->GetChildren().GetCount(); + return wxACC_OK; +} + +// 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. +wxAccStatus wxWindowAccessible::GetChild(int childId, wxAccessible** child) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + if (childId == 0) + { + *child = this; + return wxACC_OK; + } + + if (childId > (int) GetWindow()->GetChildren().GetCount()) + return wxACC_FAIL; + + wxWindow* childWindow = GetWindow()->GetChildren().Item(childId-1)->GetData(); + *child = childWindow->GetOrCreateAccessible(); + if (*child) + return wxACC_OK; + else + return wxACC_FAIL; +} + +// Gets the parent, or NULL. +wxAccStatus wxWindowAccessible::GetParent(wxAccessible** parent) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + wxWindow* parentWindow = GetWindow()->GetParent(); + if (!parentWindow) + { + *parent = NULL; + return wxACC_OK; + } + else + { + *parent = parentWindow->GetOrCreateAccessible(); + if (*parent) + return wxACC_OK; + else + return wxACC_FAIL; + } +} + +// 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). +wxAccStatus wxWindowAccessible::DoDefaultAction(int WXUNUSED(childId)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// 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." +wxAccStatus wxWindowAccessible::GetDefaultAction(int WXUNUSED(childId), wxString* WXUNUSED(actionName)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// Returns the description for this object or a child. +wxAccStatus wxWindowAccessible::GetDescription(int WXUNUSED(childId), wxString* description) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + wxString ht(GetWindow()->GetHelpText()); + if (!ht.IsEmpty()) + { + *description = ht; + return wxACC_OK; + } + return wxACC_NOT_IMPLEMENTED; +} + +// Returns help text for this object or a child, similar to tooltip text. +wxAccStatus wxWindowAccessible::GetHelpText(int WXUNUSED(childId), wxString* helpText) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + wxString ht(GetWindow()->GetHelpText()); + if (!ht.IsEmpty()) + { + *helpText = ht; + return wxACC_OK; + } + return wxACC_NOT_IMPLEMENTED; +} + +// Returns the keyboard shortcut for this object or child. +// Return e.g. ALT+K +wxAccStatus wxWindowAccessible::GetKeyboardShortcut(int WXUNUSED(childId), wxString* WXUNUSED(shortcut)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// Returns a role constant. +wxAccStatus wxWindowAccessible::GetRole(int childId, wxAccRole* role) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + // If a child, leave wxWindows to call the function on the actual + // child object. + if (childId > 0) + return wxACC_NOT_IMPLEMENTED; + + if (GetWindow()->IsKindOf(CLASSINFO(wxControl))) + return wxACC_NOT_IMPLEMENTED; +#if wxUSE_STATUSBAR + if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar))) + return wxACC_NOT_IMPLEMENTED; +#endif +#if wxUSE_TOOLBAR + if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar))) + return wxACC_NOT_IMPLEMENTED; +#endif + + //*role = wxROLE_SYSTEM_CLIENT; + *role = wxROLE_SYSTEM_CLIENT; + return wxACC_OK; + + #if 0 + return wxACC_NOT_IMPLEMENTED; + #endif +} + +// Returns a state constant. +wxAccStatus wxWindowAccessible::GetState(int childId, long* state) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + // If a child, leave wxWindows to call the function on the actual + // child object. + if (childId > 0) + return wxACC_NOT_IMPLEMENTED; + + if (GetWindow()->IsKindOf(CLASSINFO(wxControl))) + return wxACC_NOT_IMPLEMENTED; + +#if wxUSE_STATUSBAR + if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar))) + return wxACC_NOT_IMPLEMENTED; +#endif +#if wxUSE_TOOLBAR + if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar))) + return wxACC_NOT_IMPLEMENTED; +#endif + + *state = 0; + return wxACC_OK; + + #if 0 + return wxACC_NOT_IMPLEMENTED; + #endif +} + +// Returns a localized string representing the value for the object +// or child. +wxAccStatus wxWindowAccessible::GetValue(int WXUNUSED(childId), wxString* WXUNUSED(strValue)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// Selects the object or child. +wxAccStatus wxWindowAccessible::Select(int WXUNUSED(childId), wxAccSelectionFlags WXUNUSED(selectFlags)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// 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'. +wxAccStatus wxWindowAccessible::GetFocus(int* WXUNUSED(childId), wxAccessible** WXUNUSED(child)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// 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 +wxAccStatus wxWindowAccessible::GetSelections(wxVariant* WXUNUSED(selections)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +#endif // wxUSE_ACCESSIBILITY