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 "BranchList.h"
  17 #include "buffer_funcs.h"
  18 #include "Buffer.h"
  19 #include "BufferParams.h"
  20 #include "BufferView.h"
  21 #include "Color.h"
  22 #include "EmbeddedFiles.h"
  23 #include "Encoding.h"
  24 #include "FloatPlacement.h"
  25 #include "FuncRequest.h"
  26 #include "support/gettext.h"
  27 #include "GuiBranches.h"
  28 #include "Language.h"
  29 #include "LaTeXFeatures.h"
  30 #include "LaTeXHighlighter.h"
  31 #include "Layout.h"
  32 #include "LengthCombo.h"
  33 #include "LyXRC.h" // defaultUnit
  34 #include "ModuleList.h"
  35 #include "OutputParams.h"
  36 #include "PanelStack.h"
  37 #include "PDFOptions.h"
  38 #include "qt_helpers.h"
  39 #include "Spacing.h"
  40 #include "TextClassList.h"
  41 #include "Validator.h"
  42
  43 #include "insets/InsetListingsParams.h"
  44
  45 #include "support/FileName.h"
  46 #include "support/filetools.h"
  47 #include "support/lstrings.h"
  48
  49 #include <boost/bind.hpp>
  50
  51 #include <QCloseEvent>
  52 #include <QScrollBar>
  53 #include <QTextCursor>
  54
  55 #include <algorithm>
  56 #include <sstream>
  57
  58 using namespace std;
  59 using namespace lyx::support;
  60
  61 ///
  62 template<class Pair>
  63 vector<typename Pair::second_type> const
  64 getSecond(vector<Pair> const & pr)
  65 {
  66          vector<typename Pair::second_type> tmp(pr.size());
  67          transform(pr.begin(), pr.end(), tmp.begin(),
  68                                          boost::bind(&Pair::second, _1));
  69          return tmp;
  70 }
  71
  72 char const * const tex_graphics[] =
  73 {
  74         "default", "dvips", "dvitops", "emtex",
  75         "ln", "oztex", "textures", "none", ""
  76 };
  77
  78
  79 char const * const tex_graphics_gui[] =
  80 {
  81         N_("Default"), "Dvips", "DVItoPS", "EmTeX",
  82         "LN", "OzTeX", "Textures", N_("None"), ""
  83 };
  84
  85
  86 char const * const tex_fonts_roman[] =
  87 {
  88         "default", "cmr", "lmodern", "ae", "times", "palatino",
  89         "charter", "newcent", "bookman", "utopia", "beraserif",
  90         "ccfonts", "chancery", ""
  91 };
  92
  93
  94 char const * tex_fonts_roman_gui[] =
  95 {
  96         N_("Default"), N_("Computer Modern Roman"), N_("Latin Modern Roman"),
  97         N_("AE (Almost European)"), N_("Times Roman"), N_("Palatino"),
  98         N_("Bitstream Charter"), N_("New Century Schoolbook"), N_("Bookman"),
  99         N_("Utopia"),  N_("Bera Serif"), N_("Concrete Roman"), N_("Zapf Chancery"),
 100         ""
 101 };
 102
 103
 104 char const * const tex_fonts_sans[] =
 105 {
 106         "default", "cmss", "lmss", "helvet", "avant", "berasans", "cmbr", ""
 107 };
 108
 109
 110 char const * tex_fonts_sans_gui[] =
 111 {
 112         N_("Default"), N_("Computer Modern Sans"), N_("Latin Modern Sans"),
 113         N_("Helvetica"), N_("Avant Garde"), N_("Bera Sans"), N_("CM Bright"), ""
 114 };
 115
 116
 117 char const * const tex_fonts_monospaced[] =
 118 {
 119         "default", "cmtt", "lmtt", "courier", "beramono", "luximono", "cmtl", ""
 120 };
 121
 122
 123 char const * tex_fonts_monospaced_gui[] =
 124 {
 125         N_("Default"), N_("Computer Modern Typewriter"),
 126         N_("Latin Modern Typewriter"), N_("Courier"), N_("Bera Mono"),
 127         N_("LuxiMono"), N_("CM Typewriter Light"), ""
 128 };
 129
 130
 131 vector<pair<string, lyx::docstring> > pagestyles;
 132
 133
 134 namespace lyx {
 135 namespace frontend {
 136
 137 /////////////////////////////////////////////////////////////////////
 138 //
 139 // PreambleModule
 140 //
 141 /////////////////////////////////////////////////////////////////////
 142
 143 PreambleModule::PreambleModule(): current_id_(0)
 144 {
 145         // This is not a memory leak. The object will be destroyed
 146         // with this.
 147         (void) new LaTeXHighlighter(preambleTE->document());
 148         setFocusProxy(preambleTE);
 149         connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
 150 }
 151
 152
 153 void PreambleModule::update(BufferParams const & params, BufferId id)
 154 {
 155         QString preamble = toqstr(params.preamble);
 156         // Nothing to do if the params and preamble are unchanged.
 157         if (id == current_id_
 158                 && preamble == preambleTE->document()->toPlainText())
 159                 return;
 160
 161         QTextCursor cur = preambleTE->textCursor();
 162         // Save the coords before switching to the new one.
 163         preamble_coords_[current_id_] =
 164                 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
 165
 166         // Save the params address for further use.
 167         current_id_ = id;
 168         preambleTE->document()->setPlainText(preamble);
 169         Coords::const_iterator it = preamble_coords_.find(current_id_);
 170         if (it == preamble_coords_.end())
 171                 // First time we open this one.
 172                 preamble_coords_[current_id_] = make_pair(0,0);
 173         else {
 174                 // Restore saved coords.
 175                 QTextCursor cur = preambleTE->textCursor();
 176                 cur.setPosition(it->second.first);
 177                 preambleTE->setTextCursor(cur);
 178                 preambleTE->verticalScrollBar()->setValue(it->second.second);
 179         }
 180 }
 181
 182
 183 void PreambleModule::apply(BufferParams & params)
 184 {
 185         params.preamble = fromqstr(preambleTE->document()->toPlainText());
 186 }
 187
 188
 189 void PreambleModule::closeEvent(QCloseEvent * e)
 190 {
 191         // Save the coords before closing.
 192         QTextCursor cur = preambleTE->textCursor();
 193         preamble_coords_[current_id_] =
 194                 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
 195         e->accept();
 196 }
 197
 198
 199 /////////////////////////////////////////////////////////////////////
 200 //
 201 // DocumentDialog
 202 //
 203 /////////////////////////////////////////////////////////////////////
 204
 205
 206
 207 GuiDocument::GuiDocument(GuiView & lv)
 208         : GuiDialog(lv, "document")
 209 {
 210         setupUi(this);
 211         setViewTitle(_("Document Settings"));
 212
 213         lang_ = getSecond(getLanguageData(false));
 214
 215         connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
 216         connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
 217         connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
 218         connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
 219
 220         connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
 221         connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
 222
 223         // Manage the restore, ok, apply, restore and cancel/close buttons
 224         bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
 225         bc().setOK(okPB);
 226         bc().setApply(applyPB);
 227         bc().setCancel(closePB);
 228         bc().setRestore(restorePB);
 229
 230         textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
 231         // text layout
 232         connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
 233                 this, SLOT(change_adaptor()));
 234         connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
 235                 this, SLOT(setLSpacing(int)));
 236         connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString&)),
 237                 this, SLOT(change_adaptor()));
 238         connect(textLayoutModule->skipRB, SIGNAL(clicked()),
 239                 this, SLOT(change_adaptor()));
 240         connect(textLayoutModule->indentRB, SIGNAL(clicked()),
 241                 this, SLOT(change_adaptor()));
 242         connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
 243                 this, SLOT(change_adaptor()));
 244         connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
 245                 this, SLOT(change_adaptor()));
 246         connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
 247                 this, SLOT(change_adaptor()));
 248         connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
 249                 this, SLOT(setSkip(int)));
 250         connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
 251                 this, SLOT(enableSkip(bool)));
 252         connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
 253                 this, SLOT(change_adaptor()));
 254         connect(textLayoutModule->listingsED, SIGNAL(textChanged()),
 255                 this, SLOT(change_adaptor()));
 256         connect(textLayoutModule->bypassCB, SIGNAL(clicked()),
 257                 this, SLOT(change_adaptor()));
 258         connect(textLayoutModule->bypassCB, SIGNAL(clicked()),
 259                 this, SLOT(set_listings_msg()));
 260         connect(textLayoutModule->listingsED, SIGNAL(textChanged()),
 261                 this, SLOT(set_listings_msg()));
 262         textLayoutModule->listingsTB->setPlainText(
 263                 qt_("Input listings parameters on the right. Enter ? for a list of parameters."));
 264         textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
 265                 textLayoutModule->lspacingLE));
 266         textLayoutModule->skipLE->setValidator(unsignedLengthValidator(
 267                 textLayoutModule->skipLE));
 268
 269         textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
 270         textLayoutModule->skipCO->addItem(qt_("MedSkip"));
 271         textLayoutModule->skipCO->addItem(qt_("BigSkip"));
 272         textLayoutModule->skipCO->addItem(qt_("Length"));
 273         // remove the %-items from the unit choice
 274         textLayoutModule->skipLengthCO->noPercents();
 275         textLayoutModule->lspacingCO->insertItem(
 276                 Spacing::Single, qt_("Single"));
 277         textLayoutModule->lspacingCO->insertItem(
 278                 Spacing::Onehalf, qt_("OneHalf"));
 279         textLayoutModule->lspacingCO->insertItem(
 280                 Spacing::Double, qt_("Double"));
 281         textLayoutModule->lspacingCO->insertItem(
 282                 Spacing::Other, qt_("Custom"));
 283
 284         // initialize the length validator
 285         bc().addCheckedLineEdit(textLayoutModule->skipLE);
 286
 287         fontModule = new UiWidget<Ui::FontUi>;
 288         // fonts
 289         connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
 290                 this, SLOT(change_adaptor()));
 291         connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
 292                 this, SLOT(romanChanged(int)));
 293         connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
 294                 this, SLOT(change_adaptor()));
 295         connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
 296                 this, SLOT(sansChanged(int)));
 297         connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
 298                 this, SLOT(change_adaptor()));
 299         connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
 300                 this, SLOT(ttChanged(int)));
 301         connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
 302                 this, SLOT(change_adaptor()));
 303         connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
 304                 this, SLOT(change_adaptor()));
 305         connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
 306                 this, SLOT(change_adaptor()));
 307         connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
 308                 this, SLOT(change_adaptor()));
 309         connect(fontModule->fontScCB, SIGNAL(clicked()),
 310                 this, SLOT(change_adaptor()));
 311         connect(fontModule->fontOsfCB, SIGNAL(clicked()),
 312                 this, SLOT(change_adaptor()));
 313
 314         for (int n = 0; tex_fonts_roman[n][0]; ++n) {
 315                 QString font = qt_(tex_fonts_roman_gui[n]);
 316                 if (!isFontAvailable(tex_fonts_roman[n]))
 317                         font += qt_(" (not installed)");
 318                 fontModule->fontsRomanCO->addItem(font);
 319         }
 320         for (int n = 0; tex_fonts_sans[n][0]; ++n) {
 321                 QString font = qt_(tex_fonts_sans_gui[n]);
 322                 if (!isFontAvailable(tex_fonts_sans[n]))
 323                         font += qt_(" (not installed)");
 324                 fontModule->fontsSansCO->addItem(font);
 325         }
 326         for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
 327                 QString font = qt_(tex_fonts_monospaced_gui[n]);
 328                 if (!isFontAvailable(tex_fonts_monospaced[n]))
 329                         font += qt_(" (not installed)");
 330                 fontModule->fontsTypewriterCO->addItem(font);
 331         }
 332
 333         fontModule->fontsizeCO->addItem(qt_("Default"));
 334         fontModule->fontsizeCO->addItem(qt_("10"));
 335         fontModule->fontsizeCO->addItem(qt_("11"));
 336         fontModule->fontsizeCO->addItem(qt_("12"));
 337
 338         for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
 339                 fontModule->fontsDefaultCO->addItem(
 340                         qt_(GuiDocument::fontfamilies_gui[n]));
 341
 342
 343         pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
 344         // page layout
 345         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 346                 this, SLOT(setCustomPapersize(int)));
 347         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 348                 this, SLOT(setCustomPapersize(int)));
 349         connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
 350                 this, SLOT(portraitChanged()));
 351         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 352                 this, SLOT(change_adaptor()));
 353         connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
 354                 this, SLOT(change_adaptor()));
 355         connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
 356                 this, SLOT(change_adaptor()));
 357         connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
 358                 this, SLOT(change_adaptor()));
 359         connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
 360                 this, SLOT(change_adaptor()));
 361         connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
 362                 this, SLOT(change_adaptor()));
 363         connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
 364                 this, SLOT(change_adaptor()));
 365         connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
 366                 this, SLOT(change_adaptor()));
 367         connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
 368                 this, SLOT(change_adaptor()));
 369
 370         pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
 371         pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
 372         pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
 373         pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
 374         pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
 375         bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
 376                 pageLayoutModule->paperheightL);
 377         bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
 378                 pageLayoutModule->paperwidthL);
 379
 380         // paper
 381         QComboBox * cb = pageLayoutModule->papersizeCO;
 382         cb->addItem(qt_("Default"));
 383         cb->addItem(qt_("Custom"));
 384         cb->addItem(qt_("US letter"));
 385         cb->addItem(qt_("US legal"));
 386         cb->addItem(qt_("US executive"));
 387         cb->addItem(qt_("A3"));
 388         cb->addItem(qt_("A4"));
 389         cb->addItem(qt_("A5"));
 390         cb->addItem(qt_("B3"));
 391         cb->addItem(qt_("B4"));
 392         cb->addItem(qt_("B5"));
 393         // remove the %-items from the unit choice
 394         pageLayoutModule->paperwidthUnitCO->noPercents();
 395         pageLayoutModule->paperheightUnitCO->noPercents();
 396         pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
 397                 pageLayoutModule->paperheightLE));
 398         pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
 399                 pageLayoutModule->paperwidthLE));
 400
 401
 402         marginsModule = new UiWidget<Ui::MarginsUi>;
 403         // margins
 404         connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
 405                 this, SLOT(setCustomMargins(bool)));
 406         connect(marginsModule->marginCB, SIGNAL(clicked()),
 407                 this, SLOT(change_adaptor()));
 408         connect(marginsModule->topLE, SIGNAL(textChanged(const QString &)),
 409                 this, SLOT(change_adaptor()));
 410         connect(marginsModule->topUnit, SIGNAL(activated(int)),
 411                 this, SLOT(change_adaptor()));
 412         connect(marginsModule->bottomLE, SIGNAL(textChanged(const QString &)),
 413                 this, SLOT(change_adaptor()));
 414         connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
 415                 this, SLOT(change_adaptor()));
 416         connect(marginsModule->innerLE, SIGNAL(textChanged(const QString &)),
 417                 this, SLOT(change_adaptor()));
 418         connect(marginsModule->innerUnit, SIGNAL(activated(int)),
 419                 this, SLOT(change_adaptor()));
 420         connect(marginsModule->outerLE, SIGNAL(textChanged(const QString &)),
 421                 this, SLOT(change_adaptor()));
 422         connect(marginsModule->outerUnit, SIGNAL(activated(int)),
 423                 this, SLOT(change_adaptor()));
 424         connect(marginsModule->headheightLE, SIGNAL(textChanged(const QString &)),
 425                 this, SLOT(change_adaptor()));
 426         connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
 427                 this, SLOT(change_adaptor()));
 428         connect(marginsModule->headsepLE, SIGNAL(textChanged(const QString &)),
 429                 this, SLOT(change_adaptor()));
 430         connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
 431                 this, SLOT(change_adaptor()));
 432         connect(marginsModule->footskipLE, SIGNAL(textChanged(const QString&)),
 433                 this, SLOT(change_adaptor()));
 434         connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
 435                 this, SLOT(change_adaptor()));
 436         marginsModule->topLE->setValidator(unsignedLengthValidator(
 437                 marginsModule->topLE));
 438         marginsModule->bottomLE->setValidator(unsignedLengthValidator(
 439                 marginsModule->bottomLE));
 440         marginsModule->innerLE->setValidator(unsignedLengthValidator(
 441                 marginsModule->innerLE));
 442         marginsModule->outerLE->setValidator(unsignedLengthValidator(
 443                 marginsModule->outerLE));
 444         marginsModule->headsepLE->setValidator(unsignedLengthValidator(
 445                 marginsModule->headsepLE));
 446         marginsModule->headheightLE->setValidator(unsignedLengthValidator(
 447                 marginsModule->headheightLE));
 448         marginsModule->footskipLE->setValidator(unsignedLengthValidator(
 449                 marginsModule->footskipLE));
 450
 451         bc().addCheckedLineEdit(marginsModule->topLE,
 452                 marginsModule->topL);
 453         bc().addCheckedLineEdit(marginsModule->bottomLE,
 454                 marginsModule->bottomL);
 455         bc().addCheckedLineEdit(marginsModule->innerLE,
 456                 marginsModule->innerL);
 457         bc().addCheckedLineEdit(marginsModule->outerLE,
 458                 marginsModule->outerL);
 459         bc().addCheckedLineEdit(marginsModule->headsepLE,
 460                 marginsModule->headsepL);
 461         bc().addCheckedLineEdit(marginsModule->headheightLE,
 462                 marginsModule->headheightL);
 463         bc().addCheckedLineEdit(marginsModule->footskipLE,
 464                 marginsModule->footskipL);
 465
 466
 467         langModule = new UiWidget<Ui::LanguageUi>;
 468         // language & quote
 469         connect(langModule->languageCO, SIGNAL(activated(int)),
 470                 this, SLOT(change_adaptor()));
 471         connect(langModule->defaultencodingRB, SIGNAL(clicked()),
 472                 this, SLOT(change_adaptor()));
 473         connect(langModule->otherencodingRB, SIGNAL(clicked()),
 474                 this, SLOT(change_adaptor()));
 475         connect(langModule->encodingCO, SIGNAL(activated(int)),
 476                 this, SLOT(change_adaptor()));
 477         connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
 478                 this, SLOT(change_adaptor()));
 479         // language & quotes
 480         vector<LanguagePair> const langs = getLanguageData(false);
 481         vector<LanguagePair>::const_iterator lit  = langs.begin();
 482         vector<LanguagePair>::const_iterator lend = langs.end();
 483         for (; lit != lend; ++lit) {
 484                 langModule->languageCO->addItem(toqstr(lit->first));
 485         }
 486
 487         // Always put the default encoding in the first position.
 488         // It is special because the displayed text is translated.
 489         langModule->encodingCO->addItem(qt_("LaTeX default"));
 490         Encodings::const_iterator it = encodings.begin();
 491         Encodings::const_iterator const end = encodings.end();
 492         for (; it != end; ++it)
 493                 langModule->encodingCO->addItem(toqstr(it->latexName()));
 494
 495         langModule->quoteStyleCO->addItem(qt_("``text''"));
 496         langModule->quoteStyleCO->addItem(qt_("''text''"));
 497         langModule->quoteStyleCO->addItem(qt_(",,text``"));
 498         langModule->quoteStyleCO->addItem(qt_(",,text''"));
 499         langModule->quoteStyleCO->addItem(qt_("<<text>>"));
 500         langModule->quoteStyleCO->addItem(qt_(">>text<<"));
 501
 502
 503
 504         numberingModule = new UiWidget<Ui::NumberingUi>;
 505         // numbering
 506         connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
 507                 this, SLOT(change_adaptor()));
 508         connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
 509                 this, SLOT(change_adaptor()));
 510         connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
 511                 this, SLOT(updateNumbering()));
 512         connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
 513                 this, SLOT(updateNumbering()));
 514         numberingModule->tocTW->setColumnCount(3);
 515         numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
 516         numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
 517         numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
 518
 519
 520         biblioModule = new UiWidget<Ui::BiblioUi>;
 521         connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
 522                 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
 523         connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
 524                 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
 525         // biblio
 526         connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
 527                 this, SLOT(change_adaptor()));
 528         connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
 529                 this, SLOT(change_adaptor()));
 530         connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
 531                 this, SLOT(change_adaptor()));
 532         connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
 533                 this, SLOT(change_adaptor()));
 534         connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
 535                 this, SLOT(change_adaptor()));
 536         // biblio
 537         biblioModule->citeStyleCO->addItem(qt_("Author-year"));
 538         biblioModule->citeStyleCO->addItem(qt_("Numerical"));
 539         biblioModule->citeStyleCO->setCurrentIndex(0);
 540
 541
 542         mathsModule = new UiWidget<Ui::MathsUi>;
 543         connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
 544                 mathsModule->amsCB, SLOT(setDisabled(bool)));
 545         connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
 546                 mathsModule->esintCB, SLOT(setDisabled(bool)));
 547         // maths
 548         connect(mathsModule->amsCB, SIGNAL(clicked()),
 549                 this, SLOT(change_adaptor()));
 550         connect(mathsModule->amsautoCB, SIGNAL(clicked()),
 551                 this, SLOT(change_adaptor()));
 552         connect(mathsModule->esintCB, SIGNAL(clicked()),
 553                 this, SLOT(change_adaptor()));
 554         connect(mathsModule->esintautoCB, SIGNAL(clicked()),
 555                 this, SLOT(change_adaptor()));
 556
 557         latexModule = new UiWidget<Ui::LaTeXUi>;
 558         // latex class
 559         connect(latexModule->classCO, SIGNAL(activated(int)),
 560                 this, SLOT(change_adaptor()));
 561         connect(latexModule->optionsLE, SIGNAL(textChanged(const QString &)),
 562                 this, SLOT(change_adaptor()));
 563         connect(latexModule->psdriverCO, SIGNAL(activated(int)),
 564                 this, SLOT(change_adaptor()));
 565         connect(latexModule->classCO, SIGNAL(activated(int)),
 566                 this, SLOT(classChanged()));
 567
 568         selectionManager =
 569                 new GuiSelectionManager(latexModule->availableLV, latexModule->selectedLV,
 570                         latexModule->addPB, latexModule->deletePB,
 571                         latexModule->upPB, latexModule->downPB,
 572                         availableModel(), selectedModel());
 573         connect(selectionManager, SIGNAL(updateHook()),
 574                 this, SLOT(updateModuleInfo()));
 575         connect(selectionManager, SIGNAL(updateHook()),
 576                 this, SLOT(change_adaptor()));
 577
 578         // postscript drivers
 579         for (int n = 0; tex_graphics[n][0]; ++n) {
 580                 QString enc = qt_(tex_graphics_gui[n]);
 581                 latexModule->psdriverCO->addItem(enc);
 582         }
 583         // latex classes
 584         //FIXME This seems too involved with the kernel. Some of this
 585         //should be moved to the kernel---which should perhaps just
 586         //give us a list of entries or something of the sort.
 587         for (TextClassList::const_iterator cit = textclasslist.begin();
 588              cit != textclasslist.end(); ++cit) {
 589                 if (cit->isTeXClassAvailable()) {
 590                         latexModule->classCO->addItem(toqstr(cit->description()));
 591                 } else {
 592                         docstring item =
 593                                 bformat(_("Unavailable: %1$s"), from_utf8(cit->description()));
 594                         latexModule->classCO->addItem(toqstr(item));
 595                 }
 596         }
 597
 598         // branches
 599         branchesModule = new GuiBranches;
 600         connect(branchesModule, SIGNAL(changed()),
 601                 this, SLOT(change_adaptor()));
 602
 603         // preamble
 604         preambleModule = new PreambleModule;
 605         connect(preambleModule, SIGNAL(changed()),
 606                 this, SLOT(change_adaptor()));
 607
 608         // bullets
 609         bulletsModule = new BulletsModule;
 610         connect(bulletsModule, SIGNAL(changed()),
 611                 this, SLOT(change_adaptor()));
 612
 613         // embedded files
 614         embeddedFilesModule = new UiWidget<Ui::EmbeddedFilesUi>;
 615         connect(embeddedFilesModule->bundleCB, SIGNAL(toggled(bool)),
 616                 this, SLOT(change_adaptor()));
 617         connect(embeddedFilesModule->addPB, SIGNAL(clicked()),
 618                 this, SLOT(change_adaptor()));
 619         connect(embeddedFilesModule->removePB, SIGNAL(clicked()),
 620                 this, SLOT(change_adaptor()));
 621
 622         // PDF support
 623         pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
 624
 625         connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
 626                 this, SLOT(change_adaptor()));
 627         connect(pdfSupportModule->titleLE, SIGNAL(textChanged(const QString &)),
 628                 this, SLOT(change_adaptor()));
 629         connect(pdfSupportModule->authorLE, SIGNAL(textChanged(const QString &)),
 630                 this, SLOT(change_adaptor()));
 631         connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(const QString &)),
 632                 this, SLOT(change_adaptor()));
 633         connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(const QString &)),
 634                 this, SLOT(change_adaptor()));
 635         connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
 636                 this, SLOT(change_adaptor()));
 637         connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
 638                 this, SLOT(change_adaptor()));
 639         connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
 640                 this, SLOT(change_adaptor()));
 641         connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
 642                 this, SLOT(change_adaptor()));
 643         connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
 644                 this, SLOT(change_adaptor()));
 645         connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
 646                 this, SLOT(change_adaptor()));
 647         connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
 648                 this, SLOT(change_adaptor()));
 649         connect(pdfSupportModule->backrefCB, SIGNAL(toggled(bool)),
 650                 this, SLOT(change_adaptor()));
 651         connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
 652                 this, SLOT(change_adaptor()));
 653         connect(pdfSupportModule->pagebackrefCB, SIGNAL(toggled(bool)),
 654                 this, SLOT(change_adaptor()));
 655         connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
 656                 this, SLOT(change_adaptor()));
 657         connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(const QString &)),
 658                 this, SLOT(change_adaptor()));
 659
 660         // float
 661         floatModule = new FloatPlacement;
 662         connect(floatModule, SIGNAL(changed()),
 663                 this, SLOT(change_adaptor()));
 664
 665         docPS->addPanel(latexModule, _("Document Class"));
 666         docPS->addPanel(fontModule, _("Fonts"));
 667         docPS->addPanel(textLayoutModule, _("Text Layout"));
 668         docPS->addPanel(pageLayoutModule, _("Page Layout"));
 669         docPS->addPanel(marginsModule, _("Page Margins"));
 670         docPS->addPanel(langModule, _("Language"));
 671         docPS->addPanel(numberingModule, _("Numbering & TOC"));
 672         docPS->addPanel(biblioModule, _("Bibliography"));
 673         docPS->addPanel(pdfSupportModule, _("PDF Properties"));
 674         docPS->addPanel(mathsModule, _("Math Options"));
 675         docPS->addPanel(floatModule, _("Float Placement"));
 676         docPS->addPanel(bulletsModule, _("Bullets"));
 677         docPS->addPanel(branchesModule, _("Branches"));
 678         docPS->addPanel(embeddedFilesModule, _("Embedded Files"));
 679         docPS->addPanel(preambleModule, _("LaTeX Preamble"));
 680         docPS->setCurrentPanel(_("Document Class"));
 681 // FIXME: hack to work around resizing bug in Qt >= 4.2
 682 // bug verified with Qt 4.2.{0-3} (JSpitzm)
 683 #if QT_VERSION >= 0x040200
 684         docPS->updateGeometry();
 685 #endif
 686 }
 687
 688
 689 void GuiDocument::showPreamble()
 690 {
 691         docPS->setCurrentPanel(_("LaTeX Preamble"));
 692 }
 693
 694
 695 void GuiDocument::saveDefaultClicked()
 696 {
 697         saveDocDefault();
 698 }
 699
 700
 701 void GuiDocument::useDefaultsClicked()
 702 {
 703         useClassDefaults();
 704 }
 705
 706
 707 void GuiDocument::change_adaptor()
 708 {
 709         changed();
 710 }
 711
 712
 713 docstring GuiDocument::validate_listings_params()
 714 {
 715         // use a cache here to avoid repeated validation
 716         // of the same parameters
 717         static string param_cache = string();
 718         static docstring msg_cache = docstring();
 719
 720         if (textLayoutModule->bypassCB->isChecked())
 721                 return docstring();
 722
 723         string params = fromqstr(textLayoutModule->listingsED->toPlainText());
 724         if (params != param_cache) {
 725                 param_cache = params;
 726                 msg_cache = InsetListingsParams(params).validate();
 727         }
 728         return msg_cache;
 729 }
 730
 731
 732 void GuiDocument::set_listings_msg()
 733 {
 734         static bool isOK = true;
 735         docstring msg = validate_listings_params();
 736         if (msg.empty()) {
 737                 if (isOK)
 738                         return;
 739                 isOK = true;
 740                 // listingsTB->setTextColor("black");
 741                 textLayoutModule->listingsTB->setPlainText(
 742                         qt_("Input listings parameters on the right. Enter ? for a list of parameters."));
 743         } else {
 744                 isOK = false;
 745                 // listingsTB->setTextColor("red");
 746                 textLayoutModule->listingsTB->setPlainText(toqstr(msg));
 747         }
 748 }
 749
 750
 751 void GuiDocument::closeEvent(QCloseEvent * e)
 752 {
 753         slotClose();
 754         e->accept();
 755 }
 756
 757
 758 void GuiDocument::setLSpacing(int item)
 759 {
 760         textLayoutModule->lspacingLE->setEnabled(item == 3);
 761 }
 762
 763
 764 void GuiDocument::setSkip(int item)
 765 {
 766         bool const enable = (item == 3);
 767         textLayoutModule->skipLE->setEnabled(enable);
 768         textLayoutModule->skipLengthCO->setEnabled(enable);
 769 }
 770
 771
 772 void GuiDocument::enableSkip(bool skip)
 773 {
 774         textLayoutModule->skipCO->setEnabled(skip);
 775         textLayoutModule->skipLE->setEnabled(skip);
 776         textLayoutModule->skipLengthCO->setEnabled(skip);
 777         if (skip)
 778                 setSkip(textLayoutModule->skipCO->currentIndex());
 779 }
 780
 781 void GuiDocument::portraitChanged()
 782 {
 783         setMargins(pageLayoutModule->papersizeCO->currentIndex());
 784 }
 785
 786 void GuiDocument::setMargins(bool custom)
 787 {
 788         marginsModule->marginCB->setChecked(custom);
 789         setCustomMargins(custom);
 790 }
 791
 792
 793 void GuiDocument::setCustomPapersize(int papersize)
 794 {
 795         bool const custom = (papersize == 1);
 796
 797         pageLayoutModule->paperwidthL->setEnabled(custom);
 798         pageLayoutModule->paperwidthLE->setEnabled(custom);
 799         pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
 800         pageLayoutModule->paperheightL->setEnabled(custom);
 801         pageLayoutModule->paperheightLE->setEnabled(custom);
 802         pageLayoutModule->paperheightLE->setFocus();
 803         pageLayoutModule->paperheightUnitCO->setEnabled(custom);
 804 }
 805
 806
 807 void GuiDocument::setCustomMargins(bool custom)
 808 {
 809         marginsModule->topL->setEnabled(!custom);
 810         marginsModule->topLE->setEnabled(!custom);
 811         marginsModule->topUnit->setEnabled(!custom);
 812
 813         marginsModule->bottomL->setEnabled(!custom);
 814         marginsModule->bottomLE->setEnabled(!custom);
 815         marginsModule->bottomUnit->setEnabled(!custom);
 816
 817         marginsModule->innerL->setEnabled(!custom);
 818         marginsModule->innerLE->setEnabled(!custom);
 819         marginsModule->innerUnit->setEnabled(!custom);
 820
 821         marginsModule->outerL->setEnabled(!custom);
 822         marginsModule->outerLE->setEnabled(!custom);
 823         marginsModule->outerUnit->setEnabled(!custom);
 824
 825         marginsModule->headheightL->setEnabled(!custom);
 826         marginsModule->headheightLE->setEnabled(!custom);
 827         marginsModule->headheightUnit->setEnabled(!custom);
 828
 829         marginsModule->headsepL->setEnabled(!custom);
 830         marginsModule->headsepLE->setEnabled(!custom);
 831         marginsModule->headsepUnit->setEnabled(!custom);
 832
 833         marginsModule->footskipL->setEnabled(!custom);
 834         marginsModule->footskipLE->setEnabled(!custom);
 835         marginsModule->footskipUnit->setEnabled(!custom);
 836 }
 837
 838
 839 void GuiDocument::updateFontsize(string const & items, string const & sel)
 840 {
 841         fontModule->fontsizeCO->clear();
 842         fontModule->fontsizeCO->addItem(qt_("Default"));
 843
 844         for (int n = 0; !token(items,'|',n).empty(); ++n)
 845                 fontModule->fontsizeCO->
 846                         addItem(toqstr(token(items,'|',n)));
 847
 848         for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
 849                 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
 850                         fontModule->fontsizeCO->setCurrentIndex(n);
 851                         break;
 852                 }
 853         }
 854 }
 855
 856
 857 void GuiDocument::romanChanged(int item)
 858 {
 859         string const font = tex_fonts_roman[item];
 860         fontModule->fontScCB->setEnabled(providesSC(font));
 861         fontModule->fontOsfCB->setEnabled(providesOSF(font));
 862 }
 863
 864
 865 void GuiDocument::sansChanged(int item)
 866 {
 867         string const font = tex_fonts_sans[item];
 868         bool scaleable = providesScale(font);
 869         fontModule->scaleSansSB->setEnabled(scaleable);
 870         fontModule->scaleSansLA->setEnabled(scaleable);
 871 }
 872
 873
 874 void GuiDocument::ttChanged(int item)
 875 {
 876         string const font = tex_fonts_monospaced[item];
 877         bool scaleable = providesScale(font);
 878         fontModule->scaleTypewriterSB->setEnabled(scaleable);
 879         fontModule->scaleTypewriterLA->setEnabled(scaleable);
 880 }
 881
 882
 883 void GuiDocument::updatePagestyle(string const & items, string const & sel)
 884 {
 885         pagestyles.clear();
 886         pageLayoutModule->pagestyleCO->clear();
 887         pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
 888
 889         for (int n = 0; !token(items,'|',n).empty(); ++n) {
 890                 string style = token(items, '|', n);
 891                 docstring style_gui = _(style);
 892                 pagestyles.push_back(pair<string, docstring>(style, style_gui));
 893                 pageLayoutModule->pagestyleCO->addItem(toqstr(style_gui));
 894         }
 895
 896         if (sel == "default") {
 897                 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
 898                 return;
 899         }
 900
 901         int nn = 0;
 902
 903         for (size_t i = 0; i < pagestyles.size(); ++i)
 904                 if (pagestyles[i].first == sel)
 905                         nn = pageLayoutModule->pagestyleCO->findText(
 906                                         toqstr(pagestyles[i].second));
 907
 908         if (nn > 0)
 909                 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
 910 }
 911
 912
 913 void GuiDocument::classChanged()
 914 {
 915         textclass_type const tc = latexModule->classCO->currentIndex();
 916         bp_.setJustBaseClass(tc);
 917         if (lyxrc.auto_reset_options)
 918                 bp_.useClassDefaults();
 919         updateContents();
 920 }
 921
 922
 923 void GuiDocument::updateModuleInfo()
 924 {
 925         selectionManager->update();
 926         //Module description
 927         QListView const * const lv = selectionManager->selectedFocused() ?
 928                                      latexModule->selectedLV :
 929                         latexModule->availableLV;
 930         if (lv->selectionModel()->selectedIndexes().isEmpty())
 931                 latexModule->infoML->document()->clear();
 932         else {
 933                 QModelIndex const idx = lv->selectionModel()->currentIndex();
 934                 string const modName = fromqstr(idx.data().toString());
 935                 string desc = getModuleDescription(modName);
 936                 vector<string> pkgList = getPackageList(modName);
 937                 string pkgdesc;
 938                 //this mess formats the package list as "pkg1, pkg2, and pkg3"
 939                 int const pkgListSize = pkgList.size();
 940                 for (int i = 0; i < pkgListSize; ++i) {
 941                         if (i == 1) {
 942                                 if (i == pkgListSize - 1) //last element
 943                                         pkgdesc += " and ";
 944                                 else
 945                                         pkgdesc += ", ";
 946                         } else if (i > 1) {
 947                                 if (i == pkgListSize - 1) //last element
 948                                         pkgdesc += ", and ";
 949                                 else
 950                                         pkgdesc += ", ";
 951                         }
 952                         pkgdesc += pkgList[i];
 953                 }
 954                 if (!pkgdesc.empty())
 955                         desc += " Requires " + pkgdesc + ".";
 956                 latexModule->infoML->document()->setPlainText(toqstr(desc));
 957         }
 958 }
 959
 960
 961 void GuiDocument::updateEmbeddedFileList()
 962 {
 963         embeddedFilesModule->filesLW->clear();
 964         // add current embedded files
 965         EmbeddedFiles & files = buffer().embeddedFiles();
 966         files.update();
 967         EmbeddedFiles::EmbeddedFileList::iterator fit = files.begin();
 968         EmbeddedFiles::EmbeddedFileList::iterator fit_end = files.end();
 969         for (; fit != fit_end; ++fit) {
 970                 QString label = toqstr(fit->relFilename(buffer().filePath()));
 971                 if (fit->refCount() > 1)
 972                         label += " (" + QString::number(fit->refCount()) + ")";
 973                 QListWidgetItem * item = new QListWidgetItem(label);
 974                 item->setFlags(item->flags() | Qt::ItemIsSelectable
 975                         | Qt::ItemIsUserCheckable);
 976                 if(fit->embedded())
 977                         item->setCheckState(Qt::Checked);
 978                 else
 979                         item->setCheckState(Qt::Unchecked);
 980                 // index of the currently used ParConstIterator
 981                 embeddedFilesModule->filesLW->addItem(item);
 982         }
 983 }
 984
 985
 986 void GuiDocument::updateNumbering()
 987 {
 988         TextClass const & tclass = bp_.getTextClass();
 989
 990         numberingModule->tocTW->setUpdatesEnabled(false);
 991         numberingModule->tocTW->clear();
 992
 993         int const depth = numberingModule->depthSL->value();
 994         int const toc = numberingModule->tocSL->value();
 995         QString const no = qt_("No");
 996         QString const yes = qt_("Yes");
 997         TextClass::const_iterator end = tclass.end();
 998         TextClass::const_iterator cit = tclass.begin();
 999         QTreeWidgetItem * item = 0;
1000         for ( ; cit != end ; ++cit) {
1001                 int const toclevel = (*cit)->toclevel;
1002                 if (toclevel != Layout::NOT_IN_TOC
1003                     && (*cit)->labeltype == LABEL_COUNTER) {
1004                         item = new QTreeWidgetItem(numberingModule->tocTW);
1005                         item->setText(0, toqstr(translateIfPossible((*cit)->name())));
1006                         item->setText(1, (toclevel <= depth) ? yes : no);
1007                         item->setText(2, (toclevel <= toc) ? yes : no);
1008                 }
1009         }
1010
1011         numberingModule->tocTW->setUpdatesEnabled(true);
1012         numberingModule->tocTW->update();
1013 }
1014
1015
1016 void GuiDocument::apply(BufferParams & params)
1017 {
1018         // preamble
1019         preambleModule->apply(params);
1020
1021         // biblio
1022         params.setCiteEngine(biblio::ENGINE_BASIC);
1023
1024         if (biblioModule->citeNatbibRB->isChecked()) {
1025                 bool const use_numerical_citations =
1026                         biblioModule->citeStyleCO->currentIndex();
1027                 if (use_numerical_citations)
1028                         params.setCiteEngine(biblio::ENGINE_NATBIB_NUMERICAL);
1029                 else
1030                         params.setCiteEngine(biblio::ENGINE_NATBIB_AUTHORYEAR);
1031
1032         } else if (biblioModule->citeJurabibRB->isChecked())
1033                 params.setCiteEngine(biblio::ENGINE_JURABIB);
1034
1035         params.use_bibtopic =
1036                 biblioModule->bibtopicCB->isChecked();
1037
1038         // language & quotes
1039         if (langModule->defaultencodingRB->isChecked()) {
1040                 params.inputenc = "auto";
1041         } else {
1042                 int i = langModule->encodingCO->currentIndex();
1043                 if (i == 0)
1044                         params.inputenc = "default";
1045                 else
1046                         params.inputenc =
1047                                 fromqstr(langModule->encodingCO->currentText());
1048         }
1049
1050         InsetQuotes::quote_language lga = InsetQuotes::EnglishQ;
1051         switch (langModule->quoteStyleCO->currentIndex()) {
1052         case 0:
1053                 lga = InsetQuotes::EnglishQ;
1054                 break;
1055         case 1:
1056                 lga = InsetQuotes::SwedishQ;
1057                 break;
1058         case 2:
1059                 lga = InsetQuotes::GermanQ;
1060                 break;
1061         case 3:
1062                 lga = InsetQuotes::PolishQ;
1063                 break;
1064         case 4:
1065                 lga = InsetQuotes::FrenchQ;
1066                 break;
1067         case 5:
1068                 lga = InsetQuotes::DanishQ;
1069                 break;
1070         }
1071         params.quotes_language = lga;
1072
1073         int const pos = langModule->languageCO->currentIndex();
1074         params.language = lyx::languages.getLanguage(lang_[pos]);
1075
1076         // numbering
1077         if (params.getTextClass().hasTocLevels()) {
1078                 params.tocdepth = numberingModule->tocSL->value();
1079                 params.secnumdepth = numberingModule->depthSL->value();
1080         }
1081
1082         // bullets
1083         params.user_defined_bullet(0) = bulletsModule->getBullet(0);
1084         params.user_defined_bullet(1) = bulletsModule->getBullet(1);
1085         params.user_defined_bullet(2) = bulletsModule->getBullet(2);
1086         params.user_defined_bullet(3) = bulletsModule->getBullet(3);
1087
1088         // packages
1089         params.graphicsDriver =
1090                 tex_graphics[latexModule->psdriverCO->currentIndex()];
1091
1092         // Modules
1093         params.clearLayoutModules();
1094         QStringList const selMods = selectedModel()->stringList();
1095         for (int i = 0; i != selMods.size(); ++i)
1096                 params.addLayoutModule(lyx::fromqstr(selMods[i]));
1097
1098
1099         if (mathsModule->amsautoCB->isChecked()) {
1100                 params.use_amsmath = BufferParams::package_auto;
1101         } else {
1102                 if (mathsModule->amsCB->isChecked())
1103                         params.use_amsmath = BufferParams::package_on;
1104                 else
1105                         params.use_amsmath = BufferParams::package_off;
1106         }
1107
1108         if (mathsModule->esintautoCB->isChecked())
1109                 params.use_esint = BufferParams::package_auto;
1110         else {
1111                 if (mathsModule->esintCB->isChecked())
1112                         params.use_esint = BufferParams::package_on;
1113                 else
1114                         params.use_esint = BufferParams::package_off;
1115         }
1116
1117         // text layout
1118         params.setJustBaseClass(latexModule->classCO->currentIndex());
1119
1120         if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
1121                 params.pagestyle = "default";
1122         else {
1123                 docstring style_gui =
1124                         qstring_to_ucs4(pageLayoutModule->pagestyleCO->currentText());
1125                 for (size_t i = 0; i < pagestyles.size(); ++i)
1126                         if (pagestyles[i].second == style_gui)
1127                                 params.pagestyle = pagestyles[i].first;
1128         }
1129
1130         switch (textLayoutModule->lspacingCO->currentIndex()) {
1131         case 0:
1132                 params.spacing().set(Spacing::Single);
1133                 break;
1134         case 1:
1135                 params.spacing().set(Spacing::Onehalf);
1136                 break;
1137         case 2:
1138                 params.spacing().set(Spacing::Double);
1139                 break;
1140         case 3:
1141                 params.spacing().set(Spacing::Other,
1142                         fromqstr(textLayoutModule->lspacingLE->text()));
1143                 break;
1144         }
1145
1146         if (textLayoutModule->twoColumnCB->isChecked())
1147                 params.columns = 2;
1148         else
1149                 params.columns = 1;
1150
1151         // text should have passed validation
1152         params.listings_params =
1153                 InsetListingsParams(fromqstr(textLayoutModule->listingsED->toPlainText())).params();
1154
1155         if (textLayoutModule->indentRB->isChecked())
1156                 params.paragraph_separation = BufferParams::PARSEP_INDENT;
1157         else
1158                 params.paragraph_separation = BufferParams::PARSEP_SKIP;
1159
1160         switch (textLayoutModule->skipCO->currentIndex()) {
1161         case 0:
1162                 params.setDefSkip(VSpace(VSpace::SMALLSKIP));
1163                 break;
1164         case 1:
1165                 params.setDefSkip(VSpace(VSpace::MEDSKIP));
1166                 break;
1167         case 2:
1168                 params.setDefSkip(VSpace(VSpace::BIGSKIP));
1169                 break;
1170         case 3:
1171         {
1172                 VSpace vs = VSpace(
1173                         widgetsToLength(textLayoutModule->skipLE,
1174                                 textLayoutModule->skipLengthCO)
1175                         );
1176                 params.setDefSkip(vs);
1177                 break;
1178         }
1179         default:
1180                 // DocumentDefskipCB assures that this never happens
1181                 // so Assert then !!!  - jbl
1182                 params.setDefSkip(VSpace(VSpace::MEDSKIP));
1183                 break;
1184         }
1185
1186         params.options =
1187                 fromqstr(latexModule->optionsLE->text());
1188
1189         params.float_placement = floatModule->get();
1190
1191         // fonts
1192         params.fontsRoman =
1193                 tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1194
1195         params.fontsSans =
1196                 tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1197
1198         params.fontsTypewriter =
1199                 tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1200
1201         params.fontsSansScale = fontModule->scaleSansSB->value();
1202
1203         params.fontsTypewriterScale = fontModule->scaleTypewriterSB->value();
1204
1205         params.fontsSC = fontModule->fontScCB->isChecked();
1206
1207         params.fontsOSF = fontModule->fontOsfCB->isChecked();
1208
1209         params.fontsDefaultFamily = GuiDocument::fontfamilies[
1210                 fontModule->fontsDefaultCO->currentIndex()];
1211
1212         if (fontModule->fontsizeCO->currentIndex() == 0)
1213                 params.fontsize = "default";
1214         else
1215                 params.fontsize =
1216                         fromqstr(fontModule->fontsizeCO->currentText());
1217
1218         // paper
1219         params.papersize = PAPER_SIZE(
1220                 pageLayoutModule->papersizeCO->currentIndex());
1221
1222         // custom, A3, B3 and B4 paper sizes need geometry
1223         int psize = pageLayoutModule->papersizeCO->currentIndex();
1224         bool geom_papersize = (psize == 1 || psize == 5 || psize == 8 || psize == 9);
1225
1226         params.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
1227                 pageLayoutModule->paperwidthUnitCO);
1228
1229         params.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
1230                 pageLayoutModule->paperheightUnitCO);
1231
1232         if (pageLayoutModule->facingPagesCB->isChecked())
1233                 params.sides = TwoSides;
1234         else
1235                 params.sides = OneSide;
1236
1237         if (pageLayoutModule->landscapeRB->isChecked())
1238                 params.orientation = ORIENTATION_LANDSCAPE;
1239         else
1240                 params.orientation = ORIENTATION_PORTRAIT;
1241
1242         // margins
1243         params.use_geometry =
1244                 (!marginsModule->marginCB->isChecked()
1245                 || geom_papersize);
1246
1247         Ui::MarginsUi const * m(marginsModule);
1248
1249         params.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
1250         params.topmargin = widgetsToLength(m->topLE, m->topUnit);
1251         params.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
1252         params.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
1253         params.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
1254         params.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
1255         params.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
1256
1257         branchesModule->apply(params);
1258
1259         // PDF support
1260         PDFOptions & pdf = params.pdfoptions();
1261         pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
1262         pdf.title = fromqstr(pdfSupportModule->titleLE->text());
1263         pdf.author = fromqstr(pdfSupportModule->authorLE->text());
1264         pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
1265         pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
1266
1267         pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
1268         pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
1269         pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
1270         pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
1271
1272         pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
1273         pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
1274         pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
1275         pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
1276         pdf.backref = pdfSupportModule->backrefCB->isChecked();
1277         pdf.pagebackref = pdfSupportModule->pagebackrefCB->isChecked();
1278         if (pdfSupportModule->fullscreenCB->isChecked())
1279                 pdf.pagemode = pdf.pagemode_fullscreen;
1280         else
1281                 pdf.pagemode.clear();
1282         pdf.quoted_options = fromqstr(pdfSupportModule->optionsLE->text());
1283
1284         // Embedded files
1285         // FIXME
1286 }
1287
1288
1289 /** Return the position of val in the vector if found.
1290     If not found, return 0.
1291  */
1292 template<class A>
1293 static size_t findPos(vector<A> const & vec, A const & val)
1294 {
1295         typename vector<A>::const_iterator it =
1296                 find(vec.begin(), vec.end(), val);
1297         if (it == vec.end())
1298                 return 0;
1299         return distance(vec.begin(), it);
1300 }
1301
1302
1303 void GuiDocument::updateParams()
1304 {
1305         updateParams(bp_);
1306 }
1307
1308
1309 void GuiDocument::updateParams(BufferParams const & params)
1310 {
1311         // set the default unit
1312         Length::UNIT defaultUnit = Length::CM;
1313         switch (lyxrc.default_papersize) {
1314                 case PAPER_DEFAULT: break;
1315
1316                 case PAPER_USLETTER:
1317                 case PAPER_USLEGAL:
1318                 case PAPER_USEXECUTIVE:
1319                         defaultUnit = Length::IN;
1320                         break;
1321
1322                 case PAPER_A3:
1323                 case PAPER_A4:
1324                 case PAPER_A5:
1325                 case PAPER_B3:
1326                 case PAPER_B4:
1327                 case PAPER_B5:
1328                         defaultUnit = Length::CM;
1329                         break;
1330                 case PAPER_CUSTOM:
1331                         break;
1332         }
1333
1334         // preamble
1335         preambleModule->update(params, id());
1336
1337         // biblio
1338         biblioModule->citeDefaultRB->setChecked(
1339                 params.getEngine() == biblio::ENGINE_BASIC);
1340
1341         biblioModule->citeNatbibRB->setChecked(
1342                 params.getEngine() == biblio::ENGINE_NATBIB_NUMERICAL ||
1343                 params.getEngine() == biblio::ENGINE_NATBIB_AUTHORYEAR);
1344
1345         biblioModule->citeStyleCO->setCurrentIndex(
1346                 params.getEngine() == biblio::ENGINE_NATBIB_NUMERICAL);
1347
1348         biblioModule->citeJurabibRB->setChecked(
1349                 params.getEngine() == biblio::ENGINE_JURABIB);
1350
1351         biblioModule->bibtopicCB->setChecked(
1352                 params.use_bibtopic);
1353
1354         // language & quotes
1355         int const pos = int(findPos(lang_,
1356                                     params.language->lang()));
1357         langModule->languageCO->setCurrentIndex(pos);
1358
1359         langModule->quoteStyleCO->setCurrentIndex(
1360                 params.quotes_language);
1361
1362         bool default_enc = true;
1363         if (params.inputenc != "auto") {
1364                 default_enc = false;
1365                 if (params.inputenc == "default") {
1366                         langModule->encodingCO->setCurrentIndex(0);
1367                 } else {
1368                         int const i = langModule->encodingCO->findText(
1369                                         toqstr(params.inputenc));
1370                         if (i >= 0)
1371                                 langModule->encodingCO->setCurrentIndex(i);
1372                         else
1373                                 // unknown encoding. Set to default.
1374                                 default_enc = true;
1375                 }
1376         }
1377         langModule->defaultencodingRB->setChecked(default_enc);
1378         langModule->otherencodingRB->setChecked(!default_enc);
1379
1380         // numbering
1381         int const min_toclevel = textClass().min_toclevel();
1382         int const max_toclevel = textClass().max_toclevel();
1383         if (textClass().hasTocLevels()) {
1384                 numberingModule->setEnabled(true);
1385                 numberingModule->depthSL->setMinimum(min_toclevel - 1);
1386                 numberingModule->depthSL->setMaximum(max_toclevel);
1387                 numberingModule->depthSL->setValue(params.secnumdepth);
1388                 numberingModule->tocSL->setMaximum(min_toclevel - 1);
1389                 numberingModule->tocSL->setMaximum(max_toclevel);
1390                 numberingModule->tocSL->setValue(params.tocdepth);
1391                 updateNumbering();
1392         } else {
1393                 numberingModule->setEnabled(false);
1394                 numberingModule->tocTW->clear();
1395         }
1396
1397         // bullets
1398         bulletsModule->setBullet(0, params.user_defined_bullet(0));
1399         bulletsModule->setBullet(1, params.user_defined_bullet(1));
1400         bulletsModule->setBullet(2, params.user_defined_bullet(2));
1401         bulletsModule->setBullet(3, params.user_defined_bullet(3));
1402         bulletsModule->init();
1403
1404         // packages
1405         int nitem = findToken(tex_graphics, params.graphicsDriver);
1406         if (nitem >= 0)
1407                 latexModule->psdriverCO->setCurrentIndex(nitem);
1408         updateModuleInfo();
1409
1410         mathsModule->amsCB->setChecked(
1411                 params.use_amsmath == BufferParams::package_on);
1412         mathsModule->amsautoCB->setChecked(
1413                 params.use_amsmath == BufferParams::package_auto);
1414
1415         mathsModule->esintCB->setChecked(
1416                 params.use_esint == BufferParams::package_on);
1417         mathsModule->esintautoCB->setChecked(
1418                 params.use_esint == BufferParams::package_auto);
1419
1420         switch (params.spacing().getSpace()) {
1421                 case Spacing::Other: nitem = 3; break;
1422                 case Spacing::Double: nitem = 2; break;
1423                 case Spacing::Onehalf: nitem = 1; break;
1424                 case Spacing::Default: case Spacing::Single: nitem = 0; break;
1425         }
1426
1427         // text layout
1428         latexModule->classCO->setCurrentIndex(params.getBaseClass());
1429
1430         updatePagestyle(textClass().opt_pagestyle(),
1431                                  params.pagestyle);
1432
1433         textLayoutModule->lspacingCO->setCurrentIndex(nitem);
1434         if (params.spacing().getSpace() == Spacing::Other) {
1435                 textLayoutModule->lspacingLE->setText(
1436                         toqstr(params.spacing().getValueAsString()));
1437         }
1438         setLSpacing(nitem);
1439
1440         if (params.paragraph_separation == BufferParams::PARSEP_INDENT)
1441                 textLayoutModule->indentRB->setChecked(true);
1442         else
1443                 textLayoutModule->skipRB->setChecked(true);
1444
1445         int skip = 0;
1446         switch (params.getDefSkip().kind()) {
1447         case VSpace::SMALLSKIP:
1448                 skip = 0;
1449                 break;
1450         case VSpace::MEDSKIP:
1451                 skip = 1;
1452                 break;
1453         case VSpace::BIGSKIP:
1454                 skip = 2;
1455                 break;
1456         case VSpace::LENGTH:
1457         {
1458                 skip = 3;
1459                 string const length = params.getDefSkip().asLyXCommand();
1460                 lengthToWidgets(textLayoutModule->skipLE,
1461                         textLayoutModule->skipLengthCO,
1462                         length, defaultUnit);
1463                 break;
1464         }
1465         default:
1466                 skip = 0;
1467                 break;
1468         }
1469         textLayoutModule->skipCO->setCurrentIndex(skip);
1470         setSkip(skip);
1471
1472         textLayoutModule->twoColumnCB->setChecked(
1473                 params.columns == 2);
1474
1475         // break listings_params to multiple lines
1476         string lstparams =
1477                 InsetListingsParams(params.listings_params).separatedParams();
1478         textLayoutModule->listingsED->setPlainText(toqstr(lstparams));
1479
1480         if (!params.options.empty()) {
1481                 latexModule->optionsLE->setText(
1482                         toqstr(params.options));
1483         } else {
1484                 latexModule->optionsLE->setText(QString());
1485         }
1486
1487         floatModule->set(params.float_placement);
1488
1489         // Fonts
1490         updateFontsize(textClass().opt_fontsize(),
1491                         params.fontsize);
1492
1493         int n = findToken(tex_fonts_roman, params.fontsRoman);
1494         if (n >= 0) {
1495                 fontModule->fontsRomanCO->setCurrentIndex(n);
1496                 romanChanged(n);
1497         }
1498
1499         n = findToken(tex_fonts_sans, params.fontsSans);
1500         if (n >= 0)     {
1501                 fontModule->fontsSansCO->setCurrentIndex(n);
1502                 sansChanged(n);
1503         }
1504
1505         n = findToken(tex_fonts_monospaced, params.fontsTypewriter);
1506         if (n >= 0) {
1507                 fontModule->fontsTypewriterCO->setCurrentIndex(n);
1508                 ttChanged(n);
1509         }
1510
1511         fontModule->fontScCB->setChecked(params.fontsSC);
1512         fontModule->fontOsfCB->setChecked(params.fontsOSF);
1513         fontModule->scaleSansSB->setValue(params.fontsSansScale);
1514         fontModule->scaleTypewriterSB->setValue(params.fontsTypewriterScale);
1515         n = findToken(GuiDocument::fontfamilies, params.fontsDefaultFamily);
1516         if (n >= 0)
1517                 fontModule->fontsDefaultCO->setCurrentIndex(n);
1518
1519         // paper
1520         int const psize = params.papersize;
1521         pageLayoutModule->papersizeCO->setCurrentIndex(psize);
1522         setCustomPapersize(psize);
1523
1524         bool const landscape =
1525                 params.orientation == ORIENTATION_LANDSCAPE;
1526         pageLayoutModule->landscapeRB->setChecked(landscape);
1527         pageLayoutModule->portraitRB->setChecked(!landscape);
1528
1529         pageLayoutModule->facingPagesCB->setChecked(
1530                 params.sides == TwoSides);
1531
1532
1533         lengthToWidgets(pageLayoutModule->paperwidthLE,
1534                 pageLayoutModule->paperwidthUnitCO, params.paperwidth, defaultUnit);
1535
1536         lengthToWidgets(pageLayoutModule->paperheightLE,
1537                 pageLayoutModule->paperheightUnitCO, params.paperheight, defaultUnit);
1538
1539         // margins
1540         Ui::MarginsUi * m = marginsModule;
1541
1542         setMargins(!params.use_geometry);
1543
1544         lengthToWidgets(m->topLE, m->topUnit,
1545                 params.topmargin, defaultUnit);
1546
1547         lengthToWidgets(m->bottomLE, m->bottomUnit,
1548                 params.bottommargin, defaultUnit);
1549
1550         lengthToWidgets(m->innerLE, m->innerUnit,
1551                 params.leftmargin, defaultUnit);
1552
1553         lengthToWidgets(m->outerLE, m->outerUnit,
1554                 params.rightmargin, defaultUnit);
1555
1556         lengthToWidgets(m->headheightLE, m->headheightUnit,
1557                 params.headheight, defaultUnit);
1558
1559         lengthToWidgets(m->headsepLE, m->headsepUnit,
1560                 params.headsep, defaultUnit);
1561
1562         lengthToWidgets(m->footskipLE, m->footskipUnit,
1563                 params.footskip, defaultUnit);
1564
1565         branchesModule->update(params);
1566
1567         // PDF support
1568         PDFOptions const & pdf = params.pdfoptions();
1569         pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
1570         pdfSupportModule->titleLE->setText(toqstr(pdf.title));
1571         pdfSupportModule->authorLE->setText(toqstr(pdf.author));
1572         pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
1573         pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
1574
1575         pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
1576         pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
1577         pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
1578
1579         pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
1580
1581         pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
1582         pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
1583         pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
1584         pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
1585         pdfSupportModule->backrefCB->setChecked(pdf.backref);
1586         pdfSupportModule->pagebackrefCB->setChecked(pdf.pagebackref);
1587         pdfSupportModule->fullscreenCB->setChecked
1588                 (pdf.pagemode == pdf.pagemode_fullscreen);
1589
1590         pdfSupportModule->optionsLE->setText(
1591                 toqstr(pdf.quoted_options));
1592
1593         // embedded files
1594         updateEmbeddedFileList();
1595 }
1596
1597
1598 void GuiDocument::applyView()
1599 {
1600         apply(params());
1601 }
1602
1603
1604 void GuiDocument::saveDocDefault()
1605 {
1606         // we have to apply the params first
1607         applyView();
1608         saveAsDefault();
1609 }
1610
1611
1612 void GuiDocument::updateContents()
1613 {
1614         //update list of available modules
1615         QStringList strlist;
1616         vector<string> const modNames = getModuleNames();
1617         vector<string>::const_iterator it = modNames.begin();
1618         for (; it != modNames.end(); ++it)
1619                 strlist.push_back(toqstr(*it));
1620         available_model_.setStringList(strlist);
1621         //and selected ones, too
1622         QStringList strlist2;
1623         vector<string> const & selMods = getSelectedModules();
1624         it = selMods.begin();
1625         for (; it != selMods.end(); ++it)
1626                 strlist2.push_back(toqstr(*it));
1627         selected_model_.setStringList(strlist2);
1628
1629         updateParams(bp_);
1630 }
1631
1632 void GuiDocument::useClassDefaults()
1633 {
1634         bp_.setJustBaseClass(latexModule->classCO->currentIndex());
1635         bp_.useClassDefaults();
1636         updateContents();
1637 }
1638
1639
1640 bool GuiDocument::isValid()
1641 {
1642         return validate_listings_params().empty();
1643 }
1644
1645
1646 char const * const GuiDocument::fontfamilies[5] = {
1647         "default", "rmdefault", "sfdefault", "ttdefault", ""
1648 };
1649
1650
1651 char const * GuiDocument::fontfamilies_gui[5] = {
1652         N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
1653 };
1654
1655
1656 bool GuiDocument::initialiseParams(string const &)
1657 {
1658         bp_ = buffer().params();
1659         loadModuleNames();
1660         return true;
1661 }
1662
1663
1664 void GuiDocument::clearParams()
1665 {
1666         bp_ = BufferParams();
1667 }
1668
1669
1670 BufferId GuiDocument::id() const
1671 {
1672         return &buffer();
1673 }
1674
1675
1676 vector<string> GuiDocument::getModuleNames()
1677 {
1678         return moduleNames_;
1679 }
1680
1681
1682 vector<string> const & GuiDocument::getSelectedModules()
1683 {
1684         return params().getModules();
1685 }
1686
1687
1688 string GuiDocument::getModuleDescription(string const & modName) const
1689 {
1690         LyXModule const * const mod = moduleList[modName];
1691         if (!mod)
1692                 return string("Module unavailable!");
1693         return mod->description;
1694 }
1695
1696
1697 vector<string>
1698 GuiDocument::getPackageList(string const & modName) const
1699 {
1700         LyXModule const * const mod = moduleList[modName];
1701         if (!mod)
1702                 return vector<string>(); //empty such thing
1703         return mod->packageList;
1704 }
1705
1706
1707 TextClass const & GuiDocument::textClass() const
1708 {
1709         return textclasslist[bp_.getBaseClass()];
1710 }
1711
1712
1713 static void dispatch_bufferparams(Dialog const & dialog,
1714         BufferParams const & bp, kb_action lfun)
1715 {
1716         ostringstream ss;
1717         ss << "\\begin_header\n";
1718         bp.writeFile(ss);
1719         ss << "\\end_header\n";
1720         dialog.dispatch(FuncRequest(lfun, ss.str()));
1721 }
1722
1723
1724 void GuiDocument::dispatchParams()
1725 {
1726         // This must come first so that a language change is correctly noticed
1727         setLanguage();
1728
1729         // Apply the BufferParams. Note that this will set the base class
1730         // and then update the buffer's layout.
1731         //FIXME Could this be done last? Then, I think, we'd get the automatic
1732         //update mentioned in the next FIXME...
1733         dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
1734
1735         // Generate the colours requested by each new branch.
1736         BranchList & branchlist = params().branchlist();
1737         if (!branchlist.empty()) {
1738                 BranchList::const_iterator it = branchlist.begin();
1739                 BranchList::const_iterator const end = branchlist.end();
1740                 for (; it != end; ++it) {
1741                         docstring const & current_branch = it->getBranch();
1742                         Branch const * branch = branchlist.find(current_branch);
1743                         string const x11hexname = X11hexname(branch->getColor());
1744                         // display the new color
1745                         docstring const str = current_branch + ' ' + from_ascii(x11hexname);
1746                         dispatch(FuncRequest(LFUN_SET_COLOR, str));
1747                 }
1748
1749                 // Open insets of selected branches, close deselected ones
1750                 dispatch(FuncRequest(LFUN_ALL_INSETS_TOGGLE,
1751                         "assign branch"));
1752         }
1753         // FIXME: If we used an LFUN, we would not need those two lines:
1754         bufferview()->processUpdateFlags(Update::Force | Update::FitCursor);
1755 }
1756
1757
1758 void GuiDocument::setLanguage() const
1759 {
1760         Language const * const newL = bp_.language;
1761         if (buffer().params().language == newL)
1762                 return;
1763
1764         string const & lang_name = newL->lang();
1765         dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
1766 }
1767
1768
1769 void GuiDocument::saveAsDefault() const
1770 {
1771         dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
1772 }
1773
1774
1775 bool GuiDocument::isFontAvailable(string const & font) const
1776 {
1777         if (font == "default" || font == "cmr"
1778             || font == "cmss" || font == "cmtt")
1779                 // these are standard
1780                 return true;
1781         if (font == "lmodern" || font == "lmss" || font == "lmtt")
1782                 return LaTeXFeatures::isAvailable("lmodern");
1783         if (font == "times" || font == "palatino"
1784                  || font == "helvet" || font == "courier")
1785                 return LaTeXFeatures::isAvailable("psnfss");
1786         if (font == "cmbr" || font == "cmtl")
1787                 return LaTeXFeatures::isAvailable("cmbright");
1788         if (font == "utopia")
1789                 return LaTeXFeatures::isAvailable("utopia")
1790                         || LaTeXFeatures::isAvailable("fourier");
1791         if (font == "beraserif" || font == "berasans"
1792                 || font == "beramono")
1793                 return LaTeXFeatures::isAvailable("bera");
1794         return LaTeXFeatures::isAvailable(font);
1795 }
1796
1797
1798 bool GuiDocument::providesOSF(string const & font) const
1799 {
1800         if (font == "cmr")
1801                 return isFontAvailable("eco");
1802         if (font == "palatino")
1803                 return isFontAvailable("mathpazo");
1804         return false;
1805 }
1806
1807
1808 bool GuiDocument::providesSC(string const & font) const
1809 {
1810         if (font == "palatino")
1811                 return isFontAvailable("mathpazo");
1812         if (font == "utopia")
1813                 return isFontAvailable("fourier");
1814         return false;
1815 }
1816
1817
1818 bool GuiDocument::providesScale(string const & font) const
1819 {
1820         return font == "helvet" || font == "luximono"
1821                 || font == "berasans"  || font == "beramono";
1822 }
1823
1824
1825 void GuiDocument::loadModuleNames ()
1826 {
1827         moduleNames_.clear();
1828         LyXModuleList::const_iterator it = moduleList.begin();
1829         for (; it != moduleList.end(); ++it)
1830                 moduleNames_.push_back(it->name);
1831         if (!moduleNames_.empty())
1832                 sort(moduleNames_.begin(), moduleNames_.end());
1833 }
1834
1835
1836 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
1837
1838
1839 } // namespace frontend
1840 } // namespace lyx
1841
1842 #include "GuiDocument_moc.cpp"