src/frontends/kde/docdlg.C

   1 /*
   2  * docdlg.C
   3  * (C) 2001 LyX Team
   4  * John Levon, moz@compsoc.man.ac.uk
   5  */
   6
   7 /***************************************************************************
   8  *                                                                         *
   9  *   This program is free software; you can redistribute it and/or modify  *
  10  *   it under the terms of the GNU General Public License as published by  *
  11  *   the Free Software Foundation; either version 2 of the License, or     *
  12  *   (at your option) any later version.                                   *
  13  *                                                                         *
  14  ***************************************************************************/
  15
  16 #include <config.h>
  17
  18 #include <qtooltip.h>
  19
  20 #include "docdlg.h"
  21
  22 #include "layout.h"
  23 #include "tex-strings.h"
  24 #include "bufferparams.h"
  25
  26 #include "dlg/helpers.h"
  27
  28 #include "gettext.h"
  29 #include "debug.h"
  30
  31 #ifdef CXX_WORKING_NAMESPACES
  32 using kde_helpers::setSizeHint;
  33 using kde_helpers::setComboFromStr;
  34 #endif
  35
  36 using std::endl;
  37
  38 DocDialog::DocDialog(FormDocument *form, QWidget *parent, const char *name, bool, WFlags)
  39         : DocDialogData(parent,name), form_(form)
  40 {
  41         setCaption(name);
  42
  43         settings = new DocSettingsDialogData(this, "settings");
  44         extra = new DocExtraDialogData(this, "extra");
  45         geometry = new DocGeometryDialogData(this, "geometry");
  46         language = new DocLanguageDialogData(this, "language");
  47         bullets = new DocBulletsDialogData(this, "bullets");
  48
  49         tabstack->addTabPage(settings, _("&Settings"));
  50         tabstack->addTabPage(extra, _("&Extra"));
  51         tabstack->addTabPage(geometry, _("&Geometry"));
  52         tabstack->addTabPage(language, _("&Language"));
  53         tabstack->addTabPage(bullets, _("&Bullets"));
  54
  55         // document classes
  56         for (LyXTextClassList::const_iterator cit = textclasslist.begin();
  57                 cit != textclasslist.end(); ++cit)
  58                 settings->docclass->insertItem((*cit).description().c_str());
  59         setSizeHint(settings->docclass);
  60
  61         settings->pagestyle->insertItem(_("default"));
  62         settings->pagestyle->insertItem(_("empty"));
  63         settings->pagestyle->insertItem(_("plain"));
  64         settings->pagestyle->insertItem(_("headings"));
  65         settings->pagestyle->insertItem(_("fancy"));
  66         setSizeHint(settings->pagestyle);
  67
  68         // available fonts
  69         for (int i=0; tex_fonts[i][0]; i++)
  70                 settings->font->insertItem(tex_fonts[i]);
  71         setSizeHint(settings->font);
  72
  73         settings->fontsize->insertItem(_("default"));
  74         settings->fontsize->insertItem(_("10 point"));
  75         settings->fontsize->insertItem(_("11 point"));
  76         settings->fontsize->insertItem(_("12 point"));
  77         setSizeHint(settings->fontsize);
  78
  79         settings->linespacing->insertItem(_("single"));
  80         settings->linespacing->insertItem(_("1 1/2 spacing"));
  81         settings->linespacing->insertItem(_("double"));
  82         settings->linespacing->insertItem(_("custom"));
  83         setSizeHint(settings->linespacing);
  84
  85         connect(settings->linespacing, SIGNAL(highlighted(const char *)),
  86                 this, SLOT(linespacingChanged(const char *)));
  87
  88         settings->skipspacing->insertItem(_("small"));
  89         settings->skipspacing->insertItem(_("medium"));
  90         settings->skipspacing->insertItem(_("big"));
  91         settings->skipspacing->insertItem(_("custom"));
  92         setSizeHint(settings->skipspacing);
  93
  94         connect(settings->skipspacing, SIGNAL(highlighted(const char *)),
  95                 this, SLOT(skipspacingChanged(const char *)));
  96
  97         // ps driver options
  98         for (int i = 0; tex_graphics[i][0]; i++)
  99                 extra->psdriver->insertItem(tex_graphics[i]);
 100         setSizeHint(extra->psdriver);
 101
 102         geometry->papersize->insertItem(_("default"));
 103         geometry->papersize->insertItem(_("US letter"));
 104         geometry->papersize->insertItem(_("US legal"));
 105         geometry->papersize->insertItem(_("US executive"));
 106         geometry->papersize->insertItem("A3");
 107         geometry->papersize->insertItem("A4");
 108         geometry->papersize->insertItem("A5");
 109         geometry->papersize->insertItem("B3");
 110         geometry->papersize->insertItem("B4");
 111         geometry->papersize->insertItem("B5");
 112         setSizeHint(geometry->papersize);
 113
 114         geometry->margins->insertItem(_("default"));
 115         geometry->margins->insertItem(_("A4 small margins"));
 116         geometry->margins->insertItem(_("A4 very small margins"));
 117         geometry->margins->insertItem(_("A4 very wide margins"));
 118         setSizeHint(geometry->margins);
 119
 120 #ifdef DO_USE_DEFAULT_LANGUAGE
 121         language->language->insertItem(_("default"));
 122 #endif
 123         for (Languages::const_iterator cit = languages.begin();
 124                 cit != languages.end(); ++cit)
 125                 language->language->insertItem((*cit).second.lang().c_str());
 126         setSizeHint(language->language);
 127
 128         language->encoding->insertItem(_("default"));
 129         language->encoding->insertItem(_("auto"));
 130         language->encoding->insertItem(_("latin1"));
 131         language->encoding->insertItem(_("latin2"));
 132         language->encoding->insertItem(_("latin5"));
 133         language->encoding->insertItem(_("koi8-r"));
 134         language->encoding->insertItem(_("koi8-u"));
 135         language->encoding->insertItem(_("cp866"));
 136         language->encoding->insertItem(_("cp1251"));
 137         language->encoding->insertItem(_("iso88595"));
 138         setSizeHint(language->encoding);
 139
 140         language->quotes->insertItem(_("`text'"));
 141         language->quotes->insertItem(_("``text''"));
 142         language->quotes->insertItem(_("'text'"));
 143         language->quotes->insertItem(_("''text''"));
 144         language->quotes->insertItem(_(",text`"));
 145         language->quotes->insertItem(_(",,text``"));
 146         language->quotes->insertItem(_(",text'"));
 147         language->quotes->insertItem(_(",,text''"));
 148         language->quotes->insertItem(_("<text>"));
 149         language->quotes->insertItem(_("«text»"));
 150         language->quotes->insertItem(_(">text<"));
 151         language->quotes->insertItem(_("»text«"));
 152         setSizeHint(language->quotes);
 153
 154         /* FIXME: bullets */
 155
 156         QToolTip::add(settings->pagestyle, _("Specify header + footer style etc"));
 157         QToolTip::add(settings->separation, _("FIXME please !"));
 158         QToolTip::add(settings->linespacingVal, _("Custom line spacing in line units"));
 159         QToolTip::add(settings->extraoptions, _("Additional LaTeX options"));
 160         QToolTip::add(extra->floatplacement, _("Specify preferred order for\nplacing floats"));
 161         QToolTip::add(extra->sectiondepth, _("How far in the (sub)sections are numbered"));
 162         QToolTip::add(extra->tocdepth, _("How detailed the Table of Contents is"));
 163         QToolTip::add(extra->psdriver, _("Program to produce PostScript output"));
 164         QToolTip::add(extra->amsmath, _("FIXME please !"));
 165         QToolTip::add(geometry->headheight, _("FIXME please !"));
 166         QToolTip::add(geometry->headsep, _("FIXME please !"));
 167         QToolTip::add(geometry->footskip, _("FIXME please !"));
 168 }
 169
 170 DocDialog::~DocDialog()
 171 {
 172 }
 173
 174 void DocDialog::closeEvent(QCloseEvent *e)
 175 {
 176         form_->close();
 177         e->accept();
 178 }
 179
 180 void DocDialog::setReadOnly(bool readonly)
 181 {
 182         /* FIXME */
 183         cancel->setText(readonly ? _("&Close") : _("&Cancel"));
 184 }
 185
 186 void DocDialog::setFromParams(BufferParams const & params)
 187 {
 188         if (!setComboFromStr(settings->docclass, textclasslist.DescOfClass(params.textclass)))
 189                 lyxerr[Debug::GUI] << "Couldn't set docclass " << textclasslist.DescOfClass(params.textclass) << endl;
 190
 191         if (!setComboFromStr(settings->font, params.fonts))
 192                 lyxerr[Debug::GUI] << "Couldn't set font " << params.fonts << endl;
 193
 194         LyXTextClass const & tclass = textclasslist.TextClass(params.textclass);
 195
 196         // opt_fontsize is a string like "10|11|12"
 197         // FIXME: check + 1 ?
 198         settings->fontsize->setCurrentItem(tokenPos(tclass.opt_fontsize(), '|', params.fontsize) + 1);
 199
 200         // "empty|plain|headings|fancy"
 201         // FIXME: check + 1 ?
 202         settings->pagestyle->setCurrentItem(tokenPos(tclass.opt_pagestyle(), '|', params.pagestyle) + 1);
 203
 204         settings->separation->setChecked(params.paragraph_separation == BufferParams::PARSEP_INDENT);
 205
 206         int item=0;
 207
 208         switch (params.getDefSkip().kind()) {
 209                 case VSpace::SMALLSKIP: item = 0; break;
 210                 case VSpace::MEDSKIP: item = 1; break;
 211                 case VSpace::BIGSKIP: item = 2; break;
 212                 case VSpace::LENGTH: item = 3; break;
 213                 default:
 214                         lyxerr[Debug::GUI] << "Unknown defskip " << int(params.getDefSkip().kind()) << endl;
 215         }
 216
 217         /* FIXME */
 218         settings->skipspacing->setCurrentItem(item);
 219         //setFromLengthStr(settings->skipspacingVal, settings->skipspacingUnits, params.getDefSkip().asLyXCommand());
 220
 221         settings->sides->setChecked(params.sides == LyXTextClass::TwoSides);
 222         settings->columns->setChecked(params.columns == 2);
 223
 224         switch (params.spacing.getSpace()) {
 225                 case Spacing::Default:
 226                 case Spacing::Single: item = 0; break;
 227                 case Spacing::Onehalf: item = 1; break;
 228                 case Spacing::Double: item = 2; break;
 229                 case Spacing::Other: item = 3; break;
 230                 default:
 231                         lyxerr[Debug::GUI] << "Unknown line spacing " << int(params.spacing.getSpace()) << endl;
 232         }
 233
 234         settings->linespacing->setCurrentItem(item);
 235         settings->linespacingVal->setEnabled(item == 3);
 236
 237         if (item == 3)
 238                 settings->linespacingVal->setText(tostr(params.spacing.getValue()).c_str());
 239         else
 240                 settings->linespacingVal->setText("");
 241
 242         if (params.options.empty())
 243                 settings->extraoptions->setText("");
 244         else
 245                 settings->extraoptions->setText(params.options.c_str());
 246
 247         // geometry page
 248
 249         geometry->papersize->setCurrentItem(params.papersize2);
 250
 251         geometry->margins->setCurrentItem(params.paperpackage);
 252
 253         geometry->portrait->setChecked(params.orientation == BufferParams::ORIENTATION_PORTRAIT);
 254         geometry->landscape->setChecked(params.orientation != BufferParams::ORIENTATION_PORTRAIT);
 255
 256         geometry->width->setFromLengthStr(params.paperwidth);
 257         geometry->height->setFromLengthStr(params.paperheight);
 258         geometry->left->setFromLengthStr(params.leftmargin);
 259         geometry->right->setFromLengthStr(params.rightmargin);
 260         geometry->top->setFromLengthStr(params.topmargin);
 261         geometry->bottom->setFromLengthStr(params.bottommargin);
 262         geometry->headheight->setFromLengthStr(params.headheight);
 263         geometry->headsep->setFromLengthStr(params.headsep);
 264         geometry->footskip->setFromLengthStr(params.footskip);
 265
 266         // language page
 267
 268         if (!setComboFromStr(language->language, params.language->lang()))
 269                 lyxerr[Debug::GUI] << "Couldn't set language " << params.language->lang() << endl;
 270
 271         if (!setComboFromStr(language->encoding, params.inputenc))
 272                 lyxerr[Debug::GUI] << "Couldn't set encoding " << params.inputenc << endl;
 273
 274         switch (params.quotes_language) {
 275                 case InsetQuotes::EnglishQ: item = 0; break;
 276                 case InsetQuotes::SwedishQ: item = 2; break;
 277                 case InsetQuotes::GermanQ: item = 4; break;
 278                 case InsetQuotes::PolishQ: item = 6; break;
 279                 case InsetQuotes::FrenchQ: item = 8; break;
 280                 case InsetQuotes::DanishQ: item = 10; break;
 281                 default:
 282                         lyxerr[Debug::GUI] << "Unknown quote style " << int(params.quotes_language) << endl;
 283         }
 284
 285         if (params.quotes_times == InsetQuotes::DoubleQ)
 286                 item++;
 287
 288         language->quotes->setCurrentItem(item);
 289
 290         // extra page
 291
 292         if (!setComboFromStr(extra->psdriver, params.graphicsDriver))
 293                 lyxerr[Debug::GUI] << "Couldn't set psdriver " << params.graphicsDriver << endl;
 294
 295         extra->amsmath->setChecked(params.use_amsmath);
 296         extra->sectiondepth->setValue(params.secnumdepth);
 297         extra->tocdepth->setValue(params.tocdepth);
 298
 299         /* FIXME */
 300         if (params.float_placement.empty())
 301                 extra->floatplacement->setText("");
 302         else
 303                 extra->floatplacement->setText(params.float_placement.c_str());
 304
 305         /* FIXME: bullets ! */
 306 }
 307
 308 bool DocDialog::updateParams(BufferParams & params)
 309 {
 310         bool redo = false;
 311
 312         params.fonts = string(settings->font->currentText());
 313         LyXTextClass const & tclass = textclasslist.TextClass(params.textclass);
 314         params.fontsize = token(tclass.opt_fontsize(), '|', settings->fontsize->currentItem() - 1);
 315         params.pagestyle = token(tclass.opt_pagestyle(), '|', settings->pagestyle->currentItem() - 1);
 316
 317         // set and update class
 318
 319         unsigned int const new_class = settings->docclass->currentItem();
 320
 321         if (new_class != params.textclass) {
 322                 if (!form_->changeClass(params, new_class)) {
 323                         // FIXME: error msg
 324                         // restore old class
 325                         if (!setComboFromStr(settings->docclass, textclasslist.DescOfClass(params.textclass)))
 326                                 lyxerr[Debug::GUI] << "Couldn't set docclass " << textclasslist.DescOfClass(params.textclass) << endl;
 327                 } else
 328                         redo = true;
 329         }
 330
 331         // paragraph separation, skip or indent
 332         // FIXME: what does this do
 333
 334         BufferParams::PARSEP tmpsep = params.paragraph_separation;
 335
 336         (settings->separation->isChecked())
 337                 ? params.paragraph_separation = BufferParams::PARSEP_INDENT
 338                 : params.paragraph_separation = BufferParams::PARSEP_SKIP;
 339
 340         redo = (tmpsep != params.paragraph_separation) || redo;
 341
 342         // the skip spacing
 343
 344         VSpace tmpskip;
 345
 346         switch (settings->skipspacing->currentItem()) {
 347                 case 0: tmpskip = VSpace(VSpace::SMALLSKIP); break;
 348                 case 1: tmpskip = VSpace(VSpace::MEDSKIP); break;
 349                 case 2: tmpskip = VSpace(VSpace::BIGSKIP); break;
 350                 case 3:
 351                         tmpskip = VSpace(LyXGlueLength("23mm"));
 352                         /* FIXME: read glue length from skip bits !!! */
 353                         break;
 354                 default:
 355                         lyxerr[Debug::GUI] << "Unknown skip spacing " <<
 356                                 settings->skipspacing->currentItem() << endl;
 357         }
 358
 359         if (tmpskip != params.getDefSkip()) {
 360                 redo = true;
 361                 params.setDefSkip(tmpskip);
 362         }
 363
 364         // columns and sides
 365
 366         (settings->sides->isChecked())
 367                 ? params.sides = LyXTextClass::TwoSides
 368                 : params.sides = LyXTextClass::OneSide;
 369
 370         (settings->columns->isChecked())
 371                 ? params.columns = 2
 372                 : params.columns = 1;
 373
 374         // line spacing
 375
 376         Spacing tmpspacing = params.spacing;
 377
 378         switch (settings->linespacing->currentItem()) {
 379                 case 0: params.spacing.set(Spacing::Single); break;
 380                 case 1: params.spacing.set(Spacing::Onehalf); break;
 381                 case 2: params.spacing.set(Spacing::Double); break;
 382                 case 3:
 383                         params.spacing.set(Spacing::Other, settings->linespacingVal->text());
 384                         break;
 385                 default:
 386                         lyxerr[Debug::GUI] << "Unknown line spacing " <<
 387                                 settings->linespacing->currentItem();
 388         }
 389
 390         if (tmpspacing != params.spacing)
 391                 redo = true;
 392
 393         // extra options
 394
 395         params.options = settings->extraoptions->text();
 396
 397
 398         // paper package and margin package
 399         params.papersize2 = static_cast<char>(geometry->papersize->currentItem());
 400         params.paperpackage = static_cast<char>(geometry->margins->currentItem());
 401         if (geometry->landscape->isChecked())
 402                 params.orientation = BufferParams::ORIENTATION_LANDSCAPE;
 403         else
 404                 params.orientation = BufferParams::ORIENTATION_PORTRAIT;
 405
 406         params.paperwidth = geometry->width->getLengthStr();
 407         params.paperheight = geometry->height->getLengthStr();
 408         params.leftmargin = geometry->left->getLengthStr();
 409         params.rightmargin = geometry->right->getLengthStr();
 410         params.topmargin = geometry->top->getLengthStr();
 411         params.bottommargin = geometry->bottom->getLengthStr();
 412         params.headheight = geometry->headheight->getLengthStr();
 413         params.headsep = geometry->headsep->getLengthStr();
 414         params.footskip = geometry->footskip->getLengthStr();
 415
 416         /* FIXME: is geometry required for headheight,sep,footskip ? */
 417         params.use_geometry =
 418                 (params.paperwidth != "" ||
 419                 params.paperheight != "" ||
 420                 params.leftmargin != "" ||
 421                 params.rightmargin != "" ||
 422                 params.topmargin != "" ||
 423                 params.bottommargin != "");
 424
 425
 426         // language dialog
 427
 428         InsetQuotes::quote_language lga = InsetQuotes::EnglishQ;
 429
 430         switch (language->quotes->currentItem()) {
 431                 case 0: case 2: case 4: case 6: case 8: case 10:
 432                         params.quotes_times = InsetQuotes::SingleQ;
 433                         break;
 434                 default:
 435                         params.quotes_times = InsetQuotes::DoubleQ;
 436         }
 437
 438         switch (language->quotes->currentItem()) {
 439                 case 0: case 1: lga = InsetQuotes::EnglishQ; break;
 440                 case 2: case 3: lga = InsetQuotes::SwedishQ; break;
 441                 case 4: case 5: lga = InsetQuotes::GermanQ; break;
 442                 case 6: case 7: lga = InsetQuotes::PolishQ; break;
 443                 case 8: case 9: lga = InsetQuotes::FrenchQ; break;
 444                 case 10: case 11: lga = InsetQuotes::DanishQ; break;
 445                 default:
 446                         lyxerr[Debug::GUI] << "unknown quotes style" <<
 447                                 language->quotes->currentItem() << endl;
 448         }
 449
 450         params.quotes_language = lga;
 451
 452         /* wow, tongue twister */
 453         Language const * old_language = params.language;
 454         Language const * new_language = languages.getLanguage(language->language->currentText());
 455
 456         /* FIXME */
 457         if (old_language != new_language
 458                 && old_language->RightToLeft() == new_language->RightToLeft()
 459                 /*&& !lv_->buffer()->isMultiLingual()*/) {
 460                 //lv_->buffer()->ChangeLanguage(old_language, new_language);
 461         }
 462
 463         redo = (old_language != new_language) || redo;
 464         params.language = new_language;
 465
 466         params.inputenc = language->encoding->currentText();
 467
 468         // extra dialog
 469
 470         params.graphicsDriver = extra->psdriver->currentText();
 471         params.use_amsmath = extra->amsmath->isChecked();
 472
 473         if (extra->sectiondepth->value() != params.secnumdepth) {
 474                 redo = true;
 475                 params.secnumdepth = extra->sectiondepth->value();
 476         }
 477
 478         params.tocdepth = extra->tocdepth->value();
 479
 480         /* FIXME */
 481         params.float_placement = extra->floatplacement->text();
 482
 483         /* FIXME: bullets */
 484
 485         return redo;
 486 }
 487
 488 void DocDialog::linespacingChanged(const char *sel)
 489 {
 490         bool custom = !strcmp(sel, _("custom"));
 491
 492         settings->linespacingVal->setEnabled(custom);
 493 }
 494
 495 void DocDialog::skipspacingChanged(const char *sel)
 496 {
 497         bool custom = !strcmp(sel, _("custom"));
 498 }