GEOM module context menu (popup) optimization.

src/GEOMGUI/GEOMGUI_Selection.cxx

@@ -33,8 +33,8 @@
 
 #include "LightApp_DataOwner.h"
 
-#include <SUIT_Desktop.h>
 #include <SUIT_Session.h>
+#include <SUIT_Desktop.h>
 #include <SUIT_ViewWindow.h>
 #include <SUIT_ViewManager.h>
 
@@ -61,6 +61,24 @@
 // VTK Includes
 #include <vtkActorCollection.h>
 
+#define OCC_DISPLAY_MODE_TO_STRING( str, dm ) { \
+    if ( dm == AIS_WireFrame ) \
+      str = QString( "Wireframe" ); \
+    else if ( dm == AIS_Shaded )    \
+      str = QString( "Shading" ); \
+    else \
+      str = QString(); }
+
+#define VTK_DISPLAY_MODE_TO_STRING( str, dm ) { \
+    if ( dm == 0 ) \
+      str = QString( "Wireframe" ); \
+    else if ( dm == 1 )    \
+      str = QString( "Shading" ); \
+    else \
+      str = QString(); }
+
+#define USE_VISUAL_PROP_MAP
+
 GEOMGUI_Selection::GEOMGUI_Selection()
 : LightApp_Selection()
 {
@@ -70,43 +88,75 @@ GEOMGUI_Selection::~GEOMGUI_Selection()
 {
 }
 
-QVariant GEOMGUI_Selection::parameter( const QString& p ) const
+void GEOMGUI_Selection::init( const QString& context, LightApp_SelectionMgr* selMgr )
 {
-  if ( p == "isOCC" ) return QVariant( activeViewType() == OCCViewer_Viewer::Type() );
+  LightApp_Selection::init( context, selMgr );
-  if ( p == "selectionmode" ){ 
+
-    return QVariant(selectionMode()); 
+  myObjects.resize( count() );
+
+  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
+  if ( appStudy ) {
+    _PTR(Study) study = appStudy->studyDS();
+    for ( int idx = 0; idx < count(); idx++ ) {
+      QString anEntry = entry( idx );
+      if ( study && !anEntry.isEmpty() ) {
+	_PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
+	if ( aSO ) {
+	  CORBA::Object_var varObj = GeometryGUI::ClientSObjectToObject( aSO );
+	  myObjects[idx] = GEOM::GEOM_Object::_narrow( varObj );
+	}
+      }
+    }
   }
-  return LightApp_Selection::parameter( p );
 }
 
-QVariant GEOMGUI_Selection::parameter( const int ind, const QString& p ) const
+//QVariant GEOMGUI_Selection::contextParameter( const QString& p ) const
+QVariant GEOMGUI_Selection::parameter( const QString& p ) const
 {
-//  if      ( p == "isVisible"   )    return QVariant( isVisible( ind ) );
+  QVariant v;
-// parameter isVisible is calculated in base SalomeApp_Selection
+  if ( p == "isOCC" )
-//  else
+    v = activeViewType() == OCCViewer_Viewer::Type();
-  if( p == "type" )
+  else if ( p == "selectionmode" )
-    return QVariant( typeName( ind ) );
+    v = selectionMode();
-  if( p == "typeid" )
+  else if ( p == "hasImported" )
-    return QVariant( typeId( ind ) );
+    v = hasImported();
-  else if ( p == "displaymode" )
+  else if ( p == "allImported" )
-    return QVariant( displayMode( ind ) );
+    v = allImported();
-  else if ( p == "isAutoColor" )
-    return QVariant( isAutoColor( ind ) );
-  else if ( p == "isVectorsMode" )
-    return QVariant( isVectorsMode( ind ) );
-  else if ( p == "hasHiddenChildren" )
-    return QVariant( hasHiddenChildren( ind ) );
-  else if ( p == "hasShownChildren" )
-    return QVariant( hasShownChildren( ind ) );
-  else if ( p == "compoundOfVertices" )
-    return QVariant( compoundOfVertices( ind ) );
   else
-    return LightApp_Selection::parameter( ind, p );
+    v = LightApp_Selection::parameter( p );
+  return v;
+}
+
+//QVariant GEOMGUI_Selection::objectParameter( const int idx, const QString& p ) const
+QVariant GEOMGUI_Selection::parameter( const int idx, const QString& p ) const
+{
+  QVariant v;
+  if ( p == "type" )
+    v = typeName( idx );
+  else if ( p == "typeid" )
+    v = typeId( idx );
+  else if ( p == "displaymode" )
+    v = displayMode( idx );
+  else if ( p == "isAutoColor" )
+    v = isAutoColor( idx );
+  else if ( p == "isVectorsMode" )
+    v = isVectorsMode( idx );
+  else if ( p == "hasHiddenChildren" )
+    v = hasHiddenChildren( idx );
+  else if ( p == "hasShownChildren" )
+    v = hasShownChildren( idx );
+  else if ( p == "compoundOfVertices" )
+    v = compoundOfVertices( idx );
+  else if ( p == "imported" )
+    v = isImported( idx );
+  else
+    v = LightApp_Selection::parameter( idx, p );
+
+  return v;
 }
 
 // the method to skip temporary objects from selection (called from LightApp)
-
+bool GEOMGUI_Selection::processOwner( const LightApp_DataOwner* theOwner )
-bool GEOMGUI_Selection::processOwner( const LightApp_DataOwner* theOwner)
 {
   return !theOwner->entry().contains("_");
 }
@@ -115,15 +165,20 @@ QString GEOMGUI_Selection::typeName( const int index ) const
 {
   if ( isComponent( index ) )
     return "Component";
+
+  static QString aGroup( "Group" );
+  static QString aShape( "Shape" );
+  static QString anUnknown( "Unknown" );
+
   GEOM::GEOM_Object_var anObj = getObject( index );
   if ( !CORBA::is_nil( anObj ) ) {
     const int aGeomType = anObj->GetType();
     if ( aGeomType == GEOM_GROUP )
-      return "Group";
+      return aGroup;
     else
-      return "Shape";
+      return aShape;
   }
-  return "Unknown";
+  return anUnknown;
 }
 
 int GEOMGUI_Selection::typeId( const int index ) const
@@ -131,20 +186,35 @@ int GEOMGUI_Selection::typeId( const int index ) const
   int aType = -1;
   GEOM::GEOM_Object_var anObj = getObject( index );
   if ( !CORBA::is_nil( anObj ) )
-    //aType = anObj->GetType();
     aType = (int)anObj->GetShapeType();
   return aType;
 }
 
 bool GEOMGUI_Selection::isVisible( const int index ) const
 {
+  bool res = false;
+
+#ifdef USE_VISUAL_PROP_MAP
+  bool found = false;
+  QVariant v = visibleProperty( entry( index ), VISIBILITY_PROP );
+  if ( v.canConvert( QVariant::Bool ) ) {
+    res = v.toBool();
+    found = true;
+  }
+
+  if ( !found ) {
+#endif
     GEOM::GEOM_Object_var obj = getObject( index );
     SALOME_View* view = GEOM_Displayer::GetActiveView();
     if ( !CORBA::is_nil( obj ) && view ) {
       Handle(SALOME_InteractiveObject) io = new SALOME_InteractiveObject( entry( index ).toLatin1().constData(), "GEOM", "TEMP_IO" );
-    return view->isVisible( io );
+      res = view->isVisible( io );
     }
-  return false;
+#ifdef USE_VISUAL_PROP_MAP
+  }
+#endif
+
+  return res;
 }
 
 bool GEOMGUI_Selection::isAutoColor( const int index ) const
@@ -155,10 +225,62 @@ bool GEOMGUI_Selection::isAutoColor( const int index ) const
   return false;
 }
 
