XGUI_Displayer.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 XGUI_Displayer_H
#define XGUI_Displayer_H
 
#include "XGUI.h"
 
#include <GeomAPI_AISObject.h>
#include <GeomAPI_Pln.h>
 
#include <ModelAPI_Result.h>
 
#include <ModuleBase_Definitions.h>
 
#include <AIS_InteractiveObject.hxx>
#include <AIS_InteractiveContext.hxx>
#include <NCollection_Map.hxx>
#include <NCollection_DataMap.hxx>
#include <SelectMgr_AndFilter.hxx>
#include <TopoDS_Shape.hxx>
 
#include <QColor>
#include <QMap>
#include <QObject>
#include <QString>
 
class ModuleBase_ViewerPrs;
class ModelAPI_Feature;
class XGUI_SelectionActivate;
class XGUI_Workshop;
 
#define OPTIMIZE_PRS
 
#ifdef TINSPECTOR
class VInspectorAPI_CallBack;
#endif
 
 
#ifdef OPTIMIZE_PRS
class XGUI_TwoSidePresentationMap
{
public:
  ~XGUI_TwoSidePresentationMap() { clear(); }
 
  bool add(const ObjectPtr& theObj, const AISObjectPtr& theAIS)
  {
    if (myResultToAISMap.contains(theObj))
      return false;
    Handle(AIS_InteractiveObject) anAIS = theAIS->impl<Handle(AIS_InteractiveObject)>();
    myResultToAISMap[theObj] = anAIS;
    myAIStoResultMap[anAIS] = theObj;
    return true;
  }
 
  bool remove(const ObjectPtr& theObj)
  {
    if (!myResultToAISMap.contains(theObj))
      return false;
    Handle(AIS_InteractiveObject) aAIS = myResultToAISMap[theObj];
    myResultToAISMap.remove(theObj);
    myAIStoResultMap.remove(aAIS);
    return true;
  }
 
  bool remove(const AISObjectPtr& theAIS)
  {
    Handle(AIS_InteractiveObject) anAIS = theAIS->impl<Handle(AIS_InteractiveObject)>();
    if (!myAIStoResultMap.contains(anAIS))
      return false;
    ObjectPtr aObj = myAIStoResultMap[anAIS];
    myResultToAISMap.remove(aObj);
    myAIStoResultMap.remove(anAIS);
    return true;
  }
 
  void clear()
  {
    myResultToAISMap.clear();
    myAIStoResultMap.clear();
  }
 
  AISObjectPtr value(const ObjectPtr& theObj) const
  {
    if (myResultToAISMap.contains(theObj)) {
      Handle(AIS_InteractiveObject) anAIS = myResultToAISMap[theObj];
      AISObjectPtr anAISObj = AISObjectPtr(new GeomAPI_AISObject());
      anAISObj->setImpl(new Handle(AIS_InteractiveObject)(anAIS));
      return anAISObj;
    }
    return AISObjectPtr();
  }
 
  ObjectPtr value(const AISObjectPtr& theAIS) const
  {
    Handle(AIS_InteractiveObject) anAIS = theAIS->impl<Handle(AIS_InteractiveObject)>();
    if (myAIStoResultMap.contains(anAIS))
      return myAIStoResultMap[anAIS];
    return ObjectPtr();
  }
 
  ObjectPtr value(const Handle(AIS_InteractiveObject)& theAIS) const
  {
    if (myAIStoResultMap.contains(theAIS))
      return myAIStoResultMap[theAIS];
    return ObjectPtr();
  }
 
  int size() const { return myResultToAISMap.size(); }
 
  QObjectPtrList objects() const { return myResultToAISMap.keys(); }
 
  QList<Handle(AIS_InteractiveObject)> presentations() const { return myAIStoResultMap.keys(); }
 
  bool contains(const ObjectPtr& theObj) const { return myResultToAISMap.contains(theObj); }
 
  bool contains(const AISObjectPtr& theAIS) const
  {
    Handle(AIS_InteractiveObject) anAIS = theAIS->impl<Handle(AIS_InteractiveObject)>();
    return myAIStoResultMap.contains(anAIS);
  }
 
private:
  QMap<ObjectPtr, Handle(AIS_InteractiveObject)> myResultToAISMap;
  QMap<Handle(AIS_InteractiveObject), ObjectPtr> myAIStoResultMap;
};
#endif
 
 
class XGUI_EXPORT XGUI_Displayer : public QObject
{
  Q_OBJECT
public:
  enum DisplayMode {
    NoMode = -1, 
    Wireframe, 
    Shading 
  };
 
  XGUI_Displayer(XGUI_Workshop* theWorkshop);
 
  virtual ~XGUI_Displayer();
 
  bool isVisible(ObjectPtr theObject) const;
 
  bool display(ObjectPtr theObject, bool theUpdateViewer = true);
 
  bool displayAIS(AISObjectPtr theAIS, const bool toActivateInSelectionModes,
    const Standard_Integer theDisplayMode = 0, bool theUpdateViewer = true);
 
  bool displayAIS(Handle(AIS_InteractiveObject) theAISIO, const bool toActivateInSelectionModes,
    const Standard_Integer theDisplayMode = 0, bool theUpdateViewer = true);
 
