]> 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
compilation 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 #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, hh );
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 ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
1249 {
1250 XDrawString( (Display*) m_display, (Window) m_window,
1251 (GC) m_textGC, x, y + xfont->ascent, text.c_str(), text.Len() );
1252 }
1253
1254 #if 0
1255 if (m_font.GetUnderlined())
1256 {
1257 wxCoord ul_y = y + font->ascent;
1258 if (font->descent > 0) ul_y++;
1259 gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
1260 }
1261
1262 width = wxCoord(width / m_scaleX);
1263 height = wxCoord(height / m_scaleY);
1264
1265 CalcBoundingBox (x + width, y + height);
1266 CalcBoundingBox (x, y);
1267 #endif
1268 }
1269
1270 void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
1271 {
1272 // later
1273 }
1274
1275 void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
1276 wxCoord *descent, wxCoord *externalLeading,
1277 wxFont *font ) const
1278 {
1279 wxCHECK_RET( Ok(), "invalid dc" );
1280
1281 wxFont fontToUse = m_font;
1282 if (font) fontToUse = *font;
1283
1284 wxCHECK_RET( fontToUse.Ok(), "invalid font" );
1285
1286 XFontStruct *xfont = (XFontStruct*) fontToUse.GetFontStruct( m_scaleY, m_display );
1287
1288 wxCHECK_RET( xfont, wxT("invalid font") );
1289
1290 int direction, ascent, descent2;
1291 XCharStruct overall;
1292
1293 XTextExtents( xfont, string.c_str(), string.Len(), &direction,
1294 &ascent, &descent2, &overall);
1295
1296 if (width)
1297 *width = (wxCoord)( overall.width / m_scaleX );
1298 if (height)
1299 *height = (wxCoord)((ascent + descent2) / m_scaleY );
1300 if (descent)
1301 *descent = (wxCoord)(descent2 / m_scaleY );
1302 if (externalLeading)
1303 *externalLeading = 0; // ??
1304 }
1305
1306 wxCoord wxWindowDC::GetCharWidth() const
1307 {
1308 wxCHECK_MSG( Ok(), 0, "invalid dc" );
1309
1310 wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
1311
1312 XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1313
1314 wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1315
1316 int direction, ascent, descent;
1317 XCharStruct overall;
1318
1319 XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1320
1321 return (wxCoord)(overall.width / m_scaleX);
1322 }
1323
1324 wxCoord wxWindowDC::GetCharHeight() const
1325 {
1326 wxCHECK_MSG( Ok(), 0, "invalid dc" );
1327
1328 wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
1329
1330 XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1331
1332 wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1333
1334 int direction, ascent, descent;
1335 XCharStruct overall;
1336
1337 XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1338
1339 return (wxCoord)((ascent+descent) / m_scaleY);
1340 }
1341
1342 void wxWindowDC::Clear()
1343 {
1344 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1345
1346 if (!m_window) return;
1347
1348 /* - we either are a memory dc or have a window as the
1349 owner. anything else shouldn't happen.
1350 - we don't use gdk_window_clear() as we don't set
1351 the window's background colour anymore. it is too
1352 much pain to keep the DC's and the window's back-
1353 ground colour in synch. */
1354
1355 if (m_owner)
1356 {
1357 int width,height;
1358 m_owner->GetSize( &width, &height );
1359 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
1360 return;
1361 }
1362
1363 if (m_isMemDC)
1364 {
1365 int width,height;
1366 GetSize( &width, &height );
1367 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
1368 return;
1369 }
1370 }
1371
1372 void wxWindowDC::SetFont( const wxFont &font )
1373 {
1374 wxCHECK_RET( Ok(), "invalid dc" );
1375
1376 m_font = font;
1377 }
1378
1379 void wxWindowDC::SetPen( const wxPen &pen )
1380 {
1381 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1382
1383 if (m_pen == pen) return;
1384
1385 m_pen = pen;
1386
1387 if (!m_pen.Ok()) return;
1388
1389 if (!m_window) return;
1390
1391 int width = m_pen.GetWidth();
1392 if (width <= 0)
1393 {
1394 // CMB: if width is non-zero scale it with the dc
1395 width = 1;
1396 }
1397 else
1398 {
1399 // X doesn't allow different width in x and y and so we take
1400 // the average
1401 double w = 0.5 +
1402 ( fabs((double) XLOG2DEVREL(width)) +
1403 fabs((double) YLOG2DEVREL(width)) ) / 2.0;
1404 width = (int)w;
1405 }
1406
1407 static const wxX11Dash dotted[] = {1, 1};
1408 static const wxX11Dash short_dashed[] = {2, 2};
1409 static const wxX11Dash long_dashed[] = {2, 4};
1410 static const wxX11Dash dotted_dashed[] = {3, 3, 1, 3};
1411
1412 // We express dash pattern in pen width unit, so we are
1413 // independent of zoom factor and so on...
1414 int req_nb_dash;
1415 const wxX11Dash *req_dash;
1416
1417 int lineStyle = LineSolid;
1418 switch (m_pen.GetStyle())
1419 {
1420 case wxUSER_DASH:
1421 {
1422 lineStyle = LineOnOffDash;
1423 req_nb_dash = m_pen.GetDashCount();
1424 req_dash = (wxX11Dash*)m_pen.GetDash();
1425 break;
1426 }
1427 case wxDOT:
1428 {
1429 lineStyle = LineOnOffDash;
1430 req_nb_dash = 2;
1431 req_dash = dotted;
1432 break;
1433 }
1434 case wxLONG_DASH:
1435 {
1436 lineStyle = LineOnOffDash;
1437 req_nb_dash = 2;
1438 req_dash = long_dashed;
1439 break;
1440 }
1441 case wxSHORT_DASH:
1442 {
1443 lineStyle = LineOnOffDash;
1444 req_nb_dash = 2;
1445 req_dash = short_dashed;
1446 break;
1447 }
1448 case wxDOT_DASH:
1449 {
1450 // lineStyle = LineDoubleDash;
1451 lineStyle = LineOnOffDash;
1452 req_nb_dash = 4;
1453 req_dash = dotted_dashed;
1454 break;
1455 }
1456
1457 case wxTRANSPARENT:
1458 case wxSTIPPLE_MASK_OPAQUE:
1459 case wxSTIPPLE:
1460 case wxSOLID:
1461 default:
1462 {
1463 lineStyle = LineSolid;
1464 req_dash = (wxX11Dash*)NULL;
1465 req_nb_dash = 0;
1466 break;
1467 }
1468 }
1469
1470 int capStyle = CapRound;
1471 switch (m_pen.GetCap())
1472 {
1473 case wxCAP_PROJECTING: { capStyle = CapProjecting; break; }
1474 case wxCAP_BUTT: { capStyle = CapButt; break; }
1475 case wxCAP_ROUND:
1476 default:
1477 {
1478 if (width <= 1)
1479 {
1480 width = 0;
1481 capStyle = CapNotLast;
1482 }
1483 else
1484 {
1485 capStyle = CapRound;
1486 }
1487 break;
1488 }
1489 }
1490
1491 int joinStyle = JoinRound;
1492 switch (m_pen.GetJoin())
1493 {
1494 case wxJOIN_BEVEL: { joinStyle = JoinBevel; break; }
1495 case wxJOIN_MITER: { joinStyle = JoinMiter; break; }
1496 case wxJOIN_ROUND:
1497 default: { joinStyle = JoinRound; break; }
1498 }
1499
1500 XSetLineAttributes( (Display*) m_display, (GC) m_penGC, width, lineStyle, capStyle, joinStyle );
1501
1502 m_pen.GetColour().CalcPixel( m_cmap );
1503 XSetForeground( (Display*) m_display, (GC) m_penGC, m_pen.GetColour().GetPixel() );
1504 }
1505
1506 void wxWindowDC::SetBrush( const wxBrush &brush )
1507 {
1508 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1509
1510 if (m_brush == brush) return;
1511
1512 m_brush = brush;
1513
1514 if (!m_brush.Ok()) return;
1515
1516 if (!m_window) return;
1517
1518 m_brush.GetColour().CalcPixel( m_cmap );
1519 XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
1520
1521 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
1522
1523 if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
1524 {
1525 if (m_brush.GetStipple()->GetPixmap())
1526 {
1527 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillTiled );
1528 XSetTile( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetPixmap() );
1529 }
1530 else
1531 {
1532 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1533 XSetStipple( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetBitmap() );
1534 }
1535 }
1536
1537 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
1538 {
1539 XSetFillStyle( (Display*) m_display, (GC) m_textGC, FillOpaqueStippled );
1540 XSetStipple( (Display*) m_display, (GC) m_textGC, (Pixmap) m_brush.GetStipple()->GetMask()->GetBitmap() );
1541 }
1542
1543 if (IS_HATCH(m_brush.GetStyle()))
1544 {
1545 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1546 int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
1547 XSetStipple( (Display*) m_display, (GC) m_brushGC, hatches[num] );
1548 }
1549 }
1550
1551 void wxWindowDC::SetBackground( const wxBrush &brush )
1552 {
1553 /* CMB 21/7/98: Added SetBackground. Sets background brush
1554 * for Clear() and bg colour for shapes filled with cross-hatch brush */
1555
1556 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1557
1558 if (m_backgroundBrush == brush) return;
1559
1560 m_backgroundBrush = brush;
1561
1562 if (!m_backgroundBrush.Ok()) return;
1563
1564 if (!m_window) return;
1565
1566 m_backgroundBrush.GetColour().CalcPixel( m_cmap );
1567 XSetBackground( (Display*) m_display, (GC) m_brushGC, m_backgroundBrush.GetColour().GetPixel() );
1568 XSetBackground( (Display*) m_display, (GC) m_penGC, m_backgroundBrush.GetColour().GetPixel() );
1569 XSetBackground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
1570 XSetForeground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
1571
1572 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
1573
1574 if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
1575 {
1576 if (m_backgroundBrush.GetStipple()->GetPixmap())
1577 {
1578 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillTiled );
1579 XSetTile( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetPixmap() );
1580 }
1581 else
1582 {
1583 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
1584 XSetStipple( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetBitmap() );
1585 }
1586 }
1587
1588 if (IS_HATCH(m_backgroundBrush.GetStyle()))
1589 {
1590 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
1591 int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
1592 XSetStipple( (Display*) m_display, (GC) m_bgGC, hatches[num] );
1593 }
1594 }
1595
1596 void wxWindowDC::SetLogicalFunction( int function )
1597 {
1598 wxCHECK_RET( Ok(), "invalid dc" );
1599
1600 int x_function;
1601
1602 if (m_logicalFunction == function)
1603 return;
1604
1605 // VZ: shouldn't this be a CHECK?
1606 if (!m_window)
1607 return;
1608
1609 switch (function)
1610 {
1611 case wxCLEAR:
1612 x_function = GXclear;
1613 break;
1614 case wxXOR:
1615 x_function = GXxor;
1616 break;
1617 case wxINVERT:
1618 x_function = GXinvert;
1619 break;
1620 case wxOR_REVERSE:
1621 x_function = GXorReverse;
1622 break;
1623 case wxAND_REVERSE:
1624 x_function = GXandReverse;
1625 break;
1626 case wxAND:
1627 x_function = GXand;
1628 break;
1629 case wxOR:
1630 x_function = GXor;
1631 break;
1632 case wxAND_INVERT:
1633 x_function = GXandInverted;
1634 break;
1635 case wxNO_OP:
1636 x_function = GXnoop;
1637 break;
1638 case wxNOR:
1639 x_function = GXnor;
1640 break;
1641 case wxEQUIV:
1642 x_function = GXequiv;
1643 break;
1644 case wxSRC_INVERT:
1645 x_function = GXcopyInverted;
1646 break;
1647 case wxOR_INVERT:
1648 x_function = GXorInverted;
1649 break;
1650 case wxNAND:
1651 x_function = GXnand;
1652 break;
1653 case wxSET:
1654 x_function = GXset;
1655 break;
1656 case wxCOPY:
1657 default:
1658 x_function = GXcopy;
1659 break;
1660 }
1661
1662 XSetFunction( (Display*) m_display, (GC) m_penGC, x_function );
1663 XSetFunction( (Display*) m_display, (GC) m_brushGC, x_function );
1664
1665 // to stay compatible with wxMSW, we don't apply ROPs to the text
1666 // operations (i.e. DrawText/DrawRotatedText).
1667 // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
1668 XSetFunction( (Display*) m_display, (GC) m_textGC, x_function );
1669
1670 m_logicalFunction = function;
1671 }
1672
1673 void wxWindowDC::SetTextForeground( const wxColour &col )
1674 {
1675 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1676
1677 // don't set m_textForegroundColour to an invalid colour as we'd crash
1678 // later then (we use m_textForegroundColour.GetColor() without checking
1679 // in a few places)
1680 if ( !col.Ok() || (m_textForegroundColour == col) )
1681 return;
1682
1683 m_textForegroundColour = col;
1684
1685 if (m_window)
1686 {
1687 m_textForegroundColour.CalcPixel( m_cmap );
1688 XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
1689 }
1690 }
1691
1692 void wxWindowDC::SetTextBackground( const wxColour &col )
1693 {
1694 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1695
1696 // same as above
1697 if ( !col.Ok() || (m_textBackgroundColour == col) )
1698 return;
1699
1700 m_textBackgroundColour = col;
1701
1702 if (m_window)
1703 {
1704 m_textBackgroundColour.CalcPixel( m_cmap );
1705 XSetBackground( (Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel() );
1706 }
1707 }
1708
1709 void wxWindowDC::SetBackgroundMode( int mode )
1710 {
1711 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1712
1713 m_backgroundMode = mode;
1714
1715 if (!m_window) return;
1716
1717 // CMB 21/7/98: fill style of cross-hatch brushes is affected by
1718 // transparent/solid background mode
1719
1720 if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
1721 {
1722 XSetFillStyle( (Display*) m_display, (GC) m_brushGC,
1723 (m_backgroundMode == wxTRANSPARENT) ? FillStippled : FillOpaqueStippled );
1724 }
1725 }
1726
1727 void wxWindowDC::SetPalette( const wxPalette& palette )
1728 {
1729 #if 0
1730 if (m_window)
1731 {
1732 if (palette.Ok())
1733 /* Use GetXColormap */
1734 XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1735 (Colormap) palette.GetXColormap());
1736 else
1737 /* Use wxGetMainColormap */
1738 XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1739 (Colormap) wxTheApp->GetMainColormap(m_display));
1740 }
1741 #endif
1742 }
1743
1744 void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
1745 {
1746 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1747
1748 if (!m_window) return;
1749
1750 wxRect rect;
1751 rect.x = XLOG2DEV(x);
1752 rect.y = YLOG2DEV(y);
1753 rect.width = XLOG2DEVREL(width);
1754 rect.height = YLOG2DEVREL(height);
1755
1756 if (!m_currentClippingRegion.IsNull())
1757 m_currentClippingRegion.Intersect( rect );
1758 else
1759 m_currentClippingRegion.Union( rect );
1760
1761 #if USE_PAINT_REGION
1762 if (!m_paintClippingRegion.IsNull())
1763 m_currentClippingRegion.Intersect( m_paintClippingRegion );
1764 #endif
1765
1766 wxCoord xx, yy, ww, hh;
1767 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1768 wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1769
1770 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1771 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1772 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1773 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1774 }
1775
1776 void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
1777 {
1778 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1779
1780 if (region.Empty())
1781 {
1782 DestroyClippingRegion();
1783 return;
1784 }
1785
1786 if (!m_window) return;
1787
1788 if (!m_currentClippingRegion.IsNull())
1789 m_currentClippingRegion.Intersect( region );
1790 else
1791 m_currentClippingRegion.Union( region );
1792
1793 #if USE_PAINT_REGION
1794 if (!m_paintClippingRegion.IsNull())
1795 m_currentClippingRegion.Intersect( m_paintClippingRegion );
1796 #endif
1797
1798 wxCoord xx, yy, ww, hh;
1799 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1800 wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1801
1802 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1803 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1804 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1805 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1806 }
1807
1808 void wxWindowDC::DestroyClippingRegion()
1809 {
1810 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1811
1812 wxDC::DestroyClippingRegion();
1813
1814 m_currentClippingRegion.Clear();
1815
1816 #if USE_PAINT_REGION
1817 if (!m_paintClippingRegion.IsEmpty())
1818 m_currentClippingRegion.Union( m_paintClippingRegion );
1819 #endif
1820
1821 if (!m_window) return;
1822
1823 if (m_currentClippingRegion.IsEmpty())
1824 {
1825 XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
1826 XSetClipMask( (Display*) m_display, (GC) m_brushGC, None );
1827 XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
1828 XSetClipMask( (Display*) m_display, (GC) m_bgGC, None );
1829 }
1830 else
1831 {
1832 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1833 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1834 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1835 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1836 }
1837 }
1838
1839 void wxWindowDC::Destroy()
1840 {
1841 if (m_penGC) wxFreePoolGC( (GC) m_penGC );
1842 m_penGC = NULL;
1843 if (m_brushGC) wxFreePoolGC( (GC) m_brushGC );
1844 m_brushGC = NULL;
1845 if (m_textGC) wxFreePoolGC( (GC) m_textGC );
1846 m_textGC = NULL;
1847 if (m_bgGC) wxFreePoolGC( (GC) m_bgGC );
1848 m_bgGC = NULL;
1849 }
1850
1851 void wxWindowDC::ComputeScaleAndOrigin()
1852 {
1853 /* CMB: copy scale to see if it changes */
1854 double origScaleX = m_scaleX;
1855 double origScaleY = m_scaleY;
1856
1857 wxDC::ComputeScaleAndOrigin();
1858
1859 /* CMB: if scale has changed call SetPen to recalulate the line width */
1860 if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&
1861 (m_pen.Ok()))
1862 {
1863 /* this is a bit artificial, but we need to force wxDC to think
1864 the pen has changed */
1865 wxPen pen = m_pen;
1866 m_pen = wxNullPen;
1867 SetPen( pen );
1868 }
1869 }
1870
1871 wxSize wxWindowDC::GetPPI() const
1872 {
1873 return wxSize(100, 100);
1874 }
1875
1876 int wxWindowDC::GetDepth() const
1877 {
1878 wxFAIL_MSG(wxT("not implemented"));
1879
1880 return -1;
1881 }
1882
1883 // ----------------------------------------------------------------------------
1884 // wxPaintDC
1885 // ----------------------------------------------------------------------------
1886
1887 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
1888
1889 wxPaintDC::wxPaintDC(wxWindow* win)
1890 : wxClientDC(win)
1891 {
1892 #if USE_PAINT_REGION
1893 if (!win->GetClipPaintRegion())
1894 return;
1895
1896 m_paintClippingRegion = win->GetUpdateRegion();
1897 Region region = (Region) m_paintClippingRegion.GetX11Region();
1898 if (region)
1899 {
1900 m_paintClippingRegion = win->GetUpdateRegion();
1901 Region region2 = (Region) m_paintClippingRegion.GetX11Region();
1902 if (region2)
1903 {
1904 m_currentClippingRegion.Union( m_paintClippingRegion );
1905
1906 XSetRegion( (Display*) m_display, (GC) m_penGC, region2 );
1907 XSetRegion( (Display*) m_display, (GC) m_brushGC, region2 );
1908 XSetRegion( (Display*) m_display, (GC) m_textGC, region2 );
1909 XSetRegion( (Display*) m_display, (GC) m_bgGC, region2 );
1910 }
1911 }
1912 #endif // USE_PAINT_REGION
1913 }
1914
1915 //-----------------------------------------------------------------------------
1916 // wxClientDC
1917 //-----------------------------------------------------------------------------
1918
1919 IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
1920
1921 wxClientDC::wxClientDC( wxWindow *win )
1922 : wxWindowDC( win )
1923 {
1924 wxCHECK_RET( win, _T("NULL window in wxClientDC::wxClientDC") );
1925
1926 #ifdef __WXUNIVERSAL__
1927 wxPoint ptOrigin = win->GetClientAreaOrigin();
1928 SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
1929 wxSize size = win->GetClientSize();
1930 SetClippingRegion(wxPoint(0, 0), size);
1931 #endif // __WXUNIVERSAL__
1932 }
1933
1934 void wxClientDC::DoGetSize(int *width, int *height) const
1935 {
1936 wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
1937
1938 m_owner->GetClientSize( width, height );
1939 }
1940
1941 // ----------------------------------------------------------------------------
1942 // wxDCModule
1943 // ----------------------------------------------------------------------------
1944
1945 class wxDCModule : public wxModule
1946 {
1947 public:
1948 bool OnInit();
1949 void OnExit();
1950
1951 private:
1952 DECLARE_DYNAMIC_CLASS(wxDCModule)
1953 };
1954
1955 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
1956
1957 bool wxDCModule::OnInit()
1958 {
1959 wxInitGCPool();
1960 return TRUE;
1961 }
1962
1963 void wxDCModule::OnExit()
1964 {
1965 wxCleanUpGCPool();
1966 }
wxWidgets (Impactor)