src/msw/toplevel.cpp

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