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


a56b5d849803b3d0b5f83ef83390a7b06677a0ec
[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
1483 // TODO: There is an example of rotating text with GTK2 that would probably be
1484 // a better approach here:
1485 // http://www.daa.com.au/pipermail/pygtk/2003-April/005052.html
1486
1487 void wxWindowDCImpl::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
1488 {
1489 #if wxUSE_IMAGE
1490 if (!m_gdkwindow || text.empty())
1491 return;
1492
1493 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1494
1495 if ( wxIsNullDouble(angle) )
1496 {
1497 DoDrawText(text, x, y);
1498 return;
1499 }
1500
1501 wxCoord w;
1502 wxCoord h;
1503
1504 // TODO: implement later without GdkFont for GTK 2.0
1505 DoGetTextExtent(text, &w, &h, NULL,NULL, &m_font);
1506
1507 // draw the string normally
1508 wxBitmap src(w, h);
1509 wxMemoryDC dc;
1510 dc.SelectObject(src);
1511 dc.SetFont(GetFont());
1512 dc.SetBackground(*wxBLACK_BRUSH);
1513 dc.SetBrush(*wxBLACK_BRUSH);
1514 dc.Clear();
1515 dc.SetTextForeground( *wxWHITE );
1516 dc.DrawText(text, 0, 0);
1517 dc.SelectObject(wxNullBitmap);
1518
1519 // Calculate the size of the rotated bounding box.
1520 double rad = DegToRad(angle);
1521 double dx = cos(rad),
1522 dy = sin(rad);
1523
1524 // the rectngle vertices are counted clockwise with the first one being at
1525 // (0, 0) (or, rather, at (x, y))
1526 double x2 = w*dx,
1527 y2 = -w*dy; // y axis points to the bottom, hence minus
1528 double x4 = h*dy,
1529 y4 = h*dx;
1530 double x3 = x4 + x2,
1531 y3 = y4 + y2;
1532
1533 // calc max and min
1534 wxCoord maxX = (wxCoord)(dmax(x2, dmax(x3, x4)) + 0.5),
1535 maxY = (wxCoord)(dmax(y2, dmax(y3, y4)) + 0.5),
1536 minX = (wxCoord)(dmin(x2, dmin(x3, x4)) - 0.5),
1537 minY = (wxCoord)(dmin(y2, dmin(y3, y4)) - 0.5);
1538
1539
1540 wxImage image = src.ConvertToImage();
1541
1542 image.ConvertColourToAlpha( m_textForegroundColour.Red(),
1543 m_textForegroundColour.Green(),
1544 m_textForegroundColour.Blue() );
1545 image = image.Rotate( rad, wxPoint(0,0) );
1546
1547 int i_angle = (int) angle;
1548 i_angle = i_angle % 360;
1549 if (i_angle < 0)
1550 i_angle += 360;
1551 int xoffset = 0;
1552 if ((i_angle >= 90.0) && (i_angle < 270.0))
1553 xoffset = image.GetWidth();
1554 int yoffset = 0;
1555 if ((i_angle >= 0.0) && (i_angle < 180.0))
1556 yoffset = image.GetHeight();
1557
1558 if ((i_angle >= 0) && (i_angle < 90))
1559 yoffset -= (int)( cos(rad)*h );
1560 if ((i_angle >= 90) && (i_angle < 180))
1561 xoffset -= (int)( sin(rad)*h );
1562 if ((i_angle >= 180) && (i_angle < 270))
1563 yoffset -= (int)( cos(rad)*h );
1564 if ((i_angle >= 270) && (i_angle < 360))
1565 xoffset -= (int)( sin(rad)*h );
1566
1567 int i_x = x - xoffset;
1568 int i_y = y - yoffset;
1569
1570 src = image;
1571 DoDrawBitmap( src, i_x, i_y, true );
1572
1573
1574 // it would be better to draw with non underlined font and draw the line
1575 // manually here (it would be more straight...)
1576 #if 0
1577 if ( m_font.GetUnderlined() )
1578 {
1579 gdk_draw_line( m_gdkwindow, m_textGC,
1580 XLOG2DEV(x + x4), YLOG2DEV(y + y4 + font->descent),
1581 XLOG2DEV(x + x3), YLOG2DEV(y + y3 + font->descent));
1582 }
1583 #endif // 0
1584
1585 // update the bounding box
1586 CalcBoundingBox(x + minX, y + minY);
1587 CalcBoundingBox(x + maxX, y + maxY);
1588 #else // !wxUSE_IMAGE
1589 wxUnusedVar(text);
1590 wxUnusedVar(x);
1591 wxUnusedVar(y);
1592 wxUnusedVar(angle);
1593 #endif // wxUSE_IMAGE/!wxUSE_IMAGE
1594 }
1595
1596 void wxWindowDCImpl::DoGetTextExtent(const wxString &string,
1597 wxCoord *width, wxCoord *height,
1598 wxCoord *descent, wxCoord *externalLeading,
1599 const wxFont *theFont) const
1600 {
1601 if ( width )
1602 *width = 0;
1603 if ( height )
1604 *height = 0;
1605 if ( descent )
1606 *descent = 0;
1607 if ( externalLeading )
1608 *externalLeading = 0;
1609
1610 if (string.empty())
1611 return;
1612
1613 // ensure that theFont is always non-NULL
1614 if ( !theFont || !theFont->IsOk() )
1615 theFont = &m_font;
1616
1617 // and use it if it's valid
1618 if ( theFont->IsOk() )
1619 {
1620 pango_layout_set_font_description
1621 (
1622 m_layout,
1623 theFont->GetNativeFontInfo()->description
1624 );
1625 }
1626
1627 // Set layout's text
1628 const wxCharBuffer dataUTF8 = wxGTK_CONV_FONT(string, *theFont);
1629 if ( !dataUTF8 )
1630 {
1631 // hardly ideal, but what else can we do if conversion failed?
1632 return;
1633 }
1634
1635 pango_layout_set_text(m_layout, dataUTF8, -1);
1636
1637 int h;
1638 pango_layout_get_pixel_size(m_layout, width, &h);
1639 if (descent)
1640 {
1641 PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
1642 int baseline = pango_layout_iter_get_baseline(iter);
1643 pango_layout_iter_free(iter);
1644 *descent = h - PANGO_PIXELS(baseline);
1645 }
1646 if (height)
1647 *height = h;
1648
1649 // Reset old font description
1650 if (theFont->IsOk())
1651 pango_layout_set_font_description( m_layout, m_fontdesc );
1652 }
1653
1654
1655 bool wxWindowDCImpl::DoGetPartialTextExtents(const wxString& text,
1656 wxArrayInt& widths) const
1657 {
1658 const size_t len = text.length();
1659 widths.Empty();
1660 widths.Add(0, len);
1661
1662 if (text.empty())
1663 return true;
1664
1665 // Set layout's text
1666 const wxCharBuffer dataUTF8 = wxGTK_CONV_FONT(text, m_font);
1667 if ( !dataUTF8 )
1668 {
1669 // hardly ideal, but what else can we do if conversion failed?
1670 wxLogLastError(wxT("DoGetPartialTextExtents"));
1671 return false;
1672 }
1673
1674 pango_layout_set_text(m_layout, dataUTF8, -1);
1675
1676 // Calculate the position of each character based on the widths of
1677 // the previous characters
1678
1679 // Code borrowed from Scintilla's PlatGTK
1680 PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
1681 PangoRectangle pos;
1682 pango_layout_iter_get_cluster_extents(iter, NULL, &pos);
1683 size_t i = 0;
1684 while (pango_layout_iter_next_cluster(iter))
1685 {
1686 pango_layout_iter_get_cluster_extents(iter, NULL, &pos);
1687 int position = PANGO_PIXELS(pos.x);
1688 widths[i++] = position;
1689 }
1690 while (i < len)
1691 widths[i++] = PANGO_PIXELS(pos.x + pos.width);
1692 pango_layout_iter_free(iter);
1693
1694 return true;
1695 }
1696
1697
1698 wxCoord wxWindowDCImpl::GetCharWidth() const
1699 {
1700 pango_layout_set_text( m_layout, "H", 1 );
1701 int w;
1702 pango_layout_get_pixel_size( m_layout, &w, NULL );
1703 return w;
1704 }
1705
1706 wxCoord wxWindowDCImpl::GetCharHeight() const
1707 {
1708 PangoFontMetrics *metrics = pango_context_get_metrics (m_context, m_fontdesc, pango_context_get_language(m_context));
1709 wxCHECK_MSG( metrics, -1, _T("failed to get pango font metrics") );
1710
1711 wxCoord h = PANGO_PIXELS (pango_font_metrics_get_descent (metrics) +
1712 pango_font_metrics_get_ascent (metrics));
1713 pango_font_metrics_unref (metrics);
1714 return h;
1715 }
1716
1717 void wxWindowDCImpl::Clear()
1718 {
1719 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1720
1721 if (!m_gdkwindow) return;
1722
1723 int width,height;
1724 DoGetSize( &width, &height );
1725 gdk_draw_rectangle( m_gdkwindow, m_bgGC, TRUE, 0, 0, width, height );
1726 }
1727
1728 void wxWindowDCImpl::SetFont( const wxFont &font )
1729 {
1730 m_font = font;
1731
1732 if (m_font.IsOk())
1733 {
1734 if (m_fontdesc)
1735 pango_font_description_free( m_fontdesc );
1736
1737 m_fontdesc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
1738
1739
1740 if (m_window)
1741 {
1742 PangoContext *oldContext = m_context;
1743
1744 m_context = m_window->GtkGetPangoDefaultContext();
1745
1746 // If we switch back/forth between different contexts
1747 // we also have to create a new layout. I think so,
1748 // at least, and it doesn't hurt to do it.
1749 if (oldContext != m_context)
1750 {
1751 if (m_layout)
1752 g_object_unref (m_layout);
1753
1754 m_layout = pango_layout_new( m_context );
1755 }
1756 }
1757
1758 pango_layout_set_font_description( m_layout, m_fontdesc );
1759 }
1760 }
1761
1762 void wxWindowDCImpl::SetPen( const wxPen &pen )
1763 {
1764 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1765
1766 if (m_pen == pen) return;
1767
1768 m_pen = pen;
1769
1770 if (!m_pen.IsOk()) return;
1771
1772 if (!m_gdkwindow) return;
1773
1774 gint width = m_pen.GetWidth();
1775 if (width <= 0)
1776 {
1777 // CMB: if width is non-zero scale it with the dc
1778 width = 1;
1779 }
1780 else
1781 {
1782 // X doesn't allow different width in x and y and so we take
1783 // the average
1784 double w = 0.5 +
1785 ( fabs((double) XLOG2DEVREL(width)) +
1786 fabs((double) YLOG2DEVREL(width)) ) / 2.0;
1787 width = (int)w;
1788 if ( !width )
1789 {
1790 // width can't be 0 or an internal GTK error occurs inside
1791 // gdk_gc_set_dashes() below
1792 width = 1;
1793 }
1794 }
1795
1796 static const wxGTKDash dotted[] = {1, 1};
1797 static const wxGTKDash short_dashed[] = {2, 2};
1798 static const wxGTKDash wxCoord_dashed[] = {2, 4};
1799 static const wxGTKDash dotted_dashed[] = {3, 3, 1, 3};
1800
1801 // We express dash pattern in pen width unit, so we are
1802 // independent of zoom factor and so on...
1803 int req_nb_dash;
1804 const wxGTKDash *req_dash;
1805
1806 GdkLineStyle lineStyle = GDK_LINE_ON_OFF_DASH;
1807 switch (m_pen.GetStyle())
1808 {
1809 case wxPENSTYLE_USER_DASH:
1810 req_nb_dash = m_pen.GetDashCount();
1811 req_dash = (wxGTKDash*)m_pen.GetDash();
1812 break;
1813 case wxPENSTYLE_DOT:
1814 req_nb_dash = 2;
1815 req_dash = dotted;
1816 break;
1817 case wxPENSTYLE_LONG_DASH:
1818 req_nb_dash = 2;
1819 req_dash = wxCoord_dashed;
1820 break;
1821 case wxPENSTYLE_SHORT_DASH:
1822 req_nb_dash = 2;
1823 req_dash = short_dashed;
1824 break;
1825 case wxPENSTYLE_DOT_DASH:
1826 req_nb_dash = 4;
1827 req_dash = dotted_dashed;
1828 break;
1829
1830 case wxPENSTYLE_TRANSPARENT:
1831 case wxPENSTYLE_STIPPLE_MASK_OPAQUE:
1832 case wxPENSTYLE_STIPPLE:
1833 case wxPENSTYLE_SOLID:
1834 default:
1835 lineStyle = GDK_LINE_SOLID;
1836 req_dash = (wxGTKDash*)NULL;
1837 req_nb_dash = 0;
1838 break;
1839 }
1840
1841 if (req_dash && req_nb_dash)
1842 {
1843 wxGTKDash *real_req_dash = new wxGTKDash[req_nb_dash];
1844 if (real_req_dash)
1845 {
1846 for (int i = 0; i < req_nb_dash; i++)
1847 real_req_dash[i] = req_dash[i] * width;
1848 gdk_gc_set_dashes( m_penGC, 0, real_req_dash, req_nb_dash );
1849 delete[] real_req_dash;
1850 }
1851 else
1852 {
1853 // No Memory. We use non-scaled dash pattern...
1854 gdk_gc_set_dashes( m_penGC, 0, (wxGTKDash*)req_dash, req_nb_dash );
1855 }
1856 }
1857
1858 GdkCapStyle capStyle = GDK_CAP_ROUND;
1859 switch (m_pen.GetCap())
1860 {
1861 case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; }
1862 case wxCAP_BUTT: { capStyle = GDK_CAP_BUTT; break; }
1863 case wxCAP_ROUND:
1864 default:
1865 if (width <= 1)
1866 {
1867 width = 0;
1868 capStyle = GDK_CAP_NOT_LAST;
1869 }
1870 break;
1871 }
1872
1873 GdkJoinStyle joinStyle = GDK_JOIN_ROUND;
1874 switch (m_pen.GetJoin())
1875 {
1876 case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; }
1877 case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; }
1878 case wxJOIN_ROUND:
1879 default: { joinStyle = GDK_JOIN_ROUND; break; }
1880 }
1881
1882 gdk_gc_set_line_attributes( m_penGC, width, lineStyle, capStyle, joinStyle );
1883
1884 m_pen.GetColour().CalcPixel( m_cmap );
1885 gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
1886 }
1887
1888 void wxWindowDCImpl::SetBrush( const wxBrush &brush )
1889 {
1890 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1891
1892 if (m_brush == brush) return;
1893
1894 m_brush = brush;
1895
1896 if (!m_brush.IsOk()) return;
1897
1898 if (!m_gdkwindow) return;
1899
1900 m_brush.GetColour().CalcPixel( m_cmap );
1901 gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
1902
1903 gdk_gc_set_fill( m_brushGC, GDK_SOLID );
1904
1905 if ((m_brush.GetStyle() == wxBRUSHSTYLE_STIPPLE) && (m_brush.GetStipple()->IsOk()))
1906 {
1907 if (m_brush.GetStipple()->GetDepth() != 1)
1908 {
1909 gdk_gc_set_fill( m_brushGC, GDK_TILED );
1910 gdk_gc_set_tile( m_brushGC, m_brush.GetStipple()->GetPixmap() );
1911 }
1912 else
1913 {
1914 gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
1915 gdk_gc_set_stipple( m_brushGC, m_brush.GetStipple()->GetPixmap() );
1916 }
1917 }
1918
1919 if ((m_brush.GetStyle() == wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
1920 {
1921 gdk_gc_set_fill( m_textGC, GDK_OPAQUE_STIPPLED);
1922 gdk_gc_set_stipple( m_textGC, m_brush.GetStipple()->GetMask()->GetBitmap() );
1923 }
1924
1925 if (m_brush.IsHatch())
1926 {
1927 gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
1928 gdk_gc_set_stipple(m_brushGC, GetHatch(m_brush.GetStyle()));
1929 }
1930 }
1931
1932 void wxWindowDCImpl::SetBackground( const wxBrush &brush )
1933 {
1934 /* CMB 21/7/98: Added SetBackground. Sets background brush
1935 * for Clear() and bg colour for shapes filled with cross-hatch brush */
1936
1937 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1938
1939 if (m_backgroundBrush == brush) return;
1940
1941 m_backgroundBrush = brush;
1942
1943 if (!m_backgroundBrush.IsOk()) return;
1944
1945 if (!m_gdkwindow) return;
1946
1947 wxColor color = m_backgroundBrush.GetColour();
1948 color.CalcPixel(m_cmap);
1949 const GdkColor* gdkColor = color.GetColor();
1950 gdk_gc_set_background(m_brushGC, gdkColor);
1951 gdk_gc_set_background(m_penGC, gdkColor);
1952 gdk_gc_set_background(m_bgGC, gdkColor);
1953 gdk_gc_set_foreground(m_bgGC, gdkColor);
1954
1955
1956 gdk_gc_set_fill( m_bgGC, GDK_SOLID );
1957
1958 if (m_backgroundBrush.GetStyle() == wxBRUSHSTYLE_STIPPLE)
1959 {
1960 const wxBitmap* stipple = m_backgroundBrush.GetStipple();
1961 if (stipple->IsOk())
1962 {
1963 if (stipple->GetDepth() != 1)
1964 {
1965 gdk_gc_set_fill(m_bgGC, GDK_TILED);
1966 gdk_gc_set_tile(m_bgGC, stipple->GetPixmap());
1967 }
1968 else
1969 {
1970 gdk_gc_set_fill(m_bgGC, GDK_STIPPLED);
1971 gdk_gc_set_stipple(m_bgGC, stipple->GetPixmap());
1972 }
1973 }
1974 }
1975 else if (m_backgroundBrush.IsHatch())
1976 {
1977 gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
1978 gdk_gc_set_stipple(m_bgGC, GetHatch(m_backgroundBrush.GetStyle()));
1979 }
1980 }
1981
1982 void wxWindowDCImpl::SetLogicalFunction( int function )
1983 {
1984 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1985
1986 if (m_logicalFunction == function)
1987 return;
1988
1989 // VZ: shouldn't this be a CHECK?
1990 if (!m_gdkwindow)
1991 return;
1992
1993 GdkFunction mode;
1994 switch (function)
1995 {
1996 case wxXOR: mode = GDK_XOR; break;
1997 case wxINVERT: mode = GDK_INVERT; break;
1998 case wxOR_REVERSE: mode = GDK_OR_REVERSE; break;
1999 case wxAND_REVERSE: mode = GDK_AND_REVERSE; break;
2000 case wxCLEAR: mode = GDK_CLEAR; break;
2001 case wxSET: mode = GDK_SET; break;
2002 case wxOR_INVERT: mode = GDK_OR_INVERT; break;
2003 case wxAND: mode = GDK_AND; break;
2004 case wxOR: mode = GDK_OR; break;
2005 case wxEQUIV: mode = GDK_EQUIV; break;
2006 case wxNAND: mode = GDK_NAND; break;
2007 case wxAND_INVERT: mode = GDK_AND_INVERT; break;
2008 case wxCOPY: mode = GDK_COPY; break;
2009 case wxNO_OP: mode = GDK_NOOP; break;
2010 case wxSRC_INVERT: mode = GDK_COPY_INVERT; break;
2011 case wxNOR: mode = GDK_NOR; break;
2012 default:
2013 wxFAIL_MSG( wxT("unsupported logical function") );
2014 mode = GDK_COPY;
2015 }
2016
2017 m_logicalFunction = function;
2018
2019 gdk_gc_set_function( m_penGC, mode );
2020 gdk_gc_set_function( m_brushGC, mode );
2021
2022 // to stay compatible with wxMSW, we don't apply ROPs to the text
2023 // operations (i.e. DrawText/DrawRotatedText).
2024 // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
2025 gdk_gc_set_function( m_textGC, mode );
2026 }
2027
2028 void wxWindowDCImpl::SetTextForeground( const wxColour &col )
2029 {
2030 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2031
2032 // don't set m_textForegroundColour to an invalid colour as we'd crash
2033 // later then (we use m_textForegroundColour.GetColor() without checking
2034 // in a few places)
2035 if ( !col.IsOk() || (m_textForegroundColour == col) )
2036 return;
2037
2038 m_textForegroundColour = col;
2039
2040 if ( m_gdkwindow )
2041 {
2042 m_textForegroundColour.CalcPixel( m_cmap );
2043 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
2044 }
2045 }
2046
2047 void wxWindowDCImpl::SetTextBackground( const wxColour &col )
2048 {
2049 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2050
2051 // same as above
2052 if ( !col.IsOk() || (m_textBackgroundColour == col) )
2053 return;
2054
2055 m_textBackgroundColour = col;
2056
2057 if ( m_gdkwindow )
2058 {
2059 m_textBackgroundColour.CalcPixel( m_cmap );
2060 gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
2061 }
2062 }
2063
2064 void wxWindowDCImpl::SetBackgroundMode( int mode )
2065 {
2066 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2067
2068 m_backgroundMode = mode;
2069 }
2070
2071 void wxWindowDCImpl::SetPalette( const wxPalette& WXUNUSED(palette) )
2072 {
2073 wxFAIL_MSG( wxT("wxWindowDCImpl::SetPalette not implemented") );
2074 }
2075
2076 void wxWindowDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
2077 {
2078 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2079
2080 if (!m_gdkwindow) return;
2081
2082 wxRect rect;
2083 rect.x = XLOG2DEV(x);
2084 rect.y = YLOG2DEV(y);
2085 rect.width = XLOG2DEVREL(width);
2086 rect.height = YLOG2DEVREL(height);
2087
2088 if (m_window && m_window->m_wxwindow &&
2089 (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
2090 {
2091 rect.x -= rect.width;
2092 }
2093
2094 if (!m_currentClippingRegion.IsNull())
2095 m_currentClippingRegion.Intersect( rect );
2096 else
2097 m_currentClippingRegion.Union( rect );
2098
2099 #if USE_PAINT_REGION
2100 if (!m_paintClippingRegion.IsNull())
2101 m_currentClippingRegion.Intersect( m_paintClippingRegion );
2102 #endif
2103
2104 wxCoord xx, yy, ww, hh;
2105 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
2106 wxGTKDCImpl::DoSetClippingRegion( xx, yy, ww, hh );
2107
2108 GdkRegion* gdkRegion = m_currentClippingRegion.GetRegion();
2109 gdk_gc_set_clip_region(m_penGC, gdkRegion);
2110 gdk_gc_set_clip_region(m_brushGC, gdkRegion);
2111 gdk_gc_set_clip_region(m_textGC, gdkRegion);
2112 gdk_gc_set_clip_region(m_bgGC, gdkRegion);
2113 }
2114
2115 void wxWindowDCImpl::DoSetDeviceClippingRegion( const wxRegion &region )
2116 {
2117 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2118
2119 if (region.Empty())
2120 {
2121 DestroyClippingRegion();
2122 return;
2123 }
2124
2125 if (!m_gdkwindow) return;
2126
2127 if (!m_currentClippingRegion.IsNull())
2128 m_currentClippingRegion.Intersect( region );
2129 else
2130 m_currentClippingRegion.Union( region );
2131
2132 #if USE_PAINT_REGION
2133 if (!m_paintClippingRegion.IsNull())
2134 m_currentClippingRegion.Intersect( m_paintClippingRegion );
2135 #endif
2136
2137 wxCoord xx, yy, ww, hh;
2138 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
2139 wxGTKDCImpl::DoSetClippingRegion( xx, yy, ww, hh );
2140
2141 GdkRegion* gdkRegion = m_currentClippingRegion.GetRegion();
2142 gdk_gc_set_clip_region(m_penGC, gdkRegion);
2143 gdk_gc_set_clip_region(m_brushGC, gdkRegion);
2144 gdk_gc_set_clip_region(m_textGC, gdkRegion);
2145 gdk_gc_set_clip_region(m_bgGC, gdkRegion);
2146 }
2147
2148 void wxWindowDCImpl::DestroyClippingRegion()
2149 {
2150 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2151
2152 wxDCImpl::DestroyClippingRegion();
2153
2154 m_currentClippingRegion.Clear();
2155
2156 #if USE_PAINT_REGION
2157 if (!m_paintClippingRegion.IsEmpty())
2158 m_currentClippingRegion.Union( m_paintClippingRegion );
2159 #endif
2160
2161 if (!m_gdkwindow) return;
2162
2163 GdkRegion* gdkRegion = NULL;
2164 if (!m_currentClippingRegion.IsEmpty())
2165 gdkRegion = m_currentClippingRegion.GetRegion();
2166
2167 gdk_gc_set_clip_region(m_penGC, gdkRegion);
2168 gdk_gc_set_clip_region(m_brushGC, gdkRegion);
2169 gdk_gc_set_clip_region(m_textGC, gdkRegion);
2170 gdk_gc_set_clip_region(m_bgGC, gdkRegion);
2171 }
2172
2173 void wxWindowDCImpl::Destroy()
2174 {
2175 if (m_penGC) wxFreePoolGC( m_penGC );
2176 m_penGC = (GdkGC*) NULL;
2177 if (m_brushGC) wxFreePoolGC( m_brushGC );
2178 m_brushGC = (GdkGC*) NULL;
2179 if (m_textGC) wxFreePoolGC( m_textGC );
2180 m_textGC = (GdkGC*) NULL;
2181 if (m_bgGC) wxFreePoolGC( m_bgGC );
2182 m_bgGC = (GdkGC*) NULL;
2183 }
2184
2185 void wxWindowDCImpl::SetDeviceOrigin( wxCoord x, wxCoord y )
2186 {
2187 m_deviceOriginX = x;
2188 m_deviceOriginY = y;
2189
2190 ComputeScaleAndOrigin();
2191 }
2192
2193 void wxWindowDCImpl::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
2194 {
2195 m_signX = (xLeftRight ? 1 : -1);
2196 m_signY = (yBottomUp ? -1 : 1);
2197
2198 if (m_window && m_window->m_wxwindow &&
2199 (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
2200 m_signX = -m_signX;
2201
2202 ComputeScaleAndOrigin();
2203 }
2204
2205 void wxWindowDCImpl::ComputeScaleAndOrigin()
2206 {
2207 const wxRealPoint origScale(m_scaleX, m_scaleY);
2208
2209 wxDCImpl::ComputeScaleAndOrigin();
2210
2211 // if scale has changed call SetPen to recalulate the line width
2212 if ( wxRealPoint(m_scaleX, m_scaleY) != origScale && m_pen.IsOk() )
2213 {
2214 // this is a bit artificial, but we need to force wxDC to think the pen
2215 // has changed
2216 wxPen pen = m_pen;
2217 m_pen = wxNullPen;
2218 SetPen( pen );
2219 }
2220 }
2221
2222 // Resolution in pixels per logical inch
2223 wxSize wxWindowDCImpl::GetPPI() const
2224 {
2225 return wxSize( (int) (m_mm_to_pix_x * 25.4 + 0.5), (int) (m_mm_to_pix_y * 25.4 + 0.5));
2226 }
2227
2228 int wxWindowDCImpl::GetDepth() const
2229 {
2230 return gdk_drawable_get_depth(m_gdkwindow);
2231 }
2232
2233
2234 //-----------------------------------------------------------------------------
2235 // wxClientDCImpl
2236 //-----------------------------------------------------------------------------
2237
2238 IMPLEMENT_ABSTRACT_CLASS(wxClientDCImpl, wxWindowDCImpl)
2239
2240 wxClientDCImpl::wxClientDCImpl( wxDC *owner )
2241 : wxWindowDCImpl( owner )
2242 {
2243 }
2244
2245 wxClientDCImpl::wxClientDCImpl( wxDC *owner, wxWindow *win )
2246 : wxWindowDCImpl( owner, win )
2247 {
2248 wxCHECK_RET( win, _T("NULL window in wxClientDCImpl::wxClientDC") );
2249
2250 #ifdef __WXUNIVERSAL__
2251 wxPoint ptOrigin = win->GetClientAreaOrigin();
2252 SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
2253 wxSize size = win->GetClientSize();
2254 DoSetClippingRegion(0, 0, size.x, size.y);
2255 #endif
2256 // __WXUNIVERSAL__
2257 }
2258
2259 void wxClientDCImpl::DoGetSize(int *width, int *height) const
2260 {
2261 wxCHECK_RET( m_window, _T("GetSize() doesn't work without window") );
2262
2263 m_window->GetClientSize( width, height );
2264 }
2265
2266 //-----------------------------------------------------------------------------
2267 // wxPaintDCImpl
2268 //-----------------------------------------------------------------------------
2269
2270 IMPLEMENT_ABSTRACT_CLASS(wxPaintDCImpl, wxClientDCImpl)
2271
2272 // Limit the paint region to the window size. Sometimes
2273 // the paint region is too big, and this risks X11 errors
2274 static void wxLimitRegionToSize(wxRegion& region, const wxSize& sz)
2275 {
2276 wxRect originalRect = region.GetBox();
2277 wxRect rect(originalRect);
2278 if (rect.width + rect.x > sz.x)
2279 rect.width = sz.x - rect.x;
2280 if (rect.height + rect.y > sz.y)
2281 rect.height = sz.y - rect.y;
2282 if (rect != originalRect)
2283 {
2284 region = wxRegion(rect);
2285 wxLogTrace(wxT("painting"), wxT("Limiting region from %d, %d, %d, %d to %d, %d, %d, %d\n"),
2286 originalRect.x, originalRect.y, originalRect.width, originalRect.height,
2287 rect.x, rect.y, rect.width, rect.height);
2288 }
2289 }
2290
2291 wxPaintDCImpl::wxPaintDCImpl( wxDC *owner )
2292 : wxClientDCImpl( owner )
2293 {
2294 }
2295
2296 wxPaintDCImpl::wxPaintDCImpl( wxDC *owner, wxWindow *win )
2297 : wxClientDCImpl( owner, win )
2298 {
2299 #if USE_PAINT_REGION
2300 if (!win->m_clipPaintRegion)
2301 return;
2302
2303 wxSize sz = win->GetSize();
2304 m_paintClippingRegion = win->m_nativeUpdateRegion;
2305 wxLimitRegionToSize(m_paintClippingRegion, sz);
2306
2307 GdkRegion *region = m_paintClippingRegion.GetRegion();
2308 if ( region )
2309 {
2310 m_currentClippingRegion.Union( m_paintClippingRegion );
2311 wxLimitRegionToSize(m_currentClippingRegion, sz);
2312
2313 if (sz.x <= 0 || sz.y <= 0)
2314 return ;
2315
2316 gdk_gc_set_clip_region( m_penGC, region );
2317 gdk_gc_set_clip_region( m_brushGC, region );
2318 gdk_gc_set_clip_region( m_textGC, region );
2319 gdk_gc_set_clip_region( m_bgGC, region );
2320 }
2321 #endif
2322 }
2323
2324 // ----------------------------------------------------------------------------
2325 // wxDCModule
2326 // ----------------------------------------------------------------------------
2327
2328 class wxDCModule : public wxModule
2329 {
2330 public:
2331 bool OnInit();
2332 void OnExit();
2333
2334 private:
2335 DECLARE_DYNAMIC_CLASS(wxDCModule)
2336 };
2337
2338 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2339
2340 bool wxDCModule::OnInit()
2341 {
2342 wxInitGCPool();
2343 return true;
2344 }
2345
2346 void wxDCModule::OnExit()
2347 {
2348 wxCleanUpGCPool();
2349
2350 for (int i = wxBRUSHSTYLE_LAST_HATCH - wxBRUSHSTYLE_FIRST_HATCH; i--; )
2351 {
2352 if (hatches[i])
2353 g_object_unref(hatches[i]);
2354 }
2355 }
wxWidgets (Impactor)