FreeCAD

1
/***************************************************************************
2
 *   Copyright (c) 2022 Pierre-Louis Boyer <pierrelouis.boyer@gmail.com>   *
3
 *                                                                         *
4
 *   This file is part of the FreeCAD CAx development system.              *
5
 *                                                                         *
6
 *   This library is free software; you can redistribute it and/or         *
7
 *   modify it under the terms of the GNU Library General Public           *
8
 *   License as published by the Free Software Foundation; either          *
9
 *   version 2 of the License, or (at your option) any later version.      *
10
 *                                                                         *
11
 *   This library  is distributed in the hope that it will be useful,      *
12
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
13
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
14
 *   GNU Library General Public License for more details.                  *
15
 *                                                                         *
16
 *   You should have received a copy of the GNU Library General Public     *
17
 *   License along with this library; see the file COPYING.LIB. If not,    *
18
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
19
 *   Suite 330, Boston, MA  02111-1307, USA                                *
20
 *                                                                         *
21
 ***************************************************************************/
22

23

24
#include "PreCompiled.h"
25

26
#ifndef _PreComp_
27
#include <Inventor/events/SoKeyboardEvent.h>
28
#include <QApplication>
29
#include <QEvent>
30
#endif
31

32
#include "ui_SketcherToolDefaultWidget.h"
33
#include <Gui/Application.h>
34
#include <Gui/Document.h>
35
#include <Gui/BitmapFactory.h>
36
#include <Gui/ViewProvider.h>
37
#include <Gui/WaitCursor.h>
38
#include <Gui/PrefWidgets.h>
39
#include <Base/Tools.h>
40
#include <Base/UnitsApi.h>
41
#include <Base/Exception.h>
42

43

44
#include "ViewProviderSketch.h"
45

46
#include "SketcherToolDefaultWidget.h"
47

48
using namespace SketcherGui;
49
using namespace Gui::TaskView;
50

51

52
SketcherToolDefaultWidget::SketcherToolDefaultWidget(QWidget* parent)
53
    : QWidget(parent)
54
    , ui(new Ui_SketcherToolDefaultWidget)
55
    , blockParameterSlots(false)
56
    , blockParameterFocusPassing(false)
57
{
58
    ui->setupUi(this);
59

60
    // connecting the needed signals
61
    setupConnections();
62

63
    ui->parameterOne->installEventFilter(this);
64
    ui->parameterTwo->installEventFilter(this);
65
    ui->parameterThree->installEventFilter(this);
66
    ui->parameterFour->installEventFilter(this);
67
    ui->parameterFive->installEventFilter(this);
68
    ui->parameterSix->installEventFilter(this);
69

70
    reset();
71
}
72

73
SketcherToolDefaultWidget::~SketcherToolDefaultWidget() = default;
74

