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


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