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(change_adaptor()));
1110         connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
1111                 this, SLOT(change_adaptor()));
1112         connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1113                 this, SLOT(change_adaptor()));
1114         connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
1115                 this, SLOT(change_adaptor()));
1116         connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1117                 this, SLOT(change_adaptor()));
1118         connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1119                 this, SLOT(bibtexChanged(int)));
1120         connect(biblioModule->bibtexOptionsLE, SIGNAL(textChanged(QString)),
1121                 this, SLOT(change_adaptor()));
1122         connect(biblioModule->bibtexStyleLE, SIGNAL(textChanged(QString)),
1123                 this, SLOT(change_adaptor()));
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::bibtexChanged(int n)
1992 {
1993         biblioModule->bibtexOptionsLE->setEnabled(
1994                 biblioModule->bibtexCO->itemData(n).toString() != "default");
1995         changed();
1996 }
1997
1998
1999 namespace {
2000         // FIXME unicode
2001         // both of these should take a vector<docstring>
2002
2003         // This is an insanely complicated attempt to make this sort of thing
2004         // work with RTL languages.
2005         docstring formatStrVec(vector<string> const & v, docstring const & s)
2006         {
2007                 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
2008                 if (v.size() == 0)
2009                         return docstring();
2010                 if (v.size() == 1)
2011                         return translateIfPossible(from_utf8(v[0]));
2012                 if (v.size() == 2) {
2013                         docstring retval = _("%1$s and %2$s");
2014                         retval = subst(retval, _("and"), s);
2015                         return bformat(retval, translateIfPossible(from_utf8(v[0])),
2016                                        translateIfPossible(from_utf8(v[1])));
2017                 }
2018                 // The idea here is to format all but the last two items...
2019                 int const vSize = v.size();
2020                 docstring t2 = _("%1$s, %2$s");
2021                 docstring retval = translateIfPossible(from_utf8(v[0]));
2022                 for (int i = 1; i < vSize - 2; ++i)
2023                         retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
2024                 //...and then to  plug them, and the last two, into this schema
2025                 docstring t = _("%1$s, %2$s, and %3$s");
2026                 t = subst(t, _("and"), s);
2027                 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
2028                                translateIfPossible(from_utf8(v[vSize - 1])));
2029         }
2030
2031         vector<string> idsToNames(vector<string> const & idList)
2032         {
2033                 vector<string> retval;
2034                 vector<string>::const_iterator it  = idList.begin();
2035                 vector<string>::const_iterator end = idList.end();
2036                 for (; it != end; ++it) {
2037                         LyXModule const * const mod = theModuleList[*it];
2038                         if (!mod)
2039                                 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
2040                                                 translateIfPossible(from_utf8(*it)))));
2041                         else
2042                                 retval.push_back(mod->getName());
2043                 }
2044                 return retval;
2045         }
2046 } // end anonymous namespace
2047
2048
2049 void GuiDocument::modulesToParams(BufferParams & bp)
2050 {
2051         // update list of loaded modules
2052         bp.clearLayoutModules();
2053         int const srows = modules_sel_model_.rowCount();
2054         for (int i = 0; i < srows; ++i)
2055                 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2056
2057         // update the list of removed modules
2058         bp.clearRemovedModules();
2059         LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2060         list<string>::const_iterator rit = reqmods.begin();
2061         list<string>::const_iterator ren = reqmods.end();
2062
2063         // check each of the default modules
2064         for (; rit != ren; rit++) {
2065                 list<string>::const_iterator mit = bp.getModules().begin();
2066                 list<string>::const_iterator men = bp.getModules().end();
2067                 bool found = false;
2068                 for (; mit != men; mit++) {
2069                         if (*rit == *mit) {
2070                                 found = true;
2071                                 break;
2072                         }
2073                 }
2074                 if (!found) {
2075                         // the module isn't present so must have been removed by the user
2076                         bp.addRemovedModule(*rit);
2077                 }
2078         }
2079 }
2080
2081 void GuiDocument::modulesChanged()
2082 {
2083         modulesToParams(bp_);
2084         bp_.makeDocumentClass();
2085         paramsToDialog();
2086 }
2087
2088
2089 void GuiDocument::updateModuleInfo()
2090 {
2091         selectionManager->update();
2092
2093         //Module description
2094         bool const focus_on_selected = selectionManager->selectedFocused();
2095         QAbstractItemView * lv;
2096         if (focus_on_selected)
2097                 lv = modulesModule->selectedLV;
2098         else
2099                 lv= modulesModule->availableLV;
2100         if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2101                 modulesModule->infoML->document()->clear();
2102                 return;
2103         }
2104         QModelIndex const & idx = lv->selectionModel()->currentIndex();
2105         GuiIdListModel const & id_model =
2106                         focus_on_selected  ? modules_sel_model_ : modules_av_model_;
2107         string const modName = id_model.getIDString(idx.row());
2108         docstring desc = getModuleDescription(modName);
2109
2110         LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2111         if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2112                 if (!desc.empty())
2113                         desc += "\n";
2114                 desc += _("Module provided by document class.");
2115         }
2116
2117         vector<string> pkglist = getPackageList(modName);
2118         docstring pkgdesc = formatStrVec(pkglist, _("and"));
2119         if (!pkgdesc.empty()) {
2120                 if (!desc.empty())
2121                         desc += "\n";
2122                 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2123         }
2124
2125         pkglist = getRequiredList(modName);
2126         if (!pkglist.empty()) {
2127                 vector<string> const reqdescs = idsToNames(pkglist);
2128                 pkgdesc = formatStrVec(reqdescs, _("or"));
2129                 if (!desc.empty())
2130                         desc += "\n";
2131                 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2132         }
2133
2134         pkglist = getExcludedList(modName);
2135         if (!pkglist.empty()) {
2136                 vector<string> const reqdescs = idsToNames(pkglist);
2137                 pkgdesc = formatStrVec(reqdescs, _( "and"));
2138                 if (!desc.empty())
2139                         desc += "\n";
2140                 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2141         }
2142
2143         if (!isModuleAvailable(modName)) {
2144                 if (!desc.empty())
2145                         desc += "\n";
2146                 desc += _("WARNING: Some required packages are unavailable!");
2147         }
2148
2149         modulesModule->infoML->document()->setPlainText(toqstr(desc));
2150 }
2151
2152
2153 void GuiDocument::updateNumbering()
2154 {
2155         DocumentClass const & tclass = documentClass();
2156
2157         numberingModule->tocTW->setUpdatesEnabled(false);
2158         numberingModule->tocTW->clear();
2159
2160         int const depth = numberingModule->depthSL->value();
2161         int const toc = numberingModule->tocSL->value();
2162         QString const no = qt_("No");
2163         QString const yes = qt_("Yes");
2164         QTreeWidgetItem * item = 0;
2165
2166         DocumentClass::const_iterator lit = tclass.begin();
2167         DocumentClass::const_iterator len = tclass.end();
2168         for (; lit != len; ++lit) {
2169                 int const toclevel = lit->toclevel;
2170                 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
2171                         item = new QTreeWidgetItem(numberingModule->tocTW);
2172                         item->setText(0, toqstr(translateIfPossible(lit->name())));
2173                         item->setText(1, (toclevel <= depth) ? yes : no);
2174                         item->setText(2, (toclevel <= toc) ? yes : no);
2175                 }
2176         }
2177
2178         numberingModule->tocTW->setUpdatesEnabled(true);
2179         numberingModule->tocTW->update();
2180 }
2181
2182
2183 void GuiDocument::updateDefaultFormat()
2184 {
2185         if (!bufferview())
2186                 return;
2187         // make a copy in order to consider unapplied changes
2188         BufferParams param_copy = buffer().params();
2189         param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2190         int const idx = latexModule->classCO->currentIndex();
2191         if (idx >= 0) {
2192                 string const classname = classes_model_.getIDString(idx);
2193                 param_copy.setBaseClass(classname);
2194                 param_copy.makeDocumentClass();
2195         }
2196         outputModule->defaultFormatCO->blockSignals(true);
2197         outputModule->defaultFormatCO->clear();
2198         outputModule->defaultFormatCO->addItem(qt_("Default"),
2199                                 QVariant(QString("default")));
2200         typedef vector<Format const *> Formats;
2201         Formats formats = param_copy.exportableFormats(true);
2202         Formats::const_iterator cit = formats.begin();
2203         Formats::const_iterator end = formats.end();
2204         for (; cit != end; ++cit)
2205                 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
2206                                 QVariant(toqstr((*cit)->name())));
2207         outputModule->defaultFormatCO->blockSignals(false);
2208 }
2209
2210
2211 bool GuiDocument::isChildIncluded(string const & child)
2212 {
2213         if (includeonlys_.empty())
2214                 return false;
2215         return (std::find(includeonlys_.begin(),
2216                           includeonlys_.end(), child) != includeonlys_.end());
2217 }
2218
2219
2220 void GuiDocument::applyView()
2221 {
2222         // preamble
2223         preambleModule->apply(bp_);
2224         localLayout->apply(bp_);
2225
2226         // date
2227         bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2228         bp_.use_refstyle  = latexModule->refstyleCB->isChecked();
2229
2230         // biblio
2231         bp_.setCiteEngine(ENGINE_BASIC);
2232
2233         if (biblioModule->citeNatbibRB->isChecked()) {
2234                 bool const use_numerical_citations =
2235                         biblioModule->citeStyleCO->currentIndex();
2236                 if (use_numerical_citations)
2237                         bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
2238                 else
2239                         bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
2240
2241         } else if (biblioModule->citeJurabibRB->isChecked())
2242                 bp_.setCiteEngine(ENGINE_JURABIB);
2243
2244         bp_.use_bibtopic =
2245                 biblioModule->bibtopicCB->isChecked();
2246
2247         bp_.biblio_style = fromqstr(biblioModule->bibtexStyleLE->text());
2248
2249         string const bibtex_command =
2250                 fromqstr(biblioModule->bibtexCO->itemData(
2251                         biblioModule->bibtexCO->currentIndex()).toString());
2252         string const bibtex_options =
2253                 fromqstr(biblioModule->bibtexOptionsLE->text());
2254         if (bibtex_command == "default" || bibtex_options.empty())
2255                 bp_.bibtex_command = bibtex_command;
2256         else
2257                 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2258
2259         buffer().removeBiblioTempFiles();
2260
2261         // Indices
2262         indicesModule->apply(bp_);
2263
2264         // language & quotes
2265         if (langModule->defaultencodingRB->isChecked()) {
2266                 bp_.inputenc = "auto";
2267         } else {
2268                 int i = langModule->encodingCO->currentIndex();
2269                 if (i == 0)
2270                         bp_.inputenc = "default";
2271                 else {
2272                         QString const enc_gui =
2273                                 langModule->encodingCO->currentText();
2274                         Encodings::const_iterator it = encodings.begin();
2275                         Encodings::const_iterator const end = encodings.end();
2276                         bool found = false;
2277                         for (; it != end; ++it) {
2278                                 if (qt_(it->guiName()) == enc_gui) {
2279                                         bp_.inputenc = it->latexName();
2280                                         found = true;
2281                                         break;
2282                                 }
2283                         }
2284                         if (!found) {
2285                                 // should not happen
2286                                 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2287                                 bp_.inputenc = "default";
2288                         }
2289                 }
2290         }
2291
2292         InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
2293         switch (langModule->quoteStyleCO->currentIndex()) {
2294         case 0:
2295                 lga = InsetQuotes::EnglishQuotes;
2296                 break;
2297         case 1:
2298                 lga = InsetQuotes::SwedishQuotes;
2299                 break;
2300         case 2:
2301                 lga = InsetQuotes::GermanQuotes;
2302                 break;
2303         case 3:
2304                 lga = InsetQuotes::PolishQuotes;
2305                 break;
2306         case 4:
2307                 lga = InsetQuotes::FrenchQuotes;
2308                 break;
2309         case 5:
2310                 lga = InsetQuotes::DanishQuotes;
2311                 break;
2312         }
2313         bp_.quotes_language = lga;
2314
2315         QString const lang = langModule->languageCO->itemData(
2316                 langModule->languageCO->currentIndex()).toString();
2317         bp_.language = lyx::languages.getLanguage(fromqstr(lang));
2318
2319         QString const pack = langModule->languagePackageCO->itemData(
2320                 langModule->languagePackageCO->currentIndex()).toString();
2321         if (pack == "custom")
2322                 bp_.lang_package =
2323                         fromqstr(langModule->languagePackageLE->text());
2324         else
2325                 bp_.lang_package = fromqstr(pack);
2326
2327         //color
2328         bp_.backgroundcolor = set_backgroundcolor;
2329         bp_.isbackgroundcolor = is_backgroundcolor;
2330         bp_.fontcolor = set_fontcolor;
2331         bp_.isfontcolor = is_fontcolor;
2332         bp_.notefontcolor = set_notefontcolor;
2333         bp_.boxbgcolor = set_boxbgcolor;
2334
2335         // numbering
2336         if (bp_.documentClass().hasTocLevels()) {
2337                 bp_.tocdepth = numberingModule->tocSL->value();
2338                 bp_.secnumdepth = numberingModule->depthSL->value();
2339         }
2340
2341         // bullets
2342         bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2343         bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2344         bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2345         bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2346
2347         // packages
2348         bp_.graphics_driver =
2349                 tex_graphics[latexModule->psdriverCO->currentIndex()];
2350
2351         // text layout
2352         int idx = latexModule->classCO->currentIndex();
2353         if (idx >= 0) {
2354                 string const classname = classes_model_.getIDString(idx);
2355                 bp_.setBaseClass(classname);
2356         }
2357
2358         // Modules
2359         modulesToParams(bp_);
2360
2361         // Math
2362         if (mathsModule->amsautoCB->isChecked())
2363                 bp_.use_amsmath = BufferParams::package_auto;
2364         else {
2365                 if (mathsModule->amsCB->isChecked())
2366                         bp_.use_amsmath = BufferParams::package_on;
2367                 else
2368                         bp_.use_amsmath = BufferParams::package_off;
2369         }
2370         if (mathsModule->esintautoCB->isChecked())
2371                 bp_.use_esint = BufferParams::package_auto;
2372         else {
2373                 if (mathsModule->esintCB->isChecked())
2374                         bp_.use_esint = BufferParams::package_on;
2375                 else
2376                         bp_.use_esint = BufferParams::package_off;
2377         }
2378         if (mathsModule->mhchemautoCB->isChecked())
2379                 bp_.use_mhchem = BufferParams::package_auto;
2380         else {
2381                 if (mathsModule->mhchemCB->isChecked())
2382                         bp_.use_mhchem = BufferParams::package_on;
2383                 else
2384                         bp_.use_mhchem = BufferParams::package_off;
2385         }
2386         if (mathsModule->mathdotsautoCB->isChecked())
2387                 bp_.use_mathdots = BufferParams::package_auto;
2388         else {
2389                 if (mathsModule->mathdotsCB->isChecked())
2390                         bp_.use_mathdots = BufferParams::package_on;
2391                 else
2392                         bp_.use_mathdots = BufferParams::package_off;
2393         }
2394         if (mathsModule->undertildeautoCB->isChecked())
2395                 bp_.use_undertilde = BufferParams::package_auto;
2396         else {
2397                 if (mathsModule->undertildeCB->isChecked())
2398                         bp_.use_undertilde = BufferParams::package_on;
2399                 else
2400                         bp_.use_undertilde = BufferParams::package_off;
2401         }
2402
2403         // Page Layout
2404         if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2405                 bp_.pagestyle = "default";
2406         else {
2407                 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2408                 for (size_t i = 0; i != pagestyles.size(); ++i)
2409                         if (pagestyles[i].second == style_gui)
2410                                 bp_.pagestyle = pagestyles[i].first;
2411         }
2412
2413         // Text Layout
2414         switch (textLayoutModule->lspacingCO->currentIndex()) {
2415         case 0:
2416                 bp_.spacing().set(Spacing::Single);
2417                 break;
2418         case 1:
2419                 bp_.spacing().set(Spacing::Onehalf);
2420                 break;
2421         case 2:
2422                 bp_.spacing().set(Spacing::Double);
2423                 break;
2424         case 3: {
2425                 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2426                 if (s.empty())
2427                         bp_.spacing().set(Spacing::Single);
2428                 else
2429                         bp_.spacing().set(Spacing::Other, s);
2430                 break;
2431                 }
2432         }
2433
2434         if (textLayoutModule->twoColumnCB->isChecked())
2435                 bp_.columns = 2;
2436         else
2437                 bp_.columns = 1;
2438
2439         bp_.justification = textLayoutModule->justCB->isChecked();
2440
2441         if (textLayoutModule->indentRB->isChecked()) {
2442                 // if paragraphs are separated by an indentation
2443                 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2444                 switch (textLayoutModule->indentCO->currentIndex()) {
2445                 case 0:
2446                         bp_.setIndentation(HSpace(HSpace::DEFAULT));
2447                         break;
2448                 case 1: {
2449                         HSpace indent = HSpace(
2450                                 widgetsToLength(textLayoutModule->indentLE,
2451                                 textLayoutModule->indentLengthCO)
2452                                 );
2453                         bp_.setIndentation(indent);
2454                         break;
2455                         }
2456                 default:
2457                         // this should never happen
2458                         bp_.setIndentation(HSpace(HSpace::DEFAULT));
2459                         break;
2460                 }
2461         } else {
2462                 // if paragraphs are separated by a skip
2463                 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2464                 switch (textLayoutModule->skipCO->currentIndex()) {
2465                 case 0:
2466                         bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2467                         break;
2468                 case 1:
2469                         bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2470                         break;
2471                 case 2:
2472                         bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2473                         break;
2474                 case 3:
2475                         {
2476                         VSpace vs = VSpace(
2477                                 widgetsToLength(textLayoutModule->skipLE,
2478                                 textLayoutModule->skipLengthCO)
2479                                 );
2480                         bp_.setDefSkip(vs);
2481                         break;
2482                         }
2483                 default:
2484                         // this should never happen
2485                         bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2486                         break;
2487                 }
2488         }
2489
2490         bp_.options =
2491                 fromqstr(latexModule->optionsLE->text());
2492
2493         bp_.use_default_options =
2494                 latexModule->defaultOptionsCB->isChecked();
2495
2496         if (latexModule->childDocGB->isChecked())
2497                 bp_.master =
2498                         fromqstr(latexModule->childDocLE->text());
2499         else
2500                 bp_.master = string();
2501
2502         // Master/Child
2503         bp_.clearIncludedChildren();
2504         if (masterChildModule->includeonlyRB->isChecked()) {
2505                 list<string>::const_iterator it = includeonlys_.begin();
2506                 for (; it != includeonlys_.end() ; ++it) {
2507                         bp_.addIncludedChildren(*it);
2508                 }
2509         }
2510         bp_.maintain_unincluded_children =
2511                 masterChildModule->maintainAuxCB->isChecked();
2512
2513         // Float Placement
2514         bp_.float_placement = floatModule->get();
2515
2516         // Listings
2517         // text should have passed validation
2518         bp_.listings_params =
2519                 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2520
2521         // output
2522         bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2523                 outputModule->defaultFormatCO->currentIndex()).toString());
2524
2525         bool const nontexfonts = fontModule->osFontsCB->isChecked();
2526         bp_.useNonTeXFonts = nontexfonts;
2527
2528         bp_.output_sync = outputModule->outputsyncCB->isChecked();
2529
2530         bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2531
2532         int mathfmt = outputModule->mathoutCB->currentIndex();
2533         if (mathfmt == -1)
2534                 mathfmt = 0;
2535         BufferParams::MathOutput const mo =
2536                 static_cast<BufferParams::MathOutput>(mathfmt);
2537         bp_.html_math_output = mo;
2538         bp_.html_be_strict = outputModule->strictCB->isChecked();
2539         bp_.html_css_as_file = outputModule->cssCB->isChecked();
2540         bp_.html_math_img_scale = outputModule->mathimgSB->value();
2541
2542         // fonts
2543         bp_.fonts_roman =
2544                 fromqstr(fontModule->fontsRomanCO->
2545                         itemData(fontModule->fontsRomanCO->currentIndex()).toString());
2546
2547         bp_.fonts_sans =
2548                 fromqstr(fontModule->fontsSansCO->
2549                         itemData(fontModule->fontsSansCO->currentIndex()).toString());
2550
2551         bp_.fonts_typewriter =
2552                 fromqstr(fontModule->fontsTypewriterCO->
2553                         itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
2554
2555         if (fontModule->fontencCO->currentIndex() == 0)
2556                 bp_.fontenc = "global";
2557         else if (fontModule->fontencCO->currentIndex() == 1)
2558                 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2559         else if (fontModule->fontencCO->currentIndex() == 2)
2560                 bp_.fontenc = "default";
2561
2562         bp_.fonts_cjk =
2563                 fromqstr(fontModule->cjkFontLE->text());
2564
2565         bp_.fonts_sans_scale = fontModule->scaleSansSB->value();
2566
2567         bp_.fonts_typewriter_scale = fontModule->scaleTypewriterSB->value();
2568
2569         bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2570
2571         bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2572
2573         if (nontexfonts)
2574                 bp_.fonts_default_family = "default";
2575         else
2576                 bp_.fonts_default_family = GuiDocument::fontfamilies[
2577                         fontModule->fontsDefaultCO->currentIndex()];
2578
2579         if (fontModule->fontsizeCO->currentIndex() == 0)
2580                 bp_.fontsize = "default";
2581         else
2582                 bp_.fontsize =
2583                         fromqstr(fontModule->fontsizeCO->currentText());
2584
2585         // paper
2586         bp_.papersize = PAPER_SIZE(
2587                 pageLayoutModule->papersizeCO->currentIndex());
2588
2589         bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2590                 pageLayoutModule->paperwidthUnitCO);
2591
2592         bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2593                 pageLayoutModule->paperheightUnitCO);
2594
2595         if (pageLayoutModule->facingPagesCB->isChecked())
2596                 bp_.sides = TwoSides;
2597         else
2598                 bp_.sides = OneSide;
2599
2600         if (pageLayoutModule->landscapeRB->isChecked())
2601                 bp_.orientation = ORIENTATION_LANDSCAPE;
2602         else
2603                 bp_.orientation = ORIENTATION_PORTRAIT;
2604
2605         // margins
2606         bp_.use_geometry = !marginsModule->marginCB->isChecked();
2607
2608         Ui::MarginsUi const * m = marginsModule;
2609
2610         bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2611         bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2612         bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2613         bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2614         bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2615         bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2616         bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2617         bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2618
2619         // branches
2620         branchesModule->apply(bp_);
2621
2622         // PDF support
2623         PDFOptions & pdf = bp_.pdfoptions();
2624         pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2625         pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2626         pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2627         pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2628         pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2629
2630         pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2631         pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2632         pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2633         pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2634
2635         pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2636         pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2637         pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2638         pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2639         pdf.backref =
2640                 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2641         if (pdfSupportModule->fullscreenCB->isChecked())
2642                 pdf.pagemode = pdf.pagemode_fullscreen;
2643         else
2644                 pdf.pagemode.clear();
2645         pdf.quoted_options = pdf.quoted_options_check(
2646                                 fromqstr(pdfSupportModule->optionsLE->text()));
2647 }
2648
2649
2650 void GuiDocument::paramsToDialog()
2651 {
2652         // set the default unit
2653         Length::UNIT const default_unit = Length::defaultUnit();
2654
2655         // preamble
2656         preambleModule->update(bp_, id());
2657         localLayout->update(bp_, id());
2658
2659         // date
2660         latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2661         latexModule->refstyleCB->setChecked(bp_.use_refstyle);
2662
2663         // biblio
2664         biblioModule->citeDefaultRB->setChecked(
2665                 bp_.citeEngine() == ENGINE_BASIC);
2666
2667         biblioModule->citeNatbibRB->setChecked(
2668                 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2669                 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2670
2671         biblioModule->citeStyleCO->setCurrentIndex(
2672                 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2673
2674         biblioModule->citeJurabibRB->setChecked(
2675                 bp_.citeEngine() == ENGINE_JURABIB);
2676
2677         biblioModule->bibtopicCB->setChecked(
2678                 bp_.use_bibtopic);
2679
2680         biblioModule->bibtexStyleLE->setText(toqstr(bp_.biblio_style));
2681
2682         string command;
2683         string options =
2684                 split(bp_.bibtex_command, command, ' ');
2685
2686         int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2687         if (bpos != -1) {
2688                 biblioModule->bibtexCO->setCurrentIndex(bpos);
2689                 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
2690         } else {
2691                 // We reset to default if we do not know the specified compiler
2692                 // This is for security reasons
2693                 biblioModule->bibtexCO->setCurrentIndex(
2694                         biblioModule->bibtexCO->findData(toqstr("default")));
2695                 biblioModule->bibtexOptionsLE->clear();
2696         }
2697         biblioModule->bibtexOptionsLE->setEnabled(
2698                 biblioModule->bibtexCO->currentIndex() != 0);
2699
2700         // indices
2701         indicesModule->update(bp_);
2702
2703         // language & quotes
2704         int const pos = langModule->languageCO->findData(toqstr(
2705                 bp_.language->lang()));
2706         langModule->languageCO->setCurrentIndex(pos);
2707
2708         langModule->quoteStyleCO->setCurrentIndex(
2709                 bp_.quotes_language);
2710
2711         bool default_enc = true;
2712         if (bp_.inputenc != "auto") {
2713                 default_enc = false;
2714                 if (bp_.inputenc == "default") {
2715                         langModule->encodingCO->setCurrentIndex(0);
2716                 } else {
2717                         string enc_gui;
2718                         Encodings::const_iterator it = encodings.begin();
2719                         Encodings::const_iterator const end = encodings.end();
2720                         for (; it != end; ++it) {
2721                                 if (it->latexName() == bp_.inputenc) {
2722                                         enc_gui = it->guiName();
2723                                         break;
2724                                 }
2725                         }
2726                         int const i = langModule->encodingCO->findText(
2727                                         qt_(enc_gui));
2728                         if (i >= 0)
2729                                 langModule->encodingCO->setCurrentIndex(i);
2730                         else
2731                                 // unknown encoding. Set to default.
2732                                 default_enc = true;
2733                 }
2734         }
2735         langModule->defaultencodingRB->setChecked(default_enc);
2736         langModule->otherencodingRB->setChecked(!default_enc);
2737
2738         int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
2739         if (p == -1) {
2740                 langModule->languagePackageCO->setCurrentIndex(
2741                           langModule->languagePackageCO->findData("custom"));
2742                 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
2743         } else {
2744                 langModule->languagePackageCO->setCurrentIndex(p);
2745                 langModule->languagePackageLE->clear();
2746         }
2747
2748         //color
2749         if (bp_.isfontcolor) {
2750                 colorModule->fontColorPB->setStyleSheet(
2751                         colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
2752         }
2753         set_fontcolor = bp_.fontcolor;
2754         is_fontcolor = bp_.isfontcolor;
2755
2756         colorModule->noteFontColorPB->setStyleSheet(
2757                 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
2758         set_notefontcolor = bp_.notefontcolor;
2759
2760         if (bp_.isbackgroundcolor) {
2761                 colorModule->backgroundPB->setStyleSheet(
2762                         colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2763         }
2764         set_backgroundcolor = bp_.backgroundcolor;
2765         is_backgroundcolor = bp_.isbackgroundcolor;
2766
2767         colorModule->boxBackgroundPB->setStyleSheet(
2768                 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
2769         set_boxbgcolor = bp_.boxbgcolor;
2770
2771         // numbering
2772         int const min_toclevel = documentClass().min_toclevel();
2773         int const max_toclevel = documentClass().max_toclevel();
2774         if (documentClass().hasTocLevels()) {
2775                 numberingModule->setEnabled(true);
2776                 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2777                 numberingModule->depthSL->setMaximum(max_toclevel);
2778                 numberingModule->depthSL->setValue(bp_.secnumdepth);
2779                 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2780                 numberingModule->tocSL->setMaximum(max_toclevel);
2781                 numberingModule->tocSL->setValue(bp_.tocdepth);
2782                 updateNumbering();
2783         } else {
2784                 numberingModule->setEnabled(false);
2785                 numberingModule->tocTW->clear();
2786         }
2787
2788         // bullets
2789         bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2790         bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2791         bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2792         bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2793         bulletsModule->init();
2794
2795         // packages
2796         int nitem = findToken(tex_graphics, bp_.graphics_driver);
2797         if (nitem >= 0)
2798                 latexModule->psdriverCO->setCurrentIndex(nitem);
2799         updateModuleInfo();
2800
2801         mathsModule->amsCB->setChecked(
2802                 bp_.use_amsmath == BufferParams::package_on);
2803         mathsModule->amsautoCB->setChecked(
2804                 bp_.use_amsmath == BufferParams::package_auto);
2805
2806         mathsModule->esintCB->setChecked(
2807                 bp_.use_esint == BufferParams::package_on);
2808         mathsModule->esintautoCB->setChecked(
2809                 bp_.use_esint == BufferParams::package_auto);
2810
2811         mathsModule->mhchemCB->setChecked(
2812                 bp_.use_mhchem == BufferParams::package_on);
2813         mathsModule->mhchemautoCB->setChecked(
2814                 bp_.use_mhchem == BufferParams::package_auto);
2815
2816         mathsModule->mathdotsCB->setChecked(
2817                 bp_.use_mathdots == BufferParams::package_on);
2818         mathsModule->mathdotsautoCB->setChecked(
2819                 bp_.use_mathdots == BufferParams::package_auto);
2820
2821         mathsModule->undertildeCB->setChecked(
2822                 bp_.use_undertilde == BufferParams::package_on);
2823         mathsModule->undertildeautoCB->setChecked(
2824                 bp_.use_undertilde == BufferParams::package_auto);
2825
2826         switch (bp_.spacing().getSpace()) {
2827                 case Spacing::Other: nitem = 3; break;
2828                 case Spacing::Double: nitem = 2; break;
2829                 case Spacing::Onehalf: nitem = 1; break;
2830                 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2831         }
2832
2833         // text layout
2834         string const & layoutID = bp_.baseClassID();
2835         setLayoutComboByIDString(layoutID);
2836
2837         updatePagestyle(documentClass().opt_pagestyle(),
2838                                  bp_.pagestyle);
2839
2840         textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2841         if (bp_.spacing().getSpace() == Spacing::Other) {
2842                 doubleToWidget(textLayoutModule->lspacingLE,
2843                         bp_.spacing().getValueAsString());
2844         }
2845         setLSpacing(nitem);
2846
2847         if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
2848                 textLayoutModule->indentRB->setChecked(true);
2849                 string indentation = bp_.getIndentation().asLyXCommand();
2850                 int indent = 0;
2851                 if (indentation != "default") {
2852                         lengthToWidgets(textLayoutModule->indentLE,
2853                         textLayoutModule->indentLengthCO,
2854                         indentation, default_unit);
2855                         indent = 1;
2856                 }
2857                 textLayoutModule->indentCO->setCurrentIndex(indent);
2858                 setIndent(indent);
2859         } else {
2860                 textLayoutModule->skipRB->setChecked(true);
2861                 int skip = 0;
2862                 switch (bp_.getDefSkip().kind()) {
2863                 case VSpace::SMALLSKIP:
2864                         skip = 0;
2865                         break;
2866                 case VSpace::MEDSKIP:
2867                         skip = 1;
2868                         break;
2869                 case VSpace::BIGSKIP:
2870                         skip = 2;
2871                         break;
2872                 case VSpace::LENGTH:
2873                         {
2874                         skip = 3;
2875                         string const length = bp_.getDefSkip().asLyXCommand();
2876                         lengthToWidgets(textLayoutModule->skipLE,
2877                                 textLayoutModule->skipLengthCO,
2878                                 length, default_unit);
2879                         break;
2880                         }
2881                 default:
2882                         skip = 0;
2883                         break;
2884                 }
2885                 textLayoutModule->skipCO->setCurrentIndex(skip);
2886                 setSkip(skip);
2887         }
2888
2889         textLayoutModule->twoColumnCB->setChecked(
2890                 bp_.columns == 2);
2891         textLayoutModule->justCB->setChecked(bp_.justification);
2892
2893         if (!bp_.options.empty()) {
2894                 latexModule->optionsLE->setText(
2895                         toqstr(bp_.options));
2896         } else {
2897                 latexModule->optionsLE->setText(QString());
2898         }
2899
2900         // latex
2901         latexModule->defaultOptionsCB->setChecked(
2902                         bp_.use_default_options);
2903         updateSelectedModules();
2904         selectionManager->updateProvidedModules(
2905                         bp_.baseClass()->providedModules());
2906         selectionManager->updateExcludedModules(
2907                         bp_.baseClass()->excludedModules());
2908
2909         if (!documentClass().options().empty()) {
2910                 latexModule->defaultOptionsLE->setText(
2911                         toqstr(documentClass().options()));
2912         } else {
2913                 latexModule->defaultOptionsLE->setText(
2914                         toqstr(_("[No options predefined]")));
2915         }
2916
2917         latexModule->defaultOptionsLE->setEnabled(
2918                 bp_.use_default_options
2919                 && !documentClass().options().empty());
2920
2921         latexModule->defaultOptionsCB->setEnabled(
2922                 !documentClass().options().empty());
2923
2924         if (!bp_.master.empty()) {
2925                 latexModule->childDocGB->setChecked(true);
2926                 latexModule->childDocLE->setText(
2927                         toqstr(bp_.master));
2928         } else {
2929                 latexModule->childDocLE->setText(QString());
2930                 latexModule->childDocGB->setChecked(false);
2931         }
2932
2933         // Master/Child
2934         if (!bufferview() || !buffer().hasChildren()) {
2935                 masterChildModule->childrenTW->clear();
2936                 includeonlys_.clear();
2937                 docPS->showPanel(qt_("Child Documents"), false);
2938                 if (docPS->isCurrentPanel(qt_("Child Documents")))
2939                         docPS->setCurrentPanel(qt_("Document Class"));
2940         } else {
2941                 docPS->showPanel(qt_("Child Documents"), true);
2942                 masterChildModule->setEnabled(true);
2943                 includeonlys_ = bp_.getIncludedChildren();
2944                 updateIncludeonlys();
2945         }
2946         masterChildModule->maintainAuxCB->setChecked(
2947                 bp_.maintain_unincluded_children);
2948
2949         // Float Settings
2950         floatModule->set(bp_.float_placement);
2951
2952         // ListingsSettings
2953         // break listings_params to multiple lines
2954         string lstparams =
2955                 InsetListingsParams(bp_.listings_params).separatedParams();
2956         listingsModule->listingsED->setPlainText(toqstr(lstparams));
2957
2958         // Output
2959         // update combobox with formats
2960         updateDefaultFormat();
2961         int index = outputModule->defaultFormatCO->findData(toqstr(
2962                 bp_.default_output_format));
2963         // set to default if format is not found
2964         if (index == -1)
2965                 index = 0;
2966         outputModule->defaultFormatCO->setCurrentIndex(index);
2967         bool const os_fonts_available =
2968                 bp_.baseClass()->outputType() == lyx::LATEX
2969                 && LaTeXFeatures::isAvailable("fontspec");
2970         fontModule->osFontsCB->setEnabled(os_fonts_available);
2971         fontModule->osFontsCB->setChecked(
2972                 os_fonts_available && bp_.useNonTeXFonts);
2973
2974         outputModule->outputsyncCB->setChecked(bp_.output_sync);
2975         outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
2976
2977         outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
2978         outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
2979         outputModule->strictCB->setChecked(bp_.html_be_strict);
2980         outputModule->cssCB->setChecked(bp_.html_css_as_file);
2981
2982         // Fonts
2983         updateFontsize(documentClass().opt_fontsize(),
2984                         bp_.fontsize);
2985
2986         QString font = toqstr(bp_.fonts_roman);
2987         int rpos = fontModule->fontsRomanCO->findData(font);
2988         if (rpos == -1) {
2989                 rpos = fontModule->fontsRomanCO->count();
2990                 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
2991         }
2992         fontModule->fontsRomanCO->setCurrentIndex(rpos);
2993
2994         font = toqstr(bp_.fonts_sans);
2995         int spos = fontModule->fontsSansCO->findData(font);
2996         if (spos == -1) {
2997                 spos = fontModule->fontsSansCO->count();
2998                 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
2999         }
3000         fontModule->fontsSansCO->setCurrentIndex(spos);
3001
3002         font = toqstr(bp_.fonts_typewriter);
3003         int tpos = fontModule->fontsTypewriterCO->findData(font);
3004         if (tpos == -1) {
3005                 tpos = fontModule->fontsTypewriterCO->count();
3006                 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
3007         }
3008         fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
3009
3010         if (bp_.useNonTeXFonts && os_fonts_available) {
3011                 fontModule->fontencLA->setEnabled(false);
3012                 fontModule->fontencCO->setEnabled(false);
3013                 fontModule->fontencLE->setEnabled(false);
3014         } else {
3015                 fontModule->fontencLA->setEnabled(true);
3016                 fontModule->fontencCO->setEnabled(true);
3017                 fontModule->fontencLE->setEnabled(true);
3018                 romanChanged(rpos);
3019                 sansChanged(spos);
3020                 ttChanged(tpos);
3021         }
3022
3023         if (!bp_.fonts_cjk.empty())
3024                 fontModule->cjkFontLE->setText(
3025                         toqstr(bp_.fonts_cjk));
3026         else
3027                 fontModule->cjkFontLE->setText(QString());
3028
3029         fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3030         fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3031         fontModule->scaleSansSB->setValue(bp_.fonts_sans_scale);
3032         fontModule->scaleTypewriterSB->setValue(bp_.fonts_typewriter_scale);
3033
3034         int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3035         if (nn >= 0)
3036                 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3037
3038         if (bp_.fontenc == "global") {
3039                 fontModule->fontencCO->setCurrentIndex(0);
3040                 fontModule->fontencLE->setEnabled(false);
3041         } else if (bp_.fontenc == "default") {
3042                 fontModule->fontencCO->setCurrentIndex(2);
3043                 fontModule->fontencLE->setEnabled(false);
3044         } else {
3045                 fontModule->fontencCO->setCurrentIndex(1);
3046                 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3047         }
3048
3049         // paper
3050         bool const extern_geometry =
3051                 documentClass().provides("geometry");
3052         int const psize = bp_.papersize;
3053         pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3054         setCustomPapersize(!extern_geometry && psize == 1);
3055         pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3056
3057         bool const landscape =
3058                 bp_.orientation == ORIENTATION_LANDSCAPE;
3059         pageLayoutModule->landscapeRB->setChecked(landscape);
3060         pageLayoutModule->portraitRB->setChecked(!landscape);
3061         pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3062         pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3063
3064         pageLayoutModule->facingPagesCB->setChecked(
3065                 bp_.sides == TwoSides);
3066
3067         lengthToWidgets(pageLayoutModule->paperwidthLE,
3068                 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3069         lengthToWidgets(pageLayoutModule->paperheightLE,
3070                 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3071
3072         // margins
3073         Ui::MarginsUi * m = marginsModule;
3074
3075         setMargins();
3076
3077         lengthToWidgets(m->topLE, m->topUnit,
3078                 bp_.topmargin, default_unit);
3079
3080         lengthToWidgets(m->bottomLE, m->bottomUnit,
3081                 bp_.bottommargin, default_unit);
3082
3083         lengthToWidgets(m->innerLE, m->innerUnit,
3084                 bp_.leftmargin, default_unit);
3085
3086         lengthToWidgets(m->outerLE, m->outerUnit,
3087                 bp_.rightmargin, default_unit);
3088
3089         lengthToWidgets(m->headheightLE, m->headheightUnit,
3090                 bp_.headheight, default_unit);
3091
3092         lengthToWidgets(m->headsepLE, m->headsepUnit,
3093                 bp_.headsep, default_unit);
3094
3095         lengthToWidgets(m->footskipLE, m->footskipUnit,
3096                 bp_.footskip, default_unit);
3097
3098         lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3099                 bp_.columnsep, default_unit);
3100
3101         // branches
3102         updateUnknownBranches();
3103         branchesModule->update(bp_);
3104
3105         // PDF support
3106         PDFOptions const & pdf = bp_.pdfoptions();
3107         pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3108         if (bp_.documentClass().provides("hyperref"))
3109                 pdfSupportModule->use_hyperrefGB->setTitle(qt_("C&ustomize Hyperref Options"));
3110         else
3111                 pdfSupportModule->use_hyperrefGB->setTitle(qt_("&Use Hyperref Support"));
3112         pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3113         pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3114         pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3115         pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3116
3117         pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3118         pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3119         pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3120
3121         pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3122
3123         pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3124         pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3125         pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3126         pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3127
3128         nn = findToken(backref_opts, pdf.backref);
3129         if (nn >= 0)
3130                 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3131
3132         pdfSupportModule->fullscreenCB->setChecked
3133                 (pdf.pagemode == pdf.pagemode_fullscreen);
3134
3135         pdfSupportModule->optionsLE->setText(
3136                 toqstr(pdf.quoted_options));
3137
3138         // Make sure that the bc is in the INITIAL state
3139         if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3140                 bc().restore();
3141
3142         // clear changed branches cache
3143         changedBranches_.clear();
3144 }
3145
3146
3147 void GuiDocument::saveDocDefault()
3148 {
3149         // we have to apply the params first
3150         applyView();
3151         saveAsDefault();
3152 }
3153
3154
3155 void GuiDocument::updateAvailableModules()
3156 {
3157         modules_av_model_.clear();
3158         list<modInfoStruct> const & modInfoList = getModuleInfo();
3159         list<modInfoStruct>::const_iterator mit = modInfoList.begin();
3160         list<modInfoStruct>::const_iterator men = modInfoList.end();
3161         for (int i = 0; mit != men; ++mit, ++i)
3162                 modules_av_model_.insertRow(i, mit->name, mit->id,
3163                                 mit->description);
3164 }
3165
3166
3167 void GuiDocument::updateSelectedModules()
3168 {
3169         modules_sel_model_.clear();
3170         list<modInfoStruct> const selModList = getSelectedModules();
3171         list<modInfoStruct>::const_iterator mit = selModList.begin();
3172         list<modInfoStruct>::const_iterator men = selModList.end();
3173         for (int i = 0; mit != men; ++mit, ++i)
3174                 modules_sel_model_.insertRow(i, mit->name, mit->id,
3175                                 mit->description);
3176 }
3177
3178
3179 void GuiDocument::updateIncludeonlys()
3180 {
3181         masterChildModule->childrenTW->clear();
3182         QString const no = qt_("No");
3183         QString const yes = qt_("Yes");
3184
3185         if (includeonlys_.empty()) {
3186                 masterChildModule->includeallRB->setChecked(true);
3187                 masterChildModule->childrenTW->setEnabled(false);
3188                 masterChildModule->maintainAuxCB->setEnabled(false);
3189         } else {
3190                 masterChildModule->includeonlyRB->setChecked(true);
3191                 masterChildModule->childrenTW->setEnabled(true);
3192                 masterChildModule->maintainAuxCB->setEnabled(true);
3193         }
3194         QTreeWidgetItem * item = 0;
3195         ListOfBuffers children = buffer().getChildren();
3196         ListOfBuffers::const_iterator it  = children.begin();
3197         ListOfBuffers::const_iterator end = children.end();
3198         bool has_unincluded = false;
3199         bool all_unincluded = true;
3200         for (; it != end; ++it) {
3201                 item = new QTreeWidgetItem(masterChildModule->childrenTW);
3202                 // FIXME Unicode
3203                 string const name =
3204                         to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3205                                                         from_utf8(buffer().filePath())));
3206                 item->setText(0, toqstr(name));
3207                 item->setText(1, isChildIncluded(name) ? yes : no);
3208                 if (!isChildIncluded(name))
3209                         has_unincluded = true;
3210                 else
3211                         all_unincluded = false;
3212         }
3213         // Both if all childs are included and if none is included
3214         // is equal to "include all" (i.e., ommit \includeonly).
3215         // Thus, reset the GUI.
3216         if (!has_unincluded || all_unincluded) {
3217                 masterChildModule->includeallRB->setChecked(true);
3218                 masterChildModule->childrenTW->setEnabled(false);
3219                 includeonlys_.clear();
3220         }
3221         // If all are included, we need to update again.
3222         if (!has_unincluded)
3223                 updateIncludeonlys();
3224 }
3225
3226
3227 void GuiDocument::updateContents()
3228 {
3229         // Nothing to do here as the document settings is not cursor dependant.
3230         return;
3231 }
3232
3233
3234 void GuiDocument::useClassDefaults()
3235 {
3236         if (applyPB->isEnabled()) {
3237                 int const ret = Alert::prompt(_("Unapplied changes"),
3238                                 _("Some changes in the dialog were not yet applied.\n"
3239                                   "If you do not apply now, they will be lost after this action."),
3240                                 1, 1, _("&Apply"), _("&Dismiss"));
3241                 if (ret == 0)
3242                         applyView();
3243         }
3244
3245         int idx = latexModule->classCO->currentIndex();
3246         string const classname = classes_model_.getIDString(idx);
3247         if (!bp_.setBaseClass(classname)) {
3248                 Alert::error(_("Error"), _("Unable to set document class."));
3249                 return;
3250         }
3251         bp_.useClassDefaults();
3252         paramsToDialog();
3253 }
3254
3255
3256 void GuiDocument::setLayoutComboByIDString(string const & idString)
3257 {
3258         int idx = classes_model_.findIDString(idString);
3259         if (idx < 0)
3260                 Alert::warning(_("Can't set layout!"),
3261                         bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3262         else
3263                 latexModule->classCO->setCurrentIndex(idx);
3264 }
3265
3266
3267 bool GuiDocument::isValid()
3268 {
3269         return
3270                 validateListingsParameters().isEmpty() &&
3271                 localLayout->isValid() &&
3272                 (
3273                         // if we're asking for skips between paragraphs
3274                         !textLayoutModule->skipRB->isChecked() ||
3275                         // then either we haven't chosen custom
3276                         textLayoutModule->skipCO->currentIndex() != 3 ||
3277                         // or else a length has been given
3278                         !textLayoutModule->skipLE->text().isEmpty()
3279                 ) &&
3280                 (
3281                         // if we're asking for indentation
3282                         !textLayoutModule->indentRB->isChecked() ||
3283                         // then either we haven't chosen custom
3284                         textLayoutModule->indentCO->currentIndex() != 1 ||
3285                         // or else a length has been given
3286                         !textLayoutModule->indentLE->text().isEmpty()
3287                 );
3288 }
3289
3290
3291 char const * const GuiDocument::fontfamilies[5] = {
3292         "default", "rmdefault", "sfdefault", "ttdefault", ""
3293 };
3294
3295
3296 char const * GuiDocument::fontfamilies_gui[5] = {
3297         N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3298 };
3299
3300
3301 bool GuiDocument::initialiseParams(string const &)
3302 {
3303         BufferView const * view = bufferview();
3304         if (!view) {
3305                 bp_ = BufferParams();
3306                 paramsToDialog();
3307                 return true;
3308         }
3309         bp_ = view->buffer().params();
3310         loadModuleInfo();
3311         updateAvailableModules();
3312         //FIXME It'd be nice to make sure here that the selected
3313         //modules are consistent: That required modules are actually
3314         //selected, and that we don't have conflicts. If so, we could
3315         //at least pop up a warning.
3316         paramsToDialog();
3317         return true;
3318 }
3319
3320
3321 void GuiDocument::clearParams()
3322 {
3323         bp_ = BufferParams();
3324 }
3325
3326
3327 BufferId GuiDocument::id() const
3328 {
3329         BufferView const * const view = bufferview();
3330         return view? &view->buffer() : 0;
3331 }
3332
3333
3334 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3335 {
3336         return moduleNames_;
3337 }
3338
3339
3340 list<GuiDocument::modInfoStruct> const
3341                 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3342 {
3343         LayoutModuleList::const_iterator it =  mods.begin();
3344         LayoutModuleList::const_iterator end = mods.end();
3345         list<modInfoStruct> mInfo;
3346         for (; it != end; ++it) {
3347                 modInfoStruct m;
3348                 m.id = *it;
3349                 LyXModule const * const mod = theModuleList[*it];
3350                 if (mod)
3351                         // FIXME Unicode
3352                         m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
3353                 else
3354                         m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
3355                 mInfo.push_back(m);
3356         }
3357         return mInfo;
3358 }
3359
3360
3361 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3362 {
3363         return makeModuleInfo(params().getModules());
3364 }
3365
3366
3367 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3368 {
3369         return makeModuleInfo(params().baseClass()->providedModules());
3370 }
3371
3372
3373 DocumentClass const & GuiDocument::documentClass() const
3374 {
3375         return bp_.documentClass();
3376 }
3377
3378
3379 static void dispatch_bufferparams(Dialog const & dialog,
3380         BufferParams const & bp, FuncCode lfun)
3381 {
3382         ostringstream ss;
3383         ss << "\\begin_header\n";
3384         bp.writeFile(ss);
3385         ss << "\\end_header\n";
3386         dialog.dispatch(FuncRequest(lfun, ss.str()));
3387 }
3388
3389
3390 void GuiDocument::dispatchParams()
3391 {
3392         // This must come first so that a language change is correctly noticed
3393         setLanguage();
3394
3395         // Apply the BufferParams. Note that this will set the base class
3396         // and then update the buffer's layout.
3397         dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
3398
3399         if (!params().master.empty()) {
3400                 FileName const master_file = support::makeAbsPath(params().master,
3401                            support::onlyPath(buffer().absFileName()));
3402                 if (isLyXFileName(master_file.absFileName())) {
3403                         Buffer * master = checkAndLoadLyXFile(master_file);
3404                         if (master) {
3405                                 if (master->isChild(const_cast<Buffer *>(&buffer())))
3406                                         const_cast<Buffer &>(buffer()).setParent(master);
3407                                 else
3408                                         Alert::warning(_("Assigned master does not include this file"),
3409                                                 bformat(_("You must include this file in the document\n"
3410                                                           "'%1$s' in order to use the master document\n"
3411                                                           "feature."), from_utf8(params().master)));
3412                         } else
3413                                 Alert::warning(_("Could not load master"),
3414                                                 bformat(_("The master document '%1$s'\n"
3415                                                            "could not be loaded."),
3416                                                            from_utf8(params().master)));
3417                 }
3418         }
3419
3420         // Generate the colours requested by each new branch.
3421         BranchList & branchlist = params().branchlist();
3422         if (!branchlist.empty()) {
3423                 BranchList::const_iterator it = branchlist.begin();
3424                 BranchList::const_iterator const end = branchlist.end();
3425                 for (; it != end; ++it) {
3426                         docstring const & current_branch = it->branch();
3427                         Branch const * branch = branchlist.find(current_branch);
3428                         string const x11hexname = X11hexname(branch->color());
3429                         // display the new color
3430                         docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3431                         dispatch(FuncRequest(LFUN_SET_COLOR, str));
3432                 }
3433
3434                 // Open insets of selected branches, close deselected ones
3435                 dispatch(FuncRequest(LFUN_INSET_FORALL,
3436                         "Branch inset-toggle assign"));
3437         }
3438         // rename branches in the document
3439         executeBranchRenaming();
3440         // and clear changed branches cache
3441         changedBranches_.clear();
3442
3443         // Generate the colours requested by indices.
3444         IndicesList & indiceslist = params().indiceslist();
3445         if (!indiceslist.empty()) {
3446                 IndicesList::const_iterator it = indiceslist.begin();
3447                 IndicesList::const_iterator const end = indiceslist.end();
3448                 for (; it != end; ++it) {
3449                         docstring const & current_index = it->shortcut();
3450                         Index const * index = indiceslist.findShortcut(current_index);
3451                         string const x11hexname = X11hexname(index->color());
3452                         // display the new color
3453                         docstring const str = current_index + ' ' + from_ascii(x11hexname);
3454                         dispatch(FuncRequest(LFUN_SET_COLOR, str));
3455                 }
3456         }
3457         // FIXME LFUN
3458         // If we used an LFUN, we would not need these two lines:
3459         BufferView * bv = const_cast<BufferView *>(bufferview());
3460         bv->processUpdateFlags(Update::Force | Update::FitCursor);
3461 }
3462
3463
3464 void GuiDocument::setLanguage() const
3465 {
3466         Language const * const newL = bp_.language;
3467         if (buffer().params().language == newL)
3468                 return;
3469
3470         string const & lang_name = newL->lang();
3471         dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3472 }
3473
3474
3475 void GuiDocument::saveAsDefault() const
3476 {
3477         dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
3478 }
3479
3480
3481 bool GuiDocument::isFontAvailable(string const & font) const
3482 {
3483         if (font == "default" || font == "cmr"
3484             || font == "cmss" || font == "cmtt")
3485                 // these are standard
3486                 return true;
3487         if (font == "lmodern" || font == "lmss" || font == "lmtt")
3488                 return LaTeXFeatures::isAvailable("lmodern");
3489         if (font == "times" || font == "palatino"
3490                  || font == "helvet" || font == "courier")
3491                 return LaTeXFeatures::isAvailable("psnfss");
3492         if (font == "cmbr" || font == "cmtl")
3493                 return LaTeXFeatures::isAvailable("cmbright");
3494         if (font == "utopia")
3495                 return LaTeXFeatures::isAvailable("utopia")
3496                         || LaTeXFeatures::isAvailable("fourier");
3497         if (font == "beraserif" || font == "berasans"
3498                 || font == "beramono")
3499                 return LaTeXFeatures::isAvailable("bera");
3500         return LaTeXFeatures::isAvailable(font);
3501 }
3502
3503
3504 bool GuiDocument::providesOSF(string const & font) const
3505 {
3506         if (fontModule->osFontsCB->isChecked())
3507                 // FIXME: we should check if the fonts really
3508                 // have OSF support. But how?
3509                 return true;
3510         if (font == "cmr")
3511                 return isFontAvailable("eco");
3512         if (font == "palatino")
3513                 return isFontAvailable("mathpazo");
3514         return false;
3515 }
3516
3517
3518 bool GuiDocument::providesSC(string const & font) const
3519 {
3520         if (fontModule->osFontsCB->isChecked())
3521                 return false;
3522         if (font == "palatino")
3523                 return isFontAvailable("mathpazo");
3524         if (font == "utopia")
3525                 return isFontAvailable("fourier");
3526         return false;
3527 }
3528
3529
3530 bool GuiDocument::providesScale(string const & font) const
3531 {
3532         if (fontModule->osFontsCB->isChecked())
3533                 return true;
3534         return font == "helvet" || font == "luximono"
3535                 || font == "berasans"  || font == "beramono";
3536 }
3537
3538
3539 void GuiDocument::loadModuleInfo()
3540 {
3541         moduleNames_.clear();
3542         LyXModuleList::const_iterator it  = theModuleList.begin();
3543         LyXModuleList::const_iterator end = theModuleList.end();
3544         for (; it != end; ++it) {
3545                 modInfoStruct m;
3546                 m.id = it->getID();
3547                 // FIXME Unicode
3548                 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3549                 // this is supposed to give us the first sentence of the description
3550                 // FIXME Unicode
3551                 QString desc =
3552                         toqstr(translateIfPossible(from_utf8(it->getDescription())));
3553                 int const pos = desc.indexOf(".");
3554                 if (pos > 0)
3555                         desc.truncate(pos + 1);
3556                 m.description = desc;
3557                 moduleNames_.push_back(m);
3558         }
3559 }
3560
3561
3562 void GuiDocument::updateUnknownBranches()
3563 {
3564         if (!bufferview())
3565                 return;
3566         list<docstring> used_branches;
3567         buffer().getUsedBranches(used_branches);
3568         list<docstring>::const_iterator it = used_branches.begin();
3569         QStringList unknown_branches;
3570         for (; it != used_branches.end() ; ++it) {
3571                 if (!buffer().params().branchlist().find(*it))
3572                         unknown_branches.append(toqstr(*it));
3573         }
3574         branchesModule->setUnknownBranches(unknown_branches);
3575 }
3576
3577
3578 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3579 {
3580         map<docstring, docstring>::iterator it = changedBranches_.begin();
3581         for (; it != changedBranches_.end() ; ++it) {
3582                 if (it->second == oldname) {
3583                         // branch has already been renamed
3584                         it->second = newname;
3585                         return;
3586                 }
3587         }
3588         // store new name
3589         changedBranches_[oldname] = newname;
3590 }
3591
3592
3593 void GuiDocument::executeBranchRenaming() const
3594 {
3595         map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3596         for (; it != changedBranches_.end() ; ++it) {
3597                 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3598                 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3599         }
3600 }
3601
3602
3603 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
3604
3605
3606 } // namespace frontend
3607 } // namespace lyx
3608
3609 #include "moc_GuiDocument.cpp"