projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merges from Scitech Branch (George Davison):
[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 // ===========================================================================
13 // declarations
14 // ===========================================================================
15
16 // ---------------------------------------------------------------------------
17 // headers
18 // ---------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "dc.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/window.h"
33 #include "wx/dc.h"
34 #include "wx/utils.h"
35 #include "wx/dialog.h"
36 #include "wx/app.h"
37 #include "wx/bitmap.h"
38 #include "wx/dcmemory.h"
39 #include "wx/log.h"
40 #include "wx/icon.h"
41 #endif
42
43 #include "wx/sysopt.h"
44 #include "wx/dcprint.h"
45 #include "wx/module.h"
46
47 #include <string.h>
48 #include <math.h>
49
50 #include "wx/msw/private.h" // needs to be before #include <commdlg.h>
51
52 #if wxUSE_COMMON_DIALOGS && !defined(__WXMICROWIN__)
53 #include <commdlg.h>
54 #endif
55
56 #ifndef __WIN32__
57 #include <print.h>
58 #endif
59
60 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxDCBase)
61
62 // ---------------------------------------------------------------------------
63 // constants
64 // ---------------------------------------------------------------------------
65
66 static const int VIEWPORT_EXTENT = 1000;
67
68 static const int MM_POINTS = 9;
69 static const int MM_METRIC = 10;
70
71 // usually this is defined in math.h
72 #ifndef M_PI
73 static const double M_PI = 3.14159265358979323846;
74 #endif // M_PI
75
76 // ROPs which don't have standard names (see "Ternary Raster Operations" in the
77 // MSDN docs for how this and other numbers in wxDC::Blit() are obtained)
78 #define DSTCOPY 0x00AA0029 // a.k.a. NOP operation
79
80 // ----------------------------------------------------------------------------
81 // macros for logical <-> device coords conversion
82 // ----------------------------------------------------------------------------
83
84 /*
85 We currently let Windows do all the translations itself so these macros are
86 not really needed (any more) but keep them to enhance readability of the
87 code by allowing to see where are the logical and where are the device
88 coordinates used.
89 */
90
91 // logical to device
92 #define XLOG2DEV(x) (x)
93 #define YLOG2DEV(y) (y)
94
95 // device to logical
96 #define XDEV2LOG(x) (x)
97 #define YDEV2LOG(y) (y)
98
99 // ---------------------------------------------------------------------------
100 // private functions
101 // ---------------------------------------------------------------------------
102
103 // convert degrees to radians
104 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
105
106 // ----------------------------------------------------------------------------
107 // private classes
108 // ----------------------------------------------------------------------------
109
110 // instead of duplicating the same code which sets and then restores text
111 // colours in each wxDC method working with wxSTIPPLE_MASK_OPAQUE brushes,
112 // encapsulate this in a small helper class
113
114 // wxColourChanger: changes the text colours in the ctor if required and
115 // restores them in the dtor
116 class wxColourChanger
117 {
118 public:
119 wxColourChanger(wxDC& dc);
120 ~wxColourChanger();
121
122 private:
123 wxDC& m_dc;
124
125 COLORREF m_colFgOld, m_colBgOld;
126
127 bool m_changed;
128 };
129
130 // ===========================================================================
131 // implementation
132 // ===========================================================================
133
134 // ----------------------------------------------------------------------------
135 // wxColourChanger
136 // ----------------------------------------------------------------------------
137
138 wxColourChanger::wxColourChanger(wxDC& dc) : m_dc(dc)
139 {
140 const wxBrush& brush = dc.GetBrush();
141 if ( brush.Ok() && brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE )
142 {
143 HDC hdc = GetHdcOf(dc);
144 m_colFgOld = ::GetTextColor(hdc);
145 m_colBgOld = ::GetBkColor(hdc);
146
147 // note that Windows convention is opposite to wxWindows one, this is
148 // why text colour becomes the background one and vice versa
149 const wxColour& colFg = dc.GetTextForeground();
150 if ( colFg.Ok() )
151 {
152 ::SetBkColor(hdc, colFg.GetPixel());
153 }
154
155 const wxColour& colBg = dc.GetTextBackground();
156 if ( colBg.Ok() )
157 {
158 ::SetTextColor(hdc, colBg.GetPixel());
159 }
160
161 SetBkMode(hdc,
162 dc.GetBackgroundMode() == wxTRANSPARENT ? TRANSPARENT
163 : OPAQUE);
164
165 // flag which telsl us to undo changes in the dtor
166 m_changed = TRUE;
167 }
168 else
169 {
170 // nothing done, nothing to undo
171 m_changed = FALSE;
172 }
173 }
174
175 wxColourChanger::~wxColourChanger()
176 {
177 if ( m_changed )
178 {
179 // restore the colours we changed
180 HDC hdc = GetHdcOf(m_dc);
181
182 ::SetBkMode(hdc, TRANSPARENT);
183 ::SetTextColor(hdc, m_colFgOld);
184 ::SetBkColor(hdc, m_colBgOld);
185 }
186 }
187
188 // ---------------------------------------------------------------------------
189 // wxDC
190 // ---------------------------------------------------------------------------
191
192 // Default constructor
193 wxDC::wxDC()
194 {
195 m_canvas = NULL;
196
197 m_oldBitmap = 0;
198 m_oldPen = 0;
199 m_oldBrush = 0;
200 m_oldFont = 0;
201 #if wxUSE_PALETTE
202 m_oldPalette = 0;
203 #endif // wxUSE_PALETTE
204
205 m_bOwnsDC = FALSE;
206 m_hDC = 0;
207 }
208
209 wxDC::~wxDC()
210 {
211 if ( m_hDC != 0 )
212 {
213 SelectOldObjects(m_hDC);
214
215 // if we own the HDC, we delete it, otherwise we just release it
216
217 if ( m_bOwnsDC )
218 {
219 ::DeleteDC(GetHdc());
220 }
221 else // we don't own our HDC
222 {
223 if (m_canvas)
224 {
225 ::ReleaseDC(GetHwndOf(m_canvas), GetHdc());
226 }
227 else
228 {
229 // Must have been a wxScreenDC
230 ::ReleaseDC((HWND) NULL, GetHdc());
231 }
232 }
233 }
234 }
235
236 // This will select current objects out of the DC,
237 // which is what you have to do before deleting the
238 // DC.
239 void wxDC::SelectOldObjects(WXHDC dc)
240 {
241 if (dc)
242 {
243 if (m_oldBitmap)
244 {
245 ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
246 if (m_selectedBitmap.Ok())
247 {
248 m_selectedBitmap.SetSelectedInto(NULL);
249 }
250 }
251 m_oldBitmap = 0;
252 if (m_oldPen)
253 {
254 ::SelectObject((HDC) dc, (HPEN) m_oldPen);
255 }
256 m_oldPen = 0;
257 if (m_oldBrush)
258 {
259 ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
260 }
261 m_oldBrush = 0;
262 if (m_oldFont)
263 {
264 ::SelectObject((HDC) dc, (HFONT) m_oldFont);
265 }
266 m_oldFont = 0;
267
268 #if wxUSE_PALETTE
269 if (m_oldPalette)
270 {
271 ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, FALSE);
272 }
273 m_oldPalette = 0;
274 #endif // wxUSE_PALETTE
275 }
276
277 m_brush = wxNullBrush;
278 m_pen = wxNullPen;
279 #if wxUSE_PALETTE
280 m_palette = wxNullPalette;
281 #endif // wxUSE_PALETTE
282 m_font = wxNullFont;
283 m_backgroundBrush = wxNullBrush;
284 m_selectedBitmap = wxNullBitmap;
285 }
286
287 // ---------------------------------------------------------------------------
288 // clipping
289 // ---------------------------------------------------------------------------
290
291 void wxDC::UpdateClipBox()
292 {
293 #ifdef __WXMICROWIN__
294 if (!GetHDC()) return;
295 #endif
296
297 RECT rect;
298 ::GetClipBox(GetHdc(), &rect);
299
300 m_clipX1 = (wxCoord) XDEV2LOG(rect.left);
301 m_clipY1 = (wxCoord) YDEV2LOG(rect.top);
302 m_clipX2 = (wxCoord) XDEV2LOG(rect.right);
303 m_clipY2 = (wxCoord) YDEV2LOG(rect.bottom);
304 }
305
306 // common part of DoSetClippingRegion() and DoSetClippingRegionAsRegion()
307 void wxDC::SetClippingHrgn(WXHRGN hrgn)
308 {
309 wxCHECK_RET( hrgn, wxT("invalid clipping region") );
310
311 #ifdef __WXMICROWIN__
312 if (!GetHdc()) return;
313 #endif // __WXMICROWIN__
314
315 // note that we combine the new clipping region with the existing one: this
316 // is compatible with what the other ports do and is the documented
317 // behaviour now (starting with 2.3.3)
318 #ifdef __WIN16__
319 RECT rectClip;
320 if ( !::GetClipBox(GetHdc(), &rectClip) )
321 return;
322
323 HRGN hrgnDest = ::CreateRectRgn(0, 0, 0, 0);
324 HRGN hrgnClipOld = ::CreateRectRgn(rectClip.left, rectClip.top,
325 rectClip.right, rectClip.bottom);
326
327 if ( ::CombineRgn(hrgnDest, hrgnClipOld, (HRGN)hrgn, RGN_AND) != ERROR )
328 {
329 ::SelectClipRgn(GetHdc(), hrgnDest);
330 }
331
332 ::DeleteObject(hrgnClipOld);
333 ::DeleteObject(hrgnDest);
334 #else // Win32
335 if ( ::ExtSelectClipRgn(GetHdc(), (HRGN)hrgn, RGN_AND) == ERROR )
336 {
337 wxLogLastError(_T("ExtSelectClipRgn"));
338
339 return;
340 }
341 #endif // Win16/32
342
343 m_clipping = TRUE;
344
345 UpdateClipBox();
346 }
347
348 void wxDC::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
349 {
350 // the region coords are always the device ones, so do the translation
351 // manually
352 //
353 // FIXME: possible +/-1 error here, to check!
354 HRGN hrgn = ::CreateRectRgn(LogicalToDeviceX(x),
355 LogicalToDeviceY(y),
356 LogicalToDeviceX(x + w),
357 LogicalToDeviceY(y + h));
358 if ( !hrgn )
359 {
360 wxLogLastError(_T("CreateRectRgn"));
361 }
362 else
363 {
364 SetClippingHrgn((WXHRGN)hrgn);
365
366 ::DeleteObject(hrgn);
367 }
368 }
369
370 void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
371 {
372 SetClippingHrgn(region.GetHRGN());
373 }
374
375 void wxDC::DestroyClippingRegion()
376 {
377 #ifdef __WXMICROWIN__
378 if (!GetHDC()) return;
379 #endif
380
381 if (m_clipping && m_hDC)
382 {
383 // TODO: this should restore the previous clipping region,
384 // so that OnPaint processing works correctly, and the update
385 // clipping region doesn't get destroyed after the first
386 // DestroyClippingRegion.
387 HRGN rgn = CreateRectRgn(0, 0, 32000, 32000);
388 ::SelectClipRgn(GetHdc(), rgn);
389 ::DeleteObject(rgn);
390 }
391
392 m_clipping = FALSE;
393 }
394
395 // ---------------------------------------------------------------------------
396 // query capabilities
397 // ---------------------------------------------------------------------------
398
399 bool wxDC::CanDrawBitmap() const
400 {
401 return TRUE;
402 }
403
404 bool wxDC::CanGetTextExtent() const
405 {
406 #ifdef __WXMICROWIN__
407 // TODO Extend MicroWindows' GetDeviceCaps function
408 return TRUE;
409 #else
410 // What sort of display is it?
411 int technology = ::GetDeviceCaps(GetHdc(), TECHNOLOGY);
412
413 return (technology == DT_RASDISPLAY) || (technology == DT_RASPRINTER);
414 #endif
415 }
416
417 int wxDC::GetDepth() const
418 {
419 #ifdef __WXMICROWIN__
420 if (!GetHDC()) return 16;
421 #endif
422
423 return (int)::GetDeviceCaps(GetHdc(), BITSPIXEL);
424 }
425
426 // ---------------------------------------------------------------------------
427 // drawing
428 // ---------------------------------------------------------------------------
429
430 void wxDC::Clear()
431 {
432 #ifdef __WXMICROWIN__
433 if (!GetHDC()) return;
434 #endif
435
436 RECT rect;
437 if ( m_canvas )
438 {
439 GetClientRect((HWND) m_canvas->GetHWND(), &rect);
440 }
441 else
442 {
443 // No, I think we should simply ignore this if printing on e.g.
444 // a printer DC.
445 // wxCHECK_RET( m_selectedBitmap.Ok(), wxT("this DC can't be cleared") );
446 if (!m_selectedBitmap.Ok())
447 return;
448
449 rect.left = 0; rect.top = 0;
450 rect.right = m_selectedBitmap.GetWidth();
451 rect.bottom = m_selectedBitmap.GetHeight();
452 }
453
454 (void) ::SetMapMode(GetHdc(), MM_TEXT);
455
456 DWORD colour = ::GetBkColor(GetHdc());
457 HBRUSH brush = ::CreateSolidBrush(colour);
458 ::FillRect(GetHdc(), &rect, brush);
459 ::DeleteObject(brush);
460
461 int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
462 height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
463
464 ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
465 ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
466 ::SetWindowExtEx(GetHdc(), width, height, NULL);
467 ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
468 ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
469 }
470
471 void wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
472 {
473 #ifdef __WXMICROWIN__
474 if (!GetHDC()) return;
475 #endif
476
477 if ( !::ExtFloodFill(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),
478 col.GetPixel(),
479 style == wxFLOOD_SURFACE ? FLOODFILLSURFACE
480 : FLOODFILLBORDER) )
481 {
482 // quoting from the MSDN docs:
483 //
484 // Following are some of the reasons this function might fail:
485 //
486 // * The filling could not be completed.
487 // * The specified point has the boundary color specified by the
488 // crColor parameter (if FLOODFILLBORDER was requested).
489 // * The specified point does not have the color specified by
490 // crColor (if FLOODFILLSURFACE was requested)
491 // * The point is outside the clipping region that is, it is not
492 // visible on the device.
493 //
494 wxLogLastError(wxT("ExtFloodFill"));
495 }
496
497 CalcBoundingBox(x, y);
498 }
499
500 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
501 {
502 #ifdef __WXMICROWIN__
503 if (!GetHDC()) return FALSE;
504 #endif
505
506 wxCHECK_MSG( col, FALSE, _T("NULL colour parameter in wxDC::GetPixel") );
507
508 // get the color of the pixel
509 COLORREF pixelcolor = ::GetPixel(GetHdc(), XLOG2DEV(x), YLOG2DEV(y));
510
511 wxRGBToColour(*col, pixelcolor);
512
513 return TRUE;
514 }
515
516 void wxDC::DoCrossHair(wxCoord x, wxCoord y)
517 {
518 #ifdef __WXMICROWIN__
519 if (!GetHDC()) return;
520 #endif
521
522 wxCoord x1 = x-VIEWPORT_EXTENT;
523 wxCoord y1 = y-VIEWPORT_EXTENT;
524 wxCoord x2 = x+VIEWPORT_EXTENT;
525 wxCoord y2 = y+VIEWPORT_EXTENT;
526
527 (void)MoveToEx(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y), NULL);
528 (void)LineTo(GetHdc(), XLOG2DEV(x2), YLOG2DEV(y));
529
530 (void)MoveToEx(GetHdc(), XLOG2DEV(x), YLOG2DEV(y1), NULL);
531 (void)LineTo(GetHdc(), XLOG2DEV(x), YLOG2DEV(y2));
532
533 CalcBoundingBox(x1, y1);
534 CalcBoundingBox(x2, y2);
535 }
536
537 void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
538 {
539 #ifdef __WXMICROWIN__
540 if (!GetHDC()) return;
541 #endif
542
543 (void)MoveToEx(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y1), NULL);
544 (void)LineTo(GetHdc(), XLOG2DEV(x2), YLOG2DEV(y2));
545
546 CalcBoundingBox(x1, y1);
547 CalcBoundingBox(x2, y2);
548 }
549
550 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
551 // and ending at (x2, y2)
552 void wxDC::DoDrawArc(wxCoord x1, wxCoord y1,
553 wxCoord x2, wxCoord y2,
554 wxCoord xc, wxCoord yc)
555 {
556 #ifdef __WXMICROWIN__
557 if (!GetHDC()) return;
558 #endif
559
560 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
561
562 double dx = xc - x1;
563 double dy = yc - y1;
564 double radius = (double)sqrt(dx*dx+dy*dy);
565 wxCoord r = (wxCoord)radius;
566
567 // treat the special case of full circle separately
568 if ( x1 == x2 && y1 == y2 )
569 {
570 DrawEllipse(xc - r, yc - r, 2*r, 2*r);
571 return;
572 }
573
574 wxCoord xx1 = XLOG2DEV(x1);
575 wxCoord yy1 = YLOG2DEV(y1);
576 wxCoord xx2 = XLOG2DEV(x2);
577 wxCoord yy2 = YLOG2DEV(y2);
578 wxCoord xxc = XLOG2DEV(xc);
579 wxCoord yyc = YLOG2DEV(yc);
580 wxCoord ray = (wxCoord) sqrt(double((xxc-xx1)*(xxc-xx1)+(yyc-yy1)*(yyc-yy1)));
581
582 wxCoord xxx1 = (wxCoord) (xxc-ray);
583 wxCoord yyy1 = (wxCoord) (yyc-ray);
584 wxCoord xxx2 = (wxCoord) (xxc+ray);
585 wxCoord yyy2 = (wxCoord) (yyc+ray);
586
587 if ( m_brush.Ok() && m_brush.GetStyle() != wxTRANSPARENT )
588 {
589 // Have to add 1 to bottom-right corner of rectangle
590 // to make semi-circles look right (crooked line otherwise).
591 // Unfortunately this is not a reliable method, depends
592 // on the size of shape.
593 // TODO: figure out why this happens!
594 Pie(GetHdc(),xxx1,yyy1,xxx2+1,yyy2+1, xx1,yy1,xx2,yy2);
595 }
596 else
597 {
598 Arc(GetHdc(),xxx1,yyy1,xxx2,yyy2, xx1,yy1,xx2,yy2);
599 }
600
601 CalcBoundingBox(xc - r, yc - r);
602 CalcBoundingBox(xc + r, yc + r);
603 }
604
605 void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
606 wxCoord width, wxCoord height)
607 {
608 #ifdef __WXMICROWIN__
609 if (!GetHDC()) return;
610 #endif
611
612 wxCoord x2 = x1 + width,
613 y2 = y1 + height;
614
615 #if defined(__WIN32__) && !defined(__SC__) && !defined(__WXMICROWIN__)
616 RECT rect;
617 rect.left = x1;
618 rect.top = y1;
619 rect.right = x2;
620 rect.bottom = y2;
621
622 DrawFrameControl(GetHdc(), &rect, DFC_MENU, DFCS_MENUCHECK);
623 #else // Win16
624 // In WIN16, draw a cross
625 HPEN blackPen = ::CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
626 HPEN whiteBrush = (HPEN)::GetStockObject(WHITE_BRUSH);
627 HPEN hPenOld = (HPEN)::SelectObject(GetHdc(), blackPen);
628 HPEN hBrushOld = (HPEN)::SelectObject(GetHdc(), whiteBrush);
629 ::SetROP2(GetHdc(), R2_COPYPEN);
630 Rectangle(GetHdc(), x1, y1, x2, y2);
631 MoveToEx(GetHdc(), x1, y1, NULL);
632 LineTo(GetHdc(), x2, y2);
633 MoveToEx(GetHdc(), x2, y1, NULL);
634 LineTo(GetHdc(), x1, y2);
635 ::SelectObject(GetHdc(), hPenOld);
636 ::SelectObject(GetHdc(), hBrushOld);
637 ::DeleteObject(blackPen);
638 #endif // Win32/16
639
640 CalcBoundingBox(x1, y1);
641 CalcBoundingBox(x2, y2);
642 }
643
644 void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
645 {
646 #ifdef __WXMICROWIN__
647 if (!GetHDC()) return;
648 #endif
649
650 COLORREF color = 0x00ffffff;
651 if (m_pen.Ok())
652 {
653 color = m_pen.GetColour().GetPixel();
654 }
655
656 SetPixel(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), color);
657
658 CalcBoundingBox(x, y);
659 }
660
661 void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset,int fillStyle)
662 {
663 #ifdef __WXMICROWIN__
664 if (!GetHDC()) return;
665 #endif
666
667 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
668
669 // Do things less efficiently if we have offsets
670 if (xoffset != 0 || yoffset != 0)
671 {
672 POINT *cpoints = new POINT[n];
673 int i;
674 for (i = 0; i < n; i++)
675 {
676 cpoints[i].x = (int)(points[i].x + xoffset);
677 cpoints[i].y = (int)(points[i].y + yoffset);
678
679 CalcBoundingBox(cpoints[i].x, cpoints[i].y);
680 }
681 int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
682 (void)Polygon(GetHdc(), cpoints, n);
683 SetPolyFillMode(GetHdc(),prev);
684 delete[] cpoints;
685 }
686 else
687 {
688 int i;
689 for (i = 0; i < n; i++)
690 CalcBoundingBox(points[i].x, points[i].y);
691
692 int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
693 (void)Polygon(GetHdc(), (POINT*) points, n);
694 SetPolyFillMode(GetHdc(),prev);
695 }
696 }
697
698 void wxDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
699 {
700 #ifdef __WXMICROWIN__
701 if (!GetHDC()) return;
702 #endif
703
704 // Do things less efficiently if we have offsets
705 if (xoffset != 0 || yoffset != 0)
706 {
707 POINT *cpoints = new POINT[n];
708 int i;
709 for (i = 0; i < n; i++)
710 {
711 cpoints[i].x = (int)(points[i].x + xoffset);
712 cpoints[i].y = (int)(points[i].y + yoffset);
713
714 CalcBoundingBox(cpoints[i].x, cpoints[i].y);
715 }
716 (void)Polyline(GetHdc(), cpoints, n);
717 delete[] cpoints;
718 }
719 else
720 {
721 int i;
722 for (i = 0; i < n; i++)
723 CalcBoundingBox(points[i].x, points[i].y);
724
725 (void)Polyline(GetHdc(), (POINT*) points, n);
726 }
727 }
728
729 void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
730 {
731 #ifdef __WXMICROWIN__
732 if (!GetHDC()) return;
733 #endif
734
735 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
736
737 wxCoord x2 = x + width;
738 wxCoord y2 = y + height;
739
740 if ((m_logicalFunction == wxCOPY) && (m_pen.GetStyle() == wxTRANSPARENT))
741 {
742 RECT rect;
743 rect.left = XLOG2DEV(x);
744 rect.top = YLOG2DEV(y);
745 rect.right = XLOG2DEV(x2);
746 rect.bottom = YLOG2DEV(y2);
747 (void)FillRect(GetHdc(), &rect, (HBRUSH)m_brush.GetResourceHandle() );
748 }
749 else
750 {
751 // Windows draws the filled rectangles without outline (i.e. drawn with a
752 // transparent pen) one pixel smaller in both directions and we want them
753 // to have the same size regardless of which pen is used - adjust
754
755 // I wonder if this shouldn´t be done after the LOG2DEV() conversions. RR.
756 if ( m_pen.GetStyle() == wxTRANSPARENT )
757 {
758 x2++;
759 y2++;
760 }
761
762 (void)Rectangle(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
763 }
764
765
766 CalcBoundingBox(x, y);
767 CalcBoundingBox(x2, y2);
768 }
769
770 void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
771 {
772 #ifdef __WXMICROWIN__
773 if (!GetHDC()) return;
774 #endif
775
776 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
777
778 // Now, a negative radius value is interpreted to mean
779 // 'the proportion of the smallest X or Y dimension'
780
781 if (radius < 0.0)
782 {
783 double smallest = 0.0;
784 if (width < height)
785 smallest = width;
786 else
787 smallest = height;
788 radius = (- radius * smallest);
789 }
790
791 wxCoord x2 = (x+width);
792 wxCoord y2 = (y+height);
793
794 // Windows draws the filled rectangles without outline (i.e. drawn with a
795 // transparent pen) one pixel smaller in both directions and we want them
796 // to have the same size regardless of which pen is used - adjust
797 if ( m_pen.GetStyle() == wxTRANSPARENT )
798 {
799 x2++;
800 y2++;
801 }
802
803 (void)RoundRect(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2),
804 YLOG2DEV(y2), (int) (2*XLOG2DEV(radius)), (int)( 2*YLOG2DEV(radius)));
805
806 CalcBoundingBox(x, y);
807 CalcBoundingBox(x2, y2);
808 }
809
810 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
811 {
812 #ifdef __WXMICROWIN__
813 if (!GetHDC()) return;
814 #endif
815
816 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
817
818 wxCoord x2 = (x+width);
819 wxCoord y2 = (y+height);
820
821 (void)Ellipse(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
822
823 CalcBoundingBox(x, y);
824 CalcBoundingBox(x2, y2);
825 }
826
827 // Chris Breeze 20/5/98: first implementation of DrawEllipticArc on Windows
828 void wxDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
829 {
830 #ifdef __WXMICROWIN__
831 if (!GetHDC()) return;
832 #endif
833
834 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
835
836 wxCoord x2 = x + w;
837 wxCoord y2 = y + h;
838
839 int rx1 = XLOG2DEV(x+w/2);
840 int ry1 = YLOG2DEV(y+h/2);
841 int rx2 = rx1;
842 int ry2 = ry1;
843
844 sa = DegToRad(sa);
845 ea = DegToRad(ea);
846
847 rx1 += (int)(100.0 * abs(w) * cos(sa));
848 ry1 -= (int)(100.0 * abs(h) * m_signY * sin(sa));
849 rx2 += (int)(100.0 * abs(w) * cos(ea));
850 ry2 -= (int)(100.0 * abs(h) * m_signY * sin(ea));
851
852 // draw pie with NULL_PEN first and then outline otherwise a line is
853 // drawn from the start and end points to the centre
854 HPEN hpenOld = (HPEN) ::SelectObject(GetHdc(), (HPEN) ::GetStockObject(NULL_PEN));
855 if (m_signY > 0)
856 {
857 (void)Pie(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2)+1, YLOG2DEV(y2)+1,
858 rx1, ry1, rx2, ry2);
859 }
860 else
861 {
862 (void)Pie(GetHdc(), XLOG2DEV(x), YLOG2DEV(y)-1, XLOG2DEV(x2)+1, YLOG2DEV(y2),
863 rx1, ry1-1, rx2, ry2-1);
864 }
865
866 ::SelectObject(GetHdc(), hpenOld);
867
868 (void)Arc(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2),
869 rx1, ry1, rx2, ry2);
870
871 CalcBoundingBox(x, y);
872 CalcBoundingBox(x2, y2);
873 }
874
875 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
876 {
877 #ifdef __WXMICROWIN__
878 if (!GetHDC()) return;
879 #endif
880
881 wxCHECK_RET( icon.Ok(), wxT("invalid icon in DrawIcon") );
882
883 #ifdef __WIN32__
884 ::DrawIconEx(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), GetHiconOf(icon), icon.GetWidth(), icon.GetHeight(), 0, NULL, DI_NORMAL);
885 #else
886 ::DrawIcon(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), GetHiconOf(icon));
887 #endif
888
889 CalcBoundingBox(x, y);
890 CalcBoundingBox(x + icon.GetWidth(), y + icon.GetHeight());
891 }
892
893 void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask )
894 {
895 #ifdef __WXMICROWIN__
896 if (!GetHDC()) return;
897 #endif
898
899 wxCHECK_RET( bmp.Ok(), _T("invalid bitmap in wxDC::DrawBitmap") );
900
901 int width = bmp.GetWidth(),
902 height = bmp.GetHeight();
903
904 HBITMAP hbmpMask = 0;
905
906 #if wxUSE_PALETTE
907 HPALETTE oldPal = 0;
908 #endif // wxUSE_PALETTE
909
910 if ( useMask )
911 {
912 wxMask *mask = bmp.GetMask();
913 if ( mask )
914 hbmpMask = (HBITMAP)mask->GetMaskBitmap();
915
916 if ( !hbmpMask )
917 {
918 // don't give assert here because this would break existing
919 // programs - just silently ignore useMask parameter
920 useMask = FALSE;
921 }
922 }
923 if ( useMask )
924 {
925 #ifdef __WIN32__
926 // use MaskBlt() with ROP which doesn't do anything to dst in the mask
927 // points
928 // On some systems, MaskBlt succeeds yet is much much slower
929 // than the wxWindows fall-back implementation. So we need
930 // to be able to switch this on and off at runtime.
931 bool ok = FALSE;
932 #if wxUSE_SYSTEM_OPTIONS
933 if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
934 #endif
935 {
936 HDC cdc = GetHdc();
937 HDC hdcMem = ::CreateCompatibleDC(GetHdc());
938 HGDIOBJ hOldBitmap = ::SelectObject(hdcMem, GetHbitmapOf(bmp));
939 #if wxUSE_PALETTE
940 wxPalette *pal = bmp.GetPalette();
941 if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
942 {
943 oldPal = ::SelectPalette(hdcMem, GetHpaletteOf(pal), FALSE);
944 ::RealizePalette(hdcMem);
945 }
946 #endif // wxUSE_PALETTE
947
948 ok = ::MaskBlt(cdc, x, y, width, height,
949 hdcMem, 0, 0,
950 hbmpMask, 0, 0,
951 MAKEROP4(SRCCOPY, DSTCOPY)) != 0;
952
953 #if wxUSE_PALETTE
954 if (oldPal)
955 ::SelectPalette(hdcMem, oldPal, FALSE);
956 #endif // wxUSE_PALETTE
957
958 ::SelectObject(hdcMem, hOldBitmap);
959 ::DeleteDC(hdcMem);
960 }
961
962 if ( !ok )
963 #endif // Win32
964 {
965 // Rather than reproduce wxDC::Blit, let's do it at the wxWin API
966 // level
967 wxMemoryDC memDC;
968 memDC.SelectObject(bmp);
969
970 Blit(x, y, width, height, &memDC, 0, 0, wxCOPY, useMask);
971
972 memDC.SelectObject(wxNullBitmap);
973 }
974 }
975 else // no mask, just use BitBlt()
976 {
977 HDC cdc = GetHdc();
978 HDC memdc = ::CreateCompatibleDC( cdc );
979 HBITMAP hbitmap = (HBITMAP) bmp.GetHBITMAP( );
980
981 wxASSERT_MSG( hbitmap, wxT("bitmap is ok but HBITMAP is NULL?") );
982
983 COLORREF old_textground = ::GetTextColor(GetHdc());
984 COLORREF old_background = ::GetBkColor(GetHdc());
985 if (m_textForegroundColour.Ok())
986 {
987 ::SetTextColor(GetHdc(), m_textForegroundColour.GetPixel() );
988 }
989 if (m_textBackgroundColour.Ok())
990 {
991 ::SetBkColor(GetHdc(), m_textBackgroundColour.GetPixel() );
992 }
993
994 #if wxUSE_PALETTE
995 wxPalette *pal = bmp.GetPalette();
996 if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
997 {
998 oldPal = ::SelectPalette(memdc, GetHpaletteOf(pal), FALSE);
999 ::RealizePalette(memdc);
1000 }
1001 #endif // wxUSE_PALETTE
1002
1003 HGDIOBJ hOldBitmap = ::SelectObject( memdc, hbitmap );
1004 ::BitBlt( cdc, x, y, width, height, memdc, 0, 0, SRCCOPY);
1005
1006 #if wxUSE_PALETTE
1007 if (oldPal)
1008 ::SelectPalette(memdc, oldPal, FALSE);
1009 #endif // wxUSE_PALETTE
1010
1011 ::SelectObject( memdc, hOldBitmap );
1012 ::DeleteDC( memdc );
1013
1014 ::SetTextColor(GetHdc(), old_textground);
1015 ::SetBkColor(GetHdc(), old_background);
1016 }
1017 }
1018
1019 void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
1020 {
1021 #ifdef __WXMICROWIN__
1022 if (!GetHDC()) return;
1023 #endif
1024
1025 DrawAnyText(text, x, y);
1026
1027 // update the bounding box
1028 CalcBoundingBox(x, y);
1029
1030 wxCoord w, h;
1031 GetTextExtent(text, &w, &h);
1032 CalcBoundingBox(x + w, y + h);
1033 }
1034
1035 void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
1036 {
1037 #ifdef __WXMICROWIN__
1038 if (!GetHDC()) return;
1039 #endif
1040
1041 // prepare for drawing the text
1042 if ( m_textForegroundColour.Ok() )
1043 SetTextColor(GetHdc(), m_textForegroundColour.GetPixel());
1044
1045 DWORD old_background = 0;
1046 if ( m_textBackgroundColour.Ok() )
1047 {
1048 old_background = SetBkColor(GetHdc(), m_textBackgroundColour.GetPixel() );
1049 }
1050
1051 SetBkMode(GetHdc(), m_backgroundMode == wxTRANSPARENT ? TRANSPARENT
1052 : OPAQUE);
1053
1054 if ( ::TextOut(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),
1055 text.c_str(), text.length()) == 0 )
1056 {
1057 wxLogLastError(wxT("TextOut"));
1058 }
1059
1060 // restore the old parameters (text foreground colour may be left because
1061 // it never is set to anything else, but background should remain
1062 // transparent even if we just drew an opaque string)
1063 if ( m_textBackgroundColour.Ok() )
1064 (void)SetBkColor(GetHdc(), old_background);
1065
1066 SetBkMode(GetHdc(), TRANSPARENT);
1067 }
1068
1069 void wxDC::DoDrawRotatedText(const wxString& text,
1070 wxCoord x, wxCoord y,
1071 double angle)
1072 {
1073 #ifdef __WXMICROWIN__
1074 if (!GetHDC()) return;
1075 #endif
1076
1077 // we test that we have some font because otherwise we should still use the
1078 // "else" part below to avoid that DrawRotatedText(angle = 180) and
1079 // DrawRotatedText(angle = 0) use different fonts (we can't use the default
1080 // font for drawing rotated fonts unfortunately)
1081 if ( (angle == 0.0) && m_font.Ok() )
1082 {
1083 DoDrawText(text, x, y);
1084 }
1085 #ifndef __WXMICROWIN__
1086 else
1087 {
1088 // NB: don't take DEFAULT_GUI_FONT (a.k.a. wxSYS_DEFAULT_GUI_FONT)
1089 // because it's not TrueType and so can't have non zero
1090 // orientation/escapement under Win9x
1091 wxFont font = m_font.Ok() ? m_font : *wxSWISS_FONT;
1092 HFONT hfont = (HFONT)font.GetResourceHandle();
1093 LOGFONT lf;
1094 if ( ::GetObject(hfont, sizeof(lf), &lf) == 0 )
1095 {
1096 wxLogLastError(wxT("GetObject(hfont)"));
1097 }
1098
1099 // GDI wants the angle in tenth of degree
1100 long angle10 = (long)(angle * 10);
1101 lf.lfEscapement = angle10;
1102 lf. lfOrientation = angle10;
1103
1104 hfont = ::CreateFontIndirect(&lf);
1105 if ( !hfont )
1106 {
1107 wxLogLastError(wxT("CreateFont"));
1108 }
1109 else
1110 {
1111 HFONT hfontOld = (HFONT)::SelectObject(GetHdc(), hfont);
1112
1113 DrawAnyText(text, x, y);
1114
1115 (void)::SelectObject(GetHdc(), hfontOld);
1116 (void)::DeleteObject(hfont);
1117 }
1118
1119 // call the bounding box by adding all four vertices of the rectangle
1120 // containing the text to it (simpler and probably not slower than
1121 // determining which of them is really topmost/leftmost/...)
1122 wxCoord w, h;
1123 GetTextExtent(text, &w, &h);
1124
1125 double rad = DegToRad(angle);
1126
1127 // "upper left" and "upper right"
1128 CalcBoundingBox(x, y);
1129 CalcBoundingBox(x + w*cos(rad), y - h*sin(rad));
1130
1131 // "bottom left" and "bottom right"
1132 x += (wxCoord)(h*sin(rad));
1133 y += (wxCoord)(h*cos(rad));
1134 CalcBoundingBox(x, y);
1135 CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
1136 }
1137 #endif
1138 }
1139
1140 // ---------------------------------------------------------------------------
1141 // set GDI objects
1142 // ---------------------------------------------------------------------------
1143
1144 #if wxUSE_PALETTE
1145
1146 void wxDC::DoSelectPalette(bool realize)
1147 {
1148 #ifdef __WXMICROWIN__
1149 if (!GetHDC()) return;
1150 #endif
1151
1152 // Set the old object temporarily, in case the assignment deletes an object
1153 // that's not yet selected out.
1154 if (m_oldPalette)
1155 {
1156 ::SelectPalette(GetHdc(), (HPALETTE) m_oldPalette, FALSE);
1157 m_oldPalette = 0;
1158 }
1159
1160 if (m_palette.Ok() && m_palette.GetHPALETTE())
1161 {
1162 HPALETTE oldPal = ::SelectPalette(GetHdc(), (HPALETTE) m_palette.GetHPALETTE(), FALSE);
1163 if (!m_oldPalette)
1164 m_oldPalette = (WXHPALETTE) oldPal;
1165
1166 if (realize)
1167 ::RealizePalette(GetHdc());
1168 }
1169
1170
1171 }
1172
1173 void wxDC::SetPalette(const wxPalette& palette)
1174 {
1175 if (palette.Ok()) {
1176 m_palette = palette;
1177 DoSelectPalette(true);
1178 }
1179 }
1180
1181 void wxDC::InitializePalette()
1182 {
1183 if (wxDisplayDepth() <= 8) {
1184 // look for any window or parent that has a custom palette. If any has
1185 // one then we need to use it in drawing operations
1186 wxWindow *win = m_canvas;
1187 while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
1188 if (win->HasCustomPalette()) {
1189 m_palette = win->GetPalette();
1190 m_custompalette = true;
1191 // turn on MSW translation for this palette
1192 DoSelectPalette();
1193 }
1194 else
1195 m_custompalette = false;
1196 }
1197 }
1198 #endif // wxUSE_PALETTE
1199
1200 void wxDC::SetFont(const wxFont& the_font)
1201 {
1202 #ifdef __WXMICROWIN__
1203 if (!GetHDC()) return;
1204 #endif
1205
1206 // Set the old object temporarily, in case the assignment deletes an object
1207 // that's not yet selected out.
1208 if (m_oldFont)
1209 {
1210 ::SelectObject(GetHdc(), (HFONT) m_oldFont);
1211 m_oldFont = 0;
1212 }
1213
1214 m_font = the_font;
1215
1216 if (!the_font.Ok())
1217 {
1218 if (m_oldFont)
1219 ::SelectObject(GetHdc(), (HFONT) m_oldFont);
1220 m_oldFont = 0;
1221 }
1222
1223 if (m_font.Ok() && m_font.GetResourceHandle())
1224 {
1225 HFONT f = (HFONT) ::SelectObject(GetHdc(), (HFONT) m_font.GetResourceHandle());
1226 if (f == (HFONT) NULL)
1227 {
1228 wxLogDebug(wxT("::SelectObject failed in wxDC::SetFont."));
1229 }
1230 if (!m_oldFont)
1231 m_oldFont = (WXHFONT) f;
1232 }
1233 }
1234
1235 void wxDC::SetPen(const wxPen& pen)
1236 {
1237 #ifdef __WXMICROWIN__
1238 if (!GetHDC()) return;
1239 #endif
1240
1241 // Set the old object temporarily, in case the assignment deletes an object
1242 // that's not yet selected out.
1243 if (m_oldPen)
1244 {
1245 ::SelectObject(GetHdc(), (HPEN) m_oldPen);
1246 m_oldPen = 0;
1247 }
1248
1249 m_pen = pen;
1250
1251 if (!m_pen.Ok())
1252 {
1253 if (m_oldPen)
1254 ::SelectObject(GetHdc(), (HPEN) m_oldPen);
1255 m_oldPen = 0;
1256 }
1257
1258 if (m_pen.Ok())
1259 {
1260 if (m_pen.GetResourceHandle())
1261 {
1262 HPEN p = (HPEN) ::SelectObject(GetHdc(), (HPEN)m_pen.GetResourceHandle());
1263 if (!m_oldPen)
1264 m_oldPen = (WXHPEN) p;
1265 }
1266 }
1267 }
1268
1269 void wxDC::SetBrush(const wxBrush& brush)
1270 {
1271 #ifdef __WXMICROWIN__
1272 if (!GetHDC()) return;
1273 #endif
1274
1275 // Set the old object temporarily, in case the assignment deletes an object
1276 // that's not yet selected out.
1277 if (m_oldBrush)
1278 {
1279 ::SelectObject(GetHdc(), (HBRUSH) m_oldBrush);
1280 m_oldBrush = 0;
1281 }
1282
1283 m_brush = brush;
1284
1285 if (!m_brush.Ok())
1286 {
1287 if (m_oldBrush)
1288 ::SelectObject(GetHdc(), (HBRUSH) m_oldBrush);
1289 m_oldBrush = 0;
1290 }
1291
1292 if (m_brush.Ok())
1293 {
1294 // to make sure the brush is alligned with the logical coordinates
1295 wxBitmap *stipple = m_brush.GetStipple();
1296 if ( stipple && stipple->Ok() )
1297 {
1298 #ifdef __WIN32__
1299 ::SetBrushOrgEx(GetHdc(),
1300 m_deviceOriginX % stipple->GetWidth(),
1301 m_deviceOriginY % stipple->GetHeight(),
1302 NULL); // don't need previous brush origin
1303 #else
1304 ::SetBrushOrg(GetHdc(),
1305 m_deviceOriginX % stipple->GetWidth(),
1306 m_deviceOriginY % stipple->GetHeight());
1307 #endif
1308 }
1309
1310 if ( m_brush.GetResourceHandle() )
1311 {
1312 HBRUSH b = 0;
1313 b = (HBRUSH) ::SelectObject(GetHdc(), (HBRUSH)m_brush.GetResourceHandle());
1314 if (!m_oldBrush)
1315 m_oldBrush = (WXHBRUSH) b;
1316 }
1317 }
1318 }
1319
1320 void wxDC::SetBackground(const wxBrush& brush)
1321 {
1322 #ifdef __WXMICROWIN__
1323 if (!GetHDC()) return;
1324 #endif
1325
1326 m_backgroundBrush = brush;
1327
1328 if (!m_backgroundBrush.Ok())
1329 return;
1330
1331 if (m_canvas)
1332 {
1333 bool customColours = TRUE;
1334 // If we haven't specified wxUSER_COLOURS, don't allow the panel/dialog box to
1335 // change background colours from the control-panel specified colours.
1336 if (m_canvas->IsKindOf(CLASSINFO(wxWindow)) && ((m_canvas->GetWindowStyleFlag() & wxUSER_COLOURS) != wxUSER_COLOURS))
1337 customColours = FALSE;
1338
1339 if (customColours)
1340 {
1341 if (m_backgroundBrush.GetStyle()==wxTRANSPARENT)
1342 {
1343 m_canvas->SetTransparent(TRUE);
1344 }
1345 else
1346 {
1347 // New behaviour, 10/2/99: setting the background brush of a DC
1348 // doesn't affect the window background colour. However,
1349 // I'm leaving in the transparency setting because it's needed by
1350 // various controls (e.g. wxStaticText) to determine whether to draw
1351 // transparently or not. TODO: maybe this should be a new function
1352 // wxWindow::SetTransparency(). Should that apply to the child itself, or the
1353 // parent?
1354 // m_canvas->SetBackgroundColour(m_backgroundBrush.GetColour());
1355 m_canvas->SetTransparent(FALSE);
1356 }
1357 }
1358 }
1359 COLORREF new_color = m_backgroundBrush.GetColour().GetPixel();
1360 {
1361 (void)SetBkColor(GetHdc(), new_color);
1362 }
1363 }
1364
1365 void wxDC::SetBackgroundMode(int mode)
1366 {
1367 #ifdef __WXMICROWIN__
1368 if (!GetHDC()) return;
1369 #endif
1370
1371 m_backgroundMode = mode;
1372
1373 // SetBackgroundColour now only refers to text background
1374 // and m_backgroundMode is used there
1375 }
1376
1377 void wxDC::SetLogicalFunction(int function)
1378 {
1379 #ifdef __WXMICROWIN__
1380 if (!GetHDC()) return;
1381 #endif
1382
1383 m_logicalFunction = function;
1384
1385 SetRop(m_hDC);
1386 }
1387
1388 void wxDC::SetRop(WXHDC dc)
1389 {
1390 if ( !dc || m_logicalFunction < 0 )
1391 return;
1392
1393 int rop;
1394
1395 switch (m_logicalFunction)
1396 {
1397 case wxCLEAR: rop = R2_BLACK; break;
1398 case wxXOR: rop = R2_XORPEN; break;
1399 case wxINVERT: rop = R2_NOT; break;
1400 case wxOR_REVERSE: rop = R2_MERGEPENNOT; break;
1401 case wxAND_REVERSE: rop = R2_MASKPENNOT; break;
1402 case wxCOPY: rop = R2_COPYPEN; break;
1403 case wxAND: rop = R2_MASKPEN; break;
1404 case wxAND_INVERT: rop = R2_MASKNOTPEN; break;
1405 case wxNO_OP: rop = R2_NOP; break;
1406 case wxNOR: rop = R2_NOTMERGEPEN; break;
1407 case wxEQUIV: rop = R2_NOTXORPEN; break;
1408 case wxSRC_INVERT: rop = R2_NOTCOPYPEN; break;
1409 case wxOR_INVERT: rop = R2_MERGENOTPEN; break;
1410 case wxNAND: rop = R2_NOTMASKPEN; break;
1411 case wxOR: rop = R2_MERGEPEN; break;
1412 case wxSET: rop = R2_WHITE; break;
1413
1414 default:
1415 wxFAIL_MSG( wxT("unsupported logical function") );
1416 return;
1417 }
1418
1419 SetROP2(GetHdc(), rop);
1420 }
1421
1422 bool wxDC::StartDoc(const wxString& WXUNUSED(message))
1423 {
1424 // We might be previewing, so return TRUE to let it continue.
1425 return TRUE;
1426 }
1427
1428 void wxDC::EndDoc()
1429 {
1430 }
1431
1432 void wxDC::StartPage()
1433 {
1434 }
1435
1436 void wxDC::EndPage()
1437 {
1438 }
1439
1440 // ---------------------------------------------------------------------------
1441 // text metrics
1442 // ---------------------------------------------------------------------------
1443
1444 wxCoord wxDC::GetCharHeight() const
1445 {
1446 #ifdef __WXMICROWIN__
1447 if (!GetHDC()) return 0;
1448 #endif
1449
1450 TEXTMETRIC lpTextMetric;
1451
1452 GetTextMetrics(GetHdc(), &lpTextMetric);
1453
1454 return lpTextMetric.tmHeight;
1455 }
1456
1457 wxCoord wxDC::GetCharWidth() const
1458 {
1459 #ifdef __WXMICROWIN__
1460 if (!GetHDC()) return 0;
1461 #endif
1462
1463 TEXTMETRIC lpTextMetric;
1464
1465 GetTextMetrics(GetHdc(), &lpTextMetric);
1466
1467 return lpTextMetric.tmAveCharWidth;
1468 }
1469
1470 void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
1471 wxCoord *descent, wxCoord *externalLeading,
1472 wxFont *font) const
1473 {
1474 #ifdef __WXMICROWIN__
1475 if (!GetHDC())
1476 {
1477 if (x) *x = 0;
1478 if (y) *y = 0;
1479 if (descent) *descent = 0;
1480 if (externalLeading) *externalLeading = 0;
1481 return;
1482 }
1483 #endif // __WXMICROWIN__
1484
1485 HFONT hfontOld;
1486 if ( font )
1487 {
1488 wxASSERT_MSG( font->Ok(), _T("invalid font in wxDC::GetTextExtent") );
1489
1490 hfontOld = (HFONT)::SelectObject(GetHdc(), GetHfontOf(*font));
1491 }
1492 else // don't change the font
1493 {
1494 hfontOld = 0;
1495 }
1496
1497 SIZE sizeRect;
1498 TEXTMETRIC tm;
1499
1500 GetTextExtentPoint(GetHdc(), string, string.length(), &sizeRect);
1501 GetTextMetrics(GetHdc(), &tm);
1502
1503 if (x)
1504 *x = sizeRect.cx;
1505 if (y)
1506 *y = sizeRect.cy;
1507 if (descent)
1508 *descent = tm.tmDescent;
1509 if (externalLeading)
1510 *externalLeading = tm.tmExternalLeading;
1511
1512 if ( hfontOld )
1513 {
1514 ::SelectObject(GetHdc(), hfontOld);
1515 }
1516 }
1517
1518 void wxDC::SetMapMode(int mode)
1519 {
1520 #ifdef __WXMICROWIN__
1521 if (!GetHDC()) return;
1522 #endif
1523
1524 m_mappingMode = mode;
1525
1526 if ( mode == wxMM_TEXT )
1527 {
1528 m_logicalScaleX =
1529 m_logicalScaleY = 1.0;
1530 }
1531 else // need to do some calculations
1532 {
1533 int pixel_width = ::GetDeviceCaps(GetHdc(), HORZRES),
1534 pixel_height = ::GetDeviceCaps(GetHdc(), VERTRES),
1535 mm_width = ::GetDeviceCaps(GetHdc(), HORZSIZE),
1536 mm_height = ::GetDeviceCaps(GetHdc(), VERTSIZE);
1537
1538 if ( (mm_width == 0) || (mm_height == 0) )
1539 {
1540 // we can't calculate mm2pixels[XY] then!
1541 return;
1542 }
1543
1544 double mm2pixelsX = pixel_width / mm_width,
1545 mm2pixelsY = pixel_height / mm_height;
1546
1547 switch (mode)
1548 {
1549 case wxMM_TWIPS:
1550 m_logicalScaleX = twips2mm * mm2pixelsX;
1551 m_logicalScaleY = twips2mm * mm2pixelsY;
1552 break;
1553
1554 case wxMM_POINTS:
1555 m_logicalScaleX = pt2mm * mm2pixelsX;
1556 m_logicalScaleY = pt2mm * mm2pixelsY;
1557 break;
1558
1559 case wxMM_METRIC:
1560 m_logicalScaleX = mm2pixelsX;
1561 m_logicalScaleY = mm2pixelsY;
1562 break;
1563
1564 case wxMM_LOMETRIC:
1565 m_logicalScaleX = mm2pixelsX / 10.0;
1566 m_logicalScaleY = mm2pixelsY / 10.0;
1567 break;
1568
1569 default:
1570 wxFAIL_MSG( _T("unknown mapping mode in SetMapMode") );
1571 }
1572 }
1573
1574 // VZ: it seems very wasteful to always use MM_ANISOTROPIC when in 99% of
1575 // cases we could do with MM_TEXT and in the remaining 0.9% with
1576 // MM_ISOTROPIC (TODO!)
1577 ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
1578
1579 int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
1580 height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
1581
1582 ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
1583 ::SetWindowExtEx(GetHdc(), width, height, NULL);
1584
1585 ::SetViewportOrgEx(GetHdc(), m_deviceOriginX, m_deviceOriginY, NULL);
1586 ::SetWindowOrgEx(GetHdc(), m_logicalOriginX, m_logicalOriginY, NULL);
1587 }
1588
1589 void wxDC::SetUserScale(double x, double y)
1590 {
1591 #ifdef __WXMICROWIN__
1592 if (!GetHDC()) return;
1593 #endif
1594
1595 if ( x == m_userScaleX && y == m_userScaleY )
1596 return;
1597
1598 m_userScaleX = x;
1599 m_userScaleY = y;
1600
1601 SetMapMode(m_mappingMode);
1602 }
1603
1604 void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
1605 {
1606 #ifdef __WXMICROWIN__
1607 if (!GetHDC()) return;
1608 #endif
1609
1610 int signX = xLeftRight ? 1 : -1,
1611 signY = yBottomUp ? -1 : 1;
1612
1613 if ( signX != m_signX || signY != m_signY )
1614 {
1615 m_signX = signX;
1616 m_signY = signY;
1617
1618 SetMapMode(m_mappingMode);
1619 }
1620 }
1621
1622 void wxDC::SetSystemScale(double x, double y)
1623 {
1624 #ifdef __WXMICROWIN__
1625 if (!GetHDC()) return;
1626 #endif
1627
1628 if ( x == m_scaleX && y == m_scaleY )
1629 return;
1630
1631 m_scaleX = x;
1632 m_scaleY = y;
1633
1634 SetMapMode(m_mappingMode);
1635 }
1636
1637 void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
1638 {
1639 #ifdef __WXMICROWIN__
1640 if (!GetHDC()) return;
1641 #endif
1642
1643 if ( x == m_logicalOriginX && y == m_logicalOriginY )
1644 return;
1645
1646 m_logicalOriginX = x;
1647 m_logicalOriginY = y;
1648
1649 ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
1650 }
1651
1652 void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
1653 {
1654 #ifdef __WXMICROWIN__
1655 if (!GetHDC()) return;
1656 #endif
1657
1658 if ( x == m_deviceOriginX && y == m_deviceOriginY )
1659 return;
1660
1661 m_deviceOriginX = x;
1662 m_deviceOriginY = y;
1663
1664 ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
1665 }
1666
1667 // ---------------------------------------------------------------------------
1668 // coordinates transformations
1669 // ---------------------------------------------------------------------------
1670
1671 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
1672 {
1673 return DeviceToLogicalXRel(x - m_deviceOriginX)*m_signX + m_logicalOriginX;
1674 }
1675
1676 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
1677 {
1678 // axis orientation is not taken into account for conversion of a distance
1679 return (wxCoord)(x / (m_logicalScaleX*m_userScaleX*m_scaleX));
1680 }
1681
1682 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
1683 {
1684 return DeviceToLogicalYRel(y - m_deviceOriginY)*m_signY + m_logicalOriginY;
1685 }
1686
1687 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
1688 {
1689 // axis orientation is not taken into account for conversion of a distance
1690 return (wxCoord)( y / (m_logicalScaleY*m_userScaleY*m_scaleY));
1691 }
1692
1693 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
1694 {
1695 return LogicalToDeviceXRel(x - m_logicalOriginX)*m_signX + m_deviceOriginX;
1696 }
1697
1698 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
1699 {
1700 // axis orientation is not taken into account for conversion of a distance
1701 return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_scaleX);
1702 }
1703
1704 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
1705 {
1706 return LogicalToDeviceYRel(y - m_logicalOriginY)*m_signY + m_deviceOriginY;
1707 }
1708
1709 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
1710 {
1711 // axis orientation is not taken into account for conversion of a distance
1712 return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_scaleY);
1713 }
1714
1715 // ---------------------------------------------------------------------------
1716 // bit blit
1717 // ---------------------------------------------------------------------------
1718
1719 bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
1720 wxCoord width, wxCoord height,
1721 wxDC *source, wxCoord xsrc, wxCoord ysrc,
1722 int rop, bool useMask,
1723 wxCoord xsrcMask, wxCoord ysrcMask)
1724 {
1725 #ifdef __WXMICROWIN__
1726 if (!GetHDC()) return FALSE;
1727 #endif
1728
1729 wxMask *mask = NULL;
1730 if ( useMask )
1731 {
1732 const wxBitmap& bmp = source->m_selectedBitmap;
1733 mask = bmp.GetMask();
1734
1735 if ( !(bmp.Ok() && mask && mask->GetMaskBitmap()) )
1736 {
1737 // don't give assert here because this would break existing
1738 // programs - just silently ignore useMask parameter
1739 useMask = FALSE;
1740 }
1741 }
1742
1743 if (xsrcMask == -1 && ysrcMask == -1)
1744 {
1745 xsrcMask = xsrc; ysrcMask = ysrc;
1746 }
1747
1748 COLORREF old_textground = ::GetTextColor(GetHdc());
1749 COLORREF old_background = ::GetBkColor(GetHdc());
1750 if (m_textForegroundColour.Ok())
1751 {
1752 ::SetTextColor(GetHdc(), m_textForegroundColour.GetPixel() );
1753 }
1754 if (m_textBackgroundColour.Ok())
1755 {
1756 ::SetBkColor(GetHdc(), m_textBackgroundColour.GetPixel() );
1757 }
1758
1759 DWORD dwRop = SRCCOPY;
1760 switch (rop)
1761 {
1762 case wxXOR: dwRop = SRCINVERT; break;
1763 case wxINVERT: dwRop = DSTINVERT; break;
1764 case wxOR_REVERSE: dwRop = 0x00DD0228; break;
1765 case wxAND_REVERSE: dwRop = SRCERASE; break;
1766 case wxCLEAR: dwRop = BLACKNESS; break;
1767 case wxSET: dwRop = WHITENESS; break;
1768 case wxOR_INVERT: dwRop = MERGEPAINT; break;
1769 case wxAND: dwRop = SRCAND; break;
1770 case wxOR: dwRop = SRCPAINT; break;
1771 case wxEQUIV: dwRop = 0x00990066; break;
1772 case wxNAND: dwRop = 0x007700E6; break;
1773 case wxAND_INVERT: dwRop = 0x00220326; break;
1774 case wxCOPY: dwRop = SRCCOPY; break;
1775 case wxNO_OP: dwRop = DSTCOPY; break;
1776 case wxSRC_INVERT: dwRop = NOTSRCCOPY; break;
1777 case wxNOR: dwRop = NOTSRCCOPY; break;
1778 default:
1779 wxFAIL_MSG( wxT("unsupported logical function") );
1780 return FALSE;
1781 }
1782
1783 bool success = FALSE;
1784
1785 if (useMask)
1786 {
1787 #ifdef __WIN32__
1788 // we want the part of the image corresponding to the mask to be
1789 // transparent, so use "DSTCOPY" ROP for the mask points (the usual
1790 // meaning of fg and bg is inverted which corresponds to wxWin notion
1791 // of the mask which is also contrary to the Windows one)
1792
1793 // On some systems, MaskBlt succeeds yet is much much slower
1794 // than the wxWindows fall-back implementation. So we need
1795 // to be able to switch this on and off at runtime.
1796 #if wxUSE_SYSTEM_OPTIONS
1797 if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
1798 #endif
1799 {
1800 success = ::MaskBlt(GetHdc(), xdest, ydest, width, height,
1801 GetHdcOf(*source), xsrc, ysrc,
1802 (HBITMAP)mask->GetMaskBitmap(), xsrcMask, ysrcMask,
1803 MAKEROP4(dwRop, DSTCOPY)) != 0;
1804 }
1805
1806 if ( !success )
1807 #endif // Win32
1808 {
1809 // Blit bitmap with mask
1810 HDC dc_mask ;
1811 HDC dc_buffer ;
1812 HBITMAP buffer_bmap ;
1813
1814 #if wxUSE_DC_CACHEING
1815 // create a temp buffer bitmap and DCs to access it and the mask
1816 wxDCCacheEntry* dcCacheEntry1 = FindDCInCache(NULL, source->GetHDC());
1817 dc_mask = (HDC) dcCacheEntry1->m_dc;
1818
1819 wxDCCacheEntry* dcCacheEntry2 = FindDCInCache(dcCacheEntry1, GetHDC());
1820 dc_buffer = (HDC) dcCacheEntry2->m_dc;
1821
1822 wxDCCacheEntry* bitmapCacheEntry = FindBitmapInCache(GetHDC(),
1823 width, height);
1824
1825 buffer_bmap = (HBITMAP) bitmapCacheEntry->m_bitmap;
1826 #else // !wxUSE_DC_CACHEING
1827 // create a temp buffer bitmap and DCs to access it and the mask
1828 dc_mask = ::CreateCompatibleDC(GetHdcOf(*source));
1829 dc_buffer = ::CreateCompatibleDC(GetHdc());
1830 buffer_bmap = ::CreateCompatibleBitmap(GetHdc(), width, height);
1831 #endif // wxUSE_DC_CACHEING/!wxUSE_DC_CACHEING
1832 HGDIOBJ hOldMaskBitmap = ::SelectObject(dc_mask, (HBITMAP) mask->GetMaskBitmap());
1833 HGDIOBJ hOldBufferBitmap = ::SelectObject(dc_buffer, buffer_bmap);
1834
1835 // copy dest to buffer
1836 if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
1837 GetHdc(), xdest, ydest, SRCCOPY) )
1838 {
1839 wxLogLastError(wxT("BitBlt"));
1840 }
1841
1842 // copy src to buffer using selected raster op
1843 if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
1844 GetHdcOf(*source), xsrc, ysrc, dwRop) )
1845 {
1846 wxLogLastError(wxT("BitBlt"));
1847 }
1848
1849 // set masked area in buffer to BLACK (pixel value 0)
1850 COLORREF prevBkCol = ::SetBkColor(GetHdc(), RGB(255, 255, 255));
1851 COLORREF prevCol = ::SetTextColor(GetHdc(), RGB(0, 0, 0));
1852 if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
1853 dc_mask, xsrcMask, ysrcMask, SRCAND) )
1854 {
1855 wxLogLastError(wxT("BitBlt"));
1856 }
1857
1858 // set unmasked area in dest to BLACK
1859 ::SetBkColor(GetHdc(), RGB(0, 0, 0));
1860 ::SetTextColor(GetHdc(), RGB(255, 255, 255));
1861 if ( !::BitBlt(GetHdc(), xdest, ydest, (int)width, (int)height,
1862 dc_mask, xsrcMask, ysrcMask, SRCAND) )
1863 {
1864 wxLogLastError(wxT("BitBlt"));
1865 }
1866 ::SetBkColor(GetHdc(), prevBkCol); // restore colours to original values
1867 ::SetTextColor(GetHdc(), prevCol);
1868
1869 // OR buffer to dest
1870 success = ::BitBlt(GetHdc(), xdest, ydest,
1871 (int)width, (int)height,
1872 dc_buffer, 0, 0, SRCPAINT) != 0;
1873 if ( !success )
1874 {
1875 wxLogLastError(wxT("BitBlt"));
1876 }
1877
1878 // tidy up temporary DCs and bitmap
1879 ::SelectObject(dc_mask, hOldMaskBitmap);
1880 ::SelectObject(dc_buffer, hOldBufferBitmap);
1881
1882 #if !wxUSE_DC_CACHEING
1883 {
1884 ::DeleteDC(dc_mask);
1885 ::DeleteDC(dc_buffer);
1886 ::DeleteObject(buffer_bmap);
1887 }
1888 #endif
1889 }
1890 }
1891 else // no mask, just BitBlt() it
1892 {
1893 success = ::BitBlt(GetHdc(), xdest, ydest,
1894 (int)width, (int)height,
1895 GetHdcOf(*source), xsrc, ysrc, dwRop) != 0;
1896 if ( !success )
1897 {
1898 wxLogLastError(wxT("BitBlt"));
1899 }
1900 }
1901 ::SetTextColor(GetHdc(), old_textground);
1902 ::SetBkColor(GetHdc(), old_background);
1903
1904 return success;
1905 }
1906
1907 void wxDC::DoGetSize(int *w, int *h) const
1908 {
1909 #ifdef __WXMICROWIN__
1910 if (!GetHDC()) return;
1911 #endif
1912
1913 if ( w ) *w = ::GetDeviceCaps(GetHdc(), HORZRES);
1914 if ( h ) *h = ::GetDeviceCaps(GetHdc(), VERTRES);
1915 }
1916
1917 void wxDC::DoGetSizeMM(int *w, int *h) const
1918 {
1919 #ifdef __WXMICROWIN__
1920 if (!GetHDC()) return;
1921 #endif
1922
1923 if ( w ) *w = ::GetDeviceCaps(GetHdc(), HORZSIZE);
1924 if ( h ) *h = ::GetDeviceCaps(GetHdc(), VERTSIZE);
1925 }
1926
1927 wxSize wxDC::GetPPI() const
1928 {
1929 #ifdef __WXMICROWIN__
1930 if (!GetHDC()) return wxSize();
1931 #endif
1932
1933 int x = ::GetDeviceCaps(GetHdc(), LOGPIXELSX);
1934 int y = ::GetDeviceCaps(GetHdc(), LOGPIXELSY);
1935
1936 return wxSize(x, y);
1937 }
1938
1939 // For use by wxWindows only, unless custom units are required.
1940 void wxDC::SetLogicalScale(double x, double y)
1941 {
1942 #ifdef __WXMICROWIN__
1943 if (!GetHDC()) return;
1944 #endif
1945
1946 m_logicalScaleX = x;
1947 m_logicalScaleY = y;
1948 }
1949
1950 #if WXWIN_COMPATIBILITY
1951 void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
1952 float *descent, float *externalLeading,
1953 wxFont *theFont, bool use16bit) const
1954 {
1955 #ifdef __WXMICROWIN__
1956 if (!GetHDC()) return;
1957 #endif
1958
1959 wxCoord x1, y1, descent1, externalLeading1;
1960 GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
1961 *x = x1; *y = y1;
1962 if (descent)
1963 *descent = descent1;
1964 if (externalLeading)
1965 *externalLeading = externalLeading1;
1966 }
1967 #endif
1968
1969 #if wxUSE_DC_CACHEING
1970
1971 /*
1972 * This implementation is a bit ugly and uses the old-fashioned wxList class, so I will
1973 * improve it in due course, either using arrays, or simply storing pointers to one
1974 * entry for the bitmap, and two for the DCs. -- JACS
1975 */
1976
1977 wxList wxDC::sm_bitmapCache;
1978 wxList wxDC::sm_dcCache;
1979
1980 wxDCCacheEntry::wxDCCacheEntry(WXHBITMAP hBitmap, int w, int h, int depth)
1981 {
1982 m_bitmap = hBitmap;
1983 m_dc = 0;
1984 m_width = w;
1985 m_height = h;
1986 m_depth = depth;
1987 }
1988
1989 wxDCCacheEntry::wxDCCacheEntry(WXHDC hDC, int depth)
1990 {
1991 m_bitmap = 0;
1992 m_dc = hDC;
1993 m_width = 0;
1994 m_height = 0;
1995 m_depth = depth;
1996 }
1997
1998 wxDCCacheEntry::~wxDCCacheEntry()
1999 {
2000 if (m_bitmap)
2001 ::DeleteObject((HBITMAP) m_bitmap);
2002 if (m_dc)
2003 ::DeleteDC((HDC) m_dc);
2004 }
2005
2006 wxDCCacheEntry* wxDC::FindBitmapInCache(WXHDC dc, int w, int h)
2007 {
2008 int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
2009 wxNode* node = sm_bitmapCache.First();
2010 while (node)
2011 {
2012 wxDCCacheEntry* entry = (wxDCCacheEntry*) node->Data();
2013
2014 if (entry->m_depth == depth)
2015 {
2016 if (entry->m_width < w || entry->m_height < h)
2017 {
2018 ::DeleteObject((HBITMAP) entry->m_bitmap);
2019 entry->m_bitmap = (WXHBITMAP) ::CreateCompatibleBitmap((HDC) dc, w, h);
2020 if ( !entry->m_bitmap)
2021 {
2022 wxLogLastError(wxT("CreateCompatibleBitmap"));
2023 }
2024 entry->m_width = w; entry->m_height = h;
2025 return entry;
2026 }
2027 return entry;
2028 }
2029
2030 node = node->Next();
2031 }
2032 WXHBITMAP hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap((HDC) dc, w, h);
2033 if ( !hBitmap)
2034 {
2035 wxLogLastError(wxT("CreateCompatibleBitmap"));
2036 }
2037 wxDCCacheEntry* entry = new wxDCCacheEntry(hBitmap, w, h, depth);
2038 AddToBitmapCache(entry);
2039 return entry;
2040 }
2041
2042 wxDCCacheEntry* wxDC::FindDCInCache(wxDCCacheEntry* notThis, WXHDC dc)
2043 {
2044 int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
2045 wxNode* node = sm_dcCache.First();
2046 while (node)
2047 {
2048 wxDCCacheEntry* entry = (wxDCCacheEntry*) node->Data();
2049
2050 // Don't return the same one as we already have
2051 if (!notThis || (notThis != entry))
2052 {
2053 if (entry->m_depth == depth)
2054 {
2055 return entry;
2056 }
2057 }
2058
2059 node = node->Next();
2060 }
2061 WXHDC hDC = (WXHDC) ::CreateCompatibleDC((HDC) dc);
2062 if ( !hDC)
2063 {
2064 wxLogLastError(wxT("CreateCompatibleDC"));
2065 }
2066 wxDCCacheEntry* entry = new wxDCCacheEntry(hDC, depth);
2067 AddToDCCache(entry);
2068 return entry;
2069 }
2070
2071 void wxDC::AddToBitmapCache(wxDCCacheEntry* entry)
2072 {
2073 sm_bitmapCache.Append(entry);
2074 }
2075
2076 void wxDC::AddToDCCache(wxDCCacheEntry* entry)
2077 {
2078 sm_dcCache.Append(entry);
2079 }
2080
2081 void wxDC::ClearCache()
2082 {
2083 sm_bitmapCache.DeleteContents(TRUE);
2084 sm_bitmapCache.Clear();
2085 sm_bitmapCache.DeleteContents(FALSE);
2086 sm_dcCache.DeleteContents(TRUE);
2087 sm_dcCache.Clear();
2088 sm_dcCache.DeleteContents(FALSE);
2089 }
2090
2091 // Clean up cache at app exit
2092 class wxDCModule : public wxModule
2093 {
2094 public:
2095 virtual bool OnInit() { return TRUE; }
2096 virtual void OnExit() { wxDC::ClearCache(); }
2097
2098 private:
2099 DECLARE_DYNAMIC_CLASS(wxDCModule)
2100 };
2101
2102 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2103
2104 #endif
2105 // wxUSE_DC_CACHEING
2106
wxWidgets (Impactor)