gtk/src/main_window.cpp

   1 #include <memory>
   2 #include <gtkmm/main.h>
   3 #include <gtkmm/stockid.h>
   4 #include <gtkmm/stock.h>
   5
   6 #include "main_window.hpp"
   7 #include "list.hpp"
   8
   9 MainWindow::MainWindow(GtkWindow *cobject, Glib::RefPtr<Glade::Xml> &glade) :
  10         Gtk::Window(cobject),
  11         _glade(glade),
  12         _file_chooser_dialog(NULL),
  13         _opacity_adjustment_dialog(NULL),
  14         _tree_model(NULL),
  15         _opacity_presets(NULL),
  16         _opacity_scale(NULL),
  17         _opacity_adjustment(NULL),
  18         _info_box(NULL),
  19         _stats_listview(NULL),
  20         _trans_listview(NULL),
  21         _dist_listview(NULL),
  22         _ngram_listview(NULL),
  23         _fert_listview(NULL)
  24 {
  25         _init_actions();
  26         _init_ui();
  27
  28         show_all();
  29 }
  30
  31 MainWindow::~MainWindow(void)
  32 {
  33         delete _file_chooser_dialog;
  34         delete _opacity_adjustment_dialog;
  35         delete _tree_model;
  36         delete _canvas_eventbox;
  37         delete _info_box;
  38 }
  39
  40 void MainWindow::quit(void)
  41 {
  42         Gtk::Main::quit();
  43 }
  44
  45 void MainWindow::clear(void)
  46 {
  47         _stats_listview->unset_model();
  48         _trans_listview->unset_model();
  49         _dist_listview->unset_model();
  50         _ngram_listview->unset_model();
  51         _fert_listview->unset_model();
  52 }
  53
  54 void MainWindow::show_open_dialog(void)
  55 {
  56         gint response;
  57         std::string filename;
  58
  59         g_assert(_file_chooser_dialog);
  60         _file_chooser_dialog->set_current_folder(Glib::get_home_dir());
  61         response = _file_chooser_dialog->run();
  62
  63         if (response == Gtk::RESPONSE_OK) {
  64                 filename = _file_chooser_dialog->get_filename();
  65                 read_file(filename);
  66         }
  67
  68         _file_chooser_dialog->hide();
  69 }
  70
  71 void MainWindow::show_opacity_adjustment_dialog(void)
  72 {
  73         gdouble original;
  74         gint response;
  75
  76         g_assert(_opacity_adjustment_dialog);
  77
  78         original = _opacity_adjustment->get_value();
  79         response = _opacity_adjustment_dialog->run();
  80
  81         if (response == Gtk::RESPONSE_CANCEL) {
  82                 _opacity_adjustment->set_value(original);
  83         }
  84
  85         _opacity_adjustment_dialog->hide();
  86 }
  87
  88 void MainWindow::read_file(const std::string &filename)
  89 {
  90         _parser.read_file(filename);
  91
  92         clear();
  93
  94         _read_header();
  95         _read_language_models();
  96         _read_alignment();
  97         _read_translation();
  98         _read_distortion();
  99         _read_ngram();
 100         _read_fertility();
 101
 102         g_assert(_tree_model);
 103         _tree_model->add_alignment(_alignment);
 104 }
 105
 106 bool MainWindow::on_key_release_event(GdkEventKey *event)
 107 {
 108         if (Gtk::Window::on_key_release_event(event)) {
 109                 return true;
 110         }
 111
 112         if (event->keyval == GDK_h &&
 113             (event->state & GDK_SHIFT_MASK) != GDK_SHIFT_MASK &&
 114             (event->state & GDK_CONTROL_MASK) != GDK_CONTROL_MASK &&
 115             (event->state & GDK_MOD1_MASK) != GDK_MOD1_MASK) {
 116                 if (_info_box->is_visible()) {
 117                         _info_box->hide();
 118                 } else {
 119                         _info_box->show();
 120                 }
 121         } else if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) {
 122                 if (event->keyval == GDK_Left) {
 123                         _tree_model->decrease_hscale();
 124                 } else if (event->keyval == GDK_Right) {
 125                         _tree_model->increase_hscale();
 126                 } else if (event->keyval == GDK_Up) {
 127                         _tree_model->increase_vscale();
 128                 } else if (event->keyval == GDK_Down) {
 129                         _tree_model->decrease_vscale();
 130                 } else {
 131                         return false;
 132                 }
 133         } else {
 134                 return false;
 135         }
 136
 137         return true;
 138 }
 139
 140 void MainWindow::on_opacity_adjustment_value_changed(void)
 141 {
 142         if (_opacity_adjustment && _tree_model) {
 143                 _tree_model->set_opacity(_opacity_adjustment->get_value());
 144         }
 145 }
 146
 147 void MainWindow::on_opacity_presets_changed(void)
 148 {
 149         Glib::ustring val;
 150
 151         g_assert(_opacity_adjustment);
 152         g_assert(_opacity_presets);
 153
 154         _opacity_presets->get_active()->get_value(0, val);
 155
 156         if (val.compare("Both") == 0) {
 157                 _opacity_adjustment->set_value(0.0);
 158         } else if (val.compare("Leaves Only") == 0) {
 159                 _opacity_adjustment->set_value(_opacity_adjustment->get_lower());
 160         } else if (val.compare("Root Only") == 0) {
 161                 _opacity_adjustment->set_value(_opacity_adjustment->get_upper());
 162         }
 163 }
 164
 165 void MainWindow::_init_actions(void)
 166 {
 167         // Connect all the signals to the corresponding handlers
 168         _glade->connect_clicked("quit", sigc::mem_fun(*this, &MainWindow::quit));
 169         _glade->connect_clicked("open", sigc::mem_fun(*this, &MainWindow::show_open_dialog));
 170 }
 171
 172 void MainWindow::_init_ui(void)
 173 {
 174         // Get hold of the file chooser dialog.
 175         _file_chooser_dialog = _glade->get_widget("file_chooser_dialog",
 176                                                   _file_chooser_dialog);
 177         g_assert(_file_chooser_dialog);
 178         _file_chooser_dialog->add_button(Gtk::StockID(Gtk::Stock::OPEN),
 179                                          Gtk::RESPONSE_OK);
 180         _file_chooser_dialog->add_button(Gtk::StockID(Gtk::Stock::CANCEL),
 181                                          Gtk::RESPONSE_CANCEL);
 182
 183         // Initialize the canvas.
 184         _canvas_eventbox = _glade->get_widget("canvas_eventbox", _canvas_eventbox);
 185         g_assert(_canvas_eventbox);
 186         _glade->get_widget_derived("canvas", _tree_model);
 187         g_assert(_tree_model);
 188         _tree_model->set_eventbox(*_canvas_eventbox);
 189         _tree_model->get_terminal_selected_signal().connect(sigc::mem_fun(*this, &MainWindow::_show_terminal_info));
 190         _tree_model->get_opacity_adjustment_selected_signal().connect(sigc::mem_fun(*this, &MainWindow::show_opacity_adjustment_dialog));
 191
 192         // Get opacity adjustment dialog.
 193         _opacity_adjustment_dialog = _glade->get_widget("opacity_adjustment_dialog",
 194                                                         _opacity_adjustment_dialog);
 195         g_assert(_opacity_adjustment_dialog);
 196         _opacity_adjustment_dialog->add_button(Gtk::StockID(Gtk::Stock::OK),
 197                                                Gtk::RESPONSE_OK);
 198         _opacity_adjustment_dialog->add_button(Gtk::StockID(Gtk::Stock::CANCEL),
 199                                                Gtk::RESPONSE_CANCEL);
 200         _opacity_presets = _glade->get_widget("opacity_presets", _opacity_presets);
 201         g_assert(_opacity_presets);
 202         _opacity_presets->signal_changed().connect(sigc::mem_fun(*this, &MainWindow::on_opacity_presets_changed));
 203         _opacity_scale = _glade->get_widget("opacity_scale", _opacity_scale);
 204         g_assert(_opacity_scale);
 205         _opacity_adjustment = _opacity_scale->get_adjustment();
 206         _opacity_adjustment->set_value(_tree_model->get_opacity());
 207         _opacity_adjustment->signal_value_changed().connect(sigc::mem_fun(*this, &MainWindow::on_opacity_adjustment_value_changed));
 208
 209         // Get hold of the widgets which will contain the information lists.
 210         _info_box = _glade->get_widget("info_box", _info_box);
 211         g_assert(_info_box);
 212         _glade->get_widget_derived("stats_treeview", _stats_listview);
 213         _glade->get_widget_derived("trans_treeview", _trans_listview);
 214         _glade->get_widget_derived("dist_treeview", _dist_listview);
 215         _glade->get_widget_derived("ngram_treeview", _ngram_listview);
 216         _glade->get_widget_derived("fert_treeview", _fert_listview);
 217         g_assert(_stats_listview);
 218         g_assert(_trans_listview);
 219         g_assert(_dist_listview);
 220         g_assert(_ngram_listview);
 221         g_assert(_fert_listview);
 222 }
 223
 224 void MainWindow::_read_header(void)
 225 {
 226         header_t *header = NULL;
 227
 228         header = _parser.parse_header();
 229
 230         g_assert(_stats_listview);
 231
 232         if (header) {
 233                 _alignment.set_stats(*header);
 234
 235                 delete header;
 236
 237                 const Glib::RefPtr<List> &list(_alignment.get_stats());
 238                 _stats_listview->set_model(list);
 239                 _stats_listview->append_column("Name", list->get_str_column());
 240                 _stats_listview->append_column("Value", list->get_str_value_column());
 241         }
 242 }
 243
 244 void MainWindow::_read_language_models(void)
 245 {
 246         language_model_t *source = NULL;
 247         language_model_t *target = NULL;
 248
 249         source = _parser.parse_source_language_model();
 250         target = _parser.parse_target_language_model();
 251
 252         if (source) {
 253                 _alignment.set_source_language_model(source);
 254         }
 255         if (target) {
 256                 _alignment.set_target_language_model(target);
 257         }
 258 }
 259
 260 void MainWindow::_read_alignment(void)
 261 {
 262         alignment_t *source = new alignment_t;
 263         alignment_t *target = new alignment_t;
 264
 265         _parser.parse_alignment(*source, *target);
 266
 267         _alignment.set_alignment(source, target);
 268 }
 269
 270 void MainWindow::_read_translation(void)
 271 {
 272         translation_t *trans = NULL;
 273
 274         trans = _parser.parse_translation();
 275
 276         if (trans) {
 277                 g_assert(_trans_listview);
 278                 _alignment.set_translation(*trans);
 279
 280                 delete trans;
 281         }
 282 }
 283
 284 void MainWindow::_read_distortion(void)
 285 {
 286         distortion_t *dist = NULL;
 287
 288         dist = _parser.parse_distortion();
 289
 290         if (dist) {
 291                 g_assert(_dist_listview);
 292                 _alignment.set_distortion(*dist);
 293
 294                 delete dist;
 295         }
 296 }
 297
 298 void MainWindow::_read_ngram(void)
 299 {
 300         ngram_t *ngram = NULL;
 301
 302         ngram = _parser.parse_ngram();
 303
 304         if (ngram) {
 305                 g_assert(_ngram_listview);
 306                 _alignment.set_ngram(*ngram);
 307
 308                 delete ngram;
 309         }
 310 }
 311
 312 void MainWindow::_read_fertility(void)
 313 {
 314         fertility_t *fert = NULL;
 315
 316         fert = _parser.parse_fertility();
 317
 318         if (fert) {
 319                 g_assert(_fert_listview);
 320                 _alignment.set_fertility(*fert);
 321
 322                 delete fert;
 323         }
 324 }
 325
 326 void MainWindow::_show_terminal_info(const Terminal &terminal)
 327 {
 328         static bool is_trans_appended = false;
 329         static bool is_dist_appended = false;
 330         static bool is_ngram_appended = false;
 331         static bool is_fert_appended = false;
 332
 333         const Glib::RefPtr<List> &trans_list(terminal.get_translation());
 334         _trans_listview->unset_model();
 335         if (trans_list) {
 336                 _trans_listview->set_model(trans_list);
 337                 if (!is_trans_appended) {
 338                         _trans_listview->append_column("Translations", trans_list->get_str_column());
 339                         _trans_listview->append_column("Probabilities", trans_list->get_double_value_column());
 340                         is_trans_appended = true;
 341                 }
 342         }
 343
 344         const Glib::RefPtr<List> &dist_list(terminal.get_distortion());
 345         _dist_listview->unset_model();
 346         if (dist_list) {
 347                 _dist_listview->set_model(dist_list);
 348                 if (!is_dist_appended) {
 349                         _dist_listview->append_column("Distortions", dist_list->get_int_column());
 350                         _dist_listview->append_column("Probabilities", dist_list->get_double_value_column());
 351                         is_dist_appended = true;
 352                 }
 353         }
 354
 355         const Glib::RefPtr<List> &ngram_list(terminal.get_ngram());
 356         _ngram_listview->unset_model();
 357         if (ngram_list) {
 358                 _ngram_listview->set_model(ngram_list);
 359                 if (!is_ngram_appended) {
 360                         _ngram_listview->append_column("N-gram", ngram_list->get_str_column());
 361                         _ngram_listview->append_column("Probabilities", ngram_list->get_double_value_column());
 362                         is_ngram_appended = true;
 363                 }
 364         }
 365
 366         const Glib::RefPtr<List> &fert_list(terminal.get_fertility());
 367         _fert_listview->unset_model();
 368         if (fert_list) {
 369                 _fert_listview->set_model(fert_list);
 370                 if (!is_fert_appended) {
 371                         _fert_listview->append_column("Fertilities", fert_list->get_int_column());
 372                         _fert_listview->append_column("Probabilities", fert_list->get_double_value_column());
 373                         is_fert_appended = true;
 374                 }
 375         }
 376 }