/////////////////////////////////////////////////////////////////////////////
-// Name: dcclient.cpp
-// Purpose: wxClientDC class
+// Name: src/motif/dcclient.cpp
+// Purpose: wxClientDCImpl class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
-// Licence: wxWindows licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/*
- About pens, brushes, and the autoSetting flag:
-
- Under X, pens and brushes control some of the same X drawing
- parameters. Therefore, it is impossible to independently maintain
- the current pen and the current brush. Also, some settings depend
- on the current logical function. The m_currentFill, etc. instance
- variables remember state across the brush and pen.
-
- Since pens are used more than brushes, the autoSetting flag
- is used to indicate that a brush was recently used, and SetPen
- must be called to reinstall the current pen's parameters.
- If autoSetting includes 0x2, then the pens color may need
- to be set based on XOR.
-
- There is, unfortunately, some confusion between setting the
- current pen/brush and actually installing the brush/pen parameters.
- Both functionalies are perform by SetPen and SetBrush. C'est la vie.
+ About pens, brushes, and the m_autoSetting flag:
+
+ Under X, pens and brushes control some of the same X drawing
+ parameters. Therefore, it is impossible to independently maintain
+ the current pen and the current brush. Also, some settings depend on
+ the current logical function. The m_currentFill, etc. instance
+ variables remember state across the brush and pen.
+
+ Since pens are used more than brushes, the m_autoSetting flag is used to
+ indicate that a brush was recently used, and SetPen must be called to
+ reinstall the current pen's parameters. If m_autoSetting includes 0x2, then the
+ pens color may need to be set based on XOR.
+
+ There is, unfortunately, some confusion between setting the current pen/brush
+ and actually installing the brush/pen parameters. Both functionalies are
+ perform by SetPen and SetBrush. C'est la vie.
*/
-#ifdef __GNUG__
-#pragma implementation "dcclient.h"
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+ #include "wx/log.h"
+ #include "wx/app.h"
+ #include "wx/window.h"
+ #include "wx/dcmemory.h"
+ #include "wx/math.h"
+ #include "wx/image.h"
+ #include "wx/dcclient.h"
#endif
-#include "wx/dcclient.h"
-#include "wx/dcmemory.h"
-#include "wx/window.h"
-#include "wx/app.h"
-#include <math.h>
-
+#ifdef __VMS__
+#pragma message disable nosimpint
+#endif
#include <Xm/Xm.h>
+#ifdef __VMS__
+#pragma message enable nosimpint
+#endif
#include "wx/motif/private.h"
+#include "wx/motif/dcclient.h"
+
+#ifdef __EMX__
+ #include <float.h> // for M_PI
+#endif // __EMX__
#include "bdiag.xbm"
#include "fdiag.xbm"
static Pixmap bdiag, cdiag, fdiag, cross, horiz, verti;
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
// constants
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
-#define RAD2DEG 57.2957795131
-// Fudge factor. Obsolete?
-#define WX_GC_CF 0
+// Fudge factor (VZ: what??)
+#define WX_GC_CF 1
-//-----------------------------------------------------------------------------
-// wxWindowDC
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// macros
+// ----------------------------------------------------------------------------
-#if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
-IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxWindowDC)
-IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
-#endif
+IMPLEMENT_ABSTRACT_CLASS(wxClientDCImpl, wxWindowDCImpl)
+IMPLEMENT_ABSTRACT_CLASS(wxPaintDCImpl, wxWindowDCImpl)
+IMPLEMENT_ABSTRACT_CLASS(wxWindowDCImpl, wxMotifDCImpl)
+
+#define IS_HATCH(s) ((s)>=wxFIRST_HATCH && (s)<=wxLAST_HATCH)
+
+// FIXME: left over after removal of wxDC::GetOptimization()
+#define GET_OPTIMIZATION false
+
+// ----------------------------------------------------------------------------
+// prototypes
+// ----------------------------------------------------------------------------
+
+static void XCopyRemote(Display *src_display, Display *dest_display,
+ Drawable src, Drawable dest,
+ GC destgc,
+ int srcx, int srcy,
+ unsigned int w, unsigned int h,
+ int destx, int desty,
+ bool more, XImage **cache);
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+/*
+ * compare two doubles and return the larger rounded
+ * to the nearest int
+ */
+static int roundmax(double a, double b)
+{
+ return (int)((a > b ? a : b) + 0.5);
+}
+
+/*
+ * compare two doubles and return the smaller rounded
+ * to the nearest int
+ */
+static int roundmin(double a, double b)
+{
+ return (int)((a < b ? a : b) - 0.5);
+}
+
+
+// ----------------------------------------------------------------------------
+// wxWindowDCImpl
+// ----------------------------------------------------------------------------
-wxWindowDC::wxWindowDC(void)
+void wxWindowDCImpl::Init()
{
m_gc = (WXGC) 0;
m_gcBacking = (WXGC) 0;
m_currentPenWidth = 1;
m_currentPenJoin = -1;
m_currentPenDashCount = -1;
- m_currentPenDash = (char*) NULL;
+ m_currentPenDash = NULL;
m_currentStyle = -1;
m_currentFill = -1;
-// m_currentBkMode = wxTRANSPARENT;
m_colour = wxColourDisplay();
- m_display = (WXDisplay*) NULL;
- m_currentRegion = (WXRegion) 0;
- m_userRegion = (WXRegion) 0;
+ m_display = NULL;
m_pixmap = (WXPixmap) 0;
m_autoSetting = 0;
- m_oldFont = (WXFont) 0;
-};
+ m_ok = false;
+ m_clipRegion = (WXRegion) 0;
+}
+
+wxWindowDCImpl::wxWindowDCImpl(wxDC *owner)
+ : wxMotifDCImpl(owner)
+{
+ Init();
+}
-wxWindowDC::wxWindowDC( wxWindow *window )
+wxWindowDCImpl::wxWindowDCImpl(wxDC *owner, wxWindow *window)
+ : wxMotifDCImpl(owner)
{
- wxASSERT_MSG( (window != (wxWindow*) NULL), "You must pass a valid wxWindow to wxWindowDC/wxClientDC/wxPaintDC constructor." );
+ wxASSERT_MSG( (window != NULL), "You must pass a valid wxWindow to wxWindowDCImpl/wxClientDCImpl/wxPaintDCImpl constructor." );
+
+ Init();
m_window = window;
- m_gc = (WXGC) 0;
- m_gcBacking = (WXGC) 0;
- m_backgroundPixel = -1;
- m_currentPenWidth = 1;
- m_currentPenJoin = -1;
- m_currentPenDashCount = -1;
- m_currentPenDash = (char*) NULL;
- m_currentStyle = -1;
- m_currentFill = -1;
-// m_currentBkMode = wxTRANSPARENT;
- m_colour = wxColourDisplay();
- m_currentRegion = (WXRegion) 0;
- m_userRegion = (WXRegion) 0;
- m_ok = TRUE;
- m_autoSetting = 0;
+ m_font = window->GetFont();
+ m_ok = true;
m_display = window->GetXDisplay();
m_pixmap = window->GetXWindow();
gcvalues.foreground = BlackPixel (display, DefaultScreen (display));
gcvalues.background = WhitePixel (display, DefaultScreen (display));
gcvalues.graphics_exposures = False;
+ gcvalues.subwindow_mode = IncludeInferiors;
gcvalues.line_width = 1;
+#if !wxMOTIF_NEW_FONT_HANDLING
+ WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
+ gcvalues.font = ((XFontStruct*)pFontStruct)->fid;
+#endif
m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
- GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
- &gcvalues);
+ GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode
+#if !wxMOTIF_NEW_FONT_HANDLING
+ | GCFont
+#endif
+ ,
+ &gcvalues);
if (m_window->GetBackingPixmap())
{
- m_gcBacking = (WXGC) XCreateGC (display, RootWindow (display,
- DefaultScreen (display)),
- GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
- &gcvalues);
+ m_gcBacking = (WXGC) XCreateGC (display, RootWindow (display,
+ DefaultScreen (display)),
+ GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode,
+ &gcvalues);
}
- m_backgroundPixel = (int) gcvalues.background;
+ m_backgroundPixel = gcvalues.background;
- // Get the current Font so we can set it back later
- XGCValues valReturn;
- XGetGCValues((Display*) m_display, (GC) m_gc, GCFont, &valReturn);
- m_oldFont = (WXFont) valReturn.font;
-};
+ SetBackground(wxBrush(m_window->GetBackgroundColour(), wxSOLID));
+}
-wxWindowDC::~wxWindowDC(void)
+wxWindowDCImpl::~wxWindowDCImpl()
{
- if (m_gc && (m_oldFont != (WXFont) 0) && ((long) m_oldFont != -1))
- {
- XSetFont ((Display*) m_display, (GC) m_gc, (Font) m_oldFont);
-
- if (m_window && m_window->GetBackingPixmap())
- XSetFont ((Display*) m_display,(GC) m_gcBacking, (Font) m_oldFont);
- }
-
if (m_gc)
XFreeGC ((Display*) m_display, (GC) m_gc);
m_gc = (WXGC) 0;
XFreeGC ((Display*) m_display, (GC) m_gcBacking);
m_gcBacking = (WXGC) 0;
- if (m_currentRegion)
- XDestroyRegion ((Region) m_currentRegion);
- m_currentRegion = (WXRegion) 0;
+ if (m_clipRegion)
+ XDestroyRegion ((Region) m_clipRegion);
+ m_clipRegion = (WXRegion) 0;
+}
- if (m_userRegion)
- XDestroyRegion ((Region) m_userRegion);
- m_userRegion = (WXRegion) 0;
-};
+extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
+ const wxColour & col, wxFloodFillStyle style);
-void wxWindowDC::FloodFill( long WXUNUSED(x1), long WXUNUSED(y1),
- const wxColour& WXUNUSED(col), int WXUNUSED(style) )
+bool wxWindowDCImpl::DoFloodFill(wxCoord x, wxCoord y,
+ const wxColour& col, wxFloodFillStyle style)
{
- // TODO
-};
+ return wxDoFloodFill(GetOwner(), x, y, col, style);
+}
-bool wxWindowDC::GetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const
+bool wxWindowDCImpl::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
{
- // TODO
- return FALSE;
-};
+ // Generic (and therefore rather inefficient) method.
+ // Could be improved.
+ wxMemoryDC memdc;
+ wxBitmap bitmap(1, 1);
+ memdc.SelectObject(bitmap);
+ memdc.Blit(0, 0, 1, 1, GetOwner(), x1, y1);
+ memdc.SelectObject(wxNullBitmap);
+ wxImage image = bitmap.ConvertToImage();
+ col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));
+ return true;
+}
-void wxWindowDC::DrawLine( long x1, long y1, long x2, long y2 )
+void wxWindowDCImpl::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
{
- if (!Ok()) return;
-
- int x1d, y1d, x2d, y2d;
+ wxCHECK_RET( IsOk(), "invalid dc" );
- // FreeGetPixelCache();
+ int x1d, y1d, x2d, y2d;
- x1d = XLOG2DEV(x1);
- y1d = YLOG2DEV(y1);
- x2d = XLOG2DEV(x2);
- y2d = YLOG2DEV(y2);
+ x1d = XLOG2DEV(x1);
+ y1d = YLOG2DEV(y1);
+ x2d = XLOG2DEV(x2);
+ y2d = YLOG2DEV(y2);
- if (m_autoSetting)
- SetPen (m_pen);
+ if (m_autoSetting)
+ SetPen (m_pen);
- XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, x1d, y1d, x2d, y2d);
+ XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, x1d, y1d, x2d, y2d);
- if (m_window && m_window->GetBackingPixmap())
- XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
- XLOG2DEV_2(x1), YLOG2DEV_2(y1),
- XLOG2DEV_2(x2), YLOG2DEV_2(y2));
+ if (m_window && m_window->GetBackingPixmap())
+ XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+ XLOG2DEV_2(x1), YLOG2DEV_2(y1),
+ XLOG2DEV_2(x2), YLOG2DEV_2(y2));
- CalcBoundingBox(x1, y1);
- CalcBoundingBox(x2, y2);
-};
+ CalcBoundingBox(x1, y1);
+ CalcBoundingBox(x2, y2);
+}
-void wxWindowDC::CrossHair( long x, long y )
+void wxWindowDCImpl::DoCrossHair( wxCoord x, wxCoord y )
{
- if (!Ok()) return;
+ wxCHECK_RET( IsOk(), "invalid dc" );
- if (m_autoSetting)
- SetPen (m_pen);
+ if (m_autoSetting)
+ SetPen (m_pen);
- int xx = XLOG2DEV (x);
- int yy = YLOG2DEV (y);
- int ww, hh;
- wxDisplaySize (&ww, &hh);
- XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, 0, yy,
- ww, yy);
- XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xx, 0,
- xx, hh);
+ int xx = XLOG2DEV (x);
+ int yy = YLOG2DEV (y);
+ int ww, hh;
+ wxDisplaySize (&ww, &hh);
+ XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, 0, yy,
+ ww, yy);
+ XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xx, 0,
+ xx, hh);
- if (m_window && m_window->GetBackingPixmap())
+ if (m_window && m_window->GetBackingPixmap())
{
- xx = XLOG2DEV_2 (x);
- yy = YLOG2DEV_2 (y);
- XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
- 0, yy,
- ww, yy);
- XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
- xx, 0,
- xx, hh);
+ xx = XLOG2DEV_2 (x);
+ yy = YLOG2DEV_2 (y);
+ XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+ 0, yy,
+ ww, yy);
+ XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+ xx, 0,
+ xx, hh);
}
-};
+}
-void wxWindowDC::DrawArc( long x1, long y1, long x2, long y2, long xc, long yc )
+void wxWindowDCImpl::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc )
{
- if (!Ok()) return;
-
-// FreeGetPixelCache();
-
- int xx1 = XLOG2DEV (x1);
- int yy1 = YLOG2DEV (y1);
- int xx2 = XLOG2DEV (x2);
- int yy2 = YLOG2DEV (y2);
- int xxc = XLOG2DEV (xc);
- int yyc = YLOG2DEV (yc);
- int xxc_2 = XLOG2DEV_2 (xc);
- int yyc_2 = YLOG2DEV_2 (yc);
-
- long dx = xx1 - xxc;
- long dy = yy1 - yyc;
- double radius = sqrt (dx * dx + dy * dy);
- long r = (long) radius;
-
- double radius1, radius2;
-
- if (xx1 == xx2 && yy1 == yy2)
+ wxCHECK_RET( IsOk(), "invalid dc" );
+
+ int xx1 = XLOG2DEV (x1);
+ int yy1 = YLOG2DEV (y1);
+ int xx2 = XLOG2DEV (x2);
+ int yy2 = YLOG2DEV (y2);
+ int xxc = XLOG2DEV (xc);
+ int yyc = YLOG2DEV (yc);
+ int xxc_2 = XLOG2DEV_2 (xc);
+ int yyc_2 = YLOG2DEV_2 (yc);
+
+ wxCoord dx = xx1 - xxc;
+ wxCoord dy = yy1 - yyc;
+ double radius = sqrt ((double)(dx * dx + dy * dy));
+ wxCoord r = (wxCoord) radius;
+
+ double radius1, radius2;
+
+ if (xx1 == xx2 && yy1 == yy2)
{
- radius1 = 0.0;
- radius2 = 360.0;
+ radius1 = 0.0;
+ radius2 = 360.0;
}
- else if (radius == 0.0)
- radius1 = radius2 = 0.0;
- else
- {
- if (xx1 - xxc == 0)
- if (yy1 - yyc < 0)
- radius1 = 90.0;
- else
- radius1 = -90.0;
- else
- radius1 = -atan2 ((double) (yy1 - yyc), (double) (xx1 - xxc)) * 360.0 / (2 * M_PI);
-
- if (xx2 - xxc == 0)
- if (yy2 - yyc < 0)
- radius2 = 90.0;
+ else if (radius == 0.0)
+ radius1 = radius2 = 0.0;
else
- radius2 = -90.0;
- else
- radius2 = -atan2 ((double) (yy2 - yyc), (double) (xx2 - xxc)) * 360.0 / (2 * M_PI);
+ {
+ if (xx1 - xxc == 0)
+ if (yy1 - yyc < 0)
+ radius1 = 90.0;
+ else
+ radius1 = -90.0;
+ else
+ radius1 = -atan2 ((double) (yy1 - yyc), (double) (xx1 - xxc)) * 360.0 / (2 * M_PI);
+
+ if (xx2 - xxc == 0)
+ if (yy2 - yyc < 0)
+ radius2 = 90.0;
+ else
+ radius2 = -90.0;
+ else
+ radius2 = -atan2 ((double) (yy2 - yyc), (double) (xx2 - xxc)) * 360.0 / (2 * M_PI);
}
- radius1 *= 64.0;
- radius2 *= 64.0;
- int alpha1 = (int) radius1;
- int alpha2 = (int) (radius2 - radius1);
- while (alpha2 <= 0)
- alpha2 += 360 * 64;
- while (alpha2 > 360 * 64)
- alpha2 -= 360 * 64;
-
- if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+ radius1 *= 64.0;
+ radius2 *= 64.0;
+ int alpha1 = (int) radius1;
+ int alpha2 = (int) (radius2 - radius1);
+ while (alpha2 <= 0)
+ alpha2 += 360 * 64;
+ while (alpha2 > 360 * 64)
+ alpha2 -= 360 * 64;
+
+ if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
{
- SetBrush (m_brush);
- XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) (GC) m_gc,
- xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);
+ SetBrush (m_brush);
+ XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) (GC) m_gc,
+ xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);
- if (m_window && m_window->GetBackingPixmap())
- XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
- xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);
+ if (m_window && m_window->GetBackingPixmap())
+ XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+ xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);
}
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
{
if (m_autoSetting)
SetPen (m_pen);
- XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc,
- xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);
+ XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc,
+ xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);
- if (m_window && m_window->GetBackingPixmap())
- XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
- xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);
+ if (m_window && m_window->GetBackingPixmap())
+ XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+ xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);
}
- CalcBoundingBox (x1, y1);
- CalcBoundingBox (x2, y2);
-};
+ CalcBoundingBox (x1, y1);
+ CalcBoundingBox (x2, y2);
+}
-void wxWindowDC::DrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
+void wxWindowDCImpl::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
{
- if (!Ok()) return;
-
- int xd, yd, wd, hd;
-
- xd = XLOG2DEV(x);
- yd = YLOG2DEV(y);
- wd = XLOG2DEVREL(width);
- hd = YLOG2DEVREL(height);
-
- if (sa>=360 || sa<=-360) sa=sa-int(sa/360)*360;
- if (ea>=360 || ea<=-360) ea=ea-int(ea/360)*360;
- int start = int(sa*64);
- int end = int(ea*64);
- if (start<0) start+=360*64;
- if (end <0) end +=360*64;
- if (end>start) end-=start;
- else end+=360*64-start;
-
- if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+ wxCHECK_RET( IsOk(), "invalid dc" );
+
+ int xd, yd, wd, hd;
+
+ xd = XLOG2DEV(x);
+ yd = YLOG2DEV(y);
+ wd = XLOG2DEVREL(width);
+ hd = YLOG2DEVREL(height);
+
+ if (sa>=360 || sa<=-360) sa=sa-int(sa/360)*360;
+ if (ea>=360 || ea<=-360) ea=ea-int(ea/360)*360;
+ int start = int(sa*64);
+ int end = int(ea*64);
+ if (start<0) start+=360*64;
+ if (end <0) end +=360*64;
+ if (end>start) end-=start;
+ else end+=360*64-start;
+
+ if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
{
- m_autoSetting = TRUE; // must be reset
+ m_autoSetting = true; // must be reset
- SetBrush (m_brush);
- XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start, end);
+ SetBrush (m_brush);
+ XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start, end);
- if (m_window && m_window->GetBackingPixmap())
- XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
- XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
+ if (m_window && m_window->GetBackingPixmap())
+ XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+ XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
}
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
{
- if (m_autoSetting)
- SetPen (m_pen);
- XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start,end);
- if (m_window && m_window->GetBackingPixmap())
- XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
- XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
+ if (m_autoSetting)
+ SetPen (m_pen);
+ XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start,end);
+ if (m_window && m_window->GetBackingPixmap())
+ XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+ XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
}
- CalcBoundingBox (x, y);
- CalcBoundingBox (x + width, y + height);
-};
+ CalcBoundingBox (x, y);
+ CalcBoundingBox (x + width, y + height);
+}
-void wxWindowDC::DrawPoint( long x, long y )
+void wxWindowDCImpl::DoDrawPoint( wxCoord x, wxCoord y )
{
- if (!Ok()) return;
-
-// FreeGetPixelCache();
+ wxCHECK_RET( IsOk(), "invalid dc" );
- if (m_pen.Ok() && m_autoSetting)
- SetPen (m_pen);
+ if (m_pen.IsOk() && m_autoSetting)
+ SetPen (m_pen);
- XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y));
- if (m_window && m_window->GetBackingPixmap())
- XDrawPoint ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, XLOG2DEV_2 (x), YLOG2DEV_2 (y));
+ XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y));
+ if (m_window && m_window->GetBackingPixmap())
+ XDrawPoint ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, XLOG2DEV_2 (x), YLOG2DEV_2 (y));
- CalcBoundingBox (x, y);
-};
+ CalcBoundingBox (x, y);
+}
-void wxWindowDC::DrawLines( int n, wxPoint points[], long xoffset, long yoffset )
+void wxWindowDCImpl::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
{
- if (!Ok()) return;
-
-// FreeGetPixelCache();
+ wxCHECK_RET( IsOk(), "invalid dc" );
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
{
- if (m_autoSetting)
- SetPen (m_pen);
+ if (m_autoSetting)
+ SetPen (m_pen);
- XPoint *xpoints = new XPoint[n];
- int i;
+ XPoint *xpoints = new XPoint[n];
+ int i;
- for (i = 0; i < n; i++)
- {
- xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
- xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
- }
- XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints, n, 0);
+ for (i = 0; i < n; i++)
+ {
+ xpoints[i].x = (short)XLOG2DEV (points[i].x + xoffset);
+ xpoints[i].y = (short)YLOG2DEV (points[i].y + yoffset);
+ }
+ XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints, n, 0);
- if (m_window && m_window->GetBackingPixmap())
- {
- for (i = 0; i < n; i++)
+ if (m_window && m_window->GetBackingPixmap())
{
- xpoints[i].x = XLOG2DEV_2 (points[i].x + xoffset);
- xpoints[i].y = YLOG2DEV_2 (points[i].y + yoffset);
+ for (i = 0; i < n; i++)
+ {
+ xpoints[i].x = (short)XLOG2DEV_2 (points[i].x + xoffset);
+ xpoints[i].y = (short)YLOG2DEV_2 (points[i].y + yoffset);
+ }
+ XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints, n, 0);
}
- XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints, n, 0);
+ delete[]xpoints;
}
- delete[]xpoints;
- }
-};
-
-void wxWindowDC::DrawLines( wxList *list, long xoffset, long yoffset )
-{
- if (!Ok()) return;
-
- if (m_pen.GetStyle() == wxTRANSPARENT) return;
-
- int n = list->Number();
- wxPoint *points = new wxPoint[n];
-
- int i = 0;
- for(wxNode *node = list->First(); node; node = node->Next()) {
- wxPoint *point = (wxPoint *)node->Data();
- points[i].x = point->x;
- points[i++].y = point->y;
- }
- DrawLines(n, points, xoffset, yoffset);
- delete []points;
-};
+}
-void wxWindowDC::DrawPolygon( int n, wxPoint points[],
- long xoffset, long yoffset, int fillStyle )
+void wxWindowDCImpl::DoDrawPolygon( int n, wxPoint points[],
+ wxCoord xoffset, wxCoord yoffset, wxPolygonFillMode fillStyle )
{
-// FreeGetPixelCache();
+ wxCHECK_RET( IsOk(), "invalid dc" );
- XPoint *xpoints1 = new XPoint[n + 1];
- XPoint *xpoints2 = new XPoint[n + 1];
- int i;
- for (i = 0; i < n; i++)
+ XPoint *xpoints1 = new XPoint[n + 1];
+ XPoint *xpoints2 = new XPoint[n + 1];
+ int i;
+ for (i = 0; i < n; i++)
{
- xpoints1[i].x = XLOG2DEV (points[i].x + xoffset);
- xpoints1[i].y = YLOG2DEV (points[i].y + yoffset);
- xpoints2[i].x = XLOG2DEV_2 (points[i].x + xoffset);
- xpoints2[i].y = YLOG2DEV_2 (points[i].y + yoffset);
- CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
+ xpoints1[i].x = (short)XLOG2DEV (points[i].x + xoffset);
+ xpoints1[i].y = (short)YLOG2DEV (points[i].y + yoffset);
+ xpoints2[i].x = (short)XLOG2DEV_2 (points[i].x + xoffset);
+ xpoints2[i].y = (short)YLOG2DEV_2 (points[i].y + yoffset);
+ CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
}
- // Close figure for XDrawLines (not needed for XFillPolygon)
- xpoints1[i].x = xpoints1[0].x;
- xpoints1[i].y = xpoints1[0].y;
- xpoints2[i].x = xpoints2[0].x;
- xpoints2[i].y = xpoints2[0].y;
+ // Close figure for XDrawLines (not needed for XFillPolygon)
+ xpoints1[i].x = xpoints1[0].x;
+ xpoints1[i].y = xpoints1[0].y;
+ xpoints2[i].x = xpoints2[0].x;
+ xpoints2[i].y = xpoints2[0].y;
- if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+ if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
{
- SetBrush (m_brush);
- XSetFillRule ((Display*) m_display, (GC) m_gc, fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);
- XFillPolygon ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints1, n, Complex, 0);
- XSetFillRule ((Display*) m_display, (GC) m_gc, EvenOddRule); // default mode
- if (m_window && m_window->GetBackingPixmap())
- {
- XSetFillRule ((Display*) m_display,(GC) m_gcBacking,
- fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);
- XFillPolygon ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints2, n, Complex, 0);
- XSetFillRule ((Display*) m_display,(GC) m_gcBacking, EvenOddRule); // default mode
- }
- }
+ SetBrush (m_brush);
+ XSetFillRule ((Display*) m_display, (GC) m_gc, fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);
+ XFillPolygon ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints1, n, Complex, 0);
+ XSetFillRule ((Display*) m_display, (GC) m_gc, EvenOddRule); // default mode
+ if (m_window && m_window->GetBackingPixmap())
+ {
+ XSetFillRule ((Display*) m_display,(GC) m_gcBacking,
+ fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);
+ XFillPolygon ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints2, n, Complex, 0);
+ XSetFillRule ((Display*) m_display,(GC) m_gcBacking, EvenOddRule); // default mode
+ }
+ }
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
{
- if (m_autoSetting)
- SetPen (m_pen);
- XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints1, n + 1, 0);
+ if (m_autoSetting)
+ SetPen (m_pen);
+ XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints1, n + 1, 0);
- if (m_window && m_window->GetBackingPixmap())
- XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints2, n + 1, 0);
+ if (m_window && m_window->GetBackingPixmap())
+ XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints2, n + 1, 0);
}
- delete[]xpoints1;
- delete[]xpoints2;
-};
-
-void wxWindowDC::DrawPolygon( wxList *list, long xoffset,
- long yoffset, int fillStyle )
-{
- if (!Ok()) return;
-
- int n = list->Number();
- wxPoint *points = new wxPoint[n];
-
- int i = 0;
- for(wxNode *node = list->First(); node; node = node->Next()) {
- wxPoint *point = (wxPoint *)node->Data();
- points[i].x = point->x;
- points[i++].y = point->y;
- }
- DrawPolygon(n, points, xoffset, yoffset,fillStyle);
- delete[] points;
-};
+ delete[]xpoints1;
+ delete[]xpoints2;
+}
-void wxWindowDC::DrawRectangle( long x, long y, long width, long height )
+void wxWindowDCImpl::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
- if (!Ok()) return;
-
-// FreeGetPixelCache();
+ wxCHECK_RET( IsOk(), "invalid dc" );
- int xd, yd, wfd, hfd, wd, hd;
+ int xd, yd, wfd, hfd, wd, hd;
- xd = XLOG2DEV(x);
- yd = YLOG2DEV(y);
- wfd = XLOG2DEVREL(width);
- wd = wfd - WX_GC_CF;
- hfd = YLOG2DEVREL(height);
- hd = hfd - WX_GC_CF;
+ xd = XLOG2DEV(x);
+ yd = YLOG2DEV(y);
+ wfd = XLOG2DEVREL(width);
+ wd = wfd - WX_GC_CF;
+ hfd = YLOG2DEVREL(height);
+ hd = hfd - WX_GC_CF;
- if (wfd == 0 || hfd == 0) return;
- if (wd < 0) { wd = - wd; xd = xd - wd; }
- if (hd < 0) { hd = - hd; yd = yd - hd; }
+ if (wfd == 0 || hfd == 0) return;
+ if (wd < 0) { wd = - wd; xd = xd - wd; }
+ if (hd < 0) { hd = - hd; yd = yd - hd; }
- if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+ if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
{
- SetBrush (m_brush);
- XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wfd, hfd);
+ SetBrush (m_brush);
+ XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wfd, hfd);
- if (m_window && m_window->GetBackingPixmap())
- XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ if (m_window && m_window->GetBackingPixmap())
+ XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
XLOG2DEV_2 (x), YLOG2DEV_2 (y),
wfd, hfd);
}
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
{
- if (m_autoSetting)
- SetPen (m_pen);
- XDrawRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd);
+ if (m_autoSetting)
+ SetPen (m_pen);
+ XDrawRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd);
- if (m_window && m_window->GetBackingPixmap())
- XDrawRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ if (m_window && m_window->GetBackingPixmap())
+ XDrawRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
XLOG2DEV_2 (x), YLOG2DEV_2 (y),
wd, hd);
}
- CalcBoundingBox (x, y);
- CalcBoundingBox (x + width, y + height);
-};
+ CalcBoundingBox (x, y);
+ CalcBoundingBox (x + width, y + height);
+}
-void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height, double radius )
+void wxWindowDCImpl::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
{
- if (!Ok()) return;
-
-// FreeGetPixelCache();
+ wxCHECK_RET( IsOk(), "invalid dc" );
- // If radius is negative, it's a proportion of the smaller dimension.
+ // If radius is negative, it's a proportion of the smaller dimension.
- if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
+ if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
- int xd = XLOG2DEV (x);
- int yd = YLOG2DEV (y);
- int rd = XLOG2DEVREL ((long) radius);
- int wd = XLOG2DEVREL (width) - WX_GC_CF;
- int hd = YLOG2DEVREL (height) - WX_GC_CF;
+ int xd = XLOG2DEV (x);
+ int yd = YLOG2DEV (y);
+ int rd = XLOG2DEVREL ((long) radius);
+ int wd = XLOG2DEVREL (width) - WX_GC_CF;
+ int hd = YLOG2DEVREL (height) - WX_GC_CF;
- int rw_d = rd * 2;
- int rh_d = rw_d;
+ int rw_d = rd * 2;
+ int rh_d = rw_d;
- // If radius is zero use DrawRectangle() instead to avoid
- // X drawing errors with small radii
- if (rd == 0)
- {
- DrawRectangle( x, y, width, height );
- return;
- }
+ // If radius is zero use DrawRectangle() instead to avoid
+ // X drawing errors with small radii
+ if (rd == 0)
+ {
+ DoDrawRectangle( x, y, width, height );
+ return;
+ }
- // Draw nothing if transformed w or h is 0
- if (wd == 0 || hd == 0) return;
+ // Draw nothing if transformed w or h is 0
+ if (wd == 0 || hd == 0) return;
- // CMB: adjust size if outline is drawn otherwise the result is
- // 1 pixel too wide and high
- if (m_pen.GetStyle() != wxTRANSPARENT)
- {
- wd--;
- hd--;
- }
+ // CMB: adjust size if outline is drawn otherwise the result is
+ // 1 pixel too wide and high
+ if (m_pen.GetStyle() != wxTRANSPARENT)
+ {
+ wd--;
+ hd--;
+ }
- // CMB: ensure dd is not larger than rectangle otherwise we
- // get an hour glass shape
- if (rw_d > wd) rw_d = wd;
- if (rw_d > hd) rw_d = hd;
- rd = rw_d / 2;
+ // CMB: ensure dd is not larger than rectangle otherwise we
+ // get an hour glass shape
+ if (rw_d > wd) rw_d = wd;
+ if (rw_d > hd) rw_d = hd;
+ rd = rw_d / 2;
- // For backing pixmap
- int xd2 = XLOG2DEV_2 (x);
- int yd2 = YLOG2DEV_2 (y);
- int rd2 = XLOG2DEVREL ((long) radius);
- int wd2 = XLOG2DEVREL (width) ;
- int hd2 = YLOG2DEVREL (height) ;
+ // For backing pixmap
+ int xd2 = XLOG2DEV_2 (x);
+ int yd2 = YLOG2DEV_2 (y);
+ int rd2 = XLOG2DEVREL ((long) radius);
+ int wd2 = XLOG2DEVREL (width) ;
+ int hd2 = YLOG2DEVREL (height) ;
- int rw_d2 = rd2 * 2;
- int rh_d2 = rw_d2;
+ int rw_d2 = rd2 * 2;
+ int rh_d2 = rw_d2;
- if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
- {
- SetBrush (m_brush);
-
- XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
- wd - rw_d, hd);
- XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
- wd, hd - rh_d);
-
- // Arcs start from 3 o'clock, positive angles anticlockwise
- // Top-left
- XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd,
- rw_d, rh_d, 90 * 64, 90 * 64);
- // Top-right
- XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d, yd,
-// rw_d, rh_d, 0, 90 * 64);
- rw_d, rh_d, 0, 91 * 64);
- // Bottom-right
- XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d,
- yd + hd - rh_d,
-// rw_d, rh_d, 270 * 64, 90 * 64);
- rw_d, rh_d, 269 * 64, 92 * 64);
- // Bottom-left
- XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
- rw_d, rh_d, 180 * 64, 90 * 64);
+ if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
+ {
+ SetBrush (m_brush);
+
+ XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
+ wd - rw_d, hd);
+ XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
+ wd, hd - rh_d);
+
+ // Arcs start from 3 o'clock, positive angles anticlockwise
+ // Top-left
+ XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd,
+ rw_d, rh_d, 90 * 64, 90 * 64);
+ // Top-right
+ XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d, yd,
+ // rw_d, rh_d, 0, 90 * 64);
+ rw_d, rh_d, 0, 91 * 64);
+ // Bottom-right
+ XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d,
+ yd + hd - rh_d,
+ // rw_d, rh_d, 270 * 64, 90 * 64);
+ rw_d, rh_d, 269 * 64, 92 * 64);
+ // Bottom-left
+ XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
+ rw_d, rh_d, 180 * 64, 90 * 64);
- if (m_window && m_window->GetBackingPixmap())
+ if (m_window && m_window->GetBackingPixmap())
+ {
+ XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2 + rd2, yd2, wd2 - rw_d2, hd2);
+ XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2, yd2 + rd2, wd2, hd2 - rh_d2);
+
+ XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2, yd2, rw_d2, rh_d2, 90 * 64, 90 * 64);
+ XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2 + wd2 - rw_d2, yd2,
+ // rw_d2, rh_d2, 0, 90 * 64);
+ rw_d2, rh_d2, 0, 91 * 64);
+ XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2 + wd2 - rw_d2,
+ yd2 + hd2 - rh_d2,
+ // rw_d2, rh_d2, 270 * 64, 90 * 64);
+ rw_d2, rh_d2, 269 * 64, 92 * 64);
+ XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2, yd2 + hd2 - rh_d2,
+ rw_d2, rh_d2, 180 * 64, 90 * 64);
+ }
+ }
+
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
{
- XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2 + rd2, yd2, wd2 - rw_d2, hd2);
- XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2, yd2 + rd2, wd2, hd2 - rh_d2);
-
- XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2, yd2, rw_d2, rh_d2, 90 * 64, 90 * 64);
- XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2 + wd2 - rw_d2, yd2,
-// rw_d2, rh_d2, 0, 90 * 64);
- rw_d2, rh_d2, 0, 91 * 64);
- XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2 + wd2 - rw_d2,
- yd2 + hd2 - rh_d2,
-// rw_d2, rh_d2, 270 * 64, 90 * 64);
- rw_d2, rh_d2, 269 * 64, 92 * 64);
- XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2, yd2 + hd2 - rh_d2,
- rw_d2, rh_d2, 180 * 64, 90 * 64);
+ SetPen (m_pen);
+ XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
+ xd + wd - rd + 1, yd);
+ XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd + hd,
+ xd + wd - rd, yd + hd);
+
+ XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
+ xd, yd + hd - rd);
+ XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd, yd + rd,
+ xd + wd, yd + hd - rd + 1);
+ XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd,
+ rw_d, rh_d, 90 * 64, 90 * 64);
+ XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d, yd,
+ // rw_d, rh_d, 0, 90 * 64);
+ rw_d, rh_d, 0, 91 * 64);
+ XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d,
+ yd + hd - rh_d,
+ rw_d, rh_d, 269 * 64, 92 * 64);
+ XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
+ rw_d, rh_d, 180 * 64, 90 * 64);
+
+ if (m_window && m_window->GetBackingPixmap())
+ {
+ XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2 + rd2, yd2,
+ xd2 + wd2 - rd2 + 1, yd2);
+ XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2 + rd2, yd2 + hd2,
+ xd2 + wd2 - rd2, yd2 + hd2);
+
+ XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2, yd2 + rd2,
+ xd2, yd2 + hd2 - rd2);
+ XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2 + wd2, yd2 + rd2,
+ xd2 + wd2, yd2 + hd2 - rd2 + 1);
+ XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2, yd2,
+ rw_d2, rh_d2, 90 * 64, 90 * 64);
+ XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2 + wd2 - rw_d2, yd2,
+ // rw_d2, rh_d2, 0, 90 * 64);
+ rw_d2, rh_d2, 0, 91 * 64);
+ XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2 + wd2 - rw_d2,
+ yd2 + hd2 - rh_d2,
+ rw_d2, rh_d2, 269 * 64, 92 * 64);
+ XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ xd2, yd2 + hd2 - rh_d2,
+ rw_d2, rh_d2, 180 * 64, 90 * 64);
+ }
}
- }
+ CalcBoundingBox (x, y);
+ CalcBoundingBox (x + width, y + height);
+}
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
- {
- SetPen (m_pen);
- XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
- xd + wd - rd + 1, yd);
- XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd + hd,
- xd + wd - rd, yd + hd);
-
- XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
- xd, yd + hd - rd);
- XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd, yd + rd,
- xd + wd, yd + hd - rd + 1);
- XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd,
- rw_d, rh_d, 90 * 64, 90 * 64);
- XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d, yd,
-// rw_d, rh_d, 0, 90 * 64);
- rw_d, rh_d, 0, 91 * 64);
- XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d,
- yd + hd - rh_d,
- rw_d, rh_d, 269 * 64, 92 * 64);
- XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
- rw_d, rh_d, 180 * 64, 90 * 64);
+void wxWindowDCImpl::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
+{
+ wxCHECK_RET( IsOk(), "invalid dc" );
- if (m_window && m_window->GetBackingPixmap())
+ // Check for negative width and height
+ if (height < 0)
{
- XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2 + rd2, yd2,
- xd2 + wd2 - rd2 + 1, yd2);
- XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2 + rd2, yd2 + hd2,
- xd2 + wd2 - rd2, yd2 + hd2);
-
- XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2, yd2 + rd2,
- xd2, yd2 + hd2 - rd2);
- XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2 + wd2, yd2 + rd2,
- xd2 + wd2, yd2 + hd2 - rd2 + 1);
- XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2, yd2,
- rw_d2, rh_d2, 90 * 64, 90 * 64);
- XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2 + wd2 - rw_d2, yd2,
-// rw_d2, rh_d2, 0, 90 * 64);
- rw_d2, rh_d2, 0, 91 * 64);
- XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2 + wd2 - rw_d2,
- yd2 + hd2 - rh_d2,
- rw_d2, rh_d2, 269 * 64, 92 * 64);
- XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- xd2, yd2 + hd2 - rh_d2,
- rw_d2, rh_d2, 180 * 64, 90 * 64);
+ y = y + height;
+ height = - height ;
+ }
+
+ if (width < 0)
+ {
+ x = x + width;
+ width = - width ;
+ }
+
+ static const int angle = 23040;
+
+ int xd, yd, wd, hd;
+
+ xd = XLOG2DEV(x);
+ yd = YLOG2DEV(y);
+ wd = XLOG2DEVREL(width) ;
+ hd = YLOG2DEVREL(height) ;
+
+ if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
+ {
+ SetBrush (m_brush);
+ XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);
+ if (m_window && m_window->GetBackingPixmap())
+ XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ XLOG2DEV_2 (x), YLOG2DEV_2 (y),
+ XLOG2DEVREL (width) - WX_GC_CF,
+ YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
}
- }
- CalcBoundingBox (x, y);
- CalcBoundingBox (x + width, y + height);
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
+ {
+ if (m_autoSetting)
+ SetPen (m_pen);
+ XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);
+ if (m_window && m_window->GetBackingPixmap())
+ XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ XLOG2DEV_2 (x), YLOG2DEV_2 (y),
+ XLOG2DEVREL (width) - WX_GC_CF,
+ YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
+ }
+ CalcBoundingBox (x, y);
+ CalcBoundingBox (x + width, y + height);
-};
+}
-void wxWindowDC::DrawEllipse( long x, long y, long width, long height )
+bool wxWindowDCImpl::CanDrawBitmap() const
{
- if (!Ok()) return;
-
- // Check for negative width and height
- if (height < 0)
- {
- y = y + height;
- height = - height ;
- }
+ wxCHECK_MSG( IsOk(), false, "invalid dc" );
- if (width < 0)
- {
- x = x + width;
- width = - width ;
- }
+ return true;
+}
+
+// TODO: use scaled Blit e.g. as per John Price's implementation
+// in Contrib/Utilities
+bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
+ wxCoord width, wxCoord height,
+ wxDC *source, wxCoord xsrc, wxCoord ysrc,
+ wxRasterOperationMode rop, bool useMask,
+ wxCoord xsrcMask, wxCoord ysrcMask )
+{
+ wxCHECK_MSG( IsOk(), false, "invalid dc" );
-// FreeGetPixelCache();
+ wxWindowDC const * sourceDC = wxDynamicCast(source, wxWindowDC);
+ wxCHECK_MSG( sourceDC, false, "Blit source DC must be wxWindowDCImpl or derived class." );
- static const int angle = 23040;
+ // cast is safe in virtue of the above wxCHECK_MSG()
+ const wxWindowDCImpl * const
+ srcImpl = static_cast<const wxWindowDCImpl *>(sourceDC->GetImpl());
+ WXDisplay * const srcDpy = srcImpl->m_display;
- int xd, yd, wd, hd;
- xd = XLOG2DEV(x);
- yd = YLOG2DEV(y);
- wd = XLOG2DEVREL(width) ;
- hd = YLOG2DEVREL(height) ;
+ // Be sure that foreground pixels (1) of the Icon will be painted with
+ // foreground colour. [m_textForegroundColour] Background pixels (0)
+ // will be painted with backgound colour (m_textBackgroundColour)
+ // Using ::SetPen is horribly slow, so avoid doing it
+ WXPixel oldBackgroundPixel = -1;
+ WXPixel oldForegroundPixel = -1;
- if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+ if (m_textBackgroundColour.IsOk())
{
- SetBrush (m_brush);
- XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);
- if (m_window && m_window->GetBackingPixmap())
- XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- XLOG2DEV_2 (x), YLOG2DEV_2 (y),
- XLOG2DEVREL (width) - WX_GC_CF,
- YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
+ oldBackgroundPixel = m_backgroundPixel;
+ WXPixel pixel = m_textBackgroundColour.AllocColour(m_display);
+
+ XSetBackground ((Display*) m_display, (GC) m_gc, pixel);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetBackground ((Display*) m_display,(GC) m_gcBacking,
+ pixel);
}
+ if (m_textForegroundColour.IsOk())
+ {
+ oldForegroundPixel = m_currentColour.GetPixel();
+
+ if( m_textForegroundColour.GetPixel() <= -1 )
+ CalculatePixel( m_textForegroundColour,
+ m_textForegroundColour, true);
+
+ WXPixel pixel = m_textForegroundColour.GetPixel();
+ if (pixel > -1)
+ SetForegroundPixelWithLogicalFunction(pixel);
+ }
+
+ // Do bitmap scaling if necessary
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+ wxBitmap *scaledBitmap = NULL;
+ Pixmap sourcePixmap = (Pixmap) NULL;
+ double scaleX, scaleY;
+ GetUserScale(& scaleX, & scaleY);
+ bool retVal = false;
+
+ /* TODO: use the mask origin when drawing transparently */
+ if (xsrcMask == -1 && ysrcMask == -1)
{
- if (m_autoSetting)
- SetPen (m_pen);
- XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);
- if (m_window && m_window->GetBackingPixmap())
- XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- XLOG2DEV_2 (x), YLOG2DEV_2 (y),
- XLOG2DEVREL (width) - WX_GC_CF,
- YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
+ xsrcMask = xsrc; ysrcMask = ysrc;
}
- CalcBoundingBox (x, y);
- CalcBoundingBox (x + width, y + height);
-};
+ // Sorry, can't scale masks just yet
+ if (!useMask && (scaleX != 1.0 || scaleY != 1.0) && sourceDC->IsKindOf(CLASSINFO(wxMemoryDC)))
+ {
+ wxMemoryDC* memDC = (wxMemoryDC*) sourceDC;
+ wxBitmap& bitmap = memDC->GetSelectedBitmap();
-bool wxWindowDC::CanDrawBitmap(void) const
-{
- return TRUE;
-};
+ wxASSERT_MSG( (bitmap.IsOk()), "Bad source bitmap in wxWindowDCImpl::Blit");
-/* Used when copying between drawables on different (Display*) m_displays.
- Not very fast, but better than giving up.
- */
+ wxImage image = bitmap.ConvertToImage();
+ if (!image.IsOk())
+ {
+ sourcePixmap = (Pixmap) bitmap.GetDrawable();
+ }
+ else
+ {
+ int scaledW = (int) (bitmap.GetWidth() * scaleX);
+ int scaledH = (int) (bitmap.GetHeight() * scaleY);
-static void XCopyRemote(Display *src_display, Display *dest_display,
- Drawable src, Drawable dest,
- GC destgc,
- int srcx, int srcy,
- unsigned int w, unsigned int h,
- int destx, int desty,
- bool more, XImage **cache)
-{
- XImage *image, *destimage;
- Colormap destcm, srccm;
-#define CACHE_SIZE 256
- unsigned int i, j;
- unsigned long cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];
- int k, cache_pos, all_cache;
-
- if (!cache || !*cache)
- image = XGetImage(src_display, src, srcx, srcy, w, h, AllPlanes, ZPixmap);
- else
- image = *cache;
-
- destimage = XGetImage(dest_display, dest, destx, desty, w, h, AllPlanes, ZPixmap);
-
- srccm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) src_display);
- destcm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dest_display);
-
- cache_pos = 0;
- all_cache = FALSE;
-
- for (i = 0; i < w; i++)
- for (j = 0; j < h; j++) {
- unsigned long pixel;
- XColor xcol;
-
- pixel = XGetPixel(image, i, j);
- for (k = cache_pos; k--; )
- if (cachesrc[k] == pixel) {
- pixel = cachedest[k];
- goto install;
+ image = image.Scale(scaledW, scaledH);
+ scaledBitmap = new wxBitmap(image);
+ sourcePixmap = (Pixmap) scaledBitmap->GetDrawable();
+ }
}
- if (all_cache)
- for (k = CACHE_SIZE; k-- > cache_pos; )
- if (cachesrc[k] == pixel) {
- pixel = cachedest[k];
- goto install;
- }
-
- cachesrc[cache_pos] = xcol.pixel = pixel;
- XQueryColor(src_display, srccm, &xcol);
- if (!XAllocColor(dest_display, destcm, &xcol))
- xcol.pixel = 0;
- cachedest[cache_pos] = pixel = xcol.pixel;
-
- if (++cache_pos >= CACHE_SIZE) {
- cache_pos = 0;
- all_cache = TRUE;
- }
-
- install:
- XPutPixel(destimage, i, j, pixel);
+ else
+ {
+ sourcePixmap = (Pixmap) srcImpl->m_pixmap;
}
- XPutImage(dest_display, dest, destgc, destimage, 0, 0, destx, desty, w, h);
- XDestroyImage(destimage);
+ if (m_pixmap && sourcePixmap)
+ {
+ /* MATTHEW: [9] */
+ wxRasterOperationMode orig = m_logicalFunction;
- if (more)
- *cache = image;
- else
- XDestroyImage(image);
-}
+ SetLogicalFunction (rop);
-void wxWindowDC::DrawIcon( const wxIcon &icon, long x, long y, bool useMask )
-{
- if (!Ok()) return;
-
- if (!icon.Ok()) return;
-
-// FreeGetPixelCache();
-
- // Be sure that foreground pixels (1) of
- // the Icon will be painted with pen colour. [m_pen.SetColour()]
- // Background pixels (0) will be painted with
- // last selected background color. [::SetBackground]
- if (m_pen.Ok() && m_autoSetting)
- SetPen (m_pen);
-
- int width, height;
- Pixmap iconPixmap = (Pixmap) icon.GetPixmap();
- width = icon.GetWidth();
- height = icon.GetHeight();
- if (icon.GetDisplay() == m_display)
- {
- if (icon.GetDepth() <= 1)
- {
- XCopyPlane ((Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
- 0, 0, width, height,
- (int) XLOG2DEV (x), (int) YLOG2DEV (y), 1);
- }
- else
- {
- XCopyArea ((Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
- 0, 0, width, height,
- (int) XLOG2DEV (x), (int) YLOG2DEV (y));
- }
-
-
- if (m_window && m_window->GetBackingPixmap())
+ if (m_display != srcDpy)
+ {
+ XImage *cache = NULL;
+
+ if (m_window && m_window->GetBackingPixmap())
+ XCopyRemote((Display*) srcDpy, (Display*) m_display,
+ (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),
+ (GC) m_gcBacking,
+ source->LogicalToDeviceX (xsrc),
+ source->LogicalToDeviceY (ysrc),
+ source->LogicalToDeviceXRel(width),
+ source->LogicalToDeviceYRel(height),
+ XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest),
+ True, &cache);
+
+ if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
+ {
+ wxMemoryDC *memDC = (wxMemoryDC *)source;
+ wxBitmap& sel = memDC->GetSelectedBitmap();
+ if ( sel.IsOk() && sel.GetMask() && sel.GetMask()->GetBitmap() )
+ {
+ XSetClipMask ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
+ XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
+ }
+ }
+
+ XCopyRemote((Display*) srcDpy, (Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,
+ source->LogicalToDeviceX (xsrc),
+ source->LogicalToDeviceY (ysrc),
+ source->LogicalToDeviceXRel(width),
+ source->LogicalToDeviceYRel(height),
+ XLOG2DEV (xdest), YLOG2DEV (ydest),
+ False, &cache);
+
+ if ( useMask )
+ {
+ if ( m_clipRegion )
+ XSetRegion ((Display*) m_display, (GC) m_gc,
+ (Region) m_clipRegion);
+ else
+ XSetClipMask ((Display*) m_display, (GC) m_gc, None);
+
+ XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
+ }
+
+ } else
+ { //XGCValues values;
+ //XGetGCValues((Display*)m_display, (GC)m_gc, GCForeground, &values);
+
+ if (m_window && m_window->GetBackingPixmap())
+ {
+ // +++ MARKUS (mho@comnets.rwth-aachen): error on blitting bitmaps with depth 1
+ if (source->IsKindOf(CLASSINFO(wxMemoryDC)) && ((wxMemoryDC*) source)->GetSelectedBitmap().GetDepth() == 1)
+ {
+ XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ source->LogicalToDeviceX (xsrc),
+ source->LogicalToDeviceY (ysrc),
+ source->LogicalToDeviceXRel(width),
+ source->LogicalToDeviceYRel(height),
+ XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest), 1);
+ }
+ else
+ {
+ XCopyArea ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ source->LogicalToDeviceX (xsrc),
+ source->LogicalToDeviceY (ysrc),
+ source->LogicalToDeviceXRel(width),
+ source->LogicalToDeviceYRel(height),
+ XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest));
+ }
+ }
+ if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
+ {
+ wxMemoryDC *memDC = (wxMemoryDC *)source;
+ wxBitmap& sel = memDC->GetSelectedBitmap();
+ if ( sel.IsOk() && sel.GetMask() && sel.GetMask()->GetBitmap() )
+ {
+ XSetClipMask ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetBitmap());
+ XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
+ }
+ }
+
+ // Check if we're copying from a mono bitmap
+ if (source->IsKindOf(CLASSINFO(wxMemoryDC)) &&
+ ((wxMemoryDC*)source)->GetSelectedBitmap().IsOk() &&
+ (((wxMemoryDC*)source)->GetSelectedBitmap().GetDepth () == 1))
+ {
+ XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,
+ source->LogicalToDeviceX (xsrc),
+ source->LogicalToDeviceY (ysrc),
+ source->LogicalToDeviceXRel(width),
+ source->LogicalToDeviceYRel(height),
+ XLOG2DEV (xdest), YLOG2DEV (ydest), 1);
+ }
+ else
+ {
+ XCopyArea ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,
+ source->LogicalToDeviceX (xsrc),
+ source->LogicalToDeviceY (ysrc),
+ source->LogicalToDeviceXRel(width),
+ source->LogicalToDeviceYRel(height),
+ XLOG2DEV (xdest), YLOG2DEV (ydest));
+
+ }
+ if ( useMask )
+ {
+ if ( m_clipRegion )
+ XSetRegion ((Display*) m_display, (GC) m_gc,
+ (Region) m_clipRegion);
+ else
+ XSetClipMask ((Display*) m_display, (GC) m_gc, None);
+
+ XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
+ }
+
+ } /* Remote/local (Display*) m_display */
+ CalcBoundingBox (xdest, ydest);
+ CalcBoundingBox (xdest + width, ydest + height);
+
+ SetLogicalFunction(orig);
+
+ retVal = true;
+ }
+ if (scaledBitmap) delete scaledBitmap;
+
+ if (oldBackgroundPixel > -1)
{
- if (icon.GetDepth() <= 1)
- {
- XCopyPlane ((Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- 0, 0, width, height, (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y), 1);
- }
- else
- {
- XCopyArea ((Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- 0, 0, width, height,
- (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y));
- }
+ XSetBackground ((Display*) m_display, (GC) m_gc, oldBackgroundPixel);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetBackground ((Display*) m_display,(GC) m_gcBacking,
+ oldBackgroundPixel);
}
- } else { /* Remote copy (different (Display*) m_displays) */
- XImage *cache = NULL;
- if (m_window && m_window->GetBackingPixmap())
- XCopyRemote((Display*) icon.GetDisplay(), (Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),
- (GC) m_gcBacking, 0, 0, width, height,
- (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y), TRUE, &cache);
- XCopyRemote((Display*) icon.GetDisplay(), (Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
- 0, 0, width, height,
- (int) XLOG2DEV (x), (int) YLOG2DEV (y), FALSE, &cache);
+ if (oldForegroundPixel > -1)
+ {
+ XSetForeground ((Display*) m_display, (GC) m_gc, oldForegroundPixel);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetForeground ((Display*) m_display,(GC) m_gcBacking,
+ oldForegroundPixel);
}
- CalcBoundingBox (x, y);
-};
+ return retVal;
+}
-bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,
- wxDC *source, long xsrc, long ysrc, int rop, bool useMask )
+void wxWindowDCImpl::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
{
- if (!Ok()) return FALSE;
+ wxCHECK_RET( IsOk(), "invalid dc" );
- wxASSERT_MSG( (source->IsKindOf(CLASSINFO(wxWindowDC))), "Blit source DC must be wxWindowDC or derived class." );
+ // Since X draws from the baseline of the text, must add the text height
+ int cx = 0;
+ int cy = 0;
+ int ascent = 0;
+ int slen = text.length();
- wxWindowDC* sourceDC = (wxWindowDC*) source;
-
-// FreeGetPixelCache();
+ // Set FillStyle, otherwise X will use current stipple!
+ XGCValues gcV, gcBackingV;
- // Be sure that foreground pixels (1) of
- // the Icon will be painted with pen colour. [m_pen.SetColour()]
- // Background pixels (0) will be painted with
- // last selected background color. [::SetBackground]
- if (m_pen.Ok() && m_autoSetting)
- SetPen (m_pen);
-
- if (m_pixmap && sourceDC->m_pixmap)
+ XGetGCValues ((Display*) m_display, (GC)m_gc, GCFillStyle, &gcV);
+ XSetFillStyle ((Display*) m_display, (GC) m_gc, FillSolid);
+ if (m_window && m_window->GetBackingPixmap())
{
- /* MATTHEW: [9] */
- int orig = m_logicalFunction;
+ XGetGCValues ((Display*) m_display, (GC)m_gcBacking, GCFillStyle,
+ &gcBackingV );
+ XSetFillStyle ((Display*) m_display, (GC) m_gcBacking, FillSolid);
+ }
+
+ if (m_font.IsOk())
+ wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
+ text, &cx, &cy, &ascent, NULL);
- SetLogicalFunction (rop);
+ // First draw a rectangle representing the text background, if a text
+ // background is specified
+ if (m_textBackgroundColour.IsOk () && (m_backgroundMode != wxTRANSPARENT))
+ {
+ wxColour oldPenColour = m_currentColour;
+ m_currentColour = m_textBackgroundColour;
+ bool sameColour = (oldPenColour.IsOk () && m_textBackgroundColour.IsOk () &&
+ (oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
+ (oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
+ (oldPenColour.Green () == m_textBackgroundColour.Green ()));
- if (m_display != sourceDC->m_display)
- {
- XImage *cache = NULL;
+ // This separation of the big && test required for gcc2.7/HP UX 9.02
+ // or pixel value can be corrupted!
+ sameColour = (sameColour &&
+ (oldPenColour.GetPixel() == m_textBackgroundColour.GetPixel()));
- if (m_window && m_window->GetBackingPixmap())
- XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display,
- (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),
- (GC) m_gcBacking,
- source->LogicalToDeviceX (xsrc),
- source->LogicalToDeviceY (ysrc),
- source->LogicalToDeviceXRel(width),
- source->LogicalToDeviceYRel(height),
- XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest),
- TRUE, &cache);
-
- if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
+ if (!sameColour || !GET_OPTIMIZATION)
{
- wxMemoryDC *memDC = (wxMemoryDC *)source;
- wxBitmap& sel = memDC->GetBitmap();
- if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetPixmap() )
+ WXPixel pixel = m_textBackgroundColour.AllocColour(m_display);
+ m_currentColour = m_textBackgroundColour;
+
+ // Set the GC to the required colour
+ if (pixel > -1)
{
- XSetClipMask ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetPixmap());
- XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
+ XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
}
}
+ else
+ m_textBackgroundColour = oldPenColour ;
- XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
- source->LogicalToDeviceX (xsrc),
- source->LogicalToDeviceY (ysrc),
- source->LogicalToDeviceXRel(width),
- source->LogicalToDeviceYRel(height),
- XLOG2DEV (xdest), YLOG2DEV (ydest),
- FALSE, &cache);
-
- if ( useMask )
- {
- XSetClipMask ((Display*) m_display, (GC) m_gc, None);
- XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
- }
-
- } else
- {
- if (m_window && m_window->GetBackingPixmap())
- {
-// +++ MARKUS (mho@comnets.rwth-aachen): error on blitting bitmaps with depth 1
- if (source->IsKindOf(CLASSINFO(wxMemoryDC)) && ((wxMemoryDC*) source)->GetBitmap().GetDepth() == 1)
- {
- XCopyPlane ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- source->LogicalToDeviceX (xsrc),
- source->LogicalToDeviceY (ysrc),
- source->LogicalToDeviceXRel(width),
- source->LogicalToDeviceYRel(height),
- XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest), 1);
- }
- else
- {
- XCopyArea ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- source->LogicalToDeviceX (xsrc),
- source->LogicalToDeviceY (ysrc),
- source->LogicalToDeviceXRel(width),
- source->LogicalToDeviceYRel(height),
- XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest));
- }
+ XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y), cx, cy);
+ if (m_window && m_window->GetBackingPixmap())
+ XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ XLOG2DEV_2 (x), YLOG2DEV_2 (y), cx, cy);
}
- if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
+
+ // Now set the text foreground and draw the text
+ if (m_textForegroundColour.IsOk ())
{
- wxMemoryDC *memDC = (wxMemoryDC *)source;
- wxBitmap& sel = memDC->GetBitmap();
- if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetPixmap() )
+ wxColour oldPenColour = m_currentColour;
+ m_currentColour = m_textForegroundColour;
+ bool sameColour = (oldPenColour.IsOk () && m_currentColour.IsOk () &&
+ (oldPenColour.Red () == m_currentColour.Red ()) &&
+ (oldPenColour.Blue () == m_currentColour.Blue ()) &&
+ (oldPenColour.Green () == m_currentColour.Green ()) &&
+ (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
+
+ if (!sameColour || !GET_OPTIMIZATION)
{
- XSetClipMask ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetPixmap());
- XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
- }
- }
+ WXPixel pixel = CalculatePixel(m_textForegroundColour,
+ m_currentColour, false);
- // Check if we're copying from a mono bitmap
- if (source->IsKindOf(CLASSINFO(wxMemoryDC)) &&
- ((wxMemoryDC*)source)->GetBitmap().Ok() && (((wxMemoryDC*)source)->GetBitmap().GetDepth () == 1))
- {
- XCopyPlane ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
- source->LogicalToDeviceX (xsrc),
- source->LogicalToDeviceY (ysrc),
- source->LogicalToDeviceXRel(width),
- source->LogicalToDeviceYRel(height),
- XLOG2DEV (xdest), YLOG2DEV (ydest), 1);
- }
- else
- {
- XCopyArea ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
- source->LogicalToDeviceX (xsrc),
- source->LogicalToDeviceY (ysrc),
- source->LogicalToDeviceXRel(width),
- source->LogicalToDeviceYRel(height),
- XLOG2DEV (xdest), YLOG2DEV (ydest));
-
- }
- if ( useMask )
- {
- XSetClipMask ((Display*) m_display, (GC) m_gc, None);
- XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
+ // Set the GC to the required colour
+ if (pixel > -1)
+ {
+ XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
+ }
+ }
+ else
+ m_textForegroundColour = oldPenColour;
}
- } /* Remote/local (Display*) m_display */
- CalcBoundingBox (xdest, ydest);
- CalcBoundingBox (xdest + width, ydest + height);
-
- SetLogicalFunction(orig);
-
- return TRUE;
- }
- return FALSE;
-};
+ // We need to add the ascent, not the whole height, since X draws at the
+ // point above the descender.
+#if 0
+ if (use16)
+ XDrawString16((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent,
+ (XChar2b *)(char*) (const char*) text, slen);
+ else
+#endif // 0
+#if wxMOTIF_NEW_FONT_HANDLING
+ XFontSet fset = (XFontSet) m_font.GetFontSet (m_userScaleY * m_logicalScaleY, m_display);
+ XmbDrawString((Display*) m_display, (Pixmap) m_pixmap, fset, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent, text, slen);
+#else
+ XDrawString((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent, text, slen);
+#endif
-/* Helper function for 16-bit fonts */
-static int str16len(const char *s)
-{
- int count = 0;
+ if (m_window && m_window->GetBackingPixmap()) {
+#if 0
+ if (use16)
+ XDrawString16((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+ XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
+ (XChar2b *)(char*) (const char*) text, slen);
+ else
+#endif // 0
+#if wxMOTIF_NEW_FONT_HANDLING
+ XmbDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), fset, (GC) m_gcBacking,
+ XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
+ text.mb_str(), slen);
+#else
+ XDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+ XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
+ text.mb_str(), slen);
+#endif
+ }
- while (s[0] && s[1]) {
- count++;
- s += 2;
- }
+ // restore fill style
+ XSetFillStyle ((Display*) m_display, (GC) m_gc, gcV.fill_style);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetFillStyle ((Display*) m_display, (GC) m_gcBacking,
+ gcBackingV.fill_style);
- return count;
+ wxCoord w, h;
+ DoGetTextExtent (text, &w, &h);
+ CalcBoundingBox (x + w, y + h);
+ CalcBoundingBox (x, y);
}
-void wxWindowDC::DrawText( const wxString &text, long x, long y, bool use16 )
+void wxWindowDCImpl::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
+ double angle )
{
- if (!Ok()) return;
+ if (angle == 0.0)
+ {
+ DoDrawText(text, x, y);
+ return;
+ }
- // Since X draws from the baseline of the text, must
- // add the text height
- int cx = 0;
- int cy = 0;
- int ascent = 0;
- int slen;
+ wxCHECK_RET( IsOk(), "invalid dc" );
- if (use16)
- slen = str16len(text);
- else
- slen = strlen(text);
+ WXPixel oldBackgroundPixel = -1;
+ WXPixel oldForegroundPixel = -1;
+ WXPixel foregroundPixel = -1;
+ WXPixel backgroundPixel = -1;
- if (m_font.Ok())
+ if (m_textBackgroundColour.IsOk())
{
- WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
- int direction, descent;
- XCharStruct overall_return;
- if (use16)
- (void)XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *)(const char*) text, slen, &direction,
- &ascent, &descent, &overall_return);
- else
- (void)XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) text, slen, &direction,
- &ascent, &descent, &overall_return);
- cx = overall_return.width;
- cy = ascent + descent;
+ oldBackgroundPixel = m_backgroundPixel;
+ backgroundPixel = m_textBackgroundColour.AllocColour(m_display);
}
-
- // First draw a rectangle representing the text background,
- // if a text background is specified
- if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
+ if (m_textForegroundColour.IsOk())
{
- wxColour oldPenColour = m_currentColour;
- m_currentColour = m_textBackgroundColour;
- bool sameColour = (oldPenColour.Ok () && m_textBackgroundColour.Ok () &&
- (oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
- (oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
- (oldPenColour.Green () == m_textBackgroundColour.Green ()));
-
- // This separation of the big && test required for gcc2.7/HP UX 9.02
- // or pixel value can be corrupted!
- sameColour = (sameColour &&
- (oldPenColour.GetPixel() == m_textBackgroundColour.GetPixel()));
-
- if (!sameColour || !GetOptimization())
- {
- int pixel = m_textBackgroundColour.AllocColour(m_display);
- m_currentColour = m_textBackgroundColour;
+ oldForegroundPixel = m_currentColour.GetPixel();
- // Set the GC to the required colour
- if (pixel > -1)
- {
- XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
- if (m_window && m_window->GetBackingPixmap())
- XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
- }
- }
- else
- m_textBackgroundColour = oldPenColour ;
+ if( m_textForegroundColour.GetPixel() <= -1 )
+ CalculatePixel( m_textForegroundColour,
+ m_textForegroundColour, true);
- XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y), cx, cy);
- if (m_window && m_window->GetBackingPixmap())
- XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
- XLOG2DEV_2 (x), YLOG2DEV_2 (y), cx, cy);
+ foregroundPixel = m_textForegroundColour.GetPixel();
}
- // Now set the text foreground and draw the text
- if (m_textForegroundColour.Ok ())
- {
- wxColour oldPenColour = m_currentColour;
- m_currentColour = m_textForegroundColour;
- bool sameColour = (oldPenColour.Ok () && m_currentColour.Ok () &&
- (oldPenColour.Red () == m_currentColour.Red ()) &&
- (oldPenColour.Blue () == m_currentColour.Blue ()) &&
- (oldPenColour.Green () == m_currentColour.Green ()) &&
- (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
-
- if (!sameColour || !GetOptimization())
- {
- int pixel = -1;
- if (!m_colour) // Mono display
- {
- // Unless foreground is really white, draw it in black
- unsigned char red = m_textForegroundColour.Red ();
- unsigned char blue = m_textForegroundColour.Blue ();
- unsigned char green = m_textForegroundColour.Green ();
- if (red == (unsigned char) 255 && blue == (unsigned char) 255
- && green == (unsigned char) 255)
- {
- m_currentColour = *wxWHITE;
- pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
- m_currentColour.SetPixel(pixel);
- m_textForegroundColour.SetPixel(pixel);
- }
- else
- {
- m_currentColour = *wxBLACK;
- pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
- m_currentColour.SetPixel(pixel);
- m_textForegroundColour.SetPixel(pixel);
- }
- }
- else
- {
- pixel = m_textForegroundColour.AllocColour((Display*) m_display);
- m_currentColour.SetPixel(pixel);
- }
-
- // Set the GC to the required colour
- if (pixel > -1)
+ // Since X draws from the baseline of the text, must add the text height
+ int cx = 0;
+ int cy = 0;
+ int ascent = 0;
+
+ if (m_font.IsOk())
+ wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
+ text, &cx, &cy, &ascent, NULL);
+
+ wxBitmap src(cx, cy);
+ wxMemoryDC dc;
+ dc.SelectObject(src);
+ dc.SetFont(GetFont());
+ dc.SetBackground(*wxWHITE_BRUSH);
+ dc.SetBrush(*wxBLACK_BRUSH);
+ dc.Clear();
+ dc.DrawText(text, 0, 0);
+ dc.SetFont(wxNullFont);
+
+ // Calculate the size of the rotated bounding box.
+ double dx = cos(angle / 180.0 * M_PI);
+ double dy = sin(angle / 180.0 * M_PI);
+ double x4 = cy * dy;
+ double y4 = cy * dx;
+ double x3 = cx * dx;
+ double y3 = -cx * dy;
+ double x2 = x3 + x4;
+ double y2 = y3 + y4;
+ double x1 = x;
+ double y1 = y;
+
+ // Create image from the source bitmap after writing the text into it.
+ wxImage image = src.ConvertToImage();
+
+ int minx = roundmin(0, roundmin(x4, roundmin(x2, x3)));
+ int miny = roundmin(0, roundmin(y4, roundmin(y2, y3)));
+ int maxx = roundmax(0, roundmax(x4, roundmax(x2, x3)));
+ int maxy = roundmax(0, roundmax(y4, roundmax(y2, y3)));
+
+ bool lastFore = false, lastBack = false;
+
+ // This rotates counterclockwise around the top left corner.
+ for (int rx = minx; rx < maxx; rx++)
+ {
+ for (int ry = miny; ry < maxy; ry++)
{
- XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
- if (m_window && m_window->GetBackingPixmap())
- XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
+ // transform dest coords to source coords
+ int sx = (int) (rx * dx - ry * dy + 0.5);
+ int sy = - (int) (-ry * dx - rx * dy + 0.5);
+ if (sx >= 0 && sx < cx && sy >= 0 && sy < cy)
+ {
+ bool textPixel = image.GetRed(sx, sy) == 0;
+
+ if (!textPixel && m_backgroundMode != wxSOLID)
+ continue;
+
+ wxCoord ox = (wxCoord) (x1 + rx),
+ oy = (wxCoord) (y1 + ry);
+ // draw black pixels, ignore white ones (i.e. transparent b/g)
+ if (textPixel && !lastFore)
+ {
+ XSetForeground ((Display*) m_display, (GC) m_gc,
+ foregroundPixel);
+ lastFore = true;
+ lastBack = false;
+ }
+ else if (!textPixel && !lastBack)
+ {
+ XSetForeground ((Display*) m_display, (GC) m_gc,
+ backgroundPixel);
+ lastFore = false;
+ lastBack = true;
+ }
+
+ XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap,
+ (GC) m_gc, XLOG2DEV (ox), YLOG2DEV (oy));
+ if (m_window && m_window->GetBackingPixmap())
+ XDrawPoint ((Display*) m_display,
+ (Pixmap) m_window->GetBackingPixmap(),
+ (GC) m_gcBacking,
+ XLOG2DEV_2 (ox), YLOG2DEV_2 (oy));
+ }
}
- }
- else
- m_textForegroundColour = oldPenColour;
- }
-
- // We need to add the ascent, not the whole height, since X draws
- // at the point above the descender.
- if (use16)
- XDrawString16((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent,
- (XChar2b *)(char*) (const char*) text, slen);
- else
- XDrawString((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent,
- text, slen);
+ }
- if (m_window && m_window->GetBackingPixmap()) {
- if (use16)
- XDrawString16((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
- XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
- (XChar2b *)(char*) (const char*) text, slen);
- else
- XDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
- XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent, (char*) (const char*) text, slen);
- }
+ if (oldBackgroundPixel > -1)
+ {
+ XSetBackground ((Display*) m_display, (GC) m_gc, oldBackgroundPixel);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetBackground ((Display*) m_display,(GC) m_gcBacking,
+ oldBackgroundPixel);
+ }
+ if (oldForegroundPixel > -1)
+ {
+ XSetForeground ((Display*) m_display, (GC) m_gc, oldForegroundPixel);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetForeground ((Display*) m_display,(GC) m_gcBacking,
+ oldForegroundPixel);
+ }
- long w, h;
- GetTextExtent (text, &w, &h);
- CalcBoundingBox (x + w, y + h);
- CalcBoundingBox (x, y);
-};
+ CalcBoundingBox (minx, miny);
+ CalcBoundingBox (maxx, maxy);
+}
-bool wxWindowDC::CanGetTextExtent(void) const
+bool wxWindowDCImpl::CanGetTextExtent() const
{
- return TRUE;
-};
+ return true;
+}
-void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *height,
- long *descent, long *externalLeading,
- wxFont *font, bool use16 )
+void wxWindowDCImpl::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
+ wxCoord *descent, wxCoord *externalLeading,
+ const wxFont *font ) const
{
- if (!Ok()) return;
+ wxCHECK_RET( IsOk(), "invalid dc" );
- wxFont* theFont = font;
- if (!theFont)
- theFont = & m_font;
-
- if (!theFont->Ok())
- {
- // TODO: this should be an error log function
- wxFAIL_MSG("set a valid font before calling GetTextExtent!");
+ const wxFont* theFont = font ? font : &m_font;
- *width = -1;
- *height = -1;
- return;
- }
+ if (!theFont->IsOk())
+ {
+ // TODO: this should be an error log function
+ wxFAIL_MSG("set a valid font before calling GetTextExtent!");
+
+ if (width) *width = -1;
+ if (height) *height = -1;
+ return;
+ }
+
+ wxGetTextExtent(m_display, *theFont, m_userScaleY * m_logicalScaleY,
+ string, width, height, NULL, descent);
- WXFontStructPtr pFontStruct = theFont->GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
-
- int direction, ascent, descent2;
- XCharStruct overall;
- int slen;
-
- if (use16) slen = str16len(string); else slen = strlen(string);
-
- if (use16)
- XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
- &ascent, &descent2, &overall);
- else
- XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) string, slen, &direction,
- &ascent, &descent2, &overall);
-
- *width = XDEV2LOGREL (overall.width);
- *height = YDEV2LOGREL (ascent + descent2);
- if (descent)
- *descent = descent2;
- if (externalLeading)
- *externalLeading = 0;
-};
-
-long wxWindowDC::GetCharWidth(void)
+ if (width) *width = XDEV2LOGREL (*width);
+ if (height) *height = YDEV2LOGREL (*height);
+ if (externalLeading)
+ *externalLeading = 0;
+}
+
+wxCoord wxWindowDCImpl::GetCharWidth() const
{
- if (!Ok()) return 0;
+ wxCHECK_MSG( IsOk(), 0, "invalid dc" );
+ wxCHECK_MSG( m_font.IsOk(), 0, "invalid font" );
- if (!m_font.Ok())
- return 0;
+ int width;
- WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY * m_logicalScaleY, m_display);
+ wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
+ "x", &width, NULL, NULL, NULL);
- int direction, ascent, descent;
- XCharStruct overall;
- XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
- &descent, &overall);
- return XDEV2LOGREL(overall.width);
-};
+ return XDEV2LOGREL(width);
+}
-long wxWindowDC::GetCharHeight(void)
+wxCoord wxWindowDCImpl::GetCharHeight() const
{
- if (!Ok()) return 0;
+ wxCHECK_MSG( IsOk(), 0, "invalid dc" );
+ wxCHECK_MSG( m_font.IsOk(), 0, "invalid font" );
- if (!m_font.Ok())
- return 0;
+ int height;
- WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
+ wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
+ "x", NULL, &height, NULL, NULL);
- int direction, ascent, descent;
- XCharStruct overall;
- XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
- &descent, &overall);
-// return XDEV2LOGREL(overall.ascent + overall.descent);
- return XDEV2LOGREL(ascent + descent);
-};
+ return XDEV2LOGREL(height);
+}
-void wxWindowDC::Clear(void)
+void wxWindowDCImpl::DoGetSize( int *width, int *height ) const
{
- if (!Ok()) return;
-
- int w, h;
- if (m_window)
- {
- m_window->GetSize(&w, &h);
+ int w = 0, h = 0;
- if (m_window && m_window->GetBackingPixmap())
- {
- w = m_window->GetPixmapWidth();
- h = m_window->GetPixmapHeight();
- }
- }
- else
+ if( m_window )
{
- if (this->IsKindOf(CLASSINFO(wxMemoryDC)))
+ if( m_window->GetBackingPixmap() )
{
- wxMemoryDC* memDC = (wxMemoryDC*) this;
- w = memDC->GetBitmap().GetWidth();
- h = memDC->GetBitmap().GetHeight();
- }
+ w = m_window->GetPixmapWidth();
+ h = m_window->GetPixmapHeight();
+ }
else
- return;
+ m_window->GetSize( &w, &h );
}
- wxBrush saveBrush = m_brush;
- SetBrush (m_backgroundBrush);
-
- XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, 0, 0, w, h);
+ if( width ) *width = w;
+ if( height ) *height = h;
+}
- if (m_window && m_window->GetBackingPixmap())
- XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, 0, 0, w, h);
+void wxWindowDCImpl::Clear()
+{
+ wxCHECK_RET( IsOk(), "invalid dc" );
- m_brush = saveBrush;
-};
+ wxRect rect( GetSize() );
+ Clear( rect );
+}
-void wxWindowDC::Clear(const wxRect& rect)
+void wxWindowDCImpl::Clear(const wxRect& rect)
{
- if (!Ok()) return;
-
- int x = rect.x; int y = rect.y;
- int w = rect.width; int h = rect.height;
+ wxCHECK_RET( IsOk(), "invalid dc" );
- wxBrush saveBrush = m_brush;
- SetBrush (m_backgroundBrush);
+ int x = rect.x; int y = rect.y;
+ int w = rect.width; int h = rect.height;
- XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, x, y, w, h);
+ wxBrush saveBrush = m_brush;
+ SetBrush (m_backgroundBrush);
- if (m_window && m_window->GetBackingPixmap())
- XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, x, y, w, h);
+ XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc,
+ x, y, w, h);
- m_brush = saveBrush;
-};
+ if (m_window && m_window->GetBackingPixmap())
+ XFillRectangle ((Display*) m_display,
+ (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+ x, y, w, h);
+
+ m_brush = saveBrush;
+}
-void wxWindowDC::SetFont( const wxFont &font )
+void wxWindowDCImpl::SetFont( const wxFont &font )
{
- if (!Ok()) return;
-
- m_font = font;
+ wxCHECK_RET( IsOk(), "invalid dc" );
- if (!m_font.Ok())
- {
- if ((m_oldFont != (WXFont) 0) && ((long) m_oldFont != -1))
+ m_font = font;
+
+ if (!m_font.IsOk())
{
- XSetFont ((Display*) m_display, (GC) m_gc, (Font) m_oldFont);
+ return;
+ }
- if (m_window && m_window->GetBackingPixmap())
- XSetFont ((Display*) m_display,(GC) m_gcBacking, (Font) m_oldFont);
+#if !wxMOTIF_NEW_FONT_HANDLING
+ WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
+
+ Font fontId = ((XFontStruct*)pFontStruct)->fid;
+ XSetFont ((Display*) m_display, (GC) m_gc, fontId);
+
+ if (m_window && m_window->GetBackingPixmap())
+ XSetFont ((Display*) m_display,(GC) m_gcBacking, fontId);
+#endif
+}
+
+void wxWindowDCImpl::SetForegroundPixelWithLogicalFunction(WXPixel pixel)
+{
+ if (m_logicalFunction == wxXOR)
+ {
+ XGCValues values;
+ XGetGCValues ((Display*) m_display, (GC) m_gc, GCBackground, &values);
+ XSetForeground ((Display*) m_display, (GC) m_gc,
+ pixel ^ values.background);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetForeground ((Display*) m_display,(GC) m_gcBacking,
+ pixel ^ values.background);
}
- return;
- }
+ else
+ {
+ XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
+ }
+}
- WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
+WXPixel wxWindowDCImpl::CalculatePixel(wxColour& colour, wxColour& curCol,
+ bool roundToWhite) const
+{
+ const unsigned char wp = (unsigned char)255;
- Font fontId = ((XFontStruct*)pFontStruct)->fid;
- XSetFont ((Display*) m_display, (GC) m_gc, fontId);
+ WXPixel pixel = -1;
+ if(!m_colour) // Mono display
+ {
+ unsigned char red = colour.Red ();
+ unsigned char blue = colour.Blue ();
+ unsigned char green = colour.Green ();
+ // white
+ if((red == wp && blue == wp && green == wp) ||
+ // not black and roundToWhite was specified
+ ((red != 0 || blue != 0 || green != 0) && roundToWhite))
+ {
+ curCol = *wxWHITE;
+ pixel = WhitePixel((Display*) m_display,
+ DefaultScreen((Display*) m_display));
+ curCol.SetPixel(pixel);
+ colour.SetPixel(pixel);
+ }
+ else
+ {
+ curCol = *wxBLACK;
+ pixel = BlackPixel((Display*) m_display,
+ DefaultScreen((Display*) m_display));
+ curCol.SetPixel(pixel);
+ colour.SetPixel(pixel);
+ }
+ }
+ else
+ {
+ curCol = colour;
+ pixel = colour.AllocColour((Display*) m_display);
+ curCol.SetPixel(pixel);
+ }
- if (m_window && m_window->GetBackingPixmap())
- XSetFont ((Display*) m_display,(GC) m_gcBacking, fontId);
-};
+ return pixel;
+}
-void wxWindowDC::SetPen( const wxPen &pen )
+void wxWindowDCImpl::SetPen( const wxPen &pen )
{
- if (!Ok()) return;
-
- m_pen = pen;
- if (!m_pen.Ok())
- return;
-
- wxBitmap oldStipple = m_currentStipple;
- int oldStyle = m_currentStyle;
- int oldFill = m_currentFill;
- int old_pen_width = m_currentPenWidth;
- int old_pen_join = m_currentPenJoin;
- int old_pen_cap = m_currentPenCap;
- int old_pen_nb_dash = m_currentPenDashCount;
- char *old_pen_dash = m_currentPenDash;
-
- wxColour oldPenColour = m_currentColour;
- m_currentColour = m_pen.GetColour ();
- m_currentStyle = m_pen.GetStyle ();
- m_currentFill = m_pen.GetStyle (); // TODO?
- m_currentPenWidth = m_pen.GetWidth ();
- m_currentPenJoin = m_pen.GetJoin ();
- m_currentPenCap = m_pen.GetCap ();
- m_currentPenDashCount = m_pen.GetDashCount();
- m_currentPenDash = m_pen.GetDash();
-
- if (m_currentStyle == wxSTIPPLE)
- m_currentStipple = * m_pen.GetStipple ();
-
- bool sameStyle = (oldStyle == m_currentStyle &&
- oldFill == m_currentFill &&
- old_pen_join == m_currentPenJoin &&
- old_pen_cap == m_currentPenCap &&
- old_pen_nb_dash == m_currentPenDashCount &&
- old_pen_dash == m_currentPenDash &&
- old_pen_width == m_currentPenWidth);
-
- bool sameColour = (oldPenColour.Ok () &&
- (oldPenColour.Red () == m_currentColour.Red ()) &&
- (oldPenColour.Blue () == m_currentColour.Blue ()) &&
- (oldPenColour.Green () == m_currentColour.Green ()) &&
- (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
-
- if (!sameStyle || !GetOptimization())
+ wxCHECK_RET( IsOk(), "invalid dc" );
+
+ m_pen = pen;
+ if (!m_pen.IsOk())
+ return;
+
+ wxBitmap oldStipple = m_currentStipple;
+ int oldStyle = m_currentStyle;
+ int oldFill = m_currentFill;
+ int old_pen_width = m_currentPenWidth;
+ int old_pen_join = m_currentPenJoin;
+ int old_pen_cap = m_currentPenCap;
+ int old_pen_nb_dash = m_currentPenDashCount;
+ wxX11Dash *old_pen_dash = m_currentPenDash;
+
+ wxColour oldPenColour = m_currentColour;
+ m_currentColour = m_pen.GetColour ();
+ m_currentStyle = m_pen.GetStyle ();
+ m_currentFill = m_pen.GetStyle (); // TODO?
+ m_currentPenWidth = m_pen.GetWidth ();
+ m_currentPenJoin = m_pen.GetJoin ();
+ m_currentPenCap = m_pen.GetCap ();
+ m_currentPenDashCount = m_pen.GetDashCount();
+ m_currentPenDash = (wxX11Dash*)m_pen.GetDash();
+
+ if (m_currentStyle == wxSTIPPLE)
+ m_currentStipple = * m_pen.GetStipple ();
+
+ bool sameStyle = (oldStyle == m_currentStyle &&
+ oldFill == m_currentFill &&
+ old_pen_join == m_currentPenJoin &&
+ old_pen_cap == m_currentPenCap &&
+ old_pen_nb_dash == m_currentPenDashCount &&
+ old_pen_dash == m_currentPenDash &&
+ old_pen_width == m_currentPenWidth);
+
+ bool sameColour = (oldPenColour.IsOk () &&
+ (oldPenColour.Red () == m_currentColour.Red ()) &&
+ (oldPenColour.Blue () == m_currentColour.Blue ()) &&
+ (oldPenColour.Green () == m_currentColour.Green ()) &&
+ (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
+
+ if (!sameStyle || !GET_OPTIMIZATION)
{
- int scaled_width = (int) XLOG2DEVREL (m_pen.GetWidth ());
- if (scaled_width < 0)
- scaled_width = 0;
-
- int style;
- int join;
- int cap;
- static char dotted[] =
- {2, 5};
- static char short_dashed[] =
- {4, 4};
- static char long_dashed[] =
- {4, 8};
- static char dotted_dashed[] =
- {6, 6, 2, 6};
-
- // We express dash pattern in pen width unit, so we are
- // independent of zoom factor and so on...
- int req_nb_dash;
- char *req_dash;
-
- switch (m_pen.GetStyle ())
- {
+ int scaled_width = (int) XLOG2DEVREL (m_pen.GetWidth ());
+ if (scaled_width < 0)
+ scaled_width = 0;
+
+ int style;
+ int join;
+ int cap;
+ static const wxX11Dash dotted[] = {2, 5};
+ static const wxX11Dash short_dashed[] = {4, 4};
+ static const wxX11Dash long_dashed[] = {4, 8};
+ static const wxX11Dash dotted_dashed[] = {6, 6, 2, 6};
+
+ // We express dash pattern in pen width unit, so we are
+ // independent of zoom factor and so on...
+ int req_nb_dash;
+ const wxX11Dash *req_dash;
+
+ switch (m_pen.GetStyle ())
+ {
case wxUSER_DASH:
- req_nb_dash = m_currentPenDashCount;
- req_dash = m_currentPenDash;
- style = LineOnOffDash;
- break;
+ req_nb_dash = m_currentPenDashCount;
+ req_dash = m_currentPenDash;
+ style = LineOnOffDash;
+ break;
case wxDOT:
- req_nb_dash = 2;
- req_dash = dotted;
- style = LineOnOffDash;
- break;
+ req_nb_dash = 2;
+ req_dash = dotted;
+ style = LineOnOffDash;
+ break;
case wxSHORT_DASH:
- req_nb_dash = 2;
- req_dash = short_dashed;
- style = LineOnOffDash;
- break;
+ req_nb_dash = 2;
+ req_dash = short_dashed;
+ style = LineOnOffDash;
+ break;
case wxLONG_DASH:
- req_nb_dash = 2;
- req_dash = long_dashed;
- style = LineOnOffDash;
- break;
+ req_nb_dash = 2;
+ req_dash = long_dashed;
+ style = LineOnOffDash;
+ break;
case wxDOT_DASH:
- req_nb_dash = 4;
- req_dash = dotted_dashed;
- style = LineOnOffDash;
- break;
+ req_nb_dash = 4;
+ req_dash = dotted_dashed;
+ style = LineOnOffDash;
+ break;
case wxSTIPPLE:
case wxSOLID:
case wxTRANSPARENT:
default:
- style = LineSolid;
- req_dash = NULL;
- req_nb_dash = 0;
- }
-
- if (req_dash && req_nb_dash)
- {
- char *real_req_dash = new char[req_nb_dash];
- if (real_req_dash)
- {
- int factor = scaled_width == 0 ? 1 : scaled_width;
- for (int i = 0; i < req_nb_dash; i++)
- real_req_dash[i] = req_dash[i] * factor;
- XSetDashes ((Display*) m_display, (GC) m_gc, 0, real_req_dash, req_nb_dash);
-
- if (m_window && m_window->GetBackingPixmap())
- XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, real_req_dash, req_nb_dash);
- delete[]real_req_dash;
+ style = LineSolid;
+ req_dash = NULL;
+ req_nb_dash = 0;
}
- else
+
+ if (req_dash && req_nb_dash)
{
- // No Memory. We use non-scaled dash pattern...
- XSetDashes ((Display*) m_display, (GC) m_gc, 0, req_dash, req_nb_dash);
+ wxX11Dash *real_req_dash = new wxX11Dash[req_nb_dash];
+ if (real_req_dash)
+ {
+ int factor = scaled_width == 0 ? 1 : scaled_width;
+ for (int i = 0; i < req_nb_dash; i++)
+ real_req_dash[i] = (wxX11Dash)(req_dash[i] * factor);
+ XSetDashes ((Display*) m_display, (GC) m_gc, 0, real_req_dash, req_nb_dash);
+
+ if (m_window && m_window->GetBackingPixmap())
+ XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, real_req_dash, req_nb_dash);
+ delete[]real_req_dash;
+ }
+ else
+ {
+ // No Memory. We use non-scaled dash pattern...
+ XSetDashes ((Display*) m_display, (GC) m_gc, 0, req_dash, req_nb_dash);
- if (m_window && m_window->GetBackingPixmap())
- XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, req_dash, req_nb_dash);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, req_dash, req_nb_dash);
+ }
}
- }
- switch (m_pen.GetCap ())
- {
+ switch (m_pen.GetCap ())
+ {
case wxCAP_PROJECTING:
- cap = CapProjecting;
- break;
+ cap = CapProjecting;
+ break;
case wxCAP_BUTT:
- cap = CapButt;
- break;
+ cap = CapButt;
+ break;
case wxCAP_ROUND:
default:
- cap = CapRound;
- break;
- }
+ cap = (scaled_width <= 1) ? CapNotLast : CapRound;
+ break;
+ }
- switch (m_pen.GetJoin ())
- {
+ switch (m_pen.GetJoin ())
+ {
case wxJOIN_BEVEL:
- join = JoinBevel;
- break;
+ join = JoinBevel;
+ break;
case wxJOIN_MITER:
- join = JoinMiter;
- break;
+ join = JoinMiter;
+ break;
case wxJOIN_ROUND:
default:
- join = JoinRound;
- break;
- }
+ join = JoinRound;
+ break;
+ }
- XSetLineAttributes ((Display*) m_display, (GC) m_gc, scaled_width, style, cap, join);
+ XSetLineAttributes ((Display*) m_display, (GC) m_gc, scaled_width, style, cap, join);
- if (m_window && m_window->GetBackingPixmap())
- XSetLineAttributes ((Display*) m_display,(GC) m_gcBacking, scaled_width, style, cap, join);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetLineAttributes ((Display*) m_display,(GC) m_gcBacking, scaled_width, style, cap, join);
}
- if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
+ if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GET_OPTIMIZATION))
{
- Pixmap myStipple;
+ Pixmap myStipple;
- oldStipple = wxNullBitmap; // For later reset!!
+ oldStipple = wxNullBitmap; // For later reset!!
- switch (m_currentFill)
- {
+ switch (m_currentFill)
+ {
case wxBDIAGONAL_HATCH:
- if (bdiag == (Pixmap) 0)
- bdiag = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- bdiag_bits, bdiag_width, bdiag_height);
- myStipple = bdiag;
- break;
+ if (bdiag == (Pixmap) 0)
+ bdiag = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ bdiag_bits, bdiag_width, bdiag_height);
+ myStipple = bdiag;
+ break;
case wxFDIAGONAL_HATCH:
- if (fdiag == (Pixmap) 0)
- fdiag = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- fdiag_bits, fdiag_width, fdiag_height);
- myStipple = fdiag;
- break;
+ if (fdiag == (Pixmap) 0)
+ fdiag = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ fdiag_bits, fdiag_width, fdiag_height);
+ myStipple = fdiag;
+ break;
case wxCROSS_HATCH:
- if (cross == (Pixmap) 0)
- cross = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- cross_bits, cross_width, cross_height);
- myStipple = cross;
- break;
+ if (cross == (Pixmap) 0)
+ cross = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ cross_bits, cross_width, cross_height);
+ myStipple = cross;
+ break;
case wxHORIZONTAL_HATCH:
- if (horiz == (Pixmap) 0)
- horiz = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- horiz_bits, horiz_width, horiz_height);
- myStipple = horiz;
- break;
+ if (horiz == (Pixmap) 0)
+ horiz = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ horiz_bits, horiz_width, horiz_height);
+ myStipple = horiz;
+ break;
case wxVERTICAL_HATCH:
- if (verti == (Pixmap) 0)
- verti = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- verti_bits, verti_width, verti_height);
- myStipple = verti;
- break;
+ if (verti == (Pixmap) 0)
+ verti = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ verti_bits, verti_width, verti_height);
+ myStipple = verti;
+ break;
case wxCROSSDIAG_HATCH:
default:
- if (cdiag == (Pixmap) 0)
- cdiag = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- cdiag_bits, cdiag_width, cdiag_height);
- myStipple = cdiag;
- break;
- }
- XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);
+ if (cdiag == (Pixmap) 0)
+ cdiag = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ cdiag_bits, cdiag_width, cdiag_height);
+ myStipple = cdiag;
+ break;
+ }
+ XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);
- if (m_window && m_window->GetBackingPixmap())
- XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
}
- else if (m_currentStipple.Ok()
- && ((m_currentStipple != oldStipple) || !GetOptimization()))
+ else if (m_currentStyle == wxSTIPPLE && m_currentStipple.IsOk()
+ && ((!m_currentStipple.IsSameAs(oldStipple)) || !GET_OPTIMIZATION))
{
- XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetPixmap());
+ XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetDrawable());
- if (m_window && m_window->GetBackingPixmap())
- XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
+ if (m_window && m_window->GetBackingPixmap())
+ XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetDrawable());
}
- if ((m_currentFill != oldFill) || !GetOptimization())
+ if ((m_currentFill != oldFill) || !GET_OPTIMIZATION)
{
- int fill_style;
-
- if (m_currentFill == wxSTIPPLE)
- fill_style = FillStippled;
- else if (IS_HATCH (m_currentFill))
- fill_style = FillStippled;
- else
- fill_style = FillSolid;
- XSetFillStyle ((Display*) m_display, (GC) m_gc, fill_style);
- if (m_window && m_window->GetBackingPixmap())
- XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, fill_style);
+ int fill_style;
+
+ if (m_currentFill == wxSTIPPLE)
+ fill_style = FillStippled;
+ else if (IS_HATCH (m_currentFill))
+ fill_style = FillStippled;
+ else
+ fill_style = FillSolid;
+ XSetFillStyle ((Display*) m_display, (GC) m_gc, fill_style);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, fill_style);
}
// must test m_logicalFunction, because it involves background!
- if (!sameColour || !GetOptimization()
- || ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))
+ if (!sameColour || !GET_OPTIMIZATION
+ || ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))
{
- int pixel = -1;
- if (m_pen.GetStyle () == wxTRANSPARENT)
- pixel = m_backgroundPixel;
- else if (!m_colour)
- {
- unsigned char red = m_pen.GetColour ().Red ();
- unsigned char blue = m_pen.GetColour ().Blue ();
- unsigned char green = m_pen.GetColour ().Green ();
- if (red == (unsigned char) 255 && blue == (unsigned char) 255
- && green == (unsigned char) 255)
- {
- pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
- m_currentColour = *wxWHITE;
- m_pen.GetColour().SetPixel(pixel);
- m_currentColour.SetPixel(pixel);
- }
+ WXPixel pixel = -1;
+ if (m_pen.GetStyle () == wxTRANSPARENT)
+ pixel = m_backgroundPixel;
else
{
- pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
- m_currentColour = *wxBLACK;
- m_pen.GetColour().SetPixel(pixel);
- }
- }
- else
- {
- pixel = m_pen.GetColour ().AllocColour(m_display);
- m_currentColour.SetPixel(pixel);
- }
-
- // Finally, set the GC to the required colour
- if (pixel > -1)
- {
- if (m_logicalFunction == wxXOR)
- {
- XGCValues values;
- XGetGCValues ((Display*) m_display, (GC) m_gc, GCBackground, &values);
- XSetForeground ((Display*) m_display, (GC) m_gc, pixel ^ values.background);
- if (m_window && m_window->GetBackingPixmap())
- XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel ^ values.background);
- }
- else
- {
- XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
- if (m_window && m_window->GetBackingPixmap())
- XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
+ wxColour penClr = m_pen.GetColour();
+ pixel = CalculatePixel( penClr, m_currentColour, false);
+ m_pen.SetColour(penClr);
}
+
+ // Finally, set the GC to the required colour
+ if (pixel > -1)
+ SetForegroundPixelWithLogicalFunction(pixel);
}
- }
- else
- m_pen.GetColour().SetPixel(oldPenColour.GetPixel());
+ else
+ m_pen.GetColour().SetPixel(oldPenColour.GetPixel());
- m_autoSetting = 0;
-};
+ m_autoSetting = 0;
+}
-void wxWindowDC::SetBrush( const wxBrush &brush )
+void wxWindowDCImpl::SetBrush( const wxBrush &brush )
{
- if (!Ok()) return;
-
- m_brush = brush;
+ wxCHECK_RET( IsOk(), "invalid dc" );
- if (!m_brush.Ok() || m_brush.GetStyle () == wxTRANSPARENT)
- return;
+ m_brush = brush;
- int oldFill = m_currentFill;
- wxBitmap oldStipple = m_currentStipple;
+ if (!m_brush.IsOk() || m_brush.GetStyle () == wxTRANSPARENT)
+ return;
- m_autoSetting |= 0x1;
+ int oldFill = m_currentFill;
+ wxBitmap oldStipple = m_currentStipple;
- m_currentFill = m_brush.GetStyle ();
- if (m_currentFill == wxSTIPPLE)
- m_currentStipple = * m_brush.GetStipple ();
+ m_autoSetting |= 0x1;
- wxColour oldBrushColour(m_currentColour);
- m_currentColour = m_brush.GetColour ();
+ m_currentFill = m_brush.GetStyle ();
+ if (m_currentFill == wxSTIPPLE)
+ m_currentStipple = * m_brush.GetStipple ();
- bool sameColour = (oldBrushColour.Ok () &&
- (oldBrushColour.Red () == m_currentColour.Red ()) &&
- (oldBrushColour.Blue () == m_currentColour.Blue ()) &&
- (oldBrushColour.Green () == m_currentColour.Green ()) &&
- (oldBrushColour.GetPixel() == m_currentColour.GetPixel()));
+ wxColour oldBrushColour(m_currentColour);
+ m_currentColour = m_brush.GetColour ();
- if ((oldFill != m_brush.GetStyle ()) || !GetOptimization())
- {
- switch (brush.GetStyle ())
- {
+ bool sameColour = (oldBrushColour.IsOk () &&
+ (oldBrushColour.Red () == m_currentColour.Red ()) &&
+ (oldBrushColour.Blue () == m_currentColour.Blue ()) &&
+ (oldBrushColour.Green () == m_currentColour.Green ()) &&
+ (oldBrushColour.GetPixel() == m_currentColour.GetPixel()));
+
+ int stippleDepth = -1;
+
+ if ((oldFill != m_brush.GetStyle ()) || !GET_OPTIMIZATION)
+ {
+ switch (brush.GetStyle ())
+ {
case wxTRANSPARENT:
- break;
+ break;
+ case wxSTIPPLE:
+ stippleDepth = m_currentStipple.GetDepth();
+ // fall through!
case wxBDIAGONAL_HATCH:
case wxCROSSDIAG_HATCH:
case wxFDIAGONAL_HATCH:
case wxCROSS_HATCH:
case wxHORIZONTAL_HATCH:
case wxVERTICAL_HATCH:
- case wxSTIPPLE:
- {
- // Chris Breeze 23/07/97: use background mode to determine whether
- // fill style should be solid or transparent
- int style = (m_backgroundMode == wxSOLID ? FillOpaqueStippled : FillStippled);
- XSetFillStyle ((Display*) m_display, (GC) m_gc, style);
- if (m_window && m_window->GetBackingPixmap())
- XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, style);
- }
- break;
+ {
+ if (stippleDepth == -1) stippleDepth = 1;
+
+ // Chris Breeze 23/07/97: use background mode to
+ // determine whether fill style should be solid or
+ // transparent
+ int style = stippleDepth == 1 ?
+ (m_backgroundMode == wxSOLID ?
+ FillOpaqueStippled : FillStippled) :
+ FillTiled;
+ XSetFillStyle ((Display*) m_display, (GC) m_gc, style);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, style);
+ }
+ break;
case wxSOLID:
default:
- XSetFillStyle ((Display*) m_display, (GC) m_gc, FillSolid);
- if (m_window && m_window->GetBackingPixmap())
- XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, FillSolid);
- }
- }
+ XSetFillStyle ((Display*) m_display, (GC) m_gc, FillSolid);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetFillStyle ((Display*) m_display,(GC) m_gcBacking,
+ FillSolid);
+ }
+ }
- if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
+ if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GET_OPTIMIZATION))
{
- Pixmap myStipple;
+ Pixmap myStipple;
- switch (m_currentFill)
- {
+ switch (m_currentFill)
+ {
case wxBDIAGONAL_HATCH:
- if (bdiag == (Pixmap) 0)
- bdiag = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- bdiag_bits, bdiag_width, bdiag_height);
- myStipple = bdiag;
- break;
+ if (bdiag == (Pixmap) 0)
+ bdiag = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ bdiag_bits, bdiag_width, bdiag_height);
+ myStipple = bdiag;
+ break;
case wxFDIAGONAL_HATCH:
- if (fdiag == (Pixmap) 0)
- fdiag = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- fdiag_bits, fdiag_width, fdiag_height);
- myStipple = fdiag;
- break;
+ if (fdiag == (Pixmap) 0)
+ fdiag = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ fdiag_bits, fdiag_width, fdiag_height);
+ myStipple = fdiag;
+ break;
case wxCROSS_HATCH:
- if (cross == (Pixmap) 0)
- cross = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- cross_bits, cross_width, cross_height);
- myStipple = cross;
- break;
+ if (cross == (Pixmap) 0)
+ cross = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ cross_bits, cross_width, cross_height);
+ myStipple = cross;
+ break;
case wxHORIZONTAL_HATCH:
- if (horiz == (Pixmap) 0)
- horiz = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- horiz_bits, horiz_width, horiz_height);
- myStipple = horiz;
- break;
+ if (horiz == (Pixmap) 0)
+ horiz = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ horiz_bits, horiz_width, horiz_height);
+ myStipple = horiz;
+ break;
case wxVERTICAL_HATCH:
- if (verti == (Pixmap) 0)
- verti = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- verti_bits, verti_width, verti_height);
- myStipple = verti;
- break;
+ if (verti == (Pixmap) 0)
+ verti = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ verti_bits, verti_width, verti_height);
+ myStipple = verti;
+ break;
case wxCROSSDIAG_HATCH:
default:
- if (cdiag == (Pixmap) 0)
- cdiag = XCreateBitmapFromData ((Display*) m_display,
- RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
- cdiag_bits, cdiag_width, cdiag_height);
- myStipple = cdiag;
- break;
- }
- XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);
+ if (cdiag == (Pixmap) 0)
+ cdiag = XCreateBitmapFromData ((Display*) m_display,
+ RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+ cdiag_bits, cdiag_width, cdiag_height);
+ myStipple = cdiag;
+ break;
+ }
+ XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);
- if (m_window && m_window->GetBackingPixmap())
- XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
}
// X can forget the stipple value when resizing a window (apparently)
// so always set the stipple.
- else if (m_currentStipple.Ok()) // && m_currentStipple != oldStipple)
+ else if (m_currentFill != wxSOLID && m_currentFill != wxTRANSPARENT &&
+ m_currentStipple.IsOk()) // && m_currentStipple != oldStipple)
{
- XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetPixmap());
- if (m_window && m_window->GetBackingPixmap())
- XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
- }
-
- // must test m_logicalFunction, because it involves background!
- if (!sameColour || !GetOptimization() || m_logicalFunction == wxXOR)
- {
- int pixel = -1;
- if (!m_colour)
- {
- // Policy - on a monochrome screen, all brushes are white,
- // except when they're REALLY black!!!
- unsigned char red = m_brush.GetColour ().Red ();
- unsigned char blue = m_brush.GetColour ().Blue ();
- unsigned char green = m_brush.GetColour ().Green ();
-
- if (red == (unsigned char) 0 && blue == (unsigned char) 0
- && green == (unsigned char) 0)
- {
- pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
- m_currentColour = *wxBLACK;
- m_brush.GetColour().SetPixel(pixel);
- m_currentColour.SetPixel(pixel);
- }
- else
- {
- pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
- m_currentColour = *wxWHITE;
- m_brush.GetColour().SetPixel(pixel);
- m_currentColour.SetPixel(pixel);
- }
-
- // N.B. comment out the above line and uncomment the following lines
- // if you want non-white colours to be black on a monochrome display.
- /*
- if (red == (unsigned char )255 && blue == (unsigned char)255
- && green == (unsigned char)255)
- pixel = (int)WhitePixel((Display*) m_display, DefaultScreen((Display*) m_display));
- else
- pixel = (int)BlackPixel((Display*) m_display, DefaultScreen((Display*) m_display));
- */
- }
- else if (m_brush.GetStyle () != wxTRANSPARENT)
- {
- pixel = m_brush.GetColour().AllocColour(m_display);
- m_currentColour.SetPixel(pixel);
- }
- if (pixel > -1)
- {
- // Finally, set the GC to the required colour
- if (m_logicalFunction == wxXOR)
+ if (m_currentStipple.GetDepth() == 1)
{
- XGCValues values;
- XGetGCValues ((Display*) m_display, (GC) m_gc, GCBackground, &values);
- XSetForeground ((Display*) m_display, (GC) m_gc, pixel ^ values.background);
- if (m_window && m_window->GetBackingPixmap())
- XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel ^ values.background);
+ XSetStipple ((Display*) m_display, (GC) m_gc,
+ (Pixmap) m_currentStipple.GetDrawable());
+ if (m_window && m_window->GetBackingPixmap())
+ XSetStipple ((Display*) m_display,(GC) m_gcBacking,
+ (Pixmap) m_currentStipple.GetDrawable());
}
else
{
- XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
- if (m_window && m_window->GetBackingPixmap())
- XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
+ XSetTile ((Display*) m_display, (GC) m_gc,
+ (Pixmap) m_currentStipple.GetDrawable());
+ if (m_window && m_window->GetBackingPixmap())
+ XSetTile ((Display*) m_display,(GC) m_gcBacking,
+ (Pixmap) m_currentStipple.GetDrawable());
}
- }
}
- else
- m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());
-};
-void wxWindowDC::SetBackground( const wxBrush &brush )
+ // must test m_logicalFunction, because it involves background!
+ if (!sameColour || !GET_OPTIMIZATION || m_logicalFunction == wxXOR)
+ {
+ wxColour brushClr = m_brush.GetColour();
+ WXPixel pixel = CalculatePixel( brushClr, m_currentColour, true);
+ m_brush.SetColour(brushClr);
+
+ if (pixel > -1)
+ SetForegroundPixelWithLogicalFunction(pixel);
+ }
+ else
+ m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());
+}
+
+void wxWindowDCImpl::SetBackground( const wxBrush &brush )
{
- if (!Ok()) return;
-
- m_backgroundBrush = brush;
+ wxCHECK_RET( IsOk(), "invalid dc" );
- if (!m_backgroundBrush.Ok())
- return;
+ m_backgroundBrush = brush;
- int pixel = m_backgroundBrush.GetColour().AllocColour(m_display);
+ if (!m_backgroundBrush.IsOk())
+ return;
- // XSetWindowBackground doesn't work for non-Window pixmaps
- if (!this->IsKindOf(CLASSINFO(wxMemoryDC)))
- XSetWindowBackground ((Display*) m_display, (Pixmap) m_pixmap, pixel);
+ m_backgroundPixel = m_backgroundBrush.GetColour().AllocColour(m_display);
- // Necessary for ::DrawIcon, which use fg/bg pixel or the GC.
- // And Blit,... (Any fct that use XCopyPlane, in fact.)
- XSetBackground ((Display*) m_display, (GC) m_gc, pixel);
- if (m_window && m_window->GetBackingPixmap())
- XSetBackground ((Display*) m_display,(GC) m_gcBacking, pixel);
-};
+ // Necessary for ::DrawIcon, which use fg/bg pixel or the GC.
+ // And Blit,... (Any fct that use XCopyPlane, in fact.)
+ XSetBackground ((Display*) m_display, (GC) m_gc, m_backgroundPixel);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetBackground ((Display*) m_display,(GC) m_gcBacking,
+ m_backgroundPixel);
+}
-void wxWindowDC::SetLogicalFunction( int function )
+void wxWindowDCImpl::SetLogicalFunction( wxRasterOperationMode function )
{
- int x_function;
+ wxCHECK_RET( IsOk(), "invalid dc" );
- /* MATTHEW: [9] */
- if (m_logicalFunction == function)
- return;
+ int x_function;
- switch (function)
+ /* MATTHEW: [9] */
+ if (m_logicalFunction == function)
+ return;
+
+ switch (function)
{
case wxCLEAR:
- x_function = GXclear;
- break;
+ x_function = GXclear;
+ break;
case wxXOR:
- x_function = GXxor;
- break;
+ x_function = GXxor;
+ break;
case wxINVERT:
- x_function = GXinvert;
- break;
+ x_function = GXinvert;
+ break;
case wxOR_REVERSE:
- x_function = GXorReverse;
- break;
+ x_function = GXorReverse;
+ break;
case wxAND_REVERSE:
- x_function = GXandReverse;
- break;
+ x_function = GXandReverse;
+ break;
case wxAND:
- x_function = GXand;
- break;
+ x_function = GXand;
+ break;
case wxOR:
- x_function = GXor;
- break;
+ x_function = GXor;
+ break;
case wxAND_INVERT:
- x_function = GXandInverted;
- break;
+ x_function = GXandInverted;
+ break;
case wxNO_OP:
- x_function = GXnoop;
- break;
+ x_function = GXnoop;
+ break;
case wxNOR:
- x_function = GXnor;
- break;
+ x_function = GXnor;
+ break;
case wxEQUIV:
- x_function = GXequiv;
- break;
+ x_function = GXequiv;
+ break;
case wxSRC_INVERT:
- x_function = GXcopyInverted;
- break;
+ x_function = GXcopyInverted;
+ break;
case wxOR_INVERT:
- x_function = GXorInverted;
- break;
+ x_function = GXorInverted;
+ break;
case wxNAND:
- x_function = GXnand;
- break;
+ x_function = GXnand;
+ break;
case wxSET:
- x_function = GXset;
- break;
+ x_function = GXset;
+ break;
case wxCOPY:
default:
- x_function = GXcopy;
- break;
+ x_function = GXcopy;
+ break;
}
- XSetFunction((Display*) m_display, (GC) m_gc, x_function);
- if (m_window && m_window->GetBackingPixmap())
- XSetFunction((Display*) m_display, (GC) m_gcBacking, x_function);
+ XSetFunction((Display*) m_display, (GC) m_gc, x_function);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetFunction((Display*) m_display, (GC) m_gcBacking, x_function);
- if ((m_logicalFunction == wxXOR) != (function == wxXOR))
- /* MATTHEW: [9] Need to redo pen simply */
- m_autoSetting |= 0x2;
+ if ((m_logicalFunction == wxXOR) != (function == wxXOR))
+ /* MATTHEW: [9] Need to redo pen simply */
+ m_autoSetting |= 0x2;
- m_logicalFunction = function;
+ m_logicalFunction = function;
-};
+}
-void wxWindowDC::SetTextForeground( const wxColour &col )
+void wxWindowDCImpl::SetTextForeground( const wxColour &col )
{
- if (!Ok()) return;
-
- if (m_textForegroundColour == col) return;
-
- m_textForegroundColour = col;
+ wxCHECK_RET( IsOk(), "invalid dc" );
-};
+ m_textForegroundColour = col;
+}
-void wxWindowDC::SetTextBackground( const wxColour &col )
+void wxWindowDCImpl::SetTextBackground( const wxColour &col )
{
- if (!Ok()) return;
-
- if (m_textBackgroundColour == col) return;
-
- m_textBackgroundColour = col;
- if (!m_textBackgroundColour.Ok()) return;
-};
-
-void wxWindowDC::SetBackgroundMode( int mode )
-{
- m_backgroundMode = mode;
+ wxCHECK_RET( IsOk(), "invalid dc" );
-};
+ m_textBackgroundColour = col;
+}
-void wxWindowDC::SetPalette( const wxPalette& palette )
+void wxWindowDCImpl::SetBackgroundMode( int mode )
{
- if (m_window)
- {
- if (palette.Ok())
- /* Use GetXColormap */
- XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
- (Colormap) palette.GetXColormap());
- else
- /* Use wxGetMainColormap */
- XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
- (Colormap) wxTheApp->GetMainColormap(m_display));
- }
-};
+ m_backgroundMode = mode;
+}
-// Helper function
-void wxWindowDC:: SetDCClipping ()
+void wxWindowDCImpl::SetPalette( const wxPalette& palette )
{
- // m_userRegion is the region set by calling SetClippingRegion
-
- if (m_currentRegion)
- XDestroyRegion ((Region) m_currentRegion);
-
- // We need to take into account
- // clipping imposed on a window by a repaint.
- // We'll combine it with the user region. But for now,
- // just use the currently-defined user clipping region.
- if (m_userRegion || (m_window && m_window->GetUpdateRegion().Ok()) )
- m_currentRegion = (WXRegion) XCreateRegion ();
- else
- m_currentRegion = (WXRegion) NULL;
-
- if ((m_window && m_window->GetUpdateRegion().Ok()) && m_userRegion)
- XIntersectRegion ((Region) m_window->GetUpdateRegion().GetXRegion(), (Region) m_userRegion, (Region) m_currentRegion);
- else if (m_userRegion)
- XIntersectRegion ((Region) m_userRegion, (Region) m_userRegion, (Region) m_currentRegion);
- else if (m_window && m_window->GetUpdateRegion().Ok())
- XIntersectRegion ((Region) m_window->GetUpdateRegion().GetXRegion(), (Region) m_window->GetUpdateRegion().GetXRegion(),
-(Region) m_currentRegion);
-
- if (m_currentRegion)
- {
- XSetRegion ((Display*) m_display, (GC) m_gc, (Region) m_currentRegion);
- }
- else
+ if (m_window)
{
- XSetClipMask ((Display*) m_display, (GC) m_gc, None);
+ if (palette.IsOk())
+ /* Use GetXColormap */
+ XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
+ (Colormap) palette.GetXColormap());
+ else
+ /* Use wxGetMainColormap */
+ XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
+ (Colormap) wxTheApp->GetMainColormap(m_display));
}
-
}
-void wxWindowDC::SetClippingRegion( long x, long y, long width, long height )
+static void wxCopyRegion( WXRegion src, WXRegion& dst )
{
- wxDC::SetClippingRegion( x, y, width, height );
-
- if (m_userRegion)
- XDestroyRegion ((Region) m_userRegion);
- m_userRegion = (WXRegion) XCreateRegion ();
- XRectangle r;
- r.x = XLOG2DEV (x);
- r.y = YLOG2DEV (y);
- r.width = XLOG2DEVREL(width);
- r.height = YLOG2DEVREL(height);
- XUnionRectWithRegion (&r, (Region) m_userRegion, (Region) m_userRegion);
-
- SetDCClipping ();
-
- // Needs to work differently for Pixmap: without this,
- // there's a nasty (Display*) m_display bug. 8/12/94
- if (m_window && m_window->GetBackingPixmap())
- {
- XRectangle rects[1];
- rects[0].x = XLOG2DEV_2(x);
- rects[0].y = YLOG2DEV_2(y);
- rects[0].width = XLOG2DEVREL(width);
- rects[0].height = YLOG2DEVREL(height);
- XSetClipRectangles((Display*) m_display, (GC) m_gcBacking, 0, 0, rects, 1, Unsorted);
- }
-};
+ if( !dst )
+ dst = XCreateRegion();
+ XUnionRegion( (Region)src, (Region)src, (Region)dst );
+}
-void wxWindowDC::SetClippingRegion( const wxRegion& region )
+// Helper function; userRegion is the region set by calling SetClippingRegion
+void wxWindowDCImpl::SetDCClipping( WXRegion userRegion )
{
- wxRect box = region.GetBox();
-
- wxDC::SetClippingRegion( box.x, box.y, box.width, box.height );
-
- if (m_userRegion)
- XDestroyRegion ((Region) m_userRegion);
- m_userRegion = (WXRegion) XCreateRegion ();
-
- XUnionRegion((Region) m_userRegion, (Region) region.GetXRegion(), (Region) m_userRegion);
-
- SetDCClipping ();
+ bool hasUpdateRegion = m_window && m_window->GetUpdateRegion().IsOk();
+ // this means that we should start the clip region from scratch,
+ // or from the update region, if any
+ if( !userRegion )
+ {
+ if( m_clipRegion )
+ XDestroyRegion( (Region)m_clipRegion );
+ m_clipRegion = (WXRegion)NULL;
- // Needs to work differently for Pixmap: without this,
- // there's a nasty (Display*) m_display bug. 8/12/94
- if (m_window && m_window->GetBackingPixmap())
- {
- XRectangle rects[1];
- rects[0].x = XLOG2DEV_2(box.x);
- rects[0].y = YLOG2DEV_2(box.y);
- rects[0].width = XLOG2DEVREL(box.width);
- rects[0].height = YLOG2DEVREL(box.height);
- XSetClipRectangles((Display*) m_display, (GC) m_gcBacking, 0, 0, rects, 1, Unsorted);
- }
-};
+ if( hasUpdateRegion )
+ wxCopyRegion( m_window->GetUpdateRegion().GetX11Region(),
+ m_clipRegion );
+ }
+ // intersect the user region, if any, with the
+ // exisiting clip region
+ else // if( userRegion )
+ {
+ if( !m_clipRegion )
+ wxCopyRegion( userRegion, m_clipRegion );
+ else
+ XIntersectRegion( (Region)m_clipRegion,
+ (Region)userRegion, (Region)m_clipRegion );
+ }
+ if( m_clipRegion )
+ XSetRegion( (Display*)m_display, (GC)m_gc, (Region)m_clipRegion );
+ else
+ XSetClipMask( (Display*)m_display, (GC)m_gc, None );
+}
-void wxWindowDC::DestroyClippingRegion(void)
+void wxWindowDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y,
+ wxCoord width, wxCoord height )
{
- wxDC::DestroyClippingRegion();
-
- if (m_userRegion)
- XDestroyRegion ((Region) m_userRegion);
- m_userRegion = NULL;
-
- SetDCClipping ();
+ wxMotifDCImpl::DoSetClippingRegion( x, y, width, height );
- XGCValues gc_val;
- gc_val.clip_mask = None;
- if (m_window && m_window->GetBackingPixmap())
- XChangeGC((Display*) m_display, (GC) m_gcBacking, GCClipMask, &gc_val);
-};
+ wxRegion temp(XLOG2DEV(x), YLOG2DEV(y),
+ XLOG2DEVREL(width), YLOG2DEVREL(height));
-// ----------------------------------- spline code ----------------------------------------
+ SetDCClipping(temp.GetX11Region());
-void wx_quadratic_spline(double a1, double b1, double a2, double b2,
- double a3, double b3, double a4, double b4);
-void wx_clear_stack(void);
-int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
- double *y3, double *x4, double *y4);
-void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
- double x4, double y4);
-static bool wx_spline_add_point(double x, double y);
-static void wx_spline_draw_point_array(wxDC *dc);
-
-wxList wx_spline_point_list;
-
-#define half(z1, z2) ((z1+z2)/2.0)
-#define THRESHOLD 5
-
-/* iterative version */
-
-void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
- double b4)
-{
- register double xmid, ymid;
- double x1, y1, x2, y2, x3, y3, x4, y4;
-
- wx_clear_stack();
- wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
-
- while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
- xmid = (double)half(x2, x3);
- ymid = (double)half(y2, y3);
- if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
- fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
- wx_spline_add_point( x1, y1 );
- wx_spline_add_point( xmid, ymid );
- } else {
- wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
- (double)half(x3, x4), (double)half(y3, y4), x4, y4);
- wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
- (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
- }
+ // Needs to work differently for Pixmap: without this,
+ // there's a nasty (Display*) m_display bug. 8/12/94
+ if (m_window && m_window->GetBackingPixmap())
+ {
+ XRectangle rects[1];
+ rects[0].x = (short)XLOG2DEV_2(x);
+ rects[0].y = (short)YLOG2DEV_2(y);
+ rects[0].width = (unsigned short)XLOG2DEVREL(width);
+ rects[0].height = (unsigned short)YLOG2DEVREL(height);
+ XSetClipRectangles((Display*) m_display, (GC) m_gcBacking,
+ 0, 0, rects, 1, Unsorted);
}
}
-/* utilities used by spline drawing routines */
+void wxWindowDCImpl::DoSetDeviceClippingRegion( const wxRegion& region )
+{
+ SetDCClipping(region.GetX11Region());
-typedef struct wx_spline_stack_struct {
- double x1, y1, x2, y2, x3, y3, x4, y4;
-} Stack;
+ // Needs to work differently for Pixmap: without this,
+ // there's a nasty (Display*) m_display bug. 8/12/94
+ if (m_window && m_window->GetBackingPixmap())
+ {
+ wxRect box = region.GetBox();
+
+ XRectangle rects[1];
+ rects[0].x = (short)box.x;
+ rects[0].y = (short)box.y;
+ rects[0].width = (unsigned short)box.width;
+ rects[0].height = (unsigned short)box.height;
+ XSetClipRectangles((Display*) m_display, (GC) m_gcBacking,
+ 0, 0, rects, 1, Unsorted);
+ }
+}
-#define SPLINE_STACK_DEPTH 20
-static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
-static Stack *wx_stack_top;
-static int wx_stack_count;
-void wx_clear_stack(void)
+void wxWindowDCImpl::DestroyClippingRegion()
{
- wx_stack_top = wx_spline_stack;
- wx_stack_count = 0;
-}
+ wxMotifDCImpl::DestroyClippingRegion();
-void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
-{
- wx_stack_top->x1 = x1;
- wx_stack_top->y1 = y1;
- wx_stack_top->x2 = x2;
- wx_stack_top->y2 = y2;
- wx_stack_top->x3 = x3;
- wx_stack_top->y3 = y3;
- wx_stack_top->x4 = x4;
- wx_stack_top->y4 = y4;
- wx_stack_top++;
- wx_stack_count++;
-}
+ SetDCClipping(NULL);
-int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
- double *x3, double *y3, double *x4, double *y4)
-{
- if (wx_stack_count == 0)
- return (0);
- wx_stack_top--;
- wx_stack_count--;
- *x1 = wx_stack_top->x1;
- *y1 = wx_stack_top->y1;
- *x2 = wx_stack_top->x2;
- *y2 = wx_stack_top->y2;
- *x3 = wx_stack_top->x3;
- *y3 = wx_stack_top->y3;
- *x4 = wx_stack_top->x4;
- *y4 = wx_stack_top->y4;
- return (1);
+ if (m_window && m_window->GetBackingPixmap())
+ XSetClipMask ((Display*) m_display, (GC) m_gcBacking, None);
}
-static bool wx_spline_add_point(double x, double y)
+// Resolution in pixels per logical inch
+wxSize wxWindowDCImpl::GetPPI() const
{
- wxPoint *point = new wxPoint ;
- point->x = (int) x;
- point->y = (int) y;
- wx_spline_point_list.Append((wxObject*)point);
- return TRUE;
+ // TODO
+ return wxSize(100, 100);
}
-static void wx_spline_draw_point_array(wxDC *dc)
+int wxWindowDCImpl::GetDepth() const
{
- dc->DrawLines(&wx_spline_point_list, 0, 0 );
- wxNode *node = wx_spline_point_list.First();
- while (node)
- {
- wxPoint *point = (wxPoint *)node->Data();
- delete point;
- delete node;
- node = wx_spline_point_list.First();
- }
+ // TODO
+ return 24;
}
-void wxWindowDC::DrawSpline( wxList *points )
-{
- wxPoint *p;
- double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
- double x1, y1, x2, y2;
-
- wxNode *node = points->First();
- p = (wxPoint *)node->Data();
- x1 = p->x;
- y1 = p->y;
- node = node->Next();
- p = (wxPoint *)node->Data();
- x2 = p->x;
- y2 = p->y;
- cx1 = (double)((x1 + x2) / 2);
- cy1 = (double)((y1 + y2) / 2);
- cx2 = (double)((cx1 + x2) / 2);
- cy2 = (double)((cy1 + y2) / 2);
+// ----------------------------------------------------------------------------
+// wxPaintDCImpl
+// ----------------------------------------------------------------------------
- wx_spline_add_point(x1, y1);
-
- while ((node = node->Next()) != NULL)
- {
- p = (wxPoint *)node->Data();
- x1 = x2;
- y1 = y2;
- x2 = p->x;
- y2 = p->y;
- cx4 = (double)(x1 + x2) / 2;
- cy4 = (double)(y1 + y2) / 2;
- cx3 = (double)(x1 + cx4) / 2;
- cy3 = (double)(y1 + cy4) / 2;
-
- wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
-
- cx1 = cx4;
- cy1 = cy4;
- cx2 = (double)(cx1 + x2) / 2;
- cy2 = (double)(cy1 + y2) / 2;
- }
+wxPaintDCImpl::wxPaintDCImpl(wxDC *owner, wxWindow* win)
+ : wxWindowDCImpl(owner, win)
+{
+ // Set the clipping region.to the update region
+ SetDCClipping((WXRegion)NULL);
+}
- wx_spline_add_point( cx1, cy1 );
- wx_spline_add_point( x2, y2 );
+wxPaintDCImpl::~wxPaintDCImpl()
+{
+ if (m_window)
+ m_window->ClearUpdateRegion();
+ SetDCClipping((WXRegion)NULL);
+}
- wx_spline_draw_point_array( this );
-};
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
/*
- * wxPaintDC
- */
+ Used when copying between drawables on different (Display*) m_displays. Not
+ very fast, but better than giving up.
+*/
-wxPaintDC::wxPaintDC(wxWindow* win): wxWindowDC(win)
+static void XCopyRemote(Display *src_display, Display *dest_display,
+ Drawable src, Drawable dest,
+ GC destgc,
+ int srcx, int srcy,
+ unsigned int w, unsigned int h,
+ int destx, int desty,
+ bool more, XImage **cache)
{
- wxRegion* region = NULL;
+ XImage *image, *destimage;
+ Colormap destcm, srccm;
+ static const int CACHE_SIZE = 256;
- // Combine all the update rects into a region
- if (win->m_updateRects.Number() > 0)
- {
- int i = 0;
- for (i = 0; i < win->m_updateRects.Number(); i++)
- {
- wxRect* rect = (wxRect*) win->m_updateRects.Nth(i)->Data();
- /*
- cout << "wxPaintDC. wxRect: " << rect->x << ", " << rect->y << ", ";
- cout << rect->width << ", " << rect->height << "\n\n";
- */
-
- if (!region)
- region = new wxRegion(*rect);
- else
- // TODO: is this correct? In SetDCClipping above,
- // XIntersectRegion is used to combine paint and user
- // regions. XIntersectRegion appears to work in that case...
- region->Union(*rect);
- }
- }
+ unsigned int i, j;
+ Pixel cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];
+ int k, cache_pos, all_cache;
+
+ if (!cache || !*cache)
+ image = XGetImage(src_display, src, srcx, srcy, w, h, AllPlanes, ZPixmap);
else
- {
- int cw, ch;
- win->GetClientSize(&cw, &ch);
- region = new wxRegion(wxRect(0, 0, cw, ch));
- }
+ image = *cache;
- win->m_updateRegion = *region;
+ destimage = XGetImage(dest_display, dest, destx, desty, w, h, AllPlanes, ZPixmap);
- // Set the clipping region. Any user-defined region will be combined with this
- // one in SetDCClipping.
- XSetRegion ((Display*) m_display, (GC) m_gc, (Region) region->GetXRegion());
+ srccm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) src_display);
+ destcm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dest_display);
- delete region;
-}
+ cache_pos = 0;
+ all_cache = False;
+
+ for (i = 0; i < w; i++)
+ for (j = 0; j < h; j++) {
+ Pixel pixel;
+ XColor xcol;
+
+ pixel = XGetPixel(image, i, j);
+ for (k = cache_pos; k--; )
+ if (cachesrc[k] == pixel) {
+ pixel = cachedest[k];
+ goto install;
+ }
+ if (all_cache)
+ for (k = CACHE_SIZE; k-- > cache_pos; )
+ if (cachesrc[k] == pixel) {
+ pixel = cachedest[k];
+ goto install;
+ }
+
+ cachesrc[cache_pos] = xcol.pixel = pixel;
+ XQueryColor(src_display, srccm, &xcol);
+ if (!XAllocColor(dest_display, destcm, &xcol))
+ xcol.pixel = 0;
+ cachedest[cache_pos] = pixel = xcol.pixel;
+
+ if (++cache_pos >= CACHE_SIZE) {
+ cache_pos = 0;
+ all_cache = true;
+ }
+
+install:
+ XPutPixel(destimage, i, j, pixel);
+ }
-wxPaintDC::~wxPaintDC()
-{
- XSetClipMask ((Display*) m_display, (GC) m_gc, None);
- if (m_window)
- m_window->m_updateRegion.Clear();
+ XPutImage(dest_display, dest, destgc, destimage, 0, 0, destx, desty, w, h);
+ XDestroyImage(destimage);
+
+ if (more && cache)
+ *cache = image;
+ else
+ XDestroyImage(image);
}
projects / wxWidgets.git / blobdiff