projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Trivially implemented DoDrawIcon
[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
1066 /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
1067 drawing a mono-bitmap (XBitmap) we use the current text GC */
1068 if (is_mono)
1069 XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_window,
1070 (GC) m_textGC, 0, 0, w, h, xx, yy, 1 );
1071 else
1072 XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_window,
1073 (GC) m_penGC, 0, 0, w, h, xx, yy );
1074
1075 /* remove mask again if any */
1076 if (useMask && mask)
1077 {
1078 if (is_mono)
1079 {
1080 XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
1081 XSetClipOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
1082 if (!m_currentClippingRegion.IsNull())
1083 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1084 }
1085 else
1086 {
1087 XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
1088 XSetClipOrigin( (Display*) m_display, (GC) m_penGC, 0, 0 );
1089 if (!m_currentClippingRegion.IsNull())
1090 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1091 }
1092 }
1093 }
1094 #endif
1095 // wxUSE_NANOX/!wxUSE_NANOX
1096
1097 bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
1098 wxDC *source, wxCoord xsrc, wxCoord ysrc, int rop, bool useMask,
1099 wxCoord xsrcMask, wxCoord ysrcMask )
1100 {
1101 /* this is the nth try to get this utterly useless function to
1102 work. it now completely ignores the scaling or translation
1103 of the source dc, but scales correctly on the target dc and
1104 knows about possible mask information in a memory dc. */
1105
1106 wxCHECK_MSG( Ok(), FALSE, wxT("invalid window dc") );
1107
1108 wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
1109
1110 if (!m_window) return FALSE;
1111
1112 // transform the source DC coords to the device ones
1113 xsrc = source->XLOG2DEV(xsrc);
1114 ysrc = source->YLOG2DEV(ysrc);
1115
1116 wxClientDC *srcDC = (wxClientDC*)source;
1117 wxMemoryDC *memDC = (wxMemoryDC*)source;
1118
1119 bool use_bitmap_method = FALSE;
1120 bool is_mono = FALSE;
1121
1122 /* TODO: use the mask origin when drawing transparently */
1123 if (xsrcMask == -1 && ysrcMask == -1)
1124 {
1125 xsrcMask = xsrc; ysrcMask = ysrc;
1126 }
1127
1128 #if 0
1129 if (srcDC->m_isMemDC)
1130 {
1131 if (!memDC->m_selected.Ok()) return FALSE;
1132
1133 /* we use the "XCopyArea" way to copy a memory dc into
1134 y different window if the memory dc BOTH
1135 a) doesn't have any mask or its mask isn't used
1136 b) it is clipped
1137 c) is not 1-bit */
1138
1139 if (useMask && (memDC->m_selected.GetMask()))
1140 {
1141 /* we HAVE TO use the direct way for memory dcs
1142 that have mask since the XCopyArea doesn't know
1143 about masks */
1144 use_bitmap_method = TRUE;
1145 }
1146 else if (memDC->m_selected.GetDepth() == 1)
1147 {
1148 /* we HAVE TO use the direct way for memory dcs
1149 that are bitmaps because XCopyArea doesn't cope
1150 with different bit depths */
1151 is_mono = TRUE;
1152 use_bitmap_method = TRUE;
1153 }
1154 else if ((xsrc == 0) && (ysrc == 0) &&
1155 (width == memDC->m_selected.GetWidth()) &&
1156 (height == memDC->m_selected.GetHeight()))
1157 {
1158 /* we SHOULD use the direct way if all of the bitmap
1159 in the memory dc is copied in which case XCopyArea
1160 wouldn't be able able to boost performace by reducing
1161 the area to be scaled */
1162 use_bitmap_method = TRUE;
1163 }
1164 else
1165 {
1166 use_bitmap_method = FALSE;
1167 }
1168 }
1169
1170 CalcBoundingBox( xdest, ydest );
1171 CalcBoundingBox( xdest + width, ydest + height );
1172
1173 /* scale/translate size and position */
1174 wxCoord xx = XLOG2DEV(xdest);
1175 wxCoord yy = YLOG2DEV(ydest);
1176
1177 wxCoord ww = XLOG2DEVREL(width);
1178 wxCoord hh = YLOG2DEVREL(height);
1179
1180 /* compare to current clipping region */
1181 if (!m_currentClippingRegion.IsNull())
1182 {
1183 wxRegion tmp( xx,yy,ww,hh );
1184 tmp.Intersect( m_currentClippingRegion );
1185 if (tmp.IsEmpty())
1186 return TRUE;
1187 }
1188
1189 int old_logical_func = m_logicalFunction;
1190 SetLogicalFunction( logical_func );
1191
1192 if (use_bitmap_method)
1193 {
1194 /* scale/translate bitmap size */
1195 wxCoord bm_width = memDC->m_selected.GetWidth();
1196 wxCoord bm_height = memDC->m_selected.GetHeight();
1197
1198 wxCoord bm_ww = XLOG2DEVREL( bm_width );
1199 wxCoord bm_hh = YLOG2DEVREL( bm_height );
1200
1201 /* scale bitmap if required */
1202 wxBitmap use_bitmap;
1203
1204 if ((bm_width != bm_ww) || (bm_height != bm_hh))
1205 {
1206 wxImage image( memDC->m_selected );
1207 image = image.Scale( bm_ww, bm_hh );
1208
1209 if (is_mono)
1210 use_bitmap = image.ConvertToMonoBitmap(255,255,255);
1211 else
1212 use_bitmap = image.ConvertToBitmap();
1213 }
1214 else
1215 {
1216 use_bitmap = memDC->m_selected;
1217 }
1218
1219 /* apply mask if any */
1220 GdkBitmap *mask = (GdkBitmap *) NULL;
1221 if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
1222
1223 if (useMask && mask)
1224 {
1225 GdkBitmap *new_mask = (GdkBitmap*) NULL;
1226 if (!m_currentClippingRegion.IsNull())
1227 {
1228 GdkColor col;
1229 new_mask = gdk_pixmap_new( wxGetRootWindow()->window, bm_ww, bm_hh, 1 );
1230 GdkGC *gc = gdk_gc_new( new_mask );
1231 col.pixel = 0;
1232 gdk_gc_set_foreground( gc, &col );
1233 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
1234 col.pixel = 0;
1235 gdk_gc_set_background( gc, &col );
1236 col.pixel = 1;
1237 gdk_gc_set_foreground( gc, &col );
1238 gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
1239 gdk_gc_set_clip_origin( gc, -xx, -yy );
1240 gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
1241 gdk_gc_set_stipple( gc, mask );
1242 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
1243 gdk_gc_unref( gc );
1244 }
1245
1246 if (is_mono)
1247 {
1248 if (new_mask)
1249 gdk_gc_set_clip_mask( m_textGC, new_mask );
1250 else
1251 gdk_gc_set_clip_mask( m_textGC, mask );
1252 gdk_gc_set_clip_origin( m_textGC, xx, yy );
1253 }
1254 else
1255 {
1256 if (new_mask)
1257 gdk_gc_set_clip_mask( m_penGC, new_mask );
1258 else
1259 gdk_gc_set_clip_mask( m_penGC, mask );
1260 gdk_gc_set_clip_origin( m_penGC, xx, yy );
1261 }
1262 if (new_mask)
1263 gdk_bitmap_unref( new_mask );
1264 }
1265
1266 /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
1267 drawing a mono-bitmap (XBitmap) we use the current text GC */
1268
1269 if (is_mono)
1270 gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), xsrc, ysrc, xx, yy, ww, hh );
1271 else
1272 gdk_draw_pixmap( m_window, m_penGC, use_bitmap.GetPixmap(), xsrc, ysrc, xx, yy, ww, hh );
1273
1274 /* remove mask again if any */
1275 if (useMask && mask)
1276 {
1277 if (is_mono)
1278 {
1279 gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
1280 gdk_gc_set_clip_origin( m_textGC, 0, 0 );
1281 if (!m_currentClippingRegion.IsNull())
1282 gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
1283 }
1284 else
1285 {
1286 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
1287 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
1288 if (!m_currentClippingRegion.IsNull())
1289 gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
1290 }
1291 }
1292 }
1293 else /* use_bitmap_method */
1294 {
1295 if ((width != ww) || (height != hh))
1296 {
1297 /* draw source window into a bitmap as we cannot scale
1298 a window in contrast to a bitmap. this would actually
1299 work with memory dcs as well, but we'd lose the mask
1300 information and waste one step in this process since
1301 a memory already has a bitmap. all this is slightly
1302 inefficient as we could take an XImage directly from
1303 an X window, but we'd then also have to care that
1304 the window is not outside the screen (in which case
1305 we'd get a BadMatch or what not).
1306 Is a double XGetImage and combined XGetPixel and
1307 XPutPixel really faster? I'm not sure. look at wxXt
1308 for a different implementation of the same problem. */
1309
1310 wxBitmap bitmap( width, height );
1311
1312 /* copy including child window contents */
1313 gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
1314 gdk_window_copy_area( bitmap.GetPixmap(), m_penGC, 0, 0,
1315 srcDC->GetWindow(),
1316 xsrc, ysrc, width, height );
1317 gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
1318
1319 /* scale image */
1320 wxImage image( bitmap );
1321 image = image.Scale( ww, hh );
1322
1323 /* convert to bitmap */
1324 bitmap = image.ConvertToBitmap();
1325
1326 /* draw scaled bitmap */
1327 gdk_draw_pixmap( m_window, m_penGC, bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
1328
1329 }
1330 else
1331 {
1332 /* No scaling and not a memory dc with a mask either */
1333
1334 /* copy including child window contents */
1335 gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
1336 gdk_window_copy_area( m_window, m_penGC, xx, yy,
1337 srcDC->GetWindow(),
1338 xsrc, ysrc, width, height );
1339 gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
1340 }
1341 }
1342
1343 SetLogicalFunction( old_logical_func );
1344 return TRUE;
1345 #endif
1346
1347 return FALSE;
1348 }
1349
1350 void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
1351 {
1352 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1353
1354 if (!m_window) return;
1355
1356 XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1357
1358 wxCHECK_RET( xfont, wxT("invalid font") );
1359
1360 x = XLOG2DEV(x);
1361 y = YLOG2DEV(y);
1362
1363 #if 0
1364 wxCoord width = gdk_string_width( font, text.mbc_str() );
1365 wxCoord height = font->ascent + font->descent;
1366
1367 if ( m_backgroundMode == wxSOLID )
1368 {
1369 gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
1370 gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
1371 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
1372 }
1373 #endif
1374
1375 XSetFont( (Display*) m_display, (GC) m_textGC, xfont->fid );
1376 #if !wxUSE_NANOX
1377 if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
1378 #endif
1379 {
1380 XDrawString( (Display*) m_display, (Window) m_window,
1381 (GC) m_textGC, x, y + XFontStructGetAscent(xfont), text.c_str(), text.Len() );
1382 }
1383
1384 #if 0
1385 if (m_font.GetUnderlined())
1386 {
1387 wxCoord ul_y = y + XFontStructGetAscent(font);
1388 if (font->descent > 0) ul_y++;
1389 gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
1390 }
1391
1392 width = wxCoord(width / m_scaleX);
1393 height = wxCoord(height / m_scaleY);
1394
1395 CalcBoundingBox (x + width, y + height);
1396 CalcBoundingBox (x, y);
1397 #endif
1398 }
1399
1400 void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
1401 {
1402 // later
1403 }
1404
1405 void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
1406 wxCoord *descent, wxCoord *externalLeading,
1407 wxFont *font ) const
1408 {
1409 wxCHECK_RET( Ok(), "invalid dc" );
1410
1411 wxFont fontToUse = m_font;
1412 if (font) fontToUse = *font;
1413
1414 wxCHECK_RET( fontToUse.Ok(), "invalid font" );
1415
1416 XFontStruct *xfont = (XFontStruct*) fontToUse.GetFontStruct( m_scaleY, m_display );
1417
1418 wxCHECK_RET( xfont, wxT("invalid font") );
1419
1420 int direction, ascent, descent2;
1421 XCharStruct overall;
1422
1423 XTextExtents( xfont, (char*) string.c_str(), string.Len(), &direction,
1424 &ascent, &descent2, &overall);
1425
1426 if (width)
1427 *width = (wxCoord)( overall.width / m_scaleX );
1428 if (height)
1429 *height = (wxCoord)((ascent + descent2) / m_scaleY );
1430 if (descent)
1431 *descent = (wxCoord)(descent2 / m_scaleY );
1432 if (externalLeading)
1433 *externalLeading = 0; // ??
1434 }
1435
1436 wxCoord wxWindowDC::GetCharWidth() const
1437 {
1438 wxCHECK_MSG( Ok(), 0, "invalid dc" );
1439
1440 wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
1441
1442 XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1443
1444 wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1445
1446 int direction, ascent, descent;
1447 XCharStruct overall;
1448
1449 XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1450
1451 return (wxCoord)(overall.width / m_scaleX);
1452 }
1453
1454 wxCoord wxWindowDC::GetCharHeight() const
1455 {
1456 wxCHECK_MSG( Ok(), 0, "invalid dc" );
1457
1458 wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
1459
1460 XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
1461
1462 wxCHECK_MSG( xfont, 0, wxT("invalid font") );
1463
1464 int direction, ascent, descent;
1465 XCharStruct overall;
1466
1467 XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
1468
1469 return (wxCoord)((ascent+descent) / m_scaleY);
1470 }
1471
1472 void wxWindowDC::Clear()
1473 {
1474 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1475
1476 if (!m_window) return;
1477
1478 /* - we either are a memory dc or have a window as the
1479 owner. anything else shouldn't happen.
1480 - we don't use gdk_window_clear() as we don't set
1481 the window's background colour anymore. it is too
1482 much pain to keep the DC's and the window's back-
1483 ground colour in synch. */
1484
1485 if (m_owner)
1486 {
1487 int width,height;
1488 m_owner->GetSize( &width, &height );
1489 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
1490 return;
1491 }
1492
1493 if (m_isMemDC)
1494 {
1495 int width,height;
1496 GetSize( &width, &height );
1497 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_bgGC, 0, 0, width, height );
1498 return;
1499 }
1500 }
1501
1502 void wxWindowDC::SetFont( const wxFont &font )
1503 {
1504 wxCHECK_RET( Ok(), "invalid dc" );
1505
1506 m_font = font;
1507 }
1508
1509 void wxWindowDC::SetPen( const wxPen &pen )
1510 {
1511 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1512
1513 if (m_pen == pen) return;
1514
1515 m_pen = pen;
1516
1517 if (!m_pen.Ok()) return;
1518
1519 if (!m_window) return;
1520
1521 int width = m_pen.GetWidth();
1522 if (width <= 0)
1523 {
1524 // CMB: if width is non-zero scale it with the dc
1525 width = 1;
1526 }
1527 else
1528 {
1529 // X doesn't allow different width in x and y and so we take
1530 // the average
1531 double w = 0.5 +
1532 ( fabs((double) XLOG2DEVREL(width)) +
1533 fabs((double) YLOG2DEVREL(width)) ) / 2.0;
1534 width = (int)w;
1535 }
1536
1537 static const wxX11Dash dotted[] = {1, 1};
1538 static const wxX11Dash short_dashed[] = {2, 2};
1539 static const wxX11Dash long_dashed[] = {2, 4};
1540 static const wxX11Dash dotted_dashed[] = {3, 3, 1, 3};
1541
1542 // We express dash pattern in pen width unit, so we are
1543 // independent of zoom factor and so on...
1544 int req_nb_dash;
1545 const wxX11Dash *req_dash;
1546
1547 int lineStyle = LineSolid;
1548 switch (m_pen.GetStyle())
1549 {
1550 case wxUSER_DASH:
1551 {
1552 lineStyle = LineOnOffDash;
1553 req_nb_dash = m_pen.GetDashCount();
1554 req_dash = (wxX11Dash*)m_pen.GetDash();
1555 break;
1556 }
1557 case wxDOT:
1558 {
1559 lineStyle = LineOnOffDash;
1560 req_nb_dash = 2;
1561 req_dash = dotted;
1562 break;
1563 }
1564 case wxLONG_DASH:
1565 {
1566 lineStyle = LineOnOffDash;
1567 req_nb_dash = 2;
1568 req_dash = long_dashed;
1569 break;
1570 }
1571 case wxSHORT_DASH:
1572 {
1573 lineStyle = LineOnOffDash;
1574 req_nb_dash = 2;
1575 req_dash = short_dashed;
1576 break;
1577 }
1578 case wxDOT_DASH:
1579 {
1580 // lineStyle = LineDoubleDash;
1581 lineStyle = LineOnOffDash;
1582 req_nb_dash = 4;
1583 req_dash = dotted_dashed;
1584 break;
1585 }
1586
1587 case wxTRANSPARENT:
1588 case wxSTIPPLE_MASK_OPAQUE:
1589 case wxSTIPPLE:
1590 case wxSOLID:
1591 default:
1592 {
1593 lineStyle = LineSolid;
1594 req_dash = (wxX11Dash*)NULL;
1595 req_nb_dash = 0;
1596 break;
1597 }
1598 }
1599
1600 int capStyle = CapRound;
1601 switch (m_pen.GetCap())
1602 {
1603 case wxCAP_PROJECTING: { capStyle = CapProjecting; break; }
1604 case wxCAP_BUTT: { capStyle = CapButt; break; }
1605 case wxCAP_ROUND:
1606 default:
1607 {
1608 if (width <= 1)
1609 {
1610 width = 0;
1611 capStyle = CapNotLast;
1612 }
1613 else
1614 {
1615 capStyle = CapRound;
1616 }
1617 break;
1618 }
1619 }
1620
1621 int joinStyle = JoinRound;
1622 switch (m_pen.GetJoin())
1623 {
1624 case wxJOIN_BEVEL: { joinStyle = JoinBevel; break; }
1625 case wxJOIN_MITER: { joinStyle = JoinMiter; break; }
1626 case wxJOIN_ROUND:
1627 default: { joinStyle = JoinRound; break; }
1628 }
1629
1630 XSetLineAttributes( (Display*) m_display, (GC) m_penGC, width, lineStyle, capStyle, joinStyle );
1631
1632 m_pen.GetColour().CalcPixel( m_cmap );
1633 XSetForeground( (Display*) m_display, (GC) m_penGC, m_pen.GetColour().GetPixel() );
1634 }
1635
1636 void wxWindowDC::SetBrush( const wxBrush &brush )
1637 {
1638 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1639
1640 if (m_brush == brush) return;
1641
1642 m_brush = brush;
1643
1644 if (!m_brush.Ok()) return;
1645
1646 if (!m_window) return;
1647
1648 m_brush.GetColour().CalcPixel( m_cmap );
1649 XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
1650
1651 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
1652
1653 if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
1654 {
1655 if (m_brush.GetStipple()->GetPixmap())
1656 {
1657 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillTiled );
1658 XSetTile( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetPixmap() );
1659 }
1660 else
1661 {
1662 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1663 XSetStipple( (Display*) m_display, (GC) m_brushGC, (Pixmap) m_brush.GetStipple()->GetBitmap() );
1664 }
1665 }
1666
1667 if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
1668 {
1669 XSetFillStyle( (Display*) m_display, (GC) m_textGC, FillOpaqueStippled );
1670 XSetStipple( (Display*) m_display, (GC) m_textGC, (Pixmap) m_brush.GetStipple()->GetMask()->GetBitmap() );
1671 }
1672
1673 if (IS_HATCH(m_brush.GetStyle()))
1674 {
1675 XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
1676 int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
1677 XSetStipple( (Display*) m_display, (GC) m_brushGC, hatches[num] );
1678 }
1679 }
1680
1681 void wxWindowDC::SetBackground( const wxBrush &brush )
1682 {
1683 /* CMB 21/7/98: Added SetBackground. Sets background brush
1684 * for Clear() and bg colour for shapes filled with cross-hatch brush */
1685
1686 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1687
1688 if (m_backgroundBrush == brush) return;
1689
1690 m_backgroundBrush = brush;
1691
1692 if (!m_backgroundBrush.Ok()) return;
1693
1694 if (!m_window) return;
1695
1696 m_backgroundBrush.GetColour().CalcPixel( m_cmap );
1697 XSetBackground( (Display*) m_display, (GC) m_brushGC, m_backgroundBrush.GetColour().GetPixel() );
1698 XSetBackground( (Display*) m_display, (GC) m_penGC, m_backgroundBrush.GetColour().GetPixel() );
1699 XSetBackground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
1700 XSetForeground( (Display*) m_display, (GC) m_bgGC, m_backgroundBrush.GetColour().GetPixel() );
1701
1702 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
1703
1704 if ((m_backgroundBrush.GetStyle() == wxSTIPPLE) && (m_backgroundBrush.GetStipple()->Ok()))
1705 {
1706 if (m_backgroundBrush.GetStipple()->GetPixmap())
1707 {
1708 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillTiled );
1709 XSetTile( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetPixmap() );
1710 }
1711 else
1712 {
1713 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
1714 XSetStipple( (Display*) m_display, (GC) m_bgGC, (Pixmap) m_backgroundBrush.GetStipple()->GetBitmap() );
1715 }
1716 }
1717
1718 if (IS_HATCH(m_backgroundBrush.GetStyle()))
1719 {
1720 XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
1721 int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
1722 XSetStipple( (Display*) m_display, (GC) m_bgGC, hatches[num] );
1723 }
1724 }
1725
1726 void wxWindowDC::SetLogicalFunction( int function )
1727 {
1728 wxCHECK_RET( Ok(), "invalid dc" );
1729
1730 int x_function;
1731
1732 if (m_logicalFunction == function)
1733 return;
1734
1735 // VZ: shouldn't this be a CHECK?
1736 if (!m_window)
1737 return;
1738
1739 switch (function)
1740 {
1741 case wxCLEAR:
1742 x_function = GXclear;
1743 break;
1744 case wxXOR:
1745 x_function = GXxor;
1746 break;
1747 case wxINVERT:
1748 x_function = GXinvert;
1749 break;
1750 case wxOR_REVERSE:
1751 x_function = GXorReverse;
1752 break;
1753 case wxAND_REVERSE:
1754 x_function = GXandReverse;
1755 break;
1756 case wxAND:
1757 x_function = GXand;
1758 break;
1759 case wxOR:
1760 x_function = GXor;
1761 break;
1762 case wxAND_INVERT:
1763 x_function = GXandInverted;
1764 break;
1765 case wxNO_OP:
1766 x_function = GXnoop;
1767 break;
1768 case wxNOR:
1769 x_function = GXnor;
1770 break;
1771 case wxEQUIV:
1772 x_function = GXequiv;
1773 break;
1774 case wxSRC_INVERT:
1775 x_function = GXcopyInverted;
1776 break;
1777 case wxOR_INVERT:
1778 x_function = GXorInverted;
1779 break;
1780 case wxNAND:
1781 x_function = GXnand;
1782 break;
1783 case wxSET:
1784 x_function = GXset;
1785 break;
1786 case wxCOPY:
1787 default:
1788 x_function = GXcopy;
1789 break;
1790 }
1791
1792 XSetFunction( (Display*) m_display, (GC) m_penGC, x_function );
1793 XSetFunction( (Display*) m_display, (GC) m_brushGC, x_function );
1794
1795 // to stay compatible with wxMSW, we don't apply ROPs to the text
1796 // operations (i.e. DrawText/DrawRotatedText).
1797 // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
1798 XSetFunction( (Display*) m_display, (GC) m_textGC, x_function );
1799
1800 m_logicalFunction = function;
1801 }
1802
1803 void wxWindowDC::SetTextForeground( const wxColour &col )
1804 {
1805 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1806
1807 // don't set m_textForegroundColour to an invalid colour as we'd crash
1808 // later then (we use m_textForegroundColour.GetColor() without checking
1809 // in a few places)
1810 if ( !col.Ok() || (m_textForegroundColour == col) )
1811 return;
1812
1813 m_textForegroundColour = col;
1814
1815 if (m_window)
1816 {
1817 m_textForegroundColour.CalcPixel( m_cmap );
1818 XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
1819 }
1820 }
1821
1822 void wxWindowDC::SetTextBackground( const wxColour &col )
1823 {
1824 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1825
1826 // same as above
1827 if ( !col.Ok() || (m_textBackgroundColour == col) )
1828 return;
1829
1830 m_textBackgroundColour = col;
1831
1832 if (m_window)
1833 {
1834 m_textBackgroundColour.CalcPixel( m_cmap );
1835 XSetBackground( (Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel() );
1836 }
1837 }
1838
1839 void wxWindowDC::SetBackgroundMode( int mode )
1840 {
1841 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1842
1843 m_backgroundMode = mode;
1844
1845 #if wxUSE_NANOX
1846 GrSetGCUseBackground((GC) m_textGC, mode == wxTRANSPARENT ? FALSE : TRUE);
1847 #endif
1848
1849 if (!m_window) return;
1850
1851 // CMB 21/7/98: fill style of cross-hatch brushes is affected by
1852 // transparent/solid background mode
1853
1854 if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
1855 {
1856 XSetFillStyle( (Display*) m_display, (GC) m_brushGC,
1857 (m_backgroundMode == wxTRANSPARENT) ? FillStippled : FillOpaqueStippled );
1858 }
1859 }
1860
1861 void wxWindowDC::SetPalette( const wxPalette& palette )
1862 {
1863 #if 0
1864 if (m_window)
1865 {
1866 if (palette.Ok())
1867 /* Use GetXColormap */
1868 XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1869 (Colormap) palette.GetXColormap());
1870 else
1871 /* Use wxGetMainColormap */
1872 XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
1873 (Colormap) wxTheApp->GetMainColormap(m_display));
1874 }
1875 #endif
1876 }
1877
1878 void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
1879 {
1880 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1881
1882 if (!m_window) return;
1883
1884 wxRect rect;
1885 rect.x = XLOG2DEV(x);
1886 rect.y = YLOG2DEV(y);
1887 rect.width = XLOG2DEVREL(width);
1888 rect.height = YLOG2DEVREL(height);
1889
1890 if (!m_currentClippingRegion.IsNull())
1891 m_currentClippingRegion.Intersect( rect );
1892 else
1893 m_currentClippingRegion.Union( rect );
1894
1895 #if USE_PAINT_REGION
1896 if (!m_paintClippingRegion.IsNull())
1897 m_currentClippingRegion.Intersect( m_paintClippingRegion );
1898 #endif
1899
1900 wxCoord xx, yy, ww, hh;
1901 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1902 wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1903
1904 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1905 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1906 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1907 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1908 }
1909
1910 void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
1911 {
1912 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1913
1914 if (region.Empty())
1915 {
1916 DestroyClippingRegion();
1917 return;
1918 }
1919
1920 if (!m_window) return;
1921
1922 if (!m_currentClippingRegion.IsNull())
1923 m_currentClippingRegion.Intersect( region );
1924 else
1925 m_currentClippingRegion.Union( region );
1926
1927 #if USE_PAINT_REGION
1928 if (!m_paintClippingRegion.IsNull())
1929 m_currentClippingRegion.Intersect( m_paintClippingRegion );
1930 #endif
1931
1932 wxCoord xx, yy, ww, hh;
1933 m_currentClippingRegion.GetBox( xx, yy, ww, hh );
1934 wxDC::DoSetClippingRegion( xx, yy, ww, hh );
1935
1936 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1937 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1938 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1939 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1940 }
1941
1942 void wxWindowDC::DestroyClippingRegion()
1943 {
1944 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1945
1946 wxDC::DestroyClippingRegion();
1947
1948 m_currentClippingRegion.Clear();
1949
1950 #if USE_PAINT_REGION
1951 if (!m_paintClippingRegion.IsEmpty())
1952 m_currentClippingRegion.Union( m_paintClippingRegion );
1953 #endif
1954
1955 if (!m_window) return;
1956
1957 if (m_currentClippingRegion.IsEmpty())
1958 {
1959 XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
1960 XSetClipMask( (Display*) m_display, (GC) m_brushGC, None );
1961 XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
1962 XSetClipMask( (Display*) m_display, (GC) m_bgGC, None );
1963 }
1964 else
1965 {
1966 XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
1967 XSetRegion( (Display*) m_display, (GC) m_brushGC, (Region) m_currentClippingRegion.GetX11Region() );
1968 XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
1969 XSetRegion( (Display*) m_display, (GC) m_bgGC, (Region) m_currentClippingRegion.GetX11Region() );
1970 }
1971 }
1972
1973 void wxWindowDC::Destroy()
1974 {
1975 if (m_penGC) wxFreePoolGC( (GC) m_penGC );
1976 m_penGC = NULL;
1977 if (m_brushGC) wxFreePoolGC( (GC) m_brushGC );
1978 m_brushGC = NULL;
1979 if (m_textGC) wxFreePoolGC( (GC) m_textGC );
1980 m_textGC = NULL;
1981 if (m_bgGC) wxFreePoolGC( (GC) m_bgGC );
1982 m_bgGC = NULL;
1983 }
1984
1985 void wxWindowDC::ComputeScaleAndOrigin()
1986 {
1987 /* CMB: copy scale to see if it changes */
1988 double origScaleX = m_scaleX;
1989 double origScaleY = m_scaleY;
1990
1991 wxDC::ComputeScaleAndOrigin();
1992
1993 /* CMB: if scale has changed call SetPen to recalulate the line width */
1994 if ((m_scaleX != origScaleX || m_scaleY != origScaleY) &&
1995 (m_pen.Ok()))
1996 {
1997 /* this is a bit artificial, but we need to force wxDC to think
1998 the pen has changed */
1999 wxPen pen = m_pen;
2000 m_pen = wxNullPen;
2001 SetPen( pen );
2002 }
2003 }
2004
2005 wxSize wxWindowDC::GetPPI() const
2006 {
2007 return wxSize(100, 100);
2008 }
2009
2010 int wxWindowDC::GetDepth() const
2011 {
2012 wxFAIL_MSG(wxT("not implemented"));
2013
2014 return -1;
2015 }
2016
2017 // ----------------------------------------------------------------------------
2018 // wxPaintDC
2019 // ----------------------------------------------------------------------------
2020
2021 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
2022
2023 wxPaintDC::wxPaintDC(wxWindow* win)
2024 : wxClientDC(win)
2025 {
2026 #if USE_PAINT_REGION
2027 if (!win->GetClipPaintRegion())
2028 return;
2029
2030 m_paintClippingRegion = win->GetUpdateRegion();
2031 Region region = (Region) m_paintClippingRegion.GetX11Region();
2032 if (region)
2033 {
2034 m_paintClippingRegion = win->GetUpdateRegion();
2035 Region region2 = (Region) m_paintClippingRegion.GetX11Region();
2036 if (region2)
2037 {
2038 m_currentClippingRegion.Union( m_paintClippingRegion );
2039
2040 XSetRegion( (Display*) m_display, (GC) m_penGC, region2 );
2041 XSetRegion( (Display*) m_display, (GC) m_brushGC, region2 );
2042 XSetRegion( (Display*) m_display, (GC) m_textGC, region2 );
2043 XSetRegion( (Display*) m_display, (GC) m_bgGC, region2 );
2044 }
2045 }
2046 #endif // USE_PAINT_REGION
2047 }
2048
2049 //-----------------------------------------------------------------------------
2050 // wxClientDC
2051 //-----------------------------------------------------------------------------
2052
2053 IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
2054
2055 wxClientDC::wxClientDC( wxWindow *win )
2056 : wxWindowDC( win )
2057 {
2058 wxCHECK_RET( win, _T("NULL window in wxClientDC::wxClientDC") );
2059
2060 #ifdef __WXUNIVERSAL__
2061 wxPoint ptOrigin = win->GetClientAreaOrigin();
2062 SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
2063 wxSize size = win->GetClientSize();
2064 SetClippingRegion(wxPoint(0, 0), size);
2065 #endif // __WXUNIVERSAL__
2066 }
2067
2068 void wxClientDC::DoGetSize(int *width, int *height) const
2069 {
2070 wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
2071
2072 m_owner->GetClientSize( width, height );
2073 }
2074
2075 // ----------------------------------------------------------------------------
2076 // wxDCModule
2077 // ----------------------------------------------------------------------------
2078
2079 class wxDCModule : public wxModule
2080 {
2081 public:
2082 bool OnInit();
2083 void OnExit();
2084
2085 private:
2086 DECLARE_DYNAMIC_CLASS(wxDCModule)
2087 };
2088
2089 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2090
2091 bool wxDCModule::OnInit()
2092 {
2093 wxInitGCPool();
2094 return TRUE;
2095 }
2096
2097 void wxDCModule::OnExit()
2098 {
2099 wxCleanUpGCPool();
2100 }
wxWidgets (Impactor)