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