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

Lots of OS/2 fixes mostly to do with painting

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@8940 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
David Webster
2000-12-18 05:34:25 +00:00
parent 702c190d47
commit 8d854fa93f
7 changed files with 579 additions and 258 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/os2/brush.cpp
View File

@@ -204,7 +204,7 @@ bool wxBrush::RealizeResource()
if (M_BRUSHDATA->m_hBrush==NULL) wxError("Cannot create brush","Internal error") ; if (M_BRUSHDATA->m_hBrush==NULL) wxError("Cannot create brush","Internal error") ;
#endif #endif
M_BRUSHDATA->m_vBundle.lColor = vPmColour; M_BRUSHDATA->m_vBundle.lColor = vPmColour;
M_BRUSHDATA->m_vBundle.lBackColor = CLR_DEFAULT; M_BRUSHDATA->m_vBundle.lBackColor = RGB_WHITE;
M_BRUSHDATA->m_vBundle.usMixMode = FM_OVERPAINT; M_BRUSHDATA->m_vBundle.usMixMode = FM_OVERPAINT;
M_BRUSHDATA->m_vBundle.usBackMixMode = BM_OVERPAINT; M_BRUSHDATA->m_vBundle.usBackMixMode = BM_OVERPAINT;

33
src/os2/dc.cpp
View File

