src/frontends/qt4/GuiDocument.cpp

   1 /**
   2  * \file GuiDocument.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Edwin Leuven
   7  * \author Richard Heck (modules)
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "GuiDocument.h"
  15
  16 #include "GuiApplication.h"
  17 #include "GuiBranches.h"
  18 #include "GuiIndices.h"
  19 #include "GuiSelectionManager.h"
  20 #include "LaTeXHighlighter.h"
  21 #include "LengthCombo.h"
  22 #include "PanelStack.h"
  23 #include "Validator.h"
  24
  25 #include "LayoutFile.h"
  26 #include "BranchList.h"
  27 #include "buffer_funcs.h"
  28 #include "Buffer.h"
  29 #include "BufferParams.h"
  30 #include "BufferView.h"
  31 #include "Color.h"
  32 #include "ColorCache.h"
  33 #include "Encoding.h"
  34 #include "FloatPlacement.h"
  35 #include "Format.h"
  36 #include "FuncRequest.h"
  37 #include "HSpace.h"
  38 #include "IndicesList.h"
  39 #include "Language.h"
  40 #include "LaTeXFeatures.h"
  41 #include "Layout.h"
  42 #include "LayoutModuleList.h"
  43 #include "LyXRC.h"
  44 #include "ModuleList.h"
  45 #include "OutputParams.h"
  46 #include "PDFOptions.h"
  47 #include "qt_helpers.h"
  48 #include "Spacing.h"
  49 #include "TextClass.h"
  50
  51 #include "insets/InsetListingsParams.h"
  52
  53 #include "support/debug.h"
  54 #include "support/FileName.h"
  55 #include "support/filetools.h"
  56 #include "support/gettext.h"
  57 #include "support/lstrings.h"
  58
  59 #include "frontends/alert.h"
  60
  61 #include <QAbstractItemModel>
  62 #include <QHeaderView>
  63 #include <QColor>
  64 #include <QColorDialog>
  65 #include <QCloseEvent>
  66 #include <QFontDatabase>
  67 #include <QScrollBar>
  68 #include <QTextCursor>
  69
  70 #include <sstream>
  71 #include <vector>
  72
  73 #ifdef IN
  74 #undef IN
  75 #endif
  76
  77
  78 // a style sheet for buttons
  79 // this is for example used for the background color setting button
  80 static inline QString colorButtonStyleSheet(QColor const & bgColor)
  81 {
  82         if (bgColor.isValid()) {
  83                 QString rc = QLatin1String("background-color:");
  84                 rc += bgColor.name();
  85                 return rc;
  86         }
  87         return QString();
  88 }
  89
  90
  91 using namespace std;
  92 using namespace lyx::support;
  93
  94
  95 namespace {
  96
  97 char const * const tex_graphics[] =
  98 {
  99         "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
 100         "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
 101         "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
 102         "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
 103         "xetex", "none", ""
 104 };
 105
 106
 107 char const * const tex_graphics_gui[] =
 108 {
 109         N_("Default"), "dvialw", "DviLaser", "dvipdf", "DVIPDFM", "DVIPDFMx",
 110         "Dvips", "DVIPSONE", "DVItoPS", "DVIWIN", "DVIWindo", "dvi2ps", "EmTeX",
 111         "LN", "OzTeX", "pctexhp", "pctexps", "pctexwin", "PCTeX32", "pdfTeX",
 112         "psprint", "pubps", "tcidvi", "Textures", "TrueTeX", "VTeX", "xdvi",
 113         "XeTeX", N_("None"), ""
 114 };
 115
 116
 117 char const * const tex_fonts_roman[] =
 118 {
 119         "default", "cmr", "lmodern", "ae", "times", "palatino",
 120         "charter", "newcent", "bookman", "utopia", "beraserif",
 121         "ccfonts", "chancery", ""
 122 };
 123
 124
 125 char const * tex_fonts_roman_gui[] =
 126 {
 127         N_("Default"), N_("Computer Modern Roman"), N_("Latin Modern Roman"),
 128         N_("AE (Almost European)"), N_("Times Roman"), N_("Palatino"),
 129         N_("Bitstream Charter"), N_("New Century Schoolbook"), N_("Bookman"),
 130         N_("Utopia"),  N_("Bera Serif"), N_("Concrete Roman"), N_("Zapf Chancery"),
 131         ""
 132 };
 133
 134
 135 char const * const tex_fonts_sans[] =
 136 {
 137         "default", "cmss", "lmss", "helvet", "avant", "berasans", "cmbr", ""
 138 };
 139
 140
 141 char const * tex_fonts_sans_gui[] =
 142 {
 143         N_("Default"), N_("Computer Modern Sans"), N_("Latin Modern Sans"),
 144         N_("Helvetica"), N_("Avant Garde"), N_("Bera Sans"), N_("CM Bright"), ""
 145 };
 146
 147
 148 char const * const tex_fonts_monospaced[] =
 149 {
 150         "default", "cmtt", "lmtt", "courier", "beramono", "luximono", "cmtl", ""
 151 };
 152
 153
 154 char const * tex_fonts_monospaced_gui[] =
 155 {
 156         N_("Default"), N_("Computer Modern Typewriter"),
 157         N_("Latin Modern Typewriter"), N_("Courier"), N_("Bera Mono"),
 158         N_("LuxiMono"), N_("CM Typewriter Light"), ""
 159 };
 160
 161
 162 char const * backref_opts[] =
 163 {
 164         "false", "section", "slide", "page", ""
 165 };
 166
 167
 168 char const * backref_opts_gui[] =
 169 {
 170         N_("Off"), N_("Section"), N_("Slide"), N_("Page"), ""
 171 };
 172
 173
 174 vector<pair<string, QString> > pagestyles;
 175
 176
 177 } // anonymous namespace
 178
 179 namespace lyx {
 180
 181 RGBColor set_backgroundcolor;
 182 bool is_backgroundcolor;
 183 RGBColor set_fontcolor;
 184 bool is_fontcolor;
 185 RGBColor set_notefontcolor;
 186 RGBColor set_boxbgcolor;
 187
 188 namespace {
 189 // used when sorting the textclass list.
 190 class less_textclass_avail_desc
 191         : public binary_function<string, string, int>
 192 {
 193 public:
 194         bool operator()(string const & lhs, string const & rhs) const
 195         {
 196                 // Ordering criteria:
 197                 //   1. Availability of text class
 198                 //   2. Description (lexicographic)
 199                 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
 200                 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
 201                 int const order = compare_no_case(
 202                         translateIfPossible(from_utf8(tc1.description())),
 203                         translateIfPossible(from_utf8(tc2.description())));
 204                 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
 205                         (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && order < 0);
 206         }
 207 };
 208
 209 }
 210
 211 namespace frontend {
 212 namespace {
 213
 214 vector<string> getRequiredList(string const & modName)
 215 {
 216         LyXModule const * const mod = theModuleList[modName];
 217         if (!mod)
 218                 return vector<string>(); //empty such thing
 219         return mod->getRequiredModules();
 220 }
 221
 222
 223 vector<string> getExcludedList(string const & modName)
 224 {
 225         LyXModule const * const mod = theModuleList[modName];
 226         if (!mod)
 227                 return vector<string>(); //empty such thing
 228         return mod->getExcludedModules();
 229 }
 230
 231
 232 docstring getModuleDescription(string const & modName)
 233 {
 234         LyXModule const * const mod = theModuleList[modName];
 235         if (!mod)
 236                 return _("Module not found!");
 237         // FIXME Unicode
 238         return translateIfPossible(from_utf8(mod->getDescription()));
 239 }
 240
 241
 242 vector<string> getPackageList(string const & modName)
 243 {
 244         LyXModule const * const mod = theModuleList[modName];
 245         if (!mod)
 246                 return vector<string>(); //empty such thing
 247         return mod->getPackageList();
 248 }
 249
 250
 251 bool isModuleAvailable(string const & modName)
 252 {
 253         LyXModule const * const mod = theModuleList[modName];
 254         if (!mod)
 255                 return false;
 256         return mod->isAvailable();
 257 }
 258
 259 } // anonymous namespace
 260
 261
 262 /////////////////////////////////////////////////////////////////////
 263 //
 264 // ModuleSelectionManager
 265 //
 266 /////////////////////////////////////////////////////////////////////
 267
 268 /// SelectionManager for use with modules
 269 class ModuleSelectionManager : public GuiSelectionManager
 270 {
 271 public:
 272         ///
 273         ModuleSelectionManager(
 274                 QTreeView * availableLV,
 275                 QListView * selectedLV,
 276                 QPushButton * addPB,
 277                 QPushButton * delPB,
 278                 QPushButton * upPB,
 279                 QPushButton * downPB,
 280                 GuiIdListModel * availableModel,
 281                 GuiIdListModel * selectedModel,
 282                 GuiDocument const * container)
 283         : GuiSelectionManager(availableLV, selectedLV, addPB, delPB,
 284                                 upPB, downPB, availableModel, selectedModel), container_(container)
 285                 {}
 286         ///
 287         void updateProvidedModules(LayoutModuleList const & pm)
 288                         { provided_modules_ = pm.list(); }
 289         ///
 290         void updateExcludedModules(LayoutModuleList const & em)
 291                         { excluded_modules_ = em.list(); }
 292 private:
 293         ///
 294         virtual void updateAddPB();
 295         ///
 296         virtual void updateUpPB();
 297         ///
 298         virtual void updateDownPB();
 299         ///
 300         virtual void updateDelPB();
 301         /// returns availableModel as a GuiIdListModel
 302         GuiIdListModel * getAvailableModel()
 303         {
 304                 return dynamic_cast<GuiIdListModel *>(availableModel);
 305         }
 306         /// returns selectedModel as a GuiIdListModel
 307         GuiIdListModel * getSelectedModel()
 308         {
 309                 return dynamic_cast<GuiIdListModel *>(selectedModel);
 310         }
 311         /// keeps a list of the modules the text class provides
 312         list<string> provided_modules_;
 313         /// similarly...
 314         list<string> excluded_modules_;
 315         ///
 316         GuiDocument const * container_;
 317 };
 318
 319 void ModuleSelectionManager::updateAddPB()
 320 {
 321         int const arows = availableModel->rowCount();
 322         QModelIndexList const avail_sels =
 323                         availableLV->selectionModel()->selectedIndexes();
 324
 325         // disable if there aren't any modules (?), if none of them is chosen
 326         // in the dialog, or if the chosen one is already selected for use.
 327         if (arows == 0 || avail_sels.isEmpty() || isSelected(avail_sels.first())) {
 328                 addPB->setEnabled(false);
 329                 return;
 330         }
 331
 332         QModelIndex const & idx = availableLV->selectionModel()->currentIndex();
 333         string const modname = getAvailableModel()->getIDString(idx.row());
 334
 335         bool const enable =
 336                 container_->params().moduleCanBeAdded(modname);
 337         addPB->setEnabled(enable);
 338 }
 339
 340
 341 void ModuleSelectionManager::updateDownPB()
 342 {
 343         int const srows = selectedModel->rowCount();
 344         if (srows == 0) {
 345                 downPB->setEnabled(false);
 346                 return;
 347         }
 348         QModelIndex const & curidx = selectedLV->selectionModel()->currentIndex();
 349         int const curRow = curidx.row();
 350         if (curRow < 0 || curRow >= srows - 1) { // invalid or last item
 351                 downPB->setEnabled(false);
 352                 return;
 353         }
 354
 355         // determine whether immediately succeding element requires this one
 356         string const curmodname = getSelectedModel()->getIDString(curRow);
 357         string const nextmodname = getSelectedModel()->getIDString(curRow + 1);
 358
 359         vector<string> reqs = getRequiredList(nextmodname);
 360
 361         // if it doesn't require anything....
 362         if (reqs.empty()) {
 363                 downPB->setEnabled(true);
 364                 return;
 365         }
 366
 367         // Enable it if this module isn't required.
 368         // FIXME This should perhaps be more flexible and check whether, even
 369         // if the next one is required, there is also an earlier one that will do.
 370         downPB->setEnabled(
 371                         find(reqs.begin(), reqs.end(), curmodname) == reqs.end());
 372 }
 373
 374 void ModuleSelectionManager::updateUpPB()
 375 {
 376         int const srows = selectedModel->rowCount();
 377         if (srows == 0) {
 378                 upPB->setEnabled(false);
 379                 return;
 380         }
 381
 382         QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
 383         int curRow = curIdx.row();
 384         if (curRow <= 0 || curRow > srows - 1) { // first item or invalid
 385                 upPB->setEnabled(false);
 386                 return;
 387         }
 388         string const curmodname = getSelectedModel()->getIDString(curRow);
 389
 390         // determine whether immediately preceding element is required by this one
 391         vector<string> reqs = getRequiredList(curmodname);
 392
 393         // if this one doesn't require anything....
 394         if (reqs.empty()) {
 395                 upPB->setEnabled(true);
 396                 return;
 397         }
 398
 399
 400         // Enable it if the preceding module isn't required.
 401         // NOTE This is less flexible than it might be. We could check whether, even
 402         // if the previous one is required, there is an earlier one that would do.
 403         string const premod = getSelectedModel()->getIDString(curRow - 1);
 404         upPB->setEnabled(find(reqs.begin(), reqs.end(), premod) == reqs.end());
 405 }
 406
 407 void ModuleSelectionManager::updateDelPB()
 408 {
 409         int const srows = selectedModel->rowCount();
 410         if (srows == 0) {
 411                 deletePB->setEnabled(false);
 412                 return;
 413         }
 414
 415         QModelIndex const & curidx =
 416                 selectedLV->selectionModel()->currentIndex();
 417         int const curRow = curidx.row();
 418         if (curRow < 0 || curRow >= srows) { // invalid index?
 419                 deletePB->setEnabled(false);
 420                 return;
 421         }
 422
 423         string const curmodname = getSelectedModel()->getIDString(curRow);
 424
 425         // We're looking here for a reason NOT to enable the button. If we
 426         // find one, we disable it and return. If we don't, we'll end up at
 427         // the end of the function, and then we enable it.
 428         for (int i = curRow + 1; i < srows; ++i) {
 429                 string const thisMod = getSelectedModel()->getIDString(i);
 430                 vector<string> reqs = getRequiredList(thisMod);
 431                 //does this one require us?
 432                 if (find(reqs.begin(), reqs.end(), curmodname) == reqs.end())
 433                         //no...
 434                         continue;
 435
 436                 // OK, so this module requires us
 437                 // is there an EARLIER module that also satisfies the require?
 438                 // NOTE We demand that it be earlier to keep the list of modules
 439                 // consistent with the rule that a module must be proceeded by a
 440                 // required module. There would be more flexible ways to proceed,
 441                 // but that would be a lot more complicated, and the logic here is
 442                 // already complicated. (That's why I've left the debugging code.)
 443                 // lyxerr << "Testing " << thisMod << endl;
 444                 bool foundone = false;
 445                 for (int j = 0; j < curRow; ++j) {
 446                         string const mod = getSelectedModel()->getIDString(j);
 447                         // lyxerr << "In loop: Testing " << mod << endl;
 448                         // do we satisfy the require?
 449                         if (find(reqs.begin(), reqs.end(), mod) != reqs.end()) {
 450                                 // lyxerr << mod << " does the trick." << endl;
 451                                 foundone = true;
 452                                 break;
 453                         }
 454                 }
 455                 // did we find a module to satisfy the require?
 456                 if (!foundone) {
 457                         // lyxerr << "No matching module found." << endl;
 458                         deletePB->setEnabled(false);
 459                         return;
 460                 }
 461         }
 462         // lyxerr << "All's well that ends well." << endl;
 463         deletePB->setEnabled(true);
 464 }
 465
 466
 467 /////////////////////////////////////////////////////////////////////
 468 //
 469 // PreambleModule
 470 //
 471 /////////////////////////////////////////////////////////////////////
 472
 473 PreambleModule::PreambleModule() : current_id_(0)
 474 {
 475         // This is not a memory leak. The object will be destroyed
 476         // with this.
 477         (void) new LaTeXHighlighter(preambleTE->document());
 478         setFocusProxy(preambleTE);
 479         connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
 480 }
 481
 482
 483 void PreambleModule::update(BufferParams const & params, BufferId id)
 484 {
 485         QString preamble = toqstr(params.preamble);
 486         // Nothing to do if the params and preamble are unchanged.
 487         if (id == current_id_
 488                 && preamble == preambleTE->document()->toPlainText())
 489                 return;
 490
 491         QTextCursor cur = preambleTE->textCursor();
 492         // Save the coords before switching to the new one.
 493         preamble_coords_[current_id_] =
 494                 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
 495
 496         // Save the params address for further use.
 497         current_id_ = id;
 498         preambleTE->document()->setPlainText(preamble);
 499         Coords::const_iterator it = preamble_coords_.find(current_id_);
 500         if (it == preamble_coords_.end())
 501                 // First time we open this one.
 502                 preamble_coords_[current_id_] = make_pair(0, 0);
 503         else {
 504                 // Restore saved coords.
 505                 QTextCursor cur = preambleTE->textCursor();
 506                 cur.setPosition(it->second.first);
 507                 preambleTE->setTextCursor(cur);
 508                 preambleTE->verticalScrollBar()->setValue(it->second.second);
 509         }
 510 }
 511
 512
 513 void PreambleModule::apply(BufferParams & params)
 514 {
 515         params.preamble = fromqstr(preambleTE->document()->toPlainText());
 516 }
 517
 518
 519 void PreambleModule::closeEvent(QCloseEvent * e)
 520 {
 521         // Save the coords before closing.
 522         QTextCursor cur = preambleTE->textCursor();
 523         preamble_coords_[current_id_] =
 524                 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
 525         e->accept();
 526 }
 527
 528
 529 /////////////////////////////////////////////////////////////////////
 530 //
 531 // LocalLayout
 532 //
 533 /////////////////////////////////////////////////////////////////////
 534
 535
 536 LocalLayout::LocalLayout() : current_id_(0), is_valid_(false)
 537 {
 538         connect(locallayoutTE, SIGNAL(textChanged()), this, SLOT(textChanged()));
 539         connect(validatePB, SIGNAL(clicked()), this, SLOT(validatePressed()));
 540         connect(convertPB, SIGNAL(clicked()), this, SLOT(convertPressed()));
 541 }
 542
 543
 544 void LocalLayout::update(BufferParams const & params, BufferId id)
 545 {
 546         QString layout = toqstr(params.local_layout);
 547         // Nothing to do if the params and preamble are unchanged.
 548         if (id == current_id_
 549                 && layout == locallayoutTE->document()->toPlainText())
 550                 return;
 551
 552         // Save the params address for further use.
 553         current_id_ = id;
 554         locallayoutTE->document()->setPlainText(layout);
 555         validate();
 556 }
 557
 558
 559 void LocalLayout::apply(BufferParams & params)
 560 {
 561         string const layout = fromqstr(locallayoutTE->document()->toPlainText());
 562         params.local_layout = layout;
 563 }
 564
 565
 566 void LocalLayout::textChanged()
 567 {
 568         static const QString unknown = qt_("Press button to check validity...");
 569
 570         is_valid_ = false;
 571         validLB->setText(unknown);
 572         validatePB->setEnabled(true);
 573         convertPB->setEnabled(false);
 574         changed();
 575 }
 576
 577
 578 void LocalLayout::convert() {
 579         string const layout =
 580                 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
 581         string const newlayout = TextClass::convert(layout);
 582         LYXERR0(newlayout);
 583         if (newlayout.empty()) {
 584                 Alert::error(_("Conversion Failed!"),
 585                       _("Failed to convert local layout to current format."));
 586         } else {
 587                 locallayoutTE->setPlainText(toqstr(newlayout));
 588         }
 589         validate();
 590 }
 591
 592
 593 void LocalLayout::convertPressed() {
 594         convert();
 595         changed();
 596 }
 597
 598
 599 void LocalLayout::validate() {
 600         static const QString valid = qt_("Layout is valid!");
 601         static const QString vtext =
 602                 toqstr("<p style=\"font-weight: bold; \">")
 603                   + valid + toqstr("</p>");
 604         static const QString invalid = qt_("Layout is invalid!");
 605         static const QString ivtext =
 606                 toqstr("<p style=\"color: #c00000; font-weight: bold; \">")
 607                   + invalid + toqstr("</p>");
 608
 609         string const layout =
 610                 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
 611         if (layout.empty()) {
 612                 is_valid_ = true;
 613                 validatePB->setEnabled(false);
 614                 validLB->setText("");
 615                 convertPB->hide();
 616                 convertLB->hide();
 617         } else {
 618                 TextClass::ReturnValues const ret = TextClass::validate(layout);
 619                 is_valid_ = (ret == TextClass::OK) || (ret == TextClass::OK_OLDFORMAT);
 620                 validatePB->setEnabled(false);
 621                 validLB->setText(is_valid_ ? vtext : ivtext);
 622                 if (ret == TextClass::OK_OLDFORMAT) {
 623                         convertPB->show();
 624                         convertPB->setEnabled(true);
 625                         convertLB->setText(qt_("Convert to current format"));
 626                         convertLB->show();
 627                 } else {
 628                         convertPB->hide();
 629                         convertLB->hide();
 630                 }
 631         }
 632 }
 633
 634
 635 void LocalLayout::validatePressed() {
 636         validate();
 637         changed();
 638 }
 639
 640
 641 /////////////////////////////////////////////////////////////////////
 642 //
 643 // DocumentDialog
 644 //
 645 /////////////////////////////////////////////////////////////////////
 646
 647
 648 GuiDocument::GuiDocument(GuiView & lv)
 649         : GuiDialog(lv, "document", qt_("Document Settings"))
 650 {
 651         setupUi(this);
 652
 653         connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
 654         connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
 655         connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
 656         connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
 657
 658         connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
 659         connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
 660
 661         // Manage the restore, ok, apply, restore and cancel/close buttons
 662         bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
 663         bc().setOK(okPB);
 664         bc().setApply(applyPB);
 665         bc().setCancel(closePB);
 666         bc().setRestore(restorePB);
 667
 668
 669         // text layout
 670         textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
 671         connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
 672                 this, SLOT(change_adaptor()));
 673         connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
 674                 this, SLOT(setLSpacing(int)));
 675         connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
 676                 this, SLOT(change_adaptor()));
 677
 678         connect(textLayoutModule->indentRB, SIGNAL(clicked()),
 679                 this, SLOT(change_adaptor()));
 680         connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
 681                 textLayoutModule->indentCO, SLOT(setEnabled(bool)));
 682         connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
 683                 this, SLOT(change_adaptor()));
 684         connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
 685                 this, SLOT(setIndent(int)));
 686         connect(textLayoutModule->indentLE, SIGNAL(textChanged(const QString &)),
 687                 this, SLOT(change_adaptor()));
 688         connect(textLayoutModule->indentLengthCO, SIGNAL(activated(int)),
 689                 this, SLOT(change_adaptor()));
 690
 691         connect(textLayoutModule->skipRB, SIGNAL(clicked()),
 692                 this, SLOT(change_adaptor()));
 693         connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
 694                 textLayoutModule->skipCO, SLOT(setEnabled(bool)));
 695         connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
 696                 this, SLOT(change_adaptor()));
 697         connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
 698                 this, SLOT(setSkip(int)));
 699         connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
 700                 this, SLOT(change_adaptor()));
 701         connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
 702                 this, SLOT(change_adaptor()));
 703
 704         connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
 705                 this, SLOT(enableIndent(bool)));
 706         connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
 707                 this, SLOT(enableSkip(bool)));
 708
 709         connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
 710                 this, SLOT(change_adaptor()));
 711         connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
 712                 this, SLOT(setColSep()));
 713         connect(textLayoutModule->justCB, SIGNAL(clicked()),
 714                 this, SLOT(change_adaptor()));
 715
 716         textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
 717                 textLayoutModule->lspacingLE));
 718         textLayoutModule->indentLE->setValidator(unsignedLengthValidator(
 719                 textLayoutModule->indentLE));
 720         textLayoutModule->skipLE->setValidator(unsignedGlueLengthValidator(
 721                 textLayoutModule->skipLE));
 722
 723         textLayoutModule->indentCO->addItem(qt_("Default"));
 724         textLayoutModule->indentCO->addItem(qt_("Custom"));
 725         textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
 726         textLayoutModule->skipCO->addItem(qt_("MedSkip"));
 727         textLayoutModule->skipCO->addItem(qt_("BigSkip"));
 728         textLayoutModule->skipCO->addItem(qt_("Custom"));
 729         textLayoutModule->lspacingCO->insertItem(
 730                 Spacing::Single, qt_("Single"));
 731         textLayoutModule->lspacingCO->insertItem(
 732                 Spacing::Onehalf, qt_("OneHalf"));
 733         textLayoutModule->lspacingCO->insertItem(
 734                 Spacing::Double, qt_("Double"));
 735         textLayoutModule->lspacingCO->insertItem(
 736                 Spacing::Other, qt_("Custom"));
 737         // initialize the length validator
 738         bc().addCheckedLineEdit(textLayoutModule->indentLE);
 739         bc().addCheckedLineEdit(textLayoutModule->skipLE);
 740
 741
 742         // master/child handling
 743         masterChildModule = new UiWidget<Ui::MasterChildUi>;
 744
 745         connect(masterChildModule->childrenTW, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
 746                 this, SLOT(includeonlyClicked(QTreeWidgetItem *, int)));
 747         connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
 748                 masterChildModule->childrenTW, SLOT(setEnabled(bool)));
 749         connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
 750                 masterChildModule->maintainAuxCB, SLOT(setEnabled(bool)));
 751         connect(masterChildModule->includeallRB, SIGNAL(clicked()),
 752                 this, SLOT(change_adaptor()));
 753         connect(masterChildModule->includeonlyRB, SIGNAL(clicked()),
 754                 this, SLOT(change_adaptor()));
 755         connect(masterChildModule->maintainAuxCB, SIGNAL(clicked()),
 756                 this, SLOT(change_adaptor()));
 757         masterChildModule->childrenTW->setColumnCount(2);
 758         masterChildModule->childrenTW->headerItem()->setText(0, qt_("Child Document"));
 759         masterChildModule->childrenTW->headerItem()->setText(1, qt_("Include to Output"));
 760         masterChildModule->childrenTW->resizeColumnToContents(1);
 761         masterChildModule->childrenTW->resizeColumnToContents(2);
 762
 763
 764         // output
 765         outputModule = new UiWidget<Ui::OutputUi>;
 766
 767         connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
 768                 this, SLOT(change_adaptor()));
 769         connect(outputModule->mathimgSB, SIGNAL(valueChanged(double)),
 770                 this, SLOT(change_adaptor()));
 771         connect(outputModule->strictCB, SIGNAL(stateChanged(int)),
 772                 this, SLOT(change_adaptor()));
 773         connect(outputModule->cssCB, SIGNAL(stateChanged(int)),
 774                 this, SLOT(change_adaptor()));
 775         connect(outputModule->mathoutCB, SIGNAL(currentIndexChanged(int)),
 776                 this, SLOT(change_adaptor()));
 777
 778         connect(outputModule->outputsyncCB, SIGNAL(clicked()),
 779                 this, SLOT(change_adaptor()));
 780         connect(outputModule->synccustomCB, SIGNAL(editTextChanged(QString)),
 781                 this, SLOT(change_adaptor()));
 782         outputModule->synccustomCB->addItem("");
 783         outputModule->synccustomCB->addItem("\\synctex=1");
 784         outputModule->synccustomCB->addItem("\\synctex=-1");
 785         outputModule->synccustomCB->addItem("\\usepackage[active]{srcltx}");
 786
 787         outputModule->synccustomCB->setValidator(new NoNewLineValidator(
 788                 outputModule->synccustomCB));
 789
 790         // fonts
 791         fontModule = new UiWidget<Ui::FontUi>;
 792         connect(fontModule->osFontsCB, SIGNAL(clicked()),
 793                 this, SLOT(change_adaptor()));
 794         connect(fontModule->osFontsCB, SIGNAL(toggled(bool)),
 795                 this, SLOT(osFontsChanged(bool)));
 796         connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
 797                 this, SLOT(change_adaptor()));
 798         connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
 799                 this, SLOT(romanChanged(int)));
 800         connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
 801                 this, SLOT(change_adaptor()));
 802         connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
 803                 this, SLOT(sansChanged(int)));
 804         connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
 805                 this, SLOT(change_adaptor()));
 806         connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
 807                 this, SLOT(ttChanged(int)));
 808         connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
 809                 this, SLOT(change_adaptor()));
 810         connect(fontModule->fontencCO, SIGNAL(activated(int)),
 811                 this, SLOT(change_adaptor()));
 812         connect(fontModule->fontencCO, SIGNAL(activated(int)),
 813                 this, SLOT(fontencChanged(int)));
 814         connect(fontModule->fontencLE, SIGNAL(textChanged(const QString &)),
 815                 this, SLOT(change_adaptor()));
 816         connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
 817                 this, SLOT(change_adaptor()));
 818         connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
 819                 this, SLOT(change_adaptor()));
 820         connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
 821                 this, SLOT(change_adaptor()));
 822         connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
 823                 this, SLOT(change_adaptor()));
 824         connect(fontModule->fontScCB, SIGNAL(clicked()),
 825                 this, SLOT(change_adaptor()));
 826         connect(fontModule->fontOsfCB, SIGNAL(clicked()),
 827                 this, SLOT(change_adaptor()));
 828
 829         fontModule->fontencLE->setValidator(new NoNewLineValidator(
 830                 fontModule->fontencLE));
 831         fontModule->cjkFontLE->setValidator(new NoNewLineValidator(
 832                 fontModule->cjkFontLE));
 833
 834         updateFontlist();
 835
 836         fontModule->fontsizeCO->addItem(qt_("Default"));
 837         fontModule->fontsizeCO->addItem(qt_("10"));
 838         fontModule->fontsizeCO->addItem(qt_("11"));
 839         fontModule->fontsizeCO->addItem(qt_("12"));
 840
 841         fontModule->fontencCO->addItem(qt_("Default"));
 842         fontModule->fontencCO->addItem(qt_("Custom"));
 843         fontModule->fontencCO->addItem(qt_("None (no fontenc)"));
 844
 845         for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
 846                 fontModule->fontsDefaultCO->addItem(
 847                         qt_(GuiDocument::fontfamilies_gui[n]));
 848
 849         if (!LaTeXFeatures::isAvailable("fontspec"))
 850                 fontModule->osFontsCB->setToolTip(
 851                         qt_("Use OpenType and TrueType fonts directly (requires XeTeX or LuaTeX)\n"
 852                             "You need to install the package \"fontspec\" to use this feature"));
 853
 854
 855         // page layout
 856         pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
 857         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 858                 this, SLOT(papersizeChanged(int)));
 859         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 860                 this, SLOT(papersizeChanged(int)));
 861         connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
 862                 this, SLOT(change_adaptor()));
 863         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 864                 this, SLOT(change_adaptor()));
 865         connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
 866                 this, SLOT(change_adaptor()));
 867         connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
 868                 this, SLOT(change_adaptor()));
 869         connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
 870                 this, SLOT(change_adaptor()));
 871         connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
 872                 this, SLOT(change_adaptor()));
 873         connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
 874                 this, SLOT(change_adaptor()));
 875         connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
 876                 this, SLOT(change_adaptor()));
 877         connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
 878                 this, SLOT(change_adaptor()));
 879         connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
 880                 this, SLOT(change_adaptor()));
 881
 882         pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
 883         pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
 884         pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
 885         pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
 886         pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
 887         bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
 888                 pageLayoutModule->paperheightL);
 889         bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
 890                 pageLayoutModule->paperwidthL);
 891
 892         QComboBox * cb = pageLayoutModule->papersizeCO;
 893         cb->addItem(qt_("Default"));
 894         cb->addItem(qt_("Custom"));
 895         cb->addItem(qt_("US letter"));
 896         cb->addItem(qt_("US legal"));
 897         cb->addItem(qt_("US executive"));
 898         cb->addItem(qt_("A0"));
 899         cb->addItem(qt_("A1"));
 900         cb->addItem(qt_("A2"));
 901         cb->addItem(qt_("A3"));
 902         cb->addItem(qt_("A4"));
 903         cb->addItem(qt_("A5"));
 904         cb->addItem(qt_("A6"));
 905         cb->addItem(qt_("B0"));
 906         cb->addItem(qt_("B1"));
 907         cb->addItem(qt_("B2"));
 908         cb->addItem(qt_("B3"));
 909         cb->addItem(qt_("B4"));
 910         cb->addItem(qt_("B5"));
 911         cb->addItem(qt_("B6"));
 912         cb->addItem(qt_("C0"));
 913         cb->addItem(qt_("C1"));
 914         cb->addItem(qt_("C2"));
 915         cb->addItem(qt_("C3"));
 916         cb->addItem(qt_("C4"));
 917         cb->addItem(qt_("C5"));
 918         cb->addItem(qt_("C6"));
 919         cb->addItem(qt_("JIS B0"));
 920         cb->addItem(qt_("JIS B1"));
 921         cb->addItem(qt_("JIS B2"));
 922         cb->addItem(qt_("JIS B3"));
 923         cb->addItem(qt_("JIS B4"));
 924         cb->addItem(qt_("JIS B5"));
 925         cb->addItem(qt_("JIS B6"));
 926         // remove the %-items from the unit choice
 927         pageLayoutModule->paperwidthUnitCO->noPercents();
 928         pageLayoutModule->paperheightUnitCO->noPercents();
 929         pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
 930                 pageLayoutModule->paperheightLE));
 931         pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
 932                 pageLayoutModule->paperwidthLE));
 933
 934
 935         // margins
 936         marginsModule = new UiWidget<Ui::MarginsUi>;
 937         connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
 938                 this, SLOT(setCustomMargins(bool)));
 939         connect(marginsModule->marginCB, SIGNAL(clicked()),
 940                 this, SLOT(change_adaptor()));
 941         connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
 942                 this, SLOT(change_adaptor()));
 943         connect(marginsModule->topUnit, SIGNAL(activated(int)),
 944                 this, SLOT(change_adaptor()));
 945         connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
 946                 this, SLOT(change_adaptor()));
 947         connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
 948                 this, SLOT(change_adaptor()));
 949         connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
 950                 this, SLOT(change_adaptor()));
 951         connect(marginsModule->innerUnit, SIGNAL(activated(int)),
 952                 this, SLOT(change_adaptor()));
 953         connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
 954                 this, SLOT(change_adaptor()));
 955         connect(marginsModule->outerUnit, SIGNAL(activated(int)),
 956                 this, SLOT(change_adaptor()));
 957         connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
 958                 this, SLOT(change_adaptor()));
 959         connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
 960                 this, SLOT(change_adaptor()));
 961         connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
 962                 this, SLOT(change_adaptor()));
 963         connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
 964                 this, SLOT(change_adaptor()));
 965         connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
 966                 this, SLOT(change_adaptor()));
 967         connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
 968                 this, SLOT(change_adaptor()));
 969         connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
 970                 this, SLOT(change_adaptor()));
 971         connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
 972                 this, SLOT(change_adaptor()));
 973         marginsModule->topLE->setValidator(unsignedLengthValidator(
 974                 marginsModule->topLE));
 975         marginsModule->bottomLE->setValidator(unsignedLengthValidator(
 976                 marginsModule->bottomLE));
 977         marginsModule->innerLE->setValidator(unsignedLengthValidator(
 978                 marginsModule->innerLE));
 979         marginsModule->outerLE->setValidator(unsignedLengthValidator(
 980                 marginsModule->outerLE));
 981         marginsModule->headsepLE->setValidator(unsignedLengthValidator(
 982                 marginsModule->headsepLE));
 983         marginsModule->headheightLE->setValidator(unsignedLengthValidator(
 984                 marginsModule->headheightLE));
 985         marginsModule->footskipLE->setValidator(unsignedLengthValidator(
 986                 marginsModule->footskipLE));
 987         marginsModule->columnsepLE->setValidator(unsignedLengthValidator(
 988                 marginsModule->columnsepLE));
 989
 990         bc().addCheckedLineEdit(marginsModule->topLE,
 991                 marginsModule->topL);
 992         bc().addCheckedLineEdit(marginsModule->bottomLE,
 993                 marginsModule->bottomL);
 994         bc().addCheckedLineEdit(marginsModule->innerLE,
 995                 marginsModule->innerL);
 996         bc().addCheckedLineEdit(marginsModule->outerLE,
 997                 marginsModule->outerL);
 998         bc().addCheckedLineEdit(marginsModule->headsepLE,
 999                 marginsModule->headsepL);
1000         bc().addCheckedLineEdit(marginsModule->headheightLE,
1001                 marginsModule->headheightL);
1002         bc().addCheckedLineEdit(marginsModule->footskipLE,
1003                 marginsModule->footskipL);
1004         bc().addCheckedLineEdit(marginsModule->columnsepLE,
1005                 marginsModule->columnsepL);
1006
1007
1008         // language & quote
1009         langModule = new UiWidget<Ui::LanguageUi>;
1010         connect(langModule->languageCO, SIGNAL(activated(int)),
1011                 this, SLOT(change_adaptor()));
1012         connect(langModule->defaultencodingRB, SIGNAL(clicked()),
1013                 this, SLOT(change_adaptor()));
1014         connect(langModule->otherencodingRB, SIGNAL(clicked()),
1015                 this, SLOT(change_adaptor()));
1016         connect(langModule->encodingCO, SIGNAL(activated(int)),
1017                 this, SLOT(change_adaptor()));
1018         connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
1019                 this, SLOT(change_adaptor()));
1020         connect(langModule->languagePackageCO, SIGNAL(activated(int)),
1021                 this, SLOT(change_adaptor()));
1022         connect(langModule->languagePackageLE, SIGNAL(textChanged(QString)),
1023                 this, SLOT(change_adaptor()));
1024         connect(langModule->languagePackageCO, SIGNAL(currentIndexChanged(int)),
1025                 this, SLOT(languagePackageChanged(int)));
1026
1027         langModule->languagePackageLE->setValidator(new NoNewLineValidator(
1028                 langModule->languagePackageLE));
1029
1030         QAbstractItemModel * language_model = guiApp->languageModel();
1031         // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
1032         language_model->sort(0);
1033         langModule->languageCO->setModel(language_model);
1034         langModule->languageCO->setModelColumn(0);
1035
1036         // Always put the default encoding in the first position.
1037         langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
1038         QStringList encodinglist;
1039         Encodings::const_iterator it = encodings.begin();
1040         Encodings::const_iterator const end = encodings.end();
1041         for (; it != end; ++it)
1042                 encodinglist.append(qt_(it->guiName()));
1043         encodinglist.sort();
1044         langModule->encodingCO->addItems(encodinglist);
1045
1046         langModule->quoteStyleCO->addItem(qt_("``text''"));
1047         langModule->quoteStyleCO->addItem(qt_("''text''"));
1048         langModule->quoteStyleCO->addItem(qt_(",,text``"));
1049         langModule->quoteStyleCO->addItem(qt_(",,text''"));
1050         langModule->quoteStyleCO->addItem(qt_("<<text>>"));
1051         langModule->quoteStyleCO->addItem(qt_(">>text<<"));
1052
1053         langModule->languagePackageCO->addItem(
1054                 qt_("Default"), toqstr("default"));
1055         langModule->languagePackageCO->addItem(
1056                 qt_("Automatic"), toqstr("auto"));
1057         langModule->languagePackageCO->addItem(
1058                 qt_("Always Babel"), toqstr("babel"));
1059         langModule->languagePackageCO->addItem(
1060                 qt_("Custom"), toqstr("custom"));
1061         langModule->languagePackageCO->addItem(
1062                 qt_("None[[language package]]"), toqstr("none"));
1063
1064
1065         // color
1066         colorModule = new UiWidget<Ui::ColorUi>;
1067         connect(colorModule->fontColorPB, SIGNAL(clicked()),
1068                 this, SLOT(changeFontColor()));
1069         connect(colorModule->delFontColorTB, SIGNAL(clicked()),
1070                 this, SLOT(deleteFontColor()));
1071         connect(colorModule->noteFontColorPB, SIGNAL(clicked()),
1072                 this, SLOT(changeNoteFontColor()));
1073         connect(colorModule->delNoteFontColorTB, SIGNAL(clicked()),
1074                 this, SLOT(deleteNoteFontColor()));
1075         connect(colorModule->backgroundPB, SIGNAL(clicked()),
1076                 this, SLOT(changeBackgroundColor()));
1077         connect(colorModule->delBackgroundTB, SIGNAL(clicked()),
1078                 this, SLOT(deleteBackgroundColor()));
1079         connect(colorModule->boxBackgroundPB, SIGNAL(clicked()),
1080                 this, SLOT(changeBoxBackgroundColor()));
1081         connect(colorModule->delBoxBackgroundTB, SIGNAL(clicked()),
1082                 this, SLOT(deleteBoxBackgroundColor()));
1083
1084
1085         // numbering
1086         numberingModule = new UiWidget<Ui::NumberingUi>;
1087         connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1088                 this, SLOT(change_adaptor()));
1089         connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1090                 this, SLOT(change_adaptor()));
1091         connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1092                 this, SLOT(updateNumbering()));
1093         connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1094                 this, SLOT(updateNumbering()));
1095         numberingModule->tocTW->setColumnCount(3);
1096         numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
1097         numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
1098         numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
1099         numberingModule->tocTW->header()->setResizeMode(QHeaderView::ResizeToContents);
1100
1101
1102         // biblio
1103         biblioModule = new UiWidget<Ui::BiblioUi>;
1104         connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1105                 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
1106         connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1107                 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
1108         connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
1109                 this, SLOT(biblioChanged()));
1110         connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
1111                 this, SLOT(biblioChanged()));
1112         connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1113                 this, SLOT(biblioChanged()));
1114         connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
1115                 this, SLOT(biblioChanged()));
1116         connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1117                 this, SLOT(biblioChanged()));
1118         connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1119                 this, SLOT(bibtexChanged(int)));
1120         connect(biblioModule->bibtexOptionsLE, SIGNAL(textChanged(QString)),
1121                 this, SLOT(biblioChanged()));
1122         connect(biblioModule->bibtexStyleLE, SIGNAL(textChanged(QString)),
1123                 this, SLOT(biblioChanged()));
1124
1125         biblioModule->bibtexOptionsLE->setValidator(new NoNewLineValidator(
1126                 biblioModule->bibtexOptionsLE));
1127         biblioModule->bibtexStyleLE->setValidator(new NoNewLineValidator(
1128                 biblioModule->bibtexStyleLE));
1129
1130         biblioModule->citeStyleCO->addItem(qt_("Author-year"));
1131         biblioModule->citeStyleCO->addItem(qt_("Numerical"));
1132         biblioModule->citeStyleCO->setCurrentIndex(0);
1133
1134         // NOTE: we do not provide "custom" here for security reasons!
1135         biblioModule->bibtexCO->clear();
1136         biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1137         for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1138                              it != lyxrc.bibtex_alternatives.end(); ++it) {
1139                 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1140                 biblioModule->bibtexCO->addItem(command, command);
1141         }
1142
1143
1144         // indices
1145         indicesModule = new GuiIndices;
1146         connect(indicesModule, SIGNAL(changed()),
1147                 this, SLOT(change_adaptor()));
1148
1149
1150         // maths
1151         mathsModule = new UiWidget<Ui::MathsUi>;
1152         connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
1153                 mathsModule->amsCB, SLOT(setDisabled(bool)));
1154         connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
1155                 mathsModule->esintCB, SLOT(setDisabled(bool)));
1156         connect(mathsModule->mhchemautoCB, SIGNAL(toggled(bool)),
1157                 mathsModule->mhchemCB, SLOT(setDisabled(bool)));
1158         connect(mathsModule->mathdotsautoCB, SIGNAL(toggled(bool)),
1159                 mathsModule->mathdotsCB, SLOT(setDisabled(bool)));
1160         connect(mathsModule->undertildeautoCB, SIGNAL(toggled(bool)),
1161                 mathsModule->undertildeCB, SLOT(setDisabled(bool)));
1162
1163         connect(mathsModule->amsCB, SIGNAL(clicked()),
1164                 this, SLOT(change_adaptor()));
1165         connect(mathsModule->amsautoCB, SIGNAL(clicked()),
1166                 this, SLOT(change_adaptor()));
1167         connect(mathsModule->esintCB, SIGNAL(clicked()),
1168                 this, SLOT(change_adaptor()));
1169         connect(mathsModule->esintautoCB, SIGNAL(clicked()),
1170                 this, SLOT(change_adaptor()));
1171         connect(mathsModule->mhchemCB, SIGNAL(clicked()),
1172                 this, SLOT(change_adaptor()));
1173         connect(mathsModule->mhchemautoCB, SIGNAL(clicked()),
1174                 this, SLOT(change_adaptor()));
1175         connect(mathsModule->mathdotsCB, SIGNAL(clicked()),
1176                 this, SLOT(change_adaptor()));
1177         connect(mathsModule->mathdotsautoCB, SIGNAL(clicked()),
1178                 this, SLOT(change_adaptor()));
1179         connect(mathsModule->undertildeCB, SIGNAL(clicked()),
1180                 this, SLOT(change_adaptor()));
1181         connect(mathsModule->undertildeautoCB, SIGNAL(clicked()),
1182                 this, SLOT(change_adaptor()));
1183
1184
1185         // latex class
1186         latexModule = new UiWidget<Ui::LaTeXUi>;
1187         connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1188                 this, SLOT(change_adaptor()));
1189         connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1190                 this, SLOT(change_adaptor()));
1191         connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1192                 this, SLOT(change_adaptor()));
1193         connect(latexModule->classCO, SIGNAL(activated(int)),
1194                 this, SLOT(classChanged()));
1195         connect(latexModule->classCO, SIGNAL(activated(int)),
1196                 this, SLOT(change_adaptor()));
1197         connect(latexModule->layoutPB, SIGNAL(clicked()),
1198                 this, SLOT(browseLayout()));
1199         connect(latexModule->layoutPB, SIGNAL(clicked()),
1200                 this, SLOT(change_adaptor()));
1201         connect(latexModule->childDocGB, SIGNAL(clicked()),
1202                 this, SLOT(change_adaptor()));
1203         connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1204                 this, SLOT(change_adaptor()));
1205         connect(latexModule->childDocPB, SIGNAL(clicked()),
1206                 this, SLOT(browseMaster()));
1207         connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1208                 this, SLOT(change_adaptor()));
1209         connect(latexModule->refstyleCB, SIGNAL(clicked()),
1210                 this, SLOT(change_adaptor()));
1211
1212         latexModule->optionsLE->setValidator(new NoNewLineValidator(
1213                 latexModule->optionsLE));
1214         latexModule->childDocLE->setValidator(new NoNewLineValidator(
1215                 latexModule->childDocLE));
1216
1217         // postscript drivers
1218         for (int n = 0; tex_graphics[n][0]; ++n) {
1219                 QString enc = qt_(tex_graphics_gui[n]);
1220                 latexModule->psdriverCO->addItem(enc);
1221         }
1222         // latex classes
1223         latexModule->classCO->setModel(&classes_model_);
1224         LayoutFileList const & bcl = LayoutFileList::get();
1225         vector<LayoutFileIndex> classList = bcl.classList();
1226         sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1227
1228         vector<LayoutFileIndex>::const_iterator cit  = classList.begin();
1229         vector<LayoutFileIndex>::const_iterator cen = classList.end();
1230         for (int i = 0; cit != cen; ++cit, ++i) {
1231                 LayoutFile const & tc = bcl[*cit];
1232                 docstring item = (tc.isTeXClassAvailable()) ?
1233                         from_utf8(tc.description()) :
1234                         bformat(_("Unavailable: %1$s"), from_utf8(tc.description()));
1235                 classes_model_.insertRow(i, toqstr(item), *cit);
1236         }
1237
1238
1239         // branches
1240         branchesModule = new GuiBranches;
1241         connect(branchesModule, SIGNAL(changed()),
1242                 this, SLOT(change_adaptor()));
1243         connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1244                 this, SLOT(branchesRename(docstring const &, docstring const &)));
1245         updateUnknownBranches();
1246
1247
1248         // preamble
1249         preambleModule = new PreambleModule;
1250         connect(preambleModule, SIGNAL(changed()),
1251                 this, SLOT(change_adaptor()));
1252
1253         localLayout = new LocalLayout;
1254         connect(localLayout, SIGNAL(changed()),
1255                 this, SLOT(change_adaptor()));
1256
1257
1258         // bullets
1259         bulletsModule = new BulletsModule;
1260         connect(bulletsModule, SIGNAL(changed()),
1261                 this, SLOT(change_adaptor()));
1262
1263
1264         // Modules
1265         modulesModule = new UiWidget<Ui::ModulesUi>;
1266         modulesModule->availableLV->header()->setVisible(false);
1267         modulesModule->availableLV->header()->setResizeMode(QHeaderView::ResizeToContents);
1268         modulesModule->availableLV->header()->setStretchLastSection(false);
1269         selectionManager =
1270                 new ModuleSelectionManager(modulesModule->availableLV,
1271                         modulesModule->selectedLV,
1272                         modulesModule->addPB, modulesModule->deletePB,
1273                         modulesModule->upPB, modulesModule->downPB,
1274                         availableModel(), selectedModel(), this);
1275         connect(selectionManager, SIGNAL(updateHook()),
1276                 this, SLOT(updateModuleInfo()));
1277         connect(selectionManager, SIGNAL(updateHook()),
1278                 this, SLOT(change_adaptor()));
1279         connect(selectionManager, SIGNAL(selectionChanged()),
1280                 this, SLOT(modulesChanged()));
1281
1282
1283         // PDF support
1284         pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1285         connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1286                 this, SLOT(change_adaptor()));
1287         connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1288                 this, SLOT(change_adaptor()));
1289         connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1290                 this, SLOT(change_adaptor()));
1291         connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1292                 this, SLOT(change_adaptor()));
1293         connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1294                 this, SLOT(change_adaptor()));
1295         connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1296                 this, SLOT(change_adaptor()));
1297         connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1298                 this, SLOT(change_adaptor()));
1299         connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1300                 this, SLOT(change_adaptor()));
1301         connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1302                 this, SLOT(change_adaptor()));
1303         connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1304                 this, SLOT(change_adaptor()));
1305         connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1306                 this, SLOT(change_adaptor()));
1307         connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1308                 this, SLOT(change_adaptor()));
1309         connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1310                 this, SLOT(change_adaptor()));
1311         connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1312                 this, SLOT(change_adaptor()));
1313         connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1314                 this, SLOT(change_adaptor()));
1315         connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1316                 this, SLOT(change_adaptor()));
1317
1318         pdfSupportModule->titleLE->setValidator(new NoNewLineValidator(
1319                 pdfSupportModule->titleLE));
1320         pdfSupportModule->authorLE->setValidator(new NoNewLineValidator(
1321                 pdfSupportModule->authorLE));
1322         pdfSupportModule->subjectLE->setValidator(new NoNewLineValidator(
1323                 pdfSupportModule->subjectLE));
1324         pdfSupportModule->keywordsLE->setValidator(new NoNewLineValidator(
1325                 pdfSupportModule->keywordsLE));
1326         pdfSupportModule->optionsLE->setValidator(new NoNewLineValidator(
1327                 pdfSupportModule->optionsLE));
1328
1329         for (int i = 0; backref_opts[i][0]; ++i)
1330                 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1331
1332
1333         // float
1334         floatModule = new FloatPlacement;
1335         connect(floatModule, SIGNAL(changed()),
1336                 this, SLOT(change_adaptor()));
1337
1338
1339         // listings
1340         listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1341         connect(listingsModule->listingsED, SIGNAL(textChanged()),
1342                 this, SLOT(change_adaptor()));
1343         connect(listingsModule->bypassCB, SIGNAL(clicked()),
1344                 this, SLOT(change_adaptor()));
1345         connect(listingsModule->bypassCB, SIGNAL(clicked()),
1346                 this, SLOT(setListingsMessage()));
1347         connect(listingsModule->listingsED, SIGNAL(textChanged()),
1348                 this, SLOT(setListingsMessage()));
1349         listingsModule->listingsTB->setPlainText(
1350                 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1351
1352
1353         // add the panels
1354         docPS->addPanel(latexModule, qt_("Document Class"));
1355         docPS->addPanel(masterChildModule, qt_("Child Documents"));
1356         docPS->addPanel(modulesModule, qt_("Modules"));
1357         docPS->addPanel(localLayout, qt_("Local Layout"));
1358         docPS->addPanel(fontModule, qt_("Fonts"));
1359         docPS->addPanel(textLayoutModule, qt_("Text Layout"));
1360         docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
1361         docPS->addPanel(marginsModule, qt_("Page Margins"));
1362         docPS->addPanel(langModule, qt_("Language"));
1363         docPS->addPanel(colorModule, qt_("Colors"));
1364         docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
1365         docPS->addPanel(biblioModule, qt_("Bibliography"));
1366         docPS->addPanel(indicesModule, qt_("Indexes"));
1367         docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
1368         docPS->addPanel(mathsModule, qt_("Math Options"));
1369         docPS->addPanel(floatModule, qt_("Float Placement"));
1370         docPS->addPanel(listingsModule, qt_("Listings"));
1371         docPS->addPanel(bulletsModule, qt_("Bullets"));
1372         docPS->addPanel(branchesModule, qt_("Branches"));
1373         docPS->addPanel(outputModule, qt_("Output"));
1374         docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
1375         docPS->setCurrentPanel(qt_("Document Class"));
1376 // FIXME: hack to work around resizing bug in Qt >= 4.2
1377 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1378 #if QT_VERSION >= 0x040200
1379         docPS->updateGeometry();
1380 #endif
1381 }
1382
1383
1384 void GuiDocument::saveDefaultClicked()
1385 {
1386         saveDocDefault();
1387 }
1388
1389
1390 void GuiDocument::useDefaultsClicked()
1391 {
1392         useClassDefaults();
1393 }
1394
1395
1396 void GuiDocument::change_adaptor()
1397 {
1398         changed();
1399 }
1400
1401
1402 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1403 {
1404         if (item == 0)
1405                 return;
1406
1407         string child = fromqstr(item->text(0));
1408         if (child.empty())
1409                 return;
1410
1411         if (std::find(includeonlys_.begin(),
1412                       includeonlys_.end(), child) != includeonlys_.end())
1413                 includeonlys_.remove(child);
1414         else
1415                 includeonlys_.push_back(child);
1416
1417         updateIncludeonlys();
1418         changed();
1419 }
1420
1421
1422 QString GuiDocument::validateListingsParameters()
1423 {
1424         // use a cache here to avoid repeated validation
1425         // of the same parameters
1426         static string param_cache;
1427         static QString msg_cache;
1428
1429         if (listingsModule->bypassCB->isChecked())
1430                 return QString();
1431
1432         string params = fromqstr(listingsModule->listingsED->toPlainText());
1433         if (params != param_cache) {
1434                 param_cache = params;
1435                 msg_cache = toqstr(InsetListingsParams(params).validate());
1436         }
1437         return msg_cache;
1438 }
1439
1440
1441 void GuiDocument::setListingsMessage()
1442 {
1443         static bool isOK = true;
1444         QString msg = validateListingsParameters();
1445         if (msg.isEmpty()) {
1446                 if (isOK)
1447                         return;
1448                 isOK = true;
1449                 // listingsTB->setTextColor("black");
1450                 listingsModule->listingsTB->setPlainText(
1451                         qt_("Input listings parameters below. "
1452                 "Enter ? for a list of parameters."));
1453         } else {
1454                 isOK = false;
1455                 // listingsTB->setTextColor("red");
1456                 listingsModule->listingsTB->setPlainText(msg);
1457         }
1458 }
1459
1460
1461 void GuiDocument::setLSpacing(int item)
1462 {
1463         textLayoutModule->lspacingLE->setEnabled(item == 3);
1464 }
1465
1466
1467 void GuiDocument::setIndent(int item)
1468 {
1469         bool const enable = (item == 1);
1470         textLayoutModule->indentLE->setEnabled(enable);
1471         textLayoutModule->indentLengthCO->setEnabled(enable);
1472         textLayoutModule->skipLE->setEnabled(false);
1473         textLayoutModule->skipLengthCO->setEnabled(false);
1474         isValid();
1475 }
1476
1477
1478 void GuiDocument::enableIndent(bool indent)
1479 {
1480         textLayoutModule->skipLE->setEnabled(!indent);
1481         textLayoutModule->skipLengthCO->setEnabled(!indent);
1482         if (indent)
1483                 setIndent(textLayoutModule->indentCO->currentIndex());
1484 }
1485
1486
1487 void GuiDocument::setSkip(int item)
1488 {
1489         bool const enable = (item == 3);
1490         textLayoutModule->skipLE->setEnabled(enable);
1491         textLayoutModule->skipLengthCO->setEnabled(enable);
1492         isValid();
1493 }
1494
1495
1496 void GuiDocument::enableSkip(bool skip)
1497 {
1498         textLayoutModule->indentLE->setEnabled(!skip);
1499         textLayoutModule->indentLengthCO->setEnabled(!skip);
1500         if (skip)
1501                 setSkip(textLayoutModule->skipCO->currentIndex());
1502 }
1503
1504
1505 void GuiDocument::setMargins()
1506 {
1507         bool const extern_geometry =
1508                 documentClass().provides("geometry");
1509         marginsModule->marginCB->setEnabled(!extern_geometry);
1510         if (extern_geometry) {
1511                 marginsModule->marginCB->setChecked(false);
1512                 setCustomMargins(true);
1513         } else {
1514                 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1515                 setCustomMargins(!bp_.use_geometry);
1516         }
1517 }
1518
1519
1520 void GuiDocument::papersizeChanged(int paper_size)
1521 {
1522         setCustomPapersize(paper_size == 1);
1523 }
1524
1525
1526 void GuiDocument::setCustomPapersize(bool custom)
1527 {
1528         pageLayoutModule->paperwidthL->setEnabled(custom);
1529         pageLayoutModule->paperwidthLE->setEnabled(custom);
1530         pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1531         pageLayoutModule->paperheightL->setEnabled(custom);
1532         pageLayoutModule->paperheightLE->setEnabled(custom);
1533         pageLayoutModule->paperheightLE->setFocus();
1534         pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1535 }
1536
1537
1538 void GuiDocument::setColSep()
1539 {
1540         setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1541 }
1542
1543
1544 void GuiDocument::setCustomMargins(bool custom)
1545 {
1546         marginsModule->topL->setEnabled(!custom);
1547         marginsModule->topLE->setEnabled(!custom);
1548         marginsModule->topUnit->setEnabled(!custom);
1549
1550         marginsModule->bottomL->setEnabled(!custom);
1551         marginsModule->bottomLE->setEnabled(!custom);
1552         marginsModule->bottomUnit->setEnabled(!custom);
1553
1554         marginsModule->innerL->setEnabled(!custom);
1555         marginsModule->innerLE->setEnabled(!custom);
1556         marginsModule->innerUnit->setEnabled(!custom);
1557
1558         marginsModule->outerL->setEnabled(!custom);
1559         marginsModule->outerLE->setEnabled(!custom);
1560         marginsModule->outerUnit->setEnabled(!custom);
1561
1562         marginsModule->headheightL->setEnabled(!custom);
1563         marginsModule->headheightLE->setEnabled(!custom);
1564         marginsModule->headheightUnit->setEnabled(!custom);
1565
1566         marginsModule->headsepL->setEnabled(!custom);
1567         marginsModule->headsepLE->setEnabled(!custom);
1568         marginsModule->headsepUnit->setEnabled(!custom);
1569
1570         marginsModule->footskipL->setEnabled(!custom);
1571         marginsModule->footskipLE->setEnabled(!custom);
1572         marginsModule->footskipUnit->setEnabled(!custom);
1573
1574         bool const enableColSep = !custom &&
1575                         textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1576         marginsModule->columnsepL->setEnabled(enableColSep);
1577         marginsModule->columnsepLE->setEnabled(enableColSep);
1578         marginsModule->columnsepUnit->setEnabled(enableColSep);
1579 }
1580
1581
1582 void GuiDocument::changeBackgroundColor()
1583 {
1584         QColor const & newColor = QColorDialog::getColor(
1585                 rgb2qcolor(set_backgroundcolor), asQWidget());
1586         if (!newColor.isValid())
1587                 return;
1588         // set the button color and text
1589         colorModule->backgroundPB->setStyleSheet(
1590                 colorButtonStyleSheet(newColor));
1591         colorModule->backgroundPB->setText(qt_("&Change..."));
1592         // save color
1593         set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1594         is_backgroundcolor = true;
1595         changed();
1596 }
1597
1598
1599 void GuiDocument::deleteBackgroundColor()
1600 {
1601         // set the button color back to default by setting an empty StyleSheet
1602         colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1603         // change button text
1604         colorModule->backgroundPB->setText(qt_("&Default..."));
1605         // save default color (white)
1606         set_backgroundcolor = rgbFromHexName("#ffffff");
1607         is_backgroundcolor = false;
1608         changed();
1609 }
1610
1611
1612 void GuiDocument::changeFontColor()
1613 {
1614         QColor const & newColor = QColorDialog::getColor(
1615                 rgb2qcolor(set_fontcolor), asQWidget());
1616         if (!newColor.isValid())
1617                 return;
1618         // set the button color and text
1619         colorModule->fontColorPB->setStyleSheet(
1620                 colorButtonStyleSheet(newColor));
1621         colorModule->fontColorPB->setText(qt_("&Change..."));
1622         // save color
1623         set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1624         is_fontcolor = true;
1625         changed();
1626 }
1627
1628
1629 void GuiDocument::deleteFontColor()
1630 {
1631         // set the button color back to default by setting an empty StyleSheet
1632         colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1633         // change button text
1634         colorModule->fontColorPB->setText(qt_("&Default..."));
1635         // save default color (black)
1636         set_fontcolor = rgbFromHexName("#000000");
1637         is_fontcolor = false;
1638         changed();
1639 }
1640
1641
1642 void GuiDocument::changeNoteFontColor()
1643 {
1644         QColor const & newColor = QColorDialog::getColor(
1645                 rgb2qcolor(set_notefontcolor), asQWidget());
1646         if (!newColor.isValid())
1647                 return;
1648         // set the button color
1649         colorModule->noteFontColorPB->setStyleSheet(
1650                 colorButtonStyleSheet(newColor));
1651         // save color
1652         set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1653         changed();
1654 }
1655
1656
1657 void GuiDocument::deleteNoteFontColor()
1658 {
1659         // set the button color back to pref
1660         theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1661         colorModule->noteFontColorPB->setStyleSheet(
1662                 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1663         changed();
1664 }
1665
1666
1667 void GuiDocument::changeBoxBackgroundColor()
1668 {
1669         QColor const & newColor = QColorDialog::getColor(
1670                 rgb2qcolor(set_boxbgcolor), asQWidget());
1671         if (!newColor.isValid())
1672                 return;
1673         // set the button color
1674         colorModule->boxBackgroundPB->setStyleSheet(
1675                 colorButtonStyleSheet(newColor));
1676         // save color
1677         set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1678         changed();
1679 }
1680
1681
1682 void GuiDocument::deleteBoxBackgroundColor()
1683 {
1684         // set the button color back to pref
1685         theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1686         colorModule->boxBackgroundPB->setStyleSheet(
1687                 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1688         changed();
1689 }
1690
1691
1692 void GuiDocument::osFontsChanged(bool nontexfonts)
1693 {
1694         bool const tex_fonts = !nontexfonts;
1695         updateFontlist();
1696         updateDefaultFormat();
1697         langModule->encodingCO->setEnabled(tex_fonts &&
1698                 !langModule->defaultencodingRB->isChecked());
1699         langModule->defaultencodingRB->setEnabled(tex_fonts);
1700         langModule->otherencodingRB->setEnabled(tex_fonts);
1701
1702         fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1703         fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1704         fontModule->cjkFontLE->setEnabled(tex_fonts);
1705         fontModule->cjkFontLA->setEnabled(tex_fonts);
1706         string font;
1707         if (tex_fonts)
1708                 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1709         bool scaleable = providesScale(font);
1710         fontModule->scaleSansSB->setEnabled(scaleable);
1711         fontModule->scaleSansLA->setEnabled(scaleable);
1712         if (tex_fonts)
1713                 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1714         scaleable = providesScale(font);
1715         fontModule->scaleTypewriterSB->setEnabled(scaleable);
1716         fontModule->scaleTypewriterLA->setEnabled(scaleable);
1717         if (tex_fonts)
1718                 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1719         fontModule->fontScCB->setEnabled(providesSC(font));
1720         fontModule->fontOsfCB->setEnabled(providesOSF(font));
1721
1722         fontModule->fontencLA->setEnabled(tex_fonts);
1723         fontModule->fontencCO->setEnabled(tex_fonts);
1724         if (!tex_fonts)
1725                 fontModule->fontencLE->setEnabled(false);
1726         else
1727                 fontencChanged(fontModule->fontencCO->currentIndex());
1728 }
1729
1730
1731 void GuiDocument::updateFontsize(string const & items, string const & sel)
1732 {
1733         fontModule->fontsizeCO->clear();
1734         fontModule->fontsizeCO->addItem(qt_("Default"));
1735
1736         for (int n = 0; !token(items,'|',n).empty(); ++n)
1737                 fontModule->fontsizeCO->
1738                         addItem(toqstr(token(items,'|',n)));
1739
1740         for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1741                 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1742                         fontModule->fontsizeCO->setCurrentIndex(n);
1743                         break;
1744                 }
1745         }
1746 }
1747
1748
1749 void GuiDocument::updateFontlist()
1750 {
1751         fontModule->fontsRomanCO->clear();
1752         fontModule->fontsSansCO->clear();
1753         fontModule->fontsTypewriterCO->clear();
1754
1755         // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1756         if (fontModule->osFontsCB->isChecked()) {
1757                 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
1758                 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
1759                 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
1760
1761                 QFontDatabase fontdb;
1762                 QStringList families(fontdb.families());
1763                 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1764                         fontModule->fontsRomanCO->addItem(*it, *it);
1765                         fontModule->fontsSansCO->addItem(*it, *it);
1766                         fontModule->fontsTypewriterCO->addItem(*it, *it);
1767                 }
1768                 return;
1769         }
1770
1771         for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1772                 QString font = qt_(tex_fonts_roman_gui[n]);
1773                 if (!isFontAvailable(tex_fonts_roman[n]))
1774                         font += qt_(" (not installed)");
1775                 fontModule->fontsRomanCO->addItem(font, qt_(tex_fonts_roman[n]));
1776         }
1777         for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1778                 QString font = qt_(tex_fonts_sans_gui[n]);
1779                 if (!isFontAvailable(tex_fonts_sans[n]))
1780                         font += qt_(" (not installed)");
1781                 fontModule->fontsSansCO->addItem(font, qt_(tex_fonts_sans[n]));
1782         }
1783         for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1784                 QString font = qt_(tex_fonts_monospaced_gui[n]);
1785                 if (!isFontAvailable(tex_fonts_monospaced[n]))
1786                         font += qt_(" (not installed)");
1787                 fontModule->fontsTypewriterCO->addItem(font, qt_(tex_fonts_monospaced[n]));
1788         }
1789 }
1790
1791
1792 void GuiDocument::fontencChanged(int item)
1793 {
1794         fontModule->fontencLE->setEnabled(item == 1);
1795 }
1796
1797
1798 void GuiDocument::romanChanged(int item)
1799 {
1800         if (fontModule->osFontsCB->isChecked())
1801                 return;
1802         string const font = tex_fonts_roman[item];
1803         fontModule->fontScCB->setEnabled(providesSC(font));
1804         fontModule->fontOsfCB->setEnabled(providesOSF(font));
1805 }
1806
1807
1808 void GuiDocument::sansChanged(int item)
1809 {
1810         if (fontModule->osFontsCB->isChecked())
1811                 return;
1812         string const font = tex_fonts_sans[item];
1813         bool scaleable = providesScale(font);
1814         fontModule->scaleSansSB->setEnabled(scaleable);
1815         fontModule->scaleSansLA->setEnabled(scaleable);
1816 }
1817
1818
1819 void GuiDocument::ttChanged(int item)
1820 {
1821         if (fontModule->osFontsCB->isChecked())
1822                 return;
1823         string const font = tex_fonts_monospaced[item];
1824         bool scaleable = providesScale(font);
1825         fontModule->scaleTypewriterSB->setEnabled(scaleable);
1826         fontModule->scaleTypewriterLA->setEnabled(scaleable);
1827 }
1828
1829
1830 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1831 {
1832         pagestyles.clear();
1833         pageLayoutModule->pagestyleCO->clear();
1834         pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1835
1836         for (int n = 0; !token(items, '|', n).empty(); ++n) {
1837                 string style = token(items, '|', n);
1838                 QString style_gui = qt_(style);
1839                 pagestyles.push_back(pair<string, QString>(style, style_gui));
1840                 pageLayoutModule->pagestyleCO->addItem(style_gui);
1841         }
1842
1843         if (sel == "default") {
1844                 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1845                 return;
1846         }
1847
1848         int nn = 0;
1849
1850         for (size_t i = 0; i < pagestyles.size(); ++i)
1851                 if (pagestyles[i].first == sel)
1852                         nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1853
1854         if (nn > 0)
1855                 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1856 }
1857
1858
1859 void GuiDocument::browseLayout()
1860 {
1861         QString const label1 = qt_("Layouts|#o#O");
1862         QString const dir1 = toqstr(lyxrc.document_path);
1863         QStringList const filter(qt_("LyX Layout (*.layout)"));
1864         QString file = browseRelToParent(QString(), bufferFilePath(),
1865                 qt_("Local layout file"), filter, false,
1866                 label1, dir1);
1867
1868         if (!file.endsWith(".layout"))
1869                 return;
1870
1871         FileName layoutFile = support::makeAbsPath(fromqstr(file),
1872                 fromqstr(bufferFilePath()));
1873
1874         int const ret = Alert::prompt(_("Local layout file"),
1875                 _("The layout file you have selected is a local layout\n"
1876                   "file, not one in the system or user directory. Your\n"
1877                   "document may not work with this layout if you do not\n"
1878                   "keep the layout file in the document directory."),
1879                   1, 1, _("&Set Layout"), _("&Cancel"));
1880         if (ret == 1)
1881                 return;
1882
1883         // load the layout file
1884         LayoutFileList & bcl = LayoutFileList::get();
1885         string classname = layoutFile.onlyFileName();
1886         // this will update an existing layout if that layout has been loaded before.
1887         LayoutFileIndex name = bcl.addLocalLayout(
1888                 classname.substr(0, classname.size() - 7),
1889                 layoutFile.onlyPath().absFileName());
1890
1891         if (name.empty()) {
1892                 Alert::error(_("Error"),
1893                         _("Unable to read local layout file."));
1894                 return;
1895         }
1896
1897         // do not trigger classChanged if there is no change.
1898         if (latexModule->classCO->currentText() == toqstr(name))
1899                 return;
1900
1901         // add to combo box
1902         int idx = latexModule->classCO->findText(toqstr(name));
1903         if (idx == -1) {
1904                 classes_model_.insertRow(0, toqstr(name), name);
1905                 latexModule->classCO->setCurrentIndex(0);
1906         } else
1907                 latexModule->classCO->setCurrentIndex(idx);
1908
1909         classChanged();
1910 }
1911
1912
1913 void GuiDocument::browseMaster()
1914 {
1915         QString const title = qt_("Select master document");
1916         QString const dir1 = toqstr(lyxrc.document_path);
1917         QString const old = latexModule->childDocLE->text();
1918         QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1919         QStringList const filter(qt_("LyX Files (*.lyx)"));
1920         QString file = browseRelToSub(old, docpath, title, filter, false,
1921                 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1922
1923         if (!file.isEmpty())
1924                 latexModule->childDocLE->setText(file);
1925 }
1926
1927
1928 void GuiDocument::classChanged()
1929 {
1930         int idx = latexModule->classCO->currentIndex();
1931         if (idx < 0)
1932                 return;
1933         string const classname = classes_model_.getIDString(idx);
1934
1935         // check whether the selected modules have changed.
1936         bool modules_changed = false;
1937         unsigned int const srows = selectedModel()->rowCount();
1938         if (srows != bp_.getModules().size())
1939                 modules_changed = true;
1940         else {
1941                 list<string>::const_iterator mit = bp_.getModules().begin();
1942                 list<string>::const_iterator men = bp_.getModules().end();
1943                 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1944                         if (selectedModel()->getIDString(i) != *mit) {
1945                                 modules_changed = true;
1946                                 break;
1947                         }
1948         }
1949
1950         if (modules_changed || lyxrc.auto_reset_options) {
1951                 if (applyPB->isEnabled()) {
1952                         int const ret = Alert::prompt(_("Unapplied changes"),
1953                                         _("Some changes in the dialog were not yet applied.\n"
1954                                         "If you do not apply now, they will be lost after this action."),
1955                                         1, 1, _("&Apply"), _("&Dismiss"));
1956                         if (ret == 0)
1957                                 applyView();
1958                 }
1959         }
1960
1961         // We load the TextClass as soon as it is selected. This is
1962         // necessary so that other options in the dialog can be updated
1963         // according to the new class. Note, however, that, if you use
1964         // the scroll wheel when sitting on the combo box, we'll load a
1965         // lot of TextClass objects very quickly....
1966         if (!bp_.setBaseClass(classname)) {
1967                 Alert::error(_("Error"), _("Unable to set document class."));
1968                 return;
1969         }
1970         if (lyxrc.auto_reset_options)
1971                 bp_.useClassDefaults();
1972
1973         // With the introduction of modules came a distinction between the base
1974         // class and the document class. The former corresponds to the main layout
1975         // file; the latter is that plus the modules (or the document-specific layout,
1976         // or  whatever else there could be). Our parameters come from the document
1977         // class. So when we set the base class, we also need to recreate the document
1978         // class. Otherwise, we still have the old one.
1979         bp_.makeDocumentClass();
1980         paramsToDialog();
1981 }
1982
1983
1984 void GuiDocument::languagePackageChanged(int i)
1985 {
1986          langModule->languagePackageLE->setEnabled(
1987                 langModule->languagePackageCO->itemData(i).toString() == "custom");
1988 }
1989
1990
1991 void GuiDocument::biblioChanged()
1992 {
1993         buffer().invalidateBibinfoCache();
1994         buffer().removeBiblioTempFiles();
1995         changed();
1996 }
1997
1998
1999 void GuiDocument::bibtexChanged(int n)
2000 {
2001         biblioModule->bibtexOptionsLE->setEnabled(
2002                 biblioModule->bibtexCO->itemData(n).toString() != "default");
2003         biblioChanged();
2004 }
2005
2006
2007 namespace {
2008         // FIXME unicode
2009         // both of these should take a vector<docstring>
2010
2011         // This is an insanely complicated attempt to make this sort of thing
2012         // work with RTL languages.
2013         docstring formatStrVec(vector<string> const & v, docstring const & s)
2014         {
2015                 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
2016                 if (v.size() == 0)
2017                         return docstring();
2018                 if (v.size() == 1)
2019                         return translateIfPossible(from_utf8(v[0]));
2020                 if (v.size() == 2) {
2021                         docstring retval = _("%1$s and %2$s");
2022                         retval = subst(retval, _("and"), s);
2023                         return bformat(retval, translateIfPossible(from_utf8(v[0])),
2024                                        translateIfPossible(from_utf8(v[1])));
2025                 }
2026                 // The idea here is to format all but the last two items...
2027                 int const vSize = v.size();
2028                 docstring t2 = _("%1$s, %2$s");
2029                 docstring retval = translateIfPossible(from_utf8(v[0]));
2030                 for (int i = 1; i < vSize - 2; ++i)
2031                         retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
2032                 //...and then to  plug them, and the last two, into this schema
2033                 docstring t = _("%1$s, %2$s, and %3$s");
2034                 t = subst(t, _("and"), s);
2035                 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
2036                                translateIfPossible(from_utf8(v[vSize - 1])));
2037         }
2038
2039         vector<string> idsToNames(vector<string> const & idList)
2040         {
2041                 vector<string> retval;
2042                 vector<string>::const_iterator it  = idList.begin();
2043                 vector<string>::const_iterator end = idList.end();
2044                 for (; it != end; ++it) {
2045                         LyXModule const * const mod = theModuleList[*it];
2046                         if (!mod)
2047                                 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
2048                                                 translateIfPossible(from_utf8(*it)))));
2049                         else
2050                                 retval.push_back(mod->getName());
2051                 }
2052                 return retval;
2053         }
2054 } // end anonymous namespace
2055
2056
2057 void GuiDocument::modulesToParams(BufferParams & bp)
2058 {
2059         // update list of loaded modules
2060         bp.clearLayoutModules();
2061         int const srows = modules_sel_model_.rowCount();
2062         for (int i = 0; i < srows; ++i)
2063                 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2064
2065         // update the list of removed modules
2066         bp.clearRemovedModules();
2067         LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2068         list<string>::const_iterator rit = reqmods.begin();
2069         list<string>::const_iterator ren = reqmods.end();
2070
2071         // check each of the default modules
2072         for (; rit != ren; rit++) {
2073                 list<string>::const_iterator mit = bp.getModules().begin();
2074                 list<string>::const_iterator men = bp.getModules().end();
2075                 bool found = false;
2076                 for (; mit != men; mit++) {
2077                         if (*rit == *mit) {
2078                                 found = true;
2079                                 break;
2080                         }
2081                 }
2082                 if (!found) {
2083                         // the module isn't present so must have been removed by the user
2084                         bp.addRemovedModule(*rit);
2085                 }
2086         }
2087 }
2088
2089 void GuiDocument::modulesChanged()
2090 {
2091         modulesToParams(bp_);
2092         bp_.makeDocumentClass();
2093         paramsToDialog();
2094 }
2095
2096
2097 void GuiDocument::updateModuleInfo()
2098 {
2099         selectionManager->update();
2100
2101         //Module description
2102         bool const focus_on_selected = selectionManager->selectedFocused();
2103         QAbstractItemView * lv;
2104         if (focus_on_selected)
2105                 lv = modulesModule->selectedLV;
2106         else
2107                 lv= modulesModule->availableLV;
2108         if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2109                 modulesModule->infoML->document()->clear();
2110                 return;
2111         }
2112         QModelIndex const & idx = lv->selectionModel()->currentIndex();
2113         GuiIdListModel const & id_model =
2114                         focus_on_selected  ? modules_sel_model_ : modules_av_model_;
2115         string const modName = id_model.getIDString(idx.row());
2116         docstring desc = getModuleDescription(modName);
2117
2118         LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2119         if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2120                 if (!desc.empty())
2121                         desc += "\n";
2122                 desc += _("Module provided by document class.");
2123         }
2124
2125         vector<string> pkglist = getPackageList(modName);
2126         docstring pkgdesc = formatStrVec(pkglist, _("and"));
2127         if (!pkgdesc.empty()) {
2128                 if (!desc.empty())
2129                         desc += "\n";
2130                 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2131         }
2132
2133         pkglist = getRequiredList(modName);
2134         if (!pkglist.empty()) {
2135                 vector<string> const reqdescs = idsToNames(pkglist);
2136                 pkgdesc = formatStrVec(reqdescs, _("or"));
2137                 if (!desc.empty())
2138                         desc += "\n";
2139                 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2140         }
2141
2142         pkglist = getExcludedList(modName);
2143         if (!pkglist.empty()) {
2144                 vector<string> const reqdescs = idsToNames(pkglist);
2145                 pkgdesc = formatStrVec(reqdescs, _( "and"));
2146                 if (!desc.empty())
2147                         desc += "\n";
2148                 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2149         }
2150
2151         if (!isModuleAvailable(modName)) {
2152                 if (!desc.empty())
2153                         desc += "\n";
2154                 desc += _("WARNING: Some required packages are unavailable!");
2155         }
2156
2157         modulesModule->infoML->document()->setPlainText(toqstr(desc));
2158 }
2159
2160
2161 void GuiDocument::updateNumbering()
2162 {
2163         DocumentClass const & tclass = documentClass();
2164
2165         numberingModule->tocTW->setUpdatesEnabled(false);
2166         numberingModule->tocTW->clear();
2167
2168         int const depth = numberingModule->depthSL->value();
2169         int const toc = numberingModule->tocSL->value();
2170         QString const no = qt_("No");
2171         QString const yes = qt_("Yes");
2172         QTreeWidgetItem * item = 0;
2173
2174         DocumentClass::const_iterator lit = tclass.begin();
2175         DocumentClass::const_iterator len = tclass.end();
2176         for (; lit != len; ++lit) {
2177                 int const toclevel = lit->toclevel;
2178                 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
2179                         item = new QTreeWidgetItem(numberingModule->tocTW);
2180                         item->setText(0, toqstr(translateIfPossible(lit->name())));
2181                         item->setText(1, (toclevel <= depth) ? yes : no);
2182                         item->setText(2, (toclevel <= toc) ? yes : no);
2183                 }
2184         }
2185
2186         numberingModule->tocTW->setUpdatesEnabled(true);
2187         numberingModule->tocTW->update();
2188 }
2189
2190
2191 void GuiDocument::updateDefaultFormat()
2192 {
2193         if (!bufferview())
2194                 return;
2195         // make a copy in order to consider unapplied changes
2196         BufferParams param_copy = buffer().params();
2197         param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2198         int const idx = latexModule->classCO->currentIndex();
2199         if (idx >= 0) {
2200                 string const classname = classes_model_.getIDString(idx);
2201                 param_copy.setBaseClass(classname);
2202                 param_copy.makeDocumentClass();
2203         }
2204         outputModule->defaultFormatCO->blockSignals(true);
2205         outputModule->defaultFormatCO->clear();
2206         outputModule->defaultFormatCO->addItem(qt_("Default"),
2207                                 QVariant(QString("default")));
2208         typedef vector<Format const *> Formats;
2209         Formats formats = param_copy.exportableFormats(true);
2210         Formats::const_iterator cit = formats.begin();
2211         Formats::const_iterator end = formats.end();
2212         for (; cit != end; ++cit)
2213                 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
2214                                 QVariant(toqstr((*cit)->name())));
2215         outputModule->defaultFormatCO->blockSignals(false);
2216 }
2217
2218
2219 bool GuiDocument::isChildIncluded(string const & child)
2220 {
2221         if (includeonlys_.empty())
2222                 return false;
2223         return (std::find(includeonlys_.begin(),
2224                           includeonlys_.end(), child) != includeonlys_.end());
2225 }
2226
2227
2228 void GuiDocument::applyView()
2229 {
2230         // preamble
2231         preambleModule->apply(bp_);
2232         localLayout->apply(bp_);
2233
2234         // date
2235         bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2236         bp_.use_refstyle  = latexModule->refstyleCB->isChecked();
2237
2238         // biblio
2239         bp_.setCiteEngine(ENGINE_BASIC);
2240
2241         if (biblioModule->citeNatbibRB->isChecked()) {
2242                 bool const use_numerical_citations =
2243                         biblioModule->citeStyleCO->currentIndex();
2244                 if (use_numerical_citations)
2245                         bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
2246                 else
2247                         bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
2248
2249         } else if (biblioModule->citeJurabibRB->isChecked())
2250                 bp_.setCiteEngine(ENGINE_JURABIB);
2251
2252         bp_.use_bibtopic =
2253                 biblioModule->bibtopicCB->isChecked();
2254
2255         bp_.biblio_style = fromqstr(biblioModule->bibtexStyleLE->text());
2256
2257         string const bibtex_command =
2258                 fromqstr(biblioModule->bibtexCO->itemData(
2259                         biblioModule->bibtexCO->currentIndex()).toString());
2260         string const bibtex_options =
2261                 fromqstr(biblioModule->bibtexOptionsLE->text());
2262         if (bibtex_command == "default" || bibtex_options.empty())
2263                 bp_.bibtex_command = bibtex_command;
2264         else
2265                 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2266
2267         // Indices
2268         indicesModule->apply(bp_);
2269
2270         // language & quotes
2271         if (langModule->defaultencodingRB->isChecked()) {
2272                 bp_.inputenc = "auto";
2273         } else {
2274                 int i = langModule->encodingCO->currentIndex();
2275                 if (i == 0)
2276                         bp_.inputenc = "default";
2277                 else {
2278                         QString const enc_gui =
2279                                 langModule->encodingCO->currentText();
2280                         Encodings::const_iterator it = encodings.begin();
2281                         Encodings::const_iterator const end = encodings.end();
2282                         bool found = false;
2283                         for (; it != end; ++it) {
2284                                 if (qt_(it->guiName()) == enc_gui) {
2285                                         bp_.inputenc = it->latexName();
2286                                         found = true;
2287                                         break;
2288                                 }
2289                         }
2290                         if (!found) {
2291                                 // should not happen
2292                                 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2293                                 bp_.inputenc = "default";
2294                         }
2295                 }
2296         }
2297
2298         InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
2299         switch (langModule->quoteStyleCO->currentIndex()) {
2300         case 0:
2301                 lga = InsetQuotes::EnglishQuotes;
2302                 break;
2303         case 1:
2304                 lga = InsetQuotes::SwedishQuotes;
2305                 break;
2306         case 2:
2307                 lga = InsetQuotes::GermanQuotes;
2308                 break;
2309         case 3:
2310                 lga = InsetQuotes::PolishQuotes;
2311                 break;
2312         case 4:
2313                 lga = InsetQuotes::FrenchQuotes;
2314                 break;
2315         case 5:
2316                 lga = InsetQuotes::DanishQuotes;
2317                 break;
2318         }
2319         bp_.quotes_language = lga;
2320
2321         QString const lang = langModule->languageCO->itemData(
2322                 langModule->languageCO->currentIndex()).toString();
2323         bp_.language = lyx::languages.getLanguage(fromqstr(lang));
2324
2325         QString const pack = langModule->languagePackageCO->itemData(
2326                 langModule->languagePackageCO->currentIndex()).toString();
2327         if (pack == "custom")
2328                 bp_.lang_package =
2329                         fromqstr(langModule->languagePackageLE->text());
2330         else
2331                 bp_.lang_package = fromqstr(pack);
2332
2333         //color
2334         bp_.backgroundcolor = set_backgroundcolor;
2335         bp_.isbackgroundcolor = is_backgroundcolor;
2336         bp_.fontcolor = set_fontcolor;
2337         bp_.isfontcolor = is_fontcolor;
2338         bp_.notefontcolor = set_notefontcolor;
2339         bp_.boxbgcolor = set_boxbgcolor;
2340
2341         // numbering
2342         if (bp_.documentClass().hasTocLevels()) {
2343                 bp_.tocdepth = numberingModule->tocSL->value();
2344                 bp_.secnumdepth = numberingModule->depthSL->value();
2345         }
2346
2347         // bullets
2348         bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2349         bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2350         bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2351         bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2352
2353         // packages
2354         bp_.graphics_driver =
2355                 tex_graphics[latexModule->psdriverCO->currentIndex()];
2356
2357         // text layout
2358         int idx = latexModule->classCO->currentIndex();
2359         if (idx >= 0) {
2360                 string const classname = classes_model_.getIDString(idx);
2361                 bp_.setBaseClass(classname);
2362         }
2363
2364         // Modules
2365         modulesToParams(bp_);
2366
2367         // Math
2368         if (mathsModule->amsautoCB->isChecked())
2369                 bp_.use_amsmath = BufferParams::package_auto;
2370         else {
2371                 if (mathsModule->amsCB->isChecked())
2372                         bp_.use_amsmath = BufferParams::package_on;
2373                 else
2374                         bp_.use_amsmath = BufferParams::package_off;
2375         }
2376         if (mathsModule->esintautoCB->isChecked())
2377                 bp_.use_esint = BufferParams::package_auto;
2378         else {
2379                 if (mathsModule->esintCB->isChecked())
2380                         bp_.use_esint = BufferParams::package_on;
2381                 else
2382                         bp_.use_esint = BufferParams::package_off;
2383         }
2384         if (mathsModule->mhchemautoCB->isChecked())
2385                 bp_.use_mhchem = BufferParams::package_auto;
2386         else {
2387                 if (mathsModule->mhchemCB->isChecked())
2388                         bp_.use_mhchem = BufferParams::package_on;
2389                 else
2390                         bp_.use_mhchem = BufferParams::package_off;
2391         }
2392         if (mathsModule->mathdotsautoCB->isChecked())
2393                 bp_.use_mathdots = BufferParams::package_auto;
2394         else {
2395                 if (mathsModule->mathdotsCB->isChecked())
2396                         bp_.use_mathdots = BufferParams::package_on;
2397                 else
2398                         bp_.use_mathdots = BufferParams::package_off;
2399         }
2400         if (mathsModule->undertildeautoCB->isChecked())
2401                 bp_.use_undertilde = BufferParams::package_auto;
2402         else {
2403                 if (mathsModule->undertildeCB->isChecked())
2404                         bp_.use_undertilde = BufferParams::package_on;
2405                 else
2406                         bp_.use_undertilde = BufferParams::package_off;
2407         }
2408
2409         // Page Layout
2410         if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2411                 bp_.pagestyle = "default";
2412         else {
2413                 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2414                 for (size_t i = 0; i != pagestyles.size(); ++i)
2415                         if (pagestyles[i].second == style_gui)
2416                                 bp_.pagestyle = pagestyles[i].first;
2417         }
2418
2419         // Text Layout
2420         switch (textLayoutModule->lspacingCO->currentIndex()) {
2421         case 0:
2422                 bp_.spacing().set(Spacing::Single);
2423                 break;
2424         case 1:
2425                 bp_.spacing().set(Spacing::Onehalf);
2426                 break;
2427         case 2:
2428                 bp_.spacing().set(Spacing::Double);
2429                 break;
2430         case 3: {
2431                 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2432                 if (s.empty())
2433                         bp_.spacing().set(Spacing::Single);
2434                 else
2435                         bp_.spacing().set(Spacing::Other, s);
2436                 break;
2437                 }
2438         }
2439
2440         if (textLayoutModule->twoColumnCB->isChecked())
2441                 bp_.columns = 2;
2442         else
2443                 bp_.columns = 1;
2444
2445         bp_.justification = textLayoutModule->justCB->isChecked();
2446
2447         if (textLayoutModule->indentRB->isChecked()) {
2448                 // if paragraphs are separated by an indentation
2449                 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2450                 switch (textLayoutModule->indentCO->currentIndex()) {
2451                 case 0:
2452                         bp_.setIndentation(HSpace(HSpace::DEFAULT));
2453                         break;
2454                 case 1: {
2455                         HSpace indent = HSpace(
2456                                 widgetsToLength(textLayoutModule->indentLE,
2457                                 textLayoutModule->indentLengthCO)
2458                                 );
2459                         bp_.setIndentation(indent);
2460                         break;
2461                         }
2462                 default:
2463                         // this should never happen
2464                         bp_.setIndentation(HSpace(HSpace::DEFAULT));
2465                         break;
2466                 }
2467         } else {
2468                 // if paragraphs are separated by a skip
2469                 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2470                 switch (textLayoutModule->skipCO->currentIndex()) {
2471                 case 0:
2472                         bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2473                         break;
2474                 case 1:
2475                         bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2476                         break;
2477                 case 2:
2478                         bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2479                         break;
2480                 case 3:
2481                         {
2482                         VSpace vs = VSpace(
2483                                 widgetsToLength(textLayoutModule->skipLE,
2484                                 textLayoutModule->skipLengthCO)
2485                                 );
2486                         bp_.setDefSkip(vs);
2487                         break;
2488                         }
2489                 default:
2490                         // this should never happen
2491                         bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2492                         break;
2493                 }
2494         }
2495
2496         bp_.options =
2497                 fromqstr(latexModule->optionsLE->text());
2498
2499         bp_.use_default_options =
2500                 latexModule->defaultOptionsCB->isChecked();
2501
2502         if (latexModule->childDocGB->isChecked())
2503                 bp_.master =
2504                         fromqstr(latexModule->childDocLE->text());
2505         else
2506                 bp_.master = string();
2507
2508         // Master/Child
2509         bp_.clearIncludedChildren();
2510         if (masterChildModule->includeonlyRB->isChecked()) {
2511                 list<string>::const_iterator it = includeonlys_.begin();
2512                 for (; it != includeonlys_.end() ; ++it) {
2513                         bp_.addIncludedChildren(*it);
2514                 }
2515         }
2516         bp_.maintain_unincluded_children =
2517                 masterChildModule->maintainAuxCB->isChecked();
2518
2519         // Float Placement
2520         bp_.float_placement = floatModule->get();
2521
2522         // Listings
2523         // text should have passed validation
2524         bp_.listings_params =
2525                 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2526
2527         // output
2528         bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2529                 outputModule->defaultFormatCO->currentIndex()).toString());
2530
2531         bool const nontexfonts = fontModule->osFontsCB->isChecked();
2532         bp_.useNonTeXFonts = nontexfonts;
2533
2534         bp_.output_sync = outputModule->outputsyncCB->isChecked();
2535
2536         bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2537
2538         int mathfmt = outputModule->mathoutCB->currentIndex();
2539         if (mathfmt == -1)
2540                 mathfmt = 0;
2541         BufferParams::MathOutput const mo =
2542                 static_cast<BufferParams::MathOutput>(mathfmt);
2543         bp_.html_math_output = mo;
2544         bp_.html_be_strict = outputModule->strictCB->isChecked();
2545         bp_.html_css_as_file = outputModule->cssCB->isChecked();
2546         bp_.html_math_img_scale = outputModule->mathimgSB->value();
2547
2548         // fonts
2549         bp_.fonts_roman =
2550                 fromqstr(fontModule->fontsRomanCO->
2551                         itemData(fontModule->fontsRomanCO->currentIndex()).toString());
2552
2553         bp_.fonts_sans =
2554                 fromqstr(fontModule->fontsSansCO->
2555                         itemData(fontModule->fontsSansCO->currentIndex()).toString());
2556
2557         bp_.fonts_typewriter =
2558                 fromqstr(fontModule->fontsTypewriterCO->
2559                         itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
2560
2561         if (fontModule->fontencCO->currentIndex() == 0)
2562                 bp_.fontenc = "global";
2563         else if (fontModule->fontencCO->currentIndex() == 1)
2564                 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2565         else if (fontModule->fontencCO->currentIndex() == 2)
2566                 bp_.fontenc = "default";
2567
2568         bp_.fonts_cjk =
2569                 fromqstr(fontModule->cjkFontLE->text());
2570
2571         bp_.fonts_sans_scale = fontModule->scaleSansSB->value();
2572
2573         bp_.fonts_typewriter_scale = fontModule->scaleTypewriterSB->value();
2574
2575         bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2576
2577         bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2578
2579         if (nontexfonts)
2580                 bp_.fonts_default_family = "default";
2581         else
2582                 bp_.fonts_default_family = GuiDocument::fontfamilies[
2583                         fontModule->fontsDefaultCO->currentIndex()];
2584
2585         if (fontModule->fontsizeCO->currentIndex() == 0)
2586                 bp_.fontsize = "default";
2587         else
2588                 bp_.fontsize =
2589                         fromqstr(fontModule->fontsizeCO->currentText());
2590
2591         // paper
2592         bp_.papersize = PAPER_SIZE(
2593                 pageLayoutModule->papersizeCO->currentIndex());
2594
2595         bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2596                 pageLayoutModule->paperwidthUnitCO);
2597
2598         bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2599                 pageLayoutModule->paperheightUnitCO);
2600
2601         if (pageLayoutModule->facingPagesCB->isChecked())
2602                 bp_.sides = TwoSides;
2603         else
2604                 bp_.sides = OneSide;
2605
2606         if (pageLayoutModule->landscapeRB->isChecked())
2607                 bp_.orientation = ORIENTATION_LANDSCAPE;
2608         else
2609                 bp_.orientation = ORIENTATION_PORTRAIT;
2610
2611         // margins
2612         bp_.use_geometry = !marginsModule->marginCB->isChecked();
2613
2614         Ui::MarginsUi const * m = marginsModule;
2615
2616         bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2617         bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2618         bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2619         bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2620         bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2621         bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2622         bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2623         bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2624
2625         // branches
2626         branchesModule->apply(bp_);
2627
2628         // PDF support
2629         PDFOptions & pdf = bp_.pdfoptions();
2630         pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2631         pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2632         pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2633         pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2634         pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2635
2636         pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2637         pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2638         pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2639         pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2640
2641         pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2642         pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2643         pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2644         pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2645         pdf.backref =
2646                 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2647         if (pdfSupportModule->fullscreenCB->isChecked())
2648                 pdf.pagemode = pdf.pagemode_fullscreen;
2649         else
2650                 pdf.pagemode.clear();
2651         pdf.quoted_options = pdf.quoted_options_check(
2652                                 fromqstr(pdfSupportModule->optionsLE->text()));
2653 }
2654
2655
2656 void GuiDocument::paramsToDialog()
2657 {
2658         // set the default unit
2659         Length::UNIT const default_unit = Length::defaultUnit();
2660
2661         // preamble
2662         preambleModule->update(bp_, id());
2663         localLayout->update(bp_, id());
2664
2665         // date
2666         latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2667         latexModule->refstyleCB->setChecked(bp_.use_refstyle);
2668
2669         // biblio
2670         biblioModule->citeDefaultRB->setChecked(
2671                 bp_.citeEngine() == ENGINE_BASIC);
2672
2673         biblioModule->citeNatbibRB->setChecked(
2674                 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2675                 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2676
2677         biblioModule->citeStyleCO->setCurrentIndex(
2678                 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2679
2680         biblioModule->citeJurabibRB->setChecked(
2681                 bp_.citeEngine() == ENGINE_JURABIB);
2682
2683         biblioModule->bibtopicCB->setChecked(
2684                 bp_.use_bibtopic);
2685
2686         biblioModule->bibtexStyleLE->setText(toqstr(bp_.biblio_style));
2687
2688         string command;
2689         string options =
2690                 split(bp_.bibtex_command, command, ' ');
2691
2692         int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2693         if (bpos != -1) {
2694                 biblioModule->bibtexCO->setCurrentIndex(bpos);
2695                 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
2696         } else {
2697                 // We reset to default if we do not know the specified compiler
2698                 // This is for security reasons
2699                 biblioModule->bibtexCO->setCurrentIndex(
2700                         biblioModule->bibtexCO->findData(toqstr("default")));
2701                 biblioModule->bibtexOptionsLE->clear();
2702         }
2703         biblioModule->bibtexOptionsLE->setEnabled(
2704                 biblioModule->bibtexCO->currentIndex() != 0);
2705
2706         // indices
2707         indicesModule->update(bp_);
2708
2709         // language & quotes
2710         int const pos = langModule->languageCO->findData(toqstr(
2711                 bp_.language->lang()));
2712         langModule->languageCO->setCurrentIndex(pos);
2713
2714         langModule->quoteStyleCO->setCurrentIndex(
2715                 bp_.quotes_language);
2716
2717         bool default_enc = true;
2718         if (bp_.inputenc != "auto") {
2719                 default_enc = false;
2720                 if (bp_.inputenc == "default") {
2721                         langModule->encodingCO->setCurrentIndex(0);
2722                 } else {
2723                         string enc_gui;
2724                         Encodings::const_iterator it = encodings.begin();
2725                         Encodings::const_iterator const end = encodings.end();
2726                         for (; it != end; ++it) {
2727                                 if (it->latexName() == bp_.inputenc) {
2728                                         enc_gui = it->guiName();
2729                                         break;
2730                                 }
2731                         }
2732                         int const i = langModule->encodingCO->findText(
2733                                         qt_(enc_gui));
2734                         if (i >= 0)
2735                                 langModule->encodingCO->setCurrentIndex(i);
2736                         else
2737                                 // unknown encoding. Set to default.
2738                                 default_enc = true;
2739                 }
2740         }
2741         langModule->defaultencodingRB->setChecked(default_enc);
2742         langModule->otherencodingRB->setChecked(!default_enc);
2743
2744         int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
2745         if (p == -1) {
2746                 langModule->languagePackageCO->setCurrentIndex(
2747                           langModule->languagePackageCO->findData("custom"));
2748                 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
2749         } else {
2750                 langModule->languagePackageCO->setCurrentIndex(p);
2751                 langModule->languagePackageLE->clear();
2752         }
2753
2754         //color
2755         if (bp_.isfontcolor) {
2756                 colorModule->fontColorPB->setStyleSheet(
2757                         colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
2758         }
2759         set_fontcolor = bp_.fontcolor;
2760         is_fontcolor = bp_.isfontcolor;
2761
2762         colorModule->noteFontColorPB->setStyleSheet(
2763                 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
2764         set_notefontcolor = bp_.notefontcolor;
2765
2766         if (bp_.isbackgroundcolor) {
2767                 colorModule->backgroundPB->setStyleSheet(
2768                         colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2769         }
2770         set_backgroundcolor = bp_.backgroundcolor;
2771         is_backgroundcolor = bp_.isbackgroundcolor;
2772
2773         colorModule->boxBackgroundPB->setStyleSheet(
2774                 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
2775         set_boxbgcolor = bp_.boxbgcolor;
2776
2777         // numbering
2778         int const min_toclevel = documentClass().min_toclevel();
2779         int const max_toclevel = documentClass().max_toclevel();
2780         if (documentClass().hasTocLevels()) {
2781                 numberingModule->setEnabled(true);
2782                 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2783                 numberingModule->depthSL->setMaximum(max_toclevel);
2784                 numberingModule->depthSL->setValue(bp_.secnumdepth);
2785                 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2786                 numberingModule->tocSL->setMaximum(max_toclevel);
2787                 numberingModule->tocSL->setValue(bp_.tocdepth);
2788                 updateNumbering();
2789         } else {
2790                 numberingModule->setEnabled(false);
2791                 numberingModule->tocTW->clear();
2792         }
2793
2794         // bullets
2795         bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2796         bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2797         bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2798         bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2799         bulletsModule->init();
2800
2801         // packages
2802         int nitem = findToken(tex_graphics, bp_.graphics_driver);
2803         if (nitem >= 0)
2804                 latexModule->psdriverCO->setCurrentIndex(nitem);
2805         updateModuleInfo();
2806
2807         mathsModule->amsCB->setChecked(
2808                 bp_.use_amsmath == BufferParams::package_on);
2809         mathsModule->amsautoCB->setChecked(
2810                 bp_.use_amsmath == BufferParams::package_auto);
2811
2812         mathsModule->esintCB->setChecked(
2813                 bp_.use_esint == BufferParams::package_on);
2814         mathsModule->esintautoCB->setChecked(
2815                 bp_.use_esint == BufferParams::package_auto);
2816
2817         mathsModule->mhchemCB->setChecked(
2818                 bp_.use_mhchem == BufferParams::package_on);
2819         mathsModule->mhchemautoCB->setChecked(
2820                 bp_.use_mhchem == BufferParams::package_auto);
2821
2822         mathsModule->mathdotsCB->setChecked(
2823                 bp_.use_mathdots == BufferParams::package_on);
2824         mathsModule->mathdotsautoCB->setChecked(
2825                 bp_.use_mathdots == BufferParams::package_auto);
2826
2827         mathsModule->undertildeCB->setChecked(
2828                 bp_.use_undertilde == BufferParams::package_on);
2829         mathsModule->undertildeautoCB->setChecked(
2830                 bp_.use_undertilde == BufferParams::package_auto);
2831
2832         switch (bp_.spacing().getSpace()) {
2833                 case Spacing::Other: nitem = 3; break;
2834                 case Spacing::Double: nitem = 2; break;
2835                 case Spacing::Onehalf: nitem = 1; break;
2836                 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2837         }
2838
2839         // text layout
2840         string const & layoutID = bp_.baseClassID();
2841         setLayoutComboByIDString(layoutID);
2842
2843         updatePagestyle(documentClass().opt_pagestyle(),
2844                                  bp_.pagestyle);
2845
2846         textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2847         if (bp_.spacing().getSpace() == Spacing::Other) {
2848                 doubleToWidget(textLayoutModule->lspacingLE,
2849                         bp_.spacing().getValueAsString());
2850         }
2851         setLSpacing(nitem);
2852
2853         if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
2854                 textLayoutModule->indentRB->setChecked(true);
2855                 string indentation = bp_.getIndentation().asLyXCommand();
2856                 int indent = 0;
2857                 if (indentation != "default") {
2858                         lengthToWidgets(textLayoutModule->indentLE,
2859                         textLayoutModule->indentLengthCO,
2860                         indentation, default_unit);
2861                         indent = 1;
2862                 }
2863                 textLayoutModule->indentCO->setCurrentIndex(indent);
2864                 setIndent(indent);
2865         } else {
2866                 textLayoutModule->skipRB->setChecked(true);
2867                 int skip = 0;
2868                 switch (bp_.getDefSkip().kind()) {
2869                 case VSpace::SMALLSKIP:
2870                         skip = 0;
2871                         break;
2872                 case VSpace::MEDSKIP:
2873                         skip = 1;
2874                         break;
2875                 case VSpace::BIGSKIP:
2876                         skip = 2;
2877                         break;
2878                 case VSpace::LENGTH:
2879                         {
2880                         skip = 3;
2881                         string const length = bp_.getDefSkip().asLyXCommand();
2882                         lengthToWidgets(textLayoutModule->skipLE,
2883                                 textLayoutModule->skipLengthCO,
2884                                 length, default_unit);
2885                         break;
2886                         }
2887                 default:
2888                         skip = 0;
2889                         break;
2890                 }
2891                 textLayoutModule->skipCO->setCurrentIndex(skip);
2892                 setSkip(skip);
2893         }
2894
2895         textLayoutModule->twoColumnCB->setChecked(
2896                 bp_.columns == 2);
2897         textLayoutModule->justCB->setChecked(bp_.justification);
2898
2899         if (!bp_.options.empty()) {
2900                 latexModule->optionsLE->setText(
2901                         toqstr(bp_.options));
2902         } else {
2903                 latexModule->optionsLE->setText(QString());
2904         }
2905
2906         // latex
2907         latexModule->defaultOptionsCB->setChecked(
2908                         bp_.use_default_options);
2909         updateSelectedModules();
2910         selectionManager->updateProvidedModules(
2911                         bp_.baseClass()->providedModules());
2912         selectionManager->updateExcludedModules(
2913                         bp_.baseClass()->excludedModules());
2914
2915         if (!documentClass().options().empty()) {
2916                 latexModule->defaultOptionsLE->setText(
2917                         toqstr(documentClass().options()));
2918         } else {
2919                 latexModule->defaultOptionsLE->setText(
2920                         toqstr(_("[No options predefined]")));
2921         }
2922
2923         latexModule->defaultOptionsLE->setEnabled(
2924                 bp_.use_default_options
2925                 && !documentClass().options().empty());
2926
2927         latexModule->defaultOptionsCB->setEnabled(
2928                 !documentClass().options().empty());
2929
2930         if (!bp_.master.empty()) {
2931                 latexModule->childDocGB->setChecked(true);
2932                 latexModule->childDocLE->setText(
2933                         toqstr(bp_.master));
2934         } else {
2935                 latexModule->childDocLE->setText(QString());
2936                 latexModule->childDocGB->setChecked(false);
2937         }
2938
2939         // Master/Child
2940         if (!bufferview() || !buffer().hasChildren()) {
2941                 masterChildModule->childrenTW->clear();
2942                 includeonlys_.clear();
2943                 docPS->showPanel(qt_("Child Documents"), false);
2944                 if (docPS->isCurrentPanel(qt_("Child Documents")))
2945                         docPS->setCurrentPanel(qt_("Document Class"));
2946         } else {
2947                 docPS->showPanel(qt_("Child Documents"), true);
2948                 masterChildModule->setEnabled(true);
2949                 includeonlys_ = bp_.getIncludedChildren();
2950                 updateIncludeonlys();
2951         }
2952         masterChildModule->maintainAuxCB->setChecked(
2953                 bp_.maintain_unincluded_children);
2954
2955         // Float Settings
2956         floatModule->set(bp_.float_placement);
2957
2958         // ListingsSettings
2959         // break listings_params to multiple lines
2960         string lstparams =
2961                 InsetListingsParams(bp_.listings_params).separatedParams();
2962         listingsModule->listingsED->setPlainText(toqstr(lstparams));
2963
2964         // Output
2965         // update combobox with formats
2966         updateDefaultFormat();
2967         int index = outputModule->defaultFormatCO->findData(toqstr(
2968                 bp_.default_output_format));
2969         // set to default if format is not found
2970         if (index == -1)
2971                 index = 0;
2972         outputModule->defaultFormatCO->setCurrentIndex(index);
2973         bool const os_fonts_available =
2974                 bp_.baseClass()->outputType() == lyx::LATEX
2975                 && LaTeXFeatures::isAvailable("fontspec");
2976         fontModule->osFontsCB->setEnabled(os_fonts_available);
2977         fontModule->osFontsCB->setChecked(
2978                 os_fonts_available && bp_.useNonTeXFonts);
2979
2980         outputModule->outputsyncCB->setChecked(bp_.output_sync);
2981         outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
2982
2983         outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
2984         outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
2985         outputModule->strictCB->setChecked(bp_.html_be_strict);
2986         outputModule->cssCB->setChecked(bp_.html_css_as_file);
2987
2988         // Fonts
2989         updateFontsize(documentClass().opt_fontsize(),
2990                         bp_.fontsize);
2991
2992         QString font = toqstr(bp_.fonts_roman);
2993         int rpos = fontModule->fontsRomanCO->findData(font);
2994         if (rpos == -1) {
2995                 rpos = fontModule->fontsRomanCO->count();
2996                 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
2997         }
2998         fontModule->fontsRomanCO->setCurrentIndex(rpos);
2999
3000         font = toqstr(bp_.fonts_sans);
3001         int spos = fontModule->fontsSansCO->findData(font);
3002         if (spos == -1) {
3003                 spos = fontModule->fontsSansCO->count();
3004                 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
3005         }
3006         fontModule->fontsSansCO->setCurrentIndex(spos);
3007
3008         font = toqstr(bp_.fonts_typewriter);
3009         int tpos = fontModule->fontsTypewriterCO->findData(font);
3010         if (tpos == -1) {
3011                 tpos = fontModule->fontsTypewriterCO->count();
3012                 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
3013         }
3014         fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
3015
3016         if (bp_.useNonTeXFonts && os_fonts_available) {
3017                 fontModule->fontencLA->setEnabled(false);
3018                 fontModule->fontencCO->setEnabled(false);
3019                 fontModule->fontencLE->setEnabled(false);
3020         } else {
3021                 fontModule->fontencLA->setEnabled(true);
3022                 fontModule->fontencCO->setEnabled(true);
3023                 fontModule->fontencLE->setEnabled(true);
3024                 romanChanged(rpos);
3025                 sansChanged(spos);
3026                 ttChanged(tpos);
3027         }
3028
3029         if (!bp_.fonts_cjk.empty())
3030                 fontModule->cjkFontLE->setText(
3031                         toqstr(bp_.fonts_cjk));
3032         else
3033                 fontModule->cjkFontLE->setText(QString());
3034
3035         fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3036         fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3037         fontModule->scaleSansSB->setValue(bp_.fonts_sans_scale);
3038         fontModule->scaleTypewriterSB->setValue(bp_.fonts_typewriter_scale);
3039
3040         int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3041         if (nn >= 0)
3042                 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3043
3044         if (bp_.fontenc == "global") {
3045                 fontModule->fontencCO->setCurrentIndex(0);
3046                 fontModule->fontencLE->setEnabled(false);
3047         } else if (bp_.fontenc == "default") {
3048                 fontModule->fontencCO->setCurrentIndex(2);
3049                 fontModule->fontencLE->setEnabled(false);
3050         } else {
3051                 fontModule->fontencCO->setCurrentIndex(1);
3052                 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3053         }
3054
3055         // paper
3056         bool const extern_geometry =
3057                 documentClass().provides("geometry");
3058         int const psize = bp_.papersize;
3059         pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3060         setCustomPapersize(!extern_geometry && psize == 1);
3061         pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3062
3063         bool const landscape =
3064                 bp_.orientation == ORIENTATION_LANDSCAPE;
3065         pageLayoutModule->landscapeRB->setChecked(landscape);
3066         pageLayoutModule->portraitRB->setChecked(!landscape);
3067         pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3068         pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3069
3070         pageLayoutModule->facingPagesCB->setChecked(
3071                 bp_.sides == TwoSides);
3072
3073         lengthToWidgets(pageLayoutModule->paperwidthLE,
3074                 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3075         lengthToWidgets(pageLayoutModule->paperheightLE,
3076                 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3077
3078         // margins
3079         Ui::MarginsUi * m = marginsModule;
3080
3081         setMargins();
3082
3083         lengthToWidgets(m->topLE, m->topUnit,
3084                 bp_.topmargin, default_unit);
3085
3086         lengthToWidgets(m->bottomLE, m->bottomUnit,
3087                 bp_.bottommargin, default_unit);
3088
3089         lengthToWidgets(m->innerLE, m->innerUnit,
3090                 bp_.leftmargin, default_unit);
3091
3092         lengthToWidgets(m->outerLE, m->outerUnit,
3093                 bp_.rightmargin, default_unit);
3094
3095         lengthToWidgets(m->headheightLE, m->headheightUnit,
3096                 bp_.headheight, default_unit);
3097
3098         lengthToWidgets(m->headsepLE, m->headsepUnit,
3099                 bp_.headsep, default_unit);
3100
3101         lengthToWidgets(m->footskipLE, m->footskipUnit,
3102                 bp_.footskip, default_unit);
3103
3104         lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3105                 bp_.columnsep, default_unit);
3106
3107         // branches
3108         updateUnknownBranches();
3109         branchesModule->update(bp_);
3110
3111         // PDF support
3112         PDFOptions const & pdf = bp_.pdfoptions();
3113         pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3114         if (bp_.documentClass().provides("hyperref"))
3115                 pdfSupportModule->use_hyperrefGB->setTitle(qt_("C&ustomize Hyperref Options"));
3116         else
3117                 pdfSupportModule->use_hyperrefGB->setTitle(qt_("&Use Hyperref Support"));
3118         pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3119         pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3120         pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3121         pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3122
3123         pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3124         pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3125         pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3126
3127         pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3128
3129         pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3130         pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3131         pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3132         pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3133
3134         nn = findToken(backref_opts, pdf.backref);
3135         if (nn >= 0)
3136                 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3137
3138         pdfSupportModule->fullscreenCB->setChecked
3139                 (pdf.pagemode == pdf.pagemode_fullscreen);
3140
3141         pdfSupportModule->optionsLE->setText(
3142                 toqstr(pdf.quoted_options));
3143
3144         // Make sure that the bc is in the INITIAL state
3145         if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3146                 bc().restore();
3147
3148         // clear changed branches cache
3149         changedBranches_.clear();
3150 }
3151
3152
3153 void GuiDocument::saveDocDefault()
3154 {
3155         // we have to apply the params first
3156         applyView();
3157         saveAsDefault();
3158 }
3159
3160
3161 void GuiDocument::updateAvailableModules()
3162 {
3163         modules_av_model_.clear();
3164         list<modInfoStruct> const & modInfoList = getModuleInfo();
3165         list<modInfoStruct>::const_iterator mit = modInfoList.begin();
3166         list<modInfoStruct>::const_iterator men = modInfoList.end();
3167         for (int i = 0; mit != men; ++mit, ++i)
3168                 modules_av_model_.insertRow(i, mit->name, mit->id,
3169                                 mit->description);
3170 }
3171
3172
3173 void GuiDocument::updateSelectedModules()
3174 {
3175         modules_sel_model_.clear();
3176         list<modInfoStruct> const selModList = getSelectedModules();
3177         list<modInfoStruct>::const_iterator mit = selModList.begin();
3178         list<modInfoStruct>::const_iterator men = selModList.end();
3179         for (int i = 0; mit != men; ++mit, ++i)
3180                 modules_sel_model_.insertRow(i, mit->name, mit->id,
3181                                 mit->description);
3182 }
3183
3184
3185 void GuiDocument::updateIncludeonlys()
3186 {
3187         masterChildModule->childrenTW->clear();
3188         QString const no = qt_("No");
3189         QString const yes = qt_("Yes");
3190
3191         if (includeonlys_.empty()) {
3192                 masterChildModule->includeallRB->setChecked(true);
3193                 masterChildModule->childrenTW->setEnabled(false);
3194                 masterChildModule->maintainAuxCB->setEnabled(false);
3195         } else {
3196                 masterChildModule->includeonlyRB->setChecked(true);
3197                 masterChildModule->childrenTW->setEnabled(true);
3198                 masterChildModule->maintainAuxCB->setEnabled(true);
3199         }
3200         QTreeWidgetItem * item = 0;
3201         ListOfBuffers children = buffer().getChildren();
3202         ListOfBuffers::const_iterator it  = children.begin();
3203         ListOfBuffers::const_iterator end = children.end();
3204         bool has_unincluded = false;
3205         bool all_unincluded = true;
3206         for (; it != end; ++it) {
3207                 item = new QTreeWidgetItem(masterChildModule->childrenTW);
3208                 // FIXME Unicode
3209                 string const name =
3210                         to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3211                                                         from_utf8(buffer().filePath())));
3212                 item->setText(0, toqstr(name));
3213                 item->setText(1, isChildIncluded(name) ? yes : no);
3214                 if (!isChildIncluded(name))
3215                         has_unincluded = true;
3216                 else
3217                         all_unincluded = false;
3218         }
3219         // Both if all childs are included and if none is included
3220         // is equal to "include all" (i.e., ommit \includeonly).
3221         // Thus, reset the GUI.
3222         if (!has_unincluded || all_unincluded) {
3223                 masterChildModule->includeallRB->setChecked(true);
3224                 masterChildModule->childrenTW->setEnabled(false);
3225                 includeonlys_.clear();
3226         }
3227         // If all are included, we need to update again.
3228         if (!has_unincluded)
3229                 updateIncludeonlys();
3230 }
3231
3232
3233 void GuiDocument::updateContents()
3234 {
3235         // Nothing to do here as the document settings is not cursor dependant.
3236         return;
3237 }
3238
3239
3240 void GuiDocument::useClassDefaults()
3241 {
3242         if (applyPB->isEnabled()) {
3243                 int const ret = Alert::prompt(_("Unapplied changes"),
3244                                 _("Some changes in the dialog were not yet applied.\n"
3245                                   "If you do not apply now, they will be lost after this action."),
3246                                 1, 1, _("&Apply"), _("&Dismiss"));
3247                 if (ret == 0)
3248                         applyView();
3249         }
3250
3251         int idx = latexModule->classCO->currentIndex();
3252         string const classname = classes_model_.getIDString(idx);
3253         if (!bp_.setBaseClass(classname)) {
3254                 Alert::error(_("Error"), _("Unable to set document class."));
3255                 return;
3256         }
3257         bp_.useClassDefaults();
3258         paramsToDialog();
3259 }
3260
3261
3262 void GuiDocument::setLayoutComboByIDString(string const & idString)
3263 {
3264         int idx = classes_model_.findIDString(idString);
3265         if (idx < 0)
3266                 Alert::warning(_("Can't set layout!"),
3267                         bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3268         else
3269                 latexModule->classCO->setCurrentIndex(idx);
3270 }
3271
3272
3273 bool GuiDocument::isValid()
3274 {
3275         return
3276                 validateListingsParameters().isEmpty() &&
3277                 localLayout->isValid() &&
3278                 (
3279                         // if we're asking for skips between paragraphs
3280                         !textLayoutModule->skipRB->isChecked() ||
3281                         // then either we haven't chosen custom
3282                         textLayoutModule->skipCO->currentIndex() != 3 ||
3283                         // or else a length has been given
3284                         !textLayoutModule->skipLE->text().isEmpty()
3285                 ) &&
3286                 (
3287                         // if we're asking for indentation
3288                         !textLayoutModule->indentRB->isChecked() ||
3289                         // then either we haven't chosen custom
3290                         textLayoutModule->indentCO->currentIndex() != 1 ||
3291                         // or else a length has been given
3292                         !textLayoutModule->indentLE->text().isEmpty()
3293                 );
3294 }
3295
3296
3297 char const * const GuiDocument::fontfamilies[5] = {
3298         "default", "rmdefault", "sfdefault", "ttdefault", ""
3299 };
3300
3301
3302 char const * GuiDocument::fontfamilies_gui[5] = {
3303         N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3304 };
3305
3306
3307 bool GuiDocument::initialiseParams(string const &)
3308 {
3309         BufferView const * view = bufferview();
3310         if (!view) {
3311                 bp_ = BufferParams();
3312                 paramsToDialog();
3313                 return true;
3314         }
3315         bp_ = view->buffer().params();
3316         loadModuleInfo();
3317         updateAvailableModules();
3318         //FIXME It'd be nice to make sure here that the selected
3319         //modules are consistent: That required modules are actually
3320         //selected, and that we don't have conflicts. If so, we could
3321         //at least pop up a warning.
3322         paramsToDialog();
3323         return true;
3324 }
3325
3326
3327 void GuiDocument::clearParams()
3328 {
3329         bp_ = BufferParams();
3330 }
3331
3332
3333 BufferId GuiDocument::id() const
3334 {
3335         BufferView const * const view = bufferview();
3336         return view? &view->buffer() : 0;
3337 }
3338
3339
3340 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3341 {
3342         return moduleNames_;
3343 }
3344
3345
3346 list<GuiDocument::modInfoStruct> const
3347                 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3348 {
3349         LayoutModuleList::const_iterator it =  mods.begin();
3350         LayoutModuleList::const_iterator end = mods.end();
3351         list<modInfoStruct> mInfo;
3352         for (; it != end; ++it) {
3353                 modInfoStruct m;
3354                 m.id = *it;
3355                 LyXModule const * const mod = theModuleList[*it];
3356                 if (mod)
3357                         // FIXME Unicode
3358                         m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
3359                 else
3360                         m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
3361                 mInfo.push_back(m);
3362         }
3363         return mInfo;
3364 }
3365
3366
3367 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3368 {
3369         return makeModuleInfo(params().getModules());
3370 }
3371
3372
3373 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3374 {
3375         return makeModuleInfo(params().baseClass()->providedModules());
3376 }
3377
3378
3379 DocumentClass const & GuiDocument::documentClass() const
3380 {
3381         return bp_.documentClass();
3382 }
3383
3384
3385 static void dispatch_bufferparams(Dialog const & dialog,
3386         BufferParams const & bp, FuncCode lfun)
3387 {
3388         ostringstream ss;
3389         ss << "\\begin_header\n";
3390         bp.writeFile(ss);
3391         ss << "\\end_header\n";
3392         dialog.dispatch(FuncRequest(lfun, ss.str()));
3393 }
3394
3395
3396 void GuiDocument::dispatchParams()
3397 {
3398         // This must come first so that a language change is correctly noticed
3399         setLanguage();
3400
3401         // Apply the BufferParams. Note that this will set the base class
3402         // and then update the buffer's layout.
3403         dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
3404
3405         if (!params().master.empty()) {
3406                 FileName const master_file = support::makeAbsPath(params().master,
3407                            support::onlyPath(buffer().absFileName()));
3408                 if (isLyXFileName(master_file.absFileName())) {
3409                         Buffer * master = checkAndLoadLyXFile(master_file);
3410                         if (master) {
3411                                 if (master->isChild(const_cast<Buffer *>(&buffer())))
3412                                         const_cast<Buffer &>(buffer()).setParent(master);
3413                                 else
3414                                         Alert::warning(_("Assigned master does not include this file"),
3415                                                 bformat(_("You must include this file in the document\n"
3416                                                           "'%1$s' in order to use the master document\n"
3417                                                           "feature."), from_utf8(params().master)));
3418                         } else
3419                                 Alert::warning(_("Could not load master"),
3420                                                 bformat(_("The master document '%1$s'\n"
3421                                                            "could not be loaded."),
3422                                                            from_utf8(params().master)));
3423                 }
3424         }
3425
3426         // Generate the colours requested by each new branch.
3427         BranchList & branchlist = params().branchlist();
3428         if (!branchlist.empty()) {
3429                 BranchList::const_iterator it = branchlist.begin();
3430                 BranchList::const_iterator const end = branchlist.end();
3431                 for (; it != end; ++it) {
3432                         docstring const & current_branch = it->branch();
3433                         Branch const * branch = branchlist.find(current_branch);
3434                         string const x11hexname = X11hexname(branch->color());
3435                         // display the new color
3436                         docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3437                         dispatch(FuncRequest(LFUN_SET_COLOR, str));
3438                 }
3439
3440                 // Open insets of selected branches, close deselected ones
3441                 dispatch(FuncRequest(LFUN_INSET_FORALL,
3442                         "Branch inset-toggle assign"));
3443         }
3444         // rename branches in the document
3445         executeBranchRenaming();
3446         // and clear changed branches cache
3447         changedBranches_.clear();
3448
3449         // Generate the colours requested by indices.
3450         IndicesList & indiceslist = params().indiceslist();
3451         if (!indiceslist.empty()) {
3452                 IndicesList::const_iterator it = indiceslist.begin();
3453                 IndicesList::const_iterator const end = indiceslist.end();
3454                 for (; it != end; ++it) {
3455                         docstring const & current_index = it->shortcut();
3456                         Index const * index = indiceslist.findShortcut(current_index);
3457                         string const x11hexname = X11hexname(index->color());
3458                         // display the new color
3459                         docstring const str = current_index + ' ' + from_ascii(x11hexname);
3460                         dispatch(FuncRequest(LFUN_SET_COLOR, str));
3461                 }
3462         }
3463         // FIXME LFUN
3464         // If we used an LFUN, we would not need these two lines:
3465         BufferView * bv = const_cast<BufferView *>(bufferview());
3466         bv->processUpdateFlags(Update::Force | Update::FitCursor);
3467 }
3468
3469
3470 void GuiDocument::setLanguage() const
3471 {
3472         Language const * const newL = bp_.language;
3473         if (buffer().params().language == newL)
3474                 return;
3475
3476         string const & lang_name = newL->lang();
3477         dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3478 }
3479
3480
3481 void GuiDocument::saveAsDefault() const
3482 {
3483         dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
3484 }
3485
3486
3487 bool GuiDocument::isFontAvailable(string const & font) const
3488 {
3489         if (font == "default" || font == "cmr"
3490             || font == "cmss" || font == "cmtt")
3491                 // these are standard
3492                 return true;
3493         if (font == "lmodern" || font == "lmss" || font == "lmtt")
3494                 return LaTeXFeatures::isAvailable("lmodern");
3495         if (font == "times" || font == "palatino"
3496                  || font == "helvet" || font == "courier")
3497                 return LaTeXFeatures::isAvailable("psnfss");
3498         if (font == "cmbr" || font == "cmtl")
3499                 return LaTeXFeatures::isAvailable("cmbright");
3500         if (font == "utopia")
3501                 return LaTeXFeatures::isAvailable("utopia")
3502                         || LaTeXFeatures::isAvailable("fourier");
3503         if (font == "beraserif" || font == "berasans"
3504                 || font == "beramono")
3505                 return LaTeXFeatures::isAvailable("bera");
3506         return LaTeXFeatures::isAvailable(font);
3507 }
3508
3509
3510 bool GuiDocument::providesOSF(string const & font) const
3511 {
3512         if (fontModule->osFontsCB->isChecked())
3513                 // FIXME: we should check if the fonts really
3514                 // have OSF support. But how?
3515                 return true;
3516         if (font == "cmr")
3517                 return isFontAvailable("eco");
3518         if (font == "palatino")
3519                 return isFontAvailable("mathpazo");
3520         return false;
3521 }
3522
3523
3524 bool GuiDocument::providesSC(string const & font) const
3525 {
3526         if (fontModule->osFontsCB->isChecked())
3527                 return false;
3528         if (font == "palatino")
3529                 return isFontAvailable("mathpazo");
3530         if (font == "utopia")
3531                 return isFontAvailable("fourier");
3532         return false;
3533 }
3534
3535
3536 bool GuiDocument::providesScale(string const & font) const
3537 {
3538         if (fontModule->osFontsCB->isChecked())
3539                 return true;
3540         return font == "helvet" || font == "luximono"
3541                 || font == "berasans"  || font == "beramono";
3542 }
3543
3544
3545 void GuiDocument::loadModuleInfo()
3546 {
3547         moduleNames_.clear();
3548         LyXModuleList::const_iterator it  = theModuleList.begin();
3549         LyXModuleList::const_iterator end = theModuleList.end();
3550         for (; it != end; ++it) {
3551                 modInfoStruct m;
3552                 m.id = it->getID();
3553                 // FIXME Unicode
3554                 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3555                 // this is supposed to give us the first sentence of the description
3556                 // FIXME Unicode
3557                 QString desc =
3558                         toqstr(translateIfPossible(from_utf8(it->getDescription())));
3559                 int const pos = desc.indexOf(".");
3560                 if (pos > 0)
3561                         desc.truncate(pos + 1);
3562                 m.description = desc;
3563                 moduleNames_.push_back(m);
3564         }
3565 }
3566
3567
3568 void GuiDocument::updateUnknownBranches()
3569 {
3570         if (!bufferview())
3571                 return;
3572         list<docstring> used_branches;
3573         buffer().getUsedBranches(used_branches);
3574         list<docstring>::const_iterator it = used_branches.begin();
3575         QStringList unknown_branches;
3576         for (; it != used_branches.end() ; ++it) {
3577                 if (!buffer().params().branchlist().find(*it))
3578                         unknown_branches.append(toqstr(*it));
3579         }
3580         branchesModule->setUnknownBranches(unknown_branches);
3581 }
3582
3583
3584 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3585 {
3586         map<docstring, docstring>::iterator it = changedBranches_.begin();
3587         for (; it != changedBranches_.end() ; ++it) {
3588                 if (it->second == oldname) {
3589                         // branch has already been renamed
3590                         it->second = newname;
3591                         return;
3592                 }
3593         }
3594         // store new name
3595         changedBranches_[oldname] = newname;
3596 }
3597
3598
3599 void GuiDocument::executeBranchRenaming() const
3600 {
3601         map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3602         for (; it != changedBranches_.end() ; ++it) {
3603                 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3604                 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3605         }
3606 }
3607
3608
3609 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
3610
3611
3612 } // namespace frontend
3613 } // namespace lyx
3614
3615 #include "moc_GuiDocument.cpp"