gnttree.override

   1 /**
   2  * pygnt- Python bindings for the GNT toolkit.
   3  * Copyright (C) 2007 Sadrul Habib Chowdhury <sadrul@pidgin.im>
   4  *
   5  *   gnttree.override: overrides for the tree widget.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301
  20  * USA
  21  */
  22 %%
  23 headers
  24 #include "common.h"
  25 %%
  26 ignore
  27 gnt_tree_create_row
  28 gnt_tree_create_row_from_list
  29 gnt_tree_new_with_columns
  30 gnt_tree_add_row_last
  31 %%
  32 override gnt_tree_new
  33 static void
  34 deref_key(gpointer data)
  35 {
  36         Py_DECREF((PyGObject*)data);
  37 }
  38
  39 static int
  40 _wrap_gnt_tree_new(PyGObject *self, PyObject *args, PyObject *kwargs)
  41 {
  42         static char* kwlist[] = { NULL };
  43
  44         if (!PyArg_ParseTupleAndKeywords(args, kwargs,
  45                                 ":gnt.Tree.__init__",
  46                                 kwlist))
  47                 return -1;
  48
  49         pygobject_constructv(self, 0, NULL);
  50         if (!self->obj) {
  51                 PyErr_SetString(
  52                                 PyExc_RuntimeError,
  53                                 "could not create gnt.Tree object");
  54                 return -1;
  55         }
  56         g_object_set(G_OBJECT(self->obj), "columns", 1, NULL);
  57         gnt_tree_set_hash_fns(GNT_TREE(self->obj), g_direct_hash, g_direct_equal, deref_key);
  58         return 0;
  59 }
  60 %%
  61 override gnt_tree_get_selection_text_list noargs
  62 static PyObject *
  63 _wrap_gnt_tree_get_selection_text_list(PyGObject *self)
  64 {
  65         GList *list = gnt_tree_get_selection_text_list(GNT_TREE(self->obj));
  66         return create_pyobject_from_string_list(list);
  67 }
  68 %%
  69 override gnt_tree_get_rows noargs
  70 static PyObject *
  71 _wrap_gnt_tree_get_rows(PyGObject *self)
  72 {
  73         GList *list = gnt_tree_get_rows(GNT_TREE(self->obj));
  74         PyObject *py_list;
  75         if (list == NULL) {
  76                 Py_INCREF(Py_None);
  77                 return Py_None;
  78         }
  79         if ((py_list = PyList_New(0)) == NULL) {
  80                 return NULL;
  81         }
  82         while (list) {
  83                 PyObject *obj = list->data;
  84                 PyList_Append(py_list, obj);
  85                 list = list->next;
  86         }
  87         return py_list;
  88 }
  89 %%
  90 override gnt_tree_add_row_after
  91 static PyObject *
  92 _wrap_gnt_tree_add_row_after(PyGObject *self, PyObject *args)
  93 {
  94         static char *kwlist[] = {"key", "row", "parent", "bigbro", NULL};
  95         PyObject *py_list;
  96         gpointer key, parent, bigbro = NULL;
  97         int len, i;
  98         GList *list = NULL;
  99         GntTreeRow *row;
 100         gboolean insert_last = FALSE;
 101         int choice = FALSE;
 102
 103         if (!PyArg_ParseTuple(args,
 104                                 "O!OO|Oi:GntTree.add_row_after",
 105                                 &PyGObject_Type, &key,
 106                                 &py_list,
 107                                 &parent,
 108                                 &bigbro, &choice))
 109                 return NULL;
 110
 111         len = PySequence_Length(py_list);
 112         for (i = 0; i < len; i++) {
 113                 PyObject *item = PySequence_GetItem(py_list, i);
 114                 if (!pygobject_check(item, &PyString_Type)) {
 115                         PyErr_SetString(PyExc_TypeError,
 116                                         "column_list members must be strings");
 117                         Py_DECREF(item);
 118                         return NULL;
 119                 }
 120                 list = g_list_prepend(list, PyString_AsString(item));
 121                 Py_DECREF(item);
 122         }
 123
 124         if (parent == Py_None)
 125                 parent = NULL;
 126         if (bigbro == Py_None)
 127                 bigbro = NULL;
 128         else if (bigbro == NULL)
 129                 insert_last = TRUE;
 130
 131         list = g_list_reverse(list);
 132         row = gnt_tree_create_row_from_list(GNT_TREE(self->obj), list);
 133         if (insert_last) {
 134                 gnt_tree_add_row_last(GNT_TREE(self->obj),
 135                                 key, row, parent);
 136         } else {
 137                 if (choice)
 138                         gnt_tree_add_choice(GNT_TREE(self->obj), key, row, parent, bigbro);
 139                 else
 140                         gnt_tree_add_row_after(GNT_TREE(self->obj),
 141                                         key, row,
 142                                         parent, bigbro);
 143         }
 144         Py_INCREF((PyGObject*)key);
 145         g_list_free(list);
 146
 147         Py_INCREF(Py_None);
 148         return Py_None;
 149 }
 150 %%
 151 override gnt_tree_get_selection_data noargs
 152 static PyObject *
 153 _wrap_gnt_tree_get_selection_data(PyGObject *self)
 154 {
 155         PyObject *ret = gnt_tree_get_selection_data(GNT_TREE(self->obj));
 156         if (!ret)
 157                 ret = Py_None;
 158         Py_INCREF(ret);
 159         return ret;
 160 }
 161 %%
 162 override gnt_tree_set_choice kwargs
 163 static PyObject *
 164 _wrap_gnt_tree_set_choice(PyGObject *self, PyObject *args, PyObject *kwargs)
 165 {
 166         gpointer key;
 167         int choice;
 168         if (!PyArg_ParseTuple(args, "O!i:GntTree.set_choice", &PyGObject_Type, &key, &choice)) {
 169                 return NULL;
 170         }
 171         gnt_tree_set_choice(GNT_TREE(self->obj), key, choice);
 172         Py_INCREF(Py_None);
 173         return Py_None;
 174 }
 175 %%
 176 override gnt_tree_get_choice kwargs
 177 static PyObject *
 178 _wrap_gnt_tree_get_choice(PyGObject *self, PyObject *args, PyObject *kwargs)
 179 {
 180         gpointer key;
 181         gboolean choice;
 182         if (!PyArg_ParseTuple(args, "O!:GntTree.get_choice", &PyGObject_Type, &key)) {
 183                 return NULL;
 184         }
 185         choice = gnt_tree_get_choice(GNT_TREE(self->obj), key);
 186         return PyBool_FromLong(choice);
 187 }
 188 %%
 189 override gnt_tree_change_text kwargs
 190 static PyObject *
 191 _wrap_gnt_tree_change_text(PyGObject *self, PyObject *args, PyObject *kwargs)
 192 {
 193         static char *kwlist[] = { "key", "colno", "text", NULL };
 194         char *text;
 195         int colno;
 196         gpointer key;
 197
 198         if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!is:GntTree.change_text", kwlist, &PyGObject_Type, &key, &colno, &text))
 199                 return NULL;
 200
 201         gnt_tree_change_text(GNT_TREE(self->obj), key, colno, text);
 202
 203         Py_INCREF(Py_None);
 204         return Py_None;
 205 }
 206 %%
 207 override gnt_tree_set_row_color kwargs
 208 static PyObject *
 209 _wrap_gnt_tree_set_row_color(PyGObject *self, PyObject *args, PyObject *kwargs)
 210 {
 211         static char *kwlist[] = { "key", "color", NULL };
 212         gpointer key;
 213         int color;
 214
 215         if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!i:GntTree.set_row_color", kwlist, &PyGObject_Type, &key, &color))
 216                 return NULL;
 217
 218         gnt_tree_set_row_color(GNT_TREE(self->obj), key, color);
 219
 220         Py_INCREF(Py_None);
 221         return Py_None;
 222 }
 223 %%
 224 override gnt_tree_set_row_flags kwargs
 225 static PyObject *
 226 _wrap_gnt_tree_set_row_flags(PyGObject *self, PyObject *args, PyObject *kwargs)
 227 {
 228         static char *kwlist[] = { "key", "flag", NULL };
 229         int flag;
 230         gpointer key;
 231
 232         if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!i:GntTree.set_row_flags", kwlist, &PyGObject_Type, &key, &flag))
 233                 return NULL;
 234
 235         gnt_tree_set_row_flags(GNT_TREE(self->obj), key, flag);
 236
 237         Py_INCREF(Py_None);
 238         return Py_None;
 239 }
 240 %%
 241 override gnt_tree_remove kwargs
 242 static PyObject *
 243 _wrap_gnt_tree_remove(PyGObject *self, PyObject *args, PyObject *kwargs)
 244 {
 245         static char *kwlist[] = { "key", NULL };
 246         gpointer key;
 247
 248         if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:GntTree.remove", kwlist, &PyGObject_Type, &key))
 249                 return NULL;
 250
 251         gnt_tree_remove(GNT_TREE(self->obj), key);
 252
 253         Py_INCREF(Py_None);
 254         return Py_None;
 255 }
 256 %%
 257 override gnt_tree_sort_siblings kwargs
 258 static PyObject *
 259 _wrap_gnt_tree_sort_siblings(PyGObject *self, PyObject *args, PyObject *kwargs)
 260 {
 261         static char *kwlist[] = { "key", NULL };
 262         gpointer key;
 263
 264         if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:GntTree.sort_siblings", kwlist, &PyGObject_Type, &key))
 265                 return NULL;
 266
 267         gnt_tree_sort_siblings(GNT_TREE(self->obj), key);
 268
 269         Py_INCREF(Py_None);
 270         return Py_None;
 271 }
 272 %%
 273 override gnt_tree_set_selected
 274 static PyObject *
 275 _wrap_gnt_tree_set_selected(PyGObject *self, PyObject *args)
 276 {
 277         gpointer key;
 278         if (!PyArg_ParseTuple(args, "O!:GntTree.set_selected", &PyGObject_Type, &key)) {
 279                 return NULL;
 280         }
 281         gnt_tree_set_selected(GNT_TREE(self->obj), key);
 282         Py_INCREF(Py_None);
 283         return Py_None;
 284 }
 285 %%
 286 override gnt_tree_set_expanded
 287 static PyObject *
 288 _wrap_gnt_tree_set_expanded(PyGObject *self, PyObject *args)
 289 {
 290         gpointer key;
 291         int expanded;
 292         if (!PyArg_ParseTuple(args, "O!i:GntTree.set_expanded", &PyGObject_Type, &key, &expanded)) {
 293                 return NULL;
 294         }
 295         gnt_tree_set_expanded(GNT_TREE(self->obj), key, expanded);
 296         Py_INCREF(Py_None);
 297         return Py_None;
 298 }
 299 %%
 300 ignore gnt_tree_set_compare_func
 301 %%
 302 define GntTree.enable_sort noargs
 303
 304 /**
 305   Both p1 and p2 are expected to be GObjects, with a 'compare_func' property.
 306  */
 307 static int
 308 custom_compare_func(gconstpointer p1, gconstpointer p2)
 309 {
 310         PyObject *compare_func;
 311         PyObject *ret, *params;
 312         const PyGObject *o1, *o2;
 313         int retval;
 314         PyTypeObject *class;
 315
 316         o1 = p1;
 317         o2 = p2;
 318
 319         g_return_val_if_fail(G_IS_OBJECT(o1->obj), -1);
 320         g_return_val_if_fail(G_IS_OBJECT(o2->obj), -1);
 321
 322         class = pygobject_lookup_class(G_TYPE_FROM_INSTANCE(o1->obj));
 323         compare_func = PyDict_GetItemString(class->tp_dict, "COMPARE_FUNC");
 324         g_return_val_if_fail(compare_func && PyCallable_Check(compare_func), -1);
 325
 326         params = PyTuple_New(2);
 327         Py_INCREF((PyObject*)o1);
 328         PyTuple_SetItem(params, 0, (PyObject*)o1);
 329         Py_INCREF((PyObject*)o2);
 330         PyTuple_SetItem(params, 1, (PyObject*)o2);
 331         ret = PyObject_CallObject(compare_func, params);
 332         retval = (int)PyInt_AsLong(ret);
 333
 334         Py_DECREF(params);
 335         Py_DECREF(ret);
 336         return retval;
 337 }
 338
 339 static PyObject *
 340 _wrap_gnt_tree_enable_sort(PyGObject *self)
 341 {
 342         gnt_tree_set_compare_func(GNT_TREE(self->obj), custom_compare_func);
 343
 344         Py_INCREF(Py_None);
 345         return Py_None;
 346 }
 347