#include "wx/frame.h"
#include "wx/defs.h"
#include "wx/window.h"
+ #include "wx/control.h"
#include "wx/checkbox.h"
#include "wx/radiobut.h"
+ #include "wx/textctrl.h"
#include "wx/settings.h"
#include "wx/dialog.h"
+ #include "wx/msgdlg.h"
+ #include "wx/statusbr.h"
#endif //WX_PRECOMP
#if wxUSE_CONSTRAINTS
#include "wx/layout.h"
#endif // wxUSE_CONSTRAINTS
+#include "wx/sizer.h"
+
#if wxUSE_DRAG_AND_DROP
#include "wx/dnd.h"
#endif // wxUSE_DRAG_AND_DROP
+#if wxUSE_HELP
+ #include "wx/cshelp.h"
+#endif // wxUSE_HELP
+
#if wxUSE_TOOLTIPS
#include "wx/tooltip.h"
#endif // wxUSE_TOOLTIPS
BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler)
EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged)
EVT_INIT_DIALOG(wxWindowBase::OnInitDialog)
+ EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick)
+
+#if wxUSE_HELP
+ EVT_HELP(-1, wxWindowBase::OnHelp)
+#endif // wxUSE_HELP
+
END_EVENT_TABLE()
// ============================================================================
m_isShown = FALSE;
m_isEnabled = TRUE;
- // no client data
- m_clientObject = (wxClientData *)NULL;
- m_clientData = NULL;
-
// the default event handler is just this window
m_eventHandler = this;
+#if wxUSE_VALIDATORS
// no validator
m_windowValidator = (wxValidator *) NULL;
+#endif // wxUSE_VALIDATORS
// use the system default colours
- wxSystemSettings settings;
+ m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
+ m_foregroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
- m_backgroundColour = settings.GetSystemColour(wxSYS_COLOUR_BTNFACE);
- m_foregroundColour = *wxBLACK; // TODO take this from sys settings too?
- m_font = *wxSWISS_FONT; // and this?
+ // 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::GetFont(wxSYS_DEFAULT_GUI_FONT);
+#endif // __WXMSW__
+
+ // the colours/fonts are default for now
+ m_hasBgCol =
+ m_hasFgCol =
+ m_hasFont = FALSE;
// no style bits
+ m_exStyle =
m_windowStyle = 0;
// an optimization for the event processing: checking this flag is much
// no constraints whatsoever
m_constraints = (wxLayoutConstraints *) NULL;
m_constraintsInvolvedIn = (wxWindowList *) NULL;
+#endif // wxUSE_CONSTRAINTS
+
m_windowSizer = (wxSizer *) NULL;
- m_sizerParent = (wxWindowBase *) NULL;
+ m_containingSizer = (wxSizer *) NULL;
m_autoLayout = FALSE;
-#endif // wxUSE_CONSTRAINTS
#if wxUSE_DRAG_AND_DROP
m_dropTarget = (wxDropTarget *)NULL;
#if wxUSE_CARET
m_caret = (wxCaret *)NULL;
#endif // wxUSE_CARET
+
+#if wxUSE_PALETTE
+ m_hasCustomPalette = FALSE;
+#endif // wxUSE_PALETTE
+
+ // Whether we're using the current theme for this window (wxGTK only for now)
+ m_themeEnabled = FALSE;
}
// common part of window creation process
const wxPoint& WXUNUSED(pos),
const wxSize& WXUNUSED(size),
long style,
+ const wxValidator& 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, _T("Init() must have been called before!") );
+ wxASSERT_MSG( m_isWindow, wxT("Init() must have been called before!") );
// generate a new id if the user doesn't care about it
m_windowId = id == -1 ? NewControlId() : id;
SetWindowStyleFlag(style);
SetParent(parent);
+#if wxUSE_VALIDATORS
+ SetValidator(validator);
+#endif // wxUSE_VALIDATORS
+
+ // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
+ // have it too - like this it's possible to set it only in the top level
+ // dialog/frame and all children will inherit it by defult
+ if ( parent && (parent->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) )
+ {
+ SetExtraStyle(wxWS_EX_VALIDATE_RECURSIVELY);
+ }
+
return TRUE;
}
// 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
// we weren't a dialog class
wxTopLevelWindows.DeleteObject(this);
- wxASSERT_MSG( GetChildren().GetCount() == 0, _T("children not destroyed") );
+ wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
#if wxUSE_CARET
if ( m_caret )
delete m_caret;
#endif // wxUSE_CARET
+#if wxUSE_VALIDATORS
if ( m_windowValidator )
delete m_windowValidator;
-
- if ( m_clientObject )
- delete m_clientObject;
+#endif // wxUSE_VALIDATORS
#if wxUSE_CONSTRAINTS
// Have to delete constraints/sizer FIRST otherwise sizers may try to look
m_constraints = NULL;
}
+#endif // wxUSE_CONSTRAINTS
+
+ if ( m_containingSizer )
+ m_containingSizer->Remove((wxWindow*)this);
+
if ( m_windowSizer )
delete m_windowSizer;
- // If this is a child of a sizer, remove self from parent
- if ( m_sizerParent )
- m_sizerParent->RemoveChild(this);
-#endif // wxUSE_CONSTRAINTS
-
#if wxUSE_DRAG_AND_DROP
if ( m_dropTarget )
delete m_dropTarget;
if ( 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);
+ }
}
bool wxWindowBase::Destroy()
wxWindow *child = node->GetData();
- wxASSERT_MSG( child, _T("children list contains empty nodes") );
+ wxASSERT_MSG( child, wxT("children list contains empty nodes") );
+ child->Show(FALSE);
delete child;
wxASSERT_MSG( !GetChildren().Find(child),
- _T("child didn't remove itself using RemoveChild()") );
+ wxT("child didn't remove itself using RemoveChild()") );
}
return TRUE;
}
// ----------------------------------------------------------------------------
-// centre/fit the window
+// size/position related methods
// ----------------------------------------------------------------------------
// centre the window with respect to its parent in either (or both) directions
void wxWindowBase::Centre(int direction)
{
+ // the position/size of the parent window or of the entire screen
+ wxPoint posParent;
int widthParent, heightParent;
- wxWindow *parent = GetParent();
- if ( parent )
+ wxWindow *parent = NULL;
+
+ if ( !(direction & wxCENTRE_ON_SCREEN) )
{
- parent->GetClientSize(&widthParent, &heightParent);
+ // find the parent to centre this window on: it should be the
+ // immediate parent for the controls but the top level parent for the
+ // top level windows (like dialogs)
+ parent = GetParent();
+ if ( IsTopLevel() )
+ {
+ while ( parent && !parent->IsTopLevel() )
+ {
+ parent = parent->GetParent();
+ }
+ }
+
+ // did we find the parent?
+ if ( !parent )
+ {
+ // no other choice
+ direction |= wxCENTRE_ON_SCREEN;
+ }
}
- else
+
+ if ( direction & wxCENTRE_ON_SCREEN )
{
// centre with respect to the whole screen
wxDisplaySize(&widthParent, &heightParent);
}
+ else
+ {
+ if ( IsTopLevel() )
+ {
+ // centre on the parent
+ parent->GetSize(&widthParent, &heightParent);
+
+ // adjust to the parents position
+ posParent = parent->GetPosition();
+ }
+ else
+ {
+ // centre inside the parents client rectangle
+ parent->GetClientSize(&widthParent, &heightParent);
+ }
+ }
int width, height;
GetSize(&width, &height);
- int new_x = -1,
- new_y = -1;
+ int xNew = -1,
+ yNew = -1;
if ( direction & wxHORIZONTAL )
- new_x = (widthParent - width)/2;
+ xNew = (widthParent - width)/2;
if ( direction & wxVERTICAL )
- new_y = (heightParent - height)/2;
+ yNew = (heightParent - height)/2;
+
+ xNew += posParent.x;
+ yNew += posParent.y;
- Move(new_x, new_y);
+ // Base size of the visible dimensions of the display
+ // to take into account the taskbar
+ wxRect rect = wxGetClientDisplayRect();
+ wxSize size (rect.width,rect.height);
+
+ // 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 + heightParent >= 0) // if parent is (partially) on the main display
+ {
+ if (yNew+height > size.y)
+ yNew = size.y-height-1;
+
+ // Make certain that the title bar is initially visible
+ // always, even if this would push the bottom of the
+ // dialog of the visible area of the display
+ if (yNew < 0)
+ yNew = 0;
+ }
+
+ // move the window to this position (keeping the old size but using
+ // SetSize() and not Move() to allow xNew and/or yNew to be -1)
+ SetSize(xNew, yNew, width, height, wxSIZE_ALLOW_MINUS_ONE);
}
// fits the window around the children
void wxWindowBase::Fit()
{
- int maxX = 0,
- maxY = 0;
+ if ( GetChildren().GetCount() > 0 )
+ {
+ wxSize size = DoGetBestSize();
- wxWindowList::Node *node = GetChildren().GetFirst();
- while ( node )
+ // 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;
+
+ SetClientSize(size);
+ }
+ //else: do nothing if we have no children
+}
+
+// return the size best suited for the current window
+wxSize wxWindowBase::DoGetBestSize() const
+{
+ if ( GetChildren().GetCount() > 0 )
{
- wxWindow *win = node->GetData();
- if ( win->IsKindOf(CLASSINFO(wxFrame)) ||
- win->IsKindOf(CLASSINFO(wxDialog)) )
+ // our minimal acceptable size is such that all our windows fit inside
+ int maxX = 0,
+ maxY = 0;
+
+ for ( wxWindowList::Node *node = GetChildren().GetFirst();
+ node;
+ node = node->GetNext() )
{
- // dialogs and frames line in different top level windows - don't
- // deal with them here
- continue;
- }
+ wxWindow *win = node->GetData();
+ if ( win->IsTopLevel()
+#if wxUSE_STATUSBAR
+ || wxDynamicCast(win, wxStatusBar)
+#endif // wxUSE_STATUSBAR
+ )
+ {
+ // dialogs and frames lie in different top level windows -
+ // don't deal with them here; as for the status bars, they
+ // don't lie in the client area at all
+ continue;
+ }
- int wx, wy, ww, wh;
- win->GetPosition(&wx, &wy);
- win->GetSize(&ww, &wh);
- if ( wx + ww > maxX )
- maxX = wx + ww;
- if ( wy + wh > maxY )
- maxY = wy + wh;
+ int wx, wy, ww, wh;
+ win->GetPosition(&wx, &wy);
+
+ // if the window hadn't been positioned yet, assume that it is in
+ // the origin
+ if ( wx == -1 )
+ wx = 0;
+ if ( wy == -1 )
+ wy = 0;
+
+ win->GetSize(&ww, &wh);
+ if ( wx + ww > maxX )
+ maxX = wx + ww;
+ if ( wy + wh > maxY )
+ maxY = wy + wh;
+ }
- node = node->GetNext();
+ return wxSize(maxX, maxY);
}
+ else
+ {
+ // for a generic window there is no natural best size - just use the
+ // current one
+ return GetSize();
+ }
+}
- // leave a margin
- SetClientSize(maxX + 7, maxY + 14);
+// by default the origin is not shifted
+wxPoint wxWindowBase::GetClientAreaOrigin() const
+{
+ return wxPoint(0, 0);
}
// set the min/max size of the window
-
void wxWindowBase::SetSizeHints(int minW, int minH,
int maxW, int maxH,
int WXUNUSED(incW), int WXUNUSED(incH))
return FALSE;
}
}
+// ----------------------------------------------------------------------------
+// RTTI
+// ----------------------------------------------------------------------------
+
+bool wxWindowBase::IsTopLevel() const
+{
+ return FALSE;
+}
// ----------------------------------------------------------------------------
// reparenting the window
void wxWindowBase::AddChild(wxWindowBase *child)
{
- wxCHECK_RET( child, _T("can't add a NULL child") );
+ wxCHECK_RET( child, wxT("can't add a NULL 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") );
GetChildren().Append(child);
child->SetParent(this);
void wxWindowBase::RemoveChild(wxWindowBase *child)
{
- wxCHECK_RET( child, _T("can't remove a NULL child") );
+ wxCHECK_RET( child, wxT("can't remove a NULL child") );
GetChildren().DeleteObject(child);
child->SetParent((wxWindow *)NULL);
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);
+ }
+
+ handler->SetNextHandler(NULL);
+
+ return TRUE;
+ }
+
+ handlerPrev = handlerCur;
+ handlerCur = handlerNext;
+ }
+
+ wxFAIL_MSG( _T("where has the event handler gone?") );
+
+ return FALSE;
+}
+
// ----------------------------------------------------------------------------
// cursors, fonts &c
// ----------------------------------------------------------------------------
m_backgroundColour = colour;
+ m_hasBgCol = TRUE;
+
return TRUE;
}
m_foregroundColour = colour;
+ m_hasFgCol = TRUE;
+
return TRUE;
}
bool wxWindowBase::SetCursor(const wxCursor& cursor)
{
- // don't try to set invalid cursor, always fall back to the default
- const wxCursor& cursorOk = cursor.Ok() ? cursor : *wxSTANDARD_CURSOR;
-
- if ( cursorOk == m_cursor )
+ // setting an invalid cursor is ok, it means that we don't have any special
+ // cursor
+ if ( m_cursor == cursor )
{
// no change
return FALSE;
}
- m_cursor = cursorOk;
+ m_cursor = cursor;
return TRUE;
}
m_font = fontOk;
+ 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);
+}
+
+wxWindow *wxWindowBase::GetAncestorWithCustomPalette() const
+{
+ wxWindow *win = (wxWindow *)this;
+ while ( win && !win->HasCustomPalette() )
+ {
+ win = win->GetParent();
+ }
+
+ return win;
+}
+
+#endif // wxUSE_PALETTE
+
#if wxUSE_CARET
void wxWindowBase::SetCaret(wxCaret *caret)
{
if ( m_caret )
{
wxASSERT_MSG( m_caret->GetWindow() == this,
- "caret should be created associated to this window" );
+ wxT("caret should be created associated to this window") );
}
}
#endif // wxUSE_CARET
+#if wxUSE_VALIDATORS
// ----------------------------------------------------------------------------
// validators
// ----------------------------------------------------------------------------
if ( m_windowValidator )
m_windowValidator->SetWindow(this) ;
}
+#endif // wxUSE_VALIDATORS
// ----------------------------------------------------------------------------
-// update region testing
+// update region stuff
// ----------------------------------------------------------------------------
+wxRect wxWindowBase::GetUpdateClientRect() const
+{
+ wxRegion rgnUpdate = GetUpdateRegion();
+ rgnUpdate.Intersect(GetClientRect());
+ wxRect rectUpdate = rgnUpdate.GetBox();
+ wxPoint ptOrigin = GetClientAreaOrigin();
+ rectUpdate.x -= ptOrigin.x;
+ rectUpdate.y -= ptOrigin.y;
+
+ return rectUpdate;
+}
+
bool wxWindowBase::IsExposed(int x, int y) const
{
return m_updateRegion.Contains(x, y) != wxOutRegion;
// dialog oriented functions
// ----------------------------------------------------------------------------
-void wxWindowBase::MakeModal(bool WXUNUSED(modal))
+void wxWindowBase::MakeModal(bool modal)
{
- wxFAIL_MSG(_T("TODO"));
+ // Disable all other windows
+ if ( IsTopLevel() )
+ {
+ wxWindowList::Node *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::Node *node;
for ( node = m_children.GetFirst(); node; node = node->GetNext() )
{
wxWindowBase *child = node->GetData();
wxValidator *validator = child->GetValidator();
- if ( validator && validator->Validate((wxWindow *)this) )
+ 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::Node *node;
for ( node = m_children.GetFirst(); node; node = node->GetNext() )
{
wxValidator *validator = child->GetValidator();
if ( validator && !validator->TransferToWindow() )
{
- wxLog *log = wxLog::GetActiveTarget();
- if ( log )
- {
- wxLogWarning(_("Could not transfer data to window"));
- log->Flush();
- }
+ wxLogWarning(_("Could not transfer data to window"));
+ wxLog::FlushActive();
return FALSE;
}
+
+ if ( recurse )
+ {
+ if ( !child->TransferDataToWindow() )
+ {
+ // warning already given
+ return FALSE;
+ }
+ }
}
+#endif // wxUSE_VALIDATORS
return TRUE;
}
bool wxWindowBase::TransferDataFromWindow()
{
+#if wxUSE_VALIDATORS
+ bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0;
+
wxWindowList::Node *node;
for ( node = m_children.GetFirst(); node; node = node->GetNext() )
{
wxWindow *child = node->GetData();
- if ( child->GetValidator() &&
- !child->GetValidator()->TransferFromWindow() )
+ wxValidator *validator = child->GetValidator();
+ if ( validator && !validator->TransferFromWindow() )
{
+ // nop warning here because the application is supposed to give
+ // one itself - we don't know here what might have gone wrongly
+
return FALSE;
}
+
+ if ( recurse )
+ {
+ if ( !child->TransferDataFromWindow() )
+ {
+ // warning already given
+ return FALSE;
+ }
+ }
}
+#endif // wxUSE_VALIDATORS
return TRUE;
}
}
// ----------------------------------------------------------------------------
-// tooltips
+// context-sensitive help support
+// ----------------------------------------------------------------------------
+
+#if wxUSE_HELP
+
+// associate this help text with this window
+void wxWindowBase::SetHelpText(const wxString& text)
+{
+ wxHelpProvider *helpProvider = wxHelpProvider::Get();
+ if ( helpProvider )
+ {
+ helpProvider->AddHelp(this, text);
+ }
+}
+
+// associate this help text with all windows with the same id as this
+// one
+void wxWindowBase::SetHelpTextForId(const wxString& text)
+{
+ wxHelpProvider *helpProvider = wxHelpProvider::Get();
+ if ( helpProvider )
+ {
+ helpProvider->AddHelp(GetId(), text);
+ }
+}
+
+// get the help string associated with this window (may be empty)
+wxString wxWindowBase::GetHelpText() const
+{
+ wxString text;
+ wxHelpProvider *helpProvider = wxHelpProvider::Get();
+ if ( helpProvider )
+ {
+ text = helpProvider->GetHelp(this);
+ }
+
+ return text;
+}
+
+// show help for this window
+void wxWindowBase::OnHelp(wxHelpEvent& event)
+{
+ wxHelpProvider *helpProvider = wxHelpProvider::Get();
+ if ( helpProvider )
+ {
+ if ( helpProvider->ShowHelp(this) )
+ {
+ // skip the event.Skip() below
+ return;
+ }
+ }
+
+ event.Skip();
+}
+
+#endif // wxUSE_HELP
+
+// ----------------------------------------------------------------------------
+// tooltipsroot.Replace("\\", "/");
// ----------------------------------------------------------------------------
#if wxUSE_TOOLTIPS
m_constraintsInvolvedIn = (wxWindowList *) NULL;
}
}
+#endif
-void wxWindowBase::SetSizer(wxSizer *sizer)
+void wxWindowBase::SetSizer(wxSizer *sizer, bool deleteOld)
{
+ if (m_windowSizer && deleteOld) delete m_windowSizer;
+
m_windowSizer = sizer;
- if ( sizer )
- sizer->SetSizerParent(this);
}
bool wxWindowBase::Layout()
{
- if ( GetConstraints() )
+ // If there is a sizer, use it instead of the constraints
+ if ( GetSizer() )
{
int w, h;
GetClientSize(&w, &h);
- GetConstraints()->width.SetValue(w);
- GetConstraints()->height.SetValue(h);
- }
- // If top level (one sizer), evaluate the sizer's constraints.
- if ( GetSizer() )
- {
- int noChanges;
- GetSizer()->ResetConstraints(); // Mark all constraints as unevaluated
- GetSizer()->LayoutPhase1(&noChanges);
- GetSizer()->LayoutPhase2(&noChanges);
- GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
- return TRUE;
+ GetSizer()->SetDimension( 0, 0, w, h );
}
+#if wxUSE_CONSTRAINTS
else
{
- // Otherwise, evaluate child constraints
+ wxLayoutConstraints *constr = GetConstraints();
+ bool wasOk = constr && constr->AreSatisfied();
+
ResetConstraints(); // Mark all constraints as unevaluated
- DoPhase(1); // Just one phase need if no sizers involved
- DoPhase(2);
+
+ // 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
SetConstraintSizes(); // Recursively set the real window sizes
}
+#endif
+
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.
while (node)
{
wxWindow *child = node->GetData();
- if ( !child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)) )
+ if ( !child->IsTopLevel() )
{
wxLayoutConstraints *constr = child->GetConstraints();
if ( constr )
constr->centreX.SetDone(FALSE);
constr->centreY.SetDone(FALSE);
}
+
wxWindowList::Node *node = GetChildren().GetFirst();
while (node)
{
wxWindow *win = node->GetData();
- if ( !win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)) )
+ if ( !win->IsTopLevel() )
win->ResetConstraints();
node = node->GetNext();
}
void wxWindowBase::SetConstraintSizes(bool recurse)
{
wxLayoutConstraints *constr = GetConstraints();
- if ( constr && constr->left.GetDone() && constr->right.GetDone( ) &&
- constr->width.GetDone() && constr->height.GetDone())
+ if ( constr && constr->AreSatisfied() )
{
int x = constr->left.GetValue();
int y = constr->top.GetValue();
int w = constr->width.GetValue();
int h = constr->height.GetValue();
- // If we don't want to resize this window, just move it...
if ( (constr->width.GetRelationship() != wxAsIs ) ||
- (constr->height.GetRelationship() != wxAsIs))
+ (constr->height.GetRelationship() != wxAsIs) )
{
- // Calls Layout() recursively. AAAGH. How can we stop that.
- // Simply take Layout() out of non-top level OnSizes.
- SizerSetSize(x, y, w, h);
+ SetSize(x, y, w, h);
}
else
{
- SizerMove(x, y);
+ // If we don't want to resize this window, just move it...
+ Move(x, y);
}
}
else if ( constr )
{
- wxChar *windowClass = GetClassInfo()->GetClassName();
-
- wxString winName;
- if ( GetName() == _T("") )
- winName = _T("unnamed");
- else
- winName = GetName();
- wxLogDebug( _T("Constraint(s) not satisfied for window of type %s, name %s:\n"),
- (const wxChar *)windowClass,
- (const wxChar *)winName);
- if ( !constr->left.GetDone()) wxLogDebug( _T(" unsatisfied 'left' constraint.\n") );
- if ( !constr->right.GetDone()) wxLogDebug( _T(" unsatisfied 'right' constraint.\n") );
- if ( !constr->width.GetDone()) wxLogDebug( _T(" unsatisfied 'width' constraint.\n") );
- if ( !constr->height.GetDone()) wxLogDebug( _T(" unsatisfied 'height' constraint.\n") );
- wxLogDebug( _T("Please check constraints: try adding AsIs() constraints.\n") );
+ wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
+ GetClassInfo()->GetClassName(),
+ GetName().c_str());
}
if ( recurse )
while (node)
{
wxWindow *win = node->GetData();
- if ( !win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)) )
+ if ( !win->IsTopLevel() && win->GetConstraints() )
win->SetConstraintSizes();
node = node->GetNext();
}
}
}
-// This assumes that all sizers are 'on' the same window, i.e. the parent of
-// this window.
-void wxWindowBase::TransformSizerToActual(int *x, int *y) const
-{
- if ( !m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog) ) ||
- m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
- return;
-
- int xp, yp;
- m_sizerParent->GetPosition(&xp, &yp);
- m_sizerParent->TransformSizerToActual(&xp, &yp);
- *x += xp;
- *y += yp;
-}
-
-void wxWindowBase::SizerSetSize(int x, int y, int w, int h)
-{
- int xx = x;
- int yy = y;
- TransformSizerToActual(&xx, &yy);
- SetSize(xx, yy, w, h);
-}
-
-void wxWindowBase::SizerMove(int x, int y)
-{
- int xx = x;
- int yy = y;
- TransformSizerToActual(&xx, &yy);
- Move(xx, yy);
-}
-
// Only set the size/position of the constraint (if any)
void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h)
{
#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
+ if ( !IsTopLevel() )
+ {
+ wxWindow *parent = GetParent();
+ if ( !(sizeFlags & wxSIZE_NO_ADJUSTMENTS) && parent )
+ {
+ wxPoint pt(parent->GetClientAreaOrigin());
+ x += pt.x;
+ y += pt.y;
+ }
+ }
+}
+
// ----------------------------------------------------------------------------
// do Update UI processing for child controls
// ----------------------------------------------------------------------------
// of control classes.
void wxWindowBase::UpdateWindowUI()
{
- wxWindowID id = GetId();
- if ( id > 0 )
+#if wxUSE_CONTROLS
+ wxUpdateUIEvent event(GetId());
+ event.m_eventObject = this;
+
+ if ( GetEventHandler()->ProcessEvent(event) )
{
- wxUpdateUIEvent event(id);
- event.m_eventObject = this;
+ if ( event.GetSetEnabled() )
+ Enable(event.GetEnabled());
- if ( GetEventHandler()->ProcessEvent(event) )
+ if ( event.GetSetText() )
{
- if ( event.GetSetEnabled() )
- Enable(event.GetEnabled());
-
- if ( event.GetSetText() && IsKindOf(CLASSINFO(wxControl)) )
- ((wxControl*)this)->SetLabel(event.GetText());
-
- if ( IsKindOf(CLASSINFO(wxCheckBox)) )
+ wxControl *control = wxDynamicCastThis(wxControl);
+ if ( control )
{
- if ( event.GetSetChecked() )
- ((wxCheckBox *)this)->SetValue(event.GetChecked());
- }
- else if ( IsKindOf(CLASSINFO(wxRadioButton)) )
- {
- if ( event.GetSetChecked() )
- ((wxRadioButton *) this)->SetValue(event.GetChecked());
+#if wxUSE_TEXTCTRL
+ wxTextCtrl *text = wxDynamicCast(control, wxTextCtrl);
+ if ( text )
+ text->SetValue(event.GetText());
+ else
+#endif // wxUSE_TEXTCTRL
+ control->SetLabel(event.GetText());
}
}
+
+#if wxUSE_CHECKBOX
+ wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox);
+ if ( checkbox )
+ {
+ if ( event.GetSetChecked() )
+ checkbox->SetValue(event.GetChecked());
+ }
+#endif // wxUSE_CHECKBOX
+
+#if wxUSE_RADIOBTN
+ wxRadioButton *radiobtn = wxDynamicCastThis(wxRadioButton);
+ if ( radiobtn )
+ {
+ if ( event.GetSetChecked() )
+ radiobtn->SetValue(event.GetChecked());
+ }
+#endif // wxUSE_RADIOBTN
}
+#endif // wxUSE_CONTROLS
}
// ----------------------------------------------------------------------------
{
int charWidth = GetCharWidth();
int charHeight = GetCharHeight();
- wxPoint pt2;
- pt2.x = (int) ((pt.x * 4) / charWidth) ;
- pt2.y = (int) ((pt.y * 8) / charHeight) ;
+ wxPoint pt2(-1, -1);
+ if (pt.x != -1)
+ pt2.x = (int) ((pt.x * 4) / charWidth) ;
+ if (pt.y != -1)
+ pt2.y = (int) ((pt.y * 8) / charHeight) ;
return pt2;
}
{
int charWidth = GetCharWidth();
int charHeight = GetCharHeight();
- wxPoint pt2;
- pt2.x = (int) ((pt.x * charWidth) / 4) ;
- pt2.y = (int) ((pt.y * charHeight) / 8) ;
+ wxPoint pt2(-1, -1);
+ if (pt.x != -1)
+ pt2.x = (int) ((pt.x * charWidth) / 4) ;
+ if (pt.y != -1)
+ pt2.y = (int) ((pt.y * charHeight) / 8) ;
return pt2;
}
TransferDataToWindow();
}
+// process Ctrl-Alt-mclick
+void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
+{
+#if wxUSE_MSGDLG
+ if ( event.ControlDown() && event.AltDown() )
+ {
+ // don't translate these strings
+ wxString port;
+
+#ifdef __WXUNIVERSAL__
+ port = _T("Univ/");
+#endif // __WXUNIVERSAL__
+
+ switch ( wxGetOsVersion() )
+ {
+ case wxMOTIF_X: port = _T("Motif"); break;
+ case wxMAC:
+ 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 wxWINDOWS:
+ case wxPENWINDOWS:
+ case wxWINDOWS_NT:
+ case wxWIN32S:
+ case wxWIN95:
+ case wxWIN386: port = _T("MS Windows"); break;
+ case wxMGL_UNIX:
+ case wxMGL_X:
+ case wxMGL_WIN32:
+ case wxMGL_OS2: port = _T("MGL"); break;
+ case wxWINDOWS_OS2:
+ 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-2002 wxWindows team"
+ ),
+ port.c_str(),
+ wxMAJOR_VERSION,
+ wxMINOR_VERSION,
+ wxRELEASE_NUMBER,
+#if wxUSE_UNICODE
+ L" (Unicode)",
+#else
+ "",
+#endif
+ __TDATE__,
+ __TTIME__
+ ),
+ _T("wxWindows information"),
+ wxICON_INFORMATION | wxOK,
+ (wxWindow *)this);
+ }
+ else
+#endif // wxUSE_MSGDLG
+ {
+ event.Skip();
+ }
+}
+
// ----------------------------------------------------------------------------
// list classes implementation
// ----------------------------------------------------------------------------
delete (wxWindow *)GetData();
}
+// ----------------------------------------------------------------------------
+// borders
+// ----------------------------------------------------------------------------
+
+wxBorder wxWindowBase::GetBorder() const
+{
+ wxBorder border = (wxBorder)(m_windowStyle & wxBORDER_MASK);
+ if ( border == wxBORDER_DEFAULT )
+ {
+ border = GetDefaultBorder();
+ }
+
+ return border;
+}
+
+wxBorder wxWindowBase::GetDefaultBorder() const
+{
+ return wxBORDER_NONE;
+}
+
+// ----------------------------------------------------------------------------
+// hit testing
+// ----------------------------------------------------------------------------
+
+wxHitTest wxWindowBase::DoHitTest(wxCoord x, wxCoord y) const
+{
+ // here we just check if the point is inside the window or not
+
+ // check the top and left border first
+ bool outside = x < 0 || y < 0;
+ if ( !outside )
+ {
+ // check the right and bottom borders too
+ wxSize size = GetSize();
+ outside = x >= size.x || y >= size.y;
+ }
+
+ 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(0x%08x)"), 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(0x%08x)"), 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"),
+ _T("After ReleaseMouse() mouse is captured by 0x%08x"),
+ GetCapture());
+}
+
+// vi:sts=4:sw=4:et
projects / wxWidgets.git / blobdiff