bool wxWindowBase::CreateBase(wxWindowBase *parent,
wxWindowID id,
const wxPoint& WXUNUSED(pos),
- const wxSize& WXUNUSED(size),
+ const wxSize& size,
long style,
- const wxValidator& wxVALIDATOR_PARAM(validator),
const wxString& name)
{
// ids are limited to 16 bits under MSW so if you care about portability,
// reserved for wxWidgets own usage)
wxASSERT_MSG( id == wxID_ANY || (id >= 0 && id < 32767) ||
(id >= wxID_AUTO_LOWEST && id <= wxID_AUTO_HIGHEST),
- _T("invalid id value") );
+ wxT("invalid id value") );
// generate a new id if the user doesn't care about it
if ( id == wxID_ANY )
// flags by updating the window dynamically and we don't need this here
m_windowStyle = style;
+ // assume the user doesn't want this window to shrink beneath its initial
+ // size, this worked like this in wxWidgets 2.8 and before and generally
+ // often makes sense for child windows (for top level ones it definitely
+ // does not as the user should be able to resize the window)
+ //
+ // note that we can't use IsTopLevel() from ctor
+ if ( !wxTopLevelWindows.Find((wxWindow *)this) )
+ SetMinSize(size);
+
SetName(name);
SetParent(parent);
+ return true;
+}
+
+bool wxWindowBase::CreateBase(wxWindowBase *parent,
+ wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxValidator& wxVALIDATOR_PARAM(validator),
+ const wxString& name)
+{
+ if ( !CreateBase(parent, id, pos, size, style, name) )
+ return false;
+
#if wxUSE_VALIDATORS
SetValidator(validator);
#endif // wxUSE_VALIDATORS
bool wxWindowBase::ToggleWindowStyle(int flag)
{
- wxASSERT_MSG( flag, _T("flags with 0 value can't be toggled") );
+ wxASSERT_MSG( flag, wxT("flags with 0 value can't be toggled") );
bool rc;
long style = GetWindowStyleFlag();
void wxWindowBase::DoCentre(int dir)
{
wxCHECK_RET( !(dir & wxCENTRE_ON_SCREEN) && GetParent(),
- _T("this method only implements centering child windows") );
+ wxT("this method only implements centering child windows") );
SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir));
}
node = node->GetNext() )
{
wxWindow *win = node->GetData();
- if ( !win->IsTopLevel() && win->IsShown() && !win->IsKindOf(CLASSINFO(wxScrollBar)))
+ if ( !win->IsTopLevel() && win->IsShown()
+#if wxUSE_SCROLLBAR
+ && !win->IsKindOf(CLASSINFO(wxScrollBar))
+#endif
+ )
realChildCount ++;
}
return (realChildCount > 0);
}
else // ! has children
{
- // for a generic window there is no natural best size so, if the
- // minimal size is not set, use the current size but take care to
- // remember it as minimal size for the next time because our best size
- // should be constant: otherwise we could get into a situation when the
- // window is initially at some size, then expanded to a larger size and
- // then, when the containing window is shrunk back (because our initial
- // best size had been used for computing the parent min size), we can't
- // be shrunk back any more because our best size is now bigger
wxSize size = GetMinSize();
if ( !size.IsFullySpecified() )
{
- size.SetDefaults(GetSize());
- wxConstCast(this, wxWindowBase)->SetMinSize(size);
+ // if the window doesn't define its best size we assume that it can
+ // be arbitrarily small -- usually this is not the case, of course,
+ // but we have no way to know what the limit is, it should really
+ // override DoGetBestClientSize() itself to tell us
+ size.SetDefaults(wxSize(1, 1));
}
// return as-is, unadjusted by the client size difference.
break;
default:
- wxFAIL_MSG( _T("unexpected wxGetMetricOrDefault() argument") );
+ wxFAIL_MSG( wxT("unexpected wxGetMetricOrDefault() argument") );
rc = 0;
}
}
break;
default:
- wxFAIL_MSG(_T("Unknown border style."));
+ wxFAIL_MSG(wxT("Unknown border style."));
break;
}
return min;
}
+wxSize wxWindowBase::DoGetBorderSize() const
+{
+ // there is one case in which we can implement it for all ports easily:
+ // do it as some classes used by both wxUniv and native ports (e.g.
+ // wxGenericStaticText) do override DoGetBestClientSize() and so this
+ // method must work for them and that ensures that it does, at least in
+ // the default case)
+ if ( GetBorder() == wxBORDER_NONE )
+ return wxSize(0, 0);
+
+ wxFAIL_MSG( "must be overridden if called" );
+
+ return wxDefaultSize;
+}
+
wxSize wxWindowBase::GetBestSize() const
{
if ( !m_windowSizer && m_bestSizeCache.IsFullySpecified() )
break;
default:
- wxFAIL_MSG(_T("unexpected window variant"));
+ wxFAIL_MSG(wxT("unexpected window variant"));
break;
}
{
wxCHECK_RET( (minW == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) &&
(minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= maxH),
- _T("min width/height must be less than max width/height!") );
+ wxT("min width/height must be less than max width/height!") );
m_minWidth = minW;
m_maxWidth = maxW;
parent->SendSizeEvent(flags);
}
+bool wxWindowBase::HasScrollbar(int orient) const
+{
+ // if scrolling in the given direction is disabled, we can't have the
+ // corresponding scrollbar no matter what
+ if ( !CanScroll(orient) )
+ return false;
+
+ const wxSize sizeVirt = GetVirtualSize();
+ const wxSize sizeClient = GetClientSize();
+
+ return orient == wxHORIZONTAL ? sizeVirt.x > sizeClient.x
+ : sizeVirt.y > sizeClient.y;
+}
+
// ----------------------------------------------------------------------------
// show/hide/enable/disable the window
// ----------------------------------------------------------------------------
// 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((wxWindow*)child), _T("AddChild() called twice") );
+ wxASSERT_MSG( !GetChildren().Find((wxWindow*)child), wxT("AddChild() called twice") );
GetChildren().Append((wxWindow*)child);
child->SetParent(this);
handlerCur = handlerNext;
}
- wxFAIL_MSG( _T("where has the event handler gone?") );
+ wxFAIL_MSG( wxT("where has the event handler gone?") );
return false;
}
{
if ( !m_backgroundColour.IsOk() )
{
- wxASSERT_MSG( !m_hasBgCol, _T("we have invalid explicit bg colour?") );
+ wxASSERT_MSG( !m_hasBgCol, wxT("we have invalid explicit bg colour?") );
// get our default background colour
wxColour colBg = GetDefaultAttributes().colBg;
// logic is the same as in GetBackgroundColour()
if ( !m_font.IsOk() )
{
- wxASSERT_MSG( !m_hasFont, _T("we have invalid explicit font?") );
+ wxASSERT_MSG( !m_hasFont, wxT("we have invalid explicit font?") );
wxFont font = GetDefaultAttributes().font;
if ( !font.IsOk() )
#if wxUSE_TOOLTIPS
+wxString wxWindowBase::GetToolTipText() const
+{
+ return m_tooltip ? m_tooltip->GetTip() : wxString();
+}
+
void wxWindowBase::SetToolTip( const wxString &tip )
{
// don't create the new tooltip if we already have one
// 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?") );
+ wxT("Adding a window to the same sizer twice?") );
m_containingSizer = sizer;
}
// ----------------------------------------------------------------------------
// propagate the colour change event to the subwindows
-void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
+void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
{
wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
while ( node )
if ( !win->IsTopLevel() )
{
wxSysColourChangedEvent event2;
- event.SetEventObject(win);
+ event2.SetEventObject(win);
win->GetEventHandler()->ProcessEvent(event2);
}
#endif // wxUSE_MENUS
-// methods for drawing the sizers in a visible way
-#ifdef __WXDEBUG__
+// methods for drawing the sizers in a visible way: this is currently only
+// enabled for "full debug" builds with wxDEBUG_LEVEL==2 as it doesn't work
+// that well and also because we don't want to leave it enabled in default
+// builds used for production
+#if wxDEBUG_LEVEL > 1
static void DrawSizers(wxWindowBase *win);
}
}
-#endif // __WXDEBUG__
+#endif // wxDEBUG_LEVEL
// process special middle clicks
void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
{
if ( event.ControlDown() && event.AltDown() )
{
-#ifdef __WXDEBUG__
+#if wxDEBUG_LEVEL > 1
// Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds
if ( event.ShiftDown() )
{
DrawSizers(this);
- return;
}
+ else
#endif // __WXDEBUG__
- ::wxInfoMessageBox((wxWindow*)this);
+ {
+ // just Ctrl-Alt-middle click shows information about wx version
+ ::wxInfoMessageBox((wxWindow*)this);
+ }
}
else
{
void wxWindowBase::CaptureMouse()
{
- wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), static_cast<void*>(this));
+ wxLogTrace(wxT("mousecapture"), wxT("CaptureMouse(%p)"), static_cast<void*>(this));
- wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive CaptureMouse call?") );
+ wxASSERT_MSG( !ms_winCaptureChanging, wxT("recursive CaptureMouse call?") );
ms_winCaptureChanging = true;
void wxWindowBase::ReleaseMouse()
{
- wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), static_cast<void*>(this));
+ wxLogTrace(wxT("mousecapture"), wxT("ReleaseMouse(%p)"), static_cast<void*>(this));
- wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive ReleaseMouse call?") );
+ wxASSERT_MSG( !ms_winCaptureChanging, wxT("recursive ReleaseMouse call?") );
wxASSERT_MSG( GetCapture() == this,
"attempt to release mouse, but this window hasn't captured it" );
ms_winCaptureChanging = false;
- wxLogTrace(_T("mousecapture"),
- (const wxChar *) _T("After ReleaseMouse() mouse is captured by %p"),
+ wxLogTrace(wxT("mousecapture"),
+ (const wxChar *) wxT("After ReleaseMouse() mouse is captured by %p"),
static_cast<void*>(GetCapture()));
}
// correctly if it loses capture unexpectedly; see the discussion here:
// http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863
// http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/82376
- wxFAIL_MSG( _T("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") );
+ wxFAIL_MSG( wxT("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") );
}
}
wxWindow *wxWindowBase::DoGetSibling(WindowOrder order) const
{
wxCHECK_MSG( GetParent(), NULL,
- _T("GetPrev/NextSibling() don't work for TLWs!") );
+ wxT("GetPrev/NextSibling() don't work for TLWs!") );
wxWindowList& siblings = GetParent()->GetChildren();
wxWindowList::compatibility_iterator i = siblings.Find((wxWindow *)this);
- wxCHECK_MSG( i, NULL, _T("window not a child of its parent?") );
+ wxCHECK_MSG( i, NULL, wxT("window not a child of its parent?") );
if ( order == OrderBefore )
i = i->GetPrevious();
{
// check that we're not a top level window
wxCHECK_RET( GetParent(),
- _T("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
+ wxT("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
// detect the special case when we have nothing to do anyhow and when the
// code below wouldn't work
// find the target window in the siblings list
wxWindowList& siblings = GetParent()->GetChildren();
wxWindowList::compatibility_iterator i = siblings.Find(win);
- wxCHECK_RET( i, _T("MoveBefore/AfterInTabOrder(): win is not a sibling") );
+ wxCHECK_RET( i, wxT("MoveBefore/AfterInTabOrder(): win is not a sibling") );
// unfortunately, when wxUSE_STL == 1 DetachNode() is not implemented so we
// can't just move the node around