git.saurik.com Git - wxWidgets.git/blame_incremental

... / ...

Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/os2/frame.cpp
	3	// Purpose: wxFrame
	4	// Author: David Webster
	5	// Modified by:
	6	// Created: 10/27/99
	7	// Copyright: (c) David Webster
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	// For compilers that support precompilation, includes "wx.h".
	12	#include "wx/wxprec.h"
	13
	14	#ifndef WX_PRECOMP
	15	#include "wx/object.h"
	16	#include "wx/dynarray.h"
	17	#include "wx/list.h"
	18	#include "wx/hash.h"
	19	#include "wx/string.h"
	20	#include "wx/intl.h"
	21	#include "wx/log.h"
	22	#include "wx/event.h"
	23	#include "wx/frame.h"
	24	#include "wx/menu.h"
	25	#include "wx/app.h"
	26	#include "wx/utils.h"
	27	#include "wx/dialog.h"
	28	#include "wx/settings.h"
	29	#include "wx/dcclient.h"
	30	#include "wx/mdi.h"
	31	#include "wx/toolbar.h"
	32	#include "wx/statusbr.h"
	33	#include "wx/menuitem.h"
	34	#endif // WX_PRECOMP
	35
	36	#include "wx/os2/private.h"
	37
	38	// ----------------------------------------------------------------------------
	39	// globals
	40	// ----------------------------------------------------------------------------
	41
	42	#if wxUSE_MENUS_NATIVE
	43	extern wxMenu *wxCurrentPopupMenu;
	44	#endif
	45
	46	// ----------------------------------------------------------------------------
	47	// event tables
	48	// ----------------------------------------------------------------------------
	49
	50	BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
	51	EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
	52	END_EVENT_TABLE()
	53
	54	// ============================================================================
	55	// implementation
	56	// ============================================================================
	57
	58	// ----------------------------------------------------------------------------
	59	// static class members
	60	// ----------------------------------------------------------------------------
	61	#if wxUSE_STATUSBAR
	62
	63	#if wxUSE_NATIVE_STATUSBAR
	64	bool wxFrame::m_bUseNativeStatusBar = true;
	65	#else
	66	bool wxFrame::m_bUseNativeStatusBar = false;
	67	#endif
	68
	69	#endif //wxUSE_STATUSBAR
	70
	71	// ----------------------------------------------------------------------------
	72	// creation/destruction
	73	// ----------------------------------------------------------------------------
	74
	75	void wxFrame::Init()
	76	{
	77	m_nFsStatusBarFields = 0;
	78	m_nFsStatusBarHeight = 0;
	79	m_nFsToolBarHeight = 0;
	80	m_hWndToolTip = 0L;
	81	m_bWasMinimized = false;
	82
	83
	84	m_frameMenuBar = NULL;
	85	m_frameToolBar = NULL;
	86	m_frameStatusBar = NULL;
	87
	88	m_hTitleBar = NULLHANDLE;
	89	m_hHScroll = NULLHANDLE;
	90	m_hVScroll = NULLHANDLE;
	91
	92	//
	93	// Initialize SWP's
	94	//
	95	memset(&m_vSwpTitleBar, 0, sizeof(SWP));
	96	memset(&m_vSwpMenuBar, 0, sizeof(SWP));
	97	memset(&m_vSwpHScroll, 0, sizeof(SWP));
	98	memset(&m_vSwpVScroll, 0, sizeof(SWP));
	99	memset(&m_vSwpStatusBar, 0, sizeof(SWP));
	100	memset(&m_vSwpToolBar, 0, sizeof(SWP));
	101	m_bIconized = false;
	102
	103	} // end of wxFrame::Init
	104
	105	bool wxFrame::Create( wxWindow* pParent,
	106	wxWindowID vId,
	107	const wxString& rsTitle,
	108	const wxPoint& rPos,
	109	const wxSize& rSize,
	110	long lStyle,
	111	const wxString& rsName )
	112	{
	113	if (!wxTopLevelWindow::Create( pParent
	114	,vId
	115	,rsTitle
	116	,rPos
	117	,rSize
	118	,lStyle
	119	,rsName
	120	))
	121	return false;
	122	return true;
	123	} // end of wxFrame::Create
	124
	125	wxFrame::~wxFrame()
	126	{
	127	SendDestroyEvent();
	128
	129	DeleteAllBars();
	130	} // end of wxFrame::~wxFrame
	131
	132	//
	133	// Get size available for subwindows i.e. excluding menu bar, toolbar etc.
	134	//
	135	void wxFrame::DoGetClientSize(
	136	int* pX
	137	, int* pY
	138	) const
	139	{
	140	wxTopLevelWindow::DoGetClientSize( pX
	141	,pY
	142	);
	143	//
	144	// No need to use statusbar code as in WIN32 as the FORMATFRAME
	145	// window procedure ensures PM knows about the new frame client
	146	// size internally. A ::WinQueryWindowRect (that is called in
	147	// wxWindow's GetClient size from above) is all that is needed!
	148	//
	149	} // end of wxFrame::DoGetClientSize
	150
	151	//
	152	// Set the client size (i.e. leave the calculation of borders etc.
	153	// to wxWidgets)
	154	//
	155	void wxFrame::DoSetClientSize(
	156	int nWidth
	157	, int nHeight
	158	)
	159	{
	160	//
	161	// Statusbars are not part of the OS/2 Client but parent frame
	162	// so no statusbar consideration
	163	//
	164	wxTopLevelWindow::DoSetClientSize( nWidth
	165	,nHeight
	166	);
	167	} // end of wxFrame::DoSetClientSize
	168
	169	// ----------------------------------------------------------------------------
	170	// wxFrame: various geometry-related functions
	171	// ----------------------------------------------------------------------------
	172
	173	void wxFrame::Raise()
	174	{
	175	wxFrameBase::Raise();
	176	::WinSetWindowPos( (HWND) GetParent()->GetHWND()
	177	,HWND_TOP
	178	,0
	179	,0
	180	,0
	181	,0
	182	,SWP_ZORDER
	183	);
	184	}
	185
	186	#if wxUSE_STATUSBAR
	187	wxStatusBar* wxFrame::OnCreateStatusBar(
	188	int nNumber
	189	, long lulStyle
	190	, wxWindowID vId
	191	, const wxString& rName
	192	)
	193	{
	194	wxStatusBar* pStatusBar = NULL;
	195	wxString sError;
	196
	197	pStatusBar = wxFrameBase::OnCreateStatusBar( nNumber
	198	,lulStyle
	199	,vId
	200	,rName
	201	);
	202
	203	if( !pStatusBar )
	204	return NULL;
	205
	206	wxClientDC vDC(pStatusBar);
	207	int nY;
	208
	209	//
	210	// Set the height according to the font and the border size
	211	//
	212	vDC.SetFont(pStatusBar->GetFont()); // Screws up the menues for some reason
	213	vDC.GetTextExtent( wxT("X")
	214	,NULL
	215	,&nY
	216	);
	217
	218	int nHeight = ((11 * nY) / 10 + 2 * pStatusBar->GetBorderY());
	219
	220	pStatusBar->SetSize( wxDefaultCoord
	221	,wxDefaultCoord
	222	,wxDefaultCoord
	223	,nHeight
	224	);
	225
	226	::WinSetParent( pStatusBar->GetHWND(), m_hFrame, FALSE );
	227	::WinSetOwner( pStatusBar->GetHWND(), m_hFrame);
	228	//
	229	// to show statusbar
	230	//
	231	if(::WinIsWindowShowing(m_hFrame))
	232	::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
	233
	234	return pStatusBar;
	235	} // end of wxFrame::OnCreateStatusBar
	236
	237	void wxFrame::PositionStatusBar()
	238	{
	239	SWP vSwp;
	240	ERRORID vError;
	241	wxString sError;
	242
	243	//
	244	// Native status bar positions itself
	245	//
	246	if (m_frameStatusBar)
	247	{
	248	int nWidth;
	249	int nY;
	250	int nStatbarWidth;
	251	int nStatbarHeight;
	252	RECTL vRect;
	253	RECTL vFRect;
	254
	255	::WinQueryWindowRect(m_hFrame, &vRect);
	256	nY = vRect.yTop;
	257	::WinMapWindowPoints(m_hFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2);
	258	vFRect = vRect;
	259	::WinCalcFrameRect(m_hFrame, &vRect, TRUE);
	260	nWidth = vRect.xRight - vRect.xLeft;
	261	nY = nY - (vRect.yBottom - vFRect.yBottom);
	262
	263	m_frameStatusBar->GetSize( &nStatbarWidth
	264	,&nStatbarHeight
	265	);
	266
	267	nY= nY - nStatbarHeight;
	268	//
	269	// Since we wish the status bar to be directly under the client area,
	270	// we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
	271	//
	272	m_frameStatusBar->SetSize( vRect.xLeft - vFRect.xLeft
	273	,nY
	274	,nWidth
	275	,nStatbarHeight
	276	);
	277	if (!::WinQueryWindowPos(m_frameStatusBar->GetHWND(), &vSwp))
	278	{
	279	vError = ::WinGetLastError(vHabmain);
	280	sError = wxPMErrorToStr(vError);
	281	wxLogError(wxT("Error setting parent for StatusBar. Error: %s\n"), sError.c_str());
	282	return;
	283	}
	284	}
	285	} // end of wxFrame::PositionStatusBar
	286	#endif // wxUSE_STATUSBAR
	287
	288	#if wxUSE_TOOLBAR
	289	wxToolBar* wxFrame::OnCreateToolBar( long lStyle, wxWindowID vId, const wxString& rsName )
	290	{
	291	wxToolBar* pToolBar = wxFrameBase::OnCreateToolBar( lStyle
	292	,vId
	293	,rsName
	294	);
	295
	296	::WinSetParent( pToolBar->GetHWND(), m_hFrame, FALSE);
	297	::WinSetOwner( pToolBar->GetHWND(), m_hFrame);
	298	return pToolBar;
	299	} // end of WinGuiBase_CFrame::OnCreateToolBar
	300	#endif
	301
	302	#if wxUSE_MENUS_NATIVE
	303	void wxFrame::DetachMenuBar()
	304	{
	305	if (m_frameMenuBar)
	306	{
	307	m_frameMenuBar->Detach();
	308	m_frameMenuBar = NULL;
	309	}
	310	} // end of wxFrame::DetachMenuBar
	311
	312	void wxFrame::SetMenuBar(
	313	wxMenuBar* pMenuBar
	314	)
	315	{
	316	wxString sError;
	317
	318	if (!pMenuBar)
	319	{
	320	DetachMenuBar();
	321
	322	//
	323	// Actually remove the menu from the frame
	324	//
	325	m_hMenu = (WXHMENU)0;
	326	InternalSetMenuBar();
	327	}
	328	else // set new non NULL menu bar
	329	{
	330	m_frameMenuBar = NULL;
	331
	332	//
	333	// Can set a menubar several times.
	334	// TODO: how to prevent a memory leak if you have a currently-unattached
	335	// menubar? wxWidgets assumes that the frame will delete the menu (otherwise
	336	// there are problems for MDI).
	337	//
	338	if (pMenuBar->GetHMenu())
	339	{
	340	m_hMenu = pMenuBar->GetHMenu();
	341	}
	342	else
	343	{
	344	pMenuBar->Detach();
	345	m_hMenu = pMenuBar->Create();
	346	if (!m_hMenu)
	347	return;
	348	}
	349	InternalSetMenuBar();
	350	m_frameMenuBar = pMenuBar;
	351	pMenuBar->Attach((wxFrame*)this);
	352	}
	353	} // end of wxFrame::SetMenuBar
	354
	355	void wxFrame::AttachMenuBar(
	356	wxMenuBar* pMenubar
	357	)
	358	{
	359	wxFrameBase::AttachMenuBar(pMenubar);
	360
	361	m_frameMenuBar = pMenubar;
	362
	363	if (!pMenubar)
	364	{
	365	//
	366	// Actually remove the menu from the frame
	367	//
	368	m_hMenu = (WXHMENU)0;
	369	InternalSetMenuBar();
	370	}
	371	else // Set new non NULL menu bar
	372	{
	373	//
	374	// Can set a menubar several times.
	375	//
	376	if (pMenubar->GetHMenu())
	377	{
	378	m_hMenu = pMenubar->GetHMenu();
	379	}
	380	else
	381	{
	382	if (pMenubar->IsAttached())
	383	pMenubar->Detach();
	384
	385	m_hMenu = pMenubar->Create();
	386
	387	if (!m_hMenu)
	388	return;
	389	}
	390	InternalSetMenuBar();
	391	}
	392	} // end of wxFrame::AttachMenuBar
	393
	394	void wxFrame::InternalSetMenuBar()
	395	{
	396	ERRORID vError;
	397	wxString sError;
	398	//
	399	// Set the parent and owner of the menubar to be the frame
	400	//
	401	if (!::WinSetParent(m_hMenu, m_hFrame, FALSE))
	402	{
	403	vError = ::WinGetLastError(vHabmain);
	404	sError = wxPMErrorToStr(vError);
	405	wxLogError(wxT("Error setting parent for submenu. Error: %s\n"), sError.c_str());
	406	}
	407
	408	if (!::WinSetOwner(m_hMenu, m_hFrame))
	409	{
	410	vError = ::WinGetLastError(vHabmain);
	411	sError = wxPMErrorToStr(vError);
	412	wxLogError(wxT("Error setting parent for submenu. Error: %s\n"), sError.c_str());
	413	}
	414	::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
	415	} // end of wxFrame::InternalSetMenuBar
	416	#endif // wxUSE_MENUS_NATIVE
	417
	418	//
	419	// Responds to colour changes, and passes event on to children
	420	//
	421	void wxFrame::OnSysColourChanged(
	422	wxSysColourChangedEvent& rEvent
	423	)
	424	{
	425	SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
	426	Refresh();
	427
	428	#if wxUSE_STATUSBAR
	429	if (m_frameStatusBar)
	430	{
	431	wxSysColourChangedEvent vEvent2;
	432
	433	vEvent2.SetEventObject(m_frameStatusBar);
	434	m_frameStatusBar->HandleWindowEvent(vEvent2);
	435	}
	436	#endif //wxUSE_STATUSBAR
	437
	438	//
	439	// Propagate the event to the non-top-level children
	440	//
	441	wxWindow::OnSysColourChanged(rEvent);
	442	} // end of wxFrame::OnSysColourChanged
	443
	444	// Pass true to show full screen, false to restore.
	445	bool wxFrame::ShowFullScreen( bool bShow, long lStyle )
	446	{
	447	if (bShow)
	448	{
	449	if (IsFullScreen())
	450	return false;
	451
	452	m_bFsIsShowing = true;
	453	m_lFsStyle = lStyle;
	454
	455	#if wxUSE_TOOLBAR
	456	wxToolBar* pTheToolBar = GetToolBar();
	457	#endif //wxUSE_TOOLBAR
	458
	459	#if wxUSE_STATUSBAR
	460	wxStatusBar* pTheStatusBar = GetStatusBar();
	461	#endif //wxUSE_STATUSBAR
	462
	463	int nDummyWidth;
	464
	465	#if wxUSE_TOOLBAR
	466	if (pTheToolBar)
	467	pTheToolBar->GetSize(&nDummyWidth, &m_nFsToolBarHeight);
	468	#endif //wxUSE_TOOLBAR
	469
	470	#if wxUSE_STATUSBAR
	471	if (pTheStatusBar)
	472	pTheStatusBar->GetSize(&nDummyWidth, &m_nFsStatusBarHeight);
	473	#endif //wxUSE_STATUSBAR
	474
	475	#if wxUSE_TOOLBAR
	476	//
	477	// Zap the toolbar, menubar, and statusbar
	478	//
	479	if ((lStyle & wxFULLSCREEN_NOTOOLBAR) && pTheToolBar)
	480	{
	481	pTheToolBar->SetSize(wxDefaultCoord,0);
	482	pTheToolBar->Show(false);
	483	}
	484	#endif //wxUSE_TOOLBAR
	485
	486	if (lStyle & wxFULLSCREEN_NOMENUBAR)
	487	{
	488	::WinSetParent(m_hMenu, m_hFrame, FALSE);
	489	::WinSetOwner(m_hMenu, m_hFrame);
	490	::WinSendMsg((HWND)m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
	491	}
	492
	493	#if wxUSE_STATUSBAR
	494	//
	495	// Save the number of fields in the statusbar
	496	//
	497	if ((lStyle & wxFULLSCREEN_NOSTATUSBAR) && pTheStatusBar)
	498	{
	499	m_nFsStatusBarFields = pTheStatusBar->GetFieldsCount();
	500	SetStatusBar(NULL);
	501	delete pTheStatusBar;
	502	}
	503	else
	504	m_nFsStatusBarFields = 0;
	505	#endif //wxUSE_STATUSBAR
	506
	507	//
	508	// Zap the frame borders
	509	//
	510
	511	//
	512	// Save the 'normal' window style
	513	//
	514	m_lFsOldWindowStyle = ::WinQueryWindowULong(m_hFrame, QWL_STYLE);
	515
	516	//
	517	// Save the old position, width & height, maximize state
	518	//
	519	m_vFsOldSize = GetRect();
	520	m_bFsIsMaximized = IsMaximized();
	521
	522	//
	523	// Decide which window style flags to turn off
	524	//
	525	LONG lNewStyle = m_lFsOldWindowStyle;
	526	LONG lOffFlags = 0;
	527
	528	if (lStyle & wxFULLSCREEN_NOBORDER)
	529	lOffFlags \|= FCF_BORDER;
	530	if (lStyle & wxFULLSCREEN_NOCAPTION)
	531	lOffFlags \|= (FCF_TASKLIST \| FCF_SYSMENU);
	532
	533	lNewStyle &= (~lOffFlags);
	534
	535	//
	536	// Change our window style to be compatible with full-screen mode
	537	//
	538	::WinSetWindowULong((HWND)m_hFrame, QWL_STYLE, (ULONG)lNewStyle);
	539
	540	//
	541	// Resize to the size of the desktop
	542	int nWidth;
	543	int nHeight;
	544
	545	RECTL vRect;
	546
	547	::WinQueryWindowRect(HWND_DESKTOP, &vRect);
	548	nWidth = vRect.xRight - vRect.xLeft;
	549	//
	550	// Remember OS/2 is backwards!
	551	//
	552	nHeight = vRect.yTop - vRect.yBottom;
	553
	554	SetSize( nWidth, nHeight);
	555
	556	//
	557	// Now flush the window style cache and actually go full-screen
	558	//
	559	::WinSetWindowPos( (HWND) GetParent()->GetHWND()
	560	,HWND_TOP
	561	,0
	562	,0
	563	,nWidth
	564	,nHeight
	565	,SWP_SIZE \| SWP_SHOW
	566	);
	567
	568	wxSize sz( nWidth, nHeight );
	569	wxSizeEvent vEvent( sz, GetId() );
	570
	571	HandleWindowEvent(vEvent);
	572	return true;
	573	}
	574	else
	575	{
	576	if (!IsFullScreen())
	577	return false;
	578
	579	m_bFsIsShowing = false;
	580
	581	#if wxUSE_TOOLBAR
	582	wxToolBar* pTheToolBar = GetToolBar();
	583
	584	//
	585	// Restore the toolbar, menubar, and statusbar
	586	//
	587	if (pTheToolBar && (m_lFsStyle & wxFULLSCREEN_NOTOOLBAR))
	588	{
	589	pTheToolBar->SetSize(wxDefaultCoord, m_nFsToolBarHeight);
	590	pTheToolBar->Show(true);
	591	}
	592	#endif //wxUSE_TOOLBAR
	593
	594	#if wxUSE_STATUSBAR
	595	if ((m_lFsStyle & wxFULLSCREEN_NOSTATUSBAR) && (m_nFsStatusBarFields > 0))
	596	{
	597	CreateStatusBar(m_nFsStatusBarFields);
	598	// PositionStatusBar();
	599	}
	600	#endif //wxUSE_STATUSBAR
	601
	602	if ((m_lFsStyle & wxFULLSCREEN_NOMENUBAR) && (m_hMenu != 0))
	603	{
	604	::WinSetParent(m_hMenu, m_hFrame, FALSE);
	605	::WinSetOwner(m_hMenu, m_hFrame);
	606	::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
	607	}
	608	Maximize(m_bFsIsMaximized);
	609
	610	::WinSetWindowULong( m_hFrame
	611	,QWL_STYLE
	612	,(ULONG)m_lFsOldWindowStyle
	613	);
	614	::WinSetWindowPos( (HWND) GetParent()->GetHWND()
	615	,HWND_TOP
	616	,m_vFsOldSize.x
	617	,m_vFsOldSize.y
	618	,m_vFsOldSize.width
	619	,m_vFsOldSize.height
	620	,SWP_SIZE \| SWP_SHOW
	621	);
	622	}
	623	return wxFrameBase::ShowFullScreen(bShow, lStyle);
	624	} // end of wxFrame::ShowFullScreen
	625
	626	//
	627	// Frame window
	628	//
	629	// ----------------------------------------------------------------------------
	630	// wxFrame size management: we exclude the areas taken by menu/status/toolbars
	631	// from the client area, so the client area is what's really available for the
	632	// frame contents
	633	// ----------------------------------------------------------------------------
	634
	635	// Checks if there is a toolbar, and returns the first free client position
	636	wxPoint wxFrame::GetClientAreaOrigin() const
	637	{
	638	wxPoint vPoint = wxTopLevelWindow::GetClientAreaOrigin();
	639
	640	//
	641	// In OS/2 the toolbar and statusbar are frame extensions so there is no
	642	// adjustment. The client is supposedly resized for a toolbar in OS/2
	643	// as it is for the status bar.
	644	//
	645	return vPoint;
	646	} // end of wxFrame::GetClientAreaOrigin
	647
	648	// ----------------------------------------------------------------------------
	649	// tool/status bar stuff
	650	// ----------------------------------------------------------------------------
	651
	652	#if wxUSE_TOOLBAR
	653
	654	wxToolBar* wxFrame::CreateToolBar(
	655	long lStyle
	656	, wxWindowID vId
	657	, const wxString& rName
	658	)
	659	{
	660	if (wxFrameBase::CreateToolBar( lStyle
	661	,vId
	662	,rName
	663	))
	664	{
	665	PositionToolBar();
	666	}
	667	return m_frameToolBar;
	668	} // end of wxFrame::CreateToolBar
	669
	670	void wxFrame::PositionToolBar()
	671	{
	672	wxToolBar* pToolBar = GetToolBar();
	673	wxCoord vWidth;
	674	wxCoord vHeight;
	675	wxCoord vTWidth;
	676	wxCoord vTHeight;
	677
	678	if (!pToolBar)
	679	return;
	680
	681	RECTL vRect;
	682	RECTL vFRect;
	683	wxPoint vPos;
	684
	685	::WinQueryWindowRect(m_hFrame, &vRect);
	686	vPos.y = (wxCoord)vRect.yTop;
	687	::WinMapWindowPoints(m_hFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2);
	688	vFRect = vRect;
	689	::WinCalcFrameRect(m_hFrame, &vRect, TRUE);
	690
	691	vPos.y = (wxCoord)(vFRect.yTop - vRect.yTop);
	692	pToolBar->GetSize( &vTWidth
	693	,&vTHeight
	694	);
	695
	696	if (pToolBar->GetWindowStyleFlag() & wxTB_TOP)
	697	{
	698	vWidth = (wxCoord)(vRect.xRight - vRect.xLeft);
	699	pToolBar->SetSize( vRect.xLeft - vFRect.xLeft
	700	,vPos.y
	701	,vWidth
	702	,vTHeight
	703	);
	704	}
	705	else if (pToolBar->GetWindowStyleFlag() & wxTB_BOTTOM)
	706	{
	707	wxCoord vSwidth = 0;
	708	wxCoord vSheight = 0;
	709
	710	if (m_frameStatusBar)
	711	m_frameStatusBar->GetSize( &vSwidth
	712	,&vSheight
	713	);
	714	vWidth = (wxCoord)(vRect.xRight - vRect.xLeft);
	715	pToolBar->SetSize( vRect.xLeft - vFRect.xLeft
	716	,vFRect.yTop - vRect.yBottom - vTHeight - vSheight
	717	,vWidth
	718	,vTHeight
	719	);
	720	}
	721	else if (pToolBar->GetWindowStyleFlag() & wxTB_LEFT)
	722	{
	723	wxCoord vSwidth = 0;
	724	wxCoord vSheight = 0;
	725
	726	if (m_frameStatusBar)
	727	m_frameStatusBar->GetSize( &vSwidth
	728	,&vSheight
	729	);
	730	vHeight = (wxCoord)(vRect.yTop - vRect.yBottom);
	731	pToolBar->SetSize( vRect.xLeft - vRect.xLeft
	732	,vPos.y
	733	,vTWidth
	734	,vHeight - vSheight
	735	);
	736	}
	737	else
	738	{
	739	wxCoord vSwidth = 0;
	740	wxCoord vSheight = 0;
	741
	742	if (m_frameStatusBar)
	743	m_frameStatusBar->GetSize( &vSwidth
	744	,&vSheight
	745	);
	746	vHeight = (wxCoord)(vRect.yTop - vRect.yBottom);
	747	pToolBar->SetSize( vRect.xRight - vFRect.xLeft - vTWidth
	748	,vPos.y
	749	,vTWidth
	750	,vHeight - vSheight
	751	);
	752	}
	753	if( ::WinIsWindowShowing(m_hFrame) )
	754	::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
	755	} // end of wxFrame::PositionToolBar
	756	#endif // wxUSE_TOOLBAR
	757
	758	// ----------------------------------------------------------------------------
	759	// frame state (iconized/maximized/...)
	760	// ----------------------------------------------------------------------------
	761
	762	//
	763	// propagate our state change to all child frames: this allows us to emulate X
	764	// Windows behaviour where child frames float independently of the parent one
	765	// on the desktop, but are iconized/restored with it
	766	//
	767	void wxFrame::IconizeChildFrames( bool WXUNUSED(bIconize) )
	768	{
	769	// FIXME: Generic MDI does not use Frames for the Childs, so this does _not_
	770	// work. Possibly, the right thing is simply to eliminate this
	771	// functions and all the calls to it from within this file.
	772	#if 0
	773	for (wxWindowList::Node* pNode = GetChildren().GetFirst();
	774	pNode;
	775	pNode = pNode->GetNext() )
	776	{
	777	wxWindow* pWin = pNode->GetData();
	778	wxFrame* pFrame = wxDynamicCast(pWin, wxFrame);
	779
	780	if ( pFrame
	781	#if wxUSE_MDI_ARCHITECTURE
	782	&& !wxDynamicCast(pFrame, wxMDIChildFrame)
	783	#endif // wxUSE_MDI_ARCHITECTURE
	784	)
	785	{
	786	//
	787	// We don't want to restore the child frames which had been
	788	// iconized even before we were iconized, so save the child frame
	789	// status when iconizing the parent frame and check it when
	790	// restoring it.
	791	//
	792	if (bIconize)
	793	{
	794	pFrame->m_bWasMinimized = pFrame->IsIconized();
	795	}
	796
	797	//
	798	// This test works for both iconizing and restoring
	799	//
	800	if (!pFrame->m_bWasMinimized)
	801	pFrame->Iconize(bIconize);
	802	}
	803	}
	804	#endif
	805	} // end of wxFrame::IconizeChildFrames
	806
	807	WXHICON wxFrame::GetDefaultIcon() const
	808	{
	809	return (WXHICON)(wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON
	810	: wxDEFAULT_FRAME_ICON);
	811	}
	812	// ===========================================================================
	813	// message processing
	814	// ===========================================================================
	815
	816	// ---------------------------------------------------------------------------
	817	// preprocessing
	818	// ---------------------------------------------------------------------------
	819	bool wxFrame::OS2TranslateMessage( WXMSG* pMsg )
	820	{
	821	//
	822	// try the menu bar accels
	823	//
	824	wxMenuBar* pMenuBar = GetMenuBar();
	825
	826	if (!pMenuBar)
	827	return false;
	828
	829	#if wxUSE_ACCEL && wxUSE_MENUS_NATIVE
	830	const wxAcceleratorTable& rAcceleratorTable = pMenuBar->GetAccelTable();
	831	return rAcceleratorTable.Translate(GetHWND(), pMsg);
	832	#else
	833	return false;
	834	#endif //wxUSE_ACCEL
	835	} // end of wxFrame::OS2TranslateMessage
	836
	837	// ---------------------------------------------------------------------------
	838	// our private (non virtual) message handlers
	839	// ---------------------------------------------------------------------------
	840	bool wxFrame::HandlePaint()
	841	{
	842	RECTL vRect;
	843
	844	if (::WinQueryUpdateRect(GetHWND(), &vRect))
	845	{
	846	if (m_bIconized)
	847	{
	848	//
	849	// Icons in PM are the same as "pointers"
	850	//
	851	const wxIcon& vIcon = GetIcon();
	852	HPOINTER hIcon;
	853
	854	if (vIcon.IsOk())
	855	hIcon = (HPOINTER)::WinSendMsg(m_hFrame, WM_QUERYICON, 0L, 0L);
	856	else
	857	hIcon = (HPOINTER)m_hDefaultIcon;
	858
	859	//
	860	// Hold a pointer to the dc so long as the OnPaint() message
	861	// is being processed
	862	//
	863	RECTL vRect2;
	864	HPS hPs = ::WinBeginPaint(GetHwnd(), NULLHANDLE, &vRect2);
	865
	866	//
	867	// Erase background before painting or we get white background
	868	//
	869	OS2DefWindowProc(WM_ERASEBACKGROUND, (MPARAM)hPs, (MPARAM)&vRect2);
	870
	871	if (hIcon)
	872	{
	873	RECTL vRect3;
	874
	875	::WinQueryWindowRect(GetHwnd(), &vRect3);
	876
	877	static const int nIconWidth = 32;
	878	static const int nIconHeight = 32;
	879	int nIconX = (int)((vRect3.xRight - nIconWidth)/2);
	880	int nIconY = (int)((vRect3.yBottom + nIconHeight)/2);
	881
	882	::WinDrawPointer(hPs, nIconX, nIconY, hIcon, DP_NORMAL);
	883	}
	884	::WinEndPaint(hPs);
	885	}
	886	else
	887	{
	888	if (!wxWindow::HandlePaint())
	889	{
	890	HPS hPS;
	891	RECTL vRect;
	892
	893	hPS = ::WinBeginPaint( GetHwnd()
	894	,NULLHANDLE
	895	,&vRect
	896	);
	897	if(hPS)
	898	{
	899	::GpiCreateLogColorTable( hPS
	900	,0L
	901	,LCOLF_CONSECRGB
	902	,0L
	903	,(LONG)wxTheColourDatabase->m_nSize
	904	,(PLONG)wxTheColourDatabase->m_palTable
	905	);
	906	::GpiCreateLogColorTable( hPS
	907	,0L
	908	,LCOLF_RGB
	909	,0L
	910	,0L
	911	,NULL
	912	);
	913
	914	::WinFillRect( hPS
	915	,&vRect
	916	,GetBackgroundColour().GetPixel()
	917	);
	918	::WinEndPaint(hPS);
	919	}
	920	}
	921	}
	922	}
	923
	924	return true;
	925	} // end of wxFrame::HandlePaint
	926
	927	bool wxFrame::HandleSize( int nX, int nY, WXUINT nId )
	928	{
	929	bool bProcessed = false;
	930
	931	switch (nId)
	932	{
	933	case kSizeNormal:
	934	//
	935	// Only do it it if we were iconized before, otherwise resizing the
	936	// parent frame has a curious side effect of bringing it under it's
	937	// children
	938	if (!m_bIconized )
	939	break;
	940
	941	//
	942	// restore all child frames too
	943	//
	944	IconizeChildFrames(false);
	945	(void)SendIconizeEvent(false);
	946
	947	//
	948	// fall through
	949	//
	950
	951	case kSizeMax:
	952	m_bIconized = false;
	953	break;
	954
	955	case kSizeMin:
	956	//
	957	// Iconize all child frames too
	958	//
	959	IconizeChildFrames(true);
	960	(void)SendIconizeEvent();
	961	m_bIconized = true;
	962	break;
	963	}
	964
	965	if (!m_bIconized)
	966	{
	967	//
	968	// forward WM_SIZE to status bar control
	969	//
	970	#if wxUSE_NATIVE_STATUSBAR
	971	if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
	972	{
	973	wxSizeEvent vEvent( wxSize( nX
	974	,nY
	975	)
	976	,m_frameStatusBar->GetId()
	977	);
	978
	979	vEvent.SetEventObject(m_frameStatusBar);
	980	m_frameStatusBar->OnSize(vEvent);
	981	}
	982	#endif // wxUSE_NATIVE_STATUSBAR
	983
	984	PositionStatusBar();
	985	#if wxUSE_TOOLBAR
	986	PositionToolBar();
	987	#endif // wxUSE_TOOLBAR
	988
	989	bProcessed = wxWindow::HandleSize( nX
	990	,nY
	991	,nId
	992	);
	993	}
	994	return bProcessed;
	995	} // end of wxFrame::HandleSize
	996
	997	bool wxFrame::HandleCommand( WXWORD nId,
	998	WXWORD nCmd,
	999	WXHWND hControl )
	1000	{
	1001	if (hControl)
	1002	{
	1003	//
	1004	// In case it's e.g. a toolbar.
	1005	//
	1006	wxWindow* pWin = wxFindWinFromHandle(hControl);
	1007
	1008	if (pWin)
	1009	return pWin->OS2Command( nCmd, nId );
	1010	}
	1011
	1012	//
	1013	// Handle here commands from menus and accelerators
	1014	//
	1015	if (nCmd == CMDSRC_MENU \|\| nCmd == CMDSRC_ACCELERATOR)
	1016	{
	1017	#if wxUSE_MENUS_NATIVE
	1018	if (wxCurrentPopupMenu)
	1019	{
	1020	wxMenu* pPopupMenu = wxCurrentPopupMenu;
	1021
	1022	wxCurrentPopupMenu = NULL;
	1023
	1024	return pPopupMenu->OS2Command( nCmd, nId );
	1025	}
	1026	#endif
	1027
	1028	if (ProcessCommand(nId))
	1029	{
	1030	return true;
	1031	}
	1032	}
	1033	return false;
	1034	} // end of wxFrame::HandleCommand
	1035
	1036	bool wxFrame::HandleMenuSelect( WXWORD nItem,
	1037	WXWORD nFlags,
	1038	WXHMENU hMenu )
	1039	{
	1040	if( !nFlags )
	1041	{
	1042	MENUITEM mItem;
	1043	MRESULT rc;
	1044
	1045	rc = ::WinSendMsg(hMenu, MM_QUERYITEM, MPFROM2SHORT(nItem, TRUE), (MPARAM)&mItem);
	1046
	1047	if(rc && !(mItem.afStyle & (MIS_SUBMENU \| MIS_SEPARATOR)))
	1048	{
	1049	wxMenuEvent vEvent(wxEVT_MENU_HIGHLIGHT, nItem);
	1050
	1051	vEvent.SetEventObject(this);
	1052	HandleWindowEvent(vEvent); // return value would be ignored by PM
	1053	}
	1054	else
	1055	{
	1056	DoGiveHelp(wxEmptyString, true);
	1057	return false;
	1058	}
	1059	}
	1060	return true;
	1061	} // end of wxFrame::HandleMenuSelect
	1062
	1063	// ---------------------------------------------------------------------------
	1064	// Main Frame window proc
	1065	// ---------------------------------------------------------------------------
	1066	MRESULT EXPENTRY wxFrameMainWndProc( HWND hWnd,
	1067	ULONG ulMsg,
	1068	MPARAM wParam,
	1069	MPARAM lParam )
	1070	{
	1071	MRESULT rc = (MRESULT)0;
	1072	bool bProcessed = false;
	1073
	1074	wxFrame* pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
	1075	switch (ulMsg)
	1076	{
	1077	case WM_QUERYFRAMECTLCOUNT:
	1078	if(pWnd && pWnd->m_fnOldWndProc)
	1079	{
	1080	USHORT uItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
	1081
	1082	rc = MRFROMSHORT(uItemCount);
	1083	}
	1084	break;
	1085
	1086	case WM_FORMATFRAME:
	1087	/////////////////////////////////////////////////////////////////////////////////
	1088	// Applications that subclass frame controls may find that the frame is already
	1089	// subclassed the number of frame controls is variable.
	1090	// The WM_FORMATFRAME and WM_QUERYFRAMECTLCOUNT messages must always be
	1091	// subclassed by calling the previous window procedure and modifying its result.
	1092	////////////////////////////////////////////////////////////////////////////////
	1093	{
	1094	int nItemCount;
	1095	int i;
	1096	PSWP pSWP = NULL;
	1097	RECTL vRectl;
	1098	RECTL vRstb;
	1099	RECTL vRtlb;
	1100	int nHeight = 0;
	1101	int nHeight2 = 0;
	1102	int nWidth = 0;
	1103
	1104	pSWP = (PSWP)PVOIDFROMMP(wParam);
	1105	nItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
	1106	if(pWnd->m_frameStatusBar)
	1107	{
	1108	::WinQueryWindowRect(pWnd->m_frameStatusBar->GetHWND(), &vRstb);
	1109	pWnd->m_frameStatusBar->GetSize(NULL, &nHeight);
	1110	}
	1111	if(pWnd->m_frameToolBar)
	1112	{
	1113	::WinQueryWindowRect(pWnd->m_frameToolBar->GetHWND(), &vRtlb);
	1114	pWnd->m_frameToolBar->GetSize(&nWidth, &nHeight2);
	1115	}
	1116	::WinQueryWindowRect(pWnd->m_hFrame, &vRectl);
	1117	::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2);
	1118	::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE);
	1119	::WinMapWindowPoints(HWND_DESKTOP, pWnd->m_hFrame, (PPOINTL)&vRectl, 2);
	1120	for(i = 0; i < nItemCount; i++)
	1121	{
	1122	if(pWnd->m_hWnd && pSWP[i].hwnd == pWnd->m_hWnd)
	1123	{
	1124	if (pWnd->m_frameToolBar && pWnd->m_frameToolBar->GetWindowStyleFlag() & wxTB_TOP)
	1125	{
	1126	pSWP[i].x = vRectl.xLeft;
	1127	pSWP[i].y = vRectl.yBottom + nHeight;
	1128	pSWP[i].cx = vRectl.xRight - vRectl.xLeft;
	1129	pSWP[i].cy = vRectl.yTop - vRectl.yBottom - (nHeight + nHeight2);
	1130	}
	1131	else if (pWnd->m_frameToolBar && pWnd->m_frameToolBar->GetWindowStyleFlag() & wxTB_BOTTOM)
	1132	{
	1133	pSWP[i].x = vRectl.xLeft;
	1134	pSWP[i].y = vRectl.yBottom + nHeight + nHeight2;
	1135	pSWP[i].cx = vRectl.xRight - vRectl.xLeft;
	1136	pSWP[i].cy = vRectl.yTop - vRectl.yBottom - (nHeight + nHeight2);
	1137	}
	1138	else if (pWnd->m_frameToolBar && pWnd->m_frameToolBar->GetWindowStyleFlag() & wxTB_LEFT)
	1139	{
	1140	pSWP[i].x = vRectl.xLeft + nWidth;
	1141	pSWP[i].y = vRectl.yBottom + nHeight;
	1142	pSWP[i].cx = vRectl.xRight - (vRectl.xLeft + nWidth);
	1143	pSWP[i].cy = vRectl.yTop - vRectl.yBottom - nHeight;
	1144	}
	1145	else
	1146	{
	1147	pSWP[i].x = vRectl.xLeft;
	1148	pSWP[i].y = vRectl.yBottom + nHeight;
	1149	pSWP[i].cx = vRectl.xRight - (vRectl.xLeft + nWidth);
	1150	pSWP[i].cy = vRectl.yTop - vRectl.yBottom - nHeight;
	1151	}
	1152	pSWP[i].fl = SWP_SIZE \| SWP_MOVE \| SWP_SHOW;
	1153	pSWP[i].hwndInsertBehind = HWND_TOP;
	1154	}
	1155	}
	1156	bProcessed = true;
	1157	rc = MRFROMSHORT(nItemCount);
	1158	}
	1159	break;
	1160
	1161	default:
	1162	if(pWnd && pWnd->m_fnOldWndProc)
	1163	rc = pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam);
	1164	else
	1165	rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
	1166	}
	1167	return rc;
	1168	} // end of wxFrameMainWndProc
	1169
	1170	MRESULT EXPENTRY wxFrameWndProc(
	1171	HWND hWnd
	1172	, ULONG ulMsg
	1173	, MPARAM wParam
	1174	, MPARAM lParam
	1175	)
	1176	{
	1177	//
	1178	// Trace all ulMsgs - useful for the debugging
	1179	//
	1180	HWND parentHwnd;
	1181	wxFrame* pWnd = NULL;
	1182
	1183	parentHwnd = WinQueryWindow(hWnd,QW_PARENT);
	1184	pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
	1185
	1186	//
	1187	// When we get the first message for the HWND we just created, we associate
	1188	// it with wxWindow stored in wxWndHook
	1189	//
	1190
	1191	MRESULT rc = (MRESULT)0;
	1192
	1193	//
	1194	// Stop right here if we don't have a valid handle in our wxWindow object.
	1195	//
	1196	if (pWnd && !pWnd->GetHWND())
	1197	{
	1198	pWnd->SetHWND((WXHWND) hWnd);
	1199	rc = pWnd->OS2DefWindowProc(ulMsg, wParam, lParam );
	1200	pWnd->SetHWND(0);
	1201	}
	1202	else
	1203	{
	1204	if (pWnd)
	1205	rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam);
	1206	else
	1207	rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
	1208	}
	1209	return rc;
	1210	} // end of wxFrameWndProc
	1211
	1212	MRESULT wxFrame::OS2WindowProc( WXUINT uMessage,
	1213	WXWPARAM wParam,
	1214	WXLPARAM lParam )
	1215	{
	1216	MRESULT mRc = 0L;
	1217	bool bProcessed = false;
	1218
	1219	switch (uMessage)
	1220	{
	1221	case WM_CLOSE:
	1222	//
	1223	// If we can't close, tell the system that we processed the
	1224	// message - otherwise it would close us
	1225	//
	1226	bProcessed = !Close();
	1227	break;
	1228
	1229	case WM_PAINT:
	1230	bProcessed = HandlePaint();
	1231	mRc = (MRESULT)FALSE;
	1232	break;
	1233
	1234	case WM_ERASEBACKGROUND:
	1235	//
	1236	// Returning TRUE to requests PM to paint the window background
	1237	// in SYSCLR_WINDOW. We capture this here because the PS returned
	1238	// in Frames is the PS for the whole frame, which we can't really
	1239	// use at all. If you want to paint a different background, do it
	1240	// in an OnPaint using a wxPaintDC.
	1241	//
	1242	mRc = (MRESULT)(TRUE);
	1243	break;
	1244
	1245	case WM_COMMAND:
	1246	{
	1247	WORD wId;
	1248	WORD wCmd;
	1249	WXHWND hWnd;
	1250
	1251	UnpackCommand( (WXWPARAM)wParam
	1252	,(WXLPARAM)lParam
	1253	,&wId
	1254	,&hWnd
	1255	,&wCmd
	1256	);
	1257
	1258	bProcessed = HandleCommand( wId
	1259	,wCmd
	1260	,(WXHWND)hWnd
	1261	);
	1262	}
	1263	break;
	1264
	1265	case WM_MENUSELECT:
	1266	{
	1267	WXWORD wItem;
	1268	WXWORD wFlags;
	1269	WXHMENU hMenu;
	1270
	1271	UnpackMenuSelect( wParam
	1272	,lParam
	1273	,&wItem
	1274	,&wFlags
	1275	,&hMenu
	1276	);
	1277	bProcessed = HandleMenuSelect( wItem
	1278	,wFlags
	1279	,hMenu
	1280	);
	1281	mRc = (MRESULT)TRUE;
	1282	}
	1283	break;
	1284
	1285	case WM_SIZE:
	1286	{
	1287	SHORT nScxnew = SHORT1FROMMP(lParam); // New horizontal size.
	1288	SHORT nScynew = SHORT2FROMMP(lParam); // New vertical size.
	1289
	1290	lParam = MRFROM2SHORT( nScxnew - 20
	1291	,nScynew - 30
	1292	);
	1293	}
	1294	bProcessed = HandleSize(LOWORD(lParam), HIWORD(lParam), (WXUINT)wParam);
	1295	mRc = (MRESULT)FALSE;
	1296	break;
	1297
	1298	case CM_QUERYDRAGIMAGE:
	1299	{
	1300	const wxIcon& vIcon = GetIcon();
	1301	HPOINTER hIcon;
	1302
	1303	if (vIcon.IsOk())
	1304	hIcon = (HPOINTER)::WinSendMsg(GetHWND(), WM_QUERYICON, 0L, 0L);
	1305	else
	1306	hIcon = (HPOINTER)m_hDefaultIcon;
	1307	mRc = (MRESULT)hIcon;
	1308	bProcessed = mRc != 0;
	1309	}
	1310	break;
	1311	}
	1312
	1313	if (!bProcessed )
	1314	mRc = wxWindow::OS2WindowProc( uMessage
	1315	,wParam
	1316	,lParam
	1317	);
	1318	return (MRESULT)mRc;
	1319	} // wxFrame::OS2WindowProc
	1320
	1321	void wxFrame::SetClient(WXHWND WXUNUSED(c_Hwnd))
	1322	{
	1323	// Duh...nothing to do under OS/2
	1324	}
	1325
	1326	void wxFrame::SetClient( wxWindow* pWindow )
	1327	{
	1328	wxWindow* pOldClient = this->GetClient();
	1329	bool bClientHasFocus = pOldClient && (pOldClient == wxWindow::FindFocus());
	1330
	1331	if(pOldClient == pWindow) // nothing to do
	1332	return;
	1333	if(pWindow == NULL) // just need to remove old client
	1334	{
	1335	if(pOldClient == NULL) // nothing to do
	1336	return;
	1337
	1338	if(bClientHasFocus )
	1339	this->SetFocus();
	1340
	1341	pOldClient->Enable( false );
	1342	pOldClient->Show( false );
	1343	::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
	1344	// to avoid OS/2 bug need to update frame
	1345	::WinSendMsg((HWND)this->GetFrame(), WM_UPDATEFRAME, (MPARAM)~0, 0);
	1346	return;
	1347	}
	1348
	1349	//
	1350	// Else need to change client
	1351	//
	1352	if(bClientHasFocus)
	1353	this->SetFocus();
	1354
	1355	::WinEnableWindowUpdate((HWND)GetHWND(), FALSE);
	1356	if(pOldClient)
	1357	{
	1358	pOldClient->Enable(false);
	1359	pOldClient->Show(false);
	1360	::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
	1361	}
	1362	pWindow->Reparent(this);
	1363	::WinSetWindowUShort(pWindow->GetHWND(), QWS_ID, FID_CLIENT);
	1364	::WinEnableWindowUpdate((HWND)GetHWND(), TRUE);
	1365	pWindow->Enable();
	1366	pWindow->Show(); // ensure client is showing
	1367	if( this->IsShown() )
	1368	{
	1369	this->Show();
	1370	::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
	1371	}
	1372	}
	1373
	1374	wxWindow* wxFrame::GetClient()
	1375	{
	1376	return wxFindWinFromHandle((WXHWND)::WinWindowFromID(m_hFrame, FID_CLIENT));
	1377	}
	1378