projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Pass correct length to XTextExtents
[wxWidgets.git] / src / x11 / dcclient.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: x11/dcclient.cpp
3 // Purpose: wxClientDC class
4 // Author: Julian Smart, Robert Roebling
5 // Modified by:
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart, Robert Roebling
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "dcclient.h"
14 #endif
15
16 #include "wx/dcclient.h"
17 #include "wx/dcmemory.h"
18 #include "wx/window.h"
19 #include "wx/app.h"
20 #include "wx/image.h"
21
22 #include "wx/x11/private.h"
23
24 #include <math.h>
25
26 //-----------------------------------------------------------------------------
27 // local defines
28 //-----------------------------------------------------------------------------
29
30 #define USE_PAINT_REGION 1
31
32 //-----------------------------------------------------------------------------
33 // local data
34 //-----------------------------------------------------------------------------
35
36 #include "bdiag.xbm"
37 #include "fdiag.xbm"
38 #include "cdiag.xbm"
39 #include "horiz.xbm"
40 #include "verti.xbm"
41 #include "cross.xbm"
42 #define num_hatches 6
43
44 #define IS_15_PIX_HATCH(s) ((s)==wxCROSSDIAG_HATCH || (s)==wxHORIZONTAL_HATCH || (s)==wxVERTICAL_HATCH)
45 #define IS_16_PIX_HATCH(s) ((s)!=wxCROSSDIAG_HATCH && (s)!=wxHORIZONTAL_HATCH && (s)!=wxVERTICAL_HATCH)
46
47 static Pixmap hatches[num_hatches];
48 static Pixmap *hatch_bitmap = (Pixmap *) NULL;
49
50 //-----------------------------------------------------------------------------
51 // constants
52 //-----------------------------------------------------------------------------
53
54 const double RAD2DEG = 180.0 / M_PI;
55
56 // ----------------------------------------------------------------------------
57 // private functions
58 // ----------------------------------------------------------------------------
59
60 static inline double dmax(double a, double b) { return a > b ? a : b; }
61 static inline double dmin(double a, double b) { return a < b ? a : b; }
62
63 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
64
65 //-----------------------------------------------------------------------------
66 // Implement Pool of Graphic contexts. Creating them takes too much time.
67 //-----------------------------------------------------------------------------
68
69 #define GC_POOL_SIZE 200
70
71 enum wxPoolGCType
72 {
73 wxGC_ERROR = 0,
74 wxTEXT_MONO,
75 wxBG_MONO,
76 wxPEN_MONO,
77 wxBRUSH_MONO,
78 wxTEXT_COLOUR,
79 wxBG_COLOUR,
80 wxPEN_COLOUR,
81 wxBRUSH_COLOUR,
82 wxTEXT_SCREEN,
83 wxBG_SCREEN,
84 wxPEN_SCREEN,
85 wxBRUSH_SCREEN
86 };
87
88 struct wxGC
89 {
90 GC m_gc;
91 wxPoolGCType m_type;
92 bool m_used;
93 };
94
95 static wxGC wxGCPool[GC_POOL_SIZE];
96
97 static void wxInitGCPool()
98 {
99 memset( wxGCPool, 0, GC_POOL_SIZE*sizeof(wxGC) );
100 }
101
102 static void wxCleanUpGCPool()
103 {
104 for (int i = 0; i < GC_POOL_SIZE; i++)
105 {
106 if (wxGCPool[i].m_gc)
107 XFreeGC( wxGlobalDisplay(), wxGCPool[i].m_gc );
108 }
109 }
110
111 static GC wxGetPoolGC( Window window, wxPoolGCType type )
112 {
113 for (int i = 0; i < GC_POOL_SIZE; i++)
114 {
115 if (!wxGCPool[i].m_gc)
116 {
117 wxGCPool[i].m_gc = XCreateGC( wxGlobalDisplay(), window, 0, NULL );
118 XSetGraphicsExposures( wxGlobalDisplay(), wxGCPool[i].m_gc, FALSE );
119 wxGCPool[i].m_type = type;
120 wxGCPool[i].m_used = FALSE;
121 }
122 if ((!wxGCPool[i].m_used) && (wxGCPool[i].m_type == type))
123 {
124 wxGCPool[i].m_used = TRUE;
125 return wxGCPool[i].m_gc;
126 }
127 }
128
129 wxFAIL_MSG( wxT("No GC available") );
130
131 return (GC) NULL;
132 }
133
134 static void wxFreePoolGC( GC gc )
135 {
136 for (int i = 0; i < GC_POOL_SIZE; i++)
137 {
138 if (wxGCPool[i].m_gc == gc)
139 {
140 wxGCPool[i].m_used = FALSE;
141 return;
142 }
143 }
144
145 wxFAIL_MSG( wxT("Wrong GC") );
146 }
147
148 // ----------------------------------------------------------------------------
149 // wxWindowDC
150 // ----------------------------------------------------------------------------
151
152 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
153
154 wxWindowDC::wxWindowDC()
155 {
156 m_display = (WXDisplay *) NULL;
157 m_penGC = (WXGC *) NULL;
158 m_brushGC = (WXGC *) NULL;
159 m_textGC = (WXGC *) NULL;
160 m_bgGC = (WXGC *) NULL;
161 m_cmap = (WXColormap *) NULL;
162 m_isMemDC = FALSE;
163 m_isScreenDC = FALSE;
164 m_owner = (wxWindow *)NULL;
165 }
166
167 wxWindowDC::wxWindowDC( wxWindow *window )
168 {
169 wxASSERT_MSG( window, wxT("DC needs a window") );
170
171 m_display = (WXDisplay *) NULL;
172 m_penGC = (WXGC *) NULL;
173 m_brushGC = (WXGC *) NULL;
174 m_textGC = (WXGC *) NULL;
175 m_bgGC = (WXGC *) NULL;
176 m_cmap = (WXColormap *) NULL;
177 m_owner = (wxWindow *)NULL;
178 m_isMemDC = FALSE;
179 m_isScreenDC = FALSE;
180 m_font = window->GetFont();
181
182 m_window = (WXWindow*) window->GetMainWindow();
183
184 // not realized ?
185 if (!m_window)
186 {
187 // don't report problems
188 m_ok = TRUE;
189
190 return;
191 }
192
193 m_display = (WXDisplay *) wxGlobalDisplay();
194
195 int screen = DefaultScreen( (Display*) m_display );
196 m_cmap = (WXColormap) DefaultColormap( (Display*) m_display, screen );
197
198 SetUpDC();
199
200 /* this must be done after SetUpDC, bacause SetUpDC calls the
201 repective SetBrush, SetPen, SetBackground etc functions
202 to set up the DC. SetBackground call m_owner->SetBackground
203 and this might not be desired as the standard dc background
204 is white whereas a window might assume gray to be the
205 standard (as e.g. wxStatusBar) */
206
207 m_owner = window;
208 }
209
210 wxWindowDC::~wxWindowDC()
211 {
212 Destroy();
213 }
214
215 void wxWindowDC::SetUpDC()
216 {
217 m_ok = TRUE;
218
219 wxASSERT_MSG( !m_penGC, wxT("GCs already created") );
220
221 if (m_isScreenDC)
222 {
223 m_penGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxPEN_SCREEN );
224 m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBRUSH_SCREEN );
225 m_textGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxTEXT_SCREEN );
226 m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBG_SCREEN );
227 }
228 #if 0
229 else
230 if (m_isMemDC && (((wxMemoryDC*)this)->m_selected.GetDepth() == 1))
231 {
232 m_penGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxPEN_MONO );
233 m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBRUSH_MONO );
234 m_textGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxTEXT_MONO );
235 m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBG_MONO );
236 }
237 #endif
238 else
239 {
240 m_penGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxPEN_COLOUR );
241 m_brushGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBRUSH_COLOUR );
242 m_textGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxTEXT_COLOUR );
243 m_bgGC = (WXGC*) wxGetPoolGC( (Window) m_window, wxBG_COLOUR );
244 }
245
246 /* background colour */
247 m_backgroundBrush = *wxWHITE_BRUSH;
248 m_backgroundBrush.GetColour().CalcPixel( m_cmap );
249 unsigned long bg_col = m_backgroundBrush.GetColour().GetPixel();
250
251 /* m_textGC */
252 m_textForegroundColour.CalcPixel( m_cmap );
253 XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
254
255 m_textBackgroundColour.CalcPixel( m_cmap );
256 XSetBackground( (Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel() );
257
258 XSetFillStyle( (Display*) m_display, (GC) m_textGC, FillSolid );
259
260 /* m_penGC */
261 m_pen.GetColour().CalcPixel( m_cmap );
262 XSetForeground( (Display*) m_display, (GC) m_penGC, m_pen.GetColour().GetPixel() );
263 XSetBackground( (Display*) m_display, (GC) m_penGC, bg_col );
264
265 XSetLineAttributes( (Display*) m_display, (GC) m_penGC, 0, LineSolid, CapNotLast, JoinRound );
266
267 /* m_brushGC */
268 m_brush.GetColour().CalcPixel( m_cmap );
269 XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
270 XSetBackground( (Display*) m_display, (GC) m_brushGC, bg_col );
271
272 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
273
274 /* m_bgGC */
275 XSetForeground( (Display*) m_display, (GC) m_bgGC, bg_col );
276 XSetBackground( (Display*) m_display, (GC) m_bgGC, bg_col );
277
278 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
279
280 /* ROPs */
281 XSetFunction( (Display*) m_display, (GC) m_textGC, GXcopy );
282 XSetFunction( (Display*) m_display, (GC) m_brushGC, GXcopy );
283 XSetFunction( (Display*) m_display, (GC)m_penGC, GXcopy );
284
285 /* clipping */
286 XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
287 XSetClipMask( (Display*) m_display, (GC) m_brushGC, None );
288 XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
289 XSetClipMask( (Display*) m_display, (GC) m_bgGC, None );
290
291 if (!hatch_bitmap)
292 {
293 int xscreen = DefaultScreen( (Display*) m_display );
294 Window xroot = RootWindow( (Display*) m_display, xscreen );
295
296 hatch_bitmap = hatches;
297 hatch_bitmap[0] = XCreateBitmapFromData( (Display*) m_display, xroot, bdiag_bits, bdiag_width, bdiag_height );
298 hatch_bitmap[1] = XCreateBitmapFromData( (Display*) m_display, xroot, cdiag_bits, cdiag_width, cdiag_height );
299 hatch_bitmap[2] = XCreateBitmapFromData( (Display*) m_display, xroot, fdiag_bits, fdiag_width, fdiag_height );
300 hatch_bitmap[3] = XCreateBitmapFromData( (Display*) m_display, xroot, cross_bits, cross_width, cross_height );
301 hatch_bitmap[4] = XCreateBitmapFromData( (Display*) m_display, xroot, horiz_bits, horiz_width, horiz_height );
302 hatch_bitmap[5] = XCreateBitmapFromData( (Display*) m_display, xroot, verti_bits, verti_width, verti_height );
303 }
304 }
305
306 void wxWindowDC::DoGetSize( int* width, int* height ) const
307 {
308 wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
309
310 m_owner->GetSize(width, height);
311 }
312
313 void wxWindowDC::DoFloodFill( wxCoord WXUNUSED(x1), wxCoord WXUNUSED(y1),
314 const wxColour& WXUNUSED(col), int WXUNUSED(style) )
315 {
316 wxFAIL_MSG("not implemented");
317 }
318
319 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
320 {
321 // Generic (and therefore rather inefficient) method.
322 // Could be improved.
323 wxMemoryDC memdc;
324 wxBitmap bitmap(1, 1);
325 memdc.SelectObject(bitmap);
326 memdc.Blit(0, 0, 1, 1, (wxDC*) this, x1, y1);
327 memdc.SelectObject(wxNullBitmap);
328 wxImage image(bitmap);
329 col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));
330 return TRUE;
331 }
332
333 void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
334 {
335 wxCHECK_RET( Ok(), wxT("invalid window dc") );
336
337 if (m_pen.GetStyle() != wxTRANSPARENT)
338 {
339 if (m_window)
340 XDrawLine( (Display*) m_display, (Window) m_window,
341 (GC) m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
342
343 CalcBoundingBox(x1, y1);
344 CalcBoundingBox(x2, y2);
345
346 wxLogDebug("Drawing line at %d, %d -> %d, %d", XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
347 }
348 }
349
350 void wxWindowDC::DoCrossHair( wxCoord x, wxCoord y )
351 {
352 wxCHECK_RET( Ok(), wxT("invalid window dc") );
353
354 if (m_pen.GetStyle() != wxTRANSPARENT)
355 {
356 int w = 0;
357 int h = 0;
358 GetSize( &w, &h );
359 wxCoord xx = XLOG2DEV(x);
360 wxCoord yy = YLOG2DEV(y);
361 if (m_window)
362 {
363 XDrawLine( (Display*) m_display, (Window) m_window,
364 (GC) m_penGC, 0, yy, XLOG2DEVREL(w), yy );
365 XDrawLine( (Display*) m_display, (Window) m_window,
366 (GC) m_penGC, xx, 0, xx, YLOG2DEVREL(h) );
367 }
368 }
369 }
370
371 void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc )
372 {
373 wxCHECK_RET( Ok(), wxT("invalid window dc") );
374
375 wxCoord xx1 = XLOG2DEV(x1);
376 wxCoord yy1 = YLOG2DEV(y1);
377 wxCoord xx2 = XLOG2DEV(x2);
378 wxCoord yy2 = YLOG2DEV(y2);
379 wxCoord xxc = XLOG2DEV(xc);
380 wxCoord yyc = YLOG2DEV(yc);
381 double dx = xx1 - xxc;
382 double dy = yy1 - yyc;
383 double radius = sqrt((double)(dx*dx+dy*dy));
384 wxCoord r = (wxCoord)radius;
385 double radius1, radius2;
386
387 if (xx1 == xx2 && yy1 == yy2)
388 {
389 radius1 = 0.0;
390 radius2 = 360.0;
391 }
392 else
393 if (radius == 0.0)
394 {
395 radius1 = radius2 = 0.0;
396 }
397 else
398 {
399 radius1 = (xx1 - xxc == 0) ?
400 (yy1 - yyc < 0) ? 90.0 : -90.0 :
401 -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
402 radius2 = (xx2 - xxc == 0) ?
403 (yy2 - yyc < 0) ? 90.0 : -90.0 :
404 -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
405 }
406 wxCoord alpha1 = wxCoord(radius1 * 64.0);
407 wxCoord alpha2 = wxCoord((radius2 - radius1) * 64.0);
408 while (alpha2 <= 0) alpha2 += 360*64;
409 while (alpha1 > 360*64) alpha1 -= 360*64;
410
411 if (m_window)
412 {
413 if (m_brush.GetStyle() != wxTRANSPARENT)
414 {
415 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
416 {
417 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
418 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
419 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
420
421 XFillArc( (Display*) m_display, (Window) m_window,
422 (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
423
424 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
425 } else
426 if (IS_15_PIX_HATCH(m_brush.GetStyle()))
427 {
428 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
429 m_deviceOriginX % 15, m_deviceOriginY % 15 );
430
431 XFillArc( (Display*) m_display, (Window) m_window,
432 (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
433
434 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
435 } else
436 if (IS_16_PIX_HATCH(m_brush.GetStyle()))
437 {
438 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
439 m_deviceOriginX % 16, m_deviceOriginY % 16 );
440
441 XFillArc( (Display*) m_display, (Window) m_window,
442 (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
443
444 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
445 } else
446 if (m_brush.GetStyle() == wxSTIPPLE)
447 {
448 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
449 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
450 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
451
452 XFillArc( (Display*) m_display, (Window) m_window,
453 (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
454
455 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
456 }
457 else
458 {
459 XFillArc( (Display*) m_display, (Window) m_window,
460 (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
461 }
462 }
463
464 if (m_pen.GetStyle() != wxTRANSPARENT)
465 {
466 XDrawArc( (Display*) m_display, (Window) m_window,
467 (GC) m_penGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
468
469 XDrawLine( (Display*) m_display, (Window) m_window,
470 (GC) m_penGC, xx1, yy1, xxc, yyc );
471
472 XDrawLine( (Display*) m_display, (Window) m_window,
473 (GC) m_penGC, xxc, yyc, xx2, yy2 );
474 }
475 }
476
477 CalcBoundingBox (x1, y1);
478 CalcBoundingBox (x2, y2);
479 }
480
481 void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double sa, double ea )
482 {
483 wxCHECK_RET( Ok(), wxT("invalid window dc") );
484
485 wxCoord xx = XLOG2DEV(x);
486 wxCoord yy = YLOG2DEV(y);
487 wxCoord ww = m_signX * XLOG2DEVREL(width);
488 wxCoord hh = m_signY * YLOG2DEVREL(height);
489
490 // CMB: handle -ve width and/or height
491 if (ww < 0) { ww = -ww; xx = xx - ww; }
492 if (hh < 0) { hh = -hh; yy = yy - hh; }
493
494 if (m_window)
495 {
496 wxCoord start = wxCoord(sa * 64.0);
497 wxCoord end = wxCoord((ea-sa) * 64.0);
498
499 if (m_brush.GetStyle() != wxTRANSPARENT)
500 {
501 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
502 {
503 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
504 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
505 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
506
507 XFillArc( (Display*) m_display, (Window) m_window,
508 (GC) m_textGC, xx, yy, ww, hh, start, end );
509
510 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
511 } else
512 if (IS_15_PIX_HATCH(m_brush.GetStyle()))
513 {
514 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
515 m_deviceOriginX % 15, m_deviceOriginY % 15 );
516
517 XFillArc( (Display*) m_display, (Window) m_window,
518 (GC) m_brushGC, xx, yy, ww, hh, start, end );
519
520 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
521 } else
522 if (IS_16_PIX_HATCH(m_brush.GetStyle()))
523 {
524 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
525 m_deviceOriginX % 16, m_deviceOriginY % 16 );
526
527 XFillArc( (Display*) m_display, (Window) m_window,
528 (GC) m_brushGC, xx, yy, ww, hh, start, end );
529
530 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
531 } else
532 if (m_brush.GetStyle() == wxSTIPPLE)
533 {
534 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
535 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
536 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
537
538 XFillArc( (Display*) m_display, (Window) m_window,
539 (GC) m_brushGC, xx, yy, ww, hh, start, end );
540
541 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
542 }
543 else
544 {
545 XFillArc( (Display*) m_display, (Window) m_window,
546 (GC) m_brushGC, xx, yy, ww, hh, start, end );
547 }
548 }
549
550 if (m_pen.GetStyle() != wxTRANSPARENT)
551 {
552 XDrawArc( (Display*) m_display, (Window) m_window,
553 (GC) m_penGC, xx, yy, ww, hh, start, end );
554 }
555 }
556
557 CalcBoundingBox (x, y);
558 CalcBoundingBox (x + width, y + height);
559 }
560
561 void wxWindowDC::DoDrawPoint( wxCoord x, wxCoord y )
562 {
563 wxCHECK_RET( Ok(), wxT("invalid window dc") );
564
565 if ((m_pen.GetStyle() != wxTRANSPARENT) && m_window)
566 XDrawPoint( (Display*) m_display, (Window) m_window,
567 (GC) m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
568
569 CalcBoundingBox (x, y);
570 }
571
572 void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
573 {
574 wxCHECK_RET( Ok(), wxT("invalid window dc") );
575
576 if (m_pen.GetStyle() == wxTRANSPARENT) return;
577 if (n <= 0) return;
578
579 XPoint *xpoints = new XPoint[n];
580 for (int i = 0; i < n; i++)
581 {
582 xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
583 xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
584
585 CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
586 }
587 XDrawLines( (Display*) m_display, (Window) m_window, (GC) m_penGC, xpoints, n, 0 );
588
589 delete[] xpoints;
590 }
591
592 void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
593 wxCoord xoffset, wxCoord yoffset, int fillStyle )
594 {
595 wxCHECK_RET( Ok(), wxT("invalid window dc") );
596
597 if (n <= 0) return;
598
599 XPoint *xpoints = new XPoint[n + 1];
600 int i;
601 for (i = 0; i < n; i++)
602 {
603 xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
604 xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
605
606 CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
607 }
608
609 if (m_window)
610 {
611 if (m_brush.GetStyle() != wxTRANSPARENT)
612 {
613
614 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
615 {
616 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
617 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
618 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
619
620 XFillPolygon( (Display*) m_display, (Window) m_window,
621 (GC) m_textGC, xpoints, n, Complex, 0);
622
623 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
624 } else
625 if (IS_15_PIX_HATCH(m_brush.GetStyle()))
626 {
627 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
628 m_deviceOriginX % 15, m_deviceOriginY % 15 );
629
630 XFillPolygon( (Display*) m_display, (Window) m_window,
631 (GC) m_brushGC, xpoints, n, Complex, 0);
632
633 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
634 } else
635 if (IS_16_PIX_HATCH(m_brush.GetStyle()))
636 {
637 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
638 m_deviceOriginX % 16, m_deviceOriginY % 16 );
639
640 XFillPolygon( (Display*) m_display, (Window) m_window,
641 (GC) m_brushGC, xpoints, n, Complex, 0);
642
643 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
644 } else
645 if (m_brush.GetStyle() == wxSTIPPLE)
646 {
647 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
648 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
649 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
650
651 XFillPolygon( (Display*) m_display, (Window) m_window,
652 (GC) m_brushGC, xpoints, n, Complex, 0);
653
654 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
655 }
656 else
657 {
658 XFillPolygon( (Display*) m_display, (Window) m_window,
659 (GC) m_brushGC, xpoints, n, Complex, 0);
660 }
661 }
662
663 if (m_pen.GetStyle () != wxTRANSPARENT)
664 {
665 // Close figure for XDrawLines
666 xpoints[i].x = xpoints[0].x;
667 xpoints[i].y = xpoints[0].y;
668
669 XDrawLines( (Display*) m_display, (Window) m_window, (GC) m_penGC, xpoints, n + 1, 0);
670 }
671 }
672
673 delete[] xpoints;
674 }
675
676 void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
677 {
678 wxCHECK_RET( Ok(), wxT("invalid window dc") );
679
680 wxCoord xx = XLOG2DEV(x);
681 wxCoord yy = YLOG2DEV(y);
682 wxCoord ww = m_signX * XLOG2DEVREL(width);
683 wxCoord hh = m_signY * YLOG2DEVREL(height);
684
685 // CMB: draw nothing if transformed w or h is 0
686 if (ww == 0 || hh == 0) return;
687
688 // CMB: handle -ve width and/or height
689 if (ww < 0) { ww = -ww; xx = xx - ww; }
690 if (hh < 0) { hh = -hh; yy = yy - hh; }
691
692 if (m_window)
693 {
694 if (m_brush.GetStyle() != wxTRANSPARENT)
695 {
696 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
697 {
698 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
699 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
700 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
701
702 XFillRectangle( (Display*) m_display, (Window) m_window,
703 (GC) m_textGC, xx, yy, ww, hh );
704
705 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
706 } else
707 if (IS_15_PIX_HATCH(m_brush.GetStyle()))
708 {
709 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
710 m_deviceOriginX % 15, m_deviceOriginY % 15 );
711
712 XFillRectangle( (Display*) m_display, (Window) m_window,
713 (GC) m_brushGC, xx, yy, ww, hh );
714
715 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
716 } else
717 if (IS_16_PIX_HATCH(m_brush.GetStyle()))
718 {
719 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
720 m_deviceOriginX % 16, m_deviceOriginY % 16 );
721
722 XFillRectangle( (Display*) m_display, (Window) m_window,
723 (GC) m_brushGC, xx, yy, ww, hh );
724
725 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
726 } else
727 if (m_brush.GetStyle() == wxSTIPPLE)
728 {
729 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
730 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
731 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
732
733 XFillRectangle( (Display*) m_display, (Window) m_window,
734 (GC) m_brushGC, xx, yy, ww, hh );
735
736 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
737 }
738 else
739 {
740 XFillRectangle( (Display*) m_display, (Window) m_window,
741 (GC) m_brushGC, xx, yy, ww, hh );
742 }
743 }
744
745 if (m_pen.GetStyle () != wxTRANSPARENT)
746 {
747 XDrawRectangle( (Display*) m_display, (Window) m_window,
748 (GC) m_penGC, xx, yy, ww, hh );
749 }
750 }
751
752 CalcBoundingBox( x, y );
753 CalcBoundingBox( x + width, y + height );
754 wxLogDebug("Drawing rectangle at %d, %d (%dx%d)", x, y, width, height);
755 }
756
757 void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
758 {
759 // later
760 }
761
762 void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
763 {
764 wxCHECK_RET( Ok(), wxT("invalid window dc") );
765
766 wxCoord xx = XLOG2DEV(x);
767 wxCoord yy = YLOG2DEV(y);
768 wxCoord ww = m_signX * XLOG2DEVREL(width);
769 wxCoord hh = m_signY * YLOG2DEVREL(height);
770
771 // CMB: handle -ve width and/or height
772 if (ww < 0) { ww = -ww; xx = xx - ww; }
773 if (hh < 0) { hh = -hh; yy = yy - hh; }
774
775 if (m_window)
776 {
777 if (m_brush.GetStyle() != wxTRANSPARENT)
778 {
779 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
780 {
781 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
782 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
783 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
784
785 XFillArc( (Display*) m_display, (Window) m_window,
786 (GC) m_textGC, xx, yy, ww, hh, 0, 360*64 );
787
788 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
789 } else
790 if (IS_15_PIX_HATCH(m_brush.GetStyle()))
791 {
792 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
793 m_deviceOriginX % 15, m_deviceOriginY % 15 );
794
795 XFillArc( (Display*) m_display, (Window) m_window,
796 (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
797
798 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
799 } else
800 if (IS_16_PIX_HATCH(m_brush.GetStyle()))
801 {
802 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
803 m_deviceOriginX % 16, m_deviceOriginY % 16 );
804
805 XFillArc( (Display*) m_display, (Window) m_window,
806 (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
807
808 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
809 } else
810 if (m_brush.GetStyle() == wxSTIPPLE)
811 {
812 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
813 m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
814 m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
815
816 XFillArc( (Display*) m_display, (Window) m_window,
817 (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
818
819 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
820 }
821 else
822 {
823 XFillArc( (Display*) m_display, (Window) m_window,
824 (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
825 }
826 }
827
828 if (m_pen.GetStyle () != wxTRANSPARENT)
829 {
830 XDrawArc( (Display*) m_display, (Window) m_window,
831 (GC) m_penGC, xx, yy, ww, hh, 0, 360*64 );
832 }
833 }
834
835 CalcBoundingBox( x, y );
836 CalcBoundingBox( x + width, y + height );
837 }
838
839 void wxWindowDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
840 {
841 }
842
843 void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
844 wxCoord x, wxCoord y,
845 bool useMask )
846 {
847 wxCHECK_RET( Ok(), wxT("invalid window dc") );
848
849 wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
850
851 #if 0
852 bool is_mono = (bitmap.GetBitmap() != NULL);
853
854 /* scale/translate size and position */
855 int xx = XLOG2DEV(x);
856 int yy = YLOG2DEV(y);
857
858 int w = bitmap.GetWidth();
859 int h = bitmap.GetHeight();
860
861 CalcBoundingBox( x, y );
862 CalcBoundingBox( x + w, y + h );
863
864 if (!m_window) return;
865
866 int ww = XLOG2DEVREL(w);
867 int hh = YLOG2DEVREL(h);
868
869 /* compare to current clipping region */
870 if (!m_currentClippingRegion.IsNull())
871 {
872 wxRegion tmp( xx,yy,ww,hh );
873 tmp.Intersect( m_currentClippingRegion );
874 if (tmp.IsEmpty())
875 return;
876 }
877
878 /* scale bitmap if required */
879 wxBitmap use_bitmap;
880 if ((w != ww) || (h != hh))
881 {
882 wxImage image( bitmap );
883 image.Rescale( ww, hh );
884 if (is_mono)
885 use_bitmap = image.ConvertToMonoBitmap(255,255,255);
886 else
887 use_bitmap = image.ConvertToBitmap();
888 }
889 else
890 {
891 use_bitmap = bitmap;
892 }
893
894 /* apply mask if any */
895 GdkBitmap *mask = (GdkBitmap *) NULL;
896 if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
897
898 if (useMask && mask)
899 {
900 GdkBitmap *new_mask = (GdkBitmap*) NULL;
901 if (!m_currentClippingRegion.IsNull())
902 {
903 GdkColor col;
904 new_mask = gdk_pixmap_new( wxGetRootWindow()->window, ww, hh, 1 );
905 GdkGC *gc = gdk_gc_new( new_mask );
906 col.pixel = 0;
907 gdk_gc_set_foreground( gc, &col );
908 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
909 col.pixel = 0;
910 gdk_gc_set_background( gc, &col );
911 col.pixel = 1;
912 gdk_gc_set_foreground( gc, &col );
913 gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
914 gdk_gc_set_clip_origin( gc, -xx, -yy );
915 gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
916 gdk_gc_set_stipple( gc, mask );
917 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
918 gdk_gc_unref( gc );
919 }
920
921 if (is_mono)
922 {
923 if (new_mask)
924 gdk_gc_set_clip_mask( m_textGC, new_mask );
925 else
926 gdk_gc_set_clip_mask( m_textGC, mask );
927 gdk_gc_set_clip_origin( m_textGC, xx, yy );
928 }
929 else
930 {
931 if (new_mask)
932 gdk_gc_set_clip_mask( m_penGC, new_mask );
933 else
934 gdk_gc_set_clip_mask( m_penGC, mask );
935 gdk_gc_set_clip_origin( m_penGC, xx, yy );
936 }
937 if (new_mask)
938 gdk_bitmap_unref( new_mask );
939 }
940
941 /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
942 drawing a mono-bitmap (XBitmap) we use the current text GC */
943 if (is_mono)
944 gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), 0, 0, xx, yy, -1, -1 );
945 else
946 gdk_draw_pixmap( m_window, m_penGC, use_bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
947
948 /* remove mask again if any */
949 if (useMask && mask)
950 {
951 if (is_mono)
952 {
953 gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
954 gdk_gc_set_clip_origin( m_textGC, 0, 0 );
955 if (!m_currentClippingRegion.IsNull())
956 gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
957 }
958 else
959 {
960 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
961 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
962 if (!m_currentClippingRegion.IsNull())
963 gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
964 }
965 }
966 #endif
967 }
968
969 bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
970 wxDC *source, wxCoord xsrc, wxCoord ysrc, int rop, bool useMask,
971 wxCoord xsrcMask, wxCoord ysrcMask )
972 {
973 /* this is the nth try to get this utterly useless function to
974 work. it now completely ignores the scaling or translation
975 of the source dc, but scales correctly on the target dc and
976 knows about possible mask information in a memory dc. */
977
978 wxCHECK_MSG( Ok(), FALSE, wxT("invalid window dc") );
979
980 wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
981
982 if (!m_window) return FALSE;
983
984 // transform the source DC coords to the device ones
985 xsrc = source->XLOG2DEV(xsrc);
986 ysrc = source->YLOG2DEV(ysrc);
987
988 wxClientDC *srcDC = (wxClientDC*)source;
989 wxMemoryDC *memDC = (wxMemoryDC*)source;
990
991 bool use_bitmap_method = FALSE;
992 bool is_mono = FALSE;
993
994 /* TODO: use the mask origin when drawing transparently */
995 if (xsrcMask == -1 && ysrcMask == -1)
996 {
997 xsrcMask = xsrc; ysrcMask = ysrc;
998 }
999
1000 #if 0
1001 if (srcDC->m_isMemDC)
1002 {
1003 if (!memDC->m_selected.Ok()) return FALSE;
1004
1005 /* we use the "XCopyArea" way to copy a memory dc into
1006 y different window if the memory dc BOTH
1007 a) doesn't have any mask or its mask isn't used
1008 b) it is clipped
1009 c) is not 1-bit */
1010
1011 if (useMask && (memDC->m_selected.GetMask()))
1012 {
1013 /* we HAVE TO use the direct way for memory dcs
1014 that have mask since the XCopyArea doesn't know
1015 about masks */
1016 use_bitmap_method = TRUE;
1017 }
1018 else if (memDC->m_selected.GetDepth() == 1)
1019 {
1020 /* we HAVE TO use the direct way for memory dcs
1021 that are bitmaps because XCopyArea doesn't cope
1022 with different bit depths */
1023 is_mono = TRUE;
1024 use_bitmap_method = TRUE;
1025 }
1026 else if ((xsrc == 0) && (ysrc == 0) &&
1027 (width == memDC->m_selected.GetWidth()) &&
1028 (height == memDC->m_selected.GetHeight()))
1029 {
1030 /* we SHOULD use the direct way if all of the bitmap
1031 in the memory dc is copied in which case XCopyArea
1032 wouldn't be able able to boost performace by reducing
1033 the area to be scaled */
1034 use_bitmap_method = TRUE;
1035 }
1036 else
1037 {
1038 use_bitmap_method = FALSE;
1039 }
1040 }
1041
1042 CalcBoundingBox( xdest, ydest );
1043 CalcBoundingBox( xdest + width, ydest + height );
1044
1045 /* scale/translate size and position */
1046 wxCoord xx = XLOG2DEV(xdest);
1047 wxCoord yy = YLOG2DEV(ydest);
1048
1049 wxCoord ww = XLOG2DEVREL(width);
1050 wxCoord hh = YLOG2DEVREL(height);
1051
1052 /* compare to current clipping region */
1053 if (!m_currentClippingRegion.IsNull())
1054 {
1055 wxRegion tmp( xx,yy,ww,hh );
1056 tmp.Intersect( m_currentClippingRegion );
1057 if (tmp.IsEmpty())
1058 return TRUE;
1059 }
1060
1061 int old_logical_func = m_logicalFunction;
1062 SetLogicalFunction( logical_func );
1063
1064 if (use_bitmap_method)
1065 {
1066 /* scale/translate bitmap size */
1067 wxCoord bm_width = memDC->m_selected.GetWidth();
1068 wxCoord bm_height = memDC->m_selected.GetHeight();
1069
1070 wxCoord bm_ww = XLOG2DEVREL( bm_width );
1071 wxCoord bm_hh = YLOG2DEVREL( bm_height );
1072
1073 /* scale bitmap if required */
1074 wxBitmap use_bitmap;
1075
1076 if ((bm_width != bm_ww) || (bm_height != bm_hh))
1077 {
1078 wxImage image( memDC->m_selected );
1079 image = image.Scale( bm_ww, bm_hh );
1080
1081 if (is_mono)
1082 use_bitmap = image.ConvertToMonoBitmap(255,255,255);
1083 else
1084 use_bitmap = image.ConvertToBitmap();
1085 }
1086 else
1087 {
1088 use_bitmap = memDC->m_selected;
1089 }
1090
1091 /* apply mask if any */
1092 GdkBitmap *mask = (GdkBitmap *) NULL;
1093 if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
1094
1095 if (useMask && mask)
1096 {
1097 GdkBitmap *new_mask = (GdkBitmap*) NULL;
1098 if (!m_currentClippingRegion.IsNull())
1099 {
1100 GdkColor col;
1101 new_mask = gdk_pixmap_new( wxGetRootWindow()->window, bm_ww, bm_hh, 1 );
1102 GdkGC *gc = gdk_gc_new( new_mask );
1103 col.pixel = 0;
1104 gdk_gc_set_foreground( gc, &col );
1105 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
1106 col.pixel = 0;
1107 gdk_gc_set_background( gc, &col );
1108 col.pixel = 1;
1109 gdk_gc_set_foreground( gc, &col );
1110 gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
1111 gdk_gc_set_clip_origin( gc, -xx, -yy );
1112 gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
1113 gdk_gc_set_stipple( gc, mask );
1114 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
1115 gdk_gc_unref( gc );
1116 }
1117
1118 if (is_mono)
1119 {
1120 if (new_mask)
1121 gdk_gc_set_clip_mask( m_textGC, new_mask );
1122 else
1123 gdk_gc_set_clip_mask( m_textGC, mask );
1124 gdk_gc_set_clip_origin( m_textGC, xx, yy );
1125 }
1126 else
1127 {
1128 if (new_mask)
1129 gdk_gc_set_clip_mask( m_penGC, new_mask );
1130 else
1131 gdk_gc_set_clip_mask( m_penGC, mask );
1132 gdk_gc_set_clip_origin( m_penGC, xx, yy );
1133 }
1134 if (new_mask)
1135 gdk_bitmap_unref( new_mask );
1136 }
1137
1138 /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
1139 drawing a mono-bitmap (XBitmap) we use the current text GC */
1140
1141 if (is_mono)
1142 gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), xsrc, ysrc, xx, yy, ww, hh );
1143 else
1144 gdk_draw_pixmap( m_window, m_penGC, use_bitmap.GetPixmap(), xsrc, ysrc, xx, yy, ww, hh );
1145
1146 /* remove mask again if any */
1147 if (useMask && mask)
1148 {
1149 if (is_mono)
1150 {
1151 gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
1152 gdk_gc_set_clip_origin( m_textGC, 0, 0 );
1153 if (!m_currentClippingRegion.IsNull())
1154 gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
1155 }
1156 else
1157 {
1158 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
1159 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
1160 if (!m_currentClippingRegion.IsNull())
1161 gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
1162 }
1163 }
1164 }
1165 else /* use_bitmap_method */
1166 {
1167 if ((width != ww) || (height != hh))
1168 {
1169 /* draw source window into a bitmap as we cannot scale
1170 a window in contrast to a bitmap. this would actually
1171 work with memory dcs as well, but we'd lose the mask
1172 information and waste one step in this process since
1173 a memory already has a bitmap. all this is slightly
1174 inefficient as we could take an XImage directly from
1175 an X window, but we'd then also have to care that
1176 the window is not outside the screen (in which case
1177 we'd get a BadMatch or what not).
1178 Is a double XGetImage and combined XGetPixel and
1179 XPutPixel really faster? I'm not sure. look at wxXt
1180 for a different implementation of the same problem. */
1181
1182 wxBitmap bitmap( width, height );
1183
1184 /* copy including child window contents */
1185 gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
1186 gdk_window_copy_area( bitmap.GetPixmap(), m_penGC, 0, 0,
1187 srcDC->GetWindow(),
1188 xsrc, ysrc, width, height );
1189 gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
1190
1191 /* scale image */
1192 wxImage image( bitmap );
1193 image = image.Scale( ww, hh );
1194
1195 /* convert to bitmap */
1196 bitmap = image.ConvertToBitmap();
1197
1198 /* draw scaled bitmap */
1199 gdk_draw_pixmap( m_window, m_penGC, bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
1200
1201 }
1202 else
1203 {
1204 /* No scaling and not a memory dc with a mask either */
1205
1206 /* copy including child window contents */
1207 gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
1208 gdk_window_copy_area( m_window, m_penGC, xx, yy,
1209 srcDC->GetWindow(),
1210 xsrc, ysrc, width, height );
1211 gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
1212 }
1213 }
1214
1215 SetLogicalFunction( old_logical_func );
1216 return TRUE;
1217 #endif
1218
1219 return FALSE;
1220 }
1221
1222 void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
1223 {
1224 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1225
1226 if (!m_window) return;
1227
1228 XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1229
1230 wxCHECK_RET( xfont, wxT("invalid font") );
1231
1232 x = XLOG2DEV(x);
1233 y = YLOG2DEV(y);
1234
1235 XCharStruct overall_return;
1236 int direction = 0;
1237 int slen = text.Length();
1238 int ascent = 0;
1239 int descent = 0;
1240 (void)XTextExtents((XFontStruct*) xfont, (char*) (const char*) text, slen, &direction,
1241 &ascent, &descent, &overall_return);
1242 #if 0
1243 wxCoord width = gdk_string_width( font, text.mbc_str() );
1244 wxCoord height = font->ascent + font->descent;
1245
1246 if ( m_backgroundMode == wxSOLID )
1247 {
1248 gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
1249 gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
1250 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
1251 }
1252 #endif
1253
1254 XSetFont( (Display*) m_display, (GC) m_textGC, xfont->fid );
1255 if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
1256 {
1257 XDrawString( (Display*) m_display, (Window) m_window,
1258 (GC) m_textGC, x, y + ascent, text.c_str(), text.Len() );
1259 wxLogDebug("Drawing text %s at %d, %d", text.c_str(), x, y);
1260 }
1261
1262 #if 0
1263 if (m_font.GetUnderlined())
1264 {
1265 wxCoord ul_y = y + font->ascent;
1266 if (font->descent > 0) ul_y++;
1267 gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
1268 }
1269
1270 width = wxCoord(width / m_scaleX);
1271 height = wxCoord(height / m_scaleY);
1272
1273 CalcBoundingBox (x + width, y + height);
1274 CalcBoundingBox (x, y);
1275 #endif
1276 }
1277
1278 void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
1279 {
1280 // later
1281 }
1282
1283 void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
1284 wxCoord *descent, wxCoord *externalLeading,
1285 wxFont *font ) const
1286 {
1287 wxCHECK_RET( Ok(), "invalid dc" );
1288
1289 wxFont fontToUse = m_font;
1290 if (font) fontToUse = *font;
1291
1292 wxCHECK_RET( fontToUse.Ok(), "invalid font" );
1293
1294 XFontStruct *xfont = (XFontStruct*) fontToUse.GetFontStruct( m_scaleY, m_display );
1295
1296 wxCHECK_RET( xfont, wxT("invalid font") );
1297
1298 int direction, ascent, descent2;
1299 XCharStruct overall;
1300
1301 XTextExtents( xfont, string.c_str(), string.Len(), &direction,
1302 &ascent, &descent2, &overall);
1303
1304 if (width)
1305 *width = (wxCoord)( overall.width / m_scaleX );
1306 if (height)
1307 *height = (wxCoord)((ascent + descent2) / m_scaleY );
1308 if (descent)
1309 *descent = (wxCoord)(descent2 / m_scaleY );
1310 if (externalLeading)
1311 *externalLeading = 0; // ??
1312 }
1313
1314 wxCoord wxWindowDC::GetCharWidth() const
1315 {
1316 wxCHECK_MSG( Ok(), 0, "invalid dc" );
1317
1318 wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
1319
1320 XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1321
1322 wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1323
1324 int direction, ascent, descent;
1325 XCharStruct overall;
1326
1327 XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1328
1329 return (wxCoord)(overall.width / m_scaleX);
1330 }
1331
1332 wxCoord wxWindowDC::GetCharHeight() const
1333 {
1334 wxCHECK_MSG( Ok(), 0, "invalid dc" );
1335
1336 wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
1337
1338 XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1339
1340 wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1341
1342 int direction, ascent, descent;
1343 XCharStruct overall;
1344
1345 XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1346
1347 return (wxCoord)((ascent+descent) / m_scaleY);
1348 }
1349
1350 void wxWindowDC::Clear()
1351 {
1352 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1353
1354 if (!m_window) return;
1355
1356 /* - we either are a memory dc or have a window as the
1357 owner. anything else shouldn't happen.
1358 - we don't use gdk_window_clear() as we don't set
1359 the window's background colour anymore. it is too
1360 much pain to keep the DC's and the window's back-
1361 ground colour in synch. */
1362
1363 if (m_owner)
1364 {
1365 int width,height;
1366 m_owner->GetSize( &width, &height );
1367 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
1368 return;
1369 }
1370
1371 if (m_isMemDC)
1372 {
1373 int width,height;
1374 GetSize( &width, &height );
1375 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
1376 return;
1377 }
1378 }
1379
1380 void wxWindowDC::SetFont( const wxFont &font )
1381 {
1382 wxCHECK_RET( Ok(), "invalid dc" );
1383
1384 m_font = font;
1385 }
1386
1387 void wxWindowDC::SetPen( const wxPen &pen )
1388 {
1389 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1390
1391 if (m_pen == pen) return;
1392
1393 m_pen = pen;
1394
1395 if (!m_pen.Ok()) return;
1396
1397 if (!m_window) return;
1398
1399 int width = m_pen.GetWidth();
1400 if (width <= 0)
1401 {
1402 // CMB: if width is non-zero scale it with the dc
1403 width = 1;
1404 }
1405 else
1406 {
1407 // X doesn't allow different width in x and y and so we take
1408 // the average
1409 double w = 0.5 +
1410 ( fabs((double) XLOG2DEVREL(width)) +
1411 fabs((double) YLOG2DEVREL(width)) ) / 2.0;
1412 width = (int)w;
1413 }
1414
1415 static const wxX11Dash dotted[] = {1, 1};
1416 static const wxX11Dash short_dashed[] = {2, 2};
1417 static const wxX11Dash long_dashed[] = {2, 4};
1418 static const wxX11Dash dotted_dashed[] = {3, 3, 1, 3};
1419
1420 // We express dash pattern in pen width unit, so we are
1421 // independent of zoom factor and so on...
1422 int req_nb_dash;
1423 const wxX11Dash *req_dash;
1424
1425 int lineStyle = LineSolid;
1426 switch (m_pen.GetStyle())
1427 {
1428 case wxUSER_DASH:
1429 {
1430 lineStyle = LineOnOffDash;
1431 req_nb_dash = m_pen.GetDashCount();
1432 req_dash = (wxX11Dash*)m_pen.GetDash();
1433 break;
1434 }
1435 case wxDOT:
1436 {
1437 lineStyle = LineOnOffDash;
1438 req_nb_dash = 2;
1439 req_dash = dotted;
1440 break;
1441 }
1442 case wxLONG_DASH:
1443 {
1444 lineStyle = LineOnOffDash;
1445 req_nb_dash = 2;
1446 req_dash = long_dashed;
1447 break;
1448 }
1449 case wxSHORT_DASH:
1450 {
1451 lineStyle = LineOnOffDash;
1452 req_nb_dash = 2;
1453 req_dash = short_dashed;
1454 break;
1455 }
1456 case wxDOT_DASH:
1457 {
1458 // lineStyle = LineDoubleDash;
1459 lineStyle = LineOnOffDash;
1460 req_nb_dash = 4;
1461 req_dash = dotted_dashed;
1462 break;
1463 }
1464
1465 case wxTRANSPARENT:
1466 case wxSTIPPLE_MASK_OPAQUE:
1467 case wxSTIPPLE:
1468 case wxSOLID:
1469 default:
1470 {
1471 lineStyle = LineSolid;
1472 req_dash = (wxX11Dash*)NULL;
1473 req_nb_dash = 0;
1474 break;
1475 }
1476 }
1477
1478 int capStyle = CapRound;
1479 switch (m_pen.GetCap())
1480 {
1481 case wxCAP_PROJECTING: { capStyle = CapProjecting; break; }
1482 case wxCAP_BUTT: { capStyle = CapButt; break; }
1483 case wxCAP_ROUND:
1484 default:
1485 {
1486 if (width <= 1)
1487 {
1488 width = 0;
1489 capStyle = CapNotLast;
1490 }
1491 else
1492 {
1493 capStyle = CapRound;
1494 }
1495 break;
1496 }
1497 }
1498
1499 int joinStyle = JoinRound;
1500 switch (m_pen.GetJoin())
1501 {
1502 case wxJOIN_BEVEL: { joinStyle = JoinBevel; break; }
1503 case wxJOIN_MITER: { joinStyle = JoinMiter; break; }
1504 case wxJOIN_ROUND:
1505 default: { joinStyle = JoinRound; break; }
1506 }
1507
1508 XSetLineAttributes( (Display*) m_display, (GC) m_penGC, width, lineStyle, capStyle, joinStyle );
1509
1510 m_pen.GetColour().CalcPixel( m_cmap );
1511 XSetForeground( (Display*) m_display, (GC) m_penGC, m_pen.GetColour().GetPixel() );
1512 }
1513
1514 void wxWindowDC::SetBrush( const wxBrush &brush )
1515 {
1516 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1517
1518 if (m_brush == brush) return;
1519
1520 m_brush = brush;
1521
1522 if (!m_brush.Ok()) return;
1523
1524 if (!m_window) return;
1525
1526 m_brush.GetColour().CalcPixel( m_cmap );
1527 XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
1528
1529 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
1530
1531 if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
1532 {
1533 if (m_brush.GetStipple()->GetPixmap())
1534 {
1535 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillTiled );
1536 XSetTile( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetPixmap() );
1537 }
1538 else
1539 {
1540 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1541 // XSetStipple( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetBitmap() );
1542 }
1543 }
1544
1545 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
1546 {
1547 XSetFillStyle( (Display*) m_display, (GC) m_textGC, FillOpaqueStippled );
1548 // XSetStipple( (Display*) m_display, (GC) m_textGC, (Pixmap) m_brush.GetStipple()->GetMask()->GetBitmap() );
1549 }
1550
1551 if (IS_HATCH(m_brush.GetStyle()))
1552 {
1553 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1554 int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
1555 XSetStipple( (Display*) m_display, (GC) m_brushGC, hatches[num] );
1556 }
1557 }
1558
1559 void wxWindowDC::SetBackground( const wxBrush &brush )
1560 {
1561 /* CMB 21/7/98: Added SetBackground. Sets background brush
1562 * for Clear() and bg colour for shapes filled with cross-hatch brush */
1563
1564 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1565
1566 if (m_backgroundBrush == brush) return;
1567
1568 m_backgroundBrush = brush;
1569
1570 if (!m_backgroundBrush.Ok()) return;
1571
1572 if (!m_window) return;
1573
1574 m_backgroundBrush.GetColour().CalcPixel( m_cmap );
1575 XSetBackground( (Display*) m_display, (GC) m_brushGC, m_backgroundBrush.GetColour().GetPixel() );
1576 XSetBackground( (Display*) m_display, (GC) m_penGC, m_backgroundBrush.GetColour().GetPixel() );
1577 XSetBackground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
1578 XSetForeground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
1579
1580 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
1581
1582 if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
1583 {
1584 if (m_backgroundBrush.GetStipple()->GetPixmap())
1585 {
1586 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillTiled );
1587 XSetTile( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetPixmap() );
1588 }
1589 else
1590 {
1591 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
1592 // XSetStipple( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetBitmap() );
1593 }
1594 }
1595
1596 if (IS_HATCH(m_backgroundBrush.GetStyle()))
1597 {
1598 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
1599 int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
1600 XSetStipple( (Display*) m_display, (GC) m_bgGC, hatches[num] );
1601 }
1602 }
1603
1604 void wxWindowDC::SetLogicalFunction( int function )
1605 {
1606 wxCHECK_RET( Ok(), "invalid dc" );
1607
1608 int x_function;
1609
1610 if (m_logicalFunction == function)
1611 return;
1612
1613 // VZ: shouldn't this be a CHECK?
1614 if (!m_window)
1615 return;
1616
1617 switch (function)
1618 {
1619 case wxCLEAR:
1620 x_function = GXclear;
1621 break;
1622 case wxXOR:
1623 x_function = GXxor;
1624 break;
1625 case wxINVERT:
1626 x_function = GXinvert;
1627 break;
1628 case wxOR_REVERSE:
1629 x_function = GXorReverse;
1630 break;
1631 case wxAND_REVERSE:
1632 x_function = GXandReverse;
1633 break;
1634 case wxAND:
1635 x_function = GXand;
1636 break;
1637 case wxOR:
1638 x_function = GXor;
1639 break;
1640 case wxAND_INVERT:
1641 x_function = GXandInverted;
1642 break;
1643 case wxNO_OP:
1644 x_function = GXnoop;
1645 break;
1646 case wxNOR:
1647 x_function = GXnor;
1648 break;
1649 case wxEQUIV:
1650 x_function = GXequiv;
1651 break;
1652 case wxSRC_INVERT:
1653 x_function = GXcopyInverted;
1654 break;
1655 case wxOR_INVERT:
1656 x_function = GXorInverted;
1657 break;
1658 case wxNAND:
1659 x_function = GXnand;
1660 break;
1661 case wxSET:
1662 x_function = GXset;
1663 break;
1664 case wxCOPY:
1665 default:
1666 x_function = GXcopy;
1667 break;
1668 }
1669
1670 XSetFunction( (Display*) m_display, (GC) m_penGC, x_function );
1671 XSetFunction( (Display*) m_display, (GC) m_brushGC, x_function );
1672
1673 // to stay compatible with wxMSW, we don't apply ROPs to the text
1674 // operations (i.e. DrawText/DrawRotatedText).
1675 // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
1676 XSetFunction( (Display*) m_display, (GC) m_textGC, x_function );
1677
1678 m_logicalFunction = function;
1679 }
1680
1681 void wxWindowDC::SetTextForeground( const wxColour &col )
1682 {
1683 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1684
1685 // don't set m_textForegroundColour to an invalid colour as we'd crash
1686 // later then (we use m_textForegroundColour.GetColor() without checking
1687 // in a few places)
1688 if ( !col.Ok() || (m_textForegroundColour == col) )
1689 return;
1690
1691 m_textForegroundColour = col;
1692
1693 if (m_window)
1694 {
1695 m_textForegroundColour.CalcPixel( m_cmap );
1696 XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
1697 }
1698 }
1699
1700 void wxWindowDC::SetTextBackground( const wxColour &col )
1701 {
1702 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1703
1704 // same as above
1705 if ( !col.Ok() || (m_textBackgroundColour == col) )
1706 return;
1707
1708 m_textBackgroundColour = col;
1709
1710 if (m_window)
1711 {
1712 m_textBackgroundColour.CalcPixel( m_cmap );
1713 XSetBackground( (Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel() );
1714 }
1715 }
1716
1717 void wxWindowDC::SetBackgroundMode( int mode )
1718 {
1719 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1720
1721 m_backgroundMode = mode;
1722
1723 if (!m_window) return;
1724
1725 // CMB 21/7/98: fill style of cross-hatch brushes is affected by
1726 // transparent/solid background mode
1727
1728 if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
1729 {
1730 XSetFillStyle( (Display*) m_display, (GC) m_brushGC,
1731 (m_backgroundMode == wxTRANSPARENT) ? FillStippled : FillOpaqueStippled );
1732 }
1733 }
1734
1735 void wxWindowDC::SetPalette( const wxPalette& palette )
1736 {
1737 #if 0
1738 if (m_window)
1739 {
1740 if (palette.Ok())
1741 /* Use GetXColormap */
1742 XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1743 (Colormap) palette.GetXColormap());
1744 else
1745 /* Use wxGetMainColormap */
1746 XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1747 (Colormap) wxTheApp->GetMainColormap(m_display));
1748 }
1749 #endif
1750 }
1751
1752 void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
1753 {
1754 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1755
1756 if (!m_window) return;
1757
1758 wxRect rect;
1759 rect.x = XLOG2DEV(x);
1760 rect.y = YLOG2DEV(y);
1761 rect.width = XLOG2DEVREL(width);
1762 rect.height = YLOG2DEVREL(height);
1763
1764 if (!m_currentClippingRegion.IsNull())
1765 m_currentClippingRegion.Intersect( rect );
1766 else
1767 m_currentClippingRegion.Union( rect );
1768
1769 #if USE_PAINT_REGION
1770 if (!m_paintClippingRegion.IsNull())
1771 m_currentClippingRegion.Intersect( m_paintClippingRegion );
1772 #endif
1773
1774 wxCoord xx, yy, ww, hh;
1775 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1776 wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1777
1778 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1779 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1780 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1781 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1782 }
1783
1784 void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
1785 {
1786 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1787
1788 if (region.Empty())
1789 {
1790 DestroyClippingRegion();
1791 return;
1792 }
1793
1794 if (!m_window) return;
1795
1796 if (!m_currentClippingRegion.IsNull())
1797 m_currentClippingRegion.Intersect( region );
1798 else
1799 m_currentClippingRegion.Union( region );
1800
1801 #if USE_PAINT_REGION
1802 if (!m_paintClippingRegion.IsNull())
1803 m_currentClippingRegion.Intersect( m_paintClippingRegion );
1804 #endif
1805
1806 wxCoord xx, yy, ww, hh;
1807 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1808 wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1809
1810 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1811 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1812 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1813 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1814 }
1815
1816 void wxWindowDC::DestroyClippingRegion()
1817 {
1818 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1819
1820 wxDC::DestroyClippingRegion();
1821
1822 m_currentClippingRegion.Clear();
1823
1824 #if USE_PAINT_REGION
1825 if (!m_paintClippingRegion.IsEmpty())
1826 m_currentClippingRegion.Union( m_paintClippingRegion );
1827 #endif
1828
1829 if (!m_window) return;
1830
1831 if (m_currentClippingRegion.IsEmpty())
1832 {
1833 XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
1834 XSetClipMask( (Display*) m_display, (GC) m_brushGC, None );
1835 XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
1836 XSetClipMask( (Display*) m_display, (GC) m_bgGC, None );
1837 }
1838 else
1839 {
1840 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1841 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1842 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1843 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1844 }
1845 }
1846
1847 void wxWindowDC::Destroy()
1848 {
1849 if (m_penGC) wxFreePoolGC( (GC) m_penGC );
1850 m_penGC = NULL;
1851 if (m_brushGC) wxFreePoolGC( (GC) m_brushGC );
1852 m_brushGC = NULL;
1853 if (m_textGC) wxFreePoolGC( (GC) m_textGC );
1854 m_textGC = NULL;
1855 if (m_bgGC) wxFreePoolGC( (GC) m_bgGC );
1856 m_bgGC = NULL;
1857 }
1858
1859 void wxWindowDC::ComputeScaleAndOrigin()
1860 {
1861 /* CMB: copy scale to see if it changes */
1862 double origScaleX = m_scaleX;
1863 double origScaleY = m_scaleY;
1864
1865 wxDC::ComputeScaleAndOrigin();
1866
1867 /* CMB: if scale has changed call SetPen to recalulate the line width */
1868 if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&
1869 (m_pen.Ok()))
1870 {
1871 /* this is a bit artificial, but we need to force wxDC to think
1872 the pen has changed */
1873 wxPen pen = m_pen;
1874 m_pen = wxNullPen;
1875 SetPen( pen );
1876 }
1877 }
1878
1879 wxSize wxWindowDC::GetPPI() const
1880 {
1881 return wxSize(100, 100);
1882 }
1883
1884 int wxWindowDC::GetDepth() const
1885 {
1886 wxFAIL_MSG(wxT("not implemented"));
1887
1888 return -1;
1889 }
1890
1891 // ----------------------------------------------------------------------------
1892 // wxPaintDC
1893 // ----------------------------------------------------------------------------
1894
1895 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
1896
1897 wxPaintDC::wxPaintDC(wxWindow* win)
1898 : wxClientDC(win)
1899 {
1900 #if USE_PAINT_REGION
1901 if (!win->GetClipPaintRegion())
1902 return;
1903
1904 m_paintClippingRegion = win->GetUpdateRegion();
1905 Region region = (Region) m_paintClippingRegion.GetX11Region();
1906 if (region)
1907 {
1908 m_paintClippingRegion = win->GetUpdateRegion();
1909 Region region2 = (Region) m_paintClippingRegion.GetX11Region();
1910 if (region2)
1911 {
1912 m_currentClippingRegion.Union( m_paintClippingRegion );
1913
1914 XSetRegion( (Display*) m_display, (GC) m_penGC, region2 );
1915 XSetRegion( (Display*) m_display, (GC) m_brushGC, region2 );
1916 XSetRegion( (Display*) m_display, (GC) m_textGC, region2 );
1917 XSetRegion( (Display*) m_display, (GC) m_bgGC, region2 );
1918 }
1919 }
1920 #endif // USE_PAINT_REGION
1921 }
1922
1923 //-----------------------------------------------------------------------------
1924 // wxClientDC
1925 //-----------------------------------------------------------------------------
1926
1927 IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
1928
1929 wxClientDC::wxClientDC( wxWindow *win )
1930 : wxWindowDC( win )
1931 {
1932 wxCHECK_RET( win, _T("NULL window in wxClientDC::wxClientDC") );
1933 }
1934
1935 void wxClientDC::DoGetSize(int *width, int *height) const
1936 {
1937 wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
1938
1939 m_owner->GetClientSize( width, height );
1940 }
1941
1942 // ----------------------------------------------------------------------------
1943 // wxDCModule
1944 // ----------------------------------------------------------------------------
1945
1946 class wxDCModule : public wxModule
1947 {
1948 public:
1949 bool OnInit();
1950 void OnExit();
1951
1952 private:
1953 DECLARE_DYNAMIC_CLASS(wxDCModule)
1954 };
1955
1956 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
1957
1958 bool wxDCModule::OnInit()
1959 {
1960 wxInitGCPool();
1961 return TRUE;
1962 }
1963
1964 void wxDCModule::OnExit()
1965 {
1966 wxCleanUpGCPool();
1967 }
wxWidgets (Impactor)