← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/koffice/oneiric-updates

« back to all changes in this revision

Viewing changes to kspread/dialogs/ValidityDialog.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2010-10-27 17:52:57 UTC
  • mfrom: (0.12.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20101027175257-s04zqqk5bs8ckm9o
Tags: 1:2.2.83-0ubuntu1
* Merge with Debian git remaining changes:
 - Add build-deps on librcps-dev, opengtl-dev, libqtgtl-dev, freetds-dev,
   create-resources, libspnav-dev
 - Remove needless build-dep on libwv2-dev
 - koffice-libs recommends create-resources
 - krita recommends pstoedit
 - Keep our patches
* New upstream release 2.3 beta 3
  - Remove debian/patches fixed by upstream
  - Update install files

Show diffs side-by-side

added added

removed removed

Lines of Context:
kspread/dialogs/ValidityDialog.cpp
41
41
#include "CalculationSettings.h"
42
42
#include "Localization.h"
43
43
#include "Map.h"
44
 
#include "Selection.h"
 
44
#include "ui/Selection.h"
45
45
#include "Sheet.h"
 
46
#include "ValueParser.h"
46
47
 
47
48
// commands
48
49
#include "commands/ValidityCommand.h"
49
50
 
50
51
using namespace KSpread;
51
52
 
 
53
Q_DECLARE_METATYPE(Conditional::Type)
 
54
Q_DECLARE_METATYPE(Validity::Action)
 
55
Q_DECLARE_METATYPE(Validity::Restriction)
 
56
 
52
57
ValidityDialog::ValidityDialog(QWidget* parent, Selection* selection)
53
58
        : KPageDialog(parent)
54
59
 
74
79
 
75
80
    chooseType = new KComboBox(page1);
76
81
    tmpGridLayout->addWidget(chooseType, 0, 1);
77
 
    QStringList listType;
78
 
    listType += i18n("All");
79
 
    listType += i18n("Number");
80
 
    listType += i18n("Integer");
81
 
    listType += i18n("Text");
82
 
    listType += i18n("Date");
83
 
    listType += i18n("Time");
84
 
    listType += i18n("Text Length");
85
 
    listType += i18n("List");
86
 
    chooseType->insertItems(0, listType);
 
82
    chooseType->addItem(i18n("All"), QVariant::fromValue(Validity::None));
 
83
    chooseType->addItem(i18n("Number"), QVariant::fromValue(Validity::Number));
 
84
    chooseType->addItem(i18n("Integer"), QVariant::fromValue(Validity::Integer));
 
85
    chooseType->addItem(i18n("Text"), QVariant::fromValue(Validity::Text));
 
86
    chooseType->addItem(i18n("Date"), QVariant::fromValue(Validity::Date));
 
87
    chooseType->addItem(i18n("Time"), QVariant::fromValue(Validity::Time));
 
88
    chooseType->addItem(i18n("Text Length"), QVariant::fromValue(Validity::TextLength));
 
89
    chooseType->addItem(i18n("List"), QVariant::fromValue(Validity::List));
87
90
    chooseType->setCurrentIndex(0);
88
91
 
89
92
    allowEmptyCell = new QCheckBox(i18n("Allow blanks"), page1);
95
98
 
96
99
    choose = new KComboBox(page1);
97
100
    tmpGridLayout->addWidget(choose, 2, 1);
98
 
    QStringList list;
99
 
    list += i18n("equal to");
100
 
    list += i18n("greater than");
101
 
    list += i18n("less than");
102
 
    list += i18n("equal to or greater than");
103
 
    list += i18n("equal to or less than");
104
 
    list += i18n("between");
105
 
    list += i18n("different from");
106
 
    list += i18n("different to");
107
 
    choose->insertItems(0, list);
 
101
    choose->addItem(i18n("equal to"), QVariant::fromValue(Conditional::Equal));
 
102
    choose->addItem(i18n("greater than"), QVariant::fromValue(Conditional::Superior));
 
103
    choose->addItem(i18n("less than"), QVariant::fromValue(Conditional::Inferior));
 
104
    choose->addItem(i18n("equal to or greater than"), QVariant::fromValue(Conditional::SuperiorEqual));
 
105
    choose->addItem(i18n("equal to or less than"), QVariant::fromValue(Conditional::InferiorEqual));
 
106
    choose->addItem(i18n("between"), QVariant::fromValue(Conditional::Between));
 
107
    choose->addItem(i18n("different from"), QVariant::fromValue(Conditional::Different));
 
108
    choose->addItem(i18n("different to"), QVariant::fromValue(Conditional::DifferentTo));
108
109
    choose->setCurrentIndex(0);
109
110
 
110
111
    edit1 = new QLabel(page1);
171
172
 
172
173
    chooseAction = new KComboBox(page2);
173
174
    tmpGridLayout->addWidget(chooseAction, 1, 1);
174
 
    QStringList list2;
175
 
    list2 += i18n("Stop");
176
 
    list2 += i18n("Warning");
177
 
    list2 += i18n("Information");
178
 
    chooseAction->insertItems(0, list2);
 
175
    chooseAction->addItem(i18n("Stop"), QVariant::fromValue(Validity::Stop));
 
176
    chooseAction->addItem(i18n("Warning"), QVariant::fromValue(Validity::Warning));
 
177
    chooseAction->addItem(i18n("Information"), QVariant::fromValue(Validity::Information));
179
178
    chooseAction->setCurrentIndex(0);
180
179
 
181
180
    tmpQLabel = new QLabel(page2);
394
393
 
395
394
void ValidityDialog::init()
396
395
{
397
 
    const KLocale* locale = m_selection->activeSheet()->map()->calculationSettings()->locale();
 
396
    const Map *const map = m_selection->activeSheet()->map();
 
397
    const CalculationSettings *settings = map->calculationSettings();
 
398
    const KLocale* locale = settings->locale();
398
399
    Validity validity = Cell(m_selection->activeSheet(), m_selection->marker()).validity();
399
400
    if (!validity.isEmpty()) {
400
401
        message->setPlainText(validity.message());
407
408
        case Validity::Number:
408
409
            chooseType->setCurrentIndex(1);
409
410
            if (validity.condition() >= 5)
410
 
                val_max->setText(tmp.setNum(validity.maximumValue()));
411
 
            val_min->setText(tmp.setNum(validity.minimumValue()));
 
411
                val_max->setText(tmp.setNum((double)numToDouble(validity.maximumValue().asFloat())));
 
412
            val_min->setText(tmp.setNum((double)numToDouble(validity.minimumValue().asFloat())));
412
413
            break;
413
414
        case Validity::Integer:
414
415
            chooseType->setCurrentIndex(2);
415
416
            if (validity.condition() >= 5)
416
 
                val_max->setText(tmp.setNum(validity.maximumValue()));
417
 
            val_min->setText(tmp.setNum(validity.minimumValue()));
 
417
                val_max->setText(tmp.setNum((double)numToDouble(validity.maximumValue().asFloat())));
 
418
            val_min->setText(tmp.setNum((double)numToDouble(validity.minimumValue().asFloat())));
418
419
            break;
419
420
        case Validity::TextLength:
420
421
            chooseType->setCurrentIndex(6);
421
422
            if (validity.condition() >= 5)
422
 
                val_max->setText(tmp.setNum(validity.maximumValue()));
423
 
            val_min->setText(tmp.setNum(validity.minimumValue()));
 
423
                val_max->setText(tmp.setNum((double)numToDouble(validity.maximumValue().asFloat())));
 
424
            val_min->setText(tmp.setNum((double)numToDouble(validity.minimumValue().asFloat())));
424
425
            break;
425
426
        case Validity::Text:
426
427
            chooseType->setCurrentIndex(3);
427
428
            break;
428
429
        case Validity::Date:
429
430
            chooseType->setCurrentIndex(4);
430
 
            val_min->setText(locale->formatDate(validity.minimumDate(), KLocale::ShortDate));
 
431
            val_min->setText(locale->formatDate(validity.minimumValue().asDate(settings), KLocale::ShortDate));
431
432
            if (validity.condition() >= 5)
432
 
                val_max->setText(locale->formatDate(validity.maximumDate(), KLocale::ShortDate));
 
433
                val_max->setText(locale->formatDate(validity.maximumValue().asDate(settings), KLocale::ShortDate));
433
434
            break;
434
435
        case Validity::Time:
435
436
            chooseType->setCurrentIndex(5);
436
 
            val_min->setText(locale->formatTime(validity.minimumTime(), true));
 
437
            val_min->setText(locale->formatTime(validity.minimumValue().asTime(settings), true));
437
438
            if (validity.condition() >= 5)
438
 
                val_max->setText(locale->formatTime(validity.maximumTime(), true));
 
439
                val_max->setText(locale->formatTime(validity.maximumValue().asTime(settings), true));
439
440
            break;
440
441
        case Validity::List: {
441
442
            chooseType->setCurrentIndex(7);
451
452
            chooseType->setCurrentIndex(0);
452
453
            break;
453
454
        }
454
 
        switch (validity.action()) {
455
 
        case Validity::Stop:
456
 
            chooseAction->setCurrentIndex(0);
457
 
            break;
458
 
        case Validity::Warning:
459
 
            chooseAction->setCurrentIndex(1);
460
 
            break;
461
 
        case Validity::Information:
462
 
            chooseAction->setCurrentIndex(2);
463
 
            break;
464
 
        default :
465
 
            chooseAction->setCurrentIndex(0);
466
 
            break;
467
 
        }
468
 
        switch (validity.condition()) {
469
 
        case Conditional::Equal:
470
 
            choose->setCurrentIndex(0);
471
 
            break;
472
 
        case Conditional::Superior:
473
 
            choose->setCurrentIndex(1);
474
 
            break;
475
 
        case Conditional::Inferior:
476
 
            choose->setCurrentIndex(2);
477
 
            break;
478
 
        case Conditional::SuperiorEqual:
479
 
            choose->setCurrentIndex(3);
480
 
            break;
481
 
        case Conditional::InferiorEqual:
482
 
            choose->setCurrentIndex(4);
483
 
            break;
484
 
        case Conditional::Between:
485
 
            choose->setCurrentIndex(5);
486
 
            break;
487
 
        case Conditional::Different:
488
 
            choose->setCurrentIndex(6);
489
 
            break;
490
 
        case Conditional::DifferentTo:
491
 
            choose->setCurrentIndex(7);
492
 
            break;
493
 
        default :
494
 
            choose->setCurrentIndex(0);
495
 
            break;
496
 
        }
 
455
        chooseAction->setCurrentIndex(chooseAction->findData(QVariant::fromValue(validity.action())));
 
456
        choose->setCurrentIndex(choose->findData(QVariant::fromValue(validity.condition())));
497
457
        displayMessage->setChecked(validity.displayMessage());
498
458
        allowEmptyCell->setChecked(validity.allowEmptyCell());
499
459
        titleHelp->setText(validity.titleInfo());
526
486
void ValidityDialog::OkPressed()
527
487
{
528
488
    const KLocale* locale = m_selection->activeSheet()->map()->calculationSettings()->locale();
 
489
    const ValueParser *const parser = m_selection->activeSheet()->map()->parser();
529
490
    Validity validity;
530
491
    if (chooseType->currentIndex() == 1) {
531
492
        bool ok;
587
548
        validity.setCondition(Conditional::Equal);
588
549
        validity.setMessage(message->toPlainText());
589
550
        validity.setTitle(title->text());
590
 
        validity.setMinimumValue(0);
591
 
        validity.setMaximumValue(0);
592
 
        validity.setMinimumTime(QTime(0, 0, 0));
593
 
        validity.setMaximumTime(QTime(0, 0, 0));
594
 
        validity.setMinimumDate(QDate(0, 0, 0));
595
 
        validity.setMaximumDate(QDate(0, 0, 0));
 
551
        validity.setMinimumValue(Value());
 
552
        validity.setMaximumValue(Value());
596
553
    } else {
597
 
        switch (chooseType->currentIndex()) {
598
 
        case 0:
599
 
            validity.setRestriction(Validity::None);
600
 
            break;
601
 
        case 1:
602
 
            validity.setRestriction(Validity::Number);
603
 
            break;
604
 
        case 2:
605
 
            validity.setRestriction(Validity::Integer);
606
 
            break;
607
 
        case 3:
608
 
            validity.setRestriction(Validity::Text);
609
 
            break;
610
 
        case 4:
611
 
            validity.setRestriction(Validity::Date);
612
 
            break;
613
 
        case 5:
614
 
            validity.setRestriction(Validity::Time);
615
 
            break;
616
 
        case 6:
617
 
            validity.setRestriction(Validity::TextLength);
618
 
            break;
619
 
        case 7:
620
 
            validity.setRestriction(Validity::List);
621
 
            break;
622
 
 
623
 
        default :
624
 
            break;
625
 
        }
626
 
        switch (chooseAction->currentIndex()) {
627
 
        case 0:
628
 
            validity.setAction(Validity::Stop);
629
 
            break;
630
 
        case 1:
631
 
            validity.setAction(Validity::Warning);
632
 
            break;
633
 
        case 2:
634
 
            validity.setAction(Validity::Information);
635
 
            break;
636
 
        default :
637
 
            break;
638
 
        }
639
 
        switch (choose->currentIndex()) {
640
 
        case 0:
641
 
            validity.setCondition(Conditional::Equal);
642
 
            break;
643
 
        case 1:
644
 
            validity.setCondition(Conditional::Superior);
645
 
            break;
646
 
        case 2:
647
 
            validity.setCondition(Conditional::Inferior);
648
 
            break;
649
 
        case 3:
650
 
            validity.setCondition(Conditional::SuperiorEqual);
651
 
            break;
652
 
        case 4:
653
 
            validity.setCondition(Conditional::InferiorEqual);
654
 
            break;
655
 
        case 5:
656
 
            validity.setCondition(Conditional::Between);
657
 
            break;
658
 
        case 6:
659
 
            validity.setCondition(Conditional::Different);
660
 
            break;
661
 
        case 7:
662
 
            validity.setCondition(Conditional::DifferentTo);
663
 
            break;
664
 
        default :
665
 
            break;
666
 
        }
 
554
        validity.setRestriction(chooseType->itemData(chooseType->currentIndex()).value<Validity::Restriction>());
 
555
        validity.setAction(chooseAction->itemData(chooseAction->currentIndex()).value<Validity::Action>());
 
556
        validity.setCondition(choose->itemData(choose->currentIndex()).value<Conditional::Type>());
667
557
        validity.setMessage(message->toPlainText());
668
558
        validity.setTitle(title->text());
669
 
        validity.setMinimumValue(0);
670
 
        validity.setMaximumValue(0);
671
 
        validity.setMinimumTime(QTime(0, 0, 0));
672
 
        validity.setMaximumTime(QTime(0, 0, 0));
673
 
        validity.setMinimumDate(QDate(0, 0, 0));
674
 
        validity.setMaximumDate(QDate(0, 0, 0));
 
559
        validity.setMinimumValue(Value());
 
560
        validity.setMaximumValue(Value());
675
561
 
676
562
        if (chooseType->currentIndex() == 1) {
677
563
            if (choose->currentIndex()  < 5) {
678
 
                validity.setMinimumValue(val_min->text().toDouble());
 
564
                validity.setMinimumValue(Value(val_min->text().toDouble()));
679
565
            } else {
680
 
                validity.setMinimumValue(qMin(val_min->text().toDouble(), val_max->text().toDouble()));
681
 
                validity.setMaximumValue(qMax(val_max->text().toDouble(), val_min->text().toDouble()));
 
566
                validity.setMinimumValue(Value(qMin(val_min->text().toDouble(), val_max->text().toDouble())));
 
567
                validity.setMaximumValue(Value(qMax(val_max->text().toDouble(), val_min->text().toDouble())));
682
568
            }
683
569
        } else if (chooseType->currentIndex() == 2 || chooseType->currentIndex() == 6) {
684
570
            if (choose->currentIndex()  < 5) {
685
 
                validity.setMinimumValue(val_min->text().toInt());
 
571
                validity.setMinimumValue(Value(val_min->text().toInt()));
686
572
            } else {
687
 
                validity.setMinimumValue(qMin(val_min->text().toInt(), val_max->text().toInt()));
688
 
                validity.setMaximumValue(qMax(val_max->text().toInt(), val_min->text().toInt()));
 
573
                validity.setMinimumValue(Value(qMin(val_min->text().toInt(), val_max->text().toInt())));
 
574
                validity.setMaximumValue(Value(qMax(val_max->text().toInt(), val_min->text().toInt())));
689
575
            }
690
576
        } else  if (chooseType->currentIndex() == 4) {
 
577
            const Value minValue = parser->tryParseDate(val_min->text());
 
578
            const Value maxValue = parser->tryParseDate(val_max->text());
691
579
            if (choose->currentIndex()  < 5) {
692
 
                validity.setMinimumDate(locale->readDate(val_min->text()));
 
580
                validity.setMinimumValue(minValue);
693
581
            } else {
694
 
                if (locale->readDate(val_min->text()) < locale->readDate(val_max->text())) {
695
 
                    validity.setMinimumDate(locale->readDate(val_min->text()));
696
 
                    validity.setMaximumDate(locale->readDate(val_max->text()));
 
582
                if (minValue.less(maxValue)) {
 
583
                    validity.setMinimumValue(minValue);
 
584
                    validity.setMaximumValue(maxValue);
697
585
                } else {
698
 
                    validity.setMinimumDate(locale->readDate(val_max->text()));
699
 
                    validity.setMaximumDate(locale->readDate(val_min->text()));
 
586
                    validity.setMinimumValue(maxValue);
 
587
                    validity.setMaximumValue(minValue);
700
588
                }
701
589
            }
702
590
        } else  if (chooseType->currentIndex() == 5) {
 
591
            const Value minValue = parser->tryParseTime(val_min->text());
 
592
            const Value maxValue = parser->tryParseTime(val_max->text());
703
593
            if (choose->currentIndex()  < 5) {
704
 
                validity.setMinimumTime(locale->readTime(val_min->text()));
 
594
                validity.setMinimumValue(minValue);
705
595
            } else {
706
 
                if (locale->readTime(val_min->text()) < locale->readTime(val_max->text())) {
707
 
                    validity.setMaximumTime(locale->readTime(val_max->text()));
708
 
                    validity.setMinimumTime(locale->readTime(val_min->text()));
 
596
                if (minValue.less(maxValue)) {
 
597
                    validity.setMaximumValue(maxValue);
 
598
                    validity.setMinimumValue(minValue);
709
599
                } else {
710
 
                    validity.setMaximumTime(locale->readTime(val_min->text()));
711
 
                    validity.setMinimumTime(locale->readTime(val_max->text()));
 
600
                    validity.setMaximumValue(minValue);
 
601
                    validity.setMinimumValue(maxValue);
712
602
                }
713
603
            }
714
604
        } else if (chooseType->currentIndex() == 7) {