src/common/appcmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/appcmn.cpp
   3 // Purpose:     wxAppConsole and wxAppBase methods common to all platforms
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     18.10.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Vadim Zeitlin
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #if defined(__BORLANDC__)
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/app.h"
  29     #include "wx/window.h"
  30     #include "wx/bitmap.h"
  31     #include "wx/log.h"
  32     #include "wx/msgdlg.h"
  33     #include "wx/confbase.h"
  34     #include "wx/utils.h"
  35     #include "wx/wxcrtvararg.h"
  36 #endif
  37
  38 #include "wx/apptrait.h"
  39 #include "wx/cmdline.h"
  40 #include "wx/msgout.h"
  41 #include "wx/thread.h"
  42 #include "wx/vidmode.h"
  43
  44 #ifdef __WXDEBUG__
  45     #if wxUSE_STACKWALKER
  46         #include "wx/stackwalk.h"
  47     #endif // wxUSE_STACKWALKER
  48 #endif // __WXDEBUG__
  49
  50 #if defined(__WXMSW__)
  51     #include  "wx/msw/private.h"  // includes windows.h for LOGFONT
  52 #endif
  53
  54 #if wxUSE_FONTMAP
  55     #include "wx/fontmap.h"
  56 #endif // wxUSE_FONTMAP
  57
  58 // DLL options compatibility check:
  59 #include "wx/build.h"
  60 WX_CHECK_BUILD_OPTIONS("wxCore")
  61
  62 WXDLLIMPEXP_DATA_CORE(wxList) wxPendingDelete;
  63
  64 // ============================================================================
  65 // wxAppBase implementation
  66 // ============================================================================
  67
  68 // ----------------------------------------------------------------------------
  69 // initialization
  70 // ----------------------------------------------------------------------------
  71
  72 wxAppBase::wxAppBase()
  73 {
  74     m_topWindow = (wxWindow *)NULL;
  75
  76     m_useBestVisual = false;
  77     m_forceTrueColour = false;
  78
  79     m_isActive = true;
  80
  81     // We don't want to exit the app if the user code shows a dialog from its
  82     // OnInit() -- but this is what would happen if we set m_exitOnFrameDelete
  83     // to Yes initially as this dialog would be the last top level window.
  84     // OTOH, if we set it to No initially we'll have to overwrite it with Yes
  85     // when we enter our OnRun() because we do want the default behaviour from
  86     // then on. But this would be a problem if the user code calls
  87     // SetExitOnFrameDelete(false) from OnInit().
  88     //
  89     // So we use the special "Later" value which is such that
  90     // GetExitOnFrameDelete() returns false for it but which we know we can
  91     // safely (i.e. without losing the effect of the users SetExitOnFrameDelete
  92     // call) overwrite in OnRun()
  93     m_exitOnFrameDelete = Later;
  94 }
  95
  96 bool wxAppBase::Initialize(int& argcOrig, wxChar **argvOrig)
  97 {
  98     if ( !wxAppConsole::Initialize(argcOrig, argvOrig) )
  99         return false;
 100
 101     wxInitializeStockLists();
 102
 103     wxBitmap::InitStandardHandlers();
 104
 105     return true;
 106 }
 107
 108 // ----------------------------------------------------------------------------
 109 // cleanup
 110 // ----------------------------------------------------------------------------
 111
 112 wxAppBase::~wxAppBase()
 113 {
 114     // this destructor is required for Darwin
 115 }
 116
 117 void wxAppBase::CleanUp()
 118 {
 119     // clean up all the pending objects
 120     DeletePendingObjects();
 121
 122     // and any remaining TLWs (they remove themselves from wxTopLevelWindows
 123     // when destroyed, so iterate until none are left)
 124     while ( !wxTopLevelWindows.empty() )
 125     {
 126         // do not use Destroy() here as it only puts the TLW in pending list
 127         // but we want to delete them now
 128         delete wxTopLevelWindows.GetFirst()->GetData();
 129     }
 130
 131     // undo everything we did in Initialize() above
 132     wxBitmap::CleanUpHandlers();
 133
 134     wxStockGDI::DeleteAll();
 135
 136     wxDeleteStockLists();
 137
 138     delete wxTheColourDatabase;
 139     wxTheColourDatabase = NULL;
 140
 141 #if wxUSE_THREADS
 142     #if wxUSE_VALIDATORS
 143         // If we don't do the following, we get an apparent memory leak.
 144         ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
 145     #endif // wxUSE_VALIDATORS
 146 #endif // wxUSE_THREADS
 147
 148     wxAppConsole::CleanUp();
 149 }
 150
 151 // ----------------------------------------------------------------------------
 152 // various accessors
 153 // ----------------------------------------------------------------------------
 154
 155 wxWindow* wxAppBase::GetTopWindow() const
 156 {
 157     wxWindow* window = m_topWindow;
 158     if (window == NULL && wxTopLevelWindows.GetCount() > 0)
 159         window = wxTopLevelWindows.GetFirst()->GetData();
 160     return window;
 161 }
 162
 163 wxVideoMode wxAppBase::GetDisplayMode() const
 164 {
 165     return wxVideoMode();
 166 }
 167
 168 wxLayoutDirection wxAppBase::GetLayoutDirection() const
 169 {
 170 #if wxUSE_INTL
 171     const wxLocale *const locale = wxGetLocale();
 172     if ( locale )
 173     {
 174         const wxLanguageInfo *const
 175             info = wxLocale::GetLanguageInfo(locale->GetLanguage());
 176
 177         if ( info )
 178             return info->LayoutDirection;
 179     }
 180 #endif // wxUSE_INTL
 181
 182     // we don't know
 183     return wxLayout_Default;
 184 }
 185
 186 #if wxUSE_CMDLINE_PARSER
 187
 188 // ----------------------------------------------------------------------------
 189 // GUI-specific command line options handling
 190 // ----------------------------------------------------------------------------
 191
 192 #define OPTION_THEME   _T("theme")
 193 #define OPTION_MODE    _T("mode")
 194
 195 void wxAppBase::OnInitCmdLine(wxCmdLineParser& parser)
 196 {
 197     // first add the standard non GUI options
 198     wxAppConsole::OnInitCmdLine(parser);
 199
 200     // the standard command line options
 201     static const wxCmdLineEntryDesc cmdLineGUIDesc[] =
 202     {
 203 #ifdef __WXUNIVERSAL__
 204         {
 205             wxCMD_LINE_OPTION,
 206             wxEmptyString,
 207             OPTION_THEME,
 208             gettext_noop("specify the theme to use"),
 209             wxCMD_LINE_VAL_STRING,
 210             0x0
 211         },
 212 #endif // __WXUNIVERSAL__
 213
 214 #if defined(__WXMGL__)
 215         // VS: this is not specific to wxMGL, all fullscreen (framebuffer) ports
 216         //     should provide this option. That's why it is in common/appcmn.cpp
 217         //     and not mgl/app.cpp
 218         {
 219             wxCMD_LINE_OPTION,
 220             wxEmptyString,
 221             OPTION_MODE,
 222             gettext_noop("specify display mode to use (e.g. 640x480-16)"),
 223             wxCMD_LINE_VAL_STRING,
 224             0x0
 225         },
 226 #endif // __WXMGL__
 227
 228         // terminator
 229         {
 230             wxCMD_LINE_NONE,
 231             wxEmptyString,
 232             wxEmptyString,
 233             wxEmptyString,
 234             wxCMD_LINE_VAL_NONE,
 235             0x0
 236         }
 237     };
 238
 239     parser.SetDesc(cmdLineGUIDesc);
 240 }
 241
 242 bool wxAppBase::OnCmdLineParsed(wxCmdLineParser& parser)
 243 {
 244 #ifdef __WXUNIVERSAL__
 245     wxString themeName;
 246     if ( parser.Found(OPTION_THEME, &themeName) )
 247     {
 248         wxTheme *theme = wxTheme::Create(themeName);
 249         if ( !theme )
 250         {
 251             wxLogError(_("Unsupported theme '%s'."), themeName.c_str());
 252             return false;
 253         }
 254
 255         // Delete the defaultly created theme and set the new theme.
 256         delete wxTheme::Get();
 257         wxTheme::Set(theme);
 258     }
 259 #endif // __WXUNIVERSAL__
 260
 261 #if defined(__WXMGL__)
 262     wxString modeDesc;
 263     if ( parser.Found(OPTION_MODE, &modeDesc) )
 264     {
 265         unsigned w, h, bpp;
 266         if ( wxSscanf(modeDesc.c_str(), _T("%ux%u-%u"), &w, &h, &bpp) != 3 )
 267         {
 268             wxLogError(_("Invalid display mode specification '%s'."), modeDesc.c_str());
 269             return false;
 270         }
 271
 272         if ( !SetDisplayMode(wxVideoMode(w, h, bpp)) )
 273             return false;
 274     }
 275 #endif // __WXMGL__
 276
 277     return wxAppConsole::OnCmdLineParsed(parser);
 278 }
 279
 280 #endif // wxUSE_CMDLINE_PARSER
 281
 282 // ----------------------------------------------------------------------------
 283 // OnXXX() hooks
 284 // ----------------------------------------------------------------------------
 285
 286 bool wxAppBase::OnInitGui()
 287 {
 288 #ifdef __WXUNIVERSAL__
 289     if ( !wxTheme::Get() && !wxTheme::CreateDefault() )
 290         return false;
 291 #endif // __WXUNIVERSAL__
 292
 293     return true;
 294 }
 295
 296 int wxAppBase::OnRun()
 297 {
 298     // see the comment in ctor: if the initial value hasn't been changed, use
 299     // the default Yes from now on
 300     if ( m_exitOnFrameDelete == Later )
 301     {
 302         m_exitOnFrameDelete = Yes;
 303     }
 304     //else: it has been changed, assume the user knows what he is doing
 305
 306     return wxAppConsole::OnRun();
 307 }
 308
 309 int wxAppBase::OnExit()
 310 {
 311 #ifdef __WXUNIVERSAL__
 312     delete wxTheme::Set(NULL);
 313 #endif // __WXUNIVERSAL__
 314
 315     return wxAppConsole::OnExit();
 316 }
 317
 318 wxAppTraits *wxAppBase::CreateTraits()
 319 {
 320     return new wxGUIAppTraits;
 321 }
 322
 323 // ----------------------------------------------------------------------------
 324 // misc
 325 // ----------------------------------------------------------------------------
 326
 327 void wxAppBase::SetActive(bool active, wxWindow * WXUNUSED(lastFocus))
 328 {
 329     if ( active == m_isActive )
 330         return;
 331
 332     m_isActive = active;
 333
 334     wxActivateEvent event(wxEVT_ACTIVATE_APP, active);
 335     event.SetEventObject(this);
 336
 337     (void)ProcessEvent(event);
 338 }
 339
 340 // ----------------------------------------------------------------------------
 341 // idle handling
 342 // ----------------------------------------------------------------------------
 343
 344 void wxAppBase::DeletePendingObjects()
 345 {
 346     wxList::compatibility_iterator node = wxPendingDelete.GetFirst();
 347     while (node)
 348     {
 349         wxObject *obj = node->GetData();
 350
 351         // remove it from the list first so that if we get back here somehow
 352         // during the object deletion (e.g. wxYield called from its dtor) we
 353         // wouldn't try to delete it the second time
 354         if ( wxPendingDelete.Member(obj) )
 355             wxPendingDelete.Erase(node);
 356
 357         delete obj;
 358
 359         // Deleting one object may have deleted other pending
 360         // objects, so start from beginning of list again.
 361         node = wxPendingDelete.GetFirst();
 362     }
 363 }
 364
 365 // Returns true if more time is needed.
 366 bool wxAppBase::ProcessIdle()
 367 {
 368     // process pending wx events before sending idle events
 369     ProcessPendingEvents();
 370
 371     wxIdleEvent event;
 372     bool needMore = false;
 373     wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
 374     while (node)
 375     {
 376         wxWindow* win = node->GetData();
 377         if (SendIdleEvents(win, event))
 378             needMore = true;
 379         node = node->GetNext();
 380     }
 381
 382     if (wxAppConsole::ProcessIdle())
 383         needMore = true;
 384
 385     // 'Garbage' collection of windows deleted with Close().
 386     DeletePendingObjects();
 387
 388 #if wxUSE_LOG
 389     // flush the logged messages if any
 390     wxLog::FlushActive();
 391 #endif
 392
 393     wxUpdateUIEvent::ResetUpdateTime();
 394
 395     return needMore;
 396 }
 397
 398 // Send idle event to window and all subwindows
 399 bool wxAppBase::SendIdleEvents(wxWindow* win, wxIdleEvent& event)
 400 {
 401     bool needMore = false;
 402
 403     win->OnInternalIdle();
 404
 405     // should we send idle event to this window?
 406     if ( wxIdleEvent::GetMode() == wxIDLE_PROCESS_ALL ||
 407             win->HasExtraStyle(wxWS_EX_PROCESS_IDLE) )
 408     {
 409         event.SetEventObject(win);
 410         win->GetEventHandler()->ProcessEvent(event);
 411
 412         if (event.MoreRequested())
 413             needMore = true;
 414     }
 415     wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
 416     while ( node )
 417     {
 418         wxWindow *child = node->GetData();
 419         if (SendIdleEvents(child, event))
 420             needMore = true;
 421
 422         node = node->GetNext();
 423     }
 424
 425     return needMore;
 426 }
 427
 428 // ----------------------------------------------------------------------------
 429 // wxGUIAppTraitsBase
 430 // ----------------------------------------------------------------------------
 431
 432 #if wxUSE_LOG
 433
 434 wxLog *wxGUIAppTraitsBase::CreateLogTarget()
 435 {
 436 #if wxUSE_LOGGUI
 437     return new wxLogGui;
 438 #else
 439     // we must have something!
 440     return new wxLogStderr;
 441 #endif
 442 }
 443
 444 #endif // wxUSE_LOG
 445
 446 wxMessageOutput *wxGUIAppTraitsBase::CreateMessageOutput()
 447 {
 448     // The standard way of printing help on command line arguments (app --help)
 449     // is (according to common practice):
 450     //     - console apps: to stderr (on any platform)
 451     //     - GUI apps: stderr on Unix platforms (!)
 452     //                 message box under Windows and others
 453 #ifdef __UNIX__
 454     return new wxMessageOutputStderr;
 455 #else // !__UNIX__
 456     // wxMessageOutputMessageBox doesn't work under Motif
 457     #ifdef __WXMOTIF__
 458         return new wxMessageOutputLog;
 459     #else
 460         return new wxMessageOutputMessageBox;
 461     #endif
 462 #endif // __UNIX__/!__UNIX__
 463 }
 464
 465 #if wxUSE_FONTMAP
 466
 467 wxFontMapper *wxGUIAppTraitsBase::CreateFontMapper()
 468 {
 469     return new wxFontMapper;
 470 }
 471
 472 #endif // wxUSE_FONTMAP
 473
 474 wxRendererNative *wxGUIAppTraitsBase::CreateRenderer()
 475 {
 476     // use the default native renderer by default
 477     return NULL;
 478 }
 479
 480 #ifdef __WXDEBUG__
 481
 482 bool wxGUIAppTraitsBase::ShowAssertDialog(const wxString& msg)
 483 {
 484 #if defined(__WXMSW__) || !wxUSE_MSGDLG
 485     // under MSW we prefer to use the base class version using ::MessageBox()
 486     // even if wxMessageBox() is available because it has less chances to
 487     // double fault our app than our wxMessageBox()
 488     return wxAppTraitsBase::ShowAssertDialog(msg);
 489 #else // wxUSE_MSGDLG
 490     wxString msgDlg = msg;
 491
 492 #if wxUSE_STACKWALKER
 493     // on Unix stack frame generation may take some time, depending on the
 494     // size of the executable mainly... warn the user that we are working
 495     wxFprintf(stderr, wxT("[Debug] Generating a stack trace... please wait"));
 496     fflush(stderr);
 497
 498     const wxString stackTrace = GetAssertStackTrace();
 499     if ( !stackTrace.empty() )
 500         msgDlg << _T("\n\nCall stack:\n") << stackTrace;
 501 #endif // wxUSE_STACKWALKER
 502
 503     // this message is intentionally not translated -- it is for
 504     // developpers only
 505     msgDlg += wxT("\nDo you want to stop the program?\n")
 506               wxT("You can also choose [Cancel] to suppress ")
 507               wxT("further warnings.");
 508
 509     switch ( wxMessageBox(msgDlg, wxT("wxWidgets Debug Alert"),
 510                           wxYES_NO | wxCANCEL | wxICON_STOP ) )
 511     {
 512         case wxYES:
 513             wxTrap();
 514             break;
 515
 516         case wxCANCEL:
 517             // no more asserts
 518             return true;
 519
 520         //case wxNO: nothing to do
 521     }
 522
 523     return false;
 524 #endif // !wxUSE_MSGDLG/wxUSE_MSGDLG
 525 }
 526
 527 #endif // __WXDEBUG__
 528
 529 bool wxGUIAppTraitsBase::HasStderr()
 530 {
 531     // we consider that under Unix stderr always goes somewhere, even if the
 532     // user doesn't always see it under GUI desktops
 533 #ifdef __UNIX__
 534     return true;
 535 #else
 536     return false;
 537 #endif
 538 }
 539
 540 void wxGUIAppTraitsBase::ScheduleForDestroy(wxObject *object)
 541 {
 542     if ( !wxPendingDelete.Member(object) )
 543         wxPendingDelete.Append(object);
 544 }
 545
 546 void wxGUIAppTraitsBase::RemoveFromPendingDelete(wxObject *object)
 547 {
 548     wxPendingDelete.DeleteObject(object);
 549 }
 550
 551 #if wxUSE_SOCKETS
 552
 553 #if defined(__WINDOWS__)
 554     #include "wx/msw/gsockmsw.h"
 555 #elif defined(__UNIX__) || defined(__DARWIN__) || defined(__OS2__)
 556     #include "wx/unix/gsockunx.h"
 557 #elif defined(__WXMAC__)
 558     #include <MacHeaders.c>
 559     #define OTUNIXERRORS 1
 560     #include <OpenTransport.h>
 561     #include <OpenTransportProviders.h>
 562     #include <OpenTptInternet.h>
 563
 564     #include "wx/mac/gsockmac.h"
 565 #else
 566     #error "Must include correct GSocket header here"
 567 #endif
 568
 569 GSocketGUIFunctionsTable* wxGUIAppTraitsBase::GetSocketGUIFunctionsTable()
 570 {
 571 #if defined(__WXMAC__) && !defined(__DARWIN__)
 572     // NB: wxMac CFM does not have any GUI-specific functions in gsocket.c and
 573     //     so it doesn't need this table at all
 574     return NULL;
 575 #else // !__WXMAC__ || __DARWIN__
 576     static GSocketGUIFunctionsTableConcrete table;
 577     return &table;
 578 #endif // !__WXMAC__ || __DARWIN__
 579 }
 580
 581 #endif