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