]> git.saurik.com Git - wxWidgets.git/blob - src/msw/toplevel.cpp
Implemented delayed closing of an existing document
[wxWidgets.git] / src / msw / toplevel.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: 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 #ifdef __GNUG__
21 #pragma implementation "toplevel.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/app.h"
33 #include "wx/toplevel.h"
34 #include "wx/string.h"
35 #include "wx/log.h"
36 #include "wx/intl.h"
37 #include "wx/frame.h"
38 #include "wx/containr.h" // wxSetFocusToChild()
39 #endif //WX_PRECOMP
40
41 #include "wx/module.h"
42
43 #include "wx/msw/private.h"
44
45 #include "wx/display.h"
46
47 #ifndef ICON_BIG
48 #define ICON_BIG 1
49 #endif
50
51 #ifndef ICON_SMALL
52 #define ICON_SMALL 0
53 #endif
54
55 // ----------------------------------------------------------------------------
56 // stubs for missing functions under MicroWindows
57 // ----------------------------------------------------------------------------
58
59 #ifdef __WXMICROWIN__
60
61 // static inline bool IsIconic(HWND WXUNUSED(hwnd)) { return FALSE; }
62 static inline bool IsZoomed(HWND WXUNUSED(hwnd)) { return FALSE; }
63
64 #endif // __WXMICROWIN__
65
66 // NB: wxDlgProc must be defined here and not in dialog.cpp because the latter
67 // is not included by wxUniv build which does need wxDlgProc
68 LONG APIENTRY _EXPORT
69 wxDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
70
71 // ----------------------------------------------------------------------------
72 // globals
73 // ----------------------------------------------------------------------------
74
75 // list of all frames and modeless dialogs
76 wxWindowList wxModelessWindows;
77
78 // the name of the default wxWindows class
79 extern const wxChar *wxCanvasClassName;
80
81 // ----------------------------------------------------------------------------
82 // wxTLWHiddenParentModule: used to manage the hidden parent window (we need a
83 // module to ensure that the window is always deleted)
84 // ----------------------------------------------------------------------------
85
86 class wxTLWHiddenParentModule : public wxModule
87 {
88 public:
89 // module init/finalize
90 virtual bool OnInit();
91 virtual void OnExit();
92
93 // get the hidden window (creates on demand)
94 static HWND GetHWND();
95
96 private:
97 // the HWND of the hidden parent
98 static HWND ms_hwnd;
99
100 // the class used to create it
101 static const wxChar *ms_className;
102
103 DECLARE_DYNAMIC_CLASS(wxTLWHiddenParentModule)
104 };
105
106 IMPLEMENT_DYNAMIC_CLASS(wxTLWHiddenParentModule, wxModule)
107
108 // ============================================================================
109 // wxTopLevelWindowMSW implementation
110 // ============================================================================
111
112 BEGIN_EVENT_TABLE(wxTopLevelWindowMSW, wxTopLevelWindowBase)
113 EVT_ACTIVATE(wxTopLevelWindowMSW::OnActivate)
114 END_EVENT_TABLE()
115
116 // ----------------------------------------------------------------------------
117 // wxTopLevelWindowMSW creation
118 // ----------------------------------------------------------------------------
119
120 void wxTopLevelWindowMSW::Init()
121 {
122 m_iconized =
123 m_maximizeOnShow = FALSE;
124
125 // unlike (almost?) all other windows, frames are created hidden
126 m_isShown = FALSE;
127
128 // Data to save/restore when calling ShowFullScreen
129 m_fsStyle = 0;
130 m_fsOldWindowStyle = 0;
131 m_fsIsMaximized = FALSE;
132 m_fsIsShowing = FALSE;
133
134 m_winLastFocused = (wxWindow *)NULL;
135 }
136
137 WXDWORD wxTopLevelWindowMSW::MSWGetStyle(long style, WXDWORD *exflags) const
138 {
139 // let the base class deal with the common styles but fix the ones which
140 // don't make sense for us (we also deal with the borders ourselves)
141 WXDWORD msflags = wxWindow::MSWGetStyle
142 (
143 (style & ~wxBORDER_MASK) | wxBORDER_NONE, exflags
144 ) & ~WS_CHILD;
145
146 // first select the kind of window being created
147 //
148 // note that if we don't set WS_POPUP, Windows assumes WS_OVERLAPPED and
149 // creates a window with both caption and border, hence we also test it
150 // below in some other cases
151 if ( style & wxFRAME_TOOL_WINDOW )
152 msflags |= WS_POPUP;
153 else
154 msflags |= WS_OVERLAPPED;
155
156 // border and caption styles
157 if ( style & wxRESIZE_BORDER )
158 msflags |= WS_THICKFRAME;
159 else if ( !(style & wxBORDER_NONE) )
160 msflags |= WS_BORDER;
161 else
162 msflags |= WS_POPUP;
163
164 if ( style & wxCAPTION )
165 msflags |= WS_CAPTION;
166 else
167 msflags |= WS_POPUP;
168
169 // next translate the individual flags
170 if ( style & wxMINIMIZE_BOX )
171 msflags |= WS_MINIMIZEBOX;
172 if ( style & wxMAXIMIZE_BOX )
173 msflags |= WS_MAXIMIZEBOX;
174 if ( style & wxSYSTEM_MENU )
175 msflags |= WS_SYSMENU;
176 if ( style & wxMINIMIZE )
177 msflags |= WS_MINIMIZE;
178 if ( style & wxMAXIMIZE )
179 msflags |= WS_MAXIMIZE;
180
181 // Keep this here because it saves recoding this function in wxTinyFrame
182 #if wxUSE_ITSY_BITSY && !defined(__WIN32__)
183 if ( style & wxTINY_CAPTION_VERT )
184 msflags |= IBS_VERTCAPTION;
185 if ( style & wxTINY_CAPTION_HORIZ )
186 msflags |= IBS_HORZCAPTION;
187 #else
188 if ( style & (wxTINY_CAPTION_VERT | wxTINY_CAPTION_HORIZ) )
189 msflags |= WS_CAPTION;
190 #endif
191
192 if ( exflags )
193 {
194 #if !defined(__WIN16__)
195 if ( !(GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) )
196 {
197 if ( style & wxFRAME_TOOL_WINDOW )
198 {
199 // create the palette-like window
200 *exflags |= WS_EX_TOOLWINDOW;
201 }
202
203 // We have to solve 2 different problems here:
204 //
205 // 1. frames with wxFRAME_NO_TASKBAR flag shouldn't appear in the
206 // taskbar even if they don't have a parent
207 //
208 // 2. frames without this style should appear in the taskbar even
209 // if they're owned (Windows only puts non owned windows into
210 // the taskbar normally)
211 //
212 // The second one is solved here by using WS_EX_APPWINDOW flag, the
213 // first one is dealt with in our MSWGetParent() method
214 // implementation
215 if ( !(style & wxFRAME_NO_TASKBAR) && GetParent() )
216 {
217 // need to force the frame to appear in the taskbar
218 *exflags |= WS_EX_APPWINDOW;
219 }
220 //else: nothing to do [here]
221 }
222 #endif // !Win16
223
224 if ( style & wxSTAY_ON_TOP )
225 *exflags |= WS_EX_TOPMOST;
226
227 #ifdef __WIN32__
228 if ( GetExtraStyle() & wxFRAME_EX_CONTEXTHELP )
229 *exflags |= WS_EX_CONTEXTHELP;
230 #endif // __WIN32__
231 }
232
233 return msflags;
234 }
235
236 WXHWND wxTopLevelWindowMSW::MSWGetParent() const
237 {
238 // for the frames without wxFRAME_FLOAT_ON_PARENT style we should use NULL
239 // parent HWND or it would be always on top of its parent which is not what
240 // we usually want (in fact, we only want it for frames with the
241 // wxFRAME_FLOAT_ON_PARENT flag)
242 HWND hwndParent = NULL;
243 if ( HasFlag(wxFRAME_FLOAT_ON_PARENT) )
244 {
245 const wxWindow *parent = GetParent();
246
247 if ( !parent )
248 {
249 // this flag doesn't make sense then and will be ignored
250 wxFAIL_MSG( _T("wxFRAME_FLOAT_ON_PARENT but no parent?") );
251 }
252 else
253 {
254 hwndParent = GetHwndOf(parent);
255 }
256 }
257 //else: don't float on parent, must not be owned
258
259 // now deal with the 2nd taskbar-related problem (see comments above in
260 // MSWGetStyle())
261 if ( HasFlag(wxFRAME_NO_TASKBAR) && !hwndParent )
262 {
263 // use hidden parent
264 hwndParent = wxTLWHiddenParentModule::GetHWND();
265 }
266
267 return (WXHWND)hwndParent;
268 }
269
270 bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
271 const wxString& title,
272 const wxPoint& pos,
273 const wxSize& size)
274 {
275 #ifdef __WXMICROWIN__
276 // no dialogs support under MicroWin yet
277 return CreateFrame(title, pos, size);
278 #else // !__WXMICROWIN__
279 wxWindow *parent = GetParent();
280
281 // for the dialogs without wxDIALOG_NO_PARENT style, use the top level
282 // app window as parent - this avoids creating modal dialogs without
283 // parent
284 if ( !parent && !(GetWindowStyleFlag() & wxDIALOG_NO_PARENT) )
285 {
286 parent = wxTheApp->GetTopWindow();
287
288 if ( parent )
289 {
290 // don't use transient windows as parents, this is dangerous as it
291 // can lead to a crash if the parent is destroyed before the child
292 //
293 // also don't use the window which is currently hidden as then the
294 // dialog would be hidden as well
295 if ( (parent->GetExtraStyle() & wxWS_EX_TRANSIENT) ||
296 !parent->IsShown() )
297 {
298 parent = NULL;
299 }
300 }
301 }
302
303 m_hWnd = (WXHWND)::CreateDialogIndirect
304 (
305 wxGetInstance(),
306 (DLGTEMPLATE*)dlgTemplate,
307 parent ? GetHwndOf(parent) : NULL,
308 (DLGPROC)wxDlgProc
309 );
310
311 if ( !m_hWnd )
312 {
313 wxFAIL_MSG(wxT("Failed to create dialog. Incorrect DLGTEMPLATE?"));
314
315 wxLogSysError(wxT("Can't create dialog using memory template"));
316
317 return FALSE;
318 }
319
320 WXDWORD exflags;
321 (void)MSWGetCreateWindowFlags(&exflags);
322
323 if ( exflags )
324 {
325 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE, exflags);
326 ::SetWindowPos(GetHwnd(), NULL, 0, 0, 0, 0,
327 SWP_NOSIZE |
328 SWP_NOMOVE |
329 SWP_NOZORDER |
330 SWP_NOACTIVATE);
331 }
332
333 #if defined(__WIN95__)
334 // For some reason, the system menu is activated when we use the
335 // WS_EX_CONTEXTHELP style, so let's set a reasonable icon
336 if ( exflags & WS_EX_CONTEXTHELP )
337 {
338 wxFrame *winTop = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
339 if ( winTop )
340 {
341 wxIcon icon = winTop->GetIcon();
342 if ( icon.Ok() )
343 {
344 ::SendMessage(GetHwnd(), WM_SETICON,
345 (WPARAM)TRUE,
346 (LPARAM)GetHiconOf(icon));
347 }
348 }
349 }
350 #endif // __WIN95__
351
352 // move the dialog to its initial position without forcing repainting
353 int x, y, w, h;
354 if ( !MSWGetCreateWindowCoords(pos, size, x, y, w, h) )
355 {
356 x =
357 w = (int)CW_USEDEFAULT;
358 }
359
360 // we can't use CW_USEDEFAULT here as we're not calling CreateWindow()
361 // and passing CW_USEDEFAULT to MoveWindow() results in resizing the
362 // window to (0, 0) size which breaks quite a lot of things, e.g. the
363 // sizer calculation in wxSizer::Fit()
364 if ( w == (int)CW_USEDEFAULT )
365 {
366 // the exact number doesn't matter, the dialog will be resized
367 // again soon anyhow but it should be big enough to allow
368 // calculation relying on "totalSize - clientSize > 0" work, i.e.
369 // at least greater than the title bar height
370 w =
371 h = 100;
372 }
373
374 if ( x == (int)CW_USEDEFAULT )
375 {
376 // centre it on the screen - what else can we do?
377 wxSize sizeDpy = wxGetDisplaySize();
378
379 x = (sizeDpy.x - w) / 2;
380 y = (sizeDpy.y - h) / 2;
381 }
382
383 if ( !::MoveWindow(GetHwnd(), x, y, w, h, FALSE) )
384 {
385 wxLogLastError(wxT("MoveWindow"));
386 }
387
388 if ( !title.empty() )
389 {
390 ::SetWindowText(GetHwnd(), title);
391 }
392
393 SubclassWin(m_hWnd);
394
395 return TRUE;
396 #endif // __WXMICROWIN__/!__WXMICROWIN__
397 }
398
399 bool wxTopLevelWindowMSW::CreateFrame(const wxString& title,
400 const wxPoint& pos,
401 const wxSize& size)
402 {
403 WXDWORD exflags;
404 WXDWORD flags = MSWGetCreateWindowFlags(&exflags);
405
406 return MSWCreate(wxCanvasClassName, title, pos, size, flags, exflags);
407 }
408
409 bool wxTopLevelWindowMSW::Create(wxWindow *parent,
410 wxWindowID id,
411 const wxString& title,
412 const wxPoint& pos,
413 const wxSize& size,
414 long style,
415 const wxString& name)
416 {
417 bool ret = false;
418
419 // init our fields
420 Init();
421
422 m_windowStyle = style;
423
424 SetName(name);
425
426 m_windowId = id == -1 ? NewControlId() : id;
427
428 wxTopLevelWindows.Append(this);
429
430 if ( parent )
431 parent->AddChild(this);
432
433 if ( GetExtraStyle() & wxTOPLEVEL_EX_DIALOG )
434 {
435 // we have different dialog templates to allows creation of dialogs
436 // with & without captions under MSWindows, resizeable or not (but a
437 // resizeable dialog always has caption - otherwise it would look too
438 // strange)
439
440 // we need 3 additional WORDs for dialog menu, class and title (as we
441 // don't use DS_SETFONT we don't need the fourth WORD for the font)
442 static const int dlgsize = sizeof(DLGTEMPLATE) + (sizeof(WORD) * 3);
443 DLGTEMPLATE *dlgTemplate = (DLGTEMPLATE *)malloc(dlgsize);
444 memset(dlgTemplate, 0, dlgsize);
445
446 // these values are arbitrary, they won't be used normally anyhow
447 dlgTemplate->x = 34;
448 dlgTemplate->y = 22;
449 dlgTemplate->cx = 144;
450 dlgTemplate->cy = 75;
451
452 // reuse the code in MSWGetStyle() but correct the results slightly for
453 // the dialog
454 dlgTemplate->style = MSWGetStyle(style, NULL);
455
456 // all dialogs are popups
457 dlgTemplate->style |= WS_POPUP;
458
459 // force 3D-look if necessary, it looks impossibly ugly otherwise
460 if ( style & (wxRESIZE_BORDER | wxCAPTION) )
461 dlgTemplate->style |= DS_MODALFRAME;
462
463 ret = CreateDialog(dlgTemplate, title, pos, size);
464 free(dlgTemplate);
465 }
466 else // !dialog
467 {
468 ret = CreateFrame(title, pos, size);
469 }
470
471 if ( ret && !(GetWindowStyleFlag() & wxCLOSE_BOX) )
472 {
473 EnableCloseButton(false);
474 }
475
476 return ret;
477 }
478
479 wxTopLevelWindowMSW::~wxTopLevelWindowMSW()
480 {
481 if ( wxModelessWindows.Find(this) )
482 wxModelessWindows.DeleteObject(this);
483
484 // after destroying an owned window, Windows activates the next top level
485 // window in Z order but it may be different from our owner (to reproduce
486 // this simply Alt-TAB to another application and back before closing the
487 // owned frame) whereas we always want to yield activation to our parent
488 if ( HasFlag(wxFRAME_FLOAT_ON_PARENT) )
489 {
490 wxWindow *parent = GetParent();
491 if ( parent )
492 {
493 ::BringWindowToTop(GetHwndOf(parent));
494 }
495 }
496 }
497
498 // ----------------------------------------------------------------------------
499 // wxTopLevelWindowMSW showing
500 // ----------------------------------------------------------------------------
501
502 void wxTopLevelWindowMSW::DoShowWindow(int nShowCmd)
503 {
504 ::ShowWindow(GetHwnd(), nShowCmd);
505
506 m_iconized = nShowCmd == SW_MINIMIZE;
507 }
508
509 bool wxTopLevelWindowMSW::Show(bool show)
510 {
511 // don't use wxWindow version as we want to call DoShowWindow() ourselves
512 if ( !wxWindowBase::Show(show) )
513 return FALSE;
514
515 int nShowCmd;
516 if ( show )
517 {
518 if ( m_maximizeOnShow )
519 {
520 // show and maximize
521 nShowCmd = SW_MAXIMIZE;
522
523 m_maximizeOnShow = FALSE;
524 }
525 else // just show
526 {
527 if ( GetWindowStyle() & wxFRAME_TOOL_WINDOW )
528 nShowCmd = SW_SHOWNA;
529 else
530 nShowCmd = SW_SHOW;
531 }
532 }
533 else // hide
534 {
535 nShowCmd = SW_HIDE;
536 }
537
538 DoShowWindow(nShowCmd);
539
540 if ( show )
541 {
542 ::BringWindowToTop(GetHwnd());
543
544 wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_windowId);
545 event.SetEventObject( this );
546 GetEventHandler()->ProcessEvent(event);
547 }
548 else // hide
549 {
550 // Try to highlight the correct window (the parent)
551 if ( GetParent() )
552 {
553 HWND hWndParent = GetHwndOf(GetParent());
554 if (hWndParent)
555 ::BringWindowToTop(hWndParent);
556 }
557 }
558
559 return TRUE;
560 }
561
562 // ----------------------------------------------------------------------------
563 // wxTopLevelWindowMSW maximize/minimize
564 // ----------------------------------------------------------------------------
565
566 void wxTopLevelWindowMSW::Maximize(bool maximize)
567 {
568 if ( IsShown() )
569 {
570 // just maximize it directly
571 DoShowWindow(maximize ? SW_MAXIMIZE : SW_RESTORE);
572 }
573 else // hidden
574 {
575 // we can't maximize the hidden frame because it shows it as well, so
576 // just remember that we should do it later in this case
577 m_maximizeOnShow = maximize;
578 }
579 }
580
581 bool wxTopLevelWindowMSW::IsMaximized() const
582 {
583 return ::IsZoomed(GetHwnd()) != 0;
584 }
585
586 void wxTopLevelWindowMSW::Iconize(bool iconize)
587 {
588 DoShowWindow(iconize ? SW_MINIMIZE : SW_RESTORE);
589 }
590
591 bool wxTopLevelWindowMSW::IsIconized() const
592 {
593 // also update the current state
594 ((wxTopLevelWindowMSW *)this)->m_iconized = ::IsIconic(GetHwnd()) != 0;
595
596 return m_iconized;
597 }
598
599 void wxTopLevelWindowMSW::Restore()
600 {
601 DoShowWindow(SW_RESTORE);
602 }
603
604 // ----------------------------------------------------------------------------
605 // wxTopLevelWindowMSW fullscreen
606 // ----------------------------------------------------------------------------
607
608 bool wxTopLevelWindowMSW::ShowFullScreen(bool show, long style)
609 {
610 if ( show == IsFullScreen() )
611 {
612 // nothing to do
613 return TRUE;
614 }
615
616 m_fsIsShowing = show;
617
618 if ( show )
619 {
620 m_fsStyle = style;
621
622 // zap the frame borders
623
624 // save the 'normal' window style
625 m_fsOldWindowStyle = GetWindowLong(GetHwnd(), GWL_STYLE);
626
627 // save the old position, width & height, maximize state
628 m_fsOldSize = GetRect();
629 m_fsIsMaximized = IsMaximized();
630
631 // decide which window style flags to turn off
632 LONG newStyle = m_fsOldWindowStyle;
633 LONG offFlags = 0;
634
635 if (style & wxFULLSCREEN_NOBORDER)
636 offFlags |= WS_BORDER | WS_THICKFRAME;
637 if (style & wxFULLSCREEN_NOCAPTION)
638 offFlags |= WS_CAPTION | WS_SYSMENU;
639
640 newStyle &= ~offFlags;
641
642 // change our window style to be compatible with full-screen mode
643 ::SetWindowLong(GetHwnd(), GWL_STYLE, newStyle);
644
645 wxRect rect;
646 #if wxUSE_DISPLAY
647 // resize to the size of the display containing us
648 int dpy = wxDisplay::GetFromWindow(this);
649 if ( dpy != wxNOT_FOUND )
650 {
651 rect = wxDisplay(dpy).GetGeometry();
652 }
653 else // fall back to the main desktop
654 #else // wxUSE_DISPLAY
655 {
656 // resize to the size of the desktop
657 wxCopyRECTToRect(wxGetWindowRect(::GetDesktopWindow()), rect);
658 }
659 #endif // wxUSE_DISPLAY
660
661 SetSize(rect);
662
663 // now flush the window style cache and actually go full-screen
664 long flags = SWP_FRAMECHANGED;
665
666 // showing the frame full screen should also show it if it's still
667 // hidden
668 if ( !IsShown() )
669 {
670 // don't call wxWindow version to avoid flicker from calling
671 // ::ShowWindow() -- we're going to show the window at the correct
672 // location directly below -- but do call the wxWindowBase version
673 // to sync the internal m_isShown flag
674 wxWindowBase::Show();
675
676 flags |= SWP_SHOWWINDOW;
677 }
678
679 SetWindowPos(GetHwnd(), HWND_TOP,
680 rect.x, rect.y, rect.width, rect.height,
681 flags);
682
683 // finally send an event allowing the window to relayout itself &c
684 wxSizeEvent event(rect.GetSize(), GetId());
685 GetEventHandler()->ProcessEvent(event);
686 }
687 else // stop showing full screen
688 {
689 Maximize(m_fsIsMaximized);
690 SetWindowLong(GetHwnd(),GWL_STYLE, m_fsOldWindowStyle);
691 SetWindowPos(GetHwnd(),HWND_TOP,m_fsOldSize.x, m_fsOldSize.y,
692 m_fsOldSize.width, m_fsOldSize.height, SWP_FRAMECHANGED);
693 }
694
695 return TRUE;
696 }
697
698 // ----------------------------------------------------------------------------
699 // wxTopLevelWindowMSW misc
700 // ----------------------------------------------------------------------------
701
702 void wxTopLevelWindowMSW::SetIcon(const wxIcon& icon)
703 {
704 SetIcons( wxIconBundle( icon ) );
705 }
706
707 void wxTopLevelWindowMSW::SetIcons(const wxIconBundle& icons)
708 {
709 wxTopLevelWindowBase::SetIcons(icons);
710
711 #if defined(__WIN95__) && !defined(__WXMICROWIN__)
712 const wxIcon& sml = icons.GetIcon( wxSize( 16, 16 ) );
713 if( sml.Ok() && sml.GetWidth() == 16 && sml.GetHeight() == 16 )
714 {
715 ::SendMessage( GetHwndOf( this ), WM_SETICON, ICON_SMALL,
716 (LPARAM)GetHiconOf(sml) );
717 }
718
719 const wxIcon& big = icons.GetIcon( wxSize( 32, 32 ) );
720 if( big.Ok() && big.GetWidth() == 32 && big.GetHeight() == 32 )
721 {
722 ::SendMessage( GetHwndOf( this ), WM_SETICON, ICON_BIG,
723 (LPARAM)GetHiconOf(big) );
724 }
725 #endif // __WIN95__
726 }
727
728 bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
729 {
730 #ifndef __WXMICROWIN__
731 // get system (a.k.a. window) menu
732 HMENU hmenu = ::GetSystemMenu(GetHwnd(), FALSE /* get it */);
733 if ( !hmenu )
734 {
735 wxLogLastError(_T("GetSystemMenu"));
736
737 return FALSE;
738 }
739
740 // enabling/disabling the close item from it also automatically
741 // disables/enables the close title bar button
742 if ( ::EnableMenuItem(hmenu, SC_CLOSE,
743 MF_BYCOMMAND |
744 (enable ? MF_ENABLED : MF_GRAYED)) == -1 )
745 {
746 wxLogLastError(_T("EnableMenuItem(SC_CLOSE)"));
747
748 return FALSE;
749 }
750
751 // update appearance immediately
752 if ( !::DrawMenuBar(GetHwnd()) )
753 {
754 wxLogLastError(_T("DrawMenuBar"));
755 }
756 #endif // !__WXMICROWIN__
757
758 return TRUE;
759 }
760
761 bool wxTopLevelWindowMSW::SetShape(const wxRegion& region)
762 {
763 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE,
764 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
765
766 // The empty region signifies that the shape should be removed from the
767 // window.
768 if ( region.IsEmpty() )
769 {
770 if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0)
771 {
772 wxLogLastError(_T("SetWindowRgn"));
773 return FALSE;
774 }
775 return TRUE;
776 }
777
778 // Windows takes ownership of the region, so
779 // we'll have to make a copy of the region to give to it.
780 DWORD noBytes = ::GetRegionData(GetHrgnOf(region), 0, NULL);
781 RGNDATA *rgnData = (RGNDATA*) new char[noBytes];
782 ::GetRegionData(GetHrgnOf(region), noBytes, rgnData);
783 HRGN hrgn = ::ExtCreateRegion(NULL, noBytes, rgnData);
784 delete[] (char*) rgnData;
785
786 // SetWindowRgn expects the region to be in coordinants
787 // relative to the window, not the client area. Figure
788 // out the offset, if any.
789 RECT rect;
790 DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
791 DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
792 ::GetClientRect(GetHwnd(), &rect);
793 ::AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle);
794 ::OffsetRgn(hrgn, -rect.left, -rect.top);
795
796 // Now call the shape API with the new region.
797 if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0)
798 {
799 wxLogLastError(_T("SetWindowRgn"));
800 return FALSE;
801 }
802 return TRUE;
803 }
804
805 // ----------------------------------------------------------------------------
806 // wxTopLevelWindow event handling
807 // ----------------------------------------------------------------------------
808
809 // Default activation behaviour - set the focus for the first child
810 // subwindow found.
811 void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
812 {
813 if ( event.GetActive() )
814 {
815 // restore focus to the child which was last focused
816 wxLogTrace(_T("focus"), _T("wxTLW %08x activated."), (int) m_hWnd);
817
818 wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent()
819 : NULL;
820 if ( !parent )
821 {
822 parent = this;
823 }
824
825 wxSetFocusToChild(parent, &m_winLastFocused);
826 }
827 else // deactivating
828 {
829 // remember the last focused child if it is our child
830 m_winLastFocused = FindFocus();
831
832 if ( m_winLastFocused )
833 {
834 // let it know that it doesn't have focus any more
835 m_winLastFocused->HandleKillFocus((WXHWND)NULL);
836 }
837
838 // so we NULL it out if it's a child from some other frame
839 wxWindow *win = m_winLastFocused;
840 while ( win )
841 {
842 if ( win->IsTopLevel() )
843 {
844 if ( win != this )
845 {
846 m_winLastFocused = NULL;
847 }
848
849 break;
850 }
851
852 win = win->GetParent();
853 }
854
855 wxLogTrace(_T("focus"),
856 _T("wxTLW %08x deactivated, last focused: %08x."),
857 (int) m_hWnd,
858 (int) (m_winLastFocused ? GetHwndOf(m_winLastFocused)
859 : NULL));
860
861 event.Skip();
862 }
863 }
864
865 // the DialogProc for all wxWindows dialogs
866 LONG APIENTRY _EXPORT
867 wxDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
868 {
869 switch ( message )
870 {
871 case WM_INITDIALOG:
872 // for this message, returning TRUE tells system to set focus to
873 // the first control in the dialog box, but as we set the focus
874 // ourselves, we return FALSE from here as well, so fall through
875
876 default:
877 // for all the other ones, FALSE means that we didn't process the
878 // message
879 return FALSE;
880 }
881 }
882
883 // ============================================================================
884 // wxTLWHiddenParentModule implementation
885 // ============================================================================
886
887 HWND wxTLWHiddenParentModule::ms_hwnd = NULL;
888
889 const wxChar *wxTLWHiddenParentModule::ms_className = NULL;
890
891 bool wxTLWHiddenParentModule::OnInit()
892 {
893 ms_hwnd = NULL;
894 ms_className = NULL;
895
896 return TRUE;
897 }
898
899 void wxTLWHiddenParentModule::OnExit()
900 {
901 if ( ms_hwnd )
902 {
903 if ( !::DestroyWindow(ms_hwnd) )
904 {
905 wxLogLastError(_T("DestroyWindow(hidden TLW parent)"));
906 }
907
908 ms_hwnd = NULL;
909 }
910
911 if ( ms_className )
912 {
913 if ( !::UnregisterClass(ms_className, wxGetInstance()) )
914 {
915 wxLogLastError(_T("UnregisterClass(\"wxTLWHiddenParent\")"));
916 }
917
918 ms_className = NULL;
919 }
920 }
921
922 /* static */
923 HWND wxTLWHiddenParentModule::GetHWND()
924 {
925 if ( !ms_hwnd )
926 {
927 if ( !ms_className )
928 {
929 static const wxChar *HIDDEN_PARENT_CLASS = _T("wxTLWHiddenParent");
930
931 WNDCLASS wndclass;
932 wxZeroMemory(wndclass);
933
934 wndclass.lpfnWndProc = DefWindowProc;
935 wndclass.hInstance = wxGetInstance();
936 wndclass.lpszClassName = HIDDEN_PARENT_CLASS;
937
938 if ( !::RegisterClass(&wndclass) )
939 {
940 wxLogLastError(_T("RegisterClass(\"wxTLWHiddenParent\")"));
941 }
942 else
943 {
944 ms_className = HIDDEN_PARENT_CLASS;
945 }
946 }
947
948 ms_hwnd = ::CreateWindow(ms_className, _T(""), 0, 0, 0, 0, 0, NULL,
949 (HMENU)NULL, wxGetInstance(), NULL);
950 if ( !ms_hwnd )
951 {
952 wxLogLastError(_T("CreateWindow(hidden TLW parent)"));
953 }
954 }
955
956 return ms_hwnd;
957 }
958
959