src/PartSet/PartSet_WidgetSketchLabel.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:        PartSet_WidgetSketchLabel.cpp
   4 // Created:     07 July 2014
   5 // Author:      Vitaly SMETANNIKOV
   6
   7 #include "PartSet_WidgetSketchLabel.h"
   8 #include "PartSet_Tools.h"
   9 #include "PartSet_Module.h"
  10
  11 #include "SketchPlugin_SketchEntity.h"
  12
  13 #include <XGUI_Workshop.h>
  14 #include <XGUI_Displayer.h>
  15 #include <XGUI_SelectionMgr.h>
  16 #include <XGUI_Selection.h>
  17 #include <XGUI_ViewerProxy.h>
  18 #include <XGUI_ActionsMgr.h>
  19 #include <XGUI_ModuleConnector.h>
  20
  21 #include <ModuleBase_Operation.h>
  22 #include <ModuleBase_ViewerPrs.h>
  23 #include <ModuleBase_Tools.h>
  24 #include <ModuleBase_IModule.h>
  25
  26 #include <ModelAPI_ResultBody.h>
  27 #include <ModelAPI_Tools.h>
  28
  29 #include <GeomAlgoAPI_FaceBuilder.h>
  30 #include <GeomAlgoAPI_ShapeTools.h>
  31 #include <GeomDataAPI_Point.h>
  32 #include <GeomDataAPI_Dir.h>
  33 #include <GeomAPI_XYZ.h>
  34
  35 #include <SketchPlugin_Sketch.h>
  36 #include <SketcherPrs_Tools.h>
  37
  38 #include <Precision.hxx>
  39 #include <gp_Pln.hxx>
  40 #include <gp_Pnt.hxx>
  41 #include <gp_Dir.hxx>
  42 #include <AIS_Shape.hxx>
  43 #include <AIS_DimensionSelectionMode.hxx>
  44
  45 #include <Config_WidgetAPI.h>
  46 #include <Config_PropManager.h>
  47
  48 #include <QLabel>
  49 #include <QApplication>
  50 #include <QVBoxLayout>
  51 #include <QCheckBox>
  52 #include <QGroupBox>
  53 #include <QPushButton>
  54 #include <QStackedWidget>
  55
  56
  57 PartSet_WidgetSketchLabel::PartSet_WidgetSketchLabel(QWidget* theParent,
  58                                                      ModuleBase_IWorkshop* theWorkshop,
  59                                                      const Config_WidgetAPI* theData,
  60                                                      const std::string& theParentId,
  61                                                      bool toShowConstraints)
  62 : ModuleBase_WidgetValidated(theParent, theWorkshop, theData, theParentId),
  63   myPreviewDisplayed(false)
  64 {
  65   QVBoxLayout* aLayout = new QVBoxLayout(this);
  66   ModuleBase_Tools::zeroMargins(aLayout);
  67
  68   myStackWidget = new QStackedWidget(this);
  69   myStackWidget->setContentsMargins(0,0,0,0);
  70   aLayout->addWidget(myStackWidget);
  71
  72   // Define label for plane selection
  73   QWidget* aFirstWgt = new QWidget(this);
  74
  75   QString aText = QString::fromStdString(theData->getProperty("title"));
  76   QLabel* aLabel = new QLabel(aText, aFirstWgt);
  77   aLabel->setWordWrap(true);
  78   QString aTooltip = QString::fromStdString(theData->getProperty("tooltip"));
  79   aLabel->setToolTip(aTooltip);
  80   aLabel->setIndent(5);
  81
  82   aLayout = new QVBoxLayout(aFirstWgt);
  83   ModuleBase_Tools::zeroMargins(aLayout);
  84   aLayout->addWidget(aLabel);
  85
  86   myStackWidget->addWidget(aFirstWgt);
  87
  88   // Define widget for sketch manmagement
  89   QWidget* aSecondWgt = new QWidget(this);
  90   aLayout = new QVBoxLayout(aSecondWgt);
  91   ModuleBase_Tools::zeroMargins(aLayout);
  92
  93   QGroupBox* aViewBox = new QGroupBox(tr("Sketcher plane"), this);
  94   QVBoxLayout* aViewLayout = new QVBoxLayout(aViewBox);
  95
  96   myViewInverted = new QCheckBox(tr("Reversed"), aViewBox);
  97   aViewLayout->addWidget(myViewInverted);
  98
  99   QPushButton* aSetViewBtn = new QPushButton(QIcon(":icons/plane_view.png"), tr("Set plane view"), aViewBox);
 100   connect(aSetViewBtn, SIGNAL(clicked(bool)), this, SLOT(onSetPlaneView()));
 101   aViewLayout->addWidget(aSetViewBtn);
 102
 103   aLayout->addWidget(aViewBox);
 104
 105   myShowConstraints = new QCheckBox(tr("Show constraints"), this);
 106   connect(myShowConstraints, SIGNAL(toggled(bool)), this, SIGNAL(showConstraintToggled(bool)));
 107   myShowConstraints->setChecked(toShowConstraints);
 108   aLayout->addWidget(myShowConstraints);
 109
 110   myStackWidget->addWidget(aSecondWgt);
 111   //setLayout(aLayout);
 112 }
 113
 114 PartSet_WidgetSketchLabel::~PartSet_WidgetSketchLabel()
 115 {
 116 }
 117
 118 bool PartSet_WidgetSketchLabel::setSelection(QList<ModuleBase_ViewerPrs>& theValues,
 119                                              const bool theToValidate)
 120 {
 121   // do not use the given selection if the plane of the sketch has been already set.
 122   // If this check is absent, a selected plane in the viewer can be set in the sketch
 123   // even if the sketch is built on another plane.
 124   if (plane().get())
 125     return true;
 126
 127   ModuleBase_ViewerPrs aPrs = theValues.first();
 128   bool aDone = ModuleBase_WidgetValidated::setSelection(theValues, theToValidate);
 129   if (aDone)
 130     updateByPlaneSelected(aPrs);
 131
 132   return aDone;
 133 }
 134
 135 QList<QWidget*> PartSet_WidgetSketchLabel::getControls() const
 136 {
 137   QList<QWidget*> aResult;
 138   aResult << myStackWidget;
 139   return aResult;
 140 }
 141
 142 void PartSet_WidgetSketchLabel::onSelectionChanged()
 143 {
 144   QList<ModuleBase_ViewerPrs> aSelected = getFilteredSelected();
 145
 146   if (aSelected.empty())
 147     return;
 148   ModuleBase_ViewerPrs aPrs = aSelected.first();
 149
 150   bool aDone = ModuleBase_WidgetValidated::setSelection(aSelected, false);
 151   if (aDone) {
 152     updateByPlaneSelected(aPrs);
 153     updateObject(myFeature);
 154   }
 155 }
 156
 157 void PartSet_WidgetSketchLabel::updateByPlaneSelected(const ModuleBase_ViewerPrs& thePrs)
 158 {
 159   // 1. hide main planes if they have been displayed
 160   erasePreviewPlanes();
 161   // 2. if the planes were displayed, change the view projection
 162   TopoDS_Shape aShape = thePrs.shape();
 163   std::shared_ptr<GeomAPI_Shape> aGShape;
 164   std::shared_ptr<GeomAPI_Shape> aBaseShape;
 165
 166   DataPtr aData = feature()->data();
 167   AttributeSelectionPtr aSelAttr = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>
 168                             (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID()));
 169
 170   // selection happens in OCC viewer
 171   if (!aShape.IsNull()) {
 172     aGShape =  std::shared_ptr<GeomAPI_Shape>(new GeomAPI_Shape());
 173     aGShape->setImpl(new TopoDS_Shape(aShape));
 174
 175     if (aSelAttr && aSelAttr->context()) {
 176       aBaseShape = aSelAttr->context()->shape();
 177     }
 178   }
 179   else { // selection happens in OCC viewer(on body) of in the OB browser
 180     if (aSelAttr) {
 181       aGShape = aSelAttr->value();
 182     }
 183   }
 184   if (aGShape.get() != NULL) {
 185     // get plane parameters
 186     std::shared_ptr<GeomAPI_Pln> aPlane = GeomAlgoAPI_FaceBuilder::plane(aGShape);
 187     std::shared_ptr<GeomAPI_Dir> aDir = aPlane->direction();
 188     gp_XYZ aXYZ = aDir->impl<gp_Dir>().XYZ();
 189     double aTwist = 0.0;
 190
 191     // orienting projection is not needed: it is done in GeomAlgoAPI_FaceBuilder::plane
 192     /*if (aGShape->impl<TopoDS_Shape>().Orientation() == TopAbs_REVERSED) {
 193       aXYZ.Reverse();
 194     }*/
 195
 196     // Rotate view if the sketcher plane is selected only from preview planes
 197     // Preview planes are created only if there is no any shape
 198     bool aRotate = Config_PropManager::boolean("Sketch planes", "rotate_to_plane", "false");
 199     if (aRotate) {
 200       myWorkshop->viewer()->setViewProjection(aXYZ.X(), aXYZ.Y(), aXYZ.Z(), aTwist);
 201       PartSet_Module* aModule = dynamic_cast<PartSet_Module*>(myWorkshop->module());
 202       if (aModule)
 203         aModule->onViewTransformed();
 204     }
 205   }
 206   // 3. Clear text in the label
 207   myStackWidget->setCurrentIndex(1);
 208   //myLabel->setText("");
 209   //myLabel->setToolTip("");
 210   disconnect(workshop()->selector(), SIGNAL(selectionChanged()),
 211               this, SLOT(onSelectionChanged()));
 212   // 4. deactivate face selection filter
 213   activateFilters(false);
 214
 215   // 5. Clear selection mode and define sketching mode
 216   //XGUI_Displayer* aDisp = workshop()->displayer();
 217   //aDisp->closeLocalContexts();
 218   emit planeSelected(plane());
 219   // after the plane is selected in the sketch, the sketch selection should be activated
 220   // it can not be performed in the sketch label widget because, we don't need to switch off
 221   // the selection by any label deactivation, but need to switch it off by stop the sketch
 222   activateSelection(true);
 223
 224   // 6. Update sketcher actions
 225   XGUI_ActionsMgr* anActMgr = workshop()->actionsMgr();
 226   myWorkshop->updateCommandStatus();
 227   myWorkshop->viewer()->update();
 228 }
 229
 230 std::shared_ptr<GeomAPI_Pln> PartSet_WidgetSketchLabel::plane() const
 231 {
 232   CompositeFeaturePtr aSketch = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(myFeature);
 233   return PartSet_Tools::sketchPlane(aSketch);
 234 }
 235
 236 bool PartSet_WidgetSketchLabel::focusTo()
 237 {
 238   ModuleBase_Tools::setFocus(myStackWidget, "PartSet_WidgetSketchLabel::focusTo()");
 239   return true;
 240 }
 241
 242 void PartSet_WidgetSketchLabel::enableFocusProcessing()
 243 {
 244   myStackWidget->installEventFilter(this);
 245 }
 246
 247 void PartSet_WidgetSketchLabel::storeAttributeValue()
 248 {
 249   ModuleBase_WidgetValidated::storeAttributeValue();
 250 }
 251
 252 void PartSet_WidgetSketchLabel::restoreAttributeValue(const bool theValid)
 253 {
 254   ModuleBase_WidgetValidated::restoreAttributeValue(theValid);
 255
 256   // it is not necessary to save the previous plane value because the plane is chosen once
 257   DataPtr aData = feature()->data();
 258   AttributeSelectionPtr aSelAttr = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>
 259     (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID()));
 260   if (aSelAttr) {
 261     ResultPtr anEmptyResult;
 262     GeomShapePtr anEmptyShape;
 263     aSelAttr->setValue(anEmptyResult, anEmptyShape);
 264   }
 265 }
 266
 267 bool PartSet_WidgetSketchLabel::setSelectionCustom(const ModuleBase_ViewerPrs& thePrs)
 268 {
 269   bool isOwnerSet = false;
 270
 271   const TopoDS_Shape& aShape = thePrs.shape();
 272   std::shared_ptr<GeomAPI_Dir> aDir;
 273
 274   if (thePrs.object() && (feature() != thePrs.object())) {
 275     DataPtr aData = feature()->data();
 276     AttributeSelectionPtr aSelAttr =
 277       std::dynamic_pointer_cast<ModelAPI_AttributeSelection>
 278       (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID()));
 279     if (aSelAttr) {
 280       ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(thePrs.object());
 281       if (aRes) {
 282         GeomShapePtr aShapePtr(new GeomAPI_Shape());
 283         if (aShape.IsNull()) {  // selection happens in the OCC viewer
 284           aShapePtr = ModelAPI_Tools::shape(aRes);
 285         }
 286         else { // selection happens in OB browser
 287           aShapePtr->setImpl(new TopoDS_Shape(aShape));
 288         }
 289         if (aShapePtr.get() != NULL) {
 290           aSelAttr->setValue(aRes, aShapePtr);
 291           isOwnerSet = true;
 292         }
 293       }
 294     }
 295   }
 296   else if (!aShape.IsNull()) {
 297     aDir = setSketchPlane(aShape);
 298     isOwnerSet = aDir.get();
 299   }
 300   return isOwnerSet;
 301 }
 302
 303 void PartSet_WidgetSketchLabel::activateCustom()
 304 {
 305   std::shared_ptr<GeomAPI_Pln> aPlane = plane();
 306   if (aPlane.get()) {
 307     myStackWidget->setCurrentIndex(1);
 308     activateSelection(true);
 309     return;
 310   }
 311
 312   myStackWidget->setCurrentIndex(0);
 313   bool aBodyIsVisualized = false;
 314   XGUI_Displayer* aDisp = workshop()->displayer();
 315   QObjectPtrList aDisplayed = aDisp->displayedObjects();
 316   foreach (ObjectPtr anObj, aDisplayed) {
 317     ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObj);
 318     if (aResult.get() != NULL) {
 319       aBodyIsVisualized = aResult->groupName() == ModelAPI_ResultBody::group();
 320       if (aBodyIsVisualized)
 321         break;
 322     }
 323   }
 324
 325   if (!aBodyIsVisualized) {
 326     // We have to select a plane before any operation
 327     showPreviewPlanes();
 328   }
 329   activateSelection(true);
 330
 331   //myLabel->setText(myText);
 332   //myLabel->setToolTip(myTooltip);
 333
 334   connect(workshop()->selector(), SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged()));
 335   activateFilters(true);
 336 }
 337
 338 void PartSet_WidgetSketchLabel::deactivate()
 339 {
 340   ModuleBase_ModelWidget::deactivate();
 341   bool aHidePreview = myPreviewDisplayed;
 342   erasePreviewPlanes();
 343   activateSelection(false);
 344
 345   activateFilters(false);
 346   if (aHidePreview)
 347     myWorkshop->viewer()->update();
 348 }
 349
 350 void PartSet_WidgetSketchLabel::activateSelection(bool toActivate)
 351 {
 352   if (toActivate) {
 353     QIntList aModes;
 354     std::shared_ptr<GeomAPI_Pln> aPlane = plane();
 355     if (aPlane.get()) {
 356       myWorkshop->module()->activeSelectionModes(aModes);
 357     }
 358     else {
 359       aModes << TopAbs_FACE;
 360     }
 361     myWorkshop->activateSubShapesSelection(aModes);
 362   } else {
 363     myWorkshop->deactivateSubShapesSelection();
 364   }
 365 }
 366
 367 void PartSet_WidgetSketchLabel::erasePreviewPlanes()
 368 {
 369   if (myPreviewDisplayed) {
 370     XGUI_Displayer* aDisp = workshop()->displayer();
 371     aDisp->eraseAIS(myYZPlane, false);
 372     aDisp->eraseAIS(myXZPlane, false);
 373     aDisp->eraseAIS(myXYPlane, false);
 374     myPreviewDisplayed = false;
 375   }
 376 }
 377
 378 void PartSet_WidgetSketchLabel::showPreviewPlanes()
 379 {
 380   if (myPreviewDisplayed)
 381     return;
 382
 383   if (!myYZPlane) { // If planes are not created
 384     // Create Preview
 385     std::shared_ptr<GeomAPI_Pnt> anOrigin(new GeomAPI_Pnt(0, 0, 0));
 386     std::shared_ptr<GeomAPI_Dir> aYZDir(new GeomAPI_Dir(1, 0, 0));
 387     // -1, not 1 for correct internal sketch coords (issue 898)
 388     std::shared_ptr<GeomAPI_Dir> aXZDir(new GeomAPI_Dir(0, -1, 0));
 389     std::shared_ptr<GeomAPI_Dir> aXYDir(new GeomAPI_Dir(0, 0, 1));
 390
 391     std::vector<int> aYZRGB, aXZRGB, aXYRGB;
 392     aYZRGB = Config_PropManager::color("Visualization", "yz_plane_color",
 393                                                         YZ_PLANE_COLOR);
 394     aXZRGB = Config_PropManager::color("Visualization", "xz_plane_color",
 395                                                         XZ_PLANE_COLOR);
 396     aXYRGB = Config_PropManager::color("Visualization", "xy_plane_color",
 397                                                         XY_PLANE_COLOR);
 398     int aR[] = {aYZRGB[0], aYZRGB[1], aYZRGB[2]};
 399     int aG[] = {aXZRGB[0], aXZRGB[1], aXZRGB[2]};
 400     int aB[] = {aXYRGB[0], aXYRGB[1], aXYRGB[2]};
 401
 402     myYZPlane = createPreviewPlane(anOrigin, aYZDir, aR);
 403     myXZPlane = createPreviewPlane(anOrigin, aXZDir, aG);
 404     myXYPlane = createPreviewPlane(anOrigin, aXYDir, aB);
 405   }
 406   XGUI_Displayer* aDisp = workshop()->displayer();
 407   aDisp->displayAIS(myYZPlane, true, false);
 408   aDisp->displayAIS(myXZPlane, true, false);
 409   aDisp->displayAIS(myXYPlane, true, false);
 410   myPreviewDisplayed = true;
 411 }
 412
 413
 414 AISObjectPtr PartSet_WidgetSketchLabel::createPreviewPlane(std::shared_ptr<GeomAPI_Pnt> theOrigin,
 415                                                            std::shared_ptr<GeomAPI_Dir> theNorm,
 416                                                            const int theRGB[3])
 417 {
 418   double aSize = Config_PropManager::integer("Sketch planes", "planes_size", PLANE_SIZE);
 419   std::shared_ptr<GeomAPI_Shape> aFace = GeomAlgoAPI_FaceBuilder::square(theOrigin, theNorm, aSize);
 420   AISObjectPtr aAIS = AISObjectPtr(new GeomAPI_AISObject());
 421   aAIS->createShape(aFace);
 422   aAIS->setWidth(Config_PropManager::integer("Sketch planes", "planes_thickness", SKETCH_WIDTH));
 423   aAIS->setColor(theRGB[0], theRGB[1], theRGB[2]);
 424   return aAIS;
 425 }
 426
 427
 428 std::shared_ptr<GeomAPI_Dir> PartSet_WidgetSketchLabel::setSketchPlane(const TopoDS_Shape& theShape)
 429 {
 430   if (theShape.IsNull())
 431     return std::shared_ptr<GeomAPI_Dir>();
 432
 433   // get selected shape
 434   std::shared_ptr<GeomAPI_Shape> aGShape(new GeomAPI_Shape);
 435   aGShape->setImpl(new TopoDS_Shape(theShape));
 436
 437
 438
 439   // get plane parameters
 440   std::shared_ptr<GeomAPI_Pln> aPlane = GeomAlgoAPI_FaceBuilder::plane(aGShape);
 441   if (!aPlane.get())
 442     return std::shared_ptr<GeomAPI_Dir>();
 443
 444   // set plane parameters to feature
 445   std::shared_ptr<ModelAPI_Data> aData = feature()->data();
 446   double anA, aB, aC, aD;
 447   aPlane->coefficients(anA, aB, aC, aD);
 448
 449   // calculate attributes of the sketch
 450   std::shared_ptr<GeomAPI_Dir> aNormDir(new GeomAPI_Dir(anA, aB, aC));
 451   std::shared_ptr<GeomAPI_XYZ> aCoords = aNormDir->xyz();
 452   std::shared_ptr<GeomAPI_XYZ> aZero(new GeomAPI_XYZ(0, 0, 0));
 453   aCoords = aCoords->multiplied(-aD * aCoords->distance(aZero));
 454   std::shared_ptr<GeomAPI_Pnt> anOrigPnt(new GeomAPI_Pnt(aCoords));
 455   // X axis is preferable to be dirX on the sketch
 456   const double tol = Precision::Confusion();
 457   bool isX = fabs(anA - 1.0) < tol && fabs(aB) < tol && fabs(aC) < tol;
 458   std::shared_ptr<GeomAPI_Dir> aTempDir(
 459       isX ? new GeomAPI_Dir(0, 1, 0) : new GeomAPI_Dir(1, 0, 0));
 460   std::shared_ptr<GeomAPI_Dir> aYDir(new GeomAPI_Dir(aNormDir->cross(aTempDir)));
 461   std::shared_ptr<GeomAPI_Dir> aXDir(new GeomAPI_Dir(aYDir->cross(aNormDir)));
 462
 463   std::shared_ptr<GeomDataAPI_Point> anOrigin = std::dynamic_pointer_cast<GeomDataAPI_Point>(
 464       aData->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
 465   anOrigin->setValue(anOrigPnt);
 466   std::shared_ptr<GeomDataAPI_Dir> aNormal = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
 467       aData->attribute(SketchPlugin_Sketch::NORM_ID()));
 468   aNormal->setValue(aNormDir);
 469   std::shared_ptr<GeomDataAPI_Dir> aDirX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
 470       aData->attribute(SketchPlugin_Sketch::DIRX_ID()));
 471   aDirX->setValue(aXDir);
 472   std::shared_ptr<GeomAPI_Dir> aDir = aPlane->direction();
 473   return aDir;
 474 }
 475
 476 void PartSet_WidgetSketchLabel::showConstraints(bool theOn)
 477 {
 478   myShowConstraints->setChecked(theOn);
 479   emit showConstraintToggled(theOn);
 480 }
 481
 482 XGUI_Workshop* PartSet_WidgetSketchLabel::workshop() const
 483 {
 484   XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(myWorkshop);
 485   return aConnector->workshop();
 486 }
 487
 488
 489 void PartSet_WidgetSketchLabel::onSetPlaneView()
 490 {
 491   std::shared_ptr<GeomAPI_Pln> aPlane = plane();
 492   if (aPlane.get()) {
 493     std::shared_ptr<GeomAPI_Dir> aDirection = aPlane->direction();
 494     gp_Dir aDir = aDirection->impl<gp_Dir>();
 495     if (myViewInverted->isChecked())
 496       aDir.Reverse();
 497     myWorkshop->viewer()->setViewProjection(aDir.X(), aDir.Y(), aDir.Z(), 0.);
 498     PartSet_Module* aModule = dynamic_cast<PartSet_Module*>(myWorkshop->module());
 499     if (aModule)
 500       aModule->onViewTransformed();
 501   }
 502 }