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")),
  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         fl_set_form_maxsize(dialog_->form, minw_, minh_);
  43
  44         // Manage the ok, apply and cancel/close buttons
  45         bc().setCancel(dialog_->button_close);
  46         bc().addReadOnly(dialog_->input_replace);
  47
  48         fl_set_input_return(dialog_->input_entry, FL_RETURN_END_CHANGED);
  49
  50         fl_addto_tabfolder(dialog_->tabbed_folder, _("Nouns"), noun_->form);
  51         fl_addto_tabfolder(dialog_->tabbed_folder, _("Verbs"), verb_->form);
  52         fl_addto_tabfolder(dialog_->tabbed_folder, _("Adjectives"), adjective_->form);
  53         fl_addto_tabfolder(dialog_->tabbed_folder, _("Adverbs"), adverb_->form);
  54         fl_addto_tabfolder(dialog_->tabbed_folder, _("Other"), other_->form);
  55 }
  56
  57
  58 void FormThesaurus::redraw()
  59 {
  60         if (form() && form()->visible)
  61                 fl_redraw_form(form());
  62         else
  63                 return;
  64
  65         FL_FORM * form = fl_get_active_folder(dialog_->tabbed_folder);
  66         if (form && form->visible)
  67                 fl_redraw_form(form);
  68 }
  69
  70
  71 void FormThesaurus::update()
  72 {
  73         if (!dialog_.get())
  74                 return;
  75
  76         string const & str_ = controller().text();
  77         setEnabled(dialog_->button_replace, !str_.empty());
  78         fl_set_input(dialog_->input_replace, "");
  79         updateEntries(str_);
  80 }
  81
  82
  83 void FormThesaurus::updateEntries(string const & str)
  84 {
  85         fl_set_input(dialog_->input_entry, str.c_str());
  86
  87         fl_clear_browser(noun_->browser_noun);
  88         fl_clear_browser(verb_->browser_verb);
  89         fl_clear_browser(adjective_->browser_adjective);
  90         fl_clear_browser(adverb_->browser_adverb);
  91         fl_clear_browser(other_->browser_other);
  92
  93         fl_set_browser_topline(noun_->browser_noun, 1);
  94         fl_set_browser_topline(verb_->browser_verb, 1);
  95         fl_set_browser_topline(adjective_->browser_adjective, 1);
  96         fl_set_browser_topline(adverb_->browser_adverb, 1);
  97         fl_set_browser_topline(other_->browser_other, 1);
  98
  99         fl_freeze_form(noun_->form);
 100         fl_freeze_form(verb_->form);
 101         fl_freeze_form(adverb_->form);
 102         fl_freeze_form(adjective_->form);
 103         fl_freeze_form(other_->form);
 104
 105         std::vector<string> nouns = controller().getNouns(str);
 106         for (std::vector<string>::const_iterator it = nouns.begin(); it != nouns.end(); ++it)
 107                 fl_add_browser_line(noun_->browser_noun, it->c_str());
 108
 109         std::vector<string> verbs = controller().getVerbs(str);
 110         for (std::vector<string>::const_iterator it = verbs.begin(); it != verbs.end(); ++it)
 111                 fl_add_browser_line(verb_->browser_verb, it->c_str());
 112
 113         std::vector<string> adjectives = controller().getAdjectives(str);
 114         for (std::vector<string>::const_iterator it = adjectives.begin(); it != adjectives.end(); ++it)
 115                 fl_add_browser_line(adjective_->browser_adjective, it->c_str());
 116
 117         std::vector<string> adverbs = controller().getAdverbs(str);
 118         for (std::vector<string>::const_iterator it = adverbs.begin(); it != adverbs.end(); ++it)
 119                 fl_add_browser_line(adverb_->browser_adverb, it->c_str());
 120
 121         std::vector<string> others = controller().getOthers(str);
 122         for (std::vector<string>::const_iterator it = others.begin(); it != others.end(); ++it)
 123                 fl_add_browser_line(other_->browser_other, it->c_str());
 124
 125         fl_unfreeze_form(noun_->form);
 126         fl_unfreeze_form(verb_->form);
 127         fl_unfreeze_form(adverb_->form);
 128         fl_unfreeze_form(adjective_->form);
 129         fl_unfreeze_form(other_->form);
 130         fl_redraw_form(noun_->form);
 131         fl_redraw_form(verb_->form);
 132         fl_redraw_form(adverb_->form);
 133         fl_redraw_form(adjective_->form);
 134         fl_redraw_form(other_->form);
 135 }
 136
 137
 138 void FormThesaurus::setReplace(string const & templ, string const & nstr)
 139 {
 140         string str(nstr);
 141
 142         // the following mechanism makes sure we replace "House" with "Home",
 143         // "HOUSE" with "HOME" etc.
 144
 145         bool all_lower = true;
 146         bool all_upper = true;
 147
 148         for (string::const_iterator it = templ.begin(); it != templ.end(); ++it) {
 149                 if (isupper(*it))
 150                         all_lower = false;
 151                 if (islower(*it))
 152                         all_upper = false;
 153         }
 154
 155         if (all_lower) {
 156                 str = lowercase(nstr);
 157         } else if (all_upper) {
 158                 str = uppercase(nstr);
 159         } else if (templ.size() > 0 && isupper(templ[0])) {
 160                 bool rest_lower = true;
 161                 for (string::const_iterator it = templ.begin() + 1;
 162                         it != templ.end(); ++it) {
 163                         if (isupper(*it))
 164                                 rest_lower = false;
 165                 }
 166
 167                 if (rest_lower) {
 168                         str = lowercase(nstr);
 169                         str[0] = uppercase(nstr[0]);
 170                 }
 171         }
 172
 173         fl_set_input(dialog_->input_replace, str.c_str());
 174 }
 175
 176
 177 ButtonPolicy::SMInput FormThesaurus::input(FL_OBJECT * obj, long)
 178 {
 179         FL_OBJECT * browser = 0;
 180
 181         if (obj == dialog_->input_entry) {
 182                 updateEntries(fl_get_input(dialog_->input_entry));
 183                 if (string(fl_get_input(dialog_->input_entry)).empty()) {
 184                         fl_set_input(dialog_->input_replace, "");
 185                         return ButtonPolicy::SMI_APPLY;
 186                 }
 187         } else if (obj == dialog_->button_replace) {
 188                 string rep(fl_get_input(dialog_->input_replace));
 189                 if (!rep.empty())
 190                         controller().replace(fl_get_input(dialog_->input_replace));
 191                 clickline_ = -1;
 192                 updateEntries(rep);
 193                 return ButtonPolicy::SMI_APPLY;
 194         } else if (obj == noun_->browser_noun ||
 195                    obj == verb_->browser_verb ||
 196                    obj == adjective_->browser_adjective ||
 197                    obj == adverb_->browser_adverb ||
 198                    obj == other_->browser_other) {
 199                 browser = obj;
 200         }
 201
 202         if (browser) {
 203                 setReplace(fl_get_input(dialog_->input_entry),
 204                         fl_get_browser_line(browser, fl_get_browser(browser)));
 205
 206                 if (clickline_ == fl_get_browser(browser)) {
 207                         updateEntries(fl_get_input(dialog_->input_replace));
 208                         clickline_ = -1;
 209                 } else {
 210                         clickline_ = fl_get_browser(browser);
 211                 }
 212         }
 213
 214         return ButtonPolicy::SMI_VALID;
 215 }