75
void SketcherToolDefaultWidget::setupConnections()
76
{
77
    connect(ui->parameterOne,
78
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
79
            this,
80
            &SketcherToolDefaultWidget::parameterOne_valueChanged);
81
    connect(ui->parameterTwo,
82
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
83
            this,
84
            &SketcherToolDefaultWidget::parameterTwo_valueChanged);
85
    connect(ui->parameterThree,
86
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
87
            this,
88
            &SketcherToolDefaultWidget::parameterThree_valueChanged);
89
    connect(ui->parameterFour,
90
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
91
            this,
92
            &SketcherToolDefaultWidget::parameterFour_valueChanged);
93
    connect(ui->parameterFive,
94
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
95
            this,
96
            &SketcherToolDefaultWidget::parameterFive_valueChanged);
97
    connect(ui->parameterSix,
98
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
99
            this,
100
            &SketcherToolDefaultWidget::parameterSix_valueChanged);
101
    connect(ui->parameterSeven,
102
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
103
            this,
104
            &SketcherToolDefaultWidget::parameterSeven_valueChanged);
105
    connect(ui->parameterEight,
106
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
107
            this,
108
            &SketcherToolDefaultWidget::parameterEight_valueChanged);
109
    connect(ui->parameterNine,
110
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
111
            this,
112
            &SketcherToolDefaultWidget::parameterNine_valueChanged);
113
    connect(ui->parameterTen,
114
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
115
            this,
116
            &SketcherToolDefaultWidget::parameterTen_valueChanged);
117
    connect(ui->checkBoxTS1,
118
            &QCheckBox::toggled,
119
            this,
120
            &SketcherToolDefaultWidget::checkBoxTS1_toggled);
121
    connect(ui->checkBoxTS2,
122
            &QCheckBox::toggled,
123
            this,
124
            &SketcherToolDefaultWidget::checkBoxTS2_toggled);
125
    connect(ui->checkBoxTS3,
126
            &QCheckBox::toggled,
127
            this,
128
            &SketcherToolDefaultWidget::checkBoxTS3_toggled);
129
    connect(ui->checkBoxTS4,
130
            &QCheckBox::toggled,
131
            this,
132
            &SketcherToolDefaultWidget::checkBoxTS4_toggled);
133
    connect(ui->comboBox1,
134
            qOverload<int>(&QComboBox::currentIndexChanged),
135
            this,
136
            &SketcherToolDefaultWidget::comboBox1_currentIndexChanged);
137
    connect(ui->comboBox2,
138
            qOverload<int>(&QComboBox::currentIndexChanged),
139
            this,
140
            &SketcherToolDefaultWidget::comboBox2_currentIndexChanged);
141
    connect(ui->comboBox3,
142
            qOverload<int>(&QComboBox::currentIndexChanged),
143
            this,
144
            &SketcherToolDefaultWidget::comboBox3_currentIndexChanged);
145
}
146

147
// pre-select the number of the spinbox when it gets the focus.
148
bool SketcherToolDefaultWidget::eventFilter(QObject* object, QEvent* event)
149
{
150
    if (event->type() == QEvent::FocusIn) {
151
        for (int i = 0; i < nParameters; i++) {
152
            auto parameterSpinBox = getParameterSpinBox(i);
153

154
            if (object == parameterSpinBox) {
155
                parameterSpinBox->selectNumber();
156
                break;
157
            }
158
        }
159
    }
160
    else if (event->type() == QEvent::KeyPress) {
161
        QKeyEvent* ke = static_cast<QKeyEvent*>(event);
162
        if (ke->key() == Qt::Key_Tab || ke->key() == Qt::Key_Return) {
163
            for (int i = 0; i < nParameters; i++) {
164
                if (object == getParameterSpinBox(i)) {
165
                    signalParameterTabOrEnterPressed(i);
166
                    return true;
167
                }
168
            }
169
        }
170
    }
171

172
    return false;
173
}
174

175
void SketcherToolDefaultWidget::reset()
176
{
177
    Base::StateLocker lock(blockParameterSlots, true);
178

179
    std::fill(isSet.begin(), isSet.end(), false);
180

181
    for (int i = 0; i < nParameters; i++) {
182
        setParameterVisible(i, false);
183
        setParameter(i, 0.F);
184
    }
185

186
    for (int i = 0; i < nCheckbox; i++) {
187
        setCheckboxVisible(i, false);
188
        setCheckboxChecked(i, false);
189
        setCheckboxPrefEntry(i, "");
190
    }
191
    for (int i = 0; i < nCombobox; i++) {
192
        setComboboxVisible(i, false);
193
        setComboboxIndex(i, 0);
194
        getComboBox(i)->clear();
195
    }
196

197
    setNoticeVisible(false);
198
}
199

200
void SketcherToolDefaultWidget::setNoticeText(const QString& string)
201
{
202
    ui->notice->setText(string);
203
}
204
void SketcherToolDefaultWidget::setNoticeVisible(bool visible)
205
{
206
    ui->notice->setVisible(visible);
207
}
208

