projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Include wx/image.h
[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 #ifndef __WXWINCE__
1770 if ( x == m_userScaleX && y == m_userScaleY )
1771 return;
1772
1773 m_userScaleX = x;
1774 m_userScaleY = y;
1775
1776 SetMapMode(m_mappingMode);
1777 #endif
1778 }
1779
1780 void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
1781 {
1782 WXMICROWIN_CHECK_HDC
1783
1784 #ifndef __WXWINCE__
1785 int signX = xLeftRight ? 1 : -1,
1786 signY = yBottomUp ? -1 : 1;
1787
1788 if ( signX != m_signX || signY != m_signY )
1789 {
1790 m_signX = signX;
1791 m_signY = signY;
1792
1793 SetMapMode(m_mappingMode);
1794 }
1795 #endif
1796 }
1797
1798 void wxDC::SetSystemScale(double x, double y)
1799 {
1800 WXMICROWIN_CHECK_HDC
1801
1802 if ( x == m_scaleX && y == m_scaleY )
1803 return;
1804
1805 m_scaleX = x;
1806 m_scaleY = y;
1807
1808 #ifndef __WXWINCE__
1809 SetMapMode(m_mappingMode);
1810 #endif
1811 }
1812
1813 void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
1814 {
1815 WXMICROWIN_CHECK_HDC
1816
1817 if ( x == m_logicalOriginX && y == m_logicalOriginY )
1818 return;
1819
1820 m_logicalOriginX = x;
1821 m_logicalOriginY = y;
1822
1823 #ifndef __WXWINCE__
1824 ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
1825 #endif
1826 }
1827
1828 void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
1829 {
1830 WXMICROWIN_CHECK_HDC
1831
1832 if ( x == m_deviceOriginX && y == m_deviceOriginY )
1833 return;
1834
1835 m_deviceOriginX = x;
1836 m_deviceOriginY = y;
1837
1838 #ifndef __WXWINCE__
1839 ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
1840 #endif
1841 }
1842
1843 // ---------------------------------------------------------------------------
1844 // coordinates transformations
1845 // ---------------------------------------------------------------------------
1846
1847 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
1848 {
1849 return DeviceToLogicalXRel(x - m_deviceOriginX)*m_signX + m_logicalOriginX;
1850 }
1851
1852 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
1853 {
1854 // axis orientation is not taken into account for conversion of a distance
1855 return (wxCoord)(x / (m_logicalScaleX*m_userScaleX*m_scaleX));
1856 }
1857
1858 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
1859 {
1860 return DeviceToLogicalYRel(y - m_deviceOriginY)*m_signY + m_logicalOriginY;
1861 }
1862
1863 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
1864 {
1865 // axis orientation is not taken into account for conversion of a distance
1866 return (wxCoord)( y / (m_logicalScaleY*m_userScaleY*m_scaleY));
1867 }
1868
1869 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
1870 {
1871 return LogicalToDeviceXRel(x - m_logicalOriginX)*m_signX + m_deviceOriginX;
1872 }
1873
1874 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
1875 {
1876 // axis orientation is not taken into account for conversion of a distance
1877 return (wxCoord) (x*m_logicalScaleX*m_userScaleX*m_scaleX);
1878 }
1879
1880 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
1881 {
1882 return LogicalToDeviceYRel(y - m_logicalOriginY)*m_signY + m_deviceOriginY;
1883 }
1884
1885 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
1886 {
1887 // axis orientation is not taken into account for conversion of a distance
1888 return (wxCoord) (y*m_logicalScaleY*m_userScaleY*m_scaleY);
1889 }
1890
1891 // ---------------------------------------------------------------------------
1892 // bit blit
1893 // ---------------------------------------------------------------------------
1894
1895 bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
1896 wxCoord width, wxCoord height,
1897 wxDC *source, wxCoord xsrc, wxCoord ysrc,
1898 int rop, bool useMask,
1899 wxCoord xsrcMask, wxCoord ysrcMask)
1900 {
1901 wxCHECK_MSG( source, false, _T("wxDC::Blit(): NULL wxDC pointer") );
1902
1903 WXMICROWIN_CHECK_HDC_RET(false)
1904
1905 const wxBitmap& bmpSrc = source->m_selectedBitmap;
1906 if ( bmpSrc.Ok() && bmpSrc.HasAlpha() )
1907 {
1908 if ( AlphaBlt(GetHdc(), xdest, ydest, width, height,
1909 GetHdcOf(*source), bmpSrc) )
1910 return true;
1911 }
1912
1913 wxMask *mask = NULL;
1914 if ( useMask )
1915 {
1916 mask = bmpSrc.GetMask();
1917
1918 if ( !(bmpSrc.Ok() && mask && mask->GetMaskBitmap()) )
1919 {
1920 // don't give assert here because this would break existing
1921 // programs - just silently ignore useMask parameter
1922 useMask = false;
1923 }
1924 }
1925
1926 if (xsrcMask == -1 && ysrcMask == -1)
1927 {
1928 xsrcMask = xsrc; ysrcMask = ysrc;
1929 }
1930
1931 COLORREF old_textground = ::GetTextColor(GetHdc());
1932 COLORREF old_background = ::GetBkColor(GetHdc());
1933 if (m_textForegroundColour.Ok())
1934 {
1935 ::SetTextColor(GetHdc(), m_textForegroundColour.GetPixel() );
1936 }
1937 if (m_textBackgroundColour.Ok())
1938 {
1939 ::SetBkColor(GetHdc(), m_textBackgroundColour.GetPixel() );
1940 }
1941
1942 DWORD dwRop;
1943 switch (rop)
1944 {
1945 case wxXOR: dwRop = SRCINVERT; break;
1946 case wxINVERT: dwRop = DSTINVERT; break;
1947 case wxOR_REVERSE: dwRop = 0x00DD0228; break;
1948 case wxAND_REVERSE: dwRop = SRCERASE; break;
1949 case wxCLEAR: dwRop = BLACKNESS; break;
1950 case wxSET: dwRop = WHITENESS; break;
1951 case wxOR_INVERT: dwRop = MERGEPAINT; break;
1952 case wxAND: dwRop = SRCAND; break;
1953 case wxOR: dwRop = SRCPAINT; break;
1954 case wxEQUIV: dwRop = 0x00990066; break;
1955 case wxNAND: dwRop = 0x007700E6; break;
1956 case wxAND_INVERT: dwRop = 0x00220326; break;
1957 case wxCOPY: dwRop = SRCCOPY; break;
1958 case wxNO_OP: dwRop = DSTCOPY; break;
1959 case wxSRC_INVERT: dwRop = NOTSRCCOPY; break;
1960 case wxNOR: dwRop = NOTSRCCOPY; break;
1961 default:
1962 wxFAIL_MSG( wxT("unsupported logical function") );
1963 return false;
1964 }
1965
1966 bool success = false;
1967
1968 if (useMask)
1969 {
1970 #ifdef __WIN32__
1971 // we want the part of the image corresponding to the mask to be
1972 // transparent, so use "DSTCOPY" ROP for the mask points (the usual
1973 // meaning of fg and bg is inverted which corresponds to wxWin notion
1974 // of the mask which is also contrary to the Windows one)
1975
1976 // On some systems, MaskBlt succeeds yet is much much slower
1977 // than the wxWidgets fall-back implementation. So we need
1978 // to be able to switch this on and off at runtime.
1979 #if wxUSE_SYSTEM_OPTIONS
1980 if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
1981 #endif
1982 {
1983 success = ::MaskBlt
1984 (
1985 GetHdc(),
1986 xdest, ydest, width, height,
1987 GetHdcOf(*source),
1988 xsrc, ysrc,
1989 (HBITMAP)mask->GetMaskBitmap(),
1990 xsrcMask, ysrcMask,
1991 MAKEROP4(dwRop, DSTCOPY)
1992 ) != 0;
1993 }
1994
1995 if ( !success )
1996 #endif // Win32
1997 {
1998 // Blit bitmap with mask
1999 HDC dc_mask ;
2000 HDC dc_buffer ;
2001 HBITMAP buffer_bmap ;
2002
2003 #if wxUSE_DC_CACHEING
2004 // create a temp buffer bitmap and DCs to access it and the mask
2005 wxDCCacheEntry* dcCacheEntry1 = FindDCInCache(NULL, source->GetHDC());
2006 dc_mask = (HDC) dcCacheEntry1->m_dc;
2007
2008 wxDCCacheEntry* dcCacheEntry2 = FindDCInCache(dcCacheEntry1, GetHDC());
2009 dc_buffer = (HDC) dcCacheEntry2->m_dc;
2010
2011 wxDCCacheEntry* bitmapCacheEntry = FindBitmapInCache(GetHDC(),
2012 width, height);
2013
2014 buffer_bmap = (HBITMAP) bitmapCacheEntry->m_bitmap;
2015 #else // !wxUSE_DC_CACHEING
2016 // create a temp buffer bitmap and DCs to access it and the mask
2017 dc_mask = ::CreateCompatibleDC(GetHdcOf(*source));
2018 dc_buffer = ::CreateCompatibleDC(GetHdc());
2019 buffer_bmap = ::CreateCompatibleBitmap(GetHdc(), width, height);
2020 #endif // wxUSE_DC_CACHEING/!wxUSE_DC_CACHEING
2021 HGDIOBJ hOldMaskBitmap = ::SelectObject(dc_mask, (HBITMAP) mask->GetMaskBitmap());
2022 HGDIOBJ hOldBufferBitmap = ::SelectObject(dc_buffer, buffer_bmap);
2023
2024 // copy dest to buffer
2025 if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
2026 GetHdc(), xdest, ydest, SRCCOPY) )
2027 {
2028 wxLogLastError(wxT("BitBlt"));
2029 }
2030
2031 // copy src to buffer using selected raster op
2032 if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
2033 GetHdcOf(*source), xsrc, ysrc, dwRop) )
2034 {
2035 wxLogLastError(wxT("BitBlt"));
2036 }
2037
2038 // set masked area in buffer to BLACK (pixel value 0)
2039 COLORREF prevBkCol = ::SetBkColor(GetHdc(), RGB(255, 255, 255));
2040 COLORREF prevCol = ::SetTextColor(GetHdc(), RGB(0, 0, 0));
2041 if ( !::BitBlt(dc_buffer, 0, 0, (int)width, (int)height,
2042 dc_mask, xsrcMask, ysrcMask, SRCAND) )
2043 {
2044 wxLogLastError(wxT("BitBlt"));
2045 }
2046
2047 // set unmasked area in dest to BLACK
2048 ::SetBkColor(GetHdc(), RGB(0, 0, 0));
2049 ::SetTextColor(GetHdc(), RGB(255, 255, 255));
2050 if ( !::BitBlt(GetHdc(), xdest, ydest, (int)width, (int)height,
2051 dc_mask, xsrcMask, ysrcMask, SRCAND) )
2052 {
2053 wxLogLastError(wxT("BitBlt"));
2054 }
2055 ::SetBkColor(GetHdc(), prevBkCol); // restore colours to original values
2056 ::SetTextColor(GetHdc(), prevCol);
2057
2058 // OR buffer to dest
2059 success = ::BitBlt(GetHdc(), xdest, ydest,
2060 (int)width, (int)height,
2061 dc_buffer, 0, 0, SRCPAINT) != 0;
2062 if ( !success )
2063 {
2064 wxLogLastError(wxT("BitBlt"));
2065 }
2066
2067 // tidy up temporary DCs and bitmap
2068 ::SelectObject(dc_mask, hOldMaskBitmap);
2069 ::SelectObject(dc_buffer, hOldBufferBitmap);
2070
2071 #if !wxUSE_DC_CACHEING
2072 {
2073 ::DeleteDC(dc_mask);
2074 ::DeleteDC(dc_buffer);
2075 ::DeleteObject(buffer_bmap);
2076 }
2077 #endif
2078 }
2079 }
2080 else // no mask, just BitBlt() it
2081 {
2082 // if we already have a DIB, draw it using StretchDIBits(), otherwise
2083 // use StretchBlt() if available and finally fall back to BitBlt()
2084
2085 // FIXME: use appropriate WinCE functions
2086 #ifndef __WXWINCE__
2087 const int caps = ::GetDeviceCaps(GetHdc(), RASTERCAPS);
2088 if ( bmpSrc.Ok() && (caps & RC_STRETCHDIB) )
2089 {
2090 DIBSECTION ds;
2091 wxZeroMemory(ds);
2092
2093 if ( ::GetObject(GetHbitmapOf(bmpSrc),
2094 sizeof(ds),
2095 &ds) == sizeof(ds) )
2096 {
2097 StretchBltModeChanger changeMode(GetHdc(), COLORONCOLOR);
2098
2099 // Figure out what co-ordinate system we're supposed to specify
2100 // ysrc in.
2101 const LONG hDIB = ds.dsBmih.biHeight;
2102 if ( hDIB > 0 )
2103 {
2104 // reflect ysrc
2105 ysrc = hDIB - (ysrc + height);
2106 }
2107
2108 if ( ::StretchDIBits(GetHdc(),
2109 xdest, ydest,
2110 width, height,
2111 xsrc, ysrc,
2112 width, height,
2113 ds.dsBm.bmBits,
2114 (LPBITMAPINFO)&ds.dsBmih,
2115 DIB_RGB_COLORS,
2116 SRCCOPY
2117 ) == (int)GDI_ERROR )
2118 {
2119 // On Win9x this API fails most (all?) of the time, so
2120 // logging it becomes quite distracting. Since it falls
2121 // back to the code below this is not really serious, so
2122 // don't log it.
2123 //wxLogLastError(wxT("StretchDIBits"));
2124 }
2125 else
2126 {
2127 success = true;
2128 }
2129 }
2130 }
2131
2132 if ( !success && (caps & RC_STRETCHBLT) )
2133 #endif
2134 // __WXWINCE__
2135 {
2136 #ifndef __WXWINCE__
2137 StretchBltModeChanger changeMode(GetHdc(), COLORONCOLOR);
2138 #endif
2139
2140 if ( !::StretchBlt
2141 (
2142 GetHdc(),
2143 xdest, ydest, width, height,
2144 GetHdcOf(*source),
2145 xsrc, ysrc, width, height,
2146 dwRop
2147 ) )
2148 {
2149 wxLogLastError(_T("StretchBlt"));
2150 }
2151 else
2152 {
2153 success = true;
2154 }
2155 }
2156
2157 if ( !success )
2158 {
2159 if ( !::BitBlt
2160 (
2161 GetHdc(),
2162 xdest, ydest,
2163 (int)width, (int)height,
2164 GetHdcOf(*source),
2165 xsrc, ysrc,
2166 dwRop
2167 ) )
2168 {
2169 wxLogLastError(_T("BitBlt"));
2170 }
2171 else
2172 {
2173 success = true;
2174 }
2175 }
2176 }
2177
2178 ::SetTextColor(GetHdc(), old_textground);
2179 ::SetBkColor(GetHdc(), old_background);
2180
2181 return success;
2182 }
2183
2184 void wxDC::DoGetSize(int *w, int *h) const
2185 {
2186 WXMICROWIN_CHECK_HDC
2187
2188 if ( w ) *w = ::GetDeviceCaps(GetHdc(), HORZRES);
2189 if ( h ) *h = ::GetDeviceCaps(GetHdc(), VERTRES);
2190 }
2191
2192 void wxDC::DoGetSizeMM(int *w, int *h) const
2193 {
2194 WXMICROWIN_CHECK_HDC
2195
2196 // if we implement it in terms of DoGetSize() instead of directly using the
2197 // results returned by GetDeviceCaps(HORZ/VERTSIZE) as was done before, it
2198 // will also work for wxWindowDC and wxClientDC even though their size is
2199 // not the same as the total size of the screen
2200 int wPixels, hPixels;
2201 DoGetSize(&wPixels, &hPixels);
2202
2203 if ( w )
2204 {
2205 int wTotal = ::GetDeviceCaps(GetHdc(), HORZRES);
2206
2207 wxCHECK_RET( wTotal, _T("0 width device?") );
2208
2209 *w = (wPixels * ::GetDeviceCaps(GetHdc(), HORZSIZE)) / wTotal;
2210 }
2211
2212 if ( h )
2213 {
2214 int hTotal = ::GetDeviceCaps(GetHdc(), VERTRES);
2215
2216 wxCHECK_RET( hTotal, _T("0 height device?") );
2217
2218 *h = (hPixels * ::GetDeviceCaps(GetHdc(), VERTSIZE)) / hTotal;
2219 }
2220 }
2221
2222 wxSize wxDC::GetPPI() const
2223 {
2224 WXMICROWIN_CHECK_HDC_RET(wxSize())
2225
2226 int x = ::GetDeviceCaps(GetHdc(), LOGPIXELSX);
2227 int y = ::GetDeviceCaps(GetHdc(), LOGPIXELSY);
2228
2229 return wxSize(x, y);
2230 }
2231
2232 // For use by wxWidgets only, unless custom units are required.
2233 void wxDC::SetLogicalScale(double x, double y)
2234 {
2235 WXMICROWIN_CHECK_HDC
2236
2237 m_logicalScaleX = x;
2238 m_logicalScaleY = y;
2239 }
2240
2241 // ----------------------------------------------------------------------------
2242 // DC caching
2243 // ----------------------------------------------------------------------------
2244
2245 #if wxUSE_DC_CACHEING
2246
2247 /*
2248 * This implementation is a bit ugly and uses the old-fashioned wxList class, so I will
2249 * improve it in due course, either using arrays, or simply storing pointers to one
2250 * entry for the bitmap, and two for the DCs. -- JACS
2251 */
2252
2253 wxList wxDC::sm_bitmapCache;
2254 wxList wxDC::sm_dcCache;
2255
2256 wxDCCacheEntry::wxDCCacheEntry(WXHBITMAP hBitmap, int w, int h, int depth)
2257 {
2258 m_bitmap = hBitmap;
2259 m_dc = 0;
2260 m_width = w;
2261 m_height = h;
2262 m_depth = depth;
2263 }
2264
2265 wxDCCacheEntry::wxDCCacheEntry(WXHDC hDC, int depth)
2266 {
2267 m_bitmap = 0;
2268 m_dc = hDC;
2269 m_width = 0;
2270 m_height = 0;
2271 m_depth = depth;
2272 }
2273
2274 wxDCCacheEntry::~wxDCCacheEntry()
2275 {
2276 if (m_bitmap)
2277 ::DeleteObject((HBITMAP) m_bitmap);
2278 if (m_dc)
2279 ::DeleteDC((HDC) m_dc);
2280 }
2281
2282 wxDCCacheEntry* wxDC::FindBitmapInCache(WXHDC dc, int w, int h)
2283 {
2284 int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
2285 wxList::compatibility_iterator node = sm_bitmapCache.GetFirst();
2286 while (node)
2287 {
2288 wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
2289
2290 if (entry->m_depth == depth)
2291 {
2292 if (entry->m_width < w || entry->m_height < h)
2293 {
2294 ::DeleteObject((HBITMAP) entry->m_bitmap);
2295 entry->m_bitmap = (WXHBITMAP) ::CreateCompatibleBitmap((HDC) dc, w, h);
2296 if ( !entry->m_bitmap)
2297 {
2298 wxLogLastError(wxT("CreateCompatibleBitmap"));
2299 }
2300 entry->m_width = w; entry->m_height = h;
2301 return entry;
2302 }
2303 return entry;
2304 }
2305
2306 node = node->GetNext();
2307 }
2308 WXHBITMAP hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap((HDC) dc, w, h);
2309 if ( !hBitmap)
2310 {
2311 wxLogLastError(wxT("CreateCompatibleBitmap"));
2312 }
2313 wxDCCacheEntry* entry = new wxDCCacheEntry(hBitmap, w, h, depth);
2314 AddToBitmapCache(entry);
2315 return entry;
2316 }
2317
2318 wxDCCacheEntry* wxDC::FindDCInCache(wxDCCacheEntry* notThis, WXHDC dc)
2319 {
2320 int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
2321 wxList::compatibility_iterator node = sm_dcCache.GetFirst();
2322 while (node)
2323 {
2324 wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
2325
2326 // Don't return the same one as we already have
2327 if (!notThis || (notThis != entry))
2328 {
2329 if (entry->m_depth == depth)
2330 {
2331 return entry;
2332 }
2333 }
2334
2335 node = node->GetNext();
2336 }
2337 WXHDC hDC = (WXHDC) ::CreateCompatibleDC((HDC) dc);
2338 if ( !hDC)
2339 {
2340 wxLogLastError(wxT("CreateCompatibleDC"));
2341 }
2342 wxDCCacheEntry* entry = new wxDCCacheEntry(hDC, depth);
2343 AddToDCCache(entry);
2344 return entry;
2345 }
2346
2347 void wxDC::AddToBitmapCache(wxDCCacheEntry* entry)
2348 {
2349 sm_bitmapCache.Append(entry);
2350 }
2351
2352 void wxDC::AddToDCCache(wxDCCacheEntry* entry)
2353 {
2354 sm_dcCache.Append(entry);
2355 }
2356
2357 void wxDC::ClearCache()
2358 {
2359 WX_CLEAR_LIST(wxList, sm_dcCache);
2360 WX_CLEAR_LIST(wxList, sm_bitmapCache);
2361 }
2362
2363 // Clean up cache at app exit
2364 class wxDCModule : public wxModule
2365 {
2366 public:
2367 virtual bool OnInit() { return true; }
2368 virtual void OnExit() { wxDC::ClearCache(); }
2369
2370 private:
2371 DECLARE_DYNAMIC_CLASS(wxDCModule)
2372 };
2373
2374 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
2375
2376 #endif // wxUSE_DC_CACHEING
2377
2378 // ----------------------------------------------------------------------------
2379 // alpha channel support
2380 // ----------------------------------------------------------------------------
2381
2382 static bool AlphaBlt(HDC hdcDst,
2383 int x, int y, int width, int height,
2384 HDC hdcSrc,
2385 const wxBitmap& bmp)
2386 {
2387 wxASSERT_MSG( bmp.Ok() && bmp.HasAlpha(), _T("AlphaBlt(): invalid bitmap") );
2388 wxASSERT_MSG( hdcDst && hdcSrc, _T("AlphaBlt(): invalid HDC") );
2389
2390 // do we have AlphaBlend() and company in the headers?
2391 #if defined(AC_SRC_OVER) && wxUSE_DYNLIB_CLASS
2392 // yes, now try to see if we have it during run-time
2393 typedef BOOL (WINAPI *AlphaBlend_t)(HDC,int,int,int,int,
2394 HDC,int,int,int,int,
2395 BLENDFUNCTION);
2396
2397 // bitmaps can be drawn only from GUI thread so there is no need to
2398 // protect this static variable from multiple threads
2399 static bool s_triedToLoad = false;
2400 static AlphaBlend_t pfnAlphaBlend = NULL;
2401 if ( !s_triedToLoad )
2402 {
2403 s_triedToLoad = true;
2404
2405 // don't give errors about the DLL being unavailable, we're
2406 // prepared to handle this
2407 wxLogNull nolog;
2408
2409 wxDynamicLibrary dll(_T("msimg32.dll"));
2410 if ( dll.IsLoaded() )
2411 {
2412 pfnAlphaBlend = (AlphaBlend_t)dll.GetSymbol(_T("AlphaBlend"));
2413 if ( pfnAlphaBlend )
2414 {
2415 // we must keep the DLL loaded if we want to be able to
2416 // call AlphaBlend() so just never unload it at all, not a
2417 // big deal
2418 dll.Detach();
2419 }
2420 }
2421 }
2422
2423 if ( pfnAlphaBlend )
2424 {
2425 BLENDFUNCTION bf;
2426 bf.BlendOp = AC_SRC_OVER;
2427 bf.BlendFlags = 0;
2428 bf.SourceConstantAlpha = 0xff;
2429 bf.AlphaFormat = AC_SRC_ALPHA;
2430
2431 if ( pfnAlphaBlend(hdcDst, x, y, width, height,
2432 hdcSrc, 0, 0, width, height,
2433 bf) )
2434 {
2435 // skip wxAlphaBlend() call below
2436 return true;
2437 }
2438
2439 wxLogLastError(_T("AlphaBlend"));
2440 }
2441 #endif // defined(AC_SRC_OVER)
2442
2443 // AlphaBlend() unavailable of failed: use our own (probably much slower)
2444 // implementation
2445 #ifdef wxHAVE_RAW_BITMAP
2446 wxAlphaBlend(hdcDst, x, y, width, height, bmp);
2447
2448 return true;
2449 #else // !wxHAVE_RAW_BITMAP
2450 // no wxAlphaBlend() neither, fall back to using simple BitBlt() (we lose
2451 // alpha but at least something will be shown like this)
2452 return false;
2453 #endif // wxHAVE_RAW_BITMAP
2454 }
2455
2456
2457 // wxAlphaBlend: our fallback if ::AlphaBlend() is unavailable
2458 #ifdef wxHAVE_RAW_BITMAP
2459
2460 static void
2461 wxAlphaBlend(HDC hdcDst, int xDst, int yDst, int w, int h, const wxBitmap& bmpSrc)
2462 {
2463 // get the destination DC pixels
2464 wxBitmap bmpDst(w, h, 32 /* force creating RGBA DIB */);
2465 MemoryHDC hdcMem;
2466 SelectInHDC select(hdcMem, GetHbitmapOf(bmpDst));
2467
2468 if ( !::BitBlt(hdcMem, 0, 0, w, h, hdcDst, 0, 0, SRCCOPY) )
2469 {
2470 wxLogLastError(_T("BitBlt"));
2471 }
2472
2473 // combine them with the source bitmap using alpha
2474 wxAlphaPixelData dataDst(bmpDst),
2475 dataSrc((wxBitmap &)bmpSrc);
2476
2477 wxCHECK_RET( dataDst && dataSrc,
2478 _T("failed to get raw data in wxAlphaBlend") );
2479
2480 wxAlphaPixelData::Iterator pDst(dataDst),
2481 pSrc(dataSrc);
2482
2483 for ( int y = 0; y < h; y++ )
2484 {
2485 wxAlphaPixelData::Iterator pDstRowStart = pDst,
2486 pSrcRowStart = pSrc;
2487
2488 for ( int x = 0; x < w; x++ )
2489 {
2490 // note that source bitmap uses premultiplied alpha (as required by
2491 // the real AlphaBlend)
2492 const unsigned beta = 255 - pSrc.Alpha();
2493
2494 pDst.Red() = pSrc.Red() + (beta * pDst.Red() + 127) / 255;
2495 pDst.Blue() = pSrc.Blue() + (beta * pDst.Blue() + 127) / 255;
2496 pDst.Green() = pSrc.Green() + (beta * pDst.Green() + 127) / 255;
2497
2498 ++pDst;
2499 ++pSrc;
2500 }
2501
2502 pDst = pDstRowStart;
2503 pSrc = pSrcRowStart;
2504 pDst.OffsetY(dataDst, 1);
2505 pSrc.OffsetY(dataSrc, 1);
2506 }
2507
2508 // and finally blit them back to the destination DC
2509 if ( !::BitBlt(hdcDst, xDst, yDst, w, h, hdcMem, 0, 0, SRCCOPY) )
2510 {
2511 wxLogLastError(_T("BitBlt"));
2512 }
2513 }
2514
2515 #endif // #ifdef wxHAVE_RAW_BITMAP
wxWidgets (Impactor)