]> git.saurik.com Git - wxWidgets.git/blob - src/x11/dcclient.cpp
projects / wxWidgets.git / blob
? search:


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