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