X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FOBJECT%2FSMESH_Actor.cxx;h=1463f03fe5d96aebeeddd5550a01377c3a6db7cb;hb=f3d031f77dd6db87a66d6180da045fe7890ff78c;hp=b768fd2f52ecac8547a343a950e5f0887380305a;hpb=3334ebae06a359554b9489701e8753679cf76bc2;p=modules%2Fsmesh.git

diff --git a/src/OBJECT/SMESH_Actor.cxx b/src/OBJECT/SMESH_Actor.cxx
index b768fd2f5..1463f03fe 100644
--- a/src/OBJECT/SMESH_Actor.cxx
+++ b/src/OBJECT/SMESH_Actor.cxx
@@ -1,42 +1,53 @@
-//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2012  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
+// 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 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.
+// 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
+// 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
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 //  SMESH OBJECT : interactive object for SMESH visualization
 //  File   : SMESH_Actor.cxx
 //  Author : Nicolas REJNERI
 //  Module : SMESH
-
-
+//
 #include "SMESH_ActorDef.h"
 #include "SMESH_ActorUtils.h"
 #include "SMESH_DeviceActor.h"
+#include "SMESH_NodeLabelActor.h"
+#include "SMESH_CellLabelActor.h"
 #include "SMESH_ObjectDef.h"
 #include "SMESH_ControlsDef.hxx"
+#include "SMDS_UnstructuredGrid.hxx"
+#include "SMESH_ScalarBarActor.h"
 #include "VTKViewer_ExtractUnstructuredGrid.h"
 #include "VTKViewer_FramedTextActor.h"
 #include "SALOME_InteractiveObject.hxx"
+#include "SMESH_SVTKActor.h"
 
 #include "SUIT_Session.h"
 #include "SUIT_ResourceMgr.h"
 
+#include <Qtx.h>
+
+#ifndef DISABLE_PLOT2DVIEWER
+#include <SPlot2d_Histogram.h>
+#endif
+
 #include <vtkProperty.h>
 #include <vtkTimeStamp.h>
 #include <vtkObjectFactory.h>
@@ -58,13 +69,8 @@
 #include <vtkActor2D.h>
 #include <vtkProperty2D.h>
 #include <vtkPolyData.h>
-#include <vtkMaskPoints.h>
-#include <vtkCellCenters.h>
 #include <vtkTextProperty.h>
-#include <vtkLabeledDataMapper.h>
-#include <vtkSelectVisiblePoints.h>
 
-#include <vtkScalarBarActor.h>
 #include <vtkLookupTable.h>
 
 #include <vtkMath.h>
@@ -82,11 +88,10 @@
 #ifdef _DEBUG_
 static int MYDEBUG = 1;
 #else
-static int MYDEBUG = 0;
+static int MYDEBUG = 1;
 #endif
 
 static int aLineWidthInc = 2;
-static int aPointSizeInc = 2;
 
 
 SMESH_ActorDef* SMESH_ActorDef::New(){
@@ -99,24 +104,35 @@ SMESH_Actor* SMESH_Actor::New(TVisualObjPtr theVisualObj,
                               const char* theName,
                               int theIsClear)
 {
-  SMESH_ActorDef* anActor = SMESH_ActorDef::New();
-  if(!anActor->Init(theVisualObj,theEntry,theName,theIsClear)){
-    anActor->Delete();
-    anActor = NULL;
+  SMESH_ActorDef* anActor = NULL;
+  if(theVisualObj->IsValid() ) {
+    anActor = SMESH_ActorDef::New();
+    if(!anActor->Init(theVisualObj,theEntry,theName,theIsClear)){
+      anActor->Delete();
+      anActor = NULL;
+    }
+    if( anActor )
+      anActor->UpdateScalarBar();
   }
-  if( anActor )
-    anActor->UpdateScalarBar();
   return anActor;
 }
 
 
 SMESH_ActorDef::SMESH_ActorDef()
 {
-  if(MYDEBUG) MESSAGE("SMESH_ActorDef - "<<this);
+  if(MYDEBUG) MESSAGE("SMESH_ActorDef - "<<this);  
+  myBaseActor = SMESH_DeviceActor::New();
 
   myTimeStamp = vtkTimeStamp::New();
 
   myIsPointsVisible = false;
+  myIsEntityModeCache = false;
+
+  myHighlightActor = SMESH_SVTKActor::New();
+  myHighlightActor->Initialize();
+
+  myPreHighlightActor = SMESH_SVTKActor::New();
+  myPreHighlightActor->Initialize();
 
   myIsShrinkable = false;
   myIsShrunk = false;
@@ -129,9 +145,10 @@ SMESH_ActorDef::SMESH_ActorDef()
   if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
     myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);
 
-  vtkFloatingPointType aPointSize  = SMESH::GetFloat("SMESH:node_size",3);
-  vtkFloatingPointType aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
-  vtkFloatingPointType aLineWidth  = SMESH::GetFloat("SMESH:element_width",1);
+  vtkFloatingPointType aElem0DSize   = SMESH::GetFloat("SMESH:elem0d_size",5);
+  vtkFloatingPointType aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
+  vtkFloatingPointType aLineWidth    = SMESH::GetFloat("SMESH:element_width",1);
+  vtkFloatingPointType aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
 
   vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
   VTKViewer_ExtractUnstructuredGrid* aFilter = NULL;
@@ -140,14 +157,27 @@ SMESH_ActorDef::SMESH_ActorDef()
   //-----------------------------------------
   vtkFloatingPointType anRGB[3] = {1,1,1};
   mySurfaceProp = vtkProperty::New();
-  SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
-  mySurfaceProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );
+  QColor ffc, bfc;
+  int delta;
+  SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "0,170,255|-100" ) ;
+  mySurfaceProp->SetColor( ffc.red() / 255. , ffc.green() / 255. , ffc.blue() / 255. );
+  myDeltaBrightness = delta;
 
   myBackSurfaceProp = vtkProperty::New();
-  SMESH::GetColor( "SMESH", "backface_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 0, 255 ) );
-  myBackSurfaceProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );
+  bfc = Qtx::mainColorToSecondary(ffc, delta);
+  myBackSurfaceProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );
+
+  myNormalVProp = vtkProperty::New();
+  SMESH::GetColor( "SMESH", "volume_color", ffc, delta, "255,0,170|-100" );
+  myNormalVProp->SetColor( ffc.redF(), ffc.greenF(), ffc.blueF() );
+  myDeltaVBrightness = delta;
+
+  myReversedVProp = vtkProperty::New();
+  bfc = Qtx::mainColorToSecondary(ffc, delta);
+  myReversedVProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );
 
-  my2DActor = SMESH_DeviceActor::New();
+  my2DActor = SMESH_CellLabelActor::New();
+  my2DActor->SetStoreGemetryMapping(true);
   my2DActor->SetUserMatrix(aMatrix);
   my2DActor->PickableOff();
   my2DActor->SetProperty(mySurfaceProp);
@@ -160,6 +190,7 @@ SMESH_ActorDef::SMESH_ActorDef()
   aFilter->RegisterCellsWithType(VTK_QUAD);
   aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
   aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+  aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
 
   my2DExtProp = vtkProperty::New();
   my2DExtProp->DeepCopy(mySurfaceProp);
@@ -181,13 +212,16 @@ SMESH_ActorDef::SMESH_ActorDef()
   aFilter->RegisterCellsWithType(VTK_QUAD);
   aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
   aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+  aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
 
-  my3DActor = SMESH_DeviceActor::New();
+  my3DActor = SMESH_CellLabelActor::New();
+  my3DActor->SetStoreGemetryMapping(true);
   my3DActor->SetUserMatrix(aMatrix);
   my3DActor->PickableOff();
-  my3DActor->SetProperty(mySurfaceProp);
-  my3DActor->SetBackfaceProperty(myBackSurfaceProp);
+  my3DActor->SetProperty(myNormalVProp);
+  my3DActor->SetBackfaceProperty(myReversedVProp);
   my3DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
+  my3DActor->SetCoincident3DAllowed(true);
   aFilter = my3DActor->GetExtractUnstructuredGrid();
   aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
   aFilter->RegisterCellsWithType(VTK_TETRA);
@@ -195,10 +229,48 @@ SMESH_ActorDef::SMESH_ActorDef()
   aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
   aFilter->RegisterCellsWithType(VTK_WEDGE);
   aFilter->RegisterCellsWithType(VTK_PYRAMID);
+  aFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
+  aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
+  aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
+  aFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
+  aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
+  aFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID);
+  aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
+//#ifdef VTK_HAVE_POLYHEDRON
+  MESSAGE("RegisterCellsWithType(VTK_POLYHEDRON)");
+  aFilter->RegisterCellsWithType(VTK_POLYHEDRON);
+//#endif
+
+  my3DExtProp = vtkProperty::New();
+  my3DExtProp->DeepCopy(myNormalVProp);
+  SMESH::GetColor( "SMESH", "volume_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 0, 170 ) );
+  anRGB[0] = 1 - anRGB[0];
+  anRGB[1] = 1 - anRGB[1];
+  anRGB[2] = 1 - anRGB[2];
+  my3DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
+
+  my3DExtActor = SMESH_DeviceActor::New();
+  my3DExtActor->SetUserMatrix(aMatrix);
+  my3DExtActor->PickableOff();
+  my3DExtActor->SetProperty(my3DExtProp);
+  my3DExtActor->SetBackfaceProperty(my3DExtProp);
+  my3DExtActor->SetRepresentation(SMESH_DeviceActor::eSurface);
+  my3DExtActor->SetCoincident3DAllowed(true);
+  aFilter = my3DExtActor->GetExtractUnstructuredGrid();
+  aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
+  aFilter->RegisterCellsWithType(VTK_TETRA);
+  aFilter->RegisterCellsWithType(VTK_VOXEL);
+  aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
+  aFilter->RegisterCellsWithType(VTK_WEDGE);
+  aFilter->RegisterCellsWithType(VTK_PYRAMID);
+  aFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
   aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
   aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
+  aFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
   aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
+  aFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID);
   aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
+  aFilter->RegisterCellsWithType(VTK_POLYHEDRON);
 
   //Definition 1D device of the actor
   //---------------------------------
@@ -206,11 +278,12 @@ SMESH_ActorDef::SMESH_ActorDef()
   myEdgeProp->SetAmbient(1.0);
   myEdgeProp->SetDiffuse(0.0);
   myEdgeProp->SetSpecular(0.0);