209
// Spinboxes functions
210
void SketcherToolDefaultWidget::parameterOne_valueChanged(double val)
211
{
212
    if (!blockParameterSlots) {
213
        isSet[Parameter::First] = true;
214
        /*setParameterFontStyle(Parameter::First, FontStyle::Bold);
215
        if (!blockParameterFocusPassing) {
216
            setParameterFocus(Parameter::Second);
217
        }*/
218
        signalParameterValueChanged(Parameter::First, val);
219
    }
220
}
221
void SketcherToolDefaultWidget::parameterTwo_valueChanged(double val)
222
{
223
    if (!blockParameterSlots) {
224
        isSet[Parameter::Second] = true;
225
        signalParameterValueChanged(Parameter::Second, val);
226
    }
227
}
228
void SketcherToolDefaultWidget::parameterThree_valueChanged(double val)
229
{
230
    if (!blockParameterSlots) {
231
        isSet[Parameter::Third] = true;
232
        signalParameterValueChanged(Parameter::Third, val);
233
    }
234
}
235
void SketcherToolDefaultWidget::parameterFour_valueChanged(double val)
236
{
237
    if (!blockParameterSlots) {
238
        isSet[Parameter::Fourth] = true;
239
        signalParameterValueChanged(Parameter::Fourth, val);
240
    }
241
}
242
void SketcherToolDefaultWidget::parameterFive_valueChanged(double val)
243
{
244
    if (!blockParameterSlots) {
245
        isSet[Parameter::Fifth] = true;
246
        signalParameterValueChanged(Parameter::Fifth, val);
247
    }
248
}
249
void SketcherToolDefaultWidget::parameterSix_valueChanged(double val)
250
{
251
    if (!blockParameterSlots) {
252
        isSet[Parameter::Sixth] = true;
253
        signalParameterValueChanged(Parameter::Sixth, val);
254
    }
255
}
256
void SketcherToolDefaultWidget::parameterSeven_valueChanged(double val)
257
{
258
    if (!blockParameterSlots) {
259
        isSet[Parameter::Seventh] = true;
260
        signalParameterValueChanged(Parameter::Seventh, val);
261
    }
262
}
263
void SketcherToolDefaultWidget::parameterEight_valueChanged(double val)
264
{
265
    if (!blockParameterSlots) {
266
        isSet[Parameter::Eighth] = true;
267
        signalParameterValueChanged(Parameter::Eighth, val);
268
    }
269
}
270
void SketcherToolDefaultWidget::parameterNine_valueChanged(double val)
271
{
272
    if (!blockParameterSlots) {
273
        isSet[Parameter::Ninth] = true;
274
        signalParameterValueChanged(Parameter::Ninth, val);
275
    }
276
}
277
void SketcherToolDefaultWidget::parameterTen_valueChanged(double val)
278
{
279
    if (!blockParameterSlots) {
280
        isSet[Parameter::Tenth] = true;
281
        signalParameterValueChanged(Parameter::Tenth, val);
282
    }
283
}
284

285
void SketcherToolDefaultWidget::initNParameters(int nparameters, QObject* filteringObject)
286
{
287
    Base::StateLocker lock(blockParameterSlots, true);
288

289
    isSet.resize(nparameters);
290

291
    std::fill(isSet.begin(), isSet.end(), false);
292

293
    for (int i = 0; i < nParameters; i++) {
294
        setParameterVisible(i, (i < nparameters));
295
        setParameter(i, 0.F);
296
        setParameterFilteringObject(i, filteringObject);
297
        // setParameterFontStyle(i, FontStyle::Italic);
298
    }
299

300
    setParameterFocus(Parameter::First);
301
}
302

303
void SketcherToolDefaultWidget::setParameterVisible(int parameterindex, bool visible)
304
{
305
    if (parameterindex < nParameters) {
306
        getParameterLabel(parameterindex)->setVisible(visible);
307
        getParameterSpinBox(parameterindex)->setVisible(visible);
308
    }
309
}
310

