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