+bool GEOMGUI_Selection::isImported( const int index ) const
+{
+  GEOM::GEOM_Object_var obj = getObject( index );
+  if ( !CORBA::is_nil( obj ) )
+    return obj->GetType() == GEOM_IMPORT;
+  return false;
+}
+
+bool GEOMGUI_Selection::hasImported() const
+{
+  bool res = false;
+  for ( int i = 0; i < count() && !res; i++ )
+    res = isImported( i );
+  return res;
+}
+
+bool GEOMGUI_Selection::allImported() const
+{
+  bool res = true;
+  for ( int i = 0; i < count() && res; i++ )
+    res = isImported( i );
+  return res;
+}
+
+QVariant GEOMGUI_Selection::visibleProperty( const QString& entry, const QString& propName ) const
+{
+  QVariant v;
+  LightApp_Study* aStudy = study();
+  if ( aStudy ) {
+    LightApp_Application* anApp = ::qobject_cast<LightApp_Application*>( aStudy->application() );
+    if ( anApp && anApp->activeViewManager() ) {
+      int id = anApp->activeViewManager()->getGlobalId();
+      v = aStudy->getObjectProperty( id, entry, propName, QVariant() );
+    }
+  }
+  return v;
+}
+
 QString GEOMGUI_Selection::displayMode( const int index ) const
 {
-  SALOME_View* view = GEOM_Displayer::GetActiveView();
+  QString res;
   QString viewType = activeViewType();
+#ifdef USE_VISUAL_PROP_MAP
+  QVariant v = visibleProperty( entry( index ), DISPLAY_MODE_PROP );
+  if ( v.canConvert( QVariant::Int ) ) {
+    int dm = v.toInt();
+    if ( viewType == OCCViewer_Viewer::Type() ) {
+      OCC_DISPLAY_MODE_TO_STRING( res, dm );
+    } else if ( viewType == SVTK_Viewer::Type() ) {
+      VTK_DISPLAY_MODE_TO_STRING( res, dm );
+    }
+  }
+
+  if ( res.isEmpty() ) {
+#endif
+    SALOME_View* view = GEOM_Displayer::GetActiveView();
     if ( view /*fix for 9320==>*/&& ( viewType == OCCViewer_Viewer::Type() || viewType == SVTK_Viewer::Type() ) ) {
       SALOME_Prs* prs = view->CreatePrs( entry( index ).toLatin1().constData() );
       if ( prs ) {
@@ -170,19 +292,13 @@ QString GEOMGUI_Selection::displayMode( const int index ) const
 	    Handle(AIS_InteractiveObject) io = lst.First();
 	    if ( !io.IsNull() ) {
 	      int dm = io->DisplayMode();
-            if ( dm == AIS_WireFrame )
+	      OCC_DISPLAY_MODE_TO_STRING( res, dm );
-              return "Wireframe";
+	      if ( res.isEmpty() ) { // return default display mode of AIS_InteractiveContext
-            else if ( dm == AIS_Shaded )
+		OCCViewer_Viewer* occViewer = (OCCViewer_Viewer*)SUIT_Session::session()->activeApplication()->
-              return "Shading";
+		  desktop()->activeWindow()->getViewManager()->getViewModel();
-            else { // return default display mode of AIS_InteractiveContext
-              OCCViewer_Viewer* occViewer = (OCCViewer_Viewer*) SUIT_Session::session()->activeApplication()->desktop(
-                                            )->activeWindow()->getViewManager()->getViewModel();
 		Handle(AIS_InteractiveContext) ic = occViewer->getAISContext();
 		dm = ic->DisplayMode();
-              if ( dm == AIS_WireFrame )
+		OCC_DISPLAY_MODE_TO_STRING( res, dm );
-                return "Wireframe";
-              else if ( dm == AIS_Shaded )
-                return "Shading";
 	      }
 	    }
 	  }
@@ -197,22 +313,35 @@ QString GEOMGUI_Selection::displayMode( const int index ) const
 	      SALOME_Actor* salActor = dynamic_cast<SALOME_Actor*>( actor );
 	      if ( salActor ) {
 		int dm = salActor->getDisplayMode();
-              if ( dm == 0 )
+		VTK_DISPLAY_MODE_TO_STRING( res, dm );
-                return "Wireframe";
-              else if ( dm == 1 )
-                return "Shading";
 	      } // if ( salome actor )
 	    } // if ( actor )
 	  } // if ( lst == vtkPrs->GetObjects() )
 	} // if VTK
       }
     }
