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