gi/pygoptiongroup.c

   1 /* -*- Mode: C; c-basic-offset: 4 -*-
   2  * pygobject - Python bindings for the GLib, GObject and GIO
   3  * Copyright (C) 2006  Johannes Hoelzl
   4  *
   5  *   pygoptiongroup.c: GOptionContext and GOptionGroup wrapper
   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, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22
  23 #include "pygoptiongroup.h"
  24 #include "pygi-error.h"
  25 #include "pygi-util.h"
  26
  27 PYGLIB_DEFINE_TYPE("gi._gi.OptionGroup", PyGOptionGroup_Type, PyGOptionGroup)
  28
  29 /**
  30  * pyg_option_group_new:
  31  * @group: a GOptionGroup
  32  *
  33  * The returned GOptionGroup can't be used to set any hooks, translation domains
  34  * or add entries. It's only intend is, to use for GOptionContext.add_group().
  35  *
  36  * Returns: the GOptionGroup wrapper.
  37  */
  38 PyObject *
  39 pyg_option_group_new (GOptionGroup *group)
  40 {
  41     PyGOptionGroup *self;
  42
  43     self = (PyGOptionGroup *)PyObject_NEW(PyGOptionGroup,
  44                       &PyGOptionGroup_Type);
  45     if (self == NULL)
  46         return NULL;
  47
  48     self->group = group;
  49     self->other_owner = TRUE;
  50     self->is_in_context = FALSE;
  51
  52     return (PyObject *)self;
  53 }
  54
  55 static gboolean
  56 check_if_owned(PyGOptionGroup *self)
  57 {
  58     if (self->other_owner)
  59     {
  60         PyErr_SetString(PyExc_ValueError, "The GOptionGroup was not created by "
  61                         "gi._gi.OptionGroup(), so operation is not possible.");
  62         return TRUE;
  63     }
  64     return FALSE;
  65 }
  66
  67 static void
  68 destroy_g_group(PyGOptionGroup *self)
  69 {
  70     PyGILState_STATE state;
  71     state = PyGILState_Ensure();
  72
  73     self->group = NULL;
  74     Py_CLEAR(self->callback);
  75     g_slist_foreach(self->strings, (GFunc) g_free, NULL);
  76     g_slist_free(self->strings);
  77     self->strings = NULL;
  78
  79     if (self->is_in_context)
  80     {
  81         Py_DECREF(self);
  82     }
  83
  84     PyGILState_Release(state);
  85 }
  86
  87 static int
  88 pyg_option_group_init(PyGOptionGroup *self, PyObject *args, PyObject *kwargs)
  89 {
  90     static char *kwlist[] = { "name", "description", "help_description",
  91                               "callback", NULL };
  92     char *name, *description, *help_description;
  93     PyObject *callback;
  94
  95     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "zzzO:GOptionGroup.__init__",
  96                                      kwlist, &name, &description,
  97                                      &help_description, &callback))
  98         return -1;
  99
 100     self->group = g_option_group_new(name, description, help_description,
 101                                      self, (GDestroyNotify) destroy_g_group);
 102     self->other_owner = FALSE;
 103     self->is_in_context = FALSE;
 104
 105     Py_INCREF(callback);
 106     self->callback = callback;
 107
 108     return 0;
 109 }
 110
 111 static void
 112 pyg_option_group_dealloc(PyGOptionGroup *self)
 113 {
 114     if (!self->other_owner && !self->is_in_context)
 115     {
 116         GOptionGroup *tmp = self->group;
 117         self->group = NULL;
 118         if (tmp) {
 119             G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 120             g_option_group_free(tmp);
 121             G_GNUC_END_IGNORE_DEPRECATIONS
 122         }
 123     }
 124
 125     PyObject_Del(self);
 126 }
 127
 128 static gboolean
 129 arg_func(const gchar *option_name,
 130          const gchar *value,
 131          PyGOptionGroup *self,
 132          GError **error)
 133 {
 134     PyObject *ret;
 135     PyGILState_STATE state;
 136     gboolean no_error;
 137
 138     state = PyGILState_Ensure();
 139     if (value == NULL)
 140         ret = PyObject_CallFunction(self->callback, "sOO",
 141                                     option_name, Py_None, self);
 142     else
 143         ret = PyObject_CallFunction(self->callback, "ssO",
 144                                     option_name, value, self);
 145
 146     if (ret != NULL)
 147     {
 148         Py_DECREF(ret);
 149         no_error = TRUE;
 150     } else
 151         no_error = pygi_gerror_exception_check(error) != -1;
 152
 153     PyGILState_Release(state);
 154     return no_error;
 155 }
 156
 157 static PyObject *
 158 pyg_option_group_add_entries(PyGOptionGroup *self, PyObject *args,
 159                              PyObject *kwargs)
 160 {
 161     static char *kwlist[] = { "entries", NULL };
 162     gssize entry_count, pos;
 163     PyObject *entry_tuple, *list;
 164     GOptionEntry *entries;
 165
 166     if (check_if_owned(self))
 167         return NULL;
 168
 169     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GOptionGroup.add_entries",
 170                                      kwlist, &list))
 171         return NULL;
 172
 173     if (!PyList_Check(list))
 174     {
 175         PyErr_SetString(PyExc_TypeError,
 176                         "GOptionGroup.add_entries expected a list of entries");
 177         return NULL;
 178     }
 179
 180     entry_count = PyList_Size(list);
 181     if (entry_count == -1)
 182     {
 183         PyErr_SetString(PyExc_TypeError,
 184                         "GOptionGroup.add_entries expected a list of entries");
 185         return NULL;
 186     }
 187
 188     entries = g_new0(GOptionEntry, entry_count + 1);
 189     for (pos = 0; pos < entry_count; pos++)
 190     {
 191         gchar *long_name, *description, *arg_description;
 192         entry_tuple = PyList_GetItem(list, pos);
 193         if (!PyTuple_Check(entry_tuple))
 194         {
 195             PyErr_SetString(PyExc_TypeError, "GOptionGroup.add_entries "
 196                                              "expected a list of entries");
 197             g_free(entries);
 198             return NULL;
 199         }
 200         if (!PyArg_ParseTuple(entry_tuple, "scisz",
 201             &long_name,
 202             &(entries[pos].short_name),
 203             &(entries[pos].flags),
 204             &description,
 205             &arg_description))
 206         {
 207             PyErr_SetString(PyExc_TypeError, "GOptionGroup.add_entries "
 208                                              "expected a list of entries");
 209             g_free(entries);
 210             return NULL;
 211         }
 212         long_name = g_strdup(long_name);
 213         self->strings = g_slist_prepend(self->strings, long_name);
 214         entries[pos].long_name = long_name;
 215
 216         description = g_strdup(description);
 217         self->strings = g_slist_prepend(self->strings, description);
 218         entries[pos].description = description;
 219
 220         arg_description = g_strdup(arg_description);
 221         self->strings = g_slist_prepend(self->strings, arg_description);
 222         entries[pos].arg_description = arg_description;
 223
 224         entries[pos].arg = G_OPTION_ARG_CALLBACK;
 225         entries[pos].arg_data = arg_func;
 226     }
 227
 228     g_option_group_add_entries(self->group, entries);
 229
 230     g_free(entries);
 231
 232     Py_INCREF(Py_None);
 233     return Py_None;
 234 }
 235
 236
 237 static PyObject *
 238 pyg_option_group_set_translation_domain(PyGOptionGroup *self,
 239                                         PyObject *args,
 240                                         PyObject *kwargs)
 241 {
 242     static char *kwlist[] = { "domain", NULL };
 243     char *domain;
 244
 245     if (check_if_owned(self))
 246         return NULL;
 247
 248     if (self->group == NULL)
 249     {
 250         PyErr_SetString(PyExc_RuntimeError,
 251                         "The corresponding GOptionGroup was already freed, "
 252                         "probably through the release of GOptionContext");
 253         return NULL;
 254     }
 255
 256     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 257                                      "z:GOptionGroup.set_translate_domain",
 258                                      kwlist, &domain))
 259         return NULL;
 260
 261     g_option_group_set_translation_domain(self->group, domain);
 262
 263     Py_INCREF(Py_None);
 264     return Py_None;
 265 }
 266
 267 static PyObject*
 268 pyg_option_group_richcompare(PyObject *self, PyObject *other, int op)
 269 {
 270     if (Py_TYPE(self) == Py_TYPE(other) &&
 271           Py_TYPE(self) == &PyGOptionGroup_Type) {
 272         return pyg_ptr_richcompare(((PyGOptionGroup*)self)->group,
 273                                    ((PyGOptionGroup*)other)->group,
 274                                    op);
 275     } else {
 276         Py_INCREF(Py_NotImplemented);
 277         return Py_NotImplemented;
 278     }
 279 }
 280
 281 static PyMethodDef pyg_option_group_methods[] = {
 282     { "add_entries", (PyCFunction)pyg_option_group_add_entries, METH_VARARGS | METH_KEYWORDS },
 283     { "set_translation_domain", (PyCFunction)pyg_option_group_set_translation_domain, METH_VARARGS | METH_KEYWORDS },
 284     { NULL, NULL, 0 },
 285 };
 286
 287 /**
 288  * Returns 0 on success, or -1 and sets an exception.
 289  */
 290 int
 291 pygi_option_group_register_types(PyObject *d)
 292 {
 293     PyGOptionGroup_Type.tp_dealloc = (destructor)pyg_option_group_dealloc;
 294     PyGOptionGroup_Type.tp_richcompare = pyg_option_group_richcompare;
 295     PyGOptionGroup_Type.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
 296     PyGOptionGroup_Type.tp_methods = pyg_option_group_methods;
 297     PyGOptionGroup_Type.tp_init = (initproc)pyg_option_group_init;
 298     PYGLIB_REGISTER_TYPE(d, PyGOptionGroup_Type, "OptionGroup");
 299
 300     return 0;
 301 }