static void
move_selected_input_down (GtkButton *button, gpointer data)
{
GtkBuilder *builder = data;
GtkTreeModel *model;
GtkTreeIter iter, next;
GtkTreePath *path;
g_debug ("move selected input source down");
if (!get_selected_iter (builder, &model, &iter))
return;
next = iter;
if (!gtk_tree_model_iter_next (model, &next))
return;
path = gtk_tree_model_get_path (model, &next);
gtk_list_store_swap (GTK_LIST_STORE (model), &iter, &next);
set_selected_path (builder, path);
gtk_tree_path_free (path);
update_button_sensitivity (builder);
update_configuration (model);
}
/****************************************************************
Move item down in queue
*****************************************************************/
static void queue_bubble_down(struct worklist_data *ptr)
{
GtkTreePath *path;
GtkTreeViewColumn *col;
GtkTreeModel *model;
if (!gtk_widget_is_sensitive(ptr->dst_view)) {
return;
}
model = GTK_TREE_MODEL(ptr->dst);
gtk_tree_view_get_cursor(GTK_TREE_VIEW(ptr->dst_view), &path, &col);
if (path) {
GtkTreeIter it, it_next;
gtk_tree_model_get_iter(model, &it, path);
it_next = it;
if (gtk_tree_model_iter_next(model, &it_next)) {
gtk_list_store_swap(GTK_LIST_STORE(model), &it, &it_next);
gtk_tree_path_next(path);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(ptr->dst_view), path, col, FALSE);
commit_worklist(ptr);
}
}
gtk_tree_path_free(path);
}
static void prefs_custom_header_up(void)
{
GtkTreePath *prev, *sel;
GtkTreeIter isel;
GtkListStore *store = NULL;
GtkTreeModel *model = NULL;
GtkTreeIter iprev;
if (!gtk_tree_selection_get_selected
(gtk_tree_view_get_selection
(GTK_TREE_VIEW(customhdr.list_view)),
&model,
&isel))
return;
store = (GtkListStore *)model;
sel = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &isel);
if (!sel)
return;
/* no move if we're at row 0... */
prev = gtk_tree_path_copy(sel);
if (!gtk_tree_path_prev(prev)) {
gtk_tree_path_free(prev);
gtk_tree_path_free(sel);
return;
}
gtk_tree_model_get_iter(GTK_TREE_MODEL(store),
&iprev, prev);
gtk_tree_path_free(sel);
gtk_tree_path_free(prev);
gtk_list_store_swap(store, &iprev, &isel);
prefs_custom_header_set_list(cur_ac);
}
void
on_btn_down_clicked (GtkButton *button, gpointer user_data)
{
GtkTreeModel *treemodel;
GtkTreeIter iter, next;
GtkTreeSelection *sel;
GtkTreePath *path;
gint i, *indice;
GList *launcher;
sel = gtk_tree_view_get_selection( GTK_TREE_VIEW(_dlg->treeview1) );
if ( gtk_tree_selection_get_selected(sel, &treemodel, &iter) )
{
next = iter;
if (gtk_tree_model_iter_next(treemodel, &next))
{
gtk_list_store_swap(GTK_LIST_STORE(treemodel), &iter, &next);
path = gtk_tree_model_get_path(treemodel, &next);
indice = gtk_tree_path_get_indices(path);
launcher = g_list_nth(_quicklauncher->launchers, indice[0]+1);
_quicklauncher->launchers = g_list_remove_link(_quicklauncher->launchers, launcher);
_quicklauncher->launchers = g_list_insert(_quicklauncher->launchers, launcher->data, indice[0]);
quicklauncher_empty_widgets();
quicklauncher_organize();
gtk_tree_path_free (path);
g_list_free(launcher);
}
}
}
static void remmina_string_list_move(RemminaStringList *gsl, GtkTreeIter *from, GtkTreeIter *to)
{
GtkTreePath *path;
gtk_list_store_swap(gsl->store, from, to);
path = gtk_tree_model_get_path(GTK_TREE_MODEL(gsl->store), from);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(gsl->list), path, NULL, 0, 0, 0);
gtk_tree_path_free(path);
}
/**
* Move account in list depending on direction and selected account
*/
static void
account_move(gboolean move_up, gpointer data)
{
// Get view, model and selection of account
GtkTreeView *tree_view = GTK_TREE_VIEW(data);
GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
GtkTreeSelection *selection = gtk_tree_view_get_selection(tree_view);
// Find selected iteration and create a copy
GtkTreeIter iter;
gtk_tree_selection_get_selected(selection, &model, &iter);
GtkTreeIter *iter_copy;
iter_copy = gtk_tree_iter_copy(&iter);
// Find path of iteration
gchar *path = gtk_tree_model_get_string_from_iter(model, &iter);
// The first real account in the list can't move up because of the IP2IP account
// It can still move down though
if (g_strcmp0(path, "1") == 0 && move_up)
return;
GtkTreePath *tree_path = gtk_tree_path_new_from_string(path);
gint *indices = gtk_tree_path_get_indices(tree_path);
const gint pos = indices[0] - 1; /* black magic : gtk tree order is not account queue order */
// Depending on button direction get new path
if (move_up)
gtk_tree_path_prev(tree_path);
else
gtk_tree_path_next(tree_path);
gtk_tree_model_get_iter(model, &iter, tree_path);
// Swap iterations if valid
if (gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter))
gtk_list_store_swap(GTK_LIST_STORE(model), &iter, iter_copy);
// Scroll to new position
gtk_tree_view_scroll_to_cell(tree_view, tree_path, NULL, FALSE, 0, 0);
// Free resources
gtk_tree_path_free(tree_path);
gtk_tree_iter_free(iter_copy);
g_free(path);
// Perpetuate changes in account queue
if (move_up)
account_list_move_up(pos);
else
account_list_move_down(pos);
// Set the order in the configuration file
gchar *ordered_account_list = account_list_get_ordered_list();
dbus_set_accounts_order(ordered_account_list);
g_free(ordered_account_list);
}
static void
codec_moved_cb (GtkWidget *widget,
gpointer data)
{
CodecsBox *self = NULL;
GtkTreeIter iter;
GtkTreeIter *iter2 = NULL;
GtkTreeModel *model = NULL;
GtkTreeSelection *selection = NULL;
GtkTreePath *tree_path = NULL;
std::list<std::string> list;
gchar *path_str = NULL;
self = CODECS_BOX (data);
model = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->codecs_list));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->codecs_list));
if (!gtk_tree_selection_get_selected (GTK_TREE_SELECTION (selection),
NULL, &iter))
return;
/* Update the tree view */
iter2 = gtk_tree_iter_copy (&iter);
path_str = gtk_tree_model_get_string_from_iter (GTK_TREE_MODEL (model),
&iter);
tree_path = gtk_tree_path_new_from_string (path_str);
if (!g_strcmp0 ((gchar *) g_object_get_data (G_OBJECT (widget), "operation"),
"up"))
gtk_tree_path_prev (tree_path);
else
gtk_tree_path_next (tree_path);
gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, tree_path);
if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter)
&& gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter2))
gtk_list_store_swap (GTK_LIST_STORE (model), &iter, iter2);
/* Scroll to the new position */
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self->priv->codecs_list),
tree_path, NULL, FALSE, 0, 0);
gtk_tree_path_free (tree_path);
gtk_tree_iter_free (iter2);
g_free (path_str);
/* Update the key */
list = codecs_box_to_list (self);
if (self->priv->type == Ekiga::Call::Audio)
self->priv->audio_settings->set_string_list ("media-list", list);
else if (self->priv->type == Ekiga::Call::Video)
self->priv->video_settings->set_string_list ("media-list", list);
}
void CListBox::MoveDown(int idx)
{
if( idx + 1 >= Count() )
return;
GtkTreeIter iter;
gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(m_Store), &iter, NULL, idx);
GtkTreeIter iter2 = iter;
gtk_tree_model_iter_next(GTK_TREE_MODEL(m_Store), &iter2 );
gtk_list_store_swap(m_Store, &iter, &iter2);
}
static void
swap_rows (GtkWidget *button, GtkIconView *icon_list)
{
GtkTreeIter iter, iter2;
GtkTreeModel *model;
model = gtk_icon_view_get_model (icon_list);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), -2, GTK_SORT_ASCENDING);
gtk_tree_model_get_iter_first (model, &iter);
iter2 = iter;
gtk_tree_model_iter_next (model, &iter2);
gtk_list_store_swap (GTK_LIST_STORE (model), &iter, &iter2);
}
/* Called when Down button is clicked */
static void move_action_down(GtkButton *button, gpointer user_data)
{
GtkTreeIter sel_iter;
/* Check if selected */
if (gtk_tree_selection_get_selected(actions_selection, NULL, &sel_iter))
{
/* Create iter to next row */
GtkTreeIter next_iter = sel_iter;
/* Check if next row exists */
if (gtk_tree_model_iter_next((GtkTreeModel*)actions_list, &next_iter))
/* Swap rows */
gtk_list_store_swap(actions_list, &sel_iter, &next_iter);
}
}
void SwapTableItemText(int max, int rowA, int rowB)
{
GtkTreeView *table = (GtkTreeView *)glade_xml_get_widget(windowXML, "table");
GtkListStore *store = (GtkListStore *)gtk_tree_view_get_model(table);
GtkTreeModel *model = gtk_tree_view_get_model(table);
GtkTreeIter iter, iterA, iterB;
gtk_tree_model_get_iter_first(model, &iter);
for (int i=0; i<max; i++) {
if (rowA == i) iterA = iter;
if (rowB == i) iterB = iter;
}
gtk_list_store_swap(store, &iterA, &iterB);
}
static void
trackersettings_gui_exchange_font (TrackerSettings *ts,
int p1,
int p2)
{
GtkTreeIter iter1, iter2;
GtkListStore *list_store = GUI_GET_LIST_STORE(ts->list);
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(ts->list));
if(!gui_list_get_iter(p1, list_store, &iter1) ||
!gui_list_get_iter(p2, list_store, &iter2))
return;
gtk_list_store_swap(list_store, &iter1, &iter2);
gtk_tree_selection_select_iter(sel, &iter1);// Minor bug with selection determining is here...
}
static void
move_cb (SortFlowState *state,
gboolean (*mover) (GtkTreeModel *, GtkTreeIter *))
{
GtkTreeIter iter, this_iter;
if (!gtk_tree_selection_get_selected (state->selection, NULL,
&this_iter))
return;
iter = this_iter;
if (!mover (GTK_TREE_MODEL(state->model), &iter))
return;
gtk_list_store_swap (state->model, &this_iter, &iter);
cb_sort_selection_changed (state);
}
static void _preferences_on_bottom_down(gpointer data)
{
Panel * panel = data;
GtkTreeModel * model;
GtkTreeIter iter;
GtkTreeIter iter2;
GtkTreeSelection * treesel;
treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(
panel->pr_bottom_view));
if(!gtk_tree_selection_get_selected(treesel, &model, &iter))
return;
iter2 = iter;
if(!gtk_tree_model_iter_next(model, &iter))
return;
gtk_list_store_swap(panel->pr_bottom_store, &iter, &iter2);
}
/* Called when Up button is clicked */
static void move_action_up(GtkButton *button, gpointer user_data)
{
GtkTreeIter sel_iter;
/* Check if selected */
if (gtk_tree_selection_get_selected(actions_selection, NULL, &sel_iter))
{
/* Create path to previous row */
GtkTreePath* tree_path = gtk_tree_model_get_path((GtkTreeModel*)actions_list, &sel_iter);
/* Check if previous row exists */
if (gtk_tree_path_prev(tree_path))
{
/* Swap rows */
GtkTreeIter prev_iter;
gtk_tree_model_get_iter((GtkTreeModel*)actions_list, &prev_iter, tree_path);
gtk_list_store_swap(actions_list, &sel_iter, &prev_iter);
}
gtk_tree_path_free(tree_path);
}
}
static void _preferences_on_bottom_up(gpointer data)
{
Panel * panel = data;
GtkTreeModel * model;
GtkTreeIter iter;
GtkTreeIter iter2;
GtkTreePath * path;
GtkTreeSelection * treesel;
treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(
panel->pr_bottom_view));
if(!gtk_tree_selection_get_selected(treesel, &model, &iter))
return;
path = gtk_tree_model_get_path(model, &iter);
gtk_tree_path_prev(path);
gtk_tree_model_get_iter(model, &iter2, path);
gtk_tree_path_free(path);
gtk_list_store_swap(panel->pr_bottom_store, &iter, &iter2);
}
int
clip_GTK_LISTSTORESWAP(ClipMachine * cm)
{
C_object *cslist = _fetch_co_arg(cm);
C_object *citer1 = _fetch_cobject(cm, _clip_spar(cm, 2));
C_object *citer2 = _fetch_cobject(cm, _clip_spar(cm, 3));
CHECKARG2(1, MAP_t, NUMERIC_t); CHECKCOBJ(cslist, GTK_IS_LIST_STORE(cslist->object));
CHECKCOBJ(citer1, GTK_IS_TREE_ITER(citer1->object));
CHECKCOBJ(citer2, GTK_IS_TREE_ITER(citer2->object));
gtk_list_store_swap(GTK_LIST_STORE(cslist->object),
GTK_TREE_ITER(citer1->object),
GTK_TREE_ITER(citer2->object));
return 0;
err:
return 1;
}
static void prefs_custom_header_down(void)
{
GtkListStore *store = NULL;
GtkTreeModel *model = NULL;
GtkTreeIter next, sel;
if (!gtk_tree_selection_get_selected
(gtk_tree_view_get_selection
(GTK_TREE_VIEW(customhdr.list_view)),
&model,
&sel))
return;
store = (GtkListStore *)model;
next = sel;
if (!gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &next))
return;
gtk_list_store_swap(store, &next, &sel);
prefs_custom_header_set_list(cur_ac);
}
static gboolean
editlist_keypress (GtkWidget *wid, GdkEventKey *evt, gpointer userdata)
{
GtkTreeView *view = g_object_get_data (G_OBJECT (editlist_win), "view");
GtkTreeModel *store;
GtkTreeIter iter1, iter2;
GtkTreeSelection *sel;
GtkTreePath *path;
gboolean handled = FALSE;
int delta;
if (evt->state & GDK_SHIFT_MASK)
{
if (evt->keyval == GDK_KEY_Up)
{
handled = TRUE;
delta = -1;
}
else if (evt->keyval == GDK_KEY_Down)
{
handled = TRUE;
delta = 1;
}
}
if (handled)
{
sel = gtk_tree_view_get_selection (view);
gtk_tree_selection_get_selected (sel, &store, &iter1);
path = gtk_tree_model_get_path (store, &iter1);
if (delta == 1)
gtk_tree_path_next (path);
else
gtk_tree_path_prev (path);
gtk_tree_model_get_iter (store, &iter2, path);
gtk_tree_path_free (path);
gtk_list_store_swap (GTK_LIST_STORE (store), &iter1, &iter2);
}
return handled;
}
static void
cb_item_move (SheetManager *state, gnm_iter_search_t iter_search)
{
GtkTreeSelection *selection = gtk_tree_view_get_selection (state->sheet_list);
GtkTreeIter a, b;
GList *selected_rows;
g_return_if_fail (selection != NULL);
g_return_if_fail (gtk_tree_selection_count_selected_rows (selection) == 1);
selected_rows = gtk_tree_selection_get_selected_rows (selection, NULL);
gtk_tree_model_get_iter (GTK_TREE_MODEL (state->model),
&a, (GtkTreePath *) selected_rows->data);
g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free);
b = a;
if (!iter_search (GTK_TREE_MODEL (state->model), &b))
return;
gtk_list_store_swap (state->model, &a, &b);
cb_selection_changed (NULL, state);
}
static void
irc_network_dialog_button_up_clicked_cb (GtkWidget *widget,
EmpathyIrcNetworkDialog *dialog)
{
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter, iter_prev;
GtkTreePath *path;
gint *pos;
EmpathyIrcServer *server;
selection = gtk_tree_view_get_selection (
GTK_TREE_VIEW (dialog->treeview_servers));
if (!gtk_tree_selection_get_selected (selection, &model, &iter))
return;
path = gtk_tree_model_get_path (model, &iter);
if (!gtk_tree_path_prev (path))
{
gtk_tree_path_free (path);
return;
}
gtk_tree_model_get (model, &iter, COL_SRV_OBJ, &server, -1);
gtk_tree_model_get_iter (model, &iter_prev, path);
gtk_list_store_swap (GTK_LIST_STORE (model), &iter_prev, &iter);
pos = gtk_tree_path_get_indices (path);
empathy_irc_network_set_server_position (dialog->network, server, *pos);
irc_network_dialog_network_update_buttons (dialog);
g_object_unref (server);
gtk_tree_path_free (path);
}
static void
move_down_selected_layout (GtkWidget * button, GtkBuilder * dialog)
{
GtkTreeModel *model;
GtkTreeIter iter, next;
GtkTreePath *path;
if (get_selected_iter (dialog, &model, &iter) == FALSE)
return;
next = iter;
if (!gtk_tree_model_iter_next (model, &next))
return;
path = gtk_tree_model_get_path (model, &next);
gtk_list_store_swap (GTK_LIST_STORE (model), &iter, &next);
update_layouts_list (model, dialog);
set_selected_path (dialog, path);
gtk_tree_path_free (path);
}
void
DictMngr::CreateReorderDialog()
{
GtkWidget *dialog, *selector;
GtkCellRenderer *renderer;
HildonTouchSelectorColumn *column;
GtkTreeModel *tree_model;
GtkTreeIter iter, iter2;
GtkTreePath *path;
gboolean iter_valid = TRUE;
std::list < std::string > selected_dict_list;
GtkListStore *dict_list = NULL;
const gint RESPONSE_FIRST = 1;
const gint RESPONSE_UP = 2;
const gint RESPONSE_DOWN = 3;
const gint RESPONSE_LAST = 4;
gint response;
dict_list = gtk_list_store_new(N_DICT_INFO_COLUMNS,
G_TYPE_STRING, /* bookname */
G_TYPE_STRING); /* filename */
/* create dialog */
dialog = gtk_dialog_new();
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_title(GTK_WINDOW(dialog), _("Reorder"));
gtk_dialog_add_button(GTK_DIALOG(dialog), _("First"), RESPONSE_FIRST);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("Up"), RESPONSE_UP);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("Down"), RESPONSE_DOWN);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("Last"), RESPONSE_LAST);
gtk_dialog_add_button(GTK_DIALOG(dialog), "OK", GTK_RESPONSE_ACCEPT);
gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 400);
/* dictionary selector */
selector = hildon_touch_selector_new();
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), selector);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer),
"xpad", 10,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
column =
hildon_touch_selector_append_column(HILDON_TOUCH_SELECTOR
(selector),
GTK_TREE_MODEL(dict_list),
renderer, "text", BOOKNAME_DICT_INFO_COLUMN, NULL);
hildon_touch_selector_column_set_text_column(column, 0);
/* fill list with selected dictionaries */
oStarDict->oConf->GetStringList("/apps/maemo/mstardict/dict_list", selected_dict_list);
for (std::list < std::string >::iterator i = selected_dict_list.begin();
i != selected_dict_list.end(); ++i) {
DictInfo dictinfo;
dictinfo.load_from_ifo_file(i->c_str(), 0);
gtk_list_store_append(dict_list, &iter);
gtk_list_store_set(dict_list, &iter,
BOOKNAME_DICT_INFO_COLUMN,
dictinfo.bookname.c_str(), FILENAME_DICT_INFO_COLUMN, i->c_str(), -1);
}
g_object_unref(dict_list);
/* show dialog */
gtk_widget_show_all(GTK_WIDGET(dialog));
/* run the dialog */
while (TRUE) {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch(response) {
case RESPONSE_FIRST:
tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) {
gtk_list_store_move_after(GTK_LIST_STORE(tree_model), &iter, NULL);
hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector));
}
break;
case RESPONSE_UP:
tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) {
path = gtk_tree_model_get_path(tree_model, &iter);
gtk_tree_path_prev(path);
if (gtk_tree_model_get_iter(tree_model, &iter2, path)) {
gtk_list_store_swap(GTK_LIST_STORE(tree_model), &iter, &iter2);
}
gtk_tree_path_free(path);
hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector));
}
break;
case RESPONSE_DOWN:
tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) {
path = gtk_tree_model_get_path(tree_model, &iter);
gtk_tree_path_next(path);
if (gtk_tree_model_get_iter(tree_model, &iter2, path)) {
gtk_list_store_swap(GTK_LIST_STORE(tree_model), &iter, &iter2);
}
gtk_tree_path_free(path);
hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector));
}
break;
case RESPONSE_LAST:
tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
if (hildon_touch_selector_get_selected(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN, &iter)) {
gtk_list_store_move_before(GTK_LIST_STORE(tree_model), &iter, NULL);
hildon_touch_selector_center_on_selected(HILDON_TOUCH_SELECTOR(selector));
}
break;
case GTK_RESPONSE_ACCEPT:
tree_model = hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
iter_valid = gtk_tree_model_get_iter_first(tree_model, &iter);
selected_dict_list.clear();
while (iter_valid) {
const gchar *filename;
gtk_tree_model_get(GTK_TREE_MODEL(tree_model), &iter,
FILENAME_DICT_INFO_COLUMN, &filename, -1);
selected_dict_list.push_back(std::string(filename));
iter_valid = gtk_tree_model_iter_next(tree_model, &iter);
}
if (oStarDict->oConf->SetStringList("/apps/maemo/mstardict/dict_list", selected_dict_list)) {
/* reload dictionaries */
ReLoadDictionaries(selected_dict_list);
}
gtk_widget_destroy(GTK_WIDGET(dialog));
return;
default:
gtk_widget_destroy(GTK_WIDGET(dialog));
return;
}
}
}
static VALUE
rg_swap(VALUE self, VALUE iter1, VALUE iter2)
{
gtk_list_store_swap(_SELF(self), RVAL2GTKTREEITER(iter1), RVAL2GTKTREEITER(iter2));
return self;
}