]> SALOME platform Git repositories - modules/geom.git/commitdiff
Salome HOME
Fix for the "0021179: EDF 1654 SMESH GEOM: better look'n'feel" issue:
authorana <ana@opencascade.com>
Fri, 13 Apr 2012 09:03:01 +0000 (09:03 +0000)
committerana <ana@opencascade.com>
Fri, 13 Apr 2012 09:03:01 +0000 (09:03 +0000)
- Material Properties

src/GEOMGUI/GEOMGUI_Selection.cxx
src/GEOMGUI/GEOMGUI_Selection.h
src/GEOMGUI/GEOM_Displayer.cxx
src/GEOMGUI/GEOM_msg_en.ts
src/GEOMGUI/GEOM_msg_fr.ts
src/GEOMGUI/GeometryGUI.cxx

index d7977004b83faaff7ab2e8806fc752856843b98a..d1c9eb77e8d88441676e0bfe64a8b20957ff1e1f 100644 (file)
-// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-//
-// 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.
-//
-// 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
-//
-
-// File   : GEOMGUI_Selection.cxx
-// Author : Alexander SOLOVYOV, Open CASCADE S.A.S. (alexander.solovyov@opencascade.com)
-//
-#include "GEOMGUI_Selection.h"
-
-#include "GeometryGUI.h"
-#include "GEOM_Displayer.h"
-
-#include <GEOM_Constants.h>
-
-#include <SalomeApp_Application.h>
-#include <SalomeApp_Study.h>
-
-#include "LightApp_DataOwner.h"
-
-#include <SUIT_Session.h>
-#include <SUIT_Desktop.h>
-#include <SUIT_ViewWindow.h>
-#include <SUIT_ViewManager.h>
-
-#include <SALOME_Prs.h>
-#include <SALOME_InteractiveObject.hxx>
-
-#include <SOCC_Prs.h>
-#include <SVTK_Prs.h>
-#include <SALOME_Actor.h>
-#include <GEOM_Actor.h>
-
-#include <OCCViewer_ViewModel.h>
-#include <SVTK_ViewModel.h>
-
-#include <GEOMImpl_Types.hxx>
-
-#include <GEOM_AISShape.hxx>
-
-// OCCT Includes
-#include <AIS.hxx>
-#include <AIS_InteractiveObject.hxx>
-#include <AIS_ListOfInteractive.hxx>
-
-// 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 if ( dm == GEOM_AISShape::ShadingWithEdges )    \
-      str = QString( "ShadingWithEdges" ); \
-    else if ( dm == GEOM_AISShape::TexturedShape )    \
-      str = QString( "Texture" ); \
-    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 if ( dm == 3 )    \
-      str = QString( "ShadingWithEdges" ); \
-    else \
-      str = QString(); }
-
-#define USE_VISUAL_PROP_MAP
-
-GEOMGUI_Selection::GEOMGUI_Selection()
-: LightApp_Selection()
-{
-}
-
-GEOMGUI_Selection::~GEOMGUI_Selection()
-{
-}
-
-void GEOMGUI_Selection::init( const QString& context, LightApp_SelectionMgr* selMgr )
-{
-  LightApp_Selection::init( context, selMgr );
-
-  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 );
-       }
-      }
-    }
-  }
-}
-
-//QVariant GEOMGUI_Selection::contextParameter( const QString& p ) const
-QVariant GEOMGUI_Selection::parameter( const QString& p ) const
-{
-  QVariant v;
-  if ( p == "isOCC" )
-    v = activeViewType() == OCCViewer_Viewer::Type();
-  else if ( p == "selectionmode" )
-    v = selectionMode();
-  else if ( p == "hasImported" )
-    v = hasImported();
-  else if ( p == "allImported" )
-    v = allImported();
-  else
-    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 == "topLevel" )
-    v = topLevel( 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 )
-{
-  return !theOwner->entry().contains("_");
-}
-
-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 aGroup;
-    else
-      return aShape;
-  }
-  return anUnknown;
-}
-
-int GEOMGUI_Selection::typeId( const int index ) const
-{
-  int aType = -1;
-  GEOM::GEOM_Object_var anObj = getObject( index );
-  if ( !CORBA::is_nil( anObj ) )
-    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" );
-      res = view->isVisible( io );
-    }
-#ifdef USE_VISUAL_PROP_MAP
-  }
-#endif
-
-  return res;
-}
-
-bool GEOMGUI_Selection::isAutoColor( const int index ) const
-{
-  GEOM::GEOM_Object_var obj = getObject( index );
-  if ( !CORBA::is_nil( obj ) )
-    return obj->GetAutoColor();
-  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
-{
-  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 ) {
-       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC
-         SOCC_Prs* occPrs = (SOCC_Prs*) prs;
-         AIS_ListOfInteractive lst;
-         occPrs->GetObjects( lst );
-         if ( lst.Extent() ) {
-           Handle(AIS_InteractiveObject) io = lst.First();
-           if ( !io.IsNull() ) {
-             int dm = io->DisplayMode();
-             OCC_DISPLAY_MODE_TO_STRING( res, dm );
-             if ( res.isEmpty() ) { // 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();
-               OCC_DISPLAY_MODE_TO_STRING( res, dm );
-             }
-           }
-         }
-       }
-       else if ( viewType == SVTK_Viewer::Type() ) { // assuming VTK
-         SVTK_Prs* vtkPrs = dynamic_cast<SVTK_Prs*>( prs );
-         vtkActorCollection* lst = vtkPrs ? vtkPrs->GetObjects() : 0;
-         if ( lst ) {
-           lst->InitTraversal();
-           vtkActor* actor = lst->GetNextActor();
-           if ( actor ) {
-             SALOME_Actor* salActor = dynamic_cast<SALOME_Actor*>( actor );
-             if ( salActor ) {
-               int dm = salActor->getDisplayMode();
-               VTK_DISPLAY_MODE_TO_STRING( res, dm );
-             } // if ( salome actor )
-           } // if ( actor )
-         } // if ( lst == vtkPrs->GetObjects() )
-       } // if VTK
-      }
-    }
-
-#ifdef USE_VISUAL_PROP_MAP
-  }
-#endif
-
-  return res;
-}
-
-bool GEOMGUI_Selection::isVectorsMode( const int index ) const
-{
-  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() ) ) {
-      SALOME_Prs* prs = view->CreatePrs( entry( index ).toLatin1().constData() );
-      if ( prs ) {
-       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC
-         SOCC_Prs* occPrs = (SOCC_Prs*) prs;
-         AIS_ListOfInteractive lst;
-         occPrs->GetObjects( lst );
-         if ( lst.Extent() ) {
-           Handle(AIS_InteractiveObject) io = lst.First();
-           if ( !io.IsNull() ) {
-             Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);
-             if ( !aSh.IsNull() )
-               res = aSh->isShowVectors();
-           }
-         }
-       } else if ( viewType == SVTK_Viewer::Type() ) { // assuming VTK
-         SVTK_Prs* vtkPrs = dynamic_cast<SVTK_Prs*>( prs );
-         vtkActorCollection* lst = vtkPrs ? vtkPrs->GetObjects() : 0;
-         if ( lst ) {
-           lst->InitTraversal();
-           vtkActor* actor = lst->GetNextActor();
-           if ( actor ) {
-             GEOM_Actor* aGeomActor = GEOM_Actor::SafeDownCast(actor);
-             if ( aGeomActor )
-               res = aGeomActor->GetVectorMode();
-           }
-         }
-       }
-      }
-    }
-#ifdef USE_VISUAL_PROP_MAP
-  }
-#endif
-
-  return res;
-}
-
-bool GEOMGUI_Selection::hasChildren( const _PTR(SObject)& obj )
-{
-  bool ok = false;
-  if ( obj ) {
-    _PTR(ChildIterator) it ( obj->GetStudy()->NewChildIterator( obj ) );
-    for ( ; it->More() && !ok; it->Next() ) {
-      _PTR(SObject) child = it->Value();
-      if ( child ) {
-        _PTR(SObject) refObj;
-        if ( child->ReferencedObject( refObj ) ) continue; // omit references
-        if ( child->GetName() != "" ) ok = true;
-      }
-    }
-  }
-  return ok;
-}
-
-bool GEOMGUI_Selection::expandable( const _PTR(SObject)& obj )
-{
-  bool exp = true;
-  _PTR(GenericAttribute) anAttr;
-  if ( obj && obj->FindAttribute( anAttr, "AttributeExpandable" ) ) {
-    _PTR(AttributeExpandable) aAttrExp = anAttr;
-    exp = aAttrExp->IsExpandable();
-  }
-  return exp;
-}
-
-bool GEOMGUI_Selection::isCompoundOfVertices( GEOM::GEOM_Object_ptr obj )
-{
-  bool ret = false;
-  /*
-  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>
-  (SUIT_Session::session()->activeApplication()->activeStudy());*/
-  if ( /*appStudy && */!CORBA::is_nil( obj ) )
-    ret = obj->GetShapeType() == GEOM::COMPOUND && obj->GetMaxShapeType() == GEOM::VERTEX;
-  return ret;
-}
-
-bool GEOMGUI_Selection::hasHiddenChildren( const int index ) const
-{
-  bool OK = false;
-  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
-
-  if ( appStudy ) {
-    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 );
-    }
-  }
-  return OK;
-}
-
-bool GEOMGUI_Selection::hasShownChildren( const int index ) const
-{
-  bool OK = false;
-  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
-
-  if ( appStudy )  {
-    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 );
-    }
-  }
-  return OK;
-}
-
-bool GEOMGUI_Selection::compoundOfVertices( const int index ) const
-{
-  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*>( study() );
-
-  if ( appStudy ) {
-    QString anEntry = entry( index );
-    _PTR(Study) study = appStudy->studyDS();
-    if ( study && !anEntry.isNull() ) {
-      _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
-      if ( aSO && aSO->GetFatherComponent() )
-        return aSO->GetFatherComponent()->GetIOR() == aSO->GetIOR();
-    }
-  }
-  return false;
-}
-
-GEOM::GEOM_Object_ptr GEOMGUI_Selection::getObject( const int index ) const
-{
-  GEOM::GEOM_Object_var o;
-  if ( 0 <= index && index < myObjects.size() )
-    o = GEOM::GEOM_Object::_duplicate( myObjects[index] );
-  return o._retn();
-}
-
-QString GEOMGUI_Selection::selectionMode() const
-{
-  SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( study()->application() );
-  if ( app ) {
-    GeometryGUI* aGeomGUI = dynamic_cast<GeometryGUI*>( app->module( "Geometry" ) );
-    if ( aGeomGUI ) {
-      switch ( aGeomGUI->getLocalSelectionMode() )
-      {
-        case GEOM_POINT      : return "VERTEX";
-        case GEOM_EDGE       : return "EDGE";
-        case GEOM_WIRE       : return "WIRE";
-        case GEOM_FACE       : return "FACE";
-        case GEOM_SHELL      : return "SHELL";
-        case GEOM_SOLID      : return "SOLID";
-        case GEOM_COMPOUND   : return "COMPOUND";
-        case GEOM_ALLOBJECTS : return "ALL";
-        default: return "";
-      }
-    }
-  }
-  return "";
-}
-
-bool GEOMGUI_Selection::topLevel( const int index ) const {
-  bool res = false;
-  
-#ifdef USE_VISUAL_PROP_MAP
-  bool found = false;
-  QVariant v = visibleProperty( entry( index ), TOP_LEVEL_PROP );
-  if ( v.canConvert<bool>() ) {
-    res = v.toBool();
-    found = true;
-  }
-
-  if ( !found ) {
-#endif
-    SALOME_View* view = GEOM_Displayer::GetActiveView();
-    QString viewType = activeViewType();
-    if ( view && viewType == OCCViewer_Viewer::Type() ) {
-      SALOME_Prs* prs = view->CreatePrs( entry( index ).toLatin1().constData() );
-      if ( prs ) {
-       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC
-         SOCC_Prs* occPrs = (SOCC_Prs*) prs;
-         AIS_ListOfInteractive lst;
-         occPrs->GetObjects( lst );
-         if ( lst.Extent() ) {
-           Handle(AIS_InteractiveObject) io = lst.First();
-           if ( !io.IsNull() ) {
-             Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);
-             if ( !aSh.IsNull() )
-               res = (bool)aSh->isTopLevel();
-           }
-         }
-       }
-      }
-    }
-  }
-  return res;
-}
+// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE\r
+//\r
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,\r
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS\r
+//\r
+// This library is free software; you can redistribute it and/or\r
+// modify it under the terms of the GNU Lesser General Public\r
+// License as published by the Free Software Foundation; either\r
+// version 2.1 of the License.\r
+//\r
+// This library is distributed in the hope that it will be useful,\r
+// but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
+// Lesser General Public License for more details.\r
+//\r
+// You should have received a copy of the GNU Lesser General Public\r
+// License along with this library; if not, write to the Free Software\r
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA\r
+//\r
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com\r
+//\r
+\r
+// File   : GEOMGUI_Selection.cxx\r
+// Author : Alexander SOLOVYOV, Open CASCADE S.A.S. (alexander.solovyov@opencascade.com)\r
+//\r
+#include "GEOMGUI_Selection.h"\r
+\r
+#include "GeometryGUI.h"\r
+#include "GEOM_Displayer.h"\r
+\r
+#include "Material_Model.h"\r
+\r
+#include <GEOM_Constants.h>\r
+\r
+#include <SalomeApp_Application.h>\r
+#include <SalomeApp_Study.h>\r
+\r
+#include "LightApp_DataOwner.h"\r
+\r
+#include <SUIT_Session.h>\r
+#include <SUIT_Desktop.h>\r
+#include <SUIT_ViewWindow.h>\r
+#include <SUIT_ViewManager.h>\r
+\r
+#include <SALOME_Prs.h>\r
+#include <SALOME_InteractiveObject.hxx>\r
+\r
+#include <SOCC_Prs.h>\r
+#include <SVTK_Prs.h>\r
+#include <SALOME_Actor.h>\r
+#include <GEOM_Actor.h>\r
+\r
+#include <OCCViewer_ViewModel.h>\r
+#include <SVTK_ViewModel.h>\r
+\r
+#include <GEOMImpl_Types.hxx>\r
+\r
+#include <GEOM_AISShape.hxx>\r
+#include <GEOM_VTKPropertyMaterial.hxx>\r
+\r
+// OCCT Includes\r
+#include <AIS.hxx>\r
+#include <AIS_InteractiveObject.hxx>\r
+#include <AIS_ListOfInteractive.hxx>\r
+#include <AIS_GraphicTool.hxx>\r
+#include <AIS_Drawer.hxx>\r
+#include <Prs3d_ShadingAspect.hxx>\r
+#include<Graphic3d_MaterialAspect.hxx>\r
+\r
+// VTK Includes\r
+#include <vtkActorCollection.h>\r
+\r
+#define OCC_DISPLAY_MODE_TO_STRING( str, dm ) { \\r
+    if ( dm == AIS_WireFrame ) \\r
+      str = QString( "Wireframe" ); \\r
+    else if ( dm == AIS_Shaded )    \\r
+      str = QString( "Shading" ); \\r
+    else if ( dm == GEOM_AISShape::ShadingWithEdges )    \\r
+      str = QString( "ShadingWithEdges" ); \\r
+    else if ( dm == GEOM_AISShape::TexturedShape )    \\r
+      str = QString( "Texture" ); \\r
+    else \\r
+      str = QString(); }\r
+\r
+#define VTK_DISPLAY_MODE_TO_STRING( str, dm ) { \\r
+    if ( dm == 0 ) \\r
+      str = QString( "Wireframe" ); \\r
+    else if ( dm == 1 )    \\r
+      str = QString( "Shading" ); \\r
+    else if ( dm == 3 )    \\r
+      str = QString( "ShadingWithEdges" ); \\r
+    else \\r
+      str = QString(); }\r
+\r
+#define USE_VISUAL_PROP_MAP\r
+\r
+GEOMGUI_Selection::GEOMGUI_Selection()\r
+: LightApp_Selection()\r
+{\r
+}\r
+\r
+GEOMGUI_Selection::~GEOMGUI_Selection()\r
+{\r
+}\r
+\r
+void GEOMGUI_Selection::init( const QString& context, LightApp_SelectionMgr* selMgr )\r
+{\r
+  LightApp_Selection::init( context, selMgr );\r
+\r
+  myObjects.resize( count() );\r
+\r
+  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );\r
+  if ( appStudy ) {\r
+    _PTR(Study) study = appStudy->studyDS();\r
+    for ( int idx = 0; idx < count(); idx++ ) {\r
+      QString anEntry = entry( idx );\r
+      if ( study && !anEntry.isEmpty() ) {\r
+       _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );\r
+       if ( aSO ) {\r
+         CORBA::Object_var varObj = GeometryGUI::ClientSObjectToObject( aSO );\r
+         myObjects[idx] = GEOM::GEOM_Object::_narrow( varObj );\r
+       }\r
+      }\r
+    }\r
+  }\r
+}\r
+\r
+//QVariant GEOMGUI_Selection::contextParameter( const QString& p ) const\r
+QVariant GEOMGUI_Selection::parameter( const QString& p ) const\r
+{\r
+  QVariant v;\r
+  if ( p == "isOCC" )\r
+    v = activeViewType() == OCCViewer_Viewer::Type();\r
+  else if ( p == "selectionmode" )\r
+    v = selectionMode();\r
+  else if ( p == "hasImported" )\r
+    v = hasImported();\r
+  else if ( p == "allImported" )\r
+    v = allImported();\r
+  else\r
+    v = LightApp_Selection::parameter( p );\r
+  return v;\r
+}\r
+\r
+//QVariant GEOMGUI_Selection::objectParameter( const int idx, const QString& p ) const\r
+QVariant GEOMGUI_Selection::parameter( const int idx, const QString& p ) const\r
+{\r
+  QVariant v;\r
+  if ( p == "type" )\r
+    v = typeName( idx );\r
+  else if ( p == "typeid" )\r
+    v = typeId( idx );\r
+  else if ( p == "displaymode" )\r
+    v = displayMode( idx );\r
+  else if ( p == "isAutoColor" )\r
+    v = isAutoColor( idx );\r
+  else if ( p == "isVectorsMode" )\r
+    v = isVectorsMode( idx );\r
+  else if ( p == "topLevel" )\r
+    v = topLevel( idx );\r
+  else if ( p == "hasHiddenChildren" )\r
+    v = hasHiddenChildren( idx );\r
+  else if ( p == "hasShownChildren" )\r
+    v = hasShownChildren( idx );\r
+  else if ( p == "compoundOfVertices" )\r
+    v = compoundOfVertices( idx );\r
+  else if ( p == "imported" )\r
+    v = isImported( idx );\r
+  else if ( p == "isPhysicalMaterial" )\r
+    v = isPhysicalMaterial(idx);\r
+  else\r
+    v = LightApp_Selection::parameter( idx, p );\r
+\r
+  return v;\r
+}\r
+\r
+// the method to skip temporary objects from selection (called from LightApp)\r
+bool GEOMGUI_Selection::processOwner( const LightApp_DataOwner* theOwner )\r
+{\r
+  return !theOwner->entry().contains("_");\r
+}\r
+\r
+QString GEOMGUI_Selection::typeName( const int index ) const\r
+{\r
+  if ( isComponent( index ) )\r
+    return "Component";\r
+\r
+  static QString aGroup( "Group" );\r
+  static QString aShape( "Shape" );\r
+  static QString anUnknown( "Unknown" );\r
+\r
+  GEOM::GEOM_Object_var anObj = getObject( index );\r
+  if ( !CORBA::is_nil( anObj ) ) {\r
+    const int aGeomType = anObj->GetType();\r
+    if ( aGeomType == GEOM_GROUP )\r
+      return aGroup;\r
+    else\r
+      return aShape;\r
+  }\r
+  return anUnknown;\r
+}\r
+\r
+int GEOMGUI_Selection::typeId( const int index ) const\r
+{\r
+  int aType = -1;\r
+  GEOM::GEOM_Object_var anObj = getObject( index );\r
+  if ( !CORBA::is_nil( anObj ) )\r
+    aType = (int)anObj->GetShapeType();\r
+  return aType;\r
+}\r
+\r
+bool GEOMGUI_Selection::isVisible( const int index ) const\r
+{\r
+  bool res = false;\r
+\r
+#ifdef USE_VISUAL_PROP_MAP\r
+  bool found = false;\r
+  QVariant v = visibleProperty( entry( index ), VISIBILITY_PROP );\r
+  if ( v.canConvert( QVariant::Bool ) ) {\r
+    res = v.toBool();\r
+    found = true;\r
+  }\r
+\r
+  if ( !found ) {\r
+#endif\r
+    GEOM::GEOM_Object_var obj = getObject( index );\r
+    SALOME_View* view = GEOM_Displayer::GetActiveView();\r
+    if ( !CORBA::is_nil( obj ) && view ) {\r
+      Handle(SALOME_InteractiveObject) io = new SALOME_InteractiveObject( entry( index ).toLatin1().constData(), "GEOM", "TEMP_IO" );\r
+      res = view->isVisible( io );\r
+    }\r
+#ifdef USE_VISUAL_PROP_MAP\r
+  }\r
+#endif\r
+\r
+  return res;\r
+}\r
+\r
+bool GEOMGUI_Selection::isAutoColor( const int index ) const\r
+{\r
+  GEOM::GEOM_Object_var obj = getObject( index );\r
+  if ( !CORBA::is_nil( obj ) )\r
+    return obj->GetAutoColor();\r
+  return false;\r
+}\r
+\r
+bool GEOMGUI_Selection::isImported( const int index ) const\r
+{\r
+  GEOM::GEOM_Object_var obj = getObject( index );\r
+  if ( !CORBA::is_nil( obj ) )\r
+    return obj->GetType() == GEOM_IMPORT;\r
+  return false;\r
+}\r
+\r
+bool GEOMGUI_Selection::hasImported() const\r
+{\r
+  bool res = false;\r
+  for ( int i = 0; i < count() && !res; i++ )\r
+    res = isImported( i );\r
+  return res;\r
+}\r
+\r
+bool GEOMGUI_Selection::allImported() const\r
+{\r
+  bool res = true;\r
+  for ( int i = 0; i < count() && res; i++ )\r
+    res = isImported( i );\r
+  return res;\r
+}\r
+\r
+QVariant GEOMGUI_Selection::visibleProperty( const QString& entry, const QString& propName ) const\r
+{\r
+  QVariant v;\r
+  LightApp_Study* aStudy = study();\r
+  if ( aStudy ) {\r
+    LightApp_Application* anApp = ::qobject_cast<LightApp_Application*>( aStudy->application() );\r
+    if ( anApp && anApp->activeViewManager() ) {\r
+      int id = anApp->activeViewManager()->getGlobalId();\r
+      v = aStudy->getObjectProperty( id, entry, propName, QVariant() );\r
+    }\r
+  }\r
+  return v;\r
+}\r
+\r
+QString GEOMGUI_Selection::displayMode( const int index ) const\r
+{\r
+  QString res;\r
+  QString viewType = activeViewType();\r
+#ifdef USE_VISUAL_PROP_MAP\r
+  QVariant v = visibleProperty( entry( index ), DISPLAY_MODE_PROP );\r
+  if ( v.canConvert( QVariant::Int ) ) {\r
+    int dm = v.toInt();\r
+    if ( viewType == OCCViewer_Viewer::Type() ) {\r
+      OCC_DISPLAY_MODE_TO_STRING( res, dm );\r
+    } else if ( viewType == SVTK_Viewer::Type() ) {\r
+      VTK_DISPLAY_MODE_TO_STRING( res, dm );\r
+    }\r
+  }\r
+\r
+  if ( res.isEmpty() ) {\r
+#endif\r
+    SALOME_View* view = GEOM_Displayer::GetActiveView();\r
+    if ( view /*fix for 9320==>*/&& ( viewType == OCCViewer_Viewer::Type() || viewType == SVTK_Viewer::Type() ) ) {\r
+      SALOME_Prs* prs = view->CreatePrs( entry( index ).toLatin1().constData() );\r
+      if ( prs ) {\r
+       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC\r
+         SOCC_Prs* occPrs = (SOCC_Prs*) prs;\r
+         AIS_ListOfInteractive lst;\r
+         occPrs->GetObjects( lst );\r
+         if ( lst.Extent() ) {\r
+           Handle(AIS_InteractiveObject) io = lst.First();\r
+           if ( !io.IsNull() ) {\r
+             int dm = io->DisplayMode();\r
+             OCC_DISPLAY_MODE_TO_STRING( res, dm );\r
+             if ( res.isEmpty() ) { // return default display mode of AIS_InteractiveContext\r
+               OCCViewer_Viewer* occViewer = (OCCViewer_Viewer*)SUIT_Session::session()->activeApplication()->\r
+                 desktop()->activeWindow()->getViewManager()->getViewModel();\r
+               Handle(AIS_InteractiveContext) ic = occViewer->getAISContext();\r
+               dm = ic->DisplayMode();\r
+               OCC_DISPLAY_MODE_TO_STRING( res, dm );\r
+             }\r
+           }\r
+         }\r
+       }\r
+  else if ( viewType == SVTK_Viewer::Type() ) { // assuming VTK\r
+         SVTK_Prs* vtkPrs = dynamic_cast<SVTK_Prs*>( prs );\r
+         vtkActorCollection* lst = vtkPrs ? vtkPrs->GetObjects() : 0;\r
+         if ( lst ) {\r
+           lst->InitTraversal();\r
+           vtkActor* actor = lst->GetNextActor();\r
+           if ( actor ) {\r
+             SALOME_Actor* salActor = dynamic_cast<SALOME_Actor*>( actor );\r
+             if ( salActor ) {\r
+               int dm = salActor->getDisplayMode();\r
+               VTK_DISPLAY_MODE_TO_STRING( res, dm );\r
+             } // if ( salome actor )\r
+           } // if ( actor )\r
+         } // if ( lst == vtkPrs->GetObjects() )\r
+       } // if VTK\r
+      }\r
+    }\r
+\r
+#ifdef USE_VISUAL_PROP_MAP\r
+  }\r
+#endif\r
+\r
+  return res;\r
+}\r
+\r
+bool GEOMGUI_Selection::isVectorsMode( const int index ) const\r
+{\r
+  bool res = false;\r
+\r
+#ifdef USE_VISUAL_PROP_MAP\r
+  bool found = false;\r
+  QVariant v = visibleProperty( entry( index ), VECTOR_MODE_PROP );\r
+  if ( v.canConvert( QVariant::Bool ) ) {\r
+    res = v.toBool();\r
+    found = true;\r
+  }\r
+\r
+  if ( !found ) {\r
+#endif\r
+    SALOME_View* view = GEOM_Displayer::GetActiveView();\r
+    QString viewType = activeViewType();\r
+    if ( view && ( viewType == OCCViewer_Viewer::Type() || viewType == SVTK_Viewer::Type() ) ) {\r
+      SALOME_Prs* prs = view->CreatePrs( entry( index ).toLatin1().constData() );\r
+      if ( prs ) {\r
+       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC\r
+         SOCC_Prs* occPrs = (SOCC_Prs*) prs;\r
+         AIS_ListOfInteractive lst;\r
+         occPrs->GetObjects( lst );\r
+         if ( lst.Extent() ) {\r
+           Handle(AIS_InteractiveObject) io = lst.First();\r
+           if ( !io.IsNull() ) {\r
+             Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);\r
+             if ( !aSh.IsNull() )\r
+               res = aSh->isShowVectors();\r
+           }\r
+         }\r
+       } else if ( viewType == SVTK_Viewer::Type() ) { // assuming VTK\r
+         SVTK_Prs* vtkPrs = dynamic_cast<SVTK_Prs*>( prs );\r
+         vtkActorCollection* lst = vtkPrs ? vtkPrs->GetObjects() : 0;\r
+         if ( lst ) {\r
+           lst->InitTraversal();\r
+           vtkActor* actor = lst->GetNextActor();\r
+           if ( actor ) {\r
+             GEOM_Actor* aGeomActor = GEOM_Actor::SafeDownCast(actor);\r
+             if ( aGeomActor )\r
+               res = aGeomActor->GetVectorMode();\r
+           }\r
+         }\r
+       }\r
+      }\r
+    }\r
+#ifdef USE_VISUAL_PROP_MAP\r
+  }\r
+#endif\r
+\r
+  return res;\r
+}\r
+\r
+bool GEOMGUI_Selection::hasChildren( const _PTR(SObject)& obj )\r
+{\r
+  bool ok = false;\r
+  if ( obj ) {\r
+    _PTR(ChildIterator) it ( obj->GetStudy()->NewChildIterator( obj ) );\r
+    for ( ; it->More() && !ok; it->Next() ) {\r
+      _PTR(SObject) child = it->Value();\r
+      if ( child ) {\r
+        _PTR(SObject) refObj;\r
+        if ( child->ReferencedObject( refObj ) ) continue; // omit references\r
+        if ( child->GetName() != "" ) ok = true;\r
+      }\r
+    }\r
+  }\r
+  return ok;\r
+}\r
+\r
+bool GEOMGUI_Selection::expandable( const _PTR(SObject)& obj )\r
+{\r
+  bool exp = true;\r
+  _PTR(GenericAttribute) anAttr;\r
+  if ( obj && obj->FindAttribute( anAttr, "AttributeExpandable" ) ) {\r
+    _PTR(AttributeExpandable) aAttrExp = anAttr;\r
+    exp = aAttrExp->IsExpandable();\r
+  }\r
+  return exp;\r
+}\r
+\r
+bool GEOMGUI_Selection::isCompoundOfVertices( GEOM::GEOM_Object_ptr obj )\r
+{\r
+  bool ret = false;\r
+  /*\r
+  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>\r
+  (SUIT_Session::session()->activeApplication()->activeStudy());*/\r
+  if ( /*appStudy && */!CORBA::is_nil( obj ) )\r
+    ret = obj->GetShapeType() == GEOM::COMPOUND && obj->GetMaxShapeType() == GEOM::VERTEX;\r
+  return ret;\r
+}\r
+\r
+bool GEOMGUI_Selection::hasHiddenChildren( const int index ) const\r
+{\r
+  bool OK = false;\r
+  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );\r
+\r
+  if ( appStudy ) {\r
+    QString anEntry = entry( index );\r
+    _PTR(Study) study = appStudy->studyDS();\r
+    if ( study && !anEntry.isEmpty() ) {\r
+      _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );\r
+      OK = !expandable( aSO ) && hasChildren( aSO );\r
+    }\r
+  }\r
+  return OK;\r
+}\r
+\r
+bool GEOMGUI_Selection::hasShownChildren( const int index ) const\r
+{\r
+  bool OK = false;\r
+  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );\r
+\r
+  if ( appStudy )  {\r
+    QString anEntry = entry( index );\r
+    _PTR(Study) study = appStudy->studyDS();\r
+    if ( study && !anEntry.isEmpty() ) {\r
+      _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );\r
+      OK = expandable( aSO ) && hasChildren( aSO );\r
+    }\r
+  }\r
+  return OK;\r
+}\r
+\r
+bool GEOMGUI_Selection::compoundOfVertices( const int index ) const\r
+{\r
+  GEOM::GEOM_Object_var obj = getObject( index );\r
+  return isCompoundOfVertices( obj );\r
+}\r
+\r
+bool GEOMGUI_Selection::isComponent( const int index ) const\r
+{\r
+  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );\r
+\r
+  if ( appStudy ) {\r
+    QString anEntry = entry( index );\r
+    _PTR(Study) study = appStudy->studyDS();\r
+    if ( study && !anEntry.isNull() ) {\r
+      _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );\r
+      if ( aSO && aSO->GetFatherComponent() )\r
+        return aSO->GetFatherComponent()->GetIOR() == aSO->GetIOR();\r
+    }\r
+  }\r
+  return false;\r
+}\r
+\r
+GEOM::GEOM_Object_ptr GEOMGUI_Selection::getObject( const int index ) const\r
+{\r
+  GEOM::GEOM_Object_var o;\r
+  if ( 0 <= index && index < myObjects.size() )\r
+    o = GEOM::GEOM_Object::_duplicate( myObjects[index] );\r
+  return o._retn();\r
+}\r
+\r
+QString GEOMGUI_Selection::selectionMode() const\r
+{\r
+  SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( study()->application() );\r
+  if ( app ) {\r
+    GeometryGUI* aGeomGUI = dynamic_cast<GeometryGUI*>( app->module( "Geometry" ) );\r
+    if ( aGeomGUI ) {\r
+      switch ( aGeomGUI->getLocalSelectionMode() )\r
+      {\r
+        case GEOM_POINT      : return "VERTEX";\r
+        case GEOM_EDGE       : return "EDGE";\r
+        case GEOM_WIRE       : return "WIRE";\r
+        case GEOM_FACE       : return "FACE";\r
+        case GEOM_SHELL      : return "SHELL";\r
+        case GEOM_SOLID      : return "SOLID";\r
+        case GEOM_COMPOUND   : return "COMPOUND";\r
+        case GEOM_ALLOBJECTS : return "ALL";\r
+        default: return "";\r
+      }\r
+    }\r
+  }\r
+  return "";\r
+}\r
+\r
+bool GEOMGUI_Selection::topLevel( const int index ) const {\r
+  bool res = false;\r
+  \r
+#ifdef USE_VISUAL_PROP_MAP\r
+  bool found = false;\r
+  QVariant v = visibleProperty( entry( index ), TOP_LEVEL_PROP );\r
+  if ( v.canConvert<bool>() ) {\r
+    res = v.toBool();\r
+    found = true;\r
+  }\r
+\r
+  if ( !found ) {\r
+#endif\r
+    SALOME_View* view = GEOM_Displayer::GetActiveView();\r
+    QString viewType = activeViewType();\r
+    if ( view && viewType == OCCViewer_Viewer::Type() ) {\r
+      SALOME_Prs* prs = view->CreatePrs( entry( index ).toLatin1().constData() );\r
+      if ( prs ) {\r
+       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC\r
+         SOCC_Prs* occPrs = (SOCC_Prs*) prs;\r
+         AIS_ListOfInteractive lst;\r
+         occPrs->GetObjects( lst );\r
+         if ( lst.Extent() ) {\r
+           Handle(AIS_InteractiveObject) io = lst.First();\r
+           if ( !io.IsNull() ) {\r
+             Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);\r
+             if ( !aSh.IsNull() )\r
+               res = (bool)aSh->isTopLevel();\r
+           }\r
+         }\r
+       }\r
+      }\r
+    }\r
+  }\r
+  return res;\r
+}\r
+\r
+bool GEOMGUI_Selection::isPhysicalMaterial( const int idx ) const{\r
+   bool res = false;\r
+\r
+#ifdef USE_VISUAL_PROP_MAP\r
+   bool found = false;\r
+   QVariant v = visibleProperty( entry( idx ), MATERIAL_PROP );\r
+   if ( v.canConvert<QString>() ) {\r
+     Material_Model* aModel = Material_Model::getMaterialModel( v.toString().split(DIGIT_SEPARATOR) );\r
+     res = aModel->isPhysical();\r
+     found = true;\r
+   }\r
+\r
+   if ( !found ) {\r
+#endif\r
+     SALOME_View* view = GEOM_Displayer::GetActiveView();\r
+     QString viewType = activeViewType();\r
+     if ( view ) {\r
+       SALOME_Prs* prs = view->CreatePrs( entry( idx ).toLatin1().constData() );\r
+       if ( prs ) {\r
+         if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC\r
+           SOCC_Prs* occPrs = (SOCC_Prs*) prs;\r
+           AIS_ListOfInteractive lst;\r
+           occPrs->GetObjects( lst );\r
+           if ( lst.Extent() ) {\r
+             Handle(AIS_InteractiveObject) io = lst.First();\r
+             if ( !io.IsNull() ) {\r
+               Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);\r
+               if ( !aSh.IsNull() ) \r
+                 res =(bool) aSh->Attributes()->ShadingAspect()->\r
+                      Material(Aspect_TypeOfFacingModel::Aspect_TOFM_BOTH_SIDE).MaterialType( Graphic3d_MATERIAL_PHYSIC );\r
+             }\r
+           }\r
+         }\r
+         else if ( viewType == SVTK_Viewer::Type() ) { // assuming VTK\r
+               SVTK_Prs* vtkPrs = dynamic_cast<SVTK_Prs*>( prs );\r
+               vtkActorCollection* lst = vtkPrs ? vtkPrs->GetObjects() : 0;\r
+               if ( lst ) {\r
+                 lst->InitTraversal();\r
+                 vtkActor* actor = lst->GetNextActor();\r
+                 if ( actor ) {\r
+              GEOM_Actor* aGeomGActor = GEOM_Actor::SafeDownCast( actor );\r
+                   if ( aGeomGActor ) {\r
+                GEOM_VTKPropertyMaterial* mat  = GEOM_VTKPropertyMaterial::SafeDownCast(aGeomGActor->GetProperty());\r
+                res = mat->GetPhysical();\r
+                   } // if ( salome actor )\r
+                 } // if ( actor )\r
+          } // if ( lst == vtkPrs->GetObjects() )\r
+         }\r
+       }\r
+     }\r
+   }\r
+   return res;\r
+}
\ No newline at end of file
index ed9ed7182a4d0411f86c06187c37f8a51258637f..79220d6494438ec51ddc62fe549d4d01626fe1ac 100644 (file)
@@ -70,6 +70,7 @@ private:
   bool                  hasShownChildren( const int ) const;
   bool                  compoundOfVertices( const int ) const;
   bool                  topLevel( const int ) const;
