wxDATAVIEW_COL_HIDDEN = wxCOL_HIDDEN
};
-class WXDLLIMPEXP_ADV wxDataViewColumnBase : public wxHeaderColumnBase
+class WXDLLIMPEXP_ADV wxDataViewColumnBase : public wxSettableHeaderColumn
{
public:
// ctor for the text columns: takes ownership of renderer
};
// ----------------------------------------------------------------------------
-// wxHeaderColumnBase: interface for a column in a header of controls such as
-// wxListCtrl, wxDataViewCtrl or wxGrid
+// wxHeaderColumn: interface for a column in a header of controls such as
+// wxListCtrl, wxDataViewCtrl or wxGrid
// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_CORE wxHeaderColumnBase
+class WXDLLIMPEXP_CORE wxHeaderColumn
{
public:
// ctors and dtor
// virtual dtor for the base class to avoid gcc warnings even though we
// don't normally delete the objects of this class via a pointer to
- // wxHeaderColumnBase so it's not necessary, strictly speaking
- virtual ~wxHeaderColumnBase() { }
+ // wxHeaderColumn so it's not necessary, strictly speaking
+ virtual ~wxHeaderColumn() { }
+ // getters for various attributes
+ // ------------------------------
- // setters and getters for various attributes
- // ------------------------------------------
+ // notice that wxHeaderColumn only provides getters as this is all the
+ // wxHeaderCtrl needs, various derived class must also provide some way to
+ // change these attributes but this can be done either at the column level
+ // (in which case they should inherit from wxSettableHeaderColumn) or via
+ // the methods of the main control in which case you don't need setters in
+ // the column class at all
// title is the string shown for this column
- virtual void SetTitle(const wxString& title) = 0;
virtual wxString GetTitle() const = 0;
// bitmap shown (instead of text) in the column header
- virtual void SetBitmap(const wxBitmap& bitmap) = 0;
virtual wxBitmap GetBitmap() const = 0; \
// width of the column in pixels, can be set to wxCOL_WIDTH_DEFAULT meaning
// unspecified/default
- virtual void SetWidth(int width) = 0;
virtual int GetWidth() const = 0;
// minimal width can be set for resizeable columns to forbid resizing them
// below the specified size (set to 0 to remove)
- virtual void SetMinWidth(int minWidth) = 0;
virtual int GetMinWidth() const = 0;
// alignment of the text: wxALIGN_CENTRE, wxALIGN_LEFT or wxALIGN_RIGHT
- virtual void SetAlignment(wxAlignment align) = 0;
virtual wxAlignment GetAlignment() const = 0;
// flags manipulations:
// --------------------
- // notice that while we make Set/GetFlags() pure virtual here and implement
- // the individual flags access in terms of them, for some derived classes
- // it is more natural to implement access to each flag individually, in
- // which case they can use SetIndividualFlags() and GetFromIndividualFlags()
- // below to implement Set/GetFlags()
+ // notice that while we make GetFlags() pure virtual here and implement the
+ // individual flags access in terms of it, for some derived classes it is
+ // more natural to implement access to each flag individually, in which
+ // case they can use our GetFromIndividualFlags() helper below to implement
+ // GetFlags()
- // set or retrieve all column flags at once: combination of wxCOL_XXX
- // values above
- virtual void SetFlags(int flags) = 0;
+ // retrieve all column flags at once: combination of wxCOL_XXX values above
virtual int GetFlags() const = 0;
- // change, set, clear, toggle or test for any individual flag
- void ChangeFlag(int flag, bool set);
- void SetFlag(int flag);
- void ClearFlag(int flag);
- void ToggleFlag(int flag);
-
bool HasFlag(int flag) const { return (GetFlags() & flag) != 0; }
// wxCOL_RESIZABLE
- virtual void SetResizeable(bool resizeable)
- { ChangeFlag(wxCOL_RESIZABLE, resizeable); }
virtual bool IsResizeable() const
{ return HasFlag(wxCOL_RESIZABLE); }
// wxCOL_SORTABLE
- virtual void SetSortable(bool sortable)
- { ChangeFlag(wxCOL_SORTABLE, sortable); }
virtual bool IsSortable() const
{ return HasFlag(wxCOL_SORTABLE); }
// wxCOL_REORDERABLE
- virtual void SetReorderable(bool reorderable)
- { ChangeFlag(wxCOL_REORDERABLE, reorderable); }
virtual bool IsReorderable() const
{ return HasFlag(wxCOL_REORDERABLE); }
// wxCOL_HIDDEN
- virtual void SetHidden(bool hidden)
- { ChangeFlag(wxCOL_HIDDEN, hidden); }
virtual bool IsHidden() const
{ return HasFlag(wxCOL_HIDDEN); }
bool IsShown() const
// sorting
// -------
- // set this column as the one used to sort the control
- virtual void SetAsSortKey(bool sort = true) = 0;
- void UnsetAsSortKey() { SetAsSortKey(false); }
-
- // return true if the column is used for sorting
+ // return true if the column is the one currently used for sorting
virtual bool IsSortKey() const = 0;
// for sortable columns indicate whether we should sort in ascending or
// descending order (this should only be taken into account if IsSortKey())
+ virtual bool IsSortOrderAscending() const = 0;
+
+protected:
+ // helper for the class overriding IsXXX()
+ int GetFromIndividualFlags() const;
+};
+
+// ----------------------------------------------------------------------------
+// wxSettableHeaderColumn: column which allows to change its fields too
+// ----------------------------------------------------------------------------
+
+class wxSettableHeaderColumn : public wxHeaderColumn
+{
+public:
+ virtual void SetTitle(const wxString& title) = 0;
+ virtual void SetBitmap(const wxBitmap& bitmap) = 0;
+ virtual void SetWidth(int width) = 0;
+ virtual void SetMinWidth(int minWidth) = 0;
+ virtual void SetAlignment(wxAlignment align) = 0;
+
+ // see comment for wxHeaderColumn::GetFlags() about the relationship
+ // between SetFlags() and Set{Sortable,Reorderable,...}
+
+ // change, set, clear, toggle or test for any individual flag
+ virtual void SetFlags(int flags) = 0;
+ void ChangeFlag(int flag, bool set);
+ void SetFlag(int flag);
+ void ClearFlag(int flag);
+ void ToggleFlag(int flag);
+
+ virtual void SetResizeable(bool resizeable)
+ { ChangeFlag(wxCOL_RESIZABLE, resizeable); }
+ virtual void SetSortable(bool sortable)
+ { ChangeFlag(wxCOL_SORTABLE, sortable); }
+ virtual void SetReorderable(bool reorderable)
+ { ChangeFlag(wxCOL_REORDERABLE, reorderable); }
+ virtual void SetHidden(bool hidden)
+ { ChangeFlag(wxCOL_HIDDEN, hidden); }
+
+ virtual void SetAsSortKey(bool sort = true) = 0;
+ void UnsetAsSortKey() { SetAsSortKey(false); }
+
virtual void SetSortOrder(bool ascending) = 0;
void ToggleSortOrder() { SetSortOrder(!IsSortOrderAscending()); }
- virtual bool IsSortOrderAscending() const = 0;
protected:
- // helpers for the class overriding Set/IsXXX()
+ // helper for the class overriding individual SetXXX() methods instead of
+ // overriding SetFlags()
void SetIndividualFlags(int flags);
- int GetFromIndividualFlags() const;
};
// ----------------------------------------------------------------------------
-// wxHeaderColumnSimple: trivial generic implementation of wxHeaderColumnBase
+// wxHeaderColumnSimple: trivial generic implementation of wxHeaderColumn
// ----------------------------------------------------------------------------
-class wxHeaderColumnSimple : public wxHeaderColumnBase
+class wxHeaderColumnSimple : public wxSettableHeaderColumn
{
public:
// ctors and dtor
protected:
// this method must be implemented by the derived classes to return the
// information for the given column
- virtual wxHeaderColumnBase& GetColumn(unsigned int idx) = 0;
+ virtual wxHeaderColumn& GetColumn(unsigned int idx) = 0;
// this method is called from the default EVT_HEADER_SEPARATOR_DCLICK
// handler to update the fitting column width of the given column, it
protected:
// implement/override base class methods
- virtual wxHeaderColumnBase& GetColumn(unsigned int idx);
+ virtual wxHeaderColumn& GetColumn(unsigned int idx);
virtual bool UpdateColumnWidthToFit(unsigned int idx, int widthTitle);
// and define another one to be overridden in the derived classes: it
Notice that this is an abstract base class which is implemented (usually
using the information stored in the associated control) by the different
- controls using wxHeaderCtrl. You may use wxHeaderCtrlSimple which uses
- concrete wxHeaderColumnSimple if you don't already store the column
- information somewhere.
+ controls using wxHeaderCtrl. As the control only needs to retrieve the
+ information about the column, this class defines only the methods for
+ accessing the various column properties but not for changing them as the
+ setters might not be needed at all, e.g. if the column attributes can only
+ be changed via the methods of the main associated control (this is the case
+ for wxGrid for example). If you do want to allow changing them directly
+ using the column itself, you should inherit from wxSettableHeaderColumn
+ instead of this class.
+
+ Finally, if you don't already store the column information at all anywhere,
+ you should use the concrete wxHeaderColumnSimple class and
+ wxHeaderCtrlSimple.
@library{wxcore}
@category{ctrl}
{
public:
/**
- Set the text to display in the column header.
+ Get the text shown in the column header.
*/
- virtual void SetTitle(const wxString& title) = 0;
+ virtual wxString GetTitle() const = 0;
/**
- Get the text shown in the column header.
+ Returns the bitmap in the header of the column, if any.
+
+ If the column has no associated bitmap, wxNullBitmap should be returned.
+ */
+ virtual wxBitmap GetBitmap() const = 0;
+
+ /**
+ Returns the current width of the column.
+
+ @return
+ Width of the column in pixels, never wxCOL_WIDTH_DEFAULT.
+ */
+ virtual int GetWidth() const = 0;
+
+ /**
+ Return the minimal column width.
+
+ @return
+ The minimal width such that the user can't resize the column to
+ lesser size (notice that it is still possible to set the column
+ width to smaller value from the program code). Return 0 from here
+ to allow resizing the column to arbitrarily small size.
*/
- virtual wxString GetTitle() const = 0;
+ virtual int GetMinWidth() const = 0;
/**
- Set the bitmap to be displayed in the column header.
+ Returns the current column alignment.
- Notice that the bitmaps displayed in different columns of the same
- control must all be of the same size.
+ @return
+ One of wxALIGN_CENTRE, wxALIGN_LEFT or wxALIGN_RIGHT.
*/
- virtual void SetBitmap(const wxBitmap& bitmap) = 0;
+ virtual wxAlignment GetAlignment() const = 0;
+
/**
- Returns the bitmap in the header of the column, if any.
+ Get the column flags.
+
+ This method retrieves all the flags at once, you can also use HasFlag()
+ to test for any individual flag or IsResizeable(), IsSortable(),
+ IsReorderable() and IsHidden() to test for particular flags.
+ */
+ virtual int GetFlags() const = 0;
+
+ /**
+ Return @true if the specified flag is currently set for this column.
+ */
+ bool HasFlag(int flag) const;
+
+
+ /**
+ Return true if the column can be resized by the user.
+
+ Equivalent to HasFlag(wxCOL_RESIZABLE).
+ */
+ virtual bool IsResizeable() const;
- If the column has no associated bitmap, wxNullBitmap is returned.
+ /**
+ Returns @true if the column can be clicked by user to sort the control
+ contents by the field in this column.
+
+ This corresponds to wxCOL_SORTABLE flag which is off by default.
*/
- virtual wxBitmap GetBitmap() const = 0;
+ virtual bool IsSortable() const;
+
+ /**
+ Returns @true if the column can be dragged by user to change its order.
+
+ This corresponds to wxCOL_REORDERABLE flag which is on by default.
+ */
+ virtual bool IsReorderable() const;
+
+ /**
+ Returns @true if the column is currently hidden.
+
+ This corresponds to wxCOL_HIDDEN flag which is off by default.
+ */
+ virtual bool IsHidden() const;
+
+ /**
+ Returns @true if the column is currently shown.
+
+ This corresponds to the absence of wxCOL_HIDDEN flag.
+ */
+ bool IsShown() const;
+
+
+ /**
+ Returns @true if the column is currently used for sorting.
+ */
+ virtual bool IsSortKey() const = 0;
+
+ /**
+ Returns @true, if the sort order is ascending.
+
+ Notice that it only makes sense to call this function if the column is
+ used for sorting at all, i.e. if IsSortKey() returns @true.
+ */
+ virtual bool IsSortOrderAscending() const = 0;
+};
+
+/**
+ @class wxSettableHeaderColumn
+
+ Adds methods to set the column attributes to wxHeaderColumn.
+
+ This class adds setters for the column attributes defined by
+ wxHeaderColumn. It is still an abstract base class and needs to be
+ implemented before using it with wxHeaderCtrl.
+
+ @library{wxcore}
+ @category{ctrl}
+ */
+class wxSettableHeaderColumn : public wxHeaderColumn
+{
+public:
+ /**
+ Set the text to display in the column header.
+ */
+ virtual void SetTitle(const wxString& title) = 0;
+
+ /**
+ Set the bitmap to be displayed in the column header.
+
+ Notice that the bitmaps displayed in different columns of the same
+ control must all be of the same size.
+ */
+ virtual void SetBitmap(const wxBitmap& bitmap) = 0;
/**
Set the column width.
*/
virtual void SetWidth(int width) = 0;
- /**
- Returns the current width of the column.
-
- @return
- Width of the column in pixels, never wxCOL_WIDTH_DEFAULT.
- */
- virtual int GetWidth() const = 0;
-
/**
Set the minimal column width.
*/
virtual void SetMinWidth(int minWidth) = 0;
- /**
- Return the minimal column width.
-
- @return
- The value previously set by SetMinWidth() or 0 by default.
- */
- virtual int GetMinWidth() const = 0;
-
/**
Set the alignment of the column header.
*/
virtual void SetAlignment(wxAlignment align) = 0;
- /**
- Returns the current column alignment.
-
- @return
- One of wxALIGN_CENTRE, wxALIGN_LEFT or wxALIGN_RIGHT.
- */
- virtual wxAlignment GetAlignment() const = 0;
-
/**
Set the column flags.
*/
void ToggleFlag(int flag);
- /**
- Get the column flags.
-
- This method retrieves all the flags at once, you can also use HasFlag()
- to test for any individual flag or IsResizeable(), IsSortable(),
- IsReorderable() and IsHidden() to test for particular flags.
-
- @see SetFlags()
- */
- virtual int GetFlags() const = 0;
-
- /**
- Return @true if the specified flag is currently set for this column.
- */
- bool HasFlag(int flag) const;
-
/**
Call this to enable or disable interactive resizing of the column by
*/
virtual void SetResizeable(bool resizeable);
- /**
- Return true if the column can be resized by the user.
-
- Equivalent to HasFlag(wxCOL_RESIZABLE).
- */
- virtual bool IsResizeable() const;
-
/**
Allow clicking the column to sort the control contents by the field in
this column.
*/
virtual void SetSortable(bool sortable);
- /**
- Returns @true if the column can be clicked by user to sort the control
- contents by the field in this column.
-
- This corresponds to wxCOL_SORTABLE flag which is off by default.
-
- @see SetSortable()
- */
- virtual bool IsSortable() const;
-
/**
Allow changing the column order by dragging it.
*/
virtual void SetReorderable(bool reorderable);
- /**
- Returns @true if the column can be dragged by user to change its order.
-
- This corresponds to wxCOL_REORDERABLE flag which is on by default.
-
- @see SetReorderable()
- */
- virtual bool IsReorderable() const;
-
/**
Hide or show the column.
*/
virtual void SetHidden(bool hidden);
- /**
- Returns @true if the column is currently hidden.
-
- This corresponds to wxCOL_HIDDEN flag which is off by default.
- */
- virtual bool IsHidden() const;
-
- /**
- Returns @true if the column is currently shown.
-
- This corresponds to the absence of wxCOL_HIDDEN flag.
- */
- bool IsShown() const;
-
-
/**
Sets this column as the sort key for the associated control.
*/
void UnsetAsSortKey();
- /**
- Returns @true if the column is currently used for sorting.
-
- Notice that this function simply returns the value last passed to
- SetAsSortKey() (or @false if SetAsSortKey() had never been called), it
- is up to the associated control to use this information to actually
- sort its contents.
- */
- virtual bool IsSortKey() const = 0;
-
/**
Sets the sort order for this column.
@see SetSortOrder(), IsSortOrderAscending()
*/
void ToggleSortOrder();
-
- /**
- Returns @true, if the sort order is ascending.
-
- Notice that it only makes sense to call this function if the column is
- used for sorting at all, i.e. if IsSortKey() returns @true.
-
- @see SetSortOrder()
- */
- virtual bool IsSortOrderAscending() const = 0;
};
/**
Simple container for the information about the column.
- This is a concrete class implementing all base wxHeaderColumn class methods
- in a trivial way, i.e. by just storing the information in the object
- itself. It is used by and with wxHeaderCtrlSimple, e.g.
+ This is a concrete class implementing all wxSettableHeaderColumn class
+ methods in a trivial way, i.e. by just storing the information in the
+ object itself. It is used by and with wxHeaderCtrlSimple, e.g.
@code
wxHeaderCtrlSimple * header = new wxHeaderCtrlSimple(...);
wxHeaderColumnSimple col("Title");
///////////////////////////////////////////////////////////////////////////////
// Name: src/common/headercolcmn.cpp
-// Purpose: wxHeaderColumnBase implementation
+// Purpose: wxHeaderColumn implementation
// Author: Vadim Zeitlin
// Created: 2008-12-02
// RCS-ID: $Id$
#include "wx/headercol.h"
// ============================================================================
-// wxHeaderColumnBase implementation
+// wxHeaderColumn implementation
// ============================================================================
-void wxHeaderColumnBase::SetIndividualFlags(int flags)
-{
- SetResizeable((flags & wxCOL_RESIZABLE) != 0);
- SetSortable((flags & wxCOL_SORTABLE) != 0);
- SetReorderable((flags & wxCOL_REORDERABLE) != 0);
- SetHidden((flags & wxCOL_HIDDEN) != 0);
-}
-
-int wxHeaderColumnBase::GetFromIndividualFlags() const
+int wxHeaderColumn::GetFromIndividualFlags() const
{
int flags = 0;
return flags;
}
-void wxHeaderColumnBase::ChangeFlag(int flag, bool set)
+// ============================================================================
+// wxSettableHeaderColumn implementation
+// ============================================================================
+
+void wxSettableHeaderColumn::SetIndividualFlags(int flags)
+{
+ SetResizeable((flags & wxCOL_RESIZABLE) != 0);
+ SetSortable((flags & wxCOL_SORTABLE) != 0);
+ SetReorderable((flags & wxCOL_REORDERABLE) != 0);
+ SetHidden((flags & wxCOL_HIDDEN) != 0);
+}
+
+void wxSettableHeaderColumn::ChangeFlag(int flag, bool set)
{
if ( HasFlag(flag) != set )
ToggleFlag(flag);
}
-void wxHeaderColumnBase::SetFlag(int flag)
+void wxSettableHeaderColumn::SetFlag(int flag)
{
int flags = GetFlags();
if ( !(flags & flag) )
SetFlags(flags | flag);
}
-void wxHeaderColumnBase::ClearFlag(int flag)
+void wxSettableHeaderColumn::ClearFlag(int flag)
{
int flags = GetFlags();
if ( flags & flag )
SetFlags(flags & ~flag);
}
-void wxHeaderColumnBase::ToggleFlag(int flag)
+void wxSettableHeaderColumn::ToggleFlag(int flag)
{
int flags = GetFlags();
if ( flags & flag )
m_sortKey = wxNO_COLUMN;
}
-wxHeaderColumnBase& wxHeaderCtrlSimple::GetColumn(unsigned int idx)
+wxHeaderColumn& wxHeaderCtrlSimple::GetColumn(unsigned int idx)
{
return m_cols[idx];
}
protected:
// implement/override wxHeaderCtrl functions by forwarding them to the main
// control
- virtual wxHeaderColumnBase& GetColumn(unsigned int idx)
+ virtual wxHeaderColumn& GetColumn(unsigned int idx)
{
return *(GetOwner()->GetColumn(idx));
}
void OnEndResize(wxHeaderCtrlEvent& event)
{
+ wxDataViewCtrl * const owner = GetOwner();
+
const unsigned col = event.GetColumn();
- GetColumn(col).SetWidth(event.GetWidth());
+ owner->GetColumn(col)->SetWidth(event.GetWidth());
GetOwner()->OnColumnChange(col);
}
if ( i == idx )
break;
- const wxHeaderColumnBase& col = self->GetColumn(i);
+ const wxHeaderColumn& col = self->GetColumn(i);
if ( col.IsShown() )
pos += col.GetWidth();
}
for ( unsigned n = 0; n < count; n++ )
{
const unsigned idx = m_colIndices[n];
- const wxHeaderColumnBase& col = self->GetColumn(idx);
+ const wxHeaderColumn& col = self->GetColumn(idx);
if ( col.IsHidden() )
continue;
for ( unsigned int i = 0; i < count; i++ )
{
const unsigned idx = m_colIndices[i];
- const wxHeaderColumnBase& col = GetColumn(idx);
+ const wxHeaderColumn& col = GetColumn(idx);
if ( col.IsHidden() )
continue;
void wxDataViewColumn::SetAsSortKey( bool WXUNUSED(sort) )
{
- // it might not make sense to have this function in wxHeaderColumnBase at
+ // it might not make sense to have this function in wxHeaderColumn at
// all in fact, changing of the sort order should only be done using the
// associated control API
wxFAIL_MSG( "not implemented" );
void wxHeaderCtrl::DoInsertItem(unsigned int idx, int order)
{
- const wxHeaderColumnBase& col = GetColumn(idx);
+ const wxHeaderColumn& col = GetColumn(idx);
wxHDITEM hdi;
projects / wxWidgets.git / commitdiff
