]> git.saurik.com Git - wxWidgets.git/blob - src/os2/dc.cpp
added wxUSE_NOTEBOOK to include/wx/msw/setup0.h, removed wxUSE_RADIOBUTTON (we
[wxWidgets.git] / src / os2 / dc.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: dc.cpp
3 // Purpose: wxDC class
4 // Author: David Webster
5 // Modified by:
6 // Created: 10/14/99
7 // RCS-ID: $Id$
8 // Copyright: (c) David Webster
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifndef WX_PRECOMP
16 #include "wx/window.h"
17 #include "wx/dc.h"
18 #include "wx/utils.h"
19 #include "wx/dialog.h"
20 #include "wx/app.h"
21 #include "wx/bitmap.h"
22 #include "wx/dcmemory.h"
23 #include "wx/log.h"
24 #include "wx/icon.h"
25 #endif
26
27 #include "wx/dcprint.h"
28
29 #include <string.h>
30 #include <math.h>
31
32 #include "wx/os2/private.h"
33
34 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
35
36 // ---------------------------------------------------------------------------
37 // constants
38 // ---------------------------------------------------------------------------
39
40 static const int VIEWPORT_EXTENT = 1000;
41
42 static const int MM_POINTS = 9;
43 static const int MM_METRIC = 10;
44
45 // ===========================================================================
46 // implementation
47 // ===========================================================================
48
49 // ---------------------------------------------------------------------------
50 // wxDC
51 // ---------------------------------------------------------------------------
52
53 wxDC::wxDC(void)
54 {
55 m_canvas = NULL;
56
57 m_oldBitmap = 0;
58 m_oldPen = 0;
59 m_oldBrush = 0;
60 m_oldFont = 0;
61 m_oldPalette = 0;
62
63 m_bOwnsDC = FALSE;
64 m_hDC = 0;
65 m_hDCCount = 0;
66 };
67
68 wxDC::~wxDC(void)
69 {
70 // TODO:
71 };
72
73 // This will select current objects out of the DC,
74 // which is what you have to do before deleting the
75 // DC.
76 void wxDC::SelectOldObjects(WXHDC dc)
77 {
78 if (dc)
79 {
80 if (m_oldBitmap)
81 {
82 // ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
83 if (m_selectedBitmap.Ok())
84 {
85 m_selectedBitmap.SetSelectedInto(NULL);
86 }
87 }
88 m_oldBitmap = 0;
89 if (m_oldPen)
90 {
91 // ::SelectObject((HDC) dc, (HPEN) m_oldPen);
92 }
93 m_oldPen = 0;
94 if (m_oldBrush)
95 {
96 // ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
97 }
98 m_oldBrush = 0;
99 if (m_oldFont)
100 {
101 // ::SelectObject((HDC) dc, (HFONT) m_oldFont);
102 }
103 m_oldFont = 0;
104 if (m_oldPalette)
105 {
106 // ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
107 }
108 m_oldPalette = 0;
109 }
110
111 m_brush = wxNullBrush;
112 m_pen = wxNullPen;
113 m_palette = wxNullPalette;
114 m_font = wxNullFont;
115 m_backgroundBrush = wxNullBrush;
116 m_selectedBitmap = wxNullBitmap;
117 }
118
119 // ---------------------------------------------------------------------------
120 // clipping
121 // ---------------------------------------------------------------------------
122
123 void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
124 {
125 // TODO
126 }
127
128 void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y
129 ,wxCoord width, wxCoord height
130 )
131 {
132 // TODO
133 }
134
135 void wxDC::DoClipping(WXHDC dc)
136 {
137 if (m_clipping && dc)
138 {
139 // TODO:
140 // IntersectClipRect((HDC) dc, XLOG2DEV(m_clipX1), YLOG2DEV(m_clipY1),
141 // XLOG2DEV(m_clipX2), YLOG2DEV(m_clipY2));
142 }
143 }
144
145 void wxDC::DestroyClippingRegion(void)
146 {
147 // TODO:
148 };
149
150 // ---------------------------------------------------------------------------
151 // query capabilities
152 // ---------------------------------------------------------------------------
153
154 bool wxDC::CanDrawBitmap() const
155 {
156 return TRUE;
157 }
158
159 bool wxDC::CanGetTextExtent() const
160 {
161 // What sort of display is it?
162 int technology = 0; // TODO: ::GetDeviceCaps(GetHdc(), TECHNOLOGY);
163
164 // TODO: return (technology == DT_RASDISPLAY) || (technology == DT_RASPRINTER);
165 return FALSE;
166 }
167
168 int wxDC::GetDepth() const
169 {
170 // TODO:
171 return (1);
172 }
173
174 // ---------------------------------------------------------------------------
175 // drawing
176 // ---------------------------------------------------------------------------
177
178 void wxDC::Clear()
179 {
180 // TODO
181 }
182
183 void wxDC::DoFloodFill( wxCoord x
184 ,wxCoord y
185 ,const wxColour& col
186 ,int style
187 )
188 {
189 // TODO
190 }
191
192 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
193 {
194 // TODO
195 return(TRUE);
196 }
197
198 void wxDC::DoCrossHair(wxCoord x, wxCoord y)
199 {
200 // TODO
201 }
202
203 void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
204 {
205 // TODO
206 }
207
208 void wxDC::DoDrawArc( wxCoord x1, wxCoord y1
209 ,wxCoord x2, wxCoord y2
210 ,wxCoord xc, wxCoord yc
211 )
212 {
213 // TODO
214 }
215
216 void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
217 {
218 // TODO
219 }
220
221 void wxDC::DoDrawPolygon(int n, wxPoint points[]
222 ,wxCoord xoffset, wxCoord yoffset
223 ,int fillStyle
224 )
225 {
226 // TODO
227 }
228
229 void wxDC::DoDrawLines( int n, wxPoint points[]
230 ,wxCoord xoffset, wxCoord yoffset
231 )
232 {
233 // TODO
234 }
235
236 void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
237 {
238 // TODO
239 }
240
241 void wxDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y
242 ,wxCoord width, wxCoord height
243 ,double radius
244 )
245 {
246 // TODO
247 }
248
249 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
250 {
251 // TODO
252 }
253
254 void wxDC::DoDrawEllipticArc( wxCoord x
255 ,wxCoord y
256 ,wxCoord w
257 ,wxCoord h
258 ,double sa
259 ,double ea
260 )
261 {
262 // TODO
263 }
264
265 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
266 {
267 // TODO
268 }
269
270 void wxDC::DoDrawBitmap( const wxBitmap &bmp
271 ,wxCoord x, wxCoord y
272 ,bool useMask
273 )
274 {
275 // TODO
276 }
277
278 void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
279 {
280 // TODO
281 }
282
283 void wxDC::DoDrawRotatedText(const wxString& text,
284 wxCoord x, wxCoord y,
285 double angle)
286 {
287 // TODO:
288 /*
289 if ( angle == 0.0 )
290 {
291 DoDrawText(text, x, y);
292 }
293 else
294 {
295 LOGFONT lf;
296 wxFillLogFont(&lf, &m_font);
297
298 // GDI wants the angle in tenth of degree
299 long angle10 = (long)(angle * 10);
300 lf.lfEscapement = angle10;
301 lf. lfOrientation = angle10;
302
303 HFONT hfont = ::CreateFontIndirect(&lf);
304 if ( !hfont )
305 {
306 wxLogLastError("CreateFont");
307 }
308 else
309 {
310 HFONT hfontOld = ::SelectObject(GetHdc(), hfont);
311
312 DrawAnyText(text, x, y);
313
314 (void)::SelectObject(GetHdc(), hfontOld);
315 }
316
317 // call the bounding box by adding all four vertices of the rectangle
318 // containing the text to it (simpler and probably not slower than
319 // determining which of them is really topmost/leftmost/...)
320 wxCoord w, h;
321 GetTextExtent(text, &w, &h);
322
323 double rad = DegToRad(angle);
324
325 // "upper left" and "upper right"
326 CalcBoundingBox(x, y);
327 CalcBoundingBox(x + w*cos(rad), y - h*sin(rad));
328 CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
329
330 // "bottom left" and "bottom right"
331 x += (wxCoord)(h*sin(rad));
332 y += (wxCoord)(h*cos(rad));
333 CalcBoundingBox(x, y);
334 CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
335 }
336 */
337 }
338
339 // ---------------------------------------------------------------------------
340 // set GDI objects
341 // ---------------------------------------------------------------------------
342
343 void wxDC::SetPalette(const wxPalette& palette)
344 {
345 // TODO
346 }
347
348 void wxDC::SetFont(const wxFont& font)
349 {
350 // TODO
351 }
352
353 void wxDC::SetPen(const wxPen& pen)
354 {
355 // TODO
356 }
357 void wxDC::SetBrush(const wxBrush& brush)
358 {
359 // TODO
360 }
361
362 void wxDC::SetBackground(const wxBrush& brush)
363 {
364 // TODO
365 }
366
367 void wxDC::SetBackgroundMode(int mode)
368 {
369 // TODO
370 }
371
372 void wxDC::SetLogicalFunction(int function)
373 {
374 // TODO
375 }
376
377 void wxDC::SetRop(WXHDC dc)
378 {
379 if (!dc || m_logicalFunction < 0)
380 return;
381
382 int c_rop;
383 // These may be wrong
384 switch (m_logicalFunction)
385 {
386 // TODO: Figure this stuff out
387 // case wxXOR: c_rop = R2_XORPEN; break;
388 // case wxXOR: c_rop = R2_NOTXORPEN; break;
389 // case wxINVERT: c_rop = R2_NOT; break;
390 // case wxOR_REVERSE: c_rop = R2_MERGEPENNOT; break;
391 // case wxAND_REVERSE: c_rop = R2_MASKPENNOT; break;
392 // case wxCLEAR: c_rop = R2_WHITE; break;
393 // case wxSET: c_rop = R2_BLACK; break;
394 // case wxSRC_INVERT: c_rop = R2_NOTCOPYPEN; break;
395 // case wxOR_INVERT: c_rop = R2_MERGENOTPEN; break;
396 // case wxAND: c_rop = R2_MASKPEN; break;
397 // case wxOR: c_rop = R2_MERGEPEN; break;
398 // case wxAND_INVERT: c_rop = R2_MASKNOTPEN; break;
399 // case wxEQUIV:
400 // case wxNAND:
401 // case wxCOPY:
402 default:
403 // c_rop = R2_COPYPEN;
404 break;
405 }
406 // SetROP2((HDC) dc, c_rop);
407 }
408
409 bool wxDC::StartDoc(const wxString& message)
410 {
411 // We might be previewing, so return TRUE to let it continue.
412 return TRUE;
413 }
414
415 void wxDC::EndDoc()
416 {
417 }
418
419 void wxDC::StartPage()
420 {
421 }
422
423 void wxDC::EndPage()
424 {
425 }
426
427 // ---------------------------------------------------------------------------
428 // text metrics
429 // ---------------------------------------------------------------------------
430
431 wxCoord wxDC::GetCharHeight() const
432 {
433 // TODO
434 return(1);
435 }
436
437 wxCoord wxDC::GetCharWidth() const
438 {
439 // TODO
440 return(1);
441 }
442
443 void wxDC::DoGetTextExtent( const wxString& string
444 ,wxCoord* x
445 ,wxCoord* y
446 ,wxCoord* decent
447 ,wxCoord* externalLeading
448 ,wxFont* theFont
449 ) const
450 {
451 // TODO:
452 }
453
454 void wxDC::SetMapMode( int mode )
455 {
456 // TODO:
457 };
458
459 void wxDC::SetUserScale(double x, double y)
460 {
461 m_userScaleX = x;
462 m_userScaleY = y;
463
464 SetMapMode(m_mappingMode);
465 }
466
467 void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
468 {
469 m_signX = xLeftRight ? 1 : -1;
470 m_signY = yBottomUp ? -1 : 1;
471
472 SetMapMode(m_mappingMode);
473 }
474
475 void wxDC::SetSystemScale(double x, double y)
476 {
477 m_scaleX = x;
478 m_scaleY = y;
479
480 SetMapMode(m_mappingMode);
481 }
482
483 void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
484 {
485 // TODO:
486 };
487
488 void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
489 {
490 // TODO:
491 };
492
493 // ---------------------------------------------------------------------------
494 // coordinates transformations
495 // ---------------------------------------------------------------------------
496
497 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
498 {
499 wxCoord new_x = x - m_deviceOriginX;
500 if (new_x > 0)
501 return (wxCoord)((double)(new_x) / m_scaleX + 0.5) * m_signX + m_logicalOriginX;
502 else
503 return (wxCoord)((double)(new_x) / m_scaleX - 0.5) * m_signX + m_logicalOriginX;
504 };
505
506 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
507 {
508 if (x > 0)
509 return (wxCoord)((double)(x) / m_scaleX + 0.5);
510 else
511 return (wxCoord)((double)(x) / m_scaleX - 0.5);
512 };
513
514 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
515 {
516 wxCoord new_y = y - m_deviceOriginY;
517 if (new_y > 0)
518 return (wxCoord)((double)(new_y) / m_scaleY + 0.5) * m_signY + m_logicalOriginY;
519 else
520 return (wxCoord)((double)(new_y) / m_scaleY - 0.5) * m_signY + m_logicalOriginY;
521 };
522
523 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
524 {
525 if (y > 0)
526 return (wxCoord)((double)(y) / m_scaleY + 0.5);
527 else
528 return (wxCoord)((double)(y) / m_scaleY - 0.5);
529 };
530
531 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
532 {
533 wxCoord new_x = x - m_logicalOriginX;
534 if (new_x > 0)
535 return (wxCoord)((double)(new_x) * m_scaleX + 0.5) * m_signX + m_deviceOriginX;
536 else
537 return (wxCoord)((double)(new_x) * m_scaleX - 0.5) * m_signX + m_deviceOriginX;
538 };
539
540 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
541 {
542 if (x > 0)
543 return (wxCoord)((double)(x) * m_scaleX + 0.5);
544 else
545 return (wxCoord)((double)(x) * m_scaleX - 0.5);
546 };
547
548 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
549 {
550 wxCoord new_y = y - m_logicalOriginY;
551 if (new_y > 0)
552 return (wxCoord)((double)(new_y) * m_scaleY + 0.5) * m_signY + m_deviceOriginY;
553 else
554 return (wxCoord)((double)(new_y) * m_scaleY - 0.5) * m_signY + m_deviceOriginY;
555 };
556
557 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
558 {
559 if (y > 0)
560 return (wxCoord)((double)(y) * m_scaleY + 0.5);
561 else
562 return (wxCoord)((double)(y) * m_scaleY - 0.5);
563 };
564
565 // ---------------------------------------------------------------------------
566 // bit blit
567 // ---------------------------------------------------------------------------
568
569 bool wxDC::DoBlit( wxCoord xdest
570 ,wxCoord ydest
571 ,wxCoord width
572 ,wxCoord height
573 ,wxDC *source
574 ,wxCoord xsrc
575 ,wxCoord ysrc
576 ,int rop
577 ,bool useMask
578 )
579 {
580 // TODO
581 return(TRUE);
582 }
583
584 void wxDC::DoGetSize( int* width, int* height ) const
585 {
586 // TODO:
587 };
588
589 void wxDC::DoGetSizeMM( int* width, int* height ) const
590 {
591 // TODO:
592 };
593
594 wxSize wxDC::GetPPI() const
595 {
596 int x = 1;
597 int y = 1;
598 // TODO:
599 return (wxSize(x,y));
600 }
601
602 void wxDC::SetLogicalScale( double x, double y )
603 {
604 // TODO:
605 };
606
607 #if WXWIN_COMPATIBILITY
608 void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
609 float *descent, float *externalLeading,
610 wxFont *theFont, bool use16bit) const
611 {
612 wxCoord x1, y1, descent1, externalLeading1;
613 GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
614 *x = x1; *y = y1;
615 if (descent)
616 *descent = descent1;
617 if (externalLeading)
618 *externalLeading = externalLeading1;
619 }
620 #endif
621
622 // ---------------------------------------------------------------------------
623 // spline drawing code
624 // ---------------------------------------------------------------------------
625
626 #if wxUSE_SPLINES
627
628 class wxSpline: public wxObject
629 {
630 public:
631 int type;
632 wxList *points;
633
634 wxSpline(wxList *list);
635 void DeletePoints();
636
637 // Doesn't delete points
638 ~wxSpline();
639 };
640
641 void wx_draw_open_spline(wxDC *dc, wxSpline *spline);
642
643 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
644 double a3, double b3, double a4, double b4);
645 void wx_clear_stack();
646 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
647 double *y3, double *x4, double *y4);
648 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
649 double x4, double y4);
650 static bool wx_spline_add_point(double x, double y);
651 static void wx_spline_draw_point_array(wxDC *dc);
652 wxSpline *wx_make_spline(int x1, int y1, int x2, int y2, int x3, int y3);
653
654 void wxDC::DoDrawSpline(wxList *list)
655 {
656 wxSpline spline(list);
657
658 wx_draw_open_spline(this, &spline);
659 }
660
661 wxList wx_spline_point_list;
662
663 void wx_draw_open_spline(wxDC *dc, wxSpline *spline)
664 {
665 wxPoint *p;
666 double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
667 double x1, y1, x2, y2;
668
669 wxNode *node = spline->points->First();
670 p = (wxPoint *)node->Data();
671
672 x1 = p->x;
673 y1 = p->y;
674
675 node = node->Next();
676 p = (wxPoint *)node->Data();
677
678 x2 = p->x;
679 y2 = p->y;
680 cx1 = (double)((x1 + x2) / 2);
681 cy1 = (double)((y1 + y2) / 2);
682 cx2 = (double)((cx1 + x2) / 2);
683 cy2 = (double)((cy1 + y2) / 2);
684
685 wx_spline_add_point(x1, y1);
686
687 while ((node = node->Next()) != NULL)
688 {
689 p = (wxPoint *)node->Data();
690 x1 = x2;
691 y1 = y2;
692 x2 = p->x;
693 y2 = p->y;
694 cx4 = (double)(x1 + x2) / 2;
695 cy4 = (double)(y1 + y2) / 2;
696 cx3 = (double)(x1 + cx4) / 2;
697 cy3 = (double)(y1 + cy4) / 2;
698
699 wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
700
701 cx1 = cx4;
702 cy1 = cy4;
703 cx2 = (double)(cx1 + x2) / 2;
704 cy2 = (double)(cy1 + y2) / 2;
705 }
706
707 wx_spline_add_point((double)wx_round(cx1), (double)wx_round(cy1));
708 wx_spline_add_point(x2, y2);
709
710 wx_spline_draw_point_array(dc);
711
712 }
713
714 /********************* CURVES FOR SPLINES *****************************
715
716 The following spline drawing routine is from
717
718 "An Algorithm for High-Speed Curve Generation"
719 by George Merrill Chaikin,
720 Computer Graphics and Image Processing, 3, Academic Press,
721 1974, 346-349.
722
723 and
724
725 "On Chaikin's Algorithm" by R. F. Riesenfeld,
726 Computer Graphics and Image Processing, 4, Academic Press,
727 1975, 304-310.
728
729 ***********************************************************************/
730
731 #define half(z1, z2) ((z1+z2)/2.0)
732 #define THRESHOLD 5
733
734 /* iterative version */
735
736 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
737 double b4)
738 {
739 register double xmid, ymid;
740 double x1, y1, x2, y2, x3, y3, x4, y4;
741
742 wx_clear_stack();
743 wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
744
745 while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
746 xmid = (double)half(x2, x3);
747 ymid = (double)half(y2, y3);
748 if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
749 fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
750 wx_spline_add_point((double)wx_round(x1), (double)wx_round(y1));
751 wx_spline_add_point((double)wx_round(xmid), (double)wx_round(ymid));
752 } else {
753 wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
754 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
755 wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
756 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
757 }
758 }
759 }
760
761
762 /* utilities used by spline drawing routines */
763
764
765 typedef struct wx_spline_stack_struct {
766 double x1, y1, x2, y2, x3, y3, x4, y4;
767 }
768 Stack;
769
770 #define SPLINE_STACK_DEPTH 20
771 static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
772 static Stack *wx_stack_top;
773 static int wx_stack_count;
774
775 void wx_clear_stack()
776 {
777 wx_stack_top = wx_spline_stack;
778 wx_stack_count = 0;
779 }
780
781 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
782 {
783 wx_stack_top->x1 = x1;
784 wx_stack_top->y1 = y1;
785 wx_stack_top->x2 = x2;
786 wx_stack_top->y2 = y2;
787 wx_stack_top->x3 = x3;
788 wx_stack_top->y3 = y3;
789 wx_stack_top->x4 = x4;
790 wx_stack_top->y4 = y4;
791 wx_stack_top++;
792 wx_stack_count++;
793 }
794
795 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
796 double *x3, double *y3, double *x4, double *y4)
797 {
798 if (wx_stack_count == 0)
799 return (0);
800 wx_stack_top--;
801 wx_stack_count--;
802 *x1 = wx_stack_top->x1;
803 *y1 = wx_stack_top->y1;
804 *x2 = wx_stack_top->x2;
805 *y2 = wx_stack_top->y2;
806 *x3 = wx_stack_top->x3;
807 *y3 = wx_stack_top->y3;
808 *x4 = wx_stack_top->x4;
809 *y4 = wx_stack_top->y4;
810 return (1);
811 }
812
813 static bool wx_spline_add_point(double x, double y)
814 {
815 wxPoint *point = new wxPoint;
816 point->x = (int) x;
817 point->y = (int) y;
818 wx_spline_point_list.Append((wxObject*)point);
819 return TRUE;
820 }
821
822 static void wx_spline_draw_point_array(wxDC *dc)
823 {
824 dc->DrawLines(&wx_spline_point_list, 0, 0);
825 wxNode *node = wx_spline_point_list.First();
826 while (node)
827 {
828 wxPoint *point = (wxPoint *)node->Data();
829 delete point;
830 delete node;
831 node = wx_spline_point_list.First();
832 }
833 }
834
835 wxSpline::wxSpline(wxList *list)
836 {
837 points = list;
838 }
839
840 wxSpline::~wxSpline()
841 {
842 }
843
844 void wxSpline::DeletePoints()
845 {
846 for(wxNode *node = points->First(); node; node = points->First())
847 {
848 wxPoint *point = (wxPoint *)node->Data();
849 delete point;
850 delete node;
851 }
852 delete points;
853 }
854
855
856 #endif // wxUSE_SPLINES
857