311
void SketcherToolDefaultWidget::setParameterFilteringObject(int parameterindex,
312
                                                            QObject* filteringObject)
313
{
314
    if (parameterindex < nParameters) {
315
        getParameterSpinBox(parameterindex)->installEventFilter(filteringObject);
316

317
        return;
318
    }
319

320
    THROWM(Base::IndexError,
321
           QT_TRANSLATE_NOOP("Exceptions", "ToolWidget parameter index out of range"));
322
}
323

324
void SketcherToolDefaultWidget::setParameterLabel(int parameterindex, const QString& string)
325
{
326
    if (parameterindex < nParameters) {
327
        getParameterLabel(parameterindex)->setText(string);
328
    }
329
}
330

331
void SketcherToolDefaultWidget::setParameter(int parameterindex, double val)
332
{
333
    if (parameterindex < nParameters) {
334
        getParameterSpinBox(parameterindex)->setValue(val);
335

336
        return;
337
    }
338

339
    THROWM(Base::IndexError,
340
           QT_TRANSLATE_NOOP("Exceptions", "ToolWidget parameter index out of range"));
341
}
342

343
void SketcherToolDefaultWidget::setParameterWithoutPassingFocus(int parameterindex, double val)
344
{
345
    Base::StateLocker lock(blockParameterFocusPassing, true);
346
    setParameter(parameterindex, val);
347
}
348

349
void SketcherToolDefaultWidget::configureParameterInitialValue(int parameterindex, double val)
350
{
351
    Base::StateLocker lock(blockParameterSlots, true);
352
    setParameter(parameterindex, val);
353
}
354

355
void SketcherToolDefaultWidget::configureParameterUnit(int parameterindex, const Base::Unit& unit)
356
{
357
    // For reference unit can be changed with :
358
    // setUnit(Base::Unit::Length); Base::Unit::Angle
359
    Base::StateLocker lock(blockParameterSlots, true);
360
    if (parameterindex < nParameters) {
361
        getParameterSpinBox(parameterindex)->setUnit(unit);
362

363
        return;
364
    }
365

366
    THROWM(Base::IndexError,
367
           QT_TRANSLATE_NOOP("Exceptions", "ToolWidget parameter index out of range"));
368
}
369

370
void SketcherToolDefaultWidget::configureParameterDecimals(int parameterindex, int val)
371
{
372
    Base::StateLocker lock(blockParameterSlots, true);
373
    if (parameterindex < nParameters) {
374
        getParameterSpinBox(parameterindex)->setDecimals(val);
375

376
        return;
377
    }
378

379
    THROWM(Base::IndexError,
380
           QT_TRANSLATE_NOOP("Exceptions", "ToolWidget parameter index out of range"));
381
}
382

383
void SketcherToolDefaultWidget::configureParameterMin(int parameterindex, double val)
384
{
385
    Base::StateLocker lock(blockParameterSlots, true);
386
    if (parameterindex < nParameters) {
387
        getParameterSpinBox(parameterindex)->setMinimum(val);
388

389
        return;
390
    }
391

392
    THROWM(Base::IndexError,
393
           QT_TRANSLATE_NOOP("Exceptions", "ToolWidget parameter index out of range"));
394
}
395

396
void SketcherToolDefaultWidget::configureParameterMax(int parameterindex, double val)
397
{
398
    Base::StateLocker lock(blockParameterSlots, true);
399
    if (parameterindex < nParameters) {
400
        getParameterSpinBox(parameterindex)->setMaximum(val);
401

402
        return;
403
    }
404

405
    THROWM(Base::IndexError,
406
           QT_TRANSLATE_NOOP("Exceptions", "ToolWidget parameter index out of range"));
407
}
408

409
void SketcherToolDefaultWidget::setParameterEnabled(int parameterindex, bool active)
410
{
411
    if (parameterindex < nParameters) {
412
        getParameterSpinBox(parameterindex)->setEnabled(active);
413

414
        return;
415
    }
416

417
    THROWM(Base::IndexError,
418
           QT_TRANSLATE_NOOP("Exceptions", "ToolWidget parameter index out of range"));
419
}
420

