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