]> 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
* SPACE -> TAB in filelist.txt
[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::SetPalette(const wxPalette& palette)
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 m_palette = palette;
1161
1162 if (!m_palette.Ok())
1163 {
1164 // Setting a NULL colourmap is a way of restoring
1165 // the original colourmap
1166 if (m_oldPalette)
1167 {
1168 ::SelectPalette(GetHdc(), (HPALETTE) m_oldPalette, FALSE);
1169 m_oldPalette = 0;
1170 }
1171
1172 return;
1173 }
1174
1175 if (m_palette.Ok() && m_palette.GetHPALETTE())
1176 {
1177 HPALETTE oldPal = ::SelectPalette(GetHdc(), (HPALETTE) m_palette.GetHPALETTE(), FALSE);
1178 if (!m_oldPalette)
1179 m_oldPalette = (WXHPALETTE) oldPal;
1180
1181 ::RealizePalette(GetHdc());
1182 }
1183 }
1184
1185 #endif // wxUSE_PALETTE
1186
1187 void wxDC::SetFont(const wxFont& the_font)
1188 {
1189 #ifdef __WXMICROWIN__
1190 if (!GetHDC()) return;
1191 #endif
1192
1193 // Set the old object temporarily, in case the assignment deletes an object
1194 // that's not yet selected out.
1195 if (m_oldFont)
1196 {
1197 ::SelectObject(GetHdc(), (HFONT) m_oldFont);
1198 m_oldFont = 0;
1199 }
1200
1201 m_font = the_font;
1202
1203 if (!the_font.Ok())
1204 {
1205 if (m_oldFont)
1206 ::SelectObject(GetHdc(), (HFONT) m_oldFont);
1207 m_oldFont = 0;
1208 }
1209
1210 if (m_font.Ok() && m_font.GetResourceHandle())
1211 {
1212 HFONT f = (HFONT) ::SelectObject(GetHdc(), (HFONT) m_font.GetResourceHandle());
1213 if (f == (HFONT) NULL)
1214 {
1215 wxLogDebug(wxT("::SelectObject failed in wxDC::SetFont."));
1216 }
1217 if (!m_oldFont)
1218 m_oldFont = (WXHFONT) f;
1219 }
1220 }
1221
1222 void wxDC::SetPen(const wxPen& pen)
1223 {
1224 #ifdef __WXMICROWIN__
1225 if (!GetHDC()) return;
1226 #endif
1227
1228 // Set the old object temporarily, in case the assignment deletes an object
1229 // that's not yet selected out.
1230 if (m_oldPen)
1231 {
1232 ::SelectObject(GetHdc(), (HPEN) m_oldPen);
1233 m_oldPen = 0;
1234 }
1235
1236 m_pen = pen;
1237
1238 if (!m_pen.Ok())
1239 {
1240 if (m_oldPen)
1241 ::SelectObject(GetHdc(), (HPEN) m_oldPen);
1242 m_oldPen = 0;
1243 }
1244
1245 if (m_pen.Ok())
1246 {
1247 if (m_pen.GetResourceHandle())
1248 {
1249 HPEN p = (HPEN) ::SelectObject(GetHdc(), (HPEN)m_pen.GetResourceHandle());
1250 if (!m_oldPen)
1251 m_oldPen = (WXHPEN) p;
1252 }
1253 }
1254 }
1255
1256 void wxDC::SetBrush(const wxBrush& brush)
1257 {
1258 #ifdef __WXMICROWIN__
1259 if (!GetHDC()) return;
1260 #endif
1261
1262 // Set the old object temporarily, in case the assignment deletes an object
1263 // that's not yet selected out.
1264 if (m_oldBrush)
1265 {
1266 ::SelectObject(GetHdc(), (HBRUSH) m_oldBrush);
1267 m_oldBrush = 0;
1268 }
1269
1270 m_brush = brush;
1271
1272 if (!m_brush.Ok())
1273 {
1274 if (m_oldBrush)
1275 ::SelectObject(GetHdc(), (HBRUSH) m_oldBrush);
1276 m_oldBrush = 0;
1277 }
1278
1279 if (m_brush.Ok())
1280 {
1281 // to make sure the brush is alligned with the logical coordinates
1282 wxBitmap *stipple = m_brush.GetStipple();
1283 if ( stipple && stipple->Ok() )
1284 {
1285 #ifdef __WIN32__
1286 ::SetBrushOrgEx(GetHdc(),
1287 m_deviceOriginX % stipple->GetWidth(),
1288 m_deviceOriginY % stipple->GetHeight(),
1289 NULL); // don't need previous brush origin
1290 #else
1291 ::SetBrushOrg(GetHdc(),
1292 m_deviceOriginX % stipple->GetWidth(),
1293 m_deviceOriginY % stipple->GetHeight());
1294 #endif
1295 }
1296
1297 if ( m_brush.GetResourceHandle() )
1298 {
1299 HBRUSH b = 0;
1300 b = (HBRUSH) ::SelectObject(GetHdc(), (HBRUSH)m_brush.GetResourceHandle());
1301 if (!m_oldBrush)
1302 m_oldBrush = (WXHBRUSH) b;
1303 }
1304 }
1305 }
1306
1307 void wxDC::SetBackground(const wxBrush& brush)
1308 {
1309 #ifdef __WXMICROWIN__
1310 if (!GetHDC()) return;
1311 #endif
1312
1313 m_backgroundBrush = brush;
1314
1315 if (!m_backgroundBrush.Ok())
1316 return;
1317
1318 if (m_canvas)
1319 {
1320 bool customColours = TRUE;
1321 // If we haven't specified wxUSER_COLOURS, don't allow the panel/dialog box to
1322 // change background colours from the control-panel specified colours.
1323 if (m_canvas->IsKindOf(CLASSINFO(wxWindow)) && ((m_canvas->GetWindowStyleFlag() & wxUSER_COLOURS) != wxUSER_COLOURS))
1324 customColours = FALSE;
1325
1326 if (customColours)
1327 {
1328 if (m_backgroundBrush.GetStyle()==wxTRANSPARENT)
1329 {
1330 m_canvas->SetTransparent(TRUE);
1331 }
1332 else
1333 {
1334 // New behaviour, 10/2/99: setting the background brush of a DC
1335 // doesn't affect the window background colour. However,
1336 // I'm leaving in the transparency setting because it's needed by
1337 // various controls (e.g. wxStaticText) to determine whether to draw
1338 // transparently or not. TODO: maybe this should be a new function
1339 // wxWindow::SetTransparency(). Should that apply to the child itself, or the
1340 // parent?
1341 // m_canvas->SetBackgroundColour(m_backgroundBrush.GetColour());
1342 m_canvas->SetTransparent(FALSE);
1343 }
1344 }
1345 }
1346 COLORREF new_color = m_backgroundBrush.GetColour().GetPixel();
1347 {
1348 (void)SetBkColor(GetHdc(), new_color);
1349 }
1350 }
1351
1352 void wxDC::SetBackgroundMode(int mode)
1353 {
1354 #ifdef __WXMICROWIN__
1355 if (!GetHDC()) return;
1356 #endif
1357
1358 m_backgroundMode = mode;
1359
1360 // SetBackgroundColour now only refers to text background
1361 // and m_backgroundMode is used there
1362 }
1363
1364 void wxDC::SetLogicalFunction(int function)
1365 {
1366 #ifdef __WXMICROWIN__
1367 if (!GetHDC()) return;
1368 #endif
1369
1370 m_logicalFunction = function;
1371
1372 SetRop(m_hDC);
1373 }
1374
1375 void wxDC::SetRop(WXHDC dc)
1376 {
1377 if ( !dc || m_logicalFunction < 0 )
1378 return;
1379
1380 int rop;
1381
1382 switch (m_logicalFunction)
1383 {
1384 case wxCLEAR: rop = R2_BLACK; break;
1385 case wxXOR: rop = R2_XORPEN; break;
1386 case wxINVERT: rop = R2_NOT; break;
1387 case wxOR_REVERSE: rop = R2_MERGEPENNOT; break;
1388 case wxAND_REVERSE: rop = R2_MASKPENNOT; break;
1389 case wxCOPY: rop = R2_COPYPEN; break;
1390 case wxAND: rop = R2_MASKPEN; break;
1391 case wxAND_INVERT: rop = R2_MASKNOTPEN; break;
1392 case wxNO_OP: rop = R2_NOP; break;
1393 case wxNOR: rop = R2_NOTMERGEPEN; break;
1394 case wxEQUIV: rop = R2_NOTXORPEN; break;
1395 case wxSRC_INVERT: rop = R2_NOTCOPYPEN; break;
1396 case wxOR_INVERT: rop = R2_MERGENOTPEN; break;
1397 case wxNAND: rop = R2_NOTMASKPEN; break;
1398 case wxOR: rop = R2_MERGEPEN; break;
1399 case wxSET: rop = R2_WHITE; break;
1400
1401 default:
1402 wxFAIL_MSG( wxT("unsupported logical function") );
1403 return;
1404 }
1405
1406 SetROP2(GetHdc(), rop);
1407 }
1408
1409 bool wxDC::StartDoc(const wxString& WXUNUSED(message))
1410 {
1411 // We might be previewing, so return TRUE to let it continue.
1412 return TRUE;
1413 }
1414
1415 void wxDC::EndDoc()
1416 {
1417 }
1418
1419 void wxDC::StartPage()
1420 {
1421 }
1422
1423 void wxDC::EndPage()
1424 {
1425 }
1426
1427 // ---------------------------------------------------------------------------
1428 // text metrics
1429 // ---------------------------------------------------------------------------
1430
1431 wxCoord wxDC::GetCharHeight() const
1432 {
1433 #ifdef __WXMICROWIN__
1434 if (!GetHDC()) return 0;
1435 #endif
1436
1437 TEXTMETRIC lpTextMetric;
1438
1439 GetTextMetrics(GetHdc(), &lpTextMetric);
1440
1441 return lpTextMetric.tmHeight;
1442 }
1443
1444 wxCoord wxDC::GetCharWidth() 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.tmAveCharWidth;
1455 }
1456
1457 void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
1458 wxCoord *descent, wxCoord *externalLeading,
1459 wxFont *font) const
1460 {
1461 #ifdef __WXMICROWIN__
1462 if (!GetHDC())
1463 {
1464 if (x) *x = 0;
1465 if (y) *y = 0;
1466 if (descent) *descent = 0;
1467 if (externalLeading) *externalLeading = 0;
1468 return;
1469 }
1470 #endif // __WXMICROWIN__
1471
1472 HFONT hfontOld;
1473 if ( font )
1474 {
1475 wxASSERT_MSG( font->Ok(), _T("invalid font in wxDC::GetTextExtent") );
1476
1477 hfontOld = (HFONT)::SelectObject(GetHdc(), GetHfontOf(*font));
1478 }
1479 else // don't change the font
1480 {
1481 hfontOld = 0;
1482 }
1483
1484 SIZE sizeRect;
1485 TEXTMETRIC tm;
1486
1487 GetTextExtentPoint(GetHdc(), string, string.length(), &sizeRect);
1488 GetTextMetrics(GetHdc(), &tm);
1489
1490 if (x)
1491 *x = sizeRect.cx;
1492 if (y)
1493 *y = sizeRect.cy;
1494 if (descent)
1495 *descent = tm.tmDescent;
1496 if (externalLeading)
1497 *externalLeading = tm.tmExternalLeading;
1498
1499 if ( hfontOld )
1500 {
1501 ::SelectObject(GetHdc(), hfontOld);
1502 }
1503 }
1504
1505 void wxDC::SetMapMode(int mode)
1506 {
1507 #ifdef __WXMICROWIN__
1508 if (!GetHDC()) return;
1509 #endif
1510
1511 m_mappingMode = mode;
1512
1513 if ( mode == wxMM_TEXT )
1514 {
1515 m_logicalScaleX =
1516 m_logicalScaleY = 1.0;
1517 }
1518 else // need to do some calculations
1519 {
1520 int pixel_width = ::GetDeviceCaps(GetHdc(), HORZRES),
1521 pixel_height = ::GetDeviceCaps(GetHdc(), VERTRES),
1522 mm_width = ::GetDeviceCaps(GetHdc(), HORZSIZE),
1523 mm_height = ::GetDeviceCaps(GetHdc(), VERTSIZE);
1524
1525 if ( (mm_width == 0) || (mm_height == 0) )
1526 {
1527 // we can't calculate mm2pixels[XY] then!
1528 return;
1529 }
1530
1531 double mm2pixelsX = pixel_width / mm_width,
1532 mm2pixelsY = pixel_height / mm_height;
1533
1534 switch (mode)
1535 {
1536 case wxMM_TWIPS:
1537 m_logicalScaleX = twips2mm * mm2pixelsX;
1538 m_logicalScaleY = twips2mm * mm2pixelsY;
1539 break;
1540
1541 case wxMM_POINTS:
1542 m_logicalScaleX = pt2mm * mm2pixelsX;
1543 m_logicalScaleY = pt2mm * mm2pixelsY;
1544 break;
1545
1546 case wxMM_METRIC:
1547 m_logicalScaleX = mm2pixelsX;
1548 m_logicalScaleY = mm2pixelsY;
1549 break;
1550
1551 case wxMM_LOMETRIC:
1552 m_logicalScaleX = mm2pixelsX / 10.0;
1553 m_logicalScaleY = mm2pixelsY / 10.0;
1554 break;
1555
1556 default:
1557 wxFAIL_MSG( _T("unknown mapping mode in SetMapMode") );
1558 }
1559 }
1560
1561 // VZ: it seems very wasteful to always use MM_ANISOTROPIC when in 99% of
1562 // cases we could do with MM_TEXT and in the remaining 0.9% with
1563 // MM_ISOTROPIC (TODO!)
1564 ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
1565
1566 int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
1567 height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
1568
1569 ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
1570 ::SetWindowExtEx(GetHdc(), width, height, NULL);
1571
1572 ::SetViewportOrgEx(GetHdc(), m_deviceOriginX, m_deviceOriginY, NULL);
1573 ::SetWindowOrgEx(GetHdc(), m_logicalOriginX, m_logicalOriginY, NULL);
1574 }
1575
1576 void wxDC::SetUserScale(double x, double y)
1577 {
1578 #ifdef __WXMICROWIN__
1579 if (!GetHDC()) return;
1580 #endif
1581
1582 if ( x == m_userScaleX && y == m_userScaleY )
1583 return;
1584
1585 m_userScaleX = x;
1586 m_userScaleY = y;
1587
1588 SetMapMode(m_mappingMode);
1589 }
1590
1591 void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
1592 {
1593 #ifdef __WXMICROWIN__
1594 if (!GetHDC()) return;
1595 #endif
1596
1597 int signX = xLeftRight ? 1 : -1,
1598 signY = yBottomUp ? -1 : 1;
1599
1600 if ( signX != m_signX || signY != m_signY )
1601 {
1602 m_signX = signX;
1603 m_signY = signY;
1604
1605 SetMapMode(m_mappingMode);
1606 }
1607 }
1608
1609 void wxDC::SetSystemScale(double x, double y)
1610 {
1611 #ifdef __WXMICROWIN__
1612 if (!GetHDC()) return;
1613 #endif
1614
1615 if ( x == m_scaleX && y == m_scaleY )
1616 return;
1617
1618 m_scaleX = x;
1619 m_scaleY = y;
1620
1621 SetMapMode(m_mappingMode);
1622 }
1623
1624 void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
1625 {
1626 #ifdef __WXMICROWIN__
1627 if (!GetHDC()) return;
1628 #endif
1629
1630 if ( x == m_logicalOriginX && y == m_logicalOriginY )
1631 return;
1632
1633 m_logicalOriginX = x;
1634 m_logicalOriginY = y;
1635
1636 ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
1637 }
1638
1639 void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
1640 {
1641 #ifdef __WXMICROWIN__
1642 if (!GetHDC()) return;
1643 #endif
1644
1645 if ( x == m_deviceOriginX && y == m_deviceOriginY )
1646 return;
1647
1648 m_deviceOriginX = x;
1649 m_deviceOriginY = y;
1650
1651 ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
1652 }
1653
1654 // ---------------------------------------------------------------------------
1655 // coordinates transformations
1656 // ---------------------------------------------------------------------------
1657
1658 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
1659 {
1660 return DeviceToLogicalXRel(x - m_deviceOriginX)*m_signX + m_logicalOriginX;
1661 }
1662
1663 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
1664 {
1665 // axis orientation is not taken into account for conversion of a distance
1666 return (wxCoord)(x / (m_logicalScaleX*m_userScaleX*m_scaleX));
1667 }
1668
1669 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
1670 {
1671 return DeviceToLogicalYRel(y - m_deviceOriginY)*m_signY + m_logicalOriginY;
1672 }
1673
1674 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
1675 {
1676 // axis orientation is not taken into account for conversion of a distance
1677 return (wxCoord)( y / (m_logicalScaleY*m_userScaleY*m_scaleY));
1678 }
1679
1680 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
1681 {
1682 return LogicalToDeviceXRel(x - m_logicalOriginX)*m_signX + m_deviceOriginX;
1683 }
1684
1685 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
1686 {
1687 // axis orientation is not taken into account for conversion of a distance
1688 return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_scaleX);
1689 }
1690
1691 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
1692 {
1693 return LogicalToDeviceYRel(y - m_logicalOriginY)*m_signY + m_deviceOriginY;
1694 }
1695
1696 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
1697 {
1698 // axis orientation is not taken into account for conversion of a distance
1699 return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_scaleY);
1700 }
1701
1702 // ---------------------------------------------------------------------------
1703 // bit blit
1704 // ---------------------------------------------------------------------------
1705
1706 bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
1707 wxCoord width, wxCoord height,
1708 wxDC *source, wxCoord xsrc, wxCoord ysrc,
1709 int rop, bool useMask,
1710 wxCoord xsrcMask, wxCoord ysrcMask)
1711 {
1712 #ifdef __WXMICROWIN__
1713 if (!GetHDC()) return FALSE;
1714 #endif
1715
1716 wxMask *mask = NULL;
1717 if ( useMask )
1718 {
1719 const wxBitmap& bmp = source->m_selectedBitmap;
1720 mask = bmp.GetMask();
1721
1722 if ( !(bmp.Ok() && mask && mask->GetMaskBitmap()) )
1723 {
1724 // don't give assert here because this would break existing
1725 // programs - just silently ignore useMask parameter
1726 useMask = FALSE;
1727 }
1728 }
1729
1730 if (xsrcMask == -1 && ysrcMask == -1)
1731 {
1732 xsrcMask = xsrc; ysrcMask = ysrc;
1733 }
1734
1735 COLORREF old_textground = ::GetTextColor(GetHdc());
1736 COLORREF old_background = ::GetBkColor(GetHdc());
1737 if (m_textForegroundColour.Ok())
1738 {
1739 ::SetTextColor(GetHdc(), m_textForegroundColour.GetPixel() );
1740 }
1741 if (m_textBackgroundColour.Ok())
1742 {
1743 ::SetBkColor(GetHdc(), m_textBackgroundColour.GetPixel() );
1744 }
1745
1746 DWORD dwRop = SRCCOPY;
1747 switch (rop)
1748 {
1749 case wxXOR: dwRop = SRCINVERT; break;
1750 case wxINVERT: dwRop = DSTINVERT; break;
1751 case wxOR_REVERSE: dwRop = 0x00DD0228; break;
1752 case wxAND_REVERSE: dwRop = SRCERASE; break;
1753 case wxCLEAR: dwRop = BLACKNESS; break;
1754 case wxSET: dwRop = WHITENESS; break;
1755 case wxOR_INVERT: dwRop = MERGEPAINT; break;
1756 case wxAND: dwRop = SRCAND; break;
1757 case wxOR: dwRop = SRCPAINT; break;
1758 case wxEQUIV: dwRop = 0x00990066; break;
1759 case wxNAND: dwRop = 0x007700E6; break;
1760 case wxAND_INVERT: dwRop = 0x00220326; break;
1761 case wxCOPY: dwRop = SRCCOPY; break;
1762 case wxNO_OP: dwRop = DSTCOPY; break;
1763 case wxSRC_INVERT: dwRop = NOTSRCCOPY; break;
1764 case wxNOR: dwRop = NOTSRCCOPY; break;
1765 default:
1766 wxFAIL_MSG( wxT("unsupported logical function") );
1767 return FALSE;
1768 }
1769
1770 bool success = FALSE;
1771
1772 if (useMask)
1773 {
1774 #ifdef __WIN32__
1775 // we want the part of the image corresponding to the mask to be
1776 // transparent, so use "DSTCOPY" ROP for the mask points (the usual
1777 // meaning of fg and bg is inverted which corresponds to wxWin notion
1778 // of the mask which is also contrary to the Windows one)
1779
1780 // On some systems, MaskBlt succeeds yet is much much slower
1781 // than the wxWindows fall-back implementation. So we need
1782 // to be able to switch this on and off at runtime.
1783 #if wxUSE_SYSTEM_OPTIONS
1784 if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
1785 #endif
1786 {
1787 success = ::MaskBlt(GetHdc(), xdest, ydest, width, height,
1788 GetHdcOf(*source), xsrc, ysrc,
1789 (HBITMAP)mask->GetMaskBitmap(), xsrcMask, ysrcMask,
1790 MAKEROP4(dwRop, DSTCOPY)) != 0;
1791 }
1792
1793 if ( !success )
1794 #endif // Win32
1795 {
1796 // Blit bitmap with mask
1797 HDC dc_mask ;
1798 HDC dc_buffer ;
1799 HBITMAP buffer_bmap ;
1800
1801 #if wxUSE_DC_CACHEING
1802 // create a temp buffer bitmap and DCs to access it and the mask
1803 wxDCCacheEntry* dcCacheEntry1 = FindDCInCache(NULL, source->GetHDC());
1804 dc_mask = (HDC) dcCacheEntry1->m_dc;
1805
1806 wxDCCacheEntry* dcCacheEntry2 = FindDCInCache(dcCacheEntry1, GetHDC());
1807 dc_buffer = (HDC) dcCacheEntry2->m_dc;
1808
1809 wxDCCacheEntry* bitmapCacheEntry = FindBitmapInCache(GetHDC(),
1810 width, height);
1811
1812 buffer_bmap = (HBITMAP) bitmapCacheEntry->m_bitmap;
1813 #else // !wxUSE_DC_CACHEING
1814 // create a temp buffer bitmap and DCs to access it and the mask
1815 dc_mask = ::CreateCompatibleDC(GetHdcOf(*source));
1816 dc_buffer = ::CreateCompatibleDC(GetHdc());
1817 buffer_bmap = ::CreateCompatibleBitmap(GetHdc(), width, height);
1818 #endif // wxUSE_DC_CACHEING/!wxUSE_DC_CACHEING
1819 HGDIOBJ hOldMaskBitmap = ::SelectObject(dc_mask, (HBITMAP) mask->GetMaskBitmap());
1820 HGDIOBJ hOldBufferBitmap = ::SelectObject(dc_buffer, buffer_bmap);
1821
1822 // copy dest to buffer
1823 if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
1824 GetHdc(), xdest, ydest, SRCCOPY) )
1825 {
1826 wxLogLastError(wxT("BitBlt"));
1827 }
1828
1829 // copy src to buffer using selected raster op
1830 if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
1831 GetHdcOf(*source), xsrc, ysrc, dwRop) )
1832 {
1833 wxLogLastError(wxT("BitBlt"));
1834 }
1835
1836 // set masked area in buffer to BLACK (pixel value 0)
1837 COLORREF prevBkCol = ::SetBkColor(GetHdc(), RGB(255, 255, 255));
1838 COLORREF prevCol = ::SetTextColor(GetHdc(), RGB(0, 0, 0));
1839 if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
1840 dc_mask, xsrcMask, ysrcMask, SRCAND) )
1841 {
1842 wxLogLastError(wxT("BitBlt"));
1843 }
1844
1845 // set unmasked area in dest to BLACK
1846 ::SetBkColor(GetHdc(), RGB(0, 0, 0));
1847 ::SetTextColor(GetHdc(), RGB(255, 255, 255));
1848 if ( !::BitBlt(GetHdc(), xdest, ydest, (int)width, (int)height,
1849 dc_mask, xsrcMask, ysrcMask, SRCAND) )
1850 {
1851 wxLogLastError(wxT("BitBlt"));
1852 }
1853 ::SetBkColor(GetHdc(), prevBkCol); // restore colours to original values
1854 ::SetTextColor(GetHdc(), prevCol);
1855
1856 // OR buffer to dest
1857 success = ::BitBlt(GetHdc(), xdest, ydest,
1858 (int)width, (int)height,
1859 dc_buffer, 0, 0, SRCPAINT) != 0;
1860 if ( !success )
1861 {
1862 wxLogLastError(wxT("BitBlt"));
1863 }
1864
1865 // tidy up temporary DCs and bitmap
1866 ::SelectObject(dc_mask, hOldMaskBitmap);
1867 ::SelectObject(dc_buffer, hOldBufferBitmap);
1868
1869 #if !wxUSE_DC_CACHEING
1870 {
1871 ::DeleteDC(dc_mask);
1872 ::DeleteDC(dc_buffer);
1873 ::DeleteObject(buffer_bmap);
1874 }
1875 #endif
1876 }
1877 }
1878 else // no mask, just BitBlt() it
1879 {
1880 success = ::BitBlt(GetHdc(), xdest, ydest,
1881 (int)width, (int)height,
1882 GetHdcOf(*source), xsrc, ysrc, dwRop) != 0;
1883 if ( !success )
1884 {
1885 wxLogLastError(wxT("BitBlt"));
1886 }
1887 }
1888 ::SetTextColor(GetHdc(), old_textground);
1889 ::SetBkColor(GetHdc(), old_background);
1890
1891 return success;
1892 }
1893
1894 void wxDC::DoGetSize(int *w, int *h) const
1895 {
1896 #ifdef __WXMICROWIN__
1897 if (!GetHDC()) return;
1898 #endif
1899
1900 if ( w ) *w = ::GetDeviceCaps(GetHdc(), HORZRES);
1901 if ( h ) *h = ::GetDeviceCaps(GetHdc(), VERTRES);
1902 }
1903
1904 void wxDC::DoGetSizeMM(int *w, int *h) const
1905 {
1906 #ifdef __WXMICROWIN__
1907 if (!GetHDC()) return;
1908 #endif
1909
1910 if ( w ) *w = ::GetDeviceCaps(GetHdc(), HORZSIZE);
1911 if ( h ) *h = ::GetDeviceCaps(GetHdc(), VERTSIZE);
1912 }
1913
1914 wxSize wxDC::GetPPI() const
1915 {
1916 #ifdef __WXMICROWIN__
1917 if (!GetHDC()) return wxSize();
1918 #endif
1919
1920 int x = ::GetDeviceCaps(GetHdc(), LOGPIXELSX);
1921 int y = ::GetDeviceCaps(GetHdc(), LOGPIXELSY);
1922
1923 return wxSize(x, y);
1924 }
1925
1926 // For use by wxWindows only, unless custom units are required.
1927 void wxDC::SetLogicalScale(double x, double y)
1928 {
1929 #ifdef __WXMICROWIN__
1930 if (!GetHDC()) return;
1931 #endif
1932
1933 m_logicalScaleX = x;
1934 m_logicalScaleY = y;
1935 }
1936
1937 #if WXWIN_COMPATIBILITY
1938 void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
1939 float *descent, float *externalLeading,
1940 wxFont *theFont, bool use16bit) const
1941 {
1942 #ifdef __WXMICROWIN__
1943 if (!GetHDC()) return;
1944 #endif
1945
1946 wxCoord x1, y1, descent1, externalLeading1;
1947 GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
1948 *x = x1; *y = y1;
1949 if (descent)
1950 *descent = descent1;
1951 if (externalLeading)
1952 *externalLeading = externalLeading1;
1953 }
1954 #endif
1955
1956 #if wxUSE_DC_CACHEING
1957
1958 /*
1959 * This implementation is a bit ugly and uses the old-fashioned wxList class, so I will
1960 * improve it in due course, either using arrays, or simply storing pointers to one
1961 * entry for the bitmap, and two for the DCs. -- JACS
1962 */
1963
1964 wxList wxDC::sm_bitmapCache;
1965 wxList wxDC::sm_dcCache;
1966
1967 wxDCCacheEntry::wxDCCacheEntry(WXHBITMAP hBitmap, int w, int h, int depth)
1968 {
1969 m_bitmap = hBitmap;
1970 m_dc = 0;
1971 m_width = w;
1972 m_height = h;
1973 m_depth = depth;
1974 }
1975
1976 wxDCCacheEntry::wxDCCacheEntry(WXHDC hDC, int depth)
1977 {
1978 m_bitmap = 0;
1979 m_dc = hDC;
1980 m_width = 0;
1981 m_height = 0;
1982 m_depth = depth;
1983 }
1984
1985 wxDCCacheEntry::~wxDCCacheEntry()
1986 {
1987 if (m_bitmap)
1988 ::DeleteObject((HBITMAP) m_bitmap);
1989 if (m_dc)
1990 ::DeleteDC((HDC) m_dc);
1991 }
1992
1993 wxDCCacheEntry* wxDC::FindBitmapInCache(WXHDC dc, int w, int h)
1994 {
1995 int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
1996 wxNode* node = sm_bitmapCache.First();
1997 while (node)
1998 {
1999 wxDCCacheEntry* entry = (wxDCCacheEntry*) node->Data();
2000
2001 if (entry->m_depth == depth)
2002 {
2003 if (entry->m_width < w || entry->m_height < h)
2004 {
2005 ::DeleteObject((HBITMAP) entry->m_bitmap);
2006 entry->m_bitmap = (WXHBITMAP) ::CreateCompatibleBitmap((HDC) dc, w, h);
2007 if ( !entry->m_bitmap)
2008 {
2009 wxLogLastError(wxT("CreateCompatibleBitmap"));
2010 }
2011 entry->m_width = w; entry->m_height = h;
2012 return entry;
2013 }
2014 return entry;
2015 }
2016
2017 node = node->Next();
2018 }
2019 WXHBITMAP hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap((HDC) dc, w, h);
2020 if ( !hBitmap)
2021 {
2022 wxLogLastError(wxT("CreateCompatibleBitmap"));
2023 }
2024 wxDCCacheEntry* entry = new wxDCCacheEntry(hBitmap, w, h, depth);
2025 AddToBitmapCache(entry);
2026 return entry;
2027 }
2028
2029 wxDCCacheEntry* wxDC::FindDCInCache(wxDCCacheEntry* notThis, WXHDC dc)
2030 {
2031 int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
2032 wxNode* node = sm_dcCache.First();
2033 while (node)
2034 {
2035 wxDCCacheEntry* entry = (wxDCCacheEntry*) node->Data();
2036
2037 // Don't return the same one as we already have
2038 if (!notThis || (notThis != entry))
2039 {
2040 if (entry->m_depth == depth)
2041 {
2042 return entry;
2043 }
2044 }
2045
2046 node = node->Next();
2047 }
2048 WXHDC hDC = (WXHDC) ::CreateCompatibleDC((HDC) dc);
2049 if ( !hDC)
2050 {
2051 wxLogLastError(wxT("CreateCompatibleDC"));
2052 }
2053 wxDCCacheEntry* entry = new wxDCCacheEntry(hDC, depth);
2054 AddToDCCache(entry);
2055 return entry;
2056 }
2057
2058 void wxDC::AddToBitmapCache(wxDCCacheEntry* entry)
2059 {
2060 sm_bitmapCache.Append(entry);
2061 }
2062
2063 void wxDC::AddToDCCache(wxDCCacheEntry* entry)
2064 {
2065 sm_dcCache.Append(entry);
2066 }
2067
2068 void wxDC::ClearCache()
2069 {
2070 sm_bitmapCache.DeleteContents(TRUE);
2071 sm_bitmapCache.Clear();
2072 sm_bitmapCache.DeleteContents(FALSE);
2073 sm_dcCache.DeleteContents(TRUE);
2074 sm_dcCache.Clear();
2075 sm_dcCache.DeleteContents(FALSE);
2076 }
2077
2078 // Clean up cache at app exit
2079 class wxDCModule : public wxModule
2080 {
2081 public:
2082 virtual bool OnInit() { return TRUE; }
2083 virtual void OnExit() { wxDC::ClearCache(); }
2084
2085 private:
2086 DECLARE_DYNAMIC_CLASS(wxDCModule)
2087 };
2088
2089 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2090
2091 #endif
2092 // wxUSE_DC_CACHEING
2093
wxWidgets (Impactor)