]> git.saurik.com Git - wxWidgets.git/blob - src/generic/grid.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
return the index of the inserted/appended item
[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: Robin Dunn, Vadim Zeitlin
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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "grid.h"
22 #endif
23
24 // For compilers that support precompilatixon, 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 wxUSE_GRID
34
35 #ifndef WX_PRECOMP
36 #include "wx/utils.h"
37 #include "wx/dcclient.h"
38 #include "wx/settings.h"
39 #include "wx/log.h"
40 #include "wx/textctrl.h"
41 #include "wx/checkbox.h"
42 #include "wx/combobox.h"
43 #include "wx/valtext.h"
44 #endif
45
46 #include "wx/textfile.h"
47 #include "wx/spinctrl.h"
48 #include "wx/tokenzr.h"
49
50 #include "wx/grid.h"
51 #include "wx/generic/gridsel.h"
52
53 #if defined(__WXMOTIF__)
54 #define WXUNUSED_MOTIF(identifier) WXUNUSED(identifier)
55 #else
56 #define WXUNUSED_MOTIF(identifier) identifier
57 #endif
58
59 #if defined(__WXGTK__)
60 #define WXUNUSED_GTK(identifier) WXUNUSED(identifier)
61 #else
62 #define WXUNUSED_GTK(identifier) identifier
63 #endif
64
65 // Required for wxIs... functions
66 #include <ctype.h>
67
68 // ----------------------------------------------------------------------------
69 // array classes
70 // ----------------------------------------------------------------------------
71
72 WX_DEFINE_ARRAY_WITH_DECL_NO_PTR(wxGridCellAttr *, wxArrayAttrs,
73 class WXDLLIMPEXP_ADV);
74
75 struct wxGridCellWithAttr
76 {
77 wxGridCellWithAttr(int row, int col, wxGridCellAttr *attr_)
78 : coords(row, col), attr(attr_)
79 {
80 }
81
82 ~wxGridCellWithAttr()
83 {
84 attr->DecRef();
85 }
86
87 wxGridCellCoords coords;
88 wxGridCellAttr *attr;
89
90 // Cannot do this:
91 // DECLARE_NO_COPY_CLASS(wxGridCellWithAttr)
92 // without rewriting the macros, which require a public copy constructor.
93 };
94
95 WX_DECLARE_OBJARRAY_WITH_DECL(wxGridCellWithAttr, wxGridCellWithAttrArray,
96 class WXDLLIMPEXP_ADV);
97
98 #include "wx/arrimpl.cpp"
99
100 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
101 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
102
103 // ----------------------------------------------------------------------------
104 // events
105 // ----------------------------------------------------------------------------
106
107 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_CLICK)
108 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_CLICK)
109 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_DCLICK)
110 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_DCLICK)
111 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_CLICK)
112 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_CLICK)
113 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_DCLICK)
114 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_DCLICK)
115 DEFINE_EVENT_TYPE(wxEVT_GRID_ROW_SIZE)
116 DEFINE_EVENT_TYPE(wxEVT_GRID_COL_SIZE)
117 DEFINE_EVENT_TYPE(wxEVT_GRID_RANGE_SELECT)
118 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_CHANGE)
119 DEFINE_EVENT_TYPE(wxEVT_GRID_SELECT_CELL)
120 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_SHOWN)
121 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_HIDDEN)
122 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_CREATED)
123
124 // ----------------------------------------------------------------------------
125 // private classes
126 // ----------------------------------------------------------------------------
127
128 class WXDLLIMPEXP_ADV wxGridRowLabelWindow : public wxWindow
129 {
130 public:
131 wxGridRowLabelWindow() { m_owner = (wxGrid *)NULL; }
132 wxGridRowLabelWindow( wxGrid *parent, wxWindowID id,
133 const wxPoint &pos, const wxSize &size );
134
135 private:
136 wxGrid *m_owner;
137
138 void OnPaint( wxPaintEvent& event );
139 void OnMouseEvent( wxMouseEvent& event );
140 void OnMouseWheel( wxMouseEvent& event );
141 void OnKeyDown( wxKeyEvent& event );
142 void OnKeyUp( wxKeyEvent& );
143
144 DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
145 DECLARE_EVENT_TABLE()
146 DECLARE_NO_COPY_CLASS(wxGridRowLabelWindow)
147 };
148
149
150 class WXDLLIMPEXP_ADV wxGridColLabelWindow : public wxWindow
151 {
152 public:
153 wxGridColLabelWindow() { m_owner = (wxGrid *)NULL; }
154 wxGridColLabelWindow( wxGrid *parent, wxWindowID id,
155 const wxPoint &pos, const wxSize &size );
156
157 private:
158 wxGrid *m_owner;
159
160 void OnPaint( wxPaintEvent &event );
161 void OnMouseEvent( wxMouseEvent& event );
162 void OnMouseWheel( wxMouseEvent& event );
163 void OnKeyDown( wxKeyEvent& event );
164 void OnKeyUp( wxKeyEvent& );
165
166 DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
167 DECLARE_EVENT_TABLE()
168 DECLARE_NO_COPY_CLASS(wxGridColLabelWindow)
169 };
170
171
172 class WXDLLIMPEXP_ADV wxGridCornerLabelWindow : public wxWindow
173 {
174 public:
175 wxGridCornerLabelWindow() { m_owner = (wxGrid *)NULL; }
176 wxGridCornerLabelWindow( wxGrid *parent, wxWindowID id,
177 const wxPoint &pos, const wxSize &size );
178
179 private:
180 wxGrid *m_owner;
181
182 void OnMouseEvent( wxMouseEvent& event );
183 void OnMouseWheel( wxMouseEvent& event );
184 void OnKeyDown( wxKeyEvent& event );
185 void OnKeyUp( wxKeyEvent& );
186 void OnPaint( wxPaintEvent& event );
187
188 DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
189 DECLARE_EVENT_TABLE()
190 DECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow)
191 };
192
193 class WXDLLIMPEXP_ADV wxGridWindow : public wxWindow
194 {
195 public:
196 wxGridWindow()
197 {
198 m_owner = (wxGrid *)NULL;
199 m_rowLabelWin = (wxGridRowLabelWindow *)NULL;
200 m_colLabelWin = (wxGridColLabelWindow *)NULL;
201 }
202
203 wxGridWindow( wxGrid *parent,
204 wxGridRowLabelWindow *rowLblWin,
205 wxGridColLabelWindow *colLblWin,
206 wxWindowID id, const wxPoint &pos, const wxSize &size );
207 ~wxGridWindow();
208
209 void ScrollWindow( int dx, int dy, const wxRect *rect );
210
211 wxGrid* GetOwner() { return m_owner; }
212
213 private:
214 wxGrid *m_owner;
215 wxGridRowLabelWindow *m_rowLabelWin;
216 wxGridColLabelWindow *m_colLabelWin;
217
218 void OnPaint( wxPaintEvent &event );
219 void OnMouseWheel( wxMouseEvent& event );
220 void OnMouseEvent( wxMouseEvent& event );
221 void OnKeyDown( wxKeyEvent& );
222 void OnKeyUp( wxKeyEvent& );
223 void OnEraseBackground( wxEraseEvent& );
224
225
226 DECLARE_DYNAMIC_CLASS(wxGridWindow)
227 DECLARE_EVENT_TABLE()
228 DECLARE_NO_COPY_CLASS(wxGridWindow)
229 };
230
231
232
233 class wxGridCellEditorEvtHandler : public wxEvtHandler
234 {
235 public:
236 wxGridCellEditorEvtHandler()
237 : m_grid(0), m_editor(0)
238 { }
239 wxGridCellEditorEvtHandler(wxGrid* grid, wxGridCellEditor* editor)
240 : m_grid(grid), m_editor(editor)
241 { }
242
243 void OnKeyDown(wxKeyEvent& event);
244 void OnChar(wxKeyEvent& event);
245
246 private:
247 wxGrid* m_grid;
248 wxGridCellEditor* m_editor;
249 DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
250 DECLARE_EVENT_TABLE()
251 DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler)
252 };
253
254
255 IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler, wxEvtHandler )
256 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
257 EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
258 EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )
259 END_EVENT_TABLE()
260
261
262
263 // ----------------------------------------------------------------------------
264 // the internal data representation used by wxGridCellAttrProvider
265 // ----------------------------------------------------------------------------
266
267 // this class stores attributes set for cells
268 class WXDLLIMPEXP_ADV wxGridCellAttrData
269 {
270 public:
271 void SetAttr(wxGridCellAttr *attr, int row, int col);
272 wxGridCellAttr *GetAttr(int row, int col) const;
273 void UpdateAttrRows( size_t pos, int numRows );
274 void UpdateAttrCols( size_t pos, int numCols );
275
276 private:
277 // searches for the attr for given cell, returns wxNOT_FOUND if not found
278 int FindIndex(int row, int col) const;
279
280 wxGridCellWithAttrArray m_attrs;
281 };
282
283 // this class stores attributes set for rows or columns
284 class WXDLLIMPEXP_ADV wxGridRowOrColAttrData
285 {
286 public:
287 // empty ctor to suppress warnings
288 wxGridRowOrColAttrData() { }
289 ~wxGridRowOrColAttrData();
290
291 void SetAttr(wxGridCellAttr *attr, int rowOrCol);
292 wxGridCellAttr *GetAttr(int rowOrCol) const;
293 void UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols );
294
295 private:
296 wxArrayInt m_rowsOrCols;
297 wxArrayAttrs m_attrs;
298 };
299
300 // NB: this is just a wrapper around 3 objects: one which stores cell
301 // attributes, and 2 others for row/col ones
302 class WXDLLIMPEXP_ADV wxGridCellAttrProviderData
303 {
304 public:
305 wxGridCellAttrData m_cellAttrs;
306 wxGridRowOrColAttrData m_rowAttrs,
307 m_colAttrs;
308 };
309
310
311 // ----------------------------------------------------------------------------
312 // data structures used for the data type registry
313 // ----------------------------------------------------------------------------
314
315 struct wxGridDataTypeInfo
316 {
317 wxGridDataTypeInfo(const wxString& typeName,
318 wxGridCellRenderer* renderer,
319 wxGridCellEditor* editor)
320 : m_typeName(typeName), m_renderer(renderer), m_editor(editor)
321 { }
322
323 ~wxGridDataTypeInfo()
324 {
325 wxSafeDecRef(m_renderer);
326 wxSafeDecRef(m_editor);
327 }
328
329 wxString m_typeName;
330 wxGridCellRenderer* m_renderer;
331 wxGridCellEditor* m_editor;
332
333 DECLARE_NO_COPY_CLASS(wxGridDataTypeInfo)
334 };
335
336
337 WX_DEFINE_ARRAY_WITH_DECL_NO_PTR(wxGridDataTypeInfo*, wxGridDataTypeInfoArray,
338 class WXDLLIMPEXP_ADV);
339
340
341 class WXDLLIMPEXP_ADV wxGridTypeRegistry
342 {
343 public:
344 wxGridTypeRegistry() {}
345 ~wxGridTypeRegistry();
346
347 void RegisterDataType(const wxString& typeName,
348 wxGridCellRenderer* renderer,
349 wxGridCellEditor* editor);
350
351 // find one of already registered data types
352 int FindRegisteredDataType(const wxString& typeName);
353
354 // try to FindRegisteredDataType(), if this fails and typeName is one of
355 // standard typenames, register it and return its index
356 int FindDataType(const wxString& typeName);
357
358 // try to FindDataType(), if it fails see if it is not one of already
359 // registered data types with some params in which case clone the
360 // registered data type and set params for it
361 int FindOrCloneDataType(const wxString& typeName);
362
363 wxGridCellRenderer* GetRenderer(int index);
364 wxGridCellEditor* GetEditor(int index);
365
366 private:
367 wxGridDataTypeInfoArray m_typeinfo;
368 };
369
370 // ----------------------------------------------------------------------------
371 // conditional compilation
372 // ----------------------------------------------------------------------------
373
374 #ifndef WXGRID_DRAW_LINES
375 #define WXGRID_DRAW_LINES 1
376 #endif
377
378 // ----------------------------------------------------------------------------
379 // globals
380 // ----------------------------------------------------------------------------
381
382 //#define DEBUG_ATTR_CACHE
383 #ifdef DEBUG_ATTR_CACHE
384 static size_t gs_nAttrCacheHits = 0;
385 static size_t gs_nAttrCacheMisses = 0;
386 #endif // DEBUG_ATTR_CACHE
387
388 // ----------------------------------------------------------------------------
389 // constants
390 // ----------------------------------------------------------------------------
391
392 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
393 wxRect wxGridNoCellRect( -1, -1, -1, -1 );
394
395 // scroll line size
396 // TODO: this doesn't work at all, grid cells have different sizes and approx
397 // calculations don't work as because of the size mismatch scrollbars
398 // sometimes fail to be shown when they should be or vice versa
399 //
400 // The scroll bars may be a little flakey once in a while, but that is
401 // surely much less horrible than having scroll lines of only 1!!!
402 // -- Robin
403 //
404 // Well, it's still seriously broken so it might be better but needs
405 // fixing anyhow
406 // -- Vadim
407 static const size_t GRID_SCROLL_LINE_X = 15; // 1;
408 static const size_t GRID_SCROLL_LINE_Y = GRID_SCROLL_LINE_X;
409
410 // the size of hash tables used a bit everywhere (the max number of elements
411 // in these hash tables is the number of rows/columns)
412 static const int GRID_HASH_SIZE = 100;
413
414 // ----------------------------------------------------------------------------
415 // private functions
416 // ----------------------------------------------------------------------------
417
418 static inline int GetScrollX(int x)
419 {
420 return (x + GRID_SCROLL_LINE_X - 1) / GRID_SCROLL_LINE_X;
421 }
422
423 static inline int GetScrollY(int y)
424 {
425 return (y + GRID_SCROLL_LINE_Y - 1) / GRID_SCROLL_LINE_Y;
426 }
427
428 // ============================================================================
429 // implementation
430 // ============================================================================
431
432 // ----------------------------------------------------------------------------
433 // wxGridCellEditor
434 // ----------------------------------------------------------------------------
435
436 wxGridCellEditor::wxGridCellEditor()
437 {
438 m_control = NULL;
439 m_attr = NULL;
440 }
441
442
443 wxGridCellEditor::~wxGridCellEditor()
444 {
445 Destroy();
446 }
447
448 void wxGridCellEditor::Create(wxWindow* WXUNUSED(parent),
449 wxWindowID WXUNUSED(id),
450 wxEvtHandler* evtHandler)
451 {
452 if ( evtHandler )
453 m_control->PushEventHandler(evtHandler);
454 }
455
456 void wxGridCellEditor::PaintBackground(const wxRect& rectCell,
457 wxGridCellAttr *attr)
458 {
459 // erase the background because we might not fill the cell
460 wxClientDC dc(m_control->GetParent());
461 wxGridWindow* gridWindow = wxDynamicCast(m_control->GetParent(), wxGridWindow);
462 if (gridWindow)
463 gridWindow->GetOwner()->PrepareDC(dc);
464
465 dc.SetPen(*wxTRANSPARENT_PEN);
466 dc.SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
467 dc.DrawRectangle(rectCell);
468
469 // redraw the control we just painted over
470 m_control->Refresh();
471 }
472
473 void wxGridCellEditor::Destroy()
474 {
475 if (m_control)
476 {
477 m_control->PopEventHandler(TRUE /* delete it*/);
478
479 m_control->Destroy();
480 m_control = NULL;
481 }
482 }
483
484 void wxGridCellEditor::Show(bool show, wxGridCellAttr *attr)
485 {
486 wxASSERT_MSG(m_control,
487 wxT("The wxGridCellEditor must be Created first!"));
488 m_control->Show(show);
489
490 if ( show )
491 {
492 // set the colours/fonts if we have any
493 if ( attr )
494 {
495 m_colFgOld = m_control->GetForegroundColour();
496 m_control->SetForegroundColour(attr->GetTextColour());
497
498 m_colBgOld = m_control->GetBackgroundColour();
499 m_control->SetBackgroundColour(attr->GetBackgroundColour());
500
501 m_fontOld = m_control->GetFont();
502 m_control->SetFont(attr->GetFont());
503
504 // can't do anything more in the base class version, the other
505 // attributes may only be used by the derived classes
506 }
507 }
508 else
509 {
510 // restore the standard colours fonts
511 if ( m_colFgOld.Ok() )
512 {
513 m_control->SetForegroundColour(m_colFgOld);
514 m_colFgOld = wxNullColour;
515 }
516
517 if ( m_colBgOld.Ok() )
518 {
519 m_control->SetBackgroundColour(m_colBgOld);
520 m_colBgOld = wxNullColour;
521 }
522
523 if ( m_fontOld.Ok() )
524 {
525 m_control->SetFont(m_fontOld);
526 m_fontOld = wxNullFont;
527 }
528 }
529 }
530
531 void wxGridCellEditor::SetSize(const wxRect& rect)
532 {
533 wxASSERT_MSG(m_control,
534 wxT("The wxGridCellEditor must be Created first!"));
535 m_control->SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);
536 }
537
538 void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
539 {
540 event.Skip();
541 }
542
543 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
544 {
545 // accept the simple key presses, not anything with Ctrl/Alt/Meta
546 return !(event.ControlDown() || event.AltDown());
547 }
548
549 void wxGridCellEditor::StartingKey(wxKeyEvent& event)
550 {
551 event.Skip();
552 }
553
554 void wxGridCellEditor::StartingClick()
555 {
556 }
557
558 #if wxUSE_TEXTCTRL
559
560 // ----------------------------------------------------------------------------
561 // wxGridCellTextEditor
562 // ----------------------------------------------------------------------------
563
564 wxGridCellTextEditor::wxGridCellTextEditor()
565 {
566 m_maxChars = 0;
567 }
568
569 void wxGridCellTextEditor::Create(wxWindow* parent,
570 wxWindowID id,
571 wxEvtHandler* evtHandler)
572 {
573 m_control = new wxTextCtrl(parent, id, wxEmptyString,
574 wxDefaultPosition, wxDefaultSize
575 #if defined(__WXMSW__)
576 , wxTE_PROCESS_TAB | wxTE_AUTO_SCROLL
577 #endif
578 );
579
580 // set max length allowed in the textctrl, if the parameter was set
581 if (m_maxChars != 0)
582 {
583 ((wxTextCtrl*)m_control)->SetMaxLength(m_maxChars);
584 }
585
586 wxGridCellEditor::Create(parent, id, evtHandler);
587 }
588
589 void wxGridCellTextEditor::PaintBackground(const wxRect& WXUNUSED(rectCell),
590 wxGridCellAttr * WXUNUSED(attr))
591 {
592 // as we fill the entire client area, don't do anything here to minimize
593 // flicker
594 }
595
596 void wxGridCellTextEditor::SetSize(const wxRect& rectOrig)
597 {
598 wxRect rect(rectOrig);
599
600 // Make the edit control large enough to allow for internal
601 // margins
602 //
603 // TODO: remove this if the text ctrl sizing is improved esp. for
604 // unix
605 //
606 #if defined(__WXGTK__)
607 if (rect.x != 0)
608 {
609 rect.x += 1;
610 rect.y += 1;
611 rect.width -= 1;
612 rect.height -= 1;
613 }
614 #else // !GTK
615 int extra_x = ( rect.x > 2 )? 2 : 1;
616
617 // MB: treat MSW separately here otherwise the caret doesn't show
618 // when the editor is in the first row.
619 #if defined(__WXMSW__)
620 int extra_y = 2;
621 #else
622 int extra_y = ( rect.y > 2 )? 2 : 1;
623 #endif // MSW
624
625 #if defined(__WXMOTIF__)
626 extra_x *= 2;
627 extra_y *= 2;
628 #endif
629 rect.SetLeft( wxMax(0, rect.x - extra_x) );
630 rect.SetTop( wxMax(0, rect.y - extra_y) );
631 rect.SetRight( rect.GetRight() + 2*extra_x );
632 rect.SetBottom( rect.GetBottom() + 2*extra_y );
633 #endif // GTK/!GTK
634
635 wxGridCellEditor::SetSize(rect);
636 }
637
638 void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid* grid)
639 {
640 wxASSERT_MSG(m_control,
641 wxT("The wxGridCellEditor must be Created first!"));
642
643 m_startValue = grid->GetTable()->GetValue(row, col);
644
645 DoBeginEdit(m_startValue);
646 }
647
648 void wxGridCellTextEditor::DoBeginEdit(const wxString& startValue)
649 {
650 Text()->SetValue(startValue);
651 Text()->SetInsertionPointEnd();
652 Text()->SetSelection(-1,-1);
653 Text()->SetFocus();
654 }
655
656 bool wxGridCellTextEditor::EndEdit(int row, int col,
657 wxGrid* grid)
658 {
659 wxASSERT_MSG(m_control,
660 wxT("The wxGridCellEditor must be Created first!"));
661
662 bool changed = FALSE;
663 wxString value = Text()->GetValue();
664 if (value != m_startValue)
665 changed = TRUE;
666
667 if (changed)
668 grid->GetTable()->SetValue(row, col, value);
669
670 m_startValue = wxEmptyString;
671 Text()->SetValue(m_startValue);
672
673 return changed;
674 }
675
676
677 void wxGridCellTextEditor::Reset()
678 {
679 wxASSERT_MSG(m_control,
680 wxT("The wxGridCellEditor must be Created first!"));
681
682 DoReset(m_startValue);
683 }
684
685 void wxGridCellTextEditor::DoReset(const wxString& startValue)
686 {
687 Text()->SetValue(startValue);
688 Text()->SetInsertionPointEnd();
689 }
690
691 bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent& event)
692 {
693 if ( wxGridCellEditor::IsAcceptedKey(event) )
694 {
695 int keycode = event.GetKeyCode();
696 switch ( keycode )
697 {
698 case WXK_NUMPAD0:
699 case WXK_NUMPAD1:
700 case WXK_NUMPAD2:
701 case WXK_NUMPAD3:
702 case WXK_NUMPAD4:
703 case WXK_NUMPAD5:
704 case WXK_NUMPAD6:
705 case WXK_NUMPAD7:
706 case WXK_NUMPAD8:
707 case WXK_NUMPAD9:
708 case WXK_MULTIPLY:
709 case WXK_NUMPAD_MULTIPLY:
710 case WXK_ADD:
711 case WXK_NUMPAD_ADD:
712 case WXK_SUBTRACT:
713 case WXK_NUMPAD_SUBTRACT:
714 case WXK_DECIMAL:
715 case WXK_NUMPAD_DECIMAL:
716 case WXK_DIVIDE:
717 case WXK_NUMPAD_DIVIDE:
718 return TRUE;
719
720 default:
721 // accept 8 bit chars too if isprint() agrees
722 if ( (keycode < 255) && (wxIsprint(keycode)) )
723 return TRUE;
724 }
725 }
726
727 return FALSE;
728 }
729
730 void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
731 {
732 if ( !Text()->EmulateKeyPress(event) )
733 {
734 event.Skip();
735 }
736 }
737
738 void wxGridCellTextEditor::HandleReturn( wxKeyEvent&
739 WXUNUSED_GTK(WXUNUSED_MOTIF(event)) )
740 {
741 #if defined(__WXMOTIF__) || defined(__WXGTK__)
742 // wxMotif needs a little extra help...
743 size_t pos = (size_t)( Text()->GetInsertionPoint() );
744 wxString s( Text()->GetValue() );
745 s = s.Left(pos) + wxT("\n") + s.Mid(pos);
746 Text()->SetValue(s);
747 Text()->SetInsertionPoint( pos );
748 #else
749 // the other ports can handle a Return key press
750 //
751 event.Skip();
752 #endif
753 }
754
755 void wxGridCellTextEditor::SetParameters(const wxString& params)
756 {
757 if ( !params )
758 {
759 // reset to default
760 m_maxChars = 0;
761 }
762 else
763 {
764 long tmp;
765 if ( !params.ToLong(&tmp) )
766 {
767 wxLogDebug(_T("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params.c_str());
768 }
769 else
770 {
771 m_maxChars = (size_t)tmp;
772 }
773 }
774 }
775
776 // return the value in the text control
777 wxString wxGridCellTextEditor::GetValue() const
778 {
779 return Text()->GetValue();
780 }
781
782 // ----------------------------------------------------------------------------
783 // wxGridCellNumberEditor
784 // ----------------------------------------------------------------------------
785
786 wxGridCellNumberEditor::wxGridCellNumberEditor(int min, int max)
787 {
788 m_min = min;
789 m_max = max;
790 }
791
792 void wxGridCellNumberEditor::Create(wxWindow* parent,
793 wxWindowID id,
794 wxEvtHandler* evtHandler)
795 {
796 if ( HasRange() )
797 {
798 // create a spin ctrl
799 m_control = new wxSpinCtrl(parent, -1, wxEmptyString,
800 wxDefaultPosition, wxDefaultSize,
801 wxSP_ARROW_KEYS,
802 m_min, m_max);
803
804 wxGridCellEditor::Create(parent, id, evtHandler);
805 }
806 else
807 {
808 // just a text control
809 wxGridCellTextEditor::Create(parent, id, evtHandler);
810
811 #if wxUSE_VALIDATORS
812 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
813 #endif // wxUSE_VALIDATORS
814 }
815 }
816
817 void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid* grid)
818 {
819 // first get the value
820 wxGridTableBase *table = grid->GetTable();
821 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
822 {
823 m_valueOld = table->GetValueAsLong(row, col);
824 }
825 else
826 {
827 m_valueOld = 0;
828 wxString sValue = table->GetValue(row, col);
829 if (! sValue.ToLong(&m_valueOld) && ! sValue.IsEmpty())
830 {
831 wxFAIL_MSG( _T("this cell doesn't have numeric value") );
832 return;
833 }
834 }
835
836 if ( HasRange() )
837 {
838 Spin()->SetValue((int)m_valueOld);
839 Spin()->SetFocus();
840 }
841 else
842 {
843 DoBeginEdit(GetString());
844 }
845 }
846
847 bool wxGridCellNumberEditor::EndEdit(int row, int col,
848 wxGrid* grid)
849 {
850 bool changed;
851 long value = 0;
852 wxString text;
853
854 if ( HasRange() )
855 {
856 value = Spin()->GetValue();
857 changed = value != m_valueOld;
858 if (changed)
859 text = wxString::Format(wxT("%ld"), value);
860 }
861 else
862 {
863 text = Text()->GetValue();
864 changed = (text.IsEmpty() || text.ToLong(&value)) && (value != m_valueOld);
865 }
866
867 if ( changed )
868 {
869 if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER))
870 grid->GetTable()->SetValueAsLong(row, col, value);
871 else
872 grid->GetTable()->SetValue(row, col, text);
873 }
874
875 return changed;
876 }
877
878 void wxGridCellNumberEditor::Reset()
879 {
880 if ( HasRange() )
881 {
882 Spin()->SetValue((int)m_valueOld);
883 }
884 else
885 {
886 DoReset(GetString());
887 }
888 }
889
890 bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent& event)
891 {
892 if ( wxGridCellEditor::IsAcceptedKey(event) )
893 {
894 int keycode = event.GetKeyCode();
895 switch ( keycode )
896 {
897 case WXK_NUMPAD0:
898 case WXK_NUMPAD1:
899 case WXK_NUMPAD2:
900 case WXK_NUMPAD3:
901 case WXK_NUMPAD4:
902 case WXK_NUMPAD5:
903 case WXK_NUMPAD6:
904 case WXK_NUMPAD7:
905 case WXK_NUMPAD8:
906 case WXK_NUMPAD9:
907 case WXK_ADD:
908 case WXK_NUMPAD_ADD:
909 case WXK_SUBTRACT:
910 case WXK_NUMPAD_SUBTRACT:
911 case WXK_UP:
912 case WXK_DOWN:
913 return TRUE;
914
915 default:
916 if ( (keycode < 128) && wxIsdigit(keycode) )
917 return TRUE;
918 }
919 }
920
921 return FALSE;
922 }
923
924 void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
925 {
926 if ( !HasRange() )
927 {
928 int keycode = event.GetKeyCode();
929 if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-'
930 || keycode == WXK_NUMPAD0
931 || keycode == WXK_NUMPAD1
932 || keycode == WXK_NUMPAD2
933 || keycode == WXK_NUMPAD3
934 || keycode == WXK_NUMPAD4
935 || keycode == WXK_NUMPAD5
936 || keycode == WXK_NUMPAD6
937 || keycode == WXK_NUMPAD7
938 || keycode == WXK_NUMPAD8
939 || keycode == WXK_NUMPAD9
940 || keycode == WXK_ADD
941 || keycode == WXK_NUMPAD_ADD
942 || keycode == WXK_SUBTRACT
943 || keycode == WXK_NUMPAD_SUBTRACT)
944 {
945 wxGridCellTextEditor::StartingKey(event);
946
947 // skip Skip() below
948 return;
949 }
950 }
951
952 event.Skip();
953 }
954
955 void wxGridCellNumberEditor::SetParameters(const wxString& params)
956 {
957 if ( !params )
958 {
959 // reset to default
960 m_min =
961 m_max = -1;
962 }
963 else
964 {
965 long tmp;
966 if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
967 {
968 m_min = (int)tmp;
969
970 if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
971 {
972 m_max = (int)tmp;
973
974 // skip the error message below
975 return;
976 }
977 }
978
979 wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params.c_str());
980 }
981 }
982
983 // return the value in the spin control if it is there (the text control otherwise)
984 wxString wxGridCellNumberEditor::GetValue() const
985 {
986 wxString s;
987
988 if( HasRange() )
989 {
990 long value = Spin()->GetValue();
991 s.Printf(wxT("%ld"), value);
992 }
993 else
994 {
995 s = Text()->GetValue();
996 }
997 return s;
998 }
999
1000 // ----------------------------------------------------------------------------
1001 // wxGridCellFloatEditor
1002 // ----------------------------------------------------------------------------
1003
1004 wxGridCellFloatEditor::wxGridCellFloatEditor(int width, int precision)
1005 {
1006 m_width = width;
1007 m_precision = precision;
1008 }
1009
1010 void wxGridCellFloatEditor::Create(wxWindow* parent,
1011 wxWindowID id,
1012 wxEvtHandler* evtHandler)
1013 {
1014 wxGridCellTextEditor::Create(parent, id, evtHandler);
1015
1016 #if wxUSE_VALIDATORS
1017 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
1018 #endif // wxUSE_VALIDATORS
1019 }
1020
1021 void wxGridCellFloatEditor::BeginEdit(int row, int col, wxGrid* grid)
1022 {
1023 // first get the value
1024 wxGridTableBase *table = grid->GetTable();
1025 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
1026 {
1027 m_valueOld = table->GetValueAsDouble(row, col);
1028 }
1029 else
1030 {
1031 m_valueOld = 0.0;
1032 wxString sValue = table->GetValue(row, col);
1033 if (! sValue.ToDouble(&m_valueOld) && ! sValue.IsEmpty())
1034 {
1035 wxFAIL_MSG( _T("this cell doesn't have float value") );
1036 return;
1037 }
1038 }
1039
1040 DoBeginEdit(GetString());
1041 }
1042
1043 bool wxGridCellFloatEditor::EndEdit(int row, int col,
1044 wxGrid* grid)
1045 {
1046 double value = 0.0;
1047 wxString text(Text()->GetValue());
1048
1049 if ( (text.IsEmpty() || text.ToDouble(&value)) && (value != m_valueOld) )
1050 {
1051 if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT))
1052 grid->GetTable()->SetValueAsDouble(row, col, value);
1053 else
1054 grid->GetTable()->SetValue(row, col, text);
1055
1056 return TRUE;
1057 }
1058 return FALSE;
1059 }
1060
1061 void wxGridCellFloatEditor::Reset()
1062 {
1063 DoReset(GetString());
1064 }
1065
1066 void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
1067 {
1068 int keycode = event.GetKeyCode();
1069 if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-' || keycode == '.'
1070 || keycode == WXK_NUMPAD0
1071 || keycode == WXK_NUMPAD1
1072 || keycode == WXK_NUMPAD2
1073 || keycode == WXK_NUMPAD3
1074 || keycode == WXK_NUMPAD4
1075 || keycode == WXK_NUMPAD5
1076 || keycode == WXK_NUMPAD6
1077 || keycode == WXK_NUMPAD7
1078 || keycode == WXK_NUMPAD8
1079 || keycode == WXK_NUMPAD9
1080 || keycode == WXK_ADD
1081 || keycode == WXK_NUMPAD_ADD
1082 || keycode == WXK_SUBTRACT
1083 || keycode == WXK_NUMPAD_SUBTRACT)
1084 {
1085 wxGridCellTextEditor::StartingKey(event);
1086
1087 // skip Skip() below
1088 return;
1089 }
1090
1091 event.Skip();
1092 }
1093
1094 void wxGridCellFloatEditor::SetParameters(const wxString& params)
1095 {
1096 if ( !params )
1097 {
1098 // reset to default
1099 m_width =
1100 m_precision = -1;
1101 }
1102 else
1103 {
1104 long tmp;
1105 if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
1106 {
1107 m_width = (int)tmp;
1108
1109 if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
1110 {
1111 m_precision = (int)tmp;
1112
1113 // skip the error message below
1114 return;
1115 }
1116 }
1117
1118 wxLogDebug(_T("Invalid wxGridCellFloatEditor parameter string '%s' ignored"), params.c_str());
1119 }
1120 }
1121
1122 wxString wxGridCellFloatEditor::GetString() const
1123 {
1124 wxString fmt;
1125 if ( m_width == -1 )
1126 {
1127 // default width/precision
1128 fmt = _T("%f");
1129 }
1130 else if ( m_precision == -1 )
1131 {
1132 // default precision
1133 fmt.Printf(_T("%%%d.f"), m_width);
1134 }
1135 else
1136 {
1137 fmt.Printf(_T("%%%d.%df"), m_width, m_precision);
1138 }
1139
1140 return wxString::Format(fmt, m_valueOld);
1141 }
1142
1143 bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
1144 {
1145 if ( wxGridCellEditor::IsAcceptedKey(event) )
1146 {
1147 int keycode = event.GetKeyCode();
1148 switch ( keycode )
1149 {
1150 case WXK_NUMPAD0:
1151 case WXK_NUMPAD1:
1152 case WXK_NUMPAD2:
1153 case WXK_NUMPAD3:
1154 case WXK_NUMPAD4:
1155 case WXK_NUMPAD5:
1156 case WXK_NUMPAD6:
1157 case WXK_NUMPAD7:
1158 case WXK_NUMPAD8:
1159 case WXK_NUMPAD9:
1160 case WXK_ADD:
1161 case WXK_NUMPAD_ADD:
1162 case WXK_SUBTRACT:
1163 case WXK_NUMPAD_SUBTRACT:
1164 case WXK_DECIMAL:
1165 case WXK_NUMPAD_DECIMAL:
1166 return TRUE;
1167
1168 default:
1169 // additionally accept 'e' as in '1e+6'
1170 if ( (keycode < 128) &&
1171 (wxIsdigit(keycode) || tolower(keycode) == 'e') )
1172 return TRUE;
1173 }
1174 }
1175
1176 return FALSE;
1177 }
1178
1179 #endif // wxUSE_TEXTCTRL
1180
1181 #if wxUSE_CHECKBOX
1182
1183 // ----------------------------------------------------------------------------
1184 // wxGridCellBoolEditor
1185 // ----------------------------------------------------------------------------
1186
1187 void wxGridCellBoolEditor::Create(wxWindow* parent,
1188 wxWindowID id,
1189 wxEvtHandler* evtHandler)
1190 {
1191 m_control = new wxCheckBox(parent, id, wxEmptyString,
1192 wxDefaultPosition, wxDefaultSize,
1193 wxNO_BORDER);
1194
1195 wxGridCellEditor::Create(parent, id, evtHandler);
1196 }
1197
1198 void wxGridCellBoolEditor::SetSize(const wxRect& r)
1199 {
1200 bool resize = FALSE;
1201 wxSize size = m_control->GetSize();
1202 wxCoord minSize = wxMin(r.width, r.height);
1203
1204 // check if the checkbox is not too big/small for this cell
1205 wxSize sizeBest = m_control->GetBestSize();
1206 if ( !(size == sizeBest) )
1207 {
1208 // reset to default size if it had been made smaller
1209 size = sizeBest;
1210
1211 resize = TRUE;
1212 }
1213
1214 if ( size.x >= minSize || size.y >= minSize )
1215 {
1216 // leave 1 pixel margin
1217 size.x = size.y = minSize - 2;
1218
1219 resize = TRUE;
1220 }
1221
1222 if ( resize )
1223 {
1224 m_control->SetSize(size);
1225 }
1226
1227 // position it in the centre of the rectangle (TODO: support alignment?)
1228
1229 #if defined(__WXGTK__) || defined (__WXMOTIF__)
1230 // the checkbox without label still has some space to the right in wxGTK,
1231 // so shift it to the right
1232 size.x -= 8;
1233 #elif defined(__WXMSW__)
1234 // here too, but in other way
1235 size.x += 1;
1236 size.y -= 2;
1237 #endif
1238
1239 int hAlign = wxALIGN_CENTRE;
1240 int vAlign = wxALIGN_CENTRE;
1241 if (GetCellAttr())
1242 GetCellAttr()->GetAlignment(& hAlign, & vAlign);
1243
1244 int x = 0, y = 0;
1245 if (hAlign == wxALIGN_LEFT)
1246 {
1247 x = r.x + 2;
1248 #ifdef __WXMSW__
1249 x += 2;
1250 #endif
1251 y = r.y + r.height/2 - size.y/2;
1252 }
1253 else if (hAlign == wxALIGN_RIGHT)
1254 {
1255 x = r.x + r.width - size.x - 2;
1256 y = r.y + r.height/2 - size.y/2;
1257 }
1258 else if (hAlign == wxALIGN_CENTRE)
1259 {
1260 x = r.x + r.width/2 - size.x/2;
1261 y = r.y + r.height/2 - size.y/2;
1262 }
1263
1264 m_control->Move(x, y);
1265 }
1266
1267 void wxGridCellBoolEditor::Show(bool show, wxGridCellAttr *attr)
1268 {
1269 m_control->Show(show);
1270
1271 if ( show )
1272 {
1273 wxColour colBg = attr ? attr->GetBackgroundColour() : *wxLIGHT_GREY;
1274 CBox()->SetBackgroundColour(colBg);
1275 }
1276 }
1277
1278 void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
1279 {
1280 wxASSERT_MSG(m_control,
1281 wxT("The wxGridCellEditor must be Created first!"));
1282
1283 if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
1284 m_startValue = grid->GetTable()->GetValueAsBool(row, col);
1285 else
1286 {
1287 wxString cellval( grid->GetTable()->GetValue(row, col) );
1288 m_startValue = !( !cellval || (cellval == wxT("0")) );
1289 }
1290 CBox()->SetValue(m_startValue);
1291 CBox()->SetFocus();
1292 }
1293
1294 bool wxGridCellBoolEditor::EndEdit(int row, int col,
1295 wxGrid* grid)
1296 {
1297 wxASSERT_MSG(m_control,
1298 wxT("The wxGridCellEditor must be Created first!"));
1299
1300 bool changed = FALSE;
1301 bool value = CBox()->GetValue();
1302 if ( value != m_startValue )
1303 changed = TRUE;
1304
1305 if ( changed )
1306 {
1307 if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
1308 grid->GetTable()->SetValueAsBool(row, col, value);
1309 else
1310 grid->GetTable()->SetValue(row, col, value ? _T("1") : wxEmptyString);
1311 }
1312
1313 return changed;
1314 }
1315
1316 void wxGridCellBoolEditor::Reset()
1317 {
1318 wxASSERT_MSG(m_control,
1319 wxT("The wxGridCellEditor must be Created first!"));
1320
1321 CBox()->SetValue(m_startValue);
1322 }
1323
1324 void wxGridCellBoolEditor::StartingClick()
1325 {
1326 CBox()->SetValue(!CBox()->GetValue());
1327 }
1328
1329 bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent& event)
1330 {
1331 if ( wxGridCellEditor::IsAcceptedKey(event) )
1332 {
1333 int keycode = event.GetKeyCode();
1334 switch ( keycode )
1335 {
1336 case WXK_MULTIPLY:
1337 case WXK_NUMPAD_MULTIPLY:
1338 case WXK_ADD:
1339 case WXK_NUMPAD_ADD:
1340 case WXK_SUBTRACT:
1341 case WXK_NUMPAD_SUBTRACT:
1342 case WXK_SPACE:
1343 case '+':
1344 case '-':
1345 return TRUE;
1346 }
1347 }
1348
1349 return FALSE;
1350 }
1351
1352 // return the value as "1" for true and the empty string for false
1353 wxString wxGridCellBoolEditor::GetValue() const
1354 {
1355 bool bSet = CBox()->GetValue();
1356 return bSet ? _T("1") : wxEmptyString;
1357 }
1358
1359 #endif // wxUSE_CHECKBOX
1360
1361 #if wxUSE_COMBOBOX
1362
1363 // ----------------------------------------------------------------------------
1364 // wxGridCellChoiceEditor
1365 // ----------------------------------------------------------------------------
1366
1367 wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count,
1368 const wxString choices[],
1369 bool allowOthers)
1370 : m_allowOthers(allowOthers)
1371 {
1372 if ( count )
1373 {
1374 m_choices.Alloc(count);
1375 for ( size_t n = 0; n < count; n++ )
1376 {
1377 m_choices.Add(choices[n]);
1378 }
1379 }
1380 }
1381
1382 wxGridCellEditor *wxGridCellChoiceEditor::Clone() const
1383 {
1384 wxGridCellChoiceEditor *editor = new wxGridCellChoiceEditor;
1385 editor->m_allowOthers = m_allowOthers;
1386 editor->m_choices = m_choices;
1387
1388 return editor;
1389 }
1390
1391 void wxGridCellChoiceEditor::Create(wxWindow* parent,
1392 wxWindowID id,
1393 wxEvtHandler* evtHandler)
1394 {
1395 size_t count = m_choices.GetCount();
1396 wxString *choices = new wxString[count];
1397 for ( size_t n = 0; n < count; n++ )
1398 {
1399 choices[n] = m_choices[n];
1400 }
1401
1402 m_control = new wxComboBox(parent, id, wxEmptyString,
1403 wxDefaultPosition, wxDefaultSize,
1404 count, choices,
1405 m_allowOthers ? 0 : wxCB_READONLY);
1406
1407 delete [] choices;
1408
1409 wxGridCellEditor::Create(parent, id, evtHandler);
1410 }
1411
1412 void wxGridCellChoiceEditor::PaintBackground(const wxRect& rectCell,
1413 wxGridCellAttr * attr)
1414 {
1415 // as we fill the entire client area, don't do anything here to minimize
1416 // flicker
1417
1418 // TODO: It doesn't actually fill the client area since the height of a
1419 // combo always defaults to the standard... Until someone has time to
1420 // figure out the right rectangle to paint, just do it the normal way...
1421 wxGridCellEditor::PaintBackground(rectCell, attr);
1422 }
1423
1424 void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid* grid)
1425 {
1426 wxASSERT_MSG(m_control,
1427 wxT("The wxGridCellEditor must be Created first!"));
1428
1429 m_startValue = grid->GetTable()->GetValue(row, col);
1430
1431 if (m_allowOthers)
1432 Combo()->SetValue(m_startValue);
1433 else
1434 {
1435 // find the right position, or default to the first if not found
1436 int pos = Combo()->FindString(m_startValue);
1437 if (pos == -1)
1438 pos = 0;
1439 Combo()->SetSelection(pos);
1440 }
1441 Combo()->SetInsertionPointEnd();
1442 Combo()->SetFocus();
1443 }
1444
1445 bool wxGridCellChoiceEditor::EndEdit(int row, int col,
1446 wxGrid* grid)
1447 {
1448 wxString value = Combo()->GetValue();
1449 bool changed = value != m_startValue;
1450
1451 if ( changed )
1452 grid->GetTable()->SetValue(row, col, value);
1453
1454 m_startValue = wxEmptyString;
1455 if (m_allowOthers)
1456 Combo()->SetValue(m_startValue);
1457 else
1458 Combo()->SetSelection(0);
1459
1460 return changed;
1461 }
1462
1463 void wxGridCellChoiceEditor::Reset()
1464 {
1465 Combo()->SetValue(m_startValue);
1466 Combo()->SetInsertionPointEnd();
1467 }
1468
1469 void wxGridCellChoiceEditor::SetParameters(const wxString& params)
1470 {
1471 if ( !params )
1472 {
1473 // what can we do?
1474 return;
1475 }
1476
1477 m_choices.Empty();
1478
1479 wxStringTokenizer tk(params, _T(','));
1480 while ( tk.HasMoreTokens() )
1481 {
1482 m_choices.Add(tk.GetNextToken());
1483 }
1484 }
1485
1486 // return the value in the text control
1487 wxString wxGridCellChoiceEditor::GetValue() const
1488 {
1489 return Combo()->GetValue();
1490 }
1491
1492 #endif // wxUSE_COMBOBOX
1493
1494 // ----------------------------------------------------------------------------
1495 // wxGridCellEditorEvtHandler
1496 // ----------------------------------------------------------------------------
1497
1498 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
1499 {
1500 switch ( event.GetKeyCode() )
1501 {
1502 case WXK_ESCAPE:
1503 m_editor->Reset();
1504 m_grid->DisableCellEditControl();
1505 break;
1506
1507 case WXK_TAB:
1508 m_grid->GetEventHandler()->ProcessEvent( event );
1509 break;
1510
1511 case WXK_RETURN:
1512 case WXK_NUMPAD_ENTER:
1513 if (!m_grid->GetEventHandler()->ProcessEvent(event))
1514 m_editor->HandleReturn(event);
1515 break;
1516
1517
1518 default:
1519 event.Skip();
1520 }
1521 }
1522
1523 void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
1524 {
1525 switch ( event.GetKeyCode() )
1526 {
1527 case WXK_ESCAPE:
1528 case WXK_TAB:
1529 case WXK_RETURN:
1530 case WXK_NUMPAD_ENTER:
1531 break;
1532
1533 default:
1534 event.Skip();
1535 }
1536 }
1537
1538 // ----------------------------------------------------------------------------
1539 // wxGridCellWorker is an (almost) empty common base class for
1540 // wxGridCellRenderer and wxGridCellEditor managing ref counting
1541 // ----------------------------------------------------------------------------
1542
1543 void wxGridCellWorker::SetParameters(const wxString& WXUNUSED(params))
1544 {
1545 // nothing to do
1546 }
1547
1548 wxGridCellWorker::~wxGridCellWorker()
1549 {
1550 }
1551
1552 // ============================================================================
1553 // renderer classes
1554 // ============================================================================
1555
1556 // ----------------------------------------------------------------------------
1557 // wxGridCellRenderer
1558 // ----------------------------------------------------------------------------
1559
1560 void wxGridCellRenderer::Draw(wxGrid& grid,
1561 wxGridCellAttr& attr,
1562 wxDC& dc,
1563 const wxRect& rect,
1564 int WXUNUSED(row), int WXUNUSED(col),
1565 bool isSelected)
1566 {
1567 dc.SetBackgroundMode( wxSOLID );
1568
1569 // grey out fields if the grid is disabled
1570 if( grid.IsEnabled() )
1571 {
1572 if ( isSelected )
1573 {
1574 dc.SetBrush( wxBrush(grid.GetSelectionBackground(), wxSOLID) );
1575 }
1576 else
1577 {
1578 dc.SetBrush( wxBrush(attr.GetBackgroundColour(), wxSOLID) );
1579 }
1580 }
1581 else
1582 {
1583 dc.SetBrush(wxBrush(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE), wxSOLID));
1584 }
1585
1586 dc.SetPen( *wxTRANSPARENT_PEN );
1587 dc.DrawRectangle(rect);
1588 }
1589
1590 // ----------------------------------------------------------------------------
1591 // wxGridCellStringRenderer
1592 // ----------------------------------------------------------------------------
1593
1594 void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid& grid,
1595 wxGridCellAttr& attr,
1596 wxDC& dc,
1597 bool isSelected)
1598 {
1599 dc.SetBackgroundMode( wxTRANSPARENT );
1600
1601 // TODO some special colours for attr.IsReadOnly() case?
1602
1603 // different coloured text when the grid is disabled
1604 if( grid.IsEnabled() )
1605 {
1606 if ( isSelected )
1607 {
1608 dc.SetTextBackground( grid.GetSelectionBackground() );
1609 dc.SetTextForeground( grid.GetSelectionForeground() );
1610 }
1611 else
1612 {
1613 dc.SetTextBackground( attr.GetBackgroundColour() );
1614 dc.SetTextForeground( attr.GetTextColour() );
1615 }
1616 }
1617 else
1618 {
1619 dc.SetTextBackground(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE));
1620 dc.SetTextForeground(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_GRAYTEXT));
1621 }
1622
1623 dc.SetFont( attr.GetFont() );
1624 }
1625
1626 wxSize wxGridCellStringRenderer::DoGetBestSize(wxGridCellAttr& attr,
1627 wxDC& dc,
1628 const wxString& text)
1629 {
1630 wxCoord x = 0, y = 0, max_x = 0;
1631 dc.SetFont(attr.GetFont());
1632 wxStringTokenizer tk(text, _T('\n'));
1633 while ( tk.HasMoreTokens() )
1634 {
1635 dc.GetTextExtent(tk.GetNextToken(), &x, &y);
1636 max_x = wxMax(max_x, x);
1637 }
1638
1639 y *= 1 + text.Freq(wxT('\n')); // multiply by the number of lines.
1640
1641 return wxSize(max_x, y);
1642 }
1643
1644 wxSize wxGridCellStringRenderer::GetBestSize(wxGrid& grid,
1645 wxGridCellAttr& attr,
1646 wxDC& dc,
1647 int row, int col)
1648 {
1649 return DoGetBestSize(attr, dc, grid.GetCellValue(row, col));
1650 }
1651
1652 void wxGridCellStringRenderer::Draw(wxGrid& grid,
1653 wxGridCellAttr& attr,
1654 wxDC& dc,
1655 const wxRect& rectCell,
1656 int row, int col,
1657 bool isSelected)
1658 {
1659 wxRect rect = rectCell;
1660 rect.Inflate(-1);
1661
1662 // erase only this cells background, overflow cells should have been erased
1663 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1664
1665 int hAlign, vAlign;
1666 attr.GetAlignment(&hAlign, &vAlign);
1667
1668 int overflowCols = 0;
1669
1670 if (attr.GetOverflow())
1671 {
1672 int cols = grid.GetNumberCols();
1673 int best_width = GetBestSize(grid,attr,dc,row,col).GetWidth();
1674 int cell_rows, cell_cols;
1675 attr.GetSize( &cell_rows, &cell_cols ); // shouldn't get here if <=0
1676 if ((best_width > rectCell.width) && (col < cols) && grid.GetTable())
1677 {
1678 int i, c_cols, c_rows;
1679 for (i = col+cell_cols; i < cols; i++)
1680 {
1681 bool is_empty = TRUE;
1682 for (int j=row; j<row+cell_rows; j++)
1683 {
1684 // check w/ anchor cell for multicell block
1685 grid.GetCellSize(j, i, &c_rows, &c_cols);
1686 if (c_rows > 0) c_rows = 0;
1687 if (!grid.GetTable()->IsEmptyCell(j+c_rows, i))
1688 {
1689 is_empty = FALSE;
1690 break;
1691 }
1692 }
1693 if (is_empty)
1694 rect.width += grid.GetColSize(i);
1695 else
1696 {
1697 i--;
1698 break;
1699 }
1700 if (rect.width >= best_width) break;
1701 }
1702 overflowCols = i - col - cell_cols + 1;
1703 if (overflowCols >= cols) overflowCols = cols - 1;
1704 }
1705
1706 if (overflowCols > 0) // redraw overflow cells w/ proper hilight
1707 {
1708 hAlign = wxALIGN_LEFT; // if oveflowed then it's left aligned
1709 wxRect clip = rect;
1710 clip.x += rectCell.width;
1711 // draw each overflow cell individually
1712 int col_end = col+cell_cols+overflowCols;
1713 if (col_end >= grid.GetNumberCols())
1714 col_end = grid.GetNumberCols() - 1;
1715 for (int i = col+cell_cols; i <= col_end; i++)
1716 {
1717 clip.width = grid.GetColSize(i) - 1;
1718 dc.DestroyClippingRegion();
1719 dc.SetClippingRegion(clip);
1720
1721 SetTextColoursAndFont(grid, attr, dc,
1722 grid.IsInSelection(row,i));
1723
1724 grid.DrawTextRectangle(dc, grid.GetCellValue(row, col),
1725 rect, hAlign, vAlign);
1726 clip.x += grid.GetColSize(i) - 1;
1727 }
1728
1729 rect = rectCell;
1730 rect.Inflate(-1);
1731 rect.width++;
1732 dc.DestroyClippingRegion();
1733 }
1734 }
1735
1736 // now we only have to draw the text
1737 SetTextColoursAndFont(grid, attr, dc, isSelected);
1738
1739 grid.DrawTextRectangle(dc, grid.GetCellValue(row, col),
1740 rect, hAlign, vAlign);
1741 }
1742
1743 // ----------------------------------------------------------------------------
1744 // wxGridCellNumberRenderer
1745 // ----------------------------------------------------------------------------
1746
1747 wxString wxGridCellNumberRenderer::GetString(wxGrid& grid, int row, int col)
1748 {
1749 wxGridTableBase *table = grid.GetTable();
1750 wxString text;
1751 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
1752 {
1753 text.Printf(_T("%ld"), table->GetValueAsLong(row, col));
1754 }
1755 else
1756 {
1757 text = table->GetValue(row, col);
1758 }
1759
1760 return text;
1761 }
1762
1763 void wxGridCellNumberRenderer::Draw(wxGrid& grid,
1764 wxGridCellAttr& attr,
1765 wxDC& dc,
1766 const wxRect& rectCell,
1767 int row, int col,
1768 bool isSelected)
1769 {
1770 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1771
1772 SetTextColoursAndFont(grid, attr, dc, isSelected);
1773
1774 // draw the text right aligned by default
1775 int hAlign, vAlign;
1776 attr.GetAlignment(&hAlign, &vAlign);
1777 hAlign = wxALIGN_RIGHT;
1778
1779 wxRect rect = rectCell;
1780 rect.Inflate(-1);
1781
1782 grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
1783 }
1784
1785 wxSize wxGridCellNumberRenderer::GetBestSize(wxGrid& grid,
1786 wxGridCellAttr& attr,
1787 wxDC& dc,
1788 int row, int col)
1789 {
1790 return DoGetBestSize(attr, dc, GetString(grid, row, col));
1791 }
1792
1793 // ----------------------------------------------------------------------------
1794 // wxGridCellFloatRenderer
1795 // ----------------------------------------------------------------------------
1796
1797 wxGridCellFloatRenderer::wxGridCellFloatRenderer(int width, int precision)
1798 {
1799 SetWidth(width);
1800 SetPrecision(precision);
1801 }
1802
1803 wxGridCellRenderer *wxGridCellFloatRenderer::Clone() const
1804 {
1805 wxGridCellFloatRenderer *renderer = new wxGridCellFloatRenderer;
1806 renderer->m_width = m_width;
1807 renderer->m_precision = m_precision;
1808 renderer->m_format = m_format;
1809
1810 return renderer;
1811 }
1812
1813 wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
1814 {
1815 wxGridTableBase *table = grid.GetTable();
1816
1817 bool hasDouble;
1818 double val;
1819 wxString text;
1820 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
1821 {
1822 val = table->GetValueAsDouble(row, col);
1823 hasDouble = TRUE;
1824 }
1825 else
1826 {
1827 text = table->GetValue(row, col);
1828 hasDouble = text.ToDouble(&val);
1829 }
1830
1831 if ( hasDouble )
1832 {
1833 if ( !m_format )
1834 {
1835 if ( m_width == -1 )
1836 {
1837 if ( m_precision == -1 )
1838 {
1839 // default width/precision
1840 m_format = _T("%f");
1841 }
1842 else
1843 {
1844 m_format.Printf(_T("%%.%df"), m_precision);
1845 }
1846 }
1847 else if ( m_precision == -1 )
1848 {
1849 // default precision
1850 m_format.Printf(_T("%%%d.f"), m_width);
1851 }
1852 else
1853 {
1854 m_format.Printf(_T("%%%d.%df"), m_width, m_precision);
1855 }
1856 }
1857
1858 text.Printf(m_format, val);
1859
1860 }
1861 //else: text already contains the string
1862
1863 return text;
1864 }
1865
1866 void wxGridCellFloatRenderer::Draw(wxGrid& grid,
1867 wxGridCellAttr& attr,
1868 wxDC& dc,
1869 const wxRect& rectCell,
1870 int row, int col,
1871 bool isSelected)
1872 {
1873 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1874
1875 SetTextColoursAndFont(grid, attr, dc, isSelected);
1876
1877 // draw the text right aligned by default
1878 int hAlign, vAlign;
1879 attr.GetAlignment(&hAlign, &vAlign);
1880 hAlign = wxALIGN_RIGHT;
1881
1882 wxRect rect = rectCell;
1883 rect.Inflate(-1);
1884
1885 grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
1886 }
1887
1888 wxSize wxGridCellFloatRenderer::GetBestSize(wxGrid& grid,
1889 wxGridCellAttr& attr,
1890 wxDC& dc,
1891 int row, int col)
1892 {
1893 return DoGetBestSize(attr, dc, GetString(grid, row, col));
1894 }
1895
1896 void wxGridCellFloatRenderer::SetParameters(const wxString& params)
1897 {
1898 if ( !params )
1899 {
1900 // reset to defaults
1901 SetWidth(-1);
1902 SetPrecision(-1);
1903 }
1904 else
1905 {
1906 wxString tmp = params.BeforeFirst(_T(','));
1907 if ( !!tmp )
1908 {
1909 long width;
1910 if ( tmp.ToLong(&width) )
1911 {
1912 SetWidth((int)width);
1913 }
1914 else
1915 {
1916 wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params.c_str());
1917 }
1918
1919 }
1920 tmp = params.AfterFirst(_T(','));
1921 if ( !!tmp )
1922 {
1923 long precision;
1924 if ( tmp.ToLong(&precision) )
1925 {
1926 SetPrecision((int)precision);
1927 }
1928 else
1929 {
1930 wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params.c_str());
1931 }
1932
1933 }
1934 }
1935 }
1936
1937
1938 // ----------------------------------------------------------------------------
1939 // wxGridCellBoolRenderer
1940 // ----------------------------------------------------------------------------
1941
1942 wxSize wxGridCellBoolRenderer::ms_sizeCheckMark;
1943
1944 // FIXME these checkbox size calculations are really ugly...
1945
1946 // between checkmark and box
1947 static const wxCoord wxGRID_CHECKMARK_MARGIN = 2;
1948
1949 wxSize wxGridCellBoolRenderer::GetBestSize(wxGrid& grid,
1950 wxGridCellAttr& WXUNUSED(attr),
1951 wxDC& WXUNUSED(dc),
1952 int WXUNUSED(row),
1953 int WXUNUSED(col))
1954 {
1955 // compute it only once (no locks for MT safeness in GUI thread...)
1956 if ( !ms_sizeCheckMark.x )
1957 {
1958 // get checkbox size
1959 wxCoord checkSize = 0;
1960 wxCheckBox *checkbox = new wxCheckBox(&grid, -1, wxEmptyString);
1961 wxSize size = checkbox->GetBestSize();
1962 checkSize = size.y + 2*wxGRID_CHECKMARK_MARGIN;
1963
1964 // FIXME wxGTK::wxCheckBox::GetBestSize() gives "wrong" result
1965 #if defined(__WXGTK__) || defined(__WXMOTIF__)
1966 checkSize -= size.y / 2;
1967 #endif
1968
1969 delete checkbox;
1970
1971 ms_sizeCheckMark.x = ms_sizeCheckMark.y = checkSize;
1972 }
1973
1974 return ms_sizeCheckMark;
1975 }
1976
1977 void wxGridCellBoolRenderer::Draw(wxGrid& grid,
1978 wxGridCellAttr& attr,
1979 wxDC& dc,
1980 const wxRect& rect,
1981 int row, int col,
1982 bool isSelected)
1983 {
1984 wxGridCellRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
1985
1986 // draw a check mark in the centre (ignoring alignment - TODO)
1987 wxSize size = GetBestSize(grid, attr, dc, row, col);
1988
1989 // don't draw outside the cell
1990 wxCoord minSize = wxMin(rect.width, rect.height);
1991 if ( size.x >= minSize || size.y >= minSize )
1992 {
1993 // and even leave (at least) 1 pixel margin
1994 size.x = size.y = minSize - 2;
1995 }
1996
1997 // draw a border around checkmark
1998 int vAlign, hAlign;
1999 attr.GetAlignment(& hAlign, &vAlign);
2000
2001 wxRect rectBorder;
2002 if (hAlign == wxALIGN_CENTRE)
2003 {
2004 rectBorder.x = rect.x + rect.width/2 - size.x/2;
2005 rectBorder.y = rect.y + rect.height/2 - size.y/2;
2006 rectBorder.width = size.x;
2007 rectBorder.height = size.y;
2008 }
2009 else if (hAlign == wxALIGN_LEFT)
2010 {
2011 rectBorder.x = rect.x + 2;
2012 rectBorder.y = rect.y + rect.height/2 - size.y/2;
2013 rectBorder.width = size.x;
2014 rectBorder.height = size.y;
2015 }
2016 else if (hAlign == wxALIGN_RIGHT)
2017 {
2018 rectBorder.x = rect.x + rect.width - size.x - 2;
2019 rectBorder.y = rect.y + rect.height/2 - size.y/2;
2020 rectBorder.width = size.x;
2021 rectBorder.height = size.y;
2022 }
2023
2024 bool value;
2025 if ( grid.GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
2026 value = grid.GetTable()->GetValueAsBool(row, col);
2027 else
2028 {
2029 wxString cellval( grid.GetTable()->GetValue(row, col) );
2030 value = !( !cellval || (cellval == wxT("0")) );
2031 }
2032
2033 if ( value )
2034 {
2035 wxRect rectMark = rectBorder;
2036 #ifdef __WXMSW__
2037 // MSW DrawCheckMark() is weird (and should probably be changed...)
2038 rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN/2);
2039 rectMark.x++;
2040 rectMark.y++;
2041 #else // !MSW
2042 rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN);
2043 #endif // MSW/!MSW
2044
2045 dc.SetTextForeground(attr.GetTextColour());
2046 dc.DrawCheckMark(rectMark);
2047 }
2048
2049 dc.SetBrush(*wxTRANSPARENT_BRUSH);
2050 dc.SetPen(wxPen(attr.GetTextColour(), 1, wxSOLID));
2051 dc.DrawRectangle(rectBorder);
2052 }
2053
2054 // ----------------------------------------------------------------------------
2055 // wxGridCellAttr
2056 // ----------------------------------------------------------------------------
2057
2058 void wxGridCellAttr::Init(wxGridCellAttr *attrDefault)
2059 {
2060 m_nRef = 1;
2061
2062 m_isReadOnly = Unset;
2063
2064 m_renderer = NULL;
2065 m_editor = NULL;
2066
2067 m_attrkind = wxGridCellAttr::Cell;
2068
2069 m_sizeRows = m_sizeCols = 1;
2070 m_overflow = UnsetOverflow;
2071
2072 SetDefAttr(attrDefault);
2073 }
2074
2075 wxGridCellAttr *wxGridCellAttr::Clone() const
2076 {
2077 wxGridCellAttr *attr = new wxGridCellAttr(m_defGridAttr);
2078
2079 if ( HasTextColour() )
2080 attr->SetTextColour(GetTextColour());
2081 if ( HasBackgroundColour() )
2082 attr->SetBackgroundColour(GetBackgroundColour());
2083 if ( HasFont() )
2084 attr->SetFont(GetFont());
2085 if ( HasAlignment() )
2086 attr->SetAlignment(m_hAlign, m_vAlign);
2087
2088 attr->SetSize( m_sizeRows, m_sizeCols );
2089
2090 if ( m_renderer )
2091 {
2092 attr->SetRenderer(m_renderer);
2093 m_renderer->IncRef();
2094 }
2095 if ( m_editor )
2096 {
2097 attr->SetEditor(m_editor);
2098 m_editor->IncRef();
2099 }
2100
2101 if ( IsReadOnly() )
2102 attr->SetReadOnly();
2103
2104 attr->SetKind( m_attrkind );
2105
2106 return attr;
2107 }
2108
2109 void wxGridCellAttr::MergeWith(wxGridCellAttr *mergefrom)
2110 {
2111 if ( !HasTextColour() && mergefrom->HasTextColour() )
2112 SetTextColour(mergefrom->GetTextColour());
2113 if ( !HasBackgroundColour() && mergefrom->HasBackgroundColour() )
2114 SetBackgroundColour(mergefrom->GetBackgroundColour());
2115 if ( !HasFont() && mergefrom->HasFont() )
2116 SetFont(mergefrom->GetFont());
2117 if ( !HasAlignment() && mergefrom->HasAlignment() ){
2118 int hAlign, vAlign;
2119 mergefrom->GetAlignment( &hAlign, &vAlign);
2120 SetAlignment(hAlign, vAlign);
2121 }
2122
2123 mergefrom->GetSize( &m_sizeRows, &m_sizeCols );
2124
2125 // Directly access member functions as GetRender/Editor don't just return
2126 // m_renderer/m_editor
2127 //
2128 // Maybe add support for merge of Render and Editor?
2129 if (!HasRenderer() && mergefrom->HasRenderer() )
2130 {
2131 m_renderer = mergefrom->m_renderer;
2132 m_renderer->IncRef();
2133 }
2134 if ( !HasEditor() && mergefrom->HasEditor() )
2135 {
2136 m_editor = mergefrom->m_editor;
2137 m_editor->IncRef();
2138 }
2139 if ( !HasReadWriteMode() && mergefrom->HasReadWriteMode() )
2140 SetReadOnly(mergefrom->IsReadOnly());
2141
2142 if (!HasOverflowMode() && mergefrom->HasOverflowMode() )
2143 SetOverflow(mergefrom->GetOverflow());
2144
2145 SetDefAttr(mergefrom->m_defGridAttr);
2146 }
2147
2148 void wxGridCellAttr::SetSize(int num_rows, int num_cols)
2149 {
2150 // The size of a cell is normally 1,1
2151
2152 // If this cell is larger (2,2) then this is the top left cell
2153 // the other cells that will be covered (lower right cells) must be
2154 // set to negative or zero values such that
2155 // row + num_rows of the covered cell points to the larger cell (this cell)
2156 // same goes for the col + num_cols.
2157
2158 // Size of 0,0 is NOT valid, neither is <=0 and any positive value
2159
2160 wxASSERT_MSG( (!((num_rows>0)&&(num_cols<=0)) ||
2161 !((num_rows<=0)&&(num_cols>0)) ||
2162 !((num_rows==0)&&(num_cols==0))),
2163 wxT("wxGridCellAttr::SetSize only takes two postive values or negative/zero values"));
2164
2165 m_sizeRows = num_rows;
2166 m_sizeCols = num_cols;
2167 }
2168
2169 const wxColour& wxGridCellAttr::GetTextColour() const
2170 {
2171 if (HasTextColour())
2172 {
2173 return m_colText;
2174 }
2175 else if (m_defGridAttr && m_defGridAttr != this)
2176 {
2177 return m_defGridAttr->GetTextColour();
2178 }
2179 else
2180 {
2181 wxFAIL_MSG(wxT("Missing default cell attribute"));
2182 return wxNullColour;
2183 }
2184 }
2185
2186
2187 const wxColour& wxGridCellAttr::GetBackgroundColour() const
2188 {
2189 if (HasBackgroundColour())
2190 return m_colBack;
2191 else if (m_defGridAttr && m_defGridAttr != this)
2192 return m_defGridAttr->GetBackgroundColour();
2193 else
2194 {
2195 wxFAIL_MSG(wxT("Missing default cell attribute"));
2196 return wxNullColour;
2197 }
2198 }
2199
2200
2201 const wxFont& wxGridCellAttr::GetFont() const
2202 {
2203 if (HasFont())
2204 return m_font;
2205 else if (m_defGridAttr && m_defGridAttr != this)
2206 return m_defGridAttr->GetFont();
2207 else
2208 {
2209 wxFAIL_MSG(wxT("Missing default cell attribute"));
2210 return wxNullFont;
2211 }
2212 }
2213
2214
2215 void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
2216 {
2217 if (HasAlignment())
2218 {
2219 if ( hAlign ) *hAlign = m_hAlign;
2220 if ( vAlign ) *vAlign = m_vAlign;
2221 }
2222 else if (m_defGridAttr && m_defGridAttr != this)
2223 m_defGridAttr->GetAlignment(hAlign, vAlign);
2224 else
2225 {
2226 wxFAIL_MSG(wxT("Missing default cell attribute"));
2227 }
2228 }
2229
2230 void wxGridCellAttr::GetSize( int *num_rows, int *num_cols ) const
2231 {
2232 if ( num_rows ) *num_rows = m_sizeRows;
2233 if ( num_cols ) *num_cols = m_sizeCols;
2234 }
2235
2236 // GetRenderer and GetEditor use a slightly different decision path about
2237 // which attribute to use. If a non-default attr object has one then it is
2238 // used, otherwise the default editor or renderer is fetched from the grid and
2239 // used. It should be the default for the data type of the cell. If it is
2240 // NULL (because the table has a type that the grid does not have in its
2241 // registry,) then the grid's default editor or renderer is used.
2242
2243 wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col) const
2244 {
2245 wxGridCellRenderer *renderer;
2246
2247 if ( m_renderer && this != m_defGridAttr )
2248 {
2249 // use the cells renderer if it has one
2250 renderer = m_renderer;
2251 renderer->IncRef();
2252 }
2253 else // no non default cell renderer
2254 {
2255 // get default renderer for the data type
2256 if ( grid )
2257 {
2258 // GetDefaultRendererForCell() will do IncRef() for us
2259 renderer = grid->GetDefaultRendererForCell(row, col);
2260 }
2261 else
2262 {
2263 renderer = NULL;
2264 }
2265
2266 if ( !renderer )
2267 {
2268 if (m_defGridAttr && this != m_defGridAttr )
2269 {
2270 // if we still don't have one then use the grid default
2271 // (no need for IncRef() here neither)
2272 renderer = m_defGridAttr->GetRenderer(NULL, 0, 0);
2273 }
2274 else // default grid attr
2275 {
2276 // use m_renderer which we had decided not to use initially
2277 renderer = m_renderer;
2278 if ( renderer )
2279 renderer->IncRef();
2280 }
2281 }
2282 }
2283
2284 // we're supposed to always find something
2285 wxASSERT_MSG(renderer, wxT("Missing default cell renderer"));
2286
2287 return renderer;
2288 }
2289
2290 // same as above, except for s/renderer/editor/g
2291 wxGridCellEditor* wxGridCellAttr::GetEditor(wxGrid* grid, int row, int col) const
2292 {
2293 wxGridCellEditor *editor;
2294
2295 if ( m_editor && this != m_defGridAttr )
2296 {
2297 // use the cells editor if it has one
2298 editor = m_editor;
2299 editor->IncRef();
2300 }
2301 else // no non default cell editor
2302 {
2303 // get default editor for the data type
2304 if ( grid )
2305 {
2306 // GetDefaultEditorForCell() will do IncRef() for us
2307 editor = grid->GetDefaultEditorForCell(row, col);
2308 }
2309 else
2310 {
2311 editor = NULL;
2312 }
2313
2314 if ( !editor )
2315 {
2316 if ( m_defGridAttr && this != m_defGridAttr )
2317 {
2318 // if we still don't have one then use the grid default
2319 // (no need for IncRef() here neither)
2320 editor = m_defGridAttr->GetEditor(NULL, 0, 0);
2321 }
2322 else // default grid attr
2323 {
2324 // use m_editor which we had decided not to use initially
2325 editor = m_editor;
2326 if ( editor )
2327 editor->IncRef();
2328 }
2329 }
2330 }
2331
2332 // we're supposed to always find something
2333 wxASSERT_MSG(editor, wxT("Missing default cell editor"));
2334
2335 return editor;
2336 }
2337
2338 // ----------------------------------------------------------------------------
2339 // wxGridCellAttrData
2340 // ----------------------------------------------------------------------------
2341
2342 void wxGridCellAttrData::SetAttr(wxGridCellAttr *attr, int row, int col)
2343 {
2344 int n = FindIndex(row, col);
2345 if ( n == wxNOT_FOUND )
2346 {
2347 // add the attribute
2348 m_attrs.Add(new wxGridCellWithAttr(row, col, attr));
2349 }
2350 else
2351 {
2352 // free the old attribute
2353 m_attrs[(size_t)n].attr->DecRef();
2354
2355 if ( attr )
2356 {
2357 // change the attribute
2358 m_attrs[(size_t)n].attr = attr;
2359 }
2360 else
2361 {
2362 // remove this attribute
2363 m_attrs.RemoveAt((size_t)n);
2364 }
2365 }
2366 }
2367
2368 wxGridCellAttr *wxGridCellAttrData::GetAttr(int row, int col) const
2369 {
2370 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2371
2372 int n = FindIndex(row, col);
2373 if ( n != wxNOT_FOUND )
2374 {
2375 attr = m_attrs[(size_t)n].attr;
2376 attr->IncRef();
2377 }
2378
2379 return attr;
2380 }
2381
2382 void wxGridCellAttrData::UpdateAttrRows( size_t pos, int numRows )
2383 {
2384 size_t count = m_attrs.GetCount();
2385 for ( size_t n = 0; n < count; n++ )
2386 {
2387 wxGridCellCoords& coords = m_attrs[n].coords;
2388 wxCoord row = coords.GetRow();
2389 if ((size_t)row >= pos)
2390 {
2391 if (numRows > 0)
2392 {
2393 // If rows inserted, include row counter where necessary
2394 coords.SetRow(row + numRows);
2395 }
2396 else if (numRows < 0)
2397 {
2398 // If rows deleted ...
2399 if ((size_t)row >= pos - numRows)
2400 {
2401 // ...either decrement row counter (if row still exists)...
2402 coords.SetRow(row + numRows);
2403 }
2404 else
2405 {
2406 // ...or remove the attribute
2407 m_attrs.RemoveAt((size_t)n);
2408 n--; count--;
2409 }
2410 }
2411 }
2412 }
2413 }
2414
2415 void wxGridCellAttrData::UpdateAttrCols( size_t pos, int numCols )
2416 {
2417 size_t count = m_attrs.GetCount();
2418 for ( size_t n = 0; n < count; n++ )
2419 {
2420 wxGridCellCoords& coords = m_attrs[n].coords;
2421 wxCoord col = coords.GetCol();
2422 if ( (size_t)col >= pos )
2423 {
2424 if ( numCols > 0 )
2425 {
2426 // If rows inserted, include row counter where necessary
2427 coords.SetCol(col + numCols);
2428 }
2429 else if (numCols < 0)
2430 {
2431 // If rows deleted ...
2432 if ((size_t)col >= pos - numCols)
2433 {
2434 // ...either decrement row counter (if row still exists)...
2435 coords.SetCol(col + numCols);
2436 }
2437 else
2438 {
2439 // ...or remove the attribute
2440 m_attrs.RemoveAt((size_t)n);
2441 n--; count--;
2442 }
2443 }
2444 }
2445 }
2446 }
2447
2448 int wxGridCellAttrData::FindIndex(int row, int col) const
2449 {
2450 size_t count = m_attrs.GetCount();
2451 for ( size_t n = 0; n < count; n++ )
2452 {
2453 const wxGridCellCoords& coords = m_attrs[n].coords;
2454 if ( (coords.GetRow() == row) && (coords.GetCol() == col) )
2455 {
2456 return n;
2457 }
2458 }
2459
2460 return wxNOT_FOUND;
2461 }
2462
2463 // ----------------------------------------------------------------------------
2464 // wxGridRowOrColAttrData
2465 // ----------------------------------------------------------------------------
2466
2467 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
2468 {
2469 size_t count = m_attrs.Count();
2470 for ( size_t n = 0; n < count; n++ )
2471 {
2472 m_attrs[n]->DecRef();
2473 }
2474 }
2475
2476 wxGridCellAttr *wxGridRowOrColAttrData::GetAttr(int rowOrCol) const
2477 {
2478 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2479
2480 int n = m_rowsOrCols.Index(rowOrCol);
2481 if ( n != wxNOT_FOUND )
2482 {
2483 attr = m_attrs[(size_t)n];
2484 attr->IncRef();
2485 }
2486
2487 return attr;
2488 }
2489
2490 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
2491 {
2492 int i = m_rowsOrCols.Index(rowOrCol);
2493 if ( i == wxNOT_FOUND )
2494 {
2495 // add the attribute
2496 m_rowsOrCols.Add(rowOrCol);
2497 m_attrs.Add(attr);
2498 }
2499 else
2500 {
2501 size_t n = (size_t)i;
2502 if ( attr )
2503 {
2504 // change the attribute
2505 m_attrs[n]->DecRef();
2506 m_attrs[n] = attr;
2507 }
2508 else
2509 {
2510 // remove this attribute
2511 m_attrs[n]->DecRef();
2512 m_rowsOrCols.RemoveAt(n);
2513 m_attrs.RemoveAt(n);
2514 }
2515 }
2516 }
2517
2518 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols )
2519 {
2520 size_t count = m_attrs.GetCount();
2521 for ( size_t n = 0; n < count; n++ )
2522 {
2523 int & rowOrCol = m_rowsOrCols[n];
2524 if ( (size_t)rowOrCol >= pos )
2525 {
2526 if ( numRowsOrCols > 0 )
2527 {
2528 // If rows inserted, include row counter where necessary
2529 rowOrCol += numRowsOrCols;
2530 }
2531 else if ( numRowsOrCols < 0)
2532 {
2533 // If rows deleted, either decrement row counter (if row still exists)
2534 if ((size_t)rowOrCol >= pos - numRowsOrCols)
2535 rowOrCol += numRowsOrCols;
2536 else
2537 {
2538 m_rowsOrCols.RemoveAt((size_t)n);
2539 m_attrs.RemoveAt((size_t)n);
2540 n--; count--;
2541 }
2542 }
2543 }
2544 }
2545 }
2546
2547 // ----------------------------------------------------------------------------
2548 // wxGridCellAttrProvider
2549 // ----------------------------------------------------------------------------
2550
2551 wxGridCellAttrProvider::wxGridCellAttrProvider()
2552 {
2553 m_data = (wxGridCellAttrProviderData *)NULL;
2554 }
2555
2556 wxGridCellAttrProvider::~wxGridCellAttrProvider()
2557 {
2558 delete m_data;
2559 }
2560
2561 void wxGridCellAttrProvider::InitData()
2562 {
2563 m_data = new wxGridCellAttrProviderData;
2564 }
2565
2566 wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
2567 wxGridCellAttr::wxAttrKind kind ) const
2568 {
2569 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2570 if ( m_data )
2571 {
2572 switch(kind)
2573 {
2574 case (wxGridCellAttr::Any):
2575 //Get cached merge attributes.
2576 // Currenlty not used as no cache implemented as not mutiable
2577 // attr = m_data->m_mergeAttr.GetAttr(row, col);
2578 if(!attr)
2579 {
2580 //Basicaly implement old version.
2581 //Also check merge cache, so we don't have to re-merge every time..
2582 wxGridCellAttr *attrcell = (wxGridCellAttr *)NULL,
2583 *attrrow = (wxGridCellAttr *)NULL,
2584 *attrcol = (wxGridCellAttr *)NULL;
2585
2586 attrcell = m_data->m_cellAttrs.GetAttr(row, col);
2587 attrcol = m_data->m_colAttrs.GetAttr(col);
2588 attrrow = m_data->m_rowAttrs.GetAttr(row);
2589
2590 if((attrcell != attrrow) && (attrrow !=attrcol) && (attrcell != attrcol)){
2591 // Two or move are non NULL
2592 attr = new wxGridCellAttr;
2593 attr->SetKind(wxGridCellAttr::Merged);
2594
2595 //Order important..
2596 if(attrcell){
2597 attr->MergeWith(attrcell);
2598 attrcell->DecRef();
2599 }
2600 if(attrcol){
2601 attr->MergeWith(attrcol);
2602 attrcol->DecRef();
2603 }
2604 if(attrrow){
2605 attr->MergeWith(attrrow);
2606 attrrow->DecRef();
2607 }
2608 //store merge attr if cache implemented
2609 //attr->IncRef();
2610 //m_data->m_mergeAttr.SetAttr(attr, row, col);
2611 }
2612 else
2613 {
2614 // one or none is non null return it or null.
2615 if(attrrow) attr = attrrow;
2616 if(attrcol) attr = attrcol;
2617 if(attrcell) attr = attrcell;
2618 }
2619 }
2620 break;
2621 case (wxGridCellAttr::Cell):
2622 attr = m_data->m_cellAttrs.GetAttr(row, col);
2623 break;
2624 case (wxGridCellAttr::Col):
2625 attr = m_data->m_colAttrs.GetAttr(col);
2626 break;
2627 case (wxGridCellAttr::Row):
2628 attr = m_data->m_rowAttrs.GetAttr(row);
2629 break;
2630 default:
2631 // unused as yet...
2632 // (wxGridCellAttr::Default):
2633 // (wxGridCellAttr::Merged):
2634 break;
2635 }
2636 }
2637 return attr;
2638 }
2639
2640 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr *attr,
2641 int row, int col)
2642 {
2643 if ( !m_data )
2644 InitData();
2645
2646 m_data->m_cellAttrs.SetAttr(attr, row, col);
2647 }
2648
2649 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr *attr, int row)
2650 {
2651 if ( !m_data )
2652 InitData();
2653
2654 m_data->m_rowAttrs.SetAttr(attr, row);
2655 }
2656
2657 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr *attr, int col)
2658 {
2659 if ( !m_data )
2660 InitData();
2661
2662 m_data->m_colAttrs.SetAttr(attr, col);
2663 }
2664
2665 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos, int numRows )
2666 {
2667 if ( m_data )
2668 {
2669 m_data->m_cellAttrs.UpdateAttrRows( pos, numRows );
2670
2671 m_data->m_rowAttrs.UpdateAttrRowsOrCols( pos, numRows );
2672 }
2673 }
2674
2675 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos, int numCols )
2676 {
2677 if ( m_data )
2678 {
2679 m_data->m_cellAttrs.UpdateAttrCols( pos, numCols );
2680
2681 m_data->m_colAttrs.UpdateAttrRowsOrCols( pos, numCols );
2682 }
2683 }
2684
2685 // ----------------------------------------------------------------------------
2686 // wxGridTypeRegistry
2687 // ----------------------------------------------------------------------------
2688
2689 wxGridTypeRegistry::~wxGridTypeRegistry()
2690 {
2691 size_t count = m_typeinfo.Count();
2692 for ( size_t i = 0; i < count; i++ )
2693 delete m_typeinfo[i];
2694 }
2695
2696
2697 void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
2698 wxGridCellRenderer* renderer,
2699 wxGridCellEditor* editor)
2700 {
2701 wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
2702
2703 // is it already registered?
2704 int loc = FindRegisteredDataType(typeName);
2705 if ( loc != wxNOT_FOUND )
2706 {
2707 delete m_typeinfo[loc];
2708 m_typeinfo[loc] = info;
2709 }
2710 else
2711 {
2712 m_typeinfo.Add(info);
2713 }
2714 }
2715
2716 int wxGridTypeRegistry::FindRegisteredDataType(const wxString& typeName)
2717 {
2718 size_t count = m_typeinfo.GetCount();
2719 for ( size_t i = 0; i < count; i++ )
2720 {
2721 if ( typeName == m_typeinfo[i]->m_typeName )
2722 {
2723 return i;
2724 }
2725 }
2726
2727 return wxNOT_FOUND;
2728 }
2729
2730 int wxGridTypeRegistry::FindDataType(const wxString& typeName)
2731 {
2732 int index = FindRegisteredDataType(typeName);
2733 if ( index == wxNOT_FOUND )
2734 {
2735 // check whether this is one of the standard ones, in which case
2736 // register it "on the fly"
2737 #if wxUSE_TEXTCTRL
2738 if ( typeName == wxGRID_VALUE_STRING )
2739 {
2740 RegisterDataType(wxGRID_VALUE_STRING,
2741 new wxGridCellStringRenderer,
2742 new wxGridCellTextEditor);
2743 } else
2744 #endif // wxUSE_TEXTCTRL
2745 #if wxUSE_CHECKBOX
2746 if ( typeName == wxGRID_VALUE_BOOL )
2747 {
2748 RegisterDataType(wxGRID_VALUE_BOOL,
2749 new wxGridCellBoolRenderer,
2750 new wxGridCellBoolEditor);
2751 } else
2752 #endif // wxUSE_CHECKBOX
2753 #if wxUSE_TEXTCTRL
2754 if ( typeName == wxGRID_VALUE_NUMBER )
2755 {
2756 RegisterDataType(wxGRID_VALUE_NUMBER,
2757 new wxGridCellNumberRenderer,
2758 new wxGridCellNumberEditor);
2759 }
2760 else if ( typeName == wxGRID_VALUE_FLOAT )
2761 {
2762 RegisterDataType(wxGRID_VALUE_FLOAT,
2763 new wxGridCellFloatRenderer,
2764 new wxGridCellFloatEditor);
2765 } else
2766 #endif // wxUSE_TEXTCTRL
2767 #if wxUSE_COMBOBOX
2768 if ( typeName == wxGRID_VALUE_CHOICE )
2769 {
2770 RegisterDataType(wxGRID_VALUE_CHOICE,
2771 new wxGridCellStringRenderer,
2772 new wxGridCellChoiceEditor);
2773 } else
2774 #endif // wxUSE_COMBOBOX
2775 {
2776 return wxNOT_FOUND;
2777 }
2778
2779 // we get here only if just added the entry for this type, so return
2780 // the last index
2781 index = m_typeinfo.GetCount() - 1;
2782 }
2783
2784 return index;
2785 }
2786
2787 int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
2788 {
2789 int index = FindDataType(typeName);
2790 if ( index == wxNOT_FOUND )
2791 {
2792 // the first part of the typename is the "real" type, anything after ':'
2793 // are the parameters for the renderer
2794 index = FindDataType(typeName.BeforeFirst(_T(':')));
2795 if ( index == wxNOT_FOUND )
2796 {
2797 return wxNOT_FOUND;
2798 }
2799
2800 wxGridCellRenderer *renderer = GetRenderer(index);
2801 wxGridCellRenderer *rendererOld = renderer;
2802 renderer = renderer->Clone();
2803 rendererOld->DecRef();
2804
2805 wxGridCellEditor *editor = GetEditor(index);
2806 wxGridCellEditor *editorOld = editor;
2807 editor = editor->Clone();
2808 editorOld->DecRef();
2809
2810 // do it even if there are no parameters to reset them to defaults
2811 wxString params = typeName.AfterFirst(_T(':'));
2812 renderer->SetParameters(params);
2813 editor->SetParameters(params);
2814
2815 // register the new typename
2816 RegisterDataType(typeName, renderer, editor);
2817
2818 // we just registered it, it's the last one
2819 index = m_typeinfo.GetCount() - 1;
2820 }
2821
2822 return index;
2823 }
2824
2825 wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
2826 {
2827 wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
2828 if (renderer)
2829 renderer->IncRef();
2830 return renderer;
2831 }
2832
2833 wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
2834 {
2835 wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
2836 if (editor)
2837 editor->IncRef();
2838 return editor;
2839 }
2840
2841 // ----------------------------------------------------------------------------
2842 // wxGridTableBase
2843 // ----------------------------------------------------------------------------
2844
2845 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
2846
2847
2848 wxGridTableBase::wxGridTableBase()
2849 {
2850 m_view = (wxGrid *) NULL;
2851 m_attrProvider = (wxGridCellAttrProvider *) NULL;
2852 }
2853
2854 wxGridTableBase::~wxGridTableBase()
2855 {
2856 delete m_attrProvider;
2857 }
2858
2859 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
2860 {
2861 delete m_attrProvider;
2862 m_attrProvider = attrProvider;
2863 }
2864
2865 bool wxGridTableBase::CanHaveAttributes()
2866 {
2867 if ( ! GetAttrProvider() )
2868 {
2869 // use the default attr provider by default
2870 SetAttrProvider(new wxGridCellAttrProvider);
2871 }
2872 return TRUE;
2873 }
2874
2875 wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col, wxGridCellAttr::wxAttrKind kind)
2876 {
2877 if ( m_attrProvider )
2878 return m_attrProvider->GetAttr(row, col, kind);
2879 else
2880 return (wxGridCellAttr *)NULL;
2881 }
2882
2883 void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
2884 {
2885 if ( m_attrProvider )
2886 {
2887 attr->SetKind(wxGridCellAttr::Cell);
2888 m_attrProvider->SetAttr(attr, row, col);
2889 }
2890 else
2891 {
2892 // as we take ownership of the pointer and don't store it, we must
2893 // free it now
2894 wxSafeDecRef(attr);
2895 }
2896 }
2897
2898 void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
2899 {
2900 if ( m_attrProvider )
2901 {
2902 attr->SetKind(wxGridCellAttr::Row);
2903 m_attrProvider->SetRowAttr(attr, row);
2904 }
2905 else
2906 {
2907 // as we take ownership of the pointer and don't store it, we must
2908 // free it now
2909 wxSafeDecRef(attr);
2910 }
2911 }
2912
2913 void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
2914 {
2915 if ( m_attrProvider )
2916 {
2917 attr->SetKind(wxGridCellAttr::Col);
2918 m_attrProvider->SetColAttr(attr, col);
2919 }
2920 else
2921 {
2922 // as we take ownership of the pointer and don't store it, we must
2923 // free it now
2924 wxSafeDecRef(attr);
2925 }
2926 }
2927
2928 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos),
2929 size_t WXUNUSED(numRows) )
2930 {
2931 wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
2932
2933 return FALSE;
2934 }
2935
2936 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows) )
2937 {
2938 wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
2939
2940 return FALSE;
2941 }
2942
2943 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos),
2944 size_t WXUNUSED(numRows) )
2945 {
2946 wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
2947
2948 return FALSE;
2949 }
2950
2951 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos),
2952 size_t WXUNUSED(numCols) )
2953 {
2954 wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
2955
2956 return FALSE;
2957 }
2958
2959 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols) )
2960 {
2961 wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
2962
2963 return FALSE;
2964 }
2965
2966 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos),
2967 size_t WXUNUSED(numCols) )
2968 {
2969 wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
2970
2971 return FALSE;
2972 }
2973
2974
2975 wxString wxGridTableBase::GetRowLabelValue( int row )
2976 {
2977 wxString s;
2978 s << row + 1; // RD: Starting the rows at zero confuses users, no matter
2979 // how much it makes sense to us geeks.
2980 return s;
2981 }
2982
2983 wxString wxGridTableBase::GetColLabelValue( int col )
2984 {
2985 // default col labels are:
2986 // cols 0 to 25 : A-Z
2987 // cols 26 to 675 : AA-ZZ
2988 // etc.
2989
2990 wxString s;
2991 unsigned int i, n;
2992 for ( n = 1; ; n++ )
2993 {
2994 s += (_T('A') + (wxChar)( col%26 ));
2995 col = col/26 - 1;
2996 if ( col < 0 ) break;
2997 }
2998
2999 // reverse the string...
3000 wxString s2;
3001 for ( i = 0; i < n; i++ )
3002 {
3003 s2 += s[n-i-1];
3004 }
3005
3006 return s2;
3007 }
3008
3009
3010 wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
3011 {
3012 return wxGRID_VALUE_STRING;
3013 }
3014
3015 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row), int WXUNUSED(col),
3016 const wxString& typeName )
3017 {
3018 return typeName == wxGRID_VALUE_STRING;
3019 }
3020
3021 bool wxGridTableBase::CanSetValueAs( int row, int col, const wxString& typeName )
3022 {
3023 return CanGetValueAs(row, col, typeName);
3024 }
3025
3026 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row), int WXUNUSED(col) )
3027 {
3028 return 0;
3029 }
3030
3031 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col) )
3032 {
3033 return 0.0;
3034 }
3035
3036 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row), int WXUNUSED(col) )
3037 {
3038 return FALSE;
3039 }
3040
3041 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row), int WXUNUSED(col),
3042 long WXUNUSED(value) )
3043 {
3044 }
3045
3046 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col),
3047 double WXUNUSED(value) )
3048 {
3049 }
3050
3051 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row), int WXUNUSED(col),
3052 bool WXUNUSED(value) )
3053 {
3054 }
3055
3056
3057 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
3058 const wxString& WXUNUSED(typeName) )
3059 {
3060 return NULL;
3061 }
3062
3063 void wxGridTableBase::SetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
3064 const wxString& WXUNUSED(typeName),
3065 void* WXUNUSED(value) )
3066 {
3067 }
3068
3069 //////////////////////////////////////////////////////////////////////
3070 //
3071 // Message class for the grid table to send requests and notifications
3072 // to the grid view
3073 //
3074
3075 wxGridTableMessage::wxGridTableMessage()
3076 {
3077 m_table = (wxGridTableBase *) NULL;
3078 m_id = -1;
3079 m_comInt1 = -1;
3080 m_comInt2 = -1;
3081 }
3082
3083 wxGridTableMessage::wxGridTableMessage( wxGridTableBase *table, int id,
3084 int commandInt1, int commandInt2 )
3085 {
3086 m_table = table;
3087 m_id = id;
3088 m_comInt1 = commandInt1;
3089 m_comInt2 = commandInt2;
3090 }
3091
3092
3093
3094 //////////////////////////////////////////////////////////////////////
3095 //
3096 // A basic grid table for string data. An object of this class will
3097 // created by wxGrid if you don't specify an alternative table class.
3098 //
3099
3100 WX_DEFINE_OBJARRAY(wxGridStringArray)
3101
3102 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
3103
3104 wxGridStringTable::wxGridStringTable()
3105 : wxGridTableBase()
3106 {
3107 }
3108
3109 wxGridStringTable::wxGridStringTable( int numRows, int numCols )
3110 : wxGridTableBase()
3111 {
3112 m_data.Alloc( numRows );
3113
3114 wxArrayString sa;
3115 sa.Alloc( numCols );
3116 sa.Add( wxEmptyString, numCols );
3117
3118 m_data.Add( sa, numRows );
3119 }
3120
3121 wxGridStringTable::~wxGridStringTable()
3122 {
3123 }
3124
3125 int wxGridStringTable::GetNumberRows()
3126 {
3127 return m_data.GetCount();
3128 }
3129
3130 int wxGridStringTable::GetNumberCols()
3131 {
3132 if ( m_data.GetCount() > 0 )
3133 return m_data[0].GetCount();
3134 else
3135 return 0;
3136 }
3137
3138 wxString wxGridStringTable::GetValue( int row, int col )
3139 {
3140 wxCHECK_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
3141 wxEmptyString,
3142 _T("invalid row or column index in wxGridStringTable") );
3143
3144 return m_data[row][col];
3145 }
3146
3147 void wxGridStringTable::SetValue( int row, int col, const wxString& value )
3148 {
3149 wxCHECK_RET( (row < GetNumberRows()) && (col < GetNumberCols()),
3150 _T("invalid row or column index in wxGridStringTable") );
3151
3152 m_data[row][col] = value;
3153 }
3154
3155 bool wxGridStringTable::IsEmptyCell( int row, int col )
3156 {
3157 wxCHECK_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
3158 true,
3159 _T("invalid row or column index in wxGridStringTable") );
3160
3161 return (m_data[row][col] == wxEmptyString);
3162 }
3163
3164 void wxGridStringTable::Clear()
3165 {
3166 int row, col;
3167 int numRows, numCols;
3168
3169 numRows = m_data.GetCount();
3170 if ( numRows > 0 )
3171 {
3172 numCols = m_data[0].GetCount();
3173
3174 for ( row = 0; row < numRows; row++ )
3175 {
3176 for ( col = 0; col < numCols; col++ )
3177 {
3178 m_data[row][col] = wxEmptyString;
3179 }
3180 }
3181 }
3182 }
3183
3184
3185 bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
3186 {
3187 size_t curNumRows = m_data.GetCount();
3188 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3189 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3190
3191 if ( pos >= curNumRows )
3192 {
3193 return AppendRows( numRows );
3194 }
3195
3196 wxArrayString sa;
3197 sa.Alloc( curNumCols );
3198 sa.Add( wxEmptyString, curNumCols );
3199 m_data.Insert( sa, pos, numRows );
3200 if ( GetView() )
3201 {
3202 wxGridTableMessage msg( this,
3203 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
3204 pos,
3205 numRows );
3206
3207 GetView()->ProcessTableMessage( msg );
3208 }
3209
3210 return TRUE;
3211 }
3212
3213 bool wxGridStringTable::AppendRows( size_t numRows )
3214 {
3215 size_t curNumRows = m_data.GetCount();
3216 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3217 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3218
3219 wxArrayString sa;
3220 if ( curNumCols > 0 )
3221 {
3222 sa.Alloc( curNumCols );
3223 sa.Add( wxEmptyString, curNumCols );
3224 }
3225
3226 m_data.Add( sa, numRows );
3227
3228 if ( GetView() )
3229 {
3230 wxGridTableMessage msg( this,
3231 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
3232 numRows );
3233
3234 GetView()->ProcessTableMessage( msg );
3235 }
3236
3237 return TRUE;
3238 }
3239
3240 bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
3241 {
3242 size_t curNumRows = m_data.GetCount();
3243
3244 if ( pos >= curNumRows )
3245 {
3246 wxFAIL_MSG( wxString::Format
3247 (
3248 wxT("Called wxGridStringTable::DeleteRows(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu rows"),
3249 (unsigned long)pos,
3250 (unsigned long)numRows,
3251 (unsigned long)curNumRows
3252 ) );
3253
3254 return FALSE;
3255 }
3256
3257 if ( numRows > curNumRows - pos )
3258 {
3259 numRows = curNumRows - pos;
3260 }
3261
3262 if ( numRows >= curNumRows )
3263 {
3264 m_data.Clear();
3265 }
3266 else
3267 {
3268 m_data.RemoveAt( pos, numRows );
3269 }
3270 if ( GetView() )
3271 {
3272 wxGridTableMessage msg( this,
3273 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
3274 pos,
3275 numRows );
3276
3277 GetView()->ProcessTableMessage( msg );
3278 }
3279
3280 return TRUE;
3281 }
3282
3283 bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
3284 {
3285 size_t row, col;
3286
3287 size_t curNumRows = m_data.GetCount();
3288 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3289 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3290
3291 if ( pos >= curNumCols )
3292 {
3293 return AppendCols( numCols );
3294 }
3295
3296 for ( row = 0; row < curNumRows; row++ )
3297 {
3298 for ( col = pos; col < pos + numCols; col++ )
3299 {
3300 m_data[row].Insert( wxEmptyString, col );
3301 }
3302 }
3303 if ( GetView() )
3304 {
3305 wxGridTableMessage msg( this,
3306 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
3307 pos,
3308 numCols );
3309
3310 GetView()->ProcessTableMessage( msg );
3311 }
3312
3313 return TRUE;
3314 }
3315
3316 bool wxGridStringTable::AppendCols( size_t numCols )
3317 {
3318 size_t row;
3319
3320 size_t curNumRows = m_data.GetCount();
3321 #if 0
3322 if ( !curNumRows )
3323 {
3324 // TODO: something better than this ?
3325 //
3326 wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
3327 return FALSE;
3328 }
3329 #endif
3330
3331 for ( row = 0; row < curNumRows; row++ )
3332 {
3333 m_data[row].Add( wxEmptyString, numCols );
3334 }
3335
3336 if ( GetView() )
3337 {
3338 wxGridTableMessage msg( this,
3339 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
3340 numCols );
3341
3342 GetView()->ProcessTableMessage( msg );
3343 }
3344
3345 return TRUE;
3346 }
3347
3348 bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
3349 {
3350 size_t row;
3351
3352 size_t curNumRows = m_data.GetCount();
3353 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3354 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3355
3356 if ( pos >= curNumCols )
3357 {
3358 wxFAIL_MSG( wxString::Format
3359 (
3360 wxT("Called wxGridStringTable::DeleteCols(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu cols"),
3361 (unsigned long)pos,
3362 (unsigned long)numCols,
3363 (unsigned long)curNumCols
3364 ) );
3365 return FALSE;
3366 }
3367
3368 if ( numCols > curNumCols - pos )
3369 {
3370 numCols = curNumCols - pos;
3371 }
3372
3373 for ( row = 0; row < curNumRows; row++ )
3374 {
3375 if ( numCols >= curNumCols )
3376 {
3377 m_data[row].Clear();
3378 }
3379 else
3380 {
3381 m_data[row].RemoveAt( pos, numCols );
3382 }
3383 }
3384 if ( GetView() )
3385 {
3386 wxGridTableMessage msg( this,
3387 wxGRIDTABLE_NOTIFY_COLS_DELETED,
3388 pos,
3389 numCols );
3390
3391 GetView()->ProcessTableMessage( msg );
3392 }
3393
3394 return TRUE;
3395 }
3396
3397 wxString wxGridStringTable::GetRowLabelValue( int row )
3398 {
3399 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3400 {
3401 // using default label
3402 //
3403 return wxGridTableBase::GetRowLabelValue( row );
3404 }
3405 else
3406 {
3407 return m_rowLabels[ row ];
3408 }
3409 }
3410
3411 wxString wxGridStringTable::GetColLabelValue( int col )
3412 {
3413 if ( col > (int)(m_colLabels.GetCount()) - 1 )
3414 {
3415 // using default label
3416 //
3417 return wxGridTableBase::GetColLabelValue( col );
3418 }
3419 else
3420 {
3421 return m_colLabels[ col ];
3422 }
3423 }
3424
3425 void wxGridStringTable::SetRowLabelValue( int row, const wxString& value )
3426 {
3427 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3428 {
3429 int n = m_rowLabels.GetCount();
3430 int i;
3431 for ( i = n; i <= row; i++ )
3432 {
3433 m_rowLabels.Add( wxGridTableBase::GetRowLabelValue(i) );
3434 }
3435 }
3436
3437 m_rowLabels[row] = value;
3438 }
3439
3440 void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
3441 {
3442 if ( col > (int)(m_colLabels.GetCount()) - 1 )
3443 {
3444 int n = m_colLabels.GetCount();
3445 int i;
3446 for ( i = n; i <= col; i++ )
3447 {
3448 m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
3449 }
3450 }
3451
3452 m_colLabels[col] = value;
3453 }
3454
3455
3456
3457 //////////////////////////////////////////////////////////////////////
3458 //////////////////////////////////////////////////////////////////////
3459
3460 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
3461
3462 BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
3463 EVT_PAINT( wxGridRowLabelWindow::OnPaint )
3464 EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel)
3465 EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
3466 EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
3467 EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp )
3468 END_EVENT_TABLE()
3469
3470 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
3471 wxWindowID id,
3472 const wxPoint &pos, const wxSize &size )
3473 : wxWindow( parent, id, pos, size, wxWANTS_CHARS|wxBORDER_NONE )
3474 {
3475 m_owner = parent;
3476 }
3477
3478 void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3479 {
3480 wxPaintDC dc(this);
3481
3482 // NO - don't do this because it will set both the x and y origin
3483 // coords to match the parent scrolled window and we just want to
3484 // set the y coord - MB
3485 //
3486 // m_owner->PrepareDC( dc );
3487
3488 int x, y;
3489 m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3490 dc.SetDeviceOrigin( 0, -y );
3491
3492 wxArrayInt rows = m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
3493 m_owner->DrawRowLabels( dc , rows );
3494 }
3495
3496
3497 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
3498 {
3499 m_owner->ProcessRowLabelMouseEvent( event );
3500 }
3501
3502
3503 void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent& event )
3504 {
3505 m_owner->GetEventHandler()->ProcessEvent(event);
3506 }
3507
3508
3509 // This seems to be required for wxMotif otherwise the mouse
3510 // cursor must be in the cell edit control to get key events
3511 //
3512 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
3513 {
3514 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3515 }
3516
3517 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent& event )
3518 {
3519 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3520 }
3521
3522
3523
3524 //////////////////////////////////////////////////////////////////////
3525
3526 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
3527
3528 BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
3529 EVT_PAINT( wxGridColLabelWindow::OnPaint )
3530 EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel)
3531 EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
3532 EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
3533 EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp )
3534 END_EVENT_TABLE()
3535
3536 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
3537 wxWindowID id,
3538 const wxPoint &pos, const wxSize &size )
3539 : wxWindow( parent, id, pos, size, wxWANTS_CHARS|wxBORDER_NONE )
3540 {
3541 m_owner = parent;
3542 }
3543
3544 void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3545 {
3546 wxPaintDC dc(this);
3547
3548 // NO - don't do this because it will set both the x and y origin
3549 // coords to match the parent scrolled window and we just want to
3550 // set the x coord - MB
3551 //
3552 // m_owner->PrepareDC( dc );
3553
3554 int x, y;
3555 m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3556 dc.SetDeviceOrigin( -x, 0 );
3557
3558 wxArrayInt cols = m_owner->CalcColLabelsExposed( GetUpdateRegion() );
3559 m_owner->DrawColLabels( dc , cols );
3560 }
3561
3562
3563 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
3564 {
3565 m_owner->ProcessColLabelMouseEvent( event );
3566 }
3567
3568 void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent& event )
3569 {
3570 m_owner->GetEventHandler()->ProcessEvent(event);
3571 }
3572
3573
3574 // This seems to be required for wxMotif otherwise the mouse
3575 // cursor must be in the cell edit control to get key events
3576 //
3577 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
3578 {
3579 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3580 }
3581
3582 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
3583 {
3584 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3585 }
3586
3587
3588
3589 //////////////////////////////////////////////////////////////////////
3590
3591 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
3592
3593 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
3594 EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel)
3595 EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
3596 EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
3597 EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
3598 EVT_KEY_UP( wxGridCornerLabelWindow::OnKeyUp )
3599 END_EVENT_TABLE()
3600
3601 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
3602 wxWindowID id,
3603 const wxPoint &pos, const wxSize &size )
3604 : wxWindow( parent, id, pos, size, wxWANTS_CHARS|wxBORDER_NONE )
3605 {
3606 m_owner = parent;
3607 }
3608
3609 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3610 {
3611 wxPaintDC dc(this);
3612
3613 int client_height = 0;
3614 int client_width = 0;
3615 GetClientSize( &client_width, &client_height );
3616
3617 dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
3618 dc.DrawLine( client_width-1, client_height-1, client_width-1, 0 );
3619 dc.DrawLine( client_width-1, client_height-1, 0, client_height-1 );
3620 dc.DrawLine( 0, 0, client_width, 0 );
3621 dc.DrawLine( 0, 0, 0, client_height );
3622
3623 dc.SetPen( *wxWHITE_PEN );
3624 dc.DrawLine( 1, 1, client_width-1, 1 );
3625 dc.DrawLine( 1, 1, 1, client_height-1 );
3626 }
3627
3628
3629 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
3630 {
3631 m_owner->ProcessCornerLabelMouseEvent( event );
3632 }
3633
3634
3635 void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent& event )
3636 {
3637 m_owner->GetEventHandler()->ProcessEvent(event);
3638 }
3639
3640 // This seems to be required for wxMotif otherwise the mouse
3641 // cursor must be in the cell edit control to get key events
3642 //
3643 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
3644 {
3645 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3646 }
3647
3648 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent& event )
3649 {
3650 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3651 }
3652
3653
3654
3655 //////////////////////////////////////////////////////////////////////
3656
3657 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxWindow )
3658
3659 BEGIN_EVENT_TABLE( wxGridWindow, wxWindow )
3660 EVT_PAINT( wxGridWindow::OnPaint )
3661 EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel)
3662 EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
3663 EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
3664 EVT_KEY_UP( wxGridWindow::OnKeyUp )
3665 EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground )
3666 END_EVENT_TABLE()
3667
3668 wxGridWindow::wxGridWindow( wxGrid *parent,
3669 wxGridRowLabelWindow *rowLblWin,
3670 wxGridColLabelWindow *colLblWin,
3671 wxWindowID id,
3672 const wxPoint &pos,
3673 const wxSize &size )
3674 : wxWindow( parent, id, pos, size, wxWANTS_CHARS | wxBORDER_NONE | wxCLIP_CHILDREN,
3675 wxT("grid window") )
3676
3677 {
3678 m_owner = parent;
3679 m_rowLabelWin = rowLblWin;
3680 m_colLabelWin = colLblWin;
3681 SetBackgroundColour(_T("WHITE"));
3682 }
3683
3684
3685 wxGridWindow::~wxGridWindow()
3686 {
3687 }
3688
3689
3690 void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
3691 {
3692 wxPaintDC dc( this );
3693 m_owner->PrepareDC( dc );
3694 wxRegion reg = GetUpdateRegion();
3695 wxGridCellCoordsArray DirtyCells = m_owner->CalcCellsExposed( reg );
3696 m_owner->DrawGridCellArea( dc , DirtyCells);
3697 #if WXGRID_DRAW_LINES
3698 m_owner->DrawAllGridLines( dc, reg );
3699 #endif
3700 m_owner->DrawGridSpace( dc );
3701 m_owner->DrawHighlight( dc , DirtyCells );
3702 }
3703
3704
3705 void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
3706 {
3707 wxWindow::ScrollWindow( dx, dy, rect );
3708 m_rowLabelWin->ScrollWindow( 0, dy, rect );
3709 m_colLabelWin->ScrollWindow( dx, 0, rect );
3710 }
3711
3712
3713 void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
3714 {
3715 m_owner->ProcessGridCellMouseEvent( event );
3716 }
3717
3718 void wxGridWindow::OnMouseWheel( wxMouseEvent& event )
3719 {
3720 m_owner->GetEventHandler()->ProcessEvent(event);
3721 }
3722
3723 // This seems to be required for wxMotif/wxGTK otherwise the mouse
3724 // cursor must be in the cell edit control to get key events
3725 //
3726 void wxGridWindow::OnKeyDown( wxKeyEvent& event )
3727 {
3728 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3729 }
3730
3731 void wxGridWindow::OnKeyUp( wxKeyEvent& event )
3732 {
3733 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3734 }
3735
3736 void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
3737 {
3738 }
3739
3740
3741 //////////////////////////////////////////////////////////////////////
3742
3743 // Internal Helper function for computing row or column from some
3744 // (unscrolled) coordinate value, using either
3745 // m_defaultRowHeight/m_defaultColWidth or binary search on array
3746 // of m_rowBottoms/m_ColRights to speed up the search!
3747
3748 // Internal helper macros for simpler use of that function
3749
3750 static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
3751 const wxArrayInt& BorderArray, int nMax,
3752 bool clipToMinMax);
3753
3754 #define internalXToCol(x) CoordToRowOrCol(x, m_defaultColWidth, \
3755 m_minAcceptableColWidth, \
3756 m_colRights, m_numCols, TRUE)
3757 #define internalYToRow(y) CoordToRowOrCol(y, m_defaultRowHeight, \
3758 m_minAcceptableRowHeight, \
3759 m_rowBottoms, m_numRows, TRUE)
3760 /////////////////////////////////////////////////////////////////////
3761
3762 #if wxUSE_EXTENDED_RTTI
3763 WX_DEFINE_FLAGS( wxGridStyle )
3764
3765 WX_BEGIN_FLAGS( wxGridStyle )
3766 // new style border flags, we put them first to
3767 // use them for streaming out
3768 WX_FLAGS_MEMBER(wxBORDER_SIMPLE)
3769 WX_FLAGS_MEMBER(wxBORDER_SUNKEN)
3770 WX_FLAGS_MEMBER(wxBORDER_DOUBLE)
3771 WX_FLAGS_MEMBER(wxBORDER_RAISED)
3772 WX_FLAGS_MEMBER(wxBORDER_STATIC)
3773 WX_FLAGS_MEMBER(wxBORDER_NONE)
3774
3775 // old style border flags
3776 WX_FLAGS_MEMBER(wxSIMPLE_BORDER)
3777 WX_FLAGS_MEMBER(wxSUNKEN_BORDER)
3778 WX_FLAGS_MEMBER(wxDOUBLE_BORDER)
3779 WX_FLAGS_MEMBER(wxRAISED_BORDER)
3780 WX_FLAGS_MEMBER(wxSTATIC_BORDER)
3781 WX_FLAGS_MEMBER(wxNO_BORDER)
3782
3783 // standard window styles
3784 WX_FLAGS_MEMBER(wxTAB_TRAVERSAL)
3785 WX_FLAGS_MEMBER(wxCLIP_CHILDREN)
3786 WX_FLAGS_MEMBER(wxTRANSPARENT_WINDOW)
3787 WX_FLAGS_MEMBER(wxWANTS_CHARS)
3788 WX_FLAGS_MEMBER(wxNO_FULL_REPAINT_ON_RESIZE)
3789 WX_FLAGS_MEMBER(wxALWAYS_SHOW_SB )
3790 WX_FLAGS_MEMBER(wxVSCROLL)
3791 WX_FLAGS_MEMBER(wxHSCROLL)
3792
3793 WX_END_FLAGS( wxGridStyle )
3794
3795 IMPLEMENT_DYNAMIC_CLASS_XTI(wxGrid, wxScrolledWindow,"wx/grid.h")
3796
3797 WX_BEGIN_PROPERTIES_TABLE(wxGrid)
3798 WX_HIDE_PROPERTY( Children )
3799 WX_PROPERTY_FLAGS( WindowStyle , wxGridStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
3800 WX_END_PROPERTIES_TABLE()
3801
3802 WX_BEGIN_HANDLERS_TABLE(wxGrid)
3803 WX_END_HANDLERS_TABLE()
3804
3805 WX_CONSTRUCTOR_5( wxGrid , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
3806
3807 /*
3808 TODO : Expose more information of a list's layout etc. via appropriate objects (à la NotebookPageInfo)
3809 */
3810 #else
3811 IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
3812 #endif
3813
3814 BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
3815 EVT_PAINT( wxGrid::OnPaint )
3816 EVT_SIZE( wxGrid::OnSize )
3817 EVT_KEY_DOWN( wxGrid::OnKeyDown )
3818 EVT_KEY_UP( wxGrid::OnKeyUp )
3819 EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground )
3820 END_EVENT_TABLE()
3821
3822 wxGrid::wxGrid()
3823 {
3824 // in order to make sure that a size event is not
3825 // trigerred in a unfinished state
3826 m_cornerLabelWin = NULL ;
3827 m_rowLabelWin = NULL ;
3828 m_colLabelWin = NULL ;
3829 m_gridWin = NULL ;
3830 }
3831
3832 wxGrid::wxGrid( wxWindow *parent,
3833 wxWindowID id,
3834 const wxPoint& pos,
3835 const wxSize& size,
3836 long style,
3837 const wxString& name )
3838 : wxScrolledWindow( parent, id, pos, size, (style | wxWANTS_CHARS), name ),
3839 m_colMinWidths(GRID_HASH_SIZE),
3840 m_rowMinHeights(GRID_HASH_SIZE)
3841 {
3842 Create();
3843 }
3844
3845 bool wxGrid::Create(wxWindow *parent, wxWindowID id,
3846 const wxPoint& pos, const wxSize& size,
3847 long style, const wxString& name)
3848 {
3849 if (!wxScrolledWindow::Create(parent, id, pos, size,
3850 style | wxWANTS_CHARS , name))
3851 return FALSE;
3852
3853 m_colMinWidths = wxLongToLongHashMap(GRID_HASH_SIZE) ;
3854 m_rowMinHeights = wxLongToLongHashMap(GRID_HASH_SIZE) ;
3855
3856 Create() ;
3857
3858
3859 return TRUE;
3860 }
3861
3862
3863 wxGrid::~wxGrid()
3864 {
3865 // Must do this or ~wxScrollHelper will pop the wrong event handler
3866 SetTargetWindow(this);
3867 ClearAttrCache();
3868 wxSafeDecRef(m_defaultCellAttr);
3869
3870 #ifdef DEBUG_ATTR_CACHE
3871 size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
3872 wxPrintf(_T("wxGrid attribute cache statistics: "
3873 "total: %u, hits: %u (%u%%)\n"),
3874 total, gs_nAttrCacheHits,
3875 total ? (gs_nAttrCacheHits*100) / total : 0);
3876 #endif
3877
3878 if (m_ownTable)
3879 delete m_table;
3880
3881 delete m_typeRegistry;
3882 delete m_selection;
3883 }
3884
3885
3886 //
3887 // ----- internal init and update functions
3888 //
3889
3890 void wxGrid::Create()
3891 {
3892 m_created = FALSE; // set to TRUE by CreateGrid
3893
3894 m_table = (wxGridTableBase *) NULL;
3895 m_ownTable = FALSE;
3896
3897 m_cellEditCtrlEnabled = FALSE;
3898
3899 m_defaultCellAttr = new wxGridCellAttr();
3900
3901 // Set default cell attributes
3902 m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
3903 m_defaultCellAttr->SetKind(wxGridCellAttr::Default);
3904 m_defaultCellAttr->SetFont(GetFont());
3905 m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
3906 m_defaultCellAttr->SetTextColour(
3907 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
3908 m_defaultCellAttr->SetBackgroundColour(
3909 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
3910 m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);
3911 m_defaultCellAttr->SetEditor(new wxGridCellTextEditor);
3912
3913
3914 m_numRows = 0;
3915 m_numCols = 0;
3916 m_currentCellCoords = wxGridNoCellCoords;
3917
3918 m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
3919 m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
3920
3921 // create the type registry
3922 m_typeRegistry = new wxGridTypeRegistry;
3923 m_selection = NULL;
3924
3925 // subwindow components that make up the wxGrid
3926 m_cornerLabelWin = new wxGridCornerLabelWindow( this,
3927 -1,
3928 wxDefaultPosition,
3929 wxDefaultSize );
3930
3931 m_rowLabelWin = new wxGridRowLabelWindow( this,
3932 -1,
3933 wxDefaultPosition,
3934 wxDefaultSize );
3935
3936 m_colLabelWin = new wxGridColLabelWindow( this,
3937 -1,
3938 wxDefaultPosition,
3939 wxDefaultSize );
3940
3941 m_gridWin = new wxGridWindow( this,
3942 m_rowLabelWin,
3943 m_colLabelWin,
3944 -1,
3945 wxDefaultPosition,
3946 wxDefaultSize );
3947
3948 SetTargetWindow( m_gridWin );
3949
3950 Init();
3951 }
3952
3953
3954 bool wxGrid::CreateGrid( int numRows, int numCols,
3955 wxGrid::wxGridSelectionModes selmode )
3956 {
3957 wxCHECK_MSG( !m_created,
3958 FALSE,
3959 wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3960
3961 m_numRows = numRows;
3962 m_numCols = numCols;
3963
3964 m_table = new wxGridStringTable( m_numRows, m_numCols );
3965 m_table->SetView( this );
3966 m_ownTable = TRUE;
3967 m_selection = new wxGridSelection( this, selmode );
3968
3969 CalcDimensions();
3970
3971 m_created = TRUE;
3972
3973 return m_created;
3974 }
3975
3976 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
3977 {
3978 wxCHECK_RET( m_created,
3979 wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
3980
3981 m_selection->SetSelectionMode( selmode );
3982 }
3983
3984 wxGrid::wxGridSelectionModes wxGrid::GetSelectionMode() const
3985 {
3986 wxCHECK_MSG( m_created, wxGrid::wxGridSelectCells,
3987 wxT("Called wxGrid::GetSelectionMode() before calling CreateGrid()") );
3988
3989 return m_selection->GetSelectionMode();
3990 }
3991
3992 bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
3993 wxGrid::wxGridSelectionModes selmode )
3994 {
3995 if ( m_created )
3996 {
3997 // stop all processing
3998 m_created = FALSE;
3999
4000 if (m_ownTable)
4001 {
4002 wxGridTableBase *t=m_table;
4003 m_table=0;
4004 delete t;
4005 }
4006 delete m_selection;
4007
4008 m_table=0;
4009 m_selection=0;
4010 m_numRows=0;
4011 m_numCols=0;
4012 }
4013 if (table)
4014 {
4015 m_numRows = table->GetNumberRows();
4016 m_numCols = table->GetNumberCols();
4017
4018 m_table = table;
4019 m_table->SetView( this );
4020 if (takeOwnership)
4021 m_ownTable = TRUE;
4022 m_selection = new wxGridSelection( this, selmode );
4023
4024 CalcDimensions();
4025
4026 m_created = TRUE;
4027 }
4028
4029 return m_created;
4030 }
4031
4032
4033 void wxGrid::Init()
4034 {
4035 m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
4036 m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
4037
4038 if ( m_rowLabelWin )
4039 {
4040 m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();
4041 }
4042 else
4043 {
4044 m_labelBackgroundColour = wxColour( _T("WHITE") );
4045 }
4046
4047 m_labelTextColour = wxColour( _T("BLACK") );
4048
4049 // init attr cache
4050 m_attrCache.row = -1;
4051 m_attrCache.col = -1;
4052 m_attrCache.attr = NULL;
4053
4054 // TODO: something better than this ?
4055 //
4056 m_labelFont = this->GetFont();
4057 m_labelFont.SetWeight( wxBOLD );
4058
4059 m_rowLabelHorizAlign = wxALIGN_CENTRE;
4060 m_rowLabelVertAlign = wxALIGN_CENTRE;
4061
4062 m_colLabelHorizAlign = wxALIGN_CENTRE;
4063 m_colLabelVertAlign = wxALIGN_CENTRE;
4064 m_colLabelTextOrientation = wxHORIZONTAL;
4065
4066 m_defaultColWidth = WXGRID_DEFAULT_COL_WIDTH;
4067 m_defaultRowHeight = m_gridWin->GetCharHeight();
4068
4069 m_minAcceptableColWidth = WXGRID_MIN_COL_WIDTH;
4070 m_minAcceptableRowHeight = WXGRID_MIN_ROW_HEIGHT;
4071
4072 #if defined(__WXMOTIF__) || defined(__WXGTK__) // see also text ctrl sizing in ShowCellEditControl()
4073 m_defaultRowHeight += 8;
4074 #else
4075 m_defaultRowHeight += 4;
4076 #endif
4077
4078 m_gridLineColour = wxColour( 192,192,192 );
4079 m_gridLinesEnabled = TRUE;
4080 m_cellHighlightColour = *wxBLACK;
4081 m_cellHighlightPenWidth = 2;
4082 m_cellHighlightROPenWidth = 1;
4083
4084 m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
4085 m_winCapture = (wxWindow *)NULL;
4086 m_canDragRowSize = TRUE;
4087 m_canDragColSize = TRUE;
4088 m_canDragGridSize = TRUE;
4089 m_dragLastPos = -1;
4090 m_dragRowOrCol = -1;
4091 m_isDragging = FALSE;
4092 m_startDragPos = wxDefaultPosition;
4093
4094 m_waitForSlowClick = FALSE;
4095
4096 m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
4097 m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
4098
4099 m_currentCellCoords = wxGridNoCellCoords;
4100
4101 m_selectingTopLeft = wxGridNoCellCoords;
4102 m_selectingBottomRight = wxGridNoCellCoords;
4103 m_selectionBackground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
4104 m_selectionForeground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
4105
4106 m_editable = TRUE; // default for whole grid
4107
4108 m_inOnKeyDown = FALSE;
4109 m_batchCount = 0;
4110
4111 m_extraWidth =
4112 m_extraHeight = 0;
4113 }
4114
4115 // ----------------------------------------------------------------------------
4116 // the idea is to call these functions only when necessary because they create
4117 // quite big arrays which eat memory mostly unnecessary - in particular, if
4118 // default widths/heights are used for all rows/columns, we may not use these
4119 // arrays at all
4120 //
4121 // with some extra code, it should be possible to only store the
4122 // widths/heights different from default ones but this will be done later...
4123 // ----------------------------------------------------------------------------
4124
4125 void wxGrid::InitRowHeights()
4126 {
4127 m_rowHeights.Empty();
4128 m_rowBottoms.Empty();
4129
4130 m_rowHeights.Alloc( m_numRows );
4131 m_rowBottoms.Alloc( m_numRows );
4132
4133 int rowBottom = 0;
4134
4135 m_rowHeights.Add( m_defaultRowHeight, m_numRows );
4136
4137 for ( int i = 0; i < m_numRows; i++ )
4138 {
4139 rowBottom += m_defaultRowHeight;
4140 m_rowBottoms.Add( rowBottom );
4141 }
4142 }
4143
4144 void wxGrid::InitColWidths()
4145 {
4146 m_colWidths.Empty();
4147 m_colRights.Empty();
4148
4149 m_colWidths.Alloc( m_numCols );
4150 m_colRights.Alloc( m_numCols );
4151 int colRight = 0;
4152
4153 m_colWidths.Add( m_defaultColWidth, m_numCols );
4154
4155 for ( int i = 0; i < m_numCols; i++ )
4156 {
4157 colRight += m_defaultColWidth;
4158 m_colRights.Add( colRight );
4159 }
4160 }
4161
4162 int wxGrid::GetColWidth(int col) const
4163 {
4164 return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
4165 }
4166
4167 int wxGrid::GetColLeft(int col) const
4168 {
4169 return m_colRights.IsEmpty() ? col * m_defaultColWidth
4170 : m_colRights[col] - m_colWidths[col];
4171 }
4172
4173 int wxGrid::GetColRight(int col) const
4174 {
4175 return m_colRights.IsEmpty() ? (col + 1) * m_defaultColWidth
4176 : m_colRights[col];
4177 }
4178
4179 int wxGrid::GetRowHeight(int row) const
4180 {
4181 return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
4182 }
4183
4184 int wxGrid::GetRowTop(int row) const
4185 {
4186 return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
4187 : m_rowBottoms[row] - m_rowHeights[row];
4188 }
4189
4190 int wxGrid::GetRowBottom(int row) const
4191 {
4192 return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
4193 : m_rowBottoms[row];
4194 }
4195
4196 void wxGrid::CalcDimensions()
4197 {
4198 int cw, ch;
4199 GetClientSize( &cw, &ch );
4200
4201 if ( m_rowLabelWin->IsShown() )
4202 cw -= m_rowLabelWidth;
4203 if ( m_colLabelWin->IsShown() )
4204 ch -= m_colLabelHeight;
4205
4206 // grid total size
4207 int w = m_numCols > 0 ? GetColRight(m_numCols - 1) + m_extraWidth + 1 : 0;
4208 int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) + m_extraHeight + 1 : 0;
4209
4210 // take into account editor if shown
4211 if( IsCellEditControlShown() )
4212 {
4213 int w2, h2;
4214 int r = m_currentCellCoords.GetRow();
4215 int c = m_currentCellCoords.GetCol();
4216 int x = GetColLeft(c);
4217 int y = GetRowTop(r);
4218
4219 // how big is the editor
4220 wxGridCellAttr* attr = GetCellAttr(r, c);
4221 wxGridCellEditor* editor = attr->GetEditor(this, r, c);
4222 editor->GetControl()->GetSize(&w2, &h2);
4223 w2 += x;
4224 h2 += y;
4225 if( w2 > w ) w = w2;
4226 if( h2 > h ) h = h2;
4227 editor->DecRef();
4228 attr->DecRef();
4229 }
4230
4231 // preserve (more or less) the previous position
4232 int x, y;
4233 GetViewStart( &x, &y );
4234
4235 // maybe we don't need scrollbars at all?
4236 //
4237 // also adjust the position to be valid for the new scroll rangs
4238 if ( w <= cw )
4239 {
4240 w = x = 0;
4241 }
4242 else
4243 {
4244 if ( x >= w )
4245 x = w - 1;
4246 }
4247
4248 if ( h <= ch )
4249 {
4250 h = y = 0;
4251 }
4252 else
4253 {
4254 if ( y >= h )
4255 y = h - 1;
4256 }
4257
4258 // do set scrollbar parameters
4259 SetScrollbars( GRID_SCROLL_LINE_X, GRID_SCROLL_LINE_Y,
4260 GetScrollX(w), GetScrollY(h), x, y,
4261 GetBatchCount() != 0);
4262
4263 // if our OnSize() hadn't been called (it would if we have scrollbars), we
4264 // still must reposition the children
4265 CalcWindowSizes();
4266 }
4267
4268
4269 void wxGrid::CalcWindowSizes()
4270 {
4271 // escape if the window is has not been fully created yet
4272
4273 if ( m_cornerLabelWin == NULL )
4274 return ;
4275
4276 int cw, ch;
4277 GetClientSize( &cw, &ch );
4278
4279 if ( m_cornerLabelWin->IsShown() )
4280 m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
4281
4282 if ( m_colLabelWin->IsShown() )
4283 m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw-m_rowLabelWidth, m_colLabelHeight);
4284
4285 if ( m_rowLabelWin->IsShown() )
4286 m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch-m_colLabelHeight);
4287
4288 if ( m_gridWin->IsShown() )
4289 m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw-m_rowLabelWidth, ch-m_colLabelHeight);
4290 }
4291
4292
4293 // this is called when the grid table sends a message to say that it
4294 // has been redimensioned
4295 //
4296 bool wxGrid::Redimension( wxGridTableMessage& msg )
4297 {
4298 int i;
4299 bool result = FALSE;
4300
4301 // Clear the attribute cache as the attribute might refer to a different
4302 // cell than stored in the cache after adding/removing rows/columns.
4303 ClearAttrCache();
4304 // By the same reasoning, the editor should be dismissed if columns are
4305 // added or removed. And for consistency, it should IMHO always be
4306 // removed, not only if the cell "underneath" it actually changes.
4307 // For now, I intentionally do not save the editor's content as the
4308 // cell it might want to save that stuff to might no longer exist.
4309 HideCellEditControl();
4310 #if 0
4311 // if we were using the default widths/heights so far, we must change them
4312 // now
4313 if ( m_colWidths.IsEmpty() )
4314 {
4315 InitColWidths();
4316 }
4317
4318 if ( m_rowHeights.IsEmpty() )
4319 {
4320 InitRowHeights();
4321 }
4322 #endif
4323
4324 switch ( msg.GetId() )
4325 {
4326 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
4327 {
4328 size_t pos = msg.GetCommandInt();
4329 int numRows = msg.GetCommandInt2();
4330
4331 m_numRows += numRows;
4332
4333 if ( !m_rowHeights.IsEmpty() )
4334 {
4335 m_rowHeights.Insert( m_defaultRowHeight, pos, numRows );
4336 m_rowBottoms.Insert( 0, pos, numRows );
4337
4338 int bottom = 0;
4339 if ( pos > 0 ) bottom = m_rowBottoms[pos-1];
4340
4341 for ( i = pos; i < m_numRows; i++ )
4342 {
4343 bottom += m_rowHeights[i];
4344 m_rowBottoms[i] = bottom;
4345 }
4346 }
4347 if ( m_currentCellCoords == wxGridNoCellCoords )
4348 {
4349 // if we have just inserted cols into an empty grid the current
4350 // cell will be undefined...
4351 //
4352 SetCurrentCell( 0, 0 );
4353 }
4354
4355 if ( m_selection )
4356 m_selection->UpdateRows( pos, numRows );
4357 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4358 if (attrProvider)
4359 attrProvider->UpdateAttrRows( pos, numRows );
4360
4361 if ( !GetBatchCount() )
4362 {
4363 CalcDimensions();
4364 m_rowLabelWin->Refresh();
4365 }
4366 }
4367 result = TRUE;
4368 break;
4369
4370 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4371 {
4372 int numRows = msg.GetCommandInt();
4373 int oldNumRows = m_numRows;
4374 m_numRows += numRows;
4375
4376 if ( !m_rowHeights.IsEmpty() )
4377 {
4378 m_rowHeights.Add( m_defaultRowHeight, numRows );
4379 m_rowBottoms.Add( 0, numRows );
4380
4381 int bottom = 0;
4382 if ( oldNumRows > 0 ) bottom = m_rowBottoms[oldNumRows-1];
4383
4384 for ( i = oldNumRows; i < m_numRows; i++ )
4385 {
4386 bottom += m_rowHeights[i];
4387 m_rowBottoms[i] = bottom;
4388 }
4389 }
4390 if ( m_currentCellCoords == wxGridNoCellCoords )
4391 {
4392 // if we have just inserted cols into an empty grid the current
4393 // cell will be undefined...
4394 //
4395 SetCurrentCell( 0, 0 );
4396 }
4397 if ( !GetBatchCount() )
4398 {
4399 CalcDimensions();
4400 m_rowLabelWin->Refresh();
4401 }
4402 }
4403 result = TRUE;
4404 break;
4405
4406 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4407 {
4408 size_t pos = msg.GetCommandInt();
4409 int numRows = msg.GetCommandInt2();
4410 m_numRows -= numRows;
4411
4412 if ( !m_rowHeights.IsEmpty() )
4413 {
4414 m_rowHeights.RemoveAt( pos, numRows );
4415 m_rowBottoms.RemoveAt( pos, numRows );
4416
4417 int h = 0;
4418 for ( i = 0; i < m_numRows; i++ )
4419 {
4420 h += m_rowHeights[i];
4421 m_rowBottoms[i] = h;
4422 }
4423 }
4424 if ( !m_numRows )
4425 {
4426 m_currentCellCoords = wxGridNoCellCoords;
4427 }
4428 else
4429 {
4430 if ( m_currentCellCoords.GetRow() >= m_numRows )
4431 m_currentCellCoords.Set( 0, 0 );
4432 }
4433
4434 if ( m_selection )
4435 m_selection->UpdateRows( pos, -((int)numRows) );
4436 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4437 if (attrProvider) {
4438 attrProvider->UpdateAttrRows( pos, -((int)numRows) );
4439 // ifdef'd out following patch from Paul Gammans
4440 #if 0
4441 // No need to touch column attributes, unless we
4442 // removed _all_ rows, in this case, we remove
4443 // all column attributes.
4444 // I hate to do this here, but the
4445 // needed data is not available inside UpdateAttrRows.
4446 if ( !GetNumberRows() )
4447 attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
4448 #endif
4449 }
4450 if ( !GetBatchCount() )
4451 {
4452 CalcDimensions();
4453 m_rowLabelWin->Refresh();
4454 }
4455 }
4456 result = TRUE;
4457 break;
4458
4459 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4460 {
4461 size_t pos = msg.GetCommandInt();
4462 int numCols = msg.GetCommandInt2();
4463 m_numCols += numCols;
4464
4465 if ( !m_colWidths.IsEmpty() )
4466 {
4467 m_colWidths.Insert( m_defaultColWidth, pos, numCols );
4468 m_colRights.Insert( 0, pos, numCols );
4469
4470 int right = 0;
4471 if ( pos > 0 ) right = m_colRights[pos-1];
4472
4473 for ( i = pos; i < m_numCols; i++ )
4474 {
4475 right += m_colWidths[i];
4476 m_colRights[i] = right;
4477 }
4478 }
4479 if ( m_currentCellCoords == wxGridNoCellCoords )
4480 {
4481 // if we have just inserted cols into an empty grid the current
4482 // cell will be undefined...
4483 //
4484 SetCurrentCell( 0, 0 );
4485 }
4486
4487 if ( m_selection )
4488 m_selection->UpdateCols( pos, numCols );
4489 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4490 if (attrProvider)
4491 attrProvider->UpdateAttrCols( pos, numCols );
4492 if ( !GetBatchCount() )
4493 {
4494 CalcDimensions();
4495 m_colLabelWin->Refresh();
4496 }
4497
4498 }
4499 result = TRUE;
4500 break;
4501
4502 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4503 {
4504 int numCols = msg.GetCommandInt();
4505 int oldNumCols = m_numCols;
4506 m_numCols += numCols;
4507 if ( !m_colWidths.IsEmpty() )
4508 {
4509 m_colWidths.Add( m_defaultColWidth, numCols );
4510 m_colRights.Add( 0, numCols );
4511
4512 int right = 0;
4513 if ( oldNumCols > 0 ) right = m_colRights[oldNumCols-1];
4514
4515 for ( i = oldNumCols; i < m_numCols; i++ )
4516 {
4517 right += m_colWidths[i];
4518 m_colRights[i] = right;
4519 }
4520 }
4521 if ( m_currentCellCoords == wxGridNoCellCoords )
4522 {
4523 // if we have just inserted cols into an empty grid the current
4524 // cell will be undefined...
4525 //
4526 SetCurrentCell( 0, 0 );
4527 }
4528 if ( !GetBatchCount() )
4529 {
4530 CalcDimensions();
4531 m_colLabelWin->Refresh();
4532 }
4533 }
4534 result = TRUE;
4535 break;
4536
4537 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
4538 {
4539 size_t pos = msg.GetCommandInt();
4540 int numCols = msg.GetCommandInt2();
4541 m_numCols -= numCols;
4542
4543 if ( !m_colWidths.IsEmpty() )
4544 {
4545 m_colWidths.RemoveAt( pos, numCols );
4546 m_colRights.RemoveAt( pos, numCols );
4547
4548 int w = 0;
4549 for ( i = 0; i < m_numCols; i++ )
4550 {
4551 w += m_colWidths[i];
4552 m_colRights[i] = w;
4553 }
4554 }
4555 if ( !m_numCols )
4556 {
4557 m_currentCellCoords = wxGridNoCellCoords;
4558 }
4559 else
4560 {
4561 if ( m_currentCellCoords.GetCol() >= m_numCols )
4562 m_currentCellCoords.Set( 0, 0 );
4563 }
4564
4565 if ( m_selection )
4566 m_selection->UpdateCols( pos, -((int)numCols) );
4567 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4568 if (attrProvider) {
4569 attrProvider->UpdateAttrCols( pos, -((int)numCols) );
4570 // ifdef'd out following patch from Paul Gammans
4571 #if 0
4572 // No need to touch row attributes, unless we
4573 // removed _all_ columns, in this case, we remove
4574 // all row attributes.
4575 // I hate to do this here, but the
4576 // needed data is not available inside UpdateAttrCols.
4577 if ( !GetNumberCols() )
4578 attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
4579 #endif
4580 }
4581 if ( !GetBatchCount() )
4582 {
4583 CalcDimensions();
4584 m_colLabelWin->Refresh();
4585 }
4586 }
4587 result = TRUE;
4588 break;
4589 }
4590
4591 if (result && !GetBatchCount() )
4592 m_gridWin->Refresh();
4593 return result;
4594 }
4595
4596
4597 wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
4598 {
4599 wxRegionIterator iter( reg );
4600 wxRect r;
4601
4602 wxArrayInt rowlabels;
4603
4604 int top, bottom;
4605 while ( iter )
4606 {
4607 r = iter.GetRect();
4608
4609 // TODO: remove this when we can...
4610 // There is a bug in wxMotif that gives garbage update
4611 // rectangles if you jump-scroll a long way by clicking the
4612 // scrollbar with middle button. This is a work-around
4613 //
4614 #if defined(__WXMOTIF__)
4615 int cw, ch;
4616 m_gridWin->GetClientSize( &cw, &ch );
4617 if ( r.GetTop() > ch ) r.SetTop( 0 );
4618 r.SetBottom( wxMin( r.GetBottom(), ch ) );
4619 #endif
4620
4621 // logical bounds of update region
4622 //
4623 int dummy;
4624 CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
4625 CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
4626
4627 // find the row labels within these bounds
4628 //
4629 int row;
4630 for ( row = internalYToRow(top); row < m_numRows; row++ )
4631 {
4632 if ( GetRowBottom(row) < top )
4633 continue;
4634
4635 if ( GetRowTop(row) > bottom )
4636 break;
4637
4638 rowlabels.Add( row );
4639 }
4640
4641 iter++ ;
4642 }
4643
4644 return rowlabels;
4645 }
4646
4647
4648 wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg )
4649 {
4650 wxRegionIterator iter( reg );
4651 wxRect r;
4652
4653 wxArrayInt colLabels;
4654
4655 int left, right;
4656 while ( iter )
4657 {
4658 r = iter.GetRect();
4659
4660 // TODO: remove this when we can...
4661 // There is a bug in wxMotif that gives garbage update
4662 // rectangles if you jump-scroll a long way by clicking the
4663 // scrollbar with middle button. This is a work-around
4664 //
4665 #if defined(__WXMOTIF__)
4666 int cw, ch;
4667 m_gridWin->GetClientSize( &cw, &ch );
4668 if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4669 r.SetRight( wxMin( r.GetRight(), cw ) );
4670 #endif
4671
4672 // logical bounds of update region
4673 //
4674 int dummy;
4675 CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
4676 CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
4677
4678 // find the cells within these bounds
4679 //
4680 int col;
4681 for ( col = internalXToCol(left); col < m_numCols; col++ )
4682 {
4683 if ( GetColRight(col) < left )
4684 continue;
4685
4686 if ( GetColLeft(col) > right )
4687 break;
4688
4689 colLabels.Add( col );
4690 }
4691
4692 iter++ ;
4693 }
4694 return colLabels;
4695 }
4696
4697
4698 wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg )
4699 {
4700 wxRegionIterator iter( reg );
4701 wxRect r;
4702
4703 wxGridCellCoordsArray cellsExposed;
4704
4705 int left, top, right, bottom;
4706 while ( iter )
4707 {
4708 r = iter.GetRect();
4709
4710 // TODO: remove this when we can...
4711 // There is a bug in wxMotif that gives garbage update
4712 // rectangles if you jump-scroll a long way by clicking the
4713 // scrollbar with middle button. This is a work-around
4714 //
4715 #if defined(__WXMOTIF__)
4716 int cw, ch;
4717 m_gridWin->GetClientSize( &cw, &ch );
4718 if ( r.GetTop() > ch ) r.SetTop( 0 );
4719 if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4720 r.SetRight( wxMin( r.GetRight(), cw ) );
4721 r.SetBottom( wxMin( r.GetBottom(), ch ) );
4722 #endif
4723
4724 // logical bounds of update region
4725 //
4726 CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
4727 CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
4728
4729 // find the cells within these bounds
4730 //
4731 int row, col;
4732 for ( row = internalYToRow(top); row < m_numRows; row++ )
4733 {
4734 if ( GetRowBottom(row) <= top )
4735 continue;
4736
4737 if ( GetRowTop(row) > bottom )
4738 break;
4739
4740 for ( col = internalXToCol(left); col < m_numCols; col++ )
4741 {
4742 if ( GetColRight(col) <= left )
4743 continue;
4744
4745 if ( GetColLeft(col) > right )
4746 break;
4747
4748 cellsExposed.Add( wxGridCellCoords( row, col ) );
4749 }
4750 }
4751
4752 iter++;
4753 }
4754
4755 return cellsExposed;
4756 }
4757
4758
4759 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
4760 {
4761 int x, y, row;
4762 wxPoint pos( event.GetPosition() );
4763 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4764
4765 if ( event.Dragging() )
4766 {
4767 if (!m_isDragging)
4768 {
4769 m_isDragging = TRUE;
4770 m_rowLabelWin->CaptureMouse();
4771 }
4772
4773 if ( event.LeftIsDown() )
4774 {
4775 switch( m_cursorMode )
4776 {
4777 case WXGRID_CURSOR_RESIZE_ROW:
4778 {
4779 int cw, ch, left, dummy;
4780 m_gridWin->GetClientSize( &cw, &ch );
4781 CalcUnscrolledPosition( 0, 0, &left, &dummy );
4782
4783 wxClientDC dc( m_gridWin );
4784 PrepareDC( dc );
4785 y = wxMax( y,
4786 GetRowTop(m_dragRowOrCol) +
4787 GetRowMinimalHeight(m_dragRowOrCol) );
4788 dc.SetLogicalFunction(wxINVERT);
4789 if ( m_dragLastPos >= 0 )
4790 {
4791 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4792 }
4793 dc.DrawLine( left, y, left+cw, y );
4794 m_dragLastPos = y;
4795 }
4796 break;
4797
4798 case WXGRID_CURSOR_SELECT_ROW:
4799 if ( (row = YToRow( y )) >= 0 )
4800 {
4801 if ( m_selection )
4802 {
4803 m_selection->SelectRow( row,
4804 event.ControlDown(),
4805 event.ShiftDown(),
4806 event.AltDown(),
4807 event.MetaDown() );
4808 }
4809 }
4810
4811 // default label to suppress warnings about "enumeration value
4812 // 'xxx' not handled in switch
4813 default:
4814 break;
4815 }
4816 }
4817 return;
4818 }
4819
4820 if ( m_isDragging && (event.Entering() || event.Leaving()) )
4821 return;
4822
4823 if (m_isDragging)
4824 {
4825 if (m_rowLabelWin->HasCapture()) m_rowLabelWin->ReleaseMouse();
4826 m_isDragging = FALSE;
4827 }
4828
4829 // ------------ Entering or leaving the window
4830 //
4831 if ( event.Entering() || event.Leaving() )
4832 {
4833 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4834 }
4835
4836
4837 // ------------ Left button pressed
4838 //
4839 else if ( event.LeftDown() )
4840 {
4841 // don't send a label click event for a hit on the
4842 // edge of the row label - this is probably the user
4843 // wanting to resize the row
4844 //
4845 if ( YToEdgeOfRow(y) < 0 )
4846 {
4847 row = YToRow(y);
4848 if ( row >= 0 &&
4849 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
4850 {
4851 if ( !event.ShiftDown() && !event.ControlDown() )
4852 ClearSelection();
4853 if ( m_selection )
4854 {
4855 if ( event.ShiftDown() )
4856 {
4857 m_selection->SelectBlock( m_currentCellCoords.GetRow(),
4858 0,
4859 row,
4860 GetNumberCols() - 1,
4861 event.ControlDown(),
4862 event.ShiftDown(),
4863 event.AltDown(),
4864 event.MetaDown() );
4865 }
4866 else
4867 {
4868 m_selection->SelectRow( row,
4869 event.ControlDown(),
4870 event.ShiftDown(),
4871 event.AltDown(),
4872 event.MetaDown() );
4873 }
4874 }
4875
4876 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
4877 }
4878 }
4879 else
4880 {
4881 // starting to drag-resize a row
4882 //
4883 if ( CanDragRowSize() )
4884 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
4885 }
4886 }
4887
4888
4889 // ------------ Left double click
4890 //
4891 else if (event.LeftDClick() )
4892 {
4893 int row = YToEdgeOfRow(y);
4894 if ( row < 0 )
4895 {
4896 row = YToRow(y);
4897 if ( row >=0 &&
4898 !SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event ) )
4899 {
4900 // no default action at the moment
4901 }
4902 }
4903 else
4904 {
4905 // adjust row height depending on label text
4906 AutoSizeRowLabelSize( row );
4907
4908 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
4909 m_dragLastPos = -1;
4910 }
4911 }
4912
4913
4914 // ------------ Left button released
4915 //
4916 else if ( event.LeftUp() )
4917 {
4918 if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4919 {
4920 DoEndDragResizeRow();
4921
4922 // Note: we are ending the event *after* doing
4923 // default processing in this case
4924 //
4925 SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
4926 }
4927
4928 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4929 m_dragLastPos = -1;
4930 }
4931
4932
4933 // ------------ Right button down
4934 //
4935 else if ( event.RightDown() )
4936 {
4937 row = YToRow(y);
4938 if ( row >=0 &&
4939 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
4940 {
4941 // no default action at the moment
4942 }
4943 }
4944
4945
4946 // ------------ Right double click
4947 //
4948 else if ( event.RightDClick() )
4949 {
4950 row = YToRow(y);
4951 if ( row >= 0 &&
4952 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
4953 {
4954 // no default action at the moment
4955 }
4956 }
4957
4958
4959 // ------------ No buttons down and mouse moving
4960 //
4961 else if ( event.Moving() )
4962 {
4963 m_dragRowOrCol = YToEdgeOfRow( y );
4964 if ( m_dragRowOrCol >= 0 )
4965 {
4966 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4967 {
4968 // don't capture the mouse yet
4969 if ( CanDragRowSize() )
4970 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, FALSE);
4971 }
4972 }
4973 else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4974 {
4975 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, FALSE);
4976 }
4977 }
4978 }
4979
4980
4981 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
4982 {
4983 int x, y, col;
4984 wxPoint pos( event.GetPosition() );
4985 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4986
4987 if ( event.Dragging() )
4988 {
4989 if (!m_isDragging)
4990 {
4991 m_isDragging = TRUE;
4992 m_colLabelWin->CaptureMouse();
4993 }
4994
4995 if ( event.LeftIsDown() )
4996 {
4997 switch( m_cursorMode )
4998 {
4999 case WXGRID_CURSOR_RESIZE_COL:
5000 {
5001 int cw, ch, dummy, top;
5002 m_gridWin->GetClientSize( &cw, &ch );
5003 CalcUnscrolledPosition( 0, 0, &dummy, &top );
5004
5005 wxClientDC dc( m_gridWin );
5006 PrepareDC( dc );
5007
5008 x = wxMax( x, GetColLeft(m_dragRowOrCol) +
5009 GetColMinimalWidth(m_dragRowOrCol));
5010 dc.SetLogicalFunction(wxINVERT);
5011 if ( m_dragLastPos >= 0 )
5012 {
5013 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5014 }
5015 dc.DrawLine( x, top, x, top+ch );
5016 m_dragLastPos = x;
5017 }
5018 break;
5019
5020 case WXGRID_CURSOR_SELECT_COL:
5021 if ( (col = XToCol( x )) >= 0 )
5022 {
5023 if ( m_selection )
5024 {
5025 m_selection->SelectCol( col,
5026 event.ControlDown(),
5027 event.ShiftDown(),
5028 event.AltDown(),
5029 event.MetaDown() );
5030 }
5031 }
5032
5033 // default label to suppress warnings about "enumeration value
5034 // 'xxx' not handled in switch
5035 default:
5036 break;
5037 }
5038 }
5039 return;
5040 }
5041
5042 if ( m_isDragging && (event.Entering() || event.Leaving()) )
5043 return;
5044
5045 if (m_isDragging)
5046 {
5047 if (m_colLabelWin->HasCapture()) m_colLabelWin->ReleaseMouse();
5048 m_isDragging = FALSE;
5049 }
5050
5051 // ------------ Entering or leaving the window
5052 //
5053 if ( event.Entering() || event.Leaving() )
5054 {
5055 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
5056 }
5057
5058
5059 // ------------ Left button pressed
5060 //
5061 else if ( event.LeftDown() )
5062 {
5063 // don't send a label click event for a hit on the
5064 // edge of the col label - this is probably the user
5065 // wanting to resize the col
5066 //
5067 if ( XToEdgeOfCol(x) < 0 )
5068 {
5069 col = XToCol(x);
5070 if ( col >= 0 &&
5071 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
5072 {
5073 if ( !event.ShiftDown() && !event.ControlDown() )
5074 ClearSelection();
5075 if ( m_selection )
5076 {
5077 if ( event.ShiftDown() )
5078 {
5079 m_selection->SelectBlock( 0,
5080 m_currentCellCoords.GetCol(),
5081 GetNumberRows() - 1, col,
5082 event.ControlDown(),
5083 event.ShiftDown(),
5084 event.AltDown(),
5085 event.MetaDown() );
5086 }
5087 else
5088 {
5089 m_selection->SelectCol( col,
5090 event.ControlDown(),
5091 event.ShiftDown(),
5092 event.AltDown(),
5093 event.MetaDown() );
5094 }
5095 }
5096
5097 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
5098 }
5099 }
5100 else
5101 {
5102 // starting to drag-resize a col
5103 //
5104 if ( CanDragColSize() )
5105 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
5106 }
5107 }
5108
5109
5110 // ------------ Left double click
5111 //
5112 if ( event.LeftDClick() )
5113 {
5114 int col = XToEdgeOfCol(x);
5115 if ( col < 0 )
5116 {
5117 col = XToCol(x);
5118 if ( col >= 0 &&
5119 ! SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event ) )
5120 {
5121 // no default action at the moment
5122 }
5123 }
5124 else
5125 {
5126 // adjust column width depending on label text
5127 AutoSizeColLabelSize( col );
5128
5129 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
5130 m_dragLastPos = -1;
5131 }
5132 }
5133
5134
5135 // ------------ Left button released
5136 //
5137 else if ( event.LeftUp() )
5138 {
5139 if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
5140 {
5141 DoEndDragResizeCol();
5142
5143 // Note: we are ending the event *after* doing
5144 // default processing in this case
5145 //
5146 SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
5147 }
5148
5149 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
5150 m_dragLastPos = -1;
5151 }
5152
5153
5154 // ------------ Right button down
5155 //
5156 else if ( event.RightDown() )
5157 {
5158 col = XToCol(x);
5159 if ( col >= 0 &&
5160 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
5161 {
5162 // no default action at the moment
5163 }
5164 }
5165
5166
5167 // ------------ Right double click
5168 //
5169 else if ( event.RightDClick() )
5170 {
5171 col = XToCol(x);
5172 if ( col >= 0 &&
5173 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
5174 {
5175 // no default action at the moment
5176 }
5177 }
5178
5179
5180 // ------------ No buttons down and mouse moving
5181 //
5182 else if ( event.Moving() )
5183 {
5184 m_dragRowOrCol = XToEdgeOfCol( x );
5185 if ( m_dragRowOrCol >= 0 )
5186 {
5187 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5188 {
5189 // don't capture the cursor yet
5190 if ( CanDragColSize() )
5191 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, FALSE);
5192 }
5193 }
5194 else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
5195 {
5196 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, FALSE);
5197 }
5198 }
5199 }
5200
5201
5202 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
5203 {
5204 if ( event.LeftDown() )
5205 {
5206 // indicate corner label by having both row and
5207 // col args == -1
5208 //
5209 if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
5210 {
5211 SelectAll();
5212 }
5213 }
5214
5215 else if ( event.LeftDClick() )
5216 {
5217 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
5218 }
5219
5220 else if ( event.RightDown() )
5221 {
5222 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
5223 {
5224 // no default action at the moment
5225 }
5226 }
5227
5228 else if ( event.RightDClick() )
5229 {
5230 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
5231 {
5232 // no default action at the moment
5233 }
5234 }
5235 }
5236
5237 void wxGrid::ChangeCursorMode(CursorMode mode,
5238 wxWindow *win,
5239 bool captureMouse)
5240 {
5241 #ifdef __WXDEBUG__
5242 static const wxChar *cursorModes[] =
5243 {
5244 _T("SELECT_CELL"),
5245 _T("RESIZE_ROW"),
5246 _T("RESIZE_COL"),
5247 _T("SELECT_ROW"),
5248 _T("SELECT_COL")
5249 };
5250
5251 wxLogTrace(_T("grid"),
5252 _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
5253 win == m_colLabelWin ? _T("colLabelWin")
5254 : win ? _T("rowLabelWin")
5255 : _T("gridWin"),
5256 cursorModes[m_cursorMode], cursorModes[mode]);
5257 #endif // __WXDEBUG__
5258
5259 if ( mode == m_cursorMode &&
5260 win == m_winCapture &&
5261 captureMouse == (m_winCapture != NULL))
5262 return;
5263
5264 if ( !win )
5265 {
5266 // by default use the grid itself
5267 win = m_gridWin;
5268 }
5269
5270 if ( m_winCapture )
5271 {
5272 if (m_winCapture->HasCapture()) m_winCapture->ReleaseMouse();
5273 m_winCapture = (wxWindow *)NULL;
5274 }
5275
5276 m_cursorMode = mode;
5277
5278 switch ( m_cursorMode )
5279 {
5280 case WXGRID_CURSOR_RESIZE_ROW:
5281 win->SetCursor( m_rowResizeCursor );
5282 break;
5283
5284 case WXGRID_CURSOR_RESIZE_COL:
5285 win->SetCursor( m_colResizeCursor );
5286 break;
5287
5288 default:
5289 win->SetCursor( *wxSTANDARD_CURSOR );
5290 }
5291
5292 // we need to capture mouse when resizing
5293 bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
5294 m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
5295
5296 if ( captureMouse && resize )
5297 {
5298 win->CaptureMouse();
5299 m_winCapture = win;
5300 }
5301 }
5302
5303 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
5304 {
5305 int x, y;
5306 wxPoint pos( event.GetPosition() );
5307 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
5308
5309 wxGridCellCoords coords;
5310 XYToCell( x, y, coords );
5311
5312 int cell_rows, cell_cols;
5313 GetCellSize( coords.GetRow(), coords.GetCol(), &cell_rows, &cell_cols );
5314 if ((cell_rows < 0) || (cell_cols < 0))
5315 {
5316 coords.SetRow(coords.GetRow() + cell_rows);
5317 coords.SetCol(coords.GetCol() + cell_cols);
5318 }
5319
5320 if ( event.Dragging() )
5321 {
5322 //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
5323
5324 // Don't start doing anything until the mouse has been drug at
5325 // least 3 pixels in any direction...
5326 if (! m_isDragging)
5327 {
5328 if (m_startDragPos == wxDefaultPosition)
5329 {
5330 m_startDragPos = pos;
5331 return;
5332 }
5333 if (abs(m_startDragPos.x - pos.x) < 4 && abs(m_startDragPos.y - pos.y) < 4)
5334 return;
5335 }
5336
5337 m_isDragging = TRUE;
5338 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5339 {
5340 // Hide the edit control, so it
5341 // won't interfer with drag-shrinking.
5342 if ( IsCellEditControlShown() )
5343 {
5344 HideCellEditControl();
5345 SaveEditControlValue();
5346 }
5347
5348 // Have we captured the mouse yet?
5349 if (! m_winCapture)
5350 {
5351 m_winCapture = m_gridWin;
5352 m_winCapture->CaptureMouse();
5353 }
5354
5355 if ( coords != wxGridNoCellCoords )
5356 {
5357 if ( event.ControlDown() )
5358 {
5359 if ( m_selectingKeyboard == wxGridNoCellCoords)
5360 m_selectingKeyboard = coords;
5361 HighlightBlock ( m_selectingKeyboard, coords );
5362 }
5363 else
5364 {
5365 if ( !IsSelection() )
5366 {
5367 HighlightBlock( coords, coords );
5368 }
5369 else
5370 {
5371 HighlightBlock( m_currentCellCoords, coords );
5372 }
5373 }
5374
5375 if (! IsVisible(coords))
5376 {
5377 MakeCellVisible(coords);
5378 // TODO: need to introduce a delay or something here. The
5379 // scrolling is way to fast, at least on MSW - also on GTK.
5380 }
5381 }
5382 }
5383 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
5384 {
5385 int cw, ch, left, dummy;
5386 m_gridWin->GetClientSize( &cw, &ch );
5387 CalcUnscrolledPosition( 0, 0, &left, &dummy );
5388
5389 wxClientDC dc( m_gridWin );
5390 PrepareDC( dc );
5391 y = wxMax( y, GetRowTop(m_dragRowOrCol) +
5392 GetRowMinimalHeight(m_dragRowOrCol) );
5393 dc.SetLogicalFunction(wxINVERT);
5394 if ( m_dragLastPos >= 0 )
5395 {
5396 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
5397 }
5398 dc.DrawLine( left, y, left+cw, y );
5399 m_dragLastPos = y;
5400 }
5401 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
5402 {
5403 int cw, ch, dummy, top;
5404 m_gridWin->GetClientSize( &cw, &ch );
5405 CalcUnscrolledPosition( 0, 0, &dummy, &top );
5406
5407 wxClientDC dc( m_gridWin );
5408 PrepareDC( dc );
5409 x = wxMax( x, GetColLeft(m_dragRowOrCol) +
5410 GetColMinimalWidth(m_dragRowOrCol) );
5411 dc.SetLogicalFunction(wxINVERT);
5412 if ( m_dragLastPos >= 0 )
5413 {
5414 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5415 }
5416 dc.DrawLine( x, top, x, top+ch );
5417 m_dragLastPos = x;
5418 }
5419
5420 return;
5421 }
5422
5423 m_isDragging = FALSE;
5424 m_startDragPos = wxDefaultPosition;
5425
5426 // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
5427 // immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
5428 // wxGTK
5429 #if 0
5430 if ( event.Entering() || event.Leaving() )
5431 {
5432 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5433 m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
5434 }
5435 else
5436 #endif // 0
5437
5438 // ------------ Left button pressed
5439 //
5440 if ( event.LeftDown() && coords != wxGridNoCellCoords )
5441 {
5442 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,
5443 coords.GetRow(),
5444 coords.GetCol(),
5445 event ) )
5446 {
5447 if ( !event.ControlDown() )
5448 ClearSelection();
5449 if ( event.ShiftDown() )
5450 {
5451 if ( m_selection )
5452 {
5453 m_selection->SelectBlock( m_currentCellCoords.GetRow(),
5454 m_currentCellCoords.GetCol(),
5455 coords.GetRow(),
5456 coords.GetCol(),
5457 event.ControlDown(),
5458 event.ShiftDown(),
5459 event.AltDown(),
5460 event.MetaDown() );
5461 }
5462 }
5463 else if ( XToEdgeOfCol(x) < 0 &&
5464 YToEdgeOfRow(y) < 0 )
5465 {
5466 DisableCellEditControl();
5467 MakeCellVisible( coords );
5468
5469 if ( event.ControlDown() )
5470 {
5471 if ( m_selection )
5472 {
5473 m_selection->ToggleCellSelection( coords.GetRow(),
5474 coords.GetCol(),
5475 event.ControlDown(),
5476 event.ShiftDown(),
5477 event.AltDown(),
5478 event.MetaDown() );
5479 }
5480 m_selectingTopLeft = wxGridNoCellCoords;
5481 m_selectingBottomRight = wxGridNoCellCoords;
5482 m_selectingKeyboard = coords;
5483 }
5484 else
5485 {
5486 m_waitForSlowClick = m_currentCellCoords == coords && coords != wxGridNoCellCoords;
5487 SetCurrentCell( coords );
5488 if ( m_selection )
5489 {
5490 if ( m_selection->GetSelectionMode() !=
5491 wxGrid::wxGridSelectCells )
5492 {
5493 HighlightBlock( coords, coords );
5494 }
5495 }
5496 }
5497 }
5498 }
5499 }
5500
5501
5502 // ------------ Left double click
5503 //
5504 else if ( event.LeftDClick() && coords != wxGridNoCellCoords )
5505 {
5506 DisableCellEditControl();
5507
5508 if ( XToEdgeOfCol(x) < 0 && YToEdgeOfRow(y) < 0 )
5509 {
5510 SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK,
5511 coords.GetRow(),
5512 coords.GetCol(),
5513 event );
5514 }
5515 }
5516
5517
5518 // ------------ Left button released
5519 //
5520 else if ( event.LeftUp() )
5521 {
5522 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5523 {
5524 if (m_winCapture)
5525 {
5526 if (m_winCapture->HasCapture()) m_winCapture->ReleaseMouse();
5527 m_winCapture = NULL;
5528 }
5529
5530 if ( coords == m_currentCellCoords && m_waitForSlowClick && CanEnableCellControl())
5531 {
5532 ClearSelection();
5533 EnableCellEditControl();
5534
5535 wxGridCellAttr* attr = GetCellAttr(coords);
5536 wxGridCellEditor *editor = attr->GetEditor(this, coords.GetRow(), coords.GetCol());
5537 editor->StartingClick();
5538 editor->DecRef();
5539 attr->DecRef();
5540
5541 m_waitForSlowClick = FALSE;
5542 }
5543 else if ( m_selectingTopLeft != wxGridNoCellCoords &&
5544 m_selectingBottomRight != wxGridNoCellCoords )
5545 {
5546 if ( m_selection )
5547 {
5548 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
5549 m_selectingTopLeft.GetCol(),
5550 m_selectingBottomRight.GetRow(),
5551 m_selectingBottomRight.GetCol(),
5552 event.ControlDown(),
5553 event.ShiftDown(),
5554 event.AltDown(),
5555 event.MetaDown() );
5556 }
5557
5558 m_selectingTopLeft = wxGridNoCellCoords;
5559 m_selectingBottomRight = wxGridNoCellCoords;
5560
5561 // Show the edit control, if it has been hidden for
5562 // drag-shrinking.
5563 ShowCellEditControl();
5564 }
5565 }
5566 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
5567 {
5568 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5569 DoEndDragResizeRow();
5570
5571 // Note: we are ending the event *after* doing
5572 // default processing in this case
5573 //
5574 SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
5575 }
5576 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
5577 {
5578 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5579 DoEndDragResizeCol();
5580
5581 // Note: we are ending the event *after* doing
5582 // default processing in this case
5583 //
5584 SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
5585 }
5586
5587 m_dragLastPos = -1;
5588 }
5589
5590
5591 // ------------ Right button down
5592 //
5593 else if ( event.RightDown() && coords != wxGridNoCellCoords )
5594 {
5595 DisableCellEditControl();
5596 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK,
5597 coords.GetRow(),
5598 coords.GetCol(),
5599 event ) )
5600 {
5601 // no default action at the moment
5602 }
5603 }
5604
5605
5606 // ------------ Right double click
5607 //
5608 else if ( event.RightDClick() && coords != wxGridNoCellCoords )
5609 {
5610 DisableCellEditControl();
5611 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK,
5612 coords.GetRow(),
5613 coords.GetCol(),
5614 event ) )
5615 {
5616 // no default action at the moment
5617 }
5618 }
5619
5620 // ------------ Moving and no button action
5621 //
5622 else if ( event.Moving() && !event.IsButton() )
5623 {
5624 if( coords.GetRow() < 0 || coords.GetCol() < 0 )
5625 {
5626 // out of grid cell area
5627 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5628 return;
5629 }
5630
5631 int dragRow = YToEdgeOfRow( y );
5632 int dragCol = XToEdgeOfCol( x );
5633
5634 // Dragging on the corner of a cell to resize in both
5635 // directions is not implemented yet...
5636 //
5637 if ( dragRow >= 0 && dragCol >= 0 )
5638 {
5639 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5640 return;
5641 }
5642
5643 if ( dragRow >= 0 )
5644 {
5645 m_dragRowOrCol = dragRow;
5646
5647 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5648 {
5649 if ( CanDragRowSize() && CanDragGridSize() )
5650 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
5651 }
5652
5653 if ( dragCol >= 0 )
5654 {
5655 m_dragRowOrCol = dragCol;
5656 }
5657
5658 return;
5659 }
5660
5661 if ( dragCol >= 0 )
5662 {
5663 m_dragRowOrCol = dragCol;
5664
5665 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5666 {
5667 if ( CanDragColSize() && CanDragGridSize() )
5668 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
5669 }
5670
5671 return;
5672 }
5673
5674 // Neither on a row or col edge
5675 //
5676 if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
5677 {
5678 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5679 }
5680 }
5681 }
5682
5683
5684 void wxGrid::DoEndDragResizeRow()
5685 {
5686 if ( m_dragLastPos >= 0 )
5687 {
5688 // erase the last line and resize the row
5689 //
5690 int cw, ch, left, dummy;
5691 m_gridWin->GetClientSize( &cw, &ch );
5692 CalcUnscrolledPosition( 0, 0, &left, &dummy );
5693
5694 wxClientDC dc( m_gridWin );
5695 PrepareDC( dc );
5696 dc.SetLogicalFunction( wxINVERT );
5697 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
5698 HideCellEditControl();
5699 SaveEditControlValue();
5700
5701 int rowTop = GetRowTop(m_dragRowOrCol);
5702 SetRowSize( m_dragRowOrCol,
5703 wxMax( m_dragLastPos - rowTop, m_minAcceptableRowHeight ) );
5704
5705 if ( !GetBatchCount() )
5706 {
5707 // Only needed to get the correct rect.y:
5708 wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
5709 rect.x = 0;
5710 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
5711 rect.width = m_rowLabelWidth;
5712 rect.height = ch - rect.y;
5713 m_rowLabelWin->Refresh( TRUE, &rect );
5714 rect.width = cw;
5715 // if there is a multicell block, paint all of it
5716 if (m_table)
5717 {
5718 int i, cell_rows, cell_cols, subtract_rows = 0;
5719 int leftCol = XToCol(left);
5720 int rightCol = internalXToCol(left+cw);
5721 if (leftCol >= 0)
5722 {
5723 for (i=leftCol; i<rightCol; i++)
5724 {
5725 GetCellSize(m_dragRowOrCol, i, &cell_rows, &cell_cols);
5726 if (cell_rows < subtract_rows)
5727 subtract_rows = cell_rows;
5728 }
5729 rect.y = GetRowTop(m_dragRowOrCol + subtract_rows);
5730 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
5731 rect.height = ch - rect.y;
5732 }
5733 }
5734 m_gridWin->Refresh( FALSE, &rect );
5735 }
5736
5737 ShowCellEditControl();
5738 }
5739 }
5740
5741
5742 void wxGrid::DoEndDragResizeCol()
5743 {
5744 if ( m_dragLastPos >= 0 )
5745 {
5746 // erase the last line and resize the col
5747 //
5748 int cw, ch, dummy, top;
5749 m_gridWin->GetClientSize( &cw, &ch );
5750 CalcUnscrolledPosition( 0, 0, &dummy, &top );
5751
5752 wxClientDC dc( m_gridWin );
5753 PrepareDC( dc );
5754 dc.SetLogicalFunction( wxINVERT );
5755 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5756 HideCellEditControl();
5757 SaveEditControlValue();
5758
5759 int colLeft = GetColLeft(m_dragRowOrCol);
5760 SetColSize( m_dragRowOrCol,
5761 wxMax( m_dragLastPos - colLeft,
5762 GetColMinimalWidth(m_dragRowOrCol) ) );
5763
5764 if ( !GetBatchCount() )
5765 {
5766 // Only needed to get the correct rect.x:
5767 wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
5768 rect.y = 0;
5769 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
5770 rect.width = cw - rect.x;
5771 rect.height = m_colLabelHeight;
5772 m_colLabelWin->Refresh( TRUE, &rect );
5773 rect.height = ch;
5774 // if there is a multicell block, paint all of it
5775 if (m_table)
5776 {
5777 int i, cell_rows, cell_cols, subtract_cols = 0;
5778 int topRow = YToRow(top);
5779 int bottomRow = internalYToRow(top+cw);
5780 if (topRow >= 0)
5781 {
5782 for (i=topRow; i<bottomRow; i++)
5783 {
5784 GetCellSize(i, m_dragRowOrCol, &cell_rows, &cell_cols);
5785 if (cell_cols < subtract_cols)
5786 subtract_cols = cell_cols;
5787 }
5788 rect.x = GetColLeft(m_dragRowOrCol + subtract_cols);
5789 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
5790 rect.width = cw - rect.x;
5791 }
5792 }
5793 m_gridWin->Refresh( FALSE, &rect );
5794 }
5795
5796 ShowCellEditControl();
5797 }
5798 }
5799
5800
5801
5802 //
5803 // ------ interaction with data model
5804 //
5805 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
5806 {
5807 switch ( msg.GetId() )
5808 {
5809 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
5810 return GetModelValues();
5811
5812 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
5813 return SetModelValues();
5814
5815 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
5816 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
5817 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
5818 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
5819 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
5820 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
5821 return Redimension( msg );
5822
5823 default:
5824 return FALSE;
5825 }
5826 }
5827
5828
5829
5830 // The behaviour of this function depends on the grid table class
5831 // Clear() function. For the default wxGridStringTable class the
5832 // behavious is to replace all cell contents with wxEmptyString but
5833 // not to change the number of rows or cols.
5834 //
5835 void wxGrid::ClearGrid()
5836 {
5837 if ( m_table )
5838 {
5839 if (IsCellEditControlEnabled())
5840 DisableCellEditControl();
5841
5842 m_table->Clear();
5843 if ( !GetBatchCount() ) m_gridWin->Refresh();
5844 }
5845 }
5846
5847
5848 bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5849 {
5850 // TODO: something with updateLabels flag
5851
5852 if ( !m_created )
5853 {
5854 wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
5855 return FALSE;
5856 }
5857
5858 if ( m_table )
5859 {
5860 if (IsCellEditControlEnabled())
5861 DisableCellEditControl();
5862
5863 bool done = m_table->InsertRows( pos, numRows );
5864 return done;
5865
5866 // the table will have sent the results of the insert row
5867 // operation to this view object as a grid table message
5868 }
5869 return FALSE;
5870 }
5871
5872
5873 bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
5874 {
5875 // TODO: something with updateLabels flag
5876
5877 if ( !m_created )
5878 {
5879 wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
5880 return FALSE;
5881 }
5882
5883 if ( m_table )
5884 {
5885 bool done = m_table && m_table->AppendRows( numRows );
5886 return done;
5887 // the table will have sent the results of the append row
5888 // operation to this view object as a grid table message
5889 }
5890 return FALSE;
5891 }
5892
5893
5894 bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5895 {
5896 // TODO: something with updateLabels flag
5897
5898 if ( !m_created )
5899 {
5900 wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
5901 return FALSE;
5902 }
5903
5904 if ( m_table )
5905 {
5906 if (IsCellEditControlEnabled())
5907 DisableCellEditControl();
5908
5909 bool done = m_table->DeleteRows( pos, numRows );
5910 return done;
5911 // the table will have sent the results of the delete row
5912 // operation to this view object as a grid table message
5913 }
5914 return FALSE;
5915 }
5916
5917
5918 bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5919 {
5920 // TODO: something with updateLabels flag
5921
5922 if ( !m_created )
5923 {
5924 wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
5925 return FALSE;
5926 }
5927
5928 if ( m_table )
5929 {
5930 if (IsCellEditControlEnabled())
5931 DisableCellEditControl();
5932
5933 bool done = m_table->InsertCols( pos, numCols );
5934 return done;
5935 // the table will have sent the results of the insert col
5936 // operation to this view object as a grid table message
5937 }
5938 return FALSE;
5939 }
5940
5941
5942 bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
5943 {
5944 // TODO: something with updateLabels flag
5945
5946 if ( !m_created )
5947 {
5948 wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
5949 return FALSE;
5950 }
5951
5952 if ( m_table )
5953 {
5954 bool done = m_table->AppendCols( numCols );
5955 return done;
5956 // the table will have sent the results of the append col
5957 // operation to this view object as a grid table message
5958 }
5959 return FALSE;
5960 }
5961
5962
5963 bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5964 {
5965 // TODO: something with updateLabels flag
5966
5967 if ( !m_created )
5968 {
5969 wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
5970 return FALSE;
5971 }
5972
5973 if ( m_table )
5974 {
5975 if (IsCellEditControlEnabled())
5976 DisableCellEditControl();
5977
5978 bool done = m_table->DeleteCols( pos, numCols );
5979 return done;
5980 // the table will have sent the results of the delete col
5981 // operation to this view object as a grid table message
5982 }
5983 return FALSE;
5984 }
5985
5986
5987
5988 //
5989 // ----- event handlers
5990 //
5991
5992 // Generate a grid event based on a mouse event and
5993 // return the result of ProcessEvent()
5994 //
5995 int wxGrid::SendEvent( const wxEventType type,
5996 int row, int col,
5997 wxMouseEvent& mouseEv )
5998 {
5999 bool claimed;
6000 bool vetoed= FALSE;
6001
6002 if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
6003 {
6004 int rowOrCol = (row == -1 ? col : row);
6005
6006 wxGridSizeEvent gridEvt( GetId(),
6007 type,
6008 this,
6009 rowOrCol,
6010 mouseEv.GetX() + GetRowLabelSize(),
6011 mouseEv.GetY() + GetColLabelSize(),
6012 mouseEv.ControlDown(),
6013 mouseEv.ShiftDown(),
6014 mouseEv.AltDown(),
6015 mouseEv.MetaDown() );
6016
6017 claimed = GetEventHandler()->ProcessEvent(gridEvt);
6018 vetoed = !gridEvt.IsAllowed();
6019 }
6020 else if ( type == wxEVT_GRID_RANGE_SELECT )
6021 {
6022 // Right now, it should _never_ end up here!
6023 wxGridRangeSelectEvent gridEvt( GetId(),
6024 type,
6025 this,
6026 m_selectingTopLeft,
6027 m_selectingBottomRight,
6028 TRUE,
6029 mouseEv.ControlDown(),
6030 mouseEv.ShiftDown(),
6031 mouseEv.AltDown(),
6032 mouseEv.MetaDown() );
6033
6034 claimed = GetEventHandler()->ProcessEvent(gridEvt);
6035 vetoed = !gridEvt.IsAllowed();
6036 }
6037 else
6038 {
6039 wxGridEvent gridEvt( GetId(),
6040 type,
6041 this,
6042 row, col,
6043 mouseEv.GetX() + GetRowLabelSize(),
6044 mouseEv.GetY() + GetColLabelSize(),
6045 FALSE,
6046 mouseEv.ControlDown(),
6047 mouseEv.ShiftDown(),
6048 mouseEv.AltDown(),
6049 mouseEv.MetaDown() );
6050 claimed = GetEventHandler()->ProcessEvent(gridEvt);
6051 vetoed = !gridEvt.IsAllowed();
6052 }
6053
6054 // A Veto'd event may not be `claimed' so test this first
6055 if (vetoed) return -1;
6056 return claimed ? 1 : 0;
6057 }
6058
6059
6060 // Generate a grid event of specified type and return the result
6061 // of ProcessEvent().
6062 //
6063 int wxGrid::SendEvent( const wxEventType type,
6064 int row, int col )
6065 {
6066 bool claimed;
6067 bool vetoed= FALSE;
6068
6069 if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
6070 {
6071 int rowOrCol = (row == -1 ? col : row);
6072
6073 wxGridSizeEvent gridEvt( GetId(),
6074 type,
6075 this,
6076 rowOrCol );
6077
6078 claimed = GetEventHandler()->ProcessEvent(gridEvt);
6079 vetoed = !gridEvt.IsAllowed();
6080 }
6081 else
6082 {
6083 wxGridEvent gridEvt( GetId(),
6084 type,
6085 this,
6086 row, col );
6087
6088 claimed = GetEventHandler()->ProcessEvent(gridEvt);
6089 vetoed = !gridEvt.IsAllowed();
6090 }
6091
6092 // A Veto'd event may not be `claimed' so test this first
6093 if (vetoed) return -1;
6094 return claimed ? 1 : 0;
6095 }
6096
6097
6098 void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
6099 {
6100 wxPaintDC dc(this); // needed to prevent zillions of paint events on MSW
6101 }
6102
6103 void wxGrid::Refresh(bool eraseb, const wxRect* rect)
6104 {
6105 // Don't do anything if between Begin/EndBatch...
6106 // EndBatch() will do all this on the last nested one anyway.
6107 if (! GetBatchCount())
6108 {
6109 // Refresh to get correct scrolled position:
6110 wxScrolledWindow::Refresh(eraseb,rect);
6111
6112 if (rect)
6113 {
6114 int rect_x, rect_y, rectWidth, rectHeight;
6115 int width_label, width_cell, height_label, height_cell;
6116 int x, y;
6117
6118 //Copy rectangle can get scroll offsets..
6119 rect_x = rect->GetX();
6120 rect_y = rect->GetY();
6121 rectWidth = rect->GetWidth();
6122 rectHeight = rect->GetHeight();
6123
6124 width_label = m_rowLabelWidth - rect_x;
6125 if (width_label > rectWidth) width_label = rectWidth;
6126
6127 height_label = m_colLabelHeight - rect_y;
6128 if (height_label > rectHeight) height_label = rectHeight;
6129
6130 if (rect_x > m_rowLabelWidth)
6131 {
6132 x = rect_x - m_rowLabelWidth;
6133 width_cell = rectWidth;
6134 }
6135 else
6136 {
6137 x = 0;
6138 width_cell = rectWidth - (m_rowLabelWidth - rect_x);
6139 }
6140
6141 if (rect_y > m_colLabelHeight)
6142 {
6143 y = rect_y - m_colLabelHeight;
6144 height_cell = rectHeight;
6145 }
6146 else
6147 {
6148 y = 0;
6149 height_cell = rectHeight - (m_colLabelHeight - rect_y);
6150 }
6151
6152 // Paint corner label part intersecting rect.
6153 if ( width_label > 0 && height_label > 0 )
6154 {
6155 wxRect anotherrect(rect_x, rect_y, width_label, height_label);
6156 m_cornerLabelWin->Refresh(eraseb, &anotherrect);
6157 }
6158
6159 // Paint col labels part intersecting rect.
6160 if ( width_cell > 0 && height_label > 0 )
6161 {
6162 wxRect anotherrect(x, rect_y, width_cell, height_label);
6163 m_colLabelWin->Refresh(eraseb, &anotherrect);
6164 }
6165
6166 // Paint row labels part intersecting rect.
6167 if ( width_label > 0 && height_cell > 0 )
6168 {
6169 wxRect anotherrect(rect_x, y, width_label, height_cell);
6170 m_rowLabelWin->Refresh(eraseb, &anotherrect);
6171 }
6172
6173 // Paint cell area part intersecting rect.
6174 if ( width_cell > 0 && height_cell > 0 )
6175 {
6176 wxRect anotherrect(x, y, width_cell, height_cell);
6177 m_gridWin->Refresh(eraseb, &anotherrect);
6178 }
6179 }
6180 else
6181 {
6182 m_cornerLabelWin->Refresh(eraseb, NULL);
6183 m_colLabelWin->Refresh(eraseb, NULL);
6184 m_rowLabelWin->Refresh(eraseb, NULL);
6185 m_gridWin->Refresh(eraseb, NULL);
6186 }
6187 }
6188 }
6189
6190 void wxGrid::OnSize( wxSizeEvent& event )
6191 {
6192 // position the child windows
6193 CalcWindowSizes();
6194
6195 // don't call CalcDimensions() from here, the base class handles the size
6196 // changes itself
6197 event.Skip();
6198 }
6199
6200
6201 void wxGrid::OnKeyDown( wxKeyEvent& event )
6202 {
6203 if ( m_inOnKeyDown )
6204 {
6205 // shouldn't be here - we are going round in circles...
6206 //
6207 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
6208 }
6209
6210 m_inOnKeyDown = TRUE;
6211
6212 // propagate the event up and see if it gets processed
6213 //
6214 wxWindow *parent = GetParent();
6215 wxKeyEvent keyEvt( event );
6216 keyEvt.SetEventObject( parent );
6217
6218 if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
6219 {
6220
6221 // try local handlers
6222 //
6223 switch ( event.GetKeyCode() )
6224 {
6225 case WXK_UP:
6226 if ( event.ControlDown() )
6227 {
6228 MoveCursorUpBlock( event.ShiftDown() );
6229 }
6230 else
6231 {
6232 MoveCursorUp( event.ShiftDown() );
6233 }
6234 break;
6235
6236 case WXK_DOWN:
6237 if ( event.ControlDown() )
6238 {
6239 MoveCursorDownBlock( event.ShiftDown() );
6240 }
6241 else
6242 {
6243 MoveCursorDown( event.ShiftDown() );
6244 }
6245 break;
6246
6247 case WXK_LEFT:
6248 if ( event.ControlDown() )
6249 {
6250 MoveCursorLeftBlock( event.ShiftDown() );
6251 }
6252 else
6253 {
6254 MoveCursorLeft( event.ShiftDown() );
6255 }
6256 break;
6257
6258 case WXK_RIGHT:
6259 if ( event.ControlDown() )
6260 {
6261 MoveCursorRightBlock( event.ShiftDown() );
6262 }
6263 else
6264 {
6265 MoveCursorRight( event.ShiftDown() );
6266 }
6267 break;
6268
6269 case WXK_RETURN:
6270 case WXK_NUMPAD_ENTER:
6271 if ( event.ControlDown() )
6272 {
6273 event.Skip(); // to let the edit control have the return
6274 }
6275 else
6276 {
6277 if ( GetGridCursorRow() < GetNumberRows()-1 )
6278 {
6279 MoveCursorDown( event.ShiftDown() );
6280 }
6281 else
6282 {
6283 // at the bottom of a column
6284 HideCellEditControl();
6285 SaveEditControlValue();
6286 }
6287 }
6288 break;
6289
6290 case WXK_ESCAPE:
6291 ClearSelection();
6292 break;
6293
6294 case WXK_TAB:
6295 if (event.ShiftDown())
6296 {
6297 if ( GetGridCursorCol() > 0 )
6298 {
6299 MoveCursorLeft( FALSE );
6300 }
6301 else
6302 {
6303 // at left of grid
6304 HideCellEditControl();
6305 SaveEditControlValue();
6306 }
6307 }
6308 else
6309 {
6310 if ( GetGridCursorCol() < GetNumberCols()-1 )
6311 {
6312 MoveCursorRight( FALSE );
6313 }
6314 else
6315 {
6316 // at right of grid
6317 HideCellEditControl();
6318 SaveEditControlValue();
6319 }
6320 }
6321 break;
6322
6323 case WXK_HOME:
6324 if ( event.ControlDown() )
6325 {
6326 MakeCellVisible( 0, 0 );
6327 SetCurrentCell( 0, 0 );
6328 }
6329 else
6330 {
6331 event.Skip();
6332 }
6333 break;
6334
6335 case WXK_END:
6336 if ( event.ControlDown() )
6337 {
6338 MakeCellVisible( m_numRows-1, m_numCols-1 );
6339 SetCurrentCell( m_numRows-1, m_numCols-1 );
6340 }
6341 else
6342 {
6343 event.Skip();
6344 }
6345 break;
6346
6347 case WXK_PRIOR:
6348 MovePageUp();
6349 break;
6350
6351 case WXK_NEXT:
6352 MovePageDown();
6353 break;
6354
6355 case WXK_SPACE:
6356 if ( event.ControlDown() )
6357 {
6358 if ( m_selection )
6359 {
6360 m_selection->ToggleCellSelection( m_currentCellCoords.GetRow(),
6361 m_currentCellCoords.GetCol(),
6362 event.ControlDown(),
6363 event.ShiftDown(),
6364 event.AltDown(),
6365 event.MetaDown() );
6366 }
6367 break;
6368 }
6369 if ( !IsEditable() )
6370 {
6371 MoveCursorRight( FALSE );
6372 break;
6373 }
6374 // Otherwise fall through to default
6375
6376 default:
6377 // is it possible to edit the current cell at all?
6378 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
6379 {
6380 // yes, now check whether the cells editor accepts the key
6381 int row = m_currentCellCoords.GetRow();
6382 int col = m_currentCellCoords.GetCol();
6383 wxGridCellAttr* attr = GetCellAttr(row, col);
6384 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6385
6386 // <F2> is special and will always start editing, for
6387 // other keys - ask the editor itself
6388 if ( (event.GetKeyCode() == WXK_F2 && !event.HasModifiers())
6389 || editor->IsAcceptedKey(event) )
6390 {
6391 // ensure cell is visble
6392 MakeCellVisible(row, col);
6393 EnableCellEditControl();
6394
6395 // a problem can arise if the cell is not completely
6396 // visible (even after calling MakeCellVisible the
6397 // control is not created and calling StartingKey will
6398 // crash the app
6399 if( editor->IsCreated() && m_cellEditCtrlEnabled ) editor->StartingKey(event);
6400 }
6401 else
6402 {
6403 event.Skip();
6404 }
6405
6406 editor->DecRef();
6407 attr->DecRef();
6408 }
6409 else
6410 {
6411 // let others process char events with modifiers or all
6412 // char events for readonly cells
6413 event.Skip();
6414 }
6415 break;
6416 }
6417 }
6418
6419 m_inOnKeyDown = FALSE;
6420 }
6421
6422 void wxGrid::OnKeyUp( wxKeyEvent& event )
6423 {
6424 // try local handlers
6425 //
6426 if ( event.GetKeyCode() == WXK_SHIFT )
6427 {
6428 if ( m_selectingTopLeft != wxGridNoCellCoords &&
6429 m_selectingBottomRight != wxGridNoCellCoords )
6430 {
6431 if ( m_selection )
6432 {
6433 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
6434 m_selectingTopLeft.GetCol(),
6435 m_selectingBottomRight.GetRow(),
6436 m_selectingBottomRight.GetCol(),
6437 event.ControlDown(),
6438 TRUE,
6439 event.AltDown(),
6440 event.MetaDown() );
6441 }
6442 }
6443
6444 m_selectingTopLeft = wxGridNoCellCoords;
6445 m_selectingBottomRight = wxGridNoCellCoords;
6446 m_selectingKeyboard = wxGridNoCellCoords;
6447 }
6448 }
6449
6450 void wxGrid::OnEraseBackground(wxEraseEvent&)
6451 {
6452 }
6453
6454 void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
6455 {
6456 if ( SendEvent( wxEVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
6457 {
6458 // the event has been intercepted - do nothing
6459 return;
6460 }
6461
6462 wxClientDC dc(m_gridWin);
6463 PrepareDC(dc);
6464
6465 if ( m_currentCellCoords != wxGridNoCellCoords )
6466 {
6467 HideCellEditControl();
6468 DisableCellEditControl();
6469
6470 if ( IsVisible( m_currentCellCoords, FALSE ) )
6471 {
6472 wxRect r;
6473 r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
6474 if ( !m_gridLinesEnabled )
6475 {
6476 r.x--;
6477 r.y--;
6478 r.width++;
6479 r.height++;
6480 }
6481
6482 wxGridCellCoordsArray cells = CalcCellsExposed( r );
6483
6484 // Otherwise refresh redraws the highlight!
6485 m_currentCellCoords = coords;
6486
6487 DrawGridCellArea(dc,cells);
6488 DrawAllGridLines( dc, r );
6489 }
6490 }
6491
6492 m_currentCellCoords = coords;
6493
6494 wxGridCellAttr* attr = GetCellAttr(coords);
6495 DrawCellHighlight(dc, attr);
6496 attr->DecRef();
6497 }
6498
6499
6500 void wxGrid::HighlightBlock( int topRow, int leftCol, int bottomRow, int rightCol )
6501 {
6502 int temp;
6503 wxGridCellCoords updateTopLeft, updateBottomRight;
6504
6505 if ( m_selection )
6506 {
6507 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
6508 {
6509 leftCol = 0;
6510 rightCol = GetNumberCols() - 1;
6511 }
6512 else if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
6513 {
6514 topRow = 0;
6515 bottomRow = GetNumberRows() - 1;
6516 }
6517 }
6518
6519 if ( topRow > bottomRow )
6520 {
6521 temp = topRow;
6522 topRow = bottomRow;
6523 bottomRow = temp;
6524 }
6525
6526 if ( leftCol > rightCol )
6527 {
6528 temp = leftCol;
6529 leftCol = rightCol;
6530 rightCol = temp;
6531 }
6532
6533 updateTopLeft = wxGridCellCoords( topRow, leftCol );
6534 updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
6535
6536 // First the case that we selected a completely new area
6537 if ( m_selectingTopLeft == wxGridNoCellCoords ||
6538 m_selectingBottomRight == wxGridNoCellCoords )
6539 {
6540 wxRect rect;
6541 rect = BlockToDeviceRect( wxGridCellCoords ( topRow, leftCol ),
6542 wxGridCellCoords ( bottomRow, rightCol ) );
6543 m_gridWin->Refresh( FALSE, &rect );
6544 }
6545 // Now handle changing an existing selection area.
6546 else if ( m_selectingTopLeft != updateTopLeft ||
6547 m_selectingBottomRight != updateBottomRight )
6548 {
6549 // Compute two optimal update rectangles:
6550 // Either one rectangle is a real subset of the
6551 // other, or they are (almost) disjoint!
6552 wxRect rect[4];
6553 bool need_refresh[4];
6554 need_refresh[0] =
6555 need_refresh[1] =
6556 need_refresh[2] =
6557 need_refresh[3] = FALSE;
6558 int i;
6559
6560 // Store intermediate values
6561 wxCoord oldLeft = m_selectingTopLeft.GetCol();
6562 wxCoord oldTop = m_selectingTopLeft.GetRow();
6563 wxCoord oldRight = m_selectingBottomRight.GetCol();
6564 wxCoord oldBottom = m_selectingBottomRight.GetRow();
6565
6566 // Determine the outer/inner coordinates.
6567 if (oldLeft > leftCol)
6568 {
6569 temp = oldLeft;
6570 oldLeft = leftCol;
6571 leftCol = temp;
6572 }
6573 if (oldTop > topRow )
6574 {
6575 temp = oldTop;
6576 oldTop = topRow;
6577 topRow = temp;
6578 }
6579 if (oldRight < rightCol )
6580 {
6581 temp = oldRight;
6582 oldRight = rightCol;
6583 rightCol = temp;
6584 }
6585 if (oldBottom < bottomRow)
6586 {
6587 temp = oldBottom;
6588 oldBottom = bottomRow;
6589 bottomRow = temp;
6590 }
6591
6592 // Now, either the stuff marked old is the outer
6593 // rectangle or we don't have a situation where one
6594 // is contained in the other.
6595
6596 if ( oldLeft < leftCol )
6597 {
6598 // Refresh the newly selected or deselected
6599 // area to the left of the old or new selection.
6600 need_refresh[0] = TRUE;
6601 rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6602 oldLeft ),
6603 wxGridCellCoords ( oldBottom,
6604 leftCol - 1 ) );
6605 }
6606
6607 if ( oldTop < topRow )
6608 {
6609 // Refresh the newly selected or deselected
6610 // area above the old or new selection.
6611 need_refresh[1] = TRUE;
6612 rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6613 leftCol ),
6614 wxGridCellCoords ( topRow - 1,
6615 rightCol ) );
6616 }
6617
6618 if ( oldRight > rightCol )
6619 {
6620 // Refresh the newly selected or deselected
6621 // area to the right of the old or new selection.
6622 need_refresh[2] = TRUE;
6623 rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6624 rightCol + 1 ),
6625 wxGridCellCoords ( oldBottom,
6626 oldRight ) );
6627 }
6628
6629 if ( oldBottom > bottomRow )
6630 {
6631 // Refresh the newly selected or deselected
6632 // area below the old or new selection.
6633 need_refresh[3] = TRUE;
6634 rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
6635 leftCol ),
6636 wxGridCellCoords ( oldBottom,
6637 rightCol ) );
6638 }
6639
6640 // various Refresh() calls
6641 for (i = 0; i < 4; i++ )
6642 if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
6643 m_gridWin->Refresh( FALSE, &(rect[i]) );
6644 }
6645 // Change Selection
6646 m_selectingTopLeft = updateTopLeft;
6647 m_selectingBottomRight = updateBottomRight;
6648 }
6649
6650 //
6651 // ------ functions to get/send data (see also public functions)
6652 //
6653
6654 bool wxGrid::GetModelValues()
6655 {
6656 // Hide the editor, so it won't hide a changed value.
6657 HideCellEditControl();
6658
6659 if ( m_table )
6660 {
6661 // all we need to do is repaint the grid
6662 //
6663 m_gridWin->Refresh();
6664 return TRUE;
6665 }
6666
6667 return FALSE;
6668 }
6669
6670
6671 bool wxGrid::SetModelValues()
6672 {
6673 int row, col;
6674
6675 // Disable the editor, so it won't hide a changed value.
6676 // Do we also want to save the current value of the editor first?
6677 // I think so ...
6678 DisableCellEditControl();
6679
6680 if ( m_table )
6681 {
6682 for ( row = 0; row < m_numRows; row++ )
6683 {
6684 for ( col = 0; col < m_numCols; col++ )
6685 {
6686 m_table->SetValue( row, col, GetCellValue(row, col) );
6687 }
6688 }
6689
6690 return TRUE;
6691 }
6692
6693 return FALSE;
6694 }
6695
6696
6697
6698 // Note - this function only draws cells that are in the list of
6699 // exposed cells (usually set from the update region by
6700 // CalcExposedCells)
6701 //
6702 void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
6703 {
6704 if ( !m_numRows || !m_numCols ) return;
6705
6706 int i, numCells = cells.GetCount();
6707 int row, col, cell_rows, cell_cols;
6708 wxGridCellCoordsArray redrawCells;
6709
6710 for ( i = numCells-1; i >= 0; i-- )
6711 {
6712 row = cells[i].GetRow();
6713 col = cells[i].GetCol();
6714 GetCellSize( row, col, &cell_rows, &cell_cols );
6715
6716 // If this cell is part of a multicell block, find owner for repaint
6717 if ( cell_rows <= 0 || cell_cols <= 0 )
6718 {
6719 wxGridCellCoords cell(row+cell_rows, col+cell_cols);
6720 bool marked = FALSE;
6721 for ( int j = 0; j < numCells; j++ )
6722 {
6723 if ( cell == cells[j] )
6724 {
6725 marked = TRUE;
6726 break;
6727 }
6728 }
6729 if (!marked)
6730 {
6731 int count = redrawCells.GetCount();
6732 for (int j = 0; j < count; j++)
6733 {
6734 if ( cell == redrawCells[j] )
6735 {
6736 marked = TRUE;
6737 break;
6738 }
6739 }
6740 if (!marked) redrawCells.Add( cell );
6741 }
6742 continue; // don't bother drawing this cell
6743 }
6744
6745 // If this cell is empty, find cell to left that might want to overflow
6746 if (m_table && m_table->IsEmptyCell(row, col))
6747 {
6748 for ( int l = 0; l < cell_rows; l++ )
6749 {
6750 // find a cell in this row to left alreay marked for repaint
6751 int left = col;
6752 for (int k = 0; k < int(redrawCells.GetCount()); k++)
6753 if ((redrawCells[k].GetCol() < left) &&
6754 (redrawCells[k].GetRow() == row))
6755 left=redrawCells[k].GetCol();
6756
6757 if (left == col) left = 0; // oh well
6758
6759 for (int j = col-1; j >= left; j--)
6760 {
6761 if (!m_table->IsEmptyCell(row+l, j))
6762 {
6763 if (GetCellOverflow(row+l, j))
6764 {
6765 wxGridCellCoords cell(row+l, j);
6766 bool marked = FALSE;
6767
6768 for (int k = 0; k < numCells; k++)
6769 {
6770 if ( cell == cells[k] )
6771 {
6772 marked = TRUE;
6773 break;
6774 }
6775 }
6776 if (!marked)
6777 {
6778 int count = redrawCells.GetCount();
6779 for (int k = 0; k < count; k++)
6780 {
6781 if ( cell == redrawCells[k] )
6782 {
6783 marked = TRUE;
6784 break;
6785 }
6786 }
6787 if (!marked) redrawCells.Add( cell );
6788 }
6789 }
6790 break;
6791 }
6792 }
6793 }
6794 }
6795 DrawCell( dc, cells[i] );
6796 }
6797
6798 numCells = redrawCells.GetCount();
6799
6800 for ( i = numCells - 1; i >= 0; i-- )
6801 {
6802 DrawCell( dc, redrawCells[i] );
6803 }
6804 }
6805
6806
6807 void wxGrid::DrawGridSpace( wxDC& dc )
6808 {
6809 int cw, ch;
6810 m_gridWin->GetClientSize( &cw, &ch );
6811
6812 int right, bottom;
6813 CalcUnscrolledPosition( cw, ch, &right, &bottom );
6814
6815 int rightCol = m_numCols > 0 ? GetColRight(m_numCols - 1) : 0;
6816 int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0 ;
6817
6818 if ( right > rightCol || bottom > bottomRow )
6819 {
6820 int left, top;
6821 CalcUnscrolledPosition( 0, 0, &left, &top );
6822
6823 dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
6824 dc.SetPen( *wxTRANSPARENT_PEN );
6825
6826 if ( right > rightCol )
6827 {
6828 dc.DrawRectangle( rightCol, top, right - rightCol, ch);
6829 }
6830
6831 if ( bottom > bottomRow )
6832 {
6833 dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow);
6834 }
6835 }
6836 }
6837
6838
6839 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
6840 {
6841 int row = coords.GetRow();
6842 int col = coords.GetCol();
6843
6844 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6845 return;
6846
6847 // we draw the cell border ourselves
6848 #if !WXGRID_DRAW_LINES
6849 if ( m_gridLinesEnabled )
6850 DrawCellBorder( dc, coords );
6851 #endif
6852
6853 wxGridCellAttr* attr = GetCellAttr(row, col);
6854
6855 bool isCurrent = coords == m_currentCellCoords;
6856
6857 wxRect rect = CellToRect( row, col );
6858
6859 // if the editor is shown, we should use it and not the renderer
6860 // Note: However, only if it is really _shown_, i.e. not hidden!
6861 if ( isCurrent && IsCellEditControlShown() )
6862 {
6863 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6864 editor->PaintBackground(rect, attr);
6865 editor->DecRef();
6866 }
6867 else
6868 {
6869 // but all the rest is drawn by the cell renderer and hence may be
6870 // customized
6871 wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
6872 renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
6873 renderer->DecRef();
6874 }
6875
6876 attr->DecRef();
6877 }
6878
6879 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
6880 {
6881 int row = m_currentCellCoords.GetRow();
6882 int col = m_currentCellCoords.GetCol();
6883
6884 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6885 return;
6886
6887 wxRect rect = CellToRect(row, col);
6888
6889 // hmmm... what could we do here to show that the cell is disabled?
6890 // for now, I just draw a thinner border than for the other ones, but
6891 // it doesn't look really good
6892
6893 int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
6894
6895 if (penWidth > 0)
6896 {
6897 // The center of th drawn line is where the position/width/height of
6898 // the rectangle is actually at, (on wxMSW atr least,) so we will
6899 // reduce the size of the rectangle to compensate for the thickness of
6900 // the line. If this is too strange on non wxMSW platforms then
6901 // please #ifdef this appropriately.
6902 rect.x += penWidth/2;
6903 rect.y += penWidth/2;
6904 rect.width -= penWidth-1;
6905 rect.height -= penWidth-1;
6906
6907
6908 // Now draw the rectangle
6909 // use the cellHighlightColour if the cell is inside a selection, this
6910 // will ensure the cell is always visible.
6911 dc.SetPen(wxPen(IsInSelection(row,col)?m_selectionForeground:m_cellHighlightColour, penWidth, wxSOLID));
6912 dc.SetBrush(*wxTRANSPARENT_BRUSH);
6913 dc.DrawRectangle(rect);
6914 }
6915
6916 #if 0
6917 // VZ: my experiments with 3d borders...
6918
6919 // how to properly set colours for arbitrary bg?
6920 wxCoord x1 = rect.x,
6921 y1 = rect.y,
6922 x2 = rect.x + rect.width -1,
6923 y2 = rect.y + rect.height -1;
6924
6925 dc.SetPen(*wxWHITE_PEN);
6926 dc.DrawLine(x1, y1, x2, y1);
6927 dc.DrawLine(x1, y1, x1, y2);
6928
6929 dc.DrawLine(x1 + 1, y2 - 1, x2 - 1, y2 - 1);
6930 dc.DrawLine(x2 - 1, y1 + 1, x2 - 1, y2 );
6931
6932 dc.SetPen(*wxBLACK_PEN);
6933 dc.DrawLine(x1, y2, x2, y2);
6934 dc.DrawLine(x2, y1, x2, y2+1);
6935 #endif // 0
6936 }
6937
6938
6939 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
6940 {
6941 int row = coords.GetRow();
6942 int col = coords.GetCol();
6943 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6944 return;
6945
6946 dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
6947
6948 wxRect rect = CellToRect( row, col );
6949
6950 // right hand border
6951 //
6952 dc.DrawLine( rect.x + rect.width, rect.y,
6953 rect.x + rect.width, rect.y + rect.height + 1 );
6954
6955 // bottom border
6956 //
6957 dc.DrawLine( rect.x, rect.y + rect.height,
6958 rect.x + rect.width, rect.y + rect.height);
6959 }
6960
6961 void wxGrid::DrawHighlight(wxDC& dc,const wxGridCellCoordsArray& cells)
6962 {
6963 // This if block was previously in wxGrid::OnPaint but that doesn't
6964 // seem to get called under wxGTK - MB
6965 //
6966 if ( m_currentCellCoords == wxGridNoCellCoords &&
6967 m_numRows && m_numCols )
6968 {
6969 m_currentCellCoords.Set(0, 0);
6970 }
6971
6972 if ( IsCellEditControlShown() )
6973 {
6974 // don't show highlight when the edit control is shown
6975 return;
6976 }
6977
6978 // if the active cell was repainted, repaint its highlight too because it
6979 // might have been damaged by the grid lines
6980 size_t count = cells.GetCount();
6981 for ( size_t n = 0; n < count; n++ )
6982 {
6983 if ( cells[n] == m_currentCellCoords )
6984 {
6985 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
6986 DrawCellHighlight(dc, attr);
6987 attr->DecRef();
6988
6989 break;
6990 }
6991 }
6992 }
6993
6994 // TODO: remove this ???
6995 // This is used to redraw all grid lines e.g. when the grid line colour
6996 // has been changed
6997 //
6998 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
6999 {
7000 #if !WXGRID_DRAW_LINES
7001 return;
7002 #endif
7003
7004 if ( !m_gridLinesEnabled ||
7005 !m_numRows ||
7006 !m_numCols ) return;
7007
7008 int top, bottom, left, right;
7009
7010 #if 0 //#ifndef __WXGTK__
7011 if (reg.IsEmpty())
7012 {
7013 int cw, ch;
7014 m_gridWin->GetClientSize(&cw, &ch);
7015
7016 // virtual coords of visible area
7017 //
7018 CalcUnscrolledPosition( 0, 0, &left, &top );
7019 CalcUnscrolledPosition( cw, ch, &right, &bottom );
7020 }
7021 else
7022 {
7023 wxCoord x, y, w, h;
7024 reg.GetBox(x, y, w, h);
7025 CalcUnscrolledPosition( x, y, &left, &top );
7026 CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
7027 }
7028 #else
7029 int cw, ch;
7030 m_gridWin->GetClientSize(&cw, &ch);
7031 CalcUnscrolledPosition( 0, 0, &left, &top );
7032 CalcUnscrolledPosition( cw, ch, &right, &bottom );
7033 #endif
7034
7035 // avoid drawing grid lines past the last row and col
7036 //
7037 right = wxMin( right, GetColRight(m_numCols - 1) );
7038 bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );
7039
7040 // no gridlines inside multicells, clip them out
7041 int leftCol = internalXToCol(left);
7042 int topRow = internalYToRow(top);
7043 int rightCol = internalXToCol(right);
7044 int bottomRow = internalYToRow(bottom);
7045 wxRegion clippedcells(0, 0, cw, ch);
7046
7047
7048 int i, j, cell_rows, cell_cols;
7049 wxRect rect;
7050
7051 for (j=topRow; j<bottomRow; j++)
7052 {
7053 for (i=leftCol; i<rightCol; i++)
7054 {
7055 GetCellSize( j, i, &cell_rows, &cell_cols );
7056 if ((cell_rows > 1) || (cell_cols > 1))
7057 {
7058 rect = CellToRect(j,i);
7059 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
7060 clippedcells.Subtract(rect);
7061 }
7062 else if ((cell_rows < 0) || (cell_cols < 0))
7063 {
7064 rect = CellToRect(j+cell_rows, i+cell_cols);
7065 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
7066 clippedcells.Subtract(rect);
7067 }
7068 }
7069 }
7070 dc.SetClippingRegion( clippedcells );
7071
7072 dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
7073
7074 // horizontal grid lines
7075 //
7076 // already declared above - int i;
7077 for ( i = internalYToRow(top); i < m_numRows; i++ )
7078 {
7079 int bot = GetRowBottom(i) - 1;
7080
7081 if ( bot > bottom )
7082 {
7083 break;
7084 }
7085
7086 if ( bot >= top )
7087 {
7088 dc.DrawLine( left, bot, right, bot );
7089 }
7090 }
7091
7092
7093 // vertical grid lines
7094 //
7095 for ( i = internalXToCol(left); i < m_numCols; i++ )
7096 {
7097 int colRight = GetColRight(i) - 1;
7098 if ( colRight > right )
7099 {
7100 break;
7101 }
7102
7103 if ( colRight >= left )
7104 {
7105 dc.DrawLine( colRight, top, colRight, bottom );
7106 }
7107 }
7108 dc.DestroyClippingRegion();
7109 }
7110
7111
7112 void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
7113 {
7114 if ( !m_numRows ) return;
7115
7116 size_t i;
7117 size_t numLabels = rows.GetCount();
7118
7119 for ( i = 0; i < numLabels; i++ )
7120 {
7121 DrawRowLabel( dc, rows[i] );
7122 }
7123 }
7124
7125
7126 void wxGrid::DrawRowLabel( wxDC& dc, int row )
7127 {
7128 if ( GetRowHeight(row) <= 0 )
7129 return;
7130
7131 int rowTop = GetRowTop(row),
7132 rowBottom = GetRowBottom(row) - 1;
7133
7134 dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
7135 dc.DrawLine( m_rowLabelWidth-1, rowTop,
7136 m_rowLabelWidth-1, rowBottom );
7137
7138 dc.DrawLine( 0, rowTop, 0, rowBottom );
7139
7140 dc.DrawLine( 0, rowBottom, m_rowLabelWidth, rowBottom );
7141
7142 dc.SetPen( *wxWHITE_PEN );
7143 dc.DrawLine( 1, rowTop, 1, rowBottom );
7144 dc.DrawLine( 1, rowTop, m_rowLabelWidth-1, rowTop );
7145
7146 dc.SetBackgroundMode( wxTRANSPARENT );
7147 dc.SetTextForeground( GetLabelTextColour() );
7148 dc.SetFont( GetLabelFont() );
7149
7150 int hAlign, vAlign;
7151 GetRowLabelAlignment( &hAlign, &vAlign );
7152
7153 wxRect rect;
7154 rect.SetX( 2 );
7155 rect.SetY( GetRowTop(row) + 2 );
7156 rect.SetWidth( m_rowLabelWidth - 4 );
7157 rect.SetHeight( GetRowHeight(row) - 4 );
7158 DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
7159 }
7160
7161
7162 void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
7163 {
7164 if ( !m_numCols ) return;
7165
7166 size_t i;
7167 size_t numLabels = cols.GetCount();
7168
7169 for ( i = 0; i < numLabels; i++ )
7170 {
7171 DrawColLabel( dc, cols[i] );
7172 }
7173 }
7174
7175
7176 void wxGrid::DrawColLabel( wxDC& dc, int col )
7177 {
7178 if ( GetColWidth(col) <= 0 )
7179 return;
7180
7181 int colLeft = GetColLeft(col),
7182 colRight = GetColRight(col) - 1;
7183
7184 dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
7185 dc.DrawLine( colRight, 0,
7186 colRight, m_colLabelHeight-1 );
7187
7188 dc.DrawLine( colLeft, 0, colRight, 0 );
7189
7190 dc.DrawLine( colLeft, m_colLabelHeight-1,
7191 colRight+1, m_colLabelHeight-1 );
7192
7193 dc.SetPen( *wxWHITE_PEN );
7194 dc.DrawLine( colLeft, 1, colLeft, m_colLabelHeight-1 );
7195 dc.DrawLine( colLeft, 1, colRight, 1 );
7196
7197 dc.SetBackgroundMode( wxTRANSPARENT );
7198 dc.SetTextForeground( GetLabelTextColour() );
7199 dc.SetFont( GetLabelFont() );
7200
7201 int hAlign, vAlign, orient;
7202 GetColLabelAlignment( &hAlign, &vAlign );
7203 orient = GetColLabelTextOrientation();
7204
7205 wxRect rect;
7206 rect.SetX( colLeft + 2 );
7207 rect.SetY( 2 );
7208 rect.SetWidth( GetColWidth(col) - 4 );
7209 rect.SetHeight( m_colLabelHeight - 4 );
7210 DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign, orient );
7211 }
7212
7213 void wxGrid::DrawTextRectangle( wxDC& dc,
7214 const wxString& value,
7215 const wxRect& rect,
7216 int horizAlign,
7217 int vertAlign,
7218 int textOrientation )
7219 {
7220 wxArrayString lines;
7221
7222 StringToLines( value, lines );
7223
7224
7225 //Forward to new API.
7226 DrawTextRectangle( dc,
7227 lines,
7228 rect,
7229 horizAlign,
7230 vertAlign,
7231 textOrientation );
7232
7233 }
7234
7235 void wxGrid::DrawTextRectangle( wxDC& dc,
7236 const wxArrayString& lines,
7237 const wxRect& rect,
7238 int horizAlign,
7239 int vertAlign,
7240 int textOrientation )
7241 {
7242 long textWidth, textHeight;
7243 long lineWidth, lineHeight;
7244 int nLines;
7245
7246 dc.SetClippingRegion( rect );
7247
7248 nLines = lines.GetCount();
7249 if( nLines > 0 )
7250 {
7251 int l;
7252 float x = 0.0, y = 0.0;
7253
7254 if( textOrientation == wxHORIZONTAL )
7255 GetTextBoxSize(dc, lines, &textWidth, &textHeight);
7256 else
7257 GetTextBoxSize( dc, lines, &textHeight, &textWidth );
7258
7259 switch( vertAlign )
7260 {
7261 case wxALIGN_BOTTOM:
7262 if( textOrientation == wxHORIZONTAL )
7263 y = rect.y + (rect.height - textHeight - 1);
7264 else
7265 x = rect.x + rect.width - textWidth;
7266 break;
7267
7268 case wxALIGN_CENTRE:
7269 if( textOrientation == wxHORIZONTAL )
7270 y = rect.y + ((rect.height - textHeight)/2);
7271 else
7272 x = rect.x + ((rect.width - textWidth)/2);
7273 break;
7274
7275 case wxALIGN_TOP:
7276 default:
7277 if( textOrientation == wxHORIZONTAL )
7278 y = rect.y + 1;
7279 else
7280 x = rect.x + 1;
7281 break;
7282 }
7283
7284 // Align each line of a multi-line label
7285 for( l = 0; l < nLines; l++ )
7286 {
7287 dc.GetTextExtent(lines[l], &lineWidth, &lineHeight);
7288
7289 switch( horizAlign )
7290 {
7291 case wxALIGN_RIGHT:
7292 if( textOrientation == wxHORIZONTAL )
7293 x = rect.x + (rect.width - lineWidth - 1);
7294 else
7295 y = rect.y + lineWidth + 1;
7296 break;
7297
7298 case wxALIGN_CENTRE:
7299 if( textOrientation == wxHORIZONTAL )
7300 x = rect.x + ((rect.width - lineWidth)/2);
7301 else
7302 y = rect.y + rect.height - ((rect.height - lineWidth)/2);
7303 break;
7304
7305 case wxALIGN_LEFT:
7306 default:
7307 if( textOrientation == wxHORIZONTAL )
7308 x = rect.x + 1;
7309 else
7310 y = rect.y + rect.height - 1;
7311 break;
7312 }
7313
7314 if( textOrientation == wxHORIZONTAL )
7315 {
7316 dc.DrawText( lines[l], (int)x, (int)y );
7317 y += lineHeight;
7318 }
7319 else
7320 {
7321 dc.DrawRotatedText( lines[l], (int)x, (int)y, 90.0 );
7322 x += lineHeight;
7323 }
7324 }
7325 }
7326 dc.DestroyClippingRegion();
7327 }
7328
7329
7330 // Split multi line text up into an array of strings. Any existing
7331 // contents of the string array are preserved.
7332 //
7333 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
7334 {
7335 int startPos = 0;
7336 int pos;
7337 wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
7338 wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
7339
7340 while ( startPos < (int)tVal.Length() )
7341 {
7342 pos = tVal.Mid(startPos).Find( eol );
7343 if ( pos < 0 )
7344 {
7345 break;
7346 }
7347 else if ( pos == 0 )
7348 {
7349 lines.Add( wxEmptyString );
7350 }
7351 else
7352 {
7353 lines.Add( value.Mid(startPos, pos) );
7354 }
7355 startPos += pos+1;
7356 }
7357 if ( startPos < (int)value.Length() )
7358 {
7359 lines.Add( value.Mid( startPos ) );
7360 }
7361 }
7362
7363
7364 void wxGrid::GetTextBoxSize( wxDC& dc,
7365 const wxArrayString& lines,
7366 long *width, long *height )
7367 {
7368 long w = 0;
7369 long h = 0;
7370 long lineW, lineH;
7371
7372 size_t i;
7373 for ( i = 0; i < lines.GetCount(); i++ )
7374 {
7375 dc.GetTextExtent( lines[i], &lineW, &lineH );
7376 w = wxMax( w, lineW );
7377 h += lineH;
7378 }
7379
7380 *width = w;
7381 *height = h;
7382 }
7383
7384 //
7385 // ------ Batch processing.
7386 //
7387 void wxGrid::EndBatch()
7388 {
7389 if ( m_batchCount > 0 )
7390 {
7391 m_batchCount--;
7392 if ( !m_batchCount )
7393 {
7394 CalcDimensions();
7395 m_rowLabelWin->Refresh();
7396 m_colLabelWin->Refresh();
7397 m_cornerLabelWin->Refresh();
7398 m_gridWin->Refresh();
7399 }
7400 }
7401 }
7402
7403 // Use this, rather than wxWindow::Refresh(), to force an immediate
7404 // repainting of the grid. Has no effect if you are already inside a
7405 // BeginBatch / EndBatch block.
7406 //
7407 void wxGrid::ForceRefresh()
7408 {
7409 BeginBatch();
7410 EndBatch();
7411 }
7412
7413
7414 //
7415 // ------ Edit control functions
7416 //
7417
7418
7419 void wxGrid::EnableEditing( bool edit )
7420 {
7421 // TODO: improve this ?
7422 //
7423 if ( edit != m_editable )
7424 {
7425 if(!edit) EnableCellEditControl(edit);
7426 m_editable = edit;
7427 }
7428 }
7429
7430
7431 void wxGrid::EnableCellEditControl( bool enable )
7432 {
7433 if (! m_editable)
7434 return;
7435
7436 if ( m_currentCellCoords == wxGridNoCellCoords )
7437 SetCurrentCell( 0, 0 );
7438
7439 if ( enable != m_cellEditCtrlEnabled )
7440 {
7441 if ( enable )
7442 {
7443 if (SendEvent( wxEVT_GRID_EDITOR_SHOWN) <0)
7444 return;
7445
7446 // this should be checked by the caller!
7447 wxASSERT_MSG( CanEnableCellControl(),
7448 _T("can't enable editing for this cell!") );
7449
7450 // do it before ShowCellEditControl()
7451 m_cellEditCtrlEnabled = enable;
7452
7453 ShowCellEditControl();
7454 }
7455 else
7456 {
7457 //FIXME:add veto support
7458 SendEvent( wxEVT_GRID_EDITOR_HIDDEN);
7459
7460 HideCellEditControl();
7461 SaveEditControlValue();
7462
7463 // do it after HideCellEditControl()
7464 m_cellEditCtrlEnabled = enable;
7465 }
7466 }
7467 }
7468
7469 bool wxGrid::IsCurrentCellReadOnly() const
7470 {
7471 // const_cast
7472 wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
7473 bool readonly = attr->IsReadOnly();
7474 attr->DecRef();
7475
7476 return readonly;
7477 }
7478
7479 bool wxGrid::CanEnableCellControl() const
7480 {
7481 return m_editable && !IsCurrentCellReadOnly();
7482 }
7483
7484 bool wxGrid::IsCellEditControlEnabled() const
7485 {
7486 // the cell edit control might be disable for all cells or just for the
7487 // current one if it's read only
7488 return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : FALSE;
7489 }
7490
7491 bool wxGrid::IsCellEditControlShown() const
7492 {
7493 bool isShown = FALSE;
7494
7495 if ( m_cellEditCtrlEnabled )
7496 {
7497 int row = m_currentCellCoords.GetRow();
7498 int col = m_currentCellCoords.GetCol();
7499 wxGridCellAttr* attr = GetCellAttr(row, col);
7500 wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
7501 attr->DecRef();
7502
7503 if ( editor )
7504 {
7505 if ( editor->IsCreated() )
7506 {
7507 isShown = editor->GetControl()->IsShown();
7508 }
7509
7510 editor->DecRef();
7511 }
7512 }
7513
7514 return isShown;
7515 }
7516
7517 void wxGrid::ShowCellEditControl()
7518 {
7519 if ( IsCellEditControlEnabled() )
7520 {
7521 if ( !IsVisible( m_currentCellCoords ) )
7522 {
7523 m_cellEditCtrlEnabled = FALSE;
7524 return;
7525 }
7526 else
7527 {
7528 wxRect rect = CellToRect( m_currentCellCoords );
7529 int row = m_currentCellCoords.GetRow();
7530 int col = m_currentCellCoords.GetCol();
7531
7532 // if this is part of a multicell, find owner (topleft)
7533 int cell_rows, cell_cols;
7534 GetCellSize( row, col, &cell_rows, &cell_cols );
7535 if ( cell_rows <= 0 || cell_cols <= 0 )
7536 {
7537 row += cell_rows;
7538 col += cell_cols;
7539 m_currentCellCoords.SetRow( row );
7540 m_currentCellCoords.SetCol( col );
7541 }
7542
7543 // convert to scrolled coords
7544 //
7545 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
7546
7547 // done in PaintBackground()
7548 #if 0
7549 // erase the highlight and the cell contents because the editor
7550 // might not cover the entire cell
7551 wxClientDC dc( m_gridWin );
7552 PrepareDC( dc );
7553 dc.SetBrush(*wxLIGHT_GREY_BRUSH); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
7554 dc.SetPen(*wxTRANSPARENT_PEN);
7555 dc.DrawRectangle(rect);
7556 #endif // 0
7557
7558 // cell is shifted by one pixel
7559 // However, don't allow x or y to become negative
7560 // since the SetSize() method interprets that as
7561 // "don't change."
7562 if (rect.x > 0)
7563 rect.x--;
7564 if (rect.y > 0)
7565 rect.y--;
7566
7567 wxGridCellAttr* attr = GetCellAttr(row, col);
7568 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
7569 if ( !editor->IsCreated() )
7570 {
7571 editor->Create(m_gridWin, -1,
7572 new wxGridCellEditorEvtHandler(this, editor));
7573
7574 wxGridEditorCreatedEvent evt(GetId(),
7575 wxEVT_GRID_EDITOR_CREATED,
7576 this,
7577 row,
7578 col,
7579 editor->GetControl());
7580 GetEventHandler()->ProcessEvent(evt);
7581 }
7582
7583
7584 // resize editor to overflow into righthand cells if allowed
7585 int maxWidth = rect.width;
7586 wxString value = GetCellValue(row, col);
7587 if ( (value != wxEmptyString) && (attr->GetOverflow()) )
7588 {
7589 int y;
7590 GetTextExtent(value, &maxWidth, &y,
7591 NULL, NULL, &attr->GetFont());
7592 if (maxWidth < rect.width) maxWidth = rect.width;
7593 }
7594 int client_right = m_gridWin->GetClientSize().GetWidth();
7595 if (rect.x+maxWidth > client_right)
7596 maxWidth = client_right - rect.x;
7597
7598 if ((maxWidth > rect.width) && (col < m_numCols) && m_table)
7599 {
7600 GetCellSize( row, col, &cell_rows, &cell_cols );
7601 // may have changed earlier
7602 for (int i = col+cell_cols; i < m_numCols; i++)
7603 {
7604 int c_rows, c_cols;
7605 GetCellSize( row, i, &c_rows, &c_cols );
7606 // looks weird going over a multicell
7607 if (m_table->IsEmptyCell(row,i) &&
7608 (rect.width < maxWidth) && (c_rows == 1))
7609 rect.width += GetColWidth(i);
7610 else
7611 break;
7612 }
7613 if (rect.GetRight() > client_right)
7614 rect.SetRight(client_right-1);
7615 }
7616
7617 editor->SetCellAttr(attr);
7618 editor->SetSize( rect );
7619 editor->Show( TRUE, attr );
7620
7621 // recalc dimensions in case we need to
7622 // expand the scrolled window to account for editor
7623 CalcDimensions();
7624
7625 editor->BeginEdit(row, col, this);
7626 editor->SetCellAttr(NULL);
7627
7628 editor->DecRef();
7629 attr->DecRef();
7630 }
7631 }
7632 }
7633
7634
7635 void wxGrid::HideCellEditControl()
7636 {
7637 if ( IsCellEditControlEnabled() )
7638 {
7639 int row = m_currentCellCoords.GetRow();
7640 int col = m_currentCellCoords.GetCol();
7641
7642 wxGridCellAttr* attr = GetCellAttr(row, col);
7643 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
7644 editor->Show( FALSE );
7645 editor->DecRef();
7646 attr->DecRef();
7647 m_gridWin->SetFocus();
7648 // refresh whole row to the right
7649 wxRect rect( CellToRect(row, col) );
7650 CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y );
7651 rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
7652 m_gridWin->Refresh( FALSE, &rect );
7653 }
7654 }
7655
7656
7657 void wxGrid::SaveEditControlValue()
7658 {
7659 if ( IsCellEditControlEnabled() )
7660 {
7661 int row = m_currentCellCoords.GetRow();
7662 int col = m_currentCellCoords.GetCol();
7663
7664 wxString oldval = GetCellValue(row,col);
7665
7666 wxGridCellAttr* attr = GetCellAttr(row, col);
7667 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
7668 bool changed = editor->EndEdit(row, col, this);
7669
7670 editor->DecRef();
7671 attr->DecRef();
7672
7673 if (changed)
7674 {
7675 if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
7676 m_currentCellCoords.GetRow(),
7677 m_currentCellCoords.GetCol() ) < 0 ) {
7678
7679 // Event has been vetoed, set the data back.
7680 SetCellValue(row,col,oldval);
7681 }
7682 }
7683 }
7684 }
7685
7686
7687 //
7688 // ------ Grid location functions
7689 // Note that all of these functions work with the logical coordinates of
7690 // grid cells and labels so you will need to convert from device
7691 // coordinates for mouse events etc.
7692 //
7693
7694 void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
7695 {
7696 int row = YToRow(y);
7697 int col = XToCol(x);
7698
7699 if ( row == -1 || col == -1 )
7700 {
7701 coords = wxGridNoCellCoords;
7702 }
7703 else
7704 {
7705 coords.Set( row, col );
7706 }
7707 }
7708
7709
7710 // Internal Helper function for computing row or column from some
7711 // (unscrolled) coordinate value, using either
7712 // m_defaultRowHeight/m_defaultColWidth or binary search on array
7713 // of m_rowBottoms/m_ColRights to speed up the search!
7714
7715 static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
7716 const wxArrayInt& BorderArray, int nMax,
7717 bool clipToMinMax)
7718 {
7719
7720 if (coord < 0)
7721 return clipToMinMax && (nMax > 0) ? 0 : -1;
7722
7723
7724 if (!defaultDist)
7725 defaultDist = 1;
7726
7727 size_t i_max = coord / defaultDist,
7728 i_min = 0;
7729
7730 if (BorderArray.IsEmpty())
7731 {
7732 if((int) i_max < nMax)
7733 return i_max;
7734 return clipToMinMax ? nMax - 1 : -1;
7735 }
7736
7737 if ( i_max >= BorderArray.GetCount())
7738 i_max = BorderArray.GetCount() - 1;
7739 else
7740 {
7741 if ( coord >= BorderArray[i_max])
7742 {
7743 i_min = i_max;
7744 i_max = coord / minDist;
7745 }
7746 if ( i_max >= BorderArray.GetCount())
7747 i_max = BorderArray.GetCount() - 1;
7748 }
7749 if ( coord >= BorderArray[i_max])
7750 return clipToMinMax ? (int)i_max : -1;
7751 if ( coord < BorderArray[0] )
7752 return 0;
7753
7754 while ( i_max - i_min > 0 )
7755 {
7756 wxCHECK_MSG(BorderArray[i_min] <= coord && coord < BorderArray[i_max],
7757 0, _T("wxGrid: internal error in CoordToRowOrCol"));
7758 if (coord >= BorderArray[ i_max - 1])
7759 return i_max;
7760 else
7761 i_max--;
7762 int median = i_min + (i_max - i_min + 1) / 2;
7763 if (coord < BorderArray[median])
7764 i_max = median;
7765 else
7766 i_min = median;
7767 }
7768 return i_max;
7769 }
7770
7771 int wxGrid::YToRow( int y )
7772 {
7773 return CoordToRowOrCol(y, m_defaultRowHeight,
7774 m_minAcceptableRowHeight, m_rowBottoms, m_numRows, FALSE);
7775 }
7776
7777
7778 int wxGrid::XToCol( int x )
7779 {
7780 return CoordToRowOrCol(x, m_defaultColWidth,
7781 m_minAcceptableColWidth, m_colRights, m_numCols, FALSE);
7782 }
7783
7784
7785 // return the row number that that the y coord is near the edge of, or
7786 // -1 if not near an edge
7787 //
7788 int wxGrid::YToEdgeOfRow( int y )
7789 {
7790 int i;
7791 i = internalYToRow(y);
7792
7793 if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE )
7794 {
7795 // We know that we are in row i, test whether we are
7796 // close enough to lower or upper border, respectively.
7797 if ( abs(GetRowBottom(i) - y) < WXGRID_LABEL_EDGE_ZONE )
7798 return i;
7799 else if( i > 0 && y - GetRowTop(i) < WXGRID_LABEL_EDGE_ZONE )
7800 return i - 1;
7801 }
7802
7803 return -1;
7804 }
7805
7806
7807 // return the col number that that the x coord is near the edge of, or
7808 // -1 if not near an edge
7809 //
7810 int wxGrid::XToEdgeOfCol( int x )
7811 {
7812 int i;
7813 i = internalXToCol(x);
7814
7815 if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE )
7816 {
7817 // We know that we are in column i, test whether we are
7818 // close enough to right or left border, respectively.
7819 if ( abs(GetColRight(i) - x) < WXGRID_LABEL_EDGE_ZONE )
7820 return i;
7821 else if( i > 0 && x - GetColLeft(i) < WXGRID_LABEL_EDGE_ZONE )
7822 return i - 1;
7823 }
7824
7825 return -1;
7826 }
7827
7828
7829 wxRect wxGrid::CellToRect( int row, int col )
7830 {
7831 wxRect rect( -1, -1, -1, -1 );
7832
7833 if ( row >= 0 && row < m_numRows &&
7834 col >= 0 && col < m_numCols )
7835 {
7836 int i, cell_rows, cell_cols;
7837 rect.width = rect.height = 0;
7838 GetCellSize( row, col, &cell_rows, &cell_cols );
7839 // if negative then find multicell owner
7840 if (cell_rows < 0) row += cell_rows;
7841 if (cell_cols < 0) col += cell_cols;
7842 GetCellSize( row, col, &cell_rows, &cell_cols );
7843
7844 rect.x = GetColLeft(col);
7845 rect.y = GetRowTop(row);
7846 for (i=col; i<col+cell_cols; i++)
7847 rect.width += GetColWidth(i);
7848 for (i=row; i<row+cell_rows; i++)
7849 rect.height += GetRowHeight(i);
7850 }
7851
7852 // if grid lines are enabled, then the area of the cell is a bit smaller
7853 if (m_gridLinesEnabled) {
7854 rect.width -= 1;
7855 rect.height -= 1;
7856 }
7857 return rect;
7858 }
7859
7860
7861 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
7862 {
7863 // get the cell rectangle in logical coords
7864 //
7865 wxRect r( CellToRect( row, col ) );
7866
7867 // convert to device coords
7868 //
7869 int left, top, right, bottom;
7870 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
7871 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
7872
7873 // check against the client area of the grid window
7874 //
7875 int cw, ch;
7876 m_gridWin->GetClientSize( &cw, &ch );
7877
7878 if ( wholeCellVisible )
7879 {
7880 // is the cell wholly visible ?
7881 //
7882 return ( left >= 0 && right <= cw &&
7883 top >= 0 && bottom <= ch );
7884 }
7885 else
7886 {
7887 // is the cell partly visible ?
7888 //
7889 return ( ((left >=0 && left < cw) || (right > 0 && right <= cw)) &&
7890 ((top >=0 && top < ch) || (bottom > 0 && bottom <= ch)) );
7891 }
7892 }
7893
7894
7895 // make the specified cell location visible by doing a minimal amount
7896 // of scrolling
7897 //
7898 void wxGrid::MakeCellVisible( int row, int col )
7899 {
7900
7901 int i;
7902 int xpos = -1, ypos = -1;
7903
7904 if ( row >= 0 && row < m_numRows &&
7905 col >= 0 && col < m_numCols )
7906 {
7907 // get the cell rectangle in logical coords
7908 //
7909 wxRect r( CellToRect( row, col ) );
7910
7911 // convert to device coords
7912 //
7913 int left, top, right, bottom;
7914 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
7915 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
7916
7917 int cw, ch;
7918 m_gridWin->GetClientSize( &cw, &ch );
7919
7920 if ( top < 0 )
7921 {
7922 ypos = r.GetTop();
7923 }
7924 else if ( bottom > ch )
7925 {
7926 int h = r.GetHeight();
7927 ypos = r.GetTop();
7928 for ( i = row-1; i >= 0; i-- )
7929 {
7930 int rowHeight = GetRowHeight(i);
7931 if ( h + rowHeight > ch )
7932 break;
7933
7934 h += rowHeight;
7935 ypos -= rowHeight;
7936 }
7937
7938 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
7939 // have rounding errors (this is important, because if we do, we
7940 // might not scroll at all and some cells won't be redrawn)
7941 //
7942 // Sometimes GRID_SCROLL_LINE/2 is not enough, so just add a full
7943 // scroll unit...
7944 ypos += GRID_SCROLL_LINE_Y;
7945 }
7946
7947 if ( left < 0 )
7948 {
7949 xpos = r.GetLeft();
7950 }
7951 else if ( right > cw )
7952 {
7953 // position the view so that the cell is on the right
7954 int x0, y0;
7955 CalcUnscrolledPosition(0, 0, &x0, &y0);
7956 xpos = x0 + (right - cw);
7957
7958 // see comment for ypos above
7959 xpos += GRID_SCROLL_LINE_X;
7960 }
7961
7962 if ( xpos != -1 || ypos != -1 )
7963 {
7964 if ( xpos != -1 )
7965 xpos /= GRID_SCROLL_LINE_X;
7966 if ( ypos != -1 )
7967 ypos /= GRID_SCROLL_LINE_Y;
7968 Scroll( xpos, ypos );
7969 AdjustScrollbars();
7970 }
7971 }
7972 }
7973
7974
7975 //
7976 // ------ Grid cursor movement functions
7977 //
7978
7979 bool wxGrid::MoveCursorUp( bool expandSelection )
7980 {
7981 if ( m_currentCellCoords != wxGridNoCellCoords &&
7982 m_currentCellCoords.GetRow() >= 0 )
7983 {
7984 if ( expandSelection)
7985 {
7986 if ( m_selectingKeyboard == wxGridNoCellCoords )
7987 m_selectingKeyboard = m_currentCellCoords;
7988 if ( m_selectingKeyboard.GetRow() > 0 )
7989 {
7990 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() - 1 );
7991 MakeCellVisible( m_selectingKeyboard.GetRow(),
7992 m_selectingKeyboard.GetCol() );
7993 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7994 }
7995 }
7996 else if ( m_currentCellCoords.GetRow() > 0 )
7997 {
7998 ClearSelection();
7999 MakeCellVisible( m_currentCellCoords.GetRow() - 1,
8000 m_currentCellCoords.GetCol() );
8001 SetCurrentCell( m_currentCellCoords.GetRow() - 1,
8002 m_currentCellCoords.GetCol() );
8003 }
8004 else
8005 return FALSE;
8006 return TRUE;
8007 }
8008
8009 return FALSE;
8010 }
8011
8012
8013 bool wxGrid::MoveCursorDown( bool expandSelection )
8014 {
8015 if ( m_currentCellCoords != wxGridNoCellCoords &&
8016 m_currentCellCoords.GetRow() < m_numRows )
8017 {
8018 if ( expandSelection )
8019 {
8020 if ( m_selectingKeyboard == wxGridNoCellCoords )
8021 m_selectingKeyboard = m_currentCellCoords;
8022 if ( m_selectingKeyboard.GetRow() < m_numRows-1 )
8023 {
8024 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() + 1 );
8025 MakeCellVisible( m_selectingKeyboard.GetRow(),
8026 m_selectingKeyboard.GetCol() );
8027 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8028 }
8029 }
8030 else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
8031 {
8032 ClearSelection();
8033 MakeCellVisible( m_currentCellCoords.GetRow() + 1,
8034 m_currentCellCoords.GetCol() );
8035 SetCurrentCell( m_currentCellCoords.GetRow() + 1,
8036 m_currentCellCoords.GetCol() );
8037 }
8038 else
8039 return FALSE;
8040 return TRUE;
8041 }
8042
8043 return FALSE;
8044 }
8045
8046
8047 bool wxGrid::MoveCursorLeft( bool expandSelection )
8048 {
8049 if ( m_currentCellCoords != wxGridNoCellCoords &&
8050 m_currentCellCoords.GetCol() >= 0 )
8051 {
8052 if ( expandSelection )
8053 {
8054 if ( m_selectingKeyboard == wxGridNoCellCoords )
8055 m_selectingKeyboard = m_currentCellCoords;
8056 if ( m_selectingKeyboard.GetCol() > 0 )
8057 {
8058 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() - 1 );
8059 MakeCellVisible( m_selectingKeyboard.GetRow(),
8060 m_selectingKeyboard.GetCol() );
8061 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8062 }
8063 }
8064 else if ( m_currentCellCoords.GetCol() > 0 )
8065 {
8066 ClearSelection();
8067 MakeCellVisible( m_currentCellCoords.GetRow(),
8068 m_currentCellCoords.GetCol() - 1 );
8069 SetCurrentCell( m_currentCellCoords.GetRow(),
8070 m_currentCellCoords.GetCol() - 1 );
8071 }
8072 else
8073 return FALSE;
8074 return TRUE;
8075 }
8076
8077 return FALSE;
8078 }
8079
8080
8081 bool wxGrid::MoveCursorRight( bool expandSelection )
8082 {
8083 if ( m_currentCellCoords != wxGridNoCellCoords &&
8084 m_currentCellCoords.GetCol() < m_numCols )
8085 {
8086 if ( expandSelection )
8087 {
8088 if ( m_selectingKeyboard == wxGridNoCellCoords )
8089 m_selectingKeyboard = m_currentCellCoords;
8090 if ( m_selectingKeyboard.GetCol() < m_numCols - 1 )
8091 {
8092 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() + 1 );
8093 MakeCellVisible( m_selectingKeyboard.GetRow(),
8094 m_selectingKeyboard.GetCol() );
8095 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8096 }
8097 }
8098 else if ( m_currentCellCoords.GetCol() < m_numCols - 1 )
8099 {
8100 ClearSelection();
8101 MakeCellVisible( m_currentCellCoords.GetRow(),
8102 m_currentCellCoords.GetCol() + 1 );
8103 SetCurrentCell( m_currentCellCoords.GetRow(),
8104 m_currentCellCoords.GetCol() + 1 );
8105 }
8106 else
8107 return FALSE;
8108 return TRUE;
8109 }
8110
8111 return FALSE;
8112 }
8113
8114
8115 bool wxGrid::MovePageUp()
8116 {
8117 if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
8118
8119 int row = m_currentCellCoords.GetRow();
8120 if ( row > 0 )
8121 {
8122 int cw, ch;
8123 m_gridWin->GetClientSize( &cw, &ch );
8124
8125 int y = GetRowTop(row);
8126 int newRow = internalYToRow( y - ch + 1 );
8127
8128 if ( newRow == row )
8129 {
8130 //row > 0 , so newrow can never be less than 0 here.
8131 newRow = row - 1;
8132 }
8133
8134 MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
8135 SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
8136
8137 return TRUE;
8138 }
8139
8140 return FALSE;
8141 }
8142
8143 bool wxGrid::MovePageDown()
8144 {
8145 if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
8146
8147 int row = m_currentCellCoords.GetRow();
8148 if ( (row+1) < m_numRows )
8149 {
8150 int cw, ch;
8151 m_gridWin->GetClientSize( &cw, &ch );
8152
8153 int y = GetRowTop(row);
8154 int newRow = internalYToRow( y + ch );
8155 if ( newRow == row )
8156 {
8157 // row < m_numRows , so newrow can't overflow here.
8158 newRow = row + 1;
8159 }
8160
8161 MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
8162 SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
8163
8164 return TRUE;
8165 }
8166
8167 return FALSE;
8168 }
8169
8170 bool wxGrid::MoveCursorUpBlock( bool expandSelection )
8171 {
8172 if ( m_table &&
8173 m_currentCellCoords != wxGridNoCellCoords &&
8174 m_currentCellCoords.GetRow() > 0 )
8175 {
8176 int row = m_currentCellCoords.GetRow();
8177 int col = m_currentCellCoords.GetCol();
8178
8179 if ( m_table->IsEmptyCell(row, col) )
8180 {
8181 // starting in an empty cell: find the next block of
8182 // non-empty cells
8183 //
8184 while ( row > 0 )
8185 {
8186 row-- ;
8187 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8188 }
8189 }
8190 else if ( m_table->IsEmptyCell(row-1, col) )
8191 {
8192 // starting at the top of a block: find the next block
8193 //
8194 row--;
8195 while ( row > 0 )
8196 {
8197 row-- ;
8198 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8199 }
8200 }
8201 else
8202 {
8203 // starting within a block: find the top of the block
8204 //
8205 while ( row > 0 )
8206 {
8207 row-- ;
8208 if ( m_table->IsEmptyCell(row, col) )
8209 {
8210 row++ ;
8211 break;
8212 }
8213 }
8214 }
8215
8216 MakeCellVisible( row, col );
8217 if ( expandSelection )
8218 {
8219 m_selectingKeyboard = wxGridCellCoords( row, col );
8220 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8221 }
8222 else
8223 {
8224 ClearSelection();
8225 SetCurrentCell( row, col );
8226 }
8227 return TRUE;
8228 }
8229
8230 return FALSE;
8231 }
8232
8233 bool wxGrid::MoveCursorDownBlock( bool expandSelection )
8234 {
8235 if ( m_table &&
8236 m_currentCellCoords != wxGridNoCellCoords &&
8237 m_currentCellCoords.GetRow() < m_numRows-1 )
8238 {
8239 int row = m_currentCellCoords.GetRow();
8240 int col = m_currentCellCoords.GetCol();
8241
8242 if ( m_table->IsEmptyCell(row, col) )
8243 {
8244 // starting in an empty cell: find the next block of
8245 // non-empty cells
8246 //
8247 while ( row < m_numRows-1 )
8248 {
8249 row++ ;
8250 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8251 }
8252 }
8253 else if ( m_table->IsEmptyCell(row+1, col) )
8254 {
8255 // starting at the bottom of a block: find the next block
8256 //
8257 row++;
8258 while ( row < m_numRows-1 )
8259 {
8260 row++ ;
8261 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8262 }
8263 }
8264 else
8265 {
8266 // starting within a block: find the bottom of the block
8267 //
8268 while ( row < m_numRows-1 )
8269 {
8270 row++ ;
8271 if ( m_table->IsEmptyCell(row, col) )
8272 {
8273 row-- ;
8274 break;
8275 }
8276 }
8277 }
8278
8279 MakeCellVisible( row, col );
8280 if ( expandSelection )
8281 {
8282 m_selectingKeyboard = wxGridCellCoords( row, col );
8283 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8284 }
8285 else
8286 {
8287 ClearSelection();
8288 SetCurrentCell( row, col );
8289 }
8290
8291 return TRUE;
8292 }
8293
8294 return FALSE;
8295 }
8296
8297 bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
8298 {
8299 if ( m_table &&
8300 m_currentCellCoords != wxGridNoCellCoords &&
8301 m_currentCellCoords.GetCol() > 0 )
8302 {
8303 int row = m_currentCellCoords.GetRow();
8304 int col = m_currentCellCoords.GetCol();
8305
8306 if ( m_table->IsEmptyCell(row, col) )
8307 {
8308 // starting in an empty cell: find the next block of
8309 // non-empty cells
8310 //
8311 while ( col > 0 )
8312 {
8313 col-- ;
8314 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8315 }
8316 }
8317 else if ( m_table->IsEmptyCell(row, col-1) )
8318 {
8319 // starting at the left of a block: find the next block
8320 //
8321 col--;
8322 while ( col > 0 )
8323 {
8324 col-- ;
8325 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8326 }
8327 }
8328 else
8329 {
8330 // starting within a block: find the left of the block
8331 //
8332 while ( col > 0 )
8333 {
8334 col-- ;
8335 if ( m_table->IsEmptyCell(row, col) )
8336 {
8337 col++ ;
8338 break;
8339 }
8340 }
8341 }
8342
8343 MakeCellVisible( row, col );
8344 if ( expandSelection )
8345 {
8346 m_selectingKeyboard = wxGridCellCoords( row, col );
8347 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8348 }
8349 else
8350 {
8351 ClearSelection();
8352 SetCurrentCell( row, col );
8353 }
8354
8355 return TRUE;
8356 }
8357
8358 return FALSE;
8359 }
8360
8361 bool wxGrid::MoveCursorRightBlock( bool expandSelection )
8362 {
8363 if ( m_table &&
8364 m_currentCellCoords != wxGridNoCellCoords &&
8365 m_currentCellCoords.GetCol() < m_numCols-1 )
8366 {
8367 int row = m_currentCellCoords.GetRow();
8368 int col = m_currentCellCoords.GetCol();
8369
8370 if ( m_table->IsEmptyCell(row, col) )
8371 {
8372 // starting in an empty cell: find the next block of
8373 // non-empty cells
8374 //
8375 while ( col < m_numCols-1 )
8376 {
8377 col++ ;
8378 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8379 }
8380 }
8381 else if ( m_table->IsEmptyCell(row, col+1) )
8382 {
8383 // starting at the right of a block: find the next block
8384 //
8385 col++;
8386 while ( col < m_numCols-1 )
8387 {
8388 col++ ;
8389 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8390 }
8391 }
8392 else
8393 {
8394 // starting within a block: find the right of the block
8395 //
8396 while ( col < m_numCols-1 )
8397 {
8398 col++ ;
8399 if ( m_table->IsEmptyCell(row, col) )
8400 {
8401 col-- ;
8402 break;
8403 }
8404 }
8405 }
8406
8407 MakeCellVisible( row, col );
8408 if ( expandSelection )
8409 {
8410 m_selectingKeyboard = wxGridCellCoords( row, col );
8411 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8412 }
8413 else
8414 {
8415 ClearSelection();
8416 SetCurrentCell( row, col );
8417 }
8418
8419 return TRUE;
8420 }
8421
8422 return FALSE;
8423 }
8424
8425
8426
8427 //
8428 // ------ Label values and formatting
8429 //
8430
8431 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
8432 {
8433 *horiz = m_rowLabelHorizAlign;
8434 *vert = m_rowLabelVertAlign;
8435 }
8436
8437 void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
8438 {
8439 *horiz = m_colLabelHorizAlign;
8440 *vert = m_colLabelVertAlign;
8441 }
8442
8443 int wxGrid::GetColLabelTextOrientation()
8444 {
8445 return m_colLabelTextOrientation;
8446 }
8447
8448 wxString wxGrid::GetRowLabelValue( int row )
8449 {
8450 if ( m_table )
8451 {
8452 return m_table->GetRowLabelValue( row );
8453 }
8454 else
8455 {
8456 wxString s;
8457 s << row;
8458 return s;
8459 }
8460 }
8461
8462 wxString wxGrid::GetColLabelValue( int col )
8463 {
8464 if ( m_table )
8465 {
8466 return m_table->GetColLabelValue( col );
8467 }
8468 else
8469 {
8470 wxString s;
8471 s << col;
8472 return s;
8473 }
8474 }
8475
8476
8477 void wxGrid::SetRowLabelSize( int width )
8478 {
8479 width = wxMax( width, 0 );
8480 if ( width != m_rowLabelWidth )
8481 {
8482 if ( width == 0 )
8483 {
8484 m_rowLabelWin->Show( FALSE );
8485 m_cornerLabelWin->Show( FALSE );
8486 }
8487 else if ( m_rowLabelWidth == 0 )
8488 {
8489 m_rowLabelWin->Show( TRUE );
8490 if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
8491 }
8492
8493 m_rowLabelWidth = width;
8494 CalcWindowSizes();
8495 wxScrolledWindow::Refresh( TRUE );
8496 }
8497 }
8498
8499
8500 void wxGrid::SetColLabelSize( int height )
8501 {
8502 height = wxMax( height, 0 );
8503 if ( height != m_colLabelHeight )
8504 {
8505 if ( height == 0 )
8506 {
8507 m_colLabelWin->Show( FALSE );
8508 m_cornerLabelWin->Show( FALSE );
8509 }
8510 else if ( m_colLabelHeight == 0 )
8511 {
8512 m_colLabelWin->Show( TRUE );
8513 if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
8514 }
8515
8516 m_colLabelHeight = height;
8517 CalcWindowSizes();
8518 wxScrolledWindow::Refresh( TRUE );
8519 }
8520 }
8521
8522
8523 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
8524 {
8525 if ( m_labelBackgroundColour != colour )
8526 {
8527 m_labelBackgroundColour = colour;
8528 m_rowLabelWin->SetBackgroundColour( colour );
8529 m_colLabelWin->SetBackgroundColour( colour );
8530 m_cornerLabelWin->SetBackgroundColour( colour );
8531
8532 if ( !GetBatchCount() )
8533 {
8534 m_rowLabelWin->Refresh();
8535 m_colLabelWin->Refresh();
8536 m_cornerLabelWin->Refresh();
8537 }
8538 }
8539 }
8540
8541 void wxGrid::SetLabelTextColour( const wxColour& colour )
8542 {
8543 if ( m_labelTextColour != colour )
8544 {
8545 m_labelTextColour = colour;
8546 if ( !GetBatchCount() )
8547 {
8548 m_rowLabelWin->Refresh();
8549 m_colLabelWin->Refresh();
8550 }
8551 }
8552 }
8553
8554 void wxGrid::SetLabelFont( const wxFont& font )
8555 {
8556 m_labelFont = font;
8557 if ( !GetBatchCount() )
8558 {
8559 m_rowLabelWin->Refresh();
8560 m_colLabelWin->Refresh();
8561 }
8562 }
8563
8564 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
8565 {
8566 // allow old (incorrect) defs to be used
8567 switch ( horiz )
8568 {
8569 case wxLEFT: horiz = wxALIGN_LEFT; break;
8570 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
8571 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
8572 }
8573
8574 switch ( vert )
8575 {
8576 case wxTOP: vert = wxALIGN_TOP; break;
8577 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
8578 case wxCENTRE: vert = wxALIGN_CENTRE; break;
8579 }
8580
8581 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
8582 {
8583 m_rowLabelHorizAlign = horiz;
8584 }
8585
8586 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
8587 {
8588 m_rowLabelVertAlign = vert;
8589 }
8590
8591 if ( !GetBatchCount() )
8592 {
8593 m_rowLabelWin->Refresh();
8594 }
8595 }
8596
8597 void wxGrid::SetColLabelAlignment( int horiz, int vert )
8598 {
8599 // allow old (incorrect) defs to be used
8600 switch ( horiz )
8601 {
8602 case wxLEFT: horiz = wxALIGN_LEFT; break;
8603 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
8604 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
8605 }
8606
8607 switch ( vert )
8608 {
8609 case wxTOP: vert = wxALIGN_TOP; break;
8610 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
8611 case wxCENTRE: vert = wxALIGN_CENTRE; break;
8612 }
8613
8614 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
8615 {
8616 m_colLabelHorizAlign = horiz;
8617 }
8618
8619 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
8620 {
8621 m_colLabelVertAlign = vert;
8622 }
8623
8624 if ( !GetBatchCount() )
8625 {
8626 m_colLabelWin->Refresh();
8627 }
8628 }
8629
8630 // Note: under MSW, the default column label font must be changed because it
8631 // does not support vertical printing
8632 //
8633 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
8634 // pGrid->SetLabelFont(font);
8635 // pGrid->SetColLabelTextOrientation(wxVERTICAL);
8636 //
8637 void wxGrid::SetColLabelTextOrientation( int textOrientation )
8638 {
8639 if( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
8640 {
8641 m_colLabelTextOrientation = textOrientation;
8642 }
8643
8644 if ( !GetBatchCount() )
8645 {
8646 m_colLabelWin->Refresh();
8647 }
8648 }
8649
8650 void wxGrid::SetRowLabelValue( int row, const wxString& s )
8651 {
8652 if ( m_table )
8653 {
8654 m_table->SetRowLabelValue( row, s );
8655 if ( !GetBatchCount() )
8656 {
8657 wxRect rect = CellToRect( row, 0);
8658 if ( rect.height > 0 )
8659 {
8660 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
8661 rect.x = 0;
8662 rect.width = m_rowLabelWidth;
8663 m_rowLabelWin->Refresh( TRUE, &rect );
8664 }
8665 }
8666 }
8667 }
8668
8669 void wxGrid::SetColLabelValue( int col, const wxString& s )
8670 {
8671 if ( m_table )
8672 {
8673 m_table->SetColLabelValue( col, s );
8674 if ( !GetBatchCount() )
8675 {
8676 wxRect rect = CellToRect( 0, col );
8677 if ( rect.width > 0 )
8678 {
8679 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
8680 rect.y = 0;
8681 rect.height = m_colLabelHeight;
8682 m_colLabelWin->Refresh( TRUE, &rect );
8683 }
8684 }
8685 }
8686 }
8687
8688 void wxGrid::SetGridLineColour( const wxColour& colour )
8689 {
8690 if ( m_gridLineColour != colour )
8691 {
8692 m_gridLineColour = colour;
8693
8694 wxClientDC dc( m_gridWin );
8695 PrepareDC( dc );
8696 DrawAllGridLines( dc, wxRegion() );
8697 }
8698 }
8699
8700
8701 void wxGrid::SetCellHighlightColour( const wxColour& colour )
8702 {
8703 if ( m_cellHighlightColour != colour )
8704 {
8705 m_cellHighlightColour = colour;
8706
8707 wxClientDC dc( m_gridWin );
8708 PrepareDC( dc );
8709 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
8710 DrawCellHighlight(dc, attr);
8711 attr->DecRef();
8712 }
8713 }
8714
8715 void wxGrid::SetCellHighlightPenWidth(int width)
8716 {
8717 if (m_cellHighlightPenWidth != width) {
8718 m_cellHighlightPenWidth = width;
8719
8720 // Just redrawing the cell highlight is not enough since that won't
8721 // make any visible change if the the thickness is getting smaller.
8722 int row = m_currentCellCoords.GetRow();
8723 int col = m_currentCellCoords.GetCol();
8724 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
8725 return;
8726 wxRect rect = CellToRect(row, col);
8727 m_gridWin->Refresh(TRUE, &rect);
8728 }
8729 }
8730
8731 void wxGrid::SetCellHighlightROPenWidth(int width)
8732 {
8733 if (m_cellHighlightROPenWidth != width) {
8734 m_cellHighlightROPenWidth = width;
8735
8736 // Just redrawing the cell highlight is not enough since that won't
8737 // make any visible change if the the thickness is getting smaller.
8738 int row = m_currentCellCoords.GetRow();
8739 int col = m_currentCellCoords.GetCol();
8740 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
8741 return;
8742 wxRect rect = CellToRect(row, col);
8743 m_gridWin->Refresh(TRUE, &rect);
8744 }
8745 }
8746
8747 void wxGrid::EnableGridLines( bool enable )
8748 {
8749 if ( enable != m_gridLinesEnabled )
8750 {
8751 m_gridLinesEnabled = enable;
8752
8753 if ( !GetBatchCount() )
8754 {
8755 if ( enable )
8756 {
8757 wxClientDC dc( m_gridWin );
8758 PrepareDC( dc );
8759 DrawAllGridLines( dc, wxRegion() );
8760 }
8761 else
8762 {
8763 m_gridWin->Refresh();
8764 }
8765 }
8766 }
8767 }
8768
8769
8770 int wxGrid::GetDefaultRowSize()
8771 {
8772 return m_defaultRowHeight;
8773 }
8774
8775 int wxGrid::GetRowSize( int row )
8776 {
8777 wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
8778
8779 return GetRowHeight(row);
8780 }
8781
8782 int wxGrid::GetDefaultColSize()
8783 {
8784 return m_defaultColWidth;
8785 }
8786
8787 int wxGrid::GetColSize( int col )
8788 {
8789 wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
8790
8791 return GetColWidth(col);
8792 }
8793
8794 // ============================================================================
8795 // access to the grid attributes: each of them has a default value in the grid
8796 // itself and may be overidden on a per-cell basis
8797 // ============================================================================
8798
8799 // ----------------------------------------------------------------------------
8800 // setting default attributes
8801 // ----------------------------------------------------------------------------
8802
8803 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
8804 {
8805 m_defaultCellAttr->SetBackgroundColour(col);
8806 #ifdef __WXGTK__
8807 m_gridWin->SetBackgroundColour(col);
8808 #endif
8809 }
8810
8811 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
8812 {
8813 m_defaultCellAttr->SetTextColour(col);
8814 }
8815
8816 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
8817 {
8818 m_defaultCellAttr->SetAlignment(horiz, vert);
8819 }
8820
8821 void wxGrid::SetDefaultCellOverflow( bool allow )
8822 {
8823 m_defaultCellAttr->SetOverflow(allow);
8824 }
8825
8826 void wxGrid::SetDefaultCellFont( const wxFont& font )
8827 {
8828 m_defaultCellAttr->SetFont(font);
8829 }
8830
8831 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
8832 {
8833 m_defaultCellAttr->SetRenderer(renderer);
8834 }
8835
8836 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
8837 {
8838 m_defaultCellAttr->SetEditor(editor);
8839 }
8840
8841 // ----------------------------------------------------------------------------
8842 // access to the default attrbiutes
8843 // ----------------------------------------------------------------------------
8844
8845 wxColour wxGrid::GetDefaultCellBackgroundColour()
8846 {
8847 return m_defaultCellAttr->GetBackgroundColour();
8848 }
8849
8850 wxColour wxGrid::GetDefaultCellTextColour()
8851 {
8852 return m_defaultCellAttr->GetTextColour();
8853 }
8854
8855 wxFont wxGrid::GetDefaultCellFont()
8856 {
8857 return m_defaultCellAttr->GetFont();
8858 }
8859
8860 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
8861 {
8862 m_defaultCellAttr->GetAlignment(horiz, vert);
8863 }
8864
8865 bool wxGrid::GetDefaultCellOverflow()
8866 {
8867 return m_defaultCellAttr->GetOverflow();
8868 }
8869
8870 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
8871 {
8872 return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
8873 }
8874
8875 wxGridCellEditor *wxGrid::GetDefaultEditor() const
8876 {
8877 return m_defaultCellAttr->GetEditor(NULL,0,0);
8878 }
8879
8880 // ----------------------------------------------------------------------------
8881 // access to cell attributes
8882 // ----------------------------------------------------------------------------
8883
8884 wxColour wxGrid::GetCellBackgroundColour(int row, int col)
8885 {
8886 wxGridCellAttr *attr = GetCellAttr(row, col);
8887 wxColour colour = attr->GetBackgroundColour();
8888 attr->DecRef();
8889 return colour;
8890 }
8891
8892 wxColour wxGrid::GetCellTextColour( int row, int col )
8893 {
8894 wxGridCellAttr *attr = GetCellAttr(row, col);
8895 wxColour colour = attr->GetTextColour();
8896 attr->DecRef();
8897 return colour;
8898 }
8899
8900 wxFont wxGrid::GetCellFont( int row, int col )
8901 {
8902 wxGridCellAttr *attr = GetCellAttr(row, col);
8903 wxFont font = attr->GetFont();
8904 attr->DecRef();
8905 return font;
8906 }
8907
8908 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
8909 {
8910 wxGridCellAttr *attr = GetCellAttr(row, col);
8911 attr->GetAlignment(horiz, vert);
8912 attr->DecRef();
8913 }
8914
8915 bool wxGrid::GetCellOverflow( int row, int col )
8916 {
8917 wxGridCellAttr *attr = GetCellAttr(row, col);
8918 bool allow = attr->GetOverflow();
8919 attr->DecRef();
8920 return allow;
8921 }
8922
8923 void wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols )
8924 {
8925 wxGridCellAttr *attr = GetCellAttr(row, col);
8926 attr->GetSize( num_rows, num_cols );
8927 attr->DecRef();
8928 }
8929
8930 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
8931 {
8932 wxGridCellAttr* attr = GetCellAttr(row, col);
8933 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
8934 attr->DecRef();
8935
8936 return renderer;
8937 }
8938
8939 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
8940 {
8941 wxGridCellAttr* attr = GetCellAttr(row, col);
8942 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
8943 attr->DecRef();
8944
8945 return editor;
8946 }
8947
8948 bool wxGrid::IsReadOnly(int row, int col) const
8949 {
8950 wxGridCellAttr* attr = GetCellAttr(row, col);
8951 bool isReadOnly = attr->IsReadOnly();
8952 attr->DecRef();
8953 return isReadOnly;
8954 }
8955
8956 // ----------------------------------------------------------------------------
8957 // attribute support: cache, automatic provider creation, ...
8958 // ----------------------------------------------------------------------------
8959
8960 bool wxGrid::CanHaveAttributes()
8961 {
8962 if ( !m_table )
8963 {
8964 return FALSE;
8965 }
8966
8967 return m_table->CanHaveAttributes();
8968 }
8969
8970 void wxGrid::ClearAttrCache()
8971 {
8972 if ( m_attrCache.row != -1 )
8973 {
8974 wxSafeDecRef(m_attrCache.attr);
8975 m_attrCache.attr = NULL;
8976 m_attrCache.row = -1;
8977 }
8978 }
8979
8980 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
8981 {
8982 if ( attr != NULL )
8983 {
8984 wxGrid *self = (wxGrid *)this; // const_cast
8985
8986 self->ClearAttrCache();
8987 self->m_attrCache.row = row;
8988 self->m_attrCache.col = col;
8989 self->m_attrCache.attr = attr;
8990 wxSafeIncRef(attr);
8991 }
8992 }
8993
8994 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
8995 {
8996 if ( row == m_attrCache.row && col == m_attrCache.col )
8997 {
8998 *attr = m_attrCache.attr;
8999 wxSafeIncRef(m_attrCache.attr);
9000
9001 #ifdef DEBUG_ATTR_CACHE
9002 gs_nAttrCacheHits++;
9003 #endif
9004
9005 return TRUE;
9006 }
9007 else
9008 {
9009 #ifdef DEBUG_ATTR_CACHE
9010 gs_nAttrCacheMisses++;
9011 #endif
9012 return FALSE;
9013 }
9014 }
9015
9016 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
9017 {
9018 wxGridCellAttr *attr = NULL;
9019 // Additional test to avoid looking at the cache e.g. for
9020 // wxNoCellCoords, as this will confuse memory management.
9021 if ( row >= 0 )
9022 {
9023 if ( !LookupAttr(row, col, &attr) )
9024 {
9025 attr = m_table ? m_table->GetAttr(row, col , wxGridCellAttr::Any)
9026 : (wxGridCellAttr *)NULL;
9027 CacheAttr(row, col, attr);
9028 }
9029 }
9030 if (attr)
9031 {
9032 attr->SetDefAttr(m_defaultCellAttr);
9033 }
9034 else
9035 {
9036 attr = m_defaultCellAttr;
9037 attr->IncRef();
9038 }
9039
9040 return attr;
9041 }
9042
9043 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
9044 {
9045 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
9046
9047 wxCHECK_MSG( m_table, attr,
9048 _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
9049
9050 attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell);
9051 if ( !attr )
9052 {
9053 attr = new wxGridCellAttr(m_defaultCellAttr);
9054
9055 // artificially inc the ref count to match DecRef() in caller
9056 attr->IncRef();
9057 m_table->SetAttr(attr, row, col);
9058 }
9059
9060 return attr;
9061 }
9062
9063 // ----------------------------------------------------------------------------
9064 // setting column attributes (wrappers around SetColAttr)
9065 // ----------------------------------------------------------------------------
9066
9067 void wxGrid::SetColFormatBool(int col)
9068 {
9069 SetColFormatCustom(col, wxGRID_VALUE_BOOL);
9070 }
9071
9072 void wxGrid::SetColFormatNumber(int col)
9073 {
9074 SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
9075 }
9076
9077 void wxGrid::SetColFormatFloat(int col, int width, int precision)
9078 {
9079 wxString typeName = wxGRID_VALUE_FLOAT;
9080 if ( (width != -1) || (precision != -1) )
9081 {
9082 typeName << _T(':') << width << _T(',') << precision;
9083 }
9084
9085 SetColFormatCustom(col, typeName);
9086 }
9087
9088 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
9089 {
9090 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
9091
9092 attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
9093 if(!attr)
9094 attr = new wxGridCellAttr;
9095 wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
9096 attr->SetRenderer(renderer);
9097
9098 SetColAttr(col, attr);
9099
9100 }
9101
9102 // ----------------------------------------------------------------------------
9103 // setting cell attributes: this is forwarded to the table
9104 // ----------------------------------------------------------------------------
9105
9106 void wxGrid::SetAttr(int row, int col, wxGridCellAttr *attr)
9107 {
9108 if ( CanHaveAttributes() )
9109 {
9110 m_table->SetAttr(attr, row, col);
9111 ClearAttrCache();
9112 }
9113 else
9114 {
9115 wxSafeDecRef(attr);
9116 }
9117 }
9118
9119 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
9120 {
9121 if ( CanHaveAttributes() )
9122 {
9123 m_table->SetRowAttr(attr, row);
9124 ClearAttrCache();
9125 }
9126 else
9127 {
9128 wxSafeDecRef(attr);
9129 }
9130 }
9131
9132 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
9133 {
9134 if ( CanHaveAttributes() )
9135 {
9136 m_table->SetColAttr(attr, col);
9137 ClearAttrCache();
9138 }
9139 else
9140 {
9141 wxSafeDecRef(attr);
9142 }
9143 }
9144
9145 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
9146 {
9147 if ( CanHaveAttributes() )
9148 {
9149 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9150 attr->SetBackgroundColour(colour);
9151 attr->DecRef();
9152 }
9153 }
9154
9155 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
9156 {
9157 if ( CanHaveAttributes() )
9158 {
9159 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9160 attr->SetTextColour(colour);
9161 attr->DecRef();
9162 }
9163 }
9164
9165 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
9166 {
9167 if ( CanHaveAttributes() )
9168 {
9169 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9170 attr->SetFont(font);
9171 attr->DecRef();
9172 }
9173 }
9174
9175 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
9176 {
9177 if ( CanHaveAttributes() )
9178 {
9179 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9180 attr->SetAlignment(horiz, vert);
9181 attr->DecRef();
9182 }
9183 }
9184
9185 void wxGrid::SetCellOverflow( int row, int col, bool allow )
9186 {
9187 if ( CanHaveAttributes() )
9188 {
9189 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9190 attr->SetOverflow(allow);
9191 attr->DecRef();
9192 }
9193 }
9194
9195 void wxGrid::SetCellSize( int row, int col, int num_rows, int num_cols )
9196 {
9197 if ( CanHaveAttributes() )
9198 {
9199 int cell_rows, cell_cols;
9200
9201 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9202 attr->GetSize(&cell_rows, &cell_cols);
9203 attr->SetSize(num_rows, num_cols);
9204 attr->DecRef();
9205
9206 // Cannot set the size of a cell to 0 or negative values
9207 // While it is perfectly legal to do that, this function cannot
9208 // handle all the possibilies, do it by hand by getting the CellAttr.
9209 // You can only set the size of a cell to 1,1 or greater with this fn
9210 wxASSERT_MSG( !((cell_rows < 1) || (cell_cols < 1)),
9211 wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
9212 wxASSERT_MSG( !((num_rows < 1) || (num_cols < 1)),
9213 wxT("wxGrid::SetCellSize setting cell size to < 1"));
9214
9215 // if this was already a multicell then "turn off" the other cells first
9216 if ((cell_rows > 1) || (cell_rows > 1))
9217 {
9218 int i, j;
9219 for (j=row; j<row+cell_rows; j++)
9220 {
9221 for (i=col; i<col+cell_cols; i++)
9222 {
9223 if ((i != col) || (j != row))
9224 {
9225 wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
9226 attr_stub->SetSize( 1, 1 );
9227 attr_stub->DecRef();
9228 }
9229 }
9230 }
9231 }
9232
9233 // mark the cells that will be covered by this cell to
9234 // negative or zero values to point back at this cell
9235 if (((num_rows > 1) || (num_cols > 1)) && (num_rows >= 1) && (num_cols >= 1))
9236 {
9237 int i, j;
9238 for (j=row; j<row+num_rows; j++)
9239 {
9240 for (i=col; i<col+num_cols; i++)
9241 {
9242 if ((i != col) || (j != row))
9243 {
9244 wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
9245 attr_stub->SetSize( row-j, col-i );
9246 attr_stub->DecRef();
9247 }
9248 }
9249 }
9250 }
9251 }
9252 }
9253
9254 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
9255 {
9256 if ( CanHaveAttributes() )
9257 {
9258 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9259 attr->SetRenderer(renderer);
9260 attr->DecRef();
9261 }
9262 }
9263
9264 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
9265 {
9266 if ( CanHaveAttributes() )
9267 {
9268 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9269 attr->SetEditor(editor);
9270 attr->DecRef();
9271 }
9272 }
9273
9274 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
9275 {
9276 if ( CanHaveAttributes() )
9277 {
9278 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9279 attr->SetReadOnly(isReadOnly);
9280 attr->DecRef();
9281 }
9282 }
9283
9284 // ----------------------------------------------------------------------------
9285 // Data type registration
9286 // ----------------------------------------------------------------------------
9287
9288 void wxGrid::RegisterDataType(const wxString& typeName,
9289 wxGridCellRenderer* renderer,
9290 wxGridCellEditor* editor)
9291 {
9292 m_typeRegistry->RegisterDataType(typeName, renderer, editor);
9293 }
9294
9295
9296 wxGridCellEditor* wxGrid::GetDefaultEditorForCell(int row, int col) const
9297 {
9298 wxString typeName = m_table->GetTypeName(row, col);
9299 return GetDefaultEditorForType(typeName);
9300 }
9301
9302 wxGridCellRenderer* wxGrid::GetDefaultRendererForCell(int row, int col) const
9303 {
9304 wxString typeName = m_table->GetTypeName(row, col);
9305 return GetDefaultRendererForType(typeName);
9306 }
9307
9308 wxGridCellEditor*
9309 wxGrid::GetDefaultEditorForType(const wxString& typeName) const
9310 {
9311 int index = m_typeRegistry->FindOrCloneDataType(typeName);
9312 if ( index == wxNOT_FOUND )
9313 {
9314 wxFAIL_MSG(wxT("Unknown data type name"));
9315
9316 return NULL;
9317 }
9318
9319 return m_typeRegistry->GetEditor(index);
9320 }
9321
9322 wxGridCellRenderer*
9323 wxGrid::GetDefaultRendererForType(const wxString& typeName) const
9324 {
9325 int index = m_typeRegistry->FindOrCloneDataType(typeName);
9326 if ( index == wxNOT_FOUND )
9327 {
9328 wxFAIL_MSG(wxT("Unknown data type name"));
9329
9330 return NULL;
9331 }
9332
9333 return m_typeRegistry->GetRenderer(index);
9334 }
9335
9336
9337 // ----------------------------------------------------------------------------
9338 // row/col size
9339 // ----------------------------------------------------------------------------
9340
9341 void wxGrid::EnableDragRowSize( bool enable )
9342 {
9343 m_canDragRowSize = enable;
9344 }
9345
9346
9347 void wxGrid::EnableDragColSize( bool enable )
9348 {
9349 m_canDragColSize = enable;
9350 }
9351
9352 void wxGrid::EnableDragGridSize( bool enable )
9353 {
9354 m_canDragGridSize = enable;
9355 }
9356
9357
9358 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
9359 {
9360 m_defaultRowHeight = wxMax( height, m_minAcceptableRowHeight );
9361
9362 if ( resizeExistingRows )
9363 {
9364 // since we are resizing all rows to the default row size,
9365 // we can simply clear the row heights and row bottoms
9366 // arrays (which also allows us to take advantage of
9367 // some speed optimisations)
9368 m_rowHeights.Empty();
9369 m_rowBottoms.Empty();
9370 if ( !GetBatchCount() )
9371 CalcDimensions();
9372 }
9373 }
9374
9375 void wxGrid::SetRowSize( int row, int height )
9376 {
9377 wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
9378
9379 // See comment in SetColSize
9380 if ( height < GetRowMinimalAcceptableHeight()) { return; }
9381
9382 if ( m_rowHeights.IsEmpty() )
9383 {
9384 // need to really create the array
9385 InitRowHeights();
9386 }
9387
9388 int h = wxMax( 0, height );
9389 int diff = h - m_rowHeights[row];
9390
9391 m_rowHeights[row] = h;
9392 int i;
9393 for ( i = row; i < m_numRows; i++ )
9394 {
9395 m_rowBottoms[i] += diff;
9396 }
9397 if ( !GetBatchCount() )
9398 CalcDimensions();
9399 }
9400
9401 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
9402 {
9403 m_defaultColWidth = wxMax( width, m_minAcceptableColWidth );
9404
9405 if ( resizeExistingCols )
9406 {
9407 // since we are resizing all columns to the default column size,
9408 // we can simply clear the col widths and col rights
9409 // arrays (which also allows us to take advantage of
9410 // some speed optimisations)
9411 m_colWidths.Empty();
9412 m_colRights.Empty();
9413 if ( !GetBatchCount() )
9414 CalcDimensions();
9415 }
9416 }
9417
9418 void wxGrid::SetColSize( int col, int width )
9419 {
9420 wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
9421
9422 // should we check that it's bigger than GetColMinimalWidth(col) here?
9423 // (VZ)
9424 // No, because it is reasonable to assume the library user know's
9425 // what he is doing. However whe should test against the weaker
9426 // constariant of minimalAcceptableWidth, as this breaks rendering
9427 //
9428 // This test then fixes sf.net bug #645734
9429
9430 if ( width < GetColMinimalAcceptableWidth()) { return; }
9431
9432 if ( m_colWidths.IsEmpty() )
9433 {
9434 // need to really create the array
9435 InitColWidths();
9436 }
9437
9438 // if < 0 calc new width from label
9439 if( width < 0 )
9440 {
9441 long w, h;
9442 wxArrayString lines;
9443 wxClientDC dc(m_colLabelWin);
9444 dc.SetFont(GetLabelFont());
9445 StringToLines(GetColLabelValue(col), lines);
9446 GetTextBoxSize(dc, lines, &w, &h);
9447 width = w + 6;
9448 }
9449 int w = wxMax( 0, width );
9450 int diff = w - m_colWidths[col];
9451 m_colWidths[col] = w;
9452
9453 int i;
9454 for ( i = col; i < m_numCols; i++ )
9455 {
9456 m_colRights[i] += diff;
9457 }
9458 if ( !GetBatchCount() )
9459 CalcDimensions();
9460 }
9461
9462
9463 void wxGrid::SetColMinimalWidth( int col, int width )
9464 {
9465 if (width > GetColMinimalAcceptableWidth()) {
9466 m_colMinWidths[col] = width;
9467 }
9468 }
9469
9470 void wxGrid::SetRowMinimalHeight( int row, int width )
9471 {
9472 if (width > GetRowMinimalAcceptableHeight()) {
9473 m_rowMinHeights[row] = width;
9474 }
9475 }
9476
9477 int wxGrid::GetColMinimalWidth(int col) const
9478 {
9479 wxLongToLongHashMap::const_iterator it = m_colMinWidths.find(col);
9480 return it != m_colMinWidths.end() ? (int)it->second : m_minAcceptableColWidth;
9481 }
9482
9483 int wxGrid::GetRowMinimalHeight(int row) const
9484 {
9485 wxLongToLongHashMap::const_iterator it = m_rowMinHeights.find(row);
9486 return it != m_rowMinHeights.end() ? (int)it->second : m_minAcceptableRowHeight;
9487 }
9488
9489 void wxGrid::SetColMinimalAcceptableWidth( int width )
9490 {
9491 if ( width<1 )
9492 return;
9493 m_minAcceptableColWidth = width;
9494 }
9495
9496 void wxGrid::SetRowMinimalAcceptableHeight( int height )
9497 {
9498 if ( height<1 )
9499 return;
9500 m_minAcceptableRowHeight = height;
9501 };
9502
9503 int wxGrid::GetColMinimalAcceptableWidth() const
9504 {
9505 return m_minAcceptableColWidth;
9506 }
9507
9508 int wxGrid::GetRowMinimalAcceptableHeight() const
9509 {
9510 return m_minAcceptableRowHeight;
9511 }
9512
9513 // ----------------------------------------------------------------------------
9514 // auto sizing
9515 // ----------------------------------------------------------------------------
9516
9517 void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
9518 {
9519 wxClientDC dc(m_gridWin);
9520
9521 // init both of them to avoid compiler warnings, even if weo nly need one
9522 int row = -1,
9523 col = -1;
9524 if ( column )
9525 col = colOrRow;
9526 else
9527 row = colOrRow;
9528
9529 wxCoord extent, extentMax = 0;
9530 int max = column ? m_numRows : m_numCols;
9531 for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
9532 {
9533 if ( column )
9534 row = rowOrCol;
9535 else
9536 col = rowOrCol;
9537
9538 wxGridCellAttr* attr = GetCellAttr(row, col);
9539 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
9540 if ( renderer )
9541 {
9542 wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
9543 extent = column ? size.x : size.y;
9544 if ( extent > extentMax )
9545 {
9546 extentMax = extent;
9547 }
9548
9549 renderer->DecRef();
9550 }
9551
9552 attr->DecRef();
9553 }
9554
9555 // now also compare with the column label extent
9556 wxCoord w, h;
9557 dc.SetFont( GetLabelFont() );
9558
9559 if ( column )
9560 {
9561 dc.GetTextExtent( GetColLabelValue(col), &w, &h );
9562 if( GetColLabelTextOrientation() == wxVERTICAL )
9563 w = h;
9564 }
9565 else
9566 dc.GetTextExtent( GetRowLabelValue(row), &w, &h );
9567
9568 extent = column ? w : h;
9569 if ( extent > extentMax )
9570 {
9571 extentMax = extent;
9572 }
9573
9574 if ( !extentMax )
9575 {
9576 // empty column - give default extent (notice that if extentMax is less
9577 // than default extent but != 0, it's ok)
9578 extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
9579 }
9580 else
9581 {
9582 if ( column )
9583 {
9584 // leave some space around text
9585 extentMax += 10;
9586 }
9587 else
9588 {
9589 extentMax += 6;
9590 }
9591 }
9592
9593 if ( column )
9594 {
9595 SetColSize(col, extentMax);
9596 if ( !GetBatchCount() )
9597 {
9598 int cw, ch, dummy;
9599 m_gridWin->GetClientSize( &cw, &ch );
9600 wxRect rect ( CellToRect( 0, col ) );
9601 rect.y = 0;
9602 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
9603 rect.width = cw - rect.x;
9604 rect.height = m_colLabelHeight;
9605 m_colLabelWin->Refresh( TRUE, &rect );
9606 }
9607 }
9608 else
9609 {
9610 SetRowSize(row, extentMax);
9611 if ( !GetBatchCount() )
9612 {
9613 int cw, ch, dummy;
9614 m_gridWin->GetClientSize( &cw, &ch );
9615 wxRect rect ( CellToRect( row, 0 ) );
9616 rect.x = 0;
9617 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
9618 rect.width = m_rowLabelWidth;
9619 rect.height = ch - rect.y;
9620 m_rowLabelWin->Refresh( TRUE, &rect );
9621 }
9622 }
9623 if ( setAsMin )
9624 {
9625 if ( column )
9626 SetColMinimalWidth(col, extentMax);
9627 else
9628 SetRowMinimalHeight(row, extentMax);
9629 }
9630 }
9631
9632 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
9633 {
9634 int width = m_rowLabelWidth;
9635
9636 if ( !calcOnly )
9637 BeginBatch();
9638
9639 for ( int col = 0; col < m_numCols; col++ )
9640 {
9641 if ( !calcOnly )
9642 {
9643 AutoSizeColumn(col, setAsMin);
9644 }
9645
9646 width += GetColWidth(col);
9647 }
9648
9649 if ( !calcOnly )
9650 EndBatch();
9651
9652 return width;
9653 }
9654
9655 int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
9656 {
9657 int height = m_colLabelHeight;
9658
9659 if ( !calcOnly )
9660 BeginBatch();
9661
9662 for ( int row = 0; row < m_numRows; row++ )
9663 {
9664 if ( !calcOnly )
9665 {
9666 AutoSizeRow(row, setAsMin);
9667 }
9668
9669 height += GetRowHeight(row);
9670 }
9671
9672 if ( !calcOnly )
9673 EndBatch();
9674
9675 return height;
9676 }
9677
9678 void wxGrid::AutoSize()
9679 {
9680 BeginBatch();
9681
9682 wxSize size(SetOrCalcColumnSizes(FALSE), SetOrCalcRowSizes(FALSE));
9683
9684 // round up the size to a multiple of scroll step - this ensures that we
9685 // won't get the scrollbars if we're sized exactly to this width
9686 // CalcDimension adds m_extraWidth + 1 etc. to calculate the necessary
9687 // scrollbar steps
9688 wxSize sizeFit(GetScrollX(size.x + m_extraWidth + 1) * GRID_SCROLL_LINE_X,
9689 GetScrollY(size.y + m_extraHeight + 1) * GRID_SCROLL_LINE_Y);
9690
9691 // distribute the extra space between the columns/rows to avoid having
9692 // extra white space
9693
9694 // Remove the extra m_extraWidth + 1 added above
9695 wxCoord diff = sizeFit.x - size.x + (m_extraWidth + 1);
9696 if ( diff && m_numCols )
9697 {
9698 // try to resize the columns uniformly
9699 wxCoord diffPerCol = diff / m_numCols;
9700 if ( diffPerCol )
9701 {
9702 for ( int col = 0; col < m_numCols; col++ )
9703 {
9704 SetColSize(col, GetColWidth(col) + diffPerCol);
9705 }
9706 }
9707
9708 // add remaining amount to the last columns
9709 diff -= diffPerCol * m_numCols;
9710 if ( diff )
9711 {
9712 for ( int col = m_numCols - 1; col >= m_numCols - diff; col-- )
9713 {
9714 SetColSize(col, GetColWidth(col) + 1);
9715 }
9716 }
9717 }
9718
9719 // same for rows
9720 diff = sizeFit.y - size.y - (m_extraHeight + 1);
9721 if ( diff && m_numRows )
9722 {
9723 // try to resize the columns uniformly
9724 wxCoord diffPerRow = diff / m_numRows;
9725 if ( diffPerRow )
9726 {
9727 for ( int row = 0; row < m_numRows; row++ )
9728 {
9729 SetRowSize(row, GetRowHeight(row) + diffPerRow);
9730 }
9731 }
9732
9733 // add remaining amount to the last rows
9734 diff -= diffPerRow * m_numRows;
9735 if ( diff )
9736 {
9737 for ( int row = m_numRows - 1; row >= m_numRows - diff; row-- )
9738 {
9739 SetRowSize(row, GetRowHeight(row) + 1);
9740 }
9741 }
9742 }
9743
9744 EndBatch();
9745
9746 SetClientSize(sizeFit);
9747 }
9748
9749 void wxGrid::AutoSizeRowLabelSize( int row )
9750 {
9751 wxArrayString lines;
9752 long w, h;
9753
9754 // Hide the edit control, so it
9755 // won't interfer with drag-shrinking.
9756 if( IsCellEditControlShown() )
9757 {
9758 HideCellEditControl();
9759 SaveEditControlValue();
9760 }
9761
9762 // autosize row height depending on label text
9763 StringToLines( GetRowLabelValue( row ), lines );
9764 wxClientDC dc( m_rowLabelWin );
9765 GetTextBoxSize( dc, lines, &w, &h);
9766 if( h < m_defaultRowHeight )
9767 h = m_defaultRowHeight;
9768 SetRowSize(row, h);
9769 ForceRefresh();
9770 }
9771
9772 void wxGrid::AutoSizeColLabelSize( int col )
9773 {
9774 wxArrayString lines;
9775 long w, h;
9776
9777 // Hide the edit control, so it
9778 // won't interfer with drag-shrinking.
9779 if( IsCellEditControlShown() )
9780 {
9781 HideCellEditControl();
9782 SaveEditControlValue();
9783 }
9784
9785 // autosize column width depending on label text
9786 StringToLines( GetColLabelValue( col ), lines );
9787 wxClientDC dc( m_colLabelWin );
9788 if( GetColLabelTextOrientation() == wxHORIZONTAL )
9789 GetTextBoxSize( dc, lines, &w, &h);
9790 else
9791 GetTextBoxSize( dc, lines, &h, &w);
9792 if( w < m_defaultColWidth )
9793 w = m_defaultColWidth;
9794 SetColSize(col, w);
9795 ForceRefresh();
9796 }
9797
9798 wxSize wxGrid::DoGetBestSize() const
9799 {
9800 // don't set sizes, only calculate them
9801 wxGrid *self = (wxGrid *)this; // const_cast
9802
9803 int width, height;
9804 width = self->SetOrCalcColumnSizes(TRUE);
9805 height = self->SetOrCalcRowSizes(TRUE);
9806
9807 int maxwidth, maxheight;
9808 wxDisplaySize( & maxwidth, & maxheight );
9809
9810 if ( width > maxwidth ) width = maxwidth;
9811 if ( height > maxheight ) height = maxheight;
9812
9813 return wxSize( width, height );
9814 }
9815
9816 void wxGrid::Fit()
9817 {
9818 AutoSize();
9819 }
9820
9821
9822 wxPen& wxGrid::GetDividerPen() const
9823 {
9824 return wxNullPen;
9825 }
9826
9827 // ----------------------------------------------------------------------------
9828 // cell value accessor functions
9829 // ----------------------------------------------------------------------------
9830
9831 void wxGrid::SetCellValue( int row, int col, const wxString& s )
9832 {
9833 if ( m_table )
9834 {
9835 m_table->SetValue( row, col, s );
9836 if ( !GetBatchCount() )
9837 {
9838 int dummy;
9839 wxRect rect( CellToRect( row, col ) );
9840 rect.x = 0;
9841 rect.width = m_gridWin->GetClientSize().GetWidth();
9842 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
9843 m_gridWin->Refresh( FALSE, &rect );
9844 }
9845
9846 if ( m_currentCellCoords.GetRow() == row &&
9847 m_currentCellCoords.GetCol() == col &&
9848 IsCellEditControlShown())
9849 // Note: If we are using IsCellEditControlEnabled,
9850 // this interacts badly with calling SetCellValue from
9851 // an EVT_GRID_CELL_CHANGE handler.
9852 {
9853 HideCellEditControl();
9854 ShowCellEditControl(); // will reread data from table
9855 }
9856 }
9857 }
9858
9859
9860 //
9861 // ------ Block, row and col selection
9862 //
9863
9864 void wxGrid::SelectRow( int row, bool addToSelected )
9865 {
9866 if ( IsSelection() && !addToSelected )
9867 ClearSelection();
9868
9869 if ( m_selection )
9870 m_selection->SelectRow( row, FALSE, addToSelected );
9871 }
9872
9873
9874 void wxGrid::SelectCol( int col, bool addToSelected )
9875 {
9876 if ( IsSelection() && !addToSelected )
9877 ClearSelection();
9878
9879 if ( m_selection )
9880 m_selection->SelectCol( col, FALSE, addToSelected );
9881 }
9882
9883
9884 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
9885 bool addToSelected )
9886 {
9887 if ( IsSelection() && !addToSelected )
9888 ClearSelection();
9889
9890 if ( m_selection )
9891 m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol,
9892 FALSE, addToSelected );
9893 }
9894
9895
9896 void wxGrid::SelectAll()
9897 {
9898 if ( m_numRows > 0 && m_numCols > 0 )
9899 {
9900 if ( m_selection )
9901 m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
9902 }
9903 }
9904
9905 //
9906 // ------ Cell, row and col deselection
9907 //
9908
9909 void wxGrid::DeselectRow( int row )
9910 {
9911 if ( !m_selection )
9912 return;
9913
9914 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
9915 {
9916 if ( m_selection->IsInSelection(row, 0 ) )
9917 m_selection->ToggleCellSelection( row, 0);
9918 }
9919 else
9920 {
9921 int nCols = GetNumberCols();
9922 for ( int i = 0; i < nCols ; i++ )
9923 {
9924 if ( m_selection->IsInSelection(row, i ) )
9925 m_selection->ToggleCellSelection( row, i);
9926 }
9927 }
9928 }
9929
9930 void wxGrid::DeselectCol( int col )
9931 {
9932 if ( !m_selection )
9933 return;
9934
9935 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
9936 {
9937 if ( m_selection->IsInSelection(0, col ) )
9938 m_selection->ToggleCellSelection( 0, col);
9939 }
9940 else
9941 {
9942 int nRows = GetNumberRows();
9943 for ( int i = 0; i < nRows ; i++ )
9944 {
9945 if ( m_selection->IsInSelection(i, col ) )
9946 m_selection->ToggleCellSelection(i, col);
9947 }
9948 }
9949 }
9950
9951 void wxGrid::DeselectCell( int row, int col )
9952 {
9953 if ( m_selection && m_selection->IsInSelection(row, col) )
9954 m_selection->ToggleCellSelection(row, col);
9955 }
9956
9957 bool wxGrid::IsSelection()
9958 {
9959 return ( m_selection && (m_selection->IsSelection() ||
9960 ( m_selectingTopLeft != wxGridNoCellCoords &&
9961 m_selectingBottomRight != wxGridNoCellCoords) ) );
9962 }
9963
9964 bool wxGrid::IsInSelection( int row, int col ) const
9965 {
9966 return ( m_selection && (m_selection->IsInSelection( row, col ) ||
9967 ( row >= m_selectingTopLeft.GetRow() &&
9968 col >= m_selectingTopLeft.GetCol() &&
9969 row <= m_selectingBottomRight.GetRow() &&
9970 col <= m_selectingBottomRight.GetCol() )) );
9971 }
9972
9973 wxGridCellCoordsArray wxGrid::GetSelectedCells() const
9974 {
9975 if (!m_selection) { wxGridCellCoordsArray a; return a; }
9976 return m_selection->m_cellSelection;
9977 }
9978 wxGridCellCoordsArray wxGrid::GetSelectionBlockTopLeft() const
9979 {
9980 if (!m_selection) { wxGridCellCoordsArray a; return a; }
9981 return m_selection->m_blockSelectionTopLeft;
9982 }
9983 wxGridCellCoordsArray wxGrid::GetSelectionBlockBottomRight() const
9984 {
9985 if (!m_selection) { wxGridCellCoordsArray a; return a; }
9986 return m_selection->m_blockSelectionBottomRight;
9987 }
9988 wxArrayInt wxGrid::GetSelectedRows() const
9989 {
9990 if (!m_selection) { wxArrayInt a; return a; }
9991 return m_selection->m_rowSelection;
9992 }
9993 wxArrayInt wxGrid::GetSelectedCols() const
9994 {
9995 if (!m_selection) { wxArrayInt a; return a; }
9996 return m_selection->m_colSelection;
9997 }
9998
9999
10000 void wxGrid::ClearSelection()
10001 {
10002 m_selectingTopLeft = wxGridNoCellCoords;
10003 m_selectingBottomRight = wxGridNoCellCoords;
10004 if ( m_selection )
10005 m_selection->ClearSelection();
10006 }
10007
10008
10009 // This function returns the rectangle that encloses the given block
10010 // in device coords clipped to the client size of the grid window.
10011 //
10012 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
10013 const wxGridCellCoords &bottomRight )
10014 {
10015 wxRect rect( wxGridNoCellRect );
10016 wxRect cellRect;
10017
10018 cellRect = CellToRect( topLeft );
10019 if ( cellRect != wxGridNoCellRect )
10020 {
10021 rect = cellRect;
10022 }
10023 else
10024 {
10025 rect = wxRect( 0, 0, 0, 0 );
10026 }
10027
10028 cellRect = CellToRect( bottomRight );
10029 if ( cellRect != wxGridNoCellRect )
10030 {
10031 rect += cellRect;
10032 }
10033 else
10034 {
10035 return wxGridNoCellRect;
10036 }
10037
10038 int i, j;
10039 int left = rect.GetLeft();
10040 int top = rect.GetTop();
10041 int right = rect.GetRight();
10042 int bottom = rect.GetBottom();
10043
10044 int leftCol = topLeft.GetCol();
10045 int topRow = topLeft.GetRow();
10046 int rightCol = bottomRight.GetCol();
10047 int bottomRow = bottomRight.GetRow();
10048
10049 if (left > right)
10050 {
10051 i = left;
10052 left = right;
10053 right = i;
10054 i = leftCol;
10055 leftCol=rightCol;
10056 rightCol = i;
10057 }
10058
10059 if (top > bottom)
10060 {
10061 i = top;
10062 top = bottom;
10063 bottom = i;
10064 i = topRow;
10065 topRow = bottomRow;
10066 bottomRow = i;
10067 }
10068
10069
10070 for ( j = topRow; j <= bottomRow; j++ )
10071 {
10072 for ( i = leftCol; i <= rightCol; i++ )
10073 {
10074 if ((j==topRow) || (j==bottomRow) || (i==leftCol) || (i==rightCol))
10075 {
10076 cellRect = CellToRect( j, i );
10077
10078 if (cellRect.x < left)
10079 left = cellRect.x;
10080 if (cellRect.y < top)
10081 top = cellRect.y;
10082 if (cellRect.x + cellRect.width > right)
10083 right = cellRect.x + cellRect.width;
10084 if (cellRect.y + cellRect.height > bottom)
10085 bottom = cellRect.y + cellRect.height;
10086 }
10087 else i = rightCol; // jump over inner cells.
10088 }
10089 }
10090
10091 // convert to scrolled coords
10092 //
10093 CalcScrolledPosition( left, top, &left, &top );
10094 CalcScrolledPosition( right, bottom, &right, &bottom );
10095
10096 int cw, ch;
10097 m_gridWin->GetClientSize( &cw, &ch );
10098
10099 if (right < 0 || bottom < 0 || left > cw || top > ch)
10100 return wxRect( 0, 0, 0, 0);
10101
10102 rect.SetLeft( wxMax(0, left) );
10103 rect.SetTop( wxMax(0, top) );
10104 rect.SetRight( wxMin(cw, right) );
10105 rect.SetBottom( wxMin(ch, bottom) );
10106
10107 return rect;
10108 }
10109
10110 //
10111 // ------ Grid event classes
10112 //
10113
10114 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
10115
10116 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
10117 int row, int col, int x, int y, bool sel,
10118 bool control, bool shift, bool alt, bool meta )
10119 : wxNotifyEvent( type, id )
10120 {
10121 m_row = row;
10122 m_col = col;
10123 m_x = x;
10124 m_y = y;
10125 m_selecting = sel;
10126 m_control = control;
10127 m_shift = shift;
10128 m_alt = alt;
10129 m_meta = meta;
10130
10131 SetEventObject(obj);
10132 }
10133
10134
10135 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
10136
10137 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
10138 int rowOrCol, int x, int y,
10139 bool control, bool shift, bool alt, bool meta )
10140 : wxNotifyEvent( type, id )
10141 {
10142 m_rowOrCol = rowOrCol;
10143 m_x = x;
10144 m_y = y;
10145 m_control = control;
10146 m_shift = shift;
10147 m_alt = alt;
10148 m_meta = meta;
10149
10150 SetEventObject(obj);
10151 }
10152
10153
10154 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
10155
10156 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
10157 const wxGridCellCoords& topLeft,
10158 const wxGridCellCoords& bottomRight,
10159 bool sel, bool control,
10160 bool shift, bool alt, bool meta )
10161 : wxNotifyEvent( type, id )
10162 {
10163 m_topLeft = topLeft;
10164 m_bottomRight = bottomRight;
10165 m_selecting = sel;
10166 m_control = control;
10167 m_shift = shift;
10168 m_alt = alt;
10169 m_meta = meta;
10170
10171 SetEventObject(obj);
10172 }
10173
10174
10175 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
10176
10177 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
10178 wxObject* obj, int row,
10179 int col, wxControl* ctrl)
10180 : wxCommandEvent(type, id)
10181 {
10182 SetEventObject(obj);
10183 m_row = row;
10184 m_col = col;
10185 m_ctrl = ctrl;
10186 }
10187
10188 #endif // wxUSE_GRID
10189
wxWidgets (Impactor)