// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
+#ifdef __BORLANDC__
+ #pragma hdrstop
+#endif
+
#if wxUSE_DATAVIEWCTRL
#include "wx/dataview.h"
#ifdef wxUSE_GENERICDATAVIEWCTRL
#ifndef WX_PRECOMP
+ #ifdef __WXMSW__
+ #include "wx/msw/wrapwin.h"
+ #endif
#include "wx/sizer.h"
#include "wx/log.h"
+ #include "wx/dcclient.h"
+ #include "wx/timer.h"
+ #include "wx/settings.h"
+ #include "wx/msgdlg.h"
#endif
#include "wx/stockitem.h"
-#include "wx/dcclient.h"
#include "wx/calctrl.h"
#include "wx/popupwin.h"
#include "wx/renderer.h"
-#include "wx/timer.h"
-#include "wx/settings.h"
-
-#ifdef __WXMSW__
- #include "wx/msw/wrapwin.h"
-#endif
+#include "wx/dcbuffer.h"
+#include "wx/icon.h"
//-----------------------------------------------------------------------------
// classes
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
const wxString &name = wxT("wxdataviewctrlheaderwindow") );
- ~wxDataViewHeaderWindow();
+ virtual ~wxDataViewHeaderWindow();
void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
wxDataViewCtrl *GetOwner() { return m_owner; }
wxDataViewTextCtrlWrapper( wxDataViewMainWindow *owner,
wxTextCtrl *text,
wxDataViewListModel *model,
- size_t col, size_t row,
+ unsigned int col, unsigned int row,
wxRect cellLabel );
wxTextCtrl *GetText() const { return m_text; }
wxTextCtrl *m_text;
wxString m_startValue;
wxDataViewListModel *m_model;
- size_t m_col;
- size_t m_row;
+ unsigned int m_col;
+ unsigned int m_row;
bool m_finished;
bool m_aboutToFinish;
// wxDataViewMainWindow
//-----------------------------------------------------------------------------
-WX_DEFINE_SORTED_ARRAY_SIZE_T( size_t, wxDataViewSelection );
+WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(unsigned int, wxDataViewSelection, WXDLLIMPEXP_ADV);
class wxDataViewMainWindow: public wxWindow
{
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
const wxString &name = wxT("wxdataviewctrlmainwindow") );
- ~wxDataViewMainWindow();
+ virtual ~wxDataViewMainWindow();
// notifications from wxDataViewListModel
bool RowAppended();
bool RowPrepended();
- bool RowInserted( size_t before );
- bool RowDeleted( size_t row );
- bool RowChanged( size_t row );
- bool ValueChanged( size_t col, size_t row );
- bool RowsReordered( size_t *new_order );
+ bool RowInserted( unsigned int before );
+ bool RowDeleted( unsigned int row );
+ bool RowChanged( unsigned int row );
+ bool ValueChanged( unsigned int col, unsigned int row );
+ bool RowsReordered( unsigned int *new_order );
bool Cleared();
void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
wxDataViewCtrl *GetOwner() { return m_owner; }
void OnPaint( wxPaintEvent &event );
- void OnArrowChar(size_t newCurrent, const wxKeyEvent& event);
+ void OnArrowChar(unsigned int newCurrent, const wxKeyEvent& event);
void OnChar( wxKeyEvent &event );
void OnMouse( wxMouseEvent &event );
void OnSetFocus( wxFocusEvent &event );
void ScrollWindow( int dx, int dy, const wxRect *rect );
- bool HasCurrentRow() { return m_currentRow != (size_t)-1; }
- void ChangeCurrentRow( size_t row );
+ bool HasCurrentRow() { return m_currentRow != (unsigned int)-1; }
+ void ChangeCurrentRow( unsigned int row );
bool IsSingleSel() const { return !GetParent()->HasFlag(wxDV_MULTIPLE); };
bool IsEmpty() { return GetRowCount() == 0; }
int GetCountPerPage();
int GetEndOfLastCol();
- size_t GetFirstVisibleRow();
- size_t GetLastVisibleRow();
- size_t GetRowCount();
+ unsigned int GetFirstVisibleRow();
+ unsigned int GetLastVisibleRow();
+ unsigned int GetRowCount();
void SelectAllRows( bool on );
- void SelectRow( size_t row, bool on );
- void SelectRows( size_t from, size_t to, bool on );
- void ReverseRowSelection( size_t row );
- bool IsRowSelected( size_t row );
+ void SelectRow( unsigned int row, bool on );
+ void SelectRows( unsigned int from, unsigned int to, bool on );
+ void ReverseRowSelection( unsigned int row );
+ bool IsRowSelected( unsigned int row );
- void RefreshRow( size_t row );
- void RefreshRows( size_t from, size_t to );
- void RefreshRowsAfter( size_t firstRow );
+ void RefreshRow( unsigned int row );
+ void RefreshRows( unsigned int from, unsigned int to );
+ void RefreshRowsAfter( unsigned int firstRow );
private:
wxDataViewCtrl *m_owner;
bool m_dirty;
wxDataViewColumn *m_currentCol;
- size_t m_currentRow;
+ unsigned int m_currentRow;
wxDataViewSelection m_selection;
wxDataViewRenameTimer *m_renameTimer;
wxPoint m_dragStart;
// for double click logic
- size_t m_lineLastClicked,
+ unsigned int m_lineLastClicked,
m_lineBeforeLastClicked,
m_lineSelectSingleOnUp;
{ return m_mainWindow->RowAppended(); }
virtual bool RowPrepended()
{ return m_mainWindow->RowPrepended(); }
- virtual bool RowInserted( size_t before )
+ virtual bool RowInserted( unsigned int before )
{ return m_mainWindow->RowInserted( before ); }
- virtual bool RowDeleted( size_t row )
+ virtual bool RowDeleted( unsigned int row )
{ return m_mainWindow->RowDeleted( row ); }
- virtual bool RowChanged( size_t row )
+ virtual bool RowChanged( unsigned int row )
{ return m_mainWindow->RowChanged( row ); }
- virtual bool ValueChanged( size_t col, size_t row )
+ virtual bool ValueChanged( unsigned int col, unsigned int row )
{ return m_mainWindow->ValueChanged( col, row ); }
- virtual bool RowsReordered( size_t *new_order )
+ virtual bool RowsReordered( unsigned int *new_order )
{ return m_mainWindow->RowsReordered( new_order ); }
virtual bool Cleared()
{ return m_mainWindow->Cleared(); }
};
// ---------------------------------------------------------
-// wxDataViewCell
+// wxDataViewRenderer
// ---------------------------------------------------------
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewCell, wxDataViewCellBase)
+IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase)
-wxDataViewCell::wxDataViewCell( const wxString &varianttype, wxDataViewCellMode mode ) :
- wxDataViewCellBase( varianttype, mode )
+wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype, wxDataViewCellMode mode ) :
+ wxDataViewRendererBase( varianttype, mode )
{
m_dc = NULL;
}
-wxDataViewCell::~wxDataViewCell()
+wxDataViewRenderer::~wxDataViewRenderer()
{
if (m_dc)
delete m_dc;
}
-wxDC *wxDataViewCell::GetDC()
+wxDC *wxDataViewRenderer::GetDC()
{
if (m_dc == NULL)
{
}
// ---------------------------------------------------------
-// wxDataViewCustomCell
+// wxDataViewCustomRenderer
// ---------------------------------------------------------
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomCell, wxDataViewCell)
+IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
-wxDataViewCustomCell::wxDataViewCustomCell( const wxString &varianttype,
+wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString &varianttype,
wxDataViewCellMode mode ) :
- wxDataViewCell( varianttype, mode )
+ wxDataViewRenderer( varianttype, mode )
{
}
// ---------------------------------------------------------
-// wxDataViewTextCell
+// wxDataViewTextRenderer
// ---------------------------------------------------------
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewTextCell, wxDataViewCustomCell)
+IMPLEMENT_CLASS(wxDataViewTextRenderer, wxDataViewCustomRenderer)
-wxDataViewTextCell::wxDataViewTextCell( const wxString &varianttype, wxDataViewCellMode mode ) :
- wxDataViewCustomCell( varianttype, mode )
+wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString &varianttype, wxDataViewCellMode mode ) :
+ wxDataViewCustomRenderer( varianttype, mode )
{
}
-bool wxDataViewTextCell::SetValue( const wxVariant &value )
+bool wxDataViewTextRenderer::SetValue( const wxVariant &value )
{
m_text = value.GetString();
return true;
}
-bool wxDataViewTextCell::GetValue( wxVariant& WXUNUSED(value) )
+bool wxDataViewTextRenderer::GetValue( wxVariant& WXUNUSED(value) )
{
return false;
}
-bool wxDataViewTextCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
+bool wxDataViewTextRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
{
dc->DrawText( m_text, cell.x, cell.y );
return true;
}
-wxSize wxDataViewTextCell::GetSize()
+wxSize wxDataViewTextRenderer::GetSize()
{
return wxSize(80,20);
}
// ---------------------------------------------------------
-// wxDataViewToggleCell
+// wxDataViewBitmapRenderer
+// ---------------------------------------------------------
+
+IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewCustomRenderer)
+
+wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString &varianttype, wxDataViewCellMode mode ) :
+ wxDataViewCustomRenderer( varianttype, mode )
+{
+}
+
+bool wxDataViewBitmapRenderer::SetValue( const wxVariant &value )
+{
+ if (value.GetType() == wxT("wxBitmap"))
+ m_bitmap << value;
+ if (value.GetType() == wxT("wxIcon"))
+ m_icon << value;
+
+ return true;
+}
+
+bool wxDataViewBitmapRenderer::GetValue( wxVariant& WXUNUSED(value) )
+{
+ return false;
+}
+
+bool wxDataViewBitmapRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
+{
+ if (m_bitmap.Ok())
+ dc->DrawBitmap( m_bitmap, cell.x, cell.y );
+ else if (m_icon.Ok())
+ dc->DrawIcon( m_icon, cell.x, cell.y );
+
+ return true;
+}
+
+wxSize wxDataViewBitmapRenderer::GetSize()
+{
+ if (m_bitmap.Ok())
+ return wxSize( m_bitmap.GetWidth(), m_bitmap.GetHeight() );
+ else if (m_icon.Ok())
+ return wxSize( m_icon.GetWidth(), m_icon.GetHeight() );
+
+ return wxSize(16,16);
+}
+
+// ---------------------------------------------------------
+// wxDataViewToggleRenderer
// ---------------------------------------------------------
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleCell, wxDataViewCustomCell)
+IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer, wxDataViewCustomRenderer)
-wxDataViewToggleCell::wxDataViewToggleCell( const wxString &varianttype,
+wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString &varianttype,
wxDataViewCellMode mode ) :
- wxDataViewCustomCell( varianttype, mode )
+ wxDataViewCustomRenderer( varianttype, mode )
{
m_toggle = false;
}
-bool wxDataViewToggleCell::SetValue( const wxVariant &value )
+bool wxDataViewToggleRenderer::SetValue( const wxVariant &value )
{
m_toggle = value.GetBool();
return true;
}
-bool wxDataViewToggleCell::GetValue( wxVariant &WXUNUSED(value) )
+bool wxDataViewToggleRenderer::GetValue( wxVariant &WXUNUSED(value) )
{
return false;
}
-bool wxDataViewToggleCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
+bool wxDataViewToggleRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
{
// User wxRenderer here
return true;
}
-bool wxDataViewToggleCell::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, size_t col, size_t row )
+bool wxDataViewToggleRenderer::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, unsigned int col, unsigned int row )
{
bool value = !m_toggle;
wxVariant variant = value;
return true;
}
-wxSize wxDataViewToggleCell::GetSize()
+wxSize wxDataViewToggleRenderer::GetSize()
{
return wxSize(20,20);
}
// ---------------------------------------------------------
-// wxDataViewProgressCell
+// wxDataViewProgressRenderer
// ---------------------------------------------------------
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressCell, wxDataViewCustomCell)
+IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer, wxDataViewCustomRenderer)
-wxDataViewProgressCell::wxDataViewProgressCell( const wxString &label,
+wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString &label,
const wxString &varianttype, wxDataViewCellMode mode ) :
- wxDataViewCustomCell( varianttype, mode )
+ wxDataViewCustomRenderer( varianttype, mode )
{
m_label = label;
m_value = 0;
}
-wxDataViewProgressCell::~wxDataViewProgressCell()
+wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
{
}
-bool wxDataViewProgressCell::SetValue( const wxVariant &value )
+bool wxDataViewProgressRenderer::SetValue( const wxVariant &value )
{
m_value = (long) value;
return true;
}
-bool wxDataViewProgressCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
+bool wxDataViewProgressRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
{
double pct = (double)m_value / 100.0;
wxRect bar = cell;
return true;
}
-wxSize wxDataViewProgressCell::GetSize()
+wxSize wxDataViewProgressRenderer::GetSize()
{
return wxSize(40,12);
}
// ---------------------------------------------------------
-// wxDataViewDateCell
+// wxDataViewDateRenderer
// ---------------------------------------------------------
-class wxDataViewDateCellPopupTransient: public wxPopupTransientWindow
+#if wxUSE_CALENDARCTRL
+
+class wxDataViewDateRendererPopupTransient: public wxPopupTransientWindow
{
public:
- wxDataViewDateCellPopupTransient( wxWindow* parent, wxDateTime *value,
- wxDataViewListModel *model, size_t col, size_t row ) :
+ wxDataViewDateRendererPopupTransient( wxWindow* parent, wxDateTime *value,
+ wxDataViewListModel *model, unsigned int col, unsigned int row ) :
wxPopupTransientWindow( parent, wxBORDER_SIMPLE )
{
m_model = model;
wxCalendarCtrl *m_cal;
wxDataViewListModel *m_model;
- size_t m_col;
- size_t m_row;
+ unsigned int m_col;
+ unsigned int m_row;
protected:
virtual void OnDismiss()
DECLARE_EVENT_TABLE()
};
-BEGIN_EVENT_TABLE(wxDataViewDateCellPopupTransient,wxPopupTransientWindow)
- EVT_CALENDAR( wxID_ANY, wxDataViewDateCellPopupTransient::OnCalendar )
+BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient,wxPopupTransientWindow)
+ EVT_CALENDAR( wxID_ANY, wxDataViewDateRendererPopupTransient::OnCalendar )
END_EVENT_TABLE()
-void wxDataViewDateCellPopupTransient::OnCalendar( wxCalendarEvent &event )
+void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent &event )
{
wxDateTime date = event.GetDate();
wxVariant value = date;
DismissAndNotify();
}
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateCell, wxDataViewCustomCell)
+#endif // wxUSE_CALENDARCTRL
+
+IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer, wxDataViewCustomRenderer)
-wxDataViewDateCell::wxDataViewDateCell( const wxString &varianttype,
+wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString &varianttype,
wxDataViewCellMode mode ) :
- wxDataViewCustomCell( varianttype, mode )
+ wxDataViewCustomRenderer( varianttype, mode )
{
}
-bool wxDataViewDateCell::SetValue( const wxVariant &value )
+bool wxDataViewDateRenderer::SetValue( const wxVariant &value )
{
m_date = value.GetDateTime();
return true;
}
-bool wxDataViewDateCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
+bool wxDataViewDateRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
{
dc->SetFont( GetOwner()->GetOwner()->GetFont() );
wxString tmp = m_date.FormatDate();
return true;
}
-wxSize wxDataViewDateCell::GetSize()
+wxSize wxDataViewDateRenderer::GetSize()
{
wxDataViewCtrl* view = GetOwner()->GetOwner();
wxString tmp = m_date.FormatDate();
return wxSize(x,y+d);
}
-bool wxDataViewDateCell::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, size_t col, size_t row )
+bool wxDataViewDateRenderer::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, unsigned int col, unsigned int row )
{
wxVariant variant;
model->GetValue( variant, col, row );
wxDateTime value = variant.GetDateTime();
- wxDataViewDateCellPopupTransient *popup = new wxDataViewDateCellPopupTransient(
+#if wxUSE_CALENDARCTRL
+ wxDataViewDateRendererPopupTransient *popup = new wxDataViewDateRendererPopupTransient(
GetOwner()->GetOwner()->GetParent(), &value, model, col, row );
wxPoint pos = wxGetMousePosition();
popup->Move( pos );
popup->Layout();
popup->Popup( popup->m_cal );
-
+#else
+ wxMessageBox(value.Format());
+#endif
return true;
}
IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
-wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewCell *cell, size_t model_column,
- int fixed_width, wxDataViewColumnSizing sizing, int flags ) :
- wxDataViewColumnBase( title, cell, model_column, flags )
+wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewRenderer *cell, unsigned int model_column,
+ int width, int flags ) :
+ wxDataViewColumnBase( title, cell, model_column, width, flags )
{
- m_sizing = sizing;
+ m_width = width;
+ if (m_width < 0)
+ m_width = 80;
+}
- m_width = fixed_width;
- m_fixedWidth = fixed_width;
+wxDataViewColumn::wxDataViewColumn( const wxBitmap &bitmap, wxDataViewRenderer *cell, unsigned int model_column,
+ int width, int flags ) :
+ wxDataViewColumnBase( bitmap, cell, model_column, width, flags )
+{
+ m_width = width;
+ if (m_width < 0)
+ m_width = 30;
}
-wxDataViewColumn::~wxDataViewColumn()
+void wxDataViewColumn::SetAlignment( wxAlignment WXUNUSED(align) )
{
+ // TODO
}
-void wxDataViewColumn::SetTitle( const wxString &title )
+void wxDataViewColumn::SetSortable( bool WXUNUSED(sortable) )
{
- wxDataViewColumnBase::SetTitle( title );
+ // TODO
+}
+bool wxDataViewColumn::GetSortable()
+{
+ // TODO
+ return false;
}
-int wxDataViewColumn::GetWidth()
+void wxDataViewColumn::SetSortOrder( bool WXUNUSED(ascending) )
+{
+ // TODO
+}
+
+bool wxDataViewColumn::IsSortOrderAscending()
+{
+ // TODO
+ return true;
+}
+
+
+wxDataViewColumn::~wxDataViewColumn()
{
- return m_width;
}
-void wxDataViewColumn::SetFixedWidth( int width )
+void wxDataViewColumn::SetTitle( const wxString &title )
{
- m_fixedWidth = width;
+ wxDataViewColumnBase::SetTitle( title );
- if (m_sizing == wxDATAVIEW_COL_WIDTH_FIXED)
- {
- m_width = width;
- // Set dirty
- }
}
-int wxDataViewColumn::GetFixedWidth()
+void wxDataViewColumn::SetBitmap( const wxBitmap &bitmap )
{
- return m_fixedWidth;
+ wxDataViewColumnBase::SetBitmap( bitmap );
+
+}
+
+int wxDataViewColumn::GetWidth()
+{
+ return m_width;
}
//-----------------------------------------------------------------------------
m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );
wxVisualAttributes attr = wxPanel::GetClassDefaultAttributes();
+ SetBackgroundStyle( wxBG_STYLE_CUSTOM );
SetOwnForegroundColour( attr.colFg );
SetOwnBackgroundColour( attr.colBg );
if (!m_hasFont)
int w, h;
GetClientSize( &w, &h );
- wxPaintDC dc( this );
+ wxAutoBufferedPaintDC dc( this );
+
+ dc.SetBackground(GetBackgroundColour());
+ dc.Clear();
int xpix;
m_owner->GetScrollPixelsPerUnit( &xpix, NULL );
dc.SetFont( GetFont() );
- size_t cols = GetOwner()->GetNumberOfColumns();
- size_t i;
+ unsigned int cols = GetOwner()->GetNumberOfColumns();
+ unsigned int i;
int xpos = 0;
for (i = 0; i < cols; i++)
{
wxDataViewMainWindow *owner,
wxTextCtrl *text,
wxDataViewListModel *model,
- size_t col, size_t row,
+ unsigned int col, unsigned int row,
wxRect rectLabel )
{
m_owner = owner;
// wxDataViewMainWindow
//-----------------------------------------------------------------------------
-int LINKAGEMODE wxDataViewSelectionCmp( size_t row1, size_t row2 )
+int LINKAGEMODE wxDataViewSelectionCmp( unsigned int row1, unsigned int row2 )
{
if (row1 > row2) return 1;
if (row1 == row2) return 0;
m_dragCount = 0;
m_dragStart = wxPoint(0,0);
- m_lineLastClicked = (size_t) -1;
- m_lineBeforeLastClicked = (size_t) -1;
- m_lineSelectSingleOnUp = (size_t) -1;
+ m_lineLastClicked = (unsigned int) -1;
+ m_lineBeforeLastClicked = (unsigned int) -1;
+ m_lineSelectSingleOnUp = (unsigned int) -1;
m_hasFocus = false;
+ SetBackgroundStyle( wxBG_STYLE_CUSTOM );
SetBackgroundColour( *wxWHITE );
UpdateDisplay();
int xpos = 0;
- size_t cols = GetOwner()->GetNumberOfColumns();
- size_t i;
+ unsigned int cols = GetOwner()->GetNumberOfColumns();
+ unsigned int i;
for (i = 0; i < cols; i++)
{
wxDataViewColumn *c = GetOwner()->GetColumn( i );
return false;
}
-bool wxDataViewMainWindow::RowInserted( size_t WXUNUSED(before) )
+bool wxDataViewMainWindow::RowInserted( unsigned int WXUNUSED(before) )
{
return false;
}
-bool wxDataViewMainWindow::RowDeleted( size_t WXUNUSED(row) )
+bool wxDataViewMainWindow::RowDeleted( unsigned int WXUNUSED(row) )
{
return false;
}
-bool wxDataViewMainWindow::RowChanged( size_t WXUNUSED(row) )
+bool wxDataViewMainWindow::RowChanged( unsigned int WXUNUSED(row) )
{
return false;
}
-bool wxDataViewMainWindow::ValueChanged( size_t WXUNUSED(col), size_t row )
+bool wxDataViewMainWindow::ValueChanged( unsigned int WXUNUSED(col), unsigned int row )
{
wxRect rect( 0, row*m_lineHeight, 10000, m_lineHeight );
m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
return true;
}
-bool wxDataViewMainWindow::RowsReordered( size_t *WXUNUSED(new_order) )
+bool wxDataViewMainWindow::RowsReordered( unsigned int *WXUNUSED(new_order) )
{
Refresh();
}
int width = 0;
- size_t cols = GetOwner()->GetNumberOfColumns();
- size_t i;
+ unsigned int cols = GetOwner()->GetNumberOfColumns();
+ unsigned int i;
for (i = 0; i < cols; i++)
{
wxDataViewColumn *col = GetOwner()->GetColumn( i );
void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
{
- wxPaintDC dc( this );
+ wxAutoBufferedPaintDC dc( this );
+
+ dc.SetBackground(GetBackgroundColour());
+ dc.Clear();
GetOwner()->PrepareDC( dc );
wxDataViewListModel *model = GetOwner()->GetModel();
- size_t item_start = wxMax( 0, (update.y / m_lineHeight) );
- size_t item_count = wxMin( (int)(((update.y + update.height) / m_lineHeight) - item_start + 1),
+ unsigned int item_start = wxMax( 0, (update.y / m_lineHeight) );
+ unsigned int item_count = wxMin( (int)(((update.y + update.height) / m_lineHeight) - item_start + 1),
(int)(model->GetNumberOfRows()-item_start) );
- size_t item;
+ unsigned int item;
for (item = item_start; item < item_start+item_count; item++)
{
if (m_selection.Index( item ) != wxNOT_FOUND)
wxRect cell_rect;
cell_rect.x = 0;
cell_rect.height = m_lineHeight;
- size_t cols = GetOwner()->GetNumberOfColumns();
- size_t i;
+ unsigned int cols = GetOwner()->GetNumberOfColumns();
+ unsigned int i;
for (i = 0; i < cols; i++)
{
wxDataViewColumn *col = GetOwner()->GetColumn( i );
- wxDataViewCell *cell = col->GetCell();
+ wxDataViewRenderer *cell = col->GetRenderer();
cell_rect.width = col->GetWidth();
for (item = item_start; item < item_start+item_count; item++)
int wxDataViewMainWindow::GetEndOfLastCol()
{
int width = 0;
- size_t i;
+ unsigned int i;
for (i = 0; i < GetOwner()->GetNumberOfColumns(); i++)
{
wxDataViewColumn *c = GetOwner()->GetColumn( i );
return width;
}
-size_t wxDataViewMainWindow::GetFirstVisibleRow()
+unsigned int wxDataViewMainWindow::GetFirstVisibleRow()
{
int x = 0;
int y = 0;
return y / m_lineHeight;
}
-size_t wxDataViewMainWindow::GetLastVisibleRow()
+unsigned int wxDataViewMainWindow::GetLastVisibleRow()
{
wxSize client_size = GetClientSize();
m_owner->CalcUnscrolledPosition( client_size.x, client_size.y, &client_size.x, &client_size.y );
- return wxMin( GetRowCount()-1, (client_size.y/m_lineHeight)+1 );
+ return wxMin( GetRowCount()-1, ((unsigned)client_size.y/m_lineHeight)+1 );
}
-size_t wxDataViewMainWindow::GetRowCount()
+unsigned int wxDataViewMainWindow::GetRowCount()
{
return GetOwner()->GetModel()->GetNumberOfRows();
}
-void wxDataViewMainWindow::ChangeCurrentRow( size_t row )
+void wxDataViewMainWindow::ChangeCurrentRow( unsigned int row )
{
m_currentRow = row;
if (on)
{
m_selection.Clear();
- for (size_t i = 0; i < GetRowCount(); i++)
+ for (unsigned int i = 0; i < GetRowCount(); i++)
m_selection.Add( i );
Refresh();
}
else
{
- size_t first_visible = GetFirstVisibleRow();
- size_t last_visible = GetLastVisibleRow();
- size_t i;
+ unsigned int first_visible = GetFirstVisibleRow();
+ unsigned int last_visible = GetLastVisibleRow();
+ unsigned int i;
for (i = 0; i < m_selection.GetCount(); i++)
{
- size_t row = m_selection[i];
+ unsigned int row = m_selection[i];
if ((row >= first_visible) && (row <= last_visible))
RefreshRow( row );
}
}
}
-void wxDataViewMainWindow::SelectRow( size_t row, bool on )
+void wxDataViewMainWindow::SelectRow( unsigned int row, bool on )
{
if (m_selection.Index( row ) == wxNOT_FOUND)
{
}
}
-void wxDataViewMainWindow::SelectRows( size_t from, size_t to, bool on )
+void wxDataViewMainWindow::SelectRows( unsigned int from, unsigned int to, bool on )
{
if (from > to)
{
- size_t tmp = from;
+ unsigned int tmp = from;
from = to;
to = tmp;
}
- size_t i;
+ unsigned int i;
for (i = from; i <= to; i++)
{
if (m_selection.Index( i ) == wxNOT_FOUND)
RefreshRows( from, to );
}
-void wxDataViewMainWindow::ReverseRowSelection( size_t row )
+void wxDataViewMainWindow::ReverseRowSelection( unsigned int row )
{
if (m_selection.Index( row ) == wxNOT_FOUND)
m_selection.Add( row );
RefreshRow( row );
}
-bool wxDataViewMainWindow::IsRowSelected( size_t row )
+bool wxDataViewMainWindow::IsRowSelected( unsigned int row )
{
return (m_selection.Index( row ) != wxNOT_FOUND);
}
-void wxDataViewMainWindow::RefreshRow( size_t row )
+void wxDataViewMainWindow::RefreshRow( unsigned int row )
{
wxRect rect( 0, row*m_lineHeight, GetEndOfLastCol(), m_lineHeight );
m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
Refresh( true, &intersect_rect );
}
-void wxDataViewMainWindow::RefreshRows( size_t from, size_t to )
+void wxDataViewMainWindow::RefreshRows( unsigned int from, unsigned int to )
{
if (from > to)
{
- size_t tmp = to;
+ unsigned int tmp = to;
to = from;
from = tmp;
}
Refresh( true, &intersect_rect );
}
-void wxDataViewMainWindow::RefreshRowsAfter( size_t firstRow )
+void wxDataViewMainWindow::RefreshRowsAfter( unsigned int firstRow )
{
- size_t count = GetRowCount();
+ unsigned int count = GetRowCount();
if (firstRow > count)
return;
Refresh( true, &intersect_rect );
}
-void wxDataViewMainWindow::OnArrowChar(size_t newCurrent, const wxKeyEvent& event)
+void wxDataViewMainWindow::OnArrowChar(unsigned int newCurrent, const wxKeyEvent& event)
{
wxCHECK_RET( newCurrent < GetRowCount(),
_T("invalid item index in OnArrowChar()") );
if (!HasCurrentRow())
return;
- size_t oldCurrent = m_currentRow;
+ unsigned int oldCurrent = m_currentRow;
// in single selection we just ignore Shift as we can't select several
// items anyhow
case WXK_PAGEDOWN:
{
int steps = pageSize - 1;
- size_t index = m_currentRow + steps;
- size_t count = GetRowCount();
+ unsigned int index = m_currentRow + steps;
+ unsigned int count = GetRowCount();
if ( index >= count )
index = count - 1;
wxDataViewColumn *col = NULL;
int xpos = 0;
- size_t cols = GetOwner()->GetNumberOfColumns();
- size_t i;
+ unsigned int cols = GetOwner()->GetNumberOfColumns();
+ unsigned int i;
for (i = 0; i < cols; i++)
{
wxDataViewColumn *c = GetOwner()->GetColumn( i );
}
if (!col)
return;
- wxDataViewCell *cell = col->GetCell();
+ wxDataViewRenderer *cell = col->GetRenderer();
- size_t current = y / m_lineHeight;
+ unsigned int current = y / m_lineHeight;
if ((current > GetRowCount()) || (x > GetEndOfLastCol()))
{
if (event.LeftUp())
{
- if (m_lineSelectSingleOnUp != (size_t)-1)
+ if (m_lineSelectSingleOnUp != (unsigned int)-1)
{
// select single line
SelectAllRows( false );
}
m_lastOnSame = false;
- m_lineSelectSingleOnUp = (size_t)-1;
+ m_lineSelectSingleOnUp = (unsigned int)-1;
}
else
{
// from and to ourself, the up event is swallowed by the
// DnD code. So on next non-up event (which means here and
// now) m_lineSelectSingleOnUp should be reset.
- m_lineSelectSingleOnUp = (size_t)-1;
+ m_lineSelectSingleOnUp = (unsigned int)-1;
}
if (event.RightDown())
m_lineBeforeLastClicked = m_lineLastClicked;
m_lineLastClicked = current;
- size_t oldCurrentRow = m_currentRow;
+ unsigned int oldCurrentRow = m_currentRow;
bool oldWasSelected = IsRowSelected(m_currentRow);
bool cmdModifierDown = event.CmdDown();
{
ChangeCurrentRow(current);
- size_t lineFrom = oldCurrentRow,
+ unsigned int lineFrom = oldCurrentRow,
lineTo = current;
if ( lineTo < lineFrom )
return true;
}
+void wxDataViewCtrl::SetSelection( int WXUNUSED(row) )
+{
+ // FIXME - TODO
+}
+
+void wxDataViewCtrl::SetSelectionRange( unsigned int WXUNUSED(from), unsigned int WXUNUSED(to) )
+{
+ // FIXME - TODO
+}
+
+void wxDataViewCtrl::SetSelections( const wxArrayInt& WXUNUSED(aSelections) )
+{
+ // FIXME - TODO
+}
+
+void wxDataViewCtrl::Unselect( unsigned int WXUNUSED(row) )
+{
+ // FIXME - TODO
+}
+
+bool wxDataViewCtrl::IsSelected( unsigned int WXUNUSED(row) ) const
+{
+ // FIXME - TODO
+
+ return false;
+}
+
+int wxDataViewCtrl::GetSelection() const
+{
+ // FIXME - TODO
+
+ return -1;
+}
+
+int wxDataViewCtrl::GetSelections(wxArrayInt& WXUNUSED(aSelections) ) const
+{
+ // FIXME - TODO
+
+ return 0;
+}
+
#endif
// !wxUSE_GENERICDATAVIEWCTRL
projects / wxWidgets.git / blobdiff