FreeCAD

1
/***************************************************************************
2
 *   Copyright (c) 2022 WandererFan <wandererfan@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
#include "PreCompiled.h"
24
#ifndef _PreComp_
25
#include <string>
26
#include <vector>
27

28
#include <QMessageBox>
29
#include <QTableWidgetItem>
30
#endif// #ifndef _PreComp_
31

32
#include <App/Document.h>
33
#include <Base/Tools.h>
34
#include <Gui/BitmapFactory.h>
35
#include <Gui/Command.h>
36
#include <Gui/MainWindow.h>
37
#include <Gui/Selection.h>
38
#include <Mod/TechDraw/App/DrawView.h>
39
#include <Mod/TechDraw/App/DrawViewPart.h>
40

41
#include "DimensionValidators.h"
42
#include "TaskDimRepair.h"
43
#include "ui_TaskDimRepair.h"
44

45

46
using namespace Gui;
47
using namespace TechDraw;
48
using namespace TechDrawGui;
49

50
TaskDimRepair::TaskDimRepair(TechDraw::DrawViewDimension* inDvd)
51
    : ui(new Ui_TaskDimRepair),
52
      m_dim(inDvd)
53
{
54
    ui->setupUi(this);
55

56
    connect(ui->pbSelection, &QPushButton::clicked, this, &TaskDimRepair::slotUseSelection);
57

58
    saveDimState();
59
    setUiPrimary();
60
}
61

62
TaskDimRepair::~TaskDimRepair()
63
{}
64

65
void TaskDimRepair::setUiPrimary()
66
{
67
    setWindowTitle(QObject::tr("Dimension Repair"));
68
    ui->leName->setReadOnly(true);
69
    ui->leLabel->setReadOnly(true);
70

71
    ui->leName->setText(Base::Tools::fromStdString(m_dim->getNameInDocument()));
72
    ui->leLabel->setText(Base::Tools::fromStdString(m_dim->Label.getValue()));
73

74
    std::string objName = m_dim->getViewPart()->getNameInDocument();
75
    std::string objLabel = m_dim->getViewPart()->Label.getValue();
76
    ui->leObject2d->setText(Base::Tools::fromStdString(objName + " / " + objLabel));
77
    const std::vector<std::string>& subElements2d = m_dim->References2D.getSubValues();
78
    std::vector<std::string> noLabels(subElements2d.size());
79
    fillList(ui->lwGeometry2d, subElements2d, noLabels);
80

81
    QStringList headers;
82
    headers << tr("Object Name") << tr("Object Label") << tr("SubElement");
83
    ui->twReferences3d->setHorizontalHeaderLabels(headers);
84

85
    ReferenceVector references3d = m_dim->getReferences3d();
86
    loadTableWidget(ui->twReferences3d, references3d);
87
}
88

89
void TaskDimRepair::saveDimState()
90
{
91
    m_saveMeasureType = m_dim->MeasureType.getValue();
92
    m_saveDimType = m_dim->Type.getValue();
93
    m_dimType = m_dim->Type.getValue();
94
    m_saveRefs3d = m_dim->getReferences3d();
95
    m_saveRefs2d = m_dim->getReferences2d();
96
    m_saveDvp = m_dim->getViewPart();
97
}
98

99
//restore the start conditions
100
void TaskDimRepair::restoreDimState()
101
{
102
    if (m_dim) {
103
        m_dim->setReferences2d(m_saveRefs2d);
104
        m_dim->setReferences3d(m_saveRefs3d);
105
    }
106
}
107

108
//similar to code in CommandCreateDims.cpp
109
//use the current selection to replace the references in dim
110
void TaskDimRepair::slotUseSelection()
111
{
112
    const std::vector<App::DocumentObject*> dimObjects =
113
        Gui::Selection().getObjectsOfType(TechDraw::DrawViewDimension::getClassTypeId());
114
    if (dimObjects.empty()) {
115
        //selection does not include a dimension, so we need to add our dimension to keep the
116
        //validators happy
117
        //bool accepted =
118
        static_cast<void>(Gui::Selection().addSelection(m_dim->getDocument()->getName(),
119
                                                        m_dim->getNameInDocument()));
120
    }
121
    ReferenceVector references2d;
122
    ReferenceVector references3d;
123
    TechDraw::DrawViewPart* dvp = TechDraw::getReferencesFromSelection(references2d, references3d);
124
    if (dvp != m_saveDvp) {
125
        QMessageBox::warning(Gui::getMainWindow(),
126
                             QObject::tr("Incorrect Selection"),
127
                             QObject::tr("Can not use references from a different View"));
128
        return;
129
    }
130

131
    StringVector acceptableGeometry({"Edge", "Vertex"});
132
    std::vector<int> minimumCounts({1, 1});
133
    std::vector<DimensionGeometryType> acceptableDimensionGeometrys;//accept anything
134
    DimensionGeometryType geometryRefs2d = validateDimSelection(
135
        references2d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
136
    if (geometryRefs2d == isInvalid) {
137
        QMessageBox::warning(Gui::getMainWindow(),
138
                             QObject::tr("Incorrect Selection"),
139
                             QObject::tr("Can not make a dimension from selection"));
140
        return;
141
    }
142
    //what 3d geometry configuration did we receive?
143
    DimensionGeometryType geometryRefs3d(isInvalid);
144
    if (geometryRefs2d == TechDraw::isViewReference && !references3d.empty()) {
145
        geometryRefs3d = validateDimSelection3d(
146
            dvp, references3d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
147
        if (geometryRefs3d == isInvalid) {
148
            QMessageBox::warning(Gui::getMainWindow(),
149
                                 QObject::tr("Incorrect Selection"),
150
                                 QObject::tr("Can not make dimension from selection"));
151
            return;
152
        }
153
    }
154

155
    m_dimType = mapGeometryTypeToDimType(m_dim->Type.getValue(), geometryRefs2d, geometryRefs3d);
156
    m_toApply2d = references2d;
157
    if (references3d.empty()) {
158
        m_toApply3d.clear();
159
    } else {
160
        m_toApply3d = references3d;
161
    }
162
    updateUi();
163
}
164

165
void TaskDimRepair::updateUi()
166
{
167
    std::string objName = m_dim->getViewPart()->getNameInDocument();
168
    std::string objLabel = m_dim->getViewPart()->Label.getValue();
169
    ui->leObject2d->setText(Base::Tools::fromStdString(objName + " / " + objLabel));
170

171
    std::vector<std::string> subElements2d;
172
    for (auto& ref : m_toApply2d) {
173
        subElements2d.push_back(ref.getSubName());
174
    }
175
    std::vector<std::string> noLabels(subElements2d.size());
176
    fillList(ui->lwGeometry2d, subElements2d, noLabels);
177

178
    loadTableWidget(ui->twReferences3d, m_toApply3d);
179
}
180

181
void TaskDimRepair::loadTableWidget(QTableWidget* tw, ReferenceVector refs)
182
{
183
    tw->clearContents();
184
    tw->setRowCount(refs.size() + 1);
185
    size_t iRow = 0;
186
    for (auto& ref : refs) {
187
        QString qName = Base::Tools::fromStdString(ref.getObject()->getNameInDocument());
188
        QTableWidgetItem* itemName = new QTableWidgetItem(qName);
189
        itemName->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
190
        tw->setItem(iRow, 0, itemName);
191
        QString qLabel = Base::Tools::fromStdString(std::string(ref.getObject()->Label.getValue()));
192
        QTableWidgetItem* itemLabel = new QTableWidgetItem(qLabel);
193
        itemLabel->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
194
        tw->setItem(iRow, 1, itemLabel);
195
        QString qSubName = Base::Tools::fromStdString(ref.getSubName());
196
        QTableWidgetItem* itemSubName = new QTableWidgetItem(qSubName);
197
        itemSubName->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
198
        tw->setItem(iRow, 2, itemSubName);
199
        iRow++;
200
    }
201
}
202

203
void TaskDimRepair::fillList(QListWidget* lwItems, std::vector<std::string> labels,
204
                             std::vector<std::string> names)
205
{
206
    QListWidgetItem* item;
207
    QString qLabel;
208
    QString qName;
209
    QString qText;
210
    int labelCount = labels.size();
211
    int i = 0;
212
    lwItems->clear();
213
    for (; i < labelCount; i++) {
214
        qLabel = Base::Tools::fromStdString(labels[i]);
215
        qName = Base::Tools::fromStdString(names[i]);
216
        qText = QString::fromUtf8("%1 %2").arg(qName, qLabel);
217
        item = new QListWidgetItem(qText, lwItems);
218
        item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
219
        item->setData(Qt::UserRole, qName);
220
    }
221
}
222
void TaskDimRepair::replaceReferences()
223
{
224
    if (!m_dim) {
225
        return;
226
    }
227
    if (!m_toApply2d.empty()) {
228
        m_dim->setReferences2d(m_toApply2d);
229
    }
230
    if (!m_toApply3d.empty()) {
231
        m_dim->setReferences3d(m_toApply3d);
232
    }
233
}
234

235
bool TaskDimRepair::accept()
236
{
237
    Gui::Command::doCommand(Gui::Command::Gui, "Gui.ActiveDocument.resetEdit()");
238

239
    Gui::Command::openCommand(QT_TRANSLATE_NOOP("Command", "Repair Dimension"));
240
    replaceReferences();
241
    m_dim->Type.setValue(m_dimType);
242
    Gui::Command::commitCommand();
243

244
    m_dim->recomputeFeature();
245
    return true;
246
}
247

248
bool TaskDimRepair::reject()
249
{
250
    restoreDimState();
251
    Gui::Command::doCommand(Gui::Command::Gui, "Gui.ActiveDocument.resetEdit()");
252
    return false;
253
}
254

255
void TaskDimRepair::changeEvent(QEvent* e)
256
{
257
    if (e->type() == QEvent::LanguageChange) {
258
        ui->retranslateUi(this);
259
    }
260
}
261

262
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
263
TaskDlgDimReference::TaskDlgDimReference(TechDraw::DrawViewDimension* inDvd)
264
    : TaskDialog()
265
{
266
    widget = new TaskDimRepair(inDvd);
267
    taskbox = new Gui::TaskView::TaskBox(
268
        Gui::BitmapFactory().pixmap("TechDraw_DimensionRepair"), widget->windowTitle(), true, 0);
269
    taskbox->groupLayout()->addWidget(widget);
270
    Content.push_back(taskbox);
271
}
272

273

274
TaskDlgDimReference::~TaskDlgDimReference()
275
{}
276

277
void TaskDlgDimReference::update()
278
{
279
    //widget->updateTask();
280
}
281

282
//==== calls from the TaskView ===============================================================
283
void TaskDlgDimReference::open()
284
{}
285

286
void TaskDlgDimReference::clicked(int i)
287
{
288
    Q_UNUSED(i);
289
}
290

291
bool TaskDlgDimReference::accept()
292
{
293
    widget->accept();
294
    return true;
295
}
296

297
bool TaskDlgDimReference::reject()
298
{
299
    widget->reject();
300
    return true;
301
}
302

303
#include <Mod/TechDraw/Gui/moc_TaskDimRepair.cpp>
304