]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/dcclient.cpp
projects / wxWidgets.git / blob
? search:


a7c10579f31d5db6518ad9b118c4183228343728
[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 // If the pen is transparent pen we increase the size
959 // for better compatibility with other platforms.
960 if (m_pen.GetStyle() == wxPENSTYLE_TRANSPARENT)
961 {
962 ++ww;
963 ++hh;
964 }
965
966 gdk_draw_arc(m_gdkwindow, gc, true, xx, yy, ww, hh, 0, 360*64);
967
968 if (originChanged)
969 gdk_gc_set_ts_origin(gc, 0, 0);
970 }
971
972 if (m_pen.GetStyle() != wxPENSTYLE_TRANSPARENT)
973 gdk_draw_arc( m_gdkwindow, m_penGC, false, xx, yy, ww, hh, 0, 360*64 );
974 }
975
976 CalcBoundingBox( x, y );
977 CalcBoundingBox( x + width, y + height );
978 }
979
980 void wxWindowDCImpl::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
981 {
982 // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
983 DoDrawBitmap( (const wxBitmap&)icon, x, y, true );
984 }
985
986 // compare to current clipping region
987 bool wxWindowDCImpl::IsOutsideOfClippingRegion(int x, int y, int w, int h)
988 {
989 if (m_currentClippingRegion.IsNull())
990 return false;
991
992 wxRegion region(x, y, w, h);
993 region.Intersect( m_currentClippingRegion );
994 return region.IsEmpty();
995 }
996
997 void wxWindowDCImpl::RemoveClipMask(GdkGC *gc)
998 {
999 gdk_gc_set_clip_mask(gc, NULL);
1000 gdk_gc_set_clip_origin(gc, 0, 0);
1001 if (!m_currentClippingRegion.IsNull())
1002 gdk_gc_set_clip_region(gc, m_currentClippingRegion.GetRegion());
1003 }
1004
1005 // For drawing a mono-bitmap (XBitmap) we use the current text GC
1006 void wxWindowDCImpl::DoDrawMonoBitmap(const wxBitmap& bitmap,
1007 int bmp_w, int bmp_h,
1008 int xsrc, int ysrc,
1009 int xdest, int ydest,
1010 int width, int height)
1011 {
1012 wxGtkObject<GdkPixmap>
1013 bitmap2(gdk_pixmap_new( wxGetRootWindow()->window, bmp_w, bmp_h, -1 ));
1014 wxGtkObject<GdkGC> gc(gdk_gc_new( bitmap2 ));
1015 gdk_gc_set_foreground( gc, m_textForegroundColour.GetColor() );
1016 gdk_gc_set_background( gc, m_textBackgroundColour.GetColor() );
1017 gdk_wx_draw_bitmap(bitmap2, gc, bitmap.GetPixmap(), 0, 0);
1018
1019 gdk_draw_drawable(m_gdkwindow, m_textGC, bitmap2, xsrc, ysrc, xdest, ydest,
1020 width, height);
1021 }
1022
1023 // Returns a new mask that is the intersection of the old mask
1024 // and m_currentClippingRegion with proper offsets
1025 GdkBitmap* wxWindowDCImpl::GetClippedMask(GdkBitmap* mask, int w, int h,
1026 int x, int y,
1027 int xsrcMask, int ysrcMask)
1028 {
1029 // create monochrome bitmap that will be used as the new mask
1030 GdkBitmap *new_mask = gdk_pixmap_new( wxGetRootWindow()->window, w, h, 1 );
1031
1032 GdkColor c0, c1;
1033 c0.pixel = 0;
1034 c1.pixel = 1;
1035 wxGtkObject<GdkGC> gc(gdk_gc_new( new_mask ));
1036
1037 // zero-ing new_mask
1038 gdk_gc_set_foreground( gc, &c0 );
1039 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, w, h );
1040
1041 // clipping region
1042 gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
1043 gdk_gc_set_clip_origin( gc, -x, -y );
1044
1045 // copy the old mask to the new_mask in the clip region area
1046 gdk_gc_set_background( gc, &c0 );
1047 gdk_gc_set_foreground( gc, &c1 );
1048 gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
1049 gdk_gc_set_ts_origin( gc, -xsrcMask, -ysrcMask );
1050 gdk_gc_set_stipple( gc, mask );
1051 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, w, h );
1052
1053 return new_mask;
1054 }
1055
1056 void wxWindowDCImpl::DoDrawBitmap( const wxBitmap &bitmap,
1057 wxCoord x, wxCoord y,
1058 bool useMask )
1059 {
1060 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1061
1062 wxCHECK_RET( bitmap.IsOk(), wxT("invalid bitmap") );
1063
1064 bool is_mono = bitmap.GetDepth() == 1;
1065
1066 // scale/translate size and position
1067 int xx = XLOG2DEV(x);
1068 int yy = YLOG2DEV(y);
1069
1070 int w = bitmap.GetWidth();
1071 int h = bitmap.GetHeight();
1072
1073 CalcBoundingBox( x, y );
1074 CalcBoundingBox( x + w, y + h );
1075
1076 if (!m_gdkwindow) return;
1077
1078 int ww = XLOG2DEVREL(w);
1079 int hh = YLOG2DEVREL(h);
1080
1081 if (m_window && m_window->GetLayoutDirection() == wxLayout_RightToLeft)
1082 xx -= ww;
1083
1084 if (IsOutsideOfClippingRegion( xx,yy,ww,hh ))
1085 return;
1086
1087 // scale bitmap if required
1088 wxBitmap use_bitmap = bitmap;
1089 if ((w != ww) || (h != hh))
1090 use_bitmap = use_bitmap.Rescale( 0, 0, w, h, ww, hh );
1091
1092 // get mask if any
1093 GdkBitmap *mask = (GdkBitmap *) NULL;
1094 if (useMask && use_bitmap.GetMask())
1095 mask = use_bitmap.GetMask()->GetBitmap();
1096
1097 // for drawing a mono-bitmap we use the current text GC
1098 GdkGC* use_gc = is_mono ? m_textGC : m_penGC;
1099
1100 bool mask_owned = false;
1101
1102 if (mask != NULL)
1103 {
1104 if (!m_currentClippingRegion.IsNull())
1105 {
1106 mask = GetClippedMask(mask, ww, hh, xx, yy, 0, 0);
1107 mask_owned = true;
1108 }
1109
1110 gdk_gc_set_clip_mask(use_gc, mask);
1111 gdk_gc_set_clip_origin(use_gc, xx, yy);
1112 }
1113
1114 // Draw XPixmap or XBitmap, depending on what the wxBitmap contains.
1115 if (is_mono)
1116 {
1117 DoDrawMonoBitmap(use_bitmap, ww, hh, 0, 0, xx, yy, -1, -1);
1118 }
1119 else
1120 {
1121 if (use_bitmap.HasPixbuf())
1122 {
1123 gdk_draw_pixbuf(m_gdkwindow, use_gc,
1124 use_bitmap.GetPixbuf(),
1125 0, 0, xx, yy, -1, -1,
1126 GDK_RGB_DITHER_NORMAL, xx, yy);
1127 }
1128 else
1129 {
1130 gdk_draw_drawable(m_gdkwindow, use_gc,
1131 use_bitmap.GetPixmap(),
1132 0, 0, xx, yy, -1, -1);
1133 }
1134 }
1135
1136 // remove mask again if any
1137 if (mask != NULL)
1138 {
1139 RemoveClipMask(use_gc);
1140 if (mask_owned)
1141 g_object_unref(mask);
1142 }
1143 }
1144
1145 bool wxWindowDCImpl::DoBlit( wxCoord xdest, wxCoord ydest,
1146 wxCoord width, wxCoord height,
1147 wxDC *source,
1148 wxCoord xsrc, wxCoord ysrc,
1149 int logical_func,
1150 bool useMask,
1151 wxCoord xsrcMask, wxCoord ysrcMask )
1152 {
1153 wxCHECK_MSG( IsOk(), false, wxT("invalid window dc") );
1154
1155 wxCHECK_MSG( source, false, wxT("invalid source dc") );
1156
1157 if (!m_gdkwindow) return false;
1158
1159 // transform the source DC coords to the device ones
1160 xsrc = source->LogicalToDeviceX(xsrc);
1161 ysrc = source->LogicalToDeviceY(ysrc);
1162
1163 wxBitmap selected;
1164 wxMemoryDC *memDC = wxDynamicCast(source, wxMemoryDC);
1165 if ( memDC )
1166 {
1167 selected = memDC->GetSelectedBitmap();
1168 if ( !selected.IsOk() )
1169 return false;
1170 }
1171
1172 bool use_bitmap_method = false;
1173 bool is_mono = false;
1174
1175 if (xsrcMask == -1 && ysrcMask == -1)
1176 {
1177 xsrcMask = xsrc;
1178 ysrcMask = ysrc;
1179 }
1180
1181 if (selected.IsOk())
1182 {
1183 is_mono = (selected.GetDepth() == 1);
1184
1185 // we use the "XCopyArea" way to copy a memory dc into
1186 // a different window if the memory dc BOTH
1187 // a) doesn't have any mask or its mask isn't used
1188 // b) it is clipped
1189 // c) is not 1-bit
1190
1191 if (useMask && (selected.GetMask()))
1192 {
1193 // we HAVE TO use the direct way for memory dcs
1194 // that have mask since the XCopyArea doesn't know
1195 // about masks
1196 use_bitmap_method = true;
1197 }
1198 else if (is_mono)
1199 {
1200 // we HAVE TO use the direct way for memory dcs
1201 // that are bitmaps because XCopyArea doesn't cope
1202 // with different bit depths
1203 use_bitmap_method = true;
1204 }
1205 else if ((xsrc == 0) && (ysrc == 0) &&
1206 (width == selected.GetWidth()) &&
1207 (height == selected.GetHeight()))
1208 {
1209 // we SHOULD use the direct way if all of the bitmap
1210 // in the memory dc is copied in which case XCopyArea
1211 // wouldn't be able able to boost performace by reducing
1212 // the area to be scaled
1213 use_bitmap_method = true;
1214 }
1215 }
1216
1217 CalcBoundingBox( xdest, ydest );
1218 CalcBoundingBox( xdest + width, ydest + height );
1219
1220 // scale/translate size and position
1221 wxCoord xx = XLOG2DEV(xdest);
1222 wxCoord yy = YLOG2DEV(ydest);
1223
1224 wxCoord ww = XLOG2DEVREL(width);
1225 wxCoord hh = YLOG2DEVREL(height);
1226
1227 // compare to current clipping region
1228 if (IsOutsideOfClippingRegion( xx,yy,ww,hh ))
1229 return true;
1230
1231 int old_logical_func = m_logicalFunction;
1232 SetLogicalFunction( logical_func );
1233
1234 if (use_bitmap_method)
1235 {
1236 // scale/translate bitmap size
1237 wxCoord bm_width = selected.GetWidth();
1238 wxCoord bm_height = selected.GetHeight();
1239
1240 // Get clip coords for the bitmap. If we don't
1241 // use wxBitmap::Rescale(), which can clip the
1242 // bitmap, these are the same as the original
1243 // coordinates
1244 wxCoord cx = xx;
1245 wxCoord cy = yy;
1246 wxCoord cw = ww;
1247 wxCoord ch = hh;
1248
1249 // interpret userscale of src too
1250 double xsc,ysc;
1251 memDC->GetUserScale(&xsc,&ysc);
1252 bm_width = (int) (bm_width / xsc);
1253 bm_height = (int) (bm_height / ysc);
1254
1255 wxCoord bm_ww = XLOG2DEVREL( bm_width );
1256 wxCoord bm_hh = YLOG2DEVREL( bm_height );
1257
1258 // Scale bitmap if required
1259 wxBitmap use_bitmap = selected;
1260 if ((selected.GetWidth()!= bm_ww) || ( selected.GetHeight()!= bm_hh))
1261 {
1262 // This indicates that the blitting code below will get
1263 // a clipped bitmap and therefore needs to move the origin
1264 // accordingly
1265 wxRegion tmp( xx,yy,ww,hh );
1266 if (!m_currentClippingRegion.IsNull())
1267 tmp.Intersect( m_currentClippingRegion );
1268 tmp.GetBox(cx,cy,cw,ch);
1269
1270 // Scale and clipped bitmap
1271 use_bitmap = selected.Rescale(cx-xx,cy-yy,cw,ch,bm_ww,bm_hh);
1272 }
1273
1274 // apply mask if any
1275 GdkBitmap *mask = (GdkBitmap *) NULL;
1276 if (useMask && use_bitmap.GetMask())
1277 mask = use_bitmap.GetMask()->GetBitmap();
1278
1279 GdkGC* use_gc = is_mono ? m_textGC : m_penGC;
1280
1281 bool mask_owned = false;
1282
1283 if (mask != NULL)
1284 {
1285 if (!m_currentClippingRegion.IsNull())
1286 {
1287 mask = GetClippedMask(mask, bm_ww, bm_hh, cx, cy,
1288 xsrcMask, ysrcMask);
1289 mask_owned = true;
1290 }
1291
1292 gdk_gc_set_clip_mask(use_gc, mask);
1293 if (mask_owned)
1294 gdk_gc_set_clip_origin(use_gc, cx, cy);
1295 else
1296 gdk_gc_set_clip_origin(use_gc, cx - xsrcMask, cy - ysrcMask);
1297 }
1298
1299 // Draw XPixmap or XBitmap, depending on what the wxBitmap contains.
1300 if (is_mono)
1301 {
1302 DoDrawMonoBitmap(use_bitmap, bm_ww, bm_hh,
1303 xsrc, ysrc, cx, cy, cw, ch);
1304 }
1305 else
1306 {
1307 // was: gdk_draw_drawable( m_gdkwindow, m_penGC, use_bitmap.GetPixmap(), xsrc, ysrc, xx, yy, ww, hh );
1308 gdk_draw_drawable(m_gdkwindow, use_gc, use_bitmap.GetPixmap(), xsrc, ysrc, cx, cy, cw, ch);
1309 }
1310
1311 // remove mask again if any
1312 if (mask != NULL)
1313 {
1314 RemoveClipMask(use_gc);
1315 if (mask_owned)
1316 g_object_unref (mask);
1317 }
1318 }
1319 else // use_bitmap_method
1320 {
1321 if (selected.IsOk() && ((width != ww) || (height != hh)))
1322 {
1323 wxBitmap bitmap = selected.Rescale( xsrc, ysrc, width, height, ww, hh );
1324 // draw scaled bitmap
1325 gdk_draw_drawable( m_gdkwindow, m_penGC, bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
1326 }
1327 else
1328 {
1329 // No scaling and not a memory dc with a mask either
1330 GdkWindow* window = NULL;
1331 wxDCImpl *impl = source->GetImpl();
1332 wxWindowDCImpl *gtk_impl = wxDynamicCast(impl, wxWindowDCImpl);
1333 if (gtk_impl)
1334 window = gtk_impl->GetGDKWindow();
1335 if ( !window )
1336 {
1337 SetLogicalFunction( old_logical_func );
1338 return false;
1339 }
1340
1341 // copy including child window contents
1342 gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
1343 gdk_draw_drawable( m_gdkwindow, m_penGC,
1344 window,
1345 xsrc, ysrc, xx, yy,
1346 width, height );
1347 gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
1348 }
1349 }
1350
1351 SetLogicalFunction( old_logical_func );
1352
1353 return true;
1354 }
1355
1356 void wxWindowDCImpl::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
1357 {
1358 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1359
1360 if (!m_gdkwindow) return;
1361
1362 if (text.empty()) return;
1363
1364 x = XLOG2DEV(x);
1365 y = YLOG2DEV(y);
1366
1367 wxCHECK_RET( m_context, wxT("no Pango context") );
1368 wxCHECK_RET( m_layout, wxT("no Pango layout") );
1369 wxCHECK_RET( m_fontdesc, wxT("no Pango font description") );
1370
1371 gdk_pango_context_set_colormap( m_context, m_cmap ); // not needed in gtk+ >= 2.6
1372
1373 bool underlined = m_font.IsOk() && m_font.GetUnderlined();
1374
1375 wxCharBuffer data = wxGTK_CONV(text);
1376 if ( !data )
1377 return;
1378 size_t datalen = strlen(data);
1379
1380 // in Pango >= 1.16 the "underline of leading/trailing spaces" bug
1381 // has been fixed and thus the hack implemented below should never be used
1382 static bool pangoOk = !wx_pango_version_check(1, 16, 0);
1383
1384 bool needshack = underlined && !pangoOk;
1385
1386 if (needshack)
1387 {
1388 // a PangoLayout which has leading/trailing spaces with underlined font
1389 // is not correctly drawn by this pango version: Pango won't underline the spaces.
1390 // This can be a problem; e.g. wxHTML rendering of underlined text relies on
1391 // this behaviour. To workaround this problem, we use a special hack here
1392 // suggested by pango maintainer Behdad Esfahbod: we prepend and append two
1393 // empty space characters and give them a dummy colour attribute.
1394 // This will force Pango to underline the leading/trailing spaces, too.
1395
1396 wxCharBuffer data_tmp(datalen + 6);
1397 // copy the leading U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
1398 memcpy(data_tmp.data(), "\342\200\214", 3);
1399 // copy the user string
1400 memcpy(data_tmp.data() + 3, data, datalen);
1401 // copy the trailing U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
1402 memcpy(data_tmp.data() + 3 + datalen, "\342\200\214", 3);
1403
1404 data = data_tmp;
1405 datalen += 6;
1406 }
1407
1408 pango_layout_set_text(m_layout, data, datalen);
1409
1410 if (underlined)
1411 {
1412 PangoAttrList *attrs = pango_attr_list_new();
1413 PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
1414 a->start_index = 0;
1415 a->end_index = datalen;
1416 pango_attr_list_insert(attrs, a);
1417
1418 if (needshack)
1419 {
1420 // dummy colour for the leading space
1421 a = pango_attr_foreground_new (0x0057, 0x52A9, 0xD614);
1422 a->start_index = 0;
1423 a->end_index = 1;
1424 pango_attr_list_insert(attrs, a);
1425
1426 // dummy colour for the trailing space
1427 a = pango_attr_foreground_new (0x0057, 0x52A9, 0xD614);
1428 a->start_index = datalen - 1;
1429 a->end_index = datalen;
1430 pango_attr_list_insert(attrs, a);
1431 }
1432
1433 pango_layout_set_attributes(m_layout, attrs);
1434 pango_attr_list_unref(attrs);
1435 }
1436
1437 int oldSize = 0;
1438 const bool isScaled = fabs(m_scaleY - 1.0) > 0.00001;
1439 if (isScaled)
1440 {
1441 // If there is a user or actually any scale applied to
1442 // the device context, scale the font.
1443
1444 // scale font description
1445 oldSize = pango_font_description_get_size(m_fontdesc);
1446 pango_font_description_set_size(m_fontdesc, int(oldSize * m_scaleY));
1447
1448 // actually apply scaled font
1449 pango_layout_set_font_description( m_layout, m_fontdesc );
1450 }
1451
1452 int w, h;
1453 pango_layout_get_pixel_size(m_layout, &w, &h);
1454
1455 // Draw layout.
1456 int x_rtl = x;
1457 if (m_window && m_window->GetLayoutDirection() == wxLayout_RightToLeft)
1458 x_rtl -= w;
1459
1460 const GdkColor* bg_col = NULL;
1461 if (m_backgroundMode == wxBRUSHSTYLE_SOLID)
1462 bg_col = m_textBackgroundColour.GetColor();
1463
1464 gdk_draw_layout_with_colors(m_gdkwindow, m_textGC, x_rtl, y, m_layout, NULL, bg_col);
1465
1466 if (isScaled)
1467 {
1468 // reset unscaled size
1469 pango_font_description_set_size( m_fontdesc, oldSize );
1470
1471 // actually apply unscaled font
1472 pango_layout_set_font_description( m_layout, m_fontdesc );
1473 }
1474 if (underlined)
1475 {
1476 // undo underline attributes setting:
1477 pango_layout_set_attributes(m_layout, NULL);
1478 }
1479
1480 CalcBoundingBox(x + int(w / m_scaleX), y + int(h / m_scaleY));
1481 CalcBoundingBox(x, y);
1482 }
1483
1484 // TODO: When GTK2.6 is required, merge DoDrawText and DoDrawRotatedText to
1485 // avoid code duplication
1486 void wxWindowDCImpl::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
1487 {
1488 if (!m_gdkwindow || text.empty())
1489 return;
1490
1491 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1492
1493 #if __WXGTK26__
1494 if (!gtk_check_version(2,6,0))
1495 {
1496 x = XLOG2DEV(x);
1497 y = YLOG2DEV(y);
1498
1499 pango_layout_set_text(m_layout, wxGTK_CONV(text), -1);
1500
1501 if (m_font.GetUnderlined())
1502 {
1503 PangoAttrList *attrs = pango_attr_list_new();
1504 PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
1505 pango_attr_list_insert(attrs, a);
1506 pango_layout_set_attributes(m_layout, attrs);
1507 pango_attr_list_unref(attrs);
1508 }
1509
1510 int oldSize = 0;
1511 const bool isScaled = fabs(m_scaleY - 1.0) > 0.00001;
1512 if (isScaled)
1513 {
1514 //TODO: when Pango >= 1.6 is required, use pango_matrix_scale()
1515 // If there is a user or actually any scale applied to
1516 // the device context, scale the font.
1517
1518 // scale font description
1519 oldSize = pango_font_description_get_size(m_fontdesc);
1520 pango_font_description_set_size(m_fontdesc, int(oldSize * m_scaleY));
1521
1522 // actually apply scaled font
1523 pango_layout_set_font_description( m_layout, m_fontdesc );
1524 }
1525
1526 int w, h;
1527 pango_layout_get_pixel_size(m_layout, &w, &h);
1528
1529 const GdkColor* bg_col = NULL;
1530 if (m_backgroundMode == wxBRUSHSTYLE_SOLID)
1531 bg_col = m_textBackgroundColour.GetColor();
1532
1533 // rotate the text
1534 PangoMatrix matrix = PANGO_MATRIX_INIT;
1535 pango_matrix_rotate (&matrix, angle);
1536 pango_context_set_matrix (m_context, &matrix);
1537 pango_layout_context_changed (m_layout);
1538
1539 // To be compatible with MSW, the rotation axis must be in the old
1540 // top-left corner.
1541 // Calculate the vertices of the rotated rectangle containing the text,
1542 // relative to the old top-left vertex.
1543 // We could use the matrix for this, but it's simpler with trignonometry.
1544 double rad = DegToRad(angle);
1545 // the rectangle vertices are counted clockwise with the first one
1546 // being at (0, 0)
1547 double x2 = w * cos(rad);
1548 double y2 = -w * sin(rad); // y axis points to the bottom, hence minus
1549 double x4 = h * sin(rad);
1550 double y4 = h * cos(rad);
1551 double x3 = x4 + x2;
1552 double y3 = y4 + y2;
1553 // Then we calculate max and min of the rotated rectangle.
1554 wxCoord maxX = (wxCoord)(dmax(dmax(0, x2), dmax(x3, x4)) + 0.5),
1555 maxY = (wxCoord)(dmax(dmax(0, y2), dmax(y3, y4)) + 0.5),
1556 minX = (wxCoord)(dmin(dmin(0, x2), dmin(x3, x4)) - 0.5),
1557 minY = (wxCoord)(dmin(dmin(0, y2), dmin(y3, y4)) - 0.5);
1558
1559 gdk_draw_layout_with_colors(m_gdkwindow, m_textGC, x+minX, y+minY,
1560 m_layout, NULL, bg_col);
1561
1562 if (m_font.GetUnderlined())
1563 pango_layout_set_attributes(m_layout, NULL);
1564
1565 // clean up the transformation matrix
1566 pango_context_set_matrix(m_context, NULL);
1567
1568 if (isScaled)
1569 {
1570 // reset unscaled size
1571 pango_font_description_set_size( m_fontdesc, oldSize );
1572
1573 // actually apply unscaled font
1574 pango_layout_set_font_description( m_layout, m_fontdesc );
1575 }
1576
1577 CalcBoundingBox(x+minX, y+minY);
1578 CalcBoundingBox(x+maxX, y+maxY);
1579 }
1580 else
1581 #endif //__WXGTK26__
1582 {
1583 #if wxUSE_IMAGE
1584 if ( wxIsNullDouble(angle) )
1585 {
1586 DoDrawText(text, x, y);
1587 return;
1588 }
1589
1590 wxCoord w;
1591 wxCoord h;
1592
1593 // TODO: implement later without GdkFont for GTK 2.0
1594 DoGetTextExtent(text, &w, &h, NULL,NULL, &m_font);
1595
1596 // draw the string normally
1597 wxBitmap src(w, h);
1598 wxMemoryDC dc;
1599 dc.SelectObject(src);
1600 dc.SetFont(GetFont());
1601 dc.SetBackground(*wxBLACK_BRUSH);
1602 dc.SetBrush(*wxBLACK_BRUSH);
1603 dc.Clear();
1604 dc.SetTextForeground( *wxWHITE );
1605 dc.DrawText(text, 0, 0);
1606 dc.SelectObject(wxNullBitmap);
1607
1608 // Calculate the size of the rotated bounding box.
1609 double rad = DegToRad(angle);
1610 double dx = cos(rad),
1611 dy = sin(rad);
1612
1613 // the rectngle vertices are counted clockwise with the first one being at
1614 // (0, 0) (or, rather, at (x, y))
1615 double x2 = w*dx,
1616 y2 = -w*dy; // y axis points to the bottom, hence minus
1617 double x4 = h*dy,
1618 y4 = h*dx;
1619 double x3 = x4 + x2,
1620 y3 = y4 + y2;
1621
1622 // calc max and min
1623 wxCoord maxX = (wxCoord)(dmax(x2, dmax(x3, x4)) + 0.5),
1624 maxY = (wxCoord)(dmax(y2, dmax(y3, y4)) + 0.5),
1625 minX = (wxCoord)(dmin(x2, dmin(x3, x4)) - 0.5),
1626 minY = (wxCoord)(dmin(y2, dmin(y3, y4)) - 0.5);
1627
1628
1629 wxImage image = src.ConvertToImage();
1630
1631 image.ConvertColourToAlpha( m_textForegroundColour.Red(),
1632 m_textForegroundColour.Green(),
1633 m_textForegroundColour.Blue() );
1634 image = image.Rotate( rad, wxPoint(0,0) );
1635
1636 int i_angle = (int) angle;
1637 i_angle = i_angle % 360;
1638 if (i_angle < 0)
1639 i_angle += 360;
1640 int xoffset = 0;
1641 if ((i_angle >= 90.0) && (i_angle < 270.0))
1642 xoffset = image.GetWidth();
1643 int yoffset = 0;
1644 if ((i_angle >= 0.0) && (i_angle < 180.0))
1645 yoffset = image.GetHeight();
1646
1647 if ((i_angle >= 0) && (i_angle < 90))
1648 yoffset -= (int)( cos(rad)*h );
1649 if ((i_angle >= 90) && (i_angle < 180))
1650 xoffset -= (int)( sin(rad)*h );
1651 if ((i_angle >= 180) && (i_angle < 270))
1652 yoffset -= (int)( cos(rad)*h );
1653 if ((i_angle >= 270) && (i_angle < 360))
1654 xoffset -= (int)( sin(rad)*h );
1655
1656 int i_x = x - xoffset;
1657 int i_y = y - yoffset;
1658
1659 src = image;
1660 DoDrawBitmap( src, i_x, i_y, true );
1661
1662
1663 // it would be better to draw with non underlined font and draw the line
1664 // manually here (it would be more straight...)
1665 #if 0
1666 if ( m_font.GetUnderlined() )
1667 {
1668 gdk_draw_line( m_gdkwindow, m_textGC,
1669 XLOG2DEV(x + x4), YLOG2DEV(y + y4 + font->descent),
1670 XLOG2DEV(x + x3), YLOG2DEV(y + y3 + font->descent));
1671 }
1672 #endif // 0
1673
1674 // update the bounding box
1675 CalcBoundingBox(x + minX, y + minY);
1676 CalcBoundingBox(x + maxX, y + maxY);
1677 #else // !wxUSE_IMAGE
1678 wxUnusedVar(text);
1679 wxUnusedVar(x);
1680 wxUnusedVar(y);
1681 wxUnusedVar(angle);
1682 #endif // wxUSE_IMAGE/!wxUSE_IMAGE
1683 }
1684 }
1685
1686 void wxWindowDCImpl::DoGetTextExtent(const wxString &string,
1687 wxCoord *width, wxCoord *height,
1688 wxCoord *descent, wxCoord *externalLeading,
1689 const wxFont *theFont) const
1690 {
1691 if ( width )
1692 *width = 0;
1693 if ( height )
1694 *height = 0;
1695 if ( descent )
1696 *descent = 0;
1697 if ( externalLeading )
1698 *externalLeading = 0;
1699
1700 if (string.empty())
1701 return;
1702
1703 // ensure that theFont is always non-NULL
1704 if ( !theFont || !theFont->IsOk() )
1705 theFont = &m_font;
1706
1707 // and use it if it's valid
1708 if ( theFont->IsOk() )
1709 {
1710 pango_layout_set_font_description
1711 (
1712 m_layout,
1713 theFont->GetNativeFontInfo()->description
1714 );
1715 }
1716
1717 // Set layout's text
1718 const wxCharBuffer dataUTF8 = wxGTK_CONV_FONT(string, *theFont);
1719 if ( !dataUTF8 )
1720 {
1721 // hardly ideal, but what else can we do if conversion failed?
1722 return;
1723 }
1724
1725 pango_layout_set_text(m_layout, dataUTF8, -1);
1726
1727 int h;
1728 pango_layout_get_pixel_size(m_layout, width, &h);
1729 if (descent)
1730 {
1731 PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
1732 int baseline = pango_layout_iter_get_baseline(iter);
1733 pango_layout_iter_free(iter);
1734 *descent = h - PANGO_PIXELS(baseline);
1735 }
1736 if (height)
1737 *height = h;
1738
1739 // Reset old font description
1740 if (theFont->IsOk())
1741 pango_layout_set_font_description( m_layout, m_fontdesc );
1742 }
1743
1744
1745 bool wxWindowDCImpl::DoGetPartialTextExtents(const wxString& text,
1746 wxArrayInt& widths) const
1747 {
1748 const size_t len = text.length();
1749 widths.Empty();
1750 widths.Add(0, len);
1751
1752 if (text.empty())
1753 return true;
1754
1755 // Set layout's text
1756 const wxCharBuffer dataUTF8 = wxGTK_CONV_FONT(text, m_font);
1757 if ( !dataUTF8 )
1758 {
1759 // hardly ideal, but what else can we do if conversion failed?
1760 wxLogLastError(wxT("DoGetPartialTextExtents"));
1761 return false;
1762 }
1763
1764 pango_layout_set_text(m_layout, dataUTF8, -1);
1765
1766 // Calculate the position of each character based on the widths of
1767 // the previous characters
1768
1769 // Code borrowed from Scintilla's PlatGTK
1770 PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
1771 PangoRectangle pos;
1772 pango_layout_iter_get_cluster_extents(iter, NULL, &pos);
1773 size_t i = 0;
1774 while (pango_layout_iter_next_cluster(iter))
1775 {
1776 pango_layout_iter_get_cluster_extents(iter, NULL, &pos);
1777 int position = PANGO_PIXELS(pos.x);
1778 widths[i++] = position;
1779 }
1780 while (i < len)
1781 widths[i++] = PANGO_PIXELS(pos.x + pos.width);
1782 pango_layout_iter_free(iter);
1783
1784 return true;
1785 }
1786
1787
1788 wxCoord wxWindowDCImpl::GetCharWidth() const
1789 {
1790 pango_layout_set_text( m_layout, "H", 1 );
1791 int w;
1792 pango_layout_get_pixel_size( m_layout, &w, NULL );
1793 return w;
1794 }
1795
1796 wxCoord wxWindowDCImpl::GetCharHeight() const
1797 {
1798 PangoFontMetrics *metrics = pango_context_get_metrics (m_context, m_fontdesc, pango_context_get_language(m_context));
1799 wxCHECK_MSG( metrics, -1, _T("failed to get pango font metrics") );
1800
1801 wxCoord h = PANGO_PIXELS (pango_font_metrics_get_descent (metrics) +
1802 pango_font_metrics_get_ascent (metrics));
1803 pango_font_metrics_unref (metrics);
1804 return h;
1805 }
1806
1807 void wxWindowDCImpl::Clear()
1808 {
1809 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1810
1811 if (!m_gdkwindow) return;
1812
1813 int width,height;
1814 DoGetSize( &width, &height );
1815 gdk_draw_rectangle( m_gdkwindow, m_bgGC, TRUE, 0, 0, width, height );
1816 }
1817
1818 void wxWindowDCImpl::SetFont( const wxFont &font )
1819 {
1820 m_font = font;
1821
1822 if (m_font.IsOk())
1823 {
1824 if (m_fontdesc)
1825 pango_font_description_free( m_fontdesc );
1826
1827 m_fontdesc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
1828
1829
1830 if (m_window)
1831 {
1832 PangoContext *oldContext = m_context;
1833
1834 m_context = m_window->GtkGetPangoDefaultContext();
1835
1836 // If we switch back/forth between different contexts
1837 // we also have to create a new layout. I think so,
1838 // at least, and it doesn't hurt to do it.
1839 if (oldContext != m_context)
1840 {
1841 if (m_layout)
1842 g_object_unref (m_layout);
1843
1844 m_layout = pango_layout_new( m_context );
1845 }
1846 }
1847
1848 pango_layout_set_font_description( m_layout, m_fontdesc );
1849 }
1850 }
1851
1852 void wxWindowDCImpl::SetPen( const wxPen &pen )
1853 {
1854 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1855
1856 if (m_pen == pen) return;
1857
1858 m_pen = pen;
1859
1860 if (!m_pen.IsOk()) return;
1861
1862 if (!m_gdkwindow) return;
1863
1864 gint width = m_pen.GetWidth();
1865 if (width <= 0)
1866 {
1867 // CMB: if width is non-zero scale it with the dc
1868 width = 1;
1869 }
1870 else
1871 {
1872 // X doesn't allow different width in x and y and so we take
1873 // the average
1874 double w = 0.5 +
1875 ( fabs((double) XLOG2DEVREL(width)) +
1876 fabs((double) YLOG2DEVREL(width)) ) / 2.0;
1877 width = (int)w;
1878 if ( !width )
1879 {
1880 // width can't be 0 or an internal GTK error occurs inside
1881 // gdk_gc_set_dashes() below
1882 width = 1;
1883 }
1884 }
1885
1886 static const wxGTKDash dotted[] = {1, 1};
1887 static const wxGTKDash short_dashed[] = {2, 2};
1888 static const wxGTKDash wxCoord_dashed[] = {2, 4};
1889 static const wxGTKDash dotted_dashed[] = {3, 3, 1, 3};
1890
1891 // We express dash pattern in pen width unit, so we are
1892 // independent of zoom factor and so on...
1893 int req_nb_dash;
1894 const wxGTKDash *req_dash;
1895
1896 GdkLineStyle lineStyle = GDK_LINE_ON_OFF_DASH;
1897 switch (m_pen.GetStyle())
1898 {
1899 case wxPENSTYLE_USER_DASH:
1900 req_nb_dash = m_pen.GetDashCount();
1901 req_dash = (wxGTKDash*)m_pen.GetDash();
1902 break;
1903 case wxPENSTYLE_DOT:
1904 req_nb_dash = 2;
1905 req_dash = dotted;
1906 break;
1907 case wxPENSTYLE_LONG_DASH:
1908 req_nb_dash = 2;
1909 req_dash = wxCoord_dashed;
1910 break;
1911 case wxPENSTYLE_SHORT_DASH:
1912 req_nb_dash = 2;
1913 req_dash = short_dashed;
1914 break;
1915 case wxPENSTYLE_DOT_DASH:
1916 req_nb_dash = 4;
1917 req_dash = dotted_dashed;
1918 break;
1919
1920 case wxPENSTYLE_TRANSPARENT:
1921 case wxPENSTYLE_STIPPLE_MASK_OPAQUE:
1922 case wxPENSTYLE_STIPPLE:
1923 case wxPENSTYLE_SOLID:
1924 default:
1925 lineStyle = GDK_LINE_SOLID;
1926 req_dash = (wxGTKDash*)NULL;
1927 req_nb_dash = 0;
1928 break;
1929 }
1930
1931 if (req_dash && req_nb_dash)
1932 {
1933 wxGTKDash *real_req_dash = new wxGTKDash[req_nb_dash];
1934 if (real_req_dash)
1935 {
1936 for (int i = 0; i < req_nb_dash; i++)
1937 real_req_dash[i] = req_dash[i] * width;
1938 gdk_gc_set_dashes( m_penGC, 0, real_req_dash, req_nb_dash );
1939 delete[] real_req_dash;
1940 }
1941 else
1942 {
1943 // No Memory. We use non-scaled dash pattern...
1944 gdk_gc_set_dashes( m_penGC, 0, (wxGTKDash*)req_dash, req_nb_dash );
1945 }
1946 }
1947
1948 GdkCapStyle capStyle = GDK_CAP_ROUND;
1949 switch (m_pen.GetCap())
1950 {
1951 case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; }
1952 case wxCAP_BUTT: { capStyle = GDK_CAP_BUTT; break; }
1953 case wxCAP_ROUND:
1954 default:
1955 if (width <= 1)
1956 {
1957 width = 0;
1958 capStyle = GDK_CAP_NOT_LAST;
1959 }
1960 break;
1961 }
1962
1963 GdkJoinStyle joinStyle = GDK_JOIN_ROUND;
1964 switch (m_pen.GetJoin())
1965 {
1966 case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; }
1967 case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; }
1968 case wxJOIN_ROUND:
1969 default: { joinStyle = GDK_JOIN_ROUND; break; }
1970 }
1971
1972 gdk_gc_set_line_attributes( m_penGC, width, lineStyle, capStyle, joinStyle );
1973
1974 m_pen.GetColour().CalcPixel( m_cmap );
1975 gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
1976 }
1977
1978 void wxWindowDCImpl::SetBrush( const wxBrush &brush )
1979 {
1980 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1981
1982 if (m_brush == brush) return;
1983
1984 m_brush = brush;
1985
1986 if (!m_brush.IsOk()) return;
1987
1988 if (!m_gdkwindow) return;
1989
1990 m_brush.GetColour().CalcPixel( m_cmap );
1991 gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
1992
1993 gdk_gc_set_fill( m_brushGC, GDK_SOLID );
1994
1995 if ((m_brush.GetStyle() == wxBRUSHSTYLE_STIPPLE) && (m_brush.GetStipple()->IsOk()))
1996 {
1997 if (m_brush.GetStipple()->GetDepth() != 1)
1998 {
1999 gdk_gc_set_fill( m_brushGC, GDK_TILED );
2000 gdk_gc_set_tile( m_brushGC, m_brush.GetStipple()->GetPixmap() );
2001 }
2002 else
2003 {
2004 gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
2005 gdk_gc_set_stipple( m_brushGC, m_brush.GetStipple()->GetPixmap() );
2006 }
2007 }
2008
2009 if ((m_brush.GetStyle() == wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
2010 {
2011 gdk_gc_set_fill( m_textGC, GDK_OPAQUE_STIPPLED);
2012 gdk_gc_set_stipple( m_textGC, m_brush.GetStipple()->GetMask()->GetBitmap() );
2013 }
2014
2015 if (m_brush.IsHatch())
2016 {
2017 gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
2018 gdk_gc_set_stipple(m_brushGC, GetHatch(m_brush.GetStyle()));
2019 }
2020 }
2021
2022 void wxWindowDCImpl::SetBackground( const wxBrush &brush )
2023 {
2024 /* CMB 21/7/98: Added SetBackground. Sets background brush
2025 * for Clear() and bg colour for shapes filled with cross-hatch brush */
2026
2027 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2028
2029 if (m_backgroundBrush == brush) return;
2030
2031 m_backgroundBrush = brush;
2032
2033 if (!m_backgroundBrush.IsOk()) return;
2034
2035 if (!m_gdkwindow) return;
2036
2037 wxColor color = m_backgroundBrush.GetColour();
2038 color.CalcPixel(m_cmap);
2039 const GdkColor* gdkColor = color.GetColor();
2040 gdk_gc_set_background(m_brushGC, gdkColor);
2041 gdk_gc_set_background(m_penGC, gdkColor);
2042 gdk_gc_set_background(m_bgGC, gdkColor);
2043 gdk_gc_set_foreground(m_bgGC, gdkColor);
2044
2045
2046 gdk_gc_set_fill( m_bgGC, GDK_SOLID );
2047
2048 if (m_backgroundBrush.GetStyle() == wxBRUSHSTYLE_STIPPLE)
2049 {
2050 const wxBitmap* stipple = m_backgroundBrush.GetStipple();
2051 if (stipple->IsOk())
2052 {
2053 if (stipple->GetDepth() != 1)
2054 {
2055 gdk_gc_set_fill(m_bgGC, GDK_TILED);
2056 gdk_gc_set_tile(m_bgGC, stipple->GetPixmap());
2057 }
2058 else
2059 {
2060 gdk_gc_set_fill(m_bgGC, GDK_STIPPLED);
2061 gdk_gc_set_stipple(m_bgGC, stipple->GetPixmap());
2062 }
2063 }
2064 }
2065 else if (m_backgroundBrush.IsHatch())
2066 {
2067 gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
2068 gdk_gc_set_stipple(m_bgGC, GetHatch(m_backgroundBrush.GetStyle()));
2069 }
2070 }
2071
2072 void wxWindowDCImpl::SetLogicalFunction( int function )
2073 {
2074 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2075
2076 if (m_logicalFunction == function)
2077 return;
2078
2079 // VZ: shouldn't this be a CHECK?
2080 if (!m_gdkwindow)
2081 return;
2082
2083 GdkFunction mode;
2084 switch (function)
2085 {
2086 case wxXOR: mode = GDK_XOR; break;
2087 case wxINVERT: mode = GDK_INVERT; break;
2088 case wxOR_REVERSE: mode = GDK_OR_REVERSE; break;
2089 case wxAND_REVERSE: mode = GDK_AND_REVERSE; break;
2090 case wxCLEAR: mode = GDK_CLEAR; break;
2091 case wxSET: mode = GDK_SET; break;
2092 case wxOR_INVERT: mode = GDK_OR_INVERT; break;
2093 case wxAND: mode = GDK_AND; break;
2094 case wxOR: mode = GDK_OR; break;
2095 case wxEQUIV: mode = GDK_EQUIV; break;
2096 case wxNAND: mode = GDK_NAND; break;
2097 case wxAND_INVERT: mode = GDK_AND_INVERT; break;
2098 case wxCOPY: mode = GDK_COPY; break;
2099 case wxNO_OP: mode = GDK_NOOP; break;
2100 case wxSRC_INVERT: mode = GDK_COPY_INVERT; break;
2101 case wxNOR: mode = GDK_NOR; break;
2102 default:
2103 wxFAIL_MSG( wxT("unsupported logical function") );
2104 mode = GDK_COPY;
2105 }
2106
2107 m_logicalFunction = function;
2108
2109 gdk_gc_set_function( m_penGC, mode );
2110 gdk_gc_set_function( m_brushGC, mode );
2111
2112 // to stay compatible with wxMSW, we don't apply ROPs to the text
2113 // operations (i.e. DrawText/DrawRotatedText).
2114 // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
2115 gdk_gc_set_function( m_textGC, mode );
2116 }
2117
2118 void wxWindowDCImpl::SetTextForeground( const wxColour &col )
2119 {
2120 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2121
2122 // don't set m_textForegroundColour to an invalid colour as we'd crash
2123 // later then (we use m_textForegroundColour.GetColor() without checking
2124 // in a few places)
2125 if ( !col.IsOk() || (m_textForegroundColour == col) )
2126 return;
2127
2128 m_textForegroundColour = col;
2129
2130 if ( m_gdkwindow )
2131 {
2132 m_textForegroundColour.CalcPixel( m_cmap );
2133 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
2134 }
2135 }
2136
2137 void wxWindowDCImpl::SetTextBackground( const wxColour &col )
2138 {
2139 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2140
2141 // same as above
2142 if ( !col.IsOk() || (m_textBackgroundColour == col) )
2143 return;
2144
2145 m_textBackgroundColour = col;
2146
2147 if ( m_gdkwindow )
2148 {
2149 m_textBackgroundColour.CalcPixel( m_cmap );
2150 gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
2151 }
2152 }
2153
2154 void wxWindowDCImpl::SetBackgroundMode( int mode )
2155 {
2156 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2157
2158 m_backgroundMode = mode;
2159 }
2160
2161 void wxWindowDCImpl::SetPalette( const wxPalette& WXUNUSED(palette) )
2162 {
2163 wxFAIL_MSG( wxT("wxWindowDCImpl::SetPalette not implemented") );
2164 }
2165
2166 void wxWindowDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
2167 {
2168 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2169
2170 if (!m_gdkwindow) return;
2171
2172 wxRect rect;
2173 rect.x = XLOG2DEV(x);
2174 rect.y = YLOG2DEV(y);
2175 rect.width = XLOG2DEVREL(width);
2176 rect.height = YLOG2DEVREL(height);
2177
2178 if (m_window && m_window->m_wxwindow &&
2179 (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
2180 {
2181 rect.x -= rect.width;
2182 }
2183
2184 DoSetDeviceClippingRegion(wxRegion(rect));
2185 }
2186
2187 void wxWindowDCImpl::DoSetDeviceClippingRegion( const wxRegion &region )
2188 {
2189 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2190
2191 if (region.Empty())
2192 {
2193 DestroyClippingRegion();
2194 return;
2195 }
2196
2197 if (!m_gdkwindow) return;
2198
2199 if (!m_currentClippingRegion.IsNull())
2200 m_currentClippingRegion.Intersect( region );
2201 else
2202 m_currentClippingRegion.Union( region );
2203
2204 #if USE_PAINT_REGION
2205 if (!m_paintClippingRegion.IsNull())
2206 m_currentClippingRegion.Intersect( m_paintClippingRegion );
2207 #endif
2208
2209 wxCoord xx, yy, ww, hh;
2210 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
2211 wxGTKDCImpl::DoSetClippingRegion( xx, yy, ww, hh );
2212
2213 GdkRegion* gdkRegion = m_currentClippingRegion.GetRegion();
2214 gdk_gc_set_clip_region(m_penGC, gdkRegion);
2215 gdk_gc_set_clip_region(m_brushGC, gdkRegion);
2216 gdk_gc_set_clip_region(m_textGC, gdkRegion);
2217 gdk_gc_set_clip_region(m_bgGC, gdkRegion);
2218 }
2219
2220 void wxWindowDCImpl::DestroyClippingRegion()
2221 {
2222 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2223
2224 wxDCImpl::DestroyClippingRegion();
2225
2226 m_currentClippingRegion.Clear();
2227
2228 #if USE_PAINT_REGION
2229 if (!m_paintClippingRegion.IsEmpty())
2230 m_currentClippingRegion.Union( m_paintClippingRegion );
2231 #endif
2232
2233 if (!m_gdkwindow) return;
2234
2235 GdkRegion* gdkRegion = NULL;
2236 if (!m_currentClippingRegion.IsEmpty())
2237 gdkRegion = m_currentClippingRegion.GetRegion();
2238
2239 gdk_gc_set_clip_region(m_penGC, gdkRegion);
2240 gdk_gc_set_clip_region(m_brushGC, gdkRegion);
2241 gdk_gc_set_clip_region(m_textGC, gdkRegion);
2242 gdk_gc_set_clip_region(m_bgGC, gdkRegion);
2243 }
2244
2245 void wxWindowDCImpl::Destroy()
2246 {
2247 if (m_penGC) wxFreePoolGC( m_penGC );
2248 m_penGC = (GdkGC*) NULL;
2249 if (m_brushGC) wxFreePoolGC( m_brushGC );
2250 m_brushGC = (GdkGC*) NULL;
2251 if (m_textGC) wxFreePoolGC( m_textGC );
2252 m_textGC = (GdkGC*) NULL;
2253 if (m_bgGC) wxFreePoolGC( m_bgGC );
2254 m_bgGC = (GdkGC*) NULL;
2255 }
2256
2257 void wxWindowDCImpl::SetDeviceOrigin( wxCoord x, wxCoord y )
2258 {
2259 m_deviceOriginX = x;
2260 m_deviceOriginY = y;
2261
2262 ComputeScaleAndOrigin();
2263 }
2264
2265 void wxWindowDCImpl::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
2266 {
2267 m_signX = (xLeftRight ? 1 : -1);
2268 m_signY = (yBottomUp ? -1 : 1);
2269
2270 if (m_window && m_window->m_wxwindow &&
2271 (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
2272 m_signX = -m_signX;
2273
2274 ComputeScaleAndOrigin();
2275 }
2276
2277 void wxWindowDCImpl::ComputeScaleAndOrigin()
2278 {
2279 const wxRealPoint origScale(m_scaleX, m_scaleY);
2280
2281 wxDCImpl::ComputeScaleAndOrigin();
2282
2283 // if scale has changed call SetPen to recalulate the line width
2284 if ( wxRealPoint(m_scaleX, m_scaleY) != origScale && m_pen.IsOk() )
2285 {
2286 // this is a bit artificial, but we need to force wxDC to think the pen
2287 // has changed
2288 wxPen pen = m_pen;
2289 m_pen = wxNullPen;
2290 SetPen( pen );
2291 }
2292 }
2293
2294 // Resolution in pixels per logical inch
2295 wxSize wxWindowDCImpl::GetPPI() const
2296 {
2297 return wxSize( (int) (m_mm_to_pix_x * 25.4 + 0.5), (int) (m_mm_to_pix_y * 25.4 + 0.5));
2298 }
2299
2300 int wxWindowDCImpl::GetDepth() const
2301 {
2302 return gdk_drawable_get_depth(m_gdkwindow);
2303 }
2304
2305
2306 //-----------------------------------------------------------------------------
2307 // wxClientDCImpl
2308 //-----------------------------------------------------------------------------
2309
2310 IMPLEMENT_ABSTRACT_CLASS(wxClientDCImpl, wxWindowDCImpl)
2311
2312 wxClientDCImpl::wxClientDCImpl( wxDC *owner )
2313 : wxWindowDCImpl( owner )
2314 {
2315 }
2316
2317 wxClientDCImpl::wxClientDCImpl( wxDC *owner, wxWindow *win )
2318 : wxWindowDCImpl( owner, win )
2319 {
2320 wxCHECK_RET( win, _T("NULL window in wxClientDCImpl::wxClientDC") );
2321
2322 #ifdef __WXUNIVERSAL__
2323 wxPoint ptOrigin = win->GetClientAreaOrigin();
2324 SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
2325 wxSize size = win->GetClientSize();
2326 DoSetClippingRegion(0, 0, size.x, size.y);
2327 #endif
2328 // __WXUNIVERSAL__
2329 }
2330
2331 void wxClientDCImpl::DoGetSize(int *width, int *height) const
2332 {
2333 wxCHECK_RET( m_window, _T("GetSize() doesn't work without window") );
2334
2335 m_window->GetClientSize( width, height );
2336 }
2337
2338 //-----------------------------------------------------------------------------
2339 // wxPaintDCImpl
2340 //-----------------------------------------------------------------------------
2341
2342 IMPLEMENT_ABSTRACT_CLASS(wxPaintDCImpl, wxClientDCImpl)
2343
2344 // Limit the paint region to the window size. Sometimes
2345 // the paint region is too big, and this risks X11 errors
2346 static void wxLimitRegionToSize(wxRegion& region, const wxSize& sz)
2347 {
2348 wxRect originalRect = region.GetBox();
2349 wxRect rect(originalRect);
2350 if (rect.width + rect.x > sz.x)
2351 rect.width = sz.x - rect.x;
2352 if (rect.height + rect.y > sz.y)
2353 rect.height = sz.y - rect.y;
2354 if (rect != originalRect)
2355 {
2356 region = wxRegion(rect);
2357 wxLogTrace(wxT("painting"), wxT("Limiting region from %d, %d, %d, %d to %d, %d, %d, %d\n"),
2358 originalRect.x, originalRect.y, originalRect.width, originalRect.height,
2359 rect.x, rect.y, rect.width, rect.height);
2360 }
2361 }
2362
2363 wxPaintDCImpl::wxPaintDCImpl( wxDC *owner )
2364 : wxClientDCImpl( owner )
2365 {
2366 }
2367
2368 wxPaintDCImpl::wxPaintDCImpl( wxDC *owner, wxWindow *win )
2369 : wxClientDCImpl( owner, win )
2370 {
2371 #if USE_PAINT_REGION
2372 if (!win->m_clipPaintRegion)
2373 return;
2374
2375 wxSize sz = win->GetSize();
2376 m_paintClippingRegion = win->m_nativeUpdateRegion;
2377 wxLimitRegionToSize(m_paintClippingRegion, sz);
2378
2379 GdkRegion *region = m_paintClippingRegion.GetRegion();
2380 if ( region )
2381 {
2382 m_currentClippingRegion.Union( m_paintClippingRegion );
2383 wxLimitRegionToSize(m_currentClippingRegion, sz);
2384
2385 if (sz.x <= 0 || sz.y <= 0)
2386 return ;
2387
2388 gdk_gc_set_clip_region( m_penGC, region );
2389 gdk_gc_set_clip_region( m_brushGC, region );
2390 gdk_gc_set_clip_region( m_textGC, region );
2391 gdk_gc_set_clip_region( m_bgGC, region );
2392 }
2393 #endif
2394 }
2395
2396 // ----------------------------------------------------------------------------
2397 // wxDCModule
2398 // ----------------------------------------------------------------------------
2399
2400 class wxDCModule : public wxModule
2401 {
2402 public:
2403 bool OnInit();
2404 void OnExit();
2405
2406 private:
2407 DECLARE_DYNAMIC_CLASS(wxDCModule)
2408 };
2409
2410 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2411
2412 bool wxDCModule::OnInit()
2413 {
2414 wxInitGCPool();
2415 return true;
2416 }
2417
2418 void wxDCModule::OnExit()
2419 {
2420 wxCleanUpGCPool();
2421
2422 for (int i = wxBRUSHSTYLE_LAST_HATCH - wxBRUSHSTYLE_FIRST_HATCH; i--; )
2423 {
2424 if (hatches[i])
2425 g_object_unref(hatches[i]);
2426 }
2427 }
wxWidgets (Impactor)