static gboolean ui_dnd_feed_drop_possible (GtkTreeDragDest *drag_dest, GtkTreePath *dest_path, GtkSelectionData *selection_data) { GtkTreeModel *model = NULL; GtkTreePath *src_path = NULL; GtkTreeIter iter; nodePtr sourceNode, targetNode; debug1 (DEBUG_GUI, "DnD check if feed dropping is possible (%d)", dest_path); if (!(old_feed_drop_possible) (drag_dest, dest_path, selection_data)) return FALSE; if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_dest), &iter, dest_path)) return FALSE; /* Try to get an iterator, if we get none it means either feed list root or an "Empty" node. Both cases are fine */ gtk_tree_model_get (GTK_TREE_MODEL (drag_dest), &iter, FS_PTR, &targetNode, -1); if (!targetNode) return TRUE; /* If we got an iterator it's either a possible dropping candidate (a folder or source node to drop into, or a iterator to insert after). In any case we have to check if it is a writeable node source. */ /* Never drop into read-only subscription node sources */ if (!(NODE_SOURCE_TYPE (targetNode)->capabilities & NODE_SOURCE_CAPABILITY_WRITABLE_FEEDLIST)) return FALSE; /* never drag folders into non-hierarchic node sources */ if (!gtk_tree_get_row_drag_data (selection_data, &model, &src_path)) return TRUE; if (gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, src_path)) { gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, FS_PTR, &sourceNode, -1); g_assert (sourceNode); /* Never drop into another node source as this arises to many problems (e.g. remote sync, different subscription type, e.g. SF #2855990) */ if (NODE_SOURCE_TYPE (targetNode) != NODE_SOURCE_TYPE (sourceNode)) return FALSE; if (IS_FOLDER(sourceNode) && !(NODE_SOURCE_TYPE (targetNode)->capabilities & NODE_SOURCE_CAPABILITY_HIERARCHIC_FEEDLIST)) return FALSE; } gtk_tree_path_free (src_path); return TRUE; }
JNIEXPORT jboolean JNICALL Java_org_gnome_gtk_GtkSelectionData_gtk_1tree_1get_1row_1drag_1data ( JNIEnv* env, jclass cls, jlong _self, jlongArray _treeModel, jlongArray _path ) { gboolean result; jboolean _result; GtkSelectionData* self; GtkTreeModel** treeModel; GtkTreePath** path; // convert parameter self self = (GtkSelectionData*) _self; // convert parameter treeModel treeModel = (GtkTreeModel**) bindings_java_convert_jarray_to_gpointer(env, _treeModel); if (treeModel == NULL) { return JNI_FALSE; // Java Exception already thrown } // convert parameter path path = (GtkTreePath**) bindings_java_convert_jarray_to_gpointer(env, _path); if (path == NULL) { return JNI_FALSE; // Java Exception already thrown } // call function result = gtk_tree_get_row_drag_data(self, treeModel, path); // cleanup parameter self // cleanup parameter treeModel bindings_java_convert_gpointer_to_jarray(env, (gpointer*)treeModel, _treeModel); // cleanup parameter path bindings_java_convert_gpointer_to_jarray(env, (gpointer*)path, _path); // translate return value to JNI type _result = (jboolean) result; // and finally return _result; }
static gboolean view_column_model_row_drop_possible (GtkTreeDragDest *drag_dest, GtkTreePath *dest_path, GtkSelectionData *selection_data) { GtkTreeModel *src_model; if (gtk_tree_get_row_drag_data (selection_data, &src_model, NULL)) { if (src_model == left_tree_model || src_model == top_right_tree_model || src_model == bottom_right_tree_model) return TRUE; } return FALSE; }
static gboolean view_column_model_drag_data_received (GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data) { GtkTreeModel *src_model; GtkTreePath *src_path = NULL; gboolean retval = FALSE; if (gtk_tree_get_row_drag_data (selection_data, &src_model, &src_path)) { GtkTreeIter src_iter; GtkTreeIter dest_iter; gboolean have_dest; /* We are a little lazy here, and assume if we can't convert dest * to an iter, we need to append. See gtkliststore.c for a more * careful handling of this. */ have_dest = gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_dest), &dest_iter, dest); if (gtk_tree_model_get_iter (src_model, &src_iter, src_path)) { if (src_model == left_tree_model || src_model == top_right_tree_model || src_model == bottom_right_tree_model) { move_row (src_model, &src_iter, GTK_TREE_MODEL (drag_dest), have_dest ? &dest_iter : NULL); retval = TRUE; } } gtk_tree_path_free (src_path); } return retval; }
static gboolean bookmark_tree_store_row_drop_possible (GtkTreeDragDest *drag_dest, GtkTreePath *dest_path, GtkSelectionData *selection_data) { GtkTreeModel *src_model = NULL; GtkTreePath *src_path = NULL; GtkTreePath *tmp = NULL; gboolean retval = FALSE; GtkTreeIter iter; GNode *src_node, *dst_node; gftp2_bookmark *src_bm, *dst_bm; if (!gtk_tree_get_row_drag_data (selection_data, &src_model, &src_path)) goto out; /* fprintf (stderr, "%s -to- %s", gtk_tree_path_to_string (src_path), gtk_tree_path_to_string (dest_path)); */ /* can only drag to ourselves */ if (src_model != GTK_TREE_MODEL (drag_dest)) goto out; /* Can't drop into ourself. */ if (gtk_tree_path_is_ancestor (src_path, dest_path)) goto out; /* Can't drop if dest_path's parent doesn't exist */ if (gtk_tree_path_get_depth (dest_path) > 1) { tmp = gtk_tree_path_copy (dest_path); gtk_tree_path_up (tmp); if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_dest), &iter, tmp)) goto out; gtk_tree_model_get (src_model, &iter, /* src_model == dst_model */ COLUMN_ENTRY, &dst_node, -1); g_assert (dst_node); dst_bm = (gftp2_bookmark *)dst_node->data; /* can't drag an item into a non-folder */ if (!dst_bm->is_folder) goto out; gtk_tree_model_get_iter (src_model, &iter, src_path); gtk_tree_model_get (src_model, &iter, COLUMN_ENTRY, &src_node, -1); g_assert (src_node); src_bm = (gftp2_bookmark *)src_node->data; /* can't drag folder into a folder */ if (src_bm->is_folder) goto out; } /* Can otherwise drop anywhere. */ retval = TRUE; out: /* fprintf (stderr, " %s\n", retval ? "Can drop" : "Can't drop"); */ if (src_path) gtk_tree_path_free (src_path); if (tmp) gtk_tree_path_free (tmp); return retval; }
static void on_drag_data_received ( GtkWidget *dest_widget, GdkDragContext *drag_context, gint x, gint y, GtkSelectionData *sel_data, guint info, guint time) { FmPlacesView* view = FM_PLACES_VIEW(dest_widget); GtkTreePath* dest_tp = NULL; GtkTreeViewDropPosition pos; gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(view), x, y, &dest_tp, &pos); switch(info) { case FM_DND_DEST_TARGET_BOOOKMARK: if(get_bookmark_drag_dest(view, &dest_tp, &pos)) /* got the drop position */ { GtkTreePath* src_tp; /* get the source row */ gboolean ret = gtk_tree_get_row_drag_data(sel_data, NULL, &src_tp); if(ret) { /* don't do anything if source and dest are the same row */ if(G_UNLIKELY(gtk_tree_path_compare(src_tp, dest_tp) == 0)) ret = FALSE; else { /* don't do anything if this is not a bookmark item */ if(!fm_places_model_path_is_bookmark(FM_PLACES_MODEL(model), src_tp)) ret = FALSE; } if(ret) { GtkTreeIter src_it, dest_it; FmPlaceItem* item = NULL; ret = FALSE; /* get the source bookmark item */ if(gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &src_it, src_tp)) gtk_tree_model_get(GTK_TREE_MODEL(model), &src_it, FM_PLACES_MODEL_COL_INFO, &item, -1); if(item) { /* move it to destination position */ if(gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &dest_it, dest_tp)) { int new_pos, sep_pos; /* get index of the separator */ const GtkTreePath* sep_tp = fm_places_model_get_separator_path(FM_PLACES_MODEL(model)); sep_pos = gtk_tree_path_get_indices(sep_tp)[0]; if(pos == GTK_TREE_VIEW_DROP_BEFORE) gtk_list_store_move_before(model, &src_it, &dest_it); else gtk_list_store_move_after(model, &src_it, &dest_it); new_pos = gtk_tree_path_get_indices(dest_tp)[0] - sep_pos - 1; /* reorder the bookmark item */ fm_bookmarks_reorder(FM_PLACES_MODEL(model)->bookmarks, item->bm_item, new_pos); ret = TRUE; } } } gtk_tree_path_free(src_tp); } gtk_drag_finish(drag_context, ret, FALSE, time); } break; default: /* check if files are received. */ fm_dnd_dest_drag_data_received(view->dnd_dest, drag_context, x, y, sel_data, info, time); break; } if(dest_tp) gtk_tree_path_free(dest_tp); }