// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
-// Id:
+// RCS-ID: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#endif
#include "wx/dcclient.h"
+#include "wx/dcmemory.h"
//-----------------------------------------------------------------------------
// local data
#define num_hatches 6
static GdkPixmap *hatches[num_hatches];
-static GdkPixmap **hatch_bitmap = NULL;
+static GdkPixmap **hatch_bitmap = (GdkPixmap **) NULL;
//-----------------------------------------------------------------------------
// constants
#define RAD2DEG 57.2957795131
+//-----------------------------------------------------------------------------
+// temporary implementation of the missing GDK function
+//-----------------------------------------------------------------------------
+#include "gdk/gdkprivate.h"
+void gdk_draw_bitmap (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkDrawable *src,
+ gint xsrc,
+ gint ysrc,
+ gint xdest,
+ gint ydest,
+ gint width,
+ gint height)
+{
+ GdkWindowPrivate *drawable_private;
+ GdkWindowPrivate *src_private;
+ GdkGCPrivate *gc_private;
+
+ g_return_if_fail (drawable != NULL);
+ g_return_if_fail (src != NULL);
+ g_return_if_fail (gc != NULL);
+
+ drawable_private = (GdkWindowPrivate*) drawable;
+ src_private = (GdkWindowPrivate*) src;
+ if (drawable_private->destroyed || src_private->destroyed)
+ return;
+ gc_private = (GdkGCPrivate*) gc;
+
+ if (width == -1)
+ width = src_private->width;
+ if (height == -1)
+ height = src_private->height;
+
+ XCopyPlane (drawable_private->xdisplay,
+ src_private->xwindow,
+ drawable_private->xwindow,
+ gc_private->xgc,
+ xsrc, ysrc,
+ width, height,
+ xdest, ydest,
+ 1);
+}
+
//-----------------------------------------------------------------------------
// wxPaintDC
//-----------------------------------------------------------------------------
wxPaintDC::wxPaintDC(void)
{
-};
+ m_penGC = (GdkGC *) NULL;
+ m_brushGC = (GdkGC *) NULL;
+ m_textGC = (GdkGC *) NULL;
+ m_bgGC = (GdkGC *) NULL;
+ m_cmap = (GdkColormap *) NULL;
+}
wxPaintDC::wxPaintDC( wxWindow *window )
{
+ m_penGC = (GdkGC *) NULL;
+ m_brushGC = (GdkGC *) NULL;
+ m_textGC = (GdkGC *) NULL;
+ m_bgGC = (GdkGC *) NULL;
+ m_cmap = (GdkColormap *) NULL;
+
if (!window) return;
GtkWidget *widget = window->m_wxwindow;
if (!widget) return;
m_cmap = gtk_widget_get_colormap( window->m_wxwindow );
else
m_cmap = gtk_widget_get_colormap( window->m_widget );
+
+ m_isDrawable = TRUE;
+
SetUpDC();
-
- long x = 0;
- long y = 0;
- window->GetDrawingOffset( &x, &y );
- SetInternalDeviceOrigin( -x, -y );
-};
+}
wxPaintDC::~wxPaintDC(void)
{
-};
+}
void wxPaintDC::FloodFill( long WXUNUSED(x1), long WXUNUSED(y1),
wxColour *WXUNUSED(col), int WXUNUSED(style) )
{
-};
+ wxFAIL_MSG( "wxPaintDC::FloodFill not implemented" );
+}
bool wxPaintDC::GetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const
{
+ wxFAIL_MSG( "wxPaintDC::GetPixel not implemented" );
return FALSE;
-};
+}
void wxPaintDC::DrawLine( long x1, long y1, long x2, long y2 )
{
if (!Ok()) return;
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
if (m_pen.GetStyle() != wxTRANSPARENT)
{
gdk_draw_line( m_window, m_penGC,
XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
- };
-};
+ }
+}
void wxPaintDC::CrossHair( long x, long y )
{
if (!Ok()) return;
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
if (m_pen.GetStyle() != wxTRANSPARENT)
{
int w = 0;
0, yy, XLOG2DEVREL(w), yy );
gdk_draw_line( m_window, m_penGC,
xx, 0, xx, YLOG2DEVREL(h) );
- };
-};
+ }
+}
void wxPaintDC::DrawArc( long x1, long y1, long x2, long y2, double xc, double yc )
{
if (!Ok()) return;
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
long xx1 = XLOG2DEV(x1);
long yy1 = YLOG2DEV(y1);
long xx2 = XLOG2DEV(x2);
radius2 = (xx2 - xxc == 0) ?
(yy2 - yyc < 0) ? 90.0 : -90.0 :
-atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
- };
+ }
long alpha1 = long(radius1 * 64.0);
long alpha2 = long((radius2 - radius1) * 64.0);
while (alpha2 <= 0) alpha2 += 360*64;
if (m_pen.GetStyle() != wxTRANSPARENT)
gdk_draw_arc( m_window, m_penGC, FALSE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
-};
+}
void wxPaintDC::DrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
{
if (!Ok()) return;
- if (width<0) { width=-width; x=x-width; }
- if (height<0) { height=-height; y=y-height; }
-
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
long xx = XLOG2DEV(x);
long yy = YLOG2DEV(y);
- long ww = XLOG2DEVREL(width);
- long hh = YLOG2DEVREL(height);
+ long ww = m_signX * XLOG2DEVREL(width);
+ long hh = m_signY * YLOG2DEVREL(height);
+ // CMB: handle -ve width and/or height
+ if (ww < 0) { ww = -ww; xx = xx - ww; }
+ if (hh < 0) { hh = -hh; yy = yy - hh; }
+
+ long start = long(sa * 64.0);
+ long end = long(ea * 64.0);
if (m_brush.GetStyle() != wxTRANSPARENT)
- gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww-1, hh-1, 0, long(sa*64) );
+ gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
if (m_pen.GetStyle() != wxTRANSPARENT)
- gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, 0, long(ea*64) );
-};
+ gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, start, end );
+}
void wxPaintDC::DrawPoint( long x, long y )
{
if (!Ok()) return;
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
if (m_pen.GetStyle() != wxTRANSPARENT)
gdk_draw_point( m_window, m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
-};
+}
void wxPaintDC::DrawLines( int n, wxPoint points[], long xoffset, long yoffset )
{
if (!Ok()) return;
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
if (m_pen.GetStyle() == wxTRANSPARENT) return;
for (int i = 0; i < n-1; i++)
long x2 = XLOG2DEV(points[i+1].x + xoffset);
long y1 = YLOG2DEV(points[i].y + yoffset); // oh, what a waste
long y2 = YLOG2DEV(points[i+1].y + yoffset);
- gdk_draw_line( m_window, m_brushGC, x1, y1, x2, y2 );
- };
-};
+ gdk_draw_line( m_window, m_penGC, x1, y1, x2, y2 );
+ }
+}
void wxPaintDC::DrawLines( wxList *points, long xoffset, long yoffset )
{
if (!Ok()) return;
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
if (m_pen.GetStyle() == wxTRANSPARENT) return;
wxNode *node = points->First();
long x2 = XLOG2DEV(npoint->x + xoffset);
long y1 = YLOG2DEV(point->y + yoffset); // and again...
long y2 = YLOG2DEV(npoint->y + yoffset);
- gdk_draw_line( m_window, m_brushGC, x1, y1, x2, y2 );
+ gdk_draw_line( m_window, m_penGC, x1, y1, x2, y2 );
node = node->Next();
- };
-};
+ }
+}
-void wxPaintDC::DrawPolygon( int WXUNUSED(n), wxPoint WXUNUSED(points)[],
- long WXUNUSED(xoffset), long WXUNUSED(yoffset), int WXUNUSED(fillStyle) )
+void wxPaintDC::DrawPolygon( int n, wxPoint points[], long xoffset, long yoffset, int WXUNUSED(fillStyle) )
{
if (!Ok()) return;
-};
+
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
+ if (!n) return; // Nothing to draw
+ GdkPoint *gdkpoints = new GdkPoint[n+1];
+ int i;
+ for (i = 0 ; i < n ; i++)
+ {
+ gdkpoints[i].x = XLOG2DEV(points[i].x + xoffset);
+ gdkpoints[i].y = YLOG2DEV(points[i].y + yoffset);
+ }
+ if (m_brush.GetStyle() != wxTRANSPARENT)
+ gdk_draw_polygon (m_window, m_brushGC, TRUE, gdkpoints, n);
+ // To do: Fillstyle
+ if (m_pen.GetStyle() != wxTRANSPARENT)
+ for (i = 0 ; i < n ; i++)
+ gdk_draw_line( m_window, m_penGC,
+ gdkpoints[i%n].x,
+ gdkpoints[i%n].y,
+ gdkpoints[(i+1)%n].x,
+ gdkpoints[(i+1)%n].y);
+ delete[] gdkpoints;
+}
-void wxPaintDC::DrawPolygon( wxList *WXUNUSED(lines), long WXUNUSED(xoffset),
- long WXUNUSED(yoffset), int WXUNUSED(fillStyle) )
+void wxPaintDC::DrawPolygon( wxList *lines, long xoffset, long yoffset, int WXUNUSED(fillStyle))
{
if (!Ok()) return;
-};
+
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
+ int n = lines->Number();
+ GdkPoint *gdkpoints = new GdkPoint[n];
+ wxNode *node = lines->First();
+ int cnt=0;
+ while (node)
+ {
+ wxPoint *p = (wxPoint *) node->Data();
+ gdkpoints[cnt].x = XLOG2DEV(p->x + xoffset);
+ gdkpoints[cnt].y = YLOG2DEV(p->y + yoffset);
+ node = node->Next();
+ cnt++;
+ }
+ if (m_brush.GetStyle() != wxTRANSPARENT)
+ gdk_draw_polygon (m_window, m_brushGC, TRUE, gdkpoints, n);
+ // To do: Fillstyle
+ if (m_pen.GetStyle() != wxTRANSPARENT)
+ {
+ int i;
+ for (i = 0 ; i < n ; i++)
+ gdk_draw_line( m_window, m_penGC,
+ gdkpoints[i%n].x,
+ gdkpoints[i%n].y,
+ gdkpoints[(i+1)%n].x,
+ gdkpoints[(i+1)%n].y);
+ }
+ delete[] gdkpoints;
+}
void wxPaintDC::DrawRectangle( long x, long y, long width, long height )
{
if (!Ok()) return;
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
long xx = XLOG2DEV(x);
long yy = YLOG2DEV(y);
- long ww = XLOG2DEVREL(width);
- long hh = YLOG2DEVREL(height);
+ long ww = m_signX * XLOG2DEVREL(width);
+ long hh = m_signY * YLOG2DEVREL(height);
+ // CMB: draw nothing if transformed w or h is 0
+ if (ww == 0 || hh == 0) return;
+
+ // CMB: handle -ve width and/or height
+ if (ww < 0) { ww = -ww; xx = xx - ww; }
+ if (hh < 0) { hh = -hh; yy = yy - hh; }
+
if (m_brush.GetStyle() != wxTRANSPARENT)
gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
if (m_pen.GetStyle() != wxTRANSPARENT)
gdk_draw_rectangle( m_window, m_penGC, FALSE, xx, yy, ww-1, hh-1 );
-};
+}
void wxPaintDC::DrawRoundedRectangle( long x, long y, long width, long height, double radius )
{
if (!Ok()) return;
- if (width<0) { width=-width; x=x-width; }
- if (height<0) { height=-height; y=y-height; }
-
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
long xx = XLOG2DEV(x);
long yy = YLOG2DEV(y);
- long ww = XLOG2DEVREL(width);
- long hh = YLOG2DEVREL(height);
+ long ww = m_signX * XLOG2DEVREL(width);
+ long hh = m_signY * YLOG2DEVREL(height);
long rr = XLOG2DEVREL((long)radius);
+
+ // CMB: handle -ve width and/or height
+ if (ww < 0) { ww = -ww; xx = xx - ww; }
+ if (hh < 0) { hh = -hh; yy = yy - hh; }
+
+ // CMB: if radius is zero use DrawRectangle() instead to avoid
+ // X drawing errors with small radii
+ if (rr == 0)
+ {
+ DrawRectangle( x, y, width, height );
+ return;
+ }
+
+ // CMB: draw nothing if transformed w or h is 0
+ if (ww == 0 || hh == 0) return;
+
+ // CMB: adjust size if outline is drawn otherwise the result is
+ // 1 pixel too wide and high
+ if (m_pen.GetStyle() != wxTRANSPARENT)
+ {
+ ww--;
+ hh--;
+ }
+
+ // CMB: ensure dd is not larger than rectangle otherwise we
+ // get an hour glass shape
long dd = 2 * rr;
+ if (dd > ww) dd = ww;
+ if (dd > hh) dd = hh;
+ rr = dd / 2;
if (m_brush.GetStyle() != wxTRANSPARENT)
{
- gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd, hh );
- gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd );
+ gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
+ gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
- };
+ }
if (m_pen.GetStyle() != wxTRANSPARENT)
{
gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
- };
-};
+ }
+}
void wxPaintDC::DrawEllipse( long x, long y, long width, long height )
{
if (!Ok()) return;
- if (width<0) { width=-width; x=x-width; }
- if (height<0) { height=-height; y=y-height; }
-
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
long xx = XLOG2DEV(x);
long yy = YLOG2DEV(y);
- long ww = XLOG2DEVREL(width);
- long hh = YLOG2DEVREL(height);
+ long ww = m_signX * XLOG2DEVREL(width);
+ long hh = m_signY * YLOG2DEVREL(height);
+
+ // CMB: handle -ve width and/or height
+ if (ww < 0) { ww = -ww; xx = xx - ww; }
+ if (hh < 0) { hh = -hh; yy = yy - hh; }
if (m_brush.GetStyle() != wxTRANSPARENT)
gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
if (m_pen.GetStyle() != wxTRANSPARENT)
gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, 0, 360*64 );
-};
+}
bool wxPaintDC::CanDrawBitmap(void) const
{
return TRUE;
-};
+}
void wxPaintDC::DrawIcon( const wxIcon &icon, long x, long y, bool useMask )
{
if (!icon.Ok()) return;
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
int xx = XLOG2DEV(x);
int yy = YLOG2DEV(y);
- GdkBitmap *mask = NULL;
+ GdkBitmap *mask = (GdkBitmap *) NULL;
if (icon.GetMask()) mask = icon.GetMask()->GetBitmap();
if (useMask && mask)
{
gdk_gc_set_clip_mask( m_penGC, mask );
gdk_gc_set_clip_origin( m_penGC, xx, yy );
- };
+ }
GdkPixmap *pm = icon.GetPixmap();
gdk_draw_pixmap( m_window, m_penGC, pm, 0, 0, xx, yy, -1, -1 );
if (useMask && mask)
{
- gdk_gc_set_clip_mask( m_penGC, NULL );
+ gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
gdk_gc_set_clip_origin( m_penGC, 0, 0 );
- };
-};
+ }
+}
bool wxPaintDC::Blit( long xdest, long ydest, long width, long height,
wxDC *source, long xsrc, long ysrc, int WXUNUSED(logical_func), bool WXUNUSED(useMask) )
{
if (!Ok()) return FALSE;
- wxClientDC *csrc = (wxClientDC*)source;
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
+ // CMB 20/5/98: add blitting of bitmaps
+ if (source->IsKindOf(CLASSINFO(wxMemoryDC)))
+ {
+ wxMemoryDC* srcDC = (wxMemoryDC*)source;
+ GdkBitmap* bmap = srcDC->m_selected.GetBitmap();
+ if (bmap)
+ {
+ gdk_draw_bitmap( m_window, m_textGC, bmap,
+ source->DeviceToLogicalX(xsrc),
+ source->DeviceToLogicalY(ysrc),
+ XLOG2DEV(xdest),
+ YLOG2DEV(ydest),
+ source->DeviceToLogicalXRel(width),
+ source->DeviceToLogicalYRel(height) );
+ return TRUE;
+ }
+ }
+ wxClientDC *csrc = (wxClientDC*)source;
gdk_window_copy_area ( m_window, m_penGC,
XLOG2DEV(xdest), YLOG2DEV(ydest),
csrc->GetWindow(),
*/
return TRUE;
-};
+}
void wxPaintDC::DrawText( const wxString &text, long x, long y, bool WXUNUSED(use16) )
{
if (!Ok()) return;
+
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
GdkFont *font = m_font.GetInternalFont( m_scaleY );
- gdk_draw_string( m_window, font, m_textGC,
- XLOG2DEV(x),
- YLOG2DEV(y) + font->ascent, text );
-};
+
+ x = XLOG2DEV(x);
+ y = YLOG2DEV(y);
+
+ // CMB 21/5/98: draw text background if mode is wxSOLID
+ if (m_backgroundMode == wxSOLID)
+ {
+ long width = gdk_string_width( font, text );
+ long height = font->ascent + font->descent;
+ gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
+ gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
+ gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
+ }
+ gdk_draw_string( m_window, font, m_textGC, x, y + font->ascent, text );
+
+ // CMB 17/7/98: simple underline: ignores scaling and underlying
+ // X font's XA_UNDERLINE_POSITION and XA_UNDERLINE_THICKNESS
+ // properties (see wxXt implementation)
+ if (m_font.GetUnderlined())
+ {
+ long width = gdk_string_width( font, text );
+ long ul_y = y + font->ascent;
+ if (font->descent > 0) ul_y++;
+ gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
+ }
+}
bool wxPaintDC::CanGetTextExtent(void) const
{
return TRUE;
-};
+}
void wxPaintDC::GetTextExtent( const wxString &string, long *width, long *height,
- long *WXUNUSED(descent), long *WXUNUSED(externalLeading),
- wxFont *WXUNUSED(theFont), bool WXUNUSED(use16) )
+ long *descent, long *externalLeading,
+ wxFont *theFont, bool WXUNUSED(use16) )
{
if (!Ok()) return;
- GdkFont *font = m_font.GetInternalFont( m_scaleY );
- if (width) (*width) = gdk_string_width( font, string );
- if (height) (*height) = font->ascent + font->descent;
-};
+ wxFont fontToUse = m_font;
+ if (theFont) fontToUse = *theFont;
+
+ GdkFont *font = fontToUse.GetInternalFont( m_scaleY );
+ if (width) (*width) = long(gdk_string_width( font, string ) / m_scaleX);
+ if (height) (*height) = long((font->ascent + font->descent) / m_scaleY);
+ if (descent) (*descent) = long(font->descent / m_scaleY);
+ if (externalLeading) (*externalLeading) = 0; // ??
+}
long wxPaintDC::GetCharWidth(void)
{
if (!Ok()) return 0;
GdkFont *font = m_font.GetInternalFont( m_scaleY );
- return gdk_string_width( font, "H" );
-};
+ return long(gdk_string_width( font, "H" ) / m_scaleX);
+}
long wxPaintDC::GetCharHeight(void)
{
if (!Ok()) return 0;
GdkFont *font = m_font.GetInternalFont( m_scaleY );
- return font->ascent + font->descent;
-};
+ return long((font->ascent + font->descent) / m_scaleY);
+}
void wxPaintDC::Clear(void)
{
if (!Ok()) return;
- DestroyClippingRegion();
- gdk_window_clear( m_window );
-};
+ if (!m_isDrawable) ((wxMemoryDC*)this)->m_selected.DestroyImage();
+
+ if (m_isDrawable)
+ {
+ gdk_window_clear( m_window );
+ }
+ else
+ {
+ int width = 0;
+ int height = 0;
+ GetSize( &width, &height );
+ gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
+ }
+}
void wxPaintDC::SetFont( const wxFont &font )
{
if (!Ok()) return;
m_font = font;
-};
+}
void wxPaintDC::SetPen( const wxPen &pen )
{
if (!m_pen.Ok()) return;
gint width = m_pen.GetWidth();
+ // CMB: if width is non-zero scale it with the dc
+ if (width <= 0)
+ {
+ width = 1;
+ }
+ else
+ {
+ // X doesn't allow different width in x and y and so we take
+ // the average
+ double w = 0.5 + (abs(XLOG2DEVREL(width)) + abs(YLOG2DEVREL(width))) / 2.0;
+ width = (int)w;
+ }
GdkLineStyle lineStyle = GDK_LINE_SOLID;
switch (m_pen.GetStyle())
{
- case wxSOLID: { lineStyle = GDK_LINE_SOLID; break; };
- case wxDOT: { lineStyle = GDK_LINE_ON_OFF_DASH; break; };
- case wxLONG_DASH: { lineStyle = GDK_LINE_ON_OFF_DASH; break; };
- case wxSHORT_DASH: { lineStyle = GDK_LINE_ON_OFF_DASH; break; };
- case wxDOT_DASH: { lineStyle = GDK_LINE_DOUBLE_DASH; break; };
- };
+ case wxSOLID: { lineStyle = GDK_LINE_SOLID; break; }
+ case wxDOT: { lineStyle = GDK_LINE_ON_OFF_DASH; break; }
+ case wxLONG_DASH: { lineStyle = GDK_LINE_ON_OFF_DASH; break; }
+ case wxSHORT_DASH: { lineStyle = GDK_LINE_ON_OFF_DASH; break; }
+ case wxDOT_DASH: { lineStyle = GDK_LINE_DOUBLE_DASH; break; }
+ }
GdkCapStyle capStyle = GDK_CAP_ROUND;
switch (m_pen.GetCap())
{
- case wxCAP_ROUND: { capStyle = GDK_CAP_ROUND; break; };
- case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; };
- case wxCAP_BUTT: { capStyle = GDK_CAP_BUTT; break; };
- };
+ case wxCAP_ROUND: { capStyle = (width <= 1) ? GDK_CAP_NOT_LAST : GDK_CAP_ROUND; break; }
+ case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; }
+ case wxCAP_BUTT: { capStyle = GDK_CAP_BUTT; break; }
+ }
GdkJoinStyle joinStyle = GDK_JOIN_ROUND;
switch (m_pen.GetJoin())
{
- case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; };
- case wxJOIN_ROUND: { joinStyle = GDK_JOIN_ROUND; break; };
- case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; };
- };
+ case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; }
+ case wxJOIN_ROUND: { joinStyle = GDK_JOIN_ROUND; break; }
+ case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; }
+ }
gdk_gc_set_line_attributes( m_penGC, width, lineStyle, capStyle, joinStyle );
m_pen.GetColour().CalcPixel( m_cmap );
gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
-};
+}
void wxPaintDC::SetBrush( const wxBrush &brush )
{
break;
default:
fillStyle = GDK_STIPPLED;
- };
+ }
gdk_gc_set_fill( m_brushGC, fillStyle );
if (m_brush.GetStyle() == wxSTIPPLE)
{
gdk_gc_set_stipple( m_brushGC, m_brush.GetStipple()->GetPixmap() );
- };
+ }
if (IS_HATCH(m_brush.GetStyle()))
{
int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
gdk_gc_set_stipple( m_brushGC, hatches[num] );
- };
-};
+ }
+}
+
+// CMB 21/7/98: Added SetBackground. Sets background brush
+// for Clear() and bg colour for shapes filled with cross-hatch brush
+void wxPaintDC::SetBackground( const wxBrush &brush )
+{
+ if (!Ok()) return;
+
+ if (m_backgroundBrush == brush) return;
+
+ m_backgroundBrush = brush;
+
+ if (!m_backgroundBrush.Ok()) return;
+
+ m_backgroundBrush.GetColour().CalcPixel( m_cmap );
+ gdk_gc_set_background( m_brushGC, m_backgroundBrush.GetColour().GetColor() );
+ gdk_gc_set_foreground( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
+
+ GdkFill fillStyle = GDK_SOLID;
+ switch (m_backgroundBrush.GetStyle())
+ {
+ case wxSOLID:
+ case wxTRANSPARENT:
+ break;
+ default:
+ fillStyle = GDK_STIPPLED;
+ }
+
+ gdk_gc_set_fill( m_bgGC, fillStyle );
+
+ if (m_backgroundBrush.GetStyle() == wxSTIPPLE)
+ {
+ gdk_gc_set_stipple( m_bgGC, m_backgroundBrush.GetStipple()->GetPixmap() );
+ }
+
+ if (IS_HATCH(m_backgroundBrush.GetStyle()))
+ {
+ int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
+ gdk_gc_set_stipple( m_bgGC, hatches[num] );
+ }
+}
void wxPaintDC::SetLogicalFunction( int function )
{
case wxXOR: mode = GDK_INVERT; break;
case wxINVERT: mode = GDK_INVERT; break;
default: break;
- };
+ }
m_logicalFunction = function;
gdk_gc_set_function( m_penGC, mode );
gdk_gc_set_function( m_brushGC, mode );
-};
+}
void wxPaintDC::SetTextForeground( const wxColour &col )
{
m_textForegroundColour.CalcPixel( m_cmap );
gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
-};
+}
void wxPaintDC::SetTextBackground( const wxColour &col )
{
m_textBackgroundColour.CalcPixel( m_cmap );
gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
-};
+}
-void wxPaintDC::SetBackgroundMode( int WXUNUSED(mode) )
+void wxPaintDC::SetBackgroundMode( int mode )
{
-};
+ m_backgroundMode = mode;
+
+ // CMB 21/7/98: fill style of cross-hatch brushes is affected by
+ // transparent/solid background mode
+ if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
+ {
+ gdk_gc_set_fill( m_brushGC,
+ (m_backgroundMode == wxTRANSPARENT) ? GDK_STIPPLED : GDK_OPAQUE_STIPPLED);
+ }
+}
void wxPaintDC::SetPalette( const wxPalette& WXUNUSED(palette) )
{
-};
+}
void wxPaintDC::SetClippingRegion( long x, long y, long width, long height )
{
GdkRectangle rect;
rect.x = XLOG2DEV(x);
rect.y = YLOG2DEV(y);
- rect.width = XLOG2DEV(x+width);
- rect.height = YLOG2DEV(y+height);
+ rect.width = XLOG2DEVREL(width);
+ rect.height = YLOG2DEVREL(height);
gdk_gc_set_clip_rectangle( m_penGC, &rect );
gdk_gc_set_clip_rectangle( m_brushGC, &rect );
gdk_gc_set_clip_rectangle( m_textGC, &rect );
gdk_gc_set_clip_rectangle( m_bgGC, &rect );
-};
+}
void wxPaintDC::DestroyClippingRegion(void)
{
wxDC::DestroyClippingRegion();
- gdk_gc_set_clip_rectangle( m_penGC, NULL );
- gdk_gc_set_clip_rectangle( m_brushGC, NULL );
- gdk_gc_set_clip_rectangle( m_textGC, NULL );
- gdk_gc_set_clip_rectangle( m_bgGC, NULL );
-};
+ gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
+ gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
+ gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
+ gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
+}
void wxPaintDC::SetUpDC(void)
{
m_ok = TRUE;
m_logicalFunction = wxCOPY;
+ if (m_penGC) gdk_gc_unref( m_penGC );
m_penGC = gdk_gc_new( m_window );
+ if (m_brushGC) gdk_gc_unref( m_brushGC );
m_brushGC = gdk_gc_new( m_window );
+ if (m_textGC) gdk_gc_unref( m_textGC );
m_textGC = gdk_gc_new( m_window );
+ if (m_bgGC) gdk_gc_unref( m_bgGC );
m_bgGC = gdk_gc_new( m_window );
SetTextForeground( m_textForegroundColour );
SetTextBackground( m_textBackgroundColour );
if (!hatch_bitmap)
{
hatch_bitmap = hatches;
- hatch_bitmap[0] = gdk_bitmap_create_from_data( NULL, bdiag_bits, bdiag_width, bdiag_height );
- hatch_bitmap[1] = gdk_bitmap_create_from_data( NULL, cdiag_bits, cdiag_width, cdiag_height );
- hatch_bitmap[2] = gdk_bitmap_create_from_data( NULL, fdiag_bits, fdiag_width, fdiag_height );
- hatch_bitmap[3] = gdk_bitmap_create_from_data( NULL, cross_bits, cross_width, cross_height );
- hatch_bitmap[4] = gdk_bitmap_create_from_data( NULL, horiz_bits, horiz_width, horiz_height );
- hatch_bitmap[5] = gdk_bitmap_create_from_data( NULL, verti_bits, verti_width, verti_height );
- };
-};
+ hatch_bitmap[0] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, bdiag_bits, bdiag_width, bdiag_height );
+ hatch_bitmap[1] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cdiag_bits, cdiag_width, cdiag_height );
+ hatch_bitmap[2] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, fdiag_bits, fdiag_width, fdiag_height );
+ hatch_bitmap[3] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cross_bits, cross_width, cross_height );
+ hatch_bitmap[4] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, horiz_bits, horiz_width, horiz_height );
+ hatch_bitmap[5] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, verti_bits, verti_width, verti_height );
+ }
+}
GdkWindow *wxPaintDC::GetWindow(void)
{
return m_window;
-};
+}
// ----------------------------------- spline code ----------------------------------------
wx_spline_add_point( x2, y2 );
wx_spline_draw_point_array( this );
-};
+}
projects / wxWidgets.git / blobdiff