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