bindings/python/rhythmdb.override

   1 %%
   2 headers
   3 #define NO_IMPORT_PYGOBJECT
   4 #include <pygobject.h>
   5 #include <pygtk/pygtk.h>
   6
   7 #include "override_common.h"
   8
   9 #include "rhythmdb.h"
  10 #include "rhythmdb-property-model.h"
  11 #include "rhythmdb-query-model.h"
  12 #include "rhythmdb-query-results.h"
  13
  14 void pyrhythmdb_register_classes (PyObject *d);
  15 void pyrhythmdb_add_constants (PyObject *module, const gchar *strip_prefix);
  16
  17 /* hacks to deal with the nonstandard class name RHYTHMDB */
  18 #define RHYTHMDB_TYPE_RHYTHMDB RHYTHMDB_TYPE
  19 #define RHYTHMDB_RHYTHMDB(o) RHYTHMDB(o)
  20
  21
  22 /* query model sorting stuff */
  23 typedef struct {
  24         PyObject *func;
  25         PyObject *data;
  26 } PyRhythmDBQueryModelSortData;
  27
  28 static void
  29 _rhythmdb_query_model_sort_data_free (PyRhythmDBQueryModelSortData *data)
  30 {
  31         Py_DECREF (data->func);
  32         Py_DECREF (data->data);
  33         g_free (data);
  34 }
  35
  36 static int
  37 _rhythmdb_query_model_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, PyRhythmDBQueryModelSortData *data)
  38 {
  39         PyObject *args;
  40         PyObject *py_result;
  41         PyObject *py_a, *py_b;
  42         int result;
  43
  44         py_a = pyg_pointer_new (RHYTHMDB_TYPE_ENTRY, a);
  45         py_b = pyg_pointer_new (RHYTHMDB_TYPE_ENTRY, b);
  46         if (data->data)
  47                 args = Py_BuildValue ("(OOO)", py_a, py_b, data->data);
  48         else
  49                 args = Py_BuildValue ("(O)", py_a, py_b);
  50
  51         py_result = PyEval_CallObject (data->func, args);
  52         result = PyInt_AsLong (py_result);
  53
  54         Py_DECREF (args);
  55         Py_DECREF (py_result);
  56         return result;
  57 }
  58 /* end query model sorting stuff */
  59
  60 %%
  61 modulename rhythmdb
  62 %%
  63 import gtk.Widget as PyGtkWidget_Type
  64 import gobject.GObject as PyGObject_Type
  65 import gtk.TreeView as PyGtkTreeView_Type
  66 %%
  67 ignore-glob
  68   *_get_type
  69   *_quark
  70 %%
  71 ignore
  72   rhythmdb_entry_get_pointer
  73   rhythmdb_entry_get_string
  74   rhythmdb_entry_get_boolean
  75   rhythmdb_entry_get_uint64
  76   rhythmdb_entry_get_ulong
  77   rhythmdb_entry_get_double
  78   rhythmdb_query_model_tree_path_to_entry
  79   rhythmdb_query_model_iter_to_entry
  80 %%
  81 override rhythmdb_entry_get kwargs
  82 static PyObject *
  83 _wrap_rhythmdb_entry_get(PyGObject *self, PyObject *args, PyObject *kwargs)
  84 {
  85     static char *kwlist[] = { "entry", "propid", NULL };
  86     PyObject *py_propid = NULL;
  87     PyObject *entry = NULL;
  88     RhythmDB *db;
  89     RhythmDBPropType propid;
  90     GValue value = {0,};
  91     PyObject *ret;
  92
  93     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RhythmDB.entry_get", kwlist, &entry, &py_propid))
  94         return NULL;
  95     if (pyg_enum_get_value(RHYTHMDB_TYPE_PROP_TYPE, py_propid, (gint *)&propid))
  96         return NULL;
  97
  98     db = RHYTHMDB (self->obj);
  99     g_value_init (&value, rhythmdb_get_property_type (db, propid));
 100     rhythmdb_entry_get(db, pyg_pointer_get (entry, RhythmDBEntry), propid, &value);
 101     ret = pyg_value_as_pyobject (&value, TRUE);
 102     g_value_unset (&value);
 103     if (ret)
 104         return ret;
 105     Py_INCREF(Py_None);
 106     return Py_None;
 107 }
 108 %%
 109 override rhythmdb_entry_set kwargs
 110 static PyObject *
 111 _wrap_rhythmdb_entry_set(PyGObject *self, PyObject *args, PyObject *kwargs)
 112 {
 113     static char *kwlist[] = { "entry", "propid", "value", NULL };
 114     PyObject *py_entry = NULL;
 115     PyObject *py_propid = NULL;
 116     PyObject *py_value = NULL;
 117     RhythmDBEntry *entry;
 118     RhythmDBPropType propid;
 119     GValue value = {0,};
 120
 121     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RhythmDBEntry.set", kwlist, &py_entry, &py_propid, &py_value))
 122         return NULL;
 123     if (pyg_pointer_check(py_entry, RHYTHMDB_TYPE_ENTRY))
 124         entry = pyg_pointer_get(py_entry, RhythmDBEntry);
 125     else {
 126         PyErr_SetString(PyExc_TypeError, "entry should be a RhythmDBEntry");
 127         return NULL;
 128     }
 129     if (pyg_enum_get_value(RHYTHMDB_TYPE_PROP_TYPE, py_propid, (gint *)&propid))
 130         return NULL;
 131     g_value_init(&value, rhythmdb_get_property_type (RHYTHMDB(self->obj), propid));
 132     if (pyg_value_from_pyobject(&value, py_value) < 0) {
 133         PyErr_SetString(PyExc_TypeError,
 134                 "could not convert argument to correct param type");
 135         return NULL;
 136     }
 137     rhythmdb_entry_set(RHYTHMDB(self->obj), entry, propid, &value);
 138     g_value_unset (&value);
 139     Py_INCREF(Py_None);
 140     return Py_None;
 141 }
 142 %%
 143 override rhythmdb_entry_set_nonotify kwargs
 144 static PyObject *
 145 _wrap_rhythmdb_entry_set_nonotify(PyGObject *self, PyObject *args, PyObject *kwargs)
 146 {
 147     static char *kwlist[] = { "entry", "propid", "value", NULL };
 148     PyObject *py_entry = NULL;
 149     PyObject *py_propid = NULL;
 150     PyObject *py_value = NULL;
 151     RhythmDBEntry *entry;
 152     RhythmDBPropType propid;
 153     GValue value = {0,};
 154
 155     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RhythmDBEntry.set_nonotify", kwlist, &py_entry, &py_propid, &py_value))
 156         return NULL;
 157     if (pyg_pointer_check(py_entry, RHYTHMDB_TYPE_ENTRY))
 158         entry = pyg_pointer_get(py_entry, RhythmDBEntry);
 159     else {
 160         PyErr_SetString(PyExc_TypeError, "entry should be a RhythmDBEntry");
 161         return NULL;
 162     }
 163     if (pyg_enum_get_value(RHYTHMDB_TYPE_PROP_TYPE, py_propid, (gint *)&propid))
 164         return NULL;
 165     g_value_init(&value, rhythmdb_get_property_type (RHYTHMDB(self->obj), propid));
 166     if (pyg_value_from_pyobject(&value, py_value) < 0) {
 167         PyErr_SetString(PyExc_TypeError,
 168                 "could not convert argument to correct param type");
 169         return NULL;
 170     }
 171     rhythmdb_entry_set_nonotify(RHYTHMDB(self->obj), entry, propid, &value);
 172     g_value_unset (&value);
 173     Py_INCREF(Py_None);
 174     return Py_None;
 175 }
 176 %%
 177 override rhythmdb_entry_set_uninserted kwargs
 178 static PyObject *
 179 _wrap_rhythmdb_entry_set_uninserted(PyGObject *self, PyObject *args, PyObject *kwargs)
 180 {
 181     static char *kwlist[] = { "entry", "propid", "value", NULL };
 182     PyObject *py_entry = NULL;
 183     PyObject *py_propid = NULL;
 184     PyObject *py_value = NULL;
 185     RhythmDBEntry *entry;
 186     RhythmDBPropType propid;
 187     GValue value = {0,};
 188
 189     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RhythmDBEntry.set_uninserted", kwlist, &py_entry, &py_propid, &py_value))
 190         return NULL;
 191     if (pyg_pointer_check(py_entry, RHYTHMDB_TYPE_ENTRY))
 192         entry = pyg_pointer_get(py_entry, RhythmDBEntry);
 193     else {
 194         PyErr_SetString(PyExc_TypeError, "entry should be a RhythmDBEntry");
 195         return NULL;
 196     }
 197     if (pyg_enum_get_value(RHYTHMDB_TYPE_PROP_TYPE, py_propid, (gint *)&propid))
 198         return NULL;
 199     g_value_init(&value, rhythmdb_get_property_type (RHYTHMDB(self->obj), propid));
 200     if (pyg_value_from_pyobject(&value, py_value) < 0) {
 201         PyErr_SetString(PyExc_TypeError,
 202                 "could not convert argument to correct param type");
 203         return NULL;
 204     }
 205     rhythmdb_entry_set_uninserted(RHYTHMDB(self->obj), entry, propid, &value);
 206     g_value_unset (&value);
 207     Py_INCREF(Py_None);
 208     return Py_None;
 209 }
 210 %%
 211 override rhythmdb_query_results_add_results kwargs
 212 static PyObject*
 213 _wrap_rhythmdb_query_results_add_results (PyGObject *self, PyObject *args, PyObject *kwargs)
 214 {
 215     static char *kwlist[] = { "entries", NULL };
 216     PyObject *py_entries = NULL;
 217     int size, i;
 218     GPtrArray *array;
 219
 220     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:RhythmDBQueryResults.add_results", kwlist, &py_entries))
 221         return NULL;
 222
 223     array = g_ptr_array_new();
 224     size = PyList_Size(py_entries);
 225     for (i = 0; i < size; i++) {
 226         PyObject *py_entry;
 227         RhythmDBEntry *entry;
 228
 229         py_entry = PyList_GetItem(py_entries, i);
 230         if (!pyg_pointer_check(py_entry, RHYTHMDB_TYPE_ENTRY)) {
 231             g_ptr_array_free(array, FALSE);
 232             return NULL;
 233         }
 234
 235         entry = pyg_pointer_get(py_entry, RhythmDBEntry);
 236         g_ptr_array_add(array, entry);
 237     }
 238
 239     rhythmdb_query_results_add_results (RHYTHMDB_QUERY_RESULTS(self->obj), array);
 240     g_ptr_array_free(array, FALSE);
 241
 242     Py_INCREF(Py_None);
 243     return Py_None;
 244
 245 }
 246 %%
 247 override rhythmdb_entry_foreach kwargs
 248
 249 typedef struct {
 250         PyObject *func;
 251         PyObject *data;
 252 } PyRhythmDBEntryForeachData;
 253
 254 static void
 255 _rhythmdb_entry_foreach_func (RhythmDBEntry *entry, PyRhythmDBEntryForeachData  *data)
 256 {
 257         PyObject *args;
 258         PyObject *result;
 259         PyObject *py_entry;
 260
 261         py_entry = pyg_pointer_new (RHYTHMDB_TYPE_ENTRY, entry);
 262         if (data->data)
 263                 args = Py_BuildValue ("(OO)", py_entry, data->data);
 264         else
 265                 args = Py_BuildValue ("(O)", py_entry);
 266
 267         result = PyEval_CallObject (data->func, args);
 268         Py_DECREF (args);
 269
 270         Py_DECREF (result);
 271 }
 272
 273 static PyObject*
 274 _wrap_rhythmdb_entry_foreach (PyGObject *self, PyObject *args, PyObject *kwargs)
 275 {
 276         static char *kwlist[] = {"func", NULL};
 277         PyRhythmDBEntryForeachData data;
 278
 279         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:RhythmDB.entry_foreach",
 280                                          kwlist, &data.func, &data.data))
 281                 return NULL;
 282
 283         /* verify arguments' integrity */
 284         if (!PyCallable_Check (data.func)) {
 285                 PyErr_SetString (PyExc_TypeError, "func must be callable");
 286                 return NULL;
 287         }
 288
 289         rhythmdb_entry_foreach (RHYTHMDB (self->obj), (GFunc)_rhythmdb_entry_foreach_func, &data);
 290
 291         Py_INCREF(Py_None);
 292         return Py_None;
 293 }
 294 %%
 295 override rhythmdb_query_model_new kwargs
 296
 297 static PyObject*
 298 _wrap_rhythmdb_query_model_new (PyGObject *self, PyObject *args, PyObject *kwargs)
 299 {
 300         static char *kwlist[] = {"query", "func", "reverse", NULL};
 301         PyObject *py_query;
 302         int reverse;
 303         PyRhythmDBQueryModelSortData *data;
 304         RhythmDBQueryModel *query_model;
 305
 306         data = g_new0 (PyRhythmDBQueryModelSortData, 1);
 307
 308         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOi|O:RhythmDB.query_model_new", kwlist,
 309                                          &py_query, &data->func, &reverse, &data->data)) {
 310                 g_free (data);
 311                 return NULL;
 312         }
 313
 314         /* verify arguments' integrity */
 315         if (!PyCallable_Check (data->func)) {
 316                 PyErr_SetString (PyExc_TypeError, "func must be callable");
 317                 g_free (data);
 318                 return NULL;
 319         }
 320
 321         if (!pyg_boxed_check(py_query, RHYTHMDB_TYPE_QUERY)) {
 322                 PyErr_SetString(PyExc_TypeError, "query should be a RhythmDBQuery");
 323                 g_free (data);
 324                 return NULL;
 325         }
 326
 327         Py_INCREF (data->func);
 328         Py_INCREF (data->data);
 329
 330         query_model = rhythmdb_query_model_new (RHYTHMDB (self->obj), pyg_boxed_get (py_query, RhythmDBQuery),
 331                                                 (GCompareDataFunc) _rhythmdb_query_model_sort_func,
 332                                                 data, (GDestroyNotify) _rhythmdb_query_model_sort_data_free,
 333                                                 (reverse != 0));
 334
 335         return pygobject_new (G_OBJECT (query_model));
 336 }
 337 %%
 338 override rhythmdb_query_model_set_sort_order kwargs
 339
 340 static PyObject*
 341 _wrap_rhythmdb_query_model_set_sort_order (PyGObject *self, PyObject *args, PyObject *kwargs)
 342 {
 343         static char *kwlist[] = {"func", "reverse", NULL};
 344         int reverse;
 345         PyRhythmDBQueryModelSortData *data;
 346         RhythmDBQueryModel *query_model;
 347
 348         data = g_new0 (PyRhythmDBQueryModelSortData, 1);
 349
 350         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi|O:RhythmDB.query_model_set_sort_order", kwlist,
 351                                          &data->func, &reverse, &data->data)) {
 352                 g_free (data);
 353                 return NULL;
 354         }
 355
 356         /* verify arguments' integrity */
 357         if (!PyCallable_Check (data->func)) {
 358                 PyErr_SetString (PyExc_TypeError, "func must be callable");
 359                 g_free (data);
 360                 return NULL;
 361         }
 362
 363         Py_INCREF (data->func);
 364         Py_INCREF (data->data);
 365
 366         rhythmdb_query_model_set_sort_order (RHYTHMDB (self->obj),
 367                                              (GCompareDataFunc) _rhythmdb_query_model_sort_func,
 368                                              data, (GDestroyNotify) _rhythmdb_query_model_sort_data_free,
 369                                              (reverse != 0));
 370
 371         Py_INCREF(Py_None);
 372         return Py_None;
 373 }