/*!
* 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 *
PyDiaDiagramData_AddLayer(PyDiaDiagramData *self, PyObject *args)
{
gchar *name;
int pos = -1;
Layer *layer;
if (!PyArg_ParseTuple(args, "s|i:DiagramData.add_layer", &name, &pos))
return NULL;
layer = new_layer(g_strdup(name),self->data);
if (pos != -1)
data_add_layer_at(self->data, layer, pos);
else
data_add_layer(self->data, layer);
return PyDiaLayer_New(layer);
}
/*!
* \brief Render all the visible object in the layer
* @param renderer explicit this pointer
* @param layer layer to draw
* @param active TRUE if it is the currently active layer
* @param update the update rectangle, NULL for unlimited
*
* \memberof _DiaPyRenderer
*/
static void
draw_layer (DiaRenderer *renderer,
Layer *layer,
gboolean active,
Rectangle *update)
{
PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer);
func = PyObject_GetAttrString (self, "draw_layer");
if (func && PyCallable_Check(func)) {
PyObject *olayer = PyDiaLayer_New (layer);
PyObject *orect;
Py_INCREF (self);
Py_INCREF (func);
if (update) {
orect = PyDiaRectangle_New (update, NULL);
} else {
Py_INCREF(Py_None);
orect = Py_None;
}
arg = Py_BuildValue ("(OiO)", olayer, active, orect);
if (arg) {
res = PyEval_CallObject (func, arg);
ON_RES(res, FALSE);
}
Py_XDECREF (olayer);
Py_XDECREF (orect);
Py_DECREF(func);
Py_DECREF(self);
} else { /* member optional */
PyErr_Clear();
/* have to call the base class */
DIA_RENDERER_CLASS (parent_class)->draw_layer (renderer, layer, active, update);
}
}
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);
}
