src/frontends/xforms/FormSpellchecker.C

   1 /**
   2  * \file FormSpellchecker.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Edwin Leuven
   7  *
   8  * Full author contact details are available in file CREDITS
   9  */
  10
  11 #include <config.h>
  12
  13 #ifdef __GNUG__
  14 #pragma implementation
  15 #endif
  16
  17 #include "xformsBC.h"
  18 #include "ControlSpellchecker.h"
  19 #include "FormSpellchecker.h"
  20 #include "forms/form_spellchecker.h"
  21
  22 #include "forms_gettext.h"
  23 #include "Tooltips.h"
  24 #include "xforms_helpers.h"
  25 #include "support/lstrings.h"
  26
  27 #include FORMS_H_LOCATION
  28
  29 typedef FormCB<ControlSpellchecker, FormDB<FD_spellchecker> > base_class;
  30
  31
  32 FormSpellchecker::FormSpellchecker()
  33         : base_class(_("Spellchecker")), state_(STOPPED)
  34 {}
  35
  36
  37 void FormSpellchecker::build()
  38 {
  39         dialog_.reset(build_spellchecker(this));
  40
  41         // Manage the buttons
  42         bc().setCancel(dialog_->button_close);
  43
  44         // disable for read-only documents
  45         bc().addReadOnly(dialog_->button_replace);
  46
  47         // trigger an input event for cut&paste with middle mouse button.
  48         setPrehandler(dialog_->input_replacement);
  49
  50         fl_set_input_return(dialog_->input_replacement, FL_RETURN_CHANGED);
  51
  52         // callback for double click in browser
  53         fl_set_browser_dblclick_callback(dialog_->browser_suggestions,
  54                                          C_FormBaseInputCB, 2);
  55
  56         // do not allow setting of slider by the mouse
  57         fl_deactivate_object(dialog_->slider_progress);
  58
  59         // set up the tooltips
  60         string str = _("Type replacement for unknown word "
  61                         "or select from suggestions.");
  62         tooltips().init(dialog_->input_replacement, str);
  63         str = _("List of replacement suggestions from dictionary.");
  64         tooltips().init(dialog_->browser_suggestions, str);
  65         // Work-around xforms' bug; enable tooltips for browser widgets.
  66         setPrehandler(dialog_->browser_suggestions);
  67         str = _("Start the spellingchecker.");
  68         tooltips().init(dialog_->button_start, str);
  69         str = _("Replace unknown word.");
  70         tooltips().init(dialog_->button_replace, str);
  71         str = _("Ignore unknown word.");
  72         tooltips().init(dialog_->button_ignore, str);
  73         str = _("Accept unknown word as known in this session.");
  74         tooltips().init(dialog_->button_accept, str);
  75         str = _("Add unknown word to personal dictionary.");
  76         tooltips().init(dialog_->button_add, str);
  77         str = _("Shows word count and progress on spell check.");
  78         tooltips().init(dialog_->slider_progress, str);
  79 }
  80
  81
  82 void FormSpellchecker::updateState(State state)
  83 {
  84         switch (state) {
  85         case READY_TO_START:
  86                 fl_set_slider_value(dialog_->slider_progress, 0.0);
  87                 fl_set_object_label(dialog_->slider_progress, "0 %");
  88                 break;
  89
  90         case CHECKING:
  91         {
  92                 // Set suggestions.
  93                 string w = controller().getWord();
  94                 fl_set_input(dialog_->input_replacement, w.c_str());
  95                 fl_set_object_label(dialog_->text_unknown, w.c_str());
  96                 fl_clear_browser(dialog_->browser_suggestions);
  97                 while (!(w = controller().getSuggestion()).empty()) {
  98                         fl_add_browser_line(dialog_->browser_suggestions,
  99                                             w.c_str());
 100                 }
 101                 // Fall through...
 102         }
 103
 104         case STARTED:
 105         {
 106                 int const progress = controller().getProgress();
 107                 if (progress == 0)
 108                         break;
 109
 110                 double const wordcount = controller().getCount();
 111                 double const total = 100.0 * wordcount / progress;
 112                 string const label = tostr(progress) + " %";
 113
 114                 fl_set_slider_bounds(dialog_->slider_progress, 0.0, total);
 115                 fl_set_slider_value(dialog_->slider_progress, wordcount);
 116                 fl_set_object_label(dialog_->slider_progress, label.c_str());
 117                 break;
 118         }
 119
 120         case STOPPED:
 121         {
 122                 controller().stop();
 123
 124                 double const wordcount = controller().getCount();
 125
 126                 fl_set_slider_bounds(dialog_->slider_progress, 0.0, wordcount);
 127                 fl_set_slider_value(dialog_->slider_progress, wordcount);
 128                 fl_set_object_label(dialog_->slider_progress, "100 %");
 129                 break;
 130         }
 131         }
 132
 133         bool const state_change = state_ != state;
 134         state_ = state;
 135
 136         if (!state_change)
 137                 return;
 138
 139         bool const running = (state == STARTED || state == CHECKING);
 140         string const label = running ? _("Stop|#S") : _("Start|#S");
 141
 142         fl_set_object_label(dialog_->button_start, idex(label).c_str());
 143         fl_set_button_shortcut(dialog_->button_start, scex(label).c_str(), 1);
 144         fl_redraw_object(dialog_->button_start);
 145
 146         string const tip = running ?
 147                 _("Stop the spellingchecker.") :
 148                 _("Start the spellingchecker.");
 149         tooltips().init(dialog_->button_start, tip);
 150
 151         setEnabled(dialog_->button_replace,      running);
 152         setEnabled(dialog_->button_ignore,       running);
 153         setEnabled(dialog_->button_accept,       running);
 154         setEnabled(dialog_->button_add,          running);
 155         setEnabled(dialog_->browser_suggestions, running);
 156         setEnabled(dialog_->input_replacement,   running);
 157 }
 158
 159
 160 void FormSpellchecker::update()
 161 {
 162         // clear input fields
 163         fl_set_input(dialog_->input_replacement, "");
 164         fl_set_object_label(dialog_->text_unknown, "");
 165         fl_clear_browser(dialog_->browser_suggestions);
 166
 167         // reset dialog and buttons into start condition
 168         updateState(READY_TO_START);
 169 }
 170
 171
 172 ButtonPolicy::SMInput FormSpellchecker::input(FL_OBJECT * ob, long ob_value)
 173 {
 174         if (ob == dialog_->button_start) {
 175                 updateState(STARTED);
 176                 controller().check();
 177
 178         } else if (ob == dialog_->button_replace) {
 179                 string const tmp = getString(dialog_->input_replacement);
 180                 controller().replace(tmp);
 181
 182         } else if (ob == dialog_->button_ignore) {
 183                 controller().check();
 184
 185         } else if (ob == dialog_->button_accept) {
 186                 controller().ignoreAll();
 187
 188         } else if (ob == dialog_->button_add) {
 189                 controller().insert();
 190
 191         } else if (ob == dialog_->browser_suggestions) {
 192                 string const tmp = getString(dialog_->browser_suggestions);
 193                 if (tmp.empty())
 194                         return ButtonPolicy::SMI_NOOP;
 195
 196                 if (ob_value != 2) {
 197                         // single-click
 198                         // place the chosen string in the input as feedback
 199                         fl_set_input(dialog_->input_replacement, tmp.c_str());
 200
 201                 } else {
 202                         // double-click
 203                         controller().replace(tmp);
 204                         // reset the browser so that the following
 205                         // single-click callback doesn't do anything
 206                         fl_deselect_browser(dialog_->browser_suggestions);
 207                 }
 208         }
 209
 210         return ButtonPolicy::SMI_VALID;
 211 }
 212
 213
 214 void FormSpellchecker::partialUpdate(int id)
 215 {
 216         switch (id) {
 217         case 1:
 218                 // Set suggestions.
 219                 updateState(CHECKING);
 220                 break;
 221         case 2:
 222                 // End of spell checking.
 223                 updateState(STOPPED);
 224                 break;
 225         }
 226 }