PartSet_Module.h

// Copyright (C) 2014-2026  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_Module_H
#define PartSet_Module_H
 
#include "PartSet.h"
#include "PartSet_Tools.h"
#include "PartSet_OverconstraintListener.h"
#include "PartSet_SketcherMgr.h"
 
#include <ModuleBase_IModule.h>
#include <ModuleBase_Definitions.h>
#include <ModelAPI_Feature.h>
#include <ModelAPI_Attribute.h>
#include <ModelAPI_CompositeFeature.h>
 
#include <Events_Listener.h>
 
//#include <StdSelect_FaceFilter.hxx>
#include <TopoDS_Shape.hxx>
#include <SelectMgr_ListOfFilter.hxx>
#include <SelectMgr_Filter.hxx>
 
#include <QMap>
#include <QMenu>
#include <QObject>
#include <QModelIndex>
 
#include <map>
#include <memory>
#include <string>
 
class ModuleBase_Operation;
class ModuleBase_IViewWindow;
class ModuleBase_ViewerPrs;
 
class XGUI_Workshop;
class PartSet_MenuMgr;
class PartSet_CustomPrs;
class PartSet_SketcherMgr;
class PartSet_SketcherReentrantMgr;
class PartSet_RootNode;
class ModelAPI_Result;
 
class QAction;
 
class PARTSET_EXPORT PartSet_Module : public ModuleBase_IModule, public Events_Listener
{
Q_OBJECT
 
enum RestartingMode {
  RM_None, 
  RM_Forbided, 
  RM_LastFeatureUsed, 
  RM_EmptyFeatureUsed 
};
 
public:
 
  PartSet_Module(ModuleBase_IWorkshop* theWshop);
  virtual ~PartSet_Module();
 
  // Stores the current selection
  virtual void storeSelection();
 
  // Restores the current selection
  virtual void restoreSelection();
 
  virtual ModuleBase_ModelWidget* createWidgetByType(const std::string& theType, QWidget* theParent,
                                                     Config_WidgetAPI* theWidgetApi);
 
  virtual ModuleBase_ModelWidget* activeWidget() const;
 
  virtual void propertyPanelDefined(ModuleBase_Operation* theOperation);
 
  virtual bool createWidgets(const FeaturePtr& theFeature, const QString& theXmlRepr,
                             QList<ModuleBase_ModelWidget*>& theWidgets) const;
 
  virtual void editFeature(FeaturePtr theFeature);
 
  virtual bool canCommitOperation() const;
 
  virtual void launchOperation(const QString& theCmdId,
                               const bool& isStartAfterCommitOnly);
 
  virtual void operationStarted(ModuleBase_Operation* theOperation);
 
  virtual void operationResumed(ModuleBase_Operation* theOperation);
 
  virtual void operationCommitted(ModuleBase_Operation* theOperation);
 
  virtual void operationAborted(ModuleBase_Operation* theOperation);
 
  virtual void operationStopped(ModuleBase_Operation* theOperation);
 
  virtual ModuleBase_Operation* currentOperation() const;
 
  virtual bool canUndo() const;
 
  virtual bool canRedo() const;
 
  virtual bool canApplyAction(const ObjectPtr& theObject, const QString& theActionId) const;
 
  //virtual bool canCommitOperation() const;
 
  virtual bool canEraseObject(const ObjectPtr& theObject) const;
 
  virtual bool canDisplayObject(const ObjectPtr& theObject) const;
 
  virtual bool canUsePreselection(const QString& thePreviousOperationKind,
                                  const QString& theStartedOperationKind);
 
  //virtual void processHiddenObject(const std::list<ObjectPtr>& theObjects);
 
  virtual bool canActivateSelection(const ObjectPtr& theObject) const;
 
  virtual void addObjectBrowserMenu(QMenu* theMenu) const;
 
  virtual bool addViewerMenu(const QMap<QString, QAction*>& theStdActions,
                             QWidget* theParent,
                             QMap<int, QAction*>& theMenuActions) const;
 
  virtual void activeSelectionModes(QIntList& theModes);
 
  virtual void moduleSelectionModes(int theModesType, QIntList& theModes);
 
  virtual void moduleSelectionFilters(const QIntList& theFilterTypes,
                                      SelectMgr_ListOfFilter& theSelectionFilters);
 
 
  bool isMouseOverWindow();
 
  PartSet_SketcherMgr* sketchMgr() const { return mySketchMgr; }
 
  PartSet_SketcherReentrantMgr* sketchReentranceMgr() const { return mySketchReentrantMgr; }
 
  virtual void getGeomSelection(const std::shared_ptr<ModuleBase_ViewerPrs>& theSelected,
                                ObjectPtr& theObject, AttributePtr& theAttribute);
 
  PartSet_OverconstraintListener* overconstraintListener() { return myOverconstraintListener; }
 
  bool isSketchNeutralPointActivated() const;
 
  virtual void closeDocument();
 
  virtual void clearViewer();
 
  virtual void processEvent(const std::shared_ptr<Events_Message>& theMessage);
 
  void setCustomized(const FeaturePtr& theFeature);
 
