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