plug-ins/python/pydia-layer.c

   1 /* -*- Mode: C; c-basic-offset: 4 -*- */
   2 /* Python plug-in for dia
   3  * Copyright (C) 1999  James Henstridge
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include <config.h>
  21
  22 #include <glib.h>
  23
  24 #include "pydia-layer.h"
  25 #include "pydia-object.h"
  26 #include "pydia-cpoint.h"
  27
  28 PyObject *
  29 PyDiaLayer_New(Layer *layer)
  30 {
  31     PyDiaLayer *self;
  32
  33     self = PyObject_NEW(PyDiaLayer, &PyDiaLayer_Type);
  34
  35     if (!self) return NULL;
  36     self->layer = layer;
  37     return (PyObject *)self;
  38 }
  39
  40 static void
  41 PyDiaLayer_Dealloc(PyDiaLayer *self)
  42 {
  43      PyMem_DEL(self);
  44 }
  45
  46 static int
  47 PyDiaLayer_Compare(PyDiaLayer *self, PyDiaLayer *other)
  48 {
  49     if (self->layer == other->layer) return 0;
  50     if (self->layer > other->layer) return -1;
  51     return 1;
  52 }
  53
  54 static long
  55 PyDiaLayer_Hash(PyDiaLayer *self)
  56 {
  57     return (long)self->layer;
  58 }
  59
  60 static PyObject *
  61 PyDiaLayer_Str(PyDiaLayer *self)
  62 {
  63     return PyString_FromString(self->layer->name);
  64 }
  65
  66 /* methods here */
  67
  68 static PyObject *
  69 PyDiaLayer_Destroy(PyDiaLayer *self, PyObject *args)
  70 {
  71     if (!PyArg_ParseTuple(args, ":DiaLayer.destroy"))
  72         return NULL;
  73     layer_destroy(self->layer);
  74     self->layer = NULL; /* we need some error checking elsewhere */
  75     Py_INCREF(Py_None);
  76     return Py_None;
  77 }
  78
  79 static PyObject *
  80 PyDiaLayer_ObjectIndex(PyDiaLayer *self, PyObject *args)
  81 {
  82     PyDiaObject *obj;
  83
  84     if (!PyArg_ParseTuple(args, "O!:DiaLayer.object_index",
  85                           &PyDiaObject_Type, &obj))
  86         return NULL;
  87     return PyInt_FromLong(layer_object_index(self->layer, obj->object));
  88 }
  89
  90 static PyObject *
  91 PyDiaLayer_AddObject(PyDiaLayer *self, PyObject *args)
  92 {
  93     PyDiaObject *obj;
  94     int pos = -1;
  95
  96     if (!PyArg_ParseTuple(args, "O!|i:DiaLayer.add_object",
  97                           &PyDiaObject_Type, &obj,
  98                           &pos))
  99         return NULL;
 100     if (pos != -1)
 101         layer_add_object_at(self->layer, obj->object, pos);
 102     else
 103         layer_add_object(self->layer, obj->object);
 104     Py_INCREF(Py_None);
 105     return Py_None;
 106 }
 107
 108 static PyObject *
 109 PyDiaLayer_RemoveObject(PyDiaLayer *self, PyObject *args)
 110 {
 111     PyDiaObject *obj;
 112
 113     if (!PyArg_ParseTuple(args, "O!:DiaLayer.remove_object",
 114                           &PyDiaObject_Type, &obj))
 115         return NULL;
 116     layer_remove_object(self->layer, obj->object);
 117     Py_INCREF(Py_None);
 118     return Py_None;
 119 }
 120
 121 static PyObject *
 122 PyDiaLayer_FindObjectsInRectangle(PyDiaLayer *self, PyObject *args)
 123 {
 124     Rectangle rect;
 125     GList *list, *tmp;
 126     PyObject *ret;
 127
 128     if (!PyArg_ParseTuple(args, "dddd:DiaLayer.find_objects_in_rectange",
 129                           &rect.top, &rect.left, &rect.bottom, &rect.right))
 130         return NULL;
 131     list = layer_find_objects_in_rectangle(self->layer, &rect);
 132     ret = PyList_New(0);
 133     for (tmp = list; tmp; tmp = tmp->next)
 134         PyList_Append(ret, PyDiaObject_New((Object *)tmp->data));
 135     g_list_free(list);
 136     return ret;
 137 }
 138
 139 static PyObject *
 140 PyDiaLayer_FindClosestObject(PyDiaLayer *self, PyObject *args)
 141 {
 142     Point pos;
 143     real maxdist;
 144     Object *obj;
 145
 146     if (!PyArg_ParseTuple(args, "ddd:DiaLayer.find_closest_object",
 147                           &pos.x, &pos.y, &maxdist))
 148         return NULL;
 149     obj = layer_find_closest_object(self->layer, &pos, maxdist);
 150     if (obj)
 151         return PyDiaObject_New(obj);
 152     Py_INCREF(Py_None);
 153     return Py_None;
 154 }
 155
 156 static PyObject *
 157 PyDiaLayer_FindClosestConnectionPoint(PyDiaLayer *self, PyObject *args)
 158 {
 159     ConnectionPoint *cpoint = NULL;
 160     Point pos;
 161     real dist;
 162     PyObject *ret;
 163
 164     if (!PyArg_ParseTuple(args, "dd:DiaLayer.find_closest_connection_point",
 165                           &pos.x, &pos.y))
 166         return NULL;
 167     dist = layer_find_closest_connectionpoint(self->layer, &cpoint, &pos, NULL);
 168
 169     ret = PyTuple_New(2);
 170     PyTuple_SetItem(ret, 0, PyFloat_FromDouble(dist));
 171     if (cpoint)
 172         PyTuple_SetItem(ret, 1, PyDiaConnectionPoint_New(cpoint));
 173     else {
 174         Py_INCREF(Py_None);
 175         PyTuple_SetItem(ret, 1, Py_None);
 176     }
 177     return ret;
 178 }
 179
 180 static PyObject *
 181 PyDiaLayer_UpdateExtents(PyDiaLayer *self, PyObject *args)
 182 {
 183     if (!PyArg_ParseTuple(args, ":DiaLayer.update_extents"))
 184         return NULL;
 185     return PyInt_FromLong(layer_update_extents(self->layer));
 186 }
 187
 188 /* missing functions:
 189  *  layer_add_objects
 190  *  layer_add_objects_first
 191  *  layer_remove_objects
 192  *  layer_replace_object_with_list
 193  *  layer_set_object_list
 194  *
 195  *  layer_render ???
 196  */
 197
 198 static PyMethodDef PyDiaLayer_Methods[] = {
 199     {"destroy", (PyCFunction)PyDiaLayer_Destroy, 1},
 200     {"object_index", (PyCFunction)PyDiaLayer_ObjectIndex, 1},
 201     {"add_object", (PyCFunction)PyDiaLayer_AddObject, 1},
 202     {"remove_object", (PyCFunction)PyDiaLayer_RemoveObject, 1},
 203     {"find_objects_in_rectangle",
 204      (PyCFunction)PyDiaLayer_FindObjectsInRectangle, 1},
 205     {"find_closest_object", (PyCFunction)PyDiaLayer_FindClosestObject, 1},
 206     {"find_closest_connection_point",
 207      (PyCFunction)PyDiaLayer_FindClosestConnectionPoint, 1},
 208     {"update_extents", (PyCFunction)PyDiaLayer_UpdateExtents, 1},
 209     {NULL, 0, 0, NULL}
 210 };
 211
 212 static PyObject *
 213 PyDiaLayer_GetAttr(PyDiaLayer *self, gchar *attr)
 214 {
 215     if (!strcmp(attr, "__members__"))
 216         return Py_BuildValue("[ssss]", "extents", "name", "objects",
 217                              "visible");
 218     else if (!strcmp(attr, "name"))
 219         return PyString_FromString(self->layer->name);
 220     else if (!strcmp(attr, "extents"))
 221         return Py_BuildValue("(dddd)", self->layer->extents.top,
 222                              self->layer->extents.left,
 223                              self->layer->extents.bottom,
 224                              self->layer->extents.right);
 225     else if (!strcmp(attr, "objects")) {
 226         PyObject *ret;
 227         GList *tmp;
 228         gint i;
 229
 230         ret = PyTuple_New(g_list_length(self->layer->objects));
 231         for (i = 0, tmp = self->layer->objects; tmp; i++, tmp = tmp->next)
 232             PyTuple_SetItem(ret, i, PyDiaObject_New((Object *)tmp->data));
 233         return ret;
 234     } else if (!strcmp(attr, "visible"))
 235         return PyInt_FromLong(self->layer->visible);
 236
 237     return Py_FindMethod(PyDiaLayer_Methods, (PyObject *)self, attr);
 238 }
 239
 240 PyTypeObject PyDiaLayer_Type = {
 241     PyObject_HEAD_INIT(&PyType_Type)
 242     0,
 243     "DiaLayer",
 244     sizeof(PyDiaLayer),
 245     0,
 246     (destructor)PyDiaLayer_Dealloc,
 247     (printfunc)0,
 248     (getattrfunc)PyDiaLayer_GetAttr,
 249     (setattrfunc)0,
 250     (cmpfunc)PyDiaLayer_Compare,
 251     (reprfunc)0,
 252     0,
 253     0,
 254     0,
 255     (hashfunc)PyDiaLayer_Hash,
 256     (ternaryfunc)0,
 257     (reprfunc)PyDiaLayer_Str,
 258     0L,0L,0L,0L,
 259     NULL
 260 };