]> git.saurik.com Git - wxWidgets.git/blob - src/generic/grid.cpp
projects / wxWidgets.git / blob
? search:


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