]>
Commit | Line | Data |
---|---|---|
f7556ff0 JS |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: griddemo.cpp | |
3 | // Purpose: Grid control wxWindows sample | |
4 | // Author: Michael Bedward | |
5 | // Modified by: | |
6 | // RCS-ID: $Id$ | |
7 | // Copyright: (c) Michael Bedward, Julian Smart | |
8 | // Licence: wxWindows license | |
9 | ///////////////////////////////////////////////////////////////////////////// | |
10 | ||
11 | // ============================================================================ | |
12 | // declarations | |
13 | // ============================================================================ | |
14 | ||
15 | // ---------------------------------------------------------------------------- | |
16 | // headers | |
17 | // ---------------------------------------------------------------------------- | |
18 | ||
a7166b34 | 19 | #if defined(__GNUG__) && !defined(__APPLE__) |
f7556ff0 JS |
20 | #pragma implementation |
21 | #pragma interface | |
22 | #endif | |
23 | ||
24 | // For compilers that support precompilation, includes "wx/wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | #ifdef __BORLANDC__ | |
28 | #pragma hdrstop | |
29 | #endif | |
30 | ||
31 | #ifndef WX_PRECOMP | |
32 | #include "wx/wx.h" | |
33 | #endif | |
34 | ||
35 | #include "wx/colordlg.h" | |
36 | #include "wx/fontdlg.h" | |
37 | ||
38 | #include "wx/grid.h" | |
39 | #include "wx/generic/gridctrl.h" | |
40 | ||
41 | #include "griddemo.h" | |
42 | ||
43 | // ---------------------------------------------------------------------------- | |
44 | // wxWin macros | |
45 | // ---------------------------------------------------------------------------- | |
46 | ||
47 | IMPLEMENT_APP( GridApp ) | |
48 | ||
49 | // ============================================================================ | |
50 | // implementation | |
51 | // ============================================================================ | |
52 | ||
53 | // ---------------------------------------------------------------------------- | |
54 | // GridApp | |
55 | // ---------------------------------------------------------------------------- | |
56 | ||
57 | bool GridApp::OnInit() | |
58 | { | |
59 | GridFrame *frame = new GridFrame; | |
60 | frame->Show( TRUE ); | |
61 | ||
62 | return TRUE; | |
63 | } | |
64 | ||
65 | // ---------------------------------------------------------------------------- | |
66 | // GridFrame | |
67 | // ---------------------------------------------------------------------------- | |
68 | ||
69 | BEGIN_EVENT_TABLE( GridFrame, wxFrame ) | |
70 | EVT_MENU( ID_TOGGLEROWLABELS, GridFrame::ToggleRowLabels ) | |
71 | EVT_MENU( ID_TOGGLECOLLABELS, GridFrame::ToggleColLabels ) | |
72 | EVT_MENU( ID_TOGGLEEDIT, GridFrame::ToggleEditing ) | |
73 | EVT_MENU( ID_TOGGLEROWSIZING, GridFrame::ToggleRowSizing ) | |
74 | EVT_MENU( ID_TOGGLECOLSIZING, GridFrame::ToggleColSizing ) | |
75 | EVT_MENU( ID_TOGGLEGRIDSIZING, GridFrame::ToggleGridSizing ) | |
76 | EVT_MENU( ID_TOGGLEGRIDLINES, GridFrame::ToggleGridLines ) | |
77 | EVT_MENU( ID_AUTOSIZECOLS, GridFrame::AutoSizeCols ) | |
78 | EVT_MENU( ID_CELLOVERFLOW, GridFrame::CellOverflow ) | |
79 | EVT_MENU( ID_RESIZECELL, GridFrame::ResizeCell ) | |
80 | EVT_MENU( ID_SETLABELCOLOUR, GridFrame::SetLabelColour ) | |
81 | EVT_MENU( ID_SETLABELTEXTCOLOUR, GridFrame::SetLabelTextColour ) | |
82 | EVT_MENU( ID_SETLABEL_FONT, GridFrame::SetLabelFont ) | |
83 | EVT_MENU( ID_ROWLABELHORIZALIGN, GridFrame::SetRowLabelHorizAlignment ) | |
84 | EVT_MENU( ID_ROWLABELVERTALIGN, GridFrame::SetRowLabelVertAlignment ) | |
85 | EVT_MENU( ID_COLLABELHORIZALIGN, GridFrame::SetColLabelHorizAlignment ) | |
86 | EVT_MENU( ID_COLLABELVERTALIGN, GridFrame::SetColLabelVertAlignment ) | |
87 | EVT_MENU( ID_GRIDLINECOLOUR, GridFrame::SetGridLineColour ) | |
88 | EVT_MENU( ID_INSERTROW, GridFrame::InsertRow ) | |
89 | EVT_MENU( ID_INSERTCOL, GridFrame::InsertCol ) | |
90 | EVT_MENU( ID_DELETEROW, GridFrame::DeleteSelectedRows ) | |
91 | EVT_MENU( ID_DELETECOL, GridFrame::DeleteSelectedCols ) | |
92 | EVT_MENU( ID_CLEARGRID, GridFrame::ClearGrid ) | |
93 | EVT_MENU( ID_SELCELLS, GridFrame::SelectCells ) | |
94 | EVT_MENU( ID_SELROWS, GridFrame::SelectRows ) | |
95 | EVT_MENU( ID_SELCOLS, GridFrame::SelectCols ) | |
96 | ||
97 | EVT_MENU( ID_SET_CELL_FG_COLOUR, GridFrame::SetCellFgColour ) | |
98 | EVT_MENU( ID_SET_CELL_BG_COLOUR, GridFrame::SetCellBgColour ) | |
99 | ||
100 | EVT_MENU( ID_ABOUT, GridFrame::About ) | |
101 | EVT_MENU( wxID_EXIT, GridFrame::OnQuit ) | |
102 | EVT_MENU( ID_VTABLE, GridFrame::OnVTable) | |
103 | EVT_MENU( ID_BUGS_TABLE, GridFrame::OnBugsTable) | |
104 | EVT_MENU( ID_SMALL_GRID, GridFrame::OnSmallGrid) | |
105 | ||
106 | EVT_MENU( ID_DESELECT_CELL, GridFrame::DeselectCell) | |
107 | EVT_MENU( ID_DESELECT_COL, GridFrame::DeselectCol) | |
108 | EVT_MENU( ID_DESELECT_ROW, GridFrame::DeselectRow) | |
109 | EVT_MENU( ID_DESELECT_ALL, GridFrame::DeselectAll) | |
110 | EVT_MENU( ID_SELECT_CELL, GridFrame::SelectCell) | |
111 | EVT_MENU( ID_SELECT_COL, GridFrame::SelectCol) | |
112 | EVT_MENU( ID_SELECT_ROW, GridFrame::SelectRow) | |
113 | EVT_MENU( ID_SELECT_ALL, GridFrame::SelectAll) | |
114 | EVT_MENU( ID_SELECT_UNSELECT, GridFrame::OnAddToSelectToggle) | |
115 | ||
116 | EVT_MENU( ID_SET_HIGHLIGHT_WIDTH, GridFrame::OnSetHighlightWidth) | |
117 | EVT_MENU( ID_SET_RO_HIGHLIGHT_WIDTH, GridFrame::OnSetROHighlightWidth) | |
118 | ||
119 | EVT_GRID_LABEL_LEFT_CLICK( GridFrame::OnLabelLeftClick ) | |
120 | EVT_GRID_CELL_LEFT_CLICK( GridFrame::OnCellLeftClick ) | |
121 | EVT_GRID_ROW_SIZE( GridFrame::OnRowSize ) | |
122 | EVT_GRID_COL_SIZE( GridFrame::OnColSize ) | |
123 | EVT_GRID_SELECT_CELL( GridFrame::OnSelectCell ) | |
124 | EVT_GRID_RANGE_SELECT( GridFrame::OnRangeSelected ) | |
125 | EVT_GRID_CELL_CHANGE( GridFrame::OnCellValueChanged ) | |
126 | ||
127 | EVT_GRID_EDITOR_SHOWN( GridFrame::OnEditorShown ) | |
128 | EVT_GRID_EDITOR_HIDDEN( GridFrame::OnEditorHidden ) | |
129 | END_EVENT_TABLE() | |
130 | ||
131 | ||
132 | GridFrame::GridFrame() | |
133 | : wxFrame( (wxFrame *)NULL, -1, _T("wxWindows grid class demo"), | |
134 | wxDefaultPosition, | |
135 | wxDefaultSize ) | |
136 | { | |
137 | int gridW = 600, gridH = 300; | |
138 | int logW = gridW, logH = 100; | |
139 | ||
140 | wxMenu *fileMenu = new wxMenu; | |
141 | fileMenu->Append( ID_VTABLE, _T("&Virtual table test\tCtrl-V")); | |
142 | fileMenu->Append( ID_BUGS_TABLE, _T("&Bugs table test\tCtrl-B")); | |
143 | fileMenu->Append( ID_SMALL_GRID, _T("&Small Grid test\tCtrl-S")); | |
144 | fileMenu->AppendSeparator(); | |
145 | fileMenu->Append( wxID_EXIT, _T("E&xit\tAlt-X") ); | |
146 | ||
147 | wxMenu *viewMenu = new wxMenu; | |
148 | viewMenu->Append( ID_TOGGLEROWLABELS, _T("&Row labels"), _T(""), wxITEM_CHECK ); | |
149 | viewMenu->Append( ID_TOGGLECOLLABELS, _T("&Col labels"), _T(""), wxITEM_CHECK ); | |
150 | viewMenu->Append( ID_TOGGLEEDIT, _T("&Editable"), _T(""), wxITEM_CHECK ); | |
151 | viewMenu->Append( ID_TOGGLEROWSIZING, _T("Ro&w drag-resize"), _T(""), wxITEM_CHECK ); | |
152 | viewMenu->Append( ID_TOGGLECOLSIZING, _T("C&ol drag-resize"), _T(""), wxITEM_CHECK ); | |
153 | viewMenu->Append( ID_TOGGLEGRIDSIZING, _T("&Grid drag-resize"), _T(""), wxITEM_CHECK ); | |
154 | viewMenu->Append( ID_TOGGLEGRIDLINES, _T("&Grid Lines"), _T(""), wxITEM_CHECK ); | |
155 | viewMenu->Append( ID_SET_HIGHLIGHT_WIDTH, _T("&Set Cell Highlight Width..."), _T("") ); | |
156 | viewMenu->Append( ID_SET_RO_HIGHLIGHT_WIDTH, _T("&Set Cell RO Highlight Width..."), _T("") ); | |
157 | viewMenu->Append( ID_AUTOSIZECOLS, _T("&Auto-size cols") ); | |
158 | viewMenu->Append( ID_CELLOVERFLOW, _T("&Overflow cells"), _T(""), wxITEM_CHECK ); | |
159 | viewMenu->Append( ID_RESIZECELL, _T("&Resize cell (7,1)"), _T(""), wxITEM_CHECK ); | |
160 | ||
161 | wxMenu *rowLabelMenu = new wxMenu; | |
162 | ||
163 | viewMenu->Append( ID_ROWLABELALIGN, _T("R&ow label alignment"), | |
164 | rowLabelMenu, | |
165 | _T("Change alignment of row labels") ); | |
166 | ||
167 | rowLabelMenu->Append( ID_ROWLABELHORIZALIGN, _T("&Horizontal") ); | |
168 | rowLabelMenu->Append( ID_ROWLABELVERTALIGN, _T("&Vertical") ); | |
169 | ||
170 | wxMenu *colLabelMenu = new wxMenu; | |
171 | ||
172 | viewMenu->Append( ID_COLLABELALIGN, _T("Col l&abel alignment"), | |
173 | colLabelMenu, | |
174 | _T("Change alignment of col labels") ); | |
175 | ||
176 | colLabelMenu->Append( ID_COLLABELHORIZALIGN, _T("&Horizontal") ); | |
177 | colLabelMenu->Append( ID_COLLABELVERTALIGN, _T("&Vertical") ); | |
178 | ||
179 | wxMenu *colMenu = new wxMenu; | |
180 | colMenu->Append( ID_SETLABELCOLOUR, _T("Set &label colour...") ); | |
181 | colMenu->Append( ID_SETLABELTEXTCOLOUR, _T("Set label &text colour...") ); | |
182 | colMenu->Append( ID_SETLABEL_FONT, _T("Set label fo&nt...") ); | |
183 | colMenu->Append( ID_GRIDLINECOLOUR, _T("&Grid line colour...") ); | |
184 | colMenu->Append( ID_SET_CELL_FG_COLOUR, _T("Set cell &foreground colour...") ); | |
185 | colMenu->Append( ID_SET_CELL_BG_COLOUR, _T("Set cell &background colour...") ); | |
186 | ||
187 | wxMenu *editMenu = new wxMenu; | |
188 | editMenu->Append( ID_INSERTROW, _T("Insert &row") ); | |
189 | editMenu->Append( ID_INSERTCOL, _T("Insert &column") ); | |
190 | editMenu->Append( ID_DELETEROW, _T("Delete selected ro&ws") ); | |
191 | editMenu->Append( ID_DELETECOL, _T("Delete selected co&ls") ); | |
192 | editMenu->Append( ID_CLEARGRID, _T("Cl&ear grid cell contents") ); | |
193 | ||
194 | wxMenu *selectMenu = new wxMenu; | |
195 | selectMenu->Append( ID_SELECT_UNSELECT, _T("Add new cells to the selection"), | |
196 | _T("When off, old selection is deselected before ") | |
197 | _T("selecting the new cells"), wxITEM_CHECK ); | |
198 | selectMenu->Append( ID_SELECT_ALL, _T("Select all")); | |
199 | selectMenu->Append( ID_SELECT_ROW, _T("Select row 2")); | |
200 | selectMenu->Append( ID_SELECT_COL, _T("Select col 2")); | |
201 | selectMenu->Append( ID_SELECT_CELL, _T("Select cell (3, 1)")); | |
202 | selectMenu->Append( ID_DESELECT_ALL, _T("Deselect all")); | |
203 | selectMenu->Append( ID_DESELECT_ROW, _T("Deselect row 2")); | |
204 | selectMenu->Append( ID_DESELECT_COL, _T("Deselect col 2")); | |
205 | selectMenu->Append( ID_DESELECT_CELL, _T("Deselect cell (3, 1)")); | |
206 | wxMenu *selectionMenu = new wxMenu; | |
207 | selectMenu->Append( ID_CHANGESEL, _T("Change &selection mode"), | |
208 | selectionMenu, | |
209 | _T("Change selection mode") ); | |
210 | ||
211 | selectionMenu->Append( ID_SELCELLS, _T("Select &Cells") ); | |
212 | selectionMenu->Append( ID_SELROWS, _T("Select &Rows") ); | |
213 | selectionMenu->Append( ID_SELCOLS, _T("Select C&ols") ); | |
214 | ||
215 | ||
216 | wxMenu *helpMenu = new wxMenu; | |
217 | helpMenu->Append( ID_ABOUT, _T("&About wxGrid demo") ); | |
218 | ||
219 | wxMenuBar *menuBar = new wxMenuBar; | |
220 | menuBar->Append( fileMenu, _T("&File") ); | |
221 | menuBar->Append( viewMenu, _T("&View") ); | |
222 | menuBar->Append( colMenu, _T("&Colours") ); | |
223 | menuBar->Append( editMenu, _T("&Edit") ); | |
224 | menuBar->Append( selectMenu, _T("&Select") ); | |
225 | menuBar->Append( helpMenu, _T("&Help") ); | |
226 | ||
227 | SetMenuBar( menuBar ); | |
228 | ||
229 | m_addToSel = FALSE; | |
230 | ||
231 | grid = new wxGrid( this, | |
232 | -1, | |
233 | wxPoint( 0, 0 ), | |
234 | wxSize( 400, 300 ) ); | |
235 | ||
236 | logWin = new wxTextCtrl( this, | |
237 | -1, | |
238 | wxEmptyString, | |
239 | wxPoint( 0, gridH + 20 ), | |
240 | wxSize( logW, logH ), | |
241 | wxTE_MULTILINE ); | |
242 | ||
243 | logger = new wxLogTextCtrl( logWin ); | |
244 | m_logOld = logger->SetActiveTarget( logger ); | |
245 | logger->SetTimestamp( NULL ); | |
246 | ||
247 | // this will create a grid and, by default, an associated grid | |
248 | // table for strings | |
249 | grid->CreateGrid( 0, 0 ); | |
250 | grid->AppendRows(100); | |
251 | grid->AppendCols(100); | |
252 | ||
253 | int ir = grid->GetNumberRows(); | |
254 | grid->DeleteRows(0, ir); | |
255 | grid->AppendRows(ir); | |
256 | ||
257 | grid->SetRowSize( 0, 60 ); | |
258 | grid->SetCellValue( 0, 0, _T("Ctrl+Home\nwill go to\nthis cell") ); | |
259 | ||
260 | grid->SetCellValue( 0, 1, _T("A long piece of text to demonstrate wrapping.") ); | |
261 | grid->SetCellRenderer(0 , 1, new wxGridCellAutoWrapStringRenderer); | |
262 | grid->SetCellEditor( 0, 1 , new wxGridCellAutoWrapStringEditor); | |
263 | ||
264 | grid->SetCellValue( 0, 2, _T("Blah") ); | |
265 | grid->SetCellValue( 0, 3, _T("Read only") ); | |
266 | grid->SetReadOnly( 0, 3 ); | |
267 | ||
268 | grid->SetCellValue( 0, 4, _T("Can veto edit this cell") ); | |
269 | ||
270 | grid->SetCellValue( 0, 5, _T("Press\nCtrl+arrow\nto skip over\ncells") ); | |
271 | ||
272 | grid->SetRowSize( 99, 60 ); | |
273 | grid->SetCellValue( 99, 99, _T("Ctrl+End\nwill go to\nthis cell") ); | |
274 | grid->SetCellValue( 1, 0, _T("This default cell will overflow into neighboring cells, but not if you turn overflow off.")); | |
275 | ||
276 | grid->SetCellTextColour(1, 2, *wxRED); | |
277 | grid->SetCellBackgroundColour(1, 2, *wxGREEN); | |
278 | ||
279 | grid->SetCellValue( 1, 4, _T("I'm in the middle")); | |
280 | ||
281 | grid->SetCellValue(2, 2, _T("red")); | |
282 | ||
283 | grid->SetCellTextColour(2, 2, *wxRED); | |
284 | grid->SetCellValue(3, 3, _T("green on grey")); | |
285 | grid->SetCellTextColour(3, 3, *wxGREEN); | |
286 | grid->SetCellBackgroundColour(3, 3, *wxLIGHT_GREY); | |
287 | ||
288 | grid->SetCellValue(4, 4, _T("a weird looking cell")); | |
289 | grid->SetCellAlignment(4, 4, wxALIGN_CENTRE, wxALIGN_CENTRE); | |
290 | grid->SetCellRenderer(4, 4, new MyGridCellRenderer); | |
291 | ||
292 | grid->SetCellValue(3, 0, _T("0")); | |
293 | grid->SetCellRenderer(3, 0, new wxGridCellBoolRenderer); | |
294 | grid->SetCellEditor(3, 0, new wxGridCellBoolEditor); | |
295 | ||
296 | wxGridCellAttr *attr; | |
297 | attr = new wxGridCellAttr; | |
298 | attr->SetTextColour(*wxBLUE); | |
299 | grid->SetColAttr(5, attr); | |
300 | attr = new wxGridCellAttr; | |
301 | attr->SetBackgroundColour(*wxRED); | |
302 | grid->SetRowAttr(5, attr); | |
303 | ||
304 | grid->SetCellValue(2, 4, _T("a wider column")); | |
305 | grid->SetColSize(4, 120); | |
306 | grid->SetColMinimalWidth(4, 120); | |
307 | ||
308 | grid->SetCellTextColour(5, 8, *wxGREEN); | |
309 | grid->SetCellValue(5, 8, _T("Bg from row attr\nText col from cell attr")); | |
310 | grid->SetCellValue(5, 5, _T("Bg from row attr Text col from col attr and this text is so long that it covers over many many empty cells but is broken by one that isn't")); | |
311 | ||
312 | grid->SetColFormatFloat(6); | |
313 | grid->SetCellValue(0, 6, _T("3.1415")); | |
314 | grid->SetCellValue(1, 6, _T("1415")); | |
315 | grid->SetCellValue(2, 6, _T("12345.67890")); | |
316 | ||
317 | grid->SetColFormatFloat(7, 6, 2); | |
318 | grid->SetCellValue(0, 7, _T("3.1415")); | |
319 | grid->SetCellValue(1, 7, _T("1415")); | |
320 | grid->SetCellValue(2, 7, _T("12345.67890")); | |
321 | ||
322 | const wxString choices[] = | |
323 | { | |
324 | _T("Please select a choice"), | |
325 | _T("This takes two cells"), | |
326 | _T("Another choice"), | |
327 | }; | |
328 | grid->SetCellEditor(4, 0, new wxGridCellChoiceEditor(WXSIZEOF(choices), choices)); | |
329 | grid->SetCellSize(4, 0, 1, 2); | |
330 | grid->SetCellValue(4, 0, choices[0]); | |
331 | grid->SetCellOverflow(4, 0, FALSE); | |
332 | ||
333 | grid->SetCellSize(7, 1, 3, 4); | |
334 | grid->SetCellAlignment(7, 1, wxALIGN_CENTRE, wxALIGN_CENTRE); | |
335 | grid->SetCellValue(7, 1, _T("Big box!")); | |
336 | ||
337 | wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL ); | |
338 | topSizer->Add( grid, | |
339 | 1, | |
340 | wxEXPAND ); | |
341 | ||
342 | topSizer->Add( logWin, | |
343 | 0, | |
344 | wxEXPAND ); | |
345 | ||
346 | SetAutoLayout( TRUE ); | |
347 | SetSizer( topSizer ); | |
348 | ||
349 | topSizer->Fit( this ); | |
350 | topSizer->SetSizeHints( this ); | |
351 | ||
352 | Centre(); | |
353 | SetDefaults(); | |
354 | } | |
355 | ||
356 | ||
357 | GridFrame::~GridFrame() | |
358 | { | |
359 | delete wxLog::SetActiveTarget(m_logOld); | |
360 | } | |
361 | ||
362 | ||
363 | void GridFrame::SetDefaults() | |
364 | { | |
365 | GetMenuBar()->Check( ID_TOGGLEROWLABELS, TRUE ); | |
366 | GetMenuBar()->Check( ID_TOGGLECOLLABELS, TRUE ); | |
367 | GetMenuBar()->Check( ID_TOGGLEEDIT, TRUE ); | |
368 | GetMenuBar()->Check( ID_TOGGLEROWSIZING, TRUE ); | |
369 | GetMenuBar()->Check( ID_TOGGLECOLSIZING, TRUE ); | |
370 | GetMenuBar()->Check( ID_TOGGLEGRIDSIZING, TRUE ); | |
371 | GetMenuBar()->Check( ID_TOGGLEGRIDLINES, TRUE ); | |
372 | GetMenuBar()->Check( ID_CELLOVERFLOW, TRUE ); | |
373 | } | |
374 | ||
375 | ||
376 | void GridFrame::ToggleRowLabels( wxCommandEvent& WXUNUSED(ev) ) | |
377 | { | |
378 | if ( GetMenuBar()->IsChecked( ID_TOGGLEROWLABELS ) ) | |
379 | { | |
380 | grid->SetRowLabelSize( grid->GetDefaultRowLabelSize() ); | |
381 | } | |
382 | else | |
383 | { | |
384 | grid->SetRowLabelSize( 0 ); | |
385 | } | |
386 | } | |
387 | ||
388 | ||
389 | void GridFrame::ToggleColLabels( wxCommandEvent& WXUNUSED(ev) ) | |
390 | { | |
391 | if ( GetMenuBar()->IsChecked( ID_TOGGLECOLLABELS ) ) | |
392 | { | |
393 | grid->SetColLabelSize( grid->GetDefaultColLabelSize() ); | |
394 | } | |
395 | else | |
396 | { | |
397 | grid->SetColLabelSize( 0 ); | |
398 | } | |
399 | } | |
400 | ||
401 | ||
402 | void GridFrame::ToggleEditing( wxCommandEvent& WXUNUSED(ev) ) | |
403 | { | |
404 | grid->EnableEditing( | |
405 | GetMenuBar()->IsChecked( ID_TOGGLEEDIT ) ); | |
406 | } | |
407 | ||
408 | ||
409 | void GridFrame::ToggleRowSizing( wxCommandEvent& WXUNUSED(ev) ) | |
410 | { | |
411 | grid->EnableDragRowSize( | |
412 | GetMenuBar()->IsChecked( ID_TOGGLEROWSIZING ) ); | |
413 | } | |
414 | ||
415 | ||
416 | void GridFrame::ToggleColSizing( wxCommandEvent& WXUNUSED(ev) ) | |
417 | { | |
418 | grid->EnableDragColSize( | |
419 | GetMenuBar()->IsChecked( ID_TOGGLECOLSIZING ) ); | |
420 | } | |
421 | ||
422 | void GridFrame::ToggleGridSizing( wxCommandEvent& WXUNUSED(ev) ) | |
423 | { | |
424 | grid->EnableDragGridSize( | |
425 | GetMenuBar()->IsChecked( ID_TOGGLEGRIDSIZING ) ); | |
426 | } | |
427 | ||
428 | ||
429 | void GridFrame::ToggleGridLines( wxCommandEvent& WXUNUSED(ev) ) | |
430 | { | |
431 | grid->EnableGridLines( | |
432 | GetMenuBar()->IsChecked( ID_TOGGLEGRIDLINES ) ); | |
433 | } | |
434 | ||
435 | void GridFrame::OnSetHighlightWidth( wxCommandEvent& WXUNUSED(ev) ) | |
436 | { | |
437 | wxString choices[] = { _T("0"), _T("1"), _T("2"), _T("3"), _T("4"), _T("5"), _T("6"), _T("7"), _T("8"), _T("9"), _T("10")}; | |
438 | ||
439 | wxSingleChoiceDialog dlg(this, _T("Choose the thickness of the highlight pen:"), | |
440 | _T("Pen Width"), 11, choices); | |
441 | ||
442 | int current = grid->GetCellHighlightPenWidth(); | |
443 | dlg.SetSelection(current); | |
444 | if (dlg.ShowModal() == wxID_OK) { | |
445 | grid->SetCellHighlightPenWidth(dlg.GetSelection()); | |
446 | } | |
447 | } | |
448 | ||
449 | void GridFrame::OnSetROHighlightWidth( wxCommandEvent& WXUNUSED(ev) ) | |
450 | { | |
451 | wxString choices[] = { _T("0"), _T("1"), _T("2"), _T("3"), _T("4"), _T("5"), _T("6"), _T("7"), _T("8"), _T("9"), _T("10")}; | |
452 | ||
453 | wxSingleChoiceDialog dlg(this, _T("Choose the thickness of the highlight pen:"), | |
454 | _T("Pen Width"), 11, choices); | |
455 | ||
456 | int current = grid->GetCellHighlightROPenWidth(); | |
457 | dlg.SetSelection(current); | |
458 | if (dlg.ShowModal() == wxID_OK) { | |
459 | grid->SetCellHighlightROPenWidth(dlg.GetSelection()); | |
460 | } | |
461 | } | |
462 | ||
463 | ||
464 | ||
465 | void GridFrame::AutoSizeCols( wxCommandEvent& WXUNUSED(ev) ) | |
466 | { | |
467 | grid->AutoSizeColumns(); | |
468 | grid->Refresh(); | |
469 | } | |
470 | ||
471 | void GridFrame::CellOverflow( wxCommandEvent& ev ) | |
472 | { | |
473 | grid->SetDefaultCellOverflow(ev.IsChecked()); | |
474 | grid->Refresh(); | |
475 | } | |
476 | ||
477 | void GridFrame::ResizeCell( wxCommandEvent& ev ) | |
478 | { | |
479 | if (ev.IsChecked()) | |
480 | grid->SetCellSize( 7, 1, 5, 5 ); | |
481 | else | |
482 | grid->SetCellSize( 7, 1, 1, 5 ); | |
483 | grid->Refresh(); | |
484 | } | |
485 | ||
486 | void GridFrame::SetLabelColour( wxCommandEvent& WXUNUSED(ev) ) | |
487 | { | |
488 | wxColourDialog dlg( NULL ); | |
489 | if ( dlg.ShowModal() == wxID_OK ) | |
490 | { | |
491 | wxColourData retData; | |
492 | retData = dlg.GetColourData(); | |
493 | wxColour colour = retData.GetColour(); | |
494 | ||
495 | grid->SetLabelBackgroundColour( colour ); | |
496 | } | |
497 | } | |
498 | ||
499 | ||
500 | void GridFrame::SetLabelTextColour( wxCommandEvent& WXUNUSED(ev) ) | |
501 | { | |
502 | wxColourDialog dlg( NULL ); | |
503 | if ( dlg.ShowModal() == wxID_OK ) | |
504 | { | |
505 | wxColourData retData; | |
506 | retData = dlg.GetColourData(); | |
507 | wxColour colour = retData.GetColour(); | |
508 | ||
509 | grid->SetLabelTextColour( colour ); | |
510 | } | |
511 | } | |
512 | ||
513 | void GridFrame::SetLabelFont( wxCommandEvent& WXUNUSED(ev) ) | |
514 | { | |
515 | wxFont font = wxGetFontFromUser(this); | |
516 | if ( font.Ok() ) | |
517 | { | |
518 | grid->SetLabelFont(font); | |
519 | } | |
520 | } | |
521 | ||
522 | void GridFrame::SetRowLabelHorizAlignment( wxCommandEvent& WXUNUSED(ev) ) | |
523 | { | |
524 | int horiz, vert; | |
525 | grid->GetRowLabelAlignment( &horiz, &vert ); | |
526 | ||
527 | switch ( horiz ) | |
528 | { | |
529 | case wxALIGN_LEFT: | |
530 | horiz = wxALIGN_CENTRE; | |
531 | break; | |
532 | ||
533 | case wxALIGN_CENTRE: | |
534 | horiz = wxALIGN_RIGHT; | |
535 | break; | |
536 | ||
537 | case wxALIGN_RIGHT: | |
538 | horiz = wxALIGN_LEFT; | |
539 | break; | |
540 | } | |
541 | ||
542 | grid->SetRowLabelAlignment( horiz, -1 ); | |
543 | } | |
544 | ||
545 | void GridFrame::SetRowLabelVertAlignment( wxCommandEvent& WXUNUSED(ev) ) | |
546 | { | |
547 | int horiz, vert; | |
548 | grid->GetRowLabelAlignment( &horiz, &vert ); | |
549 | ||
550 | switch ( vert ) | |
551 | { | |
552 | case wxALIGN_TOP: | |
553 | vert = wxALIGN_CENTRE; | |
554 | break; | |
555 | ||
556 | case wxALIGN_CENTRE: | |
557 | vert = wxALIGN_BOTTOM; | |
558 | break; | |
559 | ||
560 | case wxALIGN_BOTTOM: | |
561 | vert = wxALIGN_TOP; | |
562 | break; | |
563 | } | |
564 | ||
565 | grid->SetRowLabelAlignment( -1, vert ); | |
566 | } | |
567 | ||
568 | ||
569 | void GridFrame::SetColLabelHorizAlignment( wxCommandEvent& WXUNUSED(ev) ) | |
570 | { | |
571 | int horiz, vert; | |
572 | grid->GetColLabelAlignment( &horiz, &vert ); | |
573 | ||
574 | switch ( horiz ) | |
575 | { | |
576 | case wxALIGN_LEFT: | |
577 | horiz = wxALIGN_CENTRE; | |
578 | break; | |
579 | ||
580 | case wxALIGN_CENTRE: | |
581 | horiz = wxALIGN_RIGHT; | |
582 | break; | |
583 | ||
584 | case wxALIGN_RIGHT: | |
585 | horiz = wxALIGN_LEFT; | |
586 | break; | |
587 | } | |
588 | ||
589 | grid->SetColLabelAlignment( horiz, -1 ); | |
590 | } | |
591 | ||
592 | ||
593 | void GridFrame::SetColLabelVertAlignment( wxCommandEvent& WXUNUSED(ev) ) | |
594 | { | |
595 | int horiz, vert; | |
596 | grid->GetColLabelAlignment( &horiz, &vert ); | |
597 | ||
598 | switch ( vert ) | |
599 | { | |
600 | case wxALIGN_TOP: | |
601 | vert = wxALIGN_CENTRE; | |
602 | break; | |
603 | ||
604 | case wxALIGN_CENTRE: | |
605 | vert = wxALIGN_BOTTOM; | |
606 | break; | |
607 | ||
608 | case wxALIGN_BOTTOM: | |
609 | vert = wxALIGN_TOP; | |
610 | break; | |
611 | } | |
612 | ||
613 | grid->SetColLabelAlignment( -1, vert ); | |
614 | } | |
615 | ||
616 | ||
617 | void GridFrame::SetGridLineColour( wxCommandEvent& WXUNUSED(ev) ) | |
618 | { | |
619 | wxColourDialog dlg( NULL ); | |
620 | if ( dlg.ShowModal() == wxID_OK ) | |
621 | { | |
622 | wxColourData retData; | |
623 | retData = dlg.GetColourData(); | |
624 | wxColour colour = retData.GetColour(); | |
625 | ||
626 | grid->SetGridLineColour( colour ); | |
627 | } | |
628 | } | |
629 | ||
630 | ||
631 | void GridFrame::InsertRow( wxCommandEvent& WXUNUSED(ev) ) | |
632 | { | |
633 | grid->InsertRows( grid->GetGridCursorRow(), 1 ); | |
634 | } | |
635 | ||
636 | ||
637 | void GridFrame::InsertCol( wxCommandEvent& WXUNUSED(ev) ) | |
638 | { | |
639 | grid->InsertCols( grid->GetGridCursorCol(), 1 ); | |
640 | } | |
641 | ||
642 | ||
643 | void GridFrame::DeleteSelectedRows( wxCommandEvent& WXUNUSED(ev) ) | |
644 | { | |
645 | if ( grid->IsSelection() ) | |
646 | { | |
647 | grid->BeginBatch(); | |
648 | for ( int n = 0; n < grid->GetNumberRows(); ) | |
649 | if ( grid->IsInSelection( n , 0 ) ) | |
650 | grid->DeleteRows( n, 1 ); | |
651 | else | |
652 | n++; | |
653 | grid->EndBatch(); | |
654 | } | |
655 | } | |
656 | ||
657 | ||
658 | void GridFrame::DeleteSelectedCols( wxCommandEvent& WXUNUSED(ev) ) | |
659 | { | |
660 | if ( grid->IsSelection() ) | |
661 | { | |
662 | grid->BeginBatch(); | |
663 | for ( int n = 0; n < grid->GetNumberCols(); ) | |
664 | if ( grid->IsInSelection( 0 , n ) ) | |
665 | grid->DeleteCols( n, 1 ); | |
666 | else | |
667 | n++; | |
668 | grid->EndBatch(); | |
669 | } | |
670 | } | |
671 | ||
672 | ||
673 | void GridFrame::ClearGrid( wxCommandEvent& WXUNUSED(ev) ) | |
674 | { | |
675 | grid->ClearGrid(); | |
676 | } | |
677 | ||
678 | void GridFrame::SelectCells( wxCommandEvent& WXUNUSED(ev) ) | |
679 | { | |
680 | grid->SetSelectionMode( wxGrid::wxGridSelectCells ); | |
681 | } | |
682 | ||
683 | void GridFrame::SelectRows( wxCommandEvent& WXUNUSED(ev) ) | |
684 | { | |
685 | grid->SetSelectionMode( wxGrid::wxGridSelectRows ); | |
686 | } | |
687 | ||
688 | void GridFrame::SelectCols( wxCommandEvent& WXUNUSED(ev) ) | |
689 | { | |
690 | grid->SetSelectionMode( wxGrid::wxGridSelectColumns ); | |
691 | } | |
692 | ||
693 | void GridFrame::SetCellFgColour( wxCommandEvent& WXUNUSED(ev) ) | |
694 | { | |
695 | wxColour col = wxGetColourFromUser(this); | |
696 | if ( col.Ok() ) | |
697 | { | |
698 | grid->SetDefaultCellTextColour(col); | |
699 | grid->Refresh(); | |
700 | } | |
701 | } | |
702 | ||
703 | void GridFrame::SetCellBgColour( wxCommandEvent& WXUNUSED(ev) ) | |
704 | { | |
705 | wxColour col = wxGetColourFromUser(this); | |
706 | if ( col.Ok() ) | |
707 | { | |
708 | // Check the new Refresh function by passing it a rectangle | |
709 | // which exactly fits the grid. | |
710 | wxRect r(wxPoint(0, 0), grid->GetSize()); | |
711 | grid->SetDefaultCellBackgroundColour(col); | |
712 | grid->Refresh(TRUE, &r); | |
713 | } | |
714 | } | |
715 | ||
716 | void GridFrame::DeselectCell(wxCommandEvent& WXUNUSED(event)) | |
717 | { | |
718 | grid->DeselectCell(3, 1); | |
719 | } | |
720 | ||
721 | void GridFrame::DeselectCol(wxCommandEvent& WXUNUSED(event)) | |
722 | { | |
723 | grid->DeselectCol(2); | |
724 | } | |
725 | ||
726 | void GridFrame::DeselectRow(wxCommandEvent& WXUNUSED(event)) | |
727 | { | |
728 | grid->DeselectRow(2); | |
729 | } | |
730 | ||
731 | void GridFrame::DeselectAll(wxCommandEvent& WXUNUSED(event)) | |
732 | { | |
733 | grid->ClearSelection(); | |
734 | } | |
735 | ||
736 | void GridFrame::SelectCell(wxCommandEvent& WXUNUSED(event)) | |
737 | { | |
738 | grid->SelectBlock(3, 1, 3, 1, m_addToSel); | |
739 | } | |
740 | ||
741 | void GridFrame::SelectCol(wxCommandEvent& WXUNUSED(event)) | |
742 | { | |
743 | grid->SelectCol(2, m_addToSel); | |
744 | } | |
745 | ||
746 | void GridFrame::SelectRow(wxCommandEvent& WXUNUSED(event)) | |
747 | { | |
748 | grid->SelectRow(2, m_addToSel); | |
749 | } | |
750 | ||
751 | void GridFrame::SelectAll(wxCommandEvent& WXUNUSED(event)) | |
752 | { | |
753 | grid->SelectAll(); | |
754 | } | |
755 | ||
756 | void GridFrame::OnAddToSelectToggle(wxCommandEvent& event) | |
757 | { | |
758 | m_addToSel = event.IsChecked(); | |
759 | } | |
760 | ||
761 | void GridFrame::OnLabelLeftClick( wxGridEvent& ev ) | |
762 | { | |
763 | logBuf = _T(""); | |
764 | if ( ev.GetRow() != -1 ) | |
765 | { | |
766 | logBuf << _T("Left click on row label ") << ev.GetRow(); | |
767 | } | |
768 | else if ( ev.GetCol() != -1 ) | |
769 | { | |
770 | logBuf << _T("Left click on col label ") << ev.GetCol(); | |
771 | } | |
772 | else | |
773 | { | |
774 | logBuf << _T("Left click on corner label"); | |
775 | } | |
776 | ||
777 | if ( ev.ShiftDown() ) logBuf << _T(" (shift down)"); | |
778 | if ( ev.ControlDown() ) logBuf << _T(" (control down)"); | |
779 | wxLogMessage( wxT("%s"), logBuf.c_str() ); | |
780 | ||
781 | // you must call event skip if you want default grid processing | |
782 | // | |
783 | ev.Skip(); | |
784 | } | |
785 | ||
786 | ||
787 | void GridFrame::OnCellLeftClick( wxGridEvent& ev ) | |
788 | { | |
789 | logBuf = _T(""); | |
790 | logBuf << _T("Left click at row ") << ev.GetRow() | |
791 | << _T(" col ") << ev.GetCol(); | |
792 | wxLogMessage( wxT("%s"), logBuf.c_str() ); | |
793 | ||
794 | // you must call event skip if you want default grid processing | |
795 | // (cell highlighting etc.) | |
796 | // | |
797 | ev.Skip(); | |
798 | } | |
799 | ||
800 | ||
801 | void GridFrame::OnRowSize( wxGridSizeEvent& ev ) | |
802 | { | |
803 | logBuf = _T(""); | |
804 | logBuf << _T("Resized row ") << ev.GetRowOrCol(); | |
805 | wxLogMessage( wxT("%s"), logBuf.c_str() ); | |
806 | ||
807 | ev.Skip(); | |
808 | } | |
809 | ||
810 | ||
811 | void GridFrame::OnColSize( wxGridSizeEvent& ev ) | |
812 | { | |
813 | logBuf = _T(""); | |
814 | logBuf << _T("Resized col ") << ev.GetRowOrCol(); | |
815 | wxLogMessage( wxT("%s"), logBuf.c_str() ); | |
816 | ||
817 | ev.Skip(); | |
818 | } | |
819 | ||
820 | ||
821 | void GridFrame::OnSelectCell( wxGridEvent& ev ) | |
822 | { | |
823 | logBuf = _T(""); | |
824 | if ( ev.Selecting() ) | |
825 | logBuf << _T("Selected "); | |
826 | else | |
827 | logBuf << _T("Deselected "); | |
828 | logBuf << _T("cell at row ") << ev.GetRow() | |
829 | << _T(" col ") << ev.GetCol() | |
830 | << _T(" ( ControlDown: ")<< (ev.ControlDown() ? 'T':'F') | |
831 | << _T(", ShiftDown: ")<< (ev.ShiftDown() ? 'T':'F') | |
832 | << _T(", AltDown: ")<< (ev.AltDown() ? 'T':'F') | |
833 | << _T(", MetaDown: ")<< (ev.MetaDown() ? 'T':'F') << _T(" )"); | |
834 | wxLogMessage( wxT("%s"), logBuf.c_str() ); | |
835 | ||
836 | // you must call Skip() if you want the default processing | |
837 | // to occur in wxGrid | |
838 | ev.Skip(); | |
839 | } | |
840 | ||
841 | void GridFrame::OnRangeSelected( wxGridRangeSelectEvent& ev ) | |
842 | { | |
843 | logBuf = _T(""); | |
844 | if ( ev.Selecting() ) | |
845 | logBuf << _T("Selected "); | |
846 | else | |
847 | logBuf << _T("Deselected "); | |
848 | logBuf << _T("cells from row ") << ev.GetTopRow() | |
849 | << _T(" col ") << ev.GetLeftCol() | |
850 | << _T(" to row ") << ev.GetBottomRow() | |
851 | << _T(" col ") << ev.GetRightCol() | |
852 | << _T(" ( ControlDown: ")<< (ev.ControlDown() ? 'T':'F') | |
853 | << _T(", ShiftDown: ")<< (ev.ShiftDown() ? 'T':'F') | |
854 | << _T(", AltDown: ")<< (ev.AltDown() ? 'T':'F') | |
855 | << _T(", MetaDown: ")<< (ev.MetaDown() ? 'T':'F') << _T(" )"); | |
856 | wxLogMessage( wxT("%s"), logBuf.c_str() ); | |
857 | ||
858 | ev.Skip(); | |
859 | } | |
860 | ||
861 | void GridFrame::OnCellValueChanged( wxGridEvent& ev ) | |
862 | { | |
863 | logBuf = _T(""); | |
864 | logBuf << _T("Value changed for cell at") | |
865 | << _T(" row ") << ev.GetRow() | |
866 | << _T(" col ") << ev.GetCol(); | |
867 | ||
868 | wxLogMessage( wxT("%s"), logBuf.c_str() ); | |
869 | ||
870 | ev.Skip(); | |
871 | } | |
872 | ||
873 | void GridFrame::OnEditorShown( wxGridEvent& ev ) | |
874 | { | |
875 | ||
876 | if ( (ev.GetCol() == 4) && | |
877 | (ev.GetRow() == 0) && | |
878 | (wxMessageBox(_T("Are you sure you wish to edit this cell"), | |
879 | _T("Checking"),wxYES_NO) == wxNO ) ) { | |
880 | ||
881 | ev.Veto(); | |
882 | return; | |
883 | } | |
884 | ||
885 | wxLogMessage( wxT("Cell editor shown.") ); | |
886 | ||
887 | ev.Skip(); | |
888 | } | |
889 | ||
890 | void GridFrame::OnEditorHidden( wxGridEvent& ev ) | |
891 | { | |
892 | ||
893 | if ( (ev.GetCol() == 4) && | |
894 | (ev.GetRow() == 0) && | |
895 | (wxMessageBox(_T("Are you sure you wish to finish editing this cell"), | |
896 | _T("Checking"),wxYES_NO) == wxNO ) ) { | |
897 | ||
898 | ev.Veto(); | |
899 | return; | |
900 | } | |
901 | ||
902 | wxLogMessage( wxT("Cell editor hidden.") ); | |
903 | ||
904 | ev.Skip(); | |
905 | } | |
906 | ||
907 | void GridFrame::About( wxCommandEvent& WXUNUSED(ev) ) | |
908 | { | |
909 | (void)wxMessageBox( _T("\n\nwxGrid demo \n\n") | |
910 | _T("Michael Bedward \n") | |
911 | _T("mbedward@ozemail.com.au \n\n"), | |
912 | _T("About"), | |
913 | wxOK ); | |
914 | } | |
915 | ||
916 | ||
917 | void GridFrame::OnQuit( wxCommandEvent& WXUNUSED(ev) ) | |
918 | { | |
919 | Close( TRUE ); | |
920 | } | |
921 | ||
922 | void GridFrame::OnBugsTable(wxCommandEvent& ) | |
923 | { | |
924 | BugsGridFrame *frame = new BugsGridFrame; | |
925 | frame->Show(TRUE); | |
926 | } | |
927 | ||
928 | void GridFrame::OnSmallGrid(wxCommandEvent& ) | |
929 | { | |
930 | wxFrame* frame = new wxFrame(NULL, -1, _T("A Small Grid"), | |
931 | wxDefaultPosition, wxSize(640, 480)); | |
932 | wxPanel* panel = new wxPanel(frame, -1); | |
933 | wxGrid* grid = new wxGrid(panel, -1, wxPoint(10,10), wxSize(400,400), | |
934 | wxWANTS_CHARS | wxSIMPLE_BORDER); | |
935 | grid->CreateGrid(3,3); | |
936 | frame->Show(TRUE); | |
937 | } | |
938 | ||
939 | void GridFrame::OnVTable(wxCommandEvent& ) | |
940 | { | |
941 | static long s_sizeGrid = 10000; | |
942 | ||
943 | #ifdef __WXMOTIF__ | |
944 | // MB: wxGetNumberFromUser doesn't work properly for wxMotif | |
945 | wxString s; | |
946 | s << s_sizeGrid; | |
947 | s = wxGetTextFromUser( _T("Size of the table to create"), | |
948 | _T("Size:"), | |
949 | s ); | |
950 | ||
951 | s.ToLong( &s_sizeGrid ); | |
952 | ||
953 | #else | |
954 | s_sizeGrid = wxGetNumberFromUser(_T("Size of the table to create"), | |
955 | _T("Size: "), | |
956 | _T("wxGridDemo question"), | |
957 | s_sizeGrid, | |
958 | 0, 32000, this); | |
959 | #endif | |
960 | ||
961 | if ( s_sizeGrid != -1 ) | |
962 | { | |
963 | BigGridFrame* win = new BigGridFrame(s_sizeGrid); | |
964 | win->Show(TRUE); | |
965 | } | |
966 | } | |
967 | ||
968 | // ---------------------------------------------------------------------------- | |
969 | // MyGridCellRenderer | |
970 | // ---------------------------------------------------------------------------- | |
971 | ||
972 | // do something that the default renderer doesn't here just to show that it is | |
973 | // possible to alter the appearance of the cell beyond what the attributes | |
974 | // allow | |
975 | void MyGridCellRenderer::Draw(wxGrid& grid, | |
976 | wxGridCellAttr& attr, | |
977 | wxDC& dc, | |
978 | const wxRect& rect, | |
979 | int row, int col, | |
980 | bool isSelected) | |
981 | { | |
982 | wxGridCellStringRenderer::Draw(grid, attr, dc, rect, row, col, isSelected); | |
983 | ||
984 | dc.SetPen(*wxGREEN_PEN); | |
985 | dc.SetBrush(*wxTRANSPARENT_BRUSH); | |
986 | dc.DrawEllipse(rect); | |
987 | } | |
988 | ||
989 | // ---------------------------------------------------------------------------- | |
990 | // MyGridCellAttrProvider | |
991 | // ---------------------------------------------------------------------------- | |
992 | ||
993 | MyGridCellAttrProvider::MyGridCellAttrProvider() | |
994 | { | |
995 | m_attrForOddRows = new wxGridCellAttr; | |
996 | m_attrForOddRows->SetBackgroundColour(*wxLIGHT_GREY); | |
997 | } | |
998 | ||
999 | MyGridCellAttrProvider::~MyGridCellAttrProvider() | |
1000 | { | |
1001 | m_attrForOddRows->DecRef(); | |
1002 | } | |
1003 | ||
1004 | wxGridCellAttr *MyGridCellAttrProvider::GetAttr(int row, int col, | |
1005 | wxGridCellAttr::wxAttrKind kind /* = wxGridCellAttr::Any */) const | |
1006 | { | |
1007 | wxGridCellAttr *attr = wxGridCellAttrProvider::GetAttr(row, col, kind); | |
1008 | ||
1009 | if ( row % 2 ) | |
1010 | { | |
1011 | if ( !attr ) | |
1012 | { | |
1013 | attr = m_attrForOddRows; | |
1014 | attr->IncRef(); | |
1015 | } | |
1016 | else | |
1017 | { | |
1018 | if ( !attr->HasBackgroundColour() ) | |
1019 | { | |
1020 | wxGridCellAttr *attrNew = attr->Clone(); | |
1021 | attr->DecRef(); | |
1022 | attr = attrNew; | |
1023 | attr->SetBackgroundColour(*wxLIGHT_GREY); | |
1024 | } | |
1025 | } | |
1026 | } | |
1027 | ||
1028 | return attr; | |
1029 | } | |
1030 | ||
1031 | // ============================================================================ | |
1032 | // BigGridFrame and BigGridTable: Sample of a non-standard table | |
1033 | // ============================================================================ | |
1034 | ||
1035 | BigGridFrame::BigGridFrame(long sizeGrid) | |
1036 | : wxFrame(NULL, -1, _T("Plugin Virtual Table"), | |
1037 | wxDefaultPosition, wxSize(500, 450)) | |
1038 | { | |
1039 | m_grid = new wxGrid(this, -1, wxDefaultPosition, wxDefaultSize); | |
1040 | m_table = new BigGridTable(sizeGrid); | |
1041 | ||
1042 | // VZ: I don't understand why this slows down the display that much, | |
1043 | // must profile it... | |
1044 | //m_table->SetAttrProvider(new MyGridCellAttrProvider); | |
1045 | ||
1046 | m_grid->SetTable(m_table, TRUE); | |
1047 | ||
1048 | #if defined __WXMOTIF__ | |
1049 | // MB: the grid isn't getting a sensible default size under wxMotif | |
1050 | int cw, ch; | |
1051 | GetClientSize( &cw, &ch ); | |
1052 | m_grid->SetSize( cw, ch ); | |
1053 | #endif | |
1054 | } | |
1055 | ||
1056 | // ============================================================================ | |
1057 | // BugsGridFrame: a "realistic" table | |
1058 | // ============================================================================ | |
1059 | ||
1060 | // ---------------------------------------------------------------------------- | |
1061 | // bugs table data | |
1062 | // ---------------------------------------------------------------------------- | |
1063 | ||
1064 | enum Columns | |
1065 | { | |
1066 | Col_Id, | |
1067 | Col_Summary, | |
1068 | Col_Severity, | |
1069 | Col_Priority, | |
1070 | Col_Platform, | |
1071 | Col_Opened, | |
1072 | Col_Max | |
1073 | }; | |
1074 | ||
1075 | enum Severity | |
1076 | { | |
1077 | Sev_Wish, | |
1078 | Sev_Minor, | |
1079 | Sev_Normal, | |
1080 | Sev_Major, | |
1081 | Sev_Critical, | |
1082 | Sev_Max | |
1083 | }; | |
1084 | ||
1085 | static const wxString severities[] = | |
1086 | { | |
1087 | _T("wishlist"), | |
1088 | _T("minor"), | |
1089 | _T("normal"), | |
1090 | _T("major"), | |
1091 | _T("critical"), | |
1092 | }; | |
1093 | ||
1094 | static struct BugsGridData | |
1095 | { | |
1096 | int id; | |
1097 | wxChar summary[80]; | |
1098 | Severity severity; | |
1099 | int prio; | |
1100 | wxChar platform[12]; | |
1101 | bool opened; | |
1102 | } gs_dataBugsGrid [] = | |
1103 | { | |
1104 | { 18, _T("foo doesn't work"), Sev_Major, 1, _T("wxMSW"), TRUE }, | |
1105 | { 27, _T("bar crashes"), Sev_Critical, 1, _T("all"), FALSE }, | |
1106 | { 45, _T("printing is slow"), Sev_Minor, 3, _T("wxMSW"), TRUE }, | |
1107 | { 68, _T("Rectangle() fails"), Sev_Normal, 1, _T("wxMSW"), FALSE }, | |
1108 | }; | |
1109 | ||
1110 | static const wxChar *headers[Col_Max] = | |
1111 | { | |
1112 | _T("Id"), | |
1113 | _T("Summary"), | |
1114 | _T("Severity"), | |
1115 | _T("Priority"), | |
1116 | _T("Platform"), | |
1117 | _T("Opened?"), | |
1118 | }; | |
1119 | ||
1120 | // ---------------------------------------------------------------------------- | |
1121 | // BugsGridTable | |
1122 | // ---------------------------------------------------------------------------- | |
1123 | ||
1124 | wxString BugsGridTable::GetTypeName(int WXUNUSED(row), int col) | |
1125 | { | |
1126 | switch ( col ) | |
1127 | { | |
1128 | case Col_Id: | |
1129 | case Col_Priority: | |
1130 | return wxGRID_VALUE_NUMBER;; | |
1131 | ||
1132 | case Col_Severity: | |
1133 | // fall thorugh (TODO should be a list) | |
1134 | ||
1135 | case Col_Summary: | |
1136 | return wxString::Format(_T("%s:80"), wxGRID_VALUE_STRING); | |
1137 | ||
1138 | case Col_Platform: | |
1139 | return wxString::Format(_T("%s:all,MSW,GTK,other"), wxGRID_VALUE_CHOICE); | |
1140 | ||
1141 | case Col_Opened: | |
1142 | return wxGRID_VALUE_BOOL; | |
1143 | } | |
1144 | ||
1145 | wxFAIL_MSG(_T("unknown column")); | |
1146 | ||
1147 | return wxEmptyString; | |
1148 | } | |
1149 | ||
1150 | int BugsGridTable::GetNumberRows() | |
1151 | { | |
1152 | return WXSIZEOF(gs_dataBugsGrid); | |
1153 | } | |
1154 | ||
1155 | int BugsGridTable::GetNumberCols() | |
1156 | { | |
1157 | return Col_Max; | |
1158 | } | |
1159 | ||
1160 | bool BugsGridTable::IsEmptyCell( int row, int col ) | |
1161 | { | |
1162 | return FALSE; | |
1163 | } | |
1164 | ||
1165 | wxString BugsGridTable::GetValue( int row, int col ) | |
1166 | { | |
1167 | const BugsGridData& gd = gs_dataBugsGrid[row]; | |
1168 | ||
1169 | switch ( col ) | |
1170 | { | |
1171 | case Col_Id: | |
1172 | case Col_Priority: | |
1173 | case Col_Opened: | |
1174 | wxFAIL_MSG(_T("unexpected column")); | |
1175 | break; | |
1176 | ||
1177 | case Col_Severity: | |
1178 | return severities[gd.severity]; | |
1179 | ||
1180 | case Col_Summary: | |
1181 | return gd.summary; | |
1182 | ||
1183 | case Col_Platform: | |
1184 | return gd.platform; | |
1185 | } | |
1186 | ||
1187 | return wxEmptyString; | |
1188 | } | |
1189 | ||
1190 | void BugsGridTable::SetValue( int row, int col, const wxString& value ) | |
1191 | { | |
1192 | BugsGridData& gd = gs_dataBugsGrid[row]; | |
1193 | ||
1194 | switch ( col ) | |
1195 | { | |
1196 | case Col_Id: | |
1197 | case Col_Priority: | |
1198 | case Col_Opened: | |
1199 | wxFAIL_MSG(_T("unexpected column")); | |
1200 | break; | |
1201 | ||
1202 | case Col_Severity: | |
1203 | { | |
1204 | size_t n; | |
1205 | for ( n = 0; n < WXSIZEOF(severities); n++ ) | |
1206 | { | |
1207 | if ( severities[n] == value ) | |
1208 | { | |
1209 | gd.severity = (Severity)n; | |
1210 | break; | |
1211 | } | |
1212 | } | |
1213 | ||
1214 | if ( n == WXSIZEOF(severities) ) | |
1215 | { | |
1216 | wxLogWarning(_T("Invalid severity value '%s'."), | |
1217 | value.c_str()); | |
1218 | gd.severity = Sev_Normal; | |
1219 | } | |
1220 | } | |
1221 | break; | |
1222 | ||
1223 | case Col_Summary: | |
1224 | wxStrncpy(gd.summary, value, WXSIZEOF(gd.summary)); | |
1225 | break; | |
1226 | ||
1227 | case Col_Platform: | |
1228 | wxStrncpy(gd.platform, value, WXSIZEOF(gd.platform)); | |
1229 | break; | |
1230 | } | |
1231 | } | |
1232 | ||
1233 | bool BugsGridTable::CanGetValueAs( int WXUNUSED(row), int col, const wxString& typeName ) | |
1234 | { | |
1235 | if ( typeName == wxGRID_VALUE_STRING ) | |
1236 | { | |
1237 | return TRUE; | |
1238 | } | |
1239 | else if ( typeName == wxGRID_VALUE_BOOL ) | |
1240 | { | |
1241 | return col == Col_Opened; | |
1242 | } | |
1243 | else if ( typeName == wxGRID_VALUE_NUMBER ) | |
1244 | { | |
1245 | return col == Col_Id || col == Col_Priority || col == Col_Severity; | |
1246 | } | |
1247 | else | |
1248 | { | |
1249 | return FALSE; | |
1250 | } | |
1251 | } | |
1252 | ||
1253 | bool BugsGridTable::CanSetValueAs( int row, int col, const wxString& typeName ) | |
1254 | { | |
1255 | return CanGetValueAs(row, col, typeName); | |
1256 | } | |
1257 | ||
1258 | long BugsGridTable::GetValueAsLong( int row, int col ) | |
1259 | { | |
1260 | const BugsGridData& gd = gs_dataBugsGrid[row]; | |
1261 | ||
1262 | switch ( col ) | |
1263 | { | |
1264 | case Col_Id: | |
1265 | return gd.id; | |
1266 | ||
1267 | case Col_Priority: | |
1268 | return gd.prio; | |
1269 | ||
1270 | case Col_Severity: | |
1271 | return gd.severity; | |
1272 | ||
1273 | default: | |
1274 | wxFAIL_MSG(_T("unexpected column")); | |
1275 | return -1; | |
1276 | } | |
1277 | } | |
1278 | ||
1279 | bool BugsGridTable::GetValueAsBool( int row, int col ) | |
1280 | { | |
1281 | if ( col == Col_Opened ) | |
1282 | { | |
1283 | return gs_dataBugsGrid[row].opened; | |
1284 | } | |
1285 | else | |
1286 | { | |
1287 | wxFAIL_MSG(_T("unexpected column")); | |
1288 | ||
1289 | return FALSE; | |
1290 | } | |
1291 | } | |
1292 | ||
1293 | void BugsGridTable::SetValueAsLong( int row, int col, long value ) | |
1294 | { | |
1295 | BugsGridData& gd = gs_dataBugsGrid[row]; | |
1296 | ||
1297 | switch ( col ) | |
1298 | { | |
1299 | case Col_Priority: | |
1300 | gd.prio = value; | |
1301 | break; | |
1302 | ||
1303 | default: | |
1304 | wxFAIL_MSG(_T("unexpected column")); | |
1305 | } | |
1306 | } | |
1307 | ||
1308 | void BugsGridTable::SetValueAsBool( int row, int col, bool value ) | |
1309 | { | |
1310 | if ( col == Col_Opened ) | |
1311 | { | |
1312 | gs_dataBugsGrid[row].opened = value; | |
1313 | } | |
1314 | else | |
1315 | { | |
1316 | wxFAIL_MSG(_T("unexpected column")); | |
1317 | } | |
1318 | } | |
1319 | ||
1320 | wxString BugsGridTable::GetColLabelValue( int col ) | |
1321 | { | |
1322 | return headers[col]; | |
1323 | } | |
1324 | ||
1325 | BugsGridTable::BugsGridTable() | |
1326 | { | |
1327 | } | |
1328 | ||
1329 | // ---------------------------------------------------------------------------- | |
1330 | // BugsGridFrame | |
1331 | // ---------------------------------------------------------------------------- | |
1332 | ||
1333 | BugsGridFrame::BugsGridFrame() | |
1334 | : wxFrame(NULL, -1, _T("Bugs table"), | |
1335 | wxDefaultPosition, wxSize(500, 300)) | |
1336 | { | |
1337 | wxGrid *grid = new wxGrid(this, -1, wxDefaultPosition); | |
1338 | wxGridTableBase *table = new BugsGridTable(); | |
1339 | table->SetAttrProvider(new MyGridCellAttrProvider); | |
1340 | grid->SetTable(table, TRUE); | |
1341 | ||
1342 | wxGridCellAttr *attrRO = new wxGridCellAttr, | |
1343 | *attrRangeEditor = new wxGridCellAttr, | |
1344 | *attrCombo = new wxGridCellAttr; | |
1345 | ||
1346 | attrRO->SetReadOnly(); | |
1347 | attrRangeEditor->SetEditor(new wxGridCellNumberEditor(1, 5)); | |
1348 | attrCombo->SetEditor(new wxGridCellChoiceEditor(WXSIZEOF(severities), | |
1349 | severities)); | |
1350 | ||
1351 | grid->SetColAttr(Col_Id, attrRO); | |
1352 | grid->SetColAttr(Col_Priority, attrRangeEditor); | |
1353 | grid->SetColAttr(Col_Severity, attrCombo); | |
1354 | ||
1355 | grid->SetMargins(0, 0); | |
1356 | ||
1357 | grid->Fit(); | |
1358 | SetClientSize(grid->GetSize()); | |
1359 | } | |
1360 | ||
1361 |