gboolean
panel_check_dnd_target_data (GtkWidget *widget,
GdkDragContext *context,
guint *ret_info,
GdkAtom *ret_atom)
{
GList *l;
g_return_val_if_fail (widget, FALSE);
if (!PANEL_IS_TOPLEVEL (widget) &&
!BUTTON_IS_WIDGET (widget))
return FALSE;
if (!(gdk_drag_context_get_actions (context) & (GDK_ACTION_COPY|GDK_ACTION_MOVE)))
return FALSE;
for (l = gdk_drag_context_list_targets (context); l; l = l->next) {
GdkAtom atom;
guint info;
atom = GDK_POINTER_TO_ATOM (l->data);
if (gtk_target_list_find (get_target_list (), atom, &info)) {
if (ret_info)
*ret_info = info;
if (ret_atom)
*ret_atom = atom;
break;
}
}
return l ? TRUE : FALSE;
}
static gboolean
nemo_list_model_multi_drag_data_get (EggTreeMultiDragSource *drag_source,
GList *path_list,
GtkSelectionData *selection_data)
{
NemoListModel *model;
DragDataGetInfo context;
guint target_info;
model = NEMO_LIST_MODEL (drag_source);
context.model = model;
context.path_list = path_list;
if (!drag_target_list) {
drag_target_list = nemo_list_model_get_drag_target_list ();
}
if (gtk_target_list_find (drag_target_list,
gtk_selection_data_get_target (selection_data),
&target_info)) {
nemo_drag_drag_data_get (NULL,
NULL,
selection_data,
target_info,
GDK_CURRENT_TIME,
&context,
each_path_get_data_binder);
return TRUE;
} else {
return FALSE;
}
}
static VALUE
rg_find(VALUE self, VALUE target)
{
guint info;
gboolean ret = gtk_target_list_find(_SELF(self), RVAL2ATOM(target),
&info);
return ret ? INT2NUM(info) : Qnil;
}
/* FIXME bugzilla.gnome.org 47445: Needs to become a shared function */
static void
get_data_on_first_target_we_support (GtkWidget *widget, GdkDragContext *context, guint32 time, int x, int y)
{
GtkTargetList *list;
GdkAtom target;
if (drop_types_list == NULL) {
drop_types_list = gtk_target_list_new (drop_types,
G_N_ELEMENTS (drop_types) - 1);
gtk_target_list_add_text_targets (drop_types_list, NEMO_ICON_DND_TEXT);
}
if (drop_types_list_root == NULL) {
drop_types_list_root = gtk_target_list_new (drop_types,
G_N_ELEMENTS (drop_types));
gtk_target_list_add_text_targets (drop_types_list_root, NEMO_ICON_DND_TEXT);
}
if (nemo_icon_container_get_is_desktop (NEMO_ICON_CONTAINER (widget))) {
list = drop_types_list_root;
} else {
list = drop_types_list;
}
target = gtk_drag_dest_find_target (widget, context, list);
if (target != GDK_NONE) {
guint info;
NemoDragInfo *drag_info;
gboolean found;
drag_info = &(NEMO_ICON_CONTAINER (widget)->details->dnd_info->drag_info);
found = gtk_target_list_find (list, target, &info);
g_assert (found);
/* Don't get_data for destructive ops */
if ((info == NEMO_ICON_DND_ROOTWINDOW_DROP ||
info == NEMO_ICON_DND_XDNDDIRECTSAVE) &&
!drag_info->drop_occured) {
/* We can't call get_data here, because that would
make the source execute the rootwin action or the direct save */
drag_info->got_drop_data_type = TRUE;
drag_info->data_type = info;
} else {
if (info == NEMO_ICON_DND_XDNDDIRECTSAVE) {
set_direct_save_uri (widget, context, drag_info, x, y);
}
gtk_drag_get_data (GTK_WIDGET (widget), context,
target, time);
}
}
}
void
brasero_file_chooser_customize (GtkWidget *widget, gpointer null_data)
{
/* we explore everything until we reach a treeview (there are two) */
if (GTK_IS_TREE_VIEW (widget)) {
GtkTargetList *list;
GdkAtom target;
gboolean found;
guint num;
list = gtk_drag_source_get_target_list (widget);
target = gdk_atom_intern ("text/uri-list", TRUE);
found = gtk_target_list_find (list, target, &num);
/* FIXME: should we unref them ? apparently not according to
* the warning messages we get if we do */
if (found
&& gtk_tree_selection_get_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget))) == GTK_SELECTION_MULTIPLE) {
GtkTreeModel *model;
/* This is done because GtkFileChooser does not use a
* GtkListStore or GtkTreeStore any more. */
egg_tree_multi_drag_add_drag_support (GTK_TREE_VIEW (widget));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
if (model) {
GType type;
type = G_OBJECT_TYPE (model);
brasero_enable_multi_DND_for_model_type (type);
}
else
g_signal_connect (widget,
"notify::model",
G_CALLBACK (brasero_file_chooser_notify_model),
NULL);
}
}
else if (GTK_IS_BUTTON (widget)) {
GtkWidget *image;
gchar *stock_id = NULL;
image = gtk_button_get_image (GTK_BUTTON (widget));
if (!GTK_IS_IMAGE (image))
return;
gtk_image_get_stock (GTK_IMAGE (image), &stock_id, NULL);
if (stock_id
&& (!strcmp (stock_id,GTK_STOCK_ADD)
|| !strcmp (stock_id, GTK_STOCK_REMOVE))) {
GtkRequisition request;
gint width;
GtkWidget *parent;
/* This is to avoid having the left part too small */
parent = gtk_widget_get_parent (widget);
gtk_widget_get_requisition (parent, &request);
width = request.width;
gtk_widget_get_preferred_size (parent, &request, NULL);
if (request.width >= width)
gtk_widget_set_size_request (parent,
request.width,
request.height);
gtk_widget_hide (widget);
}
}
else if (GTK_IS_CONTAINER (widget)) {
if (GTK_IS_PANED (widget)) {
GtkWidget *left;
/* This is to allow the left part to be shrunk as much
* as the user want. */
left = gtk_paned_get_child1 (GTK_PANED (widget));
g_object_ref (left);
gtk_container_remove (GTK_CONTAINER (widget), left);
gtk_paned_pack1 (GTK_PANED (widget),
left,
TRUE,
TRUE);
g_object_unref (left);
g_signal_connect (widget,
"size-allocate",
G_CALLBACK (brasero_file_chooser_allocation_changed),
NULL);
}
gtk_container_foreach (GTK_CONTAINER (widget),
brasero_file_chooser_customize,
NULL);
}
}
static gboolean
gimp_container_tree_view_drop_status (GimpContainerTreeView *tree_view,
GdkDragContext *context,
gint x,
gint y,
guint time,
GtkTreePath **return_path,
GdkAtom *return_atom,
GimpDndType *return_src_type,
GimpViewable **return_src,
GimpViewable **return_dest,
GtkTreeViewDropPosition *return_pos)
{
GimpViewable *src_viewable = NULL;
GimpViewable *dest_viewable = NULL;
GtkTreePath *drop_path = NULL;
GtkTargetList *target_list;
GdkAtom target_atom;
GimpDndType src_type;
GtkTreeViewDropPosition drop_pos = GTK_TREE_VIEW_DROP_BEFORE;
GdkDragAction drag_action = 0;
if (! gimp_container_view_get_container (GIMP_CONTAINER_VIEW (tree_view)) ||
! gimp_container_view_get_reorderable (GIMP_CONTAINER_VIEW (tree_view)))
goto drop_impossible;
target_list = gtk_drag_dest_get_target_list (GTK_WIDGET (tree_view->view));
target_atom = gtk_drag_dest_find_target (GTK_WIDGET (tree_view->view),
context, target_list);
if (! gtk_target_list_find (target_list, target_atom, &src_type))
goto drop_impossible;
switch (src_type)
{
case GIMP_DND_TYPE_URI_LIST:
case GIMP_DND_TYPE_TEXT_PLAIN:
case GIMP_DND_TYPE_NETSCAPE_URL:
case GIMP_DND_TYPE_COLOR:
case GIMP_DND_TYPE_SVG:
case GIMP_DND_TYPE_SVG_XML:
case GIMP_DND_TYPE_COMPONENT:
case GIMP_DND_TYPE_PIXBUF:
break;
default:
{
GtkWidget *src_widget = gtk_drag_get_source_widget (context);
if (! src_widget)
goto drop_impossible;
src_viewable = gimp_dnd_get_drag_data (src_widget);
if (! GIMP_IS_VIEWABLE (src_viewable))
goto drop_impossible;
}
break;
}
if (gtk_tree_view_get_path_at_pos (tree_view->view, x, y,
&drop_path, NULL, NULL, NULL))
{
GimpViewRenderer *renderer;
GtkTreeIter iter;
GdkRectangle cell_area;
gtk_tree_model_get_iter (tree_view->model, &iter, drop_path);
gtk_tree_model_get (tree_view->model, &iter,
GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, &renderer,
-1);
dest_viewable = renderer->viewable;
g_object_unref (renderer);
gtk_tree_view_get_cell_area (tree_view->view, drop_path, NULL, &cell_area);
if (gimp_viewable_get_children (dest_viewable))
{
if (gtk_tree_view_row_expanded (tree_view->view, drop_path))
{
if (y >= (cell_area.y + cell_area.height / 2))
drop_pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
else
drop_pos = GTK_TREE_VIEW_DROP_BEFORE;
}
else
{
if (y >= (cell_area.y + 2 * (cell_area.height / 3)))
drop_pos = GTK_TREE_VIEW_DROP_AFTER;
else if (y <= (cell_area.y + cell_area.height / 3))
drop_pos = GTK_TREE_VIEW_DROP_BEFORE;
else
drop_pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
}
}
else
{
if (y >= (cell_area.y + cell_area.height / 2))
drop_pos = GTK_TREE_VIEW_DROP_AFTER;
else
drop_pos = GTK_TREE_VIEW_DROP_BEFORE;
}
}
else
{
GtkTreeIter iter;
gint n_children;
n_children = gtk_tree_model_iter_n_children (tree_view->model, NULL);
if (n_children > 0 &&
gtk_tree_model_iter_nth_child (tree_view->model, &iter,
NULL, n_children - 1))
{
GimpViewRenderer *renderer;
gtk_tree_model_get (tree_view->model, &iter,
GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER,
&renderer,
-1);
drop_path = gtk_tree_model_get_path (tree_view->model, &iter);
dest_viewable = renderer->viewable;
drop_pos = GTK_TREE_VIEW_DROP_AFTER;
g_object_unref (renderer);
}
}
if (dest_viewable || tree_view->priv->dnd_drop_to_empty)
{
if (GIMP_CONTAINER_TREE_VIEW_GET_CLASS (tree_view)->drop_possible (tree_view,
src_type,
src_viewable,
dest_viewable,
drop_path,
drop_pos,
&drop_pos,
&drag_action))
{
gdk_drag_status (context, drag_action, time);
if (return_path)
*return_path = drop_path;
else
gtk_tree_path_free (drop_path);
if (return_atom)
*return_atom = target_atom;
if (return_src)
*return_src = src_viewable;
if (return_dest)
*return_dest = dest_viewable;
if (return_pos)
*return_pos = drop_pos;
return TRUE;
}
gtk_tree_path_free (drop_path);
}
drop_impossible:
gdk_drag_status (context, 0, time);
return FALSE;
}