-  SMESH::GetColor( "SMESH", "outline_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
+  SMESH::GetColor( "SMESH", "wireframe_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
   myEdgeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
   myEdgeProp->SetLineWidth(aLineWidth);
 
-  my1DActor = SMESH_DeviceActor::New();
+  my1DActor = SMESH_CellLabelActor::New();
+  my1DActor->SetStoreGemetryMapping(true);
   my1DActor->SetUserMatrix(aMatrix);
   my1DActor->PickableOff();
   my1DActor->SetHighlited(true);
@@ -224,7 +297,7 @@ SMESH_ActorDef::SMESH_ActorDef()
   my1DProp = vtkProperty::New();
   my1DProp->DeepCopy(myEdgeProp);
   my1DProp->SetLineWidth(aLineWidth + aLineWidthInc);
-  my1DProp->SetPointSize(aPointSize);
+  my1DProp->SetPointSize(aElem0DSize);
   
   my1DExtProp = vtkProperty::New();
   my1DExtProp->DeepCopy(myEdgeProp);
@@ -233,7 +306,7 @@ SMESH_ActorDef::SMESH_ActorDef()
   anRGB[2] = 1 - anRGB[2];
   my1DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
   my1DExtProp->SetLineWidth(aLineWidth + aLineWidthInc);
-  my1DExtProp->SetPointSize(aPointSize + aPointSizeInc);
+  my1DExtProp->SetPointSize(aElem0DSize);
 
   my1DExtActor = SMESH_DeviceActor::New();
   my1DExtActor->SetUserMatrix(aMatrix);
@@ -255,9 +328,9 @@ SMESH_ActorDef::SMESH_ActorDef()
   my0DProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
   my0DProp->SetPointSize(aElem0DSize);
 
-  my0DActor = SMESH_DeviceActor::New();
+  my0DActor = SMESH_CellLabelActor::New();
   my0DActor->SetUserMatrix(aMatrix);
-  my0DActor->SetStoreClippingMapping(true);
+  my0DActor->SetStoreGemetryMapping(true);
   my0DActor->PickableOff();
   my0DActor->SetVisibility(false);
   my0DActor->SetProperty(my0DProp);
@@ -267,6 +340,24 @@ SMESH_ActorDef::SMESH_ActorDef()
   aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
   aFilter->RegisterCellsWithType(VTK_VERTEX);
   
+  //Definition 0D device of the actor (ball elements)
+  //-----------------------------------------------
+  myBallProp = vtkProperty::New();
+  SMESH::GetColor( "SMESH", "ball_elem_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 85, 255 ) );
+  myBallProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
+  myBallProp->SetPointSize(aBallElemSize);
+
+  myBallActor = SMESH_CellLabelActor::New();
+  myBallActor->SetUserMatrix(aMatrix);
+  myBallActor->SetStoreGemetryMapping(true);
+  myBallActor->PickableOff();
+  myBallActor->SetVisibility(false);
+  myBallActor->SetProperty(myBallProp);
+  myBallActor->SetRepresentation(SMESH_DeviceActor::eSurface);
+  aFilter = myBallActor->GetExtractUnstructuredGrid();
+  aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
+  aFilter->RegisterCellsWithType(VTK_POLY_VERTEX);
+  
   //my0DExtProp = vtkProperty::New();
   //my0DExtProp->DeepCopy(my0DProp);
   //anRGB[0] = 1 - anRGB[0];
@@ -294,9 +385,8 @@ SMESH_ActorDef::SMESH_ActorDef()
   myNodeProp = vtkProperty::New();
   SMESH::GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 0, 0 ) );
   myNodeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
-  myNodeProp->SetPointSize(aPointSize);
 
-  myNodeActor = SMESH_DeviceActor::New();
+  myNodeActor = SMESH_NodeLabelActor::New();
   myNodeActor->SetUserMatrix(aMatrix);
   myNodeActor->SetStoreClippingMapping(true);
   myNodeActor->PickableOff();
@@ -312,7 +402,6 @@ SMESH_ActorDef::SMESH_ActorDef()
   anRGB[1] = 1 - anRGB[1];
   anRGB[2] = 1 - anRGB[2];
   myNodeExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
-  myNodeExtProp->SetPointSize(aPointSize);
 
   myNodeExtActor = SMESH_DeviceActor::New();
   myNodeExtActor->SetUserMatrix(aMatrix);
@@ -329,37 +418,54 @@ SMESH_ActorDef::SMESH_ActorDef()
   //Definition of Pickable and Highlitable engines
   //----------------------------------------------
 
-  myBaseActor = SMESH_DeviceActor::New();
   myBaseActor->SetUserMatrix(aMatrix);
   myBaseActor->SetStoreGemetryMapping(true);
   myBaseActor->GetProperty()->SetOpacity(0.0);
-
   myPickableActor = myBaseActor;
-
+  
   myHighlightProp = vtkProperty::New();
   myHighlightProp->SetAmbient(1.0);
   myHighlightProp->SetDiffuse(0.0);
   myHighlightProp->SetSpecular(0.0);
   SMESH::GetColor( "SMESH", "selection_object_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) );
   myHighlightProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
-  //myHighlightProp->SetPointSize(aPointSize);
-  myHighlightProp->SetPointSize(std::max(aElem0DSize,aPointSize)); // ??
+  myHighlightProp->SetPointSize(aElem0DSize); // ??
+  myHighlightProp->SetLineWidth(aLineWidth);
   myHighlightProp->SetRepresentation(1);
 
+  myBallHighlightProp = vtkProperty::New();
+  myBallHighlightProp->DeepCopy(myHighlightProp);
+  myBallHighlightProp->SetPointSize(aBallElemSize);
+  
+
+  myOutLineProp = vtkProperty::New();
+  myOutLineProp->SetAmbient(1.0);
+  myOutLineProp->SetDiffuse(0.0);
+  myOutLineProp->SetSpecular(0.0);
+  SMESH::GetColor( "SMESH", "outline_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 70, 0 ) );
+  myOutLineProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
+  myOutLineProp->SetLineWidth(aOutlineWidth);
+  myOutLineProp->SetRepresentation(1);
+
   myPreselectProp = vtkProperty::New();
   myPreselectProp->SetAmbient(1.0);
   myPreselectProp->SetDiffuse(0.0);
   myPreselectProp->SetSpecular(0.0);
   SMESH::GetColor( "SMESH", "highlight_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 255 ) );
   myPreselectProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
-  //myPreselectProp->SetPointSize(aPointSize);
-  myPreselectProp->SetPointSize(std::max(aElem0DSize,aPointSize)); // ??
+  myPreselectProp->SetPointSize(aElem0DSize); // ??
+  myPreselectProp->SetLineWidth(aLineWidth);
   myPreselectProp->SetRepresentation(1);
 
+  myBallPreselectProp = vtkProperty::New();
+  myBallPreselectProp->DeepCopy(myPreselectProp);
+  myBallPreselectProp->SetPointSize(aBallElemSize);
+
   myHighlitableActor = SMESH_DeviceActor::New();
   myHighlitableActor->SetUserMatrix(aMatrix);
   myHighlitableActor->PickableOff();
   myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
+  myHighlitableActor->SetCoincident3DAllowed(true);
 
   aMatrix->Delete();
 
@@ -376,7 +482,7 @@ SMESH_ActorDef::SMESH_ActorDef()
   //Controls - Aspect Ratio: incorrect colors of the best and worst values
   myLookupTable->SetHueRange(0.667,0.0);
 
-  myScalarBarActor = vtkScalarBarActor::New();
+  myScalarBarActor = SMESH_ScalarBarActor::New();
   myScalarBarActor->SetVisibility(false);
   myScalarBarActor->SetLookupTable(myLookupTable);
 
@@ -389,92 +495,13 @@ SMESH_ActorDef::SMESH_ActorDef()
   if( !mgr )
     return;
 
-  //Definition of points numbering pipeline
-  //---------------------------------------
-  myPointsNumDataSet = vtkUnstructuredGrid::New();
-
-  myPtsMaskPoints = vtkMaskPoints::New();
-  myPtsMaskPoints->SetInput(myPointsNumDataSet);
-  myPtsMaskPoints->SetOnRatio(1);
-
-  myPtsSelectVisiblePoints = vtkSelectVisiblePoints::New();
-  myPtsSelectVisiblePoints->SetInput(myPtsMaskPoints->GetOutput());
-  myPtsSelectVisiblePoints->SelectInvisibleOff();
-  myPtsSelectVisiblePoints->SetTolerance(0.1);
-    
-  myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
-  myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput());
-#if (VTK_XVERSION < 0x050200)
-  myPtsLabeledDataMapper->SetLabelFormat("%g");
-#endif
-  myPtsLabeledDataMapper->SetLabelModeToLabelScalars();
-    
-  vtkTextProperty* aPtsTextProp = vtkTextProperty::New();
-  aPtsTextProp->SetFontFamilyToTimes();
-  static int aPointsFontSize = 10;
-  aPtsTextProp->SetFontSize(aPointsFontSize);
-  aPtsTextProp->SetBold(1);
-  aPtsTextProp->SetItalic(0);
-  aPtsTextProp->SetShadow(0);
-  myPtsLabeledDataMapper->SetLabelTextProperty(aPtsTextProp);
-  aPtsTextProp->Delete();
-  
   myEntityMode = eAllEntity;
-
-  myIsPointsLabeled = false;
-
-  myPointLabels = vtkActor2D::New();
-  myPointLabels->SetMapper(myPtsLabeledDataMapper);
-  myPointLabels->GetProperty()->SetColor(1,1,1);
-  myPointLabels->SetVisibility(myIsPointsLabeled);
-
-
-  //Definition of cells numbering pipeline
-  //---------------------------------------
-  myCellsNumDataSet = vtkUnstructuredGrid::New();
-
-  myCellCenters = vtkCellCenters::New();
-  myCellCenters->SetInput(myCellsNumDataSet);
-
-  myClsMaskPoints = vtkMaskPoints::New();
-  myClsMaskPoints->SetInput(myCellCenters->GetOutput());
-  myClsMaskPoints->SetOnRatio(1);
-    
-  myClsSelectVisiblePoints = vtkSelectVisiblePoints::New();
-  myClsSelectVisiblePoints->SetInput(myClsMaskPoints->GetOutput());
-  myClsSelectVisiblePoints->SelectInvisibleOff();
-  myClsSelectVisiblePoints->SetTolerance(0.1);
-    
-  myClsLabeledDataMapper = vtkLabeledDataMapper::New();
-  myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput());
-#if (VTK_XVERSION < 0x050200)
-  myClsLabeledDataMapper->SetLabelFormat("%g");
-#endif
-  myClsLabeledDataMapper->SetLabelModeToLabelScalars();
-    
-  vtkTextProperty* aClsTextProp = vtkTextProperty::New();
-  aClsTextProp->SetFontFamilyToTimes();
-  static int aCellsFontSize = 12;
-  aClsTextProp->SetFontSize(aCellsFontSize);
-  aClsTextProp->SetBold(1);
-  aClsTextProp->SetItalic(0);
-  aClsTextProp->SetShadow(0);
-  myClsLabeledDataMapper->SetLabelTextProperty(aClsTextProp);
-  aClsTextProp->Delete();
-    
-  myIsCellsLabeled = false;
-
-  myCellsLabels = vtkActor2D::New();
-  myCellsLabels->SetMapper(myClsLabeledDataMapper);
-  myCellsLabels->GetProperty()->SetColor(0,1,0);
-  myCellsLabels->SetVisibility(myIsCellsLabeled);
-
+  myEntityModeCache = eAllEntity;
+  
   // Clipping planes
   myImplicitBoolean = vtkImplicitBoolean::New();
   myImplicitBoolean->SetOperationTypeToIntersection();
   
-
-
   //Quadratic 2D elements representation
   //-----------------------------------------------------------------------------
   int aQuadratic2DMode = mgr->integerValue( "SMESH", "quadratic_mode", 0);
@@ -493,9 +520,18 @@ SMESH_ActorDef::SMESH_ActorDef()
   myHighlitableActor->SetQuadraticArcAngle(aQuadraticAngle);
   my2DActor->SetQuadraticArcAngle(aQuadraticAngle);
   
-  // Set color of the name actor
-  SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
+  // Set colors of the name actor
+  SMESH::GetColor( "SMESH", "default_grp_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
   myNameActor->SetBackgroundColor(anRGB[0], anRGB[1], anRGB[2]);
+  SMESH::GetColor( "SMESH", "group_name_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) );
+  myNameActor->SetForegroundColor(anRGB[0], anRGB[1], anRGB[2]);
+
+#ifndef DISABLE_PLOT2DVIEWER
+  my2dHistogram = 0;
+#endif
+
+  SetBallSize(aBallElemSize);
+  Set0DSize(aElem0DSize);
 }
 
 
@@ -503,11 +539,21 @@ SMESH_ActorDef::~SMESH_ActorDef()
 {
   if(MYDEBUG) MESSAGE("~SMESH_ActorDef - "<<this);
 
+#ifndef DISABLE_PLOT2DVIEWER
+  if(my2dHistogram) {
+    SMESH::ProcessIn2DViewers(this,SMESH::RemoveFrom2dViewer);
+    delete my2dHistogram;
+  }
+#endif
+
   myScalarBarActor->Delete();
   myLookupTable->Delete();
 
   mySurfaceProp->Delete();
   myBackSurfaceProp->Delete();
+  myNormalVProp->Delete();
+  myReversedVProp->Delete();
+  myOutLineProp->Delete();
 
   myEdgeProp->Delete();
   myHighlightProp->Delete();
@@ -518,6 +564,7 @@ SMESH_ActorDef::~SMESH_ActorDef()
  
   my0DProp->Delete();
   my0DActor->Delete();
+  myBallActor->Delete();
 
   //my0DExtProp->Delete();
   //my0DExtActor->Delete();
@@ -532,117 +579,87 @@ SMESH_ActorDef::~SMESH_ActorDef()
   my2DExtProp->Delete();
   my2DExtActor->Delete();
   my3DActor->Delete();
+  my3DExtProp->Delete();
+  my3DExtActor->Delete();
 
   myNodeActor->Delete();
   myBaseActor->Delete();
 
-  myNodeExtActor->Delete();
-  
+  myNodeExtActor->Delete();  
   myHighlitableActor->Delete();
 
-  //Deleting of points numbering pipeline
-  //---------------------------------------
-  myPointsNumDataSet->Delete();
-
-  // commented: porting to vtk 5.0
-  //  myPtsLabeledDataMapper->RemoveAllInputs();
-  myPtsLabeledDataMapper->Delete();
-
-  // commented: porting to vtk 5.0
-  //  myPtsSelectVisiblePoints->UnRegisterAllOutputs();
-  myPtsSelectVisiblePoints->Delete();
+  myImplicitBoolean->Delete();
 
-  // commented: porting to vtk 5.0
-  //  myPtsMaskPoints->UnRegisterAllOutputs();
-  myPtsMaskPoints->Delete();
+  myTimeStamp->Delete();
+  myBallHighlightProp->Delete();
+  myBallPreselectProp->Delete();
+          
+}
 
-  myPointLabels->Delete();
+void SMESH_ActorDef::Delete()
+{
+  // This is just to guarantee that the DeleteActorEvent (which was previously invoked
+  // from the actor's destructor) will be thrown before removing the actor's observers,
+  // that is done inside the Superclass::Delete() method but before the destructor itself
+  // (see the issue 0021562: EDF SMESH: clipping and delete mesh clipped leads to crash).
+  // The event is caught by SMESHGUI::ProcessEvents() static method.
+  this->InvokeEvent( SMESH::DeleteActorEvent, NULL );
 
+  Superclass::Delete();
+}
 
-  //Deleting of cells numbering pipeline
-  //---------------------------------------
-  myCellsNumDataSet->Delete();
+void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled )
+{    
+  if(myNodeActor) {
+    myNodeActor->SetPointsLabeled(theIsPointsLabeled);
+    SetRepresentation(GetRepresentation());
+    myTimeStamp->Modified();
+  }
+}
 
-  myClsLabeledDataMapper->RemoveAllInputs();
-  myClsLabeledDataMapper->Delete();
+bool SMESH_ActorDef::GetPointsLabeled() {
+  return myNodeActor && myNodeActor->GetPointsLabeled();
+}
 
-  // commented: porting to vtk 5.0
-  //  myClsSelectVisiblePoints->UnRegisterAllOutputs();
-  myClsSelectVisiblePoints->Delete();
+void SMESH_ActorDef::SetCellsLabeled(bool theIsCellsLabeled)
+{
+  if(my3DActor)
+    my3DActor->SetCellsLabeled(theIsCellsLabeled);
 
-  // commented: porting to vtk 5.0
-  //  myClsMaskPoints->UnRegisterAllOutputs();
-  myClsMaskPoints->Delete();
+  if(my2DActor)
+    my2DActor->SetCellsLabeled(theIsCellsLabeled);
 
-  // commented: porting to vtk 5.0
-  //  myCellCenters->UnRegisterAllOutputs();
-  myCellCenters->Delete();
+  if(my1DActor)
+    my1DActor->SetCellsLabeled(theIsCellsLabeled);
 
-  myCellsLabels->Delete();
+  if(my0DActor)
+    my0DActor->SetCellsLabeled(theIsCellsLabeled);
+  
+  if(myBallActor)
+    myBallActor->SetCellsLabeled(theIsCellsLabeled);
+  
+  myTimeStamp->Modified();
+}
 
-  myImplicitBoolean->Delete();
 
-  myTimeStamp->Delete();
-}
+bool SMESH_ActorDef::GetCellsLabeled() {
+  bool result = false;
+  if(my3DActor)
+    result = result || my3DActor->GetCellsLabeled();
 
+  if(my2DActor)
+    result = result || my2DActor->GetCellsLabeled();
 
-void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled )
-{    
-  vtkUnstructuredGrid* aGrid = GetUnstructuredGrid();
-    
-  myIsPointsLabeled = theIsPointsLabeled && aGrid->GetNumberOfPoints();
+  if(my1DActor)
+    result = result || my1DActor->GetCellsLabeled();
 
-  if ( myIsPointsLabeled )
-  {
-    myPointsNumDataSet->ShallowCopy(aGrid);
-    vtkDataSet *aDataSet = myPointsNumDataSet;
-    
-    int aNbElem = aDataSet->GetNumberOfPoints();
-    
-    vtkIntArray *anArray = vtkIntArray::New();
-    anArray->SetNumberOfValues( aNbElem );
-    
-    for ( vtkIdType anId = 0; anId < aNbElem; anId++ )
-    {
-      int aSMDSId = myVisualObj->GetNodeObjId( anId );
-      anArray->SetValue( anId, aSMDSId );
-    }
-    
-    aDataSet->GetPointData()->SetScalars( anArray );
-    anArray->Delete();
-    myPtsMaskPoints->SetInput( aDataSet );
-    myPointLabels->SetVisibility( GetVisibility() );
-  }
-  else
-  {
-    myPointLabels->SetVisibility( false );
-  }
-  SetRepresentation(GetRepresentation());
-  myTimeStamp->Modified();
-}
+  if(my0DActor)
+    result = result || my0DActor->GetCellsLabeled();
 
+  if(myBallActor)
+    result = result || myBallActor->GetCellsLabeled();
 
-void SMESH_ActorDef::SetCellsLabeled(bool theIsCellsLabeled)
-{
-  vtkUnstructuredGrid* aGrid = GetUnstructuredGrid();
-  myIsCellsLabeled = theIsCellsLabeled && aGrid->GetNumberOfPoints();
-  if(myIsCellsLabeled){
-    myCellsNumDataSet->ShallowCopy(aGrid);
-    vtkDataSet *aDataSet = myCellsNumDataSet;
-    int aNbElem = aDataSet->GetNumberOfCells();
-    vtkIntArray *anArray = vtkIntArray::New();
-    anArray->SetNumberOfValues(aNbElem);
-    for(int anId = 0; anId < aNbElem; anId++){
-      int aSMDSId = myVisualObj->GetElemObjId(anId);
-      anArray->SetValue(anId,aSMDSId);
-    }
-    aDataSet->GetCellData()->SetScalars(anArray);
-    myCellCenters->SetInput(aDataSet);
-    myCellsLabels->SetVisibility(GetVisibility());
-  }else{
-    myCellsLabels->SetVisibility(false);
-  }
-  myTimeStamp->Modified();
+  return result;
 }
 
 
@@ -661,15 +678,15 @@ bool SMESH_ActorDef::GetFacesOriented()
   return myIsFacesOriented;
 }
 