+  bool                  isPhysicalMaterial( const int ) const;
 
   bool                  isComponent( const int ) const;
   GEOM::GEOM_Object_ptr getObject( const int ) const;
index ea0fbcade5092797f0a7eee8352b3e447d006986..281404e9744babd9c3b6ab9848e2e69158b1a8b2 100644 (file)
@@ -41,6 +41,7 @@
 #include <GEOM_AISVector.hxx>
 #include <GEOM_AISTrihedron.hxx>
 #include <GEOM_VTKTrihedron.hxx>
+#include <GEOM_VTKPropertyMaterial.hxx>
 
 #include <Material_Model.h>
 
@@ -809,7 +810,7 @@ void GEOM_Displayer::Update( SALOME_OCCPrs* prs )
             anAspect = AISShape->Attributes()->UnFreeBoundaryAspect();
             anAspect->SetColor( aColor );
             AISShape->Attributes()->SetUnFreeBoundaryAspect( anAspect );
-           AISShape->storeBoundaryColors();
+            AISShape->storeBoundaryColors();
 
             // Set free boundaries aspect
             col = aResMgr->colorValue( "Geometry", "free_bound_color", QColor( 0, 255, 0 ) );
@@ -827,10 +828,10 @@ void GEOM_Displayer::Update( SALOME_OCCPrs* prs )
             anAspect->SetColor( aColor );
             AISShape->Attributes()->SetWireAspect( anAspect );
 
