]> git.saurik.com Git - wxWidgets.git/blame - src/generic/grid.cpp
Added samples.inc to DATAFILES in Makefile.in - is that enough?
[wxWidgets.git] / src / generic / grid.cpp
CommitLineData
2796cce3 1///////////////////////////////////////////////////////////////////////////
d16c04bb 2// Name: generic/grid.cpp
f85afd4e
MB
3// Purpose: wxGrid and related classes
4// Author: Michael Bedward (based on code by Julian Smart, Robin Dunn)
5// Modified by:
6// Created: 1/08/1999
7// RCS-ID: $Id$
8// Copyright: (c) Michael Bedward (mbedward@ozemail.com.au)
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
758cbedf
VZ
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
f85afd4e
MB
20#ifdef __GNUG__
21 #pragma implementation "grid.h"
22#endif
23
4d85bcd1
JS
24// For compilers that support precompilation, includes "wx/wx.h".
25#include "wx/wxprec.h"
26
27#include "wx/defs.h"
f85afd4e
MB
28
29#ifdef __BORLANDC__
30 #pragma hdrstop
31#endif
32
8f177c8e 33#if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
4d85bcd1
JS
34#include "gridg.cpp"
35#else
36
f85afd4e
MB
37#ifndef WX_PRECOMP
38 #include "wx/utils.h"
39 #include "wx/dcclient.h"
40 #include "wx/settings.h"
41 #include "wx/log.h"
508011ce
VZ
42 #include "wx/textctrl.h"
43 #include "wx/checkbox.h"
4ee5fc9c 44 #include "wx/combobox.h"
816be743 45 #include "wx/valtext.h"
f85afd4e
MB
46#endif
47
cb5df486 48#include "wx/textfile.h"
816be743 49#include "wx/spinctrl.h"
c4608a8a 50#include "wx/tokenzr.h"
6d004f67 51
07296f0b 52#include "wx/grid.h"
b5808881 53#include "wx/generic/gridsel.h"
07296f0b 54
b99be8fb 55// ----------------------------------------------------------------------------
758cbedf 56// array classes
b99be8fb
VZ
57// ----------------------------------------------------------------------------
58
758cbedf
VZ
59WX_DEFINE_ARRAY(wxGridCellAttr *, wxArrayAttrs);
60
b99be8fb
VZ
61struct wxGridCellWithAttr
62{
2e9a6788
VZ
63 wxGridCellWithAttr(int row, int col, wxGridCellAttr *attr_)
64 : coords(row, col), attr(attr_)
b99be8fb
VZ
65 {
66 }
67
2e9a6788
VZ
68 ~wxGridCellWithAttr()
69 {
70 attr->DecRef();
71 }
72
b99be8fb 73 wxGridCellCoords coords;
2e9a6788 74 wxGridCellAttr *attr;
b99be8fb
VZ
75};
76
77WX_DECLARE_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
78
79#include "wx/arrimpl.cpp"
80
81WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
82WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
83
84// ----------------------------------------------------------------------------
85// private classes
86// ----------------------------------------------------------------------------
87
88class WXDLLEXPORT wxGridRowLabelWindow : public wxWindow
89{
90public:
91 wxGridRowLabelWindow() { m_owner = (wxGrid *)NULL; }
92 wxGridRowLabelWindow( wxGrid *parent, wxWindowID id,
93 const wxPoint &pos, const wxSize &size );
94
95private:
96 wxGrid *m_owner;
97
98 void OnPaint( wxPaintEvent& event );
99 void OnMouseEvent( wxMouseEvent& event );
100 void OnKeyDown( wxKeyEvent& event );
101
102 DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
103 DECLARE_EVENT_TABLE()
104};
105
106
107class WXDLLEXPORT wxGridColLabelWindow : public wxWindow
108{
109public:
110 wxGridColLabelWindow() { m_owner = (wxGrid *)NULL; }
111 wxGridColLabelWindow( wxGrid *parent, wxWindowID id,
112 const wxPoint &pos, const wxSize &size );
113
114private:
115 wxGrid *m_owner;
116
117 void OnPaint( wxPaintEvent &event );
118 void OnMouseEvent( wxMouseEvent& event );
119 void OnKeyDown( wxKeyEvent& event );
120
121 DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
122 DECLARE_EVENT_TABLE()
123};
124
125
126class WXDLLEXPORT wxGridCornerLabelWindow : public wxWindow
127{
128public:
129 wxGridCornerLabelWindow() { m_owner = (wxGrid *)NULL; }
130 wxGridCornerLabelWindow( wxGrid *parent, wxWindowID id,
131 const wxPoint &pos, const wxSize &size );
132
133private:
134 wxGrid *m_owner;
135
136 void OnMouseEvent( wxMouseEvent& event );
137 void OnKeyDown( wxKeyEvent& event );
138 void OnPaint( wxPaintEvent& event );
139
140 DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
141 DECLARE_EVENT_TABLE()
142};
143
144class WXDLLEXPORT wxGridWindow : public wxPanel
145{
146public:
147 wxGridWindow()
148 {
149 m_owner = (wxGrid *)NULL;
150 m_rowLabelWin = (wxGridRowLabelWindow *)NULL;
151 m_colLabelWin = (wxGridColLabelWindow *)NULL;
152 }
153
154 wxGridWindow( wxGrid *parent,
155 wxGridRowLabelWindow *rowLblWin,
156 wxGridColLabelWindow *colLblWin,
157 wxWindowID id, const wxPoint &pos, const wxSize &size );
158 ~wxGridWindow();
159
160 void ScrollWindow( int dx, int dy, const wxRect *rect );
161
162private:
163 wxGrid *m_owner;
164 wxGridRowLabelWindow *m_rowLabelWin;
165 wxGridColLabelWindow *m_colLabelWin;
166
167 void OnPaint( wxPaintEvent &event );
168 void OnMouseEvent( wxMouseEvent& event );
169 void OnKeyDown( wxKeyEvent& );
2796cce3
RD
170 void OnEraseBackground( wxEraseEvent& );
171
b99be8fb
VZ
172
173 DECLARE_DYNAMIC_CLASS(wxGridWindow)
174 DECLARE_EVENT_TABLE()
175};
176
2796cce3
RD
177
178
179class wxGridCellEditorEvtHandler : public wxEvtHandler
180{
181public:
182 wxGridCellEditorEvtHandler()
183 : m_grid(0), m_editor(0)
184 { }
185 wxGridCellEditorEvtHandler(wxGrid* grid, wxGridCellEditor* editor)
186 : m_grid(grid), m_editor(editor)
187 { }
188
189 void OnKeyDown(wxKeyEvent& event);
fb0de762 190 void OnChar(wxKeyEvent& event);
2796cce3
RD
191
192private:
193 wxGrid* m_grid;
194 wxGridCellEditor* m_editor;
195 DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
196 DECLARE_EVENT_TABLE()
197};
198
199
200IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler, wxEvtHandler )
201BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
202 EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
fb0de762 203 EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )
2796cce3
RD
204END_EVENT_TABLE()
205
206
207
758cbedf 208// ----------------------------------------------------------------------------
b99be8fb 209// the internal data representation used by wxGridCellAttrProvider
758cbedf
VZ
210// ----------------------------------------------------------------------------
211
212// this class stores attributes set for cells
213class WXDLLEXPORT wxGridCellAttrData
b99be8fb
VZ
214{
215public:
2e9a6788 216 void SetAttr(wxGridCellAttr *attr, int row, int col);
b99be8fb 217 wxGridCellAttr *GetAttr(int row, int col) const;
4d60017a
SN
218 void UpdateAttrRows( size_t pos, int numRows );
219 void UpdateAttrCols( size_t pos, int numCols );
b99be8fb
VZ
220
221private:
222 // searches for the attr for given cell, returns wxNOT_FOUND if not found
223 int FindIndex(int row, int col) const;
224
225 wxGridCellWithAttrArray m_attrs;
226};
227
758cbedf
VZ
228// this class stores attributes set for rows or columns
229class WXDLLEXPORT wxGridRowOrColAttrData
230{
231public:
ee6694a7
VZ
232 // empty ctor to suppress warnings
233 wxGridRowOrColAttrData() { }
758cbedf
VZ
234 ~wxGridRowOrColAttrData();
235
236 void SetAttr(wxGridCellAttr *attr, int rowOrCol);
237 wxGridCellAttr *GetAttr(int rowOrCol) const;
4d60017a 238 void UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols );
758cbedf
VZ
239
240private:
241 wxArrayInt m_rowsOrCols;
242 wxArrayAttrs m_attrs;
243};
244
245// NB: this is just a wrapper around 3 objects: one which stores cell
246// attributes, and 2 others for row/col ones
247class WXDLLEXPORT wxGridCellAttrProviderData
248{
249public:
250 wxGridCellAttrData m_cellAttrs;
251 wxGridRowOrColAttrData m_rowAttrs,
252 m_colAttrs;
253};
254
f2d76237
RD
255
256// ----------------------------------------------------------------------------
257// data structures used for the data type registry
258// ----------------------------------------------------------------------------
259
b94ae1ea
VZ
260struct wxGridDataTypeInfo
261{
f2d76237
RD
262 wxGridDataTypeInfo(const wxString& typeName,
263 wxGridCellRenderer* renderer,
264 wxGridCellEditor* editor)
265 : m_typeName(typeName), m_renderer(renderer), m_editor(editor)
266 { }
267
39bcce60
VZ
268 ~wxGridDataTypeInfo()
269 {
270 wxSafeDecRef(m_renderer);
271 wxSafeDecRef(m_editor);
272 }
f2d76237
RD
273
274 wxString m_typeName;
275 wxGridCellRenderer* m_renderer;
276 wxGridCellEditor* m_editor;
277};
278
279
280WX_DEFINE_ARRAY(wxGridDataTypeInfo*, wxGridDataTypeInfoArray);
281
282
b94ae1ea
VZ
283class WXDLLEXPORT wxGridTypeRegistry
284{
f2d76237
RD
285public:
286 ~wxGridTypeRegistry();
b94ae1ea 287
f2d76237
RD
288 void RegisterDataType(const wxString& typeName,
289 wxGridCellRenderer* renderer,
290 wxGridCellEditor* editor);
c4608a8a
VZ
291
292 // find one of already registered data types
293 int FindRegisteredDataType(const wxString& typeName);
294
295 // try to FindRegisteredDataType(), if this fails and typeName is one of
296 // standard typenames, register it and return its index
f2d76237 297 int FindDataType(const wxString& typeName);
c4608a8a
VZ
298
299 // try to FindDataType(), if it fails see if it is not one of already
300 // registered data types with some params in which case clone the
301 // registered data type and set params for it
302 int FindOrCloneDataType(const wxString& typeName);
303
f2d76237
RD
304 wxGridCellRenderer* GetRenderer(int index);
305 wxGridCellEditor* GetEditor(int index);
306
307private:
308 wxGridDataTypeInfoArray m_typeinfo;
309};
310
b99be8fb
VZ
311// ----------------------------------------------------------------------------
312// conditional compilation
313// ----------------------------------------------------------------------------
314
9496deb5
MB
315#ifndef WXGRID_DRAW_LINES
316#define WXGRID_DRAW_LINES 1
796df70a
SN
317#endif
318
0a976765
VZ
319// ----------------------------------------------------------------------------
320// globals
321// ----------------------------------------------------------------------------
322
323//#define DEBUG_ATTR_CACHE
324#ifdef DEBUG_ATTR_CACHE
325 static size_t gs_nAttrCacheHits = 0;
326 static size_t gs_nAttrCacheMisses = 0;
327#endif // DEBUG_ATTR_CACHE
f85afd4e 328
43947979
VZ
329// ----------------------------------------------------------------------------
330// constants
331// ----------------------------------------------------------------------------
332
f85afd4e
MB
333wxGridCellCoords wxGridNoCellCoords( -1, -1 );
334wxRect wxGridNoCellRect( -1, -1, -1, -1 );
335
f0102d2a
VZ
336// scroll line size
337// TODO: fixed so far - make configurable later (and also different for x/y)
338static const size_t GRID_SCROLL_LINE = 10;
f85afd4e 339
43947979
VZ
340// the size of hash tables used a bit everywhere (the max number of elements
341// in these hash tables is the number of rows/columns)
342static const int GRID_HASH_SIZE = 100;
343
ab79958a
VZ
344// ============================================================================
345// implementation
346// ============================================================================
347
2796cce3
RD
348// ----------------------------------------------------------------------------
349// wxGridCellEditor
350// ----------------------------------------------------------------------------
351
352wxGridCellEditor::wxGridCellEditor()
353{
354 m_control = NULL;
355}
356
357
358wxGridCellEditor::~wxGridCellEditor()
359{
360 Destroy();
361}
362
508011ce
VZ
363void wxGridCellEditor::Create(wxWindow* WXUNUSED(parent),
364 wxWindowID WXUNUSED(id),
365 wxEvtHandler* evtHandler)
366{
189d0213 367 if ( evtHandler )
508011ce
VZ
368 m_control->PushEventHandler(evtHandler);
369}
2796cce3 370
189d0213
VZ
371void wxGridCellEditor::PaintBackground(const wxRect& rectCell,
372 wxGridCellAttr *attr)
373{
374 // erase the background because we might not fill the cell
375 wxClientDC dc(m_control->GetParent());
376 dc.SetPen(*wxTRANSPARENT_PEN);
377 dc.SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
378 dc.DrawRectangle(rectCell);
379
380 // redraw the control we just painted over
381 m_control->Refresh();
382}
383
2796cce3
RD
384void wxGridCellEditor::Destroy()
385{
508011ce
VZ
386 if (m_control)
387 {
b94ae1ea
VZ
388 m_control->PopEventHandler(TRUE /* delete it*/);
389
2796cce3
RD
390 m_control->Destroy();
391 m_control = NULL;
392 }
393}
394
3da93aae 395void wxGridCellEditor::Show(bool show, wxGridCellAttr *attr)
2796cce3
RD
396{
397 wxASSERT_MSG(m_control,
398 wxT("The wxGridCellEditor must be Created first!"));
399 m_control->Show(show);
3da93aae
VZ
400
401 if ( show )
402 {
403 // set the colours/fonts if we have any
404 if ( attr )
405 {
f2d76237
RD
406 m_colFgOld = m_control->GetForegroundColour();
407 m_control->SetForegroundColour(attr->GetTextColour());
3da93aae 408
f2d76237
RD
409 m_colBgOld = m_control->GetBackgroundColour();
410 m_control->SetBackgroundColour(attr->GetBackgroundColour());
3da93aae 411
f2d76237
RD
412 m_fontOld = m_control->GetFont();
413 m_control->SetFont(attr->GetFont());
3da93aae
VZ
414
415 // can't do anything more in the base class version, the other
416 // attributes may only be used by the derived classes
417 }
418 }
419 else
420 {
421 // restore the standard colours fonts
422 if ( m_colFgOld.Ok() )
423 {
424 m_control->SetForegroundColour(m_colFgOld);
425 m_colFgOld = wxNullColour;
426 }
427
428 if ( m_colBgOld.Ok() )
429 {
430 m_control->SetBackgroundColour(m_colBgOld);
431 m_colBgOld = wxNullColour;
432 }
433
434 if ( m_fontOld.Ok() )
435 {
436 m_control->SetFont(m_fontOld);
437 m_fontOld = wxNullFont;
438 }
439 }
2796cce3
RD
440}
441
442void wxGridCellEditor::SetSize(const wxRect& rect)
443{
444 wxASSERT_MSG(m_control,
445 wxT("The wxGridCellEditor must be Created first!"));
28a77bc4 446 m_control->SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);
2796cce3
RD
447}
448
449void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
450{
451 event.Skip();
452}
453
454
2c9a89e0
RD
455void wxGridCellEditor::StartingKey(wxKeyEvent& event)
456{
e195a54c
VZ
457 event.Skip();
458}
2c9a89e0 459
e195a54c
VZ
460void wxGridCellEditor::StartingClick()
461{
b54ba671 462}
2c9a89e0 463
b54ba671
VZ
464// ----------------------------------------------------------------------------
465// wxGridCellTextEditor
466// ----------------------------------------------------------------------------
2c9a89e0 467
2796cce3
RD
468wxGridCellTextEditor::wxGridCellTextEditor()
469{
c4608a8a 470 m_maxChars = 0;
2796cce3
RD
471}
472
473void wxGridCellTextEditor::Create(wxWindow* parent,
474 wxWindowID id,
2796cce3
RD
475 wxEvtHandler* evtHandler)
476{
508011ce 477 m_control = new wxTextCtrl(parent, id, wxEmptyString,
2c9a89e0 478 wxDefaultPosition, wxDefaultSize
2796cce3 479#if defined(__WXMSW__)
2c9a89e0 480 , wxTE_MULTILINE | wxTE_NO_VSCROLL // necessary ???
2796cce3 481#endif
508011ce 482 );
2796cce3 483
c4608a8a
VZ
484 // TODO: use m_maxChars
485
508011ce 486 wxGridCellEditor::Create(parent, id, evtHandler);
2796cce3
RD
487}
488
189d0213
VZ
489void wxGridCellTextEditor::PaintBackground(const wxRect& WXUNUSED(rectCell),
490 wxGridCellAttr * WXUNUSED(attr))
491{
492 // as we fill the entire client area, don't do anything here to minimize
493 // flicker
494}
2796cce3 495
99306db2
VZ
496void wxGridCellTextEditor::SetSize(const wxRect& rectOrig)
497{
498 wxRect rect(rectOrig);
499
500 // Make the edit control large enough to allow for internal
501 // margins
502 //
503 // TODO: remove this if the text ctrl sizing is improved esp. for
504 // unix
505 //
506#if defined(__WXGTK__)
b0e282b3
RR
507 if (rect.x != 0)
508 {
509 rect.x += 1;
510 rect.y += 1;
511 rect.width -= 1;
512 rect.height -= 1;
513 }
99306db2 514#else // !GTK
cb105ad4
SN
515 int extra_x = ( rect.x > 2 )? 2 : 1;
516 int extra_y = ( rect.y > 2 )? 2 : 1;
99306db2 517#if defined(__WXMOTIF__)
cb105ad4
SN
518 extra_x *= 2;
519 extra_y *= 2;
99306db2 520#endif
cb105ad4
SN
521 rect.SetLeft( wxMax(0, rect.x - extra_x) );
522 rect.SetTop( wxMax(0, rect.y - extra_y) );
523 rect.SetRight( rect.GetRight() + 2*extra_x );
524 rect.SetBottom( rect.GetBottom() + 2*extra_y );
99306db2
VZ
525#endif // GTK/!GTK
526
527 wxGridCellEditor::SetSize(rect);
528}
529
3da93aae 530void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid* grid)
2796cce3
RD
531{
532 wxASSERT_MSG(m_control,
533 wxT("The wxGridCellEditor must be Created first!"));
534
535 m_startValue = grid->GetTable()->GetValue(row, col);
816be743
VZ
536
537 DoBeginEdit(m_startValue);
538}
539
540void wxGridCellTextEditor::DoBeginEdit(const wxString& startValue)
541{
542 Text()->SetValue(startValue);
b54ba671
VZ
543 Text()->SetInsertionPointEnd();
544 Text()->SetFocus();
2796cce3
RD
545}
546
3324d5f5 547bool wxGridCellTextEditor::EndEdit(int row, int col,
3da93aae 548 wxGrid* grid)
2796cce3
RD
549{
550 wxASSERT_MSG(m_control,
551 wxT("The wxGridCellEditor must be Created first!"));
552
553 bool changed = FALSE;
b54ba671 554 wxString value = Text()->GetValue();
2796cce3
RD
555 if (value != m_startValue)
556 changed = TRUE;
557
558 if (changed)
559 grid->GetTable()->SetValue(row, col, value);
2c9a89e0 560
3da93aae 561 m_startValue = wxEmptyString;
b54ba671 562 Text()->SetValue(m_startValue);
2796cce3
RD
563
564 return changed;
565}
566
567
568void wxGridCellTextEditor::Reset()
569{
570 wxASSERT_MSG(m_control,
571 wxT("The wxGridCellEditor must be Created first!"));
572
816be743
VZ
573 DoReset(m_startValue);
574}
575
576void wxGridCellTextEditor::DoReset(const wxString& startValue)
577{
578 Text()->SetValue(startValue);
b54ba671 579 Text()->SetInsertionPointEnd();
2796cce3
RD
580}
581
2c9a89e0
RD
582void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
583{
b54ba671
VZ
584 if ( !event.AltDown() && !event.MetaDown() && !event.ControlDown() )
585 {
586 // insert the key in the control
587 long keycode = event.KeyCode();
588 if ( isprint(keycode) )
589 {
590 // FIXME this is not going to work for non letters...
591 if ( !event.ShiftDown() )
592 {
593 keycode = tolower(keycode);
594 }
595
596 Text()->AppendText((wxChar)keycode);
597
598 return;
599 }
2c9a89e0 600
2c9a89e0 601 }
2c9a89e0 602
b54ba671
VZ
603 event.Skip();
604}
2c9a89e0 605
2796cce3
RD
606void wxGridCellTextEditor::HandleReturn(wxKeyEvent& event)
607{
608#if defined(__WXMOTIF__) || defined(__WXGTK__)
609 // wxMotif needs a little extra help...
b54ba671
VZ
610 int pos = Text()->GetInsertionPoint();
611 wxString s( Text()->GetValue() );
2796cce3 612 s = s.Left(pos) + "\n" + s.Mid(pos);
b54ba671
VZ
613 Text()->SetValue(s);
614 Text()->SetInsertionPoint( pos );
2796cce3
RD
615#else
616 // the other ports can handle a Return key press
617 //
618 event.Skip();
619#endif
620}
621
c4608a8a
VZ
622void wxGridCellTextEditor::SetParameters(const wxString& params)
623{
624 if ( !params )
625 {
626 // reset to default
627 m_maxChars = 0;
628 }
629 else
630 {
631 long tmp;
632 if ( !params.ToLong(&tmp) )
633 {
634 wxLogDebug(_T("Invalid wxGridCellTextEditor parameter string "
635 "'%s' ignored"), params.c_str());
636 }
637 else
638 {
639 m_maxChars = (size_t)tmp;
640 }
641 }
642}
643
816be743
VZ
644// ----------------------------------------------------------------------------
645// wxGridCellNumberEditor
646// ----------------------------------------------------------------------------
647
648wxGridCellNumberEditor::wxGridCellNumberEditor(int min, int max)
649{
650 m_min = min;
651 m_max = max;
652}
653
654void wxGridCellNumberEditor::Create(wxWindow* parent,
655 wxWindowID id,
656 wxEvtHandler* evtHandler)
657{
658 if ( HasRange() )
659 {
660 // create a spin ctrl
661 m_control = new wxSpinCtrl(parent, -1, wxEmptyString,
662 wxDefaultPosition, wxDefaultSize,
663 wxSP_ARROW_KEYS,
664 m_min, m_max);
665
666 wxGridCellEditor::Create(parent, id, evtHandler);
667 }
668 else
669 {
670 // just a text control
671 wxGridCellTextEditor::Create(parent, id, evtHandler);
672
673#if wxUSE_VALIDATORS
85bc0351 674 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
816be743
VZ
675#endif // wxUSE_VALIDATORS
676 }
677}
678
679void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid* grid)
680{
681 // first get the value
682 wxGridTableBase *table = grid->GetTable();
683 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
684 {
685 m_valueOld = table->GetValueAsLong(row, col);
686 }
687 else
688 {
a5777624
RD
689 wxString sValue = table->GetValue(row, col);
690 if (! sValue.ToLong(&m_valueOld))
691 {
692 wxFAIL_MSG( _T("this cell doesn't have numeric value") );
693 return;
694 }
816be743
VZ
695 }
696
697 if ( HasRange() )
698 {
699 Spin()->SetValue(m_valueOld);
700 }
701 else
702 {
703 DoBeginEdit(GetString());
704 }
705}
706
3324d5f5 707bool wxGridCellNumberEditor::EndEdit(int row, int col,
816be743
VZ
708 wxGrid* grid)
709{
710 bool changed;
711 long value;
712
713 if ( HasRange() )
714 {
715 value = Spin()->GetValue();
716 changed = value != m_valueOld;
717 }
718 else
719 {
720 changed = Text()->GetValue().ToLong(&value) && (value != m_valueOld);
721 }
722
723 if ( changed )
724 {
a5777624
RD
725 if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER))
726 grid->GetTable()->SetValueAsLong(row, col, value);
727 else
728 grid->GetTable()->SetValue(row, col, wxString::Format("%ld", value));
816be743
VZ
729 }
730
731 return changed;
732}
733
734void wxGridCellNumberEditor::Reset()
735{
736 if ( HasRange() )
737 {
738 Spin()->SetValue(m_valueOld);
739 }
740 else
741 {
742 DoReset(GetString());
743 }
744}
745
746void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
747{
748 if ( !HasRange() )
749 {
750 long keycode = event.KeyCode();
751 if ( isdigit(keycode) || keycode == '+' || keycode == '-' )
752 {
753 wxGridCellTextEditor::StartingKey(event);
754
755 // skip Skip() below
756 return;
757 }
758 }
759
760 event.Skip();
761}
9c4ba614 762
c4608a8a
VZ
763void wxGridCellNumberEditor::SetParameters(const wxString& params)
764{
765 if ( !params )
766 {
767 // reset to default
768 m_min =
769 m_max = -1;
770 }
771 else
772 {
773 long tmp;
774 if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
775 {
776 m_min = (int)tmp;
777
778 if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
779 {
780 m_max = (int)tmp;
781
782 // skip the error message below
783 return;
784 }
785 }
786
787 wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string "
788 "'%s' ignored"), params.c_str());
789 }
790}
791
816be743
VZ
792// ----------------------------------------------------------------------------
793// wxGridCellFloatEditor
794// ----------------------------------------------------------------------------
795
796void wxGridCellFloatEditor::Create(wxWindow* parent,
797 wxWindowID id,
798 wxEvtHandler* evtHandler)
799{
800 wxGridCellTextEditor::Create(parent, id, evtHandler);
801
802#if wxUSE_VALIDATORS
85bc0351 803 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
816be743
VZ
804#endif // wxUSE_VALIDATORS
805}
806
807void wxGridCellFloatEditor::BeginEdit(int row, int col, wxGrid* grid)
808{
809 // first get the value
810 wxGridTableBase *table = grid->GetTable();
811 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
812 {
813 m_valueOld = table->GetValueAsDouble(row, col);
814 }
815 else
816 {
a5777624
RD
817 wxString sValue = table->GetValue(row, col);
818 if (! sValue.ToDouble(&m_valueOld))
819 {
820 wxFAIL_MSG( _T("this cell doesn't have float value") );
821 return;
822 }
816be743
VZ
823 }
824
825 DoBeginEdit(GetString());
826}
827
3324d5f5 828bool wxGridCellFloatEditor::EndEdit(int row, int col,
816be743
VZ
829 wxGrid* grid)
830{
831 double value;
832 if ( Text()->GetValue().ToDouble(&value) && (value != m_valueOld) )
833 {
a5777624
RD
834 if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT))
835 grid->GetTable()->SetValueAsDouble(row, col, value);
836 else
837 grid->GetTable()->SetValue(row, col, wxString::Format("%f", value));
816be743
VZ
838
839 return TRUE;
840 }
841 else
842 {
843 return FALSE;
844 }
845}
846
847void wxGridCellFloatEditor::Reset()
848{
849 DoReset(GetString());
850}
851
852void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
853{
854 long keycode = event.KeyCode();
855 if ( isdigit(keycode) ||
856 keycode == '+' || keycode == '-' || keycode == '.' )
857 {
858 wxGridCellTextEditor::StartingKey(event);
859
860 // skip Skip() below
861 return;
862 }
863
864 event.Skip();
865}
866
508011ce
VZ
867// ----------------------------------------------------------------------------
868// wxGridCellBoolEditor
869// ----------------------------------------------------------------------------
870
871void wxGridCellBoolEditor::Create(wxWindow* parent,
872 wxWindowID id,
873 wxEvtHandler* evtHandler)
874{
875 m_control = new wxCheckBox(parent, id, wxEmptyString,
876 wxDefaultPosition, wxDefaultSize,
877 wxNO_BORDER);
878
879 wxGridCellEditor::Create(parent, id, evtHandler);
880}
881
882void wxGridCellBoolEditor::SetSize(const wxRect& r)
883{
b94ae1ea
VZ
884 bool resize = FALSE;
885 wxSize size = m_control->GetSize();
886 wxCoord minSize = wxMin(r.width, r.height);
887
888 // check if the checkbox is not too big/small for this cell
889 wxSize sizeBest = m_control->GetBestSize();
890 if ( !(size == sizeBest) )
891 {
892 // reset to default size if it had been made smaller
893 size = sizeBest;
894
895 resize = TRUE;
896 }
897
898 if ( size.x >= minSize || size.y >= minSize )
899 {
900 // leave 1 pixel margin
901 size.x = size.y = minSize - 2;
902
903 resize = TRUE;
904 }
905
906 if ( resize )
907 {
908 m_control->SetSize(size);
909 }
910
508011ce 911 // position it in the centre of the rectangle (TODO: support alignment?)
508011ce 912
b94ae1ea 913#if defined(__WXGTK__) || defined (__WXMOTIF__)
508011ce
VZ
914 // the checkbox without label still has some space to the right in wxGTK,
915 // so shift it to the right
b94ae1ea
VZ
916 size.x -= 8;
917#elif defined(__WXMSW__)
a95e38c0
VZ
918 // here too, but in other way
919 size.x += 1;
b94ae1ea
VZ
920 size.y -= 2;
921#endif
508011ce 922
b94ae1ea 923 m_control->Move(r.x + r.width/2 - size.x/2, r.y + r.height/2 - size.y/2);
508011ce
VZ
924}
925
926void wxGridCellBoolEditor::Show(bool show, wxGridCellAttr *attr)
927{
99306db2
VZ
928 m_control->Show(show);
929
189d0213 930 if ( show )
508011ce 931 {
189d0213
VZ
932 wxColour colBg = attr ? attr->GetBackgroundColour() : *wxLIGHT_GREY;
933 CBox()->SetBackgroundColour(colBg);
508011ce 934 }
508011ce
VZ
935}
936
937void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
938{
939 wxASSERT_MSG(m_control,
940 wxT("The wxGridCellEditor must be Created first!"));
941
28a77bc4 942 if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
f2d76237
RD
943 m_startValue = grid->GetTable()->GetValueAsBool(row, col);
944 else
945 m_startValue = !!grid->GetTable()->GetValue(row, col);
508011ce
VZ
946 CBox()->SetValue(m_startValue);
947 CBox()->SetFocus();
948}
949
950bool wxGridCellBoolEditor::EndEdit(int row, int col,
508011ce
VZ
951 wxGrid* grid)
952{
953 wxASSERT_MSG(m_control,
954 wxT("The wxGridCellEditor must be Created first!"));
955
956 bool changed = FALSE;
957 bool value = CBox()->GetValue();
958 if ( value != m_startValue )
959 changed = TRUE;
960
961 if ( changed )
962 {
28a77bc4 963 if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
f2d76237
RD
964 grid->GetTable()->SetValueAsBool(row, col, value);
965 else
966 grid->GetTable()->SetValue(row, col, value ? _T("1") : wxEmptyString);
508011ce
VZ
967 }
968
969 return changed;
970}
971
972void wxGridCellBoolEditor::Reset()
973{
974 wxASSERT_MSG(m_control,
975 wxT("The wxGridCellEditor must be Created first!"));
976
977 CBox()->SetValue(m_startValue);
978}
979
e195a54c 980void wxGridCellBoolEditor::StartingClick()
508011ce 981{
e195a54c 982 CBox()->SetValue(!CBox()->GetValue());
508011ce
VZ
983}
984
4ee5fc9c
VZ
985// ----------------------------------------------------------------------------
986// wxGridCellChoiceEditor
987// ----------------------------------------------------------------------------
988
989wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count,
990 const wxChar* choices[],
991 bool allowOthers)
992 : m_allowOthers(allowOthers)
993{
c4608a8a 994 if ( count )
4ee5fc9c 995 {
c4608a8a
VZ
996 m_choices.Alloc(count);
997 for ( size_t n = 0; n < count; n++ )
998 {
999 m_choices.Add(choices[n]);
1000 }
4ee5fc9c
VZ
1001 }
1002}
1003
c4608a8a
VZ
1004wxGridCellEditor *wxGridCellChoiceEditor::Clone() const
1005{
1006 wxGridCellChoiceEditor *editor = new wxGridCellChoiceEditor;
1007 editor->m_allowOthers = m_allowOthers;
1008 editor->m_choices = m_choices;
1009
1010 return editor;
1011}
1012
4ee5fc9c
VZ
1013void wxGridCellChoiceEditor::Create(wxWindow* parent,
1014 wxWindowID id,
1015 wxEvtHandler* evtHandler)
1016{
1017 size_t count = m_choices.GetCount();
1018 wxString *choices = new wxString[count];
1019 for ( size_t n = 0; n < count; n++ )
1020 {
1021 choices[n] = m_choices[n];
1022 }
1023
1024 m_control = new wxComboBox(parent, id, wxEmptyString,
1025 wxDefaultPosition, wxDefaultSize,
1026 count, choices,
1027 m_allowOthers ? 0 : wxCB_READONLY);
1028
1029 delete [] choices;
1030
1031 wxGridCellEditor::Create(parent, id, evtHandler);
1032}
1033
a5777624
RD
1034void wxGridCellChoiceEditor::PaintBackground(const wxRect& rectCell,
1035 wxGridCellAttr * attr)
4ee5fc9c
VZ
1036{
1037 // as we fill the entire client area, don't do anything here to minimize
1038 // flicker
a5777624
RD
1039
1040 // TODO: It doesn't actually fill the client area since the height of a
1041 // combo always defaults to the standard... Until someone has time to
1042 // figure out the right rectangle to paint, just do it the normal way...
1043 wxGridCellEditor::PaintBackground(rectCell, attr);
4ee5fc9c
VZ
1044}
1045
1046void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid* grid)
1047{
1048 wxASSERT_MSG(m_control,
1049 wxT("The wxGridCellEditor must be Created first!"));
1050
1051 m_startValue = grid->GetTable()->GetValue(row, col);
1052
1053 Combo()->SetValue(m_startValue);
28a77bc4
RD
1054 size_t count = m_choices.GetCount();
1055 for (size_t i=0; i<count; i++)
1056 {
1057 if (m_startValue == m_choices[i])
1058 {
1059 Combo()->SetSelection(i);
1060 break;
1061 }
1062 }
4ee5fc9c
VZ
1063 Combo()->SetInsertionPointEnd();
1064 Combo()->SetFocus();
1065}
1066
28a77bc4 1067bool wxGridCellChoiceEditor::EndEdit(int row, int col,
4ee5fc9c
VZ
1068 wxGrid* grid)
1069{
1070 wxString value = Combo()->GetValue();
1071 bool changed = value != m_startValue;
1072
1073 if ( changed )
1074 grid->GetTable()->SetValue(row, col, value);
1075
1076 m_startValue = wxEmptyString;
1077 Combo()->SetValue(m_startValue);
1078
1079 return changed;
1080}
1081
1082void wxGridCellChoiceEditor::Reset()
1083{
1084 Combo()->SetValue(m_startValue);
1085 Combo()->SetInsertionPointEnd();
1086}
1087
c4608a8a
VZ
1088void wxGridCellChoiceEditor::SetParameters(const wxString& params)
1089{
1090 if ( !params )
1091 {
1092 // what can we do?
1093 return;
1094 }
1095
1096 m_choices.Empty();
1097
1098 wxStringTokenizer tk(params, _T(','));
1099 while ( tk.HasMoreTokens() )
1100 {
1101 m_choices.Add(tk.GetNextToken());
1102 }
1103}
1104
508011ce
VZ
1105// ----------------------------------------------------------------------------
1106// wxGridCellEditorEvtHandler
1107// ----------------------------------------------------------------------------
2796cce3
RD
1108
1109void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
1110{
1111 switch ( event.KeyCode() )
1112 {
1113 case WXK_ESCAPE:
1114 m_editor->Reset();
b54ba671 1115 m_grid->DisableCellEditControl();
2796cce3
RD
1116 break;
1117
2c9a89e0 1118 case WXK_TAB:
9b4aede2
RD
1119 event.Skip( m_grid->ProcessEvent( event ) );
1120 break;
1121
2796cce3
RD
1122 case WXK_RETURN:
1123 if (!m_grid->ProcessEvent(event))
1124 m_editor->HandleReturn(event);
1125 break;
1126
2796cce3
RD
1127
1128 default:
1129 event.Skip();
1130 }
1131}
1132
fb0de762
RD
1133void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
1134{
1135 switch ( event.KeyCode() )
1136 {
1137 case WXK_ESCAPE:
1138 case WXK_TAB:
1139 case WXK_RETURN:
1140 break;
1141
1142 default:
1143 event.Skip();
1144 }
1145}
1146
c4608a8a
VZ
1147// ----------------------------------------------------------------------------
1148// wxGridCellWorker is an (almost) empty common base class for
1149// wxGridCellRenderer and wxGridCellEditor managing ref counting
1150// ----------------------------------------------------------------------------
1151
1152void wxGridCellWorker::SetParameters(const wxString& WXUNUSED(params))
1153{
1154 // nothing to do
1155}
1156
1157wxGridCellWorker::~wxGridCellWorker()
1158{
1159}
1160
508011ce
VZ
1161// ============================================================================
1162// renderer classes
1163// ============================================================================
1164
ab79958a
VZ
1165// ----------------------------------------------------------------------------
1166// wxGridCellRenderer
1167// ----------------------------------------------------------------------------
1168
1169void wxGridCellRenderer::Draw(wxGrid& grid,
2796cce3 1170 wxGridCellAttr& attr,
ab79958a
VZ
1171 wxDC& dc,
1172 const wxRect& rect,
1173 int row, int col,
1174 bool isSelected)
1175{
1176 dc.SetBackgroundMode( wxSOLID );
1177
1178 if ( isSelected )
1179 {
2796cce3 1180 dc.SetBrush( wxBrush(grid.GetSelectionBackground(), wxSOLID) );
ab79958a
VZ
1181 }
1182 else
1183 {
2796cce3 1184 dc.SetBrush( wxBrush(attr.GetBackgroundColour(), wxSOLID) );
ab79958a
VZ
1185 }
1186
1187 dc.SetPen( *wxTRANSPARENT_PEN );
ab79958a
VZ
1188 dc.DrawRectangle(rect);
1189}
1190
508011ce
VZ
1191// ----------------------------------------------------------------------------
1192// wxGridCellStringRenderer
1193// ----------------------------------------------------------------------------
1194
816be743
VZ
1195void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid& grid,
1196 wxGridCellAttr& attr,
1197 wxDC& dc,
1198 bool isSelected)
ab79958a 1199{
ab79958a
VZ
1200 dc.SetBackgroundMode( wxTRANSPARENT );
1201
283b7808
VZ
1202 // TODO some special colours for attr.IsReadOnly() case?
1203
ab79958a
VZ
1204 if ( isSelected )
1205 {
2796cce3
RD
1206 dc.SetTextBackground( grid.GetSelectionBackground() );
1207 dc.SetTextForeground( grid.GetSelectionForeground() );
ab79958a
VZ
1208 }
1209 else
1210 {
2796cce3
RD
1211 dc.SetTextBackground( attr.GetBackgroundColour() );
1212 dc.SetTextForeground( attr.GetTextColour() );
ab79958a 1213 }
816be743 1214
2796cce3 1215 dc.SetFont( attr.GetFont() );
816be743
VZ
1216}
1217
65e4e78e
VZ
1218wxSize wxGridCellStringRenderer::DoGetBestSize(wxGridCellAttr& attr,
1219 wxDC& dc,
1220 const wxString& text)
1221{
1222 wxCoord x, y;
1223 dc.SetFont(attr.GetFont());
1224 dc.GetTextExtent(text, &x, &y);
1225
1226 return wxSize(x, y);
1227}
1228
1229wxSize wxGridCellStringRenderer::GetBestSize(wxGrid& grid,
1230 wxGridCellAttr& attr,
1231 wxDC& dc,
1232 int row, int col)
1233{
1234 return DoGetBestSize(attr, dc, grid.GetCellValue(row, col));
1235}
1236
816be743
VZ
1237void wxGridCellStringRenderer::Draw(wxGrid& grid,
1238 wxGridCellAttr& attr,
1239 wxDC& dc,
1240 const wxRect& rectCell,
1241 int row, int col,
1242 bool isSelected)
1243{
1244 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1245
1246 // now we only have to draw the text
1247 SetTextColoursAndFont(grid, attr, dc, isSelected);
ab79958a
VZ
1248
1249 int hAlign, vAlign;
2796cce3 1250 attr.GetAlignment(&hAlign, &vAlign);
ab79958a
VZ
1251
1252 wxRect rect = rectCell;
816be743 1253 rect.Inflate(-1);
ab79958a
VZ
1254
1255 grid.DrawTextRectangle(dc, grid.GetCellValue(row, col),
1256 rect, hAlign, vAlign);
1257}
1258
65e4e78e
VZ
1259// ----------------------------------------------------------------------------
1260// wxGridCellNumberRenderer
1261// ----------------------------------------------------------------------------
1262
1263wxString wxGridCellNumberRenderer::GetString(wxGrid& grid, int row, int col)
1264{
1265 wxGridTableBase *table = grid.GetTable();
1266 wxString text;
1267 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
1268 {
1269 text.Printf(_T("%ld"), table->GetValueAsLong(row, col));
1270 }
9c4ba614
VZ
1271 else
1272 {
1273 text = table->GetValue(row, col);
1274 }
65e4e78e
VZ
1275
1276 return text;
1277}
1278
816be743
VZ
1279void wxGridCellNumberRenderer::Draw(wxGrid& grid,
1280 wxGridCellAttr& attr,
1281 wxDC& dc,
1282 const wxRect& rectCell,
1283 int row, int col,
1284 bool isSelected)
1285{
1286 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1287
1288 SetTextColoursAndFont(grid, attr, dc, isSelected);
1289
1290 // draw the text right aligned by default
1291 int hAlign, vAlign;
1292 attr.GetAlignment(&hAlign, &vAlign);
1293 hAlign = wxRIGHT;
1294
1295 wxRect rect = rectCell;
1296 rect.Inflate(-1);
1297
65e4e78e
VZ
1298 grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
1299}
816be743 1300
65e4e78e
VZ
1301wxSize wxGridCellNumberRenderer::GetBestSize(wxGrid& grid,
1302 wxGridCellAttr& attr,
1303 wxDC& dc,
1304 int row, int col)
1305{
1306 return DoGetBestSize(attr, dc, GetString(grid, row, col));
816be743
VZ
1307}
1308
1309// ----------------------------------------------------------------------------
1310// wxGridCellFloatRenderer
1311// ----------------------------------------------------------------------------
1312
1313wxGridCellFloatRenderer::wxGridCellFloatRenderer(int width, int precision)
1314{
1315 SetWidth(width);
1316 SetPrecision(precision);
1317}
1318
e72b4213
VZ
1319wxGridCellRenderer *wxGridCellFloatRenderer::Clone() const
1320{
1321 wxGridCellFloatRenderer *renderer = new wxGridCellFloatRenderer;
1322 renderer->m_width = m_width;
1323 renderer->m_precision = m_precision;
1324 renderer->m_format = m_format;
1325
1326 return renderer;
1327}
1328
65e4e78e
VZ
1329wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
1330{
1331 wxGridTableBase *table = grid.GetTable();
0b190b0f
VZ
1332
1333 bool hasDouble;
1334 double val;
65e4e78e
VZ
1335 wxString text;
1336 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
1337 {
0b190b0f
VZ
1338 val = table->GetValueAsDouble(row, col);
1339 hasDouble = TRUE;
65e4e78e 1340 }
9c4ba614
VZ
1341 else
1342 {
1343 text = table->GetValue(row, col);
0b190b0f 1344 hasDouble = text.ToDouble(&val);
9c4ba614 1345 }
65e4e78e 1346
0b190b0f
VZ
1347 if ( hasDouble )
1348 {
1349 if ( !m_format )
1350 {
1351 if ( m_width == -1 )
1352 {
1353 // default width/precision
1354 m_format = _T("%f");
1355 }
1356 else if ( m_precision == -1 )
1357 {
1358 // default precision
1359 m_format.Printf(_T("%%%d.f"), m_width);
1360 }
1361 else
1362 {
1363 m_format.Printf(_T("%%%d.%df"), m_width, m_precision);
1364 }
1365 }
1366
1367 text.Printf(m_format, val);
1368 }
1369 //else: text already contains the string
1370
65e4e78e
VZ
1371 return text;
1372}
1373
816be743
VZ
1374void wxGridCellFloatRenderer::Draw(wxGrid& grid,
1375 wxGridCellAttr& attr,
1376 wxDC& dc,
1377 const wxRect& rectCell,
1378 int row, int col,
1379 bool isSelected)
1380{
1381 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1382
1383 SetTextColoursAndFont(grid, attr, dc, isSelected);
1384
1385 // draw the text right aligned by default
1386 int hAlign, vAlign;
1387 attr.GetAlignment(&hAlign, &vAlign);
1388 hAlign = wxRIGHT;
1389
1390 wxRect rect = rectCell;
1391 rect.Inflate(-1);
1392
65e4e78e
VZ
1393 grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
1394}
816be743 1395
65e4e78e
VZ
1396wxSize wxGridCellFloatRenderer::GetBestSize(wxGrid& grid,
1397 wxGridCellAttr& attr,
1398 wxDC& dc,
1399 int row, int col)
1400{
1401 return DoGetBestSize(attr, dc, GetString(grid, row, col));
816be743
VZ
1402}
1403
0b190b0f
VZ
1404void wxGridCellFloatRenderer::SetParameters(const wxString& params)
1405{
1406 bool ok = TRUE;
1407
1408 if ( !params )
1409 {
1410 // reset to defaults
1411 SetWidth(-1);
1412 SetPrecision(-1);
1413 }
1414 else
1415 {
1416 wxString tmp = params.BeforeFirst(_T(','));
1417 if ( !!tmp )
1418 {
1419 long width;
1420 if ( !tmp.ToLong(&width) )
1421 {
1422 ok = FALSE;
1423 }
1424 else
1425 {
1426 SetWidth((int)width);
1427
1428 tmp = params.AfterFirst(_T(','));
1429 if ( !!tmp )
1430 {
1431 long precision;
1432 if ( !tmp.ToLong(&precision) )
1433 {
1434 ok = FALSE;
1435 }
1436 else
1437 {
1438 SetPrecision((int)precision);
1439 }
1440 }
1441 }
1442 }
1443
1444 if ( !ok )
1445 {
1446 wxLogDebug(_T("Invalid wxGridCellFloatRenderer parameter string "
1447 "'%s ignored"), params.c_str());
1448 }
1449 }
1450}
1451
508011ce
VZ
1452// ----------------------------------------------------------------------------
1453// wxGridCellBoolRenderer
1454// ----------------------------------------------------------------------------
1455
65e4e78e 1456wxSize wxGridCellBoolRenderer::ms_sizeCheckMark;
508011ce 1457
b94ae1ea
VZ
1458// FIXME these checkbox size calculations are really ugly...
1459
65e4e78e 1460// between checkmark and box
a95e38c0 1461static const wxCoord wxGRID_CHECKMARK_MARGIN = 2;
508011ce 1462
65e4e78e
VZ
1463wxSize wxGridCellBoolRenderer::GetBestSize(wxGrid& grid,
1464 wxGridCellAttr& WXUNUSED(attr),
1465 wxDC& WXUNUSED(dc),
1466 int WXUNUSED(row),
1467 int WXUNUSED(col))
1468{
1469 // compute it only once (no locks for MT safeness in GUI thread...)
1470 if ( !ms_sizeCheckMark.x )
297da4ba 1471 {
65e4e78e
VZ
1472 // get checkbox size
1473 wxCoord checkSize = 0;
297da4ba
VZ
1474 wxCheckBox *checkbox = new wxCheckBox(&grid, -1, wxEmptyString);
1475 wxSize size = checkbox->GetBestSize();
a95e38c0 1476 checkSize = size.y + 2*wxGRID_CHECKMARK_MARGIN;
297da4ba 1477
65e4e78e 1478 // FIXME wxGTK::wxCheckBox::GetBestSize() gives "wrong" result
69d8f612 1479#if defined(__WXGTK__) || defined(__WXMOTIF__)
65e4e78e 1480 checkSize -= size.y / 2;
297da4ba
VZ
1481#endif
1482
1483 delete checkbox;
65e4e78e
VZ
1484
1485 ms_sizeCheckMark.x = ms_sizeCheckMark.y = checkSize;
297da4ba
VZ
1486 }
1487
65e4e78e
VZ
1488 return ms_sizeCheckMark;
1489}
1490
1491void wxGridCellBoolRenderer::Draw(wxGrid& grid,
1492 wxGridCellAttr& attr,
1493 wxDC& dc,
1494 const wxRect& rect,
1495 int row, int col,
1496 bool isSelected)
1497{
1498 wxGridCellRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
1499
297da4ba 1500 // draw a check mark in the centre (ignoring alignment - TODO)
65e4e78e 1501 wxSize size = GetBestSize(grid, attr, dc, row, col);
b94ae1ea
VZ
1502
1503 // don't draw outside the cell
1504 wxCoord minSize = wxMin(rect.width, rect.height);
1505 if ( size.x >= minSize || size.y >= minSize )
1506 {
1507 // and even leave (at least) 1 pixel margin
1508 size.x = size.y = minSize - 2;
1509 }
1510
1511 // draw a border around checkmark
a95e38c0
VZ
1512 wxRect rectBorder;
1513 rectBorder.x = rect.x + rect.width/2 - size.x/2;
1514 rectBorder.y = rect.y + rect.height/2 - size.y/2;
1515 rectBorder.width = size.x;
1516 rectBorder.height = size.y;
b94ae1ea 1517
f2d76237 1518 bool value;
b94ae1ea 1519 if ( grid.GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
f2d76237
RD
1520 value = grid.GetTable()->GetValueAsBool(row, col);
1521 else
1522 value = !!grid.GetTable()->GetValue(row, col);
1523
1524 if ( value )
508011ce 1525 {
a95e38c0
VZ
1526 wxRect rectMark = rectBorder;
1527#ifdef __WXMSW__
1528 // MSW DrawCheckMark() is weird (and should probably be changed...)
1529 rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN/2);
1530 rectMark.x++;
1531 rectMark.y++;
1532#else // !MSW
1533 rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN);
1534#endif // MSW/!MSW
1535
508011ce
VZ
1536 dc.SetTextForeground(attr.GetTextColour());
1537 dc.DrawCheckMark(rectMark);
1538 }
a95e38c0
VZ
1539
1540 dc.SetBrush(*wxTRANSPARENT_BRUSH);
1541 dc.SetPen(wxPen(attr.GetTextColour(), 1, wxSOLID));
1542 dc.DrawRectangle(rectBorder);
508011ce
VZ
1543}
1544
2796cce3
RD
1545// ----------------------------------------------------------------------------
1546// wxGridCellAttr
1547// ----------------------------------------------------------------------------
1548
39bcce60 1549wxGridCellAttr *wxGridCellAttr::Clone() const
a68c1246
VZ
1550{
1551 wxGridCellAttr *attr = new wxGridCellAttr;
1552 if ( HasTextColour() )
1553 attr->SetTextColour(GetTextColour());
1554 if ( HasBackgroundColour() )
1555 attr->SetBackgroundColour(GetBackgroundColour());
1556 if ( HasFont() )
1557 attr->SetFont(GetFont());
1558 if ( HasAlignment() )
1559 attr->SetAlignment(m_hAlign, m_vAlign);
1560
1561 if ( m_renderer )
1562 {
1563 attr->SetRenderer(m_renderer);
39bcce60 1564 m_renderer->IncRef();
a68c1246
VZ
1565 }
1566 if ( m_editor )
1567 {
1568 attr->SetEditor(m_editor);
39bcce60 1569 m_editor->IncRef();
a68c1246
VZ
1570 }
1571
1572 if ( IsReadOnly() )
1573 attr->SetReadOnly();
1574
1575 attr->SetDefAttr(m_defGridAttr);
1576
1577 return attr;
1578}
1579
2796cce3
RD
1580const wxColour& wxGridCellAttr::GetTextColour() const
1581{
1582 if (HasTextColour())
508011ce 1583 {
2796cce3 1584 return m_colText;
508011ce 1585 }
2796cce3 1586 else if (m_defGridAttr != this)
508011ce 1587 {
2796cce3 1588 return m_defGridAttr->GetTextColour();
508011ce
VZ
1589 }
1590 else
1591 {
2796cce3
RD
1592 wxFAIL_MSG(wxT("Missing default cell attribute"));
1593 return wxNullColour;
1594 }
1595}
1596
1597
1598const wxColour& wxGridCellAttr::GetBackgroundColour() const
1599{
1600 if (HasBackgroundColour())
1601 return m_colBack;
1602 else if (m_defGridAttr != this)
1603 return m_defGridAttr->GetBackgroundColour();
508011ce
VZ
1604 else
1605 {
2796cce3
RD
1606 wxFAIL_MSG(wxT("Missing default cell attribute"));
1607 return wxNullColour;
1608 }
1609}
1610
1611
1612const wxFont& wxGridCellAttr::GetFont() const
1613{
1614 if (HasFont())
1615 return m_font;
1616 else if (m_defGridAttr != this)
1617 return m_defGridAttr->GetFont();
508011ce
VZ
1618 else
1619 {
2796cce3
RD
1620 wxFAIL_MSG(wxT("Missing default cell attribute"));
1621 return wxNullFont;
1622 }
1623}
1624
1625
1626void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
1627{
508011ce
VZ
1628 if (HasAlignment())
1629 {
2796cce3
RD
1630 if ( hAlign ) *hAlign = m_hAlign;
1631 if ( vAlign ) *vAlign = m_vAlign;
1632 }
1633 else if (m_defGridAttr != this)
1634 m_defGridAttr->GetAlignment(hAlign, vAlign);
508011ce
VZ
1635 else
1636 {
2796cce3
RD
1637 wxFAIL_MSG(wxT("Missing default cell attribute"));
1638 }
1639}
1640
1641
f2d76237 1642// GetRenderer and GetEditor use a slightly different decision path about
28a77bc4
RD
1643// which attribute to use. If a non-default attr object has one then it is
1644// used, otherwise the default editor or renderer is fetched from the grid and
1645// used. It should be the default for the data type of the cell. If it is
1646// NULL (because the table has a type that the grid does not have in its
1647// registry,) then the grid's default editor or renderer is used.
1648
1649wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col) const
1650{
28a77bc4 1651 wxGridCellRenderer* renderer = NULL;
28a77bc4 1652
0b190b0f
VZ
1653 if ( m_defGridAttr != this || grid == NULL )
1654 {
1655 renderer = m_renderer; // use local attribute
1656 if ( renderer )
1657 renderer->IncRef();
1658 }
1659
1660 if ( !renderer && grid ) // get renderer for the data type
1661 {
1662 // GetDefaultRendererForCell() will do IncRef() for us
1663 renderer = grid->GetDefaultRendererForCell(row, col);
1664 }
1665
1666 if ( !renderer )
1667 {
28a77bc4 1668 // if we still don't have one then use the grid default
0b190b0f 1669 // (no need for IncRef() here neither)
28a77bc4 1670 renderer = m_defGridAttr->GetRenderer(NULL,0,0);
0b190b0f 1671 }
28a77bc4 1672
0b190b0f
VZ
1673 if ( !renderer)
1674 {
2796cce3 1675 wxFAIL_MSG(wxT("Missing default cell attribute"));
0b190b0f 1676 }
28a77bc4
RD
1677
1678 return renderer;
2796cce3
RD
1679}
1680
28a77bc4 1681wxGridCellEditor* wxGridCellAttr::GetEditor(wxGrid* grid, int row, int col) const
07296f0b 1682{
28a77bc4 1683 wxGridCellEditor* editor = NULL;
0b190b0f
VZ
1684
1685 if ( m_defGridAttr != this || grid == NULL )
1686 {
1687 editor = m_editor; // use local attribute
1688 if ( editor )
1689 editor->IncRef();
1690 }
1691
a95e38c0
VZ
1692 if ( !editor && grid ) // get renderer for the data type
1693 editor = grid->GetDefaultEditorForCell(row, col);
28a77bc4 1694
0b190b0f 1695 if ( !editor )
28a77bc4
RD
1696 // if we still don't have one then use the grid default
1697 editor = m_defGridAttr->GetEditor(NULL,0,0);
1698
0b190b0f
VZ
1699 if ( !editor )
1700 {
07296f0b 1701 wxFAIL_MSG(wxT("Missing default cell attribute"));
0b190b0f 1702 }
28a77bc4
RD
1703
1704 return editor;
07296f0b
RD
1705}
1706
b99be8fb 1707// ----------------------------------------------------------------------------
758cbedf 1708// wxGridCellAttrData
b99be8fb
VZ
1709// ----------------------------------------------------------------------------
1710
758cbedf 1711void wxGridCellAttrData::SetAttr(wxGridCellAttr *attr, int row, int col)
b99be8fb
VZ
1712{
1713 int n = FindIndex(row, col);
1714 if ( n == wxNOT_FOUND )
1715 {
1716 // add the attribute
1717 m_attrs.Add(new wxGridCellWithAttr(row, col, attr));
1718 }
1719 else
1720 {
1721 if ( attr )
1722 {
1723 // change the attribute
2e9a6788 1724 m_attrs[(size_t)n].attr = attr;
b99be8fb
VZ
1725 }
1726 else
1727 {
1728 // remove this attribute
1729 m_attrs.RemoveAt((size_t)n);
1730 }
1731 }
b99be8fb
VZ
1732}
1733
758cbedf 1734wxGridCellAttr *wxGridCellAttrData::GetAttr(int row, int col) const
b99be8fb
VZ
1735{
1736 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
1737
1738 int n = FindIndex(row, col);
1739 if ( n != wxNOT_FOUND )
1740 {
2e9a6788
VZ
1741 attr = m_attrs[(size_t)n].attr;
1742 attr->IncRef();
b99be8fb
VZ
1743 }
1744
1745 return attr;
1746}
1747
4d60017a
SN
1748void wxGridCellAttrData::UpdateAttrRows( size_t pos, int numRows )
1749{
1750 size_t count = m_attrs.GetCount();
1751 for ( size_t n = 0; n < count; n++ )
1752 {
1753 wxGridCellCoords& coords = m_attrs[n].coords;
d1c0b4f9
VZ
1754 wxCoord row = coords.GetRow();
1755 if ((size_t)row >= pos)
1756 {
1757 if (numRows > 0)
1758 {
1759 // If rows inserted, include row counter where necessary
1760 coords.SetRow(row + numRows);
1761 }
1762 else if (numRows < 0)
1763 {
1764 // If rows deleted ...
1765 if ((size_t)row >= pos - numRows)
1766 {
1767 // ...either decrement row counter (if row still exists)...
1768 coords.SetRow(row + numRows);
1769 }
1770 else
1771 {
1772 // ...or remove the attribute
1773 m_attrs.RemoveAt((size_t)n);
1774 n--; count--;
1775 }
1776 }
4d60017a
SN
1777 }
1778 }
1779}
1780
1781void wxGridCellAttrData::UpdateAttrCols( size_t pos, int numCols )
1782{
1783 size_t count = m_attrs.GetCount();
1784 for ( size_t n = 0; n < count; n++ )
1785 {
1786 wxGridCellCoords& coords = m_attrs[n].coords;
d1c0b4f9
VZ
1787 wxCoord col = coords.GetCol();
1788 if ( (size_t)col >= pos )
1789 {
1790 if ( numCols > 0 )
1791 {
1792 // If rows inserted, include row counter where necessary
1793 coords.SetCol(col + numCols);
1794 }
1795 else if (numCols < 0)
1796 {
1797 // If rows deleted ...
1798 if ((size_t)col >= pos - numCols)
1799 {
1800 // ...either decrement row counter (if row still exists)...
1801 coords.SetCol(col + numCols);
1802 }
1803 else
1804 {
1805 // ...or remove the attribute
1806 m_attrs.RemoveAt((size_t)n);
1807 n--; count--;
1808 }
1809 }
4d60017a
SN
1810 }
1811 }
1812}
1813
758cbedf 1814int wxGridCellAttrData::FindIndex(int row, int col) const
b99be8fb
VZ
1815{
1816 size_t count = m_attrs.GetCount();
1817 for ( size_t n = 0; n < count; n++ )
1818 {
1819 const wxGridCellCoords& coords = m_attrs[n].coords;
1820 if ( (coords.GetRow() == row) && (coords.GetCol() == col) )
1821 {
1822 return n;
1823 }
1824 }
1825
1826 return wxNOT_FOUND;
1827}
1828
758cbedf
VZ
1829// ----------------------------------------------------------------------------
1830// wxGridRowOrColAttrData
1831// ----------------------------------------------------------------------------
1832
1833wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
1834{
1835 size_t count = m_attrs.Count();
1836 for ( size_t n = 0; n < count; n++ )
1837 {
1838 m_attrs[n]->DecRef();
1839 }
1840}
1841
1842wxGridCellAttr *wxGridRowOrColAttrData::GetAttr(int rowOrCol) const
1843{
1844 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
1845
1846 int n = m_rowsOrCols.Index(rowOrCol);
1847 if ( n != wxNOT_FOUND )
1848 {
1849 attr = m_attrs[(size_t)n];
1850 attr->IncRef();
1851 }
1852
1853 return attr;
1854}
1855
1856void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
1857{
a95e38c0
VZ
1858 int i = m_rowsOrCols.Index(rowOrCol);
1859 if ( i == wxNOT_FOUND )
758cbedf
VZ
1860 {
1861 // add the attribute
1862 m_rowsOrCols.Add(rowOrCol);
1863 m_attrs.Add(attr);
1864 }
1865 else
1866 {
a95e38c0 1867 size_t n = (size_t)i;
758cbedf
VZ
1868 if ( attr )
1869 {
1870 // change the attribute
a95e38c0
VZ
1871 m_attrs[n]->DecRef();
1872 m_attrs[n] = attr;
758cbedf
VZ
1873 }
1874 else
1875 {
1876 // remove this attribute
a95e38c0
VZ
1877 m_attrs[n]->DecRef();
1878 m_rowsOrCols.RemoveAt(n);
1879 m_attrs.RemoveAt(n);
758cbedf
VZ
1880 }
1881 }
1882}
1883
4d60017a
SN
1884void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols )
1885{
1886 size_t count = m_attrs.GetCount();
1887 for ( size_t n = 0; n < count; n++ )
1888 {
1889 int & rowOrCol = m_rowsOrCols[n];
d1c0b4f9
VZ
1890 if ( (size_t)rowOrCol >= pos )
1891 {
1892 if ( numRowsOrCols > 0 )
1893 {
1894 // If rows inserted, include row counter where necessary
1895 rowOrCol += numRowsOrCols;
1896 }
1897 else if ( numRowsOrCols < 0)
1898 {
1899 // If rows deleted, either decrement row counter (if row still exists)
1900 if ((size_t)rowOrCol >= pos - numRowsOrCols)
1901 rowOrCol += numRowsOrCols;
1902 else
1903 {
1904 m_rowsOrCols.RemoveAt((size_t)n);
1905 m_attrs.RemoveAt((size_t)n);
1906 n--; count--;
1907 }
1908 }
4d60017a
SN
1909 }
1910 }
1911}
1912
b99be8fb
VZ
1913// ----------------------------------------------------------------------------
1914// wxGridCellAttrProvider
1915// ----------------------------------------------------------------------------
1916
1917wxGridCellAttrProvider::wxGridCellAttrProvider()
1918{
1919 m_data = (wxGridCellAttrProviderData *)NULL;
1920}
1921
1922wxGridCellAttrProvider::~wxGridCellAttrProvider()
1923{
1924 delete m_data;
1925}
1926
1927void wxGridCellAttrProvider::InitData()
1928{
1929 m_data = new wxGridCellAttrProviderData;
1930}
1931
1932wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col) const
1933{
758cbedf
VZ
1934 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
1935 if ( m_data )
1936 {
1937 // first look for the attribute of this specific cell
1938 attr = m_data->m_cellAttrs.GetAttr(row, col);
1939
1940 if ( !attr )
1941 {
1942 // then look for the col attr (col attributes are more common than
1943 // the row ones, hence they have priority)
1944 attr = m_data->m_colAttrs.GetAttr(col);
1945 }
1946
1947 if ( !attr )
1948 {
1949 // finally try the row attributes
1950 attr = m_data->m_rowAttrs.GetAttr(row);
1951 }
1952 }
1953
1954 return attr;
b99be8fb
VZ
1955}
1956
2e9a6788 1957void wxGridCellAttrProvider::SetAttr(wxGridCellAttr *attr,
b99be8fb
VZ
1958 int row, int col)
1959{
1960 if ( !m_data )
1961 InitData();
1962
758cbedf
VZ
1963 m_data->m_cellAttrs.SetAttr(attr, row, col);
1964}
1965
1966void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr *attr, int row)
1967{
1968 if ( !m_data )
1969 InitData();
1970
1971 m_data->m_rowAttrs.SetAttr(attr, row);
1972}
1973
1974void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr *attr, int col)
1975{
1976 if ( !m_data )
1977 InitData();
1978
1979 m_data->m_colAttrs.SetAttr(attr, col);
b99be8fb
VZ
1980}
1981
4d60017a
SN
1982void wxGridCellAttrProvider::UpdateAttrRows( size_t pos, int numRows )
1983{
1984 if ( m_data )
1985 {
1986 m_data->m_cellAttrs.UpdateAttrRows( pos, numRows );
1987
d1c0b4f9 1988 m_data->m_rowAttrs.UpdateAttrRowsOrCols( pos, numRows );
4d60017a
SN
1989 }
1990}
1991
1992void wxGridCellAttrProvider::UpdateAttrCols( size_t pos, int numCols )
1993{
1994 if ( m_data )
1995 {
1996 m_data->m_cellAttrs.UpdateAttrCols( pos, numCols );
1997
d1c0b4f9 1998 m_data->m_colAttrs.UpdateAttrRowsOrCols( pos, numCols );
4d60017a
SN
1999 }
2000}
2001
f2d76237
RD
2002// ----------------------------------------------------------------------------
2003// wxGridTypeRegistry
2004// ----------------------------------------------------------------------------
2005
2006wxGridTypeRegistry::~wxGridTypeRegistry()
2007{
b94ae1ea
VZ
2008 size_t count = m_typeinfo.Count();
2009 for ( size_t i = 0; i < count; i++ )
f2d76237
RD
2010 delete m_typeinfo[i];
2011}
2012
2013
2014void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
2015 wxGridCellRenderer* renderer,
2016 wxGridCellEditor* editor)
2017{
f2d76237
RD
2018 wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
2019
2020 // is it already registered?
c4608a8a 2021 int loc = FindRegisteredDataType(typeName);
39bcce60
VZ
2022 if ( loc != wxNOT_FOUND )
2023 {
f2d76237
RD
2024 delete m_typeinfo[loc];
2025 m_typeinfo[loc] = info;
2026 }
39bcce60
VZ
2027 else
2028 {
f2d76237
RD
2029 m_typeinfo.Add(info);
2030 }
2031}
2032
c4608a8a
VZ
2033int wxGridTypeRegistry::FindRegisteredDataType(const wxString& typeName)
2034{
2035 size_t count = m_typeinfo.GetCount();
2036 for ( size_t i = 0; i < count; i++ )
2037 {
2038 if ( typeName == m_typeinfo[i]->m_typeName )
2039 {
2040 return i;
2041 }
2042 }
2043
2044 return wxNOT_FOUND;
2045}
2046
f2d76237
RD
2047int wxGridTypeRegistry::FindDataType(const wxString& typeName)
2048{
c4608a8a
VZ
2049 int index = FindRegisteredDataType(typeName);
2050 if ( index == wxNOT_FOUND )
2051 {
2052 // check whether this is one of the standard ones, in which case
2053 // register it "on the fly"
2054 if ( typeName == wxGRID_VALUE_STRING )
2055 {
2056 RegisterDataType(wxGRID_VALUE_STRING,
2057 new wxGridCellStringRenderer,
2058 new wxGridCellTextEditor);
2059 }
2060 else if ( typeName == wxGRID_VALUE_BOOL )
2061 {
2062 RegisterDataType(wxGRID_VALUE_BOOL,
2063 new wxGridCellBoolRenderer,
2064 new wxGridCellBoolEditor);
2065 }
2066 else if ( typeName == wxGRID_VALUE_NUMBER )
2067 {
2068 RegisterDataType(wxGRID_VALUE_NUMBER,
2069 new wxGridCellNumberRenderer,
2070 new wxGridCellNumberEditor);
2071 }
2072 else if ( typeName == wxGRID_VALUE_FLOAT )
2073 {
2074 RegisterDataType(wxGRID_VALUE_FLOAT,
2075 new wxGridCellFloatRenderer,
2076 new wxGridCellFloatEditor);
2077 }
2078 else if ( typeName == wxGRID_VALUE_CHOICE )
2079 {
2080 RegisterDataType(wxGRID_VALUE_CHOICE,
2081 new wxGridCellStringRenderer,
2082 new wxGridCellChoiceEditor);
2083 }
2084 else
2085 {
2086 return wxNOT_FOUND;
2087 }
f2d76237 2088
c4608a8a
VZ
2089 // we get here only if just added the entry for this type, so return
2090 // the last index
2091 index = m_typeinfo.GetCount() - 1;
2092 }
2093
2094 return index;
2095}
2096
2097int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
2098{
2099 int index = FindDataType(typeName);
2100 if ( index == wxNOT_FOUND )
2101 {
2102 // the first part of the typename is the "real" type, anything after ':'
2103 // are the parameters for the renderer
2104 index = FindDataType(typeName.BeforeFirst(_T(':')));
2105 if ( index == wxNOT_FOUND )
2106 {
2107 return wxNOT_FOUND;
f2d76237 2108 }
c4608a8a
VZ
2109
2110 wxGridCellRenderer *renderer = GetRenderer(index);
2111 wxGridCellRenderer *rendererOld = renderer;
2112 renderer = renderer->Clone();
2113 rendererOld->DecRef();
2114
2115 wxGridCellEditor *editor = GetEditor(index);
2116 wxGridCellEditor *editorOld = editor;
2117 editor = editor->Clone();
2118 editorOld->DecRef();
2119
2120 // do it even if there are no parameters to reset them to defaults
2121 wxString params = typeName.AfterFirst(_T(':'));
2122 renderer->SetParameters(params);
2123 editor->SetParameters(params);
2124
2125 // register the new typename
c4608a8a
VZ
2126 RegisterDataType(typeName, renderer, editor);
2127
2128 // we just registered it, it's the last one
2129 index = m_typeinfo.GetCount() - 1;
f2d76237
RD
2130 }
2131
c4608a8a 2132 return index;
f2d76237
RD
2133}
2134
2135wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
2136{
2137 wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
0b190b0f 2138 renderer->IncRef();
f2d76237
RD
2139 return renderer;
2140}
2141
0b190b0f 2142wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
f2d76237
RD
2143{
2144 wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
0b190b0f 2145 editor->IncRef();
f2d76237
RD
2146 return editor;
2147}
2148
758cbedf
VZ
2149// ----------------------------------------------------------------------------
2150// wxGridTableBase
2151// ----------------------------------------------------------------------------
2152
f85afd4e
MB
2153IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
2154
2155
2156wxGridTableBase::wxGridTableBase()
f85afd4e
MB
2157{
2158 m_view = (wxGrid *) NULL;
b99be8fb 2159 m_attrProvider = (wxGridCellAttrProvider *) NULL;
f85afd4e
MB
2160}
2161
2162wxGridTableBase::~wxGridTableBase()
2163{
b99be8fb
VZ
2164 delete m_attrProvider;
2165}
2166
2167void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
2168{
2169 delete m_attrProvider;
2170 m_attrProvider = attrProvider;
f85afd4e
MB
2171}
2172
f2d76237
RD
2173bool wxGridTableBase::CanHaveAttributes()
2174{
2175 if ( ! GetAttrProvider() )
2176 {
2177 // use the default attr provider by default
2178 SetAttrProvider(new wxGridCellAttrProvider);
2179 }
2180 return TRUE;
2181}
2182
b99be8fb
VZ
2183wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col)
2184{
2185 if ( m_attrProvider )
2186 return m_attrProvider->GetAttr(row, col);
2187 else
2188 return (wxGridCellAttr *)NULL;
2189}
2190
758cbedf 2191void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
b99be8fb
VZ
2192{
2193 if ( m_attrProvider )
2194 {
2195 m_attrProvider->SetAttr(attr, row, col);
2196 }
2197 else
2198 {
2199 // as we take ownership of the pointer and don't store it, we must
2200 // free it now
39bcce60 2201 wxSafeDecRef(attr);
b99be8fb
VZ
2202 }
2203}
2204
758cbedf
VZ
2205void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
2206{
2207 if ( m_attrProvider )
2208 {
2209 m_attrProvider->SetRowAttr(attr, row);
2210 }
2211 else
2212 {
2213 // as we take ownership of the pointer and don't store it, we must
2214 // free it now
39bcce60 2215 wxSafeDecRef(attr);
758cbedf
VZ
2216 }
2217}
2218
2219void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
2220{
2221 if ( m_attrProvider )
2222 {
2223 m_attrProvider->SetColAttr(attr, col);
2224 }
2225 else
2226 {
2227 // as we take ownership of the pointer and don't store it, we must
2228 // free it now
39bcce60 2229 wxSafeDecRef(attr);
758cbedf
VZ
2230 }
2231}
2232
4d60017a
SN
2233void wxGridTableBase::UpdateAttrRows( size_t pos, int numRows )
2234{
2235 if ( m_attrProvider )
2236 {
2237 m_attrProvider->UpdateAttrRows( pos, numRows );
2238 }
2239}
2240
2241void wxGridTableBase::UpdateAttrCols( size_t pos, int numCols )
2242{
2243 if ( m_attrProvider )
2244 {
2245 m_attrProvider->UpdateAttrCols( pos, numCols );
2246 }
2247}
2248
f85afd4e
MB
2249bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
2250{
bd3c6758
MB
2251 wxFAIL_MSG( wxT("Called grid table class function InsertRows\n"
2252 "but your derived table class does not override this function") );
8f177c8e 2253
f85afd4e
MB
2254 return FALSE;
2255}
2256
2257bool wxGridTableBase::AppendRows( size_t numRows )
2258{
bd3c6758
MB
2259 wxFAIL_MSG( wxT("Called grid table class function AppendRows\n"
2260 "but your derived table class does not override this function"));
8f177c8e 2261
f85afd4e
MB
2262 return FALSE;
2263}
2264
2265bool wxGridTableBase::DeleteRows( size_t pos, size_t numRows )
2266{
bd3c6758
MB
2267 wxFAIL_MSG( wxT("Called grid table class function DeleteRows\n"
2268 "but your derived table class does not override this function"));
8f177c8e 2269
f85afd4e
MB
2270 return FALSE;
2271}
2272
2273bool wxGridTableBase::InsertCols( size_t pos, size_t numCols )
2274{
bd3c6758
MB
2275 wxFAIL_MSG( wxT("Called grid table class function InsertCols\n"
2276 "but your derived table class does not override this function"));
8f177c8e 2277
f85afd4e
MB
2278 return FALSE;
2279}
2280
2281bool wxGridTableBase::AppendCols( size_t numCols )
2282{
bd3c6758
MB
2283 wxFAIL_MSG(wxT("Called grid table class function AppendCols\n"
2284 "but your derived table class does not override this function"));
8f177c8e 2285
f85afd4e
MB
2286 return FALSE;
2287}
2288
2289bool wxGridTableBase::DeleteCols( size_t pos, size_t numCols )
2290{
bd3c6758
MB
2291 wxFAIL_MSG( wxT("Called grid table class function DeleteCols\n"
2292 "but your derived table class does not override this function"));
8f177c8e 2293
f85afd4e
MB
2294 return FALSE;
2295}
2296
2297
2298wxString wxGridTableBase::GetRowLabelValue( int row )
2299{
2300 wxString s;
f2d76237
RD
2301 s << row + 1; // RD: Starting the rows at zero confuses users, no matter
2302 // how much it makes sense to us geeks.
f85afd4e
MB
2303 return s;
2304}
2305
2306wxString wxGridTableBase::GetColLabelValue( int col )
2307{
2308 // default col labels are:
2309 // cols 0 to 25 : A-Z
2310 // cols 26 to 675 : AA-ZZ
2311 // etc.
2312
2313 wxString s;
2314 unsigned int i, n;
2315 for ( n = 1; ; n++ )
2316 {
f0102d2a 2317 s += (_T('A') + (wxChar)( col%26 ));
f85afd4e
MB
2318 col = col/26 - 1;
2319 if ( col < 0 ) break;
2320 }
2321
2322 // reverse the string...
2323 wxString s2;
2324 for ( i = 0; i < n; i++ )
2325 {
2326 s2 += s[n-i-1];
2327 }
2328
2329 return s2;
2330}
2331
2332
f2d76237
RD
2333wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
2334{
816be743 2335 return wxGRID_VALUE_STRING;
f2d76237
RD
2336}
2337
2338bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row), int WXUNUSED(col),
2339 const wxString& typeName )
2340{
816be743 2341 return typeName == wxGRID_VALUE_STRING;
f2d76237
RD
2342}
2343
2344bool wxGridTableBase::CanSetValueAs( int row, int col, const wxString& typeName )
2345{
2346 return CanGetValueAs(row, col, typeName);
2347}
2348
2349long wxGridTableBase::GetValueAsLong( int WXUNUSED(row), int WXUNUSED(col) )
2350{
2351 return 0;
2352}
2353
2354double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col) )
2355{
2356 return 0.0;
2357}
2358
2359bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row), int WXUNUSED(col) )
2360{
2361 return FALSE;
2362}
2363
2364void wxGridTableBase::SetValueAsLong( int WXUNUSED(row), int WXUNUSED(col),
2365 long WXUNUSED(value) )
2366{
2367}
2368
2369void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col),
2370 double WXUNUSED(value) )
2371{
2372}
2373
2374void wxGridTableBase::SetValueAsBool( int WXUNUSED(row), int WXUNUSED(col),
2375 bool WXUNUSED(value) )
2376{
2377}
2378
2379
2380void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
2381 const wxString& WXUNUSED(typeName) )
2382{
2383 return NULL;
2384}
2385
2386void wxGridTableBase::SetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
2387 const wxString& WXUNUSED(typeName),
2388 void* WXUNUSED(value) )
2389{
2390}
2391
f85afd4e
MB
2392//////////////////////////////////////////////////////////////////////
2393//
2394// Message class for the grid table to send requests and notifications
2395// to the grid view
2396//
2397
2398wxGridTableMessage::wxGridTableMessage()
2399{
2400 m_table = (wxGridTableBase *) NULL;
2401 m_id = -1;
2402 m_comInt1 = -1;
2403 m_comInt2 = -1;
2404}
2405
2406wxGridTableMessage::wxGridTableMessage( wxGridTableBase *table, int id,
2407 int commandInt1, int commandInt2 )
2408{
2409 m_table = table;
2410 m_id = id;
2411 m_comInt1 = commandInt1;
2412 m_comInt2 = commandInt2;
2413}
2414
2415
2416
2417//////////////////////////////////////////////////////////////////////
2418//
2419// A basic grid table for string data. An object of this class will
2420// created by wxGrid if you don't specify an alternative table class.
2421//
2422
223d09f6 2423WX_DEFINE_OBJARRAY(wxGridStringArray)
f85afd4e
MB
2424
2425IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
2426
2427wxGridStringTable::wxGridStringTable()
2428 : wxGridTableBase()
2429{
2430}
2431
2432wxGridStringTable::wxGridStringTable( int numRows, int numCols )
2433 : wxGridTableBase()
2434{
2435 int row, col;
8f177c8e 2436
f85afd4e
MB
2437 m_data.Alloc( numRows );
2438
2439 wxArrayString sa;
2440 sa.Alloc( numCols );
2441 for ( col = 0; col < numCols; col++ )
2442 {
2443 sa.Add( wxEmptyString );
2444 }
8f177c8e 2445
f85afd4e
MB
2446 for ( row = 0; row < numRows; row++ )
2447 {
2448 m_data.Add( sa );
2449 }
2450}
2451
2452wxGridStringTable::~wxGridStringTable()
2453{
2454}
2455
2456long wxGridStringTable::GetNumberRows()
2457{
2458 return m_data.GetCount();
2459}
2460
2461long wxGridStringTable::GetNumberCols()
2462{
2463 if ( m_data.GetCount() > 0 )
2464 return m_data[0].GetCount();
2465 else
2466 return 0;
2467}
2468
2469wxString wxGridStringTable::GetValue( int row, int col )
2470{
831243b1 2471 wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
af547d51
VZ
2472 _T("invalid row or column index in wxGridStringTable") );
2473
f85afd4e
MB
2474 return m_data[row][col];
2475}
2476
f2d76237 2477void wxGridStringTable::SetValue( int row, int col, const wxString& value )
f85afd4e 2478{
831243b1 2479 wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
af547d51
VZ
2480 _T("invalid row or column index in wxGridStringTable") );
2481
f2d76237 2482 m_data[row][col] = value;
f85afd4e
MB
2483}
2484
2485bool wxGridStringTable::IsEmptyCell( int row, int col )
2486{
831243b1 2487 wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
af547d51
VZ
2488 _T("invalid row or column index in wxGridStringTable") );
2489
f85afd4e
MB
2490 return (m_data[row][col] == wxEmptyString);
2491}
2492
f85afd4e
MB
2493void wxGridStringTable::Clear()
2494{
2495 int row, col;
2496 int numRows, numCols;
8f177c8e 2497
f85afd4e
MB
2498 numRows = m_data.GetCount();
2499 if ( numRows > 0 )
2500 {
2501 numCols = m_data[0].GetCount();
2502
2503 for ( row = 0; row < numRows; row++ )
2504 {
2505 for ( col = 0; col < numCols; col++ )
2506 {
2507 m_data[row][col] = wxEmptyString;
2508 }
2509 }
2510 }
2511}
2512
2513
2514bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
2515{
2516 size_t row, col;
2517
2518 size_t curNumRows = m_data.GetCount();
2519 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
8f177c8e 2520
f85afd4e
MB
2521 if ( pos >= curNumRows )
2522 {
2523 return AppendRows( numRows );
2524 }
8f177c8e 2525
f85afd4e
MB
2526 wxArrayString sa;
2527 sa.Alloc( curNumCols );
2528 for ( col = 0; col < curNumCols; col++ )
2529 {
2530 sa.Add( wxEmptyString );
2531 }
2532
2533 for ( row = pos; row < pos + numRows; row++ )
2534 {
2535 m_data.Insert( sa, row );
2536 }
4d60017a 2537 UpdateAttrRows( pos, numRows );
f85afd4e
MB
2538 if ( GetView() )
2539 {
2540 wxGridTableMessage msg( this,
2541 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
2542 pos,
2543 numRows );
8f177c8e 2544
f85afd4e
MB
2545 GetView()->ProcessTableMessage( msg );
2546 }
2547
2548 return TRUE;
2549}
2550
2551bool wxGridStringTable::AppendRows( size_t numRows )
2552{
2553 size_t row, col;
2554
2555 size_t curNumRows = m_data.GetCount();
2556 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
8f177c8e 2557
f85afd4e
MB
2558 wxArrayString sa;
2559 if ( curNumCols > 0 )
2560 {
2561 sa.Alloc( curNumCols );
2562 for ( col = 0; col < curNumCols; col++ )
2563 {
2564 sa.Add( wxEmptyString );
2565 }
2566 }
8f177c8e 2567
f85afd4e
MB
2568 for ( row = 0; row < numRows; row++ )
2569 {
2570 m_data.Add( sa );
2571 }
2572
2573 if ( GetView() )
2574 {
2575 wxGridTableMessage msg( this,
2576 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
2577 numRows );
8f177c8e 2578
f85afd4e
MB
2579 GetView()->ProcessTableMessage( msg );
2580 }
2581
8f177c8e 2582 return TRUE;
f85afd4e
MB
2583}
2584
2585bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
2586{
2587 size_t n;
2588
2589 size_t curNumRows = m_data.GetCount();
8f177c8e 2590
f85afd4e
MB
2591 if ( pos >= curNumRows )
2592 {
bd3c6758
MB
2593 wxString errmsg;
2594 errmsg.Printf("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)\n"
2595 "Pos value is invalid for present table with %d rows",
2596 pos, numRows, curNumRows );
2597 wxFAIL_MSG( wxT(errmsg) );
f85afd4e
MB
2598 return FALSE;
2599 }
2600
2601 if ( numRows > curNumRows - pos )
2602 {
2603 numRows = curNumRows - pos;
2604 }
8f177c8e 2605
f85afd4e
MB
2606 if ( numRows >= curNumRows )
2607 {
2608 m_data.Empty(); // don't release memory just yet
2609 }
2610 else
2611 {
2612 for ( n = 0; n < numRows; n++ )
2613 {
2614 m_data.Remove( pos );
2615 }
2616 }
9b4aede2 2617 UpdateAttrRows( pos, -((int)numRows) );
f85afd4e
MB
2618 if ( GetView() )
2619 {
2620 wxGridTableMessage msg( this,
2621 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
2622 pos,
2623 numRows );
8f177c8e 2624
f85afd4e
MB
2625 GetView()->ProcessTableMessage( msg );
2626 }
2627
8f177c8e 2628 return TRUE;
f85afd4e
MB
2629}
2630
2631bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
2632{
2633 size_t row, col;
2634
2635 size_t curNumRows = m_data.GetCount();
2636 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
8f177c8e 2637
f85afd4e
MB
2638 if ( pos >= curNumCols )
2639 {
2640 return AppendCols( numCols );
2641 }
2642
2643 for ( row = 0; row < curNumRows; row++ )
2644 {
2645 for ( col = pos; col < pos + numCols; col++ )
2646 {
2647 m_data[row].Insert( wxEmptyString, col );
2648 }
2649 }
4d60017a 2650 UpdateAttrCols( pos, numCols );
f85afd4e
MB
2651 if ( GetView() )
2652 {
2653 wxGridTableMessage msg( this,
2654 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
2655 pos,
2656 numCols );
8f177c8e 2657
f85afd4e
MB
2658 GetView()->ProcessTableMessage( msg );
2659 }
2660
2661 return TRUE;
2662}
2663
2664bool wxGridStringTable::AppendCols( size_t numCols )
2665{
2666 size_t row, n;
2667
2668 size_t curNumRows = m_data.GetCount();
2669 if ( !curNumRows )
2670 {
2671 // TODO: something better than this ?
2672 //
bd3c6758
MB
2673 wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\n"
2674 "Call AppendRows() first") );
f85afd4e
MB
2675 return FALSE;
2676 }
8f177c8e 2677
f85afd4e
MB
2678 for ( row = 0; row < curNumRows; row++ )
2679 {
2680 for ( n = 0; n < numCols; n++ )
2681 {
2682 m_data[row].Add( wxEmptyString );
2683 }
2684 }
2685
2686 if ( GetView() )
2687 {
2688 wxGridTableMessage msg( this,
2689 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
2690 numCols );
8f177c8e 2691
f85afd4e
MB
2692 GetView()->ProcessTableMessage( msg );
2693 }
2694
2695 return TRUE;
2696}
2697
2698bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
2699{
2700 size_t row, n;
2701
2702 size_t curNumRows = m_data.GetCount();
2703 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
8f177c8e 2704
f85afd4e
MB
2705 if ( pos >= curNumCols )
2706 {
bd3c6758
MB
2707 wxString errmsg;
2708 errmsg.Printf( "Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
2709 "Pos value is invalid for present table with %d cols",
2710 pos, numCols, curNumCols );
2711 wxFAIL_MSG( wxT( errmsg ) );
8f177c8e 2712 return FALSE;
f85afd4e
MB
2713 }
2714
2715 if ( numCols > curNumCols - pos )
2716 {
8f177c8e 2717 numCols = curNumCols - pos;
f85afd4e
MB
2718 }
2719
2720 for ( row = 0; row < curNumRows; row++ )
2721 {
2722 if ( numCols >= curNumCols )
2723 {
2724 m_data[row].Clear();
2725 }
2726 else
2727 {
2728 for ( n = 0; n < numCols; n++ )
2729 {
2730 m_data[row].Remove( pos );
2731 }
2732 }
2733 }
9b4aede2 2734 UpdateAttrCols( pos, -((int)numCols) );
f85afd4e
MB
2735 if ( GetView() )
2736 {
2737 wxGridTableMessage msg( this,
2738 wxGRIDTABLE_NOTIFY_COLS_DELETED,
2739 pos,
2740 numCols );
8f177c8e 2741
f85afd4e
MB
2742 GetView()->ProcessTableMessage( msg );
2743 }
2744
8f177c8e 2745 return TRUE;
f85afd4e
MB
2746}
2747
2748wxString wxGridStringTable::GetRowLabelValue( int row )
2749{
2750 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
2751 {
2752 // using default label
2753 //
2754 return wxGridTableBase::GetRowLabelValue( row );
2755 }
2756 else
2757 {
2758 return m_rowLabels[ row ];
2759 }
2760}
2761
2762wxString wxGridStringTable::GetColLabelValue( int col )
2763{
2764 if ( col > (int)(m_colLabels.GetCount()) - 1 )
2765 {
2766 // using default label
2767 //
2768 return wxGridTableBase::GetColLabelValue( col );
2769 }
2770 else
2771 {
2772 return m_colLabels[ col ];
2773 }
2774}
2775
2776void wxGridStringTable::SetRowLabelValue( int row, const wxString& value )
2777{
2778 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
2779 {
2780 int n = m_rowLabels.GetCount();
2781 int i;
2782 for ( i = n; i <= row; i++ )
2783 {
2784 m_rowLabels.Add( wxGridTableBase::GetRowLabelValue(i) );
2785 }
2786 }
2787
2788 m_rowLabels[row] = value;
2789}
2790
2791void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
2792{
2793 if ( col > (int)(m_colLabels.GetCount()) - 1 )
2794 {
2795 int n = m_colLabels.GetCount();
2796 int i;
2797 for ( i = n; i <= col; i++ )
2798 {
2799 m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
2800 }
2801 }
2802
2803 m_colLabels[col] = value;
2804}
2805
2806
2807
f85afd4e 2808//////////////////////////////////////////////////////////////////////
2d66e025
MB
2809//////////////////////////////////////////////////////////////////////
2810
2811IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
2812
2813BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
2814 EVT_PAINT( wxGridRowLabelWindow::OnPaint )
2815 EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
2816 EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
2817END_EVENT_TABLE()
2818
60ff3b99
VZ
2819wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
2820 wxWindowID id,
2d66e025 2821 const wxPoint &pos, const wxSize &size )
ebd773c6 2822 : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
2d66e025
MB
2823{
2824 m_owner = parent;
2825}
2826
2827void wxGridRowLabelWindow::OnPaint( wxPaintEvent &event )
2828{
2829 wxPaintDC dc(this);
2830
2831 // NO - don't do this because it will set both the x and y origin
2832 // coords to match the parent scrolled window and we just want to
2833 // set the y coord - MB
2834 //
2835 // m_owner->PrepareDC( dc );
60ff3b99 2836
790ad94f 2837 int x, y;
2d66e025
MB
2838 m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
2839 dc.SetDeviceOrigin( 0, -y );
60ff3b99 2840
2d66e025
MB
2841 m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
2842 m_owner->DrawRowLabels( dc );
2843}
2844
2845
2846void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
2847{
2848 m_owner->ProcessRowLabelMouseEvent( event );
2849}
2850
2851
2852// This seems to be required for wxMotif otherwise the mouse
2853// cursor must be in the cell edit control to get key events
2854//
2855void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
2856{
2857 if ( !m_owner->ProcessEvent( event ) ) event.Skip();
2858}
2859
2860
2861
2862//////////////////////////////////////////////////////////////////////
2863
2864IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
2865
2866BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
2867 EVT_PAINT( wxGridColLabelWindow::OnPaint )
2868 EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
2869 EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
2870END_EVENT_TABLE()
2871
60ff3b99
VZ
2872wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
2873 wxWindowID id,
2d66e025 2874 const wxPoint &pos, const wxSize &size )
ebd773c6 2875 : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
2d66e025
MB
2876{
2877 m_owner = parent;
2878}
2879
2880void wxGridColLabelWindow::OnPaint( wxPaintEvent &event )
2881{
2882 wxPaintDC dc(this);
2883
2884 // NO - don't do this because it will set both the x and y origin
2885 // coords to match the parent scrolled window and we just want to
2886 // set the x coord - MB
2887 //
2888 // m_owner->PrepareDC( dc );
60ff3b99 2889
790ad94f 2890 int x, y;
2d66e025
MB
2891 m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
2892 dc.SetDeviceOrigin( -x, 0 );
2893
60ff3b99
VZ
2894 m_owner->CalcColLabelsExposed( GetUpdateRegion() );
2895 m_owner->DrawColLabels( dc );
2d66e025
MB
2896}
2897
2898
2899void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
2900{
2901 m_owner->ProcessColLabelMouseEvent( event );
2902}
2903
2904
2905// This seems to be required for wxMotif otherwise the mouse
2906// cursor must be in the cell edit control to get key events
2907//
2908void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
2909{
2910 if ( !m_owner->ProcessEvent( event ) ) event.Skip();
2911}
2912
2913
2914
2915//////////////////////////////////////////////////////////////////////
2916
2917IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
2918
2919BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
2920 EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
d2fdd8d2 2921 EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
2d66e025
MB
2922 EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
2923END_EVENT_TABLE()
2924
60ff3b99
VZ
2925wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
2926 wxWindowID id,
2d66e025 2927 const wxPoint &pos, const wxSize &size )
ebd773c6 2928 : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
2d66e025
MB
2929{
2930 m_owner = parent;
2931}
2932
d2fdd8d2
RR
2933void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
2934{
2935 wxPaintDC dc(this);
b99be8fb 2936
d2fdd8d2
RR
2937 int client_height = 0;
2938 int client_width = 0;
2939 GetClientSize( &client_width, &client_height );
b99be8fb 2940
d2fdd8d2
RR
2941 dc.SetPen( *wxBLACK_PEN );
2942 dc.DrawLine( client_width-1, client_height-1, client_width-1, 0 );
2943 dc.DrawLine( client_width-1, client_height-1, 0, client_height-1 );
b99be8fb 2944
d2fdd8d2
RR
2945 dc.SetPen( *wxWHITE_PEN );
2946 dc.DrawLine( 0, 0, client_width, 0 );
2947 dc.DrawLine( 0, 0, 0, client_height );
2948}
2949
2d66e025
MB
2950
2951void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
2952{
2953 m_owner->ProcessCornerLabelMouseEvent( event );
2954}
2955
2956
2957// This seems to be required for wxMotif otherwise the mouse
2958// cursor must be in the cell edit control to get key events
2959//
2960void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
2961{
2962 if ( !m_owner->ProcessEvent( event ) ) event.Skip();
2963}
2964
2965
2966
f85afd4e
MB
2967//////////////////////////////////////////////////////////////////////
2968
2d66e025
MB
2969IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxPanel )
2970
2971BEGIN_EVENT_TABLE( wxGridWindow, wxPanel )
2972 EVT_PAINT( wxGridWindow::OnPaint )
2d66e025
MB
2973 EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
2974 EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
2796cce3 2975 EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground )
2d66e025
MB
2976END_EVENT_TABLE()
2977
60ff3b99
VZ
2978wxGridWindow::wxGridWindow( wxGrid *parent,
2979 wxGridRowLabelWindow *rowLblWin,
2d66e025
MB
2980 wxGridColLabelWindow *colLblWin,
2981 wxWindowID id, const wxPoint &pos, const wxSize &size )
ebd773c6 2982 : wxPanel( parent, id, pos, size, wxWANTS_CHARS, "grid window" )
2d66e025
MB
2983{
2984 m_owner = parent;
2985 m_rowLabelWin = rowLblWin;
2986 m_colLabelWin = colLblWin;
2d66e025
MB
2987 SetBackgroundColour( "WHITE" );
2988}
2989
2990
2991wxGridWindow::~wxGridWindow()
2992{
2993}
2994
2995
2996void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
2997{
2998 wxPaintDC dc( this );
2999 m_owner->PrepareDC( dc );
796df70a
SN
3000 wxRegion reg = GetUpdateRegion();
3001 m_owner->CalcCellsExposed( reg );
2d66e025 3002 m_owner->DrawGridCellArea( dc );
9496deb5 3003#if WXGRID_DRAW_LINES
796df70a
SN
3004 m_owner->DrawAllGridLines( dc, reg );
3005#endif
a5777624 3006 m_owner->DrawGridSpace( dc );
b3a7510d 3007 m_owner->DrawHighlight( dc );
2d66e025
MB
3008}
3009
3010
3011void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
3012{
3013 wxPanel::ScrollWindow( dx, dy, rect );
3014 m_rowLabelWin->ScrollWindow( 0, dy, rect );
3015 m_colLabelWin->ScrollWindow( dx, 0, rect );
3016}
3017
3018
3019void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
3020{
3021 m_owner->ProcessGridCellMouseEvent( event );
3022}
3023
3024
3025// This seems to be required for wxMotif otherwise the mouse
3026// cursor must be in the cell edit control to get key events
3027//
3028void wxGridWindow::OnKeyDown( wxKeyEvent& event )
3029{
3030 if ( !m_owner->ProcessEvent( event ) ) event.Skip();
3031}
f85afd4e 3032
7c8a8ad5 3033
8dd4f536
VZ
3034void wxGridWindow::OnEraseBackground(wxEraseEvent& event)
3035{
8dd4f536 3036}
025562fe 3037
2d66e025
MB
3038
3039//////////////////////////////////////////////////////////////////////
3040
07296f0b 3041
2d66e025
MB
3042IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
3043
3044BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
f85afd4e
MB
3045 EVT_PAINT( wxGrid::OnPaint )
3046 EVT_SIZE( wxGrid::OnSize )
f85afd4e 3047 EVT_KEY_DOWN( wxGrid::OnKeyDown )
2796cce3 3048 EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground )
f85afd4e 3049END_EVENT_TABLE()
8f177c8e 3050
2d66e025
MB
3051wxGrid::wxGrid( wxWindow *parent,
3052 wxWindowID id,
3053 const wxPoint& pos,
3054 const wxSize& size,
3055 long style,
3056 const wxString& name )
ebd773c6 3057 : wxScrolledWindow( parent, id, pos, size, (style | wxWANTS_CHARS), name ),
af547d51
VZ
3058 m_colMinWidths(GRID_HASH_SIZE),
3059 m_rowMinHeights(GRID_HASH_SIZE)
2d66e025
MB
3060{
3061 Create();
58dd5b3b
MB
3062}
3063
3064
3065wxGrid::~wxGrid()
3066{
0a976765 3067 ClearAttrCache();
39bcce60 3068 wxSafeDecRef(m_defaultCellAttr);
0a976765
VZ
3069
3070#ifdef DEBUG_ATTR_CACHE
3071 size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
3072 wxPrintf(_T("wxGrid attribute cache statistics: "
3073 "total: %u, hits: %u (%u%%)\n"),
3074 total, gs_nAttrCacheHits,
3075 total ? (gs_nAttrCacheHits*100) / total : 0);
3076#endif
3077
2796cce3
RD
3078 if (m_ownTable)
3079 delete m_table;
f2d76237
RD
3080
3081 delete m_typeRegistry;
b5808881 3082 delete m_selection;
58dd5b3b
MB
3083}
3084
2d66e025 3085
58dd5b3b
MB
3086//
3087// ----- internal init and update functions
3088//
3089
3090void wxGrid::Create()
f0102d2a 3091{
4634a5d6 3092 m_created = FALSE; // set to TRUE by CreateGrid
4634a5d6
MB
3093
3094 m_table = (wxGridTableBase *) NULL;
2796cce3 3095 m_ownTable = FALSE;
2c9a89e0
RD
3096
3097 m_cellEditCtrlEnabled = FALSE;
4634a5d6 3098
2796cce3
RD
3099 m_defaultCellAttr = new wxGridCellAttr;
3100 m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
f2d76237
RD
3101
3102 // Set default cell attributes
3103 m_defaultCellAttr->SetFont(GetFont());
3104 m_defaultCellAttr->SetAlignment(wxLEFT, wxTOP);
3105 m_defaultCellAttr->SetTextColour(
3106 wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT));
3107 m_defaultCellAttr->SetBackgroundColour(
3108 wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
3109 m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);
3110 m_defaultCellAttr->SetEditor(new wxGridCellTextEditor);
2796cce3
RD
3111
3112
4634a5d6
MB
3113 m_numRows = 0;
3114 m_numCols = 0;
3115 m_currentCellCoords = wxGridNoCellCoords;
b99be8fb 3116
18f9565d
MB
3117 m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
3118 m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
2d66e025 3119
c4608a8a 3120 // create the type registry
f2d76237 3121 m_typeRegistry = new wxGridTypeRegistry;
b5808881 3122 m_selection = 0;
f2d76237 3123 // subwindow components that make up the wxGrid
7807d81c
MB
3124 m_cornerLabelWin = new wxGridCornerLabelWindow( this,
3125 -1,
18f9565d
MB
3126 wxDefaultPosition,
3127 wxDefaultSize );
7807d81c 3128
60ff3b99
VZ
3129 m_rowLabelWin = new wxGridRowLabelWindow( this,
3130 -1,
18f9565d
MB
3131 wxDefaultPosition,
3132 wxDefaultSize );
2d66e025
MB
3133
3134 m_colLabelWin = new wxGridColLabelWindow( this,
3135 -1,
18f9565d
MB
3136 wxDefaultPosition,
3137 wxDefaultSize );
60ff3b99 3138
60ff3b99
VZ
3139 m_gridWin = new wxGridWindow( this,
3140 m_rowLabelWin,
3141 m_colLabelWin,
3142 -1,
18f9565d 3143 wxDefaultPosition,
2d66e025
MB
3144 wxDefaultSize );
3145
3146 SetTargetWindow( m_gridWin );
2d66e025 3147}
f85afd4e 3148
2d66e025 3149
b5808881
SN
3150bool wxGrid::CreateGrid( int numRows, int numCols,
3151 wxGrid::wxGridSelectionModes selmode )
2d66e025
MB
3152{
3153 if ( m_created )
3154 {
2796cce3 3155 wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
2d66e025
MB
3156 return FALSE;
3157 }
3158 else
3159 {
3160 m_numRows = numRows;
3161 m_numCols = numCols;
3162
3163 m_table = new wxGridStringTable( m_numRows, m_numCols );
3164 m_table->SetView( this );
2796cce3
RD
3165 m_ownTable = TRUE;
3166 Init();
043d16b2 3167 m_selection = new wxGridSelection( this, selmode );
2796cce3
RD
3168 m_created = TRUE;
3169 }
2796cce3
RD
3170 return m_created;
3171}
3172
f1567cdd
SN
3173void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
3174{
3175 if ( !m_created )
3176 {
3177 wxFAIL_MSG( wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
3178 }
3179 else
3180 m_selection->SetSelectionMode( selmode );
3181}
3182
043d16b2
SN
3183bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
3184 wxGrid::wxGridSelectionModes selmode )
2796cce3
RD
3185{
3186 if ( m_created )
3187 {
fb295790
RD
3188 // RD: Actually, this should probably be allowed. I think it would be
3189 // nice to be able to switch multiple Tables in and out of a single
3190 // View at runtime. Is there anything in the implmentation that would
3191 // prevent this?
3192
d95b0c2b 3193 // At least, you now have to cope with m_selection
2796cce3
RD
3194 wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3195 return FALSE;
3196 }
3197 else
3198 {
3199 m_numRows = table->GetNumberRows();
3200 m_numCols = table->GetNumberCols();
3201
3202 m_table = table;
3203 m_table->SetView( this );
3204 if (takeOwnership)
3205 m_ownTable = TRUE;
2d66e025 3206 Init();
043d16b2 3207 m_selection = new wxGridSelection( this, selmode );
2d66e025
MB
3208 m_created = TRUE;
3209 }
f85afd4e 3210
2d66e025 3211 return m_created;
f85afd4e
MB
3212}
3213
2d66e025 3214
f85afd4e
MB
3215void wxGrid::Init()
3216{
f85afd4e
MB
3217 if ( m_numRows <= 0 )
3218 m_numRows = WXGRID_DEFAULT_NUMBER_ROWS;
3219
3220 if ( m_numCols <= 0 )
3221 m_numCols = WXGRID_DEFAULT_NUMBER_COLS;
3222
3223 m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
3224 m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
3225
60ff3b99
VZ
3226 if ( m_rowLabelWin )
3227 {
3228 m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();
3229 }
3230 else
3231 {
3232 m_labelBackgroundColour = wxColour( _T("WHITE") );
3233 }
3234
3235 m_labelTextColour = wxColour( _T("BLACK") );
f85afd4e 3236
0a976765
VZ
3237 // init attr cache
3238 m_attrCache.row = -1;
3239
f85afd4e
MB
3240 // TODO: something better than this ?
3241 //
3242 m_labelFont = this->GetFont();
3243 m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
8f177c8e 3244
f85afd4e
MB
3245 m_rowLabelHorizAlign = wxLEFT;
3246 m_rowLabelVertAlign = wxCENTRE;
3247
3248 m_colLabelHorizAlign = wxCENTRE;
3249 m_colLabelVertAlign = wxTOP;
3250
f85afd4e 3251 m_defaultColWidth = WXGRID_DEFAULT_COL_WIDTH;
1f1ce288
MB
3252 m_defaultRowHeight = m_gridWin->GetCharHeight();
3253
d2fdd8d2 3254#if defined(__WXMOTIF__) || defined(__WXGTK__) // see also text ctrl sizing in ShowCellEditControl()
1f1ce288
MB
3255 m_defaultRowHeight += 8;
3256#else
3257 m_defaultRowHeight += 4;
3258#endif
3259
2d66e025 3260 m_gridLineColour = wxColour( 128, 128, 255 );
f85afd4e 3261 m_gridLinesEnabled = TRUE;
8f177c8e 3262
58dd5b3b 3263 m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
e2b42eeb 3264 m_winCapture = (wxWindow *)NULL;
6e8524b1
MB
3265 m_canDragRowSize = TRUE;
3266 m_canDragColSize = TRUE;
4cfa5de6 3267 m_canDragGridSize = TRUE;
f85afd4e
MB
3268 m_dragLastPos = -1;
3269 m_dragRowOrCol = -1;
3270 m_isDragging = FALSE;
07296f0b 3271 m_startDragPos = wxDefaultPosition;
f85afd4e 3272
07296f0b 3273 m_waitForSlowClick = FALSE;
025562fe 3274
f85afd4e
MB
3275 m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
3276 m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
3277
3278 m_currentCellCoords = wxGridNoCellCoords;
f85afd4e 3279
b5808881
SN
3280 m_selectingTopLeft = wxGridNoCellCoords;
3281 m_selectingBottomRight = wxGridNoCellCoords;
2796cce3
RD
3282 m_selectionBackground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT);
3283 m_selectionForeground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
8f177c8e 3284
f85afd4e
MB
3285 m_editable = TRUE; // default for whole grid
3286
2d66e025
MB
3287 m_inOnKeyDown = FALSE;
3288 m_batchCount = 0;
3c79cf49 3289
266e8367
VZ
3290 m_extraWidth =
3291 m_extraHeight = 50;
3292
3c79cf49 3293 CalcDimensions();
7c1cb261
VZ
3294}
3295
3296// ----------------------------------------------------------------------------
3297// the idea is to call these functions only when necessary because they create
3298// quite big arrays which eat memory mostly unnecessary - in particular, if
3299// default widths/heights are used for all rows/columns, we may not use these
3300// arrays at all
3301//
3302// with some extra code, it should be possible to only store the
3303// widths/heights different from default ones but this will be done later...
3304// ----------------------------------------------------------------------------
3305
3306void wxGrid::InitRowHeights()
3307{
3308 m_rowHeights.Empty();
3309 m_rowBottoms.Empty();
3310
3311 m_rowHeights.Alloc( m_numRows );
3312 m_rowBottoms.Alloc( m_numRows );
3313
3314 int rowBottom = 0;
3315 for ( int i = 0; i < m_numRows; i++ )
3316 {
3317 m_rowHeights.Add( m_defaultRowHeight );
3318 rowBottom += m_defaultRowHeight;
3319 m_rowBottoms.Add( rowBottom );
3320 }
3321}
3322
3323void wxGrid::InitColWidths()
3324{
3325 m_colWidths.Empty();
3326 m_colRights.Empty();
3327
3328 m_colWidths.Alloc( m_numCols );
3329 m_colRights.Alloc( m_numCols );
3330 int colRight = 0;
3331 for ( int i = 0; i < m_numCols; i++ )
3332 {
3333 m_colWidths.Add( m_defaultColWidth );
3334 colRight += m_defaultColWidth;
3335 m_colRights.Add( colRight );
3336 }
3337}
3338
3339int wxGrid::GetColWidth(int col) const
3340{
3341 return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
3342}
3343
3344int wxGrid::GetColLeft(int col) const
3345{
3346 return m_colRights.IsEmpty() ? col * m_defaultColWidth
3347 : m_colRights[col] - m_colWidths[col];
3348}
3349
3350int wxGrid::GetColRight(int col) const
3351{
3352 return m_colRights.IsEmpty() ? (col + 1) * m_defaultColWidth
3353 : m_colRights[col];
3354}
3355
3356int wxGrid::GetRowHeight(int row) const
3357{
3358 return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
3359}
2d66e025 3360
7c1cb261
VZ
3361int wxGrid::GetRowTop(int row) const
3362{
3363 return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
3364 : m_rowBottoms[row] - m_rowHeights[row];
f85afd4e
MB
3365}
3366
7c1cb261
VZ
3367int wxGrid::GetRowBottom(int row) const
3368{
3369 return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
3370 : m_rowBottoms[row];
3371}
f85afd4e
MB
3372
3373void wxGrid::CalcDimensions()
3374{
f85afd4e 3375 int cw, ch;
2d66e025 3376 GetClientSize( &cw, &ch );
f85afd4e 3377
2d66e025 3378 if ( m_numRows > 0 && m_numCols > 0 )
f85afd4e 3379 {
266e8367
VZ
3380 int right = GetColRight( m_numCols-1 ) + m_extraWidth;
3381 int bottom = GetRowBottom( m_numRows-1 ) + m_extraHeight;
60ff3b99 3382
2d66e025
MB
3383 // TODO: restore the scroll position that we had before sizing
3384 //
3385 int x, y;
3386 GetViewStart( &x, &y );
f0102d2a
VZ
3387 SetScrollbars( GRID_SCROLL_LINE, GRID_SCROLL_LINE,
3388 right/GRID_SCROLL_LINE, bottom/GRID_SCROLL_LINE,
be46e4a6 3389 x, y );
f85afd4e 3390 }
f85afd4e
MB
3391}
3392
3393
7807d81c
MB
3394void wxGrid::CalcWindowSizes()
3395{
3396 int cw, ch;
3397 GetClientSize( &cw, &ch );
b99be8fb 3398
7807d81c
MB
3399 if ( m_cornerLabelWin->IsShown() )
3400 m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
3401
3402 if ( m_colLabelWin->IsShown() )
3403 m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw-m_rowLabelWidth, m_colLabelHeight);
3404
3405 if ( m_rowLabelWin->IsShown() )
3406 m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch-m_colLabelHeight);
3407
3408 if ( m_gridWin->IsShown() )
3409 m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw-m_rowLabelWidth, ch-m_colLabelHeight);
3410}
3411
3412
f85afd4e
MB
3413// this is called when the grid table sends a message to say that it
3414// has been redimensioned
3415//
3416bool wxGrid::Redimension( wxGridTableMessage& msg )
3417{
3418 int i;
8f177c8e 3419
7c1cb261
VZ
3420 // if we were using the default widths/heights so far, we must change them
3421 // now
3422 if ( m_colWidths.IsEmpty() )
3423 {
3424 InitColWidths();
3425 }
3426
3427 if ( m_rowHeights.IsEmpty() )
3428 {
3429 InitRowHeights();
3430 }
3431
f85afd4e
MB
3432 switch ( msg.GetId() )
3433 {
3434 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
3435 {
3436 size_t pos = msg.GetCommandInt();
3437 int numRows = msg.GetCommandInt2();
3438 for ( i = 0; i < numRows; i++ )
3439 {
3440 m_rowHeights.Insert( m_defaultRowHeight, pos );
3441 m_rowBottoms.Insert( 0, pos );
3442 }
3443 m_numRows += numRows;
2d66e025
MB
3444
3445 int bottom = 0;
3446 if ( pos > 0 ) bottom = m_rowBottoms[pos-1];
60ff3b99 3447
2d66e025
MB
3448 for ( i = pos; i < m_numRows; i++ )
3449 {
3450 bottom += m_rowHeights[i];
3451 m_rowBottoms[i] = bottom;
3452 }
f85afd4e
MB
3453 CalcDimensions();
3454 }
3455 return TRUE;
3456
3457 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
3458 {
3459 int numRows = msg.GetCommandInt();
3460 for ( i = 0; i < numRows; i++ )
3461 {
3462 m_rowHeights.Add( m_defaultRowHeight );
3463 m_rowBottoms.Add( 0 );
3464 }
2d66e025
MB
3465
3466 int oldNumRows = m_numRows;
f85afd4e 3467 m_numRows += numRows;
2d66e025
MB
3468
3469 int bottom = 0;
3470 if ( oldNumRows > 0 ) bottom = m_rowBottoms[oldNumRows-1];
60ff3b99 3471
2d66e025
MB
3472 for ( i = oldNumRows; i < m_numRows; i++ )
3473 {
3474 bottom += m_rowHeights[i];
3475 m_rowBottoms[i] = bottom;
3476 }
f85afd4e
MB
3477 CalcDimensions();
3478 }
3479 return TRUE;
3480
3481 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
3482 {
3483 size_t pos = msg.GetCommandInt();
3484 int numRows = msg.GetCommandInt2();
3485 for ( i = 0; i < numRows; i++ )
3486 {
3487 m_rowHeights.Remove( pos );
3488 m_rowBottoms.Remove( pos );
3489 }
3490 m_numRows -= numRows;
3491
f85afd4e
MB
3492 if ( !m_numRows )
3493 {
3494 m_numCols = 0;
3495 m_colWidths.Clear();
3496 m_colRights.Clear();
3497 m_currentCellCoords = wxGridNoCellCoords;
3498 }
2d66e025 3499 else
f85afd4e 3500 {
2d66e025
MB
3501 if ( m_currentCellCoords.GetRow() >= m_numRows )
3502 m_currentCellCoords.Set( 0, 0 );
3503
3504 int h = 0;
3505 for ( i = 0; i < m_numRows; i++ )
3506 {
3507 h += m_rowHeights[i];
3508 m_rowBottoms[i] = h;
3509 }
f85afd4e 3510 }
60ff3b99 3511
f85afd4e
MB
3512 CalcDimensions();
3513 }
3514 return TRUE;
3515
3516 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
3517 {
3518 size_t pos = msg.GetCommandInt();
3519 int numCols = msg.GetCommandInt2();
3520 for ( i = 0; i < numCols; i++ )
3521 {
3522 m_colWidths.Insert( m_defaultColWidth, pos );
3523 m_colRights.Insert( 0, pos );
3524 }
3525 m_numCols += numCols;
2d66e025
MB
3526
3527 int right = 0;
3528 if ( pos > 0 ) right = m_colRights[pos-1];
60ff3b99 3529
2d66e025
MB
3530 for ( i = pos; i < m_numCols; i++ )
3531 {
3532 right += m_colWidths[i];
3533 m_colRights[i] = right;
3534 }
f85afd4e
MB
3535 CalcDimensions();
3536 }
3537 return TRUE;
3538
3539 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
3540 {
3541 int numCols = msg.GetCommandInt();
3542 for ( i = 0; i < numCols; i++ )
3543 {
3544 m_colWidths.Add( m_defaultColWidth );
3545 m_colRights.Add( 0 );
3546 }
2d66e025
MB
3547
3548 int oldNumCols = m_numCols;
f85afd4e 3549 m_numCols += numCols;
2d66e025
MB
3550
3551 int right = 0;
3552 if ( oldNumCols > 0 ) right = m_colRights[oldNumCols-1];
60ff3b99 3553
2d66e025
MB
3554 for ( i = oldNumCols; i < m_numCols; i++ )
3555 {
3556 right += m_colWidths[i];
3557 m_colRights[i] = right;
3558 }
f85afd4e
MB
3559 CalcDimensions();
3560 }
3561 return TRUE;
3562
3563 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
3564 {
3565 size_t pos = msg.GetCommandInt();
3566 int numCols = msg.GetCommandInt2();
3567 for ( i = 0; i < numCols; i++ )
3568 {
3569 m_colWidths.Remove( pos );
3570 m_colRights.Remove( pos );
3571 }
3572 m_numCols -= numCols;
f85afd4e
MB
3573
3574 if ( !m_numCols )
3575 {
3576#if 0 // leave the row alone here so that AppendCols will work subsequently
3577 m_numRows = 0;
3578 m_rowHeights.Clear();
3579 m_rowBottoms.Clear();
8f177c8e 3580#endif
f85afd4e
MB
3581 m_currentCellCoords = wxGridNoCellCoords;
3582 }
60ff3b99 3583 else
f85afd4e 3584 {
2d66e025
MB
3585 if ( m_currentCellCoords.GetCol() >= m_numCols )
3586 m_currentCellCoords.Set( 0, 0 );
3587
3588 int w = 0;
3589 for ( i = 0; i < m_numCols; i++ )
3590 {
3591 w += m_colWidths[i];
3592 m_colRights[i] = w;
3593 }
f85afd4e
MB
3594 }
3595 CalcDimensions();
3596 }
3597 return TRUE;
3598 }
3599
3600 return FALSE;
3601}
3602
3603
2d66e025 3604void wxGrid::CalcRowLabelsExposed( wxRegion& reg )
f85afd4e 3605{
2d66e025
MB
3606 wxRegionIterator iter( reg );
3607 wxRect r;
f85afd4e 3608
2d66e025 3609 m_rowLabelsExposed.Empty();
f85afd4e 3610
2d66e025
MB
3611 int top, bottom;
3612 while ( iter )
f85afd4e 3613 {
2d66e025 3614 r = iter.GetRect();
f85afd4e 3615
2d66e025
MB
3616 // TODO: remove this when we can...
3617 // There is a bug in wxMotif that gives garbage update
3618 // rectangles if you jump-scroll a long way by clicking the
3619 // scrollbar with middle button. This is a work-around
3620 //
3621#if defined(__WXMOTIF__)
3622 int cw, ch;
3623 m_gridWin->GetClientSize( &cw, &ch );
3624 if ( r.GetTop() > ch ) r.SetTop( 0 );
3625 r.SetBottom( wxMin( r.GetBottom(), ch ) );
3626#endif
f85afd4e 3627
2d66e025
MB
3628 // logical bounds of update region
3629 //
3630 int dummy;
3631 CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
3632 CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
3633
3634 // find the row labels within these bounds
3635 //
3636 int row;
2d66e025
MB
3637 for ( row = 0; row < m_numRows; row++ )
3638 {
7c1cb261
VZ
3639 if ( GetRowBottom(row) < top )
3640 continue;
2d66e025 3641
6d55126d 3642 if ( GetRowTop(row) > bottom )
7c1cb261 3643 break;
60ff3b99 3644
2d66e025
MB
3645 m_rowLabelsExposed.Add( row );
3646 }
60ff3b99 3647
2d66e025 3648 iter++ ;
f85afd4e
MB
3649 }
3650}
3651
3652
2d66e025 3653void wxGrid::CalcColLabelsExposed( wxRegion& reg )
f85afd4e 3654{
2d66e025
MB
3655 wxRegionIterator iter( reg );
3656 wxRect r;
f85afd4e 3657
2d66e025 3658 m_colLabelsExposed.Empty();
f85afd4e 3659
2d66e025
MB
3660 int left, right;
3661 while ( iter )
f85afd4e 3662 {
2d66e025 3663 r = iter.GetRect();
f85afd4e 3664
2d66e025
MB
3665 // TODO: remove this when we can...
3666 // There is a bug in wxMotif that gives garbage update
3667 // rectangles if you jump-scroll a long way by clicking the
3668 // scrollbar with middle button. This is a work-around
3669 //
3670#if defined(__WXMOTIF__)
3671 int cw, ch;
3672 m_gridWin->GetClientSize( &cw, &ch );
3673 if ( r.GetLeft() > cw ) r.SetLeft( 0 );
3674 r.SetRight( wxMin( r.GetRight(), cw ) );
3675#endif
3676
3677 // logical bounds of update region
3678 //
3679 int dummy;
3680 CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
3681 CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
3682
3683 // find the cells within these bounds
3684 //
3685 int col;
2d66e025
MB
3686 for ( col = 0; col < m_numCols; col++ )
3687 {
7c1cb261
VZ
3688 if ( GetColRight(col) < left )
3689 continue;
60ff3b99 3690
7c1cb261
VZ
3691 if ( GetColLeft(col) > right )
3692 break;
2d66e025
MB
3693
3694 m_colLabelsExposed.Add( col );
3695 }
60ff3b99 3696
2d66e025 3697 iter++ ;
f85afd4e
MB
3698 }
3699}
3700
3701
2d66e025 3702void wxGrid::CalcCellsExposed( wxRegion& reg )
f85afd4e 3703{
2d66e025
MB
3704 wxRegionIterator iter( reg );
3705 wxRect r;
f85afd4e 3706
2d66e025
MB
3707 m_cellsExposed.Empty();
3708 m_rowsExposed.Empty();
3709 m_colsExposed.Empty();
f85afd4e 3710
2d66e025
MB
3711 int left, top, right, bottom;
3712 while ( iter )
3713 {
3714 r = iter.GetRect();
f85afd4e 3715
2d66e025
MB
3716 // TODO: remove this when we can...
3717 // There is a bug in wxMotif that gives garbage update
3718 // rectangles if you jump-scroll a long way by clicking the
3719 // scrollbar with middle button. This is a work-around
3720 //
3721#if defined(__WXMOTIF__)
f85afd4e 3722 int cw, ch;
2d66e025
MB
3723 m_gridWin->GetClientSize( &cw, &ch );
3724 if ( r.GetTop() > ch ) r.SetTop( 0 );
3725 if ( r.GetLeft() > cw ) r.SetLeft( 0 );
3726 r.SetRight( wxMin( r.GetRight(), cw ) );
3727 r.SetBottom( wxMin( r.GetBottom(), ch ) );
3728#endif
8f177c8e 3729
2d66e025
MB
3730 // logical bounds of update region
3731 //
3732 CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
3733 CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
f85afd4e 3734
2d66e025 3735 // find the cells within these bounds
f85afd4e 3736 //
2d66e025 3737 int row, col;
2d66e025 3738 for ( row = 0; row < m_numRows; row++ )
f85afd4e 3739 {
7c1cb261
VZ
3740 if ( GetRowBottom(row) <= top )
3741 continue;
f85afd4e 3742
7c1cb261
VZ
3743 if ( GetRowTop(row) > bottom )
3744 break;
60ff3b99 3745
2d66e025 3746 m_rowsExposed.Add( row );
f85afd4e 3747
2d66e025
MB
3748 for ( col = 0; col < m_numCols; col++ )
3749 {
7c1cb261
VZ
3750 if ( GetColRight(col) <= left )
3751 continue;
60ff3b99 3752
7c1cb261
VZ
3753 if ( GetColLeft(col) > right )
3754 break;
60ff3b99 3755
7c1cb261
VZ
3756 if ( m_colsExposed.Index( col ) == wxNOT_FOUND )
3757 m_colsExposed.Add( col );
2d66e025
MB
3758 m_cellsExposed.Add( wxGridCellCoords( row, col ) );
3759 }
3760 }
60ff3b99 3761
7c1cb261 3762 iter++;
f85afd4e
MB
3763 }
3764}
3765
3766
2d66e025 3767void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
f85afd4e 3768{
2d66e025
MB
3769 int x, y, row;
3770 wxPoint pos( event.GetPosition() );
3771 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
60ff3b99 3772
2d66e025 3773 if ( event.Dragging() )
f85afd4e
MB
3774 {
3775 m_isDragging = TRUE;
8f177c8e 3776
2d66e025 3777 if ( event.LeftIsDown() )
f85afd4e
MB
3778 {
3779 switch( m_cursorMode )
3780 {
f85afd4e
MB
3781 case WXGRID_CURSOR_RESIZE_ROW:
3782 {
2d66e025
MB
3783 int cw, ch, left, dummy;
3784 m_gridWin->GetClientSize( &cw, &ch );
3785 CalcUnscrolledPosition( 0, 0, &left, &dummy );
60ff3b99 3786
2d66e025
MB
3787 wxClientDC dc( m_gridWin );
3788 PrepareDC( dc );
af547d51
VZ
3789 y = wxMax( y,
3790 GetRowTop(m_dragRowOrCol) +
3791 GetRowMinimalHeight(m_dragRowOrCol) );
d2fdd8d2 3792 dc.SetLogicalFunction(wxINVERT);
f85afd4e
MB
3793 if ( m_dragLastPos >= 0 )
3794 {
2d66e025 3795 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
f85afd4e 3796 }
2d66e025
MB
3797 dc.DrawLine( left, y, left+cw, y );
3798 m_dragLastPos = y;
f85afd4e
MB
3799 }
3800 break;
3801
3802 case WXGRID_CURSOR_SELECT_ROW:
f85afd4e
MB
3803 if ( (row = YToRow( y )) >= 0 &&
3804 !IsInSelection( row, 0 ) )
3805 {
3806 SelectRow( row, TRUE );
3807 }
e2b42eeb
VZ
3808
3809 // default label to suppress warnings about "enumeration value
3810 // 'xxx' not handled in switch
3811 default:
3812 break;
f85afd4e
MB
3813 }
3814 }
3815 return;
3816 }
3817
3818 m_isDragging = FALSE;
8f177c8e 3819
60ff3b99 3820
6d004f67
MB
3821 // ------------ Entering or leaving the window
3822 //
3823 if ( event.Entering() || event.Leaving() )
3824 {
e2b42eeb 3825 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
6d004f67
MB
3826 }
3827
e2b42eeb 3828
2d66e025 3829 // ------------ Left button pressed
f85afd4e 3830 //
6d004f67 3831 else if ( event.LeftDown() )
f85afd4e 3832 {
2d66e025
MB
3833 // don't send a label click event for a hit on the
3834 // edge of the row label - this is probably the user
3835 // wanting to resize the row
3836 //
3837 if ( YToEdgeOfRow(y) < 0 )
f85afd4e 3838 {
2d66e025 3839 row = YToRow(y);
58dd5b3b 3840 if ( row >= 0 &&
b54ba671 3841 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
f85afd4e 3842 {
2d66e025 3843 SelectRow( row, event.ShiftDown() );
e2b42eeb 3844 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
f85afd4e 3845 }
2d66e025
MB
3846 }
3847 else
3848 {
3849 // starting to drag-resize a row
3850 //
6e8524b1
MB
3851 if ( CanDragRowSize() )
3852 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
2d66e025
MB
3853 }
3854 }
f85afd4e 3855
f85afd4e 3856
2d66e025
MB
3857 // ------------ Left double click
3858 //
3859 else if (event.LeftDClick() )
3860 {
3861 if ( YToEdgeOfRow(y) < 0 )
3862 {
3863 row = YToRow(y);
b54ba671 3864 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event );
f85afd4e
MB
3865 }
3866 }
60ff3b99
VZ
3867
3868
2d66e025 3869 // ------------ Left button released
f85afd4e 3870 //
2d66e025 3871 else if ( event.LeftUp() )
f85afd4e 3872 {
2d66e025 3873 if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
f85afd4e 3874 {
6d004f67 3875 DoEndDragResizeRow();
60ff3b99 3876
6d004f67
MB
3877 // Note: we are ending the event *after* doing
3878 // default processing in this case
3879 //
b54ba671 3880 SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
2d66e025 3881 }
f85afd4e 3882
e2b42eeb
VZ
3883 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
3884 m_dragLastPos = -1;
2d66e025 3885 }
f85afd4e 3886
f85afd4e 3887
2d66e025
MB
3888 // ------------ Right button down
3889 //
3890 else if ( event.RightDown() )
3891 {
3892 row = YToRow(y);
b54ba671 3893 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
2d66e025
MB
3894 {
3895 // no default action at the moment
f85afd4e
MB
3896 }
3897 }
60ff3b99
VZ
3898
3899
2d66e025 3900 // ------------ Right double click
f85afd4e 3901 //
2d66e025
MB
3902 else if ( event.RightDClick() )
3903 {
3904 row = YToRow(y);
b54ba671 3905 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
2d66e025
MB
3906 {
3907 // no default action at the moment
3908 }
3909 }
60ff3b99
VZ
3910
3911
2d66e025 3912 // ------------ No buttons down and mouse moving
f85afd4e 3913 //
2d66e025 3914 else if ( event.Moving() )
f85afd4e 3915 {
2d66e025
MB
3916 m_dragRowOrCol = YToEdgeOfRow( y );
3917 if ( m_dragRowOrCol >= 0 )
8f177c8e 3918 {
2d66e025 3919 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
8f177c8e 3920 {
e2b42eeb 3921 // don't capture the mouse yet
6e8524b1
MB
3922 if ( CanDragRowSize() )
3923 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, FALSE);
8f177c8e 3924 }
2d66e025 3925 }
6d004f67 3926 else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
2d66e025 3927 {
e2b42eeb 3928 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, FALSE);
8f177c8e 3929 }
f85afd4e 3930 }
2d66e025
MB
3931}
3932
3933
3934void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
3935{
3936 int x, y, col;
3937 wxPoint pos( event.GetPosition() );
3938 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
60ff3b99 3939
2d66e025 3940 if ( event.Dragging() )
f85afd4e 3941 {
2d66e025 3942 m_isDragging = TRUE;
8f177c8e 3943
2d66e025 3944 if ( event.LeftIsDown() )
8f177c8e 3945 {
2d66e025 3946 switch( m_cursorMode )
8f177c8e 3947 {
2d66e025 3948 case WXGRID_CURSOR_RESIZE_COL:
8f177c8e 3949 {
2d66e025
MB
3950 int cw, ch, dummy, top;
3951 m_gridWin->GetClientSize( &cw, &ch );
3952 CalcUnscrolledPosition( 0, 0, &dummy, &top );
60ff3b99 3953
2d66e025
MB
3954 wxClientDC dc( m_gridWin );
3955 PrepareDC( dc );
43947979
VZ
3956
3957 x = wxMax( x, GetColLeft(m_dragRowOrCol) +
3958 GetColMinimalWidth(m_dragRowOrCol));
d2fdd8d2 3959 dc.SetLogicalFunction(wxINVERT);
2d66e025
MB
3960 if ( m_dragLastPos >= 0 )
3961 {
3962 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
3963 }
3964 dc.DrawLine( x, top, x, top+ch );
3965 m_dragLastPos = x;
f85afd4e 3966 }
2d66e025 3967 break;
f85afd4e 3968
2d66e025 3969 case WXGRID_CURSOR_SELECT_COL:
2d66e025
MB
3970 if ( (col = XToCol( x )) >= 0 &&
3971 !IsInSelection( 0, col ) )
3972 {
3973 SelectCol( col, TRUE );
3974 }
e2b42eeb
VZ
3975
3976 // default label to suppress warnings about "enumeration value
3977 // 'xxx' not handled in switch
3978 default:
3979 break;
2d66e025 3980 }
f85afd4e 3981 }
2d66e025 3982 return;
f85afd4e 3983 }
2d66e025
MB
3984
3985 m_isDragging = FALSE;
3986
60ff3b99 3987
6d004f67
MB
3988 // ------------ Entering or leaving the window
3989 //
3990 if ( event.Entering() || event.Leaving() )
3991 {
e2b42eeb 3992 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
6d004f67
MB
3993 }
3994
e2b42eeb 3995
2d66e025 3996 // ------------ Left button pressed
f85afd4e 3997 //
6d004f67 3998 else if ( event.LeftDown() )
f85afd4e 3999 {
2d66e025
MB
4000 // don't send a label click event for a hit on the
4001 // edge of the col label - this is probably the user
4002 // wanting to resize the col
4003 //
4004 if ( XToEdgeOfCol(x) < 0 )
8f177c8e 4005 {
2d66e025 4006 col = XToCol(x);
58dd5b3b 4007 if ( col >= 0 &&
b54ba671 4008 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
8f177c8e 4009 {
2d66e025 4010 SelectCol( col, event.ShiftDown() );
e2b42eeb 4011 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
f85afd4e 4012 }
2d66e025
MB
4013 }
4014 else
4015 {
4016 // starting to drag-resize a col
4017 //
6e8524b1
MB
4018 if ( CanDragColSize() )
4019 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
2d66e025
MB
4020 }
4021 }
f85afd4e 4022
f85afd4e 4023
2d66e025
MB
4024 // ------------ Left double click
4025 //
4026 if ( event.LeftDClick() )
4027 {
4028 if ( XToEdgeOfCol(x) < 0 )
4029 {
4030 col = XToCol(x);
b54ba671 4031 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event );
2d66e025
MB
4032 }
4033 }
60ff3b99
VZ
4034
4035
2d66e025
MB
4036 // ------------ Left button released
4037 //
4038 else if ( event.LeftUp() )
4039 {
4040 if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
4041 {
6d004f67 4042 DoEndDragResizeCol();
e2b42eeb 4043
6d004f67
MB
4044 // Note: we are ending the event *after* doing
4045 // default processing in this case
4046 //
b54ba671 4047 SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
2d66e025 4048 }
f85afd4e 4049
e2b42eeb 4050 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
2d66e025 4051 m_dragLastPos = -1;
60ff3b99
VZ
4052 }
4053
4054
2d66e025
MB
4055 // ------------ Right button down
4056 //
4057 else if ( event.RightDown() )
4058 {
4059 col = XToCol(x);
b54ba671 4060 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
2d66e025
MB
4061 {
4062 // no default action at the moment
f85afd4e
MB
4063 }
4064 }
60ff3b99
VZ
4065
4066
2d66e025 4067 // ------------ Right double click
f85afd4e 4068 //
2d66e025
MB
4069 else if ( event.RightDClick() )
4070 {
4071 col = XToCol(x);
b54ba671 4072 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
2d66e025
MB
4073 {
4074 // no default action at the moment
4075 }
4076 }
60ff3b99
VZ
4077
4078
2d66e025 4079 // ------------ No buttons down and mouse moving
f85afd4e 4080 //
2d66e025 4081 else if ( event.Moving() )
f85afd4e 4082 {
2d66e025
MB
4083 m_dragRowOrCol = XToEdgeOfCol( x );
4084 if ( m_dragRowOrCol >= 0 )
f85afd4e 4085 {
2d66e025 4086 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
f85afd4e 4087 {
e2b42eeb 4088 // don't capture the cursor yet
6e8524b1
MB
4089 if ( CanDragColSize() )
4090 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, FALSE);
f85afd4e 4091 }
2d66e025 4092 }
6d004f67 4093 else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
2d66e025 4094 {
e2b42eeb 4095 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, FALSE);
8f177c8e 4096 }
f85afd4e
MB
4097 }
4098}
4099
4100
2d66e025 4101void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
f85afd4e 4102{
2d66e025 4103 if ( event.LeftDown() )
f85afd4e 4104 {
2d66e025
MB
4105 // indicate corner label by having both row and
4106 // col args == -1
f85afd4e 4107 //
b54ba671 4108 if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
2d66e025
MB
4109 {
4110 SelectAll();
4111 }
f85afd4e
MB
4112 }
4113
2d66e025
MB
4114 else if ( event.LeftDClick() )
4115 {
b54ba671 4116 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
2d66e025 4117 }
8f177c8e 4118
2d66e025 4119 else if ( event.RightDown() )
f85afd4e 4120 {
b54ba671 4121 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
f85afd4e 4122 {
2d66e025
MB
4123 // no default action at the moment
4124 }
4125 }
f85afd4e 4126
2d66e025
MB
4127 else if ( event.RightDClick() )
4128 {
b54ba671 4129 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
2d66e025
MB
4130 {
4131 // no default action at the moment
4132 }
4133 }
4134}
f85afd4e 4135
e2b42eeb
VZ
4136void wxGrid::ChangeCursorMode(CursorMode mode,
4137 wxWindow *win,
4138 bool captureMouse)
4139{
4140#ifdef __WXDEBUG__
4141 static const wxChar *cursorModes[] =
4142 {
4143 _T("SELECT_CELL"),
4144 _T("RESIZE_ROW"),
4145 _T("RESIZE_COL"),
4146 _T("SELECT_ROW"),
4147 _T("SELECT_COL")
4148 };
4149
181bfffd
VZ
4150 wxLogTrace(_T("grid"),
4151 _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
e2b42eeb
VZ
4152 win == m_colLabelWin ? _T("colLabelWin")
4153 : win ? _T("rowLabelWin")
4154 : _T("gridWin"),
4155 cursorModes[m_cursorMode], cursorModes[mode]);
4156#endif // __WXDEBUG__
4157
4158 if ( mode == m_cursorMode )
4159 return;
4160
4161 if ( !win )
4162 {
4163 // by default use the grid itself
4164 win = m_gridWin;
4165 }
4166
4167 if ( m_winCapture )
4168 {
4169 m_winCapture->ReleaseMouse();
4170 m_winCapture = (wxWindow *)NULL;
4171 }
4172
4173 m_cursorMode = mode;
4174
4175 switch ( m_cursorMode )
4176 {
4177 case WXGRID_CURSOR_RESIZE_ROW:
4178 win->SetCursor( m_rowResizeCursor );
4179 break;
4180
4181 case WXGRID_CURSOR_RESIZE_COL:
4182 win->SetCursor( m_colResizeCursor );
4183 break;
4184
4185 default:
4186 win->SetCursor( *wxSTANDARD_CURSOR );
4187 }
4188
4189 // we need to capture mouse when resizing
4190 bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
4191 m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
4192
4193 if ( captureMouse && resize )
4194 {
4195 win->CaptureMouse();
4196 m_winCapture = win;
4197 }
4198}
8f177c8e 4199
2d66e025
MB
4200void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
4201{
4202 int x, y;
4203 wxPoint pos( event.GetPosition() );
4204 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
60ff3b99 4205
2d66e025
MB
4206 wxGridCellCoords coords;
4207 XYToCell( x, y, coords );
60ff3b99 4208
2d66e025
MB
4209 if ( event.Dragging() )
4210 {
07296f0b
RD
4211 //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
4212
4213 // Don't start doing anything until the mouse has been drug at
4214 // least 3 pixels in any direction...
508011ce
VZ
4215 if (! m_isDragging)
4216 {
4217 if (m_startDragPos == wxDefaultPosition)
4218 {
07296f0b
RD
4219 m_startDragPos = pos;
4220 return;
4221 }
4222 if (abs(m_startDragPos.x - pos.x) < 4 && abs(m_startDragPos.y - pos.y) < 4)
4223 return;
4224 }
4225
2d66e025 4226 m_isDragging = TRUE;
2d66e025
MB
4227 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4228 {
f0102d2a
VZ
4229 // Hide the edit control, so it
4230 // won't interfer with drag-shrinking.
4231 if ( IsCellEditControlEnabled() )
a5777624 4232 {
f0102d2a 4233 HideCellEditControl();
a5777624
RD
4234 SaveEditControlValue();
4235 }
07296f0b
RD
4236
4237 // Have we captured the mouse yet?
508011ce
VZ
4238 if (! m_winCapture)
4239 {
07296f0b
RD
4240 m_winCapture = m_gridWin;
4241 m_winCapture->CaptureMouse();
4242 }
4243
2d66e025
MB
4244 if ( coords != wxGridNoCellCoords )
4245 {
4246 if ( !IsSelection() )
f85afd4e 4247 {
2d66e025 4248 SelectBlock( coords, coords );
f85afd4e
MB
4249 }
4250 else
4251 {
f0102d2a 4252 SelectBlock( m_currentCellCoords, coords );
f85afd4e 4253 }
07296f0b 4254
508011ce
VZ
4255 if (! IsVisible(coords))
4256 {
07296f0b
RD
4257 MakeCellVisible(coords);
4258 // TODO: need to introduce a delay or something here. The
4259 // scrolling is way to fast, at least on MSW.
4260 }
2d66e025
MB
4261 }
4262 }
6d004f67
MB
4263 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4264 {
4265 int cw, ch, left, dummy;
4266 m_gridWin->GetClientSize( &cw, &ch );
4267 CalcUnscrolledPosition( 0, 0, &left, &dummy );
8f177c8e 4268
6d004f67
MB
4269 wxClientDC dc( m_gridWin );
4270 PrepareDC( dc );
a95e38c0
VZ
4271 y = wxMax( y, GetRowTop(m_dragRowOrCol) +
4272 GetRowMinimalHeight(m_dragRowOrCol) );
6d004f67
MB
4273 dc.SetLogicalFunction(wxINVERT);
4274 if ( m_dragLastPos >= 0 )
4275 {
4276 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4277 }
4278 dc.DrawLine( left, y, left+cw, y );
4279 m_dragLastPos = y;
4280 }
4281 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
4282 {
4283 int cw, ch, dummy, top;
4284 m_gridWin->GetClientSize( &cw, &ch );
4285 CalcUnscrolledPosition( 0, 0, &dummy, &top );
e2b42eeb 4286
6d004f67
MB
4287 wxClientDC dc( m_gridWin );
4288 PrepareDC( dc );
43947979
VZ
4289 x = wxMax( x, GetColLeft(m_dragRowOrCol) +
4290 GetColMinimalWidth(m_dragRowOrCol) );
6d004f67
MB
4291 dc.SetLogicalFunction(wxINVERT);
4292 if ( m_dragLastPos >= 0 )
4293 {
4294 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
4295 }
4296 dc.DrawLine( x, top, x, top+ch );
4297 m_dragLastPos = x;
4298 }
e2b42eeb 4299
2d66e025
MB
4300 return;
4301 }
66242c80 4302
2d66e025 4303 m_isDragging = FALSE;
07296f0b
RD
4304 m_startDragPos = wxDefaultPosition;
4305
a5777624
RD
4306 // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
4307 // immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
4308 // wxGTK
e2b42eeb 4309#if 0
a5777624
RD
4310 if ( event.Entering() || event.Leaving() )
4311 {
4312 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
4313 m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
4314 }
4315 else
e2b42eeb
VZ
4316#endif // 0
4317
a5777624
RD
4318 // ------------ Left button pressed
4319 //
4320 if ( event.LeftDown() && coords != wxGridNoCellCoords )
4321 {
b5808881
SN
4322 if ( !event.ShiftDown() && !event.ControlDown() )
4323 ClearSelection();
a5777624 4324 if ( event.ShiftDown() )
2d66e025 4325 {
5c8fc7c1
SN
4326 m_selection->SelectBlock( m_currentCellCoords.GetRow(),
4327 m_currentCellCoords.GetCol(),
4328 coords.GetRow(),
d95b0c2b
SN
4329 coords.GetCol(),
4330 event.ControlDown(),
4331 event.ShiftDown(),
4332 event.AltDown(),
4333 event.MetaDown() );
a5777624
RD
4334 }
4335 else if ( XToEdgeOfCol(x) < 0 &&
4336 YToEdgeOfRow(y) < 0 )
4337 {
4338 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,
4339 coords.GetRow(),
4340 coords.GetCol(),
4341 event ) )
58dd5b3b 4342 {
a5777624
RD
4343 DisableCellEditControl();
4344 MakeCellVisible( coords );
4345
4346 // if this is the second click on this cell then start
4347 // the edit control
4348 if ( m_waitForSlowClick &&
4349 (coords == m_currentCellCoords) &&
4350 CanEnableCellControl())
58dd5b3b 4351 {
a5777624 4352 EnableCellEditControl();
e195a54c 4353
a5777624 4354 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
0b190b0f
VZ
4355 wxGridCellEditor *editor = attr->GetEditor(this,
4356 coords.GetRow(),
4357 coords.GetCol());
4358 editor->StartingClick();
4359 editor->DecRef();
a5777624 4360 attr->DecRef();
e195a54c 4361
a5777624
RD
4362 m_waitForSlowClick = FALSE;
4363 }
4364 else
4365 {
b5808881 4366 m_selection->ToggleCellSelection( coords.GetRow(),
d95b0c2b
SN
4367 coords.GetCol(),
4368 event.ControlDown(),
4369 event.ShiftDown(),
4370 event.AltDown(),
4371 event.MetaDown() );
b5808881
SN
4372 m_selectingTopLeft = wxGridNoCellCoords;
4373 m_selectingBottomRight = wxGridNoCellCoords;
a5777624
RD
4374 SetCurrentCell( coords );
4375 m_waitForSlowClick = TRUE;
58dd5b3b
MB
4376 }
4377 }
f85afd4e 4378 }
a5777624 4379 }
f85afd4e 4380
f85afd4e 4381
a5777624
RD
4382 // ------------ Left double click
4383 //
4384 else if ( event.LeftDClick() && coords != wxGridNoCellCoords )
4385 {
4386 DisableCellEditControl();
4387
4388 if ( XToEdgeOfCol(x) < 0 && YToEdgeOfRow(y) < 0 )
58dd5b3b 4389 {
a5777624
RD
4390 SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK,
4391 coords.GetRow(),
4392 coords.GetCol(),
4393 event );
58dd5b3b 4394 }
a5777624 4395 }
f85afd4e 4396
8f177c8e 4397
a5777624
RD
4398 // ------------ Left button released
4399 //
4400 else if ( event.LeftUp() )
4401 {
4402 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
f85afd4e 4403 {
b5808881
SN
4404 if ( m_selectingTopLeft != wxGridNoCellCoords &&
4405 m_selectingBottomRight != wxGridNoCellCoords )
52068ea5 4406 {
a5777624 4407 if (m_winCapture)
58dd5b3b 4408 {
a5777624
RD
4409 m_winCapture->ReleaseMouse();
4410 m_winCapture = NULL;
58dd5b3b 4411 }
5c8fc7c1
SN
4412 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
4413 m_selectingTopLeft.GetCol(),
4414 m_selectingBottomRight.GetRow(),
4415 m_selectingBottomRight.GetCol(),
d95b0c2b
SN
4416 event.ControlDown(),
4417 event.ShiftDown(),
4418 event.AltDown(),
4419 event.MetaDown() );
5c8fc7c1
SN
4420 m_selectingTopLeft = wxGridNoCellCoords;
4421 m_selectingBottomRight = wxGridNoCellCoords;
6d004f67 4422 }
2d66e025 4423
a5777624
RD
4424 // Show the edit control, if it has been hidden for
4425 // drag-shrinking.
4426 ShowCellEditControl();
4427 }
4428 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4429 {
4430 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
4431 DoEndDragResizeRow();
e2b42eeb 4432
a5777624
RD
4433 // Note: we are ending the event *after* doing
4434 // default processing in this case
4435 //
4436 SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
4437 }
4438 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
4439 {
4440 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
4441 DoEndDragResizeCol();
e2b42eeb 4442
a5777624
RD
4443 // Note: we are ending the event *after* doing
4444 // default processing in this case
4445 //
4446 SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
58dd5b3b 4447 }
f85afd4e 4448
a5777624
RD
4449 m_dragLastPos = -1;
4450 }
4451
f85afd4e 4452
a5777624
RD
4453 // ------------ Right button down
4454 //
4455 else if ( event.RightDown() && coords != wxGridNoCellCoords )
4456 {
4457 DisableCellEditControl();
4458 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK,
4459 coords.GetRow(),
4460 coords.GetCol(),
4461 event ) )
f85afd4e 4462 {
a5777624 4463 // no default action at the moment
60ff3b99 4464 }
a5777624 4465 }
2d66e025 4466
60ff3b99 4467
a5777624
RD
4468 // ------------ Right double click
4469 //
4470 else if ( event.RightDClick() && coords != wxGridNoCellCoords )
4471 {
4472 DisableCellEditControl();
4473 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK,
4474 coords.GetRow(),
4475 coords.GetCol(),
4476 event ) )
f85afd4e 4477 {
a5777624 4478 // no default action at the moment
60ff3b99 4479 }
a5777624
RD
4480 }
4481
4482 // ------------ Moving and no button action
4483 //
4484 else if ( event.Moving() && !event.IsButton() )
4485 {
4486 int dragRow = YToEdgeOfRow( y );
4487 int dragCol = XToEdgeOfCol( x );
790cc417 4488
a5777624
RD
4489 // Dragging on the corner of a cell to resize in both
4490 // directions is not implemented yet...
790cc417 4491 //
a5777624 4492 if ( dragRow >= 0 && dragCol >= 0 )
790cc417 4493 {
a5777624
RD
4494 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
4495 return;
4496 }
6d004f67 4497
a5777624
RD
4498 if ( dragRow >= 0 )
4499 {
4500 m_dragRowOrCol = dragRow;
6d004f67 4501
a5777624 4502 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
6d004f67 4503 {
a5777624
RD
4504 if ( CanDragRowSize() && CanDragGridSize() )
4505 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
6d004f67 4506 }
e2b42eeb 4507
b94ae1ea
VZ
4508 if ( dragCol >= 0 )
4509 {
4510 m_dragRowOrCol = dragCol;
122603f1 4511 }
b94ae1ea 4512
a5777624
RD
4513 return;
4514 }
e2b42eeb 4515
a5777624
RD
4516 if ( dragCol >= 0 )
4517 {
4518 m_dragRowOrCol = dragCol;
e2b42eeb 4519
a5777624 4520 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
6d004f67 4521 {
a5777624
RD
4522 if ( CanDragColSize() && CanDragGridSize() )
4523 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
6d004f67 4524 }
a5777624
RD
4525
4526 return;
6d004f67 4527 }
a5777624
RD
4528
4529 // Neither on a row or col edge
4530 //
4531 if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4532 {
4533 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
4534 }
4535 }
6d004f67
MB
4536}
4537
4538
4539void wxGrid::DoEndDragResizeRow()
4540{
4541 if ( m_dragLastPos >= 0 )
4542 {
4543 // erase the last line and resize the row
4544 //
4545 int cw, ch, left, dummy;
4546 m_gridWin->GetClientSize( &cw, &ch );
4547 CalcUnscrolledPosition( 0, 0, &left, &dummy );
4548
4549 wxClientDC dc( m_gridWin );
4550 PrepareDC( dc );
4551 dc.SetLogicalFunction( wxINVERT );
4552 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4553 HideCellEditControl();
a5777624 4554 SaveEditControlValue();
6d004f67 4555
7c1cb261 4556 int rowTop = GetRowTop(m_dragRowOrCol);
6d004f67
MB
4557 SetRowSize( m_dragRowOrCol,
4558 wxMax( m_dragLastPos - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
e2b42eeb 4559
6d004f67
MB
4560 if ( !GetBatchCount() )
4561 {
4562 // Only needed to get the correct rect.y:
4563 wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
4564 rect.x = 0;
4565 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
4566 rect.width = m_rowLabelWidth;
4567 rect.height = ch - rect.y;
4568 m_rowLabelWin->Refresh( TRUE, &rect );
4569 rect.width = cw;
4570 m_gridWin->Refresh( FALSE, &rect );
4571 }
4572
4573 ShowCellEditControl();
4574 }
4575}
4576
4577
4578void wxGrid::DoEndDragResizeCol()
4579{
4580 if ( m_dragLastPos >= 0 )
4581 {
4582 // erase the last line and resize the col
4583 //
4584 int cw, ch, dummy, top;
4585 m_gridWin->GetClientSize( &cw, &ch );
4586 CalcUnscrolledPosition( 0, 0, &dummy, &top );
4587
4588 wxClientDC dc( m_gridWin );
4589 PrepareDC( dc );
4590 dc.SetLogicalFunction( wxINVERT );
4591 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
4592 HideCellEditControl();
a5777624 4593 SaveEditControlValue();
6d004f67 4594
7c1cb261 4595 int colLeft = GetColLeft(m_dragRowOrCol);
6d004f67 4596 SetColSize( m_dragRowOrCol,
43947979
VZ
4597 wxMax( m_dragLastPos - colLeft,
4598 GetColMinimalWidth(m_dragRowOrCol) ) );
6d004f67
MB
4599
4600 if ( !GetBatchCount() )
4601 {
4602 // Only needed to get the correct rect.x:
4603 wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
4604 rect.y = 0;
4605 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
4606 rect.width = cw - rect.x;
4607 rect.height = m_colLabelHeight;
4608 m_colLabelWin->Refresh( TRUE, &rect );
4609 rect.height = ch;
4610 m_gridWin->Refresh( FALSE, &rect );
790cc417 4611 }
e2b42eeb 4612
6d004f67 4613 ShowCellEditControl();
f85afd4e 4614 }
f85afd4e
MB
4615}
4616
4617
6d004f67 4618
2d66e025
MB
4619//
4620// ------ interaction with data model
4621//
4622bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
f85afd4e 4623{
2d66e025 4624 switch ( msg.GetId() )
17732cec 4625 {
2d66e025
MB
4626 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
4627 return GetModelValues();
17732cec 4628
2d66e025
MB
4629 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
4630 return SetModelValues();
f85afd4e 4631
2d66e025
MB
4632 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
4633 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4634 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4635 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4636 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4637 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
4638 return Redimension( msg );
4639
4640 default:
4641 return FALSE;
f85afd4e 4642 }
2d66e025 4643}
f85afd4e 4644
f85afd4e 4645
f85afd4e 4646
2d66e025
MB
4647// The behaviour of this function depends on the grid table class
4648// Clear() function. For the default wxGridStringTable class the
4649// behavious is to replace all cell contents with wxEmptyString but
4650// not to change the number of rows or cols.
4651//
4652void wxGrid::ClearGrid()
4653{
4654 if ( m_table )
f85afd4e 4655 {
4cfa5de6
RD
4656 if (IsCellEditControlEnabled())
4657 DisableCellEditControl();
4658
2d66e025 4659 m_table->Clear();
1f1ce288 4660 if ( !GetBatchCount() ) m_gridWin->Refresh();
f85afd4e
MB
4661 }
4662}
4663
4664
2d66e025 4665bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
f85afd4e 4666{
2d66e025 4667 // TODO: something with updateLabels flag
8f177c8e 4668
2d66e025 4669 if ( !m_created )
f85afd4e 4670 {
bd3c6758 4671 wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
2d66e025
MB
4672 return FALSE;
4673 }
8f177c8e 4674
2d66e025
MB
4675 if ( m_table )
4676 {
b7fff980 4677 if (IsCellEditControlEnabled())
b54ba671 4678 DisableCellEditControl();
b7fff980 4679
2d66e025 4680 bool ok = m_table->InsertRows( pos, numRows );
f85afd4e 4681
2d66e025
MB
4682 // the table will have sent the results of the insert row
4683 // operation to this view object as a grid table message
4684 //
4685 if ( ok )
4686 {
4687 if ( m_numCols == 0 )
f85afd4e 4688 {
2d66e025
MB
4689 m_table->AppendCols( WXGRID_DEFAULT_NUMBER_COLS );
4690 //
4691 // TODO: perhaps instead of appending the default number of cols
4692 // we should remember what the last non-zero number of cols was ?
4693 //
4694 }
8f177c8e 4695
2d66e025
MB
4696 if ( m_currentCellCoords == wxGridNoCellCoords )
4697 {
4698 // if we have just inserted cols into an empty grid the current
4699 // cell will be undefined...
4700 //
4701 SetCurrentCell( 0, 0 );
f85afd4e
MB
4702 }
4703
b5808881 4704 m_selection->UpdateRows( pos, numRows );
2d66e025 4705 if ( !GetBatchCount() ) Refresh();
f85afd4e 4706 }
2d66e025 4707
2d66e025
MB
4708 return ok;
4709 }
4710 else
4711 {
4712 return FALSE;
f85afd4e
MB
4713 }
4714}
4715
4716
2d66e025 4717bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
f85afd4e 4718{
2d66e025
MB
4719 // TODO: something with updateLabels flag
4720
4721 if ( !m_created )
f85afd4e 4722 {
bd3c6758 4723 wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
2d66e025
MB
4724 return FALSE;
4725 }
4726
4727 if ( m_table && m_table->AppendRows( numRows ) )
4728 {
4729 if ( m_currentCellCoords == wxGridNoCellCoords )
4730 {
4731 // if we have just inserted cols into an empty grid the current
4732 // cell will be undefined...
4733 //
4734 SetCurrentCell( 0, 0 );
4735 }
4736
4737 // the table will have sent the results of the append row
4738 // operation to this view object as a grid table message
4739 //
2d66e025
MB
4740 if ( !GetBatchCount() ) Refresh();
4741 return TRUE;
4742 }
4743 else
4744 {
4745 return FALSE;
f85afd4e
MB
4746 }
4747}
4748
2d66e025
MB
4749
4750bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
f85afd4e 4751{
2d66e025
MB
4752 // TODO: something with updateLabels flag
4753
4754 if ( !m_created )
f85afd4e 4755 {
bd3c6758 4756 wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
2d66e025
MB
4757 return FALSE;
4758 }
4759
b7fff980 4760 if ( m_table )
2d66e025 4761 {
b7fff980 4762 if (IsCellEditControlEnabled())
b54ba671 4763 DisableCellEditControl();
f85afd4e 4764
b7fff980
RD
4765 if (m_table->DeleteRows( pos, numRows ))
4766 {
4767
4768 // the table will have sent the results of the delete row
4769 // operation to this view object as a grid table message
4770 //
b5808881 4771 m_selection->UpdateRows( pos, -((int)numRows) );
b7fff980
RD
4772 if ( !GetBatchCount() ) Refresh();
4773 return TRUE;
4774 }
2d66e025 4775 }
b7fff980 4776 return FALSE;
2d66e025 4777}
f85afd4e 4778
f85afd4e 4779
2d66e025
MB
4780bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
4781{
4782 // TODO: something with updateLabels flag
8f177c8e 4783
2d66e025
MB
4784 if ( !m_created )
4785 {
bd3c6758 4786 wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
2d66e025
MB
4787 return FALSE;
4788 }
f85afd4e 4789
2d66e025
MB
4790 if ( m_table )
4791 {
b7fff980 4792 if (IsCellEditControlEnabled())
b54ba671 4793 DisableCellEditControl();
b7fff980 4794
2d66e025
MB
4795 bool ok = m_table->InsertCols( pos, numCols );
4796
4797 // the table will have sent the results of the insert col
4798 // operation to this view object as a grid table message
4799 //
4800 if ( ok )
f85afd4e 4801 {
2d66e025 4802 if ( m_currentCellCoords == wxGridNoCellCoords )
f85afd4e 4803 {
2d66e025
MB
4804 // if we have just inserted cols into an empty grid the current
4805 // cell will be undefined...
4806 //
4807 SetCurrentCell( 0, 0 );
f85afd4e 4808 }
2d66e025 4809
b5808881 4810 m_selection->UpdateCols( pos, numCols );
2d66e025 4811 if ( !GetBatchCount() ) Refresh();
f85afd4e 4812 }
2d66e025 4813
2d66e025
MB
4814 return ok;
4815 }
4816 else
4817 {
4818 return FALSE;
f85afd4e
MB
4819 }
4820}
4821
2d66e025
MB
4822
4823bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
f85afd4e 4824{
2d66e025
MB
4825 // TODO: something with updateLabels flag
4826
4827 if ( !m_created )
f85afd4e 4828 {
bd3c6758 4829 wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
2d66e025
MB
4830 return FALSE;
4831 }
f85afd4e 4832
2d66e025
MB
4833 if ( m_table && m_table->AppendCols( numCols ) )
4834 {
4835 // the table will have sent the results of the append col
4836 // operation to this view object as a grid table message
4837 //
4838 if ( m_currentCellCoords == wxGridNoCellCoords )
f85afd4e 4839 {
2d66e025
MB
4840 // if we have just inserted cols into an empty grid the current
4841 // cell will be undefined...
4842 //
4843 SetCurrentCell( 0, 0 );
f85afd4e 4844 }
8f177c8e 4845
2d66e025
MB
4846 if ( !GetBatchCount() ) Refresh();
4847 return TRUE;
f85afd4e 4848 }
2d66e025 4849 else
f85afd4e 4850 {
2d66e025 4851 return FALSE;
f85afd4e 4852 }
f85afd4e
MB
4853}
4854
4855
2d66e025 4856bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
f85afd4e 4857{
2d66e025 4858 // TODO: something with updateLabels flag
8f177c8e 4859
2d66e025 4860 if ( !m_created )
f85afd4e 4861 {
bd3c6758 4862 wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
2d66e025 4863 return FALSE;
f85afd4e
MB
4864 }
4865
b7fff980 4866 if ( m_table )
2d66e025 4867 {
b7fff980 4868 if (IsCellEditControlEnabled())
b54ba671 4869 DisableCellEditControl();
8f177c8e 4870
b7fff980
RD
4871 if ( m_table->DeleteCols( pos, numCols ) )
4872 {
4873 // the table will have sent the results of the delete col
4874 // operation to this view object as a grid table message
4875 //
b5808881 4876 m_selection->UpdateCols( pos, -((int)numCols) );
b7fff980
RD
4877 if ( !GetBatchCount() ) Refresh();
4878 return TRUE;
4879 }
f85afd4e 4880 }
b7fff980 4881 return FALSE;
f85afd4e
MB
4882}
4883
4884
2d66e025
MB
4885
4886//
4887// ----- event handlers
f85afd4e 4888//
8f177c8e 4889
2d66e025
MB
4890// Generate a grid event based on a mouse event and
4891// return the result of ProcessEvent()
4892//
4893bool wxGrid::SendEvent( const wxEventType type,
4894 int row, int col,
4895 wxMouseEvent& mouseEv )
4896{
b54ba671 4897 if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
f85afd4e 4898 {
2d66e025
MB
4899 int rowOrCol = (row == -1 ? col : row);
4900
4901 wxGridSizeEvent gridEvt( GetId(),
4902 type,
4903 this,
4904 rowOrCol,
4905 mouseEv.GetX(), mouseEv.GetY(),
4906 mouseEv.ControlDown(),
4907 mouseEv.ShiftDown(),
4908 mouseEv.AltDown(),
4909 mouseEv.MetaDown() );
4910
4911 return GetEventHandler()->ProcessEvent(gridEvt);
f85afd4e 4912 }
b54ba671 4913 else if ( type == wxEVT_GRID_RANGE_SELECT )
2d66e025 4914 {
5c8fc7c1 4915 // Right now, it should _never_ end up here!
2d66e025
MB
4916 wxGridRangeSelectEvent gridEvt( GetId(),
4917 type,
4918 this,
b5808881
SN
4919 m_selectingTopLeft,
4920 m_selectingBottomRight,
5c8fc7c1 4921 TRUE,
2d66e025
MB
4922 mouseEv.ControlDown(),
4923 mouseEv.ShiftDown(),
4924 mouseEv.AltDown(),
4925 mouseEv.MetaDown() );
f85afd4e 4926
2d66e025
MB
4927 return GetEventHandler()->ProcessEvent(gridEvt);
4928 }
4929 else
4930 {
4931 wxGridEvent gridEvt( GetId(),
4932 type,
4933 this,
4934 row, col,
d95b0c2b 4935 FALSE,
2d66e025
MB
4936 mouseEv.GetX(), mouseEv.GetY(),
4937 mouseEv.ControlDown(),
4938 mouseEv.ShiftDown(),
4939 mouseEv.AltDown(),
4940 mouseEv.MetaDown() );
8f177c8e 4941
2d66e025
MB
4942 return GetEventHandler()->ProcessEvent(gridEvt);
4943 }
f85afd4e
MB
4944}
4945
4946
2d66e025
MB
4947// Generate a grid event of specified type and return the result
4948// of ProcessEvent().
f85afd4e 4949//
2d66e025
MB
4950bool wxGrid::SendEvent( const wxEventType type,
4951 int row, int col )
f85afd4e 4952{
b54ba671 4953 if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
f85afd4e 4954 {
2d66e025 4955 int rowOrCol = (row == -1 ? col : row);
f85afd4e 4956
2d66e025
MB
4957 wxGridSizeEvent gridEvt( GetId(),
4958 type,
4959 this,
4960 rowOrCol );
4961
4962 return GetEventHandler()->ProcessEvent(gridEvt);
4963 }
4964 else
4965 {
4966 wxGridEvent gridEvt( GetId(),
4967 type,
4968 this,
4969 row, col );
8f177c8e 4970
2d66e025
MB
4971 return GetEventHandler()->ProcessEvent(gridEvt);
4972 }
f85afd4e
MB
4973}
4974
4975
2d66e025 4976void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
f85afd4e 4977{
2d66e025 4978 wxPaintDC dc( this );
8f177c8e 4979}
f85afd4e
MB
4980
4981
18f9565d
MB
4982// This is just here to make sure that CalcDimensions gets called when
4983// the grid view is resized... then the size event is skipped to allow
4984// the box sizers to handle everything
4985//
2d66e025 4986void wxGrid::OnSize( wxSizeEvent& event )
f85afd4e 4987{
7807d81c 4988 CalcWindowSizes();
2d66e025 4989 CalcDimensions();
f85afd4e
MB
4990}
4991
f85afd4e 4992
2d66e025 4993void wxGrid::OnKeyDown( wxKeyEvent& event )
f85afd4e 4994{
2d66e025 4995 if ( m_inOnKeyDown )
f85afd4e 4996 {
2d66e025
MB
4997 // shouldn't be here - we are going round in circles...
4998 //
07296f0b 4999 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
f85afd4e
MB
5000 }
5001
2d66e025 5002 m_inOnKeyDown = TRUE;
f85afd4e 5003
2d66e025
MB
5004 // propagate the event up and see if it gets processed
5005 //
5006 wxWindow *parent = GetParent();
5007 wxKeyEvent keyEvt( event );
5008 keyEvt.SetEventObject( parent );
5009
5010 if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
f85afd4e 5011 {
9b4aede2 5012
2d66e025
MB
5013 // try local handlers
5014 //
d95b0c2b
SN
5015 if ( !event.ShiftDown() &&
5016 m_selectingKeyboard != wxGridNoCellCoords )
5017 {
5018 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
5019 m_selectingTopLeft.GetCol(),
5020 m_selectingBottomRight.GetRow(),
5021 m_selectingBottomRight.GetCol(),
5022 event.ControlDown(),
5023 event.ShiftDown(),
5024 event.AltDown(),
5025 event.MetaDown() );
5026 m_selectingTopLeft = wxGridNoCellCoords;
5027 m_selectingBottomRight = wxGridNoCellCoords;
5028 m_selectingKeyboard = wxGridNoCellCoords;
5029 }
5030
2d66e025
MB
5031 switch ( event.KeyCode() )
5032 {
5033 case WXK_UP:
5034 if ( event.ControlDown() )
5035 {
5c8fc7c1 5036 MoveCursorUpBlock( event.ShiftDown() );
2d66e025
MB
5037 }
5038 else
5039 {
5c8fc7c1 5040 MoveCursorUp( event.ShiftDown() );
2d66e025
MB
5041 }
5042 break;
f85afd4e 5043
2d66e025
MB
5044 case WXK_DOWN:
5045 if ( event.ControlDown() )
5046 {
5c8fc7c1 5047 MoveCursorDownBlock( event.ShiftDown() );
2d66e025
MB
5048 }
5049 else
5050 {
5c8fc7c1 5051 MoveCursorDown( event.ShiftDown() );
2d66e025
MB
5052 }
5053 break;
8f177c8e 5054
2d66e025
MB
5055 case WXK_LEFT:
5056 if ( event.ControlDown() )
5057 {
5c8fc7c1 5058 MoveCursorLeftBlock( event.ShiftDown() );
2d66e025
MB
5059 }
5060 else
5061 {
5c8fc7c1 5062 MoveCursorLeft( event.ShiftDown() );
2d66e025
MB
5063 }
5064 break;
5065
5066 case WXK_RIGHT:
5067 if ( event.ControlDown() )
5068 {
5c8fc7c1 5069 MoveCursorRightBlock( event.ShiftDown() );
2d66e025
MB
5070 }
5071 else
5072 {
5c8fc7c1 5073 MoveCursorRight( event.ShiftDown() );
2d66e025
MB
5074 }
5075 break;
b99be8fb 5076
2d66e025 5077 case WXK_RETURN:
58dd5b3b
MB
5078 if ( event.ControlDown() )
5079 {
5080 event.Skip(); // to let the edit control have the return
5081 }
5082 else
5083 {
5c8fc7c1 5084 MoveCursorDown( event.ShiftDown() );
58dd5b3b 5085 }
2d66e025
MB
5086 break;
5087
5c8fc7c1
SN
5088 case WXK_ESCAPE:
5089 m_selection->ClearSelection();
5090 break;
5091
2c9a89e0
RD
5092 case WXK_TAB:
5093 if (event.ShiftDown())
5c8fc7c1 5094 MoveCursorLeft( FALSE );
2c9a89e0 5095 else
5c8fc7c1 5096 MoveCursorRight( FALSE );
2c9a89e0
RD
5097 break;
5098
2d66e025
MB
5099 case WXK_HOME:
5100 if ( event.ControlDown() )
5101 {
5102 MakeCellVisible( 0, 0 );
5103 SetCurrentCell( 0, 0 );
5104 }
5105 else
5106 {
5107 event.Skip();
5108 }
5109 break;
5110
5111 case WXK_END:
5112 if ( event.ControlDown() )
5113 {
5114 MakeCellVisible( m_numRows-1, m_numCols-1 );
5115 SetCurrentCell( m_numRows-1, m_numCols-1 );
5116 }
5117 else
5118 {
5119 event.Skip();
5120 }
5121 break;
5122
5123 case WXK_PRIOR:
5124 MovePageUp();
5125 break;
5126
5127 case WXK_NEXT:
5128 MovePageDown();
5129 break;
5130
d95b0c2b 5131#if 1
07296f0b
RD
5132 case WXK_SPACE:
5133 if ( !IsEditable() )
5134 {
5c8fc7c1 5135 MoveCursorRight( FALSE );
07296f0b
RD
5136 break;
5137 }
5138 // Otherwise fall through to default
5c8fc7c1
SN
5139#else
5140 case WXK_SPACE:
5141 m_selection->ToggleCellSelection( m_currentCellCoords.GetRow(),
d95b0c2b
SN
5142 m_currentCellCoords.GetCol(),
5143 event.ControlDown(),
5144 event.ShiftDown(),
5145 event.AltDown(),
5146 event.MetaDown() );
5c8fc7c1
SN
5147 break;
5148#endif
07296f0b 5149
2d66e025 5150 default:
c239a4bb
VZ
5151 // alphanumeric keys or F2 (special key just for this) enable
5152 // the cell edit control
5c8fc7c1
SN
5153 // On just Shift/Control I get values for event.KeyCode()
5154 // that are outside the range where isalnum's behaviour is
5155 // well defined, so do an additional sanity check.
b94ae1ea
VZ
5156 if ( !(event.AltDown() ||
5157 event.MetaDown() ||
5158 event.ControlDown()) &&
5c8fc7c1
SN
5159 ((isalnum(event.KeyCode()) &&
5160 (event.KeyCode() < 256 && event.KeyCode() >= 0)) ||
5161 event.KeyCode() == WXK_F2) &&
b94ae1ea
VZ
5162 !IsCellEditControlEnabled() &&
5163 CanEnableCellControl() )
b54ba671
VZ
5164 {
5165 EnableCellEditControl();
f2d76237
RD
5166 int row = m_currentCellCoords.GetRow();
5167 int col = m_currentCellCoords.GetCol();
5168 wxGridCellAttr* attr = GetCellAttr(row, col);
0b190b0f
VZ
5169 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
5170 editor->StartingKey(event);
5171 editor->DecRef();
2c9a89e0
RD
5172 attr->DecRef();
5173 }
b3a7510d
VZ
5174 else
5175 {
b94ae1ea
VZ
5176 // let others process char events with modifiers or all
5177 // char events for readonly cells
b3a7510d
VZ
5178 event.Skip();
5179 }
025562fe 5180 break;
2d66e025 5181 }
f85afd4e
MB
5182 }
5183
2d66e025 5184 m_inOnKeyDown = FALSE;
f85afd4e
MB
5185}
5186
2796cce3 5187void wxGrid::OnEraseBackground(wxEraseEvent&)
508011ce
VZ
5188{
5189}
07296f0b 5190
2d66e025 5191void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
66242c80 5192{
2a7750d9 5193 if ( m_currentCellCoords != wxGridNoCellCoords )
2d66e025 5194 {
2d66e025 5195 HideCellEditControl();
b54ba671 5196 DisableCellEditControl();
07296f0b
RD
5197
5198 // Clear the old current cell highlight
5199 wxRect r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
d1c0b4f9
VZ
5200
5201 // Otherwise refresh redraws the highlight!
5202 m_currentCellCoords = coords;
5203
07296f0b 5204 m_gridWin->Refresh( FALSE, &r );
66242c80 5205 }
8f177c8e 5206
2d66e025
MB
5207 m_currentCellCoords = coords;
5208
2a7750d9
MB
5209 wxClientDC dc(m_gridWin);
5210 PrepareDC(dc);
5211
5212 wxGridCellAttr* attr = GetCellAttr(coords);
5213 DrawCellHighlight(dc, attr);
5214 attr->DecRef();
283b7808 5215
b5808881
SN
5216#if 0
5217 // SN: For my extended selection code, automatic
5218 // deselection is definitely not a good idea.
4634a5d6
MB
5219 if ( IsSelection() )
5220 {
5221 wxRect r( SelectionToDeviceRect() );
5222 ClearSelection();
5223 if ( !GetBatchCount() ) m_gridWin->Refresh( FALSE, &r );
5224 }
b5808881 5225#endif
66242c80
MB
5226}
5227
2d66e025
MB
5228
5229//
5230// ------ functions to get/send data (see also public functions)
5231//
5232
5233bool wxGrid::GetModelValues()
66242c80 5234{
2d66e025 5235 if ( m_table )
66242c80 5236 {
2d66e025 5237 // all we need to do is repaint the grid
66242c80 5238 //
2d66e025 5239 m_gridWin->Refresh();
66242c80
MB
5240 return TRUE;
5241 }
8f177c8e 5242
66242c80
MB
5243 return FALSE;
5244}
5245
2d66e025
MB
5246
5247bool wxGrid::SetModelValues()
f85afd4e 5248{
2d66e025 5249 int row, col;
8f177c8e 5250
2d66e025
MB
5251 if ( m_table )
5252 {
5253 for ( row = 0; row < m_numRows; row++ )
f85afd4e 5254 {
2d66e025 5255 for ( col = 0; col < m_numCols; col++ )
f85afd4e 5256 {
2d66e025 5257 m_table->SetValue( row, col, GetCellValue(row, col) );
f85afd4e
MB
5258 }
5259 }
8f177c8e 5260
f85afd4e
MB
5261 return TRUE;
5262 }
5263
5264 return FALSE;
5265}
5266
2d66e025
MB
5267
5268
5269// Note - this function only draws cells that are in the list of
5270// exposed cells (usually set from the update region by
5271// CalcExposedCells)
5272//
5273void wxGrid::DrawGridCellArea( wxDC& dc )
f85afd4e 5274{
2d66e025 5275 if ( !m_numRows || !m_numCols ) return;
60ff3b99 5276
2d66e025
MB
5277 size_t i;
5278 size_t numCells = m_cellsExposed.GetCount();
60ff3b99 5279
2d66e025 5280 for ( i = 0; i < numCells; i++ )
f85afd4e 5281 {
2d66e025
MB
5282 DrawCell( dc, m_cellsExposed[i] );
5283 }
5284}
8f177c8e 5285
8f177c8e 5286
7c8a8ad5
MB
5287void wxGrid::DrawGridSpace( wxDC& dc )
5288{
5289 if ( m_numRows && m_numCols )
5290 {
5291 int cw, ch;
5292 m_gridWin->GetClientSize( &cw, &ch );
5293
5294 int right, bottom;
5295 CalcUnscrolledPosition( cw, ch, &right, &bottom );
5296
5297 if ( right > GetColRight(m_numCols-1) ||
5298 bottom > GetRowBottom(m_numRows-1) )
5299 {
5300 int left, top;
5301 CalcUnscrolledPosition( 0, 0, &left, &top );
5302
5303 dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
5304 dc.SetPen( *wxTRANSPARENT_PEN );
5305
5306 if ( right > GetColRight(m_numCols-1) )
a5777624 5307 dc.DrawRectangle( GetColRight(m_numCols-1), top,
7c8a8ad5
MB
5308 right - GetColRight(m_numCols-1), ch );
5309
5310 if ( bottom > GetRowBottom(m_numRows-1) )
a5777624 5311 dc.DrawRectangle( left, GetRowBottom(m_numRows-1),
7c8a8ad5
MB
5312 cw, bottom - GetRowBottom(m_numRows-1) );
5313 }
5314 }
5315}
5316
5317
2d66e025
MB
5318void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
5319{
ab79958a
VZ
5320 int row = coords.GetRow();
5321 int col = coords.GetCol();
60ff3b99 5322
7c1cb261 5323 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
ab79958a
VZ
5324 return;
5325
5326 // we draw the cell border ourselves
9496deb5 5327#if !WXGRID_DRAW_LINES
2d66e025
MB
5328 if ( m_gridLinesEnabled )
5329 DrawCellBorder( dc, coords );
796df70a 5330#endif
f85afd4e 5331
189d0213
VZ
5332 wxGridCellAttr* attr = GetCellAttr(row, col);
5333
5334 bool isCurrent = coords == m_currentCellCoords;
508011ce 5335
ab79958a 5336 wxRect rect;
7c1cb261
VZ
5337 rect.x = GetColLeft(col);
5338 rect.y = GetRowTop(row);
5339 rect.width = GetColWidth(col) - 1;
5340 rect.height = GetRowHeight(row) - 1;
f85afd4e 5341
189d0213
VZ
5342 // if the editor is shown, we should use it and not the renderer
5343 if ( isCurrent && IsCellEditControlEnabled() )
5344 {
0b190b0f
VZ
5345 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
5346 editor->PaintBackground(rect, attr);
5347 editor->DecRef();
189d0213
VZ
5348 }
5349 else
5350 {
5351 // but all the rest is drawn by the cell renderer and hence may be
5352 // customized
0b190b0f
VZ
5353 wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
5354 renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
5355 renderer->DecRef();
189d0213 5356 }
07296f0b 5357
283b7808
VZ
5358 attr->DecRef();
5359}
07296f0b 5360
283b7808 5361void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
07296f0b
RD
5362{
5363 int row = m_currentCellCoords.GetRow();
5364 int col = m_currentCellCoords.GetCol();
5365
7c1cb261 5366 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
07296f0b
RD
5367 return;
5368
5369 wxRect rect;
7c1cb261
VZ
5370 rect.x = GetColLeft(col);
5371 rect.y = GetRowTop(row);
5372 rect.width = GetColWidth(col) - 1;
5373 rect.height = GetRowHeight(row) - 1;
07296f0b 5374
b3a7510d
VZ
5375 // hmmm... what could we do here to show that the cell is disabled?
5376 // for now, I just draw a thinner border than for the other ones, but
5377 // it doesn't look really good
5378 dc.SetPen(wxPen(m_gridLineColour, attr->IsReadOnly() ? 1 : 3, wxSOLID));
5379 dc.SetBrush(*wxTRANSPARENT_BRUSH);
5380
5381 dc.DrawRectangle(rect);
07296f0b 5382
283b7808 5383#if 0
b3a7510d 5384 // VZ: my experiments with 3d borders...
283b7808 5385
b3a7510d 5386 // how to properly set colours for arbitrary bg?
283b7808
VZ
5387 wxCoord x1 = rect.x,
5388 y1 = rect.y,
00cf1208
RR
5389 x2 = rect.x + rect.width -1,
5390 y2 = rect.y + rect.height -1;
283b7808
VZ
5391
5392 dc.SetPen(*wxWHITE_PEN);
00cf1208
RR
5393 dc.DrawLine(x1, y1, x2, y1);
5394 dc.DrawLine(x1, y1, x1, y2);
283b7808 5395
283b7808 5396 dc.DrawLine(x1 + 1, y2 - 1, x2 - 1, y2 - 1);
00cf1208 5397 dc.DrawLine(x2 - 1, y1 + 1, x2 - 1, y2 );
283b7808
VZ
5398
5399 dc.SetPen(*wxBLACK_PEN);
5400 dc.DrawLine(x1, y2, x2, y2);
00cf1208 5401 dc.DrawLine(x2, y1, x2, y2+1);
b3a7510d 5402#endif // 0
2d66e025 5403}
f85afd4e 5404
f2d76237 5405
2d66e025
MB
5406void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
5407{
2d66e025
MB
5408 int row = coords.GetRow();
5409 int col = coords.GetCol();
7c1cb261
VZ
5410 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5411 return;
5412
5413 dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
60ff3b99 5414
2d66e025
MB
5415 // right hand border
5416 //
7c1cb261
VZ
5417 dc.DrawLine( GetColRight(col), GetRowTop(row),
5418 GetColRight(col), GetRowBottom(row) );
2d66e025
MB
5419
5420 // bottom border
5421 //
7c1cb261
VZ
5422 dc.DrawLine( GetColLeft(col), GetRowBottom(row),
5423 GetColRight(col), GetRowBottom(row) );
f85afd4e
MB
5424}
5425
b3a7510d
VZ
5426void wxGrid::DrawHighlight(wxDC& dc)
5427{
2a7750d9
MB
5428 // This if block was previously in wxGrid::OnPaint but that doesn't
5429 // seem to get called under wxGTK - MB
5430 //
5431 if ( m_currentCellCoords == wxGridNoCellCoords &&
5432 m_numRows && m_numCols )
5433 {
5434 m_currentCellCoords.Set(0, 0);
5435 }
5436
99306db2
VZ
5437 if ( IsCellEditControlEnabled() )
5438 {
5439 // don't show highlight when the edit control is shown
5440 return;
5441 }
5442
b3a7510d
VZ
5443 // if the active cell was repainted, repaint its highlight too because it
5444 // might have been damaged by the grid lines
5445 size_t count = m_cellsExposed.GetCount();
5446 for ( size_t n = 0; n < count; n++ )
5447 {
5448 if ( m_cellsExposed[n] == m_currentCellCoords )
5449 {
5450 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
5451 DrawCellHighlight(dc, attr);
5452 attr->DecRef();
5453
5454 break;
5455 }
5456 }
5457}
2d66e025 5458
2d66e025
MB
5459// TODO: remove this ???
5460// This is used to redraw all grid lines e.g. when the grid line colour
5461// has been changed
5462//
796df70a 5463void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
f85afd4e 5464{
60ff3b99
VZ
5465 if ( !m_gridLinesEnabled ||
5466 !m_numRows ||
2d66e025 5467 !m_numCols ) return;
f85afd4e 5468
2d66e025 5469 int top, bottom, left, right;
796df70a 5470
8e217128 5471#ifndef __WXGTK__
508011ce
VZ
5472 if (reg.IsEmpty())
5473 {
796df70a
SN
5474 int cw, ch;
5475 m_gridWin->GetClientSize(&cw, &ch);
5476
5477 // virtual coords of visible area
5478 //
5479 CalcUnscrolledPosition( 0, 0, &left, &top );
5480 CalcUnscrolledPosition( cw, ch, &right, &bottom );
5481 }
508011ce
VZ
5482 else
5483 {
796df70a
SN
5484 wxCoord x, y, w, h;
5485 reg.GetBox(x, y, w, h);
5486 CalcUnscrolledPosition( x, y, &left, &top );
5487 CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
5488 }
8e217128
RR
5489#else
5490 int cw, ch;
5491 m_gridWin->GetClientSize(&cw, &ch);
5492 CalcUnscrolledPosition( 0, 0, &left, &top );
5493 CalcUnscrolledPosition( cw, ch, &right, &bottom );
5494#endif
f85afd4e 5495
9496deb5
MB
5496 // avoid drawing grid lines past the last row and col
5497 //
7c1cb261
VZ
5498 right = wxMin( right, GetColRight(m_numCols - 1) );
5499 bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );
9496deb5 5500
2d66e025 5501 dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
f85afd4e 5502
2d66e025 5503 // horizontal grid lines
f85afd4e 5504 //
60ff3b99 5505 int i;
9496deb5 5506 for ( i = 0; i < m_numRows; i++ )
f85afd4e 5507 {
6d55126d 5508 int bot = GetRowBottom(i) - 1;
7c1cb261 5509
6d55126d 5510 if ( bot > bottom )
2d66e025
MB
5511 {
5512 break;
5513 }
7c1cb261 5514
6d55126d 5515 if ( bot >= top )
2d66e025 5516 {
6d55126d 5517 dc.DrawLine( left, bot, right, bot );
2d66e025 5518 }
f85afd4e
MB
5519 }
5520
f85afd4e 5521
2d66e025
MB
5522 // vertical grid lines
5523 //
9496deb5 5524 for ( i = 0; i < m_numCols; i++ )
f85afd4e 5525 {
7c1cb261
VZ
5526 int colRight = GetColRight(i) - 1;
5527 if ( colRight > right )
2d66e025
MB
5528 {
5529 break;
5530 }
7c1cb261
VZ
5531
5532 if ( colRight >= left )
2d66e025 5533 {
7c1cb261 5534 dc.DrawLine( colRight, top, colRight, bottom );
2d66e025
MB
5535 }
5536 }
5537}
f85afd4e 5538
8f177c8e 5539
2d66e025
MB
5540void wxGrid::DrawRowLabels( wxDC& dc )
5541{
5542 if ( !m_numRows || !m_numCols ) return;
60ff3b99 5543
2d66e025
MB
5544 size_t i;
5545 size_t numLabels = m_rowLabelsExposed.GetCount();
60ff3b99 5546
2d66e025
MB
5547 for ( i = 0; i < numLabels; i++ )
5548 {
5549 DrawRowLabel( dc, m_rowLabelsExposed[i] );
60ff3b99 5550 }
f85afd4e
MB
5551}
5552
5553
2d66e025 5554void wxGrid::DrawRowLabel( wxDC& dc, int row )
f85afd4e 5555{
7c1cb261
VZ
5556 if ( GetRowHeight(row) <= 0 )
5557 return;
60ff3b99 5558
7c1cb261
VZ
5559 int rowTop = GetRowTop(row),
5560 rowBottom = GetRowBottom(row) - 1;
b99be8fb 5561
2d66e025 5562 dc.SetPen( *wxBLACK_PEN );
b0d6ff2f 5563 dc.DrawLine( m_rowLabelWidth-1, rowTop,
7c1cb261 5564 m_rowLabelWidth-1, rowBottom );
b99be8fb 5565
7c1cb261 5566 dc.DrawLine( 0, rowBottom, m_rowLabelWidth-1, rowBottom );
b99be8fb 5567
2d66e025 5568 dc.SetPen( *wxWHITE_PEN );
7c1cb261 5569 dc.DrawLine( 0, rowTop, 0, rowBottom );
b0d6ff2f 5570 dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
60ff3b99 5571
f85afd4e 5572 dc.SetBackgroundMode( wxTRANSPARENT );
f85afd4e
MB
5573 dc.SetTextForeground( GetLabelTextColour() );
5574 dc.SetFont( GetLabelFont() );
8f177c8e 5575
f85afd4e 5576 int hAlign, vAlign;
2d66e025 5577 GetRowLabelAlignment( &hAlign, &vAlign );
60ff3b99 5578
2d66e025
MB
5579 wxRect rect;
5580 rect.SetX( 2 );
7c1cb261 5581 rect.SetY( GetRowTop(row) + 2 );
2d66e025 5582 rect.SetWidth( m_rowLabelWidth - 4 );
7c1cb261 5583 rect.SetHeight( GetRowHeight(row) - 4 );
60ff3b99 5584 DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
f85afd4e
MB
5585}
5586
5587
2d66e025 5588void wxGrid::DrawColLabels( wxDC& dc )
f85afd4e 5589{
2d66e025 5590 if ( !m_numRows || !m_numCols ) return;
60ff3b99 5591
2d66e025
MB
5592 size_t i;
5593 size_t numLabels = m_colLabelsExposed.GetCount();
60ff3b99 5594
2d66e025 5595 for ( i = 0; i < numLabels; i++ )
f85afd4e 5596 {
2d66e025 5597 DrawColLabel( dc, m_colLabelsExposed[i] );
60ff3b99 5598 }
f85afd4e
MB
5599}
5600
5601
2d66e025 5602void wxGrid::DrawColLabel( wxDC& dc, int col )
f85afd4e 5603{
7c1cb261
VZ
5604 if ( GetColWidth(col) <= 0 )
5605 return;
60ff3b99 5606
7c1cb261
VZ
5607 int colLeft = GetColLeft(col),
5608 colRight = GetColRight(col) - 1;
b99be8fb 5609
2d66e025 5610 dc.SetPen( *wxBLACK_PEN );
7c1cb261
VZ
5611 dc.DrawLine( colRight, 0,
5612 colRight, m_colLabelHeight-1 );
b99be8fb 5613
b0d6ff2f 5614 dc.DrawLine( colLeft, m_colLabelHeight-1,
7c1cb261 5615 colRight, m_colLabelHeight-1 );
b99be8fb 5616
f85afd4e 5617 dc.SetPen( *wxWHITE_PEN );
b0d6ff2f 5618 dc.DrawLine( colLeft, 0, colLeft, m_colLabelHeight-1 );
7c1cb261 5619 dc.DrawLine( colLeft, 0, colRight, 0 );
f85afd4e 5620
b0d6ff2f
MB
5621 dc.SetBackgroundMode( wxTRANSPARENT );
5622 dc.SetTextForeground( GetLabelTextColour() );
5623 dc.SetFont( GetLabelFont() );
8f177c8e 5624
f85afd4e 5625 dc.SetBackgroundMode( wxTRANSPARENT );
f85afd4e
MB
5626 dc.SetTextForeground( GetLabelTextColour() );
5627 dc.SetFont( GetLabelFont() );
8f177c8e 5628
f85afd4e 5629 int hAlign, vAlign;
2d66e025 5630 GetColLabelAlignment( &hAlign, &vAlign );
60ff3b99 5631
2d66e025 5632 wxRect rect;
7c1cb261 5633 rect.SetX( colLeft + 2 );
2d66e025 5634 rect.SetY( 2 );
7c1cb261 5635 rect.SetWidth( GetColWidth(col) - 4 );
2d66e025 5636 rect.SetHeight( m_colLabelHeight - 4 );
60ff3b99 5637 DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
f85afd4e
MB
5638}
5639
5640
2d66e025
MB
5641void wxGrid::DrawTextRectangle( wxDC& dc,
5642 const wxString& value,
5643 const wxRect& rect,
5644 int horizAlign,
5645 int vertAlign )
f85afd4e 5646{
2d66e025
MB
5647 long textWidth, textHeight;
5648 long lineWidth, lineHeight;
5649 wxArrayString lines;
f85afd4e 5650
2d66e025
MB
5651 dc.SetClippingRegion( rect );
5652 StringToLines( value, lines );
5653 if ( lines.GetCount() )
5654 {
5655 GetTextBoxSize( dc, lines, &textWidth, &textHeight );
5656 dc.GetTextExtent( lines[0], &lineWidth, &lineHeight );
f85afd4e 5657
2d66e025
MB
5658 float x, y;
5659 switch ( horizAlign )
5660 {
5661 case wxRIGHT:
5662 x = rect.x + (rect.width - textWidth - 1);
5663 break;
f85afd4e 5664
2d66e025
MB
5665 case wxCENTRE:
5666 x = rect.x + ((rect.width - textWidth)/2);
5667 break;
f85afd4e 5668
2d66e025
MB
5669 case wxLEFT:
5670 default:
5671 x = rect.x + 1;
5672 break;
5673 }
f85afd4e 5674
2d66e025
MB
5675 switch ( vertAlign )
5676 {
5677 case wxBOTTOM:
5678 y = rect.y + (rect.height - textHeight - 1);
5679 break;
f85afd4e
MB
5680
5681 case wxCENTRE:
8f177c8e 5682 y = rect.y + ((rect.height - textHeight)/2);
f85afd4e
MB
5683 break;
5684
5685 case wxTOP:
5686 default:
8f177c8e 5687 y = rect.y + 1;
f85afd4e
MB
5688 break;
5689 }
5690
b540eb2b 5691 for ( size_t i = 0; i < lines.GetCount(); i++ )
f85afd4e
MB
5692 {
5693 dc.DrawText( lines[i], (long)x, (long)y );
5694 y += lineHeight;
5695 }
5696 }
8f177c8e 5697
f85afd4e 5698 dc.DestroyClippingRegion();
f85afd4e
MB
5699}
5700
5701
5702// Split multi line text up into an array of strings. Any existing
5703// contents of the string array are preserved.
5704//
5705void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
5706{
f85afd4e
MB
5707 int startPos = 0;
5708 int pos;
6d004f67 5709 wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
2433bb2e 5710 wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
e2b42eeb 5711
2433bb2e 5712 while ( startPos < (int)tVal.Length() )
f85afd4e 5713 {
2433bb2e 5714 pos = tVal.Mid(startPos).Find( eol );
f85afd4e
MB
5715 if ( pos < 0 )
5716 {
5717 break;
5718 }
5719 else if ( pos == 0 )
5720 {
5721 lines.Add( wxEmptyString );
5722 }
5723 else
5724 {
2433bb2e 5725 lines.Add( value.Mid(startPos, pos) );
f85afd4e
MB
5726 }
5727 startPos += pos+1;
5728 }
b540eb2b 5729 if ( startPos < (int)value.Length() )
f85afd4e
MB
5730 {
5731 lines.Add( value.Mid( startPos ) );
5732 }
5733}
5734
5735
5736void wxGrid::GetTextBoxSize( wxDC& dc,
5737 wxArrayString& lines,
5738 long *width, long *height )
5739{
5740 long w = 0;
5741 long h = 0;
5742 long lineW, lineH;
5743
b540eb2b 5744 size_t i;
f85afd4e
MB
5745 for ( i = 0; i < lines.GetCount(); i++ )
5746 {
5747 dc.GetTextExtent( lines[i], &lineW, &lineH );
5748 w = wxMax( w, lineW );
5749 h += lineH;
5750 }
5751
5752 *width = w;
5753 *height = h;
5754}
5755
5756
5757//
2d66e025 5758// ------ Edit control functions
f85afd4e
MB
5759//
5760
2d66e025
MB
5761
5762void wxGrid::EnableEditing( bool edit )
f85afd4e 5763{
2d66e025
MB
5764 // TODO: improve this ?
5765 //
5766 if ( edit != m_editable )
f85afd4e 5767 {
2d66e025 5768 m_editable = edit;
1f1ce288 5769
b54ba671
VZ
5770 // FIXME IMHO this won't disable the edit control if edit == FALSE
5771 // because of the check in the beginning of
5772 // EnableCellEditControl() just below (VZ)
2c9a89e0 5773 EnableCellEditControl(m_editable);
f85afd4e 5774 }
f85afd4e
MB
5775}
5776
5777
2d66e025 5778void wxGrid::EnableCellEditControl( bool enable )
f85afd4e 5779{
2c9a89e0
RD
5780 if (! m_editable)
5781 return;
5782
dcfe4c3d
SN
5783 if ( m_currentCellCoords == wxGridNoCellCoords )
5784 SetCurrentCell( 0, 0 );
60ff3b99 5785
2c9a89e0
RD
5786 if ( enable != m_cellEditCtrlEnabled )
5787 {
b54ba671
VZ
5788 // TODO allow the app to Veto() this event?
5789 SendEvent(enable ? wxEVT_GRID_EDITOR_SHOWN : wxEVT_GRID_EDITOR_HIDDEN);
5790
dcfe4c3d 5791 if ( enable )
f85afd4e 5792 {
b54ba671
VZ
5793 // this should be checked by the caller!
5794 wxASSERT_MSG( CanEnableCellControl(),
5795 _T("can't enable editing for this cell!") );
5796
5797 // do it before ShowCellEditControl()
dcfe4c3d 5798 m_cellEditCtrlEnabled = enable;
b54ba671 5799
2d66e025 5800 ShowCellEditControl();
2d66e025
MB
5801 }
5802 else
5803 {
2d66e025
MB
5804 HideCellEditControl();
5805 SaveEditControlValue();
b54ba671
VZ
5806
5807 // do it after HideCellEditControl()
dcfe4c3d 5808 m_cellEditCtrlEnabled = enable;
f85afd4e 5809 }
f85afd4e 5810 }
f85afd4e 5811}
f85afd4e 5812
b54ba671 5813bool wxGrid::IsCurrentCellReadOnly() const
283b7808 5814{
b54ba671
VZ
5815 // const_cast
5816 wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
5817 bool readonly = attr->IsReadOnly();
5818 attr->DecRef();
283b7808 5819
b54ba671
VZ
5820 return readonly;
5821}
283b7808 5822
b54ba671
VZ
5823bool wxGrid::CanEnableCellControl() const
5824{
5825 return m_editable && !IsCurrentCellReadOnly();
5826}
5827
5828bool wxGrid::IsCellEditControlEnabled() const
5829{
5830 // the cell edit control might be disable for all cells or just for the
5831 // current one if it's read only
5832 return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : FALSE;
283b7808
VZ
5833}
5834
2d66e025 5835void wxGrid::ShowCellEditControl()
f85afd4e 5836{
2d66e025 5837 if ( IsCellEditControlEnabled() )
f85afd4e 5838 {
2d66e025
MB
5839 if ( !IsVisible( m_currentCellCoords ) )
5840 {
5841 return;
5842 }
5843 else
5844 {
2c9a89e0
RD
5845 wxRect rect = CellToRect( m_currentCellCoords );
5846 int row = m_currentCellCoords.GetRow();
5847 int col = m_currentCellCoords.GetCol();
2d66e025
MB
5848
5849 // convert to scrolled coords
5850 //
99306db2 5851 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
508011ce 5852
99306db2
VZ
5853 // done in PaintBackground()
5854#if 0
5855 // erase the highlight and the cell contents because the editor
5856 // might not cover the entire cell
5857 wxClientDC dc( m_gridWin );
5858 PrepareDC( dc );
5859 dc.SetBrush(*wxLIGHT_GREY_BRUSH); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
5860 dc.SetPen(*wxTRANSPARENT_PEN);
5861 dc.DrawRectangle(rect);
5862#endif // 0
d2fdd8d2 5863
99306db2
VZ
5864 // cell is shifted by one pixel
5865 rect.x--;
5866 rect.y--;
f0102d2a 5867
508011ce 5868 wxGridCellAttr* attr = GetCellAttr(row, col);
28a77bc4 5869 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
3da93aae
VZ
5870 if ( !editor->IsCreated() )
5871 {
2c9a89e0
RD
5872 editor->Create(m_gridWin, -1,
5873 new wxGridCellEditorEvtHandler(this, editor));
2d66e025
MB
5874 }
5875
b0e282b3 5876 editor->Show( TRUE, attr );
0b190b0f 5877
2c9a89e0 5878 editor->SetSize( rect );
99306db2 5879
3da93aae 5880 editor->BeginEdit(row, col, this);
0b190b0f
VZ
5881
5882 editor->DecRef();
2c9a89e0
RD
5883 attr->DecRef();
5884 }
f85afd4e
MB
5885 }
5886}
5887
5888
2d66e025 5889void wxGrid::HideCellEditControl()
f85afd4e 5890{
2d66e025 5891 if ( IsCellEditControlEnabled() )
f85afd4e 5892 {
2c9a89e0
RD
5893 int row = m_currentCellCoords.GetRow();
5894 int col = m_currentCellCoords.GetCol();
5895
3da93aae 5896 wxGridCellAttr* attr = GetCellAttr(row, col);
0b190b0f
VZ
5897 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
5898 editor->Show( FALSE );
5899 editor->DecRef();
2c9a89e0
RD
5900 attr->DecRef();
5901 m_gridWin->SetFocus();
f85afd4e 5902 }
2d66e025 5903}
8f177c8e 5904
2d66e025 5905
2d66e025
MB
5906void wxGrid::SaveEditControlValue()
5907{
3da93aae
VZ
5908 if ( IsCellEditControlEnabled() )
5909 {
2c9a89e0
RD
5910 int row = m_currentCellCoords.GetRow();
5911 int col = m_currentCellCoords.GetCol();
8f177c8e 5912
3da93aae 5913 wxGridCellAttr* attr = GetCellAttr(row, col);
28a77bc4 5914 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
3324d5f5 5915 bool changed = editor->EndEdit(row, col, this);
2d66e025 5916
0b190b0f 5917 editor->DecRef();
2c9a89e0 5918 attr->DecRef();
2d66e025 5919
3da93aae
VZ
5920 if (changed)
5921 {
b54ba671 5922 SendEvent( wxEVT_GRID_CELL_CHANGE,
2d66e025
MB
5923 m_currentCellCoords.GetRow(),
5924 m_currentCellCoords.GetCol() );
5925 }
f85afd4e
MB
5926 }
5927}
5928
2d66e025
MB
5929
5930//
60ff3b99
VZ
5931// ------ Grid location functions
5932// Note that all of these functions work with the logical coordinates of
2d66e025
MB
5933// grid cells and labels so you will need to convert from device
5934// coordinates for mouse events etc.
5935//
5936
5937void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
f85afd4e 5938{
58dd5b3b
MB
5939 int row = YToRow(y);
5940 int col = XToCol(x);
5941
5942 if ( row == -1 || col == -1 )
5943 {
5944 coords = wxGridNoCellCoords;
5945 }
5946 else
5947 {
5948 coords.Set( row, col );
5949 }
2d66e025 5950}
f85afd4e 5951
8f177c8e 5952
2d66e025
MB
5953int wxGrid::YToRow( int y )
5954{
5955 int i;
8f177c8e 5956
2d66e025 5957 for ( i = 0; i < m_numRows; i++ )
f85afd4e 5958 {
7c1cb261
VZ
5959 if ( y < GetRowBottom(i) )
5960 return i;
f85afd4e 5961 }
2d66e025 5962
4ee5fc9c 5963 return -1;
f85afd4e
MB
5964}
5965
2d66e025
MB
5966
5967int wxGrid::XToCol( int x )
f85afd4e 5968{
2d66e025 5969 int i;
8f177c8e 5970
2d66e025 5971 for ( i = 0; i < m_numCols; i++ )
f85afd4e 5972 {
7c1cb261
VZ
5973 if ( x < GetColRight(i) )
5974 return i;
f85afd4e
MB
5975 }
5976
4ee5fc9c 5977 return -1;
2d66e025 5978}
8f177c8e 5979
2d66e025
MB
5980
5981// return the row number that that the y coord is near the edge of, or
5982// -1 if not near an edge
5983//
5984int wxGrid::YToEdgeOfRow( int y )
5985{
5986 int i, d;
5987
5988 for ( i = 0; i < m_numRows; i++ )
5989 {
7c1cb261 5990 if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE )
f85afd4e 5991 {
7c1cb261
VZ
5992 d = abs( y - GetRowBottom(i) );
5993 if ( d < WXGRID_LABEL_EDGE_ZONE )
5994 return i;
f85afd4e 5995 }
f85afd4e 5996 }
2d66e025
MB
5997
5998 return -1;
5999}
6000
6001
6002// return the col number that that the x coord is near the edge of, or
6003// -1 if not near an edge
6004//
6005int wxGrid::XToEdgeOfCol( int x )
6006{
6007 int i, d;
6008
6009 for ( i = 0; i < m_numCols; i++ )
f85afd4e 6010 {
7c1cb261 6011 if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE )
2d66e025 6012 {
7c1cb261
VZ
6013 d = abs( x - GetColRight(i) );
6014 if ( d < WXGRID_LABEL_EDGE_ZONE )
6015 return i;
2d66e025 6016 }
f85afd4e 6017 }
2d66e025
MB
6018
6019 return -1;
f85afd4e
MB
6020}
6021
2d66e025
MB
6022
6023wxRect wxGrid::CellToRect( int row, int col )
f85afd4e 6024{
2d66e025 6025 wxRect rect( -1, -1, -1, -1 );
f85afd4e 6026
2d66e025
MB
6027 if ( row >= 0 && row < m_numRows &&
6028 col >= 0 && col < m_numCols )
f85afd4e 6029 {
7c1cb261
VZ
6030 rect.x = GetColLeft(col);
6031 rect.y = GetRowTop(row);
6032 rect.width = GetColWidth(col);
6033 rect.height = GetRowHeight(row);
f85afd4e
MB
6034 }
6035
2d66e025
MB
6036 return rect;
6037}
6038
6039
6040bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
6041{
6042 // get the cell rectangle in logical coords
6043 //
6044 wxRect r( CellToRect( row, col ) );
60ff3b99 6045
2d66e025
MB
6046 // convert to device coords
6047 //
6048 int left, top, right, bottom;
6049 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6050 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
60ff3b99 6051
2d66e025
MB
6052 // check against the client area of the grid window
6053 //
6054 int cw, ch;
6055 m_gridWin->GetClientSize( &cw, &ch );
60ff3b99 6056
2d66e025 6057 if ( wholeCellVisible )
f85afd4e 6058 {
2d66e025 6059 // is the cell wholly visible ?
8f177c8e 6060 //
2d66e025
MB
6061 return ( left >= 0 && right <= cw &&
6062 top >= 0 && bottom <= ch );
6063 }
6064 else
6065 {
6066 // is the cell partly visible ?
6067 //
6068 return ( ((left >=0 && left < cw) || (right > 0 && right <= cw)) &&
6069 ((top >=0 && top < ch) || (bottom > 0 && bottom <= ch)) );
6070 }
6071}
6072
6073
6074// make the specified cell location visible by doing a minimal amount
6075// of scrolling
6076//
6077void wxGrid::MakeCellVisible( int row, int col )
6078{
6079 int i;
60ff3b99 6080 int xpos = -1, ypos = -1;
2d66e025
MB
6081
6082 if ( row >= 0 && row < m_numRows &&
6083 col >= 0 && col < m_numCols )
6084 {
6085 // get the cell rectangle in logical coords
6086 //
6087 wxRect r( CellToRect( row, col ) );
60ff3b99 6088
2d66e025
MB
6089 // convert to device coords
6090 //
6091 int left, top, right, bottom;
6092 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6093 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
60ff3b99 6094
2d66e025
MB
6095 int cw, ch;
6096 m_gridWin->GetClientSize( &cw, &ch );
60ff3b99 6097
2d66e025 6098 if ( top < 0 )
3f296516 6099 {
2d66e025 6100 ypos = r.GetTop();
3f296516 6101 }
2d66e025
MB
6102 else if ( bottom > ch )
6103 {
6104 int h = r.GetHeight();
6105 ypos = r.GetTop();
6106 for ( i = row-1; i >= 0; i-- )
6107 {
7c1cb261
VZ
6108 int rowHeight = GetRowHeight(i);
6109 if ( h + rowHeight > ch )
6110 break;
2d66e025 6111
7c1cb261
VZ
6112 h += rowHeight;
6113 ypos -= rowHeight;
2d66e025 6114 }
f0102d2a
VZ
6115
6116 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
6117 // have rounding errors (this is important, because if we do, we
6118 // might not scroll at all and some cells won't be redrawn)
6119 ypos += GRID_SCROLL_LINE / 2;
2d66e025
MB
6120 }
6121
6122 if ( left < 0 )
6123 {
6124 xpos = r.GetLeft();
6125 }
6126 else if ( right > cw )
6127 {
6128 int w = r.GetWidth();
6129 xpos = r.GetLeft();
6130 for ( i = col-1; i >= 0; i-- )
6131 {
7c1cb261
VZ
6132 int colWidth = GetColWidth(i);
6133 if ( w + colWidth > cw )
6134 break;
2d66e025 6135
7c1cb261
VZ
6136 w += colWidth;
6137 xpos -= colWidth;
2d66e025 6138 }
f0102d2a
VZ
6139
6140 // see comment for ypos above
6141 xpos += GRID_SCROLL_LINE / 2;
2d66e025
MB
6142 }
6143
6144 if ( xpos != -1 || ypos != -1 )
6145 {
f0102d2a
VZ
6146 if ( xpos != -1 ) xpos /= GRID_SCROLL_LINE;
6147 if ( ypos != -1 ) ypos /= GRID_SCROLL_LINE;
2d66e025
MB
6148 Scroll( xpos, ypos );
6149 AdjustScrollbars();
6150 }
6151 }
6152}
6153
6154
6155//
6156// ------ Grid cursor movement functions
6157//
6158
5c8fc7c1 6159bool wxGrid::MoveCursorUp( bool expandSelection )
2d66e025
MB
6160{
6161 if ( m_currentCellCoords != wxGridNoCellCoords &&
6162 m_currentCellCoords.GetRow() > 0 )
6163 {
6164 MakeCellVisible( m_currentCellCoords.GetRow() - 1,
d95b0c2b 6165 m_currentCellCoords.GetCol() );
5c8fc7c1 6166 if ( expandSelection )
d95b0c2b
SN
6167 {
6168 if ( m_selectingKeyboard == wxGridNoCellCoords )
6169 m_selectingKeyboard = m_currentCellCoords;
6170 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() - 1 );
6171 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6172 }
6173 else
6174 SetCurrentCell( m_currentCellCoords.GetRow() - 1,
6175 m_currentCellCoords.GetCol() );
8f177c8e 6176 return TRUE;
f85afd4e 6177 }
2d66e025
MB
6178
6179 return FALSE;
6180}
6181
6182
5c8fc7c1 6183bool wxGrid::MoveCursorDown( bool expandSelection )
2d66e025 6184{
2d66e025
MB
6185 if ( m_currentCellCoords != wxGridNoCellCoords &&
6186 m_currentCellCoords.GetRow() < m_numRows-1 )
f85afd4e 6187 {
2d66e025 6188 MakeCellVisible( m_currentCellCoords.GetRow() + 1,
d95b0c2b 6189 m_currentCellCoords.GetCol() );
5c8fc7c1 6190 if ( expandSelection )
d95b0c2b
SN
6191 {
6192 if ( m_selectingKeyboard == wxGridNoCellCoords )
6193 m_selectingKeyboard = m_currentCellCoords;
6194 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() + 1 );
6195 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6196 }
6197 else
6198 SetCurrentCell( m_currentCellCoords.GetRow() + 1,
6199 m_currentCellCoords.GetCol() );
2d66e025 6200 return TRUE;
f85afd4e 6201 }
2d66e025
MB
6202
6203 return FALSE;
f85afd4e
MB
6204}
6205
2d66e025 6206
5c8fc7c1 6207bool wxGrid::MoveCursorLeft( bool expandSelection )
f85afd4e 6208{
2d66e025
MB
6209 if ( m_currentCellCoords != wxGridNoCellCoords &&
6210 m_currentCellCoords.GetCol() > 0 )
6211 {
6212 MakeCellVisible( m_currentCellCoords.GetRow(),
d95b0c2b 6213 m_currentCellCoords.GetCol() - 1 );
5c8fc7c1 6214 if ( expandSelection )
d95b0c2b
SN
6215 {
6216 if ( m_selectingKeyboard == wxGridNoCellCoords )
6217 m_selectingKeyboard = m_currentCellCoords;
6218 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() - 1 );
6219 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6220 }
6221 else
6222 SetCurrentCell( m_currentCellCoords.GetRow(),
6223 m_currentCellCoords.GetCol() - 1 );
2d66e025
MB
6224 return TRUE;
6225 }
6226
6227 return FALSE;
6228}
6229
6230
5c8fc7c1 6231bool wxGrid::MoveCursorRight( bool expandSelection )
2d66e025
MB
6232{
6233 if ( m_currentCellCoords != wxGridNoCellCoords &&
6234 m_currentCellCoords.GetCol() < m_numCols - 1 )
f85afd4e 6235 {
2d66e025
MB
6236 MakeCellVisible( m_currentCellCoords.GetRow(),
6237 m_currentCellCoords.GetCol() + 1 );
60ff3b99 6238
5c8fc7c1 6239 if ( expandSelection )
d95b0c2b
SN
6240 {
6241 if ( m_selectingKeyboard == wxGridNoCellCoords )
6242 m_selectingKeyboard = m_currentCellCoords;
6243 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() + 1 );
6244 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6245 }
6246 else
6247 SetCurrentCell( m_currentCellCoords.GetRow(),
6248 m_currentCellCoords.GetCol() + 1 );
2d66e025 6249 return TRUE;
f85afd4e 6250 }
8f177c8e 6251
2d66e025
MB
6252 return FALSE;
6253}
6254
6255
6256bool wxGrid::MovePageUp()
6257{
6258 if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
60ff3b99 6259
2d66e025
MB
6260 int row = m_currentCellCoords.GetRow();
6261 if ( row > 0 )
f85afd4e 6262 {
2d66e025
MB
6263 int cw, ch;
6264 m_gridWin->GetClientSize( &cw, &ch );
60ff3b99 6265
7c1cb261 6266 int y = GetRowTop(row);
2d66e025
MB
6267 int newRow = YToRow( y - ch + 1 );
6268 if ( newRow == -1 )
6269 {
6270 newRow = 0;
6271 }
60ff3b99 6272 else if ( newRow == row )
2d66e025
MB
6273 {
6274 newRow = row - 1;
6275 }
8f177c8e 6276
2d66e025
MB
6277 MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
6278 SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
60ff3b99 6279
f85afd4e
MB
6280 return TRUE;
6281 }
2d66e025
MB
6282
6283 return FALSE;
6284}
6285
6286bool wxGrid::MovePageDown()
6287{
6288 if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
60ff3b99 6289
2d66e025
MB
6290 int row = m_currentCellCoords.GetRow();
6291 if ( row < m_numRows )
f85afd4e 6292 {
2d66e025
MB
6293 int cw, ch;
6294 m_gridWin->GetClientSize( &cw, &ch );
60ff3b99 6295
7c1cb261 6296 int y = GetRowTop(row);
2d66e025
MB
6297 int newRow = YToRow( y + ch );
6298 if ( newRow == -1 )
6299 {
6300 newRow = m_numRows - 1;
6301 }
60ff3b99 6302 else if ( newRow == row )
2d66e025
MB
6303 {
6304 newRow = row + 1;
6305 }
6306
6307 MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
6308 SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
60ff3b99 6309
2d66e025 6310 return TRUE;
f85afd4e 6311 }
2d66e025
MB
6312
6313 return FALSE;
f85afd4e 6314}
8f177c8e 6315
5c8fc7c1 6316bool wxGrid::MoveCursorUpBlock( bool expandSelection )
2d66e025
MB
6317{
6318 if ( m_table &&
6319 m_currentCellCoords != wxGridNoCellCoords &&
6320 m_currentCellCoords.GetRow() > 0 )
6321 {
6322 int row = m_currentCellCoords.GetRow();
6323 int col = m_currentCellCoords.GetCol();
6324
6325 if ( m_table->IsEmptyCell(row, col) )
6326 {
6327 // starting in an empty cell: find the next block of
6328 // non-empty cells
6329 //
6330 while ( row > 0 )
6331 {
6332 row-- ;
6333 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6334 }
6335 }
6336 else if ( m_table->IsEmptyCell(row-1, col) )
6337 {
6338 // starting at the top of a block: find the next block
6339 //
6340 row--;
6341 while ( row > 0 )
6342 {
6343 row-- ;
6344 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6345 }
6346 }
6347 else
6348 {
6349 // starting within a block: find the top of the block
6350 //
6351 while ( row > 0 )
6352 {
6353 row-- ;
6354 if ( m_table->IsEmptyCell(row, col) )
6355 {
6356 row++ ;
6357 break;
6358 }
6359 }
6360 }
f85afd4e 6361
2d66e025 6362 MakeCellVisible( row, col );
5c8fc7c1 6363 if ( expandSelection )
d95b0c2b
SN
6364 {
6365 m_selectingKeyboard = wxGridCellCoords( row, col );
6366 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6367 }
6368 else
6369 SetCurrentCell( row, col );
f85afd4e 6370
2d66e025
MB
6371 return TRUE;
6372 }
f85afd4e 6373
2d66e025
MB
6374 return FALSE;
6375}
f85afd4e 6376
5c8fc7c1 6377bool wxGrid::MoveCursorDownBlock( bool expandSelection )
f85afd4e 6378{
2d66e025
MB
6379 if ( m_table &&
6380 m_currentCellCoords != wxGridNoCellCoords &&
6381 m_currentCellCoords.GetRow() < m_numRows-1 )
f85afd4e 6382 {
2d66e025
MB
6383 int row = m_currentCellCoords.GetRow();
6384 int col = m_currentCellCoords.GetCol();
6385
6386 if ( m_table->IsEmptyCell(row, col) )
6387 {
6388 // starting in an empty cell: find the next block of
6389 // non-empty cells
6390 //
6391 while ( row < m_numRows-1 )
6392 {
6393 row++ ;
6394 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6395 }
6396 }
6397 else if ( m_table->IsEmptyCell(row+1, col) )
6398 {
6399 // starting at the bottom of a block: find the next block
6400 //
6401 row++;
6402 while ( row < m_numRows-1 )
6403 {
6404 row++ ;
6405 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6406 }
6407 }
6408 else
6409 {
6410 // starting within a block: find the bottom of the block
6411 //
6412 while ( row < m_numRows-1 )
6413 {
6414 row++ ;
6415 if ( m_table->IsEmptyCell(row, col) )
6416 {
6417 row-- ;
6418 break;
6419 }
6420 }
6421 }
6422
6423 MakeCellVisible( row, col );
5c8fc7c1 6424 if ( expandSelection )
d95b0c2b
SN
6425 {
6426 m_selectingKeyboard = wxGridCellCoords( row, col );
6427 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6428 }
6429 else
6430 SetCurrentCell( row, col );
2d66e025
MB
6431
6432 return TRUE;
f85afd4e 6433 }
f85afd4e 6434
2d66e025
MB
6435 return FALSE;
6436}
f85afd4e 6437
5c8fc7c1 6438bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
f85afd4e 6439{
2d66e025
MB
6440 if ( m_table &&
6441 m_currentCellCoords != wxGridNoCellCoords &&
6442 m_currentCellCoords.GetCol() > 0 )
f85afd4e 6443 {
2d66e025
MB
6444 int row = m_currentCellCoords.GetRow();
6445 int col = m_currentCellCoords.GetCol();
6446
6447 if ( m_table->IsEmptyCell(row, col) )
6448 {
6449 // starting in an empty cell: find the next block of
6450 // non-empty cells
6451 //
6452 while ( col > 0 )
6453 {
6454 col-- ;
6455 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6456 }
6457 }
6458 else if ( m_table->IsEmptyCell(row, col-1) )
6459 {
6460 // starting at the left of a block: find the next block
6461 //
6462 col--;
6463 while ( col > 0 )
6464 {
6465 col-- ;
6466 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6467 }
6468 }
6469 else
6470 {
6471 // starting within a block: find the left of the block
6472 //
6473 while ( col > 0 )
6474 {
6475 col-- ;
6476 if ( m_table->IsEmptyCell(row, col) )
6477 {
6478 col++ ;
6479 break;
6480 }
6481 }
6482 }
f85afd4e 6483
2d66e025 6484 MakeCellVisible( row, col );
5c8fc7c1 6485 if ( expandSelection )
d95b0c2b
SN
6486 {
6487 m_selectingKeyboard = wxGridCellCoords( row, col );
6488 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6489 }
6490 else
6491 SetCurrentCell( row, col );
8f177c8e 6492
2d66e025 6493 return TRUE;
f85afd4e 6494 }
2d66e025
MB
6495
6496 return FALSE;
f85afd4e
MB
6497}
6498
5c8fc7c1 6499bool wxGrid::MoveCursorRightBlock( bool expandSelection )
f85afd4e 6500{
2d66e025
MB
6501 if ( m_table &&
6502 m_currentCellCoords != wxGridNoCellCoords &&
6503 m_currentCellCoords.GetCol() < m_numCols-1 )
f85afd4e 6504 {
2d66e025
MB
6505 int row = m_currentCellCoords.GetRow();
6506 int col = m_currentCellCoords.GetCol();
8f177c8e 6507
2d66e025
MB
6508 if ( m_table->IsEmptyCell(row, col) )
6509 {
6510 // starting in an empty cell: find the next block of
6511 // non-empty cells
6512 //
6513 while ( col < m_numCols-1 )
6514 {
6515 col++ ;
6516 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6517 }
6518 }
6519 else if ( m_table->IsEmptyCell(row, col+1) )
6520 {
6521 // starting at the right of a block: find the next block
6522 //
6523 col++;
6524 while ( col < m_numCols-1 )
6525 {
6526 col++ ;
6527 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6528 }
6529 }
6530 else
6531 {
6532 // starting within a block: find the right of the block
6533 //
6534 while ( col < m_numCols-1 )
6535 {
6536 col++ ;
6537 if ( m_table->IsEmptyCell(row, col) )
6538 {
6539 col-- ;
6540 break;
6541 }
6542 }
6543 }
8f177c8e 6544
2d66e025 6545 MakeCellVisible( row, col );
5c8fc7c1 6546 if ( expandSelection )
d95b0c2b
SN
6547 {
6548 m_selectingKeyboard = wxGridCellCoords( row, col );
6549 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6550 }
6551 else
6552 SetCurrentCell( row, col );
f85afd4e 6553
2d66e025 6554 return TRUE;
f85afd4e 6555 }
2d66e025
MB
6556
6557 return FALSE;
f85afd4e
MB
6558}
6559
6560
2d66e025 6561
f85afd4e 6562//
2d66e025 6563// ------ Label values and formatting
f85afd4e
MB
6564//
6565
6566void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
6567{
6568 *horiz = m_rowLabelHorizAlign;
6569 *vert = m_rowLabelVertAlign;
6570}
6571
6572void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
6573{
6574 *horiz = m_colLabelHorizAlign;
6575 *vert = m_colLabelVertAlign;
6576}
6577
6578wxString wxGrid::GetRowLabelValue( int row )
6579{
6580 if ( m_table )
6581 {
6582 return m_table->GetRowLabelValue( row );
6583 }
6584 else
6585 {
6586 wxString s;
6587 s << row;
6588 return s;
6589 }
6590}
6591
6592wxString wxGrid::GetColLabelValue( int col )
6593{
6594 if ( m_table )
6595 {
6596 return m_table->GetColLabelValue( col );
6597 }
6598 else
6599 {
6600 wxString s;
6601 s << col;
6602 return s;
6603 }
6604}
6605
2e8cd977 6606
f85afd4e
MB
6607void wxGrid::SetRowLabelSize( int width )
6608{
2e8cd977
MB
6609 width = wxMax( width, 0 );
6610 if ( width != m_rowLabelWidth )
6611 {
2e8cd977
MB
6612 if ( width == 0 )
6613 {
6614 m_rowLabelWin->Show( FALSE );
7807d81c 6615 m_cornerLabelWin->Show( FALSE );
2e8cd977 6616 }
7807d81c 6617 else if ( m_rowLabelWidth == 0 )
2e8cd977 6618 {
7807d81c
MB
6619 m_rowLabelWin->Show( TRUE );
6620 if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
2e8cd977 6621 }
b99be8fb 6622
2e8cd977 6623 m_rowLabelWidth = width;
7807d81c
MB
6624 CalcWindowSizes();
6625 Refresh( TRUE );
2e8cd977 6626 }
f85afd4e
MB
6627}
6628
2e8cd977 6629
f85afd4e
MB
6630void wxGrid::SetColLabelSize( int height )
6631{
7807d81c 6632 height = wxMax( height, 0 );
2e8cd977
MB
6633 if ( height != m_colLabelHeight )
6634 {
2e8cd977
MB
6635 if ( height == 0 )
6636 {
2e8cd977 6637 m_colLabelWin->Show( FALSE );
7807d81c 6638 m_cornerLabelWin->Show( FALSE );
2e8cd977 6639 }
7807d81c 6640 else if ( m_colLabelHeight == 0 )
2e8cd977 6641 {
7807d81c
MB
6642 m_colLabelWin->Show( TRUE );
6643 if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
2e8cd977 6644 }
7807d81c 6645
2e8cd977 6646 m_colLabelHeight = height;
7807d81c
MB
6647 CalcWindowSizes();
6648 Refresh( TRUE );
2e8cd977 6649 }
f85afd4e
MB
6650}
6651
2e8cd977 6652
f85afd4e
MB
6653void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
6654{
2d66e025
MB
6655 if ( m_labelBackgroundColour != colour )
6656 {
6657 m_labelBackgroundColour = colour;
6658 m_rowLabelWin->SetBackgroundColour( colour );
6659 m_colLabelWin->SetBackgroundColour( colour );
6660 m_cornerLabelWin->SetBackgroundColour( colour );
6661
6662 if ( !GetBatchCount() )
6663 {
6664 m_rowLabelWin->Refresh();
6665 m_colLabelWin->Refresh();
6666 m_cornerLabelWin->Refresh();
6667 }
6668 }
f85afd4e
MB
6669}
6670
6671void wxGrid::SetLabelTextColour( const wxColour& colour )
6672{
2d66e025
MB
6673 if ( m_labelTextColour != colour )
6674 {
6675 m_labelTextColour = colour;
6676 if ( !GetBatchCount() )
6677 {
6678 m_rowLabelWin->Refresh();
6679 m_colLabelWin->Refresh();
6680 }
6681 }
f85afd4e
MB
6682}
6683
6684void wxGrid::SetLabelFont( const wxFont& font )
6685{
6686 m_labelFont = font;
2d66e025
MB
6687 if ( !GetBatchCount() )
6688 {
6689 m_rowLabelWin->Refresh();
6690 m_colLabelWin->Refresh();
6691 }
f85afd4e
MB
6692}
6693
6694void wxGrid::SetRowLabelAlignment( int horiz, int vert )
6695{
6696 if ( horiz == wxLEFT || horiz == wxCENTRE || horiz == wxRIGHT )
6697 {
6698 m_rowLabelHorizAlign = horiz;
6699 }
8f177c8e 6700
f85afd4e
MB
6701 if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
6702 {
6703 m_rowLabelVertAlign = vert;
6704 }
6705
2d66e025
MB
6706 if ( !GetBatchCount() )
6707 {
6708 m_rowLabelWin->Refresh();
60ff3b99 6709 }
f85afd4e
MB
6710}
6711
6712void wxGrid::SetColLabelAlignment( int horiz, int vert )
6713{
6714 if ( horiz == wxLEFT || horiz == wxCENTRE || horiz == wxRIGHT )
6715 {
6716 m_colLabelHorizAlign = horiz;
6717 }
8f177c8e 6718
f85afd4e
MB
6719 if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
6720 {
6721 m_colLabelVertAlign = vert;
6722 }
6723
2d66e025
MB
6724 if ( !GetBatchCount() )
6725 {
2d66e025 6726 m_colLabelWin->Refresh();
60ff3b99 6727 }
f85afd4e
MB
6728}
6729
6730void wxGrid::SetRowLabelValue( int row, const wxString& s )
6731{
6732 if ( m_table )
6733 {
6734 m_table->SetRowLabelValue( row, s );
2d66e025
MB
6735 if ( !GetBatchCount() )
6736 {
70c7a608
SN
6737 wxRect rect = CellToRect( row, 0);
6738 if ( rect.height > 0 )
6739 {
cb309039 6740 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
70c7a608
SN
6741 rect.x = m_left;
6742 rect.width = m_rowLabelWidth;
6743 m_rowLabelWin->Refresh( TRUE, &rect );
6744 }
2d66e025 6745 }
f85afd4e
MB
6746 }
6747}
6748
6749void wxGrid::SetColLabelValue( int col, const wxString& s )
6750{
6751 if ( m_table )
6752 {
6753 m_table->SetColLabelValue( col, s );
2d66e025
MB
6754 if ( !GetBatchCount() )
6755 {
70c7a608
SN
6756 wxRect rect = CellToRect( 0, col );
6757 if ( rect.width > 0 )
6758 {
cb309039 6759 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
70c7a608
SN
6760 rect.y = m_top;
6761 rect.height = m_colLabelHeight;
6762 m_colLabelWin->Refresh( TRUE, &rect );
6763 }
2d66e025 6764 }
f85afd4e
MB
6765 }
6766}
6767
6768void wxGrid::SetGridLineColour( const wxColour& colour )
6769{
2d66e025
MB
6770 if ( m_gridLineColour != colour )
6771 {
6772 m_gridLineColour = colour;
60ff3b99 6773
2d66e025
MB
6774 wxClientDC dc( m_gridWin );
6775 PrepareDC( dc );
c6a51dcd 6776 DrawAllGridLines( dc, wxRegion() );
2d66e025 6777 }
f85afd4e
MB
6778}
6779
6780void wxGrid::EnableGridLines( bool enable )
6781{
6782 if ( enable != m_gridLinesEnabled )
6783 {
6784 m_gridLinesEnabled = enable;
2d66e025
MB
6785
6786 if ( !GetBatchCount() )
6787 {
6788 if ( enable )
6789 {
6790 wxClientDC dc( m_gridWin );
6791 PrepareDC( dc );
c6a51dcd 6792 DrawAllGridLines( dc, wxRegion() );
2d66e025
MB
6793 }
6794 else
6795 {
6796 m_gridWin->Refresh();
6797 }
6798 }
f85afd4e
MB
6799 }
6800}
6801
6802
6803int wxGrid::GetDefaultRowSize()
6804{
6805 return m_defaultRowHeight;
6806}
6807
6808int wxGrid::GetRowSize( int row )
6809{
b99be8fb
VZ
6810 wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
6811
7c1cb261 6812 return GetRowHeight(row);
f85afd4e
MB
6813}
6814
6815int wxGrid::GetDefaultColSize()
6816{
6817 return m_defaultColWidth;
6818}
6819
6820int wxGrid::GetColSize( int col )
6821{
b99be8fb
VZ
6822 wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
6823
7c1cb261 6824 return GetColWidth(col);
f85afd4e
MB
6825}
6826
2e9a6788
VZ
6827// ============================================================================
6828// access to the grid attributes: each of them has a default value in the grid
6829// itself and may be overidden on a per-cell basis
6830// ============================================================================
6831
6832// ----------------------------------------------------------------------------
6833// setting default attributes
6834// ----------------------------------------------------------------------------
6835
6836void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
6837{
2796cce3 6838 m_defaultCellAttr->SetBackgroundColour(col);
c916e13b
RR
6839#ifdef __WXGTK__
6840 m_gridWin->SetBackgroundColour(col);
6841#endif
2e9a6788
VZ
6842}
6843
6844void wxGrid::SetDefaultCellTextColour( const wxColour& col )
6845{
2796cce3 6846 m_defaultCellAttr->SetTextColour(col);
2e9a6788
VZ
6847}
6848
6849void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
6850{
2796cce3 6851 m_defaultCellAttr->SetAlignment(horiz, vert);
2e9a6788
VZ
6852}
6853
6854void wxGrid::SetDefaultCellFont( const wxFont& font )
6855{
2796cce3
RD
6856 m_defaultCellAttr->SetFont(font);
6857}
6858
0ba143c9
RD
6859void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
6860{
6861 m_defaultCellAttr->SetRenderer(renderer);
6862}
2e9a6788 6863
0ba143c9
RD
6864void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
6865{
6866 m_defaultCellAttr->SetEditor(editor);
6867}
9b4aede2 6868
2e9a6788
VZ
6869// ----------------------------------------------------------------------------
6870// access to the default attrbiutes
6871// ----------------------------------------------------------------------------
6872
f85afd4e
MB
6873wxColour wxGrid::GetDefaultCellBackgroundColour()
6874{
2796cce3 6875 return m_defaultCellAttr->GetBackgroundColour();
f85afd4e
MB
6876}
6877
2e9a6788
VZ
6878wxColour wxGrid::GetDefaultCellTextColour()
6879{
2796cce3 6880 return m_defaultCellAttr->GetTextColour();
2e9a6788
VZ
6881}
6882
6883wxFont wxGrid::GetDefaultCellFont()
6884{
2796cce3 6885 return m_defaultCellAttr->GetFont();
2e9a6788
VZ
6886}
6887
6888void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
6889{
2796cce3 6890 m_defaultCellAttr->GetAlignment(horiz, vert);
2e9a6788
VZ
6891}
6892
0ba143c9
RD
6893wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
6894{
0b190b0f 6895 return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
0ba143c9 6896}
ab79958a 6897
0ba143c9
RD
6898wxGridCellEditor *wxGrid::GetDefaultEditor() const
6899{
28a77bc4 6900 return m_defaultCellAttr->GetEditor(NULL,0,0);
0ba143c9 6901}
9b4aede2 6902
2e9a6788
VZ
6903// ----------------------------------------------------------------------------
6904// access to cell attributes
6905// ----------------------------------------------------------------------------
6906
b99be8fb 6907wxColour wxGrid::GetCellBackgroundColour(int row, int col)
f85afd4e 6908{
0a976765 6909 wxGridCellAttr *attr = GetCellAttr(row, col);
2796cce3 6910 wxColour colour = attr->GetBackgroundColour();
39bcce60 6911 attr->DecRef();
b99be8fb 6912 return colour;
f85afd4e
MB
6913}
6914
b99be8fb 6915wxColour wxGrid::GetCellTextColour( int row, int col )
f85afd4e 6916{
0a976765 6917 wxGridCellAttr *attr = GetCellAttr(row, col);
2796cce3 6918 wxColour colour = attr->GetTextColour();
39bcce60 6919 attr->DecRef();
b99be8fb 6920 return colour;
f85afd4e
MB
6921}
6922
b99be8fb 6923wxFont wxGrid::GetCellFont( int row, int col )
f85afd4e 6924{
0a976765 6925 wxGridCellAttr *attr = GetCellAttr(row, col);
2796cce3 6926 wxFont font = attr->GetFont();
39bcce60 6927 attr->DecRef();
b99be8fb 6928 return font;
f85afd4e
MB
6929}
6930
b99be8fb 6931void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
f85afd4e 6932{
0a976765 6933 wxGridCellAttr *attr = GetCellAttr(row, col);
2796cce3 6934 attr->GetAlignment(horiz, vert);
39bcce60 6935 attr->DecRef();
2e9a6788
VZ
6936}
6937
2796cce3
RD
6938wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
6939{
6940 wxGridCellAttr* attr = GetCellAttr(row, col);
28a77bc4 6941 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
2796cce3 6942 attr->DecRef();
0b190b0f 6943
2796cce3
RD
6944 return renderer;
6945}
6946
9b4aede2
RD
6947wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
6948{
6949 wxGridCellAttr* attr = GetCellAttr(row, col);
28a77bc4 6950 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
9b4aede2 6951 attr->DecRef();
0b190b0f 6952
9b4aede2
RD
6953 return editor;
6954}
6955
283b7808
VZ
6956bool wxGrid::IsReadOnly(int row, int col) const
6957{
6958 wxGridCellAttr* attr = GetCellAttr(row, col);
6959 bool isReadOnly = attr->IsReadOnly();
6960 attr->DecRef();
6961 return isReadOnly;
6962}
6963
2e9a6788 6964// ----------------------------------------------------------------------------
758cbedf 6965// attribute support: cache, automatic provider creation, ...
2e9a6788
VZ
6966// ----------------------------------------------------------------------------
6967
6968bool wxGrid::CanHaveAttributes()
6969{
6970 if ( !m_table )
6971 {
6972 return FALSE;
6973 }
6974
f2d76237 6975 return m_table->CanHaveAttributes();
2e9a6788
VZ
6976}
6977
0a976765
VZ
6978void wxGrid::ClearAttrCache()
6979{
6980 if ( m_attrCache.row != -1 )
6981 {
39bcce60 6982 wxSafeDecRef(m_attrCache.attr);
0a976765
VZ
6983 m_attrCache.row = -1;
6984 }
6985}
6986
6987void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
6988{
6989 wxGrid *self = (wxGrid *)this; // const_cast
6990
6991 self->ClearAttrCache();
6992 self->m_attrCache.row = row;
6993 self->m_attrCache.col = col;
6994 self->m_attrCache.attr = attr;
39bcce60 6995 wxSafeIncRef(attr);
0a976765
VZ
6996}
6997
6998bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
6999{
7000 if ( row == m_attrCache.row && col == m_attrCache.col )
7001 {
7002 *attr = m_attrCache.attr;
39bcce60 7003 wxSafeIncRef(m_attrCache.attr);
0a976765
VZ
7004
7005#ifdef DEBUG_ATTR_CACHE
7006 gs_nAttrCacheHits++;
7007#endif
7008
7009 return TRUE;
7010 }
7011 else
7012 {
7013#ifdef DEBUG_ATTR_CACHE
7014 gs_nAttrCacheMisses++;
7015#endif
7016 return FALSE;
7017 }
7018}
7019
2e9a6788
VZ
7020wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
7021{
0a976765
VZ
7022 wxGridCellAttr *attr;
7023 if ( !LookupAttr(row, col, &attr) )
2e9a6788 7024 {
0a976765
VZ
7025 attr = m_table ? m_table->GetAttr(row, col) : (wxGridCellAttr *)NULL;
7026 CacheAttr(row, col, attr);
7027 }
508011ce
VZ
7028 if (attr)
7029 {
2796cce3 7030 attr->SetDefAttr(m_defaultCellAttr);
508011ce
VZ
7031 }
7032 else
7033 {
2796cce3
RD
7034 attr = m_defaultCellAttr;
7035 attr->IncRef();
7036 }
2e9a6788 7037
0a976765
VZ
7038 return attr;
7039}
7040
7041wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
7042{
7043 wxGridCellAttr *attr;
7044 if ( !LookupAttr(row, col, &attr) || !attr )
7045 {
7046 wxASSERT_MSG( m_table,
7047 _T("we may only be called if CanHaveAttributes() "
7048 "returned TRUE and then m_table should be !NULL") );
7049
7050 attr = m_table->GetAttr(row, col);
7051 if ( !attr )
7052 {
7053 attr = new wxGridCellAttr;
7054
7055 // artificially inc the ref count to match DecRef() in caller
7056 attr->IncRef();
7057
7058 m_table->SetAttr(attr, row, col);
7059 }
2e9a6788 7060
0a976765 7061 CacheAttr(row, col, attr);
2e9a6788 7062 }
2796cce3 7063 attr->SetDefAttr(m_defaultCellAttr);
2e9a6788
VZ
7064 return attr;
7065}
7066
0b190b0f
VZ
7067// ----------------------------------------------------------------------------
7068// setting column attributes (wrappers around SetColAttr)
7069// ----------------------------------------------------------------------------
7070
7071void wxGrid::SetColFormatBool(int col)
7072{
7073 SetColFormatCustom(col, wxGRID_VALUE_BOOL);
7074}
7075
7076void wxGrid::SetColFormatNumber(int col)
7077{
7078 SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
7079}
7080
7081void wxGrid::SetColFormatFloat(int col, int width, int precision)
7082{
7083 wxString typeName = wxGRID_VALUE_FLOAT;
7084 if ( (width != -1) || (precision != -1) )
7085 {
7086 typeName << _T(':') << width << _T(',') << precision;
7087 }
7088
7089 SetColFormatCustom(col, typeName);
7090}
7091
7092void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
7093{
7094 wxGridCellAttr *attr = new wxGridCellAttr;
7095 wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
7096 attr->SetRenderer(renderer);
7097
7098 SetColAttr(col, attr);
7099}
7100
758cbedf
VZ
7101// ----------------------------------------------------------------------------
7102// setting cell attributes: this is forwarded to the table
7103// ----------------------------------------------------------------------------
7104
7105void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
7106{
7107 if ( CanHaveAttributes() )
7108 {
7109 m_table->SetRowAttr(attr, row);
7110 }
7111 else
7112 {
39bcce60 7113 wxSafeDecRef(attr);
758cbedf
VZ
7114 }
7115}
7116
7117void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
7118{
7119 if ( CanHaveAttributes() )
7120 {
7121 m_table->SetColAttr(attr, col);
7122 }
7123 else
7124 {
39bcce60 7125 wxSafeDecRef(attr);
758cbedf
VZ
7126 }
7127}
7128
2e9a6788
VZ
7129void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
7130{
7131 if ( CanHaveAttributes() )
7132 {
0a976765 7133 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
2e9a6788
VZ
7134 attr->SetBackgroundColour(colour);
7135 attr->DecRef();
7136 }
7137}
7138
7139void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
7140{
7141 if ( CanHaveAttributes() )
7142 {
0a976765 7143 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
2e9a6788
VZ
7144 attr->SetTextColour(colour);
7145 attr->DecRef();
7146 }
7147}
7148
7149void wxGrid::SetCellFont( int row, int col, const wxFont& font )
7150{
7151 if ( CanHaveAttributes() )
7152 {
0a976765 7153 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
2e9a6788
VZ
7154 attr->SetFont(font);
7155 attr->DecRef();
7156 }
7157}
7158
7159void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
7160{
7161 if ( CanHaveAttributes() )
7162 {
0a976765 7163 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
2e9a6788
VZ
7164 attr->SetAlignment(horiz, vert);
7165 attr->DecRef();
ab79958a
VZ
7166 }
7167}
7168
7169void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
7170{
7171 if ( CanHaveAttributes() )
7172 {
0a976765 7173 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
ab79958a
VZ
7174 attr->SetRenderer(renderer);
7175 attr->DecRef();
9b4aede2
RD
7176 }
7177}
7178
7179void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
7180{
7181 if ( CanHaveAttributes() )
7182 {
7183 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7184 attr->SetEditor(editor);
7185 attr->DecRef();
283b7808
VZ
7186 }
7187}
7188
7189void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
7190{
7191 if ( CanHaveAttributes() )
7192 {
7193 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7194 attr->SetReadOnly(isReadOnly);
7195 attr->DecRef();
2e9a6788 7196 }
f85afd4e
MB
7197}
7198
f2d76237
RD
7199// ----------------------------------------------------------------------------
7200// Data type registration
7201// ----------------------------------------------------------------------------
7202
7203void wxGrid::RegisterDataType(const wxString& typeName,
7204 wxGridCellRenderer* renderer,
7205 wxGridCellEditor* editor)
7206{
7207 m_typeRegistry->RegisterDataType(typeName, renderer, editor);
7208}
7209
7210
99306db2 7211wxGridCellEditor* wxGrid::GetDefaultEditorForCell(int row, int col) const
f2d76237
RD
7212{
7213 wxString typeName = m_table->GetTypeName(row, col);
7214 return GetDefaultEditorForType(typeName);
7215}
7216
99306db2 7217wxGridCellRenderer* wxGrid::GetDefaultRendererForCell(int row, int col) const
f2d76237
RD
7218{
7219 wxString typeName = m_table->GetTypeName(row, col);
7220 return GetDefaultRendererForType(typeName);
7221}
7222
99306db2
VZ
7223wxGridCellEditor*
7224wxGrid::GetDefaultEditorForType(const wxString& typeName) const
f2d76237 7225{
c4608a8a 7226 int index = m_typeRegistry->FindOrCloneDataType(typeName);
0b190b0f
VZ
7227 if ( index == wxNOT_FOUND )
7228 {
7229 wxFAIL_MSG(wxT("Unknown data type name"));
7230
f2d76237
RD
7231 return NULL;
7232 }
0b190b0f 7233
f2d76237
RD
7234 return m_typeRegistry->GetEditor(index);
7235}
7236
99306db2
VZ
7237wxGridCellRenderer*
7238wxGrid::GetDefaultRendererForType(const wxString& typeName) const
f2d76237 7239{
c4608a8a 7240 int index = m_typeRegistry->FindOrCloneDataType(typeName);
0b190b0f
VZ
7241 if ( index == wxNOT_FOUND )
7242 {
c4608a8a 7243 wxFAIL_MSG(wxT("Unknown data type name"));
0b190b0f 7244
c4608a8a 7245 return NULL;
e72b4213 7246 }
0b190b0f 7247
c4608a8a 7248 return m_typeRegistry->GetRenderer(index);
f2d76237
RD
7249}
7250
7251
2e9a6788
VZ
7252// ----------------------------------------------------------------------------
7253// row/col size
7254// ----------------------------------------------------------------------------
7255
6e8524b1
MB
7256void wxGrid::EnableDragRowSize( bool enable )
7257{
7258 m_canDragRowSize = enable;
7259}
7260
7261
7262void wxGrid::EnableDragColSize( bool enable )
7263{
7264 m_canDragColSize = enable;
7265}
7266
4cfa5de6
RD
7267void wxGrid::EnableDragGridSize( bool enable )
7268{
7269 m_canDragGridSize = enable;
7270}
7271
6e8524b1 7272
f85afd4e
MB
7273void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
7274{
7275 m_defaultRowHeight = wxMax( height, WXGRID_MIN_ROW_HEIGHT );
7276
7277 if ( resizeExistingRows )
7278 {
7c1cb261
VZ
7279 InitRowHeights();
7280
f85afd4e 7281 CalcDimensions();
f85afd4e
MB
7282 }
7283}
7284
7285void wxGrid::SetRowSize( int row, int height )
7286{
b99be8fb 7287 wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
60ff3b99 7288
7c1cb261
VZ
7289 if ( m_rowHeights.IsEmpty() )
7290 {
7291 // need to really create the array
7292 InitRowHeights();
7293 }
60ff3b99 7294
b99be8fb
VZ
7295 int h = wxMax( 0, height );
7296 int diff = h - m_rowHeights[row];
60ff3b99 7297
b99be8fb 7298 m_rowHeights[row] = h;
7c1cb261 7299 int i;
b99be8fb 7300 for ( i = row; i < m_numRows; i++ )
f85afd4e 7301 {
b99be8fb 7302 m_rowBottoms[i] += diff;
f85afd4e 7303 }
b99be8fb 7304 CalcDimensions();
f85afd4e
MB
7305}
7306
7307void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
7308{
7309 m_defaultColWidth = wxMax( width, WXGRID_MIN_COL_WIDTH );
7310
7311 if ( resizeExistingCols )
7312 {
7c1cb261
VZ
7313 InitColWidths();
7314
f85afd4e 7315 CalcDimensions();
f85afd4e
MB
7316 }
7317}
7318
7319void wxGrid::SetColSize( int col, int width )
7320{
b99be8fb 7321 wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
60ff3b99 7322
43947979
VZ
7323 // should we check that it's bigger than GetColMinimalWidth(col) here?
7324
7c1cb261
VZ
7325 if ( m_colWidths.IsEmpty() )
7326 {
7327 // need to really create the array
7328 InitColWidths();
7329 }
f85afd4e 7330
b99be8fb
VZ
7331 int w = wxMax( 0, width );
7332 int diff = w - m_colWidths[col];
7333 m_colWidths[col] = w;
60ff3b99 7334
7c1cb261 7335 int i;
b99be8fb 7336 for ( i = col; i < m_numCols; i++ )
f85afd4e 7337 {
b99be8fb 7338 m_colRights[i] += diff;
f85afd4e 7339 }
b99be8fb 7340 CalcDimensions();
f85afd4e
MB
7341}
7342
2d66e025 7343
43947979
VZ
7344void wxGrid::SetColMinimalWidth( int col, int width )
7345{
af547d51
VZ
7346 m_colMinWidths.Put(col, width);
7347}
7348
7349void wxGrid::SetRowMinimalHeight( int row, int width )
7350{
7351 m_rowMinHeights.Put(row, width);
43947979
VZ
7352}
7353
7354int wxGrid::GetColMinimalWidth(int col) const
7355{
af547d51
VZ
7356 long value = m_colMinWidths.Get(col);
7357 return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_COL_WIDTH;
7358}
7359
7360int wxGrid::GetRowMinimalHeight(int row) const
7361{
7362 long value = m_rowMinHeights.Get(row);
7363 return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_ROW_HEIGHT;
43947979
VZ
7364}
7365
57c086ef
VZ
7366// ----------------------------------------------------------------------------
7367// auto sizing
7368// ----------------------------------------------------------------------------
7369
af547d51 7370void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
65e4e78e
VZ
7371{
7372 wxClientDC dc(m_gridWin);
7373
a95e38c0
VZ
7374 // init both of them to avoid compiler warnings, even if weo nly need one
7375 int row = -1,
7376 col = -1;
af547d51
VZ
7377 if ( column )
7378 col = colOrRow;
7379 else
7380 row = colOrRow;
7381
7382 wxCoord extent, extentMax = 0;
7383 int max = column ? m_numRows : m_numCols;
39bcce60 7384 for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
65e4e78e 7385 {
af547d51
VZ
7386 if ( column )
7387 row = rowOrCol;
7388 else
7389 col = rowOrCol;
7390
65e4e78e 7391 wxGridCellAttr* attr = GetCellAttr(row, col);
28a77bc4 7392 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
65e4e78e
VZ
7393 if ( renderer )
7394 {
af547d51
VZ
7395 wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
7396 extent = column ? size.x : size.y;
7397 if ( extent > extentMax )
65e4e78e 7398 {
af547d51 7399 extentMax = extent;
65e4e78e 7400 }
0b190b0f
VZ
7401
7402 renderer->DecRef();
65e4e78e
VZ
7403 }
7404
7405 attr->DecRef();
7406 }
7407
af547d51
VZ
7408 // now also compare with the column label extent
7409 wxCoord w, h;
65e4e78e 7410 dc.SetFont( GetLabelFont() );
294d195c
MB
7411
7412 if ( column )
7413 dc.GetTextExtent( GetColLabelValue(col), &w, &h );
7414 else
7415 dc.GetTextExtent( GetRowLabelValue(col), &w, &h );
7416
af547d51
VZ
7417 extent = column ? w : h;
7418 if ( extent > extentMax )
65e4e78e 7419 {
af547d51 7420 extentMax = extent;
65e4e78e
VZ
7421 }
7422
af547d51 7423 if ( !extentMax )
65e4e78e 7424 {
af547d51
VZ
7425 // empty column - give default extent (notice that if extentMax is less
7426 // than default extent but != 0, it's ok)
7427 extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
65e4e78e
VZ
7428 }
7429 else
7430 {
a95e38c0
VZ
7431 if ( column )
7432 {
7433 // leave some space around text
7434 extentMax += 10;
7435 }
65e4e78e
VZ
7436 }
7437
af547d51
VZ
7438 if ( column )
7439 SetColSize(col, extentMax);
7440 else
39bcce60 7441 SetRowSize(row, extentMax);
af547d51 7442
65e4e78e
VZ
7443 if ( setAsMin )
7444 {
af547d51
VZ
7445 if ( column )
7446 SetColMinimalWidth(col, extentMax);
7447 else
39bcce60 7448 SetRowMinimalHeight(row, extentMax);
65e4e78e
VZ
7449 }
7450}
7451
266e8367 7452int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
65e4e78e 7453{
57c086ef
VZ
7454 int width = m_rowLabelWidth;
7455
65e4e78e
VZ
7456 for ( int col = 0; col < m_numCols; col++ )
7457 {
266e8367
VZ
7458 if ( !calcOnly )
7459 {
7460 AutoSizeColumn(col, setAsMin);
7461 }
57c086ef
VZ
7462
7463 width += GetColWidth(col);
65e4e78e 7464 }
57c086ef 7465
266e8367 7466 return width;
65e4e78e
VZ
7467}
7468
266e8367 7469int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
57c086ef
VZ
7470{
7471 int height = m_colLabelHeight;
7472
7473 for ( int row = 0; row < m_numRows; row++ )
7474 {
af547d51
VZ
7475 if ( !calcOnly )
7476 {
7477 AutoSizeRow(row, setAsMin);
7478 }
57c086ef
VZ
7479
7480 height += GetRowHeight(row);
7481 }
7482
266e8367 7483 return height;
57c086ef
VZ
7484}
7485
7486void wxGrid::AutoSize()
7487{
266e8367
VZ
7488 // set the size too
7489 SetSize(SetOrCalcColumnSizes(FALSE), SetOrCalcRowSizes(FALSE));
7490}
7491
7492wxSize wxGrid::DoGetBestSize() const
7493{
7494 // don't set sizes, only calculate them
7495 wxGrid *self = (wxGrid *)this; // const_cast
7496
7497 return wxSize(self->SetOrCalcColumnSizes(TRUE),
7498 self->SetOrCalcRowSizes(TRUE));
7499}
7500
7501void wxGrid::Fit()
7502{
7503 AutoSize();
57c086ef
VZ
7504}
7505
7506// ----------------------------------------------------------------------------
7507// cell value accessor functions
7508// ----------------------------------------------------------------------------
f85afd4e
MB
7509
7510void wxGrid::SetCellValue( int row, int col, const wxString& s )
7511{
7512 if ( m_table )
7513 {
7514 m_table->SetValue( row, col, s.c_str() );
2d66e025
MB
7515 if ( !GetBatchCount() )
7516 {
7517 wxClientDC dc( m_gridWin );
7518 PrepareDC( dc );
7519 DrawCell( dc, wxGridCellCoords(row, col) );
7520 }
60ff3b99 7521
f85afd4e 7522 if ( m_currentCellCoords.GetRow() == row &&
4cfa5de6
RD
7523 m_currentCellCoords.GetCol() == col &&
7524 IsCellEditControlEnabled())
f85afd4e 7525 {
4cfa5de6
RD
7526 HideCellEditControl();
7527 ShowCellEditControl(); // will reread data from table
f85afd4e 7528 }
f85afd4e
MB
7529 }
7530}
7531
7532
7533//
2d66e025 7534// ------ Block, row and col selection
f85afd4e
MB
7535//
7536
7537void wxGrid::SelectRow( int row, bool addToSelected )
7538{
b5808881
SN
7539 if ( IsSelection() && !addToSelected )
7540 m_selection->ClearSelection();
70c7a608 7541
b5808881 7542 m_selection->SelectRow( row );
f85afd4e
MB
7543}
7544
7545
7546void wxGrid::SelectCol( int col, bool addToSelected )
7547{
b5808881
SN
7548 if ( IsSelection() && !addToSelected )
7549 m_selection->ClearSelection();
f85afd4e 7550
b5808881 7551 m_selection->SelectCol( col );
f85afd4e
MB
7552}
7553
7554
7555void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
7556{
7557 int temp;
da6af900 7558 wxGridCellCoords updateTopLeft, updateBottomRight;
8f177c8e 7559
f85afd4e
MB
7560 if ( topRow > bottomRow )
7561 {
7562 temp = topRow;
7563 topRow = bottomRow;
7564 bottomRow = temp;
7565 }
7566
7567 if ( leftCol > rightCol )
7568 {
7569 temp = leftCol;
7570 leftCol = rightCol;
7571 rightCol = temp;
7572 }
f0102d2a 7573
70c7a608
SN
7574 updateTopLeft = wxGridCellCoords( topRow, leftCol );
7575 updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
da6af900 7576
b5808881
SN
7577 if ( m_selectingTopLeft != updateTopLeft ||
7578 m_selectingBottomRight != updateBottomRight )
da6af900 7579 {
70c7a608
SN
7580 // Compute two optimal update rectangles:
7581 // Either one rectangle is a real subset of the
7582 // other, or they are (almost) disjoint!
7583 wxRect rect[4];
ee6694a7
VZ
7584 bool need_refresh[4];
7585 need_refresh[0] =
7586 need_refresh[1] =
7587 need_refresh[2] =
7588 need_refresh[3] = FALSE;
70c7a608
SN
7589 int i;
7590
7591 // Store intermediate values
b5808881
SN
7592 wxCoord oldLeft = m_selectingTopLeft.GetCol();
7593 wxCoord oldTop = m_selectingTopLeft.GetRow();
7594 wxCoord oldRight = m_selectingBottomRight.GetCol();
7595 wxCoord oldBottom = m_selectingBottomRight.GetRow();
70c7a608
SN
7596
7597 // Determine the outer/inner coordinates.
7598 if (oldLeft > leftCol)
f0102d2a 7599 {
70c7a608
SN
7600 temp = oldLeft;
7601 oldLeft = leftCol;
7602 leftCol = temp;
cb309039 7603 }
70c7a608 7604 if (oldTop > topRow )
f0102d2a 7605 {
70c7a608
SN
7606 temp = oldTop;
7607 oldTop = topRow;
7608 topRow = temp;
cb309039
SN
7609 }
7610 if (oldRight < rightCol )
70c7a608
SN
7611 {
7612 temp = oldRight;
7613 oldRight = rightCol;
7614 rightCol = temp;
cb309039
SN
7615 }
7616 if (oldBottom < bottomRow)
7617 {
70c7a608
SN
7618 temp = oldBottom;
7619 oldBottom = bottomRow;
7620 bottomRow = temp;
cb309039 7621 }
70c7a608
SN
7622
7623 // Now, either the stuff marked old is the outer
7624 // rectangle or we don't have a situation where one
7625 // is contained in the other.
b99be8fb 7626
cb309039
SN
7627 if ( oldLeft < leftCol )
7628 {
7629 need_refresh[0] = TRUE;
7630 rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
7631 oldLeft ),
b99be8fb 7632 wxGridCellCoords ( oldBottom,
cb309039
SN
7633 leftCol - 1 ) );
7634 }
7635
7636 if ( oldTop < topRow )
7637 {
7638 need_refresh[1] = TRUE;
7639 rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
7640 leftCol ),
b99be8fb 7641 wxGridCellCoords ( topRow - 1,
cb309039
SN
7642 rightCol ) );
7643 }
7644
7645 if ( oldRight > rightCol )
7646 {
7647 need_refresh[2] = TRUE;
7648 rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
7649 rightCol + 1 ),
7650 wxGridCellCoords ( oldBottom,
7651 oldRight ) );
7652 }
7653
7654 if ( oldBottom > bottomRow )
7655 {
7656 need_refresh[3] = TRUE;
7657 rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
7658 leftCol ),
7659 wxGridCellCoords ( oldBottom,
7660 rightCol ) );
7661 }
70c7a608
SN
7662
7663
7664 // Change Selection
b5808881
SN
7665 m_selectingTopLeft = updateTopLeft;
7666 m_selectingBottomRight = updateBottomRight;
b99be8fb 7667
70c7a608
SN
7668 // various Refresh() calls
7669 for (i = 0; i < 4; i++ )
7670 if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
c6a51dcd 7671 m_gridWin->Refresh( FALSE, &(rect[i]) );
da6af900 7672 }
f85afd4e 7673
5c8fc7c1
SN
7674 // never generate an event as it will be generated from
7675 // wxGridSelection::SelectBlock!
f85afd4e
MB
7676}
7677
7678void wxGrid::SelectAll()
7679{
b5808881
SN
7680 m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
7681}
f85afd4e 7682
b5808881
SN
7683bool wxGrid::IsSelection()
7684{
7685 return ( m_selection->IsSelection() ||
7686 ( m_selectingTopLeft != wxGridNoCellCoords &&
7687 m_selectingBottomRight != wxGridNoCellCoords ) );
f85afd4e
MB
7688}
7689
b5808881
SN
7690bool wxGrid::IsInSelection( int row, int col )
7691{
7692 return ( m_selection->IsInSelection( row, col ) ||
7693 ( row >= m_selectingTopLeft.GetRow() &&
7694 col >= m_selectingTopLeft.GetCol() &&
7695 row <= m_selectingBottomRight.GetRow() &&
7696 col <= m_selectingBottomRight.GetCol() ) );
7697}
f85afd4e
MB
7698
7699void wxGrid::ClearSelection()
7700{
b5808881
SN
7701 m_selectingTopLeft = wxGridNoCellCoords;
7702 m_selectingBottomRight = wxGridNoCellCoords;
7703 m_selection->ClearSelection();
8f177c8e 7704}
f85afd4e
MB
7705
7706
da6af900 7707// This function returns the rectangle that encloses the given block
2d66e025
MB
7708// in device coords clipped to the client size of the grid window.
7709//
58dd5b3b
MB
7710wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
7711 const wxGridCellCoords &bottomRight )
f85afd4e 7712{
58dd5b3b 7713 wxRect rect( wxGridNoCellRect );
f85afd4e
MB
7714 wxRect cellRect;
7715
58dd5b3b
MB
7716 cellRect = CellToRect( topLeft );
7717 if ( cellRect != wxGridNoCellRect )
f85afd4e 7718 {
58dd5b3b
MB
7719 rect = cellRect;
7720 }
7721 else
7722 {
7723 rect = wxRect( 0, 0, 0, 0 );
7724 }
60ff3b99 7725
58dd5b3b
MB
7726 cellRect = CellToRect( bottomRight );
7727 if ( cellRect != wxGridNoCellRect )
7728 {
7729 rect += cellRect;
2d66e025
MB
7730 }
7731 else
7732 {
7733 return wxGridNoCellRect;
f85afd4e
MB
7734 }
7735
58dd5b3b
MB
7736 // convert to scrolled coords
7737 //
7738 int left, top, right, bottom;
7739 CalcScrolledPosition( rect.GetLeft(), rect.GetTop(), &left, &top );
7740 CalcScrolledPosition( rect.GetRight(), rect.GetBottom(), &right, &bottom );
7741
7742 int cw, ch;
7743 m_gridWin->GetClientSize( &cw, &ch );
7744
7745 rect.SetLeft( wxMax(0, left) );
7746 rect.SetTop( wxMax(0, top) );
7747 rect.SetRight( wxMin(cw, right) );
7748 rect.SetBottom( wxMin(ch, bottom) );
7749
f85afd4e
MB
7750 return rect;
7751}
7752
7753
58dd5b3b 7754
f85afd4e
MB
7755//
7756// ------ Grid event classes
7757//
7758
7759IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxEvent )
7760
7761wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
5c8fc7c1 7762 int row, int col, int x, int y, bool sel,
f85afd4e
MB
7763 bool control, bool shift, bool alt, bool meta )
7764 : wxNotifyEvent( type, id )
7765{
7766 m_row = row;
7767 m_col = col;
7768 m_x = x;
7769 m_y = y;
5c8fc7c1 7770 m_selecting = sel;
f85afd4e
MB
7771 m_control = control;
7772 m_shift = shift;
7773 m_alt = alt;
7774 m_meta = meta;
8f177c8e 7775
f85afd4e
MB
7776 SetEventObject(obj);
7777}
7778
7779
7780IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxEvent )
7781
7782wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
7783 int rowOrCol, int x, int y,
7784 bool control, bool shift, bool alt, bool meta )
7785 : wxNotifyEvent( type, id )
7786{
7787 m_rowOrCol = rowOrCol;
7788 m_x = x;
7789 m_y = y;
7790 m_control = control;
7791 m_shift = shift;
7792 m_alt = alt;
7793 m_meta = meta;
8f177c8e 7794
f85afd4e
MB
7795 SetEventObject(obj);
7796}
7797
7798
7799IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxEvent )
7800
7801wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
8f177c8e
VZ
7802 const wxGridCellCoords& topLeft,
7803 const wxGridCellCoords& bottomRight,
5c8fc7c1
SN
7804 bool sel, bool control,
7805 bool shift, bool alt, bool meta )
8f177c8e 7806 : wxNotifyEvent( type, id )
f85afd4e
MB
7807{
7808 m_topLeft = topLeft;
7809 m_bottomRight = bottomRight;
5c8fc7c1 7810 m_selecting = sel;
f85afd4e
MB
7811 m_control = control;
7812 m_shift = shift;
7813 m_alt = alt;
7814 m_meta = meta;
7815
7816 SetEventObject(obj);
7817}
7818
7819
7820#endif // ifndef wxUSE_NEW_GRID