/*!
* \brief Draw object
*
* Optional on the PyDia side. If not implemented the base class method
* will be called.
*
* Intercepting this method on the Python side allows to create per
* object information in the drawing. It is also necessary if the PyDia
* renderer should support transformations.
*
* If implementing a drawing export filter and overwriting draw_object()
* the following code shall be used. Otherwise no draw/fill method will
* be called at all.
*
* \code
# don't forget to render the object
object.draw (self)
* \endcode
*
* Not calling the object draw method is only useful when a non-drawing
* export - e.g. code generation \sa codegen.py - is implemented.
*
* @param renderer Self
* @param object The object to draw
* @param matrix The transformation matrix to use or NULL for no transformation
*
* \memberof _DiaPyRenderer
*/
static void
draw_object (DiaRenderer *renderer, DiaObject *object, DiaMatrix *matrix)
{
PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer);
func = PyObject_GetAttrString (self, "draw_object");
if (func && PyCallable_Check(func)) {
PyObject *oobj = PyDiaObject_New (object);
PyObject *mat = NULL;
Py_INCREF(self);
Py_INCREF(func);
if (matrix)
mat = PyDiaMatrix_New (matrix);
else {
Py_INCREF(Py_None);
mat = Py_None;
}
arg = Py_BuildValue ("(OO)", oobj, mat);
if (arg) {
res = PyEval_CallObject (func, arg);
ON_RES(res, FALSE);
}
Py_XDECREF (arg);
Py_XDECREF (oobj);
Py_XDECREF (mat);
Py_DECREF(func);
Py_DECREF(self);
} else { /* member optional */
PyErr_Clear();
/* but should still call the base class */
DIA_RENDERER_CLASS (parent_class)->draw_object (renderer, object, matrix);
}
}
static PyObject *
PyDiaDiagram_FindClosestHandle(PyDiaDiagram *self, PyObject *args)
{
Point p;
double dist;
Handle *handle;
DiaObject *obj;
PyObject *ret;
if (!PyArg_ParseTuple(args, "dd:Diagram.find_closest_handle",
&p.x, &p.y))
return NULL;
dist = diagram_find_closest_handle(self->dia, &handle, &obj, &p);
ret = PyTuple_New(3);
PyTuple_SetItem(ret, 0, PyFloat_FromDouble(dist));
if (handle)
PyTuple_SetItem(ret, 1, PyDiaHandle_New(handle, obj));
else {
Py_INCREF(Py_None);
PyTuple_SetItem(ret, 1, Py_None);
}
if (obj)
PyTuple_SetItem(ret, 1, PyDiaObject_New(obj));
else {
Py_INCREF(Py_None);
PyTuple_SetItem(ret, 1, Py_None);
}
return ret;
}
/*!
* Callback for "object_add" and "object_remove "signal, used by the connect_after method,
* it's a proxy for the python function, creating the values it needs.
* Params are those of the signals on the Diagram object.
* @param dia The DiagramData that emitted the signal
* @param layer The Layer that the object is removed or added to.
* @param obj The DiaObject that the signal is about.
* @param user_data The python function to be called by the callback.
*/
static void
PyDiaDiagramData_CallbackObject(DiagramData *dia,Layer *layer,DiaObject *obj,void *user_data)
{
PyObject *pydata,*pylayer,*pyobj,*res,*arg;
PyObject *func = user_data;
/* Check that we got a function */
if (!func || !PyCallable_Check (func)) {
g_warning ("Callback called without valid callback function.");
return;
}
/* Create a new PyDiaDiagramData object.
*/
if (dia)
pydata = PyDiaDiagramData_New (dia);
else {
pydata = Py_None;
Py_INCREF (pydata);
}
/*
* Create PyDiaLayer
*/
if (layer)
pylayer = PyDiaLayer_New (layer);
else {
pylayer = Py_None;
Py_INCREF (pylayer);
}
/*
* Create PyDiaObject
*/
if (layer)
pyobj = PyDiaObject_New (obj);
else {
pyobj = Py_None;
Py_INCREF (pyobj);
}
Py_INCREF(func);
/* Call the callback. */
arg = Py_BuildValue ("(OOO)", pydata,pylayer,pyobj);
if (arg) {
res = PyEval_CallObject (func, arg);
ON_RES(res, FALSE);
}
/* Cleanup */
Py_XDECREF (arg);
Py_DECREF(func);
Py_XDECREF(pydata);
Py_XDECREF(pylayer);
Py_XDECREF(pyobj);
}
static PyObject *
PyDiaDiagram_FindClickedObject(PyDiaDiagram *self, PyObject *args)
{
Point p;
double dist;
DiaObject *obj;
if (!PyArg_ParseTuple(args, "(dd)d:Diagram.find_clicked_object",
&p.x, &p.y, &dist))
return NULL;
obj = diagram_find_clicked_object(self->dia, &p, dist);
if (obj)
return PyDiaObject_New(obj);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
PyDiaDiagram_GetSortedSelectedRemove(PyDiaDiagram *self, PyObject *args)
{
GList *list, *tmp;
PyObject *ret;
guint i, len;
if (!PyArg_ParseTuple(args, ":Diagram.get_sorted_selected_remove"))
return NULL;
list = diagram_get_sorted_selected_remove(self->dia);
len = g_list_length (list);
ret = PyTuple_New(len);
for (i = 0, tmp = list; tmp; i++, tmp = tmp->next)
PyTuple_SetItem(ret, i, PyDiaObject_New((DiaObject *)tmp->data));
g_list_free(list);
return ret;
}
static PyObject *
PyDiaObject_Copy(PyDiaObject *self, PyObject *args)
{
DiaObject *cp;
if (!PyArg_ParseTuple(args, ":Object.copy"))
return NULL;
if (!self->object->ops->copy) {
PyErr_SetString(PyExc_RuntimeError,"object does not implement method");
return NULL;
}
cp = self->object->ops->copy(self->object);
if (cp)
return PyDiaObject_New(cp);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
PyDiaObjectType_Create(PyDiaObjectType *self, PyObject *args)
{
Point p;
gint data = 0;
gpointer user_data;
DiaObject *ret;
Handle *h1 = NULL, *h2 = NULL;
PyObject *pyret;
if (!PyArg_ParseTuple(args, "dd|i:ObjectType.create", &p.x,&p.y, &data))
return NULL;
user_data = GINT_TO_POINTER(data);
if (!self->otype->ops) {
PyErr_SetString(PyExc_RuntimeError, "Type has no ops!?");
return NULL;
}
ret = self->otype->ops->create(&p,
user_data ? user_data : self->otype->default_user_data, &h1, &h2);
if (!ret) {
PyErr_SetString(PyExc_RuntimeError, "could not create new object");
return NULL;
}
pyret = PyTuple_New(3);
PyTuple_SetItem(pyret, 0, PyDiaObject_New(ret));
if (h1)
PyTuple_SetItem(pyret, 1, PyDiaHandle_New(h1, ret));
else {
Py_INCREF(Py_None);
PyTuple_SetItem(pyret, 1, Py_None);
}
if (h2)
PyTuple_SetItem(pyret, 2, PyDiaHandle_New(h2, ret));
else {
Py_INCREF(Py_None);
PyTuple_SetItem(pyret, 2, Py_None);
}
return pyret;
}
static PyObject *
PyDiaObject_GetAttr(PyDiaObject *self, gchar *attr)
{
if (!strcmp(attr, "__members__"))
return Py_BuildValue("[sssss]", "bounding_box", "connections",
"handles", "parent", "properties", "type");
else if (!strcmp(attr, "type"))
return PyDiaObjectType_New(self->object->type);
else if (!strcmp(attr, "bounding_box"))
return PyDiaRectangle_New(&(self->object->bounding_box), NULL);
else if (!strcmp(attr, "handles")) {
int i;
PyObject *ret = PyTuple_New(self->object->num_handles);
for (i = 0; i < self->object->num_handles; i++)
PyTuple_SetItem(ret, i, PyDiaHandle_New(self->object->handles[i], self->object));
return ret;
} else if (!strcmp(attr, "connections")) {
int i;
PyObject *ret = PyTuple_New(self->object->num_connections);
for (i = 0; i < self->object->num_connections; i++)
PyTuple_SetItem(ret, i, PyDiaConnectionPoint_New(
self->object->connections[i]));
return ret;
} else if (!strcmp(attr, "properties")) {
return PyDiaProperties_New(self->object);
} else if (!strcmp(attr, "parent")) {
if (!self->object->parent) {
Py_INCREF(Py_None);
return Py_None;
} else {
return PyDiaObject_New(self->object->parent);
}
}
return Py_FindMethod(PyDiaObject_Methods, (PyObject *)self, attr);
}
static PyObject *
PyDiaDiagram_GetAttr(PyDiaDiagram *self, gchar *attr)
{
if (!strcmp(attr, "__members__"))
return Py_BuildValue("[sssss]",
"data", "displays", "filename",
"modified", "selected", "unsaved");
else if (!strcmp(attr, "data"))
return PyDiaDiagramData_New (self->dia->data);
else if (!strcmp(attr, "filename"))
return PyString_FromString(self->dia->filename);
else if (!strcmp(attr, "unsaved"))
return PyInt_FromLong(self->dia->unsaved);
else if (!strcmp(attr, "modified"))
return PyInt_FromLong(diagram_is_modified(self->dia));
else if (!strcmp(attr, "selected")) {
guint i, len = g_list_length (self->dia->data->selected);
PyObject *ret = PyTuple_New(len);
GList *tmp;
for (i = 0, tmp = self->dia->data->selected; tmp; i++, tmp = tmp->next)
PyTuple_SetItem(ret, i, PyDiaObject_New((DiaObject *)tmp->data));
return ret;
} else if (!strcmp(attr, "displays")) {
PyObject *ret;
GSList *tmp;
gint i;
ret = PyTuple_New(g_slist_length(self->dia->displays));
for (i = 0, tmp = self->dia->displays; tmp; i++, tmp = tmp->next)
PyTuple_SetItem(ret, i, PyDiaDisplay_New((DDisplay *)tmp->data));
return ret;
}
return Py_FindMethod(PyDiaDiagram_Methods, (PyObject *)self, attr);
}
static PyObject *
PyDiaDiagramData_GetAttr(PyDiaDiagramData *self, gchar *attr)
{
Diagram *diagram = DIA_DIAGRAM(self->data);
if (!strcmp(attr, "__members__"))
return Py_BuildValue("[ssssssssssss]",
"extents", "bg_color", "paper",
"layers", "active_layer",
"grid_width", "grid_visible",
"hguides", "vguides",
"layers", "active_layer",
"selected" );
else if (!strcmp(attr, "extents"))
return PyDiaRectangle_New(&self->data->extents, NULL);
else if (!strcmp(attr, "bg_color")) {
return PyDiaColor_New (&(self->data->bg_color));
}
else if (!strcmp(attr, "layers")) {
guint i, len = self->data->layers->len;
PyObject *ret = PyTuple_New(len);
for (i = 0; i < len; i++)
PyTuple_SetItem(ret, i, PyDiaLayer_New(
g_ptr_array_index(self->data->layers, i)));
return ret;
} else if (!strcmp(attr, "active_layer")) {
return PyDiaLayer_New(self->data->active_layer);
} else if (!strcmp(attr, "paper")) {
return PyDiaPaperinfo_New (&self->data->paper);
}
else if (diagram && !strcmp(attr, "grid_width"))
return Py_BuildValue("(dd)", diagram->grid.width_x, diagram->grid.width_y);
else if (diagram && !strcmp(attr, "grid_visible"))
return Py_BuildValue("(ii)", diagram->grid.visible_x, diagram->grid.visible_y);
else if (diagram && !strcmp(attr, "hguides")) {
int len = diagram->guides.nhguides;
PyObject *ret = PyTuple_New(len);
int i;
for (i = 0; i < len; i++)
PyTuple_SetItem(ret, i, PyFloat_FromDouble(diagram->guides.hguides[i]));
return ret;
}
else if (diagram && !strcmp(attr, "vguides")) {
int len = diagram->guides.nvguides;
PyObject *ret = PyTuple_New(len);
int i;
for (i = 0; i < len; i++)
PyTuple_SetItem(ret, i, PyFloat_FromDouble(diagram->guides.vguides[i]));
return ret;
}
else if (!strcmp(attr, "layers")) {
guint i, len = self->data->layers->len;
PyObject *ret = PyTuple_New(len);
for (i = 0; i < len; i++)
PyTuple_SetItem(ret, i, PyDiaLayer_New(
g_ptr_array_index(self->data->layers, i)));
return ret;
}
else if (!strcmp(attr, "active_layer")) {
return PyDiaLayer_New(self->data->active_layer);
}
else if (!strcmp(attr, "selected")) {
PyObject *ret;
GList *tmp;
gint i;
ret = PyTuple_New(g_list_length(self->data->selected));
for (i = 0, tmp = self->data->selected; tmp; i++, tmp = tmp->next)
PyTuple_SetItem(ret, i, PyDiaObject_New((DiaObject *)tmp->data));
return ret;
}
return Py_FindMethod(PyDiaDiagramData_Methods, (PyObject *)self, attr);
}
