static void
pygdk_event_handler_marshal(GdkEvent *event, gpointer data)
{
PyGILState_STATE state;
PyGtkCustomNotify *cunote = data;
PyObject *retobj;
PyObject *pyevent;
g_assert (cunote->func);
state = pyg_gil_state_ensure();
pyevent = pyg_boxed_new(GDK_TYPE_EVENT, event, TRUE, TRUE);
if (cunote->data)
retobj = PyEval_CallFunction(cunote->func, "(NO)",
pyevent, cunote->data);
else
retobj = PyEval_CallFunction(cunote->func, "(N)", pyevent);
if (retobj == NULL) {
PyErr_Print();
} else
Py_DECREF(retobj);
pyg_gil_state_release(state);
}
static PyObject *
pygtk_rc_style_helper_getitem(PyGtkRcStyleHelper_Object *self, Py_ssize_t pos)
{
if (pos < 0) pos += NUM_STATES;
if (pos < 0 || pos >= NUM_STATES) {
PyErr_SetString(PyExc_IndexError, "index out of range");
return NULL;
}
switch (self->type) {
case RC_STYLE_STRING_ARRAY:
{
gchar **array = (gchar **)self->array;
if (array[pos])
return PyString_FromString(array[pos]);
else {
Py_INCREF(Py_None);
return Py_None;
}
}
case RC_STYLE_COLOUR_ARRAY:
if (self->rc_style->color_flags[pos] & self->is_set_flag) {
GdkColor *array = (GdkColor *)self->array;
return pyg_boxed_new(GDK_TYPE_COLOR, &array[pos], TRUE, TRUE);
}
else {
Py_INCREF(Py_None);
return Py_None;
}
}
g_assert_not_reached();
return NULL;
}
static PyObject *
pygtk_style_helper_getitem(PyGtkStyleHelper_Object *self, Py_ssize_t pos)
{
if (pos < 0) pos += NUM_STATES;
if (pos < 0 || pos >= NUM_STATES) {
PyErr_SetString(PyExc_IndexError, "index out of range");
return NULL;
}
switch (self->type) {
case STYLE_COLOUR_ARRAY:
{
GdkColor *array = (GdkColor *)self->array;
return pyg_boxed_new(GDK_TYPE_COLOR, &array[pos], TRUE, TRUE);
}
case STYLE_GC_ARRAY:
{
GdkGC **array = (GdkGC **)self->array;
return pygobject_new((GObject *)array[pos]);
}
case STYLE_PIXMAP_ARRAY:
{
GdkPixmap **array = (GdkPixmap **)self->array;
if ((long)array[pos] == GDK_PARENT_RELATIVE)
return PyLong_FromLong(GDK_PARENT_RELATIVE);
return pygobject_new((GObject *)array[pos]);
}
}
g_assert_not_reached();
return NULL;
}
static PyObject *
PyGdkRectangle_from_value(const GValue *value)
{
GdkRectangle *rect = (GdkRectangle *)g_value_get_boxed(value);
return pyg_boxed_new(GDK_TYPE_RECTANGLE, rect, TRUE, TRUE);
}
static NemoOperationResult
nemo_python_object_update_file_info (NemoInfoProvider *provider,
NemoFile *file,
GClosure *update_complete,
NemoOperationHandle **handle)
{
NemoPythonObject *object = (NemoPythonObject*)provider;
NemoOperationResult ret = NEMO_OPERATION_COMPLETE;
PyObject *py_ret = NULL;
PyGILState_STATE state = pyg_gil_state_ensure();
PyObject *py_handle = nemo_python_boxed_new (_PyNemoOperationHandle_Type, *handle, FALSE);
debug_enter();
CHECK_OBJECT(object);
if (PyObject_HasAttrString(object->instance, "update_file_info_full"))
{
py_ret = PyObject_CallMethod(object->instance,
METHOD_PREFIX "update_file_info_full", "(NNNN)",
pygobject_new((GObject*)provider),
py_handle,
pyg_boxed_new(G_TYPE_CLOSURE, update_complete, TRUE, TRUE),
pygobject_new((GObject*)file));
}
else if (PyObject_HasAttrString(object->instance, "update_file_info"))
{
py_ret = PyObject_CallMethod(object->instance,
METHOD_PREFIX METHOD_NAME, "(N)",
pygobject_new((GObject*)file));
}
else
{
goto beach;
}
HANDLE_RETVAL(py_ret);
if (!PyInt_Check(py_ret))
{
PyErr_SetString(PyExc_TypeError,
METHOD_NAME " must return None or a int");
goto beach;
}
ret = PyInt_AsLong(py_ret);
beach:
free_pygobject_data(file, NULL);
Py_XDECREF(py_ret);
pyg_gil_state_release(state);
return ret;
}
static PeasExtension *
peas_plugin_loader_python_create_extension (PeasPluginLoader *loader,
PeasPluginInfo *info,
GType exten_type,
guint n_parameters,
GParameter *parameters)
{
PyObject *pymodule = info->loader_data;
GType the_type;
GObject *object = NULL;
PyObject *pyobject;
PyObject *pyplinfo;
PyGILState_STATE state = PyGILState_Ensure ();
the_type = find_python_extension_type (exten_type, pymodule);
if (the_type == G_TYPE_INVALID)
goto out;
object = g_object_newv (the_type, n_parameters, parameters);
if (object == NULL)
goto out;
/* We have to remember which interface we are instantiating
* for the deprecated peas_extension_get_extension_type().
*/
g_object_set_qdata (object, quark_extension_type,
GSIZE_TO_POINTER (exten_type));
pyobject = pygobject_new (object);
pyplinfo = pyg_boxed_new (PEAS_TYPE_PLUGIN_INFO, info, TRUE, TRUE);
/* Set the plugin info as an attribute of the instance */
if (PyObject_SetAttrString (pyobject, "plugin_info", pyplinfo) != 0)
{
g_warning ("Failed to set 'plugin_info' for '%s'",
g_type_name (the_type));
if (PyErr_Occurred ())
PyErr_Print ();
g_clear_object (&object);
}
Py_DECREF (pyplinfo);
Py_DECREF (pyobject);
out:
PyGILState_Release (state);
return object;
}
PyObject *
_helper_wrap_boxed_gptrarray (GPtrArray *list, GType type, gboolean own_ref, gboolean dealloc)
{
PyObject *py_list;
unsigned int i;
if ((py_list = PyList_New(0)) == NULL) {
return NULL;
}
for( i = 0; i < list->len; i++ ) {
PyObject *obj = pyg_boxed_new (type, g_ptr_array_index(list,i), FALSE, own_ref);
PyList_Append(py_list, obj);
Py_DECREF(obj);
}
if (dealloc) g_ptr_array_free (list, TRUE);
return py_list;
}
static PyObject *
_wrap_gst_tag_list_from_xmp_buffer(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "buffer", NULL };
PyObject *py_buffer;
GstTagList *ret;
const GstBuffer *buffer;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:tag_list_from_xmp_buffer", kwlist, &py_buffer))
return NULL;
buffer = GST_BUFFER(pygstminiobject_get (py_buffer));
if (PyErr_Occurred())
return NULL;
pyg_begin_allow_threads;
ret = gst_tag_list_from_xmp_buffer(buffer);
pyg_end_allow_threads;
/* pyg_boxed_new handles NULL checking */
return pyg_boxed_new(GST_TYPE_TAG_LIST, (GstTagList*) ret, TRUE, TRUE);
}
PyObject *
_helper_wrap_boxed_glist (const GList *list,
GType boxed_type,
gboolean copy_boxed,
gboolean own_ref)
{
PyObject *py_list;
const GList *tmp;
if ((py_list = PyList_New(0)) == NULL) {
return NULL;
}
for (tmp = list; tmp != NULL; tmp = tmp->next) {
PyObject *py_obj = pyg_boxed_new(boxed_type, G_OBJECT(tmp->data), copy_boxed, own_ref);
if (py_obj == NULL) {
Py_DECREF(py_list);
return NULL;
}
PyList_Append(py_list, py_obj);
Py_DECREF(py_obj);
}
return py_list;
}
static PyObject *
boxed_to_pyobject (gpointer boxed,
gpointer type)
{
return pyg_boxed_new (GPOINTER_TO_SIZE (type), boxed, TRUE, TRUE);
}
static PyObject *
pygtk_tree_model_row_get_iter(PyGtkTreeModelRow *self, void *closure)
{
return pyg_boxed_new(GTK_TYPE_TREE_ITER, &self->iter, TRUE, TRUE);
}
static CajaOperationResult
caja_python_object_update_file_info (CajaInfoProvider *provider,
CajaFile *file,
GClosure *update_complete,
CajaOperationHandle **handle)
{
CajaPythonObject *object = (CajaPythonObject*)provider;
CajaOperationResult ret = CAJA_OPERATION_COMPLETE;
PyObject *py_ret = NULL;
PyGILState_STATE state = pyg_gil_state_ensure();
static volatile gssize handle_generator = 1;
debug_enter();
CHECK_OBJECT(object);
*handle = NULL;
if (PyObject_HasAttrString(object->instance, "update_file_info_full"))
{
PyObject *py_handle;
void *h;
/* Generate a new handle with a default value. */
do {
h = (CajaOperationHandle *) g_atomic_pointer_add (&handle_generator, 1);
} while (!h);
py_handle = caja_python_boxed_new (_PyCajaOperationHandle_Type,
h, FALSE);
py_ret = PyObject_CallMethod(object->instance,
METHOD_PREFIX "update_file_info_full", "(NNNN)",
pygobject_new((GObject*)provider),
py_handle,
pyg_boxed_new(G_TYPE_CLOSURE, update_complete, TRUE, TRUE),
pygobject_new((GObject*)file));
*handle = (void *) ((PyGBoxed *) py_handle)->boxed;
}
else if (PyObject_HasAttrString(object->instance, "update_file_info"))
{
py_ret = PyObject_CallMethod(object->instance,
METHOD_PREFIX METHOD_NAME, "(N)",
pygobject_new((GObject*)file));
}
else
{
goto beach;
}
HANDLE_RETVAL(py_ret);
if (!INT_CHECK(py_ret))
{
PyErr_SetString(PyExc_TypeError,
METHOD_NAME " must return None or a int");
goto beach;
}
ret = INT_ASLONG(py_ret);
if (!*handle && ret == CAJA_OPERATION_IN_PROGRESS)
ret = CAJA_OPERATION_FAILED;
beach:
free_pygobject_data(file, NULL);
Py_XDECREF(py_ret);
pyg_gil_state_release(state);
return ret;
}
/**
* pyg_value_as_pyobject:
* @value: the GValue object.
* @copy_boxed: true if boxed values should be copied.
*
* This function creates/returns a Python wrapper object that
* represents the GValue passed as an argument.
*
* Returns: a PyObject representing the value.
*/
PyObject *
pyg_value_as_pyobject(const GValue *value, gboolean copy_boxed)
{
gchar buf[128];
switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) {
case G_TYPE_INTERFACE:
if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT))
return pygobject_new(g_value_get_object(value));
else
break;
case G_TYPE_CHAR: {
gint8 val = g_value_get_char(value);
return PYGLIB_PyUnicode_FromStringAndSize((char *)&val, 1);
}
case G_TYPE_UCHAR: {
guint8 val = g_value_get_uchar(value);
return PYGLIB_PyBytes_FromStringAndSize((char *)&val, 1);
}
case G_TYPE_BOOLEAN: {
return PyBool_FromLong(g_value_get_boolean(value));
}
case G_TYPE_INT:
return PYGLIB_PyLong_FromLong(g_value_get_int(value));
case G_TYPE_UINT:
{
/* in Python, the Int object is backed by a long. If a
long can hold the whole value of an unsigned int, use
an Int. Otherwise, use a Long object to avoid overflow.
This matches the ULongArg behavior in codegen/argtypes.h */
#if (G_MAXUINT <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) g_value_get_uint(value));
#else
return PyLong_FromUnsignedLong((gulong) g_value_get_uint(value));
#endif
}
case G_TYPE_LONG:
return PYGLIB_PyLong_FromLong(g_value_get_long(value));
case G_TYPE_ULONG:
{
gulong val = g_value_get_ulong(value);
if (val <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) val);
else
return PyLong_FromUnsignedLong(val);
}
case G_TYPE_INT64:
{
gint64 val = g_value_get_int64(value);
if (G_MINLONG <= val && val <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) val);
else
return PyLong_FromLongLong(val);
}
case G_TYPE_UINT64:
{
guint64 val = g_value_get_uint64(value);
if (val <= G_MAXLONG)
return PYGLIB_PyLong_FromLong((glong) val);
else
return PyLong_FromUnsignedLongLong(val);
}
case G_TYPE_ENUM:
return pyg_enum_from_gtype(G_VALUE_TYPE(value), g_value_get_enum(value));
case G_TYPE_FLAGS:
return pyg_flags_from_gtype(G_VALUE_TYPE(value), g_value_get_flags(value));
case G_TYPE_FLOAT:
return PyFloat_FromDouble(g_value_get_float(value));
case G_TYPE_DOUBLE:
return PyFloat_FromDouble(g_value_get_double(value));
case G_TYPE_STRING:
{
const gchar *str = g_value_get_string(value);
if (str)
return PYGLIB_PyUnicode_FromString(str);
Py_INCREF(Py_None);
return Py_None;
}
case G_TYPE_POINTER:
return pyg_pointer_new(G_VALUE_TYPE(value),
g_value_get_pointer(value));
case G_TYPE_BOXED: {
PyGTypeMarshal *bm;
if (G_VALUE_HOLDS(value, PY_TYPE_OBJECT)) {
PyObject *ret = (PyObject *)g_value_dup_boxed(value);
if (ret == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
return ret;
} else if (G_VALUE_HOLDS(value, G_TYPE_VALUE)) {
GValue *n_value = g_value_get_boxed (value);
return pyg_value_as_pyobject(n_value, copy_boxed);
} else if (G_VALUE_HOLDS(value, G_TYPE_VALUE_ARRAY)) {
GValueArray *array = (GValueArray *) g_value_get_boxed(value);
PyObject *ret = PyList_New(array->n_values);
int i;
for (i = 0; i < array->n_values; ++i)
PyList_SET_ITEM(ret, i, pyg_value_as_pyobject
(array->values + i, copy_boxed));
return ret;
} else if (G_VALUE_HOLDS(value, G_TYPE_GSTRING)) {
GString *string = (GString *) g_value_get_boxed(value);
PyObject *ret = PYGLIB_PyUnicode_FromStringAndSize(string->str, string->len);
return ret;
}
bm = pyg_type_lookup(G_VALUE_TYPE(value));
if (bm) {
return bm->fromvalue(value);
} else {
if (copy_boxed)
return pyg_boxed_new(G_VALUE_TYPE(value),
g_value_get_boxed(value), TRUE, TRUE);
else
return pyg_boxed_new(G_VALUE_TYPE(value),
g_value_get_boxed(value),FALSE,FALSE);
}
}
case G_TYPE_PARAM:
return pyg_param_spec_new(g_value_get_param(value));
case G_TYPE_OBJECT:
return pygobject_new(g_value_get_object(value));
default:
{
PyGTypeMarshal *bm;
if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))))
return bm->fromvalue(value);
break;
}
}
g_snprintf(buf, sizeof(buf), "unknown type %s",
g_type_name(G_VALUE_TYPE(value)));
PyErr_SetString(PyExc_TypeError, buf);
return NULL;
}
