src/gtk1/dcclient.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        gtk/dcclient.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 1998 Robert Roebling, Markus Holzem, Chris Breeze
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifdef __GNUG__
  11 #pragma implementation "dcclient.h"
  12 #endif
  13
  14 #include "wx/dcclient.h"
  15 #include "wx/dcmemory.h"
  16 #include "wx/image.h"
  17 #include "wx/module.h"
  18
  19 #include "wx/gtk/win_gtk.h"
  20
  21 #include <math.h>               // for floating-point functions
  22
  23 #include <gdk/gdk.h>
  24 #include <gdk/gdkx.h>
  25 #include <gdk/gdkprivate.h>
  26 #include <gtk/gtk.h>
  27
  28 //-----------------------------------------------------------------------------
  29 // local defines
  30 //-----------------------------------------------------------------------------
  31
  32 #define USE_PAINT_REGION 1
  33
  34 //-----------------------------------------------------------------------------
  35 // local data
  36 //-----------------------------------------------------------------------------
  37
  38 #include "bdiag.xbm"
  39 #include "fdiag.xbm"
  40 #include "cdiag.xbm"
  41 #include "horiz.xbm"
  42 #include "verti.xbm"
  43 #include "cross.xbm"
  44 #define  num_hatches 6
  45
  46 static GdkPixmap  *hatches[num_hatches];
  47 static GdkPixmap **hatch_bitmap = (GdkPixmap **) NULL;
  48
  49 extern GtkWidget *wxRootWindow;
  50
  51 //-----------------------------------------------------------------------------
  52 // constants
  53 //-----------------------------------------------------------------------------
  54
  55 const double RAD2DEG  = 180.0 / M_PI;
  56
  57 // ----------------------------------------------------------------------------
  58 // private functions
  59 // ----------------------------------------------------------------------------
  60
  61 static inline double dmax(double a, double b) { return a > b ? a : b; }
  62 static inline double dmin(double a, double b) { return a < b ? a : b; }
  63
  64 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
  65
  66 //-----------------------------------------------------------------------------
  67 // temporary implementation of the missing GDK function
  68 //-----------------------------------------------------------------------------
  69
  70 #include "gdk/gdkprivate.h"
  71
  72 void gdk_wx_draw_bitmap     (GdkDrawable  *drawable,
  73                           GdkGC               *gc,
  74                           GdkDrawable  *src,
  75                           gint                xsrc,
  76                           gint                ysrc,
  77                           gint                xdest,
  78                           gint                ydest,
  79                           gint                width,
  80                           gint                height)
  81 {
  82     gint src_width, src_height;
  83 #ifndef __WXGTK20__
  84     GdkWindowPrivate *drawable_private;
  85     GdkWindowPrivate *src_private;
  86     GdkGCPrivate *gc_private;
  87 #endif
  88
  89     g_return_if_fail (drawable != NULL);
  90     g_return_if_fail (src != NULL);
  91     g_return_if_fail (gc != NULL);
  92
  93 #ifdef __WXGTK20__
  94     if (GDK_WINDOW_DESTROYED(drawable) || GDK_WINDOW_DESTROYED(src))
  95         return;
  96
  97     gdk_drawable_get_size(src, &src_width, &src_height);
  98 #else
  99     drawable_private = (GdkWindowPrivate*) drawable;
 100     src_private = (GdkWindowPrivate*) src;
 101     if (drawable_private->destroyed || src_private->destroyed)
 102         return;
 103
 104     src_width = src_private->width;
 105     src_height = src_private->height;
 106
 107     gc_private = (GdkGCPrivate*) gc;
 108 #endif
 109
 110     if (width == -1) width = src_width;
 111     if (height == -1) height = src_height;
 112
 113 #ifdef __WXGTK20__
 114     XCopyPlane( GDK_WINDOW_XDISPLAY(drawable),
 115                 GDK_WINDOW_XID(src),
 116                 GDK_WINDOW_XID(drawable),
 117                 GDK_GC_XGC(gc),
 118                 xsrc, ysrc,
 119                 width, height,
 120                 xdest, ydest,
 121                 1 );
 122 #else
 123     XCopyPlane( drawable_private->xdisplay,
 124                 src_private->xwindow,
 125                 drawable_private->xwindow,
 126                 gc_private->xgc,
 127                 xsrc, ysrc,
 128                 width, height,
 129                 xdest, ydest,
 130                 1 );
 131 #endif
 132 }
 133
 134 //-----------------------------------------------------------------------------
 135 // Implement Pool of Graphic contexts. Creating them takes too much time.
 136 //-----------------------------------------------------------------------------
 137
 138 #define GC_POOL_SIZE 200
 139
 140 enum wxPoolGCType
 141 {
 142    wxGC_ERROR = 0,
 143    wxTEXT_MONO,
 144    wxBG_MONO,
 145    wxPEN_MONO,
 146    wxBRUSH_MONO,
 147    wxTEXT_COLOUR,
 148    wxBG_COLOUR,
 149    wxPEN_COLOUR,
 150    wxBRUSH_COLOUR,
 151    wxTEXT_SCREEN,
 152    wxBG_SCREEN,
 153    wxPEN_SCREEN,
 154    wxBRUSH_SCREEN
 155 };
 156
 157 struct wxGC
 158 {
 159     GdkGC        *m_gc;
 160     wxPoolGCType  m_type;
 161     bool          m_used;
 162 };
 163
 164 static wxGC wxGCPool[GC_POOL_SIZE];
 165
 166 static void wxInitGCPool()
 167 {
 168     memset( wxGCPool, 0, GC_POOL_SIZE*sizeof(wxGC) );
 169 }
 170
 171 static void wxCleanUpGCPool()
 172 {
 173     for (int i = 0; i < GC_POOL_SIZE; i++)
 174     {
 175         if (wxGCPool[i].m_gc)
 176             gdk_gc_unref( wxGCPool[i].m_gc );
 177     }
 178 }
 179
 180 static GdkGC* wxGetPoolGC( GdkWindow *window, wxPoolGCType type )
 181 {
 182     for (int i = 0; i < GC_POOL_SIZE; i++)
 183     {
 184         if (!wxGCPool[i].m_gc)
 185         {
 186             wxGCPool[i].m_gc = gdk_gc_new( window );
 187             gdk_gc_set_exposures( wxGCPool[i].m_gc, FALSE );
 188             wxGCPool[i].m_type = type;
 189             wxGCPool[i].m_used = FALSE;
 190         }
 191         if ((!wxGCPool[i].m_used) && (wxGCPool[i].m_type == type))
 192         {
 193             wxGCPool[i].m_used = TRUE;
 194             return wxGCPool[i].m_gc;
 195         }
 196     }
 197
 198     wxFAIL_MSG( wxT("No GC available") );
 199
 200     return (GdkGC*) NULL;
 201 }
 202
 203 static void wxFreePoolGC( GdkGC *gc )
 204 {
 205     for (int i = 0; i < GC_POOL_SIZE; i++)
 206     {
 207         if (wxGCPool[i].m_gc == gc)
 208         {
 209             wxGCPool[i].m_used = FALSE;
 210             return;
 211         }
 212     }
 213
 214     wxFAIL_MSG( wxT("Wrong GC") );
 215 }
 216
 217 //-----------------------------------------------------------------------------
 218 // wxWindowDC
 219 //-----------------------------------------------------------------------------
 220
 221 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
 222
 223 wxWindowDC::wxWindowDC()
 224 {
 225     m_penGC = (GdkGC *) NULL;
 226     m_brushGC = (GdkGC *) NULL;
 227     m_textGC = (GdkGC *) NULL;
 228     m_bgGC = (GdkGC *) NULL;
 229     m_cmap = (GdkColormap *) NULL;
 230     m_isMemDC = FALSE;
 231     m_isScreenDC = FALSE;
 232     m_owner = (wxWindow *)NULL;
 233 #ifdef __WXGTK20__
 234     m_context = (PangoContext *)NULL;
 235     m_fontdesc = (PangoFontDescription *)NULL;
 236 #endif
 237 }
 238
 239 wxWindowDC::wxWindowDC( wxWindow *window )
 240 {
 241     m_penGC = (GdkGC *) NULL;
 242     m_brushGC = (GdkGC *) NULL;
 243     m_textGC = (GdkGC *) NULL;
 244     m_bgGC = (GdkGC *) NULL;
 245     m_cmap = (GdkColormap *) NULL;
 246     m_owner = (wxWindow *)NULL;
 247     m_isMemDC = FALSE;
 248     m_isScreenDC = FALSE;
 249     m_font = window->GetFont();
 250
 251     wxASSERT_MSG( window, wxT("DC needs a window") );
 252
 253     GtkWidget *widget = window->m_wxwindow;
 254
 255     // some controls don't have m_wxwindow - like wxStaticBox, but the user
 256     // code should still be able to create wxClientDCs for them, so we will
 257     // use the parent window here then
 258     if ( !widget )
 259     {
 260         window = window->GetParent();
 261         widget = window->m_wxwindow;
 262     }
 263
 264     wxASSERT_MSG( widget, wxT("DC needs a widget") );
 265
 266 #ifdef __WXGTK20__
 267     m_context = gtk_widget_get_pango_context( widget );
 268     m_fontdesc = widget->style->font_desc;
 269 #endif
 270
 271     GtkPizza *pizza = GTK_PIZZA( widget );
 272     m_window = pizza->bin_window;
 273
 274     /* not realized ? */
 275     if (!m_window)
 276     {
 277          /* don't report problems */
 278          m_ok = TRUE;
 279
 280          return;
 281     }
 282
 283     m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget );
 284
 285     SetUpDC();
 286
 287     /* this must be done after SetUpDC, bacause SetUpDC calls the
 288        repective SetBrush, SetPen, SetBackground etc functions
 289        to set up the DC. SetBackground call m_owner->SetBackground
 290        and this might not be desired as the standard dc background
 291        is white whereas a window might assume gray to be the
 292        standard (as e.g. wxStatusBar) */
 293
 294     m_owner = window;
 295 }
 296
 297 wxWindowDC::~wxWindowDC()
 298 {
 299     Destroy();
 300 }
 301
 302 void wxWindowDC::SetUpDC()
 303 {
 304     m_ok = TRUE;
 305
 306     wxASSERT_MSG( !m_penGC, wxT("GCs already created") );
 307
 308     if (m_isScreenDC)
 309     {
 310         m_penGC = wxGetPoolGC( m_window, wxPEN_SCREEN );
 311         m_brushGC = wxGetPoolGC( m_window, wxBRUSH_SCREEN );
 312         m_textGC = wxGetPoolGC( m_window, wxTEXT_SCREEN );
 313         m_bgGC = wxGetPoolGC( m_window, wxBG_SCREEN );
 314     }
 315     else
 316     if (m_isMemDC && (((wxMemoryDC*)this)->m_selected.GetDepth() == 1))
 317     {
 318         m_penGC = wxGetPoolGC( m_window, wxPEN_MONO );
 319         m_brushGC = wxGetPoolGC( m_window, wxBRUSH_MONO );
 320         m_textGC = wxGetPoolGC( m_window, wxTEXT_MONO );
 321         m_bgGC = wxGetPoolGC( m_window, wxBG_MONO );
 322     }
 323     else
 324     {
 325         m_penGC = wxGetPoolGC( m_window, wxPEN_COLOUR );
 326         m_brushGC = wxGetPoolGC( m_window, wxBRUSH_COLOUR );
 327         m_textGC = wxGetPoolGC( m_window, wxTEXT_COLOUR );
 328         m_bgGC = wxGetPoolGC( m_window, wxBG_COLOUR );
 329     }
 330
 331     /* background colour */
 332     m_backgroundBrush = *wxWHITE_BRUSH;
 333     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
 334     GdkColor *bg_col = m_backgroundBrush.GetColour().GetColor();
 335
 336     /* m_textGC */
 337     m_textForegroundColour.CalcPixel( m_cmap );
 338     gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
 339
 340     m_textBackgroundColour.CalcPixel( m_cmap );
 341     gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
 342
 343     gdk_gc_set_fill( m_textGC, GDK_SOLID );
 344
 345     /* m_penGC */
 346     m_pen.GetColour().CalcPixel( m_cmap );
 347     gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
 348     gdk_gc_set_background( m_penGC, bg_col );
 349
 350     gdk_gc_set_line_attributes( m_penGC, 0, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_ROUND );
 351
 352     /* m_brushGC */
 353     m_brush.GetColour().CalcPixel( m_cmap );
 354     gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
 355     gdk_gc_set_background( m_brushGC, bg_col );
 356
 357     gdk_gc_set_fill( m_brushGC, GDK_SOLID );
 358
 359     /* m_bgGC */
 360     gdk_gc_set_background( m_bgGC, bg_col );
 361     gdk_gc_set_foreground( m_bgGC, bg_col );
 362
 363     gdk_gc_set_fill( m_bgGC, GDK_SOLID );
 364
 365     /* ROPs */
 366     gdk_gc_set_function( m_textGC, GDK_COPY );
 367     gdk_gc_set_function( m_brushGC, GDK_COPY );
 368     gdk_gc_set_function( m_penGC, GDK_COPY );
 369
 370     /* clipping */
 371     gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
 372     gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
 373     gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
 374     gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
 375
 376     if (!hatch_bitmap)
 377     {
 378         hatch_bitmap    = hatches;
 379         hatch_bitmap[0] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, bdiag_bits, bdiag_width, bdiag_height );
 380         hatch_bitmap[1] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cdiag_bits, cdiag_width, cdiag_height );
 381         hatch_bitmap[2] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, fdiag_bits, fdiag_width, fdiag_height );
 382         hatch_bitmap[3] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cross_bits, cross_width, cross_height );
 383         hatch_bitmap[4] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, horiz_bits, horiz_width, horiz_height );
 384         hatch_bitmap[5] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, verti_bits, verti_width, verti_height );
 385     }
 386 }
 387
 388 void wxWindowDC::DoFloodFill( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
 389                            const wxColour &WXUNUSED(col), int WXUNUSED(style) )
 390 {
 391     wxFAIL_MSG( wxT("wxWindowDC::DoFloodFill not implemented") );
 392 }
 393
 394 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
 395 {
 396     // Generic (and therefore rather inefficient) method.
 397     // Could be improved.
 398     wxMemoryDC memdc;
 399     wxBitmap bitmap(1, 1);
 400     memdc.SelectObject(bitmap);
 401     memdc.Blit(0, 0, 1, 1, (wxDC*) this, x1, y1);
 402     memdc.SelectObject(wxNullBitmap);
 403     wxImage image(bitmap);
 404     col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));
 405     return TRUE;
 406 }
 407
 408 void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 409 {
 410     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 411
 412     if (m_pen.GetStyle() != wxTRANSPARENT)
 413     {
 414         if (m_window)
 415             gdk_draw_line( m_window, m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
 416
 417         CalcBoundingBox(x1, y1);
 418         CalcBoundingBox(x2, y2);
 419     }
 420 }
 421
 422 void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
 423 {
 424     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 425
 426     if (m_pen.GetStyle() != wxTRANSPARENT)
 427     {
 428         int w = 0;
 429         int h = 0;
 430         GetSize( &w, &h );
 431         wxCoord xx = XLOG2DEV(x);
 432         wxCoord yy = YLOG2DEV(y);
 433         if (m_window)
 434         {
 435             gdk_draw_line( m_window, m_penGC, 0, yy, XLOG2DEVREL(w), yy );
 436             gdk_draw_line( m_window, m_penGC, xx, 0, xx, YLOG2DEVREL(h) );
 437         }
 438     }
 439 }
 440
 441 void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
 442                             wxCoord xc, wxCoord yc )
 443 {
 444     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 445
 446     wxCoord xx1 = XLOG2DEV(x1);
 447     wxCoord yy1 = YLOG2DEV(y1);
 448     wxCoord xx2 = XLOG2DEV(x2);
 449     wxCoord yy2 = YLOG2DEV(y2);
 450     wxCoord xxc = XLOG2DEV(xc);
 451     wxCoord yyc = YLOG2DEV(yc);
 452     double dx = xx1 - xxc;
 453     double dy = yy1 - yyc;
 454     double radius = sqrt((double)(dx*dx+dy*dy));
 455     wxCoord   r      = (wxCoord)radius;
 456     double radius1, radius2;
 457
 458     if (xx1 == xx2 && yy1 == yy2)
 459     {
 460         radius1 = 0.0;
 461         radius2 = 360.0;
 462     }
 463     else
 464     if (radius == 0.0)
 465     {
 466         radius1 = radius2 = 0.0;
 467     }
 468     else
 469     {
 470         radius1 = (xx1 - xxc == 0) ?
 471             (yy1 - yyc < 0) ? 90.0 : -90.0 :
 472             -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
 473         radius2 = (xx2 - xxc == 0) ?
 474             (yy2 - yyc < 0) ? 90.0 : -90.0 :
 475             -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
 476     }
 477     wxCoord alpha1 = wxCoord(radius1 * 64.0);
 478     wxCoord alpha2 = wxCoord((radius2 - radius1) * 64.0);
 479     while (alpha2 <= 0) alpha2 += 360*64;
 480     while (alpha1 > 360*64) alpha1 -= 360*64;
 481
 482     if (m_window)
 483     {
 484         if (m_brush.GetStyle() != wxTRANSPARENT)
 485         {
 486             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 487             {
 488                 gdk_gc_set_ts_origin( m_textGC,
 489                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 490                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 491                 gdk_draw_arc( m_window, m_textGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 492                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
 493             } else
 494             if (m_brush.GetStyle() == wxSTIPPLE)
 495             {
 496                 gdk_gc_set_ts_origin( m_brushGC,
 497                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 498                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 499                 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 500                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 501             }
 502             else
 503             {
 504                 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 505             }
 506         }
 507
 508         if (m_pen.GetStyle() != wxTRANSPARENT)
 509             gdk_draw_arc( m_window, m_penGC, FALSE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
 510     }
 511
 512     CalcBoundingBox (x1, y1);
 513     CalcBoundingBox (x2, y2);
 514 }
 515
 516 void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
 517 {
 518     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 519
 520     wxCoord xx = XLOG2DEV(x);
 521     wxCoord yy = YLOG2DEV(y);
 522     wxCoord ww = m_signX * XLOG2DEVREL(width);
 523     wxCoord hh = m_signY * YLOG2DEVREL(height);
 524
 525     // CMB: handle -ve width and/or height
 526     if (ww < 0) { ww = -ww; xx = xx - ww; }
 527     if (hh < 0) { hh = -hh; yy = yy - hh; }
 528
 529     if (m_window)
 530     {
 531         wxCoord start = wxCoord(sa * 64.0);
 532         wxCoord end = wxCoord(ea * 64.0);
 533
 534         if (m_brush.GetStyle() != wxTRANSPARENT)
 535         {
 536             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 537             {
 538                 gdk_gc_set_ts_origin( m_textGC,
 539                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 540                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 541                 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy, ww, hh, start, end );
 542                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
 543             } else
 544             if (m_brush.GetStyle() == wxSTIPPLE)
 545             {
 546                 gdk_gc_set_ts_origin( m_brushGC,
 547                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 548                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 549                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
 550                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 551             }
 552             else
 553             {
 554                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
 555             }
 556         }
 557
 558         if (m_pen.GetStyle() != wxTRANSPARENT)
 559             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, start, end );
 560     }
 561
 562     CalcBoundingBox (x, y);
 563     CalcBoundingBox (x + width, y + height);
 564 }
 565
 566 void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
 567 {
 568     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 569
 570     if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
 571         gdk_draw_point( m_window, m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
 572
 573     CalcBoundingBox (x, y);
 574 }
 575
 576 void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
 577 {
 578     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 579
 580     if (m_pen.GetStyle() == wxTRANSPARENT) return;
 581     if (n <= 0) return;
 582
 583     CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
 584
 585     for (int i = 0; i < n-1; i++)
 586     {
 587         wxCoord x1 = XLOG2DEV(points[i].x + xoffset);
 588         wxCoord x2 = XLOG2DEV(points[i+1].x + xoffset);
 589         wxCoord y1 = YLOG2DEV(points[i].y + yoffset);     // oh, what a waste
 590         wxCoord y2 = YLOG2DEV(points[i+1].y + yoffset);
 591
 592         if (m_window)
 593             gdk_draw_line( m_window, m_penGC, x1, y1, x2, y2 );
 594
 595         CalcBoundingBox( points[i+1].x + xoffset, points[i+1].y + yoffset );
 596     }
 597 }
 598
 599 void wxWindowDC::DoDrawPolygon( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset, int WXUNUSED(fillStyle) )
 600 {
 601     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 602
 603     if (n <= 0) return;
 604
 605     GdkPoint *gdkpoints = new GdkPoint[n+1];
 606     int i;
 607     for (i = 0 ; i < n ; i++)
 608     {
 609         gdkpoints[i].x = XLOG2DEV(points[i].x + xoffset);
 610         gdkpoints[i].y = YLOG2DEV(points[i].y + yoffset);
 611
 612         CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
 613     }
 614
 615     if (m_window)
 616     {
 617         if (m_brush.GetStyle() != wxTRANSPARENT)
 618         {
 619             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 620             {
 621                 gdk_gc_set_ts_origin( m_textGC,
 622                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 623                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 624                 gdk_draw_polygon( m_window, m_textGC, TRUE, gdkpoints, n );
 625                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
 626             } else
 627             if (m_brush.GetStyle() == wxSTIPPLE)
 628             {
 629                 gdk_gc_set_ts_origin( m_brushGC,
 630                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 631                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 632                 gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
 633                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 634             }
 635             else
 636             {
 637                 gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
 638             }
 639         }
 640
 641         if (m_pen.GetStyle() != wxTRANSPARENT)
 642         {
 643             for (i = 0 ; i < n ; i++)
 644             {
 645                 gdk_draw_line( m_window, m_penGC,
 646                                gdkpoints[i%n].x,
 647                                gdkpoints[i%n].y,
 648                                gdkpoints[(i+1)%n].x,
 649                                gdkpoints[(i+1)%n].y);
 650             }
 651         }
 652     }
 653
 654     delete[] gdkpoints;
 655 }
 656
 657 void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 658 {
 659     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 660
 661     wxCoord xx = XLOG2DEV(x);
 662     wxCoord yy = YLOG2DEV(y);
 663     wxCoord ww = m_signX * XLOG2DEVREL(width);
 664     wxCoord hh = m_signY * YLOG2DEVREL(height);
 665
 666     // CMB: draw nothing if transformed w or h is 0
 667     if (ww == 0 || hh == 0) return;
 668
 669     // CMB: handle -ve width and/or height
 670     if (ww < 0) { ww = -ww; xx = xx - ww; }
 671     if (hh < 0) { hh = -hh; yy = yy - hh; }
 672
 673     if (m_window)
 674     {
 675         if (m_brush.GetStyle() != wxTRANSPARENT)
 676         {
 677             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 678             {
 679                 gdk_gc_set_ts_origin( m_textGC,
 680                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 681                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 682                 gdk_draw_rectangle( m_window, m_textGC, TRUE, xx, yy, ww, hh );
 683                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
 684             }
 685             else if (m_brush.GetStyle() == wxSTIPPLE)
 686             {
 687                 gdk_gc_set_ts_origin( m_brushGC,
 688                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 689                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 690                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
 691                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 692             }
 693             else
 694             {
 695                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
 696             }
 697         }
 698
 699         if (m_pen.GetStyle() != wxTRANSPARENT)
 700             gdk_draw_rectangle( m_window, m_penGC, FALSE, xx, yy, ww-1, hh-1 );
 701     }
 702
 703     CalcBoundingBox( x, y );
 704     CalcBoundingBox( x + width, y + height );
 705 }
 706
 707 void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
 708 {
 709     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 710
 711     if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
 712
 713     wxCoord xx = XLOG2DEV(x);
 714     wxCoord yy = YLOG2DEV(y);
 715     wxCoord ww = m_signX * XLOG2DEVREL(width);
 716     wxCoord hh = m_signY * YLOG2DEVREL(height);
 717     wxCoord rr = XLOG2DEVREL((wxCoord)radius);
 718
 719     // CMB: handle -ve width and/or height
 720     if (ww < 0) { ww = -ww; xx = xx - ww; }
 721     if (hh < 0) { hh = -hh; yy = yy - hh; }
 722
 723     // CMB: if radius is zero use DrawRectangle() instead to avoid
 724     // X drawing errors with small radii
 725     if (rr == 0)
 726     {
 727         DrawRectangle( x, y, width, height );
 728         return;
 729     }
 730
 731     // CMB: draw nothing if transformed w or h is 0
 732     if (ww == 0 || hh == 0) return;
 733
 734     // CMB: adjust size if outline is drawn otherwise the result is
 735     // 1 pixel too wide and high
 736     if (m_pen.GetStyle() != wxTRANSPARENT)
 737     {
 738         ww--;
 739         hh--;
 740     }
 741
 742     if (m_window)
 743     {
 744         // CMB: ensure dd is not larger than rectangle otherwise we
 745         // get an hour glass shape
 746         wxCoord dd = 2 * rr;
 747         if (dd > ww) dd = ww;
 748         if (dd > hh) dd = hh;
 749         rr = dd / 2;
 750
 751         if (m_brush.GetStyle() != wxTRANSPARENT)
 752         {
 753             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 754             {
 755                 gdk_gc_set_ts_origin( m_textGC,
 756                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 757                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 758                 gdk_draw_rectangle( m_window, m_textGC, TRUE, xx+rr, yy, ww-dd+1, hh );
 759                 gdk_draw_rectangle( m_window, m_textGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
 760                 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
 761                 gdk_draw_arc( m_window, m_textGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 762                 gdk_draw_arc( m_window, m_textGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 763                 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 764                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
 765             }
 766             else if (m_brush.GetStyle() == wxSTIPPLE)
 767             {
 768                 gdk_gc_set_ts_origin( m_brushGC,
 769                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 770                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 771                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
 772                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
 773                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
 774                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 775                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 776                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 777                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 778             }
 779             else
 780             {
 781                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
 782                 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
 783                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
 784                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 785                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 786                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 787             }
 788         }
 789
 790         if (m_pen.GetStyle() != wxTRANSPARENT)
 791         {
 792             gdk_draw_line( m_window, m_penGC, xx+rr, yy, xx+ww-rr, yy );
 793             gdk_draw_line( m_window, m_penGC, xx+rr, yy+hh, xx+ww-rr, yy+hh );
 794             gdk_draw_line( m_window, m_penGC, xx, yy+rr, xx, yy+hh-rr );
 795             gdk_draw_line( m_window, m_penGC, xx+ww, yy+rr, xx+ww, yy+hh-rr );
 796             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, dd, dd, 90*64, 90*64 );
 797             gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
 798             gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
 799             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
 800         }
 801     }
 802
 803     // this ignores the radius
 804     CalcBoundingBox( x, y );
 805     CalcBoundingBox( x + width, y + height );
 806 }
 807
 808 void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
 809 {
 810     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 811
 812     wxCoord xx = XLOG2DEV(x);
 813     wxCoord yy = YLOG2DEV(y);
 814     wxCoord ww = m_signX * XLOG2DEVREL(width);
 815     wxCoord hh = m_signY * YLOG2DEVREL(height);
 816
 817     // CMB: handle -ve width and/or height
 818     if (ww < 0) { ww = -ww; xx = xx - ww; }
 819     if (hh < 0) { hh = -hh; yy = yy - hh; }
 820
 821     if (m_window)
 822     {
 823         if (m_brush.GetStyle() != wxTRANSPARENT)
 824         {
 825             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
 826             {
 827                 gdk_gc_set_ts_origin( m_textGC,
 828                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 829                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 830                 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
 831                 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
 832             }
 833             else if (m_brush.GetStyle() == wxSTIPPLE)
 834             {
 835                 gdk_gc_set_ts_origin( m_brushGC,
 836                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
 837                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
 838                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
 839                 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
 840             }
 841             else
 842             {
 843                 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
 844             }
 845         }
 846
 847         if (m_pen.GetStyle() != wxTRANSPARENT)
 848             gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, 0, 360*64 );
 849     }
 850
 851     CalcBoundingBox( x - width, y - height );
 852     CalcBoundingBox( x + width, y + height );
 853 }
 854
 855 void wxWindowDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
 856 {
 857     // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
 858     DoDrawBitmap( (const wxBitmap&)icon, x, y, (bool)TRUE );
 859 }
 860
 861 void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
 862                                wxCoord x, wxCoord y,
 863                                bool useMask )
 864 {
 865     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 866
 867     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
 868
 869     bool is_mono = (bitmap.GetBitmap() != NULL);
 870
 871     /* scale/translate size and position */
 872     int xx = XLOG2DEV(x);
 873     int yy = YLOG2DEV(y);
 874
 875     int w = bitmap.GetWidth();
 876     int h = bitmap.GetHeight();
 877
 878     CalcBoundingBox( x, y );
 879     CalcBoundingBox( x + w, y + h );
 880
 881     if (!m_window) return;
 882
 883     int ww = XLOG2DEVREL(w);
 884     int hh = YLOG2DEVREL(h);
 885
 886     /* compare to current clipping region */
 887     if (!m_currentClippingRegion.IsNull())
 888     {
 889         wxRegion tmp( xx,yy,ww,hh );
 890         tmp.Intersect( m_currentClippingRegion );
 891         if (tmp.IsEmpty())
 892             return;
 893     }
 894
 895     /* scale bitmap if required */
 896     wxBitmap use_bitmap;
 897     if ((w != ww) || (h != hh))
 898     {
 899         wxImage image( bitmap );
 900         image.Rescale( ww, hh );
 901         if (is_mono)
 902             use_bitmap = image.ConvertToMonoBitmap(255,255,255);
 903         else
 904             use_bitmap = image.ConvertToBitmap();
 905     }
 906     else
 907     {
 908         use_bitmap = bitmap;
 909     }
 910
 911     /* apply mask if any */
 912     GdkBitmap *mask = (GdkBitmap *) NULL;
 913     if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
 914
 915         if (useMask && mask)
 916         {
 917             GdkBitmap *new_mask = (GdkBitmap*) NULL;
 918             if (!m_currentClippingRegion.IsNull())
 919             {
 920                 GdkColor col;
 921                 new_mask = gdk_pixmap_new( wxRootWindow->window, ww, hh, 1 );
 922                 GdkGC *gc = gdk_gc_new( new_mask );
 923                 col.pixel = 0;
 924                 gdk_gc_set_foreground( gc, &col );
 925                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
 926                 col.pixel = 0;
 927                 gdk_gc_set_background( gc, &col );
 928                 col.pixel = 1;
 929                 gdk_gc_set_foreground( gc, &col );
 930                 gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
 931                 gdk_gc_set_clip_origin( gc, -xx, -yy );
 932                 gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
 933                 gdk_gc_set_stipple( gc, mask );
 934                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
 935                 gdk_gc_unref( gc );
 936             }
 937
 938             if (is_mono)
 939             {
 940                 if (new_mask)
 941                     gdk_gc_set_clip_mask( m_textGC, new_mask );
 942                 else
 943                     gdk_gc_set_clip_mask( m_textGC, mask );
 944                 gdk_gc_set_clip_origin( m_textGC, xx, yy );
 945             }
 946             else
 947             {
 948                 if (new_mask)
 949                     gdk_gc_set_clip_mask( m_penGC, new_mask );
 950                 else
 951                     gdk_gc_set_clip_mask( m_penGC, mask );
 952                 gdk_gc_set_clip_origin( m_penGC, xx, yy );
 953             }
 954             if (new_mask)
 955                 gdk_bitmap_unref( new_mask );
 956         }
 957
 958     /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
 959        drawing a mono-bitmap (XBitmap) we use the current text GC */
 960     if (is_mono)
 961         gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), 0, 0, xx, yy, -1, -1 );
 962     else
 963         gdk_draw_pixmap( m_window, m_penGC, use_bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
 964
 965     /* remove mask again if any */
 966     if (useMask && mask)
 967     {
 968         if (is_mono)
 969         {
 970             gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
 971             gdk_gc_set_clip_origin( m_textGC, 0, 0 );
 972             if (!m_currentClippingRegion.IsNull())
 973                 gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
 974         }
 975         else
 976         {
 977             gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
 978             gdk_gc_set_clip_origin( m_penGC, 0, 0 );
 979             if (!m_currentClippingRegion.IsNull())
 980                 gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
 981         }
 982     }
 983 }
 984
 985 bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
 986                          wxDC *source, wxCoord xsrc, wxCoord ysrc,
 987                          int logical_func, bool useMask )
 988 {
 989    /* this is the nth try to get this utterly useless function to
 990       work. it now completely ignores the scaling or translation
 991       of the source dc, but scales correctly on the target dc and
 992       knows about possible mask information in a memory dc. */
 993
 994     wxCHECK_MSG( Ok(), FALSE, wxT("invalid window dc") );
 995
 996     wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
 997
 998     if (!m_window) return FALSE;
 999
1000     wxClientDC *srcDC = (wxClientDC*)source;
1001     wxMemoryDC *memDC = (wxMemoryDC*)source;
1002
1003     bool use_bitmap_method = FALSE;
1004     bool is_mono = FALSE;
1005
1006     if (srcDC->m_isMemDC)
1007     {
1008         if (!memDC->m_selected.Ok()) return FALSE;
1009
1010         /* we use the "XCopyArea" way to copy a memory dc into
1011            y different window if the memory dc BOTH
1012            a) doesn't have any mask or its mask isn't used
1013            b) it is clipped
1014            c) is not 1-bit */
1015
1016         if (useMask && (memDC->m_selected.GetMask()))
1017         {
1018            /* we HAVE TO use the direct way for memory dcs
1019               that have mask since the XCopyArea doesn't know
1020               about masks */
1021             use_bitmap_method = TRUE;
1022         }
1023         else if (memDC->m_selected.GetDepth() == 1)
1024         {
1025            /* we HAVE TO use the direct way for memory dcs
1026               that are bitmaps because XCopyArea doesn't cope
1027               with different bit depths */
1028             is_mono = TRUE;
1029             use_bitmap_method = TRUE;
1030         }
1031         else if ((xsrc == 0) && (ysrc == 0) &&
1032                  (width == memDC->m_selected.GetWidth()) &&
1033                  (height == memDC->m_selected.GetHeight()))
1034         {
1035            /* we SHOULD use the direct way if all of the bitmap
1036               in the memory dc is copied in which case XCopyArea
1037               wouldn't be able able to boost performace by reducing
1038               the area to be scaled */
1039             use_bitmap_method = TRUE;
1040         }
1041         else
1042         {
1043             use_bitmap_method = FALSE;
1044         }
1045     }
1046
1047     CalcBoundingBox( xdest, ydest );
1048     CalcBoundingBox( xdest + width, ydest + height );
1049
1050     /* scale/translate size and position */
1051     wxCoord xx = XLOG2DEV(xdest);
1052     wxCoord yy = YLOG2DEV(ydest);
1053
1054     wxCoord ww = XLOG2DEVREL(width);
1055     wxCoord hh = YLOG2DEVREL(height);
1056
1057     /* compare to current clipping region */
1058     if (!m_currentClippingRegion.IsNull())
1059     {
1060         wxRegion tmp( xx,yy,ww,hh );
1061         tmp.Intersect( m_currentClippingRegion );
1062         if (tmp.IsEmpty())
1063             return TRUE;
1064     }
1065
1066     int old_logical_func = m_logicalFunction;
1067     SetLogicalFunction( logical_func );
1068
1069     if (use_bitmap_method)
1070     {
1071         /* scale/translate bitmap size */
1072         wxCoord bm_width = memDC->m_selected.GetWidth();
1073         wxCoord bm_height = memDC->m_selected.GetHeight();
1074
1075         wxCoord bm_ww = XLOG2DEVREL( bm_width );
1076         wxCoord bm_hh = YLOG2DEVREL( bm_height );
1077
1078         /* scale bitmap if required */
1079         wxBitmap use_bitmap;
1080
1081         if ((bm_width != bm_ww) || (bm_height != bm_hh))
1082         {
1083             wxImage image( memDC->m_selected );
1084             image = image.Scale( bm_ww, bm_hh );
1085
1086             if (is_mono)
1087                 use_bitmap = image.ConvertToMonoBitmap(255,255,255);
1088             else
1089                 use_bitmap = image.ConvertToBitmap();
1090         }
1091         else
1092         {
1093             use_bitmap = memDC->m_selected;
1094         }
1095
1096         /* apply mask if any */
1097         GdkBitmap *mask = (GdkBitmap *) NULL;
1098         if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
1099
1100         if (useMask && mask)
1101         {
1102             GdkBitmap *new_mask = (GdkBitmap*) NULL;
1103             if (!m_currentClippingRegion.IsNull())
1104             {
1105                 GdkColor col;
1106                 new_mask = gdk_pixmap_new( wxRootWindow->window, bm_ww, bm_hh, 1 );
1107                 GdkGC *gc = gdk_gc_new( new_mask );
1108                 col.pixel = 0;
1109                 gdk_gc_set_foreground( gc, &col );
1110                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
1111                 col.pixel = 0;
1112                 gdk_gc_set_background( gc, &col );
1113                 col.pixel = 1;
1114                 gdk_gc_set_foreground( gc, &col );
1115                 gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
1116                 gdk_gc_set_clip_origin( gc, -xx, -yy );
1117                 gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
1118                 gdk_gc_set_stipple( gc, mask );
1119                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
1120                 gdk_gc_unref( gc );
1121             }
1122
1123             if (is_mono)
1124             {
1125                 if (new_mask)
1126                     gdk_gc_set_clip_mask( m_textGC, new_mask );
1127                 else
1128                     gdk_gc_set_clip_mask( m_textGC, mask );
1129                 gdk_gc_set_clip_origin( m_textGC, xx, yy );
1130             }
1131             else
1132             {
1133                 if (new_mask)
1134                     gdk_gc_set_clip_mask( m_penGC, new_mask );
1135                 else
1136                     gdk_gc_set_clip_mask( m_penGC, mask );
1137                 gdk_gc_set_clip_origin( m_penGC, xx, yy );
1138             }
1139             if (new_mask)
1140                 gdk_bitmap_unref( new_mask );
1141         }
1142
1143         /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
1144            drawing a mono-bitmap (XBitmap) we use the current text GC */
1145
1146         if (is_mono)
1147             gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), xsrc, ysrc, xx, yy, ww, hh );
1148         else
1149             gdk_draw_pixmap( m_window, m_penGC, use_bitmap.GetPixmap(), xsrc, ysrc, xx, yy, ww, hh );
1150
1151         /* remove mask again if any */
1152         if (useMask && mask)
1153         {
1154             if (is_mono)
1155             {
1156                 gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
1157                 gdk_gc_set_clip_origin( m_textGC, 0, 0 );
1158                 if (!m_currentClippingRegion.IsNull())
1159                     gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
1160             }
1161             else
1162             {
1163                 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
1164                 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
1165                 if (!m_currentClippingRegion.IsNull())
1166                     gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
1167             }
1168         }
1169     }
1170     else /* use_bitmap_method */
1171     {
1172         if ((width != ww) || (height != hh))
1173         {
1174             /* draw source window into a bitmap as we cannot scale
1175                a window in contrast to a bitmap. this would actually
1176                work with memory dcs as well, but we'd lose the mask
1177                information and waste one step in this process since
1178                a memory already has a bitmap. all this is slightly
1179                inefficient as we could take an XImage directly from
1180                an X window, but we'd then also have to care that
1181                the window is not outside the screen (in which case
1182                we'd get a BadMatch or what not).
1183                Is a double XGetImage and combined XGetPixel and
1184                XPutPixel really faster? I'm not sure. look at wxXt
1185                for a different implementation of the same problem. */
1186
1187             wxBitmap bitmap( width, height );
1188
1189             /* copy including child window contents */
1190             gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
1191             gdk_window_copy_area( bitmap.GetPixmap(), m_penGC, 0, 0,
1192                                   srcDC->GetWindow(),
1193                                   xsrc, ysrc, width, height );
1194             gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
1195
1196             /* scale image */
1197             wxImage image( bitmap );
1198             image = image.Scale( ww, hh );
1199
1200             /* convert to bitmap */
1201             bitmap = image.ConvertToBitmap();
1202
1203             /* draw scaled bitmap */
1204             gdk_draw_pixmap( m_window, m_penGC, bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
1205
1206         }
1207         else
1208         {
1209             /* No scaling and not a memory dc with a mask either */
1210
1211             /* copy including child window contents */
1212             gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
1213             gdk_window_copy_area( m_window, m_penGC, xx, yy,
1214                                   srcDC->GetWindow(),
1215                                   xsrc, ysrc, width, height );
1216             gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
1217         }
1218     }
1219
1220     SetLogicalFunction( old_logical_func );
1221     return TRUE;
1222 }
1223
1224 void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
1225 {
1226     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1227
1228     if (!m_window) return;
1229
1230     GdkFont *font = m_font.GetInternalFont( m_scaleY );
1231
1232     wxCHECK_RET( font, wxT("invalid font") );
1233
1234 #ifdef __WXGTK20__
1235     wxCHECK_RET( m_context, wxT("no Pango context") );
1236 #endif
1237
1238     x = XLOG2DEV(x);
1239     y = YLOG2DEV(y);
1240
1241 #ifdef __WXGTK20__
1242     /* FIXME: the layout engine should probably be abstracted at a higher level in wxDC... */
1243     PangoLayout *layout = pango_layout_new(m_context);
1244     pango_layout_set_font_description(layout, m_fontdesc);
1245     {
1246         wxWX2MBbuf data = text.mb_str(wxConvUTF8);
1247         pango_layout_set_text(layout, data, strlen(data));
1248     }
1249     PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
1250     PangoRectangle rect;
1251     pango_layout_line_get_extents(line, NULL, &rect);
1252     wxCoord width = rect.width;
1253     wxCoord height = rect.height;
1254     gdk_draw_layout( m_window, m_textGC, x, y, layout );
1255 #else
1256     wxCoord width = gdk_string_width( font, text.mbc_str() );
1257     wxCoord height = font->ascent + font->descent;
1258     /* CMB 21/5/98: draw text background if mode is wxSOLID */
1259     if (m_backgroundMode == wxSOLID)
1260     {
1261         gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
1262         gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
1263         gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
1264     }
1265     gdk_draw_string( m_window, font, m_textGC, x, y + font->ascent, text.mbc_str() );
1266 #endif
1267
1268     /* CMB 17/7/98: simple underline: ignores scaling and underlying
1269        X font's XA_UNDERLINE_POSITION and XA_UNDERLINE_THICKNESS
1270        properties (see wxXt implementation) */
1271     if (m_font.GetUnderlined())
1272     {
1273         wxCoord ul_y = y + font->ascent;
1274         if (font->descent > 0) ul_y++;
1275         gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
1276     }
1277
1278 #ifdef __WXGTK20__
1279     g_object_unref( G_OBJECT( layout ) );
1280 #endif
1281
1282     width = wxCoord(width / m_scaleX);
1283     height = wxCoord(height / m_scaleY);
1284     CalcBoundingBox (x + width, y + height);
1285     CalcBoundingBox (x, y);
1286 }
1287
1288 void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
1289 {
1290     if (angle == 0.0)
1291     {
1292         DrawText(text, x, y);
1293         return;
1294     }
1295
1296     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1297
1298     if (!m_window) return;
1299
1300     GdkFont *font = m_font.GetInternalFont( m_scaleY );
1301
1302     wxCHECK_RET( font, wxT("invalid font") );
1303
1304     // the size of the text
1305     wxCoord w = gdk_string_width( font, text.mbc_str() );
1306     wxCoord h = font->ascent + font->descent;
1307
1308     // draw the string normally
1309     wxBitmap src(w, h);
1310     wxMemoryDC dc;
1311     dc.SelectObject(src);
1312     dc.SetFont(GetFont());
1313     dc.SetBackground(*wxWHITE_BRUSH);
1314     dc.SetBrush(*wxBLACK_BRUSH);
1315     dc.Clear();
1316     dc.DrawText(text, 0, 0);
1317     dc.SetFont(wxNullFont);
1318     dc.SelectObject(wxNullBitmap);
1319
1320     // Calculate the size of the rotated bounding box.
1321     double rad = DegToRad(angle);
1322     double dx = cos(rad),
1323            dy = sin(rad);
1324
1325     // the rectngle vertices are counted clockwise with the first one being at
1326     // (0, 0) (or, rather, at (x, y))
1327     double x2 = w*dx,
1328            y2 = -w*dy;      // y axis points to the bottom, hence minus
1329     double x4 = h*dy,
1330            y4 = h*dx;
1331     double x3 = x4 + x2,
1332            y3 = y4 + y2;
1333
1334     // calc max and min
1335     wxCoord maxX = (wxCoord)(dmax(x2, dmax(x3, x4)) + 0.5),
1336             maxY = (wxCoord)(dmax(y2, dmax(y3, y4)) + 0.5),
1337             minX = (wxCoord)(dmin(x2, dmin(x3, x4)) - 0.5),
1338             minY = (wxCoord)(dmin(y2, dmin(y3, y4)) - 0.5);
1339
1340     // prepare to blit-with-rotate the bitmap to the DC
1341     wxImage image(src);
1342
1343     GdkColor *colText = m_textForegroundColour.GetColor(),
1344              *colBack = m_textBackgroundColour.GetColor();
1345
1346     bool textColSet = TRUE;
1347
1348     unsigned char *data = image.GetData();
1349
1350     // paint pixel by pixel
1351     for ( wxCoord srcX = 0; srcX < w; srcX++ )
1352     {
1353         for ( wxCoord srcY = 0; srcY < h; srcY++ )
1354         {
1355             // transform source coords to dest coords
1356             double r = sqrt((double)srcX*srcX + srcY*srcY);
1357             double angleOrig = atan2((double)srcY, (double)srcX) - rad;
1358             wxCoord dstX = (wxCoord)(r*cos(angleOrig) + 0.5),
1359                     dstY = (wxCoord)(r*sin(angleOrig) + 0.5);
1360
1361             // black pixel?
1362             bool textPixel = data[(srcY*w + srcX)*3] == 0;
1363             if ( textPixel || (m_backgroundMode == wxSOLID) )
1364             {
1365                 // change colour if needed
1366                 if ( textPixel != textColSet )
1367                 {
1368                     gdk_gc_set_foreground( m_textGC, textPixel ? colText
1369                                                                : colBack );
1370
1371                     textColSet = textPixel;
1372                 }
1373
1374                 // don't use DrawPoint() because it uses the current pen
1375                 // colour, and we don't need it here
1376                 gdk_draw_point( m_window, m_textGC,
1377                                 XLOG2DEV(x + dstX), YLOG2DEV(y + dstY) );
1378             }
1379         }
1380     }
1381
1382     // it would be better to draw with non underlined font and draw the line
1383     // manually here (it would be more straight...)
1384 #if 0
1385     if ( m_font.GetUnderlined() )
1386     {
1387         gdk_draw_line( m_window, m_textGC,
1388                        XLOG2DEV(x + x4), YLOG2DEV(y + y4 + font->descent),
1389                        XLOG2DEV(x + x3), YLOG2DEV(y + y3 + font->descent));
1390     }
1391 #endif // 0
1392
1393     // restore the font colour
1394     gdk_gc_set_foreground( m_textGC, colText );
1395
1396     // update the bounding box
1397     CalcBoundingBox(x + minX, y + minY);
1398     CalcBoundingBox(x + maxX, y + maxY);
1399 }
1400
1401 void wxWindowDC::DoGetTextExtent(const wxString &string,
1402                                  wxCoord *width, wxCoord *height,
1403                                  wxCoord *descent, wxCoord *externalLeading,
1404                                  wxFont *theFont) const
1405 {
1406     wxFont fontToUse = m_font;
1407     if (theFont) fontToUse = *theFont;
1408
1409     GdkFont *font = fontToUse.GetInternalFont( m_scaleY );
1410     if (width) (*width) = wxCoord(gdk_string_width( font, string.mbc_str() ) / m_scaleX);
1411     if (height) (*height) = wxCoord((font->ascent + font->descent) / m_scaleY);
1412     if (descent) (*descent) = wxCoord(font->descent / m_scaleY);
1413     if (externalLeading) (*externalLeading) = 0;  // ??
1414 }
1415
1416 wxCoord wxWindowDC::GetCharWidth() const
1417 {
1418     GdkFont *font = m_font.GetInternalFont( m_scaleY );
1419     wxCHECK_MSG( font, -1, wxT("invalid font") );
1420
1421     return wxCoord(gdk_string_width( font, "H" ) / m_scaleX);
1422 }
1423
1424 wxCoord wxWindowDC::GetCharHeight() const
1425 {
1426     GdkFont *font = m_font.GetInternalFont( m_scaleY );
1427     wxCHECK_MSG( font, -1, wxT("invalid font") );
1428
1429     return wxCoord((font->ascent + font->descent) / m_scaleY);
1430 }
1431
1432 void wxWindowDC::Clear()
1433 {
1434     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1435
1436     if (!m_window) return;
1437
1438     /* - we either are a memory dc or have a window as the
1439        owner. anything else shouldn't happen.
1440        - we don't use gdk_window_clear() as we don't set
1441        the window's background colour anymore. it is too
1442        much pain to keep the DC's and the window's back-
1443        ground colour in synch. */
1444
1445     if (m_owner)
1446     {
1447         int width,height;
1448         m_owner->GetSize( &width, &height );
1449         gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
1450         return;
1451     }
1452
1453     if (m_isMemDC)
1454     {
1455         int width,height;
1456         GetSize( &width, &height );
1457         gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
1458         return;
1459     }
1460 }
1461
1462 void wxWindowDC::SetFont( const wxFont &font )
1463 {
1464     m_font = font;
1465 #ifdef __WXGTK20__
1466     // fix fontdesc?
1467 #endif
1468 }
1469
1470 void wxWindowDC::SetPen( const wxPen &pen )
1471 {
1472     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1473
1474     if (m_pen == pen) return;
1475
1476     m_pen = pen;
1477
1478     if (!m_pen.Ok()) return;
1479
1480     if (!m_window) return;
1481
1482     gint width = m_pen.GetWidth();
1483     if (width <= 0)
1484     {
1485         // CMB: if width is non-zero scale it with the dc
1486         width = 1;
1487     }
1488     else
1489     {
1490         // X doesn't allow different width in x and y and so we take
1491         // the average
1492         double w = 0.5 +
1493                    ( fabs((double) XLOG2DEVREL(width)) +
1494                      fabs((double) YLOG2DEVREL(width)) ) / 2.0;
1495         width = (int)w;
1496     }
1497
1498     static const wxGTKDash dotted[] = {1, 1};
1499     static const wxGTKDash short_dashed[] = {2, 2};
1500     static const wxGTKDash wxCoord_dashed[] = {2, 4};
1501     static const wxGTKDash dotted_dashed[] = {3, 3, 1, 3};
1502
1503     // We express dash pattern in pen width unit, so we are
1504     // independent of zoom factor and so on...
1505     int req_nb_dash;
1506     const wxGTKDash *req_dash;
1507
1508     GdkLineStyle lineStyle = GDK_LINE_SOLID;
1509     switch (m_pen.GetStyle())
1510     {
1511         case wxUSER_DASH:
1512         {
1513             lineStyle = GDK_LINE_ON_OFF_DASH;
1514             req_nb_dash = m_pen.GetDashCount();
1515             req_dash = (wxGTKDash*)m_pen.GetDash();
1516             break;
1517         }
1518         case wxDOT:
1519         {
1520             lineStyle = GDK_LINE_ON_OFF_DASH;
1521             req_nb_dash = 2;
1522             req_dash = dotted;
1523             break;
1524         }
1525         case wxLONG_DASH:
1526         {
1527             lineStyle = GDK_LINE_ON_OFF_DASH;
1528             req_nb_dash = 2;
1529             req_dash = wxCoord_dashed;
1530             break;
1531         }
1532         case wxSHORT_DASH:
1533         {
1534             lineStyle = GDK_LINE_ON_OFF_DASH;
1535             req_nb_dash = 2;
1536             req_dash = short_dashed;
1537             break;
1538         }
1539         case wxDOT_DASH:
1540         {
1541 //            lineStyle = GDK_LINE_DOUBLE_DASH;
1542             lineStyle = GDK_LINE_ON_OFF_DASH;
1543             req_nb_dash = 4;
1544             req_dash = dotted_dashed;
1545             break;
1546         }
1547
1548         case wxTRANSPARENT:
1549         case wxSTIPPLE_MASK_OPAQUE:
1550         case wxSTIPPLE:
1551         case wxSOLID:
1552         default:
1553         {
1554             lineStyle = GDK_LINE_SOLID;
1555             req_dash = (wxGTKDash*)NULL;
1556             req_nb_dash = 0;
1557             break;
1558         }
1559     }
1560
1561 #if (GTK_MINOR_VERSION > 0) || (GTK_MAJOR_VERSION > 1)
1562     if (req_dash && req_nb_dash)
1563     {
1564         wxGTKDash *real_req_dash = new wxGTKDash[req_nb_dash];
1565         if (real_req_dash)
1566         {
1567             for (int i = 0; i < req_nb_dash; i++)
1568                 real_req_dash[i] = req_dash[i] * width;
1569             gdk_gc_set_dashes( m_penGC, 0, real_req_dash, req_nb_dash );
1570             delete[] real_req_dash;
1571         }
1572         else
1573         {
1574             // No Memory. We use non-scaled dash pattern...
1575             gdk_gc_set_dashes( m_penGC, 0, (wxGTKDash*)req_dash, req_nb_dash );
1576         }
1577     }
1578 #endif
1579
1580     GdkCapStyle capStyle = GDK_CAP_ROUND;
1581     switch (m_pen.GetCap())
1582     {
1583         case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; }
1584         case wxCAP_BUTT:       { capStyle = GDK_CAP_BUTT;       break; }
1585         case wxCAP_ROUND:
1586         default:
1587         {
1588             if (width <= 1)
1589             {
1590                 width = 0;
1591                 capStyle = GDK_CAP_NOT_LAST;
1592             }
1593             else
1594             {
1595                 capStyle = GDK_CAP_ROUND;
1596             }
1597             break;
1598         }
1599     }
1600
1601     GdkJoinStyle joinStyle = GDK_JOIN_ROUND;
1602     switch (m_pen.GetJoin())
1603     {
1604         case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; }
1605         case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; }
1606         case wxJOIN_ROUND:
1607         default:           { joinStyle = GDK_JOIN_ROUND; break; }
1608     }
1609
1610     gdk_gc_set_line_attributes( m_penGC, width, lineStyle, capStyle, joinStyle );
1611
1612     m_pen.GetColour().CalcPixel( m_cmap );
1613     gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
1614 }
1615
1616 void wxWindowDC::SetBrush( const wxBrush &brush )
1617 {
1618     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1619
1620     if (m_brush == brush) return;
1621
1622     m_brush = brush;
1623
1624     if (!m_brush.Ok()) return;
1625
1626     if (!m_window) return;
1627
1628     m_brush.GetColour().CalcPixel( m_cmap );
1629     gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
1630
1631     gdk_gc_set_fill( m_brushGC, GDK_SOLID );
1632
1633     if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
1634     {
1635         if (m_brush.GetStipple()->GetPixmap())
1636         {
1637             gdk_gc_set_fill( m_brushGC, GDK_TILED );
1638             gdk_gc_set_tile( m_brushGC, m_brush.GetStipple()->GetPixmap() );
1639         }
1640         else
1641         {
1642             gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
1643             gdk_gc_set_stipple( m_brushGC, m_brush.GetStipple()->GetBitmap() );
1644         }
1645     }
1646
1647     if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
1648     {
1649         gdk_gc_set_fill( m_textGC, GDK_OPAQUE_STIPPLED);
1650         gdk_gc_set_stipple( m_textGC, m_brush.GetStipple()->GetMask()->GetBitmap() );
1651     }
1652
1653     if (IS_HATCH(m_brush.GetStyle()))
1654     {
1655         gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
1656         int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
1657         gdk_gc_set_stipple( m_brushGC, hatches[num] );
1658     }
1659 }
1660
1661 void wxWindowDC::SetBackground( const wxBrush &brush )
1662 {
1663    /* CMB 21/7/98: Added SetBackground. Sets background brush
1664     * for Clear() and bg colour for shapes filled with cross-hatch brush */
1665
1666     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1667
1668     if (m_backgroundBrush == brush) return;
1669
1670     m_backgroundBrush = brush;
1671
1672     if (!m_backgroundBrush.Ok()) return;
1673
1674     if (!m_window) return;
1675
1676     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
1677     gdk_gc_set_background( m_brushGC, m_backgroundBrush.GetColour().GetColor() );
1678     gdk_gc_set_background( m_penGC, m_backgroundBrush.GetColour().GetColor() );
1679     gdk_gc_set_background( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
1680     gdk_gc_set_foreground( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
1681
1682     gdk_gc_set_fill( m_bgGC, GDK_SOLID );
1683
1684     if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
1685     {
1686         if (m_backgroundBrush.GetStipple()->GetPixmap())
1687         {
1688             gdk_gc_set_fill( m_bgGC, GDK_TILED );
1689             gdk_gc_set_tile( m_bgGC, m_backgroundBrush.GetStipple()->GetPixmap() );
1690         }
1691         else
1692         {
1693             gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
1694             gdk_gc_set_stipple( m_bgGC, m_backgroundBrush.GetStipple()->GetBitmap() );
1695         }
1696     }
1697
1698     if (IS_HATCH(m_backgroundBrush.GetStyle()))
1699     {
1700         gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
1701         int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
1702         gdk_gc_set_stipple( m_bgGC, hatches[num] );
1703     }
1704 }
1705
1706 void wxWindowDC::SetLogicalFunction( int function )
1707 {
1708     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1709
1710     if (m_logicalFunction == function)
1711         return;
1712
1713     // VZ: shouldn't this be a CHECK?
1714     if (!m_window)
1715         return;
1716
1717     GdkFunction mode = GDK_COPY;
1718     switch (function)
1719     {
1720         case wxXOR:          mode = GDK_XOR;           break;
1721         case wxINVERT:       mode = GDK_INVERT;        break;
1722 #if (GTK_MINOR_VERSION > 0)
1723         case wxOR_REVERSE:   mode = GDK_OR_REVERSE;    break;
1724         case wxAND_REVERSE:  mode = GDK_AND_REVERSE;   break;
1725         case wxCLEAR:        mode = GDK_CLEAR;         break;
1726         case wxSET:          mode = GDK_SET;           break;
1727         case wxOR_INVERT:    mode = GDK_OR_INVERT;     break;
1728         case wxAND:          mode = GDK_AND;           break;
1729         case wxOR:           mode = GDK_OR;            break;
1730         case wxEQUIV:        mode = GDK_EQUIV;         break;
1731         case wxNAND:         mode = GDK_NAND;          break;
1732         case wxAND_INVERT:   mode = GDK_AND_INVERT;    break;
1733         case wxCOPY:         mode = GDK_COPY;          break;
1734         case wxNO_OP:        mode = GDK_NOOP;          break;
1735         case wxSRC_INVERT:   mode = GDK_COPY_INVERT;   break;
1736
1737         // unsupported by GTK
1738         case wxNOR:          mode = GDK_COPY;          break;
1739 #endif
1740         default:
1741         {
1742            wxFAIL_MSG( wxT("unsupported logical function") );
1743            break;
1744         }
1745     }
1746
1747     m_logicalFunction = function;
1748
1749     gdk_gc_set_function( m_penGC, mode );
1750     gdk_gc_set_function( m_brushGC, mode );
1751
1752     // to stay compatible with wxMSW, we don't apply ROPs to the text
1753     // operations (i.e. DrawText/DrawRotatedText).
1754     // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
1755     gdk_gc_set_function( m_textGC, mode );
1756 }
1757
1758 void wxWindowDC::SetTextForeground( const wxColour &col )
1759 {
1760     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1761
1762     if (m_textForegroundColour == col) return;
1763
1764     m_textForegroundColour = col;
1765     if (!m_textForegroundColour.Ok()) return;
1766
1767     if (!m_window) return;
1768
1769     m_textForegroundColour.CalcPixel( m_cmap );
1770     gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
1771 }
1772
1773 void wxWindowDC::SetTextBackground( const wxColour &col )
1774 {
1775     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1776
1777     if (m_textBackgroundColour == col) return;
1778
1779     m_textBackgroundColour = col;
1780     if (!m_textBackgroundColour.Ok()) return;
1781
1782     if (!m_window) return;
1783
1784     m_textBackgroundColour.CalcPixel( m_cmap );
1785     gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
1786 }
1787
1788 void wxWindowDC::SetBackgroundMode( int mode )
1789 {
1790     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1791
1792     m_backgroundMode = mode;
1793
1794     if (!m_window) return;
1795
1796     // CMB 21/7/98: fill style of cross-hatch brushes is affected by
1797     // transparent/solid background mode
1798
1799     if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
1800     {
1801         gdk_gc_set_fill( m_brushGC,
1802           (m_backgroundMode == wxTRANSPARENT) ? GDK_STIPPLED : GDK_OPAQUE_STIPPLED);
1803     }
1804 }
1805
1806 void wxWindowDC::SetPalette( const wxPalette& WXUNUSED(palette) )
1807 {
1808     wxFAIL_MSG( wxT("wxWindowDC::SetPalette not implemented") );
1809 }
1810
1811 void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
1812 {
1813     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1814
1815     if (!m_window) return;
1816
1817     wxRect rect;
1818     rect.x = XLOG2DEV(x);
1819     rect.y = YLOG2DEV(y);
1820     rect.width = XLOG2DEVREL(width);
1821     rect.height = YLOG2DEVREL(height);
1822
1823     if (!m_currentClippingRegion.IsNull())
1824         m_currentClippingRegion.Intersect( rect );
1825     else
1826         m_currentClippingRegion.Union( rect );
1827
1828 #if USE_PAINT_REGION
1829     if (!m_paintClippingRegion.IsNull())
1830         m_currentClippingRegion.Intersect( m_paintClippingRegion );
1831 #endif
1832
1833     wxCoord xx, yy, ww, hh;
1834     m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1835     wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1836
1837     gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
1838     gdk_gc_set_clip_region( m_brushGC, m_currentClippingRegion.GetRegion() );
1839     gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
1840     gdk_gc_set_clip_region( m_bgGC, m_currentClippingRegion.GetRegion() );
1841 }
1842
1843 void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion &region  )
1844 {
1845     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1846
1847     if (region.Empty())
1848     {
1849         DestroyClippingRegion();
1850         return;
1851     }
1852
1853     if (!m_window) return;
1854
1855     if (!m_currentClippingRegion.IsNull())
1856         m_currentClippingRegion.Intersect( region );
1857     else
1858         m_currentClippingRegion.Union( region );
1859
1860 #if USE_PAINT_REGION
1861     if (!m_paintClippingRegion.IsNull())
1862         m_currentClippingRegion.Intersect( m_paintClippingRegion );
1863 #endif
1864
1865     wxCoord xx, yy, ww, hh;
1866     m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1867     wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1868
1869     gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
1870     gdk_gc_set_clip_region( m_brushGC, m_currentClippingRegion.GetRegion() );
1871     gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
1872     gdk_gc_set_clip_region( m_bgGC, m_currentClippingRegion.GetRegion() );
1873 }
1874
1875 void wxWindowDC::DestroyClippingRegion()
1876 {
1877     wxCHECK_RET( Ok(), wxT("invalid window dc") );
1878
1879     wxDC::DestroyClippingRegion();
1880
1881     m_currentClippingRegion.Clear();
1882
1883 #if USE_PAINT_REGION
1884     if (!m_paintClippingRegion.IsEmpty())
1885         m_currentClippingRegion.Union( m_paintClippingRegion );
1886 #endif
1887
1888     if (!m_window) return;
1889
1890     if (m_currentClippingRegion.IsEmpty())
1891     {
1892         gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
1893         gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
1894         gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
1895         gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
1896     }
1897     else
1898     {
1899         gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
1900         gdk_gc_set_clip_region( m_brushGC, m_currentClippingRegion.GetRegion() );
1901         gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
1902         gdk_gc_set_clip_region( m_bgGC, m_currentClippingRegion.GetRegion() );
1903     }
1904 }
1905
1906 void wxWindowDC::Destroy()
1907 {
1908     if (m_penGC) wxFreePoolGC( m_penGC );
1909     m_penGC = (GdkGC*) NULL;
1910     if (m_brushGC) wxFreePoolGC( m_brushGC );
1911     m_brushGC = (GdkGC*) NULL;
1912     if (m_textGC) wxFreePoolGC( m_textGC );
1913     m_textGC = (GdkGC*) NULL;
1914     if (m_bgGC) wxFreePoolGC( m_bgGC );
1915     m_bgGC = (GdkGC*) NULL;
1916 }
1917
1918 void wxWindowDC::ComputeScaleAndOrigin()
1919 {
1920     /* CMB: copy scale to see if it changes */
1921     double origScaleX = m_scaleX;
1922     double origScaleY = m_scaleY;
1923
1924     wxDC::ComputeScaleAndOrigin();
1925
1926     /* CMB: if scale has changed call SetPen to recalulate the line width */
1927     if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&
1928         (m_pen.Ok()))
1929     {
1930       /* this is a bit artificial, but we need to force wxDC to think
1931          the pen has changed */
1932       wxPen pen = m_pen;
1933       m_pen = wxNullPen;
1934       SetPen( pen );
1935   }
1936 }
1937
1938 // Resolution in pixels per logical inch
1939 wxSize wxWindowDC::GetPPI() const
1940 {
1941     return wxSize(100, 100);
1942 }
1943
1944 int wxWindowDC::GetDepth() const
1945 {
1946     wxFAIL_MSG(wxT("not implemented"));
1947
1948     return -1;
1949 }
1950
1951 #if wxUSE_SPLINES
1952 // ----------------------------------- spline code ----------------------------------------
1953
1954 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
1955                          double a3, double b3, double a4, double b4);
1956 void wx_clear_stack();
1957 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
1958         double *y3, double *x4, double *y4);
1959 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
1960           double x4, double y4);
1961 static bool wx_spline_add_point(double x, double y);
1962 static void wx_spline_draw_point_array(wxDC *dc);
1963
1964 wxList wx_spline_point_list;
1965
1966 #define                half(z1, z2)        ((z1+z2)/2.0)
1967 #define                THRESHOLD        5
1968
1969 /* iterative version */
1970
1971 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
1972                  double b4)
1973 {
1974     register double  xmid, ymid;
1975     double           x1, y1, x2, y2, x3, y3, x4, y4;
1976
1977     wx_clear_stack();
1978     wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
1979
1980     while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
1981         xmid = (double)half(x2, x3);
1982         ymid = (double)half(y2, y3);
1983         if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
1984             fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
1985             wx_spline_add_point( x1, y1 );
1986             wx_spline_add_point( xmid, ymid );
1987         } else {
1988             wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
1989                  (double)half(x3, x4), (double)half(y3, y4), x4, y4);
1990             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
1991                  (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
1992         }
1993     }
1994 }
1995
1996 /* utilities used by spline drawing routines */
1997
1998 typedef struct wx_spline_stack_struct {
1999     double           x1, y1, x2, y2, x3, y3, x4, y4;
2000 } Stack;
2001
2002 #define         SPLINE_STACK_DEPTH             20
2003 static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
2004 static Stack   *wx_stack_top;
2005 static int      wx_stack_count;
2006
2007 void wx_clear_stack()
2008 {
2009     wx_stack_top = wx_spline_stack;
2010     wx_stack_count = 0;
2011 }
2012
2013 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
2014 {
2015     wx_stack_top->x1 = x1;
2016     wx_stack_top->y1 = y1;
2017     wx_stack_top->x2 = x2;
2018     wx_stack_top->y2 = y2;
2019     wx_stack_top->x3 = x3;
2020     wx_stack_top->y3 = y3;
2021     wx_stack_top->x4 = x4;
2022     wx_stack_top->y4 = y4;
2023     wx_stack_top++;
2024     wx_stack_count++;
2025 }
2026
2027 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
2028                   double *x3, double *y3, double *x4, double *y4)
2029 {
2030     if (wx_stack_count == 0)
2031         return (0);
2032     wx_stack_top--;
2033     wx_stack_count--;
2034     *x1 = wx_stack_top->x1;
2035     *y1 = wx_stack_top->y1;
2036     *x2 = wx_stack_top->x2;
2037     *y2 = wx_stack_top->y2;
2038     *x3 = wx_stack_top->x3;
2039     *y3 = wx_stack_top->y3;
2040     *x4 = wx_stack_top->x4;
2041     *y4 = wx_stack_top->y4;
2042     return (1);
2043 }
2044
2045 static bool wx_spline_add_point(double x, double y)
2046 {
2047   wxPoint *point = new wxPoint ;
2048   point->x = (int) x;
2049   point->y = (int) y;
2050   wx_spline_point_list.Append((wxObject*)point);
2051   return TRUE;
2052 }
2053
2054 static void wx_spline_draw_point_array(wxDC *dc)
2055 {
2056   dc->DrawLines(&wx_spline_point_list, 0, 0 );
2057   wxNode *node = wx_spline_point_list.First();
2058   while (node)
2059   {
2060     wxPoint *point = (wxPoint *)node->Data();
2061     delete point;
2062     delete node;
2063     node = wx_spline_point_list.First();
2064   }
2065 }
2066
2067 void wxWindowDC::DoDrawSpline( wxList *points )
2068 {
2069     wxCHECK_RET( Ok(), wxT("invalid window dc") );
2070
2071     wxPoint *p;
2072     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
2073     double           x1, y1, x2, y2;
2074
2075     wxNode *node = points->First();
2076     p = (wxPoint *)node->Data();
2077
2078     x1 = p->x;
2079     y1 = p->y;
2080
2081     node = node->Next();
2082     p = (wxPoint *)node->Data();
2083
2084     x2 = p->x;
2085     y2 = p->y;
2086     cx1 = (double)((x1 + x2) / 2);
2087     cy1 = (double)((y1 + y2) / 2);
2088     cx2 = (double)((cx1 + x2) / 2);
2089     cy2 = (double)((cy1 + y2) / 2);
2090
2091     wx_spline_add_point(x1, y1);
2092
2093     while ((node = node->Next()) != NULL)
2094     {
2095         p = (wxPoint *)node->Data();
2096         x1 = x2;
2097         y1 = y2;
2098         x2 = p->x;
2099         y2 = p->y;
2100         cx4 = (double)(x1 + x2) / 2;
2101         cy4 = (double)(y1 + y2) / 2;
2102         cx3 = (double)(x1 + cx4) / 2;
2103         cy3 = (double)(y1 + cy4) / 2;
2104
2105         wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
2106
2107         cx1 = cx4;
2108         cy1 = cy4;
2109         cx2 = (double)(cx1 + x2) / 2;
2110         cy2 = (double)(cy1 + y2) / 2;
2111     }
2112
2113     wx_spline_add_point( cx1, cy1 );
2114     wx_spline_add_point( x2, y2 );
2115
2116     wx_spline_draw_point_array( this );
2117 }
2118
2119 #endif // wxUSE_SPLINE
2120
2121 //-----------------------------------------------------------------------------
2122 // wxPaintDC
2123 //-----------------------------------------------------------------------------
2124
2125 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC,wxWindowDC)
2126
2127 wxPaintDC::wxPaintDC()
2128   : wxWindowDC()
2129 {
2130 }
2131
2132 wxPaintDC::wxPaintDC( wxWindow *win )
2133   : wxWindowDC( win )
2134 {
2135 #if USE_PAINT_REGION
2136     if (!win->m_clipPaintRegion)
2137         return;
2138
2139     m_paintClippingRegion = win->GetUpdateRegion();
2140     GdkRegion *region = m_paintClippingRegion.GetRegion();
2141     if ( region )
2142     {
2143         m_currentClippingRegion.Union( m_paintClippingRegion );
2144
2145         gdk_gc_set_clip_region( m_penGC, region );
2146         gdk_gc_set_clip_region( m_brushGC, region );
2147         gdk_gc_set_clip_region( m_textGC, region );
2148         gdk_gc_set_clip_region( m_bgGC, region );
2149     }
2150 #endif
2151 }
2152
2153 //-----------------------------------------------------------------------------
2154 // wxClientDC
2155 //-----------------------------------------------------------------------------
2156
2157 IMPLEMENT_DYNAMIC_CLASS(wxClientDC,wxWindowDC)
2158
2159 wxClientDC::wxClientDC()
2160   : wxWindowDC()
2161 {
2162 }
2163
2164 wxClientDC::wxClientDC( wxWindow *win )
2165   : wxWindowDC( win )
2166 {
2167 }
2168
2169 // ----------------------------------------------------------------------------
2170 // wxDCModule
2171 // ----------------------------------------------------------------------------
2172
2173 class wxDCModule : public wxModule
2174 {
2175 public:
2176     bool OnInit();
2177     void OnExit();
2178
2179 private:
2180     DECLARE_DYNAMIC_CLASS(wxDCModule)
2181 };
2182
2183 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2184
2185 bool wxDCModule::OnInit()
2186 {
2187     wxInitGCPool();
2188     return TRUE;
2189 }
2190
2191 void wxDCModule::OnExit()
2192 {
2193     wxCleanUpGCPool();
2194 }