]> git.saurik.com Git - wxWidgets.git/blob - src/common/dcbase.cpp
Moved the wxPageSetupDialogData <-> native conversion
[wxWidgets.git] / src / common / dcbase.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: common/dcbase.cpp
3 // Purpose: generic methods of the wxDC Class
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 05/25/99
7 // RCS-ID: $Id$
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
17 #pragma implementation "dcbase.h"
18 #endif
19
20 // ----------------------------------------------------------------------------
21 // headers
22 // ----------------------------------------------------------------------------
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #include "wx/dc.h"
32
33 #include <math.h>
34
35 // bool wxDCBase::sm_cacheing = false;
36
37 // ============================================================================
38 // implementation
39 // ============================================================================
40
41 // ----------------------------------------------------------------------------
42 // special symbols
43 // ----------------------------------------------------------------------------
44
45 void wxDCBase::DoDrawCheckMark(wxCoord x1, wxCoord y1,
46 wxCoord width, wxCoord height)
47 {
48 wxCHECK_RET( Ok(), wxT("invalid window dc") );
49
50 wxCoord x2 = x1 + width,
51 y2 = y1 + height;
52
53 // this is to yield width of 3 for width == height == 10
54 SetPen(wxPen(GetTextForeground(), (width + height + 1) / 7, wxSOLID));
55
56 // we're drawing a scaled version of wx/generic/tick.xpm here
57 wxCoord x3 = x1 + (4*width) / 10, // x of the tick bottom
58 y3 = y1 + height / 2; // y of the left tick branch
59 DoDrawLine(x1, y3, x3, y2);
60 DoDrawLine(x3, y2, x2, y1);
61
62 CalcBoundingBox(x1, y1);
63 CalcBoundingBox(x2, y2);
64 }
65
66 // ----------------------------------------------------------------------------
67 // line/polygons
68 // ----------------------------------------------------------------------------
69
70 void wxDCBase::DrawLines(const wxList *list, wxCoord xoffset, wxCoord yoffset)
71 {
72 int n = list->GetCount();
73 wxPoint *points = new wxPoint[n];
74
75 int i = 0;
76 for ( wxList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
77 {
78 wxPoint *point = (wxPoint *)node->GetData();
79 points[i].x = point->x;
80 points[i].y = point->y;
81 }
82
83 DoDrawLines(n, points, xoffset, yoffset);
84
85 delete [] points;
86 }
87
88
89 void wxDCBase::DrawPolygon(const wxList *list,
90 wxCoord xoffset, wxCoord yoffset,
91 int fillStyle)
92 {
93 int n = list->GetCount();
94 wxPoint *points = new wxPoint[n];
95
96 int i = 0;
97 for ( wxList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
98 {
99 wxPoint *point = (wxPoint *)node->GetData();
100 points[i].x = point->x;
101 points[i].y = point->y;
102 }
103
104 DoDrawPolygon(n, points, xoffset, yoffset, fillStyle);
105
106 delete [] points;
107 }
108
109 void
110 wxDCBase::DoDrawPolyPolygon(int n,
111 int count[],
112 wxPoint points[],
113 wxCoord xoffset, wxCoord yoffset,
114 int fillStyle)
115 {
116 if ( n == 1 )
117 {
118 DoDrawPolygon(count[0], points, xoffset, yoffset, fillStyle);
119 return;
120 }
121
122 int i, j, lastOfs;
123 wxPoint* pts;
124 wxPen pen;
125
126 for (i = j = lastOfs = 0; i < n; i++)
127 {
128 lastOfs = j;
129 j += count[i];
130 }
131 pts = new wxPoint[j+n-1];
132 for (i = 0; i < j; i++)
133 pts[i] = points[i];
134 for (i = 2; i <= n; i++)
135 {
136 lastOfs -= count[n-i];
137 pts[j++] = pts[lastOfs];
138 }
139
140 pen = GetPen();
141 SetPen(wxPen(*wxBLACK, 0, wxTRANSPARENT));
142 DoDrawPolygon(j, pts, xoffset, yoffset, fillStyle);
143 SetPen(pen);
144 for (i = j = 0; i < n; i++)
145 {
146 DoDrawLines(count[i], pts+j, xoffset, yoffset);
147 j += count[i];
148 }
149 delete[] pts;
150 }
151
152 // ----------------------------------------------------------------------------
153 // splines
154 // ----------------------------------------------------------------------------
155
156 #if wxUSE_SPLINES
157
158 // TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)
159 void wxDCBase::DrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3)
160 {
161 wxList point_list;
162
163 wxPoint *point1 = new wxPoint;
164 point1->x = x1; point1->y = y1;
165 point_list.Append((wxObject*)point1);
166
167 wxPoint *point2 = new wxPoint;
168 point2->x = x2; point2->y = y2;
169 point_list.Append((wxObject*)point2);
170
171 wxPoint *point3 = new wxPoint;
172 point3->x = x3; point3->y = y3;
173 point_list.Append((wxObject*)point3);
174
175 DrawSpline(&point_list);
176
177 for( wxList::compatibility_iterator node = point_list.GetFirst(); node; node = node->GetNext() )
178 {
179 wxPoint *p = (wxPoint *)node->GetData();
180 delete p;
181 }
182 }
183
184 void wxDCBase::DrawSpline(int n, wxPoint points[])
185 {
186 wxList list;
187 for (int i =0; i < n; i++)
188 {
189 list.Append((wxObject*)&points[i]);
190 }
191
192 DrawSpline(&list);
193 }
194
195 // ----------------------------------- spline code ----------------------------------------
196
197 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
198 double a3, double b3, double a4, double b4);
199 void wx_clear_stack();
200 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
201 double *y3, double *x4, double *y4);
202 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
203 double x4, double y4);
204 static bool wx_spline_add_point(double x, double y);
205 static void wx_spline_draw_point_array(wxDCBase *dc);
206
207 wxList wx_spline_point_list;
208
209 #define half(z1, z2) ((z1+z2)/2.0)
210 #define THRESHOLD 5
211
212 /* iterative version */
213
214 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
215 double b4)
216 {
217 register double xmid, ymid;
218 double x1, y1, x2, y2, x3, y3, x4, y4;
219
220 wx_clear_stack();
221 wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
222
223 while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
224 xmid = (double)half(x2, x3);
225 ymid = (double)half(y2, y3);
226 if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
227 fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
228 wx_spline_add_point( x1, y1 );
229 wx_spline_add_point( xmid, ymid );
230 } else {
231 wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
232 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
233 wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
234 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
235 }
236 }
237 }
238
239 /* utilities used by spline drawing routines */
240
241 typedef struct wx_spline_stack_struct {
242 double x1, y1, x2, y2, x3, y3, x4, y4;
243 } Stack;
244
245 #define SPLINE_STACK_DEPTH 20
246 static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
247 static Stack *wx_stack_top;
248 static int wx_stack_count;
249
250 void wx_clear_stack()
251 {
252 wx_stack_top = wx_spline_stack;
253 wx_stack_count = 0;
254 }
255
256 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
257 {
258 wx_stack_top->x1 = x1;
259 wx_stack_top->y1 = y1;
260 wx_stack_top->x2 = x2;
261 wx_stack_top->y2 = y2;
262 wx_stack_top->x3 = x3;
263 wx_stack_top->y3 = y3;
264 wx_stack_top->x4 = x4;
265 wx_stack_top->y4 = y4;
266 wx_stack_top++;
267 wx_stack_count++;
268 }
269
270 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
271 double *x3, double *y3, double *x4, double *y4)
272 {
273 if (wx_stack_count == 0)
274 return (0);
275 wx_stack_top--;
276 wx_stack_count--;
277 *x1 = wx_stack_top->x1;
278 *y1 = wx_stack_top->y1;
279 *x2 = wx_stack_top->x2;
280 *y2 = wx_stack_top->y2;
281 *x3 = wx_stack_top->x3;
282 *y3 = wx_stack_top->y3;
283 *x4 = wx_stack_top->x4;
284 *y4 = wx_stack_top->y4;
285 return (1);
286 }
287
288 static bool wx_spline_add_point(double x, double y)
289 {
290 wxPoint *point = new wxPoint ;
291 point->x = (int) x;
292 point->y = (int) y;
293 wx_spline_point_list.Append((wxObject*)point);
294 return true;
295 }
296
297 static void wx_spline_draw_point_array(wxDCBase *dc)
298 {
299 dc->DrawLines(&wx_spline_point_list, 0, 0 );
300 wxList::compatibility_iterator node = wx_spline_point_list.GetFirst();
301 while (node)
302 {
303 wxPoint *point = (wxPoint *)node->GetData();
304 delete point;
305 wx_spline_point_list.Erase(node);
306 node = wx_spline_point_list.GetFirst();
307 }
308 }
309
310 void wxDCBase::DoDrawSpline( wxList *points )
311 {
312 wxCHECK_RET( Ok(), wxT("invalid window dc") );
313
314 wxPoint *p;
315 double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
316 double x1, y1, x2, y2;
317
318 wxList::compatibility_iterator node = points->GetFirst();
319 if (node == NULL)
320 // empty list
321 return;
322
323 p = (wxPoint *)node->GetData();
324
325 x1 = p->x;
326 y1 = p->y;
327
328 node = node->GetNext();
329 p = (wxPoint *)node->GetData();
330
331 x2 = p->x;
332 y2 = p->y;
333 cx1 = (double)((x1 + x2) / 2);
334 cy1 = (double)((y1 + y2) / 2);
335 cx2 = (double)((cx1 + x2) / 2);
336 cy2 = (double)((cy1 + y2) / 2);
337
338 wx_spline_add_point(x1, y1);
339
340 while ((node = node->GetNext())
341 #if !wxUSE_STL
342 != NULL
343 #endif // !wxUSE_STL
344 )
345 {
346 p = (wxPoint *)node->GetData();
347 x1 = x2;
348 y1 = y2;
349 x2 = p->x;
350 y2 = p->y;
351 cx4 = (double)(x1 + x2) / 2;
352 cy4 = (double)(y1 + y2) / 2;
353 cx3 = (double)(x1 + cx4) / 2;
354 cy3 = (double)(y1 + cy4) / 2;
355
356 wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
357
358 cx1 = cx4;
359 cy1 = cy4;
360 cx2 = (double)(cx1 + x2) / 2;
361 cy2 = (double)(cy1 + y2) / 2;
362 }
363
364 wx_spline_add_point( cx1, cy1 );
365 wx_spline_add_point( x2, y2 );
366
367 wx_spline_draw_point_array( this );
368 }
369
370 #endif // wxUSE_SPLINES
371
372 // ----------------------------------------------------------------------------
373 // Partial Text Extents
374 // ----------------------------------------------------------------------------
375
376
377 // Each element of the widths array will be the width of the string up to and
378 // including the coresponding character in text. This is the generic
379 // implementation, the port-specific classes should do this with native APIs
380 // if available and if faster. Note: pango_layout_index_to_pos is much slower
381 // than calling GetTextExtent!!
382
383 #define FWC_SIZE 256
384
385 class FontWidthCache
386 {
387 public:
388 FontWidthCache() : m_scaleX(1), m_widths(NULL) { }
389 ~FontWidthCache() { delete []m_widths; }
390
391 void Reset()
392 {
393 if (!m_widths)
394 m_widths = new int[FWC_SIZE];
395
396 memset(m_widths, 0, sizeof(int)*FWC_SIZE);
397 }
398
399 wxFont m_font;
400 double m_scaleX;
401 int *m_widths;
402 };
403
404 static FontWidthCache s_fontWidthCache;
405
406 bool wxDCBase::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
407 {
408 int totalWidth = 0;
409
410 size_t i, len = text.Length();
411 widths.Empty();
412 widths.Add(0, len);
413 int w, h;
414
415 // reset the cache if font or horizontal scale have changed
416 if (!s_fontWidthCache.m_widths ||
417 (s_fontWidthCache.m_scaleX != m_scaleX) ||
418 (s_fontWidthCache.m_font != GetFont()))
419 {
420 s_fontWidthCache.Reset();
421 s_fontWidthCache.m_font = GetFont();
422 s_fontWidthCache.m_scaleX = m_scaleX;
423 }
424
425 // Calculate the position of each character based on the widths of
426 // the previous characters
427 for (i=0; i<len; i++)
428 {
429 const wxChar c = text[i];
430 unsigned int c_int = (unsigned int)c;
431
432 if ((c_int < FWC_SIZE) && (s_fontWidthCache.m_widths[c_int] != 0))
433 {
434 w = s_fontWidthCache.m_widths[c_int];
435 }
436 else
437 {
438 GetTextExtent(c, &w, &h);
439 if (c_int < FWC_SIZE)
440 s_fontWidthCache.m_widths[c_int] = w;
441 }
442
443 totalWidth += w;
444 widths[i] = totalWidth;
445 }
446
447 return true;
448 }
449
450
451 // ----------------------------------------------------------------------------
452 // enhanced text drawing
453 // ----------------------------------------------------------------------------
454
455 void wxDCBase::GetMultiLineTextExtent(const wxString& text,
456 wxCoord *x,
457 wxCoord *y,
458 wxCoord *h,
459 wxFont *font)
460 {
461 wxCoord widthTextMax = 0, widthLine,
462 heightTextTotal = 0, heightLineDefault = 0, heightLine = 0;
463
464 wxString curLine;
465 for ( const wxChar *pc = text; ; pc++ )
466 {
467 if ( *pc == _T('\n') || *pc == _T('\0') )
468 {
469 if ( curLine.empty() )
470 {
471 // we can't use GetTextExtent - it will return 0 for both width
472 // and height and an empty line should count in height
473 // calculation
474
475 // assume that this line has the same height as the previous
476 // one
477 if ( !heightLineDefault )
478 heightLineDefault = heightLine;
479
480 if ( !heightLineDefault )
481 {
482 // but we don't know it yet - choose something reasonable
483 GetTextExtent(_T("W"), NULL, &heightLineDefault,
484 NULL, NULL, font);
485 }
486
487 heightTextTotal += heightLineDefault;
488 }
489 else
490 {
491 GetTextExtent(curLine, &widthLine, &heightLine,
492 NULL, NULL, font);
493 if ( widthLine > widthTextMax )
494 widthTextMax = widthLine;
495 heightTextTotal += heightLine;
496 }
497
498 if ( *pc == _T('\n') )
499 {
500 curLine.clear();
501 }
502 else
503 {
504 // the end of string
505 break;
506 }
507 }
508 else
509 {
510 curLine += *pc;
511 }
512 }
513
514 if ( x )
515 *x = widthTextMax;
516 if ( y )
517 *y = heightTextTotal;
518 if ( h )
519 *h = heightLine;
520 }
521
522 void wxDCBase::DrawLabel(const wxString& text,
523 const wxBitmap& bitmap,
524 const wxRect& rect,
525 int alignment,
526 int indexAccel,
527 wxRect *rectBounding)
528 {
529 // find the text position
530 wxCoord widthText, heightText, heightLine;
531 GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
532
533 wxCoord width, height;
534 if ( bitmap.Ok() )
535 {
536 width = widthText + bitmap.GetWidth();
537 height = bitmap.GetHeight();
538 }
539 else // no bitmap
540 {
541 width = widthText;
542 height = heightText;
543 }
544
545 wxCoord x, y;
546 if ( alignment & wxALIGN_RIGHT )
547 {
548 x = rect.GetRight() - width;
549 }
550 else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
551 {
552 x = (rect.GetLeft() + rect.GetRight() + 1 - width) / 2;
553 }
554 else // alignment & wxALIGN_LEFT
555 {
556 x = rect.GetLeft();
557 }
558
559 if ( alignment & wxALIGN_BOTTOM )
560 {
561 y = rect.GetBottom() - height;
562 }
563 else if ( alignment & wxALIGN_CENTRE_VERTICAL )
564 {
565 y = (rect.GetTop() + rect.GetBottom() + 1 - height) / 2;
566 }
567 else // alignment & wxALIGN_TOP
568 {
569 y = rect.GetTop();
570 }
571
572 // draw the bitmap first
573 wxCoord x0 = x,
574 y0 = y,
575 width0 = width;
576 if ( bitmap.Ok() )
577 {
578 DrawBitmap(bitmap, x, y, true /* use mask */);
579
580 wxCoord offset = bitmap.GetWidth() + 4;
581 x += offset;
582 width -= offset;
583
584 y += (height - heightText) / 2;
585 }
586
587 // we will draw the underscore under the accel char later
588 wxCoord startUnderscore = 0,
589 endUnderscore = 0,
590 yUnderscore = 0;
591
592 // split the string into lines and draw each of them separately
593 wxString curLine;
594 for ( const wxChar *pc = text; ; pc++ )
595 {
596 if ( *pc == _T('\n') || *pc == _T('\0') )
597 {
598 int xRealStart = x; // init it here to avoid compielr warnings
599
600 if ( !curLine.empty() )
601 {
602 // NB: can't test for !(alignment & wxALIGN_LEFT) because
603 // wxALIGN_LEFT is 0
604 if ( alignment & (wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL) )
605 {
606 wxCoord widthLine;
607 GetTextExtent(curLine, &widthLine, NULL);
608
609 if ( alignment & wxALIGN_RIGHT )
610 {
611 xRealStart += width - widthLine;
612 }
613 else // if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
614 {
615 xRealStart += (width - widthLine) / 2;
616 }
617 }
618 //else: left aligned, nothing to do
619
620 DrawText(curLine, xRealStart, y);
621 }
622
623 y += heightLine;
624
625 // do we have underscore in this line? we can check yUnderscore
626 // because it is set below to just y + heightLine if we do
627 if ( y == yUnderscore )
628 {
629 // adjust the horz positions to account for the shift
630 startUnderscore += xRealStart;
631 endUnderscore += xRealStart;
632 }
633
634 if ( *pc == _T('\0') )
635 break;
636
637 curLine.clear();
638 }
639 else // not end of line
640 {
641 if ( pc - text.c_str() == indexAccel )
642 {
643 // remeber to draw underscore here
644 GetTextExtent(curLine, &startUnderscore, NULL);
645 curLine += *pc;
646 GetTextExtent(curLine, &endUnderscore, NULL);
647
648 yUnderscore = y + heightLine;
649 }
650 else
651 {
652 curLine += *pc;
653 }
654 }
655 }
656
657 // draw the underscore if found
658 if ( startUnderscore != endUnderscore )
659 {
660 // it should be of the same colour as text
661 SetPen(wxPen(GetTextForeground(), 0, wxSOLID));
662
663 yUnderscore--;
664
665 DrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
666 }
667
668 // return bounding rect if requested
669 if ( rectBounding )
670 {
671 *rectBounding = wxRect(x, y - heightText, widthText, heightText);
672 }
673
674 CalcBoundingBox(x0, y0);
675 CalcBoundingBox(x0 + width0, y0 + height);
676 }
677
678 /*
679 Notes for wxWidgets DrawEllipticArcRot(...)
680
681 wxDCBase::DrawEllipticArcRot(...) draws a rotated elliptic arc or an ellipse.
682 It uses wxDCBase::CalculateEllipticPoints(...) and wxDCBase::Rotate(...),
683 which are also new.
684
685 All methods are generic, so they can be implemented in wxDCBase.
686 DoDrawEllipticArcRot(...) is virtual, so it can be called from deeper
687 methods like (WinCE) wxDC::DoDrawArc(...).
688
689 CalculateEllipticPoints(...) fills a given list of wxPoints with some points
690 of an elliptic arc. The algorithm is pixel-based: In every row (in flat
691 parts) or every column (in steep parts) only one pixel is calculated.
692 Trigonometric calculation (sin, cos, tan, atan) is only done if the
693 starting angle is not equal to the ending angle. The calculation of the
694 pixels is done using simple arithmetic only and should perform not too
695 bad even on devices without floating point processor. I didn't test this yet.
696
697 Rotate(...) rotates a list of point pixel-based, you will see rounding errors.
698 For instance: an ellipse rotated 180 degrees is drawn
699 slightly different from the original.
700
701 The points are then moved to an array and used to draw a polyline and/or polygon
702 (with center added, the pie).
703 The result looks quite similar to the native ellipse, only e few pixels differ.
704
705 The performance on a desktop system (Athlon 1800, WinXP) is about 7 times
706 slower as DrawEllipse(...), which calls the native API.
707 An rotated ellipse outside the clipping region takes nearly the same time,
708 while an native ellipse outside takes nearly no time to draw.
709
710 If you draw an arc with this new method, you will see the starting and ending angles
711 are calculated properly.
712 If you use DrawEllipticArc(...), you will see they are only correct for circles
713 and not properly calculated for ellipses.
714
715 Peter Lenhard
716 p.lenhard@t-online.de
717 */
718
719 #ifdef __WXWINCE__
720 void wxDCBase::DoDrawEllipticArcRot( wxCoord x, wxCoord y,
721 wxCoord w, wxCoord h,
722 double sa, double ea, double angle )
723 {
724 wxList list;
725
726 CalculateEllipticPoints( &list, x, y, w, h, sa, ea );
727 Rotate( &list, angle, wxPoint( x+w/2, y+h/2 ) );
728
729 // Add center (for polygon/pie)
730 list.Append( (wxObject*) new wxPoint( x+w/2, y+h/2 ) );
731
732 // copy list into array and delete list elements
733 int n = list.Number();
734 wxPoint *points = new wxPoint[n];
735 int i = 0;
736 wxNode* node = 0;
737 for ( node = list.First(); node; node = node->Next(), i++ )
738 {
739 wxPoint *point = (wxPoint *)node->Data();
740 points[i].x = point->x;
741 points[i].y = point->y;
742 delete point;
743 }
744
745 // first draw the pie without pen, if necessary
746 if( GetBrush() != *wxTRANSPARENT_BRUSH )
747 {
748 wxPen tempPen( GetPen() );
749 SetPen( *wxTRANSPARENT_PEN );
750 DoDrawPolygon( n, points, 0, 0 );
751 SetPen( tempPen );
752 }
753
754 // then draw the arc without brush, if necessary
755 if( GetPen() != *wxTRANSPARENT_PEN )
756 {
757 // without center
758 DoDrawLines( n-1, points, 0, 0 );
759 }
760
761 delete [] points;
762
763 } // DrawEllipticArcRot
764
765 void wxDCBase::Rotate( wxList* points, double angle, wxPoint center )
766 {
767 if( angle != 0.0 )
768 {
769 double pi(3.1415926536);
770 double dSinA = -sin(angle*2.0*pi/360.0);
771 double dCosA = cos(angle*2.0*pi/360.0);
772 for ( wxNode* node = points->First(); node; node = node->Next() )
773 {
774 wxPoint* point = (wxPoint*)node->Data();
775
776 // transform coordinates, if necessary
777 if( center.x ) point->x -= center.x;
778 if( center.y ) point->y -= center.y;
779
780 // calculate rotation, rounding simply by implicit cast to integer
781 int xTemp = point->x * dCosA - point->y * dSinA;
782 point->y = point->x * dSinA + point->y * dCosA;
783 point->x = xTemp;
784
785 // back transform coordinates, if necessary
786 if( center.x ) point->x += center.x;
787 if( center.y ) point->y += center.y;
788 }
789 }
790 }
791
792 void wxDCBase::CalculateEllipticPoints( wxList* points,
793 wxCoord xStart, wxCoord yStart,
794 wxCoord w, wxCoord h,
795 double sa, double ea )
796 {
797 double pi = 3.1415926535;
798 double sar = 0;
799 double ear = 0;
800 int xsa = 0;
801 int ysa = 0;
802 int xea = 0;
803 int yea = 0;
804 int sq = 0;
805 int eq = 0;
806 bool bUseAngles = false;
807 if( w<0 ) w = -w;
808 if( h<0 ) h = -h;
809 // half-axes
810 wxCoord a = w/2;
811 wxCoord b = h/2;
812 // decrement 1 pixel if ellipse is smaller than 2*a, 2*b
813 int decrX = 0;
814 if( 2*a == w ) decrX = 1;
815 int decrY = 0;
816 if( 2*b == h ) decrY = 1;
817 // center
818 wxCoord xCenter = xStart + a;
819 wxCoord yCenter = yStart + b;
820 // calculate data for start and end, if necessary
821 if( sa != ea )
822 {
823 bUseAngles = true;
824 // normalisation of angles
825 while( sa<0 ) sa += 360;
826 while( ea<0 ) ea += 360;
827 while( sa>=360 ) sa -= 360;
828 while( ea>=360 ) ea -= 360;
829 // calculate quadrant numbers
830 if( sa > 270 ) sq = 3;
831 else if( sa > 180 ) sq = 2;
832 else if( sa > 90 ) sq = 1;
833 if( ea > 270 ) eq = 3;
834 else if( ea > 180 ) eq = 2;
835 else if( ea > 90 ) eq = 1;
836 sar = sa * pi / 180.0;
837 ear = ea * pi / 180.0;
838 // correct angle circle -> ellipse
839 sar = atan( -a/(double)b * tan( sar ) );
840 if ( sq == 1 || sq == 2 ) sar += pi;
841 ear = atan( -a/(double)b * tan( ear ) );
842 if ( eq == 1 || eq == 2 ) ear += pi;
843 // coordinates of points
844 xsa = xCenter + a * cos( sar );
845 if( sq == 0 || sq == 3 ) xsa -= decrX;
846 ysa = yCenter + b * sin( sar );
847 if( sq == 2 || sq == 3 ) ysa -= decrY;
848 xea = xCenter + a * cos( ear );
849 if( eq == 0 || eq == 3 ) xea -= decrX;
850 yea = yCenter + b * sin( ear );
851 if( eq == 2 || eq == 3 ) yea -= decrY;
852 } // if iUseAngles
853 // calculate c1 = b^2, c2 = b^2/a^2 with a = w/2, b = h/2
854 double c1 = b * b;
855 double c2 = 2.0 / w;
856 c2 *= c2;
857 c2 *= c1;
858 wxCoord x = 0;
859 wxCoord y = b;
860 long x2 = 1;
861 long y2 = y*y;
862 long y2_old = 0;
863 long y_old = 0;
864 // Lists for quadrant 1 to 4
865 wxList pointsarray[4];
866 // Calculate points for first quadrant and set in all quadrants
867 for( x = 0; x <= a; ++x )
868 {
869 x2 = x2+x+x-1;
870 y2_old = y2;
871 y_old = y;
872 bool bNewPoint = false;
873 while( y2 > c1 - c2 * x2 && y > 0 )
874 {
875 bNewPoint = true;
876 y2 = y2-y-y+1;
877 --y;
878 }
879 // old y now to big: set point with old y, old x
880 if( bNewPoint && x>1)
881 {
882 int x1 = x - 1;
883 // remove points on the same line
884 pointsarray[0].Insert( (wxObject*) new wxPoint( xCenter + x1 - decrX, yCenter - y_old ) );
885 pointsarray[1].Append( (wxObject*) new wxPoint( xCenter - x1, yCenter - y_old ) );
886 pointsarray[2].Insert( (wxObject*) new wxPoint( xCenter - x1, yCenter + y_old - decrY ) );
887 pointsarray[3].Append( (wxObject*) new wxPoint( xCenter + x1 - decrX, yCenter + y_old - decrY ) );
888 } // set point
889 } // calculate point
890
891 // Starting and/or ending points for the quadrants, first quadrant gets both.
892 pointsarray[0].Insert( (wxObject*) new wxPoint( xCenter + a - decrX, yCenter ) );
893 pointsarray[0].Append( (wxObject*) new wxPoint( xCenter, yCenter - b ) );
894 pointsarray[1].Append( (wxObject*) new wxPoint( xCenter - a, yCenter ) );
895 pointsarray[2].Append( (wxObject*) new wxPoint( xCenter, yCenter + b - decrY ) );
896 pointsarray[3].Append( (wxObject*) new wxPoint( xCenter + a - decrX, yCenter ) );
897
898 // copy quadrants in original list
899 if( bUseAngles )
900 {
901 // Copy the right part of the points in the lists
902 // and delete the wxPoints, because they do not leave this method.
903 points->Append( (wxObject*) new wxPoint( xsa, ysa ) );
904 int q = sq;
905 bool bStarted = false;
906 bool bReady = false;
907 bool bForceTurn = ( sq == eq && sa > ea );
908 while( !bReady )
909 {
910 for( wxNode *node = pointsarray[q].First(); node; node = node->Next() )
911 {
912 // once: go to starting point in start quadrant
913 if( !bStarted &&
914 (
915 ( (wxPoint*) node->Data() )->x < xsa+1 && q <= 1
916 ||
917 ( (wxPoint*) node->Data() )->x > xsa-1 && q >= 2
918 )
919 )
920 {
921 bStarted = true;
922 }
923
924 // copy point, if not at ending point
925 if( bStarted )
926 {
927 if( q != eq || bForceTurn
928 ||
929 ( (wxPoint*) node->Data() )->x > xea+1 && q <= 1
930 ||
931 ( (wxPoint*) node->Data() )->x < xea-1 && q >= 2
932 )
933 {
934 // copy point
935 wxPoint* pPoint = new wxPoint( *((wxPoint*) node->Data() ) );
936 points->Append( (wxObject*) pPoint );
937 }
938 else if( q == eq && !bForceTurn || ( (wxPoint*) node->Data() )->x == xea)
939 {
940 bReady = true;
941 }
942 }
943 } // for node
944 ++q;
945 if( q > 3 ) q = 0;
946 bForceTurn = false;
947 bStarted = true;
948 } // while not bReady
949 points->Append( (wxObject*) new wxPoint( xea, yea ) );
950
951 // delete points
952 for( q = 0; q < 4; ++q )
953 {
954 for( wxNode *node = pointsarray[q].First(); node; node = node->Next() )
955 {
956 wxPoint *p = (wxPoint *)node->Data();
957 delete p;
958 }
959 }
960 }
961 else
962 {
963 // copy whole ellipse, wxPoints will be deleted outside
964 for( wxNode *node = pointsarray[0].First(); node; node = node->Next() )
965 {
966 wxObject *p = node->Data();
967 points->Append( p );
968 }
969 for( node = pointsarray[1].First(); node; node = node->Next() )
970 {
971 wxObject *p = node->Data();
972 points->Append( p );
973 }
974 for( node = pointsarray[2].First(); node; node = node->Next() )
975 {
976 wxObject *p = node->Data();
977 points->Append( p );
978 }
979 for( node = pointsarray[3].First(); node; node = node->Next() )
980 {
981 wxObject *p = node->Data();
982 points->Append( p );
983 }
984 } // not iUseAngles
985 } // CalculateEllipticPoints
986
987 #endif
988