@@ -147,6 +147,7 @@ wxDC::wxDC(void)
m_hOldPS = NULL; m_hOldPS = NULL;
m_hPS = NULL; m_hPS = NULL;
m_bIsPaintTime = FALSE; // True at Paint Time m_bIsPaintTime = FALSE; // True at Paint Time
m_brush.GetColour().Set("WHITE");
} }
wxDC::~wxDC(void) wxDC::~wxDC(void)
@@ -226,9 +227,9 @@ void wxDC::DoSetClippingRegion(
m_clipping = TRUE; m_clipping = TRUE;
vRect.xLeft = XLOG2DEV(x); vRect.xLeft = XLOG2DEV(x);
vRect.yTop = YLOG2DEV(y + height); vRect.yTop = YLOG2DEV(m_vRclPaint.yTop - y);
vRect.xRight = XLOG2DEV(x + width); vRect.xRight = XLOG2DEV(x + width);
vRect.yBottom = YLOG2DEV(y); vRect.yBottom = YLOG2DEV(m_vRclPaint.yTop - (y + height));
::GpiIntersectClipRectangle(m_hPS, &vRect); ::GpiIntersectClipRectangle(m_hPS, &vRect);
DO_SET_CLIPPING_BOX() DO_SET_CLIPPING_BOX()
} // end of wxDC::DoSetClippingRegion } // end of wxDC::DoSetClippingRegion
@@ -360,9 +361,9 @@ void wxDC::DoDrawLine(
POINTL vPoint[2]; POINTL vPoint[2];
vPoint[0].x = vX1; vPoint[0].x = vX1;
vPoint[0].y = vY1; vPoint[0].y = m_vRclPaint.yTop - vY1;
vPoint[1].x = vX2; vPoint[1].x = vX2;
vPoint[1].y = vY2; vPoint[1].y = m_vRclPaint.yTop - vY2;
::GpiMove(m_hPS, &vPoint[0]); ::GpiMove(m_hPS, &vPoint[0]);
::GpiLine(m_hPS, &vPoint[1]); ::GpiLine(m_hPS, &vPoint[1]);
} }
@@ -506,7 +507,7 @@ void wxDC::DoDrawPoint(
POINTL vPoint; POINTL vPoint;
vPoint.x = vX; vPoint.x = vX;
vPoint.y = vY; vPoint.y = m_vRclPaint.yTop - vY;
::GpiSetPel(m_hPS, &vPoint); ::GpiSetPel(m_hPS, &vPoint);
} }
@@ -621,9 +622,9 @@ void wxDC::DoDrawRectangle(
int nIsTRANSPARENT = 0; int nIsTRANSPARENT = 0;
vPoint[0].x = vX; vPoint[0].x = vX;
vPoint[0].y = vY; vPoint[0].y = m_vRclPaint.yTop - (vY + vHeight);
vPoint[1].x = vX + vWidth; vPoint[1].x = vX + vWidth;
vPoint[1].y = vY - vHeight; vPoint[1].y = m_vRclPaint.yTop - vY;
::GpiMove(m_hPS, &vPoint[0]); ::GpiMove(m_hPS, &vPoint[0]);
lColor = m_brush.GetColour().GetPixel(); lColor = m_brush.GetColour().GetPixel();
lBorderColor = m_pen.GetColour().GetPixel(); lBorderColor = m_pen.GetColour().GetPixel();
@@ -635,7 +636,7 @@ void wxDC::DoDrawRectangle(
if(m_brush.GetStyle() == wxTRANSPARENT) if(m_brush.GetStyle() == wxTRANSPARENT)
lControl = DRO_OUTLINE; lControl = DRO_OUTLINE;
::GpiSetColor(m_hPS, CLR_GREEN); ::GpiSetColor(m_hPS, lColor);
::GpiBox( m_hPS // handle to a presentation space ::GpiBox( m_hPS // handle to a presentation space
,lControl // draw the box outline ? or ? ,lControl // draw the box outline ? or ?
,&vPoint[1] // address of the corner ,&vPoint[1] // address of the corner
@@ -659,6 +660,11 @@ void wxDC::DoDrawRectangle(
::GpiSetColor( m_hPS ::GpiSetColor( m_hPS
,lColor ,lColor
); );
vPoint[0].x = vX + 1;
vPoint[0].y = m_vRclPaint.yTop - (vY + vHeight) + 1;
vPoint[1].x = vX + vWidth - 2;
vPoint[1].y = m_vRclPaint.yTop - (vY + 2);
::GpiMove(m_hPS, &vPoint[0]);
::GpiBox( m_hPS ::GpiBox( m_hPS
,lControl ,lControl
,&vPoint[1] ,&vPoint[1]
@@ -680,9 +686,9 @@ void wxDC::DoDrawRoundedRectangle(
LONG lControl; LONG lControl;
vPoint[0].x = vX; vPoint[0].x = vX;
vPoint[0].y = vY; vPoint[0].y = YLOG2DEV(vY) - vHeight;
vPoint[1].x = vX + vWidth; vPoint[1].x = vX + vWidth;
vPoint[1].y = vY + vHeight; vPoint[1].y = vY;
::GpiMove(m_hPS, &vPoint[0]); ::GpiMove(m_hPS, &vPoint[0]);
lControl = DRO_OUTLINEFILL; //DRO_FILL; lControl = DRO_OUTLINEFILL; //DRO_FILL;
@@ -1241,10 +1247,15 @@ void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
// TODO: // TODO:
}; };
void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y ) void wxDC::SetDeviceOrigin(
wxCoord x
, wxCoord y
)
{ {
RECTL vRect; RECTL vRect;
m_deviceOriginX = x;
m_deviceOriginY = y;
::GpiQueryPageViewport( m_hPS ::GpiQueryPageViewport( m_hPS
,&vRect ,&vRect
); );

8
src/os2/dcclient.cpp
View File

@@ -270,9 +270,7 @@ wxPaintDC::wxPaintDC(
} }
else // not in cache, create a new one else // not in cache, create a new one
{ {
SIZEL vSizl = { 0,0};
HPS hPS; HPS hPS;
HRGN hRgn;
hPS = ::WinBeginPaint( GetWinHwnd(m_pCanvas) hPS = ::WinBeginPaint( GetWinHwnd(m_pCanvas)
,NULLHANDLE ,NULLHANDLE
@@ -280,6 +278,10 @@ wxPaintDC::wxPaintDC(
); );
if(hPS) if(hPS)
{ {
POINTL vPoint[2];
LONG lControl;
LONG lColor;
m_hOldPS = m_hPS; m_hOldPS = m_hPS;
m_hPS = hPS; m_hPS = hPS;
::GpiCreateLogColorTable( m_hPS ::GpiCreateLogColorTable( m_hPS
@@ -296,6 +298,8 @@ wxPaintDC::wxPaintDC(
,0L ,0L
,NULL ,NULL
); );
::WinFillRect(hPS, &g_paintStruct, m_pCanvas->GetBackgroundColour().GetPixel());
} }
m_bIsPaintTime = TRUE; m_bIsPaintTime = TRUE;

53
src/os2/frame.cpp
View File

@@ -984,6 +984,22 @@ bool wxFrame::OS2Create(
wxAssociateWinWithHandle(m_hWnd, this); wxAssociateWinWithHandle(m_hWnd, this);
wxAssociateWinWithHandle(m_hFrame, this); wxAssociateWinWithHandle(m_hFrame, this);
m_backgroundColour.Set(wxString("GREY"));
LONG lColor = (LONG)m_backgroundColour.GetPixel();
if (!::WinSetPresParam( m_hWnd
,PP_BACKGROUNDCOLOR
,sizeof(LONG)
,(PVOID)&lColor
))
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
wxLogError("Error creating frame. Error: %s\n", sError);
return FALSE;
}
// //
// Now need to subclass window. Instead of calling the SubClassWin in wxWindow // 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 // we manually subclass here because we don't want to use the main wxWndProc
@@ -1276,8 +1292,7 @@ bool wxFrame::HandlePaint()
} }
else else
{ {
wxWindow::HandlePaint(); return(wxWindow::HandlePaint());
return TRUE;
} }
} }
else else
@@ -1585,20 +1600,19 @@ MRESULT wxFrame::OS2WindowProc(
break; break;
case WM_PAINT: case WM_PAINT:
{ bProcessed = HandlePaint();
HPS hPS;
RECTL vRect;
wxPaintEvent vEvent;
hPS = WinBeginPaint(m_hWnd, 0L, &vRect);
::WinFillRect(hPS, &vRect, CLR_BLUE /* SYSCLR_WINDOW */);
::WinEndPaint(hPS);
mRc = (MRESULT)FALSE; mRc = (MRESULT)FALSE;
vEvent.SetEventObject(this); break;
GetEventHandler()->ProcessEvent(vEvent);
bProcessed = TRUE; case WM_ERASEBACKGROUND:
} //
// Returning TRUE to requests PM to paint the window background
// in SYSCLR_WINDOW. We capture this here because the PS returned
// in Frames is the PS for the whole frame, which we can't really
// use at all. If you want to paint a different background, do it
// in an OnPaint using a wxPaintDC.
//
mRc = (MRESULT)(TRUE);
break; break;
case WM_COMMAND: case WM_COMMAND:
@@ -1656,15 +1670,6 @@ MRESULT wxFrame::OS2WindowProc(
mRc = (MRESULT)FALSE; mRc = (MRESULT)FALSE;
break; break;
case WM_ERASEBACKGROUND:
//
// Return TRUE to request PM to paint the window background
// in SYSCLR_WINDOW.
//
bProcessed = TRUE;
mRc = (MRESULT)(TRUE);
break;
case CM_QUERYDRAGIMAGE: case CM_QUERYDRAGIMAGE:
{ {
HPOINTER hIcon; HPOINTER hIcon;

2
src/os2/pen.cpp
View File

@@ -263,7 +263,7 @@ bool wxPen::RealizeResource()
} }
m_vAreaBundle.lColor = vPmColour; m_vAreaBundle.lColor = vPmColour;
m_vAreaBundle.lBackColor = CLR_DEFAULT; m_vAreaBundle.lBackColor = RGB_WHITE;
m_vAreaBundle.usMixMode = FM_OVERPAINT; m_vAreaBundle.usMixMode = FM_OVERPAINT;
m_vAreaBundle.usBackMixMode = BM_OVERPAINT; m_vAreaBundle.usBackMixMode = BM_OVERPAINT;

662
src/os2/region.cpp
View File

@@ -29,24 +29,51 @@ class WXDLLEXPORT wxRegionRefData : public wxGDIRefData {
public: public:
wxRegionRefData() wxRegionRefData()
{ {
m_region = 0; m_hRegion = 0;
} }
wxRegionRefData(const wxRegionRefData& data) wxRegionRefData(const wxRegionRefData& rData)
{ {
// TODO RGNRECT vRgnData;
PRECTL pRect = NULL;
if (::GpiQueryRegionRects( rData.m_hPS // Pres space
,rData.m_hRegion // Handle of region to query
,NULL // Return all RECTs
,&vRgnData // Will contain number or RECTs in region
,NULL // NULL to return number of RECTs
))
{
pRect = new RECTL[vRgnData.crcReturned];
vRgnData.crc = vRgnData.crcReturned;
vRgnData.ircStart = 1;
if (::GpiQueryRegionRects( rData.m_hPS // Pres space of source
,rData.m_hRegion // Handle of source region
,NULL // Return all RECTs
,&vRgnData // Operations set to return rects
,pRect // Will contain the actual RECTS
))
{
m_hRegion = ::GpiCreateRegion( rData.m_hPS
,vRgnData.crcReturned
,pRect
);
m_hPS = rData.m_hPS;
}
delete [] pRect;
}
} }
~wxRegionRefData() ~wxRegionRefData()
{ {
// TODO ::GpiDestroyRegion(m_hPS, m_hRegion);
} }
HRGN m_region; HRGN m_hRegion;
HPS m_hPS;
}; };
#define M_REGION (((wxRegionRefData*)m_refData)->m_region) #define M_REGION (((wxRegionRefData*)m_refData)->m_hRegion)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// wxRegion // wxRegion
@@ -58,151 +85,331 @@ public:
wxRegion::wxRegion() wxRegion::wxRegion()
{ {
m_refData = new wxRegionRefData; m_refData = new wxRegionRefData;
// TODO create empty region } // end of wxRegion::wxRegion
}
wxRegion::wxRegion(WXHRGN hRegion) wxRegion::wxRegion(
WXHRGN hRegion
)
{ {
m_refData = new wxRegionRefData; m_refData = new wxRegionRefData;
M_REGION = (HRGN) hRegion; M_REGION = (HRGN) hRegion;
} } // end of wxRegion::wxRegion
wxRegion::wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h) wxRegion::wxRegion(
wxCoord x
, wxCoord y
, wxCoord vWidth
, wxCoord vHeight
)
{ {
m_refData = new wxRegionRefData; RECTL vRect;
// TODO create rect region SIZEL vSize = {0, 0};
} DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
HDC hDC = ::DevOpenDC( vHabmain
,OD_MEMORY
,"*"
,5L
,(PDEVOPENDATA)&vDop
,NULLHANDLE
);
wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight)
vRect.xLeft = x;
vRect.xRight = x + vWidth;
vRect.yBottom = y;
vRect.yTop = y + vHeight;
m_refData = new wxRegionRefData;
//
// Need a PS to create a Region
//
((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
,hDC
,&vSize
,PU_PELS | GPIT_MICRO | GPIA_ASSOC
);
M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
,1
,&vRect
);
} // end of wxRegion::wxRegion
wxRegion::wxRegion(
const wxPoint& rTopLeft
, const wxPoint& rBottomRight
)
{ {
m_refData = new wxRegionRefData; RECTL vRect;
// TODO create rect region SIZEL vSize = {0, 0};
} DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
HDC hDC = ::DevOpenDC( vHabmain
,OD_MEMORY
,"*"
,5L
,(PDEVOPENDATA)&vDop
,NULLHANDLE
);
wxRegion::wxRegion(const wxRect& rect) vRect.xLeft = rTopLeft.x;
vRect.xRight = rBottomRight.x;
vRect.yBottom = rBottomRight.y;
vRect.yTop = rTopLeft.y;
m_refData = new wxRegionRefData;
//
// Need a PS to create a Region
//
((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
,hDC
,&vSize
,PU_PELS | GPIT_MICRO | GPIA_ASSOC
);
M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
,1
,&vRect
);
} // end of wxRegion::wxRegion
wxRegion::wxRegion(
const wxRect& rRect
)
{ {
m_refData = new wxRegionRefData; RECTL vRect;
// TODO create rect region SIZEL vSize = {0, 0};
} DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
HDC hDC = ::DevOpenDC( vHabmain
,OD_MEMORY
,"*"
,5L
,(PDEVOPENDATA)&vDop
,NULLHANDLE
);
/*!
* Destroy the region. vRect.xLeft = rRect.x;
*/ vRect.xRight = rRect.x + rRect.width;
vRect.yBottom = rRect.y;
vRect.yTop = rRect.y + rRect.height;
m_refData = new wxRegionRefData;
//
// Need a PS to create a Region
//
((wxRegionRefData*)m_refData)->m_hPS = ::GpiCreatePS( vHabmain
,hDC
,&vSize
,PU_PELS | GPIT_MICRO | GPIA_ASSOC
);
M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
,1
,&vRect
);
} // end of wxRegion::wxRegion
//
// Destroy the region.
//
wxRegion::~wxRegion() wxRegion::~wxRegion()
{ {
// m_refData unrefed in ~wxObject } // end of wxRegion::~wxRegion
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
//# Modify region //# Modify region
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
//! Clear current region //
// Clear current region
//
void wxRegion::Clear() void wxRegion::Clear()
{ {
UnRef(); UnRef();
} } // end of wxRegion::Clear
//! Combine rectangle (x, y, w, h) with this. //
bool wxRegion::Combine(wxCoord x, wxCoord y, wxCoord width, wxCoord height, wxRegionOp op) // Combine rectangle (x, y, w, h) with this.
//
bool wxRegion::Combine(
wxCoord x
, wxCoord y
, wxCoord vWidth
, wxCoord vHeight
, wxRegionOp eOp
)
{ {
//
// Don't change shared data // Don't change shared data
if (!m_refData) { //
if (!m_refData)
{
m_refData = new wxRegionRefData(); m_refData = new wxRegionRefData();
} else if (m_refData->GetRefCount() > 1) {
wxRegionRefData* ref = (wxRegionRefData*)m_refData;
UnRef();
m_refData = new wxRegionRefData(*ref);
} }
else if (m_refData->GetRefCount() > 1)
{
wxRegionRefData* pRef = (wxRegionRefData*)m_refData;
UnRef();
m_refData = new wxRegionRefData(*pRef);
}
//
// If ref count is 1, that means it's 'ours' anyway so no action. // If ref count is 1, that means it's 'ours' anyway so no action.
//
RECTL vRect;
// TODO create rect region vRect.xLeft = x;
vRect.xRight = x + vWidth;
vRect.yBottom = y;
vRect.yTop = y + vHeight;
int mode = 0; // TODO platform-specific code HRGN hRgn = ::GpiCreateRegion( ((wxRegionRefData*)m_refData)->m_hPS
switch (op) ,1
,&vRect
);
LONG lMode = 0L;
switch (eOp)
{ {
case wxRGN_AND: case wxRGN_AND:
// TODO lMode = CRGN_AND;
break ; break;
case wxRGN_OR: case wxRGN_OR:
// TODO lMode = CRGN_OR;
break ; break;
case wxRGN_XOR: case wxRGN_XOR:
// TODO lMode = CRGN_XOR;
break ; break;
case wxRGN_DIFF: case wxRGN_DIFF:
// TODO lMode = CRGN_DIFF;
break ; break;
case wxRGN_COPY: case wxRGN_COPY:
default: default:
// TODO lMode = CRGN_COPY;
break ; break;
} }
bool bSuccess = ::GpiCombineRegion( ((wxRegionRefData*)m_refData)->m_hPS
,M_REGION
,M_REGION
,hRgn
,lMode
);
::GpiDestroyRegion ( ((wxRegionRefData*)m_refData)->m_hPS
,hRgn
);
// TODO do combine region return bSuccess;
} // end of wxRegion::Combine
return FALSE; //
} // Union region with this.
//
//! Union /e region with this. bool wxRegion::Combine(
bool wxRegion::Combine(const wxRegion& region, wxRegionOp op) const wxRegion& rRegion
, wxRegionOp eOp
)
{ {
if (region.Empty()) if (rRegion.Empty())
return FALSE; return FALSE;
//
// Don't change shared data // Don't change shared data
if (!m_refData) { //
if (!m_refData)
{
m_refData = new wxRegionRefData(); m_refData = new wxRegionRefData();
} else if (m_refData->GetRefCount() > 1) { }
wxRegionRefData* ref = (wxRegionRefData*)m_refData; else if (m_refData->GetRefCount() > 1)
{
wxRegionRefData* pRef = (wxRegionRefData*)m_refData;
UnRef(); UnRef();
m_refData = new wxRegionRefData(*ref); m_refData = new wxRegionRefData(*pRef);
} }
int mode = 0; // TODO platform-specific code LONG lMode = 0;
switch (op)
switch (eOp)
{ {
case wxRGN_AND: case wxRGN_AND:
// TODO lMode = CRGN_AND;
break ; break;
case wxRGN_OR: case wxRGN_OR:
// TODO lMode = CRGN_OR;
break ; break;
case wxRGN_XOR: case wxRGN_XOR:
// TODO lMode = CRGN_XOR;
break ; break;
case wxRGN_DIFF: case wxRGN_DIFF:
// TODO lMode = CRGN_DIFF;
break ; break;
case wxRGN_COPY: case wxRGN_COPY:
default: default:
// TODO lMode = CRGN_COPY;
break ; break;
} }
return (::GpiCombineRegion( ((wxRegionRefData*)rRegion.m_refData)->m_hPS
,M_REGION
,M_REGION
,((wxRegionRefData*)rRegion.m_refData)->m_hRegion
,lMode
) != RGN_ERROR);
} // end of wxRegion::Combine
// TODO combine region bool wxRegion::Combine(
const wxRect& rRect
return FALSE; , wxRegionOp eOp
} )
bool wxRegion::Combine(const wxRect& rect, wxRegionOp op)
{ {
return Combine(rect.GetLeft(), rect.GetTop(), rect.GetWidth(), rect.GetHeight(), op); return Combine( rRect.GetLeft()
} ,rRect.GetTop()
,rRect.GetWidth()
,rRect.GetHeight()
,eOp
);
} // end of wxRegion::Combine
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
//# Information on region //# Information on region
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
//
// Outer bounds of region // Outer bounds of region
void wxRegion::GetBox(wxCoord& x, wxCoord& y, wxCoord&w, wxCoord &h) const //
void wxRegion::GetBox(
wxCoord& x
, wxCoord& y
, wxCoord& vWidth
, wxCoord& vHeight
) const
{ {
if (m_refData) { if (m_refData)
// TODO get box {
} else { RECTL vRect;
x = y = w = h = 0;
::GpiQueryRegionBox( ((wxRegionRefData*)m_refData)->m_hPS
,M_REGION
,&vRect
);
x = vRect.xLeft;
y = vRect.yTop;
vWidth = vRect.xRight - vRect.xLeft;
vHeight = vRect.yTop - vRect.yBottom;
} }
} else
{
x = y = vWidth = vHeight = 0L;
}
} // end of wxRegion::GetBox
wxRect wxRegion::GetBox() const wxRect wxRegion::GetBox() const
{ {
@@ -211,73 +418,136 @@ wxRect wxRegion::GetBox() const
return wxRect(x, y, w, h); return wxRect(x, y, w, h);
} }
//
// Is region empty? // Is region empty?
//
bool wxRegion::Empty() const bool wxRegion::Empty() const
{ {
// TODO wxCoord x;
return FALSE; wxCoord y;
} wxCoord vWidth;
wxCoord vHeight;
if (M_REGION == 0)
return TRUE;
GetBox( x
,y
,vWidth
,vHeight
);
return ((vWidth == 0) && (vHeight == 0));
} // end of wxRegion::Empty
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
//# Tests // Tests
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
//
// Does the region contain the point (x,y)? // Does the region contain the point (x,y)?
wxRegionContain wxRegion::Contains(wxCoord x, wxCoord y) const wxRegionContain wxRegion::Contains(
wxCoord x
, wxCoord y
) const
{ {
bool bOK = FALSE; // temporary bool bOK = FALSE;
POINTL vPoint;
vPoint.x = x;
vPoint.y = y;
if (!m_refData) if (!m_refData)
return wxOutRegion; return wxOutRegion;
// TODO. Return wxInRegion if within region. LONG lInside = ::GpiPtInRegion( ((wxRegionRefData*)m_refData)->m_hPS
if (bOK) ,M_REGION
,&vPoint
);
if (lInside == PRGN_INSIDE)
return wxInRegion; return wxInRegion;
return wxOutRegion; return wxOutRegion;
} } // end of wxRegion::Contains
//
// Does the region contain the point pt? // Does the region contain the point pt?
wxRegionContain wxRegion::Contains(const wxPoint& pt) const //
wxRegionContain wxRegion::Contains(
const wxPoint& rPoint
) const
{ {
bool bOK = FALSE; // temporary POINTL vPoint = { rPoint.x, rPoint.y };
if (!m_refData) if (!m_refData)
return wxOutRegion; return wxOutRegion;
// TODO. Return wxInRegion if within region. LONG lInside = ::GpiPtInRegion( ((wxRegionRefData*)m_refData)->m_hPS
if (bOK) ,M_REGION
,&vPoint
);
if (lInside == PRGN_INSIDE)
return wxInRegion; return wxInRegion;
else else
return wxOutRegion; return wxOutRegion;
} } // end of wxRegion::Contains
//
// Does the region contain the rectangle (x, y, w, h)? // Does the region contain the rectangle (x, y, w, h)?
wxRegionContain wxRegion::Contains(wxCoord x, wxCoord y, wxCoord w, wxCoord h) const //
wxRegionContain wxRegion::Contains(
wxCoord x
, wxCoord y
, wxCoord vWidth
, wxCoord vHeight
) const
{ {
bool bOK = FALSE; // temporary RECTL vRect;
if (!m_refData) if (!m_refData)
return wxOutRegion; return wxOutRegion;
// TODO. Return wxInRegion if within region. vRect.xLeft = x;
if (bOK) vRect.yTop = y;
vRect.xRight = x + vWidth;
vRect.yBottom = y + vHeight;
if (PRGN_INSIDE == ::GpiRectInRegion( ((wxRegionRefData*)m_refData)->m_hPS
,M_REGION
,&vRect
))
return wxInRegion; return wxInRegion;
else else
return wxOutRegion; return wxOutRegion;
} } // end of wxRegion::Contains
//
// Does the region contain the rectangle rect // Does the region contain the rectangle rect
wxRegionContain wxRegion::Contains(const wxRect& rect) const //
wxRegionContain wxRegion::Contains(
const wxRect& rRect
) const
{ {
if (!m_refData) if (!m_refData)
return wxOutRegion; return wxOutRegion;
wxCoord x, y, w, h; wxCoord x;
x = rect.x; wxCoord y;
y = rect.y; wxCoord vWidth;
w = rect.GetWidth(); wxCoord vHeight;
h = rect.GetHeight();
return Contains(x, y, w, h);
}
x = rRect.x;
y = rRect.y;
vWidth = rRect.GetWidth();
vHeight = rRect.GetHeight();
return Contains( x
,y
,vWidth
,vHeight
);
} // end of wxRegion::Contains
//
// Get internal region handle // Get internal region handle
//
WXHRGN wxRegion::GetHRGN() const WXHRGN wxRegion::GetHRGN() const
{ {
if (!m_refData) if (!m_refData)
@@ -291,96 +561,136 @@ WXHRGN wxRegion::GetHRGN() const
// // // //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
/*! //
* Initialize empty iterator // Initialize empty iterator
*/ //
wxRegionIterator::wxRegionIterator() : m_current(0), m_numRects(0), m_rects(NULL) wxRegionIterator::wxRegionIterator()
: m_lCurrent(0)
, m_lNumRects(0)
, m_pRects(NULL)
{ {
} } // end of wxRegionIterator::wxRegionIterator
wxRegionIterator::~wxRegionIterator() wxRegionIterator::~wxRegionIterator()
{ {
if (m_rects) if (m_pRects)
delete[] m_rects; delete[] m_pRects;
} } // end of wxRegionIterator::~wxRegionIterator
/*! //
* Initialize iterator for region // Initialize iterator for region
*/ //
wxRegionIterator::wxRegionIterator(const wxRegion& region) wxRegionIterator::wxRegionIterator(
const wxRegion& rRegion
)
{ {
m_rects = NULL; m_pRects = NULL;
Reset(rRegion);
} // end of wxRegionIterator::wxRegionIterator
Reset(region); //
} // Reset iterator for a new /e region.
//
/*! void wxRegionIterator::Reset(
* Reset iterator for a new /e region. const wxRegion& rRegion
*/ )
void wxRegionIterator::Reset(const wxRegion& region)
{ {
m_current = 0; m_lCurrent = 0;
m_region = region; m_vRegion = rRegion;
if (m_rects) if (m_pRects)
delete[] m_rects; delete[] m_pRects;
m_rects = NULL; m_pRects = NULL;
if (m_region.Empty()) if (m_vRegion.Empty())
m_numRects = 0; m_lNumRects = 0;
else else
{ {
// TODO create m_rects and fill with rectangles for this region RGNRECT vRgnData;
m_numRects = 0; PRECTL pRect;
if (::GpiQueryRegionRects( ((wxRegionRefData*)rRegion.m_refData)->m_hPS // Pres space
,((wxRegionRefData*)rRegion.m_refData)->m_hRegion // Handle of region to query
,NULL // Return all RECTs
,&vRgnData // Will contain number or RECTs in region
,NULL // NULL to return number of RECTs
))
{
pRect = new RECTL[vRgnData.crcReturned];
m_pRects = new wxRect[vRgnData.crcReturned];
vRgnData.crc = vRgnData.crcReturned;
m_lNumRects = vRgnData.crcReturned;
vRgnData.ircStart = 1;
if (::GpiQueryRegionRects( ((wxRegionRefData*)rRegion.m_refData)->m_hPS // Pres space of source
,((wxRegionRefData*)rRegion.m_refData)->m_hRegion // Handle of source region
,NULL // Return all RECTs
,&vRgnData // Operations set to return rects
,pRect // Will contain the actual RECTS
))
{
M_REGION = ::GpiCreateRegion( ((wxRegionRefData*)rRegion.m_refData)->m_hPS
,vRgnData.crcReturned
,pRect
);
for( LONG i = 0; i < m_lNumRects; i++)
{
m_pRects[i].x = pRect[i].xLeft;
m_pRects[i].width = pRect[i].xRight - pRect[i].xLeft;
m_pRects[i].y = pRect[i].yBottom;
m_pRects[i].height = pRect[i].yTop - pRect[i].yBottom;
} }
} ((wxRegionRefData*)m_refData)->m_hPS = ((wxRegionRefData*)rRegion.m_refData)->m_hPS;
}
}
}
} // end of wxRegionIterator::Reset
/*! //
* Increment iterator. The rectangle returned is the one after the // Increment iterator. The rectangle returned is the one after the
* incrementation. // incrementation.
*/ //
void wxRegionIterator::operator ++ () void wxRegionIterator::operator++ ()
{ {
if (m_current < m_numRects) if (m_lCurrent < m_lNumRects)
++m_current; ++m_lCurrent;
} } // end of wxRegionIterator::operator ++
/*! //
* Increment iterator. The rectangle returned is the one before the // Increment iterator. The rectangle returned is the one before the
* incrementation. // incrementation.
*/ //
void wxRegionIterator::operator ++ (int) void wxRegionIterator::operator++ (int)
{ {
if (m_current < m_numRects) if (m_lCurrent < m_lNumRects)
++m_current; ++m_lCurrent;
} } // end of wxRegionIterator::operator++
wxCoord wxRegionIterator::GetX() const wxCoord wxRegionIterator::GetX() const
{ {
if (m_current < m_numRects) if (m_lCurrent < m_lNumRects)
return m_rects[m_current].x; return m_pRects[m_lCurrent].x;
return 0; return 0L;
} } // end of wxRegionIterator::GetX
wxCoord wxRegionIterator::GetY() const wxCoord wxRegionIterator::GetY() const
{ {
if (m_current < m_numRects) if (m_lCurrent < m_lNumRects)
return m_rects[m_current].y; return m_pRects[m_lCurrent].y;
return 0; return 0L;
} } // end of wxRegionIterator::GetY
wxCoord wxRegionIterator::GetW() const wxCoord wxRegionIterator::GetW() const
{ {
if (m_current < m_numRects) if (m_lCurrent < m_lNumRects)
return m_rects[m_current].width ; return m_pRects[m_lCurrent].width ;
return 0; return 0L;
} } // end of wxRegionIterator::GetW
wxCoord wxRegionIterator::GetH() const wxCoord wxRegionIterator::GetH() const
{ {
if (m_current < m_numRects) if (m_lCurrent < m_lNumRects)
return m_rects[m_current].height; return m_pRects[m_lCurrent].height;
return 0; return 0L;
} } // end of wxRegionIterator::GetH

73
src/os2/window.cpp
View File

@@ -2106,6 +2106,15 @@ MRESULT wxWindow::OS2WindowProc(
} }
break; break;
#endif #endif
case WM_ERASEBACKGROUND:
//
// Returning TRUE to requestw PM to paint the window background
// in SYSCLR_WINDOW. We don't really want that
//
bProcessed = HandleEraseBkgnd((WXHDC)(HPS)wParam);
mResult = (MRESULT)(FALSE);
break;
// //
// Instead of CTLCOLOR messages PM sends QUERYWINDOWPARAMS to // Instead of CTLCOLOR messages PM sends QUERYWINDOWPARAMS to
// things such as colors and fonts and such // things such as colors and fonts and such
@@ -2133,17 +2142,6 @@ MRESULT wxWindow::OS2WindowProc(
bProcessed = HandlePresParamChanged(wParam); bProcessed = HandlePresParamChanged(wParam);
break; break;
// move this to wxFrame
case WM_ERASEBACKGROUND:
bProcessed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
if (bProcessed)
{
//
// We processed the message, i.e. erased the background
//
mResult = (MRESULT)TRUE;
}
break;
// move all drag and drops to wxDrg // move all drag and drops to wxDrg
case WM_ENDDRAG: case WM_ENDDRAG:
@@ -2844,47 +2842,36 @@ bool wxWindow::HandlePaint()
wxLogLastError("CreateRectRgn"); wxLogLastError("CreateRectRgn");
return FALSE; return FALSE;
} }
//
// Debug code
//
#ifdef __WXDEBUG__
{
HWND hWnd;
HWND hWnd0 = NULLHANDLE;
hWnd = GetHwnd();
if(hWnd != hWnd0)
printf("HandlePaint hWnd=%x ",hWnd);
}
#endif
m_updateRegion = wxRegion(hRgn); m_updateRegion = wxRegion(hRgn);
vEvent.SetEventObject(this); vEvent.SetEventObject(this);
return (GetEventHandler()->ProcessEvent(vEvent)); return (GetEventHandler()->ProcessEvent(vEvent));
} // end of wxWindow::HandlePaint } // end of wxWindow::HandlePaint
bool wxWindow::HandleEraseBkgnd(WXHDC hdc) bool wxWindow::HandleEraseBkgnd(
WXHDC hDC
)
{ {
// TODO: will have to worry about this later as part of SWP vSwp;
// the handling of changed presentation parameters
/* ::WinQueryWindowPos(GetHwnd(), &vSwp);
if ( ::IsIconic(GetHwnd()) ) if (vSwp.fl & SWP_MINIMIZE)
return TRUE; return TRUE;
wxDC dc; wxDC vDC;
dc.SetHDC(hdc); vDC.m_hPS = (HPS)hDC; // this is really a PS
dc.SetWindow(this); vDC.SetWindow(this);
dc.BeginDrawing(); vDC.BeginDrawing();
wxEraseEvent event(m_windowId, &dc); wxEraseEvent vEvent(m_windowId, &vDC);
event.SetEventObject(this);
bool rc = GetEventHandler()->ProcessEvent(event);
dc.EndDrawing(); vEvent.SetEventObject(this);
dc.SelectOldObjects(hdc);
dc.SetHDC((WXHDC) NULL); bool rc = GetEventHandler()->ProcessEvent(vEvent);
*/
vDC.EndDrawing();
vDC.m_hPS = NULLHANDLE;
return TRUE; return TRUE;
} // end of wxWindow::HandleEraseBkgnd } // end of wxWindow::HandleEraseBkgnd
@@ -2892,7 +2879,11 @@ void wxWindow::OnEraseBackground(
wxEraseEvent& rEvent wxEraseEvent& rEvent
) )
{ {
// TODO: RECTL vRect;
HPS hPS = rEvent.m_dc->m_hPS;
::WinQueryWindowRect(GetHwnd(), &vRect);
::WinFillRect(hPS, &vRect, m_backgroundColour.GetPixel());
} // end of wxWindow::OnEraseBackground } // end of wxWindow::OnEraseBackground
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------