src/frontends/xforms/FormRef.C

   1 // -*- C++ -*-
   2 /* This file is part of
   3  * ======================================================
   4  *
   5  *           LyX, The Document Processor
   6  *
   7  *           Copyright 2000 The LyX Team.
   8  *
   9  * ======================================================
  10  */
  11
  12 #include <config.h>
  13
  14 #include FORMS_H_LOCATION
  15
  16 #ifdef __GNUG__
  17 #pragma implementation
  18 #endif
  19
  20
  21 #include "Dialogs.h"
  22 #include "FormRef.h"
  23 #include "LyXView.h"
  24 #include "buffer.h"
  25 #include "form_ref.h"
  26 #include "lyxfunc.h"
  27 #include "insets/insetref.h"
  28
  29 #include <algorithm>
  30
  31 using std::find;
  32 using std::max;
  33 using std::sort;
  34 using std::vector;
  35
  36 FormRef::FormRef(LyXView * lv, Dialogs * d)
  37         : FormCommand(lv, d, _("Reference"), new NoRepeatedApplyPolicy),
  38           toggle(GOBACK), dialog_(0)
  39 {
  40         // let the dialog be shown
  41         // These are permanent connections so we won't bother
  42         // storing a copy because we won't be disconnecting.
  43         d->showRef.connect(slot(this, &FormRef::showInset));
  44         d->createRef.connect(slot(this, &FormRef::createInset));
  45 }
  46
  47
  48 FormRef::~FormRef()
  49 {
  50         delete dialog_;
  51 }
  52
  53
  54 FL_FORM * FormRef::form() const
  55 {
  56         if (dialog_) return dialog_->form;
  57         return 0;
  58 }
  59
  60
  61 void FormRef::disconnect()
  62 {
  63         refs.clear();
  64         FormCommand::disconnect();
  65 }
  66
  67
  68 void FormRef::build()
  69 {
  70         dialog_ = build_ref();
  71
  72         for (int i = 0; !InsetRef::types[i].latex_name.empty(); ++i)
  73                 fl_addto_choice(dialog_->type,
  74                                 _(InsetRef::types[i].gui_name.c_str()));
  75
  76         // Workaround dumb xforms sizing bug
  77         minw_ = form()->w;
  78         minh_ = form()->h;
  79
  80         // Force the user to use the browser to change refs.
  81         fl_deactivate_object(dialog_->ref);
  82
  83         // Manage the ok and cancel/close buttons
  84         bc_.setOK(dialog_->button_ok);
  85         bc_.setApply(dialog_->button_apply);
  86         bc_.setCancel(dialog_->button_cancel);
  87         bc_.setUndoAll(dialog_->button_restore);
  88         bc_.refresh();
  89
  90 #warning I had to uncomment this so the buttons could be disabled in update() (dekel)
  91         //bc_.addReadOnly(dialog_->type);
  92         //bc_.addReadOnly(dialog_->name);
  93 }
  94
  95
  96 void FormRef::update()
  97 {
  98         if (inset_) {
  99                 fl_set_input(dialog_->ref,  params.getContents().c_str());
 100                 fl_set_input(dialog_->name, params.getOptions().c_str());
 101                 fl_set_choice(dialog_->type,
 102                               InsetRef::getType(params.getCmdName()) + 1);
 103         }
 104
 105         toggle = GOBACK;
 106         fl_set_object_label(dialog_->button_go, _("Goto reference"));
 107
 108         // Name is irrelevant to LaTeX/Literate documents, while
 109         // type is irrelevant to LinuxDoc/DocBook.
 110         if (lv_->buffer()->isLatex() || lv_->buffer()->isLatex()) {
 111                 fl_deactivate_object(dialog_->name);
 112                 fl_set_object_lcol(dialog_->name, FL_INACTIVE);
 113                 fl_activate_object(dialog_->type);
 114                 fl_set_object_lcol(dialog_->type, FL_BLACK);
 115         } else {
 116                 fl_set_choice(dialog_->type, 1);
 117
 118                 fl_activate_object(dialog_->name);
 119                 fl_set_object_lcol(dialog_->name, FL_BLACK);
 120                 fl_deactivate_object(dialog_->type);
 121                 fl_set_object_lcol(dialog_->type, FL_INACTIVE);
 122         }
 123
 124         refs = lv_->buffer()->getLabelList();
 125         updateBrowser(refs);
 126
 127         bc_.readOnly(lv_->buffer()->isReadonly());
 128 }
 129
 130
 131 void FormRef::updateBrowser(vector<string> const & akeys) const
 132 {
 133         vector<string> keys(akeys);
 134         if (fl_get_button(dialog_->sort))
 135                 sort(keys.begin(), keys.end());
 136
 137         fl_clear_browser(dialog_->browser);
 138         for (vector<string>::const_iterator it = keys.begin();
 139              it != keys.end(); ++it)
 140                 fl_add_browser_line(dialog_->browser, (*it).c_str());
 141
 142         if (keys.empty()) {
 143                 fl_add_browser_line(dialog_->browser,
 144                                     _("*** No labels found in document ***"));
 145
 146                 fl_deactivate_object(dialog_->browser);
 147                 fl_deactivate_object(dialog_->sort);
 148                 fl_set_object_lcol(dialog_->browser, FL_INACTIVE);
 149                 fl_set_object_lcol(dialog_->sort, FL_INACTIVE);
 150                 fl_set_input(dialog_->ref, "");
 151         } else {
 152                 fl_activate_object(dialog_->browser);
 153                 fl_set_object_lcol(dialog_->browser, FL_BLACK);
 154                 fl_activate_object(dialog_->sort);
 155                 fl_set_object_lcol(dialog_->sort, FL_BLACK);
 156
 157                 string ref = fl_get_input(dialog_->ref);
 158                 vector<string>::const_iterator cit =
 159                         find(keys.begin(), keys.end(), ref);
 160                 if (cit == keys.end())
 161                         cit = keys.begin();
 162                 if (ref.empty())
 163                         fl_set_input(dialog_->ref, (*cit).c_str());
 164
 165                 int const i = static_cast<int>(cit - keys.begin());
 166                 fl_set_browser_topline(dialog_->browser, max(i-5, 1));
 167                 fl_select_browser_line(dialog_->browser, i+1);
 168         }
 169 }
 170
 171
 172 void FormRef::apply()
 173 {
 174         if (!lv_->view()->available())
 175                 return;
 176
 177         int const type = fl_get_choice(dialog_->type) - 1;
 178         params.setCmdName(InsetRef::getName(type));
 179
 180         params.setOptions(fl_get_input(dialog_->name));
 181         params.setContents(fl_get_input(dialog_->ref));
 182
 183         if (inset_ != 0) {
 184                 // Only update if contents have changed
 185                 if (params != inset_->params()) {
 186                         inset_->setParams(params);
 187                         lv_->view()->updateInset(inset_, true);
 188                 }
 189         } else {
 190                 lv_->getLyXFunc()->Dispatch(LFUN_REF_INSERT,
 191                                             params.getAsString());
 192         }
 193 }
 194
 195
 196 bool FormRef::input(FL_OBJECT *, long data)
 197 {
 198         bool activate(true);
 199         switch (data) {
 200         // goto reference / go back
 201         case 1:
 202         {
 203                 // No change to data
 204                 activate = false;
 205
 206                 toggle = static_cast<Goto>(toggle + 1);
 207                 if (toggle == GOFIRST ) toggle = GOREF;
 208
 209                 switch (toggle) {
 210                 case GOREF:
 211                 {
 212                         lv_->getLyXFunc()->
 213                                 Dispatch(LFUN_REF_GOTO,
 214                                          fl_get_input(dialog_->ref));
 215                         fl_set_object_label(dialog_->button_go, _("Go back"));
 216                 }
 217                 break;
 218
 219                 case GOBACK:
 220                 {
 221                         lv_->getLyXFunc()->Dispatch(LFUN_REF_BACK);
 222                         fl_set_object_label(dialog_->button_go,
 223                                             _("Goto reference"));
 224                 }
 225                 break;
 226
 227                 default:
 228                         break;
 229                 }
 230         }
 231         break;
 232
 233         // choose browser key
 234         case 2:
 235         {
 236                 unsigned int sel = fl_get_browser(dialog_->browser);
 237                 if (sel < 1 || sel > refs.size()) break;
 238
 239                 if (!lv_->buffer()->isReadonly()) {
 240                         string s = fl_get_browser_line(dialog_->browser, sel);
 241                         fl_set_input(dialog_->ref, s.c_str());
 242                 }
 243
 244                 toggle = GOBACK;
 245                 lv_->getLyXFunc()->Dispatch(LFUN_REF_BACK);
 246                 fl_set_object_label(dialog_->button_go, _("Goto reference"));
 247
 248                 fl_activate_object(dialog_->type);
 249                 fl_set_object_lcol(dialog_->type, FL_BLACK);
 250                 fl_activate_object(dialog_->button_go);
 251                 fl_set_object_lcol(dialog_->button_go, FL_BLACK);
 252                 fl_set_object_lcol(dialog_->ref, FL_BLACK);
 253         }
 254         break;
 255
 256         // update or sort
 257         case 3:
 258                 refs = lv_->buffer()->getLabelList();
 259
 260                 // fall through to...
 261         case 4:
 262                 fl_freeze_form(form());
 263                 updateBrowser(refs);
 264                 fl_unfreeze_form(form());
 265                 break;
 266
 267         // changed reference type
 268         case 5:
 269         {
 270                 int const type = fl_get_choice(dialog_->type) - 1;
 271                 if (params.getCmdName() == InsetRef::getName(type) && inset_) {
 272                         activate = false;
 273                 }
 274         }
 275         break;
 276
 277         default:
 278                 break;
 279         }
 280
 281         return activate;
 282 }
 283
 284