  bool redisplay(ObjectPtr theObject, bool theUpdateViewer = true);
 
  void redisplayObjects();
 
  void setSelected(const  QList<std::shared_ptr<ModuleBase_ViewerPrs>>& theValues,
    bool theUpdateViewer = true);
 
  void clearSelected(const bool theUpdateViewer = true);
 
  bool erase(ObjectPtr theObject, const bool theUpdateViewer = true);
 
  bool eraseAIS(AISObjectPtr theAIS, const bool theUpdateViewer = true);
 
  bool eraseAIS(Handle(AIS_InteractiveObject) theAISIO, const bool theUpdateViewer = true);
 
  bool eraseAll(const bool theUpdateViewer = true);
 
  void deactivateSelectionFilters(const bool theAddFilterOnly = true);
 
  void addSelectionFilter(const Handle(SelectMgr_Filter)& theFilter);
 
  void removeSelectionFilter(const Handle(SelectMgr_Filter)& theFilter);
 
  virtual bool hasSelectionFilter(const Handle(SelectMgr_Filter)& theFilter);
 
  void removeFilters();
 
  bool enableUpdateViewer(const bool isEnabled);
 
  bool isUpdateEnabled() const
  {
    return myViewerBlockedRecursiveCount == 0;
  }
 
  void updateViewer() const;
 
  AISObjectPtr getAISObject(ObjectPtr theObject) const;
 
  ObjectPtr getObject(const AISObjectPtr& theIO) const;
 
  ObjectPtr getObject(const Handle(AIS_InteractiveObject)& theIO) const;
 
  void deactivateObjects(const QObjectPtrList& theObjList,
    const bool theUpdateViewer = true);
 
  void setDisplayMode(ObjectPtr theObject, DisplayMode theMode, bool theUpdateViewer = true);
 
  DisplayMode displayMode(ObjectPtr theObject) const;
 
  void showOnly(const QObjectPtrList& theList);
 
  int objectsCount() const { return myResult2AISObjectMap.size(); }
 
  QObjectPtrList displayedObjects() const {
#ifdef OPTIMIZE_PRS
    return myResult2AISObjectMap.objects();
#else
    return myResult2AISObjectMap.keys();
#endif
  }
 
#ifdef OPTIMIZE_PRS
  QList<Handle(AIS_InteractiveObject)> displayedPresentations() const
  {
    return myResult2AISObjectMap.presentations();
  }
#else
  QList<AISObjectPtr> displayedPresentations() const
  {
    return myResult2AISObjectMap.values();
  }
#endif
 
  bool canBeShaded(ObjectPtr theObject) const;
 
  QColor setObjectColor(ObjectPtr theObject, const QColor& theColor, bool theUpdateViewer = true);
 
  void displayTrihedron(bool theToDisplay) const;
 
#ifdef TINSPECTOR
  void setCallBack(const Handle(VInspectorAPI_CallBack)& theCallBack)
    { myVCallBack = theCallBack; }
  Handle(VInspectorAPI_CallBack) getCallBack() const { return myVCallBack; }
#endif
 
  static bool isVisible(XGUI_Displayer* theDisplayer, const ObjectPtr& theObject);
 
 
  GeomPlanePtr getScreenPlane() const;
 
  double getViewScale() const;
 
  void setSelectionColor(const std::vector<int>& theColor);
 
  std::vector<int> selectionColor() const;
 
signals:
  void objectDisplayed(ObjectPtr theObject, AISObjectPtr theAIS);
 
  void beforeObjectErase(ObjectPtr theObject, AISObjectPtr theAIS);
 
 protected:
  Handle(AIS_InteractiveContext) AISContext() const;
 
  Handle(SelectMgr_AndFilter) GetFilter();
 
  bool display(ObjectPtr theObject, AISObjectPtr theAIS, bool isShading,
               bool theUpdateViewer = true);
 
private:
  bool customizeObject(ObjectPtr theObject);
 
  void appendResultObject(ObjectPtr theObject, AISObjectPtr theAIS);
 
#ifdef _DEBUG
  std::string getResult2AISObjectMapInfo() const;
#endif
 
  void getPresentations(const ObjectPtr& theObject,
                        NCollection_Map<Handle(AIS_InteractiveObject)>& thePresentations);
 
  static void AddOrRemoveSelectedShapes(Handle(AIS_InteractiveContext) theContext,
    const NCollection_DataMap<TopoDS_Shape,
      NCollection_Map<Handle(AIS_InteractiveObject)>>& theShapesToBeSelected);
 
private:
  XGUI_SelectionActivate* selectionActivate() const;
 
private:
  XGUI_Workshop* myWorkshop; 
#ifdef TINSPECTOR
  Handle(VInspectorAPI_CallBack) myVCallBack;
#endif
  Handle(SelectMgr_AndFilter) myAndFilter; 
 
#ifdef OPTIMIZE_PRS
  XGUI_TwoSidePresentationMap myResult2AISObjectMap; 
#else
  typedef QMap<ObjectPtr, AISObjectPtr> ResultToAISMap;
  ResultToAISMap myResult2AISObjectMap; 
#endif
 
  int myViewerBlockedRecursiveCount;
 
  mutable void* myContextId;
  mutable bool myNeedUpdate; 
};
 
#endif