/////////////////////////////////////////////////////////////////////////////
-// Name: dc.cpp
+// Name: src/os2/dc.cpp
// Purpose: wxDC class
// Author: David Webster
// Modified by:
// Created: 10/14/99
-// RCS-ID: $Id$
// Copyright: (c) David Webster
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/log.h"
#include "wx/icon.h"
#include "wx/msgdlg.h"
+ #include "wx/dcprint.h"
+ #include "wx/statusbr.h"
#include "wx/module.h"
#endif
-#include "wx/dcprint.h"
-
#include <string.h>
-#include <math.h>
+#include "wx/os2/dc.h"
+#include "wx/os2/dcclient.h"
#include "wx/os2/private.h"
- IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
+IMPLEMENT_ABSTRACT_CLASS(wxPMDCImpl, wxDCImpl)
//
-// wxWindows uses the Microsoft convention that the origin is the UPPER left.
+// wxWidgets uses the Microsoft convention that the origin is the UPPER left.
// Native OS/2 however in the GPI and PM define the origin as the LOWER left.
-// In order to map OS/2 GPI/PM y coordinates to wxWindows coordinates we must
+// In order to map OS/2 GPI/PM y coordinates to wxWidgets coordinates we must
// perform the following transformation:
//
// Parent object height: POBJHEIGHT
// Desried origin: WXORIGINY
// Object to place's height: OBJHEIGHT
//
-// To get the OS2 position from the wxWindows one:
+// To get the OS2 position from the wxWidgets one:
//
// OS2Y = POBJHEIGHT - (WXORIGINY + OBJHEIGHT)
//
// For OS/2 wxDC's we will always determine m_vRclPaint as the size of the
// OS/2 Presentation Space associated with the device context. y is the
-// desired application's y coordinate of the origin in wxWindows space.
+// desired application's y coordinate of the origin in wxWidgets space.
// objy is the height of the object we are going to draw.
//
#define OS2Y(y, objy) ((m_vRclPaint.yTop - m_vRclPaint.yBottom) - (y + objy))
static const int MM_POINTS = 9;
static const int MM_METRIC = 10;
-// usually this is defined in math.h
-#ifndef M_PI
- static const double M_PI = 3.14159265358979323846;
-#endif // M_PI
-
// ---------------------------------------------------------------------------
// private functions
// ---------------------------------------------------------------------------
// wxDCCacheEntry
// ---------------------------------------------------------------------------
-wxList wxDC::m_svBitmapCache;
-wxList wxDC::m_svDCCache;
+wxList wxPMDCImpl::m_svBitmapCache;
+wxList wxPMDCImpl::m_svDCCache;
wxDCCacheEntry::wxDCCacheEntry(
WXHBITMAP hBitmap
::GpiDestroyPS(m_hPS);
} // end of wxDCCacheEntry::~wxDCCacheEntry
-wxDCCacheEntry* wxDC::FindBitmapInCache(
+wxDCCacheEntry* wxPMDCImpl::FindBitmapInCache(
HPS hPS
, int nWidth
, int nHeight
vBmpHdr.cx = nWidth;
vBmpHdr.cy = nHeight;
vBmpHdr.cPlanes = 1;
- vBmpHdr.cBitCount = nDepth;
+ vBmpHdr.cBitCount = (USHORT)nDepth;
pEntry->m_hBitmap = (WXHBITMAP) ::GpiCreateBitmap( hPS
,&vBmpHdr
vBmpHdr.cx = nWidth;
vBmpHdr.cy = nHeight;
vBmpHdr.cPlanes = 1;
- vBmpHdr.cBitCount = nDepth;
+ vBmpHdr.cBitCount = (USHORT)nDepth;
WXHBITMAP hBitmap = (WXHBITMAP) ::GpiCreateBitmap( hPS
,&vBmpHdr
return pEntry;
} // end of FindBitmapInCache
-wxDCCacheEntry* wxDC::FindDCInCache(
+wxDCCacheEntry* wxPMDCImpl::FindDCInCache(
wxDCCacheEntry* pNotThis
, HPS hPS
)
);
AddToDCCache(pEntry);
return pEntry;
-} // end of wxDC::FindDCInCache
+} // end of wxPMDCImpl::FindDCInCache
-void wxDC::AddToBitmapCache(
+void wxPMDCImpl::AddToBitmapCache(
wxDCCacheEntry* pEntry
)
{
m_svBitmapCache.Append(pEntry);
-} // end of wxDC::AddToBitmapCache
+} // end of wxPMDCImpl::AddToBitmapCache
-void wxDC::AddToDCCache(
+void wxPMDCImpl::AddToDCCache(
wxDCCacheEntry* pEntry
)
{
m_svDCCache.Append(pEntry);
-} // end of wxDC::AddToDCCache
+} // end of wxPMDCImpl::AddToDCCache
-void wxDC::ClearCache()
+void wxPMDCImpl::ClearCache()
{
- m_svBitmapCache.DeleteContents(TRUE);
+ m_svBitmapCache.DeleteContents(true);
m_svBitmapCache.Clear();
- m_svBitmapCache.DeleteContents(FALSE);
- m_svDCCache.DeleteContents(TRUE);
+ m_svBitmapCache.DeleteContents(false);
+ m_svDCCache.DeleteContents(true);
m_svDCCache.Clear();
- m_svDCCache.DeleteContents(FALSE);
-} // end of wxDC::ClearCache
+ m_svDCCache.DeleteContents(false);
+} // end of wxPMDCImpl::ClearCache
// Clean up cache at app exit
class wxDCModule : public wxModule
{
public:
- virtual bool OnInit() { return TRUE; }
- virtual void OnExit() { wxDC::ClearCache(); }
+ virtual bool OnInit() { return true; }
+ virtual void OnExit() { wxPMDCImpl::ClearCache(); }
private:
DECLARE_DYNAMIC_CLASS(wxDCModule)
// wxDC
// ---------------------------------------------------------------------------
-wxDC::wxDC(void)
+wxPMDCImpl::wxPMDCImpl( wxDC *owner, WXHDC hDC ) :
+ wxDCImpl( owner )
{
- wxColour vColor;
-
- m_pCanvas = NULL;
-
- m_hOldBitmap = 0;
- m_hOldPen = 0;
- m_hOldBrush = 0;
- m_hOldFont = 0;
- m_hOldPalette = 0;
+ Init();
+ m_hDC = hDC;
+} // end of wxPMDCImpl::wxPMDCImpl
- m_bOwnsDC = FALSE;
- m_hDC = 0;
- m_hOldPS = NULL;
- m_hPS = NULL;
- m_bIsPaintTime = FALSE; // True at Paint Time
-
- vColor.InitFromName("BLACK");
- m_pen.SetColour(vColor);
- vColor.Set("WHITE");
- m_brush.SetColour(vColor);
-} // end of wxDC::wxDC
-
-wxDC::~wxDC(void)
+wxPMDCImpl::~wxPMDCImpl()
{
if ( m_hDC != 0 )
{
}
}
}
-} // end of wxDC::~wxDC
+} // end of wxPMDCImpl::~wxDC
// This will select current objects out of the DC,
// which is what you have to do before deleting the
// DC.
-void wxDC::SelectOldObjects(
+void wxPMDCImpl::SelectOldObjects(
WXHDC hPS
)
{
if (m_hOldBitmap)
{
::GpiSetBitmap(hPS, (HBITMAP) m_hOldBitmap);
- if (m_vSelectedBitmap.Ok())
+ if (m_vSelectedBitmap.IsOk())
{
m_vSelectedBitmap.SetSelectedInto(NULL);
}
m_font = wxNullFont;
m_backgroundBrush = wxNullBrush;
m_vSelectedBitmap = wxNullBitmap;
-} // end of wxDC::SelectOldObjects
+} // end of wxPMDCImpl::SelectOldObjects
// ---------------------------------------------------------------------------
// clipping
m_clipY2 = (wxCoord) YDEV2LOG(rect.yBottom); \
}
-void wxDC::DoSetClippingRegion(
+void wxPMDCImpl::DoSetClippingRegion(
wxCoord vX
, wxCoord vY
, wxCoord vWidth
RECTL vRect;
vY = OS2Y(vY,vHeight);
- m_clipping = TRUE;
+ m_clipping = true;
vRect.xLeft = vX;
vRect.yTop = vY + vHeight;
vRect.xRight = vX + vWidth;
vRect.yBottom = vY;
::GpiIntersectClipRectangle(m_hPS, &vRect);
DO_SET_CLIPPING_BOX()
-} // end of wxDC::DoSetClippingRegion
+} // end of wxPMDCImpl::DoSetClippingRegion
-void wxDC::DoSetClippingRegionAsRegion(
+void wxPMDCImpl::DoSetDeviceClippingRegion(
const wxRegion& rRegion
)
{
wxCHECK_RET(rRegion.GetHRGN(), wxT("invalid clipping region"));
HRGN hRgnOld;
- m_clipping = TRUE;
+ m_clipping = true;
::GpiSetClipRegion( m_hPS
,(HRGN)rRegion.GetHRGN()
,&hRgnOld
);
DO_SET_CLIPPING_BOX()
-} // end of wxDC::DoSetClippingRegionAsRegion
+} // end of wxPMDCImpl::DoSetDeviceClippingRegion
-void wxDC::DestroyClippingRegion(void)
+void wxPMDCImpl::DestroyClippingRegion()
{
if (m_clipping && m_hPS)
{
::GpiSetClipRegion(m_hPS, hRgn, &hRgnOld);
}
- m_clipping = FALSE;
-} // end of wxDC::DestroyClippingRegion
+ ResetClipping();
+} // end of wxPMDCImpl::DestroyClippingRegion
// ---------------------------------------------------------------------------
// query capabilities
// ---------------------------------------------------------------------------
-bool wxDC::CanDrawBitmap() const
+bool wxPMDCImpl::CanDrawBitmap() const
{
- return TRUE;
+ return true;
}
-bool wxDC::CanGetTextExtent() const
+bool wxPMDCImpl::CanGetTextExtent() const
{
LONG lTechnology = 0L;
::DevQueryCaps(GetHDC(), CAPS_TECHNOLOGY, 1L, &lTechnology);
return (lTechnology == CAPS_TECH_RASTER_DISPLAY) || (lTechnology == CAPS_TECH_RASTER_PRINTER);
-} // end of wxDC::CanGetTextExtent
+} // end of wxPMDCImpl::CanGetTextExtent
-int wxDC::GetDepth() const
+int wxPMDCImpl::GetDepth() const
{
- LONG lArray[CAPS_COLOR_BITCOUNT];
- int nBitsPerPixel;
+ LONG lCapsColorBitcount;
+ int nBitsPerPixel = 0;
if(::DevQueryCaps( GetHDC()
- ,CAPS_FAMILY
,CAPS_COLOR_BITCOUNT
- ,lArray
+ ,1L
+ ,&lCapsColorBitcount
))
{
- nBitsPerPixel = (int)lArray[CAPS_COLOR_BITCOUNT];
+ nBitsPerPixel = (int)lCapsColorBitcount;
}
return nBitsPerPixel;
-} // end of wxDC::GetDepth
+} // end of wxPMDCImpl::GetDepth
// ---------------------------------------------------------------------------
// drawing
// ---------------------------------------------------------------------------
-void wxDC::Clear()
+void wxPMDCImpl::Clear()
{
//
// If this is a canvas DC then just fill with the background color
}
else
::GpiErase(m_hPS);
-} // end of wxDC::Clear
+} // end of wxPMDCImpl::Clear
-bool wxDC::DoFloodFill(
+bool wxPMDCImpl::DoFloodFill(
wxCoord vX
, wxCoord vY
, const wxColour& rCol
-, int nStyle
+, wxFloodFillStyle nStyle
)
{
POINTL vPtlPos;
LONG lColor;
LONG lOptions;
LONG lHits;
- bool bSuccess = FALSE;
+ bool bSuccess = false;
vPtlPos.x = vX; // Loads x-coordinate
vPtlPos.y = OS2Y(vY,0); // Loads y-coordinate
lOptions = FF_SURFACE;
if ((lHits = ::GpiFloodFill(m_hPS, lOptions, lColor)) != GPI_ERROR)
- bSuccess = TRUE;
- return TRUE;
-} // end of wxDC::DoFloodFill
+ bSuccess = true;
-bool wxDC::DoGetPixel(
+ return bSuccess;
+} // end of wxPMDCImpl::DoFloodFill
+
+bool wxPMDCImpl::DoGetPixel(
wxCoord vX
, wxCoord vY
, wxColour* pCol
vPoint.x = vX;
vPoint.y = OS2Y(vY,0);
- lColor = ::GpiSetPel(m_hPS, &vPoint);
-
- //
- // Get the color of the pen
- //
- LONG lPencolor = 0x00ffffff;
-
- if (m_pen.Ok())
- {
- lPencolor = m_pen.GetColour().GetPixel();
- }
+ lColor = ::GpiQueryPel(m_hPS, &vPoint);
//
// return the color of the pixel
,GetGValue(lColor)
,GetBValue(lColor)
);
- return(lColor == lPencolor);
-} // end of wxDC::DoGetPixel
+ return true;
+} // end of wxPMDCImpl::DoGetPixel
-void wxDC::DoCrossHair(
+void wxPMDCImpl::DoCrossHair(
wxCoord vX
, wxCoord vY
)
::GpiLine(m_hPS, &vPoint[3]);
CalcBoundingBox(vX1, vY1);
CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoCrossHair
+} // end of wxPMDCImpl::DoCrossHair
-void wxDC::DoDrawLine(
+void wxPMDCImpl::DoDrawLine(
wxCoord vX1
, wxCoord vY1
, wxCoord vX2
)
{
POINTL vPoint[2];
+ COLORREF vColor = 0x00ffffff;
- vY1 = OS2Y(vY1,0);
- vY2 = OS2Y(vY2,0);
-
+ //
+ // Might be a memory DC with no Paint rect.
+ //
+ if (!(m_vRclPaint.yTop == 0 &&
+ m_vRclPaint.yBottom == 0 &&
+ m_vRclPaint.xRight == 0 &&
+ m_vRclPaint.xLeft == 0))
+ {
+ vY1 = OS2Y(vY1,0);
+ vY2 = OS2Y(vY2,0);
+ }
+ else
+ {
+ if (m_vSelectedBitmap.IsOk())
+ {
+ m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
+ m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
+ vY1 = OS2Y(vY1,0);
+ vY2 = OS2Y(vY2,0);
+ }
+ }
vPoint[0].x = vX1;
vPoint[0].y = vY1;
vPoint[1].x = vX2;
vPoint[1].y = vY2;
+ if (m_pen.IsOk())
+ {
+ vColor = m_pen.GetColour().GetPixel();
+ }
+ ::GpiSetColor(m_hPS, vColor);
::GpiMove(m_hPS, &vPoint[0]);
::GpiLine(m_hPS, &vPoint[1]);
CalcBoundingBox(vX1, vY1);
CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoDrawLine
+} // end of wxPMDCImpl::DoDrawLine
//////////////////////////////////////////////////////////////////////////////
// Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
// 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(
+void wxPMDCImpl::DoDrawArc(
wxCoord vX1
, wxCoord vY1
, wxCoord vX2
{
POINTL vPtlPos;
POINTL vPtlArc[2]; // Structure for current position
- int nDx;
- int nDy;
double dRadius;
double dAngl1;
double dAngl2;
// Medium point
//
dAnglmid = (dAngl1 + dAngl2)/2. + M_PI;
- vXm = vXc + dRadius * cos(dAnglmid);
- vYm = vYc + dRadius * sin(dAnglmid);
+ vXm = (wxCoord)(vXc + dRadius * cos(dAnglmid));
+ vYm = (wxCoord)(vYc + dRadius * sin(dAnglmid));
DoDrawArc( vX1, vY1
,vXm, vYm
,vXc, vYc
// Medium point
//
dAnglmid = (dAngl1 + dAngl2)/2.;
- vXm = vXc + dRadius * cos(dAnglmid);
- vYm = vYc + dRadius * sin(dAnglmid);
+ vXm = (wxCoord)(vXc + dRadius * cos(dAnglmid));
+ vYm = (wxCoord)(vYc + dRadius * sin(dAnglmid));
//
// Ellipse main axis (r,q), (p,s) with center at (0,0) */
vPtlArc[1].x = vX2;
vPtlArc[1].y = vY2;
::GpiPointArc(m_hPS, vPtlArc); // Draws the arc
- CalcBoundingBox( (vXc - dRadius)
- ,(vYc - dRadius)
+ CalcBoundingBox( (wxCoord)(vXc - dRadius)
+ ,(wxCoord)(vYc - dRadius)
);
- CalcBoundingBox( (vXc + dRadius)
- ,(vYc + dRadius)
+ CalcBoundingBox( (wxCoord)(vXc + dRadius)
+ ,(wxCoord)(vYc + dRadius)
);
-} // end of wxDC::DoDrawArc
+} // end of wxPMDCImpl::DoDrawArc
-void wxDC::DoDrawCheckMark(
+void wxPMDCImpl::DoDrawCheckMark(
wxCoord vX1
, wxCoord vY1
, wxCoord vWidth
CalcBoundingBox( vX2
,vY2
);
-} // end of wxDC::DoDrawCheckMark
+} // end of wxPMDCImpl::DoDrawCheckMark
-void wxDC::DoDrawPoint(
+void wxPMDCImpl::DoDrawPoint(
wxCoord vX
, wxCoord vY
)
POINTL vPoint;
COLORREF vColor = 0x00ffffff;
- if (m_pen.Ok())
+ if (m_pen.IsOk())
{
vColor = m_pen.GetColour().GetPixel();
}
CalcBoundingBox( vX
,vY
);
-} // end of wxDC::DoDrawPoint
+} // end of wxPMDCImpl::DoDrawPoint
-void wxDC::DoDrawPolygon(
- int n
-, wxPoint vPoints[]
-, wxCoord vXoffset
-, wxCoord vYoffset
-, int nFillStyle
-)
+void wxPMDCImpl::DoDrawPolygon( int n,
+ const wxPoint vPoints[],
+ wxCoord vXoffset,
+ wxCoord vYoffset,
+ wxPolygonFillMode nFillStyle )
{
- 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.
-//////////////////////////////////////////////////////////////////////////////
+ ULONG ulCount = 1; // Number of polygons.
+ POLYGON vPlgn; // polygon.
+ ULONG flOptions = 0L; // Drawing options.
- LONG lHits = 0L; // Correlation/error indicator.
- POINTL vPoint;
- int i;
- int nIsTRANSPARENT = 0;
- LONG lBorderColor = 0L;
- LONG lColor = 0L;
+ //////////////////////////////////////////////////////////////////////////////
+ // 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 = POLYGON_INCL; // 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.
+ int i;
+ int nIsTRANSPARENT = 0;
+ LONG lBorderColor = 0L;
+ LONG lColor = 0L;
lBorderColor = m_pen.GetColour().GetPixel();
lColor = m_brush.GetColour().GetPixel();
for(i = 0; i < n; i++)
{
- vPlgn.aPointl[i].x = vPoints[i].x; // +xoffset;
- vPlgn.aPointl[i].y = OS2Y(vPoints[i].y,0); // +yoffset;
+ vPlgn.aPointl[i].x = vPoints[i].x+vXoffset;
+ vPlgn.aPointl[i].y = OS2Y(vPoints[i].y+vYoffset,0);
}
- flModel = POLYGON_BOUNDARY;
+ flOptions = POLYGON_BOUNDARY;
if(nFillStyle == wxWINDING_RULE)
- flModel |= POLYGON_WINDING;
+ flOptions |= POLYGON_WINDING;
else
- flModel |= POLYGON_ALTERNATE;
-
- vPoint.x = vXoffset;
- vPoint.y = OS2Y(vYoffset,0);
+ flOptions |= POLYGON_ALTERNATE;
::GpiSetColor(m_hPS, lBorderColor);
- ::GpiMove(m_hPS, &vPoint);
+ ::GpiMove(m_hPS, &vPlgn.aPointl[0]);
lHits = ::GpiPolygons(m_hPS, ulCount, &vPlgn, flOptions, flModel);
free(vPlgn.aPointl);
-} // end of wxDC::DoDrawPolygon
+} // end of wxPMDCImpl::DoDrawPolygon
-void wxDC::DoDrawLines(
+void wxPMDCImpl::DoDrawLines(
int n
-, wxPoint vPoints[]
+, const wxPoint vPoints[]
, wxCoord vXoffset
, wxCoord vYoffset
)
{
POINTL vPoint;
- if (vXoffset != 0L || vXoffset != 0L)
+ if (vXoffset != 0L || vYoffset != 0L)
{
int i;
{
int i;
- CalcBoundingBox( vPoints[i].x
- ,vPoints[i].y
+ CalcBoundingBox( vPoints[0].x
+ ,vPoints[0].y
);
vPoint.x = vPoints[0].x;
vPoint.y = OS2Y(vPoints[0].y,0);
::GpiLine(m_hPS, &vPoint);
}
}
-} // end of wxDC::DoDrawLines
+} // end of wxPMDCImpl::DoDrawLines
-void wxDC::DoDrawRectangle(
+void wxPMDCImpl::DoDrawRectangle(
wxCoord vX
, wxCoord vY
, wxCoord vWidth
int nIsTRANSPARENT = 0;
//
- // Might be a memory DC with no Paint rect
+ // Might be a memory DC with no Paint rect.
//
if (!(m_vRclPaint.yTop == 0 &&
m_vRclPaint.yBottom == 0 &&
m_vRclPaint.xRight == 0 &&
m_vRclPaint.xLeft == 0))
vY = OS2Y(vY,vHeight);
+ else
+ {
+ if (m_vSelectedBitmap.IsOk())
+ {
+ m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
+ m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
+ vY = OS2Y(vY,vHeight);
+ }
+ }
wxCoord vX2 = vX + vWidth;
wxCoord vY2 = vY + vHeight;
if(m_brush.GetStyle() == wxTRANSPARENT)
lControl = DRO_OUTLINE;
- ::GpiSetColor(m_hPS, lColor);
+ ::GpiSetColor(m_hPS, lBorderColor);
::GpiBox( m_hPS // handle to a presentation space
,lControl // draw the box outline ? or ?
,&vPoint[1] // address of the corner
}
CalcBoundingBox(vX, vY);
CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoDrawRectangle
+} // end of wxPMDCImpl::DoDrawRectangle
-void wxDC::DoDrawRoundedRectangle(
+void wxPMDCImpl::DoDrawRoundedRectangle(
wxCoord vX
, wxCoord vY
, wxCoord vWidth
{
POINTL vPoint[2];
LONG lControl;
+ LONG lColor;
+ LONG lBorderColor;
+ int nIsTRANSPARENT = 0;
- vY = OS2Y(vY,vHeight);
+ //
+ // Might be a memory DC with no Paint rect.
+ //
+ if (!(m_vRclPaint.yTop == 0 &&
+ m_vRclPaint.yBottom == 0 &&
+ m_vRclPaint.xRight == 0 &&
+ m_vRclPaint.xLeft == 0))
+ vY = OS2Y(vY,vHeight);
+ else
+ {
+ if (m_vSelectedBitmap.IsOk())
+ {
+ m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
+ m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
+ vY = OS2Y(vY,vHeight);
+ }
+ }
wxCoord vX2 = (vX + vWidth);
wxCoord vY2 = (vY + vHeight);
vPoint[0].x = vX;
- vPoint[0].y = YLOG2DEV(vY) - vHeight;
- vPoint[1].x = vX + vWidth;
- vPoint[1].y = vY;
+ vPoint[0].y = vY;
+ vPoint[1].x = vX + vWidth - 1;
+ vPoint[1].y = vY + vHeight - 1;
::GpiMove(m_hPS, &vPoint[0]);
+ lColor = m_brush.GetColour().GetPixel();
+ lBorderColor = m_pen.GetColour().GetPixel();
lControl = DRO_OUTLINEFILL; //DRO_FILL;
if (m_brush.GetStyle() == wxTRANSPARENT)
+ nIsTRANSPARENT = 1;
+ if(lColor == lBorderColor || nIsTRANSPARENT)
+ {
+ lControl = DRO_OUTLINEFILL; //DRO_FILL;
+ if(m_brush.GetStyle() == wxTRANSPARENT)
+ lControl = DRO_OUTLINE;
+
+ ::GpiSetColor(m_hPS, lColor);
+ ::GpiBox( m_hPS // handle to a presentation space
+ ,lControl // draw the box outline ? or ?
+ ,&vPoint[1] // address of the corner
+ ,(LONG)dRadius // horizontal corner radius
+ ,(LONG)dRadius // vertical corner radius
+ );
+ }
+ else
+ {
lControl = DRO_OUTLINE;
- ::GpiBox( m_hPS // handle to a presentation space
- ,DRO_OUTLINE // draw the box outline ? or ?
- ,&vPoint[1] // address of the corner
- ,(LONG)dRadius // horizontal corner radius
- ,(LONG)dRadius // vertical corner radius
- );
+ ::GpiSetColor( m_hPS
+ ,lBorderColor
+ );
+ ::GpiBox( m_hPS
+ ,lControl
+ ,&vPoint[1]
+ ,(LONG)dRadius
+ ,(LONG)dRadius
+ );
+ lControl = DRO_FILL;
+ ::GpiSetColor( m_hPS
+ ,lColor
+ );
+ vPoint[0].x = vX + 1;
+ vPoint[0].y = vY + 1;
+ vPoint[1].x = vX + vWidth - 2;
+ vPoint[1].y = vY + vHeight - 2;
+ ::GpiMove(m_hPS, &vPoint[0]);
+ ::GpiBox( m_hPS
+ ,lControl
+ ,&vPoint[1]
+ ,(LONG)dRadius
+ ,(LONG)dRadius
+ );
+ }
+
CalcBoundingBox(vX, vY);
CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoDrawRoundedRectangle
+} // end of wxPMDCImpl::DoDrawRoundedRectangle
// Draw Ellipse within box (x,y) - (x+width, y+height)
-void wxDC::DoDrawEllipse(
+void wxPMDCImpl::DoDrawEllipse(
wxCoord vX
, wxCoord vY
, wxCoord vWidth
CalcBoundingBox(vX, vY);
CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoDrawEllipse
+} // end of wxPMDCImpl::DoDrawEllipse
-void wxDC::DoDrawEllipticArc(
+void wxPMDCImpl::DoDrawEllipticArc(
wxCoord vX
, wxCoord vY
, wxCoord vWidth
FIXED vFSweepa; // Start angle, sweep angle
double dIntPart;
double dFractPart;
- double dRadius;
vY = OS2Y(vY,vHeight);
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
+ vPtlPos.x = (wxCoord)(vX + vWidth/2 * (1. + cos(DegToRad(dSa)))); // Loads x-coordinate
+ vPtlPos.y = (wxCoord)(vY + vHeight/2 * (1. + sin(DegToRad(dSa)))); // Loads y-coordinate
::GpiMove(m_hPS, &vPtlPos); // Sets current position
//
CalcBoundingBox(vX, vY);
CalcBoundingBox(vX2, vY2);
-} // end of wxDC::DoDrawEllipticArc
+} // end of wxPMDCImpl::DoDrawEllipticArc
-void wxDC::DoDrawIcon(
+void wxPMDCImpl::DoDrawIcon(
const wxIcon& rIcon
, wxCoord vX
, wxCoord vY
//
// Need to copy back into a bitmap. ::WinDrawPointer uses device coords
// and I don't feel like figuring those out for scrollable windows so
- // just convert to a bitmap then let the DoDrawBitmap routing display it
+ // just convert to a bitmap then let the DoDrawBitmap routine display it
//
if (rIcon.IsXpm())
{
- DoDrawBitmap(rIcon.GetXpmSrc(), vX, vY, TRUE);
+ DoDrawBitmap(rIcon.GetXpmSrc(), vX, vY, true);
}
else
{
wxBitmap vBitmap(rIcon);
- DoDrawBitmap(vBitmap, vX, vY, FALSE);
+ DoDrawBitmap(vBitmap, vX, vY, false);
}
CalcBoundingBox(vX, vY);
CalcBoundingBox(vX + rIcon.GetWidth(), vY + rIcon.GetHeight());
-} // end of wxDC::DoDrawIcon
+} // end of wxPMDCImpl::DoDrawIcon
-void wxDC::DoDrawBitmap(
+void wxPMDCImpl::DoDrawBitmap(
const wxBitmap& rBmp
, wxCoord vX
, wxCoord vY
, bool bUseMask
)
{
+#if wxUSE_PRINTING_ARCHITECTURE
if (!IsKindOf(CLASSINFO(wxPrinterDC)))
+#endif
{
HBITMAP hBitmap = (HBITMAP)rBmp.GetHBITMAP();
- HBITMAP hBitmapOld;
+ HBITMAP hBitmapOld = NULLHANDLE;
+ POINTL vPoint[4];
vY = OS2Y(vY,rBmp.GetHeight());
- //
- // Flip the picture as OS/2 is upside-down
- //
- POINTL vPoint[4] = { vX, vY + rBmp.GetHeight()
- ,vX + rBmp.GetWidth(), vY
- ,0, 0
- ,rBmp.GetWidth(), rBmp.GetHeight()
- };
+ vPoint[0].x = vX;
+ vPoint[0].y = vY + rBmp.GetHeight();
+ vPoint[1].x = vX + rBmp.GetWidth();
+ vPoint[1].y = vY;
+ vPoint[2].x = 0;
+ vPoint[2].y = 0;
+ vPoint[3].x = rBmp.GetWidth();
+ vPoint[3].y = rBmp.GetHeight();
if (bUseMask)
{
wxMask* pMask = rBmp.GetMask();
// 5) Blit this to the screen PS
//
HBITMAP hMask = (HBITMAP)pMask->GetMaskBitmap();
+ HBITMAP hOldMask = NULLHANDLE;
HBITMAP hOldBitmap = NULLHANDLE;
HBITMAP hNewBitmap = NULLHANDLE;
unsigned char* pucBits; // buffer that will contain the bitmap data
memset(&vHeader, '\0', 16);
vHeader.cbFix = 16;
- vHeader.cx = (ULONG)rBmp.GetWidth();
- vHeader.cy = (ULONG)rBmp.GetHeight();
- vHeader.cPlanes = 1L;
- vHeader.cBitCount = 24;
memset(&vInfo, '\0', 16);
vInfo.cbFix = 16;
//
// Need to get a background color for mask blitting
//
- if (IsKindOf(CLASSINFO(wxPaintDC)))
+ if (IsKindOf(CLASSINFO(wxWindowDCImpl)))
{
- wxPaintDC* pPaintDC = wxDynamicCast(this, wxPaintDC);
+ wxWindowDCImpl* pWindowDC = wxDynamicCast(this, wxWindowDCImpl);
- lColor = pPaintDC->m_pCanvas->GetBackgroundColour().GetPixel();
+ lColor = pWindowDC->m_pCanvas->GetBackgroundColour().GetPixel();
}
- else if (GetBrush() != wxNullBrush)
+ else if (GetBrush().IsOk())
lColor = GetBrush().GetColour().GetPixel();
else
lColor = m_textBackgroundColour.GetPixel();
//
- // Bitmap must be ina double-word alligned address so we may
+ // Bitmap must be in a double-word aligned address so we may
// have some padding to worry about
//
if (nLineBoundary > 0)
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
+ ::GpiQueryBitmapInfoHeader(hBitmap, &vHeader);
+ vInfo.cBitCount = 24;
if ((lScans = ::GpiQueryBitmapBits( hPS
,0L
,(LONG)rBmp.GetHeight()
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
- if ((hOldBitmap = ::GpiSetBitmap(hPS, hMask)) == HBM_ERROR)
+ if ((hOldMask = ::GpiSetBitmap(hPS, hMask)) == HBM_ERROR)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
+ ::GpiQueryBitmapInfoHeader(hMask, &vHeader);
+ vInfo.cBitCount = 24;
if ((lScans = ::GpiQueryBitmapBits( hPS
,0L
,(LONG)rBmp.GetHeight()
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
+ if (( hMask = ::GpiSetBitmap(hPS, hOldMask)) == HBM_ERROR)
+ {
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ }
//
// Now set the bytes(bits) according to the mask values
pucData = pucBits;
pucDataMask = pucBitsMask;
+ //
+ // 16 bit kludge really only kinda works. The mask gets applied
+ // where needed but the original bitmap bits are dorked sometimes
+ //
+ bool bpp16 = (wxDisplayDepth() == 16);
+
for (i = 0; i < rBmp.GetHeight(); i++)
{
for (j = 0; j < rBmp.GetWidth(); j++)
{
// Byte 1
- if (*pucDataMask == 0xFF) // leave bitmap byte alone
+ if (bpp16 && *pucDataMask == 0xF8) // 16 bit display gobblygook
+ pucData++;
+ else if (*pucDataMask == 0xFF) // leave bitmap byte alone
pucData++;
else
{
pucData++;
}
// Byte 2
- if (*(pucDataMask + 1) == 0xFF) // leave bitmap byte alone
+ if (bpp16 && *(pucDataMask + 1) == 0xFC) // 16 bit display gobblygook
+ pucData++;
+ else if (*(pucDataMask + 1) == 0xFF) // leave bitmap byte alone
pucData++;
else
{
}
// Byte 3
- if (*(pucDataMask + 2) == 0xFF) // leave bitmap byte alone
+ if (bpp16 && *(pucDataMask + 2) == 0xF8) // 16 bit display gobblygook
+ pucData++;
+ else if (*(pucDataMask + 2) == 0xFF) // leave bitmap byte alone
pucData++;
else
{
//
// Create a new bitmap
//
+ vHeader.cx = (ULONG)rBmp.GetWidth();
+ vHeader.cy = (ULONG)rBmp.GetHeight();
+ vHeader.cPlanes = 1L;
+ vHeader.cBitCount = 24;
if ((hNewBitmap = ::GpiCreateBitmap( hPS
,&vHeader
,CBM_INIT
free(pucBits);
free(pucBitsMask);
::GpiSetBitmap(hPS, NULLHANDLE);
+ ::GpiDeleteBitmap(hNewBitmap);
::GpiDestroyPS(hPS);
::DevCloseDC(hDC);
}
}
else
{
- LONG lOldForeGround = ::GpiQueryColor((HPS)GetHPS());
- LONG lOldBackGround = ::GpiQueryBackColor((HPS)GetHPS());
+ ULONG lOldForeGround = ::GpiQueryColor((HPS)GetHPS());
+ ULONG lOldBackGround = ::GpiQueryBackColor((HPS)GetHPS());
- if (m_textForegroundColour.Ok())
+ if (m_textForegroundColour.IsOk())
{
::GpiSetColor( (HPS)GetHPS()
,m_textForegroundColour.GetPixel()
);
}
- if (m_textBackgroundColour.Ok())
+ if (m_textBackgroundColour.IsOk())
{
::GpiSetBackColor( (HPS)GetHPS()
,m_textBackgroundColour.GetPixel()
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
+ delete [] pucBits;
return;
}
if ((lScans = ::GpiQueryBitmapBits( hPS
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
+ delete [] pucBits;
return;
}
unsigned char cOldRedFore = (unsigned char)(lOldForeGround >> 16);
unsigned char cOldGreenFore = (unsigned char)(lOldForeGround >> 8);
unsigned char cOldBlueFore = (unsigned char)lOldForeGround;
- unsigned char cOldRedBack = (unsigned char)(lOldBackGround >> 16);
- unsigned char cOldGreenBack = (unsigned char)(lOldBackGround >> 8);
- unsigned char cOldBlueBack = (unsigned char)lOldBackGround;
-
unsigned char cRedFore = (unsigned char)(lForeGround >> 16);
unsigned char cGreenFore = (unsigned char)(lForeGround >> 8);
unsigned char cBlueFore = (unsigned char)lForeGround;
(cBmpGreen == cOldGreenFore) &&
(cBmpBlue == cOldBlueFore))
{
- *pucData = cRedFore;
+ *pucData = cBlueFore;
pucData++;
*pucData = cGreenFore;
pucData++;
- *pucData = cBlueFore;
+ *pucData = cRedFore;
pucData++;
}
else
{
- *pucData = cRedBack;
+ *pucData = cBlueBack;
pucData++;
*pucData = cGreenBack;
pucData++;
- *pucData = cBlueBack;
+ *pucData = cRedBack;
pucData++;
}
}
::GpiSetBackColor((HPS)GetHPS(), lOldBackGround);
}
}
-} // end of wxDC::DoDrawBitmap
+} // end of wxPMDCImpl::DoDrawBitmap
-void wxDC::DoDrawText(
+void wxPMDCImpl::DoDrawText(
const wxString& rsText
, wxCoord vX
, wxCoord vY
);
CalcBoundingBox(vX, vY);
- GetTextExtent(rsText, &vWidth, &vHeight);
+ GetOwner()->GetTextExtent(rsText, &vWidth, &vHeight);
CalcBoundingBox((vX + vWidth), (vY + vHeight));
-} // end of wxDC::DoDrawText
+} // end of wxPMDCImpl::DoDrawText
-void wxDC::DrawAnyText(
- const wxString& rsText
-, wxCoord vX
-, wxCoord vY
-)
+void wxPMDCImpl::DrawAnyText( const wxString& rsText,
+ wxCoord vX,
+ wxCoord vY )
{
int nOldBackground = 0;
POINTL vPtlStart;
//
// Set text color attributes
//
- if (m_textForegroundColour.Ok())
+ if (m_textForegroundColour.IsOk())
{
SetTextColor( m_hPS
,(int)m_textForegroundColour.GetPixel()
);
}
- if (m_textBackgroundColour.Ok())
+ if (m_textBackgroundColour.IsOk())
{
nOldBackground = SetTextBkColor( m_hPS
,(int)m_textBackgroundColour.GetPixel()
SetBkMode( m_hPS
,m_backgroundMode
);
- GetTextExtent( rsText
- ,&vTextX
- ,&vTextY
- );
+ GetOwner()->GetTextExtent( rsText
+ ,&vTextX
+ ,&vTextY
+ );
vPtlStart.x = vX;
- vPtlStart.y = OS2Y(vY,vTextY);
+ if (!(m_vRclPaint.yTop == 0 &&
+ m_vRclPaint.yBottom == 0 &&
+ m_vRclPaint.xRight == 0 &&
+ m_vRclPaint.xLeft == 0))
+ {
+ vPtlStart.y = OS2Y(vY,vTextY);
+ }
+ else
+ {
+ if (m_vSelectedBitmap.IsOk())
+ {
+ m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
+ m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
+ vPtlStart.y = OS2Y(vY,vTextY);
+ }
+ else
+ vPtlStart.y = vY;
+ }
- lHits = ::GpiCharStringAt( m_hPS
- ,&vPtlStart
- ,rsText.length()
- ,(PCH)rsText.c_str()
- );
+ ::GpiMove(m_hPS, &vPtlStart);
+ lHits = ::GpiCharString( m_hPS
+ ,rsText.length()
+ ,rsText.char_str()
+ );
if (lHits != GPI_OK)
{
wxLogLastError(wxT("TextOut"));
// it never is set to anything else, but background should remain
// transparent even if we just drew an opaque string)
//
- if (m_textBackgroundColour.Ok())
+ if (m_textBackgroundColour.IsOk())
SetTextBkColor( m_hPS
,nOldBackground
);
);
}
-void wxDC::DoDrawRotatedText(
+void wxPMDCImpl::DoDrawRotatedText(
const wxString& rsText
, wxCoord vX
, wxCoord vY
// set GDI objects
// ---------------------------------------------------------------------------
-void wxDC::DoSelectPalette(
- bool bRealize
-)
+void wxPMDCImpl::DoSelectPalette( bool WXUNUSED(bRealize) )
{
//
// Set the old object temporarily, in case the assignment deletes an object
m_hOldPalette = 0;
}
- if (m_palette.Ok())
+ if (m_palette.IsOk())
{
HPALETTE hOldPal;
if (!m_hOldPalette)
m_hOldPalette = (WXHPALETTE)hOldPal;
}
-} // end of wxDC::DoSelectPalette
+} // end of wxPMDCImpl::DoSelectPalette
-void wxDC::InitializePalette()
+void wxPMDCImpl::InitializePalette()
{
if (wxDisplayDepth() <= 8 )
{
DoSelectPalette();
}
}
-} // end of wxDC::InitializePalette
+} // end of wxPMDCImpl::InitializePalette
-void wxDC::SetPalette(
+void wxPMDCImpl::SetPalette(
const wxPalette& rPalette
)
{
m_hOldFont = 0;
}
m_palette = rPalette;
- if (!rPalette.Ok())
+ if (!rPalette.IsOk())
{
if (m_hOldFont)
{
HPALETTE hOldPal = ::GpiSelectPalette((HDC) m_hPS, (HPALETTE) m_palette.GetHPALETTE());
if (!m_hOldPalette)
m_hOldPalette = (WXHPALETTE)hOldPal;
-} // end of wxDC::SetPalette
+} // end of wxPMDCImpl::SetPalette
-void wxDC::SetFont(
+void wxPMDCImpl::SetFont(
const wxFont& rFont
)
{
m_hOldFont = 0;
}
m_font = rFont;
- if (!rFont.Ok())
+ if (!rFont.IsOk())
{
m_hOldFont = 0;
}
m_font.SetPS(m_hPS); // this will realize the font
- if (m_font.Ok())
+ if (m_font.IsOk())
{
HFONT hFont = m_font.GetResourceHandle();
if (hFont == (HFONT) NULL)
{
- wxLogDebug(wxT("::SelectObject failed in wxDC::SetFont."));
+ wxLogDebug(wxT("::SelectObject failed in wxPMDCImpl::SetFont."));
}
if (!m_hOldFont)
m_hOldFont = (WXHFONT) hFont;
}
-} // end of wxDC::SetFont
+} // end of wxPMDCImpl::SetFont
-void wxDC::SetPen(
+void wxPMDCImpl::SetPen(
const wxPen& rPen
)
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
-
if (m_pen == rPen)
return;
m_pen = rPen;
- if (!m_pen.Ok())
+ if (!m_pen.IsOk())
return;
if (m_hOldPen)
m_hOldPen = 0L;
m_pen = rPen;
- if (!m_pen.Ok())
+ if (!m_pen.IsOk())
{
if (m_hOldPen)
{
m_hOldPen = 0L;
}
- if (m_pen.Ok())
+ if (m_pen.IsOk())
{
if (m_pen.GetResourceHandle())
{
if (!m_hOldPen)
m_hOldPen = m_pen.GetPS();
}
+ ::GpiSetColor(m_hPS, m_pen.GetColour().GetPixel());
}
}
-void wxDC::SetBrush(
+void wxPMDCImpl::SetBrush(
const wxBrush& rBrush
)
{
- wxCHECK_RET( Ok(), wxT("invalid window dc") );
-
if (m_hOldBrush)
m_hOldBrush = 0L;
m_brush = rBrush;
- if (!m_brush.Ok())
+ if (!m_brush.IsOk())
if (m_brush == rBrush)
return;
- if (!m_brush.Ok())
+ if (!m_brush.IsOk())
if (m_hOldBrush)
m_hOldBrush = 0L;
- if (!m_brush.Ok())
+ if (!m_brush.IsOk())
{
if (m_hOldBrush)
{
m_hOldBrush = 0L;
}
- if (m_brush.Ok())
+ if (m_brush.IsOk())
{
if (m_brush.GetResourceHandle())
{
m_hOldBrush = (WXHWND)m_brush.GetPS();
}
}
-} // end of wxDC::SetBrush
+} // end of wxPMDCImpl::SetBrush
-void wxDC::SetBackground(
- const wxBrush& rBrush
-)
+void wxPMDCImpl::SetBackground(const wxBrush& rBrush)
{
m_backgroundBrush = rBrush;
- if (!m_backgroundBrush.Ok())
- return;
- if (m_pCanvas)
- {
- bool bCustomColours = TRUE;
- //
- // If we haven't specified wxUSER_COLOURS, don't allow the panel/dialog box to
- // change background colours from the control-panel specified colours.
- //
- if (m_pCanvas->IsKindOf(CLASSINFO(wxWindow)) &&
- ((m_pCanvas->GetWindowStyleFlag() & wxUSER_COLOURS) != wxUSER_COLOURS))
- bCustomColours = FALSE;
- if (bCustomColours)
- {
- if (m_backgroundBrush.GetStyle()==wxTRANSPARENT)
- {
- m_pCanvas->SetTransparent(TRUE);
- }
- else
- {
- //
- // Setting the background brush of a DC
- // doesn't affect the window background colour. However,
- // I'm leaving in the transparency setting because it's needed by
- // various controls (e.g. wxStaticText) to determine whether to draw
- // transparently or not. TODO: maybe this should be a new function
- // wxWindow::SetTransparency(). Should that apply to the child itself, or the
- // parent?
- // m_canvas->SetBackgroundColour(m_backgroundBrush.GetColour());
- //
- m_pCanvas->SetTransparent(FALSE);
- }
- }
+ if (m_backgroundBrush.IsOk())
+ {
+ (void)::GpiSetBackColor((HPS)m_hPS, m_backgroundBrush.GetColour().GetPixel());
}
- COLORREF vNewColor = m_backgroundBrush.GetColour().GetPixel();
- (void)::GpiSetBackColor((HPS)m_hPS, (LONG)vNewColor);
-} // end of wxDC::SetBackground
+} // end of wxPMDCImpl::SetBackground
-void wxDC::SetBackgroundMode(
- int nMode
-)
+void wxPMDCImpl::SetBackgroundMode(int nMode)
{
m_backgroundMode = nMode;
-} // end of wxDC::SetBackgroundMode
+} // end of wxPMDCImpl::SetBackgroundMode
-void wxDC::SetLogicalFunction(
- int nFunction
-)
+void wxPMDCImpl::SetLogicalFunction(wxRasterOperationMode nFunction)
{
m_logicalFunction = nFunction;
SetRop((WXHDC)m_hDC);
-} // wxDC::SetLogicalFunction
+} // wxPMDCImpl::SetLogicalFunction
-void wxDC::SetRop(
- WXHDC hDC
-)
+void wxPMDCImpl::SetRop(WXHDC hDC)
{
if (!hDC || m_logicalFunction < 0)
return;
- LONG lCRop;
+ LONG lCRop;
switch (m_logicalFunction)
{
case wxXOR:
break;
}
::GpiSetMix((HPS)hDC, lCRop);
-} // end of wxDC::SetRop
+} // end of wxPMDCImpl::SetRop
-bool wxDC::StartDoc(
- const wxString& rsMessage
-)
+bool wxPMDCImpl::StartDoc( const wxString& WXUNUSED(rsMessage) )
{
- // We might be previewing, so return TRUE to let it continue.
- return TRUE;
-} // end of wxDC::StartDoc
+ // We might be previewing, so return true to let it continue.
+ return true;
+} // end of wxPMDCImpl::StartDoc
-void wxDC::EndDoc()
+void wxPMDCImpl::EndDoc()
{
-} // end of wxDC::EndDoc
+} // end of wxPMDCImpl::EndDoc
-void wxDC::StartPage()
+void wxPMDCImpl::StartPage()
{
-} // end of wxDC::StartPage
+} // end of wxPMDCImpl::StartPage
-void wxDC::EndPage()
+void wxPMDCImpl::EndPage()
{
-} // end of wxDC::EndPage
+} // end of wxPMDCImpl::EndPage
// ---------------------------------------------------------------------------
// text metrics
// ---------------------------------------------------------------------------
-wxCoord wxDC::GetCharHeight() const
+wxCoord wxPMDCImpl::GetCharHeight() const
{
FONTMETRICS vFM; // metrics structure
return YDEV2LOGREL(vFM.lXHeight);
}
-wxCoord wxDC::GetCharWidth() const
+wxCoord wxPMDCImpl::GetCharWidth() const
{
FONTMETRICS vFM; // metrics structure
return XDEV2LOGREL(vFM.lAveCharWidth);
}
-void wxDC::DoGetTextExtent(
+void wxPMDCImpl::DoGetTextExtent(
const wxString& rsString
, wxCoord* pvX
, wxCoord* pvY
, wxCoord* pvDescent
, wxCoord* pvExternalLeading
-, wxFont* pTheFont
+, const wxFont* pTheFont
) const
{
POINTL avPoint[TXTBOX_COUNT];
int l;
FONTMETRICS vFM; // metrics structure
BOOL bRc;
- char* pStr;
ERRORID vErrorCode; // last error id code
wxFont* pFontToUse = (wxFont*)pTheFont;
- char zMsg[128]; // DEBUG
+ wxChar zMsg[128]; // DEBUG
wxString sError;
if (!pFontToUse)
pFontToUse = (wxFont*)&m_font;
l = rsString.length();
- pStr = (PCH) rsString.c_str();
//
// In world coordinates.
//
+ if (!m_hPS)
+ {
+ (void)wxMessageBox( wxT("wxWidgets core library")
+ ,"Using uninitialized DC for measuring text!\n"
+ ,wxICON_INFORMATION
+ );
+ }
+
bRc = ::GpiQueryTextBox( m_hPS
,l
- ,pStr
+ ,rsString.char_str()
,TXTBOX_COUNT // return maximum information
,avPoint // array of coordinates points
);
vErrorCode = ::WinGetLastError(wxGetInstance());
sError = wxPMErrorToStr(vErrorCode);
// DEBUG
- sprintf(zMsg, "GpiQueryTextBox for %s: failed with Error: %x - %s", pStr, vErrorCode, sError.c_str());
- (void)wxMessageBox( "wxWindows Menu sample"
+ wxSprintf(zMsg, wxT("GpiQueryTextBox for %s: failed with Error: %lx - %s"), rsString.c_str(), vErrorCode, sError.c_str());
+ (void)wxMessageBox( wxT("wxWidgets core library")
,zMsg
,wxICON_INFORMATION
);
*pvExternalLeading = vFM.lExternalLeading;
}
-void wxDC::SetMapMode(
- int nMode
+void wxPMDCImpl::SetMapMode(
+ wxMappingMode nMode
)
{
int nPixelWidth = 0;
int nPixelHeight = 0;
int nMmWidth = 1;
int nMmHeight = 1;
- LONG lArray[CAPS_VERTICAL_RESOLUTION];
+ LONG lArray[CAPS_VERTICAL_RESOLUTION+1];
m_mappingMode = nMode;
if(::DevQueryCaps( m_hDC
- ,CAPS_FAMILY
- ,CAPS_VERTICAL_RESOLUTION
+ ,CAPS_FAMILY // id of first item
+ ,CAPS_VERTICAL_RESOLUTION+1 // number of items wanted
,lArray
))
{
lHorzRes = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
lVertRes = lArray[CAPS_VERTICAL_RESOLUTION]; // returns pel/meter
nMmWidth = (lHorzRes/1000) * nPixelWidth;
- nMmWidth = (lVertRes/1000) * nPixelHeight;
+ nMmHeight = (lVertRes/1000) * nPixelHeight;
}
if ((nPixelWidth == 0) || (nPixelHeight == 0) || (nMmWidth == 0) || (nMmHeight == 0))
{
return;
}
- double dMm2pixelsX = nPixelWidth/nMmWidth;
- double dMm2pixelsY = nPixelHeight/nMmHeight;
+ double dMm2pixelsX = nPixelWidth/(double)nMmWidth;
+ double dMm2pixelsY = nPixelHeight/(double)nMmHeight;
switch (nMode)
{
m_logicalScaleY = 1.0;
break;
}
+
SIZEL vSize;
ULONG ulOptions;
ulOptions = PU_ARBITRARY | GPIF_DEFAULT;
::GpiSetPS(m_hPS, &vSize, ulOptions);
}
- m_nWindowExtX = (int)MS_XDEV2LOG(VIEWPORT_EXTENT);
- m_nWindowExtY = (int)MS_YDEV2LOG(VIEWPORT_EXTENT);
- // ????
-}; // end of wxDC::SetMapMode
+ ComputeScaleAndOrigin();
-void wxDC::SetUserScale(
- double dX
-, double dY
-)
+}; // end of wxPMDCImpl::SetMapMode
+
+void wxPMDCImpl::SetUserScale( double dX,
+ double dY )
{
m_userScaleX = dX;
m_userScaleY = dY;
SetMapMode(m_mappingMode);
-} // end of wxDC::SetUserScale
+} // end of wxPMDCImpl::SetUserScale
-void wxDC::SetAxisOrientation(
- bool bXLeftRight
-, bool bYBottomUp
-)
+void wxPMDCImpl::SetAxisOrientation( bool bXLeftRight,
+ bool bYBottomUp )
{
m_signX = bXLeftRight ? 1 : -1;
m_signY = bYBottomUp ? -1 : 1;
SetMapMode(m_mappingMode);
-} // end of wxDC::SetAxisOrientation
-
-void wxDC::SetSystemScale(
- double dX
-, double dY
-)
-{
- m_scaleX = dX;
- m_scaleY = dY;
-
- SetMapMode(m_mappingMode);
-} // end of wxDC::SetSystemScale
+} // end of wxPMDCImpl::SetAxisOrientation
-void wxDC::SetLogicalOrigin(
+void wxPMDCImpl::SetLogicalOrigin(
wxCoord vX
, wxCoord vY
)
::GpiSetPageViewport( m_hPS
,&vRect
);
-}; // end of wxDC::SetLogicalOrigin
+}; // end of wxPMDCImpl::SetLogicalOrigin
-void wxDC::SetDeviceOrigin(
+void wxPMDCImpl::SetDeviceOrigin(
wxCoord vX
, wxCoord vY
)
::GpiSetPageViewport( m_hPS
,&vRect
);
-}; // end of wxDC::SetDeviceOrigin
-
-// ---------------------------------------------------------------------------
-// coordinates transformations
-// ---------------------------------------------------------------------------
-
-wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
-{
- return (wxCoord) (((x) - m_deviceOriginX)/(m_logicalScaleX*m_userScaleX*m_signX*m_scaleX) - m_logicalOriginX);
-}
-
-wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
-{
- // axis orientation is not taken into account for conversion of a distance
- return (wxCoord) ((x)/(m_logicalScaleX*m_userScaleX*m_scaleX));
-}
-
-wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
-{
- return (wxCoord) (((y) - m_deviceOriginY)/(m_logicalScaleY*m_userScaleY*m_signY*m_scaleY) - m_logicalOriginY);
-}
-
-wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
-{
- // axis orientation is not taken into account for conversion of a distance
- return (wxCoord) ((y)/(m_logicalScaleY*m_userScaleY*m_scaleY));
-}
-
-wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
-{
- return (wxCoord) ((x - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_scaleX + m_deviceOriginX);
-}
-
-wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
-{
- // axis orientation is not taken into account for conversion of a distance
- return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_scaleX);
-}
-
-wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
-{
- return (wxCoord) ((y - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_scaleY + m_deviceOriginY);
-}
-
-wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
-{
- // axis orientation is not taken into account for conversion of a distance
- return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_scaleY);
-}
+}; // end of wxPMDCImpl::SetDeviceOrigin
// ---------------------------------------------------------------------------
// bit blit
// ---------------------------------------------------------------------------
-bool wxDC::DoBlit(
- wxCoord vXdest
-, wxCoord vYdest
-, wxCoord vWidth
-, wxCoord vHeight
-, wxDC* pSource
-, wxCoord vXsrc
-, wxCoord vYsrc
-, int nRop
-, bool bUseMask
-, wxCoord vXsrcMask
-, wxCoord vYsrcMask
-)
+bool wxPMDCImpl::DoBlit( wxCoord vXdest,
+ wxCoord vYdest,
+ wxCoord vWidth,
+ wxCoord vHeight,
+ wxDC* pSource,
+ wxCoord vXsrc,
+ wxCoord vYsrc,
+ wxRasterOperationMode nRop,
+ bool bUseMask,
+ wxCoord WXUNUSED(vXsrcMask),
+ wxCoord WXUNUSED(vYsrcMask) )
{
wxMask* pMask = NULL;
CHARBUNDLE vCbnd;
COLORREF vOldTextColor;
COLORREF vOldBackground = ::GpiQueryBackColor(m_hPS);
+ wxDCImpl *impl = pSource->GetImpl();
+ wxPMDCImpl *pm_impl = wxDynamicCast( impl, wxPMDCImpl );
+ if (!pm_impl)
+ {
+ // TODO: Do we want to be able to blit
+ // from other DCs too?
+ return false;
+ }
+
if (bUseMask)
{
- const wxBitmap& rBmp = pSource->m_vSelectedBitmap;
+ const wxBitmap& rBmp = pm_impl->GetSelectedBitmap();
pMask = rBmp.GetMask();
- if (!(rBmp.Ok() && pMask && pMask->GetMaskBitmap()))
+ if (!(rBmp.IsOk() && pMask && pMask->GetMaskBitmap()))
{
- bUseMask = FALSE;
+ bUseMask = false;
}
}
);
vOldTextColor = (COLORREF)vCbnd.lColor;
- if (m_textForegroundColour.Ok())
+ if (m_textForegroundColour.IsOk())
{
vCbnd.lColor = (LONG)m_textForegroundColour.GetPixel();
::GpiSetAttrs( m_hPS // presentation-space handle
,&vCbnd // buffer for attributes.
);
}
- if (m_textBackgroundColour.Ok())
+ if (m_textBackgroundColour.IsOk())
{
::GpiSetBackColor(m_hPS, (LONG)m_textBackgroundColour.GetPixel());
}
case wxNOR: lRop = ROP_NOTSRCCOPY; break;
default:
wxFAIL_MSG( wxT("unsupported logical function") );
- return FALSE;
+ return false;
}
bool bSuccess;
vBmpHdr.cBitCount = 24;
#if wxUSE_DC_CACHEING
- if (TRUE)
{
//
// create a temp buffer bitmap and DCs to access it and the mask
//
wxDCCacheEntry* pDCCacheEntry1 = FindDCInCache( NULL
- ,pSource->GetHPS()
+ ,pm_impl->GetHPS()
);
wxDCCacheEntry* pDCCacheEntry2 = FindDCInCache( pDCCacheEntry1
,GetHPS()
hPSMask = pDCCacheEntry1->m_hPS;
hDCBuffer = (HDC)pDCCacheEntry2->m_hPS;
hBufBitmap = (HBITMAP)pBitmapCacheEntry->m_hBitmap;
+ wxUnusedVar(hDCMask);
}
- else
-#endif
+#else
{
hDCMask = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
hDCBuffer = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
hPSBuffer = ::GpiCreatePS(vHabmain, hDCBuffer, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
hBufBitmap = ::GpiCreateBitmap(GetHPS(), &vBmpHdr, 0L, NULL, NULL);
}
+#endif
- POINTL aPoint1[4] = { 0, 0
- ,vWidth, vHeight
- ,vXdest, vYdest
- ,vXdest + vWidth, vYdest + vHeight
+ POINTL aPoint1[4] = { {0, 0}
+ ,{vWidth, vHeight}
+ ,{vXdest, vYdest}
+ ,{vXdest + vWidth, vYdest + vHeight}
};
- POINTL aPoint2[4] = { 0, 0
- ,vWidth, vHeight
- ,vXsrc, vYsrc
- ,vXsrc + vWidth, vYsrc + vHeight
+ POINTL aPoint2[4] = { {0, 0}
+ ,{vWidth, vHeight}
+ ,{vXsrc, vYsrc}
+ ,{vXsrc + vWidth, vYsrc + vHeight}
};
- POINTL aPoint3[4] = { vXdest, vYdest
- ,vXdest + vWidth, vYdest + vHeight
- ,vXsrc, vYsrc
- ,vXsrc + vWidth, vYsrc + vHeight
+ POINTL aPoint3[4] = { {vXdest, vYdest}
+ ,{vXdest + vWidth, vYdest + vHeight}
+ ,{vXsrc, vYsrc}
+ ,{vXsrc + vWidth, vYsrc + vHeight}
};
- POINTL aPoint4[4] = { vXdest, vYdest
- ,vXdest + vWidth, vYdest + vHeight
- ,0, 0
- ,vWidth, vHeight
+ POINTL aPoint4[4] = { {vXdest, vYdest}
+ ,{vXdest + vWidth, vYdest + vHeight}
+ ,{0, 0}
+ ,{vWidth, vHeight}
};
::GpiSetBitmap(hPSMask, (HBITMAP) pMask->GetMaskBitmap());
::GpiSetBitmap(hPSBuffer, (HBITMAP) hBufBitmap);
);
if (rc == GPI_ERROR)
{
- bSuccess = FALSE;
+ bSuccess = false;
wxLogLastError(wxT("BitBlt"));
}
::DevCloseDC(hDCBuffer);
::GpiDeleteBitmap(hBufBitmap);
#endif
- bSuccess = TRUE;
+ bSuccess = true;
}
else // no mask, just BitBlt() it
{
- POINTL aPoint[4] = { vXdest, vYdest
- ,vXdest + vWidth, vYdest + vHeight
- ,vXsrc, vYsrc
- ,vXsrc + vWidth, vYsrc + vHeight
+ POINTL aPoint[4] = { {vXdest, vYdest}
+ ,{vXdest + vWidth, vYdest + vHeight}
+ ,{vXsrc, vYsrc}
+ ,{vXsrc + vWidth, vYsrc + vHeight}
};
bSuccess = (::GpiBitBlt( m_hPS
- ,pSource->GetHPS()
+ ,pm_impl->GetHPS()
,4L
,aPoint
,lRop
return bSuccess;
}
-void wxDC::DoGetSize(
- int* pnWidth
-, int* pnHeight
-) const
+void wxPMDCImpl::DoGetSize( int* pnWidth,
+ int* pnHeight ) const
{
- LONG lArray[CAPS_HEIGHT];
+ LONG lArray[CAPS_HEIGHT+1];
if(::DevQueryCaps( m_hDC
,CAPS_FAMILY
- ,CAPS_HEIGHT
+ ,CAPS_HEIGHT+1
,lArray
))
{
- *pnWidth = lArray[CAPS_WIDTH];
- *pnHeight = lArray[CAPS_HEIGHT];
+ if (pnWidth)
+ *pnWidth = lArray[CAPS_WIDTH];
+ if (pnHeight)
+ *pnHeight = lArray[CAPS_HEIGHT];
}
-}; // end of wxDC::DoGetSize(
+}; // end of wxPMDCImpl::DoGetSize(
-void wxDC::DoGetSizeMM(
- int* pnWidth
-, int* pnHeight
-) const
+void wxPMDCImpl::DoGetSizeMM( int* pnWidth,
+ int* pnHeight ) const
{
- LONG lArray[CAPS_VERTICAL_RESOLUTION];
+ LONG lArray[CAPS_VERTICAL_RESOLUTION+1];
if(::DevQueryCaps( m_hDC
,CAPS_FAMILY
- ,CAPS_VERTICAL_RESOLUTION
+ ,CAPS_VERTICAL_RESOLUTION+1
,lArray
))
{
- int nWidth;
- int nHeight;
- int nHorzRes;
- int nVertRes;
+ if(pnWidth)
+ {
+ int nWidth = lArray[CAPS_WIDTH];
+ int nHorzRes = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
+ // use fp to avoid returning 0 if nHorzRes < 1000
+ *pnWidth = (int)((nHorzRes/1000.0) * nWidth);
+ }
- nWidth = lArray[CAPS_WIDTH];
- nHeight = lArray[CAPS_HEIGHT];
- nHorzRes = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
- nVertRes = lArray[CAPS_VERTICAL_RESOLUTION]; // returns pel/meter
- nWidth = (nHorzRes/1000) * nWidth;
- nHeight = (nVertRes/1000) * nHeight;
+ if(pnHeight)
+ {
+ int nHeight = lArray[CAPS_HEIGHT];
+ int nVertRes = lArray[CAPS_VERTICAL_RESOLUTION]; // returns pel/meter
+ // use fp to avoid returning 0 if nVertRes < 1000
+ *pnHeight = (int)((nVertRes/1000.0) * nHeight);
+ }
}
-}; // end of wxDC::DoGetSizeMM
+}; // end of wxPMDCImpl::DoGetSizeMM
-wxSize wxDC::GetPPI() const
+wxSize wxPMDCImpl::GetPPI() const
{
- LONG lArray[CAPS_VERTICAL_RESOLUTION];
- int nWidth;
- int nHeight;
+ LONG lArray[CAPS_VERTICAL_RESOLUTION+1];
+ int nWidth = 0;
+ int nHeight = 0;
if(::DevQueryCaps( m_hDC
,CAPS_FAMILY
- ,CAPS_VERTICAL_RESOLUTION
+ ,CAPS_VERTICAL_RESOLUTION+1
,lArray
))
{
nPelHeight = lArray[CAPS_HEIGHT];
nHorzRes = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
nVertRes = lArray[CAPS_VERTICAL_RESOLUTION]; // returns pel/meter
- nWidth = (nHorzRes/39.3) * nPelWidth;
- nHeight = (nVertRes/39.3) * nPelHeight;
+ nWidth = (int)((nHorzRes/39.3) * nPelWidth);
+ nHeight = (int)((nVertRes/39.3) * nPelHeight);
}
- return (wxSize(nWidth,nHeight));
-} // end of wxDC::GetPPI
+ wxSize ppisize(nWidth, nHeight);
+ return ppisize;
+} // end of wxPMDCImpl::GetPPI
-void wxDC::SetLogicalScale(
- double dX
-, double dY
-)
+void wxPMDCImpl::SetLogicalScale( double dX, double dY )
{
m_logicalScaleX = dX;
m_logicalScaleY = dY;
-}; // end of wxDC::SetLogicalScale
-
-#if WXWIN_COMPATIBILITY
-void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
- float *descent, float *externalLeading,
- wxFont *theFont, bool use16bit) const
-{
- wxCoord x1, y1, descent1, externalLeading1;
- GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
- *x = x1; *y = y1;
- if (descent)
- *descent = descent1;
- if (externalLeading)
- *externalLeading = externalLeading1;
-}
-#endif
-
+}; // end of wxPMDCImpl::SetLogicalScale
projects / wxWidgets.git / blobdiff