-           // Set color for edges in shading
-           col = aResMgr->colorValue( "Geometry", "edges_in_shading_color", QColor( 255, 255, 0 ) );
-           aColor = SalomeApp_Tools::color( col );
-           AISShape->SetEdgesInShadingColor( aColor );
+            // Set color for edges in shading
+            col = aResMgr->colorValue( "Geometry", "edges_in_shading_color", QColor( 255, 255, 0 ) );
+            aColor = SalomeApp_Tools::color( col );
+            AISShape->SetEdgesInShadingColor( aColor );
            
             // bug [SALOME platform 0019868]
             // Set deviation angle. Default one is 12 degrees (Prs3d_Drawer.cxx:18)
@@ -840,8 +841,8 @@ void GEOM_Displayer::Update( SALOME_OCCPrs* prs )
             double aDC = 0;
             if(useStudy) {
               aDC = aPropMap.value(DEFLECTION_COEFF_PROP).toDouble();
-             SetWidth(aPropMap.value(EDGE_WIDTH_PROP).toInt());
-             SetIsosWidth(aPropMap.value(ISOS_WIDTH_PROP).toInt());
+              SetWidth(aPropMap.value(EDGE_WIDTH_PROP).toInt());
+              SetIsosWidth(aPropMap.value(ISOS_WIDTH_PROP).toInt());
             }
             else {
               aDC = aResMgr->doubleValue("Geometry", "deflection_coeff", 0.001);
@@ -960,62 +961,30 @@ void GEOM_Displayer::Update( SALOME_OCCPrs* prs )
 
           // get material properties, set material
           Material_Model* aModelF = 0;
-          Material_Model* aModelB = 0;
           if ( useStudy ) {
-            // Get front material property from study and construct front material model
-            QString aMaterialF = aPropMap.value(FRONT_MATERIAL_PROP).toString();
+            // Get material property from study and construct material model
+            QString aMaterialF = aPropMap.value(MATERIAL_PROP).toString();
             QStringList aProps =  aMaterialF.split(DIGIT_SEPARATOR);
             aModelF = Material_Model::getMaterialModel( aProps );
-
-            // Get back material property from study and construct back material model
-            QString aMaterialB = aPropMap.value(BACK_MATERIAL_PROP).toString();
-            if ( !aMaterialB.isEmpty() ) {
-              QStringList aPropsB =  aMaterialB.split(DIGIT_SEPARATOR);
-              aModelB = Material_Model::getMaterialModel( aPropsB );
-            }
-            else
-              aModelB = aModelF;
-
           } else {
-            // Get front material property from study and construct front material model
+            // Get material property from study and construct material model
             aModelF = new Material_Model();
-            aModelF->fromResources( aResMgr, "Geometry", true );
-
-            // Get back material property from study and construct back material model
-            aModelB = new Material_Model();
-            aModelB->fromResources( aResMgr, "Geometry", false );         
+            aModelF->fromResources( aResMgr, "Geometry" );
           }
 
-          // Set front material property
+          // Set material property
           QString aMaterialPropF = aModelF->getMaterialProperty();
-          aStudy->setObjectProperty( aMgrId, anIO->getEntry(), FRONT_MATERIAL_PROP, aMaterialPropF );
+          aStudy->setObjectProperty( aMgrId, anIO->getEntry(), MATERIAL_PROP, aMaterialPropF );
 
-          // Set back material property
-          QString aMaterialPropB = aModelB->getMaterialProperty();
-          aStudy->setObjectProperty( aMgrId, anIO->getEntry(), BACK_MATERIAL_PROP, aMaterialPropB );
-
-          // Get front material properties from the model
+          // Get material properties from the model
           Graphic3d_MaterialAspect aMatF = aModelF->getMaterialOCCAspect();
 
-          // Get back material properties from the model
-          Graphic3d_MaterialAspect aMatB = aModelB->getMaterialOCCAspect();
-
-          // Set front material for the selected shape
-          AISShape->SetCurrentFacingModel(Aspect_TOFM_FRONT_SIDE);
-          AISShape->SetMaterial(aMatF); 
-
-          // Set back material for the selected shape
-          AISShape->SetCurrentFacingModel(Aspect_TOFM_BACK_SIDE);
-          AISShape->SetMaterial(aMatB);
-
-          // Return to the default facing mode
-          AISShape->SetCurrentFacingModel(Aspect_TOFM_BOTH_SIDE);
+          // Set material for the selected shape
+           AISShape->SetMaterial(aMatF);
 
           // Release memory
           if ( aModelF )
             delete aModelF;
-          if ( aModelB )
-            delete aModelB;
 
          if(HasWidth())
            aStudy->setObjectProperty( aMgrId, anIO->getEntry(), EDGE_WIDTH_PROP, GetWidth() );
@@ -1204,52 +1173,21 @@ void GEOM_Displayer::Update( SALOME_VTKPrs* prs )
           aGeomGActor->setDisplayMode(aDispModeId);
           aGeomGActor->SetDeflection(aPropMap.value(DEFLECTION_COEFF_PROP).toDouble());
 
-         // Get front material property of the object stored in the study
-         QString aMaterialF = aPropMap.value(FRONT_MATERIAL_PROP).toString();
+         // Get material property of the object stored in the study
+         QString aMaterialF = aPropMap.value(MATERIAL_PROP).toString();
          QStringList aPropsF =  aMaterialF.split(DIGIT_SEPARATOR);
-         // Create front material model
+         // Create material model
          Material_Model* aModelF = Material_Model::getMaterialModel( aPropsF );          
-         // Set front material properties for the object
+         // Set material properties for the object
          QString aMaterialPropF = aModelF->getMaterialProperty();
-         aStudy->setObjectProperty( aMgrId, anEntry, FRONT_MATERIAL_PROP, aMaterialPropF );      
-         // Get material properties from the front model
-         vtkProperty* aMatPropF = aModelF->getMaterialVTKProperty();
+         aStudy->setObjectProperty( aMgrId, anEntry, MATERIAL_PROP, aMaterialPropF );    
+         // Get material properties from the model
+         GEOM_VTKPropertyMaterial* aMatPropF = aModelF->getMaterialVTKProperty();
+         // Set the same front and back materials for the selected shape
+    std::vector<vtkProperty*> aProps;
+    aProps.push_back( (vtkProperty*) aMatPropF );
+         aGeomGActor->SetMaterial(aProps);
          
-         // Get back material property of the object stored in the study
-         QString aMaterialB = aPropMap.value(BACK_MATERIAL_PROP).toString();
-         if ( !aMaterialB.isEmpty() ) {
-           QStringList aPropsB =  aMaterialB.split(DIGIT_SEPARATOR);       
-           // Create back material model
-           Material_Model* aModelB = Material_Model::getMaterialModel( aPropsB );
-           // Set back material properties for the object
-           QString aMaterialPropB = aModelB->getMaterialProperty();
-           aStudy->setObjectProperty( aMgrId, anEntry, BACK_MATERIAL_PROP, aMaterialPropB );
-           // Get material properties from the back model
-           vtkProperty* aMatPropB = aModelB->getMaterialVTKProperty();
-
-           // Set front and back materials for the selected shape
-           std::vector<vtkProperty*> aProps;
-           aProps.push_back(aMatPropF);
-           aProps.push_back(aMatPropB);
-           aGeomGActor->SetMaterial(aProps);
-
-           // Release memory
-           delete aModelB;
-
-           if(HasWidth())
-             aStudy->setObjectProperty( aMgrId, anEntry, EDGE_WIDTH_PROP, GetWidth() );
-
-           if(HasIsosWidth())
-             aStudy->setObjectProperty( aMgrId, anEntry, ISOS_WIDTH_PROP, GetIsosWidth() );
-         
-         }
-         else {
-           // Set the same front and back materials for the selected shape
-           std::vector<vtkProperty*> aProps;
-           aProps.push_back(aMatPropF);
-           aGeomGActor->SetMaterial(aProps);
-         }
-
          // Release memory
          delete aModelF;
 
@@ -1283,37 +1221,26 @@ void GEOM_Displayer::Update( SALOME_VTKPrs* prs )
               }
             }
           }
