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