[wxWidgets.git] / wxPython / src / drawlist.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        drawlist.cpp
// Purpose:     Helper functions for optimized list drawing on a wxDC
//
// Author:      Robin Dunn,  Chris Barker
//
// Created:
// RCS-ID:      $Id$
// Copyright:   (c) 2003 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////


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


//---------------------------------------------------------------------------


// Called from _gdiinit so we can do the API import while the GIL is held
void wxPyDrawList_SetAPIPtr()
{
    wxPyCoreAPI_IMPORT();
}


PyObject* wxPyDrawXXXList(wxDC& dc, wxPyDrawListOp_t doDraw,
                          PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
{
    wxPyBeginBlockThreads(); 

    bool      isFastSeq  = PyList_Check(pyCoords) || PyTuple_Check(pyCoords);
    bool      isFastPens = PyList_Check(pyPens) || PyTuple_Check(pyPens);
    bool      isFastBrushes = PyList_Check(pyBrushes) || PyTuple_Check(pyBrushes);
    int       numObjs = 0;
    int       numPens = 0;
    int       numBrushes = 0;
    wxPen*    pen;
    wxBrush*  brush;
    PyObject* obj;
    PyObject* coords;
    int       i = 0;
    PyObject* retval;

    if (!PySequence_Check(pyCoords)) {
        goto err0;
    }
    if (!PySequence_Check(pyPens)) {
        goto err1;
    }
    if (!PySequence_Check(pyBrushes)) {
        goto err2;
    }
    numObjs = PySequence_Length(pyCoords);
    numPens = PySequence_Length(pyPens);
    numBrushes = PySequence_Length(pyBrushes);
    for (i = 0; i < numObjs; i++) {
        // Use a new pen?
        if (i < numPens) {
            if (isFastPens) {
                obj = PySequence_Fast_GET_ITEM(pyPens, i);
            }
            else {
                obj = PySequence_GetItem(pyPens, i);
            }
            if (! wxPyConvertSwigPtr(obj, (void **) &pen, wxT("wxPen"))) {
                if (!isFastPens)
                    Py_DECREF(obj);
                goto err1;
            }

            dc.SetPen(*pen);
            if (!isFastPens)
                Py_DECREF(obj);
        }
        // Use a new brush?
        if (i < numBrushes) {
            if (isFastBrushes) {
                obj = PySequence_Fast_GET_ITEM(pyBrushes, i);
            }
            else {
                obj = PySequence_GetItem(pyBrushes, i);
            }
            if (!wxPyConvertSwigPtr(obj, (void **) &brush, wxT("wxBrush"))) {
                if (!isFastBrushes)
                    Py_DECREF(obj);
                goto err2;
            }

            dc.SetBrush(*brush);
            if (!isFastBrushes)
                Py_DECREF(obj);
        }

        // Get the Coordinates
        if (isFastSeq) {
            coords = PySequence_Fast_GET_ITEM(pyCoords, i);
        }
        else {
            coords = PySequence_GetItem(pyCoords, i);
        }


        // call the drawOp
        bool success = doDraw(dc, coords);
        if (!isFastSeq)
            Py_DECREF(coords);

        if (! success) {
            retval = NULL;
            goto exit;
        }

    } // end of main for loop

    Py_INCREF(Py_None);
    retval = Py_None;
    goto exit;


 err0:
    PyErr_SetString(PyExc_TypeError, "Expected a sequence of coordinates");
    retval = NULL;
    goto exit;

 err1:
    PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxPens");
    retval = NULL;
    goto exit;

 err2:
    PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxBrushes");
    retval = NULL;
    goto exit;


 exit:
    wxPyEndBlockThreads();
    return retval;
}


bool wxPyDrawXXXPoint(wxDC& dc, PyObject* coords)
{
    int x, y;

    if (! wxPy2int_seq_helper(coords, &x, &y)) {
        PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y) sequences.");
        return False;
    }
    dc.DrawPoint(x, y);
    return True;
}

bool wxPyDrawXXXLine(wxDC& dc, PyObject* coords)
{
    int x1, y1, x2, y2;

    if (! wxPy4int_seq_helper(coords, &x1, &y1, &x2, &y2)) {
        PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x1,y1, x1,y2) sequences.");
        return False;
    }
    dc.DrawLine(x1,y1, x2,y2);
    return True;
}

bool wxPyDrawXXXRectangle(wxDC& dc, PyObject* coords)
{
    int x, y, w, h;

    if (! wxPy4int_seq_helper(coords, &x, &y, &w, &h)) {
        PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y, w,h) sequences.");
        return False;
    }
    dc.DrawRectangle(x, y, w, h);
    return True;
}

