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