///////////////////////////////////////////////////////////////////////////////
-// Name: msw/toplevel.cpp
-// Purpose: implements wxTopLevelWindow for MSW
+// Name: src/os2/toplevel.cpp
+// Purpose: implements wxTopLevelWindow for OS/2
// Author: Vadim Zeitlin
// Modified by:
// Created: 30.12.01
// RCS-ID: $Id$
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
-// License: wxWindows license
+// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "toplevel.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#pragma hdrstop
#endif
+#include "wx/toplevel.h"
+
#ifndef WX_PRECOMP
#include "wx/app.h"
- #include "wx/toplevel.h"
+ #include "wx/dialog.h"
#include "wx/string.h"
#include "wx/log.h"
#include "wx/intl.h"
#include "wx/frame.h"
#include "wx/control.h"
+ #include "wx/containr.h" // wxSetFocusToChild()
+ #include "wx/settings.h"
+ #include "wx/module.h" // wxSetFocusToChild()
#endif //WX_PRECOMP
#include "wx/os2/private.h"
// globals
// ----------------------------------------------------------------------------
-// list of all frames and modeless dialogs
-wxWindowList wxModelessWindows;
+// the name of the default wxWidgets class
+extern void wxAssociateWinWithHandle( HWND hWnd, wxWindowOS2* pWin );
+
+bool wxTopLevelWindowOS2::m_sbInitialized = false;
+wxWindow* wxTopLevelWindowOS2::m_spHiddenParent = NULL;
+
+// ============================================================================
+// wxTopLevelWindowOS2 implementation
+// ============================================================================
-// the name of the default wxWindows class
-extern void wxAssociateWinWithHandle( HWND hWnd
- ,wxWindowOS2* pWin
- );
+BEGIN_EVENT_TABLE(wxTopLevelWindowOS2, wxTopLevelWindowBase)
+ EVT_ACTIVATE(wxTopLevelWindowOS2::OnActivate)
+END_EVENT_TABLE()
// ============================================================================
// wxTopLevelWindowMSW implementation
// Dialog window proc
MRESULT EXPENTRY wxDlgProc( HWND WXUNUSED(hWnd)
,UINT uMessage
- ,MPARAM WXUNUSED(wParam)
- ,MPARAM WXUNUSED(lParam)
+ ,void * WXUNUSED(wParam)
+ ,void * WXUNUSED(lParam)
)
{
- if (uMessage == WM_INITDLG)
+ switch(uMessage)
{
- //
- // For this message, returning TRUE tells system to set focus to the
- // first control in the dialog box.
- //
- return (MRESULT)TRUE;
- }
- else
- {
- //
- // For all the other ones, FALSE means that we didn't process the
- // message
- //
- return (MRESULT)FALSE;
+ case WM_INITDLG:
+ //
+ // For this message, returning TRUE tells system to set focus to
+ // the first control in the dialog box, but we set the focus
+ // ourselves, however in OS/2 we must return true to enable the dialog
+ //
+ return (MRESULT)TRUE;
+ default:
+ //
+ // For all the other ones, FALSE means that we didn't process the
+ // message
+ //
+ return (MRESULT)FALSE;
}
} // end of wxDlgProc
+// ----------------------------------------------------------------------------
+// wxTLWHiddenParentModule: used to manage the hidden parent window (we need a
+// module to ensure that the window is always deleted)
+// ----------------------------------------------------------------------------
+
+class wxTLWHiddenParentModule : public wxModule
+{
+public:
+ //
+ // Module init/finalize
+ //
+ virtual bool OnInit(void);
+ virtual void OnExit(void);
+
+ //
+ // Get the hidden window (creates on demand)
+ //
+ static HWND GetHWND(void);
+
+private:
+ //
+ // The HWND of the hidden parent
+ //
+ static HWND m_shWnd;
+
+ //
+ // The class used to create it
+ //
+ static const wxChar* m_szClassName;
+ DECLARE_DYNAMIC_CLASS(wxTLWHiddenParentModule)
+}; // end of CLASS wxTLWHiddenParentModule
+
+IMPLEMENT_DYNAMIC_CLASS(wxTLWHiddenParentModule, wxModule)
+
// ----------------------------------------------------------------------------
// wxTopLevelWindowOS2 creation
// ----------------------------------------------------------------------------
void wxTopLevelWindowOS2::Init()
{
- m_bIconized = m_bMaximizeOnShow = FALSE;
+ m_bIconized = m_bMaximizeOnShow = false;
//
// Unlike (almost?) all other windows, frames are created hidden
//
- m_isShown = FALSE;
+ m_isShown = false;
//
// Data to save/restore when calling ShowFullScreen
m_lFsStyle = 0;
m_lFsOldWindowStyle = 0;
- m_bFsIsMaximized = FALSE;
- m_bFsIsShowing = FALSE;
+ m_bFsIsMaximized = false;
+ m_bFsIsShowing = false;
m_hFrame = NULLHANDLE;
memset(&m_vSwp, 0, sizeof(SWP));
memset(&m_vSwpClient, 0, sizeof(SWP));
+ m_pWinLastFocused = NULL;
} // end of wxTopLevelWindowIOS2::Init
-long wxTopLevelWindowOS2::OS2GetCreateWindowFlags(
- long* plExflags
-) const
+void wxTopLevelWindowOS2::OnActivate(
+ wxActivateEvent& rEvent
+)
{
- long lStyle = GetWindowStyle();
- long lMsflags = 0;
+ if (rEvent.GetActive())
+ {
+ //
+ // Restore focus to the child which was last focused
+ //
+ wxLogTrace(wxT("focus"), wxT("wxTLW %08lx activated."), m_hWnd);
- if (lStyle == wxDEFAULT_FRAME_STYLE)
- lMsflags = FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
- FCF_MINMAX | FCF_TASKLIST;
- else
+ wxWindow* pParent = m_pWinLastFocused ? m_pWinLastFocused->GetParent()
+ : NULL;
+ if (!pParent)
+ {
+ pParent = this;
+ }
+
+ wxSetFocusToChild( pParent
+ ,&m_pWinLastFocused
+ );
+ }
+ else // deactivating
{
- if ((lStyle & wxCAPTION) == wxCAPTION)
- lMsflags = FCF_TASKLIST;
- else
- lMsflags = FCF_NOMOVEWITHOWNER;
-
- if ((lStyle & wxVSCROLL) == wxVSCROLL)
- lMsflags |= FCF_VERTSCROLL;
- if ((lStyle & wxHSCROLL) == wxHSCROLL)
- lMsflags |= FCF_HORZSCROLL;
- if (lStyle & wxMINIMIZE_BOX)
- lMsflags |= FCF_MINBUTTON;
- if (lStyle & wxMAXIMIZE_BOX)
- lMsflags |= FCF_MAXBUTTON;
- if (lStyle & wxTHICK_FRAME)
- lMsflags |= FCF_DLGBORDER;
- if (lStyle & wxSYSTEM_MENU)
- lMsflags |= FCF_SYSMENU;
- if (lStyle & wxCAPTION)
- lMsflags |= FCF_TASKLIST;
- if (lStyle & wxCLIP_CHILDREN)
+ //
+ // Remember the last focused child if it is our child
+ //
+ m_pWinLastFocused = FindFocus();
+
+ //
+ // So we NULL it out if it's a child from some other frame
+ //
+ wxWindow* pWin = m_pWinLastFocused;
+
+ while (pWin)
{
- // Invalid for frame windows under PM
+ if (pWin->IsTopLevel())
+ {
+ if (pWin != this)
+ {
+ m_pWinLastFocused = NULL;
+ }
+ break;
+ }
+ pWin = pWin->GetParent();
}
- if (lStyle & wxTINY_CAPTION_VERT)
- lMsflags |= FCF_TASKLIST;
- if (lStyle & wxTINY_CAPTION_HORIZ)
- lMsflags |= FCF_TASKLIST;
+ wxLogTrace(wxT("focus"),
+ wxT("wxTLW %08lx deactivated, last focused: %08lx."),
+ m_hWnd,
+ m_pWinLastFocused ? GetHwndOf(m_pWinLastFocused)
+ : NULL);
+ rEvent.Skip();
+ }
+} // end of wxTopLevelWindowOS2::OnActivate
+
+WXDWORD wxTopLevelWindowOS2::OS2GetStyle(
+ long lStyle
+, WXDWORD* pdwExflags
+) const
+{
+ long lMsflags = wxWindow::OS2GetStyle( (lStyle & ~wxBORDER_MASK) | wxBORDER_NONE
+ ,pdwExflags
+ );
- if ((lStyle & wxTHICK_FRAME) == 0)
- lMsflags |= FCF_BORDER;
- if (lStyle & wxFRAME_TOOL_WINDOW)
- *plExflags = kFrameToolWindow;
+ if ((lStyle & wxDEFAULT_FRAME_STYLE) == wxDEFAULT_FRAME_STYLE)
+ lMsflags |= FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
+ FCF_MINMAX | FCF_TASKLIST;
- if (lStyle & wxSTAY_ON_TOP)
- lMsflags |= FCF_SYSMODAL;
+ if ((lStyle & wxCAPTION) == wxCAPTION)
+ lMsflags |= FCF_TASKLIST;
+ else
+ lMsflags |= FCF_NOMOVEWITHOWNER;
+
+ if ((lStyle & wxVSCROLL) == wxVSCROLL)
+ lMsflags |= FCF_VERTSCROLL;
+ if ((lStyle & wxHSCROLL) == wxHSCROLL)
+ lMsflags |= FCF_HORZSCROLL;
+ if (lStyle & wxMINIMIZE_BOX)
+ lMsflags |= FCF_MINBUTTON;
+ if (lStyle & wxMAXIMIZE_BOX)
+ lMsflags |= FCF_MAXBUTTON;
+ if (lStyle & wxRESIZE_BORDER)
+ lMsflags |= FCF_DLGBORDER;
+ if (lStyle & wxSYSTEM_MENU)
+ lMsflags |= FCF_SYSMENU;
+ if (lStyle & wxCAPTION)
+ lMsflags |= FCF_TASKLIST;
+ if (lStyle & wxCLIP_CHILDREN)
+ {
+ // Invalid for frame windows under PM
}
+
+ if (lStyle & wxTINY_CAPTION)
+ lMsflags |= FCF_TASKLIST;
+
+ if ((lStyle & wxRESIZE_BORDER) == 0)
+ lMsflags |= FCF_BORDER;
+ if (lStyle & wxFRAME_TOOL_WINDOW)
+ *pdwExflags = kFrameToolWindow;
+
+ if (lStyle & wxSTAY_ON_TOP)
+ lMsflags |= FCF_SYSMODAL;
+
return lMsflags;
} // end of wxTopLevelWindowOS2::OS2GetCreateWindowFlags
-bool wxTopLevelWindowOS2::CreateDialog(
- ULONG ulDlgTemplate
-, const wxString& rsTitle
-, const wxPoint& rPos
-, const wxSize& rSize
-)
+WXHWND wxTopLevelWindowOS2::OS2GetParent() const
+{
+ HWND hWndParent = NULL;
+
+ //
+ // For the frames without wxFRAME_FLOAT_ON_PARENT style we should use NULL
+ // parent HWND or it would be always on top of its parent which is not what
+ // we usually want (in fact, we only want it for frames with the
+ // wxFRAME_FLOAT_ON_PARENT flag)
+ //
+ if (HasFlag(wxFRAME_FLOAT_ON_PARENT) )
+ {
+ const wxWindow* pParent = GetParent();
+
+ if (!pParent)
+ {
+ //
+ // This flag doesn't make sense then and will be ignored
+ //
+ wxFAIL_MSG( wxT("wxFRAME_FLOAT_ON_PARENT but no parent?") );
+ }
+ else
+ {
+ hWndParent = GetHwndOf(pParent);
+ }
+ }
+ //else: don't float on parent, must not be owned
+
+ //
+ // Now deal with the 2nd taskbar-related problem (see comments above in
+ // OS2GetStyle())
+ //
+ if (HasFlag(wxFRAME_NO_TASKBAR) && !hWndParent)
+ {
+ //
+ // Use hidden parent
+ //
+ hWndParent = wxTLWHiddenParentModule::GetHWND();
+ }
+ return (WXHWND)hWndParent;
+} // end of wxTopLevelWindowOS2::OS2GetParent
+
+
+bool wxTopLevelWindowOS2::CreateDialog( ULONG ulDlgTemplate,
+ const wxString& WXUNUSED(rsTitle),
+ const wxPoint& rPos,
+ const wxSize& rSize )
{
wxWindow* pParent = GetParent();
if ( !m_hWnd )
{
- wxFAIL_MSG(_("Did you forget to include wx/os2/wx.rc in your resources?"));
+ wxFAIL_MSG(wxT("Did you forget to include wx/os2/wx.rc in your resources?"));
- wxLogSysError(_("Can't create dialog using template '%ul'"), ulDlgTemplate);
+ wxLogSysError(wxT("Can't create dialog using template '%ld'"), ulDlgTemplate);
- return FALSE;
+ return false;
}
//
nX = (vSizeDpy.x - nWidth) / 2;
nY = (vSizeDpy.y - nHeight) / 2;
}
+ SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
+
+ LONG lColor = (LONG)m_backgroundColour.GetPixel();
+
+ if (!::WinSetPresParam( m_hWnd
+ ,PP_BACKGROUNDCOLOR
+ ,sizeof(LONG)
+ ,(PVOID)&lColor
+ ))
+ {
+ return false;
+ }
+
+ // Convert to OS/2 coordinates
+ nY = GetOS2ParentHeight(pParent) - nY - nHeight;
+
::WinSetWindowPos( GetHwnd()
,HWND_TOP
,nX
,nY
,nWidth
,nHeight
- ,SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW
+ ,SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW | SWP_ACTIVATE
);
+ ::WinQueryWindowPos(GetHwnd(), GetSwp());
+ m_hFrame = m_hWnd;
SubclassWin(m_hWnd);
- return TRUE;
+ return true;
} // end of wxTopLevelWindowOS2::CreateDialog
-bool wxTopLevelWindowOS2::CreateFrame(
- const wxString& rsTitle
-, const wxPoint& rPos
-, const wxSize& rSize
-)
+bool wxTopLevelWindowOS2::CreateFrame( const wxString& rsTitle,
+ const wxPoint& rPos,
+ const wxSize& rSize )
{
- long lExflags;
- long lFlags = OS2GetCreateWindowFlags(&lExflags);
- long lStyle = GetWindowStyleFlag();
- int nX = rPos.x;
- int nY = rPos.y;
- int nWidth = rSize.x;
- int nHeight = rSize.y;
- ULONG ulStyleFlags = 0L;
- ERRORID vError;
- wxString sError;
- wxWindow* pParent = GetParent();
- HWND hParent;
- HWND hFrame;
- HWND hClient;
+ WXDWORD lExflags;
+ WXDWORD lFlags = OS2GetCreateWindowFlags(&lExflags);
+ long lStyle = GetWindowStyleFlag();
+ int nX = rPos.x;
+ int nY = rPos.y;
+ int nWidth = rSize.x;
+ int nHeight = rSize.y;
+ ULONG ulStyleFlags = 0L;
+ ERRORID vError;
+ wxString sError;
+ wxWindow* pParent = GetParent();
+ HWND hParent;
+ HWND hFrame;
+ HWND hClient;
if (pParent)
hParent = GetHwndOf(pParent);
// Clear the visible flag, we always call show
//
ulStyleFlags &= (unsigned long)~WS_VISIBLE;
- m_bIconized = FALSE;
+ m_bIconized = false;
//
// Create the frame window: We break ranks with other ports now
hFrame = ::WinCreateStdWindow( hParent
,ulStyleFlags // frame-window style
,(PULONG)&lFlags // window style
- ,(PSZ)wxFrameClassName // class name
- ,(PSZ)rsTitle.c_str() // window title
+ ,wxString(wxFrameClassName).c_str() // class name
+ ,rsTitle.c_str() // window title
,0L // default client style
,NULLHANDLE // resource in executable file
,0 // resource id
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
- wxLogError("Error creating frame. Error: %s\n", sError);
- return FALSE;
+ wxLogError(wxT("Error creating frame. Error: %s\n"), sError.c_str());
+ return false;
}
//
wxAssociateWinWithHandle(m_hWnd, this);
wxAssociateWinWithHandle(m_hFrame, this);
- m_backgroundColour.Set(wxString("GREY"));
+ SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
LONG lColor = (LONG)m_backgroundColour.GetPixel();
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
- wxLogError("Error creating frame. Error: %s\n", sError);
- return FALSE;
+ wxLogError(wxT("Error creating frame. Error: %s\n"), sError.c_str());
+ return false;
}
//
// Now size everything. If adding a menu the client will need to be resized.
//
- if (pParent)
+ if (!OS2GetCreateWindowCoords( rPos
+ ,rSize
+ ,nX
+ ,nY
+ ,nWidth
+ ,nHeight
+ ))
{
- nY = pParent->GetSize().y - (nY + nHeight);
+ nX = nWidth = (int)CW_USEDEFAULT;
}
- else
+
+ //
+ // We can't use CW_USEDEFAULT here as we're not calling CreateWindow()
+ // and passing CW_USEDEFAULT to MoveWindow() results in resizing the
+ // window to (0, 0) size which breaks quite a lot of things, e.g. the
+ // sizer calculation in wxSizer::Fit()
+ //
+ if (nWidth == (int)CW_USEDEFAULT)
+ {
+ //
+ // The exact number doesn't matter, the dialog will be resized
+ // again soon anyhow but it should be big enough to allow
+ // calculation relying on "totalSize - clientSize > 0" work, i.e.
+ // at least greater than the title bar height
+ //
+ nWidth = nHeight = 100;
+ }
+ if (nX == (int)CW_USEDEFAULT)
{
- RECTL vRect;
+ //
+ // Centre it on the screen for now - what else can we do?
+ // TODO: We could try FCF_SHELLPOSITION but it will require moving
+ // things around a bit.
+ //
+ wxSize vSizeDpy = wxGetDisplaySize();
- ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
- nY = vRect.yTop - (nY + nHeight);
+ nX = (vSizeDpy.x - nWidth) / 2;
+ nY = (vSizeDpy.y - nHeight) / 2;
}
+
+ // Convert to OS/2 coordinates
+ nY = GetOS2ParentHeight(pParent) - nY - nHeight;
+
if (!::WinSetWindowPos( m_hFrame
,HWND_TOP
,nX
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
- wxLogError("Error sizing frame. Error: %s\n", sError);
- return FALSE;
+ wxLogError(wxT("Error sizing frame. Error: %s\n"), sError.c_str());
+ return false;
}
- return TRUE;
+ lStyle = ::WinQueryWindowULong( m_hWnd
+ ,QWL_STYLE
+ );
+ lStyle |= WS_CLIPCHILDREN;
+ ::WinSetWindowULong( m_hWnd
+ ,QWL_STYLE
+ ,lStyle
+ );
+ return true;
} // end of wxTopLevelWindowOS2::CreateFrame
bool wxTopLevelWindowOS2::Create(
, wxWindowID vId
, const wxString& rsTitle
, const wxPoint& rPos
-, const wxSize& rSize
+, const wxSize& rSizeOrig
, long lStyle
, const wxString& rsName
)
m_windowStyle = lStyle;
SetName(rsName);
m_windowId = vId == -1 ? NewControlId() : vId;
+
+ // always create a frame of some reasonable, even if arbitrary, size (at
+ // least for MSW compatibility)
+ wxSize rSize = rSizeOrig;
+ if ( rSize.x == -1 || rSize.y == -1 )
+ {
+ wxSize sizeDpy = wxGetDisplaySize();
+ if ( rSize.x == -1 )
+ rSize.x = sizeDpy.x / 3;
+ if ( rSize.y == -1 )
+ rSize.y = sizeDpy.y / 5;
+ }
+
wxTopLevelWindows.Append(this);
if (pParent)
pParent->AddChild(this);
if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
{
//
- // We have different dialog templates to allows creation of dialogs
+ // We have different dialog templates to allow creation of dialogs
// with & without captions under OS2indows, resizeable or not (but a
// resizeable dialog always has caption - otherwise it would look too
// strange)
} // end of wxTopLevelWindowOS2::Create
wxTopLevelWindowOS2::~wxTopLevelWindowOS2()
-{
- wxTopLevelWindows.DeleteObject(this);
-
- if (wxModelessWindows.Find(this))
- wxModelessWindows.DeleteObject(this);
-
- //
- // If this is the last top-level window, exit.
- //
- if (wxTheApp && (wxTopLevelWindows.Number() == 0))
- {
- wxTheApp->SetTopWindow(NULL);
- if ( wxTheApp->GetExitOnFrameDelete() )
- {
- ::WinPostMsg(NULL, WM_QUIT, 0, 0);
- }
- }
-} // end of wxTopLevelWindowOS2::~wxTopLevelWindowOS2
-
-//
-// IF we have child controls in the Frame's client we need to alter
-// the y position, because, OS/2 controls are positioned relative to
-// wxWindows orgin (top left) not the OS/2 origin (bottom left)
-//
-void wxTopLevelWindowOS2::AlterChildPos()
{
//
- // OS/2 is the only OS concerned about this
+ // After destroying an owned window, Windows activates the next top level
+ // window in Z order but it may be different from our owner (to reproduce
+ // this simply Alt-TAB to another application and back before closing the
+ // owned frame) whereas we always want to yield activation to our parent
//
- wxWindow* pChild = NULL;
- wxControl* pCtrl = NULL;
- RECTL vRect;
- SWP vSwp;
-
- ::WinQueryWindowRect(GetHwnd(), &vRect);
- for (wxWindowList::Node* pNode = GetChildren().GetFirst();
- pNode;
- pNode = pNode->GetNext())
+ if (HasFlag(wxFRAME_FLOAT_ON_PARENT))
{
- wxWindow* pChild = pNode->GetData();
+ wxWindow* pParent = GetParent();
- ::WinQueryWindowPos(pChild->GetHWND(), &vSwp);
- vSwp.y += (vRect.yTop - m_vSwpClient.cy);
- if (pChild->IsKindOf(CLASSINFO(wxControl)))
+ if (pParent)
{
- pCtrl = wxDynamicCast(pChild, wxControl);
- //
- // Must deal with controls that have margins like ENTRYFIELD. The SWP
- // struct of such a control will have and origin offset from its intended
- // position by the width of the margins.
- //
- vSwp.y -= pCtrl->GetYComp();
- vSwp.x -= pCtrl->GetXComp();
+ ::WinSetWindowPos( GetHwndOf(pParent)
+ ,HWND_TOP
+ ,0, 0, 0, 0
+ ,SWP_ZORDER
+ );
}
- ::WinSetWindowPos( pChild->GetHWND()
- ,HWND_TOP
- ,vSwp.x
- ,vSwp.y
- ,vSwp.cx
- ,vSwp.cy
- ,SWP_MOVE
- );
- ::WinQueryWindowPos(pChild->GetHWND(), &vSwp);
- pChild = NULL;
}
- ::WinQueryWindowPos(GetHwnd(), &m_vSwpClient);
-} // end of wxTopLevelWindowOS2::AlterChildPos
-
-void wxTopLevelWindowOS2::UpdateInternalSize(
- wxWindow* pChild
-, int nHeight
-)
-{
- pChild->MoveChildren(m_vSwpClient.cy - nHeight);
- ::WinQueryWindowPos(GetHwnd(), &m_vSwpClient);
-} // end of wxTopLevelWindowOS2::UpdateInternalSize
+} // end of wxTopLevelWindowOS2::~wxTopLevelWindowOS2
// ----------------------------------------------------------------------------
// wxTopLevelWindowOS2 client size
int nShowCmd
)
{
- ::WinShowWindow(m_hFrame, (BOOL)nShowCmd);
+ ::WinShowWindow(m_hFrame, (BOOL)(nShowCmd & SWP_SHOW));
+
+ //
+ // Need to artificially send a size event as wxApps often expect to do some
+ // final child control sizing
+ SendSizeEvent();
m_bIconized = nShowCmd == SWP_MINIMIZE;
} // end of wxTopLevelWindowOS2::DoShowWindow
-bool wxTopLevelWindowOS2::Show(
- bool bShow
-)
+bool wxTopLevelWindowOS2::Show( bool bShow )
{
- int nShowCmd;
- SWP vSwp;
- RECTL vRect;
+ int nShowCmd;
+ SWP vSwp;
+ if (bShow != IsShown() )
+ {
+ m_isShown = bShow;
+ }
+ else
+ {
+ return false;
+ }
if (bShow)
{
if (m_bMaximizeOnShow)
{
- nShowCmd = SWP_SHOW;
- m_bMaximizeOnShow = FALSE;
+ nShowCmd = SWP_MAXIMIZE;
+ m_bMaximizeOnShow = false;
}
else
{
- nShowCmd = SWP_HIDE;
+ nShowCmd = SWP_SHOW;
}
}
else // hide
if (bShow)
{
- wxActivateEvent vEvent(wxEVT_ACTIVATE, TRUE, m_windowId);
+ wxActivateEvent vEvent(wxEVT_ACTIVATE, true, m_windowId);
::WinQueryWindowPos(m_hFrame, &vSwp);
- m_bIconized = vSwp.fl & SWP_MINIMIZE;
+ m_bIconized = ( vSwp.fl & SWP_MINIMIZE ) == SWP_MINIMIZE ;
::WinQueryWindowPos(m_hWnd, &m_vSwpClient);
::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
+ ::WinQueryWindowPos(m_hWnd, &vSwp);
::WinEnableWindow(m_hFrame, TRUE);
+
vEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(vEvent);
+ HandleWindowEvent(vEvent);
}
else
{
//
if (GetParent())
{
- HWND hWndParent = GetHwndOf(GetParent());
+ HWND hWndParent = GetHwndOf(GetParent());
::WinQueryWindowPos(hWndParent, &vSwp);
- m_bIconized = vSwp.fl & SWP_MINIMIZE;
- if (hWndParent)
- ::WinSetWindowPos( hWndParent
- ,HWND_TOP
- ,vSwp.x
- ,vSwp.y
- ,vSwp.cx
- ,vSwp.cy
- ,SWP_ZORDER | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE
- );
+ m_bIconized = (vSwp.fl & SWP_MINIMIZE)==SWP_MINIMIZE;
::WinEnableWindow(hWndParent, TRUE);
}
}
- return TRUE;
+ return true;
} // end of wxTopLevelWindowOS2::Show
// ----------------------------------------------------------------------------
// We can't maximize the hidden frame because it shows it as well, so
// just remember that we should do it later in this case
//
- m_bMaximizeOnShow = TRUE;
+ m_bMaximizeOnShow = bMaximize;
}
} // end of wxTopLevelWindowOS2::Maximize
bool wxTopLevelWindowOS2::IsMaximized() const
{
- bool bIconic;
-
::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
- return (m_vSwp.fl & SWP_MAXIMIZE);
+ return (m_vSwp.fl & SWP_MAXIMIZE) == SWP_MAXIMIZE;
} // end of wxTopLevelWindowOS2::IsMaximized
-void wxTopLevelWindowOS2::Iconize(
- bool bIconize
-)
+void wxTopLevelWindowOS2::SetTitle( const wxString& title)
+{
+ SetLabel(title);
+}
+
+wxString wxTopLevelWindowOS2::GetTitle() const
+{
+ return GetLabel();
+}
+
+void wxTopLevelWindowOS2::Iconize( bool bIconize )
{
DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
} // end of wxTopLevelWindowOS2::Iconize
// also update the current state
::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
if (m_vSwp.fl & SWP_MINIMIZE)
- ((wxTopLevelWindow*)this)->m_bIconized = TRUE;
+ ((wxTopLevelWindow*)this)->m_bIconized = true;
else
- ((wxTopLevelWindow*)this)->m_bIconized = FALSE;
+ ((wxTopLevelWindow*)this)->m_bIconized = false;
return m_bIconized;
} // end of wxTopLevelWindowOS2::IsIconized
DoShowWindow(SWP_RESTORE);
} // end of wxTopLevelWindowOS2::Restore
+// generate an artificial resize event
+void wxTopLevelWindowOS2::SendSizeEvent(int flags)
+{
+ if (!m_bIconized)
+ {
+ RECTL vRect = wxGetWindowRect(GetHwnd());
+
+ if ( flags & wxSEND_EVENT_POST )
+ {
+ (void)::WinPostMsg( m_hFrame
+ ,WM_SIZE
+ ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
+ ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
+ );
+ }
+ else // send it
+ {
+ (void)::WinSendMsg( m_hFrame
+ ,WM_SIZE
+ ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
+ ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
+ );
+ }
+ }
+} // end of wxTopLevelWindowOS2::SendSizeEvent
+
// ----------------------------------------------------------------------------
// wxTopLevelWindowOS2 fullscreen
// ----------------------------------------------------------------------------
-bool wxTopLevelWindowOS2::ShowFullScreen(
- bool bShow
-, long lStyle
-)
+bool wxTopLevelWindowOS2::ShowFullScreen( bool bShow,
+ long lStyle )
{
if (bShow)
{
if (IsFullScreen())
- return FALSE;
+ return false;
- m_bFsIsShowing = TRUE;
+ m_bFsIsShowing = true;
m_lFsStyle = lStyle;
//
//
// Decide which window lStyle flags to turn off
//
- LONG lNewStyle = m_lFsOldWindowStyle;
- LONG lOffFlags = 0;
+ LONG lNewStyle = m_lFsOldWindowStyle;
+ LONG lOffFlags = 0;
if (lStyle & wxFULLSCREEN_NOBORDER)
lOffFlags |= FCF_BORDER;
//
// Resize to the size of the desktop
//
- int nWidth;
- int nHeight;
- RECTL vRect = wxGetWindowRect(HWND_DESKTOP);
+ int nWidth;
+ int nHeight;
+ RECTL vRect = wxGetWindowRect(HWND_DESKTOP);
nWidth = vRect.xRight - vRect.xLeft;
nHeight = vRect.yTop - vRect.yBottom;
- SetSize( nWidth
- ,nHeight
- );
+ SetSize( nWidth, nHeight );
//
// Now flush the window style cache and actually go full-screen
,SWP_SIZE | SWP_MOVE
);
- wxSizeEvent vEvent( wxSize( nWidth
- ,nHeight
- )
- ,GetId()
- );
-
- GetEventHandler()->ProcessEvent(vEvent);
- return TRUE;
+ wxSize full( nWidth, nHeight );
+ wxSizeEvent vEvent( full, GetId() );
+ HandleWindowEvent(vEvent);
+ return true;
}
else
{
if (!IsFullScreen())
- return FALSE;
+ return false;
- m_bFsIsShowing = FALSE;
+ m_bFsIsShowing = false;
Maximize(m_bFsIsMaximized);
::WinSetWindowULong( (HWND)GetHWND()
,QWL_STYLE
,m_vFsOldSize.height
,SWP_SIZE | SWP_MOVE
);
- return TRUE;
+ return true;
}
} // end of wxTopLevelWindowOS2::ShowFullScreen
// wxTopLevelWindowOS2 misc
// ----------------------------------------------------------------------------
-void wxTopLevelWindowOS2::SetIcon(
- const wxIcon& rIcon
+void wxTopLevelWindowOS2::SetIcons(
+ const wxIconBundle& rIcons
)
{
//
// This sets m_icon
//
- wxTopLevelWindowBase::SetIcon(rIcon);
+ wxTopLevelWindowBase::SetIcons(rIcons);
+
+ const wxIcon& vIcon = rIcons.GetIconOfExactSize(32);
- if (m_icon.Ok())
+ if (vIcon.Ok())
{
::WinSendMsg( m_hFrame
,WM_SETICON
- ,(MPARAM)((HPOINTER)m_icon.GetHICON())
+ ,(MPARAM)((HPOINTER)vIcon.GetHICON())
,NULL
);
::WinSendMsg( m_hFrame
}
} // end of wxTopLevelWindowOS2::SetIcon
-bool wxTopLevelWindowOS2::EnableCloseButton(
- bool bEnable
-)
+bool wxTopLevelWindowOS2::EnableCloseButton( bool bEnable )
{
//
// Get system (a.k.a. window) menu
//
- HMENU hMenu = ::WinWindowFromID(m_hFrame, FID_SYSMENU);
+ HMENU hMenu = ::WinWindowFromID(m_hFrame, FID_SYSMENU);
if (!hMenu)
{
- wxLogLastError(_T("GetSystemMenu"));
- return FALSE;
+ wxLogLastError(wxT("GetSystemMenu"));
+ return false;
}
//
,(MPARAM)FCF_MENU
,(MPARAM)0
);
- return TRUE;
+ return true;
} // end of wxTopLevelWindowOS2::EnableCloseButton
+// ============================================================================
+// wxTLWHiddenParentModule implementation
+// ============================================================================
+
+HWND wxTLWHiddenParentModule::m_shWnd = NULL;
+const wxChar* wxTLWHiddenParentModule::m_szClassName = NULL;
+
+bool wxTLWHiddenParentModule::OnInit()
+{
+ m_shWnd = NULL;
+ m_szClassName = NULL;
+ return true;
+} // end of wxTLWHiddenParentModule::OnInit
+
+void wxTLWHiddenParentModule::OnExit()
+{
+ if (m_shWnd)
+ {
+ if (!::WinDestroyWindow(m_shWnd))
+ {
+ wxLogLastError(wxT("DestroyWindow(hidden TLW parent)"));
+ }
+ m_shWnd = NULL;
+ }
+
+ m_szClassName = NULL;
+} // end of wxTLWHiddenParentModule::OnExit
+
+/* static */
+HWND wxTLWHiddenParentModule::GetHWND()
+{
+ if (!m_shWnd)
+ {
+ if (!m_szClassName)
+ {
+ static const wxChar* zHIDDEN_PARENT_CLASS = wxT("wxTLWHiddenParent");
+
+ if (!::WinRegisterClass( wxGetInstance()
+ ,(PSZ)zHIDDEN_PARENT_CLASS
+ ,NULL
+ ,0
+ ,sizeof(ULONG)
+ ))
+ {
+ wxLogLastError(wxT("RegisterClass(\"wxTLWHiddenParent\")"));
+ }
+ else
+ {
+ m_szClassName = zHIDDEN_PARENT_CLASS;
+ }
+ }
+ m_shWnd = ::WinCreateWindow( HWND_DESKTOP,
+ (PSZ)m_szClassName,
+ "",
+ 0L,
+ (LONG)0L,
+ (LONG)0L,
+ (LONG)0L,
+ (LONG)0L,
+ NULLHANDLE,
+ HWND_TOP,
+ 0L,
+ NULL,
+ NULL );
+ if (!m_shWnd)
+ {
+ wxLogLastError(wxT("CreateWindow(hidden TLW parent)"));
+ }
+ }
+ return m_shWnd;
+} // end of wxTLWHiddenParentModule::GetHWND
projects / wxWidgets.git / blobdiff