kindred/create
1
1
Fork 0
Code Issues 53 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
af33cdabe53679bdca74887df2655b4266217c5f
create/src/Mod/Surface/Gui/TaskFilling.cpp

972 lines
34 KiB
C++
Raw Blame History

/***************************************************************************
* Copyright (c) 2017 Werner Mayer <wmayer[at]users.sourceforge.net> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Library General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Library General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this library; see the file COPYING.LIB. If not, *
* write to the Free Software Foundation, Inc., 59 Temple Place, *
* Suite 330, Boston, MA 02111-1307, USA *
* *
***************************************************************************/
#include "PreCompiled.h"
#ifndef _PreComp_
# include <QAction>
# include <QMenu>
# include <QMessageBox>
# include <QTimer>
# include <GeomAbs_Shape.hxx>
# include <TopExp.hxx>
# include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
# include <TopTools_IndexedMapOfShape.hxx>
# include <TopTools_ListIteratorOfListOfShape.hxx>
#endif
#include <App/Document.h>
#include <Gui/Application.h>
#include <Gui/BitmapFactory.h>
#include <Gui/Command.h>
#include <Gui/Control.h>
#include <Gui/Document.h>
#include <Gui/SelectionObject.h>
#include <Gui/Widgets.h>
#include <Mod/Part/Gui/ViewProvider.h>
#include "TaskFilling.h"
#include "ui_TaskFilling.h"
#include "TaskFillingEdge.h"
#include "TaskFillingVertex.h"
using namespace SurfaceGui;
PROPERTY_SOURCE(SurfaceGui::ViewProviderFilling, PartGui::ViewProviderSpline)
namespace SurfaceGui {
void ViewProviderFilling::setupContextMenu(QMenu* menu, QObject* receiver, const char* member)
{
QAction* act;
act = menu->addAction(QObject::tr("Edit filling"), receiver, member);
act->setData(QVariant((int)ViewProvider::Default));
PartGui::ViewProviderSpline::setupContextMenu(menu, receiver, member);
}
bool ViewProviderFilling::setEdit(int ModNum)
{
if (ModNum == ViewProvider::Default ) {
// When double-clicking on the item for this sketch the
// object unsets and sets its edit mode without closing
// the task panel
Surface::Filling* obj = static_cast<Surface::Filling*>(this->getObject());
Gui::TaskView::TaskDialog* dlg = Gui::Control().activeDialog();
// start the edit dialog
if (dlg) {
TaskFilling* tDlg = qobject_cast<TaskFilling*>(dlg);
if (tDlg)
tDlg->setEditedObject(obj);
Gui::Control().showDialog(dlg);
}
else {
Gui::Control().showDialog(new TaskFilling(this, obj));
}
return true;
}
else {
return ViewProviderSpline::setEdit(ModNum);
}
}
void ViewProviderFilling::unsetEdit(int ModNum)
{
PartGui::ViewProviderSpline::unsetEdit(ModNum);
}
QIcon ViewProviderFilling::getIcon() const
{
return Gui::BitmapFactory().pixmap("Surface_Filling");
}
void ViewProviderFilling::highlightReferences(ShapeType type, const References& refs, bool on)
{
for (const auto& it : refs) {
Part::Feature* base = dynamic_cast<Part::Feature*>(it.first);
if (base) {
PartGui::ViewProviderPartExt* svp = dynamic_cast<PartGui::ViewProviderPartExt*>(
Gui::Application::Instance->getViewProvider(base));
if (svp) {
switch (type) {
case ViewProviderFilling::Vertex:
if (on) {
std::vector<App::Color> colors;
TopTools_IndexedMapOfShape vMap;
TopExp::MapShapes(base->Shape.getValue(), TopAbs_VERTEX, vMap);
colors.resize(vMap.Extent(), svp->PointColor.getValue());
for (const auto& jt : it.second) {
// check again that the index is in range because it's possible that the
// sub-names are invalid
std::size_t idx = static_cast<std::size_t>(std::stoi(jt.substr(6)) - 1);
if (idx < colors.size())
colors[idx] = App::Color(1.0,0.0,1.0); // magenta
}
svp->setHighlightedPoints(colors);
}
else {
svp->unsetHighlightedPoints();
}
break;
case ViewProviderFilling::Edge:
if (on) {
std::vector<App::Color> colors;
TopTools_IndexedMapOfShape eMap;
TopExp::MapShapes(base->Shape.getValue(), TopAbs_EDGE, eMap);
colors.resize(eMap.Extent(), svp->LineColor.getValue());
for (const auto& jt : it.second) {
std::size_t idx = static_cast<std::size_t>(std::stoi(jt.substr(4)) - 1);
// check again that the index is in range because it's possible that the
// sub-names are invalid
if (idx < colors.size())
colors[idx] = App::Color(1.0,0.0,1.0); // magenta
}
svp->setHighlightedEdges(colors);
}
else {
svp->unsetHighlightedEdges();
}
break;
case ViewProviderFilling::Face:
if (on) {
std::vector<App::Color> colors;
TopTools_IndexedMapOfShape fMap;
TopExp::MapShapes(base->Shape.getValue(), TopAbs_FACE, fMap);
colors.resize(fMap.Extent(), svp->ShapeColor.getValue());
for (const auto& jt : it.second) {
std::size_t idx = static_cast<std::size_t>(std::stoi(jt.substr(4)) - 1);
// check again that the index is in range because it's possible that the
// sub-names are invalid
if (idx < colors.size())
colors[idx] = App::Color(1.0,0.0,1.0); // magenta
}
svp->setHighlightedFaces(colors);
}
else {
svp->unsetHighlightedFaces();
}
break;
}
}
}
}
}
// ----------------------------------------------------------------------------
class FillingPanel::ShapeSelection : public Gui::SelectionFilterGate
{
public:
ShapeSelection(FillingPanel::SelectionMode& mode, Surface::Filling* editedObject)
: Gui::SelectionFilterGate(nullPointer())
, mode(mode)
, editedObject(editedObject)
{
}
~ShapeSelection() override
{
mode = FillingPanel::None;
}
/**
* Allow the user to pick only edges.
*/
bool allow(App::Document*, App::DocumentObject* pObj, const char* sSubName) override
{
// don't allow references to itself
if (pObj == editedObject)
return false;
if (!pObj->isDerivedFrom(Part::Feature::getClassTypeId()))
return false;
if (!sSubName || sSubName[0] == '\0')
return false;
switch (mode) {
case FillingPanel::InitFace:
return allowFace(pObj, sSubName);
case FillingPanel::AppendEdge:
return allowEdge(true, pObj, sSubName);
case FillingPanel::RemoveEdge:
return allowEdge(false, pObj, sSubName);
default:
return false;
}
}
private:
bool allowFace(App::DocumentObject*, const char* sSubName)
{
std::string element(sSubName);
if (element.substr(0,4) != "Face")
return false;
return true;
}
bool allowEdge(bool appendEdges, App::DocumentObject* pObj, const char* sSubName)
{
std::string element(sSubName);
if (element.substr(0,4) != "Edge")
return false;
auto links = editedObject->BoundaryEdges.getSubListValues();
for (const auto& it : links) {
if (it.first == pObj) {
for (const auto& jt : it.second) {
if (jt == sSubName)
return !appendEdges;
}
}
}
return appendEdges;
}
private:
FillingPanel::SelectionMode& mode;
Surface::Filling* editedObject;
};
// ----------------------------------------------------------------------------
FillingPanel::FillingPanel(ViewProviderFilling* vp, Surface::Filling* obj)
: editedObject(obj)
{
ui = new Ui_TaskFilling();
ui->setupUi(this);
ui->statusLabel->clear();
selectionMode = None;
this->vp = vp;
checkCommand = true;
setEditedObject(obj);
// Create context menu
QAction* action = new QAction(tr("Remove"), this);
action->setShortcut(QString::fromLatin1("Del"));
action->setShortcutContext(Qt::WidgetShortcut);
ui->listBoundary->addAction(action);
connect(action, SIGNAL(triggered()), this, SLOT(onDeleteEdge()));
ui->listBoundary->setContextMenuPolicy(Qt::ActionsContextMenu);
connect(ui->listBoundary->model(),
SIGNAL(rowsMoved(QModelIndex, int, int, QModelIndex, int)), this, SLOT(onIndexesMoved()));
}
/*
* Destroys the object and frees any allocated resources
*/
FillingPanel::~FillingPanel()
{
// no need to delete child widgets, Qt does it all for us
delete ui;
}
void FillingPanel::appendButtons(Gui::ButtonGroup* buttonGroup)
{
buttonGroup->addButton(ui->buttonInitFace, int(SelectionMode::InitFace));
buttonGroup->addButton(ui->buttonEdgeAdd, int(SelectionMode::AppendEdge));
buttonGroup->addButton(ui->buttonEdgeRemove, int(SelectionMode::RemoveEdge));
}
// stores object pointer, its old fill type and adjusts radio buttons according to it.
void FillingPanel::setEditedObject(Surface::Filling* fea)
{
editedObject = fea;
// get the link to the initial surface if set
App::DocumentObject* initFace = editedObject->InitialFace.getValue();
const std::vector<std::string>& subList = editedObject->InitialFace.getSubValues();
if (initFace && subList.size() == 1) {
QString text = QString::fromLatin1("%1.%2")
.arg(QString::fromUtf8(initFace->Label.getValue()),
QString::fromStdString(subList.front()));
ui->lineInitFaceName->setText(text);
}
// get the boundary edges, if set their adjacent faces and continuities
auto objects = editedObject->BoundaryEdges.getValues();
auto edges = editedObject->BoundaryEdges.getSubValues();
auto count = objects.size();
// fill up faces if wrong size
auto faces = editedObject->BoundaryFaces.getValues();
if (faces.size() != edges.size()) {
faces.resize(edges.size());
std::fill(faces.begin(), faces.end(), std::string());
}
// fill up continuities if wrong size
auto conts = editedObject->BoundaryOrder.getValues();
if (edges.size() != conts.size()) {
conts.resize(edges.size());
std::fill(conts.begin(), conts.end(), static_cast<long>(GeomAbs_C0));
}
App::Document* doc = editedObject->getDocument();
for (std::size_t i=0; i<count; i++) {
App::DocumentObject* obj = objects[i];
std::string edge = edges[i];
std::string face = faces[i];
QListWidgetItem* item = new QListWidgetItem(ui->listBoundary);
ui->listBoundary->addItem(item);
QString text = QString::fromLatin1("%1.%2")
.arg(QString::fromUtf8(obj->Label.getValue()),
QString::fromStdString(edge));
item->setText(text);
// The user data field of a list widget item
// is a list of five elementa:
// 1. document name
// 2. object name
// 3. sub-element name of the edge
// 4. sub-element of an adjacent face or empty string
// 5. the continuity as int
QList<QVariant> data;
data << QByteArray(doc->getName());
data << QByteArray(obj->getNameInDocument());
data << QByteArray(edge.c_str());
data << QByteArray(face.c_str());
data << static_cast<int>(conts[i]);
item->setData(Qt::UserRole, data);
}
// attach this document observer
attachDocument(Gui::Application::Instance->getDocument(doc));
}
void FillingPanel::changeEvent(QEvent *e)
{
if (e->type() == QEvent::LanguageChange) {
ui->retranslateUi(this);
}
else {
QWidget::changeEvent(e);
}
}
void FillingPanel::open()
{
checkOpenCommand();
// highlight the boundary edges
this->vp->highlightReferences(ViewProviderFilling::Edge,
editedObject->BoundaryEdges.getSubListValues(), true);
// highlight the referenced face
std::vector<App::PropertyLinkSubList::SubSet> links;
links.emplace_back(editedObject->InitialFace.getValue(),
editedObject->InitialFace.getSubValues());
this->vp->highlightReferences(ViewProviderFilling::Face, links, true);
Gui::Selection().clearSelection();
// if the surface is not yet created then automatically start "AppendEdge" mode
if (editedObject->Shape.getShape().isNull()) {
ui->buttonEdgeAdd->setChecked(true);
}
}
void FillingPanel::clearSelection()
{
Gui::Selection().clearSelection();
}
void FillingPanel::checkOpenCommand()
{
if (checkCommand && !Gui::Command::hasPendingCommand()) {
std::string Msg("Edit ");
Msg += editedObject->Label.getValue();
Gui::Command::openCommand(Msg.c_str());
checkCommand = false;
}
}
void FillingPanel::slotUndoDocument(const Gui::Document&)
{
checkCommand = true;
}
void FillingPanel::slotRedoDocument(const Gui::Document&)
{
checkCommand = true;
}
void FillingPanel::slotDeletedObject(const Gui::ViewProviderDocumentObject& Obj)
{
// If this view provider is being deleted then reset the colors of
// referenced part objects. The dialog will be deleted later.
if (this->vp == &Obj) {
this->vp->highlightReferences(ViewProviderFilling::Edge,
editedObject->BoundaryEdges.getSubListValues(), false);
// unhighlight the referenced face
std::vector<App::PropertyLinkSubList::SubSet> links;
links.emplace_back(editedObject->InitialFace.getValue(),
editedObject->InitialFace.getSubValues());
this->vp->highlightReferences(ViewProviderFilling::Face, links, false);
}
}
bool FillingPanel::accept()
{
selectionMode = None;
Gui::Selection().rmvSelectionGate();
if (editedObject->mustExecute())
editedObject->recomputeFeature();
if (!editedObject->isValid()) {
QMessageBox::warning(this, tr("Invalid object"),
QString::fromLatin1(editedObject->getStatusString()));
return false;
}
this->vp->highlightReferences(ViewProviderFilling::Edge,
editedObject->BoundaryEdges.getSubListValues(), false);
// unhighlight the referenced face
std::vector<App::PropertyLinkSubList::SubSet> links;
links.emplace_back(editedObject->InitialFace.getValue(),
editedObject->InitialFace.getSubValues());
this->vp->highlightReferences(ViewProviderFilling::Face, links, false);
return true;
}
bool FillingPanel::reject()
{
if (!editedObject.expired()) {
this->vp->highlightReferences(ViewProviderFilling::Edge,
editedObject->BoundaryEdges.getSubListValues(), false);
// unhighlight the referenced face
std::vector<App::PropertyLinkSubList::SubSet> links;
links.emplace_back(editedObject->InitialFace.getValue(),
editedObject->InitialFace.getSubValues());
this->vp->highlightReferences(ViewProviderFilling::Face, links, false);
}
selectionMode = None;
Gui::Selection().rmvSelectionGate();
return true;
}
void FillingPanel::on_lineInitFaceName_textChanged(const QString& text)
{
if (text.isEmpty()) {
checkOpenCommand();
// unhighlight the referenced face
std::vector<App::PropertyLinkSubList::SubSet> links;
links.emplace_back(editedObject->InitialFace.getValue(),
editedObject->InitialFace.getSubValues());
this->vp->highlightReferences(ViewProviderFilling::Face, links, false);
editedObject->InitialFace.setValue(nullptr);
editedObject->recomputeFeature();
}
}
void FillingPanel::on_buttonInitFace_clicked()
{
// 'selectionMode' is passed by reference and changed when the filter is deleted
Gui::Selection().addSelectionGate(new ShapeSelection(selectionMode, editedObject.get()));
selectionMode = InitFace;
}
void FillingPanel::on_buttonEdgeAdd_toggled(bool checked)
{
if (checked) {
// 'selectionMode' is passed by reference and changed when the filter is deleted
Gui::Selection().addSelectionGate(new ShapeSelection(selectionMode, editedObject.get()));
selectionMode = AppendEdge;
}
else if (selectionMode == AppendEdge) {
exitSelectionMode();
}
}
void FillingPanel::on_buttonEdgeRemove_toggled(bool checked)
{
if (checked) {
// 'selectionMode' is passed by reference and changed when the filter is deleted
Gui::Selection().addSelectionGate(new ShapeSelection(selectionMode, editedObject.get()));
selectionMode = RemoveEdge;
}
else if (selectionMode == RemoveEdge) {
exitSelectionMode();
}
}
void FillingPanel::on_listBoundary_itemDoubleClicked(QListWidgetItem* item)
{
Gui::Selection().clearSelection();
Gui::Selection().rmvSelectionGate();
selectionMode = None;
ui->comboBoxFaces->clear();
ui->comboBoxCont->clear();
if (item) {
QList<QVariant> data;
data = item->data(Qt::UserRole).toList();
try {
App::Document* doc = App::GetApplication().getDocument(data[0].toByteArray());
App::DocumentObject* obj = doc ? doc->getObject(data[1].toByteArray()) : nullptr;
if (obj && obj->getTypeId().isDerivedFrom(Part::Feature::getClassTypeId())) {
const Part::TopoShape& shape = static_cast<Part::Feature*>(obj)->Shape.getShape();
TopoDS_Shape edge = shape.getSubShape(data[2].toByteArray());
// build up map edge->face
TopTools_IndexedMapOfShape faces;
TopExp::MapShapes(shape.getShape(), TopAbs_FACE, faces);
TopTools_IndexedDataMapOfShapeListOfShape edge2Face;
TopExp::MapShapesAndAncestors(shape.getShape(), TopAbs_EDGE, TopAbs_FACE, edge2Face);
const TopTools_ListOfShape& adj_faces = edge2Face.FindFromKey(edge);
if (adj_faces.Extent() > 0) {
int n = adj_faces.Extent();
ui->statusLabel->setText(tr("Edge has %n adjacent faces", nullptr, n));
// fill up the combo boxes
modifyBoundary(true);
ui->comboBoxFaces->addItem(tr("None"), QByteArray(""));
ui->comboBoxCont->addItem(QString::fromLatin1("C0"), static_cast<int>(GeomAbs_C0));
ui->comboBoxCont->addItem(QString::fromLatin1("G1"), static_cast<int>(GeomAbs_G1));
ui->comboBoxCont->addItem(QString::fromLatin1("G2"), static_cast<int>(GeomAbs_G2));
TopTools_ListIteratorOfListOfShape it(adj_faces);
for (; it.More(); it.Next()) {
const TopoDS_Shape& F = it.Value();
int index = faces.FindIndex(F);
QString text = QString::fromLatin1("Face%1").arg(index);
ui->comboBoxFaces->addItem(text, text.toLatin1());
}
// activate face and continuity
if (data.size() == 5) {
int index = ui->comboBoxFaces->findData(data[3]);
ui->comboBoxFaces->setCurrentIndex(index);
index = ui->comboBoxCont->findData(data[4]);
ui->comboBoxCont->setCurrentIndex(index);
}
}
else {
ui->statusLabel->setText(tr("Edge has no adjacent faces"));
}
}
Gui::Selection().addSelection(data[0].toByteArray(),
data[1].toByteArray(),
data[2].toByteArray());
}
catch (...) {
}
}
}
void FillingPanel::onSelectionChanged(const Gui::SelectionChanges& msg)
{
if (selectionMode == None)
return;
if (msg.Type == Gui::SelectionChanges::AddSelection) {
checkOpenCommand();
if (selectionMode == InitFace) {
Gui::SelectionObject sel(msg);
QString text = QString::fromLatin1("%1.%2")
.arg(QString::fromUtf8(sel.getObject()->Label.getValue()),
QString::fromLatin1(msg.pSubName));
ui->lineInitFaceName->setText(text);
std::vector<std::string> subList;
subList.emplace_back(msg.pSubName);
editedObject->InitialFace.setValue(sel.getObject(), subList);
// highlight the referenced face
std::vector<App::PropertyLinkSubList::SubSet> links;
links.emplace_back(sel.getObject(), subList);
this->vp->highlightReferences(ViewProviderFilling::Face, links, true);
Gui::Selection().rmvSelectionGate();
selectionMode = None;
}
else if (selectionMode == AppendEdge) {
QListWidgetItem* item = new QListWidgetItem(ui->listBoundary);
ui->listBoundary->addItem(item);
Gui::SelectionObject sel(msg);
QString text = QString::fromLatin1("%1.%2")
.arg(QString::fromUtf8(sel.getObject()->Label.getValue()),
QString::fromLatin1(msg.pSubName));
item->setText(text);
QList<QVariant> data;
data << QByteArray(msg.pDocName);
data << QByteArray(msg.pObjectName);
data << QByteArray(msg.pSubName);
data << QByteArray("");
data << static_cast<int>(GeomAbs_C0);
item->setData(Qt::UserRole, data);
auto objects = editedObject->BoundaryEdges.getValues();
std::size_t count = objects.size();
objects.push_back(sel.getObject());
auto element = editedObject->BoundaryEdges.getSubValues();
element.emplace_back(msg.pSubName);
editedObject->BoundaryEdges.setValues(objects, element);
// extend faces and continuities lists if needed
auto faces = editedObject->BoundaryFaces.getValues();
if (count == faces.size()) {
faces.emplace_back();
editedObject->BoundaryFaces.setValues(faces);
}
auto conts = editedObject->BoundaryOrder.getValues();
if (count == conts.size()) {
conts.push_back(static_cast<long>(GeomAbs_C0));
editedObject->BoundaryOrder.setValues(conts);
}
this->vp->highlightReferences(ViewProviderFilling::Edge,
editedObject->BoundaryEdges.getSubListValues(), true);
}
else if (selectionMode == RemoveEdge) {
Gui::SelectionObject sel(msg);
QList<QVariant> data;
data << QByteArray(msg.pDocName);
data << QByteArray(msg.pObjectName);
data << QByteArray(msg.pSubName);
// only the three first elements must match
for (int i=0; i<ui->listBoundary->count(); i++) {
QListWidgetItem* item = ui->listBoundary->item(i);
QList<QVariant> userdata = item->data(Qt::UserRole).toList();
if (userdata.mid(0,3) == data) {
ui->listBoundary->takeItem(i);
delete item;
break;
}
}
this->vp->highlightReferences(ViewProviderFilling::Edge,
editedObject->BoundaryEdges.getSubListValues(), false);
App::DocumentObject* obj = sel.getObject();
std::string sub = msg.pSubName;
auto objects = editedObject->BoundaryEdges.getValues();
auto element = editedObject->BoundaryEdges.getSubValues();
auto it = objects.begin();
auto jt = element.begin();
for (; it != objects.end() && jt != element.end(); ++it, ++jt) {
if (*it == obj && *jt == sub) {
std::size_t index = std::distance(objects.begin(), it);
objects.erase(it);
element.erase(jt);
editedObject->BoundaryEdges.setValues(objects, element);
// try to remove the item also from the faces
auto faces = editedObject->BoundaryFaces.getValues();
if (index < faces.size()) {
faces.erase(faces.begin() + index);
editedObject->BoundaryFaces.setValues(faces);
}
// try to remove the item also from the orders
auto order = editedObject->BoundaryOrder.getValues();
if (index < order.size()) {
order.erase(order.begin() + index);
editedObject->BoundaryOrder.setValues(order);
}
break;
}
}
this->vp->highlightReferences(ViewProviderFilling::Edge,
editedObject->BoundaryEdges.getSubListValues(), true);
}
editedObject->recomputeFeature();
QTimer::singleShot(50, this, SLOT(clearSelection()));
}
}
void FillingPanel::onDeleteEdge()
{
int row = ui->listBoundary->currentRow();
QListWidgetItem* item = ui->listBoundary->item(row);
if (item) {
checkOpenCommand();
QList<QVariant> data;
data = item->data(Qt::UserRole).toList();
ui->listBoundary->takeItem(row);
delete item;
App::Document* doc = App::GetApplication().getDocument(data[0].toByteArray());
App::DocumentObject* obj = doc ? doc->getObject(data[1].toByteArray()) : nullptr;
std::string sub = data[2].toByteArray().constData();
auto objects = editedObject->BoundaryEdges.getValues();
auto element = editedObject->BoundaryEdges.getSubValues();
auto it = objects.begin();
auto jt = element.begin();
this->vp->highlightReferences(ViewProviderFilling::Edge,
editedObject->BoundaryEdges.getSubListValues(), false);
for (; it != objects.end() && jt != element.end(); ++it, ++jt) {
if (*it == obj && *jt == sub) {
std::size_t index = std::distance(objects.begin(), it);
objects.erase(it);
element.erase(jt);
editedObject->BoundaryEdges.setValues(objects, element);
// try to remove the item also from the faces
auto faces = editedObject->BoundaryFaces.getValues();
if (index < faces.size()) {
faces.erase(faces.begin() + index);
editedObject->BoundaryFaces.setValues(faces);
}
// try to remove the item also from the orders
auto order = editedObject->BoundaryOrder.getValues();
if (index < order.size()) {
order.erase(order.begin() + index);
editedObject->BoundaryOrder.setValues(order);
}
break;
}
}
this->vp->highlightReferences(ViewProviderFilling::Edge,
editedObject->BoundaryEdges.getSubListValues(), true);
editedObject->recomputeFeature();
}
}
void FillingPanel::onIndexesMoved()
{
QAbstractItemModel* model = qobject_cast<QAbstractItemModel*>(sender());
if (!model)
return;
std::vector<App::DocumentObject*> objects;
std::vector<std::string> element;
std::vector<std::string> faces;
std::vector<long> order;
int rows = model->rowCount();
for (int i = 0; i < rows; i++) {
QModelIndex index = model->index(i, 0);
QList<QVariant> data;
data = index.data(Qt::UserRole).toList();
App::Document* doc = App::GetApplication().getDocument(data[0].toByteArray());
App::DocumentObject* obj = doc ? doc->getObject(data[1].toByteArray()) : nullptr;
std::string sub = data[2].toByteArray().constData();
std::string face = data[3].toByteArray().constData();
long cont = data[4].toInt();
objects.push_back(obj);
element.push_back(sub);
faces.push_back(face);
order.push_back(cont);
}
editedObject->BoundaryEdges.setValues(objects, element);
editedObject->BoundaryFaces.setValues(faces);
editedObject->BoundaryOrder.setValues(order);
editedObject->recomputeFeature();
}
void FillingPanel::on_buttonAccept_clicked()
{
QListWidgetItem* item = ui->listBoundary->currentItem();
if (item) {
QList<QVariant> data;
data = item->data(Qt::UserRole).toList();
QVariant face = ui->comboBoxFaces->itemData(ui->comboBoxFaces->currentIndex());
QVariant cont = ui->comboBoxCont->itemData(ui->comboBoxCont->currentIndex());
if (data.size() == 5) {
data[3] = face;
data[4] = cont;
}
else {
data << face;
data << cont;
}
item->setData(Qt::UserRole, data);
std::size_t index = ui->listBoundary->row(item);
// try to set the item of the faces
auto faces = editedObject->BoundaryFaces.getValues();
if (index < faces.size()) {
faces[index] = face.toByteArray().data();
editedObject->BoundaryFaces.setValues(faces);
}
// try to set the item of the orders
auto order = editedObject->BoundaryOrder.getValues();
if (index < order.size()) {
order[index] = cont.toInt();
editedObject->BoundaryOrder.setValues(order);
}
}
modifyBoundary(false);
ui->comboBoxFaces->clear();
ui->comboBoxCont->clear();
ui->statusLabel->clear();
editedObject->recomputeFeature();
}
void FillingPanel::on_buttonIgnore_clicked()
{
modifyBoundary(false);
ui->comboBoxFaces->clear();
ui->comboBoxCont->clear();
ui->statusLabel->clear();
}
void FillingPanel::modifyBoundary(bool on)
{
ui->buttonInitFace->setDisabled(on);
ui->lineInitFaceName->setDisabled(on);
ui->buttonEdgeAdd->setDisabled(on);
ui->buttonEdgeRemove->setDisabled(on);
ui->listBoundary->setDisabled(on);
ui->comboBoxFaces->setEnabled(on);
ui->comboBoxCont->setEnabled(on);
ui->buttonAccept->setEnabled(on);
ui->buttonIgnore->setEnabled(on);
}
void FillingPanel::exitSelectionMode()
{
// 'selectionMode' is passed by reference to the filter and changed when the filter is deleted
Gui::Selection().clearSelection();
Gui::Selection().rmvSelectionGate();
}
// ----------------------------------------------------------------------------
TaskFilling::TaskFilling(ViewProviderFilling* vp, Surface::Filling* obj)
{
// Set up button group
buttonGroup = new Gui::ButtonGroup(this);
buttonGroup->setExclusive(true);
// first task box
widget1 = new FillingPanel(vp, obj);
widget1->appendButtons(buttonGroup);
Gui::TaskView::TaskBox* taskbox1 = new Gui::TaskView::TaskBox(
Gui::BitmapFactory().pixmap("Surface_Filling"),
widget1->windowTitle(), true, nullptr);
taskbox1->groupLayout()->addWidget(widget1);
Content.push_back(taskbox1);
// second task box
widget2 = new FillingEdgePanel(vp, obj);
widget2->appendButtons(buttonGroup);
Gui::TaskView::TaskBox* taskbox2 = new Gui::TaskView::TaskBox(
QPixmap(), widget2->windowTitle(), true, nullptr);
taskbox2->groupLayout()->addWidget(widget2);
Content.push_back(taskbox2);
taskbox2->hideGroupBox();
// third task box
widget3 = new FillingVertexPanel(vp, obj);
widget3->appendButtons(buttonGroup);
Gui::TaskView::TaskBox* taskbox3 = new Gui::TaskView::TaskBox(
QPixmap(), widget3->windowTitle(), true, nullptr);
taskbox3->groupLayout()->addWidget(widget3);
Content.push_back(taskbox3);
taskbox3->hideGroupBox();
}
TaskFilling::~TaskFilling()
{
// automatically deleted in the sub-class
}
void TaskFilling::setEditedObject(Surface::Filling* obj)
{
widget1->setEditedObject(obj);
}
void TaskFilling::open()
{
widget1->open();
widget2->open();
widget3->open();
}
void TaskFilling::closed()
{
widget1->reject();
}
bool TaskFilling::accept()
{
bool ok = widget1->accept();
if (ok) {
widget2->reject();
widget3->reject();
Gui::Command::commitCommand();
Gui::Command::doCommand(Gui::Command::Gui,"Gui.ActiveDocument.resetEdit()");
Gui::Command::updateActive();
}
return ok;
}
bool TaskFilling::reject()
{
bool ok = widget1->reject();
if (ok) {
widget2->reject();
widget3->reject();
Gui::Command::abortCommand();
Gui::Command::doCommand(Gui::Command::Gui,"Gui.ActiveDocument.resetEdit()");
Gui::Command::updateActive();
}
return ok;
}
}
#include "moc_TaskFilling.cpp"
Reference in New Issue View Git Blame Copy Permalink