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


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