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