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


1d46f8b455f0578905daa6217be726f2f337d5d1
[wxWidgets.git] / src / gtk1 / dcclient.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: dcclient.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // RCS-ID: $Id$
6 // Copyright: (c) 1998 Robert Roebling, Markus Holzem, Chris Breeze
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #ifdef __GNUG__
11 #pragma implementation "dcclient.h"
12 #endif
13
14 #include "wx/dcclient.h"
15 #include "wx/dcmemory.h"
16
17 //-----------------------------------------------------------------------------
18 // local data
19 //-----------------------------------------------------------------------------
20
21 #include "bdiag.xbm"
22 #include "fdiag.xbm"
23 #include "cdiag.xbm"
24 #include "horiz.xbm"
25 #include "verti.xbm"
26 #include "cross.xbm"
27 #define num_hatches 6
28
29 static GdkPixmap *hatches[num_hatches];
30 static GdkPixmap **hatch_bitmap = (GdkPixmap **) NULL;
31
32 //-----------------------------------------------------------------------------
33 // constants
34 //-----------------------------------------------------------------------------
35
36 #define RAD2DEG 57.2957795131
37
38 //-----------------------------------------------------------------------------
39 // temporary implementation of the missing GDK function
40 //-----------------------------------------------------------------------------
41 #include "gdk/gdkprivate.h"
42 void gdk_draw_bitmap (GdkDrawable *drawable,
43 GdkGC *gc,
44 GdkDrawable *src,
45 gint xsrc,
46 gint ysrc,
47 gint xdest,
48 gint ydest,
49 gint width,
50 gint height)
51 {
52 GdkWindowPrivate *drawable_private;
53 GdkWindowPrivate *src_private;
54 GdkGCPrivate *gc_private;
55
56 g_return_if_fail (drawable != NULL);
57 g_return_if_fail (src != NULL);
58 g_return_if_fail (gc != NULL);
59
60 drawable_private = (GdkWindowPrivate*) drawable;
61 src_private = (GdkWindowPrivate*) src;
62 if (drawable_private->destroyed || src_private->destroyed)
63 return;
64 gc_private = (GdkGCPrivate*) gc;
65
66 if (width == -1)
67 width = src_private->width;
68 if (height == -1)
69 height = src_private->height;
70
71 XCopyPlane (drawable_private->xdisplay,
72 src_private->xwindow,
73 drawable_private->xwindow,
74 gc_private->xgc,
75 xsrc, ysrc,
76 width, height,
77 xdest, ydest,
78 1);
79 }
80
81 //-----------------------------------------------------------------------------
82 // wxPaintDC
83 //-----------------------------------------------------------------------------
84
85 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC,wxDC)
86
87 wxPaintDC::wxPaintDC(void)
88 {
89 m_penGC = (GdkGC *) NULL;
90 m_brushGC = (GdkGC *) NULL;
91 m_textGC = (GdkGC *) NULL;
92 m_bgGC = (GdkGC *) NULL;
93 m_cmap = (GdkColormap *) NULL;
94 m_isMemDC = FALSE;
95 }
96
97 wxPaintDC::wxPaintDC( wxWindow *window )
98 {
99 m_penGC = (GdkGC *) NULL;
100 m_brushGC = (GdkGC *) NULL;
101 m_textGC = (GdkGC *) NULL;
102 m_bgGC = (GdkGC *) NULL;
103 m_cmap = (GdkColormap *) NULL;
104
105 if (!window) return;
106 GtkWidget *widget = window->m_wxwindow;
107 if (!widget) return;
108 m_window = widget->window;
109 if (!m_window) return;
110 if (window->m_wxwindow)
111 m_cmap = gtk_widget_get_colormap( window->m_wxwindow );
112 else
113 m_cmap = gtk_widget_get_colormap( window->m_widget );
114
115 m_isMemDC = FALSE;
116
117 SetUpDC();
118 }
119
120 wxPaintDC::~wxPaintDC(void)
121 {
122 }
123
124 void wxPaintDC::FloodFill( long WXUNUSED(x1), long WXUNUSED(y1),
125 wxColour *WXUNUSED(col), int WXUNUSED(style) )
126 {
127 wxFAIL_MSG( "wxPaintDC::FloodFill not implemented" );
128 }
129
130 bool wxPaintDC::GetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const
131 {
132 wxFAIL_MSG( "wxPaintDC::GetPixel not implemented" );
133 return FALSE;
134 }
135
136 void wxPaintDC::DrawLine( long x1, long y1, long x2, long y2 )
137 {
138 if (!Ok()) return;
139
140 if (m_pen.GetStyle() != wxTRANSPARENT)
141 {
142 gdk_draw_line( m_window, m_penGC,
143 XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
144 }
145 }
146
147 void wxPaintDC::CrossHair( long x, long y )
148 {
149 if (!Ok()) return;
150
151 if (m_pen.GetStyle() != wxTRANSPARENT)
152 {
153 int w = 0;
154 int h = 0;
155 GetSize( &w, &h );
156 long xx = XLOG2DEV(x);
157 long yy = YLOG2DEV(y);
158 gdk_draw_line( m_window, m_penGC,
159 0, yy, XLOG2DEVREL(w), yy );
160 gdk_draw_line( m_window, m_penGC,
161 xx, 0, xx, YLOG2DEVREL(h) );
162 }
163 }
164
165 void wxPaintDC::DrawArc( long x1, long y1, long x2, long y2, double xc, double yc )
166 {
167 if (!Ok()) return;
168
169 long xx1 = XLOG2DEV(x1);
170 long yy1 = YLOG2DEV(y1);
171 long xx2 = XLOG2DEV(x2);
172 long yy2 = YLOG2DEV(y2);
173 long xxc = XLOG2DEV((long)xc);
174 long yyc = YLOG2DEV((long)yc);
175 double dx = xx1 - xxc;
176 double dy = yy1 - yyc;
177 double radius = sqrt(dx*dx+dy*dy);
178 long r = (long)radius;
179 double radius1, radius2;
180
181 if (xx1 == xx2 && yy1 == yy2)
182 {
183 radius1 = 0.0;
184 radius2 = 360.0;
185 }
186 else
187 if (radius == 0.0)
188 {
189 radius1 = radius2 = 0.0;
190 }
191 else
192 {
193 radius1 = (xx1 - xxc == 0) ?
194 (yy1 - yyc < 0) ? 90.0 : -90.0 :
195 -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
196 radius2 = (xx2 - xxc == 0) ?
197 (yy2 - yyc < 0) ? 90.0 : -90.0 :
198 -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
199 }
200 long alpha1 = long(radius1 * 64.0);
201 long alpha2 = long((radius2 - radius1) * 64.0);
202 while (alpha2 <= 0) alpha2 += 360*64;
203 while (alpha1 > 360*64) alpha1 -= 360*64;
204
205 if (m_brush.GetStyle() != wxTRANSPARENT)
206 gdk_draw_arc( m_window, m_brushGC, TRUE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
207
208 if (m_pen.GetStyle() != wxTRANSPARENT)
209 gdk_draw_arc( m_window, m_penGC, FALSE, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
210
211 }
212
213 void wxPaintDC::DrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
214 {
215 if (!Ok()) return;
216
217 long xx = XLOG2DEV(x);
218 long yy = YLOG2DEV(y);
219 long ww = m_signX * XLOG2DEVREL(width);
220 long hh = m_signY * YLOG2DEVREL(height);
221
222 // CMB: handle -ve width and/or height
223 if (ww < 0) { ww = -ww; xx = xx - ww; }
224 if (hh < 0) { hh = -hh; yy = yy - hh; }
225
226 long start = long(sa * 64.0);
227 long end = long(ea * 64.0);
228 if (m_brush.GetStyle() != wxTRANSPARENT)
229 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, start, end );
230
231 if (m_pen.GetStyle() != wxTRANSPARENT)
232 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, start, end );
233 }
234
235 void wxPaintDC::DrawPoint( long x, long y )
236 {
237 if (!Ok()) return;
238
239 if (m_pen.GetStyle() != wxTRANSPARENT)
240 gdk_draw_point( m_window, m_penGC, XLOG2DEV(x), YLOG2DEV(y) );
241 }
242
243 void wxPaintDC::DrawLines( int n, wxPoint points[], long xoffset, long yoffset )
244 {
245 if (!Ok()) return;
246
247 if (m_pen.GetStyle() == wxTRANSPARENT) return;
248
249 for (int i = 0; i < n-1; i++)
250 {
251 long x1 = XLOG2DEV(points[i].x + xoffset);
252 long x2 = XLOG2DEV(points[i+1].x + xoffset);
253 long y1 = YLOG2DEV(points[i].y + yoffset); // oh, what a waste
254 long y2 = YLOG2DEV(points[i+1].y + yoffset);
255 gdk_draw_line( m_window, m_penGC, x1, y1, x2, y2 );
256 }
257 }
258
259 void wxPaintDC::DrawLines( wxList *points, long xoffset, long yoffset )
260 {
261 if (!Ok()) return;
262
263 if (m_pen.GetStyle() == wxTRANSPARENT) return;
264
265 wxNode *node = points->First();
266 while (node->Next())
267 {
268 wxPoint *point = (wxPoint*)node->Data();
269 wxPoint *npoint = (wxPoint*)node->Next()->Data();
270 long x1 = XLOG2DEV(point->x + xoffset);
271 long x2 = XLOG2DEV(npoint->x + xoffset);
272 long y1 = YLOG2DEV(point->y + yoffset); // and again...
273 long y2 = YLOG2DEV(npoint->y + yoffset);
274 gdk_draw_line( m_window, m_penGC, x1, y1, x2, y2 );
275 node = node->Next();
276 }
277 }
278
279 void wxPaintDC::DrawPolygon( int n, wxPoint points[], long xoffset, long yoffset, int WXUNUSED(fillStyle) )
280 {
281 if (!Ok()) return;
282
283 if (!n) return; // Nothing to draw
284 GdkPoint *gdkpoints = new GdkPoint[n+1];
285 int i;
286 for (i = 0 ; i < n ; i++)
287 {
288 gdkpoints[i].x = XLOG2DEV(points[i].x + xoffset);
289 gdkpoints[i].y = YLOG2DEV(points[i].y + yoffset);
290 }
291 if (m_brush.GetStyle() != wxTRANSPARENT)
292 gdk_draw_polygon (m_window, m_brushGC, TRUE, gdkpoints, n);
293 // To do: Fillstyle
294 if (m_pen.GetStyle() != wxTRANSPARENT)
295 for (i = 0 ; i < n ; i++)
296 gdk_draw_line( m_window, m_penGC,
297 gdkpoints[i%n].x,
298 gdkpoints[i%n].y,
299 gdkpoints[(i+1)%n].x,
300 gdkpoints[(i+1)%n].y);
301 delete[] gdkpoints;
302 }
303
304 void wxPaintDC::DrawPolygon( wxList *lines, long xoffset, long yoffset, int WXUNUSED(fillStyle))
305 {
306 if (!Ok()) return;
307
308 int n = lines->Number();
309 GdkPoint *gdkpoints = new GdkPoint[n];
310 wxNode *node = lines->First();
311 int cnt=0;
312 while (node)
313 {
314 wxPoint *p = (wxPoint *) node->Data();
315 gdkpoints[cnt].x = XLOG2DEV(p->x + xoffset);
316 gdkpoints[cnt].y = YLOG2DEV(p->y + yoffset);
317 node = node->Next();
318 cnt++;
319 }
320 if (m_brush.GetStyle() != wxTRANSPARENT)
321 gdk_draw_polygon (m_window, m_brushGC, TRUE, gdkpoints, n);
322 // To do: Fillstyle
323 if (m_pen.GetStyle() != wxTRANSPARENT)
324 {
325 int i;
326 for (i = 0 ; i < n ; i++)
327 gdk_draw_line( m_window, m_penGC,
328 gdkpoints[i%n].x,
329 gdkpoints[i%n].y,
330 gdkpoints[(i+1)%n].x,
331 gdkpoints[(i+1)%n].y);
332 }
333 delete[] gdkpoints;
334 }
335
336 void wxPaintDC::DrawRectangle( long x, long y, long width, long height )
337 {
338 if (!Ok()) return;
339
340 long xx = XLOG2DEV(x);
341 long yy = YLOG2DEV(y);
342 long ww = m_signX * XLOG2DEVREL(width);
343 long hh = m_signY * YLOG2DEVREL(height);
344
345 // CMB: draw nothing if transformed w or h is 0
346 if (ww == 0 || hh == 0) return;
347
348 // CMB: handle -ve width and/or height
349 if (ww < 0) { ww = -ww; xx = xx - ww; }
350 if (hh < 0) { hh = -hh; yy = yy - hh; }
351
352 if (m_brush.GetStyle() != wxTRANSPARENT)
353 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy, ww, hh );
354
355 if (m_pen.GetStyle() != wxTRANSPARENT)
356 gdk_draw_rectangle( m_window, m_penGC, FALSE, xx, yy, ww-1, hh-1 );
357 }
358
359 void wxPaintDC::DrawRoundedRectangle( long x, long y, long width, long height, double radius )
360 {
361 if (!Ok()) return;
362
363 if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
364
365 long xx = XLOG2DEV(x);
366 long yy = YLOG2DEV(y);
367 long ww = m_signX * XLOG2DEVREL(width);
368 long hh = m_signY * YLOG2DEVREL(height);
369 long rr = XLOG2DEVREL((long)radius);
370
371 // CMB: handle -ve width and/or height
372 if (ww < 0) { ww = -ww; xx = xx - ww; }
373 if (hh < 0) { hh = -hh; yy = yy - hh; }
374
375 // CMB: if radius is zero use DrawRectangle() instead to avoid
376 // X drawing errors with small radii
377 if (rr == 0)
378 {
379 DrawRectangle( x, y, width, height );
380 return;
381 }
382
383 // CMB: draw nothing if transformed w or h is 0
384 if (ww == 0 || hh == 0) return;
385
386 // CMB: adjust size if outline is drawn otherwise the result is
387 // 1 pixel too wide and high
388 if (m_pen.GetStyle() != wxTRANSPARENT)
389 {
390 ww--;
391 hh--;
392 }
393
394 // CMB: ensure dd is not larger than rectangle otherwise we
395 // get an hour glass shape
396 long dd = 2 * rr;
397 if (dd > ww) dd = ww;
398 if (dd > hh) dd = hh;
399 rr = dd / 2;
400
401 if (m_brush.GetStyle() != wxTRANSPARENT)
402 {
403 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx+rr, yy, ww-dd+1, hh );
404 gdk_draw_rectangle( m_window, m_brushGC, TRUE, xx, yy+rr, ww, hh-dd+1 );
405 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, dd, dd, 90*64, 90*64 );
406 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
407 gdk_draw_arc( m_window, m_brushGC, TRUE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
408 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
409 }
410
411 if (m_pen.GetStyle() != wxTRANSPARENT)
412 {
413 gdk_draw_line( m_window, m_penGC, xx+rr, yy, xx+ww-rr, yy );
414 gdk_draw_line( m_window, m_penGC, xx+rr, yy+hh, xx+ww-rr, yy+hh );
415 gdk_draw_line( m_window, m_penGC, xx, yy+rr, xx, yy+hh-rr );
416 gdk_draw_line( m_window, m_penGC, xx+ww, yy+rr, xx+ww, yy+hh-rr );
417 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, dd, dd, 90*64, 90*64 );
418 gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy, dd, dd, 0, 90*64 );
419 gdk_draw_arc( m_window, m_penGC, FALSE, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
420 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
421 }
422 }
423
424 void wxPaintDC::DrawEllipse( long x, long y, long width, long height )
425 {
426 if (!Ok()) return;
427
428 long xx = XLOG2DEV(x);
429 long yy = YLOG2DEV(y);
430 long ww = m_signX * XLOG2DEVREL(width);
431 long hh = m_signY * YLOG2DEVREL(height);
432
433 // CMB: handle -ve width and/or height
434 if (ww < 0) { ww = -ww; xx = xx - ww; }
435 if (hh < 0) { hh = -hh; yy = yy - hh; }
436
437 if (m_brush.GetStyle() != wxTRANSPARENT)
438 gdk_draw_arc( m_window, m_brushGC, TRUE, xx, yy, ww, hh, 0, 360*64 );
439
440 if (m_pen.GetStyle() != wxTRANSPARENT)
441 gdk_draw_arc( m_window, m_penGC, FALSE, xx, yy, ww, hh, 0, 360*64 );
442 }
443
444 bool wxPaintDC::CanDrawBitmap(void) const
445 {
446 return TRUE;
447 }
448
449 void wxPaintDC::DrawIcon( const wxIcon &icon, long x, long y, bool useMask )
450 {
451 if (!Ok()) return;
452
453 if (!icon.Ok()) return;
454
455 int xx = XLOG2DEV(x);
456 int yy = YLOG2DEV(y);
457
458 GdkBitmap *mask = (GdkBitmap *) NULL;
459 if (icon.GetMask()) mask = icon.GetMask()->GetBitmap();
460
461 if (useMask && mask)
462 {
463 gdk_gc_set_clip_mask( m_penGC, mask );
464 gdk_gc_set_clip_origin( m_penGC, xx, yy );
465 }
466
467 GdkPixmap *pm = icon.GetPixmap();
468 gdk_draw_pixmap( m_window, m_penGC, pm, 0, 0, xx, yy, -1, -1 );
469
470 if (useMask && mask)
471 {
472 gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
473 gdk_gc_set_clip_origin( m_penGC, 0, 0 );
474 }
475 }
476
477 bool wxPaintDC::Blit( long xdest, long ydest, long width, long height,
478 wxDC *source, long xsrc, long ysrc, int WXUNUSED(logical_func), bool WXUNUSED(useMask) )
479 {
480 if (!Ok()) return FALSE;
481
482 wxClientDC *csrc = (wxClientDC*)source;
483
484 if (csrc->m_isMemDC)
485 {
486 wxMemoryDC* srcDC = (wxMemoryDC*)source;
487 GdkBitmap* bmap = srcDC->m_selected.GetBitmap();
488 if (bmap)
489 {
490 gdk_draw_bitmap( m_window, m_textGC, bmap,
491 source->DeviceToLogicalX(xsrc),
492 source->DeviceToLogicalY(ysrc),
493 XLOG2DEV(xdest),
494 YLOG2DEV(ydest),
495 source->DeviceToLogicalXRel(width),
496 source->DeviceToLogicalYRel(height) );
497 return TRUE;
498 }
499 }
500
501 gdk_window_copy_area ( m_window, m_penGC,
502 XLOG2DEV(xdest), YLOG2DEV(ydest),
503 csrc->GetWindow(),
504 source->DeviceToLogicalX(xsrc), source->DeviceToLogicalY(ysrc),
505 source->DeviceToLogicalXRel(width), source->DeviceToLogicalYRel(height) );
506
507 /*
508 gdk_window_copy_area ( m_window, m_penGC,
509 XLOG2DEV(xdest), YLOG2DEV(ydest),
510 csrc->GetWindow(),
511 xsrc, ysrc,
512 width, height );
513 */
514
515 return TRUE;
516 }
517
518 void wxPaintDC::DrawText( const wxString &text, long x, long y, bool WXUNUSED(use16) )
519 {
520 if (!Ok()) return;
521
522 GdkFont *font = m_font.GetInternalFont( m_scaleY );
523
524 x = XLOG2DEV(x);
525 y = YLOG2DEV(y);
526
527 // CMB 21/5/98: draw text background if mode is wxSOLID
528 if (m_backgroundMode == wxSOLID)
529 {
530 long width = gdk_string_width( font, text );
531 long height = font->ascent + font->descent;
532 gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
533 gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
534 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
535 }
536 gdk_draw_string( m_window, font, m_textGC, x, y + font->ascent, text );
537
538 // CMB 17/7/98: simple underline: ignores scaling and underlying
539 // X font's XA_UNDERLINE_POSITION and XA_UNDERLINE_THICKNESS
540 // properties (see wxXt implementation)
541 if (m_font.GetUnderlined())
542 {
543 long width = gdk_string_width( font, text );
544 long ul_y = y + font->ascent;
545 if (font->descent > 0) ul_y++;
546 gdk_draw_line( m_window, m_textGC, x, ul_y, x + width, ul_y);
547 }
548 }
549
550 bool wxPaintDC::CanGetTextExtent(void) const
551 {
552 return TRUE;
553 }
554
555 void wxPaintDC::GetTextExtent( const wxString &string, long *width, long *height,
556 long *descent, long *externalLeading,
557 wxFont *theFont, bool WXUNUSED(use16) )
558 {
559 if (!Ok()) return;
560
561 wxFont fontToUse = m_font;
562 if (theFont) fontToUse = *theFont;
563
564 GdkFont *font = fontToUse.GetInternalFont( m_scaleY );
565 if (width) (*width) = long(gdk_string_width( font, string ) / m_scaleX);
566 if (height) (*height) = long((font->ascent + font->descent) / m_scaleY);
567 if (descent) (*descent) = long(font->descent / m_scaleY);
568 if (externalLeading) (*externalLeading) = 0; // ??
569 }
570
571 long wxPaintDC::GetCharWidth(void)
572 {
573 if (!Ok()) return 0;
574
575 GdkFont *font = m_font.GetInternalFont( m_scaleY );
576 return long(gdk_string_width( font, "H" ) / m_scaleX);
577 }
578
579 long wxPaintDC::GetCharHeight(void)
580 {
581 if (!Ok()) return 0;
582
583 GdkFont *font = m_font.GetInternalFont( m_scaleY );
584 return long((font->ascent + font->descent) / m_scaleY);
585 }
586
587 void wxPaintDC::Clear(void)
588 {
589 if (!Ok()) return;
590
591 if (!m_isMemDC)
592 {
593 gdk_window_clear( m_window );
594 }
595 else
596 {
597 int width = 0;
598 int height = 0;
599 GetSize( &width, &height );
600 gdk_draw_rectangle( m_window, m_bgGC, TRUE, 0, 0, width, height );
601 }
602 }
603
604 void wxPaintDC::SetFont( const wxFont &font )
605 {
606 if (!Ok()) return;
607
608 m_font = font;
609 }
610
611 void wxPaintDC::SetPen( const wxPen &pen )
612 {
613 if (!Ok()) return;
614
615 if (m_pen == pen) return;
616
617 m_pen = pen;
618
619 if (!m_pen.Ok()) return;
620
621 gint width = m_pen.GetWidth();
622 // CMB: if width is non-zero scale it with the dc
623 if (width <= 0)
624 {
625 width = 1;
626 }
627 else
628 {
629 // X doesn't allow different width in x and y and so we take
630 // the average
631 double w = 0.5 + (abs(XLOG2DEVREL(width)) + abs(YLOG2DEVREL(width))) / 2.0;
632 width = (int)w;
633 }
634
635 GdkLineStyle lineStyle = GDK_LINE_SOLID;
636 switch (m_pen.GetStyle())
637 {
638 case wxSOLID: { lineStyle = GDK_LINE_SOLID; break; }
639 case wxDOT: { lineStyle = GDK_LINE_ON_OFF_DASH; break; }
640 case wxLONG_DASH: { lineStyle = GDK_LINE_ON_OFF_DASH; break; }
641 case wxSHORT_DASH: { lineStyle = GDK_LINE_ON_OFF_DASH; break; }
642 case wxDOT_DASH: { lineStyle = GDK_LINE_DOUBLE_DASH; break; }
643 }
644
645 GdkCapStyle capStyle = GDK_CAP_ROUND;
646 switch (m_pen.GetCap())
647 {
648 case wxCAP_ROUND: { capStyle = (width <= 1) ? GDK_CAP_NOT_LAST : GDK_CAP_ROUND; break; }
649 case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; }
650 case wxCAP_BUTT: { capStyle = GDK_CAP_BUTT; break; }
651 }
652
653 GdkJoinStyle joinStyle = GDK_JOIN_ROUND;
654 switch (m_pen.GetJoin())
655 {
656 case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; }
657 case wxJOIN_ROUND: { joinStyle = GDK_JOIN_ROUND; break; }
658 case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; }
659 }
660
661 gdk_gc_set_line_attributes( m_penGC, width, lineStyle, capStyle, joinStyle );
662
663 m_pen.GetColour().CalcPixel( m_cmap );
664 gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
665 }
666
667 void wxPaintDC::SetBrush( const wxBrush &brush )
668 {
669 if (!Ok()) return;
670
671 if (m_brush == brush) return;
672
673 m_brush = brush;
674
675 if (!m_brush.Ok()) return;
676
677 m_brush.GetColour().CalcPixel( m_cmap );
678 gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
679
680 GdkFill fillStyle = GDK_SOLID;
681 switch (m_brush.GetStyle())
682 {
683 case wxSOLID:
684 case wxTRANSPARENT:
685 break;
686 default:
687 fillStyle = GDK_STIPPLED;
688 }
689
690 gdk_gc_set_fill( m_brushGC, fillStyle );
691
692 if (m_brush.GetStyle() == wxSTIPPLE)
693 {
694 gdk_gc_set_stipple( m_brushGC, m_brush.GetStipple()->GetPixmap() );
695 }
696
697 if (IS_HATCH(m_brush.GetStyle()))
698 {
699 int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
700 gdk_gc_set_stipple( m_brushGC, hatches[num] );
701 }
702 }
703
704 // CMB 21/7/98: Added SetBackground. Sets background brush
705 // for Clear() and bg colour for shapes filled with cross-hatch brush
706 void wxPaintDC::SetBackground( const wxBrush &brush )
707 {
708 if (!Ok()) return;
709
710 if (m_backgroundBrush == brush) return;
711
712 m_backgroundBrush = brush;
713
714 if (!m_backgroundBrush.Ok()) return;
715
716 m_backgroundBrush.GetColour().CalcPixel( m_cmap );
717 gdk_gc_set_background( m_brushGC, m_backgroundBrush.GetColour().GetColor() );
718 gdk_gc_set_foreground( m_bgGC, m_backgroundBrush.GetColour().GetColor() );
719
720 GdkFill fillStyle = GDK_SOLID;
721 switch (m_backgroundBrush.GetStyle())
722 {
723 case wxSOLID:
724 case wxTRANSPARENT:
725 break;
726 default:
727 fillStyle = GDK_STIPPLED;
728 }
729
730 gdk_gc_set_fill( m_bgGC, fillStyle );
731
732 if (m_backgroundBrush.GetStyle() == wxSTIPPLE)
733 {
734 gdk_gc_set_stipple( m_bgGC, m_backgroundBrush.GetStipple()->GetPixmap() );
735 }
736
737 if (IS_HATCH(m_backgroundBrush.GetStyle()))
738 {
739 int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
740 gdk_gc_set_stipple( m_bgGC, hatches[num] );
741 }
742 }
743
744 void wxPaintDC::SetLogicalFunction( int function )
745 {
746 if (m_logicalFunction == function) return;
747 GdkFunction mode = GDK_COPY;
748 switch (function)
749 {
750 case wxXOR: mode = GDK_INVERT; break;
751 case wxINVERT: mode = GDK_INVERT; break;
752 default: break;
753 }
754 m_logicalFunction = function;
755 gdk_gc_set_function( m_penGC, mode );
756 gdk_gc_set_function( m_brushGC, mode );
757 }
758
759 void wxPaintDC::SetTextForeground( const wxColour &col )
760 {
761 if (!Ok()) return;
762
763 if (m_textForegroundColour == col) return;
764
765 m_textForegroundColour = col;
766 if (!m_textForegroundColour.Ok()) return;
767
768 m_textForegroundColour.CalcPixel( m_cmap );
769 gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
770 }
771
772 void wxPaintDC::SetTextBackground( const wxColour &col )
773 {
774 if (!Ok()) return;
775
776 if (m_textBackgroundColour == col) return;
777
778 m_textBackgroundColour = col;
779 if (!m_textBackgroundColour.Ok()) return;
780
781 m_textBackgroundColour.CalcPixel( m_cmap );
782 gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
783 }
784
785 void wxPaintDC::SetBackgroundMode( int mode )
786 {
787 m_backgroundMode = mode;
788
789 // CMB 21/7/98: fill style of cross-hatch brushes is affected by
790 // transparent/solid background mode
791 if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
792 {
793 gdk_gc_set_fill( m_brushGC,
794 (m_backgroundMode == wxTRANSPARENT) ? GDK_STIPPLED : GDK_OPAQUE_STIPPLED);
795 }
796 }
797
798 void wxPaintDC::SetPalette( const wxPalette& WXUNUSED(palette) )
799 {
800 }
801
802 void wxPaintDC::SetClippingRegion( long x, long y, long width, long height )
803 {
804 wxDC::SetClippingRegion( x, y, width, height );
805
806 GdkRectangle rect;
807 rect.x = XLOG2DEV(x);
808 rect.y = YLOG2DEV(y);
809 rect.width = XLOG2DEVREL(width);
810 rect.height = YLOG2DEVREL(height);
811 gdk_gc_set_clip_rectangle( m_penGC, &rect );
812 gdk_gc_set_clip_rectangle( m_brushGC, &rect );
813 gdk_gc_set_clip_rectangle( m_textGC, &rect );
814 gdk_gc_set_clip_rectangle( m_bgGC, &rect );
815
816 }
817
818 void wxPaintDC::DestroyClippingRegion(void)
819 {
820 wxDC::DestroyClippingRegion();
821
822 gdk_gc_set_clip_rectangle( m_penGC, (GdkRectangle *) NULL );
823 gdk_gc_set_clip_rectangle( m_brushGC, (GdkRectangle *) NULL );
824 gdk_gc_set_clip_rectangle( m_textGC, (GdkRectangle *) NULL );
825 gdk_gc_set_clip_rectangle( m_bgGC, (GdkRectangle *) NULL );
826 }
827
828 void wxPaintDC::SetUpDC(void)
829 {
830 m_ok = TRUE;
831 m_logicalFunction = wxCOPY;
832 if (m_penGC) gdk_gc_unref( m_penGC );
833 m_penGC = gdk_gc_new( m_window );
834 if (m_brushGC) gdk_gc_unref( m_brushGC );
835 m_brushGC = gdk_gc_new( m_window );
836 if (m_textGC) gdk_gc_unref( m_textGC );
837 m_textGC = gdk_gc_new( m_window );
838 if (m_bgGC) gdk_gc_unref( m_bgGC );
839 m_bgGC = gdk_gc_new( m_window );
840 SetTextForeground( m_textForegroundColour );
841 SetTextBackground( m_textBackgroundColour );
842 SetPen( m_pen );
843 SetFont( m_font );
844 SetBrush( m_brush );
845
846 gdk_gc_set_background( m_penGC, wxWHITE->GetColor() );
847
848 if (!hatch_bitmap)
849 {
850 hatch_bitmap = hatches;
851 hatch_bitmap[0] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, bdiag_bits, bdiag_width, bdiag_height );
852 hatch_bitmap[1] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cdiag_bits, cdiag_width, cdiag_height );
853 hatch_bitmap[2] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, fdiag_bits, fdiag_width, fdiag_height );
854 hatch_bitmap[3] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, cross_bits, cross_width, cross_height );
855 hatch_bitmap[4] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, horiz_bits, horiz_width, horiz_height );
856 hatch_bitmap[5] = gdk_bitmap_create_from_data( (GdkWindow *) NULL, verti_bits, verti_width, verti_height );
857 }
858 }
859
860 GdkWindow *wxPaintDC::GetWindow(void)
861 {
862 return m_window;
863 }
864
865 // ----------------------------------- spline code ----------------------------------------
866
867 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
868 double a3, double b3, double a4, double b4);
869 void wx_clear_stack(void);
870 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
871 double *y3, double *x4, double *y4);
872 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
873 double x4, double y4);
874 static bool wx_spline_add_point(double x, double y);
875 static void wx_spline_draw_point_array(wxDC *dc);
876
877 wxList wx_spline_point_list;
878
879 #define half(z1, z2) ((z1+z2)/2.0)
880 #define THRESHOLD 5
881
882 /* iterative version */
883
884 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
885 double b4)
886 {
887 register double xmid, ymid;
888 double x1, y1, x2, y2, x3, y3, x4, y4;
889
890 wx_clear_stack();
891 wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
892
893 while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
894 xmid = (double)half(x2, x3);
895 ymid = (double)half(y2, y3);
896 if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
897 fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
898 wx_spline_add_point( x1, y1 );
899 wx_spline_add_point( xmid, ymid );
900 } else {
901 wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
902 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
903 wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
904 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
905 }
906 }
907 }
908
909 /* utilities used by spline drawing routines */
910
911 typedef struct wx_spline_stack_struct {
912 double x1, y1, x2, y2, x3, y3, x4, y4;
913 } Stack;
914
915 #define SPLINE_STACK_DEPTH 20
916 static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
917 static Stack *wx_stack_top;
918 static int wx_stack_count;
919
920 void wx_clear_stack(void)
921 {
922 wx_stack_top = wx_spline_stack;
923 wx_stack_count = 0;
924 }
925
926 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
927 {
928 wx_stack_top->x1 = x1;
929 wx_stack_top->y1 = y1;
930 wx_stack_top->x2 = x2;
931 wx_stack_top->y2 = y2;
932 wx_stack_top->x3 = x3;
933 wx_stack_top->y3 = y3;
934 wx_stack_top->x4 = x4;
935 wx_stack_top->y4 = y4;
936 wx_stack_top++;
937 wx_stack_count++;
938 }
939
940 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
941 double *x3, double *y3, double *x4, double *y4)
942 {
943 if (wx_stack_count == 0)
944 return (0);
945 wx_stack_top--;
946 wx_stack_count--;
947 *x1 = wx_stack_top->x1;
948 *y1 = wx_stack_top->y1;
949 *x2 = wx_stack_top->x2;
950 *y2 = wx_stack_top->y2;
951 *x3 = wx_stack_top->x3;
952 *y3 = wx_stack_top->y3;
953 *x4 = wx_stack_top->x4;
954 *y4 = wx_stack_top->y4;
955 return (1);
956 }
957
958 static bool wx_spline_add_point(double x, double y)
959 {
960 wxPoint *point = new wxPoint ;
961 point->x = (int) x;
962 point->y = (int) y;
963 wx_spline_point_list.Append((wxObject*)point);
964 return TRUE;
965 }
966
967 static void wx_spline_draw_point_array(wxDC *dc)
968 {
969 dc->DrawLines(&wx_spline_point_list, 0, 0 );
970 wxNode *node = wx_spline_point_list.First();
971 while (node)
972 {
973 wxPoint *point = (wxPoint *)node->Data();
974 delete point;
975 delete node;
976 node = wx_spline_point_list.First();
977 }
978 }
979
980 void wxPaintDC::DrawSpline( wxList *points )
981 {
982 wxPoint *p;
983 double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
984 double x1, y1, x2, y2;
985
986 wxNode *node = points->First();
987 p = (wxPoint *)node->Data();
988
989 x1 = p->x;
990 y1 = p->y;
991
992 node = node->Next();
993 p = (wxPoint *)node->Data();
994
995 x2 = p->x;
996 y2 = p->y;
997 cx1 = (double)((x1 + x2) / 2);
998 cy1 = (double)((y1 + y2) / 2);
999 cx2 = (double)((cx1 + x2) / 2);
1000 cy2 = (double)((cy1 + y2) / 2);
1001
1002 wx_spline_add_point(x1, y1);
1003
1004 while ((node = node->Next()) != NULL)
1005 {
1006 p = (wxPoint *)node->Data();
1007 x1 = x2;
1008 y1 = y2;
1009 x2 = p->x;
1010 y2 = p->y;
1011 cx4 = (double)(x1 + x2) / 2;
1012 cy4 = (double)(y1 + y2) / 2;
1013 cx3 = (double)(x1 + cx4) / 2;
1014 cy3 = (double)(y1 + cy4) / 2;
1015
1016 wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
1017
1018 cx1 = cx4;
1019 cy1 = cy4;
1020 cx2 = (double)(cx1 + x2) / 2;
1021 cy2 = (double)(cy1 + y2) / 2;
1022 }
1023
1024 wx_spline_add_point( cx1, cy1 );
1025 wx_spline_add_point( x2, y2 );
1026
1027 wx_spline_draw_point_array( this );
1028 }
wxWidgets (Impactor)