-          aGeomGActor->SetColor(aColor[0],aColor[1],aColor[2]);
+          if ( !aMatPropF->GetPhysical() )
+            aGeomGActor->SetColor(aColor[0],aColor[1],aColor[2]);
         }
        else {
          SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
          if ( aResMgr ) {
-           // Create front material model
+           // Create material model
            Material_Model aModelF;
-           // Get front material name from resources
-           aModelF.fromResources( aResMgr, "Geometry", true );
-           // Set front material properties for the object
+           // Get material name from resources
+           aModelF.fromResources( aResMgr, "Geometry" );
+           // Set material properties for the object
            QString aMaterialPropF = aModelF.getMaterialProperty();
-           aStudy->setObjectProperty( aMgrId, anEntry, FRONT_MATERIAL_PROP, aMaterialPropF );      
-           // Get material properties from the front model
-           vtkProperty* aMatPropF = aModelF.getMaterialVTKProperty();
-
-           // Create back material model
-           Material_Model aModelB;
-           // Get back material name from resources
-           aModelB.fromResources( aResMgr, "Geometry", false );
-           // Set back material properties for the object
-           QString aMaterialPropB = aModelB.getMaterialProperty();
-           aStudy->setObjectProperty( aMgrId, anEntry, BACK_MATERIAL_PROP, aMaterialPropB );
-           // Get material properties from the back model
-           vtkProperty* aMatPropB = aModelB.getMaterialVTKProperty();
+           aStudy->setObjectProperty( aMgrId, anEntry, MATERIAL_PROP, aMaterialPropF );            
+           // Get material properties from the model
+           GEOM_VTKPropertyMaterial* aMatPropF = aModelF.getMaterialVTKProperty();
 
            // Set material for the selected shape
-           std::vector<vtkProperty*> aProps;
-           aProps.push_back(aMatPropF);
-           aProps.push_back(aMatPropB);
-           aGeomGActor->SetMaterial(aProps);
-         }
+      std::vector<vtkProperty*> aProps;
+      aProps.push_back( (vtkProperty*) aMatPropF );
+           aGeomGActor->SetMaterial(aProps);     }
        }
       }
 
