Salome HOME
Merge remote-tracking branch 'origin/BR_1321_ECW' into BR_DEMO
[modules/hydro.git] / src / HYDROGUI / HYDROGUI_Shape.cxx
index 6f1f62f9afdace888abe0ae2fb50eacb365b0042..964df94c41e6e121859167af5477eef6ef255e0d 100644 (file)
@@ -18,6 +18,9 @@
 
 #include <HYDROGUI_Shape.h>
 #include <HYDROGUI_Tool.h>
+#include <HYDROGUI_Polyline.h>
+#include <HYDROGUI_AISShape.h>
+
 #include <HYDROData_Channel.h>
 #include <HYDROData_Document.h>
 #include <HYDROData_DummyObject3D.h>
 #include <HYDROData_ShapesGroup.h>
 #include <HYDROData_Stream.h>
 #include <HYDROData_Zone.h>
-#include <HYDROGUI_Polyline.h>
+#include <HYDROData_LandCoverMap.h>
 
-#include <AIS_Shape.hxx>
 #include <BRep_Builder.hxx>
 #include <BRepBuilderAPI_MakeFace.hxx>
-#include <Graphic3d_AspectFillArea3d.hxx>
 #include <Prs3d_IsoAspect.hxx>
-#include <Prs3d_ShadingAspect.hxx>
 #include <TopoDS.hxx>
 #include <TopoDS_Face.hxx>
 #include <TopoDS_Wire.hxx>
 #include <TopExp_Explorer.hxx>
 
+#include <SUIT_ResourceMgr.h>
+#include <SUIT_Session.h>
+
 HYDROGUI_Shape::HYDROGUI_Shape( const Handle(AIS_InteractiveContext)& theContext,
                                 const Handle(HYDROData_Entity)&       theObject,
                                 const int                             theZLayer )
@@ -54,16 +57,14 @@ HYDROGUI_Shape::HYDROGUI_Shape( const Handle(AIS_InteractiveContext)& theContext
   myHighlightColor( Qt::white ),
   myIsToUpdate( false ),
   myIsVisible( true ),
-  myDisplayMode( AIS_Shaded )
+  myDisplayMode( AIS_Shaded ),
+  mySelectionMode( AIS_Shape::SelectionMode( TopAbs_SHAPE ) )
 {
 }
 
 HYDROGUI_Shape::~HYDROGUI_Shape()
 {
   erase( false );
-
-  if ( !myShape.IsNull() )
-    myShape.Nullify();
 }
 
 Handle(AIS_InteractiveContext) HYDROGUI_Shape::getContext() const
@@ -96,14 +97,14 @@ bool HYDROGUI_Shape::isVisible() const
   return myIsVisible;
 }
 
