// Name: wx/generic/grid.h
// Purpose: wxGrid and related classes
// Author: Michael Bedward (based on code by Julian Smart, Robin Dunn)
-// Modified by:
+// Modified by: Santiago Palacios
// Created: 1/08/1999
// RCS-ID: $Id$
// Copyright: (c) Michael Bedward
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#include "wx/defs.h"
+#ifndef _WX_GENERIC_GRID_H_
+#define _WX_GENERIC_GRID_H_
-#ifndef __WXGRID_H__
-#define __WXGRID_H__
+#include "wx/defs.h"
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma interface "grid.h"
-#endif
+#if wxUSE_GRID
-#include "wx/hashmap.h"
-#include "wx/panel.h"
#include "wx/scrolwin.h"
-#include "wx/string.h"
-#include "wx/arrstr.h"
-#include "wx/scrolbar.h"
-#include "wx/event.h"
-#include "wx/combobox.h"
-#include "wx/dynarray.h"
-#include "wx/timer.h"
-#include "wx/clntdata.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
+extern WXDLLIMPEXP_DATA_ADV(const wxChar) wxGridNameStr[];
+
// Default parameters for wxGrid
//
#define WXGRID_DEFAULT_NUMBER_ROWS 10
#define WXGRID_DEFAULT_NUMBER_COLS 10
-#ifdef __WXMSW__
+#if defined(__WXMSW__) || defined(__WXGTK20__)
#define WXGRID_DEFAULT_ROW_HEIGHT 25
#else
#define WXGRID_DEFAULT_ROW_HEIGHT 30
#define wxGRID_VALUE_TEXT wxGRID_VALUE_STRING
#define wxGRID_VALUE_LONG wxGRID_VALUE_NUMBER
+// magic constant which tells (to some functions) to automatically calculate
+// the appropriate size
+#define wxGRID_AUTOSIZE (-1)
+
+// many wxGrid methods work either with columns or rows, this enum is used for
+// the parameter indicating which one should it be
+enum wxGridDirection
+{
+ wxGRID_COLUMN,
+ wxGRID_ROW
+};
+
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_ADV wxGrid;
-class WXDLLIMPEXP_ADV wxGridCellAttr;
-class WXDLLIMPEXP_ADV wxGridCellAttrProviderData;
-class WXDLLIMPEXP_ADV wxGridColLabelWindow;
-class WXDLLIMPEXP_ADV wxGridCornerLabelWindow;
-class WXDLLIMPEXP_ADV wxGridRowLabelWindow;
-class WXDLLIMPEXP_ADV wxGridTableBase;
-class WXDLLIMPEXP_ADV wxGridWindow;
-class WXDLLIMPEXP_ADV wxGridTypeRegistry;
-class WXDLLIMPEXP_ADV wxGridSelection;
-
-class WXDLLEXPORT wxCheckBox;
-class WXDLLEXPORT wxComboBox;
-class WXDLLEXPORT wxTextCtrl;
+class WXDLLIMPEXP_FWD_ADV wxGrid;
+class WXDLLIMPEXP_FWD_ADV wxGridCellAttr;
+class WXDLLIMPEXP_FWD_ADV wxGridCellAttrProviderData;
+class WXDLLIMPEXP_FWD_ADV wxGridColLabelWindow;
+class WXDLLIMPEXP_FWD_ADV wxGridCornerLabelWindow;
+class WXDLLIMPEXP_FWD_ADV wxGridRowLabelWindow;
+class WXDLLIMPEXP_FWD_ADV wxGridWindow;
+class WXDLLIMPEXP_FWD_ADV wxGridTypeRegistry;
+class WXDLLIMPEXP_FWD_ADV wxGridSelection;
+
+class WXDLLIMPEXP_FWD_CORE wxCheckBox;
+class WXDLLIMPEXP_FWD_CORE wxComboBox;
+class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
#if wxUSE_SPINCTRL
-class WXDLLEXPORT wxSpinCtrl;
+class WXDLLIMPEXP_FWD_CORE wxSpinCtrl;
#endif
// ----------------------------------------------------------------------------
// calling DecRef() once will delete it. Calling IncRef() allows to lock
// it until the matching DecRef() is called
void IncRef() { m_nRef++; }
- void DecRef() { if ( !--m_nRef ) delete this; }
+ void DecRef() { if ( --m_nRef == 0 ) delete this; }
// interpret renderer parameters: arbitrary string whose interpretatin is
// left to the derived classes
protected:
// set the text colours before drawing
- void SetTextColoursAndFont(wxGrid& grid,
- wxGridCellAttr& attr,
+ void SetTextColoursAndFont(const wxGrid& grid,
+ const wxGridCellAttr& attr,
wxDC& dc,
bool isSelected);
// calc the string extent for given string/font
- wxSize DoGetBestSize(wxGridCellAttr& attr,
+ wxSize DoGetBestSize(const wxGridCellAttr& attr,
wxDC& dc,
const wxString& text);
};
{ return new wxGridCellNumberRenderer; }
protected:
- wxString GetString(wxGrid& grid, int row, int col);
+ wxString GetString(const wxGrid& grid, int row, int col);
};
class WXDLLIMPEXP_ADV wxGridCellFloatRenderer : public wxGridCellStringRenderer
virtual wxGridCellRenderer *Clone() const;
protected:
- wxString GetString(wxGrid& grid, int row, int col);
+ wxString GetString(const wxGrid& grid, int row, int col);
private:
// formatting parameters
// create a new object which is the copy of this one
virtual wxGridCellEditor *Clone() const = 0;
- // DJC MAPTEK
// added GetValue so we can get the value which is in the control
virtual wxString GetValue() const = 0;
virtual wxGridCellEditor *Clone() const
{ return new wxGridCellTextEditor; }
- // DJC MAPTEK
// added GetValue so we can get the value which is in the control
virtual wxString GetValue() const;
+
protected:
wxTextCtrl *Text() const { return (wxTextCtrl *)m_control; }
// parts of our virtual functions reused by the derived classes
+ void DoCreate(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler,
+ long style = 0);
void DoBeginEdit(const wxString& startValue);
void DoReset(const wxString& startValue);
virtual wxGridCellEditor *Clone() const
{ return new wxGridCellNumberEditor(m_min, m_max); }
- // DJC MAPTEK
+
// added GetValue so we can get the value which is in the control
virtual wxString GetValue() const;
wxEvtHandler* evtHandler);
virtual void SetSize(const wxRect& rect);
- virtual void Show(bool show, wxGridCellAttr *attr = (wxGridCellAttr *)NULL);
+ virtual void Show(bool show, wxGridCellAttr *attr = NULL);
virtual bool IsAcceptedKey(wxKeyEvent& event);
virtual void BeginEdit(int row, int col, wxGrid* grid);
virtual void Reset();
virtual void StartingClick();
+ virtual void StartingKey(wxKeyEvent& event);
virtual wxGridCellEditor *Clone() const
{ return new wxGridCellBoolEditor; }
- // DJC MAPTEK
- // added GetValue so we can get the value which is in the control
+
+ // added GetValue so we can get the value which is in the control, see
+ // also UseStringValues()
virtual wxString GetValue() const;
+ // set the string values returned by GetValue() for the true and false
+ // states, respectively
+ static void UseStringValues(const wxString& valueTrue = _T("1"),
+ const wxString& valueFalse = wxEmptyString);
+
+ // return true if the given string is equal to the string representation of
+ // true value which we currently use
+ static bool IsTrueValue(const wxString& value);
+
protected:
wxCheckBox *CBox() const { return (wxCheckBox *)m_control; }
private:
bool m_startValue;
+ static wxString ms_stringValues[2];
+
DECLARE_NO_COPY_CLASS(wxGridCellBoolEditor)
};
virtual void SetParameters(const wxString& params);
virtual wxGridCellEditor *Clone() const;
- // DJC MAPTEK
+
// added GetValue so we can get the value which is in the control
virtual wxString GetValue() const;
// calling DecRef() once will delete it. Calling IncRef() allows to lock
// it until the matching DecRef() is called
void IncRef() { m_nRef++; }
- void DecRef() { if ( !--m_nRef ) delete this; }
+ void DecRef() { if ( --m_nRef == 0 ) delete this; }
// setters
void SetTextColour(const wxColour& colText) { m_colText = colText; }
bool HasEditor() const { return m_editor != NULL; }
bool HasReadWriteMode() const { return m_isReadOnly != Unset; }
bool HasOverflowMode() const { return m_overflow != UnsetOverflow; }
+ bool HasSize() const { return m_sizeRows != 1 || m_sizeCols != 1; }
const wxColour& GetTextColour() const;
const wxColour& GetBackgroundColour() const;
void GetSize(int *num_rows, int *num_cols) const;
bool GetOverflow() const
{ return m_overflow != SingleCell; }
- wxGridCellRenderer *GetRenderer(wxGrid* grid, int row, int col) const;
- wxGridCellEditor *GetEditor(wxGrid* grid, int row, int col) const;
+ wxGridCellRenderer *GetRenderer(const wxGrid* grid, int row, int col) const;
+ wxGridCellEditor *GetEditor(const wxGrid* grid, int row, int col) const;
bool IsReadOnly() const { return m_isReadOnly == wxGridCellAttr::ReadOnly; }
void SetDefAttr(wxGridCellAttr* defAttr) { m_defGridAttr = defAttr; }
+protected:
+ // the dtor is private because only DecRef() can delete us
+ virtual ~wxGridCellAttr()
+ {
+ wxSafeDecRef(m_renderer);
+ wxSafeDecRef(m_editor);
+ }
+
private:
enum wxAttrReadMode
{
// the common part of all ctors
void Init(wxGridCellAttr *attrDefault = NULL);
- // the dtor is private because only DecRef() can delete us
- ~wxGridCellAttr()
- {
- wxSafeDecRef(m_renderer);
- wxSafeDecRef(m_editor);
- }
// the ref count - when it goes to 0, we die
size_t m_nRef;
class WXDLLIMPEXP_ADV wxGrid : public wxScrolledWindow
{
public:
- wxGrid() ;
+ wxGrid();
- wxGrid( wxWindow *parent,
+ wxGrid( wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxWANTS_CHARS,
- const wxString& name = wxPanelNameStr );
+ const wxString& name = wxGridNameStr );
bool Create( wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxWANTS_CHARS,
- const wxString& name = wxPanelNameStr );
+ const wxString& name = wxGridNameStr );
virtual ~wxGrid();
// ------ grid dimensions
//
- int GetNumberRows() { return m_numRows; }
- int GetNumberCols() { return m_numCols; }
+ int GetNumberRows() const { return m_numRows; }
+ int GetNumberCols() const { return m_numCols; }
// ------ display update functions
//
- wxArrayInt CalcRowLabelsExposed( const wxRegion& reg );
+ wxArrayInt CalcRowLabelsExposed( const wxRegion& reg ) const;
- wxArrayInt CalcColLabelsExposed( const wxRegion& reg );
- wxGridCellCoordsArray CalcCellsExposed( const wxRegion& reg );
+ wxArrayInt CalcColLabelsExposed( const wxRegion& reg ) const;
+ wxGridCellCoordsArray CalcCellsExposed( const wxRegion& reg ) const;
// ------ event handlers
void DoEndDragResizeRow();
void DoEndDragResizeCol();
+ void DoEndDragMoveCol();
wxGridTableBase * GetTable() const { return m_table; }
bool SetTable( wxGridTableBase *table, bool takeOwnership = false,
int textOrientation = wxHORIZONTAL );
- // Split a string containing newline chararcters into an array of
+ // Split a string containing newline characters into an array of
// strings and return the number of lines
//
- void StringToLines( const wxString& value, wxArrayString& lines );
+ void StringToLines( const wxString& value, wxArrayString& lines ) const;
- void GetTextBoxSize( wxDC& dc,
+ void GetTextBoxSize( const wxDC& dc,
const wxArrayString& lines,
- long *width, long *height );
+ long *width, long *height ) const;
// ------
// grid cells and labels so you will need to convert from device
// coordinates for mouse events etc.
//
- void XYToCell( int x, int y, wxGridCellCoords& );
- int YToRow( int y );
- int XToCol( int x );
+ void XYToCell( int x, int y, wxGridCellCoords& ) const;
+ int YToRow( int y ) const;
+ int XToCol( int x, bool clipToMinMax = false ) const;
- int YToEdgeOfRow( int y );
- int XToEdgeOfCol( int x );
+ int YToEdgeOfRow( int y ) const;
+ int XToEdgeOfCol( int x ) const;
- wxRect CellToRect( int row, int col );
- wxRect CellToRect( const wxGridCellCoords& coords )
+ wxRect CellToRect( int row, int col ) const;
+ wxRect CellToRect( const wxGridCellCoords& coords ) const
{ return CellToRect( coords.GetRow(), coords.GetCol() ); }
- int GetGridCursorRow() { return m_currentCellCoords.GetRow(); }
- int GetGridCursorCol() { return m_currentCellCoords.GetCol(); }
+ int GetGridCursorRow() const { return m_currentCellCoords.GetRow(); }
+ int GetGridCursorCol() const { return m_currentCellCoords.GetCol(); }
// check to see if a cell is either wholly visible (the default arg) or
// at least partially visible in the grid window
//
- bool IsVisible( int row, int col, bool wholeCellVisible = true );
- bool IsVisible( const wxGridCellCoords& coords, bool wholeCellVisible = true )
+ bool IsVisible( int row, int col, bool wholeCellVisible = true ) const;
+ bool IsVisible( const wxGridCellCoords& coords, bool wholeCellVisible = true ) const
{ return IsVisible( coords.GetRow(), coords.GetCol(), wholeCellVisible ); }
void MakeCellVisible( int row, int col );
void MakeCellVisible( const wxGridCellCoords& coords )
// ------ label and gridline formatting
//
- int GetDefaultRowLabelSize() { return WXGRID_DEFAULT_ROW_LABEL_WIDTH; }
- int GetRowLabelSize() { return m_rowLabelWidth; }
- int GetDefaultColLabelSize() { return WXGRID_DEFAULT_COL_LABEL_HEIGHT; }
- int GetColLabelSize() { return m_colLabelHeight; }
- wxColour GetLabelBackgroundColour() { return m_labelBackgroundColour; }
- wxColour GetLabelTextColour() { return m_labelTextColour; }
- wxFont GetLabelFont() { return m_labelFont; }
- void GetRowLabelAlignment( int *horiz, int *vert );
- void GetColLabelAlignment( int *horiz, int *vert );
- int GetColLabelTextOrientation();
- wxString GetRowLabelValue( int row );
- wxString GetColLabelValue( int col );
- wxColour GetGridLineColour() { return m_gridLineColour; }
- wxColour GetCellHighlightColour() { return m_cellHighlightColour; }
- int GetCellHighlightPenWidth() { return m_cellHighlightPenWidth; }
- int GetCellHighlightROPenWidth() { return m_cellHighlightROPenWidth; }
-
+ int GetDefaultRowLabelSize() const { return WXGRID_DEFAULT_ROW_LABEL_WIDTH; }
+ int GetRowLabelSize() const { return m_rowLabelWidth; }
+ int GetDefaultColLabelSize() const { return WXGRID_DEFAULT_COL_LABEL_HEIGHT; }
+ int GetColLabelSize() const { return m_colLabelHeight; }
+ wxColour GetLabelBackgroundColour() const { return m_labelBackgroundColour; }
+ wxColour GetLabelTextColour() const { return m_labelTextColour; }
+ wxFont GetLabelFont() const { return m_labelFont; }
+ void GetRowLabelAlignment( int *horiz, int *vert ) const;
+ void GetColLabelAlignment( int *horiz, int *vert ) const;
+ int GetColLabelTextOrientation() const;
+ wxString GetRowLabelValue( int row ) const;
+ wxString GetColLabelValue( int col ) const;
+ wxColour GetGridLineColour() const { return m_gridLineColour; }
+
+ // these methods may be overridden to customize individual grid lines
+ // appearance
+ virtual wxPen GetDefaultGridLinePen();
+ virtual wxPen GetRowGridLinePen(int row);
+ virtual wxPen GetColGridLinePen(int col);
+ wxColour GetCellHighlightColour() const { return m_cellHighlightColour; }
+ int GetCellHighlightPenWidth() const { return m_cellHighlightPenWidth; }
+ int GetCellHighlightROPenWidth() const { return m_cellHighlightROPenWidth; }
+
+ void SetUseNativeColLabels( bool native = true );
void SetRowLabelSize( int width );
void SetColLabelSize( int height );
+ void HideRowLabels() { SetRowLabelSize( 0 ); }
+ void HideColLabels() { SetColLabelSize( 0 ); }
void SetLabelBackgroundColour( const wxColour& );
void SetLabelTextColour( const wxColour& );
void SetLabelFont( const wxFont& );
void EnableDragRowSize( bool enable = true );
void DisableDragRowSize() { EnableDragRowSize( false ); }
- bool CanDragRowSize() { return m_canDragRowSize; }
+ bool CanDragRowSize() const { return m_canDragRowSize; }
void EnableDragColSize( bool enable = true );
void DisableDragColSize() { EnableDragColSize( false ); }
- bool CanDragColSize() { return m_canDragColSize; }
+ bool CanDragColSize() const { return m_canDragColSize; }
+ void EnableDragColMove( bool enable = true );
+ void DisableDragColMove() { EnableDragColMove( false ); }
+ bool CanDragColMove() const { return m_canDragColMove; }
void EnableDragGridSize(bool enable = true);
void DisableDragGridSize() { EnableDragGridSize(false); }
- bool CanDragGridSize() { return m_canDragGridSize; }
+ bool CanDragGridSize() const { return m_canDragGridSize; }
void EnableDragCell( bool enable = true );
void DisableDragCell() { EnableDragCell( false ); }
- bool CanDragCell() { return m_canDragCell; }
+ bool CanDragCell() const { return m_canDragCell; }
// this sets the specified attribute for this cell or in this row/col
void SetAttr(int row, int col, wxGridCellAttr *attr);
// DecRef() must be called on the returned pointer, as usual
wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
-
+
// shortcuts for setting the column parameters
// set the format for the data in the column: default is string
void SetColFormatCustom(int col, const wxString& typeName);
void EnableGridLines( bool enable = true );
- bool GridLinesEnabled() { return m_gridLinesEnabled; }
+ bool GridLinesEnabled() const { return m_gridLinesEnabled; }
// ------ row and col formatting
//
- int GetDefaultRowSize();
- int GetRowSize( int row );
- int GetDefaultColSize();
- int GetColSize( int col );
- wxColour GetDefaultCellBackgroundColour();
- wxColour GetCellBackgroundColour( int row, int col );
- wxColour GetDefaultCellTextColour();
- wxColour GetCellTextColour( int row, int col );
- wxFont GetDefaultCellFont();
- wxFont GetCellFont( int row, int col );
- void GetDefaultCellAlignment( int *horiz, int *vert );
- void GetCellAlignment( int row, int col, int *horiz, int *vert );
- bool GetDefaultCellOverflow();
- bool GetCellOverflow( int row, int col );
- void GetCellSize( int row, int col, int *num_rows, int *num_cols );
+ int GetDefaultRowSize() const;
+ int GetRowSize( int row ) const;
+ int GetDefaultColSize() const;
+ int GetColSize( int col ) const;
+ wxColour GetDefaultCellBackgroundColour() const;
+ wxColour GetCellBackgroundColour( int row, int col ) const;
+ wxColour GetDefaultCellTextColour() const;
+ wxColour GetCellTextColour( int row, int col ) const;
+ wxFont GetDefaultCellFont() const;
+ wxFont GetCellFont( int row, int col ) const;
+ void GetDefaultCellAlignment( int *horiz, int *vert ) const;
+ void GetCellAlignment( int row, int col, int *horiz, int *vert ) const;
+ bool GetDefaultCellOverflow() const;
+ bool GetCellOverflow( int row, int col ) const;
+ void GetCellSize( int row, int col, int *num_rows, int *num_cols ) const;
void SetDefaultRowSize( int height, bool resizeExistingRows = false );
void SetRowSize( int row, int height );
void SetColSize( int col, int width );
+ //Column positions
+ int GetColAt( int colPos ) const
+ {
+ if ( m_colAt.IsEmpty() )
+ return colPos;
+ else
+ return m_colAt[colPos];
+ }
+
+ void SetColPos( int colID, int newPos );
+
+ int GetColPos( int colID ) const
+ {
+ if ( m_colAt.IsEmpty() )
+ return colID;
+ else
+ {
+ for ( int i = 0; i < m_numCols; i++ )
+ {
+ if ( m_colAt[i] == colID )
+ return i;
+ }
+ }
+
+ return -1;
+ }
+
// automatically size the column or row to fit to its contents, if
// setAsMin is true, this optimal width will also be set as minimal width
// for this column
void AutoSizeColumn( int col, bool setAsMin = true )
- { AutoSizeColOrRow(col, setAsMin, true); }
+ { AutoSizeColOrRow(col, setAsMin, wxGRID_COLUMN); }
void AutoSizeRow( int row, bool setAsMin = true )
- { AutoSizeColOrRow(row, setAsMin, false); }
+ { AutoSizeColOrRow(row, setAsMin, wxGRID_ROW); }
// auto size all columns (very ineffective for big grids!)
void AutoSizeColumns( bool setAsMin = true )
// and also set the grid size to just fit its contents
void AutoSize();
+ // Note for both AutoSizeRowLabelSize and AutoSizeColLabelSize:
+ // If col equals to wxGRID_AUTOSIZE value then function autosizes labels column
+ // instead of data column. Note that this operation may be slow for large
+ // tables.
// autosize row height depending on label text
void AutoSizeRowLabelSize( int row );
void SetDefaultRenderer(wxGridCellRenderer *renderer);
void SetCellRenderer(int row, int col, wxGridCellRenderer *renderer);
wxGridCellRenderer *GetDefaultRenderer() const;
- wxGridCellRenderer* GetCellRenderer(int row, int col);
+ wxGridCellRenderer* GetCellRenderer(int row, int col) const;
// takes ownership of the pointer
void SetDefaultEditor(wxGridCellEditor *editor);
void SetCellEditor(int row, int col, wxGridCellEditor *editor);
wxGridCellEditor *GetDefaultEditor() const;
- wxGridCellEditor* GetCellEditor(int row, int col);
+ wxGridCellEditor* GetCellEditor(int row, int col) const;
// ------ cell value accessors
//
- wxString GetCellValue( int row, int col )
+ wxString GetCellValue( int row, int col ) const
{
if ( m_table )
{
}
}
- wxString GetCellValue( const wxGridCellCoords& coords )
+ wxString GetCellValue( const wxGridCellCoords& coords ) const
{ return GetCellValue( coords.GetRow(), coords.GetCol() ); }
void SetCellValue( int row, int col, const wxString& s );
void SelectAll();
- bool IsSelection();
+ bool IsSelection() const;
// ------ deselect blocks or cells
//
// to the client size of the grid window.
//
wxRect BlockToDeviceRect( const wxGridCellCoords & topLeft,
- const wxGridCellCoords & bottomRight );
+ const wxGridCellCoords & bottomRight ) const;
// Access or update the selection fore/back colours
wxColour GetSelectionBackground() const
}
// Accessors for component windows
- wxWindow* GetGridWindow() { return (wxWindow*)m_gridWin; }
- wxWindow* GetGridRowLabelWindow() { return (wxWindow*)m_rowLabelWin; }
- wxWindow* GetGridColLabelWindow() { return (wxWindow*)m_colLabelWin; }
- wxWindow* GetGridCornerLabelWindow() { return (wxWindow*)m_cornerLabelWin; }
+ wxWindow* GetGridWindow() const { return (wxWindow*)m_gridWin; }
+ wxWindow* GetGridRowLabelWindow() const { return (wxWindow*)m_rowLabelWin; }
+ wxWindow* GetGridColLabelWindow() const { return (wxWindow*)m_colLabelWin; }
+ wxWindow* GetGridCornerLabelWindow() const { return (wxWindow*)m_cornerLabelWin; }
// Allow adjustment of scroll increment. The default is (15, 15).
void SetScrollLineX(int x) { m_scrollLineX = x; }
// override some base class functions
virtual bool Enable(bool enable = true);
+ virtual wxWindow *GetMainWindowOfCompositeControl()
+ { return (wxWindow*)m_gridWin; }
+ // ------- drag and drop
+#if wxUSE_DRAG_AND_DROP
+ virtual void SetDropTarget(wxDropTarget *dropTarget);
+#endif // wxUSE_DRAG_AND_DROP
// ------ For compatibility with previous wxGrid only...
//
: wxScrolledWindow( parent, wxID_ANY, wxPoint(x,y), wxSize(w,h),
(style|wxWANTS_CHARS), name )
{
+ InitVars();
Create();
}
void UpdateDimensions()
{ CalcDimensions(); }
- int GetRows() { return GetNumberRows(); }
- int GetCols() { return GetNumberCols(); }
- int GetCursorRow() { return GetGridCursorRow(); }
- int GetCursorColumn() { return GetGridCursorCol(); }
+ int GetRows() const { return GetNumberRows(); }
+ int GetCols() const { return GetNumberCols(); }
+ int GetCursorRow() const { return GetGridCursorRow(); }
+ int GetCursorColumn() const { return GetGridCursorCol(); }
- int GetScrollPosX() { return 0; }
- int GetScrollPosY() { return 0; }
+ int GetScrollPosX() const { return 0; }
+ int GetScrollPosY() const { return 0; }
void SetScrollX( int WXUNUSED(x) ) { }
void SetScrollY( int WXUNUSED(y) ) { }
void SetColumnWidth( int col, int width )
{ SetColSize( col, width ); }
- int GetColumnWidth( int col )
+ int GetColumnWidth( int col ) const
{ return GetColSize( col ); }
void SetRowHeight( int row, int height )
// GetRowHeight() is below
- int GetViewHeight() // returned num whole rows visible
+ int GetViewHeight() const // returned num whole rows visible
{ return 0; }
- int GetViewWidth() // returned num whole cols visible
+ int GetViewWidth() const // returned num whole cols visible
{ return 0; }
void SetLabelSize( int orientation, int sz )
SetRowLabelSize( sz );
}
- int GetLabelSize( int orientation )
+ int GetLabelSize( int orientation ) const
{
if ( orientation == wxHORIZONTAL )
return GetColLabelSize();
SetRowLabelAlignment( align, -1 );
}
- int GetLabelAlignment( int orientation, int WXUNUSED(align) )
+ int GetLabelAlignment( int orientation, int WXUNUSED(align) ) const
{
int h, v;
if ( orientation == wxHORIZONTAL )
SetRowLabelValue( pos, val );
}
- wxString GetLabelValue( int orientation, int pos)
+ wxString GetLabelValue( int orientation, int pos) const
{
if ( orientation == wxHORIZONTAL )
return GetColLabelValue( pos );
void SetCellBackgroundColour(const wxColour& colour, int row, int col)
{ SetCellBackgroundColour( row, col, colour ); }
- bool GetEditable() { return IsEditable(); }
+ bool GetEditable() const { return IsEditable(); }
void SetEditable( bool edit = true ) { EnableEditing( edit ); }
- bool GetEditInPlace() { return IsCellEditControlEnabled(); }
+ bool GetEditInPlace() const { return IsCellEditControlEnabled(); }
void SetEditInPlace(bool WXUNUSED(edit) = true) { }
// overridden wxWindow methods
virtual void Fit();
+ // implementation only
+ void CancelMouseCapture();
+
protected:
virtual wxSize DoGetBestSize() const;
int m_minAcceptableColWidth;
wxArrayInt m_colWidths;
wxArrayInt m_colRights;
+
+ bool m_nativeColumnLabels;
// get the col/row coords
int GetColWidth(int col) const;
int SetOrCalcRowSizes(bool calcOnly, bool setAsMin = true);
// common part of AutoSizeColumn/Row()
- void AutoSizeColOrRow(int n, bool setAsMin, bool column /* or row? */);
+ void AutoSizeColOrRow(int n, bool setAsMin, wxGridDirection direction);
+
+ // Calculate the minimum acceptable size for labels area
+ wxCoord CalcColOrRowLabelAreaMinSize(wxGridDirection direction);
// if a column has a minimal width, it will be the value for it in this
// hash table
int GetRowMinimalHeight(int col) const;
// do we have some place to store attributes in?
- bool CanHaveAttributes();
+ bool CanHaveAttributes() const;
// cell attribute cache (currently we only cache 1, may be will do
// more/better later)
// looks for the attr in cache, if not found asks the table and caches the
// result
wxGridCellAttr *GetCellAttr(int row, int col) const;
- wxGridCellAttr *GetCellAttr(const wxGridCellCoords& coords )
+ wxGridCellAttr *GetCellAttr(const wxGridCellCoords& coords ) const
{ return GetCellAttr( coords.GetRow(), coords.GetCol() ); }
// the default cell attr object for cells that don't have their own
WXGRID_CURSOR_RESIZE_ROW,
WXGRID_CURSOR_RESIZE_COL,
WXGRID_CURSOR_SELECT_ROW,
- WXGRID_CURSOR_SELECT_COL
+ WXGRID_CURSOR_SELECT_COL,
+ WXGRID_CURSOR_MOVE_COL
};
// this method not only sets m_cursorMode but also sets the correct cursor
wxWindow *m_winCapture; // the window which captured the mouse
CursorMode m_cursorMode;
+ //Column positions
+ wxArrayInt m_colAt;
+ int m_moveToCol;
+
bool m_canDragRowSize;
bool m_canDragColSize;
+ bool m_canDragColMove;
bool m_canDragGridSize;
bool m_canDragCell;
int m_dragLastPos;
void Create();
void Init();
+ void InitVars();
void CalcDimensions();
void CalcWindowSizes();
bool Redimension( wxGridTableMessage& );
void OnSize( wxSizeEvent& );
void OnKeyDown( wxKeyEvent& );
void OnKeyUp( wxKeyEvent& );
+ void OnChar( wxKeyEvent& );
void OnEraseBackground( wxEraseEvent& );
bool GetModelValues();
bool SetModelValues();
- friend class WXDLLIMPEXP_ADV wxGridSelection;
+ friend class WXDLLIMPEXP_FWD_ADV wxGridSelection;
DECLARE_DYNAMIC_CLASS( wxGrid )
DECLARE_EVENT_TABLE()
DECLARE_NO_COPY_CLASS(wxGrid)
};
+// ----------------------------------------------------------------------------
+// wxGridUpdateLocker prevents updates to a grid during its lifetime
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxGridUpdateLocker
+{
+public:
+ // if the pointer is NULL, Create() can be called later
+ wxGridUpdateLocker(wxGrid *grid = NULL)
+ {
+ Init(grid);
+ }
+
+ // can be called if ctor was used with a NULL pointer, must not be called
+ // more than once
+ void Create(wxGrid *grid)
+ {
+ wxASSERT_MSG( !m_grid, _T("shouldn't be called more than once") );
+
+ Init(grid);
+ }
+
+ ~wxGridUpdateLocker()
+ {
+ if ( m_grid )
+ m_grid->EndBatch();
+ }
+
+private:
+ void Init(wxGrid *grid)
+ {
+ m_grid = grid;
+ if ( m_grid )
+ m_grid->BeginBatch();
+ }
+
+ wxGrid *m_grid;
+
+ DECLARE_NO_COPY_CLASS(wxGridUpdateLocker)
+};
// ----------------------------------------------------------------------------
// Grid event class and event types
bool MetaDown() { return m_meta; }
bool ShiftDown() { return m_shift; }
bool AltDown() { return m_alt; }
+ bool CmdDown()
+ {
+#if defined(__WXMAC__) || defined(__WXCOCOA__)
+ return MetaDown();
+#else
+ return ControlDown();
+#endif
+ }
+
+ virtual wxEvent *Clone() const { return new wxGridEvent(*this); }
protected:
int m_row;
bool m_shift;
bool m_alt;
- DECLARE_DYNAMIC_CLASS_NO_COPY(wxGridEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxGridEvent)
};
class WXDLLIMPEXP_ADV wxGridSizeEvent : public wxNotifyEvent
bool MetaDown() { return m_meta; }
bool ShiftDown() { return m_shift; }
bool AltDown() { return m_alt; }
+ bool CmdDown()
+ {
+#if defined(__WXMAC__) || defined(__WXCOCOA__)
+ return MetaDown();
+#else
+ return ControlDown();
+#endif
+ }
+
+ virtual wxEvent *Clone() const { return new wxGridSizeEvent(*this); }
protected:
int m_rowOrCol;
bool m_shift;
bool m_alt;
- DECLARE_DYNAMIC_CLASS_NO_COPY(wxGridSizeEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxGridSizeEvent)
};
bool MetaDown() { return m_meta; }
bool ShiftDown() { return m_shift; }
bool AltDown() { return m_alt; }
+ bool CmdDown()
+ {
+#if defined(__WXMAC__) || defined(__WXCOCOA__)
+ return MetaDown();
+#else
+ return ControlDown();
+#endif
+ }
+
+ virtual wxEvent *Clone() const { return new wxGridRangeSelectEvent(*this); }
protected:
wxGridCellCoords m_topLeft;
bool m_shift;
bool m_alt;
- DECLARE_DYNAMIC_CLASS_NO_COPY(wxGridRangeSelectEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxGridRangeSelectEvent)
};
void SetCol(int col) { m_col = col; }
void SetControl(wxControl* ctrl) { m_ctrl = ctrl; }
+ virtual wxEvent *Clone() const { return new wxGridEditorCreatedEvent(*this); }
+
private:
int m_row;
int m_col;
wxControl* m_ctrl;
- DECLARE_DYNAMIC_CLASS(wxGridEditorCreatedEvent)
- DECLARE_NO_COPY_CLASS(wxGridEditorCreatedEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxGridEditorCreatedEvent)
};
-BEGIN_DECLARE_EVENT_TYPES()
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_LEFT_CLICK, 1580)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_RIGHT_CLICK, 1581)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_LEFT_DCLICK, 1582)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_RIGHT_DCLICK, 1583)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_LEFT_CLICK, 1584)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_RIGHT_CLICK, 1585)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_LEFT_DCLICK, 1586)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_RIGHT_DCLICK, 1587)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_ROW_SIZE, 1588)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_COL_SIZE, 1589)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_RANGE_SELECT, 1590)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_CHANGE, 1591)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_SELECT_CELL, 1592)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_EDITOR_SHOWN, 1593)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_EDITOR_HIDDEN, 1594)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_EDITOR_CREATED, 1595)
- DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_BEGIN_DRAG, 1596)
-END_DECLARE_EVENT_TYPES()
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_LEFT_CLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_RIGHT_CLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_LEFT_DCLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_RIGHT_DCLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_LABEL_LEFT_CLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_LABEL_RIGHT_CLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_LABEL_LEFT_DCLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_LABEL_RIGHT_DCLICK;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_ROW_SIZE;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_COL_SIZE;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_RANGE_SELECT;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_CHANGE;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_SELECT_CELL;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_EDITOR_SHOWN;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_EDITOR_HIDDEN;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_EDITOR_CREATED;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_CELL_BEGIN_DRAG;
+extern WXDLLIMPEXP_ADV const wxEventType wxEVT_GRID_COL_MOVE;
typedef void (wxEvtHandler::*wxGridEventFunction)(wxGridEvent&);
typedef void (wxEvtHandler::*wxGridEditorCreatedEventFunction)(wxGridEditorCreatedEvent&);
#define wxGridEventHandler(func) \
- (wxObjectEventFunction)wxStaticCastEvent(wxGridEventFunction, &func)
+ (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxGridEventFunction, &func)
#define wxGridSizeEventHandler(func) \
- (wxObjectEventFunction)wxStaticCastEvent(wxGridSizeEventFunction, &func)
+ (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxGridSizeEventFunction, &func)
#define wxGridRangeSelectEventHandler(func) \
- (wxObjectEventFunction)wxStaticCastEvent(wxGridRangeSelectEventFunction, &func)
+ (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxGridRangeSelectEventFunction, &func)
#define wxGridEditorCreatedEventHandler(func) \
- (wxObjectEventFunction)wxStaticCastEvent(wxGridEditorCreatedEventFunction, &func)
+ (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxGridEditorCreatedEventFunction, &func)
#define wx__DECLARE_GRIDEVT(evt, id, fn) \
wx__DECLARE_EVT1(wxEVT_GRID_ ## evt, id, wxGridEventHandler(fn))
#define EVT_GRID_CMD_LABEL_RIGHT_DCLICK(id, fn) wx__DECLARE_GRIDEVT(LABEL_RIGHT_DCLICK, id, fn)
#define EVT_GRID_CMD_ROW_SIZE(id, fn) wx__DECLARE_GRIDSIZEEVT(ROW_SIZE, id, fn)
#define EVT_GRID_CMD_COL_SIZE(id, fn) wx__DECLARE_GRIDSIZEEVT(COL_SIZE, id, fn)
+#define EVT_GRID_CMD_COL_MOVE(id, fn) wx__DECLARE_GRIDSIZEEVT(COL_MOVE, id, fn)
#define EVT_GRID_CMD_RANGE_SELECT(id, fn) wx__DECLARE_GRIDRANGESELEVT(RANGE_SELECT, id, fn)
#define EVT_GRID_CMD_CELL_CHANGE(id, fn) wx__DECLARE_GRIDEVT(CELL_CHANGE, id, fn)
#define EVT_GRID_CMD_SELECT_CELL(id, fn) wx__DECLARE_GRIDEVT(SELECT_CELL, id, fn)
#define EVT_GRID_LABEL_RIGHT_DCLICK(fn) EVT_GRID_CMD_LABEL_RIGHT_DCLICK(wxID_ANY, fn)
#define EVT_GRID_ROW_SIZE(fn) EVT_GRID_CMD_ROW_SIZE(wxID_ANY, fn)
#define EVT_GRID_COL_SIZE(fn) EVT_GRID_CMD_COL_SIZE(wxID_ANY, fn)
+#define EVT_GRID_COL_MOVE(fn) EVT_GRID_CMD_COL_MOVE(wxID_ANY, fn)
#define EVT_GRID_RANGE_SELECT(fn) EVT_GRID_CMD_RANGE_SELECT(wxID_ANY, fn)
#define EVT_GRID_CELL_CHANGE(fn) EVT_GRID_CMD_CELL_CHANGE(wxID_ANY, fn)
#define EVT_GRID_SELECT_CELL(fn) EVT_GRID_CMD_SELECT_CELL(wxID_ANY, fn)
#endif
-#endif // ifndef wxUSE_GRID
-
+#endif // wxUSE_GRID
+#endif // _WX_GENERIC_GRID_H_
projects / wxWidgets.git / blobdiff