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