Commit | Line | Data |
---|---|---|
1b89a5cd | 1 | ///////////////////////////////////////////////////////////////////////////// |
80fdcdb9 | 2 | // Name: src/common/dcgraph.cpp |
1b89a5cd SC |
3 | // Purpose: graphics context methods common to all platforms |
4 | // Author: Stefan Csomor | |
5 | // Modified by: | |
6c0aace2 | 6 | // Created: |
1b89a5cd SC |
7 | // RCS-ID: $Id$ |
8 | // Copyright: (c) Stefan Csomor | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // For compilers that support precompilation, includes "wx.h". | |
13 | #include "wx/wxprec.h" | |
14 | ||
15 | #if defined(__BORLANDC__) | |
16 | #pragma hdrstop | |
17 | #endif | |
18 | ||
19 | #if wxUSE_GRAPHICS_CONTEXT | |
20 | ||
888dde65 | 21 | #include "wx/dcgraph.h" |
1b89a5cd SC |
22 | |
23 | #ifndef WX_PRECOMP | |
24 | #include "wx/icon.h" | |
38ae64e6 | 25 | #include "wx/dcclient.h" |
1b89a5cd | 26 | #include "wx/dcmemory.h" |
fcaea2fa | 27 | #endif |
b02d4340 | 28 | |
1b89a5cd SC |
29 | //----------------------------------------------------------------------------- |
30 | // constants | |
31 | //----------------------------------------------------------------------------- | |
32 | ||
33 | static const double RAD2DEG = 180.0 / M_PI; | |
34 | ||
35 | //----------------------------------------------------------------------------- | |
36 | // Local functions | |
37 | //----------------------------------------------------------------------------- | |
38 | ||
39 | static inline double DegToRad(double deg) | |
40 | { | |
41 | return (deg * M_PI) / 180.0; | |
42 | } | |
43 | ||
fec4e458 | 44 | static wxCompositionMode TranslateRasterOp(wxRasterOperationMode function) |
bf02a7f9 SC |
45 | { |
46 | switch ( function ) | |
47 | { | |
954c66fa SC |
48 | case wxCOPY: // src |
49 | // since we are supporting alpha, _OVER is closer to the intention than _SOURCE | |
d13b34d3 | 50 | // since the latter would overwrite even when alpha is not set to opaque |
fec4e458 VZ |
51 | return wxCOMPOSITION_OVER; |
52 | ||
bf02a7f9 | 53 | case wxOR: // src OR dst |
fec4e458 VZ |
54 | return wxCOMPOSITION_ADD; |
55 | ||
bf02a7f9 | 56 | case wxNO_OP: // dst |
fec4e458 VZ |
57 | return wxCOMPOSITION_DEST; // ignore the source |
58 | ||
bf02a7f9 | 59 | case wxCLEAR: // 0 |
fec4e458 VZ |
60 | return wxCOMPOSITION_CLEAR;// clear dst |
61 | ||
bf02a7f9 | 62 | case wxXOR: // src XOR dst |
fec4e458 | 63 | return wxCOMPOSITION_XOR; |
03647350 | 64 | |
bf02a7f9 SC |
65 | case wxAND: // src AND dst |
66 | case wxAND_INVERT: // (NOT src) AND dst | |
67 | case wxAND_REVERSE:// src AND (NOT dst) | |
68 | case wxEQUIV: // (NOT src) XOR dst | |
69 | case wxINVERT: // NOT dst | |
70 | case wxNAND: // (NOT src) OR (NOT dst) | |
71 | case wxNOR: // (NOT src) AND (NOT dst) | |
72 | case wxOR_INVERT: // (NOT src) OR dst | |
73 | case wxOR_REVERSE: // src OR (NOT dst) | |
74 | case wxSET: // 1 | |
75 | case wxSRC_INVERT: // NOT src | |
fec4e458 | 76 | break; |
bf02a7f9 | 77 | } |
fec4e458 VZ |
78 | |
79 | return wxCOMPOSITION_INVALID; | |
bf02a7f9 SC |
80 | } |
81 | ||
1b89a5cd SC |
82 | //----------------------------------------------------------------------------- |
83 | // wxDC bridge class | |
84 | //----------------------------------------------------------------------------- | |
85 | ||
1b89a5cd | 86 | IMPLEMENT_DYNAMIC_CLASS(wxGCDC, wxDC) |
888dde65 | 87 | |
7b1a66bb RR |
88 | wxGCDC::wxGCDC(const wxWindowDC& dc) : |
89 | wxDC( new wxGCDCImpl( this, dc ) ) | |
888dde65 | 90 | { |
888dde65 RR |
91 | } |
92 | ||
7b1a66bb RR |
93 | wxGCDC::wxGCDC( const wxMemoryDC& dc) : |
94 | wxDC( new wxGCDCImpl( this, dc ) ) | |
888dde65 | 95 | { |
888dde65 | 96 | } |
1b89a5cd | 97 | |
6d0d8455 | 98 | #if wxUSE_PRINTING_ARCHITECTURE |
b25c34aa RR |
99 | wxGCDC::wxGCDC( const wxPrinterDC& dc) : |
100 | wxDC( new wxGCDCImpl( this, dc ) ) | |
101 | { | |
102 | } | |
6d0d8455 | 103 | #endif |
b25c34aa | 104 | |
2d770c4f VZ |
105 | #if defined(__WXMSW__) && wxUSE_ENH_METAFILE |
106 | wxGCDC::wxGCDC(const wxEnhMetaFileDC& dc) | |
107 | : wxDC(new wxGCDCImpl(this, dc)) | |
108 | { | |
109 | } | |
110 | #endif | |
111 | ||
932d0768 RD |
112 | wxGCDC::wxGCDC(wxGraphicsContext* context) : |
113 | wxDC( new wxGCDCImpl( this ) ) | |
114 | { | |
115 | SetGraphicsContext(context); | |
116 | } | |
117 | ||
7b1a66bb RR |
118 | wxGCDC::wxGCDC() : |
119 | wxDC( new wxGCDCImpl( this ) ) | |
1b89a5cd | 120 | { |
888dde65 RR |
121 | } |
122 | ||
9412ee9a SC |
123 | wxGCDC::~wxGCDC() |
124 | { | |
125 | } | |
126 | ||
6c0e710f | 127 | wxGraphicsContext* wxGCDC::GetGraphicsContext() const |
888dde65 RR |
128 | { |
129 | if (!m_pimpl) return NULL; | |
130 | wxGCDCImpl *gc_impl = (wxGCDCImpl*) m_pimpl; | |
131 | return gc_impl->GetGraphicsContext(); | |
1b89a5cd SC |
132 | } |
133 | ||
134 | void wxGCDC::SetGraphicsContext( wxGraphicsContext* ctx ) | |
888dde65 RR |
135 | { |
136 | if (!m_pimpl) return; | |
137 | wxGCDCImpl *gc_impl = (wxGCDCImpl*) m_pimpl; | |
138 | gc_impl->SetGraphicsContext( ctx ); | |
139 | } | |
140 | ||
141 | IMPLEMENT_ABSTRACT_CLASS(wxGCDCImpl, wxDCImpl) | |
142 | ||
143 | wxGCDCImpl::wxGCDCImpl( wxDC *owner ) : | |
144 | wxDCImpl( owner ) | |
145 | { | |
e7042ce7 | 146 | Init(wxGraphicsContext::Create()); |
888dde65 RR |
147 | } |
148 | ||
149 | void wxGCDCImpl::SetGraphicsContext( wxGraphicsContext* ctx ) | |
6c0aace2 | 150 | { |
1b89a5cd SC |
151 | delete m_graphicContext; |
152 | m_graphicContext = ctx; | |
914fd3f1 SC |
153 | if ( m_graphicContext ) |
154 | { | |
155 | m_matrixOriginal = m_graphicContext->GetTransform(); | |
156 | m_ok = true; | |
fd791571 SC |
157 | // apply the stored transformations to the passed in context |
158 | ComputeScaleAndOrigin(); | |
ad667945 SC |
159 | m_graphicContext->SetFont( m_font , m_textForegroundColour ); |
160 | m_graphicContext->SetPen( m_pen ); | |
161 | m_graphicContext->SetBrush( m_brush); | |
914fd3f1 | 162 | } |
1b89a5cd SC |
163 | } |
164 | ||
888dde65 RR |
165 | wxGCDCImpl::wxGCDCImpl( wxDC *owner, const wxWindowDC& dc ) : |
166 | wxDCImpl( owner ) | |
1b89a5cd | 167 | { |
e7042ce7 | 168 | Init(wxGraphicsContext::Create(dc)); |
7b98cf02 | 169 | m_window = dc.GetWindow(); |
1b89a5cd SC |
170 | } |
171 | ||
888dde65 RR |
172 | wxGCDCImpl::wxGCDCImpl( wxDC *owner, const wxMemoryDC& dc ) : |
173 | wxDCImpl( owner ) | |
773ccc31 | 174 | { |
e7042ce7 | 175 | Init(wxGraphicsContext::Create(dc)); |
773ccc31 | 176 | } |
773ccc31 | 177 | |
6d0d8455 | 178 | #if wxUSE_PRINTING_ARCHITECTURE |
b25c34aa RR |
179 | wxGCDCImpl::wxGCDCImpl( wxDC *owner, const wxPrinterDC& dc ) : |
180 | wxDCImpl( owner ) | |
181 | { | |
e7042ce7 | 182 | Init(wxGraphicsContext::Create(dc)); |
b25c34aa | 183 | } |
6d0d8455 | 184 | #endif |
b25c34aa | 185 | |
2d770c4f VZ |
186 | #if defined(__WXMSW__) && wxUSE_ENH_METAFILE |
187 | wxGCDCImpl::wxGCDCImpl(wxDC *owner, const wxEnhMetaFileDC& dc) | |
188 | : wxDCImpl(owner) | |
189 | { | |
e7042ce7 | 190 | Init(wxGraphicsContext::Create(dc)); |
2d770c4f VZ |
191 | } |
192 | #endif | |
193 | ||
f30b9eed PC |
194 | wxGCDCImpl::wxGCDCImpl(wxDC* owner, int) |
195 | : wxDCImpl(owner) | |
196 | { | |
197 | // derived class will set a context | |
198 | Init(NULL); | |
199 | } | |
200 | ||
e7042ce7 | 201 | void wxGCDCImpl::Init(wxGraphicsContext* ctx) |
1b89a5cd SC |
202 | { |
203 | m_ok = false; | |
204 | m_colour = true; | |
205 | m_mm_to_pix_x = mm2pt; | |
206 | m_mm_to_pix_y = mm2pt; | |
207 | ||
208 | m_pen = *wxBLACK_PEN; | |
209 | m_font = *wxNORMAL_FONT; | |
210 | m_brush = *wxWHITE_BRUSH; | |
211 | ||
e7042ce7 PC |
212 | m_graphicContext = NULL; |
213 | if (ctx) | |
214 | SetGraphicsContext(ctx); | |
215 | ||
4280b879 | 216 | m_logicalFunctionSupported = true; |
1b89a5cd SC |
217 | } |
218 | ||
888dde65 | 219 | wxGCDCImpl::~wxGCDCImpl() |
1b89a5cd SC |
220 | { |
221 | delete m_graphicContext; | |
222 | } | |
223 | ||
08de4403 VZ |
224 | void wxGCDCImpl::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, |
225 | bool useMask ) | |
1b89a5cd | 226 | { |
888dde65 RR |
227 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid DC") ); |
228 | wxCHECK_RET( bmp.IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid bitmap") ); | |
1b89a5cd | 229 | |
ec2df34e SC |
230 | int w = bmp.GetScaledWidth(); |
231 | int h = bmp.GetScaledHeight(); | |
f889bdb3 SC |
232 | if ( bmp.GetDepth() == 1 ) |
233 | { | |
234 | m_graphicContext->SetPen(*wxTRANSPARENT_PEN); | |
235 | m_graphicContext->SetBrush( wxBrush( m_textBackgroundColour , wxSOLID ) ); | |
08de4403 | 236 | m_graphicContext->DrawRectangle( x, y, w, h ); |
f889bdb3 | 237 | m_graphicContext->SetBrush( wxBrush( m_textForegroundColour , wxSOLID ) ); |
08de4403 | 238 | m_graphicContext->DrawBitmap( bmp, x, y, w, h ); |
f889bdb3 SC |
239 | m_graphicContext->SetBrush( m_graphicContext->CreateBrush(m_brush)); |
240 | m_graphicContext->SetPen( m_graphicContext->CreatePen(m_pen)); | |
241 | } | |
08de4403 VZ |
242 | else // not a monochrome bitmap, handle it normally |
243 | { | |
244 | // make a copy in case we need to remove its mask, if we don't modify | |
245 | // it the copy is cheap as bitmaps are reference-counted | |
246 | wxBitmap bmpCopy(bmp); | |
247 | if ( !useMask && bmp.GetMask() ) | |
248 | bmpCopy.SetMask(NULL); | |
249 | ||
250 | m_graphicContext->DrawBitmap( bmpCopy, x, y, w, h ); | |
251 | } | |
1b89a5cd SC |
252 | } |
253 | ||
888dde65 | 254 | void wxGCDCImpl::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y ) |
1b89a5cd | 255 | { |
888dde65 RR |
256 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawIcon - invalid DC") ); |
257 | wxCHECK_RET( icon.IsOk(), wxT("wxGCDC(cg)::DoDrawIcon - invalid icon") ); | |
1b89a5cd | 258 | |
1b89a5cd SC |
259 | wxCoord w = icon.GetWidth(); |
260 | wxCoord h = icon.GetHeight(); | |
1b89a5cd | 261 | |
0ebd9515 | 262 | m_graphicContext->DrawIcon( icon , x, y, w, h ); |
1b89a5cd SC |
263 | } |
264 | ||
b02d4340 | 265 | bool wxGCDCImpl::StartDoc( const wxString& WXUNUSED(message) ) |
fcaea2fa | 266 | { |
26dfebbd | 267 | return true; |
fcaea2fa SC |
268 | } |
269 | ||
b02d4340 | 270 | void wxGCDCImpl::EndDoc() |
fcaea2fa SC |
271 | { |
272 | } | |
273 | ||
888dde65 | 274 | void wxGCDCImpl::StartPage() |
fcaea2fa SC |
275 | { |
276 | } | |
277 | ||
b02d4340 | 278 | void wxGCDCImpl::EndPage() |
fcaea2fa SC |
279 | { |
280 | } | |
b02d4340 | 281 | |
888dde65 | 282 | void wxGCDCImpl::Flush() |
fcaea2fa | 283 | { |
50211394 | 284 | m_graphicContext->Flush(); |
fcaea2fa SC |
285 | } |
286 | ||
888dde65 | 287 | void wxGCDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord w, wxCoord h ) |
1b89a5cd | 288 | { |
888dde65 | 289 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoSetClippingRegion - invalid DC") ); |
1b89a5cd | 290 | |
0ebd9515 | 291 | m_graphicContext->Clip( x, y, w, h ); |
1b89a5cd | 292 | |
332afcdb | 293 | wxDCImpl::DoSetClippingRegion(x, y, w, h); |
1b89a5cd SC |
294 | } |
295 | ||
fdaad94e | 296 | void wxGCDCImpl::DoSetDeviceClippingRegion( const wxRegion ®ion ) |
1b89a5cd | 297 | { |
4bae004c | 298 | // region is in device coordinates |
fdaad94e | 299 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoSetDeviceClippingRegion - invalid DC") ); |
1b89a5cd SC |
300 | |
301 | if (region.Empty()) | |
302 | { | |
fcaea2fa | 303 | //DestroyClippingRegion(); |
1b89a5cd SC |
304 | return; |
305 | } | |
306 | ||
4bae004c | 307 | wxRegion logRegion( region ); |
1b89a5cd | 308 | wxCoord x, y, w, h; |
0ebd9515 | 309 | |
4bae004c SC |
310 | logRegion.Offset( DeviceToLogicalX(0), DeviceToLogicalY(0) ); |
311 | logRegion.GetBox( x, y, w, h ); | |
312 | ||
313 | m_graphicContext->Clip( logRegion ); | |
0ebd9515 | 314 | if ( m_clipping ) |
1b89a5cd | 315 | { |
0ebd9515 SC |
316 | m_clipX1 = wxMax( m_clipX1, x ); |
317 | m_clipY1 = wxMax( m_clipY1, y ); | |
318 | m_clipX2 = wxMin( m_clipX2, (x + w) ); | |
319 | m_clipY2 = wxMin( m_clipY2, (y + h) ); | |
1b89a5cd SC |
320 | } |
321 | else | |
322 | { | |
0ebd9515 | 323 | m_clipping = true; |
1b89a5cd | 324 | |
0ebd9515 SC |
325 | m_clipX1 = x; |
326 | m_clipY1 = y; | |
327 | m_clipX2 = x + w; | |
328 | m_clipY2 = y + h; | |
1b89a5cd SC |
329 | } |
330 | } | |
331 | ||
888dde65 | 332 | void wxGCDCImpl::DestroyClippingRegion() |
1b89a5cd SC |
333 | { |
334 | m_graphicContext->ResetClip(); | |
cb6e26b8 | 335 | // currently the clip eg of a window extends to the area between the scrollbars |
4c51a665 | 336 | // so we must explicitly make sure it only covers the area we want it to draw |
cb6e26b8 | 337 | int width, height ; |
888dde65 | 338 | GetOwner()->GetSize( &width , &height ) ; |
fcaea2fa | 339 | m_graphicContext->Clip( DeviceToLogicalX(0) , DeviceToLogicalY(0) , DeviceToLogicalXRel(width), DeviceToLogicalYRel(height) ); |
b02d4340 | 340 | |
1b89a5cd SC |
341 | m_graphicContext->SetPen( m_pen ); |
342 | m_graphicContext->SetBrush( m_brush ); | |
343 | ||
344 | m_clipping = false; | |
345 | } | |
346 | ||
888dde65 | 347 | void wxGCDCImpl::DoGetSizeMM( int* width, int* height ) const |
1b89a5cd SC |
348 | { |
349 | int w = 0, h = 0; | |
350 | ||
888dde65 | 351 | GetOwner()->GetSize( &w, &h ); |
1b89a5cd SC |
352 | if (width) |
353 | *width = long( double(w) / (m_scaleX * m_mm_to_pix_x) ); | |
354 | if (height) | |
355 | *height = long( double(h) / (m_scaleY * m_mm_to_pix_y) ); | |
356 | } | |
357 | ||
888dde65 | 358 | void wxGCDCImpl::SetTextForeground( const wxColour &col ) |
1b89a5cd | 359 | { |
888dde65 | 360 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::SetTextForeground - invalid DC") ); |
1b89a5cd | 361 | |
9c17ca3f SC |
362 | // don't set m_textForegroundColour to an invalid colour as we'd crash |
363 | // later then (we use m_textForegroundColour.GetColor() without checking | |
364 | // in a few places) | |
38274d1d | 365 | if ( col.IsOk() ) |
1b89a5cd SC |
366 | { |
367 | m_textForegroundColour = col; | |
368 | m_graphicContext->SetFont( m_font, m_textForegroundColour ); | |
369 | } | |
370 | } | |
371 | ||
888dde65 | 372 | void wxGCDCImpl::SetTextBackground( const wxColour &col ) |
1b89a5cd | 373 | { |
888dde65 | 374 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::SetTextBackground - invalid DC") ); |
1b89a5cd SC |
375 | |
376 | m_textBackgroundColour = col; | |
377 | } | |
378 | ||
888dde65 | 379 | wxSize wxGCDCImpl::GetPPI() const |
1b89a5cd SC |
380 | { |
381 | return wxSize(72, 72); | |
382 | } | |
383 | ||
888dde65 | 384 | int wxGCDCImpl::GetDepth() const |
1b89a5cd SC |
385 | { |
386 | return 32; | |
387 | } | |
388 | ||
888dde65 | 389 | void wxGCDCImpl::ComputeScaleAndOrigin() |
b02d4340 | 390 | { |
2dedef25 | 391 | wxDCImpl::ComputeScaleAndOrigin(); |
1b89a5cd | 392 | |
fd791571 SC |
393 | if ( m_graphicContext ) |
394 | { | |
395 | m_matrixCurrent = m_graphicContext->CreateMatrix(); | |
08de4403 | 396 | |
fd791571 | 397 | // the logical origin sets the origin to have new coordinates |
08de4403 | 398 | m_matrixCurrent.Translate( m_deviceOriginX - m_logicalOriginX * m_signX * m_scaleX, |
d2bb4c86 | 399 | m_deviceOriginY - m_logicalOriginY * m_signY * m_scaleY); |
08de4403 | 400 | |
d225267e | 401 | m_matrixCurrent.Scale( m_scaleX * m_signX, m_scaleY * m_signY ); |
08de4403 | 402 | |
fd791571 SC |
403 | m_graphicContext->SetTransform( m_matrixOriginal ); |
404 | m_graphicContext->ConcatTransform( m_matrixCurrent ); | |
405 | } | |
1b89a5cd SC |
406 | } |
407 | ||
9eefb5c1 RD |
408 | void* wxGCDCImpl::GetHandle() const |
409 | { | |
410 | void* cgctx = NULL; | |
411 | wxGraphicsContext* gc = GetGraphicsContext(); | |
412 | if (gc) { | |
413 | cgctx = gc->GetNativeContext(); | |
414 | } | |
415 | return cgctx; | |
416 | } | |
417 | ||
888dde65 | 418 | void wxGCDCImpl::SetPalette( const wxPalette& WXUNUSED(palette) ) |
1b89a5cd SC |
419 | { |
420 | ||
421 | } | |
422 | ||
888dde65 | 423 | void wxGCDCImpl::SetBackgroundMode( int mode ) |
1b89a5cd SC |
424 | { |
425 | m_backgroundMode = mode; | |
426 | } | |
427 | ||
888dde65 | 428 | void wxGCDCImpl::SetFont( const wxFont &font ) |
1b89a5cd SC |
429 | { |
430 | m_font = font; | |
431 | if ( m_graphicContext ) | |
432 | { | |
8bcf695e | 433 | m_graphicContext->SetFont(font, m_textForegroundColour); |
1b89a5cd SC |
434 | } |
435 | } | |
436 | ||
888dde65 | 437 | void wxGCDCImpl::SetPen( const wxPen &pen ) |
1b89a5cd | 438 | { |
1b89a5cd SC |
439 | m_pen = pen; |
440 | if ( m_graphicContext ) | |
441 | { | |
0ebd9515 | 442 | m_graphicContext->SetPen( m_pen ); |
1b89a5cd SC |
443 | } |
444 | } | |
445 | ||
888dde65 | 446 | void wxGCDCImpl::SetBrush( const wxBrush &brush ) |
1b89a5cd | 447 | { |
1b89a5cd SC |
448 | m_brush = brush; |
449 | if ( m_graphicContext ) | |
450 | { | |
0ebd9515 | 451 | m_graphicContext->SetBrush( m_brush ); |
1b89a5cd SC |
452 | } |
453 | } | |
b02d4340 | 454 | |
888dde65 | 455 | void wxGCDCImpl::SetBackground( const wxBrush &brush ) |
1b89a5cd | 456 | { |
1b89a5cd | 457 | m_backgroundBrush = brush; |
888dde65 | 458 | if (!m_backgroundBrush.IsOk()) |
1b89a5cd SC |
459 | return; |
460 | } | |
461 | ||
89efaf2b | 462 | void wxGCDCImpl::SetLogicalFunction( wxRasterOperationMode function ) |
1b89a5cd | 463 | { |
1b89a5cd | 464 | m_logicalFunction = function; |
03647350 | 465 | |
fec4e458 VZ |
466 | wxCompositionMode mode = TranslateRasterOp( function ); |
467 | m_logicalFunctionSupported = mode != wxCOMPOSITION_INVALID; | |
bf02a7f9 SC |
468 | if (m_logicalFunctionSupported) |
469 | m_logicalFunctionSupported = m_graphicContext->SetCompositionMode(mode); | |
03647350 | 470 | |
584be856 | 471 | if ( function == wxXOR ) |
bf02a7f9 | 472 | m_graphicContext->SetAntialiasMode(wxANTIALIAS_NONE); |
1b89a5cd | 473 | else |
bf02a7f9 | 474 | m_graphicContext->SetAntialiasMode(wxANTIALIAS_DEFAULT); |
1b89a5cd SC |
475 | } |
476 | ||
888dde65 | 477 | bool wxGCDCImpl::DoFloodFill(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), |
03647350 | 478 | const wxColour& WXUNUSED(col), |
89efaf2b | 479 | wxFloodFillStyle WXUNUSED(style)) |
1b89a5cd SC |
480 | { |
481 | return false; | |
482 | } | |
483 | ||
888dde65 | 484 | bool wxGCDCImpl::DoGetPixel( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), wxColour *WXUNUSED(col) ) const |
1b89a5cd SC |
485 | { |
486 | // wxCHECK_MSG( 0 , false, wxT("wxGCDC(cg)::DoGetPixel - not implemented") ); | |
487 | return false; | |
488 | } | |
489 | ||
888dde65 | 490 | void wxGCDCImpl::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 ) |
1b89a5cd | 491 | { |
888dde65 | 492 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawLine - invalid DC") ); |
1b89a5cd | 493 | |
4280b879 | 494 | if ( !m_logicalFunctionSupported ) |
1b89a5cd | 495 | return; |
1b89a5cd | 496 | |
0ebd9515 | 497 | m_graphicContext->StrokeLine(x1,y1,x2,y2); |
1b89a5cd SC |
498 | |
499 | CalcBoundingBox(x1, y1); | |
500 | CalcBoundingBox(x2, y2); | |
501 | } | |
502 | ||
888dde65 | 503 | void wxGCDCImpl::DoCrossHair( wxCoord x, wxCoord y ) |
1b89a5cd | 504 | { |
888dde65 | 505 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoCrossHair - invalid DC") ); |
1b89a5cd | 506 | |
4280b879 | 507 | if ( !m_logicalFunctionSupported ) |
1b89a5cd SC |
508 | return; |
509 | ||
510 | int w = 0, h = 0; | |
511 | ||
888dde65 | 512 | GetOwner()->GetSize( &w, &h ); |
1b89a5cd | 513 | |
0ebd9515 SC |
514 | m_graphicContext->StrokeLine(0,y,w,y); |
515 | m_graphicContext->StrokeLine(x,0,x,h); | |
1b89a5cd | 516 | |
0ebd9515 SC |
517 | CalcBoundingBox(0, 0); |
518 | CalcBoundingBox(0+w, 0+h); | |
1b89a5cd SC |
519 | } |
520 | ||
888dde65 | 521 | void wxGCDCImpl::DoDrawArc( wxCoord x1, wxCoord y1, |
1b89a5cd SC |
522 | wxCoord x2, wxCoord y2, |
523 | wxCoord xc, wxCoord yc ) | |
524 | { | |
888dde65 | 525 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawArc - invalid DC") ); |
1b89a5cd | 526 | |
4280b879 | 527 | if ( !m_logicalFunctionSupported ) |
1b89a5cd SC |
528 | return; |
529 | ||
0ebd9515 SC |
530 | double dx = x1 - xc; |
531 | double dy = y1 - yc; | |
1b89a5cd SC |
532 | double radius = sqrt((double)(dx * dx + dy * dy)); |
533 | wxCoord rad = (wxCoord)radius; | |
534 | double sa, ea; | |
0ebd9515 | 535 | if (x1 == x2 && y1 == y2) |
1b89a5cd SC |
536 | { |
537 | sa = 0.0; | |
538 | ea = 360.0; | |
539 | } | |
540 | else if (radius == 0.0) | |
541 | { | |
542 | sa = ea = 0.0; | |
543 | } | |
544 | else | |
545 | { | |
0ebd9515 SC |
546 | sa = (x1 - xc == 0) ? |
547 | (y1 - yc < 0) ? 90.0 : -90.0 : | |
548 | -atan2(double(y1 - yc), double(x1 - xc)) * RAD2DEG; | |
549 | ea = (x2 - xc == 0) ? | |
550 | (y2 - yc < 0) ? 90.0 : -90.0 : | |
551 | -atan2(double(y2 - yc), double(x2 - xc)) * RAD2DEG; | |
1b89a5cd SC |
552 | } |
553 | ||
554 | bool fill = m_brush.GetStyle() != wxTRANSPARENT; | |
555 | ||
a4e73390 | 556 | wxGraphicsPath path = m_graphicContext->CreatePath(); |
1b89a5cd | 557 | if ( fill && ((x1!=x2)||(y1!=y2)) ) |
0ebd9515 | 558 | path.MoveToPoint( xc, yc ); |
4bae004c SC |
559 | // since these angles (ea,sa) are measured counter-clockwise, we invert them to |
560 | // get clockwise angles | |
561 | path.AddArc( xc, yc , rad , DegToRad(-sa) , DegToRad(-ea), false ); | |
1b89a5cd | 562 | if ( fill && ((x1!=x2)||(y1!=y2)) ) |
0ebd9515 | 563 | path.AddLineToPoint( xc, yc ); |
1b89a5cd | 564 | m_graphicContext->DrawPath(path); |
1b89a5cd SC |
565 | } |
566 | ||
888dde65 | 567 | void wxGCDCImpl::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord w, wxCoord h, |
1b89a5cd SC |
568 | double sa, double ea ) |
569 | { | |
888dde65 | 570 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawEllipticArc - invalid DC") ); |
1b89a5cd | 571 | |
4280b879 | 572 | if ( !m_logicalFunctionSupported ) |
1b89a5cd SC |
573 | return; |
574 | ||
1b89a5cd | 575 | m_graphicContext->PushState(); |
d9485f89 | 576 | m_graphicContext->Translate(x+w/2.0,y+h/2.0); |
0ebd9515 | 577 | wxDouble factor = ((wxDouble) w) / h; |
1b89a5cd | 578 | m_graphicContext->Scale( factor , 1.0); |
d9485f89 | 579 | |
1b89a5cd SC |
580 | // since these angles (ea,sa) are measured counter-clockwise, we invert them to |
581 | // get clockwise angles | |
fcaea2fa SC |
582 | if ( m_brush.GetStyle() != wxTRANSPARENT ) |
583 | { | |
584 | wxGraphicsPath path = m_graphicContext->CreatePath(); | |
585 | path.MoveToPoint( 0, 0 ); | |
47c1bb95 | 586 | path.AddArc( 0, 0, h/2.0 , DegToRad(-sa) , DegToRad(-ea), sa > ea ); |
fcaea2fa SC |
587 | path.AddLineToPoint( 0, 0 ); |
588 | m_graphicContext->FillPath( path ); | |
589 | ||
590 | path = m_graphicContext->CreatePath(); | |
591 | path.AddArc( 0, 0, h/2.0 , DegToRad(-sa) , DegToRad(-ea), sa > ea ); | |
fcaea2fa SC |
592 | m_graphicContext->StrokePath( path ); |
593 | } | |
594 | else | |
595 | { | |
596 | wxGraphicsPath path = m_graphicContext->CreatePath(); | |
47c1bb95 SC |
597 | path.AddArc( 0, 0, h/2.0 , DegToRad(-sa) , DegToRad(-ea), sa > ea ); |
598 | m_graphicContext->DrawPath( path ); | |
fcaea2fa SC |
599 | } |
600 | ||
1b89a5cd | 601 | m_graphicContext->PopState(); |
1b89a5cd SC |
602 | } |
603 | ||
888dde65 | 604 | void wxGCDCImpl::DoDrawPoint( wxCoord x, wxCoord y ) |
1b89a5cd | 605 | { |
888dde65 | 606 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawPoint - invalid DC") ); |
1b89a5cd SC |
607 | |
608 | DoDrawLine( x , y , x + 1 , y + 1 ); | |
609 | } | |
610 | ||
4787c92d | 611 | void wxGCDCImpl::DoDrawLines(int n, const wxPoint points[], |
1b89a5cd SC |
612 | wxCoord xoffset, wxCoord yoffset) |
613 | { | |
888dde65 | 614 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawLines - invalid DC") ); |
1b89a5cd | 615 | |
4280b879 | 616 | if ( !m_logicalFunctionSupported ) |
1b89a5cd | 617 | return; |
1b89a5cd SC |
618 | |
619 | wxPoint2DDouble* pointsD = new wxPoint2DDouble[n]; | |
620 | for( int i = 0; i < n; ++i) | |
621 | { | |
0ebd9515 SC |
622 | pointsD[i].m_x = points[i].x + xoffset; |
623 | pointsD[i].m_y = points[i].y + yoffset; | |
1b89a5cd SC |
624 | } |
625 | ||
626 | m_graphicContext->StrokeLines( n , pointsD); | |
627 | delete[] pointsD; | |
628 | } | |
629 | ||
630 | #if wxUSE_SPLINES | |
888dde65 | 631 | void wxGCDCImpl::DoDrawSpline(const wxPointList *points) |
1b89a5cd | 632 | { |
888dde65 | 633 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawSpline - invalid DC") ); |
1b89a5cd | 634 | |
4280b879 | 635 | if ( !m_logicalFunctionSupported ) |
1b89a5cd SC |
636 | return; |
637 | ||
a4e73390 | 638 | wxGraphicsPath path = m_graphicContext->CreatePath(); |
1b89a5cd | 639 | |
b0d7707b | 640 | wxPointList::compatibility_iterator node = points->GetFirst(); |
cb98e78b | 641 | if ( !node ) |
1b89a5cd SC |
642 | // empty list |
643 | return; | |
644 | ||
4787c92d | 645 | const wxPoint *p = node->GetData(); |
1b89a5cd SC |
646 | |
647 | wxCoord x1 = p->x; | |
648 | wxCoord y1 = p->y; | |
649 | ||
650 | node = node->GetNext(); | |
b0d7707b | 651 | p = node->GetData(); |
1b89a5cd SC |
652 | |
653 | wxCoord x2 = p->x; | |
654 | wxCoord y2 = p->y; | |
655 | wxCoord cx1 = ( x1 + x2 ) / 2; | |
656 | wxCoord cy1 = ( y1 + y2 ) / 2; | |
657 | ||
0ebd9515 SC |
658 | path.MoveToPoint( x1 , y1 ); |
659 | path.AddLineToPoint( cx1 , cy1 ); | |
01871bf6 | 660 | #if !wxUSE_STD_CONTAINERS |
1b89a5cd SC |
661 | |
662 | while ((node = node->GetNext()) != NULL) | |
663 | #else | |
664 | ||
665 | while ((node = node->GetNext())) | |
01871bf6 | 666 | #endif // !wxUSE_STD_CONTAINERS |
1b89a5cd SC |
667 | |
668 | { | |
b0d7707b | 669 | p = node->GetData(); |
1b89a5cd SC |
670 | x1 = x2; |
671 | y1 = y2; | |
672 | x2 = p->x; | |
673 | y2 = p->y; | |
674 | wxCoord cx4 = (x1 + x2) / 2; | |
675 | wxCoord cy4 = (y1 + y2) / 2; | |
676 | ||
0ebd9515 | 677 | path.AddQuadCurveToPoint(x1 , y1 ,cx4 , cy4 ); |
1b89a5cd SC |
678 | |
679 | cx1 = cx4; | |
680 | cy1 = cy4; | |
681 | } | |
682 | ||
0ebd9515 | 683 | path.AddLineToPoint( x2 , y2 ); |
1b89a5cd SC |
684 | |
685 | m_graphicContext->StrokePath( path ); | |
1b89a5cd SC |
686 | } |
687 | #endif // wxUSE_SPLINES | |
688 | ||
4787c92d | 689 | void wxGCDCImpl::DoDrawPolygon( int n, const wxPoint points[], |
89efaf2b FM |
690 | wxCoord xoffset, wxCoord yoffset, |
691 | wxPolygonFillMode fillStyle ) | |
1b89a5cd | 692 | { |
888dde65 | 693 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawPolygon - invalid DC") ); |
1b89a5cd SC |
694 | |
695 | if ( n <= 0 || (m_brush.GetStyle() == wxTRANSPARENT && m_pen.GetStyle() == wxTRANSPARENT ) ) | |
696 | return; | |
4280b879 | 697 | if ( !m_logicalFunctionSupported ) |
1b89a5cd SC |
698 | return; |
699 | ||
700 | bool closeIt = false; | |
701 | if (points[n-1] != points[0]) | |
702 | closeIt = true; | |
703 | ||
704 | wxPoint2DDouble* pointsD = new wxPoint2DDouble[n+(closeIt?1:0)]; | |
705 | for( int i = 0; i < n; ++i) | |
706 | { | |
0ebd9515 SC |
707 | pointsD[i].m_x = points[i].x + xoffset; |
708 | pointsD[i].m_y = points[i].y + yoffset; | |
1b89a5cd SC |
709 | } |
710 | if ( closeIt ) | |
711 | pointsD[n] = pointsD[0]; | |
712 | ||
713 | m_graphicContext->DrawLines( n+(closeIt?1:0) , pointsD, fillStyle); | |
714 | delete[] pointsD; | |
715 | } | |
716 | ||
888dde65 | 717 | void wxGCDCImpl::DoDrawPolyPolygon(int n, |
4787c92d PC |
718 | const int count[], |
719 | const wxPoint points[], | |
1b89a5cd SC |
720 | wxCoord xoffset, |
721 | wxCoord yoffset, | |
89efaf2b | 722 | wxPolygonFillMode fillStyle) |
1b89a5cd SC |
723 | { |
724 | wxASSERT(n > 1); | |
a4e73390 | 725 | wxGraphicsPath path = m_graphicContext->CreatePath(); |
1b89a5cd SC |
726 | |
727 | int i = 0; | |
728 | for ( int j = 0; j < n; ++j) | |
729 | { | |
730 | wxPoint start = points[i]; | |
0ebd9515 | 731 | path.MoveToPoint( start.x+ xoffset, start.y+ yoffset); |
1b89a5cd SC |
732 | ++i; |
733 | int l = count[j]; | |
734 | for ( int k = 1; k < l; ++k) | |
735 | { | |
0ebd9515 | 736 | path.AddLineToPoint( points[i].x+ xoffset, points[i].y+ yoffset); |
1b89a5cd SC |
737 | ++i; |
738 | } | |
739 | // close the polygon | |
740 | if ( start != points[i-1]) | |
0ebd9515 | 741 | path.AddLineToPoint( start.x+ xoffset, start.y+ yoffset); |
1b89a5cd SC |
742 | } |
743 | m_graphicContext->DrawPath( path , fillStyle); | |
1b89a5cd SC |
744 | } |
745 | ||
888dde65 | 746 | void wxGCDCImpl::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord w, wxCoord h) |
1b89a5cd | 747 | { |
888dde65 | 748 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawRectangle - invalid DC") ); |
1b89a5cd | 749 | |
4280b879 | 750 | if ( !m_logicalFunctionSupported ) |
1b89a5cd SC |
751 | return; |
752 | ||
1b89a5cd | 753 | // CMB: draw nothing if transformed w or h is 0 |
0ebd9515 | 754 | if (w == 0 || h == 0) |
1b89a5cd SC |
755 | return; |
756 | ||
5ebfdf41 SC |
757 | if ( m_graphicContext->ShouldOffset() ) |
758 | { | |
759 | // if we are offsetting the entire rectangle is moved 0.5, so the | |
760 | // border line gets off by 1 | |
0ebd9515 SC |
761 | w -= 1; |
762 | h -= 1; | |
5ebfdf41 | 763 | } |
0ebd9515 | 764 | m_graphicContext->DrawRectangle(x,y,w,h); |
1b89a5cd SC |
765 | } |
766 | ||
888dde65 | 767 | void wxGCDCImpl::DoDrawRoundedRectangle(wxCoord x, wxCoord y, |
0ebd9515 | 768 | wxCoord w, wxCoord h, |
1b89a5cd SC |
769 | double radius) |
770 | { | |
888dde65 | 771 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawRoundedRectangle - invalid DC") ); |
1b89a5cd | 772 | |
4280b879 | 773 | if ( !m_logicalFunctionSupported ) |
1b89a5cd SC |
774 | return; |
775 | ||
776 | if (radius < 0.0) | |
0ebd9515 | 777 | radius = - radius * ((w < h) ? w : h); |
1b89a5cd SC |
778 | |
779 | // CMB: draw nothing if transformed w or h is 0 | |
0ebd9515 | 780 | if (w == 0 || h == 0) |
1b89a5cd SC |
781 | return; |
782 | ||
d9485f89 RD |
783 | if ( m_graphicContext->ShouldOffset() ) |
784 | { | |
785 | // if we are offsetting the entire rectangle is moved 0.5, so the | |
786 | // border line gets off by 1 | |
787 | w -= 1; | |
788 | h -= 1; | |
789 | } | |
0ebd9515 | 790 | m_graphicContext->DrawRoundedRectangle( x,y,w,h,radius); |
1b89a5cd SC |
791 | } |
792 | ||
888dde65 | 793 | void wxGCDCImpl::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord w, wxCoord h) |
1b89a5cd | 794 | { |
888dde65 | 795 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawEllipse - invalid DC") ); |
1b89a5cd | 796 | |
4280b879 | 797 | if ( !m_logicalFunctionSupported ) |
1b89a5cd SC |
798 | return; |
799 | ||
d9485f89 RD |
800 | if ( m_graphicContext->ShouldOffset() ) |
801 | { | |
802 | // if we are offsetting the entire rectangle is moved 0.5, so the | |
803 | // border line gets off by 1 | |
804 | w -= 1; | |
805 | h -= 1; | |
806 | } | |
0ebd9515 | 807 | m_graphicContext->DrawEllipse(x,y,w,h); |
1b89a5cd SC |
808 | } |
809 | ||
888dde65 | 810 | bool wxGCDCImpl::CanDrawBitmap() const |
1b89a5cd SC |
811 | { |
812 | return true; | |
813 | } | |
814 | ||
888dde65 | 815 | bool wxGCDCImpl::DoBlit( |
1b89a5cd | 816 | wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, |
03647350 | 817 | wxDC *source, wxCoord xsrc, wxCoord ysrc, |
89efaf2b | 818 | wxRasterOperationMode logical_func , bool useMask, |
1b89a5cd SC |
819 | wxCoord xsrcMask, wxCoord ysrcMask ) |
820 | { | |
e3b81044 VZ |
821 | return DoStretchBlit( xdest, ydest, width, height, |
822 | source, xsrc, ysrc, width, height, logical_func, useMask, | |
823 | xsrcMask,ysrcMask ); | |
824 | } | |
825 | ||
888dde65 | 826 | bool wxGCDCImpl::DoStretchBlit( |
e3b81044 VZ |
827 | wxCoord xdest, wxCoord ydest, wxCoord dstWidth, wxCoord dstHeight, |
828 | wxDC *source, wxCoord xsrc, wxCoord ysrc, wxCoord srcWidth, wxCoord srcHeight, | |
89efaf2b | 829 | wxRasterOperationMode logical_func , bool useMask, |
e3b81044 VZ |
830 | wxCoord xsrcMask, wxCoord ysrcMask ) |
831 | { | |
888dde65 RR |
832 | wxCHECK_MSG( IsOk(), false, wxT("wxGCDC(cg)::DoStretchBlit - invalid DC") ); |
833 | wxCHECK_MSG( source->IsOk(), false, wxT("wxGCDC(cg)::DoStretchBlit - invalid source DC") ); | |
6c0aace2 | 834 | |
1b89a5cd SC |
835 | if ( logical_func == wxNO_OP ) |
836 | return true; | |
03647350 | 837 | |
fec4e458 VZ |
838 | wxCompositionMode mode = TranslateRasterOp(logical_func); |
839 | if ( mode == wxCOMPOSITION_INVALID ) | |
c64c9cd3 | 840 | { |
bf02a7f9 | 841 | wxFAIL_MSG( wxT("Blitting is not supported with this logical operation.") ); |
c64c9cd3 KO |
842 | return false; |
843 | } | |
1b89a5cd | 844 | |
d0f93bc7 PC |
845 | wxRect subrect(source->LogicalToDeviceX(xsrc), |
846 | source->LogicalToDeviceY(ysrc), | |
847 | source->LogicalToDeviceXRel(srcWidth), | |
848 | source->LogicalToDeviceYRel(srcHeight)); | |
be88fea9 | 849 | const wxRect subrectOrig = subrect; |
d0f93bc7 PC |
850 | // clip the subrect down to the size of the source DC |
851 | wxRect clip; | |
852 | source->GetSize(&clip.width, &clip.height); | |
853 | subrect.Intersect(clip); | |
854 | if (subrect.width == 0) | |
855 | return true; | |
856 | ||
bf02a7f9 | 857 | bool retval = true; |
03647350 | 858 | |
bf02a7f9 SC |
859 | wxCompositionMode formerMode = m_graphicContext->GetCompositionMode(); |
860 | if (m_graphicContext->SetCompositionMode(mode)) | |
1b89a5cd | 861 | { |
bf02a7f9 SC |
862 | wxAntialiasMode formerAa = m_graphicContext->GetAntialiasMode(); |
863 | if (mode == wxCOMPOSITION_XOR) | |
864 | { | |
865 | m_graphicContext->SetAntialiasMode(wxANTIALIAS_NONE); | |
866 | } | |
03647350 | 867 | |
bf02a7f9 SC |
868 | if (xsrcMask == -1 && ysrcMask == -1) |
869 | { | |
870 | xsrcMask = xsrc; | |
871 | ysrcMask = ysrc; | |
872 | } | |
1b89a5cd | 873 | |
bf02a7f9 | 874 | wxBitmap blit = source->GetAsBitmap( &subrect ); |
6c0aace2 | 875 | |
bf02a7f9 SC |
876 | if ( blit.IsOk() ) |
877 | { | |
878 | if ( !useMask && blit.GetMask() ) | |
879 | blit.SetMask(NULL); | |
08de4403 | 880 | |
be88fea9 PC |
881 | double x = xdest; |
882 | double y = ydest; | |
883 | double w = dstWidth; | |
884 | double h = dstHeight; | |
885 | // adjust dest rect if source rect is clipped | |
886 | if (subrect.width != subrectOrig.width || subrect.height != subrectOrig.height) | |
887 | { | |
888 | x += (subrect.x - subrectOrig.x) / double(subrectOrig.width) * dstWidth; | |
889 | y += (subrect.y - subrectOrig.y) / double(subrectOrig.height) * dstHeight; | |
890 | w *= double(subrect.width) / subrectOrig.width; | |
891 | h *= double(subrect.height) / subrectOrig.height; | |
892 | } | |
893 | m_graphicContext->DrawBitmap(blit, x, y, w, h); | |
bf02a7f9 SC |
894 | } |
895 | else | |
896 | { | |
897 | wxFAIL_MSG( wxT("Cannot Blit. Unable to get contents of DC as bitmap.") ); | |
898 | retval = false; | |
899 | } | |
03647350 | 900 | |
bf02a7f9 SC |
901 | if (mode == wxCOMPOSITION_XOR) |
902 | { | |
903 | m_graphicContext->SetAntialiasMode(formerAa); | |
904 | } | |
1b89a5cd | 905 | } |
bf02a7f9 SC |
906 | // reset composition |
907 | m_graphicContext->SetCompositionMode(formerMode); | |
1b89a5cd | 908 | |
bf02a7f9 | 909 | return retval; |
1b89a5cd SC |
910 | } |
911 | ||
888dde65 | 912 | void wxGCDCImpl::DoDrawRotatedText(const wxString& str, wxCoord x, wxCoord y, |
1b89a5cd SC |
913 | double angle) |
914 | { | |
888dde65 | 915 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawRotatedText - invalid DC") ); |
1b89a5cd | 916 | |
6636ef8d | 917 | if ( str.empty() ) |
1b89a5cd | 918 | return; |
4280b879 | 919 | if ( !m_logicalFunctionSupported ) |
1b89a5cd SC |
920 | return; |
921 | ||
068eb463 SC |
922 | if ( m_backgroundMode == wxTRANSPARENT ) |
923 | m_graphicContext->DrawText( str, x ,y , DegToRad(angle )); | |
924 | else | |
925 | m_graphicContext->DrawText( str, x ,y , DegToRad(angle ), m_graphicContext->CreateBrush( wxBrush(m_textBackgroundColour,wxSOLID) ) ); | |
1b89a5cd SC |
926 | } |
927 | ||
888dde65 | 928 | void wxGCDCImpl::DoDrawText(const wxString& str, wxCoord x, wxCoord y) |
1b89a5cd | 929 | { |
a6afde63 SC |
930 | // For compatibility with other ports (notably wxGTK) and because it's |
931 | // genuinely useful, we allow passing multiline strings to DrawText(). | |
932 | // However there is no native OSX function to draw them directly so we | |
933 | // instead reuse the generic DrawLabel() method to render them. Of course, | |
934 | // DrawLabel() itself will call back to us but with single line strings | |
935 | // only so there won't be any infinite recursion here. | |
936 | if ( str.find('\n') != wxString::npos ) | |
937 | { | |
938 | GetOwner()->DrawLabel(str, wxRect(x, y, 0, 0)); | |
939 | return; | |
940 | } | |
941 | ||
08de4403 | 942 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawText - invalid DC") ); |
1b89a5cd | 943 | |
6636ef8d | 944 | if ( str.empty() ) |
1b89a5cd | 945 | return; |
4280b879 SC |
946 | |
947 | if ( !m_logicalFunctionSupported ) | |
1b89a5cd SC |
948 | return; |
949 | ||
068eb463 SC |
950 | if ( m_backgroundMode == wxTRANSPARENT ) |
951 | m_graphicContext->DrawText( str, x ,y); | |
952 | else | |
953 | m_graphicContext->DrawText( str, x ,y , m_graphicContext->CreateBrush( wxBrush(m_textBackgroundColour,wxSOLID) ) ); | |
1b89a5cd SC |
954 | } |
955 | ||
888dde65 | 956 | bool wxGCDCImpl::CanGetTextExtent() const |
1b89a5cd | 957 | { |
888dde65 | 958 | wxCHECK_MSG( IsOk(), false, wxT("wxGCDC(cg)::CanGetTextExtent - invalid DC") ); |
1b89a5cd SC |
959 | |
960 | return true; | |
961 | } | |
962 | ||
888dde65 | 963 | void wxGCDCImpl::DoGetTextExtent( const wxString &str, wxCoord *width, wxCoord *height, |
1b89a5cd | 964 | wxCoord *descent, wxCoord *externalLeading , |
c94f845b | 965 | const wxFont *theFont ) const |
1b89a5cd | 966 | { |
d9edff06 | 967 | wxCHECK_RET( m_graphicContext, wxT("wxGCDC(cg)::DoGetTextExtent - invalid DC") ); |
1b89a5cd SC |
968 | |
969 | if ( theFont ) | |
970 | { | |
971 | m_graphicContext->SetFont( *theFont, m_textForegroundColour ); | |
972 | } | |
973 | ||
974 | wxDouble h , d , e , w; | |
975 | ||
976 | m_graphicContext->GetTextExtent( str, &w, &h, &d, &e ); | |
977 | ||
978 | if ( height ) | |
fcaea2fa | 979 | *height = (wxCoord)(h+0.5); |
1b89a5cd | 980 | if ( descent ) |
fcaea2fa | 981 | *descent = (wxCoord)(d+0.5); |
1b89a5cd | 982 | if ( externalLeading ) |
fcaea2fa | 983 | *externalLeading = (wxCoord)(e+0.5); |
1b89a5cd | 984 | if ( width ) |
fcaea2fa | 985 | *width = (wxCoord)(w+0.5); |
1b89a5cd SC |
986 | |
987 | if ( theFont ) | |
988 | { | |
989 | m_graphicContext->SetFont( m_font, m_textForegroundColour ); | |
990 | } | |
991 | } | |
992 | ||
888dde65 | 993 | bool wxGCDCImpl::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const |
1b89a5cd | 994 | { |
d9edff06 | 995 | wxCHECK_MSG( m_graphicContext, false, wxT("wxGCDC(cg)::DoGetPartialTextExtents - invalid DC") ); |
1b89a5cd SC |
996 | widths.Clear(); |
997 | widths.Add(0,text.Length()); | |
998 | if ( text.IsEmpty() ) | |
999 | return true; | |
1000 | ||
1001 | wxArrayDouble widthsD; | |
1002 | ||
1003 | m_graphicContext->GetPartialTextExtents( text, widthsD ); | |
1004 | for ( size_t i = 0; i < widths.GetCount(); ++i ) | |
0ebd9515 | 1005 | widths[i] = (wxCoord)(widthsD[i] + 0.5); |
1b89a5cd SC |
1006 | |
1007 | return true; | |
1008 | } | |
1009 | ||
888dde65 | 1010 | wxCoord wxGCDCImpl::GetCharWidth(void) const |
1b89a5cd SC |
1011 | { |
1012 | wxCoord width; | |
1013 | DoGetTextExtent( wxT("g") , &width , NULL , NULL , NULL , NULL ); | |
1014 | ||
1015 | return width; | |
1016 | } | |
1017 | ||
888dde65 | 1018 | wxCoord wxGCDCImpl::GetCharHeight(void) const |
1b89a5cd SC |
1019 | { |
1020 | wxCoord height; | |
1021 | DoGetTextExtent( wxT("g") , NULL , &height , NULL , NULL , NULL ); | |
1022 | ||
1023 | return height; | |
1024 | } | |
1025 | ||
888dde65 | 1026 | void wxGCDCImpl::Clear(void) |
1b89a5cd | 1027 | { |
888dde65 | 1028 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::Clear - invalid DC") ); |
1b89a5cd SC |
1029 | // TODO better implementation / incorporate size info into wxGCDC or context |
1030 | m_graphicContext->SetBrush( m_backgroundBrush ); | |
1031 | wxPen p = *wxTRANSPARENT_PEN; | |
1032 | m_graphicContext->SetPen( p ); | |
954c66fa SC |
1033 | wxCompositionMode formerMode = m_graphicContext->GetCompositionMode(); |
1034 | m_graphicContext->SetCompositionMode(wxCOMPOSITION_SOURCE); | |
0c4438d2 PC |
1035 | // maximum positive coordinate Cairo can handle is 2^23 - 1 |
1036 | DoDrawRectangle( | |
1037 | DeviceToLogicalX(0), DeviceToLogicalY(0), | |
1038 | DeviceToLogicalXRel(0x007fffff), DeviceToLogicalYRel(0x007fffff)); | |
954c66fa | 1039 | m_graphicContext->SetCompositionMode(formerMode); |
6c0aace2 | 1040 | m_graphicContext->SetPen( m_pen ); |
1b89a5cd SC |
1041 | m_graphicContext->SetBrush( m_brush ); |
1042 | } | |
1043 | ||
888dde65 | 1044 | void wxGCDCImpl::DoGetSize(int *width, int *height) const |
1b89a5cd | 1045 | { |
1cc7d13a SC |
1046 | wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoGetSize - invalid DC") ); |
1047 | wxDouble w,h; | |
1048 | m_graphicContext->GetSize( &w, &h ); | |
1049 | if ( height ) | |
1050 | *height = (int) (h+0.5); | |
1051 | if ( width ) | |
1052 | *width = (int) (w+0.5); | |
1b89a5cd SC |
1053 | } |
1054 | ||
888dde65 | 1055 | void wxGCDCImpl::DoGradientFillLinear(const wxRect& rect, |
1b89a5cd SC |
1056 | const wxColour& initialColour, |
1057 | const wxColour& destColour, | |
1058 | wxDirection nDirection ) | |
1059 | { | |
1060 | wxPoint start; | |
1061 | wxPoint end; | |
1062 | switch( nDirection) | |
1063 | { | |
1064 | case wxWEST : | |
1065 | start = rect.GetRightBottom(); | |
1066 | start.x++; | |
1067 | end = rect.GetLeftBottom(); | |
1068 | break; | |
1069 | case wxEAST : | |
1070 | start = rect.GetLeftBottom(); | |
1071 | end = rect.GetRightBottom(); | |
1072 | end.x++; | |
1073 | break; | |
1074 | case wxNORTH : | |
1075 | start = rect.GetLeftBottom(); | |
1076 | start.y++; | |
1077 | end = rect.GetLeftTop(); | |
1078 | break; | |
1079 | case wxSOUTH : | |
1080 | start = rect.GetLeftTop(); | |
1081 | end = rect.GetLeftBottom(); | |
1082 | end.y++; | |
1083 | break; | |
1084 | default : | |
1085 | break; | |
1086 | } | |
1087 | ||
0ebd9515 | 1088 | if (rect.width == 0 || rect.height == 0) |
1b89a5cd SC |
1089 | return; |
1090 | ||
0ebd9515 SC |
1091 | m_graphicContext->SetBrush( m_graphicContext->CreateLinearGradientBrush( |
1092 | start.x,start.y,end.x,end.y, initialColour, destColour)); | |
1b89a5cd | 1093 | m_graphicContext->SetPen(*wxTRANSPARENT_PEN); |
0ebd9515 | 1094 | m_graphicContext->DrawRectangle(rect.x,rect.y,rect.width,rect.height); |
1b89a5cd | 1095 | m_graphicContext->SetPen(m_pen); |
be6b31f3 | 1096 | m_graphicContext->SetBrush(m_brush); |
1b89a5cd SC |
1097 | } |
1098 | ||
888dde65 | 1099 | void wxGCDCImpl::DoGradientFillConcentric(const wxRect& rect, |
1b89a5cd SC |
1100 | const wxColour& initialColour, |
1101 | const wxColour& destColour, | |
1102 | const wxPoint& circleCenter) | |
1103 | { | |
1104 | //Radius | |
1105 | wxInt32 cx = rect.GetWidth() / 2; | |
1106 | wxInt32 cy = rect.GetHeight() / 2; | |
1107 | wxInt32 nRadius; | |
1108 | if (cx < cy) | |
1109 | nRadius = cx; | |
1110 | else | |
1111 | nRadius = cy; | |
1112 | ||
0ebd9515 | 1113 | // make sure the background is filled (todo move into specific platform implementation ?) |
1b89a5cd SC |
1114 | m_graphicContext->SetPen(*wxTRANSPARENT_PEN); |
1115 | m_graphicContext->SetBrush( wxBrush( destColour) ); | |
0ebd9515 | 1116 | m_graphicContext->DrawRectangle(rect.x,rect.y,rect.width,rect.height); |
1b89a5cd SC |
1117 | |
1118 | m_graphicContext->SetBrush( m_graphicContext->CreateRadialGradientBrush( | |
0ebd9515 SC |
1119 | rect.x+circleCenter.x,rect.y+circleCenter.y, |
1120 | rect.x+circleCenter.x,rect.y+circleCenter.y, | |
1121 | nRadius,initialColour,destColour)); | |
1b89a5cd | 1122 | |
0ebd9515 | 1123 | m_graphicContext->DrawRectangle(rect.x,rect.y,rect.width,rect.height); |
1b89a5cd | 1124 | m_graphicContext->SetPen(m_pen); |
be6b31f3 | 1125 | m_graphicContext->SetBrush(m_brush); |
1b89a5cd SC |
1126 | } |
1127 | ||
888dde65 | 1128 | void wxGCDCImpl::DoDrawCheckMark(wxCoord x, wxCoord y, |
1b89a5cd SC |
1129 | wxCoord width, wxCoord height) |
1130 | { | |
888dde65 | 1131 | wxDCImpl::DoDrawCheckMark(x,y,width,height); |
1b89a5cd SC |
1132 | } |
1133 | ||
53d4bdbc VZ |
1134 | #ifdef __WXMSW__ |
1135 | wxRect wxGCDCImpl::MSWApplyGDIPlusTransform(const wxRect& r) const | |
1136 | { | |
1137 | wxGraphicsContext* const gc = GetGraphicsContext(); | |
1138 | wxCHECK_MSG( gc, r, wxT("Invalid wxGCDC") ); | |
1139 | ||
1140 | double x = 0, | |
1141 | y = 0; | |
1142 | gc->GetTransform().TransformPoint(&x, &y); | |
1143 | ||
1144 | wxRect rect(r); | |
1145 | rect.Offset(x, y); | |
1146 | ||
1147 | return rect; | |
1148 | } | |
1149 | #endif // __WXMSW__ | |
1150 | ||
1b89a5cd | 1151 | #endif // wxUSE_GRAPHICS_CONTEXT |