]> 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
put both versions of wxGetMousePosition in one place so they can use one implementation
[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", "&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
1865 // Lay them out.
1866 m_textBody->SetMinSize(wxSize(300, 200));
1867
1868 wxBoxSizer* const sizer = new wxBoxSizer(wxVERTICAL);
1869 sizer->Add(m_textTitle, wxSizerFlags().Expand().Border());
1870 sizer->Add(m_textBody, wxSizerFlags(1).Expand().Border());
1871 sizer->Add(m_icons, wxSizerFlags().Expand().Border());
1872 sizer->Add(m_tipKinds, wxSizerFlags().Centre().Border());
1873 sizer->Add(m_bgStyles, wxSizerFlags().Centre().Border());
1874 sizer->Add(m_timeouts, wxSizerFlags().Centre().Border());
1875 wxBoxSizer* const sizerBtns = new wxBoxSizer(wxHORIZONTAL);
1876 sizerBtns->Add(btnShowText, wxSizerFlags().Border(wxRIGHT));
1877 sizerBtns->Add(btnShowBtn, wxSizerFlags().Border(wxLEFT));
1878 sizer->Add(sizerBtns, wxSizerFlags().Centre().Border());
1879 sizer->Add(CreateStdDialogButtonSizer(wxOK),
1880 wxSizerFlags().Expand().Border());
1881 SetSizerAndFit(sizer);
1882
1883
1884 // And connect the event handlers.
1885 btnShowText->Connect
1886 (
1887 wxEVT_COMMAND_BUTTON_CLICKED,
1888 wxCommandEventHandler(RichTipDialog::OnShowTipForText),
1889 NULL,
1890 this
1891 );
1892
1893 btnShowBtn->Connect
1894 (
1895 wxEVT_COMMAND_BUTTON_CLICKED,
1896 wxCommandEventHandler(RichTipDialog::OnShowTipForBtn),
1897 NULL,
1898 this
1899 );
1900 }
1901
1902 private:
1903 enum
1904 {
1905 Icon_None,
1906 Icon_Info,
1907 Icon_Warning,
1908 Icon_Error,
1909 Icon_Custom,
1910 Icon_Max
1911 };
1912
1913 enum
1914 {
1915 Bg_Default,
1916 Bg_Solid,
1917 Bg_Gradient,
1918 Bg_Max
1919 };
1920
1921 enum
1922 {
1923 Timeout_None,
1924 Timeout_Default,
1925 Timeout_3sec,
1926 Timeout_Max
1927 };
1928
1929
1930 void OnShowTipForText(wxCommandEvent& WXUNUSED(event))
1931 {
1932 DoShowTip(m_textTitle);
1933 }
1934
1935 void OnShowTipForBtn(wxCommandEvent& WXUNUSED(event))
1936 {
1937 DoShowTip(FindWindow(wxID_OK));
1938 }
1939
1940 void DoShowTip(wxWindow* win)
1941 {
1942 wxRichToolTip tip(m_textTitle->GetValue(), m_textBody->GetValue());
1943 const int iconSel = m_icons->GetSelection();
1944 if ( iconSel == Icon_Custom )
1945 {
1946 tip.SetIcon(tip_xpm);
1947 }
1948 else // Use a standard icon.
1949 {
1950 static const int stdIcons[] =
1951 {
1952 wxICON_NONE,
1953 wxICON_INFORMATION,
1954 wxICON_WARNING,
1955 wxICON_ERROR,
1956 };
1957
1958 tip.SetIcon(stdIcons[iconSel]);
1959 }
1960
1961 switch ( m_bgStyles->GetSelection() )
1962 {
1963 case Bg_Default:
1964 break;
1965
1966 case Bg_Solid:
1967 tip.SetBackgroundColour(*wxLIGHT_GREY);
1968 break;
1969
1970 case Bg_Gradient:
1971 tip.SetBackgroundColour(*wxWHITE, wxColour(0xe4, 0xe5, 0xf0));
1972 break;
1973 }
1974
1975 switch ( m_timeouts->GetSelection() )
1976 {
1977 case Timeout_None:
1978 tip.SetTimeout(0);
1979 break;
1980
1981 case Timeout_Default:
1982 break;
1983
1984 case Timeout_3sec:
1985 tip.SetTimeout(3000);
1986 break;
1987 }
1988
1989 tip.SetTipKind(static_cast<wxTipKind>(m_tipKinds->GetSelection()));
1990
1991 tip.ShowFor(win);
1992 }
1993
1994 wxTextCtrl* m_textTitle;
1995 wxTextCtrl* m_textBody;
1996 wxRadioBox* m_icons;
1997 wxRadioBox* m_tipKinds;
1998 wxRadioBox* m_bgStyles;
1999 wxRadioBox* m_timeouts;
2000 };
2001
2002 void MyFrame::OnRichTipDialog(wxCommandEvent& WXUNUSED(event))
2003 {
2004 RichTipDialog dialog(this);
2005 dialog.ShowModal();
2006 }
2007
2008 #endif // wxUSE_RICHTOOLTIP
2009
2010 void MyFrame::OnStandardButtonsSizerDialog(wxCommandEvent& WXUNUSED(event))
2011 {
2012 StdButtonSizerDialog dialog(this);
2013 dialog.ShowModal();
2014 }
2015
2016 // TestDefaultAction
2017
2018 #define ID_CATCH_LISTBOX_DCLICK 100
2019 #define ID_LISTBOX 101
2020 #define ID_DISABLE_OK 102
2021 #define ID_DISABLE_CANCEL 103
2022
2023 BEGIN_EVENT_TABLE(TestDefaultActionDialog, wxDialog)
2024 EVT_CHECKBOX(ID_CATCH_LISTBOX_DCLICK, TestDefaultActionDialog::OnCatchListBoxDClick)
2025 EVT_CHECKBOX(ID_DISABLE_OK, TestDefaultActionDialog::OnDisableOK)
2026 EVT_CHECKBOX(ID_DISABLE_CANCEL, TestDefaultActionDialog::OnDisableCancel)
2027 EVT_LISTBOX_DCLICK(ID_LISTBOX, TestDefaultActionDialog::OnListBoxDClick)
2028 EVT_TEXT_ENTER(wxID_ANY, TestDefaultActionDialog::OnTextEnter)
2029 END_EVENT_TABLE()
2030
2031 TestDefaultActionDialog::TestDefaultActionDialog( wxWindow *parent ) :
2032 wxDialog( parent, -1, "Test default action" )
2033 {
2034 m_catchListBoxDClick = false;
2035
2036 wxBoxSizer *main_sizer = new wxBoxSizer( wxVERTICAL );
2037
2038 wxFlexGridSizer *grid_sizer = new wxFlexGridSizer( 2, 5, 5 );
2039
2040 #if wxUSE_LISTBOX
2041 wxListBox *listbox = new wxListBox( this, ID_LISTBOX );
2042 listbox->Append( "String 1" );
2043 listbox->Append( "String 2" );
2044 listbox->Append( "String 3" );
2045 listbox->Append( "String 4" );
2046 grid_sizer->Add( listbox );
2047 #endif // wxUSE_LISTBOX
2048
2049 grid_sizer->Add( new wxCheckBox( this, ID_CATCH_LISTBOX_DCLICK, "Catch DoubleClick from wxListBox" ), 0, wxALIGN_CENTRE_VERTICAL );
2050
2051 grid_sizer->Add( new wxTextCtrl( this, -1, "", wxDefaultPosition, wxSize(80,-1), 0 ), 0, wxALIGN_CENTRE_VERTICAL );
2052 grid_sizer->Add( new wxStaticText( this, -1, "wxTextCtrl without wxTE_PROCESS_ENTER" ), 0, wxALIGN_CENTRE_VERTICAL );
2053
2054 grid_sizer->Add( new wxTextCtrl( this, -1, "", wxDefaultPosition, wxSize(80,-1), wxTE_PROCESS_ENTER ), 0, wxALIGN_CENTRE_VERTICAL );
2055 grid_sizer->Add( new wxStaticText( this, -1, "wxTextCtrl with wxTE_PROCESS_ENTER" ), 0, wxALIGN_CENTRE_VERTICAL );
2056
2057 grid_sizer->Add( new wxCheckBox(this, ID_DISABLE_OK, "Disable \"OK\""), 0, wxALIGN_CENTRE_VERTICAL );
2058 grid_sizer->Add( new wxCheckBox(this, ID_DISABLE_CANCEL, "Disable \"Cancel\""), 0, wxALIGN_CENTRE_VERTICAL );
2059
2060 main_sizer->Add( grid_sizer, 0, wxALL, 10 );
2061
2062 wxSizer *button_sizer = CreateSeparatedButtonSizer( wxOK|wxCANCEL );
2063 if (button_sizer)
2064 main_sizer->Add( button_sizer, 0, wxALL|wxGROW, 5 );
2065
2066 SetSizerAndFit( main_sizer );
2067 }
2068
2069 void TestDefaultActionDialog::OnDisableOK(wxCommandEvent& event)
2070 {
2071 FindWindow(wxID_OK)->Enable(!event.IsChecked());
2072 }
2073
2074 void TestDefaultActionDialog::OnDisableCancel(wxCommandEvent& event)
2075 {
2076 FindWindow(wxID_CANCEL)->Enable(!event.IsChecked());
2077 }
2078
2079 void TestDefaultActionDialog::OnListBoxDClick(wxCommandEvent& event)
2080 {
2081 event.Skip( !m_catchListBoxDClick );
2082 }
2083
2084 void TestDefaultActionDialog::OnCatchListBoxDClick(wxCommandEvent& WXUNUSED(event))
2085 {
2086 m_catchListBoxDClick = !m_catchListBoxDClick;
2087 }
2088
2089 void TestDefaultActionDialog::OnTextEnter(wxCommandEvent& event)
2090 {
2091 wxLogMessage("Text \"%s\" entered.", event.GetString());
2092 }
2093
2094 void MyFrame::OnTestDefaultActionDialog(wxCommandEvent& WXUNUSED(event))
2095 {
2096 TestDefaultActionDialog dialog( this );
2097 dialog.ShowModal();
2098 }
2099
2100 void MyFrame::OnExit(wxCommandEvent& WXUNUSED(event) )
2101 {
2102 Close(true);
2103 }
2104
2105 #if wxUSE_PROGRESSDLG
2106
2107 void MyFrame::ShowProgress( wxCommandEvent& WXUNUSED(event) )
2108 {
2109 static const int max = 100;
2110
2111 wxProgressDialog dialog("Progress dialog example",
2112 // "Reserve" enough space for the multiline
2113 // messages below, we'll change it anyhow
2114 // immediately in the loop below
2115 wxString(' ', 100) + "\n\n\n\n",
2116 max, // range
2117 this, // parent
2118 wxPD_CAN_ABORT |
2119 wxPD_CAN_SKIP |
2120 wxPD_APP_MODAL |
2121 //wxPD_AUTO_HIDE | // -- try this as well
2122 wxPD_ELAPSED_TIME |
2123 wxPD_ESTIMATED_TIME |
2124 wxPD_REMAINING_TIME |
2125 wxPD_SMOOTH // - makes indeterminate mode bar on WinXP very small
2126 );
2127
2128 bool cont = true;
2129 for ( int i = 0; i <= max; i++ )
2130 {
2131 wxString msg;
2132
2133 // test both modes of wxProgressDialog behaviour: start in
2134 // indeterminate mode but switch to the determinate one later
2135 const bool determinate = i > max/2;
2136
2137 if ( i == max )
2138 {
2139 msg = "That's all, folks!\n"
2140 "\n"
2141 "Nothing to see here any more.";
2142 }
2143 else if ( !determinate )
2144 {
2145 msg = "Testing indeterminate mode\n"
2146 "\n"
2147 "This mode allows you to show to the user\n"
2148 "that something is going on even if you don't know\n"
2149 "when exactly will you finish.";
2150 }
2151 else if ( determinate )
2152 {
2153 msg = "Now in standard determinate mode\n"
2154 "\n"
2155 "This is the standard usage mode in which you\n"
2156 "update the dialog after performing each new step of work.\n"
2157 "It requires knowing the total number of steps in advance.";
2158 }
2159
2160 // will be set to true if "Skip" button was pressed
2161 bool skip = false;
2162 if ( determinate )
2163 {
2164 cont = dialog.Update(i, msg, &skip);
2165 }
2166 else
2167 {
2168 cont = dialog.Pulse(msg, &skip);
2169 }
2170
2171 // each skip will move progress about quarter forward
2172 if ( skip )
2173 {
2174 i += max/4;
2175
2176 if ( i >= 100 )
2177 i = 99;
2178 }
2179
2180 if ( !cont )
2181 {
2182 if ( wxMessageBox(wxT("Do you really want to cancel?"),
2183 wxT("Progress dialog question"), // caption
2184 wxYES_NO | wxICON_QUESTION) == wxYES )
2185 break;
2186
2187 cont = true;
2188 dialog.Resume();
2189 }
2190
2191 wxMilliSleep(200);
2192 }
2193
2194 if ( !cont )
2195 {
2196 wxLogStatus(wxT("Progress dialog aborted!"));
2197 }
2198 else
2199 {
2200 wxLogStatus(wxT("Countdown from %d finished"), max);
2201 }
2202 }
2203
2204 #endif // wxUSE_PROGRESSDLG
2205
2206 #if wxUSE_ABOUTDLG
2207
2208 static void InitAboutInfoMinimal(wxAboutDialogInfo& info)
2209 {
2210 info.SetName(wxT("Dialogs Sample"));
2211 info.SetVersion(wxVERSION_NUM_DOT_STRING,
2212 wxString::Format
2213 (
2214 "%s version %s",
2215 wxMINOR_VERSION % 2 ? "Development" : "Stable",
2216 wxVERSION_NUM_DOT_STRING
2217 ));
2218 info.SetDescription(wxT("This sample shows different wxWidgets dialogs"));
2219 info.SetCopyright(wxT("(C) 1998-2006 wxWidgets dev team"));
2220 info.AddDeveloper(wxT("Vadim Zeitlin"));
2221 }
2222
2223 static void InitAboutInfoWebsite(wxAboutDialogInfo& info)
2224 {
2225 InitAboutInfoMinimal(info);
2226
2227 info.SetWebSite(wxT("http://www.wxwidgets.org/"), wxT("wxWidgets web site"));
2228 }
2229
2230 static void InitAboutInfoAll(wxAboutDialogInfo& info)
2231 {
2232 InitAboutInfoWebsite(info);
2233
2234 // we can add a second developer
2235 info.AddDeveloper(wxT("A.N. Other"));
2236
2237 // or we can add several persons at once like this
2238 static const wxChar *docwriters[] =
2239 {
2240 wxT("First D. Writer"),
2241 wxT("Second One"),
2242 };
2243
2244 info.SetDocWriters(wxArrayString(WXSIZEOF(docwriters), docwriters));
2245 info.SetLicence(wxString::FromAscii(
2246 " wxWindows Library Licence, Version 3.1\n"
2247 " ======================================\n"
2248 "\n"
2249 " Copyright (c) 1998-2005 Julian Smart, Robert Roebling et al\n"
2250 "\n"
2251 " Everyone is permitted to copy and distribute verbatim copies\n"
2252 " of this licence document, but changing it is not allowed.\n"
2253 "\n"
2254 " WXWINDOWS LIBRARY LICENCE\n"
2255 " TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n"
2256 "\n"
2257 " ...and so on and so forth...\n"
2258 ));
2259
2260 info.AddTranslator(wxT("Wun Ngo Wen (Martian)"));
2261 }
2262
2263 void MyFrame::ShowSimpleAboutDialog(wxCommandEvent& WXUNUSED(event))
2264 {
2265 wxAboutDialogInfo info;
2266 InitAboutInfoMinimal(info);
2267
2268 wxAboutBox(info, this);
2269 }
2270
2271 void MyFrame::ShowFancyAboutDialog(wxCommandEvent& WXUNUSED(event))
2272 {
2273 wxAboutDialogInfo info;
2274 InitAboutInfoWebsite(info);
2275
2276 wxAboutBox(info, this);
2277 }
2278
2279 void MyFrame::ShowFullAboutDialog(wxCommandEvent& WXUNUSED(event))
2280 {
2281 wxAboutDialogInfo info;
2282 InitAboutInfoAll(info);
2283
2284 wxAboutBox(info, this);
2285 }
2286
2287 // a trivial example of a custom dialog class
2288 class MyAboutDialog : public wxGenericAboutDialog
2289 {
2290 public:
2291 MyAboutDialog(const wxAboutDialogInfo& info, wxWindow* parent)
2292 {
2293 Create(info, parent);
2294 }
2295
2296 // add some custom controls
2297 virtual void DoAddCustomControls()
2298 {
2299 AddControl(new wxStaticLine(this), wxSizerFlags().Expand());
2300 AddText(wxT("Some custom text"));
2301 AddControl(new wxStaticLine(this), wxSizerFlags().Expand());
2302 }
2303 };
2304
2305 void MyFrame::ShowCustomAboutDialog(wxCommandEvent& WXUNUSED(event))
2306 {
2307 wxAboutDialogInfo info;
2308 InitAboutInfoAll(info);
2309
2310 MyAboutDialog dlg(info, this);
2311 dlg.ShowModal();
2312 }
2313
2314 #endif // wxUSE_ABOUTDLG
2315
2316 #if wxUSE_BUSYINFO
2317
2318 void MyFrame::ShowBusyInfo(wxCommandEvent& WXUNUSED(event))
2319 {
2320 wxWindowDisabler disableAll;
2321
2322 wxBusyInfo info(wxT("Working, please wait..."), this);
2323
2324 for ( int i = 0; i < 18; i++ )
2325 {
2326 wxMilliSleep(100);
2327 wxTheApp->Yield();
2328 }
2329
2330 wxSleep(2);
2331 //wxWakeUpIdle();
2332 }
2333
2334 #endif // wxUSE_BUSYINFO
2335
2336 #if wxUSE_FINDREPLDLG
2337
2338 void MyFrame::ShowReplaceDialog( wxCommandEvent& WXUNUSED(event) )
2339 {
2340 if ( m_dlgReplace )
2341 {
2342 wxDELETE(m_dlgReplace);
2343 }
2344 else
2345 {
2346 m_dlgReplace = new wxFindReplaceDialog
2347 (
2348 this,
2349 &m_findData,
2350 wxT("Find and replace dialog"),
2351 wxFR_REPLACEDIALOG
2352 );
2353
2354 m_dlgReplace->Show(true);
2355 }
2356 }
2357
2358 void MyFrame::ShowFindDialog( wxCommandEvent& WXUNUSED(event) )
2359 {
2360 if ( m_dlgFind )
2361 {
2362 wxDELETE(m_dlgFind);
2363 }
2364 else
2365 {
2366 m_dlgFind = new wxFindReplaceDialog
2367 (
2368 this,
2369 &m_findData,
2370 wxT("Find dialog"),
2371 // just for testing
2372 wxFR_NOWHOLEWORD
2373 );
2374
2375 m_dlgFind->Show(true);
2376 }
2377 }
2378
2379 static wxString DecodeFindDialogEventFlags(int flags)
2380 {
2381 wxString str;
2382 str << (flags & wxFR_DOWN ? wxT("down") : wxT("up")) << wxT(", ")
2383 << (flags & wxFR_WHOLEWORD ? wxT("whole words only, ") : wxT(""))
2384 << (flags & wxFR_MATCHCASE ? wxT("") : wxT("not "))
2385 << wxT("case sensitive");
2386
2387 return str;
2388 }
2389
2390 void MyFrame::OnFindDialog(wxFindDialogEvent& event)
2391 {
2392 wxEventType type = event.GetEventType();
2393
2394 if ( type == wxEVT_COMMAND_FIND || type == wxEVT_COMMAND_FIND_NEXT )
2395 {
2396 wxLogMessage(wxT("Find %s'%s' (flags: %s)"),
2397 type == wxEVT_COMMAND_FIND_NEXT ? wxT("next ") : wxT(""),
2398 event.GetFindString().c_str(),
2399 DecodeFindDialogEventFlags(event.GetFlags()).c_str());
2400 }
2401 else if ( type == wxEVT_COMMAND_FIND_REPLACE ||
2402 type == wxEVT_COMMAND_FIND_REPLACE_ALL )
2403 {
2404 wxLogMessage(wxT("Replace %s'%s' with '%s' (flags: %s)"),
2405 type == wxEVT_COMMAND_FIND_REPLACE_ALL ? wxT("all ") : wxT(""),
2406 event.GetFindString().c_str(),
2407 event.GetReplaceString().c_str(),
2408 DecodeFindDialogEventFlags(event.GetFlags()).c_str());
2409 }
2410 else if ( type == wxEVT_COMMAND_FIND_CLOSE )
2411 {
2412 wxFindReplaceDialog *dlg = event.GetDialog();
2413
2414 int idMenu;
2415 const wxChar *txt;
2416 if ( dlg == m_dlgFind )
2417 {
2418 txt = wxT("Find");
2419 idMenu = DIALOGS_FIND;
2420 m_dlgFind = NULL;
2421 }
2422 else if ( dlg == m_dlgReplace )
2423 {
2424 txt = wxT("Replace");
2425 idMenu = DIALOGS_REPLACE;
2426 m_dlgReplace = NULL;
2427 }
2428 else
2429 {
2430 txt = wxT("Unknown");
2431 idMenu = wxID_ANY;
2432
2433 wxFAIL_MSG( wxT("unexpected event") );
2434 }
2435
2436 wxLogMessage(wxT("%s dialog is being closed."), txt);
2437
2438 if ( idMenu != wxID_ANY )
2439 {
2440 GetMenuBar()->Check(idMenu, false);
2441 }
2442
2443 dlg->Destroy();
2444 }
2445 else
2446 {
2447 wxLogError(wxT("Unknown find dialog event!"));
2448 }
2449 }
2450
2451 #endif // wxUSE_FINDREPLDLG
2452
2453 // ----------------------------------------------------------------------------
2454 // MyCanvas
2455 // ----------------------------------------------------------------------------
2456
2457 void MyCanvas::OnPaint(wxPaintEvent& WXUNUSED(event) )
2458 {
2459 wxPaintDC dc(this);
2460 dc.SetBackgroundMode(wxTRANSPARENT);
2461 dc.DrawText(
2462 wxT("wxWidgets common dialogs")
2463 #if !defined(__SMARTPHONE__)
2464 wxT(" test application")
2465 #endif
2466 , 10, 10);
2467 }
2468
2469 #if USE_MODAL_PRESENTATION
2470
2471 // ----------------------------------------------------------------------------
2472 // MyModelessDialog
2473 // ----------------------------------------------------------------------------
2474
2475 MyModelessDialog::MyModelessDialog(wxWindow *parent)
2476 : wxDialog(parent, wxID_ANY, wxString(wxT("Modeless dialog")))
2477 {
2478 wxBoxSizer *sizerTop = new wxBoxSizer(wxVERTICAL);
2479
2480 wxButton *btn = new wxButton(this, DIALOGS_MODELESS_BTN, wxT("Press me"));
2481 wxCheckBox *check = new wxCheckBox(this, wxID_ANY, wxT("Should be disabled"));
2482 check->Disable();
2483
2484 sizerTop->Add(btn, 1, wxEXPAND | wxALL, 5);
2485 sizerTop->Add(check, 1, wxEXPAND | wxALL, 5);
2486
2487 SetSizerAndFit(sizerTop);
2488 }
2489
2490 void MyModelessDialog::OnButton(wxCommandEvent& WXUNUSED(event))
2491 {
2492 wxMessageBox(wxT("Button pressed in modeless dialog"), wxT("Info"),
2493 wxOK | wxICON_INFORMATION, this);
2494 }
2495
2496 void MyModelessDialog::OnClose(wxCloseEvent& event)
2497 {
2498 if ( event.CanVeto() )
2499 {
2500 wxMessageBox(wxT("Use the menu item to close this dialog"),
2501 wxT("Modeless dialog"),
2502 wxOK | wxICON_INFORMATION, this);
2503
2504 event.Veto();
2505 }
2506 }
2507
2508 // ----------------------------------------------------------------------------
2509 // MyModalDialog
2510 // ----------------------------------------------------------------------------
2511
2512 MyModalDialog::MyModalDialog(wxWindow *parent)
2513 : wxDialog(parent, wxID_ANY, wxString(wxT("Modal dialog")))
2514 {
2515 wxBoxSizer *sizerTop = new wxBoxSizer(wxHORIZONTAL);
2516
2517 m_btnModal = new wxButton(this, wxID_ANY, wxT("&Modal dialog..."));
2518 m_btnModeless = new wxButton(this, wxID_ANY, wxT("Mode&less dialog"));
2519 m_btnDelete = new wxButton(this, wxID_ANY, wxT("&Delete button"));
2520
2521 sizerTop->Add(m_btnModal, 0, wxALIGN_CENTER | wxALL, 5);
2522 sizerTop->Add(m_btnModeless, 0, wxALIGN_CENTER | wxALL, 5);
2523 sizerTop->Add(m_btnDelete, 0, wxALIGN_CENTER | wxALL, 5);
2524 sizerTop->Add(new wxButton(this, wxID_CLOSE), 0, wxALIGN_CENTER | wxALL, 5);
2525
2526 SetSizerAndFit(sizerTop);
2527
2528 SetEscapeId(wxID_CLOSE);
2529
2530 m_btnModal->SetFocus();
2531 m_btnModal->SetDefault();
2532 }
2533
2534 void MyModalDialog::OnButton(wxCommandEvent& event)
2535 {
2536 if ( event.GetEventObject() == m_btnDelete )
2537 {
2538 wxDELETE(m_btnModal);
2539 m_btnDelete->Disable();
2540 }
2541 else if ( event.GetEventObject() == m_btnModal )
2542 {
2543 #if wxUSE_TEXTDLG
2544 wxGetTextFromUser(wxT("Dummy prompt"),
2545 wxT("Modal dialog called from dialog"),
2546 wxEmptyString, this);
2547 #else
2548 wxMessageBox(wxT("Modal dialog called from dialog"));
2549 #endif // wxUSE_TEXTDLG
2550 }
2551 else if ( event.GetEventObject() == m_btnModeless )
2552 {
2553 (new MyModelessDialog(this))->Show();
2554 }
2555 else
2556 {
2557 event.Skip();
2558 }
2559 }
2560
2561 #endif // USE_MODAL_PRESENTATION
2562
2563 // ----------------------------------------------------------------------------
2564 // StdButtonSizerDialog
2565 // ----------------------------------------------------------------------------
2566
2567 StdButtonSizerDialog::StdButtonSizerDialog(wxWindow *parent)
2568 : wxDialog(parent, wxID_ANY, wxString(wxT("StdButtonSizer dialog")),
2569 wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER),
2570 m_buttonsSizer(NULL)
2571 {
2572 wxBoxSizer *const sizerTop = new wxBoxSizer(wxVERTICAL);
2573
2574 wxBoxSizer *const sizer = new wxBoxSizer(wxHORIZONTAL);
2575 wxBoxSizer *const sizerInside1 = new wxBoxSizer(wxVERTICAL);
2576
2577 m_chkboxAffirmativeButton = new wxCheckBox(this, wxID_ANY, _("Enable Affirmative Button"));
2578
2579 wxStaticBoxSizer *const sizer1 = new wxStaticBoxSizer(wxVERTICAL, this, wxT("Affirmative Button"));
2580
2581 m_radiobtnOk = new wxRadioButton(this, wxID_ANY, _("Ok"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
2582 m_radiobtnYes = new wxRadioButton(this, wxID_ANY, _("Yes"));
2583
2584 wxBoxSizer *const sizerInside2 = new wxBoxSizer(wxVERTICAL);
2585
2586 m_chkboxDismissButton = new wxCheckBox(this, wxID_ANY, _("Enable Dismiss Button"));
2587
2588 wxStaticBoxSizer *const sizer2 = new wxStaticBoxSizer(wxVERTICAL, this, wxT("Dismiss Button"));
2589
2590 m_radiobtnCancel = new wxRadioButton(this, wxID_ANY, _("Cancel"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
2591 m_radiobtnClose = new wxRadioButton(this, wxID_ANY, _("Close"));
2592
2593 wxBoxSizer *const sizer3 = new wxBoxSizer(wxHORIZONTAL);
2594
2595 m_chkboxNo = new wxCheckBox(this, wxID_ANY, _("No"));
2596 m_chkboxHelp = new wxCheckBox(this, wxID_ANY, _("Help"));
2597 m_chkboxApply = new wxCheckBox(this, wxID_ANY, _("Apply"));
2598
2599 m_chkboxNoDefault = new wxCheckBox(this, wxID_ANY, wxT("No Default"));
2600
2601 sizer1->Add(m_radiobtnOk, 0, wxALL, 5);
2602 sizer1->Add(m_radiobtnYes, 0, wxALL, 5);
2603
2604 sizer->Add(sizerInside1, 0, 0, 0);
2605 sizerInside1->Add(m_chkboxAffirmativeButton, 0, wxALL, 5);
2606 sizerInside1->Add(sizer1, 0, wxALL, 5);
2607 sizerInside1->SetItemMinSize(sizer1, sizer1->GetStaticBox()->GetBestSize()); // to prevent wrapping of static box label
2608
2609 sizer2->Add(m_radiobtnCancel, 0, wxALL, 5);
2610 sizer2->Add(m_radiobtnClose, 0, wxALL, 5);
2611
2612 sizer->Add(sizerInside2, 0, 0, 0);
2613 sizerInside2->Add(m_chkboxDismissButton, 0, wxALL, 5);
2614 sizerInside2->Add(sizer2, 0, wxALL, 5);
2615 sizerInside2->SetItemMinSize(sizer2, sizer2->GetStaticBox()->GetBestSize()); // to prevent wrapping of static box label
2616
2617 sizerTop->Add(sizer, 0, wxALL, 5);
2618
2619 sizer3->Add(m_chkboxNo, 0, wxALL, 5);
2620 sizer3->Add(m_chkboxHelp, 0, wxALL, 5);
2621 sizer3->Add(m_chkboxApply, 0, wxALL, 5);
2622
2623 sizerTop->Add(sizer3, 0, wxALL, 5);
2624
2625 sizerTop->Add(m_chkboxNoDefault, 0, wxLEFT|wxRIGHT, 10);
2626
2627 EnableDisableControls();
2628
2629 SetSizerAndFit(sizerTop);
2630
2631 wxCommandEvent ev;
2632 OnEvent(ev);
2633 }
2634
2635 void StdButtonSizerDialog::OnEvent(wxCommandEvent& WXUNUSED(event))
2636 {
2637 if (m_buttonsSizer)
2638 {
2639 m_buttonsSizer->DeleteWindows();
2640 GetSizer()->Remove(m_buttonsSizer);
2641 }
2642
2643 EnableDisableControls();
2644
2645 long flags = 0;
2646 unsigned long numButtons = 0;
2647
2648 if (m_chkboxAffirmativeButton->IsChecked())
2649 {
2650 if (m_radiobtnOk->GetValue())
2651 {
2652 flags |= wxOK;
2653 numButtons ++;
2654 }
2655 else if (m_radiobtnYes->GetValue())
2656 {
2657 flags |= wxYES;
2658 numButtons ++;
2659 }
2660 }
2661
2662 if (m_chkboxDismissButton->IsChecked())
2663 {
2664 if (m_radiobtnCancel->GetValue())
2665 {
2666 flags |= wxCANCEL;
2667 numButtons ++;
2668 }
2669
2670 else if (m_radiobtnClose->GetValue())
2671 {
2672 flags |= wxCLOSE;
2673 numButtons ++;
2674 }
2675
2676 }
2677
2678 if (m_chkboxApply->IsChecked())
2679 {
2680 flags |= wxAPPLY;
2681 numButtons ++;
2682 }
2683
2684 if (m_chkboxNo->IsChecked())
2685 {
2686 flags |= wxNO;
2687 numButtons ++;
2688 }
2689
2690 if (m_chkboxHelp->IsChecked())
2691 {
2692 flags |= wxHELP;
2693 numButtons ++;
2694 }
2695
2696 if (m_chkboxNoDefault->IsChecked())
2697 {
2698 flags |= wxNO_DEFAULT;
2699 }
2700
2701 m_buttonsSizer = CreateStdDialogButtonSizer(flags);
2702 GetSizer()->Add(m_buttonsSizer, 0, wxGROW|wxALL, 5);
2703
2704 Layout();
2705 GetSizer()->SetSizeHints(this);
2706 }
2707
2708 void StdButtonSizerDialog::EnableDisableControls()
2709 {
2710 const bool affButtonEnabled = m_chkboxAffirmativeButton->IsChecked();
2711
2712 m_radiobtnOk->Enable(affButtonEnabled);
2713 m_radiobtnYes->Enable(affButtonEnabled);
2714
2715 const bool dismissButtonEnabled = m_chkboxDismissButton->IsChecked();
2716
2717 m_radiobtnCancel->Enable(dismissButtonEnabled);
2718 m_radiobtnClose->Enable(dismissButtonEnabled);
2719 }
2720
2721 #if USE_SETTINGS_DIALOG
2722 // ----------------------------------------------------------------------------
2723 // SettingsDialog
2724 // ----------------------------------------------------------------------------
2725
2726 IMPLEMENT_CLASS(SettingsDialog, wxPropertySheetDialog)
2727
2728 BEGIN_EVENT_TABLE(SettingsDialog, wxPropertySheetDialog)
2729 END_EVENT_TABLE()
2730
2731 SettingsDialog::SettingsDialog(wxWindow* win, int dialogType)
2732 {
2733 SetExtraStyle(wxDIALOG_EX_CONTEXTHELP|wxWS_EX_VALIDATE_RECURSIVELY);
2734
2735 int tabImage1 = -1;
2736 int tabImage2 = -1;
2737
2738 bool useToolBook = (dialogType == DIALOGS_PROPERTY_SHEET_TOOLBOOK || dialogType == DIALOGS_PROPERTY_SHEET_BUTTONTOOLBOOK);
2739 int resizeBorder = wxRESIZE_BORDER;
2740
2741 if (useToolBook)
2742 {
2743 resizeBorder = 0;
2744 tabImage1 = 0;
2745 tabImage2 = 1;
2746
2747 int sheetStyle = wxPROPSHEET_SHRINKTOFIT;
2748 if (dialogType == DIALOGS_PROPERTY_SHEET_BUTTONTOOLBOOK)
2749 sheetStyle |= wxPROPSHEET_BUTTONTOOLBOOK;
2750 else
2751 sheetStyle |= wxPROPSHEET_TOOLBOOK;
2752
2753 SetSheetStyle(sheetStyle);
2754 SetSheetInnerBorder(0);
2755 SetSheetOuterBorder(0);
2756
2757 // create a dummy image list with a few icons
2758 const wxSize imageSize(32, 32);
2759
2760 m_imageList = new wxImageList(imageSize.GetWidth(), imageSize.GetHeight());
2761 m_imageList->
2762 Add(wxArtProvider::GetIcon(wxART_INFORMATION, wxART_OTHER, imageSize));
2763 m_imageList->
2764 Add(wxArtProvider::GetIcon(wxART_QUESTION, wxART_OTHER, imageSize));
2765 m_imageList->
2766 Add(wxArtProvider::GetIcon(wxART_WARNING, wxART_OTHER, imageSize));
2767 m_imageList->
2768 Add(wxArtProvider::GetIcon(wxART_ERROR, wxART_OTHER, imageSize));
2769 }
2770 else
2771 m_imageList = NULL;
2772
2773 Create(win, wxID_ANY, _("Preferences"), wxDefaultPosition, wxDefaultSize,
2774 wxDEFAULT_DIALOG_STYLE| (int)wxPlatform::IfNot(wxOS_WINDOWS_CE, resizeBorder)
2775 );
2776
2777 // If using a toolbook, also follow Mac style and don't create buttons
2778 if (!useToolBook)
2779 CreateButtons(wxOK | wxCANCEL |
2780 (int)wxPlatform::IfNot(wxOS_WINDOWS_CE, wxHELP)
2781 );
2782
2783 wxBookCtrlBase* notebook = GetBookCtrl();
2784 notebook->SetImageList(m_imageList);
2785
2786 wxPanel* generalSettings = CreateGeneralSettingsPage(notebook);
2787 wxPanel* aestheticSettings = CreateAestheticSettingsPage(notebook);
2788
2789 notebook->AddPage(generalSettings, _("General"), true, tabImage1);
2790 notebook->AddPage(aestheticSettings, _("Aesthetics"), false, tabImage2);
2791
2792 LayoutDialog();
2793 }
2794
2795 SettingsDialog::~SettingsDialog()
2796 {
2797 delete m_imageList;
2798 }
2799
2800 wxPanel* SettingsDialog::CreateGeneralSettingsPage(wxWindow* parent)
2801 {
2802 wxPanel* panel = new wxPanel(parent, wxID_ANY);
2803
2804 wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL );
2805 wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
2806
2807 //// LOAD LAST FILE
2808
2809 wxBoxSizer* itemSizer3 = new wxBoxSizer( wxHORIZONTAL );
2810 wxCheckBox* checkBox3 = new wxCheckBox(panel, ID_LOAD_LAST_PROJECT, _("&Load last project on startup"), wxDefaultPosition, wxDefaultSize);
2811 itemSizer3->Add(checkBox3, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2812 item0->Add(itemSizer3, 0, wxGROW|wxALL, 0);
2813
2814 //// AUTOSAVE
2815
2816 wxString autoSaveLabel = _("&Auto-save every");
2817 wxString minsLabel = _("mins");
2818
2819 wxBoxSizer* itemSizer12 = new wxBoxSizer( wxHORIZONTAL );
2820 wxCheckBox* checkBox12 = new wxCheckBox(panel, ID_AUTO_SAVE, autoSaveLabel, wxDefaultPosition, wxDefaultSize);
2821
2822 #if wxUSE_SPINCTRL
2823 wxSpinCtrl* spinCtrl12 = new wxSpinCtrl(panel, ID_AUTO_SAVE_MINS, wxEmptyString,
2824 wxDefaultPosition, wxSize(40, wxDefaultCoord), wxSP_ARROW_KEYS, 1, 60, 1);
2825 #endif
2826
2827 itemSizer12->Add(checkBox12, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2828 #if wxUSE_SPINCTRL
2829 itemSizer12->Add(spinCtrl12, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2830 #endif
2831 itemSizer12->Add(new wxStaticText(panel, wxID_STATIC, minsLabel), 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2832 item0->Add(itemSizer12, 0, wxGROW|wxALL, 0);
2833
2834 //// TOOLTIPS
2835
2836 wxBoxSizer* itemSizer8 = new wxBoxSizer( wxHORIZONTAL );
2837 wxCheckBox* checkBox6 = new wxCheckBox(panel, ID_SHOW_TOOLTIPS, _("Show &tooltips"), wxDefaultPosition, wxDefaultSize);
2838 itemSizer8->Add(checkBox6, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2839 item0->Add(itemSizer8, 0, wxGROW|wxALL, 0);
2840
2841 topSizer->Add( item0, 1, wxGROW|wxALIGN_CENTRE|wxALL, 5 );
2842
2843 panel->SetSizerAndFit(topSizer);
2844
2845 return panel;
2846 }
2847
2848 wxPanel* SettingsDialog::CreateAestheticSettingsPage(wxWindow* parent)
2849 {
2850 wxPanel* panel = new wxPanel(parent, wxID_ANY);
2851
2852 wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL );
2853 wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
2854
2855 //// PROJECT OR GLOBAL
2856 wxString globalOrProjectChoices[2];
2857 globalOrProjectChoices[0] = _("&New projects");
2858 globalOrProjectChoices[1] = _("&This project");
2859
2860 wxRadioBox* projectOrGlobal = new wxRadioBox(panel, ID_APPLY_SETTINGS_TO, _("&Apply settings to:"),
2861 wxDefaultPosition, wxDefaultSize, 2, globalOrProjectChoices);
2862 item0->Add(projectOrGlobal, 0, wxGROW|wxALL, 5);
2863
2864 projectOrGlobal->SetSelection(0);
2865
2866 //// BACKGROUND STYLE
2867 wxArrayString backgroundStyleChoices;
2868 backgroundStyleChoices.Add(wxT("Colour"));
2869 backgroundStyleChoices.Add(wxT("Image"));
2870 wxStaticBox* staticBox3 = new wxStaticBox(panel, wxID_ANY, _("Background style:"));
2871
2872 wxBoxSizer* styleSizer = new wxStaticBoxSizer( staticBox3, wxVERTICAL );
2873 item0->Add(styleSizer, 0, wxGROW|wxALL, 5);
2874
2875 wxBoxSizer* itemSizer2 = new wxBoxSizer( wxHORIZONTAL );
2876
2877 wxChoice* choice2 = new wxChoice(panel, ID_BACKGROUND_STYLE, wxDefaultPosition, wxDefaultSize, backgroundStyleChoices);
2878
2879 itemSizer2->Add(new wxStaticText(panel, wxID_ANY, _("&Window:")), 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2880 itemSizer2->Add(5, 5, 1, wxALL, 0);
2881 itemSizer2->Add(choice2, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5);
2882
2883 styleSizer->Add(itemSizer2, 0, wxGROW|wxALL, 5);
2884
2885 #if wxUSE_SPINCTRL
2886 //// FONT SIZE SELECTION
2887
2888 wxStaticBox* staticBox1 = new wxStaticBox(panel, wxID_ANY, _("Tile font size:"));
2889 wxBoxSizer* itemSizer5 = new wxStaticBoxSizer( staticBox1, wxHORIZONTAL );
2890
2891 wxSpinCtrl* spinCtrl = new wxSpinCtrl(panel, ID_FONT_SIZE, wxEmptyString, wxDefaultPosition,
2892 wxSize(80, wxDefaultCoord));
2893 itemSizer5->Add(spinCtrl, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
2894
2895 item0->Add(itemSizer5, 0, wxGROW|wxLEFT|wxRIGHT, 5);
2896 #endif
2897
2898 topSizer->Add( item0, 1, wxGROW|wxALIGN_CENTRE|wxALL, 5 );
2899 topSizer->AddSpacer(5);
2900
2901 panel->SetSizerAndFit(topSizer);
2902
2903 return panel;
2904 }
2905
2906 #endif // USE_SETTINGS_DIALOG
2907
2908 #if wxUSE_MSGDLG
2909 // ----------------------------------------------------------------------------
2910 // TestMessageBoxDialog
2911 // ----------------------------------------------------------------------------
2912
2913 /* static */
2914 const TestMessageBoxDialog::BtnInfo TestMessageBoxDialog::ms_btnInfo[] =
2915 {
2916 { wxYES, "&Yes" },
2917 { wxNO, "&No" },
2918 { wxOK, "&Ok" },
2919 { wxCANCEL, "&Cancel" },
2920 { wxHELP, "&Help" },
2921 };
2922
2923 BEGIN_EVENT_TABLE(TestMessageBoxDialog, wxDialog)
2924 EVT_BUTTON(wxID_APPLY, TestMessageBoxDialog::OnApply)
2925 EVT_BUTTON(wxID_CLOSE, TestMessageBoxDialog::OnClose)
2926 END_EVENT_TABLE()
2927
2928 TestMessageBoxDialog::TestMessageBoxDialog(wxWindow *parent)
2929 : wxDialog(parent, wxID_ANY, "Message Box Test Dialog",
2930 wxDefaultPosition, wxDefaultSize,
2931 wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
2932 {
2933 }
2934
2935 bool TestMessageBoxDialog::Create()
2936 {
2937 wxSizer * const sizerTop = new wxBoxSizer(wxVERTICAL);
2938
2939 // this sizer allows to configure the messages shown in the message box
2940 wxSizer * const
2941 sizerMsgs = new wxStaticBoxSizer(wxVERTICAL, this, "&Messages");
2942 sizerMsgs->Add(new wxStaticText(this, wxID_ANY, "&Title:"));
2943 m_textTitle = new wxTextCtrl(this, wxID_ANY, "Test Message Box");
2944 sizerMsgs->Add(m_textTitle, wxSizerFlags().Expand().Border(wxBOTTOM));
2945
2946 sizerMsgs->Add(new wxStaticText(this, wxID_ANY, "&Main message:"));
2947 m_textMsg = new wxTextCtrl(this, wxID_ANY, "Hello from a box!",
2948 wxDefaultPosition, wxDefaultSize,
2949 wxTE_MULTILINE);
2950 sizerMsgs->Add(m_textMsg, wxSizerFlags(1).Expand().Border(wxBOTTOM));
2951
2952 sizerMsgs->Add(new wxStaticText(this, wxID_ANY, "&Extended message:"));
2953 m_textExtMsg = new wxTextCtrl(this, wxID_ANY, "",
2954 wxDefaultPosition, wxDefaultSize,
2955 wxTE_MULTILINE);
2956 sizerMsgs->Add(m_textExtMsg, wxSizerFlags(1).Expand());
2957
2958 sizerTop->Add(sizerMsgs, wxSizerFlags(1).Expand().Border());
2959
2960 // if a derived class provides more message configurations, add these.
2961 AddAdditionalTextOptions(sizerTop);
2962
2963 // this one is for configuring the buttons
2964 wxSizer * const
2965 sizerBtnsBox = new wxStaticBoxSizer(wxVERTICAL, this, "&Buttons");
2966
2967 wxFlexGridSizer * const sizerBtns = new wxFlexGridSizer(2, 5, 5);
2968 sizerBtns->AddGrowableCol(1);
2969
2970 sizerBtns->Add(new wxStaticText(this, wxID_ANY, "Button(s)"));
2971 sizerBtns->Add(new wxStaticText(this, wxID_ANY, "Custom label"));
2972
2973 for ( int n = 0; n < Btn_Max; n++ )
2974 {
2975 m_buttons[n] = new wxCheckBox(this, wxID_ANY, ms_btnInfo[n].name);
2976 sizerBtns->Add(m_buttons[n], wxSizerFlags().Centre().Left());
2977
2978 m_labels[n] = new wxTextCtrl(this, wxID_ANY);
2979 sizerBtns->Add(m_labels[n], wxSizerFlags(1).Centre().Expand());
2980
2981 m_labels[n]->Connect(wxEVT_UPDATE_UI,
2982 wxUpdateUIEventHandler(
2983 TestMessageBoxDialog::OnUpdateLabelUI),
2984 NULL,
2985 this);
2986 }
2987
2988 sizerBtnsBox->Add(sizerBtns, wxSizerFlags(1).Expand());
2989 sizerTop->Add(sizerBtnsBox, wxSizerFlags().Expand().Border());
2990
2991
2992 // icon choice
2993 const wxString icons[] =
2994 {
2995 "&Not specified",
2996 "E&xplicitly none",
2997 "&Information icon",
2998 "&Question icon",
2999 "&Warning icon",
3000 "&Error icon"
3001 };
3002
3003 wxCOMPILE_TIME_ASSERT( WXSIZEOF(icons) == MsgDlgIcon_Max, IconMismatch );
3004
3005 m_icons = new wxRadioBox(this, wxID_ANY, "&Icon style",
3006 wxDefaultPosition, wxDefaultSize,
3007 WXSIZEOF(icons), icons,
3008 2, wxRA_SPECIFY_ROWS);
3009 // Make the 'Information' icon the default one:
3010 m_icons->SetSelection(MsgDlgIcon_Info);
3011 sizerTop->Add(m_icons, wxSizerFlags().Expand().Border());
3012
3013
3014 // miscellaneous other stuff
3015 wxSizer * const
3016 sizerFlags = new wxStaticBoxSizer(wxHORIZONTAL, this, "&Other flags");
3017
3018 m_chkNoDefault = new wxCheckBox(this, wxID_ANY, "Make \"No\" &default");
3019 m_chkNoDefault->Connect(wxEVT_UPDATE_UI,
3020 wxUpdateUIEventHandler(
3021 TestMessageBoxDialog::OnUpdateNoDefaultUI),
3022 NULL,
3023 this);
3024 sizerFlags->Add(m_chkNoDefault, wxSizerFlags(1).Border());
3025
3026 m_chkCentre = new wxCheckBox(this, wxID_ANY, "Centre on &parent");
3027 sizerFlags->Add(m_chkCentre, wxSizerFlags(1).Border());
3028
3029 // add any additional flag from subclasses
3030 AddAdditionalFlags(sizerFlags);
3031
3032 sizerTop->Add(sizerFlags, wxSizerFlags().Expand().Border());
3033
3034 // finally buttons to show the resulting message box and close this dialog
3035 sizerTop->Add(CreateStdDialogButtonSizer(wxAPPLY | wxCLOSE),
3036 wxSizerFlags().Right().Border());
3037
3038 SetSizerAndFit(sizerTop);
3039
3040 m_buttons[Btn_Ok]->SetValue(true);
3041
3042 return true;
3043 }
3044
3045 void TestMessageBoxDialog::OnUpdateLabelUI(wxUpdateUIEvent& event)
3046 {
3047 for ( int n = 0; n < Btn_Max; n++ )
3048 {
3049 if ( event.GetEventObject() == m_labels[n] )
3050 {
3051 event.Enable( m_buttons[n]->IsChecked() );
3052 return;
3053 }
3054 }
3055
3056 wxFAIL_MSG( "called for unknown label" );
3057 }
3058
3059 void TestMessageBoxDialog::OnUpdateNoDefaultUI(wxUpdateUIEvent& event)
3060 {
3061 event.Enable( m_buttons[Btn_No]->IsChecked() );
3062 }
3063
3064 long TestMessageBoxDialog::GetStyle()
3065 {
3066 long style = 0;
3067
3068 for ( int n = 0; n < Btn_Max; n++ )
3069 {
3070 if ( m_buttons[n]->IsChecked() )
3071 style |= ms_btnInfo[n].flag;
3072 }
3073
3074 switch ( m_icons->GetSelection() )
3075 {
3076 case MsgDlgIcon_Max:
3077 wxFAIL_MSG( "unexpected selection" );
3078
3079 case MsgDlgIcon_No:
3080 break;
3081
3082 case MsgDlgIcon_None:
3083 style |= wxICON_NONE;
3084 break;
3085
3086 case MsgDlgIcon_Info:
3087 style |= wxICON_INFORMATION;
3088 break;
3089
3090 case MsgDlgIcon_Question:
3091 style |= wxICON_QUESTION;
3092 break;
3093
3094 case MsgDlgIcon_Warning:
3095 style |= wxICON_WARNING;
3096 break;
3097
3098 case MsgDlgIcon_Error:
3099 style |= wxICON_ERROR;
3100 break;
3101 }
3102
3103 if ( m_chkCentre->IsChecked() )
3104 style |= wxCENTRE;
3105
3106 if ( m_chkNoDefault->IsEnabled() && m_chkNoDefault->IsChecked() )
3107 style |= wxNO_DEFAULT;
3108
3109 return style;
3110 }
3111
3112 void TestMessageBoxDialog::PrepareMessageDialog(wxMessageDialogBase &dlg)
3113 {
3114 long style = dlg.GetMessageDialogStyle();
3115
3116 if ( !m_textExtMsg->IsEmpty() )
3117 dlg.SetExtendedMessage(m_textExtMsg->GetValue());
3118
3119 if ( style & wxYES_NO )
3120 {
3121 if ( style & wxCANCEL )
3122 {
3123 dlg.SetYesNoCancelLabels(m_labels[Btn_Yes]->GetValue(),
3124 m_labels[Btn_No]->GetValue(),
3125 m_labels[Btn_Cancel]->GetValue());
3126 }
3127 else
3128 {
3129 dlg.SetYesNoLabels(m_labels[Btn_Yes]->GetValue(),
3130 m_labels[Btn_No]->GetValue());
3131 }
3132 }
3133 else
3134 {
3135 if ( style & wxCANCEL )
3136 {
3137 dlg.SetOKCancelLabels(m_labels[Btn_Ok]->GetValue(),
3138 m_labels[Btn_Cancel]->GetValue());
3139 }
3140 else
3141 {
3142 dlg.SetOKLabel(m_labels[Btn_Ok]->GetValue());
3143 }
3144 }
3145
3146 if ( style & wxHELP )
3147 {
3148 dlg.SetHelpLabel(m_labels[Btn_Help]->GetValue());
3149 }
3150 }
3151
3152 void TestMessageBoxDialog::OnApply(wxCommandEvent& WXUNUSED(event))
3153 {
3154 wxMessageDialog dlg(this, GetMessage(), GetBoxTitle(), GetStyle());
3155 PrepareMessageDialog(dlg);
3156
3157 wxString btnName;
3158 switch ( dlg.ShowModal() )
3159 {
3160 case wxID_OK:
3161 btnName = "OK";
3162 break;
3163
3164 case wxID_CANCEL:
3165 // Avoid the extra message box if the dialog was cancelled.
3166 return;
3167
3168 case wxID_YES:
3169 btnName = "Yes";
3170 break;
3171
3172 case wxID_NO:
3173 btnName = "No";
3174 break;
3175
3176 case wxID_HELP:
3177 btnName = "Help";
3178 break;
3179
3180 default:
3181 btnName = "Unknown";
3182 }
3183
3184 wxLogMessage("Dialog was closed with the \"%s\" button.", btnName);
3185 }
3186
3187 void TestMessageBoxDialog::OnClose(wxCommandEvent& WXUNUSED(event))
3188 {
3189 EndModal(wxID_CANCEL);
3190 }
3191 #endif // wxUSE_MSGDLG
3192
3193 #if wxUSE_RICHMSGDLG
3194 // ----------------------------------------------------------------------------
3195 // TestRichMessageDialog
3196 // ----------------------------------------------------------------------------
3197
3198 BEGIN_EVENT_TABLE(TestRichMessageDialog, TestMessageBoxDialog)
3199 EVT_BUTTON(wxID_APPLY, TestRichMessageDialog::OnApply)
3200 END_EVENT_TABLE()
3201
3202 TestRichMessageDialog::TestRichMessageDialog(wxWindow *parent)
3203 : TestMessageBoxDialog(parent)
3204 {
3205 SetTitle("Rich Message Dialog Test Dialog");
3206 }
3207
3208 void TestRichMessageDialog::AddAdditionalTextOptions(wxSizer *sizer)
3209 {
3210 wxSizer * const sizerMsgs = new wxStaticBoxSizer(wxVERTICAL, this,
3211 "&Additional Elements");
3212
3213 // add a option to show a check box.
3214 wxFlexGridSizer * const sizerCheckBox = new wxFlexGridSizer(2, 5, 5);
3215 sizerCheckBox->AddGrowableCol(1);
3216 sizerCheckBox->Add(new wxStaticText(this, wxID_ANY, "&Check box:"));
3217 m_textCheckBox = new wxTextCtrl(this, wxID_ANY);
3218 sizerCheckBox->Add(m_textCheckBox, wxSizerFlags(1).Expand().Border(wxBOTTOM));
3219 sizerMsgs->Add(sizerCheckBox, wxSizerFlags(1).Expand());
3220
3221 // add option to show a detailed text.
3222 sizerMsgs->Add(new wxStaticText(this, wxID_ANY, "&Detailed message:"));
3223 m_textDetailed = new wxTextCtrl(this, wxID_ANY, "",
3224 wxDefaultPosition, wxDefaultSize,
3225 wxTE_MULTILINE);
3226 sizerMsgs->Add(m_textDetailed, wxSizerFlags(1).Expand());
3227
3228 sizer->Add(sizerMsgs, wxSizerFlags(1).Expand().Border());
3229 }
3230
3231 void TestRichMessageDialog::AddAdditionalFlags(wxSizer *sizer)
3232 {
3233 // add checkbox to set the initial state for the checkbox shown
3234 // in the dialog.
3235 m_initialValueCheckBox =
3236 new wxCheckBox(this, wxID_ANY, "Checkbox initially checked");
3237 sizer->Add(m_initialValueCheckBox, wxSizerFlags(1).Border());
3238 }
3239
3240 void TestRichMessageDialog::OnApply(wxCommandEvent& WXUNUSED(event))
3241 {
3242 wxRichMessageDialog dlg(this, GetMessage(), GetBoxTitle(), GetStyle());
3243 PrepareMessageDialog(dlg);
3244
3245 dlg.ShowCheckBox(m_textCheckBox->GetValue(),
3246 m_initialValueCheckBox->GetValue());
3247 dlg.ShowDetailedText(m_textDetailed->GetValue());
3248
3249 dlg.ShowModal();
3250 }
3251
3252 #endif // wxUSE_RICHMSGDLG
3253
3254 #if wxUSE_LOG
3255
3256 // ----------------------------------------------------------------------------
3257 // custom log target
3258 // ----------------------------------------------------------------------------
3259
3260 class MyLogGui : public wxLogGui
3261 {
3262 private:
3263 virtual void DoShowSingleLogMessage(const wxString& message,
3264 const wxString& title,
3265 int style)
3266 {
3267 wxMessageDialog dlg(NULL, message, title,
3268 wxOK | wxCANCEL | wxCANCEL_DEFAULT | style);
3269 dlg.SetOKCancelLabels(wxID_COPY, wxID_OK);
3270 dlg.SetExtendedMessage("Note that this is a custom log dialog.");
3271 dlg.ShowModal();
3272 }
3273 };
3274
3275 wxLog *MyAppTraits::CreateLogTarget()
3276 {
3277 return new MyLogGui;
3278 }
3279
3280 #endif // wxUSE_LOG
wxWidgets (Impactor)