Commit | Line | Data |
---|---|---|
2bda0e17 KB |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: dc.cpp | |
3 | // Purpose: wxDC class | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 01/02/97 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart and Markus Holzem | |
fd3f686c | 9 | // Licence: wxWindows licence |
2bda0e17 KB |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
a23fd0e1 VZ |
12 | // =========================================================================== |
13 | // declarations | |
14 | // =========================================================================== | |
15 | ||
16 | // --------------------------------------------------------------------------- | |
17 | // headers | |
18 | // --------------------------------------------------------------------------- | |
19 | ||
2bda0e17 | 20 | #ifdef __GNUG__ |
a23fd0e1 | 21 | #pragma implementation "dc.h" |
2bda0e17 KB |
22 | #endif |
23 | ||
24 | // For compilers that support precompilation, includes "wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | #ifdef __BORLANDC__ | |
a23fd0e1 | 28 | #pragma hdrstop |
2bda0e17 KB |
29 | #endif |
30 | ||
31 | #ifndef WX_PRECOMP | |
4286a5b5 | 32 | #include "wx/window.h" |
a23fd0e1 VZ |
33 | #include "wx/dc.h" |
34 | #include "wx/utils.h" | |
35 | #include "wx/dialog.h" | |
36 | #include "wx/app.h" | |
37 | #include "wx/bitmap.h" | |
38 | #include "wx/dcmemory.h" | |
0c589ad0 | 39 | #include "wx/log.h" |
4286a5b5 | 40 | #include "wx/icon.h" |
2bda0e17 KB |
41 | #endif |
42 | ||
840bb342 | 43 | #include "wx/settings.h" |
2bda0e17 | 44 | #include "wx/dcprint.h" |
2bda0e17 KB |
45 | |
46 | #include <string.h> | |
47 | #include <math.h> | |
2bda0e17 | 48 | |
a58a12e9 VZ |
49 | #include "wx/msw/private.h" // needs to be before #include <commdlg.h> |
50 | ||
47d67540 | 51 | #if wxUSE_COMMON_DIALOGS |
a23fd0e1 | 52 | #include <commdlg.h> |
2bda0e17 KB |
53 | #endif |
54 | ||
55 | #ifndef __WIN32__ | |
a23fd0e1 | 56 | #include <print.h> |
2bda0e17 KB |
57 | #endif |
58 | ||
5acb7b3e | 59 | IMPLEMENT_ABSTRACT_CLASS(wxDC, wxDCBase) |
2bda0e17 | 60 | |
a23fd0e1 VZ |
61 | // --------------------------------------------------------------------------- |
62 | // constants | |
63 | // --------------------------------------------------------------------------- | |
64 | ||
42e69d6b VZ |
65 | static const int VIEWPORT_EXTENT = 1000; |
66 | ||
67 | static const int MM_POINTS = 9; | |
68 | static const int MM_METRIC = 10; | |
a23fd0e1 | 69 | |
4314ec48 VZ |
70 | // usually this is defined in math.h |
71 | #ifndef M_PI | |
72 | static const double M_PI = 3.14159265358979323846; | |
73 | #endif // M_PI | |
74 | ||
4aff28fc VZ |
75 | // ROPs which don't have standard names (see "Ternary Raster Operations" in the |
76 | // MSDN docs for how this and other numbers in wxDC::Blit() are obtained) | |
77 | #define DSTCOPY 0x00AA0029 // a.k.a. NOP operation | |
78 | ||
4314ec48 VZ |
79 | // --------------------------------------------------------------------------- |
80 | // private functions | |
81 | // --------------------------------------------------------------------------- | |
82 | ||
83 | // convert degrees to radians | |
84 | static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; } | |
85 | ||
f6bcfd97 BP |
86 | // ---------------------------------------------------------------------------- |
87 | // private classes | |
88 | // ---------------------------------------------------------------------------- | |
89 | ||
90 | // instead of duplicating the same code which sets and then restores text | |
91 | // colours in each wxDC method working with wxSTIPPLE_MASK_OPAQUE brushes, | |
92 | // encapsulate this in a small helper class | |
93 | ||
94 | // wxColourChanger: changes the text colours in the ctor if required and | |
95 | // restores them in the dtor | |
96 | class wxColourChanger | |
97 | { | |
98 | public: | |
99 | wxColourChanger(wxDC& dc); | |
100 | ~wxColourChanger(); | |
101 | ||
102 | private: | |
103 | wxDC& m_dc; | |
104 | ||
105 | COLORREF m_colFgOld, m_colBgOld; | |
106 | ||
107 | bool m_changed; | |
108 | }; | |
109 | ||
a23fd0e1 VZ |
110 | // =========================================================================== |
111 | // implementation | |
112 | // =========================================================================== | |
113 | ||
f6bcfd97 BP |
114 | // ---------------------------------------------------------------------------- |
115 | // wxColourChanger | |
116 | // ---------------------------------------------------------------------------- | |
117 | ||
118 | wxColourChanger::wxColourChanger(wxDC& dc) : m_dc(dc) | |
119 | { | |
120 | if ( dc.GetBrush().GetStyle() == wxSTIPPLE_MASK_OPAQUE ) | |
121 | { | |
122 | HDC hdc = GetHdcOf(dc); | |
123 | m_colFgOld = ::GetTextColor(hdc); | |
124 | m_colBgOld = ::GetBkColor(hdc); | |
125 | ||
126 | // note that Windows convention is opposite to wxWindows one, this is | |
127 | // why text colour becomes the background one and vice versa | |
128 | const wxColour& colFg = dc.GetTextForeground(); | |
129 | if ( colFg.Ok() ) | |
130 | { | |
131 | ::SetBkColor(hdc, colFg.GetPixel()); | |
132 | } | |
133 | ||
134 | const wxColour& colBg = dc.GetTextBackground(); | |
135 | if ( colBg.Ok() ) | |
136 | { | |
137 | ::SetTextColor(hdc, colBg.GetPixel()); | |
138 | } | |
139 | ||
140 | SetBkMode(hdc, | |
141 | dc.GetBackgroundMode() == wxTRANSPARENT ? TRANSPARENT | |
142 | : OPAQUE); | |
143 | ||
144 | // flag which telsl us to undo changes in the dtor | |
145 | m_changed = TRUE; | |
146 | } | |
147 | else | |
148 | { | |
149 | // nothing done, nothing to undo | |
150 | m_changed = FALSE; | |
151 | } | |
152 | } | |
153 | ||
154 | wxColourChanger::~wxColourChanger() | |
155 | { | |
156 | if ( m_changed ) | |
157 | { | |
158 | // restore the colours we changed | |
159 | HDC hdc = GetHdcOf(m_dc); | |
160 | ||
161 | ::SetBkMode(hdc, TRANSPARENT); | |
162 | ::SetTextColor(hdc, m_colFgOld); | |
163 | ::SetBkColor(hdc, m_colBgOld); | |
164 | } | |
165 | } | |
166 | ||
a23fd0e1 VZ |
167 | // --------------------------------------------------------------------------- |
168 | // wxDC | |
169 | // --------------------------------------------------------------------------- | |
2bda0e17 KB |
170 | |
171 | // Default constructor | |
a23fd0e1 | 172 | wxDC::wxDC() |
2bda0e17 | 173 | { |
7bcb11d3 | 174 | m_canvas = NULL; |
a23fd0e1 | 175 | |
7bcb11d3 JS |
176 | m_oldBitmap = 0; |
177 | m_oldPen = 0; | |
178 | m_oldBrush = 0; | |
179 | m_oldFont = 0; | |
180 | m_oldPalette = 0; | |
a23fd0e1 | 181 | |
7bcb11d3 JS |
182 | m_bOwnsDC = FALSE; |
183 | m_hDC = 0; | |
a23fd0e1 | 184 | |
7bcb11d3 JS |
185 | m_windowExtX = VIEWPORT_EXTENT; |
186 | m_windowExtY = VIEWPORT_EXTENT; | |
2bda0e17 KB |
187 | } |
188 | ||
189 | ||
a23fd0e1 | 190 | wxDC::~wxDC() |
2bda0e17 | 191 | { |
7ba4fbeb VZ |
192 | if ( m_hDC != 0 ) |
193 | { | |
7bcb11d3 | 194 | SelectOldObjects(m_hDC); |
7ba4fbeb VZ |
195 | |
196 | // if we own the HDC, we delete it, otherwise we just release it | |
197 | ||
198 | if ( m_bOwnsDC ) | |
199 | { | |
200 | ::DeleteDC(GetHdc()); | |
7bcb11d3 | 201 | } |
7ba4fbeb VZ |
202 | else // we don't own our HDC |
203 | { | |
db400410 JS |
204 | if (m_canvas) |
205 | { | |
206 | ::ReleaseDC(GetHwndOf(m_canvas), GetHdc()); | |
207 | } | |
208 | else | |
209 | { | |
210 | // Must have been a wxScreenDC | |
211 | ::ReleaseDC((HWND) NULL, GetHdc()); | |
212 | } | |
7ba4fbeb VZ |
213 | } |
214 | } | |
2bda0e17 KB |
215 | } |
216 | ||
217 | // This will select current objects out of the DC, | |
218 | // which is what you have to do before deleting the | |
219 | // DC. | |
220 | void wxDC::SelectOldObjects(WXHDC dc) | |
221 | { | |
7bcb11d3 | 222 | if (dc) |
2bda0e17 | 223 | { |
7bcb11d3 JS |
224 | if (m_oldBitmap) |
225 | { | |
226 | ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap); | |
227 | if (m_selectedBitmap.Ok()) | |
228 | { | |
229 | m_selectedBitmap.SetSelectedInto(NULL); | |
230 | } | |
231 | } | |
a23fd0e1 | 232 | m_oldBitmap = 0; |
7bcb11d3 JS |
233 | if (m_oldPen) |
234 | { | |
235 | ::SelectObject((HDC) dc, (HPEN) m_oldPen); | |
236 | } | |
a23fd0e1 | 237 | m_oldPen = 0; |
7bcb11d3 JS |
238 | if (m_oldBrush) |
239 | { | |
240 | ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush); | |
241 | } | |
a23fd0e1 | 242 | m_oldBrush = 0; |
7bcb11d3 JS |
243 | if (m_oldFont) |
244 | { | |
245 | ::SelectObject((HDC) dc, (HFONT) m_oldFont); | |
246 | } | |
a23fd0e1 | 247 | m_oldFont = 0; |
7bcb11d3 JS |
248 | if (m_oldPalette) |
249 | { | |
250 | ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE); | |
251 | } | |
a23fd0e1 | 252 | m_oldPalette = 0; |
2bda0e17 | 253 | } |
a23fd0e1 VZ |
254 | |
255 | m_brush = wxNullBrush; | |
7bcb11d3 JS |
256 | m_pen = wxNullPen; |
257 | m_palette = wxNullPalette; | |
258 | m_font = wxNullFont; | |
259 | m_backgroundBrush = wxNullBrush; | |
260 | m_selectedBitmap = wxNullBitmap; | |
2bda0e17 KB |
261 | } |
262 | ||
a23fd0e1 VZ |
263 | // --------------------------------------------------------------------------- |
264 | // clipping | |
265 | // --------------------------------------------------------------------------- | |
266 | ||
f547e9bb RL |
267 | #define DO_SET_CLIPPING_BOX() \ |
268 | { \ | |
269 | RECT rect; \ | |
270 | \ | |
271 | GetClipBox(GetHdc(), &rect); \ | |
272 | \ | |
273 | m_clipX1 = (wxCoord) XDEV2LOG(rect.left); \ | |
274 | m_clipY1 = (wxCoord) YDEV2LOG(rect.top); \ | |
275 | m_clipX2 = (wxCoord) XDEV2LOG(rect.right); \ | |
276 | m_clipY2 = (wxCoord) YDEV2LOG(rect.bottom); \ | |
277 | } | |
278 | ||
c4218a74 | 279 | void wxDC::DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h) |
2bda0e17 | 280 | { |
7bcb11d3 | 281 | m_clipping = TRUE; |
40a89076 | 282 | |
c4218a74 VZ |
283 | // the region coords are always the device ones, so do the translation |
284 | // manually | |
285 | HRGN hrgn = ::CreateRectRgn(LogicalToDeviceX(x), | |
286 | LogicalToDeviceY(y), | |
287 | LogicalToDeviceX(x + w), | |
288 | LogicalToDeviceY(y + h)); | |
40a89076 VZ |
289 | if ( !hrgn ) |
290 | { | |
291 | wxLogLastError(_T("CreateRectRgn")); | |
292 | } | |
293 | else | |
294 | { | |
295 | if ( ::SelectClipRgn(GetHdc(), hrgn) == ERROR ) | |
296 | { | |
297 | wxLogLastError(_T("SelectClipRgn")); | |
298 | } | |
299 | ||
300 | DO_SET_CLIPPING_BOX() | |
301 | } | |
2bda0e17 KB |
302 | } |
303 | ||
a23fd0e1 | 304 | void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region) |
a724d789 | 305 | { |
223d09f6 | 306 | wxCHECK_RET( region.GetHRGN(), wxT("invalid clipping region") ); |
a23fd0e1 | 307 | |
7bcb11d3 | 308 | m_clipping = TRUE; |
a23fd0e1 | 309 | |
1e6d9499 | 310 | #ifdef __WIN16__ |
a23fd0e1 | 311 | SelectClipRgn(GetHdc(), (HRGN) region.GetHRGN()); |
1e6d9499 | 312 | #else |
a23fd0e1 | 313 | ExtSelectClipRgn(GetHdc(), (HRGN) region.GetHRGN(), RGN_AND); |
1e6d9499 | 314 | #endif |
a724d789 | 315 | |
f547e9bb | 316 | DO_SET_CLIPPING_BOX() |
2bda0e17 KB |
317 | } |
318 | ||
a23fd0e1 | 319 | void wxDC::DestroyClippingRegion() |
2bda0e17 | 320 | { |
7bcb11d3 JS |
321 | if (m_clipping && m_hDC) |
322 | { | |
323 | // TODO: this should restore the previous clipping region, | |
324 | // so that OnPaint processing works correctly, and the update clipping region | |
325 | // doesn't get destroyed after the first DestroyClippingRegion. | |
326 | HRGN rgn = CreateRectRgn(0, 0, 32000, 32000); | |
a23fd0e1 | 327 | SelectClipRgn(GetHdc(), rgn); |
7bcb11d3 JS |
328 | DeleteObject(rgn); |
329 | } | |
330 | m_clipping = FALSE; | |
2bda0e17 KB |
331 | } |
332 | ||
a23fd0e1 VZ |
333 | // --------------------------------------------------------------------------- |
334 | // query capabilities | |
335 | // --------------------------------------------------------------------------- | |
336 | ||
337 | bool wxDC::CanDrawBitmap() const | |
2bda0e17 | 338 | { |
7bcb11d3 | 339 | return TRUE; |
2bda0e17 KB |
340 | } |
341 | ||
a23fd0e1 | 342 | bool wxDC::CanGetTextExtent() const |
2bda0e17 | 343 | { |
7bcb11d3 | 344 | // What sort of display is it? |
a23fd0e1 VZ |
345 | int technology = ::GetDeviceCaps(GetHdc(), TECHNOLOGY); |
346 | ||
347 | return (technology == DT_RASDISPLAY) || (technology == DT_RASPRINTER); | |
2bda0e17 KB |
348 | } |
349 | ||
a23fd0e1 | 350 | int wxDC::GetDepth() const |
2bda0e17 | 351 | { |
a23fd0e1 | 352 | return (int)::GetDeviceCaps(GetHdc(), BITSPIXEL); |
2bda0e17 KB |
353 | } |
354 | ||
a23fd0e1 VZ |
355 | // --------------------------------------------------------------------------- |
356 | // drawing | |
357 | // --------------------------------------------------------------------------- | |
358 | ||
359 | void wxDC::Clear() | |
2bda0e17 | 360 | { |
7bcb11d3 | 361 | RECT rect; |
2506aab6 VZ |
362 | if ( m_canvas ) |
363 | { | |
7bcb11d3 | 364 | GetClientRect((HWND) m_canvas->GetHWND(), &rect); |
2506aab6 VZ |
365 | } |
366 | else | |
7bcb11d3 | 367 | { |
eaeb6a3c JS |
368 | // No, I think we should simply ignore this if printing on e.g. |
369 | // a printer DC. | |
370 | // wxCHECK_RET( m_selectedBitmap.Ok(), wxT("this DC can't be cleared") ); | |
371 | if (!m_selectedBitmap.Ok()) | |
372 | return; | |
2506aab6 | 373 | |
7bcb11d3 JS |
374 | rect.left = 0; rect.top = 0; |
375 | rect.right = m_selectedBitmap.GetWidth(); | |
376 | rect.bottom = m_selectedBitmap.GetHeight(); | |
377 | } | |
2506aab6 | 378 | |
a23fd0e1 VZ |
379 | (void) ::SetMapMode(GetHdc(), MM_TEXT); |
380 | ||
381 | DWORD colour = GetBkColor(GetHdc()); | |
7bcb11d3 | 382 | HBRUSH brush = CreateSolidBrush(colour); |
a23fd0e1 | 383 | FillRect(GetHdc(), &rect, brush); |
7bcb11d3 | 384 | DeleteObject(brush); |
a23fd0e1 VZ |
385 | |
386 | ::SetMapMode(GetHdc(), MM_ANISOTROPIC); | |
387 | ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL); | |
388 | ::SetWindowExtEx(GetHdc(), m_windowExtX, m_windowExtY, NULL); | |
389 | ::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL); | |
390 | ::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL); | |
391 | } | |
392 | ||
72cdf4c9 | 393 | void wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style) |
a23fd0e1 | 394 | { |
0bafad0c VZ |
395 | if ( !::ExtFloodFill(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), |
396 | col.GetPixel(), | |
397 | style == wxFLOOD_SURFACE ? FLOODFILLSURFACE | |
398 | : FLOODFILLBORDER) ) | |
399 | { | |
400 | // quoting from the MSDN docs: | |
401 | // | |
402 | // Following are some of the reasons this function might fail: | |
403 | // | |
404 | // * The filling could not be completed. | |
405 | // * The specified point has the boundary color specified by the | |
406 | // crColor parameter (if FLOODFILLBORDER was requested). | |
407 | // * The specified point does not have the color specified by | |
408 | // crColor (if FLOODFILLSURFACE was requested) | |
409 | // * The point is outside the clipping region that is, it is not | |
410 | // visible on the device. | |
411 | // | |
f6bcfd97 | 412 | wxLogLastError(wxT("ExtFloodFill")); |
0bafad0c | 413 | } |
a23fd0e1 | 414 | |
7bcb11d3 | 415 | CalcBoundingBox(x, y); |
2bda0e17 KB |
416 | } |
417 | ||
72cdf4c9 | 418 | bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const |
2bda0e17 | 419 | { |
f6bcfd97 BP |
420 | wxCHECK_MSG( col, FALSE, _T("NULL colour parameter in wxDC::GetPixel") ); |
421 | ||
7bcb11d3 | 422 | // get the color of the pixel |
a23fd0e1 | 423 | COLORREF pixelcolor = ::GetPixel(GetHdc(), XLOG2DEV(x), YLOG2DEV(y)); |
0bafad0c | 424 | |
f6bcfd97 | 425 | wxRGBToColour(*col, pixelcolor); |
dc1efb1d JS |
426 | |
427 | return TRUE; | |
2bda0e17 KB |
428 | } |
429 | ||
72cdf4c9 | 430 | void wxDC::DoCrossHair(wxCoord x, wxCoord y) |
a23fd0e1 | 431 | { |
72cdf4c9 VZ |
432 | wxCoord x1 = x-VIEWPORT_EXTENT; |
433 | wxCoord y1 = y-VIEWPORT_EXTENT; | |
434 | wxCoord x2 = x+VIEWPORT_EXTENT; | |
435 | wxCoord y2 = y+VIEWPORT_EXTENT; | |
a23fd0e1 VZ |
436 | |
437 | (void)MoveToEx(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y), NULL); | |
438 | (void)LineTo(GetHdc(), XLOG2DEV(x2), YLOG2DEV(y)); | |
439 | ||
440 | (void)MoveToEx(GetHdc(), XLOG2DEV(x), YLOG2DEV(y1), NULL); | |
441 | (void)LineTo(GetHdc(), XLOG2DEV(x), YLOG2DEV(y2)); | |
442 | ||
7bcb11d3 JS |
443 | CalcBoundingBox(x1, y1); |
444 | CalcBoundingBox(x2, y2); | |
2bda0e17 KB |
445 | } |
446 | ||
72cdf4c9 | 447 | void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) |
2bda0e17 | 448 | { |
a23fd0e1 VZ |
449 | (void)MoveToEx(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y1), NULL); |
450 | (void)LineTo(GetHdc(), XLOG2DEV(x2), YLOG2DEV(y2)); | |
451 | ||
058939fc JS |
452 | // Normalization: Windows doesn't draw the last point of the line. |
453 | // But apparently neither does GTK+, so we take it out again. | |
454 | // (void)LineTo(GetHdc(), XLOG2DEV(x2) + 1, YLOG2DEV(y2)); | |
a23fd0e1 | 455 | |
7bcb11d3 JS |
456 | CalcBoundingBox(x1, y1); |
457 | CalcBoundingBox(x2, y2); | |
2bda0e17 KB |
458 | } |
459 | ||
f6bcfd97 BP |
460 | // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1) |
461 | // and ending at (x2, y2) | |
462 | void wxDC::DoDrawArc(wxCoord x1, wxCoord y1, | |
463 | wxCoord x2, wxCoord y2, | |
464 | wxCoord xc, wxCoord yc) | |
2bda0e17 | 465 | { |
f6bcfd97 | 466 | wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling |
2d8a5cb1 | 467 | |
f6bcfd97 BP |
468 | double dx = xc - x1; |
469 | double dy = yc - y1; | |
470 | double radius = (double)sqrt(dx*dx+dy*dy); | |
471 | wxCoord r = (wxCoord)radius; | |
2d8a5cb1 | 472 | |
f6bcfd97 BP |
473 | // treat the special case of full circle separately |
474 | if ( x1 == x2 && y1 == y2 ) | |
7bcb11d3 | 475 | { |
f6bcfd97 | 476 | DrawEllipse(xc - r, yc - r, 2*r, 2*r); |
a23fd0e1 | 477 | return; |
7bcb11d3 | 478 | } |
a23fd0e1 | 479 | |
72cdf4c9 VZ |
480 | wxCoord xx1 = XLOG2DEV(x1); |
481 | wxCoord yy1 = YLOG2DEV(y1); | |
482 | wxCoord xx2 = XLOG2DEV(x2); | |
483 | wxCoord yy2 = YLOG2DEV(y2); | |
484 | wxCoord xxc = XLOG2DEV(xc); | |
485 | wxCoord yyc = YLOG2DEV(yc); | |
486 | wxCoord ray = (wxCoord) sqrt(double((xxc-xx1)*(xxc-xx1)+(yyc-yy1)*(yyc-yy1))); | |
a23fd0e1 | 487 | |
72cdf4c9 VZ |
488 | wxCoord xxx1 = (wxCoord) (xxc-ray); |
489 | wxCoord yyy1 = (wxCoord) (yyc-ray); | |
490 | wxCoord xxx2 = (wxCoord) (xxc+ray); | |
491 | wxCoord yyy2 = (wxCoord) (yyc+ray); | |
f6bcfd97 BP |
492 | |
493 | if ( m_brush.Ok() && m_brush.GetStyle() != wxTRANSPARENT ) | |
7bcb11d3 JS |
494 | { |
495 | // Have to add 1 to bottom-right corner of rectangle | |
496 | // to make semi-circles look right (crooked line otherwise). | |
497 | // Unfortunately this is not a reliable method, depends | |
498 | // on the size of shape. | |
499 | // TODO: figure out why this happens! | |
f6bcfd97 | 500 | Pie(GetHdc(),xxx1,yyy1,xxx2+1,yyy2+1, xx1,yy1,xx2,yy2); |
7bcb11d3 JS |
501 | } |
502 | else | |
2d8a5cb1 | 503 | { |
f6bcfd97 | 504 | Arc(GetHdc(),xxx1,yyy1,xxx2,yyy2, xx1,yy1,xx2,yy2); |
2d8a5cb1 | 505 | } |
f6bcfd97 BP |
506 | |
507 | CalcBoundingBox(xc - r, yc - r); | |
508 | CalcBoundingBox(xc + r, yc + r); | |
2bda0e17 KB |
509 | } |
510 | ||
cd9da200 VZ |
511 | void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1, |
512 | wxCoord width, wxCoord height) | |
513 | { | |
514 | wxCoord x2 = x1 + width, | |
515 | y2 = y1 + height; | |
516 | ||
517 | #if defined(__WIN32__) && !defined(__SC__) | |
518 | RECT rect; | |
519 | rect.left = x1; | |
520 | rect.top = y1; | |
521 | rect.right = x2; | |
522 | rect.bottom = y2; | |
523 | ||
524 | DrawFrameControl(GetHdc(), &rect, DFC_MENU, DFCS_MENUCHECK); | |
525 | #else // Win16 | |
526 | // In WIN16, draw a cross | |
527 | HPEN blackPen = ::CreatePen(PS_SOLID, 1, RGB(0, 0, 0)); | |
528 | HPEN whiteBrush = (HPEN)::GetStockObject(WHITE_BRUSH); | |
e06b9569 JS |
529 | HPEN hPenOld = (HPEN)::SelectObject(GetHdc(), blackPen); |
530 | HPEN hBrushOld = (HPEN)::SelectObject(GetHdc(), whiteBrush); | |
cd9da200 VZ |
531 | ::SetROP2(GetHdc(), R2_COPYPEN); |
532 | Rectangle(GetHdc(), x1, y1, x2, y2); | |
533 | MoveTo(GetHdc(), x1, y1); | |
534 | LineTo(GetHdc(), x2, y2); | |
535 | MoveTo(GetHdc(), x2, y1); | |
536 | LineTo(GetHdc(), x1, y2); | |
537 | ::SelectObject(GetHdc(), hPenOld); | |
538 | ::SelectObject(GetHdc(), hBrushOld); | |
539 | ::DeleteObject(blackPen); | |
540 | #endif // Win32/16 | |
541 | ||
542 | CalcBoundingBox(x1, y1); | |
543 | CalcBoundingBox(x2, y2); | |
544 | } | |
545 | ||
72cdf4c9 | 546 | void wxDC::DoDrawPoint(wxCoord x, wxCoord y) |
2bda0e17 | 547 | { |
7bcb11d3 JS |
548 | COLORREF color = 0x00ffffff; |
549 | if (m_pen.Ok()) | |
550 | { | |
a23fd0e1 | 551 | color = m_pen.GetColour().GetPixel(); |
7bcb11d3 | 552 | } |
a23fd0e1 VZ |
553 | |
554 | SetPixel(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), color); | |
555 | ||
7bcb11d3 | 556 | CalcBoundingBox(x, y); |
2bda0e17 KB |
557 | } |
558 | ||
72cdf4c9 | 559 | void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset,int fillStyle) |
2bda0e17 | 560 | { |
f6bcfd97 | 561 | wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling |
de2d2cdc | 562 | |
7bcb11d3 JS |
563 | // Do things less efficiently if we have offsets |
564 | if (xoffset != 0 || yoffset != 0) | |
6a6c0a8b | 565 | { |
7bcb11d3 JS |
566 | POINT *cpoints = new POINT[n]; |
567 | int i; | |
568 | for (i = 0; i < n; i++) | |
569 | { | |
570 | cpoints[i].x = (int)(points[i].x + xoffset); | |
571 | cpoints[i].y = (int)(points[i].y + yoffset); | |
a23fd0e1 | 572 | |
7bcb11d3 JS |
573 | CalcBoundingBox(cpoints[i].x, cpoints[i].y); |
574 | } | |
a23fd0e1 VZ |
575 | int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING); |
576 | (void)Polygon(GetHdc(), cpoints, n); | |
577 | SetPolyFillMode(GetHdc(),prev); | |
7bcb11d3 JS |
578 | delete[] cpoints; |
579 | } | |
580 | else | |
581 | { | |
582 | int i; | |
583 | for (i = 0; i < n; i++) | |
584 | CalcBoundingBox(points[i].x, points[i].y); | |
a23fd0e1 VZ |
585 | |
586 | int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING); | |
587 | (void)Polygon(GetHdc(), (POINT*) points, n); | |
588 | SetPolyFillMode(GetHdc(),prev); | |
6a6c0a8b | 589 | } |
2bda0e17 KB |
590 | } |
591 | ||
72cdf4c9 | 592 | void wxDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset) |
2bda0e17 | 593 | { |
7bcb11d3 JS |
594 | // Do things less efficiently if we have offsets |
595 | if (xoffset != 0 || yoffset != 0) | |
6a6c0a8b | 596 | { |
7bcb11d3 JS |
597 | POINT *cpoints = new POINT[n]; |
598 | int i; | |
599 | for (i = 0; i < n; i++) | |
600 | { | |
601 | cpoints[i].x = (int)(points[i].x + xoffset); | |
602 | cpoints[i].y = (int)(points[i].y + yoffset); | |
a23fd0e1 | 603 | |
7bcb11d3 JS |
604 | CalcBoundingBox(cpoints[i].x, cpoints[i].y); |
605 | } | |
a23fd0e1 | 606 | (void)Polyline(GetHdc(), cpoints, n); |
7bcb11d3 JS |
607 | delete[] cpoints; |
608 | } | |
609 | else | |
610 | { | |
611 | int i; | |
612 | for (i = 0; i < n; i++) | |
613 | CalcBoundingBox(points[i].x, points[i].y); | |
a23fd0e1 VZ |
614 | |
615 | (void)Polyline(GetHdc(), (POINT*) points, n); | |
6a6c0a8b | 616 | } |
2bda0e17 KB |
617 | } |
618 | ||
72cdf4c9 | 619 | void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) |
2bda0e17 | 620 | { |
f6bcfd97 | 621 | wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling |
de2d2cdc | 622 | |
72cdf4c9 VZ |
623 | wxCoord x2 = x + width; |
624 | wxCoord y2 = y + height; | |
a23fd0e1 | 625 | |
5456b916 | 626 | if ((m_logicalFunction == wxCOPY) && (m_pen.GetStyle() == wxTRANSPARENT)) |
0bafad0c | 627 | { |
7299b1b2 | 628 | RECT rect; |
5456b916 RR |
629 | rect.left = XLOG2DEV(x); |
630 | rect.top = YLOG2DEV(y); | |
631 | rect.right = XLOG2DEV(x2); | |
7299b1b2 RD |
632 | rect.bottom = YLOG2DEV(y2); |
633 | (void)FillRect(GetHdc(), &rect, (HBRUSH)m_brush.GetResourceHandle() ); | |
5456b916 RR |
634 | } |
635 | else | |
636 | { | |
637 | // Windows draws the filled rectangles without outline (i.e. drawn with a | |
638 | // transparent pen) one pixel smaller in both directions and we want them | |
f6bcfd97 | 639 | // to have the same size regardless of which pen is used - adjust |
5456b916 RR |
640 | |
641 |