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