Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New, reworked frame class for wxOS2 and more drawing routines in wxDC

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@8747 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
David Webster
2000-11-17 06:02:53 +00:00
parent 60161cfac9
commit 51c1d535fc
4 changed files with 900 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
src/os2/app.cpp
View File

@@ -92,6 +92,9 @@ HICON wxDEFAULT_MDIPARENTFRAME_ICON = (HICON) NULL;
HBRUSH wxDisableButtonBrush = (HBRUSH) 0;
MRESULT EXPENTRY wxWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
MRESULT EXPENTRY wxFrameWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
// ===========================================================================
// implementation
// ===========================================================================
@@ -206,8 +209,8 @@ bool wxApp::RegisterWindowClasses(
if (!::WinRegisterClass( vHab
,wxFrameClassName
,NULL
,CS_SIZEREDRAW | CS_MOVENOTIFY | CS_SYNCPAINT
,wxFrameWndProc
,CS_SIZEREDRAW | CS_MOVENOTIFY | CS_SYNCPAINT | CS_CLIPCHILDREN
,sizeof(ULONG)
))
{
@@ -219,9 +222,9 @@ bool wxApp::RegisterWindowClasses(
if (!::WinRegisterClass( vHab
,wxFrameClassNameNoRedraw
,NULL
,0
,wxWndProc
,0
,sizeof(ULONG)
))
{
vError = ::WinGetLastError(vHab);
@@ -232,9 +235,9 @@ bool wxApp::RegisterWindowClasses(
if (!::WinRegisterClass( vHab
,wxMDIFrameClassName
,NULL
,wxWndProc
,CS_SIZEREDRAW | CS_MOVENOTIFY | CS_SYNCPAINT
,0
,sizeof(ULONG)
))
{
vError = ::WinGetLastError(vHab);
@@ -245,9 +248,9 @@ bool wxApp::RegisterWindowClasses(
if (!::WinRegisterClass( vHab
,wxMDIFrameClassNameNoRedraw
,NULL
,0
,wxWndProc
,0
,sizeof(ULONG)
))
{
vError = ::WinGetLastError(vHab);
@@ -258,9 +261,9 @@ bool wxApp::RegisterWindowClasses(
if (!::WinRegisterClass( vHab
,wxMDIChildFrameClassName
,NULL
,wxWndProc
,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST
,0
,sizeof(ULONG)
))
{
vError = ::WinGetLastError(vHab);
@@ -271,9 +274,9 @@ bool wxApp::RegisterWindowClasses(
if (!::WinRegisterClass( vHab
,wxMDIChildFrameClassNameNoRedraw
,NULL
,wxWndProc
,CS_HITTEST
,0
,sizeof(ULONG)
))
{
vError = ::WinGetLastError(vHab);
@@ -284,9 +287,9 @@ bool wxApp::RegisterWindowClasses(
if (!::WinRegisterClass( vHab
,wxPanelClassName
,NULL
,wxWndProc
,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT
,0
,sizeof(ULONG)
))
{
vError = ::WinGetLastError(vHab);
@@ -297,9 +300,9 @@ bool wxApp::RegisterWindowClasses(
if (!::WinRegisterClass( vHab
,wxCanvasClassName
,NULL
,0 // CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT
,0
,wxWndProc
,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT
,sizeof(ULONG)
))
{
vError = ::WinGetLastError(vHab);
@@ -483,12 +486,9 @@ int wxEntry(
if (wxTheApp->OnInit())
{
nRetValue = wxTheApp->OnRun();
// nRetValue = -1;
}
}
// Normal exit
// Normal exit
wxWindow* pTopWindow = wxTheApp->GetTopWindow();
if (pTopWindow)
{
// Forcibly delete the window.
@@ -504,6 +504,7 @@ int wxEntry(
wxTheApp->SetTopWindow(NULL);
}
}
}
else // app initialization failed
{
wxLogLastError(" Gui initialization failed, exitting");

482
src/os2/dc.cpp
View File

@@ -266,19 +266,45 @@ void wxDC::Clear()
// TODO
}
void wxDC::DoFloodFill( wxCoord x
,wxCoord y
,const wxColour& col
,int style
)
void wxDC::DoFloodFill(
wxCoord vX
, wxCoord vY
, const wxColour& rCol
, int nStyle
)
{
// TODO
POINTL vPtlPos;
LONG lColor;
LONG lOptions;
vPtlPos.x = vX; // Loads x-coordinate
vPtlPos.y = vY; // Loads y-coordinate
::GpiMove(m_hPS, &vPtlPos); // Sets current position
lColor = rCol.GetPixel();
lOptions = FF_BOUNDARY;
if(wxFLOOD_SURFACE == nStyle)
lOptions = FF_SURFACE;
::GpiFloodFill(m_hPS, lOptions, lColor);
}
bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
bool wxDC::DoGetPixel(
wxCoord vX
, wxCoord vY
, wxColour* pCol
) const
{
// TODO
POINTL vPoint;
LONG lColor;
vPoint.x = vX;
vPoint.y = vY;
lColor = ::GpiSetPel(m_hPS, &vPoint);
// *pCol.Set(lColor);
if(lColor>= 0)
return(TRUE);
else
return(FALSE);
}
void wxDC::DoCrossHair(wxCoord x, wxCoord y)
@@ -304,38 +330,250 @@ void wxDC::DoDrawLine(
::GpiLine(m_hPS, &vPoint[1]);
}
void wxDC::DoDrawArc( wxCoord x1, wxCoord y1
,wxCoord x2, wxCoord y2
,wxCoord xc, wxCoord yc
//////////////////////////////////////////////////////////////////////////////
// Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
// and ending at (x2, y2). The current pen is used for the outline and the
// current brush for filling the shape. The arc is drawn in an anticlockwise
// direction from the start point to the end point.
//////////////////////////////////////////////////////////////////////////////
void wxDC::DoDrawArc(
wxCoord vX1
, wxCoord vY1
, wxCoord vX2
, wxCoord vY2
, wxCoord vXc
, wxCoord vYc
)
{
POINTL vPtlPos;
POINTL vPtlArc[2]; // Structure for current position
int nDx;
int nDy;
double dRadius;
double dAngl1;
double dAngl2;
double dAnglmid;
wxCoord vXm;
wxCoord vYm;
ARCPARAMS vArcp; // Structure for arc parameters
if((vX1 == vXc && vY1 == vXc) || (vX2 == vXc && vY2 == vXc))
return; // Draw point ??
dRadius = 0.5 * ( hypot( (double)(vY1 - vYc)
,(double)(vX1 - vXc)
) +
hypot( (double)(vY2 - vYc)
,(double)(vX2 - vXc)
)
{
// TODO
);
dAngl1 = atan2( (double)(vY1 - vYc)
,(double)(vX1 - vXc)
);
dAngl2 = atan2( (double)(vY2 - vYc)
,(double)(vX2 - vXc)
);
if(dAngl2 < dAngl1)
dAngl2 += M_PI * 2;
//
// GpiPointArc can't draw full arc
//
if(dAngl2 == dAngl1 || (vX1 == vX2 && vY1 == vY2) )
{
//
// Medium point
//
dAnglmid = (dAngl1 + dAngl2)/2. + M_PI;
vXm = vXc + dRadius * cos(dAnglmid);
vYm = vYc + dRadius * sin(dAnglmid);
DoDrawArc( vX1
,vY1
,vXm
,vYm
,vXc
,vYc
);
DoDrawArc( vXm
,vYm
,vX2
,vY2
,vXc
,vYc
);
return;
}
//
// Medium point
//
dAnglmid = (dAngl1 + dAngl2)/2.;
vXm = vXc + dRadius * cos(dAnglmid);
vYm = vYc + dRadius * sin(dAnglmid);
//
// Ellipse main axis (r,q), (p,s) with center at (0,0) */
//
vArcp.lR = 0;
vArcp.lQ = 1;
vArcp.lP = 1;
vArcp.lS = 0;
::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default
vPtlPos.x = vX1; // Loads x-coordinate
vPtlPos.y = vY1; // Loads y-coordinate
::GpiMove(m_hPS, &vPtlPos); // Sets current position
vPtlArc[0].x = vXm;
vPtlArc[0].y = vYm;
vPtlArc[1].x = vX2;
vPtlArc[1].y = vY2;
::GpiPointArc(m_hPS, vPtlArc); // Draws the arc
}
void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
wxCoord width, wxCoord height)
void wxDC::DoDrawCheckMark(
wxCoord vX1
, wxCoord vY1
, wxCoord vWidth
, wxCoord vHeight
)
{
// TODO
POINTL vPoint[2];
vPoint[0].x = vX1;
vPoint[0].y = vY1;
vPoint[1].x = vX1 + vWidth;
vPoint[1].y = vY1 + vHeight;
::GpiMove(m_hPS, &vPoint[0]);
::GpiBox( m_hPS // handle to a presentation space
,DRO_OUTLINE // draw the box outline ? or ?
,&vPoint[1] // address of the corner
,0L // horizontal corner radius
,0L // vertical corner radius
);
if(vWidth > 4 && vHeight > 4)
{
int nTmp;
vPoint[0].x += 2; vPoint[0].y += 2;
vPoint[1].x -= 2; vPoint[1].y -= 2;
::GpiMove(m_hPS, &vPoint[0]);
::GpiLine(m_hPS, &vPoint[1]);
nTmp = vPoint[0].x;
vPoint[0].x = vPoint[1].x;
vPoint[1].x = nTmp;
::GpiMove(m_hPS, &vPoint[0]);
::GpiLine(m_hPS, &vPoint[1]);
}
}
void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
void wxDC::DoDrawPoint(
wxCoord vX
, wxCoord vY
)
{
// TODO
POINTL vPoint;
vPoint.x = vX;
vPoint.y = vY;
::GpiSetPel(m_hPS, &vPoint);
}
void wxDC::DoDrawPolygon(int n, wxPoint points[]
,wxCoord xoffset, wxCoord yoffset
,int fillStyle
)
void wxDC::DoDrawPolygon(
int n
, wxPoint vPoints[]
, wxCoord vXoffset
, wxCoord vYoffset
, int nFillStyle
)
{
// TODO
ULONG ulCount = 1; // Number of polygons.
POLYGON vPlgn; // polygon.
ULONG flOptions = 0L; // Drawing options.
//////////////////////////////////////////////////////////////////////////////
// This contains fields of option bits... to draw boundary lines as well as
// the area interior.
//
// Drawing boundary lines:
// POLYGON_NOBOUNDARY Does not draw boundary lines.
// POLYGON_BOUNDARY Draws boundary lines (the default).
//
// Construction of the area interior:
// POLYGON_ALTERNATE Constructs interior in alternate mode
// (the default).
// POLYGON_WINDING Constructs interior in winding mode.
//////////////////////////////////////////////////////////////////////////////
ULONG flModel = 0L; // Drawing model.
//////////////////////////////////////////////////////////////////////////////
// Drawing model.
// POLYGON_INCL Fill is inclusive of bottom right (the default).
// POLYGON_EXCL Fill is exclusive of bottom right.
// This is provided to aid migration from other graphics models.
//////////////////////////////////////////////////////////////////////////////
LONG lHits = 0L; // Correlation/error indicator.
POINTL vPoint;
int i;
int nIsTRANSPARENT = 0;
LONG lBorderColor = 0L;
LONG lColor = 0L;
lBorderColor = m_pen.GetColour().GetPixel();
lColor = m_brush.GetColour().GetPixel();
if(m_brush.GetStyle() == wxTRANSPARENT)
nIsTRANSPARENT = 1;
vPlgn.ulPoints = n;
vPlgn.aPointl = (POINTL*) calloc( n + 1
,sizeof(POINTL)
); // well, new will call malloc
for(i = 0; i < n; i++)
{
vPlgn.aPointl[i].x = vPoints[i].x; // +xoffset;
vPlgn.aPointl[i].y = vPoints[i].y; // +yoffset;
}
flModel = POLYGON_BOUNDARY;
if(nFillStyle == wxWINDING_RULE)
flModel |= POLYGON_WINDING;
else
flModel |= POLYGON_ALTERNATE;
vPoint.x = vXoffset;
vPoint.y = vYoffset;
::GpiSetColor(m_hPS, lBorderColor);
::GpiMove(m_hPS, &vPoint);
lHits = ::GpiPolygons(m_hPS, ulCount, &vPlgn, flOptions, flModel);
free(vPlgn.aPointl);
}
void wxDC::DoDrawLines( int n, wxPoint points[]
,wxCoord xoffset, wxCoord yoffset
)
void wxDC::DoDrawLines(
int n
, wxPoint vPoints[]
, wxCoord vXoffset
, wxCoord vYoffset
)
{
// TODO
int i;
POINTL vPoint;
vPoint.x = vPoints[0].x + vXoffset;
vPoint.y = vPoints[0].y + vYoffset;
::GpiMove(m_hPS, &vPoint);
LONG lBorderColor = m_pen.GetColour().GetPixel();
::GpiSetColor(m_hPS, lBorderColor);
for(i = 1; i < n; i++)
{
vPoint.x = vPoints[0].x + vXoffset;
vPoint.y = vPoints[0].y + vYoffset;
::GpiLine(m_hPS, &vPoint);
}
}
void wxDC::DoDrawRectangle(
@@ -346,19 +584,58 @@ void wxDC::DoDrawRectangle(
)
{
POINTL vPoint[2];
LONG lControl;
LONG lColor;
LONG lBorderColor;
int nIsTRANSPARENT = 0;
vPoint[0].x = vX;
vPoint[0].y = vY;
vPoint[1].x = vX + vWidth;
vPoint[1].y = vY - vHeight; //mustdie !!! ??
::GpiMove(m_hPS, &vPoint[0]);
lColor = m_brush.GetColour().GetPixel();
lBorderColor = m_pen.GetColour().GetPixel();
if (m_brush.GetStyle() == wxTRANSPARENT)
nIsTRANSPARENT = 1;
if(lColor == lBorderColor || nIsTRANSPARENT)
{
lControl = DRO_OUTLINEFILL; //DRO_FILL;
if(m_brush.GetStyle() == wxTRANSPARENT)
lControl = DRO_OUTLINE;
//EK ::GpiSetColor(m_hPS,lBorderColor);
::GpiSetColor(m_hPS,CLR_GREEN);
::GpiBox( m_hPS // handle to a presentation space
,DRO_OUTLINE // draw the box outline ? or ?
,lControl // draw the box outline ? or ?
,&vPoint[1] // address of the corner
,0L // horizontal corner radius
,0L // vertical corner radius
);
}
else
{
lControl = DRO_OUTLINE;
::GpiSetColor( m_hPS
,lBorderColor
);
::GpiBox( m_hPS
,lControl
,&vPoint[1]
,0L
,0L
);
lControl = DRO_FILL;
::GpiSetColor( m_hPS
,lColor
);
::GpiBox( m_hPS
,lControl
,&vPoint[1]
,0L
,0L
);
}
}
void wxDC::DoDrawRoundedRectangle(
@@ -370,13 +647,17 @@ void wxDC::DoDrawRoundedRectangle(
)
{
POINTL vPoint[2];
LONG lControl;
vPoint[0].x = vX;
vPoint[0].y = vY;
vPoint[1].x = vX + vWidth;
vPoint[1].y = vY + vHeight; //or -height aka mustdie !!! ??
vPoint[1].y = vY + vHeight;
::GpiMove(m_hPS, &vPoint[0]);
lControl = DRO_OUTLINEFILL; //DRO_FILL;
if (m_brush.GetStyle() == wxTRANSPARENT)
lControl = DRO_OUTLINE;
::GpiBox( m_hPS // handle to a presentation space
,DRO_OUTLINE // draw the box outline ? or ?
,&vPoint[1] // address of the corner
@@ -385,25 +666,97 @@ void wxDC::DoDrawRoundedRectangle(
);
}
void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
// Draw Ellipse within box (x,y) - (x+width, y+height)
void wxDC::DoDrawEllipse(
wxCoord vX
, wxCoord vY
, wxCoord vWidth
, wxCoord vHeight
)
{
// TODO
POINTL vPtlPos; // Structure for current position
FIXED vFxMult; // Multiplier for ellipse
ARCPARAMS vArcp; // Structure for arc parameters
vArcp.lR = 0;
vArcp.lQ = vHeight/2;
vArcp.lP = vWidth/2;
vArcp.lS = 0;
::GpiSetArcParams( m_hPS
,&vArcp
); // Sets parameters to default
vPtlPos.x = vX + vWidth/2; // Loads x-coordinate
vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
::GpiMove( m_hPS
,&vPtlPos
); // Sets current position
vFxMult = MAKEFIXED(1, 0); /* Sets multiplier */
//
// DRO_FILL, DRO_OTLINEFILL - where to get
//
::GpiFullArc( m_hPS
,DRO_OUTLINE
,vFxMult
); // Draws full arc with center at current position
}
void wxDC::DoDrawEllipticArc( wxCoord x
,wxCoord y
,wxCoord w
,wxCoord h
,double sa
,double ea
)
void wxDC::DoDrawEllipticArc(
wxCoord vX
, wxCoord vY
, wxCoord vWidth
, wxCoord vHeight
, double dSa
, double dEa
)
{
// TODO
POINTL vPtlPos; // Structure for current position
FIXED vFxMult; // Multiplier for ellipse
ARCPARAMS vArcp; // Structure for arc parameters
FIXED vFSa;
FIXED vFSweepa; // Start angle, sweep angle
double dIntPart;
double dFractPart;
double dRadius;
dFractPart = modf(dSa,&dIntPart);
vFSa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );
dFractPart = modf(dEa - dSa, &dIntPart);
vFSweepa = MAKEFIXED((int)dIntPart, (int)(dFractPart * 0xffff) );
//
// Ellipse main axis (r,q), (p,s) with center at (0,0)
//
vArcp.lR = 0;
vArcp.lQ = vHeight/2;
vArcp.lP = vWidth/2;
vArcp.lS = 0;
::GpiSetArcParams(m_hPS, &vArcp); // Sets parameters to default
vPtlPos.x = vX + vWidth/2 * (1. + cos(DegToRad(dSa))); // Loads x-coordinate
vPtlPos.y = vY + vHeight/2 * (1. + sin(DegToRad(dSa))); // Loads y-coordinate
::GpiMove(m_hPS, &vPtlPos); // Sets current position
//
// May be not to the center ?
//
vPtlPos.x = vX + vWidth/2 ; // Loads x-coordinate
vPtlPos.y = vY + vHeight/2; // Loads y-coordinate
vFxMult = MAKEFIXED(1, 0); // Sets multiplier
//
// DRO_FILL, DRO_OTLINEFILL - where to get
//
::GpiPartialArc( m_hPS
,&vPtlPos
,vFxMult
,vFSa
,vFSweepa
);
}
void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
{
// TODO
// TODO:
}
void wxDC::DoDrawBitmap( const wxBitmap &bmp
@@ -628,9 +981,52 @@ void wxDC::SetPen(
::GpiSetColor( m_hPS
,vColor.GetPixel()
); //DEbug ??
int nLinetype;
int nStyle = m_pen.GetStyle();
nLinetype = LINETYPE_DEFAULT;
switch(nStyle)
{
case wxDOT:
nLinetype = LINETYPE_DOT;
break;
case wxLONG_DASH:
nLinetype = LINETYPE_LONGDASH;
break;
case wxSHORT_DASH:
nLinetype = LINETYPE_SHORTDASH;
break;
case wxDOT_DASH:
nLinetype = LINETYPE_DASHDOT;
break;
case wxTRANSPARENT:
nLinetype = LINETYPE_INVISIBLE;
break;
case wxSOLID:
nLinetype = LINETYPE_SOLID;
break;
}
::GpiSetLineType( m_hPS
,nLinetype
);
nWidth = m_pen.GetWidth();
::GpiSetLineWidth( m_hPS
,MAKEFIXED( nWidth
,0
)
);
}
void wxDC::SetBrush(const wxBrush& brush)
void wxDC::SetBrush(
const wxBrush& rBrush
)
{
// TODO
}

534
src/os2/frame.cpp
View File

@@ -13,6 +13,15 @@
#include "wx/wxprec.h"
#ifndef WX_PRECOMP
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/dynarray.h"
#include "wx/list.h"
#include "wx/hash.h"
#include "wx/string.h"
#include "wx/intl.h"
#include "wx/log.h"
#include "wx/event.h"
#include "wx/setup.h"
#include "wx/frame.h"
#include "wx/menu.h"
@@ -46,6 +55,8 @@ extern wxList WXDLLEXPORT wxPendingDelete;
extern wxChar wxFrameClassName[];
extern wxMenu *wxCurrentPopupMenu;
extern void wxAssociateWinWithHandle( HWND hWnd,wxWindow* pWin);
// ----------------------------------------------------------------------------
// event tables
// ----------------------------------------------------------------------------
@@ -96,6 +107,11 @@ void wxFrame::Init()
m_bIsShown = FALSE;
m_pWinLastFocused = (wxWindow *)NULL;
m_hFrame = NULL;
m_hTitleBar = NULL;
m_hHScroll = NULL;
m_hVScroll = NULL;
//
// Initialize SWP's
//
@@ -123,6 +139,7 @@ bool wxFrame::Create(
int nY = rPos.y;
int nWidth = rSize.x;
int nHeight = rSize.y;
bool bOk = FALSE;
SetName(rsName);
m_windowStyle = lulStyle;
@@ -150,10 +167,7 @@ bool wxFrame::Create(
if ((m_windowStyle & wxFRAME_FLOAT_ON_PARENT) == 0)
pParent = NULL;
if (!pParent)
wxTopLevelWindows.Append(this);
OS2Create( m_windowId
bOk = OS2Create( m_windowId
,pParent
,wxFrameClassName
,this
@@ -164,9 +178,13 @@ bool wxFrame::Create(
,nHeight
,lulStyle
);
if (bOk)
{
if (!pParent)
wxTopLevelWindows.Append(this);
wxModelessWindows.Append(this);
return TRUE;
}
return(bOk);
} // end of wxFrame::Create
wxFrame::~wxFrame()
@@ -221,40 +239,12 @@ void wxFrame::DoGetClientSize(
, int* pY
) const
{
//
// OS/2 PM's coordinates go from bottom-left not
// top-left thus the += instead of the -=
//
RECTL vRect;
//
// PM has no GetClientRect that inherantly knows about the client window
// We have to explicitly go fetch it!
//
::WinQueryWindowRect(GetHwnd(), &vRect);
#if wxUSE_STATUSBAR
if ( GetStatusBar() )
{
int nStatusX;
int nStatusY;
GetStatusBar()->GetClientSize( &nStatusX
,&nStatusY
);
vRect.yBottom += nStatusY;
}
#endif // wxUSE_STATUSBAR
wxPoint vPoint(GetClientAreaOrigin());
vRect.yBottom += vPoint.y;
vRect.xRight -= vPoint.x;
if (pX)
*pX = vRect.xRight;
*pX = vRect.xRight - vRect.xLeft;
if (pY)
*pY = vRect.yBottom;
*pY = vRect.yTop - vRect.yBottom;
} // end of wxFrame::DoGetClientSize
//
@@ -271,8 +261,7 @@ void wxFrame::DoSetClientSize(
RECTL vRect2;
::WinQueryWindowRect(GetHwnd(), &vRect);
::WinQueryWindowRect(GetHWND(), &vRect2);
::WinQueryWindowRect(GetHwnd(), &vRect2);
//
// Find the difference between the entire window (title bar and all)
@@ -329,7 +318,7 @@ void wxFrame::DoGetSize(
{
RECTL vRect;
::WinQueryWindowRect(GetHWND(), &vRect);
::WinQueryWindowRect(m_hFrame, &vRect);
*pWidth = vRect.xRight - vRect.xLeft;
*pHeight = vRect.yTop - vRect.yBottom;
} // end of wxFrame::DoGetSize
@@ -342,7 +331,7 @@ void wxFrame::DoGetPosition(
RECTL vRect;
POINTL vPoint;
::WinQueryWindowRect(GetHWND(), &vRect);
::WinQueryWindowRect(m_hFrame, &vRect);
vPoint.x = vRect.xLeft;
//
@@ -362,7 +351,7 @@ void wxFrame::DoShowWindow(
int bShowCmd
)
{
::WinShowWindow(GetHWND(), (BOOL)bShowCmd);
::WinShowWindow(m_hFrame, (BOOL)bShowCmd);
m_bIconized = bShowCmd == SWP_MINIMIZE;
} // end of wxFrame::DoShowWindow
@@ -378,10 +367,10 @@ bool wxFrame::Show(
{
wxActivateEvent vEvent(wxEVT_ACTIVATE, TRUE, m_windowId);
::WinQueryWindowPos(GetHWND(), &vSwp);
::WinQueryWindowPos(m_hFrame, &vSwp);
m_bIconized = vSwp.fl & SWP_MINIMIZE;
::WinSendMsg(GetHWND(), WM_UPDATEFRAME, (MPARAM)~0, 0);
::WinEnableWindow(GetHWND(), TRUE);
::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
::WinEnableWindow(m_hFrame, TRUE);
vEvent.SetEventObject(this);
GetEventHandler()->ProcessEvent(vEvent);
}
@@ -433,7 +422,7 @@ bool wxFrame::IsIconized() const
{
SWP vSwp;
::WinQueryWindowPos(GetHwnd(), &vSwp);
::WinQueryWindowPos(m_hFrame, &vSwp);
if (vSwp.fl & SWP_MINIMIZE)
((wxFrame*)this)->m_bIconized = TRUE;
@@ -448,7 +437,7 @@ bool wxFrame::IsMaximized() const
SWP vSwp;
bool bIconic;
::WinQueryWindowPos(GetHWND(), &vSwp);
::WinQueryWindowPos(m_hFrame, &vSwp);
return (vSwp.fl & SWP_MAXIMIZE);
} // end of wxFrame::IsMaximized
@@ -460,12 +449,12 @@ void wxFrame::SetIcon(
if ((m_icon.GetHICON()) != NULLHANDLE)
{
::WinSendMsg( GetHWND()
::WinSendMsg( m_hFrame
,WM_SETICON
,(MPARAM)((HPOINTER)m_icon.GetHICON())
,NULL
);
::WinSendMsg( GetHWND()
::WinSendMsg( m_hFrame
,WM_UPDATEFRAME
,(MPARAM)FCF_ICON
,(MPARAM)0
@@ -495,11 +484,18 @@ wxStatusBar* wxFrame::OnCreateStatusBar(
if( !pStatusBar )
return NULL;
::WinSetParent( pStatusBar->GetHWND()
,m_hFrame
,FALSE
);
::WinSetOwner( pStatusBar->GetHWND()
,m_hFrame
);
//
// to show statusbar
//
if( ::WinIsWindowShowing(GetHWND()) )
::WinSendMsg(GetHWND(), WM_UPDATEFRAME, (MPARAM)~0, 0);
if(::WinIsWindowShowing(m_hFrame))
::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
return pStatusBar;
} // end of wxFrame::OnCreateStatusBar
@@ -516,15 +512,17 @@ void wxFrame::PositionStatusBar()
if (m_frameStatusBar)
{
int nWidth;
int nHeight;
int nStatbarWidth;
int nStatbarHeight;
HWND hWndClient;
RECTL vRect;
RECTL vFRect;
::WinQueryWindowRect(GetHwnd(), &vRect);
::WinQueryWindowRect(m_hFrame, &vRect);
::WinMapWindowPoints(m_hFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2);
vFRect = vRect;
::WinCalcFrameRect(m_hFrame, &vRect, TRUE);
nWidth = vRect.xRight - vRect.xLeft;
nHeight = vRect.yTop - vRect.yBottom;
m_frameStatusBar->GetSize( &nStatbarWidth
,&nStatbarHeight
@@ -534,8 +532,8 @@ void wxFrame::PositionStatusBar()
// 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( 0
,nHeight
m_frameStatusBar->SetSize( vRect.xLeft - vFRect.xLeft
,vRect.yBottom - vFRect.yBottom
,nWidth
,nStatbarHeight
);
@@ -543,21 +541,7 @@ void wxFrame::PositionStatusBar()
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
wxLogError("Error setting parent for submenu. Error: %s\n", sError);
return;
}
if (!::WinSetWindowPos( m_frameStatusBar->GetHWND()
,HWND_TOP
,vSwp.x
,vSwp.y
,nStatbarWidth
,nStatbarHeight
,SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER
))
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
wxLogError("Error setting parent for submenu. Error: %s\n", sError);
wxLogError("Error setting parent for StautsBar. Error: %s\n", sError);
return;
}
}
@@ -579,8 +563,6 @@ void wxFrame::SetMenuBar(
{
ERRORID vError;
wxString sError;
HWND hClient = NULLHANDLE;
HWND hFrame = NULLHANDLE;
HWND hTitlebar = NULLHANDLE;
HWND hHScroll = NULLHANDLE;
HWND hVScroll = NULLHANDLE;
@@ -626,27 +608,6 @@ void wxFrame::SetMenuBar(
m_frameMenuBar = pMenuBar;
pMenuBar->Attach(this);
}
//
// Now resize the client to fit the new frame
//
WinQueryWindowPos(GetHWND(), &vSwp);
hTitlebar = WinWindowFromID(GetHWND(), FID_TITLEBAR);
WinQueryWindowPos(hTitlebar, &vSwpTitlebar);
hHScroll = WinWindowFromID(GetHWND(), FID_HORZSCROLL);
WinQueryWindowPos(hHScroll, &vSwpHScroll);
hVScroll = WinWindowFromID(GetHWND(), FID_VERTSCROLL);
WinQueryWindowPos(hVScroll, &vSwpVScroll);
hMenuBar = WinWindowFromID(GetHWND(), FID_MENU);
WinQueryWindowPos(hMenuBar, &vSwpMenu);
WinSetWindowPos( GetHwnd()
,HWND_TOP
,SV_CXSIZEBORDER/2
,(SV_CYSIZEBORDER/2) + vSwpHScroll.cy/2
,vSwp.cx - ((SV_CXSIZEBORDER + 1) + vSwpVScroll.cx)
,vSwp.cy - ((SV_CYSIZEBORDER + 1) + vSwpTitlebar.cy + vSwpMenu.cy + vSwpHScroll.cy/2)
,SWP_SIZE | SWP_MOVE
);
} // end of wxFrame::SetMenuBar
void wxFrame::InternalSetMenuBar()
@@ -656,20 +617,20 @@ void wxFrame::InternalSetMenuBar()
//
// Set the parent and owner of the menubar to be the frame
//
if (!::WinSetParent(m_hMenu, GetHWND(), FALSE))
if (!::WinSetParent(m_hMenu, m_hFrame, FALSE))
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
wxLogError("Error setting parent for submenu. Error: %s\n", sError);
}
if (!::WinSetOwner(m_hMenu, GetHWND()))
if (!::WinSetOwner(m_hMenu, m_hFrame))
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
wxLogError("Error setting parent for submenu. Error: %s\n", sError);
}
WinSendMsg((HWND)GetHWND(), WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
} // end of wxFrame::InternalSetMenuBar
//
@@ -909,14 +870,16 @@ bool wxFrame::OS2Create(
ULONG ulExtraFlags = 0L;
FRAMECDATA vFrameCtlData;
HWND hParent = NULLHANDLE;
HWND hClient = NULLHANDLE;
HWND hFrame = NULLHANDLE;
HWND hTitlebar = NULLHANDLE;
HWND hHScroll = NULLHANDLE;
HWND hVScroll = NULLHANDLE;
HWND hFrame = NULLHANDLE;
HWND hClient = NULLHANDLE;
SWP vSwp[10];
RECTL vRect[10];
USHORT uCtlCount;
ERRORID vError;
wxString sError;
m_hDefaultIcon = (WXHICON) (wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON : wxDEFAULT_FRAME_ICON);
@@ -987,37 +950,50 @@ bool wxFrame::OS2Create(
vFrameCtlData.idResources = 0;
//
// Create the frame window
// Create the frame window: We break ranks with other ports now
// and instead of calling down into the base wxWindow class' OS2Create
// we do all our own stuff here. We will set the needed pieces
// of wxWindow manually, here.
//
if (!wxWindow::OS2Create( hParent
,WC_FRAME
,(PSZ)zTitle
,0
,0, 0, 0, 0
,NULLHANDLE
,HWND_TOP
,(ULONG)nId
,(PVOID)&vFrameCtlData
,NULL
))
hFrame = ::WinCreateStdWindow( hParent
,ulStyleFlags // frame-window style
,&ulCreateFlags // window style
,(PSZ)zWclass // class name
,(PSZ)zTitle // window title
,0L // default client style
,NULLHANDLE // resource in executable file
,0 // resource id
,&hClient // receives client window handle
);
if (!hFrame)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
wxLogError("Error creating frame. Error: %s\n", sError);
return FALSE;
}
//
// Now need to subclass window.
// wxWindow class' m_hWnd set here and needed associations
//
m_hFrame = hFrame;
m_hWnd = hClient;
wxAssociateWinWithHandle(m_hWnd, this);
wxAssociateWinWithHandle(m_hFrame, this);
//SubclassWin(GetHWND());
//
// 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
// by default
//
m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(m_hFrame, (PFNWP)wxFrameMainWndProc);
// ::WinCreateWindow(GetHWND(), WC_LISTBOX, "", WS_VISIBLE, 0, 0,
// 0, 0, GetHWND(), HWND_TOP, FID_CLIENT, NULL, NULL);
//
// Now size everything. If adding a menu the client will need to be resized.
//
if (!::WinSetWindowPos( GetHWND()
if (!::WinSetWindowPos( m_hFrame
,HWND_TOP
,nX
,nY
@@ -1025,7 +1001,30 @@ bool wxFrame::OS2Create(
,nHeight
,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
))
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
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;
}
/*
uCtlCount = SHORT1FROMMP(::WinSendMsg(GetHWND(), WM_FORMATFRAME, (MPARAM)vSwp, (MPARAM)vRect));
for (int i = 0; i < uCtlCount; i++)
@@ -1289,14 +1288,6 @@ bool wxFrame::HandlePaint()
}
else
{
/* DosBeep(500,500);
HPS hPS;
RECTL vRect;
hPS = WinBeginPaint(GetHwnd(), 0L, &vRect);
WinFillRect(hPS, &vRect, SYSCLR_WINDOW);
WinEndPaint(hPS);*/
return wxWindow::HandlePaint();
}
}
@@ -1367,7 +1358,7 @@ bool wxFrame::HandleSize(
}
#endif // wxUSE_NATIVE_STATUSBAR
// PositionStatusBar();
PositionStatusBar();
#if wxUSE_TOOLBAR
PositionToolBar();
#endif // wxUSE_TOOLBAR
@@ -1433,36 +1424,12 @@ bool wxFrame::HandleMenuSelect(
, WXHMENU hMenu
)
{
// int nMenuItem;
/* This is wrong section according to IBM's documentation
if (nFlags == 0xFFFF && hMenu == 0)
{
//
// Menu was removed from screen
//
nMenuItem = -1;
}
else if (!(nFlags & MIS_SUBMENU) && !(nFlags & MIS_SEPARATOR))
{
nMenuItem = nItem;
}
else
{
//
// Don't give hints for separators (doesn't make sense) nor for the
// items opening popup menus (they don't have them anyhow)
//
return FALSE;
}
*/
if( !nFlags )
{
MENUITEM mItem;
MRESULT rc;
rc = WinSendMsg(hMenu, MM_QUERYITEM, MPFROM2SHORT(nItem, TRUE), (MPARAM)&mItem);
rc = ::WinSendMsg(hMenu, MM_QUERYITEM, MPFROM2SHORT(nItem, TRUE), (MPARAM)&mItem);
if(rc && !(mItem.afStyle & (MIS_SUBMENU | MIS_SEPARATOR)))
{
@@ -1476,8 +1443,222 @@ bool wxFrame::HandleMenuSelect(
} // end of wxFrame::HandleMenuSelect
// ---------------------------------------------------------------------------
// the window proc for wxFrame
// Main Frame window proc
// ---------------------------------------------------------------------------
MRESULT EXPENTRY wxFrameMainWndProc(
HWND hWnd
, ULONG ulMsg
, MPARAM wParam
, MPARAM lParam
)
{
MRESULT rc = (MRESULT)0;
bool bProcessed = FALSE;
wxFrame* pWnd = NULL;
pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
switch (ulMsg)
{
case WM_QUERYFRAMECTLCOUNT:
if(pWnd && pWnd->m_fnOldWndProc)
{
USHORT uItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
rc = MRFROMSHORT(uItemCount);
}
break;
case WM_FORMATFRAME:
/////////////////////////////////////////////////////////////////////////////////
// Applications that subclass frame controls may find that the frame is already
// subclassed the number of frame controls is variable.
// The WM_FORMATFRAME and WM_QUERYFRAMECTLCOUNT messages must always be
// subclassed by calling the previous window procedure and modifying its result.
////////////////////////////////////////////////////////////////////////////////
{
int nItemCount;
int i;
PSWP pSWP = NULL;
SWP vSwpStb;
RECTL vRectl;
RECTL vRstb;
int nHeight=0;
pSWP = (PSWP)PVOIDFROMMP(wParam);
nItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
if(pWnd->m_frameStatusBar)
{
::WinQueryWindowRect(pWnd->m_frameStatusBar->GetHWND(), &vRstb);
pWnd->m_frameStatusBar->GetSize(NULL, &nHeight);
::WinQueryWindowRect(pWnd->m_hFrame, &vRectl);
::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2);
vRstb = vRectl;
::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE);
vSwpStb.x = vRectl.xLeft - vRstb.xLeft;
vSwpStb.y = vRectl.yBottom - vRstb.yBottom;
vSwpStb.cx = vRectl.xRight - vRectl.xLeft - 1; //?? -1 ??
vSwpStb.cy = nHeight;
vSwpStb.fl = SWP_SIZE |SWP_MOVE | SWP_SHOW;
vSwpStb.hwnd = pWnd->m_frameStatusBar->GetHWND();
vSwpStb.hwndInsertBehind = HWND_TOP;
}
::WinQueryWindowRect(pWnd->m_hFrame, &vRectl);
::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2);
::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE);
::WinMapWindowPoints(HWND_DESKTOP, pWnd->m_hFrame, (PPOINTL)&vRectl, 2);
for(i = 0; i < nItemCount; i++)
{
if(pWnd->m_hWnd && pSWP[i].hwnd == pWnd->m_hWnd)
{
pSWP[i].x = vRectl.xLeft;
pSWP[i].y = vRectl.yBottom + nHeight;
pSWP[i].cx = vRectl.xRight - vRectl.xLeft;
pSWP[i].cy = vRectl.yTop - vRectl.yBottom - nHeight;
pSWP[i].fl = SWP_SIZE | SWP_MOVE | SWP_SHOW;
pSWP[i].hwndInsertBehind = HWND_TOP;
}
}
bProcessed = TRUE;
rc = MRFROMSHORT(nItemCount);
}
break;
default:
if(pWnd && pWnd->m_fnOldWndProc)
rc = pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam);
else
rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
}
return rc;
} // end of wxFrameMainWndProc
MRESULT EXPENTRY wxFrameWndProc(
HWND hWnd
, ULONG ulMsg
, MPARAM wParam
, MPARAM lParam
)
{
//
// Trace all ulMsgs - useful for the debugging
//
HWND parentHwnd;
wxFrame* pWnd = NULL;
parentHwnd = WinQueryWindow(hWnd,QW_PARENT);
pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
//
// When we get the first message for the HWND we just created, we associate
// it with wxWindow stored in wxWndHook
//
// if (!pWnd && wxWndHook)
// {
// wxAssociateWinWithHandle(hWnd, wxWndHook);
// pWnd = wxWndHook;
// wxWndHook = NULL;
// pWnd->SetHWND((WXHWND)hWnd);
// }
MRESULT rc = (MRESULT)0;
bool bProcessed = FALSE;
//
// Stop right here if we don't have a valid handle in our wxWindow object.
//
if (pWnd && !pWnd->GetHWND())
{
pWnd->SetHWND((WXHWND) hWnd);
rc = pWnd->OS2DefWindowProc(ulMsg, wParam, lParam );
pWnd->SetHWND(0);
}
else
{
switch (ulMsg)
{
case WM_CLOSE:
//
// If we can't close, tell the system that we processed the
// message - otherwise it would close us
//
bProcessed = !pWnd->Close();
break;
case WM_PAINT:
{
HPS hPS;
RECTL vRect;
hPS = WinBeginPaint(hWnd, 0L, &vRect);
WinFillRect(hPS, &vRect, CLR_BLUE /* SYSCLR_WINDOW */);
WinEndPaint(hPS);
rc = FALSE;
break;
}
break;
case WM_COMMAND:
{
WORD wId;
WORD wCmd;
WXHWND hWnd;
pWnd->UnpackCommand( (WXWPARAM)wParam
,(WXLPARAM)lParam
,&wId
,&hWnd
,&wCmd
);
rc = (MRESULT) pWnd->HandleCommand( wId
,wCmd
,(WXHWND)hWnd
);
}
break;
case WM_MENUSELECT:
{
WXWORD wItem;
WXWORD wFlags;
WXHMENU hMenu;
pWnd->UnpackMenuSelect( wParam
,lParam
,&wItem
,&wFlags
,&hMenu
);
bProcessed = pWnd->HandleMenuSelect( wItem
,wFlags
,hMenu
);
rc = (MRESULT)TRUE;
}
break;
case WM_SIZE:
{
SHORT nScxold = SHORT1FROMMP(wParam); // Old horizontal size.
SHORT nScyold = SHORT2FROMMP(wParam); // Old vertical size.
SHORT nScxnew = SHORT1FROMMP(lParam); // New horizontal size.
SHORT nScynew = SHORT2FROMMP(lParam); // New vertical size.
lParam = MRFROM2SHORT( nScxnew - 20
,nScynew - 30
);
}
bProcessed = pWnd->HandleSize(LOWORD(lParam), HIWORD(lParam), (WXUINT)wParam);
rc = (MRESULT)FALSE;
break;
default:
rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
}
}
return rc;
} // end of wxFrameWndProc
MRESULT wxFrame::OS2WindowProc(
WXUINT uMessage
@@ -1658,55 +1839,54 @@ MRESULT wxFrame::OS2WindowProc(
return (MRESULT)mRc;
} // wxFrame::OS2WindowProc
void wxFrame::SetClient(WXHWND c_Hwnd)
{
// Are we really need to implement it?
// Duh...nothing to do under OS/2
}
void wxFrame::SetClient(wxWindow* c_Window)
void wxFrame::SetClient(
wxWindow* pWindow
)
{
wxWindow *oldClient = this->GetClient();
bool clientHasFocus = oldClient && (oldClient == wxWindow::FindFocus());
wxWindow* pOldClient = this->GetClient();
bool bClientHasFocus = pOldClient && (pOldClient == wxWindow::FindFocus());
if(oldClient == c_Window) // nothing to do
if(pOldClient == pWindow) // nothing to do
return;
if(c_Window == NULL) // just need to remove old client
if(pWindow == NULL) // just need to remove old client
{
if(oldClient == NULL) // nothing to do
if(pOldClient == NULL) // nothing to do
return;
if( clientHasFocus )
if(bClientHasFocus )
this->SetFocus();
oldClient->Enable( FALSE );
oldClient->Show( FALSE );
::WinSetWindowUShort(oldClient->GetHWND(), QWS_ID, (USHORT)oldClient->GetId());
pOldClient->Enable( FALSE );
pOldClient->Show( FALSE );
::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
// to avoid OS/2 bug need to update frame
::WinSendMsg((HWND)this->GetHWND(), WM_UPDATEFRAME, (MPARAM)~0, 0);
return;
}
// else need to change client
if( clientHasFocus )
//
// Else need to change client
//
if(bClientHasFocus)
this->SetFocus();
::WinEnableWindowUpdate((HWND)GetHWND(), FALSE);
if( oldClient )
if(pOldClient)
{
oldClient->Enable( FALSE );
oldClient->Show( FALSE );
::WinSetWindowUShort(oldClient->GetHWND(), QWS_ID, (USHORT)oldClient->GetId());
pOldClient->Enable(FALSE);
pOldClient->Show(FALSE);
::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
}
c_Window->Reparent( this );
::WinSetWindowUShort(c_Window->GetHWND(), QWS_ID, FID_CLIENT);
pWindow->Reparent(this);
::WinSetWindowUShort(pWindow->GetHWND(), QWS_ID, FID_CLIENT);
::WinEnableWindowUpdate((HWND)GetHWND(), TRUE);
c_Window->Enable();
c_Window->Show(); // ensure client is showing
pWindow->Enable();
pWindow->Show(); // ensure client is showing
if( this->IsShown() )
{
this->Show();
@@ -1714,7 +1894,7 @@ void wxFrame::SetClient(wxWindow* c_Window)
}
}
wxWindow *wxFrame::GetClient()
wxWindow* wxFrame::GetClient()
{
return wxFindWinFromHandle((WXHWND)::WinWindowFromID(GetHWND(), FID_CLIENT));
}

70
src/os2/window.cpp
View File

@@ -158,6 +158,7 @@ BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
EVT_INIT_DIALOG(wxWindow::OnInitDialog)
EVT_IDLE(wxWindow::OnIdle)
EVT_SET_FOCUS(wxWindow::OnSetFocus)
END_EVENT_TABLE()
// ===========================================================================
@@ -321,8 +322,6 @@ DEBUG_PRINTF(wxWindow::~wxWindow-Start);
if (m_hWnd)
{
// UnsubclassWin();
if(!::WinDestroyWindow(GetHWND()))
wxLogLastError(wxT("DestroyWindow"));
//
@@ -372,6 +371,12 @@ bool wxWindow::Create(
// set in those class create procs. PM's basic windows styles are
// very limited.
//
ulCreateFlags |= WS_VISIBLE;
if ( lStyle & wxCLIP_SIBLINGS )
ulCreateFlags |= WS_CLIPSIBLINGS;
if (lStyle & wxCLIP_CHILDREN )
ulCreateFlags |= WS_CLIPCHILDREN;
@@ -729,19 +734,12 @@ void wxWindow::SubclassWin(
HWND hwnd = (HWND)hWnd;
wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );
// wxAssociateWinWithHandle(hwnd, this);
m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);
// ::WinSetWindowULong(hwnd, QWL_USER, (ULONG)wxWndProc);
} // end of wxWindow::SubclassWin
void wxWindow::UnsubclassWin()
{
// wxRemoveHandleAssociation(this);
//
// Restore old Window proc
//
@@ -749,11 +747,10 @@ void wxWindow::UnsubclassWin()
if (m_hWnd)
{
// m_hWnd = 0;
wxCHECK_RET( ::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in UnsubclassWin") );
PFNWP fnProc = (PFNWP)::WinQueryWindowPtr(hwnd, QWP_PFNWP);
if ( (m_fnOldWndProc != 0) && (fnProc != (PFNWP) m_fnOldWndProc))
{
WinSubclassWindow(hwnd, (PFNWP)m_fnOldWndProc);
@@ -1114,6 +1111,9 @@ void wxWindow::DoGetClientSize(
RECTL vRect;
hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
if( hWndClient == NULLHANDLE)
::WinQueryWindowRect(GetHwnd(), &vRect);
else
::WinQueryWindowRect(hWndClient, &vRect);
if (pWidth)
@@ -1533,8 +1533,6 @@ bool wxWindow::OS2ProcessMessage(
{
QMSG* pQMsg = (QMSG*)pMsg;
DEBUG_PRINTF(OS2ProcessMessage);
if (m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL))
{
//
@@ -1740,11 +1738,6 @@ void wxWindow::UnpackCommand(
, WORD* pCmd
)
{
/*
*pId = LOWORD(wParam);
*phWnd = (WXHWND)lParam;
*pCmd = HIWORD(wParam);
*/
*pId = LOWORD(wParam);
*phWnd = NULL; // or may be GetHWND() ?
*pCmd = LOWORD(lParam);
@@ -1872,17 +1865,6 @@ MRESULT wxWindow::OS2WindowProc(
WXHICON hIcon;
WXHBRUSH hBrush;
//
// The return value
//
// union
// {
// bool bAllow;
// MRESULT mResult;
// WXHICON hIcon;
// WXHBRUSH hBrush;
// } vRc;
//
// For most messages we should return 0 when we do process the message
//
@@ -2375,6 +2357,8 @@ bool wxWindow::OS2Create(
long lWidth1 = 20L;
long lHeight1 = 20L;
int nControlId = 0;
int nNeedsubclass = 0;
PCSZ pszClass = zClass;
//
// Find parent's size, if it exists, to set up a possible default
@@ -2414,6 +2398,21 @@ bool wxWindow::OS2Create(
{
nControlId = ulId;
}
else
{
// no standard controls
if(wxString (wxT("wxFrameClass")) == wxString(zClass) )
{
pszClass = WC_FRAME;
nNeedsubclass = 1;
}
else
{
nControlId = ulId;
if(nControlId < 0)
nControlId = FID_CLIENT;
}
}
//
// We will either have a registered class via string name or a standard PM Class via a long
@@ -2426,9 +2425,9 @@ bool wxWindow::OS2Create(
,(LONG)lY1
,(LONG)lWidth
,(LONG)lHeight
,NULLHANDLE
,hOwner
,HWND_TOP
,(ULONG)ulId
,(ULONG)nControlId
,pCtlData
,pPresParams
);
@@ -2462,9 +2461,14 @@ bool wxWindow::OS2Create(
//
// Now need to subclass window.
//
if(!nNeedsubclass)
{
wxAssociateWinWithHandle((HWND)m_hWnd,this);
}
else
{
SubclassWin(GetHWND());
}
return TRUE;
} // end of wxWindow::OS2Create