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