src/msw/toplevel.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/toplevel.cpp
   3 // Purpose:     implements wxTopLevelWindow for MSW
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     24.09.01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
   9 // License:     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/toplevel.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/app.h"
  31     #include "wx/dialog.h"
  32     #include "wx/string.h"
  33     #include "wx/log.h"
  34     #include "wx/intl.h"
  35     #include "wx/frame.h"
  36     #include "wx/containr.h"        // wxSetFocusToChild()
  37 #endif //WX_PRECOMP
  38
  39 #include "wx/module.h"
  40 #include "wx/dynlib.h"
  41
  42 #include "wx/msw/private.h"
  43 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__)
  44   #include <ole2.h>
  45   #include <shellapi.h>
  46   // Standard SDK doesn't have aygshell.dll: see include/wx/msw/wince/libraries.h
  47   #if _WIN32_WCE < 400 || !defined(__WINCE_STANDARDSDK__)
  48     #include <aygshell.h>
  49   #endif
  50 #include "wx/msw/wince/missing.h"
  51 #endif
  52
  53 #include "wx/msw/missing.h"
  54 #include "wx/msw/winundef.h"
  55
  56 #include "wx/display.h"
  57
  58 #ifndef ICON_BIG
  59     #define ICON_BIG 1
  60 #endif
  61
  62 #ifndef ICON_SMALL
  63     #define ICON_SMALL 0
  64 #endif
  65
  66 // ----------------------------------------------------------------------------
  67 // stubs for missing functions under MicroWindows
  68 // ----------------------------------------------------------------------------
  69
  70 #ifdef __WXMICROWIN__
  71
  72 // static inline bool IsIconic(HWND WXUNUSED(hwnd)) { return false; }
  73 static inline bool IsZoomed(HWND WXUNUSED(hwnd)) { return false; }
  74
  75 #endif // __WXMICROWIN__
  76
  77 // NB: wxDlgProc must be defined here and not in dialog.cpp because the latter
  78 //     is not included by wxUniv build which does need wxDlgProc
  79 LONG APIENTRY _EXPORT
  80 wxDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
  81
  82 // ----------------------------------------------------------------------------
  83 // globals
  84 // ----------------------------------------------------------------------------
  85
  86 // the name of the default wxWidgets class
  87 #ifdef __WXWINCE__
  88 extern       wxChar *wxCanvasClassName;
  89 #else
  90 extern const wxChar *wxCanvasClassName;
  91 #endif
  92
  93 // ----------------------------------------------------------------------------
  94 // wxTLWHiddenParentModule: used to manage the hidden parent window (we need a
  95 // module to ensure that the window is always deleted)
  96 // ----------------------------------------------------------------------------
  97
  98 class wxTLWHiddenParentModule : public wxModule
  99 {
 100 public:
 101     // module init/finalize
 102     virtual bool OnInit();
 103     virtual void OnExit();
 104
 105     // get the hidden window (creates on demand)
 106     static HWND GetHWND();
 107
 108 private:
 109     // the HWND of the hidden parent
 110     static HWND ms_hwnd;
 111
 112     // the class used to create it
 113     static const wxChar *ms_className;
 114
 115     DECLARE_DYNAMIC_CLASS(wxTLWHiddenParentModule)
 116 };
 117
 118 IMPLEMENT_DYNAMIC_CLASS(wxTLWHiddenParentModule, wxModule)
 119
 120 // ============================================================================
 121 // wxTopLevelWindowMSW implementation
 122 // ============================================================================
 123
 124 BEGIN_EVENT_TABLE(wxTopLevelWindowMSW, wxTopLevelWindowBase)
 125     EVT_ACTIVATE(wxTopLevelWindowMSW::OnActivate)
 126 END_EVENT_TABLE()
 127
 128 // ----------------------------------------------------------------------------
 129 // wxTopLevelWindowMSW creation
 130 // ----------------------------------------------------------------------------
 131
 132 void wxTopLevelWindowMSW::Init()
 133 {
 134     m_iconized =
 135     m_maximizeOnShow = false;
 136
 137     // Data to save/restore when calling ShowFullScreen
 138     m_fsStyle = 0;
 139     m_fsOldWindowStyle = 0;
 140     m_fsIsMaximized = false;
 141     m_fsIsShowing = false;
 142
 143     m_winLastFocused = (wxWindow *)NULL;
 144
 145 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
 146     m_MenuBarHWND = 0;
 147 #endif
 148
 149 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
 150     SHACTIVATEINFO* info = new SHACTIVATEINFO;
 151     wxZeroMemory(*info);
 152     info->cbSize = sizeof(SHACTIVATEINFO);
 153
 154     m_activateInfo = (void*) info;
 155 #endif
 156 }
 157
 158 WXDWORD wxTopLevelWindowMSW::MSWGetStyle(long style, WXDWORD *exflags) const
 159 {
 160     // let the base class deal with the common styles but fix the ones which
 161     // don't make sense for us (we also deal with the borders ourselves)
 162     WXDWORD msflags = wxWindow::MSWGetStyle
 163                       (
 164                         (style & ~wxBORDER_MASK) | wxBORDER_NONE, exflags
 165                       ) & ~WS_CHILD & ~WS_VISIBLE;
 166
 167     // For some reason, WS_VISIBLE needs to be defined on creation for
 168     // SmartPhone 2003. The title can fail to be displayed otherwise.
 169 #if defined(__SMARTPHONE__) || (defined(__WXWINCE__) && _WIN32_WCE < 400)
 170     msflags |= WS_VISIBLE;
 171     ((wxTopLevelWindowMSW*)this)->wxWindowBase::Show(true);
 172 #endif
 173
 174     // first select the kind of window being created
 175     //
 176     // note that if we don't set WS_POPUP, Windows assumes WS_OVERLAPPED and
 177     // creates a window with both caption and border, hence we need to use
 178     // WS_POPUP in a few cases just to avoid having caption/border which we
 179     // don't want
 180
 181     // border and caption styles
 182     if ( ( style & wxRESIZE_BORDER ) && !IsAlwaysMaximized())
 183         msflags |= WS_THICKFRAME;
 184     else if ( exflags && ((style & wxBORDER_DOUBLE) || (style & wxBORDER_RAISED)) )
 185         *exflags |= WS_EX_DLGMODALFRAME;
 186     else if ( !(style & wxBORDER_NONE) )
 187         msflags |= WS_BORDER;
 188 #ifndef __POCKETPC__
 189     else
 190         msflags |= WS_POPUP;
 191 #endif
 192
 193     // normally we consider that all windows without a caption must be popups,
 194     // but CE is an exception: there windows normally do not have the caption
 195     // but shouldn't be made popups as popups can't have menus and don't look
 196     // like normal windows anyhow
 197
 198     // TODO: Smartphone appears to like wxCAPTION, but we should check that
 199     // we need it.
 200 #if defined(__SMARTPHONE__) || !defined(__WXWINCE__)
 201     if ( style & wxCAPTION )
 202         msflags |= WS_CAPTION;
 203 #ifndef __WXWINCE__
 204     else
 205         msflags |= WS_POPUP;
 206 #endif // !__WXWINCE__
 207 #endif
 208
 209     // next translate the individual flags
 210
 211     // WS_EX_CONTEXTHELP is incompatible with WS_MINIMIZEBOX and WS_MAXIMIZEBOX
 212     // and is ignored if we specify both of them, but chances are that if we
 213     // use wxFRAME_EX_CONTEXTHELP, we really do want to have the context help
 214     // button while wxMINIMIZE/wxMAXIMIZE are included by default, so the help
 215     // takes precedence
 216     if ( !(GetExtraStyle() & wxFRAME_EX_CONTEXTHELP) )
 217     {
 218         if ( style & wxMINIMIZE_BOX )
 219             msflags |= WS_MINIMIZEBOX;
 220         if ( style & wxMAXIMIZE_BOX )
 221             msflags |= WS_MAXIMIZEBOX;
 222     }
 223
 224 #ifndef __WXWINCE__
 225     if ( style & wxSYSTEM_MENU )
 226         msflags |= WS_SYSMENU;
 227 #endif
 228
 229     // NB: under CE these 2 styles are not supported currently, we should
 230     //     call Minimize()/Maximize() "manually" if we want to support them
 231     if ( style & wxMINIMIZE )
 232         msflags |= WS_MINIMIZE;
 233
 234     if ( style & wxMAXIMIZE )
 235         msflags |= WS_MAXIMIZE;
 236
 237     // Keep this here because it saves recoding this function in wxTinyFrame
 238     if ( style & (wxTINY_CAPTION_VERT | wxTINY_CAPTION_HORIZ) )
 239         msflags |= WS_CAPTION;
 240
 241     if ( exflags )
 242     {
 243         // there is no taskbar under CE, so omit all this
 244 #if !defined(__WXWINCE__)
 245         if ( !(GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) )
 246         {
 247             if ( style & wxFRAME_TOOL_WINDOW )
 248             {
 249                 // create the palette-like window
 250                 *exflags |= WS_EX_TOOLWINDOW;
 251
 252                 // tool windows shouldn't appear on the taskbar (as documented)
 253                 style |= wxFRAME_NO_TASKBAR;
 254             }
 255
 256             // We have to solve 2 different problems here:
 257             //
 258             // 1. frames with wxFRAME_NO_TASKBAR flag shouldn't appear in the
 259             //    taskbar even if they don't have a parent
 260             //
 261             // 2. frames without this style should appear in the taskbar even
 262             //    if they're owned (Windows only puts non owned windows into
 263             //    the taskbar normally)
 264             //
 265             // The second one is solved here by using WS_EX_APPWINDOW flag, the
 266             // first one is dealt with in our MSWGetParent() method
 267             // implementation
 268             if ( !(style & wxFRAME_NO_TASKBAR) && GetParent() )
 269             {
 270                 // need to force the frame to appear in the taskbar
 271                 *exflags |= WS_EX_APPWINDOW;
 272             }
 273             //else: nothing to do [here]
 274         }
 275
 276         if ( GetExtraStyle() & wxFRAME_EX_CONTEXTHELP )
 277             *exflags |= WS_EX_CONTEXTHELP;
 278 #endif // !__WXWINCE__
 279
 280         if ( style & wxSTAY_ON_TOP )
 281             *exflags |= WS_EX_TOPMOST;
 282     }
 283
 284     return msflags;
 285 }
 286
 287 WXHWND wxTopLevelWindowMSW::MSWGetParent() const
 288 {
 289     // for the frames without wxFRAME_FLOAT_ON_PARENT style we should use NULL
 290     // parent HWND or it would be always on top of its parent which is not what
 291     // we usually want (in fact, we only want it for frames with the
 292     // wxFRAME_FLOAT_ON_PARENT flag)
 293     HWND hwndParent = NULL;
 294     if ( HasFlag(wxFRAME_FLOAT_ON_PARENT) )
 295     {
 296         const wxWindow *parent = GetParent();
 297
 298         if ( !parent )
 299         {
 300             // this flag doesn't make sense then and will be ignored
 301             wxFAIL_MSG( _T("wxFRAME_FLOAT_ON_PARENT but no parent?") );
 302         }
 303         else
 304         {
 305             hwndParent = GetHwndOf(parent);
 306         }
 307     }
 308     //else: don't float on parent, must not be owned
 309
 310     // now deal with the 2nd taskbar-related problem (see comments above in
 311     // MSWGetStyle())
 312     if ( HasFlag(wxFRAME_NO_TASKBAR) && !hwndParent )
 313     {
 314         // use hidden parent
 315         hwndParent = wxTLWHiddenParentModule::GetHWND();
 316     }
 317
 318     return (WXHWND)hwndParent;
 319 }
 320
 321 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
 322 bool wxTopLevelWindowMSW::HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam)
 323 {
 324     SHACTIVATEINFO *info = (SHACTIVATEINFO*) m_activateInfo;
 325     if ( info )
 326     {
 327         SHHandleWMSettingChange(GetHwnd(), wParam, lParam, info);
 328     }
 329
 330     return wxWindowMSW::HandleSettingChange(wParam, lParam);
 331 }
 332 #endif
 333
 334 bool wxTopLevelWindowMSW::MSWProcessMessage(WXMSG* pMsg)
 335 {
 336     // MSW specific feature: if the dialog has only one notebook-like child
 337     // window (actually it could be any window that returns true from its
 338     // HasMultiplePages()), then [Shift-]Ctrl-Tab and Ctrl-PageUp/Down keys
 339     // should iterate over its pages even if the focus is outside of the
 340     // control because this is how the standard MSW properties dialogs behave
 341     if ( pMsg->message == WM_KEYDOWN && wxIsCtrlDown() &&
 342             (pMsg->wParam == VK_TAB ||
 343                 pMsg->wParam == VK_PRIOR ||
 344                     pMsg->wParam == VK_NEXT) )
 345     {
 346         // check if we have a unique notebook-like child
 347         wxWindow *bookctrl = NULL;
 348         for ( wxWindowList::const_iterator i = GetChildren().begin(),
 349                                          end = GetChildren().end();
 350               i != end;
 351               ++i )
 352         {
 353             wxWindow * const window = *i;
 354             if ( window->HasMultiplePages() )
 355             {
 356                 if ( bookctrl )
 357                 {
 358                     // this is the second book-like control already so don't do
 359                     // anything as we don't know which one should have its page
 360                     // changed
 361                     bookctrl = NULL;
 362                     break;
 363                 }
 364
 365                 bookctrl = window;
 366             }
 367         }
 368
 369         if ( bookctrl && bookctrl->wxWindowMSW::MSWProcessMessage(pMsg) )
 370             return true;
 371     }
 372
 373     return wxTopLevelWindowBase::MSWProcessMessage(pMsg);
 374 }
 375
 376 WXLRESULT wxTopLevelWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 377 {
 378     WXLRESULT rc = 0;
 379     bool processed = false;
 380
 381 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
 382     switch ( message )
 383     {
 384         case WM_ACTIVATE:
 385         {
 386             SHACTIVATEINFO* info = (SHACTIVATEINFO*) m_activateInfo;
 387             if (info)
 388             {
 389                 DWORD flags = 0;
 390                 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) flags = SHA_INPUTDIALOG;
 391                 SHHandleWMActivate(GetHwnd(), wParam, lParam, info, flags);
 392             }
 393
 394             // This implicitly sends a wxEVT_ACTIVATE_APP event
 395             if (wxTheApp)
 396                 wxTheApp->SetActive(wParam != 0, FindFocus());
 397
 398             break;
 399         }
 400         case WM_HIBERNATE:
 401         {
 402             if (wxTheApp)
 403             {
 404                 wxActivateEvent event(wxEVT_HIBERNATE, true, wxID_ANY);
 405                 event.SetEventObject(wxTheApp);
 406                 processed = wxTheApp->ProcessEvent(event);
 407             }
 408             break;
 409         }
 410     }
 411 #endif
 412
 413     if ( !processed )
 414         rc = wxTopLevelWindowBase::MSWWindowProc(message, wParam, lParam);
 415
 416     return rc;
 417 }
 418
 419 bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
 420                                        const wxString& title,
 421                                        const wxPoint& pos,
 422                                        const wxSize& size)
 423 {
 424 #ifdef __WXMICROWIN__
 425     // no dialogs support under MicroWin yet
 426     return CreateFrame(title, pos, size);
 427 #else // !__WXMICROWIN__
 428     wxWindow *parent = GetParent();
 429
 430     // for the dialogs without wxDIALOG_NO_PARENT style, use the top level
 431     // app window as parent - this avoids creating modal dialogs without
 432     // parent
 433     if ( !parent && !(GetWindowStyleFlag() & wxDIALOG_NO_PARENT) )
 434     {
 435         parent = wxTheApp->GetTopWindow();
 436
 437         if ( parent )
 438         {
 439             // don't use transient windows as parents, this is dangerous as it
 440             // can lead to a crash if the parent is destroyed before the child
 441             //
 442             // also don't use the window which is currently hidden as then the
 443             // dialog would be hidden as well
 444             if ( (parent->GetExtraStyle() & wxWS_EX_TRANSIENT) ||
 445                     !parent->IsShown() )
 446             {
 447                 parent = NULL;
 448             }
 449         }
 450     }
 451
 452     m_hWnd = (WXHWND)::CreateDialogIndirect
 453                        (
 454                         wxGetInstance(),
 455                         (DLGTEMPLATE*)dlgTemplate,
 456                         parent ? GetHwndOf(parent) : NULL,
 457                         (DLGPROC)wxDlgProc
 458                        );
 459
 460     if ( !m_hWnd )
 461     {
 462         wxFAIL_MSG(wxT("Failed to create dialog. Incorrect DLGTEMPLATE?"));
 463
 464         wxLogSysError(wxT("Can't create dialog using memory template"));
 465
 466         return false;
 467     }
 468
 469     WXDWORD exflags;
 470     (void)MSWGetCreateWindowFlags(&exflags);
 471
 472     if ( exflags )
 473     {
 474         ::SetWindowLong(GetHwnd(), GWL_EXSTYLE, exflags);
 475         ::SetWindowPos(GetHwnd(),
 476                        exflags & WS_EX_TOPMOST ? HWND_TOPMOST : 0,
 477                        0, 0, 0, 0,
 478                        SWP_NOSIZE |
 479                        SWP_NOMOVE |
 480                        (exflags & WS_EX_TOPMOST ? 0 : SWP_NOZORDER) |
 481                        SWP_NOACTIVATE);
 482     }
 483
 484 #if !defined(__WXWINCE__)
 485     // For some reason, the system menu is activated when we use the
 486     // WS_EX_CONTEXTHELP style, so let's set a reasonable icon
 487     if ( exflags & WS_EX_CONTEXTHELP )
 488     {
 489         wxFrame *winTop = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
 490         if ( winTop )
 491         {
 492             wxIcon icon = winTop->GetIcon();
 493             if ( icon.Ok() )
 494             {
 495                 ::SendMessage(GetHwnd(), WM_SETICON,
 496                               (WPARAM)TRUE,
 497                               (LPARAM)GetHiconOf(icon));
 498             }
 499         }
 500     }
 501 #endif
 502
 503     // move the dialog to its initial position without forcing repainting
 504     int x, y, w, h;
 505     (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
 506
 507     if ( x == (int)CW_USEDEFAULT )
 508     {
 509         // centre it on the screen - what else can we do?
 510         wxSize sizeDpy = wxGetDisplaySize();
 511
 512         x = (sizeDpy.x - w) / 2;
 513         y = (sizeDpy.y - h) / 2;
 514     }
 515
 516 #if !defined(__WXWINCE__) || defined(__WINCE_STANDARDSDK__)
 517     if ( !::MoveWindow(GetHwnd(), x, y, w, h, FALSE) )
 518     {
 519         wxLogLastError(wxT("MoveWindow"));
 520     }
 521 #endif
 522
 523     if ( !title.empty() )
 524     {
 525         ::SetWindowText(GetHwnd(), title);
 526     }
 527
 528     SubclassWin(m_hWnd);
 529
 530 #ifdef __SMARTPHONE__
 531     // Work around title non-display glitch
 532     Show(false);
 533 #endif
 534
 535     return true;
 536 #endif // __WXMICROWIN__/!__WXMICROWIN__
 537 }
 538
 539 bool wxTopLevelWindowMSW::CreateFrame(const wxString& title,
 540                                       const wxPoint& pos,
 541                                       const wxSize& size)
 542 {
 543     WXDWORD exflags;
 544     WXDWORD flags = MSWGetCreateWindowFlags(&exflags);
 545
 546     const wxSize sz = IsAlwaysMaximized() ? wxDefaultSize : size;
 547
 548     return MSWCreate(wxCanvasClassName, title, pos, sz, flags, exflags);
 549 }
 550
 551 bool wxTopLevelWindowMSW::Create(wxWindow *parent,
 552                                  wxWindowID id,
 553                                  const wxString& title,
 554                                  const wxPoint& pos,
 555                                  const wxSize& size,
 556                                  long style,
 557                                  const wxString& name)
 558 {
 559     bool ret wxDUMMY_INITIALIZE(false);
 560
 561     // init our fields
 562     Init();
 563
 564     wxSize sizeReal = size;
 565     if ( !sizeReal.IsFullySpecified() )
 566     {
 567         sizeReal.SetDefaults(GetDefaultSize());
 568     }
 569
 570     m_windowStyle = style;
 571
 572     SetName(name);
 573
 574     m_windowId = id == wxID_ANY ? NewControlId() : id;
 575
 576     wxTopLevelWindows.Append(this);
 577
 578     if ( parent )
 579         parent->AddChild(this);
 580
 581     if ( GetExtraStyle() & wxTOPLEVEL_EX_DIALOG )
 582     {
 583         // we have different dialog templates to allows creation of dialogs
 584         // with & without captions under MSWindows, resizeable or not (but a
 585         // resizeable dialog always has caption - otherwise it would look too
 586         // strange)
 587
 588         // we need 3 additional WORDs for dialog menu, class and title (as we
 589         // don't use DS_SETFONT we don't need the fourth WORD for the font)
 590         static const int dlgsize = sizeof(DLGTEMPLATE) + (sizeof(WORD) * 3);
 591         DLGTEMPLATE *dlgTemplate = (DLGTEMPLATE *)malloc(dlgsize);
 592         memset(dlgTemplate, 0, dlgsize);
 593
 594         // these values are arbitrary, they won't be used normally anyhow
 595         dlgTemplate->x  = 34;
 596         dlgTemplate->y  = 22;
 597         dlgTemplate->cx = 144;
 598         dlgTemplate->cy = 75;
 599
 600         // reuse the code in MSWGetStyle() but correct the results slightly for
 601         // the dialog
 602         dlgTemplate->style = MSWGetStyle(style, NULL);
 603
 604         // all dialogs are popups
 605         dlgTemplate->style |= WS_POPUP;
 606
 607 #ifndef __WXWINCE__
 608         // force 3D-look if necessary, it looks impossibly ugly otherwise
 609         if ( style & (wxRESIZE_BORDER | wxCAPTION) )
 610             dlgTemplate->style |= DS_MODALFRAME;
 611 #endif
 612
 613         ret = CreateDialog(dlgTemplate, title, pos, sizeReal);
 614         free(dlgTemplate);
 615     }
 616     else // !dialog
 617     {
 618         ret = CreateFrame(title, pos, sizeReal);
 619     }
 620
 621 #ifndef __WXWINCE__
 622     if ( ret && !(GetWindowStyleFlag() & wxCLOSE_BOX) )
 623     {
 624         EnableCloseButton(false);
 625     }
 626 #endif
 627
 628     // for standard dialogs the dialog manager generates WM_CHANGEUISTATE
 629     // itself but for custom windows we have to do it ourselves in order to
 630     // make the keyboard indicators (such as underlines for accelerators and
 631     // focus rectangles) work under Win2k+
 632     if ( ret )
 633     {
 634         MSWUpdateUIState(UIS_INITIALIZE);
 635     }
 636
 637     // Note: if we include PocketPC in this test, dialogs can fail to show up,
 638     // for example the text entry dialog in the dialogs sample. Problem with Maximise()?
 639 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__WINCE_STANDARDSDK__))
 640     if ( ( style & wxMAXIMIZE ) || IsAlwaysMaximized() )
 641     {
 642         this->Maximize();
 643     }
 644 #endif
 645
 646 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
 647     SetRightMenu(); // to nothing for initialization
 648 #endif
 649
 650     return ret;
 651 }
 652
 653 wxTopLevelWindowMSW::~wxTopLevelWindowMSW()
 654 {
 655 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
 656     SHACTIVATEINFO* info = (SHACTIVATEINFO*) m_activateInfo;
 657     delete info;
 658     m_activateInfo = NULL;
 659 #endif
 660
 661     // after destroying an owned window, Windows activates the next top level
 662     // window in Z order but it may be different from our owner (to reproduce
 663     // this simply Alt-TAB to another application and back before closing the
 664     // owned frame) whereas we always want to yield activation to our parent
 665     if ( HasFlag(wxFRAME_FLOAT_ON_PARENT) )
 666     {
 667         wxWindow *parent = GetParent();
 668         if ( parent )
 669         {
 670             ::BringWindowToTop(GetHwndOf(parent));
 671         }
 672     }
 673 }
 674
 675 // ----------------------------------------------------------------------------
 676 // wxTopLevelWindowMSW showing
 677 // ----------------------------------------------------------------------------
 678
 679 void wxTopLevelWindowMSW::DoShowWindow(int nShowCmd)
 680 {
 681     ::ShowWindow(GetHwnd(), nShowCmd);
 682
 683     m_iconized = nShowCmd == SW_MINIMIZE;
 684 }
 685
 686 bool wxTopLevelWindowMSW::Show(bool show)
 687 {
 688     // don't use wxWindow version as we want to call DoShowWindow() ourselves
 689     if ( !wxWindowBase::Show(show) )
 690         return false;
 691
 692     int nShowCmd;
 693     if ( show )
 694     {
 695         if ( m_maximizeOnShow )
 696         {
 697             // show and maximize
 698             nShowCmd = SW_MAXIMIZE;
 699
 700             // This is necessary, or no window appears
 701 #if defined( __WINCE_STANDARDSDK__) || defined(__SMARTPHONE__)
 702             DoShowWindow(SW_SHOW);
 703 #endif
 704
 705             m_maximizeOnShow = false;
 706         }
 707         else // just show
 708         {
 709            if ( GetWindowStyle() & wxFRAME_TOOL_WINDOW )
 710                nShowCmd = SW_SHOWNA;
 711            else
 712                nShowCmd = SW_SHOW;
 713         }
 714     }
 715     else // hide
 716     {
 717         nShowCmd = SW_HIDE;
 718     }
 719
 720     DoShowWindow(nShowCmd);
 721
 722 #if defined(__WXWINCE__) && (_WIN32_WCE >= 400 && !defined(__POCKETPC__) && !defined(__SMARTPHONE__))
 723     // Addornments have to be added when the frame is the correct size
 724     wxFrame* frame = wxDynamicCast(this, wxFrame);
 725     if (frame && frame->GetMenuBar())
 726         frame->GetMenuBar()->AddAdornments(GetWindowStyleFlag());
 727 #endif
 728
 729     // we only set pending size if we're maximized before being shown, now that
 730     // we're shown we don't need it any more (it is reset in size event handler
 731     // for child windows but we have to do it ourselves for this parent window)
 732     m_pendingSize = wxDefaultSize;
 733
 734     return true;
 735 }
 736
 737 // ----------------------------------------------------------------------------
 738 // wxTopLevelWindowMSW maximize/minimize
 739 // ----------------------------------------------------------------------------
 740
 741 void wxTopLevelWindowMSW::Maximize(bool maximize)
 742 {
 743     if ( IsShown() )
 744     {
 745         // just maximize it directly
 746         DoShowWindow(maximize ? SW_MAXIMIZE : SW_RESTORE);
 747     }
 748     else // hidden
 749     {
 750         // we can't maximize the hidden frame because it shows it as well,
 751         // so just remember that we should do it later in this case
 752         m_maximizeOnShow = maximize;
 753
 754         // after calling Maximize() the client code expects to get the frame
 755         // "real" size and doesn't want to know that, because of implementation
 756         // details, the frame isn't really maximized yet but will be only once
 757         // it's shown, so return our size as it will be then in this case
 758         if ( maximize )
 759         {
 760             // we must only change pending size here, and not call SetSize()
 761             // because otherwise Windows would think that this (full screen)
 762             // size is the natural size for the frame and so would use it when
 763             // the user clicks on "restore" title bar button instead of the
 764             // correct initial frame size
 765             //
 766             // NB: unfortunately we don't know which display we're on yet so we
 767             //     have to use the default one
 768             m_pendingSize = wxGetClientDisplayRect().GetSize();
 769         }
 770         //else: can't do anything in this case, we don't have the old size
 771     }
 772 }
 773
 774 bool wxTopLevelWindowMSW::IsMaximized() const
 775 {
 776     return IsAlwaysMaximized() ||
 777 #if !defined(__SMARTPHONE__) && !defined(__POCKETPC__)
 778            (::IsZoomed(GetHwnd()) != 0) ||
 779 #endif
 780            m_maximizeOnShow;
 781 }
 782
 783 void wxTopLevelWindowMSW::Iconize(bool iconize)
 784 {
 785     DoShowWindow(iconize ? SW_MINIMIZE : SW_RESTORE);
 786 }
 787
 788 bool wxTopLevelWindowMSW::IsIconized() const
 789 {
 790 #ifdef __WXWINCE__
 791     return false;
 792 #else
 793     // don't use m_iconized, it may be briefly out of sync with the real state
 794     // as it's only modified when we receive a WM_SIZE and we could be called
 795     // from an event handler from one of the messages we receive before it,
 796     // such as WM_MOVE
 797     return ::IsIconic(GetHwnd()) != 0;
 798 #endif
 799 }
 800
 801 void wxTopLevelWindowMSW::Restore()
 802 {
 803     DoShowWindow(SW_RESTORE);
 804 }
 805
 806 // ----------------------------------------------------------------------------
 807 // wxTopLevelWindowMSW fullscreen
 808 // ----------------------------------------------------------------------------
 809
 810 bool wxTopLevelWindowMSW::ShowFullScreen(bool show, long style)
 811 {
 812     if ( show == IsFullScreen() )
 813     {
 814         // nothing to do
 815         return true;
 816     }
 817
 818     m_fsIsShowing = show;
 819
 820     if ( show )
 821     {
 822         m_fsStyle = style;
 823
 824         // zap the frame borders
 825
 826         // save the 'normal' window style
 827         m_fsOldWindowStyle = GetWindowLong(GetHwnd(), GWL_STYLE);
 828
 829         // save the old position, width & height, maximize state
 830         m_fsOldSize = GetRect();
 831         m_fsIsMaximized = IsMaximized();
 832
 833         // decide which window style flags to turn off
 834         LONG newStyle = m_fsOldWindowStyle;
 835         LONG offFlags = 0;
 836
 837         if (style & wxFULLSCREEN_NOBORDER)
 838         {
 839             offFlags |= WS_BORDER;
 840 #ifndef __WXWINCE__
 841             offFlags |= WS_THICKFRAME;
 842 #endif
 843         }
 844         if (style & wxFULLSCREEN_NOCAPTION)
 845             offFlags |= WS_CAPTION | WS_SYSMENU;
 846
 847         newStyle &= ~offFlags;
 848
 849         // change our window style to be compatible with full-screen mode
 850         ::SetWindowLong(GetHwnd(), GWL_STYLE, newStyle);
 851
 852         wxRect rect;
 853 #if wxUSE_DISPLAY
 854         // resize to the size of the display containing us
 855         int dpy = wxDisplay::GetFromWindow(this);
 856         if ( dpy != wxNOT_FOUND )
 857         {
 858             rect = wxDisplay(dpy).GetGeometry();
 859         }
 860         else // fall back to the main desktop
 861 #endif // wxUSE_DISPLAY
 862         {
 863             // resize to the size of the desktop
 864             wxCopyRECTToRect(wxGetWindowRect(::GetDesktopWindow()), rect);
 865 #ifdef __WXWINCE__
 866             // FIXME: size of the bottom menu (toolbar)
 867             // should be taken in account
 868             rect.height += rect.y;
 869             rect.y       = 0;
 870 #endif
 871         }
 872
 873         SetSize(rect);
 874
 875         // now flush the window style cache and actually go full-screen
 876         long flags = SWP_FRAMECHANGED;
 877
 878         // showing the frame full screen should also show it if it's still
 879         // hidden
 880         if ( !IsShown() )
 881         {
 882             // don't call wxWindow version to avoid flicker from calling
 883             // ::ShowWindow() -- we're going to show the window at the correct
 884             // location directly below -- but do call the wxWindowBase version
 885             // to sync the internal m_isShown flag
 886             wxWindowBase::Show();
 887
 888             flags |= SWP_SHOWWINDOW;
 889         }
 890
 891         SetWindowPos(GetHwnd(), HWND_TOP,
 892                      rect.x, rect.y, rect.width, rect.height,
 893                      flags);
 894
 895 #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
 896         ::SHFullScreen(GetHwnd(), SHFS_HIDETASKBAR | SHFS_HIDESIPBUTTON);
 897 #endif
 898
 899         // finally send an event allowing the window to relayout itself &c
 900         wxSizeEvent event(rect.GetSize(), GetId());
 901         GetEventHandler()->ProcessEvent(event);
 902     }
 903     else // stop showing full screen
 904     {
 905 #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
 906         ::SHFullScreen(GetHwnd(), SHFS_SHOWTASKBAR | SHFS_SHOWSIPBUTTON);
 907 #endif
 908         Maximize(m_fsIsMaximized);
 909         SetWindowLong(GetHwnd(),GWL_STYLE, m_fsOldWindowStyle);
 910         SetWindowPos(GetHwnd(),HWND_TOP,m_fsOldSize.x, m_fsOldSize.y,
 911             m_fsOldSize.width, m_fsOldSize.height, SWP_FRAMECHANGED);
 912     }
 913
 914     return true;
 915 }
 916
 917 // ----------------------------------------------------------------------------
 918 // wxTopLevelWindowMSW misc
 919 // ----------------------------------------------------------------------------
 920
 921 void wxTopLevelWindowMSW::SetTitle( const wxString& title)
 922 {
 923     SetLabel(title);
 924 }
 925
 926 wxString wxTopLevelWindowMSW::GetTitle() const
 927 {
 928     return GetLabel();
 929 }
 930
 931 void wxTopLevelWindowMSW::SetIcon(const wxIcon& icon)
 932 {
 933     SetIcons( wxIconBundle( icon ) );
 934 }
 935
 936 void wxTopLevelWindowMSW::SetIcons(const wxIconBundle& icons)
 937 {
 938     wxTopLevelWindowBase::SetIcons(icons);
 939
 940 #if !defined(__WXMICROWIN__)
 941     const wxIcon& sml = icons.GetIcon( wxSize( 16, 16 ) );
 942     if( sml.Ok() && sml.GetWidth() == 16 && sml.GetHeight() == 16 )
 943     {
 944         ::SendMessage( GetHwndOf( this ), WM_SETICON, ICON_SMALL,
 945                        (LPARAM)GetHiconOf(sml) );
 946     }
 947
 948     const wxIcon& big = icons.GetIcon( wxSize( 32, 32 ) );
 949     if( big.Ok() && big.GetWidth() == 32 && big.GetHeight() == 32 )
 950     {
 951         ::SendMessage( GetHwndOf( this ), WM_SETICON, ICON_BIG,
 952                        (LPARAM)GetHiconOf(big) );
 953     }
 954 #endif // !__WXMICROWIN__
 955 }
 956
 957 bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
 958 {
 959 #if !defined(__WXMICROWIN__)
 960     // get system (a.k.a. window) menu
 961     HMENU hmenu = GetSystemMenu(GetHwnd(), FALSE /* get it */);
 962     if ( !hmenu )
 963     {
 964         // no system menu at all -- ok if we want to remove the close button
 965         // anyhow, but bad if we want to show it
 966         return !enable;
 967     }
 968
 969     // enabling/disabling the close item from it also automatically
 970     // disables/enables the close title bar button
 971     if ( ::EnableMenuItem(hmenu, SC_CLOSE,
 972                           MF_BYCOMMAND |
 973                           (enable ? MF_ENABLED : MF_GRAYED)) == -1 )
 974     {
 975         wxLogLastError(_T("EnableMenuItem(SC_CLOSE)"));
 976
 977         return false;
 978     }
 979 #ifndef __WXWINCE__
 980     // update appearance immediately
 981     if ( !::DrawMenuBar(GetHwnd()) )
 982     {
 983         wxLogLastError(_T("DrawMenuBar"));
 984     }
 985 #endif
 986 #endif // !__WXMICROWIN__
 987
 988     return true;
 989 }
 990
 991 #ifndef __WXWINCE__
 992
 993 bool wxTopLevelWindowMSW::SetShape(const wxRegion& region)
 994 {
 995     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
 996                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
 997
 998     // The empty region signifies that the shape should be removed from the
 999     // window.
1000     if ( region.IsEmpty() )
1001     {
1002         if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0)
1003         {
1004             wxLogLastError(_T("SetWindowRgn"));
1005             return false;
1006         }
1007         return true;
1008     }
1009
1010     // Windows takes ownership of the region, so
1011     // we'll have to make a copy of the region to give to it.
1012     DWORD noBytes = ::GetRegionData(GetHrgnOf(region), 0, NULL);
1013     RGNDATA *rgnData = (RGNDATA*) new char[noBytes];
1014     ::GetRegionData(GetHrgnOf(region), noBytes, rgnData);
1015     HRGN hrgn = ::ExtCreateRegion(NULL, noBytes, rgnData);
1016     delete[] (char*) rgnData;
1017
1018     // SetWindowRgn expects the region to be in coordinants
1019     // relative to the window, not the client area.  Figure
1020     // out the offset, if any.
1021     RECT rect;
1022     DWORD dwStyle =   ::GetWindowLong(GetHwnd(), GWL_STYLE);
1023     DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
1024     ::GetClientRect(GetHwnd(), &rect);
1025     ::AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle);
1026     ::OffsetRgn(hrgn, -rect.left, -rect.top);
1027
1028     // Now call the shape API with the new region.
1029     if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0)
1030     {
1031         wxLogLastError(_T("SetWindowRgn"));
1032         return false;
1033     }
1034     return true;
1035 }
1036
1037 #endif // !__WXWINCE__
1038
1039 void wxTopLevelWindowMSW::RequestUserAttention(int flags)
1040 {
1041     // check if we can use FlashWindowEx(): unfortunately a simple test for
1042     // FLASHW_STOP doesn't work because MSVC6 headers do #define it but don't
1043     // provide FlashWindowEx() declaration, so try to detect whether we have
1044     // real headers for WINVER 0x0500 by checking for existence of a symbol not
1045     // declated in MSVC6 header
1046 #if defined(FLASHW_STOP) && defined(VK_XBUTTON1)
1047     // available in the headers, check if it is supported by the system
1048     typedef BOOL (WINAPI *FlashWindowEx_t)(FLASHWINFO *pfwi);
1049     FlashWindowEx_t s_pfnFlashWindowEx = NULL;
1050     if ( !s_pfnFlashWindowEx )
1051     {
1052         wxDynamicLibrary dllUser32(_T("user32.dll"));
1053         s_pfnFlashWindowEx = (FlashWindowEx_t)
1054                                 dllUser32.GetSymbol(_T("FlashWindowEx"));
1055
1056         // we can safely unload user32.dll here, it's going to remain loaded as
1057         // long as the program is running anyhow
1058     }
1059
1060     if ( s_pfnFlashWindowEx )
1061     {
1062         WinStruct<FLASHWINFO> fwi;
1063         fwi.hwnd = GetHwnd();
1064         fwi.dwFlags = FLASHW_ALL;
1065         if ( flags & wxUSER_ATTENTION_INFO )
1066         {
1067             // just flash a few times
1068             fwi.uCount = 3;
1069         }
1070         else // wxUSER_ATTENTION_ERROR
1071         {
1072             // flash until the user notices it
1073             fwi.dwFlags |= FLASHW_TIMERNOFG;
1074         }
1075
1076         s_pfnFlashWindowEx(&fwi);
1077     }
1078     else // FlashWindowEx() not available
1079 #endif // FlashWindowEx() defined
1080     {
1081         wxUnusedVar(flags);
1082 #ifndef __WXWINCE__
1083         ::FlashWindow(GetHwnd(), TRUE);
1084 #endif // __WXWINCE__
1085     }
1086 }
1087
1088 // ---------------------------------------------------------------------------
1089
1090 bool wxTopLevelWindowMSW::SetTransparent(wxByte alpha)
1091 {
1092     typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD);
1093     static PSETLAYEREDWINDOWATTR pSetLayeredWindowAttributes = NULL;
1094
1095     if ( pSetLayeredWindowAttributes == NULL )
1096     {
1097         wxDynamicLibrary dllUser32(_T("user32.dll"));
1098         pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR)
1099             dllUser32.GetSymbol(wxT("SetLayeredWindowAttributes"));
1100     }
1101     if ( pSetLayeredWindowAttributes == NULL )
1102         return false;
1103
1104     LONG exstyle = GetWindowLong(GetHwnd(), GWL_EXSTYLE);
1105
1106     // if setting alpha to fully opaque then turn off the layered style
1107     if (alpha == 255)
1108     {
1109         SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle & ~WS_EX_LAYERED);
1110         Refresh();
1111         return true;
1112     }
1113
1114     // Otherwise, set the layered style if needed and set the alpha value
1115     if ((exstyle & WS_EX_LAYERED) == 0 )
1116         SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle | WS_EX_LAYERED);
1117
1118     return pSetLayeredWindowAttributes(GetHwnd(), 0, (BYTE)alpha, LWA_ALPHA) != 0;
1119 }
1120
1121 bool wxTopLevelWindowMSW::CanSetTransparent()
1122 {
1123     // The API is available on win2k and above
1124
1125     static int os_type = -1;
1126     static int ver_major = -1;
1127
1128     if (os_type == -1)
1129         os_type = ::wxGetOsVersion(&ver_major);
1130
1131     return (os_type == wxWINDOWS_NT && ver_major >= 5);
1132 }
1133
1134 // ----------------------------------------------------------------------------
1135 // wxTopLevelWindow event handling
1136 // ----------------------------------------------------------------------------
1137
1138 // Default activation behaviour - set the focus for the first child
1139 // subwindow found.
1140 void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
1141 {
1142     if ( event.GetActive() )
1143     {
1144         // restore focus to the child which was last focused unless we already
1145         // have it
1146         wxLogTrace(_T("focus"), _T("wxTLW %08x activated."), (int) m_hWnd);
1147
1148         wxWindow *winFocus = FindFocus();
1149         if ( !winFocus || wxGetTopLevelParent(winFocus) != this )
1150         {
1151             wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent()
1152                                                 : NULL;
1153             if ( !parent )
1154             {
1155                 parent = this;
1156             }
1157
1158             wxSetFocusToChild(parent, &m_winLastFocused);
1159         }
1160     }
1161     else // deactivating
1162     {
1163         // remember the last focused child if it is our child
1164         m_winLastFocused = FindFocus();
1165
1166         if ( m_winLastFocused )
1167         {
1168             // let it know that it doesn't have focus any more
1169             m_winLastFocused->HandleKillFocus((WXHWND)NULL);
1170
1171             // and don't remember it if it's a child from some other frame
1172             if ( wxGetTopLevelParent(m_winLastFocused) != this )
1173             {
1174                 m_winLastFocused = NULL;
1175             }
1176         }
1177
1178         wxLogTrace(_T("focus"),
1179                    _T("wxTLW %08x deactivated, last focused: %08x."),
1180                    (int) m_hWnd,
1181                    (int) (m_winLastFocused ? GetHwndOf(m_winLastFocused)
1182                                            : NULL));
1183
1184         event.Skip();
1185     }
1186 }
1187
1188 // the DialogProc for all wxWidgets dialogs
1189 LONG APIENTRY _EXPORT
1190 wxDlgProc(HWND hDlg,
1191           UINT message,
1192           WPARAM WXUNUSED(wParam),
1193           LPARAM WXUNUSED(lParam))
1194 {
1195     switch ( message )
1196     {
1197         case WM_INITDIALOG:
1198         {
1199             // under CE, add a "Ok" button in the dialog title bar and make it full
1200             // screen
1201             //
1202             // TODO: find the window for this HWND, and take into account
1203             // wxMAXIMIZE and wxCLOSE_BOX. For now, assume both are present.
1204             //
1205             // Standard SDK doesn't have aygshell.dll: see
1206             // include/wx/msw/wince/libraries.h
1207 #if defined(__WXWINCE__) && !defined(__WINCE_STANDARDSDK__) && !defined(__HANDHELDPC__)
1208             SHINITDLGINFO shidi;
1209             shidi.dwMask = SHIDIM_FLAGS;
1210             shidi.dwFlags = SHIDIF_SIZEDLG // take account of the SIP or menubar
1211 #ifndef __SMARTPHONE__
1212                             | SHIDIF_DONEBUTTON
1213 #endif
1214                         ;
1215             shidi.hDlg = hDlg;
1216             SHInitDialog( &shidi );
1217 #else // no SHInitDialog()
1218             wxUnusedVar(hDlg);
1219 #endif
1220             // for WM_INITDIALOG, returning TRUE tells system to set focus to
1221             // the first control in the dialog box, but as we set the focus
1222             // ourselves, we return FALSE for it as well
1223             return FALSE;
1224         }
1225     }
1226
1227     // for almost all messages, returning FALSE means that we didn't process
1228     // the message
1229     return FALSE;
1230 }
1231
1232 // ============================================================================
1233 // wxTLWHiddenParentModule implementation
1234 // ============================================================================
1235
1236 HWND wxTLWHiddenParentModule::ms_hwnd = NULL;
1237
1238 const wxChar *wxTLWHiddenParentModule::ms_className = NULL;
1239
1240 bool wxTLWHiddenParentModule::OnInit()
1241 {
1242     ms_hwnd = NULL;
1243     ms_className = NULL;
1244
1245     return true;
1246 }
1247
1248 void wxTLWHiddenParentModule::OnExit()
1249 {
1250     if ( ms_hwnd )
1251     {
1252         if ( !::DestroyWindow(ms_hwnd) )
1253         {
1254             wxLogLastError(_T("DestroyWindow(hidden TLW parent)"));
1255         }
1256
1257         ms_hwnd = NULL;
1258     }
1259
1260     if ( ms_className )
1261     {
1262         if ( !::UnregisterClass(ms_className, wxGetInstance()) )
1263         {
1264             wxLogLastError(_T("UnregisterClass(\"wxTLWHiddenParent\")"));
1265         }
1266
1267         ms_className = NULL;
1268     }
1269 }
1270
1271 /* static */
1272 HWND wxTLWHiddenParentModule::GetHWND()
1273 {
1274     if ( !ms_hwnd )
1275     {
1276         if ( !ms_className )
1277         {
1278             static const wxChar *HIDDEN_PARENT_CLASS = _T("wxTLWHiddenParent");
1279
1280             WNDCLASS wndclass;
1281             wxZeroMemory(wndclass);
1282
1283             wndclass.lpfnWndProc   = DefWindowProc;
1284             wndclass.hInstance     = wxGetInstance();
1285             wndclass.lpszClassName = HIDDEN_PARENT_CLASS;
1286
1287             if ( !::RegisterClass(&wndclass) )
1288             {
1289                 wxLogLastError(_T("RegisterClass(\"wxTLWHiddenParent\")"));
1290             }
1291             else
1292             {
1293                 ms_className = HIDDEN_PARENT_CLASS;
1294             }
1295         }
1296
1297         ms_hwnd = ::CreateWindow(ms_className, wxEmptyString, 0, 0, 0, 0, 0, NULL,
1298                                  (HMENU)NULL, wxGetInstance(), NULL);
1299         if ( !ms_hwnd )
1300         {
1301             wxLogLastError(_T("CreateWindow(hidden TLW parent)"));
1302         }
1303     }
1304
1305     return ms_hwnd;
1306 }