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