/////////////////////////////////////////////////////////////////////////////
// Name: frame.cpp
-// Purpose: wxFrame
+// Purpose: wxFrameOS2
// Author: David Webster
// Modified by:
// Created: 10/27/99
// event tables
// ----------------------------------------------------------------------------
-BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
- EVT_ACTIVATE(wxFrame::OnActivate)
- EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
+BEGIN_EVENT_TABLE(wxFrameOS2, wxFrameBase)
+ EVT_ACTIVATE(wxFrameOS2::OnActivate)
+ EVT_SYS_COLOUR_CHANGED(wxFrameOS2::OnSysColourChanged)
END_EVENT_TABLE()
+#ifndef __WXUNIVERSAL__
IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
+#endif
// ============================================================================
// implementation
#if wxUSE_STATUSBAR
#if wxUSE_NATIVE_STATUSBAR
- bool wxFrame::m_bUseNativeStatusBar = TRUE;
+ bool wxFrameOS2::m_bUseNativeStatusBar = TRUE;
#else
- bool wxFrame::m_bUseNativeStatusBar = FALSE;
+ bool wxFrameOS2::m_bUseNativeStatusBar = FALSE;
#endif
#endif //wxUSE_STATUSBAR
// creation/destruction
// ----------------------------------------------------------------------------
-void wxFrame::Init()
+void wxFrameOS2::Init()
{
m_bIconized = FALSE;
memset(&m_vSwpVScroll, 0, sizeof(SWP));
memset(&m_vSwpStatusBar, 0, sizeof(SWP));
memset(&m_vSwpToolBar, 0, sizeof(SWP));
-} // end of wxFrame::Init
+} // end of wxFrameOS2::Init
-bool wxFrame::Create(
+bool wxFrameOS2::Create(
wxWindow* pParent
, wxWindowID vId
, const wxString& rsTitle
wxModelessWindows.Append(this);
}
return(bOk);
-} // end of wxFrame::Create
+} // end of wxFrameOS2::Create
-wxFrame::~wxFrame()
+wxFrameOS2::~wxFrameOS2()
{
m_isBeingDeleted = TRUE;
);
}
}
-} // end of wxFrame::~wxFrame
+} // end of wxFrameOS2::~wxFrame
//
// Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
//
-void wxFrame::DoGetClientSize(
+void wxFrameOS2::DoGetClientSize(
int* pX
, int* pY
) const
{
RECTL vRect;
::WinQueryWindowRect(GetHwnd(), &vRect);
+
+ //
+ // No need to use statusbar code as in WIN32 as the FORMATFRAME
+ // window procedure ensures PM knows about the new frame client
+ // size internally. A ::WinQueryWindowRect is all that is needed!
+ //
+
if (pX)
*pX = vRect.xRight - vRect.xLeft;
if (pY)
*pY = vRect.yTop - vRect.yBottom;
-} // end of wxFrame::DoGetClientSize
+} // end of wxFrameOS2::DoGetClientSize
//
// Set the client size (i.e. leave the calculation of borders etc.
// to wxWindows)
//
-void wxFrame::DoSetClientSize(
+void wxFrameOS2::DoSetClientSize(
int nWidth
, int nHeight
)
);
vEvent.SetEventObject(this);
GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxFrame::DoSetClientSize
+} // end of wxFrameOS2::DoSetClientSize
-void wxFrame::DoGetSize(
+void wxFrameOS2::DoGetSize(
int* pWidth
, int* pHeight
) const
::WinQueryWindowRect(m_hFrame, &vRect);
*pWidth = vRect.xRight - vRect.xLeft;
*pHeight = vRect.yTop - vRect.yBottom;
-} // end of wxFrame::DoGetSize
+} // end of wxFrameOS2::DoGetSize
-void wxFrame::DoGetPosition(
+void wxFrameOS2::DoGetPosition(
int* pX
, int* pY
) const
POINTL vPoint;
::WinQueryWindowRect(m_hFrame, &vRect);
- vPoint.x = vRect.xLeft;
- //
- // OS/2 is backwards [WIN32 it is vRect.yTop]
- //
- vPoint.y = vRect.yBottom;
-
- *pX = vPoint.x;
- *pY = vPoint.y;
-} // end of wxFrame::DoGetPosition
+ *pX = vRect.xRight - vRect.xLeft;
+ *pY = vRect.yTop - vRect.yBottom;
+} // end of wxFrameOS2::DoGetPosition
// ----------------------------------------------------------------------------
// variations around ::ShowWindow()
// ----------------------------------------------------------------------------
-void wxFrame::DoShowWindow(
+void wxFrameOS2::DoShowWindow(
int bShowCmd
)
{
::WinShowWindow(m_hFrame, (BOOL)bShowCmd);
m_bIconized = bShowCmd == SWP_MINIMIZE;
-} // end of wxFrame::DoShowWindow
+} // end of wxFrameOS2::DoShowWindow
-bool wxFrame::Show(
+bool wxFrameOS2::Show(
bool bShow
)
{
}
}
return TRUE;
-} // end of wxFrame::Show
+} // end of wxFrameOS2::Show
-void wxFrame::Iconize(
+void wxFrameOS2::Iconize(
bool bIconize
)
{
DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
-} // end of wxFrame::Iconize
+} // end of wxFrameOS2::Iconize
-void wxFrame::Maximize(
+void wxFrameOS2::Maximize(
bool bMaximize)
{
DoShowWindow(bMaximize ? SWP_MAXIMIZE : SWP_RESTORE);
-} // end of wxFrame::Maximize
+} // end of wxFrameOS2::Maximize
-void wxFrame::Restore()
+void wxFrameOS2::Restore()
{
DoShowWindow(SWP_RESTORE);
-} // end of wxFrame::Restore
+} // end of wxFrameOS2::Restore
-bool wxFrame::IsIconized() const
+bool wxFrameOS2::IsIconized() const
{
SWP vSwp;
else
((wxFrame*)this)->m_bIconized = FALSE;
return m_bIconized;
-} // end of wxFrame::IsIconized
+} // end of wxFrameOS2::IsIconized
// Is it maximized?
-bool wxFrame::IsMaximized() const
+bool wxFrameOS2::IsMaximized() const
{
SWP vSwp;
bool bIconic;
::WinQueryWindowPos(m_hFrame, &vSwp);
return (vSwp.fl & SWP_MAXIMIZE);
-} // end of wxFrame::IsMaximized
+} // end of wxFrameOS2::IsMaximized
-void wxFrame::SetIcon(
+void wxFrameOS2::SetIcon(
const wxIcon& rIcon
)
{
,(MPARAM)0
);
}
-} // end of wxFrame::SetIcon
+} // end of wxFrameOS2::SetIcon
#if wxUSE_STATUSBAR
-wxStatusBar* wxFrame::OnCreateStatusBar(
+wxStatusBar* wxFrameOS2::OnCreateStatusBar(
int nNumber
, long lulStyle
, wxWindowID vId
::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
return pStatusBar;
-} // end of wxFrame::OnCreateStatusBar
+} // end of wxFrameOS2::OnCreateStatusBar
-void wxFrame::PositionStatusBar()
+void wxFrameOS2::PositionStatusBar()
{
SWP vSwp;
ERRORID vError;
return;
}
}
-} // end of wxFrame::PositionStatusBar
+} // end of wxFrameOS2::PositionStatusBar
#endif // wxUSE_STATUSBAR
-void wxFrame::DetachMenuBar()
+void wxFrameOS2::DetachMenuBar()
{
if (m_frameMenuBar)
{
m_frameMenuBar->Detach();
m_frameMenuBar = NULL;
}
-} // end of wxFrame::DetachMenuBar
+} // end of wxFrameOS2::DetachMenuBar
-void wxFrame::SetMenuBar(
+void wxFrameOS2::SetMenuBar(
wxMenuBar* pMenuBar
)
{
}
InternalSetMenuBar();
m_frameMenuBar = pMenuBar;
- pMenuBar->Attach(this);
+ pMenuBar->Attach((wxFrame*)this);
}
-} // end of wxFrame::SetMenuBar
+} // end of wxFrameOS2::SetMenuBar
-void wxFrame::InternalSetMenuBar()
+void wxFrameOS2::AttachMenuBar(
+ wxMenuBar* pMenubar
+)
+{
+ m_frameMenuBar = pMenubar;
+
+ if (!pMenubar)
+ {
+ //
+ // Actually remove the menu from the frame
+ //
+ m_hMenu = (WXHMENU)0;
+ InternalSetMenuBar();
+ }
+ else // Set new non NULL menu bar
+ {
+ //
+ // Can set a menubar several times.
+ //
+ if (pMenubar->GetHMenu())
+ {
+ m_hMenu = pMenubar->GetHMenu();
+ }
+ else
+ {
+ if (pMenubar->IsAttached())
+ pMenubar->Detach();
+
+ m_hMenu = pMenubar->Create();
+
+ if (!m_hMenu)
+ return;
+ }
+ InternalSetMenuBar();
+ }
+} // end of wxFrameOS2::AttachMenuBar
+
+void wxFrameOS2::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 wxFrame::InternalSetMenuBar
+} // end of wxFrameOS2::InternalSetMenuBar
//
// Responds to colour changes, and passes event on to children
//
-void wxFrame::OnSysColourChanged(
+void wxFrameOS2::OnSysColourChanged(
wxSysColourChangedEvent& rEvent
)
{
// Propagate the event to the non-top-level children
//
wxWindow::OnSysColourChanged(rEvent);
-} // end of wxFrame::OnSysColourChanged
+} // end of wxFrameOS2::OnSysColourChanged
// Pass TRUE to show full screen, FALSE to restore.
-bool wxFrame::ShowFullScreen(
+bool wxFrameOS2::ShowFullScreen(
bool bShow
, long lStyle
)
);
return TRUE;
}
-} // end of wxFrame::ShowFullScreen
+} // end of wxFrameOS2::ShowFullScreen
//
// Frame window
//
-bool wxFrame::OS2Create(
+bool wxFrameOS2::OS2Create(
int nId
, wxWindow* pParent
, const wxChar* zWclass
wxAssociateWinWithHandle(m_hWnd, this);
wxAssociateWinWithHandle(m_hFrame, this);
+ m_backgroundColour.Set(wxString("GREY"));
+
+ LONG lColor = (LONG)m_backgroundColour.GetPixel();
+
+ if (!::WinSetPresParam( m_hWnd
+ ,PP_BACKGROUNDCOLOR
+ ,sizeof(LONG)
+ ,(PVOID)&lColor
+ ))
+ {
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ wxLogError("Error creating frame. Error: %s\n", sError);
+ return FALSE;
+ }
+
//
// Now need to subclass window. Instead of calling the SubClassWin in wxWindow
// we manually subclass here because we don't want to use the main wxWndProc
//
if (!::WinSetWindowPos( m_hWnd
,HWND_TOP
- ,nX + 20
- ,nY + 20
- ,nWidth - 60
- ,nHeight - 60
+ ,nX // + 20
+ ,nY // + 20
+ ,nWidth // - 60
+ ,nHeight // - 60
,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
))
{
return FALSE;
}
return TRUE;
-} // end of wxFrame::OS2Create
+} // end of wxFrameOS2::OS2Create
//
// Default activation behaviour - set the focus for the first child
// subwindow found.
//
-void wxFrame::OnActivate(
+void wxFrameOS2::OnActivate(
wxActivateEvent& rEvent
)
{
- for (wxWindowList::Node* pNode = GetChildren().GetFirst();
- pNode;
- pNode = pNode->GetNext())
+ if ( rEvent.GetActive() )
+ {
+ // restore focus to the child which was last focused
+ wxLogTrace(_T("focus"), _T("wxFrame %08x activated."), m_hWnd);
+
+ wxWindow* pParent = m_pWinLastFocused ? m_pWinLastFocused->GetParent()
+ : NULL;
+ if (!pParent)
+ {
+ pParent = this;
+ }
+
+ wxSetFocusToChild( pParent
+ ,&m_pWinLastFocused
+ );
+ }
+ else // deactivating
{
- // FIXME all this is totally bogus - we need to do the same as wxPanel,
- // but how to do it without duplicating the code?
+ //
+ // Remember the last focused child if it is our child
+ //
+ m_pWinLastFocused = FindFocus();
- // restore focus
- wxWindow* pChild = pNode->GetData();
+ for (wxWindowList::Node* pNode = GetChildren().GetFirst();
+ pNode;
+ pNode = pNode->GetNext())
+ {
+ // FIXME all this is totally bogus - we need to do the same as wxPanel,
+ // but how to do it without duplicating the code?
- if (!pChild->IsTopLevel()
+ // restore focus
+ wxWindow* pChild = pNode->GetData();
+
+ if (!pChild->IsTopLevel()
#if wxUSE_TOOLBAR
- && !wxDynamicCast(pChild, wxToolBar)
+ && !wxDynamicCast(pChild, wxToolBar)
#endif // wxUSE_TOOLBAR
#if wxUSE_STATUSBAR
- && !wxDynamicCast(pChild, wxStatusBar)
+ && !wxDynamicCast(pChild, wxStatusBar)
#endif // wxUSE_STATUSBAR
- )
- {
- pChild->SetFocus();
- return;
+ )
+ {
+ pChild->SetFocus();
+ return;
+ }
}
}
-} // end of wxFrame::OnActivate
+} // end of wxFrameOS2::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 wxFrame::GetClientAreaOrigin() const
+wxPoint wxFrameOS2::GetClientAreaOrigin() const
{
wxPoint vPoint(0, 0);
}
#endif //wxUSE_TOOLBAR
return vPoint;
-} // end of wxFrame::GetClientAreaOrigin
+} // end of wxFrameOS2::GetClientAreaOrigin
// ----------------------------------------------------------------------------
// tool/status bar stuff
#if wxUSE_TOOLBAR
-wxToolBar* wxFrame::CreateToolBar(
+wxToolBar* wxFrameOS2::CreateToolBar(
long lStyle
, wxWindowID vId
, const wxString& rName
PositionToolBar();
}
return m_frameToolBar;
-} // end of wxFrame::CreateToolBar
+} // end of wxFrameOS2::CreateToolBar
-void wxFrame::PositionToolBar()
+void wxFrameOS2::PositionToolBar()
{
HWND hWndClient;
RECTL vRect;
}
#endif // wxUSE_STATUSBAR
- if ( GetToolBar() )
+ if ( m_frameToolBar )
{
int nToolbarWidth;
int nToolbarHeight;
- GetToolBar()->GetSize( &nToolbarWidth
+ m_frameToolBar->GetSize( &nToolbarWidth
,&nToolbarHeight
);
,wxSIZE_NO_ADJUSTMENTS
);
}
-} // end of wxFrame::PositionToolBar
+} // end of wxFrameOS2::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 wxFrame::IconizeChildFrames(
+void wxFrameOS2::IconizeChildFrames(
bool bIconize
)
{
((wxFrame *)pWin)->Iconize(bIconize);
}
}
-} // end of wxFrame::IconizeChildFrames
+} // end of wxFrameOS2::IconizeChildFrames
// ===========================================================================
// message processing
// ---------------------------------------------------------------------------
// preprocessing
// ---------------------------------------------------------------------------
-bool wxFrame::OS2TranslateMessage(
+bool wxFrameOS2::OS2TranslateMessage(
WXMSG* pMsg
)
{
#else
return FALSE;
#endif //wxUSE_ACCEL
-} // end of wxFrame::OS2TranslateMessage
+} // end of wxFrameOS2::OS2TranslateMessage
// ---------------------------------------------------------------------------
// our private (non virtual) message handlers
// ---------------------------------------------------------------------------
-bool wxFrame::HandlePaint()
+bool wxFrameOS2::HandlePaint()
{
RECTL vRect;
}
else
{
- wxWindow::HandlePaint();
- return TRUE;
+ return(wxWindow::HandlePaint());
}
}
else
return TRUE;
}
return FALSE;
-} // end of wxFrame::HandlePaint
+} // end of wxFrameOS2::HandlePaint
-bool wxFrame::HandleSize(
+bool wxFrameOS2::HandleSize(
int nX
, int nY
, WXUINT nId
// restore all child frames too
//
IconizeChildFrames(FALSE);
+ (void)SendIconizeEvent(FALSE);
//
// fall through
// Iconize all child frames too
//
IconizeChildFrames(TRUE);
+ (void)SendIconizeEvent();
m_bIconized = TRUE;
break;
}
bProcessed = GetEventHandler()->ProcessEvent(vEvent);
}
return bProcessed;
-} // end of wxFrame::HandleSize
+} // end of wxFrameOS2::HandleSize
-bool wxFrame::HandleCommand(
+bool wxFrameOS2::HandleCommand(
WXWORD nId
, WXWORD nCmd
, WXHWND hControl
}
}
return FALSE;
-} // end of wxFrame::HandleCommand
+} // end of wxFrameOS2::HandleCommand
-bool wxFrame::HandleMenuSelect(
+bool wxFrameOS2::HandleMenuSelect(
WXWORD nItem
, WXWORD nFlags
, WXHMENU hMenu
}
}
return TRUE;
-} // end of wxFrame::HandleMenuSelect
+} // end of wxFrameOS2::HandleMenuSelect
// ---------------------------------------------------------------------------
// Main Frame window proc
return rc;
} // end of wxFrameWndProc
-MRESULT wxFrame::OS2WindowProc(
+MRESULT wxFrameOS2::OS2WindowProc(
WXUINT uMessage
, WXWPARAM wParam
, WXLPARAM lParam
break;
case WM_PAINT:
- {
- HPS hPS;
- RECTL vRect;
- wxPaintEvent vEvent;
-
- hPS = WinBeginPaint(m_hWnd, 0L, &vRect);
- ::WinFillRect(hPS, &vRect, CLR_BLUE /* SYSCLR_WINDOW */);
- ::WinEndPaint(hPS);
+ bProcessed = HandlePaint();
+ mRc = (MRESULT)FALSE;
+ break;
- mRc = (MRESULT)FALSE;
- vEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(vEvent);
- bProcessed = TRUE;
- }
+ case WM_ERASEBACKGROUND:
+ //
+ // Returning TRUE to requests PM to paint the window background
+ // in SYSCLR_WINDOW. We capture this here because the PS returned
+ // in Frames is the PS for the whole frame, which we can't really
+ // use at all. If you want to paint a different background, do it
+ // in an OnPaint using a wxPaintDC.
+ //
+ mRc = (MRESULT)(TRUE);
break;
- case WM_COMMAND:
+ case WM_COMMAND:
{
WORD wId;
WORD wCmd;
mRc = (MRESULT)FALSE;
break;
- case WM_ERASEBACKGROUND:
- //
- // Return TRUE to request PM to paint the window background
- // in SYSCLR_WINDOW.
- //
- bProcessed = TRUE;
- mRc = (MRESULT)(TRUE);
- break;
-
case CM_QUERYDRAGIMAGE:
{
HPOINTER hIcon;
,lParam
);
return (MRESULT)mRc;
-} // wxFrame::OS2WindowProc
+} // wxFrameOS2::OS2WindowProc
-void wxFrame::SetClient(WXHWND c_Hwnd)
+void wxFrameOS2::SetClient(WXHWND c_Hwnd)
{
// Duh...nothing to do under OS/2
}
-void wxFrame::SetClient(
+void wxFrameOS2::SetClient(
wxWindow* pWindow
)
{
}
}
-wxWindow* wxFrame::GetClient()
+wxWindow* wxFrameOS2::GetClient()
{
return wxFindWinFromHandle((WXHWND)::WinWindowFromID(m_hFrame, FID_CLIENT));
}
projects / wxWidgets.git / blobdiff