-Handle(AIS_InteractiveObject) HYDROGUI_Shape::getAISObject() const
+QList<Handle(AIS_InteractiveObject)> HYDROGUI_Shape::getAISObjects() const
 {
-  return myShape;
+  return myShapes;
 }
 
 void HYDROGUI_Shape::display( const bool theIsUpdateViewer )
 {
-  if ( myContext.IsNull() || myShape.IsNull() || !isVisible() )
+  if ( myContext.IsNull() || myShapes.empty() || !isVisible() )
     return;
 
   displayShape( theIsUpdateViewer );
@@ -111,10 +112,10 @@ void HYDROGUI_Shape::display( const bool theIsUpdateViewer )
 
 void HYDROGUI_Shape::erase( const bool theIsUpdateViewer )
 {
-  if ( myContext.IsNull() || myShape.IsNull() )
+  if ( myContext.IsNull() || myShapes.empty() )
     return;
 
-  myContext->Erase( myShape, theIsUpdateViewer );
+  eraseShape( theIsUpdateViewer );
 }
 
 void HYDROGUI_Shape::update( bool isUpdateViewer,
@@ -164,11 +165,15 @@ void HYDROGUI_Shape::update( bool isUpdateViewer,
 
       TopoDS_Shape aPolylineShape = aPolyline->GetShape();
 
-      if ( !aPolylineShape.IsNull() ) {
-        if ( aPolylineShape.ShapeType() == TopAbs_WIRE ) {
+      if ( !aPolylineShape.IsNull() )
+      {
+        if ( aPolylineShape.ShapeType() == TopAbs_WIRE )
+        {
           TopoDS_Wire aPolylineWire = TopoDS::Wire( aPolylineShape );
           setWire( aPolylineWire, false, false );  
-        } else {
+        }
+        else
+        {
           myTopoShape = aPolylineShape;
           // Set shading mode to avoid that hilight presentation is equal to "normal" object presentation.
           // Note that hilight presentation is always to be on top ( i.e. in the top Z layer ).
@@ -215,15 +220,15 @@ void HYDROGUI_Shape::update( bool isUpdateViewer,
       TopoDS_Face aZoneFace = TopoDS::Face( aZone->GetShape() );
 
       setFace( aZoneFace, false, false, "" );
-      if (aZone->IsMergingNeed() && aZone->GetMergeType() == HYDROData_Zone::Merge_UNKNOWN )
+      ifaZone->IsMergingNeed() && aZone->GetMergeType() == HYDROData_Zone::Merge_UNKNOWN )
       {
         // Red color for a zone with bathymetry conflict
         setFillingColor( Qt::red );
       }
       else
       {
-               // Set the filling color for zone
-               setFillingColor( aZone->GetColor(HYDROData_ImmersibleZone::DefaultFillingColor()) );
+                   // Set the filling color for zone
+        setFillingColor( aZone->GetColor( Qt::darkBlue ) );
       }
     }
     else if ( myObject->IsKind( STANDARD_TYPE(HYDROData_Profile) ) )
@@ -300,13 +305,14 @@ void HYDROGUI_Shape::update( bool isUpdateViewer,
     }
   }
  
-  if ( myShape.IsNull() || !isVisible() )
+  if ( myShapes.empty() || !isVisible() )
     return;
 
   displayShape( isUpdateViewer );
 
   if (isDeactivateSelection)
-    myContext->Deactivate(myShape);
+    foreach( Handle(AIS_InteractiveObject) aShape, myShapes )
+      myContext->Deactivate( aShape );
 }
 
 void HYDROGUI_Shape::setVisible( const bool theState,
@@ -314,18 +320,18 @@ void HYDROGUI_Shape::setVisible( const bool theState,
 {
   myIsVisible = theState;
 
-  if ( myShape.IsNull() )
+  if ( myShapes.empty() )
     return;
 
-  if ( ( myIsVisible && myContext->IsDisplayed( myShape ) ) ||
-       ( !myIsVisible && !myContext->IsDisplayed( myShape ) ) )
+  if ( ( myIsVisible && myContext->IsDisplayed( myShapes[0] ) ) ||
+       ( !myIsVisible && !myContext->IsDisplayed( myShapes[0] ) ) )
     return;
 
   if ( myIsVisible ) {
     displayShape( theIsUpdateViewer );
   }
   else
-    myContext->Erase( myShape, theIsUpdateViewer );
+    eraseShape( theIsUpdateViewer );
 }
 
 void HYDROGUI_Shape::highlight( bool theIsHighlight, bool isUpdateViewer )
@@ -335,7 +341,7 @@ void HYDROGUI_Shape::highlight( bool theIsHighlight, bool isUpdateViewer )
 
   myIsHighlight = theIsHighlight;
 
-  if ( myContext.IsNull() || myShape.IsNull() )
+  if ( myContext.IsNull() || myShapes.empty() )
     return;
 
   colorShapeBorder( getActiveColor() );
@@ -419,10 +425,11 @@ void HYDROGUI_Shape::setFace( const TopoDS_Face& theFace,
 
 void HYDROGUI_Shape::setShape( const TopoDS_Shape& theShape,
                                const bool          theToDisplay,
-                               const bool          theIsUpdateViewer )
+                               const bool          theIsUpdateViewer,
+                               const int           theDisplayMode )
 {
   myTopoShape = theShape;
-  myDisplayMode = AIS_Shaded;
+  myDisplayMode = theDisplayMode;
 
   buildShape();
   updateShape( theToDisplay, theIsUpdateViewer );
@@ -470,76 +477,100 @@ void HYDROGUI_Shape::setZLayer( const int theZLayer )
     return;
 
   myZLayer = theZLayer;
-  if ( !myShape.IsNull() && isVisible() && !myContext.IsNull() && myZLayer >= 0 )
-    myContext->SetZLayer( myShape, myZLayer );
+  if( isVisible() && !myContext.IsNull() && myZLayer >= 0 )
+    foreach( Handle(AIS_InteractiveObject) aShape, myShapes )
+      myContext->SetZLayer( aShape, myZLayer );
 }
 
-Handle_AIS_InteractiveObject HYDROGUI_Shape::createShape() const
+QList<Handle(AIS_InteractiveObject)> HYDROGUI_Shape::createShape() const
 {
+  QList<Handle(AIS_InteractiveObject)> shapes;
   if( myTopoShape.IsNull() ) {
-    return Handle_AIS_InteractiveObject();
+    return shapes;
   }
 
   TopAbs_ShapeEnum aShapeType = myTopoShape.ShapeType();
-  if ( aShapeType==TopAbs_EDGE || aShapeType==TopAbs_WIRE ) {
-    return new HYDROGUI_Polyline( myTopoShape );
-  } else {
-    return new AIS_Shape( myTopoShape );
+  bool IsWireEdgeCompound = aShapeType==TopAbs_COMPOUND;
+  if (IsWireEdgeCompound) {
+    TopoDS_Iterator itr(myTopoShape);
+    while (itr.More() && IsWireEdgeCompound) {
+      if (itr.Value().ShapeType() != TopAbs_WIRE && itr.Value().ShapeType() != TopAbs_EDGE)
+        IsWireEdgeCompound = false;
+      itr.Next();
+    }
   }
+
+  if ( aShapeType==TopAbs_EDGE || aShapeType==TopAbs_WIRE || IsWireEdgeCompound)
+  {
+    SUIT_ResourceMgr* aResMgr = 0;
+    SUIT_Session* aSession = SUIT_Session::session();
+    if ( aSession )
+      aResMgr = SUIT_Session::session()->resourceMgr();
+
+    int aType = -1;
+    int aSize = -1;
+    if( aResMgr )
+    {
+      aResMgr->value( "polyline", "arrow_type", aType );
+      aResMgr->value( "polyline", "arrow_size", aSize );
+    }
+
+    shapes.append( HYDROGUI_Polyline::createPresentations( myTopoShape, aType, aSize ) );
+  }
+  else
+  {
+    shapes.append( new HYDROGUI_AISShape( myTopoShape ) );
   }
+  return shapes;
 }
 
 void HYDROGUI_Shape::buildShape()
 {
   // Erase previously created shape
-  erase();
+  erase(false);
 
-  myShape = createShape();
-  if( myShape.IsNull() )
+  myShapes = createShape();
+  if( myShapes.empty() )
     return;
 
-  Handle_AIS_Shape anAISShape = Handle_AIS_Shape::DownCast( myShape );
-  if( !anAISShape.IsNull() )
-    anAISShape ->SetHLRAngleAndDeviation( 0.001 );
+  foreach( Handle(AIS_InteractiveObject) aShape, myShapes )
+  {
+    Handle(AIS_Shape) anAISShape = Handle(AIS_Shape)::DownCast( aShape );
+    if( !anAISShape.IsNull() )
+      anAISShape ->SetHLRAngleAndDeviation( 0.001 );
 
-  if ( !myObject.IsNull() )
-    myShape->SetOwner( myObject );
+    if ( !myObject.IsNull() )
+      aShape->SetOwner( myObject );
 
-  myShape->SetTransparency( 0 );
-  myShape->SetDisplayMode( (AIS_DisplayMode)myDisplayMode );
+    if ( !myObject.IsNull() && !myObject->IsKind( STANDARD_TYPE(HYDROData_LandCoverMap) ) )
+      aShape->SetTransparency( 0 );
+    aShape->SetDisplayMode( (AIS_DisplayMode)myDisplayMode );
 
     // Init default params for shape
-  const Handle(Prs3d_Drawer)& anAttributes = myShape->Attributes();
-  if ( !anAttributes.IsNull() )
-  {
-    Handle(Prs3d_IsoAspect) anIsoAspect = anAttributes->UIsoAspect();
-    if ( !anIsoAspect.IsNull() ) {
-      anIsoAspect->SetNumber( 0 );
-      anAttributes->SetUIsoAspect( anIsoAspect );
-    }
-      
-    anIsoAspect = anAttributes->VIsoAspect();
-    if ( !anIsoAspect.IsNull() ) {
-      anIsoAspect->SetNumber( 0 );
-      anAttributes->SetVIsoAspect( anIsoAspect );
-    }
-
-    if ( myDisplayMode == AIS_Shaded )
+    const Handle(Prs3d_Drawer)& anAttributes = aShape->Attributes();
+    if ( !anAttributes.IsNull() )
     {
-      Handle(Prs3d_ShadingAspect) aShadingAspect = anAttributes->ShadingAspect();
-      if ( !aShadingAspect.IsNull() )
+      Handle(Prs3d_IsoAspect) anIsoAspect = anAttributes->UIsoAspect();
+      if ( !anIsoAspect.IsNull() ) {
+        anIsoAspect->SetNumber( 0 );
+        anAttributes->SetUIsoAspect( anIsoAspect );
+      }
+      
+      anIsoAspect = anAttributes->VIsoAspect();
+      if ( !anIsoAspect.IsNull() )
       {
-        Graphic3d_MaterialAspect aMatAspect( Graphic3d_NOM_PLASTIC );
-        //aMatAspect.SetAmbient( 1 );
-        //aMatAspect.SetDiffuse( 0 );
+        anIsoAspect->SetNumber( 0 );
+        anAttributes->SetVIsoAspect( anIsoAspect );
+      }
 
-        aShadingAspect->Aspect()->SetFrontMaterial( aMatAspect );
-        aShadingAspect->Aspect()->SetBackMaterial( aMatAspect );
+      if ( myDisplayMode == AIS_Shaded )
+      {
+        aShape->SetMaterial( Graphic3d_NOM_PLASTIC );
+      }
+      else if ( myDisplayMode == AIS_WireFrame )
+      {
+        anAttributes->SetWireDraw( true );
       }
-    }
-    else if ( myDisplayMode == AIS_WireFrame )
-    {
-      anAttributes->SetWireDraw( true );
     }
   }
 }
@@ -547,35 +578,30 @@ void HYDROGUI_Shape::buildShape()
 void HYDROGUI_Shape::updateShape( const bool theToDisplay,
                                   const bool theIsUpdateViewer )
 {
-  if ( myShape.IsNull() )
-    return;
-
-  const Handle(Prs3d_Drawer)& anAttributes = myShape->Attributes();
-  if ( !anAttributes.IsNull() )
+  foreach( Handle(AIS_InteractiveObject) aShape, myShapes )
   {
-    if ( myDisplayMode == AIS_Shaded )
+    const Handle(Prs3d_Drawer)& anAttributes = aShape->Attributes();
+    if ( !anAttributes.IsNull() )
     {
-      // Coloring face filling
-      Handle(Prs3d_ShadingAspect) aShadingAspect = anAttributes->ShadingAspect();
-      if ( !aShadingAspect.IsNull() )
+      if ( myDisplayMode == AIS_Shaded && myFillingColor.isValid() )
       {
         Quantity_Color aFillingColor( getQuantityColorVal( myFillingColor.red() ), 
                                       getQuantityColorVal( myFillingColor.green() ),
                                       getQuantityColorVal( myFillingColor.blue() ),
                                       Quantity_TOC_RGB );
-
-        aShadingAspect->SetColor( aFillingColor );
-        aShadingAspect->SetTransparency( 1 - getQuantityColorVal( myFillingColor.alpha() ) );
+  
+        aShape->SetColor( aFillingColor );
+        aShape->SetTransparency( 1 - getQuantityColorVal( myFillingColor.alpha() ) );
       }
+      else if ( myDisplayMode == AIS_WireFrame )
+      {
+      }
+  
+      // Coloring borders
     }
-    else if ( myDisplayMode == AIS_WireFrame )
-    {
-    }
-
-    // Coloring borders
-    colorShapeBorder( getActiveColor() );
   }
-
+  
+  colorShapeBorder( myBorderColor );
   if ( !theToDisplay || !isVisible() || myContext.IsNull() )
     return;
   
@@ -584,16 +610,55 @@ void HYDROGUI_Shape::updateShape( const bool theToDisplay,
 
 void HYDROGUI_Shape::displayShape( const bool theIsUpdateViewer )
 {
-  myContext->Display( myShape, Standard_False );
+  if ( myContext->HasOpenedContext() && mySelectionMode > 0 )
+    myContext->CloseLocalContext();
+
+  foreach( Handle(AIS_InteractiveObject) aShape, myShapes )
+  {
+    if ( mySelectionMode > 0 )
+      // Display object in local context with selection
+      myContext->Display( aShape, myDisplayMode, mySelectionMode, Standard_False, Standard_False );
+    else
+    {
+      if ( !myContext->HasOpenedContext() )
+        // Ordinary display of object published in the Object Browser
+        myContext->Display( aShape, Standard_False );
+      else
+        // Display object in local context without selection
+        myContext->Display( aShape, myDisplayMode, -1, Standard_False, Standard_False );
+    }
+  }
+  
+  if ( mySelectionMode > 0 )
+  {
+    myContext->OpenLocalContext();
+    foreach( Handle(AIS_InteractiveObject) aShape, myShapes )
+      myContext->Activate( aShape, mySelectionMode, Standard_True );
+  }
 
   if ( myZLayer >= 0 )
-    myContext->SetZLayer( myShape, myZLayer );
+  {
+    foreach( Handle(AIS_InteractiveObject) aShape, myShapes )
+      myContext->SetZLayer( aShape, myZLayer );
+  }
 
   if ( theIsUpdateViewer ) {
     myContext->UpdateCurrentViewer();
   }
 }
 
+void HYDROGUI_Shape::eraseShape( const bool theIsUpdateViewer )
+{
+  if ( myContext->HasOpenedContext() && mySelectionMode > 0 )
+    myContext->CloseLocalContext();
+
+  foreach( Handle(AIS_InteractiveObject) aShape, myShapes )
+    myContext->Erase( aShape, Standard_False );
+
+  if( theIsUpdateViewer )
+    myContext->UpdateCurrentViewer();
+}
+
 QColor HYDROGUI_Shape::getActiveColor() const
 {
   return isHighlighted() ? myHighlightColor : myBorderColor;
@@ -606,51 +671,33 @@ double HYDROGUI_Shape::getQuantityColorVal( const int theColorVal )
 
 void HYDROGUI_Shape::colorShapeBorder( const QColor& theColor )
 {
-  if ( myShape.IsNull() )
-    return;
-
-  const Handle(Prs3d_Drawer)& anAttributes = myShape->Attributes();
-  if ( anAttributes.IsNull() )
-    return;
+  foreach( Handle(AIS_InteractiveObject) aShape1, myShapes )
+  {
+    const Handle(Prs3d_Drawer)& anAttributes = aShape1->Attributes();
+    if ( anAttributes.IsNull() )
+      continue;
 
-  Quantity_Color aBorderColor( getQuantityColorVal( theColor.red() ), 
-                               getQuantityColorVal( theColor.green() ),
-                               getQuantityColorVal( theColor.blue() ),
-                               Quantity_TOC_RGB );
+    Quantity_Color aBorderColor( getQuantityColorVal( theColor.red() ), 
+                                 getQuantityColorVal( theColor.green() ),
+                                 getQuantityColorVal( theColor.blue() ),
+                                 Quantity_TOC_RGB );
   
-  if( !myTopoShape.IsNull() )
-  {
-    if ( myTopoShape.ShapeType() == TopAbs_WIRE ) // Note that we display polylines in shaded mode
-    {
-      myShape->SetColor( aBorderColor );
-    }
-    else if ( myDisplayMode == AIS_Shaded )
+    if( !myTopoShape.IsNull() )
     {
-      if ( theColor.alpha() == 0 )
+      if ( myTopoShape.ShapeType() == TopAbs_WIRE ) // Note that we display polylines in shaded mode
       {
-        anAttributes->SetFaceBoundaryDraw( false );
+        aShape1->SetColor( aBorderColor );
       }
-      else
+      else if ( myDisplayMode == AIS_Shaded )
       {
-        anAttributes->SetFaceBoundaryDraw( true );
-  
-        Handle(Prs3d_LineAspect) aBoundaryAspect = anAttributes->FaceBoundaryAspect();
-        if ( !aBoundaryAspect.IsNull() )
-        {
-          aBoundaryAspect->SetColor( aBorderColor );
-          anAttributes->SetFaceBoundaryAspect( aBoundaryAspect );
-        }
-        Handle(Prs3d_LineAspect) aWireAspect = anAttributes->WireAspect();
-        if ( !aWireAspect.IsNull() )
-        {
-          aWireAspect->SetColor( aBorderColor );
-          anAttributes->SetWireAspect( aWireAspect );
-        }
+        Handle(HYDROGUI_AISShape) aShape = Handle(HYDROGUI_AISShape)::DownCast( aShape1 );
+        if( !aShape.IsNull() )
+          aShape->SetBorderColor( aBorderColor );
+      }
+      else if ( myDisplayMode == AIS_WireFrame )
+      {
+        aShape1->SetColor( aBorderColor );
       }
-    }
-    else if ( myDisplayMode == AIS_WireFrame )
-    {
-      myShape->SetColor( aBorderColor );
     }
   }
 }
@@ -659,3 +706,8 @@ void HYDROGUI_Shape::setDisplayMode( int theDisplayMode )
 {
   myDisplayMode = theDisplayMode;
 }
+
+void HYDROGUI_Shape::setSelectionMode( int theSelectionMode )
+{
+  mySelectionMode = theSelectionMode;
+}