src/os2/dc.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        dc.cpp
// Purpose:     wxDC class
// Author:      David Webster
// Modified by:
// Created:     10/14/99
// RCS-ID:      $Id$
// Copyright:   (c) David Webster
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifndef WX_PRECOMP
    #include "wx/window.h"
    #include "wx/dc.h"
    #include "wx/utils.h"
    #include "wx/dialog.h"
    #include "wx/app.h"
    #include "wx/bitmap.h"
    #include "wx/dcmemory.h"
    #include "wx/log.h"
    #include "wx/icon.h"
#endif

#include "wx/dcprint.h"

#include <string.h>
#include <math.h>

#include "wx/os2/private.h"

    IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)

// ---------------------------------------------------------------------------
// constants
// ---------------------------------------------------------------------------

static const int VIEWPORT_EXTENT = 1000;

static const int MM_POINTS = 9;
static const int MM_METRIC = 10;

// ===========================================================================
// implementation
// ===========================================================================

// ---------------------------------------------------------------------------
// wxDC
// ---------------------------------------------------------------------------

wxDC::wxDC(void)
{
    m_canvas  = NULL;

    m_oldBitmap  = 0;
    m_oldPen     = 0;
    m_oldBrush   = 0;
    m_oldFont    = 0;
    m_oldPalette = 0;

    m_bOwnsDC = FALSE;
    m_hDC        = 0;
    m_hDCCount   = 0;
};

wxDC::~wxDC(void)
{
    // TODO:
};

// This will select current objects out of the DC,
// which is what you have to do before deleting the
// DC.
void wxDC::SelectOldObjects(WXHDC dc)
{
    if (dc)
    {
        if (m_oldBitmap)
        {
//            ::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
            if (m_selectedBitmap.Ok())
            {
                m_selectedBitmap.SetSelectedInto(NULL);
            }
        }
        m_oldBitmap = 0;
        if (m_oldPen)
        {
//            ::SelectObject((HDC) dc, (HPEN) m_oldPen);
        }
        m_oldPen = 0;
        if (m_oldBrush)
        {
//            ::SelectObject((HDC) dc, (HBRUSH) m_oldBrush);
        }
        m_oldBrush = 0;
        if (m_oldFont)
        {
//            ::SelectObject((HDC) dc, (HFONT) m_oldFont);
        }
        m_oldFont = 0;
        if (m_oldPalette)
        {
//            ::SelectPalette((HDC) dc, (HPALETTE) m_oldPalette, TRUE);
        }
        m_oldPalette = 0;
    }

    m_brush = wxNullBrush;
    m_pen = wxNullPen;
    m_palette = wxNullPalette;
    m_font = wxNullFont;
    m_backgroundBrush = wxNullBrush;
    m_selectedBitmap = wxNullBitmap;
}

// ---------------------------------------------------------------------------
// clipping
// ---------------------------------------------------------------------------

void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
{
   // TODO
}

void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y
                               ,wxCoord width, wxCoord height
                              )
{
   // TODO
}

void wxDC::DoClipping(WXHDC dc)
{
    if (m_clipping && dc)
    {
//      TODO:
//      IntersectClipRect((HDC) dc, XLOG2DEV(m_clipX1), YLOG2DEV(m_clipY1),
//                                  XLOG2DEV(m_clipX2), YLOG2DEV(m_clipY2));
    }
}

void wxDC::DestroyClippingRegion(void)
{
    // TODO:
};

// ---------------------------------------------------------------------------
// query capabilities
// ---------------------------------------------------------------------------

bool wxDC::CanDrawBitmap() const
{
    return TRUE;
}

bool wxDC::CanGetTextExtent() const
{
    // What sort of display is it?
    int technology = 0; // TODO:  ::GetDeviceCaps(GetHdc(), TECHNOLOGY);

    // TODO: return (technology == DT_RASDISPLAY) || (technology == DT_RASPRINTER);
    return FALSE;
}

int wxDC::GetDepth() const
{
   // TODO:
   return (1);
}

// ---------------------------------------------------------------------------
// drawing
// ---------------------------------------------------------------------------

void wxDC::Clear()
{
   // TODO
}

