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