/* FIXME: This is actually a very ugly way to retrieve the text. Ideally,
we would have API to retrieve it from the base clase (HildonTouchSelector).
In the meantime, leaving it here.
*/
static gchar *
hildon_touch_selector_entry_get_text_from_model (HildonTouchSelectorEntry * selector)
{
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
GList *selected_rows;
gchar *text;
gint text_column = -1;
model = hildon_touch_selector_get_model (HILDON_TOUCH_SELECTOR (selector), 0);
text_column = hildon_touch_selector_entry_get_text_column (selector);
selected_rows = hildon_touch_selector_get_selected_rows (HILDON_TOUCH_SELECTOR (selector), 0);
if (text_column == -1 || selected_rows == NULL) {
return NULL;
}
/* We are in single selection mode */
g_assert (selected_rows->next == NULL);
path = (GtkTreePath *)selected_rows->data;
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, text_column, &text, -1);
gtk_tree_path_free (path);
g_list_free (selected_rows);
return text;
}
static void
aw_captcha_dialog_init (AwCaptchaDialog *dialog)
{
GtkWidget *table, *widget, *content;
GtkTreeModel *model;
dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog, AW_TYPE_CAPTCHA_DIALOG,
AwCaptchaDialogPrivate);
content = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_dialog_add_button (GTK_DIALOG (dialog), _("Submit"), GTK_RESPONSE_OK);
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), HILDON_MARGIN_DOUBLE);
gtk_container_add (GTK_CONTAINER (content), table);
widget = gtk_image_new ();
gtk_widget_set_size_request (widget, AW_CAPTCHA_WIDTH, AW_CAPTCHA_HEIGHT);
gtk_table_attach (GTK_TABLE (table), widget, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
dialog->priv->challenge = widget;
widget = hildon_entry_new (HILDON_SIZE_AUTO_WIDTH | HILDON_SIZE_FINGER_HEIGHT);
gtk_entry_set_overwrite_mode (GTK_ENTRY (widget), TRUE);
gtk_entry_set_max_length (GTK_ENTRY (widget), 5);
gtk_table_attach (GTK_TABLE (table), widget, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, 0, 0, 0);
dialog->priv->response = widget;
g_signal_connect_swapped (widget, "changed",
G_CALLBACK (aw_captcha_dialog_entry_changed_cb),
dialog);
widget = hildon_touch_selector_new_text ();
gtk_widget_set_size_request (widget, -1, 4 * 70);
gtk_table_attach_defaults (GTK_TABLE (table), widget, 0, 2, 1, 2);
dialog->priv->selector = widget;
model = aw_captcha_dialog_create_model ();
hildon_touch_selector_append_text_column
(HILDON_TOUCH_SELECTOR (widget), model, TRUE);
hildon_touch_selector_append_text_column
(HILDON_TOUCH_SELECTOR (widget), model, TRUE);
hildon_touch_selector_append_text_column
(HILDON_TOUCH_SELECTOR (widget), model, TRUE);
hildon_touch_selector_append_text_column
(HILDON_TOUCH_SELECTOR (widget), model, TRUE);
hildon_touch_selector_append_text_column
(HILDON_TOUCH_SELECTOR (widget), model, TRUE);
g_signal_connect_swapped
(widget, "changed",
G_CALLBACK (aw_captcha_dialog_selector_changed_cb), dialog);
g_object_unref (model);
gtk_widget_show_all (table);
}
/**
* hildon_touch_selector_entry_new_text:
*
* Creates a #HildonTouchSelectorEntry with a single text column that
* can be populated conveniently through hildon_touch_selector_append_text(),
* hildon_touch_selector_prepend_text(), hildon_touch_selector_insert_text().
*
* Returns: A new #HildonTouchSelectorEntry
*
* Since: 2.2
**/
GtkWidget *
hildon_touch_selector_entry_new_text (void)
{
GtkListStore *model;
GtkWidget *selector;
GtkEntryCompletion *completion;
HildonTouchSelectorEntryPrivate *priv;
HildonTouchSelectorColumn *column = NULL;
selector = hildon_touch_selector_entry_new ();
priv = HILDON_TOUCH_SELECTOR_ENTRY_GET_PRIVATE (selector);
model = gtk_list_store_new (1, G_TYPE_STRING);
completion = gtk_entry_get_completion (GTK_ENTRY (priv->entry));
gtk_entry_completion_set_model (completion, GTK_TREE_MODEL (model));
column = hildon_touch_selector_append_text_column (HILDON_TOUCH_SELECTOR (selector),
GTK_TREE_MODEL (model), FALSE);
g_object_unref (model);
g_signal_connect (column, "notify::text-column", G_CALLBACK (_text_column_modified),
selector);
hildon_touch_selector_entry_set_text_column (HILDON_TOUCH_SELECTOR_ENTRY (selector), 0);
return selector;
}
static void
aw_captcha_dialog_selector_changed_cb (AwCaptchaDialog *dialog)
{
HildonTouchSelector *selector;
GtkTreeModel *model;
GtkTreeIter iter;
GString *text;
char *number;
int i;
if (dialog->priv->changing)
return;
selector = HILDON_TOUCH_SELECTOR (dialog->priv->selector);
model = hildon_touch_selector_get_model (selector, 1);
text = g_string_new (NULL);
dialog->priv->changing = TRUE;
for (i = 1; i <= 5; ++i)
{
if (hildon_touch_selector_get_selected (selector, i, &iter))
{
gtk_tree_model_get (model, &iter, 0, &number, -1);
g_string_append (text, number);
g_free (number);
}
else
g_string_append (text, "0");
}
aw_captcha_dialog_set_response (dialog, text->str);
dialog->priv->changing = FALSE;
g_string_free (text, TRUE);
}
/**
* hildon_touch_selector_entry_set_text_column:
* @selector: A #HildonTouchSelectorEntry
* @text_column: A column in model to get the strings from
*
* Sets the model column which touch selector box should use to get strings
* from to be @text_column.
*
* Since: 2.2
**/
void
hildon_touch_selector_entry_set_text_column (HildonTouchSelectorEntry *selector,
gint text_column)
{
HildonTouchSelectorColumn *column = NULL;
g_return_if_fail (HILDON_IS_TOUCH_SELECTOR_ENTRY (selector));
g_return_if_fail (text_column >= -1);
column = hildon_touch_selector_get_column (HILDON_TOUCH_SELECTOR (selector), 0);
hildon_touch_selector_column_set_text_column (column, text_column);
}
/**
* hildon_touch_selector_entry_get_text_column:
* @selector: A #HildonTouchSelectorEntry
*
* Gets the text column that @selector is using as a text column.
*
* Returns: the number of the column used as a text column.
*
* Since: 2.2
**/
gint
hildon_touch_selector_entry_get_text_column (HildonTouchSelectorEntry *selector)
{
HildonTouchSelectorColumn *column = NULL;
gint text_column = -1;
g_return_val_if_fail (HILDON_IS_TOUCH_SELECTOR_ENTRY (selector), -1);
column = hildon_touch_selector_get_column (HILDON_TOUCH_SELECTOR (selector),
0);
text_column = hildon_touch_selector_column_get_text_column (column);
return text_column;
}
void motorway_list_handler(GHashTable *table, int *res, gpointer *data)
{
if (*res != NO_ASYNC)
gdk_threads_enter();
GtkWidget *window = GTK_WIDGET( hildon_window_new() );
gtk_signal_connect(GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC (wizard_delete_event), NULL);
gtk_window_set_title(GTK_WINDOW(window), "Pick a motorway");
if (table == NULL)
{
moflow_error_dialog(*res, NULL, GTK_BUTTONS_OK);
main_exit(1);
}
GtkWidget *hbox = gtk_hbox_new(FALSE, 2);
GtkWidget *vbox = gtk_vbox_new(FALSE, 2);
GtkWidget *selector = hildon_touch_selector_new_text();
GList *sortedList = g_list_sort(g_hash_table_get_keys(table), (GCompareFunc)motorwaycmp);
for (GList *li = sortedList; li != NULL; li = g_list_next(li))
{
gchar *key = (gchar*)li->data;
hildon_touch_selector_append_text(HILDON_TOUCH_SELECTOR(selector), key);
}
g_list_free(sortedList);
gtk_box_pack_start(GTK_BOX(vbox), selector, TRUE, TRUE, 2);
GtkWidget *button = hildon_button_new_with_text(HILDON_SIZE_AUTO_WIDTH, HILDON_BUTTON_ARRANGEMENT_VERTICAL, "Go!", NULL);
gtk_widget_set_sensitive(button, FALSE);
g_signal_connect(G_OBJECT(selector), "changed", G_CALLBACK(selection_changed), button);
g_object_set_data(G_OBJECT(button), "motorwayTable", table);
g_object_set_data(G_OBJECT(button), "motorwaySelector", selector);
gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(motorway_select_cb), NULL);
gtk_widget_set_size_request(button, -1, 70);
gtk_box_pack_end(GTK_BOX(vbox), button, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 2);
GtkWidget *logo = gtk_image_new_from_file("/usr/share/pixmaps/moflow/motorway.png");
gtk_box_pack_end(GTK_BOX(hbox), logo, FALSE, FALSE, 20);
gtk_container_add(GTK_CONTAINER(window), hbox);
gtk_widget_show_all(window);
if (*res != NO_ASYNC)
gdk_threads_leave();
}
void motorway_select_cb(GtkWidget *w, gpointer *data)
{
GHashTable *table = (GHashTable*)g_object_get_data(G_OBJECT(w), "motorwayTable");
HildonTouchSelector *selector = HILDON_TOUCH_SELECTOR(g_object_get_data(G_OBJECT(w), "motorwaySelector"));
gchar *selectionText = hildon_touch_selector_get_current_text(selector);
int *selectionId = g_hash_table_lookup(table, (gpointer*)selectionText);
struct prefs_found_args *args = g_new(struct prefs_found_args, 1);
moflow_request *req = moflow_init_request();
req->motorway_id = *selectionId;
moflow_req_generate_url(req);
args->table = table;
args->request = req;
moflow_get_async(client, req, prefs_found, (gpointer*)args);
GtkWidget *window = gtk_widget_get_toplevel(w);
gtk_widget_destroy(window);
}
static GtkWidget*
integer_selector_new ( guint min, guint max )
{
GtkWidget *button;
HildonTouchSelector *selector;
guint i;
gchar label[3];
button =hildon_picker_button_new ( HILDON_SIZE_FINGER_HEIGHT,
HILDON_BUTTON_ARRANGEMENT_HORIZONTAL);
selector = HILDON_TOUCH_SELECTOR ( hildon_touch_selector_new_text () );
for ( i=min; i<=max; ++i ){
g_snprintf ( label , 3 , "%d", i );
hildon_touch_selector_append_text ( selector, label );
}
hildon_picker_button_set_selector ( HILDON_PICKER_BUTTON(button), selector );
return button;
}
static void
hildon_touch_selector_entry_init (HildonTouchSelectorEntry *self)
{
HildonTouchSelectorEntryPrivate *priv;
GtkEntryCompletion *completion;
HildonGtkInputMode input_mode;
priv = HILDON_TOUCH_SELECTOR_ENTRY_GET_PRIVATE (self);
priv->converter = g_iconv_open ("ascii//translit", "utf-8");
priv->entry = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT);
gtk_entry_set_activates_default (GTK_ENTRY (priv->entry), TRUE);
input_mode = hildon_gtk_entry_get_input_mode (GTK_ENTRY (priv->entry));
/* Disable unsupported input modes. */
input_mode &= ~HILDON_GTK_INPUT_MODE_MULTILINE;
input_mode &= ~HILDON_GTK_INPUT_MODE_INVISIBLE;
input_mode &= ~HILDON_GTK_INPUT_MODE_DICTIONARY;
hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry), input_mode);
completion = gtk_entry_completion_new ();
gtk_entry_completion_set_inline_completion (completion, TRUE);
gtk_entry_completion_set_popup_completion (completion, FALSE);
gtk_entry_set_completion (GTK_ENTRY (priv->entry), completion);
g_object_unref (completion);
gtk_widget_show (priv->entry);
g_signal_connect (G_OBJECT (priv->entry), "changed",
G_CALLBACK (entry_on_text_changed), self);
priv->signal_id = g_signal_connect (G_OBJECT (self), "changed",
G_CALLBACK (hildon_touch_selector_entry_changed), NULL);
hildon_touch_selector_set_print_func (HILDON_TOUCH_SELECTOR (self), hildon_touch_selector_entry_print_func);
gtk_box_pack_start (GTK_BOX (self), priv->entry, FALSE, FALSE, 0);
}
static void
aw_captcha_dialog_entry_changed_cb (AwCaptchaDialog *dialog)
{
HildonTouchSelector *selector;
GtkTreeModel *model;
GtkTreeIter iter;
const char *text;
int i;
if (dialog->priv->changing)
return;
selector = HILDON_TOUCH_SELECTOR (dialog->priv->selector);
model = hildon_touch_selector_get_model (selector, 1);
dialog->priv->changing = TRUE;
text = aw_captcha_dialog_get_response (dialog);
for (i = 1; i <= 5 && *text; ++i, ++text)
{
int value;
if (*text >= '0' && *text <= '9')
value = *text - '0';
else if (*text >= 'A' && *text <= 'F')
value = *text - 'A' + 10;
else if (*text >= 'a' && *text <= 'f')
value = *text - 'a' + 10;
else
value = -1;
if (value >= 0 && gtk_tree_model_iter_nth_child (model, &iter, NULL, value))
hildon_touch_selector_select_iter (selector, i, &iter, TRUE);
}
dialog->priv->changing = FALSE;
}
static void
entry_on_text_changed (GtkEditable * editable,
gpointer userdata)
{
HildonTouchSelector *selector;
HildonTouchSelectorEntryPrivate *priv;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeIter iter_suggested;
GtkEntry *entry;
const gchar *prefix;
gchar *text;
gboolean found = FALSE;
gint text_column = -1;
gchar *ascii_prefix;
gint prefix_len;
gboolean found_suggestion = FALSE;
entry = GTK_ENTRY (editable);
selector = HILDON_TOUCH_SELECTOR (userdata);
priv = HILDON_TOUCH_SELECTOR_ENTRY_GET_PRIVATE (selector);
text_column =
hildon_touch_selector_entry_get_text_column (HILDON_TOUCH_SELECTOR_ENTRY (selector));
prefix = gtk_entry_get_text (entry);
if (prefix[0] == '\0') {
return;
}
model = hildon_touch_selector_get_model (selector, 0);
if (!gtk_tree_model_get_iter_first (model, &iter)) {
return;
}
if (priv->smart_match) {
ascii_prefix = g_convert_with_iconv (prefix, -1, priv->converter, NULL, NULL, NULL);
prefix_len = strlen (ascii_prefix);
}
do {
gtk_tree_model_get (model, &iter, text_column, &text, -1);
found = g_str_has_prefix (text, prefix);
if (!found && !found_suggestion && priv->smart_match) {
gchar *ascii_text = g_convert_with_iconv (text, -1, priv->converter, NULL, NULL, NULL);
found_suggestion = !g_ascii_strncasecmp (ascii_text, ascii_prefix, prefix_len);
if (found_suggestion) {
iter_suggested = iter;
}
g_free (ascii_text);
}
g_free (text);
} while (found != TRUE && gtk_tree_model_iter_next (model, &iter));
g_signal_handler_block (selector, priv->signal_id);
{
/* We emit the HildonTouchSelector::changed signal because a change in the
GtkEntry represents a change in current selection, and therefore, users
should be notified. */
if (found) {
hildon_touch_selector_select_iter (selector, 0, &iter, TRUE);
} else if (found_suggestion) {
hildon_touch_selector_select_iter (selector, 0, &iter_suggested, TRUE);
}
g_signal_emit_by_name (selector, "changed", 0);
}
g_signal_handler_unblock (selector, priv->signal_id);
if (priv->smart_match) {
g_free (ascii_prefix);
}
}
/* Shows a dialog asking user to select a preset. If allow_new is TRUE, then
* user can specify a new preset. In this case, allow_new will become TRUE if
* user selects a new preset, or FALSE if she is selecting an already
* existent */
static xmlDoc *dialog_choose_preset(gpointer parent, gboolean *allow_new)
{
GList *presets;
GList *node;
GtkWidget *selector;
GtkWidget *dialog;
xmlDoc *preset;
xmlDoc *preset_selected = NULL;
gchar *preset_name_selected;
gint response;
presets = presets_preload_all();
if (!presets && !allow_new) {
hildon_banner_show_information(GTK_WIDGET(parent),
NULL,
"No available presets");
return NULL;
}
/* Check if user can specify a new preset */
if (allow_new && *allow_new) {
selector = hildon_touch_selector_entry_new_text();
} else {
selector = hildon_touch_selector_new_text();
}
node = presets;
while (node) {
preset = (xmlDoc *) node->data;
hildon_touch_selector_append_text(
HILDON_TOUCH_SELECTOR(selector),
preset->name);
node = g_list_next(node);
}
dialog = hildon_picker_dialog_new(parent);
hildon_picker_dialog_set_selector(HILDON_PICKER_DIALOG(dialog),
HILDON_TOUCH_SELECTOR(selector));
response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response != GTK_RESPONSE_DELETE_EVENT) {
preset_name_selected =
hildon_touch_selector_get_current_text(
HILDON_TOUCH_SELECTOR(selector));
} else {
preset_name_selected = NULL;
}
/* NOTE: There is a bug in hildon that prevent using gtk_widget_destroy
when a hildon_touch_selector_entry is usedcd, as it segs fault.
The bad part is that using hide_all makes a leak. */
if (allow_new && *allow_new) {
gtk_widget_hide_all(dialog);
} else {
gtk_widget_destroy(dialog);
}
/* Check the selected xmlDoc, freeing remaining */
node = presets;
while (node) {
preset = (xmlDoc *) node->data;
if (preset_name_selected &&
g_utf8_collate(preset->name, preset_name_selected) == 0) {
preset_selected = preset;
} else {
xmlFreeDoc(preset);
}
node = g_list_next(node);
}
g_list_free(presets);
if (preset_name_selected) {
/* User asks for new presets */
if (allow_new && *allow_new) {
if (preset_selected) {
*allow_new = FALSE;
g_free(preset_name_selected);
} else {
preset_selected = xmlNewDoc(BAD_CAST "1.0");
preset_selected->name = preset_name_selected;
*allow_new = TRUE;
}
} else {
g_free(preset_name_selected);
}
}
return preset_selected;
}
void
DictMngr::CreateDictMngrDialog()
{
GtkWidget *dialog, *selector;
GtkCellRenderer *renderer;
HildonTouchSelectorColumn *column;
GtkTreeModel *tree_model;
GtkTreeIter iter;
gboolean iter_valid = TRUE;
std::list < std::string > all_dict_list;
std::list < std::string > selected_dict_list;
GtkListStore *dict_list = NULL;
const gint RESPONSE_REORDER = 1;
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), _("Dictionaries"));
gtk_dialog_add_button(GTK_DIALOG(dialog), _("Reorder"), RESPONSE_REORDER);
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 all available dictionaries */
GetAllDictionaryList(all_dict_list);
for (std::list < std::string >::iterator i = all_dict_list.begin();
i != all_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);
/* set selector mode to multiple */
hildon_touch_selector_set_column_selection_mode(HILDON_TOUCH_SELECTOR
(selector),
HILDON_TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE);
hildon_touch_selector_unselect_all(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
/* select all load dictionaries */
tree_model =
hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
for (iter_valid = gtk_tree_model_get_iter_first(tree_model, &iter);
iter_valid; iter_valid = gtk_tree_model_iter_next(tree_model, &iter)) {
const gchar *bookname;
gtk_tree_model_get(tree_model, &iter, BOOKNAME_DICT_INFO_COLUMN, &bookname, -1);
for (size_t iLib = 0; iLib < oStarDict->oLibs->query_dictmask.size(); iLib++) {
if (!strcmp(oStarDict->oLibs->dict_name(iLib).c_str(), bookname)) {
hildon_touch_selector_select_iter(HILDON_TOUCH_SELECTOR
(selector),
BOOKNAME_DICT_INFO_COLUMN, &iter, FALSE);
break;
}
}
}
/* show dialog */
gtk_widget_show_all(GTK_WIDGET(dialog));
/* run the dialog */
response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_ACCEPT || response == RESPONSE_REORDER) {
GList *selected_dicts = NULL;
selected_dicts =
hildon_touch_selector_get_selected_rows(HILDON_TOUCH_SELECTOR
(selector), BOOKNAME_DICT_INFO_COLUMN);
if (selected_dicts) {
GList *dict = selected_dicts;
const gchar *filename;
while (dict) {
gtk_tree_model_get_iter(GTK_TREE_MODEL(tree_model), &iter,
(GtkTreePath *) (dict->data));
gtk_tree_model_get(GTK_TREE_MODEL(tree_model), &iter,
FILENAME_DICT_INFO_COLUMN, &filename, -1);
selected_dict_list.push_back(std::string(filename));
dict = dict->next;
}
g_list_foreach(selected_dicts, (GFunc) gtk_tree_path_free, NULL);
g_list_free(selected_dicts);
}
if (oStarDict->oConf->SetStringList("/apps/maemo/mstardict/dict_list", selected_dict_list)) {
/* reload dictionaries */
ReLoadDictionaries(selected_dict_list);
}
}
gtk_widget_destroy(GTK_WIDGET(dialog));
if (response == RESPONSE_REORDER) {
CreateReorderDialog();
}
}
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;
}
}
}
