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