/////////////////////////////////////////////////////////////////////////////
-// Name: dc.cpp
+// Name: src/mgl/dc.cpp
// Purpose: wxDC class
// Author: Vaclav Slavik
// Created: 2001/03/09
// RCS-ID: $Id$
-// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
+// Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// headers
// ---------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "dc.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifndef WX_PRECOMP
#include "wx/dc.h"
#include "wx/dcmemory.h"
+ #include "wx/log.h"
#endif
#include "wx/fontutil.h"
+#include "wx/encinfo.h"
#include "wx/fontmap.h"
#include "wx/mgl/private.h"
-#include "wx/log.h"
#include <string.h>
-#include <math.h>
#include <mgraph.hpp>
// constants
//-----------------------------------------------------------------------------
-const double mm2inches = 0.0393700787402;
-const double inches2mm = 25.4;
-const double mm2twips = 56.6929133859;
-const double twips2mm = 0.0176388888889;
-const double mm2pt = 2.83464566929;
-const double pt2mm = 0.352777777778;
const double RAD2DEG = 180.0 / M_PI;
const ushort STIPPLE_wxDOT = 0x5555/* - - - - - - - -*/;
const ushort STIPPLE_wxLONG_DASH = 0xF0F0/* ---- ----*/;
const ushort STIPPLE_wxSHORT_DASH = 0xCCCC/*-- -- -- -- */;
-const ushort STIPPLE_wxDOT_DASH = 0x3939/* --- - --- -*/;
-const ushort STIPPLE_wxSOLID = 0xFFFF/*----------------*/;
+const ushort STIPPLE_wxDOT_DASH = 0x3939/* --- - --- -*/;
+const ushort STIPPLE_wxSOLID = 0xFFFF/*----------------*/;
#define PATTERN_ROW(b7,b6,b5,b4,b3,b2,b1,b0) \
((b7 << 7) | (b6 << 6) | (b5 << 5) | (b4 << 4) | \
// Default constructor
wxDC::wxDC()
{
- m_isMemDC = FALSE;
+ m_isMemDC = false;
m_MGLDC = NULL;
- m_OwnsMGLDC = FALSE;
- m_ok = FALSE; // must call SetMGLDevCtx() before using it
+ m_OwnsMGLDC = false;
+ m_ok = false; // must call SetMGLDevCtx() before using it
-#if 0
m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
(double)wxGetDisplaySizeMM().GetWidth();
m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
(double)wxGetDisplaySizeMM().GetHeight();
-#endif
- // FIXME_MGL -- not in wxUniversal branch (and not implementend anyway,
- // hardcode it for 75dpi for now)
- m_mm_to_pix_x = ((double)wxGetDisplaySize().GetWidth() / 75) * inches2mm;
- m_mm_to_pix_y = ((double)wxGetDisplaySize().GetHeight() / 75) * inches2mm;
m_pen = *wxBLACK_PEN;
m_font = *wxNORMAL_FONT;
m_brush = *wxWHITE_BRUSH;
m_penOfsX = m_penOfsY = 0;
- m_penSelected = m_brushSelected = FALSE;
- m_downloadedPatterns[0] = m_downloadedPatterns[1] = FALSE;
-
+ m_penSelected = m_brushSelected = false;
+ m_downloadedPatterns[0] = m_downloadedPatterns[1] = false;
+
m_mglFont = NULL;
}
wxDC::~wxDC()
{
- if (m_OwnsMGLDC)
+ if (m_OwnsMGLDC)
delete m_MGLDC;
}
delete m_MGLDC;
m_MGLDC = mgldc;
m_OwnsMGLDC = OwnsMGLDC;
- m_ok = TRUE;
+ m_ok = true;
+
+ if ( !m_globalClippingRegion.IsNull() )
+ SetClippingRegion(m_globalClippingRegion);
+
InitializeMGLDC();
}
m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());
- m_clipping = TRUE;
+ m_clipping = true;
DO_SET_CLIPPING_BOX(m_currentClippingRegion)
}
{
wxCHECK_RET( Ok(), wxT("invalid dc") );
- if ( region.Empty() )
+ if ( region.IsEmpty() )
{
DestroyClippingRegion();
return;
}
-
+
wxRegion rg(region);
-
+
// check if the DC is scaled or moved, and if yes, then
// convert rg to device coordinates:
if ( m_deviceOriginX != 0 || m_deviceOriginY != 0 ||
+ m_logicalOriginX != 0 || m_logicalOriginY != 0 ||
XLOG2DEVREL(500) != 500 || YLOG2DEVREL(500) != 500 )
{
region_t *mrg = rg.GetMGLRegion().rgnPointer();
- span_t *s;
- segment_t *p;
- for (s = mrg->spans; s; s = s->next)
+ span_t *s;
+ segment_t *p;
+ for (s = mrg->spans; s; s = s->next)
{
- s->y = YLOG2DEV(s->y);
- for (p = s->seg; p; p = p->next)
- p->x = XLOG2DEV(p->x);
+ s->y = YLOG2DEV(s->y);
+ for (p = s->seg; p; p = p->next)
+ p->x = XLOG2DEV(p->x);
}
}
-
+
if ( !m_currentClippingRegion.IsNull() )
m_currentClippingRegion.Intersect(rg);
else
m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());
- m_clipping = TRUE;
+ m_clipping = true;
DO_SET_CLIPPING_BOX(m_currentClippingRegion)
}
void wxDC::DestroyClippingRegion()
{
wxCHECK_RET( Ok(), wxT("invalid dc") );
-
- m_MGLDC->setClipRect(MGLRect(0, 0, m_MGLDC->sizex(), m_MGLDC->sizey()));
- m_clipping = FALSE;
- m_currentClippingRegion.Clear();
+
+ if ( !m_globalClippingRegion.IsNull() )
+ {
+ m_MGLDC->setClipRegion(m_globalClippingRegion.GetMGLRegion());
+ m_currentClippingRegion = m_globalClippingRegion;
+ m_clipping = true;
+ }
+ else
+ {
+ m_MGLDC->setClipRect(MGLRect(0, 0, m_MGLDC->sizex()+1, m_MGLDC->sizey()+1));
+ ResetClipping();
+ m_currentClippingRegion.Clear();
+ }
}
// ---------------------------------------------------------------------------
bool wxDC::CanDrawBitmap() const
{
- return TRUE;
+ return true;
}
bool wxDC::CanGetTextExtent() const
{
- return TRUE;
+ return true;
}
int wxDC::GetDepth() const
wxCHECK_RET( Ok(), wxT("invalid dc") );
m_MGLDC->makeCurrent(); // will go away with MGL6.0
- m_MGLDC->clearDevice();
- if ( m_backgroundBrush.GetStyle() != wxSOLID &&
- m_backgroundBrush.GetStyle() != wxTRANSPARENT )
+ if ( m_backgroundBrush.GetStyle() != wxTRANSPARENT )
{
int w, h;
wxBrush oldb = m_brush;
SetBrush(m_backgroundBrush);
SelectBrush();
GetSize(&w, &h);
- m_MGLDC->fillRect(0, 0, w-1, h-1);
+ m_MGLDC->fillRect(0, 0, w, h);
SetBrush(oldb);
}
}
-void wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
+extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
+ const wxColour & col, int style);
+
+bool wxDC::DoFloodFill(wxCoord x, wxCoord y,
+ const wxColour& col, int style)
{
- wxFAIL_MSG( wxT("wxDC::DoFloodFill not implemented") );
+ return wxDoFloodFill(this, x, y, col, style);
}
bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
{
- wxCHECK_MSG( col, FALSE, _T("NULL colour parameter in wxDC::GetPixel"));
+ wxCHECK_MSG( col, false, _T("NULL colour parameter in wxDC::GetPixel"));
uchar r, g, b;
- m_MGLDC->unpackColorFast(m_MGLDC->getPixel(XLOG2DEV(x), XLOG2DEV(y)),
+ m_MGLDC->unpackColorFast(m_MGLDC->getPixel(XLOG2DEV(x), YLOG2DEV(y)),
r, g, b);
col->Set(r, g, b);
- return TRUE;
+ return true;
}
void wxDC::DoCrossHair(wxCoord x, wxCoord y)
int h = 0;
GetSize(&w, &h);
m_MGLDC->makeCurrent(); // will go away with MGL6.0
- if ( !m_penSelected )
+ if ( !m_penSelected )
SelectPen();
wxCoord xx = XLOG2DEV(x);
wxCoord yy = YLOG2DEV(y);
if ( m_pen.GetStyle() != wxTRANSPARENT )
{
m_MGLDC->makeCurrent(); // will go away with MGL6.0
- if ( !m_penSelected )
+ if ( !m_penSelected )
SelectPen();
- m_MGLDC->line(XLOG2DEV(x1) + m_penOfsX, XLOG2DEV(y1) + m_penOfsY,
- XLOG2DEV(x2) + m_penOfsX, XLOG2DEV(y2) + m_penOfsY);
+ m_MGLDC->lineExt(XLOG2DEV(x1) + m_penOfsX, YLOG2DEV(y1) + m_penOfsY,
+ XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY,FALSE);
CalcBoundingBox(x1, y1);
CalcBoundingBox(x2, y2);
}
m_MGLDC->makeCurrent(); // will go away with MGL6.0
if ( m_brush.GetStyle() != wxTRANSPARENT )
{
- if ( !m_brushSelected )
+ if ( !m_brushSelected )
SelectBrush();
m_MGLDC->fillEllipseArc(xxc, yyc, r, r, alpha1, alpha2);
- }
+ }
if ( m_pen.GetStyle() != wxTRANSPARENT )
{
- if ( !m_penSelected )
+ if ( !m_penSelected )
SelectPen();
m_MGLDC->ellipseArc(xxc + m_penOfsX, yyc + m_penOfsY, r, r, alpha1, alpha2);
- }
+ }
CalcBoundingBox(xc - r, yc - r);
CalcBoundingBox(xc + r, yc + r);
if ( m_pen.GetStyle() != wxTRANSPARENT )
{
m_MGLDC->makeCurrent(); // will go away with MGL6.0
- if ( !m_penSelected )
+ if ( !m_penSelected )
SelectPen();
m_MGLDC->pixel(XLOG2DEV(x), YLOG2DEV(y));
CalcBoundingBox(x, y);
}
}
-void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset,int fillStyle)
+void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset,int WXUNUSED(fillStyle))
{
wxCHECK_RET( Ok(), wxT("invalid dc") );
- wxCoord xxoffset = XLOG2DEVREL(xoffset),
+ wxCoord xxoffset = XLOG2DEVREL(xoffset),
yyoffset = YLOG2DEVREL(yoffset);
- MGLPoint *cpoints = new MGLPoint[n+1];
+ MGLPoint *cpoints = new MGLPoint[n+1];
for (int i = 0; i < n; i++)
{
CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);
if ( m_pen.GetStyle() != wxTRANSPARENT )
{
- if ( !m_penSelected )
+ if ( !m_penSelected )
SelectPen();
if (m_penOfsX != 0 || m_penOfsY != 0)
{
{
MGLPoint *cpoints = new MGLPoint[n];
m_MGLDC->makeCurrent(); // will go away with MGL6.0
- if ( !m_penSelected )
+ if ( !m_penSelected )
SelectPen();
for (int i = 0; i < n; i++)
{
if ( ww == 0 || hh == 0 ) return;
- if ( ww < 0 )
+ if ( ww < 0 )
{
- ww = -ww;
+ ww = -ww;
xx = xx - ww;
}
- if ( hh < 0 )
+ if ( hh < 0 )
{
- hh = -hh;
- yy = yy - hh;
+ hh = -hh;
+ yy = yy - hh;
}
m_MGLDC->makeCurrent(); // will go away with MGL6.0
if ( m_brush.GetStyle() != wxTRANSPARENT )
{
- if ( !m_brushSelected )
+ if ( !m_brushSelected )
SelectBrush();
m_MGLDC->fillRect(xx, yy, xx + ww, yy + hh);
- }
+ }
if ( m_pen.GetStyle() != wxTRANSPARENT )
{
- if ( !m_penSelected )
+ if ( !m_penSelected )
SelectPen();
- m_MGLDC->rect(xx + m_penOfsX, yy + m_penOfsY,
+
+ m_MGLDC->rect(xx + m_penOfsX, yy + m_penOfsY,
xx + ww + m_penOfsX, yy + hh + m_penOfsY);
- }
+ }
CalcBoundingBox(x, y);
CalcBoundingBox(x + width, y + height);
{
wxCHECK_RET( Ok(), wxT("invalid dc") );
- if ( radius < 0.0 )
+ if ( radius < 0.0 )
radius = -radius * ((width < height) ? width : height);
wxCoord xx = XLOG2DEV(x);
wxCoord rr = XLOG2DEVREL((wxCoord)radius);
// CMB: handle -ve width and/or height
- if ( ww < 0 )
+ if ( ww < 0 )
{
- ww = -ww;
- xx = xx - ww;
+ ww = -ww;
+ xx = xx - ww;
}
- if ( hh < 0 )
- {
- hh = -hh;
- yy = yy - hh;
+ if ( hh < 0 )
+ {
+ hh = -hh;
+ yy = yy - hh;
}
// CMB: if radius is zero use DrawRectangle() instead to avoid
m_MGLDC->makeCurrent(); // will go away with MGL6.0
if ( m_brush.GetStyle() != wxTRANSPARENT )
{
- if (!m_brushSelected)
+ if (!m_brushSelected)
SelectBrush();
m_MGLDC->fillRect(xx+rr, yy, xx+ww-rr, yy+hh);
m_MGLDC->fillRect(xx, yy+rr, xx+ww, yy+hh-rr);
m_MGLDC->fillEllipseArc(xx+ww-rr, yy+rr, rr, rr, 0, 90);
m_MGLDC->fillEllipseArc(xx+rr, yy+hh-rr, rr, rr, 180, 270);
m_MGLDC->fillEllipseArc(xx+ww-rr, yy+hh-rr, rr, rr, 270, 0);
- }
+ }
if ( m_pen.GetStyle() != wxTRANSPARENT )
{
- if ( !m_penSelected )
+ if ( !m_penSelected )
SelectPen();
xx += m_penOfsX;
yy += m_penOfsY;
- m_MGLDC->line(xx+rr+1, yy, xx+ww-rr, yy);
+ m_MGLDC->line(xx+rr+1, yy, xx+ww-rr, yy);
m_MGLDC->ellipseArc(xx+ww-rr, yy+rr, rr, rr, 0, 90);
m_MGLDC->line(xx+ww, yy+rr+1, xx+ww, yy+hh-rr);
m_MGLDC->ellipseArc(xx+ww-rr, yy+hh-rr, rr, rr, 270, 0);
m_MGLDC->line(xx+ww-rr, yy+hh, xx+rr+1, yy+hh);
- m_MGLDC->ellipseArc(xx+rr, yy+hh-rr, rr, rr, 180, 270);
+ m_MGLDC->ellipseArc(xx+rr, yy+hh-rr, rr, rr, 180, 270);
m_MGLDC->line(xx, yy+hh-rr, xx, yy+rr+1);
m_MGLDC->ellipseArc(xx+rr, yy+rr, rr, rr, 90, 180);
}
SelectBrush();
MGLRect rect(XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
m_MGLDC->fillEllipse(rect);
- }
+ }
if ( m_pen.GetStyle() != wxTRANSPARENT )
{
- if ( !m_penSelected )
+ if ( !m_penSelected )
SelectPen();
- MGLRect rect(XLOG2DEV(x) + m_penOfsX, YLOG2DEV(y) + m_penOfsY,
+ MGLRect rect(XLOG2DEV(x) + m_penOfsX, YLOG2DEV(y) + m_penOfsY,
XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY);
m_MGLDC->ellipse(rect);
}
if (!m_brushSelected) SelectBrush();
MGLRect rect(XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
m_MGLDC->fillEllipseArc(rect, (int)sa, (int)ea);
- }
+ }
if ( m_pen.GetStyle() != wxTRANSPARENT )
{
- if ( !m_penSelected )
+ if ( !m_penSelected )
SelectPen();
- MGLRect rect(XLOG2DEV(x) + m_penOfsX, YLOG2DEV(y) + m_penOfsY,
+ MGLRect rect(XLOG2DEV(x) + m_penOfsX, YLOG2DEV(y) + m_penOfsY,
XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY);
m_MGLDC->ellipseArc(rect, (int)sa, (int)ea);
- }
+ }
CalcBoundingBox(x, y);
CalcBoundingBox(x2, y2);
void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
{
- if ( m_pen.GetStyle() == wxTRANSPARENT ) return;
m_MGLDC->makeCurrent(); // will go away with MGL6.0
DrawAnyText(text, x, y);
bool antialiased = (GetDepth() > 8);
m_mglFont = m_font.GetMGLfont_t(scale, antialiased);
- wxCHECK_MSG( m_mglFont, FALSE, wxT("invalid font") );
-
+ wxCHECK_MSG( m_mglFont, false, wxT("invalid font") );
+
m_MGLDC->useFont(m_mglFont);
wxLogTrace("mgl_font", "useFont(%p)", m_mglFont);
!wxTestFontEncoding(nativeEnc) )
{
#if wxUSE_FONTMAP
- if ( !wxTheFontMapper->GetAltForEncoding(encoding, &nativeEnc) )
+ if ( !wxFontMapper::Get()->GetAltForEncoding(encoding, &nativeEnc) )
#endif
{
nativeEnc.mglEncoding = MGL_ENCODING_ASCII;
m_MGLDC->setTextEncoding(nativeEnc.mglEncoding);
#endif
}
- return TRUE;
+ return true;
}
void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
SelectMGLFont();
- m_MGLDC->setColor(m_MGLDC->packColorFast(m_textForegroundColour.Red(),
- m_textForegroundColour.Green(), m_textForegroundColour.Blue()));
- m_MGLDC->setBackColor(m_MGLDC->packColorFast(m_textBackgroundColour.Red(),
- m_textBackgroundColour.Green(), m_textBackgroundColour.Blue()));
-
// Render the text:
wxCoord xx = XLOG2DEV(x);
wxCoord yy = YLOG2DEV(y);
m_MGLDC->setLineStipple(0xFFFF);
m_MGLDC->setPenSize(1, 1);
m_MGLDC->setPenStyle(MGL_BITMAP_SOLID);
-
+
#if wxUSE_UNICODE
const wchar_t *c_text = text.c_str();
#else
const char *c_text = text.c_str();
#endif
+
+#if 1
+ // FIXME_MGL - this is a temporary hack in absence of proper
+ // implementation of solid text background in MGL. Once
+ // the bug in MGL is fixed, this code should be nuked
+ // immediately. Note that the code is not 100% correct;
+ // it only works with wxCOPY logical function
+ if ( m_backgroundMode == wxSOLID )
+ {
+ int w = m_MGLDC->textWidth(c_text);
+ int h = m_MGLDC->textHeight();
+ m_MGLDC->setColor(m_MGLDC->packColorFast(m_textBackgroundColour.Red(),
+ m_textBackgroundColour.Green(), m_textBackgroundColour.Blue()));
+ m_MGLDC->fillRect(xx, yy, xx+w, yy+h);
+ }
+#endif
+
+ m_MGLDC->setColor(m_MGLDC->packColorFast(m_textForegroundColour.Red(),
+ m_textForegroundColour.Green(), m_textForegroundColour.Blue()));
+ m_MGLDC->setBackColor(m_MGLDC->packColorFast(m_textBackgroundColour.Red(),
+ m_textBackgroundColour.Green(), m_textBackgroundColour.Blue()));
+
m_MGLDC->drawStr(xx, yy, c_text);
-
+
// Render underline:
if ( m_font.GetUnderlined() )
{
int x1 = xx, y1 = yy;
- int x2, y2;
+ int x2 = 0 , y2 = 0;
int w = m_MGLDC->textWidth(c_text);
m_MGLDC->underScoreLocation(x1, y1, c_text);
switch (m_MGLDC->getTextDirection())
m_MGLDC->line(x1, y1, x2, y2);
}
- m_penSelected = m_brushSelected = FALSE;
+ m_penSelected = m_brushSelected = false;
}
void wxDC::DoDrawRotatedText(const wxString& text,
wxCoord x, wxCoord y,
double angle)
{
- if ( m_pen.GetStyle() == wxTRANSPARENT ) return;
m_MGLDC->makeCurrent(); // will go away with MGL6.0
-
+
if ( angle == 0 )
{
DoDrawText(text, x, y);
wxFAIL_MSG(wxT("wxMGL only supports rotated text with angle 0,90,180 or 270"));
return;
}
-
+
DrawAnyText(text, x, y);
-
+
// Restore default:
m_MGLDC->setTextDirection(MGL_RIGHT_DIR);
}
// switch between pens and brushes, we take advantage of MGL's ability
// to have multiple (pix)pattern_t's loaded. We always download pen
// to 0th slot and brush to 1st slot.
- if ( flag == wxMGL_SELECT_FROM_PEN )
+ if ( flag == wxMGL_SELECT_FROM_PEN )
slot = 0;
else
slot = 1;
- // compute pen's width:
+ // compute pen's width:
if ( m_pen.GetWidth() <= 1 )
{
wx = wy = 1;
m_penOfsX = m_penOfsY = 0;
}
else
- {
+ {
wx = (int)(0.5 + fabs((double) XLOG2DEVREL(m_pen.GetWidth())));
wy = (int)(0.5 + fabs((double) YLOG2DEVREL(m_pen.GetWidth())));
m_penOfsX = -wx/2;
m_penOfsY = -wy/2;
}
-
+
// find pen's type:
penstyle = MGL_BITMAP_TRANSPARENT;
switch (style)
{
- case wxBDIAGONAL_HATCH: pattern = &PATTERN_wxBDIAGONAL_HATCH;
- penstyle = MGL_BITMAP_TRANSPARENT;
+ case wxBDIAGONAL_HATCH: pattern = &PATTERN_wxBDIAGONAL_HATCH;
+ penstyle = MGL_BITMAP_TRANSPARENT;
break;
- case wxCROSSDIAG_HATCH: pattern = &PATTERN_wxCROSSDIAG_HATCH;
- penstyle = MGL_BITMAP_TRANSPARENT;
+ case wxCROSSDIAG_HATCH: pattern = &PATTERN_wxCROSSDIAG_HATCH;
+ penstyle = MGL_BITMAP_TRANSPARENT;
break;
case wxFDIAGONAL_HATCH: pattern = &PATTERN_wxFDIAGONAL_HATCH;
- penstyle = MGL_BITMAP_TRANSPARENT;
+ penstyle = MGL_BITMAP_TRANSPARENT;
break;
case wxCROSS_HATCH: pattern = &PATTERN_wxCROSS_HATCH;
- penstyle = MGL_BITMAP_TRANSPARENT;
+ penstyle = MGL_BITMAP_TRANSPARENT;
break;
case wxHORIZONTAL_HATCH: pattern = &PATTERN_wxHORIZONTAL_HATCH;
- penstyle = MGL_BITMAP_TRANSPARENT;
+ penstyle = MGL_BITMAP_TRANSPARENT;
break;
case wxVERTICAL_HATCH: pattern = &PATTERN_wxVERTICAL_HATCH;
- penstyle = MGL_BITMAP_TRANSPARENT;
+ penstyle = MGL_BITMAP_TRANSPARENT;
break;
-
+
case wxSTIPPLE:
- if ( flag == wxMGL_SELECT_FROM_PEN )
+ if ( flag == wxMGL_SELECT_FROM_PEN )
pixPattern = (pixpattern24_t*) m_pen.GetPixPattern();
else
pixPattern = (pixpattern24_t*) m_brush.GetPixPattern();
penstyle = MGL_PIXMAP;
break;
-
+
case wxSTIPPLE_MASK_OPAQUE:
pattern = (pattern_t*) m_brush.GetMaskPattern();
penstyle = MGL_BITMAP_OPAQUE;
break;
-
+
case wxSOLID:
default:
penstyle = MGL_BITMAP_SOLID; break;
if ( !m_downloadedPatterns[slot] )
{
m_MGLDC->setPenBitmapPattern(slot, pattern);
- m_downloadedPatterns[slot] = TRUE;
+ m_downloadedPatterns[slot] = true;
}
m_MGLDC->usePenBitmapPattern(slot);
}
-
+
if ( pixPattern )
{
if ( !m_downloadedPatterns[slot] )
{
pixpattern_t pix;
int x, y, c;
-
+
switch (GetDepth())
{
case 8:
for (y = 0; y < 8; y++)
for (x = 0; x < 8; x++)
- pix.b8.p[x][y] = m_MGLDC->packColorFast(
+ pix.b8.p[x][y] = (uchar)m_MGLDC->packColorFast(
pixPattern->p[x][y][0],
pixPattern->p[x][y][1],
pixPattern->p[x][y][2]);
case 16:
for (y = 0; y < 8; y++)
for (x = 0; x < 8; x++)
- pix.b16.p[x][y] = m_MGLDC->packColorFast(
+ pix.b16.p[x][y] = (M_uint16)m_MGLDC->packColorFast(
pixPattern->p[x][y][0],
pixPattern->p[x][y][1],
pixPattern->p[x][y][2]);
break;
}
m_MGLDC->setPenPixmapPattern(slot, &pix);
- m_downloadedPatterns[slot] = TRUE;
+ m_downloadedPatterns[slot] = true;
}
m_MGLDC->usePenPixmapPattern(slot);
}
-
+
m_MGLDC->setLineStyle(MGL_LINE_PENSTYLE);
m_MGLDC->setPenStyle(penstyle);
m_MGLDC->setPenSize(wy, wx);
case wxDOT_DASH:
SelectMGLStipplePen(m_pen.GetStyle());
break;
-
+
case wxBDIAGONAL_HATCH:
case wxCROSSDIAG_HATCH:
case wxFDIAGONAL_HATCH:
SelectMGLFatPen(wxSOLID, wxMGL_SELECT_FROM_PEN);
break;
}
- m_penSelected = TRUE;
- m_brushSelected = FALSE;
+ m_penSelected = true;
+ m_brushSelected = false;
}
void wxDC::SelectBrush()
wxColour fg, bg;
m_MGLDC->makeCurrent(); // will go away with MGL6.0
-
+
if ( m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE )
{
fg = m_textForegroundColour;
m_MGLDC->setColorRGB(fg.Red(), fg.Green(), fg.Blue());
m_MGLDC->setBackColor(m_MGLDC->packColorFast(bg.Red(), bg.Green(), bg.Blue()));
- m_penSelected = FALSE;
- m_brushSelected = TRUE;
+ m_penSelected = false;
+ m_brushSelected = true;
SelectMGLFatPen(m_brush.GetStyle(), wxMGL_SELECT_FROM_BRUSH);
}
if ( !pen.Ok() ) return;
if ( m_pen == pen ) return;
m_pen = pen;
- m_penSelected = FALSE;
- m_downloadedPatterns[0] = FALSE;
+ m_penSelected = false;
+ m_downloadedPatterns[0] = false;
}
void wxDC::SetBrush(const wxBrush& brush)
if ( !brush.Ok() ) return;
if ( m_brush == brush ) return;
m_brush = brush;
- m_brushSelected = FALSE;
- m_downloadedPatterns[1] = FALSE;
+ m_brushSelected = false;
+ m_downloadedPatterns[1] = false;
}
void wxDC::SetPalette(const wxPalette& palette)
{
wxCHECK_RET( Ok(), wxT("invalid dc") );
-
+
if ( palette == wxNullPalette )
{
- SetPalette(m_oldPalette);
+ if ( m_oldPalette.Ok() )
+ SetPalette(m_oldPalette);
return;
}
m_palette = palette;
int cnt = m_palette.GetColoursCount();
- palette_t *pal = m_palette.GetMGLpalette_t();
+ palette_t *pal = m_palette.GetMGLpalette_t();
m_MGLDC->setPalette(pal, cnt, 0);
m_MGLDC->realizePalette(cnt, 0, TRUE);
}
void wxDC::SetFont(const wxFont& font)
{
- wxCHECK_RET( font.Ok(), wxT("invalid font") );
- m_font = font;
- m_mglFont = NULL;
+ if ( font.Ok() )
+ {
+ m_font = font;
+ m_mglFont = NULL;
+ }
}
void wxDC::SetBackground(const wxBrush& brush)
{
wxCHECK_RET( Ok(), wxT("invalid dc") );
- if (!m_backgroundBrush.Ok()) return;
+ if (!brush.Ok()) return;
m_backgroundBrush = brush;
wxColour &clr = m_backgroundBrush.GetColour();
return (int)rop;
}
-bool wxDC::StartDoc(const wxString& message)
+bool wxDC::StartDoc(const wxString& WXUNUSED(message))
{
- // 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;
}
void wxDC::EndDoc()
wxFont *theFont) const
{
wxFont oldFont;
-
+
if ( theFont != NULL )
{
oldFont = m_font;
wxConstCast(this, wxDC)->SetFont(*theFont);
}
-
+
wxCurrentDCSwitcher switcher(m_MGLDC);
if ( !wxConstCast(this, wxDC)->SelectMGLFont() ) return;
if ( x )
- // VS: YDEV is corrent, it should *not* be XDEV, because font's are
+ // VS: YDEV is corrent, it should *not* be XDEV, because font's are
// only scaled according to m_scaleY
*x = YDEV2LOGREL(m_MGLDC->textWidth(string.c_str()));
if ( y )
*descent = YDEV2LOGREL(m_mglFont->descent);
if ( externalLeading )
*externalLeading = YDEV2LOGREL(m_mglFont->leading);
-
+
if ( theFont != NULL )
wxConstCast(this, wxDC)->SetFont(oldFont);
}
{
double newX = m_logicalScaleX * m_userScaleX;
double newY = m_logicalScaleY * m_userScaleY;
-
+
// make sure font will be reloaded before drawing:
if ( newY != m_scaleY )
m_mglFont = NULL;
// make sure m_penOfs{X,Y} will be reevaluated before drawing:
if ( newY != m_scaleY || newX != m_scaleX )
- m_penSelected = FALSE;
-
+ m_penSelected = false;
+
m_scaleX = newX, m_scaleY = newY;
}
void wxDC::DoGetSize(int *w, int *h) const
{
- if (w) *w = m_MGLDC->sizex();
- if (h) *h = m_MGLDC->sizey();
+ if (w) *w = m_MGLDC->sizex()+1;
+ if (h) *h = m_MGLDC->sizey()+1;
}
void wxDC::DoGetSizeMM(int *width, int *height) const
wxSize wxDC::GetPPI() const
{
- return wxSize(int(double(m_mm_to_pix_x) * inches2mm),
+ return wxSize(int(double(m_mm_to_pix_x) * inches2mm),
int(double(m_mm_to_pix_y) * inches2mm));
}
int rop, bool useMask,
wxCoord xsrcMask, wxCoord ysrcMask)
{
- wxCHECK_MSG( Ok(), FALSE, wxT("invalid dc") );
- wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
-
+ wxCHECK_MSG( Ok(), false, wxT("invalid dc") );
+ wxCHECK_MSG( source, false, wxT("invalid source dc") );
+
// transform the source DC coords to the device ones
xsrc = source->LogicalToDeviceX(xsrc);
ysrc = source->LogicalToDeviceY(ysrc);
- /* TODO: use the mask origin when drawing transparently */
+ /* FIXME_MGL: use the mask origin when drawing transparently */
if (xsrcMask == -1 && ysrcMask == -1)
{
xsrcMask = xsrc; ysrcMask = ysrc;
/* scale/translate size and position */
wxCoord xx = XLOG2DEV(xdest);
wxCoord yy = YLOG2DEV(ydest);
- wxCoord ww = XLOG2DEVREL(width);
- wxCoord hh = YLOG2DEVREL(height);
if ( source->m_isMemDC )
{
wxMemoryDC *memDC = (wxMemoryDC*) source;
- DoDrawSubBitmap(memDC->GetSelectedObject(), xsrc, ysrc, ww, hh,
+ DoDrawSubBitmap(memDC->GetSelectedObject(),
+ xsrc, ysrc, width, height,
xdest, ydest, rop, useMask);
}
else
{
+ wxCoord ww = XLOG2DEVREL(width);
+ wxCoord hh = YLOG2DEVREL(height);
+
m_MGLDC->makeCurrent(); // will go away with MGL6.0
- m_MGLDC->bitBlt(*source->GetMGLDC(),
+ m_MGLDC->bitBlt(*source->GetMGLDC(),
xsrc, ysrc, xsrc + ww, ysrc + hh,
xx, yy, LogicalFunctionToMGLRop(rop));
}
- return TRUE;
+ return true;
}
void wxDC::DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask)
void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
{
// VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
- DoDrawBitmap((const wxBitmap&)icon, x, y, (bool)TRUE);
+ DoDrawBitmap((const wxBitmap&)icon, x, y, true);
}
static inline void DoBitBlt(const wxBitmap& src, MGLDevCtx *dst,
- int sx, int sy, int sw, int sh,
- int dx, int dy, int dw, int dh,
+ int sx, int sy, int sw, int sh,
+ int dx, int dy, int dw, int dh,
int rop, bool useStretching, bool putSection)
{
bitmap_t *bmp = src.GetMGLbitmap_t();
if (!putSection)
dst->stretchBitmap(dx, dy, dx + dw, dy + dh, bmp, rop);
else
- dst->stretchBitmapSection(sx, sy, sx + sw, sy + sh,
+ dst->stretchBitmapSection(sx, sy, sx + sw, sy + sh,
dx, dy, dx + dw, dy + dh, bmp, rop);
}
}
-void wxDC::DoDrawSubBitmap(const wxBitmap &bmp,
+void wxDC::DoDrawSubBitmap(const wxBitmap &bmp,
wxCoord x, wxCoord y, wxCoord w, wxCoord h,
wxCoord destx, wxCoord desty, int rop, bool useMask)
{
wxCoord dy = YLOG2DEV(desty);
wxCoord dw = XLOG2DEVREL(w);
wxCoord dh = YLOG2DEVREL(h);
-
+
m_MGLDC->makeCurrent(); // will go away with MGL6.0
-
+
bool useStretching = ((w != dw) || (h != dh));
bool putSection = (w != bmp.GetWidth() || h != bmp.GetHeight());
MGL_writeModeType mglRop = (MGL_writeModeType)LogicalFunctionToMGLRop(rop);
if ( useMask && bmp.GetMask() )
{
// Since MGL does not support masks directly (in MGL, mask is handled
- // in same way as in wxImage, i.e. there is one "key" color), we
+ // in same way as in wxImage, i.e. there is one "key" color), we
// simulate masked bitblt in 6 steps (same as in MSW):
//
- // 1. Create a temporary bitmap and copy the destination area into it.
- // 2. Copy the source area into the temporary bitmap using the
+ // 1. Create a temporary bitmap and copy the destination area into it.
+ // 2. Copy the source area into the temporary bitmap using the
// specified logical function.
- // 3. Set the masked area in the temporary bitmap to BLACK by ANDing
- // the mask bitmap with the temp bitmap with the foreground colour
+ // 3. Set the masked area in the temporary bitmap to BLACK by ANDing
+ // the mask bitmap with the temp bitmap with the foreground colour
// set to WHITE and the bg colour set to BLACK.
// 4. Set the unmasked area in the destination area to BLACK by
- // ANDing the mask bitmap with the destination area with the
+ // ANDing the mask bitmap with the destination area with the
// foreground colour set to BLACK and the background colour set
- // to WHITE.
- // 5. OR the temporary bitmap with the destination area.
- // 6. Delete the temporary bitmap.
- //
- // This sequence of operations ensures that the source's transparent
+ // to WHITE.
+ // 5. OR the temporary bitmap with the destination area.
+ // 6. Delete the temporary bitmap.
+ //
+ // This sequence of operations ensures that the source's transparent
// area need not be black, and logical functions are supported.
- wxBitmap *mask = bmp.GetMask()->GetBitmap();
+ wxBitmap mask = bmp.GetMask()->GetBitmap();
MGLMemoryDC *temp;
-
+
if ( GetDepth() <= 8 )
{
temp = new MGLMemoryDC(dw, dh, GetDepth(), NULL);
wxDC tempdc;
- tempdc.SetMGLDC(temp, FALSE);
+ tempdc.SetMGLDC(temp, false);
tempdc.SetPalette(m_palette);
}
else
m_MGLDC->getPixelFormat(pf);
temp = new MGLMemoryDC(dw, dh, GetDepth(), &pf);
}
-
+
wxCHECK_RET( temp->isValid(), wxT("cannot create temporary dc") );
-
+
temp->bitBlt(*m_MGLDC, dx, dy, dx + dw, dy + dh, 0, 0, MGL_REPLACE_MODE);
- DoBitBlt(bmp, temp, x, y, w, h, 0, 0, dw, dh, mglRop,
+ DoBitBlt(bmp, temp, x, y, w, h, 0, 0, dw, dh, mglRop,
useStretching, putSection);
- mask->SetMonoPalette(wxColour(0,0,0), wxColour(255,255,255));
- DoBitBlt(*mask, temp, x, y, w, h, 0, 0, dw, dh, MGL_R2_MASKSRC,
+ mask.SetMonoPalette(wxColour(0,0,0), wxColour(255,255,255));
+ DoBitBlt(mask, temp, x, y, w, h, 0, 0, dw, dh, MGL_R2_MASKSRC,
useStretching, putSection);
- DoBitBlt(*mask, m_MGLDC, x, y, w, h, dx, dy, dw, dh, MGL_R2_MASKNOTSRC,
+ DoBitBlt(mask, m_MGLDC, x, y, w, h, dx, dy, dw, dh, MGL_R2_MASKNOTSRC,
useStretching, putSection);
m_MGLDC->bitBlt(*temp, 0, 0, dw, dh, dx, dy, MGL_OR_MODE);
-
+
delete temp;
}
-
+
else
{
- DoBitBlt(bmp, m_MGLDC, x, y, w, h, dx, dy, dw, dh, mglRop,
+ DoBitBlt(bmp, m_MGLDC, x, y, w, h, dx, dy, dw, dh, mglRop,
useStretching, putSection);
}
}
projects / wxWidgets.git / blobdiff