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