-void SMESH_ActorDef::SetFacesOrientationColor(vtkFloatingPointType theColor[3])
+void SMESH_ActorDef::SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b)
 {
-  my2DActor->SetFacesOrientationColor( theColor );
-  my3DActor->SetFacesOrientationColor( theColor );
+  my2DActor->SetFacesOrientationColor( r, g, b );
+  my3DActor->SetFacesOrientationColor( r, g, b );
 }
 
-void SMESH_ActorDef::GetFacesOrientationColor(vtkFloatingPointType theColor[3])
+void SMESH_ActorDef::GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b)
 {
-  my3DActor->GetFacesOrientationColor( theColor );
+  my3DActor->GetFacesOrientationColor( r, g, b );
 }
 
 void SMESH_ActorDef::SetFacesOrientationScale(vtkFloatingPointType theScale)
@@ -719,56 +736,85 @@ SetControlMode(eControl theMode,
   my1DActor->GetMapper()->SetScalarVisibility(false);
   my2DActor->GetMapper()->SetScalarVisibility(false);
   my3DActor->GetMapper()->SetScalarVisibility(false);
+  myBallActor->GetMapper()->SetScalarVisibility(false);
   myScalarBarActor->SetVisibility(false);
 
   bool anIsScalarVisible = theMode > eNone;
 
-  if(anIsScalarVisible){
-    SMESH::Controls::FunctorPtr aFunctor;
-    switch(theMode){
+  if(anIsScalarVisible) {
+    switch(theMode) {
     case eLength:
     {
       SMESH::Controls::Length* aControl = new SMESH::Controls::Length();
       aControl->SetPrecision( myControlsPrecision );
-      aFunctor.reset( aControl );
+      myFunctor.reset( aControl );
       myControlActor = my1DActor;
       break;
     }
     case eLength2D:
     {
-      aFunctor.reset(new SMESH::Controls::Length2D());
+      myFunctor.reset(new SMESH::Controls::Length2D());
       myControlActor = my2DActor;
       break;
     }
     case eFreeBorders:
-      aFunctor.reset(new SMESH::Controls::FreeBorders());
+      myFunctor.reset(new SMESH::Controls::FreeBorders());
       myControlActor = my1DActor;
       break;
     case eFreeEdges:
-      aFunctor.reset(new SMESH::Controls::FreeEdges());
+      myFunctor.reset(new SMESH::Controls::FreeEdges());
       myControlActor = my2DActor;
       break;
     case eFreeNodes:
-      aFunctor.reset(new SMESH::Controls::FreeNodes());
+      myFunctor.reset(new SMESH::Controls::FreeNodes());
       myControlActor = myNodeActor;
       break;
     case eFreeFaces:
-      aFunctor.reset(new SMESH::Controls::FreeFaces());
+      myFunctor.reset(new SMESH::Controls::FreeFaces());
+      myControlActor = my2DActor;
+      break;
+    case eCoincidentNodes:
+      {
+        SMESH::Controls::CoincidentNodes* cn = new SMESH::Controls::CoincidentNodes();
+        double tol = mgr->doubleValue( "SMESH", "equal_nodes_tolerance", 1e-7 );
+        cn->SetTolerance( tol );
+        myFunctor.reset(cn);
+        myControlActor = myNodeActor;
+        break;
+      }
+    case eCoincidentElems1D:
+      myFunctor.reset(new SMESH::Controls::CoincidentElements1D());
+      myControlActor = my1DActor;
+      break;
+    case eCoincidentElems2D:
+      myFunctor.reset(new SMESH::Controls::CoincidentElements2D());
+      myControlActor = my2DActor;
+      break;
+    case eCoincidentElems3D:
+      myFunctor.reset(new SMESH::Controls::CoincidentElements3D());
+      myControlActor = my3DActor;
+      break;
+    case eBareBorderFace:
+      myFunctor.reset(new SMESH::Controls::BareBorderFace());
+      myControlActor = my2DActor;
+      break;
+    case eOverConstrainedFace:
+      myFunctor.reset(new SMESH::Controls::OverConstrainedFace());
       myControlActor = my2DActor;
       break;
     case eMultiConnection:
-      aFunctor.reset(new SMESH::Controls::MultiConnection());
+      myFunctor.reset(new SMESH::Controls::MultiConnection());
       myControlActor = my1DActor;
       break;
     case eMultiConnection2D:
-      aFunctor.reset(new SMESH::Controls::MultiConnection2D());
+      myFunctor.reset(new SMESH::Controls::MultiConnection2D());
       myControlActor = my2DActor;
       break;
     case eArea:
     {
       SMESH::Controls::Area* aControl = new SMESH::Controls::Area();
       aControl->SetPrecision( myControlsPrecision );
-      aFunctor.reset( aControl );
+      myFunctor.reset( aControl );
       myControlActor = my2DActor;
       break;
     }
@@ -776,7 +822,7 @@ SetControlMode(eControl theMode,
     {
       SMESH::Controls::Taper* aControl = new SMESH::Controls::Taper();
       aControl->SetPrecision( myControlsPrecision );
-      aFunctor.reset( aControl );
+      myFunctor.reset( aControl );
       myControlActor = my2DActor;
       break;
     }
@@ -784,7 +830,7 @@ SetControlMode(eControl theMode,
     {
       SMESH::Controls::AspectRatio* aControl = new SMESH::Controls::AspectRatio();
       aControl->SetPrecision( myControlsPrecision );
-      aFunctor.reset( aControl );
+      myFunctor.reset( aControl );
       myControlActor = my2DActor;
       break;
     }
@@ -792,7 +838,7 @@ SetControlMode(eControl theMode,
     {
       SMESH::Controls::AspectRatio3D* aControl = new SMESH::Controls::AspectRatio3D();
       aControl->SetPrecision( myControlsPrecision );
-      aFunctor.reset( aControl );
+      myFunctor.reset( aControl );
       myControlActor = my3DActor;
       break;
     }
@@ -800,7 +846,35 @@ SetControlMode(eControl theMode,
     {
       SMESH::Controls::Volume* aControl = new SMESH::Controls::Volume();
       aControl->SetPrecision( myControlsPrecision );
-      aFunctor.reset( aControl );
+      myFunctor.reset( aControl );
+      myControlActor = my3DActor;
+      break;
+    }
+    case eMaxElementLength2D:
+    {
+      SMESH::Controls::MaxElementLength2D* aControl = new SMESH::Controls::MaxElementLength2D();
+      aControl->SetPrecision( myControlsPrecision );
+      myFunctor.reset( aControl );
+      myControlActor = my2DActor;
+      break;
+    }
+    case eMaxElementLength3D:
+    {
+      SMESH::Controls::MaxElementLength3D* aControl = new SMESH::Controls::MaxElementLength3D();
+      aControl->SetPrecision( myControlsPrecision );
+      myFunctor.reset( aControl );
+      myControlActor = my3DActor;
+      break;
+    }
+    case eBareBorderVolume:
+    {
+      myFunctor.reset(new SMESH::Controls::BareBorderVolume());
+      myControlActor = my3DActor;
+      break;
+    }
+    case eOverConstrainedVolume:
+    {
+      myFunctor.reset(new SMESH::Controls::OverConstrainedVolume());
       myControlActor = my3DActor;
       break;
     }
@@ -808,7 +882,7 @@ SetControlMode(eControl theMode,
     {
       SMESH::Controls::MinimumAngle* aControl = new SMESH::Controls::MinimumAngle();
       aControl->SetPrecision( myControlsPrecision );
-      aFunctor.reset( aControl );
+      myFunctor.reset( aControl );
       myControlActor = my2DActor;
       break;
     }
@@ -816,7 +890,7 @@ SetControlMode(eControl theMode,
     {
       SMESH::Controls::Warping* aControl = new SMESH::Controls::Warping();
       aControl->SetPrecision( myControlsPrecision );
-      aFunctor.reset( aControl );
+      myFunctor.reset( aControl );
       myControlActor = my2DActor;
       break;
     }
@@ -824,7 +898,7 @@ SetControlMode(eControl theMode,
     {
       SMESH::Controls::Skew* aControl = new SMESH::Controls::Skew();
       aControl->SetPrecision( myControlsPrecision );
-      aFunctor.reset( aControl );
+      myFunctor.reset( aControl );
       myControlActor = my2DActor;
       break;
     }
@@ -838,106 +912,139 @@ SetControlMode(eControl theMode,
       myControlMode = theMode;
       switch(myControlMode){
       case eFreeNodes:
-        myNodeExtActor->SetExtControlMode(aFunctor);
+      case eCoincidentNodes:
+        myNodeExtActor->SetExtControlMode(myFunctor);
         break;
       case eFreeEdges:
       case eFreeBorders:
-        my1DExtActor->SetExtControlMode(aFunctor);
+      case eCoincidentElems1D:
+        my1DExtActor->SetExtControlMode(myFunctor);
         break;
       case eFreeFaces:
-        my2DExtActor->SetExtControlMode(aFunctor);
+      case eBareBorderFace:
+      case eOverConstrainedFace:
+      case eCoincidentElems2D:
+        my2DExtActor->SetExtControlMode(myFunctor);
+        break;
+      case eBareBorderVolume:
+      case eOverConstrainedVolume:
+      case eCoincidentElems3D:
+        my3DExtActor->SetExtControlMode(myFunctor);
         break;
       case eLength2D:
       case eMultiConnection2D:
-        my1DExtActor->SetExtControlMode(aFunctor,myScalarBarActor,myLookupTable);
+        my1DExtActor->SetExtControlMode(myFunctor,myScalarBarActor,myLookupTable);
+        UpdateDistribution();
         break;
       default:
-        myControlActor->SetControlMode(aFunctor,myScalarBarActor,myLookupTable);
+        myControlActor->SetControlMode(myFunctor,myScalarBarActor,myLookupTable);
+        UpdateDistribution();
       }
     }
 
-    if(theCheckEntityMode){
-      if(myControlActor == my1DActor)
+    if(theCheckEntityMode) {
+      if(myControlActor == my1DActor) {
+        if (!myIsEntityModeCache){
+          myEntityModeCache = GetEntityMode();
+          myIsEntityModeCache=true;
+        } 
         SetEntityMode(eEdges);
-      else if(myControlActor == my2DActor){
-        switch(myControlMode){
+      }
+      else if(myControlActor == my2DActor) {
+        switch(myControlMode) {
         case eLength2D:
         case eFreeEdges:
         case eFreeFaces:
         case eMultiConnection2D:
-          //SetEntityMode(eEdges);
+          if (!myIsEntityModeCache){
+            myEntityModeCache = GetEntityMode();
+            myIsEntityModeCache=true;
+          } 
           SetEntityMode(eFaces);
           break;
         default:
+          if (!myIsEntityModeCache){
+            myEntityModeCache = GetEntityMode();
+            myIsEntityModeCache=true;
+          }
           SetEntityMode(eFaces);
         }
-      }else if(myControlActor == my3DActor)
+      }else if(myControlActor == my3DActor) {
+        if (!myIsEntityModeCache){
+            myEntityModeCache = GetEntityMode();
+            myIsEntityModeCache=true;
+        } 
         SetEntityMode(eVolumes);
     }
+    }
 
-  }else if(theCheckEntityMode){
-    myEntityMode = eAllEntity;
+  }
+  else {
+    if(theCheckEntityMode){
+      myEntityMode = myEntityModeCache;
+      myIsEntityModeCache = false;
+    }
+    myFunctor.reset();
   }
 
   SetRepresentation(GetRepresentation());
 
   myTimeStamp->Modified();
   Modified();
+  Update();
 }
 
 
 void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){
-  SALOME_Actor::AddToRender(theRenderer);
-
-  theRenderer->AddActor(myNodeActor);
-  theRenderer->AddActor(myBaseActor);
   
-  theRenderer->AddActor(myNodeExtActor);
-
-  my3DActor->AddToRender(theRenderer);
-  my2DActor->AddToRender(theRenderer);
-  my2DExtActor->AddToRender(theRenderer);
+  //myHighlightActor->AddToRender(theRenderer);
 
-  theRenderer->AddActor(my1DActor);
+  theRenderer->AddActor(myBaseActor);  
+  theRenderer->AddActor(myNodeExtActor);
   theRenderer->AddActor(my1DExtActor);
 
-  theRenderer->AddActor(my0DActor);
+  my3DActor   ->AddToRender(theRenderer);
+  my3DExtActor->AddToRender(theRenderer);
+  my2DActor   ->AddToRender(theRenderer);
+  my2DExtActor->AddToRender(theRenderer);
+  myNodeActor ->AddToRender(theRenderer);
+  my1DActor   ->AddToRender(theRenderer);
+  my0DActor   ->AddToRender(theRenderer);
+  myBallActor ->AddToRender(theRenderer);
   //theRenderer->AddActor(my0DExtActor);
 
   theRenderer->AddActor(myHighlitableActor);
   
   theRenderer->AddActor2D(myScalarBarActor);
 
-  myPtsSelectVisiblePoints->SetRenderer(theRenderer);
-  myClsSelectVisiblePoints->SetRenderer(theRenderer);
-
-  theRenderer->AddActor2D(myPointLabels);
-  theRenderer->AddActor2D(myCellsLabels);
+  // the superclass' method should be called at the end
+  // (in particular, for correct work of selection)
+  SALOME_Actor::AddToRender(theRenderer);
 }
 
 void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){
   SALOME_Actor::RemoveFromRender(theRenderer);
 
-  theRenderer->RemoveActor(myNodeActor);
   theRenderer->RemoveActor(myBaseActor);
 
   theRenderer->RemoveActor(myNodeExtActor);
 
   theRenderer->RemoveActor(myHighlitableActor);
 
-  theRenderer->RemoveActor(my0DActor);
   //theRenderer->RemoveActor(my0DExtActor);
 
-  theRenderer->RemoveActor(my1DActor);
   theRenderer->RemoveActor(my1DExtActor);
 
   my2DActor->RemoveFromRender(theRenderer);
   my2DExtActor->RemoveFromRender(theRenderer);
   my3DActor->RemoveFromRender(theRenderer);
+  my3DExtActor->RemoveFromRender(theRenderer);
+  myNodeActor->RemoveFromRender(theRenderer);
+  my0DActor->RemoveFromRender(theRenderer);
+  myBallActor->RemoveFromRender(theRenderer);
+  my1DActor->RemoveFromRender(theRenderer);
 
   theRenderer->RemoveActor(myScalarBarActor);
-  theRenderer->RemoveActor(myPointLabels);
-  theRenderer->RemoveActor(myCellsLabels);
 }
 
 
@@ -961,6 +1068,7 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
   myNodeExtActor->Init(myVisualObj,myImplicitBoolean);
   
   my0DActor->Init(myVisualObj,myImplicitBoolean);
+  myBallActor->Init(myVisualObj,myImplicitBoolean);
   //my0DExtActor->Init(myVisualObj,myImplicitBoolean);
   
   my1DActor->Init(myVisualObj,myImplicitBoolean);
@@ -969,8 +1077,10 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
   my2DActor->Init(myVisualObj,myImplicitBoolean);
   my2DExtActor->Init(myVisualObj,myImplicitBoolean);
   my3DActor->Init(myVisualObj,myImplicitBoolean);
+  my3DExtActor->Init(myVisualObj,myImplicitBoolean);
   
   my0DActor->GetMapper()->SetLookupTable(myLookupTable);
+  myBallActor->GetMapper()->SetLookupTable(myLookupTable);
   //my0DExtActor->GetMapper()->SetLookupTable(myLookupTable);
   
   my1DActor->GetMapper()->SetLookupTable(myLookupTable);
@@ -979,11 +1089,13 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
   my2DActor->GetMapper()->SetLookupTable(myLookupTable);
   my2DExtActor->GetMapper()->SetLookupTable(myLookupTable);
   my3DActor->GetMapper()->SetLookupTable(myLookupTable);
+  my3DExtActor->GetMapper()->SetLookupTable(myLookupTable);
     
   vtkFloatingPointType aFactor, aUnits;
   my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
   my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
   my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5);
+  my3DActor->SetPolygonOffsetParameters(2*aFactor,aUnits);
 
   SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
   if( !mgr )
@@ -1012,6 +1124,10 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
   if( dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
     SetIsDisplayNameActor( true );
 
+  int aMarkerType = mgr->integerValue( "SMESH", "type_of_marker", 1 ); // dot
+  int aMarkerScale = mgr->integerValue( "SMESH", "marker_scale", 9 );  // 5 pixels
+  SetMarkerStd( (VTK::MarkerType)aMarkerType, (VTK::MarkerScale)aMarkerScale );
+
   myTimeStamp->Modified();
   Modified();
   return true;
@@ -1039,6 +1155,7 @@ void SMESH_ActorDef::SetTransform(VTKViewer_Transform* theTransform){
   myNodeExtActor->SetTransform(theTransform);
 
   my0DActor->SetTransform(theTransform);
+  myBallActor->SetTransform(theTransform);
   //my0DExtActor->SetTransform(theTransform);
 
   my1DActor->SetTransform(theTransform);
@@ -1047,6 +1164,7 @@ void SMESH_ActorDef::SetTransform(VTKViewer_Transform* theTransform){
   my2DActor->SetTransform(theTransform);
   my2DExtActor->SetTransform(theTransform);
   my3DActor->SetTransform(theTransform);
+  my3DExtActor->SetTransform(theTransform);
 
   Modified();
 }
@@ -1102,6 +1220,9 @@ void SMESH_ActorDef::SetShrinkFactor(vtkFloatingPointType theValue){
   my2DActor->SetShrinkFactor(theValue);
   my2DExtActor->SetShrinkFactor(theValue);
   my3DActor->SetShrinkFactor(theValue);
+  my3DExtActor->SetShrinkFactor(theValue);
+  my3DExtActor->SetShrinkFactor(theValue);
+  myHighlitableActor->SetShrinkFactor(theValue);
 
   Modified();
 }
@@ -1117,6 +1238,8 @@ void SMESH_ActorDef::SetShrink(){
   my2DActor->SetShrink();
   my2DExtActor->SetShrink();
   my3DActor->SetShrink();
+  my3DExtActor->SetShrink();
+  myHighlitableActor->SetShrink();
 
   myIsShrunk = true;
   Modified();
@@ -1133,6 +1256,8 @@ void SMESH_ActorDef::UnShrink(){
   my2DActor->UnShrink();
   my2DExtActor->UnShrink();
   my3DActor->UnShrink();
+  my3DExtActor->UnShrink();
+  myHighlitableActor->UnShrink();
 
   myIsShrunk = false;
   Modified();
@@ -1171,6 +1296,7 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){
   myNodeExtActor->VisibilityOff();
 
   my0DActor->VisibilityOff();
+  myBallActor->VisibilityOff();
   //my0DExtActor->VisibilityOff();
 
   my1DActor->VisibilityOff();
@@ -1179,10 +1305,9 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){
   my2DActor->VisibilityOff();
   my2DExtActor->VisibilityOff();
   my3DActor->VisibilityOff();
+  my3DExtActor->VisibilityOff();
   
   myScalarBarActor->VisibilityOff();
-  myPointLabels->VisibilityOff();
-  myCellsLabels->VisibilityOff();
   
   if(GetVisibility()){
     if(theIsUpdateRepersentation)
@@ -1191,15 +1316,25 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){
     if(myControlMode != eNone){
       switch(myControlMode){
       case eFreeNodes:
+      case eCoincidentNodes:
         myNodeExtActor->VisibilityOn();
         break;
       case eFreeEdges:
       case eFreeBorders:
+      case eCoincidentElems1D:
         my1DExtActor->VisibilityOn();
         break;
       case eFreeFaces:
+      case eBareBorderFace:
+      case eOverConstrainedFace:
+      case eCoincidentElems2D:
         my2DExtActor->VisibilityOn();
         break;
+      case eBareBorderVolume:
+      case eOverConstrainedVolume:
+      case eCoincidentElems3D:
+        my3DExtActor->VisibilityOn();
+        break;
       case eLength2D:
       case eMultiConnection2D:
         my1DExtActor->VisibilityOn();
@@ -1215,30 +1350,48 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){
       myNodeActor->VisibilityOn();
     }
 
-    if(myEntityMode & e0DElements){
+    if(myEntityMode & e0DElements && GetRepresentation() != ePoint ){
       my0DActor->VisibilityOn();
     }
+    if(myEntityMode & eBallElem && GetRepresentation() != ePoint ){
+      myBallActor->VisibilityOn();
+    }
 
-    if(myEntityMode & eEdges){
+    if(myEntityMode & eEdges && GetRepresentation() != ePoint){
       my1DActor->VisibilityOn();
     }
     
-    if(myEntityMode & eFaces){
+    if(myEntityMode & eFaces && GetRepresentation() != ePoint){
       my2DActor->VisibilityOn();
     }
     
-    if(myEntityMode & eVolumes){
+    if(myEntityMode & eVolumes && GetRepresentation() != ePoint){
       my3DActor->VisibilityOn();
     }
     
-    if(myIsPointsLabeled){ 
-      myPointLabels->VisibilityOn();
+    if(myNodeActor->GetPointsLabeled()){ 
       myNodeActor->VisibilityOn();
     }
 
-    if(myIsCellsLabeled) 
-      myCellsLabels->VisibilityOn();
-  }
+    if(my0DActor)
+      my0DActor->UpdateLabels();
+    
+    if(myBallActor)
+      myBallActor->UpdateLabels();
+    
+    if(my1DActor)
+      my1DActor->UpdateLabels();
+    
+    if(my2DActor)
+      my2DActor->UpdateLabels();
+    
+    if(my3DActor)
+      my3DActor->UpdateLabels();    
+  } 
+#ifndef DISABLE_PLOT2DVIEWER
+  else
+    SMESH::ProcessIn2DViewers(this,SMESH::RemoveFrom2dViewer);
+#endif
   UpdateHighlight();
   Modified();
 }
@@ -1253,6 +1406,11 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode)
     theMode &= ~e0DElements;
   }
 
+  if(!myVisualObj->GetNbEntities(SMDSAbs_Ball)) {
+    myEntityState &= ~eBallElem;
+    theMode &= ~eBallElem;
+  }
+
   if(!myVisualObj->GetNbEntities(SMDSAbs_Edge)) {
     myEntityState &= ~eEdges;
     theMode &= ~eEdges;
@@ -1272,6 +1430,9 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode)
     if(myVisualObj->GetNbEntities(SMDSAbs_0DElement))
       theMode |= e0DElements;
 
+    if(myVisualObj->GetNbEntities(SMDSAbs_Ball))
+      theMode |= eBallElem;
+
     if(myVisualObj->GetNbEntities(SMDSAbs_Edge))
       theMode |= eEdges;
 
@@ -1292,11 +1453,7 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode)
 
   VTKViewer_ExtractUnstructuredGrid* aHightFilter = myHighlitableActor->GetExtractUnstructuredGrid();
   aHightFilter->ClearRegisteredCellsWithType();
-
-  // The following row has been commented (initially added in 1.28.2.3.1 revision)
-  // Reason: seems to be unnecessary, this filter should always have default (ePassAll) mode of changing
-  // In addition, it leads to exception (see bug IPAL21372)
-  //aHightFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
+  aHightFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
 
   if (myEntityMode & e0DElements) {
     if (MYDEBUG) MESSAGE("0D ELEMENTS");
@@ -1304,6 +1461,11 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode)
     aHightFilter->RegisterCellsWithType(VTK_VERTEX);
   }
 
+  if (myEntityMode & eBallElem) {
+    aFilter->RegisterCellsWithType(VTK_POLY_VERTEX);
+    aHightFilter->RegisterCellsWithType(VTK_POLY_VERTEX);
+  }
+
   if (myEntityMode & eEdges) {
     if (MYDEBUG) MESSAGE("EDGES");
     aFilter->RegisterCellsWithType(VTK_LINE);
@@ -1320,12 +1482,14 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode)
     aFilter->RegisterCellsWithType(VTK_QUAD);
     aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
     aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+    aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
 
     aHightFilter->RegisterCellsWithType(VTK_TRIANGLE);
     aHightFilter->RegisterCellsWithType(VTK_POLYGON);
     aHightFilter->RegisterCellsWithType(VTK_QUAD);
     aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
     aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+    aHightFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
   }
 
   if (myEntityMode & eVolumes) {
@@ -1335,20 +1499,31 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode)
     aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
     aFilter->RegisterCellsWithType(VTK_WEDGE);
     aFilter->RegisterCellsWithType(VTK_PYRAMID);
+    aFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
     aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
     aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
+    aFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
     aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
     aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
+//#ifdef VTK_HAVE_POLYHEDRON
+    aFilter->RegisterCellsWithType(VTK_POLYHEDRON);
+//#endif
     
     aHightFilter->RegisterCellsWithType(VTK_TETRA);
     aHightFilter->RegisterCellsWithType(VTK_VOXEL);
     aHightFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
     aHightFilter->RegisterCellsWithType(VTK_WEDGE);
     aHightFilter->RegisterCellsWithType(VTK_PYRAMID);
+    aHightFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
     aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
     aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
+    aHightFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
     aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
+    aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID);
     aHightFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
+//#ifdef VTK_HAVE_POLYHEDRON
+    aHightFilter->RegisterCellsWithType(VTK_POLYHEDRON);
+//#endif
   }
   aFilter->Update();
   if (MYDEBUG) MESSAGE(aFilter->GetOutput()->GetNumberOfCells());
@@ -1360,6 +1535,8 @@ void SMESH_ActorDef::SetRepresentation (int theMode)
   int aNbEdges = myVisualObj->GetNbEntities(SMDSAbs_Edge);
   int aNbFaces = myVisualObj->GetNbEntities(SMDSAbs_Face);
   int aNbVolumes = myVisualObj->GetNbEntities(SMDSAbs_Volume);
+  int aNb0Ds       = myVisualObj->GetNbEntities(SMDSAbs_0DElement);
+  int aNbBalls       = myVisualObj->GetNbEntities(SMDSAbs_Ball);
 
   if (theMode < 0) {
     myRepresentation = eSurface;
@@ -1371,10 +1548,10 @@ void SMESH_ActorDef::SetRepresentation (int theMode)
   } else {
     switch (theMode) {
     case eEdge:
-      if (!aNbFaces && !aNbVolumes && !aNbEdges) return;
+      if (!aNbFaces && !aNbVolumes && !aNbEdges && !aNb0Ds && !aNbBalls) return;
       break;
     case eSurface:
-      if (!aNbFaces && !aNbVolumes) return;
+      if (!aNbFaces && !aNbVolumes && !aNb0Ds && !aNbBalls) return;
       break;
     }    
     myRepresentation = theMode;
@@ -1396,6 +1573,7 @@ void SMESH_ActorDef::SetRepresentation (int theMode)
   myNodeActor->SetVisibility(false);
   myNodeExtActor->SetVisibility(false);
   vtkProperty *aProp = NULL, *aBackProp = NULL;
+  vtkProperty *aPropVN = NULL, *aPropVR = NULL;
   SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::EReperesent(-1);
   SMESH_Actor::EQuadratic2DRepresentation aQuadraticMode = GetQuadratic2DRepresentation();
   switch (myRepresentation) {
@@ -1403,16 +1581,18 @@ void SMESH_ActorDef::SetRepresentation (int theMode)
     myPickableActor = myNodeActor;
     myNodeActor->SetVisibility(true);
     aQuadraticMode = SMESH_Actor::eLines;
-    aProp = aBackProp = myNodeProp;
+    aProp = aBackProp = aPropVN = aPropVR = myNodeProp;
     aReperesent = SMESH_DeviceActor::ePoint;
     break;
   case eEdge:
-    aProp = aBackProp = myEdgeProp;
+    aProp = aBackProp = aPropVN = aPropVR = myEdgeProp;
     aReperesent = SMESH_DeviceActor::eInsideframe;
     break;
   case eSurface:
     aProp = mySurfaceProp;
     aBackProp = myBackSurfaceProp;
+    aPropVN = myNormalVProp;
+    aPropVR = myReversedVProp;
     aReperesent = SMESH_DeviceActor::eSurface;
     break;
   }
@@ -1428,18 +1608,20 @@ void SMESH_ActorDef::SetRepresentation (int theMode)
 
   my2DExtActor->SetRepresentation(aReperesent);
   
-  my3DActor->SetProperty(aProp);
-  my3DActor->SetBackfaceProperty(aBackProp);
+  my3DActor->SetProperty(aPropVN);
+  my3DActor->SetBackfaceProperty(aPropVR);
   my3DActor->SetRepresentation(aReperesent);
 
   //my0DExtActor->SetVisibility(false);
   my1DExtActor->SetVisibility(false);
   my2DExtActor->SetVisibility(false);
+  my3DExtActor->SetVisibility(false);
 
   // ???
   //my0DActor->SetProperty(aProp);
   //my0DActor->SetBackfaceProperty(aBackProp);
   my0DActor->SetRepresentation(aReperesent);
+  myBallActor->SetRepresentation(aReperesent);
   //my0DExtActor->SetRepresentation(aReperesent);
 
   switch(myControlMode){
@@ -1483,35 +1665,52 @@ void SMESH_ActorDef::SetPointRepresentation(bool theIsPointsVisible){
 }
 
 bool SMESH_ActorDef::GetPointRepresentation(){ 
-  return myIsPointsVisible || myIsPointsLabeled;
+  return myIsPointsVisible || myNodeActor->GetPointsLabeled();
 }
 
 
 void SMESH_ActorDef::UpdateHighlight(){
-  myHighlitableActor->SetVisibility(false);
   myHighlitableActor->SetHighlited(false);
-
-  if(myIsHighlighted){
-    myHighlitableActor->SetProperty(myHighlightProp);
-  }else if(myIsPreselected){
-    myHighlitableActor->SetProperty(myPreselectProp);
-  }
+  myHighlitableActor->SetVisibility(false);
 
   bool anIsVisible = GetVisibility();
 
-  if(myIsHighlighted || myIsPreselected){
-    if(GetUnstructuredGrid()->GetNumberOfCells()){
-      myHighlitableActor->SetHighlited(anIsVisible);
-      myHighlitableActor->SetVisibility(anIsVisible);
-      myHighlitableActor->GetExtractUnstructuredGrid()->
-        SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::eCells);
-      myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
-    }else if(myRepresentation == ePoint || GetPointRepresentation()){
-      myHighlitableActor->SetHighlited(anIsVisible);
-      myHighlitableActor->GetExtractUnstructuredGrid()->
-        SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
+  switch(myRepresentation){
+  case SMESH_DeviceActor::eSurface:
+  case SMESH_DeviceActor::eWireframe:
+    {
+      if(myIsHighlighted) {
+        myHighlitableActor->SetProperty(myHighlightProp);
+	myBallActor->SetProperty(myBallHighlightProp);
+      }else if(myIsPreselected){
+        myHighlitableActor->SetProperty(myPreselectProp);
+	myBallActor->SetProperty(myBallPreselectProp);
+      } else if(anIsVisible){
+	myBallActor->SetProperty(myBallProp);
+        (myRepresentation == eSurface) ? 
+          myHighlitableActor->SetProperty(myOutLineProp) : myHighlitableActor->SetProperty(myEdgeProp);
+      }
+      if(GetUnstructuredGrid()->GetNumberOfCells()) {
+        myHighlitableActor->SetHighlited(anIsVisible);
+        myHighlitableActor->GetExtractUnstructuredGrid()->
+          SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::eCells);
+        myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
+      }
       myHighlitableActor->SetVisibility(anIsVisible);
-      myHighlitableActor->SetRepresentation(SMESH_DeviceActor::ePoint);
+      break;
+    }
+  case SMESH_DeviceActor::ePoint:
+    {
+      if(myIsHighlighted) {
+        myNodeActor->SetProperty(myHighlightProp);
+      }else if(myIsPreselected) {
+        myNodeActor->SetProperty(myPreselectProp);
+      } else if(anIsVisible) {
+        myNodeActor->SetProperty(myNodeProp);
+      }
+      myNodeActor->SetRepresentation(SMESH_DeviceActor::ePoint);
+      myNodeActor->GetExtractUnstructuredGrid()->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
+      break;
     }
   }
 }
@@ -1576,15 +1775,33 @@ void SMESH_ActorDef::Update(){
     if (anObjTime > aTime)
       SetControlMode(GetControlMode(),false);
   }
-  if(myIsPointsLabeled){
-    SetPointsLabeled(myIsPointsLabeled);
-  }
-  if(myIsCellsLabeled){
-    SetCellsLabeled(myIsCellsLabeled);
-  }
+
+  if(myNodeActor)
+    myNodeActor->UpdateLabels();
+
+  if(my0DActor)
+    my0DActor->UpdateLabels();
+  
+  if(myBallActor)
+    myBallActor->UpdateLabels();
+  
+  if(my1DActor)
+    my1DActor->UpdateLabels();
+  
+  if(my2DActor)
+    my2DActor->UpdateLabels();
+
+  if(my3DActor)
+    my3DActor->UpdateLabels();
+  
   if(myIsFacesOriented){
     SetFacesOriented(myIsFacesOriented);
   }
+    
+  if(myVisualObj->GetEntitiesFlag()) {
+    myEntityMode |= myVisualObj->GetEntitiesState();
+  }
+  
   SetEntityMode(GetEntityMode());
   SetVisibility(GetVisibility());
   
@@ -1611,10 +1828,15 @@ static void GetColor(vtkProperty *theProperty, vtkFloatingPointType& r,vtkFloati
 void SMESH_ActorDef::SetOpacity(vtkFloatingPointType theValue){
   mySurfaceProp->SetOpacity(theValue);
   myBackSurfaceProp->SetOpacity(theValue);
+  myNormalVProp->SetOpacity(theValue);
+  myReversedVProp->SetOpacity(theValue);
   myEdgeProp->SetOpacity(theValue);
+  myOutLineProp->SetOpacity(theValue);
   myNodeProp->SetOpacity(theValue);
 
   my1DProp->SetOpacity(theValue);
+  my0DProp->SetOpacity(theValue);
+  myBallProp->SetOpacity(theValue);
 }
 
 
@@ -1623,27 +1845,40 @@ vtkFloatingPointType SMESH_ActorDef::GetOpacity(){
 }
 
 
-void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta){
   mySurfaceProp->SetColor(r,g,b);
+  my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
   if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
-    if( aGroupObj->GetElementType() == SMDSAbs_Face ||
-        aGroupObj->GetElementType() == SMDSAbs_Volume )
+    if( aGroupObj->GetElementType() == SMDSAbs_Face )
       myNameActor->SetBackgroundColor(r,g,b);
+  
+  myDeltaBrightness = delta;
+  QColor bfc = Qtx::mainColorToSecondary(QColor(int(r*255),int(g*255),int(b*255)), delta);
+  myBackSurfaceProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );
   Modified();
 }
 
-void SMESH_ActorDef::GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta){
   ::GetColor(mySurfaceProp,r,g,b);
-  my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
+  delta = myDeltaBrightness;
 }
 
-void SMESH_ActorDef::SetBackSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
-  myBackSurfaceProp->SetColor(r,g,b);
+void SMESH_ActorDef::SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta){
+  myNormalVProp->SetColor(r,g,b);
+  my3DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
+  if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
+    if( aGroupObj->GetElementType() == SMDSAbs_Volume )
+      myNameActor->SetBackgroundColor(r,g,b);
+  
+  myDeltaVBrightness = delta;
+  QColor bfc = Qtx::mainColorToSecondary(QColor(int(r*255),int(g*255),int(b*255)), delta);
+  myReversedVProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );
   Modified();
 }
 
-void SMESH_ActorDef::GetBackSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
-  ::GetColor(myBackSurfaceProp,r,g,b);
+void SMESH_ActorDef::GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta){
+  ::GetColor(myNormalVProp,r,g,b);
+  delta = myDeltaVBrightness;
 }
 
 void SMESH_ActorDef::SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
@@ -1660,6 +1895,16 @@ void SMESH_ActorDef::GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType&
   ::GetColor(myEdgeProp,r,g,b);
 }
 
+void SMESH_ActorDef::SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+  myOutLineProp->SetColor(r,g,b);
+  Modified();
+}
+
+void SMESH_ActorDef::GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+  ::GetColor(myOutLineProp,r,g,b);
+}
+
+
 void SMESH_ActorDef::SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ 
   myNodeProp->SetColor(r,g,b);
   myNodeExtProp->SetColor(1.0-r,1.0-g,1.0-b);
@@ -1675,6 +1920,9 @@ void SMESH_ActorDef::GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType&
 
 void SMESH_ActorDef::Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ 
   my0DProp->SetColor(r,g,b);
+  if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
+    if( aGroupObj->GetElementType() == SMDSAbs_0DElement )
+      myNameActor->SetBackgroundColor(r,g,b);
   Modified();
 }
 
@@ -1682,8 +1930,21 @@ void SMESH_ActorDef::Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,
   ::GetColor(my0DProp,r,g,b);
 }
 
+void SMESH_ActorDef::SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ 
+  myBallProp->SetColor(r,g,b);
+  if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
+    if( aGroupObj->GetElementType() == SMDSAbs_Ball )
+      myNameActor->SetBackgroundColor(r,g,b);
+  Modified();
+}
+
+void SMESH_ActorDef::GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ 
+  ::GetColor(myBallProp,r,g,b);
+}
+
 void SMESH_ActorDef::SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ 
   myHighlightProp->SetColor(r,g,b);
