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