]> git.saurik.com Git - wxWidgets.git/blob - src/msw/dc.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added spinbutton
[wxWidgets.git] / src / msw / dc.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: dc.cpp
3 // Purpose: wxDC class
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "dc.h"
14 #endif
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #ifndef WX_PRECOMP
24 #include "wx/frame.h"
25 #include "wx/dc.h"
26 #include "wx/utils.h"
27 #include "wx/dialog.h"
28 #include "wx/app.h"
29 #endif
30
31 #include "wx/dcprint.h"
32 #include "wx/msw/private.h"
33
34 #include <string.h>
35 #include <math.h>
36
37 #if wxUSE_COMMON_DIALOGS
38 #include <commdlg.h>
39 #endif
40
41 #ifndef __WIN32__
42 #include <print.h>
43 #endif
44
45 #ifdef DrawText
46 #undef DrawText
47 #endif
48
49 #ifdef GetCharWidth
50 #undef GetCharWidth
51 #endif
52
53 #ifdef StartDoc
54 #undef StartDoc
55 #endif
56
57 #if !USE_SHARED_LIBRARY
58 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
59 #endif
60
61 // Declarations local to this file
62
63 #define YSCALE(y) (yorigin - (y))
64
65 // #define wx_round(a) (int)((a)+.5)
66
67 // Default constructor
68 wxDC::wxDC(void)
69 {
70 m_minX = 0; m_minY = 0; m_maxX = 0; m_maxY = 0;
71 m_clipping = FALSE;
72
73 m_filename = "";
74 m_canvas = NULL;
75 m_oldBitmap = 0;
76 m_oldPen = 0;
77 m_oldBrush = 0;
78 m_oldFont = 0;
79 m_oldPalette = 0;
80 m_minX = 0; m_minY = 0; m_maxX = 0; m_maxY = 0;
81 m_logicalOriginX = 0;
82 m_logicalOriginY = 0;
83 m_deviceOriginX = 0;
84 m_deviceOriginY = 0;
85 m_logicalScaleX = 1.0;
86 m_logicalScaleY = 1.0;
87 m_userScaleX = 1.0;
88 m_userScaleY = 1.0;
89 m_signX = 1;
90 m_signY = 1;
91 m_systemScaleX = 1.0;
92 m_systemScaleY = 1.0;
93 m_mappingMode = MM_TEXT;
94 m_bOwnsDC = FALSE;
95 m_hDC = 0;
96 m_clipping = FALSE;
97 m_ok = TRUE;
98 m_windowExtX = VIEWPORT_EXTENT;
99 m_windowExtY = VIEWPORT_EXTENT;
100 m_logicalFunction = -1;
101
102 m_backgroundBrush = *wxWHITE_BRUSH;
103
104 m_textForegroundColour = *wxBLACK;
105 m_textBackgroundColour = *wxWHITE;
106
107 m_colour = wxColourDisplay();
108
109 m_hDCCount = 0;
110 }
111
112
113 wxDC::~wxDC(void)
114 {
115 if ( m_hDC != 0 ) {
116 SelectOldObjects(m_hDC);
117 if ( m_bOwnsDC ) {
118 if ( m_canvas == NULL )
119 ::DeleteDC((HDC)m_hDC);
120 else
121 ::ReleaseDC((HWND)m_canvas->GetHWND(), (HDC)m_hDC);
122 }
123 }
124
125 }
126
127 // This will select current objects out of the DC,
128 // which is what you have to do before deleting the
129 // DC.
130 void wxDC::SelectOldObjects(WXHDC dc)
131 {
132 if (dc)
133 {
134 if (m_oldBitmap)
135 {
136 ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
137 if (m_selectedBitmap.Ok())
138 {
139 m_selectedBitmap.SetSelectedInto(NULL);
140 }
141 }
142 m_oldBitmap = 0 ;
143 if (m_oldPen)
144 {
145 ::SelectObject((HDC) dc, (HPEN) m_oldPen);
146 }
147 m_oldPen = 0 ;
148 if (m_oldBrush)
149 {
150 ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
151 }
152 m_oldBrush = 0 ;
153 if (m_oldFont)
154 {
155 ::SelectObject((HDC) dc, (HFONT) m_oldFont);
156 }
157 m_oldFont = 0 ;
158 if (m_oldPalette)
159 {
160 ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
161 }
162 m_oldPalette = 0 ;
163 }
164
165 m_brush = wxNullBrush ;
166 m_pen = wxNullPen;
167 m_palette = wxNullPalette;
168 m_font = wxNullFont;
169 m_backgroundBrush = wxNullBrush;
170 m_selectedBitmap = wxNullBitmap;
171 }
172
173 void wxDC::SetClippingRegion(long cx, long cy, long cw, long ch)
174 {
175 m_clipping = TRUE;
176 m_clipX1 = (int)cx;
177 m_clipY1 = (int)cy;
178 m_clipX2 = (int)(cx + cw);
179 m_clipY2 = (int)(cy + ch);
180
181 DoClipping((WXHDC) m_hDC);
182 }
183
184 void wxDC::DoClipping(WXHDC dc)
185 {
186 if (m_clipping && dc)
187 {
188 IntersectClipRect((HDC) dc, XLOG2DEV(m_clipX1), YLOG2DEV(m_clipY1),
189 XLOG2DEV(m_clipX2), YLOG2DEV(m_clipY2));
190 }
191 }
192
193 void wxDC::DestroyClippingRegion(void)
194 {
195 if (m_clipping && m_hDC)
196 {
197 HRGN rgn = CreateRectRgn(0, 0, 32000, 32000);
198 SelectClipRgn((HDC) m_hDC, rgn);
199 DeleteObject(rgn);
200 }
201 m_clipping = FALSE;
202 }
203
204 bool wxDC::CanDrawBitmap(void) const
205 {
206 return TRUE;
207 }
208
209 bool wxDC::CanGetTextExtent(void) const
210 {
211 // What sort of display is it?
212 int technology = ::GetDeviceCaps((HDC) m_hDC, TECHNOLOGY);
213
214 bool ok;
215
216 if (technology != DT_RASDISPLAY && technology != DT_RASPRINTER)
217 ok = FALSE;
218 else ok = TRUE;
219
220 return ok;
221 }
222
223 void wxDC::SetPalette(const wxPalette& palette)
224 {
225 // Set the old object temporarily, in case the assignment deletes an object
226 // that's not yet selected out.
227 if (m_oldPalette)
228 {
229 ::SelectPalette((HDC) m_hDC, (HPALETTE) m_oldPalette, TRUE);
230 m_oldPalette = 0;
231 }
232
233 m_palette = m_palette;
234
235 if (!m_palette.Ok())
236 {
237 // Setting a NULL colourmap is a way of restoring
238 // the original colourmap
239 if (m_oldPalette)
240 {
241 ::SelectPalette((HDC) m_hDC, (HPALETTE) m_oldPalette, TRUE);
242 m_oldPalette = 0;
243 }
244
245 return;
246 }
247
248 if (m_palette.Ok() && m_palette.GetHPALETTE())
249 {
250 HPALETTE oldPal = ::SelectPalette((HDC) m_hDC, (HPALETTE) m_palette.GetHPALETTE(), TRUE);
251 if (!m_oldPalette)
252 m_oldPalette = (WXHPALETTE) oldPal;
253
254 ::RealizePalette((HDC) m_hDC);
255 }
256 }
257
258 void wxDC::Clear(void)
259 {
260 RECT rect;
261 if (m_canvas)
262 GetClientRect((HWND) m_canvas->GetHWND(), &rect);
263 else if (m_selectedBitmap.Ok())
264 {
265 rect.left = 0; rect.top = 0;
266 rect.right = m_selectedBitmap.GetWidth();
267 rect.bottom = m_selectedBitmap.GetHeight();
268 }
269 (void) ::SetMapMode((HDC) m_hDC, MM_TEXT);
270
271 DWORD colour = GetBkColor((HDC) m_hDC);
272 HBRUSH brush = CreateSolidBrush(colour);
273 FillRect((HDC) m_hDC, &rect, brush);
274 DeleteObject(brush);
275
276 ::SetMapMode((HDC) m_hDC, MM_ANISOTROPIC);
277 ::SetViewportExtEx((HDC) m_hDC, VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
278 ::SetWindowExtEx((HDC) m_hDC, m_windowExtX, m_windowExtY, NULL);
279 ::SetViewportOrgEx((HDC) m_hDC, (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
280 ::SetWindowOrgEx((HDC) m_hDC, (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
281 }
282
283 void wxDC::FloodFill(long x, long y, const wxColour& col, int style)
284 {
285 (void)ExtFloodFill((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y),
286 col.GetPixel(),
287 style==wxFLOOD_SURFACE?
288 FLOODFILLSURFACE:FLOODFILLBORDER
289 );
290
291 CalcBoundingBox(x, y);
292 }
293
294 bool wxDC::GetPixel(long x, long y, wxColour *col) const
295 {
296 // added by steve 29.12.94 (copied from DrawPoint)
297 // returns TRUE for pixels in the color of the current pen
298 // and FALSE for all other pixels colors
299 // if col is non-NULL return the color of the pixel
300
301 // get the color of the pixel
302 COLORREF pixelcolor = ::GetPixel((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y));
303 // get the color of the pen
304 COLORREF pencolor = 0x00ffffff;
305 if (m_pen.Ok())
306 {
307 pencolor = m_pen.GetColour().GetPixel() ;
308 }
309
310 // return the color of the pixel
311 if(col)
312 col->Set(GetRValue(pixelcolor),GetGValue(pixelcolor),GetBValue(pixelcolor));
313
314 // check, if color of the pixels is the same as the color
315 // of the current pen
316 return(pixelcolor==pencolor);
317 }
318
319 void wxDC::CrossHair(long x, long y)
320 {
321 // We suppose that our screen is 2000x2000 max.
322 long x1 = x-2000;
323 long y1 = y-2000;
324 long x2 = x+2000;
325 long y2 = y+2000;
326
327 (void)MoveToEx((HDC) m_hDC, XLOG2DEV(x1), YLOG2DEV(y), NULL);
328 (void)LineTo((HDC) m_hDC, XLOG2DEV(x2), YLOG2DEV(y));
329
330 (void)MoveToEx((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y1), NULL);
331 (void)LineTo((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y2));
332
333 CalcBoundingBox(x1, y1);
334 CalcBoundingBox(x2, y2);
335 }
336
337 void wxDC::DrawLine(long x1, long y1, long x2, long y2)
338 {
339 (void)MoveToEx((HDC) m_hDC, XLOG2DEV(x1), YLOG2DEV(y1), NULL);
340 (void)LineTo((HDC) m_hDC, XLOG2DEV(x2), YLOG2DEV(y2));
341
342 /* MATTHEW: [6] New normalization */
343 #if WX_STANDARD_GRAPHICS
344 (void)LineTo((HDC) m_hDC, XLOG2DEV(x2) + 1, YLOG2DEV(y2));
345 #endif
346
347 CalcBoundingBox(x1, y1);
348 CalcBoundingBox(x2, y2);
349 }
350
351 void wxDC::DrawArc(long x1,long y1,long x2,long y2, long xc, long yc)
352 {
353 double dx = xc-x1 ;
354 double dy = yc-y1 ;
355 double radius = (double)sqrt(dx*dx+dy*dy) ;;
356 if (x1==x2 && x2==y2)
357 {
358 DrawEllipse(xc,yc,(double)(radius*2.0),(double)(radius*2)) ;
359 return ;
360 }
361
362 long xx1 = XLOG2DEV(x1) ;
363 long yy1 = YLOG2DEV(y1) ;
364 long xx2 = XLOG2DEV(x2) ;
365 long yy2 = YLOG2DEV(y2) ;
366 long xxc = XLOG2DEV(xc) ;
367 long yyc = YLOG2DEV(yc) ;
368 long ray = (long) sqrt(double((xxc-xx1)*(xxc-xx1)+(yyc-yy1)*(yyc-yy1))) ;
369
370 (void)MoveToEx((HDC) m_hDC, (int) xx1, (int) yy1, NULL);
371 long xxx1 = (long) (xxc-ray);
372 long yyy1 = (long) (yyc-ray);
373 long xxx2 = (long) (xxc+ray);
374 long yyy2 = (long) (yyc+ray);
375 if (m_brush.Ok() && m_brush.GetStyle() !=wxTRANSPARENT)
376 {
377 // Have to add 1 to bottom-right corner of rectangle
378 // to make semi-circles look right (crooked line otherwise).
379 // Unfortunately this is not a reliable method, depends
380 // on the size of shape.
381 // TODO: figure out why this happens!
382 Pie((HDC) m_hDC,xxx1,yyy1,xxx2+1,yyy2+1,
383 xx1,yy1,xx2,yy2) ;
384 }
385 else
386 Arc((HDC) m_hDC,xxx1,yyy1,xxx2,yyy2,
387 xx1,yy1,xx2,yy2) ;
388
389 CalcBoundingBox((xc-radius), (yc-radius));
390 CalcBoundingBox((xc+radius), (yc+radius));
391 }
392
393 void wxDC::DrawPoint(long x, long y)
394 {
395 COLORREF color = 0x00ffffff;
396 if (m_pen.Ok())
397 {
398 color = m_pen.GetColour().GetPixel() ;
399 }
400
401 SetPixel((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), color);
402
403 CalcBoundingBox(x, y);
404 }
405
406 void wxDC::DrawPolygon(int n, wxPoint points[], long xoffset, long yoffset,int fillStyle)
407 {
408 // Do things less efficiently if we have offsets
409 if (xoffset != 0 || yoffset != 0)
410 {
411 POINT *cpoints = new POINT[n];
412 int i;
413 for (i = 0; i < n; i++)
414 {
415 cpoints[i].x = (int)(points[i].x + xoffset);
416 cpoints[i].y = (int)(points[i].y + yoffset);
417
418 CalcBoundingBox(cpoints[i].x, cpoints[i].y);
419 }
420 int prev = SetPolyFillMode((HDC) m_hDC,fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING) ;
421 (void)Polygon((HDC) m_hDC, cpoints, n);
422 SetPolyFillMode((HDC) m_hDC,prev) ;
423 delete[] cpoints;
424 }
425 else
426 {
427 int i;
428 for (i = 0; i < n; i++)
429 CalcBoundingBox(points[i].x, points[i].y);
430
431 int prev = SetPolyFillMode((HDC) m_hDC,fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING) ;
432 (void)Polygon((HDC) m_hDC, (POINT*) points, n);
433 SetPolyFillMode((HDC) m_hDC,prev) ;
434 }
435 }
436
437 void wxDC::DrawLines(int n, wxPoint points[], long xoffset, long yoffset)
438 {
439 // Do things less efficiently if we have offsets
440 if (xoffset != 0 || yoffset != 0)
441 {
442 POINT *cpoints = new POINT[n];
443 int i;
444 for (i = 0; i < n; i++)
445 {
446 cpoints[i].x = (int)(points[i].x + xoffset);
447 cpoints[i].y = (int)(points[i].y + yoffset);
448
449 CalcBoundingBox(cpoints[i].x, cpoints[i].y);
450 }
451 (void)Polyline((HDC) m_hDC, cpoints, n);
452 delete[] cpoints;
453 }
454 else
455 {
456 int i;
457 for (i = 0; i < n; i++)
458 CalcBoundingBox(points[i].x, points[i].y);
459
460 (void)Polyline((HDC) m_hDC, (POINT*) points, n);
461 }
462 }
463
464 void wxDC::DrawRectangle(long x, long y, long width, long height)
465 {
466 long x2 = x + width;
467 long y2 = y + height;
468
469 /* MATTHEW: [6] new normalization */
470 #if WX_STANDARD_GRAPHICS
471 bool do_brush, do_pen;
472
473 do_brush = m_brush.Ok() && m_brush.GetStyle() != wxTRANSPARENT;
474 do_pen = m_pen.Ok() && m_pen.GetStyle() != wxTRANSPARENT;
475
476 if (do_brush) {
477 HPEN orig_pen = NULL;
478
479 if (do_pen || !m_pen.Ok())
480 orig_pen = (HPEN) ::SelectObject((HDC) m_hDC, (HPEN) ::GetStockObject(NULL_PEN));
481
482 (void)Rectangle((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y),
483 XLOG2DEV(x2) + 1, YLOG2DEV(y2) + 1);
484
485 if (do_pen || !m_pen.Ok())
486 ::SelectObject((HDC) m_hDC , orig_pen);
487 }
488 if (do_pen) {
489 HBRUSH orig_brush = NULL;
490
491 if (do_brush || !m_brush.Ok())
492 orig_brush = (HBRUSH) ::SelectObject((HDC) m_hDC, (HBRUSH) ::GetStockObject(NULL_BRUSH));
493
494 (void)Rectangle((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y),
495 XLOG2DEV(x2), YLOG2DEV(y2));
496
497 if (do_brush || !m_brush.Ok())
498 ::SelectObject((HDC) m_hDC, orig_brush);
499 }
500 #else
501 (void)Rectangle((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
502 #endif
503
504 CalcBoundingBox(x, y);
505 CalcBoundingBox(x2, y2);
506 }
507
508 void wxDC::DrawRoundedRectangle(long x, long y, long width, long height, double radius)
509 {
510 // Now, a negative radius value is interpreted to mean
511 // 'the proportion of the smallest X or Y dimension'
512
513 if (radius < 0.0)
514 {
515 double smallest = 0.0;
516 if (width < height)
517 smallest = width;
518 else
519 smallest = height;
520 radius = (- radius * smallest);
521 }
522
523 long x2 = (x+width);
524 long y2 = (y+height);
525
526 (void)RoundRect((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2),
527 YLOG2DEV(y2), 2*XLOG2DEV(radius), 2*YLOG2DEV(radius));
528
529 CalcBoundingBox(x, y);
530 CalcBoundingBox(x2, y2);
531 }
532
533 void wxDC::DrawEllipse(long x, long y, long width, long height)
534 {
535 long x2 = (x+width);
536 long y2 = (y+height);
537
538 (void)Ellipse((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
539
540 CalcBoundingBox(x, y);
541 CalcBoundingBox(x2, y2);
542 }
543
544 // Chris Breeze 20/5/98: first implementation of DrawEllipticArc on Windows
545 void wxDC::DrawEllipticArc(long x,long y,long w,long h,double sa,double ea)
546 {
547 long x2 = (x+w);
548 long y2 = (y+h);
549
550 const double deg2rad = 3.14159265359 / 180.0;
551 int rx1 = XLOG2DEV(x+w/2);
552 int ry1 = YLOG2DEV(y+h/2);
553 int rx2 = rx1;
554 int ry2 = ry1;
555 rx1 += (int)(100.0 * abs(w) * cos(sa * deg2rad));
556 ry1 -= (int)(100.0 * abs(h) * m_signY * sin(sa * deg2rad));
557 rx2 += (int)(100.0 * abs(w) * cos(ea * deg2rad));
558 ry2 -= (int)(100.0 * abs(h) * m_signY * sin(ea * deg2rad));
559
560 // draw pie with NULL_PEN first and then outline otherwise a line is
561 // drawn from the start and end points to the centre
562 HPEN orig_pen = (HPEN) ::SelectObject((HDC) m_hDC, (HPEN) ::GetStockObject(NULL_PEN));
563 if (m_signY > 0)
564 {
565 (void)Pie((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2)+1, YLOG2DEV(y2)+1,
566 rx1, ry1, rx2, ry2);
567 }
568 else
569 {
570 (void)Pie((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y)-1, XLOG2DEV(x2)+1, YLOG2DEV(y2),
571 rx1, ry1-1, rx2, ry2-1);
572 }
573 ::SelectObject((HDC) m_hDC, orig_pen);
574 (void)Arc((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2),
575 rx1, ry1, rx2, ry2);
576
577 CalcBoundingBox(x, y);
578 CalcBoundingBox(x2, y2);
579 }
580
581 void wxDC::DrawIcon(const wxIcon& icon, long x, long y)
582 {
583 ::DrawIcon((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), (HICON) icon.GetHICON());
584 CalcBoundingBox(x, y);
585 CalcBoundingBox(x+icon.GetWidth(), y+icon.GetHeight());
586 }
587
588 void wxDC::SetFont(const wxFont& the_font)
589 {
590 // Set the old object temporarily, in case the assignment deletes an object
591 // that's not yet selected out.
592 if (m_oldFont)
593 {
594 ::SelectObject((HDC) m_hDC, (HFONT) m_oldFont);
595 m_oldFont = 0;
596 }
597
598 m_font = the_font;
599
600 if (!the_font.Ok())
601 {
602 if (m_oldFont)
603 ::SelectObject((HDC) m_hDC, (HFONT) m_oldFont);
604 m_oldFont = 0 ;
605 }
606
607 if (m_font.Ok() && m_font.GetResourceHandle())
608 {
609 HFONT f = (HFONT) ::SelectObject((HDC) m_hDC, (HFONT) m_font.GetResourceHandle());
610 if (f == NULL)
611 {
612 wxDebugMsg("::SelectObject failed in wxDC::SetFont.");
613 }
614 if (!m_oldFont)
615 m_oldFont = (WXHFONT) f;
616 }
617 }
618
619 void wxDC::SetPen(const wxPen& pen)
620 {
621 // Set the old object temporarily, in case the assignment deletes an object
622 // that's not yet selected out.
623 if (m_oldPen)
624 {
625 ::SelectObject((HDC) m_hDC, (HPEN) m_oldPen);
626 m_oldPen = 0;
627 }
628
629 m_pen = pen;
630
631 if (!m_pen.Ok())
632 {
633 if (m_oldPen)
634 ::SelectObject((HDC) m_hDC, (HPEN) m_oldPen);
635 m_oldPen = 0 ;
636 }
637
638 if (m_pen.Ok())
639 {
640 if (m_pen.GetResourceHandle())
641 {
642 HPEN p = (HPEN) ::SelectObject((HDC) m_hDC, (HPEN)m_pen.GetResourceHandle()) ;
643 if (!m_oldPen)
644 m_oldPen = (WXHPEN) p;
645 }
646 }
647 }
648
649 void wxDC::SetBrush(const wxBrush& brush)
650 {
651 // Set the old object temporarily, in case the assignment deletes an object
652 // that's not yet selected out.
653 if (m_oldBrush)
654 {
655 ::SelectObject((HDC) m_hDC, (HBRUSH) m_oldBrush);
656 m_oldBrush = 0;
657 }
658
659 m_brush = brush;
660
661 if (!m_brush.Ok())
662 {
663 if (m_oldBrush)
664 ::SelectObject((HDC) m_hDC, (HBRUSH) m_oldBrush);
665 m_oldBrush = 0 ;
666 }
667
668 if (m_brush.Ok())
669 {
670 if (m_brush.GetResourceHandle())
671 {
672 HBRUSH b = 0;
673 b = (HBRUSH) ::SelectObject((HDC) m_hDC, (HBRUSH)m_brush.GetResourceHandle()) ;
674 if (!m_oldBrush)
675 m_oldBrush = (WXHBRUSH) b;
676 }
677 }
678 }
679
680 void wxDC::DrawText(const wxString& text, long x, long y, bool use16bit)
681 {
682 // Should be unnecessary: SetFont should have done this already.
683 #if 0
684 if (m_font.Ok() && m_font.GetResourceHandle())
685 {
686 HFONT f = (HFONT) ::SelectObject((HDC) m_hDC, (HFONT) m_font.GetResourceHandle());
687 if (!m_oldFont)
688 m_oldFont = (WXHFONT) f;
689 }
690 #endif
691
692 if (m_textForegroundColour.Ok())
693 SetTextColor((HDC) m_hDC, m_textForegroundColour.GetPixel() ) ;
694
695 DWORD old_background;
696 if (m_textBackgroundColour.Ok())
697 {
698 old_background = SetBkColor((HDC) m_hDC, m_textBackgroundColour.GetPixel() ) ;
699 }
700
701 if (m_backgroundMode == wxTRANSPARENT)
702 SetBkMode((HDC) m_hDC, TRANSPARENT);
703 else
704 SetBkMode((HDC) m_hDC, OPAQUE);
705
706 (void)TextOut((HDC) m_hDC, XLOG2DEV(x), YLOG2DEV(y), (char *) (const char *)text, strlen((const char *)text));
707
708 if (m_textBackgroundColour.Ok())
709 (void)SetBkColor((HDC) m_hDC, old_background);
710
711 CalcBoundingBox(x, y);
712
713 long w, h;
714 GetTextExtent(text, &w, &h);
715 CalcBoundingBox((x + w), (y + h));
716 }
717
718 void wxDC::SetBackground(const wxBrush& brush)
719 {
720 m_backgroundBrush = brush;
721
722 if (!m_backgroundBrush.Ok())
723 return;
724
725 if (m_canvas)
726 {
727 bool customColours = TRUE;
728 // If we haven't specified wxUSER_COLOURS, don't allow the panel/dialog box to
729 // change background colours from the control-panel specified colours.
730 if (m_canvas->IsKindOf(CLASSINFO(wxWindow)) && ((m_canvas->GetWindowStyleFlag() & wxUSER_COLOURS) != wxUSER_COLOURS))
731 customColours = FALSE;
732
733 if (customColours)
734 {
735 if (m_backgroundBrush.GetStyle()==wxTRANSPARENT)
736 {
737 m_canvas->m_backgroundTransparent = TRUE;
738 }
739 else
740 {
741 m_canvas->SetBackgroundColour(m_backgroundBrush.GetColour());
742 m_canvas->m_backgroundTransparent = FALSE;
743 }
744 }
745 }
746 COLORREF new_color = m_backgroundBrush.GetColour().GetPixel() ;
747 {
748 (void)SetBkColor((HDC) m_hDC, new_color);
749 }
750 }
751
752 void wxDC::SetBackgroundMode(int mode)
753 {
754 m_backgroundMode = mode;
755
756 if (m_backgroundMode == wxTRANSPARENT)
757 ::SetBkMode((HDC) m_hDC, TRANSPARENT);
758 else
759 ::SetBkMode((HDC) m_hDC, OPAQUE);
760 }
761
762 void wxDC::SetLogicalFunction(int function)
763 {
764 m_logicalFunction = function;
765
766 SetRop((WXHDC) m_hDC);
767 }
768
769 void wxDC::SetRop(WXHDC dc)
770 {
771 if (!dc || m_logicalFunction < 0)
772 return;
773
774 int c_rop;
775 // These may be wrong
776 switch (m_logicalFunction)
777 {
778 // case wxXOR: c_rop = R2_XORPEN; break;
779 case wxXOR: c_rop = R2_NOTXORPEN; break;
780 case wxINVERT: c_rop = R2_NOT; break;
781 case wxOR_REVERSE: c_rop = R2_MERGEPENNOT; break;
782 case wxAND_REVERSE: c_rop = R2_MASKPENNOT; break;
783 case wxCLEAR: c_rop = R2_WHITE; break;
784 case wxSET: c_rop = R2_BLACK; break;
785 case wxSRC_INVERT: c_rop = R2_NOTCOPYPEN; break;
786 case wxOR_INVERT: c_rop = R2_MERGENOTPEN; break;
787 case wxAND: c_rop = R2_MASKPEN; break;
788 case wxOR: c_rop = R2_MERGEPEN; break;
789 case wxAND_INVERT: c_rop = R2_MASKNOTPEN; break;
790 case wxEQUIV:
791 case wxNAND:
792 case wxCOPY:
793 default:
794 c_rop = R2_COPYPEN; break;
795 }
796 SetROP2((HDC) dc, c_rop);
797 }
798
799 bool wxDC::StartDoc(const wxString& message)
800 {
801 if (!this->IsKindOf(CLASSINFO(wxPrinterDC)))
802 return TRUE;
803
804 DOCINFO docinfo;
805 docinfo.cbSize = sizeof(DOCINFO);
806 docinfo.lpszDocName = (const char *)message;
807
808 if (m_filename.IsEmpty())
809 docinfo.lpszOutput = NULL;
810 else
811 docinfo.lpszOutput = (const char *)m_filename;
812
813 #if defined(__WIN95__)
814 docinfo.lpszDatatype = NULL;
815 docinfo.fwType = 0;
816 #endif
817
818 if (!m_hDC)
819 return FALSE;
820
821 int ret =
822 #ifndef __WIN32__
823 ::StartDoc((HDC) m_hDC, &docinfo);
824 #else
825 #ifdef UNICODE
826 ::StartDocW((HDC) m_hDC, &docinfo);
827 #else
828 ::StartDocA((HDC) m_hDC, &docinfo);
829 #endif
830 #endif
831
832 if (ret <= 0)
833 {
834 DWORD lastError = GetLastError();
835 wxDebugMsg("wxDC::StartDoc failed with error: %d\n", lastError);
836 }
837 return (ret > 0);
838 }
839
840 void wxDC::EndDoc(void)
841 {
842 if (!this->IsKindOf(CLASSINFO(wxPrinterDC)))
843 return;
844 if (m_hDC) ::EndDoc((HDC) m_hDC);
845 }
846
847 void wxDC::StartPage(void)
848 {
849 if (!this->IsKindOf(CLASSINFO(wxPrinterDC)))
850 return;
851 if (m_hDC)
852 ::StartPage((HDC) m_hDC);
853 }
854
855 void wxDC::EndPage(void)
856 {
857 if (!this->IsKindOf(CLASSINFO(wxPrinterDC)))
858 return;
859 if (m_hDC)
860 ::EndPage((HDC) m_hDC);
861 }
862
863 long wxDC::GetCharHeight(void) const
864 {
865 TEXTMETRIC lpTextMetric;
866
867 GetTextMetrics((HDC) m_hDC, &lpTextMetric);
868
869 return YDEV2LOGREL(lpTextMetric.tmHeight);
870 }
871
872 long wxDC::GetCharWidth(void) const
873 {
874 TEXTMETRIC lpTextMetric;
875
876 GetTextMetrics((HDC) m_hDC, &lpTextMetric);
877
878 return XDEV2LOGREL(lpTextMetric.tmAveCharWidth);
879 }
880
881 void wxDC::GetTextExtent(const wxString& string, long *x, long *y,
882 long *descent, long *externalLeading, wxFont *theFont, bool use16bit) const
883 {
884 wxFont *fontToUse = (wxFont*) theFont;
885 if (!fontToUse)
886 fontToUse = (wxFont*) &m_font;
887
888 SIZE sizeRect;
889 TEXTMETRIC tm;
890
891 GetTextExtentPoint((HDC) m_hDC, (char *)(const char *) string, strlen((char *)(const char *) string), &sizeRect);
892 GetTextMetrics((HDC) m_hDC, &tm);
893
894 if (x) *x = XDEV2LOGREL(sizeRect.cx);
895 if (y) *y = YDEV2LOGREL(sizeRect.cy);
896 if (descent) *descent = tm.tmDescent;
897 if (externalLeading) *externalLeading = tm.tmExternalLeading;
898 }
899
900 void wxDC::SetMapMode(int mode)
901 {
902 m_mappingMode = mode;
903
904 int pixel_width = 0;
905 int pixel_height = 0;
906 int mm_width = 0;
907 int mm_height = 0;
908
909 pixel_width = GetDeviceCaps((HDC) m_hDC, HORZRES);
910 pixel_height = GetDeviceCaps((HDC) m_hDC, VERTRES);
911 mm_width = GetDeviceCaps((HDC) m_hDC, HORZSIZE);
912 mm_height = GetDeviceCaps((HDC) m_hDC, VERTSIZE);
913
914 if ((pixel_width == 0) || (pixel_height == 0) || (mm_width == 0) || (mm_height == 0))
915 {
916 return;
917 }
918
919 double mm2pixelsX = pixel_width/mm_width;
920 double mm2pixelsY = pixel_height/mm_height;
921
922 switch (mode)
923 {
924 case MM_TWIPS:
925 {
926 m_logicalScaleX = (twips2mm * mm2pixelsX);
927 m_logicalScaleY = (twips2mm * mm2pixelsY);
928 break;
929 }
930 case MM_POINTS:
931 {
932 m_logicalScaleX = (pt2mm * mm2pixelsX);
933 m_logicalScaleY = (pt2mm * mm2pixelsY);
934 break;
935 }
936 case MM_METRIC:
937 {
938 m_logicalScaleX = mm2pixelsX;
939 m_logicalScaleY = mm2pixelsY;
940 break;
941 }
942 case MM_LOMETRIC:
943 {
944 m_logicalScaleX = (mm2pixelsX/10.0);
945 m_logicalScaleY = (mm2pixelsY/10.0);
946 break;
947 }
948 default:
949 case MM_TEXT:
950 {
951 m_logicalScaleX = 1.0;
952 m_logicalScaleY = 1.0;
953 break;
954 }
955 }
956
957 if (::GetMapMode((HDC) m_hDC) != MM_ANISOTROPIC)
958 ::SetMapMode((HDC) m_hDC, MM_ANISOTROPIC);
959
960 SetViewportExtEx((HDC) m_hDC, VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
961 m_windowExtX = (int)MS_XDEV2LOGREL(VIEWPORT_EXTENT);
962 m_windowExtY = (int)MS_YDEV2LOGREL(VIEWPORT_EXTENT);
963 ::SetWindowExtEx((HDC) m_hDC, m_windowExtX, m_windowExtY, NULL);
964 ::SetViewportOrgEx((HDC) m_hDC, (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
965 ::SetWindowOrgEx((HDC) m_hDC, (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
966 }
967
968 void wxDC::SetUserScale(double x, double y)
969 {
970 m_userScaleX = x;
971 m_userScaleY = y;
972
973 SetMapMode(m_mappingMode);
974 }
975
976 void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
977 {
978 m_signX = xLeftRight ? 1 : -1;
979 m_signY = yBottomUp ? -1 : 1;
980
981 SetMapMode(m_mappingMode);
982 }
983
984 void wxDC::SetSystemScale(double x, double y)
985 {
986 m_systemScaleX = x;
987 m_systemScaleY = y;
988
989 SetMapMode(m_mappingMode);
990 }
991
992 void wxDC::SetLogicalOrigin(long x, long y)
993 {
994 m_logicalOriginX = x;
995 m_logicalOriginY = y;
996
997 ::SetWindowOrgEx((HDC) m_hDC, (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
998 }
999
1000 void wxDC::SetDeviceOrigin(long x, long y)
1001 {
1002 m_deviceOriginX = x;
1003 m_deviceOriginY = y;
1004
1005 ::SetViewportOrgEx((HDC) m_hDC, (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
1006 }
1007
1008 long wxDC::DeviceToLogicalX(long x) const
1009 {
1010 return (long) (((x) - m_deviceOriginX)/(m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX) - m_logicalOriginX) ;
1011 }
1012
1013 long wxDC::DeviceToLogicalXRel(long x) const
1014 {
1015 return (long) ((x)/(m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX)) ;
1016 }
1017
1018 long wxDC::DeviceToLogicalY(long y) const
1019 {
1020 return (long) (((y) - m_deviceOriginY)/(m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY) - m_logicalOriginY) ;
1021 }
1022
1023 long wxDC::DeviceToLogicalYRel(long y) const
1024 {
1025 return (long) ((y)/(m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY)) ;
1026 }
1027
1028 long wxDC::LogicalToDeviceX(long x) const
1029 {
1030 return (long) (floor((x) - m_logicalOriginX)*m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX + m_deviceOriginX) ;
1031 }
1032
1033 long wxDC::LogicalToDeviceXRel(long x) const
1034 {
1035 return (long) (floor(x)*m_logicalScaleX*m_userScaleX*m_signX*m_systemScaleX) ;
1036 }
1037
1038 long wxDC::LogicalToDeviceY(long y) const
1039 {
1040 return (long) (floor((y) - m_logicalOriginY)*m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY + m_deviceOriginY);
1041 }
1042
1043 long wxDC::LogicalToDeviceYRel(long y) const
1044 {
1045 return (long) (floor(y)*m_logicalScaleY*m_userScaleY*m_signY*m_systemScaleY) ;
1046 }
1047
1048 // This group of functions may not do any conversion
1049 // if m_scaleGDI is TRUE, since the HDC does the
1050 // conversion automatically.
1051
1052 long wxDC::ImplDeviceToLogicalX(long x) const
1053 {
1054 // return (m_scaleGDI ? x : DeviceToLogicalX(x));
1055 return x;
1056 }
1057
1058 long wxDC::ImplDeviceToLogicalY(long y) const
1059 {
1060 // return (m_scaleGDI ? y : DeviceToLogicalY(y));
1061 return y;
1062 }
1063
1064 long wxDC::ImplDeviceToLogicalXRel(long x) const
1065 {
1066 // return (m_scaleGDI ? x : DeviceToLogicalXRel(x));
1067 return x;
1068 }
1069
1070 long wxDC::ImplDeviceToLogicalYRel(long y) const
1071 {
1072 // return (m_scaleGDI ? y : DeviceToLogicalYRel(y));
1073 return y;
1074 }
1075
1076 long wxDC::ImplLogicalToDeviceX(long x) const
1077 {
1078 // return (m_scaleGDI ? (floor(double(x))) : LogicalToDeviceX(x));
1079 return x;
1080 }
1081
1082 long wxDC::ImplLogicalToDeviceY(long y) const
1083 {
1084 // return (m_scaleGDI ? (floor(double(y))) : LogicalToDeviceY(y));
1085 return y;
1086 }
1087
1088 long wxDC::ImplLogicalToDeviceXRel(long x) const
1089 {
1090 // return (m_scaleGDI ? (floor(double(x))) : LogicalToDeviceXRel(x));
1091 return x;
1092 }
1093
1094 long wxDC::ImplLogicalToDeviceYRel(long y) const
1095 {
1096 // return (m_scaleGDI ? (floor(double(y))) : LogicalToDeviceYRel(y));
1097 return y;
1098 }
1099
1100 bool wxDC::Blit(long xdest, long ydest, long width, long height,
1101 wxDC *source, long xsrc, long ysrc, int rop, bool useMask)
1102 {
1103 long xdest1 = xdest;
1104 long ydest1 = ydest;
1105 long xsrc1 = xsrc;
1106 long ysrc1 = ysrc;
1107
1108 // Chris Breeze 18/5/98: use text foreground/background colours
1109 // when blitting from 1-bit bitmaps
1110 COLORREF old_textground = ::GetTextColor((HDC)m_hDC);
1111 COLORREF old_background = ::GetBkColor((HDC)m_hDC);
1112 if (m_textForegroundColour.Ok())
1113 {
1114 ::SetTextColor((HDC) m_hDC, m_textForegroundColour.GetPixel() ) ;
1115 }
1116 if (m_textBackgroundColour.Ok())
1117 {
1118 ::SetBkColor((HDC) m_hDC, m_textBackgroundColour.GetPixel() ) ;
1119 }
1120
1121 DWORD dwRop = rop == wxCOPY ? SRCCOPY :
1122 rop == wxCLEAR ? WHITENESS :
1123 rop == wxSET ? BLACKNESS :
1124 rop == wxINVERT ? DSTINVERT :
1125 rop == wxAND ? MERGECOPY :
1126 rop == wxOR ? MERGEPAINT :
1127 rop == wxSRC_INVERT ? NOTSRCCOPY :
1128 rop == wxXOR ? SRCINVERT :
1129 rop == wxOR_REVERSE ? MERGEPAINT :
1130 rop == wxAND_REVERSE ? SRCERASE :
1131 rop == wxSRC_OR ? SRCPAINT :
1132 rop == wxSRC_AND ? SRCAND :
1133 SRCCOPY;
1134
1135 bool success;
1136 if (useMask && source->m_selectedBitmap.Ok() && source->m_selectedBitmap.GetMask())
1137 {
1138
1139 #if 0 // __WIN32__
1140 // Not implemented under Win95 (or maybe a specific device?)
1141 if (MaskBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
1142 (HDC) source->m_hDC, xsrc1, ysrc1, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap(),
1143 0, 0, 0xAACC0020))
1144 {
1145 // Success
1146 }
1147 else
1148 #endif
1149 {
1150 // Old code
1151 #if 0
1152 HDC dc_mask = CreateCompatibleDC((HDC) source->m_hDC);
1153 ::SelectObject(dc_mask, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap());
1154 success = (BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
1155 dc_mask, xsrc1, ysrc1, 0x00220326 /* NOTSRCAND */) != 0);
1156 success = (BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
1157 (HDC) source->m_hDC, xsrc1, ysrc1, SRCPAINT) != 0);
1158 ::SelectObject(dc_mask, 0);
1159 ::DeleteDC(dc_mask);
1160 #endif
1161 // New code from Chris Breeze, 15/7/98
1162 // Blit bitmap with mask
1163
1164 if (IsKindOf(CLASSINFO(wxPrinterDC)))
1165 {
1166 // If we are printing source colours are screen colours
1167 // not printer colours and so we need copy the bitmap
1168 // pixel by pixel.
1169 RECT rect;
1170 HDC dc_mask = ::CreateCompatibleDC((HDC) source->m_hDC);
1171 HDC dc_src = (HDC) source->m_hDC;
1172
1173 ::SelectObject(dc_mask, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap());
1174 for (int x = 0; x < width; x++)
1175 {
1176 for (int y = 0; y < height; y++)
1177 {
1178 COLORREF cref = ::GetPixel(dc_mask, x, y);
1179 if (cref)
1180 {
1181 HBRUSH brush = ::CreateSolidBrush(::GetPixel(dc_src, x, y));
1182 rect.left = xdest1 + x; rect.right = rect.left + 1;
1183 rect.top = ydest1 + y; rect.bottom = rect.top + 1;
1184 ::FillRect((HDC) m_hDC, &rect, brush);
1185 ::DeleteObject(brush);
1186 }
1187 }
1188 }
1189 ::SelectObject(dc_mask, 0);
1190 ::DeleteDC(dc_mask);
1191 }
1192 else
1193 {
1194 // create a temp buffer bitmap and DCs to access it and the mask
1195 HDC dc_mask = ::CreateCompatibleDC((HDC) source->m_hDC);
1196 HDC dc_buffer = ::CreateCompatibleDC((HDC) m_hDC);
1197 HBITMAP buffer_bmap = ::CreateCompatibleBitmap((HDC) m_hDC, width, height);
1198 ::SelectObject(dc_mask, (HBITMAP) source->m_selectedBitmap.GetMask()->GetMaskBitmap());
1199 ::SelectObject(dc_buffer, buffer_bmap);
1200
1201 // copy dest to buffer
1202 ::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
1203 (HDC) m_hDC, xdest1, ydest1, SRCCOPY);
1204
1205 // copy src to buffer using selected raster op
1206 ::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
1207 (HDC) source->m_hDC, xsrc1, ysrc1, dwRop);
1208
1209 // set masked area in buffer to BLACK (pixel value 0)
1210 COLORREF prevBkCol = ::SetBkColor((HDC) m_hDC, RGB(255, 255, 255));
1211 COLORREF prevCol = ::SetTextColor((HDC) m_hDC, RGB(0, 0, 0));
1212 ::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
1213 dc_mask, xsrc1, ysrc1, SRCAND);
1214
1215 // set unmasked area in dest to BLACK
1216 ::SetBkColor((HDC) m_hDC, RGB(0, 0, 0));
1217 ::SetTextColor((HDC) m_hDC, RGB(255, 255, 255));
1218 ::BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
1219 dc_mask, xsrc1, ysrc1, SRCAND);
1220 ::SetBkColor((HDC) m_hDC, prevBkCol); // restore colours to original values
1221 ::SetTextColor((HDC) m_hDC, prevCol);
1222
1223 // OR buffer to dest
1224 success = (::BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height,
1225 dc_buffer, 0, 0, SRCPAINT) != 0);
1226
1227 // tidy up temporary DCs and bitmap
1228 ::SelectObject(dc_mask, 0);
1229 ::DeleteDC(dc_mask);
1230 ::SelectObject(dc_buffer, 0);
1231 ::DeleteDC(dc_buffer);
1232 ::DeleteObject(buffer_bmap);
1233 }
1234 }
1235 }
1236 else
1237 {
1238 if (IsKindOf(CLASSINFO(wxPrinterDC)))
1239 {
1240 // If we are printing source colours are screen colours
1241 // not printer colours and so we need copy the bitmap
1242 // pixel by pixel.
1243 HDC dc_src = (HDC) source->m_hDC;
1244 RECT rect;
1245 for (int x = 0; x < width; x++)
1246 {
1247 for (int y = 0; y < height; y++)
1248 {
1249 HBRUSH brush = ::CreateSolidBrush(::GetPixel(dc_src, x, y));
1250 rect.left = xdest1 + x; rect.right = rect.left + 1;
1251 rect.top = ydest1 + y; rect.bottom = rect.top + 1;
1252 ::FillRect((HDC) m_hDC, &rect, brush);
1253 ::DeleteObject(brush);
1254 }
1255 }
1256 }
1257 else
1258 {
1259 success = (BitBlt((HDC) m_hDC, xdest1, ydest1, (int)width, (int)height, (HDC) source->m_hDC,
1260 xsrc1, ysrc1, dwRop) != 0);
1261 }
1262 }
1263 ::SetTextColor((HDC)m_hDC, old_textground);
1264 ::SetBkColor((HDC)m_hDC, old_background);
1265
1266 return success;
1267 }
1268
1269 void wxDC::GetSize(int* width, int* height) const
1270 {
1271 long w=::GetDeviceCaps((HDC) m_hDC,HORZRES);
1272 long h=::GetDeviceCaps((HDC) m_hDC,VERTRES);
1273 *width = w;
1274 *height = h;
1275 }
1276
1277 void wxDC::GetSizeMM(long *width, long *height) const
1278 {
1279 long w=::GetDeviceCaps((HDC) m_hDC,HORZSIZE);
1280 long h=::GetDeviceCaps((HDC) m_hDC,VERTSIZE);
1281 *width = w;
1282 *height = h;
1283 }
1284
1285 void wxDC::DrawPolygon(wxList *list, long xoffset, long yoffset,int fillStyle)
1286 {
1287 int n = list->Number();
1288 wxPoint *points = new wxPoint[n];
1289
1290 int i = 0;
1291 for(wxNode *node = list->First(); node; node = node->Next()) {
1292 wxPoint *point = (wxPoint *)node->Data();
1293 points[i].x = point->x;
1294 points[i++].y = point->y;
1295 }
1296 DrawPolygon(n, points, xoffset, yoffset,fillStyle);
1297 delete[] points;
1298 }
1299
1300 void wxDC::DrawLines(wxList *list, long xoffset, long yoffset)
1301 {
1302 int n = list->Number();
1303 wxPoint *points = new wxPoint[n];
1304
1305 int i = 0;
1306 for(wxNode *node = list->First(); node; node = node->Next()) {
1307 wxPoint *point = (wxPoint *)node->Data();
1308 points[i].x = point->x;
1309 points[i++].y = point->y;
1310 }
1311 DrawLines(n, points, xoffset, yoffset);
1312 delete []points;
1313 }
1314
1315 void wxDC::SetTextForeground(const wxColour& colour)
1316 {
1317 m_textForegroundColour = colour;
1318 }
1319
1320 void wxDC::SetTextBackground(const wxColour& colour)
1321 {
1322 m_textBackgroundColour = colour;
1323 }
1324
1325 // For use by wxWindows only, unless custom units are required.
1326 void wxDC::SetLogicalScale(double x, double y)
1327 {
1328 m_logicalScaleX = x;
1329 m_logicalScaleY = y;
1330 }
1331
1332 void wxDC::CalcBoundingBox(long x, long y)
1333 {
1334 if (x < m_minX) m_minX = x;
1335 if (y < m_minY) m_minY = y;
1336 if (x > m_maxX) m_maxX = x;
1337 if (y > m_maxY) m_maxY = y;
1338 }
1339
1340 void wxDC::GetClippingBox(long *x,long *y,long *w,long *h) const
1341 {
1342 if (m_clipping)
1343 {
1344 *x = m_clipX1 ;
1345 *y = m_clipY1 ;
1346 *w = (m_clipX2 - m_clipX1) ;
1347 *h = (m_clipY2 - m_clipY1) ;
1348 }
1349 else
1350 *x = *y = *w = *h = 0 ;
1351 }
1352
1353 #if WXWIN_COMPATIBILITY
1354 void wxDC::GetTextExtent(const wxString& string, float *x, float *y,
1355 float *descent, float *externalLeading,
1356 wxFont *theFont, bool use16bit) const
1357 {
1358 long x1, y1, descent1, externalLeading1;
1359 GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
1360 *x = x1; *y = y1;
1361 if (descent)
1362 *descent = descent1;
1363 if (externalLeading)
1364 *externalLeading = externalLeading1;
1365 }
1366 #endif
1367
1368 int wxDC::GetDepth(void) const
1369 {
1370 return (int) ::GetDeviceCaps((HDC) m_hDC,BITSPIXEL);
1371 }
1372
1373 #if wxUSE_SPLINES
1374
1375 // Make a 3-point spline
1376 void wxDC::DrawSpline(long x1, long y1, long x2, long y2, long x3, long y3)
1377 {
1378 wxList *point_list = new wxList;
1379
1380 wxPoint *point1 = new wxPoint;
1381 point1->x = x1; point1->y = y1;
1382 point_list->Append((wxObject*)point1);
1383
1384 wxPoint *point2 = new wxPoint;
1385 point2->x = x2; point2->y = y2;
1386 point_list->Append((wxObject*)point2);
1387
1388 wxPoint *point3 = new wxPoint;
1389 point3->x = x3; point3->y = y3;
1390 point_list->Append((wxObject*)point3);
1391
1392 DrawSpline(point_list);
1393
1394 for(wxNode *node = point_list->First(); node; node = node->Next()) {
1395 wxPoint *p = (wxPoint *)node->Data();
1396 delete p;
1397 }
1398 delete point_list;
1399 }
1400
1401 ////#define wx_round(a) (int)((a)+.5)
1402 //#define wx_round(a) (a)
1403
1404 class wxSpline: public wxObject
1405 {
1406 public:
1407 int type;
1408 wxList *points;
1409
1410 wxSpline(wxList *list);
1411 void DeletePoints(void);
1412
1413 // Doesn't delete points
1414 ~wxSpline(void);
1415 };
1416
1417 void wxDC::DrawSpline(int n, wxPoint points[])
1418 {
1419 wxList list;
1420 int i;
1421 for (i =0; i < n; i++)
1422 list.Append((wxObject*)&points[i]);
1423 DrawSpline((wxList *)&list);
1424 }
1425
1426 void wx_draw_open_spline(wxDC *dc, wxSpline *spline);
1427
1428 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
1429 double a3, double b3, double a4, double b4);
1430 void wx_clear_stack(void);
1431 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
1432 double *y3, double *x4, double *y4);
1433 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
1434 double x4, double y4);
1435 static bool wx_spline_add_point(double x, double y);
1436 static void wx_spline_draw_point_array(wxDC *dc);
1437 wxSpline *wx_make_spline(int x1, int y1, int x2, int y2, int x3, int y3);
1438
1439 void wxDC::DrawSpline(wxList *list)
1440 {
1441 wxSpline spline(list);
1442
1443 wx_draw_open_spline(this, &spline);
1444 }
1445
1446
1447 wxList wx_spline_point_list;
1448
1449 void wx_draw_open_spline(wxDC *dc, wxSpline *spline)
1450 {
1451 wxPoint *p;
1452 double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
1453 double x1, y1, x2, y2;
1454
1455 wxNode *node = spline->points->First();
1456 p = (wxPoint *)node->Data();
1457
1458 x1 = p->x;
1459 y1 = p->y;
1460
1461 node = node->Next();
1462 p = (wxPoint *)node->Data();
1463
1464 x2 = p->x;
1465 y2 = p->y;
1466 cx1 = (double)((x1 + x2) / 2);
1467 cy1 = (double)((y1 + y2) / 2);
1468 cx2 = (double)((cx1 + x2) / 2);
1469 cy2 = (double)((cy1 + y2) / 2);
1470
1471 wx_spline_add_point(x1, y1);
1472
1473 while ((node = node->Next()) != NULL)
1474 {
1475 p = (wxPoint *)node->Data();
1476 x1 = x2;
1477 y1 = y2;
1478 x2 = p->x;
1479 y2 = p->y;
1480 cx4 = (double)(x1 + x2) / 2;
1481 cy4 = (double)(y1 + y2) / 2;
1482 cx3 = (double)(x1 + cx4) / 2;
1483 cy3 = (double)(y1 + cy4) / 2;
1484
1485 wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
1486
1487 cx1 = cx4;
1488 cy1 = cy4;
1489 cx2 = (double)(cx1 + x2) / 2;
1490 cy2 = (double)(cy1 + y2) / 2;
1491 }
1492
1493 wx_spline_add_point((double)wx_round(cx1), (double)wx_round(cy1));
1494 wx_spline_add_point(x2, y2);
1495
1496 wx_spline_draw_point_array(dc);
1497
1498 }
1499
1500 /********************* CURVES FOR SPLINES *****************************
1501
1502 The following spline drawing routine is from
1503
1504 "An Algorithm for High-Speed Curve Generation"
1505 by George Merrill Chaikin,
1506 Computer Graphics and Image Processing, 3, Academic Press,
1507 1974, 346-349.
1508
1509 and
1510
1511 "On Chaikin's Algorithm" by R. F. Riesenfeld,
1512 Computer Graphics and Image Processing, 4, Academic Press,
1513 1975, 304-310.
1514
1515 ***********************************************************************/
1516
1517 #define half(z1, z2) ((z1+z2)/2.0)
1518 #define THRESHOLD 5
1519
1520 /* iterative version */
1521
1522 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
1523 double b4)
1524 {
1525 register double xmid, ymid;
1526 double x1, y1, x2, y2, x3, y3, x4, y4;
1527
1528 wx_clear_stack();
1529 wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
1530
1531 while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
1532 xmid = (double)half(x2, x3);
1533 ymid = (double)half(y2, y3);
1534 if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
1535 fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
1536 wx_spline_add_point((double)wx_round(x1), (double)wx_round(y1));
1537 wx_spline_add_point((double)wx_round(xmid), (double)wx_round(ymid));
1538 } else {
1539 wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
1540 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
1541 wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
1542 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
1543 }
1544 }
1545 }
1546
1547
1548 /* utilities used by spline drawing routines */
1549
1550
1551 typedef struct wx_spline_stack_struct {
1552 double x1, y1, x2, y2, x3, y3, x4, y4;
1553 }
1554 Stack;
1555
1556 #define SPLINE_STACK_DEPTH 20
1557 static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
1558 static Stack *wx_stack_top;
1559 static int wx_stack_count;
1560
1561 void wx_clear_stack(void)
1562 {
1563 wx_stack_top = wx_spline_stack;
1564 wx_stack_count = 0;
1565 }
1566
1567 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
1568 {
1569 wx_stack_top->x1 = x1;
1570 wx_stack_top->y1 = y1;
1571 wx_stack_top->x2 = x2;
1572 wx_stack_top->y2 = y2;
1573 wx_stack_top->x3 = x3;
1574 wx_stack_top->y3 = y3;
1575 wx_stack_top->x4 = x4;
1576 wx_stack_top->y4 = y4;
1577 wx_stack_top++;
1578 wx_stack_count++;
1579 }
1580
1581 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
1582 double *x3, double *y3, double *x4, double *y4)
1583 {
1584 if (wx_stack_count == 0)
1585 return (0);
1586 wx_stack_top--;
1587 wx_stack_count--;
1588 *x1 = wx_stack_top->x1;
1589 *y1 = wx_stack_top->y1;
1590 *x2 = wx_stack_top->x2;
1591 *y2 = wx_stack_top->y2;
1592 *x3 = wx_stack_top->x3;
1593 *y3 = wx_stack_top->y3;
1594 *x4 = wx_stack_top->x4;
1595 *y4 = wx_stack_top->y4;
1596 return (1);
1597 }
1598
1599 static bool wx_spline_add_point(double x, double y)
1600 {
1601 wxPoint *point = new wxPoint ;
1602 point->x = (int) x;
1603 point->y = (int) y;
1604 wx_spline_point_list.Append((wxObject*)point);
1605 return TRUE;
1606 }
1607
1608 static void wx_spline_draw_point_array(wxDC *dc)
1609 {
1610 dc->DrawLines(&wx_spline_point_list, (double)0.0, (double)0.0);
1611 wxNode *node = wx_spline_point_list.First();
1612 while (node)
1613 {
1614 wxPoint *point = (wxPoint *)node->Data();
1615 delete point;
1616 delete node;
1617 node = wx_spline_point_list.First();
1618 }
1619 }
1620
1621 wxSpline::wxSpline(wxList *list)
1622 {
1623 points = list;
1624 }
1625
1626 wxSpline::~wxSpline(void)
1627 {
1628 }
1629
1630 void wxSpline::DeletePoints(void)
1631 {
1632 for(wxNode *node = points->First(); node; node = points->First())
1633 {
1634 wxPoint *point = (wxPoint *)node->Data();
1635 delete point;
1636 delete node;
1637 }
1638 delete points;
1639 }
1640
1641
1642 #endif // wxUSE_SPLINES
1643
wxWidgets (Impactor)