@@ -2009,23 +1936,16 @@ PropMap GEOM_Displayer::getDefaultPropertyMap(const QString& viewer_type) {
   aDefaultMap.insert( DEFLECTION_COEFF_PROP , aDC);
 
   //8. Material
-  //   Front material
   Material_Model aModelF;
-  aModelF.fromResources( aResMgr, "Geometry", true );
+  aModelF.fromResources( aResMgr, "Geometry" );
   QString aMaterialF = aModelF.getMaterialProperty();
-  aDefaultMap.insert( FRONT_MATERIAL_PROP , aMaterialF );  
+  aDefaultMap.insert( MATERIAL_PROP , aMaterialF );  
 
-  //9.  Back material
-  Material_Model aModelB;
-  aModelB.fromResources( aResMgr, "Geometry", false );
-  QString aMaterialB = aModelB.getMaterialProperty();
-  aDefaultMap.insert( BACK_MATERIAL_PROP , aMaterialB );
-
-  //10. Width of the edges
+  //9. Width of the edges
   aDefaultMap.insert( EDGE_WIDTH_PROP , aResMgr->integerValue("Geometry", "edge_width", 1));
 
 
-  //11. Width of iso-lines
+  //10. Width of iso-lines
   aDefaultMap.insert( ISOS_WIDTH_PROP , aResMgr->integerValue("Geometry", "isolines_width", 1));
 
   if(viewer_type == SOCC_Viewer::Type()) {
@@ -2062,12 +1982,8 @@ bool GEOM_Displayer::MergePropertyMaps(PropMap& theOrigin, PropMap& theDefault)
     theOrigin.insert(DEFLECTION_COEFF_PROP, theDefault.value(DEFLECTION_COEFF_PROP));
     nbInserted++;
   }
-  if(!theOrigin.contains(FRONT_MATERIAL_PROP)) {
-    theOrigin.insert(FRONT_MATERIAL_PROP, theDefault.value(FRONT_MATERIAL_PROP));
-    nbInserted++;
-  }
-  if(!theOrigin.contains(BACK_MATERIAL_PROP)) {
-    theOrigin.insert(BACK_MATERIAL_PROP, theDefault.value(BACK_MATERIAL_PROP));
+  if(!theOrigin.contains(MATERIAL_PROP)) {
+    theOrigin.insert(MATERIAL_PROP, theDefault.value(MATERIAL_PROP));
     nbInserted++;
   }
 
@@ -2081,6 +1997,11 @@ bool GEOM_Displayer::MergePropertyMaps(PropMap& theOrigin, PropMap& theDefault)
     nbInserted++;
   }
 
+  if(!theOrigin.contains(COLOR_PROP)) {
+    theOrigin.insert(COLOR_PROP, theDefault.value(COLOR_PROP));
+    nbInserted++;
+  }
+
   return (nbInserted > 0);
 }
 