421
void SketcherToolDefaultWidget::setParameterFocus(int parameterindex)
422
{
423
    if (parameterindex < nParameters) {
424
        auto parameterSpinBox = getParameterSpinBox(parameterindex);
425
        parameterSpinBox->selectNumber();
426
        QMetaObject::invokeMethod(parameterSpinBox, "setFocus", Qt::QueuedConnection);
427

428
        return;
429
    }
430

431
    THROWM(Base::IndexError,
432
           QT_TRANSLATE_NOOP("Exceptions", "ToolWidget parameter index out of range"));
433
}
434

435
void SketcherToolDefaultWidget::setParameterFontStyle(int parameterindex, FontStyle fontStyle)
436
{
437
    if (parameterindex < nParameters) {
438
        auto parameterSpinBox = getParameterSpinBox(parameterindex);
439

440
        switch (fontStyle) {
441
            case FontStyle::Italic:
442
                parameterSpinBox->setStyleSheet(QStringLiteral("font-weight: normal;"));
443
                parameterSpinBox->setStyleSheet(QStringLiteral("font-style: italic;"));
444
                break;
445
            case FontStyle::Bold:
446
                parameterSpinBox->setStyleSheet(QStringLiteral("font-style: normal;"));
447
                parameterSpinBox->setStyleSheet(QStringLiteral("font-weight: bold;"));
448
                break;
449
            case FontStyle::Normal:
450
                parameterSpinBox->setStyleSheet(QStringLiteral("font-style: normal;"));
451
                parameterSpinBox->setStyleSheet(QStringLiteral("font-weight: normal;"));
452
                break;
453
        }
454

455
        return;
456
    }
457

458
    THROWM(Base::IndexError,
459
           QT_TRANSLATE_NOOP("Exceptions", "ToolWidget parameter index out of range"));
460
}
461

462
QLabel* SketcherToolDefaultWidget::getParameterLabel(int parameterindex)
463
{
464
    switch (parameterindex) {
465
        case Parameter::First:
466
            return ui->label;
467
            break;
468
        case Parameter::Second:
469
            return ui->label2;
470
            break;
471
        case Parameter::Third:
472
            return ui->label3;
473
            break;
474
        case Parameter::Fourth:
475
            return ui->label4;
476
            break;
477
        case Parameter::Fifth:
478
            return ui->label5;
479
            break;
480
        case Parameter::Sixth:
481
            return ui->label6;
482
            break;
483
        case Parameter::Seventh:
484
            return ui->label7;
485
            break;
486
        case Parameter::Eighth:
487
            return ui->label8;
488
            break;
489
        case Parameter::Ninth:
490
            return ui->label9;
491
            break;
492
        case Parameter::Tenth:
493
            return ui->label10;
494
            break;
495
        default:
496
            THROWM(Base::IndexError, "ToolWidget spinbox index out of range");
497
    }
498
}
499

500
Gui::PrefQuantitySpinBox* SketcherToolDefaultWidget::getParameterSpinBox(int parameterindex)
501
{
502
    switch (parameterindex) {
503
        case Parameter::First:
504
            return ui->parameterOne;
505
            break;
506
        case Parameter::Second:
507
            return ui->parameterTwo;
508
            break;
509
        case Parameter::Third:
510
            return ui->parameterThree;
511
            break;
512
        case Parameter::Fourth:
513
            return ui->parameterFour;
514
            break;
515
        case Parameter::Fifth:
516
            return ui->parameterFive;
517
            break;
518
        case Parameter::Sixth:
519
            return ui->parameterSix;
520
            break;
521
        case Parameter::Seventh:
522
            return ui->parameterSeven;
523
            break;
524
        case Parameter::Eighth:
525
            return ui->parameterEight;
526
            break;
527
        case Parameter::Ninth:
528
            return ui->parameterNine;
529
            break;
530
        case Parameter::Tenth:
531
            return ui->parameterTen;
532
            break;
533
        default:
534
            THROWM(Base::IndexError, "ToolWidget spinbox index out of range");
535
    }
536
}
537

