gi/_gobject/pygparamspec.c

   1 /* -*- Mode: C; c-basic-offset: 4 -*-
   2  * pygtk- Python bindings for the GTK toolkit.
   3  * Copyright (C) 1998-2003  James Henstridge
   4  * Copyright (C) 2004       Johan Dahlin
   5  *
   6  *   pygenum.c: GEnum and GFlag wrappers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  21  * USA
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include <config.h>
  26 #endif
  27
  28 #include <pyglib.h>
  29
  30 #include "pygobject-private.h"
  31 #include "pygparamspec.h"
  32
  33 PYGLIB_DEFINE_TYPE("gobject.GParamSpec", PyGParamSpec_Type, PyGParamSpec);
  34
  35 static PyObject*
  36 pyg_param_spec_richcompare(PyObject *self, PyObject *other, int op)
  37 {
  38     if (Py_TYPE(self) == Py_TYPE(other) && Py_TYPE(self) == &PyGParamSpec_Type)
  39         return _pyglib_generic_ptr_richcompare(((PyGParamSpec*)self)->pspec,
  40                                                ((PyGParamSpec*)other)->pspec,
  41                                                op);
  42     else {
  43         Py_INCREF(Py_NotImplemented);
  44         return Py_NotImplemented;
  45     }
  46 }
  47
  48 static long
  49 pyg_param_spec_hash(PyGParamSpec *self)
  50 {
  51     return (long)self->pspec;
  52 }
  53
  54 static PyObject *
  55 pyg_param_spec_repr(PyGParamSpec *self)
  56 {
  57     char buf[80];
  58
  59     g_snprintf(buf, sizeof(buf), "<%s '%s'>",
  60                G_PARAM_SPEC_TYPE_NAME(self->pspec),
  61                g_param_spec_get_name(self->pspec));
  62     return PYGLIB_PyUnicode_FromString(buf);
  63 }
  64
  65 static void
  66 pyg_param_spec_dealloc(PyGParamSpec *self)
  67 {
  68     g_param_spec_unref(self->pspec);
  69     PyObject_DEL(self);
  70 }
  71
  72
  73 static PyObject *
  74 pygenum_from_pspec(GParamSpec *pspec)
  75 {
  76     PyObject *pyclass;
  77     GParamSpecEnum *enum_pspec;
  78     GType enum_type;
  79
  80     enum_pspec = G_PARAM_SPEC_ENUM(pspec);
  81     enum_type = G_ENUM_CLASS_TYPE(enum_pspec->enum_class);
  82     pyclass = (PyObject*)g_type_get_qdata(enum_type, pygenum_class_key);
  83     if (pyclass == NULL) {
  84         pyclass = pyg_enum_add(NULL, g_type_name(enum_type), NULL, enum_type);
  85         if (pyclass == NULL)
  86             pyclass = Py_None;
  87     }
  88
  89     Py_INCREF(pyclass);
  90     return pyclass;
  91 }
  92
  93 static PyObject *
  94 pygflags_from_pspec(GParamSpec *pspec)
  95 {
  96     PyObject *pyclass;
  97     GParamSpecFlags *flag_pspec;
  98     GType flag_type;
  99
 100     flag_pspec = G_PARAM_SPEC_FLAGS(pspec);
 101     flag_type = G_FLAGS_CLASS_TYPE(flag_pspec->flags_class);
 102     pyclass = (PyObject*)g_type_get_qdata(flag_type, pygflags_class_key);
 103     if (pyclass == NULL) {
 104         pyclass = pyg_flags_add(NULL, g_type_name(flag_type), NULL, flag_type);
 105         if (pyclass == NULL)
 106             pyclass = Py_None;
 107     }
 108     Py_INCREF(pyclass);
 109     return pyclass;
 110 }
 111
 112 static PyObject *
 113 pyg_param_spec_getattr(PyGParamSpec *self, const gchar *attr)
 114 {
 115     GParamSpec *pspec;
 116
 117     pspec = self->pspec;
 118
 119     /* common attributes */
 120     if (!strcmp(attr, "__gtype__")) {
 121         return pyg_type_wrapper_new(G_PARAM_SPEC_TYPE(pspec));
 122     } else if (!strcmp(attr, "name")) {
 123         return Py_BuildValue("s", g_param_spec_get_name(pspec));
 124     } else if (!strcmp(attr, "nick")) {
 125         return Py_BuildValue("s", g_param_spec_get_nick(pspec));
 126     } else if (!strcmp(attr, "blurb") || !strcmp(attr, "__doc__")) {
 127         return Py_BuildValue("s", g_param_spec_get_blurb(pspec));
 128     } else if (!strcmp(attr, "flags")) {
 129         return PYGLIB_PyLong_FromLong(pspec->flags);
 130     } else if (!strcmp(attr, "value_type")) {
 131         return pyg_type_wrapper_new(pspec->value_type);
 132     } else if (!strcmp(attr, "owner_type")) {
 133         return pyg_type_wrapper_new(pspec->owner_type);
 134     }
 135
 136     if (G_IS_PARAM_SPEC_CHAR(pspec)) {
 137         if (!strcmp(attr, "__members__")) {
 138             return Py_BuildValue("[sssssssssss]", "__doc__", "__gtype__",
 139                                  "blurb", "default_value", "flags",
 140                                  "maximum", "minimum", "name", "nick",
 141                                  "owner_type", "value_type");
 142         } else if (!strcmp(attr, "default_value")) {
 143             return PYGLIB_PyUnicode_FromFormat(
 144                 "%c", G_PARAM_SPEC_CHAR(pspec)->default_value);
 145         } else if (!strcmp(attr, "minimum")) {
 146             return PYGLIB_PyLong_FromLong(G_PARAM_SPEC_CHAR(pspec)->minimum);
 147         } else if (!strcmp(attr, "maximum")) {
 148             return PYGLIB_PyLong_FromLong(G_PARAM_SPEC_CHAR(pspec)->maximum);
 149         }
 150     } else if (G_IS_PARAM_SPEC_UCHAR(pspec)) {
 151         if (!strcmp(attr, "__members__")) {
 152             return Py_BuildValue("[sssssssssss]", "__doc__", "__gtype__",
 153                                  "blurb", "default_value",
 154                                  "flags", "maximum", "minimum",
 155                                  "name", "nick", "owner_type",
 156                                  "value_type");
 157         } else if (!strcmp(attr, "default_value")) {
 158             return PYGLIB_PyUnicode_FromFormat(
 159                 "%c", G_PARAM_SPEC_UCHAR(pspec)->default_value);
 160         } else if (!strcmp(attr, "minimum")) {
 161             return PYGLIB_PyLong_FromLong(G_PARAM_SPEC_UCHAR(pspec)->minimum);
 162         } else if (!strcmp(attr, "maximum")) {
 163             return PYGLIB_PyLong_FromLong(G_PARAM_SPEC_UCHAR(pspec)->maximum);
 164         }
 165     } else if (G_IS_PARAM_SPEC_BOOLEAN(pspec)) {
 166         if (!strcmp(attr, "__members__")) {
 167             return Py_BuildValue("[sssssssss]", "__doc__", "__gtype__",
 168                                  "blurb", "default_value",
 169                                  "flags", "name", "nick", "owner_type",
 170                                  "value_type");
 171         } else if (!strcmp(attr, "default_value")) {
 172             return PyBool_FromLong(G_PARAM_SPEC_BOOLEAN(pspec)->default_value);
 173         }
 174     } else if (G_IS_PARAM_SPEC_INT(pspec)) {
 175         if (!strcmp(attr, "__members__")) {
 176             return Py_BuildValue("[sssssssssss]", "__doc__", "__gtype__",
 177                                  "blurb", "default_value",
 178                                  "flags", "maximum", "minimum", "name",
 179                                  "nick", "owner_type", "value_type");
 180         } else if (!strcmp(attr, "default_value")) {
 181             return PYGLIB_PyLong_FromLong(G_PARAM_SPEC_INT(pspec)->default_value);
 182         } else if (!strcmp(attr, "minimum")) {
 183             return PYGLIB_PyLong_FromLong(G_PARAM_SPEC_INT(pspec)->minimum);
 184         } else if (!strcmp(attr, "maximum")) {
 185             return PYGLIB_PyLong_FromLong(G_PARAM_SPEC_INT(pspec)->maximum);
 186         }
 187     } else if (G_IS_PARAM_SPEC_UINT(pspec)) {
 188         if (!strcmp(attr, "__members__")) {
 189             return Py_BuildValue("[sssssssssss]", "__doc__", "__gtype__",
 190                                  "blurb", "default_value",
 191                                  "flags", "maximum", "minimum",
 192                                  "name", "nick", "owner_type",
 193                                  "value_type");
 194         } else if (!strcmp(attr, "default_value")) {
 195             return PyLong_FromUnsignedLong(G_PARAM_SPEC_UINT(pspec)->default_value);
 196         } else if (!strcmp(attr, "minimum")) {
 197             return PyLong_FromUnsignedLong(G_PARAM_SPEC_UINT(pspec)->minimum);
 198         } else if (!strcmp(attr, "maximum")) {
 199             return PyLong_FromUnsignedLong(G_PARAM_SPEC_UINT(pspec)->maximum);
 200         }
 201     } else if (G_IS_PARAM_SPEC_LONG(pspec)) {
 202         if (!strcmp(attr, "__members__")) {
 203             return Py_BuildValue("[sssssssssss]", "__doc__", "__gtype__",
 204                                  "blurb", "default_value",
 205                                  "flags", "maximum", "minimum", "name",
 206                                  "nick", "owner_type", "value_type");
 207         } else if (!strcmp(attr, "default_value")) {
 208             return PyLong_FromLong(G_PARAM_SPEC_LONG(pspec)->default_value);
 209         } else if (!strcmp(attr, "minimum")) {
 210             return PyLong_FromLong(G_PARAM_SPEC_LONG(pspec)->minimum);
 211         } else if (!strcmp(attr, "maximum")) {
 212             return PyLong_FromLong(G_PARAM_SPEC_LONG(pspec)->maximum);
 213         }
 214     } else if (G_IS_PARAM_SPEC_ULONG(pspec)) {
 215         if (!strcmp(attr, "__members__")) {
 216             return Py_BuildValue("[sssssssssss]", "__doc__", "__gtype__",
 217                                  "blurb", "default_value",
 218                                  "flags", "maximum", "minimum", "name",
 219                                  "nick", "owner_type", "value_type");
 220         } else if (!strcmp(attr, "default_value")) {
 221             return PyLong_FromUnsignedLong(G_PARAM_SPEC_ULONG(pspec)->default_value);
 222         } else if (!strcmp(attr, "minimum")) {
 223             return PyLong_FromUnsignedLong(G_PARAM_SPEC_ULONG(pspec)->minimum);
 224         } else if (!strcmp(attr, "maximum")) {
 225             return PyLong_FromUnsignedLong(G_PARAM_SPEC_ULONG(pspec)->maximum);
 226         }
 227     } else if (G_IS_PARAM_SPEC_INT64(pspec)) {
 228         if (!strcmp(attr, "__members__")) {
 229             return Py_BuildValue("[sssssssssss]", "__doc__", "__gtype__",
 230                                  "blurb", "default_value",
 231                                  "flags", "maximum", "minimum", "name",
 232                                  "nick", "owner_type", "value_type");
 233         } else if (!strcmp(attr, "default_value")) {
 234             return PyLong_FromLongLong(G_PARAM_SPEC_INT64(pspec)->default_value);
 235         } else if (!strcmp(attr, "minimum")) {
 236             return PyLong_FromLongLong(G_PARAM_SPEC_INT64(pspec)->minimum);
 237         } else if (!strcmp(attr, "maximum")) {
 238             return PyLong_FromLongLong(G_PARAM_SPEC_INT64(pspec)->maximum);
 239         }
 240     } else if (G_IS_PARAM_SPEC_UINT64(pspec)) {
 241         if (!strcmp(attr, "__members__")) {
 242             return Py_BuildValue("[sssssssssss]", "__doc__", "__gtype__",
 243                                  "blurb", "default_value",
 244                                  "flags", "maximum", "minimum",
 245                                  "name", "nick", "owner_type",
 246                                  "value_type");
 247         } else if (!strcmp(attr, "default_value")) {
 248             return PyLong_FromUnsignedLongLong(G_PARAM_SPEC_UINT64(pspec)->default_value);
 249         } else if (!strcmp(attr, "minimum")) {
 250             return PyLong_FromUnsignedLongLong(G_PARAM_SPEC_UINT64(pspec)->minimum);
 251         } else if (!strcmp(attr, "maximum")) {
 252             return PyLong_FromUnsignedLongLong(G_PARAM_SPEC_UINT64(pspec)->maximum);
 253         }
 254     } else if (G_IS_PARAM_SPEC_UNICHAR(pspec)) {
 255         if (!strcmp(attr, "__members__")) {
 256             return Py_BuildValue("[sssssssss]", "__doc__", "__gtype__",
 257                                  "blurb", "default_value",
 258                                  "flags", "name", "nick", "owner_type",
 259                                  "value_type");
 260         } else if (!strcmp(attr, "default_value")) {
 261             return PYGLIB_PyUnicode_FromFormat(
 262                 "%c", G_PARAM_SPEC_UNICHAR(pspec)->default_value);
 263         }
 264     } else if (G_IS_PARAM_SPEC_ENUM(pspec)) {
 265         if (!strcmp(attr, "__members__")) {
 266             return Py_BuildValue("[ssssssssss]", "__doc__", "__gtype__",
 267                                  "blurb", "default_value", "enum_class",
 268                                  "flags", "name", "nick", "owner_type",
 269                                  "value_type");
 270         } else if (!strcmp(attr, "default_value")) {
 271             return pyg_enum_from_gtype(
 272                 pspec->value_type, G_PARAM_SPEC_ENUM(pspec)->default_value);
 273         } else if (!strcmp(attr, "enum_class")) {
 274             return pygenum_from_pspec(pspec);
 275         }
 276     } else if (G_IS_PARAM_SPEC_FLAGS(pspec)) {
 277         if (!strcmp(attr, "__members__")) {
 278             return Py_BuildValue("[ssssssssss]", "__doc__", "__gtype__",
 279                                  "blurb", "default_value",
 280                                  "flags", "flags_class", "name", "nick",
 281                                  "owner_type", "value_type");
 282         } else if (!strcmp(attr, "default_value")) {
 283             return pyg_flags_from_gtype(
 284                 pspec->value_type, G_PARAM_SPEC_FLAGS(pspec)->default_value);
 285         } else if (!strcmp(attr, "flags_class")) {
 286             return pygflags_from_pspec(pspec);
 287         }
 288     } else if (G_IS_PARAM_SPEC_FLOAT(pspec)) {
 289         if (!strcmp(attr, "__members__")) {
 290             return Py_BuildValue("[ssssssssssss]", "__doc__", "__gtype__",
 291                                  "blurb", "epsilon",
 292                                  "flags", "maximum", "minimum", "name", "nick", "owner_type",
 293                                  "value_type",
 294                                  "default_value");
 295         } else if (!strcmp(attr, "default_value")) {
 296             return PyFloat_FromDouble(G_PARAM_SPEC_FLOAT(pspec)->default_value);
 297         } else if (!strcmp(attr, "minimum")) {
 298             return PyFloat_FromDouble(G_PARAM_SPEC_FLOAT(pspec)->minimum);
 299         } else if (!strcmp(attr, "maximum")) {
 300             return PyFloat_FromDouble(G_PARAM_SPEC_FLOAT(pspec)->maximum);
 301         } else if (!strcmp(attr, "epsilon")) {
 302             return PyFloat_FromDouble(G_PARAM_SPEC_FLOAT(pspec)->epsilon);
 303         }
 304     } else if (G_IS_PARAM_SPEC_DOUBLE(pspec)) {
 305         if (!strcmp(attr, "__members__")) {
 306             return Py_BuildValue("[ssssssssssss]", "__doc__", "__gtype__",
 307                                  "blurb", "default_value", "epsilon",
 308                                  "flags", "maximum", "minimum", "name", "nick",
 309                                  "owner_type", "value_type");
 310         } else if (!strcmp(attr, "default_value")) {
 311             return PyFloat_FromDouble(
 312                 G_PARAM_SPEC_DOUBLE(pspec)->default_value);
 313         } else if (!strcmp(attr, "minimum")) {
 314             return PyFloat_FromDouble(G_PARAM_SPEC_DOUBLE(pspec)->minimum);
 315         } else if (!strcmp(attr, "maximum")) {
 316             return PyFloat_FromDouble(G_PARAM_SPEC_DOUBLE(pspec)->maximum);
 317         } else if (!strcmp(attr, "epsilon")) {
 318             return PyFloat_FromDouble(G_PARAM_SPEC_DOUBLE(pspec)->epsilon);
 319         }
 320     } else if (G_IS_PARAM_SPEC_STRING(pspec)) {
 321         if (!strcmp(attr, "__members__")) {
 322             return Py_BuildValue("[ssssssssssssss]", "__doc__", "__gtype__",
 323                                  "blurb", "cset_firth", "cset_nth", "default_value",
 324                                  "ensure_non_null", "flags", "name", "nick",
 325                                  "null_fold_if_empty", "owner_type", "substitutor",
 326                                  "value_type");
 327         } else if (!strcmp(attr, "default_value")) {
 328             return Py_BuildValue(
 329                 "s", G_PARAM_SPEC_STRING(pspec)->default_value);
 330         } else if (!strcmp(attr, "cset_first")) {
 331             return Py_BuildValue(
 332                 "s", G_PARAM_SPEC_STRING(pspec)->cset_first);
 333         } else if (!strcmp(attr, "cset_nth")) {
 334             return Py_BuildValue(
 335                 "s", G_PARAM_SPEC_STRING(pspec)->cset_nth);
 336         } else if (!strcmp(attr, "substitutor")) {
 337             return Py_BuildValue(
 338                 "c", G_PARAM_SPEC_STRING(pspec)->substitutor);
 339         } else if (!strcmp(attr, "null_fold_if_empty")) {
 340             return PyBool_FromLong(
 341                 G_PARAM_SPEC_STRING(pspec)->null_fold_if_empty);
 342         } else if (!strcmp(attr, "ensure_non_null")) {
 343             return PyBool_FromLong(
 344                 G_PARAM_SPEC_STRING(pspec)->ensure_non_null);
 345         }
 346     } else {
 347         if (!strcmp(attr, "__members__")) {
 348             return Py_BuildValue("[ssssssss]", "__doc__", "__gtype__", "blurb",
 349                                  "flags", "name", "nick",
 350                                  "owner_type", "value_type");
 351
 352         /* This is actually not what's exported by GObjects paramspecs,
 353          * But we exported this in earlier versions, so it's better to keep it here
 354          * compatibility. But don't add it in __members__, to "hide" it.
 355          */
 356         } else if (!strcmp(attr, "default_value")) {
 357             /* XXX: Raise deprecation warning */
 358             Py_INCREF(Py_None);
 359             return Py_None;
 360         }
 361     }
 362
 363     PyErr_SetString(PyExc_AttributeError, attr);
 364     return NULL;
 365 }
 366
 367 /**
 368  * pyg_param_spec_new:
 369  * @pspec: a GParamSpec.
 370  *
 371  * Creates a wrapper for a GParamSpec.
 372  *
 373  * Returns: the GParamSpec wrapper.
 374  */
 375 PyObject *
 376 pyg_param_spec_new(GParamSpec *pspec)
 377 {
 378     PyGParamSpec *self;
 379
 380     self = (PyGParamSpec *)PyObject_NEW(PyGParamSpec,
 381                                         &PyGParamSpec_Type);
 382     if (self == NULL)
 383         return NULL;
 384
 385     self->pspec = g_param_spec_ref(pspec);
 386     return (PyObject *)self;
 387 }
 388
 389 void
 390 pygobject_paramspec_register_types(PyObject *d)
 391 {
 392     Py_TYPE(&PyGParamSpec_Type) = &PyType_Type;
 393     PyGParamSpec_Type.tp_dealloc = (destructor)pyg_param_spec_dealloc;
 394     PyGParamSpec_Type.tp_getattr = (getattrfunc)pyg_param_spec_getattr;
 395     PyGParamSpec_Type.tp_richcompare = pyg_param_spec_richcompare;
 396     PyGParamSpec_Type.tp_flags = Py_TPFLAGS_DEFAULT;
 397     PyGParamSpec_Type.tp_repr = (reprfunc)pyg_param_spec_repr;
 398     PyGParamSpec_Type.tp_hash = (hashfunc)pyg_param_spec_hash;
 399
 400
 401     if (PyType_Ready(&PyGParamSpec_Type))
 402         return;
 403     PyDict_SetItemString(d, "GParamSpec", (PyObject *)&PyGParamSpec_Type);
 404 }