git.maemo.org Git - mstardict/blob - src/dictmngr.cpp

   1 /*
   2  *  MStarDict - International dictionary for Maemo.
   3  *  Copyright (C) 2010 Roman Moravcik
   4  *
   5  *  base on code of stardict:
   6  *  Copyright (C) 2003-2007 Hu Zheng <huzheng_001@163.com>
   7  *
   8  *  based on code of sdcv:
   9  *  Copyright (C) 2005-2006 Evgeniy <dushistov@mail.ru>
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #  include "config.h"
  28 #endif
  29
  30 #include <cerrno>
  31 #include <cstring>
  32 #include <cstdlib>
  33 #include <cstdio>
  34 #include <clocale>
  35
  36 #include <glib.h>
  37 #include <glib/gi18n.h>
  38 #include <glib/gstdio.h>
  39
  40 #include <gtk/gtk.h>
  41 #include <hildon/hildon.h>
  42
  43 #include <getopt.h>
  44 #include <string>
  45 #include <vector>
  46 #include <memory>
  47 #include <list>
  48
  49 #include "conf.hpp"
  50 #include "libwrapper.hpp"
  51 #include "mstardict.hpp"
  52 #include "dictmngr.hpp"
  53
  54 enum {
  55     BOOKNAME_DICT_INFO_COLUMN,
  56     FILENAME_DICT_INFO_COLUMN,
  57     N_DICT_INFO_COLUMNS
  58 };
  59
  60 class GetAllDictList {
  61   public:
  62     GetAllDictList(std::list < std::string > &dict_all_list_):dict_all_list(dict_all_list_) {
  63     } void operator() (const std::string & url, bool disable) {
  64         dict_all_list.push_back(url);
  65     }
  66   private:
  67     std::list < std::string > &dict_all_list;
  68 };
  69
  70 DictMngr::DictMngr(MStarDict *mStarDict)
  71 {
  72     oStarDict = mStarDict;
  73 }
  74
  75 DictMngr::~DictMngr()
  76 {
  77 }
  78
  79 void
  80 DictMngr::CreateDictMngrDialog()
  81 {
  82     GtkWidget *dialog, *selector;
  83     GtkCellRenderer *renderer;
  84     HildonTouchSelectorColumn *column;
  85     GtkTreeModel *tree_model;
  86     GtkTreeIter iter;
  87     gboolean iter_valid = TRUE;
  88     std::list < std::string > all_dict_list;
  89     std::list < std::string > selected_dict_list;
  90     GtkListStore *dict_list = NULL;
  91
  92     dict_list = gtk_list_store_new(N_DICT_INFO_COLUMNS,
  93                                    G_TYPE_STRING,       /* bookname */
  94                                    G_TYPE_STRING);      /* filename */
  95
  96     /* create dialog */
  97     dialog = gtk_dialog_new();
  98     gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
  99     gtk_window_set_title(GTK_WINDOW(dialog), _("Dictionaries"));
 100     gtk_dialog_add_button(GTK_DIALOG(dialog), "OK", GTK_RESPONSE_ACCEPT);
 101     gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 400);
 102
 103     /* dictionary selector */
 104     selector = hildon_touch_selector_new();
 105     gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), selector);
 106
 107     renderer = gtk_cell_renderer_text_new();
 108     g_object_set(G_OBJECT(renderer),
 109                  "xpad", 10,
 110                  "ellipsize", PANGO_ELLIPSIZE_END,
 111                  "ellipsize-set", TRUE,
 112                  NULL);
 113
 114     column =
 115         hildon_touch_selector_append_column(HILDON_TOUCH_SELECTOR
 116                                             (selector),
 117                                             GTK_TREE_MODEL(dict_list),
 118                                             renderer, "text", BOOKNAME_DICT_INFO_COLUMN, NULL);
 119     hildon_touch_selector_column_set_text_column(column, 0);
 120
 121     /* fill list with all available dictionaries */
 122     GetAllDictionaryList(all_dict_list);
 123     for (std::list < std::string >::iterator i = all_dict_list.begin();
 124          i != all_dict_list.end(); ++i) {
 125         DictInfo dictinfo;
 126
 127         dictinfo.load_from_ifo_file(i->c_str(), 0);
 128         gtk_list_store_append(dict_list, &iter);
 129         gtk_list_store_set(dict_list, &iter,
 130                            BOOKNAME_DICT_INFO_COLUMN,
 131                            dictinfo.bookname.c_str(), FILENAME_DICT_INFO_COLUMN, i->c_str(), -1);
 132     }
 133     g_object_unref(dict_list);
 134
 135     /* set selector mode to multiple */
 136     hildon_touch_selector_set_column_selection_mode(HILDON_TOUCH_SELECTOR
 137                                                     (selector),
 138                                                     HILDON_TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE);
 139     hildon_touch_selector_unselect_all(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
 140
 141     /* select all load dictionaries */
 142     tree_model =
 143         hildon_touch_selector_get_model(HILDON_TOUCH_SELECTOR(selector), BOOKNAME_DICT_INFO_COLUMN);
 144     for (iter_valid = gtk_tree_model_get_iter_first(tree_model, &iter);
 145          iter_valid; iter_valid = gtk_tree_model_iter_next(tree_model, &iter)) {
 146         const gchar *bookname;
 147
 148         gtk_tree_model_get(tree_model, &iter, BOOKNAME_DICT_INFO_COLUMN, &bookname, -1);
 149         for (size_t iLib = 0; iLib < oStarDict->oLibs->query_dictmask.size(); iLib++) {
 150             if (!strcmp(oStarDict->oLibs->dict_name(iLib).c_str(), bookname)) {
 151                 hildon_touch_selector_select_iter(HILDON_TOUCH_SELECTOR
 152                                                   (selector),
 153                                                   BOOKNAME_DICT_INFO_COLUMN, &iter, FALSE);
 154                 break;
 155             }
 156         }
 157     }
 158
 159     /* show dialog */
 160     gtk_widget_show_all(GTK_WIDGET(dialog));
 161
 162     /* run the dialog */
 163     if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
 164         GList *selected_dicts = NULL;
 165
 166         selected_dicts =
 167             hildon_touch_selector_get_selected_rows(HILDON_TOUCH_SELECTOR
 168                                                     (selector), BOOKNAME_DICT_INFO_COLUMN);
 169         if (selected_dicts) {
 170             GList *dict = selected_dicts;
 171             const gchar *filename;
 172
 173             while (dict) {
 174                 gtk_tree_model_get_iter(GTK_TREE_MODEL(tree_model), &iter,
 175                                         (GtkTreePath *) (dict->data));
 176                 gtk_tree_model_get(GTK_TREE_MODEL(tree_model), &iter,
 177                                    FILENAME_DICT_INFO_COLUMN, &filename, -1);
 178                 selected_dict_list.push_back(std::string(filename));
 179                 dict = dict->next;
 180             }
 181             g_list_foreach(selected_dicts, (GFunc) gtk_tree_path_free, NULL);
 182             g_list_free(selected_dicts);
 183         }
 184
 185         if (oStarDict->oConf->SetStringList("/apps/maemo/mstardict/dict_list", selected_dict_list)) {
 186             /* reload dictionaries */
 187             ReLoadDictionaries(selected_dict_list);
 188
 189 //          /* trigger re-search */
 190 //          oStarDict->onSearchEntryChanged(GTK_EDITABLE(oStarDict->search), oStarDict);
 191         }
 192     }
 193     gtk_widget_destroy(GTK_WIDGET(dialog));
 194 }
 195
 196 void
 197 DictMngr::GetAllDictionaryList(std::list < std::string > &dict_list)
 198 {
 199     strlist_t dicts_dir_list;
 200     strlist_t order_list;
 201     strlist_t disable_list;
 202
 203     /* dictionary directory */
 204     dicts_dir_list.push_back(std::string("/home/user/MyDocs/mstardict"));
 205     for_each_file(dicts_dir_list, ".ifo", order_list, disable_list, GetAllDictList(dict_list));
 206 }
 207
 208 void
 209 DictMngr::LoadDictionaries()
 210 {
 211     std::list < std::string > dict_list;
 212
 213     if (!oStarDict->oConf->GetStringList("/apps/maemo/mstardict/dict_list", dict_list)) {
 214         GetAllDictionaryList(dict_list);
 215         oStarDict->oConf->SetStringList("/apps/maemo/mstardict/dict_list", dict_list);
 216     }
 217
 218     oStarDict->oLibs->load(dict_list);
 219     oStarDict->oLibs->query_dictmask.clear();
 220     for (std::list < std::string >::iterator i = dict_list.begin(); i != dict_list.end(); ++i) {
 221         size_t iLib;
 222         if (oStarDict->oLibs->find_lib_by_filename(i->c_str(), iLib)) {
 223             InstantDictIndex instance_dict_index;
 224             instance_dict_index.type = InstantDictType_LOCAL;
 225             instance_dict_index.index = iLib;
 226             oStarDict->oLibs->query_dictmask.push_back(instance_dict_index);
 227         }
 228     }
 229
 230     if (oStarDict->oLibs->iCurrentIndex)
 231         g_free(oStarDict->oLibs->iCurrentIndex);
 232     oStarDict->oLibs->iCurrentIndex =
 233         (CurrentIndex *) g_malloc(sizeof(CurrentIndex) * oStarDict->oLibs->query_dictmask.size());
 234
 235     if (oStarDict->oLibs->query_dictmask.empty())
 236         oStarDict->ShowNoDictionary(true);
 237 }
 238
 239 void
 240 DictMngr::ReLoadDictionaries(std::list < std::string > &dict_list)
 241 {
 242     oStarDict->oLibs->reload(dict_list, 0, 0);
 243     oStarDict->oLibs->query_dictmask.clear();
 244     for (std::list < std::string >::iterator i = dict_list.begin(); i != dict_list.end(); ++i) {
 245         size_t iLib;
 246         if (oStarDict->oLibs->find_lib_by_filename(i->c_str(), iLib)) {
 247             InstantDictIndex instance_dict_index;
 248             instance_dict_index.type = InstantDictType_LOCAL;
 249             instance_dict_index.index = iLib;
 250             oStarDict->oLibs->query_dictmask.push_back(instance_dict_index);
 251         }
 252     }
 253
 254     if (oStarDict->oLibs->iCurrentIndex)
 255         g_free(oStarDict->oLibs->iCurrentIndex);
 256     oStarDict->oLibs->iCurrentIndex =
 257         (CurrentIndex *) g_malloc(sizeof(CurrentIndex) * oStarDict->oLibs->query_dictmask.size());
 258
 259     if (oStarDict->oLibs->query_dictmask.empty())
 260         oStarDict->ShowNoDictionary(true);
 261 }