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