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