ModuleBase_IModule.h

// Copyright (C) 2014-2023  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 ModuleBase_IModule_H
#define ModuleBase_IModule_H
 
#include "ModuleBase.h"
#include "ModuleBase_IWorkshop.h"
#include <ModuleBase_SelectionFilterType.h>
 
#include <ModelAPI_Feature.h>
#include <ModelAPI_Attribute.h>
 
#include <GeomAPI_Shape.h>
#include <GeomAPI_ICustomPrs.h>
 
#include <SelectMgr_ListOfFilter.hxx>
 
#include <QString>
#include <QObject>
#include <QMap>
#include <QList>
 
#include <string>
#include <vector>
#include <map>
 
#ifdef _MSC_VER
#pragma warning(disable: 4100)
#endif
 
class QAction;
class QMouseEvent;
class QKeyEvent;
class QMenu;
class Config_WidgetAPI;
 
class ModuleBase_ModelWidget;
class ModuleBase_Operation;
class ModuleBase_ViewerPrs;
class ModuleBase_ITreeNode;
class ModuleBase_IWorkshop;
 
class ModelAPI_Result;
class Events_Message;
 
class AIS_InteractiveObject;
 
class MODULEBASE_EXPORT ModuleBase_IModule : public QObject
{
  Q_OBJECT
 public:
  enum ModuleBase_CustomizeFlag {
    CustomizeArguments = 0, 
    CustomizeResults, 
    CustomizeHighlightedObjects 
  };
 
   ModuleBase_IModule(ModuleBase_IWorkshop* theParent);
 
   virtual ~ModuleBase_IModule();
 
  virtual void storeSelection() {}
 
  virtual void restoreSelection() {}
 
  virtual void createFeatures();
 
  virtual void actionCreated(QAction*);
 
  virtual void editFeature(FeaturePtr theFeature);
 
  virtual bool canCommitOperation() const { return true; }
 
  virtual void launchOperation(const QString& theCmdId,
                               const bool& isStartAfterCommitOnly);
 
  virtual void launchModal(const QString& theCmdId);
 
  virtual void operationStarted(ModuleBase_Operation* theOperation) {}
 
  virtual void operationResumed(ModuleBase_Operation* theOperation);
 
  virtual void operationStopped(ModuleBase_Operation* theOperation) {}
 
  virtual void operationCommitted(ModuleBase_Operation* theOperation) {}
 
  virtual void operationAborted(ModuleBase_Operation* theOperation) {}
 
  virtual ModuleBase_Operation* currentOperation() const = 0;
 
  virtual bool addViewerMenu(const QMap<QString, QAction*>& theStdActions,
                             QWidget* theParent,
                             QMap<int, QAction*>& theMenuActions) const
  { return false; }
 
  virtual void addObjectBrowserMenu(QMenu* theMenu) const {};
 
  virtual ModuleBase_ModelWidget* createWidgetByType(const std::string& theType,
                                                     QWidget* theParent,
                                                     Config_WidgetAPI* theWidgetApi)
  {
    return 0;
  }
 
  virtual ModuleBase_ModelWidget* activeWidget() const = 0;
 
  ModuleBase_IWorkshop* workshop() const { return myWorkshop; }
 
  virtual void propertyPanelDefined(ModuleBase_Operation* theOperation) {}
 
  virtual bool createWidgets(const FeaturePtr& theFeature, const QString& theXmlRepr,
                             QList<ModuleBase_ModelWidget*>& theWidgets) const { return false; }
 
  virtual bool canUndo() const;
 
  virtual bool canRedo() const;
 
  virtual bool canApplyAction(const ObjectPtr& theObject, const QString& theActionId) const = 0;
 
  //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 bool deleteObjects() { return false; };
 
  virtual void closeDocument() = 0;
 
  virtual void clearViewer() = 0;
 
  virtual void activeSelectionModes(QIntList& theModes) {}
 
  virtual void moduleSelectionModes(int theModesType, QIntList& theModes) = 0;
 
  virtual void moduleSelectionFilters(const QIntList& theFilterTypes,
                                      SelectMgr_ListOfFilter& theSelectionFilters) = 0;
 
  virtual QIntList selectionFilters();
 
  virtual Handle(SelectMgr_Filter) selectionFilter(const int theType);
 
  void registerSelectionFilter(const ModuleBase_SelectionFilterType theFilterType,
    const Handle(SelectMgr_Filter)& theFilter);
 
