src/frontends/xforms/FormThesaurus.C

   1 /**
   2  * \file FormThesaurus.C
   3  * Copyright 2001 The LyX Team.
   4  * See the file COPYING.
   5  *
   6  * \author Edwin Leuven
   7  */
   8
   9 #include <config.h>
  10
  11 #ifdef __GNUG__
  12 #pragma implementation
  13 #endif
  14
  15 #include <cctype>
  16 #include "support/lstrings.h"
  17 #include "xformsBC.h"
  18 #include "xforms_helpers.h"
  19 #include "ControlThesaurus.h"
  20 #include "FormThesaurus.h"
  21 #include "form_thesaurus.h"
  22 #include "debug.h"
  23
  24 typedef FormCB<ControlThesaurus, FormDB<FD_form_tabbed_thesaurus> > base_class;
  25
  26 FormThesaurus::FormThesaurus(ControlThesaurus & c)
  27         : base_class(c, _("LyX: Thesaurus"), false),
  28         clickline_(-1)
  29 {
  30 }
  31
  32
  33 void FormThesaurus::build()
  34 {
  35         dialog_.reset(build_tabbed_thesaurus());
  36         noun_.reset(build_noun());
  37         verb_.reset(build_verb());
  38         adjective_.reset(build_adjective());
  39         adverb_.reset(build_adverb());
  40         other_.reset(build_other());
  41
  42         // Manage the ok, apply and cancel/close buttons
  43         bc().setCancel(dialog_->button_close);
  44         bc().addReadOnly(dialog_->input_replace);
  45
  46         fl_set_input_return(dialog_->input_entry, FL_RETURN_END_CHANGED);
  47
  48         fl_addto_tabfolder(dialog_->tabbed_folder, _("Nouns"), noun_->form);
  49         fl_addto_tabfolder(dialog_->tabbed_folder, _("Verbs"), verb_->form);
  50         fl_addto_tabfolder(dialog_->tabbed_folder, _("Adjectives"), adjective_->form);
  51         fl_addto_tabfolder(dialog_->tabbed_folder, _("Adverbs"), adverb_->form);
  52         fl_addto_tabfolder(dialog_->tabbed_folder, _("Other"), other_->form);
  53 }
  54
  55
  56 void FormThesaurus::redraw()
  57 {
  58         if (form() && form()->visible)
  59                 fl_redraw_form(form());
  60         else
  61                 return;
  62
  63         FL_FORM * form = fl_get_active_folder(dialog_->tabbed_folder);
  64         if (form && form->visible)
  65                 fl_redraw_form(form);
  66 }
  67
  68
  69 void FormThesaurus::update()
  70 {
  71         if (!dialog_.get())
  72                 return;
  73
  74         string const & str_ = controller().text();
  75         setEnabled(dialog_->button_replace, !str_.empty());
  76         fl_set_input(dialog_->input_replace, "");
  77         updateEntries(str_);
  78 }
  79
  80
  81 void FormThesaurus::updateEntries(string const & str)
  82 {
  83         fl_set_input(dialog_->input_entry, str.c_str());
  84
  85         fl_clear_browser(noun_->browser_noun);
  86         fl_clear_browser(verb_->browser_verb);
  87         fl_clear_browser(adjective_->browser_adjective);
  88         fl_clear_browser(adverb_->browser_adverb);
  89         fl_clear_browser(other_->browser_other);
  90
  91         fl_set_browser_topline(noun_->browser_noun, 1);
  92         fl_set_browser_topline(verb_->browser_verb, 1);
  93         fl_set_browser_topline(adjective_->browser_adjective, 1);
  94         fl_set_browser_topline(adverb_->browser_adverb, 1);
  95         fl_set_browser_topline(other_->browser_other, 1);
  96
  97         fl_freeze_form(noun_->form);
  98         fl_freeze_form(verb_->form);
  99         fl_freeze_form(adverb_->form);
 100         fl_freeze_form(adjective_->form);
 101         fl_freeze_form(other_->form);
 102
 103         std::vector<string> nouns = controller().getNouns(str);
 104         for (std::vector<string>::const_iterator it = nouns.begin(); it != nouns.end(); ++it)
 105                 fl_add_browser_line(noun_->browser_noun, it->c_str());
 106
 107         std::vector<string> verbs = controller().getVerbs(str);
 108         for (std::vector<string>::const_iterator it = verbs.begin(); it != verbs.end(); ++it)
 109                 fl_add_browser_line(verb_->browser_verb, it->c_str());
 110
 111         std::vector<string> adjectives = controller().getAdjectives(str);
 112         for (std::vector<string>::const_iterator it = adjectives.begin(); it != adjectives.end(); ++it)
 113                 fl_add_browser_line(adjective_->browser_adjective, it->c_str());
 114
 115         std::vector<string> adverbs = controller().getAdverbs(str);
 116         for (std::vector<string>::const_iterator it = adverbs.begin(); it != adverbs.end(); ++it)
 117                 fl_add_browser_line(adverb_->browser_adverb, it->c_str());
 118
 119         std::vector<string> others = controller().getOthers(str);
 120         for (std::vector<string>::const_iterator it = others.begin(); it != others.end(); ++it)
 121                 fl_add_browser_line(other_->browser_other, it->c_str());
 122
 123         fl_unfreeze_form(noun_->form);
 124         fl_unfreeze_form(verb_->form);
 125         fl_unfreeze_form(adverb_->form);
 126         fl_unfreeze_form(adjective_->form);
 127         fl_unfreeze_form(other_->form);
 128         fl_redraw_form(noun_->form);
 129         fl_redraw_form(verb_->form);
 130         fl_redraw_form(adverb_->form);
 131         fl_redraw_form(adjective_->form);
 132         fl_redraw_form(other_->form);
 133 }
 134
 135
 136 void FormThesaurus::setReplace(string const & templ, string const & nstr)
 137 {
 138         string str(nstr);
 139
 140         // the following mechanism makes sure we replace "House" with "Home",
 141         // "HOUSE" with "HOME" etc.
 142
 143         bool all_lower = true;
 144         bool all_upper = true;
 145
 146         for (string::const_iterator it = templ.begin(); it != templ.end(); ++it) {
 147                 if (isupper(*it))
 148                         all_lower = false;
 149                 if (islower(*it))
 150                         all_upper = false;
 151         }
 152
 153         if (all_lower) {
 154                 str = lowercase(nstr);
 155         } else if (all_upper) {
 156                 str = uppercase(nstr);
 157         } else if (templ.size() > 0 && isupper(templ[0])) {
 158                 bool rest_lower = true;
 159                 for (string::const_iterator it = templ.begin() + 1;
 160                         it != templ.end(); ++it) {
 161                         if (isupper(*it))
 162                                 rest_lower = false;
 163                 }
 164
 165                 if (rest_lower) {
 166                         str = lowercase(nstr);
 167                         str[0] = uppercase(nstr[0]);
 168                 }
 169         }
 170
 171         fl_set_input(dialog_->input_replace, str.c_str());
 172 }
 173
 174
 175 ButtonPolicy::SMInput FormThesaurus::input(FL_OBJECT * obj, long)
 176 {
 177         FL_OBJECT * browser = 0;
 178
 179         if (obj == dialog_->input_entry) {
 180                 updateEntries(fl_get_input(dialog_->input_entry));
 181                 if (string(fl_get_input(dialog_->input_entry)).empty()) {
 182                         fl_set_input(dialog_->input_replace, "");
 183                         return ButtonPolicy::SMI_APPLY;
 184                 }
 185         } else if (obj == dialog_->button_replace) {
 186                 string rep(fl_get_input(dialog_->input_replace));
 187                 if (!rep.empty())
 188                         controller().replace(fl_get_input(dialog_->input_replace));
 189                 clickline_ = -1;
 190                 updateEntries(rep);
 191                 return ButtonPolicy::SMI_APPLY;
 192         } else if (obj == noun_->browser_noun ||
 193                    obj == verb_->browser_verb ||
 194                    obj == adjective_->browser_adjective ||
 195                    obj == adverb_->browser_adverb ||
 196                    obj == other_->browser_other) {
 197                 browser = obj;
 198         }
 199
 200         if (browser) {
 201                 setReplace(fl_get_input(dialog_->input_entry),
 202                         fl_get_browser_line(browser, fl_get_browser(browser)));
 203
 204                 if (clickline_ == fl_get_browser(browser)) {
 205                         updateEntries(fl_get_input(dialog_->input_replace));
 206                         clickline_ = -1;
 207                 } else {
 208                         clickline_ = fl_get_browser(browser);
 209                 }
 210         }
 211
 212         return ButtonPolicy::SMI_VALID;
 213 }