static VALUE
rg_move_before(VALUE self, VALUE iter, VALUE position)
{
gtk_tree_store_move_before(_SELF(self), RVAL2GTKTREEITER(iter),
NIL_P(position) ? NULL : RVAL2GTKTREEITER(position));
return self;
}
void PluginManageDlg::drag_data_received_cb(GtkWidget *widget, GdkDragContext *ctx, guint x, guint y, GtkSelectionData *sd, guint info, guint t, PluginManageDlg *oPluginManageDlg)
{
if (gtk_selection_data_get_target(sd) == gdk_atom_intern("STARDICT_PLUGINMANAGE", FALSE) && gtk_selection_data_get_data(sd)) {
GtkTreePath *path = NULL;
GtkTreeViewDropPosition position;
GtkTreeIter drag_iter;
memcpy(&drag_iter, gtk_selection_data_get_data(sd), sizeof(drag_iter));
if (gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(widget), x, y, &path, &position)) {
GtkTreeIter iter;
GtkTreeModel *model = GTK_TREE_MODEL(oPluginManageDlg->plugin_tree_model);
gtk_tree_model_get_iter(model, &iter, path);
if (gtk_tree_model_iter_has_child(model, &iter)) {
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
if (gtk_tree_model_iter_has_child(model, &drag_iter)) {
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
GtkTreeIter parent_iter;
if (!gtk_tree_model_iter_parent(model, &parent_iter, &iter)) {
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
GtkTreeIter drag_parent_iter;
if (!gtk_tree_model_iter_parent(model, &drag_parent_iter, &drag_iter)) {
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
char *iter_str, *drag_iter_str;
iter_str = gtk_tree_model_get_string_from_iter(model, &parent_iter);
drag_iter_str = gtk_tree_model_get_string_from_iter(model, &drag_parent_iter);
if (strcmp(iter_str, drag_iter_str) != 0) {
g_free(iter_str);
g_free(drag_iter_str);
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
g_free(iter_str);
g_free(drag_iter_str);
switch (position) {
case GTK_TREE_VIEW_DROP_AFTER:
case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
gtk_tree_store_move_after(GTK_TREE_STORE(model), &drag_iter, &iter);
break;
case GTK_TREE_VIEW_DROP_BEFORE:
case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
gtk_tree_store_move_before(GTK_TREE_STORE(model), &drag_iter, &iter);
break;
default: {
gtk_drag_finish (ctx, FALSE, FALSE, t);
return;
}
}
oPluginManageDlg->write_order_list();
oPluginManageDlg->order_changed_ = true;
gtk_drag_finish (ctx, TRUE, FALSE, t);
}
}
}
int tree_config_move_selected_up(void)
{
GtkTreeSelection *sel;
GtkTreeModel *model;
GtkTreeIter iter, iter_before, iter_tmp;
//model = GTK_TREE_MODEL(tree_config_get_store());
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(GET_WIDGET(TREE_CONFIGS)));
if (gtk_tree_selection_get_selected(sel, &model, &iter) == FALSE)
return -1;
gtk_tree_model_get_iter_first(model, &iter_before);
if (tree_config_iter_equals(&iter_before, &iter) == 1)
return -1;
iter_tmp = iter_before;
while (tree_config_iter_equals(&iter_tmp, &iter) == 0)
{
iter_before = iter_tmp;
gtk_tree_model_iter_next(model, &iter_tmp);
}
gtk_tree_store_move_before(GTK_TREE_STORE(model), &iter, &iter_before);
tree_config_update_priorities();
return 0;
}
static void
move_row (chan *ch, int delta, GtkTreeIter *parent)
{
GtkTreeStore *store = ch->cv->store;
GtkTreeIter *src = &ch->iter;
GtkTreeIter dest = ch->iter;
GtkTreePath *dest_path;
if (delta < 0) /* down */
{
if (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &dest))
gtk_tree_store_swap (store, src, &dest);
else /* move to top */
gtk_tree_store_move_after (store, src, NULL);
} else
{
dest_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &dest);
if (gtk_tree_path_prev (dest_path))
{
gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &dest, dest_path);
gtk_tree_store_swap (store, src, &dest);
} else
{ /* move to bottom */
gtk_tree_store_move_before (store, src, NULL);
}
gtk_tree_path_free (dest_path);
}
}
static void prefs_dialog_sensor_up_button_clicked(GtkButton *button, PrefsDialog *prefs_dialog) {
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
if (gtk_tree_selection_get_selected(prefs_dialog->sensors_applet->selection, &model, &iter)) {
/* if has no prev node set up button insentive */
path = gtk_tree_model_get_path(model, &iter);
if (gtk_tree_path_prev(path)) {
GtkTreeIter prev_iter;
/* check is a valid node in out model */
if (gtk_tree_model_get_iter(model, &prev_iter, path)) {
gtk_tree_store_move_before(GTK_TREE_STORE(model),
&iter,
&prev_iter);
g_signal_emit_by_name(prefs_dialog->sensors_applet->selection,
"changed");
sensors_applet_reorder_sensors(prefs_dialog->sensors_applet);
}
}
gtk_tree_path_free(path);
}
}
void gTreeRow::moveBefore(char *key)
{
gTreeRow *row;
if (!key || !*key)
{
moveLast();
return;
}
row = tree->getRow(key);
if (!row)
return;
if (strcmp(row->parent(), parent()))
return;
gtk_tree_store_move_before(tree->store, dataiter, row->dataiter);
}
static void
gbf_project_model_merge (GtkTreeModel *model,
GtkTreePath *begin,
GtkTreePath *half,
GtkTreePath *end,
GtkTreeIterCompareFunc compare_func,
gpointer user_data)
{
GtkTreeIter right;
GtkTreeIter left;
if (gtk_tree_model_get_iter (model, &left, begin) &&
gtk_tree_model_get_iter (model, &right, half))
{
gint depth;
gint ll, lr;
/* Get number of elements in both list */
ll = (gtk_tree_path_get_indices_with_depth (half, &depth)[depth - 1]
- gtk_tree_path_get_indices_with_depth (begin, &depth)[depth - 1]);
lr = (gtk_tree_path_get_indices_with_depth (end, &depth)[depth - 1]
- gtk_tree_path_get_indices_with_depth (half, &depth)[depth - 1]);
while (ll && lr)
{
if (compare_func (model, &left, &right, user_data) <= 0)
{
gtk_tree_model_iter_next (model, &left);
ll--;
}
else
{
GtkTreeIter iter;
iter = right;
gtk_tree_model_iter_next (model, &right);
lr--;
gtk_tree_store_move_before (GTK_TREE_STORE (model), &iter, &left);
}
}
}
}
/**
* Callback called by a click on the up arrow
* to move a payment method up
*
* \param button
* \param tree_view
*
* \return FALSE
*/
gboolean gsb_reconcile_sort_config_move_up ( GtkWidget *button,
GtkWidget *tree_view )
{
GtkTreePath * treepath;
gboolean good, visible;
GtkTreeIter iter, other;
gint payment_number;
gint account_number;
GtkTreeModel *model;
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
good = gtk_tree_selection_get_selected (selection, NULL, &iter);
if (good)
gtk_tree_model_get ( GTK_TREE_MODEL(model), &iter,
RECONCILIATION_SORT_VISIBLE_COLUMN, &visible,
RECONCILIATION_SORT_ACCOUNT_COLUMN, &account_number,
RECONCILIATION_SORT_TYPE_COLUMN, &payment_number,
-1 );
if ( good && ! visible )
{
treepath = gtk_tree_model_get_path ( GTK_TREE_MODEL(model),
&iter );
if ( gtk_tree_path_prev ( treepath ) &&
gtk_tree_model_get_iter ( GTK_TREE_MODEL(model),
&other, treepath ) )
{
gtk_tree_store_move_before ( GTK_TREE_STORE(model),
&iter, &other );
}
}
gsb_reconcile_sort_config_select ( selection,
GTK_TREE_MODEL(model) );
gsb_reconcile_sort_config_update_account_sort_list (account_number, model);
return FALSE;
}
int
clip_GTK_TREESTOREMOVEBEFORE(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
C_object *citer1 = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
C_object *citer2 = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3));
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKCOBJ(citer1, GTK_IS_TREE_ITER(citer1->object));
CHECKCOBJOPT(citer2, GTK_IS_TREE_ITER(citer2->object));
gtk_tree_store_move_before(GTK_TREE_STORE(cstree->object),
GTK_TREE_ITER(citer1->object), (citer2) ? GTK_TREE_ITER(citer2->object) : NULL);
return 0;
err:
return 1;
}
void gTreeRow::moveLast()
{
gtk_tree_store_move_before(tree->store, dataiter, NULL);
}
static void sort_method_ext_blist_sort(
PurpleBlistNode *node, PurpleBuddyList *blist,
GtkTreeIter group, GtkTreeIter *cur, GtkTreeIter *ret
) {
GtkTreeIter tmp_iter;
PidginBuddyList *gtkblist;
gtkblist = PIDGIN_BLIST(purple_get_blist());
if(!PURPLE_BLIST_NODE_IS_CONTACT(node) && !PURPLE_BLIST_NODE_IS_CHAT(node)) {
sort_method_none(node, blist, group, cur, ret);
return;
}
/* Get first child of group. Insert immediately if group is empty. */
if (!gtk_tree_model_iter_children(GTK_TREE_MODEL(gtkblist->treemodel), &tmp_iter, &group)) {
gtk_tree_store_insert(gtkblist->treemodel, ret, &group, 0);
return;
}
/* Go trough all children */
do {
GValue val;
PurpleBlistNode *n;
gint cmp1, cmp2, cmp3;
/* Retrieve a BlistNode from a TreeModelNode */
val.g_type=0;
gtk_tree_model_get_value(GTK_TREE_MODEL(gtkblist->treemodel), &tmp_iter, NODE_COLUMN, &val);
n = g_value_get_pointer(&val);
/* Comparing... */
cmp1 = compare(
purple_prefs_get_int(PLUGIN_PREFS_PREFIX "/sort1"),
purple_prefs_get_bool(PLUGIN_PREFS_PREFIX "/sort1_reverse"),
node, n
);
cmp2 = compare(
purple_prefs_get_int(PLUGIN_PREFS_PREFIX "/sort2"),
purple_prefs_get_bool(PLUGIN_PREFS_PREFIX "/sort2_reverse"),
node, n
);
cmp3 = compare(
purple_prefs_get_int(PLUGIN_PREFS_PREFIX "/sort3"),
purple_prefs_get_bool(PLUGIN_PREFS_PREFIX "/sort3_reverse"),
node, n
);
/* Insert node before the current? */
/* TODO: refactor */
if(cmp1 < 0 ||
(cmp1 == 0 &&
(cmp2 < 0 ||
(cmp2 == 0 &&
(cmp3 < 0 ||
(cmp3 == 0 && node < n)))))) {
if(cur == NULL) {
gtk_tree_store_insert_before(gtkblist->treemodel, ret, &group, &tmp_iter);
} else {
gtk_tree_store_move_before(gtkblist->treemodel, cur, &tmp_iter);
*ret = *cur;
}
return;
}
g_value_unset(&val);
/* Get next node */
} while(gtk_tree_model_iter_next(GTK_TREE_MODEL(gtkblist->treemodel), &tmp_iter));
/* Insert at the end */
if(cur == NULL) {
gtk_tree_store_append(gtkblist->treemodel, ret, &group);
} else {
gtk_tree_store_move_before(gtkblist->treemodel, cur, NULL);
*ret = *cur;
}
return;
}
