FreeCAD

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

24
#include "PreCompiled.h"
25
#ifndef _PreComp_
26
#include <QAction>
27
#include <QMenu>
28
#include <QMessageBox>
29
#include <QTimer>
30
#include <TopExp.hxx>
31
#include <TopTools_IndexedMapOfShape.hxx>
32
#endif
33

34
#include <App/Document.h>
35
#include <Base/Console.h>
36
#include <Gui/Application.h>
37
#include <Gui/BitmapFactory.h>
38
#include <Gui/Command.h>
39
#include <Gui/Control.h>
40
#include <Gui/Document.h>
41
#include <Gui/SelectionObject.h>
42
#include <Gui/Widgets.h>
43
#include <Mod/Part/Gui/ViewProvider.h>
44

45
#include "TaskGeomFillSurface.h"
46
#include "ui_TaskGeomFillSurface.h"
47

48

49
using namespace SurfaceGui;
50

51
PROPERTY_SOURCE(SurfaceGui::ViewProviderGeomFillSurface, PartGui::ViewProviderSpline)
52

53
namespace SurfaceGui
54
{
55

56
void ViewProviderGeomFillSurface::setupContextMenu(QMenu* menu,
57
                                                   QObject* receiver,
58
                                                   const char* member)
59
{
60
    QAction* act;
61
    act = menu->addAction(QObject::tr("Edit filling"), receiver, member);
62
    act->setData(QVariant((int)ViewProvider::Default));
63
    PartGui::ViewProviderSpline::setupContextMenu(menu, receiver, member);
64
}
65

66
bool ViewProviderGeomFillSurface::setEdit(int ModNum)
67
{
68
    if (ModNum == ViewProvider::Default) {
69
        // When double-clicking on the item for this sketch the
70
        // object unsets and sets its edit mode without closing
71
        // the task panel
72

73
        Surface::GeomFillSurface* obj = static_cast<Surface::GeomFillSurface*>(this->getObject());
74

75
        Gui::TaskView::TaskDialog* dlg = Gui::Control().activeDialog();
76

77
        // start the edit dialog
78
        if (dlg) {
79
            TaskGeomFillSurface* tDlg = qobject_cast<TaskGeomFillSurface*>(dlg);
80
            if (tDlg) {
81
                tDlg->setEditedObject(obj);
82
            }
83
            Gui::Control().showDialog(dlg);
84
        }
85
        else {
86
            Gui::Control().showDialog(new TaskGeomFillSurface(this, obj));
87
        }
88
        return true;
89
    }
90
    else {
91
        return ViewProviderSpline::setEdit(ModNum);
92
    }
93
}
94

95
void ViewProviderGeomFillSurface::unsetEdit(int ModNum)
96
{
97
    if (ModNum == ViewProvider::Default) {
98
        // when pressing ESC make sure to close the dialog
99
        QTimer::singleShot(0, &Gui::Control(), &Gui::ControlSingleton::closeDialog);
100
    }
101
    else {
102
        PartGui::ViewProviderSpline::unsetEdit(ModNum);
103
    }
104
}
105

106
QIcon ViewProviderGeomFillSurface::getIcon() const
107
{
108
    return Gui::BitmapFactory().pixmap("Surface_BSplineSurface");
109
}
110

111
void ViewProviderGeomFillSurface::highlightReferences(bool on)
112
{
113
    Surface::GeomFillSurface* surface = static_cast<Surface::GeomFillSurface*>(getObject());
114
    auto bounds = surface->BoundaryList.getSubListValues();
115
    for (const auto& it : bounds) {
116
        Part::Feature* base = dynamic_cast<Part::Feature*>(it.first);
117
        if (base) {
118
            PartGui::ViewProviderPartExt* svp = dynamic_cast<PartGui::ViewProviderPartExt*>(
119
                Gui::Application::Instance->getViewProvider(base));
120
            if (svp) {
121
                if (on) {
122
                    std::vector<App::Color> colors;
123
                    TopTools_IndexedMapOfShape eMap;
124
                    TopExp::MapShapes(base->Shape.getValue(), TopAbs_EDGE, eMap);
125
                    colors.resize(eMap.Extent(), svp->LineColor.getValue());
126

127
                    for (const auto& jt : it.second) {
128
                        std::size_t idx = static_cast<std::size_t>(std::stoi(jt.substr(4)) - 1);
129
                        assert(idx < colors.size());
130
                        colors[idx] = App::Color(1.0, 0.0, 1.0);  // magenta
131
                    }
132

133
                    svp->setHighlightedEdges(colors);
134
                }
135
                else {
136
                    svp->unsetHighlightedEdges();
137
                }
138
            }
139
        }
140
    }
141
}
142

143
// ----------------------------------------------------------------------------
144

145
class GeomFillSurface::EdgeSelection: public Gui::SelectionFilterGate
146
{
147
public:
148
    EdgeSelection(bool appendEdges, Surface::GeomFillSurface* editedObject)
149
        : Gui::SelectionFilterGate(nullPointer())
150
        , appendEdges(appendEdges)
151
        , editedObject(editedObject)
152
    {}
153
    /**
154
     * Allow the user to pick only edges.
155
     */
156
    bool allow(App::Document* pDoc, App::DocumentObject* pObj, const char* sSubName) override;
157

158
private:
159
    bool appendEdges;
160
    Surface::GeomFillSurface* editedObject;
161
};
162

163
bool GeomFillSurface::EdgeSelection::allow(App::Document*,
164
                                           App::DocumentObject* pObj,
165
                                           const char* sSubName)
166
{
167
    // don't allow references to itself
168
    if (pObj == editedObject) {
169
        return false;
170
    }
171
    if (!pObj->isDerivedFrom(Part::Feature::getClassTypeId())) {
172
        return false;
173
    }
174

175
    if (!sSubName || sSubName[0] == '\0') {
176
        return false;
177
    }
178

179
    std::string element(sSubName);
180
    if (element.substr(0, 4) != "Edge") {
181
        return false;
182
    }
183

184
    auto links = editedObject->BoundaryList.getSubListValues();
185
    for (const auto& it : links) {
186
        if (it.first == pObj) {
187
            for (const auto& jt : it.second) {
188
                if (jt == sSubName) {
189
                    return !appendEdges;
190
                }
191
            }
192
        }
193
    }
194

195
    return appendEdges;
196
}
197

198
// ----------------------------------------------------------------------------
199

200
GeomFillSurface::GeomFillSurface(ViewProviderGeomFillSurface* vp, Surface::GeomFillSurface* obj)
201
{
202
    ui = new Ui_GeomFillSurface();
203
    ui->setupUi(this);
204
    setupConnections();
205

206
    selectionMode = None;
207
    this->vp = vp;
208
    checkCommand = true;
209
    setEditedObject(obj);
210

211
    // Set up button group
212
    buttonGroup = new Gui::ButtonGroup(this);
213
    buttonGroup->setExclusive(true);
214
    buttonGroup->addButton(ui->buttonEdgeAdd, (int)SelectionMode::Append);
215
    buttonGroup->addButton(ui->buttonEdgeRemove, (int)SelectionMode::Remove);
216

217
    // Create context menu
218
    QAction* remove = new QAction(tr("Remove"), this);
219
    remove->setShortcut(QString::fromLatin1("Del"));
220
    ui->listWidget->addAction(remove);
221
    connect(remove, &QAction::triggered, this, &GeomFillSurface::onDeleteEdge);
222

223
    QAction* orientation = new QAction(tr("Flip orientation"), this);
224
    ui->listWidget->addAction(orientation);
225
    connect(orientation, &QAction::triggered, this, &GeomFillSurface::onFlipOrientation);
226

227
    ui->listWidget->setContextMenuPolicy(Qt::ActionsContextMenu);
228
}
229

230
/*
231
 *  Destroys the object and frees any allocated resources
232
 */
233
GeomFillSurface::~GeomFillSurface()
234
{
235
    // no need to delete child widgets, Qt does it all for us
236
    delete ui;
237
}
238

239
void GeomFillSurface::setupConnections()
240
{
241
    connect(ui->fillType_stretch,
242
            &QRadioButton::clicked,
243
            this,
244
            &GeomFillSurface::onFillTypeStretchClicked);
245
    connect(ui->fillType_coons,
246
            &QRadioButton::clicked,
247
            this,
248
            &GeomFillSurface::onFillTypeCoonsClicked);
249
    connect(ui->fillType_curved,
250
            &QRadioButton::clicked,
251
            this,
252
            &GeomFillSurface::onFillTypeCurvedClicked);
253
    connect(ui->buttonEdgeAdd,
254
            &QToolButton::toggled,
255
            this,
256
            &GeomFillSurface::onButtonEdgeAddToggled);
257
    connect(ui->buttonEdgeRemove,
258
            &QToolButton::toggled,
259
            this,
260
            &GeomFillSurface::onButtonEdgeRemoveToggled);
261
    connect(ui->listWidget,
262
            &QListWidget::itemDoubleClicked,
263
            this,
264
            &GeomFillSurface::onListWidgetItemDoubleClicked);
265
}
266

267
// stores object pointer, its old fill type and adjusts radio buttons according to it.
268
void GeomFillSurface::setEditedObject(Surface::GeomFillSurface* obj)
269
{
270
    editedObject = obj;
271
    GeomFill_FillingStyle curtype =
272
        static_cast<GeomFill_FillingStyle>(editedObject->FillType.getValue());
273
    switch (curtype) {
274
        case GeomFill_StretchStyle:
275
            ui->fillType_stretch->setChecked(true);
276
            break;
277
        case GeomFill_CoonsStyle:
278
            ui->fillType_coons->setChecked(true);
279
            break;
280
        case GeomFill_CurvedStyle:
281
            ui->fillType_curved->setChecked(true);
282
            break;
283
        default:
284
            break;
285
    }
286

287
    auto objects = editedObject->BoundaryList.getValues();
288
    auto element = editedObject->BoundaryList.getSubValues();
289
    auto boolean = editedObject->ReversedList.getValues();
290
    auto it = objects.begin();
291
    auto jt = element.begin();
292
    std::size_t index = 0;
293

294
    QPixmap rotateLeft = Gui::BitmapFactory().pixmap("view-rotate-left");
295
    QPixmap rotateRight = Gui::BitmapFactory().pixmap("view-rotate-right");
296

297
    App::Document* doc = editedObject->getDocument();
298
    for (; it != objects.end() && jt != element.end(); ++it, ++jt, ++index) {
299
        QListWidgetItem* item = new QListWidgetItem(ui->listWidget);
300
        if (index < boolean.size()) {
301
            if (boolean[index]) {
302
                item->setIcon(rotateLeft);
303
            }
304
            else {
305
                item->setIcon(rotateRight);
306
            }
307
        }
308
        ui->listWidget->addItem(item);
309

310
        QString text = QString::fromLatin1("%1.%2").arg(QString::fromUtf8((*it)->Label.getValue()),
311
                                                        QString::fromStdString(*jt));
312
        item->setText(text);
313

314
        QList<QVariant> data;
315
        data << QByteArray(doc->getName());
316
        data << QByteArray((*it)->getNameInDocument());
317
        data << QByteArray(jt->c_str());
318
        item->setData(Qt::UserRole, data);
319
    }
320

321
    attachDocument(Gui::Application::Instance->getDocument(doc));
322
}
323

324
void GeomFillSurface::changeEvent(QEvent* e)
325
{
326
    if (e->type() == QEvent::LanguageChange) {
327
        ui->retranslateUi(this);
328
    }
329
    else {
330
        QWidget::changeEvent(e);
331
    }
332
}
333

334
void GeomFillSurface::open()
335
{
336
    checkOpenCommand();
337
    this->vp->highlightReferences(true);
338
    Gui::Selection().clearSelection();
339
}
340

341
void GeomFillSurface::clearSelection()
342
{
343
    Gui::Selection().clearSelection();
344
}
345

346
void GeomFillSurface::checkOpenCommand()
347
{
348
    if (checkCommand && !Gui::Command::hasPendingCommand()) {
349
        std::string Msg("Edit ");
350
        Msg += editedObject->Label.getValue();
351
        Gui::Command::openCommand(Msg.c_str());
352
        checkCommand = false;
353
    }
354
}
355

356
void GeomFillSurface::slotUndoDocument(const Gui::Document&)
357
{
358
    checkCommand = true;
359
}
360

361
void GeomFillSurface::slotRedoDocument(const Gui::Document&)
362
{
363
    checkCommand = true;
364
}
365

366
void GeomFillSurface::slotDeletedObject(const Gui::ViewProviderDocumentObject& Obj)
367
{
368
    // If this view provider is being deleted then reset the colors of
369
    // referenced part objects. The dialog will be deleted later.
370
    if (this->vp == &Obj) {
371
        this->vp->highlightReferences(false);
372
    }
373
}
374

375
bool GeomFillSurface::accept()
376
{
377
    selectionMode = None;
378
    Gui::Selection().rmvSelectionGate();
379

380
    int count = ui->listWidget->count();
381
    if (count > 4) {
382
        QMessageBox::warning(this,
383
                             tr("Too many edges"),
384
                             tr("The tool requires two, three or four edges"));
385
        return false;
386
    }
387
    else if (count < 2) {
388
        QMessageBox::warning(this,
389
                             tr("Too less edges"),
390
                             tr("The tool requires two, three or four edges"));
391
        return false;
392
    }
393

394
    if (editedObject->mustExecute()) {
395
        editedObject->recomputeFeature();
396
    }
397
    if (!editedObject->isValid()) {
398
        QMessageBox::warning(this,
399
                             tr("Invalid object"),
400
                             QString::fromLatin1(editedObject->getStatusString()));
401
        return false;
402
    }
403

404
    this->vp->highlightReferences(false);
405

406
    Gui::Command::commitCommand();
407
    Gui::Command::doCommand(Gui::Command::Gui, "Gui.ActiveDocument.resetEdit()");
408
    Gui::Command::updateActive();
409
    return true;
410
}
411

412
bool GeomFillSurface::reject()
413
{
414
    this->vp->highlightReferences(false);
415
    selectionMode = None;
416
    Gui::Selection().rmvSelectionGate();
417

418
    Gui::Command::abortCommand();
419
    Gui::Command::doCommand(Gui::Command::Gui, "Gui.ActiveDocument.resetEdit()");
420
    Gui::Command::updateActive();
421
    return true;
422
}
423

424
void GeomFillSurface::onFillTypeStretchClicked()
425
{
426
    changeFillType(GeomFill_StretchStyle);
427
}
428

429
void GeomFillSurface::onFillTypeCoonsClicked()
430
{
431
    changeFillType(GeomFill_CoonsStyle);
432
}
433

434
void GeomFillSurface::onFillTypeCurvedClicked()
435
{
436
    changeFillType(GeomFill_CurvedStyle);
437
}
438

439
void GeomFillSurface::changeFillType(GeomFill_FillingStyle fillType)
440
{
441
    GeomFill_FillingStyle curtype =
442
        static_cast<GeomFill_FillingStyle>(editedObject->FillType.getValue());
443
    if (curtype != fillType) {
444
        checkOpenCommand();
445
        editedObject->FillType.setValue(static_cast<long>(fillType));
446
        editedObject->recomputeFeature();
447
        if (!editedObject->isValid()) {
448
            Base::Console().Error("Surface filling: %s", editedObject->getStatusString());
449
        }
450
    }
451
}
452

453
void GeomFillSurface::onButtonEdgeAddToggled(bool checked)
454
{
455
    if (checked) {
456
        selectionMode = Append;
457
        Gui::Selection().addSelectionGate(new EdgeSelection(true, editedObject));
458
    }
459
    else if (selectionMode == Append) {
460
        exitSelectionMode();
461
    }
462
}
463

464
void GeomFillSurface::onButtonEdgeRemoveToggled(bool checked)
465
{
466
    if (checked) {
467
        selectionMode = Remove;
468
        Gui::Selection().addSelectionGate(new EdgeSelection(false, editedObject));
469
    }
470
    else if (selectionMode == Remove) {
471
        exitSelectionMode();
472
    }
473
}
474

475
void GeomFillSurface::onSelectionChanged(const Gui::SelectionChanges& msg)
476
{
477
    if (selectionMode == None) {
478
        return;
479
    }
480

481
    if (msg.Type == Gui::SelectionChanges::AddSelection) {
482
        checkOpenCommand();
483
        if (selectionMode == Append) {
484
            QListWidgetItem* item = new QListWidgetItem(ui->listWidget);
485
            item->setIcon(Gui::BitmapFactory().pixmap("view-rotate-right"));
486
            ui->listWidget->addItem(item);
487

488
            Gui::SelectionObject sel(msg);
489
            QString text = QString::fromLatin1("%1.%2").arg(
490
                QString::fromUtf8(sel.getObject()->Label.getValue()),
491
                QString::fromLatin1(msg.pSubName));
492
            item->setText(text);
493

494
            QList<QVariant> data;
495
            data << QByteArray(msg.pDocName);
496
            data << QByteArray(msg.pObjectName);
497
            data << QByteArray(msg.pSubName);
498
            item->setData(Qt::UserRole, data);
499

500
            auto objects = editedObject->BoundaryList.getValues();
501
            objects.push_back(sel.getObject());
502
            auto element = editedObject->BoundaryList.getSubValues();
503
            element.emplace_back(msg.pSubName);
504
            editedObject->BoundaryList.setValues(objects, element);
505
            auto booleans = editedObject->ReversedList.getValues();
506
            booleans.push_back(false);
507
            editedObject->ReversedList.setValues(booleans);
508
            this->vp->highlightReferences(true);
509
        }
510
        else {
511
            Gui::SelectionObject sel(msg);
512
            QList<QVariant> data;
513
            int row = 0;
514
            data << QByteArray(msg.pDocName);
515
            data << QByteArray(msg.pObjectName);
516
            data << QByteArray(msg.pSubName);
517
            for (int i = 0; i < ui->listWidget->count(); i++) {
518
                QListWidgetItem* item = ui->listWidget->item(i);
519
                if (item && item->data(Qt::UserRole) == data) {
520
                    row = i;
521
                    ui->listWidget->takeItem(i);
522
                    delete item;
523
                }
524
            }
525

526
            this->vp->highlightReferences(false);
527
            App::DocumentObject* obj = sel.getObject();
528
            std::string sub = msg.pSubName;
529
            auto objects = editedObject->BoundaryList.getValues();
530
            auto element = editedObject->BoundaryList.getSubValues();
531
            auto it = objects.begin();
532
            auto jt = element.begin();
533

534
            // remove the element of the bitset at position 'row'
535
            const boost::dynamic_bitset<>& old_booleans = editedObject->ReversedList.getValues();
536
            boost::dynamic_bitset<> new_booleans = old_booleans >> 1;
537
            new_booleans.resize(objects.size() - 1);
538

539
            // double-check in case 'old_booleans' is out of sync
540
            if (new_booleans.size() < old_booleans.size()) {
541
                for (int i = 0; i < row; i++) {
542
                    new_booleans[i] = old_booleans[i];
543
                }
544
            }
545

546
            for (; it != objects.end() && jt != element.end(); ++it, ++jt) {
547
                if (*it == obj && *jt == sub) {
548
                    objects.erase(it);
549
                    element.erase(jt);
550
                    editedObject->BoundaryList.setValues(objects, element);
551
                    editedObject->ReversedList.setValues(new_booleans);
552
                    break;
553
                }
554
            }
555
            this->vp->highlightReferences(true);
556
        }
557

558
        editedObject->recomputeFeature();
559
        QTimer::singleShot(50, this, &GeomFillSurface::clearSelection);
560
    }
561
}
562

563
void GeomFillSurface::onDeleteEdge()
564
{
565
    int row = ui->listWidget->currentRow();
566
    QListWidgetItem* item = ui->listWidget->item(row);
567
    if (item) {
568
        checkOpenCommand();
569
        QList<QVariant> data;
570
        data = item->data(Qt::UserRole).toList();
571
        ui->listWidget->takeItem(row);
572
        delete item;
573

574
        App::Document* doc = App::GetApplication().getDocument(data[0].toByteArray());
575
        App::DocumentObject* obj = doc ? doc->getObject(data[1].toByteArray()) : nullptr;
576
        std::string sub = data[2].toByteArray().constData();
577
        auto objects = editedObject->BoundaryList.getValues();
578
        auto element = editedObject->BoundaryList.getSubValues();
579
        auto it = objects.begin();
580
        auto jt = element.begin();
581
        this->vp->highlightReferences(false);
582

583
        // remove the element of the bitset at position 'row'
584
        const boost::dynamic_bitset<>& old_booleans = editedObject->ReversedList.getValues();
585
        boost::dynamic_bitset<> new_booleans = old_booleans >> 1;
586
        new_booleans.resize(objects.size() - 1);
587

588
        // double-check in case 'old_booleans' is out of sync
589
        if (new_booleans.size() < old_booleans.size()) {
590
            for (int i = 0; i < row; i++) {
591
                new_booleans[i] = old_booleans[i];
592
            }
593
        }
594

595
        for (; it != objects.end() && jt != element.end(); ++it, ++jt) {
596
            if (*it == obj && *jt == sub) {
597
                objects.erase(it);
598
                element.erase(jt);
599
                editedObject->BoundaryList.setValues(objects, element);
600
                editedObject->ReversedList.setValues(new_booleans);
601
                break;
602
            }
603
        }
604
        this->vp->highlightReferences(true);
605
    }
606
}
607

608
void GeomFillSurface::flipOrientation(QListWidgetItem* item)
609
{
610
    // toggle the orientation of the input curve
611
    //
612
    QPixmap rotateLeft = Gui::BitmapFactory().pixmap("view-rotate-left");
613
    QPixmap rotateRight = Gui::BitmapFactory().pixmap("view-rotate-right");
614

615
    int row = ui->listWidget->row(item);
616
    if (row < editedObject->ReversedList.getSize()) {
617
        auto booleans = editedObject->ReversedList.getValues();
618
        bool reversed = !booleans[row];
619
        booleans[row] = reversed;
620
        if (reversed) {
621
            item->setIcon(rotateLeft);
622
        }
623
        else {
624
            item->setIcon(rotateRight);
625
        }
626

627
        editedObject->ReversedList.setValues(booleans);
628
        editedObject->recomputeFeature();
629
    }
630
}
631

632
void GeomFillSurface::onListWidgetItemDoubleClicked(QListWidgetItem* item)
633
{
634
    if (item) {
635
        flipOrientation(item);
636
    }
637
}
638

639
void GeomFillSurface::onFlipOrientation()
640
{
641
    QListWidgetItem* item = ui->listWidget->currentItem();
642
    if (item) {
643
        flipOrientation(item);
644
    }
645
}
646

647
void GeomFillSurface::exitSelectionMode()
648
{
649
    selectionMode = None;
650
    Gui::Selection().clearSelection();
651
    Gui::Selection().rmvSelectionGate();
652
}
653

654
// ----------------------------------------------------------------------------
655

656
TaskGeomFillSurface::TaskGeomFillSurface(ViewProviderGeomFillSurface* vp,
657
                                         Surface::GeomFillSurface* obj)
658
{
659
    widget = new GeomFillSurface(vp, obj);
660
    widget->setWindowTitle(QObject::tr("Surface"));
661
    addTaskBox(Gui::BitmapFactory().pixmap("Surface_BSplineSurface"), widget);
662
}
663

664
void TaskGeomFillSurface::setEditedObject(Surface::GeomFillSurface* obj)
665
{
666
    widget->setEditedObject(obj);
667
}
668

669
void TaskGeomFillSurface::open()
670
{
671
    widget->open();
672
}
673

674
bool TaskGeomFillSurface::accept()
675
{
676
    return widget->accept();
677
}
678

679
bool TaskGeomFillSurface::reject()
680
{
681
    return widget->reject();
682
}
683

684
}  // namespace SurfaceGui
685

686
#include "moc_TaskGeomFillSurface.cpp"
687