always call SetIcon() on the main frame of the sample; some small cleanup
[wxWidgets.git] / samples / grid / griddemo.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: griddemo.cpp
3 // Purpose: Grid control wxWidgets sample
4 // Author: Michael Bedward
5 // Modified by: Santiago Palacios
6 // RCS-ID: $Id$
7 // Copyright: (c) Michael Bedward, Julian Smart, Vadim Zeitlin
8 // Licence: wxWindows license
9 /////////////////////////////////////////////////////////////////////////////
10
11 // ============================================================================
12 // declarations
13 // ============================================================================
14
15 // ----------------------------------------------------------------------------
16 // headers
17 // ----------------------------------------------------------------------------
18
19 // For compilers that support precompilation, includes "wx/wx.h".
20 #include "wx/wxprec.h"
21
22 #ifdef __BORLANDC__
23 #pragma hdrstop
24 #endif
25
26 #ifndef WX_PRECOMP
27 #include "wx/wx.h"
28 #endif
29
30 #include "wx/colordlg.h"
31 #include "wx/fontdlg.h"
32 #include "wx/numdlg.h"
33 #include "wx/aboutdlg.h"
34
35 #include "wx/grid.h"
36 #include "wx/headerctrl.h"
37 #include "wx/generic/gridctrl.h"
38 #include "wx/generic/grideditors.h"
39
40 #include "griddemo.h"
41
42 #ifndef __WXMSW__
43 #include "../sample.xpm"
44 #endif
45
46 // ----------------------------------------------------------------------------
47 // wxWin macros
48 // ----------------------------------------------------------------------------
49
50 IMPLEMENT_APP( GridApp )
51
52 // ============================================================================
53 // implementation
54 // ============================================================================
55
56 // ----------------------------------------------------------------------------
57 // GridApp
58 // ----------------------------------------------------------------------------
59
60 bool GridApp::OnInit()
61 {
62 GridFrame *frame = new GridFrame;
63 frame->Show(true);
64
65 return true;
66 }
67
68 // ----------------------------------------------------------------------------
69 // GridFrame
70 // ----------------------------------------------------------------------------
71
72 BEGIN_EVENT_TABLE( GridFrame, wxFrame )
73 EVT_MENU( ID_TOGGLEROWLABELS, GridFrame::ToggleRowLabels )
74 EVT_MENU( ID_TOGGLECOLLABELS, GridFrame::ToggleColLabels )
75 EVT_MENU( ID_TOGGLEEDIT, GridFrame::ToggleEditing )
76 EVT_MENU( ID_TOGGLEROWSIZING, GridFrame::ToggleRowSizing )
77 EVT_MENU( ID_TOGGLECOLSIZING, GridFrame::ToggleColSizing )
78 EVT_MENU( ID_TOGGLECOLMOVING, GridFrame::ToggleColMoving )
79 EVT_MENU( ID_TOGGLEGRIDSIZING, GridFrame::ToggleGridSizing )
80 EVT_MENU( ID_TOGGLEGRIDDRAGCELL, GridFrame::ToggleGridDragCell )
81 EVT_MENU( ID_TOGGLENATIVEHEADER, GridFrame::ToggleNativeHeader )
82 EVT_MENU( ID_TOGGLEGRIDLINES, GridFrame::ToggleGridLines )
83 EVT_MENU( ID_AUTOSIZECOLS, GridFrame::AutoSizeCols )
84 EVT_MENU( ID_CELLOVERFLOW, GridFrame::CellOverflow )
85 EVT_MENU( ID_RESIZECELL, GridFrame::ResizeCell )
86 EVT_MENU( ID_SETLABELCOLOUR, GridFrame::SetLabelColour )
87 EVT_MENU( ID_SETLABELTEXTCOLOUR, GridFrame::SetLabelTextColour )
88 EVT_MENU( ID_SETLABEL_FONT, GridFrame::SetLabelFont )
89 EVT_MENU( ID_ROWLABELHORIZALIGN, GridFrame::SetRowLabelHorizAlignment )
90 EVT_MENU( ID_ROWLABELVERTALIGN, GridFrame::SetRowLabelVertAlignment )
91 EVT_MENU( ID_COLLABELHORIZALIGN, GridFrame::SetColLabelHorizAlignment )
92 EVT_MENU( ID_COLLABELVERTALIGN, GridFrame::SetColLabelVertAlignment )
93 EVT_MENU( ID_GRIDLINECOLOUR, GridFrame::SetGridLineColour )
94 EVT_MENU( ID_INSERTROW, GridFrame::InsertRow )
95 EVT_MENU( ID_INSERTCOL, GridFrame::InsertCol )
96 EVT_MENU( ID_DELETEROW, GridFrame::DeleteSelectedRows )
97 EVT_MENU( ID_DELETECOL, GridFrame::DeleteSelectedCols )
98 EVT_MENU( ID_CLEARGRID, GridFrame::ClearGrid )
99 EVT_MENU( ID_SELCELLS, GridFrame::SelectCells )
100 EVT_MENU( ID_SELROWS, GridFrame::SelectRows )
101 EVT_MENU( ID_SELCOLS, GridFrame::SelectCols )
102 EVT_MENU( ID_SELROWSORCOLS, GridFrame::SelectRowsOrCols )
103
104 EVT_MENU( ID_SET_CELL_FG_COLOUR, GridFrame::SetCellFgColour )
105 EVT_MENU( ID_SET_CELL_BG_COLOUR, GridFrame::SetCellBgColour )
106
107 EVT_MENU( wxID_ABOUT, GridFrame::About )
108 EVT_MENU( wxID_EXIT, GridFrame::OnQuit )
109 EVT_MENU( ID_VTABLE, GridFrame::OnVTable)
110 EVT_MENU( ID_BUGS_TABLE, GridFrame::OnBugsTable)
111 EVT_MENU( ID_TABULAR_TABLE, GridFrame::OnTabularTable)
112
113 EVT_MENU( ID_DESELECT_CELL, GridFrame::DeselectCell)
114 EVT_MENU( ID_DESELECT_COL, GridFrame::DeselectCol)
115 EVT_MENU( ID_DESELECT_ROW, GridFrame::DeselectRow)
116 EVT_MENU( ID_DESELECT_ALL, GridFrame::DeselectAll)
117 EVT_MENU( ID_SELECT_CELL, GridFrame::SelectCell)
118 EVT_MENU( ID_SELECT_COL, GridFrame::SelectCol)
119 EVT_MENU( ID_SELECT_ROW, GridFrame::SelectRow)
120 EVT_MENU( ID_SELECT_ALL, GridFrame::SelectAll)
121 EVT_MENU( ID_SELECT_UNSELECT, GridFrame::OnAddToSelectToggle)
122 EVT_MENU( ID_SHOW_SELECTION, GridFrame::OnShowSelection)
123
124 EVT_MENU( ID_SIZE_ROW, GridFrame::AutoSizeRow )
125 EVT_MENU( ID_SIZE_COL, GridFrame::AutoSizeCol )
126 EVT_MENU( ID_SIZE_ROW_LABEL, GridFrame::AutoSizeRowLabel )
127 EVT_MENU( ID_SIZE_COL_LABEL, GridFrame::AutoSizeColLabel )
128 EVT_MENU( ID_SIZE_LABELS_COL, GridFrame::AutoSizeLabelsCol )
129 EVT_MENU( ID_SIZE_LABELS_ROW, GridFrame::AutoSizeLabelsRow )
130 EVT_MENU( ID_SIZE_GRID, GridFrame::AutoSizeTable )
131
132 EVT_MENU( ID_SET_HIGHLIGHT_WIDTH, GridFrame::OnSetHighlightWidth)
133 EVT_MENU( ID_SET_RO_HIGHLIGHT_WIDTH, GridFrame::OnSetROHighlightWidth)
134
135 EVT_GRID_LABEL_LEFT_CLICK( GridFrame::OnLabelLeftClick )
136 EVT_GRID_CELL_LEFT_CLICK( GridFrame::OnCellLeftClick )
137 EVT_GRID_ROW_SIZE( GridFrame::OnRowSize )
138 EVT_GRID_COL_SIZE( GridFrame::OnColSize )
139 EVT_GRID_SELECT_CELL( GridFrame::OnSelectCell )
140 EVT_GRID_RANGE_SELECT( GridFrame::OnRangeSelected )
141 EVT_GRID_CELL_CHANGING( GridFrame::OnCellValueChanging )
142 EVT_GRID_CELL_CHANGE( GridFrame::OnCellValueChanged )
143 EVT_GRID_CELL_BEGIN_DRAG( GridFrame::OnCellBeginDrag )
144
145 EVT_GRID_EDITOR_SHOWN( GridFrame::OnEditorShown )
146 EVT_GRID_EDITOR_HIDDEN( GridFrame::OnEditorHidden )
147 END_EVENT_TABLE()
148
149
150 GridFrame::GridFrame()
151 : wxFrame( (wxFrame *)NULL, wxID_ANY, _T("wxWidgets grid class demo"),
152 wxDefaultPosition,
153 wxDefaultSize )
154 {
155 SetIcon(wxICON(sample));
156
157 wxMenu *fileMenu = new wxMenu;
158 fileMenu->Append( ID_VTABLE, _T("&Virtual table test\tCtrl-V"));
159 fileMenu->Append( ID_BUGS_TABLE, _T("&Bugs table test\tCtrl-B"));
160 fileMenu->Append( ID_TABULAR_TABLE, _T("&Tabular table test\tCtrl-T"));
161 fileMenu->AppendSeparator();
162 fileMenu->Append( wxID_EXIT, _T("E&xit\tAlt-X") );
163
164 wxMenu *viewMenu = new wxMenu;
165 viewMenu->AppendCheckItem(ID_TOGGLEROWLABELS, "&Row labels");
166 viewMenu->AppendCheckItem(ID_TOGGLECOLLABELS, "&Col labels");
167 viewMenu->AppendCheckItem(ID_TOGGLEEDIT,"&Editable");
168 viewMenu->AppendCheckItem(ID_TOGGLEROWSIZING, "Ro&w drag-resize");
169 viewMenu->AppendCheckItem(ID_TOGGLECOLSIZING, "C&ol drag-resize");
170 viewMenu->AppendCheckItem(ID_TOGGLECOLMOVING, "Col drag-&move");
171 viewMenu->AppendCheckItem(ID_TOGGLEGRIDSIZING, "&Grid drag-resize");
172 viewMenu->AppendCheckItem(ID_TOGGLEGRIDDRAGCELL, "&Grid drag-cell");
173 viewMenu->AppendCheckItem(ID_TOGGLENATIVEHEADER, "&Native column headers");
174 viewMenu->AppendCheckItem(ID_TOGGLEGRIDLINES, "&Grid Lines");
175 viewMenu->AppendCheckItem(ID_SET_HIGHLIGHT_WIDTH, "&Set Cell Highlight Width...");
176 viewMenu->AppendCheckItem(ID_SET_RO_HIGHLIGHT_WIDTH, "&Set Cell RO Highlight Width...");
177 viewMenu->AppendCheckItem(ID_AUTOSIZECOLS, "&Auto-size cols");
178 viewMenu->AppendCheckItem(ID_CELLOVERFLOW, "&Overflow cells");
179 viewMenu->AppendCheckItem(ID_RESIZECELL, "&Resize cell (7,1)");
180
181 wxMenu *rowLabelMenu = new wxMenu;
182
183 viewMenu->Append( ID_ROWLABELALIGN, _T("R&ow label alignment"),
184 rowLabelMenu,
185 _T("Change alignment of row labels") );
186
187 rowLabelMenu->Append( ID_ROWLABELHORIZALIGN, _T("&Horizontal") );
188 rowLabelMenu->Append( ID_ROWLABELVERTALIGN, _T("&Vertical") );
189
190 wxMenu *colLabelMenu = new wxMenu;
191
192 viewMenu->Append( ID_COLLABELALIGN, _T("Col l&abel alignment"),
193 colLabelMenu,
194 _T("Change alignment of col labels") );
195
196 colLabelMenu->Append( ID_COLLABELHORIZALIGN, _T("&Horizontal") );
197 colLabelMenu->Append( ID_COLLABELVERTALIGN, _T("&Vertical") );
198
199 wxMenu *colMenu = new wxMenu;
200 colMenu->Append( ID_SETLABELCOLOUR, _T("Set &label colour...") );
201 colMenu->Append( ID_SETLABELTEXTCOLOUR, _T("Set label &text colour...") );
202 colMenu->Append( ID_SETLABEL_FONT, _T("Set label fo&nt...") );
203 colMenu->Append( ID_GRIDLINECOLOUR, _T("&Grid line colour...") );
204 colMenu->Append( ID_SET_CELL_FG_COLOUR, _T("Set cell &foreground colour...") );
205 colMenu->Append( ID_SET_CELL_BG_COLOUR, _T("Set cell &background colour...") );
206
207 wxMenu *editMenu = new wxMenu;
208 editMenu->Append( ID_INSERTROW, _T("Insert &row") );
209 editMenu->Append( ID_INSERTCOL, _T("Insert &column") );
210 editMenu->Append( ID_DELETEROW, _T("Delete selected ro&ws") );
211 editMenu->Append( ID_DELETECOL, _T("Delete selected co&ls") );
212 editMenu->Append( ID_CLEARGRID, _T("Cl&ear grid cell contents") );
213
214 wxMenu *selectMenu = new wxMenu;
215 selectMenu->Append( ID_SELECT_UNSELECT, _T("Add new cells to the selection"),
216 _T("When off, old selection is deselected before ")
217 _T("selecting the new cells"), wxITEM_CHECK );
218 selectMenu->Append( ID_SHOW_SELECTION,
219 _T("&Show current selection\tCtrl-Alt-S"));
220 selectMenu->AppendSeparator();
221 selectMenu->Append( ID_SELECT_ALL, _T("Select all"));
222 selectMenu->Append( ID_SELECT_ROW, _T("Select row 2"));
223 selectMenu->Append( ID_SELECT_COL, _T("Select col 2"));
224 selectMenu->Append( ID_SELECT_CELL, _T("Select cell (3, 1)"));
225 selectMenu->AppendSeparator();
226 selectMenu->Append( ID_DESELECT_ALL, _T("Deselect all"));
227 selectMenu->Append( ID_DESELECT_ROW, _T("Deselect row 2"));
228 selectMenu->Append( ID_DESELECT_COL, _T("Deselect col 2"));
229 selectMenu->Append( ID_DESELECT_CELL, _T("Deselect cell (3, 1)"));
230 wxMenu *selectionMenu = new wxMenu;
231 selectMenu->Append( ID_CHANGESEL, _T("Change &selection mode"),
232 selectionMenu,
233 _T("Change selection mode") );
234
235 selectionMenu->Append( ID_SELCELLS, _T("Select &cells") );
236 selectionMenu->Append( ID_SELROWS, _T("Select &rows") );
237 selectionMenu->Append( ID_SELCOLS, _T("Select col&umns") );
238 selectionMenu->Append( ID_SELROWSORCOLS, _T("Select rows &or columns") );
239
240 wxMenu *autosizeMenu = new wxMenu;
241 autosizeMenu->Append( ID_SIZE_ROW, _T("Selected &row data") );
242 autosizeMenu->Append( ID_SIZE_COL, _T("Selected &column data") );
243 autosizeMenu->Append( ID_SIZE_ROW_LABEL, _T("Selected row la&bel") );
244 autosizeMenu->Append( ID_SIZE_COL_LABEL, _T("Selected column &label") );
245 autosizeMenu->Append( ID_SIZE_LABELS_COL, _T("Column la&bels") );
246 autosizeMenu->Append( ID_SIZE_LABELS_ROW, _T("Row label&s") );
247 autosizeMenu->Append( ID_SIZE_GRID, _T("Entire &grid") );
248
249 wxMenu *helpMenu = new wxMenu;
250 helpMenu->Append( wxID_ABOUT, _T("&About wxGrid demo") );
251
252 wxMenuBar *menuBar = new wxMenuBar;
253 menuBar->Append( fileMenu, _T("&File") );
254 menuBar->Append( viewMenu, _T("&Grid") );
255 menuBar->Append( colMenu, _T("&Colours") );
256 menuBar->Append( editMenu, _T("&Edit") );
257 menuBar->Append( selectMenu, _T("&Select") );
258 menuBar->Append( autosizeMenu, _T("&Autosize") );
259 menuBar->Append( helpMenu, _T("&Help") );
260
261 SetMenuBar( menuBar );
262
263 m_addToSel = false;
264
265 grid = new wxGrid( this,
266 wxID_ANY,
267 wxPoint( 0, 0 ),
268 wxSize( 400, 300 ) );
269
270 #if wxUSE_LOG
271 int gridW = 600, gridH = 300;
272 int logW = gridW, logH = 100;
273
274 logWin = new wxTextCtrl( this,
275 wxID_ANY,
276 wxEmptyString,
277 wxPoint( 0, gridH + 20 ),
278 wxSize( logW, logH ),
279 wxTE_MULTILINE );
280
281 logger = new wxLogTextCtrl( logWin );
282 m_logOld = wxLog::SetActiveTarget( logger );
283 wxLog::DisableTimestamp();
284 #endif // wxUSE_LOG
285
286 // this will create a grid and, by default, an associated grid
287 // table for strings
288 grid->CreateGrid( 0, 0 );
289 grid->AppendRows(100);
290 grid->AppendCols(100);
291
292 int ir = grid->GetNumberRows();
293 grid->DeleteRows(0, ir);
294 grid->AppendRows(ir);
295
296 grid->SetRowSize( 0, 60 );
297 grid->SetCellValue( 0, 0, _T("Ctrl+Home\nwill go to\nthis cell") );
298
299 grid->SetCellValue( 0, 1, _T("A long piece of text to demonstrate wrapping.") );
300 grid->SetCellRenderer(0 , 1, new wxGridCellAutoWrapStringRenderer);
301 grid->SetCellEditor( 0, 1 , new wxGridCellAutoWrapStringEditor);
302
303 grid->SetCellValue( 0, 2, _T("Blah") );
304 grid->SetCellValue( 0, 3, _T("Read only") );
305 grid->SetReadOnly( 0, 3 );
306
307 grid->SetCellValue( 0, 4, _T("Can veto edit this cell") );
308
309 grid->SetCellValue( 0, 5, _T("Press\nCtrl+arrow\nto skip over\ncells") );
310
311 grid->SetRowSize( 99, 60 );
312 grid->SetCellValue( 99, 99, _T("Ctrl+End\nwill go to\nthis cell") );
313 grid->SetCellValue( 1, 0, _T("This default cell will overflow into neighboring cells, but not if you turn overflow off."));
314
315 grid->SetCellTextColour(1, 2, *wxRED);
316 grid->SetCellBackgroundColour(1, 2, *wxGREEN);
317
318 grid->SetCellValue( 1, 4, _T("I'm in the middle"));
319
320 grid->SetCellValue(2, 2, _T("red"));
321
322 grid->SetCellTextColour(2, 2, *wxRED);
323 grid->SetCellValue(3, 3, _T("green on grey"));
324 grid->SetCellTextColour(3, 3, *wxGREEN);
325 grid->SetCellBackgroundColour(3, 3, *wxLIGHT_GREY);
326
327 grid->SetCellValue(4, 4, _T("a weird looking cell"));
328 grid->SetCellAlignment(4, 4, wxALIGN_CENTRE, wxALIGN_CENTRE);
329 grid->SetCellRenderer(4, 4, new MyGridCellRenderer);
330
331 grid->SetCellRenderer(3, 0, new wxGridCellBoolRenderer);
332 grid->SetCellEditor(3, 0, new wxGridCellBoolEditor);
333
334 wxGridCellAttr *attr;
335 attr = new wxGridCellAttr;
336 attr->SetTextColour(*wxBLUE);
337 grid->SetColAttr(5, attr);
338 attr = new wxGridCellAttr;
339 attr->SetBackgroundColour(*wxRED);
340 grid->SetRowAttr(5, attr);
341
342 grid->SetCellValue(2, 4, _T("a wider column"));
343 grid->SetColSize(4, 120);
344 grid->SetColMinimalWidth(4, 120);
345
346 grid->SetCellTextColour(5, 8, *wxGREEN);
347 grid->SetCellValue(5, 8, _T("Bg from row attr\nText col from cell attr"));
348 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"));
349
350 grid->SetColFormatFloat(6);
351 grid->SetCellValue(0, 6, wxString::Format(wxT("%g"), 3.1415));
352 grid->SetCellValue(1, 6, wxString::Format(wxT("%g"), 1415.0));
353 grid->SetCellValue(2, 6, wxString::Format(wxT("%g"), 12345.67890));
354
355 grid->SetColFormatFloat(7, 6, 2);
356 grid->SetCellValue(0, 7, wxString::Format(wxT("%g"), 3.1415));
357 grid->SetCellValue(1, 7, wxString::Format(wxT("%g"), 1415.0));
358 grid->SetCellValue(2, 7, wxString::Format(wxT("%g"), 12345.67890));
359
360 grid->SetColFormatNumber(8);
361 grid->SetCellValue(0, 8, "17");
362 grid->SetCellValue(1, 8, "0");
363 grid->SetCellValue(2, 8, "-666");
364
365 const wxString choices[] =
366 {
367 _T("Please select a choice"),
368 _T("This takes two cells"),
369 _T("Another choice"),
370 };
371 grid->SetCellEditor(4, 0, new wxGridCellChoiceEditor(WXSIZEOF(choices), choices));
372 grid->SetCellSize(4, 0, 1, 2);
373 grid->SetCellValue(4, 0, choices[0]);
374 grid->SetCellOverflow(4, 0, false);
375
376 grid->SetCellSize(7, 1, 3, 4);
377 grid->SetCellAlignment(7, 1, wxALIGN_CENTRE, wxALIGN_CENTRE);
378 grid->SetCellValue(7, 1, _T("Big box!"));
379
380 // this does exactly nothing except testing that SetAttr() handles NULL
381 // attributes and does reference counting correctly
382 grid->SetAttr(11, 11, NULL);
383 grid->SetAttr(11, 11, new wxGridCellAttr);
384 grid->SetAttr(11, 11, NULL);
385
386 wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL );
387 topSizer->Add( grid,
388 1,
389 wxEXPAND );
390
391 #if wxUSE_LOG
392 topSizer->Add( logWin,
393 0,
394 wxEXPAND );
395 #endif // wxUSE_LOG
396
397 SetSizerAndFit( topSizer );
398
399 Centre();
400 SetDefaults();
401 }
402
403
404 GridFrame::~GridFrame()
405 {
406 #if wxUSE_LOG
407 delete wxLog::SetActiveTarget(m_logOld);
408 #endif // wxUSE_LOG
409 }
410
411
412 void GridFrame::SetDefaults()
413 {
414 GetMenuBar()->Check( ID_TOGGLEROWLABELS, true );
415 GetMenuBar()->Check( ID_TOGGLECOLLABELS, true );
416 GetMenuBar()->Check( ID_TOGGLEEDIT, true );
417 GetMenuBar()->Check( ID_TOGGLEROWSIZING, true );
418 GetMenuBar()->Check( ID_TOGGLECOLSIZING, true );
419 GetMenuBar()->Check( ID_TOGGLECOLMOVING, false );
420 GetMenuBar()->Check( ID_TOGGLEGRIDSIZING, true );
421 GetMenuBar()->Check( ID_TOGGLEGRIDDRAGCELL, false );
422 GetMenuBar()->Check( ID_TOGGLENATIVEHEADER, false );
423 GetMenuBar()->Check( ID_TOGGLEGRIDLINES, true );
424 GetMenuBar()->Check( ID_CELLOVERFLOW, true );
425 }
426
427
428 void GridFrame::ToggleRowLabels( wxCommandEvent& WXUNUSED(ev) )
429 {
430 if ( GetMenuBar()->IsChecked( ID_TOGGLEROWLABELS ) )
431 {
432 grid->SetRowLabelSize( grid->GetDefaultRowLabelSize() );
433 }
434 else
435 {
436 grid->SetRowLabelSize( 0 );
437 }
438 }
439
440
441 void GridFrame::ToggleColLabels( wxCommandEvent& WXUNUSED(ev) )
442 {
443 if ( GetMenuBar()->IsChecked( ID_TOGGLECOLLABELS ) )
444 {
445 grid->SetColLabelSize( grid->GetDefaultColLabelSize() );
446 }
447 else
448 {
449 grid->SetColLabelSize( 0 );
450 }
451 }
452
453
454 void GridFrame::ToggleEditing( wxCommandEvent& WXUNUSED(ev) )
455 {
456 grid->EnableEditing(
457 GetMenuBar()->IsChecked( ID_TOGGLEEDIT ) );
458 }
459
460
461 void GridFrame::ToggleRowSizing( wxCommandEvent& WXUNUSED(ev) )
462 {
463 grid->EnableDragRowSize(
464 GetMenuBar()->IsChecked( ID_TOGGLEROWSIZING ) );
465 }
466
467
468 void GridFrame::ToggleColSizing( wxCommandEvent& WXUNUSED(ev) )
469 {
470 grid->EnableDragColSize(
471 GetMenuBar()->IsChecked( ID_TOGGLECOLSIZING ) );
472 }
473
474 void GridFrame::ToggleColMoving( wxCommandEvent& WXUNUSED(ev) )
475 {
476 grid->EnableDragColMove(
477 GetMenuBar()->IsChecked( ID_TOGGLECOLMOVING ) );
478 }
479
480 void GridFrame::ToggleGridSizing( wxCommandEvent& WXUNUSED(ev) )
481 {
482 grid->EnableDragGridSize(
483 GetMenuBar()->IsChecked( ID_TOGGLEGRIDSIZING ) );
484 }
485
486 void GridFrame::ToggleGridDragCell( wxCommandEvent& WXUNUSED(ev) )
487 {
488 grid->EnableDragCell(
489 GetMenuBar()->IsChecked( ID_TOGGLEGRIDDRAGCELL ) );
490 }
491
492 void GridFrame::ToggleNativeHeader( wxCommandEvent& WXUNUSED(ev) )
493 {
494 grid->SetUseNativeColLabels(
495 GetMenuBar()->IsChecked( ID_TOGGLENATIVEHEADER ) );
496 }
497
498 void GridFrame::ToggleGridLines( wxCommandEvent& WXUNUSED(ev) )
499 {
500 grid->EnableGridLines(
501 GetMenuBar()->IsChecked( ID_TOGGLEGRIDLINES ) );
502 }
503
504 void GridFrame::OnSetHighlightWidth( wxCommandEvent& WXUNUSED(ev) )
505 {
506 wxString choices[] = { _T("0"), _T("1"), _T("2"), _T("3"), _T("4"), _T("5"), _T("6"), _T("7"), _T("8"), _T("9"), _T("10")};
507
508 wxSingleChoiceDialog dlg(this, _T("Choose the thickness of the highlight pen:"),
509 _T("Pen Width"), 11, choices);
510
511 int current = grid->GetCellHighlightPenWidth();
512 dlg.SetSelection(current);
513 if (dlg.ShowModal() == wxID_OK) {
514 grid->SetCellHighlightPenWidth(dlg.GetSelection());
515 }
516 }
517
518 void GridFrame::OnSetROHighlightWidth( wxCommandEvent& WXUNUSED(ev) )
519 {
520 wxString choices[] = { _T("0"), _T("1"), _T("2"), _T("3"), _T("4"), _T("5"), _T("6"), _T("7"), _T("8"), _T("9"), _T("10")};
521
522 wxSingleChoiceDialog dlg(this, _T("Choose the thickness of the highlight pen:"),
523 _T("Pen Width"), 11, choices);
524
525 int current = grid->GetCellHighlightROPenWidth();
526 dlg.SetSelection(current);
527 if (dlg.ShowModal() == wxID_OK) {
528 grid->SetCellHighlightROPenWidth(dlg.GetSelection());
529 }
530 }
531
532
533
534 void GridFrame::AutoSizeCols( wxCommandEvent& WXUNUSED(ev) )
535 {
536 grid->AutoSizeColumns();
537 grid->Refresh();
538 }
539
540 void GridFrame::CellOverflow( wxCommandEvent& ev )
541 {
542 grid->SetDefaultCellOverflow(ev.IsChecked());
543 grid->Refresh();
544 }
545
546 void GridFrame::ResizeCell( wxCommandEvent& ev )
547 {
548 if (ev.IsChecked())
549 grid->SetCellSize( 7, 1, 5, 5 );
550 else
551 grid->SetCellSize( 7, 1, 1, 5 );
552 grid->Refresh();
553 }
554
555 void GridFrame::SetLabelColour( wxCommandEvent& WXUNUSED(ev) )
556 {
557 wxColourDialog dlg( NULL );
558 if ( dlg.ShowModal() == wxID_OK )
559 {
560 wxColourData retData;
561 retData = dlg.GetColourData();
562 wxColour colour = retData.GetColour();
563
564 grid->SetLabelBackgroundColour( colour );
565 }
566 }
567
568
569 void GridFrame::SetLabelTextColour( wxCommandEvent& WXUNUSED(ev) )
570 {
571 wxColourDialog dlg( NULL );
572 if ( dlg.ShowModal() == wxID_OK )
573 {
574 wxColourData retData;
575 retData = dlg.GetColourData();
576 wxColour colour = retData.GetColour();
577
578 grid->SetLabelTextColour( colour );
579 }
580 }
581
582 void GridFrame::SetLabelFont( wxCommandEvent& WXUNUSED(ev) )
583 {
584 wxFont font = wxGetFontFromUser(this);
585 if ( font.Ok() )
586 {
587 grid->SetLabelFont(font);
588 }
589 }
590
591 void GridFrame::SetRowLabelHorizAlignment( wxCommandEvent& WXUNUSED(ev) )
592 {
593 int horiz, vert;
594 grid->GetRowLabelAlignment( &horiz, &vert );
595
596 switch ( horiz )
597 {
598 case wxALIGN_LEFT:
599 horiz = wxALIGN_CENTRE;
600 break;
601
602 case wxALIGN_CENTRE:
603 horiz = wxALIGN_RIGHT;
604 break;
605
606 case wxALIGN_RIGHT:
607 horiz = wxALIGN_LEFT;
608 break;
609 }
610
611 grid->SetRowLabelAlignment( horiz, vert );
612 }
613
614 void GridFrame::SetRowLabelVertAlignment( wxCommandEvent& WXUNUSED(ev) )
615 {
616 int horiz, vert;
617 grid->GetRowLabelAlignment( &horiz, &vert );
618
619 switch ( vert )
620 {
621 case wxALIGN_TOP:
622 vert = wxALIGN_CENTRE;
623 break;
624
625 case wxALIGN_CENTRE:
626 vert = wxALIGN_BOTTOM;
627 break;
628
629 case wxALIGN_BOTTOM:
630 vert = wxALIGN_TOP;
631 break;
632 }
633
634 grid->SetRowLabelAlignment( horiz, vert );
635 }
636
637
638 void GridFrame::SetColLabelHorizAlignment( wxCommandEvent& WXUNUSED(ev) )
639 {
640 int horiz, vert;
641 grid->GetColLabelAlignment( &horiz, &vert );
642
643 switch ( horiz )
644 {
645 case wxALIGN_LEFT:
646 horiz = wxALIGN_CENTRE;
647 break;
648
649 case wxALIGN_CENTRE:
650 horiz = wxALIGN_RIGHT;
651 break;
652
653 case wxALIGN_RIGHT:
654 horiz = wxALIGN_LEFT;
655 break;
656 }
657
658 grid->SetColLabelAlignment( horiz, vert );
659 }
660
661
662 void GridFrame::SetColLabelVertAlignment( wxCommandEvent& WXUNUSED(ev) )
663 {
664 int horiz, vert;
665 grid->GetColLabelAlignment( &horiz, &vert );
666
667 switch ( vert )
668 {
669 case wxALIGN_TOP:
670 vert = wxALIGN_CENTRE;
671 break;
672
673 case wxALIGN_CENTRE:
674 vert = wxALIGN_BOTTOM;
675 break;
676
677 case wxALIGN_BOTTOM:
678 vert = wxALIGN_TOP;
679 break;
680 }
681
682 grid->SetColLabelAlignment( horiz, vert );
683 }
684
685
686 void GridFrame::SetGridLineColour( wxCommandEvent& WXUNUSED(ev) )
687 {
688 wxColourDialog dlg( NULL );
689 if ( dlg.ShowModal() == wxID_OK )
690 {
691 wxColourData retData;
692 retData = dlg.GetColourData();
693 wxColour colour = retData.GetColour();
694
695 grid->SetGridLineColour( colour );
696 }
697 }
698
699
700 void GridFrame::InsertRow( wxCommandEvent& WXUNUSED(ev) )
701 {
702 grid->InsertRows( grid->GetGridCursorRow(), 1 );
703 }
704
705
706 void GridFrame::InsertCol( wxCommandEvent& WXUNUSED(ev) )
707 {
708 grid->InsertCols( grid->GetGridCursorCol(), 1 );
709 }
710
711
712 void GridFrame::DeleteSelectedRows( wxCommandEvent& WXUNUSED(ev) )
713 {
714 if ( grid->IsSelection() )
715 {
716 wxGridUpdateLocker locker(grid);
717 for ( int n = 0; n < grid->GetNumberRows(); )
718 {
719 if ( grid->IsInSelection( n , 0 ) )
720 grid->DeleteRows( n, 1 );
721 else
722 n++;
723 }
724 }
725 }
726
727
728 void GridFrame::AutoSizeRow(wxCommandEvent& WXUNUSED(event))
729 {
730 wxGridUpdateLocker locker(grid);
731 const wxArrayInt sels = grid->GetSelectedRows();
732 for ( size_t n = 0, count = sels.size(); n < count; n++ )
733 {
734 grid->AutoSizeRow( sels[n], false );
735 }
736 }
737
738 void GridFrame::AutoSizeCol(wxCommandEvent& WXUNUSED(event))
739 {
740 wxGridUpdateLocker locker(grid);
741 const wxArrayInt sels = grid->GetSelectedCols();
742 for ( size_t n = 0, count = sels.size(); n < count; n++ )
743 {
744 grid->AutoSizeColumn( sels[n], false );
745 }
746 }
747
748 void GridFrame::AutoSizeRowLabel(wxCommandEvent& WXUNUSED(event))
749 {
750 wxGridUpdateLocker locker(grid);
751 const wxArrayInt sels = grid->GetSelectedRows();
752 for ( size_t n = 0, count = sels.size(); n < count; n++ )
753 {
754 grid->AutoSizeRowLabelSize( sels[n] );
755 }
756 }
757
758 void GridFrame::AutoSizeColLabel(wxCommandEvent& WXUNUSED(event))
759 {
760 wxGridUpdateLocker locker(grid);
761 const wxArrayInt sels = grid->GetSelectedCols();
762 for ( size_t n = 0, count = sels.size(); n < count; n++ )
763 {
764 grid->AutoSizeColLabelSize( sels[n] );
765 }
766 }
767
768 void GridFrame::AutoSizeLabelsCol(wxCommandEvent& WXUNUSED(event))
769 {
770 grid->SetColLabelSize( wxGRID_AUTOSIZE );
771 }
772
773 void GridFrame::AutoSizeLabelsRow(wxCommandEvent& WXUNUSED(event))
774 {
775 grid->SetRowLabelSize( wxGRID_AUTOSIZE );
776 }
777
778 void GridFrame::AutoSizeTable(wxCommandEvent& WXUNUSED(event))
779 {
780 grid->AutoSize();
781 }
782
783
784 void GridFrame::DeleteSelectedCols( wxCommandEvent& WXUNUSED(ev) )
785 {
786 if ( grid->IsSelection() )
787 {
788 wxGridUpdateLocker locker(grid);
789 for ( int n = 0; n < grid->GetNumberCols(); )
790 {
791 if ( grid->IsInSelection( 0 , n ) )
792 grid->DeleteCols( n, 1 );
793 else
794 n++;
795 }
796 }
797 }
798
799
800 void GridFrame::ClearGrid( wxCommandEvent& WXUNUSED(ev) )
801 {
802 grid->ClearGrid();
803 }
804
805 void GridFrame::SelectCells( wxCommandEvent& WXUNUSED(ev) )
806 {
807 grid->SetSelectionMode( wxGrid::wxGridSelectCells );
808 }
809
810 void GridFrame::SelectRows( wxCommandEvent& WXUNUSED(ev) )
811 {
812 grid->SetSelectionMode( wxGrid::wxGridSelectRows );
813 }
814
815 void GridFrame::SelectCols( wxCommandEvent& WXUNUSED(ev) )
816 {
817 grid->SetSelectionMode( wxGrid::wxGridSelectColumns );
818 }
819
820 void GridFrame::SelectRowsOrCols( wxCommandEvent& WXUNUSED(ev) )
821 {
822 grid->SetSelectionMode( wxGrid::wxGridSelectRowsOrColumns );
823 }
824
825 void GridFrame::SetCellFgColour( wxCommandEvent& WXUNUSED(ev) )
826 {
827 wxColour col = wxGetColourFromUser(this);
828 if ( col.Ok() )
829 {
830 grid->SetDefaultCellTextColour(col);
831 grid->Refresh();
832 }
833 }
834
835 void GridFrame::SetCellBgColour( wxCommandEvent& WXUNUSED(ev) )
836 {
837 wxColour col = wxGetColourFromUser(this);
838 if ( col.Ok() )
839 {
840 // Check the new Refresh function by passing it a rectangle
841 // which exactly fits the grid.
842 wxPoint pt(0, 0);
843 wxRect r(pt, grid->GetSize());
844 grid->SetDefaultCellBackgroundColour(col);
845 grid->Refresh(true, &r);
846 }
847 }
848
849 void GridFrame::DeselectCell(wxCommandEvent& WXUNUSED(event))
850 {
851 grid->DeselectCell(3, 1);
852 }
853
854 void GridFrame::DeselectCol(wxCommandEvent& WXUNUSED(event))
855 {
856 grid->DeselectCol(2);
857 }
858
859 void GridFrame::DeselectRow(wxCommandEvent& WXUNUSED(event))
860 {
861 grid->DeselectRow(2);
862 }
863
864 void GridFrame::DeselectAll(wxCommandEvent& WXUNUSED(event))
865 {
866 grid->ClearSelection();
867 }
868
869 void GridFrame::SelectCell(wxCommandEvent& WXUNUSED(event))
870 {
871 grid->SelectBlock(3, 1, 3, 1, m_addToSel);
872 }
873
874 void GridFrame::SelectCol(wxCommandEvent& WXUNUSED(event))
875 {
876 grid->SelectCol(2, m_addToSel);
877 }
878
879 void GridFrame::SelectRow(wxCommandEvent& WXUNUSED(event))
880 {
881 grid->SelectRow(2, m_addToSel);
882 }
883
884 void GridFrame::SelectAll(wxCommandEvent& WXUNUSED(event))
885 {
886 grid->SelectAll();
887 }
888
889 void GridFrame::OnAddToSelectToggle(wxCommandEvent& event)
890 {
891 m_addToSel = event.IsChecked();
892 }
893
894 void GridFrame::OnLabelLeftClick( wxGridEvent& ev )
895 {
896 wxString logBuf;
897 if ( ev.GetRow() != -1 )
898 {
899 logBuf << _T("Left click on row label ") << ev.GetRow();
900 }
901 else if ( ev.GetCol() != -1 )
902 {
903 logBuf << _T("Left click on col label ") << ev.GetCol();
904 }
905 else
906 {
907 logBuf << _T("Left click on corner label");
908 }
909
910 if ( ev.ShiftDown() )
911 logBuf << _T(" (shift down)");
912 if ( ev.ControlDown() )
913 logBuf << _T(" (control down)");
914 wxLogMessage( wxT("%s"), logBuf.c_str() );
915
916 // you must call event skip if you want default grid processing
917 //
918 ev.Skip();
919 }
920
921
922 void GridFrame::OnCellLeftClick( wxGridEvent& ev )
923 {
924 wxLogMessage(_T("Left click at row %d, col %d"), ev.GetRow(), ev.GetCol());
925
926 // you must call event skip if you want default grid processing
927 // (cell highlighting etc.)
928 //
929 ev.Skip();
930 }
931
932
933 void GridFrame::OnRowSize( wxGridSizeEvent& ev )
934 {
935 wxLogMessage(_T("Resized row %d"), ev.GetRowOrCol());
936
937 ev.Skip();
938 }
939
940
941 void GridFrame::OnColSize( wxGridSizeEvent& ev )
942 {
943 wxLogMessage(_T("Resized col %d"), ev.GetRowOrCol());
944
945 ev.Skip();
946 }
947
948
949 void GridFrame::OnShowSelection(wxCommandEvent& WXUNUSED(event))
950 {
951 // max number of elements to dump -- otherwise it can take too much time
952 static const size_t countMax = 100;
953
954 bool rows = false;
955
956 switch ( grid->GetSelectionMode() )
957 {
958 case wxGrid::wxGridSelectCells:
959 {
960 const wxGridCellCoordsArray cells(grid->GetSelectedCells());
961 size_t count = cells.size();
962 wxLogMessage(_T("%lu cells selected:"), (unsigned long)count);
963 if ( count > countMax )
964 {
965 wxLogMessage(_T("[too many selected cells, ")
966 _T("showing only the first %lu]"),
967 (unsigned long)countMax);
968 count = countMax;
969 }
970
971 for ( size_t n = 0; n < count; n++ )
972 {
973 const wxGridCellCoords& c = cells[n];
974 wxLogMessage(_T(" selected cell %lu: (%d, %d)"),
975 (unsigned long)n, c.GetCol(), c.GetRow());
976 }
977 }
978 break;
979
980 case wxGrid::wxGridSelectRows:
981 rows = true;
982 // fall through
983
984 case wxGrid::wxGridSelectColumns:
985 {
986 const wxChar *plural, *single;
987 if ( rows )
988 {
989 plural = _T("rows");
990 single = _T("row");
991 }
992 else // columns
993 {
994 plural = _T("columns");
995 single = _T("column");
996 }
997
998 const wxArrayInt sels((const wxArrayInt)(rows ? grid->GetSelectedRows()
999 : grid->GetSelectedCols()));
1000 size_t count = sels.size();
1001 wxLogMessage(_T("%lu %s selected:"),
1002 (unsigned long)count, plural);
1003 if ( count > countMax )
1004 {
1005 wxLogMessage(_T("[too many selected %s, ")
1006 _T("showing only the first %lu]"),
1007 plural, (unsigned long)countMax);
1008 count = countMax;
1009 }
1010
1011 for ( size_t n = 0; n < count; n++ )
1012 {
1013 wxLogMessage(_T(" selected %s %lu: %d"),
1014 single, (unsigned long)n, sels[n]);
1015 }
1016 }
1017 break;
1018
1019 default:
1020 wxFAIL_MSG( _T("unknown wxGrid selection mode") );
1021 break;
1022 }
1023 }
1024
1025 void GridFrame::OnSelectCell( wxGridEvent& ev )
1026 {
1027 wxString logBuf;
1028 if ( ev.Selecting() )
1029 logBuf << _T("Selected ");
1030 else
1031 logBuf << _T("Deselected ");
1032 logBuf << _T("cell at row ") << ev.GetRow()
1033 << _T(" col ") << ev.GetCol()
1034 << _T(" ( ControlDown: ")<< (ev.ControlDown() ? 'T':'F')
1035 << _T(", ShiftDown: ")<< (ev.ShiftDown() ? 'T':'F')
1036 << _T(", AltDown: ")<< (ev.AltDown() ? 'T':'F')
1037 << _T(", MetaDown: ")<< (ev.MetaDown() ? 'T':'F') << _T(" )");
1038
1039 //Indicate whether this column was moved
1040 if ( ((wxGrid *)ev.GetEventObject())->GetColPos( ev.GetCol() ) != ev.GetCol() )
1041 logBuf << _T(" *** Column moved, current position: ") << ((wxGrid *)ev.GetEventObject())->GetColPos( ev.GetCol() );
1042
1043 wxLogMessage( wxT("%s"), logBuf.c_str() );
1044
1045 // you must call Skip() if you want the default processing
1046 // to occur in wxGrid
1047 ev.Skip();
1048 }
1049
1050 void GridFrame::OnRangeSelected( wxGridRangeSelectEvent& ev )
1051 {
1052 wxString logBuf;
1053 if ( ev.Selecting() )
1054 logBuf << _T("Selected ");
1055 else
1056 logBuf << _T("Deselected ");
1057 logBuf << _T("cells from row ") << ev.GetTopRow()
1058 << _T(" col ") << ev.GetLeftCol()
1059 << _T(" to row ") << ev.GetBottomRow()
1060 << _T(" col ") << ev.GetRightCol()
1061 << _T(" ( ControlDown: ")<< (ev.ControlDown() ? 'T':'F')
1062 << _T(", ShiftDown: ")<< (ev.ShiftDown() ? 'T':'F')
1063 << _T(", AltDown: ")<< (ev.AltDown() ? 'T':'F')
1064 << _T(", MetaDown: ")<< (ev.MetaDown() ? 'T':'F') << _T(" )");
1065 wxLogMessage( wxT("%s"), logBuf.c_str() );
1066
1067 ev.Skip();
1068 }
1069
1070 void GridFrame::OnCellValueChanging( wxGridEvent& ev )
1071 {
1072 int row = ev.GetRow(),
1073 col = ev.GetCol();
1074
1075 wxLogMessage("Value of cell at (%d, %d): about to change "
1076 "from \"%s\" to \"%s\"",
1077 row, col,
1078 grid->GetCellValue(row, col), ev.GetString());
1079
1080 // test how vetoing works
1081 if ( ev.GetString() == "42" )
1082 {
1083 wxLogMessage("Vetoing the change.");
1084 ev.Veto();
1085 return;
1086 }
1087
1088 ev.Skip();
1089 }
1090
1091 void GridFrame::OnCellValueChanged( wxGridEvent& ev )
1092 {
1093 int row = ev.GetRow(),
1094 col = ev.GetCol();
1095
1096 wxLogMessage("Value of cell at (%d, %d) changed and is now \"%s\" "
1097 "(was \"%s\")",
1098 row, col,
1099 grid->GetCellValue(row, col), ev.GetString());
1100
1101 ev.Skip();
1102 }
1103
1104 void GridFrame::OnCellBeginDrag( wxGridEvent& ev )
1105 {
1106 wxLogMessage(_T("Got request to drag cell at row %d, col %d"),
1107 ev.GetRow(), ev.GetCol());
1108
1109 ev.Skip();
1110 }
1111
1112 void GridFrame::OnEditorShown( wxGridEvent& ev )
1113 {
1114
1115 if ( (ev.GetCol() == 4) &&
1116 (ev.GetRow() == 0) &&
1117 (wxMessageBox(_T("Are you sure you wish to edit this cell"),
1118 _T("Checking"),wxYES_NO) == wxNO ) ) {
1119
1120 ev.Veto();
1121 return;
1122 }
1123
1124 wxLogMessage( wxT("Cell editor shown.") );
1125
1126 ev.Skip();
1127 }
1128
1129 void GridFrame::OnEditorHidden( wxGridEvent& ev )
1130 {
1131
1132 if ( (ev.GetCol() == 4) &&
1133 (ev.GetRow() == 0) &&
1134 (wxMessageBox(_T("Are you sure you wish to finish editing this cell"),
1135 _T("Checking"),wxYES_NO) == wxNO ) ) {
1136
1137 ev.Veto();
1138 return;
1139 }
1140
1141 wxLogMessage( wxT("Cell editor hidden.") );
1142
1143 ev.Skip();
1144 }
1145
1146 void GridFrame::About( wxCommandEvent& WXUNUSED(ev) )
1147 {
1148 wxAboutDialogInfo aboutInfo;
1149 aboutInfo.SetName(wxT("wxGrid demo"));
1150 aboutInfo.SetDescription(_("wxGrid sample program"));
1151 aboutInfo.AddDeveloper(wxT("Michael Bedward"));
1152 aboutInfo.AddDeveloper(wxT("Julian Smart"));
1153 aboutInfo.AddDeveloper(wxT("Vadim Zeitlin"));
1154
1155 wxAboutBox(aboutInfo);
1156 }
1157
1158
1159 void GridFrame::OnQuit( wxCommandEvent& WXUNUSED(ev) )
1160 {
1161 Close( true );
1162 }
1163
1164 void GridFrame::OnBugsTable(wxCommandEvent& )
1165 {
1166 BugsGridFrame *frame = new BugsGridFrame;
1167 frame->Show(true);
1168 }
1169
1170 // ----------------------------------------------------------------------------
1171 // MyGridCellAttrProvider
1172 // ----------------------------------------------------------------------------
1173
1174 MyGridCellAttrProvider::MyGridCellAttrProvider()
1175 {
1176 m_attrForOddRows = new wxGridCellAttr;
1177 m_attrForOddRows->SetBackgroundColour(*wxLIGHT_GREY);
1178 }
1179
1180 MyGridCellAttrProvider::~MyGridCellAttrProvider()
1181 {
1182 m_attrForOddRows->DecRef();
1183 }
1184
1185 wxGridCellAttr *MyGridCellAttrProvider::GetAttr(int row, int col,
1186 wxGridCellAttr::wxAttrKind kind /* = wxGridCellAttr::Any */) const
1187 {
1188 wxGridCellAttr *attr = wxGridCellAttrProvider::GetAttr(row, col, kind);
1189
1190 if ( row % 2 )
1191 {
1192 if ( !attr )
1193 {
1194 attr = m_attrForOddRows;
1195 attr->IncRef();
1196 }
1197 else
1198 {
1199 if ( !attr->HasBackgroundColour() )
1200 {
1201 wxGridCellAttr *attrNew = attr->Clone();
1202 attr->DecRef();
1203 attr = attrNew;
1204 attr->SetBackgroundColour(*wxLIGHT_GREY);
1205 }
1206 }
1207 }
1208
1209 return attr;
1210 }
1211
1212 void GridFrame::OnVTable(wxCommandEvent& )
1213 {
1214 static long s_sizeGrid = 10000;
1215
1216 s_sizeGrid = wxGetNumberFromUser(_T("Size of the table to create"),
1217 _T("Size: "),
1218 _T("wxGridDemo question"),
1219 s_sizeGrid,
1220 0, 32000, this);
1221
1222 if ( s_sizeGrid != -1 )
1223 {
1224 BigGridFrame* win = new BigGridFrame(s_sizeGrid);
1225 win->Show(true);
1226 }
1227 }
1228
1229 // ----------------------------------------------------------------------------
1230 // MyGridCellRenderer
1231 // ----------------------------------------------------------------------------
1232
1233 // do something that the default renderer doesn't here just to show that it is
1234 // possible to alter the appearance of the cell beyond what the attributes
1235 // allow
1236 void MyGridCellRenderer::Draw(wxGrid& grid,
1237 wxGridCellAttr& attr,
1238 wxDC& dc,
1239 const wxRect& rect,
1240 int row, int col,
1241 bool isSelected)
1242 {
1243 wxGridCellStringRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
1244
1245 dc.SetPen(*wxGREEN_PEN);
1246 dc.SetBrush(*wxTRANSPARENT_BRUSH);
1247 dc.DrawEllipse(rect);
1248 }
1249
1250 // ============================================================================
1251 // BigGridFrame and BigGridTable: Sample of a non-standard table
1252 // ============================================================================
1253
1254 BigGridFrame::BigGridFrame(long sizeGrid)
1255 : wxFrame(NULL, wxID_ANY, _T("Plugin Virtual Table"),
1256 wxDefaultPosition, wxSize(500, 450))
1257 {
1258 m_grid = new wxGrid(this, wxID_ANY, wxDefaultPosition, wxDefaultSize);
1259 m_table = new BigGridTable(sizeGrid);
1260
1261 // VZ: I don't understand why this slows down the display that much,
1262 // must profile it...
1263 //m_table->SetAttrProvider(new MyGridCellAttrProvider);
1264
1265 m_grid->SetTable(m_table, true);
1266
1267 #if defined __WXMOTIF__
1268 // MB: the grid isn't getting a sensible default size under wxMotif
1269 int cw, ch;
1270 GetClientSize( &cw, &ch );
1271 m_grid->SetSize( cw, ch );
1272 #endif
1273 }
1274
1275 // ============================================================================
1276 // BugsGridFrame: a "realistic" table
1277 // ============================================================================
1278
1279 // ----------------------------------------------------------------------------
1280 // bugs table data
1281 // ----------------------------------------------------------------------------
1282
1283 enum Columns
1284 {
1285 Col_Id,
1286 Col_Summary,
1287 Col_Severity,
1288 Col_Priority,
1289 Col_Platform,
1290 Col_Opened,
1291 Col_Max
1292 };
1293
1294 enum Severity
1295 {
1296 Sev_Wish,
1297 Sev_Minor,
1298 Sev_Normal,
1299 Sev_Major,
1300 Sev_Critical,
1301 Sev_Max
1302 };
1303
1304 static const wxString severities[] =
1305 {
1306 _T("wishlist"),
1307 _T("minor"),
1308 _T("normal"),
1309 _T("major"),
1310 _T("critical"),
1311 };
1312
1313 static struct BugsGridData
1314 {
1315 int id;
1316 wxChar summary[80];
1317 Severity severity;
1318 int prio;
1319 wxChar platform[12];
1320 bool opened;
1321 } gs_dataBugsGrid [] =
1322 {
1323 { 18, _T("foo doesn't work"), Sev_Major, 1, _T("wxMSW"), true },
1324 { 27, _T("bar crashes"), Sev_Critical, 1, _T("all"), false },
1325 { 45, _T("printing is slow"), Sev_Minor, 3, _T("wxMSW"), true },
1326 { 68, _T("Rectangle() fails"), Sev_Normal, 1, _T("wxMSW"), false },
1327 };
1328
1329 static const wxChar *headers[Col_Max] =
1330 {
1331 _T("Id"),
1332 _T("Summary"),
1333 _T("Severity"),
1334 _T("Priority"),
1335 _T("Platform"),
1336 _T("Opened?"),
1337 };
1338
1339 // ----------------------------------------------------------------------------
1340 // BugsGridTable
1341 // ----------------------------------------------------------------------------
1342
1343 wxString BugsGridTable::GetTypeName(int WXUNUSED(row), int col)
1344 {
1345 switch ( col )
1346 {
1347 case Col_Id:
1348 case Col_Priority:
1349 return wxGRID_VALUE_NUMBER;;
1350
1351 case Col_Severity:
1352 // fall thorugh (TODO should be a list)
1353
1354 case Col_Summary:
1355 return wxString::Format(_T("%s:80"), wxGRID_VALUE_STRING);
1356
1357 case Col_Platform:
1358 return wxString::Format(_T("%s:all,MSW,GTK,other"), wxGRID_VALUE_CHOICE);
1359
1360 case Col_Opened:
1361 return wxGRID_VALUE_BOOL;
1362 }
1363
1364 wxFAIL_MSG(_T("unknown column"));
1365
1366 return wxEmptyString;
1367 }
1368
1369 int BugsGridTable::GetNumberRows()
1370 {
1371 return WXSIZEOF(gs_dataBugsGrid);
1372 }
1373
1374 int BugsGridTable::GetNumberCols()
1375 {
1376 return Col_Max;
1377 }
1378
1379 bool BugsGridTable::IsEmptyCell( int WXUNUSED(row), int WXUNUSED(col) )
1380 {
1381 return false;
1382 }
1383
1384 wxString BugsGridTable::GetValue( int row, int col )
1385 {
1386 const BugsGridData& gd = gs_dataBugsGrid[row];
1387
1388 switch ( col )
1389 {
1390 case Col_Id:
1391 return wxString::Format(_T("%d"), gd.id);
1392
1393 case Col_Priority:
1394 return wxString::Format(_T("%d"), gd.prio);
1395
1396 case Col_Opened:
1397 return gd.opened ? _T("1") : _T("0");
1398
1399 case Col_Severity:
1400 return severities[gd.severity];
1401
1402 case Col_Summary:
1403 return gd.summary;
1404
1405 case Col_Platform:
1406 return gd.platform;
1407 }
1408
1409 return wxEmptyString;
1410 }
1411
1412 void BugsGridTable::SetValue( int row, int col, const wxString& value )
1413 {
1414 BugsGridData& gd = gs_dataBugsGrid[row];
1415
1416 switch ( col )
1417 {
1418 case Col_Id:
1419 case Col_Priority:
1420 case Col_Opened:
1421 wxFAIL_MSG(_T("unexpected column"));
1422 break;
1423
1424 case Col_Severity:
1425 {
1426 size_t n;
1427 for ( n = 0; n < WXSIZEOF(severities); n++ )
1428 {
1429 if ( severities[n] == value )
1430 {
1431 gd.severity = (Severity)n;
1432 break;
1433 }
1434 }
1435
1436 if ( n == WXSIZEOF(severities) )
1437 {
1438 wxLogWarning(_T("Invalid severity value '%s'."),
1439 value.c_str());
1440 gd.severity = Sev_Normal;
1441 }
1442 }
1443 break;
1444
1445 case Col_Summary:
1446 wxStrncpy(gd.summary, value, WXSIZEOF(gd.summary));
1447 break;
1448
1449 case Col_Platform:
1450 wxStrncpy(gd.platform, value, WXSIZEOF(gd.platform));
1451 break;
1452 }
1453 }
1454
1455 bool
1456 BugsGridTable::CanGetValueAs(int WXUNUSED(row),
1457 int col,
1458 const wxString& typeName)
1459 {
1460 if ( typeName == wxGRID_VALUE_STRING )
1461 {
1462 return true;
1463 }
1464 else if ( typeName == wxGRID_VALUE_BOOL )
1465 {
1466 return col == Col_Opened;
1467 }
1468 else if ( typeName == wxGRID_VALUE_NUMBER )
1469 {
1470 return col == Col_Id || col == Col_Priority || col == Col_Severity;
1471 }
1472 else
1473 {
1474 return false;
1475 }
1476 }
1477
1478 bool BugsGridTable::CanSetValueAs( int row, int col, const wxString& typeName )
1479 {
1480 return CanGetValueAs(row, col, typeName);
1481 }
1482
1483 long BugsGridTable::GetValueAsLong( int row, int col )
1484 {
1485 const BugsGridData& gd = gs_dataBugsGrid[row];
1486
1487 switch ( col )
1488 {
1489 case Col_Id:
1490 return gd.id;
1491
1492 case Col_Priority:
1493 return gd.prio;
1494
1495 case Col_Severity:
1496 return gd.severity;
1497
1498 default:
1499 wxFAIL_MSG(_T("unexpected column"));
1500 return -1;
1501 }
1502 }
1503
1504 bool BugsGridTable::GetValueAsBool( int row, int col )
1505 {
1506 if ( col == Col_Opened )
1507 {
1508 return gs_dataBugsGrid[row].opened;
1509 }
1510 else
1511 {
1512 wxFAIL_MSG(_T("unexpected column"));
1513
1514 return false;
1515 }
1516 }
1517
1518 void BugsGridTable::SetValueAsLong( int row, int col, long value )
1519 {
1520 BugsGridData& gd = gs_dataBugsGrid[row];
1521
1522 switch ( col )
1523 {
1524 case Col_Priority:
1525 gd.prio = value;
1526 break;
1527
1528 default:
1529 wxFAIL_MSG(_T("unexpected column"));
1530 }
1531 }
1532
1533 void BugsGridTable::SetValueAsBool( int row, int col, bool value )
1534 {
1535 if ( col == Col_Opened )
1536 {
1537 gs_dataBugsGrid[row].opened = value;
1538 }
1539 else
1540 {
1541 wxFAIL_MSG(_T("unexpected column"));
1542 }
1543 }
1544
1545 wxString BugsGridTable::GetColLabelValue( int col )
1546 {
1547 return headers[col];
1548 }
1549
1550 // ----------------------------------------------------------------------------
1551 // BugsGridFrame
1552 // ----------------------------------------------------------------------------
1553
1554 BugsGridFrame::BugsGridFrame()
1555 : wxFrame(NULL, wxID_ANY, _T("Bugs table"))
1556 {
1557 wxGrid *grid = new wxGrid(this, wxID_ANY);
1558 wxGridTableBase *table = new BugsGridTable();
1559 table->SetAttrProvider(new MyGridCellAttrProvider);
1560 grid->SetTable(table, true);
1561
1562 wxGridCellAttr *attrRO = new wxGridCellAttr,
1563 *attrRangeEditor = new wxGridCellAttr,
1564 *attrCombo = new wxGridCellAttr;
1565
1566 attrRO->SetReadOnly();
1567 attrRangeEditor->SetEditor(new wxGridCellNumberEditor(1, 5));
1568 attrCombo->SetEditor(new wxGridCellChoiceEditor(WXSIZEOF(severities),
1569 severities));
1570
1571 grid->SetColAttr(Col_Id, attrRO);
1572 grid->SetColAttr(Col_Priority, attrRangeEditor);
1573 grid->SetColAttr(Col_Severity, attrCombo);
1574
1575 grid->Fit();
1576 SetClientSize(grid->GetSize());
1577 }
1578
1579 // ============================================================================
1580 // TabularGrid: grid used for display of tabular data
1581 // ============================================================================
1582
1583 class TabularGridTable : public wxGridTableBase
1584 {
1585 public:
1586 enum
1587 {
1588 COL_NAME,
1589 COL_EXT,
1590 COL_SIZE,
1591 COL_DATE,
1592 COL_MAX
1593 };
1594
1595 enum
1596 {
1597 ROW_MAX = 3
1598 };
1599
1600 TabularGridTable() { m_sortOrder = NULL; }
1601
1602 virtual int GetNumberRows() { return ROW_MAX; }
1603 virtual int GetNumberCols() { return COL_MAX; }
1604
1605 virtual wxString GetValue(int row, int col)
1606 {
1607 if ( m_sortOrder )
1608 row = m_sortOrder[row];
1609
1610 switch ( col )
1611 {
1612 case COL_NAME:
1613 case COL_EXT:
1614 return GetNameOrExt(row, col);
1615
1616 case COL_SIZE:
1617 return wxString::Format("%lu", GetSize(row));
1618
1619 case COL_DATE:
1620 return GetDate(row).FormatDate();
1621
1622 case COL_MAX:
1623 default:
1624 wxFAIL_MSG( "unknown column" );
1625 }
1626
1627 return wxString();
1628 }
1629
1630 virtual void SetValue(int, int, const wxString&)
1631 {
1632 wxFAIL_MSG( "shouldn't be called" );
1633 }
1634
1635 virtual wxString GetColLabelValue(int col)
1636 {
1637 // notice that column parameter here always refers to the internal
1638 // column index, independently of its position on the screen
1639 static const char *labels[] = { "Name", "Extension", "Size", "Date" };
1640 wxCOMPILE_TIME_ASSERT( WXSIZEOF(labels) == COL_MAX, LabelsMismatch );
1641
1642 return labels[col];
1643 }
1644
1645 virtual void SetColLabelValue(int, const wxString&)
1646 {
1647 wxFAIL_MSG( "shouldn't be called" );
1648 }
1649
1650 void Sort(int col, bool ascending)
1651 {
1652 // we hardcode all sorting orders for simplicity here
1653 static int sortOrders[COL_MAX][2][ROW_MAX] =
1654 {
1655 // descending ascending
1656 { { 2, 1, 0 }, { 0, 1, 2 } },
1657 { { 2, 1, 0 }, { 0, 1, 2 } },
1658 { { 2, 1, 0 }, { 0, 1, 2 } },
1659 { { 1, 0, 2 }, { 2, 0, 1 } },
1660 };
1661
1662 m_sortOrder = col == wxNOT_FOUND ? NULL : sortOrders[col][ascending];
1663 }
1664
1665 private:
1666 wxString GetNameOrExt(int row, int col) const
1667 {
1668 static const char *
1669 names[] = { "autoexec.bat", "boot.ini", "io.sys" };
1670 wxCOMPILE_TIME_ASSERT( WXSIZEOF(names) == ROW_MAX, NamesMismatch );
1671
1672 const wxString s(names[row]);
1673 return col == COL_NAME ? s.BeforeFirst('.') : s.AfterLast('.');
1674 }
1675
1676 unsigned long GetSize(int row) const
1677 {
1678 static const unsigned long
1679 sizes[] = { 412, 604, 40774 };
1680 wxCOMPILE_TIME_ASSERT( WXSIZEOF(sizes) == ROW_MAX, SizesMismatch );
1681
1682 return sizes[row];
1683 }
1684
1685 wxDateTime GetDate(int row) const
1686 {
1687 static const char *
1688 dates[] = { "2004-04-17", "2006-05-27", "1994-05-31" };
1689 wxCOMPILE_TIME_ASSERT( WXSIZEOF(dates) == ROW_MAX, DatesMismatch );
1690
1691 wxDateTime dt;
1692 dt.ParseISODate(dates[row]);
1693 return dt;
1694 }
1695
1696 int *m_sortOrder;
1697 };
1698
1699 // specialized text control for column indexes entry
1700 class ColIndexEntry : public wxTextCtrl
1701 {
1702 public:
1703 ColIndexEntry(wxWindow *parent)
1704 : wxTextCtrl(parent, wxID_ANY, "")
1705 {
1706 SetValidator(wxTextValidator(wxFILTER_NUMERIC));
1707 }
1708
1709 int GetCol()
1710 {
1711 unsigned long col;
1712 if ( !GetValue().ToULong(&col) || col > TabularGridTable::COL_MAX )
1713 {
1714 SetFocus();
1715 return -1;
1716 }
1717
1718 return col;
1719 }
1720
1721 protected:
1722 virtual wxSize DoGetBestSize() const
1723 {
1724 wxSize size = wxTextCtrl::DoGetBestSize();
1725 size.x = 3*GetCharWidth();
1726 return size;
1727 }
1728 };
1729
1730 class TabularGridFrame : public wxFrame
1731 {
1732 public:
1733 TabularGridFrame();
1734
1735 private:
1736 enum // control ids
1737 {
1738 Id_Check_UseNativeHeader,
1739 Id_Check_DrawNativeLabels,
1740 Id_Check_ShowRowLabels,
1741 Id_Check_EnableColMove
1742 };
1743
1744 // event handlers
1745
1746 void OnToggleUseNativeHeader(wxCommandEvent&)
1747 {
1748 m_grid->UseNativeColHeader(m_chkUseNative->IsChecked());
1749 }
1750
1751 void OnUpdateDrawNativeLabelsUI(wxUpdateUIEvent& event)
1752 {
1753 // we don't draw labels at all, native or otherwise, if we use the
1754 // native header control
1755 event.Enable( !m_chkUseNative->GetValue() );
1756 }
1757
1758 void OnToggleDrawNativeLabels(wxCommandEvent&)
1759 {
1760 m_grid->SetUseNativeColLabels(m_chkDrawNative->IsChecked());
1761 }
1762
1763 void OnToggleShowRowLabels(wxCommandEvent&)
1764 {
1765 m_grid->SetRowLabelSize(m_chkShowRowLabels->IsChecked()
1766 ? wxGRID_AUTOSIZE
1767 : 0);
1768 }
1769
1770 void OnToggleColMove(wxCommandEvent&)
1771 {
1772 m_grid->EnableDragColMove(m_chkEnableColMove->IsChecked());
1773 }
1774
1775 void OnShowHideColumn(wxCommandEvent& event)
1776 {
1777 int col = m_txtColShowHide->GetCol();
1778 if ( col != -1 )
1779 {
1780 m_grid->SetColSize(col,
1781 event.GetId() == wxID_ADD ? wxGRID_AUTOSIZE : 0);
1782
1783 UpdateOrderAndVisibility();
1784 }
1785 }
1786
1787 void OnMoveColumn(wxCommandEvent&)
1788 {
1789 int col = m_txtColIndex->GetCol();
1790 int pos = m_txtColPos->GetCol();
1791 if ( col == -1 || pos == -1 )
1792 return;
1793
1794 m_grid->SetColPos(col, pos);
1795
1796 UpdateOrderAndVisibility();
1797 }
1798
1799 void OnResetColumnOrder(wxCommandEvent&)
1800 {
1801 m_grid->ResetColPos();
1802
1803 UpdateOrderAndVisibility();
1804 }
1805
1806 void OnGridColSort(wxGridEvent& event)
1807 {
1808 const int col = event.GetCol();
1809 m_table->Sort(col, !(m_grid->IsSortingBy(col) &&
1810 m_grid->IsSortOrderAscending()));
1811 }
1812
1813 void OnGridColMove(wxGridEvent& event)
1814 {
1815 // can't update it yet as the order hasn't been changed, so do it a bit
1816 // later
1817 m_shouldUpdateOrder = true;
1818
1819 event.Skip();
1820 }
1821
1822 void OnGridColSize(wxGridSizeEvent& event)
1823 {
1824 // we only catch this event to react to the user showing or hiding this
1825 // column using the header control menu and not because we're
1826 // interested in column resizing
1827 UpdateOrderAndVisibility();
1828
1829 event.Skip();
1830 }
1831
1832 void OnIdle(wxIdleEvent& event)
1833 {
1834 if ( m_shouldUpdateOrder )
1835 {
1836 m_shouldUpdateOrder = false;
1837 UpdateOrderAndVisibility();
1838 }
1839
1840 event.Skip();
1841 }
1842
1843 void UpdateOrderAndVisibility()
1844 {
1845 wxString s;
1846 for ( int pos = 0; pos < TabularGridTable::COL_MAX; pos++ )
1847 {
1848 const int col = m_grid->GetColAt(pos);
1849 const bool isHidden = m_grid->GetColSize(col) == 0;
1850
1851 if ( isHidden )
1852 s << '[';
1853 s << col;
1854 if ( isHidden )
1855 s << ']';
1856
1857 s << ' ';
1858 }
1859
1860 m_statOrder->SetLabel(s);
1861 }
1862
1863 // controls
1864 wxGrid *m_grid;
1865 TabularGridTable *m_table;
1866 wxCheckBox *m_chkUseNative,
1867 *m_chkDrawNative,
1868 *m_chkShowRowLabels,
1869 *m_chkEnableColMove;
1870
1871 ColIndexEntry *m_txtColIndex,
1872 *m_txtColPos,
1873 *m_txtColShowHide;
1874
1875 wxStaticText *m_statOrder;
1876
1877 // fla for EVT_IDLE handler
1878 bool m_shouldUpdateOrder;
1879
1880 DECLARE_NO_COPY_CLASS(TabularGridFrame)
1881 DECLARE_EVENT_TABLE()
1882 };
1883
1884 BEGIN_EVENT_TABLE(TabularGridFrame, wxFrame)
1885 EVT_CHECKBOX(Id_Check_UseNativeHeader,
1886 TabularGridFrame::OnToggleUseNativeHeader)
1887 EVT_CHECKBOX(Id_Check_DrawNativeLabels,
1888 TabularGridFrame::OnToggleDrawNativeLabels)
1889 EVT_CHECKBOX(Id_Check_ShowRowLabels,
1890 TabularGridFrame::OnToggleShowRowLabels)
1891 EVT_CHECKBOX(Id_Check_EnableColMove,
1892 TabularGridFrame::OnToggleColMove)
1893
1894 EVT_UPDATE_UI(Id_Check_DrawNativeLabels,
1895 TabularGridFrame::OnUpdateDrawNativeLabelsUI)
1896
1897 EVT_BUTTON(wxID_APPLY, TabularGridFrame::OnMoveColumn)
1898 EVT_BUTTON(wxID_RESET, TabularGridFrame::OnResetColumnOrder)
1899 EVT_BUTTON(wxID_ADD, TabularGridFrame::OnShowHideColumn)
1900 EVT_BUTTON(wxID_DELETE, TabularGridFrame::OnShowHideColumn)
1901
1902 EVT_GRID_COL_SORT(TabularGridFrame::OnGridColSort)
1903 EVT_GRID_COL_MOVE(TabularGridFrame::OnGridColMove)
1904 EVT_GRID_COL_SIZE(TabularGridFrame::OnGridColSize)
1905
1906 EVT_IDLE(TabularGridFrame::OnIdle)
1907 END_EVENT_TABLE()
1908
1909 TabularGridFrame::TabularGridFrame()
1910 : wxFrame(NULL, wxID_ANY, "Tabular table")
1911 {
1912 m_shouldUpdateOrder = false;
1913
1914 wxPanel * const panel = new wxPanel(this);
1915
1916 // create and initialize the grid with the specified data
1917 m_table = new TabularGridTable;
1918 m_grid = new wxGrid(panel, wxID_ANY,
1919 wxDefaultPosition, wxDefaultSize,
1920 wxBORDER_STATIC | wxWANTS_CHARS);
1921 m_grid->SetTable(m_table, true, wxGrid::wxGridSelectRows);
1922
1923 m_grid->EnableDragColMove();
1924 m_grid->UseNativeColHeader();
1925 m_grid->HideRowLabels();
1926
1927 // add it and the other controls to the frame
1928 wxSizer * const sizerTop = new wxBoxSizer(wxVERTICAL);
1929 sizerTop->Add(m_grid, wxSizerFlags(1).Expand().Border());
1930
1931 wxSizer * const sizerControls = new wxBoxSizer(wxHORIZONTAL);
1932
1933 wxSizer * const sizerStyles = new wxBoxSizer(wxVERTICAL);
1934 m_chkUseNative = new wxCheckBox(panel, Id_Check_UseNativeHeader,
1935 "&Use native header");
1936 m_chkUseNative->SetValue(true);
1937 sizerStyles->Add(m_chkUseNative, wxSizerFlags().Border());
1938
1939 m_chkDrawNative = new wxCheckBox(panel, Id_Check_DrawNativeLabels,
1940 "&Draw native column labels");
1941 sizerStyles->Add(m_chkDrawNative, wxSizerFlags().Border());
1942
1943 m_chkShowRowLabels = new wxCheckBox(panel, Id_Check_ShowRowLabels,
1944 "Show &row labels");
1945 sizerStyles->Add(m_chkShowRowLabels, wxSizerFlags().Border());
1946
1947 m_chkEnableColMove = new wxCheckBox(panel, Id_Check_EnableColMove,
1948 "Allow column re&ordering");
1949 m_chkEnableColMove->SetValue(true);
1950 sizerStyles->Add(m_chkEnableColMove, wxSizerFlags().Border());
1951 sizerControls->Add(sizerStyles);
1952
1953 sizerControls->AddSpacer(10);
1954
1955 wxSizer * const sizerColumns = new wxBoxSizer(wxVERTICAL);
1956 wxSizer * const sizerMoveCols = new wxBoxSizer(wxHORIZONTAL);
1957 const wxSizerFlags
1958 flagsHorz(wxSizerFlags().Border(wxLEFT | wxRIGHT).Centre());
1959 sizerMoveCols->Add(new wxStaticText(panel, wxID_ANY, "&Move column"),
1960 flagsHorz);
1961 m_txtColIndex = new ColIndexEntry(panel);
1962 sizerMoveCols->Add(m_txtColIndex, flagsHorz);
1963 sizerMoveCols->Add(new wxStaticText(panel, wxID_ANY, "&to"), flagsHorz);
1964 m_txtColPos = new ColIndexEntry(panel);
1965 sizerMoveCols->Add(m_txtColPos, flagsHorz);
1966 sizerMoveCols->Add(new wxButton(panel, wxID_APPLY), flagsHorz);
1967
1968 sizerColumns->Add(sizerMoveCols, wxSizerFlags().Expand().Border(wxBOTTOM));
1969
1970 wxSizer * const sizerShowCols = new wxBoxSizer(wxHORIZONTAL);
1971 sizerShowCols->Add(new wxStaticText(panel, wxID_ANY, "Current order:"),
1972 flagsHorz);
1973 m_statOrder = new wxStaticText(panel, wxID_ANY, "<<< default >>>");
1974 sizerShowCols->Add(m_statOrder, flagsHorz);
1975 sizerShowCols->Add(new wxButton(panel, wxID_RESET, "&Reset order"));
1976 sizerColumns->Add(sizerShowCols, wxSizerFlags().Expand().Border(wxTOP));
1977
1978 wxSizer * const sizerShowHide = new wxBoxSizer(wxHORIZONTAL);
1979 sizerShowHide->Add(new wxStaticText(panel, wxID_ANY, "Show/hide column:"),
1980 flagsHorz);
1981 m_txtColShowHide = new ColIndexEntry(panel);
1982 sizerShowHide->Add(m_txtColShowHide, flagsHorz);
1983 sizerShowHide->Add(new wxButton(panel, wxID_ADD, "&Show"), flagsHorz);
1984 sizerShowHide->Add(new wxButton(panel, wxID_DELETE, "&Hide"), flagsHorz);
1985 sizerColumns->Add(sizerShowHide, wxSizerFlags().Expand().Border(wxTOP));
1986
1987 sizerControls->Add(sizerColumns, wxSizerFlags(1).Expand().Border());
1988
1989 sizerTop->Add(sizerControls, wxSizerFlags().Expand().Border());
1990
1991 panel->SetSizer(sizerTop);
1992
1993 SetClientSize(panel->GetBestSize());
1994 SetSizeHints(GetSize());
1995
1996 Show();
1997 }
1998
1999 void GridFrame::OnTabularTable(wxCommandEvent&)
2000 {
2001 new TabularGridFrame;
2002 }