index b43229a40dda5262a714968129772bd53d648f2c..51660252e9324b611164825d976fd6bb7265f930 100644 (file)
@@ -3015,12 +3015,8 @@ Please, select face, shell or solid and try again</translation>
         <translation>Default wireframe color</translation>
     </message>
     <message>
-        <source>PREF_FRONT_MATERIAL</source>
-        <translation>Default front material</translation>
-    </message>
-    <message>
-        <source>PREF_BACK_MATERIAL</source>
-        <translation>Default back material</translation>
+        <source>PREF_MATERIAL</source>
+        <translation>Default material</translation>
     </message>
     <message>
         <source>PREF_EDGE_WIDTH</source>
@@ -5274,6 +5270,10 @@ Would you like to continue?</translation>
         <source>SHININESS</source>
         <translation>Shininess:</translation>
     </message>
+    <message>
+        <source>PHYSICAL</source>
+        <translation>Physical:</translation>
+    </message>
     <message>
         <source>CUSTOM_MATERIAL</source>
         <translation>Custom material</translation>
index 983f5ab230a9043ce22e3d732f430ad78b82c6be..54309e6bce1edf526acb542f0dc801e6d19e4322 100644 (file)
@@ -5274,6 +5274,10 @@ Voulez-vous continuer?</translation>
         <source>SHININESS</source>
         <translation>Shininess:</translation>
     </message>
