PartSet_WidgetSketchLabel.h

// Copyright (C) 2014-2025  CEA, EDF
//
// 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
//
 
#ifndef PartSet_WidgetSketchLabel_H
#define PartSet_WidgetSketchLabel_H
 
#include "PartSet.h"
#include "PartSet_Tools.h"
 
#include <ModuleBase_WidgetValidated.h>
#include <ModuleBase_ViewerFilters.h>
#include <ModuleBase_ViewerPrs.h>
 
#include <GeomAPI_Dir.h>
 
#include <TopoDS_Shape.hxx>
 
#include <QStackedWidget>
#include <QDoubleSpinBox>
#include <QMap>
 
class PartSet_PreviewPlanes;
class PartSet_PreviewSketchPlane;
 
class XGUI_OperationMgr;
class XGUI_Workshop;
class QCheckBox;
class QComboBox;
class QDialog;
class QSpinBox;
class QGroupBox;
class QLabel;
class QLineEdit;
class QPushButton;
class QStackedWidget;
class QGridLayout;
 
class PartSet_WidgetSketchLabel;
class ModelAPI_CompositeFeature;
 
 
class PartSet_WidgetSketchRectangularGrid;
class PartSet_WidgetSketchCircularGrid;
 
 
class PARTSET_EXPORT PartSet_WidgetSketchLabel : public ModuleBase_WidgetValidated
{
Q_OBJECT
 
public:
  PartSet_WidgetSketchLabel(QWidget* theParent, ModuleBase_IWorkshop* theWorkshop,
                      const Config_WidgetAPI* theData,
                      const QMap<PartSet_Tools::ConstraintVisibleState, bool>& toShowConstraints);
 
  virtual ~PartSet_WidgetSketchLabel() = default;
 
  virtual void setFeature(
    const FeaturePtr& theFeature,
    const bool theToStoreValue = false,
    const bool isUpdateFlushed = true
  );
 
  virtual bool isModified() const { return mySketchDataIsModified; }
 
  virtual bool setSelection(QList<std::shared_ptr<ModuleBase_ViewerPrs>>& theValues,
                            const bool theToValidate);
 
  virtual void selectionModes(int& theModuleSelectionModes, QIntList& theModes);
 
  virtual void selectionFilters(QIntList& theModuleSelectionFilters,
                                SelectMgr_ListOfFilter& theSelectionFilters);
 
  virtual QList<QWidget*> getControls() const;
 
  virtual void deactivate();
 
  virtual bool needToBeActivated() { return true; }
 
  std::shared_ptr<GeomAPI_Pln> plane() const;
 
  virtual bool focusTo();
  virtual void setHighlighted(bool) { /*do nothing*/ };
  virtual void enableFocusProcessing();
 
  void setShowPointsState(bool theState);
 
  static bool canFillSketch(const ModuleBase_ViewerPrsPtr& thePrs);
 
  virtual void showInformativePage() {
    if (myStackWidget) myStackWidget->setCurrentIndex(1);
  }
 
signals:
  void planeSelected(const std::shared_ptr<GeomAPI_Pln>& thePln);
 
  void showConstraintToggled(int theType, bool theState);
 
  void showFreePoints(bool toShow);
 
  void autoConstraints(bool isOn);
 
protected:
  virtual void storeAttributeValue(const AttributePtr& theAttribute);
 
  virtual void restoreAttributeValue(const AttributePtr& theAttribute,
                                     const bool theValid);
 
  virtual bool setSelectionCustom(const ModuleBase_ViewerPrsPtr& thePrs);
 
  virtual bool storeValueCustom();
 
  virtual bool restoreValueCustom();
 
  virtual void activateCustom();
 
  virtual void blockAttribute(const AttributePtr& theAttribute, const bool& theToBlock,
                              bool& isFlushesActived,
                              bool& isAttributeSetInitializedBlocked,
                              bool& isAttributeSendUpdatedBlocked);
 
  virtual bool processSelection();
 
  bool setSelectionInternal(const QList<ModuleBase_ViewerPrsPtr>& theValues,
                            const bool theToValidate);
 
  void updateByPlaneSelected(const ModuleBase_ViewerPrsPtr& thePrs);
 
  bool fillSketchPlaneBySelection(const ModuleBase_ViewerPrsPtr& thePrs);
 
  virtual void showEvent(QShowEvent* theEvent);
 
  virtual void hideEvent(QHideEvent* theEvent);
 
  virtual bool eventFilter(QObject* theObj, QEvent* theEvent);
 
private slots:
  void onSetPlaneView();
 
  void onShowConstraint(bool theOn);
 
  void onChangePlane();
 
  void onShowDOF();
 
  void onShowPanel();
 
  void onShowAxes(bool);
  void onShowSubstrate(bool);
 
  void onGridTypeChanged(int);
  void onGridSnappingModeChanged(int);
 
  void reconfigureSketchViewWidgets();
 
  void saveSketchViewPreferenceToSkethData();
 
private:
  std::shared_ptr<GeomAPI_Dir> setSketchPlane(const TopoDS_Shape& theShape);
 
  std::shared_ptr<GeomAPI_Dir> setSketchPlane(std::shared_ptr<GeomAPI_Pln> thePlane);
 
  QList<ModuleBase_ViewerPrsPtr> findCircularEdgesInPlane();
 
private:
  PartSet_PreviewPlanes* myPreviewPlanes;
 
