path: root/gtk/gdkwindow.override

/* -*- Mode: C; c-basic-offset: 4 -*-
 * pygtk- Python bindings for the GTK toolkit.
 *
 *   gdkwindow.override: gtk.gdk.Window overrides
 *
 * 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
 */
%%
override gdk_window_new kwargs
static int
_wrap_gdk_window_new(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "parent", "width", "height", "window_type",
			      "event_mask", "wclass", "title", "x", "y",
			      "visual", "colormap", "cursor", "wmclass_name",
			      "wmclass_class", "override_redirect", NULL };
    GdkWindowAttr attr = { NULL, 0, -1, -1, 0, 0, -1, NULL, NULL, 0, NULL,
			   NULL, NULL, -1 };
    guint attr_mask = 0;
    GdkWindow *parent = NULL;
    PyGObject *py_parent = NULL;
    PyObject *py_window_type = NULL;
    PyObject *py_wclass = NULL;
    PyGObject *py_visual = NULL;
    PyGObject *py_colormap = NULL;
    PyGObject *py_cursor = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
				     "OiiOiO|siiO!O!Ossb:GdkWindow.__init__",
				     kwlist, &py_parent, &attr.width,
				     &attr.height, &py_window_type,
				     &attr.event_mask, &py_wclass,
				     &attr.title, &attr.x, &attr.y,
				     &PyGdkVisual_Type, &py_visual,
				     &PyGdkColormap_Type, &py_colormap,
				     &py_cursor,
				     &attr.wmclass_name,
				     &attr.wmclass_class,
				     &attr.override_redirect))
	return -1;

    if (py_parent && pygobject_check(py_parent, &PyGdkWindow_Type))
        parent = GDK_WINDOW(py_parent->obj);
    else if ((PyObject *)py_parent != Py_None) {
        PyErr_SetString(PyExc_TypeError, "parent must be a GdkWindow or None");
        return -1;
    }
    
    if (pyg_enum_get_value(GDK_TYPE_WINDOW_CLASS,
			   py_wclass, (gint *)&attr.wclass))
        return -1;
    if (pyg_enum_get_value(GDK_TYPE_WINDOW_TYPE,
			   py_window_type, (gint *)&attr.window_type))
        return -1;
    
    if (attr.title)
	attr_mask |= GDK_WA_TITLE;
    if (attr.x != -1)
	attr_mask |= GDK_WA_X;
    if (attr.y != -1)
	attr_mask |= GDK_WA_Y;
    if (py_visual) {
	attr.visual = GDK_VISUAL(py_visual->obj);
	attr_mask |= GDK_WA_VISUAL;
    }
    if (py_colormap) {
	attr.colormap = GDK_COLORMAP(py_colormap->obj);
	attr_mask |= GDK_WA_COLORMAP;
    }
    if (py_cursor) {
	if (!pyg_boxed_check(py_cursor, GDK_TYPE_CURSOR)) {
	    PyErr_SetString(PyExc_TypeError, "cursor should be a GdkCursor");
	    return -1;
	}
	attr.cursor = pyg_boxed_get(py_cursor, GdkCursor);
	attr_mask |= GDK_WA_CURSOR;
    }
    if (attr.wmclass_name && attr.wmclass_class)
	attr_mask |= GDK_WA_WMCLASS;
    if (attr.override_redirect != -1)
	attr_mask |= GDK_WA_NOREDIR;

    self->obj = (GObject *)gdk_window_new(parent, &attr, attr_mask);
    if (!self->obj) {
	PyErr_SetString(PyExc_RuntimeError,
			"could not create GdkWindow object");
	return -1;
    }

    g_object_ref(self->obj);

    pygobject_register_wrapper((PyObject *)self);
    return 0;
}
%%
override gdk_property_get kwargs

static GdkAtom atom_type = GDK_NONE, atom_pair_type = GDK_NONE;

