]>
Commit | Line | Data |
---|---|---|
1 | \section{\class{wxApp}}\label{wxapp} | |
2 | ||
3 | The {\bf wxApp} class represents the application itself. It is used | |
4 | to: | |
5 | ||
6 | \begin{itemize}\itemsep=0pt | |
7 | \item set and get application-wide properties; | |
8 | \item implement the windowing system message or event loop; | |
9 | \item initiate application processing via \helpref{wxApp::OnInit}{wxapponinit}; | |
10 | \item allow default processing of events not handled by other | |
11 | objects in the application. | |
12 | \end{itemize} | |
13 | ||
14 | You should use the macro IMPLEMENT\_APP(appClass) in your application implementation | |
15 | file to tell wxWindows how to create an instance of your application class. | |
16 | ||
17 | Use DECLARE\_APP(appClass) in a header file if you want the wxGetApp function (which returns | |
18 | a reference to your application object) to be visible to other files. | |
19 | ||
20 | \wxheading{Derived from} | |
21 | ||
22 | \helpref{wxEvtHandler}{wxevthandler}\\ | |
23 | \helpref{wxObject}{wxobject} | |
24 | ||
25 | \wxheading{Include files} | |
26 | ||
27 | <wx/app.h> | |
28 | ||
29 | \wxheading{See also} | |
30 | ||
31 | \helpref{wxApp overview}{wxappoverview} | |
32 | ||
33 | \latexignore{\rtfignore{\wxheading{Members}}} | |
34 | ||
35 | \membersection{wxApp::wxApp} | |
36 | ||
37 | \func{void}{wxApp}{\void} | |
38 | ||
39 | Constructor. Called implicitly with a definition of a wxApp object. | |
40 | ||
41 | \membersection{wxApp::\destruct{wxApp}} | |
42 | ||
43 | \func{void}{\destruct{wxApp}}{\void} | |
44 | ||
45 | Destructor. Will be called implicitly on program exit if the wxApp | |
46 | object is created on the stack. | |
47 | ||
48 | \membersection{wxApp::argc}\label{wxappargc} | |
49 | ||
50 | \member{int}{argc} | |
51 | ||
52 | Number of command line arguments (after environment-specific processing). | |
53 | ||
54 | \membersection{wxApp::argv}\label{wxappargv} | |
55 | ||
56 | \member{char **}{argv} | |
57 | ||
58 | Command line arguments (after environment-specific processing). | |
59 | ||
60 | \membersection{wxApp::CreateLogTarget}\label{wxappcreatelogtarget} | |
61 | ||
62 | \func{virtual wxLog*}{CreateLogTarget}{\void} | |
63 | ||
64 | Creates a wxLog class for the application to use for logging errors. The default | |
65 | implementation returns a new wxLogGui class. | |
66 | ||
67 | \wxheading{See also} | |
68 | ||
69 | \helpref{wxLog}{wxlog} | |
70 | ||
71 | \membersection{wxApp::Dispatch}\label{wxappdispatch} | |
72 | ||
73 | \func{void}{Dispatch}{\void} | |
74 | ||
75 | Dispatches the next event in the windowing system event queue. | |
76 | ||
77 | This can be used for programming event loops, e.g. | |
78 | ||
79 | \begin{verbatim} | |
80 | while (app.Pending()) | |
81 | Dispatch(); | |
82 | \end{verbatim} | |
83 | ||
84 | \wxheading{See also} | |
85 | ||
86 | \helpref{wxApp::Pending}{wxapppending} | |
87 | ||
88 | \membersection{wxApp::FilterEvent}\label{wxappfilterevent} | |
89 | ||
90 | \func{int}{FilterEvent}{\param{wxEvent\& }{event}} | |
91 | ||
92 | This function is called before processing any event and allows the application | |
93 | to preempt the processing of some events. If this method returns $-1$ the event | |
94 | is processed normally, otherwise either {\tt true} or {\tt false} should be | |
95 | returned and the event processing stops immediately considering that the event | |
96 | had been already processed (for the former return value) or that it is not | |
97 | going to be processed at all (for the latter one). | |
98 | ||
99 | \membersection{wxApp::GetAppName}\label{wxappgetappname} | |
100 | ||
101 | \constfunc{wxString}{GetAppName}{\void} | |
102 | ||
103 | Returns the application name. | |
104 | ||
105 | \wxheading{Remarks} | |
106 | ||
107 | wxWindows sets this to a reasonable default before | |
108 | calling \helpref{wxApp::OnInit}{wxapponinit}, but the application can reset it at will. | |
109 | ||
110 | \membersection{wxApp::GetAuto3D}\label{wxappgetauto3d} | |
111 | ||
112 | \constfunc{bool}{GetAuto3D}{\void} | |
113 | ||
114 | Returns true if 3D control mode is on, false otherwise. | |
115 | ||
116 | \wxheading{See also} | |
117 | ||
118 | \helpref{wxApp::SetAuto3D}{wxappsetauto3d} | |
119 | ||
120 | \membersection{wxApp::GetClassName}\label{wxappgetclassname} | |
121 | ||
122 | \constfunc{wxString}{GetClassName}{\void} | |
123 | ||
124 | Gets the class name of the application. The class name may be used in a platform specific | |
125 | manner to refer to the application. | |
126 | ||
127 | \wxheading{See also} | |
128 | ||
129 | \helpref{wxApp::SetClassName}{wxappsetclassname} | |
130 | ||
131 | \membersection{wxApp::GetExitOnFrameDelete}\label{wxappgetexitonframedelete} | |
132 | ||
133 | \constfunc{bool}{GetExitOnFrameDelete}{\void} | |
134 | ||
135 | Returns true if the application will exit when the top-level window is deleted, false | |
136 | otherwise. | |
137 | ||
138 | \wxheading{See also} | |
139 | ||
140 | \helpref{wxApp::SetExitOnFrameDelete}{wxappsetexitonframedelete},\\ | |
141 | \helpref{wxApp shutdown overview}{wxappshutdownoverview} | |
142 | ||
143 | \membersection{wxApp::GetTopWindow}\label{wxappgettopwindow} | |
144 | ||
145 | \constfunc{virtual wxWindow *}{GetTopWindow}{\void} | |
146 | ||
147 | Returns a pointer to the top window. | |
148 | ||
149 | \wxheading{Remarks} | |
150 | ||
151 | If the top window hasn't been set using \helpref{wxApp::SetTopWindow}{wxappsettopwindow}, this | |
152 | function will find the first top-level window (frame or dialog) and return that. | |
153 | ||
154 | \wxheading{See also} | |
155 | ||
156 | \helpref{SetTopWindow}{wxappsettopwindow} | |
157 | ||
158 | \membersection{wxApp::GetUseBestVisual}\label{wxappgetusebestvisual} | |
159 | ||
160 | \constfunc{bool}{GetUseBestVisual}{\void} | |
161 | ||
162 | Returns true if the application will use the best visual on systems that support | |
163 | different visuals, false otherwise. | |
164 | ||
165 | \wxheading{See also} | |
166 | ||
167 | \helpref{SetUseBestVisual}{wxappsetusebestvisual} | |
168 | ||
169 | \membersection{wxApp::GetVendorName}\label{wxappgetvendorname} | |
170 | ||
171 | \constfunc{wxString}{GetVendorName}{\void} | |
172 | ||
173 | Returns the application's vendor name. | |
174 | ||
175 | \membersection{wxApp::ExitMainLoop}\label{wxappexitmainloop} | |
176 | ||
177 | \func{void}{ExitMainLoop}{\void} | |
178 | ||
179 | Call this to explicitly exit the main message (event) loop. | |
180 | You should normally exit the main loop (and the application) by deleting | |
181 | the top window. | |
182 | ||
183 | \membersection{wxApp::Initialized}\label{wxappinitialized} | |
184 | ||
185 | \func{bool}{Initialized}{\void} | |
186 | ||
187 | Returns true if the application has been initialized (i.e. if\rtfsp | |
188 | \helpref{wxApp::OnInit}{wxapponinit} has returned successfully). This can be useful for error | |
189 | message routines to determine which method of output is best for the | |
190 | current state of the program (some windowing systems may not like | |
191 | dialogs to pop up before the main loop has been entered). | |
192 | ||
193 | \membersection{wxApp::MainLoop}\label{wxappmainloop} | |
194 | ||
195 | \func{int}{MainLoop}{\void} | |
196 | ||
197 | Called by wxWindows on creation of the application. Override this if you wish | |
198 | to provide your own (environment-dependent) main loop. | |
199 | ||
200 | \wxheading{Return value} | |
201 | ||
202 | Returns 0 under X, and the wParam of the WM\_QUIT message under Windows. | |
203 | ||
204 | %% VZ: OnXXX() functions should *not* be documented | |
205 | %% | |
206 | %%\membersection{wxApp::OnActivate}\label{wxapponactivate} | |
207 | %% | |
208 | %%\func{void}{OnActivate}{\param{wxActivateEvent\& }{event}} | |
209 | %% | |
210 | %%Provide this member function to know whether the application is being | |
211 | %%activated or deactivated (Windows only). | |
212 | %% | |
213 | %%\wxheading{See also} | |
214 | %% | |
215 | %%\helpref{wxWindow::OnActivate}{wxwindowonactivate}, \helpref{wxActivateEvent}{wxactivateevent} | |
216 | %% | |
217 | %%\membersection{wxApp::OnCharHook}\label{wxapponcharhook} | |
218 | %% | |
219 | %%\func{void}{OnCharHook}{\param{wxKeyEvent\&}{ event}} | |
220 | %% | |
221 | %%This event handler function is called (under Windows only) to allow the window to intercept keyboard events | |
222 | %%before they are processed by child windows. | |
223 | %% | |
224 | %%\wxheading{Parameters} | |
225 | %% | |
226 | %%\docparam{event}{The keypress event.} | |
227 | %% | |
228 | %%\wxheading{Remarks} | |
229 | %% | |
230 | %%Use the wxEVT\_CHAR\_HOOK macro in your event table. | |
231 | %% | |
232 | %%If you use this member, you can selectively consume keypress events by calling\rtfsp | |
233 | %%\helpref{wxEvent::Skip}{wxeventskip} for characters the application is not interested in. | |
234 | %% | |
235 | %%\wxheading{See also} | |
236 | %% | |
237 | %%\helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnChar}{wxwindowonchar},\rtfsp | |
238 | %%\helpref{wxWindow::OnCharHook}{wxwindowoncharhook}, \helpref{wxDialog::OnCharHook}{wxdialogoncharhook} | |
239 | ||
240 | \membersection{wxApp::OnAssert}\label{wxapponassert} | |
241 | ||
242 | \func{void}{OnAssert}{\param{const wxChar }{*file}, \param{int }{line}, \param{const wxChar }{*cond}, \param{const wxChar }{*msg}} | |
243 | ||
244 | This function is called when an assert failure occurs, i.e. the condition | |
245 | specified in \helpref{wxASSERT}{wxassert} macro evaluated to {\tt false}. | |
246 | It is only called in debug mode (when {\tt \_\_WXDEBUG\_\_} is defined) as | |
247 | asserts are not left in the release code at all. | |
248 | ||
249 | The base class version show the default assert failure dialog box proposing to | |
250 | the user to stop the program, continue or ignore all subsequent asserts. | |
251 | ||
252 | \wxheading{Parameters} | |
253 | ||
254 | \docparam{file}{the name of the source file where the assert occured} | |
255 | ||
256 | \docparam{line}{the line number in this file where the assert occured} | |
257 | ||
258 | \docparam{cond}{the condition of the failed assert in string form} | |
259 | ||
260 | \docparam{msg}{the message specified as argument to | |
261 | \helpref{wxASSERT\_MSG}{wxassertmsg} or \helpref{wxFAIL\_MSG}{wxfailmsg}, will | |
262 | be {\tt NULL} if just \helpref{wxASSERT}{wxassert} or \helpref{wxFAIL}{wxfail} | |
263 | was used} | |
264 | ||
265 | \membersection{wxApp::OnExit}\label{wxapponexit} | |
266 | ||
267 | \func{int}{OnExit}{\void} | |
268 | ||
269 | Provide this member function for any processing which needs to be | |
270 | done as the application is about to exit. OnExit is called after | |
271 | destroying all application windows and controls, but before | |
272 | wxWindows cleanup. | |
273 | ||
274 | \membersection{wxApp::OnCmdLineError}\label{wxapponcmdlineerror} | |
275 | ||
276 | \func{bool}{OnCmdLineError}{\param{wxCmdLineParser\& }{parser}} | |
277 | ||
278 | Called when command line parsing fails (i.e. an incorrect command line option | |
279 | was specified by the user). The default behaviour is to show the program usage | |
280 | text and abort the program. | |
281 | ||
282 | Return {\tt true} to continue normal execution or {\tt false} to return | |
283 | {\tt false} from \helpref{OnInit}{wxapponinit} thus terminating the program. | |
284 | ||
285 | \wxheading{See also} | |
286 | ||
287 | \helpref{OnInitCmdLine}{wxapponinitcmdline} | |
288 | ||
289 | \membersection{wxApp::OnCmdLineHelp}\label{wxapponcmdlinehelp} | |
290 | ||
291 | \func{bool}{OnCmdLineHelp}{\param{wxCmdLineParser\& }{parser}} | |
292 | ||
293 | Called when the help option ({\tt --help}) was specified on the command line. | |
294 | The default behaviour is to show the program usage text and abort the program. | |
295 | ||
296 | Return {\tt true} to continue normal execution or {\tt false} to return | |
297 | {\tt false} from \helpref{OnInit}{wxapponinit} thus terminating the program. | |
298 | ||
299 | \wxheading{See also} | |
300 | ||
301 | \helpref{OnInitCmdLine}{wxapponinitcmdline} | |
302 | ||
303 | \membersection{wxApp::OnCmdLineParsed}\label{wxapponcmdlineparsed} | |
304 | ||
305 | \func{bool}{OnCmdLineParsed}{\param{wxCmdLineParser\& }{parser}} | |
306 | ||
307 | Called after the command line had been successfully parsed. You may override | |
308 | this method to test for the values of the various parameters which could be | |
309 | set from the command line. | |
310 | ||
311 | Don't forget to call the base class version unless you want to suppress | |
312 | processing of the standard command line options. | |
313 | ||
314 | Return {\tt true} to continue normal execution or {\tt false} to return | |
315 | {\tt false} from \helpref{OnInit}{wxapponinit} thus terminating the program. | |
316 | ||
317 | \wxheading{See also} | |
318 | ||
319 | \helpref{OnInitCmdLine}{wxapponinitcmdline} | |
320 | ||
321 | \membersection{wxApp::OnFatalException}\label{wxapponfatalexception} | |
322 | ||
323 | \func{void}{OnFatalException}{\void} | |
324 | ||
325 | This function may be called if something fatal happens: an unhandled | |
326 | exception under Win32 or a a fatal signal under Unix, for example. However, | |
327 | this will not happen by default: you have to explicitly call | |
328 | \helpref{wxHandleFatalExceptions}{wxhandlefatalexceptions} to enable this. | |
329 | ||
330 | Generally speaking, this function should only show a message to the user and | |
331 | return. You may attempt to save unsaved data but this is not guaranteed to | |
332 | work and, in fact, probably won't. | |
333 | ||
334 | \wxheading{See also} | |
335 | ||
336 | \helpref{wxHandleFatalExcetions}{wxhandlefatalexceptions} | |
337 | ||
338 | %% VZ: the wxApp event handler are private and should not be documented here! | |
339 | %% | |
340 | %%\membersection{wxApp::OnIdle}\label{wxapponidle} | |
341 | %% | |
342 | %%\func{void}{OnIdle}{\param{wxIdleEvent\& }{event}} | |
343 | %% | |
344 | %%Override this member function for any processing which needs to be done | |
345 | %%when the application is idle. You should call wxApp::OnIdle from your own function, | |
346 | %%since this forwards OnIdle events to windows and also performs garbage collection for | |
347 | %%windows whose destruction has been delayed. | |
348 | %% | |
349 | %%wxWindows' strategy for OnIdle processing is as follows. After pending user interface events for an | |
350 | %%application have all been processed, wxWindows sends an OnIdle event to the application object. wxApp::OnIdle itself | |
351 | %%sends an OnIdle event to each application window, allowing windows to do idle processing such as updating | |
352 | %%their appearance. If either wxApp::OnIdle or a window OnIdle function requested more time, by | |
353 | %%calling \helpref{wxIdleEvent::RequestMore}{wxidleeventrequestmore}, wxWindows will send another OnIdle | |
354 | %%event to the application object. This will occur in a loop until either a user event is found to be | |
355 | %%pending, or OnIdle requests no more time. Then all pending user events are processed until the system | |
356 | %%goes idle again, when OnIdle is called, and so on. | |
357 | %% | |
358 | %%\wxheading{See also} | |
359 | %% | |
360 | %%\helpref{wxWindow::OnIdle}{wxwindowonidle}, \helpref{wxIdleEvent}{wxidleevent},\rtfsp | |
361 | %%\helpref{wxWindow::SendIdleEvents}{wxappsendidleevents} | |
362 | %% | |
363 | %%\membersection{wxApp::OnEndSession}\label{wxapponendsession} | |
364 | %% | |
365 | %%\func{void}{OnEndSession}{\param{wxCloseEvent\& }{event}} | |
366 | %% | |
367 | %%This is an event handler function called when the operating system or GUI session is | |
368 | %%about to close down. The application has a chance to silently save information, | |
369 | %%and can optionally close itself. | |
370 | %% | |
371 | %%Use the EVT\_END\_SESSION event table macro to handle query end session events. | |
372 | %% | |
373 | %%The default handler calls \helpref{wxWindow::Close}{wxwindowclose} with a true argument | |
374 | %%(forcing the application to close itself silently). | |
375 | %% | |
376 | %%\wxheading{Remarks} | |
377 | %% | |
378 | %%Under X, OnEndSession is called in response to the `die' event. | |
379 | %% | |
380 | %%Under Windows, OnEndSession is called in response to the WM\_ENDSESSION message. | |
381 | %% | |
382 | %%\wxheading{See also} | |
383 | %% | |
384 | %%\helpref{wxWindow::Close}{wxwindowclose},\rtfsp | |
385 | %%\helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp | |
386 | %%\helpref{wxCloseEvent}{wxcloseevent},\rtfsp | |
387 | %%\helpref{wxApp::OnQueryEndSession}{wxapponqueryendsession} | |
388 | ||
389 | \membersection{wxApp::OnInit}\label{wxapponinit} | |
390 | ||
391 | \func{bool}{OnInit}{\void} | |
392 | ||
393 | This must be provided by the application, and will usually create the | |
394 | application's main window, optionally calling | |
395 | \helpref{wxApp::SetTopWindow}{wxappsettopwindow}. | |
396 | ||
397 | Notice that if you want to to use the command line processing provided by | |
398 | wxWindows you have to call the base class version in the derived class | |
399 | OnInit(). | |
400 | ||
401 | Return true to continue processing, false to exit the application. | |
402 | ||
403 | \membersection{wxApp::OnInitCmdLine}\label{wxapponinitcmdline} | |
404 | ||
405 | \func{void}{OnInitCmdLine}{\param{wxCmdLineParser\& }{parser}} | |
406 | ||
407 | Called from \helpref{OnInit}{wxapponinit} and may be used to initialize the | |
408 | parser with the command line options for this application. The base class | |
409 | versions adds support for a few standard options only. | |
410 | ||
411 | \membersection{wxApp::OnQueryEndSession}\label{wxapponqueryendsession} | |
412 | ||
413 | \func{void}{OnQueryEndSession}{\param{wxCloseEvent\& }{event}} | |
414 | ||
415 | This is an event handler function called when the operating system or GUI session is | |
416 | about to close down. Typically, an application will try to save unsaved documents | |
417 | at this point. | |
418 | ||
419 | If \helpref{wxCloseEvent::CanVeto}{wxcloseeventcanveto} returns true, the application | |
420 | is allowed to veto the shutdown by calling \helpref{wxCloseEvent::Veto}{wxcloseeventveto}. | |
421 | The application might veto the shutdown after prompting for documents to be saved, and the | |
422 | user has cancelled the save. | |
423 | ||
424 | Use the EVT\_QUERY\_END\_SESSION event table macro to handle query end session events. | |
425 | ||
426 | You should check whether the application is forcing the deletion of the window | |
427 | using \helpref{wxCloseEvent::GetForce}{wxcloseeventgetforce}. If this is true, | |
428 | destroy the window using \helpref{wxWindow::Destroy}{wxwindowdestroy}. | |
429 | If not, it is up to you whether you respond by destroying the window. | |
430 | ||
431 | The default handler calls \helpref{wxWindow::Close}{wxwindowclose} on the top-level window, | |
432 | and vetoes the shutdown if Close returns false. This will be sufficient for many applications. | |
433 | ||
434 | \wxheading{Remarks} | |
435 | ||
436 | Under X, OnQueryEndSession is called in response to the `save session' event. | |
437 | ||
438 | Under Windows, OnQueryEndSession is called in response to the WM\_QUERYENDSESSION message. | |
439 | ||
440 | \wxheading{See also} | |
441 | ||
442 | \helpref{wxWindow::Close}{wxwindowclose},\rtfsp | |
443 | \helpref{wxCloseEvent}{wxcloseevent} | |
444 | %% GD: OnXXX functions are not documented | |
445 | %%\helpref{wxApp::OnEndSession}{wxapponendsession} | |
446 | ||
447 | \membersection{wxApp::ProcessMessage}\label{wxappprocessmessage} | |
448 | ||
449 | \func{bool}{ProcessMessage}{\param{WXMSG *}{msg}} | |
450 | ||
451 | Windows-only function for processing a message. This function | |
452 | is called from the main message loop, checking for windows that | |
453 | may wish to process it. The function returns true if the message | |
454 | was processed, false otherwise. If you use wxWindows with another class | |
455 | library with its own message loop, you should make sure that this | |
456 | function is called to allow wxWindows to receive messages. For example, | |
457 | to allow co-existence with the Microsoft Foundation Classes, override | |
458 | the PreTranslateMessage function: | |
459 | ||
460 | \begin{verbatim} | |
461 | // Provide wxWindows message loop compatibility | |
462 | BOOL CTheApp::PreTranslateMessage(MSG *msg) | |
463 | { | |
464 | if (wxTheApp && wxTheApp->ProcessMessage((WXMSW *)msg)) | |
465 | return true; | |
466 | else | |
467 | return CWinApp::PreTranslateMessage(msg); | |
468 | } | |
469 | \end{verbatim} | |
470 | ||
471 | \membersection{wxApp::Pending}\label{wxapppending} | |
472 | ||
473 | \func{bool}{Pending}{\void} | |
474 | ||
475 | Returns true if unprocessed events are in the window system event queue. | |
476 | ||
477 | \wxheading{See also} | |
478 | ||
479 | \helpref{wxApp::Dispatch}{wxappdispatch} | |
480 | ||
481 | \membersection{wxApp::SendIdleEvents}\label{wxappsendidleevents} | |
482 | ||
483 | \func{bool}{SendIdleEvents}{\void} | |
484 | ||
485 | Sends idle events to all top-level windows. | |
486 | ||
487 | \func{bool}{SendIdleEvents}{\param{wxWindow*}{ win}} | |
488 | ||
489 | Sends idle events to a window and its children. | |
490 | ||
491 | \wxheading{Remarks} | |
492 | ||
493 | These functions poll the top-level windows, and their children, for idle event processing. | |
494 | If true is returned, more OnIdle processing is requested by one or more window. | |
495 | ||
496 | \wxheading{See also} | |
497 | ||
498 | %% GD: OnXXX functions are not documented | |
499 | %%\helpref{wxApp::OnIdle}{wxapponidle} | |
500 | \helpref{wxIdleEvent}{wxidleevent} | |
501 | ||
502 | \membersection{wxApp::SetAppName}\label{wxappsetappname} | |
503 | ||
504 | \func{void}{SetAppName}{\param{const wxString\& }{name}} | |
505 | ||
506 | Sets the name of the application. The name may be used in dialogs | |
507 | (for example by the document/view framework). A default name is set by | |
508 | wxWindows. | |
509 | ||
510 | \wxheading{See also} | |
511 | ||
512 | \helpref{wxApp::GetAppName}{wxappgetappname} | |
513 | ||
514 | \membersection{wxApp::SetAuto3D}\label{wxappsetauto3d} | |
515 | ||
516 | \func{void}{SetAuto3D}{\param{const bool}{ auto3D}} | |
517 | ||
518 | Switches automatic 3D controls on or off. | |
519 | ||
520 | \wxheading{Parameters} | |
521 | ||
522 | \docparam{auto3D}{If true, all controls will be created with 3D appearances unless | |
523 | overridden for a control or dialog. The default is true} | |
524 | ||
525 | \wxheading{Remarks} | |
526 | ||
527 | This has an effect on Windows only. | |
528 | ||
529 | \wxheading{See also} | |
530 | ||
531 | \helpref{wxApp::GetAuto3D}{wxappgetauto3d} | |
532 | ||
533 | \membersection{wxApp::SetClassName}\label{wxappsetclassname} | |
534 | ||
535 | \func{void}{SetClassName}{\param{const wxString\& }{name}} | |
536 | ||
537 | Sets the class name of the application. This may be used in a platform specific | |
538 | manner to refer to the application. | |
539 | ||
540 | \wxheading{See also} | |
541 | ||
542 | \helpref{wxApp::GetClassName}{wxappgetclassname} | |
543 | ||
544 | \membersection{wxApp::SetExitOnFrameDelete}\label{wxappsetexitonframedelete} | |
545 | ||
546 | \func{void}{SetExitOnFrameDelete}{\param{bool}{ flag}} | |
547 | ||
548 | Allows the programmer to specify whether the application will exit when the | |
549 | top-level frame is deleted. | |
550 | ||
551 | \wxheading{Parameters} | |
552 | ||
553 | \docparam{flag}{If true (the default), the application will exit when the top-level frame is | |
554 | deleted. If false, the application will continue to run.} | |
555 | ||
556 | \wxheading{See also} | |
557 | ||
558 | \helpref{wxApp::GetExitOnFrameDelete}{wxappgetexitonframedelete},\\ | |
559 | \helpref{wxApp shutdown overview}{wxappshutdownoverview} | |
560 | ||
561 | \membersection{wxApp::SetTopWindow}\label{wxappsettopwindow} | |
562 | ||
563 | \func{void}{SetTopWindow}{\param{wxWindow* }{window}} | |
564 | ||
565 | Sets the `top' window. You can call this from within \helpref{wxApp::OnInit}{wxapponinit} to | |
566 | let wxWindows know which is the main window. You don't have to set the top window; | |
567 | it is only a convenience so that (for example) certain dialogs without parents can use a | |
568 | specific window as the top window. If no top window is specified by the application, | |
569 | wxWindows just uses the first frame or dialog in its top-level window list, when it | |
570 | needs to use the top window. | |
571 | ||
572 | \wxheading{Parameters} | |
573 | ||
574 | \docparam{window}{The new top window.} | |
575 | ||
576 | \wxheading{See also} | |
577 | ||
578 | \helpref{wxApp::GetTopWindow}{wxappgettopwindow}, \helpref{wxApp::OnInit}{wxapponinit} | |
579 | ||
580 | ||
581 | \membersection{wxApp::SetVendorName}\label{wxappsetvendorname} | |
582 | ||
583 | \func{void}{SetVendorName}{\param{const wxString\& }{name}} | |
584 | ||
585 | Sets the name of application's vendor. The name will be used | |
586 | in registry access. A default name is set by | |
587 | wxWindows. | |
588 | ||
589 | \wxheading{See also} | |
590 | ||
591 | \helpref{wxApp::GetVendorName}{wxappgetvendorname} | |
592 | ||
593 | \membersection{wxApp::SetUseBestVisual}\label{wxappsetusebestvisual} | |
594 | ||
595 | \func{void}{SetUseBestVisual}{\param{bool}{ flag}} | |
596 | ||
597 | Allows the programmer to specify whether the application will use the best visual | |
598 | on systems that support several visual on the same display. This is typically the | |
599 | case under Solaris and IRIX, where the default visual is only 8-bit whereas certain | |
600 | applications are supposed to run in TrueColour mode. | |
601 | ||
602 | Note that this function has to be called in the constructor of the {\tt wxApp} | |
603 | instance and won't have any effect when called later on. | |
604 | ||
605 | This function currently only has effect under GTK. | |
606 | ||
607 | \wxheading{Parameters} | |
608 | ||
609 | \docparam{flag}{If true, the app will use the best visual.} | |
610 | ||
611 | \membersection{wxApp::Yield}\label{wxappyield} | |
612 | ||
613 | \func{bool}{Yield}{\param{bool}{ onlyIfNeeded = false}} | |
614 | ||
615 | Yields control to pending messages in the windowing system. This can be useful, for example, when a | |
616 | time-consuming process writes to a text window. Without an occasional | |
617 | yield, the text window will not be updated properly, and on systems with | |
618 | cooperative multitasking, such as Windows 3.1 other processes will not respond. | |
619 | ||
620 | Caution should be exercised, however, since yielding may allow the | |
621 | user to perform actions which are not compatible with the current task. | |
622 | Disabling menu items or whole menus during processing can avoid unwanted | |
623 | reentrance of code: see \helpref{::wxSafeYield}{wxsafeyield} for a better | |
624 | function. | |
625 | ||
626 | Note that Yield() will not flush the message logs. This is intentional as | |
627 | calling Yield() is usually done to quickly update the screen and popping up a | |
628 | message box dialog may be undesirable. If you do wish to flush the log | |
629 | messages immediately (otherwise it will be done during the next idle loop | |
630 | iteration), call \helpref{wxLog::FlushActive}{wxlogflushactive}. | |
631 | ||
632 | Calling Yield() recursively is normally an error and an assert failure is | |
633 | raised in debug build if such situation is detected. However if the the | |
634 | {\it onlyIfNeeded} parameter is {\tt true}, the method will just silently | |
635 | return {\tt false} instead. | |
636 |