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