static GtkWidget * build_tab_label (EphyNotebook *nb, EphyEmbed *embed) { GtkWidget *tab_label; EphyWebView *view; tab_label = ephy_tab_label_new (); g_signal_connect (tab_label, "close-clicked", G_CALLBACK (close_button_clicked_cb), embed); /* Set up drag-and-drop target */ g_signal_connect (tab_label, "drag-data-received", G_CALLBACK (notebook_drag_data_received_cb), embed); gtk_drag_dest_set (tab_label, GTK_DEST_DEFAULT_ALL, url_drag_types, G_N_ELEMENTS (url_drag_types), GDK_ACTION_MOVE | GDK_ACTION_COPY); gtk_drag_dest_add_text_targets (tab_label); /* Hook the label up to the tab properties */ view = ephy_embed_get_web_view (embed); g_signal_connect_object (embed, "notify::title", G_CALLBACK (rebuild_tab_menu_cb), nb, 0); g_object_bind_property (view, "title", tab_label, "label-text", G_BINDING_DEFAULT); g_object_bind_property (view, "display-address", tab_label, "label-uri", G_BINDING_DEFAULT); g_object_bind_property (view, "icon", tab_label, "icon-buf", G_BINDING_DEFAULT); g_object_bind_property (view, "is-loading", tab_label, "spinning", G_BINDING_DEFAULT); g_object_bind_property (view, "is-playing-audio", tab_label, "audio", G_BINDING_DEFAULT); return tab_label; }
static void gtk_ellipsis_init (GtkEllipsis *ellipsis) { GtkEllipsisPrivate *priv; ellipsis->priv = priv = GTK_ELLIPSIS_GET_PRIVATE (ellipsis); GTK_WIDGET_SET_FLAGS (ellipsis, GTK_CAN_FOCUS); GTK_WIDGET_SET_FLAGS (ellipsis, GTK_NO_WINDOW); priv->label = NULL; priv->ellipsis_label = NULL; priv->event_window = NULL; priv->wrap_mode = GTK_ELLIPSIS_DEFAULT_WRAP; priv->expanded = FALSE; priv->use_underline = FALSE; priv->use_markup = FALSE; priv->button_down = FALSE; priv->prelight = FALSE; priv->expand_timer = 0; gtk_drag_dest_set (GTK_WIDGET (ellipsis), 0, NULL, 0, 0); gtk_drag_dest_set_track_motion (GTK_WIDGET (ellipsis), TRUE); }
static GtkWidget *create_video_window(LinphoneCall *call){ char *remote,*title; GtkWidget *video_window; const LinphoneAddress *addr; guint timeout; MSVideoSize vsize={MS_VIDEO_SIZE_CIF_W,MS_VIDEO_SIZE_CIF_H}; GdkColor color; addr=linphone_call_get_remote_address(call); remote=linphone_gtk_address(addr); video_window=gtk_window_new(GTK_WINDOW_TOPLEVEL); /*gtk_window_set_transient_for(GTK_WINDOW(video_window), GTK_WINDOW(linphone_gtk_get_main_window()));*/ title=g_strdup_printf("%s - Video call with %s",linphone_gtk_get_ui_config("title","Linphone"),remote); ms_free(remote); gtk_window_set_title(GTK_WINDOW(video_window),title); g_free(title); gtk_window_resize(GTK_WINDOW(video_window),vsize.width,vsize.height); gdk_color_parse("black",&color); gtk_widget_modify_bg(video_window,GTK_STATE_NORMAL,&color); gtk_drag_dest_set(video_window, GTK_DEST_DEFAULT_ALL, targets, sizeof(targets)/sizeof(GtkTargetEntry), GDK_ACTION_COPY); gtk_widget_show(video_window); gdk_window_set_events(gtk_widget_get_window(video_window), gdk_window_get_events(gtk_widget_get_window(video_window)) | GDK_POINTER_MOTION_MASK); timeout=g_timeout_add(500,(GSourceFunc)resize_video_window,call); g_signal_connect(video_window,"destroy",(GCallback)on_video_window_destroy,GINT_TO_POINTER(timeout)); g_signal_connect(video_window,"key-press-event",(GCallback)on_video_window_key_press,NULL); g_signal_connect_swapped(video_window,"motion-notify-event",(GCallback)show_video_controls,video_window); g_signal_connect(video_window,"configure-event",(GCallback)video_window_moved,NULL); g_signal_connect(video_window, "drag-data-received",(GCallback)drag_data_received, NULL); g_signal_connect(video_window, "drag-drop",(GCallback)drag_drop, NULL); g_object_set_data(G_OBJECT(video_window),"call",call); return video_window; }
void list_init(void) { GType types[COL_N]; for (int i = 0; i < HASH_FUNCS_N; i++) { gtk_tree_view_insert_column_with_attributes(gui.treeview, -1, hash.funcs[i].name, gtk_cell_renderer_text_new(), "text", COL_HASH + i, NULL); } for (int i = 0; i < COL_N; i++) { types[i] = G_TYPE_STRING; GtkTreeViewColumn *col = gtk_tree_view_get_column(gui.treeview, i); gtk_tree_view_column_set_resizable(col, true); } gui.liststore = gtk_list_store_newv(COL_N, types); gui.treemodel = GTK_TREE_MODEL(gui.liststore); gtk_tree_view_set_model(gui.treeview, gui.treemodel); gtk_tree_selection_set_mode(gui.treeselection, GTK_SELECTION_MULTIPLE); const GtkTargetEntry targets[] = { { (char *)"text/uri-list", 0, 0 } }; gtk_drag_dest_set(GTK_WIDGET(gui.treeview), GTK_DEST_DEFAULT_ALL, targets, G_N_ELEMENTS(targets), GDK_ACTION_COPY); }
static void trash_applet_init (TrashApplet *applet) { const GtkTargetEntry drop_types[] = { { "text/uri-list" } }; /* needed to clamp ourselves to the panel size */ panel_applet_set_flags (PANEL_APPLET (applet), PANEL_APPLET_EXPAND_MINOR); /* setup the image */ applet->image = g_object_ref_sink (gtk_image_new ()); gtk_container_add (GTK_CONTAINER (applet), GTK_WIDGET (applet->image)); gtk_widget_show (GTK_WIDGET (applet->image)); /* setup the trash backend */ applet->trash = g_file_new_for_uri ("trash:/"); applet->trash_monitor = g_file_monitor_file (applet->trash, 0, NULL, NULL); g_signal_connect_swapped (applet->trash_monitor, "changed", G_CALLBACK (trash_applet_monitor_changed), applet); /* setup drag and drop */ gtk_drag_dest_set (GTK_WIDGET (applet), GTK_DEST_DEFAULT_ALL, drop_types, G_N_ELEMENTS (drop_types), GDK_ACTION_MOVE); /* synthesise the first update */ applet->items = -1; trash_applet_monitor_changed (applet); }
/* * Configure the GtkIconView: background color, visual columns, drag-and-drop, * and icon activation. */ static void set_up_icon_view(GtkWidget *icons, struct state *d) { /* Background color */ GdkRGBA transparent = {0, 0, 0, 0}; override_background_color(icons, &transparent); /* Columns */ gtk_icon_view_set_text_column(d->icon_view, FILE_NAME); gtk_icon_view_set_pixbuf_column(d->icon_view, FILE_ICON); /* Drag */ gtk_drag_source_set(icons, GDK_BUTTON1_MASK, dnd_targets, TARGET_COUNT, GDK_ACTION_COPY | GDK_ACTION_MOVE); gtk_drag_source_add_text_targets(icons); gtk_drag_source_add_uri_targets(icons); g_signal_connect(icons, "drag-begin", G_CALLBACK(on_icons_drag_begin), d); g_signal_connect(icons, "drag-data-get", G_CALLBACK(on_icons_drag_data_get), d); g_signal_connect(icons, "drag-end", G_CALLBACK(on_icons_drag_end), d); /* Drop */ gtk_drag_dest_set(icons, GTK_DEST_DEFAULT_ALL, dnd_targets, TARGET_COUNT, GDK_ACTION_COPY | GDK_ACTION_MOVE); gtk_drag_dest_add_text_targets(icons); gtk_drag_dest_add_uri_targets(icons); g_signal_connect(icons, "drag-motion", G_CALLBACK(on_icons_drag_motion), d); g_signal_connect(icons, "drag-leave", G_CALLBACK(on_icons_data_leave), d); g_signal_connect(icons, "drag-data-received", G_CALLBACK(on_icons_drag_data_received), d); /* Activations */ g_signal_connect(icons, "item-activated", G_CALLBACK(on_icons_item_activated), d); g_signal_connect(icons, "button-press-event", G_CALLBACK(on_desktop_icon_button_press_event), d); }
gboolean CreateAudioModulePanelIdleCode (AudioModulePanel * action) { action -> viewport = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (action -> viewport), action -> atom -> name ()); //gtk_window_set_decorated (GTK_WINDOW (action -> viewport), FALSE); g_signal_connect (action -> viewport, "delete-event", G_CALLBACK (AudioModulePanelDeleteEvent), action); action -> area = gtk_drawing_area_new (); gtk_container_add (GTK_CONTAINER (action -> viewport), action -> area); action -> gtk_redrawer = g_signal_connect (G_OBJECT (action -> area), "expose-event", G_CALLBACK (RedrawAudioModulePanel), action); gtk_widget_add_events (action -> viewport, GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK); g_signal_connect (G_OBJECT (action -> viewport), "button_press_event", G_CALLBACK (AudioModulePanelKeyon), action); g_signal_connect (G_OBJECT (action -> viewport), "button_release_event", G_CALLBACK (AudioModulePanelKeyoff), action); g_signal_connect (G_OBJECT (action -> viewport), "motion_notify_event", G_CALLBACK (AudioModulePanelMove), action); g_signal_connect (G_OBJECT (action -> viewport), "key-press-event", G_CALLBACK (AudioModulePanelFunctionKey), action); if (action -> background_image != 0) gtk_window_resize (GTK_WINDOW (action -> viewport), cairo_image_surface_get_width (action -> background_image), cairo_image_surface_get_height (action -> background_image)); gtk_window_move (GTK_WINDOW (action -> viewport), (int) action -> location . x, (int) action -> location . y); //gtk_window_set_position (GTK_WINDOW (action -> viewport), GTK_WIN_POS_CENTER); const GtkTargetEntry targets [3] = {{"text/plain", 0, 0}, {"text/uri-list", 0, 0}, {"application/x-rootwindow-drop", 0, 0}}; gtk_drag_dest_set (action -> area, GTK_DEST_DEFAULT_ALL, targets, 3, GDK_ACTION_COPY); g_signal_connect (action -> area, "drag-drop", G_CALLBACK (dnd_drop), action); g_signal_connect (action -> area, "drag-motion", G_CALLBACK (dnd_motion), 0); g_signal_connect (action -> area, "drag-data-received", G_CALLBACK (dnd_receive), action); g_signal_connect (action -> area, "drag-leave", G_CALLBACK (dnd_leave), 0); gtk_widget_show_all (action -> viewport); return FALSE; }
static void e_image_chooser_init (EImageChooser *chooser) { EImageChooserPrivate *priv; priv = chooser->priv = g_new0 (EImageChooserPrivate, 1); priv->image = gtk_image_new (); gtk_box_set_homogeneous (GTK_BOX (chooser), FALSE); gtk_box_pack_start (GTK_BOX (chooser), priv->image, TRUE, TRUE, 0); gtk_drag_dest_set (priv->image, 0, image_drag_types, num_image_drag_types, GDK_ACTION_COPY); g_signal_connect (priv->image, "drag_motion", G_CALLBACK (image_drag_motion_cb), chooser); g_signal_connect (priv->image, "drag_drop", G_CALLBACK (image_drag_drop_cb), chooser); g_signal_connect (priv->image, "drag_data_received", G_CALLBACK (image_drag_data_received_cb), chooser); gtk_widget_show_all (priv->image); /* we default to being editable */ priv->editable = TRUE; }
static void cairo_main_icon_constructed (GObject *object) { CairoMainIconPrivate * priv = GET_PRIVATE (object); GdkPixbuf * pbuf; gint size = awn_applet_get_size (priv->applet); G_OBJECT_CLASS (cairo_main_icon_parent_class)->constructed (object); awn_themed_icon_set_info_simple (AWN_THEMED_ICON(object),"cairo-menu",awn_applet_get_uid (priv->applet),"gnome-main-menu"); awn_themed_icon_set_size (AWN_THEMED_ICON (object),size); gtk_drag_dest_set (GTK_WIDGET (object), GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP, drop_types, n_drop_types, GDK_ACTION_COPY | GDK_ACTION_ASK); /* call our function in the module */ priv->menu_instance = get_menu_instance (priv->applet, (GetRunCmdFunc)cairo_menu_applet_get_run_cmd, (GetSearchCmdFunc)cairo_menu_applet_get_search_cmd, (AddIconFunc) cairo_menu_applet_add_icon, (CheckMenuHiddenFunc) cairo_menu_applet_check_hidden_menu, NULL, 0); g_idle_add ( (GSourceFunc)queue_menu_build, object); awn_icon_set_tooltip_text (AWN_ICON (object), _("Main Menu")); }
static void empathy_avatar_chooser_init (EmpathyAvatarChooser *chooser) { EmpathyAvatarChooserPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser, EMPATHY_TYPE_AVATAR_CHOOSER, EmpathyAvatarChooserPriv); chooser->priv = priv; gtk_drag_dest_set (GTK_WIDGET (chooser), GTK_DEST_DEFAULT_ALL, drop_types, G_N_ELEMENTS (drop_types), GDK_ACTION_COPY); g_signal_connect (chooser, "drag-motion", G_CALLBACK (avatar_chooser_drag_motion_cb), chooser); g_signal_connect (chooser, "drag-leave", G_CALLBACK (avatar_chooser_drag_leave_cb), chooser); g_signal_connect (chooser, "drag-drop", G_CALLBACK (avatar_chooser_drag_drop_cb), chooser); g_signal_connect (chooser, "drag-data-received", G_CALLBACK (avatar_chooser_drag_data_received_cb), chooser); g_signal_connect (chooser, "clicked", G_CALLBACK (avatar_chooser_clicked_cb), chooser); empathy_avatar_chooser_set (chooser, NULL); }
void wxDropTarget::RegisterWidget( GtkWidget *widget ) { wxCHECK_RET( widget != NULL, wxT("register widget is NULL") ); /* gtk_drag_dest_set() determines what default behaviour we'd like GTK to supply. we don't want to specify out targets (=formats) or actions in advance (i.e. not GTK_DEST_DEFAULT_MOTION and not GTK_DEST_DEFAULT_DROP). instead we react individually to "drag_motion" and "drag_drop" events. this makes it possible to allow dropping on only a small area. we should set GTK_DEST_DEFAULT_HIGHLIGHT as this will switch on the nice highlighting if dragging over standard controls, but this seems to be broken without the other two. */ gtk_drag_dest_set( widget, (GtkDestDefaults) 0, /* no default behaviour */ NULL, /* we don't supply any formats here */ 0, /* number of targets = 0 */ (GdkDragAction) 0 ); /* we don't supply any actions here */ gtk_signal_connect( GTK_OBJECT(widget), "drag_leave", GTK_SIGNAL_FUNC(target_drag_leave), (gpointer) this ); gtk_signal_connect( GTK_OBJECT(widget), "drag_motion", GTK_SIGNAL_FUNC(target_drag_motion), (gpointer) this ); gtk_signal_connect( GTK_OBJECT(widget), "drag_drop", GTK_SIGNAL_FUNC(target_drag_drop), (gpointer) this ); gtk_signal_connect( GTK_OBJECT(widget), "drag_data_received", GTK_SIGNAL_FUNC(target_drag_data_received), (gpointer) this ); }
void setup_dnd(GtkWidget *wid) { GtkTargetEntry target_entry[3]; target_entry[0].target = WAVE_DRAG_TAR_NAME_0; target_entry[0].flags = 0; target_entry[0].info = WAVE_DRAG_TAR_INFO_0; target_entry[1].target = WAVE_DRAG_TAR_NAME_1; target_entry[1].flags = 0; target_entry[1].info = WAVE_DRAG_TAR_INFO_1; target_entry[2].target = WAVE_DRAG_TAR_NAME_2; target_entry[2].flags = 0; target_entry[2].info = WAVE_DRAG_TAR_INFO_2; gtk_drag_dest_set( GTK_WIDGET(wid), GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry), GDK_ACTION_COPY ); gtk_signal_connect(GTK_OBJECT(wid), "drag_data_received", GTK_SIGNAL_FUNC(DNDDataReceivedCB), GTK_WIDGET(wid)); gtk_signal_connect(GTK_OBJECT(wid), "drag_motion", GTK_SIGNAL_FUNC(DNDDragMotionCB), GTK_WIDGET(wid)); gtk_signal_connect(GTK_OBJECT(wid), "drag_begin", GTK_SIGNAL_FUNC(DNDBeginCB), GTK_WIDGET(wid)); gtk_signal_connect(GTK_OBJECT(wid), "drag_end", GTK_SIGNAL_FUNC(DNDEndCB), GTK_WIDGET(wid)); }
static int gtkSetDropTargetAttrib(Ihandle* ih, const char* value) { if(iupStrBoolean(value)) { GtkTargetList *targetlist = (GtkTargetList*)iupAttribGet(ih, "_IUPGTK_DROP_TARGETLIST"); GtkTargetEntry *drop_types_entry; int targetlist_count; if(!targetlist) return 0; drop_types_entry = gtk_target_table_new_from_list(targetlist, &targetlist_count); gtk_drag_dest_set(ih->handle, GTK_DEST_DEFAULT_ALL, drop_types_entry, targetlist_count, GDK_ACTION_MOVE|GDK_ACTION_COPY); g_signal_connect(ih->handle, "drag_motion", G_CALLBACK(gtkDragMotion), ih); g_signal_connect(ih->handle, "drag_data_received", G_CALLBACK(gtkDragDataReceived), ih); gtk_target_table_free(drop_types_entry, targetlist_count); } else gtk_drag_dest_unset(ih->handle); return 1; }
void table_create (GstTool *tool) { GtkWidget *table = gst_dialog_get_widget (tool->main_dialog, "shares_table"); GtkWidget *popup; GtkTreeSelection *selection; GtkTreeModel *model; model = create_table_model (); gtk_tree_view_set_model (GTK_TREE_VIEW (table), model); g_object_unref (G_OBJECT (model)); add_table_columns (GTK_TREE_VIEW (table)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (table)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (on_shares_table_selection_changed), NULL); popup = popup_menu_create (GTK_TREE_VIEW (table)); g_signal_connect (G_OBJECT (table), "button-press-event", G_CALLBACK (on_shares_table_button_press), (gpointer) popup); g_signal_connect (G_OBJECT (table), "popup_menu", G_CALLBACK (on_shares_table_popup_menu), (gpointer) popup); /* Drag and Drop stuff */ gtk_drag_dest_unset (table); gtk_drag_dest_set (table, GTK_DEST_DEFAULT_ALL, drop_types, sizeof (drop_types) / sizeof (drop_types[0]), GDK_ACTION_COPY); g_signal_connect (G_OBJECT (table), "drag_data_received", G_CALLBACK (on_shares_dragged_folder), NULL); }
static GtkWidget * caja_emblem_sidebar_create_container (CajaEmblemSidebar *emblem_sidebar) { GtkWidget *emblems_table, *scroller; /* The emblems wrapped table */ scroller = eel_scrolled_wrap_table_new (TRUE, GTK_SHADOW_IN, &emblems_table); gtk_container_set_border_width (GTK_CONTAINER (emblems_table), 8); /* set up dnd for adding emblems */ gtk_drag_dest_set (scroller, GTK_DEST_DEFAULT_ALL, dest_types, G_N_ELEMENTS (dest_types), GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect (scroller, "drag-data-received", G_CALLBACK (caja_emblem_sidebar_drag_received_cb), emblem_sidebar); gtk_widget_show (scroller); emblem_sidebar->details->emblems_table = emblems_table; return scroller; }
BrowseWidget_t* browse_widget_new (const gchar *name) { BrowseWidget_t *browse = g_new(BrowseWidget_t, 1); GtkWidget *button; GtkWidget *icon; browse->file_chooser = NULL; browse->name = name; browse->filter = NULL; browse->hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); gtk_widget_show (browse->hbox); browse->file = gtk_entry_new (); gtk_box_pack_start (GTK_BOX(browse->hbox), browse->file, TRUE, TRUE, 0); gtk_drag_dest_set (browse->file, GTK_DEST_DEFAULT_ALL, target_table, 2, GDK_ACTION_COPY); g_signal_connect (browse->file, "drag-data-received", G_CALLBACK(handle_drop), NULL); gtk_widget_show (browse->file); browse->button = button = gtk_button_new (); icon = gtk_image_new_from_icon_name ("gimp-open", GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (button), icon); gtk_widget_show (icon); gtk_box_pack_end(GTK_BOX (browse->hbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK(browse_cb), (gpointer) browse); gtk_widget_show (button); return browse; }
static void gtk_expander_init (GtkExpander *expander) { GtkExpanderPrivate *priv; expander->priv = priv = GTK_EXPANDER_GET_PRIVATE (expander); gtk_widget_set_can_focus (GTK_WIDGET (expander), TRUE); gtk_widget_set_has_window (GTK_WIDGET (expander), FALSE); priv->label_widget = NULL; priv->event_window = NULL; priv->spacing = 0; priv->expander_style = GTK_EXPANDER_COLLAPSED; priv->animation_timeout = 0; priv->expanded = FALSE; priv->use_underline = FALSE; priv->use_markup = FALSE; priv->button_down = FALSE; priv->prelight = FALSE; priv->label_fill = FALSE; priv->expand_timer = 0; gtk_drag_dest_set (GTK_WIDGET (expander), 0, NULL, 0, 0); gtk_drag_dest_set_track_motion (GTK_WIDGET (expander), TRUE); }
void fm__gth_browser_load_location_after_cb (GthBrowser *browser, GthFileData *location_data, const GError *error) { BrowserData *data; GtkWidget *file_view; if ((location_data == NULL) || (error != NULL)) return; data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY); file_manager_update_ui (data, browser); if (! g_file_info_get_attribute_boolean (location_data->info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)) { file_view = gth_file_list_get_view (GTH_FILE_LIST (gth_browser_get_file_list (browser))); gth_file_view_unset_drag_dest (GTH_FILE_VIEW (file_view)); file_view = gth_file_list_get_empty_view (GTH_FILE_LIST (gth_browser_get_file_list (browser))); gtk_drag_dest_unset (file_view); } else if (gth_file_source_is_reorderable (gth_browser_get_location_source (browser))) { file_view = gth_file_list_get_view (GTH_FILE_LIST (gth_browser_get_file_list (browser))); gth_file_view_enable_drag_dest (GTH_FILE_VIEW (file_view), reorderable_drag_dest_targets, G_N_ELEMENTS (reorderable_drag_dest_targets), GDK_ACTION_COPY | GDK_ACTION_MOVE); file_view = gth_file_list_get_empty_view (GTH_FILE_LIST (gth_browser_get_file_list (browser))); gtk_drag_dest_set (file_view, 0, reorderable_drag_dest_targets, G_N_ELEMENTS (reorderable_drag_dest_targets), GDK_ACTION_COPY | GDK_ACTION_MOVE); } else { file_view = gth_file_list_get_view (GTH_FILE_LIST (gth_browser_get_file_list (browser))); gth_file_view_enable_drag_dest (GTH_FILE_VIEW (file_view), non_reorderable_drag_dest_targets, G_N_ELEMENTS (non_reorderable_drag_dest_targets), GDK_ACTION_COPY); file_view = gth_file_list_get_empty_view (GTH_FILE_LIST (gth_browser_get_file_list (browser))); gtk_drag_dest_set (file_view, 0, non_reorderable_drag_dest_targets, G_N_ELEMENTS (non_reorderable_drag_dest_targets), GDK_ACTION_COPY); } }
void nautilus_drag_slot_proxy_init (GtkWidget *widget, NautilusFile *target_file, NautilusWindowSlot *target_slot) { NautilusDragSlotProxyInfo *drag_info; const GtkTargetEntry targets[] = { { NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NAUTILUS_ICON_DND_GNOME_ICON_LIST }, { NAUTILUS_ICON_DND_NETSCAPE_URL_TYPE, 0, NAUTILUS_ICON_DND_NETSCAPE_URL }, { NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE, 0, NAUTILUS_ICON_DND_XDNDDIRECTSAVE }, /* XDS Protocol Type */ { NAUTILUS_ICON_DND_RAW_TYPE, 0, NAUTILUS_ICON_DND_RAW } }; GtkTargetList *target_list; g_assert (GTK_IS_WIDGET (widget)); drag_info = g_slice_new0 (NautilusDragSlotProxyInfo); g_object_set_data_full (G_OBJECT (widget), "drag-slot-proxy-data", drag_info, drag_info_free); drag_info->is_notebook = (g_object_get_data (G_OBJECT (widget), "nautilus-notebook-tab") != NULL); if (target_file != NULL) drag_info->target_file = nautilus_file_ref (target_file); if (target_slot != NULL) drag_info->target_slot = g_object_ref (target_slot); drag_info->widget = widget; gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_ASK); target_list = gtk_target_list_new (targets, G_N_ELEMENTS (targets)); gtk_target_list_add_uri_targets (target_list, NAUTILUS_ICON_DND_URI_LIST); gtk_target_list_add_text_targets (target_list, NAUTILUS_ICON_DND_TEXT); gtk_drag_dest_set_target_list (widget, target_list); gtk_target_list_unref (target_list); g_signal_connect (widget, "drag-motion", G_CALLBACK (slot_proxy_drag_motion), drag_info); g_signal_connect (widget, "drag-drop", G_CALLBACK (slot_proxy_drag_drop), drag_info); g_signal_connect (widget, "drag-data-received", G_CALLBACK (slot_proxy_drag_data_received), drag_info); g_signal_connect (widget, "drag-leave", G_CALLBACK (slot_proxy_drag_leave), drag_info); }
static void gstyle_color_widget_init (GstyleColorWidget *self) { GtkStyleContext *context; GtkWidget *widget = GTK_WIDGET (self); gtk_widget_set_has_window (GTK_WIDGET (self), TRUE); self->label = GTK_LABEL (g_object_new (GTK_TYPE_LABEL, "ellipsize", PANGO_ELLIPSIZE_END, "visible", TRUE, "halign", GTK_ALIGN_CENTER, "valign", GTK_ALIGN_CENTER, NULL)); gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->label)); self->is_name_visible = TRUE; self->is_fallback_name_visible = TRUE; self->fallback_name_kind = GSTYLE_COLOR_KIND_RGB_HEX6; self->checkered_pattern = gstyle_utils_get_checkered_pattern (); gtk_widget_set_valign (widget, GTK_ALIGN_FILL); gtk_widget_set_halign (widget, GTK_ALIGN_FILL); gtk_widget_set_hexpand (widget, TRUE); gtk_widget_set_vexpand (widget, TRUE); context = gtk_widget_get_style_context (GTK_WIDGET (self)); self->default_provider = gstyle_css_provider_init_default (gtk_style_context_get_screen (context)); self->target_list = gtk_target_list_new (dnd_targets, G_N_ELEMENTS (dnd_targets)); gtk_target_list_add_text_targets (self->target_list, 0); gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_MOVE); gtk_drag_dest_set_target_list (widget, self->target_list); gtk_drag_dest_set_track_motion (GTK_WIDGET (self), TRUE); update_container_parent_informations (self); self->multipress_gesture = gtk_gesture_multi_press_new (widget); gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (self->multipress_gesture), 0); gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (self->multipress_gesture), GTK_PHASE_BUBBLE); g_signal_connect (self->multipress_gesture, "pressed", G_CALLBACK (gstyle_color_widget_multipress_gesture_pressed), widget); self->drag_gesture = gtk_gesture_drag_new (GTK_WIDGET (self)); g_signal_connect (self->drag_gesture, "drag-update", G_CALLBACK (gstyle_color_widget_drag_gesture_update), self); g_signal_connect_swapped (self, "key-press-event", G_CALLBACK (gstyle_color_widget_key_pressed_cb), self); gstyle_color_widget_actions_init (self); gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE); }
static void bar_pane_exif_dnd_init(GtkWidget *pane) { gtk_drag_dest_set(pane, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, bar_pane_exif_drop_types, n_exif_entry_drop_types, GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect(G_OBJECT(pane), "drag_data_received", G_CALLBACK(bar_pane_exif_dnd_receive), NULL); }
void dnd_init(void) { // from list to tree gtk_drag_source_set(clist_wnd, GDK_BUTTON1_MASK, target_table_1, n_targets, GDK_ACTION_COPY | GDK_ACTION_MOVE); gtk_drag_dest_set(ctree_wnd, GTK_DEST_DEFAULT_ALL, target_table_1, n_targets+1, GDK_ACTION_COPY | GDK_ACTION_MOVE); // from tree to list gtk_drag_source_set(ctree_wnd, GDK_BUTTON1_MASK, target_table_2, n_targets, GDK_ACTION_COPY | GDK_ACTION_MOVE); gtk_drag_dest_set(clist_wnd, GTK_DEST_DEFAULT_ALL, target_table_2, n_targets, GDK_ACTION_COPY | GDK_ACTION_MOVE); }
void dnd_init(GtkWidget *widget) { gtk_drag_dest_set(widget, GTK_DEST_DEFAULT_ALL, drag_types, n_drag_types, GDK_ACTION_COPY); g_signal_connect(G_OBJECT(widget), "drag_data_received", G_CALLBACK(dnd_drag_data_recieved_handler), NULL); g_signal_connect(G_OBJECT(widget), "drag_motion", G_CALLBACK(dnd_drag_motion_handler), NULL); }
void dnd_setup () { gtk_drag_dest_set(app->window, GTK_DEST_DEFAULT_ALL, dnd_file_drag_types, // const GtkTargetEntry *targets, dnd_file_drag_types_count, // gint n_targets, (GdkDragAction)(GDK_ACTION_MOVE | GDK_ACTION_COPY)); g_signal_connect(G_OBJECT(app->window), "drag-data-received", G_CALLBACK(drag_received), NULL); }
void xkb_layouts_prepare_selected_tree (GtkBuilder * dialog, MateConfChangeSet * changeset) { GtkListStore *list_store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); GtkWidget *tree_view = WID ("xkb_layouts_selected"); GtkTreeSelection *selection; GtkTargetEntry self_drag_target = { "xkb_layouts_selected", GTK_TARGET_SAME_WIDGET, 0 }; GtkTreeViewColumn *desc_column; text_renderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ()); desc_column = gtk_tree_view_column_new_with_attributes (_("Layout"), text_renderer, "text", SEL_LAYOUT_TREE_COL_DESCRIPTION, "sensitive", SEL_LAYOUT_TREE_COL_ENABLED, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store)); gtk_tree_view_column_set_sizing (desc_column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (desc_column, TRUE); gtk_tree_view_column_set_expand (desc_column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), desc_column); g_signal_connect_swapped (G_OBJECT (selection), "changed", G_CALLBACK (xkb_layouts_enable_disable_buttons), dialog); max_selected_layouts = xkl_engine_get_max_num_groups (engine); /* Setting up DnD */ gtk_drag_source_set (tree_view, GDK_BUTTON1_MASK, &self_drag_target, 1, GDK_ACTION_MOVE); gtk_drag_source_set_icon_name (tree_view, "input-keyboard"); gtk_drag_dest_set (tree_view, GTK_DEST_DEFAULT_ALL, &self_drag_target, 1, GDK_ACTION_MOVE); g_signal_connect (G_OBJECT (tree_view), "drag_data_get", G_CALLBACK (xkb_layouts_dnd_data_get), dialog); g_signal_connect (G_OBJECT (tree_view), "drag_data_received", G_CALLBACK (xkb_layouts_dnd_data_received), dialog); }
static void ddb_tabstrip_realize (GtkWidget *widget) { DdbTabStrip *darea = DDB_TABSTRIP (widget); GdkWindowAttr attributes; gint attributes_mask; if (!gtk_widget_get_has_window (widget)) { GTK_WIDGET_CLASS (ddb_tabstrip_parent_class)->realize (widget); } else { gtk_widget_set_realized (widget, TRUE); attributes.window_type = GDK_WINDOW_CHILD; GtkAllocation a; gtk_widget_get_allocation (widget, &a); attributes.x = a.x; attributes.y = a.y; attributes.width = a.width; attributes.height = a.height; attributes.wclass = GDK_INPUT_OUTPUT; attributes.visual = gtk_widget_get_visual (widget); #if !GTK_CHECK_VERSION(3,0,0) attributes.colormap = gtk_widget_get_colormap (widget); #endif attributes.event_mask = gtk_widget_get_events (widget); attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK; attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; #if !GTK_CHECK_VERSION(3,0,0) attributes_mask |= GDK_WA_COLORMAP; #endif GdkWindow *window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask); gtk_widget_set_window(widget, window); gdk_window_set_user_data (gtk_widget_get_window(widget), darea); #if !GTK_CHECK_VERSION(3,0,0) widget->style = gtk_style_attach (widget->style, widget->window); gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL); #else gtk_style_context_set_background (gtk_widget_get_style_context (widget), window); #endif } ddb_tabstrip_send_configure (DDB_TABSTRIP (widget)); GtkTargetEntry entry = { .target = TARGET_PLAYITEMS, .flags = GTK_TARGET_SAME_APP, .info = TARGET_SAMEWIDGET }; gtk_drag_dest_set (widget, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP, &entry, 1, GDK_ACTION_COPY | GDK_ACTION_MOVE); gtk_drag_dest_add_uri_targets (widget); gtk_drag_dest_set_track_motion (widget, TRUE); }
GtkWidget *drop_box_new(const char *message) { GtkWidget *button, *label, *vbox, *icon; MaskedPixmap *mp; DropBox *drop_box; GtkTargetEntry targets[] = { {"text/uri-list", 0, 0}, }; drop_box = g_object_new(drop_box_get_type(), NULL); gtk_frame_set_shadow_type(GTK_FRAME(drop_box), GTK_SHADOW_IN); gtk_container_set_border_width(GTK_CONTAINER(drop_box), 4); gtk_drag_dest_set(GTK_WIDGET(drop_box), GTK_DEST_DEFAULT_ALL, targets, sizeof(targets) / sizeof(*targets), GDK_ACTION_COPY); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(drop_box), vbox); label = gtk_label_new(message); gtk_misc_set_padding(GTK_MISC(label), 10, 10); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); drop_box->label = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(vbox), drop_box->label, FALSE, TRUE, 0); gtk_misc_set_padding(GTK_MISC(drop_box->label), 2, 2); drop_box->buttons = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(vbox), drop_box->buttons, FALSE, TRUE, 0); button = gtk_button_new_from_stock(GTK_STOCK_CLEAR); gtk_box_pack_start(GTK_BOX(drop_box->buttons), button, FALSE, TRUE, 0); g_signal_connect(button, "clicked", G_CALLBACK(clear_clicked), drop_box); mp = type_to_icon(inode_directory); pixmap_make_small(mp); icon = gtk_image_new_from_pixbuf(mp->sm_pixbuf); g_object_unref(mp); button = button_new_image_text(icon, _("Show")); gtk_box_pack_start(GTK_BOX(drop_box->buttons), button, FALSE, TRUE, 0); g_signal_connect(button, "clicked", G_CALLBACK(open_dir_clicked), drop_box); gtk_tooltips_set_tip(tooltips, button, _("Show the current choice in a filer window"), NULL); drop_box_set_path(drop_box, NULL); gtk_widget_show_all(vbox); return GTK_WIDGET(drop_box); }
static void exo_toolbars_editor_init (ExoToolbarsEditor *editor) { GtkWidget *scrolled_window; GtkWidget *hbox; GtkWidget *image; GtkWidget *label; editor->priv = EXO_TOOLBARS_EDITOR_GET_PRIVATE (editor); g_object_set (G_OBJECT (editor), "border-width", 12, "sensitive", FALSE, "spacing", 6, NULL); scrolled_window = g_object_new (GTK_TYPE_SCROLLED_WINDOW, "hscrollbar-policy", GTK_POLICY_NEVER, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL); gtk_box_pack_start (GTK_BOX (editor), scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); editor->priv->table = g_object_new (GTK_TYPE_TABLE, "border-width", 12, "column-spacing", 6, "homogeneous", TRUE, "row-spacing", 6, NULL); gtk_drag_dest_set (editor->priv->table, GTK_DEST_DEFAULT_ALL, targets, G_N_ELEMENTS (targets), GDK_ACTION_MOVE); g_signal_connect_swapped (G_OBJECT (editor->priv->table), "drag-data-received", G_CALLBACK (exo_toolbars_editor_update), editor); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), editor->priv->table); gtk_widget_show (editor->priv->table); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (editor), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); gtk_widget_show (image); label = g_object_new (GTK_TYPE_LABEL, "label", _("Drag an item onto the toolbars above to add it, " "from the toolbars in the items table to remove it."), "wrap", TRUE, "xalign", 0.0, "yalign", 0.5, NULL); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); }
JIDList::JIDList(WokXMLTag *tag) : GtkPCommon(tag) { std::string name; if( tag->GetAttr("label").size() ) name = tag->GetAttr("label"); else name = tag->GetName(); gxml = glade_xml_new (PACKAGE_GLADE_DIR"/wokjab/preference.jidlist.glade", "mainbox", NULL); gtk_label_set_text(GTK_LABEL(glade_xml_get_widget(gxml, "label")), name.c_str()); GtkListStore *store; store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(glade_xml_get_widget(gxml, "list")), GTK_TREE_MODEL(store)); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW(glade_xml_get_widget(gxml, "list"))), GTK_SELECTION_MULTIPLE); GtkCellRenderer *renderer; GtkTreeViewColumn *column; /* renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes("nick", renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id(column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW(glade_xml_get_widget(gxml, "list")), column); */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes("jid", renderer, "text", 1, NULL); gtk_tree_view_column_set_sort_column_id(column, 1); gtk_tree_view_append_column (GTK_TREE_VIEW(glade_xml_get_widget(gxml, "list")), column); GtkTreeIter iter; std::list <WokXMLTag *>::iterator citer; for( citer = conf->GetFirstTag("list").GetTagList("item").begin(); citer != conf->GetFirstTag("list").GetTagList("item").end(); citer++) { gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 1, (*citer)->GetAttr("data").c_str(), -1); } enum { TARGET_STRING }; static GtkTargetEntry target_entry[] = { { "STRING", 0, TARGET_STRING }, }; gtk_drag_dest_set(glade_xml_get_widget (gxml, "list"), GTK_DEST_DEFAULT_DROP, target_entry, 1, (GdkDragAction) (GDK_ACTION_COPY)); g_signal_connect(glade_xml_get_widget (gxml, "list"), "drag_data_received", G_CALLBACK(JIDList::DataReceived), this); g_signal_connect(glade_xml_get_widget (gxml, "delete"), "clicked", G_CALLBACK(JIDList::Remove), this); }
void nemo_drag_slot_proxy_init (GtkWidget *widget, NemoFile *target_file, NemoWindowSlot *target_slot) { NemoDragSlotProxyInfo *drag_info; const GtkTargetEntry targets[] = { { NEMO_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NEMO_ICON_DND_GNOME_ICON_LIST }, { NEMO_ICON_DND_NETSCAPE_URL_TYPE, 0, NEMO_ICON_DND_NETSCAPE_URL } }; GtkTargetList *target_list; g_assert (GTK_IS_WIDGET (widget)); drag_info = g_slice_new0 (NemoDragSlotProxyInfo); g_object_set_data_full (G_OBJECT (widget), "drag-slot-proxy-data", drag_info, drag_info_free); drag_info->desktop_dnd_source_fs = NULL; drag_info->desktop_dnd_can_delete_source = FALSE; if (target_file != NULL) drag_info->target_file = g_object_ref (target_file); if (target_slot != NULL) drag_info->target_slot = g_object_ref (target_slot); gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_ASK); target_list = gtk_target_list_new (targets, G_N_ELEMENTS (targets)); gtk_target_list_add_uri_targets (target_list, NEMO_ICON_DND_URI_LIST); gtk_drag_dest_set_target_list (widget, target_list); gtk_target_list_unref (target_list); g_signal_connect (widget, "drag-motion", G_CALLBACK (slot_proxy_drag_motion), drag_info); g_signal_connect (widget, "drag-drop", G_CALLBACK (slot_proxy_drag_drop), drag_info); g_signal_connect (widget, "drag-data-received", G_CALLBACK (slot_proxy_drag_data_received), drag_info); g_signal_connect (widget, "drag-leave", G_CALLBACK (slot_proxy_drag_leave), drag_info); }