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