void wxDC::DoFloodFill( wxCoord x
                       ,wxCoord y
                       ,const wxColour& col
                       ,int style
                      )
{
   // TODO
}

bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
{
   // TODO
   return(TRUE);
}

void wxDC::DoCrossHair(wxCoord x, wxCoord y)
{
   // TODO
}

void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
{
   // TODO
}

void wxDC::DoDrawArc( wxCoord x1, wxCoord y1
                     ,wxCoord x2, wxCoord y2
                     ,wxCoord xc, wxCoord yc
                    )
{
   // TODO
}

void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
{
   // TODO
}

void wxDC::DoDrawPolygon(int n, wxPoint points[]
                         ,wxCoord xoffset, wxCoord yoffset
                         ,int fillStyle
                        )
{
   // TODO
}

void wxDC::DoDrawLines( int n, wxPoint points[]
                       ,wxCoord xoffset, wxCoord yoffset
                      )
{
   // TODO
}

void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
{
   // TODO
}

void wxDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y
                                  ,wxCoord width, wxCoord height
                                  ,double radius
                                 )
{
   // TODO
}

void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
{
   // TODO
}

void wxDC::DoDrawEllipticArc( wxCoord x
                             ,wxCoord y
                             ,wxCoord w
                             ,wxCoord h
                             ,double sa
                             ,double ea
                            )
{
   // TODO
}

void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
{
   // TODO
}

void wxDC::DoDrawBitmap( const wxBitmap &bmp
                        ,wxCoord x, wxCoord y
                        ,bool useMask
                       )
{
   // TODO
}

void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
{
   // TODO
}

void wxDC::DoDrawRotatedText(const wxString& text,
                             wxCoord x, wxCoord y,
                             double angle)
{
   // TODO:
   /*
    if ( angle == 0.0 )
    {
        DoDrawText(text, x, y);
    }
    else
    {
        LOGFONT lf;
        wxFillLogFont(&lf, &m_font);

        // GDI wants the angle in tenth of degree
        long angle10 = (long)(angle * 10);
        lf.lfEscapement = angle10;
        lf. lfOrientation = angle10;

        HFONT hfont = ::CreateFontIndirect(&lf);
        if ( !hfont )
        {
            wxLogLastError("CreateFont");
        }
        else
        {
            HFONT hfontOld = ::SelectObject(GetHdc(), hfont);

            DrawAnyText(text, x, y);

            (void)::SelectObject(GetHdc(), hfontOld);
        }

        // call the bounding box by adding all four vertices of the rectangle
        // containing the text to it (simpler and probably not slower than
        // determining which of them is really topmost/leftmost/...)
        wxCoord w, h;
        GetTextExtent(text, &w, &h);

        double rad = DegToRad(angle);

        // "upper left" and "upper right"
        CalcBoundingBox(x, y);
        CalcBoundingBox(x + w*cos(rad), y - h*sin(rad));
        CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));

        // "bottom left" and "bottom right"
        x += (wxCoord)(h*sin(rad));
        y += (wxCoord)(h*cos(rad));
        CalcBoundingBox(x, y);
        CalcBoundingBox(x + h*sin(rad), y + h*cos(rad));
    }
*/
}

// ---------------------------------------------------------------------------
// set GDI objects
// ---------------------------------------------------------------------------

void wxDC::SetPalette(const wxPalette& palette)
{
   // TODO
}

void wxDC::SetFont(const wxFont& font)
{
   // TODO
}

void wxDC::SetPen(const wxPen& pen)
{
   // TODO
}
void wxDC::SetBrush(const wxBrush& brush)
{
   // TODO
}

void wxDC::SetBackground(const wxBrush& brush)
{
   // TODO
}

void wxDC::SetBackgroundMode(int mode)
{
   // TODO
}

void wxDC::SetLogicalFunction(int function)
{
   // TODO
}

