wxPython/src/pseudodc.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        common/pseudodc.cpp
// Purpose:     Implementation of the wxPseudoDC Class
// Author:      Paul Lanier
// Modified by:
// Created:     05/25/06
// RCS-ID:      $Id$
// Copyright:   (c) wxWidgets team
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#undef DEBUG
#include <Python.h>
#include "wx/wxPython/wxPython.h"
#include "wx/wxPython/pseudodc.h"

// wxList based class definitions
#include <wx/listimpl.cpp>
WX_DEFINE_LIST(pdcOpList);
WX_DEFINE_LIST(pdcObjectList);

//----------------------------------------------------------------------------
// Helper functions used for drawing greyed out versions of objects
//----------------------------------------------------------------------------
wxColour &MakeColourGrey(const wxColour &c)
{
    static wxColour rval;
    rval.Set(byte((230-c.Red())*0.7+c.Red()),
             byte((230-c.Green())*0.7+c.Green()),
             byte((230-c.Blue())*0.7+c.Blue()));
    return rval;
}
wxBrush &GetGreyBrush(wxBrush &brush)
{
	static wxBrush b;
	wxColour c;
	b = brush;
	c = MakeColourGrey(brush.GetColour());
	b.SetColour(c);
	return b;
}

wxPen &GetGreyPen(wxPen &pen)
{
	static wxPen p;
	wxColour c;
	p = pen;
	c = MakeColourGrey(pen.GetColour());
	p.SetColour(c);
	return p;
}

void GreyOutImage(wxImage &img)
{
    unsigned char *data = img.GetData();
    unsigned char r,g,b;
    unsigned char mr,mg,mb;
    int i, tst;
    int len = img.GetHeight()*img.GetWidth()*3;
    if (img.HasMask())
    {
        mr = img.GetMaskRed();
        mg = img.GetMaskGreen();
        mb = img.GetMaskBlue();
    }
    tst=0;
    for (i=0;i<len;i+=3)
    {
        r=data[i]; g=data[i+1]; b=data[i+2];
        if (!img.HasMask() ||
            r!=mr || g!=mg || b!=mb)
        {
            if (!tst)
            {
                tst=1;
            }
            r = (unsigned char)((230.0-r)*0.7+r);
            g = (unsigned char)((230.0-g)*0.7+g);
            b = (unsigned char)((230.0-b)*0.7+b);
            data[i]=r; data[i+1]=g; data[i+2]=b;
        }
    }
}

wxIcon &GetGreyIcon(wxIcon &icon)
{
    wxBitmap bmp;
    bmp.CopyFromIcon(icon);
    wxImage img = bmp.ConvertToImage();
    GreyOutImage(img);
    wxBitmap bmp2(img,32);
    static wxIcon rval;
    rval.CopyFromBitmap(bmp2);
    return rval;
}

wxBitmap &GetGreyBitmap(wxBitmap &bmp)
{
    wxImage img = bmp.ConvertToImage();
    GreyOutImage(img);
    static wxBitmap rval(img,32);
    return rval;
}

// ============================================================================
// various pdcOp class implementation methods
// ============================================================================

// ----------------------------------------------------------------------------
// pdcDrawPolyPolygonOp constructor
// ----------------------------------------------------------------------------
pdcDrawPolyPolygonOp::pdcDrawPolyPolygonOp(int n, int count[], wxPoint points[],
                 wxCoord xoffset, wxCoord yoffset, int fillStyle)
{
    m_n=n; m_xoffset=xoffset; m_yoffset=yoffset; m_fillStyle=fillStyle;
    int total_n=0;
    if (n)
    {
        m_count = new int[n];
        for(int i=0; i<n; i++)
        {
            total_n+=count[i];
            m_count[i]=count[i];
        }
        if (total_n)
        {
            m_points = new wxPoint[total_n];
            for(int j=0; j<total_n; j++)
                m_points[j] = points[j];
        }
        else m_points=NULL;
    }
    else
    {
        m_points=NULL;
        m_count=NULL;
    }
    m_totaln = total_n;
}

// ----------------------------------------------------------------------------
// pdcDrawPolyPolygonOp destructor
// ----------------------------------------------------------------------------
pdcDrawPolyPolygonOp::~pdcDrawPolyPolygonOp()
{
    if (m_points) delete m_points;
    if (m_count) delete m_count;
    m_points=NULL;
    m_count=NULL;
}

// ----------------------------------------------------------------------------
// pdcDrawLinesOp constructor
// ----------------------------------------------------------------------------
pdcDrawLinesOp::pdcDrawLinesOp(int n, wxPoint points[],
             wxCoord xoffset, wxCoord yoffset)
{
    m_n=n; m_xoffset=xoffset; m_yoffset=yoffset;
    if (n)
    {
        m_points = new wxPoint[n];
        for (int i=0; i<n; i++)
            m_points[i] = points[i];
    }
    else m_points=NULL;
}

// ----------------------------------------------------------------------------
// pdcDrawLinesOp destructor
// ----------------------------------------------------------------------------
pdcDrawLinesOp::~pdcDrawLinesOp()
{
    if (m_points) delete m_points;
    m_points=NULL;
}

// ----------------------------------------------------------------------------
// pdcDrawPolygonOp constructor
// ----------------------------------------------------------------------------
pdcDrawPolygonOp::pdcDrawPolygonOp(int n, wxPoint points[],
             wxCoord xoffset, wxCoord yoffset, int fillStyle)
{
    m_n=n; m_xoffset=xoffset; m_yoffset=yoffset; m_fillStyle=fillStyle;
    if (n)
    {
        m_points = new wxPoint[n];
        for (int i=0; i<n; i++)
            m_points[i] = points[i];
    }
    else m_points=NULL;
}

