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