+    <message>
+        <source>PHYSICAL</source>
+        <translation>Physical:</translation>
+    </message>
     <message>
         <source>CUSTOM_MATERIAL</source>
         <translation>Matériau personnalisé</translation>
index b9fa4579775046ba18a6c74489c4b56ef41f6b56..6fc3eeb06db5fdd8be8dd5fb78552ea86f0f32c1 100644 (file)
@@ -591,10 +591,7 @@ void GeometryGUI::OnGUIEvent( int id )
       if ( pref ) {
        Material_ResourceMgr aMatResMgr;
        QStringList aPerfMatNames = aMatResMgr.getPreferenceMaterialsNames();
-       setPreferenceProperty( pref->rootItem()->findItem( tr( "PREF_FRONT_MATERIAL" ), true )->id(),
-                              "strings",
-                              aPerfMatNames );
-       setPreferenceProperty( pref->rootItem()->findItem( tr( "PREF_BACK_MATERIAL" ), true )->id(),
+       setPreferenceProperty( pref->rootItem()->findItem( tr( "PREF_MATERIAL" ), true )->id(),
                               "strings",
                               aPerfMatNames );
       }
@@ -1250,7 +1247,7 @@ void GeometryGUI::initialize( CAM_Application* app )
   mgr->setRule( action( GEOMOp::OpVectors ), clientOCCorVTK + " and isVectorsMode", QtxPopupMgr::ToggleRule );
   mgr->insert( separator(), -1, -1 );     // -----------
   mgr->insert( action(  GEOMOp::OpColor ), -1, -1 ); // color
-  mgr->setRule( action( GEOMOp::OpColor ), clientOCCorVTKorOB_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
+  mgr->setRule( action( GEOMOp::OpColor ), clientOCCorVTKorOB_AndSomeVisible + " and ($component={'GEOM'})" + "and isPhysicalMaterial=false", QtxPopupMgr::VisibleRule );
   mgr->insert( action(  GEOMOp::OpTransparency ), -1, -1 ); // transparency
   mgr->setRule( action( GEOMOp::OpTransparency ), clientOCCorVTK_AndSomeVisible, QtxPopupMgr::VisibleRule );
   mgr->insert( action(  GEOMOp::OpIsos ), -1, -1 ); // isos
@@ -1719,14 +1716,10 @@ void GeometryGUI::createPreferences()
   int defl = addPreference( tr( "PREF_DEFLECTION" ), genGroup,
                             LightApp_Preferences::DblSpin, "Geometry", "deflection_coeff" );
 
-  int front_material = addPreference( tr( "PREF_FRONT_MATERIAL" ), genGroup,
+  int material = addPreference( tr( "PREF_MATERIAL" ), genGroup,
                                      LightApp_Preferences::Selector,
-                                     "Geometry", "front_material" );
+                                     "Geometry", "material" );
   
-  int back_material = addPreference( tr( "PREF_BACK_MATERIAL" ), genGroup,
-                                    LightApp_Preferences::Selector,
-                                    "Geometry", "back_material" );
-
   const int nb = 4;
   int wd[nb];
   int iter=0;
@@ -1816,8 +1809,7 @@ void GeometryGUI::createPreferences()
   // Set property for default material
   Material_ResourceMgr aMatResMgr;
   QStringList aPrefMatNames = aMatResMgr.getPreferenceMaterialsNames();
-  setPreferenceProperty( front_material, "strings", aPrefMatNames );
-  setPreferenceProperty( back_material, "strings", aPrefMatNames );
+  setPreferenceProperty( material, "strings", aPrefMatNames );
 
   // Set property vertex marker type
   QList<QVariant> aMarkerTypeIndicesList;
@@ -2014,17 +2006,11 @@ void GeometryGUI::storeVisualParameters (int savePoint)
           ip->setParameter(entry, param, aProps.value(MARKER_TYPE_PROP).toString().toLatin1().data());
         }
 
-       if(aProps.contains(FRONT_MATERIAL_PROP)) {
-          param = occParam + FRONT_MATERIAL_PROP;
-          ip->setParameter(entry, param, aProps.value(FRONT_MATERIAL_PROP).toString().toLatin1().data());
+       if(aProps.contains(MATERIAL_PROP)) {
+          param = occParam + MATERIAL_PROP;
+          ip->setParameter(entry, param, aProps.value(MATERIAL_PROP).toString().toLatin1().data());
         }
 
-       if(aProps.contains(BACK_MATERIAL_PROP)) {
-          param = occParam + BACK_MATERIAL_PROP;
-          ip->setParameter(entry, param, aProps.value(BACK_MATERIAL_PROP).toString().toLatin1().data());
-         
-       }
-
        if(aProps.contains( EDGE_WIDTH_PROP )) {
              param = occParam + EDGE_WIDTH_PROP;
            ip->setParameter(entry, param, aProps.value(EDGE_WIDTH_PROP).toString().toLatin1().data());                              
@@ -2144,10 +2130,8 @@ void GeometryGUI::restoreVisualParameters (int savePoint)
         aListOfMap[viewIndex].insert( DEFLECTION_COEFF_PROP, val.toDouble());
       }  else if(paramNameStr == MARKER_TYPE_PROP) {
         aListOfMap[viewIndex].insert( MARKER_TYPE_PROP, val);
-      } else if(paramNameStr == FRONT_MATERIAL_PROP) {
-        aListOfMap[viewIndex].insert( FRONT_MATERIAL_PROP, val);
-      } else if(paramNameStr == BACK_MATERIAL_PROP) {
-        aListOfMap[viewIndex].insert( BACK_MATERIAL_PROP, val);
+      } else if(paramNameStr == MATERIAL_PROP) {
+        aListOfMap[viewIndex].insert( MATERIAL_PROP, val);
       }  else if(paramNameStr == EDGE_WIDTH_PROP) {
        aListOfMap[viewIndex].insert( EDGE_WIDTH_PROP , val);
       }  else if(paramNameStr == ISOS_WIDTH_PROP) {