// ----------------------------------------------------------------------------
// pdcDrawPolygonOp destructor
// ----------------------------------------------------------------------------
pdcDrawPolygonOp::~pdcDrawPolygonOp()
{
    if (m_points) delete m_points;
    m_points=NULL;
}

#if wxUSE_SPLINES
// ----------------------------------------------------------------------------
// pdcDrawSplineOp constructor
// ----------------------------------------------------------------------------
pdcDrawSplineOp::pdcDrawSplineOp(int n, wxPoint points[])
{
    m_n=n;
    if (n)
    {
        m_points = new wxPoint[n];
        for(int i=0; i<n; i++)
            m_points[i] = points[i];
    }
    else m_points=NULL;
}

// ----------------------------------------------------------------------------
// pdcDrawSplineOp destructor
// ----------------------------------------------------------------------------
pdcDrawSplineOp::~pdcDrawSplineOp()
{
    if (m_points) delete m_points;
    m_points=NULL;
}
#endif // wxUSE_SPLINES

// ============================================================================
// pdcObject implementation
// ============================================================================
// ----------------------------------------------------------------------------
// DrawToDC - play back the op list to the DC
// ----------------------------------------------------------------------------
void pdcObject::DrawToDC(wxDC *dc)
{
    pdcOpList::Node *node = m_oplist.GetFirst();
    while(node)
    {
        node->GetData()->DrawToDC(dc, m_greyedout);
        node = node->GetNext();
    }
}

// ----------------------------------------------------------------------------
// Translate - translate all the operations by some dx,dy
// ----------------------------------------------------------------------------
void pdcObject::Translate(wxCoord dx, wxCoord dy)
{
    pdcOpList::Node *node = m_oplist.GetFirst();
    while(node)
    {
        node->GetData()->Translate(dx,dy);
        node = node->GetNext();
    }
	if (m_bounded)
	{
		m_bounds.x += dx;
		m_bounds.y += dy;
	}
}

// ----------------------------------------------------------------------------
// SetGreyedOut - set the greyout member and cache grey versions of everything
// if greyout is true
// ----------------------------------------------------------------------------
void pdcObject::SetGreyedOut(bool greyout)
{
	m_greyedout=greyout;
	if (greyout)
	{
		pdcOpList::Node *node = m_oplist.GetFirst();
        pdcOp *obj;
		while(node)
		{

			obj = node->GetData();
            obj->CacheGrey();
			node = node->GetNext();
		}
	}
}

// ============================================================================
// wxPseudoDC implementation
// ============================================================================

// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
wxPseudoDC::~wxPseudoDC()
{
    // delete all the nodes in the list
	RemoveAll();

}

// ----------------------------------------------------------------------------
// ClearAll - remove all nodes from list
// ----------------------------------------------------------------------------
void wxPseudoDC::RemoveAll(void)
{
    m_objectlist.Clear();
    m_currId = -1;
	m_lastObjNode = NULL;
}

// ----------------------------------------------------------------------------
// GetLen - return the number of operations in the current op list
// ----------------------------------------------------------------------------
int wxPseudoDC::GetLen(void)
{
    pdcObjectList::Node *pt = m_objectlist.GetFirst();
    int len=0;
    while (pt)
    {
        len += pt->GetData()->GetLen();
        pt = pt->GetNext();
    }
    return len;
}

// ----------------------------------------------------------------------------
// FindObjNode - find and return an object node by id.  If node doesn't exist
//               and create is true then create one and return it.  Otherwise
//               return NULL.
// ----------------------------------------------------------------------------
pdcObjectList::Node *wxPseudoDC::FindObjNode(int id, bool create)
{
    // see if last operation was for same id
    if (m_lastObjNode && m_lastObjNode->GetData()->GetId() == id)
        return m_lastObjNode;
    // if not then search for it
    pdcObjectList::Node *pt = m_objectlist.GetFirst();
    while (pt)
    {
        if (pt->GetData()->GetId() == id)
		{

            // cache this node for future operations
            m_lastObjNode = pt;
            return pt;
        }
        pt = pt->GetNext();
    }
    // if create then create and return a new node
    if (create)
    {
        // cache this node for future operations
        m_lastObjNode = m_objectlist.Append(new pdcObject(id));
        return m_lastObjNode;
    }
    // otherwise just return NULL
    return NULL;
}

// ----------------------------------------------------------------------------
// AddToList - Add a node to the list at the end (preserve draw order)
// ----------------------------------------------------------------------------
void wxPseudoDC::AddToList(pdcOp *newOp)
{
    pdcObjectList::Node *pt = FindObjNode(m_currId, true);
    pt->GetData()->AddOp(newOp);
}

// ----------------------------------------------------------------------------
// ClearID - remove all the operations associated with a single ID
// ----------------------------------------------------------------------------
void wxPseudoDC::ClearId(int id)
{
    pdcObjectList::Node *pt = FindObjNode(id);
    if (pt) pt->GetData()->Clear();
}

// ----------------------------------------------------------------------------
// RemoveID - Remove the object node (and all operations) associated with an id
// ----------------------------------------------------------------------------
void wxPseudoDC::RemoveId(int id)
{
    pdcObjectList::Node *pt = FindObjNode(id);
    if (pt)
    {
        if (m_lastObjNode == pt)
            m_lastObjNode = NULL;
        m_objectlist.DeleteNode(pt);
    }
}

