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