| Current File : //usr/share/pygobject27/2.0/defs/gicon.override |
/* -*- Mode: C; c-basic-offset: 4 -*-
* pygtk- Python bindings for the GTK toolkit.
* Copyright (C) 2008 Johan Dahlin
*
* gicon.override: module overrides for GIcon and related types
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
* USA
*/
%%
ignore-glob
g_icon_hash
g_themed_icon_new_from_names
g_themed_icon_new_with_default_fallbacks
%%
override-slot GIcon.tp_richcompare
static PyObject *
_wrap_g_icon_tp_richcompare(PyGObject *self, PyGObject *other, int op)
{
PyObject *result;
if (PyObject_TypeCheck(self, &PyGIcon_Type)
&& PyObject_TypeCheck(other, &PyGIcon_Type)) {
GIcon *icon1 = G_ICON(self->obj);
GIcon *icon2 = G_ICON(other->obj);
switch (op) {
case Py_EQ:
result = (g_icon_equal(icon1, icon2)
? Py_True : Py_False);
break;
case Py_NE:
result = (!g_icon_equal(icon1, icon2)
? Py_True : Py_False);
break;
default:
result = Py_NotImplemented;
}
}
else
result = Py_NotImplemented;
Py_INCREF(result);
return result;
}
%%
override-slot GIcon.tp_hash
static long
_wrap_g_icon_tp_hash(PyGObject *self)
{
return g_icon_hash(G_ICON(self->obj));
}
%%
override g_loadable_icon_load kwargs
static PyObject *
_wrap_g_loadable_icon_load(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "size", "cancellable", NULL };
int size = 0;
char *type = NULL;
PyGObject *pycancellable = NULL;
GCancellable *cancellable;
GError *error = NULL;
GInputStream *stream;
PyObject *result;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"|iO:gio.LoadableIcon.load",
kwlist,
&size, &pycancellable))
return NULL;
if (!pygio_check_cancellable(pycancellable, &cancellable))
return NULL;
stream = g_loadable_icon_load(G_LOADABLE_ICON(self->obj), size, &type,
cancellable, &error);
if (pyg_error_check(&error))
return NULL;
result = Py_BuildValue("Ns", pygobject_new((GObject *) stream), type);
g_free(type);
return result;
}
%%
override g_loadable_icon_load_async kwargs
static PyObject *
_wrap_g_loadable_icon_load_async(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "callback", "size", "cancellable", "user_data", NULL };
int size = 0;
PyGObject *pycancellable = NULL;
GCancellable *cancellable;
PyGIONotify *notify;
notify = pygio_notify_new();
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O|iOO:gio.LoadableIcon.load_async",
kwlist,
¬ify->callback, &size, &pycancellable, ¬ify->data))
goto error;
if (!pygio_notify_callback_is_valid(notify))
goto error;
if (!pygio_check_cancellable(pycancellable, &cancellable))
goto error;
pygio_notify_reference_callback(notify);
g_loadable_icon_load_async(G_LOADABLE_ICON(self->obj),
size,
cancellable,
(GAsyncReadyCallback) async_result_callback_marshal,
notify);
Py_INCREF(Py_None);
return Py_None;
error:
pygio_notify_free(notify);
return NULL;
}
%%
override g_loadable_icon_load_finish kwargs
static PyObject *
_wrap_g_loadable_icon_load_finish(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "res", NULL };
PyGObject *res;
char *type = NULL;
GError *error = NULL;
GInputStream *stream;
PyObject *result;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O!:gio.LoadableIcon.load_finish",
kwlist,
&PyGAsyncResult_Type, &res))
return NULL;
stream = g_loadable_icon_load_finish(G_LOADABLE_ICON(self->obj),
G_ASYNC_RESULT(res->obj), &type, &error);
if (pyg_error_check(&error))
return NULL;
result = Py_BuildValue("Ns", pygobject_new((GObject *) stream), type);
g_free(type);
return result;
}
%%
override-slot GFileIcon.tp_repr
static PyObject *
_wrap_g_file_icon_tp_repr(PyGObject *self)
{
GFile *file = g_file_icon_get_file(G_FILE_ICON(self->obj));
char *uri = (file ? g_file_get_uri(file) : NULL);
gchar *representation;
PyObject *result;
if (uri) {
representation = g_strdup_printf("<%s at %p: %s>", self->ob_type->tp_name, self, uri);
g_free(uri);
}
else
representation = g_strdup_printf("<%s at %p: UNKNOWN URI>", self->ob_type->tp_name, self);
result = PyString_FromString(representation);
g_free(representation);
return result;
}
%%
new-constructor G_TYPE_THEMED_ICON
%%
override g_themed_icon_new kwargs
static int
_wrap_g_themed_icon_new(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "name", "use_default_fallbacks", NULL };
PyObject *name;
gboolean use_default_fallbacks = FALSE;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|i:gio.ThemedIcon.__init__",
kwlist, &name, &use_default_fallbacks))
return -1;
if (PyString_Check(name)) {
pygobject_construct(self,
"name", PyString_AsString(name),
"use-default-fallbacks", use_default_fallbacks, NULL);
return 0;
}
else if (PySequence_Check(name)) {
PyObject *tuple = PySequence_Tuple(name);
if (tuple) {
int k;
int length = PyTuple_Size(tuple);
char **names = g_new(char *, length + 1);
for (k = 0; k < length; k++) {
PyObject *str = PyTuple_GetItem(tuple, k);
if (str && PyString_Check(str))
names[k] = PyString_AsString(str);
else {
Py_DECREF(tuple);
g_free(names);
goto error;
}
}
names[length] = NULL;
pygobject_construct(self,
"names", names,
"use-default-fallbacks", use_default_fallbacks, NULL);
Py_DECREF(tuple);
g_free(names);
return 0;
}
}
error:
if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError,
"argument 1 of gio.ThemedIcon.__init__ "
"must be either a string or a sequence of strings");
}
return -1;
}
%%
override g_themed_icon_get_names noargs
static PyObject *
_wrap_g_themed_icon_get_names(PyGObject *self)
{
const char * const *names;
PyObject *ret;
names = g_themed_icon_get_names(G_THEMED_ICON(self->obj));
ret = PyList_New(0);
while (names && *names) {
PyObject *item = PyString_FromString(names[0]);
PyList_Append(ret, item);
Py_DECREF(item);
names++;
}
return ret;
}
%%
override-slot GThemedIcon.tp_repr
static PyObject *
_wrap_g_themed_icon_tp_repr(PyGObject *self)
{
const char * const *names = g_themed_icon_get_names(G_THEMED_ICON(self->obj));
GString *representation = g_string_new(NULL);
PyObject *result;
g_string_append_printf(representation, "<%s at %p: ", self->ob_type->tp_name, self);
if (names) {
gboolean first_name = TRUE;
while (*names) {
if (!first_name)
g_string_append(representation, ", ");
else
first_name = FALSE;
g_string_append(representation, *names++);
}
}
g_string_append(representation, ">");
result = PyString_FromString(representation->str);
g_string_free(representation, TRUE);
return result;
}
%%
override g_emblemed_icon_get_emblems noargs
static PyObject *
_wrap_g_emblemed_icon_get_emblems(PyGObject *self)
{
GList *list;
PyObject *ret;
list = g_emblemed_icon_get_emblems(G_EMBLEMED_ICON(self->obj));
PYLIST_FROMGLIST(ret, list, pygobject_new(list_item), NULL, NULL);
return ret;
}