projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Applied [ 1283696 ] wxDC::GetPartialTextExtents crashes on empty strings
[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/sysopt.h"
45 #include "wx/dcprint.h"
46 #include "wx/module.h"
47 #include "wx/dynload.h"
48
49 #ifdef wxHAVE_RAW_BITMAP
50 #include "wx/rawbmp.h"
51 #endif
52
53 #include <string.h>
54
55 #include "wx/msw/wrapcdlg.h"
56 #ifndef __WIN32__
57 #include <print.h>
58 #endif
59
60 #ifndef AC_SRC_ALPHA
61 #define AC_SRC_ALPHA 1
62 #endif
63
64 /* Quaternary raster codes */
65 #ifndef MAKEROP4
66 #define MAKEROP4(fore,back) (DWORD)((((back) << 8) & 0xFF000000) | (fore))
67 #endif
68
69 // apparently with MicroWindows it is possible that HDC is 0 so we have to
70 // check for this ourselves
71 #ifdef __WXMICROWIN__
72 #define WXMICROWIN_CHECK_HDC if ( !GetHDC() ) return;
73 #define WXMICROWIN_CHECK_HDC_RET(x) if ( !GetHDC() ) return x;
74 #else
75 #define WXMICROWIN_CHECK_HDC
76 #define WXMICROWIN_CHECK_HDC_RET(x)
77 #endif
78
79 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxDCBase)
80
81 // ---------------------------------------------------------------------------
82 // constants
83 // ---------------------------------------------------------------------------
84
85 static const int VIEWPORT_EXTENT = 1000;
86
87 static const int MM_POINTS = 9;
88 static const int MM_METRIC = 10;
89
90 // ROPs which don't have standard names (see "Ternary Raster Operations" in the
91 // MSDN docs for how this and other numbers in wxDC::Blit() are obtained)
92 #define DSTCOPY 0x00AA0029 // a.k.a. NOP operation
93
94 // ----------------------------------------------------------------------------
95 // macros for logical <-> device coords conversion
96 // ----------------------------------------------------------------------------
97
98 /*
99 We currently let Windows do all the translations itself so these macros are
100 not really needed (any more) but keep them to enhance readability of the
101 code by allowing to see where are the logical and where are the device
102 coordinates used.
103 */
104
105 #ifdef __WXWINCE__
106 #define XLOG2DEV(x) ((x-m_logicalOriginX)*m_signX)
107 #define YLOG2DEV(y) ((y-m_logicalOriginY)*m_signY)
108 #define XDEV2LOG(x) ((x)*m_signX+m_logicalOriginX)
109 #define YDEV2LOG(y) ((y)*m_signY+m_logicalOriginY)
110 #else
111 #define XLOG2DEV(x) (x)
112 #define YLOG2DEV(y) (y)
113 #define XDEV2LOG(x) (x)
114 #define YDEV2LOG(y) (y)
115 #endif
116
117 // ---------------------------------------------------------------------------
118 // private functions
119 // ---------------------------------------------------------------------------
120
121 // convert degrees to radians
122 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
123
124 // call AlphaBlend() to blit contents of hdcSrc to hdcDst using alpha
125 //
126 // NB: bmpSrc is the bitmap selected in hdcSrc, it is not really needed
127 // to pass it to this function but as we already have it at the point
128 // of call anyhow we do
129 //
130 // return true if we could draw the bitmap in one way or the other, false
131 // otherwise
132 static bool AlphaBlt(HDC hdcDst,
133 int x, int y, int w, int h,
134 int srcX, int srcY, HDC hdcSrc,
135 const wxBitmap& bmpSrc);
136
137 #ifdef wxHAVE_RAW_BITMAP
138 // our (limited) AlphaBlend() replacement
139 static void
140 wxAlphaBlend(HDC hdcDst, int x, int y, int w, int h, int srcX, int srcY, const wxBitmap& bmp);
141 #endif
142
143 // ----------------------------------------------------------------------------
144 // private classes
145 // ----------------------------------------------------------------------------
146
147 // instead of duplicating the same code which sets and then restores text
148 // colours in each wxDC method working with wxSTIPPLE_MASK_OPAQUE brushes,
149 // encapsulate this in a small helper class
150
151 // wxColourChanger: changes the text colours in the ctor if required and
152 // restores them in the dtor
153 class wxColourChanger
154 {
155 public:
156 wxColourChanger(wxDC& dc);
157 ~wxColourChanger();
158
159 private:
160 wxDC& m_dc;
161
162 COLORREF m_colFgOld, m_colBgOld;
163
164 bool m_changed;
165
166 DECLARE_NO_COPY_CLASS(wxColourChanger)
167 };
168
169 // this class saves the old stretch blit mode during its life time
170 class StretchBltModeChanger
171 {
172 public:
173 StretchBltModeChanger(HDC hdc,
174 int WXUNUSED_IN_WINCE(mode))
175 : m_hdc(hdc)
176 {
177 #ifndef __WXWINCE__
178 m_modeOld = ::SetStretchBltMode(m_hdc, mode);
179 if ( !m_modeOld )
180 wxLogLastError(_T("SetStretchBltMode"));
181 #endif
182 }
183
184 ~StretchBltModeChanger()
185 {
186 #ifndef __WXWINCE__
187 if ( !::SetStretchBltMode(m_hdc, m_modeOld) )
188 wxLogLastError(_T("SetStretchBltMode"));
189 #endif
190 }
191
192 private:
193 const HDC m_hdc;
194
195 int m_modeOld;
196
197 DECLARE_NO_COPY_CLASS(StretchBltModeChanger)
198 };
199
200 // ===========================================================================
201 // implementation
202 // ===========================================================================
203
204 // ----------------------------------------------------------------------------
205 // wxColourChanger
206 // ----------------------------------------------------------------------------
207
208 wxColourChanger::wxColourChanger(wxDC& dc) : m_dc(dc)
209 {
210 const wxBrush& brush = dc.GetBrush();
211 if ( brush.Ok() && brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE )
212 {
213 HDC hdc = GetHdcOf(dc);
214 m_colFgOld = ::GetTextColor(hdc);
215 m_colBgOld = ::GetBkColor(hdc);
216
217 // note that Windows convention is opposite to wxWidgets one, this is
218 // why text colour becomes the background one and vice versa
219 const wxColour& colFg = dc.GetTextForeground();
220 if ( colFg.Ok() )
221 {
222 ::SetBkColor(hdc, colFg.GetPixel());
223 }
224
225 const wxColour& colBg = dc.GetTextBackground();
226 if ( colBg.Ok() )
227 {
228 ::SetTextColor(hdc, colBg.GetPixel());
229 }
230
231 SetBkMode(hdc,
232 dc.GetBackgroundMode() == wxTRANSPARENT ? TRANSPARENT
233 : OPAQUE);
234
235 // flag which telsl us to undo changes in the dtor
236 m_changed = true;
237 }
238 else
239 {
240 // nothing done, nothing to undo
241 m_changed = false;
242 }
243 }
244
245 wxColourChanger::~wxColourChanger()
246 {
247 if ( m_changed )
248 {
249 // restore the colours we changed
250 HDC hdc = GetHdcOf(m_dc);
251
252 ::SetBkMode(hdc, TRANSPARENT);
253 ::SetTextColor(hdc, m_colFgOld);
254 ::SetBkColor(hdc, m_colBgOld);
255 }
256 }
257
258 // ---------------------------------------------------------------------------
259 // wxDC
260 // ---------------------------------------------------------------------------
261
262 // Default constructor
263 wxDC::wxDC()
264 {
265 m_canvas = NULL;
266
267 m_oldBitmap = 0;
268 m_oldPen = 0;
269 m_oldBrush = 0;
270 m_oldFont = 0;
271 #if wxUSE_PALETTE
272 m_oldPalette = 0;
273 #endif // wxUSE_PALETTE
274
275 m_bOwnsDC = false;
276 m_hDC = 0;
277 }
278
279 wxDC::~wxDC()
280 {
281 if ( m_hDC != 0 )
282 {
283 SelectOldObjects(m_hDC);
284
285 // if we own the HDC, we delete it, otherwise we just release it
286
287 if ( m_bOwnsDC )
288 {
289 ::DeleteDC(GetHdc());
290 }
291 else // we don't own our HDC
292 {
293 if (m_canvas)
294 {
295 ::ReleaseDC(GetHwndOf(m_canvas), GetHdc());
296 }
297 else
298 {
299 // Must have been a wxScreenDC
300 ::ReleaseDC((HWND) NULL, GetHdc());
301 }
302 }
303 }
304 }
305
306 // This will select current objects out of the DC,
307 // which is what you have to do before deleting the
308 // DC.
309 void wxDC::SelectOldObjects(WXHDC dc)
310 {
311 if (dc)
312 {
313 if (m_oldBitmap)
314 {
315 ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
316 #ifdef __WXDEBUG__
317 if (m_selectedBitmap.Ok())
318 {
319 m_selectedBitmap.SetSelectedInto(NULL);
320 }
321 #endif
322 }
323 m_oldBitmap = 0;
324 if (m_oldPen)
325 {
326 ::SelectObject((HDC) dc, (HPEN) m_oldPen);
327 }
328 m_oldPen = 0;
329 if (m_oldBrush)
330 {
331 ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
332 }
333 m_oldBrush = 0;
334 if (m_oldFont)
335 {
336 ::SelectObject((HDC) dc, (HFONT) m_oldFont);
337 }
338 m_oldFont = 0;
339
340 #if wxUSE_PALETTE
341 if (m_oldPalette)
342 {
343 ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, FALSE);
344 }
345 m_oldPalette = 0;
346 #endif // wxUSE_PALETTE
347 }
348
349 m_brush = wxNullBrush;
350 m_pen = wxNullPen;
351 #if wxUSE_PALETTE
352 m_palette = wxNullPalette;
353 #endif // wxUSE_PALETTE
354 m_font = wxNullFont;
355 m_backgroundBrush = wxNullBrush;
356 m_selectedBitmap = wxNullBitmap;
357 }
358
359 // ---------------------------------------------------------------------------
360 // clipping
361 // ---------------------------------------------------------------------------
362
363 void wxDC::UpdateClipBox()
364 {
365 WXMICROWIN_CHECK_HDC
366
367 RECT rect;
368 ::GetClipBox(GetHdc(), &rect);
369
370 m_clipX1 = (wxCoord) XDEV2LOG(rect.left);
371 m_clipY1 = (wxCoord) YDEV2LOG(rect.top);
372 m_clipX2 = (wxCoord) XDEV2LOG(rect.right);
373 m_clipY2 = (wxCoord) YDEV2LOG(rect.bottom);
374 }
375
376 void
377 wxDC::DoGetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const
378 {
379 // check if we should try to retrieve the clipping region possibly not set
380 // by our SetClippingRegion() but preset by Windows:this can only happen
381 // when we're associated with an existing HDC usign SetHDC(), see there
382 if ( m_clipping && !m_clipX1 && !m_clipX2 )
383 {
384 wxDC *self = wxConstCast(this, wxDC);
385 self->UpdateClipBox();
386
387 if ( !m_clipX1 && !m_clipX2 )
388 self->m_clipping = false;
389 }
390
391 wxDCBase::DoGetClippingBox(x, y, w, h);
392 }
393
394 // common part of DoSetClippingRegion() and DoSetClippingRegionAsRegion()
395 void wxDC::SetClippingHrgn(WXHRGN hrgn)
396 {
397 wxCHECK_RET( hrgn, wxT("invalid clipping region") );
398
399 WXMICROWIN_CHECK_HDC
400
401 // note that we combine the new clipping region with the existing one: this
402 // is compatible with what the other ports do and is the documented
403 // behaviour now (starting with 2.3.3)
404 #if defined(__WXWINCE__)
405 RECT rectClip;
406 if ( !::GetClipBox(GetHdc(), &rectClip) )
407 return;
408
409 // GetClipBox returns logical coordinates, so transform to device
410 rectClip.left = LogicalToDeviceX(rectClip.left);
411 rectClip.top = LogicalToDeviceY(rectClip.top);
412 rectClip.right = LogicalToDeviceX(rectClip.right);
413 rectClip.bottom = LogicalToDeviceY(rectClip.bottom);
414
415 HRGN hrgnDest = ::CreateRectRgn(0, 0, 0, 0);
416 HRGN hrgnClipOld = ::CreateRectRgn(rectClip.left, rectClip.top,
417 rectClip.right, rectClip.bottom);
418
419 if ( ::CombineRgn(hrgnDest, hrgnClipOld, (HRGN)hrgn, RGN_AND) != ERROR )
420 {
421 ::SelectClipRgn(GetHdc(), hrgnDest);
422 }
423
424 ::DeleteObject(hrgnClipOld);
425 ::DeleteObject(hrgnDest);
426 #else // !WinCE
427 if ( ::ExtSelectClipRgn(GetHdc(), (HRGN)hrgn, RGN_AND) == ERROR )
428 {
429 wxLogLastError(_T("ExtSelectClipRgn"));
430
431 return;
432 }
433 #endif // WinCE/!WinCE
434
435 m_clipping = true;
436
437 UpdateClipBox();
438 }
439
440 void wxDC::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
441 {
442 // the region coords are always the device ones, so do the translation
443 // manually
444 //
445 // FIXME: possible +/-1 error here, to check!
446 HRGN hrgn = ::CreateRectRgn(LogicalToDeviceX(x),
447 LogicalToDeviceY(y),
448 LogicalToDeviceX(x + w),
449 LogicalToDeviceY(y + h));
450 if ( !hrgn )
451 {
452 wxLogLastError(_T("CreateRectRgn"));
453 }
454 else
455 {
456 SetClippingHrgn((WXHRGN)hrgn);
457
458 ::DeleteObject(hrgn);
459 }
460 }
461
462 void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
463 {
464 SetClippingHrgn(region.GetHRGN());
465 }
466
467 void wxDC::DestroyClippingRegion()
468 {
469 WXMICROWIN_CHECK_HDC
470
471 if (m_clipping && m_hDC)
472 {
473 // TODO: this should restore the previous clipping region,
474 // so that OnPaint processing works correctly, and the update
475 // clipping region doesn't get destroyed after the first
476 // DestroyClippingRegion.
477 HRGN rgn = CreateRectRgn(0, 0, 32000, 32000);
478 ::SelectClipRgn(GetHdc(), rgn);
479 ::DeleteObject(rgn);
480 }
481
482 wxDCBase::DestroyClippingRegion();
483 }
484
485 // ---------------------------------------------------------------------------
486 // query capabilities
487 // ---------------------------------------------------------------------------
488
489 bool wxDC::CanDrawBitmap() const
490 {
491 return true;
492 }
493
494 bool wxDC::CanGetTextExtent() const
495 {
496 #ifdef __WXMICROWIN__
497 // TODO Extend MicroWindows' GetDeviceCaps function
498 return true;
499 #else
500 // What sort of display is it?
501 int technology = ::GetDeviceCaps(GetHdc(), TECHNOLOGY);
502
503 return (technology == DT_RASDISPLAY) || (technology == DT_RASPRINTER);
504 #endif
505 }
506
507 int wxDC::GetDepth() const
508 {
509 WXMICROWIN_CHECK_HDC_RET(16)
510
511 return (int)::GetDeviceCaps(GetHdc(), BITSPIXEL);
512 }
513
514 // ---------------------------------------------------------------------------
515 // drawing
516 // ---------------------------------------------------------------------------
517
518 void wxDC::Clear()
519 {
520 WXMICROWIN_CHECK_HDC
521
522 RECT rect;
523 if ( m_canvas )
524 {
525 GetClientRect((HWND) m_canvas->GetHWND(), &rect);
526 }
527 else
528 {
529 // No, I think we should simply ignore this if printing on e.g.
530 // a printer DC.
531 // wxCHECK_RET( m_selectedBitmap.Ok(), wxT("this DC can't be cleared") );
532 if (!m_selectedBitmap.Ok())
533 return;
534
535 rect.left = 0; rect.top = 0;
536 rect.right = m_selectedBitmap.GetWidth();
537 rect.bottom = m_selectedBitmap.GetHeight();
538 }
539
540 #ifndef __WXWINCE__
541 (void) ::SetMapMode(GetHdc(), MM_TEXT);
542 #endif
543
544 DWORD colour = ::GetBkColor(GetHdc());
545 HBRUSH brush = ::CreateSolidBrush(colour);
546 ::FillRect(GetHdc(), &rect, brush);
547 ::DeleteObject(brush);
548
549 #ifndef __WXWINCE__
550 int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
551 height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
552
553 ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
554
555 ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
556 ::SetWindowExtEx(GetHdc(), width, height, NULL);
557 ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
558 ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
559 #endif
560 }
561
562 bool wxDC::DoFloodFill(wxCoord WXUNUSED_IN_WINCE(x),
563 wxCoord WXUNUSED_IN_WINCE(y),
564 const wxColour& WXUNUSED_IN_WINCE(col),
565 int WXUNUSED_IN_WINCE(style))
566 {
567 #ifdef __WXWINCE__
568 return false;
569 #else
570 WXMICROWIN_CHECK_HDC_RET(false)
571
572 bool success = (0 != ::ExtFloodFill(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),
573 col.GetPixel(),
574 style == wxFLOOD_SURFACE ? FLOODFILLSURFACE
575 : FLOODFILLBORDER) ) ;
576 if (!success)
577 {
578 // quoting from the MSDN docs:
579 //
580 // Following are some of the reasons this function might fail:
581 //
582 // * The filling could not be completed.
583 // * The specified point has the boundary color specified by the
584 // crColor parameter (if FLOODFILLBORDER was requested).
585 // * The specified point does not have the color specified by
586 // crColor (if FLOODFILLSURFACE was requested)
587 // * The point is outside the clipping region that is, it is not
588 // visible on the device.
589 //
590 wxLogLastError(wxT("ExtFloodFill"));
591 }
592
593 CalcBoundingBox(x, y);
594
595 return success;
596 #endif
597 }
598
599 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
600 {
601 WXMICROWIN_CHECK_HDC_RET(false)
602
603 wxCHECK_MSG( col, false, _T("NULL colour parameter in wxDC::GetPixel") );
604
605 // get the color of the pixel
606 COLORREF pixelcolor = ::GetPixel(GetHdc(), XLOG2DEV(x), YLOG2DEV(y));
607
608 wxRGBToColour(*col, pixelcolor);
609
610 return true;
611 }
612
613 void wxDC::DoCrossHair(wxCoord x, wxCoord y)
614 {
615 WXMICROWIN_CHECK_HDC
616
617 wxCoord x1 = x-VIEWPORT_EXTENT;
618 wxCoord y1 = y-VIEWPORT_EXTENT;
619 wxCoord x2 = x+VIEWPORT_EXTENT;
620 wxCoord y2 = y+VIEWPORT_EXTENT;
621
622 wxDrawLine(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y));
623 wxDrawLine(GetHdc(), XLOG2DEV(x), YLOG2DEV(y1), XLOG2DEV(x), YLOG2DEV(y2));
624
625 CalcBoundingBox(x1, y1);
626 CalcBoundingBox(x2, y2);
627 }
628
629 void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
630 {
631 WXMICROWIN_CHECK_HDC
632
633 wxDrawLine(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2));
634
635 CalcBoundingBox(x1, y1);
636 CalcBoundingBox(x2, y2);
637 }
638
639 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
640 // and ending at (x2, y2)
641 void wxDC::DoDrawArc(wxCoord x1, wxCoord y1,
642 wxCoord x2, wxCoord y2,
643 wxCoord xc, wxCoord yc)
644 {
645 #ifdef __WXWINCE__
646 // Slower emulation since WinCE doesn't support Pie and Arc
647 double r = sqrt( (x1-xc)*(x1-xc) + (y1-yc)*(y1-yc) );
648 double sa = acos((x1-xc)/r)/M_PI*180; // between 0 and 180
649 if( y1>yc ) sa = -sa; // below center
650 double ea = atan2(yc-y2, x2-xc)/M_PI*180;
651 DoDrawEllipticArcRot( xc-r, yc-r, 2*r, 2*r, sa, ea );
652 #else
653
654 WXMICROWIN_CHECK_HDC
655
656 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
657
658 double dx = xc - x1;
659 double dy = yc - y1;
660 double radius = (double)sqrt(dx*dx+dy*dy);
661 wxCoord r = (wxCoord)radius;
662
663 // treat the special case of full circle separately
664 if ( x1 == x2 && y1 == y2 )
665 {
666 DrawEllipse(xc - r, yc - r, 2*r, 2*r);
667 return;
668 }
669
670 wxCoord xx1 = XLOG2DEV(x1);
671 wxCoord yy1 = YLOG2DEV(y1);
672 wxCoord xx2 = XLOG2DEV(x2);
673 wxCoord yy2 = YLOG2DEV(y2);
674 wxCoord xxc = XLOG2DEV(xc);
675 wxCoord yyc = YLOG2DEV(yc);
676 wxCoord ray = (wxCoord) sqrt(double((xxc-xx1)*(xxc-xx1)+(yyc-yy1)*(yyc-yy1)));
677
678 wxCoord xxx1 = (wxCoord) (xxc-ray);
679 wxCoord yyy1 = (wxCoord) (yyc-ray);
680 wxCoord xxx2 = (wxCoord) (xxc+ray);
681 wxCoord yyy2 = (wxCoord) (yyc+ray);
682
683 if ( m_brush.Ok() && m_brush.GetStyle() != wxTRANSPARENT )
684 {
685 // Have to add 1 to bottom-right corner of rectangle
686 // to make semi-circles look right (crooked line otherwise).
687 // Unfortunately this is not a reliable method, depends
688 // on the size of shape.
689 // TODO: figure out why this happens!
690 Pie(GetHdc(),xxx1,yyy1,xxx2+1,yyy2+1, xx1,yy1,xx2,yy2);
691 }
692 else
693 {
694 Arc(GetHdc(),xxx1,yyy1,xxx2,yyy2, xx1,yy1,xx2,yy2);
695 }
696
697 CalcBoundingBox(xc - r, yc - r);
698 CalcBoundingBox(xc + r, yc + r);
699 #endif
700 }
701
702 void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
703 wxCoord width, wxCoord height)
704 {
705 WXMICROWIN_CHECK_HDC
706
707 wxCoord x2 = x1 + width,
708 y2 = y1 + height;
709
710 #if defined(__WIN32__) && !defined(__SYMANTEC__) && !defined(__WXMICROWIN__)
711 RECT rect;
712 rect.left = x1;
713 rect.top = y1;
714 rect.right = x2;
715 rect.bottom = y2;
716
717 #ifdef __WXWINCE__
718 DrawFrameControl(GetHdc(), &rect, DFC_BUTTON, DFCS_BUTTONCHECK);
719 #else
720 DrawFrameControl(GetHdc(), &rect, DFC_MENU, DFCS_MENUCHECK);
721 #endif
722 #else // Symantec-MicroWin
723 // draw a cross
724 HPEN blackPen = ::CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
725 HPEN whiteBrush = (HPEN)::GetStockObject(WHITE_BRUSH);
726 HPEN hPenOld = (HPEN)::SelectObject(GetHdc(), blackPen);
727 HPEN hBrushOld = (HPEN)::SelectObject(GetHdc(), whiteBrush);
728 ::SetROP2(GetHdc(), R2_COPYPEN);
729 Rectangle(GetHdc(), x1, y1, x2, y2);
730 MoveToEx(GetHdc(), x1, y1, NULL);
731 LineTo(GetHdc(), x2, y2);
732 MoveToEx(GetHdc(), x2, y1, NULL);
733 LineTo(GetHdc(), x1, y2);
734 ::SelectObject(GetHdc(), hPenOld);
735 ::SelectObject(GetHdc(), hBrushOld);
736 ::DeleteObject(blackPen);
737 #endif // Win32/Symantec-MicroWin
738
739 CalcBoundingBox(x1, y1);
740 CalcBoundingBox(x2, y2);
741 }
742
743 void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
744 {
745 WXMICROWIN_CHECK_HDC
746
747 COLORREF color = 0x00ffffff;
748 if (m_pen.Ok())
749 {
750 color = m_pen.GetColour().GetPixel();
751 }
752
753 SetPixel(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), color);
754
755 CalcBoundingBox(x, y);
756 }
757
758 void wxDC::DoDrawPolygon(int n,
759 wxPoint points[],
760 wxCoord xoffset,
761 wxCoord yoffset,
762 int WXUNUSED_IN_WINCE(fillStyle))
763 {
764 WXMICROWIN_CHECK_HDC
765
766 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
767
768 // Do things less efficiently if we have offsets
769 if (xoffset != 0 || yoffset != 0)
770 {
771 POINT *cpoints = new POINT[n];
772 int i;
773 for (i = 0; i < n; i++)
774 {
775 cpoints[i].x = (int)(points[i].x + xoffset);
776 cpoints[i].y = (int)(points[i].y + yoffset);
777
778 CalcBoundingBox(cpoints[i].x, cpoints[i].y);
779 }
780 #ifndef __WXWINCE__
781 int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
782 #endif
783 (void)Polygon(GetHdc(), cpoints, n);
784 #ifndef __WXWINCE__
785 SetPolyFillMode(GetHdc(),prev);
786 #endif
787 delete[] cpoints;
788 }
789 else
790 {
791 int i;
792 for (i = 0; i < n; i++)
793 CalcBoundingBox(points[i].x, points[i].y);
794
795 #ifndef __WXWINCE__
796 int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
797 #endif
798 (void)Polygon(GetHdc(), (POINT*) points, n);
799 #ifndef __WXWINCE__
800 SetPolyFillMode(GetHdc(),prev);
801 #endif
802 }
803 }
804
805 void
806 wxDC::DoDrawPolyPolygon(int n,
807 int count[],
808 wxPoint points[],
809 wxCoord xoffset,
810 wxCoord yoffset,
811 int fillStyle)
812 {
813 #ifdef __WXWINCE__
814 wxDCBase::DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle);
815 #else
816 WXMICROWIN_CHECK_HDC
817
818 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
819 int i, cnt;
820 for (i = cnt = 0; i < n; i++)
821 cnt += count[i];
822
823 // Do things less efficiently if we have offsets
824 if (xoffset != 0 || yoffset != 0)
825 {
826 POINT *cpoints = new POINT[cnt];
827 for (i = 0; i < cnt; i++)
828 {
829 cpoints[i].x = (int)(points[i].x + xoffset);
830 cpoints[i].y = (int)(points[i].y + yoffset);
831
832 CalcBoundingBox(cpoints[i].x, cpoints[i].y);
833 }
834 #ifndef __WXWINCE__
835 int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
836 #endif
837 (void)PolyPolygon(GetHdc(), cpoints, count, n);
838 #ifndef __WXWINCE__
839 SetPolyFillMode(GetHdc(),prev);
840 #endif
841 delete[] cpoints;
842 }
843 else
844 {
845 for (i = 0; i < cnt; i++)
846 CalcBoundingBox(points[i].x, points[i].y);
847
848 #ifndef __WXWINCE__
849 int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
850 #endif
851 (void)PolyPolygon(GetHdc(), (POINT*) points, count, n);
852 #ifndef __WXWINCE__
853 SetPolyFillMode(GetHdc(),prev);
854 #endif
855 }
856 #endif
857 // __WXWINCE__
858 }
859
860 void wxDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
861 {
862 WXMICROWIN_CHECK_HDC
863
864 // Do things less efficiently if we have offsets
865 if (xoffset != 0 || yoffset != 0)
866 {
867 POINT *cpoints = new POINT[n];
868 int i;
869 for (i = 0; i < n; i++)
870 {
871 cpoints[i].x = (int)(points[i].x + xoffset);
872 cpoints[i].y = (int)(points[i].y + yoffset);
873
874 CalcBoundingBox(cpoints[i].x, cpoints[i].y);
875 }
876 (void)Polyline(GetHdc(), cpoints, n);
877 delete[] cpoints;
878 }
879 else
880 {
881 int i;
882 for (i = 0; i < n; i++)
883 CalcBoundingBox(points[i].x, points[i].y);
884
885 (void)Polyline(GetHdc(), (POINT*) points, n);
886 }
887 }
888
889 void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
890 {
891 WXMICROWIN_CHECK_HDC
892
893 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
894
895 wxCoord x2 = x + width;
896 wxCoord y2 = y + height;
897
898 if ((m_logicalFunction == wxCOPY) && (m_pen.GetStyle() == wxTRANSPARENT))
899 {
900 RECT rect;
901 rect.left = XLOG2DEV(x);
902 rect.top = YLOG2DEV(y);
903 rect.right = XLOG2DEV(x2);
904 rect.bottom = YLOG2DEV(y2);
905 (void)FillRect(GetHdc(), &rect, (HBRUSH)m_brush.GetResourceHandle() );
906 }
907 else
908 {
909 // Windows draws the filled rectangles without outline (i.e. drawn with a
910 // transparent pen) one pixel smaller in both directions and we want them
911 // to have the same size regardless of which pen is used - adjust
912
913 // I wonder if this shouldn´t be done after the LOG2DEV() conversions. RR.
914 if ( m_pen.GetStyle() == wxTRANSPARENT )
915 {
916 // Apparently not needed for WinCE (see e.g. Life! demo)
917 #ifndef __WXWINCE__
918 x2++;
919 y2++;
920 #endif
921 }
922
923 (void)Rectangle(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
924 }
925
926
927 CalcBoundingBox(x, y);
928 CalcBoundingBox(x2, y2);
929 }
930
931 void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
932 {
933 WXMICROWIN_CHECK_HDC
934
935 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
936
937 // Now, a negative radius value is interpreted to mean
938 // 'the proportion of the smallest X or Y dimension'
939
940 if (radius < 0.0)
941 {
942 double smallest = (width < height) ? width : height;
943 radius = (- radius * smallest);
944 }
945
946 wxCoord x2 = (x+width);
947 wxCoord y2 = (y+height);
948
949 // Windows draws the filled rectangles without outline (i.e. drawn with a
950 // transparent pen) one pixel smaller in both directions and we want them
951 // to have the same size regardless of which pen is used - adjust
952 if ( m_pen.GetStyle() == wxTRANSPARENT )
953 {
954 x2++;
955 y2++;
956 }
957
958 (void)RoundRect(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2),
959 YLOG2DEV(y2), (int) (2*XLOG2DEV(radius)), (int)( 2*YLOG2DEV(radius)));
960
961 CalcBoundingBox(x, y);
962 CalcBoundingBox(x2, y2);
963 }
964
965 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
966 {
967 WXMICROWIN_CHECK_HDC
968
969 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
970
971 wxCoord x2 = (x+width);
972 wxCoord y2 = (y+height);
973
974 (void)Ellipse(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
975
976 CalcBoundingBox(x, y);
977 CalcBoundingBox(x2, y2);
978 }
979
980 // Chris Breeze 20/5/98: first implementation of DrawEllipticArc on Windows
981 void wxDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
982 {
983 #ifdef __WXWINCE__
984 DoDrawEllipticArcRot( x, y, w, h, sa, ea );
985 #else
986
987 WXMICROWIN_CHECK_HDC
988
989 wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
990
991 wxCoord x2 = x + w;
992 wxCoord y2 = y + h;
993
994 int rx1 = XLOG2DEV(x+w/2);
995 int ry1 = YLOG2DEV(y+h/2);
996 int rx2 = rx1;
997 int ry2 = ry1;
998
999 sa = DegToRad(sa);
1000 ea = DegToRad(ea);
1001
1002 rx1 += (int)(100.0 * abs(w) * cos(sa));
1003 ry1 -= (int)(100.0 * abs(h) * m_signY * sin(sa));
1004 rx2 += (int)(100.0 * abs(w) * cos(ea));
1005 ry2 -= (int)(100.0 * abs(h) * m_signY * sin(ea));
1006
1007 // draw pie with NULL_PEN first and then outline otherwise a line is
1008 // drawn from the start and end points to the centre
1009 HPEN hpenOld = (HPEN) ::SelectObject(GetHdc(), (HPEN) ::GetStockObject(NULL_PEN));
1010 if (m_signY > 0)
1011 {
1012 (void)Pie(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2)+1, YLOG2DEV(y2)+1,
1013 rx1, ry1, rx2, ry2);
1014 }
1015 else
1016 {
1017 (void)Pie(GetHdc(), XLOG2DEV(x), YLOG2DEV(y)-1, XLOG2DEV(x2)+1, YLOG2DEV(y2),
1018 rx1, ry1-1, rx2, ry2-1);
1019 }
1020
1021 ::SelectObject(GetHdc(), hpenOld);
1022
1023 (void)Arc(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2),
1024 rx1, ry1, rx2, ry2);
1025
1026 CalcBoundingBox(x, y);
1027 CalcBoundingBox(x2, y2);
1028 #endif
1029 }
1030
1031 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
1032 {
1033 WXMICROWIN_CHECK_HDC
1034
1035 wxCHECK_RET( icon.Ok(), wxT("invalid icon in DrawIcon") );
1036
1037 #ifdef __WIN32__
1038 ::DrawIconEx(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), GetHiconOf(icon), icon.GetWidth(), icon.GetHeight(), 0, NULL, DI_NORMAL);
1039 #else
1040 ::DrawIcon(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), GetHiconOf(icon));
1041 #endif
1042
1043 CalcBoundingBox(x, y);
1044 CalcBoundingBox(x + icon.GetWidth(), y + icon.GetHeight());
1045 }
1046
1047 void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask )
1048 {
1049 WXMICROWIN_CHECK_HDC
1050
1051 wxCHECK_RET( bmp.Ok(), _T("invalid bitmap in wxDC::DrawBitmap") );
1052
1053 int width = bmp.GetWidth(),
1054 height = bmp.GetHeight();
1055
1056 HBITMAP hbmpMask = 0;
1057
1058 #if wxUSE_PALETTE
1059 HPALETTE oldPal = 0;
1060 #endif // wxUSE_PALETTE
1061
1062 if ( bmp.HasAlpha() )
1063 {
1064 MemoryHDC hdcMem;
1065 SelectInHDC select(hdcMem, GetHbitmapOf(bmp));
1066
1067 if ( AlphaBlt(GetHdc(), x, y, width, height, 0, 0, hdcMem, bmp) )
1068 return;
1069 }
1070
1071 if ( useMask )
1072 {
1073 wxMask *mask = bmp.GetMask();
1074 if ( mask )
1075 hbmpMask = (HBITMAP)mask->GetMaskBitmap();
1076
1077 if ( !hbmpMask )
1078 {
1079 // don't give assert here because this would break existing
1080 // programs - just silently ignore useMask parameter
1081 useMask = false;
1082 }
1083 }
1084 if ( useMask )
1085 {
1086 #ifdef __WIN32__
1087 // use MaskBlt() with ROP which doesn't do anything to dst in the mask
1088 // points
1089 // On some systems, MaskBlt succeeds yet is much much slower
1090 // than the wxWidgets fall-back implementation. So we need
1091 // to be able to switch this on and off at runtime.
1092 bool ok = false;
1093 #if wxUSE_SYSTEM_OPTIONS
1094 if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
1095 #endif
1096 {
1097 HDC cdc = GetHdc();
1098 HDC hdcMem = ::CreateCompatibleDC(GetHdc());
1099 HGDIOBJ hOldBitmap = ::SelectObject(hdcMem, GetHbitmapOf(bmp));
1100 #if wxUSE_PALETTE
1101 wxPalette *pal = bmp.GetPalette();
1102 if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
1103 {
1104 oldPal = ::SelectPalette(hdcMem, GetHpaletteOf(*pal), FALSE);
1105 ::RealizePalette(hdcMem);
1106 }
1107 #endif // wxUSE_PALETTE
1108
1109 ok = ::MaskBlt(cdc, x, y, width, height,
1110 hdcMem, 0, 0,
1111 hbmpMask, 0, 0,
1112 MAKEROP4(SRCCOPY, DSTCOPY)) != 0;
1113
1114 #if wxUSE_PALETTE
1115 if (oldPal)
1116 ::SelectPalette(hdcMem, oldPal, FALSE);
1117 #endif // wxUSE_PALETTE
1118
1119 ::SelectObject(hdcMem, hOldBitmap);
1120 ::DeleteDC(hdcMem);
1121 }
1122
1123 if ( !ok )
1124 #endif // Win32
1125 {
1126 // Rather than reproduce wxDC::Blit, let's do it at the wxWin API
1127 // level
1128 wxMemoryDC memDC;
1129 memDC.SelectObject(bmp);
1130
1131 Blit(x, y, width, height, &memDC, 0, 0, wxCOPY, useMask);
1132
1133 memDC.SelectObject(wxNullBitmap);
1134 }
1135 }
1136 else // no mask, just use BitBlt()
1137 {
1138 HDC cdc = GetHdc();
1139 HDC memdc = ::CreateCompatibleDC( cdc );
1140 HBITMAP hbitmap = (HBITMAP) bmp.GetHBITMAP( );
1141
1142 wxASSERT_MSG( hbitmap, wxT("bitmap is ok but HBITMAP is NULL?") );
1143
1144 COLORREF old_textground = ::GetTextColor(GetHdc());
1145 COLORREF old_background = ::GetBkColor(GetHdc());
1146 if (m_textForegroundColour.Ok())
1147 {
1148 ::SetTextColor(GetHdc(), m_textForegroundColour.GetPixel() );
1149 }
1150 if (m_textBackgroundColour.Ok())
1151 {
1152 ::SetBkColor(GetHdc(), m_textBackgroundColour.GetPixel() );
1153 }
1154
1155 #if wxUSE_PALETTE
1156 wxPalette *pal = bmp.GetPalette();
1157 if ( pal && ::GetDeviceCaps(cdc,BITSPIXEL) <= 8 )
1158 {
1159 oldPal = ::SelectPalette(memdc, GetHpaletteOf(*pal), FALSE);
1160 ::RealizePalette(memdc);
1161 }
1162 #endif // wxUSE_PALETTE
1163
1164 HGDIOBJ hOldBitmap = ::SelectObject( memdc, hbitmap );
1165 ::BitBlt( cdc, x, y, width, height, memdc, 0, 0, SRCCOPY);
1166
1167 #if wxUSE_PALETTE
1168 if (oldPal)
1169 ::SelectPalette(memdc, oldPal, FALSE);
1170 #endif // wxUSE_PALETTE
1171
1172 ::SelectObject( memdc, hOldBitmap );
1173 ::DeleteDC( memdc );
1174
1175 ::SetTextColor(GetHdc(), old_textground);
1176 ::SetBkColor(GetHdc(), old_background);
1177 }
1178 }
1179
1180 void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
1181 {
1182 WXMICROWIN_CHECK_HDC
1183
1184 DrawAnyText(text, x, y);
1185
1186 // update the bounding box
1187 CalcBoundingBox(x, y);
1188
1189 wxCoord w, h;
1190 GetTextExtent(text, &w, &h);
1191 CalcBoundingBox(x + w, y + h);
1192 }
1193
1194 void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
1195 {
1196 WXMICROWIN_CHECK_HDC
1197
1198 // prepare for drawing the text
1199 if ( m_textForegroundColour.Ok() )
1200 SetTextColor(GetHdc(), m_textForegroundColour.GetPixel());
1201
1202 DWORD old_background = 0;
1203 if ( m_textBackgroundColour.Ok() )
1204 {
1205 old_background = SetBkColor(GetHdc(), m_textBackgroundColour.GetPixel() );
1206 }
1207
1208 SetBkMode(GetHdc(), m_backgroundMode == wxTRANSPARENT ? TRANSPARENT
1209 : OPAQUE);
1210
1211 #ifdef __WXWINCE__
1212 if ( ::ExtTextOut(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), 0, NULL,
1213 text.c_str(), text.length(), NULL) == 0 )
1214 {
1215 wxLogLastError(wxT("TextOut"));
1216 }
1217 #else
1218 if ( ::TextOut(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),
1219 text.c_str(), text.length()) == 0 )
1220 {
1221 wxLogLastError(wxT("TextOut"));
1222 }
1223 #endif
1224
1225 // restore the old parameters (text foreground colour may be left because
1226 // it never is set to anything else, but background should remain
1227 // transparent even if we just drew an opaque string)
1228 if ( m_textBackgroundColour.Ok() )
1229 (void)SetBkColor(GetHdc(), old_background);
1230
1231 SetBkMode(GetHdc(), TRANSPARENT);
1232 }
1233
1234 void wxDC::DoDrawRotatedText(const wxString& text,
1235 wxCoord x, wxCoord y,
1236 double angle)
1237 {
1238 WXMICROWIN_CHECK_HDC
1239
1240 // we test that we have some font because otherwise we should still use the
1241 // "else" part below to avoid that DrawRotatedText(angle = 180) and
1242 // DrawRotatedText(angle = 0) use different fonts (we can't use the default
1243 // font for drawing rotated fonts unfortunately)
1244 if ( (angle == 0.0) && m_font.Ok() )
1245 {
1246 DoDrawText(text, x, y);
1247 }
1248 #ifndef __WXMICROWIN__
1249 else
1250 {
1251 // NB: don't take DEFAULT_GUI_FONT (a.k.a. wxSYS_DEFAULT_GUI_FONT)
1252 // because it's not TrueType and so can't have non zero
1253 // orientation/escapement under Win9x
1254 wxFont font = m_font.Ok() ? m_font : *wxSWISS_FONT;
1255 HFONT hfont = (HFONT)font.GetResourceHandle();
1256 LOGFONT lf;
1257 if ( ::GetObject(hfont, sizeof(lf), &lf) == 0 )
1258 {
1259 wxLogLastError(wxT("GetObject(hfont)"));
1260 }
1261
1262 // GDI wants the angle in tenth of degree
1263 long angle10 = (long)(angle * 10);
1264 lf.lfEscapement = angle10;
1265 lf. lfOrientation = angle10;
1266
1267 hfont = ::CreateFontIndirect(&lf);
1268 if ( !hfont )
1269 {
1270 wxLogLastError(wxT("CreateFont"));
1271 }
1272 else
1273 {
1274 HFONT hfontOld = (HFONT)::SelectObject(GetHdc(), hfont);
1275
1276 DrawAnyText(text, x, y);
1277
1278 (void)::SelectObject(GetHdc(), hfontOld);
1279 (void)::DeleteObject(hfont);
1280 }
1281
1282 // call the bounding box by adding all four vertices of the rectangle
1283 // containing the text to it (simpler and probably not slower than
1284 // determining which of them is really topmost/leftmost/...)
1285 wxCoord w, h;
1286 GetTextExtent(text, &w, &h);
1287
1288 double rad = DegToRad(angle);
1289
1290 // "upper left" and "upper right"
1291 CalcBoundingBox(x, y);
1292 CalcBoundingBox(x + wxCoord(w*cos(rad)), y - wxCoord(w*sin(rad)));
1293
1294 // "bottom left" and "bottom right"
1295 x += (wxCoord)(h*sin(rad));
1296 y += (wxCoord)(h*cos(rad));
1297 CalcBoundingBox(x, y);
1298 CalcBoundingBox(x + wxCoord(w*cos(rad)), y - wxCoord(w*sin(rad)));
1299 }
1300 #endif
1301 }
1302
1303 // ---------------------------------------------------------------------------
1304 // set GDI objects
1305 // ---------------------------------------------------------------------------
1306
1307 #if wxUSE_PALETTE
1308
1309 void wxDC::DoSelectPalette(bool realize)
1310 {
1311 WXMICROWIN_CHECK_HDC
1312
1313 // Set the old object temporarily, in case the assignment deletes an object
1314 // that's not yet selected out.
1315 if (m_oldPalette)
1316 {
1317 ::SelectPalette(GetHdc(), (HPALETTE) m_oldPalette, FALSE);
1318 m_oldPalette = 0;
1319 }
1320
1321 if ( m_palette.Ok() )
1322 {
1323 HPALETTE oldPal = ::SelectPalette(GetHdc(),
1324 GetHpaletteOf(m_palette),
1325 false);
1326 if (!m_oldPalette)
1327 m_oldPalette = (WXHPALETTE) oldPal;
1328
1329 if (realize)
1330 ::RealizePalette(GetHdc());
1331 }
1332 }
1333
1334 void wxDC::SetPalette(const wxPalette& palette)
1335 {
1336 if ( palette.Ok() )
1337 {
1338 m_palette = palette;
1339 DoSelectPalette(true);
1340 }
1341 }
1342
1343 void wxDC::InitializePalette()
1344 {
1345 if ( wxDisplayDepth() <= 8 )
1346 {
1347 // look for any window or parent that has a custom palette. If any has
1348 // one then we need to use it in drawing operations
1349 wxWindow *win = m_canvas->GetAncestorWithCustomPalette();
1350
1351 m_hasCustomPalette = win && win->HasCustomPalette();
1352 if ( m_hasCustomPalette )
1353 {
1354 m_palette = win->GetPalette();
1355
1356 // turn on MSW translation for this palette
1357 DoSelectPalette();
1358 }
1359 }
1360 }
1361
1362 #endif // wxUSE_PALETTE
1363
1364 // SetFont/Pen/Brush() really ask to be implemented as a single template
1365 // function... but doing it is not worth breaking OpenWatcom build <sigh>
1366
1367 void wxDC::SetFont(const wxFont& font)
1368 {
1369 WXMICROWIN_CHECK_HDC
1370
1371 if ( font == m_font )
1372 return;
1373
1374 if ( font.Ok() )
1375 {
1376 HGDIOBJ hfont = ::SelectObject(GetHdc(), GetHfontOf(font));
1377 if ( hfont == HGDI_ERROR )
1378 {
1379 wxLogLastError(_T("SelectObject(font)"));
1380 }
1381 else // selected ok
1382 {
1383 if ( !m_oldFont )
1384 m_oldFont = (WXHPEN)hfont;
1385
1386 m_font = font;
1387 }
1388 }
1389 else // invalid font, reset the current font
1390 {
1391 if ( m_oldFont )
1392 {
1393 if ( ::SelectObject(GetHdc(), (HPEN) m_oldFont) == HGDI_ERROR )
1394 {
1395 wxLogLastError(_T("SelectObject(old font)"));
1396 }
1397
1398 m_oldFont = 0;
1399 }
1400
1401 m_font = wxNullFont;
1402 }
1403 }
1404
1405 void wxDC::SetPen(const wxPen& pen)
1406 {
1407 WXMICROWIN_CHECK_HDC
1408
1409 if ( pen == m_pen )
1410 return;
1411
1412 if ( pen.Ok() )
1413 {
1414 HGDIOBJ hpen = ::SelectObject(GetHdc(), GetHpenOf(pen));
1415 if ( hpen == HGDI_ERROR )
1416 {
1417 wxLogLastError(_T("SelectObject(pen)"));
1418 }
1419 else // selected ok
1420 {
1421 if ( !m_oldPen )
1422 m_oldPen = (WXHPEN)hpen;
1423
1424 m_pen = pen;
1425 }
1426 }
1427 else // invalid pen, reset the current pen
1428 {
1429 if ( m_oldPen )
1430 {
1431 if ( ::SelectObject(GetHdc(), (HPEN) m_oldPen) == HGDI_ERROR )
1432 {
1433 wxLogLastError(_T("SelectObject(old pen)"));
1434 }
1435
1436 m_oldPen = 0;
1437 }
1438
1439 m_pen = wxNullPen;
1440 }
1441 }
1442
1443 void wxDC::SetBrush(const wxBrush& brush)
1444 {
1445 WXMICROWIN_CHECK_HDC
1446
1447 if ( brush == m_brush )
1448 return;
1449
1450 if ( brush.Ok() )
1451 {
1452 // we must make sure the brush is aligned with the logical coordinates
1453 // before selecting it
1454 wxBitmap *stipple = brush.GetStipple();
1455 if ( stipple && stipple->Ok() )
1456 {
1457 if ( !::SetBrushOrgEx
1458 (
1459 GetHdc(),
1460 m_deviceOriginX % stipple->GetWidth(),
1461 m_deviceOriginY % stipple->GetHeight(),
1462 NULL // [out] previous brush origin
1463 ) )
1464 {
1465 wxLogLastError(_T("SetBrushOrgEx()"));
1466 }
1467 }
1468
1469 HGDIOBJ hbrush = ::SelectObject(GetHdc(), GetHbrushOf(brush));
1470 if ( hbrush == HGDI_ERROR )
1471 {
1472 wxLogLastError(_T("SelectObject(brush)"));
1473 }
1474 else // selected ok
1475 {
1476 if ( !m_oldBrush )
1477 m_oldBrush = (WXHPEN)hbrush;
1478
1479 m_brush = brush;
1480 }
1481 }
1482 else // invalid brush, reset the current brush
1483 {
1484 if ( m_oldBrush )
1485 {
1486 if ( ::SelectObject(GetHdc(), (HPEN) m_oldBrush) == HGDI_ERROR )
1487 {
1488 wxLogLastError(_T("SelectObject(old brush)"));
1489 }
1490
1491 m_oldBrush = 0;
1492 }
1493
1494 m_brush = wxNullBrush;
1495 }
1496 }
1497
1498 void wxDC::SetBackground(const wxBrush& brush)
1499 {
1500 WXMICROWIN_CHECK_HDC
1501
1502 m_backgroundBrush = brush;
1503
1504 if ( m_backgroundBrush.Ok() )
1505 {
1506 (void)SetBkColor(GetHdc(), m_backgroundBrush.GetColour().GetPixel());
1507 }
1508 }
1509
1510 void wxDC::SetBackgroundMode(int mode)
1511 {
1512 WXMICROWIN_CHECK_HDC
1513
1514 m_backgroundMode = mode;
1515
1516 // SetBackgroundColour now only refers to text background
1517 // and m_backgroundMode is used there
1518 }
1519
1520 void wxDC::SetLogicalFunction(int function)
1521 {
1522 WXMICROWIN_CHECK_HDC
1523
1524 m_logicalFunction = function;
1525
1526 SetRop(m_hDC);
1527 }
1528
1529 void wxDC::SetRop(WXHDC dc)
1530 {
1531 if ( !dc || m_logicalFunction < 0 )
1532 return;
1533
1534 int rop;
1535
1536 switch (m_logicalFunction)
1537 {
1538 case wxCLEAR: rop = R2_BLACK; break;
1539 case wxXOR: rop = R2_XORPEN; break;
1540 case wxINVERT: rop = R2_NOT; break;
1541 case wxOR_REVERSE: rop = R2_MERGEPENNOT; break;
1542 case wxAND_REVERSE: rop = R2_MASKPENNOT; break;
1543 case wxCOPY: rop = R2_COPYPEN; break;
1544 case wxAND: rop = R2_MASKPEN; break;
1545 case wxAND_INVERT: rop = R2_MASKNOTPEN; break;
1546 case wxNO_OP: rop = R2_NOP; break;
1547 case wxNOR: rop = R2_NOTMERGEPEN; break;
1548 case wxEQUIV: rop = R2_NOTXORPEN; break;
1549 case wxSRC_INVERT: rop = R2_NOTCOPYPEN; break;
1550 case wxOR_INVERT: rop = R2_MERGENOTPEN; break;
1551 case wxNAND: rop = R2_NOTMASKPEN; break;
1552 case wxOR: rop = R2_MERGEPEN; break;
1553 case wxSET: rop = R2_WHITE; break;
1554
1555 default:
1556 wxFAIL_MSG( wxT("unsupported logical function") );
1557 return;
1558 }
1559
1560 SetROP2(GetHdc(), rop);
1561 }
1562
1563 bool wxDC::StartDoc(const wxString& WXUNUSED(message))
1564 {
1565 // We might be previewing, so return true to let it continue.
1566 return true;
1567 }
1568
1569 void wxDC::EndDoc()
1570 {
1571 }
1572
1573 void wxDC::StartPage()
1574 {
1575 }
1576
1577 void wxDC::EndPage()
1578 {
1579 }
1580
1581 // ---------------------------------------------------------------------------
1582 // text metrics
1583 // ---------------------------------------------------------------------------
1584
1585 wxCoord wxDC::GetCharHeight() const
1586 {
1587 WXMICROWIN_CHECK_HDC_RET(0)
1588
1589 TEXTMETRIC lpTextMetric;
1590
1591 GetTextMetrics(GetHdc(), &lpTextMetric);
1592
1593 return lpTextMetric.tmHeight;
1594 }
1595
1596 wxCoord wxDC::GetCharWidth() const
1597 {
1598 WXMICROWIN_CHECK_HDC_RET(0)
1599
1600 TEXTMETRIC lpTextMetric;
1601
1602 GetTextMetrics(GetHdc(), &lpTextMetric);
1603
1604 return lpTextMetric.tmAveCharWidth;
1605 }
1606
1607 void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
1608 wxCoord *descent, wxCoord *externalLeading,
1609 wxFont *font) const
1610 {
1611 #ifdef __WXMICROWIN__
1612 if (!GetHDC())
1613 {
1614 if (x) *x = 0;
1615 if (y) *y = 0;
1616 if (descent) *descent = 0;
1617 if (externalLeading) *externalLeading = 0;
1618 return;
1619 }
1620 #endif // __WXMICROWIN__
1621
1622 HFONT hfontOld;
1623 if ( font )
1624 {
1625 wxASSERT_MSG( font->Ok(), _T("invalid font in wxDC::GetTextExtent") );
1626
1627 hfontOld = (HFONT)::SelectObject(GetHdc(), GetHfontOf(*font));
1628 }
1629 else // don't change the font
1630 {
1631 hfontOld = 0;
1632 }
1633
1634 SIZE sizeRect;
1635 TEXTMETRIC tm;
1636
1637 ::GetTextExtentPoint32(GetHdc(), string, string.length(), &sizeRect);
1638 GetTextMetrics(GetHdc(), &tm);
1639
1640 if (x)
1641 *x = sizeRect.cx;
1642 if (y)
1643 *y = sizeRect.cy;
1644 if (descent)
1645 *descent = tm.tmDescent;
1646 if (externalLeading)
1647 *externalLeading = tm.tmExternalLeading;
1648
1649 if ( hfontOld )
1650 {
1651 ::SelectObject(GetHdc(), hfontOld);
1652 }
1653 }
1654
1655
1656 // Each element of the array will be the width of the string up to and
1657 // including the coresoponding character in text.
1658
1659 bool wxDC::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
1660 {
1661 static int maxLenText = -1;
1662 static int maxWidth = -1;
1663 int fit = 0;
1664 SIZE sz = {0,0};
1665 int stlen = text.Length();
1666
1667 if (maxLenText == -1)
1668 {
1669 // Win9x and WinNT+ have different limits
1670 int version = wxGetOsVersion();
1671 maxLenText = version == wxWINDOWS_NT ? 65535 : 8192;
1672 maxWidth = version == wxWINDOWS_NT ? INT_MAX : 32767;
1673 }
1674
1675 widths.Empty();
1676 widths.Add(0, stlen); // fill the array with zeros
1677 if (stlen == 0)
1678 return true;
1679
1680 if (!::GetTextExtentExPoint(GetHdc(),
1681 text.c_str(), // string to check
1682 wxMin(stlen, maxLenText),
1683 maxWidth,
1684 &fit, // [out] count of chars
1685 // that will fit
1686 &widths[0], // array to fill
1687 &sz))
1688 {
1689 // API failed
1690 wxLogLastError(wxT("GetTextExtentExPoint"));
1691 return false;
1692 }
1693
1694 return true;
1695 }
1696
1697
1698
1699
1700 void wxDC::SetMapMode(int mode)
1701 {
1702 WXMICROWIN_CHECK_HDC
1703
1704 m_mappingMode = mode;
1705
1706 if ( mode == wxMM_TEXT )
1707 {
1708 m_logicalScaleX =
1709 m_logicalScaleY = 1.0;
1710 }
1711 else // need to do some calculations
1712 {
1713 int pixel_width = ::GetDeviceCaps(GetHdc(), HORZRES),
1714 pixel_height = ::GetDeviceCaps(GetHdc(), VERTRES),
1715 mm_width = ::GetDeviceCaps(GetHdc(), HORZSIZE),
1716 mm_height = ::GetDeviceCaps(GetHdc(), VERTSIZE);
1717
1718 if ( (mm_width == 0) || (mm_height == 0) )
1719 {
1720 // we can't calculate mm2pixels[XY] then!
1721 return;
1722 }
1723
1724 double mm2pixelsX = (double)pixel_width / mm_width,
1725 mm2pixelsY = (double)pixel_height / mm_height;
1726
1727 switch (mode)
1728 {
1729 case wxMM_TWIPS:
1730 m_logicalScaleX = twips2mm * mm2pixelsX;
1731 m_logicalScaleY = twips2mm * mm2pixelsY;
1732 break;
1733
1734 case wxMM_POINTS:
1735 m_logicalScaleX = pt2mm * mm2pixelsX;
1736 m_logicalScaleY = pt2mm * mm2pixelsY;
1737 break;
1738
1739 case wxMM_METRIC:
1740 m_logicalScaleX = mm2pixelsX;
1741 m_logicalScaleY = mm2pixelsY;
1742 break;
1743
1744 case wxMM_LOMETRIC:
1745 m_logicalScaleX = mm2pixelsX / 10.0;
1746 m_logicalScaleY = mm2pixelsY / 10.0;
1747 break;
1748
1749 default:
1750 wxFAIL_MSG( _T("unknown mapping mode in SetMapMode") );
1751 }
1752 }
1753
1754 // VZ: it seems very wasteful to always use MM_ANISOTROPIC when in 99% of
1755 // cases we could do with MM_TEXT and in the remaining 0.9% with
1756 // MM_ISOTROPIC (TODO!)
1757 #ifndef __WXWINCE__
1758 ::SetMapMode(GetHdc(), MM_ANISOTROPIC);
1759
1760 int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
1761 height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
1762
1763 ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
1764 ::SetWindowExtEx(GetHdc(), width, height, NULL);
1765
1766 ::SetViewportOrgEx(GetHdc(), m_deviceOriginX, m_deviceOriginY, NULL);
1767 ::SetWindowOrgEx(GetHdc(), m_logicalOriginX, m_logicalOriginY, NULL);
1768 #endif
1769 }
1770
1771 void wxDC::SetUserScale(double x, double y)
1772 {
1773 WXMICROWIN_CHECK_HDC
1774
1775 if ( x == m_userScaleX && y == m_userScaleY )
1776 return;
1777
1778 m_userScaleX = x;
1779 m_userScaleY = y;
1780
1781 this->SetMapMode(m_mappingMode);
1782 }
1783
1784 void wxDC::SetAxisOrientation(bool WXUNUSED_IN_WINCE(xLeftRight),
1785 bool WXUNUSED_IN_WINCE(yBottomUp))
1786 {
1787 WXMICROWIN_CHECK_HDC
1788
1789 #ifndef __WXWINCE__
1790 int signX = xLeftRight ? 1 : -1,
1791 signY = yBottomUp ? -1 : 1;
1792
1793 if ( signX != m_signX || signY != m_signY )
1794 {
1795 m_signX = signX;
1796 m_signY = signY;
1797
1798 SetMapMode(m_mappingMode);
1799 }
1800 #endif
1801 }
1802
1803 void wxDC::SetSystemScale(double x, double y)
1804 {
1805 WXMICROWIN_CHECK_HDC
1806
1807 if ( x == m_scaleX && y == m_scaleY )
1808 return;
1809
1810 m_scaleX = x;
1811 m_scaleY = y;
1812
1813 #ifndef __WXWINCE__
1814 SetMapMode(m_mappingMode);
1815 #endif
1816 }
1817
1818 void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
1819 {
1820 WXMICROWIN_CHECK_HDC
1821
1822 if ( x == m_logicalOriginX && y == m_logicalOriginY )
1823 return;
1824
1825 m_logicalOriginX = x;
1826 m_logicalOriginY = y;
1827
1828 #ifndef __WXWINCE__
1829 ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
1830 #endif
1831 }
1832
1833 void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
1834 {
1835 WXMICROWIN_CHECK_HDC
1836
1837 if ( x == m_deviceOriginX && y == m_deviceOriginY )
1838 return;
1839
1840 m_deviceOriginX = x;
1841 m_deviceOriginY = y;
1842
1843 ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
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 xsrc, ysrc, 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 int srcX, int srcY, 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, srcX, srcY, 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, srcX, srcY, 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, int srcX, int srcY, 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 pSrc.Offset(dataSrc, srcX, srcY);
2491
2492 for ( int y = 0; y < h; y++ )
2493 {
2494 wxAlphaPixelData::Iterator pDstRowStart = pDst,
2495 pSrcRowStart = pSrc;
2496
2497 for ( int x = 0; x < w; x++ )
2498 {
2499 // note that source bitmap uses premultiplied alpha (as required by
2500 // the real AlphaBlend)
2501 const unsigned beta = 255 - pSrc.Alpha();
2502
2503 pDst.Red() = pSrc.Red() + (beta * pDst.Red() + 127) / 255;
2504 pDst.Blue() = pSrc.Blue() + (beta * pDst.Blue() + 127) / 255;
2505 pDst.Green() = pSrc.Green() + (beta * pDst.Green() + 127) / 255;
2506
2507 ++pDst;
2508 ++pSrc;
2509 }
2510
2511 pDst = pDstRowStart;
2512 pSrc = pSrcRowStart;
2513 pDst.OffsetY(dataDst, 1);
2514 pSrc.OffsetY(dataSrc, 1);
2515 }
2516
2517 // and finally blit them back to the destination DC
2518 if ( !::BitBlt(hdcDst, xDst, yDst, w, h, hdcMem, 0, 0, SRCCOPY) )
2519 {
2520 wxLogLastError(_T("BitBlt"));
2521 }
2522 }
2523
2524 #endif // #ifdef wxHAVE_RAW_BITMAP
wxWidgets (Impactor)