static PyObject *
_wrap_gdk_property_get(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "property", "type", "pdelete", NULL };
    PyObject *py_property, *py_type = NULL;
    GdkAtom property, type;
    gint pdelete = FALSE;

    GdkAtom atype;
    gint aformat, alength;
    guchar *data;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "O|Oi:GdkWindow.property_get", kwlist,
                                     &py_property, &py_type, 
                                     &pdelete)) {
        return NULL;
    }
    property = pygdk_atom_from_pyobject(py_property);
    if (PyErr_Occurred())
        return NULL;

    type = pygdk_atom_from_pyobject(py_type);
    if (PyErr_Occurred())
        return NULL;

    if (gdk_property_get(GDK_WINDOW(self->obj), property, type, 0, 9999,
                         pdelete, &atype, &aformat, &alength, &data)) {
        /* success */
        PyObject *pdata = NULL;
        gint nelements, i;
        gchar *aname;
        PyObject *ret;

        switch (aformat) {
        case 8:
            if ((pdata = PyString_FromStringAndSize((char*)data,
						    alength)) == NULL)
                return NULL;
            break;
        case 16: {
            short *data16;

            data16 = (short *)data;
            nelements = alength / sizeof(short);
            if ((pdata = PyList_New(nelements)) == NULL)
                return NULL;
            for (i = 0; i < nelements; i++)
                PyList_SetItem(pdata, i, PyInt_FromLong(data16[i]));
            break;
        }
        case 32: {
            if (atom_type == GDK_NONE) {
                atom_type = gdk_atom_intern("ATOM", TRUE);
                atom_pair_type = gdk_atom_intern("ATOM_PAIR", TRUE);
            }

            /* special handling for atom types */
            if (atype == atom_type || atype == atom_pair_type) {
                GdkAtom *data32;

                data32 = (GdkAtom *)data;
                nelements = alength / sizeof(GdkAtom);
                if ((pdata = PyList_New(nelements)) == NULL)
                    return NULL;
                for (i = 0; i < nelements; i++) {
                    aname = gdk_atom_name(data32[i]);
                    PyList_SetItem(pdata, i, PyString_FromString(aname));
                    g_free(aname);
                }
            } else {
                long *data32;

                data32 = (long *)data;
                nelements  = alength / sizeof(long);
                if ((pdata = PyList_New(nelements)) == NULL)
                    return NULL;
                for (i = 0; i < nelements; i++)
                    PyList_SetItem(pdata, i, PyInt_FromLong(data32[i]));
            }
            break;
        }
        default:
            g_warning("got a property format != 8, 16 or 32");
            g_assert_not_reached();
        }
        g_free(data);
        aname = gdk_atom_name(atype);
        ret = Py_BuildValue("(NiN)", PyString_FromString(aname), aformat,
                            pdata);
        g_free(aname);
        return ret;
    } else {
        Py_INCREF(Py_None);
        return Py_None;
    }
}
%%
override gdk_property_change kwargs
static PyObject *
_wrap_gdk_property_change(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "property","type","format","mode","data",NULL };
    PyObject *py_property, *py_type;
    GdkAtom property, type;
    gint format;
    PyObject *py_mode, *pdata;
    GdkPropMode mode;
    guchar *data = NULL;
    gint nelements;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "OOiOO:GdkWindow.property_change", kwlist,
                                     &py_property, &py_type, &format, &py_mode,
                                     &pdata)) {
        return NULL;
    }
    property = pygdk_atom_from_pyobject(py_property);
    if (PyErr_Occurred())
        return NULL;

    type = pygdk_atom_from_pyobject(py_type);
    if (PyErr_Occurred())
        return NULL;
    
    if (pyg_enum_get_value(GDK_TYPE_PROP_MODE, py_mode, (gint *)&mode))
        return NULL;
    switch (format) {
    case 8:
        if (!PyString_Check(pdata)) {
            PyErr_SetString(PyExc_TypeError, "data not a string and format=8");
            return NULL;
        }
        data = (guchar*)PyString_AsString(pdata);
        nelements = PyString_Size(pdata);
        break;
    case 16: {
        short *data16;
        gint i;

        if (!PySequence_Check(pdata)) {
            PyErr_SetString(PyExc_TypeError,
                            "data not a sequence and format=16");
            return NULL;
        }
        nelements = PySequence_Length(pdata);
        data16 = g_new(short, nelements);
        data = (guchar *)data16;
        for (i = 0; i < nelements; i++) {
            PyObject *item = PySequence_GetItem(pdata, i);

            if (item) data16[i] = PyInt_AsLong(item);
            if (!item || PyErr_Occurred()) {
                Py_XDECREF(item);
                g_free(data16);
                PyErr_Clear();
                PyErr_SetString(PyExc_TypeError,"data element not an int");
                return NULL;
            }
            Py_DECREF(item);
        }
        break;
    }
    case 32: {
        gint i;

        if (!PySequence_Check(pdata)) {
            PyErr_SetString(PyExc_TypeError,
                            "data not a sequence and format=32");
            return NULL;
        }
        nelements = PySequence_Length(pdata);

        if (atom_type == GDK_NONE) {
            atom_type = gdk_atom_intern("ATOM", TRUE);
            atom_pair_type = gdk_atom_intern("ATOM_PAIR", TRUE);
        }

        /* special handling for atom types */
        if (type == atom_type || type == atom_pair_type) {
            GdkAtom *data32 = g_new(GdkAtom, nelements);

            data = (guchar *)data32;
            for (i = 0; i < nelements; i++) {
                PyObject *item = PySequence_GetItem(pdata, i);

                if (item) data32[i] = pygdk_atom_from_pyobject(item);
                if (!item || PyErr_Occurred()) {
                    Py_XDECREF(item);
                    g_free(data32);
                    PyErr_Clear();
                    PyErr_SetString(PyExc_TypeError,"data element not an atom");
                    return NULL;
                }
                Py_DECREF(item);
            }
        } else {
            long *data32 = g_new(long, nelements);

            data = (guchar *)data32;
            for (i = 0; i < nelements; i++) {
                PyObject *item = PySequence_GetItem(pdata, i);

                if (item) data32[i] = PyInt_AsLong(item);
                if (!item || PyErr_Occurred()) {
                    Py_XDECREF(item);
                    g_free(data32);
                    PyErr_Clear();
                    PyErr_SetString(PyExc_TypeError,"data element not an int");
                    return NULL;
                }
                Py_DECREF(item);
            }
        }
        break;
    }
    default:
        PyErr_SetString(PyExc_TypeError, "format must be 8, 16 or 32");
        return NULL;
        break;
    }
    gdk_property_change(GDK_WINDOW(self->obj), property, type, format, mode,
                        data, nelements);
    if (format != 8)
        g_free(data);
    Py_INCREF(Py_None);
    return Py_None;
}
%%
override gdk_window_set_geometry_hints kwargs
static PyObject *
_wrap_gdk_window_set_geometry_hints(PyGObject *self, PyObject *args,
                                    PyObject *kwargs)
{
    static char *kwlist[] = { "min_width", "min_height",
                              "max_width", "max_height", "base_width",
                              "base_height", "width_inc", "height_inc",
                              "min_aspect", "max_aspect", NULL };
    gint min_width = -1, min_height = -1, max_width = -1, max_height = -1;
    gint base_width = -1, base_height = -1, width_inc = -1, height_inc = -1;
    gdouble min_aspect = -1.0, max_aspect = -1.0;
    GdkGeometry geometry = { 0 };
    GdkWindowHints geom_mask = 0;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
				     "|iiiiiiiidd:GdkWindow.set_geometry_hints",
				     kwlist, &min_width, &min_height,
				     &max_width, &max_height,
                                     &base_width, &base_height, &width_inc,
                                     &height_inc, &min_aspect, &max_aspect))
        return NULL;
    if (min_width >= 0 || min_height >= 0) {
        geometry.min_width = MAX(min_width, 0);
        geometry.min_height = MAX(min_height, 0);
        geom_mask |= GDK_HINT_MIN_SIZE;
    }
    if (max_width >= 0 || max_height >= 0) {
        geometry.max_width = MAX(max_width, 0);
        geometry.max_height = MAX(max_height, 0);
        geom_mask |= GDK_HINT_MAX_SIZE;
    }
    if (base_width >= 0 || base_height >= 0) {
        geometry.base_width = MAX(base_width, 0);
        geometry.base_height = MAX(base_height, 0);
        geom_mask |= GDK_HINT_BASE_SIZE;
    }
    if (width_inc >= 0 || height_inc >= 0) {
        geometry.width_inc = MAX(width_inc, 0);
        geometry.height_inc = MAX(height_inc, 0);
        geom_mask |= GDK_HINT_RESIZE_INC;
    }
    if (min_aspect >= 0.0 || max_aspect >= 0.0) {
        if (min_aspect <= 0.0 || max_aspect <= 0.0) {
            PyErr_SetString(PyExc_TypeError, "aspect ratios must be positive");
            return NULL;
        }
        geometry.min_aspect = min_aspect;
        geometry.max_aspect = max_aspect;
        geom_mask |= GDK_HINT_ASPECT;
    }
    gdk_window_set_geometry_hints(GDK_WINDOW(self->obj), &geometry, geom_mask);
    Py_INCREF(Py_None);
    return Py_None;
}
%%
override gdk_window_get_geometry noargs
static PyObject *
_wrap_gdk_window_get_geometry(PyGObject *self)
{
    gint x, y, width, height, depth;

    gdk_window_get_geometry(GDK_WINDOW(self->obj), &x, &y, &width, &height,
                            &depth);
    return Py_BuildValue("(iiiii)", x, y, width, height, depth);
}
%%
override gdk_window_get_position noargs
static PyObject *
_wrap_gdk_window_get_position(PyGObject *self)
{
    gint x, y;

    gdk_window_get_position(GDK_WINDOW(self->obj), &x, &y);
    return Py_BuildValue("(ii)", x, y);
}
%%
override gdk_window_get_origin noargs
static PyObject *
_wrap_gdk_window_get_origin(PyGObject *self)
{
    gint x, y;

    gdk_window_get_origin(GDK_WINDOW(self->obj), &x, &y);
    return Py_BuildValue("(ii)", x, y);
}
%%
override gdk_window_get_deskrelative_origin noargs
static PyObject *
_wrap_gdk_window_get_deskrelative_origin(PyGObject *self)
{
    gint x, y;

    gdk_window_get_deskrelative_origin(GDK_WINDOW(self->obj), &x, &y);
    return Py_BuildValue("(ii)", x, y);
}
%%
override gdk_window_get_root_origin noargs
static PyObject *
_wrap_gdk_window_get_root_origin(PyGObject *self)
{
    gint x, y;

    gdk_window_get_root_origin(GDK_WINDOW(self->obj), &x, &y);
    return Py_BuildValue("(ii)", x, y);
}
%%
override gdk_window_get_pointer noargs
static PyObject *
_wrap_gdk_window_get_pointer(PyGObject *self)
{
    gint x, y;
    GdkModifierType mask;

    gdk_window_get_pointer(GDK_WINDOW(self->obj), &x, &y, &mask);
    return Py_BuildValue("(iiN)", x, y,
                         pyg_flags_from_gtype(GDK_TYPE_MODIFIER_TYPE, mask));
}
%%
ignore gdk_window_peek_children
%%
override gdk_window_get_children noargs
static PyObject *
_wrap_gdk_window_get_children(PyGObject *self)
{
    GList *children, *tmp;
    PyObject *list;

    children = gdk_window_get_children(GDK_WINDOW(self->obj));
    list = PyList_New(0);
    for (tmp = children; tmp != NULL; tmp = tmp->next) {
        PyObject *item = pygobject_new((GObject *)tmp->data);

        PyList_Append(list, item);
        Py_DECREF(item);
    }
    g_list_free(children);
    return list;
}
%%
override gdk_window_set_icon_list kwargs
static PyObject *
_wrap_gdk_window_set_icon_list(PyGObject *self, PyObject *args,
			       PyObject *kwargs)
{
    static char *kwlist[] = { "pixbufs", NULL };
    PyObject *py_pixbufs;
    gint length, i;
    GList *pixbufs = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GdkWindow.set_icon_list",
				     kwlist, &py_pixbufs))
	return NULL;
    if (!(py_pixbufs = PySequence_Fast(py_pixbufs,
				"pixbufs must be a sequence of pixbufs")))
	return NULL;
    length = PySequence_Fast_GET_SIZE(py_pixbufs);
    for (i = length - 1; i >= 0; i--) {
	PyObject *item = PySequence_Fast_GET_ITEM(py_pixbufs, i);

	if (!pygobject_check(item, &PyGdkPixbuf_Type)) {
	    g_list_free(pixbufs);
	    Py_DECREF(py_pixbufs);
	    PyErr_SetString(PyExc_TypeError,
			    "pixbufs must be a sequence of pixbufs");
	    return NULL;
	}
	pixbufs = g_list_prepend(pixbufs, GDK_PIXBUF(pygobject_get(item)));
    }
    gdk_window_set_icon_list(GDK_WINDOW(self->obj), pixbufs);
    g_list_free(pixbufs);
    Py_DECREF(py_pixbufs);
    Py_INCREF(Py_None);
    return Py_None;
}
%%
override gdk_window_get_frame_extents noargs
static PyObject *
_wrap_gdk_window_get_frame_extents(PyGObject *self)
{
    GdkRectangle rect = {0, 0, 0, 0};

    gdk_window_get_frame_extents(GDK_WINDOW(self->obj), &rect);

    return pyg_boxed_new(GDK_TYPE_RECTANGLE, &rect, TRUE, TRUE);
}
%%
override gdk_window_get_decorations noargs
static PyObject *
_wrap_gdk_window_get_decorations(PyGObject *self)
{
    GdkWMDecoration decor = 0; 

    gdk_window_get_decorations(GDK_WINDOW(self->obj), &decor);

    return pyg_flags_from_gtype(GDK_TYPE_WM_DECORATION, decor);
}
%%
override gdk_window_get_toplevels noargs
static PyObject *
_wrap_gdk_window_get_toplevels(PyGObject *self)
{
    GList *topl;
    guint ntopl;
    int i;
    PyObject *list;

    topl = gdk_window_get_toplevels();
    ntopl = g_list_length(topl);

    if ((list = PyList_New(ntopl)) == NULL)
	return NULL;

    for (i = 0; i < ntopl; i++) {
	PyObject *item;

	item = pygobject_new((GObject *)g_list_nth_data(topl, i));
	PyList_SetItem(list, i, item);
    }

    g_list_free(topl);

    return list;
}
%%
override gdk_window_set_user_data kwargs

