src/frontends/qt2/paragraphdlgimpl.C

   1 /**
   2  * \file paragraphdlgimpl.C
   3  * Copyright 2001 LyX Team
   4  * see the file COPYING
   5  *
   6  * \author John Levon, moz@compsoc.man.ac.uk
   7  * \author Edwin Leuven, leuven@fee.uva.nl
   8  */
   9
  10 #include "paragraphdlg.h"
  11
  12 #include <config.h>
  13 #include <gettext.h>
  14 #include <string>
  15
  16 #include "paragraphdlgimpl.h"
  17 #include "FormParagraph.h"
  18 #include "support/lstrings.h"
  19 #include "debug.h"
  20
  21 #include "qlineedit.h"
  22 #include "qcombobox.h"
  23 #include "qcheckbox.h"
  24 #include "qpushbutton.h"
  25 #include "qtabwidget.h"
  26 #include "qlabel.h"
  27 #include "qgroupbox.h"
  28
  29
  30 ParagraphDlgImpl::ParagraphDlgImpl(FormParagraph *form, QWidget* parent,  const char* name, bool modal, WFlags fl )
  31     : ParagraphDlg( parent, name, modal, fl ), form_(form)
  32 {
  33   setCaption(name);
  34 }
  35
  36 ParagraphDlgImpl::~ParagraphDlgImpl()
  37 {
  38     // no need to delete child widgets, Qt does it all for us
  39 }
  40
  41 void ParagraphDlgImpl::setReadOnly(bool readonly)
  42 {
  43    TabsParagraph->setEnabled(!readonly);
  44    okPB->setEnabled(!readonly);
  45    applyPB->setEnabled(!readonly);
  46    defaultsPB->setEnabled(!readonly);
  47    cancelPB->setText(readonly ? _("&Close") : _("&Cancel"));
  48 }
  49
  50 void ParagraphDlgImpl::setLabelWidth(const char *text)
  51 {
  52    // FIXME: should be cleverer here
  53    if (!strcmp(_("Senseless with this layout!"),text)) {
  54       listOptions->setEnabled(false);
  55       labelWidth->setText("");
  56    } else {
  57       listOptions->setEnabled(true);
  58       labelWidth->setText(text);
  59    }
  60 }
  61
  62 void ParagraphDlgImpl::setAlign(int type)
  63 {
  64    int item=0;
  65    switch (type) {
  66     case LYX_ALIGN_BLOCK : item=0; break;
  67     case LYX_ALIGN_LEFT : item=1; break;
  68     case LYX_ALIGN_RIGHT : item=2; break;
  69     case LYX_ALIGN_CENTER : item=3; break;
  70     default:
  71       item=0;
  72    }
  73    alignment->setCurrentItem(item);
  74 }
  75
  76 void ParagraphDlgImpl::setChecks(bool labove, bool lbelow, bool pabove, bool pbelow, bool noindent)
  77 {
  78    lineAbove->setChecked(labove);
  79    lineBelow->setChecked(lbelow);
  80    pagebreakAbove->setChecked(pabove);
  81    pagebreakBelow->setChecked(pbelow);
  82    noIndent->setChecked(noindent);
  83 }
  84
  85 void ParagraphDlgImpl::setSpace(VSpace::vspace_kind kindabove, VSpace::vspace_kind kindbelow, bool keepabove, bool keepbelow)
  86 {
  87    int item=0;
  88
  89    switch (kindabove) {
  90       case VSpace::NONE: item = 0; break;
  91       case VSpace::DEFSKIP: item = 1; break;
  92       case VSpace::SMALLSKIP: item = 2; break;
  93       case VSpace::MEDSKIP: item = 3; break;
  94       case VSpace::BIGSKIP: item = 4; break;
  95       case VSpace::VFILL: item = 5; break;
  96       case VSpace::LENGTH: item = 6; break;
  97    }
  98    spacingAbove->setCurrentItem(item);
  99
 100    switch (kindbelow) {
 101       case VSpace::NONE: item = 0; break;
 102       case VSpace::DEFSKIP: item = 1; break;
 103       case VSpace::SMALLSKIP: item = 2; break;
 104       case VSpace::MEDSKIP: item = 3; break;
 105       case VSpace::BIGSKIP: item = 4; break;
 106       case VSpace::VFILL: item = 5; break;
 107       case VSpace::LENGTH: item = 6; break;
 108    }
 109    spacingBelow->setCurrentItem(item);
 110
 111    spacingAboveValue->setEnabled(kindabove == VSpace::LENGTH);
 112    spacingAbovePlus->setEnabled(kindabove == VSpace::LENGTH);
 113    spacingAboveMinus->setEnabled(kindabove == VSpace::LENGTH);
 114    spacingBelowValue->setEnabled(kindbelow == VSpace::LENGTH);
 115    spacingBelowPlus->setEnabled(kindbelow == VSpace::LENGTH);
 116    spacingBelowMinus->setEnabled(kindbelow == VSpace::LENGTH);
 117
 118    spacingAboveKeep->setChecked(keepabove);
 119    spacingBelowKeep->setChecked(keepbelow);
 120 }
 121
 122 void ParagraphDlgImpl::setAboveLength(float val, float plus, float minus,
 123         LyXLength::UNIT vunit, LyXLength::UNIT punit, LyXLength::UNIT munit)
 124 {
 125    if (vunit==LyXLength::UNIT_NONE) {
 126       spacingAboveValue->setText("");
 127       spacingAbovePlus->setText("");
 128       spacingAboveMinus->setText("");
 129    } else {
 130       spacingAboveValue->setText(tostr(val).c_str());
 131       spacingAbovePlus->setText(tostr(plus).c_str());
 132       spacingAboveMinus->setText(tostr(minus).c_str());
 133    }
 134
 135    spacingAboveValueUnit->setCurrentItem(getItem(vunit));
 136    spacingAbovePlusUnit->setCurrentItem(getItem(punit));
 137    spacingAboveMinusUnit->setCurrentItem(getItem(munit));
 138
 139 }
 140
 141 void ParagraphDlgImpl::setBelowLength(float val, float plus, float minus,
 142         LyXLength::UNIT vunit, LyXLength::UNIT punit, LyXLength::UNIT munit)
 143 {
 144    if (vunit==LyXLength::UNIT_NONE) {
 145       spacingBelowValue->setText("");
 146       spacingBelowPlus->setText("");
 147       spacingBelowMinus->setText("");
 148    } else {
 149       spacingBelowValue->setText(tostr(val).c_str());
 150       spacingBelowPlus->setText(tostr(plus).c_str());
 151       spacingBelowMinus->setText(tostr(minus).c_str());
 152    }
 153
 154    spacingBelowValueUnit->setCurrentItem(getItem(vunit));
 155    spacingBelowPlusUnit->setCurrentItem(getItem(punit));
 156    spacingBelowMinusUnit->setCurrentItem(getItem(munit));
 157 }
 158
 159 void ParagraphDlgImpl::setExtra(float widthval, LyXLength::UNIT units, const string percent, int align,
 160         bool hfill, bool startminipage, LyXParagraph::PEXTRA_TYPE type)
 161 {
 162    if (type!=LyXParagraph::PEXTRA_NONE) {
 163       lyxerr[Debug::GUI] << "percent : $" << percent << "$ widthval " << widthval << " unit " << long(units) << endl;
 164       if (percent != "") {
 165          extraWidth->setText(percent.c_str());
 166          extraUnit->setCurrentItem(11);
 167       } else {
 168          extraWidth->setText(tostr(widthval).c_str());
 169          extraUnit->setCurrentItem(getItem(units));
 170       }
 171    } else
 172      extraWidth->setText("");
 173
 174    switch (type) {
 175       case LyXParagraph::PEXTRA_NONE:
 176       extraType->setCurrentItem(0);
 177       break;
 178       case LyXParagraph::PEXTRA_MINIPAGE:
 179       extraType->setCurrentItem(1);
 180       enable_extraOptions(1);
 181       enable_minipageOptions(1);
 182       break;
 183       case LyXParagraph::PEXTRA_FLOATFLT:
 184       extraType->setCurrentItem(2);
 185       enable_extraOptions(2);
 186       break;
 187       case LyXParagraph::PEXTRA_INDENT:
 188       extraType->setCurrentItem(3);
 189       enable_extraOptions(3);
 190       break;
 191    }
 192
 193    switch (align) {
 194       case LyXParagraph::MINIPAGE_ALIGN_TOP:
 195       minipageValign->setCurrentItem(0);
 196       break;
 197       case LyXParagraph::MINIPAGE_ALIGN_MIDDLE:
 198       minipageValign->setCurrentItem(1);
 199       break;
 200       case LyXParagraph::MINIPAGE_ALIGN_BOTTOM:
 201       minipageValign->setCurrentItem(2);
 202       break;
 203    }
 204
 205    minipageHfill->setChecked(hfill);
 206    minipageStart->setChecked(startminipage);
 207
 208 }
 209
 210 LyXGlueLength ParagraphDlgImpl::getAboveLength() const
 211 {
 212    LyXGlueLength len(
 213                      spacingAboveValue->text().toFloat(),
 214                      getLyXLength( spacingAboveValueUnit->currentItem() ),
 215                      spacingAbovePlus->text().toFloat(),
 216                      getLyXLength( spacingAbovePlusUnit->currentItem() ),
 217                      spacingAboveMinus->text().toFloat(),
 218                      getLyXLength( spacingAboveMinusUnit->currentItem() )
 219                      );
 220    return len;
 221 }
 222
 223 LyXGlueLength ParagraphDlgImpl::getBelowLength() const
 224 {
 225    LyXGlueLength len(
 226                      spacingBelowValue->text().toFloat(),
 227                      getLyXLength( spacingBelowValueUnit->currentItem() ),
 228                      spacingBelowPlus->text().toFloat(),
 229                      getLyXLength( spacingBelowPlusUnit->currentItem() ),
 230                      spacingBelowMinus->text().toFloat(),
 231                      getLyXLength( spacingBelowMinusUnit->currentItem() )
 232                 );
 233    return len;
 234 }
 235
 236 LyXLength ParagraphDlgImpl::getExtraWidth() const
 237 {
 238    if (extraUnit->currentItem()!=11) {
 239       LyXLength len(
 240                     (extraWidth->text()).toDouble(),
 241                     getLyXLength(extraUnit->currentItem())
 242                     );
 243       return len;
 244    } else {
 245       LyXLength len(0.0, LyXLength::UNIT_NONE);
 246       return len;
 247    }
 248 }
 249
 250 string ParagraphDlgImpl::getExtraWidthPercent() const
 251 {
 252    double val = (extraWidth->text()).toDouble();
 253    if (val > 100.0)
 254      val = 100.0;
 255    if (val < 0.0)
 256      val = 0.0;
 257    return tostr(val);
 258 }
 259
 260
 261 const char* ParagraphDlgImpl::getLabelWidth() const {
 262    return labelWidth->text();
 263 }
 264
 265 LyXAlignment ParagraphDlgImpl::getAlign() const {
 266    switch (alignment->currentItem()) {
 267       case 0: return LYX_ALIGN_BLOCK;
 268       case 1: return LYX_ALIGN_LEFT;
 269       case 2: return LYX_ALIGN_RIGHT;
 270       case 3: return LYX_ALIGN_CENTER;
 271       default: return LYX_ALIGN_CENTER;
 272    }
 273 }
 274
 275
 276 bool ParagraphDlgImpl::getAboveKeep() const {
 277    return spacingAboveKeep->isChecked();
 278 }
 279
 280 bool ParagraphDlgImpl::getBelowKeep() const {
 281    return spacingBelowKeep->isChecked();
 282 }
 283
 284 bool ParagraphDlgImpl::getLineAbove() const {
 285    return lineAbove->isChecked();
 286 }
 287
 288 bool ParagraphDlgImpl::getLineBelow() const {
 289    return lineBelow->isChecked();
 290 }
 291
 292 bool ParagraphDlgImpl::getPagebreakAbove() const {
 293    return pagebreakAbove->isChecked();
 294 }
 295
 296 bool ParagraphDlgImpl::getPagebreakBelow() const {
 297    return pagebreakBelow->isChecked();
 298 }
 299
 300 bool ParagraphDlgImpl::getNoIndent() const {
 301    return noIndent->isChecked();
 302 }
 303
 304 VSpace::vspace_kind ParagraphDlgImpl::getSpaceAboveKind() const {
 305    return getSpaceKind(spacingAbove->currentItem());
 306 }
 307
 308 VSpace::vspace_kind ParagraphDlgImpl::getSpaceBelowKind() const {
 309    return getSpaceKind(spacingBelow->currentItem());
 310 }
 311
 312 LyXParagraph::PEXTRA_TYPE ParagraphDlgImpl::getExtraType() const {
 313    switch (extraType->currentItem()) {
 314       case 0: return LyXParagraph::PEXTRA_NONE;
 315       case 1: return LyXParagraph::PEXTRA_MINIPAGE;
 316       case 2: return LyXParagraph::PEXTRA_FLOATFLT;
 317       case 3: return LyXParagraph::PEXTRA_INDENT;
 318    }
 319    return LyXParagraph::PEXTRA_NONE;
 320 }
 321
 322 LyXParagraph::MINIPAGE_ALIGNMENT ParagraphDlgImpl::getExtraAlign() const {
 323    switch (minipageValign->currentItem()) {
 324       case 0: return LyXParagraph::MINIPAGE_ALIGN_TOP;
 325       case 1: return LyXParagraph::MINIPAGE_ALIGN_MIDDLE;
 326       case 2: return LyXParagraph::MINIPAGE_ALIGN_BOTTOM;
 327       default: return LyXParagraph::MINIPAGE_ALIGN_BOTTOM;
 328    }
 329 }
 330
 331 bool ParagraphDlgImpl::getHfillBetween() const {
 332    return minipageHfill->isChecked();
 333 }
 334
 335 bool ParagraphDlgImpl::getStartNewMinipage() const {
 336    return minipageStart->isChecked();
 337 }
 338
 339 VSpace::vspace_kind ParagraphDlgImpl::getSpaceKind(int val) const {
 340    switch (val) {
 341       case 0: return VSpace::NONE;
 342       case 1: return VSpace::DEFSKIP;
 343       case 2: return VSpace::SMALLSKIP;
 344       case 3: return VSpace::MEDSKIP;
 345       case 4: return VSpace::BIGSKIP;
 346       case 5: return VSpace::VFILL;
 347       case 6: return VSpace::LENGTH;
 348       default:
 349       lyxerr[Debug::GUI] << "Unknown kind combo entry " << val << std::endl;
 350       }
 351    return VSpace::NONE;
 352 }
 353
 354 LyXLength::UNIT ParagraphDlgImpl::getLyXLength(int val) const {
 355    switch (val) {
 356     case 0: return LyXLength::CM;
 357     case 1: return LyXLength::IN;
 358     case 2: return LyXLength::PT;
 359     case 3: return LyXLength::MM;
 360     case 4: return LyXLength::PC;
 361     case 5: return LyXLength::EX;
 362     case 6: return LyXLength::EM;
 363     case 7: return LyXLength::SP;
 364     case 8: return LyXLength::BP;
 365     case 9: return LyXLength::DD;
 366     case 10: return LyXLength::CC;
 367     default:
 368       lyxerr[Debug::GUI] << "Unknown kind combo entry " << val << std::endl;
 369    }
 370    return LyXLength::UNIT_NONE;
 371 }
 372
 373 int ParagraphDlgImpl::getItem(LyXLength::UNIT unit) const {
 374    int item=0;
 375    switch (unit) {
 376       case LyXLength::CM: item = 0; break;
 377       case LyXLength::IN: item = 1; break;
 378       case LyXLength::PT: item = 2; break;
 379       case LyXLength::MM: item = 3; break;
 380       case LyXLength::PC: item = 4; break;
 381       case LyXLength::EX: item = 5; break;
 382       case LyXLength::EM: item = 6; break;
 383       case LyXLength::SP: item = 7; break;
 384       case LyXLength::BP: item = 8; break;
 385       case LyXLength::DD: item = 9; break;
 386       case LyXLength::CC: item = 10; break;
 387       case LyXLength::MU: item = 0; break;
 388       case LyXLength::UNIT_NONE: item = 0; break;
 389       default:
 390       lyxerr[Debug::GUI] << "Unknown unit " << long(unit) << endl;
 391    }
 392    return item;
 393 }
 394
 395 void ParagraphDlgImpl::enable_extraOptions(int item)
 396 {
 397    bool enable = (item==0);
 398    extraWidth->setEnabled(enable);
 399    extraWidthL->setEnabled(enable);
 400    extraUnit->setEnabled(enable);
 401    extraUnitL->setEnabled(enable);
 402 }
 403
 404 void ParagraphDlgImpl::enable_minipageOptions(int item)
 405 {
 406    minipageOptions->setEnabled( item==1 );
 407 }
 408
 409 void ParagraphDlgImpl::enable_spacingAbove(int item)
 410 {
 411    bool enable = (item==6);
 412    spacingAboveValue->setEnabled(enable);
 413    spacingAbovePlus->setEnabled(enable);
 414    spacingAboveMinus->setEnabled(enable);
 415    spacingAboveValueUnit->setEnabled(enable);
 416    spacingAbovePlusUnit->setEnabled(enable);
 417    spacingAboveMinusUnit->setEnabled(enable);
 418    spacingAboveUnitsL->setEnabled(enable);
 419    bool enablel = ( (item==6) || (item!=6 && spacingBelow->currentItem()==6) );
 420    spacingValueL->setEnabled(enablel);
 421    spacingPlusL->setEnabled(enablel);
 422    spacingMinusL->setEnabled(enablel);
 423 }
 424
 425 void ParagraphDlgImpl::enable_spacingBelow(int item)
 426 {
 427    bool enable = (item==6);
 428    spacingBelowValue->setEnabled(enable);
 429    spacingBelowPlus->setEnabled(enable);
 430    spacingBelowMinus->setEnabled(enable);
 431    spacingBelowValueUnit->setEnabled(enable);
 432    spacingBelowPlusUnit->setEnabled(enable);
 433    spacingBelowMinusUnit->setEnabled(enable);
 434    spacingBelowUnitsL->setEnabled(enable);
 435    bool enablel = ( (item==6) || (item!=6 && spacingAbove->currentItem()==6) );
 436    spacingValueL->setEnabled(enablel);
 437    spacingPlusL->setEnabled(enablel);
 438    spacingMinusL->setEnabled(enablel);
 439 }
 440
 441 void ParagraphDlgImpl::closeEvent(QCloseEvent * e)
 442 {
 443    form_->close();
 444    e->accept();
 445 }
 446
 447 void ParagraphDlgImpl::apply_adaptor()
 448 {
 449    form_->apply();
 450 }
 451
 452 void ParagraphDlgImpl::cancel_adaptor()
 453 {
 454    form_->close();
 455    hide();
 456 }
 457
 458 void ParagraphDlgImpl::ok_adaptor()
 459 {
 460    apply_adaptor();
 461    form_->close();
 462    hide();
 463 }
 464
 465 void ParagraphDlgImpl::restore_adaptor()
 466 {
 467    form_->update();
 468 }
 469