538
double SketcherToolDefaultWidget::getParameter(int parameterindex)
539
{
540
    if (parameterindex < nParameters) {
541
        return getParameterSpinBox(parameterindex)->value().getValue();
542
    }
543

544
    THROWM(Base::IndexError, "ToolWidget parameter index out of range");
545
}
546

547
bool SketcherToolDefaultWidget::isParameterSet(int parameterindex)
548
{
549
    if (parameterindex < nParameters) {
550
        return isSet[parameterindex];
551
    }
552

553
    THROWM(Base::IndexError, "ToolWidget parameter index out of range");
554
}
555

556
void SketcherToolDefaultWidget::updateVisualValue(int parameterindex,
557
                                                  double val,
558
                                                  const Base::Unit& unit)
559
{
560
    if (parameterindex < nParameters) {
561
        Base::StateLocker lock(blockParameterSlots, true);
562

563
        auto parameterSpinBox = getParameterSpinBox(parameterindex);
564

565
        parameterSpinBox->setValue(Base::Quantity(val, unit));
566

567
        if (parameterSpinBox->hasFocus()) {
568
            parameterSpinBox->selectNumber();
569
        }
570

571
        return;
572
    }
573

574
    THROWM(Base::IndexError,
575
           QT_TRANSLATE_NOOP("Exceptions", "ToolWidget parameter index out of range"));
576
}
577

578
// checkbox functions
579
void SketcherToolDefaultWidget::checkBoxTS1_toggled(bool val)
580
{
581
    if (!blockParameterSlots) {
582
        if (!isCheckBoxPrefEntryEmpty(Checkbox::FirstBox)) {
583
            ui->checkBoxTS1->onSave();
584
        }
585
        signalCheckboxCheckedChanged(Checkbox::FirstBox, val);
586
    }
587
}
588
void SketcherToolDefaultWidget::checkBoxTS2_toggled(bool val)
589
{
590
    if (!blockParameterSlots) {
591
        if (!isCheckBoxPrefEntryEmpty(Checkbox::SecondBox)) {
592
            ui->checkBoxTS2->onSave();
593
        }
594
        signalCheckboxCheckedChanged(Checkbox::SecondBox, val);
595
    }
596
}
597
void SketcherToolDefaultWidget::checkBoxTS3_toggled(bool val)
598
{
599
    if (!blockParameterSlots) {
600
        if (!isCheckBoxPrefEntryEmpty(Checkbox::ThirdBox)) {
601
            ui->checkBoxTS3->onSave();
602
        }
603
        signalCheckboxCheckedChanged(Checkbox::ThirdBox, val);
604
    }
605
}
606
void SketcherToolDefaultWidget::checkBoxTS4_toggled(bool val)
607
{
608
    if (!blockParameterSlots) {
609
        if (!isCheckBoxPrefEntryEmpty(Checkbox::FourthBox)) {
610
            ui->checkBoxTS4->onSave();
611
        }
612
        signalCheckboxCheckedChanged(Checkbox::FourthBox, val);
613
    }
614
}
615

616
void SketcherToolDefaultWidget::initNCheckboxes(int ncheckbox)
617
{
618
    Base::StateLocker lock(blockParameterSlots, true);
619

620
    for (int i = 0; i < nCheckbox; i++) {
621
        setCheckboxVisible(i, (i < ncheckbox));
622
        setCheckboxChecked(i, false);
623
    }
624
}
625

626
void SketcherToolDefaultWidget::setCheckboxVisible(int checkboxindex, bool visible)
627
{
628
    if (checkboxindex < nCheckbox) {
629
        getCheckBox(checkboxindex)->setVisible(visible);
630
    }
631
}
632

