src/msw/app.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/app.cpp
   3 // Purpose:     wxApp
   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 #if defined(__BORLANDC__)
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/msw/wrapcctl.h"
  29     #include "wx/dynarray.h"
  30     #include "wx/frame.h"
  31     #include "wx/app.h"
  32     #include "wx/utils.h"
  33     #include "wx/gdicmn.h"
  34     #include "wx/pen.h"
  35     #include "wx/brush.h"
  36     #include "wx/cursor.h"
  37     #include "wx/icon.h"
  38     #include "wx/palette.h"
  39     #include "wx/dc.h"
  40     #include "wx/dialog.h"
  41     #include "wx/msgdlg.h"
  42     #include "wx/intl.h"
  43     #include "wx/crt.h"
  44     #include "wx/log.h"
  45     #include "wx/module.h"
  46 #endif
  47
  48 #include "wx/apptrait.h"
  49 #include "wx/filename.h"
  50 #include "wx/dynlib.h"
  51 #include "wx/evtloop.h"
  52 #include "wx/thread.h"
  53
  54 #include "wx/msw/private.h"
  55 #include "wx/msw/dc.h"
  56 #include "wx/msw/ole/oleutils.h"
  57 #include "wx/msw/private/timer.h"
  58
  59 #if wxUSE_TOOLTIPS
  60     #include "wx/tooltip.h"
  61 #endif // wxUSE_TOOLTIPS
  62
  63 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
  64 // compilers don't support it (missing headers, libs, ...)
  65 #if defined(__GNUWIN32_OLD__) || defined(__SYMANTEC__)
  66     #undef wxUSE_OLE
  67
  68     #define  wxUSE_OLE 0
  69 #endif // broken compilers
  70
  71 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
  72     #include <ole2.h>
  73     #include <aygshell.h>
  74 #endif
  75
  76 #if wxUSE_OLE
  77     #include <ole2.h>
  78 #endif
  79
  80 #include <string.h>
  81 #include <ctype.h>
  82
  83 #include "wx/msw/missing.h"
  84
  85 // instead of including <shlwapi.h> which is not part of the core SDK and not
  86 // shipped at all with other compilers, we always define the parts of it we
  87 // need here ourselves
  88 //
  89 // NB: DLLVER_PLATFORM_WINDOWS will be defined if shlwapi.h had been somehow
  90 //     included already
  91 #ifndef DLLVER_PLATFORM_WINDOWS
  92     // hopefully we don't need to change packing as DWORDs should be already
  93     // correctly aligned
  94     struct DLLVERSIONINFO
  95     {
  96         DWORD cbSize;
  97         DWORD dwMajorVersion;                   // Major version
  98         DWORD dwMinorVersion;                   // Minor version
  99         DWORD dwBuildNumber;                    // Build number
 100         DWORD dwPlatformID;                     // DLLVER_PLATFORM_*
 101     };
 102
 103     typedef HRESULT (CALLBACK* DLLGETVERSIONPROC)(DLLVERSIONINFO *);
 104 #endif // defined(DLLVERSIONINFO)
 105
 106
 107 // ---------------------------------------------------------------------------
 108 // global variables
 109 // ---------------------------------------------------------------------------
 110
 111 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 112 extern void wxSetKeyboardHook(bool doIt);
 113 #endif
 114
 115 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
 116 //     with NR suffix - wxWindow::MSWCreate() supposes this
 117 #ifdef __WXWINCE__
 118 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassName;
 119 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassNameNR;
 120 #else
 121 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName = NULL;
 122 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassNameNR = NULL;
 123 #endif
 124 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassName = NULL;
 125 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassNameNoRedraw = NULL;
 126 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassName = NULL;
 127 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassNameNoRedraw = NULL;
 128
 129 // ----------------------------------------------------------------------------
 130 // private functions
 131 // ----------------------------------------------------------------------------
 132
 133 LRESULT WXDLLEXPORT APIENTRY wxWndProc(HWND, UINT, WPARAM, LPARAM);
 134
 135 // ===========================================================================
 136 // wxGUIAppTraits implementation
 137 // ===========================================================================
 138
 139 // private class which we use to pass parameters from BeforeChildWaitLoop() to
 140 // AfterChildWaitLoop()
 141 struct ChildWaitLoopData
 142 {
 143     ChildWaitLoopData(wxWindowDisabler *wd_, wxWindow *winActive_)
 144     {
 145         wd = wd_;
 146         winActive = winActive_;
 147     }
 148
 149     wxWindowDisabler *wd;
 150     wxWindow *winActive;
 151 };
 152
 153 void *wxGUIAppTraits::BeforeChildWaitLoop()
 154 {
 155     /*
 156        We use a dirty hack here to disable all application windows (which we
 157        must do because otherwise the calls to wxYield() could lead to some very
 158        unexpected reentrancies in the users code) but to avoid losing
 159        focus/activation entirely when the child process terminates which would
 160        happen if we simply disabled everything using wxWindowDisabler. Indeed,
 161        remember that Windows will never activate a disabled window and when the
 162        last childs window is closed and Windows looks for a window to activate
 163        all our windows are still disabled. There is no way to enable them in
 164        time because we don't know when the childs windows are going to be
 165        closed, so the solution we use here is to keep one special tiny frame
 166        enabled all the time. Then when the child terminates it will get
 167        activated and when we close it below -- after reenabling all the other
 168        windows! -- the previously active window becomes activated again and
 169        everything is ok.
 170      */
 171     wxBeginBusyCursor();
 172
 173     // first disable all existing windows
 174     wxWindowDisabler *wd = new wxWindowDisabler;
 175
 176     // then create an "invisible" frame: it has minimal size, is positioned
 177     // (hopefully) outside the screen and doesn't appear on the taskbar
 178     wxWindow *winActive = new wxFrame
 179                     (
 180                         wxTheApp->GetTopWindow(),
 181                         wxID_ANY,
 182                         wxEmptyString,
 183                         wxPoint(32600, 32600),
 184                         wxSize(1, 1),
 185                         wxDEFAULT_FRAME_STYLE | wxFRAME_NO_TASKBAR
 186                     );
 187     winActive->Show();
 188
 189     return new ChildWaitLoopData(wd, winActive);
 190 }
 191
 192 void wxGUIAppTraits::AlwaysYield()
 193 {
 194     wxYield();
 195 }
 196
 197 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
 198 {
 199     wxEndBusyCursor();
 200
 201     ChildWaitLoopData * const data = (ChildWaitLoopData *)dataOrig;
 202
 203     delete data->wd;
 204
 205     // finally delete the dummy frame and, as wd has been already destroyed and
 206     // the other windows reenabled, the activation is going to return to the
 207     // window which had had it before
 208     data->winActive->Destroy();
 209
 210     // also delete the temporary data object itself
 211     delete data;
 212 }
 213
 214 bool wxGUIAppTraits::DoMessageFromThreadWait()
 215 {
 216     // we should return false only if the app should exit, i.e. only if
 217     // Dispatch() determines that the main event loop should terminate
 218     wxEventLoopBase * const evtLoop = wxEventLoop::GetActive();
 219     if ( !evtLoop || !evtLoop->Pending() )
 220     {
 221         // no events means no quit event
 222         return true;
 223     }
 224
 225     return evtLoop->Dispatch();
 226 }
 227
 228 DWORD wxGUIAppTraits::WaitForThread(WXHANDLE hThread)
 229 {
 230     // if we don't have a running event loop, we shouldn't wait for the
 231     // messages as we never remove them from the message queue and so we enter
 232     // an infinite loop as MsgWaitForMultipleObjects() keeps returning
 233     // WAIT_OBJECT_0 + 1
 234     if ( !wxEventLoop::GetActive() )
 235         return DoSimpleWaitForThread(hThread);
 236
 237     return ::MsgWaitForMultipleObjects
 238              (
 239                1,                   // number of objects to wait for
 240                (HANDLE *)&hThread,  // the objects
 241                false,               // wait for any objects, not all
 242                INFINITE,            // no timeout
 243                QS_ALLINPUT |        // return as soon as there are any events
 244                QS_ALLPOSTMESSAGE
 245              );
 246 }
 247
 248 wxPortId wxGUIAppTraits::GetToolkitVersion(int *majVer, int *minVer) const
 249 {
 250     OSVERSIONINFO info;
 251     wxZeroMemory(info);
 252
 253     // on Windows, the toolkit version is the same of the OS version
 254     // as Windows integrates the OS kernel with the GUI toolkit.
 255     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 256     if ( ::GetVersionEx(&info) )
 257     {
 258         if ( majVer )
 259             *majVer = info.dwMajorVersion;
 260         if ( minVer )
 261             *minVer = info.dwMinorVersion;
 262     }
 263
 264 #if defined(__WXHANDHELD__) || defined(__WXWINCE__)
 265     return wxPORT_WINCE;
 266 #else
 267     return wxPORT_MSW;
 268 #endif
 269 }
 270
 271 #if wxUSE_TIMER
 272
 273 wxTimerImpl *wxGUIAppTraits::CreateTimerImpl(wxTimer *timer)
 274 {
 275     return new wxMSWTimerImpl(timer);
 276 }
 277
 278 #endif // wxUSE_TIMER
 279
 280 wxEventLoopBase* wxGUIAppTraits::CreateEventLoop()
 281 {
 282     return new wxEventLoop;
 283 }
 284
 285 // ---------------------------------------------------------------------------
 286 // Stuff for using console from the GUI applications
 287 // ---------------------------------------------------------------------------
 288
 289 #ifndef __WXWINCE__
 290
 291 #include <wx/dynlib.h>
 292
 293 namespace
 294 {
 295
 296 /*
 297     Helper class to manipulate console from a GUI app.
 298
 299     Notice that console output is available in the GUI app only if:
 300     - AttachConsole() returns TRUE (which means it never works under pre-XP)
 301     - we have a valid STD_ERROR_HANDLE
 302     - command history hasn't been changed since our startup
 303
 304     To check if all these conditions are verified, you need to simple call
 305     IsOkToUse(). It will check the first two conditions above the first time it
 306     is called (and if this fails, the subsequent calls will return immediately)
 307     and also recheck the last one every time it is called.
 308  */
 309 class wxConsoleStderr
 310 {
 311 public:
 312     // default ctor does nothing, call Init() before using this class
 313     wxConsoleStderr()
 314     {
 315         m_hStderr = INVALID_HANDLE_VALUE;
 316         m_historyLen =
 317         m_dataLen =
 318         m_dataLine = 0;
 319
 320         m_ok = -1;
 321     }
 322
 323     ~wxConsoleStderr()
 324     {
 325         if ( m_hStderr != INVALID_HANDLE_VALUE )
 326         {
 327             if ( !::FreeConsole() )
 328             {
 329                 wxLogLastError(_T("FreeConsole"));
 330             }
 331         }
 332     }
 333
 334     // return true if we were successfully initialized and there had been no
 335     // console activity which would interfere with our output since then
 336     bool IsOkToUse() const
 337     {
 338         if ( m_ok == -1 )
 339         {
 340             wxConsoleStderr * const self = wx_const_cast(wxConsoleStderr *, this);
 341             self->m_ok = self->DoInit();
 342
 343             // no need to call IsHistoryUnchanged() as we just initialized
 344             // m_history anyhow
 345             return m_ok == 1;
 346         }
 347
 348         return m_ok && IsHistoryUnchanged();
 349     }
 350
 351
 352     // output the provided text on the console, return true if ok
 353     bool Write(const wxString& text);
 354
 355 private:
 356     // called by Init() once only to do the real initialization
 357     bool DoInit();
 358
 359     // retrieve the command line history into the provided buffer and return
 360     // its length
 361     int GetCommandHistory(wxWxCharBuffer& buf) const;
 362
 363     // check if the console history has changed
 364     bool IsHistoryUnchanged() const;
 365
 366     int m_ok;                   // initially -1, set to true or false by Init()
 367
 368     wxDynamicLibrary m_dllKernel32;
 369
 370     HANDLE m_hStderr;           // console handle, if it's valid we must call
 371                                 // FreeConsole() (even if m_ok != 1)
 372
 373     wxWxCharBuffer m_history;   // command history on startup
 374     int m_historyLen;           // length command history buffer
 375
 376     wxCharBuffer m_data;        // data between empty line and cursor position
 377     int m_dataLen;              // length data buffer
 378     int m_dataLine;             // line offset
 379
 380     typedef DWORD (WINAPI *GetConsoleCommandHistory_t)(LPTSTR sCommands,
 381                                                        DWORD nBufferLength,
 382                                                        LPCTSTR sExeName);
 383     typedef DWORD (WINAPI *GetConsoleCommandHistoryLength_t)(LPCTSTR sExeName);
 384
 385     GetConsoleCommandHistory_t m_pfnGetConsoleCommandHistory;
 386     GetConsoleCommandHistoryLength_t m_pfnGetConsoleCommandHistoryLength;
 387
 388     DECLARE_NO_COPY_CLASS(wxConsoleStderr)
 389 };
 390
 391 bool wxConsoleStderr::DoInit()
 392 {
 393     HANDLE hStderr = ::GetStdHandle(STD_ERROR_HANDLE);
 394
 395     if ( hStderr == INVALID_HANDLE_VALUE || !hStderr )
 396         return false;
 397
 398     if ( !m_dllKernel32.Load(_T("kernel32.dll")) )
 399         return false;
 400
 401     typedef BOOL (WINAPI *AttachConsole_t)(DWORD dwProcessId);
 402     AttachConsole_t wxDL_INIT_FUNC(pfn, AttachConsole, m_dllKernel32);
 403
 404     if ( !pfnAttachConsole || !pfnAttachConsole(ATTACH_PARENT_PROCESS) )
 405         return false;
 406
 407     // console attached, set m_hStderr now to ensure that we free it in the
 408     // dtor
 409     m_hStderr = hStderr;
 410
 411     wxDL_INIT_FUNC_AW(m_pfn, GetConsoleCommandHistory, m_dllKernel32);
 412     if ( !m_pfnGetConsoleCommandHistory )
 413         return false;
 414
 415     wxDL_INIT_FUNC_AW(m_pfn, GetConsoleCommandHistoryLength, m_dllKernel32);
 416     if ( !m_pfnGetConsoleCommandHistoryLength )
 417         return false;
 418
 419     // remember the current command history to be able to compare with it later
 420     // in IsHistoryUnchanged()
 421     m_historyLen = GetCommandHistory(m_history);
 422     if ( !m_history )
 423         return false;
 424
 425
 426     // now find the first blank line above the current position
 427     CONSOLE_SCREEN_BUFFER_INFO csbi;
 428
 429     if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )
 430     {
 431         wxLogLastError(_T("GetConsoleScreenBufferInfo"));
 432         return false;
 433     }
 434
 435     COORD pos;
 436     pos.X = 0;
 437     pos.Y = csbi.dwCursorPosition.Y + 1;
 438
 439     // we decide that a line is empty if first 4 characters are spaces
 440     DWORD ret;
 441     char buf[4];
 442     do
 443     {
 444         pos.Y--;
 445         if ( !::ReadConsoleOutputCharacterA(m_hStderr, buf, WXSIZEOF(buf),
 446                                             pos, &ret) )
 447         {
 448             wxLogLastError(_T("ReadConsoleOutputCharacterA"));
 449             return false;
 450         }
 451     } while ( wxStrncmp("    ", buf, WXSIZEOF(buf)) != 0 );
 452
 453     // calculate line offset and length of data
 454     m_dataLine = csbi.dwCursorPosition.Y - pos.Y;
 455     m_dataLen = m_dataLine*csbi.dwMaximumWindowSize.X + csbi.dwCursorPosition.X;
 456
 457     if ( m_dataLen > 0 )
 458     {
 459         m_data.extend(m_dataLen);
 460         if ( !::ReadConsoleOutputCharacterA(m_hStderr, m_data.data(), m_dataLen,
 461                                             pos, &ret) )
 462         {
 463             wxLogLastError(_T("ReadConsoleOutputCharacterA"));
 464             return false;
 465         }
 466     }
 467
 468     return true;
 469 }
 470
 471 int wxConsoleStderr::GetCommandHistory(wxWxCharBuffer& buf) const
 472 {
 473     // these functions are internal and may only be called by cmd.exe
 474     static const wxChar *CMD_EXE = _T("cmd.exe");
 475
 476     const int len = m_pfnGetConsoleCommandHistoryLength(CMD_EXE);
 477     if ( len )
 478     {
 479         buf.extend(len);
 480         const int len2 = m_pfnGetConsoleCommandHistory(buf.data(), len, CMD_EXE);
 481         wxASSERT_MSG( len2 == len, _T("failed getting history?") );
 482     }
 483
 484     return len;
 485 }
 486
 487 bool wxConsoleStderr::IsHistoryUnchanged() const
 488 {
 489     wxASSERT_MSG( m_ok == 1, _T("shouldn't be called if not initialized") );
 490
 491     // get (possibly changed) command history
 492     wxWxCharBuffer history;
 493     const int historyLen = GetCommandHistory(history);
 494
 495     // and compare it with the original one
 496     return historyLen == m_historyLen && history &&
 497                 memcmp(m_history, history, historyLen) == 0;
 498 }
 499
 500 bool wxConsoleStderr::Write(const wxString& text)
 501 {
 502     wxASSERT_MSG( m_hStderr != INVALID_HANDLE_VALUE,
 503                     _T("should only be called if Init() returned true") );
 504
 505     // get current position
 506     CONSOLE_SCREEN_BUFFER_INFO csbi;
 507     if ( !::GetConsoleScreenBufferInfo(m_hStderr, &csbi) )
 508     {
 509         wxLogLastError(_T("GetConsoleScreenBufferInfo"));
 510         return false;
 511     }
 512
 513     // and calculate new position (where is empty line)
 514     csbi.dwCursorPosition.X = 0;
 515     csbi.dwCursorPosition.Y -= m_dataLine;
 516
 517     if ( !::SetConsoleCursorPosition(m_hStderr, csbi.dwCursorPosition) )
 518     {
 519         wxLogLastError(_T("SetConsoleCursorPosition"));
 520         return false;
 521     }
 522
 523     DWORD ret;
 524     if ( !::FillConsoleOutputCharacter(m_hStderr, _T(' '), m_dataLen,
 525                                        csbi.dwCursorPosition, &ret) )
 526     {
 527         wxLogLastError(_T("FillConsoleOutputCharacter"));
 528         return false;
 529     }
 530
 531     if ( !::WriteConsole(m_hStderr, text.wx_str(), text.length(), &ret, NULL) )
 532     {
 533         wxLogLastError(_T("WriteConsole"));
 534         return false;
 535     }
 536
 537     WriteConsoleA(m_hStderr, m_data, m_dataLen, &ret, 0);
 538
 539     return true;
 540 }
 541
 542 wxConsoleStderr s_consoleStderr;
 543
 544 } // anonymous namespace
 545
 546 bool wxGUIAppTraits::CanUseStderr()
 547 {
 548     return s_consoleStderr.IsOkToUse();
 549 }
 550
 551 bool wxGUIAppTraits::WriteToStderr(const wxString& text)
 552 {
 553     return s_consoleStderr.IsOkToUse() && s_consoleStderr.Write(text);
 554 }
 555
 556 #endif // !__WXWINCE__
 557
 558 // ===========================================================================
 559 // wxApp implementation
 560 // ===========================================================================
 561
 562 int wxApp::m_nCmdShow = SW_SHOWNORMAL;
 563
 564 // ---------------------------------------------------------------------------
 565 // wxWin macros
 566 // ---------------------------------------------------------------------------
 567
 568 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 569
 570 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 571     EVT_IDLE(wxApp::OnIdle)
 572     EVT_END_SESSION(wxApp::OnEndSession)
 573     EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
 574 END_EVENT_TABLE()
 575
 576 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
 577 // fails
 578 class wxCallBaseCleanup
 579 {
 580 public:
 581     wxCallBaseCleanup(wxApp *app) : m_app(app) { }
 582     ~wxCallBaseCleanup() { if ( m_app ) m_app->wxAppBase::CleanUp(); }
 583
 584     void Dismiss() { m_app = NULL; }
 585
 586 private:
 587     wxApp *m_app;
 588 };
 589
 590 //// Initialize
 591 bool wxApp::Initialize(int& argc, wxChar **argv)
 592 {
 593     if ( !wxAppBase::Initialize(argc, argv) )
 594         return false;
 595
 596     // ensure that base cleanup is done if we return too early
 597     wxCallBaseCleanup callBaseCleanup(this);
 598
 599 #ifdef __WXWINCE__
 600     wxString tmp = GetAppName();
 601     tmp += wxT("ClassName");
 602     wxCanvasClassName = wxStrdup( tmp.wc_str() );
 603     tmp += wxT("NR");
 604     wxCanvasClassNameNR = wxStrdup( tmp.wc_str() );
 605     HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
 606     if (hWnd)
 607     {
 608         SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
 609         return false;
 610     }
 611 #endif
 612
 613 #if !defined(__WXMICROWIN__)
 614     InitCommonControls();
 615 #endif // !defined(__WXMICROWIN__)
 616
 617 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
 618     SHInitExtraControls();
 619 #endif
 620
 621 #ifndef __WXWINCE__
 622     // Don't show a message box if a function such as SHGetFileInfo
 623     // fails to find a device.
 624     SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
 625 #endif
 626
 627     wxOleInitialize();
 628
 629     RegisterWindowClasses();
 630
 631 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 632     wxSetKeyboardHook(true);
 633 #endif
 634
 635     callBaseCleanup.Dismiss();
 636
 637     return true;
 638 }
 639
 640 // ---------------------------------------------------------------------------
 641 // RegisterWindowClasses
 642 // ---------------------------------------------------------------------------
 643
 644 // This function registers the given class name and stores a pointer to a
 645 // heap-allocated copy of it at the specified location, it must be deleted
 646 // later.
 647 static void RegisterAndStoreClassName(const wxString& uniqueClassName,
 648                                       const wxChar **className,
 649                                       WNDCLASS *lpWndClass)
 650 {
 651     const size_t length = uniqueClassName.length() + 1; // for trailing NUL
 652     wxChar *newChars = new wxChar[length];
 653     wxStrncpy(newChars, uniqueClassName, length);
 654     *className = newChars;
 655     lpWndClass->lpszClassName = *className;
 656
 657     if ( !::RegisterClass(lpWndClass) )
 658     {
 659         wxLogLastError(wxString::Format(wxT("RegisterClass(%s)"), newChars));
 660     }
 661 }
 662
 663 // This function registers the class defined by the provided WNDCLASS struct
 664 // contents using a unique name constructed from the specified base name and
 665 // and a suffix unique to this library instance. It also stores the generated
 666 // unique names for normal and "no redraw" versions of the class in the
 667 // provided variables, caller must delete their contents later.
 668 static void RegisterClassWithUniqueNames(const wxString& baseName,
 669                                          const wxChar **className,
 670                                          const wxChar **classNameNR,
 671                                          WNDCLASS *lpWndClass)
 672 {
 673     // for each class we register one with CS_(V|H)REDRAW style and one
 674     // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
 675     static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
 676     static const long styleNoRedraw = CS_DBLCLKS;
 677
 678     const wxString uniqueSuffix(wxString::Format(wxT("@%p"), className));
 679
 680     wxString uniqueClassName(baseName + uniqueSuffix);
 681     lpWndClass->style = styleNormal;
 682     RegisterAndStoreClassName(uniqueClassName, className, lpWndClass);
 683
 684     // NB: remember that code elsewhere supposes that no redraw class names
 685     //     use the same names as normal classes with "NR" suffix so we must put
 686     //     "NR" at the end instead of using more natural baseName+"NR"+suffix
 687     wxString uniqueClassNameNR(uniqueClassName + wxT("NR"));
 688     lpWndClass->style = styleNoRedraw;
 689     RegisterAndStoreClassName(uniqueClassNameNR, classNameNR, lpWndClass);
 690 }
 691
 692 // TODO we should only register classes really used by the app. For this it
 693 //      would be enough to just delay the class registration until an attempt
 694 //      to create a window of this class is made.
 695 bool wxApp::RegisterWindowClasses()
 696 {
 697     WNDCLASS wndclass;
 698     wxZeroMemory(wndclass);
 699
 700     // the fields which are common to all classes
 701     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
 702     wndclass.hInstance     = wxhInstance;
 703     wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
 704
 705     // register the class for all normal windows and "no redraw" frames
 706     wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
 707     RegisterClassWithUniqueNames(wxT("wxWindowClass"),
 708                                  &wxCanvasClassName,
 709                                  &wxCanvasClassNameNR,
 710                                  &wndclass);
 711
 712     // Register the MDI frame window class and "no redraw" MDI frame
 713     wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
 714     RegisterClassWithUniqueNames(wxT("wxMDIFrameClass"),
 715                                  &wxMDIFrameClassName,
 716                                  &wxMDIFrameClassNameNoRedraw,
 717                                  &wndclass);
 718
 719     // Register the MDI child frame window class and "no redraw" MDI child frame
 720     wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
 721     RegisterClassWithUniqueNames(wxT("wxMDIChildFrameClass"),
 722                                  &wxMDIChildFrameClassName,
 723                                  &wxMDIChildFrameClassNameNoRedraw,
 724                                  &wndclass);
 725
 726     return true;
 727 }
 728
 729 // ---------------------------------------------------------------------------
 730 // UnregisterWindowClasses
 731 // ---------------------------------------------------------------------------
 732
 733 // This function unregisters the class with the given name and frees memory
 734 // allocated for it by RegisterAndStoreClassName().
 735 static bool UnregisterAndFreeClassName(const wxChar **ppClassName)
 736 {
 737     bool retval = true;
 738
 739     if ( !::UnregisterClass(*ppClassName, wxhInstance) )
 740     {
 741         wxLogLastError(
 742                 wxString::Format(wxT("UnregisterClass(%s)"), *ppClassName));
 743
 744         retval = false;
 745     }
 746
 747     delete [] (wxChar*) *ppClassName;
 748     *ppClassName = NULL;
 749
 750     return retval;
 751 }
 752
 753 bool wxApp::UnregisterWindowClasses()
 754 {
 755     bool retval = true;
 756
 757 #ifndef __WXMICROWIN__
 758     if ( !UnregisterAndFreeClassName(&wxMDIFrameClassName) )
 759         retval = false;
 760
 761     if ( !UnregisterAndFreeClassName(&wxMDIFrameClassNameNoRedraw) )
 762         retval = false;
 763
 764     if ( !UnregisterAndFreeClassName(&wxMDIChildFrameClassName) )
 765         retval = false;
 766
 767     if ( !UnregisterAndFreeClassName(&wxMDIChildFrameClassNameNoRedraw) )
 768         retval = false;
 769
 770     if ( !UnregisterAndFreeClassName(&wxCanvasClassName) )
 771         retval = false;
 772
 773     if ( !UnregisterAndFreeClassName(&wxCanvasClassNameNR) )
 774         retval = false;
 775 #endif // __WXMICROWIN__
 776
 777     return retval;
 778 }
 779
 780 void wxApp::CleanUp()
 781 {
 782     // all objects pending for deletion must be deleted first, otherwise
 783     // UnregisterWindowClasses() call wouldn't succeed (because windows
 784     // using the classes being unregistered still exist), so call the base
 785     // class method first and only then do our clean up
 786     wxAppBase::CleanUp();
 787
 788 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 789     wxSetKeyboardHook(false);
 790 #endif
 791
 792     wxOleUninitialize();
 793
 794     // for an EXE the classes are unregistered when it terminates but DLL may
 795     // be loaded several times (load/unload/load) into the same process in
 796     // which case the registration will fail after the first time if we don't
 797     // unregister the classes now
 798     UnregisterWindowClasses();
 799
 800 #ifdef __WXWINCE__
 801     free( wxCanvasClassName );
 802     free( wxCanvasClassNameNR );
 803 #endif
 804 }
 805
 806 // ----------------------------------------------------------------------------
 807 // wxApp ctor/dtor
 808 // ----------------------------------------------------------------------------
 809
 810 wxApp::wxApp()
 811 {
 812     m_printMode = wxPRINT_WINDOWS;
 813 }
 814
 815 wxApp::~wxApp()
 816 {
 817 }
 818
 819 // ----------------------------------------------------------------------------
 820 // wxApp idle handling
 821 // ----------------------------------------------------------------------------
 822
 823 void wxApp::OnIdle(wxIdleEvent& WXUNUSED(event))
 824 {
 825 #if wxUSE_DC_CACHEING
 826     // automated DC cache management: clear the cached DCs and bitmap
 827     // if it's likely that the app has finished with them, that is, we
 828     // get an idle event and we're not dragging anything.
 829     if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
 830         wxMSWDCImpl::ClearCache();
 831 #endif // wxUSE_DC_CACHEING
 832 }
 833
 834 void wxApp::WakeUpIdle()
 835 {
 836     // Send the top window a dummy message so idle handler processing will
 837     // start up again.  Doing it this way ensures that the idle handler
 838     // wakes up in the right thread (see also wxWakeUpMainThread() which does
 839     // the same for the main app thread only)
 840     wxWindow * const topWindow = wxTheApp->GetTopWindow();
 841     if ( topWindow )
 842     {
 843         HWND hwndTop = GetHwndOf(topWindow);
 844
 845         // Do not post WM_NULL if there's already a pending WM_NULL to avoid
 846         // overflowing the message queue.
 847         //
 848         // Notice that due to a limitation of PeekMessage() API (which handles
 849         // 0,0 range specially), we have to check the range from 0-1 instead.
 850         // This still makes it possible to overflow the queue with WM_NULLs by
 851         // interspersing the calles to WakeUpIdle() with windows creation but
 852         // it should be rather hard to do it accidentally.
 853         MSG msg;
 854         if ( !::PeekMessage(&msg, hwndTop, 0, 1, PM_NOREMOVE) ||
 855               ::PeekMessage(&msg, hwndTop, 1, 1, PM_NOREMOVE) )
 856         {
 857             if ( !::PostMessage(hwndTop, WM_NULL, 0, 0) )
 858             {
 859                 // should never happen
 860                 wxLogLastError(wxT("PostMessage(WM_NULL)"));
 861             }
 862         }
 863     }
 864 }
 865
 866 // ----------------------------------------------------------------------------
 867 // other wxApp event hanlders
 868 // ----------------------------------------------------------------------------
 869
 870 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
 871 {
 872     // Windows will terminate the process soon after we return from
 873     // WM_ENDSESSION handler or when we delete our last window, so make sure we
 874     // at least execute our cleanup code before
 875
 876     // prevent the window from being destroyed when the corresponding wxTLW is
 877     // destroyed: this will result in a leak of a HWND, of course, but who
 878     // cares when the process is being killed anyhow
 879     if ( !wxTopLevelWindows.empty() )
 880         wxTopLevelWindows[0]->SetHWND(0);
 881
 882     const int rc = OnExit();
 883
 884     wxEntryCleanup();
 885
 886     // calling exit() instead of ExitProcess() or not doing anything at all and
 887     // being killed by Windows has the advantage of executing the dtors of
 888     // global objects
 889     exit(rc);
 890 }
 891
 892 // Default behaviour: close the application with prompts. The
 893 // user can veto the close, and therefore the end session.
 894 void wxApp::OnQueryEndSession(wxCloseEvent& event)
 895 {
 896     if (GetTopWindow())
 897     {
 898         if (!GetTopWindow()->Close(!event.CanVeto()))
 899             event.Veto(true);
 900     }
 901 }
 902
 903 // ----------------------------------------------------------------------------
 904 // system DLL versions
 905 // ----------------------------------------------------------------------------
 906
 907 // these functions have trivial inline implementations for CE
 908 #ifndef __WXWINCE__
 909
 910 #if wxUSE_DYNLIB_CLASS
 911
 912 namespace
 913 {
 914
 915 // helper function: retrieve the DLL version by using DllGetVersion(), returns
 916 // 0 if the DLL doesn't export such function
 917 int CallDllGetVersion(wxDynamicLibrary& dll)
 918 {
 919     // now check if the function is available during run-time
 920     wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dll );
 921     if ( !pfnDllGetVersion )
 922         return 0;
 923
 924     DLLVERSIONINFO dvi;
 925     dvi.cbSize = sizeof(dvi);
 926
 927     HRESULT hr = (*pfnDllGetVersion)(&dvi);
 928     if ( FAILED(hr) )
 929     {
 930         wxLogApiError(_T("DllGetVersion"), hr);
 931
 932         return 0;
 933     }
 934
 935     return 100*dvi.dwMajorVersion + dvi.dwMinorVersion;
 936 }
 937
 938 } // anonymous namespace
 939
 940 /* static */
 941 int wxApp::GetComCtl32Version()
 942 {
 943     // cache the result
 944     //
 945     // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
 946     //     but as its value should be the same both times it doesn't matter
 947     static int s_verComCtl32 = -1;
 948
 949     if ( s_verComCtl32 == -1 )
 950     {
 951         // we're prepared to handle the errors
 952         wxLogNull noLog;
 953
 954         // the DLL should really be available
 955         wxDynamicLibrary dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM);
 956         if ( !dllComCtl32.IsLoaded() )
 957         {
 958             s_verComCtl32 = 0;
 959             return 0;
 960         }
 961
 962         // try DllGetVersion() for recent DLLs
 963         s_verComCtl32 = CallDllGetVersion(dllComCtl32);
 964
 965         // if DllGetVersion() is unavailable either during compile or
 966         // run-time, try to guess the version otherwise
 967         if ( !s_verComCtl32 )
 968         {
 969             // InitCommonControlsEx is unique to 4.70 and later
 970             void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
 971             if ( !pfn )
 972             {
 973                 // not found, must be 4.00
 974                 s_verComCtl32 = 400;
 975             }
 976             else // 4.70+
 977             {
 978                 // many symbols appeared in comctl32 4.71, could use any of
 979                 // them except may be DllInstall()
 980                 pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
 981                 if ( !pfn )
 982                 {
 983                     // not found, must be 4.70
 984                     s_verComCtl32 = 470;
 985                 }
 986                 else
 987                 {
 988                     // found, must be 4.71 or later
 989                     s_verComCtl32 = 471;
 990                 }
 991             }
 992         }
 993     }
 994
 995     return s_verComCtl32;
 996 }
 997
 998 /* static */
 999 int wxApp::GetShell32Version()
