#include <string.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)
//
// wxWidgets uses the Microsoft convention that the origin is the UPPER left.
// 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
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.Clear();
m_svDCCache.DeleteContents(true);
m_svDCCache.Clear();
m_svDCCache.DeleteContents(false);
-} // end of wxDC::ClearCache
+} // 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 void OnExit() { wxPMDCImpl::ClearCache(); }
private:
DECLARE_DYNAMIC_CLASS(wxDCModule)
// wxDC
// ---------------------------------------------------------------------------
-wxDC::wxDC(void)
+wxPMDCImpl::wxPMDCImpl( wxDC *owner, WXHDC hDC ) :
+ wxDCImpl( owner )
{
- m_pCanvas = NULL;
+ Init();
+ m_hDC = hDC;
+} // end of wxPMDCImpl::wxPMDCImpl
- m_hOldBitmap = 0;
- m_hOldPen = 0;
- m_hOldBrush = 0;
- m_hOldFont = 0;
- m_hOldPalette = 0;
-
- m_bOwnsDC = false;
- m_hDC = 0;
- m_hOldPS = NULL;
- m_hPS = NULL;
- m_bIsPaintTime = false; // True at Paint Time
-
- m_pen.SetColour(*wxBLACK);
- m_brush.SetColour(*wxWHITE);
-
-} // end of wxDC::wxDC
-
-wxDC::~wxDC(void)
+wxPMDCImpl::~wxPMDCImpl(void)
{
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
)
{
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
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
)
{
,&hRgnOld
);
DO_SET_CLIPPING_BOX()
-} // end of wxDC::DoSetClippingRegionAsRegion
+} // end of wxPMDCImpl::DoSetDeviceClippingRegion
-void wxDC::DestroyClippingRegion(void)
+void wxPMDCImpl::DestroyClippingRegion(void)
{
if (m_clipping && m_hPS)
{
::GpiSetClipRegion(m_hPS, hRgn, &hRgnOld);
}
ResetClipping();
-} // end of wxDC::DestroyClippingRegion
+} // end of wxPMDCImpl::DestroyClippingRegion
// ---------------------------------------------------------------------------
// query capabilities
// ---------------------------------------------------------------------------
-bool wxDC::CanDrawBitmap() const
+bool wxPMDCImpl::CanDrawBitmap() const
{
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];
+ 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;
bSuccess = true;
return bSuccess;
-} // end of wxDC::DoFloodFill
+} // end of wxPMDCImpl::DoFloodFill
-bool wxDC::DoGetPixel(
+bool wxPMDCImpl::DoGetPixel(
wxCoord vX
, wxCoord vY
, wxColour* pCol
,GetBValue(lColor)
);
return true;
-} // end of wxDC::DoGetPixel
+} // 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
::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
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
)
CalcBoundingBox( vX
,vY
);
-} // end of wxDC::DoDrawPoint
+} // end of wxPMDCImpl::DoDrawPoint
-void wxDC::DoDrawPolygon( int n,
+void wxPMDCImpl::DoDrawPolygon( int n,
wxPoint vPoints[],
wxCoord vXoffset,
wxCoord vYoffset,
- int nFillStyle )
+ wxPolygonFillMode nFillStyle )
{
ULONG ulCount = 1; // Number of polygons.
POLYGON vPlgn; // polygon.
::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[]
, wxCoord vXoffset
::GpiLine(m_hPS, &vPoint);
}
}
-} // end of wxDC::DoDrawLines
+} // end of wxPMDCImpl::DoDrawLines
-void wxDC::DoDrawRectangle(
+void wxPMDCImpl::DoDrawRectangle(
wxCoord vX
, wxCoord vY
, wxCoord vWidth
}
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
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
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
}
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
//
// Need to get a background color for mask blitting
//
- if (IsKindOf(CLASSINFO(wxWindowDC)))
+ if (IsKindOf(CLASSINFO(wxWindowDCImpl)))
{
- wxWindowDC* pWindowDC = wxDynamicCast(this, wxWindowDC);
+ wxWindowDCImpl* pWindowDC = wxDynamicCast(this, wxWindowDCImpl);
lColor = pWindowDC->m_pCanvas->GetBackgroundColour().GetPixel();
}
::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,
+void wxPMDCImpl::DrawAnyText( const wxString& rsText,
wxCoord vX,
wxCoord vY )
{
SetBkMode( m_hPS
,m_backgroundMode
);
- GetTextExtent( rsText
- ,&vTextX
- ,&vTextY
- );
+ GetOwner()->GetTextExtent( rsText
+ ,&vTextX
+ ,&vTextY
+ );
vPtlStart.x = vX;
if (!(m_vRclPaint.yTop == 0 &&
m_vRclPaint.yBottom == 0 &&
::GpiMove(m_hPS, &vPtlStart);
lHits = ::GpiCharString( m_hPS
,rsText.length()
- ,rsText.wx_str()
+ ,rsText.char_str()
);
if (lHits != GPI_OK)
{
);
}
-void wxDC::DoDrawRotatedText(
+void wxPMDCImpl::DoDrawRotatedText(
const wxString& rsText
, wxCoord vX
, wxCoord vY
// set GDI objects
// ---------------------------------------------------------------------------
-void wxDC::DoSelectPalette( bool WXUNUSED(bRealize) )
+void wxPMDCImpl::DoSelectPalette( bool WXUNUSED(bRealize) )
{
//
// Set the old object temporarily, in case the assignment deletes an object
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
)
{
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
)
{
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;
}
}
-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;
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;
{
(void)::GpiSetBackColor((HPS)m_hPS, m_backgroundBrush.GetColour().GetPixel());
}
-} // 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;
break;
}
::GpiSetMix((HPS)hDC, lCRop);
-} // end of wxDC::SetRop
+} // end of wxPMDCImpl::SetRop
-bool wxDC::StartDoc( const wxString& WXUNUSED(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
+} // 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];
//
// 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
- ,(char *)rsString.wx_str()
+ ,rsString.char_str()
,TXTBOX_COUNT // return maximum information
,avPoint // array of coordinates points
);
vErrorCode = ::WinGetLastError(wxGetInstance());
sError = wxPMErrorToStr(vErrorCode);
// DEBUG
- wxSprintf(zMsg, _T("GpiQueryTextBox for %s: failed with Error: %lx - %s"), rsString.c_str(), vErrorCode, sError.c_str());
- (void)wxMessageBox( _T("wxWidgets 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,
+}; // 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,
+void wxPMDCImpl::SetAxisOrientation( bool bXLeftRight,
bool bYBottomUp )
{
m_signX = bXLeftRight ? 1 : -1;
m_signY = bYBottomUp ? -1 : 1;
SetMapMode(m_mappingMode);
-} // end of wxDC::SetAxisOrientation
+} // end of wxPMDCImpl::SetAxisOrientation
-void wxDC::SetSystemScale(
- double dX
-, double dY
-)
-{
- m_scaleX = dX;
- m_scaleY = dY;
-
- SetMapMode(m_mappingMode);
-} // end of wxDC::SetSystemScale
-
-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,
+bool wxPMDCImpl::DoBlit( wxCoord vXdest,
wxCoord vYdest,
wxCoord vWidth,
wxCoord vHeight,
wxDC* pSource,
wxCoord vXsrc,
wxCoord vYsrc,
- int nRop,
+ wxRasterOperationMode nRop,
bool bUseMask,
wxCoord WXUNUSED(vXsrcMask),
wxCoord WXUNUSED(vYsrcMask) )
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()))
// 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()
};
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,
+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
))
{
if(pnWidth)
{
- int nWidth = lArray[CAPS_WIDTH];
- int nHorzRes = lArray[CAPS_HORIZONTAL_RESOLUTION]; // returns pel/meter
- *pnWidth = (nHorzRes/1000) * nWidth;
+ 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);
}
if(pnHeight)
{
- int nHeight = lArray[CAPS_HEIGHT];
+ int nHeight = lArray[CAPS_HEIGHT];
int nVertRes = lArray[CAPS_VERTICAL_RESOLUTION]; // returns pel/meter
- *pnHeight = (nVertRes/1000) * nHeight;
+ // 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];
+ 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
))
{
}
wxSize ppisize(nWidth, nHeight);
return ppisize;
-} // end of wxDC::GetPPI
+} // 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
+}; // end of wxPMDCImpl::SetLogicalScale
projects / wxWidgets.git / blobdiff