633
void SketcherToolDefaultWidget::setCheckboxChecked(int checkboxindex, bool checked)
634
{
635
    if (checkboxindex < nCheckbox) {
636
        getCheckBox(checkboxindex)->setChecked(checked);
637
    }
638
}
639

640
void SketcherToolDefaultWidget::setCheckboxLabel(int checkboxindex, const QString& string)
641
{
642
    if (checkboxindex < nCheckbox) {
643
        getCheckBox(checkboxindex)->setText(string);
644
    }
645
}
646

647
void SketcherToolDefaultWidget::setCheckboxToolTip(int checkboxindex, const QString& string)
648
{
649
    if (checkboxindex < nCheckbox) {
650
        getCheckBox(checkboxindex)->setToolTip(string);
651
    }
652
}
653

654
Gui::PrefCheckBox* SketcherToolDefaultWidget::getCheckBox(int checkboxindex)
655
{
656
    switch (checkboxindex) {
657
        case Checkbox::FirstBox:
658
            return ui->checkBoxTS1;
659
            break;
660
        case Checkbox::SecondBox:
661
            return ui->checkBoxTS2;
662
            break;
663
        case Checkbox::ThirdBox:
664
            return ui->checkBoxTS3;
665
            break;
666
        case Checkbox::FourthBox:
667
            return ui->checkBoxTS4;
668
            break;
669
        default:
670
            THROWM(Base::IndexError, "ToolWidget checkbox index out of range");
671
    }
672
}
673

674
bool SketcherToolDefaultWidget::getCheckboxChecked(int checkboxindex)
675
{
676
    if (checkboxindex < nParameters) {
677
        return getCheckBox(checkboxindex)->isChecked();
678
    }
679

680
    THROWM(Base::IndexError, "ToolWidget checkbox index out of range");
681
}
682

683
void SketcherToolDefaultWidget::setCheckboxPrefEntry(int checkboxindex,
684
                                                     const std::string& prefEntry)
685
{
686
    if (checkboxindex < nCheckbox) {
687
        QByteArray byteArray(prefEntry.c_str(), prefEntry.length());
688
        getCheckBox(checkboxindex)->setEntryName(byteArray);
689
    }
690
}
691

692
void SketcherToolDefaultWidget::restoreCheckBoxPref(int checkboxindex)
693
{
694
    if (checkboxindex < nCheckbox) {
695
        getCheckBox(checkboxindex)->onRestore();
696
    }
697
}
698

699
void SketcherToolDefaultWidget::setCheckboxIcon(int checkboxindex, QIcon icon)
700
{
701
    if (checkboxindex < nCheckbox) {
702
        getCheckBox(checkboxindex)->setIcon(icon);
703
    }
704
}
705

706
void SketcherToolDefaultWidget::setComboboxItemIcon(int comboboxindex, int index, QIcon icon)
707
{
708
    if (comboboxindex < nCombobox) {
709
        getComboBox(comboboxindex)->setItemIcon(index, icon);
710
    }
711
}
712

713
void SketcherToolDefaultWidget::setComboboxPrefEntry(int comboboxindex,
714
                                                     const std::string& prefEntry)
715
{
716
    if (comboboxindex < nCombobox) {
717
        QByteArray byteArray(prefEntry.c_str(), prefEntry.length());
718
        getComboBox(comboboxindex)->setEntryName(byteArray);
719
    }
720
}
721

722
void SketcherToolDefaultWidget::restoreComboboxPref(int comboboxindex)
723
{
724
    if (comboboxindex < nCombobox) {
725
        getComboBox(comboboxindex)->onRestore();
726
    }
727
}
728

729
bool SketcherToolDefaultWidget::isCheckBoxPrefEntryEmpty(int checkboxindex)
730
{
731
    return getCheckBox(checkboxindex)->entryName().size() == 0;
732
}
733

