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);
}
