src/msw/main.cpp

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