/////////////////////////////////////////////////////////////////////////////
-// 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
/////////////////////////////////////////////////////////////////////////////
/*
- About pens, brushes, and the autoSetting flag:
+ 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 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
+ 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 autoSetting includes 0x2, then the
+ 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
// headers
// ----------------------------------------------------------------------------
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma implementation "dcclient.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
-#include "wx/dcclient.h"
-#include "wx/dcmemory.h"
-#include "wx/window.h"
-#include "wx/app.h"
-#include "wx/image.h"
-#include "wx/log.h"
-
-#include <math.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
#ifdef __VMS__
#pragma message disable nosimpint
#endif
#include "wx/motif/private.h"
+#include "wx/motif/dcclient.h"
#ifdef __EMX__
#include <float.h> // for M_PI
// macros
// ----------------------------------------------------------------------------
- IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
- IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxWindowDC)
- IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
+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
// ----------------------------------------------------------------------------
-// wxWindowDC
+// wxWindowDCImpl
// ----------------------------------------------------------------------------
-void wxWindowDC::Init()
+void wxWindowDCImpl::Init()
{
m_gc = (WXGC) 0;
m_gcBacking = (WXGC) 0;
m_currentPenWidth = 1;
m_currentPenJoin = -1;
m_currentPenDashCount = -1;
- m_currentPenDash = (wxX11Dash*) NULL;
+ m_currentPenDash = NULL;
m_currentStyle = -1;
m_currentFill = -1;
m_colour = wxColourDisplay();
- m_display = (WXDisplay*) NULL;
+ m_display = NULL;
m_pixmap = (WXPixmap) 0;
m_autoSetting = 0;
- m_oldFont = (WXFont) 0;
m_ok = false;
m_clipRegion = (WXRegion) 0;
}
-wxWindowDC::wxWindowDC()
+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_font = window->GetFont();
- m_ok = TRUE;
+ m_ok = true;
m_display = window->GetXDisplay();
m_pixmap = window->GetXWindow();
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 | GCSubwindowMode,
+ GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode
+#if !wxMOTIF_NEW_FONT_HANDLING
+ | GCFont
+#endif
+ ,
&gcvalues);
if (m_window->GetBackingPixmap())
&gcvalues);
}
- m_backgroundPixel = (int) 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;
+ m_backgroundPixel = gcvalues.background;
SetBackground(wxBrush(m_window->GetBackgroundColour(), wxSOLID));
}
-wxWindowDC::~wxWindowDC()
+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;
m_clipRegion = (WXRegion) 0;
}
-extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
- const wxColour & col, int style);
+extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
+ const wxColour & col, wxFloodFillStyle style);
-bool wxWindowDC::DoFloodFill(wxCoord x, wxCoord y,
- const wxColour& col, int style)
+bool wxWindowDCImpl::DoFloodFill(wxCoord x, wxCoord y,
+ const wxColour& col, wxFloodFillStyle style)
{
- return wxDoFloodFill(this, x, y, col, style);
+ return wxDoFloodFill(GetOwner(), x, y, col, style);
}
-
-bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
+
+bool wxWindowDCImpl::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
{
// Generic (and therefore rather inefficient) method.
// Could be improved.
wxMemoryDC memdc;
wxBitmap bitmap(1, 1);
memdc.SelectObject(bitmap);
- memdc.Blit(0, 0, 1, 1, (wxDC*) this, x1, y1);
+ 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;
+ return true;
}
-void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
+void wxWindowDCImpl::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
int x1d, y1d, x2d, y2d;
CalcBoundingBox(x2, y2);
}
-void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
+void wxWindowDCImpl::DoCrossHair( wxCoord x, wxCoord y )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
if (m_autoSetting)
SetPen (m_pen);
}
}
-void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc )
+void wxWindowDCImpl::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
int xx1 = XLOG2DEV (x1);
int yy1 = YLOG2DEV (y1);
while (alpha2 > 360 * 64)
alpha2 -= 360 * 64;
- if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+ if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
{
SetBrush (m_brush);
XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) (GC) m_gc,
}
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
{
if (m_autoSetting)
SetPen (m_pen);
CalcBoundingBox (x2, y2);
}
-void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
+void wxWindowDCImpl::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
int xd, yd, wd, hd;
if (end>start) end-=start;
else end+=360*64-start;
- if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+ 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);
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);
CalcBoundingBox (x + width, y + height);
}
-void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
+void wxWindowDCImpl::DoDrawPoint( wxCoord x, wxCoord y )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
- if (m_pen.Ok() && m_autoSetting)
+ if (m_pen.IsOk() && m_autoSetting)
SetPen (m_pen);
XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y));
CalcBoundingBox (x, y);
}
-void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
+void wxWindowDCImpl::DoDrawLines( int n, const wxPoint points[], wxCoord xoffset, wxCoord yoffset )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ 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);
for (i = 0; i < n; i++)
{
- xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
- xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
+ 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);
{
for (i = 0; i < n; i++)
{
- xpoints[i].x = XLOG2DEV_2 (points[i].x + xoffset);
- xpoints[i].y = YLOG2DEV_2 (points[i].y + yoffset);
+ 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);
}
}
}
-void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
- wxCoord xoffset, wxCoord yoffset, int fillStyle )
+void wxWindowDCImpl::DoDrawPolygon( int n, const wxPoint points[],
+ wxCoord xoffset, wxCoord yoffset, wxPolygonFillMode fillStyle )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ 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++)
{
- 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);
+ 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);
}
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);
}
}
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
{
if (m_autoSetting)
SetPen (m_pen);
delete[]xpoints2;
}
-void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
+void wxWindowDCImpl::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
int xd, yd, wfd, hfd, wd, hd;
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);
wfd, hfd);
}
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
{
if (m_autoSetting)
SetPen (m_pen);
CalcBoundingBox (x + width, y + height);
}
-void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
+void wxWindowDCImpl::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
// If radius is negative, it's a proportion of the smaller dimension.
// X drawing errors with small radii
if (rd == 0)
{
- DrawRectangle( x, y, width, height );
+ DoDrawRectangle( x, y, width, height );
return;
}
int rw_d2 = rd2 * 2;
int rh_d2 = rw_d2;
- if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+ if (m_brush.IsOk() && m_brush.GetStyle () != wxTRANSPARENT)
{
SetBrush (m_brush);
}
}
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
{
SetPen (m_pen);
XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
CalcBoundingBox (x + width, y + height);
}
-void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
+void wxWindowDCImpl::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
// Check for negative width and height
if (height < 0)
wd = XLOG2DEVREL(width) ;
hd = YLOG2DEVREL(height) ;
- if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+ 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);
YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
}
- if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+ if (m_pen.IsOk() && m_pen.GetStyle () != wxTRANSPARENT)
{
if (m_autoSetting)
SetPen (m_pen);
}
-bool wxWindowDC::CanDrawBitmap() const
+bool wxWindowDCImpl::CanDrawBitmap() const
{
- wxCHECK_MSG( Ok(), FALSE, "invalid dc" );
+ wxCHECK_MSG( IsOk(), false, "invalid dc" );
- return TRUE;
+ return true;
}
-// TODO: use scaled Blit e.g. as per John Price's implementation
+// TODO: use scaled Blit e.g. as per John Price's implementation
// in Contrib/Utilities
-bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
+bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
wxCoord width, wxCoord height,
wxDC *source, wxCoord xsrc, wxCoord ysrc,
- int rop, bool useMask,
+ wxRasterOperationMode rop, bool useMask,
wxCoord xsrcMask, wxCoord ysrcMask )
{
- wxCHECK_MSG( Ok(), FALSE, "invalid dc" );
+ wxCHECK_MSG( IsOk(), false, "invalid dc" );
+
+ wxWindowDC const * sourceDC = wxDynamicCast(source, wxWindowDC);
+ wxCHECK_MSG( sourceDC, false, "Blit source DC must be wxWindowDCImpl or derived class." );
- wxWindowDC* sourceDC = wxDynamicCast(source, wxWindowDC);
+ // 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;
- wxASSERT_MSG( sourceDC, "Blit source DC must be wxWindowDC or derived class." );
// 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
- int oldBackgroundPixel = -1;
- int oldForegroundPixel = -1;
+ WXPixel oldBackgroundPixel = -1;
+ WXPixel oldForegroundPixel = -1;
- if (m_textBackgroundColour.Ok())
+ if (m_textBackgroundColour.IsOk())
{
oldBackgroundPixel = m_backgroundPixel;
- int pixel = m_textBackgroundColour.AllocColour(m_display);
+ 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.Ok())
+ if (m_textForegroundColour.IsOk())
{
oldForegroundPixel = m_currentColour.GetPixel();
if( m_textForegroundColour.GetPixel() <= -1 )
CalculatePixel( m_textForegroundColour,
- m_textForegroundColour, TRUE);
-
- int pixel = m_textForegroundColour.GetPixel();
+ m_textForegroundColour, true);
+
+ WXPixel pixel = m_textForegroundColour.GetPixel();
if (pixel > -1)
SetForegroundPixelWithLogicalFunction(pixel);
}
// Do bitmap scaling if necessary
- wxBitmap *scaledBitmap = (wxBitmap*) NULL;
+ wxBitmap *scaledBitmap = NULL;
Pixmap sourcePixmap = (Pixmap) NULL;
double scaleX, scaleY;
GetUserScale(& scaleX, & scaleY);
- bool retVal = FALSE;
+ bool retVal = false;
/* TODO: use the mask origin when drawing transparently */
if (xsrcMask == -1 && ysrcMask == -1)
if (!useMask && (scaleX != 1.0 || scaleY != 1.0) && sourceDC->IsKindOf(CLASSINFO(wxMemoryDC)))
{
wxMemoryDC* memDC = (wxMemoryDC*) sourceDC;
- wxBitmap& bitmap = memDC->GetBitmap();
+ wxBitmap& bitmap = memDC->GetSelectedBitmap();
- wxASSERT_MSG( (bitmap.Ok()), "Bad source bitmap in wxWindowDC::Blit");
+ wxASSERT_MSG( (bitmap.IsOk()), "Bad source bitmap in wxWindowDCImpl::Blit");
wxImage image = bitmap.ConvertToImage();
- if (!image.Ok())
+ if (!image.IsOk())
{
sourcePixmap = (Pixmap) bitmap.GetDrawable();
}
}
}
else
- sourcePixmap = (Pixmap) sourceDC->m_pixmap;
+ {
+ sourcePixmap = (Pixmap) srcImpl->m_pixmap;
+ }
if (m_pixmap && sourcePixmap)
{
/* MATTHEW: [9] */
- int orig = m_logicalFunction;
+ wxRasterOperationMode orig = m_logicalFunction;
SetLogicalFunction (rop);
- if (m_display != sourceDC->m_display)
+ if (m_display != srcDpy)
{
XImage *cache = NULL;
if (m_window && m_window->GetBackingPixmap())
- XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display,
+ XCopyRemote((Display*) srcDpy, (Display*) m_display,
(Pixmap) sourcePixmap, (Pixmap) m_window->GetBackingPixmap(),
(GC) m_gcBacking,
source->LogicalToDeviceX (xsrc),
source->LogicalToDeviceXRel(width),
source->LogicalToDeviceYRel(height),
XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest),
- TRUE, &cache);
+ True, &cache);
if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
{
wxMemoryDC *memDC = (wxMemoryDC *)source;
- wxBitmap& sel = memDC->GetBitmap();
- if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetBitmap() )
+ 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*) sourceDC->m_display, (Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,
+ 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);
+ False, &cache);
if ( useMask )
{
} else
{ //XGCValues values;
- //XGetGCValues((Display*)m_display, (GC)m_gc, GCForeground, &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)->GetBitmap().GetDepth() == 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),
if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
{
wxMemoryDC *memDC = (wxMemoryDC *)source;
- wxBitmap& sel = memDC->GetBitmap();
- if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetBitmap() )
+ 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)->GetBitmap().Ok() && (((wxMemoryDC*)source)->GetBitmap().GetDepth () == 1))
+ ((wxMemoryDC*)source)->GetSelectedBitmap().IsOk() &&
+ (((wxMemoryDC*)source)->GetSelectedBitmap().GetDepth () == 1))
{
XCopyPlane ((Display*) m_display, (Pixmap) sourcePixmap, (Pixmap) m_pixmap, (GC) m_gc,
source->LogicalToDeviceX (xsrc),
SetLogicalFunction(orig);
- retVal = TRUE;
+ retVal = true;
}
if (scaledBitmap) delete scaledBitmap;
return retVal;
}
-void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
+void wxWindowDCImpl::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
// 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;
+ int slen = text.length();
// Set FillStyle, otherwise X will use current stipple!
XGCValues gcV, gcBackingV;
XSetFillStyle ((Display*) m_display, (GC) m_gcBacking, FillSolid);
}
- slen = strlen(text);
-
- if (m_font.Ok())
- {
- WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
- int direction, descent;
- XCharStruct overall_return;
-#if 0
- if (use16)
- (void)XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *)(const char*) text, slen, &direction,
- &ascent, &descent, &overall_return);
- else
-#endif // 0
- (void)XTextExtents((XFontStruct*) pFontStruct,
- wxConstCast(text.c_str(), char),
- slen, &direction,
- &ascent, &descent, &overall_return);
-
- cx = overall_return.width;
- cy = ascent + descent;
- }
+ if (m_font.IsOk())
+ wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
+ text, &cx, &cy, &ascent, NULL);
// First draw a rectangle representing the text background, if a text
// background is specified
- if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
+ if (m_textBackgroundColour.IsOk () && (m_backgroundMode != wxTRANSPARENT))
{
wxColour oldPenColour = m_currentColour;
m_currentColour = m_textBackgroundColour;
- bool sameColour = (oldPenColour.Ok () && m_textBackgroundColour.Ok () &&
+ bool sameColour = (oldPenColour.IsOk () && m_textBackgroundColour.IsOk () &&
(oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
(oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
(oldPenColour.Green () == m_textBackgroundColour.Green ()));
sameColour = (sameColour &&
(oldPenColour.GetPixel() == m_textBackgroundColour.GetPixel()));
- if (!sameColour || !GetOptimization())
+ if (!sameColour || !GET_OPTIMIZATION)
{
- int pixel = m_textBackgroundColour.AllocColour(m_display);
+ WXPixel pixel = m_textBackgroundColour.AllocColour(m_display);
m_currentColour = m_textBackgroundColour;
// Set the GC to the required colour
}
// Now set the text foreground and draw the text
- if (m_textForegroundColour.Ok ())
+ if (m_textForegroundColour.IsOk ())
{
wxColour oldPenColour = m_currentColour;
m_currentColour = m_textForegroundColour;
- bool sameColour = (oldPenColour.Ok () && m_currentColour.Ok () &&
+ 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 || !GetOptimization())
+ if (!sameColour || !GET_OPTIMIZATION)
{
- int pixel = CalculatePixel(m_textForegroundColour,
- m_currentColour, FALSE);
+ WXPixel pixel = CalculatePixel(m_textForegroundColour,
+ m_currentColour, false);
// Set the GC to the required colour
if (pixel > -1)
(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
if (m_window && m_window->GetBackingPixmap()) {
#if 0
(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,
- wxConstCast(text.c_str(), char), slen);
+ text.mb_str(), slen);
+#endif
}
// restore fill style
gcBackingV.fill_style);
wxCoord w, h;
- GetTextExtent (text, &w, &h);
+ DoGetTextExtent (text, &w, &h);
CalcBoundingBox (x + w, y + h);
CalcBoundingBox (x, y);
}
-void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
+void wxWindowDCImpl::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y,
double angle )
{
if (angle == 0.0)
{
- DrawText(text, x, y);
+ DoDrawText(text, x, y);
return;
}
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
- int oldBackgroundPixel = -1;
- int oldForegroundPixel = -1;
- int foregroundPixel = -1;
- int backgroundPixel = -1;
+ WXPixel oldBackgroundPixel = -1;
+ WXPixel oldForegroundPixel = -1;
+ WXPixel foregroundPixel = -1;
+ WXPixel backgroundPixel = -1;
- if (m_textBackgroundColour.Ok())
+ if (m_textBackgroundColour.IsOk())
{
oldBackgroundPixel = m_backgroundPixel;
backgroundPixel = m_textBackgroundColour.AllocColour(m_display);
}
- if (m_textForegroundColour.Ok())
+ if (m_textForegroundColour.IsOk())
{
oldForegroundPixel = m_currentColour.GetPixel();
if( m_textForegroundColour.GetPixel() <= -1 )
CalculatePixel( m_textForegroundColour,
- m_textForegroundColour, TRUE);
-
+ m_textForegroundColour, true);
+
foregroundPixel = m_textForegroundColour.GetPixel();
}
int cx = 0;
int cy = 0;
int ascent = 0;
- int slen = text.length();
-
- if (m_font.Ok())
- {
- // Calculate text extent.
- WXFontStructPtr pFontStruct =
- m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
- int direction, descent;
- XCharStruct overall_return;
-#if 0
- if (use16)
- (void)XTextExtents16((XFontStruct*) pFontStruct,
- (XChar2b *)(const char*) text,
- slen, &direction,
- &ascent, &descent, &overall_return);
- else
-#endif // 0
- (void)XTextExtents((XFontStruct*) pFontStruct,
- wxConstCast(text.c_str(), char),
- slen, &direction,
- &ascent, &descent, &overall_return);
- cx = overall_return.width;
- cy = ascent + descent;
- }
+ if (m_font.IsOk())
+ wxGetTextExtent (m_display, m_font, m_userScaleY * m_logicalScaleY,
+ text, &cx, &cy, &ascent, NULL);
wxBitmap src(cx, cy);
wxMemoryDC dc;
CalcBoundingBox (maxx, maxy);
}
-bool wxWindowDC::CanGetTextExtent() const
+bool wxWindowDCImpl::CanGetTextExtent() const
{
- return TRUE;
+ return true;
}
-void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
+void wxWindowDCImpl::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
wxCoord *descent, wxCoord *externalLeading,
- wxFont *font ) const
+ const wxFont *font ) const
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
- wxFont* theFont = font;
- if (!theFont)
- theFont = (wxFont *)&m_font; // const_cast
+ const wxFont* theFont = font ? font : &m_font;
- if (!theFont->Ok())
+ if (!theFont->IsOk())
{
// TODO: this should be an error log function
wxFAIL_MSG("set a valid font before calling GetTextExtent!");
return;
}
- WXFontStructPtr pFontStruct = theFont->GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
-
- int direction, ascent, descent2;
- XCharStruct overall;
- int slen;
-
-#if 0
- if (use16)
- slen = str16len(string);
- else
-#endif // 0
- slen = strlen(string);
+ wxGetTextExtent(m_display, *theFont, m_userScaleY * m_logicalScaleY,
+ string, width, height, NULL, descent);
-#if 0
- if (use16)
- XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
- &ascent, &descent2, &overall);
- else
-#endif // 0
- XTextExtents((XFontStruct*) pFontStruct,
- wxConstCast(string.c_str(), char), slen, &direction,
- &ascent, &descent2, &overall);
-
- if (width) *width = XDEV2LOGREL (overall.width);
- if (height) *height = YDEV2LOGREL (ascent + descent2);
- if (descent)
- *descent = descent2;
+ if (width) *width = XDEV2LOGREL (*width);
+ if (height) *height = YDEV2LOGREL (*height);
if (externalLeading)
*externalLeading = 0;
}
-wxCoord wxWindowDC::GetCharWidth() const
+wxCoord wxWindowDCImpl::GetCharWidth() const
{
- wxCHECK_MSG( Ok(), 0, "invalid dc" );
- wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
+ wxCHECK_MSG( IsOk(), 0, "invalid dc" );
+ wxCHECK_MSG( m_font.IsOk(), 0, "invalid font" );
+
+ 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);
}
-wxCoord wxWindowDC::GetCharHeight() const
+wxCoord wxWindowDCImpl::GetCharHeight() const
{
- wxCHECK_MSG( Ok(), 0, "invalid dc" );
- wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
+ wxCHECK_MSG( IsOk(), 0, "invalid dc" );
+ wxCHECK_MSG( m_font.IsOk(), 0, "invalid font" );
- WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
+ int height;
+
+ 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::DoGetSize( int *width, int *height ) const
+void wxWindowDCImpl::DoGetSize( int *width, int *height ) const
{
int w = 0, h = 0;
if( height ) *height = h;
}
-void wxWindowDC::Clear()
+void wxWindowDCImpl::Clear()
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
wxRect rect( GetSize() );
Clear( rect );
}
-void wxWindowDC::Clear(const wxRect& rect)
+void wxWindowDCImpl::Clear(const wxRect& rect)
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
int x = rect.x; int y = rect.y;
int w = rect.width; int h = rect.height;
m_brush = saveBrush;
}
-void wxWindowDC::SetFont( const wxFont &font )
+void wxWindowDCImpl::SetFont( const wxFont &font )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
m_font = font;
- if (!m_font.Ok())
+ if (!m_font.IsOk())
{
- if ((m_oldFont != (WXFont) 0) && ((wxCoord) 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);
- }
return;
}
+#if !wxMOTIF_NEW_FONT_HANDLING
WXFontStructPtr pFontStruct = m_font.GetFontStruct(m_userScaleY*m_logicalScaleY, m_display);
Font fontId = ((XFontStruct*)pFontStruct)->fid;
if (m_window && m_window->GetBackingPixmap())
XSetFont ((Display*) m_display,(GC) m_gcBacking, fontId);
+#endif
}
-void wxWindowDC::SetForegroundPixelWithLogicalFunction(int pixel)
+void wxWindowDCImpl::SetForegroundPixelWithLogicalFunction(WXPixel pixel)
{
if (m_logicalFunction == wxXOR)
{
}
}
-int wxWindowDC::CalculatePixel(wxColour& colour, wxColour& curCol,
+WXPixel wxWindowDCImpl::CalculatePixel(wxColour& colour, wxColour& curCol,
bool roundToWhite) const
{
const unsigned char wp = (unsigned char)255;
-
- int pixel = -1;
+
+ WXPixel pixel = -1;
if(!m_colour) // Mono display
{
unsigned char red = colour.Red ();
((red != 0 || blue != 0 || green != 0) && roundToWhite))
{
curCol = *wxWHITE;
- pixel = (int)WhitePixel((Display*) m_display,
- DefaultScreen((Display*) m_display));
+ pixel = WhitePixel((Display*) m_display,
+ DefaultScreen((Display*) m_display));
curCol.SetPixel(pixel);
colour.SetPixel(pixel);
}
else
{
curCol = *wxBLACK;
- pixel = (int)BlackPixel((Display*) m_display,
- DefaultScreen((Display*) m_display));
+ pixel = BlackPixel((Display*) m_display,
+ DefaultScreen((Display*) m_display));
curCol.SetPixel(pixel);
colour.SetPixel(pixel);
}
return pixel;
}
-void wxWindowDC::SetPen( const wxPen &pen )
+void wxWindowDCImpl::SetPen( const wxPen &pen )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
m_pen = pen;
- if (!m_pen.Ok())
+ if (!m_pen.IsOk())
return;
wxBitmap oldStipple = m_currentStipple;
old_pen_dash == m_currentPenDash &&
old_pen_width == m_currentPenWidth);
- bool sameColour = (oldPenColour.Ok () &&
+ 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 || !GetOptimization())
+ if (!sameStyle || !GET_OPTIMIZATION)
{
int scaled_width = (int) XLOG2DEVREL (m_pen.GetWidth ());
if (scaled_width < 0)
case wxTRANSPARENT:
default:
style = LineSolid;
- req_dash = (wxX11Dash*)NULL;
+ req_dash = NULL;
req_nb_dash = 0;
}
{
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;
+ 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())
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;
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.GetDrawable());
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;
}
// must test m_logicalFunction, because it involves background!
- if (!sameColour || !GetOptimization()
+ if (!sameColour || !GET_OPTIMIZATION
|| ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))
{
- int pixel = -1;
+ WXPixel pixel = -1;
if (m_pen.GetStyle () == wxTRANSPARENT)
pixel = m_backgroundPixel;
else
{
- pixel = CalculatePixel(m_pen.GetColour(), m_currentColour, FALSE);
+ wxColour penClr = m_pen.GetColour();
+ pixel = CalculatePixel( penClr, m_currentColour, false);
+ m_pen.SetColour(penClr);
}
// Finally, set the GC to the required colour
m_autoSetting = 0;
}
-void wxWindowDC::SetBrush( const wxBrush &brush )
+void wxWindowDCImpl::SetBrush( const wxBrush &brush )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
m_brush = brush;
- if (!m_brush.Ok() || m_brush.GetStyle () == wxTRANSPARENT)
+ if (!m_brush.IsOk() || m_brush.GetStyle () == wxTRANSPARENT)
return;
int oldFill = m_currentFill;
wxColour oldBrushColour(m_currentColour);
m_currentColour = m_brush.GetColour ();
- bool sameColour = (oldBrushColour.Ok () &&
+ bool sameColour = (oldBrushColour.IsOk () &&
(oldBrushColour.Red () == m_currentColour.Red ()) &&
(oldBrushColour.Blue () == m_currentColour.Blue ()) &&
(oldBrushColour.Green () == m_currentColour.Green ()) &&
int stippleDepth = -1;
- if ((oldFill != m_brush.GetStyle ()) || !GetOptimization())
+ if ((oldFill != m_brush.GetStyle ()) || !GET_OPTIMIZATION)
{
switch (brush.GetStyle ())
{
// determine whether fill style should be solid or
// transparent
int style = stippleDepth == 1 ?
- (m_backgroundMode == wxSOLID ?
+ (m_backgroundMode == wxSOLID ?
FillOpaqueStippled : FillStippled) :
FillTiled;
XSetFillStyle ((Display*) m_display, (GC) m_gc, style);
}
}
- if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
+ if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GET_OPTIMIZATION))
{
Pixmap myStipple;
// X can forget the stipple value when resizing a window (apparently)
// so always set the stipple.
else if (m_currentFill != wxSOLID && m_currentFill != wxTRANSPARENT &&
- m_currentStipple.Ok()) // && m_currentStipple != oldStipple)
+ m_currentStipple.IsOk()) // && m_currentStipple != oldStipple)
{
if (m_currentStipple.GetDepth() == 1)
{
}
// must test m_logicalFunction, because it involves background!
- if (!sameColour || !GetOptimization() || m_logicalFunction == wxXOR)
+ if (!sameColour || !GET_OPTIMIZATION || m_logicalFunction == wxXOR)
{
- int pixel = CalculatePixel(m_brush.GetColour(), m_currentColour, TRUE);
-
+ wxColour brushClr = m_brush.GetColour();
+ WXPixel pixel = CalculatePixel( brushClr, m_currentColour, true);
+ m_brush.SetColour(brushClr);
+
if (pixel > -1)
SetForegroundPixelWithLogicalFunction(pixel);
}
m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());
}
-void wxWindowDC::SetBackground( const wxBrush &brush )
+void wxWindowDCImpl::SetBackground( const wxBrush &brush )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
m_backgroundBrush = brush;
- if (!m_backgroundBrush.Ok())
+ if (!m_backgroundBrush.IsOk())
return;
m_backgroundPixel = m_backgroundBrush.GetColour().AllocColour(m_display);
m_backgroundPixel);
}
-void wxWindowDC::SetLogicalFunction( int function )
+void wxWindowDCImpl::SetLogicalFunction( wxRasterOperationMode function )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
int x_function;
}
-void wxWindowDC::SetTextForeground( const wxColour &col )
+void wxWindowDCImpl::SetTextForeground( const wxColour &col )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
m_textForegroundColour = col;
}
-void wxWindowDC::SetTextBackground( const wxColour &col )
+void wxWindowDCImpl::SetTextBackground( const wxColour &col )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( IsOk(), "invalid dc" );
m_textBackgroundColour = col;
}
-void wxWindowDC::SetBackgroundMode( int mode )
+void wxWindowDCImpl::SetBackgroundMode( int mode )
{
m_backgroundMode = mode;
}
-void wxWindowDC::SetPalette( const wxPalette& palette )
+void wxWindowDCImpl::SetPalette( const wxPalette& palette )
{
if (m_window)
{
- if (palette.Ok())
+ if (palette.IsOk())
/* Use GetXColormap */
XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
(Colormap) palette.GetXColormap());
}
// Helper function; userRegion is the region set by calling SetClippingRegion
-void wxWindowDC::SetDCClipping( WXRegion userRegion )
+void wxWindowDCImpl::SetDCClipping( WXRegion userRegion )
{
- bool hasUpdateRegion = m_window && m_window->GetUpdateRegion().Ok();
+ 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 )
XSetClipMask( (Display*)m_display, (GC)m_gc, None );
}
-void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y,
+void wxWindowDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y,
wxCoord width, wxCoord height )
{
- wxDC::DoSetClippingRegion( x, y, width, height );
+ wxMotifDCImpl::DoSetClippingRegion( x, y, width, height );
- wxRegion temp(x, y, width, height);
+ wxRegion temp(XLOG2DEV(x), YLOG2DEV(y),
+ XLOG2DEVREL(width), YLOG2DEVREL(height));
SetDCClipping(temp.GetX11Region());
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);
+ 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);
}
}
-void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
+void wxWindowDCImpl::DoSetDeviceClippingRegion( const wxRegion& region )
{
- wxRect box = region.GetBox();
-
- wxDC::DoSetClippingRegion( box.x, box.y, box.width, box.height );
-
SetDCClipping(region.GetX11Region());
// 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 = XLOG2DEV_2(box.x);
- rects[0].y = YLOG2DEV_2(box.y);
- rects[0].width = XLOG2DEVREL(box.width);
- rects[0].height = YLOG2DEVREL(box.height);
+ 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);
}
}
-void wxWindowDC::DestroyClippingRegion()
+void wxWindowDCImpl::DestroyClippingRegion()
{
- wxDC::DestroyClippingRegion();
+ wxMotifDCImpl::DestroyClippingRegion();
SetDCClipping(NULL);
}
// Resolution in pixels per logical inch
-wxSize wxWindowDC::GetPPI() const
+wxSize wxWindowDCImpl::GetPPI() const
{
// TODO
return wxSize(100, 100);
}
-int wxWindowDC::GetDepth() const
+int wxWindowDCImpl::GetDepth() const
{
// TODO
return 24;
// ----------------------------------------------------------------------------
-// wxPaintDC
+// wxPaintDCImpl
// ----------------------------------------------------------------------------
-wxPaintDC::wxPaintDC(wxWindow* win) : wxWindowDC(win)
+wxPaintDCImpl::wxPaintDCImpl(wxDC *owner, wxWindow* win)
+ : wxWindowDCImpl(owner, win)
{
// Set the clipping region.to the update region
- SetDCClipping((WXRegion)NULL);
+ SetDCClipping((WXRegion)NULL);
}
-wxPaintDC::~wxPaintDC()
+wxPaintDCImpl::~wxPaintDCImpl()
{
if (m_window)
m_window->ClearUpdateRegion();
static const int CACHE_SIZE = 256;
unsigned int i, j;
- unsigned long cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];
+ Pixel cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];
int k, cache_pos, all_cache;
if (!cache || !*cache)
destcm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dest_display);
cache_pos = 0;
- all_cache = FALSE;
+ all_cache = False;
for (i = 0; i < w; i++)
for (j = 0; j < h; j++) {
- unsigned long pixel;
+ Pixel pixel;
XColor xcol;
pixel = XGetPixel(image, i, j);
if (++cache_pos >= CACHE_SIZE) {
cache_pos = 0;
- all_cache = TRUE;
+ all_cache = true;
}
install:
XPutImage(dest_display, dest, destgc, destimage, 0, 0, destx, desty, w, h);
XDestroyImage(destimage);
- if (more)
+ if (more && cache)
*cache = image;
else
XDestroyImage(image);
}
-#if 0
-
-/* Helper function for 16-bit fonts */
-static int str16len(const char *s)
-{
- int count = 0;
-
- while (s[0] && s[1]) {
- count++;
- s += 2;
- }
-
- return count;
-}
-
-#endif // 0
projects / wxWidgets.git / blobdiff