bool wxPyDrawXXXEllipse(wxDC& dc, PyObject* coords)
{
    int x, y, w, h;

    if (! wxPy4int_seq_helper(coords, &x, &y, &w, &h)) {
        PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y, w,h) sequences.");
        return False;
    }
    dc.DrawEllipse(x, y, w, h);
    return True;
}


bool wxPyDrawXXXPolygon(wxDC& dc, PyObject* coords)
{
    wxPoint* points;
    int numPoints;

    points = wxPoint_LIST_helper(coords, &numPoints);
    if (! points) {
        PyErr_SetString(PyExc_TypeError, "Expected a sequence of sequences of (x,y) sequences.");
        return False;
    }
    dc.DrawPolygon(numPoints, points);
    return True;
}


//---------------------------------------------------------------------------


PyObject* wxPyDrawTextList(wxDC& dc, PyObject* textList, PyObject* pyPoints, PyObject* foregroundList, PyObject* backgroundList)
{
    wxPyBeginBlockThreads();

    bool      isFastSeq  = PyList_Check(pyPoints) || PyTuple_Check(pyPoints);
    bool      isFastText = PyList_Check(textList) || PyTuple_Check(textList);
    bool      isFastForeground = PyList_Check(foregroundList) || PyTuple_Check(foregroundList);
    bool      isFastBackground = PyList_Check(backgroundList) || PyTuple_Check(backgroundList);
    int       numText = 0;
    int       numPoints = 0;
    int       numForeground = 0;
    int       numBackground = 0;
    PyObject* obj;
    int       x1, y1;
    int       i = 0;
    wxColor*    color;
    PyObject* retval;
    wxString  string;

    if (!PySequence_Check(pyPoints)) {
        goto err0;
    }
    if (!PySequence_Check(textList)) {
        goto err1;
    }
    if (!PySequence_Check(foregroundList)) {
        goto err2;
    }
    if (!PySequence_Check(backgroundList)) {
        goto err3;
    }
    numPoints = PySequence_Length(pyPoints);
    numText = PySequence_Length(textList);
    numForeground = PySequence_Length(foregroundList);
    numBackground = PySequence_Length(backgroundList);

    for (i = 0; i < numPoints; i++) {
        // Use a new string ?
        if (i < numText) {
            if ( isFastText ) {
                obj = PySequence_Fast_GET_ITEM(textList, i);
            }
            else {
                obj = PySequence_GetItem(textList, i);
            }
            if (! PyString_Check(obj) ) {
                Py_DECREF(obj);
                goto err1;
            }
            string = Py2wxString(obj);
            if ( !isFastText )
                Py_DECREF(obj);
        }

        if (i < numForeground) {
            // Use a new foreground ?
            if ( isFastForeground ) {
                obj = PySequence_Fast_GET_ITEM(foregroundList, i);
            }
            else {
                obj = PySequence_GetItem(foregroundList, i);
            }
            if (! wxPyConvertSwigPtr(obj, (void **) &color, wxT("wxColour"))) {
                if (!isFastForeground)
                    Py_DECREF(obj);
                goto err2;
            }
            dc.SetTextForeground(*color);
            if ( !isFastForeground )
                Py_DECREF(obj);
        }

        if (i < numBackground) {
            // Use a new background ?
            if ( isFastBackground ) {
                obj = PySequence_Fast_GET_ITEM(backgroundList, i);
            }
            else {
                obj = PySequence_GetItem(backgroundList, i);
            }
            if (! wxPyConvertSwigPtr(obj, (void **) &color, wxT("wxColour"))) {
                if (!isFastBackground)
                    Py_DECREF(obj);
                goto err3;
            }
            dc.SetTextBackground(*color);
            if ( !isFastBackground )
                Py_DECREF(obj);
        }

        // Get the point coordinates
        if (isFastSeq) {
            obj = PySequence_Fast_GET_ITEM(pyPoints, i);
        }
        else {
            obj = PySequence_GetItem(pyPoints, i);
        }
        if (! wxPy2int_seq_helper(obj, &x1, &y1)) {
            if (! isFastSeq)
                Py_DECREF(obj);
            goto err0;
        }
        if (PyErr_Occurred()) {
            retval = NULL;
            if (!isFastSeq)
                Py_DECREF(obj);
            goto exit;
        }


        // Now draw the text
        dc.DrawText(string, x1, y1);

        if (!isFastText)
            Py_DECREF(obj);
    }

    Py_INCREF(Py_None);
    retval = Py_None;
    goto exit;

 err0:
    PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y) sequences.");
    retval = NULL;
    goto exit;
 err1:
    PyErr_SetString(PyExc_TypeError, "Expected a sequence of strings");
    retval = NULL;
    goto exit;

 err2:
    PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxColours for foregrounds");
    retval = NULL;
    goto exit;

 err3:
    PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxColours for backgrounds");
    retval = NULL;
    goto exit;

 exit:
    wxPyEndBlockThreads();
    return retval;
}


