1/* -*- Mode: C; c-basic-offset: 4 -*-
2 * pygtk- Python bindings for the GTK toolkit.
3 * Copyright (C) 1998-2003  James Henstridge
4 *
5 *   gdk.override: overrides for the gtk.gdk module.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
20 * USA
21 */
22%%
23headers
24#ifdef HAVE_CONFIG_H
25#  include <config.h>
26#endif
27
28#define NO_IMPORT_PYGOBJECT
29#include "pygobject.h"
30#include <glib.h>
31#include <gdk/gdk.h>
32#include <gtk/gtk.h>
33#include <gdk-pixbuf/gdk-pixbuf.h>
34#include "pygtk-private.h"
35
36#if defined(GDK_WINDOWING_X11)
37#include <gdk/gdkx.h>
38#elif defined(GDK_WINDOWING_WIN32)
39#include <gdk/gdkwin32.h>
40#elif defined(GDK_WINDOWING_QUARTZ)
41#include <gdk/gdkquartz.h>
42#endif
43
44/* make GDK_DISPLAY() the case macro */
45#undef GDK_DISPLAY
46#define GDK_DISPLAY(object) (GDK_DISPLAY_OBJECT(object))
47
48#ifdef HAVE_NUMPY
49#  include <numpy/arrayobject.h>
50static int have_numpy(void);
51#endif
52
53extern PyTypeObject PyGtkWidget_Type;
54
55#ifdef HAVE_PYCAIRO
56# include <pylcairo.h>
57extern Pycairo_CAPI_t *Pycairo_CAPI;
58extern PyTypeObject PyGdkCairoContext_Type;
59#endif
60
61#ifndef GDK_TYPE_REGION
62GType
63pygdk_region_get_type (void)
64{
65  static GType our_type = 0;
66
67  if (our_type == 0)
68    our_type = g_boxed_type_register_static ("GdkRegion",
69					     (GBoxedCopyFunc)gdk_region_copy,
70					     (GBoxedFreeFunc)gdk_region_destroy);
71  return our_type;
72}
73#endif
74
75#ifndef GDK_TYPE_PIXBUF_SIMPLE_ANIM_ITER
76GType gtk_print_capabilites_get_type (void) G_GNUC_CONST;
77#define GDK_TYPE_PIXBUF_SIMPLE_ANIM_ITER (gdk_pixbuf_simple_anim_iter_get_type())
78#endif
79
80%%
81include
82  gdkcairo.override
83  gdkcolor.override
84  gdkdraw.override
85  gdkevent.override
86  gdkgc.override
87  gdkpixbuf.override
88  gdkrectangle.override
89  gdkwindow.override
90%%
91modulename gtk.gdk
92%%
93import gobject.GObject as PyGObject_Type
94import pango.Context as PyPangoContext_Type
95import pango.Font as PyPangoFont_Type
96import pango.Layout as PyPangoLayout_Type
97import pango.Renderer as PyPangoRenderer_Type
98import gio.AppLaunchContext as PyGAppLaunchContext_Type for GAppLaunchContext
99import gio.Icon as PyGIcon_Type for GIcon
100import gio.InputStream as PyGInputStream_Type
101import gio.Cancellable as PyGCancellable_Type
102%%
103ignore
104  gdk_window_set_debug_updates
105  gdk_region_destroy
106  gdk_atom_intern_static_string
107  gdk_pixbuf_from_pixdata
108%%
109ignore-glob
110  *_get_type
111  _*
112  *_ref
113  *_unref
114  gdk_spawn_*
115  *_libgtk_only
116  gdk_pixdata_*
117%%
118ignore-type
119  GdkPixmapObject
120  GdkWindowObject
121%%
122override gdk_threads_init noargs
123static PyObject *
124_wrap_gdk_threads_init(PyObject *self)
125{
126    if (pyg_enable_threads())
127        return NULL;
128    gdk_threads_init();
129    Py_INCREF(Py_None);
130    return Py_None;
131}
132%%
133override gdk_threads_enter noargs
134static PyObject *
135_wrap_gdk_threads_enter(PyObject *self)
136{
137    /* must allow threads while acquiring lock, or no other python
138     * code will execute while we wait! */
139    pyg_begin_allow_threads;
140    gdk_threads_enter();
141    pyg_end_allow_threads;
142
143    Py_INCREF(Py_None);
144    return Py_None;
145}
146%%
147override gdk_fontset_load kwargs
148static PyObject *
149_wrap_gdk_fontset_load(PyObject *self, PyObject *args, PyObject *kwargs)
150{
151    static char *kwlist[] = { "fontset_name", NULL };
152    char *fontset_name;
153
154    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:fontset_load", kwlist,
155                                     &fontset_name))
156        return NULL;
157
158    /* pyg_boxed_new handles NULL checking */
159    return pyg_boxed_new(GDK_TYPE_FONT, gdk_fontset_load(fontset_name),
160                         FALSE, TRUE);
161}
162%%
163override gdk_text_extents kwargs
164static PyObject *
165_wrap_gdk_text_extents(PyObject *self, PyObject *args, PyObject *kwargs)
166{
167    static char *kwlist[] = { "text", NULL };
168    gchar *text;
169    Py_ssize_t length;
170    gint lbearing, rbearing, width, ascent, descent;
171
172    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#:GdkFont.extents",
173                                     kwlist, &text, &length))
174        return NULL;
175    gdk_text_extents(pyg_boxed_get(self, GdkFont), text, length,
176                     &lbearing, &rbearing, &width, &ascent, &descent);
177    return Py_BuildValue("(iiiii)", lbearing, rbearing, width,
178                         ascent, descent);
179}
180%%
181override gdk_pixmap_create_from_xpm kwargs
182static PyObject *
183_wrap_gdk_pixmap_create_from_xpm(PyObject *self, PyObject *args,
184                                 PyObject *kwargs)
185{
186    static char *kwlist[] = { "window", "transparent_color", "filename", NULL};
187    PyGObject *window;
188    PyObject *py_trans_color, *ret;
189    GdkColor *trans_color = NULL;
190    gchar *filename;
191    GdkPixmap *pixmap;
192    GdkBitmap *mask;
193
194    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
195                                     "O!Os:pixmap_create_from_xpm", kwlist,
196                                     &PyGdkDrawable_Type, &window,
197                                     &py_trans_color, &filename))
198        return NULL;
199    if (pyg_boxed_check(py_trans_color, GDK_TYPE_COLOR))
200        trans_color = pyg_boxed_get(py_trans_color, GdkColor);
201    else if (py_trans_color != Py_None) {
202        PyErr_SetString(PyExc_TypeError,
203                        "transparent_color must be a colour or None");
204        return NULL;
205    }
206    pixmap = gdk_pixmap_create_from_xpm(GDK_DRAWABLE(window->obj), &mask,
207                                        trans_color, filename);
208    if (pixmap == NULL) {
209        PyErr_SetString(PyExc_IOError, "can't load pixmap");
210        return NULL;
211    }
212    ret = Py_BuildValue("(NN)",
213                        pygobject_new((GObject *)pixmap),
214                        pygobject_new((GObject *)mask));
215    g_object_unref(pixmap);
216    g_object_unref(mask);
217    return ret;
218}
219%%
220override gdk_pixmap_colormap_create_from_xpm kwargs
221static PyObject *
222_wrap_gdk_pixmap_colormap_create_from_xpm(PyObject *self, PyObject *args,
223                                          PyObject *kwargs)
224{
225    static char *kwlist[] = { "window", "colormap", "transparent_color",
226                              "filename", NULL };
227    PyObject *py_window, *py_colormap, *py_trans_color, *ret;
228    GdkDrawable *window = NULL;
229    GdkColormap *colormap = NULL;
230    GdkColor *trans_color = NULL;
231    gchar *filename;
232    GdkPixmap *pixmap;
233    GdkBitmap *mask;
234
235    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
236                                     "OOOs:pixmap_colormap_create_from_xpm",
237                                     kwlist, &py_window, &py_colormap,
238                                     &py_trans_color, &filename))
239        return NULL;
240    if (pygobject_check(py_window, &PyGdkDrawable_Type))
241        window = GDK_DRAWABLE(pygobject_get(py_window));
242    else if (py_window != Py_None) {
243        PyErr_SetString(PyExc_TypeError, "window must be a GdkDrawable or None");
244        return NULL;
245    }
246    if (pygobject_check(py_colormap, &PyGdkColormap_Type))
247        colormap = GDK_COLORMAP(pygobject_get(py_colormap));
248    else if (py_colormap != Py_None) {
249        PyErr_SetString(PyExc_TypeError,
250                        "colormap must be a GdkColormap or None");
251        return NULL;
252    }
253    if (pyg_boxed_check(py_trans_color, GDK_TYPE_COLOR))
254        trans_color = pyg_boxed_get(py_trans_color, GdkColor);
255    else if (py_trans_color != Py_None) {
256        PyErr_SetString(PyExc_TypeError,
257                        "transparent_color must be a colour or None");
258        return NULL;
259    }
260    pixmap = gdk_pixmap_colormap_create_from_xpm(window, colormap, &mask,
261                                                 trans_color, filename);
262    if (pixmap == NULL) {
263        PyErr_SetString(PyExc_IOError, "can't load pixmap");
264        return NULL;
265    }
266    ret = Py_BuildValue("(NN)",
267                        pygobject_new((GObject *)pixmap),
268                        pygobject_new((GObject *)mask));
269    g_object_unref(pixmap);
270    g_object_unref(mask);
271    return ret;
272}
273%%
274override gdk_pixmap_create_from_xpm_d kwargs
275static PyObject *
276_wrap_gdk_pixmap_create_from_xpm_d(PyObject *self, PyObject *args,
277                                   PyObject *kwargs)
278{
279    static char *kwlist[] = { "window", "transparent_color", "data", NULL };
280    PyGObject *window;
281    PyObject *py_trans_color, *py_data, *ret;
282    GdkColor *trans_color = NULL;
283    gchar **data;
284    int len, i;
285    GdkPixmap *pixmap;
286    GdkBitmap *mask;
287
288    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
289                                     "O!OO!:pixmap_create_from_xpm_d", kwlist,
290                                     &PyGdkDrawable_Type, &window,
291                                     &py_trans_color, &PyList_Type, &py_data))
292        return NULL;
293    if (pyg_boxed_check(py_trans_color, GDK_TYPE_COLOR))
294        trans_color = pyg_boxed_get(py_trans_color, GdkColor);
295    else if (py_trans_color != Py_None) {
296        PyErr_SetString(PyExc_TypeError,
297                        "transparent_color must be a colour or None");
298        return NULL;
299    }
300    len = PyList_Size(py_data);
301    data = g_new(gchar *, len);
302    for (i = 0; i < len; i ++) {
303        PyObject *item = PyList_GetItem(py_data, i);
304        if (!PyString_Check(item)) {
305            PyErr_SetString(PyExc_TypeError, "data items must be strings");
306            g_free(data);
307            return NULL;
308        }
309        data[i] = PyString_AsString(item);
310    }
311    pixmap = gdk_pixmap_create_from_xpm_d(GDK_DRAWABLE(window->obj), &mask,
312                                          trans_color, data);
313    g_free(data);
314    if (pixmap == NULL) {
315        PyErr_SetString(PyExc_IOError, "can't load pixmap");
316        return NULL;
317    }
318    ret = Py_BuildValue("(NN)",
319                        pygobject_new((GObject *)pixmap),
320                        pygobject_new((GObject *)mask));
321    g_object_unref(pixmap);
322    g_object_unref(mask);
323    return ret;
324}
325%%
326override gdk_pixmap_colormap_create_from_xpm_d kwargs
327static PyObject *
328_wrap_gdk_pixmap_colormap_create_from_xpm_d(PyObject *self, PyObject *args,
329                                            PyObject *kwargs)
330{
331    static char *kwlist[] = { "window", "colormap", "transparent_color",
332                              "data", NULL };
333    PyObject *py_window, *py_colormap, *py_trans_color, *py_data, *ret;
334    GdkDrawable *window = NULL;
335    GdkColormap *colormap = NULL;
336    GdkColor *trans_color = NULL;
337    gchar **data;
338    int len, i;
339    GdkPixmap *pixmap;
340    GdkBitmap *mask;
341
342    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
343                                     "OOOO!:pixmap_colormap_create_from_xpm_d",
344                                     kwlist, &py_window, &py_colormap,
345                                     &py_trans_color,
346                                     &PyList_Type, &py_data))
347        return NULL;
348    if (pygobject_check(py_window, &PyGdkDrawable_Type))
349        window = GDK_DRAWABLE(pygobject_get(py_window));
350    else if (py_window != Py_None) {
351        PyErr_SetString(PyExc_TypeError, "window must be a GdkDrawable or None");
352        return NULL;
353    }
354    if (pygobject_check(py_colormap, &PyGdkColormap_Type))
355        colormap = GDK_COLORMAP(pygobject_get(py_colormap));
356    else if (py_colormap != Py_None) {
357        PyErr_SetString(PyExc_TypeError,
358                        "colormap must be a GdkColormap or None");
359        return NULL;
360    }
361    if (pyg_boxed_check(py_trans_color, GDK_TYPE_COLOR))
362        trans_color = pyg_boxed_get(py_trans_color, GdkColor);
363    else if (py_trans_color != Py_None) {
364        PyErr_SetString(PyExc_TypeError,
365                        "transparent_color must be a colour or None");
366        return NULL;
367    }
368    len = PyList_Size(py_data);
369    data = g_new(gchar *, len);
370    for (i = 0; i < len; i ++) {
371        PyObject *item = PyList_GetItem(py_data, i);
372        if (!PyString_Check(item)) {
373            PyErr_SetString(PyExc_TypeError, "data items must be strings");
374            g_free(data);
375            return NULL;
376        }
377        data[i] = PyString_AsString(item);
378    }
379    pixmap = gdk_pixmap_colormap_create_from_xpm_d(window, colormap, &mask,
380                                                   trans_color, data);
381    g_free(data);
382    if (pixmap == NULL) {
383        PyErr_SetString(PyExc_IOError, "can't load pixmap");
384        return NULL;
385    }
386    ret = Py_BuildValue("(NN)",
387                        pygobject_new((GObject *)pixmap),
388                        pygobject_new((GObject *)mask));
389    g_object_unref(pixmap);
390    g_object_unref(mask);
391    return ret;
392}
393%%
394ignore gdk_cursor_new_from_pixmap
395%%
396override gdk_cursor_new kwargs
397static int
398_wrap_gdk_cursor_new(PyGBoxed *self, PyObject *args, PyObject *kwargs)
399{
400    static char *kwlist1[] = { "cursor_type", NULL };
401    static char *kwlist2[] = { "display", "cursor_type", NULL };
402    static char *kwlist3[] = { "display", "pixbuf", "x", "y", NULL };
403    static char *kwlist4[] = { "source", "mask", "fg", "bg", "x", "y", NULL };
404    PyObject *py_cursor_type;
405    PyGObject *py_display;
406    PyGObject *source, *mask, *pixbuf;
407    PyObject *fg, *bg;
408    gint x, y;
409
410    self->gtype = GDK_TYPE_CURSOR;
411    self->free_on_dealloc = FALSE;
412    self->boxed = NULL;
413
414    if (PyArg_ParseTupleAndKeywords(args, kwargs, "O:GdkCursor.__init__",
415				     kwlist1, &py_cursor_type)) {
416	GdkCursorType cursor_type;
417
418        if (pyg_enum_get_value(GDK_TYPE_CURSOR_TYPE, py_cursor_type,
419                               (gint *)&cursor_type))
420            return -1;
421        self->boxed = gdk_cursor_new(cursor_type);
422	goto done;
423    }
424
425    PyErr_Clear();
426
427    if (PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GdkCursor.__init__",
428				     kwlist2, &py_display, &py_cursor_type)) {
429
430	GdkCursorType cursor_type;
431
432	if (!pygobject_check(py_display, &PyGdkDisplay_Type)) {
433	    PyErr_SetString(PyExc_TypeError,
434			    "display should be a GdkDisplay");
435	    return -1;
436	}
437        if (pyg_enum_get_value(GDK_TYPE_CURSOR_TYPE, py_cursor_type,
438                               (gint *)&cursor_type))
439            return -1;
440        self->boxed = gdk_cursor_new_for_display(GDK_DISPLAY(py_display->obj),
441						 cursor_type);
442	goto done;
443    }
444
445    PyErr_Clear();
446
447    if (PyArg_ParseTupleAndKeywords(args, kwargs,
448				    "OOii:GdkCursor.__init__", kwlist3,
449				    &py_display, &pixbuf, &x, &y)) {
450
451	if (!pygobject_check(py_display, &PyGdkDisplay_Type)) {
452	    PyErr_SetString(PyExc_TypeError,
453			    "display should be a GdkDisplay");
454	    return -1;
455	}
456	if (!pygobject_check(pixbuf, &PyGdkPixbuf_Type)) {
457	    PyErr_SetString(PyExc_TypeError,
458			    "pixbuf should be a GdkPixbuf");
459	    return -1;
460	}
461	self->boxed = gdk_cursor_new_from_pixbuf(GDK_DISPLAY(py_display->obj),
462						 GDK_PIXBUF(pixbuf->obj),
463						 x, y);
464	goto done;
465     }
466
467    PyErr_Clear();
468
469    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
470				    "OOOOii:GdkCursor.__init__", kwlist4,
471				     &source, &mask, &fg, &bg, &x, &y)) {
472	PyErr_Clear();
473	PyErr_SetString(PyExc_TypeError, "Usage:\n"
474			"  gtk.gdk.Cursor(cursor_type)\n"
475			"  gtk.gdk.Cursor(display, cursor_type)\n"
476			"  gtk.gdk.Cursor(display, pixbuf, x, y)\n"
477			"  gtk.gdk.Cursor(source, mask, fg, bg, x, y)");
478	return -1;
479    }
480
481    if (!pygobject_check(source, &PyGdkPixmap_Type)) {
482	PyErr_SetString(PyExc_TypeError, "source should be a GdkPixmap");
483	return -1;
484    }
485    if (!pygobject_check(mask, &PyGdkPixmap_Type)) {
486	PyErr_SetString(PyExc_TypeError, "mask should be a GdkPixmap");
487	return -1;
488    }
489    if (!pyg_boxed_check(fg, GDK_TYPE_COLOR)) {
490	PyErr_SetString(PyExc_TypeError, "fg should be a GdkColor");
491	return -1;
492    }
493    if (!pyg_boxed_check(bg, GDK_TYPE_COLOR)) {
494	PyErr_SetString(PyExc_TypeError, "bg should be a GdkColor");
495	return -1;
496    }
497    self->boxed = gdk_cursor_new_from_pixmap(GDK_PIXMAP(source->obj),
498					     GDK_PIXMAP(mask->obj),
499					     pyg_boxed_get(fg, GdkColor),
500					     pyg_boxed_get(bg, GdkColor),
501					     x, y);
502 done:
503    if (!self->boxed) {
504	PyErr_SetString(PyExc_RuntimeError,
505			"could not create GdkCursor object");
506	return -1;
507    }
508    self->free_on_dealloc = TRUE;
509    return 0;
510}
511%%
512override-slot GdkCursor.tp_repr
513static PyObject *
514_wrap_gdk_cursor_tp_repr(PyGObject *self)
515{
516    GdkCursor *cursor = pyg_boxed_get(self, GdkCursor);
517    GEnumValue *type = g_enum_get_value(g_type_class_peek(GDK_TYPE_CURSOR_TYPE), cursor->type);
518
519    /* We use <...> syntax because gtk.gdk.Cursor objects are generally impossible to
520     * reconstruct with eval(repr(...))  round-trip. */
521    return PyString_FromFormat("<%s at %p: %s>",
522                               self->ob_type->tp_name, self,
523                               type ? type->value_name : "UNKNOWN TYPE");
524}
525%%
526override gdk_region_get_clipbox noargs
527static PyObject *
528_wrap_gdk_region_get_clipbox(PyGObject *self)
529{
530    GdkRectangle rect = {0, 0, 0, 0};
531
532    gdk_region_get_clipbox(pyg_boxed_get(self, GdkRegion), &rect);
533
534    return pyg_boxed_new(GDK_TYPE_RECTANGLE, &rect, TRUE, TRUE);
535}
536%%
537override gdk_region_get_rectangles noargs
538static PyObject *
539_wrap_gdk_region_get_rectangles(PyGObject *self)
540{
541    GdkRectangle    *rect;
542    gint            n_rect, i;
543    PyObject        *py_rects;
544
545    gdk_region_get_rectangles(pyg_boxed_get(self, GdkRegion), &rect, &n_rect);
546
547    py_rects = PyList_New(n_rect);
548
549    for (i = 0; i < n_rect; i++)
550	PyList_SetItem(py_rects, i, pyg_boxed_new(GDK_TYPE_RECTANGLE,
551						   &rect[i], TRUE, TRUE));
552
553    g_free(rect);
554    return py_rects;
555}
556%%
557override-slot GdkRegion.tp_richcompare
558static PyObject *
559_wrap_pygdk_region_tp_richcompare(PyObject *self, PyObject *other, int op)
560{
561    PyObject *result;
562
563    if (PyObject_TypeCheck(self, &PyGdkRegion_Type)
564        && PyObject_TypeCheck(other, &PyGdkRegion_Type)) {
565        GdkRegion *region1 = pyg_boxed_get(self, GdkRegion);
566        GdkRegion *region2 = pyg_boxed_get(other, GdkRegion);
567
568        switch (op) {
569        case Py_EQ:
570            result = (gdk_region_equal(region1, region2)
571                      ? Py_True : Py_False);
572            break;
573        case Py_NE:
574            result = (!gdk_region_equal(region1, region2)
575                      ? Py_True : Py_False);
576            break;
577        default:
578            result = Py_NotImplemented;
579        }
580    }
581    else
582        result = Py_NotImplemented;
583
584    Py_INCREF(result);
585    return result;
586}
587%%
588override-attr GdkDevice.axes
589static PyObject *
590_wrap_gdk_device__get_axes(PyGObject *self, void *closure)
591{
592    GdkDevice *device = GDK_DEVICE(self->obj);
593    PyObject *ret;
594    gint i;
595
596    ret = PyTuple_New(device->num_axes);
597    for (i = 0; i < device->num_axes; i++)
598        PyTuple_SetItem(ret, i, Py_BuildValue("(idd)",
599                                              device->axes[i].use,
600                                              device->axes[i].min,
601                                              device->axes[i].max));
602    return ret;
603}
604%%
605override-attr GdkDevice.keys
606static PyObject *
607_wrap_gdk_device__get_keys(PyGObject *self, void *closure)
608{
609    GdkDevice *device = GDK_DEVICE(self->obj);
610    PyObject *ret;
611    gint i;
612
613    ret = PyTuple_New(device->num_keys);
614    for (i = 0; i < device->num_keys; i++)
615        PyTuple_SetItem(ret, i,
616                        Py_BuildValue("(iN)", device->keys[i].keyval,
617                                      pyg_flags_from_gtype(GDK_TYPE_MODIFIER_TYPE,
618                                                           device->keys[i].modifiers)));
619    return ret;
620}
621%%
622override gdk_device_get_state kwargs
623static PyObject *
624_wrap_gdk_device_get_state(PyGObject *self, PyObject *args, PyObject *kwargs)
625{
626    static char *kwlist[] = { "window", NULL };
627    GdkDevice *device = GDK_DEVICE(self->obj);
628    PyGObject *window;
629    gdouble *axes;
630    GdkModifierType mask;
631    PyObject *py_axes;
632    guint i;
633
634    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GdkDevice.get_state",
635                                     kwlist, &window))
636        return NULL;
637    if (!pygobject_check(window, &PyGdkWindow_Type)) {
638        PyErr_SetString(PyExc_TypeError, "window should be a GdkWindow");
639        return NULL;
640    }
641    axes = g_new0(gdouble, device->num_axes);
642    gdk_device_get_state(device, GDK_WINDOW(window->obj), axes, &mask);
643    py_axes = PyTuple_New(device->num_axes);
644    for (i = 0; i < device->num_axes; i++)
645        PyTuple_SetItem(py_axes, i, PyFloat_FromDouble(axes[i]));
646    g_free(axes);
647    return Py_BuildValue("(NN)", py_axes,
648                         pyg_flags_from_gtype(GDK_TYPE_MODIFIER_TYPE, mask));
649}
650%%
651ignore gdk_device_free_history
652%%
653override gdk_device_get_history kwargs
654static PyObject *
655_wrap_gdk_device_get_history(PyGObject *self, PyObject *args, PyObject *kwargs)
656{
657    static char *kwlist[] = { "window", "start", "stop", NULL };
658    GdkDevice *device = GDK_DEVICE(self->obj);
659    PyGObject *window;
660    guint start, stop;
661    GdkTimeCoord **events;
662    gint n_events;
663    PyObject *pyevents;
664    guint i;
665
666    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
667                                     "Oii:GdkDevice.get_history", kwlist,
668                                     &window, &start, &stop))
669        return NULL;
670    if (!pygobject_check(window, &PyGdkWindow_Type)) {
671        PyErr_SetString(PyExc_TypeError, "window should be a GdkWindow");
672        return NULL;
673    }
674    gdk_device_get_history(device, GDK_WINDOW(window->obj), start, stop,
675                           &events, &n_events);
676    pyevents = PyTuple_New(n_events);
677    for (i = 0; i < n_events; i++) {
678        PyObject *axes;
679        gint j;
680
681        axes = PyTuple_New(device->num_axes);
682        for (j = 0; j < device->num_axes; j++)
683            PyTuple_SetItem(axes, j, PyFloat_FromDouble(events[i]->axes[j]));
684        PyTuple_SetItem(pyevents, i, Py_BuildValue("(iN)", events[i]->time,
685                                                   axes));
686    }
687    gdk_device_free_history(events, n_events);
688    return pyevents;
689}
690%%
691override gdk_device_get_axis kwargs
692static PyObject *
693_wrap_gdk_device_get_axis(PyGObject *self, PyObject *args, PyObject *kwargs)
694{
695    static char *kwlist[] = { "axes", "use", NULL };
696    GdkDevice *device = GDK_DEVICE(self->obj);
697    PyObject *py_axes;
698    gdouble *axes, value;
699    GdkAxisUse use;
700    gboolean ret;
701    gint i;
702
703    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi:GdkDevice.get_axis",
704                                     kwlist, &py_axes, &use))
705        return NULL;
706    if (!PySequence_Check(py_axes)) {
707        PyErr_SetString(PyExc_TypeError, "axes must be a sequence");
708        return NULL;
709    }
710    if (PySequence_Length(py_axes) != device->num_axes) {
711        PyErr_SetString(PyExc_TypeError, "axes has the wrong length");
712        return NULL;
713    }
714    axes = g_new(gdouble, device->num_axes);
715    for (i = 0; i < device->num_axes; i++) {
716        PyObject *item = PySequence_GetItem(py_axes, i);
717
718        axes[i] = PyFloat_AsDouble(item);
719        Py_DECREF(item);
720        if (PyErr_Occurred()) {
721            g_free(axes);
722            return NULL;
723       }
724    }
725    ret = gdk_device_get_axis(device, axes, use, &value);
726    g_free(axes);
727    if (ret)
728        return PyFloat_FromDouble(value);
729    Py_INCREF(Py_None);
730    return Py_None;
731}
732%%
733override gdk_drag_find_window kwargs
734static PyObject *
735_wrap_gdk_drag_find_window(PyGObject *self, PyObject *args, PyObject *kwargs)
736{
737    static char *kwlist[] = { "drag_window", "x_root", "y_root", NULL };
738    PyGObject *drag_window;
739    gint x_root, y_root;
740    GdkWindow *dest_window;
741    GdkDragProtocol protocol;
742
743    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
744                                     "Oii:GdkDragContext.drag_find_window",
745                                     kwlist, &drag_window, &x_root, &y_root))
746        return NULL;
747    if (!pygobject_check(drag_window, &PyGdkWindow_Type)) {
748        PyErr_SetString(PyExc_TypeError, "drag_window must be a GdkWindow");
749        return NULL;
750    }
751    gdk_drag_find_window(GDK_DRAG_CONTEXT(self->obj),
752                         GDK_WINDOW(drag_window->obj), x_root, y_root,
753                         &dest_window, &protocol);
754    return Py_BuildValue("(Ni)", pygobject_new((GObject *)dest_window),
755                         protocol);
756}
757%%
758override gdk_drag_find_window_for_screen kwargs
759static PyObject *
760_wrap_gdk_drag_find_window_for_screen(PyGObject *self, PyObject *args,
761				      PyObject *kwargs)
762{
763    static char *kwlist[] = { "drag_window", "screen", "x_root", "y_root", NULL };
764    PyGObject *drag_window, *screen;
765    gint x_root, y_root;
766    GdkWindow *dest_window;
767    GdkDragProtocol protocol;
768
769    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
770			"O!O!ii:GdkDragContext.drag_find_window_for_screen",
771			kwlist, &PyGdkWindow_Type, &drag_window,
772			&PyGdkScreen_Type, &screen,
773			&x_root, &y_root))
774        return NULL;
775    gdk_drag_find_window_for_screen(GDK_DRAG_CONTEXT(self->obj),
776				    GDK_WINDOW(drag_window->obj),
777				    GDK_SCREEN(screen->obj),
778				    x_root, y_root,
779				    &dest_window, &protocol);
780    return Py_BuildValue("(Ni)", pygobject_new((GObject *)dest_window),
781                         protocol);
782}
783%%
784override-attr GdkDragContext.targets
785static PyObject *
786_wrap_gdk_drag_context__get_targets(PyGObject *self, void *closure)
787{
788    PyObject *atom, *ret = PyList_New(0);
789    GList *tmp;
790    if (ret == NULL)
791        return NULL;
792    for (tmp = GDK_DRAG_CONTEXT(self->obj)->targets; tmp; tmp = tmp->next) {
793        gchar *name;
794
795        name = gdk_atom_name(GDK_POINTER_TO_ATOM(tmp->data));
796        if ((atom = PyString_FromString(name)) == NULL) {
797            g_free(name);
798            Py_DECREF(ret);
799            return NULL;
800        }
801        PyList_Append(ret, atom);
802        g_free(name);
803        Py_DECREF(atom);
804    }
805    return ret;
806}
807%%
808override gdk_drawable_get_size noargs
809static PyObject *
810_wrap_gdk_drawable_get_size(PyGObject *self)
811{
812    gint width;
813    gint height;
814
815    gdk_drawable_get_size(GDK_DRAWABLE(self->obj), &width, &height);
816    return Py_BuildValue("(ii)", width, height);
817}
818%%
819override gdk_drag_begin kwargs
820static PyObject *
821_wrap_gdk_drag_begin(PyGObject *self, PyObject *args, PyObject *kwargs)
822{
823    static char *kwlist[] = { "targets", NULL };
824    PyObject *py_targets;
825    GList *targets = NULL;
826    guint i, len;
827    GdkDragContext *context;
828    PyObject *py_context;
829
830    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GdkWindow.drag_begin",
831                                     kwlist, &py_targets))
832        return NULL;
833    if (!PySequence_Check(py_targets)) {
834        PyErr_SetString(PyExc_TypeError, "targets must be a list of ints");
835        return NULL;
836    }
837    len = PySequence_Length(py_targets);
838    for (i = 0; i < len; i++) {
839        PyObject *item = PySequence_GetItem(py_targets, i);
840
841        if (PyInt_Check(item)) {
842            targets = g_list_append(targets,
843                                    GUINT_TO_POINTER(PyInt_AsLong(item)));
844            Py_DECREF(item);
845        } else {
846            PyErr_SetString(PyExc_TypeError, "targets must be a list of ints");
847            Py_DECREF(item);
848            g_list_free(targets);
849            return NULL;
850        }
851    }
852    context = gdk_drag_begin(GDK_WINDOW(self->obj), targets);
853    g_list_free(targets);
854    py_context = pygobject_new((GObject *)context);
855    gdk_drag_context_unref(context);
856    return py_context;
857}
858%%
859override gdk_devices_list noargs
860static PyObject *
861_wrap_gdk_devices_list(PyObject *self)
862{
863    GList * devlist,  *tmp;
864    PyObject *list;
865
866    devlist = gdk_devices_list();
867    list = PyList_New(0);
868    for (tmp = devlist; tmp != NULL; tmp = tmp->next) {
869        PyObject *item = pygobject_new((GObject *)tmp->data);
870        PyList_Append(list, item);
871        Py_DECREF(item);
872    }
873
874    return list;
875}
876%%
877override-attr GdkDrawable.handle
878static PyObject *
879_wrap_gdk_drawable__get_handle(PyGObject *self, void *closure)
880{
881#if defined(GDK_WINDOWING_WIN32)
882    GdkDrawable *drawable = GDK_DRAWABLE(self->obj);
883    return PyLong_FromVoidPtr(GDK_WINDOW_HWND(drawable));
884#else
885    PyErr_SetString(PyExc_AttributeError, "handle attribute not supported");
886    return NULL;
887#endif
888}
889%%
890override-attr GdkDrawable.nsview
891static PyObject *
892_wrap_gdk_drawable__get_nsview(PyGObject *self, void *closure)
893{
894#if defined(GDK_WINDOWING_QUARTZ)
895    GdkDrawable *drawable = GDK_DRAWABLE(self->obj);
896    return PyLong_FromVoidPtr(gdk_quartz_window_get_nsview(drawable));
897#else
898    PyErr_SetString(PyExc_AttributeError, "nsview attribute not supported");
899    return NULL;
900#endif
901}
902%%
903override-attr GdkDrawable.nswindow
904static PyObject *
905_wrap_gdk_drawable__get_nswindow(PyGObject *self, void *closure)
906{
907#if defined(GDK_WINDOWING_QUARTZ)
908    GdkDrawable *drawable = GDK_DRAWABLE(self->obj);
909    return PyLong_FromVoidPtr(gdk_quartz_window_get_nswindow(drawable));
910#else
911    PyErr_SetString(PyExc_AttributeError, "nsview attribute not supported");
912    return NULL;
913#endif
914}
915%%
916override-attr GdkDrawable.xid
917static PyObject *
918_wrap_gdk_drawable__get_xid(PyGObject *self, void *closure)
919{
920#if defined(GDK_WINDOWING_X11)
921    GdkDrawable *drawable = GDK_DRAWABLE(self->obj);
922    return PyLong_FromUnsignedLong(GDK_DRAWABLE_XID(drawable));
923#else
924    PyErr_SetString(PyExc_AttributeError, "xid attribute not supported");
925    return NULL;
926#endif
927}
928%%
929override gdk_list_visuals noargs
930static PyObject *
931_wrap_gdk_list_visuals(PyGObject *self)
932{
933    GList *visl;
934    guint nvisl;
935    int i;
936    PyObject *list;
937
938    visl = gdk_list_visuals();
939    nvisl = g_list_length(visl);
940
941    if ((list = PyList_New(nvisl)) == NULL)
942	return NULL;
943
944    for (i = 0; i < nvisl; i++) {
945	PyObject *item;
946
947	item = pygobject_new((GObject *)g_list_nth_data(visl, i));
948	PyList_SetItem(list, i, item);
949    }
950
951    g_list_free(visl);
952
953    return list;
954}
955%%
956override gdk_display_list_devices noargs
957static PyObject *
958_wrap_gdk_display_list_devices(PyGObject *self)
959{
960    GList * devlist,  *tmp;
961    PyObject *list;
962
963    devlist = gdk_display_list_devices(GDK_DISPLAY_OBJECT(self->obj));
964    list = PyList_New(0);
965    for (tmp = devlist; tmp != NULL; tmp = tmp->next) {
966        PyObject *item = pygobject_new((GObject *)tmp->data);
967        PyList_Append(list, item);
968        Py_DECREF(item);
969    }
970
971    return list;
972}
973%%
974override gdk_display_get_pointer noargs
975static PyObject *
976_wrap_gdk_display_get_pointer(PyGObject *self)
977{
978    GdkScreen *screen = NULL;
979    gint x, y;
980    GdkModifierType mask;
981
982    gdk_display_get_pointer(GDK_DISPLAY_OBJECT(self->obj), &screen, &x, &y, &mask);
983    return Py_BuildValue("(NiiN)", pygobject_new((GObject *)screen),
984			 x, y,
985                         pyg_flags_from_gtype(GDK_TYPE_MODIFIER_TYPE, mask));
986}
987%%
988override gdk_display_get_window_at_pointer noargs
989static PyObject *
990_wrap_gdk_display_get_window_at_pointer(PyGObject *self)
991{
992    GdkWindow *window;
993    gint win_x, win_y;
994
995    window = gdk_display_get_window_at_pointer(GDK_DISPLAY_OBJECT(self->obj),
996					       &win_x, &win_y);
997    if (window)
998	return Py_BuildValue("(Nii)", pygobject_new((GObject *)window),
999			     win_x, win_y);
1000    Py_INCREF(Py_None);
1001    return Py_None;
1002}
1003%%
1004override gdk_display_manager_list_displays noargs
1005static PyObject *
1006_wrap_gdk_display_manager_list_displays(PyGObject *self)
1007{
1008    GSList *list, *tmp;
1009    PyObject *py_list;
1010
1011    list = gdk_display_manager_list_displays(GDK_DISPLAY_MANAGER(self->obj));
1012    py_list = PyList_New(0);
1013    for (tmp = list; tmp != NULL; tmp = tmp->next) {
1014        PyObject *item = pygobject_new((GObject *)tmp->data);
1015        PyList_Append(py_list, item);
1016        Py_DECREF(item);
1017    }
1018    g_slist_free(list);
1019
1020    return py_list;
1021}
1022%%
1023override gdk_screen_new noargs
1024static int
1025_wrap_gdk_screen_new (PyGObject *self)
1026{
1027    self->obj = (GObject *)gdk_screen_get_default();
1028    if (!self->obj) {
1029	PyErr_SetString(PyExc_RuntimeError,
1030			"could not get default display");
1031	return -1;
1032    }
1033
1034    g_object_ref(self->obj);
1035
1036    pygobject_register_wrapper((PyObject *)self);
1037    return 0;
1038}
1039%%
1040override gdk_screen_list_visuals noargs
1041static PyObject *
1042_wrap_gdk_screen_list_visuals(PyGObject *self)
1043{
1044    GList *visl;
1045    guint nvisl;
1046    int i;
1047    PyObject *list;
1048
1049    visl = gdk_screen_list_visuals(GDK_SCREEN(self->obj));
1050    nvisl = g_list_length(visl);
1051
1052    if ((list = PyList_New(nvisl)) == NULL)
1053	return NULL;
1054
1055    for (i = 0; i < nvisl; i++) {
1056	PyObject *item;
1057
1058	item = pygobject_new((GObject *)g_list_nth_data(visl, i));
1059	PyList_SetItem(list, i, item);
1060    }
1061
1062    g_list_free(visl);
1063
1064    return list;
1065}
1066%%
1067override gdk_screen_get_toplevel_windows noargs
1068static PyObject *
1069_wrap_gdk_screen_get_toplevel_windows(PyGObject *self)
1070{
1071    GList *topl;
1072    guint ntopl;
1073    int i;
1074    PyObject *list;
1075
1076    topl = gdk_screen_get_toplevel_windows(GDK_SCREEN(self->obj));
1077    ntopl = g_list_length(topl);
1078
1079    if ((list = PyList_New(ntopl)) == NULL)
1080	return NULL;
1081
1082    for (i = 0; i < ntopl; i++) {
1083	PyObject *item;
1084
1085	item = pygobject_new((GObject *)g_list_nth_data(topl, i));
1086	PyList_SetItem(list, i, item);
1087    }
1088
1089    g_list_free(topl);
1090
1091    return list;
1092}
1093%%
1094override gdk_screen_get_monitor_geometry kwargs
1095static PyObject *
1096_wrap_gdk_screen_get_monitor_geometry(PyGObject *self, PyObject *args,
1097				      PyObject *kwargs)
1098{
1099    static char *kwlist[] = { "monitor_num", NULL };
1100    int monitor_num;
1101    GdkRectangle dest = { 0, 0, 0, 0 };
1102
1103    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
1104				     "i:GdkScreen.get_monitor_geometry",
1105				     kwlist, &monitor_num))
1106        return NULL;
1107
1108    gdk_screen_get_monitor_geometry(GDK_SCREEN(self->obj), monitor_num, &dest);
1109
1110    return pyg_boxed_new(GDK_TYPE_RECTANGLE, &dest, TRUE, TRUE);
1111}
1112%%
1113override gdk_screen_get_setting kwargs
1114static PyObject *
1115_wrap_gdk_screen_get_setting(PyGObject *self, PyObject *args, PyObject *kwargs)
1116{
1117    static char *kwlist[] = { "name", NULL };
1118    char *name;
1119    GValue value = { 0, };
1120    PyObject *ret;
1121
1122    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:GdkScreen.get_setting",
1123				     kwlist, &name))
1124	return NULL;
1125
1126    /* this is a bit of a hack.  We don't know what type of setting it is */
1127    g_value_init(&value, GDK_TYPE_COLOR);
1128    if (gdk_screen_get_setting(GDK_SCREEN(self->obj), name, &value))
1129	goto got_setting;
1130    g_value_unset(&value);
1131    g_value_init(&value, G_TYPE_INT);
1132    if (gdk_screen_get_setting(GDK_SCREEN(self->obj), name, &value))
1133	goto got_setting;
1134    g_value_unset(&value);
1135    g_value_init(&value, G_TYPE_STRING);
1136    if (gdk_screen_get_setting(GDK_SCREEN(self->obj), name, &value))
1137	goto got_setting;
1138    g_value_unset(&value);
1139    /* setting not found */
1140    PyErr_SetString(PyExc_ValueError, "could not find setting");
1141    return NULL;
1142
1143 got_setting:
1144    ret = pyg_value_as_pyobject(&value, TRUE);
1145    g_value_unset(&value);
1146    return ret;
1147}
1148%%
1149override gdk_atom_intern kwargs
1150static PyObject *
1151_wrap_gdk_atom_intern(PyObject *self, PyObject *args, PyObject *kwargs)
1152{
1153    static char *kwlist[] = { "atom_name", "only_if_exists", NULL };
1154    char *atom_name;
1155    int only_if_exists = FALSE;
1156    GdkAtom ret;
1157
1158    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|i:atom_intern",
1159				     kwlist, &atom_name, &only_if_exists))
1160        return NULL;
1161    ret = gdk_atom_intern(atom_name, only_if_exists);
1162    if (ret == GDK_NONE) {
1163	Py_INCREF(Py_None);
1164	return Py_None;
1165    }
1166    return PyGdkAtom_New(ret);
1167}
1168%%
1169override gdk_display_get_maximal_cursor_size noargs
1170static PyObject *
1171_wrap_gdk_display_get_maximal_cursor_size(PyGObject *self)
1172{
1173    guint width, height;
1174
1175    gdk_display_get_maximal_cursor_size(GDK_DISPLAY(self->obj),
1176					&width, &height);
1177
1178    return Py_BuildValue("(ii)", width, height);
1179}
1180%%
1181override gdk_keyval_convert_case kwargs
1182static PyObject *
1183_wrap_gdk_keyval_convert_case(PyObject *self, PyObject *args, PyObject *kwargs)
1184{
1185    static char *kwlist[] = { "symbol", NULL };
1186    guint symbol, upper, lower;
1187
1188    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:keyval_convert_case",
1189				     kwlist, &symbol))
1190	return NULL;
1191
1192    gdk_keyval_convert_case(symbol, &lower, &upper);
1193
1194    return Py_BuildValue("(ii)", lower, upper);
1195}
1196%%
1197override gdk_keymap_get_entries_for_keyval kwargs
1198static PyObject *
1199_wrap_gdk_keymap_get_entries_for_keyval(PyGObject *self, PyObject *args,
1200					PyObject *kwargs)
1201{
1202    static char *kwlist[] = { "keyval", NULL };
1203    guint keyval;
1204    GdkKeymapKey *keys;
1205    gint n_keys;
1206
1207    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
1208				     "i:gtk.gdk.Keymap.get_entries_for_keyval",
1209				     kwlist, &keyval))
1210	return NULL;
1211
1212    if (gdk_keymap_get_entries_for_keyval(GDK_KEYMAP(self->obj), keyval,
1213					  &keys, &n_keys)) {
1214	int i;
1215	PyObject * list = PyTuple_New(n_keys);
1216
1217	for (i = 0; i < n_keys; i++) {
1218	    PyTuple_SetItem(list, i,
1219			    Py_BuildValue("(iii)", keys[i].keycode,
1220					  keys[i].group, keys[i].level));
1221	}
1222	g_free(keys);
1223
1224	return list;
1225    }
1226
1227    Py_INCREF(Py_None);
1228    return Py_None;
1229}
1230%%
1231override gdk_keymap_get_entries_for_keycode kwargs
1232static PyObject *
1233_wrap_gdk_keymap_get_entries_for_keycode(PyGObject *self, PyObject *args,
1234					 PyObject *kwargs)
1235{
1236    static char *kwlist[] = { "hardware_keycode", NULL };
1237    guint keycode;
1238    GdkKeymapKey *keys;
1239    guint *keyvals;
1240    gint n_keys;
1241
1242    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
1243				     "i:gtk.gdk.Keymap.get_entries_for_keycode",
1244				     kwlist, &keycode))
1245	return NULL;
1246
1247    if (gdk_keymap_get_entries_for_keycode(GDK_KEYMAP(self->obj), keycode,
1248					  &keys, &keyvals, &n_keys)) {
1249	int i;
1250	PyObject * list = PyTuple_New(n_keys);
1251
1252	for (i = 0; i < n_keys; i++) {
1253	    PyTuple_SetItem(list, i,
1254			    Py_BuildValue("(iiii)", keyvals[i],
1255					  keys[i].keycode,
1256					  keys[i].group, keys[i].level));
1257	}
1258	g_free(keys);
1259
1260	return list;
1261    }
1262
1263    Py_INCREF(Py_None);
1264    return Py_None;
1265}
1266%%
1267override gdk_keymap_lookup_key kwargs
1268static PyObject *
1269_wrap_gdk_keymap_lookup_key(PyGObject *self, PyObject *args,
1270			    PyObject *kwargs)
1271{
1272    static char *kwlist[] = { "keycode", "group", "level", NULL };
1273    GdkKeymapKey key;
1274
1275    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
1276				     "iii:gtk.gdk.Keymap.lookup_key",
1277				     kwlist, &key.keycode, &key.group,
1278				     &key.level))
1279	return NULL;
1280
1281    return PyInt_FromLong(gdk_keymap_lookup_key(GDK_KEYMAP(self->obj), &key));
1282}
1283%%
1284override gdk_keymap_translate_keyboard_state kwargs
1285static PyObject *
1286_wrap_gdk_keymap_translate_keyboard_state(PyGObject *self, PyObject *args,
1287					  PyObject *kwargs)
1288{
1289    static char *kwlist[] = { "keycode", "state", "group", NULL };
1290    guint keycode, keyval;
1291    gint group, effective_group, level;
1292    GdkModifierType state, modifiers;
1293    PyObject *py_state;
1294
1295    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
1296				     "iOi:gtk.gdk.Keymap.translate_keyboard_state",
1297				     kwlist, &keycode, &py_state,
1298				     &group))
1299	return NULL;
1300
1301    if (pyg_flags_get_value(GDK_TYPE_MODIFIER_TYPE, py_state,
1302			    (gint *)&state))
1303        return NULL;
1304
1305    if (gdk_keymap_translate_keyboard_state(GDK_KEYMAP(self->obj), keycode,
1306					    state, group, &keyval,
1307					    &effective_group, &level,
1308					    &modifiers))
1309	return Py_BuildValue("(iiiN)", keyval, effective_group, level,
1310			     pyg_flags_from_gtype(GDK_TYPE_MODIFIER_TYPE,
1311                                                  modifiers));
1312    Py_INCREF(Py_None);
1313    return Py_None;
1314}
1315%%
1316override gdk_query_depths noargs
1317static PyObject *
1318_wrap_gdk_query_depths(PyObject *self)
1319{
1320    gint count, i;
1321    gint *depths;
1322    PyObject *py_depths;
1323
1324    gdk_query_depths(&depths, &count);
1325
1326    py_depths = PyTuple_New(count);
1327
1328    for (i = 0; i < count; i++)
1329	PyTuple_SetItem(py_depths, i, PyInt_FromLong(depths[i]));
1330
1331    return py_depths;
1332}
1333%%
1334override gdk_query_visual_types noargs
1335static PyObject *
1336_wrap_gdk_query_visual_types(PyObject *self)
1337{
1338    gint count, i;
1339    GdkVisualType *types;
1340    PyObject *py_types;
1341
1342    gdk_query_visual_types(&types, &count);
1343
1344    py_types = PyTuple_New(count);
1345
1346    for (i = 0; i < count; i++)
1347	PyTuple_SetItem(py_types, i, PyInt_FromLong(types[i]));
1348
1349    return py_types;
1350}
1351%%
1352override gdk_window_at_pointer noargs
1353static PyObject *
1354_wrap_gdk_window_at_pointer(PyObject *self)
1355{
1356    GdkWindow *window;
1357    gint x, y;
1358
1359    window = gdk_window_at_pointer(&x, &y);
1360
1361    if (window)
1362	return Py_BuildValue("(Nii)", pygobject_new((GObject *)window), x, y);
1363
1364    Py_INCREF(Py_None);
1365    return Py_None;
1366}
1367%%
1368override gdk_display_store_clipboard kwargs
1369static PyObject *
1370_wrap_gdk_display_store_clipboard(PyGObject *self, PyObject *args,
1371                                  PyObject *kwargs)
1372{
1373    static char *kwlist[] = { "clipboard_window", "time_", "targets", NULL };
1374    PyGObject *pyclipboard_window;
1375    guint32 time_;
1376    PyObject *pytargets;
1377    GdkAtom *targets;
1378    int tlen, i;
1379
1380    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
1381				     "O!iO:GdkDIsplay.store_clipboard", kwlist,
1382				     &PyGdkWindow_Type, &pyclipboard_window,
1383                                     &time_, &pytargets))
1384	return NULL;
1385
1386    if (!pytargets || pytargets == Py_None) {
1387        tlen = 0;
1388        targets = NULL;
1389    } else {
1390        if (!PySequence_Check(pytargets)) {
1391            PyErr_SetString(PyExc_TypeError,
1392                            "targets must be a sequence of target strings"
1393                            "or GdkAtoms or None");
1394            return NULL;
1395        }
1396        tlen = PySequence_Size(pytargets);
1397        targets = g_new0(GdkAtom, tlen);
1398        for (i = 0; i < tlen; i++) {
1399            PyObject *item = PySequence_GetItem(pytargets, i);
1400            targets[i] = pygdk_atom_from_pyobject(item);
1401            if (PyErr_Occurred()) {
1402                Py_DECREF(item);
1403                g_free(targets);
1404                return NULL;
1405            }
1406            Py_DECREF(item);
1407        }
1408        g_free(targets);
1409    }
1410    gdk_display_store_clipboard(GDK_DISPLAY(self->obj),
1411                                GDK_WINDOW(pyclipboard_window->obj),
1412                                time_, targets, tlen);
1413    Py_INCREF(Py_None);
1414    return Py_None;
1415}
1416%%
1417override gdk_event_handler_set args
1418static void
1419pygdk_event_handler_marshal(GdkEvent *event, gpointer data)
1420{
1421    PyGILState_STATE state;
1422    PyGtkCustomNotify *cunote = data;
1423    PyObject *retobj;
1424    PyObject *pyevent;
1425
1426    g_assert (cunote->func);
1427
1428    state = pyg_gil_state_ensure();
1429
1430    pyevent = pyg_boxed_new(GDK_TYPE_EVENT, event, TRUE, TRUE);
1431    if (cunote->data)
1432        retobj = PyEval_CallFunction(cunote->func, "(NO)",
1433				     pyevent, cunote->data);
1434    else
1435        retobj = PyEval_CallFunction(cunote->func, "(N)", pyevent);
1436
1437    if (retobj == NULL) {
1438        PyErr_Print();
1439    } else
1440        Py_DECREF(retobj);
1441
1442    pyg_gil_state_release(state);
1443}
1444
1445static PyObject *
1446_wrap_gdk_event_handler_set(PyObject *self, PyObject *args, PyObject *kwargs)
1447{
1448    PyObject *pyfunc, *pyarg = NULL;
1449    PyGtkCustomNotify *cunote;
1450
1451    if (!PyArg_ParseTuple(args, "O|O:event_handler_set",
1452                          &pyfunc, &pyarg))
1453        return NULL;
1454
1455    if (pyfunc == Py_None) {
1456	gdk_event_handler_set(NULL, NULL, NULL);
1457    } else {
1458	cunote = g_new0(PyGtkCustomNotify, 1);
1459	cunote->func = pyfunc;
1460	cunote->data = pyarg;
1461	Py_INCREF(cunote->func);
1462	Py_XINCREF(cunote->data);
1463
1464	gdk_event_handler_set(pygdk_event_handler_marshal,
1465			      cunote,
1466			      pygtk_custom_destroy_notify);
1467    }
1468
1469    Py_INCREF(Py_None);
1470    return Py_None;
1471}
1472
1473%%
1474override gdk_bitmap_create_from_data kwargs
1475static PyObject *
1476_wrap_gdk_bitmap_create_from_data(PyObject *self, PyObject *args, PyObject *kwargs)
1477{
1478    static char *kwlist[] = { "drawable", "data", "width", "height", NULL };
1479    PyGObject *py_drawable;
1480    GdkDrawable *drawable = NULL;
1481    gchar *data;
1482    GdkBitmap *ret;
1483    Py_ssize_t data_len;
1484    int width, height, rowstride;
1485
1486    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Os#ii:bitmap_create_from_data", kwlist, &py_drawable, &data, &data_len, &width, &height))
1487        return NULL;
1488    if (py_drawable && pygobject_check(py_drawable, &PyGdkDrawable_Type))
1489        drawable = GDK_DRAWABLE(py_drawable->obj);
1490    else if ((PyObject *)py_drawable != Py_None) {
1491        PyErr_SetString(PyExc_TypeError, "drawable should be a GdkDrawable or None");
1492        return NULL;
1493    }
1494
1495    rowstride = (width&(~7))/8 + 1;
1496    if (data_len*8 < rowstride*height) {
1497        PyErr_SetString(PyExc_ValueError, "data size is insufficient for the given width, height, and depth");
1498        return NULL;
1499    }
1500
1501    ret = gdk_bitmap_create_from_data((GdkDrawable *) drawable, data, width, height);
1502
1503    /* pygobject_new handles NULL checking */
1504    return pygobject_new((GObject *)ret);
1505}
1506
1507%%
1508override gdk_pixmap_create_from_data kwargs
1509static PyObject *
1510_wrap_gdk_pixmap_create_from_data(PyObject *self, PyObject *args, PyObject *kwargs)
1511{
1512    static char *kwlist[] = { "drawable", "data", "width", "height", "depth", "fg", "bg", NULL };
1513    Py_ssize_t data_len;
1514    int width, height, depth;
1515    GdkPixmap *ret;
1516    PyObject *py_fg, *py_bg;
1517    GdkColor *fg = NULL, *bg = NULL;
1518    GdkDrawable *drawable = NULL;
1519    gchar *data;
1520    PyGObject *py_drawable;
1521
1522    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Os#iiiOO:pixmap_create_from_data", kwlist, &py_drawable, &data, &data_len, &width, &height, &depth, &py_fg, &py_bg))
1523        return NULL;
1524    if (py_drawable && pygobject_check(py_drawable, &PyGdkDrawable_Type))
1525        drawable = GDK_DRAWABLE(py_drawable->obj);
1526    else if ((PyObject *)py_drawable != Py_None) {
1527        PyErr_SetString(PyExc_TypeError, "drawable should be a GdkDrawable or None");
1528        return NULL;
1529    }
1530    if (pyg_boxed_check(py_fg, GDK_TYPE_COLOR))
1531        fg = pyg_boxed_get(py_fg, GdkColor);
1532    else {
1533        PyErr_SetString(PyExc_TypeError, "fg should be a GdkColor");
1534        return NULL;
1535    }
1536    if (pyg_boxed_check(py_bg, GDK_TYPE_COLOR))
1537        bg = pyg_boxed_get(py_bg, GdkColor);
1538    else {
1539        PyErr_SetString(PyExc_TypeError, "bg should be a GdkColor");
1540        return NULL;
1541    }
1542
1543    if (data_len < width*height*(depth>>3)) {
1544        PyErr_SetString(PyExc_ValueError, "data size is insufficient for the given width, height, and depth");
1545        return NULL;
1546    }
1547
1548    ret = gdk_pixmap_create_from_data((GdkDrawable *) drawable, data, width, height, depth, fg, bg);
1549
1550    /* pygobject_new handles NULL checking */
1551    return pygobject_new((GObject *)ret);
1552}
1553%%
1554override gdk_screen_get_font_options noargs
1555static PyObject *
1556_wrap_gdk_screen_get_font_options(PyGObject *self)
1557{
1558    const cairo_font_options_t *options;
1559
1560    options = gdk_screen_get_font_options(GDK_SCREEN(self->obj));
1561    if (!options) {
1562        Py_INCREF(Py_None);
1563        return Py_None;
1564    }
1565    return PycairoFontOptions_FromFontOptions(cairo_font_options_copy(options));
1566}
1567%%
1568override gdk_screen_set_font_options kwargs
1569static PyObject *
1570_wrap_gdk_screen_set_font_options(PyGObject *self, PyObject *args,
1571                                  PyObject *kwargs)
1572{
1573    static char *kwlist[] = { "options", NULL };
1574    PyGObject *py_options;
1575    const cairo_font_options_t *options;
1576
1577    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
1578                                     "O:GdkScreen.set_font_options",
1579                                     kwlist, &py_options))
1580        return NULL;
1581    if ((PyObject*)py_options == Py_None)
1582        options = NULL;
1583    else if (pygobject_check(py_options, &PycairoFontOptions_Type))
1584        options = ((PycairoFontOptions *)py_options)->font_options;
1585    else {
1586        PyErr_SetString(PyExc_TypeError,
1587                        "options must be a cairo.FontOptions or None");
1588        return NULL;
1589    }
1590
1591    gdk_screen_set_font_options(GDK_SCREEN(self->obj), options);
1592    Py_INCREF(Py_None);
1593    return Py_None;
1594}
1595
1596%%
1597override gdk_display_close noargs
1598static PyObject *
1599_wrap_gdk_display_close(PyGObject *self)
1600{
1601    GdkDisplay *display = GDK_DISPLAY(self->obj);
1602    if (self->obj && !display->closed) {
1603        g_object_ref(self->obj);
1604        gdk_display_close(display);
1605    }
1606    Py_INCREF(Py_None);
1607    return Py_None;
1608}
1609