static void na_tray_child_realize (GtkWidget *widget) { NaTrayChild *child = NA_TRAY_CHILD (widget); GdkVisual *visual = gtk_widget_get_visual (widget); GdkWindow *window; GTK_WIDGET_CLASS (na_tray_child_parent_class)->realize (widget); window = gtk_widget_get_window (widget); if (child->has_alpha) { /* We have real transparency with an ARGB visual and the Composite * extension. */ /* Set a transparent background */ GdkColor transparent = { 0, 0, 0, 0 }; /* only pixel=0 matters */ gdk_window_set_background (window, &transparent); gdk_window_set_composited (window, TRUE); child->parent_relative_bg = FALSE; } #if GTK_CHECK_VERSION(3, 0, 0) else if (visual == gdk_window_get_visual(gdk_window_get_parent(window))) #else else if (visual == gdk_drawable_get_visual(GDK_DRAWABLE(gdk_window_get_parent(window)))) #endif { /* Otherwise, if the visual matches the visual of the parent window, we * can use a parent-relative background and fake transparency. */ gdk_window_set_back_pixmap (window, NULL, TRUE); child->parent_relative_bg = TRUE; } else { /* Nothing to do; the icon will sit on top of an ugly gray box */ child->parent_relative_bg = FALSE; } gdk_window_set_composited (window, child->composited); gtk_widget_set_app_paintable (GTK_WIDGET (child), child->parent_relative_bg || child->has_alpha); /* Double-buffering will interfere with the parent-relative-background fake * transparency, since the double-buffer code doesn't know how to fill in the * background of the double-buffer correctly. */ gtk_widget_set_double_buffered (GTK_WIDGET (child), child->parent_relative_bg); }
JNIEXPORT jlong JNICALL Java_org_gnome_gdk_GdkWindow_gdk_1window_1get_1parent ( JNIEnv* env, jclass cls, jlong _self ) { GdkWindow* result; jlong _result; GdkWindow* self; // convert parameter self self = (GdkWindow*) _self; // call function result = gdk_window_get_parent(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; }
void WinDraw_InitWindowSize(WORD width, WORD height) { static BOOL inited = FALSE; if (!inited) { GdkWindow *t, *root = window->window; while ((t = gdk_window_get_parent(root)) != 0) root = t; gdk_window_get_size(root, &root_width, &root_height); inited = TRUE; } gdk_window_get_position(window->window, &winx, &winy); winw = width; winh = height; if (root_width < winw) winx = (root_width - winw) / 2; else if (winx < 0) winx = 0; else if ((winx + winw) > root_width) winx = root_width - winw; if (root_height < winh) winy = (root_height - winh) / 2; else if (winy < 0) winy = 0; else if ((winy + winh) > root_height) winy = root_height - winh; }
/** * anjuta_tabber_get_widget_coordinates: * @widget: widget for the coordinates * @event: event to get coordinates from * @x: return location for x coordinate * @y: return location for y coordinate * * Returns: %TRUE if coordinates were set, %FALSE otherwise */ static gboolean anjuta_tabber_get_widget_coordinates (GtkWidget *widget, GdkEvent *event, gint *x, gint *y) { GdkWindow *window = ((GdkEventAny *)event)->window; gdouble tx, ty; if (!gdk_event_get_coords (event, &tx, &ty)) return FALSE; while (window && window != gtk_widget_get_window (widget)) { gint window_x, window_y; gdk_window_get_position (window, &window_x, &window_y); tx += window_x; ty += window_y; window = gdk_window_get_parent (window); } if (window) { *x = tx; *y = ty; return TRUE; } else return FALSE; }
static void na_tray_child_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { NaTrayChild *child = NA_TRAY_CHILD (widget); GtkAllocation widget_allocation; gboolean moved, resized; gtk_widget_get_allocation (widget, &widget_allocation); moved = (allocation->x != widget_allocation.x || allocation->y != widget_allocation.y); resized = (allocation->width != widget_allocation.width || allocation->height != widget_allocation.height); /* When we are allocating the widget while mapped we need special handling * for both real and fake transparency. * * Real transparency: we need to invalidate and trigger a redraw of the old * and new areas. (GDK really should handle this for us, but doesn't as of * GTK+-2.14) * * Fake transparency: if the widget moved, we need to force the contents to * be redrawn with the new offset for the parent-relative background. */ if ((moved || resized) && gtk_widget_get_mapped (widget)) { if (na_tray_child_has_alpha (child)) gdk_window_invalidate_rect (gdk_window_get_parent (gtk_widget_get_window (widget)), &widget_allocation, FALSE); } GTK_WIDGET_CLASS (na_tray_child_parent_class)->size_allocate (widget, allocation); if ((moved || resized) && gtk_widget_get_mapped (widget)) { if (na_tray_child_has_alpha (NA_TRAY_CHILD (widget))) gdk_window_invalidate_rect (gdk_window_get_parent (gtk_widget_get_window (widget)), &widget_allocation, FALSE); else if (moved && child->parent_relative_bg) na_tray_child_force_redraw (child); } }
static void na_tray_child_realize (GtkWidget *widget) { NaTrayChild *child = NA_TRAY_CHILD (widget); GdkVisual *visual = gtk_widget_get_visual (widget); GdkWindow *window; GTK_WIDGET_CLASS (na_tray_child_parent_class)->realize (widget); window = gtk_widget_get_window (widget); if (child->has_alpha) { /* We have real transparency with an ARGB visual and the Composite * extension. */ /* Set a transparent background */ cairo_pattern_t *transparent = cairo_pattern_create_rgba (0, 0, 0, 0); gdk_window_set_background_pattern (window, transparent); gdk_window_set_composited (window, TRUE); cairo_pattern_destroy (transparent); child->parent_relative_bg = FALSE; } else if (visual == gdk_window_get_visual (gdk_window_get_parent (window))) { /* Otherwise, if the visual matches the visual of the parent window, we * can use a parent-relative background and fake transparency. */ gdk_window_set_background_pattern (window, NULL); child->parent_relative_bg = TRUE; } else { /* Nothing to do; the icon will sit on top of an ugly gray box */ child->parent_relative_bg = FALSE; } gdk_window_set_composited (window, child->composited); gtk_widget_set_app_paintable (GTK_WIDGET (child), child->parent_relative_bg || child->has_alpha); /* Double-buffering will interfere with the parent-relative-background fake * transparency, since the double-buffer code doesn't know how to fill in the * background of the double-buffer correctly. */ gtk_widget_set_double_buffered (GTK_WIDGET (child), child->parent_relative_bg); }
PRIVATE GdkFilterReturn monitor_icon_event(GdkXEvent* xevent, GdkEvent* event, GdkWindow* wrapper) { XEvent* xev = xevent; if (xev->type == DestroyNotify) { if (_deepin_tray == wrapper ) { destroy_wrapper(_deepin_tray); _deepin_tray = NULL; _deepin_tray_width = 0; _update_fcitx_try_position(); } else if (_fcitx_tray == wrapper) { destroy_wrapper(_fcitx_tray); _fcitx_tray = NULL; _fcitx_tray_width = 0; _update_notify_area_width(); } else { g_hash_table_remove(_icons, wrapper); destroy_wrapper(wrapper); _update_notify_area_width(); } return GDK_FILTER_CONTINUE; } else if (xev->type == ConfigureNotify) { XConfigureEvent* xev = (XConfigureEvent*)xevent; int new_width = ((XConfigureEvent*)xev)->width; if (wrapper == _deepin_tray) { _deepin_tray_width = CLAMP_WIDTH(new_width); _update_deepin_try_position(); } else if (wrapper == _fcitx_tray) { _fcitx_tray_width = CLAMP_WIDTH(new_width); _update_fcitx_try_position(); } else if (wrapper != _deepin_tray && wrapper != _fcitx_tray) { int new_height = ((XConfigureEvent*)xev)->height; g_hash_table_insert(_icons, wrapper, GINT_TO_POINTER(CLAMP_WIDTH((new_width * 1.0 / new_height * DEFAULT_HEIGHT)))); _update_notify_area_width(); } return GDK_FILTER_REMOVE; } else if (xev->type == GenericEvent) { GdkWindow* parent = gdk_window_get_parent(wrapper); XGenericEvent* ge = xevent; if (ge->evtype == EnterNotify) { g_object_set_data(G_OBJECT(wrapper), "is_mouse_in", GINT_TO_POINTER(TRUE)); gdk_window_invalidate_rect(parent, NULL, TRUE); } else if (ge->evtype == LeaveNotify) { g_object_set_data(G_OBJECT(wrapper), "is_mouse_in", GINT_TO_POINTER(FALSE)); gdk_window_invalidate_rect(parent, NULL, TRUE); } return GDK_FILTER_REMOVE; } return GDK_FILTER_CONTINUE; }
static void realize(GtkWidget* widget) { parent_class->realize(widget); wxPizza* pizza = WX_PIZZA(widget); if (pizza->m_border_style || pizza->m_is_scrollable) { int border_x, border_y; pizza->get_border_widths(border_x, border_y); int x = widget->allocation.x + border_x; int y = widget->allocation.y + border_y; int w = widget->allocation.width - 2 * border_x; int h = widget->allocation.height - 2 * border_y; if (w < 0) w = 0; if (h < 0) h = 0; if (pizza->m_is_scrollable) { // second window is created if wxWindow is scrollable GdkWindowAttr attr; attr.event_mask = 0; attr.x = x; attr.y = y; attr.width = w; attr.height = h; attr.wclass = GDK_INPUT_OUTPUT; attr.visual = gtk_widget_get_visual(widget); attr.colormap = gtk_widget_get_colormap(widget); attr.window_type = GDK_WINDOW_CHILD; pizza->m_backing_window = gdk_window_new( gdk_window_get_parent(widget->window), &attr, GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP); gdk_window_set_user_data(pizza->m_backing_window, widget); gdk_window_reparent(widget->window, pizza->m_backing_window, 0, 0); gdk_window_resize(widget->window, w, h); // Parts of m_backing_window may be exposed temporarily while // resizing. Setting the backing pixmap to None prevents those // areas from being briefly painted black. gdk_window_set_back_pixmap(pizza->m_backing_window, NULL, false); } else gdk_window_move_resize(widget->window, x, y, w, h); } }
static gboolean is_parent_of (GdkWindow *parent, GdkWindow *child) { GdkWindow *w; w = child; while (w != NULL) { if (w == parent) return TRUE; w = gdk_window_get_parent (w); } return FALSE; }
GdkWindow * gdk_xynth_other_event_window (GdkWindow *window, GdkEventType type) { GdkWindow *w; guint32 evmask; ENTER(); w = window; while (w != _gdk_parent_root) { if ((w != window) && (GDK_WINDOW_OBJECT(w)->window_type != GDK_WINDOW_CHILD) && (g_object_get_data(G_OBJECT(w), "gdk-window-child-handler"))) { break; } evmask = GDK_WINDOW_OBJECT(w)->event_mask; if (evmask & type_masks[type]) { LEAVE(); return w; } w = gdk_window_get_parent(w); } LEAVE(); return NULL; }
GtkWidget* remmina_widget_pool_find_by_window(GType type, GdkWindow *window) { GtkWidget *widget; gint i; GdkWindow *parent; if (window == NULL || remmina_widget_pool == NULL) return NULL; for (i = 0; i < remmina_widget_pool->len; i++) { widget = GTK_WIDGET(g_ptr_array_index(remmina_widget_pool, i)); if (!G_TYPE_CHECK_INSTANCE_TYPE(widget, type)) continue; /* gdk_window_get_toplevel won't work here, if the window is an embedded client. So we iterate the window tree */ for (parent = window; parent && parent != GDK_WINDOW_ROOT; parent = gdk_window_get_parent(parent)) { if (gtk_widget_get_window(widget) == parent) return widget; } } return NULL; }
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); }
nsresult EmbedPrivate::Realize(PRBool *aAlreadyRealized) { *aAlreadyRealized = PR_FALSE; // create the offscreen window if we have to EnsureOffscreenWindow(); // Have we ever been initialized before? If so then just reparent // from the offscreen window. if (mMozWindowWidget) { gtk_widget_reparent(mMozWindowWidget, GTK_WIDGET(mOwningWidget)); *aAlreadyRealized = PR_TRUE; return NS_OK; } // Get the nsIWebBrowser object for our embedded window. nsCOMPtr<nsIWebBrowser> webBrowser; mWindow->GetWebBrowser(getter_AddRefs(webBrowser)); // get a handle on the navigation object mNavigation = do_QueryInterface(webBrowser); // Create our session history object and tell the navigation object // to use it. We need to do this before we create the web browser // window. mSessionHistory = do_CreateInstance(NS_SHISTORY_CONTRACTID); mNavigation->SetSessionHistory(mSessionHistory); // create the window mWindow->CreateWindow(); // bind the progress listener to the browser object nsCOMPtr<nsISupportsWeakReference> supportsWeak; supportsWeak = do_QueryInterface(mProgressGuard); nsCOMPtr<nsIWeakReference> weakRef; supportsWeak->GetWeakReference(getter_AddRefs(weakRef)); webBrowser->AddWebBrowserListener(weakRef, NS_GET_IID(nsIWebProgressListener)); // set ourselves as the parent uri content listener nsCOMPtr<nsIURIContentListener> uriListener; uriListener = do_QueryInterface(mContentListenerGuard); webBrowser->SetParentURIContentListener(uriListener); // save the window id of the newly created window nsCOMPtr<nsIWidget> mozWidget; mWindow->mBaseWindow->GetMainWidget(getter_AddRefs(mozWidget)); // get the native drawing area GdkWindow *tmp_window = static_cast<GdkWindow *>( mozWidget->GetNativeData(NS_NATIVE_WINDOW)); // and, thanks to superwin we actually need the parent of that. tmp_window = gdk_window_get_parent(tmp_window); // save the widget ID - it should be the mozarea of the window. gpointer data = nsnull; gdk_window_get_user_data(tmp_window, &data); mMozWindowWidget = static_cast<GtkWidget *>(data); // Apply the current chrome mask ApplyChromeMask(); return NS_OK; }
static GtkWidget * find_widget_under_pointer (GdkWindow *window, gint *x, gint *y) { GtkWidget *event_widget; struct ChildLocation child_loc = { NULL, NULL, 0, 0 }; gdk_window_get_user_data (window, (void **)&event_widget); if (! event_widget) return NULL; #ifdef DEBUG_TOOLTIP g_print ("event window %p (belonging to %p (%s)) (%d, %d)\n", window, event_widget, gtk_widget_get_name (event_widget), *x, *y); #endif /* Coordinates are relative to event window */ child_loc.x = *x; child_loc.y = *y; /* We go down the window hierarchy to the widget->window, * coordinates stay relative to the current window. * We end up with window == widget->window, coordinates relative to that. */ while (window && window != gtk_widget_get_window (event_widget)) { gint px, py; gdk_window_get_position (window, &px, &py); child_loc.x += px; child_loc.y += py; window = gdk_window_get_parent (window); } /* Failing to find widget->window can happen for e.g. a detached handle box; * chaining ::query-tooltip up to its parent probably makes little sense, * and users better implement tooltips on handle_box->child. * so we simply ignore the event for tooltips here. */ if (!window) return NULL; /* Convert the window relative coordinates to allocation * relative coordinates. */ window_to_alloc (event_widget, child_loc.x, child_loc.y, &child_loc.x, &child_loc.y); if (GTK_IS_CONTAINER (event_widget)) { GtkWidget *container = event_widget; child_loc.container = event_widget; child_loc.child = NULL; gtk_container_forall (GTK_CONTAINER (event_widget), child_location_foreach, &child_loc); /* Here we have a widget, with coordinates relative to * child_loc.container's allocation. */ if (child_loc.child) event_widget = child_loc.child; else if (child_loc.container) event_widget = child_loc.container; /* Translate to event_widget's allocation */ gtk_widget_translate_coordinates (container, event_widget, child_loc.x, child_loc.y, &child_loc.x, &child_loc.y); } /* We return (x, y) relative to the allocation of event_widget. */ if (x) *x = child_loc.x; if (y) *y = child_loc.y; return event_widget; }
static VALUE gdkwin_get_parent(VALUE self) { return GOBJ2RVAL(gdk_window_get_parent(_SELF(self))); }
GdkWindow * gdk_xynth_pointer_event_window (GdkWindow *window, GdkEventType type) { guint evmask; GdkWindow *w; GdkModifierType mask; ENTER(); gdk_xynth_mouse_get_info(NULL, NULL, &mask); if (_gdk_xynth_pointer_grab_window && !_gdk_xynth_pointer_grab_owner_events) { evmask = _gdk_xynth_pointer_grab_events; if (evmask & (GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK | GDK_BUTTON3_MOTION_MASK)) { if (((mask & GDK_BUTTON1_MASK) && (evmask & GDK_BUTTON1_MOTION_MASK)) || ((mask & GDK_BUTTON2_MASK) && (evmask & GDK_BUTTON2_MOTION_MASK)) || ((mask & GDK_BUTTON3_MASK) && (evmask & GDK_BUTTON3_MOTION_MASK))) { evmask |= GDK_POINTER_MOTION_MASK; } } if (evmask & type_masks[type]) { if (_gdk_xynth_pointer_grab_owner_events) { LEAVE(); return _gdk_xynth_pointer_grab_window; } else { GdkWindowObject *obj= GDK_WINDOW_OBJECT(window); while (obj != NULL && obj != GDK_WINDOW_OBJECT(_gdk_xynth_pointer_grab_window)) { obj = (GdkWindowObject *) obj->parent; } if (obj == GDK_WINDOW_OBJECT(_gdk_xynth_pointer_grab_window)) { LEAVE(); return window; } else { LEAVE(); return _gdk_xynth_pointer_grab_window; } } } } w = window; while (w != _gdk_parent_root) { /* Huge hack, so that we don't propagate events to GtkWindow->frame */ if ((w != window) && (GDK_WINDOW_OBJECT(w)->window_type != GDK_WINDOW_CHILD) && (g_object_get_data(G_OBJECT(w), "gdk-window-child-handler"))) { break; } evmask = GDK_WINDOW_OBJECT(w)->event_mask; if (evmask & (GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK | GDK_BUTTON3_MOTION_MASK)) { if (((mask & GDK_BUTTON1_MASK) && (evmask & GDK_BUTTON1_MOTION_MASK)) || ((mask & GDK_BUTTON2_MASK) && (evmask & GDK_BUTTON2_MOTION_MASK)) || ((mask & GDK_BUTTON3_MASK) && (evmask & GDK_BUTTON3_MOTION_MASK))) { evmask |= GDK_POINTER_MOTION_MASK; } } if (evmask & type_masks[type]) { LEAVE(); return w; } w = gdk_window_get_parent(w); } LEAVE(); return NULL; }
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 void find_widget (GtkWidget *widget, FindWidgetData *data) { GtkAllocation new_allocation; gint x_offset = 0; gint y_offset = 0; gtk_widget_get_allocation (widget, &new_allocation); if (data->found || !gtk_widget_get_mapped (widget)) return; /* Note that in the following code, we only count the * position as being inside a WINDOW widget if it is inside * widget->window; points that are outside of widget->window * but within the allocation are not counted. This is consistent * with the way we highlight drag targets. */ if (gtk_widget_get_has_window (widget)) { new_allocation.x = 0; new_allocation.y = 0; } if (gtk_widget_get_parent (widget) && !data->first) { GdkWindow *window; window = gtk_widget_get_window (widget); while (window != gtk_widget_get_window (gtk_widget_get_parent (widget))) { gint tx, ty, twidth, theight; if (window == NULL) return; twidth = gdk_window_get_width (window); theight = gdk_window_get_height (window); if (new_allocation.x < 0) { new_allocation.width += new_allocation.x; new_allocation.x = 0; } if (new_allocation.y < 0) { new_allocation.height += new_allocation.y; new_allocation.y = 0; } if (new_allocation.x + new_allocation.width > twidth) new_allocation.width = twidth - new_allocation.x; if (new_allocation.y + new_allocation.height > theight) new_allocation.height = theight - new_allocation.y; gdk_window_get_position (window, &tx, &ty); new_allocation.x += tx; x_offset += tx; new_allocation.y += ty; y_offset += ty; window = gdk_window_get_parent (window); } } if ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) && (data->x < new_allocation.x + new_allocation.width) && (data->y < new_allocation.y + new_allocation.height)) { /* First, check if the drag is in a valid drop site in * one of our children */ if (GTK_IS_CONTAINER (widget)) { FindWidgetData new_data = *data; new_data.x -= x_offset; new_data.y -= y_offset; new_data.found = FALSE; new_data.first = FALSE; gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback)find_widget, &new_data); data->found = new_data.found; if (data->found) data->res_widget = new_data.res_widget; } /* If not, and this widget is registered as a drop site, check to * emit "drag_motion" to check if we are actually in * a drop site. */ if (!data->found) { data->found = TRUE; data->res_widget = widget; } } }