]> git.saurik.com Git - wxWidgets.git/blame - src/gtk/dcclient.cpp
Commit pickers-fixes.patch added to 1472329 (Francesco Montorsi)
[wxWidgets.git] / src / gtk / dcclient.cpp
CommitLineData
c801d85f 1/////////////////////////////////////////////////////////////////////////////
e4db172a 2// Name: src/gtk/dcclient.cpp
c801d85f
KB
3// Purpose:
4// Author: Robert Roebling
6f65e337 5// RCS-ID: $Id$
6c9a19aa 6// Copyright: (c) 1998 Robert Roebling, Chris Breeze
65571936 7// Licence: wxWindows licence
c801d85f
KB
8/////////////////////////////////////////////////////////////////////////////
9
14f355c2
VS
10// For compilers that support precompilation, includes "wx.h".
11#include "wx/wxprec.h"
12
d02af7bb
JJ
13#ifdef __VMS
14#define XCopyPlane XCOPYPLANE
15#endif
16
c801d85f 17#include "wx/dcclient.h"
e4db172a
WS
18
19#ifndef WX_PRECOMP
20 #include "wx/log.h"
f38924e8 21 #include "wx/dcmemory.h"
e4db172a
WS
22#endif
23
4bc67cc5 24#include "wx/image.h"
e5131165 25#include "wx/module.h"
db16cab4 26#include "wx/fontutil.h"
e5131165 27
ed673c6a 28#include "wx/gtk/win_gtk.h"
a3669332 29#include "wx/gtk/private.h"
c801d85f 30
463c4d71 31#include "wx/math.h" // for floating-point functions
e5131165 32
071a2d78 33#include <gdk/gdk.h>
993f97ee 34#include <gdk/gdkx.h>
8943b403 35#include <gdk/gdkprivate.h>
071a2d78 36#include <gtk/gtk.h>
83624f79 37
809934d2
RR
38//-----------------------------------------------------------------------------
39// local defines
40//-----------------------------------------------------------------------------
41
e1208c31 42#define USE_PAINT_REGION 1
809934d2 43
c801d85f
KB
44//-----------------------------------------------------------------------------
45// local data
46//-----------------------------------------------------------------------------
47
48#include "bdiag.xbm"
49#include "fdiag.xbm"
50#include "cdiag.xbm"
51#include "horiz.xbm"
52#include "verti.xbm"
53#include "cross.xbm"
54#define num_hatches 6
55
3ca6a5f0
BP
56#define IS_15_PIX_HATCH(s) ((s)==wxCROSSDIAG_HATCH || (s)==wxHORIZONTAL_HATCH || (s)==wxVERTICAL_HATCH)
57#define IS_16_PIX_HATCH(s) ((s)!=wxCROSSDIAG_HATCH && (s)!=wxHORIZONTAL_HATCH && (s)!=wxVERTICAL_HATCH)
58
59
c801d85f 60static GdkPixmap *hatches[num_hatches];
c67daf87 61static GdkPixmap **hatch_bitmap = (GdkPixmap **) NULL;
c801d85f 62
c2fa61e8 63extern GtkWidget *wxGetRootWindow();
3d2d8da1 64
c801d85f
KB
65//-----------------------------------------------------------------------------
66// constants
67//-----------------------------------------------------------------------------
68
95724b1a 69const double RAD2DEG = 180.0 / M_PI;
c801d85f 70
9a8c7620
VZ
71// ----------------------------------------------------------------------------
72// private functions
73// ----------------------------------------------------------------------------
74
75static inline double dmax(double a, double b) { return a > b ? a : b; }
76static inline double dmin(double a, double b) { return a < b ? a : b; }
77
78static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
79
6f65e337
JS
80//-----------------------------------------------------------------------------
81// temporary implementation of the missing GDK function
82//-----------------------------------------------------------------------------
b0e0d661 83
6f65e337 84#include "gdk/gdkprivate.h"
b0e0d661 85
1e6feb95
VZ
86void gdk_wx_draw_bitmap(GdkDrawable *drawable,
87 GdkGC *gc,
88 GdkDrawable *src,
89 gint xsrc,
90 gint ysrc,
91 gint xdest,
92 gint ydest,
93 gint width,
94 gint height)
6f65e337 95{
17a1ebd1
VZ
96 wxCHECK_RET( drawable, _T("NULL drawable in gdk_wx_draw_bitmap") );
97 wxCHECK_RET( src, _T("NULL src in gdk_wx_draw_bitmap") );
98 wxCHECK_RET( gc, _T("NULL gc in gdk_wx_draw_bitmap") );
ab9d0a8c 99
d90c9596 100 gint src_width, src_height;
8943b403 101 gdk_drawable_get_size(src, &src_width, &src_height);
8943b403
OK
102 if (width == -1) width = src_width;
103 if (height == -1) height = src_height;
265898fd 104
8943b403
OK
105 XCopyPlane( GDK_WINDOW_XDISPLAY(drawable),
106 GDK_WINDOW_XID(src),
107 GDK_WINDOW_XID(drawable),
108 GDK_GC_XGC(gc),
109 xsrc, ysrc,
110 width, height,
d90c9596 111 0, 0,
8943b403 112 1 );
6f65e337
JS
113}
114
3d2d8da1
RR
115//-----------------------------------------------------------------------------
116// Implement Pool of Graphic contexts. Creating them takes too much time.
117//-----------------------------------------------------------------------------
118
0e09f76e
RR
119enum wxPoolGCType
120{
121 wxGC_ERROR = 0,
122 wxTEXT_MONO,
123 wxBG_MONO,
124 wxPEN_MONO,
125 wxBRUSH_MONO,
126 wxTEXT_COLOUR,
127 wxBG_COLOUR,
128 wxPEN_COLOUR,
f6bcfd97
BP
129 wxBRUSH_COLOUR,
130 wxTEXT_SCREEN,
131 wxBG_SCREEN,
132 wxPEN_SCREEN,
133 wxBRUSH_SCREEN
0e09f76e
RR
134};
135
3d2d8da1
RR
136struct wxGC
137{
0e09f76e
RR
138 GdkGC *m_gc;
139 wxPoolGCType m_type;
140 bool m_used;
3d2d8da1
RR
141};
142
696f36b7
JS
143#define GC_POOL_ALLOC_SIZE 100
144
145static int wxGCPoolSize = 0;
146
147static wxGC *wxGCPool = NULL;
3d2d8da1
RR
148
149static void wxInitGCPool()
150{
696f36b7
JS
151 // This really could wait until the first call to
152 // wxGetPoolGC, but we will make the first allocation
153 // now when other initialization is being performed.
ab9d0a8c 154
696f36b7
JS
155 // Set initial pool size.
156 wxGCPoolSize = GC_POOL_ALLOC_SIZE;
ab9d0a8c 157
696f36b7
JS
158 // Allocate initial pool.
159 wxGCPool = (wxGC *)malloc(wxGCPoolSize * sizeof(wxGC));
160 if (wxGCPool == NULL)
161 {
162 // If we cannot malloc, then fail with error
163 // when debug is enabled. If debug is not enabled,
164 // the problem will eventually get caught
551b5391 165 // in wxGetPoolGC.
696f36b7
JS
166 wxFAIL_MSG( wxT("Cannot allocate GC pool") );
167 return;
168 }
ab9d0a8c 169
696f36b7
JS
170 // Zero initial pool.
171 memset(wxGCPool, 0, wxGCPoolSize * sizeof(wxGC));
3d2d8da1
RR
172}
173
174static void wxCleanUpGCPool()
175{
f6116855 176 for (int i = 0; i < wxGCPoolSize; i++)
3d2d8da1
RR
177 {
178 if (wxGCPool[i].m_gc)
3fe39b0c 179 g_object_unref (wxGCPool[i].m_gc);
3d2d8da1 180 }
696f36b7
JS
181
182 free(wxGCPool);
183 wxGCPool = NULL;
184 wxGCPoolSize = 0;
3d2d8da1
RR
185}
186
0e09f76e 187static GdkGC* wxGetPoolGC( GdkWindow *window, wxPoolGCType type )
3d2d8da1 188{
696f36b7 189 wxGC *pptr;
ab9d0a8c 190
696f36b7
JS
191 // Look for an available GC.
192 for (int i = 0; i < wxGCPoolSize; i++)
3d2d8da1
RR
193 {
194 if (!wxGCPool[i].m_gc)
195 {
196 wxGCPool[i].m_gc = gdk_gc_new( window );
197 gdk_gc_set_exposures( wxGCPool[i].m_gc, FALSE );
0e09f76e 198 wxGCPool[i].m_type = type;
ab9d0a8c 199 wxGCPool[i].m_used = false;
3d2d8da1 200 }
0e09f76e 201 if ((!wxGCPool[i].m_used) && (wxGCPool[i].m_type == type))
3d2d8da1 202 {
ab9d0a8c 203 wxGCPool[i].m_used = true;
3d2d8da1
RR
204 return wxGCPool[i].m_gc;
205 }
206 }
5f170f33 207
696f36b7
JS
208 // We did not find an available GC.
209 // We need to grow the GC pool.
210 pptr = (wxGC *)realloc(wxGCPool,
551b5391 211 (wxGCPoolSize + GC_POOL_ALLOC_SIZE)*sizeof(wxGC));
696f36b7
JS
212 if (pptr != NULL)
213 {
214 // Initialize newly allocated pool.
215 wxGCPool = pptr;
551b5391
RR
216 memset(&wxGCPool[wxGCPoolSize], 0,
217 GC_POOL_ALLOC_SIZE*sizeof(wxGC));
ab9d0a8c
WS
218
219 // Initialize entry we will return.
696f36b7
JS
220 wxGCPool[wxGCPoolSize].m_gc = gdk_gc_new( window );
221 gdk_gc_set_exposures( wxGCPool[wxGCPoolSize].m_gc, FALSE );
222 wxGCPool[wxGCPoolSize].m_type = type;
ab9d0a8c
WS
223 wxGCPool[wxGCPoolSize].m_used = true;
224
696f36b7
JS
225 // Set new value of pool size.
226 wxGCPoolSize += GC_POOL_ALLOC_SIZE;
ab9d0a8c 227
696f36b7
JS
228 // Return newly allocated entry.
229 return wxGCPool[wxGCPoolSize-GC_POOL_ALLOC_SIZE].m_gc;
230 }
ab9d0a8c 231
696f36b7 232 // The realloc failed. Fall through to error.
3d2d8da1 233 wxFAIL_MSG( wxT("No GC available") );
5f170f33 234
3d2d8da1
RR
235 return (GdkGC*) NULL;
236}
237
238static void wxFreePoolGC( GdkGC *gc )
239{
696f36b7 240 for (int i = 0; i < wxGCPoolSize; i++)
3d2d8da1
RR
241 {
242 if (wxGCPool[i].m_gc == gc)
243 {
ab9d0a8c 244 wxGCPool[i].m_used = false;
3d2d8da1
RR
245 return;
246 }
247 }
5f170f33 248
3d2d8da1
RR
249 wxFAIL_MSG( wxT("Wrong GC") );
250}
251
c801d85f 252//-----------------------------------------------------------------------------
ec758a20 253// wxWindowDC
c801d85f
KB
254//-----------------------------------------------------------------------------
255
b0e0d661 256IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
c801d85f 257
4bc67cc5 258wxWindowDC::wxWindowDC()
c801d85f 259{
265898fd
RR
260 m_penGC = (GdkGC *) NULL;
261 m_brushGC = (GdkGC *) NULL;
262 m_textGC = (GdkGC *) NULL;
263 m_bgGC = (GdkGC *) NULL;
264 m_cmap = (GdkColormap *) NULL;
ab9d0a8c
WS
265 m_isMemDC = false;
266 m_isScreenDC = false;
bbbbe360 267 m_owner = (wxWindow *)NULL;
8943b403 268 m_context = (PangoContext *)NULL;
cfcc3932 269 m_layout = (PangoLayout *)NULL;
8943b403 270 m_fontdesc = (PangoFontDescription *)NULL;
903f689b 271}
c801d85f 272
ec758a20 273wxWindowDC::wxWindowDC( wxWindow *window )
c801d85f 274{
3cd0b8c5
RR
275 wxASSERT_MSG( window, wxT("DC needs a window") );
276
265898fd
RR
277 m_penGC = (GdkGC *) NULL;
278 m_brushGC = (GdkGC *) NULL;
279 m_textGC = (GdkGC *) NULL;
280 m_bgGC = (GdkGC *) NULL;
281 m_cmap = (GdkColormap *) NULL;
bbbbe360 282 m_owner = (wxWindow *)NULL;
ab9d0a8c
WS
283 m_isMemDC = false;
284 m_isScreenDC = false;
3b245d60 285 m_font = window->GetFont();
7d5af6fa 286
a2053b27 287 GtkWidget *widget = window->m_wxwindow;
7d5af6fa 288
cfcc3932 289 // Some controls don't have m_wxwindow - like wxStaticBox, but the user
b7f1f77f 290 // code should still be able to create wxClientDCs for them, so we will
cfcc3932 291 // use the parent window here then.
b7f1f77f
VZ
292 if ( !widget )
293 {
294 window = window->GetParent();
295 widget = window->m_wxwindow;
296 }
297
223d09f6 298 wxASSERT_MSG( widget, wxT("DC needs a widget") );
7d5af6fa 299
2b5f62a0 300 m_context = window->GtkGetPangoDefaultContext();
cfcc3932
RR
301 m_layout = pango_layout_new( m_context );
302 m_fontdesc = pango_font_description_copy( widget->style->font_desc );
8943b403 303
da048e3d
RR
304 GtkPizza *pizza = GTK_PIZZA( widget );
305 m_window = pizza->bin_window;
7d5af6fa 306
cfcc3932 307 // Window not realized ?
1e133b7d
RR
308 if (!m_window)
309 {
cfcc3932 310 // Don't report problems as per MSW.
ab9d0a8c 311 m_ok = true;
7d5af6fa
VZ
312
313 return;
1e133b7d 314 }
7d5af6fa 315
b7f1f77f 316 m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget );
7d5af6fa 317
265898fd 318 SetUpDC();
bbbbe360
RR
319
320 /* this must be done after SetUpDC, bacause SetUpDC calls the
321 repective SetBrush, SetPen, SetBackground etc functions
322 to set up the DC. SetBackground call m_owner->SetBackground
323 and this might not be desired as the standard dc background
324 is white whereas a window might assume gray to be the
325 standard (as e.g. wxStatusBar) */
7d5af6fa 326
bbbbe360 327 m_owner = window;
903f689b 328}
c801d85f 329
4bc67cc5 330wxWindowDC::~wxWindowDC()
c801d85f 331{
265898fd 332 Destroy();
ab9d0a8c 333
cfcc3932 334 if (m_layout)
3fe39b0c 335 g_object_unref (m_layout);
cfcc3932
RR
336 if (m_fontdesc)
337 pango_font_description_free( m_fontdesc );
903f689b 338}
c801d85f 339
809934d2
RR
340void wxWindowDC::SetUpDC()
341{
ab9d0a8c 342 m_ok = true;
5f170f33 343
809934d2 344 wxASSERT_MSG( !m_penGC, wxT("GCs already created") );
5f170f33 345
f6bcfd97
BP
346 if (m_isScreenDC)
347 {
348 m_penGC = wxGetPoolGC( m_window, wxPEN_SCREEN );
349 m_brushGC = wxGetPoolGC( m_window, wxBRUSH_SCREEN );
350 m_textGC = wxGetPoolGC( m_window, wxTEXT_SCREEN );
351 m_bgGC = wxGetPoolGC( m_window, wxBG_SCREEN );
352 }
353 else
809934d2
RR
354 if (m_isMemDC && (((wxMemoryDC*)this)->m_selected.GetDepth() == 1))
355 {
356 m_penGC = wxGetPoolGC( m_window, wxPEN_MONO );
357 m_brushGC = wxGetPoolGC( m_window, wxBRUSH_MONO );
358 m_textGC = wxGetPoolGC( m_window, wxTEXT_MONO );
359 m_bgGC = wxGetPoolGC( m_window, wxBG_MONO );
360 }
361 else
362 {
363 m_penGC = wxGetPoolGC( m_window, wxPEN_COLOUR );
364 m_brushGC = wxGetPoolGC( m_window, wxBRUSH_COLOUR );
365 m_textGC = wxGetPoolGC( m_window, wxTEXT_COLOUR );
366 m_bgGC = wxGetPoolGC( m_window, wxBG_COLOUR );
367 }
368
369 /* background colour */
370 m_backgroundBrush = *wxWHITE_BRUSH;
371 m_backgroundBrush.GetColour().CalcPixel( m_cmap );
372 GdkColor *bg_col = m_backgroundBrush.GetColour().GetColor();
373
374 /* m_textGC */
375 m_textForegroundColour.CalcPixel( m_cmap );
376 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
377
378 m_textBackgroundColour.CalcPixel( m_cmap );
379 gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
380
381 gdk_gc_set_fill( m_textGC, GDK_SOLID );
382
383 /* m_penGC */
384 m_pen.GetColour().CalcPixel( m_cmap );
385 gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
386 gdk_gc_set_background( m_penGC, bg_col );
5f170f33 387
809934d2 388 gdk_gc_set_line_attributes( m_penGC, 0, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_ROUND );
5f170f33 389
809934d2
RR
390 /* m_brushGC */
391 m_brush.GetColour().CalcPixel( m_cmap );
392 gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
393 gdk_gc_set_background( m_brushGC, bg_col );
5f170f33 394
809934d2 395 gdk_gc_set_fill( m_brushGC, GDK_SOLID );
5f170f33 396
809934d2
RR
397 /* m_bgGC */
398 gdk_gc_set_background( m_bgGC, bg_col );
399 gdk_gc_set_foreground( m_bgGC, bg_col );
400
401 gdk_gc_set_fill( m_bgGC, GDK_SOLID );
5f170f33 402
809934d2
RR
403 /* ROPs */
404 gdk_gc_set_function( m_textGC, GDK_COPY );
405 gdk_gc_set_function( m_brushGC, GDK_COPY );
406 gdk_gc_set_function( m_penGC, GDK_COPY );
5f170f33 407
809934d2
RR
408 /* clipping */
409 gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
410 gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
411 gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
412 gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
413
414 if (!hatch_bitmap)
415 {
416 hatch_bitmap = hatches;
417 hatch_bitmap[0] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, bdiag_bits, bdiag_width, bdiag_height );
418 hatch_bitmap[1] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cdiag_bits, cdiag_width, cdiag_height );
419 hatch_bitmap[2] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, fdiag_bits, fdiag_width, fdiag_height );
420 hatch_bitmap[3] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cross_bits, cross_width, cross_height );
421 hatch_bitmap[4] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, horiz_bits, horiz_width, horiz_height );
422 hatch_bitmap[5] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, verti_bits, verti_width, verti_height );
423 }
424}
425
376aa62a
VZ
426void wxWindowDC::DoGetSize( int* width, int* height ) const
427{
428 wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
429
430 m_owner->GetSize(width, height);
431}
432
ab9d0a8c 433extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
06cf7c08 434 const wxColour & col, int style);
b1699cd3 435
387ebd3e 436bool wxWindowDC::DoFloodFill(wxCoord x, wxCoord y,
06cf7c08
VS
437 const wxColour& col, int style)
438{
387ebd3e 439 return wxDoFloodFill(this, x, y, col, style);
903f689b 440}
c801d85f 441
dc1efb1d 442bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
c801d85f 443{
dc1efb1d
JS
444 // Generic (and therefore rather inefficient) method.
445 // Could be improved.
446 wxMemoryDC memdc;
447 wxBitmap bitmap(1, 1);
448 memdc.SelectObject(bitmap);
449 memdc.Blit(0, 0, 1, 1, (wxDC*) this, x1, y1);
450 memdc.SelectObject(wxNullBitmap);
c2fa61e8 451
368d59f0 452 wxImage image = bitmap.ConvertToImage();
dc1efb1d 453 col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));
ab9d0a8c 454 return true;
903f689b 455}
c801d85f 456
72cdf4c9 457void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
c801d85f 458{
223d09f6 459 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 460
265898fd
RR
461 if (m_pen.GetStyle() != wxTRANSPARENT)
462 {
6db90681
RR
463 if (m_window)
464 gdk_draw_line( m_window, m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
7d5af6fa 465
ed880dd4
RR
466 CalcBoundingBox(x1, y1);
467 CalcBoundingBox(x2, y2);
265898fd 468 }
903f689b 469}
c801d85f 470
72cdf4c9 471void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
c801d85f 472{
223d09f6 473 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 474
265898fd
RR
475 if (m_pen.GetStyle() != wxTRANSPARENT)
476 {
477 int w = 0;
478 int h = 0;
479 GetSize( &w, &h );
72cdf4c9
VZ
480 wxCoord xx = XLOG2DEV(x);
481 wxCoord yy = YLOG2DEV(y);
6db90681 482 if (m_window)
7d5af6fa 483 {
6db90681
RR
484 gdk_draw_line( m_window, m_penGC, 0, yy, XLOG2DEVREL(w), yy );
485 gdk_draw_line( m_window, m_penGC, xx, 0, xx, YLOG2DEVREL(h) );
7d5af6fa 486 }
265898fd 487 }
903f689b 488}
c801d85f 489
72cdf4c9
VZ
490void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
491 wxCoord xc, wxCoord yc )
c801d85f 492{
223d09f6 493 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 494
72cdf4c9
VZ
495 wxCoord xx1 = XLOG2DEV(x1);
496 wxCoord yy1 = YLOG2DEV(y1);
497 wxCoord xx2 = XLOG2DEV(x2);
498 wxCoord yy2 = YLOG2DEV(y2);
499 wxCoord xxc = XLOG2DEV(xc);
500 wxCoord yyc = YLOG2DEV(yc);
7d5af6fa 501 double dx = xx1 - xxc;
265898fd 502 double dy = yy1 - yyc;
de87c353 503 double radius = sqrt((double)(dx*dx+dy*dy));
72cdf4c9 504 wxCoord r = (wxCoord)radius;
265898fd
RR
505 double radius1, radius2;
506
7d5af6fa 507 if (xx1 == xx2 && yy1 == yy2)
265898fd
RR
508 {
509 radius1 = 0.0;
510 radius2 = 360.0;
7d5af6fa 511 }
c77a6796 512 else if ( wxIsNullDouble(radius) )
265898fd 513 {
c77a6796
VZ
514 radius1 =
515 radius2 = 0.0;
7d5af6fa
VZ
516 }
517 else
265898fd
RR
518 {
519 radius1 = (xx1 - xxc == 0) ?
b0e0d661
VZ
520 (yy1 - yyc < 0) ? 90.0 : -90.0 :
521 -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
265898fd 522 radius2 = (xx2 - xxc == 0) ?
b0e0d661
VZ
523 (yy2 - yyc < 0) ? 90.0 : -90.0 :
524 -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
265898fd 525 }
72cdf4c9
VZ
526 wxCoord alpha1 = wxCoord(radius1 * 64.0);
527 wxCoord alpha2 = wxCoord((radius2 - radius1) * 64.0);
265898fd
RR
528 while (alpha2 <= 0) alpha2 += 360*64;
529 while (alpha1 > 360*64) alpha1 -= 360*64;
530
6db90681
RR
531 if (m_window)
532 {
533 if (m_brush.GetStyle() != wxTRANSPARENT)
e9f88d04
VZ
534 {
535 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
536 {
537 gdk_gc_set_ts_origin( m_textGC,
538 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
539 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
540 gdk_draw_arc( m_window, m_textGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
541 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
542 } else
3ca6a5f0
BP
543 if (IS_15_PIX_HATCH(m_brush.GetStyle()))
544 {
545 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
546 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
547 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
548 } else
549 if (IS_16_PIX_HATCH(m_brush.GetStyle()))
550 {
551 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
552 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
553 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
554 } else
e9f88d04
VZ
555 if (m_brush.GetStyle() == wxSTIPPLE)
556 {
557 gdk_gc_set_ts_origin( m_brushGC,
558 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
559 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
560 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
561 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
562 }
563 else
564 {
565 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
566 }
567 }
7d5af6fa 568
6db90681 569 if (m_pen.GetStyle() != wxTRANSPARENT)
3d0c4d2e 570 {
6db90681 571 gdk_draw_arc( m_window, m_penGC, FALSE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
f469b27c 572
3d0c4d2e
RR
573 gdk_draw_line( m_window, m_penGC, xx1, yy1, xxc, yyc );
574 gdk_draw_line( m_window, m_penGC, xxc, yyc, xx2, yy2 );
575 }
6db90681 576 }
7d5af6fa 577
265898fd
RR
578 CalcBoundingBox (x1, y1);
579 CalcBoundingBox (x2, y2);
903f689b 580}
c801d85f 581
72cdf4c9 582void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
c801d85f 583{
223d09f6 584 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 585
72cdf4c9
VZ
586 wxCoord xx = XLOG2DEV(x);
587 wxCoord yy = YLOG2DEV(y);
588 wxCoord ww = m_signX * XLOG2DEVREL(width);
589 wxCoord hh = m_signY * YLOG2DEVREL(height);
7d5af6fa 590
265898fd
RR
591 // CMB: handle -ve width and/or height
592 if (ww < 0) { ww = -ww; xx = xx - ww; }
593 if (hh < 0) { hh = -hh; yy = yy - hh; }
7d5af6fa 594
6db90681
RR
595 if (m_window)
596 {
72cdf4c9 597 wxCoord start = wxCoord(sa * 64.0);
3d0c4d2e 598 wxCoord end = wxCoord((ea-sa) * 64.0);
7d5af6fa 599
6db90681 600 if (m_brush.GetStyle() != wxTRANSPARENT)
e9f88d04
VZ
601 {
602 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
603 {
604 gdk_gc_set_ts_origin( m_textGC,
605 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
606 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
607 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy, ww, hh, start, end );
608 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
609 } else
3ca6a5f0
BP
610 if (IS_15_PIX_HATCH(m_brush.GetStyle()))
611 {
612 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
613 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
614 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
615 } else
616 if (IS_16_PIX_HATCH(m_brush.GetStyle()))
617 {
618 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
619 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
620 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
621 } else
e9f88d04
VZ
622 if (m_brush.GetStyle() == wxSTIPPLE)
623 {
624 gdk_gc_set_ts_origin( m_brushGC,
625 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
626 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
627 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
628 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
629 }
630 else
631 {
632 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
633 }
634 }
7d5af6fa 635
6db90681
RR
636 if (m_pen.GetStyle() != wxTRANSPARENT)
637 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, start, end );
638 }
7d5af6fa 639
265898fd
RR
640 CalcBoundingBox (x, y);
641 CalcBoundingBox (x + width, y + height);
903f689b 642}
c801d85f 643
72cdf4c9 644void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
c801d85f 645{
223d09f6 646 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 647
6db90681 648 if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
265898fd 649 gdk_draw_point( m_window, m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
7d5af6fa 650
265898fd 651 CalcBoundingBox (x, y);
903f689b 652}
c801d85f 653
72cdf4c9 654void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
c801d85f 655{
223d09f6 656 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 657
265898fd
RR
658 if (m_pen.GetStyle() == wxTRANSPARENT) return;
659 if (n <= 0) return;
7d5af6fa 660
e90411c2
JS
661 //Check, if scaling is necessary
662 bool doScale(true);
663 long val(10);
664 if (!xoffset)
665 if (!yoffset)
666 if (XLOG2DEV(val)==val)
667 if (YLOG2DEV(val)==val)
668 doScale = false;
669
670 GdkPoint *gpts = NULL;
671
672 if (doScale){
673 gpts = new GdkPoint[n];
6eb37239
VZ
674 if (! gpts)
675 {
676 wxFAIL_MSG( wxT("Cannot allocate PolyLine") );
677 return;
678 }
7d5af6fa 679
ab9d0a8c 680 for (int i = 0; i < n; i++)
265898fd 681 {
72cdf4c9 682 wxCoord x1 = XLOG2DEV(points[i].x + xoffset);
6eb37239 683 wxCoord y1 = YLOG2DEV(points[i].y + yoffset);
7d5af6fa 684
6eb37239 685 CalcBoundingBox( x1 + xoffset, y1 + yoffset );
7d5af6fa 686
6eb37239
VZ
687 gpts[i].x = x1;
688 gpts[i].y = y1;
265898fd 689 }
e90411c2
JS
690 }
691 else {
692 for (int i = 0; i < n; i++) {
693 CalcBoundingBox( points[i].x, points[i].y );
694 }
695
696 //GdkPoint and wxPoint have the same memory allignment, so we can cast one into another
697 gpts = reinterpret_cast<GdkPoint*>(points);
698 }
6eb37239
VZ
699
700 if (m_window)
701 gdk_draw_lines( m_window, m_penGC, gpts, n);
702
e90411c2 703 if (doScale)
6eb37239 704 delete[] gpts;
903f689b 705}
c801d85f 706
72cdf4c9 707void wxWindowDC::DoDrawPolygon( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset, int WXUNUSED(fillStyle) )
cf7a7e13 708{
223d09f6 709 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 710
4bc67cc5 711 if (n <= 0) return;
7d5af6fa 712
e90411c2
JS
713 //Check, if scaling is necessary
714 bool doScale(true);
715 long val(10);
716 if (!xoffset)
717 if (!yoffset)
718 if (XLOG2DEV(val)==val)
719 if (YLOG2DEV(val)==val){
720 doScale = false;
721 }
722
723 GdkPoint *gdkpoints = NULL;
724
725 if (doScale){
726 gdkpoints = new GdkPoint[n+1]; //FIXME: Why the "+1"
727
265898fd
RR
728 int i;
729 for (i = 0 ; i < n ; i++)
730 {
731 gdkpoints[i].x = XLOG2DEV(points[i].x + xoffset);
732 gdkpoints[i].y = YLOG2DEV(points[i].y + yoffset);
7d5af6fa 733
265898fd
RR
734 CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
735 }
e90411c2
JS
736 }
737 else {
738 int i(0);
739 for (; i < n ; ++i) {
740 CalcBoundingBox( points[i].x, points[i].y );
741 }
742 //GdkPoint and wxPoint have the same memory allignment, so we can cast one into another
743 gdkpoints = reinterpret_cast<GdkPoint*> (points);
744 }
7d5af6fa 745
de2d2cdc 746 if (m_window)
72174350 747 {
e90411c2
JS
748 //I think wxSOLID is the most often used style (it is for me),
749 //so I put it in front of the if ... ifelse's
750 if (m_brush.GetStyle() == wxSOLID)
751 {
752 gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
753 }else
e1208c31 754 if (m_brush.GetStyle() != wxTRANSPARENT)
72174350 755 {
e1208c31
RR
756 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
757 {
5f170f33
VZ
758 gdk_gc_set_ts_origin( m_textGC,
759 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
e1208c31
RR
760 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
761 gdk_draw_polygon( m_window, m_textGC, TRUE, gdkpoints, n );
762 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
763 } else
3ca6a5f0
BP
764 if (IS_15_PIX_HATCH(m_brush.GetStyle()))
765 {
766 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
767 gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
768 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
769 } else
770 if (IS_16_PIX_HATCH(m_brush.GetStyle()))
771 {
772 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
773 gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
774 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
775 } else
e1208c31
RR
776 if (m_brush.GetStyle() == wxSTIPPLE)
777 {
5f170f33
VZ
778 gdk_gc_set_ts_origin( m_brushGC,
779 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
e1208c31
RR
780 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
781 gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
782 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
783 }
784 else
785 {
786 gdk_draw_polygon( m_window, m_brushGC, TRUE, gdkpoints, n );
787 }
72174350 788 }
7d5af6fa 789
e1208c31 790 if (m_pen.GetStyle() != wxTRANSPARENT)
b0e0d661 791 {
bb56b0a8 792/*
e1208c31
RR
793 for (i = 0 ; i < n ; i++)
794 {
795 gdk_draw_line( m_window, m_penGC,
796 gdkpoints[i%n].x,
797 gdkpoints[i%n].y,
798 gdkpoints[(i+1)%n].x,
799 gdkpoints[(i+1)%n].y);
800 }
bb56b0a8
JS
801*/
802 gdk_draw_polygon( m_window, m_penGC, FALSE, gdkpoints, n );
ab9d0a8c 803
265898fd 804 }
6db90681 805 }
7d5af6fa 806
e90411c2 807 if (doScale)
265898fd 808 delete[] gdkpoints;
903f689b 809}
c801d85f 810
72cdf4c9 811void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
c801d85f 812{
223d09f6 813 wxCHECK_RET( Ok(), wxT("invalid window dc") );
c801d85f 814
72cdf4c9
VZ
815 wxCoord xx = XLOG2DEV(x);
816 wxCoord yy = YLOG2DEV(y);
817 wxCoord ww = m_signX * XLOG2DEVREL(width);
818 wxCoord hh = m_signY * YLOG2DEVREL(height);
7d5af6fa 819
265898fd
RR
820 // CMB: draw nothing if transformed w or h is 0
821 if (ww == 0 || hh == 0) return;
6f65e337 822
265898fd
RR
823 // CMB: handle -ve width and/or height
824 if (ww < 0) { ww = -ww; xx = xx - ww; }
825 if (hh < 0) { hh = -hh; yy = yy - hh; }
6f65e337 826
6db90681
RR
827 if (m_window)
828 {
e1208c31 829 if (m_brush.GetStyle() != wxTRANSPARENT)
72174350 830 {
e1208c31
RR
831 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
832 {
5f170f33
VZ
833 gdk_gc_set_ts_origin( m_textGC,
834 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
e1208c31
RR
835 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
836 gdk_draw_rectangle( m_window, m_textGC, TRUE, xx, yy, ww, hh );
837 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
3ca6a5f0
BP
838 } else
839 if (IS_15_PIX_HATCH(m_brush.GetStyle()))
840 {
841 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
842 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
843 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
844 } else
845 if (IS_16_PIX_HATCH(m_brush.GetStyle()))
846 {
847 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
848 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
849 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
850 } else
851 if (m_brush.GetStyle() == wxSTIPPLE)
e1208c31 852 {
5f170f33
VZ
853 gdk_gc_set_ts_origin( m_brushGC,
854 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
e1208c31 855 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
72174350 856 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
e1208c31
RR
857 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
858 }
859 else
860 {
861 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
862 }
72174350 863 }
e1208c31
RR
864
865 if (m_pen.GetStyle() != wxTRANSPARENT)
866 gdk_draw_rectangle( m_window, m_penGC, FALSE, xx, yy, ww-1, hh-1 );
6db90681 867 }
7d5af6fa 868
265898fd
RR
869 CalcBoundingBox( x, y );
870 CalcBoundingBox( x + width, y + height );
903f689b 871}
c801d85f 872
72cdf4c9 873void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
c801d85f 874{
223d09f6 875 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 876
265898fd 877 if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
7d5af6fa 878
72cdf4c9
VZ
879 wxCoord xx = XLOG2DEV(x);
880 wxCoord yy = YLOG2DEV(y);
881 wxCoord ww = m_signX * XLOG2DEVREL(width);
882 wxCoord hh = m_signY * YLOG2DEVREL(height);
883 wxCoord rr = XLOG2DEVREL((wxCoord)radius);
265898fd
RR
884
885 // CMB: handle -ve width and/or height
886 if (ww < 0) { ww = -ww; xx = xx - ww; }
887 if (hh < 0) { hh = -hh; yy = yy - hh; }
888
889 // CMB: if radius is zero use DrawRectangle() instead to avoid
890 // X drawing errors with small radii
891 if (rr == 0)
892 {
893 DrawRectangle( x, y, width, height );
894 return;
895 }
896
897 // CMB: draw nothing if transformed w or h is 0
898 if (ww == 0 || hh == 0) return;
899
900 // CMB: adjust size if outline is drawn otherwise the result is
901 // 1 pixel too wide and high
902 if (m_pen.GetStyle() != wxTRANSPARENT)
903 {
904 ww--;
905 hh--;
906 }
907
6db90681 908 if (m_window)
265898fd 909 {
6db90681
RR
910 // CMB: ensure dd is not larger than rectangle otherwise we
911 // get an hour glass shape
72cdf4c9 912 wxCoord dd = 2 * rr;
6db90681
RR
913 if (dd > ww) dd = ww;
914 if (dd > hh) dd = hh;
915 rr = dd / 2;
916
917 if (m_brush.GetStyle() != wxTRANSPARENT)
918 {
a56fcaaf
RR
919 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
920 {
5f170f33
VZ
921 gdk_gc_set_ts_origin( m_textGC,
922 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
a56fcaaf
RR
923 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
924 gdk_draw_rectangle( m_window, m_textGC, TRUE, xx+rr, yy, ww-dd+1, hh );
925 gdk_draw_rectangle( m_window, m_textGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
926 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
927 gdk_draw_arc( m_window, m_textGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
928 gdk_draw_arc( m_window, m_textGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
929 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
930 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
3ca6a5f0
BP
931 } else
932 if (IS_15_PIX_HATCH(m_brush.GetStyle()))
933 {
934 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
935 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
936 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
937 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
938 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
939 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
940 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
941 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
942 } else
943 if (IS_16_PIX_HATCH(m_brush.GetStyle()))
944 {
945 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
946 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
947 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
948 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
949 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
950 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
951 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
952 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
953 } else
954 if (m_brush.GetStyle() == wxSTIPPLE)
a56fcaaf 955 {
5f170f33
VZ
956 gdk_gc_set_ts_origin( m_brushGC,
957 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
a56fcaaf
RR
958 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
959 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
960 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
961 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
962 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
963 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
964 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
965 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
966 }
967 else
968 {
969 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
970 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
971 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
972 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
973 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
974 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
975 }
6db90681 976 }
7d5af6fa 977
6db90681 978 if (m_pen.GetStyle() != wxTRANSPARENT)
7d5af6fa 979 {
3ca6a5f0
BP
980 gdk_draw_line( m_window, m_penGC, xx+rr+1, yy, xx+ww-rr, yy );
981 gdk_draw_line( m_window, m_penGC, xx+rr+1, yy+hh, xx+ww-rr, yy+hh );
982 gdk_draw_line( m_window, m_penGC, xx, yy+rr+1, xx, yy+hh-rr );
983 gdk_draw_line( m_window, m_penGC, xx+ww, yy+rr+1, xx+ww, yy+hh-rr );
6db90681
RR
984 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, dd, dd, 90*64, 90*64 );
985 gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
986 gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
987 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
7d5af6fa 988 }
265898fd 989 }
7d5af6fa 990
265898fd
RR
991 // this ignores the radius
992 CalcBoundingBox( x, y );
993 CalcBoundingBox( x + width, y + height );
903f689b 994}
c801d85f 995
72cdf4c9 996void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
c801d85f 997{
223d09f6 998 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 999
72cdf4c9
VZ
1000 wxCoord xx = XLOG2DEV(x);
1001 wxCoord yy = YLOG2DEV(y);
1002 wxCoord ww = m_signX * XLOG2DEVREL(width);
1003 wxCoord hh = m_signY * YLOG2DEVREL(height);
6f65e337 1004
265898fd
RR
1005 // CMB: handle -ve width and/or height
1006 if (ww < 0) { ww = -ww; xx = xx - ww; }
1007 if (hh < 0) { hh = -hh; yy = yy - hh; }
7d5af6fa 1008
6db90681
RR
1009 if (m_window)
1010 {
1011 if (m_brush.GetStyle() != wxTRANSPARENT)
a56fcaaf
RR
1012 {
1013 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
1014 {
5f170f33
VZ
1015 gdk_gc_set_ts_origin( m_textGC,
1016 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
a56fcaaf
RR
1017 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
1018 gdk_draw_arc( m_window, m_textGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
1019 gdk_gc_set_ts_origin( m_textGC, 0, 0 );
3ca6a5f0
BP
1020 } else
1021 if (IS_15_PIX_HATCH(m_brush.GetStyle()))
1022 {
1023 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
1024 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
1025 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
1026 } else
1027 if (IS_16_PIX_HATCH(m_brush.GetStyle()))
1028 {
1029 gdk_gc_set_ts_origin( m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
1030 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
1031 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
1032 } else
1033 if (m_brush.GetStyle() == wxSTIPPLE)
a56fcaaf 1034 {
5f170f33
VZ
1035 gdk_gc_set_ts_origin( m_brushGC,
1036 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
a56fcaaf
RR
1037 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
1038 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
1039 gdk_gc_set_ts_origin( m_brushGC, 0, 0 );
1040 }
1041 else
1042 {
1043 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
1044 }
1045 }
7d5af6fa 1046
6db90681
RR
1047 if (m_pen.GetStyle() != wxTRANSPARENT)
1048 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, 0, 360*64 );
1049 }
7d5af6fa 1050
44856297 1051 CalcBoundingBox( x, y );
265898fd 1052 CalcBoundingBox( x + width, y + height );
903f689b 1053}
c801d85f 1054
72cdf4c9 1055void wxWindowDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
c801d85f 1056{
b0e0d661 1057 // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
ab9d0a8c 1058 DoDrawBitmap( (const wxBitmap&)icon, x, y, true );
903f689b 1059}
c801d85f 1060
b0e0d661 1061void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
72cdf4c9 1062 wxCoord x, wxCoord y,
b0e0d661 1063 bool useMask )
4bc67cc5 1064{
223d09f6 1065 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 1066
223d09f6 1067 wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
7d5af6fa 1068
cf214c35 1069 bool is_mono = (bitmap.GetBitmap() != NULL);
82ea63e6 1070
d90c9596 1071 // scale/translate size and position
265898fd
RR
1072 int xx = XLOG2DEV(x);
1073 int yy = YLOG2DEV(y);
7d5af6fa 1074
4bc67cc5
RR
1075 int w = bitmap.GetWidth();
1076 int h = bitmap.GetHeight();
7d5af6fa 1077
6453876e
RR
1078 CalcBoundingBox( x, y );
1079 CalcBoundingBox( x + w, y + h );
7d5af6fa 1080
6453876e 1081 if (!m_window) return;
7d5af6fa 1082
4bc67cc5
RR
1083 int ww = XLOG2DEVREL(w);
1084 int hh = YLOG2DEVREL(h);
7d5af6fa 1085
d90c9596 1086 // compare to current clipping region
e1208c31 1087 if (!m_currentClippingRegion.IsNull())
3d2d8da1
RR
1088 {
1089 wxRegion tmp( xx,yy,ww,hh );
1090 tmp.Intersect( m_currentClippingRegion );
1091 if (tmp.IsEmpty())
1092 return;
1093 }
5f170f33 1094
ab9d0a8c 1095 // scale bitmap if required
d90c9596 1096 wxBitmap use_bitmap = bitmap;
4bc67cc5 1097 if ((w != ww) || (h != hh))
d90c9596 1098 use_bitmap = use_bitmap.Rescale( 0, 0, ww, hh, ww, hh );
ab9d0a8c 1099
1abedc32
VS
1100#if !GTK_CHECK_VERSION(2,2,0)
1101 // NB: We can't render pixbufs with GTK+ < 2.2, we need to use pixmaps code.
1102 // Pixbufs-based bitmaps with alpha channel don't have a mask, so we
1103 // have to call GetPixmap() here -- it converts the pixbuf into pixmap
1104 // and also creates the mask as a side-effect:
1105 use_bitmap.GetPixmap();
1106#endif
ab9d0a8c 1107
d90c9596 1108 // apply mask if any
463c1fa1 1109 GdkBitmap *mask = (GdkBitmap *) NULL;
4bc67cc5 1110 if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
7d5af6fa 1111
d90c9596 1112 GdkBitmap *new_mask = (GdkBitmap*) NULL;
ab9d0a8c 1113
d90c9596
RR
1114 if (useMask && mask)
1115 {
1116 if (!m_currentClippingRegion.IsNull())
82ea63e6 1117 {
d90c9596
RR
1118 GdkColor col;
1119 new_mask = gdk_pixmap_new( wxGetRootWindow()->window, ww, hh, 1 );
1120 GdkGC *gc = gdk_gc_new( new_mask );
1121 col.pixel = 0;
1122 gdk_gc_set_foreground( gc, &col );
1123 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
1124 col.pixel = 0;
1125 gdk_gc_set_background( gc, &col );
1126 col.pixel = 1;
1127 gdk_gc_set_foreground( gc, &col );
1128 gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
1129 gdk_gc_set_clip_origin( gc, -xx, -yy );
1130 gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
1131 gdk_gc_set_stipple( gc, mask );
1132 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
3fe39b0c 1133 g_object_unref (gc);
d90c9596 1134 }
ab9d0a8c 1135
d90c9596
RR
1136 if (is_mono)
1137 {
1138 if (new_mask)
1139 gdk_gc_set_clip_mask( m_textGC, new_mask );
3d2d8da1 1140 else
d90c9596
RR
1141 gdk_gc_set_clip_mask( m_textGC, mask );
1142 gdk_gc_set_clip_origin( m_textGC, xx, yy );
1143 }
1144 else
1145 {
3d2d8da1 1146 if (new_mask)
d90c9596
RR
1147 gdk_gc_set_clip_mask( m_penGC, new_mask );
1148 else
1149 gdk_gc_set_clip_mask( m_penGC, mask );
1150 gdk_gc_set_clip_origin( m_penGC, xx, yy );
b0e0d661 1151 }
d90c9596 1152 }
7d5af6fa 1153
d90c9596
RR
1154 // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
1155 // drawing a mono-bitmap (XBitmap) we use the current text GC
82ea63e6 1156 if (is_mono)
d90c9596 1157 {
4e115ed2
VZ
1158 GdkPixmap *bitmap2 = gdk_pixmap_new( wxGetRootWindow()->window, ww, hh, -1 );
1159 GdkGC *gc = gdk_gc_new( bitmap2 );
d90c9596
RR
1160 gdk_gc_set_foreground( gc, m_textForegroundColour.GetColor() );
1161 gdk_gc_set_background( gc, m_textBackgroundColour.GetColor() );
4e115ed2 1162 gdk_wx_draw_bitmap( bitmap2, gc, use_bitmap.GetBitmap(), 0, 0, 0, 0, -1, -1 );
ab9d0a8c 1163
4e115ed2 1164 gdk_draw_drawable( m_window, m_textGC, bitmap2, 0, 0, xx, yy, -1, -1 );
ab9d0a8c 1165
3fe39b0c
MR
1166 g_object_unref (bitmap2);
1167 g_object_unref (gc);
d90c9596 1168 }
82ea63e6 1169 else
d90c9596 1170 {
feac7937 1171#if GTK_CHECK_VERSION(2,2,0)
cc35003a 1172 if (!gtk_check_version(2,2,0) && use_bitmap.HasPixbuf())
feac7937
VS
1173 {
1174 gdk_draw_pixbuf(m_window, m_penGC,
1175 use_bitmap.GetPixbuf(),
1176 0, 0, xx, yy, -1, -1,
1177 GDK_RGB_DITHER_NORMAL, xx, yy);
1178 }
1179 else
1180#endif
1181 {
15f0ad70
MR
1182 gdk_draw_drawable(m_window, m_penGC,
1183 use_bitmap.GetPixmap(),
1184 0, 0, xx, yy, -1, -1);
feac7937 1185 }
d90c9596 1186 }
72174350 1187
d90c9596 1188 // remove mask again if any
7d5af6fa 1189 if (useMask && mask)
463c1fa1 1190 {
82ea63e6
RR
1191 if (is_mono)
1192 {
1193 gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
1194 gdk_gc_set_clip_origin( m_textGC, 0, 0 );
e1208c31 1195 if (!m_currentClippingRegion.IsNull())
3d2d8da1 1196 gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
82ea63e6
RR
1197 }
1198 else
1199 {
1200 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
1201 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
e1208c31 1202 if (!m_currentClippingRegion.IsNull())
3d2d8da1 1203 gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
82ea63e6 1204 }
463c1fa1 1205 }
ab9d0a8c 1206
d90c9596 1207 if (new_mask)
3fe39b0c 1208 g_object_unref (new_mask);
463c1fa1
RR
1209}
1210
1e6feb95
VZ
1211bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest,
1212 wxCoord width, wxCoord height,
1213 wxDC *source,
1214 wxCoord xsrc, wxCoord ysrc,
1215 int logical_func,
0cbff120
JS
1216 bool useMask,
1217 wxCoord xsrcMask, wxCoord ysrcMask )
c801d85f 1218{
ab9d0a8c 1219 wxCHECK_MSG( Ok(), false, wxT("invalid window dc") );
7d5af6fa 1220
ab9d0a8c 1221 wxCHECK_MSG( source, false, wxT("invalid source dc") );
7d5af6fa 1222
ab9d0a8c 1223 if (!m_window) return false;
7d5af6fa 1224
1e6feb95 1225 // transform the source DC coords to the device ones
06201c35
RR
1226 xsrc = source->XLOG2DEV(xsrc);
1227 ysrc = source->YLOG2DEV(ysrc);
1e6feb95 1228
6e13c196
RR
1229 wxClientDC *srcDC = (wxClientDC*)source;
1230 wxMemoryDC *memDC = (wxMemoryDC*)source;
7d5af6fa 1231
ab9d0a8c
WS
1232 bool use_bitmap_method = false;
1233 bool is_mono = false;
7d5af6fa 1234
0cbff120
JS
1235 if (xsrcMask == -1 && ysrcMask == -1)
1236 {
d90c9596
RR
1237 xsrcMask = xsrc;
1238 ysrcMask = ysrc;
0cbff120
JS
1239 }
1240
6e13c196
RR
1241 if (srcDC->m_isMemDC)
1242 {
ab9d0a8c 1243 if (!memDC->m_selected.Ok()) return false;
7d5af6fa 1244
d90c9596
RR
1245 is_mono = (memDC->m_selected.GetDepth() == 1);
1246
1247 // we use the "XCopyArea" way to copy a memory dc into
1248 // a different window if the memory dc BOTH
1249 // a) doesn't have any mask or its mask isn't used
1250 // b) it is clipped
1251 // c) is not 1-bit
7d5af6fa 1252
f234c60c 1253 if (useMask && (memDC->m_selected.GetMask()))
b0e0d661 1254 {
d90c9596
RR
1255 // we HAVE TO use the direct way for memory dcs
1256 // that have mask since the XCopyArea doesn't know
1257 // about masks
ab9d0a8c 1258 use_bitmap_method = true;
b0e0d661 1259 }
d90c9596 1260 else if (is_mono)
b0e0d661 1261 {
d90c9596
RR
1262 // we HAVE TO use the direct way for memory dcs
1263 // that are bitmaps because XCopyArea doesn't cope
1264 // with different bit depths
ab9d0a8c 1265 use_bitmap_method = true;
b0e0d661
VZ
1266 }
1267 else if ((xsrc == 0) && (ysrc == 0) &&
1268 (width == memDC->m_selected.GetWidth()) &&
1269 (height == memDC->m_selected.GetHeight()))
1270 {
d90c9596
RR
1271 // we SHOULD use the direct way if all of the bitmap
1272 // in the memory dc is copied in which case XCopyArea
1273 // wouldn't be able able to boost performace by reducing
1274 // the area to be scaled
ab9d0a8c 1275 use_bitmap_method = true;
b0e0d661
VZ
1276 }
1277 else
1278 {
ab9d0a8c 1279 use_bitmap_method = false;
b0e0d661 1280 }
6e13c196 1281 }
7d5af6fa 1282
265898fd
RR
1283 CalcBoundingBox( xdest, ydest );
1284 CalcBoundingBox( xdest + width, ydest + height );
7d5af6fa 1285
d90c9596 1286 // scale/translate size and position
3d2d8da1
RR
1287 wxCoord xx = XLOG2DEV(xdest);
1288 wxCoord yy = YLOG2DEV(ydest);
1289
1290 wxCoord ww = XLOG2DEVREL(width);
1291 wxCoord hh = YLOG2DEVREL(height);
1292
d90c9596 1293 // compare to current clipping region
e1208c31 1294 if (!m_currentClippingRegion.IsNull())
3d2d8da1
RR
1295 {
1296 wxRegion tmp( xx,yy,ww,hh );
1297 tmp.Intersect( m_currentClippingRegion );
1298 if (tmp.IsEmpty())
ab9d0a8c 1299 return true;
3d2d8da1
RR
1300 }
1301
4bc67cc5
RR
1302 int old_logical_func = m_logicalFunction;
1303 SetLogicalFunction( logical_func );
5f170f33 1304
6e13c196 1305 if (use_bitmap_method)
6f65e337 1306 {
d90c9596 1307 // scale/translate bitmap size
72cdf4c9
VZ
1308 wxCoord bm_width = memDC->m_selected.GetWidth();
1309 wxCoord bm_height = memDC->m_selected.GetHeight();
7d5af6fa 1310
551b5391
RR
1311 // Get clip coords for the bitmap. If we don't
1312 // use wxBitmap::Rescale(), which can clip the
1313 // bitmap, these are the same as the original
1314 // coordinates
1315 wxCoord cx = xx;
1316 wxCoord cy = yy;
1317 wxCoord cw = ww;
1318 wxCoord ch = hh;
ab9d0a8c 1319
d90c9596
RR
1320 // interpret userscale of src too
1321 double xsc,ysc;
1322 memDC->GetUserScale(&xsc,&ysc);
1323 bm_width = (int) (bm_width / xsc);
1324 bm_height = (int) (bm_height / ysc);
1325
72cdf4c9
VZ
1326 wxCoord bm_ww = XLOG2DEVREL( bm_width );
1327 wxCoord bm_hh = YLOG2DEVREL( bm_height );
7d5af6fa 1328
551b5391 1329 // Scale bitmap if required
6e13c196 1330 wxBitmap use_bitmap;
f53df133 1331 if ((memDC->m_selected.GetWidth()!= bm_ww) || ( memDC->m_selected.GetHeight()!= bm_hh))
6e13c196 1332 {
551b5391
RR
1333 // This indicates that the blitting code below will get
1334 // a clipped bitmap and therefore needs to move the origin
1335 // accordingly
1336 wxRegion tmp( xx,yy,ww,hh );
1337 tmp.Intersect( m_currentClippingRegion );
1338 tmp.GetBox(cx,cy,cw,ch);
ab9d0a8c 1339
551b5391
RR
1340 // Scale and clipped bitmap
1341 use_bitmap = memDC->m_selected.Rescale(cx-xx,cy-yy,cw,ch,bm_ww,bm_hh);
6e13c196
RR
1342 }
1343 else
e23d0e95 1344 {
551b5391 1345 // Don't scale bitmap
6e13c196
RR
1346 use_bitmap = memDC->m_selected;
1347 }
7d5af6fa 1348
d90c9596 1349 // apply mask if any
6e13c196
RR
1350 GdkBitmap *mask = (GdkBitmap *) NULL;
1351 if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
7d5af6fa 1352
d90c9596 1353 GdkBitmap *new_mask = (GdkBitmap*) NULL;
ab9d0a8c 1354
7d5af6fa 1355 if (useMask && mask)
6e13c196 1356 {
e1208c31 1357 if (!m_currentClippingRegion.IsNull())
3d2d8da1
RR
1358 {
1359 GdkColor col;
c2fa61e8 1360 new_mask = gdk_pixmap_new( wxGetRootWindow()->window, bm_ww, bm_hh, 1 );
3d2d8da1
RR
1361 GdkGC *gc = gdk_gc_new( new_mask );
1362 col.pixel = 0;
1363 gdk_gc_set_foreground( gc, &col );
b7a49654 1364 gdk_gc_set_ts_origin( gc, -xsrcMask, -ysrcMask);
3d2d8da1
RR
1365 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
1366 col.pixel = 0;
1367 gdk_gc_set_background( gc, &col );
1368 col.pixel = 1;
1369 gdk_gc_set_foreground( gc, &col );
1370 gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
d90c9596
RR
1371 // was: gdk_gc_set_clip_origin( gc, -xx, -yy );
1372 gdk_gc_set_clip_origin( gc, -cx, -cy );
3d2d8da1
RR
1373 gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
1374 gdk_gc_set_stipple( gc, mask );
1375 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
3fe39b0c 1376 g_object_unref (gc);
3d2d8da1 1377 }
d90c9596 1378
82ea63e6
RR
1379 if (is_mono)
1380 {
3d2d8da1 1381 if (new_mask)
b7a49654 1382 {
3d2d8da1 1383 gdk_gc_set_clip_mask( m_textGC, new_mask );
b7a49654
RR
1384 gdk_gc_set_clip_origin( m_textGC, cx, cy );
1385 }
3d2d8da1 1386 else
b7a49654 1387 {
3d2d8da1 1388 gdk_gc_set_clip_mask( m_textGC, mask );
b7a49654 1389 gdk_gc_set_clip_origin( m_textGC, cx-xsrcMask, cy-ysrcMask );
0a164d4c 1390 }
82ea63e6
RR
1391 }
1392 else
6e13c196 1393 {
3d2d8da1 1394 if (new_mask)
b7a49654 1395 {
3d2d8da1 1396 gdk_gc_set_clip_mask( m_penGC, new_mask );
b7a49654
RR
1397 gdk_gc_set_clip_origin( m_penGC, cx, cy );
1398 }
3d2d8da1 1399 else
b7a49654 1400 {
3d2d8da1 1401 gdk_gc_set_clip_mask( m_penGC, mask );
b7a49654 1402 gdk_gc_set_clip_origin( m_penGC, cx-xsrcMask, cy-ysrcMask );
0a164d4c 1403 }
b0e0d661 1404 }
6e13c196 1405 }
7d5af6fa 1406
d90c9596
RR
1407 // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
1408 // drawing a mono-bitmap (XBitmap) we use the current text GC
5f170f33 1409
82ea63e6 1410 if (is_mono)
d90c9596 1411 {
d90c9596
RR
1412 GdkPixmap *bitmap = gdk_pixmap_new( wxGetRootWindow()->window, bm_ww, bm_hh, -1 );
1413 GdkGC *gc = gdk_gc_new( bitmap );
1414 gdk_gc_set_foreground( gc, m_textForegroundColour.GetColor() );
1415 gdk_gc_set_background( gc, m_textBackgroundColour.GetColor() );
1416 gdk_wx_draw_bitmap( bitmap, gc, use_bitmap.GetBitmap(), 0, 0, 0, 0, -1, -1 );
ab9d0a8c 1417
d90c9596 1418 gdk_draw_drawable( m_window, m_textGC, bitmap, xsrc, ysrc, cx, cy, cw, ch );
ab9d0a8c 1419
3fe39b0c
MR
1420 g_object_unref (bitmap);
1421 g_object_unref (gc);
d90c9596 1422 }
82ea63e6 1423 else
d90c9596 1424 {
15f0ad70
MR
1425 // was: gdk_draw_drawable( m_window, m_penGC, use_bitmap.GetPixmap(), xsrc, ysrc, xx, yy, ww, hh );
1426 gdk_draw_drawable( m_window, m_penGC, use_bitmap.GetPixmap(), xsrc, ysrc, cx, cy, cw, ch );
d90c9596 1427 }
82ea63e6 1428
d90c9596 1429 // remove mask again if any
7d5af6fa 1430 if (useMask && mask)
6e13c196 1431 {
82ea63e6
RR
1432 if (is_mono)
1433 {
1434 gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
1435 gdk_gc_set_clip_origin( m_textGC, 0, 0 );
e1208c31 1436 if (!m_currentClippingRegion.IsNull())
3d2d8da1 1437 gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
82ea63e6
RR
1438 }
1439 else
1440 {
1441 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
1442 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
e1208c31 1443 if (!m_currentClippingRegion.IsNull())
3d2d8da1 1444 gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
82ea63e6 1445 }
265898fd 1446 }
ab9d0a8c 1447
d90c9596 1448 if (new_mask)
3fe39b0c 1449 g_object_unref (new_mask);
6f65e337 1450 }
d90c9596 1451 else // use_bitmap_method
6e13c196 1452 {
bf9848e7 1453 if ((width != ww) || (height != hh))
b0e0d661 1454 {
d90c9596
RR
1455 // get clip coords
1456 wxRegion tmp( xx,yy,ww,hh );
1457 tmp.Intersect( m_currentClippingRegion );
1458 wxCoord cx,cy,cw,ch;
1459 tmp.GetBox(cx,cy,cw,ch);
ab9d0a8c
WS
1460
1461 // rescale bitmap
d90c9596 1462 wxBitmap bitmap = memDC->m_selected.Rescale( cx-xx, cy-yy, cw, ch, ww, hh );
7d5af6fa 1463
d90c9596 1464 // draw scaled bitmap
15f0ad70
MR
1465 // was: gdk_draw_drawable( m_window, m_penGC, bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
1466 gdk_draw_drawable( m_window, m_penGC, bitmap.GetPixmap(), 0, 0, cx, cy, -1, -1 );
b0e0d661
VZ
1467 }
1468 else
1469 {
ab9d0a8c 1470 // No scaling and not a memory dc with a mask either
993f97ee 1471
d90c9596 1472 // copy including child window contents
a56fcaaf 1473 gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
15f0ad70
MR
1474 gdk_draw_drawable( m_window, m_penGC,
1475 srcDC->GetWindow(),
1476 xsrc, ysrc, xx, yy,
1477 width, height );
a56fcaaf 1478 gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
b0e0d661 1479 }
6e13c196 1480 }
c801d85f 1481
4bc67cc5 1482 SetLogicalFunction( old_logical_func );
ab9d0a8c
WS
1483
1484 return true;
903f689b 1485}
c801d85f 1486
72cdf4c9 1487void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
c801d85f 1488{
223d09f6 1489 wxCHECK_RET( Ok(), wxT("invalid window dc") );
18a2fa37 1490
6db90681 1491 if (!m_window) return;
ab9d0a8c 1492
2b5f62a0 1493 if (text.empty()) return;
7d5af6fa 1494
265898fd
RR
1495 x = XLOG2DEV(x);
1496 y = YLOG2DEV(y);
18a2fa37 1497
cfcc3932 1498 wxCHECK_RET( m_context, wxT("no Pango context") );
61850501 1499 wxCHECK_RET( m_layout, wxT("no Pango layout") );
cfcc3932 1500 wxCHECK_RET( m_fontdesc, wxT("no Pango font description") );
e4da1035 1501
1dbeee57
VS
1502 bool underlined = m_font.Ok() && m_font.GetUnderlined();
1503
a3669332
VZ
1504 const wxCharBuffer data = wxGTK_CONV( text );
1505 if ( !data )
7706daf3 1506 return;
a3669332
VZ
1507 const size_t datalen = strlen(data);
1508 pango_layout_set_text( m_layout, data, datalen);
ab9d0a8c 1509
1dbeee57
VS
1510 if (underlined)
1511 {
1512 PangoAttrList *attrs = pango_attr_list_new();
1513 PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
1514 a->start_index = 0;
1515 a->end_index = datalen;
1516 pango_attr_list_insert(attrs, a);
1517 pango_layout_set_attributes(m_layout, attrs);
1518 pango_attr_list_unref(attrs);
1519 }
e4da1035 1520
76b20467 1521 int w,h;
fa499247
RR
1522
1523 if (fabs(m_scaleY - 1.0) > 0.00001)
e4da1035
RR
1524 {
1525 // If there is a user or actually any scale applied to
1526 // the device context, scale the font.
ab9d0a8c 1527
e4da1035
RR
1528 // scale font description
1529 gint oldSize = pango_font_description_get_size( m_fontdesc );
1530 double size = oldSize;
1531 size = size * m_scaleY;
1532 pango_font_description_set_size( m_fontdesc, (gint)size );
ab9d0a8c 1533
e4da1035
RR
1534 // actually apply scaled font
1535 pango_layout_set_font_description( m_layout, m_fontdesc );
ab9d0a8c 1536
76b20467
VS
1537 pango_layout_get_pixel_size( m_layout, &w, &h );
1538 if ( m_backgroundMode == wxSOLID )
1539 {
1540 gdk_gc_set_foreground(m_textGC, m_textBackgroundColour.GetColor());
1541 gdk_draw_rectangle(m_window, m_textGC, TRUE, x, y, w, h);
1542 gdk_gc_set_foreground(m_textGC, m_textForegroundColour.GetColor());
1543 }
ab9d0a8c 1544
e4da1035
RR
1545 // Draw layout.
1546 gdk_draw_layout( m_window, m_textGC, x, y, m_layout );
ab9d0a8c 1547
e4da1035
RR
1548 // reset unscaled size
1549 pango_font_description_set_size( m_fontdesc, oldSize );
ab9d0a8c 1550
61850501 1551 // actually apply unscaled font
e4da1035
RR
1552 pango_layout_set_font_description( m_layout, m_fontdesc );
1553 }
1554 else
1555 {
76b20467
VS
1556 pango_layout_get_pixel_size( m_layout, &w, &h );
1557 if ( m_backgroundMode == wxSOLID )
1558 {
1559 gdk_gc_set_foreground(m_textGC, m_textBackgroundColour.GetColor());
1560 gdk_draw_rectangle(m_window, m_textGC, TRUE, x, y, w, h);
1561 gdk_gc_set_foreground(m_textGC, m_textForegroundColour.GetColor());
1562 }
1563 // Draw layout.
1564 gdk_draw_layout( m_window, m_textGC, x, y, m_layout );
8943b403 1565 }
1dbeee57
VS
1566
1567 if (underlined)
1568 {
1569 // undo underline attributes setting:
1570 pango_layout_set_attributes(m_layout, NULL);
1571 }
ab9d0a8c 1572
2b5f62a0
VZ
1573 wxCoord width = w;
1574 wxCoord height = h;
ab9d0a8c 1575
8943b403
OK
1576 width = wxCoord(width / m_scaleX);
1577 height = wxCoord(height / m_scaleY);
1578 CalcBoundingBox (x + width, y + height);
265898fd 1579 CalcBoundingBox (x, y);
903f689b 1580}
c801d85f 1581
bf47e398
RD
1582
1583// TODO: There is an example of rotating text with GTK2 that would probably be
1584// a better approach here:
1585// http://www.daa.com.au/pipermail/pygtk/2003-April/005052.html
1586
95724b1a
VZ
1587void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
1588{
1c2d839f
PC
1589 if (!m_window || text.empty())
1590 return;
1591
1592 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1593
c77a6796 1594 if ( wxIsNullDouble(angle) )
95724b1a
VZ
1595 {
1596 DrawText(text, x, y);
1597 return;
1598 }
1599
bf47e398
RD
1600 wxCoord w;
1601 wxCoord h;
1602
68567a96 1603 // TODO: implement later without GdkFont for GTK 2.0
bf47e398 1604 GetTextExtent(text, &w, &h, NULL,NULL, &m_font);
ab9d0a8c 1605
9a8c7620
VZ
1606 // draw the string normally
1607 wxBitmap src(w, h);
95724b1a
VZ
1608 wxMemoryDC dc;
1609 dc.SelectObject(src);
1610 dc.SetFont(GetFont());
f1c72f0c 1611 dc.SetBackground(*wxBLACK_BRUSH);
95724b1a
VZ
1612 dc.SetBrush(*wxBLACK_BRUSH);
1613 dc.Clear();
f1c72f0c 1614 dc.SetTextForeground( *wxWHITE );
95724b1a 1615 dc.DrawText(text, 0, 0);
9a8c7620 1616 dc.SelectObject(wxNullBitmap);
95724b1a
VZ
1617
1618 // Calculate the size of the rotated bounding box.
9a8c7620
VZ
1619 double rad = DegToRad(angle);
1620 double dx = cos(rad),
1621 dy = sin(rad);
1622
1623 // the rectngle vertices are counted clockwise with the first one being at
1624 // (0, 0) (or, rather, at (x, y))
1625 double x2 = w*dx,
1626 y2 = -w*dy; // y axis points to the bottom, hence minus
1627 double x4 = h*dy,
1628 y4 = h*dx;
1629 double x3 = x4 + x2,
1630 y3 = y4 + y2;
ab9d0a8c 1631
72174350 1632 // calc max and min
9a8c7620
VZ
1633 wxCoord maxX = (wxCoord)(dmax(x2, dmax(x3, x4)) + 0.5),
1634 maxY = (wxCoord)(dmax(y2, dmax(y3, y4)) + 0.5),
1635 minX = (wxCoord)(dmin(x2, dmin(x3, x4)) - 0.5),
1636 minY = (wxCoord)(dmin(y2, dmin(y3, y4)) - 0.5);
1637
72174350 1638
f1c72f0c 1639 wxImage image = src.ConvertToImage();
9a8c7620 1640
f1c72f0c
RR
1641 image.ConvertColourToAlpha( m_textForegroundColour.Red(),
1642 m_textForegroundColour.Green(),
1643 m_textForegroundColour.Blue() );
1644 image = image.Rotate( rad, wxPoint(0,0) );
ab9d0a8c 1645
1d65e535
RR
1646 int i_angle = (int) angle;
1647 i_angle = i_angle % 360;
c2cb80c8
KH
1648 if (i_angle < 0)
1649 i_angle += 360;
1d65e535
RR
1650 int xoffset = 0;
1651 if ((i_angle >= 90.0) && (i_angle < 270.0))
1652 xoffset = image.GetWidth();
1653 int yoffset = 0;
1654 if ((i_angle >= 0.0) && (i_angle < 180.0))
1655 yoffset = image.GetHeight();
ab9d0a8c 1656
1d65e535
RR
1657 if ((i_angle >= 0) && (i_angle < 90))
1658 yoffset -= (int)( cos(rad)*h );
1659 if ((i_angle >= 90) && (i_angle < 180))
ab9d0a8c 1660 xoffset -= (int)( sin(rad)*h );
1d65e535
RR
1661 if ((i_angle >= 180) && (i_angle < 270))
1662 yoffset -= (int)( cos(rad)*h );
1663 if ((i_angle >= 270) && (i_angle < 360))
1664 xoffset -= (int)( sin(rad)*h );
ab9d0a8c 1665
1d65e535
RR
1666 int i_x = x - xoffset;
1667 int i_y = y - yoffset;
ab9d0a8c 1668
f1c72f0c 1669 src = image;
1d65e535 1670 DoDrawBitmap( src, i_x, i_y, true );
9a8c7620 1671
95724b1a 1672
9a8c7620
VZ
1673 // it would be better to draw with non underlined font and draw the line
1674 // manually here (it would be more straight...)
1675#if 0
1676 if ( m_font.GetUnderlined() )
1677 {
1678 gdk_draw_line( m_window, m_textGC,
1679 XLOG2DEV(x + x4), YLOG2DEV(y + y4 + font->descent),
1680 XLOG2DEV(x + x3), YLOG2DEV(y + y3 + font->descent));
1681 }
1682#endif // 0
1683
9a8c7620
VZ
1684 // update the bounding box
1685 CalcBoundingBox(x + minX, y + minY);
1686 CalcBoundingBox(x + maxX, y + maxY);
95724b1a
VZ
1687}
1688
72cdf4c9
VZ
1689void wxWindowDC::DoGetTextExtent(const wxString &string,
1690 wxCoord *width, wxCoord *height,
1691 wxCoord *descent, wxCoord *externalLeading,
1692 wxFont *theFont) const
c801d85f 1693{
b1f0abe4
VZ
1694 if ( width )
1695 *width = 0;
1696 if ( height )
1697 *height = 0;
1698 if ( descent )
1699 *descent = 0;
1700 if ( externalLeading )
1701 *externalLeading = 0;
1702
ab9d0a8c 1703 if (string.empty())
48d011c8 1704 return;
ab9d0a8c 1705
bf5752a4
VZ
1706 // ensure that theFont is always non-NULL
1707 if ( !theFont || !theFont->Ok() )
1708 theFont = wx_const_cast(wxFont *, &m_font);
1709
1710 // and use it if it's valid
1711 if ( theFont->Ok() )
1712 {
1713 pango_layout_set_font_description
1714 (
1715 m_layout,
1716 theFont->GetNativeFontInfo()->description
1717 );
1718 }
ab9d0a8c 1719
2b5f62a0 1720 // Set layout's text
bf5752a4 1721 const wxCharBuffer dataUTF8 = wxGTK_CONV_FONT(string, *theFont);
a1e101d0
VZ
1722 if ( !dataUTF8 )
1723 {
1724 // hardly ideal, but what else can we do if conversion failed?
1725 return;
1726 }
1727
1728 pango_layout_set_text( m_layout, dataUTF8, strlen(dataUTF8) );
ab9d0a8c 1729
48d011c8
RR
1730 if (descent)
1731 {
ace35c62
RR
1732 int h;
1733 pango_layout_get_pixel_size( m_layout, width, &h );
f69e2009
VS
1734 PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
1735 int baseline = pango_layout_iter_get_baseline(iter);
1736 pango_layout_iter_free(iter);
1737 *descent = h - PANGO_PIXELS(baseline);
ace35c62
RR
1738
1739 if (height)
1740 *height = (wxCoord) h;
1741 }
1742 else
1743 {
1744 pango_layout_get_pixel_size( m_layout, width, height );
48d011c8 1745 }
ab9d0a8c 1746
cfcc3932
RR
1747 // Reset old font description
1748 if (theFont)
1749 pango_layout_set_font_description( m_layout, m_fontdesc );
903f689b 1750}
c801d85f 1751
72cdf4c9 1752wxCoord wxWindowDC::GetCharWidth() const
c801d85f 1753{
cfcc3932 1754 pango_layout_set_text( m_layout, "H", 1 );
ace35c62
RR
1755 int w;
1756 pango_layout_get_pixel_size( m_layout, &w, NULL );
2b5f62a0 1757 return w;
903f689b 1758}
c801d85f 1759
72cdf4c9 1760wxCoord wxWindowDC::GetCharHeight() const
c801d85f 1761{
cfcc3932 1762 pango_layout_set_text( m_layout, "H", 1 );
ace35c62
RR
1763 int h;
1764 pango_layout_get_pixel_size( m_layout, NULL, &h );
2b5f62a0 1765 return h;
903f689b 1766}
c801d85f 1767
4bc67cc5 1768void wxWindowDC::Clear()
c801d85f 1769{
223d09f6 1770 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 1771
6db90681 1772 if (!m_window) return;
7d5af6fa 1773
f60e7fdd
VZ
1774 // VZ: the code below results in infinite recursion and crashes when
1775 // dc.Clear() is done from OnPaint() so I disable it for now.
1776 // I don't know what the correct fix is but Clear() surely should not
1777 // reenter OnPaint()!
1778#if 0
f234c60c
RR
1779 /* - we either are a memory dc or have a window as the
1780 owner. anything else shouldn't happen.
1781 - we don't use gdk_window_clear() as we don't set
1782 the window's background colour anymore. it is too
1783 much pain to keep the DC's and the window's back-
1784 ground colour in synch. */
7d5af6fa 1785
f234c60c 1786 if (m_owner)
265898fd 1787 {
f90566f5 1788 m_owner->Clear();
b0e0d661 1789 return;
265898fd 1790 }
f234c60c
RR
1791
1792 if (m_isMemDC)
265898fd
RR
1793 {
1794 int width,height;
1795 GetSize( &width, &height );
1796 gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
b0e0d661 1797 return;
265898fd 1798 }
f60e7fdd
VZ
1799#else // 1
1800 int width,height;
1801 GetSize( &width, &height );
1802 gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
1803#endif // 0/1
903f689b 1804}
c801d85f 1805
ec758a20 1806void wxWindowDC::SetFont( const wxFont &font )
c801d85f 1807{
265898fd 1808 m_font = font;
ab9d0a8c 1809
77416abd 1810 if (m_font.Ok())
2b5f62a0 1811 {
cfcc3932
RR
1812 if (m_fontdesc)
1813 pango_font_description_free( m_fontdesc );
ab9d0a8c 1814
cfcc3932 1815 m_fontdesc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
ab9d0a8c
WS
1816
1817
77416abd
JS
1818 if (m_owner)
1819 {
cfcc3932 1820 PangoContext *oldContext = m_context;
ab9d0a8c 1821
f26623c8 1822 m_context = m_owner->GtkGetPangoDefaultContext();
ab9d0a8c 1823
cfcc3932
RR
1824 // If we switch back/forth between different contexts
1825 // we also have to create a new layout. I think so,
ab9d0a8c 1826 // at least, and it doesn't hurt to do it.
cfcc3932
RR
1827 if (oldContext != m_context)
1828 {
1829 if (m_layout)
3fe39b0c 1830 g_object_unref (m_layout);
ab9d0a8c 1831
cfcc3932
RR
1832 m_layout = pango_layout_new( m_context );
1833 }
77416abd 1834 }
ab9d0a8c 1835
cfcc3932 1836 pango_layout_set_font_description( m_layout, m_fontdesc );
2b5f62a0 1837 }
903f689b 1838}
c801d85f 1839
ec758a20 1840void wxWindowDC::SetPen( const wxPen &pen )
c801d85f 1841{
223d09f6 1842 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 1843
265898fd 1844 if (m_pen == pen) return;
7d5af6fa 1845
265898fd 1846 m_pen = pen;
7d5af6fa 1847
265898fd 1848 if (!m_pen.Ok()) return;
7d5af6fa 1849
6db90681 1850 if (!m_window) return;
7d5af6fa 1851
265898fd 1852 gint width = m_pen.GetWidth();
265898fd
RR
1853 if (width <= 0)
1854 {
112c5086 1855 // CMB: if width is non-zero scale it with the dc
265898fd
RR
1856 width = 1;
1857 }
1858 else
1859 {
1860 // X doesn't allow different width in x and y and so we take
1861 // the average
503f414e
VZ
1862 double w = 0.5 +
1863 ( fabs((double) XLOG2DEVREL(width)) +
1864 fabs((double) YLOG2DEVREL(width)) ) / 2.0;
265898fd 1865 width = (int)w;
375fc5a9
VZ
1866 if ( !width )
1867 {
1868 // width can't be 0 or an internal GTK error occurs inside
1869 // gdk_gc_set_dashes() below
1870 width = 1;
1871 }
265898fd 1872 }
7d5af6fa 1873
2eca425d
RL
1874 static const wxGTKDash dotted[] = {1, 1};
1875 static const wxGTKDash short_dashed[] = {2, 2};
1876 static const wxGTKDash wxCoord_dashed[] = {2, 4};
1877 static const wxGTKDash dotted_dashed[] = {3, 3, 1, 3};
7d5af6fa 1878
112c5086
RR
1879 // We express dash pattern in pen width unit, so we are
1880 // independent of zoom factor and so on...
1881 int req_nb_dash;
2eca425d 1882 const wxGTKDash *req_dash;
7d5af6fa 1883
265898fd
RR
1884 GdkLineStyle lineStyle = GDK_LINE_SOLID;
1885 switch (m_pen.GetStyle())
1886 {
112c5086 1887 case wxUSER_DASH:
7d5af6fa
VZ
1888 {
1889 lineStyle = GDK_LINE_ON_OFF_DASH;
112c5086 1890 req_nb_dash = m_pen.GetDashCount();
2eca425d 1891 req_dash = (wxGTKDash*)m_pen.GetDash();
112c5086 1892 break;
7d5af6fa
VZ
1893 }
1894 case wxDOT:
1895 {
1896 lineStyle = GDK_LINE_ON_OFF_DASH;
112c5086
RR
1897 req_nb_dash = 2;
1898 req_dash = dotted;
7d5af6fa
VZ
1899 break;
1900 }
1901 case wxLONG_DASH:
1902 {
1903 lineStyle = GDK_LINE_ON_OFF_DASH;
112c5086 1904 req_nb_dash = 2;
72cdf4c9 1905 req_dash = wxCoord_dashed;
7d5af6fa
VZ
1906 break;
1907 }
1908 case wxSHORT_DASH:
1909 {
1910 lineStyle = GDK_LINE_ON_OFF_DASH;
112c5086
RR
1911 req_nb_dash = 2;
1912 req_dash = short_dashed;
7d5af6fa
VZ
1913 break;
1914 }
1915 case wxDOT_DASH:
1916 {
1917// lineStyle = GDK_LINE_DOUBLE_DASH;
1918 lineStyle = GDK_LINE_ON_OFF_DASH;
112c5086
RR
1919 req_nb_dash = 4;
1920 req_dash = dotted_dashed;
7d5af6fa
VZ
1921 break;
1922 }
1923
1924 case wxTRANSPARENT:
72174350 1925 case wxSTIPPLE_MASK_OPAQUE:
7d5af6fa
VZ
1926 case wxSTIPPLE:
1927 case wxSOLID:
1928 default:
1929 {
1930 lineStyle = GDK_LINE_SOLID;
2eca425d 1931 req_dash = (wxGTKDash*)NULL;
112c5086 1932 req_nb_dash = 0;
7d5af6fa
VZ
1933 break;
1934 }
265898fd 1935 }
7d5af6fa 1936
112c5086
RR
1937 if (req_dash && req_nb_dash)
1938 {
2eca425d 1939 wxGTKDash *real_req_dash = new wxGTKDash[req_nb_dash];
112c5086
RR
1940 if (real_req_dash)
1941 {
1942 for (int i = 0; i < req_nb_dash; i++)
1943 real_req_dash[i] = req_dash[i] * width;
2eca425d 1944 gdk_gc_set_dashes( m_penGC, 0, real_req_dash, req_nb_dash );
112c5086
RR
1945 delete[] real_req_dash;
1946 }
1947 else
1948 {
1949 // No Memory. We use non-scaled dash pattern...
2eca425d 1950 gdk_gc_set_dashes( m_penGC, 0, (wxGTKDash*)req_dash, req_nb_dash );
112c5086
RR
1951 }
1952 }
7d5af6fa 1953
265898fd
RR
1954 GdkCapStyle capStyle = GDK_CAP_ROUND;
1955 switch (m_pen.GetCap())
1956 {
265898fd
RR
1957 case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; }
1958 case wxCAP_BUTT: { capStyle = GDK_CAP_BUTT; break; }
d4aa3a4b
RR
1959 case wxCAP_ROUND:
1960 default:
72174350 1961 {
d4aa3a4b
RR
1962 if (width <= 1)
1963 {
1964 width = 0;
1965 capStyle = GDK_CAP_NOT_LAST;
1966 }
1967 else
1968 {
1969 capStyle = GDK_CAP_ROUND;
1970 }
72174350 1971 break;
d4aa3a4b 1972 }
265898fd 1973 }
7d5af6fa 1974
265898fd
RR
1975 GdkJoinStyle joinStyle = GDK_JOIN_ROUND;
1976 switch (m_pen.GetJoin())
1977 {
1978 case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; }
265898fd 1979 case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; }
d4aa3a4b
RR
1980 case wxJOIN_ROUND:
1981 default: { joinStyle = GDK_JOIN_ROUND; break; }
265898fd 1982 }
7d5af6fa 1983
265898fd 1984 gdk_gc_set_line_attributes( m_penGC, width, lineStyle, capStyle, joinStyle );
7d5af6fa 1985
265898fd
RR
1986 m_pen.GetColour().CalcPixel( m_cmap );
1987 gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
903f689b 1988}
c801d85f 1989
ec758a20 1990void wxWindowDC::SetBrush( const wxBrush &brush )
c801d85f 1991{
223d09f6 1992 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 1993
265898fd 1994 if (m_brush == brush) return;
7d5af6fa 1995
265898fd 1996 m_brush = brush;
7d5af6fa 1997
265898fd 1998 if (!m_brush.Ok()) return;
7d5af6fa 1999
6db90681 2000 if (!m_window) return;
7d5af6fa 2001
265898fd
RR
2002 m_brush.GetColour().CalcPixel( m_cmap );
2003 gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
7d5af6fa 2004
956dbab1 2005 gdk_gc_set_fill( m_brushGC, GDK_SOLID );
7d5af6fa 2006
4fcd73bd 2007 if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
265898fd 2008 {
4fcd73bd 2009 if (m_brush.GetStipple()->GetPixmap())
7d5af6fa 2010 {
956dbab1 2011 gdk_gc_set_fill( m_brushGC, GDK_TILED );
cd25b18c 2012 gdk_gc_set_tile( m_brushGC, m_brush.GetStipple()->GetPixmap() );
7d5af6fa 2013 }
b0e0d661 2014 else
7d5af6fa 2015 {
956dbab1 2016 gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
4fcd73bd 2017 gdk_gc_set_stipple( m_brushGC, m_brush.GetStipple()->GetBitmap() );
7d5af6fa 2018 }
265898fd 2019 }
7d5af6fa 2020
de2d2cdc
VZ
2021 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
2022 {
e1208c31
RR
2023 gdk_gc_set_fill( m_textGC, GDK_OPAQUE_STIPPLED);
2024 gdk_gc_set_stipple( m_textGC, m_brush.GetStipple()->GetMask()->GetBitmap() );
de2d2cdc
VZ
2025 }
2026
ab9d0a8c 2027 if (m_brush.IsHatch())
265898fd 2028 {
956dbab1 2029 gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
265898fd
RR
2030 int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
2031 gdk_gc_set_stipple( m_brushGC, hatches[num] );
2032 }
903f689b 2033}
c801d85f 2034
ec758a20 2035void wxWindowDC::SetBackground( const wxBrush &brush )
46dc76ba 2036{
bbbbe360
RR
2037 /* CMB 21/7/98: Added SetBackground. Sets background brush
2038 * for Clear() and bg colour for shapes filled with cross-hatch brush */
7d5af6fa 2039
223d09f6 2040 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 2041
265898fd 2042 if (m_backgroundBrush == brush) return;
7d5af6fa 2043
265898fd 2044 m_backgroundBrush = brush;
7d5af6fa 2045
265898fd 2046 if (!m_backgroundBrush.Ok()) return;
7d5af6fa 2047
6db90681 2048 if (!m_window) return;
7d5af6fa 2049
265898fd
RR
2050 m_backgroundBrush.GetColour().CalcPixel( m_cmap );
2051 gdk_gc_set_background( m_brushGC, m_backgroundBrush.GetColour().GetColor() );
a802c3a1 2052 gdk_gc_set_background( m_penGC, m_backgroundBrush.GetColour().GetColor() );
031b2a7b 2053 gdk_gc_set_background( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
265898fd 2054 gdk_gc_set_foreground( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
3417c2cd
RR
2055
2056 gdk_gc_set_fill( m_bgGC, GDK_SOLID );
7d5af6fa 2057
cd25b18c 2058 if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
265898fd 2059 {
fd128b0c 2060 if (m_backgroundBrush.GetStipple()->GetPixmap())
7d5af6fa 2061 {
3417c2cd 2062 gdk_gc_set_fill( m_bgGC, GDK_TILED );
fd128b0c 2063 gdk_gc_set_tile( m_bgGC, m_backgroundBrush.GetStipple()->GetPixmap() );
7d5af6fa 2064 }
cd25b18c 2065 else
7d5af6fa 2066 {
3417c2cd 2067 gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
fd128b0c 2068 gdk_gc_set_stipple( m_bgGC, m_backgroundBrush.GetStipple()->GetBitmap() );
7d5af6fa 2069 }
265898fd 2070 }
7d5af6fa 2071
ab9d0a8c 2072 if (m_backgroundBrush.IsHatch())
265898fd 2073 {
3417c2cd 2074 gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
265898fd
RR
2075 int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
2076 gdk_gc_set_stipple( m_bgGC, hatches[num] );
bbbbe360 2077 }
903f689b 2078}
46dc76ba 2079
ec758a20 2080void wxWindowDC::SetLogicalFunction( int function )
c801d85f 2081{
223d09f6 2082 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 2083
72174350
VZ
2084 if (m_logicalFunction == function)
2085 return;
2086
2087 // VZ: shouldn't this be a CHECK?
2088 if (!m_window)
2089 return;
01eaf507 2090
2b5f62a0 2091 GdkFunction mode;
265898fd
RR
2092 switch (function)
2093 {
3c679789
RR
2094 case wxXOR: mode = GDK_XOR; break;
2095 case wxINVERT: mode = GDK_INVERT; break;
3c679789
RR
2096 case wxOR_REVERSE: mode = GDK_OR_REVERSE; break;
2097 case wxAND_REVERSE: mode = GDK_AND_REVERSE; break;
2098 case wxCLEAR: mode = GDK_CLEAR; break;
2099 case wxSET: mode = GDK_SET; break;
2100 case wxOR_INVERT: mode = GDK_OR_INVERT; break;
2101 case wxAND: mode = GDK_AND; break;
2102 case wxOR: mode = GDK_OR; break;
2103 case wxEQUIV: mode = GDK_EQUIV; break;
2104 case wxNAND: mode = GDK_NAND; break;
2105 case wxAND_INVERT: mode = GDK_AND_INVERT; break;
7d5af6fa
VZ
2106 case wxCOPY: mode = GDK_COPY; break;
2107 case wxNO_OP: mode = GDK_NOOP; break;
2108 case wxSRC_INVERT: mode = GDK_COPY_INVERT; break;
72174350 2109
2d52841d
RR
2110 // unsupported by GTK
2111 case wxNOR: mode = GDK_COPY; break;
01eaf507 2112 default:
223d09f6 2113 wxFAIL_MSG( wxT("unsupported logical function") );
2b5f62a0 2114 mode = GDK_COPY;
265898fd 2115 }
7d5af6fa 2116
265898fd 2117 m_logicalFunction = function;
7d5af6fa 2118
265898fd
RR
2119 gdk_gc_set_function( m_penGC, mode );
2120 gdk_gc_set_function( m_brushGC, mode );
72174350
VZ
2121
2122 // to stay compatible with wxMSW, we don't apply ROPs to the text
3d2d8da1
RR
2123 // operations (i.e. DrawText/DrawRotatedText).
2124 // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
2125 gdk_gc_set_function( m_textGC, mode );
903f689b 2126}
c801d85f 2127
ec758a20 2128void wxWindowDC::SetTextForeground( const wxColour &col )
c801d85f 2129{
223d09f6 2130 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 2131
71ec83d2
VZ
2132 // don't set m_textForegroundColour to an invalid colour as we'd crash
2133 // later then (we use m_textForegroundColour.GetColor() without checking
2134 // in a few places)
2135 if ( !col.Ok() || (m_textForegroundColour == col) )
2136 return;
7d5af6fa 2137
265898fd 2138 m_textForegroundColour = col;
7d5af6fa 2139
71ec83d2
VZ
2140 if ( m_window )
2141 {
2142 m_textForegroundColour.CalcPixel( m_cmap );
2143 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
2144 }
903f689b 2145}
c801d85f 2146
ec758a20 2147void wxWindowDC::SetTextBackground( const wxColour &col )
c801d85f 2148{
223d09f6 2149 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 2150
71ec83d2
VZ
2151 // same as above
2152 if ( !col.Ok() || (m_textBackgroundColour == col) )
2153 return;
7d5af6fa 2154
265898fd 2155 m_textBackgroundColour = col;
7d5af6fa 2156
71ec83d2
VZ
2157 if ( m_window )
2158 {
2159 m_textBackgroundColour.CalcPixel( m_cmap );
2160 gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
2161 }
903f689b 2162}
c801d85f 2163
ec758a20 2164void wxWindowDC::SetBackgroundMode( int mode )
c801d85f 2165{
223d09f6 2166 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 2167
265898fd 2168 m_backgroundMode = mode;
46dc76ba 2169
6db90681 2170 if (!m_window) return;
7d5af6fa 2171
265898fd
RR
2172 // CMB 21/7/98: fill style of cross-hatch brushes is affected by
2173 // transparent/solid background mode
7d5af6fa 2174
265898fd
RR
2175 if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
2176 {
2177 gdk_gc_set_fill( m_brushGC,
2178 (m_backgroundMode == wxTRANSPARENT) ? GDK_STIPPLED : GDK_OPAQUE_STIPPLED);
2179 }
903f689b 2180}
c801d85f 2181
ec758a20 2182void wxWindowDC::SetPalette( const wxPalette& WXUNUSED(palette) )
c801d85f 2183{
223d09f6 2184 wxFAIL_MSG( wxT("wxWindowDC::SetPalette not implemented") );
903f689b 2185}
c801d85f 2186
72cdf4c9 2187void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
c801d85f 2188{
223d09f6 2189 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 2190
6db90681 2191 if (!m_window) return;
7d5af6fa 2192
3d2d8da1 2193 wxRect rect;
265898fd
RR
2194 rect.x = XLOG2DEV(x);
2195 rect.y = YLOG2DEV(y);
2196 rect.width = XLOG2DEVREL(width);
2197 rect.height = YLOG2DEVREL(height);
5f170f33 2198
e1208c31 2199 if (!m_currentClippingRegion.IsNull())
993f97ee
RR
2200 m_currentClippingRegion.Intersect( rect );
2201 else
2202 m_currentClippingRegion.Union( rect );
5f170f33
VZ
2203
2204#if USE_PAINT_REGION
e1208c31 2205 if (!m_paintClippingRegion.IsNull())
3d2d8da1 2206 m_currentClippingRegion.Intersect( m_paintClippingRegion );
809934d2 2207#endif
3d2d8da1 2208
ee8dbe63
RL
2209 wxCoord xx, yy, ww, hh;
2210 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
2211 wxDC::DoSetClippingRegion( xx, yy, ww, hh );
2212
3d2d8da1
RR
2213 gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
2214 gdk_gc_set_clip_region( m_brushGC, m_currentClippingRegion.GetRegion() );
2215 gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
2216 gdk_gc_set_clip_region( m_bgGC, m_currentClippingRegion.GetRegion() );
903f689b 2217}
c801d85f 2218
b0e0d661 2219void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion &region )
463c1fa1 2220{
223d09f6 2221 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 2222
463c1fa1
RR
2223 if (region.Empty())
2224 {
2225 DestroyClippingRegion();
2226 return;
2227 }
7d5af6fa 2228
6db90681 2229 if (!m_window) return;
5f170f33 2230
e1208c31 2231 if (!m_currentClippingRegion.IsNull())
993f97ee
RR
2232 m_currentClippingRegion.Intersect( region );
2233 else
2234 m_currentClippingRegion.Union( region );
5f170f33
VZ
2235
2236#if USE_PAINT_REGION
e1208c31 2237 if (!m_paintClippingRegion.IsNull())
3d2d8da1 2238 m_currentClippingRegion.Intersect( m_paintClippingRegion );
809934d2 2239#endif
3d2d8da1 2240
ee8dbe63
RL
2241 wxCoord xx, yy, ww, hh;
2242 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
2243 wxDC::DoSetClippingRegion( xx, yy, ww, hh );
2244
3d2d8da1
RR
2245 gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
2246 gdk_gc_set_clip_region( m_brushGC, m_currentClippingRegion.GetRegion() );
2247 gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
2248 gdk_gc_set_clip_region( m_bgGC, m_currentClippingRegion.GetRegion() );
463c1fa1
RR
2249}
2250
4bc67cc5 2251void wxWindowDC::DestroyClippingRegion()
c801d85f 2252{
223d09f6 2253 wxCHECK_RET( Ok(), wxT("invalid window dc") );
7d5af6fa 2254
265898fd 2255 wxDC::DestroyClippingRegion();
7d5af6fa 2256
3d2d8da1 2257 m_currentClippingRegion.Clear();
5f170f33
VZ
2258
2259#if USE_PAINT_REGION
3d2d8da1
RR
2260 if (!m_paintClippingRegion.IsEmpty())
2261 m_currentClippingRegion.Union( m_paintClippingRegion );
993f97ee 2262#endif
3d2d8da1 2263
6db90681 2264 if (!m_window) return;
7d5af6fa 2265
3d2d8da1
RR
2266 if (m_currentClippingRegion.IsEmpty())
2267 {
2268 gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
2269 gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
2270 gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
2271 gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
2272 }
2273 else
2274 {
2275 gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
2276 gdk_gc_set_clip_region( m_brushGC, m_currentClippingRegion.GetRegion() );
2277 gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
2278 gdk_gc_set_clip_region( m_bgGC, m_currentClippingRegion.GetRegion() );
2279 }
903f689b 2280}
c801d85f 2281
4bc67cc5 2282void wxWindowDC::Destroy()
dbf858b5 2283{
3d2d8da1 2284 if (m_penGC) wxFreePoolGC( m_penGC );
265898fd 2285 m_penGC = (GdkGC*) NULL;
3d2d8da1 2286 if (m_brushGC) wxFreePoolGC( m_brushGC );
265898fd 2287 m_brushGC = (GdkGC*) NULL;
3d2d8da1 2288 if (m_textGC) wxFreePoolGC( m_textGC );
265898fd 2289 m_textGC = (GdkGC*) NULL;
3d2d8da1 2290 if (m_bgGC) wxFreePoolGC( m_bgGC );
265898fd 2291 m_bgGC = (GdkGC*) NULL;
dbf858b5
RR
2292}
2293
238d735d
RR
2294void wxWindowDC::ComputeScaleAndOrigin()
2295{
c77a6796 2296 const wxRealPoint origScale(m_scaleX, m_scaleY);
238d735d
RR
2297
2298 wxDC::ComputeScaleAndOrigin();
2299
c77a6796
VZ
2300 // if scale has changed call SetPen to recalulate the line width
2301 if ( wxRealPoint(m_scaleX, m_scaleY) != origScale && m_pen.Ok() )
238d735d 2302 {
c77a6796
VZ
2303 // this is a bit artificial, but we need to force wxDC to think the pen
2304 // has changed
0a164d4c
WS
2305 wxPen pen = m_pen;
2306 m_pen = wxNullPen;
2307 SetPen( pen );
2308 }
238d735d
RR
2309}
2310
b0e0d661
VZ
2311// Resolution in pixels per logical inch
2312wxSize wxWindowDC::GetPPI() const
2313{
7a5e6267 2314 return wxSize( (int) (m_mm_to_pix_x * 25.4 + 0.5), (int) (m_mm_to_pix_y * 25.4 + 0.5));
b0e0d661
VZ
2315}
2316
2317int wxWindowDC::GetDepth() const
c801d85f 2318{
ace35c62 2319 return gdk_drawable_get_depth(m_window);
903f689b 2320}
c801d85f 2321
ec758a20
RR
2322
2323//-----------------------------------------------------------------------------
2324// wxPaintDC
2325//-----------------------------------------------------------------------------
2326
f469b27c 2327IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
ec758a20 2328
2cfddfe7
JS
2329// Limit the paint region to the window size. Sometimes
2330// the paint region is too big, and this risks X11 errors
2331static void wxLimitRegionToSize(wxRegion& region, const wxSize& sz)
2332{
2333 wxRect originalRect = region.GetBox();
2334 wxRect rect(originalRect);
2335 if (rect.width + rect.x > sz.x)
2336 rect.width = sz.x - rect.x;
2337 if (rect.height + rect.y > sz.y)
2338 rect.height = sz.y - rect.y;
2339 if (rect != originalRect)
2340 {
2341 region = wxRegion(rect);
2342 wxLogTrace(wxT("painting"), wxT("Limiting region from %d, %d, %d, %d to %d, %d, %d, %d\n"),
2343 originalRect.x, originalRect.y, originalRect.width, originalRect.height,
2344 rect.x, rect.y, rect.width, rect.height);
2345 }
2346}
2347
ec758a20 2348wxPaintDC::wxPaintDC( wxWindow *win )
f469b27c 2349 : wxClientDC( win )
ec758a20 2350{
b6fa52db
RR
2351#if USE_PAINT_REGION
2352 if (!win->m_clipPaintRegion)
2353 return;
f469b27c 2354
2cfddfe7 2355 wxSize sz = win->GetSize();
e1208c31 2356 m_paintClippingRegion = win->GetUpdateRegion();
2cfddfe7 2357 wxLimitRegionToSize(m_paintClippingRegion, sz);
ab9d0a8c 2358
5f170f33
VZ
2359 GdkRegion *region = m_paintClippingRegion.GetRegion();
2360 if ( region )
2361 {
823faac3 2362 m_currentClippingRegion.Union( m_paintClippingRegion );
2cfddfe7
JS
2363 wxLimitRegionToSize(m_currentClippingRegion, sz);
2364
2365 if (sz.x <= 0 || sz.y <= 0)
2366 return ;
5f170f33 2367
823faac3
JS
2368 gdk_gc_set_clip_region( m_penGC, region );
2369 gdk_gc_set_clip_region( m_brushGC, region );
2370 gdk_gc_set_clip_region( m_textGC, region );
2371 gdk_gc_set_clip_region( m_bgGC, region );
5f170f33 2372 }
1e6feb95 2373#endif // USE_PAINT_REGION
ec758a20
RR
2374}
2375
2376//-----------------------------------------------------------------------------
2377// wxClientDC
2378//-----------------------------------------------------------------------------
2379
f469b27c 2380IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
ec758a20 2381
f469b27c
VZ
2382wxClientDC::wxClientDC( wxWindow *win )
2383 : wxWindowDC( win )
ec758a20 2384{
4f55a07f
VZ
2385 wxCHECK_RET( win, _T("NULL window in wxClientDC::wxClientDC") );
2386
1e6feb95
VZ
2387#ifdef __WXUNIVERSAL__
2388 wxPoint ptOrigin = win->GetClientAreaOrigin();
2389 SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
2390 wxSize size = win->GetClientSize();
2391 SetClippingRegion(wxPoint(0, 0), size);
2392#endif // __WXUNIVERSAL__
ec758a20
RR
2393}
2394
4f55a07f
VZ
2395void wxClientDC::DoGetSize(int *width, int *height) const
2396{
2397 wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
2398
2399 m_owner->GetClientSize( width, height );
2400}
2401
3d2d8da1
RR
2402// ----------------------------------------------------------------------------
2403// wxDCModule
2404// ----------------------------------------------------------------------------
2405
2406class wxDCModule : public wxModule
2407{
2408public:
2409 bool OnInit();
2410 void OnExit();
2411
2412private:
2413 DECLARE_DYNAMIC_CLASS(wxDCModule)
2414};
2415
2416IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2417
2418bool wxDCModule::OnInit()
2419{
2420 wxInitGCPool();
ab9d0a8c 2421 return true;
3d2d8da1
RR
2422}
2423
2424void wxDCModule::OnExit()
2425{
2426 wxCleanUpGCPool();
2427}