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