  virtual bool isCustomPrsActivated(const ModuleBase_CustomizeFlag& theFlag) const;
 
  virtual void activateCustomPrs(const FeaturePtr& theFeature,
                                 const ModuleBase_CustomizeFlag& theFlag,
                                 const bool theUpdateViewer);
 
  virtual void deactivateCustomPrs(const ModuleBase_CustomizeFlag& theFlag,
                                   const bool theUpdateViewer);
 
  //virtual bool customisePresentation(std::shared_ptr<ModelAPI_Result> theResult,
  //                                   AISObjectPtr thePrs,
  //                                   std::shared_ptr<GeomAPI_ICustomPrs> theCustomPrs);
 
  //virtual bool afterCustomisePresentation(std::shared_ptr<ModelAPI_Result> theResult,
  //                                        AISObjectPtr thePrs,
  //                                        GeomCustomPrsPtr theCustomPrs);
 
  virtual bool customizeFeature(ObjectPtr theObject, const ModuleBase_CustomizeFlag& theFlag,
                                const bool theUpdateViewer);
 
  virtual void disableCustomMode(ModuleBase_CustomizeFlag theMode);
 
  virtual void enableCustomModes();
 
  virtual void customizeObjectBrowser(QWidget* theObjectBrowser);
 
  int getVisualLayerId() const { return myVisualLayerId; }
 
  virtual AISObjectPtr createPresentation(const ObjectPtr& theResult);
 
  virtual void customizePresentation(const ObjectPtr& theObject, const AISObjectPtr& thePrs) const;
 
  virtual ObjectPtr findPresentedObject(const AISObjectPtr& theAIS) const;
 
  virtual bool canBeShaded(Handle(AIS_InteractiveObject) theAIS) const;
 
  virtual void updateViewerMenu(const QMap<QString, QAction*>& theStdActions);
 
  virtual bool isActionEnableStateFixed(const int theActionId) const;
 
  virtual QString getFeatureError(const FeaturePtr& theFeature);
 
  virtual void grantedOperationIds(ModuleBase_Operation* theOperation, QStringList& theIds) const;
 
  virtual void widgetStateChanged(int thePreviousState);
 
  virtual bool processEnter(const std::string& thePreviousAttributeID);
 
  virtual void beforeOperationStopped(ModuleBase_Operation* theOperation);
 
  virtual GeomShapePtr findShape(const AttributePtr& theAttribute);
 
  virtual AttributePtr findAttribute(const ObjectPtr& theObject, const GeomShapePtr& theGeomShape);
 
  virtual std::shared_ptr<Events_Message> reentrantMessage();
 
  virtual void setReentrantPreSelection(const std::shared_ptr<Events_Message>& theMessage);
 
  virtual ModuleBase_ITreeNode* rootNode() const;
 
  XGUI_Workshop* getWorkshop() const;
 
  virtual void createFeatures();
 
  static void setTexture(const AISObjectPtr& thePrs, const ResultPtr& theResult);
 
public slots:
  virtual void onObjectDisplayed(ObjectPtr theObject, AISObjectPtr theAIS);
 
  virtual void onBeforeObjectErase(ObjectPtr theObject, AISObjectPtr theAIS);
 
  virtual void onViewTransformed(int theTrsfType = 2);
 
  void onRemoveConflictingConstraints();
 
protected slots:
  virtual void onSelectionChanged();
 
  void onKeyRelease(ModuleBase_IViewWindow* theWnd, QKeyEvent* theEvent);
 
  void onViewCreated(ModuleBase_IViewWindow*);
 
  void onChoiceChanged(ModuleBase_ModelWidget* theWidget, int theIndex);
 
protected:
  virtual void customSubShapesSelectionModes(QIntList& theModes);
 
  void storeConstraintsState(const std::string& theFeatureKindId);
 
  void updateConstraintsState(const std::string& theFeatureKind);
 
  virtual void registerValidators();
 
  virtual void connectToPropertyPanel(ModuleBase_ModelWidget* theWidget, const bool isToConnect);
 
  void updateSketcherOnStart(ModuleBase_Operation* theOperation);
 
  void updatePresentationsOnStart(ModuleBase_Operation* theOperation);
 
 private slots:
   void onTreeViewDoubleClick(const QModelIndex&);
 
   void onActiveDocPopup(const QPoint&);
 
 private:
  virtual bool deleteObjects();
 
  void setDefaultConstraintShown();
 
private:
  bool myIsOperationIsLaunched; 
 
  PartSet_SketcherMgr* mySketchMgr;
  PartSet_SketcherReentrantMgr* mySketchReentrantMgr;
  PartSet_MenuMgr* myMenuMgr;
  PartSet_CustomPrs* myCustomPrs;
  PartSet_OverconstraintListener* myOverconstraintListener;
  int myVisualLayerId;
 
  QMap<PartSet_Tools::ConstraintVisibleState, bool> myHasConstraintShown;
 
  PartSet_SketcherMgr::FeatureToSelectionMap myCurrentSelection;
  QModelIndex myActivePartIndex;
 
  PartSet_RootNode* myRoot;
};
 
#endif