static int
add_templates (gpointer gclass, PyObject * templates)
{
if (PyTuple_Check (templates)) {
gint i, len;
PyGObject *templ;
len = PyTuple_Size (templates);
if (len == 0)
return 0;
for (i = 0; i < len; i++) {
templ = (PyGObject *) PyTuple_GetItem (templates, i);
if (!pygobject_check (templ, &PyGObject_Type)) {
PyObject *repr = PyObject_Repr ((PyObject *) templ);
#if PY_VERSION_HEX < 0x03000000
PyErr_Format (PyExc_TypeError, "expected GObject but got %s",
PyString_AsString (repr));
#else
PyErr_Format (PyExc_TypeError, "expected GObject but got %s",
_PyUnicode_AsString (repr));
#endif
Py_DECREF (repr);
return -1;
} else if (!GST_IS_PAD_TEMPLATE (pygobject_get (templ))) {
gchar *error =
g_strdup_printf
("entries for __gsttemplates__ must be of type GstPadTemplate (%s)",
G_OBJECT_TYPE_NAME (pygobject_get (templ)));
PyErr_SetString (PyExc_TypeError, error);
g_free (error);
return -1;
}
}
for (i = 0; i < len; i++) {
templ = (PyGObject *) PyTuple_GetItem (templates, i);
gst_element_class_add_pad_template (gclass,
GST_PAD_TEMPLATE (templ->obj));
}
return 0;
} else if (!pygobject_check (templates, &PyGObject_Type) ||
GST_IS_PAD_TEMPLATE (pygobject_get (templates)) == FALSE) {
PyErr_SetString (PyExc_TypeError,
"entry for __gsttemplates__ must be of type GstPadTemplate");
return -1;
}
gst_element_class_add_pad_template (gclass,
GST_PAD_TEMPLATE (pygobject_get (templates)));
return 0;
}
static PyObject * py_set_strut(PyObject * self, PyObject * args) {
PyObject * py_gdk_window;
PyObject * py_list;
if (!PyArg_ParseTuple(args, "OO", &py_gdk_window, &py_list))
return NULL;
if(!pygobject_check(py_gdk_window, pygobject_lookup_class(GDK_TYPE_WINDOW))) {
return NULL;
}
if(!PyList_Check(py_list)) {
return NULL;
}
if (PyList_Size(py_list) == 4) {
/* if _net_wm_strut */
long strut[4];
for (int i = 0; i < 4; ++i) {
PyObject * v = PyList_GetItem(py_list, i);
if (PyLong_Check(v)) {
strut[i] = PyLong_AsLong(v);
} else {
return NULL;
}
}
GdkAtom cardinal = gdk_atom_intern("CARDINAL", FALSE);
GdkAtom _net_wm_strut = gdk_atom_intern("_NET_WM_STRUT", FALSE);
gdk_property_change(GDK_WINDOW(pygobject_get(py_gdk_window)),
_net_wm_strut, cardinal, 32, GDK_PROP_MODE_REPLACE,
(guchar*) strut, 4);
} else if (PyList_Size(py_list) == 12) {
/* if _net_wm_strut_partial */
long strut_partial[12];
for (int i = 0; i < 12; ++i) {
PyObject * v = PyList_GetItem(py_list, i);
if (PyLong_Check(v)) {
strut_partial[i] = PyLong_AsLong(v);
} else {
return NULL;
}
}
GdkAtom cardinal = gdk_atom_intern("CARDINAL", FALSE);
GdkAtom _net_wm_strut_partial = gdk_atom_intern("_NET_WM_STRUT_PARTIAL", FALSE);
gdk_property_change(GDK_WINDOW(pygobject_get(py_gdk_window)),
_net_wm_strut_partial, cardinal, 32, GDK_PROP_MODE_REPLACE,
(guchar*) strut_partial, 12);
} else {
/* else error */
return NULL;
}
Py_RETURN_NONE;
}
int
_moo_pyobject_to_object_array (PyObject *obj,
MooObjectArray **dest)
{
int len, i;
PyTypeObject *type;
type = moo_get_pygobject_type ();
g_return_val_if_fail (type != NULL, FALSE);
if (obj == Py_None)
{
*dest = NULL;
return TRUE;
}
if (!PySequence_Check (obj))
{
PyErr_SetString (PyExc_TypeError,
"argument must be a sequence");
return FALSE;
}
len = PySequence_Size (obj);
if (len < 0)
{
PyErr_SetString (PyExc_RuntimeError,
"got negative length of a sequence");
return FALSE;
}
for (i = 0; i < len; ++i)
{
PyObject *item = PySequence_ITEM (obj, i);
g_return_val_if_fail (item != NULL, FALSE);
// TODO: this doesn't check element types
if (!pygobject_check (item, type))
{
PyErr_SetString (PyExc_TypeError,
"argument must be a sequence of objects");
return FALSE;
}
}
*dest = _moo_pyobject_to_object_array_no_check (obj, len);
return TRUE;
}
static PyObject * py_print_type(PyObject * self, PyObject * args) {
PyObject * pyobj;
if (!PyArg_ParseTuple(args, "O", &pyobj))
return NULL;
if(pygobject_check(pyobj, pygobject_lookup_class(CLUTTER_TYPE_STAGE))) {
GObject * obj = pygobject_get(pyobj);
GType t = G_OBJECT_TYPE(obj);
printf("type = %s\n", g_type_name(t));
} else {
printf("unknown object\n");
}
Py_RETURN_NONE;
}
static PyObject * py_gdk_add_filter(PyObject * self, PyObject * args) {
PyObject * pyobj; // the GdkWindow
PyObject * func; // the function to call
if (!PyArg_ParseTuple(args, "OO", &pyobj, &func))
return NULL;
if (!PyCallable_Check(func)) {
PyErr_SetString(PyExc_TypeError, "parameter must be callable");
return NULL;
}
if(pygobject_check(pyobj, pygobject_lookup_class(GDK_TYPE_WINDOW)) && PyCallable_Check(func)) {
GdkWindow * window = GDK_WINDOW(pygobject_get(pyobj));
Py_INCREF(func);
Py_INCREF(func);
Py_INCREF(func);
Py_INCREF(func);
Py_INCREF(func);
Py_INCREF(func);
Py_INCREF(func);
printf("YYYY %d\n", ((PyObject*)(func))->ob_refcnt);
// PyObject_Print(func, stdout, 0);
// printf("\nXXXX %p\n", func);
// PyObject* result = PyObject_CallFunction(func, "i", 10);
// printf("return = %p\n", result);
// if (result != NULL)
// PyObject_Print(result, stdout, 0);
// else
// return NULL;
//
// Py_DECREF(result);
g_func = func;
gdk_window_add_filter(window, &call_python_filter, (gpointer)func);
} else {
printf("unknown object\n");
}
Py_RETURN_NONE;
}
static GtkWidget *
nemo_python_object_get_widget (NemoLocationWidgetProvider *provider,
const char *uri,
GtkWidget *window)
{
NemoPythonObject *object = (NemoPythonObject*)provider;
GtkWidget *ret = NULL;
PyObject *py_ret = NULL;
PyGObject *py_ret_gobj;
PyObject *py_uri = NULL;
PyGILState_STATE state = pyg_gil_state_ensure();
debug_enter();
CHECK_OBJECT(object);
CHECK_METHOD_NAME(object->instance);
py_uri = PyString_FromString(uri);
py_ret = PyObject_CallMethod(object->instance, METHOD_PREFIX METHOD_NAME,
"(NN)", py_uri,
pygobject_new((GObject *)window));
HANDLE_RETVAL(py_ret);
py_ret_gobj = (PyGObject *)py_ret;
if (!pygobject_check(py_ret_gobj, &PyGtkWidget_Type))
{
PyErr_SetString(PyExc_TypeError,
METHOD_NAME "should return a gtk.Widget");
goto beach;
}
ret = (GtkWidget *)g_object_ref(py_ret_gobj->obj);
beach:
Py_XDECREF(py_ret);
pyg_gil_state_release(state);
return ret;
}
static int
pygtk_style_helper_setitem(PyGtkStyleHelper_Object *self, Py_ssize_t pos,
PyObject *value)
{
extern PyTypeObject PyGdkGC_Type;
extern PyTypeObject PyGdkPixmap_Type;
if (pos < 0) pos += NUM_STATES;
if (pos < 0 || pos >= NUM_STATES) {
PyErr_SetString(PyExc_IndexError, "index out of range");
return -1;
}
switch (self->type) {
case STYLE_COLOUR_ARRAY:
{
GdkColor *array = (GdkColor *)self->array;
if (!pyg_boxed_check(value, GDK_TYPE_COLOR)) {
PyErr_SetString(PyExc_TypeError, "can only assign a GdkColor");
return -1;
}
array[pos] = *pyg_boxed_get(value, GdkColor);
return 0;
}
case STYLE_GC_ARRAY:
{
GdkGC **array = (GdkGC **)self->array;
if (!pygobject_check(value, &PyGdkGC_Type)) {
PyErr_SetString(PyExc_TypeError, "can only assign a GdkGC");
return -1;
}
if (array[pos]) {
g_object_unref(array[pos]);
}
array[pos] = GDK_GC(g_object_ref(pygobject_get(value)));
return 0;
}
case STYLE_PIXMAP_ARRAY:
{
GdkPixmap **array = (GdkPixmap **)self->array;
GdkPixmap *cvalue = NULL;
if (pygobject_check(value, &PyGdkPixmap_Type))
cvalue = GDK_PIXMAP(g_object_ref(pygobject_get(value)));
else if (PyLong_Check(value)) {
if (PyLong_AsLong(value) != GDK_PARENT_RELATIVE) {
PyErr_SetString(PyExc_TypeError,
"can only assign a GdkPixmap, None or "
"GDK_PARENT_RELATIVE");
return -1;
}
cvalue = (GdkPixmap*)GDK_PARENT_RELATIVE;
} else if (value != Py_None) {
PyErr_SetString(PyExc_TypeError,
"can only assign a GdkPixmap, None or "
"GDK_PARENT_RELATIVE");
return -1;
}
if (array[pos] && (long)array[pos] != GDK_PARENT_RELATIVE) {
g_object_unref(array[pos]);
}
array[pos] = cvalue;
return 0;
}
}
g_assert_not_reached();
return -1;
}
