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


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