/////////////////////////////////////////////////////////////////////////////
-// Name: dc.cpp
+// Name: src/os2/dc.cpp
// Purpose: wxDC class
// Author: David Webster
// Modified by:
#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/private.h"
- IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
+IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
//
-// 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
// ---------------------------------------------------------------------------
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
void wxDC::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);
+ m_svDCCache.DeleteContents(false);
} // end of wxDC::ClearCache
// Clean up cache at app exit
class wxDCModule : public wxModule
{
public:
- virtual bool OnInit() { return TRUE; }
+ virtual bool OnInit() { return true; }
virtual void OnExit() { wxDC::ClearCache(); }
private:
wxDC::wxDC(void)
{
- wxColour vColor;
-
m_pCanvas = NULL;
m_hOldBitmap = 0;
m_hOldFont = 0;
m_hOldPalette = 0;
- m_bOwnsDC = FALSE;
+ m_bOwnsDC = false;
m_hDC = 0;
m_hOldPS = NULL;
m_hPS = NULL;
- m_bIsPaintTime = FALSE; // True at Paint Time
+ m_bIsPaintTime = false; // True at Paint Time
+
+ m_pen.SetColour(*wxBLACK);
+ m_brush.SetColour(*wxWHITE);
- vColor.InitFromName("BLACK");
- m_pen.SetColour(vColor);
- vColor.Set("WHITE");
- m_brush.SetColour(vColor);
} // end of wxDC::wxDC
wxDC::~wxDC(void)
RECTL vRect;
vY = OS2Y(vY,vHeight);
- m_clipping = TRUE;
+ m_clipping = true;
vRect.xLeft = vX;
vRect.yTop = vY + vHeight;
vRect.xRight = vX + vWidth;
wxCHECK_RET(rRegion.GetHRGN(), wxT("invalid clipping region"));
HRGN hRgnOld;
- m_clipping = TRUE;
+ m_clipping = true;
::GpiSetClipRegion( m_hPS
,(HRGN)rRegion.GetHRGN()
,&hRgnOld
::GpiSetClipRegion(m_hPS, hRgn, &hRgnOld);
}
- m_clipping = FALSE;
+ ResetClipping();
} // end of wxDC::DestroyClippingRegion
// ---------------------------------------------------------------------------
bool wxDC::CanDrawBitmap() const
{
- return TRUE;
+ return true;
}
bool wxDC::CanGetTextExtent() const
int wxDC::GetDepth() const
{
LONG lArray[CAPS_COLOR_BITCOUNT];
- int nBitsPerPixel;
+ int nBitsPerPixel = 0;
if(::DevQueryCaps( GetHDC()
,CAPS_FAMILY
::GpiErase(m_hPS);
} // end of wxDC::Clear
-void wxDC::DoFloodFill(
+bool wxDC::DoFloodFill(
wxCoord vX
, wxCoord vY
, const wxColour& rCol
POINTL vPtlPos;
LONG lColor;
LONG lOptions;
+ LONG lHits;
+ bool bSuccess = false;
vPtlPos.x = vX; // Loads x-coordinate
vPtlPos.y = OS2Y(vY,0); // Loads y-coordinate
if(wxFLOOD_SURFACE == nStyle)
lOptions = FF_SURFACE;
- ::GpiFloodFill(m_hPS, lOptions, lColor);
+ if ((lHits = ::GpiFloodFill(m_hPS, lOptions, lColor)) != GPI_ERROR)
+ bSuccess = true;
+
+ return bSuccess;
} // end of wxDC::DoFloodFill
bool wxDC::DoGetPixel(
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);
+ return true;
} // end of wxDC::DoGetPixel
void wxDC::DoCrossHair(
)
{
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.Ok())
+ {
+ 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.Ok())
+ {
+ vColor = m_pen.GetColour().GetPixel();
+ }
+ ::GpiSetColor(m_hPS, vColor);
::GpiMove(m_hPS, &vPoint[0]);
::GpiLine(m_hPS, &vPoint[1]);
CalcBoundingBox(vX1, vY1);
{
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 wxDC::DoDrawPoint
-void wxDC::DoDrawPolygon(
- int n
-, wxPoint vPoints[]
-, wxCoord vXoffset
-, wxCoord vYoffset
-, int nFillStyle
-)
+void wxDC::DoDrawPolygon( int n,
+ wxPoint vPoints[],
+ wxCoord vXoffset,
+ wxCoord vYoffset,
+ int nFillStyle )
{
- ULONG ulCount = 1; // Number of polygons.
- POLYGON vPlgn; // polygon.
- ULONG flOptions = 0L; // Drawing options.
+ 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;
+ //////////////////////////////////////////////////////////////////////////////
+ // 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
{
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);
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.Ok())
+ {
+ 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 = vY;
- vPoint[1].x = vX + vWidth;
- vPoint[1].y = vY + vHeight;
+ 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();
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
);
vPoint[0].x = vX + 1;
vPoint[0].y = vY + 1;
- vPoint[1].x = vX + vWidth - 1;
- vPoint[1].y = vY + vHeight - 1;
+ vPoint[1].x = vX + vWidth - 2;
+ vPoint[1].y = vY + vHeight - 2;
::GpiMove(m_hPS, &vPoint[0]);
::GpiBox( m_hPS
,lControl
{
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.Ok())
+ {
+ 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
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
//
, wxCoord vY
)
{
- vY = OS2Y(vY,rIcon.GetHeight());
- wxCHECK_RET( rIcon.Ok(), wxT("invalid icon in DrawIcon") );
+ //
+ // 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 routine display it
+ //
+ if (rIcon.IsXpm())
+ {
+ DoDrawBitmap(rIcon.GetXpmSrc(), vX, vY, true);
+ }
+ else
+ {
+ wxBitmap vBitmap(rIcon);
- ::WinDrawPointer( GetHPS()
- ,vX
- ,vY
- ,(HPOINTER)GetHiconOf(rIcon)
- ,DP_NORMAL
- );
+ DoDrawBitmap(vBitmap, vX, vY, false);
+ }
CalcBoundingBox(vX, vY);
CalcBoundingBox(vX + rIcon.GetWidth(), vY + rIcon.GetHeight());
} // end of wxDC::DoDrawIcon
, bool bUseMask
)
{
- POINTL vPoint = {vX, vY};
+#if wxUSE_PRINTING_ARCHITECTURE
+ if (!IsKindOf(CLASSINFO(wxPrinterDC)))
+#endif
+ {
+ HBITMAP hBitmap = (HBITMAP)rBmp.GetHBITMAP();
+ HBITMAP hBitmapOld = NULLHANDLE;
+ POINTL vPoint[4];
+
+ vY = OS2Y(vY,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();
- ::WinDrawBitmap( GetHPS()
- ,(HBITMAP)GetHbitmapOf(rBmp)
- ,NULL
- ,&vPoint
- ,0L
- ,0L
- ,DBM_NORMAL
- );
+ if (pMask)
+ {
+ //
+ // Need to imitate ::MaskBlt in windows.
+ // 1) Extract the bits from from the bitmap.
+ // 2) Extract the bits from the mask
+ // 3) Using the mask bits do the following:
+ // A) If the mask byte is 00 leave the bitmap byte alone
+ // B) If the mask byte is FF copy the screen color into
+ // bitmap byte
+ // 4) Create a new bitmap and set its bits to the above result
+ // 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
+ unsigned char* pucBitsMask; // buffer that will contain the mask data
+ unsigned char* pucData; // pointer to use to traverse bitmap data
+ unsigned char* pucDataMask; // pointer to use to traverse mask data
+ LONG lHits;
+ ERRORID vError;
+ wxString sError;
+
+ //
+ // The usual Memory context creation stuff
+ //
+ DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+ SIZEL vSize = {0, 0};
+ HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
+
+ //
+ // The usual bitmap header stuff
+ //
+ BITMAPINFOHEADER2 vHeader;
+ BITMAPINFO2 vInfo;
+
+ memset(&vHeader, '\0', 16);
+ vHeader.cbFix = 16;
+
+ memset(&vInfo, '\0', 16);
+ vInfo.cbFix = 16;
+ vInfo.cx = (ULONG)rBmp.GetWidth();
+ vInfo.cy = (ULONG)rBmp.GetHeight();
+ vInfo.cPlanes = 1;
+ vInfo.cBitCount = 24; // Set to desired count going in
+
+ //
+ // Create the buffers for data....all wxBitmaps are 24 bit internally
+ //
+ int nBytesPerLine = rBmp.GetWidth() * 3;
+ int nSizeDWORD = sizeof(DWORD);
+ int nLineBoundary = nBytesPerLine % nSizeDWORD;
+ int nPadding = 0;
+ int i;
+ int j;
+ LONG lScans = 0L;
+ LONG lColor = 0L;
+
+ //
+ // Need to get a background color for mask blitting
+ //
+ if (IsKindOf(CLASSINFO(wxWindowDC)))
+ {
+ wxWindowDC* pWindowDC = wxDynamicCast(this, wxWindowDC);
+
+ lColor = pWindowDC->m_pCanvas->GetBackgroundColour().GetPixel();
+ }
+ else if (GetBrush().Ok())
+ lColor = GetBrush().GetColour().GetPixel();
+ else
+ lColor = m_textBackgroundColour.GetPixel();
+
+ //
+ // Bitmap must be in a double-word aligned address so we may
+ // have some padding to worry about
+ //
+ if (nLineBoundary > 0)
+ {
+ nPadding = nSizeDWORD - nLineBoundary;
+ nBytesPerLine += nPadding;
+ }
+ pucBits = (unsigned char *)malloc(nBytesPerLine * rBmp.GetHeight());
+ pucBitsMask = (unsigned char *)malloc(nBytesPerLine * rBmp.GetHeight());
+ memset(pucBits, '\0', (nBytesPerLine * rBmp.GetHeight()));
+ memset(pucBitsMask, '\0', (nBytesPerLine * rBmp.GetHeight()));
+
+ //
+ // Extract the bitmap and mask data
+ //
+ if ((hOldBitmap = ::GpiSetBitmap(hPS, hBitmap)) == HBM_ERROR)
+ {
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ }
+ ::GpiQueryBitmapInfoHeader(hBitmap, &vHeader);
+ vInfo.cBitCount = 24;
+ if ((lScans = ::GpiQueryBitmapBits( hPS
+ ,0L
+ ,(LONG)rBmp.GetHeight()
+ ,(PBYTE)pucBits
+ ,&vInfo
+ )) == GPI_ALTERROR)
+ {
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ }
+ 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()
+ ,(PBYTE)pucBitsMask
+ ,&vInfo
+ )) == GPI_ALTERROR)
+ {
+ 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
+ // 3 bytes per pel...must handle one at a time
+ //
+ 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 (bpp16 && *pucDataMask == 0xF8) // 16 bit display gobblygook
+ pucData++;
+ else if (*pucDataMask == 0xFF) // leave bitmap byte alone
+ pucData++;
+ else
+ {
+ *pucData = ((unsigned char)(lColor >> 16));
+ pucData++;
+ }
+ // Byte 2
+ if (bpp16 && *(pucDataMask + 1) == 0xFC) // 16 bit display gobblygook
+ pucData++;
+ else if (*(pucDataMask + 1) == 0xFF) // leave bitmap byte alone
+ pucData++;
+ else
+ {
+ *pucData = ((unsigned char)(lColor >> 8));
+ pucData++;
+ }
+
+ // Byte 3
+ if (bpp16 && *(pucDataMask + 2) == 0xF8) // 16 bit display gobblygook
+ pucData++;
+ else if (*(pucDataMask + 2) == 0xFF) // leave bitmap byte alone
+ pucData++;
+ else
+ {
+ *pucData = ((unsigned char)lColor);
+ pucData++;
+ }
+ pucDataMask += 3;
+ }
+ for (j = 0; j < nPadding; j++)
+ {
+ pucData++;
+ pucDataMask++;
+ }
+ }
+ //
+ // 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
+ ,(PBYTE)pucBits
+ ,&vInfo
+ )) == GPI_ERROR)
+ {
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ }
+
+ //
+ // Now blit it to the screen PS
+ //
+ if ((lHits = ::GpiWCBitBlt( (HPS)GetHPS()
+ ,hNewBitmap
+ ,4
+ ,vPoint
+ ,ROP_SRCCOPY
+ ,BBO_IGNORE
+ )) == GPI_ERROR)
+ {
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ }
+
+ //
+ // Clean up
+ //
+ free(pucBits);
+ free(pucBitsMask);
+ ::GpiSetBitmap(hPS, NULLHANDLE);
+ ::GpiDeleteBitmap(hNewBitmap);
+ ::GpiDestroyPS(hPS);
+ ::DevCloseDC(hDC);
+ }
+ }
+ else
+ {
+ ULONG lOldForeGround = ::GpiQueryColor((HPS)GetHPS());
+ ULONG lOldBackGround = ::GpiQueryBackColor((HPS)GetHPS());
+
+ if (m_textForegroundColour.Ok())
+ {
+ ::GpiSetColor( (HPS)GetHPS()
+ ,m_textForegroundColour.GetPixel()
+ );
+ }
+ if (m_textBackgroundColour.Ok())
+ {
+ ::GpiSetBackColor( (HPS)GetHPS()
+ ,m_textBackgroundColour.GetPixel()
+ );
+ }
+ //
+ // Need to alter bits in a mono bitmap to match the new
+ // background-foreground if it is different.
+ //
+ if (rBmp.IsMono() &&
+ ((m_textForegroundColour.GetPixel() != lOldForeGround) ||
+ (m_textBackgroundColour.GetPixel() != lOldBackGround)))
+ {
+ DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+ SIZEL vSize = {0, 0};
+ HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
+
+ int nBytesPerLine = rBmp.GetWidth() * 3;
+ int i, j;
+ LONG lForeGround = m_textForegroundColour.GetPixel();
+ LONG lBackGround = m_textBackgroundColour.GetPixel();
+ LONG lScans;
+ HBITMAP hOldBitmap = NULLHANDLE;
+ BITMAPINFO2 vInfo;
+ ERRORID vError;
+ wxString sError;
+
+
+ memset(&vInfo, '\0', 16);
+ vInfo.cbFix = 16;
+ vInfo.cx = (ULONG)rBmp.GetWidth();
+ vInfo.cy = (ULONG)rBmp.GetHeight();
+ vInfo.cPlanes = 1;
+ vInfo.cBitCount = 24;
+
+ unsigned char* pucBits; // buffer that will contain the bitmap data
+ unsigned char* pucData; // pointer to use to traverse bitmap data
+
+ pucBits = new unsigned char[nBytesPerLine * rBmp.GetHeight()];
+ memset(pucBits, '\0', (nBytesPerLine * rBmp.GetHeight()));
+
+ if ((hOldBitmap = ::GpiSetBitmap(hPS, hBitmap)) == HBM_ERROR)
+ {
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ return;
+ }
+ if ((lScans = ::GpiQueryBitmapBits( hPS
+ ,0L
+ ,(LONG)rBmp.GetHeight()
+ ,(PBYTE)pucBits
+ ,&vInfo
+ )) == GPI_ALTERROR)
+ {
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ return;
+ }
+ unsigned char cOldRedFore = (unsigned char)(lOldForeGround >> 16);
+ unsigned char cOldGreenFore = (unsigned char)(lOldForeGround >> 8);
+ unsigned char cOldBlueFore = (unsigned char)lOldForeGround;
+
+ unsigned char cRedFore = (unsigned char)(lForeGround >> 16);
+ unsigned char cGreenFore = (unsigned char)(lForeGround >> 8);
+ unsigned char cBlueFore = (unsigned char)lForeGround;
+
+ unsigned char cRedBack = (unsigned char)(lBackGround >> 16);
+ unsigned char cGreenBack = (unsigned char)(lBackGround >> 8);
+ unsigned char cBlueBack = (unsigned char)lBackGround;
+
+ pucData = pucBits;
+ for (i = 0; i < rBmp.GetHeight(); i++)
+ {
+ for (j = 0; j < rBmp.GetWidth(); j++)
+ {
+ unsigned char cBmpRed = *pucData;
+ unsigned char cBmpGreen = *(pucData + 1);
+ unsigned char cBmpBlue = *(pucData + 2);
+
+ if ((cBmpRed == cOldRedFore) &&
+ (cBmpGreen == cOldGreenFore) &&
+ (cBmpBlue == cOldBlueFore))
+ {
+ *pucData = cBlueFore;
+ pucData++;
+ *pucData = cGreenFore;
+ pucData++;
+ *pucData = cRedFore;
+ pucData++;
+ }
+ else
+ {
+ *pucData = cBlueBack;
+ pucData++;
+ *pucData = cGreenBack;
+ pucData++;
+ *pucData = cRedBack;
+ pucData++;
+ }
+ }
+ }
+ if ((lScans = ::GpiSetBitmapBits( hPS
+ ,0L
+ ,(LONG)rBmp.GetHeight()
+ ,(PBYTE)pucBits
+ ,&vInfo
+ )) == GPI_ALTERROR)
+ {
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ return;
+ }
+ delete [] pucBits;
+ ::GpiSetBitmap(hPS, NULLHANDLE);
+ ::GpiDestroyPS(hPS);
+ ::DevCloseDC(hDC);
+ }
+ ::GpiWCBitBlt( (HPS)GetHPS()
+ ,hBitmap
+ ,4
+ ,vPoint
+ ,ROP_SRCCOPY
+ ,BBO_IGNORE
+ );
+ ::GpiSetBitmap((HPS)GetHPS(), hBitmapOld);
+ ::GpiSetColor((HPS)GetHPS(), lOldForeGround);
+ ::GpiSetBackColor((HPS)GetHPS(), lOldBackGround);
+ }
+ }
} // end of wxDC::DoDrawBitmap
void wxDC::DoDrawText(
CalcBoundingBox((vX + vWidth), (vY + vHeight));
} // end of wxDC::DoDrawText
-void wxDC::DrawAnyText(
- const wxString& rsText
-, wxCoord vX
-, wxCoord vY
-)
+void wxDC::DrawAnyText( const wxString& rsText,
+ wxCoord vX,
+ wxCoord vY )
{
int nOldBackground = 0;
POINTL vPtlStart;
,&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.Ok())
+ {
+ m_vRclPaint.yTop = m_vSelectedBitmap.GetHeight();
+ m_vRclPaint.xRight = m_vSelectedBitmap.GetWidth();
+ vPtlStart.y = OS2Y(vY,vTextY);
+ }
+ else
+ vPtlStart.y = vY;
+ }
+
+ PCH pzStr = (PCH)rsText.c_str();
- lHits = ::GpiCharStringAt( m_hPS
- ,&vPtlStart
- ,rsText.length()
- ,(PCH)rsText.c_str()
- );
+ ::GpiMove(m_hPS, &vPtlStart);
+ lHits = ::GpiCharString( m_hPS
+ ,rsText.length()
+ ,pzStr
+ );
if (lHits != GPI_OK)
{
wxLogLastError(wxT("TextOut"));
// set GDI objects
// ---------------------------------------------------------------------------
+void wxDC::DoSelectPalette( bool WXUNUSED(bRealize) )
+{
+ //
+ // Set the old object temporarily, in case the assignment deletes an object
+ // that's not yet selected out.
+ //
+ if (m_hOldPalette)
+ {
+ m_hOldPalette = 0;
+ }
+
+ if (m_palette.Ok())
+ {
+ HPALETTE hOldPal;
+
+ hOldPal = ::GpiSelectPalette((HDC) m_hPS, (HPALETTE) m_palette.GetHPALETTE());
+ if (!m_hOldPalette)
+ m_hOldPalette = (WXHPALETTE)hOldPal;
+ }
+} // end of wxDC::DoSelectPalette
+
+void wxDC::InitializePalette()
+{
+ if (wxDisplayDepth() <= 8 )
+ {
+ //
+ // Look for any window or parent that has a custom palette. If any has
+ // one then we need to use it in drawing operations
+ //
+ wxWindow* pWin = m_pCanvas->GetAncestorWithCustomPalette();
+
+ m_hasCustomPalette = pWin && pWin->HasCustomPalette();
+ if (m_hasCustomPalette)
+ {
+ m_palette = pWin->GetPalette();
+
+ //
+ // turn on PM translation for this palette
+ //
+ DoSelectPalette();
+ }
+ }
+} // end of wxDC::InitializePalette
+
void wxDC::SetPalette(
const wxPalette& rPalette
)
if (!m_hOldPen)
m_hOldPen = m_pen.GetPS();
}
+ ::GpiSetColor(m_hPS, m_pen.GetColour().GetPixel());
}
}
}
} // end of wxDC::SetBrush
-void wxDC::SetBackground(
- const wxBrush& rBrush
-)
+void wxDC::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.Ok())
+ {
+ (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
-void wxDC::SetBackgroundMode(
- int nMode
-)
+void wxDC::SetBackgroundMode(int nMode)
{
m_backgroundMode = nMode;
} // end of wxDC::SetBackgroundMode
-void wxDC::SetLogicalFunction(
- int nFunction
-)
+void wxDC::SetLogicalFunction(int nFunction)
{
m_logicalFunction = nFunction;
SetRop((WXHDC)m_hDC);
} // wxDC::SetLogicalFunction
-void wxDC::SetRop(
- WXHDC hDC
-)
+void wxDC::SetRop(WXHDC hDC)
{
if (!hDC || m_logicalFunction < 0)
return;
- LONG lCRop;
+ LONG lCRop;
switch (m_logicalFunction)
{
case wxXOR:
::GpiSetMix((HPS)hDC, lCRop);
} // end of wxDC::SetRop
-bool wxDC::StartDoc(
- const wxString& rsMessage
-)
+bool wxDC::StartDoc( const wxString& WXUNUSED(rsMessage) )
{
- // We might be previewing, so return TRUE to let it continue.
- return TRUE;
+ // We might be previewing, so return true to let it continue.
+ return true;
} // end of wxDC::StartDoc
void wxDC::EndDoc()
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.
//
bRc = ::GpiQueryTextBox( m_hPS
,l
- ,pStr
+ ,(PCH)rsString.c_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, _T("GpiQueryTextBox for %s: failed with Error: %lx - %s"), rsString.c_str(), vErrorCode, sError.c_str());
+ (void)wxMessageBox( _T("wxWidgets Menu sample")
,zMsg
,wxICON_INFORMATION
);
// ????
}; // end of wxDC::SetMapMode
-void wxDC::SetUserScale(
- double dX
-, double dY
-)
+void wxDC::SetUserScale( double dX,
+ double dY )
{
m_userScaleX = dX;
m_userScaleY = dY;
SetMapMode(m_mappingMode);
} // end of wxDC::SetUserScale
-void wxDC::SetAxisOrientation(
- bool bXLeftRight
-, bool bYBottomUp
-)
+void wxDC::SetAxisOrientation( bool bXLeftRight,
+ bool bYBottomUp )
{
m_signX = bXLeftRight ? 1 : -1;
m_signY = bYBottomUp ? -1 : 1;
wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
{
- // axis orientation is not taken into account for conversion of a distance
+ // axis orientation is not taken into account for conversion of a distance
return (wxCoord) ((x)/(m_logicalScaleX*m_userScaleX*m_scaleX));
}
wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
{
- // axis orientation is not taken into account for conversion of a distance
+ // axis orientation is not taken into account for conversion of a distance
return (wxCoord) ((y)/(m_logicalScaleY*m_userScaleY*m_scaleY));
}
wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
{
- // axis orientation is not taken into account for conversion of a distance
+ // axis orientation is not taken into account for conversion of a distance
return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_scaleX);
}
wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
{
- // axis orientation is not taken into account for conversion of a distance
+ // axis orientation is not taken into account for conversion of a distance
return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_scaleY);
}
// 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 wxDC::DoBlit( wxCoord vXdest,
+ wxCoord vYdest,
+ wxCoord vWidth,
+ wxCoord vHeight,
+ wxDC* pSource,
+ wxCoord vXsrc,
+ wxCoord vYsrc,
+ int nRop,
+ bool bUseMask,
+ wxCoord WXUNUSED(vXsrcMask),
+ wxCoord WXUNUSED(vYsrcMask) )
{
wxMask* pMask = NULL;
CHARBUNDLE vCbnd;
pMask = rBmp.GetMask();
if (!(rBmp.Ok() && pMask && pMask->GetMaskBitmap()))
{
- bUseMask = FALSE;
+ bUseMask = false;
}
}
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
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
return bSuccess;
}
-void wxDC::DoGetSize(
- int* pnWidth
-, int* pnHeight
-) const
+void wxDC::DoGetSize( int* pnWidth,
+ int* pnHeight ) const
{
- LONG lArray[CAPS_HEIGHT];
+ LONG lArray[CAPS_HEIGHT];
if(::DevQueryCaps( m_hDC
,CAPS_FAMILY
}
}; // end of wxDC::DoGetSize(
-void wxDC::DoGetSizeMM(
- int* pnWidth
-, int* pnHeight
-) const
+void wxDC::DoGetSizeMM( int* pnWidth,
+ int* pnHeight ) const
{
LONG lArray[CAPS_VERTICAL_RESOLUTION];
,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
+ *pnWidth = (nHorzRes/1000) * 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
+ *pnHeight = (nVertRes/1000) * nHeight;
+ }
}
}; // end of wxDC::DoGetSizeMM
wxSize wxDC::GetPPI() const
{
LONG lArray[CAPS_VERTICAL_RESOLUTION];
- int nWidth;
- int nHeight;
+ int nWidth = 0;
+ int nHeight = 0;
if(::DevQueryCaps( m_hDC
,CAPS_FAMILY
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));
+ wxSize ppisize(nWidth, nHeight);
+ return ppisize;
} // end of wxDC::GetPPI
-void wxDC::SetLogicalScale(
- double dX
-, double dY
-)
+void wxDC::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
-
projects / wxWidgets.git / blobdiff