void
setup_uri_drag (GtkWidget *menuitem,
const char *uri,
const char *icon,
GdkDragAction action)
{
static GtkTargetEntry menu_item_targets[] = {
{ "text/uri-list", 0, 0 }
};
if (panel_lockdown_get_locked_down ())
return;
gtk_drag_source_set (menuitem,
GDK_BUTTON1_MASK|GDK_BUTTON2_MASK,
menu_item_targets, 1,
action);
if (icon != NULL)
gtk_drag_source_set_icon_name (menuitem, icon);
g_signal_connect (G_OBJECT (menuitem), "drag_begin",
G_CALLBACK (drag_begin_menu_cb), NULL);
g_signal_connect_data (G_OBJECT (menuitem), "drag_data_get",
G_CALLBACK (drag_data_get_string_cb),
g_strdup (uri),
(GClosureNotify)g_free,
0 /* connect_flags */);
g_signal_connect (G_OBJECT (menuitem), "drag_end",
G_CALLBACK (drag_end_menu_cb), NULL);
}
void
panel_launcher_set_dnd_enabled (Launcher *launcher,
gboolean dnd_enabled)
{
GdkPixbuf *pixbuf;
if (dnd_enabled) {
static GtkTargetEntry dnd_targets[] = {
{ (gchar *) "application/x-panel-icon-internal", 0, TARGET_ICON_INTERNAL },
{ (gchar *) "text/uri-list", 0, TARGET_URI_LIST }
};
gtk_widget_set_has_window (launcher->button, TRUE);
gtk_drag_source_set (launcher->button,
GDK_BUTTON1_MASK,
dnd_targets, 2,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
//FIXME: this doesn't work since the pixbuf isn't loaded yet
pixbuf = button_widget_get_pixbuf (BUTTON_WIDGET (launcher->button));
if (pixbuf) {
gtk_drag_source_set_icon_pixbuf (launcher->button,
pixbuf);
g_object_unref (pixbuf);
}
gtk_widget_set_has_window (launcher->button, FALSE);
} else
gtk_drag_source_unset (launcher->button);
}
void
panel_menu_button_set_dnd_enabled (PanelMenuButton *button,
gboolean dnd_enabled)
{
g_return_if_fail (PANEL_IS_MENU_BUTTON (button));
dnd_enabled = dnd_enabled != FALSE;
if (button->priv->dnd_enabled == dnd_enabled)
return;
if (dnd_enabled) {
static GtkTargetEntry dnd_targets [] = {
{ "application/x-mate-panel-applet-internal", 0, 0 }
};
char *icon;
gtk_widget_set_has_window (GTK_WIDGET (button), TRUE);
gtk_drag_source_set (GTK_WIDGET (button), GDK_BUTTON1_MASK,
dnd_targets, 1,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
icon = panel_menu_button_get_icon (button);
if (icon != NULL) {
gtk_drag_source_set_icon_name (GTK_WIDGET (button),
icon);
g_free (icon);
}
gtk_widget_set_has_window (GTK_WIDGET (button), FALSE);
} else
gtk_drag_source_unset (GTK_WIDGET (button));
}
void
setup_internal_applet_drag (GtkWidget *menuitem,
PanelActionButtonType type)
{
static GtkTargetEntry menu_item_targets[] = {
{ "application/x-mate-panel-applet-internal", 0, 0 }
};
if (panel_lockdown_get_locked_down ())
return;
gtk_drag_source_set (menuitem,
GDK_BUTTON1_MASK|GDK_BUTTON2_MASK,
menu_item_targets, 1,
GDK_ACTION_COPY);
if (panel_action_get_icon_name (type) != NULL)
gtk_drag_source_set_icon_name (menuitem,
panel_action_get_icon_name (type));
g_signal_connect (G_OBJECT (menuitem), "drag_begin",
G_CALLBACK (drag_begin_menu_cb), NULL);
g_signal_connect_data (G_OBJECT (menuitem), "drag_data_get",
G_CALLBACK (drag_data_get_string_cb),
g_strdup (panel_action_get_drag_id (type)),
(GClosureNotify)g_free,
0 /* connect_flags */);
g_signal_connect (G_OBJECT (menuitem), "drag_end",
G_CALLBACK (drag_end_menu_cb), NULL);
}
void
gnac_profiles_mgr_init(void)
{
profiles_mgr_builder = gnac_ui_utils_create_gtk_builder(
PKGDATADIR "/profiles/gnac-profiles-manager.xml");
GtkTreeView *view = GTK_TREE_VIEW(
gnac_profiles_mgr_get_widget("profile_treeview"));
GtkTreeSelection *selection = gtk_tree_view_get_selection(view);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(gnac_profiles_mgr_on_treeselection_changed), NULL);
gtk_drag_dest_set(GTK_WIDGET(view), GTK_DEST_DEFAULT_ALL, target_list,
n_targets, GDK_ACTION_COPY);
gtk_drag_source_set(GTK_WIDGET(view), GDK_BUTTON1_MASK, target_list,
n_targets, GDK_ACTION_COPY);
gnac_profiles_properties_init();
gnac_profiles_mgr_set_parent();
gnac_profiles_mgr_show_import_progressbar(FALSE);
gnac_profiles_mgr_display_status_message(NULL, NULL);
gnac_profiles_mgr_populate();
}
void
panel_action_button_set_dnd_enabled (PanelActionButton *button,
gboolean enabled)
{
g_return_if_fail (PANEL_IS_ACTION_BUTTON (button));
if (!button->priv->type)
return; /* wait until we know what type it is */
enabled = enabled != FALSE;
if (button->priv->dnd_enabled == enabled)
return;
if (enabled) {
static GtkTargetEntry dnd_targets [] = {
{ "application/x-mate-panel-applet-internal", 0, 0 }
};
gtk_widget_set_has_window (GTK_WIDGET (button), TRUE);
gtk_drag_source_set (GTK_WIDGET (button), GDK_BUTTON1_MASK,
dnd_targets, 1,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
if (actions [button->priv->type].icon_name != NULL)
gtk_drag_source_set_icon_name (GTK_WIDGET (button),
actions [button->priv->type].icon_name);
gtk_widget_set_has_window (GTK_WIDGET (button), FALSE);
} else
gtk_drag_source_unset (GTK_WIDGET (button));
button->priv->dnd_enabled = enabled;
g_object_notify (G_OBJECT (button), "dnd-enabled");
}
/*
* 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);
}
/**
* physically add widgets to store window
*/
bool nsgtk_toolbar_add_store_widget(GtkWidget *widget)
{
if (window->numberh >= NSGTK_STORE_WIDTH) {
window->currentbar = gtk_toolbar_new();
if (window->currentbar == NULL) {
warn_user("NoMemory", 0);
return false;
}
gtk_toolbar_set_style(GTK_TOOLBAR(window->currentbar),
GTK_TOOLBAR_BOTH);
gtk_toolbar_set_icon_size(GTK_TOOLBAR(window->currentbar),
GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_box_pack_start(GTK_BOX(window->widgetvbox),
window->currentbar, FALSE, FALSE, 0);
window->numberh = 0;
}
gtk_widget_set_size_request(widget, NSGTK_BUTTON_WIDTH,
NSGTK_BUTTON_HEIGHT);
gtk_toolbar_insert(GTK_TOOLBAR(window->currentbar), GTK_TOOL_ITEM(
widget), window->numberh++);
gtk_tool_item_set_use_drag_window(GTK_TOOL_ITEM(widget), TRUE);
gtk_drag_source_set(widget, GDK_BUTTON1_MASK, &entry, 1,
GDK_ACTION_COPY);
gtk_widget_show_all(window->window);
return true;
}
static int gtkSetDragSourceAttrib(Ihandle* ih, const char* value)
{
if (iupStrBoolean(value))
{
GtkTargetList *targetlist = (GtkTargetList*)iupAttribGet(ih, "_IUPGTK_DRAG_TARGETLIST");
GtkTargetEntry *drag_types_entry;
int targetlist_count;
if(!targetlist)
return 0;
drag_types_entry = gtk_target_table_new_from_list(targetlist, &targetlist_count);
gtk_drag_source_set(ih->handle, GDK_BUTTON1_MASK, drag_types_entry, targetlist_count,
iupAttribGetBoolean(ih, "DRAGSOURCEMOVE")? GDK_ACTION_MOVE|GDK_ACTION_COPY: GDK_ACTION_COPY);
g_signal_connect(ih->handle, "drag_begin", G_CALLBACK(gtkDragBegin), ih);
g_signal_connect(ih->handle, "drag_data_get", G_CALLBACK(gtkDragDataGet), ih);
g_signal_connect(ih->handle, "drag_end", G_CALLBACK(gtkDragEnd), ih);
gtk_target_table_free(drag_types_entry, targetlist_count);
}
else
gtk_drag_source_unset(ih->handle);
return 1;
}
static GtkWidget *
matewnck_selector_item_new (MatewnckSelector *selector,
const gchar *label, MatewnckWindow *window)
{
GtkWidget *item;
GtkWidget *ellipsizing_label;
window_hash_item *hash_item;
static const GtkTargetEntry targets[] = {
{ "application/x-matewnck-window-id", 0, 0 }
};
item = gtk_image_menu_item_new ();
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), TRUE);
ellipsizing_label = gtk_label_new (label);
gtk_misc_set_alignment (GTK_MISC (ellipsizing_label), 0.0, 0.5);
gtk_label_set_ellipsize (GTK_LABEL (ellipsizing_label),
PANGO_ELLIPSIZE_END);
if (window != NULL)
{
/* if window demands attention, bold the label */
if (matewnck_window_or_transient_needs_attention (window))
_make_gtk_label_bold (GTK_LABEL (ellipsizing_label));
hash_item = g_new0 (window_hash_item, 1);
hash_item->item = item;
hash_item->label = ellipsizing_label;
g_hash_table_insert (selector->priv->window_hash, window, hash_item);
}
gtk_container_add (GTK_CONTAINER (item), ellipsizing_label);
gtk_widget_show (ellipsizing_label);
gtk_widget_set_size_request (ellipsizing_label,
matewnck_selector_get_width (GTK_WIDGET (selector),
label), -1);
if (window != NULL)
{
gtk_drag_source_set (item,
GDK_BUTTON1_MASK,
targets, 1,
GDK_ACTION_MOVE);
g_signal_connect_object (item, "drag_data_get",
G_CALLBACK (matewnck_selector_drag_data_get),
G_OBJECT (window),
0);
g_signal_connect_object (item, "drag_begin",
G_CALLBACK (matewnck_selector_drag_begin),
G_OBJECT (window),
0);
}
return item;
}
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
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);
}
int
clip_GTK_DRAGSOURCESET(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
GdkModifierType start_button_mask = _clip_parni(cm, 2);
ClipArrVar *ctag = (ClipArrVar*)_clip_vptr(_clip_spar(cm, 3));
gint ntargets = _clip_parni(cm, 4);
GdkDragAction actions = _clip_parni(cm, 5);
CHECKCWID(cwid, GTK_IS_WIDGET);
CHECKARG(2, NUMERIC_t);
CHECKARG(3, ARRAY_t);
CHECKARG(4, NUMERIC_t);
CHECKARG(5, NUMERIC_t);
if (ctag)
{
GtkTargetEntry *tags;
gint i;
tags = malloc(ctag->count*sizeof(GtkTargetEntry));
memset(tags, 0, sizeof(GtkTargetEntry)*ctag->count);
for (i=0; i<ctag->count; i++)
_array_to_target_entry(cm, &ctag->items[i], &tags[i]);
gtk_drag_source_set(GTK_WIDGET(cwid->widget),
start_button_mask,
tags,
ntargets,
actions);
free(tags);
}
else
gtk_drag_source_set(GTK_WIDGET(cwid->widget),
start_button_mask,
NULL,
ntargets,
actions);
return 0;
err:
return 1;
}
static void
nemo_location_bar_init (NemoLocationBar *bar)
{
GtkWidget *entry;
GtkWidget *event_box;
bar->details = G_TYPE_INSTANCE_GET_PRIVATE (bar, NEMO_TYPE_LOCATION_BAR,
NemoLocationBarDetails);
gtk_orientable_set_orientation (GTK_ORIENTABLE (bar),
GTK_ORIENTATION_HORIZONTAL);
event_box = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (event_box), 2);
entry = nemo_location_entry_new ();
g_signal_connect_object (entry, "activate",
G_CALLBACK (editable_activate_callback), bar, G_CONNECT_AFTER);
g_signal_connect_object (entry, "changed",
G_CALLBACK (editable_changed_callback), bar, 0);
gtk_container_add (GTK_CONTAINER (event_box), entry);
gtk_box_pack_start (GTK_BOX (bar), event_box, TRUE, TRUE, 4);
/* Label context menu */
g_signal_connect (event_box, "button-press-event",
G_CALLBACK (button_pressed_callback), NULL);
/* Drag source */
gtk_drag_source_set (GTK_WIDGET (event_box),
GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
drag_types, G_N_ELEMENTS (drag_types),
GDK_ACTION_COPY | GDK_ACTION_LINK);
g_signal_connect_object (event_box, "drag_data_get",
G_CALLBACK (drag_data_get_callback), bar, 0);
/* Drag dest. */
gtk_drag_dest_set (GTK_WIDGET (bar),
GTK_DEST_DEFAULT_ALL,
drop_types, G_N_ELEMENTS (drop_types),
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
g_signal_connect (bar, "drag_data_received",
G_CALLBACK (drag_data_received_callback), NULL);
bar->details->entry = NEMO_ENTRY (entry);
gtk_widget_show_all (GTK_WIDGET (bar));
}
static void
tile_setup (Tile * tile)
{
gtk_button_set_relief (GTK_BUTTON (tile), GTK_RELIEF_NONE);
if (tile->uri)
{
gtk_drag_source_set (GTK_WIDGET (tile), GDK_BUTTON1_MASK, NULL, 0,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_source_add_uri_targets (GTK_WIDGET (tile));
}
}
static VALUE
rg_m_source_set(VALUE self, VALUE rbwidget, VALUE rbstart_button_mask, VALUE rbtargets, VALUE rbactions)
{
GtkWidget *widget = RVAL2WIDGET(rbwidget);
GdkModifierType start_button_mask = RVAL2GFLAGS(rbstart_button_mask, GDK_TYPE_MODIFIER_TYPE);
GdkDragAction actions = RVAL2GFLAGS(rbactions, GDK_TYPE_DRAG_ACTION);
long n;
GtkTargetEntry *targets = RVAL2GTKTARGETENTRIES(rbtargets, &n);
gtk_drag_source_set(widget, start_button_mask, targets, n, actions);
g_free(targets);
return self;
}
static void bar_pane_exif_entry_dnd_init(GtkWidget *entry)
{
ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
gtk_drag_source_set(entry, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
bar_pane_exif_drag_types, n_exif_entry_drag_types,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
g_signal_connect(G_OBJECT(entry), "drag_data_get",
G_CALLBACK(bar_pane_exif_entry_dnd_get), ee);
g_signal_connect(G_OBJECT(entry), "drag_begin",
G_CALLBACK(bar_pane_exif_entry_dnd_begin), ee);
g_signal_connect(G_OBJECT(entry), "drag_end",
G_CALLBACK(bar_pane_exif_entry_dnd_end), ee);
}
static GtkWidget*
exo_toolbars_editor_create_item (ExoToolbarsEditor *editor,
GtkWidget *image,
const gchar *text,
GdkDragAction action)
{
GtkWidget *ebox;
GtkWidget *vbox;
GtkWidget *label;
gchar *text_no_mnemonic;
ebox = gtk_event_box_new ();
gtk_drag_source_set (ebox, GDK_BUTTON1_MASK,
targets, G_N_ELEMENTS (targets),
action);
g_signal_connect (G_OBJECT (ebox), "drag-data-get",
G_CALLBACK (exo_toolbars_editor_drag_data_get), editor);
g_signal_connect_after (G_OBJECT (ebox), "realize",
G_CALLBACK (event_box_realize), image);
g_signal_connect_swapped (G_OBJECT (ebox), "drag-data-delete",
G_CALLBACK (exo_toolbars_editor_update), editor);
gtk_widget_show (ebox);
if (action == GDK_ACTION_MOVE)
{
g_signal_connect (G_OBJECT (ebox), "drag-begin",
G_CALLBACK (gtk_widget_hide), NULL);
g_signal_connect (G_OBJECT (ebox), "drag-end",
G_CALLBACK (gtk_widget_show), NULL);
}
vbox = gtk_vbox_new (0, FALSE);
gtk_container_add (GTK_CONTAINER (ebox), vbox);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, TRUE, 0);
gtk_widget_show (image);
text_no_mnemonic = exo_str_elide_underscores (text);
label = gtk_label_new (text_no_mnemonic);
gtk_widget_set_tooltip_text (ebox, text_no_mnemonic);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
g_free (text_no_mnemonic);
gtk_widget_show (label);
return ebox;
}
static void
gtk_color_button_init (GtkColorButton *button)
{
PangoLayout *layout;
PangoRectangle rect;
/* Create the widgets */
button->priv = gtk_color_button_get_instance_private (button);
button->priv->draw_area = gtk_drawing_area_new ();
layout = gtk_widget_create_pango_layout (GTK_WIDGET (button), "Black");
pango_layout_get_pixel_extents (layout, NULL, &rect);
g_object_unref (layout);
gtk_widget_set_size_request (button->priv->draw_area,
rect.width, rect.height);
g_signal_connect (button->priv->draw_area, "draw",
G_CALLBACK (gtk_color_button_draw_cb), button);
gtk_container_add (GTK_CONTAINER (button), button->priv->draw_area);
gtk_widget_show (button->priv->draw_area);
button->priv->title = g_strdup (_("Pick a Color")); /* default title */
/* Start with opaque black, alpha disabled */
button->priv->rgba.red = 0;
button->priv->rgba.green = 0;
button->priv->rgba.blue = 0;
button->priv->rgba.alpha = 1;
button->priv->use_alpha = FALSE;
gtk_drag_dest_set (GTK_WIDGET (button),
GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_DROP,
drop_types, 1, GDK_ACTION_COPY);
gtk_drag_source_set (GTK_WIDGET (button),
GDK_BUTTON1_MASK|GDK_BUTTON3_MASK,
drop_types, 1,
GDK_ACTION_COPY);
g_signal_connect (button, "drag-begin",
G_CALLBACK (gtk_color_button_drag_begin), button);
g_signal_connect (button, "drag-data-received",
G_CALLBACK (gtk_color_button_drag_data_received), button);
g_signal_connect (button, "drag-data-get",
G_CALLBACK (gtk_color_button_drag_data_get), button);
}
static GtkWidget *
editor_create_item (EggToolbarEditor *editor,
GtkImage *icon,
const char *label_text,
GdkDragAction action)
{
GtkWidget *event_box;
GtkWidget *vbox;
GtkWidget *label;
gchar *label_no_mnemonic = NULL;
event_box = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
gtk_widget_show (event_box);
gtk_drag_source_set (event_box,
GDK_BUTTON1_MASK,
source_drag_types, n_source_drag_types, action);
g_signal_connect (event_box, "drag_data_get",
G_CALLBACK (drag_data_get_cb), editor);
g_signal_connect (event_box, "drag_data_delete",
G_CALLBACK (editor_drag_data_delete_cb), editor);
g_signal_connect_after (event_box, "realize",
G_CALLBACK (event_box_realize_cb), icon);
if (action == GDK_ACTION_MOVE)
{
g_signal_connect (event_box, "drag_begin",
G_CALLBACK (drag_begin_cb), NULL);
g_signal_connect (event_box, "drag_end",
G_CALLBACK (drag_end_cb), NULL);
}
vbox = gtk_vbox_new (0, FALSE);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (event_box), vbox);
gtk_widget_show (GTK_WIDGET (icon));
gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (icon), FALSE, TRUE, 0);
label_no_mnemonic = elide_underscores (label_text);
label = gtk_label_new (label_no_mnemonic);
g_free (label_no_mnemonic);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
return event_box;
}
static void
set_features (EmpathyPersonaView *self,
EmpathyPersonaViewFeatureFlags features)
{
EmpathyPersonaViewPriv *priv = GET_PRIV (self);
priv->features = features;
/* Setting reorderable is a hack that gets us row previews as drag icons
for free. We override all the drag handlers. It's tricky to get the
position of the drag icon right in drag_begin. GtkTreeView has special
voodoo for it, so we let it do the voodoo that he do (but only if dragging
is enabled). */
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self),
(features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DRAG));
/* Update DnD source/dest */
if (features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DRAG)
{
gtk_drag_source_set (GTK_WIDGET (self),
GDK_BUTTON1_MASK,
drag_types_source,
G_N_ELEMENTS (drag_types_source),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
}
else
{
gtk_drag_source_unset (GTK_WIDGET (self));
}
if (features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DROP)
{
gtk_drag_dest_set (GTK_WIDGET (self),
GTK_DEST_DEFAULT_ALL,
drag_types_dest,
G_N_ELEMENTS (drag_types_dest), GDK_ACTION_MOVE | GDK_ACTION_COPY);
}
else
{
gtk_drag_dest_unset (GTK_WIDGET (self));
}
g_object_notify (G_OBJECT (self), "features");
}
static void view_window_dnd_init(ViewWindow *vw)
{
ImageWindow *imd;
imd = vw->imd;
gtk_drag_source_set(imd->pr, GDK_BUTTON2_MASK,
dnd_file_drag_types, dnd_file_drag_types_count,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
g_signal_connect(G_OBJECT(imd->pr), "drag_data_get",
G_CALLBACK(view_window_set_dnd_data), vw);
gtk_drag_dest_set(imd->pr,
GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
dnd_file_drop_types, dnd_file_drop_types_count,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
g_signal_connect(G_OBJECT(imd->pr), "drag_data_received",
G_CALLBACK(view_window_get_dnd_data), vw);
}
/*
* Set up a widget as a drag source
*/
void
dnd_setup_source(GtkWindow *window, GtkWidget *w, WaveVar *dv)
{
gtk_drag_source_set (w, GDK_BUTTON1_MASK,
target_table, n_targets,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_source_set_icon (w,
gtk_widget_get_colormap(GTK_WIDGET(window)),
drag_icon_pixmap, drag_mask_pixmap);
gtk_signal_connect (GTK_OBJECT(w), "drag_data_get",
GTK_SIGNAL_FUNC(dnd_source_data_get),
(gpointer) dv);
gtk_signal_connect (GTK_OBJECT(w), "drag_data_delete",
GTK_SIGNAL_FUNC (dnd_source_data_delete), NULL);
}
static void rc_gui_list2_tree_view_set_drag()
{
static GtkTargetEntry entry[4];
entry[0].target = "RhythmCat/MusicItem";
entry[0].flags = GTK_TARGET_SAME_APP;
entry[0].info = 1;
entry[1].target = "STRING";
entry[1].flags = 0;
entry[1].info = 6;
entry[2].target = "text/plain";
entry[2].flags = 0;
entry[2].info = 6;
entry[3].target = "text/uri-list";
entry[3].flags = 0;
entry[3].info = 7;
gtk_drag_source_set(rc_ui->list2_tree_view, GDK_BUTTON1_MASK, entry,
1, GDK_ACTION_MOVE);
gtk_drag_dest_set(rc_ui->list2_tree_view, GTK_DEST_DEFAULT_ALL, entry,
4, GDK_ACTION_COPY|GDK_ACTION_MOVE|GDK_ACTION_LINK);
}
CAMLprim value ml_gtk_drag_source_set (value w, value m, value t, value a)
{
GtkTargetEntry *targets = (GtkTargetEntry *)Val_unit;
int n_targets, i;
CAMLparam4 (w,m,t,a);
n_targets = Wosize_val(t);
if (n_targets)
targets = (GtkTargetEntry *)
alloc (Wosize_asize(n_targets * sizeof(GtkTargetEntry)),
Abstract_tag);
for (i=0; i<n_targets; i++) {
targets[i].target = String_val(Field(Field(t, i), 0));
targets[i].flags = Flags_Target_flags_val(Field(Field(t, i), 1));
targets[i].info = Int_val(Field(Field(t, i), 2));
}
gtk_drag_source_set (GtkWidget_val(w), OptFlags_GdkModifier_val(m),
targets, n_targets, Flags_GdkDragAction_val(a));
CAMLreturn(Val_unit);
}
/**
* when 'reload defaults' button is clicked
*/
gboolean nsgtk_toolbar_reset(GtkWidget *widget, gpointer data)
{
nsgtk_scaffolding *g = (nsgtk_scaffolding *)data;
int i;
for (i = BACK_BUTTON; i < PLACEHOLDER_BUTTON; i++)
nsgtk_scaffolding_button(g, i)->location =
(i <= THROBBER_ITEM) ? i : -1;
nsgtk_toolbar_set_physical(g);
for (i = BACK_BUTTON; i <= THROBBER_ITEM; i++) {
if (i == URL_BAR_ITEM)
continue;
gtk_tool_item_set_use_drag_window(GTK_TOOL_ITEM(
nsgtk_scaffolding_button(g, i)->button), TRUE);
gtk_drag_source_set(GTK_WIDGET(
nsgtk_scaffolding_button(g, i)->button),
GDK_BUTTON1_MASK, &entry, 1, GDK_ACTION_COPY);
nsgtk_toolbar_temp_connect(g, i);
}
return TRUE;
}
static void
setup_dnd (TTXWindow *self, GtkWidget *ebox)
{
GtkTargetEntry entries[] = {
{ "text/uri-list", 0, 1 },
{ "application/x-rootwindow-drop", 0, 2 }
};
/* note: without this, D&D does not work; see the Gtk docs */
gtk_event_box_set_visible_window (GTK_EVENT_BOX(ebox),
FALSE);
/* setup drag & drop */
gtk_drag_source_set (ebox, GDK_BUTTON1_MASK,
entries, G_N_ELEMENTS(entries),
GDK_ACTION_COPY);
g_signal_connect (G_OBJECT(ebox), "drag-data-get",
G_CALLBACK(on_drag_data_get), self);
}
static void info_window_dnd_init(InfoData *id)
{
ImageWindow *imd;
imd = id->image;
gtk_drag_source_set(imd->image, GDK_BUTTON2_MASK,
dnd_file_drag_types, dnd_file_drag_types_count,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
g_signal_connect(G_OBJECT(imd->image), "drag_data_get",
G_CALLBACK(info_window_dnd_data_set), id);
#if 0
gtk_drag_dest_set(imd->image,
GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
dnd_file_drop_types, dnd_file_drop_types_count,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
g_signal_connect(G_OBJECT(imd->image), "drag_data_received",
G_CALLBACK(info_window_dnd_data_get), id);
#endif
}
void
timeSeriesPlotDragAndDropEnable(splotd *sp, gboolean active) {
static GtkTargetEntry target = {"text/plain", GTK_TARGET_SAME_APP, 1001};
if (active) {
gtk_drag_source_set(GTK_WIDGET(sp), GDK_BUTTON1_MASK, &target, 1,
GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(sp), "drag_data_get",
G_CALLBACK(start_timeSeries_drag), NULL);
gtk_drag_dest_set(GTK_WIDGET(sp), GTK_DEST_DEFAULT_ALL /* DROP */,
&target, 1, GDK_ACTION_COPY /*MOVE*/);
g_signal_connect(G_OBJECT(sp), "drag_data_received",
G_CALLBACK(receive_timeSeries_drag), NULL);
} else {
g_signal_handlers_disconnect_by_func(G_OBJECT(sp),
G_CALLBACK(start_timeSeries_drag), NULL);
g_signal_handlers_disconnect_by_func(G_OBJECT(sp),
G_CALLBACK(receive_timeSeries_drag), NULL);
gtk_drag_source_unset(GTK_WIDGET(sp));
gtk_drag_dest_unset(GTK_WIDGET(sp));
}
}
static void
gsm_color_button_init (GSMColorButton * color_button)
{
color_button->priv = GSM_COLOR_BUTTON_GET_PRIVATE (color_button);
color_button->priv->color.red = 0;
color_button->priv->color.green = 0;
color_button->priv->color.blue = 0;
color_button->priv->fraction = 0.5;
color_button->priv->type = GSMCP_TYPE_CPU;
color_button->priv->image_buffer = NULL;
color_button->priv->title = g_strdup (_("Pick a Color")); /* default title */
gtk_drag_dest_set (GTK_WIDGET (color_button),
GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_DROP, drop_types, 1, GDK_ACTION_COPY);
gtk_drag_source_set (GTK_WIDGET (color_button),
GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
drop_types, 1, GDK_ACTION_COPY);
g_signal_connect (color_button, "drag_begin",
G_CALLBACK (gsm_color_button_drag_begin), color_button);
g_signal_connect (color_button, "drag_data_received",
G_CALLBACK (gsm_color_button_drag_data_received),
color_button);
g_signal_connect (color_button, "drag_data_get",
G_CALLBACK (gsm_color_button_drag_data_get),
color_button);
gtk_widget_add_events (GTK_WIDGET(color_button), GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK);
gtk_widget_set_tooltip_text (GTK_WIDGET(color_button), _("Click to set graph colors"));
#if GTK_CHECK_VERSION(3,0,0)
g_signal_connect (color_button, "draw", G_CALLBACK (expose_event), color_button);
#else
g_signal_connect (color_button, "expose-event", G_CALLBACK (expose_event), color_button);
#endif
}
