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