+  myBallHighlightProp->SetColor(r,g,b);
   Modified();
 }
 
@@ -1693,6 +1954,7 @@ void SMESH_ActorDef::GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointT
 
 void SMESH_ActorDef::SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ 
   myPreselectProp->SetColor(r,g,b);
+  myBallPreselectProp->SetColor(r,g,b);
   Modified();
 }
 
@@ -1710,40 +1972,37 @@ void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){
   myEdgeProp->SetLineWidth(theVal);
 
   my1DProp->SetLineWidth(theVal + aLineWidthInc);
-  my1DExtProp->SetLineWidth(theVal + aLineWidthInc);
-
+  my1DExtProp->SetLineWidth(theVal + aLineWidthInc);    
+  my2DExtProp->SetLineWidth(theVal + aLineWidthInc);
+  my3DExtProp->SetLineWidth(theVal + aLineWidthInc);
+  myOutLineProp->SetLineWidth(theVal);
+  myHighlightProp->SetLineWidth(theVal);
+  myPreselectProp->SetLineWidth(theVal);
   Modified();
 }
 
-
-void SMESH_ActorDef::SetNodeSize(vtkFloatingPointType theVal){
-  myNodeProp->SetPointSize(theVal);
-  myNodeExtProp->SetPointSize(theVal);
-
-  vtkFloatingPointType aPointSize = my0DProp->GetPointSize() > theVal ? my0DProp->GetPointSize() : theVal;
-  //myHighlightProp->SetPointSize(theVal);
-  myHighlightProp->SetPointSize(aPointSize); // ??
-  //myPreselectProp->SetPointSize(theVal);
-  myPreselectProp->SetPointSize(aPointSize); // ??
-
-  my1DProp->SetPointSize(theVal + aPointSizeInc);
-  my1DExtProp->SetPointSize(theVal + aPointSizeInc);
-
-  Modified();
+vtkFloatingPointType SMESH_ActorDef::GetOutlineWidth()
+{
+  return myOutLineProp->GetLineWidth();
 }
 
-vtkFloatingPointType SMESH_ActorDef::GetNodeSize(){
-  return myNodeProp->GetPointSize();
+void SMESH_ActorDef::SetOutlineWidth(vtkFloatingPointType theVal)
+{
+  myOutLineProp->SetLineWidth(theVal);
+  Modified();
 }
 
 void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){
   my0DProp->SetPointSize(theVal);
+  myHighlightProp->SetPointSize(theVal);
+  myPreselectProp->SetPointSize(theVal);
 
-  vtkFloatingPointType aPointSize = myNodeProp->GetPointSize() > theVal ? myNodeProp->GetPointSize() : theVal;
-  //myHighlightProp->SetPointSize(theVal);
-  myHighlightProp->SetPointSize(aPointSize); // ??
-  //myPreselectProp->SetPointSize(theVal);
-  myPreselectProp->SetPointSize(aPointSize); // ??
+  if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myHighlightActor )) {
+    aCustom->Set0DSize(theVal);
+  }
+  if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myPreHighlightActor )) {
+    aCustom->Set0DSize(theVal);
+  }
 
   Modified();
 }
