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         // Keep the #ifdef block inside the case to fix a potential MSVC
 365         // warning regarding switch statement containing no case or
 366         // default labels (or a default only).
 367 #ifndef __WXUNIVERSAL__
 368             // We may need to generate events for the items added to the system
 369             // menu if it had been created (and presumably modified).
 370             if ( m_menuSystem )
 371             {
 372                 // From MSDN:
 373                 //
 374                 //      ... the four low-order bits of the wParam parameter are
 375                 //      used internally by the system. To obtain the correct
 376                 //      result when testing the value of wParam, an application
 377                 //      must combine the value 0xFFF0 with the wParam value by
 378                 //      using the bitwise AND operator.
 379                 unsigned id = wParam & 0xfff0;
 380
 381                 // SC_SIZE is the first of the system-defined commands and we
 382                 // leave those to DefWindowProc().
 383                 if ( id < SC_SIZE )
 384                 {
 385                     if ( m_menuSystem->MSWCommand(0 /* unused anyhow */, id) )
 386                         processed = true;
 387                 }
 388             }
 389 #endif // #ifndef __WXUNIVERSAL__
 390             break;
 391     }
 392
 393     if ( !processed )
 394         rc = wxTopLevelWindowBase::MSWWindowProc(message, wParam, lParam);
 395
 396     return rc;
 397 }
 398
 399 bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
 400                                        const wxString& title,
 401                                        const wxPoint& pos,
 402                                        const wxSize& size)
 403 {
 404 #ifdef __WXMICROWIN__
 405     // no dialogs support under MicroWin yet
 406     return CreateFrame(title, pos, size);
 407 #else // !__WXMICROWIN__
 408     // static cast is valid as we're only ever called for dialogs
 409     wxWindow * const
 410         parent = static_cast<wxDialog *>(this)->GetParentForModalDialog();
 411
 412     m_hWnd = (WXHWND)::CreateDialogIndirect
 413                        (
 414                         wxGetInstance(),
 415                         (DLGTEMPLATE*)dlgTemplate,
 416                         parent ? GetHwndOf(parent) : NULL,
 417                         (DLGPROC)wxDlgProc
 418                        );
 419
 420     if ( !m_hWnd )
 421     {
 422         wxFAIL_MSG(wxT("Failed to create dialog. Incorrect DLGTEMPLATE?"));
 423
 424         wxLogSysError(wxT("Can't create dialog using memory template"));
 425
 426         return false;
 427     }
 428
 429 #if !defined(__WXWINCE__)
 430     // For some reason, the system menu is activated when we use the
 431     // WS_EX_CONTEXTHELP style, so let's set a reasonable icon
 432     if ( HasExtraStyle(wxWS_EX_CONTEXTHELP) )
 433     {
 434         wxFrame *winTop = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
 435         if ( winTop )
 436         {
 437             wxIcon icon = winTop->GetIcon();
 438             if ( icon.IsOk() )
 439             {
 440                 ::SendMessage(GetHwnd(), WM_SETICON,
 441                               (WPARAM)TRUE,
 442                               (LPARAM)GetHiconOf(icon));
 443             }
 444         }
 445     }
 446 #endif // !__WXWINCE__
 447
 448     if ( !title.empty() )
 449     {
 450         ::SetWindowText(GetHwnd(), title.wx_str());
 451     }
 452
 453     SubclassWin(m_hWnd);
 454
 455 #if !defined(__WXWINCE__) || defined(__WINCE_STANDARDSDK__)
 456     // move the dialog to its initial position without forcing repainting
 457     int x, y, w, h;
 458     (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
 459
 460     if ( x == (int)CW_USEDEFAULT )
 461     {
 462         // Let the system position the window, just set its size.
 463         ::SetWindowPos(GetHwnd(), 0,
 464                        0, 0, w, h,
 465                        SWP_NOMOVE | SWP_NOZORDER);
 466     }
 467     else // Move the window to the desired location and set its size too.
 468     {
 469         if ( !::MoveWindow(GetHwnd(), x, y, w, h, FALSE) )
 470         {
 471             wxLogLastError(wxT("MoveWindow"));
 472         }
 473     }
 474 #endif // !__WXWINCE__
 475
 476 #ifdef __SMARTPHONE__
 477     // Work around title non-display glitch
 478     Show(false);
 479 #endif
 480
 481     return true;
 482 #endif // __WXMICROWIN__/!__WXMICROWIN__
 483 }
 484
 485 bool wxTopLevelWindowMSW::CreateFrame(const wxString& title,
 486                                       const wxPoint& pos,
 487                                       const wxSize& size)
 488 {
 489     WXDWORD exflags;
 490     WXDWORD flags = MSWGetCreateWindowFlags(&exflags);
 491
 492     const wxSize sz = IsAlwaysMaximized() ? wxDefaultSize : size;
 493
 494 #ifndef __WXWINCE__
 495     if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
 496         exflags |= WS_EX_LAYOUTRTL;
 497 #endif
 498
 499     return MSWCreate(MSWGetRegisteredClassName(),
 500                      title.wx_str(), pos, sz, flags, exflags);
 501 }
 502
 503 bool wxTopLevelWindowMSW::Create(wxWindow *parent,
 504                                  wxWindowID id,
 505                                  const wxString& title,
 506                                  const wxPoint& pos,
 507                                  const wxSize& size,
 508                                  long style,
 509                                  const wxString& name)
 510 {
 511     wxSize sizeReal = size;
 512     if ( !sizeReal.IsFullySpecified() )
 513     {
 514         sizeReal.SetDefaults(GetDefaultSize());
 515     }
 516
 517     // notice that we should append this window to wxTopLevelWindows list
 518     // before calling CreateBase() as it behaves differently for TLW and
 519     // non-TLW windows
 520     wxTopLevelWindows.Append(this);
 521
 522     bool ret = CreateBase(parent, id, pos, sizeReal, style, name);
 523     if ( !ret )
 524         return false;
 525
 526     if ( parent )
 527         parent->AddChild(this);
 528
 529     if ( GetExtraStyle() & wxTOPLEVEL_EX_DIALOG )
 530     {
 531         // we have different dialog templates to allows creation of dialogs
 532         // with & without captions under MSWindows, resizable or not (but a
 533         // resizable dialog always has caption - otherwise it would look too
 534         // strange)
 535
 536         // we need 3 additional WORDs for dialog menu, class and title (as we
 537         // don't use DS_SETFONT we don't need the fourth WORD for the font)
 538         static const int dlgsize = sizeof(DLGTEMPLATE) + (sizeof(WORD) * 3);
 539         DLGTEMPLATE *dlgTemplate = (DLGTEMPLATE *)malloc(dlgsize);
 540         memset(dlgTemplate, 0, dlgsize);
 541
 542         // these values are arbitrary, they won't be used normally anyhow
 543         dlgTemplate->x  = 34;
 544         dlgTemplate->y  = 22;
 545         dlgTemplate->cx = 144;
 546         dlgTemplate->cy = 75;
 547
 548         // reuse the code in MSWGetStyle() but correct the results slightly for
 549         // the dialog
 550         //
 551         // NB: we need a temporary variable as we can't pass pointer to
 552         //     dwExtendedStyle directly, it's not aligned correctly for 64 bit
 553         //     architectures
 554         WXDWORD dwExtendedStyle;
 555         dlgTemplate->style = MSWGetStyle(style, &dwExtendedStyle);
 556         dlgTemplate->dwExtendedStyle = dwExtendedStyle;
 557
 558         // all dialogs are popups
 559         dlgTemplate->style |= WS_POPUP;
 560
 561 #ifndef __WXWINCE__
 562         if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
 563         {
 564             dlgTemplate->dwExtendedStyle |= WS_EX_LAYOUTRTL;
 565         }
 566
 567         // force 3D-look if necessary, it looks impossibly ugly otherwise
 568         if ( style & (wxRESIZE_BORDER | wxCAPTION) )
 569             dlgTemplate->style |= DS_MODALFRAME;
 570 #endif
 571
 572         ret = CreateDialog(dlgTemplate, title, pos, sizeReal);
 573         free(dlgTemplate);
 574     }
 575     else // !dialog
 576     {
 577         ret = CreateFrame(title, pos, sizeReal);
 578     }
 579
 580 #ifndef __WXWINCE__
 581     if ( ret && !(GetWindowStyleFlag() & wxCLOSE_BOX) )
 582     {
 583         EnableCloseButton(false);
 584     }
 585 #endif
 586
 587     // for standard dialogs the dialog manager generates WM_CHANGEUISTATE
 588     // itself but for custom windows we have to do it ourselves in order to
 589     // make the keyboard indicators (such as underlines for accelerators and
 590     // focus rectangles) work under Win2k+
 591     if ( ret )
 592     {
 593         MSWUpdateUIState(UIS_INITIALIZE);
 594     }
 595
 596     // Note: if we include PocketPC in this test, dialogs can fail to show up,
 597     // for example the text entry dialog in the dialogs sample. Problem with Maximise()?
 598 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__WINCE_STANDARDSDK__))
 599     if ( ( style & wxMAXIMIZE ) || IsAlwaysMaximized() )
 600     {
 601         this->Maximize();
 602     }
 603 #endif
 604
 605 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
 606     SetRightMenu(); // to nothing for initialization
 607 #endif
 608
 609     return ret;
 610 }
 611
 612 wxTopLevelWindowMSW::~wxTopLevelWindowMSW()
 613 {
 614     delete m_menuSystem;
 615
 616     SendDestroyEvent();
 617
 618 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
 619     SHACTIVATEINFO* info = (SHACTIVATEINFO*) m_activateInfo;
 620     delete info;
 621     m_activateInfo = NULL;
 622 #endif
 623
 624     // after destroying an owned window, Windows activates the next top level
 625     // window in Z order but it may be different from our owner (to reproduce
 626     // this simply Alt-TAB to another application and back before closing the
 627     // owned frame) whereas we always want to yield activation to our parent
 628     if ( HasFlag(wxFRAME_FLOAT_ON_PARENT) )
 629     {
 630         wxWindow *parent = GetParent();
 631         if ( parent )
 632         {
 633             ::BringWindowToTop(GetHwndOf(parent));
 634         }
 635     }
 636 }
 637
 638 // ----------------------------------------------------------------------------
 639 // wxTopLevelWindowMSW showing
 640 // ----------------------------------------------------------------------------
 641
 642 void wxTopLevelWindowMSW::DoShowWindow(int nShowCmd)
 643 {
 644     ::ShowWindow(GetHwnd(), nShowCmd);
 645
 646     // Hiding the window doesn't change its iconized state.
 647     if ( nShowCmd != SW_HIDE )
 648     {
 649         // Otherwise restoring, maximizing or showing the window normally also
 650         // makes it not iconized and only minimizing it does make it iconized.
 651         m_iconized = nShowCmd == SW_MINIMIZE;
 652     }
 653 }
 654
 655 void wxTopLevelWindowMSW::ShowWithoutActivating()
 656 {
 657     if ( !wxWindowBase::Show(true) )
 658         return;
 659
 660     DoShowWindow(SW_SHOWNA);
 661 }
 662
 663 bool wxTopLevelWindowMSW::Show(bool show)
 664 {
 665     // don't use wxWindow version as we want to call DoShowWindow() ourselves
 666     if ( !wxWindowBase::Show(show) )
 667         return false;
 668
 669     int nShowCmd;
 670     if ( show )
 671     {
 672         if ( m_maximizeOnShow )
 673         {
 674             // show and maximize
 675             nShowCmd = SW_MAXIMIZE;
 676
 677             // This is necessary, or no window appears
 678 #if defined( __WINCE_STANDARDSDK__) || defined(__SMARTPHONE__)
 679             DoShowWindow(SW_SHOW);
 680 #endif
 681
 682             m_maximizeOnShow = false;
 683         }
 684         else if ( m_iconized )
 685         {
 686             // iconize and show
 687             nShowCmd = SW_MINIMIZE;
 688         }
 689         else // just show
 690         {
 691             // we shouldn't use SW_SHOW which also activates the window for
 692             // tool frames (as they shouldn't steal focus from the main window)
 693             // nor for the currently disabled windows as they would be enabled
 694             // as a side effect
 695             if ( HasFlag(wxFRAME_TOOL_WINDOW) || !IsEnabled() )
 696                 nShowCmd = SW_SHOWNA;
 697             else
 698                 nShowCmd = SW_SHOW;
 699         }
 700     }
 701     else // hide
 702     {
 703         nShowCmd = SW_HIDE;
 704     }
 705
 706 #if wxUSE_DEFERRED_SIZING
 707     // we only set pending size if we're maximized before being shown, now that
 708     // we're shown we don't need it any more (it is reset in size event handler
 709     // for child windows but we have to do it ourselves for this parent window)
 710     //
 711     // make sure to reset it before actually showing the window as this will
 712     // generate WM_SIZE events and we want to use the correct client size from
 713     // them, not the size returned by WM_NCCALCSIZE in DoGetClientSize() which
 714     // turns out to be wrong for maximized windows (see #11762)
 715     m_pendingSize = wxDefaultSize;
 716 #endif // wxUSE_DEFERRED_SIZING
 717
 718     DoShowWindow(nShowCmd);
 719
 720 #if defined(__WXWINCE__) && (_WIN32_WCE >= 400 && !defined(__POCKETPC__) && !defined(__SMARTPHONE__))
 721     // Addornments have to be added when the frame is the correct size
 722     wxFrame* frame = wxDynamicCast(this, wxFrame);
 723     if (frame && frame->GetMenuBar())
 724         frame->GetMenuBar()->AddAdornments(GetWindowStyleFlag());
 725 #endif
 726
 727     return true;
 728 }
 729
 730 // ----------------------------------------------------------------------------
 731 // wxTopLevelWindowMSW maximize/minimize
 732 // ----------------------------------------------------------------------------
 733
 734 void wxTopLevelWindowMSW::Maximize(bool maximize)
 735 {
 736     if ( IsShown() )
 737     {
 738         // just maximize it directly
 739         DoShowWindow(maximize ? SW_MAXIMIZE : SW_RESTORE);
 740     }
 741     else // hidden
 742     {
 743         // we can't maximize the hidden frame because it shows it as well,
 744         // so just remember that we should do it later in this case
 745         m_maximizeOnShow = maximize;
 746
 747 #if wxUSE_DEFERRED_SIZING
 748         // after calling Maximize() the client code expects to get the frame
 749         // "real" size and doesn't want to know that, because of implementation
 750         // details, the frame isn't really maximized yet but will be only once
 751         // it's shown, so return our size as it will be then in this case
 752         if ( maximize )
 753         {
 754             // we must only change pending size here, and not call SetSize()
 755             // because otherwise Windows would think that this (full screen)
 756             // size is the natural size for the frame and so would use it when
 757             // the user clicks on "restore" title bar button instead of the
 758             // correct initial frame size
 759             //
 760             // NB: unfortunately we don't know which display we're on yet so we
 761             //     have to use the default one
 762             m_pendingSize = wxGetClientDisplayRect().GetSize();
 763         }
 764         //else: can't do anything in this case, we don't have the old size
 765 #endif // wxUSE_DEFERRED_SIZING
 766     }
 767 }
 768
 769 bool wxTopLevelWindowMSW::IsMaximized() const
 770 {
 771     return IsAlwaysMaximized() ||
 772 #if !defined(__SMARTPHONE__) && !defined(__POCKETPC__) && !defined(__WINCE_STANDARDSDK__)
 773
 774            (::IsZoomed(GetHwnd()) != 0) ||
 775 #endif
 776            m_maximizeOnShow;
 777 }
 778
 779 void wxTopLevelWindowMSW::Iconize(bool iconize)
 780 {
 781     if ( iconize == m_iconized )
 782     {
 783         // Do nothing, in particular don't restore non-iconized windows when
 784         // Iconize(false) is called as this would wrongly un-maximize them.
 785         return;
 786     }
 787
 788     if ( IsShown() )
 789     {
 790         // change the window state immediately
 791         DoShowWindow(iconize ? SW_MINIMIZE : SW_RESTORE);
 792     }
 793     else // hidden
 794     {
 795         // iconizing the window shouldn't show it so just remember that we need
 796         // to become iconized when shown later
 797         m_iconized = true;
 798     }
 799 }
 800
 801 bool wxTopLevelWindowMSW::IsIconized() const
 802 {
 803 #ifdef __WXWINCE__
 804     return false;
 805 #else
 806     if ( !IsShown() )
 807         return m_iconized;
 808
 809     // don't use m_iconized, it may be briefly out of sync with the real state
 810     // as it's only modified when we receive a WM_SIZE and we could be called
 811     // from an event handler from one of the messages we receive before it,
 812     // such as WM_MOVE
 813     return ::IsIconic(GetHwnd()) != 0;
 814 #endif
 815 }
 816
 817 void wxTopLevelWindowMSW::Restore()
 818 {
 819     DoShowWindow(SW_RESTORE);
 820 }
 821
 822 void wxTopLevelWindowMSW::SetLayoutDirection(wxLayoutDirection dir)
 823 {
 824     if ( dir == wxLayout_Default )
 825         dir = wxTheApp->GetLayoutDirection();
 826
 827     if ( dir != wxLayout_Default )
 828         wxTopLevelWindowBase::SetLayoutDirection(dir);
 829 }
 830
 831 // ----------------------------------------------------------------------------
 832 // wxTopLevelWindowMSW geometry
 833 // ----------------------------------------------------------------------------
 834
 835 #ifndef __WXWINCE__
 836
 837 void wxTopLevelWindowMSW::DoGetPosition(int *x, int *y) const
 838 {
 839     if ( IsIconized() )
 840     {
 841         WINDOWPLACEMENT wp;
 842         wp.length = sizeof(WINDOWPLACEMENT);
 843         if ( ::GetWindowPlacement(GetHwnd(), &wp) )
 844         {
 845             RECT& rc = wp.rcNormalPosition;
 846
 847             // the position returned by GetWindowPlacement() is in workspace
 848             // coordinates except for windows with WS_EX_TOOLWINDOW style
 849             if ( !HasFlag(wxFRAME_TOOL_WINDOW) )
 850             {
 851                 // we must use the correct display for the translation as the
 852                 // task bar might be shown on one display but not the other one
 853                 int n = wxDisplay::GetFromWindow(this);
 854                 wxDisplay dpy(n == wxNOT_FOUND ? 0 : n);
 855                 const wxPoint ptOfs = dpy.GetClientArea().GetPosition() -
 856                                       dpy.GetGeometry().GetPosition();
 857
 858                 rc.left += ptOfs.x;
 859                 rc.top += ptOfs.y;
 860             }
 861
 862             if ( x )
 863                 *x = rc.left;
 864             if ( y )
 865                 *y = rc.top;
 866
 867             return;
 868         }
 869
 870         wxLogLastError(wxT("GetWindowPlacement"));
 871     }
 872     //else: normal case
 873
 874     wxTopLevelWindowBase::DoGetPosition(x, y);
 875 }
 876
 877 void wxTopLevelWindowMSW::DoGetSize(int *width, int *height) const
 878 {
 879     if ( IsIconized() )
 880     {
 881         WINDOWPLACEMENT wp;
 882         wp.length = sizeof(WINDOWPLACEMENT);
 883         if ( ::GetWindowPlacement(GetHwnd(), &wp) )
 884         {
 885             const RECT& rc = wp.rcNormalPosition;
 886
 887             if ( width )
 888                 *width = rc.right - rc.left;
 889             if ( height )
 890                 *height = rc.bottom - rc.top;
 891
 892             return;
 893         }
 894
 895         wxLogLastError(wxT("GetWindowPlacement"));
 896     }
 897     //else: normal case
 898
 899     wxTopLevelWindowBase::DoGetSize(width, height);
 900 }
 901
 902 #endif // __WXWINCE__
 903
 904 void
 905 wxTopLevelWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
 906                                               const wxSize& size,
 907                                               int& x, int& y,
 908                                               int& w, int& h) const
 909 {
 910     // let the system position the window if no explicit position was specified
 911     if ( pos.x == wxDefaultCoord )
 912     {
 913         // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
 914         // can just as well set it to CW_USEDEFAULT as well
 915         x =
 916         y = CW_USEDEFAULT;
 917     }
 918     else
 919     {
 920         // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
 921         // neither because it is not handled as a special value by Windows then
 922         // and so we have to choose some default value for it, even if a
 923         // completely arbitrary one
 924         static const int DEFAULT_Y = 200;
 925
 926         x = pos.x;
 927         y = pos.y == wxDefaultCoord ? DEFAULT_Y : pos.y;
 928     }
 929
 930     if ( size.x == wxDefaultCoord || size.y == wxDefaultCoord )
 931     {
 932         // We don't use CW_USEDEFAULT here for several reasons:
 933         //
 934         //  1. It results in huge frames on modern screens (1000*800 is not
 935         //     uncommon on my 1280*1024 screen) which is way too big for a half
 936         //     empty frame of most of wxWidgets samples for example)
 937         //
 938         //  2. It is buggy for frames with wxFRAME_TOOL_WINDOW style for which
 939         //     the default is for whatever reason 8*8 which breaks client <->
 940         //     window size calculations (it would be nice if it didn't, but it
 941         //     does and the simplest way to fix it seemed to change the broken
 942         //     default size anyhow)
 943         //
 944         //  3. There is just no advantage in doing it: with x and y it is
 945         //     possible that [future versions of] Windows position the new top
 946         //     level window in some smart way which we can't do, but we can
 947         //     guess a reasonably good size for a new window just as well
 948         //     ourselves
 949         //
 950         // The only exception is for the Windows CE platform where the system
 951         // does know better than we how should the windows be sized
 952 #ifdef _WIN32_WCE
 953         w =
 954         h = CW_USEDEFAULT;
 955 #else // !_WIN32_WCE
 956         wxSize sizeReal = size;
 957         sizeReal.SetDefaults(GetDefaultSize());
 958
 959         w = sizeReal.x;
 960         h = sizeReal.y;
 961 #endif // _WIN32_WCE/!_WIN32_WCE
 962     }
 963     else
 964     {
 965         w = size.x;
 966         h = size.y;
 967     }
 968 }
 969
 970 // ----------------------------------------------------------------------------
 971 // wxTopLevelWindowMSW fullscreen
 972 // ----------------------------------------------------------------------------
 973
 974 bool wxTopLevelWindowMSW::ShowFullScreen(bool show, long style)
 975 {
 976     if ( show == IsFullScreen() )
 977     {
 978         // nothing to do
 979         return true;
 980     }
 981
 982     m_fsIsShowing = show;
 983
 984     if ( show )
 985     {
 986         m_fsStyle = style;
 987
 988         // zap the frame borders
 989
 990         // save the 'normal' window style
 991         m_fsOldWindowStyle = GetWindowLong(GetHwnd(), GWL_STYLE);
 992
 993         // save the old position, width & height, maximize state
 994         m_fsOldSize = GetRect();
 995         m_fsIsMaximized = IsMaximized();
 996
 997         // decide which window style flags to turn off
 998         LONG newStyle = m_fsOldWindowStyle;
 999         LONG offFlags = 0;
1000
1001         if (style & wxFULLSCREEN_NOBORDER)
1002         {
1003             offFlags |= WS_BORDER;
1004 #ifndef __WXWINCE__
1005             offFlags |= WS_THICKFRAME;
1006 #endif
1007         }
1008         if (style & wxFULLSCREEN_NOCAPTION)
1009             offFlags |= WS_CAPTION | WS_SYSMENU;
1010
1011         newStyle &= ~offFlags;
1012
1013         // change our window style to be compatible with full-screen mode
1014         ::SetWindowLong(GetHwnd(), GWL_STYLE, newStyle);
1015
1016         wxRect rect;
1017 #if wxUSE_DISPLAY
1018         // resize to the size of the display containing us
1019         int dpy = wxDisplay::GetFromWindow(this);
1020         if ( dpy != wxNOT_FOUND )
1021         {
1022             rect = wxDisplay(dpy).GetGeometry();
1023         }
1024         else // fall back to the main desktop
1025 #endif // wxUSE_DISPLAY
1026         {
1027             // resize to the size of the desktop
1028             wxCopyRECTToRect(wxGetWindowRect(::GetDesktopWindow()), rect);
1029 #ifdef __WXWINCE__
1030             // FIXME: size of the bottom menu (toolbar)
1031             // should be taken in account
1032             rect.height += rect.y;
1033             rect.y       = 0;
1034 #endif
1035         }
1036
1037         SetSize(rect);
1038
1039         // now flush the window style cache and actually go full-screen
1040         long flags = SWP_FRAMECHANGED;
1041
1042         // showing the frame full screen should also show it if it's still
1043         // hidden
1044         if ( !IsShown() )
1045         {
1046             // don't call wxWindow version to avoid flicker from calling
1047             // ::ShowWindow() -- we're going to show the window at the correct
1048             // location directly below -- but do call the wxWindowBase version
1049             // to sync the internal m_isShown flag
1050             wxWindowBase::Show();
1051
1052             flags |= SWP_SHOWWINDOW;
1053         }
1054
1055         SetWindowPos(GetHwnd(), HWND_TOP,
1056                      rect.x, rect.y, rect.width, rect.height,
1057                      flags);
1058
1059 #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
1060         ::SHFullScreen(GetHwnd(), SHFS_HIDETASKBAR | SHFS_HIDESIPBUTTON);
1061 #endif
1062
1063         // finally send an event allowing the window to relayout itself &c
1064         wxSizeEvent event(rect.GetSize(), GetId());
1065         event.SetEventObject(this);
1066         HandleWindowEvent(event);
1067     }
1068     else // stop showing full screen
1069     {
1070 #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
1071         ::SHFullScreen(GetHwnd(), SHFS_SHOWTASKBAR | SHFS_SHOWSIPBUTTON);
1072 #endif
1073         Maximize(m_fsIsMaximized);
1074         SetWindowLong(GetHwnd(),GWL_STYLE, m_fsOldWindowStyle);
1075         SetWindowPos(GetHwnd(),HWND_TOP,m_fsOldSize.x, m_fsOldSize.y,
1076             m_fsOldSize.width, m_fsOldSize.height, SWP_FRAMECHANGED);
1077     }
1078
1079     return true;
1080 }
1081
1082 // ----------------------------------------------------------------------------
1083 // wxTopLevelWindowMSW misc
1084 // ----------------------------------------------------------------------------
1085
1086 void wxTopLevelWindowMSW::SetTitle( const wxString& title)
1087 {
1088     SetLabel(title);
1089 }
1090
1091 wxString wxTopLevelWindowMSW::GetTitle() const
1092 {
1093     return GetLabel();
1094 }
1095
1096 bool wxTopLevelWindowMSW::DoSelectAndSetIcon(const wxIconBundle& icons,
1097                                              int smX,
1098                                              int smY,
1099                                              int i)
1100 {
1101     const wxSize size(::GetSystemMetrics(smX), ::GetSystemMetrics(smY));
1102
1103     // Try the exact size first.
1104     wxIcon icon = icons.GetIconOfExactSize(size);
1105
1106     if ( !icon.IsOk() )
1107     {
1108         // If we didn't find any, set at least some icon: it will look scaled
1109         // and ugly but in practice it's impossible to prevent this because not
1110         // everyone can provide the icons in all sizes used by all versions of
1111         // Windows in all DPIs (this would include creating them in at least
1112         // 14, 16, 22, 32, 48, 64 and 128 pixel sizes).
1113         icon = icons.GetIcon(size);
1114     }
1115
1116     if ( !icon.IsOk() )
1117         return false;
1118
1119     ::SendMessage(GetHwnd(), WM_SETICON, i, (LPARAM)GetHiconOf(icon));
1120     return true;
1121 }
1122
1123 void wxTopLevelWindowMSW::SetIcons(const wxIconBundle& icons)
1124 {
1125     wxTopLevelWindowBase::SetIcons(icons);
1126
1127     if ( icons.IsEmpty() )
1128     {
1129         // FIXME: SetIcons(wxNullIconBundle) should unset existing icons,
1130         //        but we currently don't do that
1131         wxASSERT_MSG( m_icons.IsEmpty(), "unsetting icons doesn't work" );
1132         return;
1133     }
1134
1135     DoSelectAndSetIcon(icons, SM_CXSMICON, SM_CYSMICON, ICON_SMALL);
1136     DoSelectAndSetIcon(icons, SM_CXICON, SM_CYICON, ICON_BIG);
1137 }
1138
1139 bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
1140 {
1141 #if !defined(__WXMICROWIN__)
1142     // get system (a.k.a. window) menu
1143     HMENU hmenu = GetSystemMenu(GetHwnd(), FALSE /* get it */);
1144     if ( !hmenu )
1145     {
1146         // no system menu at all -- ok if we want to remove the close button
1147         // anyhow, but bad if we want to show it
1148         return !enable;
1149     }
1150
1151     // enabling/disabling the close item from it also automatically
1152     // disables/enables the close title bar button
1153     if ( ::EnableMenuItem(hmenu, SC_CLOSE,
1154                           MF_BYCOMMAND |
1155                           (enable ? MF_ENABLED : MF_GRAYED)) == -1 )
1156     {
1157         wxLogLastError(wxT("EnableMenuItem(SC_CLOSE)"));
1158
1159         return false;
1160     }
1161 #ifndef __WXWINCE__
1162     // update appearance immediately
1163     if ( !::DrawMenuBar(GetHwnd()) )
1164     {
1165         wxLogLastError(wxT("DrawMenuBar"));
1166     }
1167 #endif
1168 #endif // !__WXMICROWIN__
1169
1170     return true;
1171 }
1172
1173 void wxTopLevelWindowMSW::RequestUserAttention(int flags)
1174 {
1175     // check if we can use FlashWindowEx(): unfortunately a simple test for
1176     // FLASHW_STOP doesn't work because MSVC6 headers do #define it but don't
1177     // provide FlashWindowEx() declaration, so try to detect whether we have
1178     // real headers for WINVER 0x0500 by checking for existence of a symbol not
1179     // declated in MSVC6 header
1180 #if defined(FLASHW_STOP) && defined(VK_XBUTTON1) && wxUSE_DYNLIB_CLASS
1181     // available in the headers, check if it is supported by the system
1182     typedef BOOL (WINAPI *FlashWindowEx_t)(FLASHWINFO *pfwi);
1183     static FlashWindowEx_t s_pfnFlashWindowEx = NULL;
1184     if ( !s_pfnFlashWindowEx )
1185     {
1186         wxDynamicLibrary dllUser32(wxT("user32.dll"));
1187         s_pfnFlashWindowEx = (FlashWindowEx_t)
1188                                 dllUser32.GetSymbol(wxT("FlashWindowEx"));
1189
1190         // we can safely unload user32.dll here, it's going to remain loaded as
1191         // long as the program is running anyhow
1192     }
1193
1194     if ( s_pfnFlashWindowEx )
1195     {
1196         WinStruct<FLASHWINFO> fwi;
1197         fwi.hwnd = GetHwnd();
1198         fwi.dwFlags = FLASHW_ALL;
1199         if ( flags & wxUSER_ATTENTION_INFO )
1200         {
1201             // just flash a few times
1202             fwi.uCount = 3;
1203         }
1204         else // wxUSER_ATTENTION_ERROR
1205         {
1206             // flash until the user notices it
1207             fwi.dwFlags |= FLASHW_TIMERNOFG;
1208         }
1209
1210         s_pfnFlashWindowEx(&fwi);
1211     }
1212     else // FlashWindowEx() not available
1213 #endif // FlashWindowEx() defined
1214     {
1215         wxUnusedVar(flags);
1216 #ifndef __WXWINCE__
1217         ::FlashWindow(GetHwnd(), TRUE);
1218 #endif // __WXWINCE__
1219     }
1220 }
1221
1222 wxMenu *wxTopLevelWindowMSW::MSWGetSystemMenu() const
1223 {
1224 #ifndef __WXUNIVERSAL__
1225     if ( !m_menuSystem )
1226     {
1227         HMENU hmenu = ::GetSystemMenu(GetHwnd(), FALSE);
1228         if ( !hmenu )
1229         {
1230             wxLogLastError(wxT("GetSystemMenu()"));
1231             return NULL;
1232         }
1233
1234         wxTopLevelWindowMSW * const
1235             self = const_cast<wxTopLevelWindowMSW *>(this);
1236
1237         self->m_menuSystem = wxMenu::MSWNewFromHMENU(hmenu);
1238
1239         // We need to somehow associate this menu with this window to ensure
1240         // that we get events from it. A natural idea would be to pretend that
1241         // it's attached to our menu bar but this wouldn't work if we don't
1242         // have any menu bar which is a common case for applications using
1243         // custom items in the system menu (they mostly do it exactly because
1244         // they don't have any other menus).
1245         //
1246         // So reuse the invoking window pointer instead, this is not exactly
1247         // correct but doesn't seem to have any serious drawbacks.
1248         m_menuSystem->SetInvokingWindow(self);
1249     }
1250 #endif // #ifndef __WXUNIVERSAL__
1251
1252     return m_menuSystem;
1253 }
1254
1255 // ----------------------------------------------------------------------------
1256 // Transparency support
1257 // ---------------------------------------------------------------------------
1258
1259 bool wxTopLevelWindowMSW::SetTransparent(wxByte alpha)
1260 {
1261 #if wxUSE_DYNLIB_CLASS
1262     typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD);
1263     static PSETLAYEREDWINDOWATTR
1264         pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR)-1;
1265
1266     if ( pSetLayeredWindowAttributes == (PSETLAYEREDWINDOWATTR)-1 )
1267     {
1268         wxDynamicLibrary dllUser32(wxT("user32.dll"));
1269
1270         // use RawGetSymbol() and not GetSymbol() to avoid error messages under
1271         // Windows 95: there is nothing the user can do about this anyhow
1272         pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR)
1273             dllUser32.RawGetSymbol(wxT("SetLayeredWindowAttributes"));
1274
1275         // it's ok to destroy dllUser32 here, we link statically to user32.dll
1276         // anyhow so it won't be unloaded
1277     }
1278
1279     if ( !pSetLayeredWindowAttributes )
1280         return false;
1281 #endif // wxUSE_DYNLIB_CLASS
1282
1283     LONG exstyle = GetWindowLong(GetHwnd(), GWL_EXSTYLE);
1284
1285     // if setting alpha to fully opaque then turn off the layered style
1286     if (alpha == 255)
1287     {
1288         SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle & ~WS_EX_LAYERED);
1289         Refresh();
1290         return true;
1291     }
1292
1293 #if wxUSE_DYNLIB_CLASS
1294     // Otherwise, set the layered style if needed and set the alpha value
1295     if ((exstyle & WS_EX_LAYERED) == 0 )
1296         SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle | WS_EX_LAYERED);
1297
1298     if ( pSetLayeredWindowAttributes(GetHwnd(), 0, (BYTE)alpha, LWA_ALPHA) )
1299         return true;
1300 #endif // wxUSE_DYNLIB_CLASS
1301
1302     return false;
1303 }
1304
1305 bool wxTopLevelWindowMSW::CanSetTransparent()
1306 {
1307     // The API is available on win2k and above
1308
1309     static int os_type = -1;
1310     static int ver_major = -1;
1311
1312     if (os_type == -1)
1313         os_type = ::wxGetOsVersion(&ver_major);
1314
1315     return (os_type == wxOS_WINDOWS_NT && ver_major >= 5);
1316 }
1317
1318 void wxTopLevelWindowMSW::DoEnable(bool enable)
1319 {
1320     wxTopLevelWindowBase::DoEnable(enable);
1321
1322     // Enabling or disabling a window may change its appearance. Unfortunately,
1323     // in at least some situation, toplevel windows don't repaint themselves,
1324     // so we have to issue explicit refresh to avoid rendering artifacts.
1325     //
1326     // TODO: find out just what exactly is wrong here
1327     Refresh();
1328 }
1329
1330 void wxTopLevelWindowMSW::DoFreeze()
1331 {
1332     // do nothing: freezing toplevel window causes paint and mouse events
1333     // to go through it any TLWs under it, so the best we can do is to freeze
1334     // all children -- and wxWindowBase::Freeze() does that
1335 }
1336
1337 void wxTopLevelWindowMSW::DoThaw()
1338 {
1339     // intentionally empty -- see DoFreeze()
1340 }
1341
1342
1343 // ----------------------------------------------------------------------------
1344 // wxTopLevelWindow event handling
1345 // ----------------------------------------------------------------------------
1346
1347 // Default activation behaviour - set the focus for the first child
1348 // subwindow found.
1349 void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
1350 {
1351     if ( event.GetActive() )
1352     {
1353         // restore focus to the child which was last focused unless we already
1354         // have it
1355         wxLogTrace(wxT("focus"), wxT("wxTLW %p activated."), m_hWnd);
1356
1357         wxWindow *winFocus = FindFocus();
1358         if ( !winFocus || wxGetTopLevelParent(winFocus) != this )
1359         {
1360             wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent()
1361                                                 : NULL;
1362             if ( !parent )
1363             {
1364                 parent = this;
1365             }
1366
1367             wxSetFocusToChild(parent, &m_winLastFocused);
1368         }
1369     }
1370     else // deactivating
1371     {
1372         // remember the last focused child if it is our child
1373         m_winLastFocused = FindFocus();
1374
1375         if ( m_winLastFocused )
1376         {
1377             // let it know that it doesn't have focus any more
1378             // But this will already be done via WM_KILLFOCUS, so we'll get two kill
1379             // focus events if we call it explicitly.
1380             // m_winLastFocused->HandleKillFocus((WXHWND)NULL);
1381
1382             // and don't remember it if it's a child from some other frame
1383             if ( wxGetTopLevelParent(m_winLastFocused) != this )
1384             {
1385                 m_winLastFocused = NULL;
1386             }
1387         }
1388
1389         wxLogTrace(wxT("focus"),
1390                    wxT("wxTLW %p deactivated, last focused: %p."),
1391                    m_hWnd,
1392                    m_winLastFocused ? GetHwndOf(m_winLastFocused) : NULL);
1393
1394         event.Skip();
1395     }
1396 }
1397
1398 // the DialogProc for all wxWidgets dialogs
1399 LONG APIENTRY _EXPORT
1400 wxDlgProc(HWND hDlg,
1401           UINT message,
1402           WPARAM WXUNUSED(wParam),
1403           LPARAM WXUNUSED(lParam))
1404 {
1405     switch ( message )
1406     {
1407         case WM_INITDIALOG:
1408         {
1409             // under CE, add a "Ok" button in the dialog title bar and make it full
1410             // screen
1411             //
1412             // TODO: find the window for this HWND, and take into account
1413             // wxMAXIMIZE and wxCLOSE_BOX. For now, assume both are present.
1414             //
1415             // Standard SDK doesn't have aygshell.dll: see
1416             // include/wx/msw/wince/libraries.h
1417 #if defined(__WXWINCE__) && !defined(__WINCE_STANDARDSDK__) && !defined(__HANDHELDPC__)
1418             SHINITDLGINFO shidi;
1419             shidi.dwMask = SHIDIM_FLAGS;
1420             shidi.dwFlags = SHIDIF_SIZEDLG // take account of the SIP or menubar
1421 #ifndef __SMARTPHONE__
1422                             | SHIDIF_DONEBUTTON
1423 #endif
1424                         ;
1425             shidi.hDlg = hDlg;
1426             SHInitDialog( &shidi );
1427 #else // no SHInitDialog()
1428             wxUnusedVar(hDlg);
1429 #endif
1430             // for WM_INITDIALOG, returning TRUE tells system to set focus to
1431             // the first control in the dialog box, but as we set the focus
1432             // ourselves, we return FALSE for it as well
1433             return FALSE;
1434         }
1435     }
1436
1437     // for almost all messages, returning FALSE means that we didn't process
1438     // the message
1439     return FALSE;
1440 }
1441
1442 // ============================================================================
1443 // wxTLWHiddenParentModule implementation
1444 // ============================================================================
1445
1446 HWND wxTLWHiddenParentModule::ms_hwnd = NULL;
1447
1448 const wxChar *wxTLWHiddenParentModule::ms_className = NULL;
1449
1450 bool wxTLWHiddenParentModule::OnInit()
1451 {
1452     ms_hwnd = NULL;
1453     ms_className = NULL;
1454
1455     return true;
1456 }
1457
1458 void wxTLWHiddenParentModule::OnExit()
1459 {
1460     if ( ms_hwnd )
1461     {
1462         if ( !::DestroyWindow(ms_hwnd) )
1463         {
1464             wxLogLastError(wxT("DestroyWindow(hidden TLW parent)"));
1465         }
1466
1467         ms_hwnd = NULL;
1468     }
1469
1470     if ( ms_className )
1471     {
1472         if ( !::UnregisterClass(ms_className, wxGetInstance()) )
1473         {
1474             wxLogLastError(wxT("UnregisterClass(\"wxTLWHiddenParent\")"));
1475         }
1476
1477         ms_className = NULL;
1478     }
1479 }
1480
1481 /* static */
1482 HWND wxTLWHiddenParentModule::GetHWND()
1483 {
1484     if ( !ms_hwnd )
1485     {
1486         if ( !ms_className )
1487         {
1488             static const wxChar *HIDDEN_PARENT_CLASS = wxT("wxTLWHiddenParent");
1489
1490             WNDCLASS wndclass;
1491             wxZeroMemory(wndclass);
1492
1493             wndclass.lpfnWndProc   = DefWindowProc;
1494             wndclass.hInstance     = wxGetInstance();
1495             wndclass.lpszClassName = HIDDEN_PARENT_CLASS;
1496
1497             if ( !::RegisterClass(&wndclass) )
1498             {
1499                 wxLogLastError(wxT("RegisterClass(\"wxTLWHiddenParent\")"));
1500             }
1501             else
1502             {
1503                 ms_className = HIDDEN_PARENT_CLASS;
1504             }
1505         }
1506
1507         ms_hwnd = ::CreateWindow(ms_className, wxEmptyString, 0, 0, 0, 0, 0, NULL,
1508                                  (HMENU)NULL, wxGetInstance(), NULL);
1509         if ( !ms_hwnd )
1510         {
1511             wxLogLastError(wxT("CreateWindow(hidden TLW parent)"));
1512         }
1513     }
1514
1515     return ms_hwnd;
1516 }