static CeditNotebook * find_notebook_at_pointer (gint abs_x, gint abs_y) { GdkWindow *win_at_pointer; GdkWindow *toplevel_win; gpointer toplevel = NULL; gint x, y; /* FIXME multi-head */ win_at_pointer = gdk_window_at_pointer (&x, &y); if (win_at_pointer == NULL) { /* We are outside all windows of the same application */ return NULL; } toplevel_win = gdk_window_get_toplevel (win_at_pointer); /* get the GtkWidget which owns the toplevel GdkWindow */ gdk_window_get_user_data (toplevel_win, &toplevel); /* toplevel should be an CeditWindow */ if ((toplevel != NULL) && CEDIT_IS_WINDOW (toplevel)) { return CEDIT_NOTEBOOK (_cedit_window_get_notebook (CEDIT_WINDOW (toplevel))); } /* We are outside all windows containing a notebook */ return NULL; }
static void set_user_time (GdkWindow *window, GdkEvent *event) { g_return_if_fail (event != NULL); window = gdk_window_get_toplevel (event->any.window); g_return_if_fail (GDK_IS_WINDOW (window)); /* If an event doesn't have a valid timestamp, we shouldn't use it * to update the latest user interaction time. */ if (gdk_event_get_time (event) != GDK_CURRENT_TIME) gdk_x11_window_set_user_time (gdk_window_get_toplevel (window), gdk_event_get_time (event)); }
JNIEXPORT jlong JNICALL Java_org_gnome_gdk_GdkWindow_gdk_1window_1get_1toplevel ( JNIEnv* env, jclass cls, jlong _self ) { GdkWindow* result; jlong _result; GdkWindow* self; // convert parameter self self = (GdkWindow*) _self; // call function result = gdk_window_get_toplevel(self); // cleanup parameter self // translate return value to JNI type _result = (jlong) result; // cleanup return value if (result != NULL) { bindings_java_memory_cleanup((GObject*)result, FALSE); } // and finally return _result; }
/** * Change current cursor to a animated watch (if animation supported * by environment). * * \param force_update Call a gtk iteration to ensure cursor * is updated. May cause trouble if * called from some signal handlers. */ void gsb_status_wait ( gboolean force_update ) { GdkWindow * current_window; gdk_window_set_cursor ( run.window -> window, gdk_cursor_new_for_display ( gdk_display_get_default ( ), GDK_WATCH ) ); current_window = gdk_display_get_window_at_pointer ( gdk_display_get_default ( ), NULL, NULL ); if ( current_window && GDK_IS_WINDOW ( current_window ) && current_window != run.window -> window ) { GdkWindow * parent = gdk_window_get_toplevel ( current_window ); if ( parent && parent != current_window ) { current_window = parent; } gdk_window_set_cursor ( current_window, gdk_cursor_new_for_display ( gdk_display_get_default ( ), GDK_WATCH ) ); tracked_window = current_window; } if ( force_update ) update_gui ( ); }
/* FIXME remove when gtknotebook's func for this becomes public, bug #.... */ static EphyNotebook * find_notebook_at_pointer (gint abs_x, gint abs_y) { GdkWindow *win_at_pointer, *toplevel_win; gpointer toplevel = NULL; gint x, y; /* FIXME multi-head */ win_at_pointer = gdk_window_at_pointer (&x, &y); if (win_at_pointer == NULL) { /* We are outside all windows containing a notebook */ return NULL; } toplevel_win = gdk_window_get_toplevel (win_at_pointer); /* get the GtkWidget which owns the toplevel GdkWindow */ gdk_window_get_user_data (toplevel_win, &toplevel); /* toplevel should be an EphyWindow */ if (toplevel != NULL && EPHY_IS_WINDOW (toplevel)) { return EPHY_NOTEBOOK (ephy_window_get_notebook (EPHY_WINDOW (toplevel))); } return NULL; }
GdkWindow * do_find_current_window (void) { GdkWindow *current_window; GdkDeviceManager *manager; GdkDevice *device; current_window = screenshot_find_active_window (); manager = gdk_display_get_device_manager (gdk_display_get_default ()); device = gdk_device_manager_get_client_pointer (manager); /* If there's no active window, we fall back to returning the * window that the cursor is in. */ if (!current_window) current_window = gdk_device_get_window_at_position (device, NULL, NULL); if (current_window) { if (screenshot_window_is_desktop (current_window)) /* if the current window is the desktop (e.g. nautilus), we * return NULL, as getting the whole screen makes more sense. */ return NULL; /* Once we have a window, we take the toplevel ancestor. */ current_window = gdk_window_get_toplevel (current_window); } return current_window; }
/* FIXME remove when gtknotebook's func for this becomes public, bug #.... */ static NautilusNotebook * find_notebook_at_pointer (gint abs_x, gint abs_y) { GdkWindow *win_at_pointer, *toplevel_win; gpointer toplevel = NULL; gint x, y; /* FIXME multi-head */ win_at_pointer = gdk_window_at_pointer (&x, &y); if (win_at_pointer == NULL) { /* We are outside all windows containing a notebook */ return NULL; } toplevel_win = gdk_window_get_toplevel (win_at_pointer); /* get the GtkWidget which owns the toplevel GdkWindow */ gdk_window_get_user_data (toplevel_win, &toplevel); /* toplevel should be an NautilusWindow */ if (toplevel != NULL && NAUTILUS_IS_NAVIGATION_WINDOW (toplevel)) { return NAUTILUS_NOTEBOOK (NAUTILUS_NAVIGATION_WINDOW (toplevel)->notebook); } return NULL; }
/* FIXME remove when gtknotebook's func for this becomes public, bug #.... */ static NautilusNotebook * find_notebook_at_pointer (gint abs_x, gint abs_y) { GdkDeviceManager *manager; GdkDevice *pointer; GdkWindow *win_at_pointer, *toplevel_win; gpointer toplevel = NULL; gint x, y; /* FIXME multi-head */ manager = gdk_display_get_device_manager (gdk_display_get_default ()); pointer = gdk_device_manager_get_client_pointer (manager); win_at_pointer = gdk_device_get_window_at_position (pointer, &x, &y); if (win_at_pointer == NULL) { /* We are outside all windows containing a notebook */ return NULL; } toplevel_win = gdk_window_get_toplevel (win_at_pointer); /* get the GtkWidget which owns the toplevel GdkWindow */ gdk_window_get_user_data (toplevel_win, &toplevel); /* toplevel should be an NautilusWindow */ if (toplevel != NULL && NAUTILUS_IS_WINDOW (toplevel)) { return NAUTILUS_NOTEBOOK (NAUTILUS_WINDOW (toplevel)->details->notebook); } return NULL; }
NS_IMETHODIMP Icon::Init(nsIDOMWindow *aWindow, const nsString& aTitle) { nsresult rv; nsCOMPtr<nsIBaseWindow> baseWindow; rv = GetBaseWindow(aWindow, getter_AddRefs(baseWindow)); NS_ENSURE_SUCCESS(rv, rv); nativeWindow native = 0; rv = baseWindow->GetParentNativeWindow(&native); NS_ENSURE_SUCCESS(rv, rv); // Get the window mGdkWindow = gdk_window_get_toplevel(reinterpret_cast<GdkWindow*>(native)); if (!mGdkWindow) { return NS_ERROR_UNEXPECTED; } // Get the widget and gtk window GtkWidget *widget; gdk_window_get_user_data(mGdkWindow, reinterpret_cast<gpointer*>(&widget)); widget = gtk_widget_get_toplevel(widget); mGtkWindow = reinterpret_cast<GtkWindow*>(widget); // Set up tray icon mStatusIcon = gtk_status_icon_new(); // Get the window icon and set it GdkPixbuf *buf = gtk_window_get_icon(mGtkWindow); if (buf) { gtk_status_icon_set_from_pixbuf(mStatusIcon, buf); } else { const gchar *iconname = gtk_window_get_icon_name(mGtkWindow); if (iconname) gtk_status_icon_set_from_icon_name(mStatusIcon, iconname); } // Get and set the title if (aTitle.IsEmpty()) { gtk_status_icon_set_tooltip_text(mStatusIcon, gtk_window_get_title(mGtkWindow)); gtk_widget_add_events(widget, GDK_PROPERTY_CHANGE_MASK); propertyEventId = g_signal_connect(mGtkWindow, "property-notify-event", G_CALLBACK(gtkPropertyEvent), this); } else { NS_ConvertUTF16toUTF8 titleUTF8(aTitle); gtk_status_icon_set_tooltip_text(mStatusIcon, reinterpret_cast<const char*>(titleUTF8.get())); propertyEventId = 0; } // Add signals g_signal_connect(G_OBJECT(mStatusIcon), "button-press-event", G_CALLBACK(gtkButtonEvent), this); g_signal_connect(G_OBJECT(mStatusIcon), "button-release-event", G_CALLBACK(gtkButtonEvent), this); // Make visible gtk_status_icon_set_visible(mStatusIcon, 1); return NS_OK; }
static gint gtk_label_accessible_get_offset_at_point (AtkText *atk_text, gint x, gint y, AtkCoordType coords) { GtkWidget *widget; GtkLabel *label; const gchar *text; gint index, x_layout, y_layout; gint x_window, y_window; gint x_local, y_local; GdkWindow *window; widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text)); if (widget == NULL) return -1; label = GTK_LABEL (widget); gtk_label_get_layout_offsets (label, &x_layout, &y_layout); window = gtk_widget_get_window (widget); gdk_window_get_origin (window, &x_window, &y_window); x_local = x - x_layout - x_window; y_local = y - y_layout - y_window; if (coords == ATK_XY_WINDOW) { window = gdk_window_get_toplevel (window); gdk_window_get_origin (window, &x_window, &y_window); x_local += x_window; y_local += y_window; } if (!pango_layout_xy_to_index (gtk_label_get_layout (label), x_local * PANGO_SCALE, y_local * PANGO_SCALE, &index, NULL)) { if (x_local < 0 || y_local < 0) index = 0; else index = -1; } if (index != -1) { text = gtk_label_get_text (label); return g_utf8_pointer_to_offset (text, text + index); } return -1; }
GdkGrabStatus gdk_keyboard_grab (GdkWindow * window, gboolean owner_events, guint32 time) { gint return_val; unsigned long serial; GdkDisplay *display; GdkDisplayX11 *display_x11; GdkWindow *native; g_return_val_if_fail (window != NULL, 0); g_return_val_if_fail (GDK_IS_WINDOW (window), 0); native = gdk_window_get_toplevel (window); /* TODO: What do we do for offscreens and children? We need to proxy the grab somehow */ if (!GDK_IS_WINDOW_IMPL_X11 (GDK_WINDOW_OBJECT (native)->impl)) return GDK_GRAB_SUCCESS; display = GDK_WINDOW_DISPLAY (native); display_x11 = GDK_DISPLAY_X11 (display); serial = NextRequest (GDK_WINDOW_XDISPLAY (native)); if (!GDK_WINDOW_DESTROYED (native)) { #ifdef G_ENABLE_DEBUG if (_gdk_debug_flags & GDK_DEBUG_NOGRABS) return_val = GrabSuccess; else #endif return_val = XGrabKeyboard (GDK_WINDOW_XDISPLAY (native), GDK_WINDOW_XID (native), owner_events, GrabModeAsync, GrabModeAsync, time); if (G_UNLIKELY (!display_x11->trusted_client && return_val == AlreadyGrabbed)) /* we can't grab the keyboard, but we can do a GTK-local grab */ return_val = GrabSuccess; } else return_val = AlreadyGrabbed; if (return_val == GrabSuccess) _gdk_display_set_has_keyboard_grab (display, window, native, owner_events, serial, time); return gdk_x11_convert_grab_status (return_val); }
static void goo_canvas_item_accessible_get_extents (AtkComponent *component, gint *x, gint *y, gint *width, gint *height, AtkCoordType coord_type) { GooCanvasItem *item; GooCanvas *canvas; GObject *object; gint window_x, window_y; gint toplevel_x, toplevel_y; GdkRectangle rect; GdkWindow *window; g_return_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (component)); *x = *y = G_MININT; object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (component)); if (!object) return; item = GOO_CANVAS_ITEM (object); canvas = goo_canvas_item_get_canvas (item); if (!canvas || !GTK_WIDGET (canvas)->window) return; goo_canvas_item_accessible_get_item_extents (item, &rect); *width = rect.width; *height = rect.height; if (!goo_canvas_item_accessible_is_item_in_window (item, &rect)) return; gdk_window_get_origin (GTK_WIDGET (canvas)->window, &window_x, &window_y); *x = rect.x + window_x; *y = rect.y + window_y; if (coord_type == ATK_XY_WINDOW) { window = gdk_window_get_toplevel (GTK_WIDGET (canvas)->window); gdk_window_get_origin (window, &toplevel_x, &toplevel_y); *x -= toplevel_x; *y -= toplevel_y; } }
static GdkDrawable* rootWindowForFrame(Frame* frame) { if (!frame) return 0; FrameView* frameView = frame->view(); if (!frameView) return 0; GdkDrawable* drawable = frameView->drawable(); if (!drawable) return 0; if (!GDK_WINDOW(drawable)) return drawable; GdkWindow* window = GDK_WINDOW(drawable); return gdk_window_get_toplevel(window); }
static void gtk_label_accessible_get_character_extents (AtkText *text, gint offset, gint *x, gint *y, gint *width, gint *height, AtkCoordType coords) { GtkWidget *widget; GtkLabel *label; PangoRectangle char_rect; const gchar *label_text; gint index, x_layout, y_layout; GdkWindow *window; gint x_window, y_window; widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text)); if (widget == NULL) return; label = GTK_LABEL (widget); gtk_label_get_layout_offsets (label, &x_layout, &y_layout); label_text = gtk_label_get_text (label); index = g_utf8_offset_to_pointer (label_text, offset) - label_text; pango_layout_index_to_pos (gtk_label_get_layout (label), index, &char_rect); pango_extents_to_pixels (&char_rect, NULL); window = gtk_widget_get_window (widget); gdk_window_get_origin (window, &x_window, &y_window); *x = x_window + x_layout + char_rect.x; *y = x_window + y_layout + char_rect.y; *width = char_rect.width; *height = char_rect.height; if (coords == ATK_XY_WINDOW) { window = gdk_window_get_toplevel (window); gdk_window_get_origin (window, &x_window, &y_window); *x -= x_window; *y -= y_window; } }
static void get_origins (GtkWidget *widget, gint *x_window, gint *y_window, gint *x_toplevel, gint *y_toplevel) { GdkWindow *window; if (GTK_IS_TREE_VIEW (widget)) window = gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget)); else window = gtk_widget_get_window (widget); gdk_window_get_origin (window, x_window, y_window); window = gdk_window_get_toplevel (gtk_widget_get_window (widget)); gdk_window_get_origin (window, x_toplevel, y_toplevel); }
NS_IMETHODIMP UnwatchWindow(nsIDOMWindow *aWindow) { nsresult rv; nsCOMPtr<nsIBaseWindow> baseWindow; rv = GetBaseWindow(aWindow, getter_AddRefs(baseWindow)); NS_ENSURE_SUCCESS(rv, rv); nativeWindow native = 0; rv = baseWindow->GetParentNativeWindow(&native); NS_ENSURE_SUCCESS(rv, rv); GdkWindow *gdkWindow = gdk_window_get_toplevel(reinterpret_cast<GdkWindow*>(native)); if (!gdkWindow) { return NS_ERROR_UNEXPECTED; } gdk_window_remove_filter(gdkWindow, reinterpret_cast<GdkFilterFunc>(filterWindows), aWindow); return NS_OK; }
/* FIXME remove when gtknotebook's func for this becomes public, bug #.... */ static CajaNotebook * find_notebook_at_pointer (gint abs_x, gint abs_y) { #if GTK_CHECK_VERSION(3, 0, 0) GdkDeviceManager *manager; GdkDevice *pointer; #endif GdkWindow *win_at_pointer, *toplevel_win; gpointer toplevel = NULL; gint x, y; /* FIXME multi-head */ #if GTK_CHECK_VERSION(3, 0, 0) manager = gdk_display_get_device_manager (gdk_display_get_default ()); pointer = gdk_device_manager_get_client_pointer (manager); win_at_pointer = gdk_device_get_window_at_position (pointer, &x, &y); #else win_at_pointer = gdk_window_at_pointer (&x, &y); #endif if (win_at_pointer == NULL) { /* We are outside all windows containing a notebook */ return NULL; } toplevel_win = gdk_window_get_toplevel (win_at_pointer); /* get the GtkWidget which owns the toplevel GdkWindow */ gdk_window_get_user_data (toplevel_win, &toplevel); /* toplevel should be an CajaWindow */ if (toplevel != NULL && CAJA_IS_NAVIGATION_WINDOW (toplevel)) { return CAJA_NOTEBOOK (CAJA_NAVIGATION_WINDOW_PANE (CAJA_WINDOW (toplevel)->details->active_pane)->notebook); } return NULL; }
/* a helper function to return our toplevel GDK window given a Mozilla window. */ static nsresult GetToplevelGdkWindow(nsISupports* aWindow, GdkWindow** aToplevelWindow) { GdkWindow* window; /* we need somewhere to put the result */ if (!aToplevelWindow) { return NS_ERROR_FAILURE; } /* find the window that was passed in */ window = NativeWindowFromNode::get(aWindow); if (!GDK_IS_WINDOW(window)) { return NS_ERROR_FAILURE; } /* no, actually we want the top-level window since we're doing a resize */ window = gdk_window_get_toplevel(window); if (!GDK_IS_WINDOW(window)) { return NS_ERROR_FAILURE; } *aToplevelWindow = window; return NS_OK; }
static void gdk_device_win32_set_window_cursor (GdkDevice *device, GdkWindow *window, GdkCursor *cursor) { GdkWin32Cursor *cursor_private; GdkWindow *parent_window; GdkWindowImplWin32 *impl; HCURSOR hcursor; HCURSOR hprevcursor; impl = GDK_WINDOW_IMPL_WIN32 (window->impl); cursor_private = (GdkWin32Cursor*) cursor; hprevcursor = impl->hcursor; if (!cursor) hcursor = NULL; else hcursor = cursor_private->hcursor; if (hcursor != NULL) { /* If the pointer is over our window, set new cursor */ GdkWindow *curr_window = gdk_window_get_pointer (window, NULL, NULL, NULL); if (curr_window == window || (curr_window && window == gdk_window_get_toplevel (curr_window))) SetCursor (hcursor); else { /* Climb up the tree and find whether our window is the * first ancestor that has cursor defined, and if so, set * new cursor. */ while (curr_window && curr_window->impl && !GDK_WINDOW_IMPL_WIN32 (curr_window->impl)->hcursor) { curr_window = curr_window->parent; if (curr_window == GDK_WINDOW (window)) { SetCursor (hcursor); break; } } } } /* Unset the previous cursor: Need to make sure it's no longer in * use before we destroy it, in case we're not over our window but * the cursor is still set to our old one. */ if (hprevcursor != NULL && GetCursor () == hprevcursor) { /* Look for a suitable cursor to use instead */ hcursor = NULL; parent_window = GDK_WINDOW (window)->parent; while (hcursor == NULL) { if (parent_window) { impl = GDK_WINDOW_IMPL_WIN32 (parent_window->impl); hcursor = impl->hcursor; parent_window = parent_window->parent; } else hcursor = LoadCursor (NULL, IDC_ARROW); } SetCursor (hcursor); } }
static VALUE gdkwin_get_toplevel(VALUE self) { return GOBJ2RVAL(gdk_window_get_toplevel(_SELF(self))); }
gint drag_received (GtkWidget* widget, GdkDragContext* drag_context, gint x, gint y, GtkSelectionData* data, guint info, guint time, gpointer user_data) { // this receives drops for the whole window. if(!data || data->length < 0){ perr("no data!\n"); return -1; } dbg(1, "%s", data->data); if(g_str_has_prefix((char*)data->data, "colour:")){ char* colour_string = (char*)data->data + 7; unsigned colour_index = atoi(colour_string) ? atoi(colour_string) - 1 : 0; // which row are we on? GtkTreePath* path; GtkTreeIter iter; gint tx, treeview_top; gdk_window_get_position(app->libraryview->widget->window, &tx, &treeview_top); dbg(2, "treeview_top=%i", y); #ifdef HAVE_GTK_2_12 gint bx, by; gtk_tree_view_convert_widget_to_bin_window_coords(GTK_TREE_VIEW(app->libraryview->widget), x, y - treeview_top, &bx, &by); dbg(2, "coords: %dx%d => %dx%d", x, y, bx, by); #else gint by = y - treeview_top - 20; #endif #ifdef USE_GDL GdkWindow* top_window = gdk_window_get_toplevel(gtk_widget_get_toplevel(app->libraryview->widget)->window); GdkWindow* window = app->libraryview->widget->window; while((window = gdk_window_get_parent(window)) != top_window){ gint x0, y0; gdk_window_get_position(window, &x0, &y0); by -= y0; } #endif if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(app->libraryview->widget), x, by, &path, NULL, NULL, NULL)){ gtk_tree_model_get_iter(GTK_TREE_MODEL(samplecat.store), &iter, path); gchar* path_str = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(samplecat.store), &iter); dbg(2, "path=%s y=%i final_y=%i", path_str, y, y - treeview_top); listview_item_set_colour(path, colour_index); gtk_tree_path_free(path); } else dbg(0, "path not found."); return FALSE; } if(info == GPOINTER_TO_INT(GDK_SELECTION_TYPE_STRING)) printf(" type=string.\n"); if(info == GPOINTER_TO_INT(TARGET_URI_LIST)){ dbg(1, "type=uri_list. len=%i", data->length); GList* list = uri_list_to_glist((char*)data->data); if(g_list_length(list) < 1) pwarn("drag drop: uri list parsing found no uri's.\n"); int i = 0; ScanResults result = {0,}; GList* l = list; #ifdef __APPLE__ gdk_threads_enter(); #endif for(;l;l=l->next){ char* u = l->data; gchar* method_string; vfs_get_method_string(u, &method_string); dbg(2, "%i: %s method=%s", i, u, method_string); if(!strcmp(method_string, "file")){ //we could probably better use g_filename_from_uri() here //http://10.0.0.151/man/glib-2.0/glib-Character-Set-Conversion.html#g-filename-from-uri //-or perhaps get_local_path() from rox/src/support.c char* uri_unescaped = vfs_unescape_string(u + strlen(method_string) + 1, NULL); char* uri = (strstr(uri_unescaped, "///") == uri_unescaped) ? uri_unescaped + 2 : uri_unescaped; if(do_progress(0,0)) break; if(is_dir(uri)) application_add_dir(uri, &result); else application_add_file(uri, &result); g_free(uri_unescaped); } else pwarn("drag drop: unknown format: '%s'. Ignoring.\n", u); i++; } hide_progress(); #ifdef __APPLE__ gdk_threads_leave(); #endif statusbar_print(1, "import complete. %i files added", result.n_added); uri_list_free(list); } return FALSE; }
static PyObject * PyGdkWindow_GetAttr(PyGdkWindow_Object *self, char *key) { GdkWindow *win = PyGdkWindow_Get(self); gint x, y; GdkModifierType p_mask; if (!strcmp(key, "__members__")) return Py_BuildValue("[sssssssssssss]", "children", "colormap", "depth", "height", "parent", "pointer", "pointer_state", "toplevel", "type", "width", "x", "xid", "y"); if (!strcmp(key, "width")) { gdk_drawable_get_size(win, &x, NULL); return PyInt_FromLong(x); } if (!strcmp(key, "height")) { gdk_drawable_get_size(win, NULL, &y); return PyInt_FromLong(y); } if (!strcmp(key, "x")) { gdk_window_get_position(win, &x, NULL); return PyInt_FromLong(x); } if (!strcmp(key, "y")) { gdk_window_get_position(win, NULL, &y); return PyInt_FromLong(y); } if (!strcmp(key, "colormap")) return PyGdkColormap_New(gdk_drawable_get_colormap(win)); if (!strcmp(key, "pointer")) { gdk_window_get_pointer(win, &x, &y, NULL); return Py_BuildValue("(ii)", x, y); } if (!strcmp(key, "pointer_state")) { gdk_window_get_pointer(win, NULL, NULL, &p_mask); return PyInt_FromLong(p_mask); } if (!strcmp(key, "parent")) { GdkWindow *par = gdk_window_get_parent(win); if (par) return PyGdkWindow_New(par); Py_INCREF(Py_None); return Py_None; } if (!strcmp(key, "toplevel")) return PyGdkWindow_New(gdk_window_get_toplevel(win)); if (!strcmp(key, "children")) { GList *children, *tmp; PyObject *ret; children = gdk_window_get_children(win); if ((ret = PyList_New(0)) == NULL) return NULL; for (tmp = children; tmp != NULL; tmp = tmp->next) { PyObject *win = PyGdkWindow_New(tmp->data); if (win == NULL) { Py_DECREF(ret); return NULL; } PyList_Append(ret, win); Py_DECREF(win); } g_list_free(children); return ret; } if (!strcmp(key, "type")) return PyInt_FromLong(gdk_drawable_get_type(win)); if (!strcmp(key, "depth")) { gdk_window_get_geometry(win, NULL, NULL, NULL, NULL, &x); return PyInt_FromLong(x); } #ifdef WITH_XSTUFF if (!strcmp(key, "xid")) return PyInt_FromLong(GDK_WINDOW_XWINDOW(win)); #endif return Py_FindMethod(PyGdkWindow_methods, (PyObject *)self, key); }