void wxDC::SetRop(WXHDC dc)
{
    if (!dc || m_logicalFunction < 0)
        return;

    int c_rop;
    // These may be wrong
    switch (m_logicalFunction)
    {
// TODO: Figure this stuff out
        //    case wxXOR: c_rop = R2_XORPEN; break;
//    case wxXOR: c_rop = R2_NOTXORPEN; break;
//    case wxINVERT: c_rop = R2_NOT; break;
//    case wxOR_REVERSE: c_rop = R2_MERGEPENNOT; break;
//    case wxAND_REVERSE: c_rop = R2_MASKPENNOT; break;
//    case wxCLEAR: c_rop = R2_WHITE; break;
//    case wxSET: c_rop = R2_BLACK; break;
//    case wxSRC_INVERT: c_rop = R2_NOTCOPYPEN; break;
//    case wxOR_INVERT: c_rop = R2_MERGENOTPEN; break;
//    case wxAND: c_rop = R2_MASKPEN; break;
//    case wxOR: c_rop = R2_MERGEPEN; break;
//    case wxAND_INVERT: c_rop = R2_MASKNOTPEN; break;
//    case wxEQUIV:
//    case wxNAND:
//    case wxCOPY:
    default:
//      c_rop = R2_COPYPEN;
        break;
    }
//    SetROP2((HDC) dc, c_rop);
}

bool wxDC::StartDoc(const wxString& message)
{
    // We might be previewing, so return TRUE to let it continue.
    return TRUE;
}

void wxDC::EndDoc()
{
}

void wxDC::StartPage()
{
}

void wxDC::EndPage()
{
}

// ---------------------------------------------------------------------------
// text metrics
// ---------------------------------------------------------------------------

wxCoord wxDC::GetCharHeight() const
{
    // TODO
    return(1);
}

wxCoord wxDC::GetCharWidth() const
{
    // TODO
    return(1);
}

void wxDC::DoGetTextExtent( const wxString& string
                           ,wxCoord* x
                           ,wxCoord* y
                           ,wxCoord* decent
                           ,wxCoord* externalLeading
                           ,wxFont* theFont
                          ) const
{
   // TODO:
}

void wxDC::SetMapMode( int mode )
{
    // TODO:
};

void wxDC::SetUserScale(double x, double y)
{
    m_userScaleX = x;
    m_userScaleY = y;

    SetMapMode(m_mappingMode);
}

void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
{
    m_signX = xLeftRight ? 1 : -1;
    m_signY = yBottomUp ? -1 : 1;

    SetMapMode(m_mappingMode);
}

void wxDC::SetSystemScale(double x, double y)
{
    m_scaleX = x;
    m_scaleY = y;

    SetMapMode(m_mappingMode);
}

void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
{
    // TODO:
};

void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
{
    // TODO:
};

// ---------------------------------------------------------------------------
// coordinates transformations
// ---------------------------------------------------------------------------

wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
{
    wxCoord new_x = x - m_deviceOriginX;
    if (new_x > 0)
        return (wxCoord)((double)(new_x) / m_scaleX + 0.5) * m_signX + m_logicalOriginX;
    else
        return (wxCoord)((double)(new_x) / m_scaleX - 0.5) * m_signX + m_logicalOriginX;
};

wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
{
    if (x > 0)
        return (wxCoord)((double)(x) / m_scaleX + 0.5);
    else
        return (wxCoord)((double)(x) / m_scaleX - 0.5);
};

wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
{
    wxCoord new_y = y - m_deviceOriginY;
    if (new_y > 0)
        return (wxCoord)((double)(new_y) / m_scaleY + 0.5) * m_signY + m_logicalOriginY;
    else
        return (wxCoord)((double)(new_y) / m_scaleY - 0.5) * m_signY + m_logicalOriginY;
};

wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
{
    if (y > 0)
        return (wxCoord)((double)(y) / m_scaleY + 0.5);
    else
        return (wxCoord)((double)(y) / m_scaleY - 0.5);
};

wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
{
    wxCoord new_x = x - m_logicalOriginX;
    if (new_x > 0)
        return (wxCoord)((double)(new_x) * m_scaleX + 0.5) * m_signX + m_deviceOriginX;
    else
    return (wxCoord)((double)(new_x) * m_scaleX - 0.5) * m_signX + m_deviceOriginX;
};

wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
{
    if (x > 0)
        return (wxCoord)((double)(x) * m_scaleX + 0.5);
    else
        return (wxCoord)((double)(x) * m_scaleX - 0.5);
};

wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
{
    wxCoord new_y = y - m_logicalOriginY;
    if (new_y > 0)
        return (wxCoord)((double)(new_y) * m_scaleY + 0.5) * m_signY + m_deviceOriginY;
    else
        return (wxCoord)((double)(new_y) * m_scaleY - 0.5) * m_signY + m_deviceOriginY;
};

wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
{
    if (y > 0)
        return (wxCoord)((double)(y) * m_scaleY + 0.5);
    else
        return (wxCoord)((double)(y) * m_scaleY - 0.5);
};

// ---------------------------------------------------------------------------
// bit blit
// ---------------------------------------------------------------------------

bool wxDC::DoBlit( wxCoord xdest
                  ,wxCoord ydest
                  ,wxCoord width
                  ,wxCoord height
                  ,wxDC *source
                  ,wxCoord xsrc
                  ,wxCoord ysrc
                  ,int  rop
                  ,bool useMask
                 )
{
   // TODO
   return(TRUE);
}

void wxDC::DoGetSize( int* width, int* height ) const
{
    // TODO:
};

void wxDC::DoGetSizeMM( int* width, int* height ) const
{
    // TODO:
};

wxSize wxDC::GetPPI() const
{
   int x = 1;
   int y = 1;
   // TODO:
   return (wxSize(x,y));
}

void wxDC::SetLogicalScale( double x, double y )
{
    // TODO:
};

#if WXWIN_COMPATIBILITY
void wxDC::DoGetTextExtent(const wxString& string, float *x, float *y,
                         float *descent, float *externalLeading,
                         wxFont *theFont, bool use16bit) const
{
    wxCoord x1, y1, descent1, externalLeading1;
    GetTextExtent(string, & x1, & y1, & descent1, & externalLeading1, theFont, use16bit);
    *x = x1; *y = y1;
    if (descent)
        *descent = descent1;
    if (externalLeading)
        *externalLeading = externalLeading1;
}
#endif

// ---------------------------------------------------------------------------
// spline drawing code
// ---------------------------------------------------------------------------

#if wxUSE_SPLINES

class wxSpline: public wxObject
{
public:
    int type;
    wxList *points;

    wxSpline(wxList *list);
    void DeletePoints();

    // Doesn't delete points
    ~wxSpline();
};

void wx_draw_open_spline(wxDC *dc, wxSpline *spline);

void wx_quadratic_spline(double a1, double b1, double a2, double b2,
                         double a3, double b3, double a4, double b4);
void wx_clear_stack();
int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
                  double *y3, double *x4, double *y4);
void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
                    double x4, double y4);
static bool wx_spline_add_point(double x, double y);
static void wx_spline_draw_point_array(wxDC *dc);
wxSpline *wx_make_spline(int x1, int y1, int x2, int y2, int x3, int y3);

void wxDC::DoDrawSpline(wxList *list)
{
    wxSpline spline(list);

    wx_draw_open_spline(this, &spline);
}

wxList wx_spline_point_list;

void wx_draw_open_spline(wxDC *dc, wxSpline *spline)
{
    wxPoint *p;
    double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
    double           x1, y1, x2, y2;

    wxNode *node = spline->points->First();
    p = (wxPoint *)node->Data();

    x1 = p->x;
    y1 = p->y;

    node = node->Next();
    p = (wxPoint *)node->Data();

    x2 = p->x;
    y2 = p->y;
    cx1 = (double)((x1 + x2) / 2);
    cy1 = (double)((y1 + y2) / 2);
    cx2 = (double)((cx1 + x2) / 2);
    cy2 = (double)((cy1 + y2) / 2);

    wx_spline_add_point(x1, y1);

    while ((node = node->Next()) != NULL)
    {
        p = (wxPoint *)node->Data();
        x1 = x2;
        y1 = y2;
        x2 = p->x;
        y2 = p->y;
        cx4 = (double)(x1 + x2) / 2;
        cy4 = (double)(y1 + y2) / 2;
        cx3 = (double)(x1 + cx4) / 2;
        cy3 = (double)(y1 + cy4) / 2;

        wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);

        cx1 = cx4;
        cy1 = cy4;
        cx2 = (double)(cx1 + x2) / 2;
        cy2 = (double)(cy1 + y2) / 2;
    }

    wx_spline_add_point((double)wx_round(cx1), (double)wx_round(cy1));
    wx_spline_add_point(x2, y2);

    wx_spline_draw_point_array(dc);

}