-  return "";
+
+#ifdef USE_VISUAL_PROP_MAP
+  }
+#endif
+
+  return res;
 }
 
 bool GEOMGUI_Selection::isVectorsMode( const int index ) const
 {
-  bool ret = false;
+  bool res = false;
+
+#ifdef USE_VISUAL_PROP_MAP
+  bool found = false;
+  QVariant v = visibleProperty( entry( index ), VECTOR_MODE_PROP );
+  if ( v.canConvert( QVariant::Bool ) ) {
+    res = v.toBool();
+    found = true;
+  }
+
+  if ( !found ) {
+#endif
     SALOME_View* view = GEOM_Displayer::GetActiveView();
     QString viewType = activeViewType();
     if ( view && ( viewType == OCCViewer_Viewer::Type() || viewType == SVTK_Viewer::Type() ) ) {
@@ -227,7 +356,7 @@ bool GEOMGUI_Selection::isVectorsMode( const int index ) const
 	    if ( !io.IsNull() ) {
 	      Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);
 	      if ( !aSh.IsNull() )
-              ret = aSh->isShowVectors();
+		res = aSh->isShowVectors();
 	    }
 	  }
 	} else if ( viewType == SVTK_Viewer::Type() ) { // assuming VTK
@@ -239,13 +368,17 @@ bool GEOMGUI_Selection::isVectorsMode( const int index ) const
 	    if ( actor ) {
 	      GEOM_Actor* aGeomActor = GEOM_Actor::SafeDownCast(actor);
 	      if ( aGeomActor )
-              ret = aGeomActor->GetVectorMode();
+		res = aGeomActor->GetVectorMode();
 	    }
 	  }
 	}
       }
     }