//---------------------------------------------------------------------------
Commit	Line	Data
1e4a197e RD	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: drawlist.cpp
	3	// Purpose: Helper functions for optimized list drawing on a wxDC
	4	//
d14a1e28	5	// Author: Robin Dunn, Chris Barker
1e4a197e RD	6	//
	7	// Created:
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 2003 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13
	14	#undef DEBUG
	15	#include <Python.h>
d14a1e28 RD	16	#include "wx/wxPython/wxPython.h"
d14a1e28 RD	17	#include "wx/wxPython/pydrawxxx.h"
1e4a197e RD	18
1e4a197e RD	19
7722248d	20	//---------------------------------------------------------------------------
1e4a197e RD	21
1e4a197e RD	22
7722248d RD	23	// Called from _gdiinit so we can do the API import while the GIL is held
	24	void wxPyDrawList_SetAPIPtr()
	25	{
	26	wxPyCoreAPI_IMPORT();
	27	}
1e4a197e	28
1e4a197e	29
7722248d RD	30	PyObject* wxPyDrawXXXList(wxDC& dc, wxPyDrawListOp_t doDraw,
	31	PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
	32	{
d14a1e28	33	wxPyBeginBlockThreads();
1e4a197e RD	34
	35	bool isFastSeq = PyList_Check(pyCoords) \|\| PyTuple_Check(pyCoords);
	36	bool isFastPens = PyList_Check(pyPens) \|\| PyTuple_Check(pyPens);
	37	bool isFastBrushes = PyList_Check(pyBrushes) \|\| PyTuple_Check(pyBrushes);
	38	int numObjs = 0;
	39	int numPens = 0;
	40	int numBrushes = 0;
	41	wxPen* pen;
	42	wxBrush* brush;
	43	PyObject* obj;
	44	PyObject* coords;
1e4a197e RD	45	int i = 0;
	46	PyObject* retval;
	47
	48	if (!PySequence_Check(pyCoords)) {
	49	goto err0;
	50	}
	51	if (!PySequence_Check(pyPens)) {
	52	goto err1;
	53	}
	54	if (!PySequence_Check(pyBrushes)) {
	55	goto err2;
	56	}
	57	numObjs = PySequence_Length(pyCoords);
	58	numPens = PySequence_Length(pyPens);
	59	numBrushes = PySequence_Length(pyBrushes);
	60	for (i = 0; i < numObjs; i++) {
	61	// Use a new pen?
	62	if (i < numPens) {
	63	if (isFastPens) {
	64	obj = PySequence_Fast_GET_ITEM(pyPens, i);
	65	}
	66	else {
	67	obj = PySequence_GetItem(pyPens, i);
	68	}
d14a1e28	69	if (! wxPyConvertSwigPtr(obj, (void **) &pen, wxT("wxPen"))) {
1e4a197e RD	70	if (!isFastPens)
	71	Py_DECREF(obj);
	72	goto err1;
	73	}
	74
	75	dc.SetPen(*pen);
	76	if (!isFastPens)
	77	Py_DECREF(obj);
	78	}
	79	// Use a new brush?
	80	if (i < numBrushes) {
	81	if (isFastBrushes) {
	82	obj = PySequence_Fast_GET_ITEM(pyBrushes, i);
	83	}
	84	else {
	85	obj = PySequence_GetItem(pyBrushes, i);
	86	}
d14a1e28	87	if (!wxPyConvertSwigPtr(obj, (void **) &brush, wxT("wxBrush"))) {
1e4a197e RD	88	if (!isFastBrushes)
	89	Py_DECREF(obj);
	90	goto err2;
	91	}
	92
	93	dc.SetBrush(*brush);
	94	if (!isFastBrushes)
	95	Py_DECREF(obj);
	96	}
	97
	98	// Get the Coordinates
	99	if (isFastSeq) {
	100	coords = PySequence_Fast_GET_ITEM(pyCoords, i);
	101	}
	102	else {
	103	coords = PySequence_GetItem(pyCoords, i);
	104	}
	105
	106
	107	// call the drawOp
	108	bool success = doDraw(dc, coords);
	109	if (!isFastSeq)
	110	Py_DECREF(coords);
	111
	112	if (! success) {
	113	retval = NULL;
	114	goto exit;
	115	}
	116
	117	} // end of main for loop
	118
	119	Py_INCREF(Py_None);
	120	retval = Py_None;
	121	goto exit;
	122
	123
	124	err0:
	125	PyErr_SetString(PyExc_TypeError, "Expected a sequence of coordinates");
	126	retval = NULL;
	127	goto exit;
	128
	129	err1:
	130	PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxPens");
	131	retval = NULL;
	132	goto exit;
	133
	134	err2:
	135	PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxBrushes");
	136	retval = NULL;
	137	goto exit;
	138
	139
	140	exit:
	141	wxPyEndBlockThreads();
	142	return retval;
	143	}
	144
	145
	146
7722248d RD	147	bool wxPyDrawXXXPoint(wxDC& dc, PyObject* coords)
7722248d RD	148	{
1e4a197e RD	149	int x, y;
	150
	151	if (! wxPy2int_seq_helper(coords, &x, &y)) {
	152	PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y) sequences.");
dd9f7fea	153	return False;
1e4a197e RD	154	}
1e4a197e RD	155	dc.DrawPoint(x, y);
dd9f7fea	156	return True;
1e4a197e RD	157	}
1e4a197e RD	158
7722248d RD	159	bool wxPyDrawXXXLine(wxDC& dc, PyObject* coords)
7722248d RD	160	{
1e4a197e RD	161	int x1, y1, x2, y2;
	162
	163	if (! wxPy4int_seq_helper(coords, &x1, &y1, &x2, &y2)) {
	164	PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x1,y1, x1,y2) sequences.");
dd9f7fea	165	return False;
1e4a197e RD	166	}
1e4a197e RD	167	dc.DrawLine(x1,y1, x2,y2);
dd9f7fea	168	return True;
1e4a197e RD	169	}
1e4a197e RD	170
7722248d RD	171	bool wxPyDrawXXXRectangle(wxDC& dc, PyObject* coords)
7722248d RD	172	{
1e4a197e RD	173	int x, y, w, h;
	174
	175	if (! wxPy4int_seq_helper(coords, &x, &y, &w, &h)) {
	176	PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y, w,h) sequences.");
dd9f7fea	177	return False;
1e4a197e RD	178	}
1e4a197e RD	179	dc.DrawRectangle(x, y, w, h);
dd9f7fea	180	return True;
1e4a197e RD	181	}
1e4a197e RD	182
7722248d RD	183	bool wxPyDrawXXXEllipse(wxDC& dc, PyObject* coords)
7722248d RD	184	{
1e4a197e RD	185	int x, y, w, h;
	186
	187	if (! wxPy4int_seq_helper(coords, &x, &y, &w, &h)) {
	188	PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y, w,h) sequences.");
dd9f7fea	189	return False;
1e4a197e RD	190	}
1e4a197e RD	191	dc.DrawEllipse(x, y, w, h);
dd9f7fea	192	return True;
1e4a197e RD	193	}
	194
	195