@@ -1752,6 +2011,24 @@ vtkFloatingPointType SMESH_ActorDef::Get0DSize(){
   return my0DProp->GetPointSize();
 }
 
+void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){
+  myBallProp->SetPointSize(theVal);
+  myBallHighlightProp->SetPointSize(theVal);
+  myBallPreselectProp->SetPointSize(theVal);
+  if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myHighlightActor )) {
+    aCustom->SetBallSize(theVal);
+  }
+  if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myPreHighlightActor )) {
+    aCustom->SetBallSize(theVal);
+  }
+
+  Modified();
+}
+
+vtkFloatingPointType SMESH_ActorDef::GetBallSize(){
+  return myBallProp->GetPointSize();
+}
+
 int SMESH_ActorDef::GetObjDimension( const int theObjId )
 {
   return myVisualObj->GetElemDimension( theObjId );
@@ -1775,6 +2052,7 @@ SMESH_ActorDef::SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed)
   myNodeExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
 
   my0DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
+  myBallActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
   //my0DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
 
   my1DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
@@ -1783,6 +2061,7 @@ SMESH_ActorDef::SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed)
   my2DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
   my2DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
   my3DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
+  my3DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
 }
 
 vtkIdType 
@@ -1793,6 +2072,7 @@ SMESH_ActorDef::AddClippingPlane(vtkPlane* thePlane)
     myCippingPlaneCont.push_back(thePlane);
     if(!IsImplicitFunctionUsed())
       SetImplicitFunctionUsed(true);
