3f66f6a5b3
This keyword is not expanded by Git which means it's not replaced with the correct revision value in the releases made using git-based scripts and it's confusing to have lines with unexpanded "$Id$" in the released files. As expanding them with Git is not that simple (it could be done with git archive and export-subst attribute) and there are not many benefits in having them in the first place, just remove all these lines. If nothing else, this will make an eventual transition to Git simpler. Closes #14487. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@74602 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
342 lines
12 KiB
C++
342 lines
12 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: wx/gbsizer.h
|
|
// Purpose: wxGridBagSizer: A sizer that can lay out items in a grid,
|
|
// with items at specified cells, and with the option of row
|
|
// and/or column spanning
|
|
//
|
|
// Author: Robin Dunn
|
|
// Created: 03-Nov-2003
|
|
// Copyright: (c) Robin Dunn
|
|
// Licence: wxWindows licence
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef __WXGBSIZER_H__
|
|
#define __WXGBSIZER_H__
|
|
|
|
#include "wx/sizer.h"
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Classes to represent a position in the grid and a size of an item in the
|
|
// grid, IOW, the number of rows and columns it occupies. I chose to use these
|
|
// instead of wxPoint and wxSize because they are (x,y) and usually pixel
|
|
// oriented while grids and tables are usually thought of as (row,col) so some
|
|
// confusion would definitely result in using wxPoint...
|
|
//
|
|
// NOTE: This should probably be refactored to a common RowCol data type which
|
|
// is used for this and also for wxGridCellCoords.
|
|
//---------------------------------------------------------------------------
|
|
|
|
class WXDLLIMPEXP_CORE wxGBPosition
|
|
{
|
|
public:
|
|
wxGBPosition() : m_row(0), m_col(0) {}
|
|
wxGBPosition(int row, int col) : m_row(row), m_col(col) {}
|
|
|
|
// default copy ctor and assignment operator are okay.
|
|
|
|
int GetRow() const { return m_row; }
|
|
int GetCol() const { return m_col; }
|
|
void SetRow(int row) { m_row = row; }
|
|
void SetCol(int col) { m_col = col; }
|
|
|
|
bool operator==(const wxGBPosition& p) const { return m_row == p.m_row && m_col == p.m_col; }
|
|
bool operator!=(const wxGBPosition& p) const { return !(*this == p); }
|
|
|
|
private:
|
|
int m_row;
|
|
int m_col;
|
|
};
|
|
|
|
|
|
class WXDLLIMPEXP_CORE wxGBSpan
|
|
{
|
|
public:
|
|
wxGBSpan() { Init(); }
|
|
wxGBSpan(int rowspan, int colspan)
|
|
{
|
|
// Initialize the members to valid values as not doing it may result in
|
|
// infinite loop in wxGBSizer code if the user passed 0 for any of
|
|
// them, see #12934.
|
|
Init();
|
|
|
|
SetRowspan(rowspan);
|
|
SetColspan(colspan);
|
|
}
|
|
|
|
// default copy ctor and assignment operator are okay.
|
|
|
|
// Factor constructor creating an invalid wxGBSpan: this is mostly supposed
|
|
// to be used as return value for functions returning wxGBSpan in case of
|
|
// errors.
|
|
static wxGBSpan Invalid()
|
|
{
|
|
return wxGBSpan(NULL);
|
|
}
|
|
|
|
int GetRowspan() const { return m_rowspan; }
|
|
int GetColspan() const { return m_colspan; }
|
|
void SetRowspan(int rowspan)
|
|
{
|
|
wxCHECK_RET( rowspan > 0, "Row span should be strictly positive" );
|
|
|
|
m_rowspan = rowspan;
|
|
}
|
|
|
|
void SetColspan(int colspan)
|
|
{
|
|
wxCHECK_RET( colspan > 0, "Column span should be strictly positive" );
|
|
|
|
m_colspan = colspan;
|
|
}
|
|
|
|
bool operator==(const wxGBSpan& o) const { return m_rowspan == o.m_rowspan && m_colspan == o.m_colspan; }
|
|
bool operator!=(const wxGBSpan& o) const { return !(*this == o); }
|
|
|
|
private:
|
|
// This private ctor is used by Invalid() only.
|
|
wxGBSpan(struct InvalidCtorTag*)
|
|
{
|
|
m_rowspan =
|
|
m_colspan = -1;
|
|
}
|
|
|
|
void Init()
|
|
{
|
|
m_rowspan =
|
|
m_colspan = 1;
|
|
}
|
|
|
|
int m_rowspan;
|
|
int m_colspan;
|
|
};
|
|
|
|
|
|
extern WXDLLIMPEXP_DATA_CORE(const wxGBSpan) wxDefaultSpan;
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// wxGBSizerItem
|
|
//---------------------------------------------------------------------------
|
|
|
|
class WXDLLIMPEXP_FWD_CORE wxGridBagSizer;
|
|
|
|
|
|
class WXDLLIMPEXP_CORE wxGBSizerItem : public wxSizerItem
|
|
{
|
|
public:
|
|
// spacer
|
|
wxGBSizerItem( int width,
|
|
int height,
|
|
const wxGBPosition& pos,
|
|
const wxGBSpan& span=wxDefaultSpan,
|
|
int flag=0,
|
|
int border=0,
|
|
wxObject* userData=NULL);
|
|
|
|
// window
|
|
wxGBSizerItem( wxWindow *window,
|
|
const wxGBPosition& pos,
|
|
const wxGBSpan& span=wxDefaultSpan,
|
|
int flag=0,
|
|
int border=0,
|
|
wxObject* userData=NULL );
|
|
|
|
// subsizer
|
|
wxGBSizerItem( wxSizer *sizer,
|
|
const wxGBPosition& pos,
|
|
const wxGBSpan& span=wxDefaultSpan,
|
|
int flag=0,
|
|
int border=0,
|
|
wxObject* userData=NULL );
|
|
|
|
// default ctor
|
|
wxGBSizerItem();
|
|
|
|
|
|
// Get the grid position of the item
|
|
wxGBPosition GetPos() const { return m_pos; }
|
|
void GetPos(int& row, int& col) const;
|
|
|
|
// Get the row and column spanning of the item
|
|
wxGBSpan GetSpan() const { return m_span; }
|
|
void GetSpan(int& rowspan, int& colspan) const;
|
|
|
|
// If the item is already a member of a sizer then first ensure that there
|
|
// is no other item that would intersect with this one at the new
|
|
// position, then set the new position. Returns true if the change is
|
|
// successful and after the next Layout the item will be moved.
|
|
bool SetPos( const wxGBPosition& pos );
|
|
|
|
// If the item is already a member of a sizer then first ensure that there
|
|
// is no other item that would intersect with this one with its new
|
|
// spanning size, then set the new spanning. Returns true if the change
|
|
// is successful and after the next Layout the item will be resized.
|
|
bool SetSpan( const wxGBSpan& span );
|
|
|
|
// Returns true if this item and the other item intersect
|
|
bool Intersects(const wxGBSizerItem& other);
|
|
|
|
// Returns true if the given pos/span would intersect with this item.
|
|
bool Intersects(const wxGBPosition& pos, const wxGBSpan& span);
|
|
|
|
// Get the row and column of the endpoint of this item
|
|
void GetEndPos(int& row, int& col);
|
|
|
|
|
|
wxGridBagSizer* GetGBSizer() const { return m_gbsizer; }
|
|
void SetGBSizer(wxGridBagSizer* sizer) { m_gbsizer = sizer; }
|
|
|
|
|
|
protected:
|
|
wxGBPosition m_pos;
|
|
wxGBSpan m_span;
|
|
wxGridBagSizer* m_gbsizer; // so SetPos/SetSpan can check for intersects
|
|
|
|
|
|
private:
|
|
DECLARE_DYNAMIC_CLASS(wxGBSizerItem)
|
|
wxDECLARE_NO_COPY_CLASS(wxGBSizerItem);
|
|
};
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// wxGridBagSizer
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
class WXDLLIMPEXP_CORE wxGridBagSizer : public wxFlexGridSizer
|
|
{
|
|
public:
|
|
wxGridBagSizer(int vgap = 0, int hgap = 0 );
|
|
|
|
// The Add methods return true if the item was successfully placed at the
|
|
// given position, false if something was already there.
|
|
wxSizerItem* Add( wxWindow *window,
|
|
const wxGBPosition& pos,
|
|
const wxGBSpan& span = wxDefaultSpan,
|
|
int flag = 0,
|
|
int border = 0,
|
|
wxObject* userData = NULL );
|
|
wxSizerItem* Add( wxSizer *sizer,
|
|
const wxGBPosition& pos,
|
|
const wxGBSpan& span = wxDefaultSpan,
|
|
int flag = 0,
|
|
int border = 0,
|
|
wxObject* userData = NULL );
|
|
wxSizerItem* Add( int width,
|
|
int height,
|
|
const wxGBPosition& pos,
|
|
const wxGBSpan& span = wxDefaultSpan,
|
|
int flag = 0,
|
|
int border = 0,
|
|
wxObject* userData = NULL );
|
|
wxSizerItem* Add( wxGBSizerItem *item );
|
|
|
|
|
|
// Get/Set the size used for cells in the grid with no item.
|
|
wxSize GetEmptyCellSize() const { return m_emptyCellSize; }
|
|
void SetEmptyCellSize(const wxSize& sz) { m_emptyCellSize = sz; }
|
|
|
|
// Get the size of the specified cell, including hgap and vgap. Only
|
|
// valid after a Layout.
|
|
wxSize GetCellSize(int row, int col) const;
|
|
|
|
// Get the grid position of the specified item (non-recursive)
|
|
wxGBPosition GetItemPosition(wxWindow *window);
|
|
wxGBPosition GetItemPosition(wxSizer *sizer);
|
|
wxGBPosition GetItemPosition(size_t index);
|
|
|
|
// Set the grid position of the specified item. Returns true on success.
|
|
// If the move is not allowed (because an item is already there) then
|
|
// false is returned. (non-recursive)
|
|
bool SetItemPosition(wxWindow *window, const wxGBPosition& pos);
|
|
bool SetItemPosition(wxSizer *sizer, const wxGBPosition& pos);
|
|
bool SetItemPosition(size_t index, const wxGBPosition& pos);
|
|
|
|
// Get the row/col spanning of the specified item (non-recursive)
|
|
wxGBSpan GetItemSpan(wxWindow *window);
|
|
wxGBSpan GetItemSpan(wxSizer *sizer);
|
|
wxGBSpan GetItemSpan(size_t index);
|
|
|
|
// Set the row/col spanning of the specified item. Returns true on
|
|
// success. If the move is not allowed (because an item is already there)
|
|
// then false is returned. (non-recursive)
|
|
bool SetItemSpan(wxWindow *window, const wxGBSpan& span);
|
|
bool SetItemSpan(wxSizer *sizer, const wxGBSpan& span);
|
|
bool SetItemSpan(size_t index, const wxGBSpan& span);
|
|
|
|
|
|
// Find the sizer item for the given window or subsizer, returns NULL if
|
|
// not found. (non-recursive)
|
|
wxGBSizerItem* FindItem(wxWindow* window);
|
|
wxGBSizerItem* FindItem(wxSizer* sizer);
|
|
|
|
|
|
// Return the sizer item for the given grid cell, or NULL if there is no
|
|
// item at that position. (non-recursive)
|
|
wxGBSizerItem* FindItemAtPosition(const wxGBPosition& pos);
|
|
|
|
|
|
// Return the sizer item located at the point given in pt, or NULL if
|
|
// there is no item at that point. The (x,y) coordinates in pt correspond
|
|
// to the client coordinates of the window using the sizer for
|
|
// layout. (non-recursive)
|
|
wxGBSizerItem* FindItemAtPoint(const wxPoint& pt);
|
|
|
|
|
|
// Return the sizer item that has a matching user data (it only compares
|
|
// pointer values) or NULL if not found. (non-recursive)
|
|
wxGBSizerItem* FindItemWithData(const wxObject* userData);
|
|
|
|
|
|
// These are what make the sizer do size calculations and layout
|
|
virtual void RecalcSizes();
|
|
virtual wxSize CalcMin();
|
|
|
|
|
|
// Look at all items and see if any intersect (or would overlap) the given
|
|
// item. Returns true if so, false if there would be no overlap. If an
|
|
// excludeItem is given then it will not be checked for intersection, for
|
|
// example it may be the item we are checking the position of.
|
|
bool CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem = NULL);
|
|
bool CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem = NULL);
|
|
|
|
|
|
// The Add base class virtuals should not be used with this class, but
|
|
// we'll try to make them automatically select a location for the item
|
|
// anyway.
|
|
virtual wxSizerItem* Add( wxWindow *window, int proportion = 0, int flag = 0, int border = 0, wxObject* userData = NULL );
|
|
virtual wxSizerItem* Add( wxSizer *sizer, int proportion = 0, int flag = 0, int border = 0, wxObject* userData = NULL );
|
|
virtual wxSizerItem* Add( int width, int height, int proportion = 0, int flag = 0, int border = 0, wxObject* userData = NULL );
|
|
|
|
// The Insert and Prepend base class virtuals that are not appropriate for
|
|
// this class and should not be used. Their implementation in this class
|
|
// simply fails.
|
|
virtual wxSizerItem* Add( wxSizerItem *item );
|
|
virtual wxSizerItem* Insert( size_t index, wxWindow *window, int proportion = 0, int flag = 0, int border = 0, wxObject* userData = NULL );
|
|
virtual wxSizerItem* Insert( size_t index, wxSizer *sizer, int proportion = 0, int flag = 0, int border = 0, wxObject* userData = NULL );
|
|
virtual wxSizerItem* Insert( size_t index, int width, int height, int proportion = 0, int flag = 0, int border = 0, wxObject* userData = NULL );
|
|
virtual wxSizerItem* Insert( size_t index, wxSizerItem *item );
|
|
virtual wxSizerItem* Prepend( wxWindow *window, int proportion = 0, int flag = 0, int border = 0, wxObject* userData = NULL );
|
|
virtual wxSizerItem* Prepend( wxSizer *sizer, int proportion = 0, int flag = 0, int border = 0, wxObject* userData = NULL );
|
|
virtual wxSizerItem* Prepend( int width, int height, int proportion = 0, int flag = 0, int border = 0, wxObject* userData = NULL );
|
|
virtual wxSizerItem* Prepend( wxSizerItem *item );
|
|
|
|
|
|
protected:
|
|
wxGBPosition FindEmptyCell();
|
|
void AdjustForOverflow();
|
|
|
|
wxSize m_emptyCellSize;
|
|
|
|
|
|
private:
|
|
|
|
DECLARE_CLASS(wxGridBagSizer)
|
|
wxDECLARE_NO_COPY_CLASS(wxGridBagSizer);
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
#endif
|