1000 {
1001     static int s_verShell32 = -1;
1002     if ( s_verShell32 == -1 )
1003     {
1004         // we're prepared to handle the errors
1005         wxLogNull noLog;
1006
1007         wxDynamicLibrary dllShell32(_T("shell32.dll"), wxDL_VERBATIM);
1008         if ( dllShell32.IsLoaded() )
1009         {
1010             s_verShell32 = CallDllGetVersion(dllShell32);
1011
1012             if ( !s_verShell32 )
1013             {
1014                 // there doesn't seem to be any way to distinguish between 4.00
1015                 // and 4.70 (starting from 4.71 we have DllGetVersion()) so
1016                 // just assume it is 4.0
1017                 s_verShell32 = 400;
1018             }
1019         }
1020         else // failed load the DLL?
1021         {
1022             s_verShell32 = 0;
1023         }
1024     }
1025
1026     return s_verShell32;
1027 }
1028
1029 #else // !wxUSE_DYNLIB_CLASS
1030
1031 /* static */
1032 int wxApp::GetComCtl32Version()
1033 {
1034     return 0;
1035 }
1036
1037 /* static */
1038 int wxApp::GetShell32Version()
1039 {
1040     return 0;
1041 }
1042
1043 #endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS
1044
1045 #endif // !__WXWINCE__
1046
1047 // ----------------------------------------------------------------------------
1048 // Yield to incoming messages
1049 // ----------------------------------------------------------------------------
1050
1051 bool wxApp::Yield(bool onlyIfNeeded)
1052 {
1053     // MT-FIXME
1054     static bool s_inYield = false;
1055
1056 #if wxUSE_LOG
1057     // disable log flushing from here because a call to wxYield() shouldn't
1058     // normally result in message boxes popping up &c
1059     wxLog::Suspend();
1060 #endif // wxUSE_LOG
1061
1062     if ( s_inYield )
1063     {
1064         if ( !onlyIfNeeded )
1065         {
1066             wxFAIL_MSG( wxT("wxYield called recursively" ) );
1067         }
1068
1069         return false;
1070     }
1071
1072     s_inYield = true;
1073
1074     // we don't want to process WM_QUIT from here - it should be processed in
1075     // the main event loop in order to stop it
1076     wxEventLoopGuarantor dummyLoopIfNeeded;
1077     MSG msg;
1078     while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
1079             msg.message != WM_QUIT )
1080     {
1081 #if wxUSE_THREADS
1082         wxMutexGuiLeaveOrEnter();
1083 #endif // wxUSE_THREADS
1084
1085         if ( !wxTheApp->Dispatch() )
1086             break;
1087     }
1088
1089     // if there are pending events, we must process them.
1090     ProcessPendingEvents();
1091
1092 #if wxUSE_LOG
1093     // let the logs be flashed again
1094     wxLog::Resume();
1095 #endif // wxUSE_LOG
1096
1097     s_inYield = false;
1098
1099     return true;
1100 }
1101
1102 #if wxUSE_EXCEPTIONS
1103
1104 // ----------------------------------------------------------------------------
1105 // exception handling
1106 // ----------------------------------------------------------------------------
1107
1108 bool wxApp::OnExceptionInMainLoop()
1109 {
1110     // ask the user about what to do: use the Win32 API function here as it
1111     // could be dangerous to use any wxWidgets code in this state
1112     switch (
1113             ::MessageBox
1114               (
1115                 NULL,
1116                 _T("An unhandled exception occurred. Press \"Abort\" to \
1117 terminate the program,\r\n\
1118 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
1119                 _T("Unhandled exception"),
1120                 MB_ABORTRETRYIGNORE |
1121                 MB_ICONERROR|
1122                 MB_TASKMODAL
1123               )
1124            )
1125     {
1126         case IDABORT:
1127             throw;
1128
1129         default:
1130             wxFAIL_MSG( _T("unexpected MessageBox() return code") );
1131             // fall through
1132
1133         case IDRETRY:
1134             return false;
1135
1136         case IDIGNORE:
1137             return true;
1138     }
1139 }
1140
1141 #endif // wxUSE_EXCEPTIONS