static void __gdk_window_set_user_data_window_destroyed(gpointer widget,
                                                        GObject *window);

static void
__gdk_window_set_user_data_widget_destroyed(gpointer  window,
                                            GObject  *widget)
{
    gpointer old_user_data = NULL;
    gdk_window_get_user_data(GDK_WINDOW(window), &old_user_data);
    gdk_window_set_user_data(GDK_WINDOW(window), NULL);
    g_object_weak_unref(G_OBJECT(window), __gdk_window_set_user_data_window_destroyed,
                        widget);
}

static void
__gdk_window_set_user_data_window_destroyed(gpointer widget,
                                            GObject *window)
{
    g_object_weak_unref(G_OBJECT(widget), __gdk_window_set_user_data_widget_destroyed,
                        window);
}

static PyObject *
_wrap_gdk_window_set_user_data(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "user_data", NULL };
    PyGObject *user_data;
    gpointer old_user_data = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
				     "O:GdkWindow.set_user_data",
				     kwlist, &user_data))
        return NULL;

    if ((PyObject *)user_data != Py_None &&
	!pygobject_check(user_data, &PyGtkWidget_Type)) {
	PyErr_SetString(PyExc_TypeError, "Only GtkWidgets are allowed as user data."
                        " Maybe you want to use GObject.set_data()");
	return NULL;
    }
      /* Remove any existing weak references */
    gdk_window_get_user_data(GDK_WINDOW(self->obj), &old_user_data);
    if (old_user_data) {
        g_object_weak_unref(old_user_data, __gdk_window_set_user_data_widget_destroyed, self->obj);
        g_object_weak_unref(self->obj, __gdk_window_set_user_data_window_destroyed, old_user_data);
    }

    if ((PyObject *)user_data != Py_None) {
	  /* Add new weak references */
	gdk_window_set_user_data(GDK_WINDOW(self->obj), GTK_WIDGET(user_data->obj));
	g_object_weak_ref(user_data->obj, __gdk_window_set_user_data_widget_destroyed, self->obj);
	g_object_weak_ref(self->obj, __gdk_window_set_user_data_window_destroyed, user_data->obj);
    } else {
	gdk_window_set_user_data(GDK_WINDOW(self->obj), NULL);
    }

    Py_INCREF(Py_None);
    return Py_None;
}
%%
override gdk_window_get_user_data noargs
static PyObject *
_wrap_gdk_window_get_user_data(PyGObject *self)
{
    gpointer user_data = NULL;
    gdk_window_get_user_data(GDK_WINDOW(self->obj), &user_data);
    if (GTK_IS_WIDGET(user_data)) {
	return pygobject_new(G_OBJECT(user_data));
    } else {
	PyErr_SetString(PyExc_ValueError, "could not convert the user data");
	return NULL;
    }
}
%%
override gdk_window_add_filter kwargs
static int
pygdk_filter_func_marshal(GdkXEvent *xevent,
			  GdkEvent *event,
			  PyGtkCustomNotify *cunote)
{
    PyGILState_STATE state;
    PyObject *ret;
    PyObject *pyevent;
    int retval;
    
    state = pyg_gil_state_ensure();
    
    pyevent = pyg_boxed_new(GDK_TYPE_EVENT, event, TRUE, TRUE);

    if (cunote->data)
        ret = PyObject_CallFunction(cunote->func, "OO", pyevent, cunote->data);

    else
        ret = PyObject_CallFunction(cunote->func, "O", pyevent);
    
    if (ret == NULL) {
        PyErr_Print();
	retval = GDK_FILTER_CONTINUE;
    } else {
	retval = PyInt_AsLong(ret);
    }
    
    pyg_gil_state_release(state);

    return retval;
}
static PyObject*
_wrap_gdk_window_add_filter(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "entries", "callback_data", NULL };
    PyGtkCustomNotify *cunote;
    PyObject *pyfunc, *pydata = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "O|O:GdkWindow.add_filter", kwlist,
                                     &pyfunc, &pydata))
        return NULL;
     
    
    cunote = g_new0(PyGtkCustomNotify, 1);
    cunote->func = pyfunc;
    cunote->data = pydata;
    Py_INCREF(cunote->func);
    Py_XINCREF(cunote->data);

    g_object_weak_ref(G_OBJECT(self->obj),
		      (GWeakNotify) pygtk_custom_destroy_notify,
		      cunote);
    
    gdk_window_add_filter (GDK_WINDOW(self->obj),
			   (GdkFilterFunc)pygdk_filter_func_marshal,
			   cunote);

    Py_INCREF(Py_None);
    return Py_None;
}