/********************* CURVES FOR SPLINES *****************************

  The following spline drawing routine is from

    "An Algorithm for High-Speed Curve Generation"
    by George Merrill Chaikin,
    Computer Graphics and Image Processing, 3, Academic Press,
    1974, 346-349.

      and

        "On Chaikin's Algorithm" by R. F. Riesenfeld,
        Computer Graphics and Image Processing, 4, Academic Press,
        1975, 304-310.

***********************************************************************/

#define     half(z1, z2)    ((z1+z2)/2.0)
#define     THRESHOLD   5

/* iterative version */

void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
                         double b4)
{
    register double  xmid, ymid;
    double           x1, y1, x2, y2, x3, y3, x4, y4;

    wx_clear_stack();
    wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);

    while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
        xmid = (double)half(x2, x3);
        ymid = (double)half(y2, y3);
        if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
            fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
            wx_spline_add_point((double)wx_round(x1), (double)wx_round(y1));
            wx_spline_add_point((double)wx_round(xmid), (double)wx_round(ymid));
        } else {
            wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
                (double)half(x3, x4), (double)half(y3, y4), x4, y4);
            wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
                (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
        }
    }
}


/* utilities used by spline drawing routines */


typedef struct wx_spline_stack_struct {
    double           x1, y1, x2, y2, x3, y3, x4, y4;
}
Stack;

#define         SPLINE_STACK_DEPTH             20
static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
static Stack   *wx_stack_top;
static int      wx_stack_count;

void wx_clear_stack()
{
    wx_stack_top = wx_spline_stack;
    wx_stack_count = 0;
}

void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
    wx_stack_top->x1 = x1;
    wx_stack_top->y1 = y1;
    wx_stack_top->x2 = x2;
    wx_stack_top->y2 = y2;
    wx_stack_top->x3 = x3;
    wx_stack_top->y3 = y3;
    wx_stack_top->x4 = x4;
    wx_stack_top->y4 = y4;
    wx_stack_top++;
    wx_stack_count++;
}

int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
                  double *x3, double *y3, double *x4, double *y4)
{
    if (wx_stack_count == 0)
        return (0);
    wx_stack_top--;
    wx_stack_count--;
    *x1 = wx_stack_top->x1;
    *y1 = wx_stack_top->y1;
    *x2 = wx_stack_top->x2;
    *y2 = wx_stack_top->y2;
    *x3 = wx_stack_top->x3;
    *y3 = wx_stack_top->y3;
    *x4 = wx_stack_top->x4;
    *y4 = wx_stack_top->y4;
    return (1);
}

static bool wx_spline_add_point(double x, double y)
{
    wxPoint *point = new wxPoint;
    point->x = (int) x;
    point->y = (int) y;
    wx_spline_point_list.Append((wxObject*)point);
    return TRUE;
}

static void wx_spline_draw_point_array(wxDC *dc)
{
    dc->DrawLines(&wx_spline_point_list, 0, 0);
    wxNode *node = wx_spline_point_list.First();
    while (node)
    {
        wxPoint *point = (wxPoint *)node->Data();
        delete point;
        delete node;
        node = wx_spline_point_list.First();
    }
}

wxSpline::wxSpline(wxList *list)
{
    points = list;
}

wxSpline::~wxSpline()
{
}

void wxSpline::DeletePoints()
{
    for(wxNode *node = points->First(); node; node = points->First())
    {
        wxPoint *point = (wxPoint *)node->Data();
        delete point;
        delete node;
    }
    delete points;
}


#endif // wxUSE_SPLINES
Commit	Line	Data
	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 + wcos(rad), y - hsin(rad));
	328	CalcBoundingBox(x + hsin(rad), y + hcos(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 + hsin(rad), y + hcos(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