// ----------------------------------------------------------------------------
// SetIdBounds - Set the bounding rect for a given id
// ----------------------------------------------------------------------------
void wxPseudoDC::SetIdBounds(int id, wxRect& rect)
{
    pdcObjectList::Node *pt = FindObjNode(id, true);
    pt->GetData()->SetBounds(rect);
}

// ----------------------------------------------------------------------------
// GetIdBounds - Get the bounding rect for a given id
// ----------------------------------------------------------------------------
void wxPseudoDC::GetIdBounds(int id, wxRect& rect)
{
    pdcObjectList::Node *pt = FindObjNode(id);
	if (pt && pt->GetData()->IsBounded())
		rect = pt->GetData()->GetBounds();
	else
		rect.x = rect.y = rect.width = rect.height = 0;
}

// ----------------------------------------------------------------------------
// TranslateId - Translate all the operations of a single id
// ----------------------------------------------------------------------------
void wxPseudoDC::TranslateId(int id, wxCoord dx, wxCoord dy)
{
    pdcObjectList::Node *pt = FindObjNode(id);
    if (pt) pt->GetData()->Translate(dx,dy);
}

// ----------------------------------------------------------------------------
// DrawIdToDC - Draw a specific id to the dc passed in
// ----------------------------------------------------------------------------
void wxPseudoDC::DrawIdToDC(int id, wxDC *dc)
{
    pdcObjectList::Node *pt = FindObjNode(id);
    if (pt) pt->GetData()->DrawToDC(dc);
}

// ----------------------------------------------------------------------------
// SetIdGreyedOut - Set the greyedout member of id
// ----------------------------------------------------------------------------
void wxPseudoDC::SetIdGreyedOut(int id, bool greyout)
{
    pdcObjectList::Node *pt = FindObjNode(id);
    if (pt) pt->GetData()->SetGreyedOut(greyout);
}

// ----------------------------------------------------------------------------
// GetIdGreyedOut - Get the greyedout member of id
// ----------------------------------------------------------------------------
bool wxPseudoDC::GetIdGreyedOut(int id)
{
    pdcObjectList::Node *pt = FindObjNode(id);
    if (pt) return pt->GetData()->GetGreyedOut();
	else return false;
}

// ----------------------------------------------------------------------------
// FindObjectsByBBox - Return a list of all the ids whose bounding boxes
//                     contain (x,y)
// ----------------------------------------------------------------------------
PyObject *wxPseudoDC::FindObjectsByBBox(wxCoord x, wxCoord y)
{
    //wxPyBlock_t blocked = wxPyBeginBlockThreads();
    pdcObjectList::Node *pt = m_objectlist.GetFirst();
    pdcObject *obj;
    PyObject* pyList = NULL;
    pyList = PyList_New(0);
    wxRect r;
    while (pt)
    {
        obj = pt->GetData();
        r = obj->GetBounds();
        if (obj->IsBounded() && r.Contains(x,y))
        {
            PyObject* pyObj = PyInt_FromLong((long)obj->GetId());
            PyList_Insert(pyList, 0, pyObj);
            Py_DECREF(pyObj);
        }
        pt = pt->GetNext();
    }
    //wxPyEndBlockThreads(blocked);
    return pyList;
}

// ----------------------------------------------------------------------------
// FindObjects - Return a list of all the ids that draw to (x,y)
// ----------------------------------------------------------------------------
PyObject *wxPseudoDC::FindObjects(wxCoord x, wxCoord y,
                                  wxCoord radius, const wxColor& bg)
{
    //wxPyBlock_t blocked = wxPyBeginBlockThreads();
    pdcObjectList::Node *pt = m_objectlist.GetFirst();
    pdcObject *obj;
    PyObject* pyList = NULL;
    pyList = PyList_New(0);
    wxBrush bgbrush(bg);
    wxPen bgpen(bg);
    // special case radius = 0
    if (radius == 0)
    {
        wxBitmap bmp(4,4,24);
        wxMemoryDC memdc;
        wxColor pix;
        wxRect viewrect(x-2,y-2,4,4);
        // setup the memdc for rendering
        memdc.SelectObject(bmp);
        memdc.SetBackground(bgbrush);
        memdc.Clear();
        memdc.SetDeviceOrigin(2-x,2-y);
        while (pt)
        {
            obj = pt->GetData();
            if (obj->IsBounded() && obj->GetBounds().Contains(x,y))
            {
                // start clean
                memdc.SetBrush(bgbrush);
                memdc.SetPen(bgpen);
                memdc.DrawRectangle(viewrect);
                // draw the object
                obj->DrawToDC(&memdc);
                memdc.GetPixel(x,y,&pix);
                // clear and update rgn2
                if (pix != bg)
                {
                    PyObject* pyObj = PyInt_FromLong((long)obj->GetId());
                    PyList_Insert(pyList, 0, pyObj);
                    Py_DECREF(pyObj);
                }
            }
            pt = pt->GetNext();
        }
        memdc.SelectObject(wxNullBitmap);
    }
    else
    {
        wxRect viewrect(x-radius,y-radius,2*radius,2*radius);
        wxBitmap maskbmp(2*radius,2*radius,24);
        wxMemoryDC maskdc;
        // create bitmap with circle for masking
        maskdc.SelectObject(maskbmp);
        maskdc.SetBackground(*wxBLACK_BRUSH);
        maskdc.Clear();
        maskdc.SetBrush(*wxWHITE_BRUSH);
        maskdc.SetPen(*wxWHITE_PEN);
        maskdc.DrawCircle(radius,radius,radius);
        // now setup a memdc for rendering our object
        wxBitmap bmp(2*radius,2*radius,24);
        wxMemoryDC memdc;
        memdc.SelectObject(bmp);
        // set the origin so (x,y) is in the bmp center
        memdc.SetDeviceOrigin(radius-x,radius-y);
        // a region will be used to see if the result is empty
        wxRegion rgn2;
        while (pt)
        {
            obj = pt->GetData();
            if (obj->IsBounded() && viewrect.Intersects(obj->GetBounds()))
            {
                // start clean
                //memdc.Clear();
                memdc.SetBrush(bgbrush);
                memdc.SetPen(bgpen);
                memdc.DrawRectangle(viewrect);
                // draw the object
                obj->DrawToDC(&memdc);
                // remove background color
                memdc.SetLogicalFunction(wxXOR);
                memdc.SetBrush(bgbrush);
                memdc.SetPen(bgpen);
                memdc.DrawRectangle(viewrect);
                memdc.SetLogicalFunction(wxCOPY);
                // AND with circle bitmap
                memdc.Blit(x-radius,y-radius,2*radius,2*radius,&maskdc,0,0,wxAND);
                // clear and update rgn2
                memdc.SelectObject(wxNullBitmap);
                rgn2.Clear();
                rgn2.Union(bmp, *wxBLACK);
                //rgn2.Intersect(rgn);
                memdc.SelectObject(bmp);
                if (!rgn2.IsEmpty())
                {
                    PyObject* pyObj = PyInt_FromLong((long)obj->GetId());
                    PyList_Insert(pyList, 0, pyObj);
                    Py_DECREF(pyObj);
                }
            }
            pt = pt->GetNext();
        }
        maskdc.SelectObject(wxNullBitmap);
        memdc.SelectObject(wxNullBitmap);
    }
    //wxPyEndBlockThreads(blocked);
    return pyList;
}

