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


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