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