32ac755d4a
Added debug code because I dont know why buttons sometimes work and sometimes not. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2394 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
352 lines
11 KiB
C++
352 lines
11 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: layout.h
|
|
// Purpose: Layout classes
|
|
// Author: Julian Smart
|
|
// Modified by:
|
|
// Created: 29/01/98
|
|
// RCS-ID: $Id$
|
|
// Copyright: (c) 1998 Julian Smart
|
|
// Licence: wxWindows license
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef _WX_LAYOUTH__
|
|
#define _WX_LAYOUTH__
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// headers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#ifdef __GNUG__
|
|
#pragma interface "layout.h"
|
|
#endif
|
|
|
|
#include "wx/defs.h"
|
|
|
|
// X stupidly defines these in X.h
|
|
#ifdef Above
|
|
#undef Above
|
|
#endif
|
|
#ifdef Below
|
|
#undef Below
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// forward declrations
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class WXDLLEXPORT wxWindowBase;
|
|
class WXDLLEXPORT wxLayoutConstraints;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// constants
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#define wxLAYOUT_DEFAULT_MARGIN 0
|
|
|
|
enum wxEdge
|
|
{
|
|
wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
|
|
wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY
|
|
};
|
|
|
|
enum wxRelationship
|
|
{
|
|
wxUnconstrained = 0,
|
|
wxAsIs,
|
|
wxPercentOf,
|
|
wxAbove,
|
|
wxBelow,
|
|
wxLeftOf,
|
|
wxRightOf,
|
|
wxSameAs,
|
|
wxAbsolute
|
|
};
|
|
|
|
enum wxSizerBehaviour
|
|
{
|
|
wxSizerShrink,
|
|
wxSizerExpand,
|
|
wxSizerNone
|
|
};
|
|
|
|
#define wxTYPE_SIZER 90
|
|
|
|
// =============================================================================
|
|
// classes
|
|
// =============================================================================
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxIndividualLayoutConstraint: a constraint on window position
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class WXDLLEXPORT wxIndividualLayoutConstraint : public wxObject
|
|
{
|
|
DECLARE_DYNAMIC_CLASS(wxIndividualLayoutConstraint)
|
|
|
|
protected:
|
|
// To be allowed to modify the internal variables
|
|
friend class wxIndividualLayoutConstraint_Serialize;
|
|
|
|
// 'This' window is the parent or sibling of otherWin
|
|
wxWindowBase *otherWin;
|
|
|
|
wxEdge myEdge;
|
|
wxRelationship relationship;
|
|
int margin;
|
|
int value;
|
|
int percent;
|
|
wxEdge otherEdge;
|
|
bool done;
|
|
|
|
public:
|
|
wxIndividualLayoutConstraint();
|
|
~wxIndividualLayoutConstraint();
|
|
|
|
void Set(wxRelationship rel, wxWindowBase *otherW, wxEdge otherE, int val = 0, int marg = wxLAYOUT_DEFAULT_MARGIN);
|
|
|
|
//
|
|
// Sibling relationships
|
|
//
|
|
void LeftOf(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
|
|
void RightOf(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
|
|
void Above(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
|
|
void Below(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
|
|
|
|
//
|
|
// 'Same edge' alignment
|
|
//
|
|
void SameAs(wxWindowBase *otherW, wxEdge edge, int marg = wxLAYOUT_DEFAULT_MARGIN);
|
|
|
|
// The edge is a percentage of the other window's edge
|
|
void PercentOf(wxWindowBase *otherW, wxEdge wh, int per);
|
|
|
|
//
|
|
// Edge has absolute value
|
|
//
|
|
void Absolute(int val);
|
|
|
|
//
|
|
// Dimension is unconstrained
|
|
//
|
|
void Unconstrained() { relationship = wxUnconstrained; }
|
|
|
|
//
|
|
// Dimension is 'as is' (use current size settings)
|
|
//
|
|
void AsIs() { relationship = wxAsIs; }
|
|
|
|
//
|
|
// Accessors
|
|
//
|
|
wxWindowBase *GetOtherWindow() { return otherWin; }
|
|
wxEdge GetMyEdge() const { return myEdge; }
|
|
void SetEdge(wxEdge which) { myEdge = which; }
|
|
void SetValue(int v) { value = v; }
|
|
int GetMargin() { return margin; }
|
|
void SetMargin(int m) { margin = m; }
|
|
int GetValue() const { return value; }
|
|
int GetPercent() const { return percent; }
|
|
int GetOtherEdge() const { return otherEdge; }
|
|
bool GetDone() const { return done; }
|
|
void SetDone(bool d) { done = d; }
|
|
wxRelationship GetRelationship() { return relationship; }
|
|
void SetRelationship(wxRelationship r) { relationship = r; }
|
|
|
|
// Reset constraint if it mentions otherWin
|
|
bool ResetIfWin(wxWindowBase *otherW);
|
|
|
|
// Try to satisfy constraint
|
|
bool SatisfyConstraint(wxLayoutConstraints *constraints, wxWindowBase *win);
|
|
|
|
// Get the value of this edge or dimension, or if this
|
|
// is not determinable, -1.
|
|
int GetEdge(wxEdge which, wxWindowBase *thisWin, wxWindowBase *other) const;
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxLayoutConstraints: the complete set of constraints for a window
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class WXDLLEXPORT wxLayoutConstraints : public wxObject
|
|
{
|
|
DECLARE_DYNAMIC_CLASS(wxLayoutConstraints)
|
|
|
|
public:
|
|
// Edge constraints
|
|
wxIndividualLayoutConstraint left;
|
|
wxIndividualLayoutConstraint top;
|
|
wxIndividualLayoutConstraint right;
|
|
wxIndividualLayoutConstraint bottom;
|
|
// Size constraints
|
|
wxIndividualLayoutConstraint width;
|
|
wxIndividualLayoutConstraint height;
|
|
// Centre constraints
|
|
wxIndividualLayoutConstraint centreX;
|
|
wxIndividualLayoutConstraint centreY;
|
|
|
|
wxLayoutConstraints();
|
|
~wxLayoutConstraints();
|
|
|
|
bool SatisfyConstraints(wxWindowBase *win, int *noChanges);
|
|
bool AreSatisfied() const
|
|
{
|
|
return left.GetDone() && top.GetDone() && right.GetDone() &&
|
|
bottom.GetDone() && centreX.GetDone() && centreY.GetDone();
|
|
}
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// sizers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/*
|
|
|
|
Algorithm:
|
|
|
|
Each sizer has a Layout function.
|
|
|
|
wxExpandSizer::Layout ; E.g. for resizeable windows
|
|
|
|
- parent size must be known (i.e. called
|
|
from OnSize or explicitly)
|
|
- call Layout on each child to give it a chance to resize
|
|
(e.g. child shrinks around its own children):
|
|
stop when all children return TRUE, or no change
|
|
- evaluate constraints on self to set size
|
|
|
|
wxShrinkSizer::Layout ; E.g. fit-to-contents windows
|
|
; Perhaps 2 rowcols, one above other.
|
|
|
|
- call Layout on each child to give it a chance to resize
|
|
(e.g. child shrinks around its own children):
|
|
stop when each returns TRUE, or no change
|
|
- fit around children
|
|
(what if some want to be centred? E.g. OK/Cancel rowcol.
|
|
- done by centring e.g. bottom sizer w.r.t. top sizer.
|
|
(sibling relationship only))
|
|
- evaluate own constraints (e.g. may be below another window)
|
|
- IF parent is a real window (remember: a real window can
|
|
have only one child sizer, although a sizer can have several child
|
|
(real) windows), then resize this parent WITHOUT invoking Layout
|
|
again.
|
|
Frame and dialog box OnSizes can check if the sizer is a shrink
|
|
sizer; if not, can call layout. Maybe have virtual bool AutoSizeLayout()
|
|
to determine this.
|
|
|
|
How to relayout if a child sizer/window changes? Need to go all the way
|
|
to the top of the hierarchy and call Layout() again.
|
|
|
|
wxRowColSizer::Layout
|
|
|
|
- Similar to wxShrinkSizer only instead of shrinking to fit
|
|
contents, more sophisticated layout of contents, and THEN
|
|
shrinking (possibly).
|
|
- Do the same parent window check/setsize as for wxShrinkSizer.
|
|
|
|
*/
|
|
|
|
class WXDLLEXPORT wxSizer : public wxWindow
|
|
{
|
|
DECLARE_DYNAMIC_CLASS(wxSizer)
|
|
|
|
protected:
|
|
wxSizerBehaviour sizerBehaviour;
|
|
int borderX;
|
|
int borderY;
|
|
int sizerWidth;
|
|
int sizerHeight;
|
|
int sizerX;
|
|
int sizerY;
|
|
|
|
public:
|
|
wxSizer();
|
|
wxSizer(wxWindowBase *parent, wxSizerBehaviour behav = wxSizerNone);
|
|
~wxSizer();
|
|
|
|
bool Create(wxWindowBase *parent, wxSizerBehaviour behav = wxSizerNone);
|
|
|
|
virtual void DoGetSize(int *w, int *h) const;
|
|
virtual void DoGetClientSize(int *w, int *h) const { GetSize(w, h); }
|
|
virtual void DoGetPosition(int *x, int *y) const;
|
|
|
|
void SizerSetSize(int x, int y, int w, int h) { SetSize(x, y, w, h); }
|
|
void SizerMove(int x, int y) { Move(x, y); }
|
|
|
|
virtual void SetBorder(int w, int h);
|
|
int GetBorderX() { return borderX ; }
|
|
int GetBorderY() { return borderY ; }
|
|
|
|
virtual void AddSizerChild(wxWindowBase *child);
|
|
virtual void RemoveSizerChild(wxWindowBase *child);
|
|
|
|
virtual void SetBehaviour(wxSizerBehaviour b) { sizerBehaviour = b; }
|
|
virtual wxSizerBehaviour GetBehaviour() { return sizerBehaviour; }
|
|
|
|
virtual bool LayoutPhase1(int *);
|
|
virtual bool LayoutPhase2(int *);
|
|
|
|
protected:
|
|
virtual void DoSetSize(int x, int y,
|
|
int width, int height,
|
|
int sizeFlags = wxSIZE_AUTO);
|
|
};
|
|
|
|
#define wxSIZER_ROWS TRUE
|
|
#define wxSIZER_COLS FALSE
|
|
|
|
class WXDLLEXPORT wxRowColSizer : public wxSizer
|
|
{
|
|
DECLARE_DYNAMIC_CLASS(wxRowColSizer)
|
|
|
|
protected:
|
|
bool rowOrCol;
|
|
int rowOrColSize;
|
|
int xSpacing;
|
|
int ySpacing;
|
|
|
|
public:
|
|
// rowOrCol = TRUE to be laid out in rows, otherwise in columns.
|
|
wxRowColSizer();
|
|
wxRowColSizer(wxWindowBase *parent, bool rowOrCol = wxSIZER_ROWS,
|
|
int rowsOrColSize = 20, wxSizerBehaviour = wxSizerShrink);
|
|
~wxRowColSizer();
|
|
|
|
bool Create(wxWindowBase *parent, bool rowOrCol = wxSIZER_ROWS,
|
|
int rowsOrColSize = 20, wxSizerBehaviour = wxSizerShrink);
|
|
|
|
virtual void SetRowOrCol(bool rc) { rowOrCol = rc; }
|
|
virtual bool GetRowOrCol() { return rowOrCol; }
|
|
virtual void SetRowOrColSize(int n) { rowOrColSize = n; }
|
|
virtual int GetRowOrColSize() { return rowOrColSize; }
|
|
virtual void SetSpacing(int x, int y) { xSpacing = x; ySpacing = y; }
|
|
virtual void GetSpacing(int *x, int *y) { *x = xSpacing; *y = ySpacing; }
|
|
|
|
bool LayoutPhase1(int *);
|
|
bool LayoutPhase2(int *);
|
|
};
|
|
|
|
class WXDLLEXPORT wxSpacingSizer : public wxSizer
|
|
{
|
|
DECLARE_DYNAMIC_CLASS(wxSpacingSizer)
|
|
|
|
public:
|
|
wxSpacingSizer();
|
|
wxSpacingSizer(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int spacing);
|
|
wxSpacingSizer(wxWindowBase *parent);
|
|
~wxSpacingSizer();
|
|
|
|
bool Create(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int sp);
|
|
bool Create(wxWindowBase *parent);
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// global functions
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#if WXWIN_COMPATIBILITY
|
|
extern bool WXDLLEXPORT wxOldDoLayout(wxWindowBase *win);
|
|
#endif // WXWIN_COMPATIBILITY
|
|
|
|
#endif
|
|
// _WX_LAYOUTH__
|