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                         const QMap<PartSet_Tools::ConstraintVisibleState, 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   QMap<PartSet_Tools::ConstraintVisibleState, QString> aStates;
 106   aStates[PartSet_Tools::Geometrical] = tr("Show geometrical constraints");
 107   aStates[PartSet_Tools::Dimensional] = tr("Show dimensional constraints");
 108
 109   QMap<PartSet_Tools::ConstraintVisibleState, QString>::const_iterator anIt = aStates.begin(),
 110                                                         aLast = aStates.end();
 111   for (; anIt != aLast; anIt++) {
 112     QCheckBox* aShowConstraints = new QCheckBox(anIt.value(), this);
 113     connect(aShowConstraints, SIGNAL(toggled(bool)), this, SLOT(onShowConstraint(bool)));
 114     aLayout->addWidget(aShowConstraints);
 115
 116     PartSet_Tools::ConstraintVisibleState aState = anIt.key();
 117     myShowConstraints[aState] = aShowConstraints;
 118
 119     if (toShowConstraints.contains(aState))
 120       aShowConstraints->setChecked(toShowConstraints[aState]);
 121   }
 122
 123   myStackWidget->addWidget(aSecondWgt);
 124   //setLayout(aLayout);
 125 }
 126
 127 PartSet_WidgetSketchLabel::~PartSet_WidgetSketchLabel()
 128 {
 129 }
 130
 131 bool PartSet_WidgetSketchLabel::setSelection(QList<ModuleBase_ViewerPrs>& theValues,
 132                                              const bool theToValidate)
 133 {
 134   // do not use the given selection if the plane of the sketch has been already set.
 135   // If this check is absent, a selected plane in the viewer can be set in the sketch
 136   // even if the sketch is built on another plane.
 137   if (plane().get())
 138     return true;
 139
 140   ModuleBase_ViewerPrs aPrs = theValues.first();
 141   bool aDone = ModuleBase_WidgetValidated::setSelection(theValues, theToValidate);
 142   if (aDone)
 143     updateByPlaneSelected(aPrs);
 144
 145   return aDone;
 146 }
 147
 148 QList<QWidget*> PartSet_WidgetSketchLabel::getControls() const
 149 {
 150   QList<QWidget*> aResult;
 151   aResult << myStackWidget;
 152   return aResult;
 153 }
 154
 155 void PartSet_WidgetSketchLabel::onSelectionChanged()
 156 {
 157   QList<ModuleBase_ViewerPrs> aSelected = getFilteredSelected();
 158
 159   if (aSelected.empty())
 160     return;
 161   ModuleBase_ViewerPrs aPrs = aSelected.first();
 162
 163   bool aDone = ModuleBase_WidgetValidated::setSelection(aSelected, false);
 164   if (aDone) {
 165     updateByPlaneSelected(aPrs);
 166     updateObject(myFeature);
 167   }
 168 }
 169
 170 void PartSet_WidgetSketchLabel::onShowConstraint(bool theOn)
 171 {
 172   QCheckBox* aSenderCheckBox = qobject_cast<QCheckBox*>(sender());
 173
 174   QMap<PartSet_Tools::ConstraintVisibleState, QCheckBox*>::const_iterator
 175                           anIt = myShowConstraints.begin(), aLast = myShowConstraints.end();
 176
 177   PartSet_Tools::ConstraintVisibleState aState = PartSet_Tools::Geometrical;
 178   bool aFound = false;
 179   for (; anIt != aLast && !aFound; anIt++) {
 180     aFound = anIt.value() == aSenderCheckBox;
 181     if (aFound)
 182       aState = anIt.key();
 183   }
 184   if (aFound)
 185     emit showConstraintToggled(theOn, aState);
 186 }
 187
 188 void PartSet_WidgetSketchLabel::updateByPlaneSelected(const ModuleBase_ViewerPrs& thePrs)
 189 {
 190   // 1. hide main planes if they have been displayed
 191   erasePreviewPlanes();
 192   // 2. if the planes were displayed, change the view projection
 193   TopoDS_Shape aShape = thePrs.shape();
 194   std::shared_ptr<GeomAPI_Shape> aGShape;
 195   std::shared_ptr<GeomAPI_Shape> aBaseShape;
 196
 197   DataPtr aData = feature()->data();
 198   AttributeSelectionPtr aSelAttr = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>
 199                             (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID()));
 200
 201   // selection happens in OCC viewer
 202   if (!aShape.IsNull()) {
 203     aGShape =  std::shared_ptr<GeomAPI_Shape>(new GeomAPI_Shape());
 204     aGShape->setImpl(new TopoDS_Shape(aShape));
 205
 206     if (aSelAttr && aSelAttr->context()) {
 207       aBaseShape = aSelAttr->context()->shape();
 208     }
 209   }
 210   else { // selection happens in OCC viewer(on body) of in the OB browser
 211     if (aSelAttr) {
 212       aGShape = aSelAttr->value();
 213     }
 214   }
 215   if (aGShape.get() != NULL) {
 216     // get plane parameters
 217     std::shared_ptr<GeomAPI_Pln> aPlane = GeomAlgoAPI_FaceBuilder::plane(aGShape);
 218     std::shared_ptr<GeomAPI_Dir> aDir = aPlane->direction();
 219     gp_XYZ aXYZ = aDir->impl<gp_Dir>().XYZ();
 220     double aTwist = 0.0;
 221
 222     // orienting projection is not needed: it is done in GeomAlgoAPI_FaceBuilder::plane
 223     /*if (aGShape->impl<TopoDS_Shape>().Orientation() == TopAbs_REVERSED) {
 224       aXYZ.Reverse();
 225     }*/
 226
 227     // Rotate view if the sketcher plane is selected only from preview planes
 228     // Preview planes are created only if there is no any shape
 229     bool aRotate = Config_PropManager::boolean("Sketch planes", "rotate_to_plane", "false");
 230     if (aRotate) {
 231       myWorkshop->viewer()->setViewProjection(aXYZ.X(), aXYZ.Y(), aXYZ.Z(), aTwist);
 232       PartSet_Module* aModule = dynamic_cast<PartSet_Module*>(myWorkshop->module());
 233       if (aModule)
 234         aModule->onViewTransformed();
 235     }
 236   }
 237   // 3. Clear text in the label
 238   myStackWidget->setCurrentIndex(1);
 239   //myLabel->setText("");
 240   //myLabel->setToolTip("");
 241   disconnect(workshop()->selector(), SIGNAL(selectionChanged()),
 242               this, SLOT(onSelectionChanged()));
 243   // 4. deactivate face selection filter
 244   activateFilters(false);
 245
 246   // 5. Clear selection mode and define sketching mode
 247   //XGUI_Displayer* aDisp = workshop()->displayer();
 248   //aDisp->closeLocalContexts();
 249   emit planeSelected(plane());
 250   // after the plane is selected in the sketch, the sketch selection should be activated
 251   // it can not be performed in the sketch label widget because, we don't need to switch off
 252   // the selection by any label deactivation, but need to switch it off by stop the sketch
 253   activateSelection(true);
 254
 255   // 6. Update sketcher actions
 256   XGUI_ActionsMgr* anActMgr = workshop()->actionsMgr();
 257   myWorkshop->updateCommandStatus();
 258   myWorkshop->viewer()->update();
 259 }
 260
 261 std::shared_ptr<GeomAPI_Pln> PartSet_WidgetSketchLabel::plane() const
 262 {
 263   CompositeFeaturePtr aSketch = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(myFeature);
 264   return PartSet_Tools::sketchPlane(aSketch);
 265 }
 266
 267 bool PartSet_WidgetSketchLabel::focusTo()
 268 {
 269   ModuleBase_Tools::setFocus(myStackWidget, "PartSet_WidgetSketchLabel::focusTo()");
 270   return true;
 271 }
 272
 273 void PartSet_WidgetSketchLabel::enableFocusProcessing()
 274 {
 275   myStackWidget->installEventFilter(this);
 276 }
 277
 278 void PartSet_WidgetSketchLabel::storeAttributeValue()
 279 {
 280   ModuleBase_WidgetValidated::storeAttributeValue();
 281 }
 282
 283 void PartSet_WidgetSketchLabel::restoreAttributeValue(const bool theValid)
 284 {
 285   ModuleBase_WidgetValidated::restoreAttributeValue(theValid);
 286
 287   // it is not necessary to save the previous plane value because the plane is chosen once
 288   DataPtr aData = feature()->data();
 289   AttributeSelectionPtr aSelAttr = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>
 290     (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID()));
 291   if (aSelAttr) {
 292     ResultPtr anEmptyResult;
 293     GeomShapePtr anEmptyShape;
 294     aSelAttr->setValue(anEmptyResult, anEmptyShape);
 295   }
 296 }
 297
 298 bool PartSet_WidgetSketchLabel::setSelectionCustom(const ModuleBase_ViewerPrs& thePrs)
 299 {
 300   bool isOwnerSet = false;
 301
 302   const TopoDS_Shape& aShape = thePrs.shape();
 303   std::shared_ptr<GeomAPI_Dir> aDir;
 304
 305   if (thePrs.object() && (feature() != thePrs.object())) {
 306     DataPtr aData = feature()->data();
 307     AttributeSelectionPtr aSelAttr =
 308       std::dynamic_pointer_cast<ModelAPI_AttributeSelection>
 309       (aData->attribute(SketchPlugin_SketchEntity::EXTERNAL_ID()));
 310     if (aSelAttr) {
 311       ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(thePrs.object());
 312       if (aRes) {
 313         GeomShapePtr aShapePtr(new GeomAPI_Shape());
 314         if (aShape.IsNull()) {  // selection happens in the OCC viewer
 315           aShapePtr = ModelAPI_Tools::shape(aRes);
 316         }
 317         else { // selection happens in OB browser
 318           aShapePtr->setImpl(new TopoDS_Shape(aShape));
 319         }
 320         if (aShapePtr.get() != NULL) {
 321           aSelAttr->setValue(aRes, aShapePtr);
 322           isOwnerSet = true;
 323         }
 324       }
 325     }
 326   }
 327   else if (!aShape.IsNull()) {
 328     aDir = setSketchPlane(aShape);
 329     isOwnerSet = aDir.get();
 330   }
 331   return isOwnerSet;
 332 }
 333
 334 void PartSet_WidgetSketchLabel::activateCustom()
 335 {
 336   std::shared_ptr<GeomAPI_Pln> aPlane = plane();
 337   if (aPlane.get()) {
 338     myStackWidget->setCurrentIndex(1);
 339     activateSelection(true);
 340     return;
 341   }
 342
 343   myStackWidget->setCurrentIndex(0);
 344   bool aBodyIsVisualized = false;
 345   XGUI_Displayer* aDisp = workshop()->displayer();
 346   QObjectPtrList aDisplayed = aDisp->displayedObjects();
 347   foreach (ObjectPtr anObj, aDisplayed) {
 348     ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObj);
 349     if (aResult.get() != NULL) {
 350       aBodyIsVisualized = aResult->groupName() == ModelAPI_ResultBody::group();
 351       if (aBodyIsVisualized)
 352         break;
 353     }
 354   }
 355
 356   if (!aBodyIsVisualized) {
 357     // We have to select a plane before any operation
 358     showPreviewPlanes();
 359   }
 360   activateSelection(true);
 361
 362   //myLabel->setText(myText);
 363   //myLabel->setToolTip(myTooltip);
 364
 365   connect(workshop()->selector(), SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged()));
 366   activateFilters(true);
 367 }
 368
 369 void PartSet_WidgetSketchLabel::deactivate()
 370 {
 371   ModuleBase_ModelWidget::deactivate();
 372   bool aHidePreview = myPreviewDisplayed;
 373   erasePreviewPlanes();
 374   activateSelection(false);
 375
 376   activateFilters(false);
 377   if (aHidePreview)
 378     myWorkshop->viewer()->update();
 379 }
 380
 381 void PartSet_WidgetSketchLabel::activateSelection(bool toActivate)
 382 {
 383   if (toActivate) {
 384     QIntList aModes;
 385     std::shared_ptr<GeomAPI_Pln> aPlane = plane();
 386     if (aPlane.get()) {
 387       myWorkshop->module()->activeSelectionModes(aModes);
 388     }
 389     else {
 390       aModes << TopAbs_FACE;
 391     }
 392     myWorkshop->activateSubShapesSelection(aModes);
 393   } else {
 394     myWorkshop->deactivateSubShapesSelection();
 395   }
 396 }
 397
 398 void PartSet_WidgetSketchLabel::erasePreviewPlanes()
 399 {
 400   if (myPreviewDisplayed) {
 401     XGUI_Displayer* aDisp = workshop()->displayer();
 402     aDisp->eraseAIS(myYZPlane, false);
 403     aDisp->eraseAIS(myXZPlane, false);
 404     aDisp->eraseAIS(myXYPlane, false);
 405     myPreviewDisplayed = false;
 406   }
 407 }
 408
 409 void PartSet_WidgetSketchLabel::showPreviewPlanes()
 410 {
 411   if (myPreviewDisplayed)
 412     return;
 413
 414   if (!myYZPlane) { // If planes are not created
 415     // Create Preview
 416     std::shared_ptr<GeomAPI_Pnt> anOrigin(new GeomAPI_Pnt(0, 0, 0));
 417     std::shared_ptr<GeomAPI_Dir> aYZDir(new GeomAPI_Dir(1, 0, 0));
 418     // -1, not 1 for correct internal sketch coords (issue 898)
 419     std::shared_ptr<GeomAPI_Dir> aXZDir(new GeomAPI_Dir(0, -1, 0));
 420     std::shared_ptr<GeomAPI_Dir> aXYDir(new GeomAPI_Dir(0, 0, 1));
 421
 422     std::vector<int> aYZRGB, aXZRGB, aXYRGB;
 423     aYZRGB = Config_PropManager::color("Visualization", "yz_plane_color",
 424                                                         YZ_PLANE_COLOR);
 425     aXZRGB = Config_PropManager::color("Visualization", "xz_plane_color",
 426                                                         XZ_PLANE_COLOR);
 427     aXYRGB = Config_PropManager::color("Visualization", "xy_plane_color",
 428                                                         XY_PLANE_COLOR);
 429     int aR[] = {aYZRGB[0], aYZRGB[1], aYZRGB[2]};
 430     int aG[] = {aXZRGB[0], aXZRGB[1], aXZRGB[2]};
 431     int aB[] = {aXYRGB[0], aXYRGB[1], aXYRGB[2]};
 432
 433     myYZPlane = createPreviewPlane(anOrigin, aYZDir, aR);
 434     myXZPlane = createPreviewPlane(anOrigin, aXZDir, aG);
 435     myXYPlane = createPreviewPlane(anOrigin, aXYDir, aB);
 436   }
 437   XGUI_Displayer* aDisp = workshop()->displayer();
 438   aDisp->displayAIS(myYZPlane, true, false);
 439   aDisp->displayAIS(myXZPlane, true, false);
 440   aDisp->displayAIS(myXYPlane, true, false);
 441   myPreviewDisplayed = true;
 442 }
 443
 444
 445 AISObjectPtr PartSet_WidgetSketchLabel::createPreviewPlane(std::shared_ptr<GeomAPI_Pnt> theOrigin,
 446                                                            std::shared_ptr<GeomAPI_Dir> theNorm,
 447                                                            const int theRGB[3])
 448 {
 449   double aSize = Config_PropManager::integer("Sketch planes", "planes_size", PLANE_SIZE);
 450   std::shared_ptr<GeomAPI_Shape> aFace = GeomAlgoAPI_FaceBuilder::square(theOrigin, theNorm, aSize);
 451   AISObjectPtr aAIS = AISObjectPtr(new GeomAPI_AISObject());
 452   aAIS->createShape(aFace);
 453   aAIS->setWidth(Config_PropManager::integer("Sketch planes", "planes_thickness", SKETCH_WIDTH));
 454   aAIS->setColor(theRGB[0], theRGB[1], theRGB[2]);
 455   return aAIS;
 456 }
 457
 458
 459 std::shared_ptr<GeomAPI_Dir> PartSet_WidgetSketchLabel::setSketchPlane(const TopoDS_Shape& theShape)
 460 {
 461   if (theShape.IsNull())
 462     return std::shared_ptr<GeomAPI_Dir>();
 463
 464   // get selected shape
 465   std::shared_ptr<GeomAPI_Shape> aGShape(new GeomAPI_Shape);
 466   aGShape->setImpl(new TopoDS_Shape(theShape));
 467
 468
 469
 470   // get plane parameters
 471   std::shared_ptr<GeomAPI_Pln> aPlane = GeomAlgoAPI_FaceBuilder::plane(aGShape);
 472   if (!aPlane.get())
 473     return std::shared_ptr<GeomAPI_Dir>();
 474
 475   // set plane parameters to feature
 476   std::shared_ptr<ModelAPI_Data> aData = feature()->data();
 477   double anA, aB, aC, aD;
 478   aPlane->coefficients(anA, aB, aC, aD);
 479
 480   // calculate attributes of the sketch
 481   std::shared_ptr<GeomAPI_Dir> aNormDir(new GeomAPI_Dir(anA, aB, aC));
 482   std::shared_ptr<GeomAPI_XYZ> aCoords = aNormDir->xyz();
 483   std::shared_ptr<GeomAPI_XYZ> aZero(new GeomAPI_XYZ(0, 0, 0));
 484   aCoords = aCoords->multiplied(-aD * aCoords->distance(aZero));
 485   std::shared_ptr<GeomAPI_Pnt> anOrigPnt(new GeomAPI_Pnt(aCoords));
 486   // X axis is preferable to be dirX on the sketch
 487   const double tol = Precision::Confusion();
 488   bool isX = fabs(anA - 1.0) < tol && fabs(aB) < tol && fabs(aC) < tol;
 489   std::shared_ptr<GeomAPI_Dir> aTempDir(
 490       isX ? new GeomAPI_Dir(0, 1, 0) : new GeomAPI_Dir(1, 0, 0));
 491   std::shared_ptr<GeomAPI_Dir> aYDir(new GeomAPI_Dir(aNormDir->cross(aTempDir)));
 492   std::shared_ptr<GeomAPI_Dir> aXDir(new GeomAPI_Dir(aYDir->cross(aNormDir)));
 493
 494   std::shared_ptr<GeomDataAPI_Point> anOrigin = std::dynamic_pointer_cast<GeomDataAPI_Point>(
 495       aData->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
 496   anOrigin->setValue(anOrigPnt);
 497   std::shared_ptr<GeomDataAPI_Dir> aNormal = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
 498       aData->attribute(SketchPlugin_Sketch::NORM_ID()));
 499   aNormal->setValue(aNormDir);
 500   std::shared_ptr<GeomDataAPI_Dir> aDirX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
 501       aData->attribute(SketchPlugin_Sketch::DIRX_ID()));
 502   aDirX->setValue(aXDir);
 503   std::shared_ptr<GeomAPI_Dir> aDir = aPlane->direction();
 504   return aDir;
 505 }
 506
 507 XGUI_Workshop* PartSet_WidgetSketchLabel::workshop() const
 508 {
 509   XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(myWorkshop);
 510   return aConnector->workshop();
 511 }
 512
 513
 514 void PartSet_WidgetSketchLabel::onSetPlaneView()
 515 {
 516   std::shared_ptr<GeomAPI_Pln> aPlane = plane();
 517   if (aPlane.get()) {
 518     std::shared_ptr<GeomAPI_Dir> aDirection = aPlane->direction();
 519     gp_Dir aDir = aDirection->impl<gp_Dir>();
 520     if (myViewInverted->isChecked())
 521       aDir.Reverse();
 522     myWorkshop->viewer()->setViewProjection(aDir.X(), aDir.Y(), aDir.Z(), 0.);
 523     PartSet_Module* aModule = dynamic_cast<PartSet_Module*>(myWorkshop->module());
 524     if (aModule)
 525       aModule->onViewTransformed();
 526   }
 527 }