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