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