  bool mySketchDataIsModified;
  QGroupBox* mySketchViewGroupBox;
 
  QCheckBox* myViewInverted;
  QCheckBox* myAxesVisibleCheckBox; // Local sketch axes.
  QCheckBox* mySubstrateVisibleCheckBox;
 
  QComboBox* myGridTypeComboBox;
  QComboBox* myGridSnappingModeComboBox;
 
  friend class PartSet_WidgetSketchGrid;
  friend class PartSet_WidgetSketchRectangularGrid;
  friend class PartSet_WidgetSketchCircularGrid;
  PartSet_WidgetSketchRectangularGrid* myWidgetRectangularGrid;
  PartSet_WidgetSketchCircularGrid*    myWidgetCircularGrid;
 
  QCheckBox* myRemoveExternal;
  QCheckBox* myShowPoints;
  QCheckBox* myAutoConstraints;
 
  QMap<PartSet_Tools::ConstraintVisibleState, QCheckBox*> myShowConstraints;
 
  QWidget* mySizeOfViewWidget; 
  QLineEdit* mySizeOfView; 
  QStackedWidget* myStackWidget;
 
  QLabel* myDoFLabel;
  QPushButton* myShowDOFBtn;
 
  bool myOpenTransaction;
  bool myIsSelection;
 
  QDialog* myPartSetMessage;
  QDialog* mySizeMessage;
 
  GeomPlanePtr myTmpPlane;
};
 
 
class PARTSET_EXPORT PitchSpinBox : public QDoubleSpinBox
{
    Q_OBJECT
public:
  PitchSpinBox(QWidget* theParent);
  ~PitchSpinBox() = default;
 
  void setValue(double theVal);
 
signals:
  void valueSet(double theVal);
 
private slots:
  virtual void onTextChanged();
  virtual void onEditingFinished();
 
private:
  double myPrevVal;
};
 
 
class PARTSET_EXPORT PartSet_WidgetSketchGrid : public QWidget
{
  Q_OBJECT
public:
  PartSet_WidgetSketchGrid(QWidget* theParent, PartSet_WidgetSketchLabel* theSketchLabel);
  virtual ~PartSet_WidgetSketchGrid() = default;
 
  virtual void reconfigure() = 0;
 
protected slots:
  virtual void onResetClicked() = 0;
  virtual void onOffsetAngleChanged(double theOffset) = 0;
  virtual void onOffsetXChanged(double theOffset) = 0;
  virtual void onOffsetYChanged(double theOffset) = 0;
 
protected:
  static double clampValue(double theValue, double theIntervalWidth);
 
  static double reasonableOffsetIncrement(double theStep);
 
  static double reasonablePitchIncrement(double theStep);
 
  void retrieveSketchAndPlane();
 
protected:
  static const int NUM_OF_DECIMAL_DIGITS_TRANS;
 
  static const int NUM_OF_DECIMAL_DIGITS_ROTAT;
 
  static const int SPIN_BOX_MIN_WIDTH;
 
protected:
  PartSet_WidgetSketchLabel* const mySketchLabel;
  PartSet_PreviewSketchPlane* myPreviewPlane;
 
  QGridLayout*    myLayout;
 
  QPushButton*    myResetButton;
 
  QDoubleSpinBox* myOffsetXSpinBox;
  QDoubleSpinBox* myOffsetYSpinBox;
  QDoubleSpinBox* myOffsetAngleSpinBox;
 
  friend class PitchSpinBox;
};
 
 
class PARTSET_EXPORT PartSet_WidgetSketchRectangularGrid : public PartSet_WidgetSketchGrid
{
  Q_OBJECT
public:
  PartSet_WidgetSketchRectangularGrid(QWidget* theParent, PartSet_WidgetSketchLabel* theSketchLabel);
  virtual ~PartSet_WidgetSketchRectangularGrid() = default;
 
  virtual void reconfigure();
 
private slots:
  void onStepXSet(double theStep);
  void onStepYSet(double theStep);
 
protected slots:
  virtual void onResetClicked();
  virtual void onOffsetAngleChanged(double theOffset);
  virtual void onOffsetXChanged(double theOffset);
  virtual void onOffsetYChanged(double theOffset);
 
private:
  PitchSpinBox* myStepXSpinBox;
  PitchSpinBox* myStepYSpinBox;
};
 
 
class PARTSET_EXPORT PartSet_WidgetSketchCircularGrid : public PartSet_WidgetSketchGrid
{
  Q_OBJECT
public:
  PartSet_WidgetSketchCircularGrid(QWidget* theParent, PartSet_WidgetSketchLabel* theSketchLabel);
  virtual ~PartSet_WidgetSketchCircularGrid() = default;
 
  virtual void reconfigure();
 
private slots:
  void onStepRChanged(double theStep);
  void onNumOfAngularSegmentsChanged(int theNum);
 
protected slots:
  virtual void onResetClicked();
  virtual void onOffsetAngleChanged(double theOffset);
  virtual void onOffsetXChanged(double theOffset);
  virtual void onOffsetYChanged(double theOffset);
 
private:
  void updateSegmentsToolTip();
 
  PitchSpinBox* myStepRSpinBox;
  QSpinBox*       myNASSpinBox;
};
 
#endif