]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/dcclient.cpp
added stubs for wxTreeCtrl functions not yet implemented under MSW
[wxWidgets.git] / src / gtk / dcclient.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: 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 <math.h>
18
19 //-----------------------------------------------------------------------------
20 // local data
21 //-----------------------------------------------------------------------------
22
23 #include "bdiag.xbm"
24 #include "fdiag.xbm"
25 #include "cdiag.xbm"
26 #include "horiz.xbm"
27 #include "verti.xbm"
28 #include "cross.xbm"
29 #define num_hatches 6
30
31 static GdkPixmap *hatches[num_hatches];
32 static GdkPixmap **hatch_bitmap = (GdkPixmap **) NULL;
33
34 //-----------------------------------------------------------------------------
35 // constants
36 //-----------------------------------------------------------------------------
37
38 #define RAD2DEG 57.2957795131
39
40 //-----------------------------------------------------------------------------
41 // temporary implementation of the missing GDK function
42 //-----------------------------------------------------------------------------
43 #include "gdk/gdkprivate.h"
44 void gdk_draw_bitmap (GdkDrawable *drawable,
45 GdkGC *gc,
46 GdkDrawable *src,
47 gint xsrc,
48 gint ysrc,
49 gint xdest,
50 gint ydest,
51 gint width,
52 gint height)
53 {
54 GdkWindowPrivate *drawable_private;
55 GdkWindowPrivate *src_private;
56 GdkGCPrivate *gc_private;
57
58 g_return_if_fail (drawable != NULL);
59 g_return_if_fail (src != NULL);
60 g_return_if_fail (gc != NULL);
61
62 drawable_private = (GdkWindowPrivate*) drawable;
63 src_private = (GdkWindowPrivate*) src;
64 if (drawable_private->destroyed || src_private->destroyed)
65 return;
66
67 gc_private = (GdkGCPrivate*) gc;
68
69 if (width == -1) width = src_private->width;
70 if (height == -1) height = src_private->height;
71
72 XCopyPlane( drawable_private->xdisplay,
73 src_private->xwindow,
74 drawable_private->xwindow,
75 gc_private->xgc,
76 xsrc, ysrc,
77 width, height,
78 xdest, ydest,
79 1 );
80 }
81
82 //-----------------------------------------------------------------------------
83 // wxWindowDC
84 //-----------------------------------------------------------------------------
85
86 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC,wxDC)
87
88 wxWindowDC::wxWindowDC()
89 {
90 m_penGC = (GdkGC *) NULL;
91 m_brushGC = (GdkGC *) NULL;
92 m_textGC = (GdkGC *) NULL;
93 m_bgGC = (GdkGC *) NULL;
94 m_cmap = (GdkColormap *) NULL;
95 m_isMemDC = FALSE;
96 }
97
98 wxWindowDC::wxWindowDC( wxWindow *window )
99 {
100 m_penGC = (GdkGC *) NULL;
101 m_brushGC = (GdkGC *) NULL;
102 m_textGC = (GdkGC *) NULL;
103 m_bgGC = (GdkGC *) NULL;
104 m_cmap = (GdkColormap *) NULL;
105
106 if (!window) return;
107 GtkWidget *widget = window->m_wxwindow;
108 if (!widget) return;
109 m_window = widget->window;
110 if (!m_window) return;
111 if (window->m_wxwindow)
112 m_cmap = gtk_widget_get_colormap( window->m_wxwindow );
113 else
114 m_cmap = gtk_widget_get_colormap( window->m_widget );
115
116 m_isMemDC = FALSE;
117
118 SetUpDC();
119
120 }
121
122 wxWindowDC::~wxWindowDC()
123 {
124 Destroy();
125 }
126
127 void wxWindowDC::FloodFill( long WXUNUSED(x), long WXUNUSED(y),
128 const wxColour &WXUNUSED(col), int WXUNUSED(style) )
129 {
130 wxFAIL_MSG( "wxWindowDC::FloodFill not implemented" );
131 }
132
133 bool wxWindowDC::GetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const
134 {
135 wxFAIL_MSG( "wxWindowDC::GetPixel not implemented" );
136 return FALSE;
137 }
138
139 void wxWindowDC::DrawLine( long x1, long y1, long x2, long y2 )
140 {
141 wxCHECK_RET( Ok(), "invalid window dc" );
142
143 if (m_pen.GetStyle() != wxTRANSPARENT)
144 {
145 gdk_draw_line( m_window, m_penGC,
146 XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
147
148 CalcBoundingBox(x1, y1);
149 CalcBoundingBox(x2, y2);
150 }
151 }
152
153 void wxWindowDC::CrossHair( long x, long y )
154 {
155 wxCHECK_RET( Ok(), "invalid window dc" );
156
157 if (m_pen.GetStyle() != wxTRANSPARENT)
158 {
159 int w = 0;
160 int h = 0;
161 GetSize( &w, &h );
162 long xx = XLOG2DEV(x);
163 long yy = YLOG2DEV(y);
164 gdk_draw_line( m_window, m_penGC, 0, yy, XLOG2DEVREL(w), yy );
165 gdk_draw_line( m_window, m_penGC, xx, 0, xx, YLOG2DEVREL(h) );
166 }
167 }
168
169 void wxWindowDC::DrawArc( long x1, long y1, long x2, long y2, double xc, double yc )
170 {
171 wxCHECK_RET( Ok(), "invalid window dc" );
172
173 long xx1 = XLOG2DEV(x1);
174 long yy1 = YLOG2DEV(y1);
175 long xx2 = XLOG2DEV(x2);
176 long yy2 = YLOG2DEV(y2);
177 long xxc = XLOG2DEV((long)xc);
178 long yyc = YLOG2DEV((long)yc);
179 double dx = xx1 - xxc;
180 double dy = yy1 - yyc;
181 double radius = sqrt(dx*dx+dy*dy);
182 long r = (long)radius;
183 double radius1, radius2;
184
185 if (xx1 == xx2 && yy1 == yy2)
186 {
187 radius1 = 0.0;
188 radius2 = 360.0;
189 }
190 else
191 if (radius == 0.0)
192 {
193 radius1 = radius2 = 0.0;
194 }
195 else
196 {
197 radius1 = (xx1 - xxc == 0) ?
198 (yy1 - yyc < 0) ? 90.0 : -90.0 :
199 -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
200 radius2 = (xx2 - xxc == 0) ?
201 (yy2 - yyc < 0) ? 90.0 : -90.0 :
202 -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
203 }
204 long alpha1 = long(radius1 * 64.0);
205 long alpha2 = long((radius2 - radius1) * 64.0);
206 while (alpha2 <= 0) alpha2 += 360*64;
207 while (alpha1 > 360*64) alpha1 -= 360*64;
208
209 if (m_brush.GetStyle() != wxTRANSPARENT)
210 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
211
212 if (m_pen.GetStyle() != wxTRANSPARENT)
213 gdk_draw_arc( m_window, m_penGC, FALSE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
214
215 CalcBoundingBox (x1, y1);
216 CalcBoundingBox (x2, y2);
217 }
218
219 void wxWindowDC::DrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
220 {
221 wxCHECK_RET( Ok(), "invalid window dc" );
222
223 long xx = XLOG2DEV(x);
224 long yy = YLOG2DEV(y);
225 long ww = m_signX * XLOG2DEVREL(width);
226 long hh = m_signY * YLOG2DEVREL(height);
227
228 // CMB: handle -ve width and/or height
229 if (ww < 0) { ww = -ww; xx = xx - ww; }
230 if (hh < 0) { hh = -hh; yy = yy - hh; }
231
232 long start = long(sa * 64.0);
233 long end = long(ea * 64.0);
234 if (m_brush.GetStyle() != wxTRANSPARENT)
235 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
236
237 if (m_pen.GetStyle() != wxTRANSPARENT)
238 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, start, end );
239
240 CalcBoundingBox (x, y);
241 CalcBoundingBox (x + width, y + height);
242 }
243
244 void wxWindowDC::DrawPoint( long x, long y )
245 {
246 wxCHECK_RET( Ok(), "invalid window dc" );
247
248 if (m_pen.GetStyle() != wxTRANSPARENT)
249 gdk_draw_point( m_window, m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
250
251 CalcBoundingBox (x, y);
252 }
253
254 void wxWindowDC::DrawLines( int n, wxPoint points[], long xoffset, long yoffset )
255 {
256 wxCHECK_RET( Ok(), "invalid window dc" );
257
258 if (m_pen.GetStyle() == wxTRANSPARENT) return;
259 if (n <= 0) return;
260
261 CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
262
263 for (int i = 0; i < n-1; i++)
264 {
265 long x1 = XLOG2DEV(points[i].x + xoffset);
266 long x2 = XLOG2DEV(points[i+1].x + xoffset);
267 long y1 = YLOG2DEV(points[i].y + yoffset); // oh, what a waste
268 long y2 = YLOG2DEV(points[i+1].y + yoffset);
269 gdk_draw_line( m_window, m_penGC, x1, y1, x2, y2 );
270
271 CalcBoundingBox( points[i+1].x + xoffset, points[i+1].y + yoffset );
272 }
273 }
274
275 void wxWindowDC::DrawLines( wxList *points, long xoffset, long yoffset )
276 {
277 wxCHECK_RET( Ok(), "invalid window dc" );
278
279 if (m_pen.GetStyle() == wxTRANSPARENT) return;
280
281 wxNode *node = points->First();
282 if (!node) return;
283
284 wxPoint *pt = (wxPoint*)node->Data();
285 CalcBoundingBox( pt->x + xoffset, pt->y + yoffset );
286
287 while (node->Next())
288 {
289 wxPoint *point = (wxPoint*)node->Data();
290 wxPoint *npoint = (wxPoint*)node->Next()->Data();
291 long x1 = XLOG2DEV(point->x + xoffset);
292 long x2 = XLOG2DEV(npoint->x + xoffset);
293 long y1 = YLOG2DEV(point->y + yoffset); // and a waste again...
294 long y2 = YLOG2DEV(npoint->y + yoffset);
295 gdk_draw_line( m_window, m_penGC, x1, y1, x2, y2 );
296 node = node->Next();
297
298 CalcBoundingBox( npoint->x + xoffset, npoint->y + yoffset );
299 }
300 }
301
302 void wxWindowDC::DrawPolygon( int n, wxPoint points[], long xoffset, long yoffset, int WXUNUSED(fillStyle) )
303 {
304 wxCHECK_RET( Ok(), "invalid window dc" );
305
306 if (n <= 0) return;
307
308 GdkPoint *gdkpoints = new GdkPoint[n+1];
309 int i;
310 for (i = 0 ; i < n ; i++)
311 {
312 gdkpoints[i].x = XLOG2DEV(points[i].x + xoffset);
313 gdkpoints[i].y = YLOG2DEV(points[i].y + yoffset);
314
315 CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
316 }
317
318 if (m_brush.GetStyle() != wxTRANSPARENT)
319 gdk_draw_polygon (m_window, m_brushGC, TRUE, gdkpoints, n);
320
321 // To do: Fillstyle
322
323 if (m_pen.GetStyle() != wxTRANSPARENT)
324 for (i = 0 ; i < n ; i++)
325 {
326 gdk_draw_line( m_window, m_penGC,
327 gdkpoints[i%n].x,
328 gdkpoints[i%n].y,
329 gdkpoints[(i+1)%n].x,
330 gdkpoints[(i+1)%n].y);
331 }
332
333 delete[] gdkpoints;
334 }
335
336 void wxWindowDC::DrawPolygon( wxList *lines, long xoffset, long yoffset, int WXUNUSED(fillStyle))
337 {
338 wxCHECK_RET( Ok(), "invalid window dc" );
339
340 int n = lines->Number();
341 if (n <= 0) return;
342
343 GdkPoint *gdkpoints = new GdkPoint[n];
344 wxNode *node = lines->First();
345 int cnt = 0;
346 while (node)
347 {
348 wxPoint *p = (wxPoint *) node->Data();
349 gdkpoints[cnt].x = XLOG2DEV(p->x + xoffset);
350 gdkpoints[cnt].y = YLOG2DEV(p->y + yoffset);
351 node = node->Next();
352 cnt++;
353
354 CalcBoundingBox( p->x + xoffset, p->y + yoffset );
355 }
356
357 if (m_brush.GetStyle() != wxTRANSPARENT)
358 gdk_draw_polygon (m_window, m_brushGC, TRUE, gdkpoints, n);
359
360 // To do: Fillstyle
361
362 if (m_pen.GetStyle() != wxTRANSPARENT)
363 {
364 int i;
365 for (i = 0 ; i < n ; i++)
366 {
367 gdk_draw_line( m_window, m_penGC,
368 gdkpoints[i%n].x,
369 gdkpoints[i%n].y,
370 gdkpoints[(i+1)%n].x,
371 gdkpoints[(i+1)%n].y );
372 }
373 }
374 delete[] gdkpoints;
375 }
376
377 void wxWindowDC::DrawRectangle( long x, long y, long width, long height )
378 {
379 wxCHECK_RET( Ok(), "invalid window dc" );
380
381 long xx = XLOG2DEV(x);
382 long yy = YLOG2DEV(y);
383 long ww = m_signX * XLOG2DEVREL(width);
384 long hh = m_signY * YLOG2DEVREL(height);
385
386 // CMB: draw nothing if transformed w or h is 0
387 if (ww == 0 || hh == 0) return;
388
389 // CMB: handle -ve width and/or height
390 if (ww < 0) { ww = -ww; xx = xx - ww; }
391 if (hh < 0) { hh = -hh; yy = yy - hh; }
392
393 if (m_brush.GetStyle() != wxTRANSPARENT)
394 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
395
396 if (m_pen.GetStyle() != wxTRANSPARENT)
397 gdk_draw_rectangle( m_window, m_penGC, FALSE, xx, yy, ww-1, hh-1 );
398
399 CalcBoundingBox( x, y );
400 CalcBoundingBox( x + width, y + height );
401 }
402
403 void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height, double radius )
404 {
405 wxCHECK_RET( Ok(), "invalid window dc" );
406
407 if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
408
409 long xx = XLOG2DEV(x);
410 long yy = YLOG2DEV(y);
411 long ww = m_signX * XLOG2DEVREL(width);
412 long hh = m_signY * YLOG2DEVREL(height);
413 long rr = XLOG2DEVREL((long)radius);
414
415 // CMB: handle -ve width and/or height
416 if (ww < 0) { ww = -ww; xx = xx - ww; }
417 if (hh < 0) { hh = -hh; yy = yy - hh; }
418
419 // CMB: if radius is zero use DrawRectangle() instead to avoid
420 // X drawing errors with small radii
421 if (rr == 0)
422 {
423 DrawRectangle( x, y, width, height );
424 return;
425 }
426
427 // CMB: draw nothing if transformed w or h is 0
428 if (ww == 0 || hh == 0) return;
429
430 // CMB: adjust size if outline is drawn otherwise the result is
431 // 1 pixel too wide and high
432 if (m_pen.GetStyle() != wxTRANSPARENT)
433 {
434 ww--;
435 hh--;
436 }
437
438 // CMB: ensure dd is not larger than rectangle otherwise we
439 // get an hour glass shape
440 long dd = 2 * rr;
441 if (dd > ww) dd = ww;
442 if (dd > hh) dd = hh;
443 rr = dd / 2;
444
445 if (m_brush.GetStyle() != wxTRANSPARENT)
446 {
447 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
448 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
449 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
450 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
451 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
452 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
453 }
454
455 if (m_pen.GetStyle() != wxTRANSPARENT)
456 {
457 gdk_draw_line( m_window, m_penGC, xx+rr, yy, xx+ww-rr, yy );
458 gdk_draw_line( m_window, m_penGC, xx+rr, yy+hh, xx+ww-rr, yy+hh );
459 gdk_draw_line( m_window, m_penGC, xx, yy+rr, xx, yy+hh-rr );
460 gdk_draw_line( m_window, m_penGC, xx+ww, yy+rr, xx+ww, yy+hh-rr );
461 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, dd, dd, 90*64, 90*64 );
462 gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
463 gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
464 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
465 }
466
467 // this ignores the radius
468 CalcBoundingBox( x, y );
469 CalcBoundingBox( x + width, y + height );
470 }
471
472 void wxWindowDC::DrawEllipse( long x, long y, long width, long height )
473 {
474 wxCHECK_RET( Ok(), "invalid window dc" );
475
476 long xx = XLOG2DEV(x);
477 long yy = YLOG2DEV(y);
478 long ww = m_signX * XLOG2DEVREL(width);
479 long hh = m_signY * YLOG2DEVREL(height);
480
481 // CMB: handle -ve width and/or height
482 if (ww < 0) { ww = -ww; xx = xx - ww; }
483 if (hh < 0) { hh = -hh; yy = yy - hh; }
484
485 if (m_brush.GetStyle() != wxTRANSPARENT)
486 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
487
488 if (m_pen.GetStyle() != wxTRANSPARENT)
489 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, 0, 360*64 );
490
491 CalcBoundingBox( x - width, y - height );
492 CalcBoundingBox( x + width, y + height );
493 }
494
495 bool wxWindowDC::CanDrawBitmap() const
496 {
497 return TRUE;
498 }
499
500 void wxWindowDC::DrawIcon( const wxIcon &icon, long x, long y )
501 {
502 DrawBitmap( icon, x, y, TRUE );
503 }
504
505 void wxWindowDC::DrawBitmap( const wxBitmap &bitmap, long x, long y, bool useMask )
506 {
507 wxCHECK_RET( Ok(), "invalid window dc" );
508
509 if (!bitmap.Ok()) return;
510
511 int xx = XLOG2DEV(x);
512 int yy = YLOG2DEV(y);
513
514 int w = bitmap.GetWidth();
515 int h = bitmap.GetHeight();
516
517 int ww = XLOG2DEVREL(w);
518 int hh = YLOG2DEVREL(h);
519
520 wxBitmap use_bitmap;
521
522 if ((w != ww) || (h != hh))
523 {
524 wxImage image( bitmap );
525 image = image.Scale( ww, hh );
526
527 use_bitmap = image.ConvertToBitmap();
528 }
529 else
530 {
531 use_bitmap = bitmap;
532 }
533
534 GdkBitmap *mask = (GdkBitmap *) NULL;
535 if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
536
537 if (useMask && mask)
538 {
539 gdk_gc_set_clip_mask( m_penGC, mask );
540 gdk_gc_set_clip_origin( m_penGC, xx, yy );
541 }
542
543 GdkPixmap *pm = use_bitmap.GetPixmap();
544 gdk_draw_pixmap( m_window, m_penGC, pm, 0, 0, xx, yy, -1, -1 );
545
546 if (useMask && mask)
547 {
548 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
549 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
550 }
551
552 CalcBoundingBox( x, y );
553 CalcBoundingBox( x + w, y + h );
554 }
555
556 bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,
557 wxDC *source, long xsrc, long ysrc, int logical_func, bool useMask )
558 {
559 wxCHECK_MSG( Ok(), FALSE, "invalid window dc" );
560
561 CalcBoundingBox( xdest, ydest );
562 CalcBoundingBox( xdest + width, ydest + height );
563
564 int old_logical_func = m_logicalFunction;
565 SetLogicalFunction( logical_func );
566
567 wxClientDC *csrc = (wxClientDC*)source;
568
569 if (csrc->m_isMemDC)
570 {
571 wxMemoryDC* srcDC = (wxMemoryDC*)source;
572 GdkPixmap* pmap = srcDC->m_selected.GetPixmap();
573 if (pmap)
574 {
575 long xx = XLOG2DEV(xdest);
576 long yy = YLOG2DEV(ydest);
577
578 GdkBitmap *mask = (GdkBitmap *) NULL;
579 if (srcDC->m_selected.GetMask()) mask = srcDC->m_selected.GetMask()->GetBitmap();
580
581 if (useMask && mask)
582 {
583 gdk_gc_set_clip_mask( m_penGC, mask );
584 gdk_gc_set_clip_origin( m_penGC, xx, yy );
585 }
586
587 gdk_draw_pixmap( m_window, m_penGC, pmap,
588 source->DeviceToLogicalX(xsrc),
589 source->DeviceToLogicalY(ysrc),
590 xx,
591 yy,
592 source->DeviceToLogicalXRel(width),
593 source->DeviceToLogicalYRel(height) );
594
595 if (useMask && mask)
596 {
597 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
598 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
599 }
600
601 SetLogicalFunction( old_logical_func );
602 return TRUE;
603 }
604
605 GdkBitmap* bmap = srcDC->m_selected.GetBitmap();
606 if (bmap)
607 {
608 long xx = XLOG2DEV(xdest);
609 long yy = YLOG2DEV(ydest);
610
611 GdkBitmap *mask = (GdkBitmap *) NULL;
612 if (srcDC->m_selected.GetMask()) mask = srcDC->m_selected.GetMask()->GetBitmap();
613
614 if (useMask && mask)
615 {
616 gdk_gc_set_clip_mask( m_penGC, mask );
617 gdk_gc_set_clip_origin( m_penGC, xx, yy );
618 }
619
620 gdk_draw_bitmap( m_window, m_textGC, bmap,
621 source->DeviceToLogicalX(xsrc),
622 source->DeviceToLogicalY(ysrc),
623 xx,
624 yy,
625 source->DeviceToLogicalXRel(width),
626 source->DeviceToLogicalYRel(height) );
627
628 if (useMask && mask)
629 {
630 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
631 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
632 }
633
634 SetLogicalFunction( old_logical_func );
635 return TRUE;
636 }
637 }
638
639 gdk_window_copy_area ( m_window, m_penGC,
640 XLOG2DEV(xdest), YLOG2DEV(ydest),
641 csrc->GetWindow(),
642 source->DeviceToLogicalX(xsrc),
643 source->DeviceToLogicalY(ysrc),
644 source->DeviceToLogicalXRel(width),
645 source->DeviceToLogicalYRel(height) );
646
647 SetLogicalFunction( old_logical_func );
648 return TRUE;
649 }
650
651 void wxWindowDC::DrawText( const wxString &text, long x, long y, bool WXUNUSED(use16) )
652 {
653 wxCHECK_RET( Ok(), "invalid window dc" );
654
655 GdkFont *font = m_font.GetInternalFont( m_scaleY );
656
657 x = XLOG2DEV(x);
658 y = YLOG2DEV(y);
659
660 // CMB 21/5/98: draw text background if mode is wxSOLID
661 if (m_backgroundMode == wxSOLID)
662 {
663 long width = gdk_string_width( font, text );
664 long height = font->ascent + font->descent;
665 gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
666 gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
667 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
668 }
669 gdk_draw_string( m_window, font, m_textGC, x, y + font->ascent, text );
670
671 // CMB 17/7/98: simple underline: ignores scaling and underlying
672 // X font's XA_UNDERLINE_POSITION and XA_UNDERLINE_THICKNESS
673 // properties (see wxXt implementation)
674 if (m_font.GetUnderlined())
675 {
676 long width = gdk_string_width( font, text );
677 long ul_y = y + font->ascent;
678 if (font->descent > 0) ul_y++;
679 gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
680 }
681
682 long w, h;
683 GetTextExtent (text, &w, &h);
684 CalcBoundingBox (x + w, y + h);
685 CalcBoundingBox (x, y);
686 }
687
688 bool wxWindowDC::CanGetTextExtent() const
689 {
690 return TRUE;
691 }
692
693 void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *height,
694 long *descent, long *externalLeading,
695 wxFont *theFont, bool WXUNUSED(use16) )
696 {
697 wxCHECK_RET( Ok(), "invalid window dc" );
698
699 wxFont fontToUse = m_font;
700 if (theFont) fontToUse = *theFont;
701
702 GdkFont *font = fontToUse.GetInternalFont( m_scaleY );
703 if (width) (*width) = long(gdk_string_width( font, string ) / m_scaleX);
704 if (height) (*height) = long((font->ascent + font->descent) / m_scaleY);
705 if (descent) (*descent) = long(font->descent / m_scaleY);
706 if (externalLeading) (*externalLeading) = 0; // ??
707 }
708
709 long wxWindowDC::GetCharWidth()
710 {
711 wxCHECK_MSG( Ok(), 0, "invalid window dc" );
712
713 GdkFont *font = m_font.GetInternalFont( m_scaleY );
714 return long(gdk_string_width( font, "H" ) / m_scaleX);
715 }
716
717 long wxWindowDC::GetCharHeight()
718 {
719 wxCHECK_MSG( Ok(), 0, "invalid window dc" );
720
721 GdkFont *font = m_font.GetInternalFont( m_scaleY );
722 return long((font->ascent + font->descent) / m_scaleY);
723 }
724
725 void wxWindowDC::Clear()
726 {
727 wxCHECK_RET( Ok(), "invalid window dc" );
728
729 if (!m_isMemDC)
730 {
731 gdk_window_clear( m_window );
732 }
733 else
734 {
735 int width,height;
736 GetSize( &width, &height );
737 gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
738 }
739 }
740
741 void wxWindowDC::SetFont( const wxFont &font )
742 {
743 wxCHECK_RET( Ok(), "invalid window dc" );
744
745 m_font = font;
746 }
747
748 void wxWindowDC::SetPen( const wxPen &pen )
749 {
750 wxCHECK_RET( Ok(), "invalid window dc" );
751
752 if (m_pen == pen) return;
753
754 m_pen = pen;
755
756 if (!m_pen.Ok()) return;
757
758 gint width = m_pen.GetWidth();
759 // CMB: if width is non-zero scale it with the dc
760 if (width <= 0)
761 {
762 width = 1;
763 }
764 else
765 {
766 // X doesn't allow different width in x and y and so we take
767 // the average
768 double w = 0.5 + (abs(XLOG2DEVREL(width)) + abs(YLOG2DEVREL(width))) / 2.0;
769 width = (int)w;
770 }
771
772 GdkLineStyle lineStyle = GDK_LINE_SOLID;
773 switch (m_pen.GetStyle())
774 {
775 case wxSOLID: { lineStyle = GDK_LINE_SOLID; break; }
776 case wxDOT: { lineStyle = GDK_LINE_ON_OFF_DASH; break; }
777 case wxLONG_DASH: { lineStyle = GDK_LINE_ON_OFF_DASH; break; }
778 case wxSHORT_DASH: { lineStyle = GDK_LINE_ON_OFF_DASH; break; }
779 case wxDOT_DASH: { lineStyle = GDK_LINE_DOUBLE_DASH; break; }
780 }
781
782 GdkCapStyle capStyle = GDK_CAP_ROUND;
783 switch (m_pen.GetCap())
784 {
785 case wxCAP_ROUND: { capStyle = (width <= 1) ? GDK_CAP_NOT_LAST : GDK_CAP_ROUND; break; }
786 case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; }
787 case wxCAP_BUTT: { capStyle = GDK_CAP_BUTT; break; }
788 }
789
790 GdkJoinStyle joinStyle = GDK_JOIN_ROUND;
791 switch (m_pen.GetJoin())
792 {
793 case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; }
794 case wxJOIN_ROUND: { joinStyle = GDK_JOIN_ROUND; break; }
795 case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; }
796 }
797
798 gdk_gc_set_line_attributes( m_penGC, width, lineStyle, capStyle, joinStyle );
799
800 m_pen.GetColour().CalcPixel( m_cmap );
801 gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
802 }
803
804 void wxWindowDC::SetBrush( const wxBrush &brush )
805 {
806 wxCHECK_RET( Ok(), "invalid window dc" );
807
808 if (m_brush == brush) return;
809
810 m_brush = brush;
811
812 if (!m_brush.Ok()) return;
813
814 m_brush.GetColour().CalcPixel( m_cmap );
815 gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
816
817 GdkFill fillStyle = GDK_SOLID;
818 switch (m_brush.GetStyle())
819 {
820 case wxSOLID:
821 case wxTRANSPARENT:
822 break;
823 default:
824 fillStyle = GDK_STIPPLED;
825 }
826
827 gdk_gc_set_fill( m_brushGC, fillStyle );
828
829 if (m_brush.GetStyle() == wxSTIPPLE)
830 {
831 gdk_gc_set_stipple( m_brushGC, m_brush.GetStipple()->GetPixmap() );
832 }
833
834 if (IS_HATCH(m_brush.GetStyle()))
835 {
836 int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
837 gdk_gc_set_stipple( m_brushGC, hatches[num] );
838 }
839 }
840
841 void wxWindowDC::SetBackground( const wxBrush &brush )
842 {
843 // CMB 21/7/98: Added SetBackground. Sets background brush
844 // for Clear() and bg colour for shapes filled with cross-hatch brush
845
846 wxCHECK_RET( Ok(), "invalid window dc" );
847
848 if (m_backgroundBrush == brush) return;
849
850 m_backgroundBrush = brush;
851
852 if (!m_backgroundBrush.Ok()) return;
853
854 m_backgroundBrush.GetColour().CalcPixel( m_cmap );
855 gdk_gc_set_background( m_brushGC, m_backgroundBrush.GetColour().GetColor() );
856 gdk_gc_set_background( m_penGC, m_backgroundBrush.GetColour().GetColor() );
857 gdk_gc_set_background( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
858 gdk_gc_set_foreground( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
859
860 GdkFill fillStyle = GDK_SOLID;
861 switch (m_backgroundBrush.GetStyle())
862 {
863 case wxSOLID:
864 case wxTRANSPARENT:
865 break;
866 default:
867 fillStyle = GDK_STIPPLED;
868 }
869
870 gdk_gc_set_fill( m_bgGC, fillStyle );
871
872 if (m_backgroundBrush.GetStyle() == wxSTIPPLE)
873 {
874 gdk_gc_set_stipple( m_bgGC, m_backgroundBrush.GetStipple()->GetPixmap() );
875 }
876
877 if (IS_HATCH(m_backgroundBrush.GetStyle()))
878 {
879 int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
880 gdk_gc_set_stipple( m_bgGC, hatches[num] );
881 }
882 }
883
884 void wxWindowDC::SetLogicalFunction( int function )
885 {
886 wxCHECK_RET( Ok(), "invalid window dc" );
887
888 if (m_logicalFunction == function) return;
889
890 GdkFunction mode = GDK_COPY;
891 switch (function)
892 {
893 case wxXOR: mode = GDK_INVERT; break;
894 case wxINVERT: mode = GDK_INVERT; break;
895 default: break;
896 }
897
898 m_logicalFunction = function;
899 gdk_gc_set_function( m_penGC, mode );
900 gdk_gc_set_function( m_brushGC, mode );
901 gdk_gc_set_function( m_textGC, mode );
902 }
903
904 void wxWindowDC::SetTextForeground( const wxColour &col )
905 {
906 wxCHECK_RET( Ok(), "invalid window dc" );
907
908 if (m_textForegroundColour == col) return;
909
910 m_textForegroundColour = col;
911 if (!m_textForegroundColour.Ok()) return;
912
913 m_textForegroundColour.CalcPixel( m_cmap );
914 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
915 }
916
917 void wxWindowDC::SetTextBackground( const wxColour &col )
918 {
919 wxCHECK_RET( Ok(), "invalid window dc" );
920
921 if (m_textBackgroundColour == col) return;
922
923 m_textBackgroundColour = col;
924 if (!m_textBackgroundColour.Ok()) return;
925
926 m_textBackgroundColour.CalcPixel( m_cmap );
927 gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
928 }
929
930 void wxWindowDC::SetBackgroundMode( int mode )
931 {
932 wxCHECK_RET( Ok(), "invalid window dc" );
933
934 m_backgroundMode = mode;
935
936 // CMB 21/7/98: fill style of cross-hatch brushes is affected by
937 // transparent/solid background mode
938
939 if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
940 {
941 gdk_gc_set_fill( m_brushGC,
942 (m_backgroundMode == wxTRANSPARENT) ? GDK_STIPPLED : GDK_OPAQUE_STIPPLED);
943 }
944 }
945
946 void wxWindowDC::SetPalette( const wxPalette& WXUNUSED(palette) )
947 {
948 wxFAIL_MSG( "wxWindowDC::SetPalette not implemented" );
949 }
950
951 void wxWindowDC::SetClippingRegion( long x, long y, long width, long height )
952 {
953 wxCHECK_RET( Ok(), "invalid window dc" );
954
955 wxDC::SetClippingRegion( x, y, width, height );
956
957 GdkRectangle rect;
958 rect.x = XLOG2DEV(x);
959 rect.y = YLOG2DEV(y);
960 rect.width = XLOG2DEVREL(width);
961 rect.height = YLOG2DEVREL(height);
962 gdk_gc_set_clip_rectangle( m_penGC, &rect );
963 gdk_gc_set_clip_rectangle( m_brushGC, &rect );
964 gdk_gc_set_clip_rectangle( m_textGC, &rect );
965 gdk_gc_set_clip_rectangle( m_bgGC, &rect );
966 }
967
968 void wxWindowDC::SetClippingRegion( const wxRegion &region )
969 {
970 wxCHECK_RET( Ok(), "invalid window dc" );
971
972 if (region.Empty())
973 {
974 DestroyClippingRegion();
975 return;
976 }
977
978 gdk_gc_set_clip_region( m_penGC, region.GetRegion() );
979 gdk_gc_set_clip_region( m_brushGC, region.GetRegion() );
980 gdk_gc_set_clip_region( m_textGC, region.GetRegion() );
981 gdk_gc_set_clip_region( m_bgGC, region.GetRegion() );
982 }
983
984 void wxWindowDC::DestroyClippingRegion()
985 {
986 wxCHECK_RET( Ok(), "invalid window dc" );
987
988 wxDC::DestroyClippingRegion();
989
990 gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
991 gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
992 gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
993 gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
994 }
995
996 void wxWindowDC::SetUpDC()
997 {
998 Destroy();
999 m_ok = TRUE;
1000 m_logicalFunction = wxCOPY;
1001 m_penGC = gdk_gc_new( m_window );
1002 m_brushGC = gdk_gc_new( m_window );
1003 m_textGC = gdk_gc_new( m_window );
1004 m_bgGC = gdk_gc_new( m_window );
1005
1006 wxColour tmp_col( m_textForegroundColour );
1007 m_textForegroundColour = wxNullColour;
1008 SetTextForeground( tmp_col );
1009 tmp_col = m_textBackgroundColour;
1010 m_textBackgroundColour = wxNullColour;
1011 SetTextBackground( tmp_col );
1012
1013 wxPen tmp_pen( m_pen );
1014 m_pen = wxNullPen;
1015 SetPen( tmp_pen );
1016
1017 wxFont tmp_font( m_font );
1018 m_font = wxNullFont;
1019 SetFont( tmp_font );
1020
1021 wxBrush tmp_brush( m_brush );
1022 m_brush = wxNullBrush;
1023 SetBrush( tmp_brush );
1024
1025 tmp_brush = m_backgroundBrush;
1026 m_backgroundBrush = wxNullBrush;
1027 SetBackground( tmp_brush );
1028
1029 if (!hatch_bitmap)
1030 {
1031 hatch_bitmap = hatches;
1032 hatch_bitmap[0] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, bdiag_bits, bdiag_width, bdiag_height );
1033 hatch_bitmap[1] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cdiag_bits, cdiag_width, cdiag_height );
1034 hatch_bitmap[2] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, fdiag_bits, fdiag_width, fdiag_height );
1035 hatch_bitmap[3] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cross_bits, cross_width, cross_height );
1036 hatch_bitmap[4] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, horiz_bits, horiz_width, horiz_height );
1037 hatch_bitmap[5] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, verti_bits, verti_width, verti_height );
1038 }
1039 }
1040
1041 void wxWindowDC::Destroy()
1042 {
1043 if (m_penGC) gdk_gc_unref( m_penGC );
1044 m_penGC = (GdkGC*) NULL;
1045 if (m_brushGC) gdk_gc_unref( m_brushGC );
1046 m_brushGC = (GdkGC*) NULL;
1047 if (m_textGC) gdk_gc_unref( m_textGC );
1048 m_textGC = (GdkGC*) NULL;
1049 if (m_bgGC) gdk_gc_unref( m_bgGC );
1050 m_bgGC = (GdkGC*) NULL;
1051 }
1052
1053 GdkWindow *wxWindowDC::GetWindow()
1054 {
1055 return m_window;
1056 }
1057
1058 // ----------------------------------- spline code ----------------------------------------
1059
1060 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
1061 double a3, double b3, double a4, double b4);
1062 void wx_clear_stack();
1063 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
1064 double *y3, double *x4, double *y4);
1065 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
1066 double x4, double y4);
1067 static bool wx_spline_add_point(double x, double y);
1068 static void wx_spline_draw_point_array(wxDC *dc);
1069
1070 wxList wx_spline_point_list;
1071
1072 #define half(z1, z2) ((z1+z2)/2.0)
1073 #define THRESHOLD 5
1074
1075 /* iterative version */
1076
1077 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
1078 double b4)
1079 {
1080 register double xmid, ymid;
1081 double x1, y1, x2, y2, x3, y3, x4, y4;
1082
1083 wx_clear_stack();
1084 wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
1085
1086 while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
1087 xmid = (double)half(x2, x3);
1088 ymid = (double)half(y2, y3);
1089 if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
1090 fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
1091 wx_spline_add_point( x1, y1 );
1092 wx_spline_add_point( xmid, ymid );
1093 } else {
1094 wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
1095 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
1096 wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
1097 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
1098 }
1099 }
1100 }
1101
1102 /* utilities used by spline drawing routines */
1103
1104 typedef struct wx_spline_stack_struct {
1105 double x1, y1, x2, y2, x3, y3, x4, y4;
1106 } Stack;
1107
1108 #define SPLINE_STACK_DEPTH 20
1109 static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
1110 static Stack *wx_stack_top;
1111 static int wx_stack_count;
1112
1113 void wx_clear_stack()
1114 {
1115 wx_stack_top = wx_spline_stack;
1116 wx_stack_count = 0;
1117 }
1118
1119 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
1120 {
1121 wx_stack_top->x1 = x1;
1122 wx_stack_top->y1 = y1;
1123 wx_stack_top->x2 = x2;
1124 wx_stack_top->y2 = y2;
1125 wx_stack_top->x3 = x3;
1126 wx_stack_top->y3 = y3;
1127 wx_stack_top->x4 = x4;
1128 wx_stack_top->y4 = y4;
1129 wx_stack_top++;
1130 wx_stack_count++;
1131 }
1132
1133 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
1134 double *x3, double *y3, double *x4, double *y4)
1135 {
1136 if (wx_stack_count == 0)
1137 return (0);
1138 wx_stack_top--;
1139 wx_stack_count--;
1140 *x1 = wx_stack_top->x1;
1141 *y1 = wx_stack_top->y1;
1142 *x2 = wx_stack_top->x2;
1143 *y2 = wx_stack_top->y2;
1144 *x3 = wx_stack_top->x3;
1145 *y3 = wx_stack_top->y3;
1146 *x4 = wx_stack_top->x4;
1147 *y4 = wx_stack_top->y4;
1148 return (1);
1149 }
1150
1151 static bool wx_spline_add_point(double x, double y)
1152 {
1153 wxPoint *point = new wxPoint ;
1154 point->x = (int) x;
1155 point->y = (int) y;
1156 wx_spline_point_list.Append((wxObject*)point);
1157 return TRUE;
1158 }
1159
1160 static void wx_spline_draw_point_array(wxDC *dc)
1161 {
1162 dc->DrawLines(&wx_spline_point_list, 0, 0 );
1163 wxNode *node = wx_spline_point_list.First();
1164 while (node)
1165 {
1166 wxPoint *point = (wxPoint *)node->Data();
1167 delete point;
1168 delete node;
1169 node = wx_spline_point_list.First();
1170 }
1171 }
1172
1173 void wxWindowDC::DrawSpline( wxList *points )
1174 {
1175 wxCHECK_RET( Ok(), "invalid window dc" );
1176
1177 wxPoint *p;
1178 double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
1179 double x1, y1, x2, y2;
1180
1181 wxNode *node = points->First();
1182 p = (wxPoint *)node->Data();
1183
1184 x1 = p->x;
1185 y1 = p->y;
1186
1187 node = node->Next();
1188 p = (wxPoint *)node->Data();
1189
1190 x2 = p->x;
1191 y2 = p->y;
1192 cx1 = (double)((x1 + x2) / 2);
1193 cy1 = (double)((y1 + y2) / 2);
1194 cx2 = (double)((cx1 + x2) / 2);
1195 cy2 = (double)((cy1 + y2) / 2);
1196
1197 wx_spline_add_point(x1, y1);
1198
1199 while ((node = node->Next()) != NULL)
1200 {
1201 p = (wxPoint *)node->Data();
1202 x1 = x2;
1203 y1 = y2;
1204 x2 = p->x;
1205 y2 = p->y;
1206 cx4 = (double)(x1 + x2) / 2;
1207 cy4 = (double)(y1 + y2) / 2;
1208 cx3 = (double)(x1 + cx4) / 2;
1209 cy3 = (double)(y1 + cy4) / 2;
1210
1211 wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
1212
1213 cx1 = cx4;
1214 cy1 = cy4;
1215 cx2 = (double)(cx1 + x2) / 2;
1216 cy2 = (double)(cy1 + y2) / 2;
1217 }
1218
1219 wx_spline_add_point( cx1, cy1 );
1220 wx_spline_add_point( x2, y2 );
1221
1222 wx_spline_draw_point_array( this );
1223 }
1224
1225
1226 //-----------------------------------------------------------------------------
1227 // wxPaintDC
1228 //-----------------------------------------------------------------------------
1229
1230 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC,wxWindowDC)
1231
1232 wxPaintDC::wxPaintDC()
1233 : wxWindowDC()
1234 {
1235 }
1236
1237 wxPaintDC::wxPaintDC( wxWindow *win )
1238 : wxWindowDC( win )
1239 {
1240 }
1241
1242 //-----------------------------------------------------------------------------
1243 // wxClientDC
1244 //-----------------------------------------------------------------------------
1245
1246 IMPLEMENT_DYNAMIC_CLASS(wxClientDC,wxWindowDC)
1247
1248 wxClientDC::wxClientDC()
1249 : wxWindowDC()
1250 {
1251 }
1252
1253 wxClientDC::wxClientDC( wxWindow *win )
1254 : wxWindowDC( win )
1255 {
1256 }
1257