src/msw/main.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/main.cpp
   3 // Purpose:     WinMain/DllMain
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   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 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/event.h"
  29     #include "wx/app.h"
  30     #include "wx/utils.h"
  31 #endif //WX_PRECOMP
  32
  33 #include "wx/cmdline.h"
  34 #include "wx/scopeguard.h"
  35
  36 #include "wx/msw/private.h"
  37 #include "wx/msw/seh.h"
  38
  39 #if wxUSE_ON_FATAL_EXCEPTION
  40     #include "wx/datetime.h"
  41     #include "wx/msw/crashrpt.h"
  42 #endif // wxUSE_ON_FATAL_EXCEPTION
  43
  44 #ifdef __WXWINCE__
  45     // there is no ExitProcess() under CE but exiting the main thread has the
  46     // same effect
  47     #ifndef ExitProcess
  48         #define ExitProcess ExitThread
  49     #endif
  50 #endif // __WXWINCE__
  51
  52 #ifdef __BORLANDC__
  53     // BC++ has to be special: its run-time expects the DLL entry point to be
  54     // named DllEntryPoint instead of the (more) standard DllMain
  55     #define DllMain DllEntryPoint
  56 #endif // __BORLANDC__
  57
  58 #if defined(__WXMICROWIN__)
  59     #define HINSTANCE HANDLE
  60 #endif
  61
  62 // defined in common/init.cpp
  63 extern int wxEntryReal(int& argc, wxChar **argv);
  64 extern int wxEntryCleanupReal(int& argc, wxChar **argv);
  65
  66 // ============================================================================
  67 // implementation: various entry points
  68 // ============================================================================
  69
  70 #if wxUSE_BASE
  71
  72 #if wxUSE_ON_FATAL_EXCEPTION && defined(__VISUALC__) && !defined(__WXWINCE__)
  73     // VC++ (at least from 4.0 up to version 7.1) is incredibly broken in that
  74     // a "catch ( ... )" will *always* catch SEH exceptions in it even though
  75     // it should have never been the case... to prevent such catches from
  76     // stealing the exceptions from our wxGlobalSEHandler which is only called
  77     // if the exception is not handled elsewhere, we have to also call it from
  78     // a special SEH translator function which is called by VC CRT when a Win32
  79     // exception occurs
  80
  81     // this warns that /EHa (async exceptions) should be used when using
  82     // _set_se_translator but, in fact, this doesn't seem to change anything
  83     // with VC++ up to 8.0
  84     #if _MSC_VER <= 1400
  85         #pragma warning(disable:4535)
  86     #endif
  87
  88     // note that the SE translator must be called wxSETranslator!
  89     #define DisableAutomaticSETranslator() _set_se_translator(wxSETranslator)
  90 #else // !__VISUALC__
  91     #define DisableAutomaticSETranslator()
  92 #endif // __VISUALC__/!__VISUALC__
  93
  94 // ----------------------------------------------------------------------------
  95 // wrapper wxEntry catching all Win32 exceptions occurring in a wx program
  96 // ----------------------------------------------------------------------------
  97
  98 // wrap real wxEntry in a try-except block to be able to call
  99 // OnFatalException() if necessary
 100 #if wxUSE_ON_FATAL_EXCEPTION
 101
 102 // global pointer to exception information, only valid inside OnFatalException,
 103 // used by wxStackWalker and wxCrashReport
 104 extern EXCEPTION_POINTERS *wxGlobalSEInformation = NULL;
 105
 106 // flag telling us whether the application wants to handle exceptions at all
 107 static bool gs_handleExceptions = false;
 108
 109 static void wxFatalExit()
 110 {
 111     // use the same exit code as abort()
 112     ::ExitProcess(3);
 113 }
 114
 115 unsigned long wxGlobalSEHandler(EXCEPTION_POINTERS *pExcPtrs)
 116 {
 117     if ( gs_handleExceptions && wxTheApp )
 118     {
 119         // store the pointer to exception info
 120         wxGlobalSEInformation = pExcPtrs;
 121
 122         // give the user a chance to do something special about this
 123         wxSEH_TRY
 124         {
 125             wxTheApp->OnFatalException();
 126         }
 127         wxSEH_IGNORE      // ignore any exceptions inside the exception handler
 128
 129         wxGlobalSEInformation = NULL;
 130
 131         // this will execute our handler and terminate the process
 132         return EXCEPTION_EXECUTE_HANDLER;
 133     }
 134
 135     return EXCEPTION_CONTINUE_SEARCH;
 136 }
 137
 138 #ifdef __VISUALC__
 139
 140 void wxSETranslator(unsigned int WXUNUSED(code), EXCEPTION_POINTERS *ep)
 141 {
 142     switch ( wxGlobalSEHandler(ep) )
 143     {
 144         default:
 145             wxFAIL_MSG( _T("unexpected wxGlobalSEHandler() return value") );
 146             // fall through
 147
 148         case EXCEPTION_EXECUTE_HANDLER:
 149             // if wxApp::OnFatalException() had been called we should exit the
 150             // application -- but we shouldn't kill our host when we're a DLL
 151 #ifndef WXMAKINGDLL
 152             wxFatalExit();
 153 #endif // not a DLL
 154             break;
 155
 156         case EXCEPTION_CONTINUE_SEARCH:
 157             // we're called for each "catch ( ... )" and if we (re)throw from
 158             // here, the catch handler body is not executed, so the effect is
 159             // as if had inhibited translation of SE to C++ ones because the
 160             // handler will never see any structured exceptions
 161             throw;
 162     }
 163 }
 164
 165 #endif // __VISUALC__
 166
 167 bool wxHandleFatalExceptions(bool doit)
 168 {
 169     // assume this can only be called from the main thread
 170     gs_handleExceptions = doit;
 171
 172 #if wxUSE_CRASHREPORT
 173     if ( doit )
 174     {
 175         // try to find a place where we can put out report file later
 176         wxChar fullname[MAX_PATH];
 177         if ( !::GetTempPath(WXSIZEOF(fullname), fullname) )
 178         {
 179             wxLogLastError(_T("GetTempPath"));
 180
 181             // when all else fails...
 182             wxStrcpy(fullname, _T("c:\\"));
 183         }
 184
 185         // use PID and date to make the report file name more unique
 186         wxString name = wxString::Format
 187                         (
 188                             _T("%s_%s_%lu.dmp"),
 189                             wxTheApp ? (const wxChar*)wxTheApp->GetAppDisplayName().c_str()
 190                                      : _T("wxwindows"),
 191                             wxDateTime::Now().Format(_T("%Y%m%dT%H%M%S")).c_str(),
 192                             ::GetCurrentProcessId()
 193                         );
 194
 195         wxStrncat(fullname, name, WXSIZEOF(fullname) - wxStrlen(fullname) - 1);
 196
 197         wxCrashReport::SetFileName(fullname);
 198     }
 199 #endif // wxUSE_CRASHREPORT
 200
 201     return true;
 202 }
 203
 204 int wxEntry(int& argc, wxChar **argv)
 205 {
 206     DisableAutomaticSETranslator();
 207
 208     wxSEH_TRY
 209     {
 210         return wxEntryReal(argc, argv);
 211     }
 212     wxSEH_HANDLE(-1)
 213 }
 214
 215 #else // !wxUSE_ON_FATAL_EXCEPTION
 216
 217 #if defined(__VISUALC__) && !defined(__WXWINCE__)
 218
 219 static void
 220 wxSETranslator(unsigned int WXUNUSED(code), EXCEPTION_POINTERS * WXUNUSED(ep))
 221 {
 222     // see wxSETranslator() version for wxUSE_ON_FATAL_EXCEPTION above
 223     throw;
 224 }
 225
 226 #endif // __VISUALC__
 227
 228 int wxEntry(int& argc, wxChar **argv)
 229 {
 230     DisableAutomaticSETranslator();
 231
 232     return wxEntryReal(argc, argv);
 233 }
 234
 235 #endif // wxUSE_ON_FATAL_EXCEPTION/!wxUSE_ON_FATAL_EXCEPTION
 236
 237 #endif // wxUSE_BASE
 238
 239 #if wxUSE_GUI && defined(__WXMSW__)
 240
 241 #if wxUSE_UNICODE && !defined(__WXWINCE__)
 242     #define NEED_UNICODE_CHECK
 243 #endif
 244
 245 #ifdef NEED_UNICODE_CHECK
 246
 247 // check whether Unicode is available
 248 static bool wxIsUnicodeAvailable()
 249 {
 250     static const wchar_t *ERROR_STRING = L"wxWidgets Fatal Error";
 251
 252     if ( wxGetOsVersion() != wxOS_WINDOWS_NT )
 253     {
 254         // we need to be built with MSLU support
 255 #if !wxUSE_UNICODE_MSLU
 256         // note that we can use MessageBoxW() as it's implemented even under
 257         // Win9x - OTOH, we can't use wxGetTranslation() because the file APIs
 258         // used by wxLocale are not
 259         ::MessageBox
 260         (
 261          NULL,
 262          L"This program uses Unicode and requires Windows NT/2000/XP.\n"
 263          L"\n"
 264          L"Program aborted.",
 265          ERROR_STRING,
 266          MB_ICONERROR | MB_OK
 267         );
 268
 269         return false;
 270 #else // wxUSE_UNICODE_MSLU
 271         // and the MSLU DLL must also be available
 272         HMODULE hmod = ::LoadLibraryA("unicows.dll");
 273         if ( !hmod )
 274         {
 275             ::MessageBox
 276             (
 277              NULL,
 278              L"This program uses Unicode and requires unicows.dll to work "
 279              L"under current operating system.\n"
 280              L"\n"
 281              L"Please install unicows.dll and relaunch the program.",
 282              ERROR_STRING,
 283              MB_ICONERROR | MB_OK
 284             );
 285             return false;
 286         }
 287
 288         // this is not really necessary but be tidy
 289         ::FreeLibrary(hmod);
 290
 291         // finally do the last check: has unicows.lib initialized correctly?
 292         hmod = ::LoadLibraryW(L"unicows.dll");
 293         if ( !hmod )
 294         {
 295             ::MessageBox
 296             (
 297              NULL,
 298              L"This program uses Unicode but is not using unicows.dll\n"
 299              L"correctly and so cannot work under current operating system.\n"
 300              L"Please contact the program author for an updated version.\n"
 301              L"\n"
 302              L"Program aborted.",
 303              ERROR_STRING,
 304              MB_ICONERROR | MB_OK
 305             );
 306
 307             return false;
 308         }
 309
 310         ::FreeLibrary(hmod);
 311 #endif // !wxUSE_UNICODE_MSLU
 312     }
 313
 314     return true;
 315 }
 316
 317 #endif // NEED_UNICODE_CHECK
 318
 319 // ----------------------------------------------------------------------------
 320 // Windows-specific wxEntry
 321 // ----------------------------------------------------------------------------
 322
 323 struct wxMSWCommandLineArguments
 324 {
 325     wxMSWCommandLineArguments() { argc = 0; argv = NULL; }
 326
 327     void Init(const wxArrayString& args)
 328     {
 329         argc = args.size();
 330
 331         // +1 here for the terminating NULL
 332         argv = new wxChar *[argc + 1];
 333         for ( int i = 0; i < argc; i++ )
 334         {
 335             argv[i] = wxStrdup(args[i].wx_str());
 336         }
 337
 338         // argv[] must be NULL-terminated
 339         argv[argc] = NULL;
 340     }
 341
 342     void Free()
 343     {
 344         if ( !argc )
 345             return;
 346
 347         for ( int i = 0; i < argc; i++ )
 348         {
 349             free(argv[i]);
 350         }
 351
 352         delete [] argv;
 353         argv = NULL;
 354         argc = 0;
 355     }
 356
 357     int argc;
 358     wxChar **argv;
 359 };
 360
 361 static wxMSWCommandLineArguments wxArgs;
 362
 363 // common part of wxMSW-specific wxEntryStart() and wxEntry() overloads
 364 static bool
 365 wxMSWEntryCommon(HINSTANCE hInstance, int nCmdShow)
 366 {
 367     // the first thing to do is to check if we're trying to run an Unicode
 368     // program under Win9x w/o MSLU emulation layer - if so, abort right now
 369     // as it has no chance to work and has all chances to crash
 370 #ifdef NEED_UNICODE_CHECK
 371     if ( !wxIsUnicodeAvailable() )
 372         return false;
 373 #endif // NEED_UNICODE_CHECK
 374
 375
 376     // remember the parameters Windows gave us
 377     wxSetInstance(hInstance);
 378     wxApp::m_nCmdShow = nCmdShow;
 379
 380     // parse the command line: we can't use pCmdLine in Unicode build so it is
 381     // simpler to never use it at all (this also results in a more correct
 382     // argv[0])
 383
 384     // break the command line in words
 385     wxArrayString args;
 386
 387     const wxChar *cmdLine = ::GetCommandLine();
 388     if ( cmdLine )
 389     {
 390         args = wxCmdLineParser::ConvertStringToArgs(cmdLine);
 391     }
 392
 393 #ifdef __WXWINCE__
 394     // WinCE doesn't insert the program itself, so do it ourselves.
 395     args.Insert(wxGetFullModuleName(), 0);
 396 #endif
 397
 398     wxArgs.Init(args);
 399
 400     return true;
 401 }
 402
 403 WXDLLEXPORT bool wxEntryStart(HINSTANCE hInstance,
 404                               HINSTANCE WXUNUSED(hPrevInstance),
 405                               wxCmdLineArgType WXUNUSED(pCmdLine),
 406                               int nCmdShow)
 407 {
 408     if ( !wxMSWEntryCommon(hInstance, nCmdShow) )
 409        return false;
 410
 411     return wxEntryStart(wxArgs.argc, wxArgs.argv);
 412 }
 413
 414 WXDLLEXPORT int wxEntry(HINSTANCE hInstance,
 415                         HINSTANCE WXUNUSED(hPrevInstance),
 416                         wxCmdLineArgType WXUNUSED(pCmdLine),
 417                         int nCmdShow)
 418 {
 419     if ( !wxMSWEntryCommon(hInstance, nCmdShow) )
 420         return -1;
 421
 422     wxON_BLOCK_EXIT_OBJ0(wxArgs, wxMSWCommandLineArguments::Free);
 423
 424     return wxEntry(wxArgs.argc, wxArgs.argv);
 425 }
 426
 427 #endif // wxUSE_GUI && __WXMSW__
 428
 429 // ----------------------------------------------------------------------------
 430 // global HINSTANCE
 431 // ----------------------------------------------------------------------------
 432
 433 #if wxUSE_BASE
 434
 435 HINSTANCE wxhInstance = 0;
 436
 437 extern "C" HINSTANCE wxGetInstance()
 438 {
 439     return wxhInstance;
 440 }
 441
 442 void wxSetInstance(HINSTANCE hInst)
 443 {
 444     wxhInstance = hInst;
 445 }
 446
 447 #endif // wxUSE_BASE