7722248d RD	196	bool wxPyDrawXXXPolygon(wxDC& dc, PyObject* coords)
7722248d RD	197	{
1e4a197e RD	198	wxPoint* points;
	199	int numPoints;
	200
	201	points = wxPoint_LIST_helper(coords, &numPoints);
	202	if (! points) {
	203	PyErr_SetString(PyExc_TypeError, "Expected a sequence of sequences of (x,y) sequences.");
dd9f7fea	204	return False;
1e4a197e RD	205	}
1e4a197e RD	206	dc.DrawPolygon(numPoints, points);
dd9f7fea	207	return True;
1e4a197e RD	208	}
	209
	210
7722248d	211	//---------------------------------------------------------------------------
1e4a197e RD	212
	213
	214
7722248d RD	215	PyObject* wxPyDrawTextList(wxDC& dc, PyObject* textList, PyObject* pyPoints, PyObject* foregroundList, PyObject* backgroundList)
7722248d RD	216	{
1e4a197e RD	217	wxPyBeginBlockThreads();
	218
	219	bool isFastSeq = PyList_Check(pyPoints) \|\| PyTuple_Check(pyPoints);
	220	bool isFastText = PyList_Check(textList) \|\| PyTuple_Check(textList);
	221	bool isFastForeground = PyList_Check(foregroundList) \|\| PyTuple_Check(foregroundList);
	222	bool isFastBackground = PyList_Check(backgroundList) \|\| PyTuple_Check(backgroundList);
	223	int numText = 0;
	224	int numPoints = 0;
	225	int numForeground = 0;
	226	int numBackground = 0;
	227	PyObject* obj;
	228	int x1, y1;
	229	int i = 0;
	230	wxColor* color;
	231	PyObject* retval;
	232	wxString string;
	233
	234	if (!PySequence_Check(pyPoints)) {
	235	goto err0;
	236	}
	237	if (!PySequence_Check(textList)) {
	238	goto err1;
	239	}
	240	if (!PySequence_Check(foregroundList)) {
	241	goto err2;
	242	}
	243	if (!PySequence_Check(backgroundList)) {
	244	goto err3;
	245	}
	246	numPoints = PySequence_Length(pyPoints);
	247	numText = PySequence_Length(textList);
	248	numForeground = PySequence_Length(foregroundList);
	249	numBackground = PySequence_Length(backgroundList);
	250
	251	for (i = 0; i < numPoints; i++) {
	252	// Use a new string ?
	253	if (i < numText) {
	254	if ( isFastText ) {
	255	obj = PySequence_Fast_GET_ITEM(textList, i);
	256	}
	257	else {
	258	obj = PySequence_GetItem(textList, i);
	259	}
	260	if (! PyString_Check(obj) ) {
	261	Py_DECREF(obj);
	262	goto err1;
	263	}
	264	string = Py2wxString(obj);
	265	if ( !isFastText )
	266	Py_DECREF(obj);
	267	}
	268
	269	if (i < numForeground) {
	270	// Use a new foreground ?
	271	if ( isFastForeground ) {
	272	obj = PySequence_Fast_GET_ITEM(foregroundList, i);
	273	}
	274	else {
	275	obj = PySequence_GetItem(foregroundList, i);
	276	}
fd3f2efe	277	if (! wxPyConvertSwigPtr(obj, (void **) &color, wxT("wxColour"))) {
1e4a197e RD	278	if (!isFastForeground)
	279	Py_DECREF(obj);
	280	goto err2;
	281	}
	282	dc.SetTextForeground(*color);
	283	if ( !isFastForeground )
	284	Py_DECREF(obj);
	285	}
	286
	287	if (i < numBackground) {
	288	// Use a new background ?
	289	if ( isFastBackground ) {
	290	obj = PySequence_Fast_GET_ITEM(backgroundList, i);
	291	}
	292	else {
	293	obj = PySequence_GetItem(backgroundList, i);
	294	}
d14a1e28	295	if (! wxPyConvertSwigPtr(obj, (void **) &color, wxT("wxColour"))) {
1e4a197e RD	296	if (!isFastBackground)
	297	Py_DECREF(obj);
	298	goto err3;
	299	}
	300	dc.SetTextBackground(*color);
	301	if ( !isFastBackground )
	302	Py_DECREF(obj);
	303	}
	304
	305	// Get the point coordinates
	306	if (isFastSeq) {
	307	obj = PySequence_Fast_GET_ITEM(pyPoints, i);
	308	}
	309	else {
	310	obj = PySequence_GetItem(pyPoints, i);
	311	}
	312	if (! wxPy2int_seq_helper(obj, &x1, &y1)) {
	313	if (! isFastSeq)
	314	Py_DECREF(obj);
	315	goto err0;
	316	}
	317	if (PyErr_Occurred()) {
	318	retval = NULL;
	319	if (!isFastSeq)
	320	Py_DECREF(obj);
	321	goto exit;
	322	}
	323
	324
	325	// Now draw the text
	326	dc.DrawText(string, x1, y1);
	327
	328	if (!isFastText)
	329	Py_DECREF(obj);
	330	}
	331
	332	Py_INCREF(Py_None);
	333	retval = Py_None;
	334	goto exit;
	335
	336	err0:
	337	PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y) sequences.");
	338	retval = NULL;
	339	goto exit;
	340	err1:
	341	PyErr_SetString(PyExc_TypeError, "Expected a sequence of strings");
	342	retval = NULL;
	343	goto exit;
	344
	345	err2:
	346	PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxColours for foregrounds");
	347	retval = NULL;
	348	goto exit;
	349
	350	err3:
	351	PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxColours for backgrounds");
	352	retval = NULL;
	353	goto exit;
	354
	355	exit:
	356	wxPyEndBlockThreads();
	357	return retval;
	358	}
	359
360
361
7722248d	362	//---------------------------------------------------------------------------