bool wxTopLevelWindowMSW::IsMaximized() const
{
return IsAlwaysMaximized() ||
#if !defined(__SMARTPHONE__) && !defined(__POCKETPC__) && !defined(__WINCE_STANDARDSDK__)
(::IsZoomed(GetHwnd()) != 0) ||
#endif
m_maximizeOnShow;
}
MyChild::MyChild(wxMDIParentFrame *parent)
: wxMDIChildFrame
(
parent,
wxID_ANY,
wxString::Format("Child %u", ++ms_numChildren)
),
MenuEventLogger("child", this)
{
m_canvas = new MyCanvas(this, wxPoint(0, 0), GetClientSize());
SetIcon(wxICON(chart));
const bool canBeResized = !IsAlwaysMaximized();
// create our menu bar: it will be shown instead of the main frame one when
// we're active
#if wxUSE_MENUS
wxMenuBar *mbar = MyFrame::CreateMainMenubar();
mbar->GetMenu(0)->Insert(1, wxID_CLOSE, "&Close child\tCtrl-W",
"Close this window");
wxMenu *menuChild = new wxMenu;
menuChild->Append(MDI_REFRESH, "&Refresh picture");
menuChild->Append(MDI_CHANGE_TITLE, "Change &title...\tCtrl-T");
if ( canBeResized )
{
menuChild->AppendSeparator();
menuChild->Append(MDI_CHANGE_POSITION, "Move frame\tCtrl-M");
menuChild->Append(MDI_CHANGE_SIZE, "Resize frame\tCtrl-S");
}
#if wxUSE_CLIPBOARD
menuChild->AppendSeparator();
menuChild->Append(wxID_PASTE, "Copy text from clipboard\tCtrl-V");
#endif // wxUSE_CLIPBOARD
mbar->Insert(1, menuChild, "&Child");
// Associate the menu bar with the frame
SetMenuBar(mbar);
#endif // wxUSE_MENUS
// this should work for MDI frames as well as for normal ones, provided
// they can be resized at all
if ( canBeResized )
SetSizeHints(100, 100);
// test that event handlers pushed on top of MDI children do work (this
// used to be broken, see #11225)
PushEventHandler(new EventHandler(ms_numChildren));
}
bool wxTopLevelWindowMSW::CreateFrame(const wxString& title,
const wxPoint& pos,
const wxSize& size)
{
WXDWORD exflags;
WXDWORD flags = MSWGetCreateWindowFlags(&exflags);
const wxSize sz = IsAlwaysMaximized() ? wxDefaultSize : size;
if ( wxApp::MSWGetDefaultLayout(m_parent) == wxLayout_RightToLeft )
exflags |= WS_EX_LAYOUTRTL;
return MSWCreate(MSWGetRegisteredClassName(),
title.t_str(), pos, sz, flags, exflags);
}
bool wxTopLevelWindowMSW::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
wxSize sizeReal = size;
if ( !sizeReal.IsFullySpecified() )
{
sizeReal.SetDefaults(GetDefaultSize());
}
// notice that we should append this window to wxTopLevelWindows list
// before calling CreateBase() as it behaves differently for TLW and
// non-TLW windows
wxTopLevelWindows.Append(this);
bool ret = CreateBase(parent, id, pos, sizeReal, style, name);
if ( !ret )
return false;
if ( parent )
parent->AddChild(this);
if ( GetExtraStyle() & wxTOPLEVEL_EX_DIALOG )
{
// we have different dialog templates to allows creation of dialogs
// with & without captions under MSWindows, resizable or not (but a
// resizable dialog always has caption - otherwise it would look too
// strange)
// we need 3 additional WORDs for dialog menu, class and title (as we
// don't use DS_SETFONT we don't need the fourth WORD for the font)
static const int dlgsize = sizeof(DLGTEMPLATE) + (sizeof(WORD) * 3);
DLGTEMPLATE *dlgTemplate = (DLGTEMPLATE *)malloc(dlgsize);
memset(dlgTemplate, 0, dlgsize);
// these values are arbitrary, they won't be used normally anyhow
dlgTemplate->x = 34;
dlgTemplate->y = 22;
dlgTemplate->cx = 144;
dlgTemplate->cy = 75;
// reuse the code in MSWGetStyle() but correct the results slightly for
// the dialog
//
// NB: we need a temporary variable as we can't pass pointer to
// dwExtendedStyle directly, it's not aligned correctly for 64 bit
// architectures
WXDWORD dwExtendedStyle;
dlgTemplate->style = MSWGetStyle(style, &dwExtendedStyle);
dlgTemplate->dwExtendedStyle = dwExtendedStyle;
// all dialogs are popups
dlgTemplate->style |= WS_POPUP;
#ifndef __WXWINCE__
if ( wxApp::MSWGetDefaultLayout(m_parent) == wxLayout_RightToLeft )
{
dlgTemplate->dwExtendedStyle |= WS_EX_LAYOUTRTL;
}
// force 3D-look if necessary, it looks impossibly ugly otherwise
if ( style & (wxRESIZE_BORDER | wxCAPTION) )
dlgTemplate->style |= DS_MODALFRAME;
#endif
ret = CreateDialog(dlgTemplate, title, pos, sizeReal);
free(dlgTemplate);
}
else // !dialog
{
ret = CreateFrame(title, pos, sizeReal);
}
#ifndef __WXWINCE__
if ( ret && !(GetWindowStyleFlag() & wxCLOSE_BOX) )
{
EnableCloseButton(false);
}
#endif
// for standard dialogs the dialog manager generates WM_CHANGEUISTATE
// itself but for custom windows we have to do it ourselves in order to
// make the keyboard indicators (such as underlines for accelerators and
// focus rectangles) work under Win2k+
if ( ret )
{
MSWUpdateUIState(UIS_INITIALIZE);
}
// Note: if we include PocketPC in this test, dialogs can fail to show up,
// for example the text entry dialog in the dialogs sample. Problem with Maximise()?
#if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__WINCE_STANDARDSDK__))
if ( ( style & wxMAXIMIZE ) || IsAlwaysMaximized() )
{
this->Maximize();
}
#endif
#if defined(__SMARTPHONE__) && defined(__WXWINCE__)
SetRightMenu(); // to nothing for initialization
#endif
return ret;
}
WXDWORD wxTopLevelWindowMSW::MSWGetStyle(long style, WXDWORD *exflags) const
{
// let the base class deal with the common styles but fix the ones which
// don't make sense for us (we also deal with the borders ourselves)
WXDWORD msflags = wxWindow::MSWGetStyle
(
(style & ~wxBORDER_MASK) | wxBORDER_NONE, exflags
) & ~WS_CHILD & ~WS_VISIBLE;
// For some reason, WS_VISIBLE needs to be defined on creation for
// SmartPhone 2003. The title can fail to be displayed otherwise.
#if defined(__SMARTPHONE__) || (defined(__WXWINCE__) && _WIN32_WCE < 400)
msflags |= WS_VISIBLE;
((wxTopLevelWindowMSW*)this)->wxWindowBase::Show(true);
#endif
// first select the kind of window being created
//
// note that if we don't set WS_POPUP, Windows assumes WS_OVERLAPPED and
// creates a window with both caption and border, hence we need to use
// WS_POPUP in a few cases just to avoid having caption/border which we
// don't want
// border and caption styles
if ( ( style & wxRESIZE_BORDER ) && !IsAlwaysMaximized())
msflags |= WS_THICKFRAME;
else if ( exflags && ((style & wxBORDER_DOUBLE) || (style & wxBORDER_RAISED)) )
*exflags |= WS_EX_DLGMODALFRAME;
else if ( !(style & wxBORDER_NONE) )
msflags |= WS_BORDER;
#ifndef __POCKETPC__
else
msflags |= WS_POPUP;
#endif
// normally we consider that all windows without a caption must be popups,
// but CE is an exception: there windows normally do not have the caption
// but shouldn't be made popups as popups can't have menus and don't look
// like normal windows anyhow
// TODO: Smartphone appears to like wxCAPTION, but we should check that
// we need it.
#if defined(__SMARTPHONE__) || !defined(__WXWINCE__)
if ( style & wxCAPTION )
msflags |= WS_CAPTION;
#ifndef __WXWINCE__
else
msflags |= WS_POPUP;
#endif // !__WXWINCE__
#endif
// next translate the individual flags
// WS_EX_CONTEXTHELP is incompatible with WS_MINIMIZEBOX and WS_MAXIMIZEBOX
// and is ignored if we specify both of them, but chances are that if we
// use wxWS_EX_CONTEXTHELP, we really do want to have the context help
// button while wxMINIMIZE/wxMAXIMIZE are included by default, so the help
// takes precedence
if ( !(GetExtraStyle() & wxWS_EX_CONTEXTHELP) )
{
if ( style & wxMINIMIZE_BOX )
msflags |= WS_MINIMIZEBOX;
if ( style & wxMAXIMIZE_BOX )
msflags |= WS_MAXIMIZEBOX;
}
#ifndef __WXWINCE__
// notice that if wxCLOSE_BOX is specified we need to use WS_SYSMENU too as
// otherwise the close box doesn't appear
if ( style & (wxSYSTEM_MENU | wxCLOSE_BOX) )
msflags |= WS_SYSMENU;
#endif // !__WXWINCE__
// NB: under CE these 2 styles are not supported currently, we should
// call Minimize()/Maximize() "manually" if we want to support them
if ( style & wxMINIMIZE )
msflags |= WS_MINIMIZE;
if ( style & wxMAXIMIZE )
msflags |= WS_MAXIMIZE;
// Keep this here because it saves recoding this function in wxTinyFrame
if ( style & wxTINY_CAPTION )
msflags |= WS_CAPTION;
if ( exflags )
{
// there is no taskbar under CE, so omit all this
#if !defined(__WXWINCE__)
if ( !(GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) )
{
if ( style & wxFRAME_TOOL_WINDOW )
{
// create the palette-like window
*exflags |= WS_EX_TOOLWINDOW;
// tool windows shouldn't appear on the taskbar (as documented)
style |= wxFRAME_NO_TASKBAR;
}
// We have to solve 2 different problems here:
//
// 1. frames with wxFRAME_NO_TASKBAR flag shouldn't appear in the
// taskbar even if they don't have a parent
//
// 2. frames without this style should appear in the taskbar even
// if they're owned (Windows only puts non owned windows into
// the taskbar normally)
//
// The second one is solved here by using WS_EX_APPWINDOW flag, the
// first one is dealt with in our MSWGetParent() method
// implementation
if ( !(style & wxFRAME_NO_TASKBAR) && GetParent() )
{
// need to force the frame to appear in the taskbar
*exflags |= WS_EX_APPWINDOW;
}
//else: nothing to do [here]
}
if ( GetExtraStyle() & wxWS_EX_CONTEXTHELP )
*exflags |= WS_EX_CONTEXTHELP;
#endif // !__WXWINCE__
if ( style & wxSTAY_ON_TOP )
*exflags |= WS_EX_TOPMOST;
}
return msflags;
}
void wxTopLevelWindowBase::DoCentre(int dir)
{
// on some platforms centering top level windows is impossible
// because they are always maximized by guidelines or limitations
//
// and centering a maximized window doesn't make sense as its position
// can't change
if ( IsAlwaysMaximized() || IsMaximized() )
return;
// we need the display rect anyhow so store it first: notice that we should
// be centered on the same display as our parent window, the display of
// this window itself is not really defined yet
int nDisplay = wxDisplay::GetFromWindow(GetParent() ? GetParent() : this);
wxDisplay dpy(nDisplay == wxNOT_FOUND ? 0 : nDisplay);
const wxRect rectDisplay(dpy.GetClientArea());
// what should we centre this window on?
wxRect rectParent;
if ( !(dir & wxCENTRE_ON_SCREEN) && GetParent() )
{
// centre on parent window: notice that we need screen coordinates for
// positioning this TLW
rectParent = GetParent()->GetScreenRect();
// if the parent is entirely off screen (happens at least with MDI
// parent frame under Mac but could happen elsewhere too if the frame
// was hidden/moved away for some reason), don't use it as otherwise
// this window wouldn't be visible at all
if ( !rectParent.Intersects(rectDisplay) )
{
// just centre on screen then
rectParent = rectDisplay;
}
}
else
{
// we were explicitly asked to centre this window on the entire screen
// or if we have no parent anyhow and so can't centre on it
rectParent = rectDisplay;
}
if ( !(dir & wxBOTH) )
dir |= wxBOTH; // if neither is specified, center in both directions
// the new window rect candidate
wxRect rect = GetRect().CentreIn(rectParent, dir & ~wxCENTRE_ON_SCREEN);
// we don't want to place the window off screen if Centre() is called as
// this is (almost?) never wanted and it would be very difficult to prevent
// it from happening from the user code if we didn't check for it here
if ( !rectDisplay.Contains(rect.GetTopLeft()) )
{
// move the window just enough to make the corner visible
int dx = rectDisplay.GetLeft() - rect.GetLeft();
int dy = rectDisplay.GetTop() - rect.GetTop();
rect.Offset(dx > 0 ? dx : 0, dy > 0 ? dy : 0);
}
if ( !rectDisplay.Contains(rect.GetBottomRight()) )
{
// do the same for this corner too
int dx = rectDisplay.GetRight() - rect.GetRight();
int dy = rectDisplay.GetBottom() - rect.GetBottom();
rect.Offset(dx < 0 ? dx : 0, dy < 0 ? dy : 0);
}
// the window top left and bottom right corner are both visible now and
// although the window might still be not entirely on screen (with 2
// staggered displays for example) we wouldn't be able to improve the
// layout much in such case, so we stop here
// -1 could be valid coordinate here if there are several displays
SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);
}
bool wxTopLevelWindowMSW::IsMaximized() const
{
return IsAlwaysMaximized() ||
(::IsZoomed(GetHwnd()) != 0) ||
m_maximizeOnShow;
}
