]> 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
don't set virtual size of the window to (0, 0) if scrollbars are removed from it
[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
147 DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
148 DECLARE_EVENT_TABLE()
149 DECLARE_NO_COPY_CLASS(wxGridRowLabelWindow)
150 };
151
152
153 class WXDLLIMPEXP_ADV wxGridColLabelWindow : public wxWindow
154 {
155 public:
156 wxGridColLabelWindow() { m_owner = (wxGrid *)NULL; }
157 wxGridColLabelWindow( wxGrid *parent, wxWindowID id,
158 const wxPoint &pos, const wxSize &size );
159
160 private:
161 wxGrid *m_owner;
162
163 void OnPaint( wxPaintEvent &event );
164 void OnMouseEvent( wxMouseEvent& event );
165 void OnMouseWheel( wxMouseEvent& event );
166 void OnKeyDown( wxKeyEvent& event );
167 void OnKeyUp( wxKeyEvent& );
168
169 DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
170 DECLARE_EVENT_TABLE()
171 DECLARE_NO_COPY_CLASS(wxGridColLabelWindow)
172 };
173
174
175 class WXDLLIMPEXP_ADV wxGridCornerLabelWindow : public wxWindow
176 {
177 public:
178 wxGridCornerLabelWindow() { m_owner = (wxGrid *)NULL; }
179 wxGridCornerLabelWindow( wxGrid *parent, wxWindowID id,
180 const wxPoint &pos, const wxSize &size );
181
182 private:
183 wxGrid *m_owner;
184
185 void OnMouseEvent( wxMouseEvent& event );
186 void OnMouseWheel( wxMouseEvent& event );
187 void OnKeyDown( wxKeyEvent& event );
188 void OnKeyUp( wxKeyEvent& );
189 void OnPaint( wxPaintEvent& event );
190
191 DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
192 DECLARE_EVENT_TABLE()
193 DECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow)
194 };
195
196 class WXDLLIMPEXP_ADV wxGridWindow : public wxWindow
197 {
198 public:
199 wxGridWindow()
200 {
201 m_owner = (wxGrid *)NULL;
202 m_rowLabelWin = (wxGridRowLabelWindow *)NULL;
203 m_colLabelWin = (wxGridColLabelWindow *)NULL;
204 }
205
206 wxGridWindow( wxGrid *parent,
207 wxGridRowLabelWindow *rowLblWin,
208 wxGridColLabelWindow *colLblWin,
209 wxWindowID id, const wxPoint &pos, const wxSize &size );
210 ~wxGridWindow(){}
211
212 void ScrollWindow( int dx, int dy, const wxRect *rect );
213
214 wxGrid* GetOwner() { return m_owner; }
215
216 private:
217 wxGrid *m_owner;
218 wxGridRowLabelWindow *m_rowLabelWin;
219 wxGridColLabelWindow *m_colLabelWin;
220
221 void OnPaint( wxPaintEvent &event );
222 void OnMouseWheel( wxMouseEvent& event );
223 void OnMouseEvent( wxMouseEvent& event );
224 void OnKeyDown( wxKeyEvent& );
225 void OnKeyUp( wxKeyEvent& );
226 void OnEraseBackground( wxEraseEvent& );
227 void OnFocus( wxFocusEvent& );
228
229 DECLARE_DYNAMIC_CLASS(wxGridWindow)
230 DECLARE_EVENT_TABLE()
231 DECLARE_NO_COPY_CLASS(wxGridWindow)
232 };
233
234
235
236 class wxGridCellEditorEvtHandler : public wxEvtHandler
237 {
238 public:
239 wxGridCellEditorEvtHandler()
240 : m_grid(0), m_editor(0)
241 { }
242 wxGridCellEditorEvtHandler(wxGrid* grid, wxGridCellEditor* editor)
243 : m_grid(grid), m_editor(editor)
244 { }
245
246 void OnKeyDown(wxKeyEvent& event);
247 void OnChar(wxKeyEvent& event);
248
249 private:
250 wxGrid* m_grid;
251 wxGridCellEditor* m_editor;
252 DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
253 DECLARE_EVENT_TABLE()
254 DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler)
255 };
256
257
258 IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler, wxEvtHandler )
259 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
260 EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
261 EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )
262 END_EVENT_TABLE()
263
264
265
266 // ----------------------------------------------------------------------------
267 // the internal data representation used by wxGridCellAttrProvider
268 // ----------------------------------------------------------------------------
269
270 // this class stores attributes set for cells
271 class WXDLLIMPEXP_ADV wxGridCellAttrData
272 {
273 public:
274 void SetAttr(wxGridCellAttr *attr, int row, int col);
275 wxGridCellAttr *GetAttr(int row, int col) const;
276 void UpdateAttrRows( size_t pos, int numRows );
277 void UpdateAttrCols( size_t pos, int numCols );
278
279 private:
280 // searches for the attr for given cell, returns wxNOT_FOUND if not found
281 int FindIndex(int row, int col) const;
282
283 wxGridCellWithAttrArray m_attrs;
284 };
285
286 // this class stores attributes set for rows or columns
287 class WXDLLIMPEXP_ADV wxGridRowOrColAttrData
288 {
289 public:
290 // empty ctor to suppress warnings
291 wxGridRowOrColAttrData() { }
292 ~wxGridRowOrColAttrData();
293
294 void SetAttr(wxGridCellAttr *attr, int rowOrCol);
295 wxGridCellAttr *GetAttr(int rowOrCol) const;
296 void UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols );
297
298 private:
299 wxArrayInt m_rowsOrCols;
300 wxArrayAttrs m_attrs;
301 };
302
303 // NB: this is just a wrapper around 3 objects: one which stores cell
304 // attributes, and 2 others for row/col ones
305 class WXDLLIMPEXP_ADV wxGridCellAttrProviderData
306 {
307 public:
308 wxGridCellAttrData m_cellAttrs;
309 wxGridRowOrColAttrData m_rowAttrs,
310 m_colAttrs;
311 };
312
313
314 // ----------------------------------------------------------------------------
315 // data structures used for the data type registry
316 // ----------------------------------------------------------------------------
317
318 struct wxGridDataTypeInfo
319 {
320 wxGridDataTypeInfo(const wxString& typeName,
321 wxGridCellRenderer* renderer,
322 wxGridCellEditor* editor)
323 : m_typeName(typeName), m_renderer(renderer), m_editor(editor)
324 { }
325
326 ~wxGridDataTypeInfo()
327 {
328 wxSafeDecRef(m_renderer);
329 wxSafeDecRef(m_editor);
330 }
331
332 wxString m_typeName;
333 wxGridCellRenderer* m_renderer;
334 wxGridCellEditor* m_editor;
335
336 DECLARE_NO_COPY_CLASS(wxGridDataTypeInfo)
337 };
338
339
340 WX_DEFINE_ARRAY_WITH_DECL_PTR(wxGridDataTypeInfo*, wxGridDataTypeInfoArray,
341 class WXDLLIMPEXP_ADV);
342
343
344 class WXDLLIMPEXP_ADV wxGridTypeRegistry
345 {
346 public:
347 wxGridTypeRegistry() {}
348 ~wxGridTypeRegistry();
349
350 void RegisterDataType(const wxString& typeName,
351 wxGridCellRenderer* renderer,
352 wxGridCellEditor* editor);
353
354 // find one of already registered data types
355 int FindRegisteredDataType(const wxString& typeName);
356
357 // try to FindRegisteredDataType(), if this fails and typeName is one of
358 // standard typenames, register it and return its index
359 int FindDataType(const wxString& typeName);
360
361 // try to FindDataType(), if it fails see if it is not one of already
362 // registered data types with some params in which case clone the
363 // registered data type and set params for it
364 int FindOrCloneDataType(const wxString& typeName);
365
366 wxGridCellRenderer* GetRenderer(int index);
367 wxGridCellEditor* GetEditor(int index);
368
369 private:
370 wxGridDataTypeInfoArray m_typeinfo;
371 };
372
373 // ----------------------------------------------------------------------------
374 // conditional compilation
375 // ----------------------------------------------------------------------------
376
377 #ifndef WXGRID_DRAW_LINES
378 #define WXGRID_DRAW_LINES 1
379 #endif
380
381 // ----------------------------------------------------------------------------
382 // globals
383 // ----------------------------------------------------------------------------
384
385 //#define DEBUG_ATTR_CACHE
386 #ifdef DEBUG_ATTR_CACHE
387 static size_t gs_nAttrCacheHits = 0;
388 static size_t gs_nAttrCacheMisses = 0;
389 #endif // DEBUG_ATTR_CACHE
390
391 // ----------------------------------------------------------------------------
392 // constants
393 // ----------------------------------------------------------------------------
394
395 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
396 wxRect wxGridNoCellRect( -1, -1, -1, -1 );
397
398 // scroll line size
399 // TODO: this doesn't work at all, grid cells have different sizes and approx
400 // calculations don't work as because of the size mismatch scrollbars
401 // sometimes fail to be shown when they should be or vice versa
402 //
403 // The scroll bars may be a little flakey once in a while, but that is
404 // surely much less horrible than having scroll lines of only 1!!!
405 // -- Robin
406 //
407 // Well, it's still seriously broken so it might be better but needs
408 // fixing anyhow
409 // -- Vadim
410 static const size_t GRID_SCROLL_LINE_X = 15; // 1;
411 static const size_t GRID_SCROLL_LINE_Y = GRID_SCROLL_LINE_X;
412
413 // the size of hash tables used a bit everywhere (the max number of elements
414 // in these hash tables is the number of rows/columns)
415 static const int GRID_HASH_SIZE = 100;
416
417 #if 0
418 // ----------------------------------------------------------------------------
419 // private functions
420 // ----------------------------------------------------------------------------
421
422 static inline int GetScrollX(int x)
423 {
424 return (x + GRID_SCROLL_LINE_X - 1) / GRID_SCROLL_LINE_X;
425 }
426
427 static inline int GetScrollY(int y)
428 {
429 return (y + GRID_SCROLL_LINE_Y - 1) / GRID_SCROLL_LINE_Y;
430 }
431 #endif
432
433 // ============================================================================
434 // implementation
435 // ============================================================================
436
437 // ----------------------------------------------------------------------------
438 // wxGridCellEditor
439 // ----------------------------------------------------------------------------
440
441 wxGridCellEditor::wxGridCellEditor()
442 {
443 m_control = NULL;
444 m_attr = NULL;
445 }
446
447
448 wxGridCellEditor::~wxGridCellEditor()
449 {
450 Destroy();
451 }
452
453 void wxGridCellEditor::Create(wxWindow* WXUNUSED(parent),
454 wxWindowID WXUNUSED(id),
455 wxEvtHandler* evtHandler)
456 {
457 if ( evtHandler )
458 m_control->PushEventHandler(evtHandler);
459 }
460
461 void wxGridCellEditor::PaintBackground(const wxRect& rectCell,
462 wxGridCellAttr *attr)
463 {
464 // erase the background because we might not fill the cell
465 wxClientDC dc(m_control->GetParent());
466 wxGridWindow* gridWindow = wxDynamicCast(m_control->GetParent(), wxGridWindow);
467 if (gridWindow)
468 gridWindow->GetOwner()->PrepareDC(dc);
469
470 dc.SetPen(*wxTRANSPARENT_PEN);
471 dc.SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
472 dc.DrawRectangle(rectCell);
473
474 // redraw the control we just painted over
475 m_control->Refresh();
476 }
477
478 void wxGridCellEditor::Destroy()
479 {
480 if (m_control)
481 {
482 m_control->PopEventHandler(true /* delete it*/);
483
484 m_control->Destroy();
485 m_control = NULL;
486 }
487 }
488
489 void wxGridCellEditor::Show(bool show, wxGridCellAttr *attr)
490 {
491 wxASSERT_MSG(m_control,
492 wxT("The wxGridCellEditor must be Created first!"));
493 m_control->Show(show);
494
495 if ( show )
496 {
497 // set the colours/fonts if we have any
498 if ( attr )
499 {
500 m_colFgOld = m_control->GetForegroundColour();
501 m_control->SetForegroundColour(attr->GetTextColour());
502
503 m_colBgOld = m_control->GetBackgroundColour();
504 m_control->SetBackgroundColour(attr->GetBackgroundColour());
505
506 // Workaround for GTK+1 font setting problem on some platforms
507 #if !defined(__WXGTK__) || defined(__WXGTK20__)
508 m_fontOld = m_control->GetFont();
509 m_control->SetFont(attr->GetFont());
510 #endif
511 // can't do anything more in the base class version, the other
512 // attributes may only be used by the derived classes
513 }
514 }
515 else
516 {
517 // restore the standard colours fonts
518 if ( m_colFgOld.Ok() )
519 {
520 m_control->SetForegroundColour(m_colFgOld);
521 m_colFgOld = wxNullColour;
522 }
523
524 if ( m_colBgOld.Ok() )
525 {
526 m_control->SetBackgroundColour(m_colBgOld);
527 m_colBgOld = wxNullColour;
528 }
529 // Workaround for GTK+1 font setting problem on some platforms
530 #if !defined(__WXGTK__) || defined(__WXGTK20__)
531 if ( m_fontOld.Ok() )
532 {
533 m_control->SetFont(m_fontOld);
534 m_fontOld = wxNullFont;
535 }
536 #endif
537 }
538 }
539
540 void wxGridCellEditor::SetSize(const wxRect& rect)
541 {
542 wxASSERT_MSG(m_control,
543 wxT("The wxGridCellEditor must be Created first!"));
544 m_control->SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);
545 }
546
547 void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
548 {
549 event.Skip();
550 }
551
552 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
553 {
554 // accept the simple key presses, not anything with Ctrl/Alt/Meta
555 return !(event.ControlDown() || event.AltDown() || event.GetKeyCode() == WXK_SHIFT);
556 }
557
558 void wxGridCellEditor::StartingKey(wxKeyEvent& event)
559 {
560 event.Skip();
561 }
562
563 void wxGridCellEditor::StartingClick()
564 {
565 }
566
567 #if wxUSE_TEXTCTRL
568
569 // ----------------------------------------------------------------------------
570 // wxGridCellTextEditor
571 // ----------------------------------------------------------------------------
572
573 wxGridCellTextEditor::wxGridCellTextEditor()
574 {
575 m_maxChars = 0;
576 }
577
578 void wxGridCellTextEditor::Create(wxWindow* parent,
579 wxWindowID id,
580 wxEvtHandler* evtHandler)
581 {
582 m_control = new wxTextCtrl(parent, id, wxEmptyString,
583 wxDefaultPosition, wxDefaultSize
584 #if defined(__WXMSW__)
585 , wxTE_PROCESS_TAB | wxTE_AUTO_SCROLL
586 #endif
587 );
588
589 // set max length allowed in the textctrl, if the parameter was set
590 if (m_maxChars != 0)
591 {
592 ((wxTextCtrl*)m_control)->SetMaxLength(m_maxChars);
593 }
594
595 wxGridCellEditor::Create(parent, id, evtHandler);
596 }
597
598 void wxGridCellTextEditor::PaintBackground(const wxRect& WXUNUSED(rectCell),
599 wxGridCellAttr * WXUNUSED(attr))
600 {
601 // as we fill the entire client area, don't do anything here to minimize
602 // flicker
603 }
604
605 void wxGridCellTextEditor::SetSize(const wxRect& rectOrig)
606 {
607 wxRect rect(rectOrig);
608
609 // Make the edit control large enough to allow for internal
610 // margins
611 //
612 // TODO: remove this if the text ctrl sizing is improved esp. for
613 // unix
614 //
615 #if defined(__WXGTK__)
616 if (rect.x != 0)
617 {
618 rect.x += 1;
619 rect.y += 1;
620 rect.width -= 1;
621 rect.height -= 1;
622 }
623 #else // !GTK
624 int extra_x = ( rect.x > 2 )? 2 : 1;
625
626 // MB: treat MSW separately here otherwise the caret doesn't show
627 // when the editor is in the first row.
628 #if defined(__WXMSW__)
629 int extra_y = 2;
630 #else
631 int extra_y = ( rect.y > 2 )? 2 : 1;
632 #endif // MSW
633
634 #if defined(__WXMOTIF__)
635 extra_x *= 2;
636 extra_y *= 2;
637 #endif
638 rect.SetLeft( wxMax(0, rect.x - extra_x) );
639 rect.SetTop( wxMax(0, rect.y - extra_y) );
640 rect.SetRight( rect.GetRight() + 2*extra_x );
641 rect.SetBottom( rect.GetBottom() + 2*extra_y );
642 #endif // GTK/!GTK
643
644 wxGridCellEditor::SetSize(rect);
645 }
646
647 void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid* grid)
648 {
649 wxASSERT_MSG(m_control,
650 wxT("The wxGridCellEditor must be Created first!"));
651
652 m_startValue = grid->GetTable()->GetValue(row, col);
653
654 DoBeginEdit(m_startValue);
655 }
656
657 void wxGridCellTextEditor::DoBeginEdit(const wxString& startValue)
658 {
659 Text()->SetValue(startValue);
660 Text()->SetInsertionPointEnd();
661 Text()->SetSelection(-1,-1);
662 Text()->SetFocus();
663 }
664
665 bool wxGridCellTextEditor::EndEdit(int row, int col,
666 wxGrid* grid)
667 {
668 wxASSERT_MSG(m_control,
669 wxT("The wxGridCellEditor must be Created first!"));
670
671 bool changed = false;
672 wxString value = Text()->GetValue();
673 if (value != m_startValue)
674 changed = true;
675
676 if (changed)
677 grid->GetTable()->SetValue(row, col, value);
678
679 m_startValue = wxEmptyString;
680 // No point in setting the text of the hidden control
681 //Text()->SetValue(m_startValue);
682
683 return changed;
684 }
685
686
687 void wxGridCellTextEditor::Reset()
688 {
689 wxASSERT_MSG(m_control,
690 wxT("The wxGridCellEditor must be Created first!"));
691
692 DoReset(m_startValue);
693 }
694
695 void wxGridCellTextEditor::DoReset(const wxString& startValue)
696 {
697 Text()->SetValue(startValue);
698 Text()->SetInsertionPointEnd();
699 }
700
701 bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent& event)
702 {
703 if ( wxGridCellEditor::IsAcceptedKey(event) )
704 {
705 int keycode = event.GetKeyCode();
706 switch ( keycode )
707 {
708 case WXK_NUMPAD0:
709 case WXK_NUMPAD1:
710 case WXK_NUMPAD2:
711 case WXK_NUMPAD3:
712 case WXK_NUMPAD4:
713 case WXK_NUMPAD5:
714 case WXK_NUMPAD6:
715 case WXK_NUMPAD7:
716 case WXK_NUMPAD8:
717 case WXK_NUMPAD9:
718 case WXK_MULTIPLY:
719 case WXK_NUMPAD_MULTIPLY:
720 case WXK_ADD:
721 case WXK_NUMPAD_ADD:
722 case WXK_SUBTRACT:
723 case WXK_NUMPAD_SUBTRACT:
724 case WXK_DECIMAL:
725 case WXK_NUMPAD_DECIMAL:
726 case WXK_DIVIDE:
727 case WXK_NUMPAD_DIVIDE:
728 return true;
729
730 default:
731 // accept 8 bit chars too if isprint() agrees
732 if ( (keycode < 255) && (wxIsprint(keycode)) )
733 return true;
734 }
735 }
736
737 return false;
738 }
739
740 void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
741 {
742 if ( !Text()->EmulateKeyPress(event) )
743 {
744 event.Skip();
745 }
746 }
747
748 void wxGridCellTextEditor::HandleReturn( wxKeyEvent&
749 WXUNUSED_GTK(WXUNUSED_MOTIF(event)) )
750 {
751 #if defined(__WXMOTIF__) || defined(__WXGTK__)
752 // wxMotif needs a little extra help...
753 size_t pos = (size_t)( Text()->GetInsertionPoint() );
754 wxString s( Text()->GetValue() );
755 s = s.Left(pos) + wxT("\n") + s.Mid(pos);
756 Text()->SetValue(s);
757 Text()->SetInsertionPoint( pos );
758 #else
759 // the other ports can handle a Return key press
760 //
761 event.Skip();
762 #endif
763 }
764
765 void wxGridCellTextEditor::SetParameters(const wxString& params)
766 {
767 if ( !params )
768 {
769 // reset to default
770 m_maxChars = 0;
771 }
772 else
773 {
774 long tmp;
775 if ( !params.ToLong(&tmp) )
776 {
777 wxLogDebug(_T("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params.c_str());
778 }
779 else
780 {
781 m_maxChars = (size_t)tmp;
782 }
783 }
784 }
785
786 // return the value in the text control
787 wxString wxGridCellTextEditor::GetValue() const
788 {
789 return Text()->GetValue();
790 }
791
792 // ----------------------------------------------------------------------------
793 // wxGridCellNumberEditor
794 // ----------------------------------------------------------------------------
795
796 wxGridCellNumberEditor::wxGridCellNumberEditor(int min, int max)
797 {
798 m_min = min;
799 m_max = max;
800 }
801
802 void wxGridCellNumberEditor::Create(wxWindow* parent,
803 wxWindowID id,
804 wxEvtHandler* evtHandler)
805 {
806 #if wxUSE_SPINCTRL
807 if ( HasRange() )
808 {
809 // create a spin ctrl
810 m_control = new wxSpinCtrl(parent, wxID_ANY, wxEmptyString,
811 wxDefaultPosition, wxDefaultSize,
812 wxSP_ARROW_KEYS,
813 m_min, m_max);
814
815 wxGridCellEditor::Create(parent, id, evtHandler);
816 }
817 else
818 #endif
819 {
820 // just a text control
821 wxGridCellTextEditor::Create(parent, id, evtHandler);
822
823 #if wxUSE_VALIDATORS
824 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
825 #endif // wxUSE_VALIDATORS
826 }
827 }
828
829 void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid* grid)
830 {
831 // first get the value
832 wxGridTableBase *table = grid->GetTable();
833 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
834 {
835 m_valueOld = table->GetValueAsLong(row, col);
836 }
837 else
838 {
839 m_valueOld = 0;
840 wxString sValue = table->GetValue(row, col);
841 if (! sValue.ToLong(&m_valueOld) && ! sValue.empty())
842 {
843 wxFAIL_MSG( _T("this cell doesn't have numeric value") );
844 return;
845 }
846 }
847
848 #if wxUSE_SPINCTRL
849 if ( HasRange() )
850 {
851 Spin()->SetValue((int)m_valueOld);
852 Spin()->SetFocus();
853 }
854 else
855 #endif
856 {
857 DoBeginEdit(GetString());
858 }
859 }
860
861 bool wxGridCellNumberEditor::EndEdit(int row, int col,
862 wxGrid* grid)
863 {
864 bool changed;
865 long value = 0;
866 wxString text;
867
868 #if wxUSE_SPINCTRL
869 if ( HasRange() )
870 {
871 value = Spin()->GetValue();
872 changed = value != m_valueOld;
873 if (changed)
874 text = wxString::Format(wxT("%ld"), value);
875 }
876 else
877 #endif
878 {
879 text = Text()->GetValue();
880 changed = (text.empty() || text.ToLong(&value)) && (value != m_valueOld);
881 }
882
883 if ( changed )
884 {
885 if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER))
886 grid->GetTable()->SetValueAsLong(row, col, value);
887 else
888 grid->GetTable()->SetValue(row, col, text);
889 }
890
891 return changed;
892 }
893
894 void wxGridCellNumberEditor::Reset()
895 {
896 #if wxUSE_SPINCTRL
897 if ( HasRange() )
898 {
899 Spin()->SetValue((int)m_valueOld);
900 }
901 else
902 #endif
903 {
904 DoReset(GetString());
905 }
906 }
907
908 bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent& event)
909 {
910 if ( wxGridCellEditor::IsAcceptedKey(event) )
911 {
912 int keycode = event.GetKeyCode();
913 switch ( keycode )
914 {
915 case WXK_NUMPAD0:
916 case WXK_NUMPAD1:
917 case WXK_NUMPAD2:
918 case WXK_NUMPAD3:
919 case WXK_NUMPAD4:
920 case WXK_NUMPAD5:
921 case WXK_NUMPAD6:
922 case WXK_NUMPAD7:
923 case WXK_NUMPAD8:
924 case WXK_NUMPAD9:
925 case WXK_ADD:
926 case WXK_NUMPAD_ADD:
927 case WXK_SUBTRACT:
928 case WXK_NUMPAD_SUBTRACT:
929 case WXK_UP:
930 case WXK_DOWN:
931 return true;
932
933 default:
934 if ( (keycode < 128) && wxIsdigit(keycode) )
935 return true;
936 }
937 }
938
939 return false;
940 }
941
942 void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
943 {
944 if ( !HasRange() )
945 {
946 int keycode = event.GetKeyCode();
947 if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-'
948 || keycode == WXK_NUMPAD0
949 || keycode == WXK_NUMPAD1
950 || keycode == WXK_NUMPAD2
951 || keycode == WXK_NUMPAD3
952 || keycode == WXK_NUMPAD4
953 || keycode == WXK_NUMPAD5
954 || keycode == WXK_NUMPAD6
955 || keycode == WXK_NUMPAD7
956 || keycode == WXK_NUMPAD8
957 || keycode == WXK_NUMPAD9
958 || keycode == WXK_ADD
959 || keycode == WXK_NUMPAD_ADD
960 || keycode == WXK_SUBTRACT
961 || keycode == WXK_NUMPAD_SUBTRACT)
962 {
963 wxGridCellTextEditor::StartingKey(event);
964
965 // skip Skip() below
966 return;
967 }
968 }
969
970 event.Skip();
971 }
972
973 void wxGridCellNumberEditor::SetParameters(const wxString& params)
974 {
975 if ( !params )
976 {
977 // reset to default
978 m_min =
979 m_max = -1;
980 }
981 else
982 {
983 long tmp;
984 if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
985 {
986 m_min = (int)tmp;
987
988 if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
989 {
990 m_max = (int)tmp;
991
992 // skip the error message below
993 return;
994 }
995 }
996
997 wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params.c_str());
998 }
999 }
1000
1001 // return the value in the spin control if it is there (the text control otherwise)
1002 wxString wxGridCellNumberEditor::GetValue() const
1003 {
1004 wxString s;
1005
1006 #if wxUSE_SPINCTRL
1007 if( HasRange() )
1008 {
1009 long value = Spin()->GetValue();
1010 s.Printf(wxT("%ld"), value);
1011 }
1012 else
1013 #endif
1014 {
1015 s = Text()->GetValue();
1016 }
1017
1018 return s;
1019 }
1020
1021 // ----------------------------------------------------------------------------
1022 // wxGridCellFloatEditor
1023 // ----------------------------------------------------------------------------
1024
1025 wxGridCellFloatEditor::wxGridCellFloatEditor(int width, int precision)
1026 {
1027 m_width = width;
1028 m_precision = precision;
1029 }
1030
1031 void wxGridCellFloatEditor::Create(wxWindow* parent,
1032 wxWindowID id,
1033 wxEvtHandler* evtHandler)
1034 {
1035 wxGridCellTextEditor::Create(parent, id, evtHandler);
1036
1037 #if wxUSE_VALIDATORS
1038 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
1039 #endif // wxUSE_VALIDATORS
1040 }
1041
1042 void wxGridCellFloatEditor::BeginEdit(int row, int col, wxGrid* grid)
1043 {
1044 // first get the value
1045 wxGridTableBase *table = grid->GetTable();
1046 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
1047 {
1048 m_valueOld = table->GetValueAsDouble(row, col);
1049 }
1050 else
1051 {
1052 m_valueOld = 0.0;
1053 wxString sValue = table->GetValue(row, col);
1054 if (! sValue.ToDouble(&m_valueOld) && ! sValue.empty())
1055 {
1056 wxFAIL_MSG( _T("this cell doesn't have float value") );
1057 return;
1058 }
1059 }
1060
1061 DoBeginEdit(GetString());
1062 }
1063
1064 bool wxGridCellFloatEditor::EndEdit(int row, int col,
1065 wxGrid* grid)
1066 {
1067 double value = 0.0;
1068 wxString text(Text()->GetValue());
1069
1070 if ( (text.empty() || text.ToDouble(&value)) && (value != m_valueOld) )
1071 {
1072 if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT))
1073 grid->GetTable()->SetValueAsDouble(row, col, value);
1074 else
1075 grid->GetTable()->SetValue(row, col, text);
1076
1077 return true;
1078 }
1079 return false;
1080 }
1081
1082 void wxGridCellFloatEditor::Reset()
1083 {
1084 DoReset(GetString());
1085 }
1086
1087 void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
1088 {
1089 int keycode = event.GetKeyCode();
1090 char tmpbuf[2];
1091 tmpbuf[0] = (char) keycode;
1092 tmpbuf[1] = '\0';
1093 wxString strbuf(tmpbuf, *wxConvCurrent);
1094 bool is_decimal_point = ( strbuf ==
1095 wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT, wxLOCALE_CAT_NUMBER) );
1096 if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-'
1097 || is_decimal_point
1098 || keycode == WXK_NUMPAD0
1099 || keycode == WXK_NUMPAD1
1100 || keycode == WXK_NUMPAD2
1101 || keycode == WXK_NUMPAD3
1102 || keycode == WXK_NUMPAD4
1103 || keycode == WXK_NUMPAD5
1104 || keycode == WXK_NUMPAD6
1105 || keycode == WXK_NUMPAD7
1106 || keycode == WXK_NUMPAD8
1107 || keycode == WXK_NUMPAD9
1108 || keycode == WXK_ADD
1109 || keycode == WXK_NUMPAD_ADD
1110 || keycode == WXK_SUBTRACT
1111 || keycode == WXK_NUMPAD_SUBTRACT)
1112 {
1113 wxGridCellTextEditor::StartingKey(event);
1114
1115 // skip Skip() below
1116 return;
1117 }
1118
1119 event.Skip();
1120 }
1121
1122 void wxGridCellFloatEditor::SetParameters(const wxString& params)
1123 {
1124 if ( !params )
1125 {
1126 // reset to default
1127 m_width =
1128 m_precision = -1;
1129 }
1130 else
1131 {
1132 long tmp;
1133 if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
1134 {
1135 m_width = (int)tmp;
1136
1137 if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
1138 {
1139 m_precision = (int)tmp;
1140
1141 // skip the error message below
1142 return;
1143 }
1144 }
1145
1146 wxLogDebug(_T("Invalid wxGridCellFloatEditor parameter string '%s' ignored"), params.c_str());
1147 }
1148 }
1149
1150 wxString wxGridCellFloatEditor::GetString() const
1151 {
1152 wxString fmt;
1153 if ( m_width == -1 )
1154 {
1155 // default width/precision
1156 fmt = _T("%f");
1157 }
1158 else if ( m_precision == -1 )
1159 {
1160 // default precision
1161 fmt.Printf(_T("%%%d.f"), m_width);
1162 }
1163 else
1164 {
1165 fmt.Printf(_T("%%%d.%df"), m_width, m_precision);
1166 }
1167
1168 return wxString::Format(fmt, m_valueOld);
1169 }
1170
1171 bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
1172 {
1173 if ( wxGridCellEditor::IsAcceptedKey(event) )
1174 {
1175 int keycode = event.GetKeyCode();
1176 switch ( keycode )
1177 {
1178 case WXK_NUMPAD0:
1179 case WXK_NUMPAD1:
1180 case WXK_NUMPAD2:
1181 case WXK_NUMPAD3:
1182 case WXK_NUMPAD4:
1183 case WXK_NUMPAD5:
1184 case WXK_NUMPAD6:
1185 case WXK_NUMPAD7:
1186 case WXK_NUMPAD8:
1187 case WXK_NUMPAD9:
1188 case WXK_ADD:
1189 case WXK_NUMPAD_ADD:
1190 case WXK_SUBTRACT:
1191 case WXK_NUMPAD_SUBTRACT:
1192 case WXK_DECIMAL:
1193 case WXK_NUMPAD_DECIMAL:
1194 return true;
1195
1196 default:
1197 {
1198 // additionally accept 'e' as in '1e+6', also '-', '+', and '.'
1199 char tmpbuf[2];
1200 tmpbuf[0] = (char) keycode;
1201 tmpbuf[1] = '\0';
1202 wxString strbuf(tmpbuf, *wxConvCurrent);
1203 bool is_decimal_point =
1204 ( strbuf == wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT,
1205 wxLOCALE_CAT_NUMBER) );
1206 if ( (keycode < 128) &&
1207 (wxIsdigit(keycode) || tolower(keycode) == 'e' ||
1208 is_decimal_point || keycode == '+' || keycode == '-') )
1209 return true;
1210 }
1211 }
1212 }
1213
1214 return false;
1215 }
1216
1217 #endif // wxUSE_TEXTCTRL
1218
1219 #if wxUSE_CHECKBOX
1220
1221 // ----------------------------------------------------------------------------
1222 // wxGridCellBoolEditor
1223 // ----------------------------------------------------------------------------
1224
1225 void wxGridCellBoolEditor::Create(wxWindow* parent,
1226 wxWindowID id,
1227 wxEvtHandler* evtHandler)
1228 {
1229 m_control = new wxCheckBox(parent, id, wxEmptyString,
1230 wxDefaultPosition, wxDefaultSize,
1231 wxNO_BORDER);
1232
1233 wxGridCellEditor::Create(parent, id, evtHandler);
1234 }
1235
1236 void wxGridCellBoolEditor::SetSize(const wxRect& r)
1237 {
1238 bool resize = false;
1239 wxSize size = m_control->GetSize();
1240 wxCoord minSize = wxMin(r.width, r.height);
1241
1242 // check if the checkbox is not too big/small for this cell
1243 wxSize sizeBest = m_control->GetBestSize();
1244 if ( !(size == sizeBest) )
1245 {
1246 // reset to default size if it had been made smaller
1247 size = sizeBest;
1248
1249 resize = true;
1250 }
1251
1252 if ( size.x >= minSize || size.y >= minSize )
1253 {
1254 // leave 1 pixel margin
1255 size.x = size.y = minSize - 2;
1256
1257 resize = true;
1258 }
1259
1260 if ( resize )
1261 {
1262 m_control->SetSize(size);
1263 }
1264
1265 // position it in the centre of the rectangle (TODO: support alignment?)
1266
1267 #if defined(__WXGTK__) || defined (__WXMOTIF__)
1268 // the checkbox without label still has some space to the right in wxGTK,
1269 // so shift it to the right
1270 size.x -= 8;
1271 #elif defined(__WXMSW__)
1272 // here too, but in other way
1273 size.x += 1;
1274 size.y -= 2;
1275 #endif
1276
1277 int hAlign = wxALIGN_CENTRE;
1278 int vAlign = wxALIGN_CENTRE;
1279 if (GetCellAttr())
1280 GetCellAttr()->GetAlignment(& hAlign, & vAlign);
1281
1282 int x = 0, y = 0;
1283 if (hAlign == wxALIGN_LEFT)
1284 {
1285 x = r.x + 2;
1286 #ifdef __WXMSW__
1287 x += 2;
1288 #endif
1289 y = r.y + r.height/2 - size.y/2;
1290 }
1291 else if (hAlign == wxALIGN_RIGHT)
1292 {
1293 x = r.x + r.width - size.x - 2;
1294 y = r.y + r.height/2 - size.y/2;
1295 }
1296 else if (hAlign == wxALIGN_CENTRE)
1297 {
1298 x = r.x + r.width/2 - size.x/2;
1299 y = r.y + r.height/2 - size.y/2;
1300 }
1301
1302 m_control->Move(x, y);
1303 }
1304
1305 void wxGridCellBoolEditor::Show(bool show, wxGridCellAttr *attr)
1306 {
1307 m_control->Show(show);
1308
1309 if ( show )
1310 {
1311 wxColour colBg = attr ? attr->GetBackgroundColour() : *wxLIGHT_GREY;
1312 CBox()->SetBackgroundColour(colBg);
1313 }
1314 }
1315
1316 void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
1317 {
1318 wxASSERT_MSG(m_control,
1319 wxT("The wxGridCellEditor must be Created first!"));
1320
1321 if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
1322 m_startValue = grid->GetTable()->GetValueAsBool(row, col);
1323 else
1324 {
1325 wxString cellval( grid->GetTable()->GetValue(row, col) );
1326 m_startValue = !( !cellval || (cellval == wxT("0")) );
1327 }
1328 CBox()->SetValue(m_startValue);
1329 CBox()->SetFocus();
1330 }
1331
1332 bool wxGridCellBoolEditor::EndEdit(int row, int col,
1333 wxGrid* grid)
1334 {
1335 wxASSERT_MSG(m_control,
1336 wxT("The wxGridCellEditor must be Created first!"));
1337
1338 bool changed = false;
1339 bool value = CBox()->GetValue();
1340 if ( value != m_startValue )
1341 changed = true;
1342
1343 if ( changed )
1344 {
1345 if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
1346 grid->GetTable()->SetValueAsBool(row, col, value);
1347 else
1348 grid->GetTable()->SetValue(row, col, value ? _T("1") : wxEmptyString);
1349 }
1350
1351 return changed;
1352 }
1353
1354 void wxGridCellBoolEditor::Reset()
1355 {
1356 wxASSERT_MSG(m_control,
1357 wxT("The wxGridCellEditor must be Created first!"));
1358
1359 CBox()->SetValue(m_startValue);
1360 }
1361
1362 void wxGridCellBoolEditor::StartingClick()
1363 {
1364 CBox()->SetValue(!CBox()->GetValue());
1365 }
1366
1367 bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent& event)
1368 {
1369 if ( wxGridCellEditor::IsAcceptedKey(event) )
1370 {
1371 int keycode = event.GetKeyCode();
1372 switch ( keycode )
1373 {
1374 case WXK_MULTIPLY:
1375 case WXK_NUMPAD_MULTIPLY:
1376 case WXK_ADD:
1377 case WXK_NUMPAD_ADD:
1378 case WXK_SUBTRACT:
1379 case WXK_NUMPAD_SUBTRACT:
1380 case WXK_SPACE:
1381 case '+':
1382 case '-':
1383 return true;
1384 }
1385 }
1386
1387 return false;
1388 }
1389
1390 // return the value as "1" for true and the empty string for false
1391 wxString wxGridCellBoolEditor::GetValue() const
1392 {
1393 bool bSet = CBox()->GetValue();
1394 return bSet ? _T("1") : wxEmptyString;
1395 }
1396
1397 #endif // wxUSE_CHECKBOX
1398
1399 #if wxUSE_COMBOBOX
1400
1401 // ----------------------------------------------------------------------------
1402 // wxGridCellChoiceEditor
1403 // ----------------------------------------------------------------------------
1404
1405 wxGridCellChoiceEditor::wxGridCellChoiceEditor(const wxArrayString& choices,
1406 bool allowOthers)
1407 : m_choices(choices),
1408 m_allowOthers(allowOthers) { }
1409
1410 wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count,
1411 const wxString choices[],
1412 bool allowOthers)
1413 : m_allowOthers(allowOthers)
1414 {
1415 if ( count )
1416 {
1417 m_choices.Alloc(count);
1418 for ( size_t n = 0; n < count; n++ )
1419 {
1420 m_choices.Add(choices[n]);
1421 }
1422 }
1423 }
1424
1425 wxGridCellEditor *wxGridCellChoiceEditor::Clone() const
1426 {
1427 wxGridCellChoiceEditor *editor = new wxGridCellChoiceEditor;
1428 editor->m_allowOthers = m_allowOthers;
1429 editor->m_choices = m_choices;
1430
1431 return editor;
1432 }
1433
1434 void wxGridCellChoiceEditor::Create(wxWindow* parent,
1435 wxWindowID id,
1436 wxEvtHandler* evtHandler)
1437 {
1438 m_control = new wxComboBox(parent, id, wxEmptyString,
1439 wxDefaultPosition, wxDefaultSize,
1440 m_choices,
1441 m_allowOthers ? 0 : wxCB_READONLY);
1442
1443 wxGridCellEditor::Create(parent, id, evtHandler);
1444 }
1445
1446 void wxGridCellChoiceEditor::PaintBackground(const wxRect& rectCell,
1447 wxGridCellAttr * attr)
1448 {
1449 // as we fill the entire client area, don't do anything here to minimize
1450 // flicker
1451
1452 // TODO: It doesn't actually fill the client area since the height of a
1453 // combo always defaults to the standard... Until someone has time to
1454 // figure out the right rectangle to paint, just do it the normal way...
1455 wxGridCellEditor::PaintBackground(rectCell, attr);
1456 }
1457
1458 void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid* grid)
1459 {
1460 wxASSERT_MSG(m_control,
1461 wxT("The wxGridCellEditor must be Created first!"));
1462
1463 m_startValue = grid->GetTable()->GetValue(row, col);
1464
1465 if (m_allowOthers)
1466 Combo()->SetValue(m_startValue);
1467 else
1468 {
1469 // find the right position, or default to the first if not found
1470 int pos = Combo()->FindString(m_startValue);
1471 if (pos == -1)
1472 pos = 0;
1473 Combo()->SetSelection(pos);
1474 }
1475 Combo()->SetInsertionPointEnd();
1476 Combo()->SetFocus();
1477 }
1478
1479 bool wxGridCellChoiceEditor::EndEdit(int row, int col,
1480 wxGrid* grid)
1481 {
1482 wxString value = Combo()->GetValue();
1483 if ( value == m_startValue )
1484 return false;
1485
1486 grid->GetTable()->SetValue(row, col, value);
1487
1488 return true;
1489 }
1490
1491 void wxGridCellChoiceEditor::Reset()
1492 {
1493 Combo()->SetValue(m_startValue);
1494 Combo()->SetInsertionPointEnd();
1495 }
1496
1497 void wxGridCellChoiceEditor::SetParameters(const wxString& params)
1498 {
1499 if ( !params )
1500 {
1501 // what can we do?
1502 return;
1503 }
1504
1505 m_choices.Empty();
1506
1507 wxStringTokenizer tk(params, _T(','));
1508 while ( tk.HasMoreTokens() )
1509 {
1510 m_choices.Add(tk.GetNextToken());
1511 }
1512 }
1513
1514 // return the value in the text control
1515 wxString wxGridCellChoiceEditor::GetValue() const
1516 {
1517 return Combo()->GetValue();
1518 }
1519
1520 #endif // wxUSE_COMBOBOX
1521
1522 // ----------------------------------------------------------------------------
1523 // wxGridCellEditorEvtHandler
1524 // ----------------------------------------------------------------------------
1525
1526 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
1527 {
1528 switch ( event.GetKeyCode() )
1529 {
1530 case WXK_ESCAPE:
1531 m_editor->Reset();
1532 m_grid->DisableCellEditControl();
1533 break;
1534
1535 case WXK_TAB:
1536 m_grid->GetEventHandler()->ProcessEvent( event );
1537 break;
1538
1539 case WXK_RETURN:
1540 case WXK_NUMPAD_ENTER:
1541 if (!m_grid->GetEventHandler()->ProcessEvent(event))
1542 m_editor->HandleReturn(event);
1543 break;
1544
1545
1546 default:
1547 event.Skip();
1548 }
1549 }
1550
1551 void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
1552 {
1553 switch ( event.GetKeyCode() )
1554 {
1555 case WXK_ESCAPE:
1556 case WXK_TAB:
1557 case WXK_RETURN:
1558 case WXK_NUMPAD_ENTER:
1559 break;
1560
1561 default:
1562 event.Skip();
1563 }
1564 }
1565
1566 // ----------------------------------------------------------------------------
1567 // wxGridCellWorker is an (almost) empty common base class for
1568 // wxGridCellRenderer and wxGridCellEditor managing ref counting
1569 // ----------------------------------------------------------------------------
1570
1571 void wxGridCellWorker::SetParameters(const wxString& WXUNUSED(params))
1572 {
1573 // nothing to do
1574 }
1575
1576 wxGridCellWorker::~wxGridCellWorker()
1577 {
1578 }
1579
1580 // ============================================================================
1581 // renderer classes
1582 // ============================================================================
1583
1584 // ----------------------------------------------------------------------------
1585 // wxGridCellRenderer
1586 // ----------------------------------------------------------------------------
1587
1588 void wxGridCellRenderer::Draw(wxGrid& grid,
1589 wxGridCellAttr& attr,
1590 wxDC& dc,
1591 const wxRect& rect,
1592 int WXUNUSED(row), int WXUNUSED(col),
1593 bool isSelected)
1594 {
1595 dc.SetBackgroundMode( wxSOLID );
1596
1597 // grey out fields if the grid is disabled
1598 if( grid.IsEnabled() )
1599 {
1600 if ( isSelected )
1601 {
1602 dc.SetBrush( wxBrush(grid.GetSelectionBackground(), wxSOLID) );
1603 }
1604 else
1605 {
1606 dc.SetBrush( wxBrush(attr.GetBackgroundColour(), wxSOLID) );
1607 }
1608 }
1609 else
1610 {
1611 dc.SetBrush(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE), wxSOLID));
1612 }
1613
1614 dc.SetPen( *wxTRANSPARENT_PEN );
1615 dc.DrawRectangle(rect);
1616 }
1617
1618 // ----------------------------------------------------------------------------
1619 // wxGridCellStringRenderer
1620 // ----------------------------------------------------------------------------
1621
1622 void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid& grid,
1623 wxGridCellAttr& attr,
1624 wxDC& dc,
1625 bool isSelected)
1626 {
1627 dc.SetBackgroundMode( wxTRANSPARENT );
1628
1629 // TODO some special colours for attr.IsReadOnly() case?
1630
1631 // different coloured text when the grid is disabled
1632 if( grid.IsEnabled() )
1633 {
1634 if ( isSelected )
1635 {
1636 dc.SetTextBackground( grid.GetSelectionBackground() );
1637 dc.SetTextForeground( grid.GetSelectionForeground() );
1638 }
1639 else
1640 {
1641 dc.SetTextBackground( attr.GetBackgroundColour() );
1642 dc.SetTextForeground( attr.GetTextColour() );
1643 }
1644 }
1645 else
1646 {
1647 dc.SetTextBackground(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
1648 dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT));
1649 }
1650
1651 dc.SetFont( attr.GetFont() );
1652 }
1653
1654 wxSize wxGridCellStringRenderer::DoGetBestSize(wxGridCellAttr& attr,
1655 wxDC& dc,
1656 const wxString& text)
1657 {
1658 wxCoord x = 0, y = 0, max_x = 0;
1659 dc.SetFont(attr.GetFont());
1660 wxStringTokenizer tk(text, _T('\n'));
1661 while ( tk.HasMoreTokens() )
1662 {
1663 dc.GetTextExtent(tk.GetNextToken(), &x, &y);
1664 max_x = wxMax(max_x, x);
1665 }
1666
1667 y *= 1 + text.Freq(wxT('\n')); // multiply by the number of lines.
1668
1669 return wxSize(max_x, y);
1670 }
1671
1672 wxSize wxGridCellStringRenderer::GetBestSize(wxGrid& grid,
1673 wxGridCellAttr& attr,
1674 wxDC& dc,
1675 int row, int col)
1676 {
1677 return DoGetBestSize(attr, dc, grid.GetCellValue(row, col));
1678 }
1679
1680 void wxGridCellStringRenderer::Draw(wxGrid& grid,
1681 wxGridCellAttr& attr,
1682 wxDC& dc,
1683 const wxRect& rectCell,
1684 int row, int col,
1685 bool isSelected)
1686 {
1687 wxRect rect = rectCell;
1688 rect.Inflate(-1);
1689
1690 // erase only this cells background, overflow cells should have been erased
1691 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1692
1693 int hAlign, vAlign;
1694 attr.GetAlignment(&hAlign, &vAlign);
1695
1696 int overflowCols = 0;
1697
1698 if (attr.GetOverflow())
1699 {
1700 int cols = grid.GetNumberCols();
1701 int best_width = GetBestSize(grid,attr,dc,row,col).GetWidth();
1702 int cell_rows, cell_cols;
1703 attr.GetSize( &cell_rows, &cell_cols ); // shouldn't get here if <=0
1704 if ((best_width > rectCell.width) && (col < cols) && grid.GetTable())
1705 {
1706 int i, c_cols, c_rows;
1707 for (i = col+cell_cols; i < cols; i++)
1708 {
1709 bool is_empty = true;
1710 for (int j=row; j<row+cell_rows; j++)
1711 {
1712 // check w/ anchor cell for multicell block
1713 grid.GetCellSize(j, i, &c_rows, &c_cols);
1714 if (c_rows > 0) c_rows = 0;
1715 if (!grid.GetTable()->IsEmptyCell(j+c_rows, i))
1716 {
1717 is_empty = false;
1718 break;
1719 }
1720 }
1721 if (is_empty)
1722 rect.width += grid.GetColSize(i);
1723 else
1724 {
1725 i--;
1726 break;
1727 }
1728 if (rect.width >= best_width) break;
1729 }
1730 overflowCols = i - col - cell_cols + 1;
1731 if (overflowCols >= cols) overflowCols = cols - 1;
1732 }
1733
1734 if (overflowCols > 0) // redraw overflow cells w/ proper hilight
1735 {
1736 hAlign = wxALIGN_LEFT; // if oveflowed then it's left aligned
1737 wxRect clip = rect;
1738 clip.x += rectCell.width;
1739 // draw each overflow cell individually
1740 int col_end = col+cell_cols+overflowCols;
1741 if (col_end >= grid.GetNumberCols())
1742 col_end = grid.GetNumberCols() - 1;
1743 for (int i = col+cell_cols; i <= col_end; i++)
1744 {
1745 clip.width = grid.GetColSize(i) - 1;
1746 dc.DestroyClippingRegion();
1747 dc.SetClippingRegion(clip);
1748
1749 SetTextColoursAndFont(grid, attr, dc,
1750 grid.IsInSelection(row,i));
1751
1752 grid.DrawTextRectangle(dc, grid.GetCellValue(row, col),
1753 rect, hAlign, vAlign);
1754 clip.x += grid.GetColSize(i) - 1;
1755 }
1756
1757 rect = rectCell;
1758 rect.Inflate(-1);
1759 rect.width++;
1760 dc.DestroyClippingRegion();
1761 }
1762 }
1763
1764 // now we only have to draw the text
1765 SetTextColoursAndFont(grid, attr, dc, isSelected);
1766
1767 grid.DrawTextRectangle(dc, grid.GetCellValue(row, col),
1768 rect, hAlign, vAlign);
1769 }
1770
1771 // ----------------------------------------------------------------------------
1772 // wxGridCellNumberRenderer
1773 // ----------------------------------------------------------------------------
1774
1775 wxString wxGridCellNumberRenderer::GetString(wxGrid& grid, int row, int col)
1776 {
1777 wxGridTableBase *table = grid.GetTable();
1778 wxString text;
1779 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
1780 {
1781 text.Printf(_T("%ld"), table->GetValueAsLong(row, col));
1782 }
1783 else
1784 {
1785 text = table->GetValue(row, col);
1786 }
1787
1788 return text;
1789 }
1790
1791 void wxGridCellNumberRenderer::Draw(wxGrid& grid,
1792 wxGridCellAttr& attr,
1793 wxDC& dc,
1794 const wxRect& rectCell,
1795 int row, int col,
1796 bool isSelected)
1797 {
1798 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1799
1800 SetTextColoursAndFont(grid, attr, dc, isSelected);
1801
1802 // draw the text right aligned by default
1803 int hAlign, vAlign;
1804 attr.GetAlignment(&hAlign, &vAlign);
1805 hAlign = wxALIGN_RIGHT;
1806
1807 wxRect rect = rectCell;
1808 rect.Inflate(-1);
1809
1810 grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
1811 }
1812
1813 wxSize wxGridCellNumberRenderer::GetBestSize(wxGrid& grid,
1814 wxGridCellAttr& attr,
1815 wxDC& dc,
1816 int row, int col)
1817 {
1818 return DoGetBestSize(attr, dc, GetString(grid, row, col));
1819 }
1820
1821 // ----------------------------------------------------------------------------
1822 // wxGridCellFloatRenderer
1823 // ----------------------------------------------------------------------------
1824
1825 wxGridCellFloatRenderer::wxGridCellFloatRenderer(int width, int precision)
1826 {
1827 SetWidth(width);
1828 SetPrecision(precision);
1829 }
1830
1831 wxGridCellRenderer *wxGridCellFloatRenderer::Clone() const
1832 {
1833 wxGridCellFloatRenderer *renderer = new wxGridCellFloatRenderer;
1834 renderer->m_width = m_width;
1835 renderer->m_precision = m_precision;
1836 renderer->m_format = m_format;
1837
1838 return renderer;
1839 }
1840
1841 wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
1842 {
1843 wxGridTableBase *table = grid.GetTable();
1844
1845 bool hasDouble;
1846 double val;
1847 wxString text;
1848 if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
1849 {
1850 val = table->GetValueAsDouble(row, col);
1851 hasDouble = true;
1852 }
1853 else
1854 {
1855 text = table->GetValue(row, col);
1856 hasDouble = text.ToDouble(&val);
1857 }
1858
1859 if ( hasDouble )
1860 {
1861 if ( !m_format )
1862 {
1863 if ( m_width == -1 )
1864 {
1865 if ( m_precision == -1 )
1866 {
1867 // default width/precision
1868 m_format = _T("%f");
1869 }
1870 else
1871 {
1872 m_format.Printf(_T("%%.%df"), m_precision);
1873 }
1874 }
1875 else if ( m_precision == -1 )
1876 {
1877 // default precision
1878 m_format.Printf(_T("%%%d.f"), m_width);
1879 }
1880 else
1881 {
1882 m_format.Printf(_T("%%%d.%df"), m_width, m_precision);
1883 }
1884 }
1885
1886 text.Printf(m_format, val);
1887
1888 }
1889 //else: text already contains the string
1890
1891 return text;
1892 }
1893
1894 void wxGridCellFloatRenderer::Draw(wxGrid& grid,
1895 wxGridCellAttr& attr,
1896 wxDC& dc,
1897 const wxRect& rectCell,
1898 int row, int col,
1899 bool isSelected)
1900 {
1901 wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1902
1903 SetTextColoursAndFont(grid, attr, dc, isSelected);
1904
1905 // draw the text right aligned by default
1906 int hAlign, vAlign;
1907 attr.GetAlignment(&hAlign, &vAlign);
1908 hAlign = wxALIGN_RIGHT;
1909
1910 wxRect rect = rectCell;
1911 rect.Inflate(-1);
1912
1913 grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
1914 }
1915
1916 wxSize wxGridCellFloatRenderer::GetBestSize(wxGrid& grid,
1917 wxGridCellAttr& attr,
1918 wxDC& dc,
1919 int row, int col)
1920 {
1921 return DoGetBestSize(attr, dc, GetString(grid, row, col));
1922 }
1923
1924 void wxGridCellFloatRenderer::SetParameters(const wxString& params)
1925 {
1926 if ( !params )
1927 {
1928 // reset to defaults
1929 SetWidth(-1);
1930 SetPrecision(-1);
1931 }
1932 else
1933 {
1934 wxString tmp = params.BeforeFirst(_T(','));
1935 if ( !tmp.empty() )
1936 {
1937 long width;
1938 if ( tmp.ToLong(&width) )
1939 {
1940 SetWidth((int)width);
1941 }
1942 else
1943 {
1944 wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params.c_str());
1945 }
1946
1947 }
1948 tmp = params.AfterFirst(_T(','));
1949 if ( !tmp.empty() )
1950 {
1951 long precision;
1952 if ( tmp.ToLong(&precision) )
1953 {
1954 SetPrecision((int)precision);
1955 }
1956 else
1957 {
1958 wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params.c_str());
1959 }
1960
1961 }
1962 }
1963 }
1964
1965
1966 // ----------------------------------------------------------------------------
1967 // wxGridCellBoolRenderer
1968 // ----------------------------------------------------------------------------
1969
1970 wxSize wxGridCellBoolRenderer::ms_sizeCheckMark;
1971
1972 // FIXME these checkbox size calculations are really ugly...
1973
1974 // between checkmark and box
1975 static const wxCoord wxGRID_CHECKMARK_MARGIN = 2;
1976
1977 wxSize wxGridCellBoolRenderer::GetBestSize(wxGrid& grid,
1978 wxGridCellAttr& WXUNUSED(attr),
1979 wxDC& WXUNUSED(dc),
1980 int WXUNUSED(row),
1981 int WXUNUSED(col))
1982 {
1983 // compute it only once (no locks for MT safeness in GUI thread...)
1984 if ( !ms_sizeCheckMark.x )
1985 {
1986 // get checkbox size
1987 wxCheckBox *checkbox = new wxCheckBox(&grid, wxID_ANY, wxEmptyString);
1988 wxSize size = checkbox->GetBestSize();
1989 wxCoord checkSize = size.y + 2*wxGRID_CHECKMARK_MARGIN;
1990
1991 // FIXME wxGTK::wxCheckBox::GetBestSize() gives "wrong" result
1992 #if defined(__WXGTK__) || defined(__WXMOTIF__)
1993 checkSize -= size.y / 2;
1994 #endif
1995
1996 delete checkbox;
1997
1998 ms_sizeCheckMark.x = ms_sizeCheckMark.y = checkSize;
1999 }
2000
2001 return ms_sizeCheckMark;
2002 }
2003
2004 void wxGridCellBoolRenderer::Draw(wxGrid& grid,
2005 wxGridCellAttr& attr,
2006 wxDC& dc,
2007 const wxRect& rect,
2008 int row, int col,
2009 bool isSelected)
2010 {
2011 wxGridCellRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
2012
2013 // draw a check mark in the centre (ignoring alignment - TODO)
2014 wxSize size = GetBestSize(grid, attr, dc, row, col);
2015
2016 // don't draw outside the cell
2017 wxCoord minSize = wxMin(rect.width, rect.height);
2018 if ( size.x >= minSize || size.y >= minSize )
2019 {
2020 // and even leave (at least) 1 pixel margin
2021 size.x = size.y = minSize - 2;
2022 }
2023
2024 // draw a border around checkmark
2025 int vAlign, hAlign;
2026 attr.GetAlignment(& hAlign, &vAlign);
2027
2028 wxRect rectBorder;
2029 if (hAlign == wxALIGN_CENTRE)
2030 {
2031 rectBorder.x = rect.x + rect.width/2 - size.x/2;
2032 rectBorder.y = rect.y + rect.height/2 - size.y/2;
2033 rectBorder.width = size.x;
2034 rectBorder.height = size.y;
2035 }
2036 else if (hAlign == wxALIGN_LEFT)
2037 {
2038 rectBorder.x = rect.x + 2;
2039 rectBorder.y = rect.y + rect.height/2 - size.y/2;
2040 rectBorder.width = size.x;
2041 rectBorder.height = size.y;
2042 }
2043 else if (hAlign == wxALIGN_RIGHT)
2044 {
2045 rectBorder.x = rect.x + rect.width - size.x - 2;
2046 rectBorder.y = rect.y + rect.height/2 - size.y/2;
2047 rectBorder.width = size.x;
2048 rectBorder.height = size.y;
2049 }
2050
2051 bool value;
2052 if ( grid.GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
2053 value = grid.GetTable()->GetValueAsBool(row, col);
2054 else
2055 {
2056 wxString cellval( grid.GetTable()->GetValue(row, col) );
2057 value = !( !cellval || (cellval == wxT("0")) );
2058 }
2059
2060 if ( value )
2061 {
2062 wxRect rectMark = rectBorder;
2063 #ifdef __WXMSW__
2064 // MSW DrawCheckMark() is weird (and should probably be changed...)
2065 rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN/2);
2066 rectMark.x++;
2067 rectMark.y++;
2068 #else // !MSW
2069 rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN);
2070 #endif // MSW/!MSW
2071
2072 dc.SetTextForeground(attr.GetTextColour());
2073 dc.DrawCheckMark(rectMark);
2074 }
2075
2076 dc.SetBrush(*wxTRANSPARENT_BRUSH);
2077 dc.SetPen(wxPen(attr.GetTextColour(), 1, wxSOLID));
2078 dc.DrawRectangle(rectBorder);
2079 }
2080
2081 // ----------------------------------------------------------------------------
2082 // wxGridCellAttr
2083 // ----------------------------------------------------------------------------
2084
2085 void wxGridCellAttr::Init(wxGridCellAttr *attrDefault)
2086 {
2087 m_nRef = 1;
2088
2089 m_isReadOnly = Unset;
2090
2091 m_renderer = NULL;
2092 m_editor = NULL;
2093
2094 m_attrkind = wxGridCellAttr::Cell;
2095
2096 m_sizeRows = m_sizeCols = 1;
2097 m_overflow = UnsetOverflow;
2098
2099 SetDefAttr(attrDefault);
2100 }
2101
2102 wxGridCellAttr *wxGridCellAttr::Clone() const
2103 {
2104 wxGridCellAttr *attr = new wxGridCellAttr(m_defGridAttr);
2105
2106 if ( HasTextColour() )
2107 attr->SetTextColour(GetTextColour());
2108 if ( HasBackgroundColour() )
2109 attr->SetBackgroundColour(GetBackgroundColour());
2110 if ( HasFont() )
2111 attr->SetFont(GetFont());
2112 if ( HasAlignment() )
2113 attr->SetAlignment(m_hAlign, m_vAlign);
2114
2115 attr->SetSize( m_sizeRows, m_sizeCols );
2116
2117 if ( m_renderer )
2118 {
2119 attr->SetRenderer(m_renderer);
2120 m_renderer->IncRef();
2121 }
2122 if ( m_editor )
2123 {
2124 attr->SetEditor(m_editor);
2125 m_editor->IncRef();
2126 }
2127
2128 if ( IsReadOnly() )
2129 attr->SetReadOnly();
2130
2131 attr->SetKind( m_attrkind );
2132
2133 return attr;
2134 }
2135
2136 void wxGridCellAttr::MergeWith(wxGridCellAttr *mergefrom)
2137 {
2138 if ( !HasTextColour() && mergefrom->HasTextColour() )
2139 SetTextColour(mergefrom->GetTextColour());
2140 if ( !HasBackgroundColour() && mergefrom->HasBackgroundColour() )
2141 SetBackgroundColour(mergefrom->GetBackgroundColour());
2142 if ( !HasFont() && mergefrom->HasFont() )
2143 SetFont(mergefrom->GetFont());
2144 if ( !HasAlignment() && mergefrom->HasAlignment() ){
2145 int hAlign, vAlign;
2146 mergefrom->GetAlignment( &hAlign, &vAlign);
2147 SetAlignment(hAlign, vAlign);
2148 }
2149
2150 mergefrom->GetSize( &m_sizeRows, &m_sizeCols );
2151
2152 // Directly access member functions as GetRender/Editor don't just return
2153 // m_renderer/m_editor
2154 //
2155 // Maybe add support for merge of Render and Editor?
2156 if (!HasRenderer() && mergefrom->HasRenderer() )
2157 {
2158 m_renderer = mergefrom->m_renderer;
2159 m_renderer->IncRef();
2160 }
2161 if ( !HasEditor() && mergefrom->HasEditor() )
2162 {
2163 m_editor = mergefrom->m_editor;
2164 m_editor->IncRef();
2165 }
2166 if ( !HasReadWriteMode() && mergefrom->HasReadWriteMode() )
2167 SetReadOnly(mergefrom->IsReadOnly());
2168
2169 if (!HasOverflowMode() && mergefrom->HasOverflowMode() )
2170 SetOverflow(mergefrom->GetOverflow());
2171
2172 SetDefAttr(mergefrom->m_defGridAttr);
2173 }
2174
2175 void wxGridCellAttr::SetSize(int num_rows, int num_cols)
2176 {
2177 // The size of a cell is normally 1,1
2178
2179 // If this cell is larger (2,2) then this is the top left cell
2180 // the other cells that will be covered (lower right cells) must be
2181 // set to negative or zero values such that
2182 // row + num_rows of the covered cell points to the larger cell (this cell)
2183 // same goes for the col + num_cols.
2184
2185 // Size of 0,0 is NOT valid, neither is <=0 and any positive value
2186
2187 wxASSERT_MSG( (!((num_rows>0)&&(num_cols<=0)) ||
2188 !((num_rows<=0)&&(num_cols>0)) ||
2189 !((num_rows==0)&&(num_cols==0))),
2190 wxT("wxGridCellAttr::SetSize only takes two postive values or negative/zero values"));
2191
2192 m_sizeRows = num_rows;
2193 m_sizeCols = num_cols;
2194 }
2195
2196 const wxColour& wxGridCellAttr::GetTextColour() const
2197 {
2198 if (HasTextColour())
2199 {
2200 return m_colText;
2201 }
2202 else if (m_defGridAttr && m_defGridAttr != this)
2203 {
2204 return m_defGridAttr->GetTextColour();
2205 }
2206 else
2207 {
2208 wxFAIL_MSG(wxT("Missing default cell attribute"));
2209 return wxNullColour;
2210 }
2211 }
2212
2213
2214 const wxColour& wxGridCellAttr::GetBackgroundColour() const
2215 {
2216 if (HasBackgroundColour())
2217 return m_colBack;
2218 else if (m_defGridAttr && m_defGridAttr != this)
2219 return m_defGridAttr->GetBackgroundColour();
2220 else
2221 {
2222 wxFAIL_MSG(wxT("Missing default cell attribute"));
2223 return wxNullColour;
2224 }
2225 }
2226
2227
2228 const wxFont& wxGridCellAttr::GetFont() const
2229 {
2230 if (HasFont())
2231 return m_font;
2232 else if (m_defGridAttr && m_defGridAttr != this)
2233 return m_defGridAttr->GetFont();
2234 else
2235 {
2236 wxFAIL_MSG(wxT("Missing default cell attribute"));
2237 return wxNullFont;
2238 }
2239 }
2240
2241
2242 void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
2243 {
2244 if (HasAlignment())
2245 {
2246 if ( hAlign ) *hAlign = m_hAlign;
2247 if ( vAlign ) *vAlign = m_vAlign;
2248 }
2249 else if (m_defGridAttr && m_defGridAttr != this)
2250 m_defGridAttr->GetAlignment(hAlign, vAlign);
2251 else
2252 {
2253 wxFAIL_MSG(wxT("Missing default cell attribute"));
2254 }
2255 }
2256
2257 void wxGridCellAttr::GetSize( int *num_rows, int *num_cols ) const
2258 {
2259 if ( num_rows ) *num_rows = m_sizeRows;
2260 if ( num_cols ) *num_cols = m_sizeCols;
2261 }
2262
2263 // GetRenderer and GetEditor use a slightly different decision path about
2264 // which attribute to use. If a non-default attr object has one then it is
2265 // used, otherwise the default editor or renderer is fetched from the grid and
2266 // used. It should be the default for the data type of the cell. If it is
2267 // NULL (because the table has a type that the grid does not have in its
2268 // registry,) then the grid's default editor or renderer is used.
2269
2270 wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col) const
2271 {
2272 wxGridCellRenderer *renderer;
2273
2274 if ( m_renderer && this != m_defGridAttr )
2275 {
2276 // use the cells renderer if it has one
2277 renderer = m_renderer;
2278 renderer->IncRef();
2279 }
2280 else // no non default cell renderer
2281 {
2282 // get default renderer for the data type
2283 if ( grid )
2284 {
2285 // GetDefaultRendererForCell() will do IncRef() for us
2286 renderer = grid->GetDefaultRendererForCell(row, col);
2287 }
2288 else
2289 {
2290 renderer = NULL;
2291 }
2292
2293 if ( !renderer )
2294 {
2295 if (m_defGridAttr && this != m_defGridAttr )
2296 {
2297 // if we still don't have one then use the grid default
2298 // (no need for IncRef() here neither)
2299 renderer = m_defGridAttr->GetRenderer(NULL, 0, 0);
2300 }
2301 else // default grid attr
2302 {
2303 // use m_renderer which we had decided not to use initially
2304 renderer = m_renderer;
2305 if ( renderer )
2306 renderer->IncRef();
2307 }
2308 }
2309 }
2310
2311 // we're supposed to always find something
2312 wxASSERT_MSG(renderer, wxT("Missing default cell renderer"));
2313
2314 return renderer;
2315 }
2316
2317 // same as above, except for s/renderer/editor/g
2318 wxGridCellEditor* wxGridCellAttr::GetEditor(wxGrid* grid, int row, int col) const
2319 {
2320 wxGridCellEditor *editor;
2321
2322 if ( m_editor && this != m_defGridAttr )
2323 {
2324 // use the cells editor if it has one
2325 editor = m_editor;
2326 editor->IncRef();
2327 }
2328 else // no non default cell editor
2329 {
2330 // get default editor for the data type
2331 if ( grid )
2332 {
2333 // GetDefaultEditorForCell() will do IncRef() for us
2334 editor = grid->GetDefaultEditorForCell(row, col);
2335 }
2336 else
2337 {
2338 editor = NULL;
2339 }
2340
2341 if ( !editor )
2342 {
2343 if ( m_defGridAttr && this != m_defGridAttr )
2344 {
2345 // if we still don't have one then use the grid default
2346 // (no need for IncRef() here neither)
2347 editor = m_defGridAttr->GetEditor(NULL, 0, 0);
2348 }
2349 else // default grid attr
2350 {
2351 // use m_editor which we had decided not to use initially
2352 editor = m_editor;
2353 if ( editor )
2354 editor->IncRef();
2355 }
2356 }
2357 }
2358
2359 // we're supposed to always find something
2360 wxASSERT_MSG(editor, wxT("Missing default cell editor"));
2361
2362 return editor;
2363 }
2364
2365 // ----------------------------------------------------------------------------
2366 // wxGridCellAttrData
2367 // ----------------------------------------------------------------------------
2368
2369 void wxGridCellAttrData::SetAttr(wxGridCellAttr *attr, int row, int col)
2370 {
2371 int n = FindIndex(row, col);
2372 if ( n == wxNOT_FOUND )
2373 {
2374 // add the attribute
2375 m_attrs.Add(new wxGridCellWithAttr(row, col, attr));
2376 }
2377 else
2378 {
2379 // free the old attribute
2380 m_attrs[(size_t)n].attr->DecRef();
2381
2382 if ( attr )
2383 {
2384 // change the attribute
2385 m_attrs[(size_t)n].attr = attr;
2386 }
2387 else
2388 {
2389 // remove this attribute
2390 m_attrs.RemoveAt((size_t)n);
2391 }
2392 }
2393 }
2394
2395 wxGridCellAttr *wxGridCellAttrData::GetAttr(int row, int col) const
2396 {
2397 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2398
2399 int n = FindIndex(row, col);
2400 if ( n != wxNOT_FOUND )
2401 {
2402 attr = m_attrs[(size_t)n].attr;
2403 attr->IncRef();
2404 }
2405
2406 return attr;
2407 }
2408
2409 void wxGridCellAttrData::UpdateAttrRows( size_t pos, int numRows )
2410 {
2411 size_t count = m_attrs.GetCount();
2412 for ( size_t n = 0; n < count; n++ )
2413 {
2414 wxGridCellCoords& coords = m_attrs[n].coords;
2415 wxCoord row = coords.GetRow();
2416 if ((size_t)row >= pos)
2417 {
2418 if (numRows > 0)
2419 {
2420 // If rows inserted, include row counter where necessary
2421 coords.SetRow(row + numRows);
2422 }
2423 else if (numRows < 0)
2424 {
2425 // If rows deleted ...
2426 if ((size_t)row >= pos - numRows)
2427 {
2428 // ...either decrement row counter (if row still exists)...
2429 coords.SetRow(row + numRows);
2430 }
2431 else
2432 {
2433 // ...or remove the attribute
2434 // No need to DecRef the attribute itself since this is
2435 // done be wxGridCellWithAttr's destructor!
2436 m_attrs.RemoveAt(n);
2437 n--; count--;
2438 }
2439 }
2440 }
2441 }
2442 }
2443
2444 void wxGridCellAttrData::UpdateAttrCols( size_t pos, int numCols )
2445 {
2446 size_t count = m_attrs.GetCount();
2447 for ( size_t n = 0; n < count; n++ )
2448 {
2449 wxGridCellCoords& coords = m_attrs[n].coords;
2450 wxCoord col = coords.GetCol();
2451 if ( (size_t)col >= pos )
2452 {
2453 if ( numCols > 0 )
2454 {
2455 // If rows inserted, include row counter where necessary
2456 coords.SetCol(col + numCols);
2457 }
2458 else if (numCols < 0)
2459 {
2460 // If rows deleted ...
2461 if ((size_t)col >= pos - numCols)
2462 {
2463 // ...either decrement row counter (if row still exists)...
2464 coords.SetCol(col + numCols);
2465 }
2466 else
2467 {
2468 // ...or remove the attribute
2469 // No need to DecRef the attribute itself since this is
2470 // done be wxGridCellWithAttr's destructor!
2471 m_attrs.RemoveAt(n);
2472 n--; count--;
2473 }
2474 }
2475 }
2476 }
2477 }
2478
2479 int wxGridCellAttrData::FindIndex(int row, int col) const
2480 {
2481 size_t count = m_attrs.GetCount();
2482 for ( size_t n = 0; n < count; n++ )
2483 {
2484 const wxGridCellCoords& coords = m_attrs[n].coords;
2485 if ( (coords.GetRow() == row) && (coords.GetCol() == col) )
2486 {
2487 return n;
2488 }
2489 }
2490
2491 return wxNOT_FOUND;
2492 }
2493
2494 // ----------------------------------------------------------------------------
2495 // wxGridRowOrColAttrData
2496 // ----------------------------------------------------------------------------
2497
2498 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
2499 {
2500 size_t count = m_attrs.Count();
2501 for ( size_t n = 0; n < count; n++ )
2502 {
2503 m_attrs[n]->DecRef();
2504 }
2505 }
2506
2507 wxGridCellAttr *wxGridRowOrColAttrData::GetAttr(int rowOrCol) const
2508 {
2509 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2510
2511 int n = m_rowsOrCols.Index(rowOrCol);
2512 if ( n != wxNOT_FOUND )
2513 {
2514 attr = m_attrs[(size_t)n];
2515 attr->IncRef();
2516 }
2517
2518 return attr;
2519 }
2520
2521 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
2522 {
2523 int i = m_rowsOrCols.Index(rowOrCol);
2524 if ( i == wxNOT_FOUND )
2525 {
2526 // add the attribute
2527 m_rowsOrCols.Add(rowOrCol);
2528 m_attrs.Add(attr);
2529 }
2530 else
2531 {
2532 size_t n = (size_t)i;
2533 if ( attr )
2534 {
2535 // change the attribute
2536 m_attrs[n]->DecRef();
2537 m_attrs[n] = attr;
2538 }
2539 else
2540 {
2541 // remove this attribute
2542 m_attrs[n]->DecRef();
2543 m_rowsOrCols.RemoveAt(n);
2544 m_attrs.RemoveAt(n);
2545 }
2546 }
2547 }
2548
2549 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols )
2550 {
2551 size_t count = m_attrs.GetCount();
2552 for ( size_t n = 0; n < count; n++ )
2553 {
2554 int & rowOrCol = m_rowsOrCols[n];
2555 if ( (size_t)rowOrCol >= pos )
2556 {
2557 if ( numRowsOrCols > 0 )
2558 {
2559 // If rows inserted, include row counter where necessary
2560 rowOrCol += numRowsOrCols;
2561 }
2562 else if ( numRowsOrCols < 0)
2563 {
2564 // If rows deleted, either decrement row counter (if row still exists)
2565 if ((size_t)rowOrCol >= pos - numRowsOrCols)
2566 rowOrCol += numRowsOrCols;
2567 else
2568 {
2569 m_rowsOrCols.RemoveAt(n);
2570 m_attrs[n]->DecRef();
2571 m_attrs.RemoveAt(n);
2572 n--; count--;
2573 }
2574 }
2575 }
2576 }
2577 }
2578
2579 // ----------------------------------------------------------------------------
2580 // wxGridCellAttrProvider
2581 // ----------------------------------------------------------------------------
2582
2583 wxGridCellAttrProvider::wxGridCellAttrProvider()
2584 {
2585 m_data = (wxGridCellAttrProviderData *)NULL;
2586 }
2587
2588 wxGridCellAttrProvider::~wxGridCellAttrProvider()
2589 {
2590 delete m_data;
2591 }
2592
2593 void wxGridCellAttrProvider::InitData()
2594 {
2595 m_data = new wxGridCellAttrProviderData;
2596 }
2597
2598 wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
2599 wxGridCellAttr::wxAttrKind kind ) const
2600 {
2601 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2602 if ( m_data )
2603 {
2604 switch(kind)
2605 {
2606 case (wxGridCellAttr::Any):
2607 //Get cached merge attributes.
2608 // Currenlty not used as no cache implemented as not mutiable
2609 // attr = m_data->m_mergeAttr.GetAttr(row, col);
2610 if(!attr)
2611 {
2612 //Basicaly implement old version.
2613 //Also check merge cache, so we don't have to re-merge every time..
2614 wxGridCellAttr *attrcell = m_data->m_cellAttrs.GetAttr(row, col);
2615 wxGridCellAttr *attrrow = m_data->m_rowAttrs.GetAttr(row);
2616 wxGridCellAttr *attrcol = m_data->m_colAttrs.GetAttr(col);
2617
2618 if((attrcell != attrrow) && (attrrow != attrcol) && (attrcell != attrcol)){
2619 // Two or more are non NULL
2620 attr = new wxGridCellAttr;
2621 attr->SetKind(wxGridCellAttr::Merged);
2622
2623 //Order important..
2624 if(attrcell){
2625 attr->MergeWith(attrcell);
2626 attrcell->DecRef();
2627 }
2628 if(attrcol){
2629 attr->MergeWith(attrcol);
2630 attrcol->DecRef();
2631 }
2632 if(attrrow){
2633 attr->MergeWith(attrrow);
2634 attrrow->DecRef();
2635 }
2636 //store merge attr if cache implemented
2637 //attr->IncRef();
2638 //m_data->m_mergeAttr.SetAttr(attr, row, col);
2639 }
2640 else
2641 {
2642 // one or none is non null return it or null.
2643 if(attrrow) attr = attrrow;
2644 if(attrcol)
2645 {
2646 if(attr)
2647 attr->DecRef();
2648 attr = attrcol;
2649 }
2650 if(attrcell)
2651 {
2652 if(attr)
2653 attr->DecRef();
2654 attr = attrcell;
2655 }
2656 }
2657 }
2658 break;
2659 case (wxGridCellAttr::Cell):
2660 attr = m_data->m_cellAttrs.GetAttr(row, col);
2661 break;
2662 case (wxGridCellAttr::Col):
2663 attr = m_data->m_colAttrs.GetAttr(col);
2664 break;
2665 case (wxGridCellAttr::Row):
2666 attr = m_data->m_rowAttrs.GetAttr(row);
2667 break;
2668 default:
2669 // unused as yet...
2670 // (wxGridCellAttr::Default):
2671 // (wxGridCellAttr::Merged):
2672 break;
2673 }
2674 }
2675 return attr;
2676 }
2677
2678 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr *attr,
2679 int row, int col)
2680 {
2681 if ( !m_data )
2682 InitData();
2683
2684 m_data->m_cellAttrs.SetAttr(attr, row, col);
2685 }
2686
2687 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr *attr, int row)
2688 {
2689 if ( !m_data )
2690 InitData();
2691
2692 m_data->m_rowAttrs.SetAttr(attr, row);
2693 }
2694
2695 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr *attr, int col)
2696 {
2697 if ( !m_data )
2698 InitData();
2699
2700 m_data->m_colAttrs.SetAttr(attr, col);
2701 }
2702
2703 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos, int numRows )
2704 {
2705 if ( m_data )
2706 {
2707 m_data->m_cellAttrs.UpdateAttrRows( pos, numRows );
2708
2709 m_data->m_rowAttrs.UpdateAttrRowsOrCols( pos, numRows );
2710 }
2711 }
2712
2713 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos, int numCols )
2714 {
2715 if ( m_data )
2716 {
2717 m_data->m_cellAttrs.UpdateAttrCols( pos, numCols );
2718
2719 m_data->m_colAttrs.UpdateAttrRowsOrCols( pos, numCols );
2720 }
2721 }
2722
2723 // ----------------------------------------------------------------------------
2724 // wxGridTypeRegistry
2725 // ----------------------------------------------------------------------------
2726
2727 wxGridTypeRegistry::~wxGridTypeRegistry()
2728 {
2729 size_t count = m_typeinfo.Count();
2730 for ( size_t i = 0; i < count; i++ )
2731 delete m_typeinfo[i];
2732 }
2733
2734
2735 void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
2736 wxGridCellRenderer* renderer,
2737 wxGridCellEditor* editor)
2738 {
2739 wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
2740
2741 // is it already registered?
2742 int loc = FindRegisteredDataType(typeName);
2743 if ( loc != wxNOT_FOUND )
2744 {
2745 delete m_typeinfo[loc];
2746 m_typeinfo[loc] = info;
2747 }
2748 else
2749 {
2750 m_typeinfo.Add(info);
2751 }
2752 }
2753
2754 int wxGridTypeRegistry::FindRegisteredDataType(const wxString& typeName)
2755 {
2756 size_t count = m_typeinfo.GetCount();
2757 for ( size_t i = 0; i < count; i++ )
2758 {
2759 if ( typeName == m_typeinfo[i]->m_typeName )
2760 {
2761 return i;
2762 }
2763 }
2764
2765 return wxNOT_FOUND;
2766 }
2767
2768 int wxGridTypeRegistry::FindDataType(const wxString& typeName)
2769 {
2770 int index = FindRegisteredDataType(typeName);
2771 if ( index == wxNOT_FOUND )
2772 {
2773 // check whether this is one of the standard ones, in which case
2774 // register it "on the fly"
2775 #if wxUSE_TEXTCTRL
2776 if ( typeName == wxGRID_VALUE_STRING )
2777 {
2778 RegisterDataType(wxGRID_VALUE_STRING,
2779 new wxGridCellStringRenderer,
2780 new wxGridCellTextEditor);
2781 } else
2782 #endif // wxUSE_TEXTCTRL
2783 #if wxUSE_CHECKBOX
2784 if ( typeName == wxGRID_VALUE_BOOL )
2785 {
2786 RegisterDataType(wxGRID_VALUE_BOOL,
2787 new wxGridCellBoolRenderer,
2788 new wxGridCellBoolEditor);
2789 } else
2790 #endif // wxUSE_CHECKBOX
2791 #if wxUSE_TEXTCTRL
2792 if ( typeName == wxGRID_VALUE_NUMBER )
2793 {
2794 RegisterDataType(wxGRID_VALUE_NUMBER,
2795 new wxGridCellNumberRenderer,
2796 new wxGridCellNumberEditor);
2797 }
2798 else if ( typeName == wxGRID_VALUE_FLOAT )
2799 {
2800 RegisterDataType(wxGRID_VALUE_FLOAT,
2801 new wxGridCellFloatRenderer,
2802 new wxGridCellFloatEditor);
2803 } else
2804 #endif // wxUSE_TEXTCTRL
2805 #if wxUSE_COMBOBOX
2806 if ( typeName == wxGRID_VALUE_CHOICE )
2807 {
2808 RegisterDataType(wxGRID_VALUE_CHOICE,
2809 new wxGridCellStringRenderer,
2810 new wxGridCellChoiceEditor);
2811 } else
2812 #endif // wxUSE_COMBOBOX
2813 {
2814 return wxNOT_FOUND;
2815 }
2816
2817 // we get here only if just added the entry for this type, so return
2818 // the last index
2819 index = m_typeinfo.GetCount() - 1;
2820 }
2821
2822 return index;
2823 }
2824
2825 int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
2826 {
2827 int index = FindDataType(typeName);
2828 if ( index == wxNOT_FOUND )
2829 {
2830 // the first part of the typename is the "real" type, anything after ':'
2831 // are the parameters for the renderer
2832 index = FindDataType(typeName.BeforeFirst(_T(':')));
2833 if ( index == wxNOT_FOUND )
2834 {
2835 return wxNOT_FOUND;
2836 }
2837
2838 wxGridCellRenderer *renderer = GetRenderer(index);
2839 wxGridCellRenderer *rendererOld = renderer;
2840 renderer = renderer->Clone();
2841 rendererOld->DecRef();
2842
2843 wxGridCellEditor *editor = GetEditor(index);
2844 wxGridCellEditor *editorOld = editor;
2845 editor = editor->Clone();
2846 editorOld->DecRef();
2847
2848 // do it even if there are no parameters to reset them to defaults
2849 wxString params = typeName.AfterFirst(_T(':'));
2850 renderer->SetParameters(params);
2851 editor->SetParameters(params);
2852
2853 // register the new typename
2854 RegisterDataType(typeName, renderer, editor);
2855
2856 // we just registered it, it's the last one
2857 index = m_typeinfo.GetCount() - 1;
2858 }
2859
2860 return index;
2861 }
2862
2863 wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
2864 {
2865 wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
2866 if (renderer)
2867 renderer->IncRef();
2868 return renderer;
2869 }
2870
2871 wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
2872 {
2873 wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
2874 if (editor)
2875 editor->IncRef();
2876 return editor;
2877 }
2878
2879 // ----------------------------------------------------------------------------
2880 // wxGridTableBase
2881 // ----------------------------------------------------------------------------
2882
2883 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
2884
2885
2886 wxGridTableBase::wxGridTableBase()
2887 {
2888 m_view = (wxGrid *) NULL;
2889 m_attrProvider = (wxGridCellAttrProvider *) NULL;
2890 }
2891
2892 wxGridTableBase::~wxGridTableBase()
2893 {
2894 delete m_attrProvider;
2895 }
2896
2897 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
2898 {
2899 delete m_attrProvider;
2900 m_attrProvider = attrProvider;
2901 }
2902
2903 bool wxGridTableBase::CanHaveAttributes()
2904 {
2905 if ( ! GetAttrProvider() )
2906 {
2907 // use the default attr provider by default
2908 SetAttrProvider(new wxGridCellAttrProvider);
2909 }
2910 return true;
2911 }
2912
2913 wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col, wxGridCellAttr::wxAttrKind kind)
2914 {
2915 if ( m_attrProvider )
2916 return m_attrProvider->GetAttr(row, col, kind);
2917 else
2918 return (wxGridCellAttr *)NULL;
2919 }
2920
2921 void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
2922 {
2923 if ( m_attrProvider )
2924 {
2925 attr->SetKind(wxGridCellAttr::Cell);
2926 m_attrProvider->SetAttr(attr, row, col);
2927 }
2928 else
2929 {
2930 // as we take ownership of the pointer and don't store it, we must
2931 // free it now
2932 wxSafeDecRef(attr);
2933 }
2934 }
2935
2936 void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
2937 {
2938 if ( m_attrProvider )
2939 {
2940 attr->SetKind(wxGridCellAttr::Row);
2941 m_attrProvider->SetRowAttr(attr, row);
2942 }
2943 else
2944 {
2945 // as we take ownership of the pointer and don't store it, we must
2946 // free it now
2947 wxSafeDecRef(attr);
2948 }
2949 }
2950
2951 void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
2952 {
2953 if ( m_attrProvider )
2954 {
2955 attr->SetKind(wxGridCellAttr::Col);
2956 m_attrProvider->SetColAttr(attr, col);
2957 }
2958 else
2959 {
2960 // as we take ownership of the pointer and don't store it, we must
2961 // free it now
2962 wxSafeDecRef(attr);
2963 }
2964 }
2965
2966 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos),
2967 size_t WXUNUSED(numRows) )
2968 {
2969 wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
2970
2971 return false;
2972 }
2973
2974 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows) )
2975 {
2976 wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
2977
2978 return false;
2979 }
2980
2981 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos),
2982 size_t WXUNUSED(numRows) )
2983 {
2984 wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
2985
2986 return false;
2987 }
2988
2989 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos),
2990 size_t WXUNUSED(numCols) )
2991 {
2992 wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
2993
2994 return false;
2995 }
2996
2997 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols) )
2998 {
2999 wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
3000
3001 return false;
3002 }
3003
3004 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos),
3005 size_t WXUNUSED(numCols) )
3006 {
3007 wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
3008
3009 return false;
3010 }
3011
3012
3013 wxString wxGridTableBase::GetRowLabelValue( int row )
3014 {
3015 wxString s;
3016 s << row + 1; // RD: Starting the rows at zero confuses users, no matter
3017 // how much it makes sense to us geeks.
3018 return s;
3019 }
3020
3021 wxString wxGridTableBase::GetColLabelValue( int col )
3022 {
3023 // default col labels are:
3024 // cols 0 to 25 : A-Z
3025 // cols 26 to 675 : AA-ZZ
3026 // etc.
3027
3028 wxString s;
3029 unsigned int i, n;
3030 for ( n = 1; ; n++ )
3031 {
3032 s += (wxChar) (_T('A') + (wxChar)( col%26 ));
3033 col = col/26 - 1;
3034 if ( col < 0 ) break;
3035 }
3036
3037 // reverse the string...
3038 wxString s2;
3039 for ( i = 0; i < n; i++ )
3040 {
3041 s2 += s[n-i-1];
3042 }
3043
3044 return s2;
3045 }
3046
3047
3048 wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
3049 {
3050 return wxGRID_VALUE_STRING;
3051 }
3052
3053 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row), int WXUNUSED(col),
3054 const wxString& typeName )
3055 {
3056 return typeName == wxGRID_VALUE_STRING;
3057 }
3058
3059 bool wxGridTableBase::CanSetValueAs( int row, int col, const wxString& typeName )
3060 {
3061 return CanGetValueAs(row, col, typeName);
3062 }
3063
3064 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row), int WXUNUSED(col) )
3065 {
3066 return 0;
3067 }
3068
3069 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col) )
3070 {
3071 return 0.0;
3072 }
3073
3074 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row), int WXUNUSED(col) )
3075 {
3076 return false;
3077 }
3078
3079 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row), int WXUNUSED(col),
3080 long WXUNUSED(value) )
3081 {
3082 }
3083
3084 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col),
3085 double WXUNUSED(value) )
3086 {
3087 }
3088
3089 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row), int WXUNUSED(col),
3090 bool WXUNUSED(value) )
3091 {
3092 }
3093
3094
3095 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
3096 const wxString& WXUNUSED(typeName) )
3097 {
3098 return NULL;
3099 }
3100
3101 void wxGridTableBase::SetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
3102 const wxString& WXUNUSED(typeName),
3103 void* WXUNUSED(value) )
3104 {
3105 }
3106
3107 //////////////////////////////////////////////////////////////////////
3108 //
3109 // Message class for the grid table to send requests and notifications
3110 // to the grid view
3111 //
3112
3113 wxGridTableMessage::wxGridTableMessage()
3114 {
3115 m_table = (wxGridTableBase *) NULL;
3116 m_id = -1;
3117 m_comInt1 = -1;
3118 m_comInt2 = -1;
3119 }
3120
3121 wxGridTableMessage::wxGridTableMessage( wxGridTableBase *table, int id,
3122 int commandInt1, int commandInt2 )
3123 {
3124 m_table = table;
3125 m_id = id;
3126 m_comInt1 = commandInt1;
3127 m_comInt2 = commandInt2;
3128 }
3129
3130
3131
3132 //////////////////////////////////////////////////////////////////////
3133 //
3134 // A basic grid table for string data. An object of this class will
3135 // created by wxGrid if you don't specify an alternative table class.
3136 //
3137
3138 WX_DEFINE_OBJARRAY(wxGridStringArray)
3139
3140 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
3141
3142 wxGridStringTable::wxGridStringTable()
3143 : wxGridTableBase()
3144 {
3145 }
3146
3147 wxGridStringTable::wxGridStringTable( int numRows, int numCols )
3148 : wxGridTableBase()
3149 {
3150 m_data.Alloc( numRows );
3151
3152 wxArrayString sa;
3153 sa.Alloc( numCols );
3154 sa.Add( wxEmptyString, numCols );
3155
3156 m_data.Add( sa, numRows );
3157 }
3158
3159 wxGridStringTable::~wxGridStringTable()
3160 {
3161 }
3162
3163 int wxGridStringTable::GetNumberRows()
3164 {
3165 return m_data.GetCount();
3166 }
3167
3168 int wxGridStringTable::GetNumberCols()
3169 {
3170 if ( m_data.GetCount() > 0 )
3171 return m_data[0].GetCount();
3172 else
3173 return 0;
3174 }
3175
3176 wxString wxGridStringTable::GetValue( int row, int col )
3177 {
3178 wxCHECK_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
3179 wxEmptyString,
3180 _T("invalid row or column index in wxGridStringTable") );
3181
3182 return m_data[row][col];
3183 }
3184
3185 void wxGridStringTable::SetValue( int row, int col, const wxString& value )
3186 {
3187 wxCHECK_RET( (row < GetNumberRows()) && (col < GetNumberCols()),
3188 _T("invalid row or column index in wxGridStringTable") );
3189
3190 m_data[row][col] = value;
3191 }
3192
3193 bool wxGridStringTable::IsEmptyCell( int row, int col )
3194 {
3195 wxCHECK_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
3196 true,
3197 _T("invalid row or column index in wxGridStringTable") );
3198
3199 return (m_data[row][col] == wxEmptyString);
3200 }
3201
3202 void wxGridStringTable::Clear()
3203 {
3204 int row, col;
3205 int numRows, numCols;
3206
3207 numRows = m_data.GetCount();
3208 if ( numRows > 0 )
3209 {
3210 numCols = m_data[0].GetCount();
3211
3212 for ( row = 0; row < numRows; row++ )
3213 {
3214 for ( col = 0; col < numCols; col++ )
3215 {
3216 m_data[row][col] = wxEmptyString;
3217 }
3218 }
3219 }
3220 }
3221
3222
3223 bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
3224 {
3225 size_t curNumRows = m_data.GetCount();
3226 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3227 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3228
3229 if ( pos >= curNumRows )
3230 {
3231 return AppendRows( numRows );
3232 }
3233
3234 wxArrayString sa;
3235 sa.Alloc( curNumCols );
3236 sa.Add( wxEmptyString, curNumCols );
3237 m_data.Insert( sa, pos, numRows );
3238 if ( GetView() )
3239 {
3240 wxGridTableMessage msg( this,
3241 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
3242 pos,
3243 numRows );
3244
3245 GetView()->ProcessTableMessage( msg );
3246 }
3247
3248 return true;
3249 }
3250
3251 bool wxGridStringTable::AppendRows( size_t numRows )
3252 {
3253 size_t curNumRows = m_data.GetCount();
3254 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3255 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3256
3257 wxArrayString sa;
3258 if ( curNumCols > 0 )
3259 {
3260 sa.Alloc( curNumCols );
3261 sa.Add( wxEmptyString, curNumCols );
3262 }
3263
3264 m_data.Add( sa, numRows );
3265
3266 if ( GetView() )
3267 {
3268 wxGridTableMessage msg( this,
3269 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
3270 numRows );
3271
3272 GetView()->ProcessTableMessage( msg );
3273 }
3274
3275 return true;
3276 }
3277
3278 bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
3279 {
3280 size_t curNumRows = m_data.GetCount();
3281
3282 if ( pos >= curNumRows )
3283 {
3284 wxFAIL_MSG( wxString::Format
3285 (
3286 wxT("Called wxGridStringTable::DeleteRows(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu rows"),
3287 (unsigned long)pos,
3288 (unsigned long)numRows,
3289 (unsigned long)curNumRows
3290 ) );
3291
3292 return false;
3293 }
3294
3295 if ( numRows > curNumRows - pos )
3296 {
3297 numRows = curNumRows - pos;
3298 }
3299
3300 if ( numRows >= curNumRows )
3301 {
3302 m_data.Clear();
3303 }
3304 else
3305 {
3306 m_data.RemoveAt( pos, numRows );
3307 }
3308 if ( GetView() )
3309 {
3310 wxGridTableMessage msg( this,
3311 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
3312 pos,
3313 numRows );
3314
3315 GetView()->ProcessTableMessage( msg );
3316 }
3317
3318 return true;
3319 }
3320
3321 bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
3322 {
3323 size_t row, col;
3324
3325 size_t curNumRows = m_data.GetCount();
3326 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3327 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3328
3329 if ( pos >= curNumCols )
3330 {
3331 return AppendCols( numCols );
3332 }
3333
3334 for ( row = 0; row < curNumRows; row++ )
3335 {
3336 for ( col = pos; col < pos + numCols; col++ )
3337 {
3338 m_data[row].Insert( wxEmptyString, col );
3339 }
3340 }
3341 if ( GetView() )
3342 {
3343 wxGridTableMessage msg( this,
3344 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
3345 pos,
3346 numCols );
3347
3348 GetView()->ProcessTableMessage( msg );
3349 }
3350
3351 return true;
3352 }
3353
3354 bool wxGridStringTable::AppendCols( size_t numCols )
3355 {
3356 size_t row;
3357
3358 size_t curNumRows = m_data.GetCount();
3359 #if 0
3360 if ( !curNumRows )
3361 {
3362 // TODO: something better than this ?
3363 //
3364 wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
3365 return false;
3366 }
3367 #endif
3368
3369 for ( row = 0; row < curNumRows; row++ )
3370 {
3371 m_data[row].Add( wxEmptyString, numCols );
3372 }
3373
3374 if ( GetView() )
3375 {
3376 wxGridTableMessage msg( this,
3377 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
3378 numCols );
3379
3380 GetView()->ProcessTableMessage( msg );
3381 }
3382
3383 return true;
3384 }
3385
3386 bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
3387 {
3388 size_t row;
3389
3390 size_t curNumRows = m_data.GetCount();
3391 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3392 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3393
3394 if ( pos >= curNumCols )
3395 {
3396 wxFAIL_MSG( wxString::Format
3397 (
3398 wxT("Called wxGridStringTable::DeleteCols(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu cols"),
3399 (unsigned long)pos,
3400 (unsigned long)numCols,
3401 (unsigned long)curNumCols
3402 ) );
3403 return false;
3404 }
3405
3406 if ( numCols > curNumCols - pos )
3407 {
3408 numCols = curNumCols - pos;
3409 }
3410
3411 for ( row = 0; row < curNumRows; row++ )
3412 {
3413 if ( numCols >= curNumCols )
3414 {
3415 m_data[row].Clear();
3416 }
3417 else
3418 {
3419 m_data[row].RemoveAt( pos, numCols );
3420 }
3421 }
3422 if ( GetView() )
3423 {
3424 wxGridTableMessage msg( this,
3425 wxGRIDTABLE_NOTIFY_COLS_DELETED,
3426 pos,
3427 numCols );
3428
3429 GetView()->ProcessTableMessage( msg );
3430 }
3431
3432 return true;
3433 }
3434
3435 wxString wxGridStringTable::GetRowLabelValue( int row )
3436 {
3437 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3438 {
3439 // using default label
3440 //
3441 return wxGridTableBase::GetRowLabelValue( row );
3442 }
3443 else
3444 {
3445 return m_rowLabels[ row ];
3446 }
3447 }
3448
3449 wxString wxGridStringTable::GetColLabelValue( int col )
3450 {
3451 if ( col > (int)(m_colLabels.GetCount()) - 1 )
3452 {
3453 // using default label
3454 //
3455 return wxGridTableBase::GetColLabelValue( col );
3456 }
3457 else
3458 {
3459 return m_colLabels[ col ];
3460 }
3461 }
3462
3463 void wxGridStringTable::SetRowLabelValue( int row, const wxString& value )
3464 {
3465 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3466 {
3467 int n = m_rowLabels.GetCount();
3468 int i;
3469 for ( i = n; i <= row; i++ )
3470 {
3471 m_rowLabels.Add( wxGridTableBase::GetRowLabelValue(i) );
3472 }
3473 }
3474
3475 m_rowLabels[row] = value;
3476 }
3477
3478 void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
3479 {
3480 if ( col > (int)(m_colLabels.GetCount()) - 1 )
3481 {
3482 int n = m_colLabels.GetCount();
3483 int i;
3484 for ( i = n; i <= col; i++ )
3485 {
3486 m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
3487 }
3488 }
3489
3490 m_colLabels[col] = value;
3491 }
3492
3493
3494
3495 //////////////////////////////////////////////////////////////////////
3496 //////////////////////////////////////////////////////////////////////
3497
3498 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
3499
3500 BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
3501 EVT_PAINT( wxGridRowLabelWindow::OnPaint )
3502 EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel)
3503 EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
3504 EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
3505 EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp )
3506 END_EVENT_TABLE()
3507
3508 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
3509 wxWindowID id,
3510 const wxPoint &pos, const wxSize &size )
3511 : wxWindow( parent, id, pos, size, wxWANTS_CHARS|wxBORDER_NONE|wxFULL_REPAINT_ON_RESIZE )
3512 {
3513 m_owner = parent;
3514 }
3515
3516 void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3517 {
3518 wxPaintDC dc(this);
3519
3520 // NO - don't do this because it will set both the x and y origin
3521 // coords to match the parent scrolled window and we just want to
3522 // set the y coord - MB
3523 //
3524 // m_owner->PrepareDC( dc );
3525
3526 int x, y;
3527 m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3528 dc.SetDeviceOrigin( 0, -y );
3529
3530 wxArrayInt rows = m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
3531 m_owner->DrawRowLabels( dc , rows );
3532 }
3533
3534
3535 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
3536 {
3537 m_owner->ProcessRowLabelMouseEvent( event );
3538 }
3539
3540
3541 void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent& event )
3542 {
3543 m_owner->GetEventHandler()->ProcessEvent(event);
3544 }
3545
3546
3547 // This seems to be required for wxMotif otherwise the mouse
3548 // cursor must be in the cell edit control to get key events
3549 //
3550 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
3551 {
3552 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3553 }
3554
3555 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent& event )
3556 {
3557 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3558 }
3559
3560
3561
3562 //////////////////////////////////////////////////////////////////////
3563
3564 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
3565
3566 BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
3567 EVT_PAINT( wxGridColLabelWindow::OnPaint )
3568 EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel)
3569 EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
3570 EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
3571 EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp )
3572 END_EVENT_TABLE()
3573
3574 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
3575 wxWindowID id,
3576 const wxPoint &pos, const wxSize &size )
3577 : wxWindow( parent, id, pos, size, wxWANTS_CHARS|wxBORDER_NONE|wxFULL_REPAINT_ON_RESIZE )
3578 {
3579 m_owner = parent;
3580 }
3581
3582 void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3583 {
3584 wxPaintDC dc(this);
3585
3586 // NO - don't do this because it will set both the x and y origin
3587 // coords to match the parent scrolled window and we just want to
3588 // set the x coord - MB
3589 //
3590 // m_owner->PrepareDC( dc );
3591
3592 int x, y;
3593 m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3594 dc.SetDeviceOrigin( -x, 0 );
3595
3596 wxArrayInt cols = m_owner->CalcColLabelsExposed( GetUpdateRegion() );
3597 m_owner->DrawColLabels( dc , cols );
3598 }
3599
3600
3601 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
3602 {
3603 m_owner->ProcessColLabelMouseEvent( event );
3604 }
3605
3606 void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent& event )
3607 {
3608 m_owner->GetEventHandler()->ProcessEvent(event);
3609 }
3610
3611
3612 // This seems to be required for wxMotif otherwise the mouse
3613 // cursor must be in the cell edit control to get key events
3614 //
3615 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
3616 {
3617 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3618 }
3619
3620 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
3621 {
3622 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3623 }
3624
3625
3626
3627 //////////////////////////////////////////////////////////////////////
3628
3629 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
3630
3631 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
3632 EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel)
3633 EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
3634 EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
3635 EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
3636 EVT_KEY_UP( wxGridCornerLabelWindow::OnKeyUp )
3637 END_EVENT_TABLE()
3638
3639 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
3640 wxWindowID id,
3641 const wxPoint &pos, const wxSize &size )
3642 : wxWindow( parent, id, pos, size, wxWANTS_CHARS|wxBORDER_NONE|wxFULL_REPAINT_ON_RESIZE )
3643 {
3644 m_owner = parent;
3645 }
3646
3647 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3648 {
3649 wxPaintDC dc(this);
3650
3651 int client_height = 0;
3652 int client_width = 0;
3653 GetClientSize( &client_width, &client_height );
3654
3655 #if __WXGTK__
3656 wxRect rect;
3657 rect.SetX( 1 );
3658 rect.SetY( 1 );
3659 rect.SetWidth( client_width - 2 );
3660 rect.SetHeight( client_height - 2 );
3661
3662 wxRendererNative::Get().DrawHeaderButton( this, dc, rect, 0 );
3663 #else
3664 dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
3665 dc.DrawLine( client_width-1, client_height-1, client_width-1, 0 );
3666 dc.DrawLine( client_width-1, client_height-1, 0, client_height-1 );
3667 dc.DrawLine( 0, 0, client_width, 0 );
3668 dc.DrawLine( 0, 0, 0, client_height );
3669
3670 dc.SetPen( *wxWHITE_PEN );
3671 dc.DrawLine( 1, 1, client_width-1, 1 );
3672 dc.DrawLine( 1, 1, 1, client_height-1 );
3673 #endif
3674 }
3675
3676
3677 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
3678 {
3679 m_owner->ProcessCornerLabelMouseEvent( event );
3680 }
3681
3682
3683 void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent& event )
3684 {
3685 m_owner->GetEventHandler()->ProcessEvent(event);
3686 }
3687
3688 // This seems to be required for wxMotif otherwise the mouse
3689 // cursor must be in the cell edit control to get key events
3690 //
3691 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
3692 {
3693 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3694 }
3695
3696 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent& event )
3697 {
3698 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3699 }
3700
3701
3702
3703 //////////////////////////////////////////////////////////////////////
3704
3705 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxWindow )
3706
3707 BEGIN_EVENT_TABLE( wxGridWindow, wxWindow )
3708 EVT_PAINT( wxGridWindow::OnPaint )
3709 EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel)
3710 EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
3711 EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
3712 EVT_KEY_UP( wxGridWindow::OnKeyUp )
3713 EVT_SET_FOCUS( wxGridWindow::OnFocus )
3714 EVT_KILL_FOCUS( wxGridWindow::OnFocus )
3715 EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground )
3716 END_EVENT_TABLE()
3717
3718 wxGridWindow::wxGridWindow( wxGrid *parent,
3719 wxGridRowLabelWindow *rowLblWin,
3720 wxGridColLabelWindow *colLblWin,
3721 wxWindowID id,
3722 const wxPoint &pos,
3723 const wxSize &size )
3724 : wxWindow( parent, id, pos, size, wxWANTS_CHARS | wxBORDER_NONE | wxCLIP_CHILDREN|wxFULL_REPAINT_ON_RESIZE,
3725 wxT("grid window") )
3726
3727 {
3728 m_owner = parent;
3729 m_rowLabelWin = rowLblWin;
3730 m_colLabelWin = colLblWin;
3731 }
3732
3733
3734 void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
3735 {
3736 wxPaintDC dc( this );
3737 m_owner->PrepareDC( dc );
3738 wxRegion reg = GetUpdateRegion();
3739 wxGridCellCoordsArray DirtyCells = m_owner->CalcCellsExposed( reg );
3740 m_owner->DrawGridCellArea( dc , DirtyCells);
3741 #if WXGRID_DRAW_LINES
3742 m_owner->DrawAllGridLines( dc, reg );
3743 #endif
3744 m_owner->DrawGridSpace( dc );
3745 m_owner->DrawHighlight( dc , DirtyCells );
3746 }
3747
3748
3749 void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
3750 {
3751 wxWindow::ScrollWindow( dx, dy, rect );
3752 m_rowLabelWin->ScrollWindow( 0, dy, rect );
3753 m_colLabelWin->ScrollWindow( dx, 0, rect );
3754 }
3755
3756
3757 void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
3758 {
3759 m_owner->ProcessGridCellMouseEvent( event );
3760 }
3761
3762 void wxGridWindow::OnMouseWheel( wxMouseEvent& event )
3763 {
3764 m_owner->GetEventHandler()->ProcessEvent(event);
3765 }
3766
3767 // This seems to be required for wxMotif/wxGTK otherwise the mouse
3768 // cursor must be in the cell edit control to get key events
3769 //
3770 void wxGridWindow::OnKeyDown( wxKeyEvent& event )
3771 {
3772 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3773 }
3774
3775 void wxGridWindow::OnKeyUp( wxKeyEvent& event )
3776 {
3777 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3778 }
3779
3780 void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
3781 {
3782 }
3783
3784 void wxGridWindow::OnFocus(wxFocusEvent& event)
3785 {
3786 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
3787 event.Skip();
3788 }
3789
3790 //////////////////////////////////////////////////////////////////////
3791
3792 // Internal Helper function for computing row or column from some
3793 // (unscrolled) coordinate value, using either
3794 // m_defaultRowHeight/m_defaultColWidth or binary search on array
3795 // of m_rowBottoms/m_ColRights to speed up the search!
3796
3797 // Internal helper macros for simpler use of that function
3798
3799 static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
3800 const wxArrayInt& BorderArray, int nMax,
3801 bool clipToMinMax);
3802
3803 #define internalXToCol(x) CoordToRowOrCol(x, m_defaultColWidth, \
3804 m_minAcceptableColWidth, \
3805 m_colRights, m_numCols, true)
3806 #define internalYToRow(y) CoordToRowOrCol(y, m_defaultRowHeight, \
3807 m_minAcceptableRowHeight, \
3808 m_rowBottoms, m_numRows, true)
3809 /////////////////////////////////////////////////////////////////////
3810
3811 #if wxUSE_EXTENDED_RTTI
3812 WX_DEFINE_FLAGS( wxGridStyle )
3813
3814 wxBEGIN_FLAGS( wxGridStyle )
3815 // new style border flags, we put them first to
3816 // use them for streaming out
3817 wxFLAGS_MEMBER(wxBORDER_SIMPLE)
3818 wxFLAGS_MEMBER(wxBORDER_SUNKEN)
3819 wxFLAGS_MEMBER(wxBORDER_DOUBLE)
3820 wxFLAGS_MEMBER(wxBORDER_RAISED)
3821 wxFLAGS_MEMBER(wxBORDER_STATIC)
3822 wxFLAGS_MEMBER(wxBORDER_NONE)
3823
3824 // old style border flags
3825 wxFLAGS_MEMBER(wxSIMPLE_BORDER)
3826 wxFLAGS_MEMBER(wxSUNKEN_BORDER)
3827 wxFLAGS_MEMBER(wxDOUBLE_BORDER)
3828 wxFLAGS_MEMBER(wxRAISED_BORDER)
3829 wxFLAGS_MEMBER(wxSTATIC_BORDER)
3830 wxFLAGS_MEMBER(wxBORDER)
3831
3832 // standard window styles
3833 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
3834 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
3835 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
3836 wxFLAGS_MEMBER(wxWANTS_CHARS)
3837 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
3838 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
3839 wxFLAGS_MEMBER(wxVSCROLL)
3840 wxFLAGS_MEMBER(wxHSCROLL)
3841
3842 wxEND_FLAGS( wxGridStyle )
3843
3844 IMPLEMENT_DYNAMIC_CLASS_XTI(wxGrid, wxScrolledWindow,"wx/grid.h")
3845
3846 wxBEGIN_PROPERTIES_TABLE(wxGrid)
3847 wxHIDE_PROPERTY( Children )
3848 wxPROPERTY_FLAGS( WindowStyle , wxGridStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
3849 wxEND_PROPERTIES_TABLE()
3850
3851 wxBEGIN_HANDLERS_TABLE(wxGrid)
3852 wxEND_HANDLERS_TABLE()
3853
3854 wxCONSTRUCTOR_5( wxGrid , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
3855
3856 /*
3857 TODO : Expose more information of a list's layout etc. via appropriate objects (\81à la NotebookPageInfo)
3858 */
3859 #else
3860 IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
3861 #endif
3862
3863 BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
3864 EVT_PAINT( wxGrid::OnPaint )
3865 EVT_SIZE( wxGrid::OnSize )
3866 EVT_KEY_DOWN( wxGrid::OnKeyDown )
3867 EVT_KEY_UP( wxGrid::OnKeyUp )
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 // is it possible to edit the current cell at all?
6470 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
6471 {
6472 // yes, now check whether the cells editor accepts the key
6473 int row = m_currentCellCoords.GetRow();
6474 int col = m_currentCellCoords.GetCol();
6475 wxGridCellAttr* attr = GetCellAttr(row, col);
6476 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6477
6478 // <F2> is special and will always start editing, for
6479 // other keys - ask the editor itself
6480 if ( (event.GetKeyCode() == WXK_F2 && !event.HasModifiers())
6481 || editor->IsAcceptedKey(event) )
6482 {
6483 // ensure cell is visble
6484 MakeCellVisible(row, col);
6485 EnableCellEditControl();
6486
6487 // a problem can arise if the cell is not completely
6488 // visible (even after calling MakeCellVisible the
6489 // control is not created and calling StartingKey will
6490 // crash the app
6491 if( editor->IsCreated() && m_cellEditCtrlEnabled ) editor->StartingKey(event);
6492 }
6493 else
6494 {
6495 event.Skip();
6496 }
6497
6498 editor->DecRef();
6499 attr->DecRef();
6500 }
6501 else
6502 {
6503 // let others process char events with modifiers or all
6504 // char events for readonly cells
6505 event.Skip();
6506 }
6507 break;
6508 }
6509 }
6510
6511 m_inOnKeyDown = false;
6512 }
6513
6514 void wxGrid::OnKeyUp( wxKeyEvent& event )
6515 {
6516 // try local handlers
6517 //
6518 if ( event.GetKeyCode() == WXK_SHIFT )
6519 {
6520 if ( m_selectingTopLeft != wxGridNoCellCoords &&
6521 m_selectingBottomRight != wxGridNoCellCoords )
6522 {
6523 if ( m_selection )
6524 {
6525 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
6526 m_selectingTopLeft.GetCol(),
6527 m_selectingBottomRight.GetRow(),
6528 m_selectingBottomRight.GetCol(),
6529 event.ControlDown(),
6530 true,
6531 event.AltDown(),
6532 event.MetaDown() );
6533 }
6534 }
6535
6536 m_selectingTopLeft = wxGridNoCellCoords;
6537 m_selectingBottomRight = wxGridNoCellCoords;
6538 m_selectingKeyboard = wxGridNoCellCoords;
6539 }
6540 }
6541
6542 void wxGrid::OnEraseBackground(wxEraseEvent&)
6543 {
6544 }
6545
6546 void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
6547 {
6548 if ( SendEvent( wxEVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
6549 {
6550 // the event has been intercepted - do nothing
6551 return;
6552 }
6553
6554 wxClientDC dc(m_gridWin);
6555 PrepareDC(dc);
6556
6557 if ( m_currentCellCoords != wxGridNoCellCoords )
6558 {
6559 DisableCellEditControl();
6560
6561 if ( IsVisible( m_currentCellCoords, false ) )
6562 {
6563 wxRect r;
6564 r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
6565 if ( !m_gridLinesEnabled )
6566 {
6567 r.x--;
6568 r.y--;
6569 r.width++;
6570 r.height++;
6571 }
6572
6573 wxGridCellCoordsArray cells = CalcCellsExposed( r );
6574
6575 // Otherwise refresh redraws the highlight!
6576 m_currentCellCoords = coords;
6577
6578 DrawGridCellArea(dc,cells);
6579 DrawAllGridLines( dc, r );
6580 }
6581 }
6582
6583 m_currentCellCoords = coords;
6584
6585 wxGridCellAttr* attr = GetCellAttr(coords);
6586 DrawCellHighlight(dc, attr);
6587 attr->DecRef();
6588 }
6589
6590
6591 void wxGrid::HighlightBlock( int topRow, int leftCol, int bottomRow, int rightCol )
6592 {
6593 int temp;
6594 wxGridCellCoords updateTopLeft, updateBottomRight;
6595
6596 if ( m_selection )
6597 {
6598 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
6599 {
6600 leftCol = 0;
6601 rightCol = GetNumberCols() - 1;
6602 }
6603 else if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
6604 {
6605 topRow = 0;
6606 bottomRow = GetNumberRows() - 1;
6607 }
6608 }
6609
6610 if ( topRow > bottomRow )
6611 {
6612 temp = topRow;
6613 topRow = bottomRow;
6614 bottomRow = temp;
6615 }
6616
6617 if ( leftCol > rightCol )
6618 {
6619 temp = leftCol;
6620 leftCol = rightCol;
6621 rightCol = temp;
6622 }
6623
6624 updateTopLeft = wxGridCellCoords( topRow, leftCol );
6625 updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
6626
6627 // First the case that we selected a completely new area
6628 if ( m_selectingTopLeft == wxGridNoCellCoords ||
6629 m_selectingBottomRight == wxGridNoCellCoords )
6630 {
6631 wxRect rect;
6632 rect = BlockToDeviceRect( wxGridCellCoords ( topRow, leftCol ),
6633 wxGridCellCoords ( bottomRow, rightCol ) );
6634 m_gridWin->Refresh( false, &rect );
6635 }
6636 // Now handle changing an existing selection area.
6637 else if ( m_selectingTopLeft != updateTopLeft ||
6638 m_selectingBottomRight != updateBottomRight )
6639 {
6640 // Compute two optimal update rectangles:
6641 // Either one rectangle is a real subset of the
6642 // other, or they are (almost) disjoint!
6643 wxRect rect[4];
6644 bool need_refresh[4];
6645 need_refresh[0] =
6646 need_refresh[1] =
6647 need_refresh[2] =
6648 need_refresh[3] = false;
6649 int i;
6650
6651 // Store intermediate values
6652 wxCoord oldLeft = m_selectingTopLeft.GetCol();
6653 wxCoord oldTop = m_selectingTopLeft.GetRow();
6654 wxCoord oldRight = m_selectingBottomRight.GetCol();
6655 wxCoord oldBottom = m_selectingBottomRight.GetRow();
6656
6657 // Determine the outer/inner coordinates.
6658 if (oldLeft > leftCol)
6659 {
6660 temp = oldLeft;
6661 oldLeft = leftCol;
6662 leftCol = temp;
6663 }
6664 if (oldTop > topRow )
6665 {
6666 temp = oldTop;
6667 oldTop = topRow;
6668 topRow = temp;
6669 }
6670 if (oldRight < rightCol )
6671 {
6672 temp = oldRight;
6673 oldRight = rightCol;
6674 rightCol = temp;
6675 }
6676 if (oldBottom < bottomRow)
6677 {
6678 temp = oldBottom;
6679 oldBottom = bottomRow;
6680 bottomRow = temp;
6681 }
6682
6683 // Now, either the stuff marked old is the outer
6684 // rectangle or we don't have a situation where one
6685 // is contained in the other.
6686
6687 if ( oldLeft < leftCol )
6688 {
6689 // Refresh the newly selected or deselected
6690 // area to the left of the old or new selection.
6691 need_refresh[0] = true;
6692 rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6693 oldLeft ),
6694 wxGridCellCoords ( oldBottom,
6695 leftCol - 1 ) );
6696 }
6697
6698 if ( oldTop < topRow )
6699 {
6700 // Refresh the newly selected or deselected
6701 // area above the old or new selection.
6702 need_refresh[1] = true;
6703 rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6704 leftCol ),
6705 wxGridCellCoords ( topRow - 1,
6706 rightCol ) );
6707 }
6708
6709 if ( oldRight > rightCol )
6710 {
6711 // Refresh the newly selected or deselected
6712 // area to the right of the old or new selection.
6713 need_refresh[2] = true;
6714 rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6715 rightCol + 1 ),
6716 wxGridCellCoords ( oldBottom,
6717 oldRight ) );
6718 }
6719
6720 if ( oldBottom > bottomRow )
6721 {
6722 // Refresh the newly selected or deselected
6723 // area below the old or new selection.
6724 need_refresh[3] = true;
6725 rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
6726 leftCol ),
6727 wxGridCellCoords ( oldBottom,
6728 rightCol ) );
6729 }
6730
6731 // various Refresh() calls
6732 for (i = 0; i < 4; i++ )
6733 if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
6734 m_gridWin->Refresh( false, &(rect[i]) );
6735 }
6736 // Change Selection
6737 m_selectingTopLeft = updateTopLeft;
6738 m_selectingBottomRight = updateBottomRight;
6739 }
6740
6741 //
6742 // ------ functions to get/send data (see also public functions)
6743 //
6744
6745 bool wxGrid::GetModelValues()
6746 {
6747 // Hide the editor, so it won't hide a changed value.
6748 HideCellEditControl();
6749
6750 if ( m_table )
6751 {
6752 // all we need to do is repaint the grid
6753 //
6754 m_gridWin->Refresh();
6755 return true;
6756 }
6757
6758 return false;
6759 }
6760
6761
6762 bool wxGrid::SetModelValues()
6763 {
6764 int row, col;
6765
6766 // Disable the editor, so it won't hide a changed value.
6767 // Do we also want to save the current value of the editor first?
6768 // I think so ...
6769 DisableCellEditControl();
6770
6771 if ( m_table )
6772 {
6773 for ( row = 0; row < m_numRows; row++ )
6774 {
6775 for ( col = 0; col < m_numCols; col++ )
6776 {
6777 m_table->SetValue( row, col, GetCellValue(row, col) );
6778 }
6779 }
6780
6781 return true;
6782 }
6783
6784 return false;
6785 }
6786
6787
6788
6789 // Note - this function only draws cells that are in the list of
6790 // exposed cells (usually set from the update region by
6791 // CalcExposedCells)
6792 //
6793 void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
6794 {
6795 if ( !m_numRows || !m_numCols ) return;
6796
6797 int i, numCells = cells.GetCount();
6798 int row, col, cell_rows, cell_cols;
6799 wxGridCellCoordsArray redrawCells;
6800
6801 for ( i = numCells-1; i >= 0; i-- )
6802 {
6803 row = cells[i].GetRow();
6804 col = cells[i].GetCol();
6805 GetCellSize( row, col, &cell_rows, &cell_cols );
6806
6807 // If this cell is part of a multicell block, find owner for repaint
6808 if ( cell_rows <= 0 || cell_cols <= 0 )
6809 {
6810 wxGridCellCoords cell(row+cell_rows, col+cell_cols);
6811 bool marked = false;
6812 for ( int j = 0; j < numCells; j++ )
6813 {
6814 if ( cell == cells[j] )
6815 {
6816 marked = true;
6817 break;
6818 }
6819 }
6820 if (!marked)
6821 {
6822 int count = redrawCells.GetCount();
6823 for (int j = 0; j < count; j++)
6824 {
6825 if ( cell == redrawCells[j] )
6826 {
6827 marked = true;
6828 break;
6829 }
6830 }
6831 if (!marked) redrawCells.Add( cell );
6832 }
6833 continue; // don't bother drawing this cell
6834 }
6835
6836 // If this cell is empty, find cell to left that might want to overflow
6837 if (m_table && m_table->IsEmptyCell(row, col))
6838 {
6839 for ( int l = 0; l < cell_rows; l++ )
6840 {
6841 // find a cell in this row to left alreay marked for repaint
6842 int left = col;
6843 for (int k = 0; k < int(redrawCells.GetCount()); k++)
6844 if ((redrawCells[k].GetCol() < left) &&
6845 (redrawCells[k].GetRow() == row))
6846 left=redrawCells[k].GetCol();
6847
6848 if (left == col) left = 0; // oh well
6849
6850 for (int j = col-1; j >= left; j--)
6851 {
6852 if (!m_table->IsEmptyCell(row+l, j))
6853 {
6854 if (GetCellOverflow(row+l, j))
6855 {
6856 wxGridCellCoords cell(row+l, j);
6857 bool marked = false;
6858
6859 for (int k = 0; k < numCells; k++)
6860 {
6861 if ( cell == cells[k] )
6862 {
6863 marked = true;
6864 break;
6865 }
6866 }
6867 if (!marked)
6868 {
6869 int count = redrawCells.GetCount();
6870 for (int k = 0; k < count; k++)
6871 {
6872 if ( cell == redrawCells[k] )
6873 {
6874 marked = true;
6875 break;
6876 }
6877 }
6878 if (!marked) redrawCells.Add( cell );
6879 }
6880 }
6881 break;
6882 }
6883 }
6884 }
6885 }
6886 DrawCell( dc, cells[i] );
6887 }
6888
6889 numCells = redrawCells.GetCount();
6890
6891 for ( i = numCells - 1; i >= 0; i-- )
6892 {
6893 DrawCell( dc, redrawCells[i] );
6894 }
6895 }
6896
6897
6898 void wxGrid::DrawGridSpace( wxDC& dc )
6899 {
6900 int cw, ch;
6901 m_gridWin->GetClientSize( &cw, &ch );
6902
6903 int right, bottom;
6904 CalcUnscrolledPosition( cw, ch, &right, &bottom );
6905
6906 int rightCol = m_numCols > 0 ? GetColRight(m_numCols - 1) : 0;
6907 int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0 ;
6908
6909 if ( right > rightCol || bottom > bottomRow )
6910 {
6911 int left, top;
6912 CalcUnscrolledPosition( 0, 0, &left, &top );
6913
6914 dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
6915 dc.SetPen( *wxTRANSPARENT_PEN );
6916
6917 if ( right > rightCol )
6918 {
6919 dc.DrawRectangle( rightCol, top, right - rightCol, ch);
6920 }
6921
6922 if ( bottom > bottomRow )
6923 {
6924 dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow);
6925 }
6926 }
6927 }
6928
6929
6930 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
6931 {
6932 int row = coords.GetRow();
6933 int col = coords.GetCol();
6934
6935 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6936 return;
6937
6938 // we draw the cell border ourselves
6939 #if !WXGRID_DRAW_LINES
6940 if ( m_gridLinesEnabled )
6941 DrawCellBorder( dc, coords );
6942 #endif
6943
6944 wxGridCellAttr* attr = GetCellAttr(row, col);
6945
6946 bool isCurrent = coords == m_currentCellCoords;
6947
6948 wxRect rect = CellToRect( row, col );
6949
6950 // if the editor is shown, we should use it and not the renderer
6951 // Note: However, only if it is really _shown_, i.e. not hidden!
6952 if ( isCurrent && IsCellEditControlShown() )
6953 {
6954 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6955 editor->PaintBackground(rect, attr);
6956 editor->DecRef();
6957 }
6958 else
6959 {
6960 // but all the rest is drawn by the cell renderer and hence may be
6961 // customized
6962 wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
6963 renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
6964 renderer->DecRef();
6965 }
6966
6967 attr->DecRef();
6968 }
6969
6970 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
6971 {
6972 int row = m_currentCellCoords.GetRow();
6973 int col = m_currentCellCoords.GetCol();
6974
6975 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6976 return;
6977
6978 wxRect rect = CellToRect(row, col);
6979
6980 // hmmm... what could we do here to show that the cell is disabled?
6981 // for now, I just draw a thinner border than for the other ones, but
6982 // it doesn't look really good
6983
6984 int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
6985
6986 if (penWidth > 0)
6987 {
6988 // The center of th drawn line is where the position/width/height of
6989 // the rectangle is actually at, (on wxMSW atr least,) so we will
6990 // reduce the size of the rectangle to compensate for the thickness of
6991 // the line. If this is too strange on non wxMSW platforms then
6992 // please #ifdef this appropriately.
6993 rect.x += penWidth/2;
6994 rect.y += penWidth/2;
6995 rect.width -= penWidth-1;
6996 rect.height -= penWidth-1;
6997
6998
6999 // Now draw the rectangle
7000 // use the cellHighlightColour if the cell is inside a selection, this
7001 // will ensure the cell is always visible.
7002 dc.SetPen(wxPen(IsInSelection(row,col)?m_selectionForeground:m_cellHighlightColour, penWidth, wxSOLID));
7003 dc.SetBrush(*wxTRANSPARENT_BRUSH);
7004 dc.DrawRectangle(rect);
7005 }
7006
7007 #if 0
7008 // VZ: my experiments with 3d borders...
7009
7010 // how to properly set colours for arbitrary bg?
7011 wxCoord x1 = rect.x,
7012 y1 = rect.y,
7013 x2 = rect.x + rect.width -1,
7014 y2 = rect.y + rect.height -1;
7015
7016 dc.SetPen(*wxWHITE_PEN);
7017 dc.DrawLine(x1, y1, x2, y1);
7018 dc.DrawLine(x1, y1, x1, y2);
7019
7020 dc.DrawLine(x1 + 1, y2 - 1, x2 - 1, y2 - 1);
7021 dc.DrawLine(x2 - 1, y1 + 1, x2 - 1, y2 );
7022
7023 dc.SetPen(*wxBLACK_PEN);
7024 dc.DrawLine(x1, y2, x2, y2);
7025 dc.DrawLine(x2, y1, x2, y2+1);
7026 #endif // 0
7027 }
7028
7029
7030 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
7031 {
7032 int row = coords.GetRow();
7033 int col = coords.GetCol();
7034 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7035 return;
7036
7037 dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
7038
7039 wxRect rect = CellToRect( row, col );
7040
7041 // right hand border
7042 //
7043 dc.DrawLine( rect.x + rect.width, rect.y,
7044 rect.x + rect.width, rect.y + rect.height + 1 );
7045
7046 // bottom border
7047 //
7048 dc.DrawLine( rect.x, rect.y + rect.height,
7049 rect.x + rect.width, rect.y + rect.height);
7050 }
7051
7052 void wxGrid::DrawHighlight(wxDC& dc,const wxGridCellCoordsArray& cells)
7053 {
7054 // This if block was previously in wxGrid::OnPaint but that doesn't
7055 // seem to get called under wxGTK - MB
7056 //
7057 if ( m_currentCellCoords == wxGridNoCellCoords &&
7058 m_numRows && m_numCols )
7059 {
7060 m_currentCellCoords.Set(0, 0);
7061 }
7062
7063 if ( IsCellEditControlShown() )
7064 {
7065 // don't show highlight when the edit control is shown
7066 return;
7067 }
7068
7069 // if the active cell was repainted, repaint its highlight too because it
7070 // might have been damaged by the grid lines
7071 size_t count = cells.GetCount();
7072 for ( size_t n = 0; n < count; n++ )
7073 {
7074 if ( cells[n] == m_currentCellCoords )
7075 {
7076 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
7077 DrawCellHighlight(dc, attr);
7078 attr->DecRef();
7079
7080 break;
7081 }
7082 }
7083 }
7084
7085 // TODO: remove this ???
7086 // This is used to redraw all grid lines e.g. when the grid line colour
7087 // has been changed
7088 //
7089 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
7090 {
7091 #if !WXGRID_DRAW_LINES
7092 return;
7093 #endif
7094
7095 if ( !m_gridLinesEnabled ||
7096 !m_numRows ||
7097 !m_numCols ) return;
7098
7099 int top, bottom, left, right;
7100
7101 #if 0 //#ifndef __WXGTK__
7102 if (reg.IsEmpty())
7103 {
7104 int cw, ch;
7105 m_gridWin->GetClientSize(&cw, &ch);
7106
7107 // virtual coords of visible area
7108 //
7109 CalcUnscrolledPosition( 0, 0, &left, &top );
7110 CalcUnscrolledPosition( cw, ch, &right, &bottom );
7111 }
7112 else
7113 {
7114 wxCoord x, y, w, h;
7115 reg.GetBox(x, y, w, h);
7116 CalcUnscrolledPosition( x, y, &left, &top );
7117 CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
7118 }
7119 #else
7120 int cw, ch;
7121 m_gridWin->GetClientSize(&cw, &ch);
7122 CalcUnscrolledPosition( 0, 0, &left, &top );
7123 CalcUnscrolledPosition( cw, ch, &right, &bottom );
7124 #endif
7125
7126 // avoid drawing grid lines past the last row and col
7127 //
7128 right = wxMin( right, GetColRight(m_numCols - 1) );
7129 bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );
7130
7131 // no gridlines inside multicells, clip them out
7132 int leftCol = internalXToCol(left);
7133 int topRow = internalYToRow(top);
7134 int rightCol = internalXToCol(right);
7135 int bottomRow = internalYToRow(bottom);
7136 wxRegion clippedcells(0, 0, cw, ch);
7137
7138
7139 int i, j, cell_rows, cell_cols;
7140 wxRect rect;
7141
7142 for (j=topRow; j<bottomRow; j++)
7143 {
7144 for (i=leftCol; i<rightCol; i++)
7145 {
7146 GetCellSize( j, i, &cell_rows, &cell_cols );
7147 if ((cell_rows > 1) || (cell_cols > 1))
7148 {
7149 rect = CellToRect(j,i);
7150 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
7151 clippedcells.Subtract(rect);
7152 }
7153 else if ((cell_rows < 0) || (cell_cols < 0))
7154 {
7155 rect = CellToRect(j+cell_rows, i+cell_cols);
7156 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
7157 clippedcells.Subtract(rect);
7158 }
7159 }
7160 }
7161 dc.SetClippingRegion( clippedcells );
7162
7163 dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
7164
7165 // horizontal grid lines
7166 //
7167 // already declared above - int i;
7168 for ( i = internalYToRow(top); i < m_numRows; i++ )
7169 {
7170 int bot = GetRowBottom(i) - 1;
7171
7172 if ( bot > bottom )
7173 {
7174 break;
7175 }
7176
7177 if ( bot >= top )
7178 {
7179 dc.DrawLine( left, bot, right, bot );
7180 }
7181 }
7182
7183
7184 // vertical grid lines
7185 //
7186 for ( i = internalXToCol(left); i < m_numCols; i++ )
7187 {
7188 int colRight = GetColRight(i) - 1;
7189 if ( colRight > right )
7190 {
7191 break;
7192 }
7193
7194 if ( colRight >= left )
7195 {
7196 dc.DrawLine( colRight, top, colRight, bottom );
7197 }
7198 }
7199 dc.DestroyClippingRegion();
7200 }
7201
7202
7203 void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
7204 {
7205 if ( !m_numRows ) return;
7206
7207 size_t i;
7208 size_t numLabels = rows.GetCount();
7209
7210 for ( i = 0; i < numLabels; i++ )
7211 {
7212 DrawRowLabel( dc, rows[i] );
7213 }
7214 }
7215
7216
7217 void wxGrid::DrawRowLabel( wxDC& dc, int row )
7218 {
7219 if ( GetRowHeight(row) <= 0 )
7220 return;
7221
7222 wxRect rect;
7223 #ifdef __WXGTK__
7224 rect.SetX( 1 );
7225 rect.SetY( GetRowTop(row) + 1 );
7226 rect.SetWidth( m_rowLabelWidth - 2 );
7227 rect.SetHeight( GetRowHeight(row) - 2 );
7228
7229 CalcScrolledPosition( 0, rect.y, NULL, &rect.y );
7230
7231 wxWindowDC *win_dc = (wxWindowDC*) &dc;
7232
7233 wxRendererNative::Get().DrawHeaderButton( win_dc->m_owner, dc, rect, 0 );
7234 #else
7235 int rowTop = GetRowTop(row),
7236 rowBottom = GetRowBottom(row) - 1;
7237
7238 dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
7239 dc.DrawLine( m_rowLabelWidth-1, rowTop,
7240 m_rowLabelWidth-1, rowBottom );
7241
7242 dc.DrawLine( 0, rowTop, 0, rowBottom );
7243
7244 dc.DrawLine( 0, rowBottom, m_rowLabelWidth, rowBottom );
7245
7246 dc.SetPen( *wxWHITE_PEN );
7247 dc.DrawLine( 1, rowTop, 1, rowBottom );
7248 dc.DrawLine( 1, rowTop, m_rowLabelWidth-1, rowTop );
7249 #endif
7250 dc.SetBackgroundMode( wxTRANSPARENT );
7251 dc.SetTextForeground( GetLabelTextColour() );
7252 dc.SetFont( GetLabelFont() );
7253
7254 int hAlign, vAlign;
7255 GetRowLabelAlignment( &hAlign, &vAlign );
7256
7257 rect.SetX( 2 );
7258 rect.SetY( GetRowTop(row) + 2 );
7259 rect.SetWidth( m_rowLabelWidth - 4 );
7260 rect.SetHeight( GetRowHeight(row) - 4 );
7261 DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
7262 }
7263
7264
7265 void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
7266 {
7267 if ( !m_numCols ) return;
7268
7269 size_t i;
7270 size_t numLabels = cols.GetCount();
7271
7272 for ( i = 0; i < numLabels; i++ )
7273 {
7274 DrawColLabel( dc, cols[i] );
7275 }
7276 }
7277
7278
7279 void wxGrid::DrawColLabel( wxDC& dc, int col )
7280 {
7281 if ( GetColWidth(col) <= 0 )
7282 return;
7283
7284 int colLeft = GetColLeft(col);
7285
7286 wxRect rect;
7287 #ifdef __WXGTK__
7288 rect.SetX( colLeft + 1 );
7289 rect.SetY( 1 );
7290 rect.SetWidth( GetColWidth(col) - 2 );
7291 rect.SetHeight( m_colLabelHeight - 2 );
7292
7293 wxWindowDC *win_dc = (wxWindowDC*) &dc;
7294
7295 wxRendererNative::Get().DrawHeaderButton( win_dc->m_owner, dc, rect, 0 );
7296 #else
7297 int colRight = GetColRight(col) - 1;
7298
7299 dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
7300 dc.DrawLine( colRight, 0,
7301 colRight, m_colLabelHeight-1 );
7302
7303 dc.DrawLine( colLeft, 0, colRight, 0 );
7304
7305 dc.DrawLine( colLeft, m_colLabelHeight-1,
7306 colRight+1, m_colLabelHeight-1 );
7307
7308 dc.SetPen( *wxWHITE_PEN );
7309 dc.DrawLine( colLeft, 1, colLeft, m_colLabelHeight-1 );
7310 dc.DrawLine( colLeft, 1, colRight, 1 );
7311 #endif
7312 dc.SetBackgroundMode( wxTRANSPARENT );
7313 dc.SetTextForeground( GetLabelTextColour() );
7314 dc.SetFont( GetLabelFont() );
7315
7316 int hAlign, vAlign, orient;
7317 GetColLabelAlignment( &hAlign, &vAlign );
7318 orient = GetColLabelTextOrientation();
7319
7320 rect.SetX( colLeft + 2 );
7321 rect.SetY( 2 );
7322 rect.SetWidth( GetColWidth(col) - 4 );
7323 rect.SetHeight( m_colLabelHeight - 4 );
7324 DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign, orient );
7325 }
7326
7327 void wxGrid::DrawTextRectangle( wxDC& dc,
7328 const wxString& value,
7329 const wxRect& rect,
7330 int horizAlign,
7331 int vertAlign,
7332 int textOrientation )
7333 {
7334 wxArrayString lines;
7335
7336 StringToLines( value, lines );
7337
7338
7339 //Forward to new API.
7340 DrawTextRectangle( dc,
7341 lines,
7342 rect,
7343 horizAlign,
7344 vertAlign,
7345 textOrientation );
7346
7347 }
7348
7349 void wxGrid::DrawTextRectangle( wxDC& dc,
7350 const wxArrayString& lines,
7351 const wxRect& rect,
7352 int horizAlign,
7353 int vertAlign,
7354 int textOrientation )
7355 {
7356 long textWidth, textHeight;
7357 long lineWidth, lineHeight;
7358 int nLines;
7359
7360 dc.SetClippingRegion( rect );
7361
7362 nLines = lines.GetCount();
7363 if( nLines > 0 )
7364 {
7365 int l;
7366 float x = 0.0, y = 0.0;
7367
7368 if( textOrientation == wxHORIZONTAL )
7369 GetTextBoxSize(dc, lines, &textWidth, &textHeight);
7370 else
7371 GetTextBoxSize( dc, lines, &textHeight, &textWidth );
7372
7373 switch( vertAlign )
7374 {
7375 case wxALIGN_BOTTOM:
7376 if( textOrientation == wxHORIZONTAL )
7377 y = rect.y + (rect.height - textHeight - 1);
7378 else
7379 x = rect.x + rect.width - textWidth;
7380 break;
7381
7382 case wxALIGN_CENTRE:
7383 if( textOrientation == wxHORIZONTAL )
7384 y = rect.y + ((rect.height - textHeight)/2);
7385 else
7386 x = rect.x + ((rect.width - textWidth)/2);
7387 break;
7388
7389 case wxALIGN_TOP:
7390 default:
7391 if( textOrientation == wxHORIZONTAL )
7392 y = rect.y + 1;
7393 else
7394 x = rect.x + 1;
7395 break;
7396 }
7397
7398 // Align each line of a multi-line label
7399 for( l = 0; l < nLines; l++ )
7400 {
7401 dc.GetTextExtent(lines[l], &lineWidth, &lineHeight);
7402
7403 switch( horizAlign )
7404 {
7405 case wxALIGN_RIGHT:
7406 if( textOrientation == wxHORIZONTAL )
7407 x = rect.x + (rect.width - lineWidth - 1);
7408 else
7409 y = rect.y + lineWidth + 1;
7410 break;
7411
7412 case wxALIGN_CENTRE:
7413 if( textOrientation == wxHORIZONTAL )
7414 x = rect.x + ((rect.width - lineWidth)/2);
7415 else
7416 y = rect.y + rect.height - ((rect.height - lineWidth)/2);
7417 break;
7418
7419 case wxALIGN_LEFT:
7420 default:
7421 if( textOrientation == wxHORIZONTAL )
7422 x = rect.x + 1;
7423 else
7424 y = rect.y + rect.height - 1;
7425 break;
7426 }
7427
7428 if( textOrientation == wxHORIZONTAL )
7429 {
7430 dc.DrawText( lines[l], (int)x, (int)y );
7431 y += lineHeight;
7432 }
7433 else
7434 {
7435 dc.DrawRotatedText( lines[l], (int)x, (int)y, 90.0 );
7436 x += lineHeight;
7437 }
7438 }
7439 }
7440 dc.DestroyClippingRegion();
7441 }
7442
7443
7444 // Split multi line text up into an array of strings. Any existing
7445 // contents of the string array are preserved.
7446 //
7447 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
7448 {
7449 int startPos = 0;
7450 int pos;
7451 wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
7452 wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
7453
7454 while ( startPos < (int)tVal.Length() )
7455 {
7456 pos = tVal.Mid(startPos).Find( eol );
7457 if ( pos < 0 )
7458 {
7459 break;
7460 }
7461 else if ( pos == 0 )
7462 {
7463 lines.Add( wxEmptyString );
7464 }
7465 else
7466 {
7467 lines.Add( value.Mid(startPos, pos) );
7468 }
7469 startPos += pos+1;
7470 }
7471 if ( startPos < (int)value.Length() )
7472 {
7473 lines.Add( value.Mid( startPos ) );
7474 }
7475 }
7476
7477
7478 void wxGrid::GetTextBoxSize( wxDC& dc,
7479 const wxArrayString& lines,
7480 long *width, long *height )
7481 {
7482 long w = 0;
7483 long h = 0;
7484 long lineW, lineH;
7485
7486 size_t i;
7487 for ( i = 0; i < lines.GetCount(); i++ )
7488 {
7489 dc.GetTextExtent( lines[i], &lineW, &lineH );
7490 w = wxMax( w, lineW );
7491 h += lineH;
7492 }
7493
7494 *width = w;
7495 *height = h;
7496 }
7497
7498 //
7499 // ------ Batch processing.
7500 //
7501 void wxGrid::EndBatch()
7502 {
7503 if ( m_batchCount > 0 )
7504 {
7505 m_batchCount--;
7506 if ( !m_batchCount )
7507 {
7508 CalcDimensions();
7509 m_rowLabelWin->Refresh();
7510 m_colLabelWin->Refresh();
7511 m_cornerLabelWin->Refresh();
7512 m_gridWin->Refresh();
7513 }
7514 }
7515 }
7516
7517 // Use this, rather than wxWindow::Refresh(), to force an immediate
7518 // repainting of the grid. Has no effect if you are already inside a
7519 // BeginBatch / EndBatch block.
7520 //
7521 void wxGrid::ForceRefresh()
7522 {
7523 BeginBatch();
7524 EndBatch();
7525 }
7526
7527 bool wxGrid::Enable(bool enable)
7528 {
7529 if ( !wxScrolledWindow::Enable(enable) )
7530 return false;
7531
7532 // redraw in the new state
7533 m_gridWin->Refresh();
7534
7535 return true;
7536 }
7537
7538 //
7539 // ------ Edit control functions
7540 //
7541
7542
7543 void wxGrid::EnableEditing( bool edit )
7544 {
7545 // TODO: improve this ?
7546 //
7547 if ( edit != m_editable )
7548 {
7549 if(!edit) EnableCellEditControl(edit);
7550 m_editable = edit;
7551 }
7552 }
7553
7554
7555 void wxGrid::EnableCellEditControl( bool enable )
7556 {
7557 if (! m_editable)
7558 return;
7559
7560 if ( m_currentCellCoords == wxGridNoCellCoords )
7561 SetCurrentCell( 0, 0 );
7562
7563 if ( enable != m_cellEditCtrlEnabled )
7564 {
7565 if ( enable )
7566 {
7567 if (SendEvent( wxEVT_GRID_EDITOR_SHOWN) <0)
7568 return;
7569
7570 // this should be checked by the caller!
7571 wxASSERT_MSG( CanEnableCellControl(),
7572 _T("can't enable editing for this cell!") );
7573
7574 // do it before ShowCellEditControl()
7575 m_cellEditCtrlEnabled = enable;
7576
7577 ShowCellEditControl();
7578 }
7579 else
7580 {
7581 //FIXME:add veto support
7582 SendEvent( wxEVT_GRID_EDITOR_HIDDEN);
7583
7584 HideCellEditControl();
7585 SaveEditControlValue();
7586
7587 // do it after HideCellEditControl()
7588 m_cellEditCtrlEnabled = enable;
7589 }
7590 }
7591 }
7592
7593 bool wxGrid::IsCurrentCellReadOnly() const
7594 {
7595 // const_cast
7596 wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
7597 bool readonly = attr->IsReadOnly();
7598 attr->DecRef();
7599
7600 return readonly;
7601 }
7602
7603 bool wxGrid::CanEnableCellControl() const
7604 {
7605 return m_editable && (m_currentCellCoords != wxGridNoCellCoords) &&
7606 !IsCurrentCellReadOnly();
7607
7608 }
7609
7610 bool wxGrid::IsCellEditControlEnabled() const
7611 {
7612 // the cell edit control might be disable for all cells or just for the
7613 // current one if it's read only
7614 return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : false;
7615 }
7616
7617 bool wxGrid::IsCellEditControlShown() const
7618 {
7619 bool isShown = false;
7620
7621 if ( m_cellEditCtrlEnabled )
7622 {
7623 int row = m_currentCellCoords.GetRow();
7624 int col = m_currentCellCoords.GetCol();
7625 wxGridCellAttr* attr = GetCellAttr(row, col);
7626 wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
7627 attr->DecRef();
7628
7629 if ( editor )
7630 {
7631 if ( editor->IsCreated() )
7632 {
7633 isShown = editor->GetControl()->IsShown();
7634 }
7635
7636 editor->DecRef();
7637 }
7638 }
7639
7640 return isShown;
7641 }
7642
7643 void wxGrid::ShowCellEditControl()
7644 {
7645 if ( IsCellEditControlEnabled() )
7646 {
7647 if ( !IsVisible( m_currentCellCoords ) )
7648 {
7649 m_cellEditCtrlEnabled = false;
7650 return;
7651 }
7652 else
7653 {
7654 wxRect rect = CellToRect( m_currentCellCoords );
7655 int row = m_currentCellCoords.GetRow();
7656 int col = m_currentCellCoords.GetCol();
7657
7658 // if this is part of a multicell, find owner (topleft)
7659 int cell_rows, cell_cols;
7660 GetCellSize( row, col, &cell_rows, &cell_cols );
7661 if ( cell_rows <= 0 || cell_cols <= 0 )
7662 {
7663 row += cell_rows;
7664 col += cell_cols;
7665 m_currentCellCoords.SetRow( row );
7666 m_currentCellCoords.SetCol( col );
7667 }
7668
7669 // convert to scrolled coords
7670 //
7671 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
7672
7673 // done in PaintBackground()
7674 #if 0
7675 // erase the highlight and the cell contents because the editor
7676 // might not cover the entire cell
7677 wxClientDC dc( m_gridWin );
7678 PrepareDC( dc );
7679 dc.SetBrush(*wxLIGHT_GREY_BRUSH); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
7680 dc.SetPen(*wxTRANSPARENT_PEN);
7681 dc.DrawRectangle(rect);
7682 #endif // 0
7683
7684 // cell is shifted by one pixel
7685 // However, don't allow x or y to become negative
7686 // since the SetSize() method interprets that as
7687 // "don't change."
7688 if (rect.x > 0)
7689 rect.x--;
7690 if (rect.y > 0)
7691 rect.y--;
7692
7693 wxGridCellAttr* attr = GetCellAttr(row, col);
7694 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
7695 if ( !editor->IsCreated() )
7696 {
7697 editor->Create(m_gridWin, wxID_ANY,
7698 new wxGridCellEditorEvtHandler(this, editor));
7699
7700 wxGridEditorCreatedEvent evt(GetId(),
7701 wxEVT_GRID_EDITOR_CREATED,
7702 this,
7703 row,
7704 col,
7705 editor->GetControl());
7706 GetEventHandler()->ProcessEvent(evt);
7707 }
7708
7709
7710 // resize editor to overflow into righthand cells if allowed
7711 int maxWidth = rect.width;
7712 wxString value = GetCellValue(row, col);
7713 if ( (value != wxEmptyString) && (attr->GetOverflow()) )
7714 {
7715 int y;
7716 GetTextExtent(value, &maxWidth, &y,
7717 NULL, NULL, &attr->GetFont());
7718 if (maxWidth < rect.width) maxWidth = rect.width;
7719 }
7720 int client_right = m_gridWin->GetClientSize().GetWidth();
7721 if (rect.x+maxWidth > client_right)
7722 maxWidth = client_right - rect.x;
7723
7724 if ((maxWidth > rect.width) && (col < m_numCols) && m_table)
7725 {
7726 GetCellSize( row, col, &cell_rows, &cell_cols );
7727 // may have changed earlier
7728 for (int i = col+cell_cols; i < m_numCols; i++)
7729 {
7730 int c_rows, c_cols;
7731 GetCellSize( row, i, &c_rows, &c_cols );
7732 // looks weird going over a multicell
7733 if (m_table->IsEmptyCell(row,i) &&
7734 (rect.width < maxWidth) && (c_rows == 1))
7735 rect.width += GetColWidth(i);
7736 else
7737 break;
7738 }
7739 if (rect.GetRight() > client_right)
7740 rect.SetRight(client_right-1);
7741 }
7742
7743 editor->SetCellAttr(attr);
7744 editor->SetSize( rect );
7745 editor->Show( true, attr );
7746
7747 // recalc dimensions in case we need to
7748 // expand the scrolled window to account for editor
7749 CalcDimensions();
7750
7751 editor->BeginEdit(row, col, this);
7752 editor->SetCellAttr(NULL);
7753
7754 editor->DecRef();
7755 attr->DecRef();
7756 }
7757 }
7758 }
7759
7760
7761 void wxGrid::HideCellEditControl()
7762 {
7763 if ( IsCellEditControlEnabled() )
7764 {
7765 int row = m_currentCellCoords.GetRow();
7766 int col = m_currentCellCoords.GetCol();
7767
7768 wxGridCellAttr* attr = GetCellAttr(row, col);
7769 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
7770 editor->Show( false );
7771 editor->DecRef();
7772 attr->DecRef();
7773 m_gridWin->SetFocus();
7774 // refresh whole row to the right
7775 wxRect rect( CellToRect(row, col) );
7776 CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y );
7777 rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
7778 m_gridWin->Refresh( false, &rect );
7779 }
7780 }
7781
7782
7783 void wxGrid::SaveEditControlValue()
7784 {
7785 if ( IsCellEditControlEnabled() )
7786 {
7787 int row = m_currentCellCoords.GetRow();
7788 int col = m_currentCellCoords.GetCol();
7789
7790 wxString oldval = GetCellValue(row,col);
7791
7792 wxGridCellAttr* attr = GetCellAttr(row, col);
7793 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
7794 bool changed = editor->EndEdit(row, col, this);
7795
7796 editor->DecRef();
7797 attr->DecRef();
7798
7799 if (changed)
7800 {
7801 if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
7802 m_currentCellCoords.GetRow(),
7803 m_currentCellCoords.GetCol() ) < 0 ) {
7804
7805 // Event has been vetoed, set the data back.
7806 SetCellValue(row,col,oldval);
7807 }
7808 }
7809 }
7810 }
7811
7812
7813 //
7814 // ------ Grid location functions
7815 // Note that all of these functions work with the logical coordinates of
7816 // grid cells and labels so you will need to convert from device
7817 // coordinates for mouse events etc.
7818 //
7819
7820 void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
7821 {
7822 int row = YToRow(y);
7823 int col = XToCol(x);
7824
7825 if ( row == -1 || col == -1 )
7826 {
7827 coords = wxGridNoCellCoords;
7828 }
7829 else
7830 {
7831 coords.Set( row, col );
7832 }
7833 }
7834
7835
7836 // Internal Helper function for computing row or column from some
7837 // (unscrolled) coordinate value, using either
7838 // m_defaultRowHeight/m_defaultColWidth or binary search on array
7839 // of m_rowBottoms/m_ColRights to speed up the search!
7840
7841 static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
7842 const wxArrayInt& BorderArray, int nMax,
7843 bool clipToMinMax)
7844 {
7845
7846 if (coord < 0)
7847 return clipToMinMax && (nMax > 0) ? 0 : -1;
7848
7849
7850 if (!defaultDist)
7851 defaultDist = 1;
7852
7853 size_t i_max = coord / defaultDist,
7854 i_min = 0;
7855
7856 if (BorderArray.IsEmpty())
7857 {
7858 if((int) i_max < nMax)
7859 return i_max;
7860 return clipToMinMax ? nMax - 1 : -1;
7861 }
7862
7863 if ( i_max >= BorderArray.GetCount())
7864 i_max = BorderArray.GetCount() - 1;
7865 else
7866 {
7867 if ( coord >= BorderArray[i_max])
7868 {
7869 i_min = i_max;
7870 if (minDist)
7871 i_max = coord / minDist;
7872 else
7873 i_max = BorderArray.GetCount() - 1;
7874 }
7875 if ( i_max >= BorderArray.GetCount())
7876 i_max = BorderArray.GetCount() - 1;
7877 }
7878 if ( coord >= BorderArray[i_max])
7879 return clipToMinMax ? (int)i_max : -1;
7880 if ( coord < BorderArray[0] )
7881 return 0;
7882
7883 while ( i_max - i_min > 0 )
7884 {
7885 wxCHECK_MSG(BorderArray[i_min] <= coord && coord < BorderArray[i_max],
7886 0, _T("wxGrid: internal error in CoordToRowOrCol"));
7887 if (coord >= BorderArray[ i_max - 1])
7888 return i_max;
7889 else
7890 i_max--;
7891 int median = i_min + (i_max - i_min + 1) / 2;
7892 if (coord < BorderArray[median])
7893 i_max = median;
7894 else
7895 i_min = median;
7896 }
7897 return i_max;
7898 }
7899
7900 int wxGrid::YToRow( int y )
7901 {
7902 return CoordToRowOrCol(y, m_defaultRowHeight,
7903 m_minAcceptableRowHeight, m_rowBottoms, m_numRows, false);
7904 }
7905
7906
7907 int wxGrid::XToCol( int x )
7908 {
7909 return CoordToRowOrCol(x, m_defaultColWidth,
7910 m_minAcceptableColWidth, m_colRights, m_numCols, false);
7911 }
7912
7913
7914 // return the row number that that the y coord is near the edge of, or
7915 // -1 if not near an edge
7916 //
7917 int wxGrid::YToEdgeOfRow( int y )
7918 {
7919 int i;
7920 i = internalYToRow(y);
7921
7922 if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE )
7923 {
7924 // We know that we are in row i, test whether we are
7925 // close enough to lower or upper border, respectively.
7926 if ( abs(GetRowBottom(i) - y) < WXGRID_LABEL_EDGE_ZONE )
7927 return i;
7928 else if( i > 0 && y - GetRowTop(i) < WXGRID_LABEL_EDGE_ZONE )
7929 return i - 1;
7930 }
7931
7932 return -1;
7933 }
7934
7935
7936 // return the col number that that the x coord is near the edge of, or
7937 // -1 if not near an edge
7938 //
7939 int wxGrid::XToEdgeOfCol( int x )
7940 {
7941 int i;
7942 i = internalXToCol(x);
7943
7944 if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE )
7945 {
7946 // We know that we are in column i, test whether we are
7947 // close enough to right or left border, respectively.
7948 if ( abs(GetColRight(i) - x) < WXGRID_LABEL_EDGE_ZONE )
7949 return i;
7950 else if( i > 0 && x - GetColLeft(i) < WXGRID_LABEL_EDGE_ZONE )
7951 return i - 1;
7952 }
7953
7954 return -1;
7955 }
7956
7957
7958 wxRect wxGrid::CellToRect( int row, int col )
7959 {
7960 wxRect rect( -1, -1, -1, -1 );
7961
7962 if ( row >= 0 && row < m_numRows &&
7963 col >= 0 && col < m_numCols )
7964 {
7965 int i, cell_rows, cell_cols;
7966 rect.width = rect.height = 0;
7967 GetCellSize( row, col, &cell_rows, &cell_cols );
7968 // if negative then find multicell owner
7969 if (cell_rows < 0) row += cell_rows;
7970 if (cell_cols < 0) col += cell_cols;
7971 GetCellSize( row, col, &cell_rows, &cell_cols );
7972
7973 rect.x = GetColLeft(col);
7974 rect.y = GetRowTop(row);
7975 for (i=col; i<col+cell_cols; i++)
7976 rect.width += GetColWidth(i);
7977 for (i=row; i<row+cell_rows; i++)
7978 rect.height += GetRowHeight(i);
7979 }
7980
7981 // if grid lines are enabled, then the area of the cell is a bit smaller
7982 if (m_gridLinesEnabled) {
7983 rect.width -= 1;
7984 rect.height -= 1;
7985 }
7986 return rect;
7987 }
7988
7989
7990 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
7991 {
7992 // get the cell rectangle in logical coords
7993 //
7994 wxRect r( CellToRect( row, col ) );
7995
7996 // convert to device coords
7997 //
7998 int left, top, right, bottom;
7999 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
8000 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
8001
8002 // check against the client area of the grid window
8003 //
8004 int cw, ch;
8005 m_gridWin->GetClientSize( &cw, &ch );
8006
8007 if ( wholeCellVisible )
8008 {
8009 // is the cell wholly visible ?
8010 //
8011 return ( left >= 0 && right <= cw &&
8012 top >= 0 && bottom <= ch );
8013 }
8014 else
8015 {
8016 // is the cell partly visible ?
8017 //
8018 return ( ((left >=0 && left < cw) || (right > 0 && right <= cw)) &&
8019 ((top >=0 && top < ch) || (bottom > 0 && bottom <= ch)) );
8020 }
8021 }
8022
8023
8024 // make the specified cell location visible by doing a minimal amount
8025 // of scrolling
8026 //
8027 void wxGrid::MakeCellVisible( int row, int col )
8028 {
8029
8030 int i;
8031 int xpos = -1, ypos = -1;
8032
8033 if ( row >= 0 && row < m_numRows &&
8034 col >= 0 && col < m_numCols )
8035 {
8036 // get the cell rectangle in logical coords
8037 //
8038 wxRect r( CellToRect( row, col ) );
8039
8040 // convert to device coords
8041 //
8042 int left, top, right, bottom;
8043 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
8044 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
8045
8046 int cw, ch;
8047 m_gridWin->GetClientSize( &cw, &ch );
8048
8049 if ( top < 0 )
8050 {
8051 ypos = r.GetTop();
8052 }
8053 else if ( bottom > ch )
8054 {
8055 int h = r.GetHeight();
8056 ypos = r.GetTop();
8057 for ( i = row-1; i >= 0; i-- )
8058 {
8059 int rowHeight = GetRowHeight(i);
8060 if ( h + rowHeight > ch )
8061 break;
8062
8063 h += rowHeight;
8064 ypos -= rowHeight;
8065 }
8066
8067 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
8068 // have rounding errors (this is important, because if we do, we
8069 // might not scroll at all and some cells won't be redrawn)
8070 //
8071 // Sometimes GRID_SCROLL_LINE/2 is not enough, so just add a full
8072 // scroll unit...
8073 ypos += GRID_SCROLL_LINE_Y;
8074 }
8075
8076 if ( left < 0 )
8077 {
8078 xpos = r.GetLeft();
8079 }
8080 else if ( right > cw )
8081 {
8082 // position the view so that the cell is on the right
8083 int x0, y0;
8084 CalcUnscrolledPosition(0, 0, &x0, &y0);
8085 xpos = x0 + (right - cw);
8086
8087 // see comment for ypos above
8088 xpos += GRID_SCROLL_LINE_X;
8089 }
8090
8091 if ( xpos != -1 || ypos != -1 )
8092 {
8093 if ( xpos != -1 )
8094 xpos /= GRID_SCROLL_LINE_X;
8095 if ( ypos != -1 )
8096 ypos /= GRID_SCROLL_LINE_Y;
8097 Scroll( xpos, ypos );
8098 AdjustScrollbars();
8099 }
8100 }
8101 }
8102
8103
8104 //
8105 // ------ Grid cursor movement functions
8106 //
8107
8108 bool wxGrid::MoveCursorUp( bool expandSelection )
8109 {
8110 if ( m_currentCellCoords != wxGridNoCellCoords &&
8111 m_currentCellCoords.GetRow() >= 0 )
8112 {
8113 if ( expandSelection)
8114 {
8115 if ( m_selectingKeyboard == wxGridNoCellCoords )
8116 m_selectingKeyboard = m_currentCellCoords;
8117 if ( m_selectingKeyboard.GetRow() > 0 )
8118 {
8119 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() - 1 );
8120 MakeCellVisible( m_selectingKeyboard.GetRow(),
8121 m_selectingKeyboard.GetCol() );
8122 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8123 }
8124 }
8125 else if ( m_currentCellCoords.GetRow() > 0 )
8126 {
8127 ClearSelection();
8128 MakeCellVisible( m_currentCellCoords.GetRow() - 1,
8129 m_currentCellCoords.GetCol() );
8130 SetCurrentCell( m_currentCellCoords.GetRow() - 1,
8131 m_currentCellCoords.GetCol() );
8132 }
8133 else
8134 return false;
8135 return true;
8136 }
8137
8138 return false;
8139 }
8140
8141
8142 bool wxGrid::MoveCursorDown( bool expandSelection )
8143 {
8144 if ( m_currentCellCoords != wxGridNoCellCoords &&
8145 m_currentCellCoords.GetRow() < m_numRows )
8146 {
8147 if ( expandSelection )
8148 {
8149 if ( m_selectingKeyboard == wxGridNoCellCoords )
8150 m_selectingKeyboard = m_currentCellCoords;
8151 if ( m_selectingKeyboard.GetRow() < m_numRows-1 )
8152 {
8153 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() + 1 );
8154 MakeCellVisible( m_selectingKeyboard.GetRow(),
8155 m_selectingKeyboard.GetCol() );
8156 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8157 }
8158 }
8159 else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
8160 {
8161 ClearSelection();
8162 MakeCellVisible( m_currentCellCoords.GetRow() + 1,
8163 m_currentCellCoords.GetCol() );
8164 SetCurrentCell( m_currentCellCoords.GetRow() + 1,
8165 m_currentCellCoords.GetCol() );
8166 }
8167 else
8168 return false;
8169 return true;
8170 }
8171
8172 return false;
8173 }
8174
8175
8176 bool wxGrid::MoveCursorLeft( bool expandSelection )
8177 {
8178 if ( m_currentCellCoords != wxGridNoCellCoords &&
8179 m_currentCellCoords.GetCol() >= 0 )
8180 {
8181 if ( expandSelection )
8182 {
8183 if ( m_selectingKeyboard == wxGridNoCellCoords )
8184 m_selectingKeyboard = m_currentCellCoords;
8185 if ( m_selectingKeyboard.GetCol() > 0 )
8186 {
8187 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() - 1 );
8188 MakeCellVisible( m_selectingKeyboard.GetRow(),
8189 m_selectingKeyboard.GetCol() );
8190 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8191 }
8192 }
8193 else if ( m_currentCellCoords.GetCol() > 0 )
8194 {
8195 ClearSelection();
8196 MakeCellVisible( m_currentCellCoords.GetRow(),
8197 m_currentCellCoords.GetCol() - 1 );
8198 SetCurrentCell( m_currentCellCoords.GetRow(),
8199 m_currentCellCoords.GetCol() - 1 );
8200 }
8201 else
8202 return false;
8203 return true;
8204 }
8205
8206 return false;
8207 }
8208
8209
8210 bool wxGrid::MoveCursorRight( bool expandSelection )
8211 {
8212 if ( m_currentCellCoords != wxGridNoCellCoords &&
8213 m_currentCellCoords.GetCol() < m_numCols )
8214 {
8215 if ( expandSelection )
8216 {
8217 if ( m_selectingKeyboard == wxGridNoCellCoords )
8218 m_selectingKeyboard = m_currentCellCoords;
8219 if ( m_selectingKeyboard.GetCol() < m_numCols - 1 )
8220 {
8221 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() + 1 );
8222 MakeCellVisible( m_selectingKeyboard.GetRow(),
8223 m_selectingKeyboard.GetCol() );
8224 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8225 }
8226 }
8227 else if ( m_currentCellCoords.GetCol() < m_numCols - 1 )
8228 {
8229 ClearSelection();
8230 MakeCellVisible( m_currentCellCoords.GetRow(),
8231 m_currentCellCoords.GetCol() + 1 );
8232 SetCurrentCell( m_currentCellCoords.GetRow(),
8233 m_currentCellCoords.GetCol() + 1 );
8234 }
8235 else
8236 return false;
8237 return true;
8238 }
8239
8240 return false;
8241 }
8242
8243
8244 bool wxGrid::MovePageUp()
8245 {
8246 if ( m_currentCellCoords == wxGridNoCellCoords ) return false;
8247
8248 int row = m_currentCellCoords.GetRow();
8249 if ( row > 0 )
8250 {
8251 int cw, ch;
8252 m_gridWin->GetClientSize( &cw, &ch );
8253
8254 int y = GetRowTop(row);
8255 int newRow = internalYToRow( y - ch + 1 );
8256
8257 if ( newRow == row )
8258 {
8259 //row > 0 , so newrow can never be less than 0 here.
8260 newRow = row - 1;
8261 }
8262
8263 MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
8264 SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
8265
8266 return true;
8267 }
8268
8269 return false;
8270 }
8271
8272 bool wxGrid::MovePageDown()
8273 {
8274 if ( m_currentCellCoords == wxGridNoCellCoords ) return false;
8275
8276 int row = m_currentCellCoords.GetRow();
8277 if ( (row+1) < m_numRows )
8278 {
8279 int cw, ch;
8280 m_gridWin->GetClientSize( &cw, &ch );
8281
8282 int y = GetRowTop(row);
8283 int newRow = internalYToRow( y + ch );
8284 if ( newRow == row )
8285 {
8286 // row < m_numRows , so newrow can't overflow here.
8287 newRow = row + 1;
8288 }
8289
8290 MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
8291 SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
8292
8293 return true;
8294 }
8295
8296 return false;
8297 }
8298
8299 bool wxGrid::MoveCursorUpBlock( bool expandSelection )
8300 {
8301 if ( m_table &&
8302 m_currentCellCoords != wxGridNoCellCoords &&
8303 m_currentCellCoords.GetRow() > 0 )
8304 {
8305 int row = m_currentCellCoords.GetRow();
8306 int col = m_currentCellCoords.GetCol();
8307
8308 if ( m_table->IsEmptyCell(row, col) )
8309 {
8310 // starting in an empty cell: find the next block of
8311 // non-empty cells
8312 //
8313 while ( row > 0 )
8314 {
8315 row-- ;
8316 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8317 }
8318 }
8319 else if ( m_table->IsEmptyCell(row-1, col) )
8320 {
8321 // starting at the top of a block: find the next block
8322 //
8323 row--;
8324 while ( row > 0 )
8325 {
8326 row-- ;
8327 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8328 }
8329 }
8330 else
8331 {
8332 // starting within a block: find the top of the block
8333 //
8334 while ( row > 0 )
8335 {
8336 row-- ;
8337 if ( m_table->IsEmptyCell(row, col) )
8338 {
8339 row++ ;
8340 break;
8341 }
8342 }
8343 }
8344
8345 MakeCellVisible( row, col );
8346 if ( expandSelection )
8347 {
8348 m_selectingKeyboard = wxGridCellCoords( row, col );
8349 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8350 }
8351 else
8352 {
8353 ClearSelection();
8354 SetCurrentCell( row, col );
8355 }
8356 return true;
8357 }
8358
8359 return false;
8360 }
8361
8362 bool wxGrid::MoveCursorDownBlock( bool expandSelection )
8363 {
8364 if ( m_table &&
8365 m_currentCellCoords != wxGridNoCellCoords &&
8366 m_currentCellCoords.GetRow() < m_numRows-1 )
8367 {
8368 int row = m_currentCellCoords.GetRow();
8369 int col = m_currentCellCoords.GetCol();
8370
8371 if ( m_table->IsEmptyCell(row, col) )
8372 {
8373 // starting in an empty cell: find the next block of
8374 // non-empty cells
8375 //
8376 while ( row < m_numRows-1 )
8377 {
8378 row++ ;
8379 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8380 }
8381 }
8382 else if ( m_table->IsEmptyCell(row+1, col) )
8383 {
8384 // starting at the bottom of a block: find the next block
8385 //
8386 row++;
8387 while ( row < m_numRows-1 )
8388 {
8389 row++ ;
8390 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8391 }
8392 }
8393 else
8394 {
8395 // starting within a block: find the bottom of the block
8396 //
8397 while ( row < m_numRows-1 )
8398 {
8399 row++ ;
8400 if ( m_table->IsEmptyCell(row, col) )
8401 {
8402 row-- ;
8403 break;
8404 }
8405 }
8406 }
8407
8408 MakeCellVisible( row, col );
8409 if ( expandSelection )
8410 {
8411 m_selectingKeyboard = wxGridCellCoords( row, col );
8412 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8413 }
8414 else
8415 {
8416 ClearSelection();
8417 SetCurrentCell( row, col );
8418 }
8419
8420 return true;
8421 }
8422
8423 return false;
8424 }
8425
8426 bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
8427 {
8428 if ( m_table &&
8429 m_currentCellCoords != wxGridNoCellCoords &&
8430 m_currentCellCoords.GetCol() > 0 )
8431 {
8432 int row = m_currentCellCoords.GetRow();
8433 int col = m_currentCellCoords.GetCol();
8434
8435 if ( m_table->IsEmptyCell(row, col) )
8436 {
8437 // starting in an empty cell: find the next block of
8438 // non-empty cells
8439 //
8440 while ( col > 0 )
8441 {
8442 col-- ;
8443 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8444 }
8445 }
8446 else if ( m_table->IsEmptyCell(row, col-1) )
8447 {
8448 // starting at the left of a block: find the next block
8449 //
8450 col--;
8451 while ( col > 0 )
8452 {
8453 col-- ;
8454 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8455 }
8456 }
8457 else
8458 {
8459 // starting within a block: find the left of the block
8460 //
8461 while ( col > 0 )
8462 {
8463 col-- ;
8464 if ( m_table->IsEmptyCell(row, col) )
8465 {
8466 col++ ;
8467 break;
8468 }
8469 }
8470 }
8471
8472 MakeCellVisible( row, col );
8473 if ( expandSelection )
8474 {
8475 m_selectingKeyboard = wxGridCellCoords( row, col );
8476 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8477 }
8478 else
8479 {
8480 ClearSelection();
8481 SetCurrentCell( row, col );
8482 }
8483
8484 return true;
8485 }
8486
8487 return false;
8488 }
8489
8490 bool wxGrid::MoveCursorRightBlock( bool expandSelection )
8491 {
8492 if ( m_table &&
8493 m_currentCellCoords != wxGridNoCellCoords &&
8494 m_currentCellCoords.GetCol() < m_numCols-1 )
8495 {
8496 int row = m_currentCellCoords.GetRow();
8497 int col = m_currentCellCoords.GetCol();
8498
8499 if ( m_table->IsEmptyCell(row, col) )
8500 {
8501 // starting in an empty cell: find the next block of
8502 // non-empty cells
8503 //
8504 while ( col < m_numCols-1 )
8505 {
8506 col++ ;
8507 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8508 }
8509 }
8510 else if ( m_table->IsEmptyCell(row, col+1) )
8511 {
8512 // starting at the right of a block: find the next block
8513 //
8514 col++;
8515 while ( col < m_numCols-1 )
8516 {
8517 col++ ;
8518 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8519 }
8520 }
8521 else
8522 {
8523 // starting within a block: find the right of the block
8524 //
8525 while ( col < m_numCols-1 )
8526 {
8527 col++ ;
8528 if ( m_table->IsEmptyCell(row, col) )
8529 {
8530 col-- ;
8531 break;
8532 }
8533 }
8534 }
8535
8536 MakeCellVisible( row, col );
8537 if ( expandSelection )
8538 {
8539 m_selectingKeyboard = wxGridCellCoords( row, col );
8540 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8541 }
8542 else
8543 {
8544 ClearSelection();
8545 SetCurrentCell( row, col );
8546 }
8547
8548 return true;
8549 }
8550
8551 return false;
8552 }
8553
8554
8555
8556 //
8557 // ------ Label values and formatting
8558 //
8559
8560 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
8561 {
8562 *horiz = m_rowLabelHorizAlign;
8563 *vert = m_rowLabelVertAlign;
8564 }
8565
8566 void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
8567 {
8568 *horiz = m_colLabelHorizAlign;
8569 *vert = m_colLabelVertAlign;
8570 }
8571
8572 int wxGrid::GetColLabelTextOrientation()
8573 {
8574 return m_colLabelTextOrientation;
8575 }
8576
8577 wxString wxGrid::GetRowLabelValue( int row )
8578 {
8579 if ( m_table )
8580 {
8581 return m_table->GetRowLabelValue( row );
8582 }
8583 else
8584 {
8585 wxString s;
8586 s << row;
8587 return s;
8588 }
8589 }
8590
8591 wxString wxGrid::GetColLabelValue( int col )
8592 {
8593 if ( m_table )
8594 {
8595 return m_table->GetColLabelValue( col );
8596 }
8597 else
8598 {
8599 wxString s;
8600 s << col;
8601 return s;
8602 }
8603 }
8604
8605
8606 void wxGrid::SetRowLabelSize( int width )
8607 {
8608 width = wxMax( width, 0 );
8609 if ( width != m_rowLabelWidth )
8610 {
8611 if ( width == 0 )
8612 {
8613 m_rowLabelWin->Show( false );
8614 m_cornerLabelWin->Show( false );
8615 }
8616 else if ( m_rowLabelWidth == 0 )
8617 {
8618 m_rowLabelWin->Show( true );
8619 if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( true );
8620 }
8621
8622 m_rowLabelWidth = width;
8623 CalcWindowSizes();
8624 wxScrolledWindow::Refresh( true );
8625 }
8626 }
8627
8628
8629 void wxGrid::SetColLabelSize( int height )
8630 {
8631 height = wxMax( height, 0 );
8632 if ( height != m_colLabelHeight )
8633 {
8634 if ( height == 0 )
8635 {
8636 m_colLabelWin->Show( false );
8637 m_cornerLabelWin->Show( false );
8638 }
8639 else if ( m_colLabelHeight == 0 )
8640 {
8641 m_colLabelWin->Show( true );
8642 if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( true );
8643 }
8644
8645 m_colLabelHeight = height;
8646 CalcWindowSizes();
8647 wxScrolledWindow::Refresh( true );
8648 }
8649 }
8650
8651
8652 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
8653 {
8654 if ( m_labelBackgroundColour != colour )
8655 {
8656 m_labelBackgroundColour = colour;
8657 m_rowLabelWin->SetBackgroundColour( colour );
8658 m_colLabelWin->SetBackgroundColour( colour );
8659 m_cornerLabelWin->SetBackgroundColour( colour );
8660
8661 if ( !GetBatchCount() )
8662 {
8663 m_rowLabelWin->Refresh();
8664 m_colLabelWin->Refresh();
8665 m_cornerLabelWin->Refresh();
8666 }
8667 }
8668 }
8669
8670 void wxGrid::SetLabelTextColour( const wxColour& colour )
8671 {
8672 if ( m_labelTextColour != colour )
8673 {
8674 m_labelTextColour = colour;
8675 if ( !GetBatchCount() )
8676 {
8677 m_rowLabelWin->Refresh();
8678 m_colLabelWin->Refresh();
8679 }
8680 }
8681 }
8682
8683 void wxGrid::SetLabelFont( const wxFont& font )
8684 {
8685 m_labelFont = font;
8686 if ( !GetBatchCount() )
8687 {
8688 m_rowLabelWin->Refresh();
8689 m_colLabelWin->Refresh();
8690 }
8691 }
8692
8693 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
8694 {
8695 // allow old (incorrect) defs to be used
8696 switch ( horiz )
8697 {
8698 case wxLEFT: horiz = wxALIGN_LEFT; break;
8699 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
8700 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
8701 }
8702
8703 switch ( vert )
8704 {
8705 case wxTOP: vert = wxALIGN_TOP; break;
8706 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
8707 case wxCENTRE: vert = wxALIGN_CENTRE; break;
8708 }
8709
8710 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
8711 {
8712 m_rowLabelHorizAlign = horiz;
8713 }
8714
8715 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
8716 {
8717 m_rowLabelVertAlign = vert;
8718 }
8719
8720 if ( !GetBatchCount() )
8721 {
8722 m_rowLabelWin->Refresh();
8723 }
8724 }
8725
8726 void wxGrid::SetColLabelAlignment( int horiz, int vert )
8727 {
8728 // allow old (incorrect) defs to be used
8729 switch ( horiz )
8730 {
8731 case wxLEFT: horiz = wxALIGN_LEFT; break;
8732 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
8733 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
8734 }
8735
8736 switch ( vert )
8737 {
8738 case wxTOP: vert = wxALIGN_TOP; break;
8739 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
8740 case wxCENTRE: vert = wxALIGN_CENTRE; break;
8741 }
8742
8743 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
8744 {
8745 m_colLabelHorizAlign = horiz;
8746 }
8747
8748 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
8749 {
8750 m_colLabelVertAlign = vert;
8751 }
8752
8753 if ( !GetBatchCount() )
8754 {
8755 m_colLabelWin->Refresh();
8756 }
8757 }
8758
8759 // Note: under MSW, the default column label font must be changed because it
8760 // does not support vertical printing
8761 //
8762 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
8763 // pGrid->SetLabelFont(font);
8764 // pGrid->SetColLabelTextOrientation(wxVERTICAL);
8765 //
8766 void wxGrid::SetColLabelTextOrientation( int textOrientation )
8767 {
8768 if( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
8769 {
8770 m_colLabelTextOrientation = textOrientation;
8771 }
8772
8773 if ( !GetBatchCount() )
8774 {
8775 m_colLabelWin->Refresh();
8776 }
8777 }
8778
8779 void wxGrid::SetRowLabelValue( int row, const wxString& s )
8780 {
8781 if ( m_table )
8782 {
8783 m_table->SetRowLabelValue( row, s );
8784 if ( !GetBatchCount() )
8785 {
8786 wxRect rect = CellToRect( row, 0);
8787 if ( rect.height > 0 )
8788 {
8789 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
8790 rect.x = 0;
8791 rect.width = m_rowLabelWidth;
8792 m_rowLabelWin->Refresh( true, &rect );
8793 }
8794 }
8795 }
8796 }
8797
8798 void wxGrid::SetColLabelValue( int col, const wxString& s )
8799 {
8800 if ( m_table )
8801 {
8802 m_table->SetColLabelValue( col, s );
8803 if ( !GetBatchCount() )
8804 {
8805 wxRect rect = CellToRect( 0, col );
8806 if ( rect.width > 0 )
8807 {
8808 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
8809 rect.y = 0;
8810 rect.height = m_colLabelHeight;
8811 m_colLabelWin->Refresh( true, &rect );
8812 }
8813 }
8814 }
8815 }
8816
8817 void wxGrid::SetGridLineColour( const wxColour& colour )
8818 {
8819 if ( m_gridLineColour != colour )
8820 {
8821 m_gridLineColour = colour;
8822
8823 wxClientDC dc( m_gridWin );
8824 PrepareDC( dc );
8825 DrawAllGridLines( dc, wxRegion() );
8826 }
8827 }
8828
8829
8830 void wxGrid::SetCellHighlightColour( const wxColour& colour )
8831 {
8832 if ( m_cellHighlightColour != colour )
8833 {
8834 m_cellHighlightColour = colour;
8835
8836 wxClientDC dc( m_gridWin );
8837 PrepareDC( dc );
8838 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
8839 DrawCellHighlight(dc, attr);
8840 attr->DecRef();
8841 }
8842 }
8843
8844 void wxGrid::SetCellHighlightPenWidth(int width)
8845 {
8846 if (m_cellHighlightPenWidth != width) {
8847 m_cellHighlightPenWidth = width;
8848
8849 // Just redrawing the cell highlight is not enough since that won't
8850 // make any visible change if the the thickness is getting smaller.
8851 int row = m_currentCellCoords.GetRow();
8852 int col = m_currentCellCoords.GetCol();
8853 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
8854 return;
8855 wxRect rect = CellToRect(row, col);
8856 m_gridWin->Refresh(true, &rect);
8857 }
8858 }
8859
8860 void wxGrid::SetCellHighlightROPenWidth(int width)
8861 {
8862 if (m_cellHighlightROPenWidth != width) {
8863 m_cellHighlightROPenWidth = width;
8864
8865 // Just redrawing the cell highlight is not enough since that won't
8866 // make any visible change if the the thickness is getting smaller.
8867 int row = m_currentCellCoords.GetRow();
8868 int col = m_currentCellCoords.GetCol();
8869 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
8870 return;
8871 wxRect rect = CellToRect(row, col);
8872 m_gridWin->Refresh(true, &rect);
8873 }
8874 }
8875
8876 void wxGrid::EnableGridLines( bool enable )
8877 {
8878 if ( enable != m_gridLinesEnabled )
8879 {
8880 m_gridLinesEnabled = enable;
8881
8882 if ( !GetBatchCount() )
8883 {
8884 if ( enable )
8885 {
8886 wxClientDC dc( m_gridWin );
8887 PrepareDC( dc );
8888 DrawAllGridLines( dc, wxRegion() );
8889 }
8890 else
8891 {
8892 m_gridWin->Refresh();
8893 }
8894 }
8895 }
8896 }
8897
8898
8899 int wxGrid::GetDefaultRowSize()
8900 {
8901 return m_defaultRowHeight;
8902 }
8903
8904 int wxGrid::GetRowSize( int row )
8905 {
8906 wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
8907
8908 return GetRowHeight(row);
8909 }
8910
8911 int wxGrid::GetDefaultColSize()
8912 {
8913 return m_defaultColWidth;
8914 }
8915
8916 int wxGrid::GetColSize( int col )
8917 {
8918 wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
8919
8920 return GetColWidth(col);
8921 }
8922
8923 // ============================================================================
8924 // access to the grid attributes: each of them has a default value in the grid
8925 // itself and may be overidden on a per-cell basis
8926 // ============================================================================
8927
8928 // ----------------------------------------------------------------------------
8929 // setting default attributes
8930 // ----------------------------------------------------------------------------
8931
8932 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
8933 {
8934 m_defaultCellAttr->SetBackgroundColour(col);
8935 #ifdef __WXGTK__
8936 m_gridWin->SetBackgroundColour(col);
8937 #endif
8938 }
8939
8940 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
8941 {
8942 m_defaultCellAttr->SetTextColour(col);
8943 }
8944
8945 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
8946 {
8947 m_defaultCellAttr->SetAlignment(horiz, vert);
8948 }
8949
8950 void wxGrid::SetDefaultCellOverflow( bool allow )
8951 {
8952 m_defaultCellAttr->SetOverflow(allow);
8953 }
8954
8955 void wxGrid::SetDefaultCellFont( const wxFont& font )
8956 {
8957 m_defaultCellAttr->SetFont(font);
8958 }
8959
8960
8961 // For editors and renderers the type registry takes precedence over the
8962 // default attr, so we need to register the new editor/renderer for the string
8963 // data type in order to make setting a default editor/renderer appear to
8964 // work correctly.
8965
8966 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
8967 {
8968 RegisterDataType(wxGRID_VALUE_STRING,
8969 renderer,
8970 GetDefaultEditorForType(wxGRID_VALUE_STRING));
8971 }
8972
8973 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
8974 {
8975 RegisterDataType(wxGRID_VALUE_STRING,
8976 GetDefaultRendererForType(wxGRID_VALUE_STRING),
8977 editor);
8978 }
8979
8980 // ----------------------------------------------------------------------------
8981 // access to the default attrbiutes
8982 // ----------------------------------------------------------------------------
8983
8984 wxColour wxGrid::GetDefaultCellBackgroundColour()
8985 {
8986 return m_defaultCellAttr->GetBackgroundColour();
8987 }
8988
8989 wxColour wxGrid::GetDefaultCellTextColour()
8990 {
8991 return m_defaultCellAttr->GetTextColour();
8992 }
8993
8994 wxFont wxGrid::GetDefaultCellFont()
8995 {
8996 return m_defaultCellAttr->GetFont();
8997 }
8998
8999 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
9000 {
9001 m_defaultCellAttr->GetAlignment(horiz, vert);
9002 }
9003
9004 bool wxGrid::GetDefaultCellOverflow()
9005 {
9006 return m_defaultCellAttr->GetOverflow();
9007 }
9008
9009 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
9010 {
9011 return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
9012 }
9013
9014 wxGridCellEditor *wxGrid::GetDefaultEditor() const
9015 {
9016 return m_defaultCellAttr->GetEditor(NULL,0,0);
9017 }
9018
9019 // ----------------------------------------------------------------------------
9020 // access to cell attributes
9021 // ----------------------------------------------------------------------------
9022
9023 wxColour wxGrid::GetCellBackgroundColour(int row, int col)
9024 {
9025 wxGridCellAttr *attr = GetCellAttr(row, col);
9026 wxColour colour = attr->GetBackgroundColour();
9027 attr->DecRef();
9028 return colour;
9029 }
9030
9031 wxColour wxGrid::GetCellTextColour( int row, int col )
9032 {
9033 wxGridCellAttr *attr = GetCellAttr(row, col);
9034 wxColour colour = attr->GetTextColour();
9035 attr->DecRef();
9036 return colour;
9037 }
9038
9039 wxFont wxGrid::GetCellFont( int row, int col )
9040 {
9041 wxGridCellAttr *attr = GetCellAttr(row, col);
9042 wxFont font = attr->GetFont();
9043 attr->DecRef();
9044 return font;
9045 }
9046
9047 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
9048 {
9049 wxGridCellAttr *attr = GetCellAttr(row, col);
9050 attr->GetAlignment(horiz, vert);
9051 attr->DecRef();
9052 }
9053
9054 bool wxGrid::GetCellOverflow( int row, int col )
9055 {
9056 wxGridCellAttr *attr = GetCellAttr(row, col);
9057 bool allow = attr->GetOverflow();
9058 attr->DecRef();
9059 return allow;
9060 }
9061
9062 void wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols )
9063 {
9064 wxGridCellAttr *attr = GetCellAttr(row, col);
9065 attr->GetSize( num_rows, num_cols );
9066 attr->DecRef();
9067 }
9068
9069 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
9070 {
9071 wxGridCellAttr* attr = GetCellAttr(row, col);
9072 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
9073 attr->DecRef();
9074
9075 return renderer;
9076 }
9077
9078 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
9079 {
9080 wxGridCellAttr* attr = GetCellAttr(row, col);
9081 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
9082 attr->DecRef();
9083
9084 return editor;
9085 }
9086
9087 bool wxGrid::IsReadOnly(int row, int col) const
9088 {
9089 wxGridCellAttr* attr = GetCellAttr(row, col);
9090 bool isReadOnly = attr->IsReadOnly();
9091 attr->DecRef();
9092 return isReadOnly;
9093 }
9094
9095 // ----------------------------------------------------------------------------
9096 // attribute support: cache, automatic provider creation, ...
9097 // ----------------------------------------------------------------------------
9098
9099 bool wxGrid::CanHaveAttributes()
9100 {
9101 if ( !m_table )
9102 {
9103 return false;
9104 }
9105
9106 return m_table->CanHaveAttributes();
9107 }
9108
9109 void wxGrid::ClearAttrCache()
9110 {
9111 if ( m_attrCache.row != -1 )
9112 {
9113 wxSafeDecRef(m_attrCache.attr);
9114 m_attrCache.attr = NULL;
9115 m_attrCache.row = -1;
9116 }
9117 }
9118
9119 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
9120 {
9121 if ( attr != NULL )
9122 {
9123 wxGrid *self = (wxGrid *)this; // const_cast
9124
9125 self->ClearAttrCache();
9126 self->m_attrCache.row = row;
9127 self->m_attrCache.col = col;
9128 self->m_attrCache.attr = attr;
9129 wxSafeIncRef(attr);
9130 }
9131 }
9132
9133 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
9134 {
9135 if ( row == m_attrCache.row && col == m_attrCache.col )
9136 {
9137 *attr = m_attrCache.attr;
9138 wxSafeIncRef(m_attrCache.attr);
9139
9140 #ifdef DEBUG_ATTR_CACHE
9141 gs_nAttrCacheHits++;
9142 #endif
9143
9144 return true;
9145 }
9146 else
9147 {
9148 #ifdef DEBUG_ATTR_CACHE
9149 gs_nAttrCacheMisses++;
9150 #endif
9151 return false;
9152 }
9153 }
9154
9155 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
9156 {
9157 wxGridCellAttr *attr = NULL;
9158 // Additional test to avoid looking at the cache e.g. for
9159 // wxNoCellCoords, as this will confuse memory management.
9160 if ( row >= 0 )
9161 {
9162 if ( !LookupAttr(row, col, &attr) )
9163 {
9164 attr = m_table ? m_table->GetAttr(row, col , wxGridCellAttr::Any)
9165 : (wxGridCellAttr *)NULL;
9166 CacheAttr(row, col, attr);
9167 }
9168 }
9169 if (attr)
9170 {
9171 attr->SetDefAttr(m_defaultCellAttr);
9172 }
9173 else
9174 {
9175 attr = m_defaultCellAttr;
9176 attr->IncRef();
9177 }
9178
9179 return attr;
9180 }
9181
9182 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
9183 {
9184 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
9185 bool canHave = ((wxGrid*)this)->CanHaveAttributes();
9186
9187 wxCHECK_MSG( canHave, attr, _T("Cell attributes not allowed"));
9188 wxCHECK_MSG( m_table, attr, _T("must have a table") );
9189
9190 attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell);
9191 if ( !attr )
9192 {
9193 attr = new wxGridCellAttr(m_defaultCellAttr);
9194
9195 // artificially inc the ref count to match DecRef() in caller
9196 attr->IncRef();
9197 m_table->SetAttr(attr, row, col);
9198 }
9199
9200 return attr;
9201 }
9202
9203 // ----------------------------------------------------------------------------
9204 // setting column attributes (wrappers around SetColAttr)
9205 // ----------------------------------------------------------------------------
9206
9207 void wxGrid::SetColFormatBool(int col)
9208 {
9209 SetColFormatCustom(col, wxGRID_VALUE_BOOL);
9210 }
9211
9212 void wxGrid::SetColFormatNumber(int col)
9213 {
9214 SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
9215 }
9216
9217 void wxGrid::SetColFormatFloat(int col, int width, int precision)
9218 {
9219 wxString typeName = wxGRID_VALUE_FLOAT;
9220 if ( (width != -1) || (precision != -1) )
9221 {
9222 typeName << _T(':') << width << _T(',') << precision;
9223 }
9224
9225 SetColFormatCustom(col, typeName);
9226 }
9227
9228 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
9229 {
9230 wxGridCellAttr *attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
9231 if(!attr)
9232 attr = new wxGridCellAttr;
9233 wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
9234 attr->SetRenderer(renderer);
9235
9236 SetColAttr(col, attr);
9237
9238 }
9239
9240 // ----------------------------------------------------------------------------
9241 // setting cell attributes: this is forwarded to the table
9242 // ----------------------------------------------------------------------------
9243
9244 void wxGrid::SetAttr(int row, int col, wxGridCellAttr *attr)
9245 {
9246 if ( CanHaveAttributes() )
9247 {
9248 m_table->SetAttr(attr, row, col);
9249 ClearAttrCache();
9250 }
9251 else
9252 {
9253 wxSafeDecRef(attr);
9254 }
9255 }
9256
9257 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
9258 {
9259 if ( CanHaveAttributes() )
9260 {
9261 m_table->SetRowAttr(attr, row);
9262 ClearAttrCache();
9263 }
9264 else
9265 {
9266 wxSafeDecRef(attr);
9267 }
9268 }
9269
9270 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
9271 {
9272 if ( CanHaveAttributes() )
9273 {
9274 m_table->SetColAttr(attr, col);
9275 ClearAttrCache();
9276 }
9277 else
9278 {
9279 wxSafeDecRef(attr);
9280 }
9281 }
9282
9283 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
9284 {
9285 if ( CanHaveAttributes() )
9286 {
9287 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9288 attr->SetBackgroundColour(colour);
9289 attr->DecRef();
9290 }
9291 }
9292
9293 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
9294 {
9295 if ( CanHaveAttributes() )
9296 {
9297 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9298 attr->SetTextColour(colour);
9299 attr->DecRef();
9300 }
9301 }
9302
9303 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
9304 {
9305 if ( CanHaveAttributes() )
9306 {
9307 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9308 attr->SetFont(font);
9309 attr->DecRef();
9310 }
9311 }
9312
9313 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
9314 {
9315 if ( CanHaveAttributes() )
9316 {
9317 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9318 attr->SetAlignment(horiz, vert);
9319 attr->DecRef();
9320 }
9321 }
9322
9323 void wxGrid::SetCellOverflow( int row, int col, bool allow )
9324 {
9325 if ( CanHaveAttributes() )
9326 {
9327 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9328 attr->SetOverflow(allow);
9329 attr->DecRef();
9330 }
9331 }
9332
9333 void wxGrid::SetCellSize( int row, int col, int num_rows, int num_cols )
9334 {
9335 if ( CanHaveAttributes() )
9336 {
9337 int cell_rows, cell_cols;
9338
9339 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9340 attr->GetSize(&cell_rows, &cell_cols);
9341 attr->SetSize(num_rows, num_cols);
9342 attr->DecRef();
9343
9344 // Cannot set the size of a cell to 0 or negative values
9345 // While it is perfectly legal to do that, this function cannot
9346 // handle all the possibilies, do it by hand by getting the CellAttr.
9347 // You can only set the size of a cell to 1,1 or greater with this fn
9348 wxASSERT_MSG( !((cell_rows < 1) || (cell_cols < 1)),
9349 wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
9350 wxASSERT_MSG( !((num_rows < 1) || (num_cols < 1)),
9351 wxT("wxGrid::SetCellSize setting cell size to < 1"));
9352
9353 // if this was already a multicell then "turn off" the other cells first
9354 if ((cell_rows > 1) || (cell_rows > 1))
9355 {
9356 int i, j;
9357 for (j=row; j<row+cell_rows; j++)
9358 {
9359 for (i=col; i<col+cell_cols; i++)
9360 {
9361 if ((i != col) || (j != row))
9362 {
9363 wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
9364 attr_stub->SetSize( 1, 1 );
9365 attr_stub->DecRef();
9366 }
9367 }
9368 }
9369 }
9370
9371 // mark the cells that will be covered by this cell to
9372 // negative or zero values to point back at this cell
9373 if (((num_rows > 1) || (num_cols > 1)) && (num_rows >= 1) && (num_cols >= 1))
9374 {
9375 int i, j;
9376 for (j=row; j<row+num_rows; j++)
9377 {
9378 for (i=col; i<col+num_cols; i++)
9379 {
9380 if ((i != col) || (j != row))
9381 {
9382 wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
9383 attr_stub->SetSize( row-j, col-i );
9384 attr_stub->DecRef();
9385 }
9386 }
9387 }
9388 }
9389 }
9390 }
9391
9392 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
9393 {
9394 if ( CanHaveAttributes() )
9395 {
9396 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9397 attr->SetRenderer(renderer);
9398 attr->DecRef();
9399 }
9400 }
9401
9402 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
9403 {
9404 if ( CanHaveAttributes() )
9405 {
9406 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9407 attr->SetEditor(editor);
9408 attr->DecRef();
9409 }
9410 }
9411
9412 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
9413 {
9414 if ( CanHaveAttributes() )
9415 {
9416 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9417 attr->SetReadOnly(isReadOnly);
9418 attr->DecRef();
9419 }
9420 }
9421
9422 // ----------------------------------------------------------------------------
9423 // Data type registration
9424 // ----------------------------------------------------------------------------
9425
9426 void wxGrid::RegisterDataType(const wxString& typeName,
9427 wxGridCellRenderer* renderer,
9428 wxGridCellEditor* editor)
9429 {
9430 m_typeRegistry->RegisterDataType(typeName, renderer, editor);
9431 }
9432
9433
9434 wxGridCellEditor* wxGrid::GetDefaultEditorForCell(int row, int col) const
9435 {
9436 wxString typeName = m_table->GetTypeName(row, col);
9437 return GetDefaultEditorForType(typeName);
9438 }
9439
9440 wxGridCellRenderer* wxGrid::GetDefaultRendererForCell(int row, int col) const
9441 {
9442 wxString typeName = m_table->GetTypeName(row, col);
9443 return GetDefaultRendererForType(typeName);
9444 }
9445
9446 wxGridCellEditor*
9447 wxGrid::GetDefaultEditorForType(const wxString& typeName) const
9448 {
9449 int index = m_typeRegistry->FindOrCloneDataType(typeName);
9450 if ( index == wxNOT_FOUND )
9451 {
9452 wxFAIL_MSG(wxT("Unknown data type name"));
9453
9454 return NULL;
9455 }
9456
9457 return m_typeRegistry->GetEditor(index);
9458 }
9459
9460 wxGridCellRenderer*
9461 wxGrid::GetDefaultRendererForType(const wxString& typeName) const
9462 {
9463 int index = m_typeRegistry->FindOrCloneDataType(typeName);
9464 if ( index == wxNOT_FOUND )
9465 {
9466 wxFAIL_MSG(wxT("Unknown data type name"));
9467
9468 return NULL;
9469 }
9470
9471 return m_typeRegistry->GetRenderer(index);
9472 }
9473
9474
9475 // ----------------------------------------------------------------------------
9476 // row/col size
9477 // ----------------------------------------------------------------------------
9478
9479 void wxGrid::EnableDragRowSize( bool enable )
9480 {
9481 m_canDragRowSize = enable;
9482 }
9483
9484
9485 void wxGrid::EnableDragColSize( bool enable )
9486 {
9487 m_canDragColSize = enable;
9488 }
9489
9490 void wxGrid::EnableDragGridSize( bool enable )
9491 {
9492 m_canDragGridSize = enable;
9493 }
9494
9495 void wxGrid::EnableDragCell( bool enable )
9496 {
9497 m_canDragCell = enable;
9498 }
9499
9500 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
9501 {
9502 m_defaultRowHeight = wxMax( height, m_minAcceptableRowHeight );
9503
9504 if ( resizeExistingRows )
9505 {
9506 // since we are resizing all rows to the default row size,
9507 // we can simply clear the row heights and row bottoms
9508 // arrays (which also allows us to take advantage of
9509 // some speed optimisations)
9510 m_rowHeights.Empty();
9511 m_rowBottoms.Empty();
9512 if ( !GetBatchCount() )
9513 CalcDimensions();
9514 }
9515 }
9516
9517 void wxGrid::SetRowSize( int row, int height )
9518 {
9519 wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
9520
9521 // See comment in SetColSize
9522 if ( height < GetRowMinimalAcceptableHeight()) { return; }
9523
9524 if ( m_rowHeights.IsEmpty() )
9525 {
9526 // need to really create the array
9527 InitRowHeights();
9528 }
9529
9530 int h = wxMax( 0, height );
9531 int diff = h - m_rowHeights[row];
9532
9533 m_rowHeights[row] = h;
9534 int i;
9535 for ( i = row; i < m_numRows; i++ )
9536 {
9537 m_rowBottoms[i] += diff;
9538 }
9539 if ( !GetBatchCount() )
9540 CalcDimensions();
9541 }
9542
9543 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
9544 {
9545 m_defaultColWidth = wxMax( width, m_minAcceptableColWidth );
9546
9547 if ( resizeExistingCols )
9548 {
9549 // since we are resizing all columns to the default column size,
9550 // we can simply clear the col widths and col rights
9551 // arrays (which also allows us to take advantage of
9552 // some speed optimisations)
9553 m_colWidths.Empty();
9554 m_colRights.Empty();
9555 if ( !GetBatchCount() )
9556 CalcDimensions();
9557 }
9558 }
9559
9560 void wxGrid::SetColSize( int col, int width )
9561 {
9562 wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
9563
9564 // should we check that it's bigger than GetColMinimalWidth(col) here?
9565 // (VZ)
9566 // No, because it is reasonable to assume the library user know's
9567 // what he is doing. However whe should test against the weaker
9568 // constariant of minimalAcceptableWidth, as this breaks rendering
9569 //
9570 // This test then fixes sf.net bug #645734
9571
9572 if ( width < GetColMinimalAcceptableWidth()) { return; }
9573
9574 if ( m_colWidths.IsEmpty() )
9575 {
9576 // need to really create the array
9577 InitColWidths();
9578 }
9579
9580 // if < 0 calc new width from label
9581 if( width < 0 )
9582 {
9583 long w, h;
9584 wxArrayString lines;
9585 wxClientDC dc(m_colLabelWin);
9586 dc.SetFont(GetLabelFont());
9587 StringToLines(GetColLabelValue(col), lines);
9588 GetTextBoxSize(dc, lines, &w, &h);
9589 width = w + 6;
9590 }
9591 int w = wxMax( 0, width );
9592 int diff = w - m_colWidths[col];
9593 m_colWidths[col] = w;
9594
9595 int i;
9596 for ( i = col; i < m_numCols; i++ )
9597 {
9598 m_colRights[i] += diff;
9599 }
9600 if ( !GetBatchCount() )
9601 CalcDimensions();
9602 }
9603
9604
9605 void wxGrid::SetColMinimalWidth( int col, int width )
9606 {
9607 if (width > GetColMinimalAcceptableWidth()) {
9608 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
9609 m_colMinWidths[key] = width;
9610 }
9611 }
9612
9613 void wxGrid::SetRowMinimalHeight( int row, int width )
9614 {
9615 if (width > GetRowMinimalAcceptableHeight()) {
9616 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
9617 m_rowMinHeights[key] = width;
9618 }
9619 }
9620
9621 int wxGrid::GetColMinimalWidth(int col) const
9622 {
9623 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
9624 wxLongToLongHashMap::const_iterator it = m_colMinWidths.find(key);
9625 return it != m_colMinWidths.end() ? (int)it->second : m_minAcceptableColWidth;
9626 }
9627
9628 int wxGrid::GetRowMinimalHeight(int row) const
9629 {
9630 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
9631 wxLongToLongHashMap::const_iterator it = m_rowMinHeights.find(key);
9632 return it != m_rowMinHeights.end() ? (int)it->second : m_minAcceptableRowHeight;
9633 }
9634
9635 void wxGrid::SetColMinimalAcceptableWidth( int width )
9636 {
9637 // We do allow a width of 0 since this gives us
9638 // an easy way to temporarily hidding columns.
9639 if ( width<0 )
9640 return;
9641 m_minAcceptableColWidth = width;
9642 }
9643
9644 void wxGrid::SetRowMinimalAcceptableHeight( int height )
9645 {
9646 // We do allow a height of 0 since this gives us
9647 // an easy way to temporarily hidding rows.
9648 if ( height<0 )
9649 return;
9650 m_minAcceptableRowHeight = height;
9651 };
9652
9653 int wxGrid::GetColMinimalAcceptableWidth() const
9654 {
9655 return m_minAcceptableColWidth;
9656 }
9657
9658 int wxGrid::GetRowMinimalAcceptableHeight() const
9659 {
9660 return m_minAcceptableRowHeight;
9661 }
9662
9663 // ----------------------------------------------------------------------------
9664 // auto sizing
9665 // ----------------------------------------------------------------------------
9666
9667 void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
9668 {
9669 wxClientDC dc(m_gridWin);
9670
9671 //Cancel editting of cell
9672 HideCellEditControl();
9673 SaveEditControlValue();
9674
9675 // init both of them to avoid compiler warnings, even if weo nly need one
9676 int row = -1,
9677 col = -1;
9678 if ( column )
9679 col = colOrRow;
9680 else
9681 row = colOrRow;
9682
9683 wxCoord extent, extentMax = 0;
9684 int max = column ? m_numRows : m_numCols;
9685 for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
9686 {
9687 if ( column )
9688 row = rowOrCol;
9689 else
9690 col = rowOrCol;
9691
9692 wxGridCellAttr* attr = GetCellAttr(row, col);
9693 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
9694 if ( renderer )
9695 {
9696 wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
9697 extent = column ? size.x : size.y;
9698 if ( extent > extentMax )
9699 {
9700 extentMax = extent;
9701 }
9702
9703 renderer->DecRef();
9704 }
9705
9706 attr->DecRef();
9707 }
9708
9709 // now also compare with the column label extent
9710 wxCoord w, h;
9711 dc.SetFont( GetLabelFont() );
9712
9713 if ( column )
9714 {
9715 dc.GetTextExtent( GetColLabelValue(col), &w, &h );
9716 if( GetColLabelTextOrientation() == wxVERTICAL )
9717 w = h;
9718 }
9719 else
9720 dc.GetTextExtent( GetRowLabelValue(row), &w, &h );
9721
9722 extent = column ? w : h;
9723 if ( extent > extentMax )
9724 {
9725 extentMax = extent;
9726 }
9727
9728 if ( !extentMax )
9729 {
9730 // empty column - give default extent (notice that if extentMax is less
9731 // than default extent but != 0, it's ok)
9732 extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
9733 }
9734 else
9735 {
9736 if ( column )
9737 {
9738 // leave some space around text
9739 extentMax += 10;
9740 }
9741 else
9742 {
9743 extentMax += 6;
9744 }
9745 }
9746
9747 if ( column )
9748 {
9749 SetColSize(col, extentMax);
9750 if ( !GetBatchCount() )
9751 {
9752 int cw, ch, dummy;
9753 m_gridWin->GetClientSize( &cw, &ch );
9754 wxRect rect ( CellToRect( 0, col ) );
9755 rect.y = 0;
9756 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
9757 rect.width = cw - rect.x;
9758 rect.height = m_colLabelHeight;
9759 m_colLabelWin->Refresh( true, &rect );
9760 }
9761 }
9762 else
9763 {
9764 SetRowSize(row, extentMax);
9765 if ( !GetBatchCount() )
9766 {
9767 int cw, ch, dummy;
9768 m_gridWin->GetClientSize( &cw, &ch );
9769 wxRect rect ( CellToRect( row, 0 ) );
9770 rect.x = 0;
9771 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
9772 rect.width = m_rowLabelWidth;
9773 rect.height = ch - rect.y;
9774 m_rowLabelWin->Refresh( true, &rect );
9775 }
9776 }
9777 if ( setAsMin )
9778 {
9779 if ( column )
9780 SetColMinimalWidth(col, extentMax);
9781 else
9782 SetRowMinimalHeight(row, extentMax);
9783 }
9784 }
9785
9786 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
9787 {
9788 int width = m_rowLabelWidth;
9789
9790 if ( !calcOnly )
9791 BeginBatch();
9792
9793 for ( int col = 0; col < m_numCols; col++ )
9794 {
9795 if ( !calcOnly )
9796 {
9797 AutoSizeColumn(col, setAsMin);
9798 }
9799
9800 width += GetColWidth(col);
9801 }
9802
9803 if ( !calcOnly )
9804 EndBatch();
9805
9806 return width;
9807 }
9808
9809 int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
9810 {
9811 int height = m_colLabelHeight;
9812
9813 if ( !calcOnly )
9814 BeginBatch();
9815
9816 for ( int row = 0; row < m_numRows; row++ )
9817 {
9818 if ( !calcOnly )
9819 {
9820 AutoSizeRow(row, setAsMin);
9821 }
9822
9823 height += GetRowHeight(row);
9824 }
9825
9826 if ( !calcOnly )
9827 EndBatch();
9828
9829 return height;
9830 }
9831
9832 void wxGrid::AutoSize()
9833 {
9834 BeginBatch();
9835
9836 wxSize size(SetOrCalcColumnSizes(false), SetOrCalcRowSizes(false));
9837
9838 // round up the size to a multiple of scroll step - this ensures that we
9839 // won't get the scrollbars if we're sized exactly to this width
9840 // CalcDimension adds m_extraWidth + 1 etc. to calculate the necessary
9841 // scrollbar steps
9842 wxSize sizeFit(GetScrollX(size.x + m_extraWidth + 1) * GRID_SCROLL_LINE_X,
9843 GetScrollY(size.y + m_extraHeight + 1) * GRID_SCROLL_LINE_Y);
9844
9845 // distribute the extra space between the columns/rows to avoid having
9846 // extra white space
9847
9848 // Remove the extra m_extraWidth + 1 added above
9849 wxCoord diff = sizeFit.x - size.x + (m_extraWidth + 1);
9850 if ( diff && m_numCols )
9851 {
9852 // try to resize the columns uniformly
9853 wxCoord diffPerCol = diff / m_numCols;
9854 if ( diffPerCol )
9855 {
9856 for ( int col = 0; col < m_numCols; col++ )
9857 {
9858 SetColSize(col, GetColWidth(col) + diffPerCol);
9859 }
9860 }
9861
9862 // add remaining amount to the last columns
9863 diff -= diffPerCol * m_numCols;
9864 if ( diff )
9865 {
9866 for ( int col = m_numCols - 1; col >= m_numCols - diff; col-- )
9867 {
9868 SetColSize(col, GetColWidth(col) + 1);
9869 }
9870 }
9871 }
9872
9873 // same for rows
9874 diff = sizeFit.y - size.y - (m_extraHeight + 1);
9875 if ( diff && m_numRows )
9876 {
9877 // try to resize the columns uniformly
9878 wxCoord diffPerRow = diff / m_numRows;
9879 if ( diffPerRow )
9880 {
9881 for ( int row = 0; row < m_numRows; row++ )
9882 {
9883 SetRowSize(row, GetRowHeight(row) + diffPerRow);
9884 }
9885 }
9886
9887 // add remaining amount to the last rows
9888 diff -= diffPerRow * m_numRows;
9889 if ( diff )
9890 {
9891 for ( int row = m_numRows - 1; row >= m_numRows - diff; row-- )
9892 {
9893 SetRowSize(row, GetRowHeight(row) + 1);
9894 }
9895 }
9896 }
9897
9898 EndBatch();
9899
9900 SetClientSize(sizeFit);
9901 }
9902
9903 void wxGrid::AutoSizeRowLabelSize( int row )
9904 {
9905 wxArrayString lines;
9906 long w, h;
9907
9908 // Hide the edit control, so it
9909 // won't interfer with drag-shrinking.
9910 if( IsCellEditControlShown() )
9911 {
9912 HideCellEditControl();
9913 SaveEditControlValue();
9914 }
9915
9916 // autosize row height depending on label text
9917 StringToLines( GetRowLabelValue( row ), lines );
9918 wxClientDC dc( m_rowLabelWin );
9919 GetTextBoxSize( dc, lines, &w, &h);
9920 if( h < m_defaultRowHeight )
9921 h = m_defaultRowHeight;
9922 SetRowSize(row, h);
9923 ForceRefresh();
9924 }
9925
9926 void wxGrid::AutoSizeColLabelSize( int col )
9927 {
9928 wxArrayString lines;
9929 long w, h;
9930
9931 // Hide the edit control, so it
9932 // won't interfer with drag-shrinking.
9933 if( IsCellEditControlShown() )
9934 {
9935 HideCellEditControl();
9936 SaveEditControlValue();
9937 }
9938
9939 // autosize column width depending on label text
9940 StringToLines( GetColLabelValue( col ), lines );
9941 wxClientDC dc( m_colLabelWin );
9942 if( GetColLabelTextOrientation() == wxHORIZONTAL )
9943 GetTextBoxSize( dc, lines, &w, &h);
9944 else
9945 GetTextBoxSize( dc, lines, &h, &w);
9946 if( w < m_defaultColWidth )
9947 w = m_defaultColWidth;
9948 SetColSize(col, w);
9949 ForceRefresh();
9950 }
9951
9952 wxSize wxGrid::DoGetBestSize() const
9953 {
9954 // don't set sizes, only calculate them
9955 wxGrid *self = (wxGrid *)this; // const_cast
9956
9957 int width, height;
9958 width = self->SetOrCalcColumnSizes(true);
9959 height = self->SetOrCalcRowSizes(true);
9960
9961 if (!width) width=100;
9962 if (!height) height=80;
9963
9964 // Round up to a multiple the scroll rate NOTE: this still doesn't get rid
9965 // of the scrollbars, is there any magic incantaion for that?
9966 int xpu, ypu;
9967 GetScrollPixelsPerUnit(&xpu, &ypu);
9968 if (xpu)
9969 width += 1 + xpu - (width % xpu);
9970 if (ypu)
9971 height += 1 + ypu - (height % ypu);
9972
9973 // limit to 1/4 of the screen size
9974 int maxwidth, maxheight;
9975 wxDisplaySize( & maxwidth, & maxheight );
9976 maxwidth /= 2;
9977 maxheight /= 2;
9978 if ( width > maxwidth ) width = maxwidth;
9979 if ( height > maxheight ) height = maxheight;
9980
9981
9982 wxSize best(width, height);
9983 // NOTE: This size should be cached, but first we need to add calls to
9984 // InvalidateBestSize everywhere that could change the results of this
9985 // calculation.
9986 // CacheBestSize(size);
9987 return best;
9988 }
9989
9990 void wxGrid::Fit()
9991 {
9992 AutoSize();
9993 }
9994
9995
9996 wxPen& wxGrid::GetDividerPen() const
9997 {
9998 return wxNullPen;
9999 }
10000
10001 // ----------------------------------------------------------------------------
10002 // cell value accessor functions
10003 // ----------------------------------------------------------------------------
10004
10005 void wxGrid::SetCellValue( int row, int col, const wxString& s )
10006 {
10007 if ( m_table )
10008 {
10009 m_table->SetValue( row, col, s );
10010 if ( !GetBatchCount() )
10011 {
10012 int dummy;
10013 wxRect rect( CellToRect( row, col ) );
10014 rect.x = 0;
10015 rect.width = m_gridWin->GetClientSize().GetWidth();
10016 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
10017 m_gridWin->Refresh( false, &rect );
10018 }
10019
10020 if ( m_currentCellCoords.GetRow() == row &&
10021 m_currentCellCoords.GetCol() == col &&
10022 IsCellEditControlShown())
10023 // Note: If we are using IsCellEditControlEnabled,
10024 // this interacts badly with calling SetCellValue from
10025 // an EVT_GRID_CELL_CHANGE handler.
10026 {
10027 HideCellEditControl();
10028 ShowCellEditControl(); // will reread data from table
10029 }
10030 }
10031 }
10032
10033
10034 //
10035 // ------ Block, row and col selection
10036 //
10037
10038 void wxGrid::SelectRow( int row, bool addToSelected )
10039 {
10040 if ( IsSelection() && !addToSelected )
10041 ClearSelection();
10042
10043 if ( m_selection )
10044 m_selection->SelectRow( row, false, addToSelected );
10045 }
10046
10047
10048 void wxGrid::SelectCol( int col, bool addToSelected )
10049 {
10050 if ( IsSelection() && !addToSelected )
10051 ClearSelection();
10052
10053 if ( m_selection )
10054 m_selection->SelectCol( col, false, addToSelected );
10055 }
10056
10057
10058 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
10059 bool addToSelected )
10060 {
10061 if ( IsSelection() && !addToSelected )
10062 ClearSelection();
10063
10064 if ( m_selection )
10065 m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol,
10066 false, addToSelected );
10067 }
10068
10069
10070 void wxGrid::SelectAll()
10071 {
10072 if ( m_numRows > 0 && m_numCols > 0 )
10073 {
10074 if ( m_selection )
10075 m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
10076 }
10077 }
10078
10079 //
10080 // ------ Cell, row and col deselection
10081 //
10082
10083 void wxGrid::DeselectRow( int row )
10084 {
10085 if ( !m_selection )
10086 return;
10087
10088 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
10089 {
10090 if ( m_selection->IsInSelection(row, 0 ) )
10091 m_selection->ToggleCellSelection( row, 0);
10092 }
10093 else
10094 {
10095 int nCols = GetNumberCols();
10096 for ( int i = 0; i < nCols ; i++ )
10097 {
10098 if ( m_selection->IsInSelection(row, i ) )
10099 m_selection->ToggleCellSelection( row, i);
10100 }
10101 }
10102 }
10103
10104 void wxGrid::DeselectCol( int col )
10105 {
10106 if ( !m_selection )
10107 return;
10108
10109 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
10110 {
10111 if ( m_selection->IsInSelection(0, col ) )
10112 m_selection->ToggleCellSelection( 0, col);
10113 }
10114 else
10115 {
10116 int nRows = GetNumberRows();
10117 for ( int i = 0; i < nRows ; i++ )
10118 {
10119 if ( m_selection->IsInSelection(i, col ) )
10120 m_selection->ToggleCellSelection(i, col);
10121 }
10122 }
10123 }
10124
10125 void wxGrid::DeselectCell( int row, int col )
10126 {
10127 if ( m_selection && m_selection->IsInSelection(row, col) )
10128 m_selection->ToggleCellSelection(row, col);
10129 }
10130
10131 bool wxGrid::IsSelection()
10132 {
10133 return ( m_selection && (m_selection->IsSelection() ||
10134 ( m_selectingTopLeft != wxGridNoCellCoords &&
10135 m_selectingBottomRight != wxGridNoCellCoords) ) );
10136 }
10137
10138 bool wxGrid::IsInSelection( int row, int col ) const
10139 {
10140 return ( m_selection && (m_selection->IsInSelection( row, col ) ||
10141 ( row >= m_selectingTopLeft.GetRow() &&
10142 col >= m_selectingTopLeft.GetCol() &&
10143 row <= m_selectingBottomRight.GetRow() &&
10144 col <= m_selectingBottomRight.GetCol() )) );
10145 }
10146
10147 wxGridCellCoordsArray wxGrid::GetSelectedCells() const
10148 {
10149 if (!m_selection) { wxGridCellCoordsArray a; return a; }
10150 return m_selection->m_cellSelection;
10151 }
10152 wxGridCellCoordsArray wxGrid::GetSelectionBlockTopLeft() const
10153 {
10154 if (!m_selection) { wxGridCellCoordsArray a; return a; }
10155 return m_selection->m_blockSelectionTopLeft;
10156 }
10157 wxGridCellCoordsArray wxGrid::GetSelectionBlockBottomRight() const
10158 {
10159 if (!m_selection) { wxGridCellCoordsArray a; return a; }
10160 return m_selection->m_blockSelectionBottomRight;
10161 }
10162 wxArrayInt wxGrid::GetSelectedRows() const
10163 {
10164 if (!m_selection) { wxArrayInt a; return a; }
10165 return m_selection->m_rowSelection;
10166 }
10167 wxArrayInt wxGrid::GetSelectedCols() const
10168 {
10169 if (!m_selection) { wxArrayInt a; return a; }
10170 return m_selection->m_colSelection;
10171 }
10172
10173
10174 void wxGrid::ClearSelection()
10175 {
10176 m_selectingTopLeft = wxGridNoCellCoords;
10177 m_selectingBottomRight = wxGridNoCellCoords;
10178 if ( m_selection )
10179 m_selection->ClearSelection();
10180 }
10181
10182
10183 // This function returns the rectangle that encloses the given block
10184 // in device coords clipped to the client size of the grid window.
10185 //
10186 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
10187 const wxGridCellCoords &bottomRight )
10188 {
10189 wxRect rect( wxGridNoCellRect );
10190 wxRect cellRect;
10191
10192 cellRect = CellToRect( topLeft );
10193 if ( cellRect != wxGridNoCellRect )
10194 {
10195 rect = cellRect;
10196 }
10197 else
10198 {
10199 rect = wxRect(0,0,0,0);
10200 }
10201
10202 cellRect = CellToRect( bottomRight );
10203 if ( cellRect != wxGridNoCellRect )
10204 {
10205 rect += cellRect;
10206 }
10207 else
10208 {
10209 return wxGridNoCellRect;
10210 }
10211
10212 int i, j;
10213 int left = rect.GetLeft();
10214 int top = rect.GetTop();
10215 int right = rect.GetRight();
10216 int bottom = rect.GetBottom();
10217
10218 int leftCol = topLeft.GetCol();
10219 int topRow = topLeft.GetRow();
10220 int rightCol = bottomRight.GetCol();
10221 int bottomRow = bottomRight.GetRow();
10222
10223 if (left > right)
10224 {
10225 i = left;
10226 left = right;
10227 right = i;
10228 i = leftCol;
10229 leftCol=rightCol;
10230 rightCol = i;
10231 }
10232
10233 if (top > bottom)
10234 {
10235 i = top;
10236 top = bottom;
10237 bottom = i;
10238 i = topRow;
10239 topRow = bottomRow;
10240 bottomRow = i;
10241 }
10242
10243
10244 for ( j = topRow; j <= bottomRow; j++ )
10245 {
10246 for ( i = leftCol; i <= rightCol; i++ )
10247 {
10248 if ((j==topRow) || (j==bottomRow) || (i==leftCol) || (i==rightCol))
10249 {
10250 cellRect = CellToRect( j, i );
10251
10252 if (cellRect.x < left)
10253 left = cellRect.x;
10254 if (cellRect.y < top)
10255 top = cellRect.y;
10256 if (cellRect.x + cellRect.width > right)
10257 right = cellRect.x + cellRect.width;
10258 if (cellRect.y + cellRect.height > bottom)
10259 bottom = cellRect.y + cellRect.height;
10260 }
10261 else i = rightCol; // jump over inner cells.
10262 }
10263 }
10264
10265 // convert to scrolled coords
10266 //
10267 CalcScrolledPosition( left, top, &left, &top );
10268 CalcScrolledPosition( right, bottom, &right, &bottom );
10269
10270 int cw, ch;
10271 m_gridWin->GetClientSize( &cw, &ch );
10272
10273 if (right < 0 || bottom < 0 || left > cw || top > ch)
10274 return wxRect(0,0,0,0);
10275
10276 rect.SetLeft( wxMax(0, left) );
10277 rect.SetTop( wxMax(0, top) );
10278 rect.SetRight( wxMin(cw, right) );
10279 rect.SetBottom( wxMin(ch, bottom) );
10280
10281 return rect;
10282 }
10283
10284 //
10285 // ------ Grid event classes
10286 //
10287
10288 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
10289
10290 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
10291 int row, int col, int x, int y, bool sel,
10292 bool control, bool shift, bool alt, bool meta )
10293 : wxNotifyEvent( type, id )
10294 {
10295 m_row = row;
10296 m_col = col;
10297 m_x = x;
10298 m_y = y;
10299 m_selecting = sel;
10300 m_control = control;
10301 m_shift = shift;
10302 m_alt = alt;
10303 m_meta = meta;
10304
10305 SetEventObject(obj);
10306 }
10307
10308
10309 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
10310
10311 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
10312 int rowOrCol, int x, int y,
10313 bool control, bool shift, bool alt, bool meta )
10314 : wxNotifyEvent( type, id )
10315 {
10316 m_rowOrCol = rowOrCol;
10317 m_x = x;
10318 m_y = y;
10319 m_control = control;
10320 m_shift = shift;
10321 m_alt = alt;
10322 m_meta = meta;
10323
10324 SetEventObject(obj);
10325 }
10326
10327
10328 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
10329
10330 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
10331 const wxGridCellCoords& topLeft,
10332 const wxGridCellCoords& bottomRight,
10333 bool sel, bool control,
10334 bool shift, bool alt, bool meta )
10335 : wxNotifyEvent( type, id )
10336 {
10337 m_topLeft = topLeft;
10338 m_bottomRight = bottomRight;
10339 m_selecting = sel;
10340 m_control = control;
10341 m_shift = shift;
10342 m_alt = alt;
10343 m_meta = meta;
10344
10345 SetEventObject(obj);
10346 }
10347
10348
10349 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
10350
10351 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
10352 wxObject* obj, int row,
10353 int col, wxControl* ctrl)
10354 : wxCommandEvent(type, id)
10355 {
10356 SetEventObject(obj);
10357 m_row = row;
10358 m_col = col;
10359 m_ctrl = ctrl;
10360 }
10361
10362 #endif // wxUSE_GRID
10363
wxWidgets (Impactor)