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