+    myNodeActor->UpdateLabels();
   }
   return myCippingPlaneCont.size();
 }
@@ -1805,6 +2085,7 @@ RemoveAllClippingPlanes()
   myImplicitBoolean->GetFunction()->Modified(); // VTK bug
   myCippingPlaneCont.clear();
   SetImplicitFunctionUsed(false);
+  myNodeActor->UpdateLabels();
 }
 
 vtkIdType
@@ -1823,92 +2104,6 @@ GetClippingPlane(vtkIdType theID)
   return myCippingPlaneCont[theID].Get();
 }
 
-
-static void ComputeBoundsParam(vtkDataSet* theDataSet,
-                               vtkFloatingPointType theDirection[3], vtkFloatingPointType theMinPnt[3],
-                               vtkFloatingPointType& theMaxBoundPrj, vtkFloatingPointType& theMinBoundPrj)
-{
-  vtkFloatingPointType aBounds[6];
-  theDataSet->GetBounds(aBounds);
-
-  //Enlarge bounds in order to avoid conflicts of precision
-  for(int i = 0; i < 6; i += 2){
-    static double EPS = 1.0E-3;
-    vtkFloatingPointType aDelta = (aBounds[i+1] - aBounds[i])*EPS;
-    aBounds[i] -= aDelta;
-    aBounds[i+1] += aDelta;
-  }
-
-  vtkFloatingPointType aBoundPoints[8][3] = { {aBounds[0],aBounds[2],aBounds[4]},
-                               {aBounds[1],aBounds[2],aBounds[4]},
-                               {aBounds[0],aBounds[3],aBounds[4]},
-                               {aBounds[1],aBounds[3],aBounds[4]},
-                               {aBounds[0],aBounds[2],aBounds[5]},
-                               {aBounds[1],aBounds[2],aBounds[5]}, 
-                               {aBounds[0],aBounds[3],aBounds[5]}, 
-                               {aBounds[1],aBounds[3],aBounds[5]}};
-
-  int aMaxId = 0, aMinId = aMaxId;
-  theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]);
-  theMinBoundPrj = theMaxBoundPrj;
-  for(int i = 1; i < 8; i++){
-    vtkFloatingPointType aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]);
-    if(theMaxBoundPrj < aTmp){
-      theMaxBoundPrj = aTmp;
-      aMaxId = i;
-    }
-    if(theMinBoundPrj > aTmp){
-      theMinBoundPrj = aTmp;
-      aMinId = i;
-    }
-  }
-  vtkFloatingPointType *aMinPnt = aBoundPoints[aMaxId];
-  theMinPnt[0] = aMinPnt[0];
-  theMinPnt[1] = aMinPnt[1];
-  theMinPnt[2] = aMinPnt[2];
-}
-
-
-static void DistanceToPosition(vtkDataSet* theDataSet,
-                               vtkFloatingPointType theDirection[3], vtkFloatingPointType theDist, vtkFloatingPointType thePos[3])
-{
-  vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
-  ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
-  vtkFloatingPointType aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist;
-  thePos[0] = aMinPnt[0]-theDirection[0]*aLength;
-  thePos[1] = aMinPnt[1]-theDirection[1]*aLength;
-  thePos[2] = aMinPnt[2]-theDirection[2]*aLength;
-}
-
-
-static void PositionToDistance(vtkDataSet* theDataSet, 
-                               vtkFloatingPointType theDirection[3], vtkFloatingPointType thePos[3], vtkFloatingPointType& theDist)
-{
-  vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
-  ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
-  vtkFloatingPointType aPrj = vtkMath::Dot(theDirection,thePos);
-  theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj);
-}
-
-
-void SMESH_ActorDef::SetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType theDist, vtkPlane* thePlane)
-{
-  thePlane->SetNormal(theDir);
-  vtkFloatingPointType anOrigin[3];
-  ::DistanceToPosition(GetUnstructuredGrid(),theDir,theDist,anOrigin);
-  thePlane->SetOrigin(anOrigin);
-}
-
-
-void SMESH_ActorDef::GetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType& theDist, vtkPlane* thePlane)
-{
-  thePlane->GetNormal(theDir);
-
-  vtkFloatingPointType anOrigin[3];
-  thePlane->GetOrigin(anOrigin);
-  ::PositionToDistance(GetUnstructuredGrid(),theDir,anOrigin,theDist);
-}
-
 void SMESH_ActorDef::UpdateScalarBar()
 {
   SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
@@ -2022,9 +2217,45 @@ void SMESH_ActorDef::UpdateScalarBar()
   if( mgr->hasValue( "SMESH", "scalar_bar_num_colors" ) )
     anIntVal = mgr->integerValue( "SMESH", "scalar_bar_num_colors", anIntVal );
   myScalarBarActor->SetMaximumNumberOfColors( anIntVal == 0 ? 64 : anIntVal );
+
+  bool distributionVisibility = mgr->booleanValue("SMESH","distribution_visibility");
+  myScalarBarActor->SetDistributionVisibility(distributionVisibility);
+
+  int coloringType = mgr->integerValue("SMESH", "distribution_coloring_type", 0);
+  myScalarBarActor->SetDistributionColoringType(coloringType);
+  
+  QColor distributionColor = mgr->colorValue("SMESH", "distribution_color",
+                                             QColor(255, 255, 255));
+  double rgb[3];
+  rgb[0]= distributionColor.red()/255.;
+  rgb[1]= distributionColor.green()/255.;
+  rgb[2]= distributionColor.blue()/255.;
+  myScalarBarActor->SetDistributionColor(rgb);
+
   
 }
 
