static VALUE
rg_move_after(VALUE self, VALUE iter, VALUE position)
{
gtk_tree_store_move_after(_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);
}
}
}
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);
}
}
void gTreeRow::moveAfter(char *key)
{
gTreeRow *row;
if (!key || !*key)
{
moveFirst();
return;
}
row = tree->getRow(key);
if (!row)
return;
if (strcmp(row->parent(), parent()))
return;
gtk_tree_store_move_after(tree->store, dataiter, row->dataiter);
}
static void prefs_dialog_sensor_down_button_clicked(GtkButton *button, PrefsDialog *prefs_dialog) {
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeIter iter_next;
if (gtk_tree_selection_get_selected(prefs_dialog->sensors_applet->selection, &model, &iter)) {
iter_next = iter;
/* if has no next node set down button insentive */
if (gtk_tree_model_iter_next(model, &iter_next)) {
gtk_tree_store_move_after(GTK_TREE_STORE(model),
&iter,
&iter_next);
g_signal_emit_by_name(prefs_dialog->sensors_applet->selection,
"changed");
sensors_applet_reorder_sensors(prefs_dialog->sensors_applet);
}
}
}
/**
* 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_down ( 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 );
gtk_tree_path_next ( treepath ) ;
if ( gtk_tree_model_get_iter ( GTK_TREE_MODEL(model),
&other, treepath ) )
{
gtk_tree_store_move_after ( 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 tree_config_move_selected_down(void)
{
GtkTreeSelection *sel;
GtkTreeModel *model;
GtkTreeIter iter, iter_after;
//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;
iter_after = iter;
if (gtk_tree_model_iter_next(model, &iter_after) == FALSE)
return -1;
gtk_tree_store_move_after(GTK_TREE_STORE(model), &iter, &iter_after);
tree_config_update_priorities();
return 0;
}
int
clip_GTK_TREESTOREMOVEAFTER(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_after(GTK_TREE_STORE(cstree->object),
GTK_TREE_ITER(citer1->object), (citer2) ? GTK_TREE_ITER(citer2->object) : NULL);
return 0;
err:
return 1;
}
void gTreeRow::moveFirst()
{
gtk_tree_store_move_after(tree->store, dataiter, NULL);
}
/**
* Build data storage by querying the X server for all input devices.
* Can be called multiple times, in which case it'll clean out and re-fill
* update the tree store.
*/
static GtkTreeStore* query_devices(GDeviceSetup* gds)
{
GtkTreeStore *treestore;
GtkTreeModel *model;
GtkTreeIter iter, child;
XIDeviceInfo *devices, *dev;
int ndevices;
int i, j;
int icontype;
GdkPixbuf *icon;
int valid, child_valid;
int id, masterid;
if (!gds->treeview)
{
treestore = gtk_tree_store_new(NUM_COLS,
G_TYPE_UINT, /* deviceid*/
G_TYPE_STRING, /* name */
G_TYPE_UINT,
GDK_TYPE_PIXBUF,
G_TYPE_UINT
);
model = GTK_TREE_MODEL(treestore);
} else
{
model = gtk_tree_view_get_model(gds->treeview);
treestore = GTK_TREE_STORE(model);
}
gds->generation++;
devices = XIQueryDevice(gds->dpy, XIAllDevices, &ndevices);
/* First, run through all master device and append them to the tree store
*/
for (i = 0; i < ndevices; i++)
{
dev = &devices[i];
if (dev->use != XIMasterPointer && dev->use != XIMasterKeyboard)
continue;
valid = gtk_tree_model_get_iter_first(model, &iter);
g_debug("MD %d: %s", dev->deviceid, dev->name);
while(valid) {
gtk_tree_model_get(model, &iter, COL_ID, &id, -1);
if (id == dev->deviceid)
{
gtk_tree_store_set(treestore, &iter,
COL_GENERATION, gds->generation, -1);
valid = 0xFF;
break;
}
valid = gtk_tree_model_iter_next(model, &iter);
}
if (valid != 0xFF) /* new MD */
{
icontype = (dev->use == XIMasterPointer) ? ICON_MOUSE : ICON_KEYBOARD;
icon = load_icon(icontype);
gtk_tree_store_append(treestore, &iter, NULL);
gtk_tree_store_set(treestore, &iter,
COL_ID, dev->deviceid,
COL_NAME, dev->name,
COL_USE, dev->use,
COL_ICON, icon,
COL_GENERATION, gds->generation,
-1);
g_object_unref(icon);
}
}
/* search for Floating fake master device */
valid = gtk_tree_model_get_iter_first(model, &iter);
while(valid)
{
gtk_tree_model_get(model, &iter, COL_ID, &id, -1);
if (id == ID_FLOATING)
break;
valid = gtk_tree_model_iter_next(model, &iter);
}
if (!valid)
{
/* Attach a fake master device for "Floating" */
icon = load_icon(ICON_FLOATING);
gtk_tree_store_append(treestore, &iter, NULL);
gtk_tree_store_set(treestore, &iter,
COL_ID, ID_FLOATING,
COL_NAME, "Floating",
COL_USE, ID_FLOATING,
COL_ICON, icon,
COL_GENERATION, gds->generation,
-1);
g_object_unref(icon);
} else {
GtkTreeIter prev;
GtkTreeIter pos = iter; /* current position of Floating */
/* always move Floating fake device to end of list */
while(valid)
{
prev = iter;
valid = gtk_tree_model_iter_next(model, &iter);
}
gtk_tree_store_move_after(treestore, &pos, &prev);
/* update generation too */
gtk_tree_store_set(treestore, &pos,
COL_GENERATION, gds->generation, -1);
}
/* now that we added all MDs, run through again and add SDs to the
* respective MD */
for (i = 0; i < ndevices; i++)
{
dev = &devices[i];
if (dev->use == XIMasterPointer || dev->use == XIMasterKeyboard)
continue;
g_debug("SD %d: %s", dev->deviceid, dev->name);
valid = gtk_tree_model_get_iter_first(model, &iter);
while(valid) {
gtk_tree_model_get(model, &iter, COL_ID, &masterid, -1);
if(dev->attachment == masterid || (dev->use == XIFloatingSlave && masterid == ID_FLOATING))
{
/* found master, check if we're already attached to it in
* the tree model */
child_valid = gtk_tree_model_iter_children(model, &child, &iter);
while (child_valid)
{
gtk_tree_model_get(model, &child, COL_ID, &id);
if (id == dev->deviceid)
{
gtk_tree_store_set(treestore, &child,
COL_GENERATION, gds->generation, -1);
child_valid = 0xFF;
break;
}
child_valid = gtk_tree_model_iter_next(model, &child);
}
/* new slave device, attach */
if (child_valid != 0xFF)
{
gtk_tree_store_append(treestore, &child, &iter);
gtk_tree_store_set(treestore, &child,
COL_ID, dev->deviceid,
COL_NAME, dev->name,
COL_USE, dev->use,
COL_GENERATION, gds->generation,
-1);
}
break;
}
valid = gtk_tree_model_iter_next(model, &iter);
}
}
XIFreeDeviceInfo(devices);
/* clean tree store of anything that doesn't have the current
server generation */
valid = gtk_tree_model_get_iter_first(model, &iter);
while(valid)
{
int gen;
child_valid = gtk_tree_model_iter_children(model, &child, &iter);
while(child_valid)
{
gtk_tree_model_get(model, &child, COL_GENERATION, &gen, -1);
if (gen < gds->generation)
child_valid = gtk_tree_store_remove(treestore, &child);
else
child_valid = gtk_tree_model_iter_next(model, &child);
}
gtk_tree_model_get(model, &iter, COL_GENERATION, &gen, -1);
if (gen < gds->generation)
valid = gtk_tree_store_remove(treestore, &iter);
else
valid = gtk_tree_model_iter_next(model, &iter);
}
return treestore;
}