// ----------------------------------------------------------------------------
// DrawToDCClipped - play back the op list to the DC but clip any objects
//                   known to be not in rect.  This is a coarse level of
//                   clipping to speed things up when lots of objects are off
//                   screen and doesn't affect the dc level clipping
// ----------------------------------------------------------------------------
void wxPseudoDC::DrawToDCClipped(wxDC *dc, const wxRect& rect)
{
    pdcObjectList::Node *pt = m_objectlist.GetFirst();
    pdcObject *obj;
    while (pt)
    {
        obj = pt->GetData();
        if (!obj->IsBounded() || rect.Intersects(obj->GetBounds()))
            obj->DrawToDC(dc);
        pt = pt->GetNext();
    }
}
void wxPseudoDC::DrawToDCClippedRgn(wxDC *dc, const wxRegion& region)
{
    pdcObjectList::Node *pt = m_objectlist.GetFirst();
    pdcObject *obj;
    while (pt)
    {
        obj = pt->GetData();
        if (!obj->IsBounded() ||
		    (region.Contains(obj->GetBounds()) != wxOutRegion))
            obj->DrawToDC(dc);
        pt = pt->GetNext();
    }
}

// ----------------------------------------------------------------------------
// DrawToDC - play back the op list to the DC
// ----------------------------------------------------------------------------
void wxPseudoDC::DrawToDC(wxDC *dc)
{
    pdcObjectList::Node *pt = m_objectlist.GetFirst();
    while (pt)
    {
        pt->GetData()->DrawToDC(dc);
        pt = pt->GetNext();
    }
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: common/pseudodc.cpp
	3	// Purpose: Implementation of the wxPseudoDC Class
	4	// Author: Paul Lanier
	5	// Modified by:
	6	// Created: 05/25/06
	7	// RCS-ID: $Id$
	8	// Copyright: (c) wxWidgets team
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// For compilers that support precompilation, includes "wx.h".
	13	//include "wx/wxprec.h"
	14
	15	#undef DEBUG
	16	#include <Python.h>
	17	#include "wx/wxPython/wxPython.h"
	18	#include "wx/wxPython/pseudodc.h"
	19
	20	// wxList based class definitions
	21	#include <wx/listimpl.cpp>
	22	WX_DEFINE_LIST(pdcOpList);
	23	WX_DEFINE_LIST(pdcObjectList);
	24
	25	//----------------------------------------------------------------------------
	26	// Helper functions used for drawing greyed out versions of objects
	27	//----------------------------------------------------------------------------
	28	wxColour &MakeColourGrey(const wxColour &c)
	29	{
	30	static wxColour rval;
	31	rval.Set(byte((230-c.Red())*0.7+c.Red()),
	32	byte((230-c.Green())*0.7+c.Green()),
	33	byte((230-c.Blue())*0.7+c.Blue()));
	34	return rval;
	35	}
	36	wxBrush &GetGreyBrush(wxBrush &brush)
	37	{
	38	static wxBrush b;
	39	wxColour c;
	40	b = brush;
	41	c = MakeColourGrey(brush.GetColour());
	42	b.SetColour(c);
	43	return b;
	44	}
	45
	46	wxPen &GetGreyPen(wxPen &pen)
	47	{
	48	static wxPen p;
	49	wxColour c;
	50	p = pen;
	51	c = MakeColourGrey(pen.GetColour());
	52	p.SetColour(c);
	53	return p;
	54	}
	55
	56	void GreyOutImage(wxImage &img)
	57	{
	58	unsigned char *data = img.GetData();
	59	unsigned char r,g,b;
	60	unsigned char mr,mg,mb;
	61	int i, tst;
	62	int len = img.GetHeight()img.GetWidth()3;
	63	if (img.HasMask())
	64	{
	65	mr = img.GetMaskRed();
	66	mg = img.GetMaskGreen();
	67	mb = img.GetMaskBlue();
	68	}
	69	tst=0;
	70	for (i=0;i<len;i+=3)
	71	{
	72	r=data[i]; g=data[i+1]; b=data[i+2];
	73	if (!img.HasMask() \|\|
	74	r!=mr \|\| g!=mg \|\| b!=mb)
	75	{
	76	if (!tst)
	77	{
	78	tst=1;
	79	}
	80	r = (unsigned char)((230.0-r)*0.7+r);
	81	g = (unsigned char)((230.0-g)*0.7+g);
	82	b = (unsigned char)((230.0-b)*0.7+b);
	83	data[i]=r; data[i+1]=g; data[i+2]=b;
	84	}
	85	}
	86	}
	87
	88	wxIcon &GetGreyIcon(wxIcon &icon)
	89	{
	90	wxBitmap bmp;
	91	bmp.CopyFromIcon(icon);
	92	wxImage img = bmp.ConvertToImage();
	93	GreyOutImage(img);
	94	wxBitmap bmp2(img,32);
	95	static wxIcon rval;
	96	rval.CopyFromBitmap(bmp2);
	97	return rval;
	98	}
	99
	100	wxBitmap &GetGreyBitmap(wxBitmap &bmp)
	101	{
	102	wxImage img = bmp.ConvertToImage();
	103	GreyOutImage(img);
	104	static wxBitmap rval(img,32);
	105	return rval;
	106	}
	107
	108	// ============================================================================
	109	// various pdcOp class implementation methods
	110	// ============================================================================
	111
	112	// ----------------------------------------------------------------------------
	113	// pdcDrawPolyPolygonOp constructor
	114	// ----------------------------------------------------------------------------
	115	pdcDrawPolyPolygonOp::pdcDrawPolyPolygonOp(int n, int count[], wxPoint points[],
	116	wxCoord xoffset, wxCoord yoffset, int fillStyle)
	117	{
	118	m_n=n; m_xoffset=xoffset; m_yoffset=yoffset; m_fillStyle=fillStyle;
	119	int total_n=0;
	120	if (n)
	121	{
	122	m_count = new int[n];
	123	for(int i=0; i<n; i++)
	124	{
	125	total_n+=count[i];
	126	m_count[i]=count[i];
	127	}
	128	if (total_n)
	129	{
	130	m_points = new wxPoint[total_n];
	131	for(int j=0; j<total_n; j++)
	132	m_points[j] = points[j];
	133	}
	134	else m_points=NULL;
	135	}
	136	else
	137	{
	138	m_points=NULL;
	139	m_count=NULL;
	140	}
	141	m_totaln = total_n;
	142	}
	143
	144	// ----------------------------------------------------------------------------
	145	// pdcDrawPolyPolygonOp destructor
	146	// ----------------------------------------------------------------------------
	147	pdcDrawPolyPolygonOp::~pdcDrawPolyPolygonOp()
	148	{
	149	if (m_points) delete m_points;
	150	if (m_count) delete m_count;
	151	m_points=NULL;
	152	m_count=NULL;
	153	}
	154
	155	// ----------------------------------------------------------------------------
	156	// pdcDrawLinesOp constructor
	157	// ----------------------------------------------------------------------------
	158	pdcDrawLinesOp::pdcDrawLinesOp(int n, wxPoint points[],
	159	wxCoord xoffset, wxCoord yoffset)
	160	{
	161	m_n=n; m_xoffset=xoffset; m_yoffset=yoffset;
	162	if (n)
	163	{
	164	m_points = new wxPoint[n];
	165	for (int i=0; i<n; i++)
	166	m_points[i] = points[i];
	167	}
	168	else m_points=NULL;
	169	}
	170
	171	// ----------------------------------------------------------------------------
	172	// pdcDrawLinesOp destructor
	173	// ----------------------------------------------------------------------------
	174	pdcDrawLinesOp::~pdcDrawLinesOp()
	175	{
	176	if (m_points) delete m_points;
	177	m_points=NULL;
	178	}
	179
	180	// ----------------------------------------------------------------------------
	181	// pdcDrawPolygonOp constructor
	182	// ----------------------------------------------------------------------------
	183	pdcDrawPolygonOp::pdcDrawPolygonOp(int n, wxPoint points[],
	184	wxCoord xoffset, wxCoord yoffset, int fillStyle)
	185	{
	186	m_n=n; m_xoffset=xoffset; m_yoffset=yoffset; m_fillStyle=fillStyle;
	187	if (n)
	188	{
	189	m_points = new wxPoint[n];
	190	for (int i=0; i<n; i++)
	191	m_points[i] = points[i];
	192	}
	193	else m_points=NULL;
	194	}
	195
	196	// ----------------------------------------------------------------------------
	197	// pdcDrawPolygonOp destructor
	198	// ----------------------------------------------------------------------------
	199	pdcDrawPolygonOp::~pdcDrawPolygonOp()
	200	{
	201	if (m_points) delete m_points;
	202	m_points=NULL;
	203	}
	204
	205	#if wxUSE_SPLINES
	206	// ----------------------------------------------------------------------------
	207	// pdcDrawSplineOp constructor
	208	// ----------------------------------------------------------------------------
	209	pdcDrawSplineOp::pdcDrawSplineOp(int n, wxPoint points[])
	210	{
	211	m_n=n;
	212	if (n)
	213	{
	214	m_points = new wxPoint[n];
	215	for(int i=0; i<n; i++)
	216	m_points[i] = points[i];
	217	}
	218	else m_points=NULL;
	219	}
	220
	221	// ----------------------------------------------------------------------------
	222	// pdcDrawSplineOp destructor
	223	// ----------------------------------------------------------------------------
	224	pdcDrawSplineOp::~pdcDrawSplineOp()
	225	{
	226	if (m_points) delete m_points;
	227	m_points=NULL;
	228	}
	229	#endif // wxUSE_SPLINES
	230
	231	// ============================================================================
	232	// pdcObject implementation
	233	// ============================================================================
	234	// ----------------------------------------------------------------------------
	235	// DrawToDC - play back the op list to the DC
	236	// ----------------------------------------------------------------------------
	237	void pdcObject::DrawToDC(wxDC *dc)
	238	{
	239	pdcOpList::Node *node = m_oplist.GetFirst();
	240	while(node)
	241	{
	242	node->GetData()->DrawToDC(dc, m_greyedout);
	243	node = node->GetNext();
	244	}
	245	}
	246
	247	// ----------------------------------------------------------------------------
	248	// Translate - translate all the operations by some dx,dy
	249	// ----------------------------------------------------------------------------
	250	void pdcObject::Translate(wxCoord dx, wxCoord dy)
	251	{
	252	pdcOpList::Node *node = m_oplist.GetFirst();
	253	while(node)
	254	{
	255	node->GetData()->Translate(dx,dy);
	256	node = node->GetNext();
	257	}
	258	if (m_bounded)
	259	{
	260	m_bounds.x += dx;
	261	m_bounds.y += dy;
	262	}
	263	}
	264
	265	// ----------------------------------------------------------------------------
	266	// SetGreyedOut - set the greyout member and cache grey versions of everything
	267	// if greyout is true
	268	// ----------------------------------------------------------------------------
	269	void pdcObject::SetGreyedOut(bool greyout)
	270	{
	271	m_greyedout=greyout;
	272	if (greyout)
	273	{
	274	pdcOpList::Node *node = m_oplist.GetFirst();
	275	pdcOp *obj;
	276	while(node)
	277	{
	278
	279	obj = node->GetData();
	280	obj->CacheGrey();
	281	node = node->GetNext();
	282	}
	283	}
	284	}
	285
	286	// ============================================================================
	287	// wxPseudoDC implementation
	288	// ============================================================================
	289
	290	// ----------------------------------------------------------------------------
	291	// Destructor
	292	// ----------------------------------------------------------------------------
	293	wxPseudoDC::~wxPseudoDC()
	294	{
	295	// delete all the nodes in the list
	296	RemoveAll();
	297
	298	}
	299
	300	// ----------------------------------------------------------------------------
	301	// ClearAll - remove all nodes from list
	302	// ----------------------------------------------------------------------------
	303	void wxPseudoDC::RemoveAll(void)
	304	{
	305	m_objectlist.Clear();
	306	m_currId = -1;
	307	m_lastObjNode = NULL;
	308	}
	309
	310	// ----------------------------------------------------------------------------
	311	// GetLen - return the number of operations in the current op list
	312	// ----------------------------------------------------------------------------
	313	int wxPseudoDC::GetLen(void)
	314	{
	315	pdcObjectList::Node *pt = m_objectlist.GetFirst();
	316	int len=0;
	317	while (pt)
	318	{
	319	len += pt->GetData()->GetLen();
	320	pt = pt->GetNext();
	321	}
	322	return len;
	323	}
	324
	325	// ----------------------------------------------------------------------------
	326	// FindObjNode - find and return an object node by id. If node doesn't exist
	327	// and create is true then create one and return it. Otherwise
	328	// return NULL.
	329	// ----------------------------------------------------------------------------
	330	pdcObjectList::Node *wxPseudoDC::FindObjNode(int id, bool create)
	331	{
	332	// see if last operation was for same id
	333	if (m_lastObjNode && m_lastObjNode->GetData()->GetId() == id)
	334	return m_lastObjNode;
	335	// if not then search for it
	336	pdcObjectList::Node *pt = m_objectlist.GetFirst();
	337	while (pt)
	338	{
	339	if (pt->GetData()->GetId() == id)
	340	{
	341
	342	// cache this node for future operations
	343	m_lastObjNode = pt;
	344	return pt;
	345	}
	346	pt = pt->GetNext();
	347	}
	348	// if create then create and return a new node
	349	if (create)
	350	{
	351	// cache this node for future operations
	352	m_lastObjNode = m_objectlist.Append(new pdcObject(id));
	353	return m_lastObjNode;
	354	}
	355	// otherwise just return NULL
	356	return NULL;
	357	}
	358
	359	// ----------------------------------------------------------------------------
	360	// AddToList - Add a node to the list at the end (preserve draw order)
	361	// ----------------------------------------------------------------------------
	362	void wxPseudoDC::AddToList(pdcOp *newOp)
	363	{
	364	pdcObjectList::Node *pt = FindObjNode(m_currId, true);
	365	pt->GetData()->AddOp(newOp);
	366	}
	367
	368	// ----------------------------------------------------------------------------
	369	// ClearID - remove all the operations associated with a single ID
	370	// ----------------------------------------------------------------------------
	371	void wxPseudoDC::ClearId(int id)
	372	{
	373	pdcObjectList::Node *pt = FindObjNode(id);
	374	if (pt) pt->GetData()->Clear();
	375	}
	376
	377	// ----------------------------------------------------------------------------
	378	// RemoveID - Remove the object node (and all operations) associated with an id
	379	// ----------------------------------------------------------------------------
	380	void wxPseudoDC::RemoveId(int id)
	381	{
	382	pdcObjectList::Node *pt = FindObjNode(id);
	383	if (pt)
	384	{
	385	if (m_lastObjNode == pt)
	386	m_lastObjNode = NULL;
	387	m_objectlist.DeleteNode(pt);
	388	}
	389	}
	390
	391	// ----------------------------------------------------------------------------
	392	// SetIdBounds - Set the bounding rect for a given id
	393	// ----------------------------------------------------------------------------
	394	void wxPseudoDC::SetIdBounds(int id, wxRect& rect)
	395	{
	396	pdcObjectList::Node *pt = FindObjNode(id, true);
	397	pt->GetData()->SetBounds(rect);
	398	}
	399
	400	// ----------------------------------------------------------------------------
	401	// GetIdBounds - Get the bounding rect for a given id
	402	// ----------------------------------------------------------------------------
	403	void wxPseudoDC::GetIdBounds(int id, wxRect& rect)
	404	{
	405	pdcObjectList::Node *pt = FindObjNode(id);
	406	if (pt && pt->GetData()->IsBounded())
	407	rect = pt->GetData()->GetBounds();
	408	else
	409	rect.x = rect.y = rect.width = rect.height = 0;
	410	}
	411
	412	// ----------------------------------------------------------------------------
	413	// TranslateId - Translate all the operations of a single id
	414	// ----------------------------------------------------------------------------
	415	void wxPseudoDC::TranslateId(int id, wxCoord dx, wxCoord dy)
	416	{
	417	pdcObjectList::Node *pt = FindObjNode(id);
	418	if (pt) pt->GetData()->Translate(dx,dy);
	419	}
	420
	421	// ----------------------------------------------------------------------------
	422	// DrawIdToDC - Draw a specific id to the dc passed in
	423	// ----------------------------------------------------------------------------
	424	void wxPseudoDC::DrawIdToDC(int id, wxDC *dc)
	425	{
	426	pdcObjectList::Node *pt = FindObjNode(id);
	427	if (pt) pt->GetData()->DrawToDC(dc);
	428	}
	429
	430	// ----------------------------------------------------------------------------
	431	// SetIdGreyedOut - Set the greyedout member of id
	432	// ----------------------------------------------------------------------------
	433	void wxPseudoDC::SetIdGreyedOut(int id, bool greyout)
	434	{
	435	pdcObjectList::Node *pt = FindObjNode(id);
	436	if (pt) pt->GetData()->SetGreyedOut(greyout);
	437	}
	438
	439	// ----------------------------------------------------------------------------
	440	// GetIdGreyedOut - Get the greyedout member of id
	441	// ----------------------------------------------------------------------------
	442	bool wxPseudoDC::GetIdGreyedOut(int id)
	443	{
	444	pdcObjectList::Node *pt = FindObjNode(id);
	445	if (pt) return pt->GetData()->GetGreyedOut();
	446	else return false;
	447	}
	448
	449	// ----------------------------------------------------------------------------
	450	// FindObjectsByBBox - Return a list of all the ids whose bounding boxes
	451	// contain (x,y)
	452	// ----------------------------------------------------------------------------
	453	PyObject *wxPseudoDC::FindObjectsByBBox(wxCoord x, wxCoord y)
	454	{
	455	//wxPyBlock_t blocked = wxPyBeginBlockThreads();
	456	pdcObjectList::Node *pt = m_objectlist.GetFirst();
	457	pdcObject *obj;
	458	PyObject* pyList = NULL;
	459	pyList = PyList_New(0);
	460	wxRect r;
	461	while (pt)
	462	{
	463	obj = pt->GetData();
	464	r = obj->GetBounds();
	465	if (obj->IsBounded() && r.Contains(x,y))
	466	{
	467	PyObject* pyObj = PyInt_FromLong((long)obj->GetId());
	468	PyList_Insert(pyList, 0, pyObj);
	469	Py_DECREF(pyObj);
	470	}
	471	pt = pt->GetNext();
	472	}
	473	//wxPyEndBlockThreads(blocked);
	474	return pyList;
	475	}
	476
	477	// ----------------------------------------------------------------------------
	478	// FindObjects - Return a list of all the ids that draw to (x,y)
	479	// ----------------------------------------------------------------------------
	480	PyObject *wxPseudoDC::FindObjects(wxCoord x, wxCoord y,
	481	wxCoord radius, const wxColor& bg)
	482	{
	483	//wxPyBlock_t blocked = wxPyBeginBlockThreads();
	484	pdcObjectList::Node *pt = m_objectlist.GetFirst();
	485	pdcObject *obj;
	486	PyObject* pyList = NULL;
	487	pyList = PyList_New(0);
	488	wxBrush bgbrush(bg);
	489	wxPen bgpen(bg);
	490	// special case radius = 0
	491	if (radius == 0)
	492	{
	493	wxBitmap bmp(4,4,24);
	494	wxMemoryDC memdc;
	495	wxColor pix;
	496	wxRect viewrect(x-2,y-2,4,4);
	497	// setup the memdc for rendering
	498	memdc.SelectObject(bmp);
	499	memdc.SetBackground(bgbrush);
	500	memdc.Clear();
	501	memdc.SetDeviceOrigin(2-x,2-y);
	502	while (pt)
	503	{
	504	obj = pt->GetData();
	505	if (obj->IsBounded() && obj->GetBounds().Contains(x,y))
	506	{
	507	// start clean
	508	memdc.SetBrush(bgbrush);
	509	memdc.SetPen(bgpen);
	510	memdc.DrawRectangle(viewrect);
	511	// draw the object
	512	obj->DrawToDC(&memdc);
	513	memdc.GetPixel(x,y,&pix);
	514	// clear and update rgn2
	515	if (pix != bg)
	516	{
	517	PyObject* pyObj = PyInt_FromLong((long)obj->GetId());
	518	PyList_Insert(pyList, 0, pyObj);
	519	Py_DECREF(pyObj);
	520	}
	521	}
	522	pt = pt->GetNext();
	523	}
	524	memdc.SelectObject(wxNullBitmap);
	525	}
	526	else
	527	{
	528	wxRect viewrect(x-radius,y-radius,2radius,2radius);
	529	wxBitmap maskbmp(2radius,2radius,24);
	530	wxMemoryDC maskdc;
	531	// create bitmap with circle for masking
	532	maskdc.SelectObject(maskbmp);
	533	maskdc.SetBackground(*wxBLACK_BRUSH);
	534	maskdc.Clear();
	535	maskdc.SetBrush(*wxWHITE_BRUSH);
	536	maskdc.SetPen(*wxWHITE_PEN);
	537	maskdc.DrawCircle(radius,radius,radius);
	538	// now setup a memdc for rendering our object
	539	wxBitmap bmp(2radius,2radius,24);
	540	wxMemoryDC memdc;
	541	memdc.SelectObject(bmp);
	542	// set the origin so (x,y) is in the bmp center
	543	memdc.SetDeviceOrigin(radius-x,radius-y);
	544	// a region will be used to see if the result is empty
	545	wxRegion rgn2;
	546	while (pt)
	547	{
	548	obj = pt->GetData();
	549	if (obj->IsBounded() && viewrect.Intersects(obj->GetBounds()))
	550	{
	551	// start clean
	552	//memdc.Clear();
	553	memdc.SetBrush(bgbrush);
	554	memdc.SetPen(bgpen);
	555	memdc.DrawRectangle(viewrect);
	556	// draw the object
	557	obj->DrawToDC(&memdc);
	558	// remove background color
	559	memdc.SetLogicalFunction(wxXOR);
	560	memdc.SetBrush(bgbrush);
	561	memdc.SetPen(bgpen);
	562	memdc.DrawRectangle(viewrect);
	563	memdc.SetLogicalFunction(wxCOPY);
	564	// AND with circle bitmap
	565	memdc.Blit(x-radius,y-radius,2radius,2radius,&maskdc,0,0,wxAND);
	566	// clear and update rgn2
	567	memdc.SelectObject(wxNullBitmap);
	568	rgn2.Clear();
	569	rgn2.Union(bmp, *wxBLACK);
	570	//rgn2.Intersect(rgn);
	571	memdc.SelectObject(bmp);
	572	if (!rgn2.IsEmpty())
	573	{
	574	PyObject* pyObj = PyInt_FromLong((long)obj->GetId());
	575	PyList_Insert(pyList, 0, pyObj);
	576	Py_DECREF(pyObj);
	577	}
	578	}
	579	pt = pt->GetNext();
	580	}
	581	maskdc.SelectObject(wxNullBitmap);
	582	memdc.SelectObject(wxNullBitmap);
	583	}
	584	//wxPyEndBlockThreads(blocked);
	585	return pyList;
	586	}
	587
	588	// ----------------------------------------------------------------------------
	589	// DrawToDCClipped - play back the op list to the DC but clip any objects
	590	// known to be not in rect. This is a coarse level of
	591	// clipping to speed things up when lots of objects are off
	592	// screen and doesn't affect the dc level clipping
	593	// ----------------------------------------------------------------------------
	594	void wxPseudoDC::DrawToDCClipped(wxDC *dc, const wxRect& rect)
	595	{
	596	pdcObjectList::Node *pt = m_objectlist.GetFirst();
	597	pdcObject *obj;
	598	while (pt)
	599	{
	600	obj = pt->GetData();
	601	if (!obj->IsBounded() \|\| rect.Intersects(obj->GetBounds()))
	602	obj->DrawToDC(dc);
	603	pt = pt->GetNext();
	604	}
	605	}
	606	void wxPseudoDC::DrawToDCClippedRgn(wxDC *dc, const wxRegion& region)
	607	{
	608	pdcObjectList::Node *pt = m_objectlist.GetFirst();
	609	pdcObject *obj;
	610	while (pt)
	611	{
	612	obj = pt->GetData();
	613	if (!obj->IsBounded() \|\|
	614	(region.Contains(obj->GetBounds()) != wxOutRegion))
	615	obj->DrawToDC(dc);
	616	pt = pt->GetNext();
	617	}
	618	}
	619
	620	// ----------------------------------------------------------------------------
	621	// DrawToDC - play back the op list to the DC
	622	// ----------------------------------------------------------------------------
	623	void wxPseudoDC::DrawToDC(wxDC *dc)
	624	{
	625	pdcObjectList::Node *pt = m_objectlist.GetFirst();
	626	while (pt)
	627	{
	628	pt->GetData()->DrawToDC(dc);
	629	pt = pt->GetNext();
	630	}
	631	}
	632