src/frontends/xforms/FormRef.C

   1 /**
   2  * \file xforms/FormRef.C
   3  * Copyright 2000-2001 The LyX Team.
   4  * See the file COPYING.
   5  *
   6  * \author Angus Leeming <leeming@lyx.org>
   7  */
   8
   9 #include <config.h>
  10 #include <algorithm>
  11
  12 #ifdef __GNUG__
  13 #pragma implementation
  14 #endif
  15
  16 #include "xformsBC.h"
  17 #include "ControlRef.h"
  18 #include "FormRef.h"
  19 #include "forms/form_ref.h"
  20 #include "xforms_helpers.h"
  21 #include "insets/insetref.h"
  22 #include "helper_funcs.h" // getStringFromVector
  23 #include "support/lstrings.h" // frontStrip, strip
  24 #include FORMS_H_LOCATION
  25
  26 using std::find;
  27 using std::max;
  28 using std::sort;
  29 using std::vector;
  30
  31 typedef FormCB<ControlRef, FormDB<FD_ref> > base_class;
  32
  33 FormRef::FormRef()
  34         : base_class(_("Reference")),
  35           at_ref_(false)
  36 {}
  37
  38
  39 void FormRef::build()
  40 {
  41         dialog_.reset(build_ref(this));
  42
  43         for (int i = 0; !InsetRef::types[i].latex_name.empty(); ++i)
  44                 fl_addto_choice(dialog_->choice_type,
  45                                 _(InsetRef::types[i].gui_name.c_str()));
  46
  47         // Force the user to use the browser to change refs.
  48         fl_deactivate_object(dialog_->input_ref);
  49
  50         fl_set_input_return(dialog_->input_name, FL_RETURN_CHANGED);
  51         fl_set_input_return(dialog_->input_ref,  FL_RETURN_CHANGED);
  52
  53         setPrehandler(dialog_->input_name);
  54         setPrehandler(dialog_->input_ref);
  55
  56         // Manage the ok and cancel/close buttons
  57         bc().setOK(dialog_->button_ok);
  58         bc().setApply(dialog_->button_apply);
  59         bc().setCancel(dialog_->button_close);
  60         bc().setRestore(dialog_->button_restore);
  61
  62         bc().addReadOnly(dialog_->button_update);
  63         bc().addReadOnly(dialog_->input_name);
  64         bc().addReadOnly(dialog_->input_ref);
  65 }
  66
  67
  68 void FormRef::update()
  69 {
  70         fl_set_input(dialog_->input_ref,
  71                      controller().params().getContents().c_str());
  72         fl_set_input(dialog_->input_name,
  73                      controller().params().getOptions().c_str());
  74         fl_set_choice(dialog_->choice_type,
  75                       InsetRef::getType(controller().params().getCmdName()) + 1);
  76
  77         at_ref_ = false;
  78         fl_set_object_label(dialog_->button_go, _("Go to reference"));
  79
  80         // Name is irrelevant to LaTeX/Literate documents
  81         if (controller().docType() == ControlRef::LATEX ||
  82             controller().docType() == ControlRef::LITERATE) {
  83                 setEnabled(dialog_->input_name, false);
  84         } else {
  85                 setEnabled(dialog_->input_name, true);
  86         }
  87
  88         // type is irrelevant to LinuxDoc/DocBook.
  89         if (controller().docType() == ControlRef::LINUXDOC ||
  90             controller().docType() == ControlRef::DOCBOOK) {
  91                 fl_set_choice(dialog_->choice_type, 1);
  92                 setEnabled(dialog_->choice_type, false);
  93         } else {
  94                 setEnabled(dialog_->choice_type, true);
  95         }
  96
  97         // Get the available buffers
  98         vector<string> const buffers = controller().getBufferList();
  99         vector<string> const choice_buffers =
 100                 getVector(dialog_->choice_buffer);
 101
 102         // If different from the current contents of the choice, then update it
 103         if (buffers != choice_buffers) {
 104                 // create a string of entries " entry1 | entry2 | entry3 "
 105                 // with which to initialise the xforms choice object.
 106                 string const choice =
 107                         " " + getStringFromVector(buffers, " | ") + " ";
 108
 109                 fl_clear_choice(dialog_->choice_buffer);
 110                 fl_addto_choice(dialog_->choice_buffer, choice.c_str());
 111
 112                 fl_set_choice(dialog_->choice_buffer,
 113                               controller().getBufferNum() + 1);
 114         }
 115
 116         string const name = controller().
 117                 getBufferName(fl_get_choice(dialog_->choice_buffer) - 1);
 118         refs_ = controller().getLabelList(name);
 119
 120         updateBrowser(refs_);
 121 }
 122
 123
 124 void FormRef::updateBrowser(vector<string> const & akeys) const
 125 {
 126         vector<string> keys(akeys);
 127         if (fl_get_button(dialog_->check_sort))
 128                 sort(keys.begin(), keys.end());
 129
 130         vector<string> browser_keys = getVector(dialog_->browser_refs);
 131
 132         if (browser_keys == keys)
 133                 return;
 134
 135         fl_clear_browser(dialog_->browser_refs);
 136         for (vector<string>::const_iterator it = keys.begin();
 137              it != keys.end(); ++it)
 138                 fl_add_browser_line(dialog_->browser_refs, it->c_str());
 139
 140         if (keys.empty()) {
 141                 fl_add_browser_line(dialog_->browser_refs,
 142                                     _("*** No labels found in document ***"));
 143
 144                 setEnabled(dialog_->browser_refs, false);
 145                 setEnabled(dialog_->check_sort,   false);
 146
 147                 fl_set_input(dialog_->input_ref, "");
 148         } else {
 149                 setEnabled(dialog_->browser_refs, true);
 150                 setEnabled(dialog_->check_sort,   true);
 151
 152                 string ref = fl_get_input(dialog_->input_ref);
 153                 vector<string>::const_iterator cit = (ref.empty())
 154                         ? keys.begin()
 155                         : find(keys.begin(), keys.end(), ref);
 156                 if (cit == keys.end()) {
 157                         fl_deselect_browser(dialog_->browser_refs);
 158                 } else {
 159                         if (ref.empty())
 160                                 fl_set_input(dialog_->input_ref, cit->c_str());
 161
 162                         int const i = static_cast<int>(cit - keys.begin());
 163                         fl_set_browser_topline(dialog_->browser_refs, max(i-5, 1));
 164                         fl_select_browser_line(dialog_->browser_refs, i+1);
 165                 }
 166         }
 167 }
 168
 169
 170 void FormRef::apply()
 171 {
 172         int const type = fl_get_choice(dialog_->choice_type) - 1;
 173         controller().params().setCmdName(InsetRef::getName(type));
 174
 175         controller().params().setOptions(fl_get_input(dialog_->input_name));
 176         controller().params().setContents(fl_get_input(dialog_->input_ref));
 177 }
 178
 179
 180 ButtonPolicy::SMInput FormRef::input(FL_OBJECT * ob, long)
 181 {
 182         ButtonPolicy::SMInput activate(ButtonPolicy::SMI_VALID);
 183
 184         if (ob == dialog_->button_go) {
 185                 // goto reference / go back
 186
 187                 // No change to data
 188                 activate = ButtonPolicy::SMI_NOOP;
 189
 190                 at_ref_ = !at_ref_;
 191                 if (at_ref_) {
 192                         controller().gotoRef(fl_get_input(dialog_->input_ref));
 193                         fl_set_object_label(dialog_->button_go, _("Go back"));
 194                 } else {
 195                         controller().gotoBookmark();
 196                         fl_set_object_label(dialog_->button_go,
 197                                             _("Go to reference"));
 198                 }
 199
 200         } else if (ob == dialog_->browser_refs) {
 201
 202                 unsigned int sel = fl_get_browser(dialog_->browser_refs);
 203                 if (sel < 1 || sel > refs_.size())
 204                         return ButtonPolicy::SMI_NOOP;
 205
 206                 if (!controller().bufferIsReadonly()) {
 207                         string s = fl_get_browser_line(dialog_->browser_refs, sel);
 208                         fl_set_input(dialog_->input_ref, s.c_str());
 209                 }
 210
 211                 if (at_ref_)
 212                         controller().gotoBookmark();
 213                 at_ref_ = false;
 214                 fl_set_object_label(dialog_->button_go, _("Go to reference"));
 215
 216                 setEnabled(dialog_->choice_type,      true);
 217                 setEnabled(dialog_->button_go, true);
 218                 fl_set_object_lcol(dialog_->input_ref, FL_BLACK);
 219
 220         } else if (ob == dialog_->button_update ||
 221                    ob == dialog_->check_sort ||
 222                    ob == dialog_->choice_buffer) {
 223
 224                 if (ob == dialog_->button_update ||
 225                     ob == dialog_->choice_buffer) {
 226                         string const name =
 227                                 controller().getBufferName(fl_get_choice(dialog_->choice_buffer) - 1);
 228                         refs_ = controller().getLabelList(name);
 229                 }
 230
 231                 fl_freeze_form(form());
 232                 updateBrowser(refs_);
 233                 fl_unfreeze_form(form());
 234
 235         } else if (ob == dialog_->choice_type) {
 236
 237                 int const type = fl_get_choice(dialog_->choice_type) - 1;
 238                 if (controller().params().getCmdName() ==
 239                     InsetRef::getName(type)) {
 240                         activate = ButtonPolicy::SMI_NOOP;
 241                 }
 242         }
 243
 244         return activate;
 245 }