  virtual bool isCustomPrsActivated(const ModuleBase_CustomizeFlag& theFlag) const
  { return false; };
 
  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,
  //                                   GeomCustomPrsPtr theCustomPrs) { return false; };
 
  //virtual bool afterCustomisePresentation(std::shared_ptr<ModelAPI_Result> theResult,
  //                                   AISObjectPtr thePrs,
  //                                   GeomCustomPrsPtr theCustomPrs) { return false; };
 
  virtual bool customizeFeature(ObjectPtr theObject, const ModuleBase_CustomizeFlag& theFlag,
    const bool theUpdateViewer) {
    return false;
  }
 
  virtual void disableCustomMode(ModuleBase_CustomizeFlag theMode) {}
 
  virtual void enableCustomModes() {}
 
  virtual void customizeObjectBrowser(QWidget* theObjectBrowser) {}
 
  virtual ModuleBase_Operation* createOperation(const std::string& theCmdId);
 
  virtual AISObjectPtr createPresentation(const ObjectPtr& theResult);
 
  virtual void customizePresentation(const ObjectPtr& theObject, const AISObjectPtr& thePrs) const
  {}
 
  virtual ObjectPtr findPresentedObject(const AISObjectPtr& theAIS) const = 0;
 
  virtual bool canBeShaded(Handle(AIS_InteractiveObject) theAIS) const;
 
  virtual void updateObjectBrowserMenu(const QMap<QString, QAction*>& theStdActions) {}
 
  virtual void updateViewerMenu(const QMap<QString, QAction*>& theStdActions) {}
 
  virtual bool isActionEnableStateFixed(const int theActionId) const { return false; }
 
  virtual QString getFeatureError(const FeaturePtr& theFeature);
 
  virtual void grantedOperationIds(ModuleBase_Operation* theOperation, QStringList& theIds) const;
 
  virtual void connectToPropertyPanel(ModuleBase_ModelWidget* theWidget, const bool isToConnect) {};
 
  virtual void widgetStateChanged(int thePreviousState) {};
 
  virtual bool processEnter(const std::string& thePreviousAttributeID) { return false; };
 
  virtual void beforeOperationStopped(ModuleBase_Operation* theOperation) {};
 
  virtual GeomShapePtr findShape(const AttributePtr& theAttribute) = 0;
 
  virtual AttributePtr findAttribute(const ObjectPtr& theObject,
                                     const GeomShapePtr& theGeomShape) = 0;
 
  virtual std::shared_ptr<Events_Message> reentrantMessage() = 0;
 
  virtual void setReentrantPreSelection(const std::shared_ptr<Events_Message>& theMessage) = 0;
 
  void getXMLRepresentation(const std::string& theFeatureId, std::string& theXmlCfg,
                            std::string& theDescription);
 
  virtual ModuleBase_ITreeNode* rootNode() const = 0;
 
signals:
  void resumed(ModuleBase_Operation* theOp);
 
public slots:
  virtual void onFeatureTriggered();
 
  virtual void onObjectDisplayed(ObjectPtr theObject, AISObjectPtr theAIS) {}
 
  virtual void onBeforeObjectErase(ObjectPtr theObject, AISObjectPtr theAIS) {}
 
  virtual void onViewTransformed(int theTrsfType = 2) {}
 
protected slots:
  virtual void onSelectionChanged() {}
 
protected:
  virtual void registerValidators() {}
 
  virtual void registerProperties() {}
 
  virtual ModuleBase_Operation* getNewOperation(const std::string& theFeatureId);
 
  void loadProprietaryPlugins();
 
  void processProprietaryFeatures();
 
protected:
  ModuleBase_IWorkshop* myWorkshop;
 
  std::map<std::string, std::string> myFeaturesInFiles;
  std::map<std::string, std::string> myProprietaryFeatures;
  std::set<std::string> myProprietaryPlugins;
  std::set<std::string> myFeaturesValidLicense;
 
  std::map<ModuleBase_SelectionFilterType, Handle(SelectMgr_Filter)> mySelectionFilters;
 
};
 
 
 
extern "C" {
typedef ModuleBase_IModule* (*CREATE_FUNC)(ModuleBase_IWorkshop*);
}
 
#define CREATE_MODULE "createModule"
 
#endif //ModuleBase_IModule