]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/dcclient.cpp
projects / wxWidgets.git / blob
? search:


f17a53d55ad6415970e249f2874efa052944ce66
[wxWidgets.git] / src / gtk1 / 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 "wx/gtk/win_gtk.h"
18 #include <math.h> // for floating-point functions
19
20 #include "gdk/gdk.h"
21 #include "gtk/gtk.h"
22
23 //-----------------------------------------------------------------------------
24 // local data
25 //-----------------------------------------------------------------------------
26
27 #include "bdiag.xbm"
28 #include "fdiag.xbm"
29 #include "cdiag.xbm"
30 #include "horiz.xbm"
31 #include "verti.xbm"
32 #include "cross.xbm"
33 #define num_hatches 6
34
35 static GdkPixmap *hatches[num_hatches];
36 static GdkPixmap **hatch_bitmap = (GdkPixmap **) NULL;
37
38 //-----------------------------------------------------------------------------
39 // constants
40 //-----------------------------------------------------------------------------
41
42 #define RAD2DEG 57.2957795131
43
44 //-----------------------------------------------------------------------------
45 // temporary implementation of the missing GDK function
46 //-----------------------------------------------------------------------------
47
48 #include "gdk/gdkprivate.h"
49
50 void gdk_draw_bitmap (GdkDrawable *drawable,
51 GdkGC *gc,
52 GdkDrawable *src,
53 gint xsrc,
54 gint ysrc,
55 gint xdest,
56 gint ydest,
57 gint width,
58 gint height)
59 {
60 GdkWindowPrivate *drawable_private;
61 GdkWindowPrivate *src_private;
62 GdkGCPrivate *gc_private;
63
64 g_return_if_fail (drawable != NULL);
65 g_return_if_fail (src != NULL);
66 g_return_if_fail (gc != NULL);
67
68 drawable_private = (GdkWindowPrivate*) drawable;
69 src_private = (GdkWindowPrivate*) src;
70 if (drawable_private->destroyed || src_private->destroyed)
71 return;
72
73 gc_private = (GdkGCPrivate*) gc;
74
75 if (width == -1) width = src_private->width;
76 if (height == -1) height = src_private->height;
77
78 XCopyPlane( drawable_private->xdisplay,
79 src_private->xwindow,
80 drawable_private->xwindow,
81 gc_private->xgc,
82 xsrc, ysrc,
83 width, height,
84 xdest, ydest,
85 1 );
86 }
87
88 //-----------------------------------------------------------------------------
89 // wxWindowDC
90 //-----------------------------------------------------------------------------
91
92 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
93
94 wxWindowDC::wxWindowDC()
95 {
96 m_penGC = (GdkGC *) NULL;
97 m_brushGC = (GdkGC *) NULL;
98 m_textGC = (GdkGC *) NULL;
99 m_bgGC = (GdkGC *) NULL;
100 m_cmap = (GdkColormap *) NULL;
101 m_isMemDC = FALSE;
102 m_owner = (wxWindow *)NULL;
103 }
104
105 wxWindowDC::wxWindowDC( wxWindow *window )
106 {
107 m_penGC = (GdkGC *) NULL;
108 m_brushGC = (GdkGC *) NULL;
109 m_textGC = (GdkGC *) NULL;
110 m_bgGC = (GdkGC *) NULL;
111 m_cmap = (GdkColormap *) NULL;
112 m_owner = (wxWindow *)NULL;
113 m_isMemDC = FALSE;
114 m_font = window->GetFont();
115
116 wxASSERT_MSG( window, wxT("DC needs a window") );
117
118 GtkWidget *widget = window->m_wxwindow;
119
120 wxASSERT_MSG( widget, wxT("DC needs a widget") );
121
122 GtkMyFixed *myfixed = GTK_MYFIXED( widget );
123 m_window = myfixed->bin_window;
124
125 /* not realized ? */
126 if (!m_window)
127 {
128 /* don't report problems */
129 m_ok = TRUE;
130
131 return;
132 }
133
134 if (window->m_wxwindow)
135 m_cmap = gtk_widget_get_colormap( window->m_wxwindow );
136 else
137 m_cmap = gtk_widget_get_colormap( window->m_widget );
138
139 SetUpDC();
140
141 /* this must be done after SetUpDC, bacause SetUpDC calls the
142 repective SetBrush, SetPen, SetBackground etc functions
143 to set up the DC. SetBackground call m_owner->SetBackground
144 and this might not be desired as the standard dc background
145 is white whereas a window might assume gray to be the
146 standard (as e.g. wxStatusBar) */
147
148 m_owner = window;
149 }
150
151 wxWindowDC::~wxWindowDC()
152 {
153 Destroy();
154 }
155
156 void wxWindowDC::DoFloodFill( long WXUNUSED(x), long WXUNUSED(y),
157 const wxColour &WXUNUSED(col), int WXUNUSED(style) )
158 {
159 wxFAIL_MSG( wxT("wxWindowDC::DoFloodFill not implemented") );
160 }
161
162 bool wxWindowDC::DoGetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const
163 {
164 wxFAIL_MSG( wxT("wxWindowDC::DoGetPixel not implemented") );
165 return FALSE;
166 }
167
168 void wxWindowDC::DoDrawLine( long x1, long y1, long x2, long y2 )
169 {
170 wxCHECK_RET( Ok(), wxT("invalid window dc") );
171
172 if (m_pen.GetStyle() != wxTRANSPARENT)
173 {
174 if (m_window)
175 gdk_draw_line( m_window, m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
176
177 CalcBoundingBox(x1, y1);
178 CalcBoundingBox(x2, y2);
179 }
180 }
181
182 void wxWindowDC::DoCrossHair( long x, long y )
183 {
184 wxCHECK_RET( Ok(), wxT("invalid window dc") );
185
186 if (m_pen.GetStyle() != wxTRANSPARENT)
187 {
188 int w = 0;
189 int h = 0;
190 GetSize( &w, &h );
191 long xx = XLOG2DEV(x);
192 long yy = YLOG2DEV(y);
193 if (m_window)
194 {
195 gdk_draw_line( m_window, m_penGC, 0, yy, XLOG2DEVREL(w), yy );
196 gdk_draw_line( m_window, m_penGC, xx, 0, xx, YLOG2DEVREL(h) );
197 }
198 }
199 }
200
201 void wxWindowDC::DoDrawArc( long x1, long y1, long x2, long y2,
202 long xc, long yc )
203 {
204 wxCHECK_RET( Ok(), wxT("invalid window dc") );
205
206 long xx1 = XLOG2DEV(x1);
207 long yy1 = YLOG2DEV(y1);
208 long xx2 = XLOG2DEV(x2);
209 long yy2 = YLOG2DEV(y2);
210 long xxc = XLOG2DEV(xc);
211 long yyc = YLOG2DEV(yc);
212 double dx = xx1 - xxc;
213 double dy = yy1 - yyc;
214 double radius = sqrt(dx*dx+dy*dy);
215 long r = (long)radius;
216 double radius1, radius2;
217
218 if (xx1 == xx2 && yy1 == yy2)
219 {
220 radius1 = 0.0;
221 radius2 = 360.0;
222 }
223 else
224 if (radius == 0.0)
225 {
226 radius1 = radius2 = 0.0;
227 }
228 else
229 {
230 radius1 = (xx1 - xxc == 0) ?
231 (yy1 - yyc < 0) ? 90.0 : -90.0 :
232 -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
233 radius2 = (xx2 - xxc == 0) ?
234 (yy2 - yyc < 0) ? 90.0 : -90.0 :
235 -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
236 }
237 long alpha1 = long(radius1 * 64.0);
238 long alpha2 = long((radius2 - radius1) * 64.0);
239 while (alpha2 <= 0) alpha2 += 360*64;
240 while (alpha1 > 360*64) alpha1 -= 360*64;
241
242 if (m_window)
243 {
244 if (m_brush.GetStyle() != wxTRANSPARENT)
245 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
246
247 if (m_pen.GetStyle() != wxTRANSPARENT)
248 gdk_draw_arc( m_window, m_penGC, FALSE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
249 }
250
251 CalcBoundingBox (x1, y1);
252 CalcBoundingBox (x2, y2);
253 }
254
255 void wxWindowDC::DoDrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
256 {
257 wxCHECK_RET( Ok(), wxT("invalid window dc") );
258
259 long xx = XLOG2DEV(x);
260 long yy = YLOG2DEV(y);
261 long ww = m_signX * XLOG2DEVREL(width);
262 long hh = m_signY * YLOG2DEVREL(height);
263
264 // CMB: handle -ve width and/or height
265 if (ww < 0) { ww = -ww; xx = xx - ww; }
266 if (hh < 0) { hh = -hh; yy = yy - hh; }
267
268 if (m_window)
269 {
270 long start = long(sa * 64.0);
271 long end = long(ea * 64.0);
272
273 if (m_brush.GetStyle() != wxTRANSPARENT)
274 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
275
276 if (m_pen.GetStyle() != wxTRANSPARENT)
277 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, start, end );
278 }
279
280 CalcBoundingBox (x, y);
281 CalcBoundingBox (x + width, y + height);
282 }
283
284 void wxWindowDC::DoDrawPoint( long x, long y )
285 {
286 wxCHECK_RET( Ok(), wxT("invalid window dc") );
287
288 if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
289 gdk_draw_point( m_window, m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
290
291 CalcBoundingBox (x, y);
292 }
293
294 void wxWindowDC::DoDrawLines( int n, wxPoint points[], long xoffset, long yoffset )
295 {
296 wxCHECK_RET( Ok(), wxT("invalid window dc") );
297
298 if (m_pen.GetStyle() == wxTRANSPARENT) return;
299 if (n <= 0) return;
300
301 CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
302
303 for (int i = 0; i < n-1; i++)
304 {
305 long x1 = XLOG2DEV(points[i].x + xoffset);
306 long x2 = XLOG2DEV(points[i+1].x + xoffset);
307 long y1 = YLOG2DEV(points[i].y + yoffset); // oh, what a waste
308 long y2 = YLOG2DEV(points[i+1].y + yoffset);
309
310 if (m_window)
311 gdk_draw_line( m_window, m_penGC, x1, y1, x2, y2 );
312
313 CalcBoundingBox( points[i+1].x + xoffset, points[i+1].y + yoffset );
314 }
315 }
316
317 void wxWindowDC::DoDrawPolygon( int n, wxPoint points[], long xoffset, long yoffset, int WXUNUSED(fillStyle) )
318 {
319 wxCHECK_RET( Ok(), wxT("invalid window dc") );
320
321 if (n <= 0) return;
322
323 GdkPoint *gdkpoints = new GdkPoint[n+1];
324 int i;
325 for (i = 0 ; i < n ; i++)
326 {
327 gdkpoints[i].x = XLOG2DEV(points[i].x + xoffset);
328 gdkpoints[i].y = YLOG2DEV(points[i].y + yoffset);
329
330 CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
331 }
332
333 if ((m_brush.GetStyle() != wxTRANSPARENT) && m_window)
334 gdk_draw_polygon (m_window, m_brushGC, TRUE, gdkpoints, n);
335
336 // To do: Fillstyle
337
338 if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
339 {
340 for (i = 0 ; i < n ; i++)
341 {
342 gdk_draw_line( m_window, m_penGC,
343 gdkpoints[i%n].x,
344 gdkpoints[i%n].y,
345 gdkpoints[(i+1)%n].x,
346 gdkpoints[(i+1)%n].y);
347 }
348 }
349
350 delete[] gdkpoints;
351 }
352
353 void wxWindowDC::DoDrawRectangle( long x, long y, long width, long height )
354 {
355 wxCHECK_RET( Ok(), wxT("invalid window dc") );
356
357 long xx = XLOG2DEV(x);
358 long yy = YLOG2DEV(y);
359 long ww = m_signX * XLOG2DEVREL(width);
360 long hh = m_signY * YLOG2DEVREL(height);
361
362 // CMB: draw nothing if transformed w or h is 0
363 if (ww == 0 || hh == 0) return;
364
365 // CMB: handle -ve width and/or height
366 if (ww < 0) { ww = -ww; xx = xx - ww; }
367 if (hh < 0) { hh = -hh; yy = yy - hh; }
368
369 if (m_window)
370 {
371 if (m_brush.GetStyle() != wxTRANSPARENT)
372 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
373
374 if (m_pen.GetStyle() != wxTRANSPARENT)
375 gdk_draw_rectangle( m_window, m_penGC, FALSE, xx, yy, ww-1, hh-1 );
376 }
377
378 CalcBoundingBox( x, y );
379 CalcBoundingBox( x + width, y + height );
380 }
381
382 void wxWindowDC::DoDrawRoundedRectangle( long x, long y, long width, long height, double radius )
383 {
384 wxCHECK_RET( Ok(), wxT("invalid window dc") );
385
386 if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
387
388 long xx = XLOG2DEV(x);
389 long yy = YLOG2DEV(y);
390 long ww = m_signX * XLOG2DEVREL(width);
391 long hh = m_signY * YLOG2DEVREL(height);
392 long rr = XLOG2DEVREL((long)radius);
393
394 // CMB: handle -ve width and/or height
395 if (ww < 0) { ww = -ww; xx = xx - ww; }
396 if (hh < 0) { hh = -hh; yy = yy - hh; }
397
398 // CMB: if radius is zero use DrawRectangle() instead to avoid
399 // X drawing errors with small radii
400 if (rr == 0)
401 {
402 DrawRectangle( x, y, width, height );
403 return;
404 }
405
406 // CMB: draw nothing if transformed w or h is 0
407 if (ww == 0 || hh == 0) return;
408
409 // CMB: adjust size if outline is drawn otherwise the result is
410 // 1 pixel too wide and high
411 if (m_pen.GetStyle() != wxTRANSPARENT)
412 {
413 ww--;
414 hh--;
415 }
416
417 if (m_window)
418 {
419 // CMB: ensure dd is not larger than rectangle otherwise we
420 // get an hour glass shape
421 long dd = 2 * rr;
422 if (dd > ww) dd = ww;
423 if (dd > hh) dd = hh;
424 rr = dd / 2;
425
426 if (m_brush.GetStyle() != wxTRANSPARENT)
427 {
428 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
429 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
430 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
431 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
432 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
433 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
434 }
435
436 if (m_pen.GetStyle() != wxTRANSPARENT)
437 {
438 gdk_draw_line( m_window, m_penGC, xx+rr, yy, xx+ww-rr, yy );
439 gdk_draw_line( m_window, m_penGC, xx+rr, yy+hh, xx+ww-rr, yy+hh );
440 gdk_draw_line( m_window, m_penGC, xx, yy+rr, xx, yy+hh-rr );
441 gdk_draw_line( m_window, m_penGC, xx+ww, yy+rr, xx+ww, yy+hh-rr );
442 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, dd, dd, 90*64, 90*64 );
443 gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
444 gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
445 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
446 }
447 }
448
449 // this ignores the radius
450 CalcBoundingBox( x, y );
451 CalcBoundingBox( x + width, y + height );
452 }
453
454 void wxWindowDC::DoDrawEllipse( long x, long y, long width, long height )
455 {
456 wxCHECK_RET( Ok(), wxT("invalid window dc") );
457
458 long xx = XLOG2DEV(x);
459 long yy = YLOG2DEV(y);
460 long ww = m_signX * XLOG2DEVREL(width);
461 long hh = m_signY * YLOG2DEVREL(height);
462
463 // CMB: handle -ve width and/or height
464 if (ww < 0) { ww = -ww; xx = xx - ww; }
465 if (hh < 0) { hh = -hh; yy = yy - hh; }
466
467 if (m_window)
468 {
469 if (m_brush.GetStyle() != wxTRANSPARENT)
470 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
471
472 if (m_pen.GetStyle() != wxTRANSPARENT)
473 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, 0, 360*64 );
474 }
475
476 CalcBoundingBox( x - width, y - height );
477 CalcBoundingBox( x + width, y + height );
478 }
479
480 void wxWindowDC::DoDrawIcon( const wxIcon &icon, long x, long y )
481 {
482 // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
483 DoDrawBitmap( (const wxBitmap&)icon, x, y, (bool)TRUE );
484 }
485
486 void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
487 long x, long y,
488 bool useMask )
489 {
490 wxCHECK_RET( Ok(), wxT("invalid window dc") );
491
492 wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
493
494 /* scale/translate size and position */
495
496 int xx = XLOG2DEV(x);
497 int yy = YLOG2DEV(y);
498
499 int w = bitmap.GetWidth();
500 int h = bitmap.GetHeight();
501
502 CalcBoundingBox( x, y );
503 CalcBoundingBox( x + w, y + h );
504
505 if (!m_window) return;
506
507 int ww = XLOG2DEVREL(w);
508 int hh = YLOG2DEVREL(h);
509
510 /* scale bitmap if required */
511
512 wxBitmap use_bitmap;
513
514 if ((w != ww) || (h != hh))
515 {
516 wxImage image( bitmap );
517 image = image.Scale( ww, hh );
518
519 use_bitmap = image.ConvertToBitmap();
520 }
521 else
522 {
523 use_bitmap = bitmap;
524 }
525
526 /* apply mask if any */
527
528 GdkBitmap *mask = (GdkBitmap *) NULL;
529 if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
530
531 if (useMask && mask)
532 {
533 gdk_gc_set_clip_mask( m_penGC, mask );
534 gdk_gc_set_clip_origin( m_penGC, xx, yy );
535 }
536
537 /* draw XPixmap or XBitmap, depending on what the wxBitmap contains */
538
539 GdkPixmap *pm = use_bitmap.GetPixmap();
540 if (pm)
541 {
542 gdk_draw_pixmap( m_window, m_penGC, pm, 0, 0, xx, yy, -1, -1 );
543 }
544 else
545 {
546 GdkBitmap *bm = use_bitmap.GetBitmap();
547 if (bm)
548 {
549 gdk_draw_bitmap( m_window, m_penGC, bm, 0, 0, xx, yy, -1, -1 );
550 }
551 }
552
553 /* remove mask again if any */
554
555 if (useMask && mask)
556 {
557 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
558 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
559 }
560 }
561
562 bool wxWindowDC::DoBlit( long xdest, long ydest, long width, long height,
563 wxDC *source, long xsrc, long ysrc,
564 int logical_func, bool useMask )
565 {
566 /* this is the nth try to get this utterly useless function to
567 work. it now completely ignores the scaling or translation
568 of the source dc, but scales correctly on the target dc and
569 knows about possible mask information in a memory dc. */
570
571 wxCHECK_MSG( Ok(), FALSE, wxT("invalid window dc") );
572
573 wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
574
575 if (!m_window) return FALSE;
576
577 wxClientDC *srcDC = (wxClientDC*)source;
578 wxMemoryDC *memDC = (wxMemoryDC*)source;
579
580 bool use_bitmap_method = FALSE;
581
582 if (srcDC->m_isMemDC)
583 {
584 if (!memDC->m_selected.Ok()) return FALSE;
585
586 /* we use the "XCopyArea" way to copy a memory dc into
587 y different window if the memory dc BOTH
588 a) doesn't have any mask or its mask isn't used
589 b) it is clipped
590 c) is not 1-bit */
591
592 if (useMask && (memDC->m_selected.GetMask()))
593 {
594 /* we HAVE TO use the direct way for memory dcs
595 that have mask since the XCopyArea doesn't know
596 about masks */
597 use_bitmap_method = TRUE;
598 }
599 else if (memDC->m_selected.GetDepth() == 1)
600 {
601 /* we HAVE TO use the direct way for memory dcs
602 that are bitmaps because XCopyArea doesn't cope
603 with different bit depths */
604 use_bitmap_method = TRUE;
605 }
606 else if ((xsrc == 0) && (ysrc == 0) &&
607 (width == memDC->m_selected.GetWidth()) &&
608 (height == memDC->m_selected.GetHeight()))
609 {
610 /* we SHOULD use the direct way if all of the bitmap
611 in the memory dc is copied in which case XCopyArea
612 wouldn't be able able to boost performace by reducing
613 the area to be scaled */
614 use_bitmap_method = TRUE;
615 }
616 else
617 {
618 use_bitmap_method = FALSE;
619 }
620 }
621
622 CalcBoundingBox( xdest, ydest );
623 CalcBoundingBox( xdest + width, ydest + height );
624
625 int old_logical_func = m_logicalFunction;
626 SetLogicalFunction( logical_func );
627
628 if (use_bitmap_method)
629 {
630 /* scale/translate bitmap size */
631
632 long bm_width = memDC->m_selected.GetWidth();
633 long bm_height = memDC->m_selected.GetHeight();
634
635 long bm_ww = XLOG2DEVREL( bm_width );
636 long bm_hh = YLOG2DEVREL( bm_height );
637
638 /* scale bitmap if required */
639
640 wxBitmap use_bitmap;
641
642 if ((bm_width != bm_ww) || (bm_height != bm_hh))
643 {
644 wxImage image( memDC->m_selected );
645 image = image.Scale( bm_ww, bm_hh );
646
647 use_bitmap = image.ConvertToBitmap();
648 }
649 else
650 {
651 use_bitmap = memDC->m_selected;
652 }
653
654 /* scale/translate size and position */
655
656 long xx = XLOG2DEV(xdest);
657 long yy = YLOG2DEV(ydest);
658
659 long ww = XLOG2DEVREL(width);
660 long hh = YLOG2DEVREL(height);
661
662 /* apply mask if any */
663
664 GdkBitmap *mask = (GdkBitmap *) NULL;
665 if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
666
667 if (useMask && mask)
668 {
669 gdk_gc_set_clip_mask( m_penGC, mask );
670 gdk_gc_set_clip_origin( m_penGC, xx, yy );
671 }
672
673 /* draw XPixmap or XBitmap, depending on what the wxBitmap contains */
674
675 GdkPixmap *pm = use_bitmap.GetPixmap();
676 if (pm)
677 {
678 gdk_draw_pixmap( m_window, m_penGC, pm, xsrc, ysrc, xx, yy, ww, hh );
679 }
680 else
681 {
682 GdkBitmap *bm = use_bitmap.GetBitmap();
683 if (bm)
684 {
685 /* we use the textGC here because blitting a bitmap is done
686 using the current text colour */
687 gdk_draw_bitmap( m_window, m_textGC, bm, xsrc, ysrc, xx, yy, ww, hh );
688 }
689 }
690
691 /* remove mask again if any */
692
693 if (useMask && mask)
694 {
695 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
696 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
697 }
698 }
699 else /* use_bitmap_method */
700 {
701 /* scale/translate size and position */
702
703 long xx = XLOG2DEV(xdest);
704 long yy = YLOG2DEV(ydest);
705
706 long ww = XLOG2DEVREL(width);
707 long hh = YLOG2DEVREL(height);
708
709 if ((width != ww) || (height != hh))
710 {
711 /* draw source window into a bitmap as we cannot scale
712 a window in contrast to a bitmap. this would actually
713 work with memory dcs as well, but we'd lose the mask
714 information and waste one step in this process since
715 a memory already has a bitmap. all this is slightly
716 inefficient as we could take an XImage directly from
717 an X window, but we'd then also have to care that
718 the window is not outside the screen (in which case
719 we'd get a BadMatch or what not).
720 Is a double XGetImage and combined XGetPixel and
721 XPutPixel really faster? I'm not sure. look at wxXt
722 for a different implementation of the same problem. */
723
724 wxBitmap bitmap( width, height );
725 gdk_window_copy_area( bitmap.GetPixmap(), m_penGC, 0, 0,
726 srcDC->GetWindow(),
727 xsrc, ysrc, width, height );
728
729 /* scale image */
730
731 wxImage image( bitmap );
732 image = image.Scale( ww, hh );
733
734 /* convert to bitmap */
735
736 bitmap = image.ConvertToBitmap();
737
738 /* draw scaled bitmap */
739
740 gdk_draw_pixmap( m_window, m_penGC, bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
741
742 }
743 else
744 {
745 /* no scaling and not a memory dc with a mask either */
746
747 gdk_window_copy_area( m_window, m_penGC, xx, yy,
748 srcDC->GetWindow(),
749 xsrc, ysrc, width, height );
750 }
751 }
752
753 SetLogicalFunction( old_logical_func );
754 return TRUE;
755 }
756
757 void wxWindowDC::DoDrawText( const wxString &text, long x, long y )
758 {
759 wxCHECK_RET( Ok(), wxT("invalid window dc") );
760
761 if (!m_window) return;
762
763 GdkFont *font = m_font.GetInternalFont( m_scaleY );
764
765 x = XLOG2DEV(x);
766 y = YLOG2DEV(y);
767
768 /* CMB 21/5/98: draw text background if mode is wxSOLID */
769 if (m_backgroundMode == wxSOLID)
770 {
771 long width = gdk_string_width( font, text.mbc_str() );
772 long height = font->ascent + font->descent;
773 gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
774 gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
775 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
776 }
777 gdk_draw_string( m_window, font, m_textGC, x, y + font->ascent, text.mbc_str() );
778
779 /* CMB 17/7/98: simple underline: ignores scaling and underlying
780 X font's XA_UNDERLINE_POSITION and XA_UNDERLINE_THICKNESS
781 properties (see wxXt implementation) */
782 if (m_font.GetUnderlined())
783 {
784 long width = gdk_string_width( font, text.mbc_str() );
785 long ul_y = y + font->ascent;
786 if (font->descent > 0) ul_y++;
787 gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
788 }
789
790 long w, h;
791 GetTextExtent (text, &w, &h);
792 CalcBoundingBox (x + w, y + h);
793 CalcBoundingBox (x, y);
794 }
795
796 void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *height,
797 long *descent, long *externalLeading,
798 wxFont *theFont ) const
799 {
800 wxFont fontToUse = m_font;
801 if (theFont) fontToUse = *theFont;
802
803 GdkFont *font = fontToUse.GetInternalFont( m_scaleY );
804 if (width) (*width) = long(gdk_string_width( font, string.mbc_str() ) / m_scaleX);
805 if (height) (*height) = long((font->ascent + font->descent) / m_scaleY);
806 if (descent) (*descent) = long(font->descent / m_scaleY);
807 if (externalLeading) (*externalLeading) = 0; // ??
808 }
809
810 long wxWindowDC::GetCharWidth() const
811 {
812 GdkFont *font = m_font.GetInternalFont( m_scaleY );
813 return long(gdk_string_width( font, "H" ) / m_scaleX);
814 }
815
816 long wxWindowDC::GetCharHeight() const
817 {
818 GdkFont *font = m_font.GetInternalFont( m_scaleY );
819 return long((font->ascent + font->descent) / m_scaleY);
820 }
821
822 void wxWindowDC::Clear()
823 {
824 wxCHECK_RET( Ok(), wxT("invalid window dc") );
825
826 if (!m_window) return;
827
828 /* - we either are a memory dc or have a window as the
829 owner. anything else shouldn't happen.
830 - we don't use gdk_window_clear() as we don't set
831 the window's background colour anymore. it is too
832 much pain to keep the DC's and the window's back-
833 ground colour in synch. */
834
835 if (m_owner)
836 {
837 int width,height;
838 m_owner->GetSize( &width, &height );
839 gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
840 return;
841 }
842
843 if (m_isMemDC)
844 {
845 int width,height;
846 GetSize( &width, &height );
847 gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
848 return;
849 }
850 }
851
852 void wxWindowDC::SetFont( const wxFont &font )
853 {
854 m_font = font;
855 }
856
857 void wxWindowDC::SetPen( const wxPen &pen )
858 {
859 wxCHECK_RET( Ok(), wxT("invalid window dc") );
860
861 if (m_pen == pen) return;
862
863 m_pen = pen;
864
865 if (!m_pen.Ok()) return;
866
867 if (!m_window) return;
868
869 gint width = m_pen.GetWidth();
870 if (width <= 0)
871 {
872 // CMB: if width is non-zero scale it with the dc
873 width = 1;
874 }
875 else
876 {
877 // X doesn't allow different width in x and y and so we take
878 // the average
879 double w = 0.5 +
880 ( fabs((double) XLOG2DEVREL(width)) +
881 fabs((double) YLOG2DEVREL(width)) ) / 2.0;
882 width = (int)w;
883 }
884
885 static const char dotted[] = {1, 1};
886 static const char short_dashed[] = {2, 2};
887 static const char long_dashed[] = {2, 4};
888 static const char dotted_dashed[] = {3, 3, 1, 3};
889
890 // We express dash pattern in pen width unit, so we are
891 // independent of zoom factor and so on...
892 int req_nb_dash;
893 const char *req_dash;
894
895 GdkLineStyle lineStyle = GDK_LINE_SOLID;
896 switch (m_pen.GetStyle())
897 {
898 case wxUSER_DASH:
899 {
900 lineStyle = GDK_LINE_ON_OFF_DASH;
901 req_nb_dash = m_pen.GetDashCount();
902 req_dash = m_pen.GetDash();
903 break;
904 }
905 case wxDOT:
906 {
907 lineStyle = GDK_LINE_ON_OFF_DASH;
908 req_nb_dash = 2;
909 req_dash = dotted;
910 break;
911 }
912 case wxLONG_DASH:
913 {
914 lineStyle = GDK_LINE_ON_OFF_DASH;
915 req_nb_dash = 2;
916 req_dash = long_dashed;
917 break;
918 }
919 case wxSHORT_DASH:
920 {
921 lineStyle = GDK_LINE_ON_OFF_DASH;
922 req_nb_dash = 2;
923 req_dash = short_dashed;
924 break;
925 }
926 case wxDOT_DASH:
927 {
928 // lineStyle = GDK_LINE_DOUBLE_DASH;
929 lineStyle = GDK_LINE_ON_OFF_DASH;
930 req_nb_dash = 4;
931 req_dash = dotted_dashed;
932 break;
933 }
934
935 case wxTRANSPARENT:
936 case wxSTIPPLE:
937 case wxSOLID:
938 default:
939 {
940 lineStyle = GDK_LINE_SOLID;
941 req_dash = (wxDash*)NULL;
942 req_nb_dash = 0;
943 break;
944 }
945 }
946
947 #if (GTK_MINOR_VERSION > 0)
948 if (req_dash && req_nb_dash)
949 {
950 char *real_req_dash = new char[req_nb_dash];
951 if (real_req_dash)
952 {
953 for (int i = 0; i < req_nb_dash; i++)
954 real_req_dash[i] = req_dash[i] * width;
955 gdk_gc_set_dashes( m_penGC, 0, real_req_dash, req_nb_dash );
956 delete[] real_req_dash;
957 }
958 else
959 {
960 // No Memory. We use non-scaled dash pattern...
961 gdk_gc_set_dashes( m_penGC, 0, (char*)req_dash, req_nb_dash );
962 }
963 }
964 #endif
965
966 GdkCapStyle capStyle = GDK_CAP_ROUND;
967 switch (m_pen.GetCap())
968 {
969 case wxCAP_ROUND: { capStyle = (width <= 1) ? GDK_CAP_NOT_LAST : GDK_CAP_ROUND; break; }
970 case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; }
971 case wxCAP_BUTT: { capStyle = GDK_CAP_BUTT; break; }
972 }
973
974 GdkJoinStyle joinStyle = GDK_JOIN_ROUND;
975 switch (m_pen.GetJoin())
976 {
977 case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; }
978 case wxJOIN_ROUND: { joinStyle = GDK_JOIN_ROUND; break; }
979 case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; }
980 }
981
982 gdk_gc_set_line_attributes( m_penGC, width, lineStyle, capStyle, joinStyle );
983
984 m_pen.GetColour().CalcPixel( m_cmap );
985 gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
986 }
987
988 void wxWindowDC::SetBrush( const wxBrush &brush )
989 {
990 wxCHECK_RET( Ok(), wxT("invalid window dc") );
991
992 if (m_brush == brush) return;
993
994 m_brush = brush;
995
996 if (!m_brush.Ok()) return;
997
998 if (!m_window) return;
999
1000 m_brush.GetColour().CalcPixel( m_cmap );
1001 gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
1002
1003 gdk_gc_set_fill( m_brushGC, GDK_SOLID );
1004
1005 if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
1006 {
1007 if (m_brush.GetStipple()->GetPixmap())
1008 {
1009 gdk_gc_set_fill( m_brushGC, GDK_TILED );
1010 gdk_gc_set_tile( m_brushGC, m_brush.GetStipple()->GetPixmap() );
1011 }
1012 else
1013 {
1014 gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
1015 gdk_gc_set_stipple( m_brushGC, m_brush.GetStipple()->GetBitmap() );
1016 }
1017 }
1018
1019 if (IS_HATCH(m_brush.GetStyle()))
1020 {
1021 gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
1022 int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
1023 gdk_gc_set_stipple( m_brushGC, hatches[num] );
1024 }
1025 }
1026
1027 void wxWindowDC::SetBackground( const wxBrush &brush )
1028 {
1029 /* CMB 21/7/98: Added SetBackground. Sets background brush
1030 * for Clear() and bg colour for shapes filled with cross-hatch brush */
1031
1032 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1033
1034 if (m_backgroundBrush == brush) return;
1035
1036 m_backgroundBrush = brush;
1037
1038 if (!m_backgroundBrush.Ok()) return;
1039
1040 if (!m_window) return;
1041
1042 m_backgroundBrush.GetColour().CalcPixel( m_cmap );
1043 gdk_gc_set_background( m_brushGC, m_backgroundBrush.GetColour().GetColor() );
1044 gdk_gc_set_background( m_penGC, m_backgroundBrush.GetColour().GetColor() );
1045 gdk_gc_set_background( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
1046 gdk_gc_set_foreground( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
1047
1048 gdk_gc_set_fill( m_bgGC, GDK_SOLID );
1049
1050 if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
1051 {
1052 if (m_backgroundBrush.GetStipple()->GetPixmap())
1053 {
1054 gdk_gc_set_fill( m_bgGC, GDK_TILED );
1055 gdk_gc_set_tile( m_bgGC, m_backgroundBrush.GetStipple()->GetPixmap() );
1056 }
1057 else
1058 {
1059 gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
1060 gdk_gc_set_stipple( m_bgGC, m_backgroundBrush.GetStipple()->GetBitmap() );
1061 }
1062 }
1063
1064 if (IS_HATCH(m_backgroundBrush.GetStyle()))
1065 {
1066 gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
1067 int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
1068 gdk_gc_set_stipple( m_bgGC, hatches[num] );
1069 }
1070 }
1071
1072 void wxWindowDC::SetLogicalFunction( int function )
1073 {
1074 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1075
1076 if (m_logicalFunction == function) return;
1077
1078 GdkFunction mode = GDK_COPY;
1079 switch (function)
1080 {
1081 case wxXOR: mode = GDK_XOR; break;
1082 case wxINVERT: mode = GDK_INVERT; break;
1083 #if (GTK_MINOR_VERSION > 0)
1084 case wxOR_REVERSE: mode = GDK_OR_REVERSE; break;
1085 case wxAND_REVERSE: mode = GDK_AND_REVERSE; break;
1086 case wxCLEAR: mode = GDK_CLEAR; break;
1087 case wxSET: mode = GDK_SET; break;
1088 case wxOR_INVERT: mode = GDK_OR_INVERT; break;
1089 case wxSRC_AND:
1090 case wxAND: mode = GDK_AND; break;
1091 case wxSRC_OR:
1092 case wxOR: mode = GDK_OR; break;
1093 case wxEQUIV: mode = GDK_EQUIV; break;
1094 case wxNAND: mode = GDK_NAND; break;
1095 case wxAND_INVERT: mode = GDK_AND_INVERT; break;
1096 case wxCOPY: mode = GDK_COPY; break;
1097 case wxNO_OP: mode = GDK_NOOP; break;
1098 case wxSRC_INVERT: mode = GDK_COPY_INVERT; break;
1099 #endif
1100 default:
1101 {
1102 wxFAIL_MSG( wxT("unsupported logical function") );
1103 break;
1104 }
1105 }
1106
1107 m_logicalFunction = function;
1108
1109 if (!m_window) return;
1110
1111 gdk_gc_set_function( m_penGC, mode );
1112 gdk_gc_set_function( m_brushGC, mode );
1113 gdk_gc_set_function( m_textGC, mode );
1114 }
1115
1116 void wxWindowDC::SetTextForeground( const wxColour &col )
1117 {
1118 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1119
1120 if (m_textForegroundColour == col) return;
1121
1122 m_textForegroundColour = col;
1123 if (!m_textForegroundColour.Ok()) return;
1124
1125 if (!m_window) return;
1126
1127 m_textForegroundColour.CalcPixel( m_cmap );
1128 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
1129 }
1130
1131 void wxWindowDC::SetTextBackground( const wxColour &col )
1132 {
1133 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1134
1135 if (m_textBackgroundColour == col) return;
1136
1137 m_textBackgroundColour = col;
1138 if (!m_textBackgroundColour.Ok()) return;
1139
1140 if (!m_window) return;
1141
1142 m_textBackgroundColour.CalcPixel( m_cmap );
1143 gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
1144 }
1145
1146 void wxWindowDC::SetBackgroundMode( int mode )
1147 {
1148 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1149
1150 m_backgroundMode = mode;
1151
1152 if (!m_window) return;
1153
1154 // CMB 21/7/98: fill style of cross-hatch brushes is affected by
1155 // transparent/solid background mode
1156
1157 if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
1158 {
1159 gdk_gc_set_fill( m_brushGC,
1160 (m_backgroundMode == wxTRANSPARENT) ? GDK_STIPPLED : GDK_OPAQUE_STIPPLED);
1161 }
1162 }
1163
1164 void wxWindowDC::SetPalette( const wxPalette& WXUNUSED(palette) )
1165 {
1166 wxFAIL_MSG( wxT("wxWindowDC::SetPalette not implemented") );
1167 }
1168
1169 void wxWindowDC::DoSetClippingRegion( long x, long y, long width, long height )
1170 {
1171 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1172
1173 wxDC::DoSetClippingRegion( x, y, width, height );
1174
1175 if (!m_window) return;
1176
1177 GdkRectangle rect;
1178 rect.x = XLOG2DEV(x);
1179 rect.y = YLOG2DEV(y);
1180 rect.width = XLOG2DEVREL(width);
1181 rect.height = YLOG2DEVREL(height);
1182 gdk_gc_set_clip_rectangle( m_penGC, &rect );
1183 gdk_gc_set_clip_rectangle( m_brushGC, &rect );
1184 gdk_gc_set_clip_rectangle( m_textGC, &rect );
1185 gdk_gc_set_clip_rectangle( m_bgGC, &rect );
1186 }
1187
1188 void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion &region )
1189 {
1190 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1191
1192 if (region.Empty())
1193 {
1194 DestroyClippingRegion();
1195 return;
1196 }
1197
1198 if (!m_window) return;
1199
1200 gdk_gc_set_clip_region( m_penGC, region.GetRegion() );
1201 gdk_gc_set_clip_region( m_brushGC, region.GetRegion() );
1202 gdk_gc_set_clip_region( m_textGC, region.GetRegion() );
1203 gdk_gc_set_clip_region( m_bgGC, region.GetRegion() );
1204 }
1205
1206 void wxWindowDC::DestroyClippingRegion()
1207 {
1208 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1209
1210 wxDC::DestroyClippingRegion();
1211
1212 if (!m_window) return;
1213
1214 gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
1215 gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
1216 gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
1217 gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
1218 }
1219
1220 void wxWindowDC::SetUpDC()
1221 {
1222 Destroy();
1223 m_ok = TRUE;
1224 m_logicalFunction = wxCOPY;
1225 m_penGC = gdk_gc_new( m_window );
1226 m_brushGC = gdk_gc_new( m_window );
1227 m_textGC = gdk_gc_new( m_window );
1228 m_bgGC = gdk_gc_new( m_window );
1229
1230 wxColour tmp_col( m_textForegroundColour );
1231 m_textForegroundColour = wxNullColour;
1232 SetTextForeground( tmp_col );
1233 tmp_col = m_textBackgroundColour;
1234 m_textBackgroundColour = wxNullColour;
1235 SetTextBackground( tmp_col );
1236
1237 wxPen tmp_pen( m_pen );
1238 m_pen = wxNullPen;
1239 SetPen( tmp_pen );
1240
1241 wxFont tmp_font( m_font );
1242 m_font = wxNullFont;
1243 SetFont( tmp_font );
1244
1245 wxBrush tmp_brush( m_brush );
1246 m_brush = wxNullBrush;
1247 SetBrush( tmp_brush );
1248
1249 /*
1250 tmp_brush = m_backgroundBrush;
1251 m_backgroundBrush = wxNullBrush;
1252 SetBackground( tmp_brush );
1253 */
1254 tmp_brush = m_backgroundBrush;
1255 m_backgroundBrush = wxNullBrush;
1256 SetBackground( *wxWHITE_BRUSH );
1257 m_backgroundBrush = tmp_brush;
1258
1259 if (!hatch_bitmap)
1260 {
1261 hatch_bitmap = hatches;
1262 hatch_bitmap[0] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, bdiag_bits, bdiag_width, bdiag_height );
1263 hatch_bitmap[1] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cdiag_bits, cdiag_width, cdiag_height );
1264 hatch_bitmap[2] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, fdiag_bits, fdiag_width, fdiag_height );
1265 hatch_bitmap[3] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cross_bits, cross_width, cross_height );
1266 hatch_bitmap[4] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, horiz_bits, horiz_width, horiz_height );
1267 hatch_bitmap[5] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, verti_bits, verti_width, verti_height );
1268 }
1269 }
1270
1271 void wxWindowDC::Destroy()
1272 {
1273 if (m_penGC) gdk_gc_unref( m_penGC );
1274 m_penGC = (GdkGC*) NULL;
1275 if (m_brushGC) gdk_gc_unref( m_brushGC );
1276 m_brushGC = (GdkGC*) NULL;
1277 if (m_textGC) gdk_gc_unref( m_textGC );
1278 m_textGC = (GdkGC*) NULL;
1279 if (m_bgGC) gdk_gc_unref( m_bgGC );
1280 m_bgGC = (GdkGC*) NULL;
1281 }
1282
1283 void wxWindowDC::ComputeScaleAndOrigin()
1284 {
1285 /* CMB: copy scale to see if it changes */
1286 double origScaleX = m_scaleX;
1287 double origScaleY = m_scaleY;
1288
1289 wxDC::ComputeScaleAndOrigin();
1290
1291 /* CMB: if scale has changed call SetPen to recalulate the line width */
1292 if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&
1293 (m_pen.Ok()))
1294 {
1295 /* this is a bit artificial, but we need to force wxDC to think
1296 the pen has changed */
1297 wxPen pen = m_pen;
1298 m_pen = wxNullPen;
1299 SetPen( pen );
1300 }
1301 }
1302
1303 // Resolution in pixels per logical inch
1304 wxSize wxWindowDC::GetPPI() const
1305 {
1306 return wxSize(100, 100);
1307 }
1308
1309 int wxWindowDC::GetDepth() const
1310 {
1311 wxFAIL_MSG(wxT("not implemented"));
1312
1313 return -1;
1314 }
1315
1316 #if wxUSE_SPLINES
1317 // ----------------------------------- spline code ----------------------------------------
1318
1319 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
1320 double a3, double b3, double a4, double b4);
1321 void wx_clear_stack();
1322 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
1323 double *y3, double *x4, double *y4);
1324 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
1325 double x4, double y4);
1326 static bool wx_spline_add_point(double x, double y);
1327 static void wx_spline_draw_point_array(wxDC *dc);
1328
1329 wxList wx_spline_point_list;
1330
1331 #define half(z1, z2) ((z1+z2)/2.0)
1332 #define THRESHOLD 5
1333
1334 /* iterative version */
1335
1336 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
1337 double b4)
1338 {
1339 register double xmid, ymid;
1340 double x1, y1, x2, y2, x3, y3, x4, y4;
1341
1342 wx_clear_stack();
1343 wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
1344
1345 while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
1346 xmid = (double)half(x2, x3);
1347 ymid = (double)half(y2, y3);
1348 if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
1349 fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
1350 wx_spline_add_point( x1, y1 );
1351 wx_spline_add_point( xmid, ymid );
1352 } else {
1353 wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
1354 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
1355 wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
1356 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
1357 }
1358 }
1359 }
1360
1361 /* utilities used by spline drawing routines */
1362
1363 typedef struct wx_spline_stack_struct {
1364 double x1, y1, x2, y2, x3, y3, x4, y4;
1365 } Stack;
1366
1367 #define SPLINE_STACK_DEPTH 20
1368 static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
1369 static Stack *wx_stack_top;
1370 static int wx_stack_count;
1371
1372 void wx_clear_stack()
1373 {
1374 wx_stack_top = wx_spline_stack;
1375 wx_stack_count = 0;
1376 }
1377
1378 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
1379 {
1380 wx_stack_top->x1 = x1;
1381 wx_stack_top->y1 = y1;
1382 wx_stack_top->x2 = x2;
1383 wx_stack_top->y2 = y2;
1384 wx_stack_top->x3 = x3;
1385 wx_stack_top->y3 = y3;
1386 wx_stack_top->x4 = x4;
1387 wx_stack_top->y4 = y4;
1388 wx_stack_top++;
1389 wx_stack_count++;
1390 }
1391
1392 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
1393 double *x3, double *y3, double *x4, double *y4)
1394 {
1395 if (wx_stack_count == 0)
1396 return (0);
1397 wx_stack_top--;
1398 wx_stack_count--;
1399 *x1 = wx_stack_top->x1;
1400 *y1 = wx_stack_top->y1;
1401 *x2 = wx_stack_top->x2;
1402 *y2 = wx_stack_top->y2;
1403 *x3 = wx_stack_top->x3;
1404 *y3 = wx_stack_top->y3;
1405 *x4 = wx_stack_top->x4;
1406 *y4 = wx_stack_top->y4;
1407 return (1);
1408 }
1409
1410 static bool wx_spline_add_point(double x, double y)
1411 {
1412 wxPoint *point = new wxPoint ;
1413 point->x = (int) x;
1414 point->y = (int) y;
1415 wx_spline_point_list.Append((wxObject*)point);
1416 return TRUE;
1417 }
1418
1419 static void wx_spline_draw_point_array(wxDC *dc)
1420 {
1421 dc->DrawLines(&wx_spline_point_list, 0, 0 );
1422 wxNode *node = wx_spline_point_list.First();
1423 while (node)
1424 {
1425 wxPoint *point = (wxPoint *)node->Data();
1426 delete point;
1427 delete node;
1428 node = wx_spline_point_list.First();
1429 }
1430 }
1431
1432 void wxWindowDC::DoDrawSpline( wxList *points )
1433 {
1434 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1435
1436 wxPoint *p;
1437 double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
1438 double x1, y1, x2, y2;
1439
1440 wxNode *node = points->First();
1441 p = (wxPoint *)node->Data();
1442
1443 x1 = p->x;
1444 y1 = p->y;
1445
1446 node = node->Next();
1447 p = (wxPoint *)node->Data();
1448
1449 x2 = p->x;
1450 y2 = p->y;
1451 cx1 = (double)((x1 + x2) / 2);
1452 cy1 = (double)((y1 + y2) / 2);
1453 cx2 = (double)((cx1 + x2) / 2);
1454 cy2 = (double)((cy1 + y2) / 2);
1455
1456 wx_spline_add_point(x1, y1);
1457
1458 while ((node = node->Next()) != NULL)
1459 {
1460 p = (wxPoint *)node->Data();
1461 x1 = x2;
1462 y1 = y2;
1463 x2 = p->x;
1464 y2 = p->y;
1465 cx4 = (double)(x1 + x2) / 2;
1466 cy4 = (double)(y1 + y2) / 2;
1467 cx3 = (double)(x1 + cx4) / 2;
1468 cy3 = (double)(y1 + cy4) / 2;
1469
1470 wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
1471
1472 cx1 = cx4;
1473 cy1 = cy4;
1474 cx2 = (double)(cx1 + x2) / 2;
1475 cy2 = (double)(cy1 + y2) / 2;
1476 }
1477
1478 wx_spline_add_point( cx1, cy1 );
1479 wx_spline_add_point( x2, y2 );
1480
1481 wx_spline_draw_point_array( this );
1482 }
1483
1484 #endif // wxUSE_SPLINE
1485
1486 //-----------------------------------------------------------------------------
1487 // wxPaintDC
1488 //-----------------------------------------------------------------------------
1489
1490 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC,wxWindowDC)
1491
1492 wxPaintDC::wxPaintDC()
1493 : wxWindowDC()
1494 {
1495 }
1496
1497 wxPaintDC::wxPaintDC( wxWindow *win )
1498 : wxWindowDC( win )
1499 {
1500 }
1501
1502 //-----------------------------------------------------------------------------
1503 // wxClientDC
1504 //-----------------------------------------------------------------------------
1505
1506 IMPLEMENT_DYNAMIC_CLASS(wxClientDC,wxWindowDC)
1507
1508 wxClientDC::wxClientDC()
1509 : wxWindowDC()
1510 {
1511 }
1512
1513 wxClientDC::wxClientDC( wxWindow *win )
1514 : wxWindowDC( win )
1515 {
1516 }
1517
wxWidgets (Impactor)