static PyObject *
curve_segment(SKCurveObject * self, PyObject * args)
{
int idx;
CurveSegment * segment;
PyObject * result, *p1, *p2, *p;
if (!PyArg_ParseTuple(args, "i", &idx))
return NULL;
idx = check_index(self, idx, "path.Segment");
if (idx < 0)
return NULL;
segment = self->segments + idx;
p = SKPoint_FromXY(segment->x, segment->y);
if (segment->type == CurveBezier)
{
p1 = SKPoint_FromXY(segment->x1, segment->y1);
p2 = SKPoint_FromXY(segment->x2, segment->y2);
result = Py_BuildValue("i(OO)Oi", segment->type, p1, p2, p,
segment->cont);
Py_XDECREF(p1);
Py_XDECREF(p2);
}
else
{
result = Py_BuildValue("i()Oi", segment->type, p, segment->cont);
}
Py_XDECREF(p);
return result;
}
/*
* fm.typeset_string(STRING)
*
* Return a list of SKPoint objects, one for each char in STRING,
* indicating the coordinates of the characters origin. The first char
* is set at (0, 0).
*/
static PyObject *
skfm_typeset_string(SKFontMetric * self, PyObject * args)
{
unsigned char * string;
int length, i;
int width = 0;
PyObject * list;
PyObject * point;
if (!PyArg_ParseTuple(args, "s#", &string, &length))
return NULL;
list = PyList_New(length);
if (!list)
return NULL;
for (i = 0; i < length; i++)
{
point = SKPoint_FromXY(width / 1000.0, 0.0);
if (!point)
{
Py_DECREF(list);
return NULL;
}
if (PyList_SetItem(list, i, point) < 0)
{
Py_DECREF(list);
return NULL;
}
width += self->char_metric[string[i]].width;
}
return list;
}
/*
* curve.node_list()
*
* Return all nodes of path as a list of SKPoint objects. For a closed
* curve, the last node is omitted, since it is identical to the first.
*/
static PyObject *
curve_node_list(SKCurveObject * self, PyObject *args)
{
int i, length;
CurveSegment * segment;
PyObject * list, *point;
if (!PyArg_ParseTuple(args, ""))
return NULL;
length = self->len;
if (self->closed)
length -= 1;
list = PyList_New(length);
if (!list)
return NULL;
segment = self->segments;
for (i = 0; i < length; i++, segment++)
{
point = SKPoint_FromXY(segment->x, segment->y);
if (!point)
{
Py_DECREF(list);
return NULL;
}
PyList_SetItem(list, i, point);
}
return list;
}
static PyObject *
sktrafo_call(SKTrafoObject * self, PyObject * args, PyObject * kw)
{
PyObject * arg;
double x, y;
if (PyTuple_Size(args) == 2)
arg = args;
else if (!PyArg_ParseTuple(args, "O", &arg))
return NULL;
if (skpoint_extract_xy(arg, &x, &y))
{
return SKPoint_FromXY(self->m11 * x + self->m12 * y + self->v1,
self->m21 * x + self->m22 * y + self->v2);
}
else if (SKTrafo_Check(arg))
{
register SKTrafoObject * t = (SKTrafoObject *) arg;
return SKTrafo_FromDouble(self->m11 * t->m11 + self->m12 * t->m21,
self->m21 * t->m11 + self->m22 * t->m21,
self->m11 * t->m12 + self->m12 * t->m22,
self->m21 * t->m12 + self->m22 * t->m22,
self->m11*t->v1 + self->m12*t->v2 + self->v1,
self->m21*t->v1 + self->m22*t->v2 +self->v2);
}
else if (SKRect_Check(arg))
{
SKRectObject * result;
register SKRectObject * r = (SKRectObject*)arg;
if (r == SKRect_InfinityRect || r == SKRect_EmptyRect)
{
Py_INCREF(r);
return (PyObject*)r;
}
result = (SKRectObject*) \
SKRect_FromDouble(self->m11 * r->left + self->m12 * r->top,
self->m21 * r->left + self->m22 * r->top,
self->m11 * r->right + self->m12 * r->bottom,
self->m21 * r->right + self->m22 * r->bottom);
if (result)
{
SKRect_AddXY(result, self->m11 * r->right + self->m12 * r->top,
self->m21 * r->right + self->m22 * r->top);
SKRect_AddXY(result, self->m11 * r->left + self->m12 * r->bottom,
self->m21 * r->left + self->m22 * r->bottom);
result->left += self->v1;
result->right += self->v1;
result->top += self->v2;
result->bottom += self->v2;
}
return (PyObject*) result;
}
PyErr_SetString(PyExc_TypeError, "SKTrafo must be applied to SKPoints, "
"SKRects or SKTrafos");
return NULL;
}
/*
* curve.node(IDX)
*
* Return the node at position IDX as an SKPoint object. A negative IDX
* is interpreted like a negative list index in Python.
*/
static PyObject *
curve_node(SKCurveObject * self, PyObject *args)
{
int idx;
if (!PyArg_ParseTuple(args, "i", &idx))
return NULL;
if (idx < 0)
idx = idx + self->len;
if (idx < 0 || idx >= self->len)
{
PyErr_SetString(PyExc_IndexError,
"curve_node: index out of range");
return NULL;
}
return SKPoint_FromXY(self->segments[idx].x, self->segments[idx].y);
}
/* trafo.DTransform(POINT)
*
* Transform POINT as a vector. This means that the translation is not
* applied. (In homogeneous coordinates: if POINT is SKPoint(x, y), treat it as
* (x, y, 0) and not (x, y, 1))
*/
static PyObject *
sktrafo_dtransform(SKTrafoObject * self, PyObject * args)
{
PyObject * arg;
double x, y;
if (PyTuple_Size(args) == 2)
arg = args;
else if (!PyArg_ParseTuple(args, "O", &arg))
return NULL;
if (skpoint_extract_xy(arg, &x, &y))
{
return SKPoint_FromXY(self->m11 * x + self->m12 * y,
self->m21 * x + self->m22 * y);
}
PyErr_SetString(PyExc_TypeError,
"arguments must be either be two numbers, "
"a point or a sequence of two numbers");
return NULL;
}
static PyObject *
sktrafo_offset(SKTrafoObject * self, PyObject * args)
{
return SKPoint_FromXY(self->v1, self->v2);
}
