src/frontends/gtk/GDocument.C

   1 /**
   2  * \file GDocument.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author John Spray
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 // Too hard to make concept checks work with this file
  14 #ifdef _GLIBCXX_CONCEPT_CHECKS
  15 #undef _GLIBCXX_CONCEPT_CHECKS
  16 #endif
  17 #ifdef _GLIBCPP_CONCEPT_CHECKS
  18 #undef _GLIBCPP_CONCEPT_CHECKS
  19 #endif
  20
  21 #include "GDocument.h"
  22 #include "ghelpers.h"
  23
  24 #include "ControlDocument.h"
  25 #include "controllers/helper_funcs.h"
  26 #include "controllers/frnt_lang.h"
  27
  28 #include "support/lstrings.h"
  29 #include "lyxrc.h"
  30
  31 #include "lyxtextclasslist.h"
  32 #include "bufferparams.h"
  33 #include "tex-strings.h"
  34 #include "language.h"
  35
  36 using std::string;
  37 using std::vector;
  38
  39 namespace lyx {
  40
  41 using support::bformat;
  42 using support::token;
  43 using support::contains;
  44 using support::findToken;
  45
  46 namespace frontend {
  47
  48 namespace {
  49
  50 char const * const encodings[] = { "Language Default", "LaTeX default",
  51         "latin1", "latin2", "latin3", "latin4", "latin5", "latin9",
  52         "koi8-r", "koi8-u", "cp866", "cp1251", "iso88595", "pt154", 0
  53 };
  54
  55 }
  56
  57
  58 GDocument::GDocument(Dialog & parent)
  59         : GViewCB<ControlDocument, GViewGladeB>(parent, _("Document Settings"), false),
  60         lang_(getSecond(getLanguageData(false)))
  61 {}
  62
  63 void GDocument::doBuild()
  64 {
  65         string const gladeName = findGladeFile("document");
  66         xml_ = Gnome::Glade::Xml::create(gladeName);
  67
  68         // Manage the action area buttons
  69         Gtk::Button * button;
  70         xml_->get_widget("Cancel", button);
  71         setCancel(button);
  72         xml_->get_widget("OK", button);
  73         setOK(button);
  74         xml_->get_widget("Apply", button);
  75         setApply(button);
  76         xml_->get_widget("Revert", button);
  77         setRestore(button);
  78
  79         xml_->get_widget("UseClassDefaults", button);
  80         button->signal_clicked().connect(
  81                 sigc::mem_fun(*this, &GDocument::resetToDefaults));
  82         xml_->get_widget("SaveAsDocumentDefaults", button);
  83         button->signal_clicked().connect(
  84                 sigc::mem_fun(*this, &GDocument::saveAsDefaults));
  85
  86
  87         // *** Start "Document" Page ***
  88         Gtk::Box * box = NULL;
  89         xml_->get_widget("DocumentClass", box);
  90         // Prevent combo making dialog super-wide due to long class names
  91         classcombo_.set_size_request(1, -1);
  92         box->pack_start(classcombo_, true, true, 0);
  93         box->show_all();
  94
  95         classcombo_.signal_changed().connect(
  96                 sigc::mem_fun(*this, &GDocument::classChanged));
  97
  98         // Populate Document Class combo
  99         for (LyXTextClassList::const_iterator cit = textclasslist.begin();
 100              cit != textclasslist.end(); ++cit) {
 101                 if (cit->isTeXClassAvailable()) {
 102                         classcombo_.append_text(cit->description());
 103                 } else {
 104                         string item =
 105                                 bformat(_("Unavailable: %1$s"), cit->description());
 106                         classcombo_.append_text(item);
 107                 }
 108         }
 109
 110         xml_->get_widget("ExtraOptions", extraoptionsentry_);
 111
 112         xml_->get_widget("PostscriptDriver", box);
 113         box->pack_start(psdrivercombo_, true, true, 0);
 114         box->show_all();
 115
 116         // Populate Postscript driver combo
 117         for (int i = 0; tex_graphics[i][0]; ++i) {
 118                 psdrivercombo_.append_text(tex_graphics[i]);
 119         }
 120
 121         xml_->get_widget("FontSans", box);
 122         box->pack_start(fontsanscombo_, true, true, 0);
 123         box->show_all();
 124
 125         // Populate sans font combo
 126         for (int i = 0; tex_fonts_sans_gui[i][0]; ++i) {
 127                 string font = _(tex_fonts_sans_gui[i]);
 128                 if (!controller().isFontAvailable(tex_fonts_sans[i]))
 129                         font += _(" (not installed)");
 130                 fontsanscombo_.append_text(font);
 131         }
 132
 133         xml_->get_widget("FontRoman", box);
 134         box->pack_start(fontromancombo_, true, true, 0);
 135         box->show_all();
 136
 137         // Populate roman font combo
 138         for (int i = 0; tex_fonts_roman_gui[i][0]; ++i) {
 139                 string font = _(tex_fonts_roman_gui[i]);
 140                 if (!controller().isFontAvailable(tex_fonts_roman[i]))
 141                         font += _(" (not installed)");
 142                 fontsanscombo_.append_text(font);
 143         }
 144
 145         xml_->get_widget("FontTypewriter", box);
 146         box->pack_start(fonttypewritercombo_, true, true, 0);
 147         box->show_all();
 148
 149         // Populate typewriter font combo
 150         for (int i = 0; tex_fonts_monospaced_gui[i][0]; ++i) {
 151                 string font = _(tex_fonts_monospaced_gui[i]);
 152                 if (!controller().isFontAvailable(tex_fonts_monospaced[i]))
 153                         font += _(" (not installed)");
 154                 fontsanscombo_.append_text(font);
 155         }
 156
 157         xml_->get_widget("FontDefaultFamily", box);
 158         box->pack_start(fontdefaultfamilycombo_, true, true, 0);
 159         box->show_all();
 160
 161         // Populate font default family combo
 162         for (int i = 0; ControlDocument::fontfamilies_gui[i][0]; ++i)
 163                 fontdefaultfamilycombo_.append_text(_(ControlDocument::fontfamilies_gui[i]));
 164
 165         xml_->get_widget("FontSize", box);
 166         box->pack_start(fontsizecombo_, true, true, 0);
 167         box->show_all();
 168
 169         xml_->get_widget("fontScCB", fontScCB_);
 170
 171         xml_->get_widget("fontOsfCB", fontOsfCB_);
 172
 173         xml_->get_widget("scaleSansSB", scaleSansSB_);
 174         scaleSansSB_->set_range(10, 200);
 175         scaleSansSB_->set_digits(0);
 176
 177         xml_->get_widget("scaleTypewriterSB", scaleTypewriterSB_);
 178         scaleTypewriterSB_->set_range(10, 200);
 179         scaleTypewriterSB_->set_digits(0);
 180
 181         Gtk::SpinButton * spin;
 182         xml_->get_widget("LineSpacing", spin);
 183         linespacingadj_ = spin->get_adjustment();
 184
 185         xml_->get_widget("Indentation", indentradio_);
 186         xml_->get_widget("VerticalSpace", vspaceradio_);
 187         vspaceradio_->signal_toggled().connect(
 188                 sigc::mem_fun(*this, &GDocument::updateParagraphSeparationSensitivity));
 189
 190
 191         xml_->get_widget("VerticalSpaceSize", box);
 192         box->pack_start(vspacesizecombo_, true, true, 0);
 193         box->show_all();
 194         // The order of these items is magic
 195         vspacesizecombo_.append_text(_("Small Skip"));
 196         vspacesizecombo_.append_text(_("Medium Skip"));
 197         vspacesizecombo_.append_text(_("Big Skip"));
 198         vspacesizecombo_.append_text(_("Custom"));
 199         vspacesizemap_[0] = VSpace::SMALLSKIP;
 200         vspacesizemap_[1] = VSpace::MEDSKIP;
 201         vspacesizemap_[2] = VSpace::BIGSKIP;
 202         vspacesizemap_[3] = VSpace::LENGTH;
 203
 204         vspacesizecombo_.signal_changed().connect(
 205                 sigc::mem_fun(*this,
 206                 &GDocument::updateParagraphSeparationSensitivity));
 207
 208         xml_->get_widget_derived("VerticalSpaceLength", vspacelengthentry_);
 209         vspacelengthentry_->set_relative(false);
 210
 211         updateParagraphSeparationSensitivity();
 212         // *** End "Document" Page ***
 213
 214         // *** Begin "Page" Page ***
 215         xml_->get_widget("PageSize", box);
 216         box->pack_start(pagesizecombo_, true, true, 0);
 217         box->show_all();
 218         pagesizecombo_.append_text(_("Default"));
 219         pagesizecombo_.append_text(_("Custom"));
 220         pagesizecombo_.append_text(_("US letter"));
 221         pagesizecombo_.append_text(_("US legal"));
 222         pagesizecombo_.append_text(_("US executive"));
 223         pagesizecombo_.append_text(_("A3"));
 224         pagesizecombo_.append_text(_("A4"));
 225         pagesizecombo_.append_text(_("A5"));
 226         pagesizecombo_.append_text(_("B3"));
 227         pagesizecombo_.append_text(_("B4"));
 228         pagesizecombo_.append_text(_("B5"));
 229         pagesizecombo_.signal_changed().connect(
 230                 sigc::mem_fun(*this, &GDocument::pageSizeChanged));
 231
 232         xml_->get_widget_derived("PageWidth", pagewidthlengthentry_);
 233         xml_->get_widget_derived("PageHeight", pageheightlengthentry_);
 234         pagewidthlengthentry_->set_relative(false);
 235         pageheightlengthentry_->set_relative(false);
 236
 237         xml_->get_widget("Portrait", portraitradio_);
 238         xml_->get_widget("Landscape", landscaperadio_);
 239
 240         xml_->get_widget("PageStyle", box);
 241         box->pack_start(pagestylecombo_, true, true, 0);
 242         box->show_all();
 243         xml_->get_widget("DoubleSided", doublesidedtoggle_);
 244         xml_->get_widget("TwoColumns", twocolumnstoggle_);
 245         // *** End "Page" Page ***
 246
 247         // *** Begin "Margins" Page ***
 248         xml_->get_widget("DefaultMargins", defaultmargins_);
 249         defaultmargins_->signal_toggled().connect(
 250                 sigc::mem_fun(*this, &GDocument::marginsChanged));
 251
 252         xml_->get_widget_derived("MarginsTop", mtoplengthentry_);
 253         xml_->get_widget_derived("MarginsBottom", mbottomlengthentry_);
 254         xml_->get_widget_derived("MarginsInner", minnerlengthentry_);
 255         xml_->get_widget_derived("MarginsOuter", mouterlengthentry_);
 256         xml_->get_widget_derived("MarginsHeadSep", mheadseplengthentry_);
 257         xml_->get_widget_derived("MarginsHeadHeight", mheadheightlengthentry_);
 258         xml_->get_widget_derived("MarginsFootSkip", mfootskiplengthentry_);
 259         // *** End "Margins" Page ***
 260
 261         // *** Start "Language" Page ***
 262         xml_->get_widget("Language", box);
 263         box->pack_start(languagecombo_, true, true, 0);
 264         box->show_all();
 265
 266         vector<LanguagePair> const langs = getLanguageData(false);
 267         vector<LanguagePair>::const_iterator lit  = langs.begin();
 268         vector<LanguagePair>::const_iterator lend = langs.end();
 269         for (; lit != lend; ++lit) {
 270                 languagecombo_.append_text(lit->first);
 271         }
 272
 273         xml_->get_widget("TextEncoding", box);
 274         box->pack_start(encodingcombo_, true, true, 0);
 275         box->show_all();
 276
 277         int i = 0;
 278         while (encodings[i])
 279                 encodingcombo_.append_text(encodings[i++]);
 280
 281         xml_->get_widget("EnglishQuote", qenglishradio_);
 282         xml_->get_widget("SwedishQuote", qswedishradio_);
 283         xml_->get_widget("GermanQuote", qgermanradio_);
 284         xml_->get_widget("PolishQuote", qpolishradio_);
 285         xml_->get_widget("FrenchQuote", qfrenchradio_);
 286         xml_->get_widget("DanishQuote", qdanishradio_);
 287         // *** End "Language" Page ***
 288
 289         // *** Start "Numbering" Page ***
 290         Gtk::HScale * scale;
 291         xml_->get_widget("Numbering", scale);
 292         numberingadj_ = scale->get_adjustment();
 293         numberingadj_->signal_value_changed().connect(
 294                 sigc::mem_fun(*this, &GDocument::numberingChanged));
 295         xml_->get_widget("NumberingLabel", numberinglabel_);
 296
 297         xml_->get_widget("TOC", scale);
 298         TOCadj_ = scale->get_adjustment();
 299         TOCadj_->signal_value_changed().connect(
 300                 sigc::mem_fun(*this, &GDocument::TOCChanged));
 301         xml_->get_widget("TOCLabel", TOClabel_);
 302         // *** End "Numbering" Page ***
 303
 304         // *** Start "Bibliography" Page ***
 305         xml_->get_widget("BasicNumerical", basicnumericalradio_);
 306         xml_->get_widget("NatbibNumerical", natbibnumericalradio_);
 307         xml_->get_widget("NatbibAuthorYear", natbibauthoryearradio_);
 308         xml_->get_widget("Jurabib", jurabibradio_);
 309         xml_->get_widget("SectionedBibliography", sectionedbibliographytoggle_);
 310         // *** End "Bibliography" Page ***
 311
 312         // *** Start "Math" Page ***
 313         xml_->get_widget("AMSAutomatically", AMSautomaticallyradio_);
 314         xml_->get_widget("AMSAlways", AMSalwaysradio_);
 315         xml_->get_widget("AMSNever", AMSneverradio_);
 316         // *** End "Math" Page ***
 317
 318         // *** Start "Floats" Page ***
 319         xml_->get_widget("DocumentDefault", defaultradio_);
 320         xml_->get_widget("HereDefinitely", heredefinitelyradio_);
 321         xml_->get_widget("Alternative", alternativeradio_);
 322         alternativeradio_->signal_toggled().connect(
 323                 sigc::mem_fun(*this, &GDocument::alternativeChanged));
 324         xml_->get_widget("TopOfPage", topcheck_);
 325         xml_->get_widget("BottomOfPage", bottomcheck_);
 326         xml_->get_widget("PageOfFloats", pageoffloatscheck_);
 327         xml_->get_widget("HereIfPossible", hereifpossiblecheck_);
 328         xml_->get_widget("IgnoreRules", ignorerulescheck_);
 329         // Initial sensitivity
 330         GDocument::alternativeChanged();
 331
 332         // *** End "Floats" Page ***
 333
 334         // *** Start "Bullets" Page ***
 335         // *** End "Bullets" Page ***
 336
 337         // *** Start "Branches" Page ***
 338         xml_->get_widget("Branches", branchesview_);
 339         xml_->get_widget("AddBranch", addbranchbutton_);
 340         addbranchbutton_->signal_clicked().connect(
 341                 sigc::mem_fun(*this, &GDocument::addBranch));
 342         xml_->get_widget("RemoveBranch", removebranchbutton_);
 343         removebranchbutton_->signal_clicked().connect(
 344                 sigc::mem_fun(*this, &GDocument::removeBranch));
 345         branchCols_.add(branchColName_);
 346         branchCols_.add(branchColActivated_);
 347         branchCols_.add(branchColColor_);
 348
 349         branchliststore_ = Gtk::ListStore::create(branchCols_);
 350         branchesview_->set_model(branchliststore_);
 351         branchesview_->append_column_editable(_("Name"), branchColName_);
 352         branchesview_->append_column_editable(_("Activated"), branchColActivated_);
 353         branchesview_->append_column_editable(_("Color"), branchColColor_);
 354         branchsel_ = branchesview_->get_selection();
 355
 356         branchsel_->signal_changed().connect(
 357                 sigc::mem_fun(*this, &GDocument::branchSelChanged));
 358
 359         /*
 360         ErrorList::const_iterator cit = errors.begin();
 361         ErrorList::const_iterator end = errors.end();
 362         for (int rowindex = 0; cit != end; ++cit, ++rowindex) {
 363                 Gtk::ListStore::Row row = *errliststore_->append();
 364                 if (rowindex == 0)
 365                         errlistsel_->select(*row);
 366
 367                 (*row)[listCol_] = cit->error;
 368                 (*row)[listColIndex_] = rowindex;
 369         }
 370         */
 371         Gtk::ListStore::Row row = *branchliststore_->append();
 372         (*row)[branchColName_] = "Munch";
 373         (*row)[branchColActivated_] = false;
 374         row = *branchliststore_->append();
 375         (*row)[branchColName_] = "Hunch";
 376         (*row)[branchColActivated_] = true;
 377         // *** End "Branches" Page ***
 378
 379         // *** Begin "Preamble" Page ***
 380         Gtk::TextView *view;
 381         xml_->get_widget ("Preamble", view);
 382         preamblebuffer_ = view->get_buffer();
 383         // *** End "Preamble" Page ***
 384 }
 385
 386
 387 void GDocument::update()
 388 {
 389         BufferParams & params = controller().params();
 390
 391         // *** Start "Document" Page ***
 392
 393         // Document Class
 394         classcombo_.set_active(params.textclass);
 395
 396         // Extra Options
 397         extraoptionsentry_->set_text(params.options);
 398
 399         // Postscript driver
 400         psdrivercombo_.set_active_text (params.graphicsDriver);
 401
 402         // Font & Size
 403         int i = findToken(tex_fonts_sans, params.fontsSans);
 404         if (i >= 0)
 405                 fontsanscombo_.set_active_text(_(tex_fonts_sans_gui[i]));
 406         i = findToken(tex_fonts_sans, params.fontsRoman);
 407         if (i >= 0)
 408                 fontromancombo_.set_active_text(_(tex_fonts_roman_gui[i]));
 409         i = findToken(tex_fonts_monospaced, params.fontsTypewriter);
 410         if (i >= 0)
 411                 fonttypewritercombo_.set_active_text(tex_fonts_monospaced_gui[i]);
 412         i = findToken(ControlDocument::fontfamilies, params.fontsDefaultFamily);
 413         if (i >= 0)
 414                 fontdefaultfamilycombo_.set_active_text(
 415                                 _(ControlDocument::fontfamilies_gui[i]));
 416         fontsizecombo_.set_active_text (params.fontsize);
 417         scaleSansSB_->set_value(params.fontsSansScale);
 418         scaleTypewriterSB_->set_value(params.fontsTypewriterScale);
 419         fontScCB_->set_active(params.fontsSC);
 420         fontOsfCB_->set_active(params.fontsOSF);
 421
 422         // Line Spacing
 423         linespacingadj_->set_value(params.spacing().getValue());
 424
 425         // Paragraph Separation
 426         if (params.paragraph_separation == BufferParams::PARSEP_INDENT) {
 427                 indentradio_->set_active(true);
 428         } else {
 429                 vspaceradio_->set_active(true);
 430         }
 431
 432         // Paragraph Separation Vertical Space Size
 433         VSpace::vspace_kind const skipkind = params.getDefSkip().kind();
 434         for (int i = 0; i <= 3; ++i) {
 435                 if (vspacesizemap_[i] == skipkind)
 436                         vspacesizecombo_.set_active(i);
 437         }
 438
 439         LyXLength vspacelen = params.getDefSkip().length().len();
 440         vspacelengthentry_->set_length (vspacelen);
 441
 442         // *** End "Document" Page ***
 443
 444         // *** Begin "Page" Page ***
 445         int const psize = params.papersize;
 446         pagesizecombo_.set_active(psize);
 447
 448         pagewidthlengthentry_->set_length(LyXLength(params.paperwidth));
 449         pageheightlengthentry_->set_length(LyXLength(params.paperheight));
 450
 451         if (params.orientation == ORIENTATION_PORTRAIT)
 452                 portraitradio_->set_active();
 453         else
 454                 landscaperadio_->set_active();
 455
 456         if (params.columns == 2)
 457                 twocolumnstoggle_->set_active(true);
 458         else
 459                 twocolumnstoggle_->set_active(false);
 460
 461         doublesidedtoggle_->set_active(params.sides == LyXTextClass::TwoSides);
 462
 463         pagestylecombo_.set_active_text (params.pagestyle);
 464         // *** End "Page" Page ***
 465
 466         defaultmargins_->set_active(!params.use_geometry);
 467
 468         mtoplengthentry_->set_length(params.topmargin);
 469         mbottomlengthentry_->set_length(params.bottommargin);
 470         minnerlengthentry_->set_length(params.leftmargin);
 471         mouterlengthentry_->set_length(params.rightmargin);
 472         mheadseplengthentry_->set_length(params.headsep);
 473         mheadheightlengthentry_->set_length(params.headheight);
 474         mfootskiplengthentry_->set_length(params.footskip);
 475
 476         marginsChanged();
 477         // *** End "Margins" Page ***
 478
 479         // *** Start "Language" Page ***
 480         int const langpos = findPos(lang_,
 481                 params.language->lang());
 482         languagecombo_.set_active(langpos);
 483
 484         // Default to "auto"
 485         encodingcombo_.set_active(0);
 486         if (params.inputenc == "default") {
 487                 encodingcombo_.set_active(1);
 488         } else {
 489                 int i = 0;
 490                 while (encodings[i]) {
 491                         if (encodings[i] == params.inputenc)
 492                                 encodingcombo_.set_active(i);
 493                         ++i;
 494                 }
 495         }
 496
 497         switch (params.quotes_language) {
 498         case InsetQuotes::EnglishQ:
 499                 qenglishradio_->set_active();
 500                 break;
 501         case InsetQuotes::SwedishQ:
 502                 qswedishradio_->set_active();
 503                 break;
 504         case InsetQuotes::GermanQ:
 505                 qgermanradio_->set_active();
 506                 break;
 507         case InsetQuotes::PolishQ:
 508                 qpolishradio_->set_active();
 509                 break;
 510         case InsetQuotes::FrenchQ:
 511                 qfrenchradio_->set_active();
 512                 break;
 513         case InsetQuotes::DanishQ:
 514                 qdanishradio_->set_active();
 515                 break;
 516         }
 517
 518         // *** End "Language" Page ***
 519
 520         // *** Start "Numbering" Page ***
 521         numberingadj_->set_value(params.secnumdepth + 2);
 522         TOCadj_->set_value(params.tocdepth + 1);
 523         // *** End "Numbering" Page ***
 524
 525         // *** Start "Bibliography" Page ***
 526         switch (params.cite_engine) {
 527         case biblio::ENGINE_BASIC:
 528                 basicnumericalradio_->set_active();
 529                 break;
 530         case biblio::ENGINE_NATBIB_NUMERICAL:
 531                 natbibnumericalradio_->set_active();
 532                 break;
 533         case biblio::ENGINE_NATBIB_AUTHORYEAR:
 534                 natbibauthoryearradio_->set_active();
 535                 break;
 536         case biblio::ENGINE_JURABIB:
 537                 jurabibradio_->set_active();
 538                 break;
 539         }
 540
 541         sectionedbibliographytoggle_->set_active(params.use_bibtopic);
 542         // *** End "Bibliography" Page ***
 543
 544         // *** Start "Math" Page ***
 545         switch (params.use_amsmath) {
 546         case BufferParams::AMS_AUTO:
 547                 AMSautomaticallyradio_->set_active();
 548                 break;
 549         case BufferParams::AMS_ON:
 550                 AMSalwaysradio_->set_active();
 551                 break;
 552         case BufferParams::AMS_OFF:
 553                 AMSneverradio_->set_active();
 554                 break;
 555         }
 556         // *** End "Math" Page ***
 557
 558         // *** Start "Floats" Page ***
 559         string const placement = params.float_placement;
 560         bool const here_definitely = contains(placement, 'H');
 561         bool const top    = contains(placement, 't');
 562         bool const bottom = contains(placement, 'b');
 563         bool const page   = contains(placement, 'p');
 564         bool const here   = contains(placement, 'h');
 565         bool const force  = contains(placement, '!');
 566         bool const alternatives = top || bottom || page || here;
 567
 568         if (alternatives) {
 569                 alternativeradio_->set_active(true);
 570         } else if (here_definitely) {
 571                 heredefinitelyradio_->set_active(true);
 572         } else {
 573                 defaultradio_->set_active(true);
 574         }
 575         ignorerulescheck_->set_active(force);
 576         topcheck_->set_active(top);
 577         bottomcheck_->set_active(bottom);
 578         pageoffloatscheck_->set_active(page);
 579         hereifpossiblecheck_->set_active(here);
 580
 581         // *** End "Floats" Page ***
 582
 583         // *** Start "Bullets" Page ***
 584         // *** End "Bullets" Page ***
 585
 586         // *** Start "Branches" Page ***
 587         branchliststore_->clear();
 588
 589         BranchList::const_iterator it = params.branchlist().begin();
 590         BranchList::const_iterator const end = params.branchlist().end();
 591         for (; it != end; ++it) {
 592                 Gtk::ListStore::Row row = *branchliststore_->append();
 593                 (*row)[branchColName_] = (*it).getBranch();
 594                 std::cerr << "update: loading '" << (*it).getBranch() << "'\n";
 595                 (*row)[branchColActivated_] = (*it).getSelected();
 596                 (*row)[branchColColor_] = X11hexname((*it).getColor());
 597         }
 598         // *** End "Branches" Page ***
 599
 600         // *** Begin "Preamble" Page ***
 601         preamblebuffer_->set_text(params.preamble);
 602         // *** End "Preamble" Page ***
 603
 604         // Be a cheesy bastard, for the moment
 605         bc().valid();
 606 }
 607
 608
 609 void GDocument::apply()
 610 {
 611         BufferParams & params = controller().params();
 612
 613         // *** Start "Document" Page ***
 614
 615         // Document Class
 616         params.textclass = classcombo_.get_active_row_number();
 617
 618         // Extra Options
 619         params.options = extraoptionsentry_->get_text();
 620
 621         // Postscript Driver
 622         params.graphicsDriver = psdrivercombo_.get_active_text();
 623
 624         // Font & Size
 625         params.fontsSans = tex_fonts_sans[fontsanscombo_.get_active_row_number()];
 626         params.fontsRoman = tex_fonts_roman[fontromancombo_.get_active_row_number()];
 627         params.fontsTypewriter = tex_fonts_monospaced[fonttypewritercombo_.get_active_row_number()];
 628         params.fontsDefaultFamily =
 629                 ControlDocument::fontfamilies[fontdefaultfamilycombo_.get_active_row_number()];
 630         params.fontsize = fontsizecombo_.get_active_text();
 631         params.fontsSansScale = int(scaleSansSB_->get_adjustment()->get_value());
 632         params.fontsTypewriterScale = int(scaleTypewriterSB_->get_adjustment()->get_value());
 633         params.fontsSC = fontScCB_->get_active();
 634         params.fontsOSF = fontOsfCB_->get_active();
 635
 636         // Line Spacing
 637         params.spacing().set(Spacing::Other, linespacingadj_->get_value());
 638
 639         // Paragraph Separation
 640         if (indentradio_->get_active()) {
 641                 params.paragraph_separation = BufferParams::PARSEP_INDENT;
 642         } else {
 643                 params.paragraph_separation = BufferParams::PARSEP_SKIP;
 644         }
 645
 646         // Paragraph Separation Vertical Space Size
 647         VSpace::vspace_kind const selection =
 648                 vspacesizemap_[vspacesizecombo_.get_active_row_number()];
 649         params.setDefSkip(VSpace(selection));
 650         if (selection == VSpace::LENGTH) {
 651                 LyXLength length = vspacelengthentry_->get_length();
 652                 params.setDefSkip(VSpace(LyXGlueLength(length)));
 653         }
 654
 655         // *** End "Document" Page ***
 656
 657         // *** Begin "Page" Page ***
 658         params.papersize = PAPER_SIZE(
 659                 pagesizecombo_.get_active_row_number());
 660
 661         params.paperwidth = pagewidthlengthentry_->get_length_string();
 662         params.paperheight = pageheightlengthentry_->get_length_string();
 663
 664         if (portraitradio_->get_active())
 665                 params.orientation = ORIENTATION_PORTRAIT;
 666         else
 667                 params.orientation = ORIENTATION_LANDSCAPE;
 668
 669         if (twocolumnstoggle_->get_active())
 670                 params.columns = 2;
 671         else
 672                 params.columns = 1;
 673
 674         if (doublesidedtoggle_->get_active())
 675                 params.sides = LyXTextClass::TwoSides;
 676         else
 677                 params.sides = LyXTextClass::OneSide;
 678
 679         params.pagestyle = pagestylecombo_.get_active_text();
 680         // *** End "Page" Page ***
 681
 682         // *** Begin "Margins" Page ***
 683         params.use_geometry = !defaultmargins_->get_active();
 684
 685         params.topmargin = mtoplengthentry_->get_length_string();
 686         params.bottommargin = mbottomlengthentry_->get_length_string();
 687         params.leftmargin = minnerlengthentry_->get_length_string();
 688         params.rightmargin = mouterlengthentry_->get_length_string();
 689         params.headsep = mheadseplengthentry_->get_length_string();
 690         params.headheight = mheadheightlengthentry_->get_length_string();
 691         params.footskip = mfootskiplengthentry_->get_length_string();
 692         // *** End "Margins" Page ***
 693
 694         // *** Start "Language" Page ***
 695         int const encodingsel = encodingcombo_.get_active_row_number();
 696         if (encodingsel == 0)
 697                 params.inputenc = "auto";
 698         else if (encodingsel == 1)
 699                 params.inputenc = "default";
 700         else
 701                 params.inputenc = encodings[encodingsel];
 702
 703         int const langsel = languagecombo_.get_active_row_number();
 704         params.language = languages.getLanguage(lang_[langsel]);
 705
 706         if (qenglishradio_->get_active())
 707                 params.quotes_language = InsetQuotes::EnglishQ;
 708         else if (qswedishradio_->get_active())
 709                 params.quotes_language = InsetQuotes::SwedishQ;
 710         else if (qgermanradio_->get_active())
 711                 params.quotes_language = InsetQuotes::GermanQ;
 712         else if (qpolishradio_->get_active())
 713                 params.quotes_language = InsetQuotes::PolishQ;
 714         else if (qfrenchradio_->get_active())
 715                 params.quotes_language = InsetQuotes::FrenchQ;
 716         else if (qdanishradio_->get_active())
 717                 params.quotes_language = InsetQuotes::DanishQ;
 718         // *** End "Language" Page ***
 719
 720         // *** Start "Numbering" Page ***
 721         params.secnumdepth = (int)(numberingadj_->get_value()) - 2;
 722         params.tocdepth = (int)(TOCadj_->get_value()) - 1;
 723         // *** End "Numbering" Page ***
 724
 725         // *** Start "Bibliography" Page ***
 726         if (basicnumericalradio_->get_active())
 727                 params.cite_engine = biblio::ENGINE_BASIC;
 728         else if (natbibnumericalradio_->get_active())
 729                 params.cite_engine = biblio::ENGINE_NATBIB_NUMERICAL;
 730         else if (natbibauthoryearradio_->get_active())
 731                 params.cite_engine = biblio::ENGINE_NATBIB_AUTHORYEAR;
 732         else if (jurabibradio_->get_active())
 733                 params.cite_engine = biblio::ENGINE_JURABIB;
 734
 735         params.use_bibtopic = sectionedbibliographytoggle_->get_active();
 736         // *** End "Bibliography" Page ***
 737
 738         // *** Start "Math" Page ***
 739         if (AMSautomaticallyradio_->get_active())
 740                 params.use_amsmath = BufferParams::AMS_AUTO;
 741         else if (AMSalwaysradio_->get_active())
 742                 params.use_amsmath = BufferParams::AMS_ON;
 743         else if (AMSneverradio_->get_active())
 744                 params.use_amsmath = BufferParams::AMS_OFF;
 745         // *** End "Math" Page ***
 746
 747         // *** Start "Floats" Page ***
 748         string placement;
 749         if (alternativeradio_->get_active()) {
 750                 if (ignorerulescheck_->get_active())
 751                         placement += '!';
 752                 if (topcheck_->get_active())
 753                         placement += 't';
 754                 if (bottomcheck_->get_active())
 755                         placement += 'b';
 756                 if (pageoffloatscheck_->get_active())
 757                         placement += 'p';
 758                 if (hereifpossiblecheck_->get_active())
 759                         placement += 'h';
 760                 if (placement == "!")
 761                         placement.erase();
 762         } else if (heredefinitelyradio_->get_active())
 763                 placement = "H";
 764
 765         params.float_placement = placement;
 766         // *** End "Floats" Page ***
 767
 768         // *** Start "Bullets" Page ***
 769         // *** End "Bullets" Page ***
 770
 771         // *** Start "Branches" Page ***
 772         /*branchliststore_->clear();
 773
 774         BranchList::const_iterator it = params.branchlist().begin();
 775         BranchList::const_iterator const end = params.branchlist().end();
 776         for (; it != end; ++it) {
 777                 Gtk::ListStore::Row row = *branchliststore_->append();
 778                 (*row)[branchColName_] = (*it).getBranch();
 779                 (*row)[branchColActivated_] = (*it).getSelected();
 780                 (*row)[branchColColor_] = (*it).getColor();
 781         }*/
 782
 783         BranchList branchlist;
 784
 785         Gtk::ListStore::iterator it = branchliststore_->children().begin();
 786         Gtk::ListStore::iterator const end = branchliststore_->children().end();
 787         for (; it != end; ++it) {
 788                 Gtk::ListStore::Row row = *it;
 789                 Glib::ustring const name = (*row)[branchColName_];
 790                 if (branchlist.add(name)) {
 791                         std::cerr << "apply: adding '" << name << "'\n";
 792                         Branch * newbranch = branchlist.find(name);
 793                         newbranch->setSelected((*row)[branchColActivated_]);
 794                         Glib::ustring const color = (*row)[branchColColor_];
 795                         // FIXME: The color should be editable via a color
 796                         // chooser, not a text field (see qt frontends)
 797                         // setColor will silently ignore an invalid color and
 798                         // use the normal background color for now.
 799                         newbranch->setColor(color);
 800                 }
 801         }
 802
 803         params.branchlist() = branchlist;
 804
 805         // *** End "Branches" Page ***
 806
 807         // *** Begin "Preamble" Page ***
 808         params.preamble = preamblebuffer_->get_text();
 809         // *** End "Preamble" Page ***
 810 }
 811
 812
 813 void GDocument::saveAsDefaults()
 814 {
 815         apply();
 816         controller().saveAsDefault();
 817 }
 818
 819
 820 void GDocument::resetToDefaults()
 821 {
 822         BufferParams & params = controller().params();
 823         params.textclass = classcombo_.get_active_row_number();
 824         params.useClassDefaults();
 825         update();
 826 }
 827
 828
 829 void GDocument::updateParagraphSeparationSensitivity()
 830 {
 831         bool const vspacesensitive = vspaceradio_->get_active();
 832
 833         vspacesizecombo_.set_sensitive(vspacesensitive);
 834
 835         bool const lengthsensitive = vspacesensitive &&
 836                 (vspacesizecombo_.get_active_row_number() == 3);
 837
 838         vspacelengthentry_->set_sensitive(lengthsensitive);
 839 }
 840
 841
 842 void GDocument::classChanged()
 843 {
 844         ControlDocument & ctrl = controller();
 845         BufferParams & params = ctrl.params();
 846
 847         lyx::textclass_type const tc = classcombo_.get_active_row_number();
 848
 849         if (ctrl.loadTextclass(tc)) {
 850                 params.textclass = tc;
 851
 852                 if (lyxrc.auto_reset_options) {
 853                         params.useClassDefaults();
 854                         update();
 855                 } else {
 856                         fontsizecombo_.clear();
 857                         fontsizecombo_.append_text("default");
 858
 859                         string const fontsizeitems = ctrl.textClass().opt_fontsize();
 860                         for (int n = 0; !token(fontsizeitems, '|', n).empty(); ++n)
 861                                 fontsizecombo_.append_text(token(fontsizeitems, '|', n));
 862
 863                         fontsizecombo_.set_active_text (params.fontsize);
 864
 865                         pagestylecombo_.clear();
 866                         pagestylecombo_.append_text("default");
 867
 868                         string const pagestyleitems = ctrl.textClass().opt_pagestyle();
 869                         for (int n=0; !token(pagestyleitems,'|',n).empty(); ++n)
 870                                 pagestylecombo_.append_text(token(pagestyleitems,'|',n));
 871
 872                         pagestylecombo_.set_active_text (params.pagestyle);
 873                 }
 874         } else {
 875                 classcombo_.set_active(params.textclass);
 876         }
 877 }
 878
 879
 880 void GDocument::pageSizeChanged()
 881 {
 882         bool const customsize = pagesizecombo_.get_active_row_number() == 1;
 883         pagewidthlengthentry_->set_sensitive(customsize);
 884         pageheightlengthentry_->set_sensitive(customsize);
 885
 886         if (customsize)
 887                 portraitradio_->set_active();
 888 }
 889
 890
 891 void GDocument::marginsChanged()
 892 {
 893         bool const custom = !defaultmargins_->get_active();
 894
 895         mtoplengthentry_->set_sensitive(custom);
 896         mbottomlengthentry_->set_sensitive(custom);
 897         minnerlengthentry_->set_sensitive(custom);
 898         mouterlengthentry_->set_sensitive(custom);
 899         mheadseplengthentry_->set_sensitive(custom);
 900         mheadheightlengthentry_->set_sensitive(custom);
 901         mfootskiplengthentry_->set_sensitive(custom);
 902 }
 903
 904
 905 void GDocument::numberingChanged()
 906 {
 907         string const numberinglabels[] = {
 908                 _("No headings numbered"),
 909                 _("Only parts numbered"),
 910                 _("Chapters and above numbered"),
 911                 _("Sections and above numbered"),
 912                 _("Subsections and above numbered"),
 913                 _("Subsubsections and above numbered"),
 914                 _("Paragraphs and above numbered"),
 915                 _("All headings numbered")
 916         };
 917
 918         int const value = (int)(numberingadj_->get_value());
 919         numberinglabel_->set_label("<i>" + numberinglabels[value] + "</i>");
 920 }
 921
 922
 923 void GDocument::TOCChanged()
 924 {
 925         string const TOClabels[] = {
 926                 _("Only Parts appear in TOC"),
 927                 _("Chapters and above appear in TOC"),
 928                 _("Sections and above appear in TOC"),
 929                 _("Subsections and above appear in TOC"),
 930                 _("Subsubsections and above appear in TOC"),
 931                 _("Paragraphs and above appear in TOC"),
 932                 _("TOC contains all headings")
 933         };
 934
 935         int const value = (int)(TOCadj_->get_value());
 936         TOClabel_->set_label("<i>" + TOClabels[value] + "</i>");
 937 }
 938
 939
 940 void GDocument::alternativeChanged()
 941 {
 942         bool const sens = alternativeradio_->get_active();
 943         topcheck_->set_sensitive(sens);
 944         bottomcheck_->set_sensitive(sens);
 945         pageoffloatscheck_->set_sensitive(sens);
 946         hereifpossiblecheck_->set_sensitive(sens);
 947         ignorerulescheck_->set_sensitive(sens);
 948 }
 949
 950
 951 void GDocument::addBranch()
 952 {
 953         Gtk::ListStore::Row row = *branchliststore_->append();
 954         (*row)[branchColName_] = "New Branch";
 955         (*row)[branchColActivated_] = false;
 956         (*row)[branchColColor_] = "#000000";
 957 }
 958
 959
 960 void GDocument::removeBranch()
 961 {
 962         Gtk::TreeModel::iterator const selected = branchsel_->get_selected();
 963         if (!branchliststore_->iter_is_valid(selected))
 964                 return;
 965
 966         branchliststore_->erase (selected);
 967 }
 968
 969
 970 void GDocument::branchSelChanged()
 971 {
 972         if (branchsel_->get_selected() == branchliststore_->children().end())
 973                 removebranchbutton_->set_sensitive(false);
 974         else
 975                 removebranchbutton_->set_sensitive(true);
 976 }
 977
 978 } // namespace frontend
 979 } // namespace lyx