+void SMESH_ActorDef::UpdateDistribution()
+{
+  if(SMESH::Controls::NumericalFunctor* fun =
+     dynamic_cast<SMESH::Controls::NumericalFunctor*>(myFunctor.get()))
+  {
+    int nbIntervals = myScalarBarActor->GetMaximumNumberOfColors();
+    std::vector<int> nbEvents;
+    std::vector<double> funValues;
+    SMESH_VisualObjDef::TEntityList elems;
+    if ( ! dynamic_cast<SMESH_MeshObj*>(myVisualObj.get()))
+      dynamic_cast<SMESH_VisualObjDef*>(myVisualObj.get())->GetEntities( fun->GetType(), elems );
+    std::vector<int> elemIds;
+    for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e)
+      elemIds.push_back( (*e)->GetID());
+    vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
+    double * range = lookupTable->GetRange();
+    fun->GetHistogram(nbIntervals, nbEvents, funValues, elemIds, range);
+    myScalarBarActor->SetDistribution(nbEvents);
+  }
+}
+
 void SMESH_ActorDef::SetQuadratic2DRepresentation(EQuadratic2DRepresentation theMode)
 {
   switch(theMode) {
@@ -2053,3 +2284,72 @@ SMESH_Actor::EQuadratic2DRepresentation SMESH_ActorDef::GetQuadratic2DRepresenta
   else
     return SMESH_Actor::eLines;
 }
+
+void SMESH_ActorDef::SetMarkerStd( VTK::MarkerType theMarkerType, VTK::MarkerScale theMarkerScale )
+{
+  SALOME_Actor::SetMarkerStd( theMarkerType, theMarkerScale );
+  myNodeActor->SetMarkerStd( theMarkerType, theMarkerScale );
+  myNodeExtActor->SetMarkerStd( theMarkerType, theMarkerScale );
+}
+
+void SMESH_ActorDef::SetMarkerTexture( int theMarkerId, VTK::MarkerTexture theMarkerTexture )
+{
+  SALOME_Actor::SetMarkerTexture( theMarkerId, theMarkerTexture );
+  myNodeActor->SetMarkerTexture( theMarkerId, theMarkerTexture );
+  myNodeExtActor->SetMarkerTexture( theMarkerId, theMarkerTexture );
+  myMarkerTexture = theMarkerTexture; // for deferred update of myHighlightActor
+}
+
+#ifndef DISABLE_PLOT2DVIEWER
+SPlot2d_Histogram* SMESH_ActorDef::UpdatePlot2Histogram() {
+
+  if(my2dHistogram)
+    my2dHistogram->clearAllPoints();
+  
+  if(SMESH::Controls::NumericalFunctor* fun =
+     dynamic_cast<SMESH::Controls::NumericalFunctor*>(myFunctor.get()))
+  {
+    
+    if(!my2dHistogram) {
+      my2dHistogram = new SPlot2d_Histogram();
+      Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(getIO()->getEntry(),"SMESH",getName());
+      my2dHistogram->setIO(anIO);
+    }
+    
+    int nbIntervals = myScalarBarActor->GetMaximumNumberOfColors();
+    std::vector<int> nbEvents;
+    std::vector<double> funValues;
+    SMESH_VisualObjDef::TEntityList elems;
+    if ( ! dynamic_cast<SMESH_MeshObj*>(myVisualObj.get()))
+      dynamic_cast<SMESH_VisualObjDef*>(myVisualObj.get())->GetEntities( fun->GetType(), elems );
+    std::vector<int> elemIds;
+    
+    for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e)
+      elemIds.push_back( (*e)->GetID());
+
+    vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
+    double * range = lookupTable->GetRange();
+    fun->GetHistogram(nbIntervals, nbEvents, funValues, elemIds, range);
+
+    for ( int i = 0; i < std::min( nbEvents.size(), funValues.size() -1 ); i++ ) 
+      my2dHistogram->addPoint(funValues[i] + (funValues[i+1] - funValues[i])/2.0, static_cast<double>(nbEvents[i]));
+
+    if(funValues.size() >= 2)
+      my2dHistogram->setWidth((funValues[1] - funValues[0]) * 0.8) ;
+
+  }
+  
+  //Color of the histogram
+  if(myScalarBarActor->GetDistributionColoringType() == SMESH_MULTICOLOR_TYPE)
+    my2dHistogram->setAutoAssign(true);
+  else {
+    double rgb[3];
+    myScalarBarActor->GetDistributionColor(rgb);
+    QColor aColor = QColor( (int)( rgb[0]*255 ), (int)( rgb[1]*255 ), (int)( rgb[2]*255 ) );
+    my2dHistogram->setColor(aColor);
+
+  }
+      
+  return my2dHistogram;
+}
+#endif