-  return ret;
+#ifdef USE_VISUAL_PROP_MAP
+  }
+#endif
+
+  return res;
 }
 
 bool GEOMGUI_Selection::hasChildren( const _PTR(SObject)& obj )
@@ -279,9 +412,10 @@ bool GEOMGUI_Selection::expandable( const _PTR(SObject)& obj )
 bool GEOMGUI_Selection::isCompoundOfVertices( GEOM::GEOM_Object_ptr obj )
 {
   bool ret = false;
+  /*
   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>
-    (SUIT_Session::session()->activeApplication()->activeStudy());
+  (SUIT_Session::session()->activeApplication()->activeStudy());*/
-  if ( appStudy && !CORBA::is_nil( obj ) )
+  if ( /*appStudy && */!CORBA::is_nil( obj ) )
     ret = obj->GetShapeType() == GEOM::COMPOUND && obj->GetMaxShapeType() == GEOM::VERTEX;
   return ret;
 }
@@ -289,13 +423,11 @@ bool GEOMGUI_Selection::isCompoundOfVertices( GEOM::GEOM_Object_ptr obj )
 bool GEOMGUI_Selection::hasHiddenChildren( const int index ) const
 {
   bool OK = false;
-  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>
+  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
-    (SUIT_Session::session()->activeApplication()->activeStudy());
 
-  if ( appStudy && index >= 0 && index < count() )  {
+  if ( appStudy ) {
-    _PTR(Study) study = appStudy->studyDS();
     QString anEntry = entry( index );
-
+    _PTR(Study) study = appStudy->studyDS();
     if ( study && !anEntry.isEmpty() ) {
       _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
       OK = !expandable( aSO ) && hasChildren( aSO );
@@ -307,13 +439,11 @@ bool GEOMGUI_Selection::hasHiddenChildren( const int index ) const
 bool GEOMGUI_Selection::hasShownChildren( const int index ) const
 {
   bool OK = false;
-  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>
+  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
-    (SUIT_Session::session()->activeApplication()->activeStudy());
 
-  if ( appStudy && index >= 0 && index < count() )  {
+  if ( appStudy )  {
-    _PTR(Study) study = appStudy->studyDS();
     QString anEntry = entry( index );
-
+    _PTR(Study) study = appStudy->studyDS();
     if ( study && !anEntry.isEmpty() ) {
       _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
       OK = expandable( aSO ) && hasChildren( aSO );
@@ -324,18 +454,17 @@ bool GEOMGUI_Selection::hasShownChildren( const int index ) const
 
 bool GEOMGUI_Selection::compoundOfVertices( const int index ) const
 {
-  return isCompoundOfVertices( getObject( index ) );
+  GEOM::GEOM_Object_var obj = getObject( index );
+  return isCompoundOfVertices( obj );
 }
 
 bool GEOMGUI_Selection::isComponent( const int index ) const
 {
-  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>
+  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
-    (SUIT_Session::session()->activeApplication()->activeStudy());
 
-  if ( appStudy && index >= 0 && index < count() )  {
+  if ( appStudy ) {
-    _PTR(Study) study = appStudy->studyDS();
     QString anEntry = entry( index );
-
+    _PTR(Study) study = appStudy->studyDS();
     if ( study && !anEntry.isNull() ) {
       _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
       if ( aSO && aSO->GetFatherComponent() )
@@ -347,31 +476,19 @@ bool GEOMGUI_Selection::isComponent( const int index ) const
 
 GEOM::GEOM_Object_ptr GEOMGUI_Selection::getObject( const int index ) const
 {
-  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>
+  GEOM::GEOM_Object_var o;
-    (SUIT_Session::session()->activeApplication()->activeStudy());
+  if ( 0 <= index && index < myObjects.size() )
-
+    o = GEOM::GEOM_Object::_duplicate( myObjects[index] );
-  if (appStudy && index >= 0 && index < count()) {
+  return o._retn();
-    _PTR(Study) study = appStudy->studyDS();
-    QString anEntry = entry(index);
-
-    if (study && !anEntry.isNull()) {
-      _PTR(SObject) aSO (study->FindObjectID(anEntry.toStdString()));
-      if (aSO) {
-        CORBA::Object_var anObj = GeometryGUI::ClientSObjectToObject(aSO);
-        return GEOM::GEOM_Object::_narrow(anObj);
-      }
-    }
-  }
-  return GEOM::GEOM_Object::_nil();
 }
 
 QString GEOMGUI_Selection::selectionMode() const
 {
-  SalomeApp_Application* app = (SalomeApp_Application*)(SUIT_Session::session()->activeApplication());
+  SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( study()->application() );
-  if (app) {
+  if ( app ) {
     GeometryGUI* aGeomGUI = dynamic_cast<GeometryGUI*>( app->module( "Geometry" ) );
-    if (aGeomGUI) {
+    if ( aGeomGUI ) {
-      switch (aGeomGUI->getLocalSelectionMode())
+      switch ( aGeomGUI->getLocalSelectionMode() )
       {
         case GEOM_POINT      : return "VERTEX";
         case GEOM_EDGE       : return "EDGE";

src/GEOMGUI/GEOMGUI_Selection.h

@@ -43,18 +43,24 @@ public:
   GEOMGUI_Selection();
   virtual ~GEOMGUI_Selection();
 
-  virtual QVariant      parameter( const int, const QString& ) const;
+  virtual void          init( const QString&, LightApp_SelectionMgr* );
-  virtual QVariant      parameter( const QString& ) const;
-  
   virtual bool          processOwner( const LightApp_DataOwner* );
 
+  virtual QVariant      parameter( const QString& ) const;
+  virtual QVariant      parameter( const int, const QString& ) const;
+
   static bool           hasChildren( const _PTR(SObject)& );
   static bool           expandable( const _PTR(SObject)& );
   static bool           isCompoundOfVertices( GEOM::GEOM_Object_ptr );
 
+protected:
+  //  virtual QVariant      contextParameter( const QString& ) const;
+  //  virtual QVariant      objectParameter( const int, const QString& ) const;
+
 private:
   bool                  isVisible( const int ) const;
   bool                  isAutoColor( const int ) const;
+  bool                  isImported( const int ) const;
   QString               typeName( const int ) const;
   int                   typeId( const int ) const;
   QString               displayMode( const int ) const;
@@ -66,6 +72,17 @@ private:
 
   bool                  isComponent( const int ) const;
   GEOM::GEOM_Object_ptr getObject( const int ) const;
+
+  bool                  hasImported() const;
+  bool                  allImported() const;
+
+  QVariant              visibleProperty( const QString&, const QString& ) const;
+
+private:
+  typedef QVector<GEOM::GEOM_Object_var> GeomObjectVector;
+
+private:
+  GeomObjectVector      myObjects;
 };
 
-#endif // GEOMGUI_SELECTION_H
+#endif

src/GEOMGUI/GeometryGUI.cxx

@@ -70,6 +70,7 @@
 
 // External includes
 #include <QMenu>
+#include <QTime>
 #include <QAction>
 #include <QFileInfo>
 #include <QString>
@@ -1200,6 +1201,8 @@ void GeometryGUI::initialize( CAM_Application* app )
   mgr->insert( action(  GEOMOp::OpPublishObject ), -1, -1 ); // Publish object
   mgr->setRule( action( GEOMOp::OpPublishObject ), QString("client='ObjectBrowser' and isComponent=true"), QtxPopupMgr::VisibleRule );
 
+  mgr->insert( action(  GEOMOp::OpReimport ), -1, -1 );  // delete
+  mgr->setRule( action( GEOMOp::OpReimport ), QString("$imported in {'true'} and selcount>0"), QtxPopupMgr::VisibleRule );
 
   mgr->hide( mgr->actionId( action( myEraseAll ) ) );
 }
@@ -1484,8 +1487,9 @@ LightApp_Selection* GeometryGUI::createSelection() const
 
 void GeometryGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
 {
-  SalomeApp_Module::contextMenuPopup(client, menu, title);
+  SalomeApp_Module::contextMenuPopup( client, menu, title );
 
+  /*
   SALOME_ListIO lst;
   getApp()->selectionMgr()->selectedObjects(lst);
   if (lst.Extent() < 1)
@@ -1518,6 +1522,7 @@ void GeometryGUI::contextMenuPopup( const QString& client, QMenu* menu, QString&
   if (isImported) {
     menu->addAction(action(GEOMOp::OpReimport)); // Reload imported shape
   }
+  */
 }
 
 void GeometryGUI::createPreferences()