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