src/frontends/kde/docdlg.C

   1 /**
   2  * \file docdlg.C
   3  * Copyright 2001 the LyX Team
   4  * Read the file COPYING
   5  *
   6  * \author John Levon
   7  */
   8
   9 #include <config.h>
  10
  11 #include <qtooltip.h>
  12
  13 #include "docdlg.h"
  14
  15 #include "support/lstrings.h"
  16
  17 #include "layout.h"
  18 #include "tex-strings.h"
  19 #include "bufferparams.h"
  20
  21 #include "dlg/helpers.h"
  22
  23 #include "language.h"
  24 #include "gettext.h"
  25 #include "debug.h"
  26
  27 using kde_helpers::setSizeHint;
  28 using kde_helpers::setComboFromStr;
  29 using std::endl;
  30
  31 DocDialog::DocDialog(FormDocument * form, QWidget * parent, char const * name, bool, WFlags)
  32         : DocDialogData(parent,name), form_(form)
  33 {
  34         setCaption(name);
  35
  36         setUpdatesEnabled(false);
  37
  38         settings = new DocSettingsDialogData(this, "settings");
  39         extra = new DocExtraDialogData(this, "extra");
  40         geometry = new DocGeometryDialogData(this, "geometry");
  41         language = new DocLanguageDialogData(this, "language");
  42         bullets = new DocBulletsDialogData(this, "bullets");
  43
  44         tabstack->addTabPage(settings, _("&Settings"));
  45         tabstack->addTabPage(extra, _("&Extra"));
  46         tabstack->addTabPage(geometry, _("&Geometry"));
  47         tabstack->addTabPage(language, _("&Language"));
  48         tabstack->addTabPage(bullets, _("&Bullets"));
  49
  50         // document classes
  51         for (LyXTextClassList::const_iterator cit = textclasslist.begin();
  52                 cit != textclasslist.end(); ++cit)
  53                 settings->combo_docclass->insertItem((*cit).description().c_str());
  54         setSizeHint(settings->combo_docclass);
  55
  56         settings->combo_pagestyle->insertItem(_("default"));
  57         settings->combo_pagestyle->insertItem(_("empty"));
  58         settings->combo_pagestyle->insertItem(_("plain"));
  59         settings->combo_pagestyle->insertItem(_("headings"));
  60         settings->combo_pagestyle->insertItem(_("fancy"));
  61         setSizeHint(settings->combo_pagestyle);
  62
  63         // available fonts
  64         for (int i=0; tex_fonts[i][0]; i++)
  65                 settings->combo_font->insertItem(tex_fonts[i]);
  66         setSizeHint(settings->combo_font);
  67
  68         settings->combo_fontsize->insertItem(_("default"));
  69         settings->combo_fontsize->insertItem(_("10 point"));
  70         settings->combo_fontsize->insertItem(_("11 point"));
  71         settings->combo_fontsize->insertItem(_("12 point"));
  72         setSizeHint(settings->combo_fontsize);
  73
  74         settings->combo_linespacing->insertItem(_("single"));
  75         settings->combo_linespacing->insertItem(_("1 1/2 spacing"));
  76         settings->combo_linespacing->insertItem(_("double"));
  77         settings->combo_linespacing->insertItem(_("custom"));
  78         setSizeHint(settings->combo_linespacing);
  79
  80         connect(settings->combo_linespacing, SIGNAL(highlighted(const char *)),
  81                 this, SLOT(linespacingChanged(const char *)));
  82
  83         settings->combo_paraspacing->insertItem(_("small"));
  84         settings->combo_paraspacing->insertItem(_("medium"));
  85         settings->combo_paraspacing->insertItem(_("big"));
  86         settings->combo_paraspacing->insertItem(_("custom"));
  87         setSizeHint(settings->combo_paraspacing);
  88
  89         connect(settings->combo_paraspacing, SIGNAL(highlighted(const char *)),
  90                 this, SLOT(paraspacingChanged(const char *)));
  91
  92         connect(settings->check_addspace, SIGNAL(toggled(bool)),
  93                 this, SLOT(addspaceChanged(bool)));
  94
  95         extra->combo_first->insertItem(_("Here"));
  96         extra->combo_first->insertItem(_("Bottom of page"));
  97         extra->combo_first->insertItem(_("Top of page"));
  98         extra->combo_first->insertItem(_("Separate page"));
  99         extra->combo_first->insertItem(_("Not set"));
 100         extra->combo_second->insertItem(_("Here"));
 101         extra->combo_second->insertItem(_("Bottom of page"));
 102         extra->combo_second->insertItem(_("Top of page"));
 103         extra->combo_second->insertItem(_("Separate page"));
 104         extra->combo_second->insertItem(_("Not set"));
 105         extra->combo_third->insertItem(_("Here"));
 106         extra->combo_third->insertItem(_("Bottom of page"));
 107         extra->combo_third->insertItem(_("Top of page"));
 108         extra->combo_third->insertItem(_("Separate page"));
 109         extra->combo_third->insertItem(_("Not set"));
 110         extra->combo_fourth->insertItem(_("Here"));
 111         extra->combo_fourth->insertItem(_("Bottom of page"));
 112         extra->combo_fourth->insertItem(_("Top of page"));
 113         extra->combo_fourth->insertItem(_("Separate page"));
 114         extra->combo_fourth->insertItem(_("Not set"));
 115
 116         // ps driver options
 117         for (int i = 0; tex_graphics[i][0]; i++)
 118                 extra->combo_psdriver->insertItem(tex_graphics[i]);
 119         setSizeHint(extra->combo_psdriver);
 120
 121         geometry->combo_papersize->insertItem(_("default"));
 122         geometry->combo_papersize->insertItem(_("US letter"));
 123         geometry->combo_papersize->insertItem(_("US legal"));
 124         geometry->combo_papersize->insertItem(_("US executive"));
 125         geometry->combo_papersize->insertItem("A3");
 126         geometry->combo_papersize->insertItem("A4");
 127         geometry->combo_papersize->insertItem("A5");
 128         geometry->combo_papersize->insertItem("B3");
 129         geometry->combo_papersize->insertItem("B4");
 130         geometry->combo_papersize->insertItem("B5");
 131         setSizeHint(geometry->combo_papersize);
 132
 133         geometry->combo_margins->insertItem(_("default"));
 134         geometry->combo_margins->insertItem(_("A4 small margins"));
 135         geometry->combo_margins->insertItem(_("A4 very small margins"));
 136         geometry->combo_margins->insertItem(_("A4 very wide margins"));
 137         setSizeHint(geometry->combo_margins);
 138
 139         for (Languages::const_iterator cit = languages.begin();
 140                 cit != languages.end(); ++cit)
 141                 language->combo_language->insertItem((*cit).second.lang().c_str());
 142         setSizeHint(language->combo_language);
 143
 144         language->combo_encoding->insertItem(_("default"));
 145         language->combo_encoding->insertItem(_("auto"));
 146         language->combo_encoding->insertItem(_("latin1"));
 147         language->combo_encoding->insertItem(_("latin2"));
 148         language->combo_encoding->insertItem(_("latin5"));
 149         language->combo_encoding->insertItem(_("latin9"));
 150         language->combo_encoding->insertItem(_("koi8-r"));
 151         language->combo_encoding->insertItem(_("koi8-u"));
 152         language->combo_encoding->insertItem(_("cp866"));
 153         language->combo_encoding->insertItem(_("cp1251"));
 154         language->combo_encoding->insertItem(_("iso88595"));
 155         setSizeHint(language->combo_encoding);
 156
 157         language->combo_quotes->insertItem(_("`text'"));
 158         language->combo_quotes->insertItem(_("``text''"));
 159         language->combo_quotes->insertItem(_("'text'"));
 160         language->combo_quotes->insertItem(_("''text''"));
 161         language->combo_quotes->insertItem(_(",text`"));
 162         language->combo_quotes->insertItem(_(",,text``"));
 163         language->combo_quotes->insertItem(_(",text'"));
 164         language->combo_quotes->insertItem(_(",,text''"));
 165         language->combo_quotes->insertItem(_("<text>"));
 166         language->combo_quotes->insertItem(_("«text»"));
 167         language->combo_quotes->insertItem(_(">text<"));
 168         language->combo_quotes->insertItem(_("»text«"));
 169         setSizeHint(language->combo_quotes);
 170
 171         /* FIXME: bullets */
 172
 173         QToolTip::add(settings->combo_pagestyle, _("Specify header + footer style etc"));
 174         QToolTip::add(settings->check_addspace, _("Add spacing between paragraphs rather\n than indenting"));
 175         QToolTip::add(settings->combo_linespacing, _("Custom line spacing in line units"));
 176         QToolTip::add(settings->line_extraoptions, _("Additional LaTeX options"));
 177         QToolTip::add(extra->combo_first, _("Specify preferred order for\nplacing floats"));
 178         QToolTip::add(extra->combo_second, _("Specify preferred order for\nplacing floats"));
 179         QToolTip::add(extra->combo_third, _("Specify preferred order for\nplacing floats"));
 180         QToolTip::add(extra->combo_fourth, _("Specify preferred order for\nplacing floats"));
 181         QToolTip::add(extra->check_ignore, _("Tell LaTeX to ignore usual rules\n for float placement"));
 182         QToolTip::add(extra->spin_sectiondepth, _("How far in the (sub)sections are numbered"));
 183         QToolTip::add(extra->spin_tocdepth, _("How detailed the Table of Contents is"));
 184         QToolTip::add(extra->combo_psdriver, _("Program to produce PostScript output"));
 185         QToolTip::add(extra->check_amsmath, _("FIXME please !"));
 186         QToolTip::add(geometry->length_headheight, _("FIXME please !"));
 187         QToolTip::add(geometry->length_headsep, _("FIXME please !"));
 188         QToolTip::add(geometry->length_footskip, _("FIXME please !"));
 189
 190         setUpdatesEnabled(true);
 191         update();
 192 }
 193
 194
 195 DocDialog::~DocDialog()
 196 {
 197 }
 198
 199
 200 void DocDialog::closeEvent(QCloseEvent * e)
 201 {
 202         form_->close();
 203         e->accept();
 204 }
 205
 206
 207 void DocDialog::setReadOnly(bool readonly)
 208 {
 209         /* FIXME */
 210         button_cancel->setText(readonly ? _("&Close") : _("&Cancel"));
 211 }
 212
 213
 214 void DocDialog::setFromParams(BufferParams const & params)
 215 {
 216         setUpdatesEnabled(false);
 217
 218         if (!setComboFromStr(settings->combo_docclass, textclasslist.DescOfClass(params.textclass)))
 219                 lyxerr[Debug::GUI] << "Couldn't set docclass " << textclasslist.DescOfClass(params.textclass) << endl;
 220
 221         if (!setComboFromStr(settings->combo_font, params.fonts))
 222                 lyxerr[Debug::GUI] << "Couldn't set font " << params.fonts << endl;
 223
 224         LyXTextClass const & tclass = textclasslist.TextClass(params.textclass);
 225
 226         // opt_fontsize is a string like "10|11|12"
 227         settings->combo_fontsize->setCurrentItem(tokenPos(tclass.opt_fontsize(), '|', params.fontsize) + 1);
 228
 229         // "empty|plain|headings|fancy"
 230         settings->combo_pagestyle->setCurrentItem(tokenPos(tclass.opt_pagestyle(), '|', params.pagestyle) + 1);
 231
 232         settings->check_addspace->setChecked(params.paragraph_separation == BufferParams::PARSEP_SKIP);
 233
 234         bool const isskip = (params.paragraph_separation == BufferParams::PARSEP_SKIP);
 235
 236         settings->combo_paraspacing->setEnabled(isskip);
 237         settings->length_paraspacing->setEnabled(isskip);
 238         settings->length_paraspacingstretch->setEnabled(isskip);
 239         settings->length_paraspacingshrink->setEnabled(isskip);
 240
 241         int item=0;
 242
 243         switch (params.getDefSkip().kind()) {
 244                 case VSpace::SMALLSKIP: item = 0; break;
 245                 case VSpace::MEDSKIP: item = 1; break;
 246                 case VSpace::BIGSKIP: item = 2; break;
 247                 case VSpace::LENGTH: item = 3; break;
 248                 default:
 249                         lyxerr[Debug::GUI] << "Unknown defskip " << int(params.getDefSkip().kind()) << endl;
 250         }
 251
 252         settings->combo_paraspacing->setCurrentItem(item);
 253
 254         settings->length_paraspacing->setEnabled(item == 3);
 255         settings->length_paraspacingstretch->setEnabled(item == 3);
 256         settings->length_paraspacingshrink->setEnabled(item == 3);
 257
 258         if (item == 3) {
 259                 LyXGlueLength const len = params.getDefSkip().length();
 260                 settings->length_paraspacing->setValue(len.value());
 261                 settings->length_paraspacing->setUnits(len.unit());
 262                 settings->length_paraspacingstretch->setValue(len.plusValue());
 263                 settings->length_paraspacingstretch->setUnits(len.plusUnit());
 264                 settings->length_paraspacingshrink->setValue(len.minusValue());
 265                 settings->length_paraspacingshrink->setUnits(len.minusUnit());
 266                 lyxerr[Debug::GUI] << params.getDefSkip().asLyXCommand() << endl;;
 267         } else {
 268                 settings->length_paraspacing->setFromLengthStr("0cm");
 269                 settings->length_paraspacingstretch->setFromLengthStr("0cm");
 270                 settings->length_paraspacingshrink->setFromLengthStr("0cm");
 271         }
 272
 273         settings->check_sides->setChecked(params.sides == LyXTextClass::TwoSides);
 274         settings->check_columns->setChecked(params.columns == 2);
 275
 276         switch (params.spacing.getSpace()) {
 277                 case Spacing::Default:
 278                 case Spacing::Single: item = 0; break;
 279                 case Spacing::Onehalf: item = 1; break;
 280                 case Spacing::Double: item = 2; break;
 281                 case Spacing::Other: item = 3; break;
 282                 default:
 283                         lyxerr[Debug::GUI] << "Unknown line spacing " << int(params.spacing.getSpace()) << endl;
 284         }
 285
 286         settings->combo_linespacing->setCurrentItem(item);
 287         settings->line_linespacing->setEnabled(item == 3);
 288
 289         if (item == 3)
 290                 settings->line_linespacing->setText(tostr(params.spacing.getValue()).c_str());
 291         else
 292                 settings->line_linespacing->setText("");
 293
 294         if (params.options.empty())
 295                 settings->line_extraoptions->setText("");
 296         else
 297                 settings->line_extraoptions->setText(params.options.c_str());
 298
 299         // geometry page
 300
 301         geometry->combo_papersize->setCurrentItem(params.papersize2);
 302
 303         geometry->combo_margins->setCurrentItem(params.paperpackage);
 304
 305         geometry->radio_portrait->setChecked(params.orientation == BufferParams::ORIENTATION_PORTRAIT);
 306         geometry->radio_landscape->setChecked(params.orientation != BufferParams::ORIENTATION_PORTRAIT);
 307
 308         geometry->length_width->setFromLengthStr(params.paperwidth);
 309         geometry->length_height->setFromLengthStr(params.paperheight);
 310         geometry->length_left->setFromLengthStr(params.leftmargin);
 311         geometry->length_right->setFromLengthStr(params.rightmargin);
 312         geometry->length_top->setFromLengthStr(params.topmargin);
 313         geometry->length_bottom->setFromLengthStr(params.bottommargin);
 314         geometry->length_headheight->setFromLengthStr(params.headheight);
 315         geometry->length_headsep->setFromLengthStr(params.headsep);
 316         geometry->length_footskip->setFromLengthStr(params.footskip);
 317
 318         // language page
 319
 320         if (!setComboFromStr(language->combo_language, params.language->lang()))
 321                 lyxerr[Debug::GUI] << "Couldn't set language " << params.language->lang() << endl;
 322
 323         if (!setComboFromStr(language->combo_encoding, params.inputenc))
 324                 lyxerr[Debug::GUI] << "Couldn't set encoding " << params.inputenc << endl;
 325
 326         switch (params.quotes_language) {
 327                 case InsetQuotes::EnglishQ: item = 0; break;
 328                 case InsetQuotes::SwedishQ: item = 2; break;
 329                 case InsetQuotes::GermanQ: item = 4; break;
 330                 case InsetQuotes::PolishQ: item = 6; break;
 331                 case InsetQuotes::FrenchQ: item = 8; break;
 332                 case InsetQuotes::DanishQ: item = 10; break;
 333                 default:
 334                         lyxerr[Debug::GUI] << "Unknown quote style " << int(params.quotes_language) << endl;
 335         }
 336
 337         if (params.quotes_times == InsetQuotes::DoubleQ)
 338                 item++;
 339
 340         language->combo_quotes->setCurrentItem(item);
 341
 342         // extra page
 343
 344         if (!setComboFromStr(extra->combo_psdriver, params.graphicsDriver))
 345                 lyxerr[Debug::GUI] << "Couldn't set psdriver " << params.graphicsDriver << endl;
 346
 347         extra->check_amsmath->setChecked(params.use_amsmath);
 348         extra->spin_sectiondepth->setValue(params.secnumdepth);
 349         extra->spin_tocdepth->setValue(params.tocdepth);
 350
 351         string const place = params.float_placement;
 352         int count = 0;
 353         QComboBox * box;
 354
 355         extra->check_ignore->setChecked(false);
 356         setComboFromStr(extra->combo_first, _("Not set"));
 357         setComboFromStr(extra->combo_second, _("Not set"));
 358         setComboFromStr(extra->combo_third, _("Not set"));
 359         setComboFromStr(extra->combo_fourth, _("Not set"));
 360
 361         for (string::const_iterator iter = place.begin(); iter != place.end(); ++count, ++iter) {
 362                 switch (count) {
 363                         case 0: box = extra->combo_first; break;
 364                         case 1: box = extra->combo_second; break;
 365                         case 2: box = extra->combo_third; break;
 366                         default: box = extra->combo_fourth; break;
 367                 };
 368
 369                 if (*iter == '!') {
 370                         extra->check_ignore->setChecked(true);
 371                         continue;
 372                 }
 373
 374                 switch (*iter) {
 375                         case 'h': setComboFromStr(box, _("Here")); break;
 376                         case 'b': setComboFromStr(box, _("Bottom of page")); break;
 377                         case 't': setComboFromStr(box, _("Top of page")); break;
 378                         case 'p': setComboFromStr(box, _("Separate page")); break;
 379                         default:
 380                                 lyxerr[Debug::GUI] << "Unknown float placement \'" << *iter << endl;
 381                 }
 382         }
 383
 384         /* FIXME: bullets ! */
 385
 386         setUpdatesEnabled(true);
 387         update();
 388 }
 389
 390
 391 bool DocDialog::updateParams(BufferParams & params)
 392 {
 393         bool redo = false;
 394
 395         params.fonts = string(settings->combo_font->currentText());
 396         LyXTextClass const & tclass = textclasslist.TextClass(params.textclass);
 397         params.fontsize = token(tclass.opt_fontsize(), '|', settings->combo_fontsize->currentItem() - 1);
 398         params.pagestyle = token(tclass.opt_pagestyle(), '|', settings->combo_pagestyle->currentItem() - 1);
 399
 400         // set and update class
 401
 402         unsigned int const new_class = settings->combo_docclass->currentItem();
 403
 404         if (new_class != params.textclass) {
 405                 if (!form_->changeClass(params, new_class)) {
 406                         // FIXME: error msg
 407                         // restore old class
 408                         if (!setComboFromStr(settings->combo_docclass, textclasslist.DescOfClass(params.textclass)))
 409                                 lyxerr[Debug::GUI] << "Couldn't set docclass " << textclasslist.DescOfClass(params.textclass) << endl;
 410                 } else
 411                         redo = true;
 412         }
 413
 414         BufferParams::PARSEP tmpsep = params.paragraph_separation;
 415
 416         (settings->check_addspace->isChecked())
 417                 ? params.paragraph_separation = BufferParams::PARSEP_SKIP
 418                 : params.paragraph_separation = BufferParams::PARSEP_INDENT;
 419
 420         redo = (tmpsep != params.paragraph_separation) || redo;
 421
 422         // the skip spacing
 423
 424         VSpace tmpskip;
 425
 426         switch (settings->combo_paraspacing->currentItem()) {
 427                 case 0: tmpskip = VSpace(VSpace::SMALLSKIP); break;
 428                 case 1: tmpskip = VSpace(VSpace::MEDSKIP); break;
 429                 case 2: tmpskip = VSpace(VSpace::BIGSKIP); break;
 430                 default:
 431                         lyxerr[Debug::GUI] << "Unknown skip spacing " <<
 432                                 settings->combo_paraspacing->currentItem() << endl;
 433                         break;
 434                 case 3:
 435                         string const val = settings->length_paraspacing->getLengthStr()
 436                                 + "+" + settings->length_paraspacingstretch->getLengthStr()
 437                                 + "-" + settings->length_paraspacingshrink->getLengthStr();
 438                         lyxerr[Debug::GUI] << "Read para spacing of \"" << val << "\"" << endl;
 439                         LyXGlueLength length(0.0, LyXLength::PT);
 440                         isValidGlueLength(val, &length);
 441                         tmpskip = VSpace(length);
 442                         break;
 443         }
 444
 445         if (!(tmpskip == params.getDefSkip())) {
 446                 redo = true;
 447                 params.setDefSkip(tmpskip);
 448         }
 449
 450         // columns and sides
 451
 452         (settings->check_sides->isChecked())
 453                 ? params.sides = LyXTextClass::TwoSides
 454                 : params.sides = LyXTextClass::OneSide;
 455
 456         (settings->check_columns->isChecked())
 457                 ? params.columns = 2
 458                 : params.columns = 1;
 459
 460         // line spacing
 461
 462         Spacing tmpspacing = params.spacing;
 463
 464         switch (settings->combo_linespacing->currentItem()) {
 465                 case 0: params.spacing.set(Spacing::Single); break;
 466                 case 1: params.spacing.set(Spacing::Onehalf); break;
 467                 case 2: params.spacing.set(Spacing::Double); break;
 468                 case 3:
 469                         params.spacing.set(Spacing::Other, settings->line_linespacing->text());
 470                         break;
 471                 default:
 472                         lyxerr[Debug::GUI] << "Unknown line spacing " <<
 473                                 settings->combo_linespacing->currentItem();
 474         }
 475
 476         if (tmpspacing != params.spacing)
 477                 redo = true;
 478
 479         // extra options
 480
 481         params.options = settings->line_extraoptions->text();
 482
 483
 484         // paper package and margin package
 485         params.papersize2 = static_cast<char>(geometry->combo_papersize->currentItem());
 486         params.paperpackage = static_cast<char>(geometry->combo_margins->currentItem());
 487         if (geometry->radio_landscape->isChecked())
 488                 params.orientation = BufferParams::ORIENTATION_LANDSCAPE;
 489         else
 490                 params.orientation = BufferParams::ORIENTATION_PORTRAIT;
 491
 492         params.paperwidth = geometry->length_width->getLengthStr();
 493         params.paperheight = geometry->length_height->getLengthStr();
 494         params.leftmargin = geometry->length_left->getLengthStr();
 495         params.rightmargin = geometry->length_right->getLengthStr();
 496         params.topmargin = geometry->length_top->getLengthStr();
 497         params.bottommargin = geometry->length_bottom->getLengthStr();
 498         params.headheight = geometry->length_headheight->getLengthStr();
 499         params.headsep = geometry->length_headsep->getLengthStr();
 500         params.footskip = geometry->length_footskip->getLengthStr();
 501
 502         /* FIXME: is geometry required for headheight,sep,footskip ? */
 503         params.use_geometry =
 504                 (params.paperwidth != "" ||
 505                 params.paperheight != "" ||
 506                 params.leftmargin != "" ||
 507                 params.rightmargin != "" ||
 508                 params.topmargin != "" ||
 509                 params.bottommargin != "");
 510
 511         // language dialog
 512
 513         InsetQuotes::quote_language lga = InsetQuotes::EnglishQ;
 514
 515         switch (language->combo_quotes->currentItem()) {
 516                 case 0: case 2: case 4: case 6: case 8: case 10:
 517                         params.quotes_times = InsetQuotes::SingleQ;
 518                         break;
 519                 default:
 520                         params.quotes_times = InsetQuotes::DoubleQ;
 521         }
 522
 523         switch (language->combo_quotes->currentItem()) {
 524                 case 0: case 1: lga = InsetQuotes::EnglishQ; break;
 525                 case 2: case 3: lga = InsetQuotes::SwedishQ; break;
 526                 case 4: case 5: lga = InsetQuotes::GermanQ; break;
 527                 case 6: case 7: lga = InsetQuotes::PolishQ; break;
 528                 case 8: case 9: lga = InsetQuotes::FrenchQ; break;
 529                 case 10: case 11: lga = InsetQuotes::DanishQ; break;
 530                 default:
 531                         lyxerr[Debug::GUI] << "unknown quotes style" <<
 532                                 language->combo_quotes->currentItem() << endl;
 533         }
 534
 535         params.quotes_language = lga;
 536
 537         /* wow, tongue twister */
 538         Language const * old_language = params.language;
 539         Language const * new_language = languages.getLanguage(language->combo_language->currentText());
 540
 541         /* FIXME */
 542         if (old_language != new_language
 543                 && old_language->RightToLeft() == new_language->RightToLeft()
 544                 /*&& !lv_->buffer()->isMultiLingual()*/) {
 545                 //lv_->buffer()->ChangeLanguage(old_language, new_language);
 546         }
 547
 548         redo = (old_language != new_language) || redo;
 549         params.language = new_language;
 550
 551         params.inputenc = language->combo_encoding->currentText();
 552
 553         // extra dialog
 554
 555         params.graphicsDriver = extra->combo_psdriver->currentText();
 556         params.use_amsmath = extra->check_amsmath->isChecked();
 557
 558         if (extra->spin_sectiondepth->value() != params.secnumdepth) {
 559                 redo = true;
 560                 params.secnumdepth = extra->spin_sectiondepth->value();
 561         }
 562
 563         params.tocdepth = extra->spin_tocdepth->value();
 564
 565         string place;
 566
 567         place += placementString(extra->combo_first);
 568         place += placementString(extra->combo_second);
 569         place += placementString(extra->combo_third);
 570         place += placementString(extra->combo_fourth);
 571         params.float_placement = place;
 572
 573         /* FIXME: bullets */
 574
 575         return redo;
 576 }
 577
 578 string DocDialog::placementString(QComboBox * box) const
 579 {
 580         if (!compare(box->currentText(), _("Here")))
 581                 return "h";
 582         if (!compare(box->currentText(), _("Bottom of page")))
 583                 return "b";
 584         if (!compare(box->currentText(), _("Top of page")))
 585                 return "t";
 586         if (!compare(box->currentText(), _("Separate page")))
 587                 return "p";
 588         return "";
 589 }
 590
 591 void DocDialog::linespacingChanged(const char * sel)
 592 {
 593         bool const custom = !compare(sel, _("custom"));
 594
 595         settings->line_linespacing->setEnabled(custom);
 596 }
 597
 598
 599 void DocDialog::paraspacingChanged(const char * sel)
 600 {
 601         bool const custom = !compare(sel, _("custom"));
 602         settings->length_paraspacing->setEnabled(custom);
 603         settings->length_paraspacingstretch->setEnabled(custom);
 604         settings->length_paraspacingshrink->setEnabled(custom);
 605 }
 606
 607 void DocDialog::addspaceChanged(bool on)
 608 {
 609         settings->combo_paraspacing->setEnabled(on);
 610         on = (on && !compare(settings->combo_paraspacing->currentText(),
 611                              _("custom")));
 612         settings->length_paraspacing->setEnabled(on);
 613         settings->length_paraspacingstretch->setEnabled(on);
 614         settings->length_paraspacingshrink->setEnabled(on);
 615 }