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