X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPartSet%2FPartSet_WidgetSketchLabel.cpp;h=d3908d81e0e350937d88b90f512c7156dd2fe35d;hb=ade68d25465a422af49d71881550bd89a2ecb824;hp=0c2dc8e8848fcf7731dc860ce092825994584bd3;hpb=547568321f6f46b9f60715312a33809dcff37c90;p=modules%2Fshaper.git diff --git a/src/PartSet/PartSet_WidgetSketchLabel.cpp b/src/PartSet/PartSet_WidgetSketchLabel.cpp index 0c2dc8e88..d3908d81e 100644 --- a/src/PartSet/PartSet_WidgetSketchLabel.cpp +++ b/src/PartSet/PartSet_WidgetSketchLabel.cpp @@ -1,12 +1,27 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: PartSet_WidgetSketchLabel.cpp -// Created: 07 July 2014 -// Author: Vitaly SMETANNIKOV +// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 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 +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or +// email : webmaster.salome@opencascade.com +// #include "PartSet_WidgetSketchLabel.h" #include "PartSet_Tools.h" #include "PartSet_Module.h" +#include "PartSet_PreviewPlanes.h" #include "SketchPlugin_SketchEntity.h" @@ -16,6 +31,7 @@ #include #include #include +#include #include #include @@ -31,6 +47,9 @@ #include #include #include +#include +#include +#include #include #include @@ -41,6 +60,7 @@ #include #include #include +#include #include #include @@ -48,19 +68,23 @@ #include #include #include +#include #include #include #include #include +#include +#include +#ifndef DBL_MAX +#define DBL_MAX 1.7976931348623158e+308 +#endif PartSet_WidgetSketchLabel::PartSet_WidgetSketchLabel(QWidget* theParent, - ModuleBase_IWorkshop* theWorkshop, - const Config_WidgetAPI* theData, - const std::string& theParentId, - bool toShowConstraints) -: ModuleBase_WidgetValidated(theParent, theWorkshop, theData, theParentId), - myPreviewDisplayed(false) + ModuleBase_IWorkshop* theWorkshop, + const Config_WidgetAPI* theData, + const QMap& toShowConstraints) +: ModuleBase_WidgetValidated(theParent, theWorkshop, theData) { QVBoxLayout* aLayout = new QVBoxLayout(this); ModuleBase_Tools::zeroMargins(aLayout); @@ -72,6 +96,18 @@ PartSet_WidgetSketchLabel::PartSet_WidgetSketchLabel(QWidget* theParent, // Define label for plane selection QWidget* aFirstWgt = new QWidget(this); + // Size of the View control + mySizeOfViewWidget = new QWidget(aFirstWgt); + QHBoxLayout* aSizeLayout = new QHBoxLayout(mySizeOfViewWidget); + aSizeLayout->addWidget(new QLabel("Size of the view", mySizeOfViewWidget)); + mySizeOfView = new QLineEdit(mySizeOfViewWidget); + + QDoubleValidator* aValidator = new QDoubleValidator(0, DBL_MAX, 12, mySizeOfView); + aValidator->setLocale(ModuleBase_Tools::doubleLocale()); + aValidator->setNotation(QDoubleValidator::StandardNotation); + mySizeOfView->setValidator(aValidator); + aSizeLayout->addWidget(mySizeOfView); + QString aText = QString::fromStdString(theData->getProperty("title")); QLabel* aLabel = new QLabel(aText, aFirstWgt); aLabel->setWordWrap(true); @@ -81,7 +117,9 @@ PartSet_WidgetSketchLabel::PartSet_WidgetSketchLabel(QWidget* theParent, aLayout = new QVBoxLayout(aFirstWgt); ModuleBase_Tools::zeroMargins(aLayout); + aLayout->addWidget(mySizeOfViewWidget); aLayout->addWidget(aLabel); + aLayout->addStretch(1); myStackWidget->addWidget(aFirstWgt); @@ -96,26 +134,43 @@ PartSet_WidgetSketchLabel::PartSet_WidgetSketchLabel(QWidget* theParent, myViewInverted = new QCheckBox(tr("Reversed"), aViewBox); aViewLayout->addWidget(myViewInverted); - QPushButton* aSetViewBtn = new QPushButton(QIcon(":icons/plane_view.png"), tr("Set plane view"), aViewBox); + QPushButton* aSetViewBtn = + new QPushButton(QIcon(":icons/plane_view.png"), tr("Set plane view"), aViewBox); connect(aSetViewBtn, SIGNAL(clicked(bool)), this, SLOT(onSetPlaneView())); aViewLayout->addWidget(aSetViewBtn); aLayout->addWidget(aViewBox); - myShowConstraints = new QCheckBox(tr("Show constraints"), this); - connect(myShowConstraints, SIGNAL(toggled(bool)), this, SIGNAL(showConstraintToggled(bool))); - myShowConstraints->setChecked(toShowConstraints); - aLayout->addWidget(myShowConstraints); + QMap aStates; + aStates[PartSet_Tools::Geometrical] = tr("Show geometrical constraints"); + aStates[PartSet_Tools::Dimensional] = tr("Show dimensional constraints"); + aStates[PartSet_Tools::Expressions] = tr("Show existing expressions"); + + QMap::const_iterator anIt = aStates.begin(), + aLast = aStates.end(); + for (; anIt != aLast; anIt++) { + QCheckBox* aShowConstraints = new QCheckBox(anIt.value(), this); + connect(aShowConstraints, SIGNAL(toggled(bool)), this, SLOT(onShowConstraint(bool))); + aLayout->addWidget(aShowConstraints); + + PartSet_Tools::ConstraintVisibleState aState = anIt.key(); + myShowConstraints[aState] = aShowConstraints; + + if (toShowConstraints.contains(aState)) + aShowConstraints->setChecked(toShowConstraints[aState]); + } myStackWidget->addWidget(aSecondWgt); //setLayout(aLayout); + + myPreviewPlanes = new PartSet_PreviewPlanes(); } PartSet_WidgetSketchLabel::~PartSet_WidgetSketchLabel() { } -bool PartSet_WidgetSketchLabel::setSelection(QList& theValues, +bool PartSet_WidgetSketchLabel::setSelection(QList& theValues, const bool theToValidate) { // do not use the given selection if the plane of the sketch has been already set. @@ -124,11 +179,10 @@ bool PartSet_WidgetSketchLabel::setSelection(QList& theVal if (plane().get()) return true; - ModuleBase_ViewerPrs aPrs = theValues.first(); - bool aDone = ModuleBase_WidgetValidated::setSelection(theValues, theToValidate); + ModuleBase_ViewerPrsPtr aPrs = theValues.first(); + bool aDone = setSelectionInternal(theValues, theToValidate); if (aDone) updateByPlaneSelected(aPrs); - return aDone; } @@ -141,49 +195,130 @@ QList PartSet_WidgetSketchLabel::getControls() const void PartSet_WidgetSketchLabel::onSelectionChanged() { - QList aSelected = getFilteredSelected(); + QList aSelected = getFilteredSelected(); if (aSelected.empty()) return; - ModuleBase_ViewerPrs aPrs = aSelected.first(); - - bool aDone = ModuleBase_WidgetValidated::setSelection(aSelected, false); + ModuleBase_ViewerPrsPtr aPrs = aSelected.first(); + bool aDone = setSelectionInternal(aSelected, false); if (aDone) { updateByPlaneSelected(aPrs); updateObject(myFeature); } } -void PartSet_WidgetSketchLabel::updateByPlaneSelected(const ModuleBase_ViewerPrs& thePrs) +void PartSet_WidgetSketchLabel::onShowConstraint(bool theOn) +{ + QCheckBox* aSenderCheckBox = qobject_cast(sender()); + + QMap::const_iterator + anIt = myShowConstraints.begin(), aLast = myShowConstraints.end(); + + PartSet_Tools::ConstraintVisibleState aState = PartSet_Tools::Geometrical; + bool aFound = false; + for (; anIt != aLast && !aFound; anIt++) { + aFound = anIt.value() == aSenderCheckBox; + if (aFound) + aState = anIt.key(); + } + if (aFound) + emit showConstraintToggled(aState, theOn); +} + +void PartSet_WidgetSketchLabel::blockAttribute(const AttributePtr& theAttribute, + const bool& theToBlock, bool& isFlushesActived, + bool& isAttributeSetInitializedBlocked, + bool& isAttributeSendUpdatedBlocked) +{ + ModuleBase_WidgetValidated::blockAttribute(theAttribute, theToBlock, isFlushesActived, + isAttributeSetInitializedBlocked, + isAttributeSendUpdatedBlocked); + // We do not restore the previous state of isAttributeSetInitializedBlocked for each of + // attributes. It it is necessary, these states should be append to the method attributes + // or stored in the widget + + std::list anAttributes = myFeature->data()->attributes(""); + std::list::const_iterator anIt = anAttributes.begin(), aLast = anAttributes.end(); + QStringList aValues; + for(; anIt != aLast; anIt++) { + AttributePtr anAttribute = *anIt; + if (theToBlock) + anAttribute->blockSetInitialized(true); + else + anAttribute->blockSetInitialized(isAttributeSetInitializedBlocked); + } +} + +bool PartSet_WidgetSketchLabel::setSelectionInternal( + const QList& theValues, + const bool theToValidate) { - // 1. hide main planes if they have been displayed - erasePreviewPlanes(); + bool aDone = false; + if (theValues.empty()) { + // In order to make reselection possible, set empty object and shape should be done + setSelectionCustom(std::shared_ptr( + new ModuleBase_ViewerPrs(ObjectPtr(), GeomShapePtr(), NULL))); + aDone = false; + } + else { + // it removes the processed value from the parameters list + ModuleBase_ViewerPrsPtr aValue = theValues.first();//.takeFirst(); + if (!theToValidate || isValidInFilters(aValue)) + aDone = setSelectionCustom(aValue); + } + + return aDone; +} + +void PartSet_WidgetSketchLabel::updateByPlaneSelected(const ModuleBase_ViewerPrsPtr& thePrs) +{ + // 1. hide main planes if they have been displayed and display sketch preview plane + myPreviewPlanes->erasePreviewPlanes(myWorkshop); + + PartSet_Module* aModule = dynamic_cast(myWorkshop->module()); + if (aModule) { + CompositeFeaturePtr aSketch = std::dynamic_pointer_cast(myFeature); + aModule->sketchMgr()->previewSketchPlane()->createSketchPlane(aSketch, myWorkshop); + } // 2. if the planes were displayed, change the view projection - TopoDS_Shape aShape = thePrs.shape(); + const GeomShapePtr& aShape = thePrs->shape(); std::shared_ptr aGShape; - std::shared_ptr aBaseShape; DataPtr aData = feature()->data(); AttributeSelectionPtr aSelAttr = std::dynamic_pointer_cast (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID())); // selection happens in OCC viewer - if (!aShape.IsNull()) { - aGShape = std::shared_ptr(new GeomAPI_Shape()); - aGShape->setImpl(new TopoDS_Shape(aShape)); - - if (aSelAttr && aSelAttr->context()) { - aBaseShape = aSelAttr->context()->shape(); - } + if (aShape.get() && !aShape->isNull()) { + aGShape = aShape; } else { // selection happens in OCC viewer(on body) of in the OB browser if (aSelAttr) { aGShape = aSelAttr->value(); } } + // If the selected object is a sketch then use its plane + std::shared_ptr aPlane; + ObjectPtr aObj = thePrs->object(); + // obsolete as selected sketch is stored in external attribute + /*if (aObj.get()) { + FeaturePtr aFeature = ModelAPI_Feature::feature(aObj); + if (aFeature.get() && (aFeature != feature())) { + if (aFeature->getKind() == SketchPlugin_Sketch::ID()) { + CompositeFeaturePtr aSketch = + std::dynamic_pointer_cast(aFeature); + aPlane = PartSet_Tools::sketchPlane(aSketch); + } + } + }*/ if (aGShape.get() != NULL) { // get plane parameters - std::shared_ptr aPlane = GeomAlgoAPI_FaceBuilder::plane(aGShape); + if (!aPlane.get()) { + std::shared_ptr aFace(new GeomAPI_Face(aGShape)); + aPlane = aFace->getPlane(); + } + if (!aPlane.get()) + return; std::shared_ptr aDir = aPlane->direction(); gp_XYZ aXYZ = aDir->impl().XYZ(); double aTwist = 0.0; @@ -195,26 +330,39 @@ void PartSet_WidgetSketchLabel::updateByPlaneSelected(const ModuleBase_ViewerPrs // Rotate view if the sketcher plane is selected only from preview planes // Preview planes are created only if there is no any shape - bool aRotate = Config_PropManager::boolean("Sketch planes", "rotate_to_plane", "false"); + bool aRotate = Config_PropManager::boolean(SKETCH_TAB_NAME, "rotate_to_plane"); if (aRotate) { myWorkshop->viewer()->setViewProjection(aXYZ.X(), aXYZ.Y(), aXYZ.Z(), aTwist); - PartSet_Module* aModule = dynamic_cast(myWorkshop->module()); - if (aModule) - aModule->onViewTransformed(); } + QString aSizeOfViewStr = mySizeOfView->text(); + if (!aSizeOfViewStr.isEmpty()) { + bool isOk; + double aSizeOfView = aSizeOfViewStr.toDouble(&isOk); + if (isOk && aSizeOfView > 0) { + Handle(V3d_View) aView3d = myWorkshop->viewer()->activeView(); + if (!aView3d.IsNull()) { + Bnd_Box aBndBox; + double aHalfSize = aSizeOfView/2.0; + aBndBox.Update(-aHalfSize, -aHalfSize, -aHalfSize, aHalfSize, aHalfSize, aHalfSize); + aView3d->FitAll(aBndBox, 0.01, false); + } + } + } + PartSet_Module* aModule = dynamic_cast(myWorkshop->module()); + if (aModule) + aModule->onViewTransformed(); } // 3. Clear text in the label myStackWidget->setCurrentIndex(1); //myLabel->setText(""); //myLabel->setToolTip(""); - disconnect(workshop()->selector(), SIGNAL(selectionChanged()), + XGUI_Workshop* aWorkshop = XGUI_Tools::workshop(myWorkshop); + disconnect(aWorkshop->selector(), SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged())); // 4. deactivate face selection filter activateFilters(false); // 5. Clear selection mode and define sketching mode - //XGUI_Displayer* aDisp = workshop()->displayer(); - //aDisp->closeLocalContexts(); emit planeSelected(plane()); // after the plane is selected in the sketch, the sketch selection should be activated // it can not be performed in the sketch label widget because, we don't need to switch off @@ -222,8 +370,10 @@ void PartSet_WidgetSketchLabel::updateByPlaneSelected(const ModuleBase_ViewerPrs activateSelection(true); // 6. Update sketcher actions - XGUI_ActionsMgr* anActMgr = workshop()->actionsMgr(); - anActMgr->update(); + XGUI_ActionsMgr* anActMgr = aWorkshop->actionsMgr(); + + myWorkshop->updateCommandStatus(); + aWorkshop->selector()->clearSelection(); myWorkshop->viewer()->update(); } @@ -235,7 +385,7 @@ std::shared_ptr PartSet_WidgetSketchLabel::plane() const bool PartSet_WidgetSketchLabel::focusTo() { - myStackWidget->setFocus(); + ModuleBase_Tools::setFocus(myStackWidget, "PartSet_WidgetSketchLabel::focusTo()"); return true; } @@ -244,14 +394,15 @@ void PartSet_WidgetSketchLabel::enableFocusProcessing() myStackWidget->installEventFilter(this); } -void PartSet_WidgetSketchLabel::storeAttributeValue() +void PartSet_WidgetSketchLabel::storeAttributeValue(const AttributePtr& theAttribute) { - ModuleBase_WidgetValidated::storeAttributeValue(); + ModuleBase_WidgetValidated::storeAttributeValue(theAttribute); } -void PartSet_WidgetSketchLabel::restoreAttributeValue(const bool theValid) +void PartSet_WidgetSketchLabel::restoreAttributeValue(const AttributePtr& theAttribute, + const bool theValid) { - ModuleBase_WidgetValidated::restoreAttributeValue(theValid); + ModuleBase_WidgetValidated::restoreAttributeValue(theAttribute, theValid); // it is not necessary to save the previous plane value because the plane is chosen once DataPtr aData = feature()->data(); @@ -264,27 +415,63 @@ void PartSet_WidgetSketchLabel::restoreAttributeValue(const bool theValid) } } -bool PartSet_WidgetSketchLabel::setSelectionCustom(const ModuleBase_ViewerPrs& thePrs) +bool PartSet_WidgetSketchLabel::setSelectionCustom(const ModuleBase_ViewerPrsPtr& thePrs) +{ + return fillSketchPlaneBySelection(thePrs); +} + +bool PartSet_WidgetSketchLabel::canFillSketch(const ModuleBase_ViewerPrsPtr& thePrs) +{ + bool aCanFillSketch = true; + // avoid any selection on sketch object + ObjectPtr anObject = thePrs->object(); + ResultPtr aResult = std::dynamic_pointer_cast(anObject); + if (aResult.get()) { + FeaturePtr aFeature = ModelAPI_Feature::feature(aResult); + if (aFeature->getKind() == SketchPlugin_Sketch::ID()) + aCanFillSketch = false; + } + // check plane or planar face of any non-sketch object + if (aCanFillSketch) { + std::shared_ptr aGeomFace; + + GeomShapePtr aGeomShape = thePrs->shape(); + if ((!aGeomShape.get() || aGeomShape->isNull()) && aResult.get()) { + aGeomShape = aResult->shape(); + } + + if (aGeomShape.get() && aGeomShape->shapeType() == GeomAPI_Shape::FACE) { + std::shared_ptr aGeomFace(new GeomAPI_Face(aGeomShape)); + aCanFillSketch = aGeomFace.get() && aGeomFace->isPlanar(); + } + else + aCanFillSketch = false; + } + return aCanFillSketch; +} + +bool PartSet_WidgetSketchLabel::fillSketchPlaneBySelection(const ModuleBase_ViewerPrsPtr& thePrs) { bool isOwnerSet = false; - const TopoDS_Shape& aShape = thePrs.shape(); + const GeomShapePtr& aShape = thePrs->shape(); std::shared_ptr aDir; - if (thePrs.object() && (feature() != thePrs.object())) { + if (thePrs->object() && (feature() != thePrs->object())) { + FeaturePtr aFeature = ModelAPI_Feature::feature(thePrs->object()); DataPtr aData = feature()->data(); - AttributeSelectionPtr aSelAttr = + AttributeSelectionPtr aSelAttr = std::dynamic_pointer_cast (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID())); if (aSelAttr) { - ResultPtr aRes = std::dynamic_pointer_cast(thePrs.object()); + ResultPtr aRes = std::dynamic_pointer_cast(thePrs->object()); if (aRes) { GeomShapePtr aShapePtr(new GeomAPI_Shape()); - if (aShape.IsNull()) { // selection happens in the OCC viewer + if (!aShape.get() || aShape->isNull()) { // selection happens in the OCC viewer aShapePtr = ModelAPI_Tools::shape(aRes); } else { // selection happens in OB browser - aShapePtr->setImpl(new TopoDS_Shape(aShape)); + aShapePtr = aShape; } if (aShapePtr.get() != NULL) { aSelAttr->setValue(aRes, aShapePtr); @@ -293,8 +480,9 @@ bool PartSet_WidgetSketchLabel::setSelectionCustom(const ModuleBase_ViewerPrs& t } } } - else if (!aShape.IsNull()) { - aDir = setSketchPlane(aShape); + else if (aShape.get() && !aShape->isNull()) { + const TopoDS_Shape& aTDShape = aShape->impl(); + aDir = setSketchPlane(aTDShape); isOwnerSet = aDir.get(); } return isOwnerSet; @@ -310,38 +498,38 @@ void PartSet_WidgetSketchLabel::activateCustom() } myStackWidget->setCurrentIndex(0); - bool aBodyIsVisualized = false; - XGUI_Displayer* aDisp = workshop()->displayer(); - QObjectPtrList aDisplayed = aDisp->displayedObjects(); - foreach (ObjectPtr anObj, aDisplayed) { - ResultPtr aResult = std::dynamic_pointer_cast(anObj); - if (aResult.get() != NULL) { - aBodyIsVisualized = aResult->groupName() == ModelAPI_ResultBody::group(); - if (aBodyIsVisualized) - break; - } - } + bool aBodyIsVisualized = myPreviewPlanes->hasVisualizedBodies(myWorkshop); + + // Clear previous selection mode It is necessary for correct activation of preview planes + XGUI_Workshop* aWorkshop = XGUI_Tools::workshop(myWorkshop); + XGUI_Displayer* aDisp = aWorkshop->displayer(); + aDisp->activateObjects(QIntList(), aDisp->displayedObjects(), false); if (!aBodyIsVisualized) { // We have to select a plane before any operation - showPreviewPlanes(); + myPreviewPlanes->showPreviewPlanes(myWorkshop); + mySizeOfViewWidget->setVisible(true); } - activateSelection(true); + else + mySizeOfViewWidget->setVisible(false); - //myLabel->setText(myText); - //myLabel->setToolTip(myTooltip); + activateSelection(true); - connect(workshop()->selector(), SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged())); + connect(XGUI_Tools::workshop(myWorkshop)->selector(), SIGNAL(selectionChanged()), + this, SLOT(onSelectionChanged())); activateFilters(true); } void PartSet_WidgetSketchLabel::deactivate() { ModuleBase_ModelWidget::deactivate(); - erasePreviewPlanes(); + bool aHidePreview = myPreviewPlanes->isPreviewDisplayed(); + myPreviewPlanes->erasePreviewPlanes(myWorkshop); activateSelection(false); activateFilters(false); + if (aHidePreview) + myWorkshop->viewer()->update(); } void PartSet_WidgetSketchLabel::activateSelection(bool toActivate) @@ -361,68 +549,9 @@ void PartSet_WidgetSketchLabel::activateSelection(bool toActivate) } } -void PartSet_WidgetSketchLabel::erasePreviewPlanes() -{ - if (myPreviewDisplayed) { - XGUI_Displayer* aDisp = workshop()->displayer(); - aDisp->eraseAIS(myYZPlane, false); - aDisp->eraseAIS(myXZPlane, false); - aDisp->eraseAIS(myXYPlane, false); - myPreviewDisplayed = false; - } -} - -void PartSet_WidgetSketchLabel::showPreviewPlanes() -{ - if (myPreviewDisplayed) - return; - - if (!myYZPlane) { // If planes are not created - // Create Preview - std::shared_ptr anOrigin(new GeomAPI_Pnt(0, 0, 0)); - std::shared_ptr aYZDir(new GeomAPI_Dir(1, 0, 0)); - // -1, not 1 for correct internal sketch coords (issue 898) - std::shared_ptr aXZDir(new GeomAPI_Dir(0, -1, 0)); - std::shared_ptr aXYDir(new GeomAPI_Dir(0, 0, 1)); - - std::vector aYZRGB, aXZRGB, aXYRGB; - aYZRGB = Config_PropManager::color("Visualization", "yz_plane_color", - YZ_PLANE_COLOR); - aXZRGB = Config_PropManager::color("Visualization", "xz_plane_color", - XZ_PLANE_COLOR); - aXYRGB = Config_PropManager::color("Visualization", "xy_plane_color", - XY_PLANE_COLOR); - int aR[] = {aYZRGB[0], aYZRGB[1], aYZRGB[2]}; - int aG[] = {aXZRGB[0], aXZRGB[1], aXZRGB[2]}; - int aB[] = {aXYRGB[0], aXYRGB[1], aXYRGB[2]}; - - myYZPlane = createPreviewPlane(anOrigin, aYZDir, aR); - myXZPlane = createPreviewPlane(anOrigin, aXZDir, aG); - myXYPlane = createPreviewPlane(anOrigin, aXYDir, aB); - } - XGUI_Displayer* aDisp = workshop()->displayer(); - aDisp->displayAIS(myYZPlane, true, false); - aDisp->displayAIS(myXZPlane, true, false); - aDisp->displayAIS(myXYPlane, true, false); - myPreviewDisplayed = true; -} - -AISObjectPtr PartSet_WidgetSketchLabel::createPreviewPlane(std::shared_ptr theOrigin, - std::shared_ptr theNorm, - const int theRGB[3]) -{ - double aSize = Config_PropManager::integer("Sketch planes", "planes_size", PLANE_SIZE); - std::shared_ptr aFace = GeomAlgoAPI_FaceBuilder::square(theOrigin, theNorm, aSize); - AISObjectPtr aAIS = AISObjectPtr(new GeomAPI_AISObject()); - aAIS->createShape(aFace); - aAIS->setWidth(Config_PropManager::integer("Sketch planes", "planes_thickness", SKETCH_WIDTH)); - aAIS->setColor(theRGB[0], theRGB[1], theRGB[2]); - return aAIS; -} - - -std::shared_ptr PartSet_WidgetSketchLabel::setSketchPlane(const TopoDS_Shape& theShape) +std::shared_ptr + PartSet_WidgetSketchLabel::setSketchPlane(const TopoDS_Shape& theShape) { if (theShape.IsNull()) return std::shared_ptr(); @@ -431,17 +560,21 @@ std::shared_ptr PartSet_WidgetSketchLabel::setSketchPlane(const Top std::shared_ptr aGShape(new GeomAPI_Shape); aGShape->setImpl(new TopoDS_Shape(theShape)); - - // get plane parameters - std::shared_ptr aPlane = GeomAlgoAPI_FaceBuilder::plane(aGShape); + std::shared_ptr aFace(new GeomAPI_Face(aGShape)); + std::shared_ptr aPlane = aFace->getPlane(); if (!aPlane.get()) return std::shared_ptr(); + return setSketchPlane(aPlane); +} +std::shared_ptr + PartSet_WidgetSketchLabel::setSketchPlane(std::shared_ptr thePlane) +{ // set plane parameters to feature std::shared_ptr aData = feature()->data(); double anA, aB, aC, aD; - aPlane->coefficients(anA, aB, aC, aD); + thePlane->coefficients(anA, aB, aC, aD); // calculate attributes of the sketch std::shared_ptr aNormDir(new GeomAPI_Dir(anA, aB, aC)); @@ -451,7 +584,7 @@ std::shared_ptr PartSet_WidgetSketchLabel::setSketchPlane(const Top std::shared_ptr anOrigPnt(new GeomAPI_Pnt(aCoords)); // X axis is preferable to be dirX on the sketch const double tol = Precision::Confusion(); - bool isX = fabs(anA - 1.0) < tol && fabs(aB) < tol && fabs(aC) < tol; + bool isX = fabs(fabs(anA) - 1.0) < tol && fabs(aB) < tol && fabs(aC) < tol; std::shared_ptr aTempDir( isX ? new GeomAPI_Dir(0, 1, 0) : new GeomAPI_Dir(1, 0, 0)); std::shared_ptr aYDir(new GeomAPI_Dir(aNormDir->cross(aTempDir))); @@ -466,23 +599,10 @@ std::shared_ptr PartSet_WidgetSketchLabel::setSketchPlane(const Top std::shared_ptr aDirX = std::dynamic_pointer_cast( aData->attribute(SketchPlugin_Sketch::DIRX_ID())); aDirX->setValue(aXDir); - std::shared_ptr aDir = aPlane->direction(); + std::shared_ptr aDir = thePlane->direction(); return aDir; } -void PartSet_WidgetSketchLabel::showConstraints(bool theOn) -{ - myShowConstraints->setChecked(theOn); - emit showConstraintToggled(theOn); -} - -XGUI_Workshop* PartSet_WidgetSketchLabel::workshop() const -{ - XGUI_ModuleConnector* aConnector = dynamic_cast(myWorkshop); - return aConnector->workshop(); -} - - void PartSet_WidgetSketchLabel::onSetPlaneView() { std::shared_ptr aPlane = plane(); @@ -497,3 +617,47 @@ void PartSet_WidgetSketchLabel::onSetPlaneView() aModule->onViewTransformed(); } } + + +//****************************************************** +QList> PartSet_WidgetSketchLabel::findCircularEdgesInPlane() +{ + QList> aResult; + XGUI_Workshop* aWorkshop = XGUI_Tools::workshop(myWorkshop); + XGUI_Displayer* aDisplayer = aWorkshop->displayer(); + QObjectPtrList aDispObjects = aDisplayer->displayedObjects(); + + std::shared_ptr aPlane = plane(); + foreach(ObjectPtr aObj, aDispObjects) { + ResultPtr aResObj = std::dynamic_pointer_cast(aObj); + if (aResObj.get()) { + GeomShapePtr aShape = aResObj->shape(); + if (aShape.get()) { + GeomAPI_ShapeExplorer aExplorer(aShape, GeomAPI_Shape::EDGE); + for(; aExplorer.more(); aExplorer.next()) { + GeomShapePtr aEdgeShape = aExplorer.current(); + GeomAPI_Edge anEdge(aEdgeShape); + if ((anEdge.isCircle() || anEdge.isArc() || anEdge.isEllipse()) && + anEdge.isInPlane(aPlane)) { + bool isContains = false; + // Check that edge is not used. + // It is possible that the same edge will be taken from different faces + foreach(std::shared_ptr aPrs, aResult) { + GeomAPI_Edge aUsedEdge(aPrs->shape()); + if (aUsedEdge.isEqual(aEdgeShape)) { + isContains = true; + break; + } + } + if (!isContains) { + std::shared_ptr + aPrs(new ModuleBase_ViewerPrs(aResObj, aEdgeShape)); + aResult.append(aPrs); + } + } + } + } + } + } + return aResult; +}