1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/dcclient.cpp
3 // Purpose: wxWindowDCImpl implementation
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Chris Breeze
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
13 #include "wx/gtk/dcclient.h"
16 #include "wx/window.h"
18 #include "wx/dcmemory.h"
21 #include "wx/module.h"
24 #include "wx/fontutil.h"
26 #include "wx/gtk/private.h"
27 #include "wx/gtk/private/object.h"
29 //-----------------------------------------------------------------------------
31 //-----------------------------------------------------------------------------
33 #define XLOG2DEV(x) LogicalToDeviceX(x)
34 #define XLOG2DEVREL(x) LogicalToDeviceXRel(x)
35 #define YLOG2DEV(y) LogicalToDeviceY(y)
36 #define YLOG2DEVREL(y) LogicalToDeviceYRel(y)
38 #define USE_PAINT_REGION 1
40 //-----------------------------------------------------------------------------
42 //-----------------------------------------------------------------------------
51 static GdkPixmap
* hatches
[wxBRUSHSTYLE_LAST_HATCH
- wxBRUSHSTYLE_FIRST_HATCH
+ 1];
53 //-----------------------------------------------------------------------------
55 //-----------------------------------------------------------------------------
57 static const double RAD2DEG
= 180.0 / M_PI
;
59 // ----------------------------------------------------------------------------
61 // ----------------------------------------------------------------------------
63 static inline double dmax(double a
, double b
) { return a
> b ? a
: b
; }
64 static inline double dmin(double a
, double b
) { return a
< b ? a
: b
; }
66 static inline double DegToRad(double deg
) { return (deg
* M_PI
) / 180.0; }
68 static GdkPixmap
* GetHatch(int style
)
70 wxASSERT(style
>= wxBRUSHSTYLE_FIRST_HATCH
&& style
<= wxBRUSHSTYLE_LAST_HATCH
);
71 const int i
= style
- wxBRUSHSTYLE_FIRST_HATCH
;
72 if (hatches
[i
] == NULL
)
76 case wxBRUSHSTYLE_BDIAGONAL_HATCH
:
77 hatches
[i
] = gdk_bitmap_create_from_data(NULL
, bdiag_bits
, bdiag_width
, bdiag_height
);
79 case wxBRUSHSTYLE_CROSSDIAG_HATCH
:
80 hatches
[i
] = gdk_bitmap_create_from_data(NULL
, cdiag_bits
, cdiag_width
, cdiag_height
);
82 case wxBRUSHSTYLE_CROSS_HATCH
:
83 hatches
[i
] = gdk_bitmap_create_from_data(NULL
, cross_bits
, cross_width
, cross_height
);
85 case wxBRUSHSTYLE_FDIAGONAL_HATCH
:
86 hatches
[i
] = gdk_bitmap_create_from_data(NULL
, fdiag_bits
, fdiag_width
, fdiag_height
);
88 case wxBRUSHSTYLE_HORIZONTAL_HATCH
:
89 hatches
[i
] = gdk_bitmap_create_from_data(NULL
, horiz_bits
, horiz_width
, horiz_height
);
91 case wxBRUSHSTYLE_VERTICAL_HATCH
:
92 hatches
[i
] = gdk_bitmap_create_from_data(NULL
, verti_bits
, verti_width
, verti_height
);
99 //-----------------------------------------------------------------------------
100 // Implement Pool of Graphic contexts. Creating them takes too much time.
101 //-----------------------------------------------------------------------------
127 #define GC_POOL_ALLOC_SIZE 100
129 static int wxGCPoolSize
= 0;
131 static wxGC
*wxGCPool
= NULL
;
133 static void wxInitGCPool()
135 // This really could wait until the first call to
136 // wxGetPoolGC, but we will make the first allocation
137 // now when other initialization is being performed.
139 // Set initial pool size.
140 wxGCPoolSize
= GC_POOL_ALLOC_SIZE
;
142 // Allocate initial pool.
143 wxGCPool
= (wxGC
*)malloc(wxGCPoolSize
* sizeof(wxGC
));
144 if (wxGCPool
== NULL
)
146 // If we cannot malloc, then fail with error
147 // when debug is enabled. If debug is not enabled,
148 // the problem will eventually get caught
150 wxFAIL_MSG( wxT("Cannot allocate GC pool") );
154 // Zero initial pool.
155 memset(wxGCPool
, 0, wxGCPoolSize
* sizeof(wxGC
));
158 static void wxCleanUpGCPool()
160 for (int i
= 0; i
< wxGCPoolSize
; i
++)
162 if (wxGCPool
[i
].m_gc
)
163 g_object_unref (wxGCPool
[i
].m_gc
);
171 static GdkGC
* wxGetPoolGC( GdkWindow
*window
, wxPoolGCType type
)
175 // Look for an available GC.
176 for (int i
= 0; i
< wxGCPoolSize
; i
++)
178 if (!wxGCPool
[i
].m_gc
)
180 wxGCPool
[i
].m_gc
= gdk_gc_new( window
);
181 gdk_gc_set_exposures( wxGCPool
[i
].m_gc
, FALSE
);
182 wxGCPool
[i
].m_type
= type
;
183 wxGCPool
[i
].m_used
= false;
185 if ((!wxGCPool
[i
].m_used
) && (wxGCPool
[i
].m_type
== type
))
187 wxGCPool
[i
].m_used
= true;
188 return wxGCPool
[i
].m_gc
;
192 // We did not find an available GC.
193 // We need to grow the GC pool.
194 pptr
= (wxGC
*)realloc(wxGCPool
,
195 (wxGCPoolSize
+ GC_POOL_ALLOC_SIZE
)*sizeof(wxGC
));
198 // Initialize newly allocated pool.
200 memset(&wxGCPool
[wxGCPoolSize
], 0,
201 GC_POOL_ALLOC_SIZE
*sizeof(wxGC
));
203 // Initialize entry we will return.
204 wxGCPool
[wxGCPoolSize
].m_gc
= gdk_gc_new( window
);
205 gdk_gc_set_exposures( wxGCPool
[wxGCPoolSize
].m_gc
, FALSE
);
206 wxGCPool
[wxGCPoolSize
].m_type
= type
;
207 wxGCPool
[wxGCPoolSize
].m_used
= true;
209 // Set new value of pool size.
210 wxGCPoolSize
+= GC_POOL_ALLOC_SIZE
;
212 // Return newly allocated entry.
213 return wxGCPool
[wxGCPoolSize
-GC_POOL_ALLOC_SIZE
].m_gc
;
216 // The realloc failed. Fall through to error.
217 wxFAIL_MSG( wxT("No GC available") );
222 static void wxFreePoolGC( GdkGC
*gc
)
224 for (int i
= 0; i
< wxGCPoolSize
; i
++)
226 if (wxGCPool
[i
].m_gc
== gc
)
228 wxGCPool
[i
].m_used
= false;
233 wxFAIL_MSG( wxT("Wrong GC") );
236 //-----------------------------------------------------------------------------
238 //-----------------------------------------------------------------------------
240 IMPLEMENT_ABSTRACT_CLASS(wxWindowDCImpl
, wxGTKDCImpl
)
242 wxWindowDCImpl
::wxWindowDCImpl( wxDC
*owner
) :
251 m_isScreenDC
= false;
257 wxWindowDCImpl
::wxWindowDCImpl( wxDC
*owner
, wxWindow
*window
) :
260 wxASSERT_MSG( window
, wxT("DC needs a window") );
268 m_isScreenDC
= false;
269 m_font
= window
->GetFont();
271 GtkWidget
*widget
= window
->m_wxwindow
;
273 // Some controls don't have m_wxwindow - like wxStaticBox, but the user
274 // code should still be able to create wxClientDCs for them
277 widget
= window
->m_widget
;
279 wxCHECK_RET(widget
, "DC needs a widget");
281 if (GTK_WIDGET_NO_WINDOW(widget
))
282 SetDeviceLocalOrigin(widget
->allocation
.x
, widget
->allocation
.y
);
285 m_context
= window
->GTKGetPangoDefaultContext();
286 m_layout
= pango_layout_new( m_context
);
287 m_fontdesc
= pango_font_description_copy( widget
->style
->font_desc
);
289 m_gdkwindow
= widget
->window
;
291 // Window not realized ?
294 // Don't report problems as per MSW.
300 m_cmap
= gtk_widget_get_colormap(widget
);
304 /* this must be done after SetUpDC, bacause SetUpDC calls the
305 repective SetBrush, SetPen, SetBackground etc functions
306 to set up the DC. SetBackground call m_owner->SetBackground
307 and this might not be desired as the standard dc background
308 is white whereas a window might assume gray to be the
309 standard (as e.g. wxStatusBar) */
313 if (m_window
&& m_window
->m_wxwindow
&&
314 (m_window
->GetLayoutDirection() == wxLayout_RightToLeft
))
319 // origin in the upper right corner
320 m_deviceOriginX
= m_window
->GetClientSize().x
;
324 wxWindowDCImpl
::~wxWindowDCImpl()
329 g_object_unref (m_layout
);
331 pango_font_description_free( m_fontdesc
);
334 void wxWindowDCImpl
::SetUpDC( bool isMemDC
)
338 wxASSERT_MSG( !m_penGC
, wxT("GCs already created") );
342 if ((isMemDC
) && (GetSelectedBitmap().IsOk()))
344 if (GetSelectedBitmap().GetDepth() == 1)
346 m_penGC
= wxGetPoolGC( m_gdkwindow
, wxPEN_MONO
);
347 m_brushGC
= wxGetPoolGC( m_gdkwindow
, wxBRUSH_MONO
);
348 m_textGC
= wxGetPoolGC( m_gdkwindow
, wxTEXT_MONO
);
349 m_bgGC
= wxGetPoolGC( m_gdkwindow
, wxBG_MONO
);
358 m_penGC
= wxGetPoolGC( m_gdkwindow
, wxPEN_SCREEN
);
359 m_brushGC
= wxGetPoolGC( m_gdkwindow
, wxBRUSH_SCREEN
);
360 m_textGC
= wxGetPoolGC( m_gdkwindow
, wxTEXT_SCREEN
);
361 m_bgGC
= wxGetPoolGC( m_gdkwindow
, wxBG_SCREEN
);
365 m_penGC
= wxGetPoolGC( m_gdkwindow
, wxPEN_COLOUR
);
366 m_brushGC
= wxGetPoolGC( m_gdkwindow
, wxBRUSH_COLOUR
);
367 m_textGC
= wxGetPoolGC( m_gdkwindow
, wxTEXT_COLOUR
);
368 m_bgGC
= wxGetPoolGC( m_gdkwindow
, wxBG_COLOUR
);
372 /* background colour */
373 m_backgroundBrush
= *wxWHITE_BRUSH
;
374 m_backgroundBrush
.GetColour().CalcPixel( m_cmap
);
375 const GdkColor
*bg_col
= m_backgroundBrush
.GetColour().GetColor();
378 m_textForegroundColour
.CalcPixel( m_cmap
);
379 gdk_gc_set_foreground( m_textGC
, m_textForegroundColour
.GetColor() );
381 m_textBackgroundColour
.CalcPixel( m_cmap
);
382 gdk_gc_set_background( m_textGC
, m_textBackgroundColour
.GetColor() );
384 gdk_gc_set_fill( m_textGC
, GDK_SOLID
);
386 gdk_gc_set_colormap( m_textGC
, m_cmap
);
389 m_pen
.GetColour().CalcPixel( m_cmap
);
390 gdk_gc_set_foreground( m_penGC
, m_pen
.GetColour().GetColor() );
391 gdk_gc_set_background( m_penGC
, bg_col
);
393 gdk_gc_set_line_attributes( m_penGC
, 0, GDK_LINE_SOLID
, GDK_CAP_NOT_LAST
, GDK_JOIN_ROUND
);
396 m_brush
.GetColour().CalcPixel( m_cmap
);
397 gdk_gc_set_foreground( m_brushGC
, m_brush
.GetColour().GetColor() );
398 gdk_gc_set_background( m_brushGC
, bg_col
);
400 gdk_gc_set_fill( m_brushGC
, GDK_SOLID
);
403 gdk_gc_set_background( m_bgGC
, bg_col
);
404 gdk_gc_set_foreground( m_bgGC
, bg_col
);
406 gdk_gc_set_fill( m_bgGC
, GDK_SOLID
);
409 gdk_gc_set_function( m_textGC
, GDK_COPY
);
410 gdk_gc_set_function( m_brushGC
, GDK_COPY
);
411 gdk_gc_set_function( m_penGC
, GDK_COPY
);
414 gdk_gc_set_clip_rectangle( m_penGC
, NULL
);
415 gdk_gc_set_clip_rectangle( m_brushGC
, NULL
);
416 gdk_gc_set_clip_rectangle( m_textGC
, NULL
);
417 gdk_gc_set_clip_rectangle( m_bgGC
, NULL
);
420 void wxWindowDCImpl
::DoGetSize( int* width
, int* height
) const
422 wxCHECK_RET( m_window
, wxT("GetSize() doesn't work without window") );
424 m_window
->GetSize(width
, height
);
427 bool wxWindowDCImpl
::DoFloodFill(wxCoord x
, wxCoord y
,
428 const wxColour
& col
, wxFloodFillStyle style
)
431 extern bool wxDoFloodFill(wxDC
*dc
, wxCoord x
, wxCoord y
,
432 const wxColour
& col
, wxFloodFillStyle style
);
434 return wxDoFloodFill( GetOwner(), x
, y
, col
, style
);
445 bool wxWindowDCImpl
::DoGetPixel( wxCoord x1
, wxCoord y1
, wxColour
*col
) const
447 GdkImage
* image
= NULL
;
450 const int x
= LogicalToDeviceX(x1
);
451 const int y
= LogicalToDeviceY(y1
);
453 gdk_drawable_get_size(m_gdkwindow
, &rect
.width
, &rect
.height
);
454 if (rect
.Contains(x
, y
))
455 image
= gdk_drawable_get_image(m_gdkwindow
, x
, y
, 1, 1);
462 GdkColormap
* colormap
= gdk_image_get_colormap(image
);
463 const unsigned pixel
= gdk_image_get_pixel(image
, 0, 0);
464 if (colormap
== NULL
)
465 *col
= pixel ? m_textForegroundColour
: m_textBackgroundColour
;
469 gdk_colormap_query_color(colormap
, pixel
, &c
);
470 col
->Set(c
.red
>> 8, c
.green
>> 8, c
.blue
>> 8);
472 g_object_unref(image
);
476 void wxWindowDCImpl
::DoDrawLine( wxCoord x1
, wxCoord y1
, wxCoord x2
, wxCoord y2
)
478 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
480 if (m_pen
.GetStyle() != wxPENSTYLE_TRANSPARENT
)
483 gdk_draw_line( m_gdkwindow
, m_penGC
, XLOG2DEV(x1
), YLOG2DEV(y1
), XLOG2DEV(x2
), YLOG2DEV(y2
) );
485 CalcBoundingBox(x1
, y1
);
486 CalcBoundingBox(x2
, y2
);
490 void wxWindowDCImpl
::DoCrossHair( wxCoord x
, wxCoord y
)
492 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
494 if (m_pen
.GetStyle() != wxPENSTYLE_TRANSPARENT
)
498 GetOwner()->GetSize( &w
, &h
);
499 wxCoord xx
= XLOG2DEV(x
);
500 wxCoord yy
= YLOG2DEV(y
);
503 gdk_draw_line( m_gdkwindow
, m_penGC
, 0, yy
, XLOG2DEVREL(w
), yy
);
504 gdk_draw_line( m_gdkwindow
, m_penGC
, xx
, 0, xx
, YLOG2DEVREL(h
) );
509 void wxWindowDCImpl
::DrawingSetup(GdkGC
*& gc
, bool& originChanged
)
512 GdkPixmap
* pixmap
= NULL
;
513 const int style
= m_brush
.GetStyle();
515 if (style
== wxBRUSHSTYLE_STIPPLE
|| style
== wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE
)
517 const wxBitmap
* stipple
= m_brush
.GetStipple();
520 if (style
== wxBRUSHSTYLE_STIPPLE
)
521 pixmap
= stipple
->GetPixmap();
522 else if (stipple
->GetMask())
524 pixmap
= stipple
->GetPixmap();
529 else if (m_brush
.IsHatch())
531 pixmap
= GetHatch(style
);
539 gdk_drawable_get_size(pixmap
, &w
, &h
);
540 origin_x
= m_deviceOriginX
% w
;
541 origin_y
= m_deviceOriginY
% h
;
544 originChanged
= origin_x
|| origin_y
;
546 gdk_gc_set_ts_origin(gc
, origin_x
, origin_y
);
549 void wxWindowDCImpl
::DoDrawArc( wxCoord x1
, wxCoord y1
, wxCoord x2
, wxCoord y2
,
550 wxCoord xc
, wxCoord yc
)
552 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
554 wxCoord xx1
= XLOG2DEV(x1
);
555 wxCoord yy1
= YLOG2DEV(y1
);
556 wxCoord xx2
= XLOG2DEV(x2
);
557 wxCoord yy2
= YLOG2DEV(y2
);
558 wxCoord xxc
= XLOG2DEV(xc
);
559 wxCoord yyc
= YLOG2DEV(yc
);
560 double dx
= xx1
- xxc
;
561 double dy
= yy1
- yyc
;
562 double radius
= sqrt((double)(dx
*dx
+dy
*dy
));
563 wxCoord r
= (wxCoord
)radius
;
564 double radius1
, radius2
;
566 if (xx1
== xx2
&& yy1
== yy2
)
571 else if ( wxIsNullDouble(radius
) )
578 radius1
= (xx1
- xxc
== 0) ?
579 (yy1
- yyc
< 0) ?
90.0 : -90.0 :
580 -atan2(double(yy1
-yyc
), double(xx1
-xxc
)) * RAD2DEG
;
581 radius2
= (xx2
- xxc
== 0) ?
582 (yy2
- yyc
< 0) ?
90.0 : -90.0 :
583 -atan2(double(yy2
-yyc
), double(xx2
-xxc
)) * RAD2DEG
;
585 wxCoord alpha1
= wxCoord(radius1
* 64.0);
586 wxCoord alpha2
= wxCoord((radius2
- radius1
) * 64.0);
587 while (alpha2
<= 0) alpha2
+= 360*64;
588 while (alpha1
> 360*64) alpha1
-= 360*64;
592 if (m_brush
.GetStyle() != wxBRUSHSTYLE_TRANSPARENT
)
596 DrawingSetup(gc
, originChanged
);
598 gdk_draw_arc(m_gdkwindow
, gc
, true, xxc
-r
, yyc
-r
, 2*r
, 2*r
, alpha1
, alpha2
);
601 gdk_gc_set_ts_origin(gc
, 0, 0);
604 if (m_pen
.GetStyle() != wxPENSTYLE_TRANSPARENT
)
606 gdk_draw_arc( m_gdkwindow
, m_penGC
, FALSE
, xxc
-r
, yyc
-r
, 2*r
,2*r
, alpha1
, alpha2
);
608 if ((m_brush
.GetStyle() != wxBRUSHSTYLE_TRANSPARENT
) && (alpha2
- alpha1
!= 360*64))
610 gdk_draw_line( m_gdkwindow
, m_penGC
, xx1
, yy1
, xxc
, yyc
);
611 gdk_draw_line( m_gdkwindow
, m_penGC
, xxc
, yyc
, xx2
, yy2
);
616 CalcBoundingBox (x1
, y1
);
617 CalcBoundingBox (x2
, y2
);
620 void wxWindowDCImpl
::DoDrawEllipticArc( wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
, double sa
, double ea
)
622 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
624 wxCoord xx
= XLOG2DEV(x
);
625 wxCoord yy
= YLOG2DEV(y
);
626 wxCoord ww
= m_signX
* XLOG2DEVREL(width
);
627 wxCoord hh
= m_signY
* YLOG2DEVREL(height
);
629 // CMB: handle -ve width and/or height
630 if (ww
< 0) { ww
= -ww
; xx
= xx
- ww
; }
631 if (hh
< 0) { hh
= -hh
; yy
= yy
- hh
; }
635 wxCoord start
= wxCoord(sa
* 64.0);
636 wxCoord end
= wxCoord((ea
-sa
) * 64.0);
638 if (m_brush
.GetStyle() != wxBRUSHSTYLE_TRANSPARENT
)
642 DrawingSetup(gc
, originChanged
);
644 gdk_draw_arc(m_gdkwindow
, gc
, true, xx
, yy
, ww
, hh
, start
, end
);
647 gdk_gc_set_ts_origin(gc
, 0, 0);
650 if (m_pen
.GetStyle() != wxPENSTYLE_TRANSPARENT
)
651 gdk_draw_arc( m_gdkwindow
, m_penGC
, FALSE
, xx
, yy
, ww
, hh
, start
, end
);
654 CalcBoundingBox (x
, y
);
655 CalcBoundingBox (x
+ width
, y
+ height
);
658 void wxWindowDCImpl
::DoDrawPoint( wxCoord x
, wxCoord y
)
660 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
662 if ((m_pen
.GetStyle() != wxPENSTYLE_TRANSPARENT
) && m_gdkwindow
)
663 gdk_draw_point( m_gdkwindow
, m_penGC
, XLOG2DEV(x
), YLOG2DEV(y
) );
665 CalcBoundingBox (x
, y
);
668 void wxWindowDCImpl
::DoDrawLines( int n
, wxPoint points
[], wxCoord xoffset
, wxCoord yoffset
)
670 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
672 if (m_pen
.GetStyle() == wxPENSTYLE_TRANSPARENT
) return;
675 //Check, if scaling is necessary
677 xoffset
!= 0 || yoffset
!= 0 || XLOG2DEV(10) != 10 || YLOG2DEV(10) != 10;
679 // GdkPoint and wxPoint have the same memory layout, so we can cast one to the other
680 GdkPoint
* gpts
= reinterpret_cast<GdkPoint
*>(points
);
683 gpts
= new GdkPoint
[n
];
685 for (int i
= 0; i
< n
; i
++)
689 gpts
[i
].x
= XLOG2DEV(points
[i
].x
+ xoffset
);
690 gpts
[i
].y
= YLOG2DEV(points
[i
].y
+ yoffset
);
692 CalcBoundingBox(points
[i
].x
+ xoffset
, points
[i
].y
+ yoffset
);
696 gdk_draw_lines( m_gdkwindow
, m_penGC
, gpts
, n
);
702 void wxWindowDCImpl
::DoDrawPolygon( int n
, wxPoint points
[],
703 wxCoord xoffset
, wxCoord yoffset
,
704 wxPolygonFillMode
WXUNUSED(fillStyle
) )
706 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
710 //Check, if scaling is necessary
712 xoffset
!= 0 || yoffset
!= 0 || XLOG2DEV(10) != 10 || YLOG2DEV(10) != 10;
714 // GdkPoint and wxPoint have the same memory layout, so we can cast one to the other
715 GdkPoint
* gdkpoints
= reinterpret_cast<GdkPoint
*>(points
);
718 gdkpoints
= new GdkPoint
[n
];
721 for (i
= 0 ; i
< n
; i
++)
725 gdkpoints
[i
].x
= XLOG2DEV(points
[i
].x
+ xoffset
);
726 gdkpoints
[i
].y
= YLOG2DEV(points
[i
].y
+ yoffset
);
728 CalcBoundingBox(points
[i
].x
+ xoffset
, points
[i
].y
+ yoffset
);
733 if (m_brush
.GetStyle() != wxBRUSHSTYLE_TRANSPARENT
)
737 DrawingSetup(gc
, originChanged
);
739 gdk_draw_polygon(m_gdkwindow
, gc
, true, gdkpoints
, n
);
742 gdk_gc_set_ts_origin(gc
, 0, 0);
745 if (m_pen
.GetStyle() != wxPENSTYLE_TRANSPARENT
)
748 for (i = 0 ; i < n ; i++)
750 gdk_draw_line( m_gdkwindow, m_penGC,
753 gdkpoints[(i+1)%n].x,
754 gdkpoints[(i+1)%n].y);
757 gdk_draw_polygon( m_gdkwindow
, m_penGC
, FALSE
, gdkpoints
, n
);
766 void wxWindowDCImpl
::DoDrawRectangle( wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
768 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
770 wxCoord xx
= XLOG2DEV(x
);
771 wxCoord yy
= YLOG2DEV(y
);
772 wxCoord ww
= m_signX
* XLOG2DEVREL(width
);
773 wxCoord hh
= m_signY
* YLOG2DEVREL(height
);
775 // CMB: draw nothing if transformed w or h is 0
776 if (ww
== 0 || hh
== 0) return;
778 // CMB: handle -ve width and/or height
779 if (ww
< 0) { ww
= -ww
; xx
= xx
- ww
; }
780 if (hh
< 0) { hh
= -hh
; yy
= yy
- hh
; }
784 if (m_brush
.GetStyle() != wxBRUSHSTYLE_TRANSPARENT
)
788 DrawingSetup(gc
, originChanged
);
790 gdk_draw_rectangle(m_gdkwindow
, gc
, true, xx
, yy
, ww
, hh
);
793 gdk_gc_set_ts_origin(gc
, 0, 0);
796 if (m_pen
.GetStyle() != wxPENSTYLE_TRANSPARENT
)
799 if ((m_pen
.GetWidth() == 2) && (m_pen
.GetCap() == wxCAP_ROUND
) &&
800 (m_pen
.GetJoin() == wxJOIN_ROUND
) && (m_pen
.GetStyle() == wxPENSTYLE_SOLID
))
802 // Use 2 1-line rects instead
803 gdk_gc_set_line_attributes( m_penGC
, 1, GDK_LINE_SOLID
, GDK_CAP_ROUND
, GDK_JOIN_ROUND
);
808 gdk_draw_rectangle( m_gdkwindow
, m_penGC
, FALSE
, xx
+1, yy
, ww
-2, hh
-2 );
809 gdk_draw_rectangle( m_gdkwindow
, m_penGC
, FALSE
, xx
, yy
-1, ww
, hh
);
813 gdk_draw_rectangle( m_gdkwindow
, m_penGC
, FALSE
, xx
, yy
, ww
-2, hh
-2 );
814 gdk_draw_rectangle( m_gdkwindow
, m_penGC
, FALSE
, xx
-1, yy
-1, ww
, hh
);
818 gdk_gc_set_line_attributes( m_penGC
, 2, GDK_LINE_SOLID
, GDK_CAP_ROUND
, GDK_JOIN_ROUND
);
823 // Just use X11 for other cases
824 gdk_draw_rectangle( m_gdkwindow
, m_penGC
, FALSE
, xx
, yy
, ww
-1, hh
-1 );
829 CalcBoundingBox( x
, y
);
830 CalcBoundingBox( x
+ width
, y
+ height
);
833 void wxWindowDCImpl
::DoDrawRoundedRectangle( wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
, double radius
)
835 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
837 if (radius
< 0.0) radius
= - radius
* ((width
< height
) ? width
: height
);
839 wxCoord xx
= XLOG2DEV(x
);
840 wxCoord yy
= YLOG2DEV(y
);
841 wxCoord ww
= m_signX
* XLOG2DEVREL(width
);
842 wxCoord hh
= m_signY
* YLOG2DEVREL(height
);
843 wxCoord rr
= XLOG2DEVREL((wxCoord
)radius
);
845 // CMB: handle -ve width and/or height
846 if (ww
< 0) { ww
= -ww
; xx
= xx
- ww
; }
847 if (hh
< 0) { hh
= -hh
; yy
= yy
- hh
; }
849 // CMB: if radius is zero use DrawRectangle() instead to avoid
850 // X drawing errors with small radii
853 DoDrawRectangle( x
, y
, width
, height
);
857 // CMB: draw nothing if transformed w or h is 0
858 if (ww
== 0 || hh
== 0) return;
860 // CMB: adjust size if outline is drawn otherwise the result is
861 // 1 pixel too wide and high
862 if (m_pen
.GetStyle() != wxPENSTYLE_TRANSPARENT
)
870 // CMB: ensure dd is not larger than rectangle otherwise we
871 // get an hour glass shape
873 if (dd
> ww
) dd
= ww
;
874 if (dd
> hh
) dd
= hh
;
877 if (m_brush
.GetStyle() != wxBRUSHSTYLE_TRANSPARENT
)
881 DrawingSetup(gc
, originChanged
);
883 gdk_draw_rectangle(m_gdkwindow
, gc
, true, xx
+rr
, yy
, ww
-dd
+1, hh
);
884 gdk_draw_rectangle(m_gdkwindow
, gc
, true, xx
, yy
+rr
, ww
, hh
-dd
+1);
885 gdk_draw_arc(m_gdkwindow
, gc
, true, xx
, yy
, dd
, dd
, 90*64, 90*64);
886 gdk_draw_arc(m_gdkwindow
, gc
, true, xx
+ww
-dd
, yy
, dd
, dd
, 0, 90*64);
887 gdk_draw_arc(m_gdkwindow
, gc
, true, xx
+ww
-dd
, yy
+hh
-dd
, dd
, dd
, 270*64, 90*64);
888 gdk_draw_arc(m_gdkwindow
, gc
, true, xx
, yy
+hh
-dd
, dd
, dd
, 180*64, 90*64);
891 gdk_gc_set_ts_origin(gc
, 0, 0);
894 if (m_pen
.GetStyle() != wxPENSTYLE_TRANSPARENT
)
896 gdk_draw_line( m_gdkwindow
, m_penGC
, xx
+rr
+1, yy
, xx
+ww
-rr
, yy
);
897 gdk_draw_line( m_gdkwindow
, m_penGC
, xx
+rr
+1, yy
+hh
, xx
+ww
-rr
, yy
+hh
);
898 gdk_draw_line( m_gdkwindow
, m_penGC
, xx
, yy
+rr
+1, xx
, yy
+hh
-rr
);
899 gdk_draw_line( m_gdkwindow
, m_penGC
, xx
+ww
, yy
+rr
+1, xx
+ww
, yy
+hh
-rr
);
900 gdk_draw_arc( m_gdkwindow
, m_penGC
, FALSE
, xx
, yy
, dd
, dd
, 90*64, 90*64 );
901 gdk_draw_arc( m_gdkwindow
, m_penGC
, FALSE
, xx
+ww
-dd
, yy
, dd
, dd
, 0, 90*64 );
902 gdk_draw_arc( m_gdkwindow
, m_penGC
, FALSE
, xx
+ww
-dd
, yy
+hh
-dd
, dd
, dd
, 270*64, 90*64 );
903 gdk_draw_arc( m_gdkwindow
, m_penGC
, FALSE
, xx
, yy
+hh
-dd
, dd
, dd
, 180*64, 90*64 );
907 // this ignores the radius
908 CalcBoundingBox( x
, y
);
909 CalcBoundingBox( x
+ width
, y
+ height
);
912 void wxWindowDCImpl
::DoDrawEllipse( wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
914 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
916 wxCoord xx
= XLOG2DEV(x
);
917 wxCoord yy
= YLOG2DEV(y
);
918 wxCoord ww
= m_signX
* XLOG2DEVREL(width
);
919 wxCoord hh
= m_signY
* YLOG2DEVREL(height
);
921 // CMB: handle -ve width and/or height
922 if (ww
< 0) { ww
= -ww
; xx
= xx
- ww
; }
923 if (hh
< 0) { hh
= -hh
; yy
= yy
- hh
; }
927 if (m_brush
.GetStyle() != wxBRUSHSTYLE_TRANSPARENT
)
931 DrawingSetup(gc
, originChanged
);
933 // If the pen is transparent pen we increase the size
934 // for better compatibility with other platforms.
935 if (m_pen
.GetStyle() == wxPENSTYLE_TRANSPARENT
)
941 gdk_draw_arc(m_gdkwindow
, gc
, true, xx
, yy
, ww
, hh
, 0, 360*64);
944 gdk_gc_set_ts_origin(gc
, 0, 0);
947 if (m_pen
.GetStyle() != wxPENSTYLE_TRANSPARENT
)
948 gdk_draw_arc( m_gdkwindow
, m_penGC
, false, xx
, yy
, ww
, hh
, 0, 360*64 );
951 CalcBoundingBox( x
, y
);
952 CalcBoundingBox( x
+ width
, y
+ height
);
955 void wxWindowDCImpl
::DoDrawIcon( const wxIcon
&icon
, wxCoord x
, wxCoord y
)
957 // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
958 DoDrawBitmap( (const wxBitmap
&)icon
, x
, y
, true );
961 // scale a pixbuf, return new pixbuf, unref old one
963 Scale(GdkPixbuf
* pixbuf
, int dst_w
, int dst_h
, double sx
, double sy
)
965 GdkPixbuf
* pixbuf_scaled
= gdk_pixbuf_new(
966 GDK_COLORSPACE_RGB
, gdk_pixbuf_get_has_alpha(pixbuf
), 8, dst_w
, dst_h
);
967 gdk_pixbuf_scale(pixbuf
, pixbuf_scaled
,
968 0, 0, dst_w
, dst_h
, 0, 0, sx
, sy
, GDK_INTERP_NEAREST
);
969 g_object_unref(pixbuf
);
970 return pixbuf_scaled
;
973 // scale part of a pixmap using pixbuf scaling, return pixbuf
975 Scale(GdkPixmap
* pixmap
, int x
, int y
, int w
, int h
, int dst_w
, int dst_h
, double sx
, double sy
)
977 GdkPixbuf
* pixbuf
= gdk_pixbuf_get_from_drawable(
978 NULL
, pixmap
, NULL
, x
, y
, 0, 0, w
, h
);
979 return Scale(pixbuf
, dst_w
, dst_h
, sx
, sy
);
982 // scale part of a mask pixmap, return new mask, unref old one
984 ScaleMask(GdkPixmap
* mask
, int x
, int y
, int w
, int h
, int dst_w
, int dst_h
, double sx
, double sy
)
986 GdkPixbuf
* pixbuf
= Scale(mask
, x
, y
, w
, h
, dst_w
, dst_h
, sx
, sy
);
988 // convert black and white pixbuf back to a mono pixmap
989 const unsigned out_rowstride
= (dst_w
+ 7) / 8;
990 const size_t data_size
= out_rowstride
* size_t(dst_h
);
991 char* data
= new char[data_size
];
993 const guchar
* row
= gdk_pixbuf_get_pixels(pixbuf
);
994 const int rowstride
= gdk_pixbuf_get_rowstride(pixbuf
);
995 memset(data
, 0, data_size
);
996 for (int j
= 0; j
< dst_h
; j
++, row
+= rowstride
, out
+= out_rowstride
)
998 const guchar
* in
= row
;
999 for (int i
= 0; i
< dst_w
; i
++, in
+= 3)
1001 out
[i
>> 3] |= 1 << (i
& 7);
1003 g_object_unref(pixbuf
);
1004 GdkPixmap
* pixmap
= gdk_bitmap_create_from_data(mask
, data
, dst_w
, dst_h
);
1006 g_object_unref(mask
);
1010 // Make a new mask from part of a mask and a clip region.
1011 // Return new mask, unref old one.
1013 ClipMask(GdkPixmap
* mask
, GdkRegion
* clipRegion
, int x
, int y
, int dst_x
, int dst_y
, int w
, int h
)
1015 GdkGCValues gcValues
;
1016 gcValues
.foreground
.pixel
= 0;
1017 GdkGC
* gc
= gdk_gc_new_with_values(mask
, &gcValues
, GDK_GC_FOREGROUND
);
1018 GdkPixmap
* pixmap
= gdk_pixmap_new(mask
, w
, h
, 1);
1019 // clear new mask, so clipped areas will be masked
1020 gdk_draw_rectangle(pixmap
, gc
, true, 0, 0, w
, h
);
1021 gdk_gc_set_clip_region(gc
, clipRegion
);
1022 gdk_gc_set_clip_origin(gc
, -dst_x
, -dst_y
);
1023 // draw old mask onto new one, with clip
1024 gdk_draw_drawable(pixmap
, gc
, mask
, x
, y
, 0, 0, w
, h
);
1026 g_object_unref(mask
);
1030 // make a color pixmap from part of a mono one, using text fg/bg colors
1032 wxWindowDCImpl
::MonoToColor(GdkPixmap
* monoPixmap
, int x
, int y
, int w
, int h
) const
1034 GdkPixmap
* pixmap
= gdk_pixmap_new(m_gdkwindow
, w
, h
, -1);
1035 GdkGCValues gcValues
;
1036 gcValues
.foreground
.pixel
= m_textForegroundColour
.GetColor()->pixel
;
1037 gcValues
.background
.pixel
= m_textBackgroundColour
.GetColor()->pixel
;
1038 gcValues
.stipple
= monoPixmap
;
1039 gcValues
.fill
= GDK_OPAQUE_STIPPLED
;
1040 gcValues
.ts_x_origin
= -x
;
1041 gcValues
.ts_y_origin
= -y
;
1042 GdkGC
* gc
= gdk_gc_new_with_values(pixmap
, &gcValues
, GdkGCValuesMask(
1043 GDK_GC_FOREGROUND
| GDK_GC_BACKGROUND
| GDK_GC_STIPPLE
| GDK_GC_FILL
|
1044 GDK_GC_TS_X_ORIGIN
| GDK_GC_TS_Y_ORIGIN
));
1045 gdk_draw_rectangle(pixmap
, gc
, true, 0, 0, w
, h
);
1050 void wxWindowDCImpl
::DoDrawBitmap( const wxBitmap
&bitmap
,
1051 wxCoord x
, wxCoord y
,
1054 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1055 wxCHECK_RET( bitmap
.IsOk(), wxT("invalid bitmap") );
1057 if (!m_gdkwindow
) return;
1059 const int w
= bitmap
.GetWidth();
1060 const int h
= bitmap
.GetHeight();
1062 CalcBoundingBox(x
, y
);
1063 CalcBoundingBox(x
+ w
, y
+ h
);
1066 int xx
= LogicalToDeviceX(x
);
1067 const int yy
= LogicalToDeviceY(y
);
1068 const int ww
= LogicalToDeviceXRel(w
);
1069 const int hh
= LogicalToDeviceYRel(h
);
1071 if (m_window
&& m_window
->GetLayoutDirection() == wxLayout_RightToLeft
)
1074 GdkRegion
* const clipRegion
= m_currentClippingRegion
.GetRegion();
1075 // determine clip region overlap
1076 int overlap
= wxInRegion
;
1079 overlap
= m_currentClippingRegion
.Contains(xx
, yy
, ww
, hh
);
1080 if (overlap
== wxOutRegion
)
1084 const bool isScaled
= ww
!= w
|| hh
!= h
;
1085 const bool hasAlpha
= bitmap
.HasAlpha();
1086 GdkGC
* const use_gc
= m_penGC
;
1088 GdkPixmap
* mask
= NULL
;
1089 // mask does not work when drawing a pixbuf with alpha
1090 if (useMask
&& !hasAlpha
)
1092 wxMask
* m
= bitmap
.GetMask();
1094 mask
= m
->GetBitmap();
1100 mask
= ScaleMask(mask
, 0, 0, w
, h
, ww
, hh
, m_scaleX
, m_scaleY
);
1101 if (overlap
== wxPartRegion
)
1103 // need a new mask that also masks the clipped area,
1104 // because gc can't have both a mask and a clip region
1105 mask
= ClipMask(mask
, clipRegion
, 0, 0, xx
, yy
, ww
, hh
);
1107 gdk_gc_set_clip_mask(use_gc
, mask
);
1108 gdk_gc_set_clip_origin(use_gc
, xx
, yy
);
1111 // determine whether to use pixmap or pixbuf
1112 GdkPixmap
* pixmap
= NULL
;
1113 GdkPixbuf
* pixbuf
= NULL
;
1114 if (bitmap
.HasPixmap())
1115 pixmap
= bitmap
.GetPixmap();
1116 if (pixmap
&& gdk_drawable_get_depth(pixmap
) == 1)
1118 // convert mono pixmap to color using text fg/bg colors
1119 pixmap
= MonoToColor(pixmap
, 0, 0, w
, h
);
1121 else if (hasAlpha
|| pixmap
== NULL
)
1124 pixbuf
= bitmap
.GetPixbuf();
1125 g_object_ref(pixbuf
);
1129 g_object_ref(pixmap
);
1135 pixbuf
= Scale(pixbuf
, ww
, hh
, m_scaleX
, m_scaleY
);
1137 pixbuf
= Scale(pixmap
, 0, 0, w
, h
, ww
, hh
, m_scaleX
, m_scaleY
);
1142 gdk_draw_pixbuf(m_gdkwindow
, use_gc
, pixbuf
,
1143 0, 0, xx
, yy
, ww
, hh
, GDK_RGB_DITHER_NORMAL
, 0, 0);
1144 g_object_unref(pixbuf
);
1148 gdk_draw_drawable(m_gdkwindow
, use_gc
, pixmap
, 0, 0, xx
, yy
, ww
, hh
);
1152 g_object_unref(pixmap
);
1155 g_object_unref(mask
);
1156 gdk_gc_set_clip_region(use_gc
, clipRegion
);
1160 bool wxWindowDCImpl
::DoBlit( wxCoord xdest
, wxCoord ydest
,
1161 wxCoord width
, wxCoord height
,
1163 wxCoord xsrc
, wxCoord ysrc
,
1164 wxRasterOperationMode logical_func
,
1166 wxCoord xsrcMask
, wxCoord ysrcMask
)
1168 wxCHECK_MSG( IsOk(), false, wxT("invalid window dc") );
1169 wxCHECK_MSG( source
, false, wxT("invalid source dc") );
1171 if (!m_gdkwindow
) return false;
1173 GdkDrawable
* srcDrawable
= NULL
;
1174 GdkPixmap
* mask
= NULL
;
1175 wxMemoryDC
* memDC
= wxDynamicCast(source
, wxMemoryDC
);
1178 const wxBitmap
& bitmap
= memDC
->GetSelectedBitmap();
1181 srcDrawable
= bitmap
.GetPixmap();
1184 wxMask
* m
= bitmap
.GetMask();
1186 mask
= m
->GetBitmap();
1191 wxDCImpl
* impl
= source
->GetImpl();
1192 wxWindowDCImpl
* gtk_impl
= wxDynamicCast(impl
, wxWindowDCImpl
);
1194 srcDrawable
= gtk_impl
->GetGDKWindow();
1195 if (srcDrawable
== NULL
)
1199 CalcBoundingBox(xdest
, ydest
);
1200 CalcBoundingBox(xdest
+ width
, ydest
+ height
);
1202 // source device coords
1203 int src_x
= source
->LogicalToDeviceX(xsrc
);
1204 int src_y
= source
->LogicalToDeviceY(ysrc
);
1205 int src_w
= source
->LogicalToDeviceXRel(width
);
1206 int src_h
= source
->LogicalToDeviceYRel(height
);
1208 // Clip source rect to source dc.
1209 // Only necessary when scaling, to avoid GDK errors when
1210 // converting to pixbuf, but no harm in always doing it.
1211 // If source rect changes, it also changes the dest rect.
1213 gdk_drawable_get_size(srcDrawable
, &clip
.width
, &clip
.height
);
1214 clip
.Intersect(wxRect(src_x
, src_y
, src_w
, src_h
));
1215 if (src_w
!= clip
.width
|| src_h
!= clip
.height
)
1217 if (clip
.width
== 0)
1221 src_h
= clip
.height
;
1222 width
= source
->DeviceToLogicalXRel(src_w
);
1223 height
= source
->DeviceToLogicalYRel(src_h
);
1224 if (src_x
!= clip
.x
|| src_y
!= clip
.y
)
1226 xdest
+= source
->DeviceToLogicalXRel(clip
.x
- src_x
);
1227 ydest
+= source
->DeviceToLogicalYRel(clip
.y
- src_y
);
1233 // destination device coords
1234 const int dst_x
= LogicalToDeviceX(xdest
);
1235 const int dst_y
= LogicalToDeviceY(ydest
);
1236 const int dst_w
= LogicalToDeviceXRel(width
);
1237 const int dst_h
= LogicalToDeviceYRel(height
);
1239 GdkRegion
* const clipRegion
= m_currentClippingRegion
.GetRegion();
1240 // determine dest clip region overlap
1241 int overlap
= wxInRegion
;
1244 overlap
= m_currentClippingRegion
.Contains(dst_x
, dst_y
, dst_w
, dst_h
);
1245 if (overlap
== wxOutRegion
)
1249 const bool isScaled
= src_w
!= dst_w
|| src_h
!= dst_h
;
1254 // get source to dest scale
1255 double usx
, usy
, lsx
, lsy
;
1256 source
->GetUserScale(&usx
, &usy
);
1257 source
->GetLogicalScale(&lsx
, &lsy
);
1258 scale_x
= m_scaleX
/ (usx
* lsx
);
1259 scale_y
= m_scaleY
/ (usy
* lsy
);
1262 GdkGC
* const use_gc
= m_penGC
;
1267 int srcMask_x
= src_x
;
1268 int srcMask_y
= src_y
;
1269 if (xsrcMask
!= -1 || ysrcMask
!= -1)
1271 srcMask_x
= source
->LogicalToDeviceX(xsrcMask
);
1272 srcMask_y
= source
->LogicalToDeviceY(ysrcMask
);
1276 mask
= ScaleMask(mask
, srcMask_x
, srcMask_y
,
1277 src_w
, src_h
, dst_w
, dst_h
, scale_x
, scale_y
);
1281 if (overlap
== wxPartRegion
)
1283 // need a new mask that also masks the clipped area,
1284 // because gc can't have both a mask and a clip region
1285 mask
= ClipMask(mask
, clipRegion
,
1286 srcMask_x
, srcMask_y
, dst_x
, dst_y
, dst_w
, dst_h
);
1290 gdk_gc_set_clip_mask(use_gc
, mask
);
1291 gdk_gc_set_clip_origin(use_gc
, dst_x
- srcMask_x
, dst_y
- srcMask_y
);
1294 GdkPixmap
* pixmap
= NULL
;
1295 if (gdk_drawable_get_depth(srcDrawable
) == 1)
1297 // Convert mono pixmap to color using text fg/bg colors.
1298 // Scaling/drawing is simpler if this is done first.
1299 pixmap
= MonoToColor(srcDrawable
, src_x
, src_y
, src_w
, src_h
);
1300 srcDrawable
= pixmap
;
1305 const wxRasterOperationMode logical_func_save
= m_logicalFunction
;
1306 SetLogicalFunction(logical_func
);
1308 gdk_gc_set_subwindow(use_gc
, GDK_INCLUDE_INFERIORS
);
1312 GdkPixbuf
* pixbuf
= Scale(srcDrawable
,
1313 src_x
, src_y
, src_w
, src_h
, dst_w
, dst_h
, scale_x
, scale_y
);
1314 gdk_draw_pixbuf(m_gdkwindow
, use_gc
, pixbuf
,
1315 0, 0, dst_x
, dst_y
, dst_w
, dst_h
, GDK_RGB_DITHER_NONE
, 0, 0);
1316 g_object_unref(pixbuf
);
1320 gdk_draw_drawable(m_gdkwindow
, use_gc
, srcDrawable
,
1321 src_x
, src_y
, dst_x
, dst_y
, dst_w
, dst_h
);
1324 SetLogicalFunction(logical_func_save
);
1326 gdk_gc_set_subwindow(use_gc
, GDK_CLIP_BY_CHILDREN
);
1329 g_object_unref(pixmap
);
1332 g_object_unref(mask
);
1333 gdk_gc_set_clip_region(use_gc
, clipRegion
);
1338 void wxWindowDCImpl
::DoDrawText(const wxString
& text
,
1342 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1344 if (!m_gdkwindow
) return;
1346 if (text
.empty()) return;
1348 wxCoord x
= XLOG2DEV(xLogical
),
1349 y
= YLOG2DEV(yLogical
);
1351 wxCHECK_RET( m_context
, wxT("no Pango context") );
1352 wxCHECK_RET( m_layout
, wxT("no Pango layout") );
1353 wxCHECK_RET( m_fontdesc
, wxT("no Pango font description") );
1355 gdk_pango_context_set_colormap( m_context
, m_cmap
); // not needed in gtk+ >= 2.6
1357 bool underlined
= m_font
.IsOk() && m_font
.GetUnderlined();
1359 wxCharBuffer data
= wxGTK_CONV(text
);
1362 size_t datalen
= strlen(data
);
1364 // in Pango >= 1.16 the "underline of leading/trailing spaces" bug
1365 // has been fixed and thus the hack implemented below should never be used
1366 static bool pangoOk
= !wx_pango_version_check(1, 16, 0);
1368 bool needshack
= underlined
&& !pangoOk
;
1372 // a PangoLayout which has leading/trailing spaces with underlined font
1373 // is not correctly drawn by this pango version: Pango won't underline the spaces.
1374 // This can be a problem; e.g. wxHTML rendering of underlined text relies on
1375 // this behaviour. To workaround this problem, we use a special hack here
1376 // suggested by pango maintainer Behdad Esfahbod: we prepend and append two
1377 // empty space characters and give them a dummy colour attribute.
1378 // This will force Pango to underline the leading/trailing spaces, too.
1380 wxCharBuffer
data_tmp(datalen
+ 6);
1381 // copy the leading U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
1382 memcpy(data_tmp
.data(), "\342\200\214", 3);
1383 // copy the user string
1384 memcpy(data_tmp
.data() + 3, data
, datalen
);
1385 // copy the trailing U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
1386 memcpy(data_tmp
.data() + 3 + datalen
, "\342\200\214", 3);
1392 pango_layout_set_text(m_layout
, data
, datalen
);
1396 PangoAttrList
*attrs
= pango_attr_list_new();
1397 PangoAttribute
*a
= pango_attr_underline_new(PANGO_UNDERLINE_SINGLE
);
1399 a
->end_index
= datalen
;
1400 pango_attr_list_insert(attrs
, a
);
1404 // dummy colour for the leading space
1405 a
= pango_attr_foreground_new (0x0057, 0x52A9, 0xD614);
1408 pango_attr_list_insert(attrs
, a
);
1410 // dummy colour for the trailing space
1411 a
= pango_attr_foreground_new (0x0057, 0x52A9, 0xD614);
1412 a
->start_index
= datalen
- 1;
1413 a
->end_index
= datalen
;
1414 pango_attr_list_insert(attrs
, a
);
1417 pango_layout_set_attributes(m_layout
, attrs
);
1418 pango_attr_list_unref(attrs
);
1422 const bool isScaled
= fabs(m_scaleY
- 1.0) > 0.00001;
1425 // If there is a user or actually any scale applied to
1426 // the device context, scale the font.
1428 // scale font description
1429 oldSize
= pango_font_description_get_size(m_fontdesc
);
1430 pango_font_description_set_size(m_fontdesc
, int(oldSize
* m_scaleY
));
1432 // actually apply scaled font
1433 pango_layout_set_font_description( m_layout
, m_fontdesc
);
1437 pango_layout_get_pixel_size(m_layout
, &w
, &h
);
1441 if (m_window
&& m_window
->GetLayoutDirection() == wxLayout_RightToLeft
)
1444 const GdkColor
* bg_col
= NULL
;
1445 if (m_backgroundMode
== wxBRUSHSTYLE_SOLID
)
1446 bg_col
= m_textBackgroundColour
.GetColor();
1448 gdk_draw_layout_with_colors(m_gdkwindow
, m_textGC
, x_rtl
, y
, m_layout
, NULL
, bg_col
);
1452 // reset unscaled size
1453 pango_font_description_set_size( m_fontdesc
, oldSize
);
1455 // actually apply unscaled font
1456 pango_layout_set_font_description( m_layout
, m_fontdesc
);
1460 // undo underline attributes setting:
1461 pango_layout_set_attributes(m_layout
, NULL
);
1464 CalcBoundingBox(xLogical
+ int(w
/ m_scaleX
), yLogical
+ int(h
/ m_scaleY
));
1465 CalcBoundingBox(xLogical
, yLogical
);
1468 // TODO: When GTK2.6 is required, merge DoDrawText and DoDrawRotatedText to
1469 // avoid code duplication
1470 void wxWindowDCImpl
::DoDrawRotatedText( const wxString
&text
, wxCoord x
, wxCoord y
, double angle
)
1472 if (!m_gdkwindow
|| text
.empty())
1475 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1478 if (!gtk_check_version(2,6,0))
1483 pango_layout_set_text(m_layout
, wxGTK_CONV(text
), -1);
1485 if (m_font
.GetUnderlined())
1487 PangoAttrList
*attrs
= pango_attr_list_new();
1488 PangoAttribute
*a
= pango_attr_underline_new(PANGO_UNDERLINE_SINGLE
);
1489 pango_attr_list_insert(attrs
, a
);
1490 pango_layout_set_attributes(m_layout
, attrs
);
1491 pango_attr_list_unref(attrs
);
1495 const bool isScaled
= fabs(m_scaleY
- 1.0) > 0.00001;
1498 //TODO: when Pango >= 1.6 is required, use pango_matrix_scale()
1499 // If there is a user or actually any scale applied to
1500 // the device context, scale the font.
1502 // scale font description
1503 oldSize
= pango_font_description_get_size(m_fontdesc
);
1504 pango_font_description_set_size(m_fontdesc
, int(oldSize
* m_scaleY
));
1506 // actually apply scaled font
1507 pango_layout_set_font_description( m_layout
, m_fontdesc
);
1511 pango_layout_get_pixel_size(m_layout
, &w
, &h
);
1513 const GdkColor
* bg_col
= NULL
;
1514 if (m_backgroundMode
== wxBRUSHSTYLE_SOLID
)
1515 bg_col
= m_textBackgroundColour
.GetColor();
1518 PangoMatrix matrix
= PANGO_MATRIX_INIT
;
1519 pango_matrix_rotate (&matrix
, angle
);
1520 pango_context_set_matrix (m_context
, &matrix
);
1521 pango_layout_context_changed (m_layout
);
1523 // To be compatible with MSW, the rotation axis must be in the old
1525 // Calculate the vertices of the rotated rectangle containing the text,
1526 // relative to the old top-left vertex.
1527 // We could use the matrix for this, but it's simpler with trignonometry.
1528 double rad
= DegToRad(angle
);
1529 // the rectangle vertices are counted clockwise with the first one
1531 double x2
= w
* cos(rad
);
1532 double y2
= -w
* sin(rad
); // y axis points to the bottom, hence minus
1533 double x4
= h
* sin(rad
);
1534 double y4
= h
* cos(rad
);
1535 double x3
= x4
+ x2
;
1536 double y3
= y4
+ y2
;
1537 // Then we calculate max and min of the rotated rectangle.
1538 wxCoord maxX
= (wxCoord
)(dmax(dmax(0, x2
), dmax(x3
, x4
)) + 0.5),
1539 maxY
= (wxCoord
)(dmax(dmax(0, y2
), dmax(y3
, y4
)) + 0.5),
1540 minX
= (wxCoord
)(dmin(dmin(0, x2
), dmin(x3
, x4
)) - 0.5),
1541 minY
= (wxCoord
)(dmin(dmin(0, y2
), dmin(y3
, y4
)) - 0.5);
1543 gdk_draw_layout_with_colors(m_gdkwindow
, m_textGC
, x
+minX
, y
+minY
,
1544 m_layout
, NULL
, bg_col
);
1546 if (m_font
.GetUnderlined())
1547 pango_layout_set_attributes(m_layout
, NULL
);
1549 // clean up the transformation matrix
1550 pango_context_set_matrix(m_context
, NULL
);
1554 // reset unscaled size
1555 pango_font_description_set_size( m_fontdesc
, oldSize
);
1557 // actually apply unscaled font
1558 pango_layout_set_font_description( m_layout
, m_fontdesc
);
1561 CalcBoundingBox(x
+minX
, y
+minY
);
1562 CalcBoundingBox(x
+maxX
, y
+maxY
);
1565 #endif //__WXGTK26__
1568 if ( wxIsNullDouble(angle
) )
1570 DoDrawText(text
, x
, y
);
1577 // TODO: implement later without GdkFont for GTK 2.0
1578 DoGetTextExtent(text
, &w
, &h
, NULL
,NULL
, &m_font
);
1580 // draw the string normally
1583 dc
.SelectObject(src
);
1584 dc
.SetFont(GetFont());
1585 dc
.SetBackground(*wxBLACK_BRUSH
);
1586 dc
.SetBrush(*wxBLACK_BRUSH
);
1588 dc
.SetTextForeground( *wxWHITE
);
1589 dc
.DrawText(text
, 0, 0);
1590 dc
.SelectObject(wxNullBitmap
);
1592 // Calculate the size of the rotated bounding box.
1593 double rad
= DegToRad(angle
);
1594 double dx
= cos(rad
),
1597 // the rectngle vertices are counted clockwise with the first one being at
1598 // (0, 0) (or, rather, at (x, y))
1600 y2
= -w
*dy
; // y axis points to the bottom, hence minus
1603 double x3
= x4
+ x2
,
1607 wxCoord maxX
= (wxCoord
)(dmax(x2
, dmax(x3
, x4
)) + 0.5),
1608 maxY
= (wxCoord
)(dmax(y2
, dmax(y3
, y4
)) + 0.5),
1609 minX
= (wxCoord
)(dmin(x2
, dmin(x3
, x4
)) - 0.5),
1610 minY
= (wxCoord
)(dmin(y2
, dmin(y3
, y4
)) - 0.5);
1613 wxImage image
= src
.ConvertToImage();
1615 image
.ConvertColourToAlpha( m_textForegroundColour
.Red(),
1616 m_textForegroundColour
.Green(),
1617 m_textForegroundColour
.Blue() );
1618 image
= image
.Rotate( rad
, wxPoint(0,0) );
1620 int i_angle
= (int) angle
;
1621 i_angle
= i_angle
% 360;
1625 if ((i_angle
>= 90.0) && (i_angle
< 270.0))
1626 xoffset
= image
.GetWidth();
1628 if ((i_angle
>= 0.0) && (i_angle
< 180.0))
1629 yoffset
= image
.GetHeight();
1631 if ((i_angle
>= 0) && (i_angle
< 90))
1632 yoffset
-= (int)( cos(rad
)*h
);
1633 if ((i_angle
>= 90) && (i_angle
< 180))
1634 xoffset
-= (int)( sin(rad
)*h
);
1635 if ((i_angle
>= 180) && (i_angle
< 270))
1636 yoffset
-= (int)( cos(rad
)*h
);
1637 if ((i_angle
>= 270) && (i_angle
< 360))
1638 xoffset
-= (int)( sin(rad
)*h
);
1640 int i_x
= x
- xoffset
;
1641 int i_y
= y
- yoffset
;
1644 DoDrawBitmap( src
, i_x
, i_y
, true );
1647 // it would be better to draw with non underlined font and draw the line
1648 // manually here (it would be more straight...)
1650 if ( m_font
.GetUnderlined() )
1652 gdk_draw_line( m_gdkwindow
, m_textGC
,
1653 XLOG2DEV(x
+ x4
), YLOG2DEV(y
+ y4
+ font
->descent
),
1654 XLOG2DEV(x
+ x3
), YLOG2DEV(y
+ y3
+ font
->descent
));
1658 // update the bounding box
1659 CalcBoundingBox(x
+ minX
, y
+ minY
);
1660 CalcBoundingBox(x
+ maxX
, y
+ maxY
);
1661 #else // !wxUSE_IMAGE
1666 #endif // wxUSE_IMAGE/!wxUSE_IMAGE
1670 void wxWindowDCImpl
::DoGetTextExtent(const wxString
&string
,
1671 wxCoord
*width
, wxCoord
*height
,
1672 wxCoord
*descent
, wxCoord
*externalLeading
,
1673 const wxFont
*theFont
) const
1681 if ( externalLeading
)
1682 *externalLeading
= 0;
1687 // ensure that theFont is always non-NULL
1688 if ( !theFont
|| !theFont
->IsOk() )
1691 // and use it if it's valid
1692 if ( theFont
->IsOk() )
1694 pango_layout_set_font_description
1697 theFont
->GetNativeFontInfo()->description
1701 // Set layout's text
1702 const wxCharBuffer dataUTF8
= wxGTK_CONV_FONT(string
, *theFont
);
1705 // hardly ideal, but what else can we do if conversion failed?
1709 pango_layout_set_text(m_layout
, dataUTF8
, -1);
1712 pango_layout_get_pixel_size(m_layout
, width
, &h
);
1715 PangoLayoutIter
*iter
= pango_layout_get_iter(m_layout
);
1716 int baseline
= pango_layout_iter_get_baseline(iter
);
1717 pango_layout_iter_free(iter
);
1718 *descent
= h
- PANGO_PIXELS(baseline
);
1723 // Reset old font description
1724 if (theFont
->IsOk())
1725 pango_layout_set_font_description( m_layout
, m_fontdesc
);
1729 bool wxWindowDCImpl
::DoGetPartialTextExtents(const wxString
& text
,
1730 wxArrayInt
& widths
) const
1732 const size_t len
= text
.length();
1739 // Set layout's text
1740 const wxCharBuffer dataUTF8
= wxGTK_CONV_FONT(text
, m_font
);
1743 // hardly ideal, but what else can we do if conversion failed?
1744 wxLogLastError(wxT("DoGetPartialTextExtents"));
1748 pango_layout_set_text(m_layout
, dataUTF8
, -1);
1750 // Calculate the position of each character based on the widths of
1751 // the previous characters
1753 // Code borrowed from Scintilla's PlatGTK
1754 PangoLayoutIter
*iter
= pango_layout_get_iter(m_layout
);
1756 pango_layout_iter_get_cluster_extents(iter
, NULL
, &pos
);
1758 while (pango_layout_iter_next_cluster(iter
))
1760 pango_layout_iter_get_cluster_extents(iter
, NULL
, &pos
);
1761 int position
= PANGO_PIXELS(pos
.x
);
1762 widths
[i
++] = position
;
1765 widths
[i
++] = PANGO_PIXELS(pos
.x
+ pos
.width
);
1766 pango_layout_iter_free(iter
);
1772 wxCoord wxWindowDCImpl
::GetCharWidth() const
1774 pango_layout_set_text( m_layout
, "H", 1 );
1776 pango_layout_get_pixel_size( m_layout
, &w
, NULL
);
1780 wxCoord wxWindowDCImpl
::GetCharHeight() const
1782 PangoFontMetrics
*metrics
= pango_context_get_metrics (m_context
, m_fontdesc
, pango_context_get_language(m_context
));
1783 wxCHECK_MSG( metrics
, -1, wxT("failed to get pango font metrics") );
1785 wxCoord h
= PANGO_PIXELS (pango_font_metrics_get_descent (metrics
) +
1786 pango_font_metrics_get_ascent (metrics
));
1787 pango_font_metrics_unref (metrics
);
1791 void wxWindowDCImpl
::Clear()
1793 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1795 if (!m_gdkwindow
) return;
1798 DoGetSize( &width
, &height
);
1799 gdk_draw_rectangle( m_gdkwindow
, m_bgGC
, TRUE
, 0, 0, width
, height
);
1802 void wxWindowDCImpl
::SetFont( const wxFont
&font
)
1809 pango_font_description_free( m_fontdesc
);
1811 m_fontdesc
= pango_font_description_copy( m_font
.GetNativeFontInfo()->description
);
1816 PangoContext
*oldContext
= m_context
;
1818 m_context
= m_window
->GTKGetPangoDefaultContext();
1820 // If we switch back/forth between different contexts
1821 // we also have to create a new layout. I think so,
1822 // at least, and it doesn't hurt to do it.
1823 if (oldContext
!= m_context
)
1826 g_object_unref (m_layout
);
1828 m_layout
= pango_layout_new( m_context
);
1832 pango_layout_set_font_description( m_layout
, m_fontdesc
);
1836 void wxWindowDCImpl
::SetPen( const wxPen
&pen
)
1838 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1840 if (m_pen
== pen
) return;
1844 if (!m_pen
.IsOk()) return;
1846 if (!m_gdkwindow
) return;
1848 gint width
= m_pen
.GetWidth();
1851 // CMB: if width is non-zero scale it with the dc
1856 // X doesn't allow different width in x and y and so we take
1859 ( fabs((double) XLOG2DEVREL(width
)) +
1860 fabs((double) YLOG2DEVREL(width
)) ) / 2.0;
1864 // width can't be 0 or an internal GTK error occurs inside
1865 // gdk_gc_set_dashes() below
1870 static const wxGTKDash dotted
[] = {1, 1};
1871 static const wxGTKDash short_dashed
[] = {2, 2};
1872 static const wxGTKDash wxCoord_dashed
[] = {2, 4};
1873 static const wxGTKDash dotted_dashed
[] = {3, 3, 1, 3};
1875 // We express dash pattern in pen width unit, so we are
1876 // independent of zoom factor and so on...
1878 const wxGTKDash
*req_dash
;
1880 GdkLineStyle lineStyle
= GDK_LINE_ON_OFF_DASH
;
1881 switch (m_pen
.GetStyle())
1883 case wxPENSTYLE_USER_DASH
:
1884 req_nb_dash
= m_pen
.GetDashCount();
1885 req_dash
= (wxGTKDash
*)m_pen
.GetDash();
1887 case wxPENSTYLE_DOT
:
1891 case wxPENSTYLE_LONG_DASH
:
1893 req_dash
= wxCoord_dashed
;
1895 case wxPENSTYLE_SHORT_DASH
:
1897 req_dash
= short_dashed
;
1899 case wxPENSTYLE_DOT_DASH
:
1901 req_dash
= dotted_dashed
;
1904 case wxPENSTYLE_TRANSPARENT
:
1905 case wxPENSTYLE_STIPPLE_MASK_OPAQUE
:
1906 case wxPENSTYLE_STIPPLE
:
1907 case wxPENSTYLE_SOLID
:
1909 lineStyle
= GDK_LINE_SOLID
;
1915 if (req_dash
&& req_nb_dash
)
1917 wxGTKDash
*real_req_dash
= new wxGTKDash
[req_nb_dash
];
1920 for (int i
= 0; i
< req_nb_dash
; i
++)
1921 real_req_dash
[i
] = req_dash
[i
] * width
;
1922 gdk_gc_set_dashes( m_penGC
, 0, real_req_dash
, req_nb_dash
);
1923 delete[] real_req_dash
;
1927 // No Memory. We use non-scaled dash pattern...
1928 gdk_gc_set_dashes( m_penGC
, 0, (wxGTKDash
*)req_dash
, req_nb_dash
);
1932 GdkCapStyle capStyle
= GDK_CAP_ROUND
;
1933 switch (m_pen
.GetCap())
1935 case wxCAP_PROJECTING
: { capStyle
= GDK_CAP_PROJECTING
; break; }
1936 case wxCAP_BUTT
: { capStyle
= GDK_CAP_BUTT
; break; }
1942 capStyle
= GDK_CAP_NOT_LAST
;
1947 GdkJoinStyle joinStyle
= GDK_JOIN_ROUND
;
1948 switch (m_pen
.GetJoin())
1950 case wxJOIN_BEVEL
: { joinStyle
= GDK_JOIN_BEVEL
; break; }
1951 case wxJOIN_MITER
: { joinStyle
= GDK_JOIN_MITER
; break; }
1953 default: { joinStyle
= GDK_JOIN_ROUND
; break; }
1956 gdk_gc_set_line_attributes( m_penGC
, width
, lineStyle
, capStyle
, joinStyle
);
1958 m_pen
.GetColour().CalcPixel( m_cmap
);
1959 gdk_gc_set_foreground( m_penGC
, m_pen
.GetColour().GetColor() );
1962 void wxWindowDCImpl
::SetBrush( const wxBrush
&brush
)
1964 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1966 if (m_brush
== brush
) return;
1970 if (!m_brush
.IsOk()) return;
1972 if (!m_gdkwindow
) return;
1974 m_brush
.GetColour().CalcPixel( m_cmap
);
1975 gdk_gc_set_foreground( m_brushGC
, m_brush
.GetColour().GetColor() );
1977 gdk_gc_set_fill( m_brushGC
, GDK_SOLID
);
1979 if ((m_brush
.GetStyle() == wxBRUSHSTYLE_STIPPLE
) && (m_brush
.GetStipple()->IsOk()))
1981 if (m_brush
.GetStipple()->GetDepth() != 1)
1983 gdk_gc_set_fill( m_brushGC
, GDK_TILED
);
1984 gdk_gc_set_tile( m_brushGC
, m_brush
.GetStipple()->GetPixmap() );
1988 gdk_gc_set_fill( m_brushGC
, GDK_STIPPLED
);
1989 gdk_gc_set_stipple( m_brushGC
, m_brush
.GetStipple()->GetPixmap() );
1993 if ((m_brush
.GetStyle() == wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE
) && (m_brush
.GetStipple()->GetMask()))
1995 gdk_gc_set_fill( m_textGC
, GDK_OPAQUE_STIPPLED
);
1996 gdk_gc_set_stipple( m_textGC
, m_brush
.GetStipple()->GetMask()->GetBitmap() );
1999 if (m_brush
.IsHatch())
2001 gdk_gc_set_fill( m_brushGC
, GDK_STIPPLED
);
2002 gdk_gc_set_stipple(m_brushGC
, GetHatch(m_brush
.GetStyle()));
2006 void wxWindowDCImpl
::SetBackground( const wxBrush
&brush
)
2008 /* CMB 21/7/98: Added SetBackground. Sets background brush
2009 * for Clear() and bg colour for shapes filled with cross-hatch brush */
2011 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2013 if (m_backgroundBrush
== brush
) return;
2015 m_backgroundBrush
= brush
;
2017 if (!m_backgroundBrush
.IsOk()) return;
2019 if (!m_gdkwindow
) return;
2021 wxColor color
= m_backgroundBrush
.GetColour();
2022 color
.CalcPixel(m_cmap
);
2023 const GdkColor
* gdkColor
= color
.GetColor();
2024 gdk_gc_set_background(m_brushGC
, gdkColor
);
2025 gdk_gc_set_background(m_penGC
, gdkColor
);
2026 gdk_gc_set_background(m_bgGC
, gdkColor
);
2027 gdk_gc_set_foreground(m_bgGC
, gdkColor
);
2030 gdk_gc_set_fill( m_bgGC
, GDK_SOLID
);
2032 if (m_backgroundBrush
.GetStyle() == wxBRUSHSTYLE_STIPPLE
)
2034 const wxBitmap
* stipple
= m_backgroundBrush
.GetStipple();
2035 if (stipple
->IsOk())
2037 if (stipple
->GetDepth() != 1)
2039 gdk_gc_set_fill(m_bgGC
, GDK_TILED
);
2040 gdk_gc_set_tile(m_bgGC
, stipple
->GetPixmap());
2044 gdk_gc_set_fill(m_bgGC
, GDK_STIPPLED
);
2045 gdk_gc_set_stipple(m_bgGC
, stipple
->GetPixmap());
2049 else if (m_backgroundBrush
.IsHatch())
2051 gdk_gc_set_fill( m_bgGC
, GDK_STIPPLED
);
2052 gdk_gc_set_stipple(m_bgGC
, GetHatch(m_backgroundBrush
.GetStyle()));
2056 void wxWindowDCImpl
::SetLogicalFunction( wxRasterOperationMode function
)
2058 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2060 if (m_logicalFunction
== function
)
2063 // VZ: shouldn't this be a CHECK?
2070 case wxXOR
: mode
= GDK_XOR
; break;
2071 case wxINVERT
: mode
= GDK_INVERT
; break;
2072 case wxOR_REVERSE
: mode
= GDK_OR_REVERSE
; break;
2073 case wxAND_REVERSE
: mode
= GDK_AND_REVERSE
; break;
2074 case wxCLEAR
: mode
= GDK_CLEAR
; break;
2075 case wxSET
: mode
= GDK_SET
; break;
2076 case wxOR_INVERT
: mode
= GDK_OR_INVERT
; break;
2077 case wxAND
: mode
= GDK_AND
; break;
2078 case wxOR
: mode
= GDK_OR
; break;
2079 case wxEQUIV
: mode
= GDK_EQUIV
; break;
2080 case wxNAND
: mode
= GDK_NAND
; break;
2081 case wxAND_INVERT
: mode
= GDK_AND_INVERT
; break;
2082 case wxCOPY
: mode
= GDK_COPY
; break;
2083 case wxNO_OP
: mode
= GDK_NOOP
; break;
2084 case wxSRC_INVERT
: mode
= GDK_COPY_INVERT
; break;
2085 case wxNOR
: mode
= GDK_NOR
; break;
2087 wxFAIL_MSG("unknown mode");
2091 m_logicalFunction
= function
;
2093 gdk_gc_set_function( m_penGC
, mode
);
2094 gdk_gc_set_function( m_brushGC
, mode
);
2096 // to stay compatible with wxMSW, we don't apply ROPs to the text
2097 // operations (i.e. DrawText/DrawRotatedText).
2098 // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
2099 gdk_gc_set_function( m_textGC
, mode
);
2102 void wxWindowDCImpl
::SetTextForeground( const wxColour
&col
)
2104 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2106 // don't set m_textForegroundColour to an invalid colour as we'd crash
2107 // later then (we use m_textForegroundColour.GetColor() without checking
2109 if ( !col
.IsOk() || (m_textForegroundColour
== col
) )
2112 m_textForegroundColour
= col
;
2116 m_textForegroundColour
.CalcPixel( m_cmap
);
2117 gdk_gc_set_foreground( m_textGC
, m_textForegroundColour
.GetColor() );
2121 void wxWindowDCImpl
::SetTextBackground( const wxColour
&col
)
2123 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2126 if ( !col
.IsOk() || (m_textBackgroundColour
== col
) )
2129 m_textBackgroundColour
= col
;
2133 m_textBackgroundColour
.CalcPixel( m_cmap
);
2134 gdk_gc_set_background( m_textGC
, m_textBackgroundColour
.GetColor() );
2138 void wxWindowDCImpl
::SetBackgroundMode( int mode
)
2140 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2142 m_backgroundMode
= mode
;
2145 void wxWindowDCImpl
::SetPalette( const wxPalette
& WXUNUSED(palette
) )
2147 wxFAIL_MSG( wxT("wxWindowDCImpl::SetPalette not implemented") );
2150 void wxWindowDCImpl
::DoSetClippingRegion( wxCoord x
, wxCoord y
, wxCoord width
, wxCoord height
)
2152 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2154 if (!m_gdkwindow
) return;
2157 rect
.x
= XLOG2DEV(x
);
2158 rect
.y
= YLOG2DEV(y
);
2159 rect
.width
= XLOG2DEVREL(width
);
2160 rect
.height
= YLOG2DEVREL(height
);
2162 if (m_window
&& m_window
->m_wxwindow
&&
2163 (m_window
->GetLayoutDirection() == wxLayout_RightToLeft
))
2165 rect
.x
-= rect
.width
;
2168 DoSetDeviceClippingRegion(wxRegion(rect
));
2171 void wxWindowDCImpl
::DoSetDeviceClippingRegion( const wxRegion
®ion
)
2173 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2177 DestroyClippingRegion();
2181 if (!m_gdkwindow
) return;
2183 if (!m_currentClippingRegion
.IsNull())
2184 m_currentClippingRegion
.Intersect( region
);
2186 m_currentClippingRegion
.Union( region
);
2188 #if USE_PAINT_REGION
2189 if (!m_paintClippingRegion
.IsNull())
2190 m_currentClippingRegion
.Intersect( m_paintClippingRegion
);
2193 wxCoord xx
, yy
, ww
, hh
;
2194 m_currentClippingRegion
.GetBox( xx
, yy
, ww
, hh
);
2195 wxGTKDCImpl
::DoSetClippingRegion( xx
, yy
, ww
, hh
);
2197 GdkRegion
* gdkRegion
= m_currentClippingRegion
.GetRegion();
2198 gdk_gc_set_clip_region(m_penGC
, gdkRegion
);
2199 gdk_gc_set_clip_region(m_brushGC
, gdkRegion
);
2200 gdk_gc_set_clip_region(m_textGC
, gdkRegion
);
2201 gdk_gc_set_clip_region(m_bgGC
, gdkRegion
);
2204 void wxWindowDCImpl
::DestroyClippingRegion()
2206 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2208 wxDCImpl
::DestroyClippingRegion();
2210 m_currentClippingRegion
.Clear();
2212 #if USE_PAINT_REGION
2213 if (!m_paintClippingRegion
.IsEmpty())
2214 m_currentClippingRegion
.Union( m_paintClippingRegion
);
2217 if (!m_gdkwindow
) return;
2219 GdkRegion
* gdkRegion
= NULL
;
2220 if (!m_currentClippingRegion
.IsEmpty())
2221 gdkRegion
= m_currentClippingRegion
.GetRegion();
2223 gdk_gc_set_clip_region(m_penGC
, gdkRegion
);
2224 gdk_gc_set_clip_region(m_brushGC
, gdkRegion
);
2225 gdk_gc_set_clip_region(m_textGC
, gdkRegion
);
2226 gdk_gc_set_clip_region(m_bgGC
, gdkRegion
);
2229 void wxWindowDCImpl
::Destroy()
2231 if (m_penGC
) wxFreePoolGC( m_penGC
);
2233 if (m_brushGC
) wxFreePoolGC( m_brushGC
);
2235 if (m_textGC
) wxFreePoolGC( m_textGC
);
2237 if (m_bgGC
) wxFreePoolGC( m_bgGC
);
2241 void wxWindowDCImpl
::SetDeviceOrigin( wxCoord x
, wxCoord y
)
2243 m_deviceOriginX
= x
;
2244 m_deviceOriginY
= y
;
2246 ComputeScaleAndOrigin();
2249 void wxWindowDCImpl
::SetAxisOrientation( bool xLeftRight
, bool yBottomUp
)
2251 m_signX
= (xLeftRight ?
1 : -1);
2252 m_signY
= (yBottomUp ?
-1 : 1);
2254 if (m_window
&& m_window
->m_wxwindow
&&
2255 (m_window
->GetLayoutDirection() == wxLayout_RightToLeft
))
2258 ComputeScaleAndOrigin();
2261 void wxWindowDCImpl
::ComputeScaleAndOrigin()
2263 const wxRealPoint
origScale(m_scaleX
, m_scaleY
);
2265 wxDCImpl
::ComputeScaleAndOrigin();
2267 // if scale has changed call SetPen to recalulate the line width
2268 if ( wxRealPoint(m_scaleX
, m_scaleY
) != origScale
&& m_pen
.IsOk() )
2270 // this is a bit artificial, but we need to force wxDC to think the pen
2278 // Resolution in pixels per logical inch
2279 wxSize wxWindowDCImpl
::GetPPI() const
2281 return wxSize( (int) (m_mm_to_pix_x
* 25.4 + 0.5), (int) (m_mm_to_pix_y
* 25.4 + 0.5));
2284 int wxWindowDCImpl
::GetDepth() const
2286 return gdk_drawable_get_depth(m_gdkwindow
);
2290 //-----------------------------------------------------------------------------
2292 //-----------------------------------------------------------------------------
2294 IMPLEMENT_ABSTRACT_CLASS(wxClientDCImpl
, wxWindowDCImpl
)
2296 wxClientDCImpl
::wxClientDCImpl( wxDC
*owner
)
2297 : wxWindowDCImpl( owner
)
2301 wxClientDCImpl
::wxClientDCImpl( wxDC
*owner
, wxWindow
*win
)
2302 : wxWindowDCImpl( owner
, win
)
2304 wxCHECK_RET( win
, wxT("NULL window in wxClientDCImpl::wxClientDC") );
2306 #ifdef __WXUNIVERSAL__
2307 wxPoint ptOrigin
= win
->GetClientAreaOrigin();
2308 SetDeviceOrigin(ptOrigin
.x
, ptOrigin
.y
);
2309 wxSize size
= win
->GetClientSize();
2310 DoSetClippingRegion(0, 0, size
.x
, size
.y
);
2315 void wxClientDCImpl
::DoGetSize(int *width
, int *height
) const
2317 wxCHECK_RET( m_window
, wxT("GetSize() doesn't work without window") );
2319 m_window
->GetClientSize( width
, height
);
2322 //-----------------------------------------------------------------------------
2324 //-----------------------------------------------------------------------------
2326 IMPLEMENT_ABSTRACT_CLASS(wxPaintDCImpl
, wxClientDCImpl
)
2328 // Limit the paint region to the window size. Sometimes
2329 // the paint region is too big, and this risks X11 errors
2330 static void wxLimitRegionToSize(wxRegion
& region
, const wxSize
& sz
)
2332 wxRect originalRect
= region
.GetBox();
2333 wxRect
rect(originalRect
);
2334 if (rect
.width
+ rect
.x
> sz
.x
)
2335 rect
.width
= sz
.x
- rect
.x
;
2336 if (rect
.height
+ rect
.y
> sz
.y
)
2337 rect
.height
= sz
.y
- rect
.y
;
2338 if (rect
!= originalRect
)
2340 region
= wxRegion(rect
);
2341 wxLogTrace(wxT("painting"), wxT("Limiting region from %d, %d, %d, %d to %d, %d, %d, %d\n"),
2342 originalRect
.x
, originalRect
.y
, originalRect
.width
, originalRect
.height
,
2343 rect
.x
, rect
.y
, rect
.width
, rect
.height
);
2347 wxPaintDCImpl
::wxPaintDCImpl( wxDC
*owner
)
2348 : wxClientDCImpl( owner
)
2352 wxPaintDCImpl
::wxPaintDCImpl( wxDC
*owner
, wxWindow
*win
)
2353 : wxClientDCImpl( owner
, win
)
2355 #if USE_PAINT_REGION
2356 if (!win
->m_clipPaintRegion
)
2359 wxSize sz
= win
->GetSize();
2360 m_paintClippingRegion
= win
->m_nativeUpdateRegion
;
2361 wxLimitRegionToSize(m_paintClippingRegion
, sz
);
2363 GdkRegion
*region
= m_paintClippingRegion
.GetRegion();
2366 m_currentClippingRegion
.Union( m_paintClippingRegion
);
2367 wxLimitRegionToSize(m_currentClippingRegion
, sz
);
2369 if (sz
.x
<= 0 || sz
.y
<= 0)
2372 gdk_gc_set_clip_region( m_penGC
, region
);
2373 gdk_gc_set_clip_region( m_brushGC
, region
);
2374 gdk_gc_set_clip_region( m_textGC
, region
);
2375 gdk_gc_set_clip_region( m_bgGC
, region
);
2380 // ----------------------------------------------------------------------------
2382 // ----------------------------------------------------------------------------
2384 class wxDCModule
: public wxModule
2391 DECLARE_DYNAMIC_CLASS(wxDCModule
)
2394 IMPLEMENT_DYNAMIC_CLASS(wxDCModule
, wxModule
)
2396 bool wxDCModule
::OnInit()
2402 void wxDCModule
::OnExit()
2406 for (int i
= wxBRUSHSTYLE_LAST_HATCH
- wxBRUSHSTYLE_FIRST_HATCH
; i
--; )
2409 g_object_unref(hatches
[i
]);