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

482
src/os2/dc.cpp
View File

@@ -266,19 +266,45 @@ void wxDC::Clear()
// TODO // TODO
} }
void wxDC::DoFloodFill( wxCoord x void wxDC::DoFloodFill(
,wxCoord y wxCoord vX
,const wxColour& col , wxCoord vY
,int style , 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); return(TRUE);
else
return(FALSE);
} }
void wxDC::DoCrossHair(wxCoord x, wxCoord y) void wxDC::DoCrossHair(wxCoord x, wxCoord y)
@@ -304,38 +330,250 @@ void wxDC::DoDrawLine(
::GpiLine(m_hPS, &vPoint[1]); ::GpiLine(m_hPS, &vPoint[1]);
} }
void wxDC::DoDrawArc( wxCoord x1, wxCoord y1 //////////////////////////////////////////////////////////////////////////////
,wxCoord x2, wxCoord y2 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
,wxCoord xc, wxCoord yc // 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, void wxDC::DoDrawCheckMark(
wxCoord width, wxCoord height) 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[] void wxDC::DoDrawPolygon(
,wxCoord xoffset, wxCoord yoffset int n
,int fillStyle , 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[] void wxDC::DoDrawLines(
,wxCoord xoffset, wxCoord yoffset 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( void wxDC::DoDrawRectangle(
@@ -346,19 +584,58 @@ void wxDC::DoDrawRectangle(
) )
{ {
POINTL vPoint[2]; POINTL vPoint[2];
LONG lControl;
LONG lColor;
LONG lBorderColor;
int nIsTRANSPARENT = 0;
vPoint[0].x = vX; vPoint[0].x = vX;
vPoint[0].y = vY; vPoint[0].y = vY;
vPoint[1].x = vX + vWidth; vPoint[1].x = vX + vWidth;
vPoint[1].y = vY - vHeight; //mustdie !!! ?? vPoint[1].y = vY - vHeight; //mustdie !!! ??
::GpiMove(m_hPS, &vPoint[0]); ::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 ::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 ,&vPoint[1] // address of the corner
,0L // horizontal corner radius ,0L // horizontal corner radius
,0L // vertical 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( void wxDC::DoDrawRoundedRectangle(
@@ -370,13 +647,17 @@ void wxDC::DoDrawRoundedRectangle(
) )
{ {
POINTL vPoint[2]; POINTL vPoint[2];
LONG lControl;
vPoint[0].x = vX; vPoint[0].x = vX;
vPoint[0].y = vY; vPoint[0].y = vY;
vPoint[1].x = vX + vWidth; vPoint[1].x = vX + vWidth;
vPoint[1].y = vY + vHeight; //or -height aka mustdie !!! ?? vPoint[1].y = vY + vHeight;
::GpiMove(m_hPS, &vPoint[0]); ::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 ::GpiBox( m_hPS // handle to a presentation space
,DRO_OUTLINE // draw the box outline ? or ? ,DRO_OUTLINE // draw the box outline ? or ?
,&vPoint[1] // address of the corner ,&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 void wxDC::DoDrawEllipticArc(
,wxCoord y wxCoord vX
,wxCoord w , wxCoord vY
,wxCoord h , wxCoord vWidth
,double sa , wxCoord vHeight
,double ea , 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) void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
{ {
// TODO // TODO:
} }
void wxDC::DoDrawBitmap( const wxBitmap &bmp void wxDC::DoDrawBitmap( const wxBitmap &bmp
@@ -628,9 +981,52 @@ void wxDC::SetPen(
::GpiSetColor( m_hPS ::GpiSetColor( m_hPS
,vColor.GetPixel() ,vColor.GetPixel()
); //DEbug ?? ); //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 // TODO
} }

534
src/os2/frame.cpp
View File

@@ -13,6 +13,15 @@
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifndef WX_PRECOMP #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/setup.h"
#include "wx/frame.h" #include "wx/frame.h"
#include "wx/menu.h" #include "wx/menu.h"
@@ -46,6 +55,8 @@ extern wxList WXDLLEXPORT wxPendingDelete;
extern wxChar wxFrameClassName[]; extern wxChar wxFrameClassName[];
extern wxMenu *wxCurrentPopupMenu; extern wxMenu *wxCurrentPopupMenu;
extern void wxAssociateWinWithHandle( HWND hWnd,wxWindow* pWin);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// event tables // event tables
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -96,6 +107,11 @@ void wxFrame::Init()
m_bIsShown = FALSE; m_bIsShown = FALSE;
m_pWinLastFocused = (wxWindow *)NULL; m_pWinLastFocused = (wxWindow *)NULL;
m_hFrame = NULL;
m_hTitleBar = NULL;
m_hHScroll = NULL;
m_hVScroll = NULL;
// //
// Initialize SWP's // Initialize SWP's
// //
@@ -123,6 +139,7 @@ bool wxFrame::Create(
int nY = rPos.y; int nY = rPos.y;
int nWidth = rSize.x; int nWidth = rSize.x;
int nHeight = rSize.y; int nHeight = rSize.y;
bool bOk = FALSE;
SetName(rsName); SetName(rsName);
m_windowStyle = lulStyle; m_windowStyle = lulStyle;
@@ -150,10 +167,7 @@ bool wxFrame::Create(
if ((m_windowStyle & wxFRAME_FLOAT_ON_PARENT) == 0) if ((m_windowStyle & wxFRAME_FLOAT_ON_PARENT) == 0)
pParent = NULL; pParent = NULL;
if (!pParent) bOk = OS2Create( m_windowId
wxTopLevelWindows.Append(this);
OS2Create( m_windowId
,pParent ,pParent
,wxFrameClassName ,wxFrameClassName
,this ,this
@@ -164,9 +178,13 @@ bool wxFrame::Create(
,nHeight ,nHeight
,lulStyle ,lulStyle
); );
if (bOk)
{
if (!pParent)
wxTopLevelWindows.Append(this);
wxModelessWindows.Append(this); wxModelessWindows.Append(this);
return TRUE; }
return(bOk);
} // end of wxFrame::Create } // end of wxFrame::Create
wxFrame::~wxFrame() wxFrame::~wxFrame()
@@ -221,40 +239,12 @@ void wxFrame::DoGetClientSize(
, int* pY , int* pY
) const ) const
{ {
//
// OS/2 PM's coordinates go from bottom-left not
// top-left thus the += instead of the -=
//
RECTL vRect; RECTL vRect;
//
// PM has no GetClientRect that inherantly knows about the client window
// We have to explicitly go fetch it!
//
::WinQueryWindowRect(GetHwnd(), &vRect); ::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) if (pX)
*pX = vRect.xRight; *pX = vRect.xRight - vRect.xLeft;
if (pY) if (pY)
*pY = vRect.yBottom; *pY = vRect.yTop - vRect.yBottom;
} // end of wxFrame::DoGetClientSize } // end of wxFrame::DoGetClientSize
// //
@@ -271,8 +261,7 @@ void wxFrame::DoSetClientSize(
RECTL vRect2; RECTL vRect2;
::WinQueryWindowRect(GetHwnd(), &vRect); ::WinQueryWindowRect(GetHwnd(), &vRect);
::WinQueryWindowRect(GetHwnd(), &vRect2);
::WinQueryWindowRect(GetHWND(), &vRect2);
// //
// Find the difference between the entire window (title bar and all) // Find the difference between the entire window (title bar and all)
@@ -329,7 +318,7 @@ void wxFrame::DoGetSize(
{ {
RECTL vRect; RECTL vRect;
::WinQueryWindowRect(GetHWND(), &vRect); ::WinQueryWindowRect(m_hFrame, &vRect);
*pWidth = vRect.xRight - vRect.xLeft; *pWidth = vRect.xRight - vRect.xLeft;
*pHeight = vRect.yTop - vRect.yBottom; *pHeight = vRect.yTop - vRect.yBottom;
} // end of wxFrame::DoGetSize } // end of wxFrame::DoGetSize
@@ -342,7 +331,7 @@ void wxFrame::DoGetPosition(
RECTL vRect; RECTL vRect;
POINTL vPoint; POINTL vPoint;
::WinQueryWindowRect(GetHWND(), &vRect); ::WinQueryWindowRect(m_hFrame, &vRect);
vPoint.x = vRect.xLeft; vPoint.x = vRect.xLeft;
// //
@@ -362,7 +351,7 @@ void wxFrame::DoShowWindow(
int bShowCmd int bShowCmd
) )
{ {
::WinShowWindow(GetHWND(), (BOOL)bShowCmd); ::WinShowWindow(m_hFrame, (BOOL)bShowCmd);
m_bIconized = bShowCmd == SWP_MINIMIZE; m_bIconized = bShowCmd == SWP_MINIMIZE;
} // end of wxFrame::DoShowWindow } // end of wxFrame::DoShowWindow
@@ -378,10 +367,10 @@ bool wxFrame::Show(
{ {
wxActivateEvent vEvent(wxEVT_ACTIVATE, TRUE, m_windowId); wxActivateEvent vEvent(wxEVT_ACTIVATE, TRUE, m_windowId);
::WinQueryWindowPos(GetHWND(), &vSwp); ::WinQueryWindowPos(m_hFrame, &vSwp);
m_bIconized = vSwp.fl & SWP_MINIMIZE; m_bIconized = vSwp.fl & SWP_MINIMIZE;
::WinSendMsg(GetHWND(), WM_UPDATEFRAME, (MPARAM)~0, 0); ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
::WinEnableWindow(GetHWND(), TRUE); ::WinEnableWindow(m_hFrame, TRUE);
vEvent.SetEventObject(this); vEvent.SetEventObject(this);
GetEventHandler()->ProcessEvent(vEvent); GetEventHandler()->ProcessEvent(vEvent);
} }
@@ -433,7 +422,7 @@ bool wxFrame::IsIconized() const
{ {
SWP vSwp; SWP vSwp;
::WinQueryWindowPos(GetHwnd(), &vSwp); ::WinQueryWindowPos(m_hFrame, &vSwp);
if (vSwp.fl & SWP_MINIMIZE) if (vSwp.fl & SWP_MINIMIZE)
((wxFrame*)this)->m_bIconized = TRUE; ((wxFrame*)this)->m_bIconized = TRUE;
@@ -448,7 +437,7 @@ bool wxFrame::IsMaximized() const
SWP vSwp; SWP vSwp;
bool bIconic; bool bIconic;
::WinQueryWindowPos(GetHWND(), &vSwp); ::WinQueryWindowPos(m_hFrame, &vSwp);
return (vSwp.fl & SWP_MAXIMIZE); return (vSwp.fl & SWP_MAXIMIZE);
} // end of wxFrame::IsMaximized } // end of wxFrame::IsMaximized
@@ -460,12 +449,12 @@ void wxFrame::SetIcon(
if ((m_icon.GetHICON()) != NULLHANDLE) if ((m_icon.GetHICON()) != NULLHANDLE)
{ {
::WinSendMsg( GetHWND() ::WinSendMsg( m_hFrame
,WM_SETICON ,WM_SETICON
,(MPARAM)((HPOINTER)m_icon.GetHICON()) ,(MPARAM)((HPOINTER)m_icon.GetHICON())
,NULL ,NULL
); );
::WinSendMsg( GetHWND() ::WinSendMsg( m_hFrame
,WM_UPDATEFRAME ,WM_UPDATEFRAME
,(MPARAM)FCF_ICON ,(MPARAM)FCF_ICON
,(MPARAM)0 ,(MPARAM)0
@@ -495,11 +484,18 @@ wxStatusBar* wxFrame::OnCreateStatusBar(
if( !pStatusBar ) if( !pStatusBar )
return NULL; return NULL;
::WinSetParent( pStatusBar->GetHWND()
,m_hFrame
,FALSE
);
::WinSetOwner( pStatusBar->GetHWND()
,m_hFrame
);
// //
// to show statusbar // to show statusbar
// //
if( ::WinIsWindowShowing(GetHWND()) ) if(::WinIsWindowShowing(m_hFrame))
::WinSendMsg(GetHWND(), WM_UPDATEFRAME, (MPARAM)~0, 0); ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
return pStatusBar; return pStatusBar;
} // end of wxFrame::OnCreateStatusBar } // end of wxFrame::OnCreateStatusBar
@@ -516,15 +512,17 @@ void wxFrame::PositionStatusBar()
if (m_frameStatusBar) if (m_frameStatusBar)
{ {
int nWidth; int nWidth;
int nHeight;
int nStatbarWidth; int nStatbarWidth;
int nStatbarHeight; int nStatbarHeight;
HWND hWndClient; HWND hWndClient;
RECTL vRect; 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; nWidth = vRect.xRight - vRect.xLeft;
nHeight = vRect.yTop - vRect.yBottom;
m_frameStatusBar->GetSize( &nStatbarWidth m_frameStatusBar->GetSize( &nStatbarWidth
,&nStatbarHeight ,&nStatbarHeight
@@ -534,8 +532,8 @@ void wxFrame::PositionStatusBar()
// Since we wish the status bar to be directly under the client area, // Since we wish the status bar to be directly under the client area,
// we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS. // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
// //
m_frameStatusBar->SetSize( 0 m_frameStatusBar->SetSize( vRect.xLeft - vFRect.xLeft
,nHeight ,vRect.yBottom - vFRect.yBottom
,nWidth ,nWidth
,nStatbarHeight ,nStatbarHeight
); );
@@ -543,21 +541,7 @@ void wxFrame::PositionStatusBar()
{ {
vError = ::WinGetLastError(vHabmain); vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError); sError = wxPMErrorToStr(vError);
wxLogError("Error setting parent for submenu. Error: %s\n", sError); wxLogError("Error setting parent for StautsBar. 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);
return; return;
} }
} }
@@ -579,8 +563,6 @@ void wxFrame::SetMenuBar(
{ {
ERRORID vError; ERRORID vError;
wxString sError; wxString sError;
HWND hClient = NULLHANDLE;
HWND hFrame = NULLHANDLE;
HWND hTitlebar = NULLHANDLE; HWND hTitlebar = NULLHANDLE;
HWND hHScroll = NULLHANDLE; HWND hHScroll = NULLHANDLE;
HWND hVScroll = NULLHANDLE; HWND hVScroll = NULLHANDLE;
@@ -626,27 +608,6 @@ void wxFrame::SetMenuBar(
m_frameMenuBar = pMenuBar; m_frameMenuBar = pMenuBar;
pMenuBar->Attach(this); 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 } // end of wxFrame::SetMenuBar
void wxFrame::InternalSetMenuBar() void wxFrame::InternalSetMenuBar()
@@ -656,20 +617,20 @@ void wxFrame::InternalSetMenuBar()
// //
// Set the parent and owner of the menubar to be the frame // 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); vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError); sError = wxPMErrorToStr(vError);
wxLogError("Error setting parent for submenu. Error: %s\n", sError); wxLogError("Error setting parent for submenu. Error: %s\n", sError);
} }
if (!::WinSetOwner(m_hMenu, GetHWND())) if (!::WinSetOwner(m_hMenu, m_hFrame))
{ {
vError = ::WinGetLastError(vHabmain); vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError); sError = wxPMErrorToStr(vError);
wxLogError("Error setting parent for submenu. Error: %s\n", sError); 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 } // end of wxFrame::InternalSetMenuBar
// //
@@ -909,14 +870,16 @@ bool wxFrame::OS2Create(
ULONG ulExtraFlags = 0L; ULONG ulExtraFlags = 0L;
FRAMECDATA vFrameCtlData; FRAMECDATA vFrameCtlData;
HWND hParent = NULLHANDLE; HWND hParent = NULLHANDLE;
HWND hClient = NULLHANDLE;
HWND hFrame = NULLHANDLE;
HWND hTitlebar = NULLHANDLE; HWND hTitlebar = NULLHANDLE;
HWND hHScroll = NULLHANDLE; HWND hHScroll = NULLHANDLE;
HWND hVScroll = NULLHANDLE; HWND hVScroll = NULLHANDLE;
HWND hFrame = NULLHANDLE;
HWND hClient = NULLHANDLE;
SWP vSwp[10]; SWP vSwp[10];
RECTL vRect[10]; RECTL vRect[10];
USHORT uCtlCount; USHORT uCtlCount;
ERRORID vError;
wxString sError;
m_hDefaultIcon = (WXHICON) (wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON : wxDEFAULT_FRAME_ICON); m_hDefaultIcon = (WXHICON) (wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON : wxDEFAULT_FRAME_ICON);
@@ -987,37 +950,50 @@ bool wxFrame::OS2Create(
vFrameCtlData.idResources = 0; 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 hFrame = ::WinCreateStdWindow( hParent
,WC_FRAME ,ulStyleFlags // frame-window style
,(PSZ)zTitle ,&ulCreateFlags // window style
,0 ,(PSZ)zWclass // class name
,0, 0, 0, 0 ,(PSZ)zTitle // window title
,NULLHANDLE ,0L // default client style
,HWND_TOP ,NULLHANDLE // resource in executable file
,(ULONG)nId ,0 // resource id
,(PVOID)&vFrameCtlData ,&hClient // receives client window handle
,NULL );
)) if (!hFrame)
{ {
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
wxLogError("Error creating frame. Error: %s\n", sError);
return FALSE; 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. // Now size everything. If adding a menu the client will need to be resized.
// //
if (!::WinSetWindowPos( GetHWND() if (!::WinSetWindowPos( m_hFrame
,HWND_TOP ,HWND_TOP
,nX ,nX
,nY ,nY
@@ -1025,7 +1001,30 @@ bool wxFrame::OS2Create(
,nHeight ,nHeight
,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
)) ))
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
wxLogError("Error sizing frame. Error: %s\n", sError);
return FALSE; 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)); uCtlCount = SHORT1FROMMP(::WinSendMsg(GetHWND(), WM_FORMATFRAME, (MPARAM)vSwp, (MPARAM)vRect));
for (int i = 0; i < uCtlCount; i++) for (int i = 0; i < uCtlCount; i++)
@@ -1289,14 +1288,6 @@ bool wxFrame::HandlePaint()
} }
else else
{ {
/* DosBeep(500,500);
HPS hPS;
RECTL vRect;
hPS = WinBeginPaint(GetHwnd(), 0L, &vRect);
WinFillRect(hPS, &vRect, SYSCLR_WINDOW);
WinEndPaint(hPS);*/
return wxWindow::HandlePaint(); return wxWindow::HandlePaint();
} }
} }
@@ -1367,7 +1358,7 @@ bool wxFrame::HandleSize(
} }
#endif // wxUSE_NATIVE_STATUSBAR #endif // wxUSE_NATIVE_STATUSBAR
// PositionStatusBar(); PositionStatusBar();
#if wxUSE_TOOLBAR #if wxUSE_TOOLBAR
PositionToolBar(); PositionToolBar();
#endif // wxUSE_TOOLBAR #endif // wxUSE_TOOLBAR
@@ -1433,36 +1424,12 @@ bool wxFrame::HandleMenuSelect(
, WXHMENU hMenu , 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 ) if( !nFlags )
{ {
MENUITEM mItem; MENUITEM mItem;
MRESULT rc; 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))) if(rc && !(mItem.afStyle & (MIS_SUBMENU | MIS_SEPARATOR)))
{ {
@@ -1476,8 +1443,222 @@ bool wxFrame::HandleMenuSelect(
} // end of 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( MRESULT wxFrame::OS2WindowProc(
WXUINT uMessage WXUINT uMessage
@@ -1658,55 +1839,54 @@ MRESULT wxFrame::OS2WindowProc(
return (MRESULT)mRc; return (MRESULT)mRc;
} // wxFrame::OS2WindowProc } // wxFrame::OS2WindowProc
void wxFrame::SetClient(WXHWND c_Hwnd) 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(); wxWindow* pOldClient = this->GetClient();
bool clientHasFocus = oldClient && (oldClient == wxWindow::FindFocus()); bool bClientHasFocus = pOldClient && (pOldClient == wxWindow::FindFocus());
if(oldClient == c_Window) // nothing to do if(pOldClient == pWindow) // nothing to do
return; return;
if(pWindow == NULL) // just need to remove old client
if(c_Window == NULL) // just need to remove old client
{ {
if(oldClient == NULL) // nothing to do if(pOldClient == NULL) // nothing to do
return; return;
if( clientHasFocus ) if(bClientHasFocus )
this->SetFocus(); this->SetFocus();
oldClient->Enable( FALSE ); pOldClient->Enable( FALSE );
oldClient->Show( FALSE ); pOldClient->Show( FALSE );
::WinSetWindowUShort(oldClient->GetHWND(), QWS_ID, (USHORT)oldClient->GetId()); ::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
// to avoid OS/2 bug need to update frame // to avoid OS/2 bug need to update frame
::WinSendMsg((HWND)this->GetHWND(), WM_UPDATEFRAME, (MPARAM)~0, 0); ::WinSendMsg((HWND)this->GetHWND(), WM_UPDATEFRAME, (MPARAM)~0, 0);
return; return;
} }
// else need to change client //
if( clientHasFocus ) // Else need to change client
//
if(bClientHasFocus)
this->SetFocus(); this->SetFocus();
::WinEnableWindowUpdate((HWND)GetHWND(), FALSE); ::WinEnableWindowUpdate((HWND)GetHWND(), FALSE);
if( oldClient ) if(pOldClient)
{ {
oldClient->Enable( FALSE ); pOldClient->Enable(FALSE);
oldClient->Show( FALSE ); pOldClient->Show(FALSE);
::WinSetWindowUShort(oldClient->GetHWND(), QWS_ID, (USHORT)oldClient->GetId()); ::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
} }
pWindow->Reparent(this);
c_Window->Reparent( this ); ::WinSetWindowUShort(pWindow->GetHWND(), QWS_ID, FID_CLIENT);
::WinSetWindowUShort(c_Window->GetHWND(), QWS_ID, FID_CLIENT);
::WinEnableWindowUpdate((HWND)GetHWND(), TRUE); ::WinEnableWindowUpdate((HWND)GetHWND(), TRUE);
c_Window->Enable(); pWindow->Enable();
c_Window->Show(); // ensure client is showing pWindow->Show(); // ensure client is showing
if( this->IsShown() ) if( this->IsShown() )
{ {
this->Show(); 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)); 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_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
EVT_INIT_DIALOG(wxWindow::OnInitDialog) EVT_INIT_DIALOG(wxWindow::OnInitDialog)
EVT_IDLE(wxWindow::OnIdle) EVT_IDLE(wxWindow::OnIdle)
EVT_SET_FOCUS(wxWindow::OnSetFocus)
END_EVENT_TABLE() END_EVENT_TABLE()
// =========================================================================== // ===========================================================================
@@ -321,8 +322,6 @@ DEBUG_PRINTF(wxWindow::~wxWindow-Start);
if (m_hWnd) if (m_hWnd)
{ {
// UnsubclassWin();
if(!::WinDestroyWindow(GetHWND())) if(!::WinDestroyWindow(GetHWND()))
wxLogLastError(wxT("DestroyWindow")); wxLogLastError(wxT("DestroyWindow"));
// //
@@ -372,6 +371,12 @@ bool wxWindow::Create(
// set in those class create procs. PM's basic windows styles are // set in those class create procs. PM's basic windows styles are
// very limited. // very limited.
// //
ulCreateFlags |= WS_VISIBLE;
if ( lStyle & wxCLIP_SIBLINGS )
ulCreateFlags |= WS_CLIPSIBLINGS;
if (lStyle & wxCLIP_CHILDREN ) if (lStyle & wxCLIP_CHILDREN )
ulCreateFlags |= WS_CLIPCHILDREN; ulCreateFlags |= WS_CLIPCHILDREN;
@@ -729,19 +734,12 @@ void wxWindow::SubclassWin(
HWND hwnd = (HWND)hWnd; HWND hwnd = (HWND)hWnd;
wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") ); wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") ); wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );
// wxAssociateWinWithHandle(hwnd, this);
m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc); m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);
// ::WinSetWindowULong(hwnd, QWL_USER, (ULONG)wxWndProc);
} // end of wxWindow::SubclassWin } // end of wxWindow::SubclassWin
void wxWindow::UnsubclassWin() void wxWindow::UnsubclassWin()
{ {
// wxRemoveHandleAssociation(this);
// //
// Restore old Window proc // Restore old Window proc
// //
@@ -749,11 +747,10 @@ void wxWindow::UnsubclassWin()
if (m_hWnd) if (m_hWnd)
{ {
// m_hWnd = 0;
wxCHECK_RET( ::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in UnsubclassWin") ); wxCHECK_RET( ::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in UnsubclassWin") );
PFNWP fnProc = (PFNWP)::WinQueryWindowPtr(hwnd, QWP_PFNWP); PFNWP fnProc = (PFNWP)::WinQueryWindowPtr(hwnd, QWP_PFNWP);
if ( (m_fnOldWndProc != 0) && (fnProc != (PFNWP) m_fnOldWndProc)) if ( (m_fnOldWndProc != 0) && (fnProc != (PFNWP) m_fnOldWndProc))
{ {
WinSubclassWindow(hwnd, (PFNWP)m_fnOldWndProc); WinSubclassWindow(hwnd, (PFNWP)m_fnOldWndProc);
@@ -1114,6 +1111,9 @@ void wxWindow::DoGetClientSize(
RECTL vRect; RECTL vRect;
hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT); hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
if( hWndClient == NULLHANDLE)
::WinQueryWindowRect(GetHwnd(), &vRect);
else
::WinQueryWindowRect(hWndClient, &vRect); ::WinQueryWindowRect(hWndClient, &vRect);
if (pWidth) if (pWidth)
@@ -1533,8 +1533,6 @@ bool wxWindow::OS2ProcessMessage(
{ {
QMSG* pQMsg = (QMSG*)pMsg; QMSG* pQMsg = (QMSG*)pMsg;
DEBUG_PRINTF(OS2ProcessMessage);
if (m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL)) if (m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL))
{ {
// //
@@ -1740,11 +1738,6 @@ void wxWindow::UnpackCommand(
, WORD* pCmd , WORD* pCmd
) )
{ {
/*
*pId = LOWORD(wParam);
*phWnd = (WXHWND)lParam;
*pCmd = HIWORD(wParam);
*/
*pId = LOWORD(wParam); *pId = LOWORD(wParam);
*phWnd = NULL; // or may be GetHWND() ? *phWnd = NULL; // or may be GetHWND() ?
*pCmd = LOWORD(lParam); *pCmd = LOWORD(lParam);
@@ -1872,17 +1865,6 @@ MRESULT wxWindow::OS2WindowProc(
WXHICON hIcon; WXHICON hIcon;
WXHBRUSH hBrush; 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 // For most messages we should return 0 when we do process the message
// //
@@ -2375,6 +2357,8 @@ bool wxWindow::OS2Create(
long lWidth1 = 20L; long lWidth1 = 20L;
long lHeight1 = 20L; long lHeight1 = 20L;
int nControlId = 0; int nControlId = 0;
int nNeedsubclass = 0;
PCSZ pszClass = zClass;
// //
// Find parent's size, if it exists, to set up a possible default // Find parent's size, if it exists, to set up a possible default
@@ -2414,6 +2398,21 @@ bool wxWindow::OS2Create(
{ {
nControlId = ulId; 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 // 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)lY1
,(LONG)lWidth ,(LONG)lWidth
,(LONG)lHeight ,(LONG)lHeight
,NULLHANDLE ,hOwner
,HWND_TOP ,HWND_TOP
,(ULONG)ulId ,(ULONG)nControlId
,pCtlData ,pCtlData
,pPresParams ,pPresParams
); );
@@ -2462,9 +2461,14 @@ bool wxWindow::OS2Create(
// //
// Now need to subclass window. // Now need to subclass window.
// //
if(!nNeedsubclass)
{
wxAssociateWinWithHandle((HWND)m_hWnd,this);
}
else
{
SubclassWin(GetHWND()); SubclassWin(GetHWND());
}
return TRUE; return TRUE;
} // end of wxWindow::OS2Create } // end of wxWindow::OS2Create