/////////////////////////////////////////////////////////////////////////////
// Name: frame.cpp
-// Purpose: wxFrameOS2
+// Purpose: wxFrame
// Author: David Webster
// Modified by:
// Created: 10/27/99
// event tables
// ----------------------------------------------------------------------------
-BEGIN_EVENT_TABLE(wxFrameOS2, wxFrameBase)
- EVT_ACTIVATE(wxFrameOS2::OnActivate)
- EVT_SYS_COLOUR_CHANGED(wxFrameOS2::OnSysColourChanged)
+BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
+ EVT_ACTIVATE(wxFrame::OnActivate)
+ EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
END_EVENT_TABLE()
-#ifndef __WXUNIVERSAL__
IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
-#endif
// ============================================================================
// implementation
#if wxUSE_STATUSBAR
#if wxUSE_NATIVE_STATUSBAR
- bool wxFrameOS2::m_bUseNativeStatusBar = TRUE;
+ bool wxFrame::m_bUseNativeStatusBar = TRUE;
#else
- bool wxFrameOS2::m_bUseNativeStatusBar = FALSE;
+ bool wxFrame::m_bUseNativeStatusBar = FALSE;
#endif
#endif //wxUSE_STATUSBAR
// creation/destruction
// ----------------------------------------------------------------------------
-void wxFrameOS2::Init()
+void wxFrame::Init()
{
m_bIconized = FALSE;
m_nFsStatusBarHeight = 0;
m_nFsToolBarHeight = 0;
m_bFsIsMaximized = FALSE;
+ m_bWasMinimized = FALSE;
m_bFsIsShowing = FALSE;
m_bIsShown = FALSE;
m_pWinLastFocused = (wxWindow *)NULL;
memset(&m_vSwpVScroll, 0, sizeof(SWP));
memset(&m_vSwpStatusBar, 0, sizeof(SWP));
memset(&m_vSwpToolBar, 0, sizeof(SWP));
-} // end of wxFrameOS2::Init
+} // end of wxFrame::Init
-bool wxFrameOS2::Create(
+bool wxFrame::Create(
wxWindow* pParent
, wxWindowID vId
, const wxString& rsTitle
wxModelessWindows.Append(this);
}
return(bOk);
-} // end of wxFrameOS2::Create
+} // end of wxFrame::Create
-wxFrameOS2::~wxFrameOS2()
+wxFrame::~wxFrame()
{
m_isBeingDeleted = TRUE;
);
}
}
-} // end of wxFrameOS2::~wxFrame
+} // end of wxFrame::~wxFrame
+
+//
+// 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 wxFrame::AlterChildPos()
+{
+ //
+ // OS/2 is the only OS concerned about this
+ //
+ wxWindow* pChild = NULL;
+ wxControl* pCtrl = NULL;
+ RECTL vRect;
+ SWP vSwp;
+
+ ::WinQueryWindowRect(GetHwnd(), &vRect);
+ for (wxWindowList::Node* pNode = GetChildren().GetFirst();
+ pNode;
+ pNode = pNode->GetNext())
+ {
+ wxWindow* pChild = pNode->GetData();
+
+ ::WinQueryWindowPos(pChild->GetHWND(), &vSwp);
+ vSwp.y += (vRect.yTop - m_vSwpClient.cy);
+ if (pChild->IsKindOf(CLASSINFO(wxControl)))
+ {
+ 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( pChild->GetHWND()
+ ,HWND_TOP
+ ,vSwp.x
+ ,vSwp.y
+ ,vSwp.cx
+ ,vSwp.cy
+ ,SWP_MOVE
+ );
+ ::WinQueryWindowPos(pChild->GetHWND(), &vSwp);
+ pChild = NULL;
+ }
+} // end of wxFrame::AlterChildPos
//
// Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
//
-void wxFrameOS2::DoGetClientSize(
+void wxFrame::DoGetClientSize(
int* pX
, int* pY
) const
*pX = vRect.xRight - vRect.xLeft;
if (pY)
*pY = vRect.yTop - vRect.yBottom;
-} // end of wxFrameOS2::DoGetClientSize
+} // end of wxFrame::DoGetClientSize
//
// Set the client size (i.e. leave the calculation of borders etc.
// to wxWindows)
//
-void wxFrameOS2::DoSetClientSize(
+void wxFrame::DoSetClientSize(
int nWidth
, int nHeight
)
// and the client area; add this to the new client size to move the
// window. Remember OS/2's backwards y coord system!
//
- int nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth;
- int nActualHeight = vRect2.yTop + vRect2.yTop - vRect.yTop + nHeight;
+ int nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight;
+ int nActualHeight = vRect2.yTop + vRect2.yTop - vRect.yTop;
#if wxUSE_STATUSBAR
- if ( GetStatusBar() )
- {
- int nStatusX;
- int nStatusY;
+ wxStatusBar* pStatusBar = GetStatusBar();
- GetStatusBar()->GetClientSize( &nStatusX
- ,&nStatusY
- );
- nActualHeight += nStatusY;
+ if (pStatusBar && pStatusBar->IsShown())
+ {
+ nActualHeight += pStatusBar->GetSize().y;
}
+
#endif // wxUSE_STATUSBAR
wxPoint vPoint(GetClientAreaOrigin());
- nActualWidth += vPoint.y;
- nActualHeight += vPoint.x;
+
+ nActualWidth += vPoint.x;
+ nActualHeight += vPoint.y;
POINTL vPointl;
);
vEvent.SetEventObject(this);
GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxFrameOS2::DoSetClientSize
+} // end of wxFrame::DoSetClientSize
-void wxFrameOS2::DoGetSize(
+void wxFrame::DoGetSize(
int* pWidth
, int* pHeight
) const
::WinQueryWindowRect(m_hFrame, &vRect);
*pWidth = vRect.xRight - vRect.xLeft;
*pHeight = vRect.yTop - vRect.yBottom;
-} // end of wxFrameOS2::DoGetSize
+} // end of wxFrame::DoGetSize
-void wxFrameOS2::DoGetPosition(
+void wxFrame::DoGetPosition(
int* pX
, int* pY
) const
*pX = vRect.xRight - vRect.xLeft;
*pY = vRect.yTop - vRect.yBottom;
-} // end of wxFrameOS2::DoGetPosition
+} // end of wxFrame::DoGetPosition
// ----------------------------------------------------------------------------
// variations around ::ShowWindow()
// ----------------------------------------------------------------------------
-void wxFrameOS2::DoShowWindow(
+void wxFrame::DoShowWindow(
int bShowCmd
)
{
::WinShowWindow(m_hFrame, (BOOL)bShowCmd);
m_bIconized = bShowCmd == SWP_MINIMIZE;
-} // end of wxFrameOS2::DoShowWindow
+} // end of wxFrame::DoShowWindow
-bool wxFrameOS2::Show(
+bool wxFrame::Show(
bool bShow
)
{
+ int nShowCmd;
SWP vSwp;
- DoShowWindow((int)bShow);
+ if (bShow)
+ {
+ nShowCmd = SWP_SHOW;
+ }
+ else // hide
+ {
+ nShowCmd = SWP_HIDE;
+ }
+
+ DoShowWindow(nShowCmd);
if (bShow)
{
::WinQueryWindowPos(m_hFrame, &vSwp);
m_bIconized = vSwp.fl & SWP_MINIMIZE;
+ ::WinQueryWindowPos(m_hWnd, &m_vSwpClient);
::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
::WinEnableWindow(m_hFrame, TRUE);
vEvent.SetEventObject(this);
}
}
return TRUE;
-} // end of wxFrameOS2::Show
+} // end of wxFrame::Show
-void wxFrameOS2::Iconize(
+void wxFrame::Iconize(
bool bIconize
)
{
DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
-} // end of wxFrameOS2::Iconize
+} // end of wxFrame::Iconize
-void wxFrameOS2::Maximize(
+void wxFrame::Maximize(
bool bMaximize)
{
DoShowWindow(bMaximize ? SWP_MAXIMIZE : SWP_RESTORE);
-} // end of wxFrameOS2::Maximize
+} // end of wxFrame::Maximize
-void wxFrameOS2::Restore()
+void wxFrame::Restore()
{
DoShowWindow(SWP_RESTORE);
-} // end of wxFrameOS2::Restore
+} // end of wxFrame::Restore
-bool wxFrameOS2::IsIconized() const
+bool wxFrame::IsIconized() const
{
SWP vSwp;
else
((wxFrame*)this)->m_bIconized = FALSE;
return m_bIconized;
-} // end of wxFrameOS2::IsIconized
+} // end of wxFrame::IsIconized
// Is it maximized?
-bool wxFrameOS2::IsMaximized() const
+bool wxFrame::IsMaximized() const
{
SWP vSwp;
bool bIconic;
::WinQueryWindowPos(m_hFrame, &vSwp);
return (vSwp.fl & SWP_MAXIMIZE);
-} // end of wxFrameOS2::IsMaximized
+} // end of wxFrame::IsMaximized
-void wxFrameOS2::SetIcon(
+void wxFrame::SetIcon(
const wxIcon& rIcon
)
{
,(MPARAM)0
);
}
-} // end of wxFrameOS2::SetIcon
+} // end of wxFrame::SetIcon
#if wxUSE_STATUSBAR
-wxStatusBar* wxFrameOS2::OnCreateStatusBar(
+wxStatusBar* wxFrame::OnCreateStatusBar(
int nNumber
, long lulStyle
, wxWindowID vId
::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
return pStatusBar;
-} // end of wxFrameOS2::OnCreateStatusBar
+} // end of wxFrame::OnCreateStatusBar
-void wxFrameOS2::PositionStatusBar()
+void wxFrame::PositionStatusBar()
{
SWP vSwp;
ERRORID vError;
if (m_frameStatusBar)
{
int nWidth;
+ int nY;
int nStatbarWidth;
int nStatbarHeight;
HWND hWndClient;
RECTL vFRect;
::WinQueryWindowRect(m_hFrame, &vRect);
+ nY = vRect.yTop;
::WinMapWindowPoints(m_hFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2);
vFRect = vRect;
::WinCalcFrameRect(m_hFrame, &vRect, TRUE);
nWidth = vRect.xRight - vRect.xLeft;
+ nY = nY - (vRect.yBottom - vFRect.yBottom);
m_frameStatusBar->GetSize( &nStatbarWidth
,&nStatbarHeight
);
+ nY= nY - nStatbarHeight;
//
// Since we wish the status bar to be directly under the client area,
// we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
//
m_frameStatusBar->SetSize( vRect.xLeft - vFRect.xLeft
- ,vRect.yBottom - vFRect.yBottom
+ ,nY
,nWidth
,nStatbarHeight
);
return;
}
}
-} // end of wxFrameOS2::PositionStatusBar
+} // end of wxFrame::PositionStatusBar
#endif // wxUSE_STATUSBAR
#if wxUSE_MENUS_NATIVE
-void wxFrameOS2::DetachMenuBar()
+void wxFrame::DetachMenuBar()
{
if (m_frameMenuBar)
{
m_frameMenuBar->Detach();
m_frameMenuBar = NULL;
}
-} // end of wxFrameOS2::DetachMenuBar
+} // end of wxFrame::DetachMenuBar
-void wxFrameOS2::SetMenuBar(
+void wxFrame::SetMenuBar(
wxMenuBar* pMenuBar
)
{
m_frameMenuBar = pMenuBar;
pMenuBar->Attach((wxFrame*)this);
}
-} // end of wxFrameOS2::SetMenuBar
+} // end of wxFrame::SetMenuBar
-void wxFrameOS2::AttachMenuBar(
+void wxFrame::AttachMenuBar(
wxMenuBar* pMenubar
)
{
}
InternalSetMenuBar();
}
-} // end of wxFrameOS2::AttachMenuBar
+} // end of wxFrame::AttachMenuBar
-void wxFrameOS2::InternalSetMenuBar()
+void wxFrame::InternalSetMenuBar()
{
ERRORID vError;
wxString sError;
wxLogError("Error setting parent for submenu. Error: %s\n", sError);
}
::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
-} // end of wxFrameOS2::InternalSetMenuBar
+} // end of wxFrame::InternalSetMenuBar
#endif // wxUSE_MENUS_NATIVE
//
// Responds to colour changes, and passes event on to children
//
-void wxFrameOS2::OnSysColourChanged(
+void wxFrame::OnSysColourChanged(
wxSysColourChangedEvent& rEvent
)
{
// Propagate the event to the non-top-level children
//
wxWindow::OnSysColourChanged(rEvent);
-} // end of wxFrameOS2::OnSysColourChanged
+} // end of wxFrame::OnSysColourChanged
// Pass TRUE to show full screen, FALSE to restore.
-bool wxFrameOS2::ShowFullScreen(
+bool wxFrame::ShowFullScreen(
bool bShow
, long lStyle
)
);
return TRUE;
}
-} // end of wxFrameOS2::ShowFullScreen
+} // end of wxFrame::ShowFullScreen
//
// Frame window
//
-bool wxFrameOS2::OS2Create(
+bool wxFrame::OS2Create(
int nId
, wxWindow* pParent
, const wxChar* zWclass
// Now size everything. If adding a menu the client will need to be resized.
//
+ if (pParent)
+ {
+ nY = pParent->GetSize().y - (nY + nHeight);
+ }
+ else
+ {
+ RECTL vRect;
+
+ ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
+ nY = vRect.yTop - (nY + nHeight);
+ }
if (!::WinSetWindowPos( m_hFrame
,HWND_TOP
,nX
wxLogError("Error sizing frame. Error: %s\n", sError);
return FALSE;
}
- //
- // We may have to be smarter here when variable sized toolbars are added!
- //
- if (!::WinSetWindowPos( m_hWnd
- ,HWND_TOP
- ,nX // + 20
- ,nY // + 20
- ,nWidth // - 60
- ,nHeight // - 60
- ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
- ))
- {
- vError = ::WinGetLastError(vHabmain);
- sError = wxPMErrorToStr(vError);
- wxLogError("Error sizing client. Error: %s\n", sError);
- return FALSE;
- }
return TRUE;
-} // end of wxFrameOS2::OS2Create
+} // end of wxFrame::OS2Create
//
// Default activation behaviour - set the focus for the first child
// subwindow found.
//
-void wxFrameOS2::OnActivate(
+void wxFrame::OnActivate(
wxActivateEvent& rEvent
)
{
}
}
}
-} // end of wxFrameOS2::OnActivate
+} // end of wxFrame::OnActivate
// ----------------------------------------------------------------------------
// wxFrame size management: we exclude the areas taken by menu/status/toolbars
// ----------------------------------------------------------------------------
// Checks if there is a toolbar, and returns the first free client position
-wxPoint wxFrameOS2::GetClientAreaOrigin() const
+wxPoint wxFrame::GetClientAreaOrigin() const
{
wxPoint vPoint(0, 0);
}
#endif //wxUSE_TOOLBAR
return vPoint;
-} // end of wxFrameOS2::GetClientAreaOrigin
+} // end of wxFrame::GetClientAreaOrigin
// ----------------------------------------------------------------------------
// tool/status bar stuff
#if wxUSE_TOOLBAR
-wxToolBar* wxFrameOS2::CreateToolBar(
+wxToolBar* wxFrame::CreateToolBar(
long lStyle
, wxWindowID vId
, const wxString& rName
PositionToolBar();
}
return m_frameToolBar;
-} // end of wxFrameOS2::CreateToolBar
+} // end of wxFrame::CreateToolBar
-void wxFrameOS2::PositionToolBar()
+void wxFrame::PositionToolBar()
{
HWND hWndClient;
RECTL vRect;
,wxSIZE_NO_ADJUSTMENTS
);
}
-} // end of wxFrameOS2::PositionToolBar
+} // end of wxFrame::PositionToolBar
#endif // wxUSE_TOOLBAR
// ----------------------------------------------------------------------------
// Windows behaviour where child frames float independently of the parent one
// on the desktop, but are iconized/restored with it
//
-void wxFrameOS2::IconizeChildFrames(
+void wxFrame::IconizeChildFrames(
bool bIconize
)
{
pNode = pNode->GetNext() )
{
wxWindow* pWin = pNode->GetData();
+ wxFrame* pFrame = wxDynamicCast(pWin, wxFrame);
- if (pWin->IsKindOf(CLASSINFO(wxFrame)) )
+ if ( pFrame
+#if wxUSE_MDI_ARCHITECTURE
+ && !wxDynamicCast(pFrame, wxMDIChildFrame)
+#endif // wxUSE_MDI_ARCHITECTURE
+ )
{
- ((wxFrame *)pWin)->Iconize(bIconize);
+ //
+ // We don't want to restore the child frames which had been
+ // iconized even before we were iconized, so save the child frame
+ // status when iconizing the parent frame and check it when
+ // restoring it.
+ //
+ if (bIconize)
+ {
+ pFrame->m_bWasMinimized = pFrame->IsIconized();
+ }
+
+ //
+ // This test works for both iconizing and restoring
+ //
+ if (!pFrame->m_bWasMinimized)
+ pFrame->Iconize(bIconize);
}
}
-} // end of wxFrameOS2::IconizeChildFrames
+} // end of wxFrame::IconizeChildFrames
// ===========================================================================
// message processing
// ---------------------------------------------------------------------------
// preprocessing
// ---------------------------------------------------------------------------
-bool wxFrameOS2::OS2TranslateMessage(
+bool wxFrame::OS2TranslateMessage(
WXMSG* pMsg
)
{
#else
return FALSE;
#endif //wxUSE_ACCEL
-} // end of wxFrameOS2::OS2TranslateMessage
+} // end of wxFrame::OS2TranslateMessage
// ---------------------------------------------------------------------------
// our private (non virtual) message handlers
// ---------------------------------------------------------------------------
-bool wxFrameOS2::HandlePaint()
+bool wxFrame::HandlePaint()
{
RECTL vRect;
}
else
{
- return(wxWindow::HandlePaint());
+ if (!wxWindow::HandlePaint())
+ {
+ HPS hPS;
+ RECTL vRect;
+
+ hPS = ::WinBeginPaint( GetHwnd()
+ ,NULLHANDLE
+ ,&vRect
+ );
+ if(hPS)
+ {
+ ::GpiCreateLogColorTable( hPS
+ ,0L
+ ,LCOLF_CONSECRGB
+ ,0L
+ ,(LONG)wxTheColourDatabase->m_nSize
+ ,(PLONG)wxTheColourDatabase->m_palTable
+ );
+ ::GpiCreateLogColorTable( hPS
+ ,0L
+ ,LCOLF_RGB
+ ,0L
+ ,0L
+ ,NULL
+ );
+
+ ::WinFillRect( hPS
+ ,&vRect
+ ,GetBackgroundColour().GetPixel()
+ );
+ ::WinEndPaint(hPS);
+ }
+ }
+ return TRUE;
}
}
else
return TRUE;
}
return FALSE;
-} // end of wxFrameOS2::HandlePaint
+} // end of wxFrame::HandlePaint
-bool wxFrameOS2::HandleSize(
+bool wxFrame::HandleSize(
int nX
, int nY
, WXUINT nId
vEvent.SetEventObject(this);
bProcessed = GetEventHandler()->ProcessEvent(vEvent);
+ AlterChildPos();
}
return bProcessed;
-} // end of wxFrameOS2::HandleSize
+} // end of wxFrame::HandleSize
-bool wxFrameOS2::HandleCommand(
+bool wxFrame::HandleCommand(
WXWORD nId
, WXWORD nCmd
, WXHWND hControl
}
}
return FALSE;
-} // end of wxFrameOS2::HandleCommand
+} // end of wxFrame::HandleCommand
-bool wxFrameOS2::HandleMenuSelect(
+bool wxFrame::HandleMenuSelect(
WXWORD nItem
, WXWORD nFlags
, WXHMENU hMenu
}
}
return TRUE;
-} // end of wxFrameOS2::HandleMenuSelect
+} // end of wxFrame::HandleMenuSelect
// ---------------------------------------------------------------------------
// Main Frame window proc
return rc;
} // end of wxFrameWndProc
-MRESULT wxFrameOS2::OS2WindowProc(
+MRESULT wxFrame::OS2WindowProc(
WXUINT uMessage
, WXWPARAM wParam
, WXLPARAM lParam
,lParam
);
return (MRESULT)mRc;
-} // wxFrameOS2::OS2WindowProc
+} // wxFrame::OS2WindowProc
-void wxFrameOS2::SetClient(WXHWND c_Hwnd)
+void wxFrame::SetClient(WXHWND c_Hwnd)
{
// Duh...nothing to do under OS/2
}
-void wxFrameOS2::SetClient(
+void wxFrame::SetClient(
wxWindow* pWindow
)
{
}
}
-wxWindow* wxFrameOS2::GetClient()
+wxWindow* wxFrame::GetClient()
{
return wxFindWinFromHandle((WXHWND)::WinWindowFromID(m_hFrame, FID_CLIENT));
}
projects / wxWidgets.git / blobdiff