734
// Combobox functions
735
void SketcherToolDefaultWidget::comboBox1_currentIndexChanged(int val)
736
{
737
    if (!blockParameterSlots) {
738
        signalComboboxSelectionChanged(Combobox::FirstCombo, val);
739
    }
740
    ui->comboBox1->onSave();
741
}
742
void SketcherToolDefaultWidget::comboBox2_currentIndexChanged(int val)
743
{
744
    if (!blockParameterSlots) {
745
        signalComboboxSelectionChanged(Combobox::SecondCombo, val);
746
    }
747
    ui->comboBox2->onSave();
748
}
749
void SketcherToolDefaultWidget::comboBox3_currentIndexChanged(int val)
750
{
751
    if (!blockParameterSlots) {
752
        signalComboboxSelectionChanged(Combobox::ThirdCombo, val);
753
    }
754
    ui->comboBox3->onSave();
755
}
756

757
void SketcherToolDefaultWidget::initNComboboxes(int ncombobox)
758
{
759
    Base::StateLocker lock(blockParameterSlots, true);
760

761
    for (int i = 0; i < nCombobox; i++) {
762
        setComboboxVisible(i, (i < ncombobox));
763
    }
764
}
765

766
void SketcherToolDefaultWidget::setComboboxVisible(int comboboxindex, bool visible)
767
{
768
    if (comboboxindex < nCombobox) {
769
        getComboBox(comboboxindex)->setVisible(visible);
770
        getComboBoxLabel(comboboxindex)->setVisible(visible);
771
    }
772
}
773

774
void SketcherToolDefaultWidget::setComboboxIndex(int comboboxindex, int value)
775
{
776
    if (comboboxindex < nCombobox) {
777
        getComboBox(comboboxindex)->setCurrentIndex(value);
778
    }
779
}
780

781
void SketcherToolDefaultWidget::setComboboxLabel(int comboboxindex, const QString& string)
782
{
783
    if (comboboxindex < nCombobox) {
784
        getComboBoxLabel(comboboxindex)->setText(string);
785
    }
786
}
787

788
void SketcherToolDefaultWidget::setComboboxElements(int comboboxindex, const QStringList& names)
789
{
790
    if (comboboxindex < nCombobox) {
791
        getComboBox(comboboxindex)->clear();
792
        getComboBox(comboboxindex)->addItems(names);
793
    }
794
}
795

796
Gui::PrefComboBox* SketcherToolDefaultWidget::getComboBox(int comboboxindex)
797
{
798
    switch (comboboxindex) {
799
        case Combobox::FirstCombo:
800
            return ui->comboBox1;
801
            break;
802
        case Combobox::SecondCombo:
803
            return ui->comboBox2;
804
            break;
805
        case Combobox::ThirdCombo:
806
            return ui->comboBox3;
807
            break;
808
        default:
809
            THROWM(Base::IndexError, "ToolWidget combobox index out of range");
810
    }
811
}
812
QLabel* SketcherToolDefaultWidget::getComboBoxLabel(int comboboxindex)
813
{
814
    switch (comboboxindex) {
815
        case Combobox::FirstCombo:
816
            return ui->comboLabel1;
817
            break;
818
        case Combobox::SecondCombo:
819
            return ui->comboLabel2;
820
            break;
821
        case Combobox::ThirdCombo:
822
            return ui->comboLabel3;
823
            break;
824
        default:
825
            THROWM(Base::IndexError, "ToolWidget combobox index out of range");
826
    }
827
}
828

829
int SketcherToolDefaultWidget::getComboboxIndex(int comboboxindex)
830
{
831
    if (comboboxindex < nCombobox) {
832
        return getComboBox(comboboxindex)->currentIndex();
833
    }
834

835
    THROWM(Base::IndexError, "ToolWidget combobox index out of range");
836
}
837

838

839
void SketcherToolDefaultWidget::changeEvent(QEvent* ev)
840
{
841
    QWidget::changeEvent(ev);
842
    if (ev->type() == QEvent::LanguageChange) {
843
        ui->retranslateUi(this);
844
    }
845
}
846

847
#include "moc_SketcherToolDefaultWidget.cpp"
848