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


8475d387d0dc7e3f78f35b944329d6c339df784c
[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
1462 if (is_mono)
1463 XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_x11window,
1464 (GC) m_textGC, xsrc, ysrc, width, height, xx, yy, 1 );
1465 else
1466 XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_x11window,
1467 (GC) m_penGC, xsrc, ysrc, width, height, xx, yy );
1468
1469 // remove mask again if any
1470 if (useMask && mask)
1471 {
1472 if (is_mono)
1473 {
1474 XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
1475 XSetClipOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
1476 if (!m_currentClippingRegion.IsNull())
1477 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1478 }
1479 else
1480 {
1481 XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
1482 XSetClipOrigin( (Display*) m_display, (GC) m_penGC, 0, 0 );
1483 if (!m_currentClippingRegion.IsNull())
1484 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1485 }
1486 }
1487 }
1488 else // use_bitmap_method
1489 {
1490 if ((width != ww) || (height != hh))
1491 {
1492 /* Draw source window into a bitmap as we cannot scale
1493 a window in contrast to a bitmap. this would actually
1494 work with memory dcs as well, but we'd lose the mask
1495 information and waste one step in this process since
1496 a memory already has a bitmap. all this is slightly
1497 inefficient as we could take an XImage directly from
1498 an X window, but we'd then also have to care that
1499 the window is not outside the screen (in which case
1500 we'd get a BadMatch or what not).
1501 Is a double XGetImage and combined XGetPixel and
1502 XPutPixel really faster? I'm not sure. look at wxXt
1503 for a different implementation of the same problem. */
1504
1505 wxBitmap bitmap( width, height );
1506
1507 // copy including child window contents
1508 XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );
1509 XCopyArea( (Display*) m_display, (Window) srcDC->GetWindow(), (Window) bitmap.GetPixmap(),
1510 (GC) m_penGC, xsrc, ysrc, width, height, 0, 0 );
1511 XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
1512
1513 // scale image
1514 wxImage image( bitmap.ConvertToImage() );
1515 image = image.Scale( ww, hh );
1516
1517 // convert to bitmap
1518 bitmap = image;
1519
1520 // draw scaled bitmap
1521 XCopyArea( (Display*) m_display, (Window) bitmap.GetPixmap(), (Window) m_x11window,
1522 (GC) m_penGC, 0, 0, width, height, xx, yy );
1523 }
1524 else
1525 {
1526 // No scaling and not a memory dc with a mask either
1527
1528 // copy including child window contents
1529 XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );
1530 XCopyArea( (Display*) m_display, (Window) srcDC->GetWindow(), (Window) m_x11window,
1531 (GC) m_penGC, xsrc, ysrc, width, height, xx, yy );
1532 XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
1533 }
1534 }
1535
1536 SetLogicalFunction( old_logical_func );
1537
1538 return true;
1539 }
1540
1541 void wxWindowDCImpl::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
1542 {
1543 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1544
1545 if (!m_x11window) return;
1546
1547 x = XLOG2DEV(x);
1548 y = YLOG2DEV(y);
1549
1550 #if wxUSE_UNICODE
1551 PangoLayout *layout = pango_layout_new(m_context);
1552 pango_layout_set_font_description(layout, m_fontdesc);
1553
1554 const wxCharBuffer data = wxConvUTF8.cWC2MB( text );
1555 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
1556
1557 // Measure layout.
1558 int w,h;
1559 pango_layout_get_pixel_size(layout, &w, &h);
1560 wxCoord width = w;
1561 wxCoord height = h;
1562
1563 // Draw layout.
1564 x11_draw_layout( (Drawable) m_x11window, (GC) m_textGC, x, y, layout, m_textForegroundColour );
1565
1566 g_object_unref( G_OBJECT( layout ) );
1567
1568 CalcBoundingBox (x + width, y + height);
1569 CalcBoundingBox (x, y);
1570 #else
1571 XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1572
1573 wxCHECK_RET( xfont, wxT("invalid font") );
1574
1575 // First draw a rectangle representing the text background, if a text
1576 // background is specified
1577 if (m_textBackgroundColour.IsOk () && (m_backgroundMode != wxTRANSPARENT))
1578 {
1579 // Since X draws from the baseline of the text, must add the text height
1580 int cx = 0;
1581 int cy = 0;
1582 int ascent = 0;
1583 int slen;
1584 int direction, descent;
1585
1586 slen = strlen(text);
1587 XCharStruct overall_return;
1588
1589 (void)XTextExtents(xfont, (const char*) text.c_str(), slen, &direction,
1590 &ascent, &descent, &overall_return);
1591
1592 cx = overall_return.width;
1593 cy = ascent + descent;
1594 m_textBackgroundColour.CalcPixel(m_cmap);
1595 m_textForegroundColour.CalcPixel(m_cmap);
1596 XSetForeground ((Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel());
1597 XFillRectangle( (Display*) m_display, (Window) m_x11window,
1598 (GC) m_textGC, x, y, cx, cy );
1599 XSetForeground ((Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel());
1600
1601 }
1602
1603 XSetFont( (Display*) m_display, (GC) m_textGC, xfont->fid );
1604 #if !wxUSE_NANOX
1605 // This may be a test for whether the font is 16-bit, but it also
1606 // seems to fail for valid 8-bit fonts too.
1607 if (1) // (xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
1608 #endif
1609 {
1610 XDrawString( (Display*) m_display, (Window) m_x11window,
1611 (GC) m_textGC, x, y + XFontStructGetAscent(xfont), text.c_str(), text.length() );
1612 }
1613
1614 #if 0
1615 if (m_font.GetUnderlined())
1616 {
1617 wxCoord ul_y = y + XFontStructGetAscent(font);
1618 if (font->descent > 0) ul_y++;
1619 gdk_draw_line( m_x11window, m_textGC, x, ul_y, x + width, ul_y);
1620 }
1621
1622 width = wxCoord(width / m_scaleX);
1623 height = wxCoord(height / m_scaleY);
1624
1625 CalcBoundingBox (x + width, y + height);
1626 CalcBoundingBox (x, y);
1627 #endif
1628 #endif
1629 }
1630
1631 void wxWindowDCImpl::DoDrawRotatedText(const wxString& WXUNUSED(text),
1632 wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
1633 double WXUNUSED(angle))
1634 {
1635 wxFAIL_MSG( "not implemented" );
1636 }
1637
1638 void wxWindowDCImpl::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
1639 wxCoord *descent, wxCoord *externalLeading,
1640 const wxFont *font ) const
1641 {
1642 wxCHECK_RET( IsOk(), wxT("invalid dc") );
1643
1644 if (string.empty())
1645 {
1646 if (width) (*width) = 0;
1647 if (height) (*height) = 0;
1648 return;
1649 }
1650
1651 #if wxUSE_UNICODE
1652 PangoLayout *layout = pango_layout_new( m_context );
1653
1654 if (font)
1655 pango_layout_set_font_description( layout, font->GetNativeFontInfo()->description );
1656 else
1657 pango_layout_set_font_description(layout, m_fontdesc);
1658
1659 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
1660 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
1661
1662 // Measure text.
1663 int w,h;
1664 pango_layout_get_pixel_size(layout, &w, &h);
1665
1666 if (width) (*width) = (wxCoord) w;
1667 if (height) (*height) = (wxCoord) h;
1668 if (descent)
1669 {
1670 // Do something about metrics here. TODO.
1671 (*descent) = 0;
1672 }
1673 if (externalLeading) (*externalLeading) = 0; // ??
1674
1675 g_object_unref( G_OBJECT( layout ) );
1676 #else
1677 wxFont fontToUse = m_font;
1678 if (font) fontToUse = *font;
1679
1680 wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );
1681
1682 XFontStruct *xfont = (XFontStruct*) fontToUse.GetFontStruct( m_scaleY, m_display );
1683
1684 wxCHECK_RET( xfont, wxT("invalid font") );
1685
1686 int direction, ascent, descent2;
1687 XCharStruct overall;
1688
1689 XTextExtents( xfont, (const char*) string.c_str(), string.length(), &direction,
1690 &ascent, &descent2, &overall);
1691
1692 if (width)
1693 *width = (wxCoord)( overall.width / m_scaleX );
1694 if (height)
1695 *height = (wxCoord)((ascent + descent2) / m_scaleY );
1696 if (descent)
1697 *descent = (wxCoord)(descent2 / m_scaleY );
1698 if (externalLeading)
1699 *externalLeading = 0; // ??
1700 #endif
1701 }
1702
1703 wxCoord wxWindowDCImpl::GetCharWidth() const
1704 {
1705 wxCHECK_MSG( IsOk(), 0, wxT("invalid dc") );
1706
1707 #if wxUSE_UNICODE
1708 PangoLayout *layout = pango_layout_new( m_context );
1709
1710 if (m_fontdesc)
1711 pango_layout_set_font_description(layout, m_fontdesc);
1712 else
1713 pango_layout_set_font_description(layout, this->GetFont().GetNativeFontInfo()->description);
1714
1715 pango_layout_set_text(layout, "H", 1 );
1716 int w,h;
1717 pango_layout_get_pixel_size(layout, &w, &h);
1718 g_object_unref( G_OBJECT( layout ) );
1719
1720 return w;
1721 #else
1722 wxCHECK_MSG( m_font.IsOk(), 0, wxT("invalid font") );
1723
1724 XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1725
1726 wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1727
1728 int direction, ascent, descent;
1729 XCharStruct overall;
1730
1731 XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1732
1733 return (wxCoord)(overall.width / m_scaleX);
1734 #endif
1735 }
1736
1737 wxCoord wxWindowDCImpl::GetCharHeight() const
1738 {
1739 wxCHECK_MSG( IsOk(), 0, wxT("invalid dc") );
1740
1741 #if wxUSE_UNICODE
1742 PangoLayout *layout = pango_layout_new( m_context );
1743
1744 if (m_fontdesc)
1745 pango_layout_set_font_description(layout, m_fontdesc);
1746 else
1747 pango_layout_set_font_description(layout, this->GetFont().GetNativeFontInfo()->description);
1748
1749 pango_layout_set_text(layout, "H", 1 );
1750 int w,h;
1751 pango_layout_get_pixel_size(layout, &w, &h);
1752 g_object_unref( G_OBJECT( layout ) );
1753
1754 return h;
1755 #else
1756 wxCHECK_MSG( m_font.IsOk(), 0, wxT("invalid font") );
1757
1758 XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1759
1760 wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1761
1762 int direction, ascent, descent;
1763 XCharStruct overall;
1764
1765 XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1766
1767 return (wxCoord)((ascent+descent) / m_scaleY);
1768 #endif
1769 }
1770
1771 void wxWindowDCImpl::Clear()
1772 {
1773 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1774
1775 if (!m_x11window) return;
1776
1777 /* - we either are a memory dc or have a window as the
1778 owner. anything else shouldn't happen.
1779 - we don't use gdk_window_clear() as we don't set
1780 the window's background colour anymore. it is too
1781 much pain to keep the DC's and the window's back-
1782 ground colour in synch. */
1783
1784 if (m_window)
1785 {
1786 int width,height;
1787 m_window->GetSize( &width, &height );
1788 XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_bgGC, 0, 0, width, height );
1789 return;
1790 }
1791
1792 if (m_isMemDC)
1793 {
1794 int width,height;
1795 DoGetSize( &width, &height );
1796 XFillRectangle( (Display*) m_display, (Window) m_x11window, (GC) m_bgGC, 0, 0, width, height );
1797 return;
1798 }
1799 }
1800
1801 void wxWindowDCImpl::SetFont( const wxFont &font )
1802 {
1803 wxCHECK_RET( IsOk(), wxT("invalid dc") );
1804
1805 m_font = font;
1806
1807 #if wxUSE_UNICODE
1808 m_fontdesc = font.GetNativeFontInfo()->description;
1809 #endif
1810 }
1811
1812 void wxWindowDCImpl::SetPen( const wxPen &pen )
1813 {
1814 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1815
1816 if (m_pen == pen) return;
1817
1818 m_pen = pen;
1819
1820 if (!m_pen.IsOk()) return;
1821
1822 if (!m_x11window) return;
1823
1824 int width = m_pen.GetWidth();
1825 if (width <= 0)
1826 {
1827 // CMB: if width is non-zero scale it with the dc
1828 width = 1;
1829 }
1830 else
1831 {
1832 // X doesn't allow different width in x and y and so we take
1833 // the average
1834 double w = 0.5 +
1835 ( fabs((double) XLOG2DEVREL(width)) +
1836 fabs((double) YLOG2DEVREL(width)) ) / 2.0;
1837 width = (int)w;
1838 }
1839
1840 static const wxX11Dash dotted[] = {1, 1};
1841 static const wxX11Dash short_dashed[] = {2, 2};
1842 static const wxX11Dash long_dashed[] = {2, 4};
1843 static const wxX11Dash dotted_dashed[] = {3, 3, 1, 3};
1844
1845 // We express dash pattern in pen width unit, so we are
1846 // independent of zoom factor and so on...
1847 int req_nb_dash;
1848 const wxX11Dash *req_dash;
1849
1850 int lineStyle = LineSolid;
1851 switch (m_pen.GetStyle())
1852 {
1853 case wxUSER_DASH:
1854 {
1855 lineStyle = LineOnOffDash;
1856 req_nb_dash = m_pen.GetDashCount();
1857 req_dash = (wxX11Dash*)m_pen.GetDash();
1858 break;
1859 }
1860 case wxDOT:
1861 {
1862 lineStyle = LineOnOffDash;
1863 req_nb_dash = 2;
1864 req_dash = dotted;
1865 break;
1866 }
1867 case wxLONG_DASH:
1868 {
1869 lineStyle = LineOnOffDash;
1870 req_nb_dash = 2;
1871 req_dash = long_dashed;
1872 break;
1873 }
1874 case wxSHORT_DASH:
1875 {
1876 lineStyle = LineOnOffDash;
1877 req_nb_dash = 2;
1878 req_dash = short_dashed;
1879 break;
1880 }
1881 case wxDOT_DASH:
1882 {
1883 // lineStyle = LineDoubleDash;
1884 lineStyle = LineOnOffDash;
1885 req_nb_dash = 4;
1886 req_dash = dotted_dashed;
1887 break;
1888 }
1889
1890 case wxTRANSPARENT:
1891 case wxSTIPPLE_MASK_OPAQUE:
1892 case wxSTIPPLE:
1893 case wxSOLID:
1894 default:
1895 {
1896 lineStyle = LineSolid;
1897 req_dash = (wxX11Dash*)NULL;
1898 req_nb_dash = 0;
1899 break;
1900 }
1901 }
1902
1903 int capStyle = CapRound;
1904 switch (m_pen.GetCap())
1905 {
1906 case wxCAP_PROJECTING: { capStyle = CapProjecting; break; }
1907 case wxCAP_BUTT: { capStyle = CapButt; break; }
1908 case wxCAP_ROUND:
1909 default:
1910 {
1911 if (width <= 1)
1912 {
1913 width = 0;
1914 capStyle = CapNotLast;
1915 }
1916 else
1917 {
1918 capStyle = CapRound;
1919 }
1920 break;
1921 }
1922 }
1923
1924 int joinStyle = JoinRound;
1925 switch (m_pen.GetJoin())
1926 {
1927 case wxJOIN_BEVEL: { joinStyle = JoinBevel; break; }
1928 case wxJOIN_MITER: { joinStyle = JoinMiter; break; }
1929 case wxJOIN_ROUND:
1930 default: { joinStyle = JoinRound; break; }
1931 }
1932
1933 XSetLineAttributes( (Display*) m_display, (GC) m_penGC, width, lineStyle, capStyle, joinStyle );
1934
1935 m_pen.GetColour().CalcPixel( m_cmap );
1936 XSetForeground( (Display*) m_display, (GC) m_penGC, m_pen.GetColour().GetPixel() );
1937 }
1938
1939 void wxWindowDCImpl::SetBrush( const wxBrush &brush )
1940 {
1941 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1942
1943 if (m_brush == brush) return;
1944
1945 m_brush = brush;
1946
1947 if (!m_brush.IsOk()) return;
1948
1949 if (!m_x11window) return;
1950
1951 m_brush.GetColour().CalcPixel( m_cmap );
1952 XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
1953
1954 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
1955
1956 if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->IsOk()))
1957 {
1958 if (m_brush.GetStipple()->GetPixmap())
1959 {
1960 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillTiled );
1961 XSetTile( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetPixmap() );
1962 }
1963 else
1964 {
1965 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1966 XSetStipple( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetBitmap() );
1967 }
1968 }
1969
1970 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
1971 {
1972 XSetFillStyle( (Display*) m_display, (GC) m_textGC, FillOpaqueStippled );
1973 XSetStipple( (Display*) m_display, (GC) m_textGC, (Pixmap) m_brush.GetStipple()->GetMask()->GetBitmap() );
1974 }
1975
1976 if (m_brush.IsHatch())
1977 {
1978 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1979 int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
1980 XSetStipple( (Display*) m_display, (GC) m_brushGC, hatches[num] );
1981 }
1982 }
1983
1984 void wxWindowDCImpl::SetBackground( const wxBrush &brush )
1985 {
1986 /* CMB 21/7/98: Added SetBackground. Sets background brush
1987 * for Clear() and bg colour for shapes filled with cross-hatch brush */
1988
1989 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
1990
1991 if (m_backgroundBrush == brush) return;
1992
1993 m_backgroundBrush = brush;
1994
1995 if (!m_backgroundBrush.IsOk()) return;
1996
1997 if (!m_x11window) return;
1998
1999 m_backgroundBrush.GetColour().CalcPixel( m_cmap );
2000 XSetBackground( (Display*) m_display, (GC) m_brushGC, m_backgroundBrush.GetColour().GetPixel() );
2001 XSetBackground( (Display*) m_display, (GC) m_penGC, m_backgroundBrush.GetColour().GetPixel() );
2002 XSetBackground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
2003 XSetForeground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
2004
2005 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
2006
2007 if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->IsOk()))
2008 {
2009 if (m_backgroundBrush.GetStipple()->GetPixmap())
2010 {
2011 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillTiled );
2012 XSetTile( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetPixmap() );
2013 }
2014 else
2015 {
2016 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
2017 XSetStipple( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetBitmap() );
2018 }
2019 }
2020
2021 if (m_backgroundBrush.IsHatch())
2022 {
2023 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
2024 int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
2025 XSetStipple( (Display*) m_display, (GC) m_bgGC, hatches[num] );
2026 }
2027 }
2028
2029 void wxWindowDCImpl::SetLogicalFunction( int function )
2030 {
2031 wxCHECK_RET( IsOk(), wxT("invalid dc") );
2032
2033 int x_function;
2034
2035 if (m_logicalFunction == function)
2036 return;
2037
2038 // VZ: shouldn't this be a CHECK?
2039 if (!m_x11window)
2040 return;
2041
2042 switch (function)
2043 {
2044 case wxCLEAR:
2045 x_function = GXclear;
2046 break;
2047 case wxXOR:
2048 x_function = GXxor;
2049 break;
2050 case wxINVERT:
2051 x_function = GXinvert;
2052 break;
2053 case wxOR_REVERSE:
2054 x_function = GXorReverse;
2055 break;
2056 case wxAND_REVERSE:
2057 x_function = GXandReverse;
2058 break;
2059 case wxAND:
2060 x_function = GXand;
2061 break;
2062 case wxOR:
2063 x_function = GXor;
2064 break;
2065 case wxAND_INVERT:
2066 x_function = GXandInverted;
2067 break;
2068 case wxNO_OP:
2069 x_function = GXnoop;
2070 break;
2071 case wxNOR:
2072 x_function = GXnor;
2073 break;
2074 case wxEQUIV:
2075 x_function = GXequiv;
2076 break;
2077 case wxSRC_INVERT:
2078 x_function = GXcopyInverted;
2079 break;
2080 case wxOR_INVERT:
2081 x_function = GXorInverted;
2082 break;
2083 case wxNAND:
2084 x_function = GXnand;
2085 break;
2086 case wxSET:
2087 x_function = GXset;
2088 break;
2089 case wxCOPY:
2090 default:
2091 x_function = GXcopy;
2092 break;
2093 }
2094
2095 XSetFunction( (Display*) m_display, (GC) m_penGC, x_function );
2096 XSetFunction( (Display*) m_display, (GC) m_brushGC, x_function );
2097
2098 // to stay compatible with wxMSW, we don't apply ROPs to the text
2099 // operations (i.e. DrawText/DrawRotatedText).
2100 // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
2101 XSetFunction( (Display*) m_display, (GC) m_textGC, x_function );
2102
2103 m_logicalFunction = function;
2104 }
2105
2106 void wxWindowDCImpl::SetTextForeground( const wxColour &col )
2107 {
2108 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2109
2110 // don't set m_textForegroundColour to an invalid colour as we'd crash
2111 // later then (we use m_textForegroundColour.GetColor() without checking
2112 // in a few places)
2113 if ( !col.IsOk() || (m_textForegroundColour == col) )
2114 return;
2115
2116 m_textForegroundColour = col;
2117
2118 if (m_x11window)
2119 {
2120 m_textForegroundColour.CalcPixel( m_cmap );
2121 XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
2122 }
2123 }
2124
2125 void wxWindowDCImpl::SetTextBackground( const wxColour &col )
2126 {
2127 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2128
2129 // same as above
2130 if ( !col.IsOk() || (m_textBackgroundColour == col) )
2131 return;
2132
2133 m_textBackgroundColour = col;
2134
2135 if (m_x11window)
2136 {
2137 m_textBackgroundColour.CalcPixel( m_cmap );
2138 XSetBackground( (Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel() );
2139 }
2140 }
2141
2142 void wxWindowDCImpl::SetBackgroundMode( int mode )
2143 {
2144 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2145
2146 m_backgroundMode = mode;
2147
2148 #if wxUSE_NANOX
2149 GrSetGCUseBackground((GC) m_textGC, mode == wxTRANSPARENT ? FALSE : TRUE);
2150 #endif
2151
2152 if (!m_x11window) return;
2153
2154 // CMB 21/7/98: fill style of cross-hatch brushes is affected by
2155 // transparent/solid background mode
2156
2157 if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
2158 {
2159 XSetFillStyle( (Display*) m_display, (GC) m_brushGC,
2160 (m_backgroundMode == wxTRANSPARENT) ? FillStippled : FillOpaqueStippled );
2161 }
2162 }
2163
2164 void wxWindowDCImpl::SetPalette( const wxPalette& WXUNUSED(palette) )
2165 {
2166 #if 0
2167 if (m_x11window)
2168 {
2169 if (palette.IsOk())
2170 /* Use GetXColormap */
2171 XSetWindowColormap ((Display*) m_display, (Window) m_x11window->GetXWindow(),
2172 (Colormap) palette.GetXColormap());
2173 else
2174 /* Use wxGetMainColormap */
2175 XSetWindowColormap ((Display*) m_display, (Window) m_x11window->GetXWindow(),
2176 (Colormap) wxTheApp->GetMainColormap(m_display));
2177 }
2178 #endif
2179 }
2180
2181 void wxWindowDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
2182 {
2183 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2184
2185 if (!m_x11window) return;
2186
2187 if (width <= 0)
2188 width = 1;
2189
2190 if (height <= 0)
2191 height = 1;
2192
2193 wxRect rect;
2194 rect.x = XLOG2DEV(x);
2195 rect.y = YLOG2DEV(y);
2196 rect.width = XLOG2DEVREL(width);
2197 rect.height = YLOG2DEVREL(height);
2198
2199 if (!m_currentClippingRegion.IsEmpty())
2200 m_currentClippingRegion.Intersect( rect );
2201 else
2202 m_currentClippingRegion = rect;
2203
2204 #if USE_PAINT_REGION
2205 if (!m_paintClippingRegion.IsEmpty())
2206 m_currentClippingRegion.Intersect( m_paintClippingRegion );
2207 #endif
2208
2209 wxCoord xx, yy, ww, hh;
2210 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
2211 wxX11DCImpl::DoSetClippingRegion( xx, yy, ww, hh );
2212
2213 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
2214 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
2215 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
2216 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
2217 }
2218
2219 void wxWindowDCImpl::DoSetClippingRegionAsRegion( const wxRegion& region )
2220 {
2221 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2222
2223 if (region.Empty())
2224 {
2225 DestroyClippingRegion();
2226 return;
2227 }
2228
2229 if (!m_x11window) return;
2230
2231 if (!m_currentClippingRegion.IsEmpty())
2232 m_currentClippingRegion.Intersect( region );
2233 else
2234 m_currentClippingRegion = region;
2235
2236 #if USE_PAINT_REGION
2237 if (!m_paintClippingRegion.IsEmpty())
2238 m_currentClippingRegion.Intersect( m_paintClippingRegion );
2239 #endif
2240
2241 wxCoord xx, yy, ww, hh;
2242 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
2243 wxX11DCImpl::DoSetClippingRegion( xx, yy, ww, hh );
2244
2245 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
2246 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
2247 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
2248 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
2249 }
2250
2251 void wxWindowDCImpl::DestroyClippingRegion()
2252 {
2253 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
2254
2255 wxDCImpl::DestroyClippingRegion();
2256
2257 m_currentClippingRegion.Clear();
2258
2259 #if USE_PAINT_REGION
2260 if (!m_paintClippingRegion.IsEmpty())
2261 m_currentClippingRegion.Union( m_paintClippingRegion );
2262 #endif
2263
2264 if (!m_x11window) return;
2265
2266 if (m_currentClippingRegion.IsEmpty())
2267 {
2268 XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
2269 XSetClipMask( (Display*) m_display, (GC) m_brushGC, None );
2270 XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
2271 XSetClipMask( (Display*) m_display, (GC) m_bgGC, None );
2272 }
2273 else
2274 {
2275 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
2276 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
2277 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
2278 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
2279 }
2280 }
2281
2282 void wxWindowDCImpl::Destroy()
2283 {
2284 if (m_penGC) wxFreePoolGC( (GC) m_penGC );
2285 m_penGC = NULL;
2286 if (m_brushGC) wxFreePoolGC( (GC) m_brushGC );
2287 m_brushGC = NULL;
2288 if (m_textGC) wxFreePoolGC( (GC) m_textGC );
2289 m_textGC = NULL;
2290 if (m_bgGC) wxFreePoolGC( (GC) m_bgGC );
2291 m_bgGC = NULL;
2292 }
2293
2294 void wxWindowDCImpl::ComputeScaleAndOrigin()
2295 {
2296 /* CMB: copy scale to see if it changes */
2297 double origScaleX = m_scaleX;
2298 double origScaleY = m_scaleY;
2299
2300 wxDCImpl::ComputeScaleAndOrigin();
2301
2302 /* CMB: if scale has changed call SetPen to recalulate the line width */
2303 if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&
2304 (m_pen.IsOk()))
2305 {
2306 /* this is a bit artificial, but we need to force wxDC to think
2307 the pen has changed */
2308 wxPen pen = m_pen;
2309 m_pen = wxNullPen;
2310 SetPen( pen );
2311 }
2312 }
2313
2314 wxSize wxWindowDCImpl::GetPPI() const
2315 {
2316 return wxSize(100, 100);
2317 }
2318
2319 int wxWindowDCImpl::GetDepth() const
2320 {
2321 wxFAIL_MSG(wxT("not implemented"));
2322
2323 return -1;
2324 }
2325
2326 //-----------------------------------------------------------------------------
2327 // wxClientDC
2328 //-----------------------------------------------------------------------------
2329
2330 IMPLEMENT_ABSTRACT_CLASS(wxClientDCImpl, wxWindowDCImpl)
2331
2332 wxClientDCImpl::wxClientDCImpl( wxDC *owner, wxWindow *window )
2333 : wxWindowDCImpl( owner, window )
2334 {
2335 wxCHECK_RET( window, _T("NULL window in wxClientDC::wxClientDC") );
2336
2337 m_x11window = (WXWindow*) window->GetClientAreaWindow();
2338
2339 // Adjust the client area when the wxWindow is not using 2 X11 windows.
2340 if (m_x11window == (WXWindow*) window->GetMainWindow())
2341 {
2342 wxPoint ptOrigin = window->GetClientAreaOrigin();
2343 SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
2344 wxSize size = window->GetClientSize();
2345 DoSetClippingRegion( 0, 0, size.x, size.y );
2346 }
2347 }
2348
2349 void wxClientDCImpl::DoGetSize(int *width, int *height) const
2350 {
2351 wxCHECK_RET( m_window, _T("GetSize() doesn't work without window") );
2352
2353 m_window->GetClientSize( width, height );
2354 }
2355
2356 // ----------------------------------------------------------------------------
2357 // wxPaintDC
2358 // ----------------------------------------------------------------------------
2359
2360 IMPLEMENT_ABSTRACT_CLASS(wxPaintDCImpl, wxClientDCImpl)
2361
2362 wxPaintDCImpl::wxPaintDCImpl(wxDC *owner, wxWindow* window)
2363 : wxClientDCImpl(owner, window)
2364 {
2365 #if USE_PAINT_REGION
2366 if (!window->GetClipPaintRegion())
2367 return;
2368
2369 m_paintClippingRegion = window->GetUpdateRegion();
2370 Region region = (Region) m_paintClippingRegion.GetX11Region();
2371 if (region)
2372 {
2373 m_currentClippingRegion.Union( m_paintClippingRegion );
2374
2375 XSetRegion( (Display*) m_display, (GC) m_penGC, region );
2376 XSetRegion( (Display*) m_display, (GC) m_brushGC, region );
2377 XSetRegion( (Display*) m_display, (GC) m_textGC, region );
2378 XSetRegion( (Display*) m_display, (GC) m_bgGC, region );
2379 }
2380 #endif // USE_PAINT_REGION
2381 }
2382
2383 // ----------------------------------------------------------------------------
2384 // wxDCModule
2385 // ----------------------------------------------------------------------------
2386
2387 class wxDCModule : public wxModule
2388 {
2389 public:
2390 // we must be cleaned up before wxDisplayModule which closes the global
2391 // display
2392 wxDCModule()
2393 {
2394 AddDependency(wxClassInfo::FindClass(_T("wxX11DisplayModule")));
2395 }
2396
2397 bool OnInit() { wxInitGCPool(); return true; }
2398 void OnExit() { wxCleanUpGCPool(); }
2399
2400 private:
2401 DECLARE_DYNAMIC_CLASS(wxDCModule)
2402 };
2403
2404 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2405
wxWidgets (Impactor)