git.maemo.org Git - mstardict/blob - src/mstardict.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 "dictmngr.hpp"
  51 #include "libwrapper.hpp"
  52 #include "transwin.hpp"
  53 #include "mstardict.hpp"
  54
  55 MStarDict *pMStarDict;
  56
  57 enum {
  58     DEF_COLUMN,
  59     N_COLUMNS
  60 };
  61
  62 MStarDict::MStarDict()
  63 {
  64     window = NULL;
  65     label_widget = NULL;
  66     results_widget = NULL;
  67     results_view = NULL;
  68     results_view_scroll = NULL;
  69
  70     /* create list of ressults */
  71     results_list = gtk_list_store_new(N_COLUMNS,
  72                                       G_TYPE_STRING);   /* DEF_COLUMN */
  73
  74     /* initialize configuration */
  75     oConf = new Conf();
  76
  77     /* initialize stardict plugins */
  78     std::list < std::string > plugin_order_list;
  79     std::list < std::string > plugin_disable_list;
  80     oStarDictPlugins = new StarDictPlugins("/usr/lib/mstardict/plugins",
  81                                            plugin_order_list,
  82                                            plugin_disable_list);
  83
  84     /* initialize dict manager */
  85     oDict = new DictMngr(this);
  86
  87     /* initialize translation window */
  88     oTransWin = new TransWin(this);
  89
  90     /* initialize stardict library */
  91     oLibs = new Library(this);
  92 }
  93
  94 MStarDict::~MStarDict()
  95 {
  96     /* destroy list of results */
  97     g_object_unref(results_list);
  98
  99     /* deinitialize stardict library */
 100     delete oLibs;
 101
 102     /* deinitialize translation window */
 103     delete oTransWin;
 104
 105     /* deinitialize dict manager */
 106     delete oDict;
 107
 108     /* deinitialize stardict plugins */
 109     delete oStarDictPlugins;
 110
 111     /* deinitialize configuration */
 112     delete oConf;
 113 }
 114
 115 gboolean
 116 MStarDict::onResultsViewSelectionChanged(GtkTreeSelection *selection,
 117                                          MStarDict *mStarDict)
 118 {
 119     GtkTreeModel *model;
 120     GtkTreeIter iter;
 121     const gchar *sWord;
 122     bool bFound = false;
 123
 124     if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
 125         GList *results = NULL;
 126
 127         /* unselect selected rows */
 128         gtk_tree_selection_unselect_all(selection);
 129
 130         gtk_tree_model_get(model, &iter, DEF_COLUMN, &sWord, -1);
 131
 132         for (size_t iLib = 0; iLib < mStarDict->oLibs->query_dictmask.size(); iLib++) {
 133             bFound =
 134                 mStarDict->oLibs->BuildResultData(mStarDict->oLibs->query_dictmask, sWord,
 135                                                   mStarDict->oLibs->iCurrentIndex, iLib,
 136                                                   &results);
 137         }
 138
 139         /* create translation window */
 140         mStarDict->oTransWin->CreateTransWindow(results);
 141
 142         /* free result data */
 143         mStarDict->oLibs->FreeResultData(results);
 144     }
 145
 146     /* grab focus to search entry */
 147     mStarDict->GrabFocus();
 148
 149     return true;
 150 }
 151
 152 gboolean
 153 MStarDict::onSearchEntryChanged(GtkEditable* editable,
 154                                 MStarDict* mStarDict)
 155 {
 156     const gchar *sWord;
 157     bool bFound = false;
 158     std::string query;
 159
 160     if (mStarDict->oLibs->query_dictmask.empty())
 161         return true;
 162
 163     sWord = gtk_entry_get_text(GTK_ENTRY(editable));
 164     if (strcmp(sWord, "") == 0) {
 165         mStarDict->ShowNoResults(true);
 166     } else {
 167         mStarDict->ShowProgressIndicator(true);
 168         mStarDict->ResultsUnselectAll(GTK_SELECTION_NONE);
 169
 170         switch (analyse_query(sWord, query)) {
 171         case qtFUZZY:
 172             bFound = mStarDict->oLibs->LookupWithFuzzy(query.c_str());
 173             break;
 174
 175         case qtPATTERN:
 176             bFound = mStarDict->oLibs->LookupWithRule(query.c_str());
 177             break;
 178
 179         case qtREGEX:
 180             bFound = mStarDict->oLibs->LookupWithRegex(query.c_str());
 181             break;
 182
 183         case qtSIMPLE:
 184             bFound = mStarDict->oLibs->SimpleLookup(query.c_str(), mStarDict->oLibs->iCurrentIndex);
 185             if (!bFound) {
 186                 const gchar *sugWord = mStarDict->oLibs->GetSuggestWord(query.c_str(),
 187                                                                         mStarDict->
 188                                                                         oLibs->iCurrentIndex,
 189                                                                         mStarDict->
 190                                                                         oLibs->query_dictmask, 0);
 191                 if (sugWord) {
 192                     gchar *sSugWord = g_strdup(sugWord);
 193                     bFound =
 194                         mStarDict->oLibs->SimpleLookup(sSugWord, mStarDict->oLibs->iCurrentIndex);
 195                     g_free(sSugWord);
 196                 }
 197             }
 198             mStarDict->oLibs->ListWords(mStarDict->oLibs->iCurrentIndex);
 199             break;
 200
 201         default:
 202             break;
 203         }
 204
 205         if (bFound)
 206             mStarDict->ShowNoResults(false);
 207         else
 208             mStarDict->ShowNoResults(true);
 209
 210         mStarDict->ResultsUnselectAll(GTK_SELECTION_SINGLE);
 211         mStarDict->ShowProgressIndicator(false);
 212     }
 213
 214     return true;
 215 }
 216
 217 gboolean
 218 MStarDict::onDictionariesMenuItemClicked(GtkButton *button,
 219                                          MStarDict *mStarDict)
 220 {
 221     mStarDict->oDict->CreateDictMngrDialog();
 222
 223     /* trigger re-search */
 224     mStarDict->onSearchEntryChanged(GTK_EDITABLE(mStarDict->search), mStarDict);
 225     return true;
 226 }
 227
 228 gboolean
 229 MStarDict::onQuitMenuItemClicked(GtkButton *button,
 230                                  MStarDict *mStarDict)
 231 {
 232     gtk_main_quit();
 233     return true;
 234 }
 235
 236 gboolean
 237 MStarDict::onLookupProgressDialogResponse(GtkDialog *dialog,
 238                                           gint response_id,
 239                                           bool *cancel)
 240 {
 241     *cancel = true;
 242     return true;
 243 }
 244
 245 gboolean
 246 MStarDict::onMainWindowKeyPressEvent(GtkWidget *window,
 247                                      GdkEventKey *event,
 248                                      MStarDict *mStarDict)
 249 {
 250     if (event->type == GDK_KEY_PRESS && event->keyval == GDK_KP_Enter) {
 251         mStarDict->SearchWord();
 252     } else if (event->type == GDK_KEY_PRESS && event->keyval >= 0x21 && event->keyval <= 0x7E) {
 253         mStarDict->GrabFocus();
 254     }
 255     return false;
 256 }
 257
 258 GtkWidget *
 259 MStarDict::CreateLookupProgressDialog(bool *cancel)
 260 {
 261     GtkWidget *dialog, *progress;
 262
 263     /* create dialog */
 264     dialog = gtk_dialog_new();
 265     gtk_window_set_title(GTK_WINDOW(dialog), _("Searching"));
 266     gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(window));
 267     gtk_dialog_add_button(GTK_DIALOG(dialog), _("Cancel"), GTK_RESPONSE_OK);
 268
 269     g_signal_connect(dialog, "response", G_CALLBACK(onLookupProgressDialogResponse), cancel);
 270
 271     /* add progress bar */
 272     progress = gtk_progress_bar_new();
 273     gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), progress);
 274     g_object_set_data(G_OBJECT(dialog), "progress_bar", progress);
 275
 276     /* show dialog */
 277     gtk_widget_show_all(dialog);
 278
 279     while (gtk_events_pending())
 280         gtk_main_iteration();
 281
 282     return dialog;
 283 }
 284
 285 void
 286 MStarDict::DestroyLookupProgressDialog(GtkWidget *dialog)
 287 {
 288     gtk_widget_destroy(GTK_WIDGET(dialog));
 289 }
 290
 291 void
 292 MStarDict::CreateMainWindow()
 293 {
 294     HildonProgram *program = NULL;
 295     GtkWidget *alignment, *vbox;
 296     GtkCellRenderer *renderer;
 297     GtkTreeSelection *selection;
 298
 299     /* hildon program */
 300     program = hildon_program_get_instance();
 301     g_set_application_name(_("MStardict"));
 302
 303     /* main window */
 304     window = hildon_stackable_window_new();
 305     hildon_program_add_window(program, HILDON_WINDOW(window));
 306
 307     /* aligment */
 308     alignment = gtk_alignment_new(0.5, 0.5, 1.0, 1.0);
 309     gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
 310                               HILDON_MARGIN_HALF, 0, HILDON_MARGIN_DEFAULT, HILDON_MARGIN_DEFAULT);
 311     gtk_container_add(GTK_CONTAINER(window), alignment);
 312
 313     /* main vbox */
 314     vbox = gtk_vbox_new(FALSE, 0);
 315     gtk_container_add(GTK_CONTAINER(alignment), vbox);
 316
 317     /* no_search_result label */
 318     label_widget = gtk_label_new(_("No search result"));
 319     hildon_helper_set_logical_color(label_widget, GTK_RC_FG,
 320                                     GTK_STATE_NORMAL, "SecondaryTextColor");
 321     hildon_helper_set_logical_font(label_widget, "LargeSystemFont");
 322     gtk_box_pack_start(GTK_BOX(vbox), label_widget, TRUE, TRUE, 0);
 323
 324     /* alignment for pannable area */
 325     results_widget = gtk_alignment_new(0.5, 0.5, 1.0, 1.0);
 326     gtk_alignment_set_padding(GTK_ALIGNMENT(results_widget),
 327                               0, 0, HILDON_MARGIN_DEFAULT, HILDON_MARGIN_DEFAULT);
 328     gtk_box_pack_start(GTK_BOX(vbox), results_widget, TRUE, TRUE, 0);
 329
 330     /* pannable for tree view */
 331     results_view_scroll = hildon_pannable_area_new();
 332     gtk_container_add(GTK_CONTAINER(results_widget), results_view_scroll);
 333
 334     /* result tree view */
 335     results_view = hildon_gtk_tree_view_new(HILDON_UI_MODE_EDIT);
 336     gtk_tree_view_set_model(GTK_TREE_VIEW(results_view), GTK_TREE_MODEL(results_list));
 337     gtk_container_add(GTK_CONTAINER(results_view_scroll), results_view);
 338
 339     selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(results_view));
 340     g_signal_connect(selection, "changed", G_CALLBACK(onResultsViewSelectionChanged), this);
 341
 342     /* def column */
 343     renderer = gtk_cell_renderer_text_new();
 344     gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW
 345                                                 (results_view), -1, "Def",
 346                                                 renderer, "text", DEF_COLUMN, NULL);
 347     g_object_set(G_OBJECT(renderer),
 348                  "xpad", 10,
 349                  "ellipsize", PANGO_ELLIPSIZE_END,
 350                  "ellipsize-set", TRUE,
 351                  NULL);
 352
 353     /* search entry */
 354     search = hildon_entry_new(HILDON_SIZE_FINGER_HEIGHT);
 355     gtk_box_pack_end(GTK_BOX(vbox), search, FALSE, TRUE, 0);
 356     g_signal_connect(search, "changed", G_CALLBACK(onSearchEntryChanged), this);
 357
 358     /* window signals */
 359     g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 360     g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(onMainWindowKeyPressEvent), this);
 361
 362     /* show all widget instead of alignment */
 363     gtk_widget_show_all(GTK_WIDGET(window));
 364
 365     /* grab focus to search entry */
 366     GrabFocus();
 367 }
 368
 369 void
 370 MStarDict::CreateMainMenu()
 371 {
 372     HildonAppMenu *menu;
 373     GtkWidget *item;
 374
 375     menu = HILDON_APP_MENU(hildon_app_menu_new());
 376     hildon_window_set_app_menu(HILDON_WINDOW(window), menu);
 377
 378     /* dictionaries menu item */
 379     item = hildon_gtk_button_new(HILDON_SIZE_AUTO);
 380     gtk_button_set_label(GTK_BUTTON(item), _("Dictionaries"));
 381     hildon_app_menu_append(menu, GTK_BUTTON(item));
 382     g_signal_connect(item, "clicked", G_CALLBACK(onDictionariesMenuItemClicked), this);
 383
 384     /* quit menu item */
 385     item = hildon_gtk_button_new(HILDON_SIZE_AUTO);
 386     gtk_button_set_label(GTK_BUTTON(item), _("Quit"));
 387     hildon_app_menu_append(menu, GTK_BUTTON(item));
 388     g_signal_connect(item, "clicked", G_CALLBACK(onQuitMenuItemClicked), this);
 389
 390     /* show main menu */
 391     gtk_widget_show_all(GTK_WIDGET(menu));
 392 }
 393
 394 void
 395 MStarDict::SearchWord()
 396 {
 397     const gchar *sWord;
 398     bool bFound = false;
 399     std::string query;
 400
 401     if (oLibs->query_dictmask.empty())
 402         return;
 403
 404     sWord = gtk_entry_get_text(GTK_ENTRY(search));
 405     if (strcmp(sWord, "") == 0) {
 406         ShowNoResults(true);
 407     } else {
 408         /* unselect rows */
 409         ResultsUnselectAll(GTK_SELECTION_NONE);
 410
 411         switch (analyse_query(sWord, query)) {
 412         case qtDATA:
 413             bFound = oLibs->LookupData(query.c_str());
 414             break;
 415         default:
 416             /* nothing */ ;
 417         }
 418
 419         /* unselect selected rows */
 420         ResultsUnselectAll(GTK_SELECTION_SINGLE);
 421
 422         if (bFound)
 423             ShowNoResults(false);
 424         else
 425             ShowNoResults(true);
 426     }
 427 }
 428
 429 void
 430 MStarDict::ResultsListClear()
 431 {
 432     gtk_list_store_clear(results_list);
 433 }
 434
 435 void
 436 MStarDict::ResultsListInsertLast(const gchar *word)
 437 {
 438     GtkTreeIter iter;
 439     gtk_list_store_append(results_list, &iter);
 440     gtk_list_store_set(results_list, &iter, DEF_COLUMN, word, -1);
 441 }
 442
 443 void
 444 MStarDict::ResultsReScroll()
 445 {
 446     hildon_pannable_area_scroll_to(HILDON_PANNABLE_AREA(results_view_scroll), -1, 0);
 447 }
 448
 449 void
 450 MStarDict::ResultsUnselectAll(GtkSelectionMode mode)
 451 {
 452     GtkTreeSelection *selection;
 453
 454     selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(results_view));
 455     gtk_tree_selection_set_mode(selection, mode);
 456     gtk_tree_selection_unselect_all(selection);
 457 }
 458
 459 void
 460 MStarDict::ShowNoResults(bool bNoResults)
 461 {
 462     if (bNoResults) {
 463         gtk_label_set_text(GTK_LABEL(label_widget), _("No search result"));
 464         gtk_widget_show(label_widget);
 465         gtk_widget_hide(results_widget);
 466     } else {
 467         gtk_widget_hide(label_widget);
 468         gtk_widget_show(results_widget);
 469     }
 470 }
 471
 472 void
 473 MStarDict::ShowNoDictionary(bool bNoDictionary)
 474 {
 475     if (bNoDictionary) {
 476         gtk_label_set_text(GTK_LABEL(label_widget), _("No loaded dictionary"));
 477         gtk_widget_show(label_widget);
 478         gtk_widget_hide(results_widget);
 479     } else {
 480         gtk_widget_hide(label_widget);
 481         gtk_widget_show(results_widget);
 482     }
 483 }
 484
 485 void
 486 MStarDict::ShowProgressIndicator(bool bShow)
 487 {
 488     if (bShow)
 489         hildon_gtk_window_set_progress_indicator(GTK_WINDOW(window), 1);
 490     else
 491         hildon_gtk_window_set_progress_indicator(GTK_WINDOW(window), 0);
 492 }
 493
 494 void
 495 MStarDict::GrabFocus()
 496 {
 497     gtk_widget_grab_focus(GTK_WIDGET(search));
 498 }
 499
 500 int
 501 main(int argc,
 502      char **argv)
 503 {
 504     /* initialize hildon */
 505     hildon_gtk_init(&argc, &argv);
 506
 507     /* initialize localization */
 508     setlocale(LC_ALL, "");
 509     bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
 510     bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
 511     textdomain(GETTEXT_PACKAGE);
 512
 513     /* create main window */
 514     MStarDict mStarDict;
 515     pMStarDict = &mStarDict;
 516     mStarDict.CreateMainWindow();
 517     mStarDict.CreateMainMenu();
 518     mStarDict.ShowNoResults(true);
 519
 520     /* load dictionaries */
 521     mStarDict.oDict->LoadDictionaries();
 522
 523     gtk_main();
 524     return 0;
 525 }