]> git.saurik.com Git - wxWidgets.git/blob - src/msw/dc.cpp
projects / wxWidgets.git / blob
? search:


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