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