]> git.saurik.com Git - wxWidgets.git/blob - samples/dialogs/dialogs.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Allow using either single or multi line wxTextCtrl in keyboard sample.
[wxWidgets.git] / samples / dialogs / dialogs.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: dialogs.cpp
3 // Purpose: Common dialogs demo
4 // Author: Julian Smart, Vadim Zeitlin, ABX
5 // Created: 04/01/98
6 // RCS-ID: $Id$
7 // Copyright: (c) Julian Smart
8 // (c) 2004 ABX
9 // (c) Vadim Zeitlin
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 // For compilers that support precompilation, includes "wx/wx.h".
14 #include "wx/wxprec.h"
15
16 #ifdef __BORLANDC__
17 #pragma hdrstop
18 #endif
19
20 #ifndef WX_PRECOMP
21 #include "wx/wx.h"
22 #endif
23
24 #include "../sample.xpm"
25
26 #include "wx/apptrait.h"
27 #include "wx/datetime.h"
28 #include "wx/image.h"
29 #include "wx/bookctrl.h"
30 #include "wx/artprov.h"
31 #include "wx/imaglist.h"
32 #include "wx/minifram.h"
33 #include "wx/sysopt.h"
34 #include "wx/notifmsg.h"
35
36 #if wxUSE_RICHMSGDLG
37 #include "wx/richmsgdlg.h"
38 #endif // wxUSE_RICHMSGDLG
39
40 #if wxUSE_COLOURDLG
41 #include "wx/colordlg.h"
42 #endif // wxUSE_COLOURDLG
43
44 #if wxUSE_CHOICEDLG
45 #include "wx/choicdlg.h"
46 #endif // wxUSE_CHOICEDLG
47
48 #include "wx/rearrangectrl.h"
49
50 #if wxUSE_STARTUP_TIPS
51 #include "wx/tipdlg.h"
52 #endif // wxUSE_STARTUP_TIPS
53
54 #if wxUSE_PROGRESSDLG
55 #if wxUSE_STOPWATCH && wxUSE_LONGLONG
56 #include "wx/datetime.h" // wxDateTime
57 #endif
58
59 #include "wx/progdlg.h"
60 #endif // wxUSE_PROGRESSDLG
61
62 #if wxUSE_ABOUTDLG
63 #include "wx/aboutdlg.h"
64
65 // these headers are only needed for custom about dialog
66 #include "wx/statline.h"
67 #include "wx/generic/aboutdlgg.h"
68 #endif // wxUSE_ABOUTDLG
69
70 #if wxUSE_BUSYINFO
71 #include "wx/busyinfo.h"
72 #endif // wxUSE_BUSYINFO
73
74 #if wxUSE_NUMBERDLG
75 #include "wx/numdlg.h"
76 #endif // wxUSE_NUMBERDLG
77
78 #if wxUSE_FILEDLG
79 #include "wx/filedlg.h"
80 #endif // wxUSE_FILEDLG
81
82 #if wxUSE_DIRDLG
83 #include "wx/dirdlg.h"
84 #endif // wxUSE_DIRDLG
85
86 #if wxUSE_FONTDLG
87 #include "wx/fontdlg.h"
88 #endif // wxUSE_FONTDLG
89
90 #if wxUSE_FINDREPLDLG
91 #include "wx/fdrepdlg.h"
92 #endif // wxUSE_FINDREPLDLG
93
94 #if wxUSE_INFOBAR
95 #include "wx/infobar.h"
96 #endif // wxUSE_INFOBAR
97
98 #include "wx/spinctrl.h"
99 #include "wx/propdlg.h"
100
101 #include "dialogs.h"
102
103 #if USE_COLOURDLG_GENERIC
104 #include "wx/generic/colrdlgg.h"
105 #endif // USE_COLOURDLG_GENERIC
106
107 #if USE_DIRDLG_GENERIC
108 #include "wx/generic/dirdlgg.h"
109 #endif // USE_DIRDLG_GENERIC
110
111 #if USE_FILEDLG_GENERIC
112 #include "wx/generic/filedlgg.h"
113 #endif // USE_FILEDLG_GENERIC
114
115 #if USE_FONTDLG_GENERIC
116 #include "wx/generic/fontdlgg.h"
117 #endif // USE_FONTDLG_GENERIC
118
119 IMPLEMENT_APP(MyApp)
120
121 BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
122 EVT_PAINT(MyCanvas::OnPaint)
123 END_EVENT_TABLE()
124
125
126
127 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
128 #if wxUSE_MSGDLG
129 EVT_MENU(DIALOGS_MESSAGE_BOX, MyFrame::MessageBox)
130 EVT_MENU(DIALOGS_MESSAGE_BOX_WINDOW_MODAL, MyFrame::MessageBoxWindowModal)
131 EVT_MENU(DIALOGS_MESSAGE_DIALOG, MyFrame::MessageBoxDialog)
132 EVT_MENU(DIALOGS_MESSAGE_BOX_WXINFO, MyFrame::MessageBoxInfo)
133 #endif // wxUSE_MSGDLG
134 #if wxUSE_RICHMSGDLG
135 EVT_MENU(DIALOGS_RICH_MESSAGE_DIALOG, MyFrame::RichMessageDialog)
136 #endif // wxUSE_RICHMSGDLG
137 #if wxUSE_COLOURDLG
138 EVT_MENU(DIALOGS_CHOOSE_COLOUR, MyFrame::ChooseColour)
139 EVT_MENU(DIALOGS_GET_COLOUR, MyFrame::GetColour)
140 #endif // wxUSE_COLOURDLG
141
142 #if wxUSE_FONTDLG
143 EVT_MENU(DIALOGS_CHOOSE_FONT, MyFrame::ChooseFont)
144 #endif // wxUSE_FONTDLG
145
146 #if wxUSE_LOG_DIALOG
147 EVT_MENU(DIALOGS_LOG_DIALOG, MyFrame::LogDialog)
148 #endif // wxUSE_LOG_DIALOG
149 #if wxUSE_INFOBAR
150 EVT_MENU(DIALOGS_INFOBAR_SIMPLE, MyFrame::InfoBarSimple)
151 EVT_MENU(DIALOGS_INFOBAR_ADVANCED, MyFrame::InfoBarAdvanced)
152 #endif // wxUSE_INFOBAR
153
154 #if wxUSE_TEXTDLG
155 EVT_MENU(DIALOGS_LINE_ENTRY, MyFrame::LineEntry)
156 EVT_MENU(DIALOGS_TEXT_ENTRY, MyFrame::TextEntry)
157 EVT_MENU(DIALOGS_PASSWORD_ENTRY, MyFrame::PasswordEntry)
158 #endif // wxUSE_TEXTDLG
159
160 #if wxUSE_NUMBERDLG
161 EVT_MENU(DIALOGS_NUM_ENTRY, MyFrame::NumericEntry)
162 #endif // wxUSE_NUMBERDLG
163
164 #if wxUSE_CHOICEDLG
165 EVT_MENU(DIALOGS_SINGLE_CHOICE, MyFrame::SingleChoice)
166 EVT_MENU(DIALOGS_MULTI_CHOICE, MyFrame::MultiChoice)
167 #endif // wxUSE_CHOICEDLG
168
169 #if wxUSE_REARRANGECTRL
170 EVT_MENU(DIALOGS_REARRANGE, MyFrame::Rearrange)
171 #endif // wxUSE_REARRANGECTRL
172
173 #if wxUSE_FILEDLG
174 EVT_MENU(DIALOGS_FILE_OPEN, MyFrame::FileOpen)
175 EVT_MENU(DIALOGS_FILE_OPEN2, MyFrame::FileOpen2)
176 EVT_MENU(DIALOGS_FILES_OPEN, MyFrame::FilesOpen)
177 EVT_MENU(DIALOGS_FILE_SAVE, MyFrame::FileSave)
178 #endif // wxUSE_FILEDLG
179
180 #if USE_FILEDLG_GENERIC
181 EVT_MENU(DIALOGS_FILE_OPEN_GENERIC, MyFrame::FileOpenGeneric)
182 EVT_MENU(DIALOGS_FILES_OPEN_GENERIC, MyFrame::FilesOpenGeneric)
183 EVT_MENU(DIALOGS_FILE_SAVE_GENERIC, MyFrame::FileSaveGeneric)
184 #endif // USE_FILEDLG_GENERIC
185
186 #if wxUSE_DIRDLG
187 EVT_MENU(DIALOGS_DIR_CHOOSE, MyFrame::DirChoose)
188 EVT_MENU(DIALOGS_DIRNEW_CHOOSE, MyFrame::DirChooseNew)
189 #endif // wxUSE_DIRDLG
190
191 #if USE_MODAL_PRESENTATION
192 EVT_MENU(DIALOGS_MODAL, MyFrame::ModalDlg)
193 #endif // USE_MODAL_PRESENTATION
194 EVT_MENU(DIALOGS_MODELESS, MyFrame::ModelessDlg)
195 EVT_MENU(DIALOGS_CENTRE_SCREEN, MyFrame::DlgCenteredScreen)
196 EVT_MENU(DIALOGS_CENTRE_PARENT, MyFrame::DlgCenteredParent)
197 #if wxUSE_MINIFRAME
198 EVT_MENU(DIALOGS_MINIFRAME, MyFrame::MiniFrame)
199 #endif // wxUSE_MINIFRAME
200 EVT_MENU(DIALOGS_ONTOP, MyFrame::DlgOnTop)
201
202 #if wxUSE_STARTUP_TIPS
203 EVT_MENU(DIALOGS_TIP, MyFrame::ShowTip)
204 #endif // wxUSE_STARTUP_TIPS
205
206 #if USE_FONTDLG_GENERIC
207 EVT_MENU(DIALOGS_CHOOSE_FONT_GENERIC, MyFrame::ChooseFontGeneric)
208 #endif // USE_FONTDLG_GENERIC
209
210 #if USE_DIRDLG_GENERIC
211 EVT_MENU(DIALOGS_GENERIC_DIR_CHOOSE, MyFrame::GenericDirChoose)
212 #endif // wxMSW || wxMAC
213
214 #if USE_COLOURDLG_GENERIC
215 EVT_MENU(DIALOGS_CHOOSE_COLOUR_GENERIC, MyFrame::ChooseColourGeneric)
216 #endif // USE_COLOURDLG_GENERIC
217
218 #if wxUSE_PROGRESSDLG
219 EVT_MENU(DIALOGS_PROGRESS, MyFrame::ShowProgress)
220 #endif // wxUSE_PROGRESSDLG
221
222 #if wxUSE_ABOUTDLG
223 EVT_MENU(DIALOGS_ABOUTDLG_SIMPLE, MyFrame::ShowSimpleAboutDialog)
224 EVT_MENU(DIALOGS_ABOUTDLG_FANCY, MyFrame::ShowFancyAboutDialog)
225 EVT_MENU(DIALOGS_ABOUTDLG_FULL, MyFrame::ShowFullAboutDialog)
226 EVT_MENU(DIALOGS_ABOUTDLG_CUSTOM, MyFrame::ShowCustomAboutDialog)
227 #endif // wxUSE_ABOUTDLG
228
229 #if wxUSE_BUSYINFO
230 EVT_MENU(DIALOGS_BUSYINFO, MyFrame::ShowBusyInfo)
231 #endif // wxUSE_BUSYINFO
232
233 #if wxUSE_FINDREPLDLG
234 EVT_MENU(DIALOGS_FIND, MyFrame::ShowFindDialog)
235 EVT_MENU(DIALOGS_REPLACE, MyFrame::ShowReplaceDialog)
236
237 EVT_FIND(wxID_ANY, MyFrame::OnFindDialog)
238 EVT_FIND_NEXT(wxID_ANY, MyFrame::OnFindDialog)
239 EVT_FIND_REPLACE(wxID_ANY, MyFrame::OnFindDialog)
240 EVT_FIND_REPLACE_ALL(wxID_ANY, MyFrame::OnFindDialog)
241 EVT_FIND_CLOSE(wxID_ANY, MyFrame::OnFindDialog)
242 #endif // wxUSE_FINDREPLDLG
243
244 #if USE_SETTINGS_DIALOG
245 EVT_MENU(DIALOGS_PROPERTY_SHEET, MyFrame::OnPropertySheet)
246 EVT_MENU(DIALOGS_PROPERTY_SHEET_TOOLBOOK, MyFrame::OnPropertySheet)
247 EVT_MENU(DIALOGS_PROPERTY_SHEET_BUTTONTOOLBOOK, MyFrame::OnPropertySheet)
248 #endif // USE_SETTINGS_DIALOG
249
250 EVT_MENU(DIALOGS_STANDARD_BUTTON_SIZER_DIALOG, MyFrame::OnStandardButtonsSizerDialog)
251 EVT_MENU(DIALOGS_TEST_DEFAULT_ACTION, MyFrame::OnTestDefaultActionDialog)
252
253 EVT_MENU(DIALOGS_REQUEST, MyFrame::OnRequestUserAttention)
254 #if wxUSE_NOTIFICATION_MESSAGE
255 EVT_MENU(DIALOGS_NOTIFY_AUTO, MyFrame::OnNotifMsgAuto)
256 EVT_MENU(DIALOGS_NOTIFY_SHOW, MyFrame::OnNotifMsgShow)
257 EVT_MENU(DIALOGS_NOTIFY_HIDE, MyFrame::OnNotifMsgHide)
258 #endif // wxUSE_NOTIFICATION_MESSAGE
259
260 #if wxUSE_RICHTOOLTIP
261 EVT_MENU(DIALOGS_RICHTIP_DIALOG, MyFrame::OnRichTipDialog)
262 #endif // wxUSE_RICHTOOLTIP
263
264 EVT_MENU(wxID_EXIT, MyFrame::OnExit)
265 END_EVENT_TABLE()
266
267 #if USE_MODAL_PRESENTATION
268
269 BEGIN_EVENT_TABLE(MyModalDialog, wxDialog)
270 EVT_BUTTON(wxID_ANY, MyModalDialog::OnButton)
271 END_EVENT_TABLE()
272
273 BEGIN_EVENT_TABLE(MyModelessDialog, wxDialog)
274 EVT_BUTTON(DIALOGS_MODELESS_BTN, MyModelessDialog::OnButton)
275 EVT_CLOSE(MyModelessDialog::OnClose)
276 END_EVENT_TABLE()
277
278 #endif // USE_MODAL_PRESENTATION
279
280 BEGIN_EVENT_TABLE(StdButtonSizerDialog, wxDialog)
281 EVT_CHECKBOX(wxID_ANY, StdButtonSizerDialog::OnEvent)
282 EVT_RADIOBUTTON(wxID_ANY, StdButtonSizerDialog::OnEvent)
283 END_EVENT_TABLE()
284
285 #if wxUSE_CMDLINE_PARSER
286
287 #include "wx/cmdline.h"
288
289 static const char *PROGRESS_SWITCH = "progress";
290
291 void MyApp::OnInitCmdLine(wxCmdLineParser& parser)
292 {
293 wxApp::OnInitCmdLine(parser);
294
295 parser.AddOption("", PROGRESS_SWITCH,
296 "Style for the startup progress dialog (wxPD_XXX)",
297 wxCMD_LINE_VAL_NUMBER);
298 }
299
300 bool MyApp::OnCmdLineParsed(wxCmdLineParser& parser)
301 {
302 if ( !wxApp::OnCmdLineParsed(parser) )
303 return false;
304
305 parser.Found(PROGRESS_SWITCH, &m_startupProgressStyle);
306
307 return true;
308 }
309
310 #endif // wxUSE_CMDLINE_PARSER
311
312 // `Main program' equivalent, creating windows and returning main app frame
313 bool MyApp::OnInit()
314 {
315 if ( !wxApp::OnInit() )
316 return false;
317
318 #if wxUSE_PROGRESSDLG
319 if ( m_startupProgressStyle != -1 )
320 {
321 // Show a test progress dialog before the main event loop is started:
322 // it should still work.
323 const int PROGRESS_COUNT = 100;
324 wxProgressDialog dlg
325 (
326 "Progress in progress",
327 "Please wait, starting...",
328 PROGRESS_COUNT,
329 NULL,
330 m_startupProgressStyle
331 );
332 for ( int i = 0; i <= PROGRESS_COUNT; i++ )
333 {
334 if ( !dlg.Update(i) )
335 break;
336
337 wxMilliSleep(50);
338 }
339 }
340 #endif // wxUSE_PROGRESSDLG
341
342 #if wxUSE_IMAGE
343 wxInitAllImageHandlers();
344 #endif
345
346 // Create the main frame window
347 MyFrame *frame = new MyFrame(wxT("wxWidgets dialogs example"));
348
349 // Make a menubar
350 wxMenu *menuDlg = new wxMenu;
351
352 menuDlg->Append(DIALOGS_MESSAGE_BOX, wxT("&Message box\tCtrl-M"));
353 menuDlg->Append(DIALOGS_MESSAGE_BOX_WINDOW_MODAL, wxT("Window-Modal Message box "));
354 menuDlg->Append(DIALOGS_MESSAGE_DIALOG, wxT("Message dialog\tShift-Ctrl-M"));
355 #if wxUSE_RICHMSGDLG
356 menuDlg->Append(DIALOGS_RICH_MESSAGE_DIALOG, wxT("Rich message dialog"));
357 #endif // wxUSE_RICHMSGDLG
358
359
360 #if wxUSE_COLOURDLG || wxUSE_FONTDLG || wxUSE_CHOICEDLG
361
362 wxMenu *choices_menu = new wxMenu;
363
364 #if wxUSE_COLOURDLG
365 choices_menu->Append(DIALOGS_CHOOSE_COLOUR, wxT("&Choose bg colour"));
366 choices_menu->Append(DIALOGS_GET_COLOUR, wxT("&Choose fg colour"));
367 #endif // wxUSE_COLOURDLG
368
369 #if wxUSE_FONTDLG
370 choices_menu->Append(DIALOGS_CHOOSE_FONT, wxT("Choose &font"));
371 #endif // wxUSE_FONTDLG
372
373 #if wxUSE_CHOICEDLG
374 choices_menu->Append(DIALOGS_SINGLE_CHOICE, wxT("&Single choice\tCtrl-C"));
375 choices_menu->Append(DIALOGS_MULTI_CHOICE, wxT("M&ultiple choice\tCtrl-U"));
376 #endif // wxUSE_CHOICEDLG
377
378 #if wxUSE_REARRANGECTRL
379 choices_menu->Append(DIALOGS_REARRANGE, wxT("&Rearrange dialog\tCtrl-R"));
380 #endif // wxUSE_REARRANGECTRL
381
382 #if USE_COLOURDLG_GENERIC || USE_FONTDLG_GENERIC
383 choices_menu->AppendSeparator();
384 #endif // USE_COLOURDLG_GENERIC || USE_FONTDLG_GENERIC
385
386 #if USE_COLOURDLG_GENERIC
387 choices_menu->Append(DIALOGS_CHOOSE_COLOUR_GENERIC, wxT("&Choose colour (generic)"));
388 #endif // USE_COLOURDLG_GENERIC
389
390 #if USE_FONTDLG_GENERIC
391 choices_menu->Append(DIALOGS_CHOOSE_FONT_GENERIC, wxT("Choose &font (generic)"));
392 #endif // USE_FONTDLG_GENERIC
393
394 menuDlg->Append(wxID_ANY,wxT("&Choices and selectors"),choices_menu);
395 #endif // wxUSE_COLOURDLG || wxUSE_FONTDLG || wxUSE_CHOICEDLG
396
397
398 #if wxUSE_TEXTDLG || wxUSE_NUMBERDLG
399
400 wxMenu *entry_menu = new wxMenu;
401
402 #if wxUSE_TEXTDLG
403 entry_menu->Append(DIALOGS_LINE_ENTRY, wxT("Single line &entry\tCtrl-E"));
404 entry_menu->Append(DIALOGS_TEXT_ENTRY, wxT("Multi line text &entry\tShift-Ctrl-E"));
405 entry_menu->Append(DIALOGS_PASSWORD_ENTRY, wxT("&Password entry\tCtrl-P"));
406 #endif // wxUSE_TEXTDLG
407
408 #if wxUSE_NUMBERDLG
409 entry_menu->Append(DIALOGS_NUM_ENTRY, wxT("&Numeric entry\tCtrl-N"));
410 #endif // wxUSE_NUMBERDLG
411
412 menuDlg->Append(wxID_ANY,wxT("&Entry dialogs"),entry_menu);
413
414 #endif // wxUSE_TEXTDLG || wxUSE_NUMBERDLG
415
416
417 #if wxUSE_FILEDLG
418
419 wxMenu *filedlg_menu = new wxMenu;
420 filedlg_menu->Append(DIALOGS_FILE_OPEN, wxT("&Open file\tCtrl-O"));
421 filedlg_menu->Append(DIALOGS_FILE_OPEN2, wxT("&Second open file\tCtrl-2"));
422 filedlg_menu->Append(DIALOGS_FILES_OPEN, wxT("Open &files\tCtrl-Q"));
423 filedlg_menu->Append(DIALOGS_FILE_SAVE, wxT("Sa&ve file\tCtrl-S"));
424
425 #if USE_FILEDLG_GENERIC
426 filedlg_menu->AppendSeparator();
427 filedlg_menu->Append(DIALOGS_FILE_OPEN_GENERIC, wxT("&Open file (generic)"));
428 filedlg_menu->Append(DIALOGS_FILES_OPEN_GENERIC, wxT("Open &files (generic)"));
429 filedlg_menu->Append(DIALOGS_FILE_SAVE_GENERIC, wxT("Sa&ve file (generic)"));
430 #endif // USE_FILEDLG_GENERIC
431
432 menuDlg->Append(wxID_ANY,wxT("&File operations"),filedlg_menu);
433
434 #endif // wxUSE_FILEDLG
435
436 #if wxUSE_DIRDLG
437 wxMenu *dir_menu = new wxMenu;
438
439 dir_menu->Append(DIALOGS_DIR_CHOOSE, wxT("&Choose a directory\tCtrl-D"));
440 dir_menu->Append(DIALOGS_DIRNEW_CHOOSE, wxT("Choose a directory (with \"Ne&w\" button)\tShift-Ctrl-D"));
441 menuDlg->Append(wxID_ANY,wxT("&Directory operations"),dir_menu);
442
443 #if USE_DIRDLG_GENERIC
444 dir_menu->AppendSeparator();
445 dir_menu->Append(DIALOGS_GENERIC_DIR_CHOOSE, wxT("&Choose a directory (generic)"));
446 #endif // USE_DIRDLG_GENERIC
447
448 #endif // wxUSE_DIRDLG
449
450
451 #if wxUSE_STARTUP_TIPS || \
452 wxUSE_PROGRESSDLG || \
453 wxUSE_BUSYINFO || \
454 wxUSE_LOG_DIALOG || \
455 wxUSE_MSGDLG
456
457 wxMenu *info_menu = new wxMenu;
458
459 #if wxUSE_STARTUP_TIPS
460 info_menu->Append(DIALOGS_TIP, wxT("&Tip of the day\tCtrl-T"));
461 #endif // wxUSE_STARTUP_TIPS
462
463 #if wxUSE_PROGRESSDLG
464 info_menu->Append(DIALOGS_PROGRESS, wxT("Pro&gress dialog\tCtrl-G"));
465 #endif // wxUSE_PROGRESSDLG
466
467 #if wxUSE_BUSYINFO
468 info_menu->Append(DIALOGS_BUSYINFO, wxT("&Busy info dialog\tCtrl-B"));
469 #endif // wxUSE_BUSYINFO
470
471 #if wxUSE_LOG_DIALOG
472 info_menu->Append(DIALOGS_LOG_DIALOG, wxT("&Log dialog\tCtrl-L"));
473 #endif // wxUSE_LOG_DIALOG
474
475 #if wxUSE_INFOBAR
476 info_menu->Append(DIALOGS_INFOBAR_SIMPLE, "Simple &info bar\tCtrl-I");
477 info_menu->Append(DIALOGS_INFOBAR_ADVANCED, "&Advanced info bar\tShift-Ctrl-I");
478 #endif // wxUSE_INFOBAR
479
480 #if wxUSE_MSGDLG
481 info_menu->Append(DIALOGS_MESSAGE_BOX_WXINFO,
482 wxT("&wxWidgets information\tCtrl-W"));
483 #endif // wxUSE_MSGDLG
484
485 menuDlg->Append(wxID_ANY,wxT("&Informative dialogs"),info_menu);
486
487 #endif // wxUSE_STARTUP_TIPS || wxUSE_PROGRESSDLG || wxUSE_BUSYINFO || wxUSE_LOG_DIALOG
488
489
490 #if wxUSE_FINDREPLDLG
491 wxMenu *find_menu = new wxMenu;
492 find_menu->AppendCheckItem(DIALOGS_FIND, wxT("&Find dialog\tCtrl-F"));
493 find_menu->AppendCheckItem(DIALOGS_REPLACE, wxT("Find and &replace dialog\tShift-Ctrl-F"));
494 menuDlg->Append(wxID_ANY,wxT("&Searching"),find_menu);
495 #endif // wxUSE_FINDREPLDLG
496
497 wxMenu *dialogs_menu = new wxMenu;
498 #if USE_MODAL_PRESENTATION
499 dialogs_menu->Append(DIALOGS_MODAL, wxT("&Modal dialog\tShift-Ctrl-W"));
500 #endif // USE_MODAL_PRESENTATION
501 dialogs_menu->AppendCheckItem(DIALOGS_MODELESS, wxT("Mode&less dialog\tShift-Ctrl-Z"));
502 dialogs_menu->Append(DIALOGS_CENTRE_SCREEN, wxT("Centered on &screen\tShift-Ctrl-1"));
503 dialogs_menu->Append(DIALOGS_CENTRE_PARENT, wxT("Centered on &parent\tShift-Ctrl-2"));
504 #if wxUSE_MINIFRAME
505 dialogs_menu->Append(DIALOGS_MINIFRAME, wxT("&Mini frame"));
506 #endif // wxUSE_MINIFRAME
507 dialogs_menu->Append(DIALOGS_ONTOP, wxT("Dialog staying on &top"));
508 menuDlg->Append(wxID_ANY, wxT("&Generic dialogs"), dialogs_menu);
509
510 #if USE_SETTINGS_DIALOG
511 wxMenu *sheet_menu = new wxMenu;
512 sheet_menu->Append(DIALOGS_PROPERTY_SHEET, wxT("&Standard property sheet\tShift-Ctrl-P"));
513 sheet_menu->Append(DIALOGS_PROPERTY_SHEET_TOOLBOOK, wxT("&Toolbook sheet\tShift-Ctrl-T"));
514
515 if (wxPlatformIs(wxPORT_MAC))
516 sheet_menu->Append(DIALOGS_PROPERTY_SHEET_BUTTONTOOLBOOK, wxT("Button &Toolbook sheet\tShift-Ctrl-U"));
517 /*
518 #ifdef __WXMAC__
519 sheet_menu->Append(DIALOGS_PROPERTY_SHEET_BUTTONTOOLBOOK, wxT("Button &Toolbook sheet\tShift-Ctrl-U"));
520 #endif
521 */
522 menuDlg->Append(wxID_ANY, wxT("&Property sheets"), sheet_menu);
523 #endif // USE_SETTINGS_DIALOG
524
525 wxMenu *menuNotif = new wxMenu;
526 menuNotif->Append(DIALOGS_REQUEST, wxT("&Request user attention\tCtrl-Shift-R"));
527 #if wxUSE_NOTIFICATION_MESSAGE
528 menuNotif->Append(DIALOGS_NOTIFY_AUTO, "&Automatically hidden notification");
529 menuNotif->Append(DIALOGS_NOTIFY_SHOW, "&Show manual notification");
530 menuNotif->Append(DIALOGS_NOTIFY_HIDE, "&Hide manual notification");
531 #endif // wxUSE_NOTIFICATION_MESSAGE
532 menuDlg->AppendSubMenu(menuNotif, "&User notifications");
533
534 #if wxUSE_RICHTOOLTIP
535 menuDlg->Append(DIALOGS_RICHTIP_DIALOG, "Rich &tooltip dialog...\tCtrl-H");
536 menuDlg->AppendSeparator();
537 #endif // wxUSE_RICHTOOLTIP
538
539 menuDlg->Append(DIALOGS_STANDARD_BUTTON_SIZER_DIALOG, wxT("&Standard Buttons Sizer Dialog"));
540 menuDlg->Append(DIALOGS_TEST_DEFAULT_ACTION, wxT("&Test dialog default action"));
541
542 menuDlg->AppendSeparator();
543 menuDlg->Append(wxID_EXIT, wxT("E&xit\tAlt-X"));
544
545 #if wxUSE_ABOUTDLG
546 wxMenu *menuHelp = new wxMenu;
547 menuHelp->Append(DIALOGS_ABOUTDLG_SIMPLE, wxT("&About (simple)...\tF1"));
548 menuHelp->Append(DIALOGS_ABOUTDLG_FANCY, wxT("About (&fancy)...\tShift-F1"));
549 menuHelp->Append(DIALOGS_ABOUTDLG_FULL, wxT("About (f&ull)...\tCtrl-F1"));
550 menuHelp->Append(DIALOGS_ABOUTDLG_CUSTOM, wxT("About (&custom)...\tCtrl-Shift-F1"));
551 #endif // wxUSE_ABOUTDLG
552
553 wxMenu* editMenu = new wxMenu;
554 editMenu->Append(wxID_UNDO, _("&Undo\tCtrl+Z"));
555 editMenu->Append(wxID_REDO, _("&Redo\tCtrl+Y"));
556 editMenu->AppendSeparator();
557 editMenu->Append(wxID_CUT, _("Cu&t\tCtrl+X"));
558 editMenu->Append(wxID_COPY, _("&Copy\tCtrl+C"));
559 editMenu->Append(wxID_PASTE, _("&Paste\tCtrl+V"));
560 editMenu->Append(wxID_CLEAR, _("&Delete"));
561
562 editMenu->AppendSeparator();
563 editMenu->Append(wxID_SELECTALL, _("Select All\tCtrl+A"));
564
565 wxMenuBar *menubar = new wxMenuBar;
566 menubar->Append(menuDlg, wxT("&Dialogs"));
567
568 menubar->Append(editMenu, wxT("&Edit"));
569
570 #if wxUSE_ABOUTDLG
571 menubar->Append(menuHelp, wxT("&Help"));
572 #endif // wxUSE_ABOUTDLG
573
574 frame->SetMenuBar(menubar);
575
576 frame->Centre(wxBOTH);
577 frame->Show(true);
578
579 return true;
580 }
581
582 // My frame constructor
583 MyFrame::MyFrame(const wxString& title)
584 : wxFrame(NULL, wxID_ANY, title)
585 {
586 SetIcon(wxICON(sample));
587
588 #if USE_MODAL_PRESENTATION
589 m_dialog = (MyModelessDialog *)NULL;
590 #endif // USE_MODAL_PRESENTATION
591
592 #if wxUSE_FINDREPLDLG
593 m_dlgFind =
594 m_dlgReplace = NULL;
595 #endif
596
597 #if wxUSE_COLOURDLG
598 m_clrData.SetChooseFull(true);
599 for (int i = 0; i < wxColourData::NUM_CUSTOM; i++)
600 {
601 unsigned char n = i*16;
602 m_clrData.SetCustomColour(i, wxColour(n, n, n));
603 }
604 #endif // wxUSE_COLOURDLG
605
606 #if wxUSE_NOTIFICATION_MESSAGE
607 m_notifMsg = NULL;
608 #endif // wxUSE_NOTIFICATION_MESSAGE
609
610 #if wxUSE_STATUSBAR
611 CreateStatusBar();
612 #endif // wxUSE_STATUSBAR
613
614 m_canvas = new MyCanvas(this);
615
616 #if wxUSE_INFOBAR
617 // an info bar can be created very simply and used without any extra effort
618 m_infoBarSimple = new wxInfoBar(this);
619
620 // or it can also be customized by
621 m_infoBarAdvanced = new wxInfoBar(this);
622
623 // ... adding extra buttons (but more than two will usually be too many)
624 m_infoBarAdvanced->AddButton(wxID_UNDO);
625 m_infoBarAdvanced->AddButton(wxID_REDO);
626
627 m_infoBarAdvanced->Connect(wxID_REDO, wxEVT_COMMAND_BUTTON_CLICKED,
628 wxCommandEventHandler(MyFrame::OnInfoBarRedo),
629 NULL,
630 this);
631
632 // adding and removing a button immediately doesn't make sense here, of
633 // course, it's done just to show that it is possible
634 m_infoBarAdvanced->AddButton(wxID_EXIT);
635 m_infoBarAdvanced->RemoveButton(wxID_EXIT);
636
637 // ... changing the colours and/or fonts
638 m_infoBarAdvanced->SetOwnBackgroundColour(0xc8ffff);
639 m_infoBarAdvanced->SetFont(GetFont().Bold().Larger());
640
641 // ... and changing the effect (only does anything under MSW currently)
642 m_infoBarAdvanced->SetShowHideEffects(wxSHOW_EFFECT_EXPAND,
643 wxSHOW_EFFECT_EXPAND);
644 m_infoBarAdvanced->SetEffectDuration(1500);
645
646
647 // to use the info bars we need to use sizer for the window layout
648 wxBoxSizer * const sizer = new wxBoxSizer(wxVERTICAL);
649 sizer->Add(m_infoBarSimple, wxSizerFlags().Expand());
650 sizer->Add(m_canvas, wxSizerFlags(1).Expand());
651 sizer->Add(m_infoBarAdvanced, wxSizerFlags().Expand());
652 SetSizer(sizer);
653
654 // final touch: under MSW the info bars are shown progressively and parts
655 // of the parent window can be seen during the process, so use the same
656 // background colour for our background as for the canvas window which
657 // covers our entire client area to avoid jarring colour jumps
658 SetOwnBackgroundColour(m_canvas->GetBackgroundColour());
659 #endif // wxUSE_INFOBAR
660
661 #ifdef __WXMSW__
662 // Test MSW-specific function allowing to access the "system" menu.
663 wxMenu * const menu = MSWGetSystemMenu();
664 if ( menu )
665 {
666 menu->AppendSeparator();
667
668 // The ids of the menu commands in MSW system menu must be multiple of
669 // 16 so we can't use DIALOGS_ABOUTDLG_SIMPLE here because it might not
670 // satisfy this condition and need to define and connect a separate id.
671 static const int DIALOGS_SYSTEM_ABOUT = 0x4010;
672
673 menu->Append(DIALOGS_SYSTEM_ABOUT, "&About");
674 Connect(DIALOGS_SYSTEM_ABOUT, wxEVT_COMMAND_MENU_SELECTED,
675 wxCommandEventHandler(MyFrame::ShowSimpleAboutDialog));
676 }
677 #endif // __WXMSW__
678 }
679
680 MyFrame::~MyFrame()
681 {
682 #if wxUSE_NOTIFICATION_MESSAGE
683 delete m_notifMsg;
684 #endif // wxUSE_NOTIFICATION_MESSAGE
685 }
686
687 #if wxUSE_COLOURDLG
688
689 void MyFrame::ChooseColour(wxCommandEvent& WXUNUSED(event))
690 {
691 m_clrData.SetColour(m_canvas->GetBackgroundColour());
692
693 wxColourDialog dialog(this, &m_clrData);
694 dialog.SetTitle(_("Please choose the background colour"));
695 if ( dialog.ShowModal() == wxID_OK )
696 {
697 m_clrData = dialog.GetColourData();
698 m_canvas->SetBackgroundColour(m_clrData.GetColour());
699 m_canvas->ClearBackground();
700 m_canvas->Refresh();
701 }
702 }
703
704 void MyFrame::GetColour(wxCommandEvent& WXUNUSED(event))
705 {
706 wxColour clr = wxGetColourFromUser
707 (
708 this,
709 m_canvas->GetForegroundColour(),
710 "Please choose the foreground colour"
711 );
712 if ( clr.IsOk() )
713 {
714 m_canvas->SetForegroundColour(clr);
715 m_canvas->Refresh();
716 }
717 //else: dialog cancelled by user
718 }
719
720 #endif // wxUSE_COLOURDLG
721
722
723 #if USE_COLOURDLG_GENERIC
724 void MyFrame::ChooseColourGeneric(wxCommandEvent& WXUNUSED(event))
725 {
726 m_clrData.SetColour(m_canvas->GetBackgroundColour());
727
728 //FIXME:TODO:This has no effect...
729 m_clrData.SetChooseFull(true);
730
731 for (int i = 0; i < 16; i++)
732 {
733 wxColour colour(
734 (unsigned char)(i*16),
735 (unsigned char)(i*16),
736 (unsigned char)(i*16)
737 );
738 m_clrData.SetCustomColour(i, colour);
739 }
740
741 wxGenericColourDialog *dialog = new wxGenericColourDialog(this, &m_clrData);
742 if (dialog->ShowModal() == wxID_OK)
743 {
744 m_clrData = dialog->GetColourData();
745 m_canvas->SetBackgroundColour(m_clrData.GetColour());
746 m_canvas->ClearBackground();
747 m_canvas->Refresh();
748 }
749 dialog->Destroy();
750 }
751 #endif // USE_COLOURDLG_GENERIC
752
753 #if wxUSE_FONTDLG
754 void MyFrame::ChooseFont(wxCommandEvent& WXUNUSED(event) )
755 {
756 wxFontData data;
757 data.SetInitialFont(m_canvas->GetFont());
758 data.SetColour(m_canvas->GetForegroundColour());
759
760 // you might also do this:
761 //
762 // wxFontDialog dialog;
763 // if ( !dialog.Create(this, data) { ... error ... }
764 //
765 wxFontDialog dialog(this, data);
766
767 if (dialog.ShowModal() == wxID_OK)
768 {
769 wxFontData retData = dialog.GetFontData();
770 m_canvas->SetFont(retData.GetChosenFont());
771 m_canvas->SetForegroundColour(retData.GetColour());
772 m_canvas->Refresh();
773 }
774 //else: cancelled by the user, don't change the font
775 }
776 #endif // wxUSE_FONTDLG
777
778 #if USE_FONTDLG_GENERIC
779 void MyFrame::ChooseFontGeneric(wxCommandEvent& WXUNUSED(event) )
780 {
781 wxFontData data;
782 data.SetInitialFont(m_canvas->GetFont());
783 data.SetColour(m_canvas->GetForegroundColour());
784
785 wxGenericFontDialog *dialog = new wxGenericFontDialog(this, data);
786 if (dialog->ShowModal() == wxID_OK)
787 {
788 wxFontData retData = dialog->GetFontData();
789 m_canvas->SetFont(retData.GetChosenFont());
790 m_canvas->SetForegroundColour(retData.GetColour());
791 m_canvas->Refresh();
792 }
793 dialog->Destroy();
794 }
795 #endif // USE_FONTDLG_GENERIC
796
797 #if wxUSE_LOG_DIALOG
798 void MyFrame::LogDialog(wxCommandEvent& WXUNUSED(event))
799 {
800 // calling wxYield() (as ~wxBusyCursor does) shouldn't result in messages
801 // being flushed -- test it
802 {
803 wxBusyCursor bc;
804 wxLogMessage(wxT("This is some message - everything is ok so far."));
805 wxLogMessage(wxT("Another message...\n... this one is on multiple lines"));
806 wxLogWarning(wxT("And then something went wrong!"));
807
808 // and if ~wxBusyCursor doesn't do it, then call it manually
809 wxYield();
810 }
811
812 wxLogError(wxT("Intermediary error handler decided to abort."));
813 wxLogError(wxT("The top level caller detected an unrecoverable error."));
814
815 wxLog::FlushActive();
816
817 wxLogMessage(wxT("And this is the same dialog but with only one message."));
818 }
819 #endif // wxUSE_LOG_DIALOG
820
821 #if wxUSE_INFOBAR
822
823 void MyFrame::InfoBarSimple(wxCommandEvent& WXUNUSED(event))
824 {
825 static int s_count = 0;
826 m_infoBarSimple->ShowMessage
827 (
828 wxString::Format("Message #%d in the info bar.", ++s_count)
829 );
830 }
831
832 void MyFrame::InfoBarAdvanced(wxCommandEvent& WXUNUSED(event))
833 {
834 m_infoBarAdvanced->ShowMessage("Sorry, it didn't work out.", wxICON_WARNING);
835 }
836
837 void MyFrame::OnInfoBarRedo(wxCommandEvent& WXUNUSED(event))
838 {
839 m_infoBarAdvanced->ShowMessage("Still no, sorry again.", wxICON_ERROR);
840 }
841
842 #endif // wxUSE_INFOBAR
843
844
845 #if wxUSE_MSGDLG
846 void MyFrame::MessageBox(wxCommandEvent& WXUNUSED(event))
847 {
848 wxMessageDialog dialog(this,
849 "This is a message box\n"
850 "This is a long, long string to test out if the message box "
851 "is laid out properly.",
852 "Message box text",
853 wxCENTER |
854 wxNO_DEFAULT | wxYES_NO | wxCANCEL |
855 wxICON_INFORMATION);
856
857 wxString extmsg;
858 if ( dialog.SetYesNoCancelLabels
859 (
860 "Answer &Yes",
861 "Answer &No",
862 "Refuse to answer"
863 ) )
864 {
865 extmsg = "This platform supports custom button labels,\n"
866 "so you should see the descriptive labels below.";
867 }
868 else
869 {
870 extmsg = "Custom button labels are not supported on this platform,\n"
871 "so the default \"Yes\"/\"No\"/\"Cancel\" buttons are used.";
872 }
873 dialog.SetExtendedMessage(extmsg);
874
875 switch ( dialog.ShowModal() )
876 {
877 case wxID_YES:
878 wxLogStatus(wxT("You pressed \"Yes\""));
879 break;
880
881 case wxID_NO:
882 wxLogStatus(wxT("You pressed \"No\""));
883 break;
884
885 case wxID_CANCEL:
886 wxLogStatus(wxT("You pressed \"Cancel\""));
887 break;
888
889 default:
890 wxLogError(wxT("Unexpected wxMessageDialog return code!"));
891 }
892 }
893
894 void MyFrame::MessageBoxWindowModal(wxCommandEvent& WXUNUSED(event))
895 {
896 wxMessageDialog* dialog = new wxMessageDialog(this,
897 "This is a message box\n"
898 "This is a long, long string to test out if the message box "
899 "is laid out properly.",
900 "Message box text",
901 wxCENTER |
902 wxNO_DEFAULT | wxYES_NO | wxCANCEL |
903 wxICON_INFORMATION);
904
905 wxString extmsg;
906 if ( dialog->SetYesNoCancelLabels
907 (
908 "Answer &Yes",
909 "Answer &No",
910 "Refuse to answer"
911 ) )
912 {
913 extmsg = "This platform supports custom button labels,\n"
914 "so you should see the descriptive labels below.";
915 }
916 else
917 {
918 extmsg = "Custom button labels are not supported on this platform,\n"
919 "so the default \"Yes\"/\"No\"/\"Cancel\" buttons are used.";
920 }
921 dialog->SetExtendedMessage(extmsg);
922 dialog->Connect( wxEVT_WINDOW_MODAL_DIALOG_CLOSED, wxWindowModalDialogEventHandler(MyFrame::MessageBoxWindowModalClosed), NULL, this );
923 dialog->ShowWindowModal();
924 }
925
926 void MyFrame::MessageBoxWindowModalClosed(wxWindowModalDialogEvent& event)
927 {
928 wxDialog* dialog = event.GetDialog();
929 switch ( dialog->GetReturnCode() )
930 {
931 case wxID_YES:
932 wxLogStatus(wxT("You pressed \"Yes\""));
933 break;
934
935 case wxID_NO:
936 wxLogStatus(wxT("You pressed \"No\""));
937 break;
938
939 case wxID_CANCEL:
940 wxLogStatus(wxT("You pressed \"Cancel\""));
941 break;
942
943 default:
944 wxLogError(wxT("Unexpected wxMessageDialog return code!"));
945 }
946 delete dialog;
947 }
948
949 void MyFrame::MessageBoxDialog(wxCommandEvent& WXUNUSED(event))
950 {
951 TestMessageBoxDialog dlg(this);
952 dlg.Create();
953 dlg.ShowModal();
954 }
955
956 void MyFrame::MessageBoxInfo(wxCommandEvent& WXUNUSED(event))
957 {
958 ::wxInfoMessageBox(this);
959 }
960 #endif // wxUSE_MSGDLG
961
962 #if wxUSE_RICHMSGDLG
963 void MyFrame::RichMessageDialog(wxCommandEvent& WXUNUSED(event))
964 {
965 TestRichMessageDialog dlg(this);
966 dlg.Create();
967 dlg.ShowModal();
968 }
969 #endif // wxUSE_RICHMSGDLG
970
971 #if wxUSE_NUMBERDLG
972 void MyFrame::NumericEntry(wxCommandEvent& WXUNUSED(event))
973 {
974 long res = wxGetNumberFromUser( wxT("This is some text, actually a lot of text.\n")
975 wxT("Even two rows of text."),
976 wxT("Enter a number:"), wxT("Numeric input test"),
977 50, 0, 100, this );
978
979 wxString msg;
980 int icon;
981 if ( res == -1 )
982 {
983 msg = wxT("Invalid number entered or dialog cancelled.");
984 icon = wxICON_HAND;
985 }
986 else
987 {
988 msg.Printf(wxT("You've entered %lu"), res );
989 icon = wxICON_INFORMATION;
990 }
991
992 wxMessageBox(msg, wxT("Numeric test result"), wxOK | icon, this);
993 }
994 #endif // wxUSE_NUMBERDLG
995
996 #if wxUSE_TEXTDLG
997 void MyFrame::PasswordEntry(wxCommandEvent& WXUNUSED(event))
998 {
999 wxString pwd = wxGetPasswordFromUser(wxT("Enter password:"),
1000 wxT("Password entry dialog"),
1001 wxEmptyString,
1002 this);
1003 if ( !pwd.empty() )
1004 {
1005 wxMessageBox(wxString::Format(wxT("Your password is '%s'"), pwd.c_str()),
1006 wxT("Got password"), wxOK | wxICON_INFORMATION, this);
1007 }
1008 }
1009
1010 void MyFrame::LineEntry(wxCommandEvent& WXUNUSED(event))
1011 {
1012 wxTextEntryDialog dialog(this,
1013 wxT("This is a small sample\n")
1014 wxT("A long, long string to test out the text entrybox"),
1015 wxT("Please enter a string"),
1016 wxT("Default value"),
1017 wxOK | wxCANCEL);
1018
1019 if (dialog.ShowModal() == wxID_OK)
1020 {
1021 wxMessageBox(dialog.GetValue(), wxT("Got string"), wxOK | wxICON_INFORMATION, this);
1022 }
1023 }
1024
1025 void MyFrame::TextEntry(wxCommandEvent& WXUNUSED(event))
1026 {
1027 wxTextEntryDialog dialog(this, "You can enter a multiline string here.",
1028 "Please enter some text",
1029 "First line\nSecond one\nAnd another one too",
1030 wxOK | wxCANCEL | wxTE_MULTILINE);
1031
1032 if (dialog.ShowModal() == wxID_OK)
1033 {
1034 wxMessageBox(dialog.GetValue(), wxT("Got text"), wxOK | wxICON_INFORMATION, this);
1035 }
1036 }
1037 #endif // wxUSE_TEXTDLG
1038
1039 #if wxUSE_CHOICEDLG
1040 void MyFrame::SingleChoice(wxCommandEvent& WXUNUSED(event) )
1041 {
1042 const wxString choices[] = { wxT("One"), wxT("Two"), wxT("Three"), wxT("Four"), wxT("Five") } ;
1043
1044 wxSingleChoiceDialog dialog(this,
1045 wxT("This is a small sample\n")
1046 wxT("A single-choice convenience dialog"),
1047 wxT("Please select a value"),
1048 WXSIZEOF(choices), choices);
1049
1050 dialog.SetSelection(2);
1051
1052 if (dialog.ShowModal() == wxID_OK)
1053 {
1054 wxMessageDialog dialog2(this, dialog.GetStringSelection(), wxT("Got string"));
1055 dialog2.ShowModal();
1056 }
1057 }
1058
1059 void MyFrame::MultiChoice(wxCommandEvent& WXUNUSED(event) )
1060 {
1061 const wxString choices[] =
1062 {
1063 wxT("One"), wxT("Two"), wxT("Three"), wxT("Four"), wxT("Five"),
1064 wxT("Six"), wxT("Seven"), wxT("Eight"), wxT("Nine"), wxT("Ten"),
1065 wxT("Eleven"), wxT("Twelve"), wxT("Seventeen"),
1066 };
1067
1068 wxArrayInt selections;
1069 const int count = wxGetSelectedChoices(selections,
1070 wxT("This is a small sample\n")
1071 wxT("A multi-choice convenience dialog"),
1072 wxT("Please select a value"),
1073 WXSIZEOF(choices), choices,
1074 this);
1075 if ( count >= 0 )
1076 {
1077 wxString msg;
1078 if ( count == 0 )
1079 {
1080 msg = wxT("You did not select any items");
1081 }
1082 else
1083 {
1084 msg.Printf(wxT("You selected %u items:\n"), (unsigned)count);
1085 for ( int n = 0; n < count; n++ )
1086 {
1087 msg += wxString::Format(wxT("\t%u: %u (%s)\n"),
1088 (unsigned)n, (unsigned)selections[n],
1089 choices[selections[n]].c_str());
1090 }
1091 }
1092 wxLogMessage(msg);
1093 }
1094 //else: cancelled
1095 }
1096 #endif // wxUSE_CHOICEDLG
1097
1098 #if wxUSE_REARRANGECTRL
1099 // custom rearrange dialog: it adds the possibility to rename an item to the
1100 // base class functionality
1101 class MyRearrangeDialog : public wxRearrangeDialog
1102 {
1103 public:
1104 MyRearrangeDialog(wxWindow *parent,
1105 wxArrayInt& order,
1106 wxArrayString& labels,
1107 wxArrayString& labelsOrig)
1108 : wxRearrangeDialog
1109 (
1110 parent,
1111 "Configure the columns shown:",
1112 "wxRearrangeDialog example",
1113 order,
1114 labels
1115 ),
1116 m_order(order),
1117 m_labels(labels),
1118 m_labelsOrig(labelsOrig)
1119 {
1120 m_sel = wxNOT_FOUND;
1121
1122 wxPanel * const panel = new wxPanel(this);
1123 wxSizer * const sizer = new wxBoxSizer(wxHORIZONTAL);
1124
1125 m_labelOrig = new wxStaticText(panel, wxID_ANY, "");
1126 sizer->Add(m_labelOrig, wxSizerFlags().Centre().Border(wxRIGHT));
1127
1128 m_text = new wxTextCtrl(panel, wxID_ANY, "",
1129 wxDefaultPosition, wxDefaultSize,
1130 wxTE_PROCESS_ENTER);
1131 sizer->Add(m_text, wxSizerFlags().Centre().Border(wxRIGHT));
1132
1133 sizer->Add(new wxButton(panel, wxID_APPLY, "&Rename"),
1134 wxSizerFlags().Centre());
1135
1136 panel->SetSizer(sizer);
1137
1138 // call this first to ensure that the controls have a reasonable best
1139 // size before they're added
1140 DoUpdateExtraControls(GetList()->GetSelection());
1141
1142 AddExtraControls(panel);
1143
1144
1145 // another customization not directly supported by the dialog: add a
1146 // custom button
1147 wxWindow * const btnOk = FindWindow(wxID_OK);
1148 wxCHECK_RET( btnOk, "no Ok button?" );
1149
1150 wxSizer * const sizerBtns = btnOk->GetContainingSizer();
1151 wxCHECK_RET( sizerBtns, "no buttons sizer?" );
1152
1153 sizerBtns->Add(new wxButton(this, wxID_RESET, "&Reset all"),
1154 wxSizerFlags().Border(wxLEFT));
1155 }
1156
1157 // call this instead of ShowModal() to update order and labels array in
1158 // case the dialog was not cancelled
1159 bool Rearrange()
1160 {
1161 switch ( ShowModal() )
1162 {
1163 case wxID_CANCEL:
1164 return false;
1165
1166 case wxID_OK:
1167 m_order = GetOrder();
1168 break;
1169
1170 case wxID_RESET:
1171 // order already reset
1172 break;
1173 }
1174
1175 return true;
1176 }
1177
1178 private:
1179 void OnSelChange(wxCommandEvent& event)
1180 {
1181 DoUpdateExtraControls(event.GetInt());
1182 }
1183
1184 void OnUpdateUIRename(wxUpdateUIEvent& event)
1185 {
1186 event.Enable( CanRename() );
1187 }
1188
1189 void OnRename(wxCommandEvent& WXUNUSED(event))
1190 {
1191 if ( !CanRename() )
1192 return;
1193
1194 m_labels[m_sel] = m_text->GetValue();
1195 GetList()->SetString(m_sel, m_labels[m_sel]);
1196 }
1197
1198 void OnReset(wxCommandEvent& WXUNUSED(event))
1199 {
1200 // in a real program we should probably ask if the user really wants to
1201 // do this but here we just go ahead and reset all columns labels and
1202 // their order without confirmation
1203 const unsigned count = m_order.size();
1204 for ( unsigned n = 0; n < count; n++ )
1205 {
1206 m_order[n] = n;
1207 m_labels[n] = m_labelsOrig[n];
1208 }
1209
1210 EndModal(wxID_RESET);
1211 }
1212
1213 bool CanRename() const
1214 {
1215 // only allow renaming if the user modified the currently selected item
1216 // text (which presupposes that we do have a current item)
1217 return m_sel != wxNOT_FOUND && m_text->GetValue() != m_labels[m_sel];
1218 }
1219
1220 void DoUpdateExtraControls(int sel)
1221 {
1222 m_sel = sel;
1223
1224 if ( m_sel == wxNOT_FOUND )
1225 {
1226 m_labelOrig->SetLabel("<no selection>");
1227 m_text->Clear();
1228 m_text->Disable();
1229 }
1230 else // have valid item
1231 {
1232 m_labelOrig->SetLabelText(m_labelsOrig[m_sel]);
1233 m_text->Enable();
1234 m_text->SetValue(m_labels[m_sel]);
1235 }
1236 }
1237
1238 wxArrayInt& m_order;
1239 wxArrayString& m_labels,
1240 m_labelsOrig;
1241
1242 int m_sel;
1243 wxStaticText *m_labelOrig;
1244 wxTextCtrl *m_text;
1245
1246 DECLARE_EVENT_TABLE()
1247 wxDECLARE_NO_COPY_CLASS(MyRearrangeDialog);
1248 };
1249
1250 BEGIN_EVENT_TABLE(MyRearrangeDialog, wxRearrangeDialog)
1251 EVT_LISTBOX(wxID_ANY, MyRearrangeDialog::OnSelChange)
1252
1253 EVT_UPDATE_UI(wxID_APPLY, MyRearrangeDialog::OnUpdateUIRename)
1254
1255 EVT_TEXT_ENTER(wxID_ANY, MyRearrangeDialog::OnRename)
1256 EVT_BUTTON(wxID_APPLY, MyRearrangeDialog::OnRename)
1257 EVT_BUTTON(wxID_RESET, MyRearrangeDialog::OnReset)
1258 END_EVENT_TABLE()
1259
1260 void MyFrame::Rearrange(wxCommandEvent& WXUNUSED(event))
1261 {
1262 // the arrays are static so that we preserve the items order between calls
1263 // to this function
1264 static wxArrayInt s_order;
1265 static wxArrayString s_labels,
1266 s_labelsOrig;
1267
1268 // initialize them on the first call
1269 if ( s_labelsOrig.empty() )
1270 {
1271 static const struct ItemInfo
1272 {
1273 const char *label;
1274 const char *labelOrig;
1275 int order;
1276 } items[] =
1277 {
1278 { "File name", "Name", 0 },
1279 { "File type", "Ext", 1 },
1280 { "Size", "Size", 2 },
1281 { "Creation time", "Ctime", ~3 }, // negated so hidden
1282 { "Last accessed", "Atime", ~4 },
1283 { "Last modified", "Mtime", 5 },
1284 };
1285
1286 s_order.reserve(WXSIZEOF(items));
1287 s_labels.reserve(WXSIZEOF(items));
1288 s_labelsOrig.reserve(WXSIZEOF(items));
1289 for ( unsigned n = 0; n < WXSIZEOF(items); n++ )
1290 {
1291 const ItemInfo& item = items[n];
1292 s_order.push_back(item.order);
1293 s_labels.push_back(item.label);
1294 s_labelsOrig.push_back(item.labelOrig);
1295 }
1296 }
1297
1298 MyRearrangeDialog dlg(this, s_order, s_labels, s_labelsOrig);
1299 if ( !dlg.Rearrange() )
1300 return;
1301
1302 wxString columns;
1303 for ( unsigned n = 0; n < s_order.size(); n++ )
1304 {
1305 columns += wxString::Format("\n %u: ", n);
1306 int idx = s_order[n];
1307 if ( idx < 0 )
1308 {
1309 columns += "[hidden] ";
1310 idx = ~idx;
1311 }
1312
1313 columns += s_labels[idx];
1314 if ( s_labels[idx] != s_labelsOrig[idx] )
1315 {
1316 columns += wxString::Format(" (original label: \"%s\")",
1317 s_labelsOrig[idx]);
1318 }
1319 }
1320
1321 wxLogMessage("The columns order now is:%s", columns);
1322 }
1323 #endif // wxUSE_REARRANGECTRL
1324
1325 #if wxUSE_FILEDLG
1326
1327 // panel with custom controls for file dialog
1328 class MyExtraPanel : public wxPanel
1329 {
1330 public:
1331 MyExtraPanel(wxWindow *parent);
1332 void OnCheckBox(wxCommandEvent& event) { m_btn->Enable(event.IsChecked()); }
1333 wxString GetInfo() const
1334 {
1335 return wxString::Format("checkbox value = %d", (int) m_cb->GetValue());
1336 }
1337 private:
1338 wxButton *m_btn;
1339 wxCheckBox *m_cb;
1340 };
1341
1342 MyExtraPanel::MyExtraPanel(wxWindow *parent)
1343 : wxPanel(parent)
1344 {
1345 m_btn = new wxButton(this, -1, wxT("Custom Button"));
1346 m_btn->Enable(false);
1347 m_cb = new wxCheckBox(this, -1, wxT("Enable Custom Button"));
1348 m_cb->Connect(wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED,
1349 wxCommandEventHandler(MyExtraPanel::OnCheckBox), NULL, this);
1350 wxBoxSizer *sizerTop = new wxBoxSizer(wxHORIZONTAL);
1351 sizerTop->Add(m_cb, wxSizerFlags().Centre().Border());
1352 sizerTop->AddStretchSpacer();
1353 sizerTop->Add(m_btn, wxSizerFlags().Right().Border());
1354 SetSizerAndFit(sizerTop);
1355 }
1356
1357 // a static method can be used instead of a function with most of compilers
1358 static wxWindow* createMyExtraPanel(wxWindow *parent)
1359 {
1360 return new MyExtraPanel(parent);
1361 }
1362
1363 void MyFrame::FileOpen(wxCommandEvent& WXUNUSED(event) )
1364 {
1365 wxFileDialog dialog
1366 (
1367 this,
1368 wxT("Testing open file dialog"),
1369 wxEmptyString,
1370 wxEmptyString,
1371 #ifdef __WXMOTIF__
1372 wxT("C++ files (*.cpp)|*.cpp")
1373 #else
1374 wxT("C++ files (*.cpp;*.h)|*.cpp;*.h")
1375 #endif
1376 );
1377
1378 dialog.SetExtraControlCreator(&createMyExtraPanel);
1379 dialog.CentreOnParent();
1380 dialog.SetDirectory(wxGetHomeDir());
1381
1382 if (dialog.ShowModal() == wxID_OK)
1383 {
1384 wxString info;
1385 wxWindow * const extra = dialog.GetExtraControl();
1386 info.Printf(wxT("Full file name: %s\n")
1387 wxT("Path: %s\n")
1388 wxT("Name: %s\n")
1389 wxT("Custom window: %s"),
1390 dialog.GetPath().c_str(),
1391 dialog.GetDirectory().c_str(),
1392 dialog.GetFilename().c_str(),
1393 extra ? static_cast<MyExtraPanel*>(extra)->GetInfo()
1394 : wxString("None"));
1395 wxMessageDialog dialog2(this, info, wxT("Selected file"));
1396 dialog2.ShowModal();
1397 }
1398 }
1399
1400 // this shows how to take advantage of specifying a default extension in the
1401 // call to wxFileSelector: it is remembered after each new call and the next
1402 // one will use it by default
1403 void MyFrame::FileOpen2(wxCommandEvent& WXUNUSED(event) )
1404 {
1405 static wxString s_extDef;
1406 wxString path = wxFileSelector(
1407 wxT("Select the file to load"),
1408 wxEmptyString, wxEmptyString,
1409 s_extDef,
1410 wxString::Format
1411 (
1412 wxT("Waveform (*.wav)|*.wav|Plain text (*.txt)|*.txt|All files (%s)|%s"),
1413 wxFileSelectorDefaultWildcardStr,
1414 wxFileSelectorDefaultWildcardStr
1415 ),
1416 wxFD_OPEN|wxFD_CHANGE_DIR|wxFD_PREVIEW,
1417 this
1418 );
1419
1420 if ( !path )
1421 return;
1422
1423 // it is just a sample, would use wxSplitPath in real program
1424 s_extDef = path.AfterLast(wxT('.'));
1425
1426 wxLogMessage(wxT("You selected the file '%s', remembered extension '%s'"),
1427 path, s_extDef);
1428 }
1429
1430 void MyFrame::FilesOpen(wxCommandEvent& WXUNUSED(event) )
1431 {
1432 wxString wildcards =
1433 #ifdef __WXMOTIF__
1434 wxT("C++ files (*.cpp)|*.cpp");
1435 #else
1436 wxString::Format
1437 (
1438 wxT("All files (%s)|%s|C++ files (*.cpp;*.h)|*.cpp;*.h"),
1439 wxFileSelectorDefaultWildcardStr,
1440 wxFileSelectorDefaultWildcardStr
1441 );
1442 #endif
1443 wxFileDialog dialog(this, wxT("Testing open multiple file dialog"),
1444 wxEmptyString, wxEmptyString, wildcards,
1445 wxFD_OPEN|wxFD_MULTIPLE);
1446
1447 if (dialog.ShowModal() == wxID_OK)
1448 {
1449 wxArrayString paths, filenames;
1450
1451 dialog.GetPaths(paths);
1452 dialog.GetFilenames(filenames);
1453
1454 wxString msg, s;
1455 size_t count = paths.GetCount();
1456 for ( size_t n = 0; n < count; n++ )
1457 {
1458 s.Printf(wxT("File %d: %s (%s)\n"),
1459 (int)n, paths[n].c_str(), filenames[n].c_str());
1460
1461 msg += s;
1462 }
1463 s.Printf(wxT("Filter index: %d"), dialog.GetFilterIndex());
1464 msg += s;
1465
1466 wxMessageDialog dialog2(this, msg, wxT("Selected files"));
1467 dialog2.ShowModal();
1468 }
1469 }
1470
1471 void MyFrame::FileSave(wxCommandEvent& WXUNUSED(event) )
1472 {
1473 wxFileDialog dialog(this,
1474 wxT("Testing save file dialog"),
1475 wxEmptyString,
1476 wxT("myletter.doc"),
1477 wxT("Text files (*.txt)|*.txt|Document files (*.doc;*.ods)|*.doc;*.ods"),
1478 wxFD_SAVE|wxFD_OVERWRITE_PROMPT);
1479
1480 dialog.SetFilterIndex(1);
1481
1482 if (dialog.ShowModal() == wxID_OK)
1483 {
1484 wxLogMessage(wxT("%s, filter %d"),
1485 dialog.GetPath().c_str(), dialog.GetFilterIndex());
1486 }
1487 }
1488 #endif // wxUSE_FILEDLG
1489
1490 #if USE_FILEDLG_GENERIC
1491 void MyFrame::FileOpenGeneric(wxCommandEvent& WXUNUSED(event) )
1492 {
1493 wxGenericFileDialog dialog
1494 (
1495 this,
1496 wxT("Testing open file dialog"),
1497 wxEmptyString,
1498 wxEmptyString,
1499 wxT("C++ files (*.cpp;*.h)|*.cpp;*.h")
1500 );
1501
1502 dialog.SetExtraControlCreator(&createMyExtraPanel);
1503 dialog.SetDirectory(wxGetHomeDir());
1504
1505 if (dialog.ShowModal() == wxID_OK)
1506 {
1507 wxString info;
1508 info.Printf(wxT("Full file name: %s\n")
1509 wxT("Path: %s\n")
1510 wxT("Name: %s"),
1511 dialog.GetPath().c_str(),
1512 dialog.GetDirectory().c_str(),
1513 dialog.GetFilename().c_str());
1514 wxMessageDialog dialog2(this, info, wxT("Selected file"));
1515 dialog2.ShowModal();
1516 }
1517 }
1518
1519 void MyFrame::FilesOpenGeneric(wxCommandEvent& WXUNUSED(event) )
1520 {
1521 // On PocketPC you can disable OK-only dialogs policy using system option
1522 int buttons = wxSystemOptions::GetOptionInt(wxT("wince.dialog.real-ok-cancel"));
1523 wxSystemOptions::SetOption(wxT("wince.dialog.real-ok-cancel"), 1);
1524
1525 wxString wildcards = wxT("All files (*.*)|*.*|C++ files (*.cpp;*.h)|*.cpp;*.h");
1526 wxGenericFileDialog dialog(this, wxT("Testing open multiple file dialog"),
1527 wxEmptyString, wxEmptyString, wildcards,
1528 wxFD_MULTIPLE);
1529
1530 if (dialog.ShowModal() == wxID_OK)
1531 {
1532 wxArrayString paths, filenames;
1533
1534 dialog.GetPaths(paths);
1535 dialog.GetFilenames(filenames);
1536
1537 wxString msg, s;
1538 size_t count = paths.GetCount();
1539 for ( size_t n = 0; n < count; n++ )
1540 {
1541 s.Printf(wxT("File %d: %s (%s)\n"),
1542 (int)n, paths[n].c_str(), filenames[n].c_str());
1543
1544 msg += s;
1545 }
1546 s.Printf(wxT("Filter index: %d"), dialog.GetFilterIndex());
1547 msg += s;
1548
1549 wxMessageDialog dialog2(this, msg, wxT("Selected files"));
1550 dialog2.ShowModal();
1551 }
1552
1553 // restore system option
1554 wxSystemOptions::SetOption(wxT("wince.dialog.real-ok-cancel"), buttons);
1555 }
1556
1557 void MyFrame::FileSaveGeneric(wxCommandEvent& WXUNUSED(event) )
1558 {
1559 wxGenericFileDialog dialog(this,
1560 wxT("Testing save file dialog"),
1561 wxEmptyString,
1562 wxT("myletter.doc"),
1563 wxT("Text files (*.txt)|*.txt|Document files (*.doc;*.ods)|*.doc;*.ods"),
1564 wxFD_SAVE|wxFD_OVERWRITE_PROMPT);
1565
1566 dialog.SetFilterIndex(1);
1567
1568 if (dialog.ShowModal() == wxID_OK)
1569 {
1570 wxLogMessage(wxT("%s, filter %d"),
1571 dialog.GetPath().c_str(), dialog.GetFilterIndex());
1572 }
1573 }
1574 #endif // USE_FILEDLG_GENERIC
1575
1576 #if wxUSE_DIRDLG
1577 void MyFrame::DoDirChoose(int style)
1578 {
1579 // pass some initial dir to wxDirDialog
1580 wxString dirHome;
1581 wxGetHomeDir(&dirHome);
1582
1583 wxDirDialog dialog(this, wxT("Testing directory picker"), dirHome, style);
1584
1585 if (dialog.ShowModal() == wxID_OK)
1586 {
1587 wxLogMessage(wxT("Selected path: %s"), dialog.GetPath().c_str());
1588 }
1589 }
1590
1591 void MyFrame::DirChoose(wxCommandEvent& WXUNUSED(event) )
1592 {
1593 DoDirChoose(wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
1594 }
1595
1596 void MyFrame::DirChooseNew(wxCommandEvent& WXUNUSED(event) )
1597 {
1598 DoDirChoose(wxDD_DEFAULT_STYLE & ~wxDD_DIR_MUST_EXIST);
1599 }
1600 #endif // wxUSE_DIRDLG
1601
1602 #if USE_DIRDLG_GENERIC
1603 void MyFrame::GenericDirChoose(wxCommandEvent& WXUNUSED(event) )
1604 {
1605 // pass some initial dir to wxDirDialog
1606 wxString dirHome;
1607 wxGetHomeDir(&dirHome);
1608
1609 wxGenericDirDialog dialog(this, wxT("Testing generic directory picker"), dirHome);
1610
1611 if (dialog.ShowModal() == wxID_OK)
1612 {
1613 wxMessageDialog dialog2(this, dialog.GetPath(), wxT("Selected path"));
1614 dialog2.ShowModal();
1615 }
1616 }
1617 #endif // USE_DIRDLG_GENERIC
1618
1619 #if USE_MODAL_PRESENTATION
1620 void MyFrame::ModalDlg(wxCommandEvent& WXUNUSED(event))
1621 {
1622 MyModalDialog dlg(this);
1623 dlg.ShowModal();
1624 }
1625 #endif // USE_MODAL_PRESENTATION
1626
1627 void MyFrame::ModelessDlg(wxCommandEvent& event)
1628 {
1629 bool show = GetMenuBar()->IsChecked(event.GetId());
1630
1631 if ( show )
1632 {
1633 if ( !m_dialog )
1634 {
1635 m_dialog = new MyModelessDialog(this);
1636 }
1637
1638 m_dialog->Show(true);
1639 }
1640 else // hide
1641 {
1642 // If m_dialog is NULL, then possibly the system
1643 // didn't report the checked menu item status correctly.
1644 // It should be true just after the menu item was selected,
1645 // if there was no modeless dialog yet.
1646
1647 wxASSERT( m_dialog != NULL );
1648 if (m_dialog)
1649 m_dialog->Hide();
1650 }
1651 }
1652
1653 void MyFrame::DlgCenteredScreen(wxCommandEvent& WXUNUSED(event))
1654 {
1655 wxDialog dlg(this, wxID_ANY, wxT("Dialog centered on screen"),
1656 wxDefaultPosition, wxSize(200, 100));
1657 (new wxButton(&dlg, wxID_OK, wxT("Close")))->Centre();
1658 dlg.CentreOnScreen();
1659 dlg.ShowModal();
1660 }
1661
1662 void MyFrame::DlgCenteredParent(wxCommandEvent& WXUNUSED(event))
1663 {
1664 wxDialog dlg(this, wxID_ANY, wxT("Dialog centered on parent"),
1665 wxDefaultPosition, wxSize(200, 100));
1666 (new wxButton(&dlg, wxID_OK, wxT("Close")))->Centre();
1667 dlg.CentreOnParent();
1668 dlg.ShowModal();
1669 }
1670
1671 #if wxUSE_MINIFRAME
1672 void MyFrame::MiniFrame(wxCommandEvent& WXUNUSED(event))
1673 {
1674 wxFrame *frame = new wxMiniFrame(this, wxID_ANY, wxT("Mini frame"),
1675 wxDefaultPosition, wxSize(300, 100),
1676 wxCAPTION | wxCLOSE_BOX);
1677 new wxStaticText(frame,
1678 wxID_ANY,
1679 wxT("Mini frames have slightly different appearance"),
1680 wxPoint(5, 5));
1681 new wxStaticText(frame,
1682 wxID_ANY,
1683 wxT("from the normal frames but that's the only difference."),
1684 wxPoint(5, 25));
1685
1686 frame->CentreOnParent();
1687 frame->Show();
1688 }
1689 #endif // wxUSE_MINIFRAME
1690
1691 void MyFrame::DlgOnTop(wxCommandEvent& WXUNUSED(event))
1692 {
1693 wxDialog dlg(this, wxID_ANY, wxT("Dialog staying on top of other windows"),
1694 wxDefaultPosition, wxSize(300, 100),
1695 wxDEFAULT_DIALOG_STYLE | wxSTAY_ON_TOP);
1696 (new wxButton(&dlg, wxID_OK, wxT("Close")))->Centre();
1697 dlg.ShowModal();
1698 }
1699
1700 #if wxUSE_STARTUP_TIPS
1701 void MyFrame::ShowTip(wxCommandEvent& WXUNUSED(event))
1702 {
1703 static size_t s_index = (size_t)-1;
1704
1705 if ( s_index == (size_t)-1 )
1706 {
1707 srand(time(NULL));
1708
1709 // this is completely bogus, we don't know how many lines are there
1710 // in the file, but who cares, it's a demo only...
1711 s_index = rand() % 5;
1712 }
1713
1714 wxTipProvider *tipProvider = wxCreateFileTipProvider(wxT("tips.txt"), s_index);
1715
1716 bool showAtStartup = wxShowTip(this, tipProvider);
1717
1718 if ( showAtStartup )
1719 {
1720 wxMessageBox(wxT("Will show tips on startup"), wxT("Tips dialog"),
1721 wxOK | wxICON_INFORMATION, this);
1722 }
1723
1724 s_index = tipProvider->GetCurrentTip();
1725 delete tipProvider;
1726 }
1727 #endif // wxUSE_STARTUP_TIPS
1728
1729 #if USE_SETTINGS_DIALOG
1730 void MyFrame::OnPropertySheet(wxCommandEvent& event)
1731 {
1732 SettingsDialog dialog(this, event.GetId());
1733 dialog.ShowModal();
1734 }
1735 #endif // USE_SETTINGS_DIALOG
1736
1737 void MyFrame::OnRequestUserAttention(wxCommandEvent& WXUNUSED(event))
1738 {
1739 wxLogStatus(wxT("Sleeping for 3 seconds to allow you to switch to another window"));
1740
1741 wxSleep(3);
1742
1743 RequestUserAttention(wxUSER_ATTENTION_ERROR);
1744 }
1745
1746 #if wxUSE_NOTIFICATION_MESSAGE
1747
1748 void MyFrame::OnNotifMsgAuto(wxCommandEvent& WXUNUSED(event))
1749 {
1750 // Notice that the notification remains shown even after the
1751 // wxNotificationMessage object itself is destroyed so we can show simple
1752 // notifications using temporary objects.
1753 if ( !wxNotificationMessage
1754 (
1755 "Automatic Notification",
1756 "Nothing important has happened\n"
1757 "this notification will disappear soon."
1758 ).Show() )
1759 {
1760 wxLogStatus("Failed to show notification message");
1761 }
1762
1763 // But it doesn't have to be a temporary, of course.
1764 wxNotificationMessage n("Dummy Warning", "Example of a warning notification.");
1765 n.SetFlags(wxICON_ERROR);
1766 n.Show(5); // Just for testing, use 5 second delay.
1767 }
1768
1769 void MyFrame::OnNotifMsgShow(wxCommandEvent& WXUNUSED(event))
1770 {
1771 if ( !m_notifMsg )
1772 {
1773 m_notifMsg = new wxNotificationMessage
1774 (
1775 "wxWidgets Manual Notification",
1776 "You can hide this notification from the menu",
1777 this
1778 );
1779 }
1780
1781 if ( !m_notifMsg->Show(wxNotificationMessage::Timeout_Never) )
1782 {
1783 wxLogStatus("Failed to show manual notification message");
1784 }
1785 }
1786
1787 void MyFrame::OnNotifMsgHide(wxCommandEvent& WXUNUSED(event))
1788 {
1789 if ( m_notifMsg && !m_notifMsg->Close() )
1790 {
1791 wxLogStatus("Failed to hide manual notification message");
1792 }
1793 }
1794
1795 #endif // wxUSE_NOTIFICATION_MESSAGE
1796
1797 #if wxUSE_RICHTOOLTIP
1798
1799 #include "wx/richtooltip.h"
1800
1801 #include "tip.xpm"
1802
1803 class RichTipDialog : public wxDialog
1804 {
1805 public:
1806 RichTipDialog(wxWindow* parent)
1807 : wxDialog(parent, wxID_ANY, "wxRichToolTip Test",
1808 wxDefaultPosition, wxDefaultSize,
1809 wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
1810 {
1811 // Create the controls.
1812 m_textTitle = new wxTextCtrl(this, wxID_ANY, "Tooltip title");
1813 m_textBody = new wxTextCtrl(this, wxID_ANY, "Main tooltip text\n"
1814 "possibly on several\n"
1815 "lines.",
1816 wxDefaultPosition, wxDefaultSize,
1817 wxTE_MULTILINE);
1818 wxButton* btnShowText = new wxButton(this, wxID_ANY, "Show for &text");
1819 wxButton* btnShowBtn = new wxButton(this, wxID_ANY, "Show for &button");
1820
1821 const wxString icons[] =
1822 {
1823 "&None",
1824 "&Information",
1825 "&Warning",
1826 "&Error",
1827 "&Custom"
1828 };
1829 wxCOMPILE_TIME_ASSERT( WXSIZEOF(icons) == Icon_Max, IconMismatch );
1830 m_icons = new wxRadioBox(this, wxID_ANY, "&Icon choice:",
1831 wxDefaultPosition, wxDefaultSize,
1832 WXSIZEOF(icons), icons,
1833 1, wxRA_SPECIFY_ROWS);
1834 m_icons->SetSelection(Icon_Info);
1835
1836 const wxString tipKinds[] =
1837 {
1838 "&None", "Top left", "Top", "Top right",
1839 "Bottom left", "Bottom", "Bottom right", "&Auto"
1840 };
1841 m_tipKinds = new wxRadioBox(this, wxID_ANY, "Tip &kind:",
1842 wxDefaultPosition, wxDefaultSize,
1843 WXSIZEOF(tipKinds), tipKinds,
1844 4, wxRA_SPECIFY_COLS);
1845 m_tipKinds->SetSelection(wxTipKind_Auto);
1846
1847 const wxString bgStyles[] =
1848 {
1849 "&Default", "&Solid", "&Gradient",
1850 };
1851 wxCOMPILE_TIME_ASSERT( WXSIZEOF(bgStyles) == Bg_Max, BgMismatch );
1852 m_bgStyles = new wxRadioBox(this, wxID_ANY, "Background style:",
1853 wxDefaultPosition, wxDefaultSize,
1854 WXSIZEOF(bgStyles), bgStyles,
1855 1, wxRA_SPECIFY_ROWS);
1856
1857 const wxString timeouts[] = { "&None", "&Default (no delay)", "&3 seconds" };
1858 wxCOMPILE_TIME_ASSERT( WXSIZEOF(timeouts) == Timeout_Max, TmMismatch );
1859 m_timeouts = new wxRadioBox(this, wxID_ANY, "Timeout:",
1860 wxDefaultPosition, wxDefaultSize,
1861 WXSIZEOF(timeouts), timeouts,
1862 1, wxRA_SPECIFY_ROWS);
1863 m_timeouts->SetSelection(Timeout_Default);
1864 m_timeDelay = new wxCheckBox(this, wxID_ANY, "Delay show" );
1865
1866 // Lay them out.
1867 m_textBody->SetMinSize(wxSize(300, 200));
1868
1869 wxBoxSizer* const sizer = new wxBoxSizer(wxVERTICAL);
1870 sizer->Add(m_textTitle, wxSizerFlags().Expand().Border());
1871 sizer->Add(m_textBody, wxSizerFlags(1).Expand().Border());
1872 sizer->Add(m_icons, wxSizerFlags().Expand().Border());
1873 sizer->Add(m_tipKinds, wxSizerFlags().Centre().Border());
1874 sizer->Add(m_bgStyles, wxSizerFlags().Centre().Border());
1875 sizer->Add(m_timeouts, wxSizerFlags().Centre().Border());
1876 sizer->Add(m_timeDelay, wxSizerFlags().Centre().Border());
1877 wxBoxSizer* const sizerBtns = new wxBoxSizer(wxHORIZONTAL);
1878 sizerBtns->Add(btnShowText, wxSizerFlags().Border(wxRIGHT));
1879 sizerBtns->Add(btnShowBtn, wxSizerFlags().Border(wxLEFT));
1880 sizer->Add(sizerBtns, wxSizerFlags().Centre().Border());
1881 sizer->Add(CreateStdDialogButtonSizer(wxOK),
1882 wxSizerFlags().Expand().Border());
1883 SetSizerAndFit(sizer);
1884
1885
1886 // And connect the event handlers.
1887 btnShowText->Connect
1888 (
1889 wxEVT_COMMAND_BUTTON_CLICKED,
1890 wxCommandEventHandler(RichTipDialog::OnShowTipForText),
1891 NULL,
1892 this
1893 );
1894
1895 btnShowBtn->Connect
1896 (
1897 wxEVT_COMMAND_BUTTON_CLICKED,
1898 wxCommandEventHandler(RichTipDialog::OnShowTipForBtn),
1899 NULL,
1900 this
1901 );
1902 }
1903
1904 private:
1905 enum
1906 {
1907 Icon_None,
1908 Icon_Info,
1909 Icon_Warning,
1910 Icon_Error,
1911 Icon_Custom,
1912 Icon_Max
1913 };
1914
1915 enum
1916 {
1917 Bg_Default,
1918 Bg_Solid,
1919 Bg_Gradient,
1920 Bg_Max
1921 };
1922
1923 enum
1924 {
1925 Timeout_None,
1926 Timeout_Default,
1927 Timeout_3sec,
1928 Timeout_Max
1929 };
1930
1931
1932 void OnShowTipForText(wxCommandEvent& WXUNUSED(event))
1933 {
1934 DoShowTip(m_textTitle);
1935 }
1936
1937 void OnShowTipForBtn(wxCommandEvent& WXUNUSED(event))
1938 {
1939 DoShowTip(FindWindow(wxID_OK));
1940 }
1941
1942 void DoShowTip(wxWindow* win)
1943 {
1944 wxRichToolTip tip(m_textTitle->GetValue(), m_textBody->GetValue());
1945 const int iconSel = m_icons->GetSelection();
1946 if ( iconSel == Icon_Custom )
1947 {
1948 tip.SetIcon(tip_xpm);
1949 }
1950 else // Use a standard icon.
1951 {
1952 static const int stdIcons[] =
1953 {
1954 wxICON_NONE,
1955 wxICON_INFORMATION,
1956 wxICON_WARNING,
1957 wxICON_ERROR,
1958 };
1959
1960 tip.SetIcon(stdIcons[iconSel]);
1961 }
1962
1963 switch ( m_bgStyles->GetSelection() )
1964 {
1965 case Bg_Default:
1966 break;
1967
1968 case Bg_Solid:
1969 tip.SetBackgroundColour(*wxLIGHT_GREY);
1970 break;
1971
1972 case Bg_Gradient:
1973 tip.SetBackgroundColour(*wxWHITE, wxColour(0xe4, 0xe5, 0xf0));
1974 break;
1975 }
1976
1977 int delay = m_timeDelay->IsChecked() ? 500 : 0;
1978
1979 switch ( m_timeouts->GetSelection() )
1980 {
1981 case Timeout_None:
1982 // Don't call SetTimeout unnecessarily
1983 // or msw will show generic impl
1984 if ( delay )
1985 tip.SetTimeout(0, delay);
1986 break;
1987
1988 case Timeout_Default:
1989 break;
1990
1991 case Timeout_3sec:
1992 tip.SetTimeout(3000, delay);
1993 break;
1994 }
1995
1996 tip.SetTipKind(static_cast<wxTipKind>(m_tipKinds->GetSelection()));
1997
1998 tip.ShowFor(win);
1999 }
2000
2001 wxTextCtrl* m_textTitle;
2002 wxTextCtrl* m_textBody;
2003 wxRadioBox* m_icons;
2004 wxRadioBox* m_tipKinds;
2005 wxRadioBox* m_bgStyles;
2006 wxRadioBox* m_timeouts;
2007 wxCheckBox* m_timeDelay;
2008 };
2009
2010 void MyFrame::OnRichTipDialog(wxCommandEvent& WXUNUSED(event))
2011 {
2012 RichTipDialog dialog(this);
2013 dialog.ShowModal();
2014 }
2015
2016 #endif // wxUSE_RICHTOOLTIP
2017
2018 void MyFrame::OnStandardButtonsSizerDialog(wxCommandEvent& WXUNUSED(event))
2019 {
2020 StdButtonSizerDialog dialog(this);
2021 dialog.ShowModal();
2022 }
2023
2024 // TestDefaultAction
2025
2026 #define ID_CATCH_LISTBOX_DCLICK 100
2027 #define ID_LISTBOX 101
2028 #define ID_DISABLE_OK 102
2029 #define ID_DISABLE_CANCEL 103
2030
2031 BEGIN_EVENT_TABLE(TestDefaultActionDialog, wxDialog)
2032 EVT_CHECKBOX(ID_CATCH_LISTBOX_DCLICK, TestDefaultActionDialog::OnCatchListBoxDClick)
2033 EVT_CHECKBOX(ID_DISABLE_OK, TestDefaultActionDialog::OnDisableOK)
2034 EVT_CHECKBOX(ID_DISABLE_CANCEL, TestDefaultActionDialog::OnDisableCancel)
2035 EVT_LISTBOX_DCLICK(ID_LISTBOX, TestDefaultActionDialog::OnListBoxDClick)
2036 EVT_TEXT_ENTER(wxID_ANY, TestDefaultActionDialog::OnTextEnter)
2037 END_EVENT_TABLE()
2038
2039 TestDefaultActionDialog::TestDefaultActionDialog( wxWindow *parent ) :
2040 wxDialog( parent, -1, "Test default action" )
2041 {
2042 m_catchListBoxDClick = false;
2043
2044 wxBoxSizer *main_sizer = new wxBoxSizer( wxVERTICAL );
2045
2046 wxFlexGridSizer *grid_sizer = new wxFlexGridSizer( 2, 5, 5 );
2047
2048 #if wxUSE_LISTBOX
2049 wxListBox *listbox = new wxListBox( this, ID_LISTBOX );
2050 listbox->Append( "String 1" );
2051 listbox->Append( "String 2" );
2052 listbox->Append( "String 3" );
2053 listbox->Append( "String 4" );
2054 grid_sizer->Add( listbox );
2055 #endif // wxUSE_LISTBOX
2056
2057 grid_sizer->Add( new wxCheckBox( this, ID_CATCH_LISTBOX_DCLICK, "Catch DoubleClick from wxListBox" ), 0, wxALIGN_CENTRE_VERTICAL );
2058
2059 grid_sizer->Add( new wxTextCtrl( this, -1, "", wxDefaultPosition, wxSize(80,-1), 0 ), 0, wxALIGN_CENTRE_VERTICAL );
2060 grid_sizer->Add( new wxStaticText( this, -1, "wxTextCtrl without wxTE_PROCESS_ENTER" ), 0, wxALIGN_CENTRE_VERTICAL );
2061
2062 grid_sizer->Add( new wxTextCtrl( this, -1, "", wxDefaultPosition, wxSize(80,-1), wxTE_PROCESS_ENTER ), 0, wxALIGN_CENTRE_VERTICAL );
2063 grid_sizer->Add( new wxStaticText( this, -1, "wxTextCtrl with wxTE_PROCESS_ENTER" ), 0, wxALIGN_CENTRE_VERTICAL );
2064
2065 grid_sizer->Add( new wxCheckBox(this, ID_DISABLE_OK, "Disable \"OK\""), 0, wxALIGN_CENTRE_VERTICAL );
2066 grid_sizer->Add( new wxCheckBox(this, ID_DISABLE_CANCEL, "Disable \"Cancel\""), 0, wxALIGN_CENTRE_VERTICAL );
2067
2068 main_sizer->Add( grid_sizer, 0, wxALL, 10 );
2069
2070 wxSizer *button_sizer = CreateSeparatedButtonSizer( wxOK|wxCANCEL );
2071 if (button_sizer)
2072 main_sizer->Add( button_sizer, 0, wxALL|wxGROW, 5 );
2073
2074 SetSizerAndFit( main_sizer );
2075 }
2076
2077 void TestDefaultActionDialog::OnDisableOK(wxCommandEvent& event)
2078 {
2079 FindWindow(wxID_OK)->Enable(!event.IsChecked());
2080 }
2081
2082 void TestDefaultActionDialog::OnDisableCancel(wxCommandEvent& event)
2083 {
2084 FindWindow(wxID_CANCEL)->Enable(!event.IsChecked());
2085 }
2086
2087 void TestDefaultActionDialog::OnListBoxDClick(wxCommandEvent& event)
2088 {
2089 event.Skip( !m_catchListBoxDClick );
2090 }
2091
2092 void TestDefaultActionDialog::OnCatchListBoxDClick(wxCommandEvent& WXUNUSED(event))
2093 {
2094 m_catchListBoxDClick = !m_catchListBoxDClick;
2095 }
2096
2097 void TestDefaultActionDialog::OnTextEnter(wxCommandEvent& event)
2098 {
2099 wxLogMessage("Text \"%s\" entered.", event.GetString());
2100 }
2101
2102 void MyFrame::OnTestDefaultActionDialog(wxCommandEvent& WXUNUSED(event))
2103 {
2104 TestDefaultActionDialog dialog( this );
2105 dialog.ShowModal();
2106 }
2107
2108 void MyFrame::OnExit(wxCommandEvent& WXUNUSED(event) )
2109 {
2110 Close(true);
2111 }
2112
2113 #if wxUSE_PROGRESSDLG
2114
2115 void MyFrame::ShowProgress( wxCommandEvent& WXUNUSED(event) )
2116 {
2117 static const int max = 100;
2118
2119 wxProgressDialog dialog("Progress dialog example",
2120 // "Reserve" enough space for the multiline
2121 // messages below, we'll change it anyhow
2122 // immediately in the loop below
2123 wxString(' ', 100) + "\n\n\n\n",
2124 max, // range
2125 this, // parent
2126 wxPD_CAN_ABORT |
2127 wxPD_CAN_SKIP |
2128 wxPD_APP_MODAL |
2129 //wxPD_AUTO_HIDE | // -- try this as well
2130 wxPD_ELAPSED_TIME |
2131 wxPD_ESTIMATED_TIME |
2132 wxPD_REMAINING_TIME |
2133 wxPD_SMOOTH // - makes indeterminate mode bar on WinXP very small
2134 );
2135
2136 bool cont = true;
2137 for ( int i = 0; i <= max; i++ )
2138 {
2139 wxString msg;
2140
2141 // test both modes of wxProgressDialog behaviour: start in
2142 // indeterminate mode but switch to the determinate one later
2143 const bool determinate = i > max/2;
2144
2145 if ( i == max )
2146 {
2147 msg = "That's all, folks!\n"
2148 "\n"
2149 "Nothing to see here any more.";
2150 }
2151 else if ( !determinate )
2152 {
2153 msg = "Testing indeterminate mode\n"
2154 "\n"
2155 "This mode allows you to show to the user\n"
2156 "that something is going on even if you don't know\n"
2157 "when exactly will you finish.";
2158 }
2159 else if ( determinate )
2160 {
2161 msg = "Now in standard determinate mode\n"
2162 "\n"
2163 "This is the standard usage mode in which you\n"
2164 "update the dialog after performing each new step of work.\n"
2165 "It requires knowing the total number of steps in advance.";
2166 }
2167
2168 // will be set to true if "Skip" button was pressed
2169 bool skip = false;
2170 if ( determinate )
2171 {
2172 cont = dialog.Update(i, msg, &skip);
2173 }
2174 else
2175 {
2176 cont = dialog.Pulse(msg, &skip);
2177 }
2178
2179 // each skip will move progress about quarter forward
2180 if ( skip )
2181 {
2182 i += max/4;
2183
2184 if ( i >= 100 )
2185 i = 99;
2186 }
2187
2188 if ( !cont )
2189 {
2190 if ( wxMessageBox(wxT("Do you really want to cancel?"),
2191 wxT("Progress dialog question"), // caption
2192 wxYES_NO | wxICON_QUESTION) == wxYES )
2193 break;
2194
2195 cont = true;
2196 dialog.Resume();
2197 }
2198
2199 wxMilliSleep(200);
2200 }
2201
2202 if ( !cont )
2203 {
2204 wxLogStatus(wxT("Progress dialog aborted!"));
2205 }
2206 else
2207 {
2208 wxLogStatus(wxT("Countdown from %d finished"), max);
2209 }
2210 }
2211
2212 #endif // wxUSE_PROGRESSDLG
2213
2214 #if wxUSE_ABOUTDLG
2215
2216 static void InitAboutInfoMinimal(wxAboutDialogInfo& info)
2217 {
2218 info.SetName(wxT("Dialogs Sample"));
2219 info.SetVersion(wxVERSION_NUM_DOT_STRING,
2220 wxString::Format
2221 (
2222 "%s version %s",
2223 wxMINOR_VERSION % 2 ? "Development" : "Stable",
2224 wxVERSION_NUM_DOT_STRING
2225 ));
2226 info.SetDescription(wxT("This sample shows different wxWidgets dialogs"));
2227 info.SetCopyright(wxT("(C) 1998-2006 wxWidgets dev team"));
2228 info.AddDeveloper(wxT("Vadim Zeitlin"));
2229 }
2230
2231 static void InitAboutInfoWebsite(wxAboutDialogInfo& info)
2232 {
2233 InitAboutInfoMinimal(info);
2234
2235 info.SetWebSite(wxT("http://www.wxwidgets.org/"), wxT("wxWidgets web site"));
2236 }
2237
2238 static void InitAboutInfoAll(wxAboutDialogInfo& info)
2239 {
2240 InitAboutInfoWebsite(info);
2241
2242 // we can add a second developer
2243 info.AddDeveloper(wxT("A.N. Other"));
2244
2245 // or we can add several persons at once like this
2246 static const wxChar *docwriters[] =
2247 {
2248 wxT("First D. Writer"),
2249 wxT("Second One"),
2250 };
2251
2252 info.SetDocWriters(wxArrayString(WXSIZEOF(docwriters), docwriters));
2253 info.SetLicence(wxString::FromAscii(
2254 " wxWindows Library Licence, Version 3.1\n"
2255 " ======================================\n"
2256 "\n"
2257 " Copyright (c) 1998-2005 Julian Smart, Robert Roebling et al\n"
2258 "\n"
2259 " Everyone is permitted to copy and distribute verbatim copies\n"
2260 " of this licence document, but changing it is not allowed.\n"
2261 "\n"
2262 " WXWINDOWS LIBRARY LICENCE\n"
2263 " TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n"
2264 "\n"
2265 " ...and so on and so forth...\n"
2266 ));
2267
2268 info.AddTranslator(wxT("Wun Ngo Wen (Martian)"));
2269 }
2270
2271 void MyFrame::ShowSimpleAboutDialog(wxCommandEvent& WXUNUSED(event))
2272 {
2273 wxAboutDialogInfo info;
2274 InitAboutInfoMinimal(info);
2275
2276 wxAboutBox(info, this);
2277 }
2278
2279 void MyFrame::ShowFancyAboutDialog(wxCommandEvent& WXUNUSED(event))
2280 {
2281 wxAboutDialogInfo info;
2282 InitAboutInfoWebsite(info);
2283
2284 wxAboutBox(info, this);
2285 }
2286
2287 void MyFrame::ShowFullAboutDialog(wxCommandEvent& WXUNUSED(event))
2288 {
2289 wxAboutDialogInfo info;
2290 InitAboutInfoAll(info);
2291
2292 wxAboutBox(info, this);
2293 }
2294
2295 // a trivial example of a custom dialog class
2296 class MyAboutDialog : public wxGenericAboutDialog
2297 {
2298 public:
2299 MyAboutDialog(const wxAboutDialogInfo& info, wxWindow* parent)
2300 {
2301 Create(info, parent);
2302 }
2303
2304 // add some custom controls
2305 virtual void DoAddCustomControls()
2306 {
2307 AddControl(new wxStaticLine(this), wxSizerFlags().Expand());
2308 AddText(wxT("Some custom text"));
2309 AddControl(new wxStaticLine(this), wxSizerFlags().Expand());
2310 }
2311 };
2312
2313 void MyFrame::ShowCustomAboutDialog(wxCommandEvent& WXUNUSED(event))
2314 {
2315 wxAboutDialogInfo info;
2316 InitAboutInfoAll(info);
2317
2318 MyAboutDialog dlg(info, this);
2319 dlg.ShowModal();
2320 }
2321
2322 #endif // wxUSE_ABOUTDLG
2323
2324 #if wxUSE_BUSYINFO
2325
2326 void MyFrame::ShowBusyInfo(wxCommandEvent& WXUNUSED(event))
2327 {
2328 wxWindowDisabler disableAll;
2329
2330 wxBusyInfo info(wxT("Working, please wait..."), this);
2331
2332 for ( int i = 0; i < 18; i++ )
2333 {
2334 wxMilliSleep(100);
2335 wxTheApp->Yield();
2336 }
2337
2338 wxSleep(2);
2339 //wxWakeUpIdle();
2340 }
2341
2342 #endif // wxUSE_BUSYINFO
2343
2344 #if wxUSE_FINDREPLDLG
2345
2346 void MyFrame::ShowReplaceDialog( wxCommandEvent& WXUNUSED(event) )
2347 {
2348 if ( m_dlgReplace )
2349 {
2350 wxDELETE(m_dlgReplace);
2351 }
2352 else
2353 {
2354 m_dlgReplace = new wxFindReplaceDialog
2355 (
2356 this,
2357 &m_findData,
2358 wxT("Find and replace dialog"),
2359 wxFR_REPLACEDIALOG
2360 );
2361
2362 m_dlgReplace->Show(true);
2363 }
2364 }
2365
2366 void MyFrame::ShowFindDialog( wxCommandEvent& WXUNUSED(event) )
2367 {
2368 if ( m_dlgFind )
2369 {
2370 wxDELETE(m_dlgFind);
2371 }
2372 else
2373 {
2374 m_dlgFind = new wxFindReplaceDialog
2375 (
2376 this,
2377 &m_findData,
2378 wxT("Find dialog"),
2379 // just for testing
2380 wxFR_NOWHOLEWORD
2381 );
2382
2383 m_dlgFind->Show(true);
2384 }
2385 }
2386
2387 static wxString DecodeFindDialogEventFlags(int flags)
2388 {
2389 wxString str;
2390 str << (flags & wxFR_DOWN ? wxT("down") : wxT("up")) << wxT(", ")
2391 << (flags & wxFR_WHOLEWORD ? wxT("whole words only, ") : wxT(""))
2392 << (flags & wxFR_MATCHCASE ? wxT("") : wxT("not "))
2393 << wxT("case sensitive");
2394
2395 return str;
2396 }
2397
2398 void MyFrame::OnFindDialog(wxFindDialogEvent& event)
2399 {
2400 wxEventType type = event.GetEventType();
2401
2402 if ( type == wxEVT_COMMAND_FIND || type == wxEVT_COMMAND_FIND_NEXT )
2403 {
2404 wxLogMessage(wxT("Find %s'%s' (flags: %s)"),
2405 type == wxEVT_COMMAND_FIND_NEXT ? wxT("next ") : wxT(""),
2406 event.GetFindString().c_str(),
2407 DecodeFindDialogEventFlags(event.GetFlags()).c_str());
2408 }
2409 else if ( type == wxEVT_COMMAND_FIND_REPLACE ||
2410 type == wxEVT_COMMAND_FIND_REPLACE_ALL )
2411 {
2412 wxLogMessage(wxT("Replace %s'%s' with '%s' (flags: %s)"),
2413 type == wxEVT_COMMAND_FIND_REPLACE_ALL ? wxT("all ") : wxT(""),
2414 event.GetFindString().c_str(),
2415 event.GetReplaceString().c_str(),
2416 DecodeFindDialogEventFlags(event.GetFlags()).c_str());
2417 }
2418 else if ( type == wxEVT_COMMAND_FIND_CLOSE )
2419 {
2420 wxFindReplaceDialog *dlg = event.GetDialog();
2421
2422 int idMenu;
2423 const wxChar *txt;
2424 if ( dlg == m_dlgFind )
2425 {
2426 txt = wxT("Find");
2427 idMenu = DIALOGS_FIND;
2428 m_dlgFind = NULL;
2429 }
2430 else if ( dlg == m_dlgReplace )
2431 {
2432 txt = wxT("Replace");
2433 idMenu = DIALOGS_REPLACE;
2434 m_dlgReplace = NULL;
2435 }
2436 else
2437 {
2438 txt = wxT("Unknown");
2439 idMenu = wxID_ANY;
2440
2441 wxFAIL_MSG( wxT("unexpected event") );
2442 }
2443
2444 wxLogMessage(wxT("%s dialog is being closed."), txt);
2445
2446 if ( idMenu != wxID_ANY )
2447 {
2448 GetMenuBar()->Check(idMenu, false);
2449 }
2450
2451 dlg->Destroy();
2452 }
2453 else
2454 {
2455 wxLogError(wxT("Unknown find dialog event!"));
2456 }
2457 }
2458
2459 #endif // wxUSE_FINDREPLDLG
2460
2461 // ----------------------------------------------------------------------------
2462 // MyCanvas
2463 // ----------------------------------------------------------------------------
2464
2465 void MyCanvas::OnPaint(wxPaintEvent& WXUNUSED(event) )
2466 {
2467 wxPaintDC dc(this);
2468 dc.SetBackgroundMode(wxTRANSPARENT);
2469 dc.DrawText(
2470 wxT("wxWidgets common dialogs")
2471 #if !defined(__SMARTPHONE__)
2472 wxT(" test application")
2473 #endif
2474 , 10, 10);
2475 }
2476
2477 #if USE_MODAL_PRESENTATION
2478
2479 // ----------------------------------------------------------------------------
2480 // MyModelessDialog
2481 // ----------------------------------------------------------------------------
2482
2483 MyModelessDialog::MyModelessDialog(wxWindow *parent)
2484 : wxDialog(parent, wxID_ANY, wxString(wxT("Modeless dialog")))
2485 {
2486 wxBoxSizer *sizerTop = new wxBoxSizer(wxVERTICAL);
2487
2488 wxButton *btn = new wxButton(this, DIALOGS_MODELESS_BTN, wxT("Press me"));
2489 wxCheckBox *check = new wxCheckBox(this, wxID_ANY, wxT("Should be disabled"));
2490 check->Disable();
2491
2492 sizerTop->Add(btn, 1, wxEXPAND | wxALL, 5);
2493 sizerTop->Add(check, 1, wxEXPAND | wxALL, 5);
2494
2495 SetSizerAndFit(sizerTop);
2496 }
2497
2498 void MyModelessDialog::OnButton(wxCommandEvent& WXUNUSED(event))
2499 {
2500 wxMessageBox(wxT("Button pressed in modeless dialog"), wxT("Info"),
2501 wxOK | wxICON_INFORMATION, this);
2502 }
2503
2504 void MyModelessDialog::OnClose(wxCloseEvent& event)
2505 {
2506 if ( event.CanVeto() )
2507 {
2508 wxMessageBox(wxT("Use the menu item to close this dialog"),
2509 wxT("Modeless dialog"),
2510 wxOK | wxICON_INFORMATION, this);
2511
2512 event.Veto();
2513 }
2514 }
2515
2516 // ----------------------------------------------------------------------------
2517 // MyModalDialog
2518 // ----------------------------------------------------------------------------
2519
2520 MyModalDialog::MyModalDialog(wxWindow *parent)
2521 : wxDialog(parent, wxID_ANY, wxString(wxT("Modal dialog")))
2522 {
2523 wxBoxSizer *sizerTop = new wxBoxSizer(wxHORIZONTAL);
2524
2525 m_btnModal = new wxButton(this, wxID_ANY, wxT("&Modal dialog..."));
2526 m_btnModeless = new wxButton(this, wxID_ANY, wxT("Mode&less dialog"));
2527 m_btnDelete = new wxButton(this, wxID_ANY, wxT("&Delete button"));
2528
2529 sizerTop->Add(m_btnModal, 0, wxALIGN_CENTER | wxALL, 5);
2530 sizerTop->Add(m_btnModeless, 0, wxALIGN_CENTER | wxALL, 5);
2531 sizerTop->Add(m_btnDelete, 0, wxALIGN_CENTER | wxALL, 5);
2532 sizerTop->Add(new wxButton(this, wxID_CLOSE), 0, wxALIGN_CENTER | wxALL, 5);
2533
2534 SetSizerAndFit(sizerTop);
2535
2536 SetEscapeId(wxID_CLOSE);
2537
2538 m_btnModal->SetFocus();
2539 m_btnModal->SetDefault();
2540 }
2541
2542 void MyModalDialog::OnButton(wxCommandEvent& event)
2543 {
2544 if ( event.GetEventObject() == m_btnDelete )
2545 {
2546 wxDELETE(m_btnModal);
2547 m_btnDelete->Disable();
2548 }
2549 else if ( event.GetEventObject() == m_btnModal )
2550 {
2551 #if wxUSE_TEXTDLG
2552 wxGetTextFromUser(wxT("Dummy prompt"),
2553 wxT("Modal dialog called from dialog"),
2554 wxEmptyString, this);
2555 #else
2556 wxMessageBox(wxT("Modal dialog called from dialog"));
2557 #endif // wxUSE_TEXTDLG
2558 }
2559 else if ( event.GetEventObject() == m_btnModeless )
2560 {
2561 (new MyModelessDialog(this))->Show();
2562 }
2563 else
2564 {
2565 event.Skip();
2566 }
2567 }
2568
2569 #endif // USE_MODAL_PRESENTATION
2570
2571 // ----------------------------------------------------------------------------
2572 // StdButtonSizerDialog
2573 // ----------------------------------------------------------------------------
2574
2575 StdButtonSizerDialog::StdButtonSizerDialog(wxWindow *parent)
2576 : wxDialog(parent, wxID_ANY, wxString(wxT("StdButtonSizer dialog")),
2577 wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER),
2578 m_buttonsSizer(NULL)
2579 {
2580 wxBoxSizer *const sizerTop = new wxBoxSizer(wxVERTICAL);
2581
2582 wxBoxSizer *const sizer = new wxBoxSizer(wxHORIZONTAL);
2583 wxBoxSizer *const sizerInside1 = new wxBoxSizer(wxVERTICAL);
2584
2585 m_chkboxAffirmativeButton = new wxCheckBox(this, wxID_ANY, _("Enable Affirmative Button"));
2586
2587 wxStaticBoxSizer *const sizer1 = new wxStaticBoxSizer(wxVERTICAL, this, wxT("Affirmative Button"));
2588
2589 m_radiobtnOk = new wxRadioButton(this, wxID_ANY, _("Ok"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
2590 m_radiobtnYes = new wxRadioButton(this, wxID_ANY, _("Yes"));
2591
2592 wxBoxSizer *const sizerInside2 = new wxBoxSizer(wxVERTICAL);
2593
2594 m_chkboxDismissButton = new wxCheckBox(this, wxID_ANY, _("Enable Dismiss Button"));
2595
2596 wxStaticBoxSizer *const sizer2 = new wxStaticBoxSizer(wxVERTICAL, this, wxT("Dismiss Button"));
2597
2598 m_radiobtnCancel = new wxRadioButton(this, wxID_ANY, _("Cancel"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
2599 m_radiobtnClose = new wxRadioButton(this, wxID_ANY, _("Close"));
2600
2601 wxBoxSizer *const sizer3 = new wxBoxSizer(wxHORIZONTAL);
2602
2603 m_chkboxNo = new wxCheckBox(this, wxID_ANY, _("No"));
2604 m_chkboxHelp = new wxCheckBox(this, wxID_ANY, _("Help"));
2605 m_chkboxApply = new wxCheckBox(this, wxID_ANY, _("Apply"));
2606
2607 m_chkboxNoDefault = new wxCheckBox(this, wxID_ANY, wxT("No Default"));
2608
2609 sizer1->Add(m_radiobtnOk, 0, wxALL, 5);
2610 sizer1->Add(m_radiobtnYes, 0, wxALL, 5);
2611
2612 sizer->Add(sizerInside1, 0, 0, 0);
2613 sizerInside1->Add(m_chkboxAffirmativeButton, 0, wxALL, 5);
2614 sizerInside1->Add(sizer1, 0, wxALL, 5);
2615 sizerInside1->SetItemMinSize(sizer1, sizer1->GetStaticBox()->GetBestSize()); // to prevent wrapping of static box label
2616
2617 sizer2->Add(m_radiobtnCancel, 0, wxALL, 5);
2618 sizer2->Add(m_radiobtnClose, 0, wxALL, 5);
2619
2620 sizer->Add(sizerInside2, 0, 0, 0);
2621 sizerInside2->Add(m_chkboxDismissButton, 0, wxALL, 5);
2622 sizerInside2->Add(sizer2, 0, wxALL, 5);
2623 sizerInside2->SetItemMinSize(sizer2, sizer2->GetStaticBox()->GetBestSize()); // to prevent wrapping of static box label
2624
2625 sizerTop->Add(sizer, 0, wxALL, 5);
2626
2627 sizer3->Add(m_chkboxNo, 0, wxALL, 5);
2628 sizer3->Add(m_chkboxHelp, 0, wxALL, 5);
2629 sizer3->Add(m_chkboxApply, 0, wxALL, 5);
2630
2631 sizerTop->Add(sizer3, 0, wxALL, 5);
2632
2633 sizerTop->Add(m_chkboxNoDefault, 0, wxLEFT|wxRIGHT, 10);
2634
2635 EnableDisableControls();
2636
2637 SetSizerAndFit(sizerTop);
2638
2639 wxCommandEvent ev;
2640 OnEvent(ev);
2641 }
2642
2643 void StdButtonSizerDialog::OnEvent(wxCommandEvent& WXUNUSED(event))
2644 {
2645 if (m_buttonsSizer)
2646 {
2647 m_buttonsSizer->DeleteWindows();
2648 GetSizer()->Remove(m_buttonsSizer);
2649 }
2650
2651 EnableDisableControls();
2652
2653 long flags = 0;
2654 unsigned long numButtons = 0;
2655
2656 if (m_chkboxAffirmativeButton->IsChecked())
2657 {
2658 if (m_radiobtnOk->GetValue())
2659 {
2660 flags |= wxOK;
2661 numButtons ++;
2662 }
2663 else if (m_radiobtnYes->GetValue())
2664 {
2665 flags |= wxYES;
2666 numButtons ++;
2667 }
2668 }
2669
2670 if (m_chkboxDismissButton->IsChecked())
2671 {
2672 if (m_radiobtnCancel->GetValue())
2673 {
2674 flags |= wxCANCEL;
2675 numButtons ++;
2676 }
2677
2678 else if (m_radiobtnClose->GetValue())
2679 {
2680 flags |= wxCLOSE;
2681 numButtons ++;
2682 }
2683
2684 }
2685
2686 if (m_chkboxApply->IsChecked())
2687 {
2688 flags |= wxAPPLY;
2689 numButtons ++;
2690 }
2691
2692 if (m_chkboxNo->IsChecked())
2693 {
2694 flags |= wxNO;
2695 numButtons ++;
2696 }
2697
2698 if (m_chkboxHelp->IsChecked())
2699 {
2700 flags |= wxHELP;
2701 numButtons ++;
2702 }
2703
2704 if (m_chkboxNoDefault->IsChecked())
2705 {
2706 flags |= wxNO_DEFAULT;
2707 }
2708
2709 m_buttonsSizer = CreateStdDialogButtonSizer(flags);
2710 GetSizer()->Add(m_buttonsSizer, 0, wxGROW|wxALL, 5);
2711
2712 Layout();
2713 GetSizer()->SetSizeHints(this);
2714 }
2715
2716 void StdButtonSizerDialog::EnableDisableControls()
2717 {
2718 const bool affButtonEnabled = m_chkboxAffirmativeButton->IsChecked();
2719
2720 m_radiobtnOk->Enable(affButtonEnabled);
2721 m_radiobtnYes->Enable(affButtonEnabled);
2722
2723 const bool dismissButtonEnabled = m_chkboxDismissButton->IsChecked();
2724
2725 m_radiobtnCancel->Enable(dismissButtonEnabled);
2726 m_radiobtnClose->Enable(dismissButtonEnabled);
2727 }
2728
2729 #if USE_SETTINGS_DIALOG
2730 // ----------------------------------------------------------------------------
2731 // SettingsDialog
2732 // ----------------------------------------------------------------------------
2733
2734 IMPLEMENT_CLASS(SettingsDialog, wxPropertySheetDialog)
2735
2736 BEGIN_EVENT_TABLE(SettingsDialog, wxPropertySheetDialog)
2737 END_EVENT_TABLE()
2738
2739 SettingsDialog::SettingsDialog(wxWindow* win, int dialogType)
2740 {
2741 SetExtraStyle(wxDIALOG_EX_CONTEXTHELP|wxWS_EX_VALIDATE_RECURSIVELY);
2742
2743 int tabImage1 = -1;
2744 int tabImage2 = -1;
2745
2746 bool useToolBook = (dialogType == DIALOGS_PROPERTY_SHEET_TOOLBOOK || dialogType == DIALOGS_PROPERTY_SHEET_BUTTONTOOLBOOK);
2747 int resizeBorder = wxRESIZE_BORDER;
2748
2749 if (useToolBook)
2750 {
2751 resizeBorder = 0;
2752 tabImage1 = 0;
2753 tabImage2 = 1;
2754
2755 int sheetStyle = wxPROPSHEET_SHRINKTOFIT;
2756 if (dialogType == DIALOGS_PROPERTY_SHEET_BUTTONTOOLBOOK)
2757 sheetStyle |= wxPROPSHEET_BUTTONTOOLBOOK;
2758 else
2759 sheetStyle |= wxPROPSHEET_TOOLBOOK;
2760
2761 SetSheetStyle(sheetStyle);
2762 SetSheetInnerBorder(0);
2763 SetSheetOuterBorder(0);
2764
2765 // create a dummy image list with a few icons
2766 const wxSize imageSize(32, 32);
2767
2768 m_imageList = new wxImageList(imageSize.GetWidth(), imageSize.GetHeight());
2769 m_imageList->
2770 Add(wxArtProvider::GetIcon(wxART_INFORMATION, wxART_OTHER, imageSize));
2771 m_imageList->
2772 Add(wxArtProvider::GetIcon(wxART_QUESTION, wxART_OTHER, imageSize));
2773 m_imageList->
2774 Add(wxArtProvider::GetIcon(wxART_WARNING, wxART_OTHER, imageSize));
2775 m_imageList->
2776 Add(wxArtProvider::GetIcon(wxART_ERROR, wxART_OTHER, imageSize));
2777 }
2778 else
2779 m_imageList = NULL;
2780
2781 Create(win, wxID_ANY, _("Preferences"), wxDefaultPosition, wxDefaultSize,
2782 wxDEFAULT_DIALOG_STYLE| (int)wxPlatform::IfNot(wxOS_WINDOWS_CE, resizeBorder)
2783 );
2784
2785 // If using a toolbook, also follow Mac style and don't create buttons
2786 if (!useToolBook)
2787 CreateButtons(wxOK | wxCANCEL |
2788 (int)wxPlatform::IfNot(wxOS_WINDOWS_CE, wxHELP)
2789 );
2790
2791 wxBookCtrlBase* notebook = GetBookCtrl();
2792 notebook->SetImageList(m_imageList);
2793
2794 wxPanel* generalSettings = CreateGeneralSettingsPage(notebook);
2795 wxPanel* aestheticSettings = CreateAestheticSettingsPage(notebook);
2796
2797 notebook->AddPage(generalSettings, _("General"), true, tabImage1);
2798 notebook->AddPage(aestheticSettings, _("Aesthetics"), false, tabImage2);
2799
2800 LayoutDialog();
2801 }
2802
2803 SettingsDialog::~SettingsDialog()
2804 {
2805 delete m_imageList;
2806 }
2807
2808 wxPanel* SettingsDialog::CreateGeneralSettingsPage(wxWindow* parent)
2809 {
2810 wxPanel* panel = new wxPanel(parent, wxID_ANY);
2811
2812 wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL );
2813 wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
2814
2815 //// LOAD LAST FILE
2816
2817 wxBoxSizer* itemSizer3 = new wxBoxSizer( wxHORIZONTAL );
2818 wxCheckBox* checkBox3 = new wxCheckBox(panel, ID_LOAD_LAST_PROJECT, _("&Load last project on startup"), wxDefaultPosition, wxDefaultSize);
2819 itemSizer3->Add(checkBox3, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2820 item0->Add(itemSizer3, 0, wxGROW|wxALL, 0);
2821
2822 //// AUTOSAVE
2823
2824 wxString autoSaveLabel = _("&Auto-save every");
2825 wxString minsLabel = _("mins");
2826
2827 wxBoxSizer* itemSizer12 = new wxBoxSizer( wxHORIZONTAL );
2828 wxCheckBox* checkBox12 = new wxCheckBox(panel, ID_AUTO_SAVE, autoSaveLabel, wxDefaultPosition, wxDefaultSize);
2829
2830 #if wxUSE_SPINCTRL
2831 wxSpinCtrl* spinCtrl12 = new wxSpinCtrl(panel, ID_AUTO_SAVE_MINS, wxEmptyString,
2832 wxDefaultPosition, wxSize(40, wxDefaultCoord), wxSP_ARROW_KEYS, 1, 60, 1);
2833 #endif
2834
2835 itemSizer12->Add(checkBox12, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2836 #if wxUSE_SPINCTRL
2837 itemSizer12->Add(spinCtrl12, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2838 #endif
2839 itemSizer12->Add(new wxStaticText(panel, wxID_STATIC, minsLabel), 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2840 item0->Add(itemSizer12, 0, wxGROW|wxALL, 0);
2841
2842 //// TOOLTIPS
2843
2844 wxBoxSizer* itemSizer8 = new wxBoxSizer( wxHORIZONTAL );
2845 wxCheckBox* checkBox6 = new wxCheckBox(panel, ID_SHOW_TOOLTIPS, _("Show &tooltips"), wxDefaultPosition, wxDefaultSize);
2846 itemSizer8->Add(checkBox6, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2847 item0->Add(itemSizer8, 0, wxGROW|wxALL, 0);
2848
2849 topSizer->Add( item0, 1, wxGROW|wxALIGN_CENTRE|wxALL, 5 );
2850
2851 panel->SetSizerAndFit(topSizer);
2852
2853 return panel;
2854 }
2855
2856 wxPanel* SettingsDialog::CreateAestheticSettingsPage(wxWindow* parent)
2857 {
2858 wxPanel* panel = new wxPanel(parent, wxID_ANY);
2859
2860 wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL );
2861 wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
2862
2863 //// PROJECT OR GLOBAL
2864 wxString globalOrProjectChoices[2];
2865 globalOrProjectChoices[0] = _("&New projects");
2866 globalOrProjectChoices[1] = _("&This project");
2867
2868 wxRadioBox* projectOrGlobal = new wxRadioBox(panel, ID_APPLY_SETTINGS_TO, _("&Apply settings to:"),
2869 wxDefaultPosition, wxDefaultSize, 2, globalOrProjectChoices);
2870 item0->Add(projectOrGlobal, 0, wxGROW|wxALL, 5);
2871
2872 projectOrGlobal->SetSelection(0);
2873
2874 //// BACKGROUND STYLE
2875 wxArrayString backgroundStyleChoices;
2876 backgroundStyleChoices.Add(wxT("Colour"));
2877 backgroundStyleChoices.Add(wxT("Image"));
2878 wxStaticBox* staticBox3 = new wxStaticBox(panel, wxID_ANY, _("Background style:"));
2879
2880 wxBoxSizer* styleSizer = new wxStaticBoxSizer( staticBox3, wxVERTICAL );
2881 item0->Add(styleSizer, 0, wxGROW|wxALL, 5);
2882
2883 wxBoxSizer* itemSizer2 = new wxBoxSizer( wxHORIZONTAL );
2884
2885 wxChoice* choice2 = new wxChoice(panel, ID_BACKGROUND_STYLE, wxDefaultPosition, wxDefaultSize, backgroundStyleChoices);
2886
2887 itemSizer2->Add(new wxStaticText(panel, wxID_ANY, _("&Window:")), 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2888 itemSizer2->Add(5, 5, 1, wxALL, 0);
2889 itemSizer2->Add(choice2, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2890
2891 styleSizer->Add(itemSizer2, 0, wxGROW|wxALL, 5);
2892
2893 #if wxUSE_SPINCTRL
2894 //// FONT SIZE SELECTION
2895
2896 wxStaticBox* staticBox1 = new wxStaticBox(panel, wxID_ANY, _("Tile font size:"));
2897 wxBoxSizer* itemSizer5 = new wxStaticBoxSizer( staticBox1, wxHORIZONTAL );
2898
2899 wxSpinCtrl* spinCtrl = new wxSpinCtrl(panel, ID_FONT_SIZE, wxEmptyString, wxDefaultPosition,
2900 wxSize(80, wxDefaultCoord));
2901 itemSizer5->Add(spinCtrl, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
2902
2903 item0->Add(itemSizer5, 0, wxGROW|wxLEFT|wxRIGHT, 5);
2904 #endif
2905
2906 topSizer->Add( item0, 1, wxGROW|wxALIGN_CENTRE|wxALL, 5 );
2907 topSizer->AddSpacer(5);
2908
2909 panel->SetSizerAndFit(topSizer);
2910
2911 return panel;
2912 }
2913
2914 #endif // USE_SETTINGS_DIALOG
2915
2916 #if wxUSE_MSGDLG
2917 // ----------------------------------------------------------------------------
2918 // TestMessageBoxDialog
2919 // ----------------------------------------------------------------------------
2920
2921 /* static */
2922 const TestMessageBoxDialog::BtnInfo TestMessageBoxDialog::ms_btnInfo[] =
2923 {
2924 { wxYES, "&Yes" },
2925 { wxNO, "&No" },
2926 { wxOK, "&Ok" },
2927 { wxCANCEL, "&Cancel" },
2928 { wxHELP, "&Help" },
2929 };
2930
2931 BEGIN_EVENT_TABLE(TestMessageBoxDialog, wxDialog)
2932 EVT_BUTTON(wxID_APPLY, TestMessageBoxDialog::OnApply)
2933 EVT_BUTTON(wxID_CLOSE, TestMessageBoxDialog::OnClose)
2934 END_EVENT_TABLE()
2935
2936 TestMessageBoxDialog::TestMessageBoxDialog(wxWindow *parent)
2937 : wxDialog(parent, wxID_ANY, "Message Box Test Dialog",
2938 wxDefaultPosition, wxDefaultSize,
2939 wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
2940 {
2941 }
2942
2943 bool TestMessageBoxDialog::Create()
2944 {
2945 wxSizer * const sizerTop = new wxBoxSizer(wxVERTICAL);
2946
2947 // this sizer allows to configure the messages shown in the message box
2948 wxSizer * const
2949 sizerMsgs = new wxStaticBoxSizer(wxVERTICAL, this, "&Messages");
2950 sizerMsgs->Add(new wxStaticText(this, wxID_ANY, "&Title:"));
2951 m_textTitle = new wxTextCtrl(this, wxID_ANY, "Test Message Box");
2952 sizerMsgs->Add(m_textTitle, wxSizerFlags().Expand().Border(wxBOTTOM));
2953
2954 sizerMsgs->Add(new wxStaticText(this, wxID_ANY, "&Main message:"));
2955 m_textMsg = new wxTextCtrl(this, wxID_ANY, "Hello from a box!",
2956 wxDefaultPosition, wxDefaultSize,
2957 wxTE_MULTILINE);
2958 sizerMsgs->Add(m_textMsg, wxSizerFlags(1).Expand().Border(wxBOTTOM));
2959
2960 sizerMsgs->Add(new wxStaticText(this, wxID_ANY, "&Extended message:"));
2961 m_textExtMsg = new wxTextCtrl(this, wxID_ANY, "",
2962 wxDefaultPosition, wxDefaultSize,
2963 wxTE_MULTILINE);
2964 sizerMsgs->Add(m_textExtMsg, wxSizerFlags(1).Expand());
2965
2966 sizerTop->Add(sizerMsgs, wxSizerFlags(1).Expand().Border());
2967
2968 // if a derived class provides more message configurations, add these.
2969 AddAdditionalTextOptions(sizerTop);
2970
2971 // this one is for configuring the buttons
2972 wxSizer * const
2973 sizerBtnsBox = new wxStaticBoxSizer(wxVERTICAL, this, "&Buttons");
2974
2975 wxFlexGridSizer * const sizerBtns = new wxFlexGridSizer(2, 5, 5);
2976 sizerBtns->AddGrowableCol(1);
2977
2978 sizerBtns->Add(new wxStaticText(this, wxID_ANY, "Button(s)"));
2979 sizerBtns->Add(new wxStaticText(this, wxID_ANY, "Custom label"));
2980
2981 for ( int n = 0; n < Btn_Max; n++ )
2982 {
2983 m_buttons[n] = new wxCheckBox(this, wxID_ANY, ms_btnInfo[n].name);
2984 sizerBtns->Add(m_buttons[n], wxSizerFlags().Centre().Left());
2985
2986 m_labels[n] = new wxTextCtrl(this, wxID_ANY);
2987 sizerBtns->Add(m_labels[n], wxSizerFlags(1).Centre().Expand());
2988
2989 m_labels[n]->Connect(wxEVT_UPDATE_UI,
2990 wxUpdateUIEventHandler(
2991 TestMessageBoxDialog::OnUpdateLabelUI),
2992 NULL,
2993 this);
2994 }
2995
2996 sizerBtnsBox->Add(sizerBtns, wxSizerFlags(1).Expand());
2997 sizerTop->Add(sizerBtnsBox, wxSizerFlags().Expand().Border());
2998
2999
3000 // icon choice
3001 const wxString icons[] =
3002 {
3003 "&Not specified",
3004 "E&xplicitly none",
3005 "&Information icon",
3006 "&Question icon",
3007 "&Warning icon",
3008 "&Error icon"
3009 };
3010
3011 wxCOMPILE_TIME_ASSERT( WXSIZEOF(icons) == MsgDlgIcon_Max, IconMismatch );
3012
3013 m_icons = new wxRadioBox(this, wxID_ANY, "&Icon style",
3014 wxDefaultPosition, wxDefaultSize,
3015 WXSIZEOF(icons), icons,
3016 2, wxRA_SPECIFY_ROWS);
3017 // Make the 'Information' icon the default one:
3018 m_icons->SetSelection(MsgDlgIcon_Info);
3019 sizerTop->Add(m_icons, wxSizerFlags().Expand().Border());
3020
3021
3022 // miscellaneous other stuff
3023 wxSizer * const
3024 sizerFlags = new wxStaticBoxSizer(wxHORIZONTAL, this, "&Other flags");
3025
3026 m_chkNoDefault = new wxCheckBox(this, wxID_ANY, "Make \"No\" &default");
3027 m_chkNoDefault->Connect(wxEVT_UPDATE_UI,
3028 wxUpdateUIEventHandler(
3029 TestMessageBoxDialog::OnUpdateNoDefaultUI),
3030 NULL,
3031 this);
3032 sizerFlags->Add(m_chkNoDefault, wxSizerFlags(1).Border());
3033
3034 m_chkCentre = new wxCheckBox(this, wxID_ANY, "Centre on &parent");
3035 sizerFlags->Add(m_chkCentre, wxSizerFlags(1).Border());
3036
3037 // add any additional flag from subclasses
3038 AddAdditionalFlags(sizerFlags);
3039
3040 sizerTop->Add(sizerFlags, wxSizerFlags().Expand().Border());
3041
3042 // finally buttons to show the resulting message box and close this dialog
3043 sizerTop->Add(CreateStdDialogButtonSizer(wxAPPLY | wxCLOSE),
3044 wxSizerFlags().Right().Border());
3045
3046 SetSizerAndFit(sizerTop);
3047
3048 m_buttons[Btn_Ok]->SetValue(true);
3049
3050 return true;
3051 }
3052
3053 void TestMessageBoxDialog::OnUpdateLabelUI(wxUpdateUIEvent& event)
3054 {
3055 for ( int n = 0; n < Btn_Max; n++ )
3056 {
3057 if ( event.GetEventObject() == m_labels[n] )
3058 {
3059 event.Enable( m_buttons[n]->IsChecked() );
3060 return;
3061 }
3062 }
3063
3064 wxFAIL_MSG( "called for unknown label" );
3065 }
3066
3067 void TestMessageBoxDialog::OnUpdateNoDefaultUI(wxUpdateUIEvent& event)
3068 {
3069 event.Enable( m_buttons[Btn_No]->IsChecked() );
3070 }
3071
3072 long TestMessageBoxDialog::GetStyle()
3073 {
3074 long style = 0;
3075
3076 for ( int n = 0; n < Btn_Max; n++ )
3077 {
3078 if ( m_buttons[n]->IsChecked() )
3079 style |= ms_btnInfo[n].flag;
3080 }
3081
3082 switch ( m_icons->GetSelection() )
3083 {
3084 case MsgDlgIcon_Max:
3085 wxFAIL_MSG( "unexpected selection" );
3086
3087 case MsgDlgIcon_No:
3088 break;
3089
3090 case MsgDlgIcon_None:
3091 style |= wxICON_NONE;
3092 break;
3093
3094 case MsgDlgIcon_Info:
3095 style |= wxICON_INFORMATION;
3096 break;
3097
3098 case MsgDlgIcon_Question:
3099 style |= wxICON_QUESTION;
3100 break;
3101
3102 case MsgDlgIcon_Warning:
3103 style |= wxICON_WARNING;
3104 break;
3105
3106 case MsgDlgIcon_Error:
3107 style |= wxICON_ERROR;
3108 break;
3109 }
3110
3111 if ( m_chkCentre->IsChecked() )
3112 style |= wxCENTRE;
3113
3114 if ( m_chkNoDefault->IsEnabled() && m_chkNoDefault->IsChecked() )
3115 style |= wxNO_DEFAULT;
3116
3117 return style;
3118 }
3119
3120 void TestMessageBoxDialog::PrepareMessageDialog(wxMessageDialogBase &dlg)
3121 {
3122 long style = dlg.GetMessageDialogStyle();
3123
3124 if ( !m_textExtMsg->IsEmpty() )
3125 dlg.SetExtendedMessage(m_textExtMsg->GetValue());
3126
3127 if ( style & wxYES_NO )
3128 {
3129 if ( style & wxCANCEL )
3130 {
3131 dlg.SetYesNoCancelLabels(m_labels[Btn_Yes]->GetValue(),
3132 m_labels[Btn_No]->GetValue(),
3133 m_labels[Btn_Cancel]->GetValue());
3134 }
3135 else
3136 {
3137 dlg.SetYesNoLabels(m_labels[Btn_Yes]->GetValue(),
3138 m_labels[Btn_No]->GetValue());
3139 }
3140 }
3141 else
3142 {
3143 if ( style & wxCANCEL )
3144 {
3145 dlg.SetOKCancelLabels(m_labels[Btn_Ok]->GetValue(),
3146 m_labels[Btn_Cancel]->GetValue());
3147 }
3148 else
3149 {
3150 dlg.SetOKLabel(m_labels[Btn_Ok]->GetValue());
3151 }
3152 }
3153
3154 if ( style & wxHELP )
3155 {
3156 dlg.SetHelpLabel(m_labels[Btn_Help]->GetValue());
3157 }
3158 }
3159
3160 void TestMessageBoxDialog::OnApply(wxCommandEvent& WXUNUSED(event))
3161 {
3162 wxMessageDialog dlg(this, GetMessage(), GetBoxTitle(), GetStyle());
3163 PrepareMessageDialog(dlg);
3164
3165 wxString btnName;
3166 switch ( dlg.ShowModal() )
3167 {
3168 case wxID_OK:
3169 btnName = "OK";
3170 break;
3171
3172 case wxID_CANCEL:
3173 // Avoid the extra message box if the dialog was cancelled.
3174 return;
3175
3176 case wxID_YES:
3177 btnName = "Yes";
3178 break;
3179
3180 case wxID_NO:
3181 btnName = "No";
3182 break;
3183
3184 case wxID_HELP:
3185 btnName = "Help";
3186 break;
3187
3188 default:
3189 btnName = "Unknown";
3190 }
3191
3192 wxLogMessage("Dialog was closed with the \"%s\" button.", btnName);
3193 }
3194
3195 void TestMessageBoxDialog::OnClose(wxCommandEvent& WXUNUSED(event))
3196 {
3197 EndModal(wxID_CANCEL);
3198 }
3199 #endif // wxUSE_MSGDLG
3200
3201 #if wxUSE_RICHMSGDLG
3202 // ----------------------------------------------------------------------------
3203 // TestRichMessageDialog
3204 // ----------------------------------------------------------------------------
3205
3206 BEGIN_EVENT_TABLE(TestRichMessageDialog, TestMessageBoxDialog)
3207 EVT_BUTTON(wxID_APPLY, TestRichMessageDialog::OnApply)
3208 END_EVENT_TABLE()
3209
3210 TestRichMessageDialog::TestRichMessageDialog(wxWindow *parent)
3211 : TestMessageBoxDialog(parent)
3212 {
3213 SetTitle("Rich Message Dialog Test Dialog");
3214 }
3215
3216 void TestRichMessageDialog::AddAdditionalTextOptions(wxSizer *sizer)
3217 {
3218 wxSizer * const sizerMsgs = new wxStaticBoxSizer(wxVERTICAL, this,
3219 "&Additional Elements");
3220
3221 // add a option to show a check box.
3222 wxFlexGridSizer * const sizerCheckBox = new wxFlexGridSizer(2, 5, 5);
3223 sizerCheckBox->AddGrowableCol(1);
3224 sizerCheckBox->Add(new wxStaticText(this, wxID_ANY, "&Check box:"));
3225 m_textCheckBox = new wxTextCtrl(this, wxID_ANY);
3226 sizerCheckBox->Add(m_textCheckBox, wxSizerFlags(1).Expand().Border(wxBOTTOM));
3227 sizerMsgs->Add(sizerCheckBox, wxSizerFlags(1).Expand());
3228
3229 // add option to show a detailed text.
3230 sizerMsgs->Add(new wxStaticText(this, wxID_ANY, "&Detailed message:"));
3231 m_textDetailed = new wxTextCtrl(this, wxID_ANY, "",
3232 wxDefaultPosition, wxDefaultSize,
3233 wxTE_MULTILINE);
3234 sizerMsgs->Add(m_textDetailed, wxSizerFlags(1).Expand());
3235
3236 sizer->Add(sizerMsgs, wxSizerFlags(1).Expand().Border());
3237 }
3238
3239 void TestRichMessageDialog::AddAdditionalFlags(wxSizer *sizer)
3240 {
3241 // add checkbox to set the initial state for the checkbox shown
3242 // in the dialog.
3243 m_initialValueCheckBox =
3244 new wxCheckBox(this, wxID_ANY, "Checkbox initially checked");
3245 sizer->Add(m_initialValueCheckBox, wxSizerFlags(1).Border());
3246 }
3247
3248 void TestRichMessageDialog::OnApply(wxCommandEvent& WXUNUSED(event))
3249 {
3250 wxRichMessageDialog dlg(this, GetMessage(), GetBoxTitle(), GetStyle());
3251 PrepareMessageDialog(dlg);
3252
3253 dlg.ShowCheckBox(m_textCheckBox->GetValue(),
3254 m_initialValueCheckBox->GetValue());
3255 dlg.ShowDetailedText(m_textDetailed->GetValue());
3256
3257 dlg.ShowModal();
3258 }
3259
3260 #endif // wxUSE_RICHMSGDLG
3261
3262 #if wxUSE_LOG
3263
3264 // ----------------------------------------------------------------------------
3265 // custom log target
3266 // ----------------------------------------------------------------------------
3267
3268 class MyLogGui : public wxLogGui
3269 {
3270 private:
3271 virtual void DoShowSingleLogMessage(const wxString& message,
3272 const wxString& title,
3273 int style)
3274 {
3275 wxMessageDialog dlg(NULL, message, title,
3276 wxOK | wxCANCEL | wxCANCEL_DEFAULT | style);
3277 dlg.SetOKCancelLabels(wxID_COPY, wxID_OK);
3278 dlg.SetExtendedMessage("Note that this is a custom log dialog.");
3279 dlg.ShowModal();
3280 }
3281 };
3282
3283 wxLog *MyAppTraits::CreateLogTarget()
3284 {
3285 return new MyLogGui;
3286 }
3287
3288 #endif // wxUSE_LOG
wxWidgets (Impactor)