src/SMESH_I/SMESH_Filter_i.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
  24 //  File   : SMESH_Filter_i.cxx
  25 //  Author : Alexey Petrov, OCC
  26 //  Module : SMESH
  27
  28 #include "SMESH_Filter_i.hxx"
  29
  30 #include "SMDS_ElemIterator.hxx"
  31 #include "SMDS_Mesh.hxx"
  32 #include "SMDS_MeshElement.hxx"
  33 #include "SMDS_MeshNode.hxx"
  34 #include "SMESHDS_GroupBase.hxx"
  35 #include "SMESHDS_Mesh.hxx"
  36 #include "SMESH_Gen_i.hxx"
  37 #include "SMESH_Group_i.hxx"
  38 #include "SMESH_PythonDump.hxx"
  39
  40 #include <SALOMEDS_wrap.hxx>
  41 #include <GEOM_wrap.hxx>
  42
  43 #include <Basics_OCCTVersion.hxx>
  44
  45 #include <BRep_Tool.hxx>
  46 #include <Geom_CylindricalSurface.hxx>
  47 #include <Geom_Plane.hxx>
  48 #include <LDOMParser.hxx>
  49 #include <LDOMString.hxx>
  50 #include <LDOM_Document.hxx>
  51 #include <LDOM_Element.hxx>
  52 #include <LDOM_Node.hxx>
  53 #include <LDOM_XmlWriter.hxx>
  54 #include <Precision.hxx>
  55 #include <TColStd_ListIteratorOfListOfInteger.hxx>
  56 #include <TColStd_ListIteratorOfListOfReal.hxx>
  57 #include <TColStd_ListOfInteger.hxx>
  58 #include <TColStd_ListOfReal.hxx>
  59 #include <TColStd_SequenceOfHAsciiString.hxx>
  60 #include <TCollection_HAsciiString.hxx>
  61 #include <TopExp_Explorer.hxx>
  62 #include <TopoDS.hxx>
  63 #include <TopoDS_Shape.hxx>
  64
  65 using namespace SMESH;
  66 using namespace SMESH::Controls;
  67
  68
  69 namespace SMESH
  70 {
  71   Predicate_i*
  72   GetPredicate( Predicate_ptr thePredicate )
  73   {
  74     return DownCast<Predicate_i*>(thePredicate);
  75   }
  76 }
  77
  78 /*
  79                             AUXILIARY METHODS
  80 */
  81
  82 inline
  83 const SMDS_Mesh*
  84 MeshPtr2SMDSMesh( SMESH_Mesh_ptr theMesh )
  85 {
  86   SMESH_Mesh_i* anImplPtr = DownCast<SMESH_Mesh_i*>(theMesh);
  87   return anImplPtr ? anImplPtr->GetImpl().GetMeshDS() : 0;
  88 }
  89
  90 inline
  91 SMESH::long_array*
  92 toArray( const TColStd_ListOfInteger& aList )
  93 {
  94   SMESH::long_array_var anArray = new SMESH::long_array;
  95   anArray->length( aList.Extent() );
  96   TColStd_ListIteratorOfListOfInteger anIter( aList );
  97   int i = 0;
  98   for( ; anIter.More(); anIter.Next() )
  99     anArray[ i++ ] = anIter.Value();
 100
 101   return anArray._retn();
 102 }
 103
 104 inline
 105 SMESH::double_array*
 106 toArray( const TColStd_ListOfReal& aList )
 107 {
 108   SMESH::double_array_var anArray = new SMESH::double_array;
 109   anArray->length( aList.Extent() );
 110   TColStd_ListIteratorOfListOfReal anIter( aList );
 111   int i = 0;
 112   for( ; anIter.More(); anIter.Next() )
 113     anArray[ i++ ] = anIter.Value();
 114
 115   return anArray._retn();
 116 }
 117
 118 static SMESH::Filter::Criterion createCriterion()
 119 {
 120   SMESH::Filter::Criterion aCriterion;
 121
 122   aCriterion.Type          = FT_Undefined;
 123   aCriterion.Compare       = FT_Undefined;
 124   aCriterion.Threshold     = 0;
 125   aCriterion.UnaryOp       = FT_Undefined;
 126   aCriterion.BinaryOp      = FT_Undefined;
 127   aCriterion.ThresholdStr  = "";
 128   aCriterion.ThresholdID   = "";
 129   aCriterion.Tolerance     = Precision::Confusion();
 130   aCriterion.TypeOfElement = SMESH::ALL;
 131   aCriterion.Precision     = -1;
 132
 133   return aCriterion;
 134 }
 135
 136 static TopoDS_Shape getShapeByName( const char* theName )
 137 {
 138   if ( theName != 0 )
 139   {
 140     SMESH_Gen_i* aSMESHGen     = SMESH_Gen_i::GetSMESHGen();
 141     SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
 142     if ( !aStudy->_is_nil() )
 143     {
 144       SALOMEDS::Study::ListOfSObject_var aList = aStudy->FindObjectByName( theName, "GEOM" );
 145       if ( aList->length() > 0 )
 146       {
 147         CORBA::Object_var        anObj = aList[ 0 ]->GetObject();
 148         GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( anObj );
 149         TopoDS_Shape             shape = aSMESHGen->GeomObjectToShape( aGeomObj );
 150         SALOME::UnRegister( aList ); // UnRegister() objects in aList
 151         return shape;
 152       }
 153     }
 154   }
 155   return TopoDS_Shape();
 156 }
 157
 158 static TopoDS_Shape getShapeByID (const char* theID)
 159 {
 160   if ( theID && strlen( theID ) > 0 ) {
 161     SMESH_Gen_i*     aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 162     SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
 163     if ( !aStudy->_is_nil() ) {
 164       SALOMEDS::SObject_wrap aSObj = aStudy->FindObjectID(theID);
 165       if ( !aSObj->_is_nil() ) {
 166         CORBA::Object_var          obj = aSObj->GetObject();
 167         GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(obj);
 168         return aSMESHGen->GeomObjectToShape( aGeomObj );
 169       }
 170     }
 171   }
 172   return TopoDS_Shape();
 173 }
 174
 175 // static std::string getShapeNameByID (const char* theID)
 176 // {
 177 //   if ( theID && strlen( theID ) > 0 ) {
 178 //     SMESH_Gen_i*     aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 179 //     SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
 180 //     if ( !aStudy->_is_nil() ) {
 181 //       SALOMEDS::SObject_wrap aSObj = aStudy->FindObjectID(theID);
 182 //       if ( !aSObj->_is_nil() ) {
 183 //         CORBA::String_var name = aSObj->GetName();
 184 //         return name.in();
 185 //       }
 186 //     }
 187 //   }
 188 //   return "";
 189 // }
 190
 191 /*
 192                                 FUNCTORS
 193 */
 194
 195 /*
 196   Class       : Functor_i
 197   Description : An abstact class for all functors
 198 */
 199 Functor_i::Functor_i():
 200   SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
 201 {
 202   //Base class Salome_GenericObject do it inmplicitly by overriding PortableServer::POA_ptr _default_POA() method
 203   //PortableServer::ObjectId_var anObjectId =
 204   //  SMESH_Gen_i::GetPOA()->activate_object( this );
 205 }
 206
 207 Functor_i::~Functor_i()
 208 {
 209   //TPythonDump()<<this<<".UnRegister()";
 210 }
 211
 212 void Functor_i::SetMesh( SMESH_Mesh_ptr theMesh )
 213 {
 214   myFunctorPtr->SetMesh( MeshPtr2SMDSMesh( theMesh ) );
 215   TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
 216 }
 217
 218 ElementType Functor_i::GetElementType()
 219 {
 220   return ( ElementType )myFunctorPtr->GetType();
 221 }
 222
 223
 224 /*
 225   Class       : NumericalFunctor_i
 226   Description : Base class for numerical functors
 227 */
 228 CORBA::Double NumericalFunctor_i::GetValue( CORBA::Long theId )
 229 {
 230   return myNumericalFunctorPtr->GetValue( theId );
 231 }
 232
 233 SMESH::Histogram* NumericalFunctor_i::GetHistogram(CORBA::Short nbIntervals, CORBA::Boolean isLogarithmic)
 234 {
 235   std::vector<int> nbEvents;
 236   std::vector<double> funValues;
 237   std::vector<int> elements;
 238   myNumericalFunctorPtr->GetHistogram(nbIntervals,nbEvents,funValues,elements,0,isLogarithmic);
 239
 240   SMESH::Histogram_var histogram = new SMESH::Histogram;
 241
 242   nbIntervals = CORBA::Short( Min( int( nbEvents.size()),
 243                                    int( funValues.size() - 1 )));
 244   if ( nbIntervals > 0 )
 245   {
 246     histogram->length( nbIntervals );
 247     for ( int i = 0; i < nbIntervals; ++i )
 248     {
 249       HistogramRectangle& rect = histogram[i];
 250       rect.nbEvents = nbEvents[i];
 251       rect.min = funValues[i];
 252       rect.max = funValues[i+1];
 253     }
 254   }
 255   return histogram._retn();
 256 }
 257
 258 SMESH::Histogram* NumericalFunctor_i::GetLocalHistogram(CORBA::Short              nbIntervals,
 259                                                         CORBA::Boolean            isLogarithmic,
 260                                                         SMESH::SMESH_IDSource_ptr object)
 261 {
 262   SMESH::Histogram_var histogram = new SMESH::Histogram;
 263
 264   std::vector<int>    nbEvents;
 265   std::vector<double> funValues;
 266   std::vector<int>    elements;
 267
 268   SMDS_ElemIteratorPtr elemIt;
 269   if ( SMESH::DownCast< SMESH_GroupOnFilter_i* >( object ) ||
 270        SMESH::DownCast< SMESH::Filter_i* >( object ))
 271   {
 272     elemIt = SMESH_Mesh_i::GetElements( object, GetElementType() );
 273     if ( !elemIt ) return histogram._retn();
 274   }
 275   else
 276   {
 277     SMESH::SMESH_Mesh_var        mesh = object->GetMesh();
 278     SMESH::long_array_var  objNbElems = object->GetNbElementsByType();
 279     SMESH::long_array_var meshNbElems = mesh->  GetNbElementsByType();
 280     if ( meshNbElems[ GetElementType() ] !=
 281          objNbElems [ GetElementType() ] )
 282     {
 283       elements.reserve( objNbElems[ GetElementType() ]);
 284       elemIt = SMESH_Mesh_i::GetElements( object, GetElementType() );
 285     }
 286   }
 287   if ( elemIt )
 288   {
 289     while ( elemIt->more() )
 290       elements.push_back( elemIt->next()->GetID() );
 291     if ( elements.empty() ) return histogram._retn();
 292   }
 293
 294   myNumericalFunctorPtr->GetHistogram(nbIntervals,nbEvents,funValues,elements,0,isLogarithmic);
 295
 296   nbIntervals = CORBA::Short( Min( int( nbEvents.size()),
 297                                    int( funValues.size() - 1 )));
 298   if ( nbIntervals > 0 )
 299   {
 300     histogram->length( nbIntervals );
 301     for ( int i = 0; i < nbIntervals; ++i )
 302     {
 303       HistogramRectangle& rect = histogram[i];
 304       rect.nbEvents = nbEvents[i];
 305       rect.min = funValues[i];
 306       rect.max = funValues[i+1];
 307     }
 308   }
 309   return histogram._retn();
 310 }
 311
 312 void NumericalFunctor_i::SetPrecision( CORBA::Long thePrecision )
 313 {
 314   myNumericalFunctorPtr->SetPrecision( thePrecision );
 315   TPythonDump()<<this<<".SetPrecision("<<thePrecision<<")";
 316 }
 317
 318 CORBA::Long NumericalFunctor_i::GetPrecision()
 319 {
 320  return myNumericalFunctorPtr->GetPrecision();
 321 }
 322
 323 Controls::NumericalFunctorPtr NumericalFunctor_i::GetNumericalFunctor()
 324 {
 325   return myNumericalFunctorPtr;
 326 }
 327
 328
 329 /*
 330   Class       : SMESH_MinimumAngle
 331   Description : Functor for calculation of minimum angle
 332 */
 333 MinimumAngle_i::MinimumAngle_i()
 334 {
 335   myNumericalFunctorPtr.reset( new Controls::MinimumAngle() );
 336   myFunctorPtr = myNumericalFunctorPtr;
 337 }
 338
 339 FunctorType MinimumAngle_i::GetFunctorType()
 340 {
 341   return SMESH::FT_MinimumAngle;
 342 }
 343
 344
 345 /*
 346   Class       : AspectRatio
 347   Description : Functor for calculating aspect ratio
 348 */
 349 AspectRatio_i::AspectRatio_i()
 350 {
 351   myNumericalFunctorPtr.reset( new Controls::AspectRatio() );
 352   myFunctorPtr = myNumericalFunctorPtr;
 353 }
 354
 355 FunctorType AspectRatio_i::GetFunctorType()
 356 {
 357   return SMESH::FT_AspectRatio;
 358 }
 359
 360
 361 /*
 362   Class       : AspectRatio3D
 363   Description : Functor for calculating aspect ratio 3D
 364 */
 365 AspectRatio3D_i::AspectRatio3D_i()
 366 {
 367   myNumericalFunctorPtr.reset( new Controls::AspectRatio3D() );
 368   myFunctorPtr = myNumericalFunctorPtr;
 369 }
 370
 371 FunctorType AspectRatio3D_i::GetFunctorType()
 372 {
 373   return SMESH::FT_AspectRatio3D;
 374 }
 375
 376
 377 /*
 378   Class       : Warping_i
 379   Description : Functor for calculating warping
 380 */
 381 Warping_i::Warping_i()
 382 {
 383   myNumericalFunctorPtr.reset( new Controls::Warping() );
 384   myFunctorPtr = myNumericalFunctorPtr;
 385 }
 386
 387 FunctorType Warping_i::GetFunctorType()
 388 {
 389   return SMESH::FT_Warping;
 390 }
 391
 392
 393 /*
 394   Class       : Taper_i
 395   Description : Functor for calculating taper
 396 */
 397 Taper_i::Taper_i()
 398 {
 399   myNumericalFunctorPtr.reset( new Controls::Taper() );
 400   myFunctorPtr = myNumericalFunctorPtr;
 401 }
 402
 403 FunctorType Taper_i::GetFunctorType()
 404 {
 405   return SMESH::FT_Taper;
 406 }
 407
 408 /*
 409   Class       : Skew_i
 410   Description : Functor for calculating skew in degrees
 411 */
 412 Skew_i::Skew_i()
 413 {
 414   myNumericalFunctorPtr.reset( new Controls::Skew() );
 415   myFunctorPtr = myNumericalFunctorPtr;
 416 }
 417
 418 FunctorType Skew_i::GetFunctorType()
 419 {
 420   return SMESH::FT_Skew;
 421 }
 422
 423 /*
 424   Class       : Area_i
 425   Description : Functor for calculating area
 426 */
 427 Area_i::Area_i()
 428 {
 429   myNumericalFunctorPtr.reset( new Controls::Area() );
 430   myFunctorPtr = myNumericalFunctorPtr;
 431 }
 432
 433 FunctorType Area_i::GetFunctorType()
 434 {
 435   return SMESH::FT_Area;
 436 }
 437
 438 /*
 439   Class       : Volume3D_i
 440   Description : Functor for calculating volume of 3D element
 441 */
 442 Volume3D_i::Volume3D_i()
 443 {
 444   myNumericalFunctorPtr.reset( new Controls::Volume() );
 445   myFunctorPtr = myNumericalFunctorPtr;
 446 }
 447
 448 FunctorType Volume3D_i::GetFunctorType()
 449 {
 450   return SMESH::FT_Volume3D;
 451 }
 452
 453 /*
 454   Class       : MaxElementLength2D_i
 455   Description : Functor for calculating maximum length of 2D element
 456 */
 457 MaxElementLength2D_i::MaxElementLength2D_i()
 458 {
 459   myNumericalFunctorPtr.reset( new Controls::MaxElementLength2D() );
 460   myFunctorPtr = myNumericalFunctorPtr;
 461 }
 462
 463 FunctorType MaxElementLength2D_i::GetFunctorType()
 464 {
 465   return SMESH::FT_MaxElementLength2D;
 466 }
 467
 468 /*
 469   Class       : MaxElementLength3D_i
 470   Description : Functor for calculating maximum length of 3D element
 471 */
 472 MaxElementLength3D_i::MaxElementLength3D_i()
 473 {
 474   myNumericalFunctorPtr.reset( new Controls::MaxElementLength3D() );
 475   myFunctorPtr = myNumericalFunctorPtr;
 476 }
 477
 478 FunctorType MaxElementLength3D_i::GetFunctorType()
 479 {
 480   return SMESH::FT_MaxElementLength3D;
 481 }
 482
 483 /*
 484   Class       : Length_i
 485   Description : Functor for calculating length off edge
 486 */
 487 Length_i::Length_i()
 488 {
 489   myNumericalFunctorPtr.reset( new Controls::Length() );
 490   myFunctorPtr = myNumericalFunctorPtr;
 491 }
 492
 493 FunctorType Length_i::GetFunctorType()
 494 {
 495   return SMESH::FT_Length;
 496 }
 497
 498 /*
 499   Class       : Length2D_i
 500   Description : Functor for calculating length of edge
 501 */
 502 Length2D_i::Length2D_i()
 503 {
 504   myNumericalFunctorPtr.reset( new Controls::Length2D() );
 505   myFunctorPtr = myNumericalFunctorPtr;
 506 }
 507
 508 FunctorType Length2D_i::GetFunctorType()
 509 {
 510   return SMESH::FT_Length2D;
 511 }
 512
 513 SMESH::Length2D::Values* Length2D_i::GetValues()
 514 {
 515   SMESH::Controls::Length2D::TValues aValues;
 516   (dynamic_cast<SMESH::Controls::Length2D*>(myFunctorPtr.get()))->GetValues( aValues );
 517
 518   long i = 0, iEnd = aValues.size();
 519
 520   SMESH::Length2D::Values_var aResult = new SMESH::Length2D::Values(iEnd);
 521   aResult->length(iEnd);
 522
 523   SMESH::Controls::Length2D::TValues::const_iterator anIter;
 524   for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
 525   {
 526     const SMESH::Controls::Length2D::Value&  aVal = *anIter;
 527     SMESH::Length2D::Value &aValue = aResult[ i ];
 528
 529     aValue.myLength = aVal.myLength;
 530     aValue.myPnt1 = aVal.myPntId[ 0 ];
 531     aValue.myPnt2 = aVal.myPntId[ 1 ];
 532   }
 533
 534   return aResult._retn();
 535 }
 536
 537 /*
 538   Class       : Deflection2D_i
 539   Description : Functor for calculating distance between a face and geometry
 540 */
 541 Deflection2D_i::Deflection2D_i()
 542 {
 543   myNumericalFunctorPtr.reset( new Controls::Deflection2D() );
 544   myFunctorPtr = myNumericalFunctorPtr;
 545 }
 546
 547 FunctorType Deflection2D_i::GetFunctorType()
 548 {
 549   return SMESH::FT_Deflection2D;
 550 }
 551
 552 /*
 553   Class       : MultiConnection_i
 554   Description : Functor for calculating number of faces conneted to the edge
 555 */
 556 MultiConnection_i::MultiConnection_i()
 557 {
 558   myNumericalFunctorPtr.reset( new Controls::MultiConnection() );
 559   myFunctorPtr = myNumericalFunctorPtr;
 560 }
 561
 562 FunctorType MultiConnection_i::GetFunctorType()
 563 {
 564   return SMESH::FT_MultiConnection;
 565 }
 566
 567 /*
 568   Class       : BallDiameter_i
 569   Description : Functor returning diameter of a ball element
 570 */
 571 BallDiameter_i::BallDiameter_i()
 572 {
 573   myNumericalFunctorPtr.reset( new Controls::BallDiameter() );
 574   myFunctorPtr = myNumericalFunctorPtr;
 575 }
 576
 577 FunctorType BallDiameter_i::GetFunctorType()
 578 {
 579   return SMESH::FT_BallDiameter;
 580 }
 581
 582 /*
 583   Class       : NodeConnectivityNumber_i
 584   Description : Functor returning diameter of a ball element
 585 */
 586 NodeConnectivityNumber_i::NodeConnectivityNumber_i()
 587 {
 588   myNumericalFunctorPtr.reset( new Controls::NodeConnectivityNumber() );
 589   myFunctorPtr = myNumericalFunctorPtr;
 590 }
 591
 592 FunctorType NodeConnectivityNumber_i::GetFunctorType()
 593 {
 594   return SMESH::FT_NodeConnectivityNumber;
 595 }
 596
 597 /*
 598   Class       : MultiConnection2D_i
 599   Description : Functor for calculating number of faces conneted to the edge
 600 */
 601 MultiConnection2D_i::MultiConnection2D_i()
 602 {
 603   myNumericalFunctorPtr.reset( new Controls::MultiConnection2D() );
 604   myFunctorPtr = myNumericalFunctorPtr;
 605 }
 606
 607 FunctorType MultiConnection2D_i::GetFunctorType()
 608 {
 609   return SMESH::FT_MultiConnection2D;
 610 }
 611
 612 SMESH::MultiConnection2D::Values* MultiConnection2D_i::GetValues()
 613 {
 614   SMESH::Controls::MultiConnection2D::MValues aValues;
 615   (dynamic_cast<SMESH::Controls::MultiConnection2D*>(myFunctorPtr.get()))->GetValues( aValues );
 616
 617   long i = 0, iEnd = aValues.size();
 618
 619   SMESH::MultiConnection2D::Values_var aResult = new SMESH::MultiConnection2D::Values(iEnd);
 620   aResult->length(iEnd);
 621
 622   SMESH::Controls::MultiConnection2D::MValues::const_iterator anIter;
 623   for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
 624   {
 625     const SMESH::Controls::MultiConnection2D::Value&  aVal = (*anIter).first;
 626     SMESH::MultiConnection2D::Value &aValue = aResult[ i ];
 627
 628     aValue.myPnt1 = aVal.myPntId[ 0 ];
 629     aValue.myPnt2 = aVal.myPntId[ 1 ];
 630     aValue.myNbConnects = (*anIter).second;
 631   }
 632
 633   return aResult._retn();
 634 }
 635
 636 /*
 637                             PREDICATES
 638 */
 639
 640
 641 /*
 642   Class       : Predicate_i
 643   Description : Base class for all predicates
 644 */
 645 CORBA::Boolean Predicate_i::IsSatisfy( CORBA::Long theId )
 646 {
 647   return myPredicatePtr->IsSatisfy( theId );
 648 }
 649
 650 CORBA::Long Predicate_i::NbSatisfying( SMESH::SMESH_IDSource_ptr obj )
 651 {
 652   SMESH::SMESH_Mesh_var meshVar = obj->GetMesh();
 653   const SMDS_Mesh*       meshDS = MeshPtr2SMDSMesh( meshVar );
 654   if ( !meshDS )
 655     return 0;
 656   myPredicatePtr->SetMesh( meshDS );
 657
 658   SMDSAbs_ElementType elemType = SMDSAbs_ElementType( GetElementType() );
 659
 660   int nb = 0;
 661   SMDS_ElemIteratorPtr elemIt =
 662     SMESH::DownCast<SMESH_Mesh_i*>( meshVar )->GetElements( obj, GetElementType() );
 663   if ( elemIt )
 664     while ( elemIt->more() )
 665     {
 666       const SMDS_MeshElement* e = elemIt->next();
 667       if ( e && e->GetType() == elemType )
 668         nb += myPredicatePtr->IsSatisfy( e->GetID() );
 669     }
 670   return nb;
 671 }
 672
 673 Controls::PredicatePtr Predicate_i::GetPredicate()
 674 {
 675   return myPredicatePtr;
 676 }
 677
 678 /*
 679   Class       : BadOrientedVolume_i
 680   Description : Verify whether a mesh volume is incorrectly oriented from
 681                 the point of view of MED convention
 682 */
 683 BadOrientedVolume_i::BadOrientedVolume_i()
 684 {
 685   Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
 686   myFunctorPtr = myPredicatePtr = control;
 687 };
 688
 689 FunctorType BadOrientedVolume_i::GetFunctorType()
 690 {
 691   return SMESH::FT_BadOrientedVolume;
 692 }
 693
 694 /*
 695   Class       : BareBorderVolume_i
 696   Description : Verify whether a mesh volume has a free facet without a face on it
 697 */
 698 BareBorderVolume_i::BareBorderVolume_i()
 699 {
 700   Controls::PredicatePtr control( new Controls::BareBorderVolume() );
 701   myFunctorPtr = myPredicatePtr = control;
 702 };
 703
 704 FunctorType BareBorderVolume_i::GetFunctorType()
 705 {
 706   return SMESH::FT_BareBorderVolume;
 707 }
 708
 709 /*
 710   Class       : BareBorderFace_i
 711   Description : Verify whether a mesh face has a free border without an edge on it
 712 */
 713 BareBorderFace_i::BareBorderFace_i()
 714 {
 715   Controls::PredicatePtr control( new Controls::BareBorderFace() );
 716   myFunctorPtr = myPredicatePtr = control;
 717 };
 718
 719 FunctorType BareBorderFace_i::GetFunctorType()
 720 {
 721   return SMESH::FT_BareBorderFace;
 722 }
 723
 724 /*
 725   Class       : OverConstrainedVolume_i
 726   Description : Verify whether a mesh volume has only one facet shared with other volumes
 727 */
 728 OverConstrainedVolume_i::OverConstrainedVolume_i()
 729 {
 730   Controls::PredicatePtr control( new Controls::OverConstrainedVolume() );
 731   myFunctorPtr = myPredicatePtr = control;
 732 };
 733
 734 FunctorType OverConstrainedVolume_i::GetFunctorType()
 735 {
 736   return SMESH::FT_OverConstrainedVolume;
 737 }
 738
 739 /*
 740   Class       : OverConstrainedFace_i
 741   Description : Verify whether a mesh face has only one border shared with other faces
 742 */
 743 OverConstrainedFace_i::OverConstrainedFace_i()
 744 {
 745   Controls::PredicatePtr control( new Controls::OverConstrainedFace() );
 746   myFunctorPtr = myPredicatePtr = control;
 747 };
 748
 749 FunctorType OverConstrainedFace_i::GetFunctorType()
 750 {
 751   return SMESH::FT_OverConstrainedFace;
 752 }
 753
 754 /*
 755   Class       : BelongToMeshGroup_i
 756   Description : Verify whether a mesh element is included into a mesh group
 757 */
 758 BelongToMeshGroup_i::BelongToMeshGroup_i()
 759 {
 760   myBelongToMeshGroup = Controls::BelongToMeshGroupPtr( new Controls::BelongToMeshGroup() );
 761   myFunctorPtr = myPredicatePtr = myBelongToMeshGroup;
 762 }
 763
 764 BelongToMeshGroup_i::~BelongToMeshGroup_i()
 765 {
 766   SetGroup( SMESH::SMESH_GroupBase::_nil() );
 767 }
 768
 769 void BelongToMeshGroup_i::SetGroup( SMESH::SMESH_GroupBase_ptr theGroup )
 770 {
 771   if ( myGroup->_is_equivalent( theGroup ))
 772     return;
 773
 774   if ( ! myGroup->_is_nil() )
 775     myGroup->UnRegister();
 776
 777   myGroup = SMESH_GroupBase::_duplicate( theGroup );
 778
 779   myBelongToMeshGroup->SetGroup( 0 );
 780   if ( SMESH_GroupBase_i* gr_i = SMESH::DownCast< SMESH_GroupBase_i* >( myGroup ))
 781   {
 782     myBelongToMeshGroup->SetGroup( gr_i->GetGroupDS() );
 783     myGroup->Register();
 784   }
 785 }
 786
 787 void BelongToMeshGroup_i::SetGroupID( const char* theID ) // IOR or StoreName
 788 {
 789   myID = theID;
 790   if ( strncmp( "IOR:", myID.c_str(), 4 ) == 0 ) // transient mode, no GUI
 791   {
 792     CORBA::Object_var obj = SMESH_Gen_i::GetORB()->string_to_object( myID.c_str() );
 793     SetGroup( SMESH::SMESH_GroupBase::_narrow( obj ));
 794   }
 795   else if ( strncmp( "0:", myID.c_str(), 2 ) == 0 ) // transient mode + GUI
 796   {
 797     SMESH_Gen_i* aSMESHGen     = SMESH_Gen_i::GetSMESHGen();
 798     SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
 799     if ( !aStudy->_is_nil() ) {
 800       SALOMEDS::SObject_wrap aSObj = aStudy->FindObjectID( myID.c_str() );
 801       if ( !aSObj->_is_nil() ) {
 802         CORBA::Object_var obj = aSObj->GetObject();
 803         SetGroup( SMESH::SMESH_GroupBase::_narrow( obj ));
 804       }
 805     }
 806   }
 807   else if ( !myID.empty() ) // persistent mode
 808   {
 809     myBelongToMeshGroup->SetStoreName( myID );
 810   }
 811 }
 812
 813 std::string BelongToMeshGroup_i::GetGroupID()
 814 {
 815   if ( myGroup->_is_nil() )
 816     SMESH::SMESH_GroupBase_var( GetGroup() );
 817
 818   if ( !myGroup->_is_nil() )
 819     myID = SMESH_Gen_i::GetORB()->object_to_string( myGroup );
 820
 821   return myID;
 822 }
 823
 824 SMESH::SMESH_GroupBase_ptr BelongToMeshGroup_i::GetGroup()
 825 {
 826   if ( myGroup->_is_nil() && myBelongToMeshGroup->GetGroup() )
 827   {
 828     // search for a group in a current study
 829     SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 830     if ( StudyContext*  sc = aSMESHGen->GetCurrentStudyContext() )
 831     {
 832       int id = 1;
 833       std::string ior;
 834       while (true)
 835       {
 836         ior = sc->getIORbyId( id++ );
 837         if ( ior.empty() ) break;
 838         CORBA::Object_var obj = aSMESHGen->GetORB()->string_to_object( ior.c_str() );
 839         if ( SMESH_GroupBase_i* g_i = SMESH::DownCast<SMESH_GroupBase_i*>( obj ))
 840           if ( g_i->GetGroupDS() == myBelongToMeshGroup->GetGroup() )
 841           {
 842             SetGroup( g_i->_this() );
 843             break;
 844           }
 845       }
 846     }
 847   }
 848   return SMESH::SMESH_GroupBase::_duplicate( myGroup );
 849 }
 850
 851 FunctorType BelongToMeshGroup_i::GetFunctorType()
 852 {
 853   return SMESH::FT_BelongToMeshGroup;
 854 }
 855
 856 /*
 857   Class       : BelongToGeom_i
 858   Description : Predicate for selection on geometrical support
 859 */
 860 BelongToGeom_i::BelongToGeom_i()
 861 {
 862   myBelongToGeomPtr.reset( new Controls::BelongToGeom() );
 863   myFunctorPtr = myPredicatePtr = myBelongToGeomPtr;
 864   myShapeName = 0;
 865   myShapeID   = 0;
 866 }
 867
 868 BelongToGeom_i::~BelongToGeom_i()
 869 {
 870   CORBA::string_free( myShapeName );
 871   CORBA::string_free( myShapeID );
 872 }
 873
 874 void BelongToGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
 875 {
 876   if ( theGeom->_is_nil() )
 877     return;
 878   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 879   GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
 880   TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
 881   myBelongToGeomPtr->SetGeom( aLocShape );
 882   TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
 883 }
 884
 885 void BelongToGeom_i::SetGeom( const TopoDS_Shape& theShape )
 886 {
 887   myBelongToGeomPtr->SetGeom( theShape );
 888 }
 889
 890 void BelongToGeom_i::SetElementType(ElementType theType)
 891 {
 892   myBelongToGeomPtr->SetType(SMDSAbs_ElementType(theType));
 893   TPythonDump()<<this<<".SetElementType("<<theType<<")";
 894 }
 895
 896 FunctorType BelongToGeom_i::GetFunctorType()
 897 {
 898   return SMESH::FT_BelongToGeom;
 899 }
 900
 901 void BelongToGeom_i::SetShapeName( const char* theName )
 902 {
 903   CORBA::string_free( myShapeName );
 904   myShapeName = CORBA::string_dup( theName );
 905   myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
 906   TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
 907 }
 908
 909 void BelongToGeom_i::SetShape( const char* theID, const char* theName )
 910 {
 911   CORBA::string_free( myShapeName );
 912   CORBA::string_free( myShapeID );
 913   myShapeName = CORBA::string_dup( theName );
 914   myShapeID   = CORBA::string_dup( theID );
 915   bool hasName = ( theName && theName[0] );
 916   bool hasID   = ( theID   && theID[0] );
 917
 918   TopoDS_Shape S;
 919   if ( hasName && hasID )
 920   {
 921     S = getShapeByID( myShapeID );
 922     if ( S.IsNull() )
 923       S = getShapeByName( myShapeName );
 924   }
 925   else
 926   {
 927     S = hasID ? getShapeByID( myShapeID ) : getShapeByName( myShapeName );
 928   }
 929   myBelongToGeomPtr->SetGeom( S );
 930 }
 931
 932 char* BelongToGeom_i::GetShapeName()
 933 {
 934   return CORBA::string_dup( myShapeName );
 935 }
 936
 937 char* BelongToGeom_i::GetShapeID()
 938 {
 939   return CORBA::string_dup( myShapeID );
 940 }
 941
 942 void BelongToGeom_i::SetTolerance( CORBA::Double theToler )
 943 {
 944   myBelongToGeomPtr->SetTolerance( theToler );
 945   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
 946 }
 947
 948 CORBA::Double BelongToGeom_i::GetTolerance()
 949 {
 950   return myBelongToGeomPtr->GetTolerance();
 951 }
 952
 953 /*
 954   Class       : BelongToSurface_i
 955   Description : Predicate for selection on geometrical support
 956 */
 957 BelongToSurface_i::BelongToSurface_i( const Handle(Standard_Type)& theSurfaceType )
 958 {
 959   myElementsOnSurfacePtr.reset( new Controls::ElementsOnSurface() );
 960   myFunctorPtr = myPredicatePtr = myElementsOnSurfacePtr;
 961   myShapeName = 0;
 962   myShapeID   = 0;
 963   mySurfaceType = theSurfaceType;
 964 }
 965
 966 BelongToSurface_i::~BelongToSurface_i()
 967 {
 968   CORBA::string_free( myShapeName );
 969   CORBA::string_free( myShapeID );
 970 }
 971
 972 void BelongToSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
 973 {
 974   if ( theGeom->_is_nil() )
 975     return;
 976   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 977   GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
 978   TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
 979
 980   if ( aLocShape.ShapeType() == TopAbs_FACE )
 981   {
 982     Handle(Geom_Surface) aSurf = BRep_Tool::Surface( TopoDS::Face( aLocShape ) );
 983     if ( !aSurf.IsNull() && aSurf->DynamicType() == mySurfaceType )
 984     {
 985       myElementsOnSurfacePtr->SetSurface( aLocShape, (SMDSAbs_ElementType)theType );
 986       return;
 987     }
 988   }
 989
 990   myElementsOnSurfacePtr->SetSurface( TopoDS_Shape(), (SMDSAbs_ElementType)theType );
 991 }
 992
 993 void BelongToSurface_i::SetShapeName( const char* theName, ElementType theType )
 994 {
 995   CORBA::string_free( myShapeName );
 996   myShapeName = CORBA::string_dup( theName );
 997   myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
 998   TPythonDump()<<this<<".SetShapeName('"<<theName<<"',"<<theType<<")";
 999 }
1000
1001 void BelongToSurface_i::SetShape( const char* theID,  const char* theName, ElementType theType )
1002 {
1003   CORBA::string_free( myShapeName );
1004   CORBA::string_free( myShapeID );
1005   myShapeName = CORBA::string_dup( theName );
1006   myShapeID   = CORBA::string_dup( theID );
1007   bool hasName = ( theName && theName[0] );
1008   bool hasID   = ( theID   && theID[0] );
1009
1010   TopoDS_Shape S;
1011   if ( hasName && hasID )
1012   {
1013     S = getShapeByID( myShapeID );
1014     if ( S.IsNull() )
1015       S = getShapeByName( myShapeName );
1016   }
1017   else
1018   {
1019     S = hasID ? getShapeByID( myShapeID ) : getShapeByName( myShapeName );
1020   }
1021   myElementsOnSurfacePtr->SetSurface( S, (SMDSAbs_ElementType)theType );
1022 }
1023
1024 char* BelongToSurface_i::GetShapeName()
1025 {
1026   return CORBA::string_dup( myShapeName );
1027 }
1028
1029 char* BelongToSurface_i::GetShapeID()
1030 {
1031   return CORBA::string_dup( myShapeID );
1032 }
1033
1034 void BelongToSurface_i::SetTolerance( CORBA::Double theToler )
1035 {
1036   myElementsOnSurfacePtr->SetTolerance( theToler );
1037   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1038 }
1039
1040 CORBA::Double BelongToSurface_i::GetTolerance()
1041 {
1042   return myElementsOnSurfacePtr->GetTolerance();
1043 }
1044
1045 void BelongToSurface_i::SetUseBoundaries( CORBA::Boolean theUseBndRestrictions )
1046 {
1047   myElementsOnSurfacePtr->SetUseBoundaries( theUseBndRestrictions );
1048   TPythonDump()<<this<<".SetUseBoundaries( " << theUseBndRestrictions << " )";
1049 }
1050
1051 CORBA::Boolean BelongToSurface_i::GetUseBoundaries()
1052 {
1053   return myElementsOnSurfacePtr->GetUseBoundaries();
1054 }
1055
1056
1057 /*
1058   Class       : BelongToPlane_i
1059   Description : Verify whether mesh element lie in pointed Geom planar object
1060 */
1061
1062 BelongToPlane_i::BelongToPlane_i()
1063 : BelongToSurface_i( STANDARD_TYPE( Geom_Plane ) )
1064 {
1065 }
1066
1067 void BelongToPlane_i::SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
1068 {
1069   BelongToSurface_i::SetSurface( theGeom, theType );
1070   TPythonDump()<<this<<".SetPlane("<<theGeom<<","<<theType<<")";
1071 }
1072
1073 FunctorType BelongToPlane_i::GetFunctorType()
1074 {
1075   return FT_BelongToPlane;
1076 }
1077
1078 /*
1079   Class       : BelongToCylinder_i
1080   Description : Verify whether mesh element lie in pointed Geom planar object
1081 */
1082
1083 BelongToCylinder_i::BelongToCylinder_i()
1084 : BelongToSurface_i( STANDARD_TYPE( Geom_CylindricalSurface ) )
1085 {
1086 }
1087
1088 void BelongToCylinder_i::SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
1089 {
1090   BelongToSurface_i::SetSurface( theGeom, theType );
1091   TPythonDump()<<this<<".SetCylinder("<<theGeom<<","<<theType<<")";
1092 }
1093
1094 FunctorType BelongToCylinder_i::GetFunctorType()
1095 {
1096   return FT_BelongToCylinder;
1097 }
1098
1099 /*
1100   Class       : BelongToGenSurface_i
1101   Description : Verify whether mesh element lie in pointed Geom planar object
1102 */
1103
1104 BelongToGenSurface_i::BelongToGenSurface_i()
1105 : BelongToSurface_i( STANDARD_TYPE( Geom_CylindricalSurface ) )
1106 {
1107 }
1108
1109 void BelongToGenSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
1110 {
1111   if ( theGeom->_is_nil() )
1112     return;
1113   TopoDS_Shape aLocShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theGeom );
1114   if ( !aLocShape.IsNull() && aLocShape.ShapeType() != TopAbs_FACE )
1115     aLocShape.Nullify();
1116
1117   BelongToSurface_i::myElementsOnSurfacePtr->SetSurface( aLocShape, (SMDSAbs_ElementType)theType );
1118   TPythonDump()<<this<<".SetGenSurface("<<theGeom<<","<<theType<<")";
1119 }
1120
1121 FunctorType BelongToGenSurface_i::GetFunctorType()
1122 {
1123   return FT_BelongToGenSurface;
1124 }
1125
1126 /*
1127   Class       : LyingOnGeom_i
1128   Description : Predicate for selection on geometrical support
1129 */
1130 LyingOnGeom_i::LyingOnGeom_i()
1131 {
1132   myLyingOnGeomPtr.reset( new Controls::LyingOnGeom() );
1133   myFunctorPtr = myPredicatePtr = myLyingOnGeomPtr;
1134   myShapeName = 0;
1135   myShapeID = 0;
1136 }
1137
1138 LyingOnGeom_i::~LyingOnGeom_i()
1139 {
1140   CORBA::string_free( myShapeName );
1141   CORBA::string_free( myShapeID );
1142 }
1143
1144 void LyingOnGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
1145 {
1146   if ( theGeom->_is_nil() )
1147     return;
1148   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1149   GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
1150   TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
1151   myLyingOnGeomPtr->SetGeom( aLocShape );
1152   TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
1153 }
1154
1155 void LyingOnGeom_i::SetGeom( const TopoDS_Shape& theShape )
1156 {
1157   myLyingOnGeomPtr->SetGeom( theShape );
1158 }
1159
1160 void LyingOnGeom_i::SetElementType(ElementType theType){
1161   myLyingOnGeomPtr->SetType(SMDSAbs_ElementType(theType));
1162   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1163 }
1164
1165 FunctorType LyingOnGeom_i::GetFunctorType()
1166 {
1167   return SMESH::FT_LyingOnGeom;
1168 }
1169
1170 void LyingOnGeom_i::SetShapeName( const char* theName )
1171 {
1172   CORBA::string_free( myShapeName );
1173   myShapeName = CORBA::string_dup( theName );
1174   myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
1175   TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
1176 }
1177
1178 void LyingOnGeom_i::SetShape( const char* theID, const char* theName )
1179 {
1180   CORBA::string_free( myShapeName );
1181   CORBA::string_free( myShapeID   );
1182   myShapeName = CORBA::string_dup( theName );
1183   myShapeID   = CORBA::string_dup( theID   );
1184   bool hasName = ( theName && theName[0] );
1185   bool hasID   = ( theID   && theID[0]   );
1186
1187   TopoDS_Shape S;
1188   if ( hasName && hasID )
1189   {
1190     S = getShapeByID( myShapeID );
1191     if ( S.IsNull() )
1192       S = getShapeByName( myShapeName );
1193   }
1194   else
1195   {
1196     S = hasID ? getShapeByID( myShapeID ) : getShapeByName( myShapeName );
1197   }
1198   myLyingOnGeomPtr->SetGeom( S );
1199 }
1200
1201 char* LyingOnGeom_i::GetShapeName()
1202 {
1203   return CORBA::string_dup( myShapeName );
1204 }
1205
1206 char* LyingOnGeom_i::GetShapeID()
1207 {
1208   return CORBA::string_dup( myShapeID );
1209 }
1210
1211 void LyingOnGeom_i::SetTolerance( CORBA::Double theToler )
1212 {
1213   myLyingOnGeomPtr->SetTolerance( theToler );
1214   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1215 }
1216
1217 CORBA::Double LyingOnGeom_i::GetTolerance()
1218 {
1219   return myLyingOnGeomPtr->GetTolerance();
1220 }
1221
1222 /*
1223   Class       : FreeBorders_i
1224   Description : Predicate for free borders
1225 */
1226 FreeBorders_i::FreeBorders_i()
1227 {
1228   myPredicatePtr.reset(new Controls::FreeBorders());
1229   myFunctorPtr = myPredicatePtr;
1230 }
1231
1232 FunctorType FreeBorders_i::GetFunctorType()
1233 {
1234   return SMESH::FT_FreeBorders;
1235 }
1236
1237 /*
1238   Class       : FreeEdges_i
1239   Description : Predicate for free borders
1240 */
1241 FreeEdges_i::FreeEdges_i()
1242 : myFreeEdgesPtr( new Controls::FreeEdges() )
1243 {
1244   myFunctorPtr = myPredicatePtr = myFreeEdgesPtr;
1245 }
1246
1247 SMESH::FreeEdges::Borders* FreeEdges_i::GetBorders()
1248 {
1249   SMESH::Controls::FreeEdges::TBorders aBorders;
1250   myFreeEdgesPtr->GetBoreders( aBorders );
1251
1252   long i = 0, iEnd = aBorders.size();
1253
1254   SMESH::FreeEdges::Borders_var aResult = new SMESH::FreeEdges::Borders;
1255   aResult->length(iEnd);
1256
1257   SMESH::Controls::FreeEdges::TBorders::const_iterator anIter;
1258   for ( anIter = aBorders.begin() ; anIter != aBorders.end(); anIter++, i++ )
1259   {
1260     const SMESH::Controls::FreeEdges::Border&  aBord = *anIter;
1261     SMESH::FreeEdges::Border &aBorder = aResult[ i ];
1262
1263     aBorder.myElemId = aBord.myElemId;
1264     aBorder.myPnt1 = aBord.myPntId[ 0 ];
1265     aBorder.myPnt2 = aBord.myPntId[ 1 ];
1266   }
1267   return aResult._retn();
1268 }
1269
1270 FunctorType FreeEdges_i::GetFunctorType()
1271 {
1272   return SMESH::FT_FreeEdges;
1273 }
1274
1275 /*
1276   Class       : FreeFaces_i
1277   Description : Predicate for free faces
1278 */
1279 FreeFaces_i::FreeFaces_i()
1280 {
1281   myPredicatePtr.reset(new Controls::FreeFaces());
1282   myFunctorPtr = myPredicatePtr;
1283 }
1284
1285 FunctorType FreeFaces_i::GetFunctorType()
1286 {
1287   return SMESH::FT_FreeFaces;
1288 }
1289
1290 /*
1291   Class       : FreeNodes_i
1292   Description : Predicate for free nodes
1293 */
1294 FreeNodes_i::FreeNodes_i()
1295 {
1296   myPredicatePtr.reset(new Controls::FreeNodes());
1297   myFunctorPtr = myPredicatePtr;
1298 }
1299
1300 FunctorType FreeNodes_i::GetFunctorType()
1301 {
1302   return SMESH::FT_FreeNodes;
1303 }
1304
1305 /*
1306   Class       : EqualNodes_i
1307   Description : Predicate for Equal nodes
1308 */
1309 EqualNodes_i::EqualNodes_i()
1310 {
1311   myCoincidentNodesPtr.reset(new Controls::CoincidentNodes());
1312   myFunctorPtr = myPredicatePtr = myCoincidentNodesPtr;
1313 }
1314
1315 FunctorType EqualNodes_i::GetFunctorType()
1316 {
1317   return SMESH::FT_EqualNodes;
1318 }
1319
1320 void EqualNodes_i::SetTolerance( double tol )
1321 {
1322   myCoincidentNodesPtr->SetTolerance( tol );
1323 }
1324
1325 double EqualNodes_i::GetTolerance()
1326 {
1327   return myCoincidentNodesPtr->GetTolerance();
1328 }
1329
1330 /*
1331   Class       : EqualEdges_i
1332   Description : Predicate for Equal Edges
1333 */
1334 EqualEdges_i::EqualEdges_i()
1335 {
1336   myPredicatePtr.reset(new Controls::CoincidentElements1D());
1337   myFunctorPtr = myPredicatePtr;
1338 }
1339
1340 FunctorType EqualEdges_i::GetFunctorType()
1341 {
1342   return SMESH::FT_EqualEdges;
1343 }
1344
1345 /*
1346   Class       : EqualFaces_i
1347   Description : Predicate for Equal Faces
1348 */
1349 EqualFaces_i::EqualFaces_i()
1350 {
1351   myPredicatePtr.reset(new Controls::CoincidentElements2D());
1352   myFunctorPtr = myPredicatePtr;
1353 }
1354
1355 FunctorType EqualFaces_i::GetFunctorType()
1356 {
1357   return SMESH::FT_EqualFaces;
1358 }
1359
1360 /*
1361   Class       : EqualVolumes_i
1362   Description : Predicate for Equal Volumes
1363 */
1364 EqualVolumes_i::EqualVolumes_i()
1365 {
1366   myPredicatePtr.reset(new Controls::CoincidentElements3D());
1367   myFunctorPtr = myPredicatePtr;
1368 }
1369
1370 FunctorType EqualVolumes_i::GetFunctorType()
1371 {
1372   return SMESH::FT_EqualVolumes;
1373 }
1374
1375
1376 /*
1377   Class       : RangeOfIds_i
1378   Description : Predicate for Range of Ids.
1379                 Range may be specified with two ways.
1380                 1. Using AddToRange method
1381                 2. With SetRangeStr method. Parameter of this method is a string
1382                    like as "1,2,3,50-60,63,67,70-"
1383 */
1384
1385 RangeOfIds_i::RangeOfIds_i()
1386 {
1387   myRangeOfIdsPtr.reset( new Controls::RangeOfIds() );
1388   myFunctorPtr = myPredicatePtr = myRangeOfIdsPtr;
1389 }
1390
1391 void RangeOfIds_i::SetRange( const SMESH::long_array& theIds )
1392 {
1393   CORBA::Long iEnd = theIds.length();
1394   for ( CORBA::Long i = 0; i < iEnd; i++ )
1395     myRangeOfIdsPtr->AddToRange( theIds[ i ] );
1396   TPythonDump()<<this<<".SetRange("<<theIds<<")";
1397 }
1398
1399 CORBA::Boolean RangeOfIds_i::SetRangeStr( const char* theRange )
1400 {
1401   TPythonDump()<<this<<".SetRangeStr('"<<theRange<<"')";
1402   return myRangeOfIdsPtr->SetRangeStr(
1403     TCollection_AsciiString( (Standard_CString)theRange ) );
1404 }
1405
1406 char* RangeOfIds_i::GetRangeStr()
1407 {
1408   TCollection_AsciiString aStr;
1409   myRangeOfIdsPtr->GetRangeStr( aStr );
1410   return CORBA::string_dup( aStr.ToCString() );
1411 }
1412
1413 void RangeOfIds_i::SetElementType( ElementType theType )
1414 {
1415   myRangeOfIdsPtr->SetType( SMDSAbs_ElementType( theType ) );
1416   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1417 }
1418
1419 FunctorType RangeOfIds_i::GetFunctorType()
1420 {
1421   return SMESH::FT_RangeOfIds;
1422 }
1423
1424 /*
1425   Class       : LinearOrQuadratic_i
1426   Description : Predicate to verify whether a mesh element is linear
1427 */
1428 LinearOrQuadratic_i::LinearOrQuadratic_i()
1429 {
1430   myLinearOrQuadraticPtr.reset(new Controls::LinearOrQuadratic());
1431   myFunctorPtr = myPredicatePtr = myLinearOrQuadraticPtr;
1432 }
1433
1434 void LinearOrQuadratic_i::SetElementType(ElementType theType)
1435 {
1436   myLinearOrQuadraticPtr->SetType(SMDSAbs_ElementType(theType));
1437   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1438 }
1439
1440 FunctorType LinearOrQuadratic_i::GetFunctorType()
1441 {
1442   return SMESH::FT_LinearOrQuadratic;
1443 }
1444
1445 /*
1446   Class       : GroupColor_i
1447   Description : Functor for check color of group to which mesh element belongs to
1448 */
1449 GroupColor_i::GroupColor_i()
1450 {
1451   myGroupColorPtr.reset(new Controls::GroupColor());
1452   myFunctorPtr = myPredicatePtr = myGroupColorPtr;
1453 }
1454
1455 FunctorType GroupColor_i::GetFunctorType()
1456 {
1457   return SMESH::FT_GroupColor;
1458 }
1459
1460 void GroupColor_i::SetColorStr( const char* theColor )
1461 {
1462   myGroupColorPtr->SetColorStr(
1463     TCollection_AsciiString( (Standard_CString)theColor ) );
1464   TPythonDump()<<this<<".SetColorStr('"<<theColor<<"')";
1465 }
1466
1467 char* GroupColor_i::GetColorStr()
1468 {
1469   TCollection_AsciiString aStr;
1470   myGroupColorPtr->GetColorStr( aStr );
1471   return CORBA::string_dup( aStr.ToCString() );
1472 }
1473
1474 void GroupColor_i::SetElementType(ElementType theType)
1475 {
1476   myGroupColorPtr->SetType(SMDSAbs_ElementType(theType));
1477   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1478 }
1479
1480 /*
1481   Class       : ElemGeomType_i
1482   Description : Predicate check is element has indicated geometry type
1483 */
1484 ElemGeomType_i::ElemGeomType_i()
1485 {
1486   myElemGeomTypePtr.reset(new Controls::ElemGeomType());
1487   myFunctorPtr = myPredicatePtr = myElemGeomTypePtr;
1488 }
1489
1490 void ElemGeomType_i::SetElementType(ElementType theType)
1491 {
1492   myElemGeomTypePtr->SetType(SMDSAbs_ElementType(theType));
1493   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1494 }
1495
1496 void ElemGeomType_i::SetGeometryType(GeometryType theType)
1497 {
1498   myElemGeomTypePtr->SetGeomType(SMDSAbs_GeometryType(theType));
1499   TPythonDump()<<this<<".SetGeometryType("<<theType<<")";
1500 }
1501
1502 GeometryType ElemGeomType_i::GetGeometryType() const
1503 {
1504   return (GeometryType)myElemGeomTypePtr->GetGeomType();
1505 }
1506
1507 FunctorType ElemGeomType_i::GetFunctorType()
1508 {
1509   return SMESH::FT_ElemGeomType;
1510 }
1511
1512 /*
1513   Class       : ElemEntityType_i
1514   Description : Predicate check is element has indicated entity type
1515 */
1516 ElemEntityType_i::ElemEntityType_i()
1517 {
1518   myElemEntityTypePtr.reset(new Controls::ElemEntityType());
1519   myFunctorPtr = myPredicatePtr = myElemEntityTypePtr;
1520 }
1521
1522 void ElemEntityType_i::SetElementType(ElementType theType)
1523 {
1524   myElemEntityTypePtr->SetType(SMDSAbs_ElementType(theType));
1525   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1526 }
1527
1528 void ElemEntityType_i::SetEntityType(EntityType theEntityType)
1529 {
1530   myElemEntityTypePtr->SetElemEntityType(SMDSAbs_EntityType (theEntityType));
1531   TPythonDump()<<this<<".SetEntityType("<<theEntityType<<")";
1532 }
1533 EntityType ElemEntityType_i::GetEntityType() const
1534 {
1535  return (EntityType) myElemEntityTypePtr->GetElemEntityType();
1536 }
1537
1538 FunctorType ElemEntityType_i::GetFunctorType()
1539 {
1540   return SMESH::FT_EntityType;
1541 }
1542
1543 /*
1544   Class       : CoplanarFaces_i
1545   Description : Returns true if a mesh face is a coplanar neighbour to a given one
1546 */
1547 CoplanarFaces_i::CoplanarFaces_i()
1548 {
1549   myCoplanarFacesPtr.reset(new Controls::CoplanarFaces());
1550   myFunctorPtr = myPredicatePtr = myCoplanarFacesPtr;
1551 }
1552
1553 void CoplanarFaces_i::SetFace ( CORBA::Long theFaceID )
1554 {
1555   myCoplanarFacesPtr->SetFace(theFaceID);
1556   TPythonDump()<<this<<".SetFace("<<theFaceID<<")";
1557 }
1558
1559 void CoplanarFaces_i::SetTolerance( CORBA::Double theToler )
1560 {
1561   myCoplanarFacesPtr->SetTolerance(theToler);
1562   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1563 }
1564
1565 CORBA::Long CoplanarFaces_i::GetFace () const
1566 {
1567   return myCoplanarFacesPtr->GetFace();
1568 }
1569
1570 char* CoplanarFaces_i::GetFaceAsString () const
1571 {
1572   TCollection_AsciiString str(Standard_Integer(myCoplanarFacesPtr->GetFace()));
1573   return CORBA::string_dup( str.ToCString() );
1574 }
1575
1576 CORBA::Double CoplanarFaces_i::GetTolerance() const
1577 {
1578   return myCoplanarFacesPtr->GetTolerance();
1579 }
1580
1581 FunctorType CoplanarFaces_i::GetFunctorType()
1582 {
1583   return SMESH::FT_CoplanarFaces;
1584 }
1585
1586 /*
1587  * Class       : ConnectedElements_i
1588  * Description : Returns true if an element is connected via other elements to the element
1589  *               located at a given point.
1590  */
1591 ConnectedElements_i::ConnectedElements_i()
1592 {
1593   myConnectedElementsPtr.reset(new Controls::ConnectedElements());
1594   myFunctorPtr = myPredicatePtr = myConnectedElementsPtr;
1595 }
1596
1597 FunctorType ConnectedElements_i::GetFunctorType()
1598 {
1599   return FT_ConnectedElements;
1600 }
1601
1602 void ConnectedElements_i::SetElementType( ElementType theType )
1603 {
1604   myConnectedElementsPtr->SetType( SMDSAbs_ElementType( theType ));
1605   TPythonDump() << this << ".SetElementType( " << theType << " )";
1606 }
1607
1608 void ConnectedElements_i::SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Double z )
1609 {
1610   myConnectedElementsPtr->SetPoint( x,y,z );
1611   myVertexID.clear();
1612   TPythonDump() << this << ".SetPoint( " << x << ", " << y << ", " << z << " )";
1613 }
1614
1615 void ConnectedElements_i::SetVertex( GEOM::GEOM_Object_ptr vertex )
1616   throw (SALOME::SALOME_Exception)
1617 {
1618   TopoDS_Shape shape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( vertex );
1619   if ( shape.IsNull() )
1620     THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetVertex(): NULL Vertex",
1621                                   SALOME::BAD_PARAM );
1622
1623   TopExp_Explorer v( shape, TopAbs_VERTEX );
1624   if ( !v.More() )
1625     THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetVertex(): empty vertex",
1626                                   SALOME::BAD_PARAM );
1627
1628   gp_Pnt p = BRep_Tool::Pnt( TopoDS::Vertex( v.Current() ));
1629   myConnectedElementsPtr->SetPoint( p.X(), p.Y(), p.Z() );
1630   //
1631   CORBA::String_var id = vertex->GetStudyEntry();
1632   myVertexID = id.in();
1633
1634   TPythonDump() << this << ".SetVertex( " << vertex << " )";
1635 }
1636
1637 void ConnectedElements_i::SetNode ( CORBA::Long nodeID )
1638   throw (SALOME::SALOME_Exception)
1639 {
1640   if ( nodeID < 1 )
1641     THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetNode(): nodeID must be > 0",
1642                                   SALOME::BAD_PARAM );
1643
1644   myConnectedElementsPtr->SetNode( nodeID );
1645   myVertexID.clear();
1646   TPythonDump() << this << ".SetNode( " << nodeID << " )";
1647 }
1648
1649 /*!
1650  * \brief This is a comfort method for Filter dialog
1651  */
1652 void ConnectedElements_i::SetThreshold ( const char*                             threshold,
1653                                          SMESH::ConnectedElements::ThresholdType type )
1654   throw (SALOME::SALOME_Exception)
1655 {
1656   if ( !threshold )
1657     THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetThreshold(): NULL threshold",
1658                                   SALOME::BAD_PARAM );
1659   switch ( type )
1660   {
1661   case SMESH::ConnectedElements::POINT: // read 3 node coordinates ///////////////////
1662     {
1663       std::vector< double > xyz;
1664       char* endptr;
1665       do
1666       {
1667         // skip a separator
1668         while ( *threshold &&
1669                 *threshold != '+' &&
1670                 *threshold != '-' &&
1671                 !isdigit( *threshold ))
1672           ++threshold;
1673         if ( !*threshold )
1674           break;
1675         // read a coordinate
1676         xyz.push_back( strtod( threshold, &endptr ));
1677         if ( threshold == endptr )
1678         {
1679           xyz.resize( xyz.size() - 1 );
1680           break;
1681         }
1682         threshold = endptr;
1683       }
1684       while ( xyz.size() < 3 );
1685
1686       if ( xyz.size() < 3 )
1687         THROW_SALOME_CORBA_EXCEPTION
1688           ( "ConnectedElements_i::SetThreshold(): invalid point coordinates", SALOME::BAD_PARAM );
1689
1690       SetPoint( xyz[0], xyz[1], xyz[2] );
1691       break;
1692     }
1693   case SMESH::ConnectedElements::VERTEX: // get a VERTEX by its entry /////////////////
1694     {
1695       SALOMEDS::Study_var study = SMESH_Gen_i::GetSMESHGen()->GetCurrentStudy();
1696       if ( study->_is_nil() )
1697         THROW_SALOME_CORBA_EXCEPTION
1698           ( "ConnectedElements_i::SetThreshold(): NULL current study", SALOME::BAD_PARAM );
1699       SALOMEDS::SObject_wrap sobj = study->FindObjectID( threshold );
1700       if ( sobj->_is_nil() )
1701         THROW_SALOME_CORBA_EXCEPTION
1702           ( "ConnectedElements_i::SetThreshold(): invalid vertex study entry", SALOME::BAD_PARAM );
1703       CORBA::Object_var        obj = sobj->GetObject();
1704       GEOM::GEOM_Object_var vertex = GEOM::GEOM_Object::_narrow( obj );
1705       if ( vertex->_is_nil() )
1706         THROW_SALOME_CORBA_EXCEPTION
1707           ( "ConnectedElements_i::SetThreshold(): no GEOM_Object in SObject", SALOME::BAD_PARAM );
1708       SetVertex( vertex );
1709       break;
1710     }
1711   case SMESH::ConnectedElements::NODE: // read a node ID ////////////////////////////
1712     {
1713       char* endptr;
1714       int id = strtol( threshold, &endptr, 10 );
1715       if ( threshold == endptr )
1716         THROW_SALOME_CORBA_EXCEPTION
1717           ( "ConnectedElements_i::SetThreshold(): invalid node ID", SALOME::BAD_PARAM );
1718       SetNode( id );
1719       break;
1720     }
1721   default:
1722     THROW_SALOME_CORBA_EXCEPTION
1723       ( "ConnectedElements_i::SetThreshold(): invalid ThresholdType", SALOME::BAD_PARAM );
1724   }
1725 }
1726
1727 char* ConnectedElements_i::GetThreshold ( SMESH::ConnectedElements::ThresholdType& type )
1728 {
1729   std::string threshold;
1730   if ( !myVertexID.empty() )
1731   {
1732     threshold = myVertexID;
1733     type      = SMESH::ConnectedElements::VERTEX;
1734   }
1735   else
1736   {
1737     std::vector<double> xyz = myConnectedElementsPtr->GetPoint();
1738     if ( xyz.size() == 3 )
1739     {
1740       threshold = SMESH_Comment( xyz[0] ) << "; " << xyz[1] << "; " << xyz[2];
1741       type      = SMESH::ConnectedElements::POINT;
1742     }
1743     else
1744     {
1745       threshold = SMESH_Comment( myConnectedElementsPtr->GetNode() );
1746       type      = SMESH::ConnectedElements::NODE;
1747     }
1748   }
1749   return CORBA::string_dup( threshold.c_str() );
1750 }
1751
1752 /*
1753   Class       : Comparator_i
1754   Description : Base class for comparators
1755 */
1756 Comparator_i::Comparator_i():
1757   myNumericalFunctor( NULL )
1758 {}
1759
1760 Comparator_i::~Comparator_i()
1761 {
1762   if ( myNumericalFunctor )
1763     myNumericalFunctor->UnRegister();
1764 }
1765
1766 void Comparator_i::SetMargin( CORBA::Double theValue )
1767 {
1768   myComparatorPtr->SetMargin( theValue );
1769   TPythonDump()<<this<<".SetMargin("<<theValue<<")";
1770 }
1771
1772 CORBA::Double Comparator_i::GetMargin()
1773 {
1774   return myComparatorPtr->GetMargin();
1775 }
1776
1777 void Comparator_i::SetNumFunctor( NumericalFunctor_ptr theFunct )
1778 {
1779   if ( myNumericalFunctor )
1780     myNumericalFunctor->UnRegister();
1781
1782   myNumericalFunctor = DownCast<NumericalFunctor_i*>(theFunct);
1783
1784   if ( myNumericalFunctor )
1785   {
1786     myComparatorPtr->SetNumFunctor( myNumericalFunctor->GetNumericalFunctor() );
1787     myNumericalFunctor->Register();
1788     TPythonDump()<<this<<".SetNumFunctor("<<myNumericalFunctor<<")";
1789   }
1790 }
1791
1792 Controls::ComparatorPtr Comparator_i::GetComparator()
1793 {
1794   return myComparatorPtr;
1795 }
1796
1797 NumericalFunctor_i* Comparator_i::GetNumFunctor_i()
1798 {
1799   return myNumericalFunctor;
1800 }
1801
1802
1803 /*
1804   Class       : LessThan_i
1805   Description : Comparator "<"
1806 */
1807 LessThan_i::LessThan_i()
1808 {
1809   myComparatorPtr.reset( new Controls::LessThan() );
1810   myFunctorPtr = myPredicatePtr = myComparatorPtr;
1811 }
1812
1813 FunctorType LessThan_i::GetFunctorType()
1814 {
1815   return SMESH::FT_LessThan;
1816 }
1817
1818
1819 /*
1820   Class       : MoreThan_i
1821   Description : Comparator ">"
1822 */
1823 MoreThan_i::MoreThan_i()
1824 {
1825   myComparatorPtr.reset( new Controls::MoreThan() );
1826   myFunctorPtr = myPredicatePtr = myComparatorPtr;
1827 }
1828
1829 FunctorType MoreThan_i::GetFunctorType()
1830 {
1831   return SMESH::FT_MoreThan;
1832 }
1833
1834
1835 /*
1836   Class       : EqualTo_i
1837   Description : Comparator "="
1838 */
1839 EqualTo_i::EqualTo_i()
1840 : myEqualToPtr( new Controls::EqualTo() )
1841 {
1842   myFunctorPtr = myPredicatePtr = myComparatorPtr = myEqualToPtr;
1843 }
1844
1845 void EqualTo_i::SetTolerance( CORBA::Double theToler )
1846 {
1847   myEqualToPtr->SetTolerance( theToler );
1848   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1849 }
1850
1851 CORBA::Double EqualTo_i::GetTolerance()
1852 {
1853   return myEqualToPtr->GetTolerance();
1854 }
1855
1856 FunctorType EqualTo_i::GetFunctorType()
1857 {
1858   return SMESH::FT_EqualTo;
1859 }
1860
1861 /*
1862   Class       : LogicalNOT_i
1863   Description : Logical NOT predicate
1864 */
1865 LogicalNOT_i::LogicalNOT_i():
1866   myLogicalNOTPtr( new Controls::LogicalNOT() ),
1867   myPredicate( NULL )
1868 {
1869   myFunctorPtr = myPredicatePtr = myLogicalNOTPtr;
1870 }
1871
1872 LogicalNOT_i::~LogicalNOT_i()
1873 {
1874   if ( myPredicate )
1875     myPredicate->UnRegister();
1876 }
1877
1878 void LogicalNOT_i::SetPredicate( Predicate_ptr thePredicate )
1879 {
1880   if ( myPredicate )
1881     myPredicate->UnRegister();
1882
1883   myPredicate = SMESH::GetPredicate(thePredicate);
1884
1885   if ( myPredicate ){
1886     myLogicalNOTPtr->SetPredicate(myPredicate->GetPredicate());
1887     myPredicate->Register();
1888     TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
1889   }
1890 }
1891
1892 FunctorType LogicalNOT_i::GetFunctorType()
1893 {
1894   return SMESH::FT_LogicalNOT;
1895 }
1896
1897 Predicate_i* LogicalNOT_i::GetPredicate_i()
1898 {
1899   return myPredicate;
1900 }
1901
1902
1903
1904 /*
1905   Class       : LogicalBinary_i
1906   Description : Base class for binary logical predicate
1907 */
1908 LogicalBinary_i::LogicalBinary_i()
1909 : myPredicate1( NULL ),
1910   myPredicate2( NULL )
1911 {}
1912
1913 LogicalBinary_i::~LogicalBinary_i()
1914 {
1915   if ( myPredicate1 )
1916     myPredicate1->UnRegister();
1917
1918   if ( myPredicate2 )
1919     myPredicate2->UnRegister();
1920 }
1921
1922 void LogicalBinary_i::SetMesh( SMESH_Mesh_ptr theMesh )
1923 {
1924   if ( myPredicate1 )
1925     myPredicate1->SetMesh( theMesh );
1926
1927   if ( myPredicate2 )
1928     myPredicate2->SetMesh( theMesh );
1929 }
1930
1931 void LogicalBinary_i::SetPredicate1( Predicate_ptr thePredicate )
1932 {
1933   if ( myPredicate1 )
1934     myPredicate1->UnRegister();
1935
1936   myPredicate1 = SMESH::GetPredicate(thePredicate);
1937
1938   if ( myPredicate1 ){
1939     myLogicalBinaryPtr->SetPredicate1(myPredicate1->GetPredicate());
1940     myPredicate1->Register();
1941     TPythonDump()<<this<<".SetPredicate1("<<myPredicate1<<")";
1942   }
1943 }
1944
1945 void LogicalBinary_i::SetPredicate2( Predicate_ptr thePredicate )
1946 {
1947   if ( myPredicate2 )
1948     myPredicate2->UnRegister();
1949
1950   myPredicate2 = SMESH::GetPredicate(thePredicate);
1951
1952   if ( myPredicate2 ){
1953     myLogicalBinaryPtr->SetPredicate2(myPredicate2->GetPredicate());
1954     myPredicate2->Register();
1955     TPythonDump()<<this<<".SetPredicate2("<<myPredicate2<<")";
1956   }
1957 }
1958
1959 Controls::LogicalBinaryPtr LogicalBinary_i::GetLogicalBinary()
1960 {
1961   return myLogicalBinaryPtr;
1962 }
1963
1964 Predicate_i* LogicalBinary_i::GetPredicate1_i()
1965 {
1966   return myPredicate1;
1967 }
1968 Predicate_i* LogicalBinary_i::GetPredicate2_i()
1969 {
1970   return myPredicate2;
1971 }
1972
1973
1974 /*
1975   Class       : LogicalAND_i
1976   Description : Logical AND
1977 */
1978 LogicalAND_i::LogicalAND_i()
1979 {
1980   myLogicalBinaryPtr.reset( new Controls::LogicalAND() );
1981   myFunctorPtr = myPredicatePtr = myLogicalBinaryPtr;
1982 }
1983
1984 FunctorType LogicalAND_i::GetFunctorType()
1985 {
1986   return SMESH::FT_LogicalAND;
1987 }
1988
1989
1990 /*
1991   Class       : LogicalOR_i
1992   Description : Logical OR
1993 */
1994 LogicalOR_i::LogicalOR_i()
1995 {
1996   myLogicalBinaryPtr.reset( new Controls::LogicalOR() );
1997   myFunctorPtr = myPredicatePtr = myLogicalBinaryPtr;
1998 }
1999
2000 FunctorType LogicalOR_i::GetFunctorType()
2001 {
2002   return SMESH::FT_LogicalOR;
2003 }
2004
2005
2006 /*
2007                             FILTER MANAGER
2008 */
2009
2010 FilterManager_i::FilterManager_i()
2011 : SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
2012 {
2013   //Base class Salome_GenericObject do it inmplicitly by overriding PortableServer::POA_ptr _default_POA() method
2014   //PortableServer::ObjectId_var anObjectId =
2015   //  SMESH_Gen_i::GetPOA()->activate_object( this );
2016 }
2017
2018
2019 FilterManager_i::~FilterManager_i()
2020 {
2021   //TPythonDump()<<this<<".UnRegister()";
2022 }
2023
2024
2025 MinimumAngle_ptr FilterManager_i::CreateMinimumAngle()
2026 {
2027   SMESH::MinimumAngle_i* aServant = new SMESH::MinimumAngle_i();
2028   SMESH::MinimumAngle_var anObj = aServant->_this();
2029   TPythonDump()<<aServant<<" = "<<this<<".CreateMinimumAngle()";
2030   return anObj._retn();
2031 }
2032
2033
2034 AspectRatio_ptr FilterManager_i::CreateAspectRatio()
2035 {
2036   SMESH::AspectRatio_i* aServant = new SMESH::AspectRatio_i();
2037   SMESH::AspectRatio_var anObj = aServant->_this();
2038   TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio()";
2039   return anObj._retn();
2040 }
2041
2042
2043 AspectRatio3D_ptr FilterManager_i::CreateAspectRatio3D()
2044 {
2045   SMESH::AspectRatio3D_i* aServant = new SMESH::AspectRatio3D_i();
2046   SMESH::AspectRatio3D_var anObj = aServant->_this();
2047   TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio3D()";
2048   return anObj._retn();
2049 }
2050
2051
2052 Warping_ptr FilterManager_i::CreateWarping()
2053 {
2054   SMESH::Warping_i* aServant = new SMESH::Warping_i();
2055   SMESH::Warping_var anObj = aServant->_this();
2056   TPythonDump()<<aServant<<" = "<<this<<".CreateWarping()";
2057   return anObj._retn();
2058 }
2059
2060
2061 Taper_ptr FilterManager_i::CreateTaper()
2062 {
2063   SMESH::Taper_i* aServant = new SMESH::Taper_i();
2064   SMESH::Taper_var anObj = aServant->_this();
2065   TPythonDump()<<aServant<<" = "<<this<<".CreateTaper()";
2066   return anObj._retn();
2067 }
2068
2069
2070 Skew_ptr FilterManager_i::CreateSkew()
2071 {
2072   SMESH::Skew_i* aServant = new SMESH::Skew_i();
2073   SMESH::Skew_var anObj = aServant->_this();
2074   TPythonDump()<<aServant<<" = "<<this<<".CreateSkew()";
2075   return anObj._retn();
2076 }
2077
2078
2079 Area_ptr FilterManager_i::CreateArea()
2080 {
2081   SMESH::Area_i* aServant = new SMESH::Area_i();
2082   SMESH::Area_var anObj = aServant->_this();
2083   TPythonDump()<<aServant<<" = "<<this<<".CreateArea()";
2084   return anObj._retn();
2085 }
2086
2087
2088 Volume3D_ptr FilterManager_i::CreateVolume3D()
2089 {
2090   SMESH::Volume3D_i* aServant = new SMESH::Volume3D_i();
2091   SMESH::Volume3D_var anObj = aServant->_this();
2092   TPythonDump()<<aServant<<" = "<<this<<".CreateVolume3D()";
2093   return anObj._retn();
2094 }
2095
2096
2097 MaxElementLength2D_ptr FilterManager_i::CreateMaxElementLength2D()
2098 {
2099   SMESH::MaxElementLength2D_i* aServant = new SMESH::MaxElementLength2D_i();
2100   SMESH::MaxElementLength2D_var anObj = aServant->_this();
2101   TPythonDump()<<aServant<<" = "<<this<<".CreateMaxElementLength2D()";
2102   return anObj._retn();
2103 }
2104
2105
2106 MaxElementLength3D_ptr FilterManager_i::CreateMaxElementLength3D()
2107 {
2108   SMESH::MaxElementLength3D_i* aServant = new SMESH::MaxElementLength3D_i();
2109   SMESH::MaxElementLength3D_var anObj = aServant->_this();
2110   TPythonDump()<<aServant<<" = "<<this<<".CreateMaxElementLength3D()";
2111   return anObj._retn();
2112 }
2113
2114
2115 Length_ptr FilterManager_i::CreateLength()
2116 {
2117   SMESH::Length_i* aServant = new SMESH::Length_i();
2118   SMESH::Length_var anObj = aServant->_this();
2119   TPythonDump()<<aServant<<" = "<<this<<".CreateLength()";
2120   return anObj._retn();
2121 }
2122
2123 Length2D_ptr FilterManager_i::CreateLength2D()
2124 {
2125   SMESH::Length2D_i* aServant = new SMESH::Length2D_i();
2126   SMESH::Length2D_var anObj = aServant->_this();
2127   TPythonDump()<<aServant<<" = "<<this<<".CreateLength2D()";
2128   return anObj._retn();
2129 }
2130
2131 Deflection2D_ptr FilterManager_i::CreateDeflection2D()
2132 {
2133   SMESH::Deflection2D_i* aServant = new SMESH::Deflection2D_i();
2134   SMESH::Deflection2D_var   anObj = aServant->_this();
2135   TPythonDump()<<aServant<<" = "<<this<<".CreateLength2D()";
2136   return anObj._retn();
2137 }
2138
2139 MultiConnection_ptr FilterManager_i::CreateMultiConnection()
2140 {
2141   SMESH::MultiConnection_i* aServant = new SMESH::MultiConnection_i();
2142   SMESH::MultiConnection_var anObj = aServant->_this();
2143   TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection()";
2144   return anObj._retn();
2145 }
2146
2147 MultiConnection2D_ptr FilterManager_i::CreateMultiConnection2D()
2148 {
2149   SMESH::MultiConnection2D_i* aServant = new SMESH::MultiConnection2D_i();
2150   SMESH::MultiConnection2D_var anObj = aServant->_this();
2151   TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection2D()";
2152   return anObj._retn();
2153 }
2154
2155 BallDiameter_ptr FilterManager_i::CreateBallDiameter()
2156 {
2157   SMESH::BallDiameter_i* aServant = new SMESH::BallDiameter_i();
2158   SMESH::BallDiameter_var anObj = aServant->_this();
2159   TPythonDump()<<aServant<<" = "<<this<<".CreateBallDiameter()";
2160   return anObj._retn();
2161 }
2162
2163 NodeConnectivityNumber_ptr FilterManager_i::CreateNodeConnectivityNumber()
2164 {
2165   SMESH::NodeConnectivityNumber_i* aServant = new SMESH::NodeConnectivityNumber_i();
2166   SMESH::NodeConnectivityNumber_var anObj = aServant->_this();
2167   TPythonDump()<<aServant<<" = "<<this<<".CreateNodeConnectivityNumber()";
2168   return anObj._retn();
2169 }
2170
2171 BelongToMeshGroup_ptr FilterManager_i::CreateBelongToMeshGroup()
2172 {
2173   SMESH::BelongToMeshGroup_i* aServant = new SMESH::BelongToMeshGroup_i();
2174   SMESH::BelongToMeshGroup_var anObj = aServant->_this();
2175   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToMeshGroup()";
2176   return anObj._retn();
2177 }
2178
2179 BelongToGeom_ptr FilterManager_i::CreateBelongToGeom()
2180 {
2181   SMESH::BelongToGeom_i* aServant = new SMESH::BelongToGeom_i();
2182   SMESH::BelongToGeom_var anObj = aServant->_this();
2183   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToGeom()";
2184   return anObj._retn();
2185 }
2186
2187 BelongToPlane_ptr FilterManager_i::CreateBelongToPlane()
2188 {
2189   SMESH::BelongToPlane_i* aServant = new SMESH::BelongToPlane_i();
2190   SMESH::BelongToPlane_var anObj = aServant->_this();
2191   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToPlane()";
2192   return anObj._retn();
2193 }
2194
2195 BelongToCylinder_ptr FilterManager_i::CreateBelongToCylinder()
2196 {
2197   SMESH::BelongToCylinder_i* aServant = new SMESH::BelongToCylinder_i();
2198   SMESH::BelongToCylinder_var anObj = aServant->_this();
2199   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToCylinder()";
2200   return anObj._retn();
2201 }
2202
2203 BelongToGenSurface_ptr FilterManager_i::CreateBelongToGenSurface()
2204 {
2205   SMESH::BelongToGenSurface_i* aServant = new SMESH::BelongToGenSurface_i();
2206   SMESH::BelongToGenSurface_var anObj = aServant->_this();
2207   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToGenSurface()";
2208   return anObj._retn();
2209 }
2210
2211 LyingOnGeom_ptr FilterManager_i::CreateLyingOnGeom()
2212 {
2213   SMESH::LyingOnGeom_i* aServant = new SMESH::LyingOnGeom_i();
2214   SMESH::LyingOnGeom_var anObj = aServant->_this();
2215   TPythonDump()<<aServant<<" = "<<this<<".CreateLyingOnGeom()";
2216   return anObj._retn();
2217 }
2218
2219 CoplanarFaces_ptr FilterManager_i::CreateCoplanarFaces()
2220 {
2221   SMESH::CoplanarFaces_i* aServant = new SMESH::CoplanarFaces_i();
2222   SMESH::CoplanarFaces_var anObj = aServant->_this();
2223   TPythonDump()<<aServant<<" = "<<this<<".CreateCoplanarFaces()";
2224   return anObj._retn();
2225 }
2226
2227 ConnectedElements_ptr FilterManager_i::CreateConnectedElements()
2228 {
2229   SMESH::ConnectedElements_i* aServant = new SMESH::ConnectedElements_i();
2230   SMESH::ConnectedElements_var anObj = aServant->_this();
2231   TPythonDump()<<aServant<<" = "<<this<<".CreateConnectedElements()";
2232   return anObj._retn();
2233 }
2234
2235 FreeBorders_ptr FilterManager_i::CreateFreeBorders()
2236 {
2237   SMESH::FreeBorders_i* aServant = new SMESH::FreeBorders_i();
2238   SMESH::FreeBorders_var anObj = aServant->_this();
2239   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeBorders()";
2240   return anObj._retn();
2241 }
2242
2243 FreeEdges_ptr FilterManager_i::CreateFreeEdges()
2244 {
2245   SMESH::FreeEdges_i* aServant = new SMESH::FreeEdges_i();
2246   SMESH::FreeEdges_var anObj = aServant->_this();
2247   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeEdges()";
2248   return anObj._retn();
2249 }
2250
2251 FreeFaces_ptr FilterManager_i::CreateFreeFaces()
2252 {
2253   SMESH::FreeFaces_i* aServant = new SMESH::FreeFaces_i();
2254   SMESH::FreeFaces_var anObj = aServant->_this();
2255   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeFaces()";
2256   return anObj._retn();
2257 }
2258
2259 FreeNodes_ptr FilterManager_i::CreateFreeNodes()
2260 {
2261   SMESH::FreeNodes_i* aServant = new SMESH::FreeNodes_i();
2262   SMESH::FreeNodes_var anObj = aServant->_this();
2263   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeNodes()";
2264   return anObj._retn();
2265 }
2266
2267 EqualNodes_ptr FilterManager_i::CreateEqualNodes()
2268 {
2269   SMESH::EqualNodes_i* aServant = new SMESH::EqualNodes_i();
2270   SMESH::EqualNodes_var anObj = aServant->_this();
2271   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualNodes()";
2272   return anObj._retn();
2273 }
2274
2275 EqualEdges_ptr FilterManager_i::CreateEqualEdges()
2276 {
2277   SMESH::EqualEdges_i* aServant = new SMESH::EqualEdges_i();
2278   SMESH::EqualEdges_var anObj = aServant->_this();
2279   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualEdges()";
2280   return anObj._retn();
2281 }
2282 EqualFaces_ptr FilterManager_i::CreateEqualFaces()
2283 {
2284   SMESH::EqualFaces_i* aServant = new SMESH::EqualFaces_i();
2285   SMESH::EqualFaces_var anObj = aServant->_this();
2286   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualFaces()";
2287   return anObj._retn();
2288 }
2289 EqualVolumes_ptr FilterManager_i::CreateEqualVolumes()
2290 {
2291   SMESH::EqualVolumes_i* aServant = new SMESH::EqualVolumes_i();
2292   SMESH::EqualVolumes_var anObj = aServant->_this();
2293   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualVolumes()";
2294   return anObj._retn();
2295 }
2296
2297 RangeOfIds_ptr FilterManager_i::CreateRangeOfIds()
2298 {
2299   SMESH::RangeOfIds_i* aServant = new SMESH::RangeOfIds_i();
2300   SMESH::RangeOfIds_var anObj = aServant->_this();
2301   TPythonDump()<<aServant<<" = "<<this<<".CreateRangeOfIds()";
2302   return anObj._retn();
2303 }
2304
2305 BadOrientedVolume_ptr FilterManager_i::CreateBadOrientedVolume()
2306 {
2307   SMESH::BadOrientedVolume_i* aServant = new SMESH::BadOrientedVolume_i();
2308   SMESH::BadOrientedVolume_var anObj = aServant->_this();
2309   TPythonDump()<<aServant<<" = "<<this<<".CreateBadOrientedVolume()";
2310   return anObj._retn();
2311 }
2312
2313 BareBorderVolume_ptr FilterManager_i::CreateBareBorderVolume()
2314 {
2315   SMESH::BareBorderVolume_i* aServant = new SMESH::BareBorderVolume_i();
2316   SMESH::BareBorderVolume_var anObj = aServant->_this();
2317   TPythonDump()<<aServant<<" = "<<this<<".CreateBareBorderVolume()";
2318   return anObj._retn();
2319 }
2320
2321 BareBorderFace_ptr FilterManager_i::CreateBareBorderFace()
2322 {
2323   SMESH::BareBorderFace_i* aServant = new SMESH::BareBorderFace_i();
2324   SMESH::BareBorderFace_var anObj = aServant->_this();
2325   TPythonDump()<<aServant<<" = "<<this<<".CreateBareBorderFace()";
2326   return anObj._retn();
2327 }
2328
2329 OverConstrainedVolume_ptr FilterManager_i::CreateOverConstrainedVolume()
2330 {
2331   SMESH::OverConstrainedVolume_i* aServant = new SMESH::OverConstrainedVolume_i();
2332   SMESH::OverConstrainedVolume_var anObj = aServant->_this();
2333   TPythonDump()<<aServant<<" = "<<this<<".CreateOverConstrainedVolume()";
2334   return anObj._retn();
2335 }
2336
2337 OverConstrainedFace_ptr FilterManager_i::CreateOverConstrainedFace()
2338 {
2339   SMESH::OverConstrainedFace_i* aServant = new SMESH::OverConstrainedFace_i();
2340   SMESH::OverConstrainedFace_var anObj = aServant->_this();
2341   TPythonDump()<<aServant<<" = "<<this<<".CreateOverConstrainedFace()";
2342   return anObj._retn();
2343 }
2344
2345 LessThan_ptr FilterManager_i::CreateLessThan()
2346 {
2347   SMESH::LessThan_i* aServant = new SMESH::LessThan_i();
2348   SMESH::LessThan_var anObj = aServant->_this();
2349   TPythonDump()<<aServant<<" = "<<this<<".CreateLessThan()";
2350   return anObj._retn();
2351 }
2352
2353 MoreThan_ptr FilterManager_i::CreateMoreThan()
2354 {
2355   SMESH::MoreThan_i* aServant = new SMESH::MoreThan_i();
2356   SMESH::MoreThan_var anObj = aServant->_this();
2357   TPythonDump()<<aServant<<" = "<<this<<".CreateMoreThan()";
2358   return anObj._retn();
2359 }
2360
2361 EqualTo_ptr FilterManager_i::CreateEqualTo()
2362 {
2363   SMESH::EqualTo_i* aServant = new SMESH::EqualTo_i();
2364   SMESH::EqualTo_var anObj = aServant->_this();
2365   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualTo()";
2366   return anObj._retn();
2367 }
2368
2369 LogicalNOT_ptr FilterManager_i::CreateLogicalNOT()
2370 {
2371   SMESH::LogicalNOT_i* aServant = new SMESH::LogicalNOT_i();
2372   SMESH::LogicalNOT_var anObj = aServant->_this();
2373   TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalNOT()";
2374   return anObj._retn();
2375 }
2376
2377 LogicalAND_ptr FilterManager_i::CreateLogicalAND()
2378 {
2379   SMESH::LogicalAND_i* aServant = new SMESH::LogicalAND_i();
2380   SMESH::LogicalAND_var anObj = aServant->_this();
2381   TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalAND()";
2382   return anObj._retn();
2383 }
2384
2385 LogicalOR_ptr FilterManager_i::CreateLogicalOR()
2386 {
2387   SMESH::LogicalOR_i* aServant = new SMESH::LogicalOR_i();
2388   SMESH::LogicalOR_var anObj = aServant->_this();
2389   TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalOR()";
2390   return anObj._retn();
2391 }
2392
2393 LinearOrQuadratic_ptr FilterManager_i::CreateLinearOrQuadratic()
2394 {
2395   SMESH::LinearOrQuadratic_i* aServant = new SMESH::LinearOrQuadratic_i();
2396   SMESH::LinearOrQuadratic_var anObj = aServant->_this();
2397   TPythonDump()<<aServant<<" = "<<this<<".CreateLinearOrQuadratic()";
2398   return anObj._retn();
2399 }
2400
2401 GroupColor_ptr FilterManager_i::CreateGroupColor()
2402 {
2403   SMESH::GroupColor_i* aServant = new SMESH::GroupColor_i();
2404   SMESH::GroupColor_var anObj = aServant->_this();
2405   TPythonDump()<<aServant<<" = "<<this<<".CreateGroupColor()";
2406   return anObj._retn();
2407 }
2408
2409 ElemGeomType_ptr FilterManager_i::CreateElemGeomType()
2410 {
2411   SMESH::ElemGeomType_i* aServant = new SMESH::ElemGeomType_i();
2412   SMESH::ElemGeomType_var anObj = aServant->_this();
2413   TPythonDump()<<aServant<<" = "<<this<<".CreateElemGeomType()";
2414   return anObj._retn();
2415 }
2416
2417 ElemEntityType_ptr FilterManager_i::CreateElemEntityType()
2418 {
2419   SMESH::ElemEntityType_i* aServant = new SMESH::ElemEntityType_i();
2420   SMESH::ElemEntityType_var anObj = aServant->_this();
2421   TPythonDump()<<aServant<<" = "<<this<<".CreateElemEntityType()";
2422   return anObj._retn();
2423 }
2424
2425 Filter_ptr FilterManager_i::CreateFilter()
2426 {
2427   SMESH::Filter_i* aServant = new SMESH::Filter_i();
2428   SMESH::Filter_var anObj = aServant->_this();
2429   TPythonDump()<<aServant<<" = "<<this<<".CreateFilter()";
2430   return anObj._retn();
2431 }
2432
2433 FilterLibrary_ptr FilterManager_i::LoadLibrary( const char* aFileName )
2434 {
2435   SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i( aFileName );
2436   SMESH::FilterLibrary_var anObj = aServant->_this();
2437   TPythonDump()<<aServant<<" = "<<this<<".LoadLibrary('"<<aFileName<<"')";
2438   return anObj._retn();
2439 }
2440
2441 FilterLibrary_ptr FilterManager_i::CreateLibrary()
2442 {
2443   SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i();
2444   SMESH::FilterLibrary_var anObj = aServant->_this();
2445   TPythonDump()<<aServant<<" = "<<this<<".CreateLibrary()";
2446   return anObj._retn();
2447 }
2448
2449 CORBA::Boolean FilterManager_i::DeleteLibrary( const char* aFileName )
2450 {
2451   TPythonDump()<<this<<".DeleteLibrary("<<aFileName<<")";
2452   return remove( aFileName ) ? false : true;
2453 }
2454
2455 //=============================================================================
2456 /*!
2457  *  SMESH_Gen_i::CreateFilterManager
2458  *
2459  *  Create filter manager
2460  */
2461 //=============================================================================
2462
2463 SMESH::FilterManager_ptr SMESH_Gen_i::CreateFilterManager()
2464 {
2465   SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
2466   SMESH::FilterManager_var anObj = aFilter->_this();
2467   return anObj._retn();
2468 }
2469
2470
2471 /*
2472                               FILTER
2473 */
2474
2475 //=======================================================================
2476 // name    : Filter_i::Filter_i
2477 // Purpose : Constructor
2478 //=======================================================================
2479 Filter_i::Filter_i()
2480 : myPredicate( NULL )
2481 {}
2482
2483 //=======================================================================
2484 // name    : Filter_i::~Filter_i
2485 // Purpose : Destructor
2486 //=======================================================================
2487 Filter_i::~Filter_i()
2488 {
2489   if ( myPredicate )
2490     myPredicate->UnRegister();
2491
2492   if(!CORBA::is_nil(myMesh))
2493     myMesh->UnRegister();
2494
2495   myPredicate = 0;
2496   FindBaseObjects();
2497 }
2498
2499 //=======================================================================
2500 // name    : Filter_i::SetPredicate
2501 // Purpose : Set predicate
2502 //=======================================================================
2503 void Filter_i::SetPredicate( Predicate_ptr thePredicate )
2504 {
2505   if ( myPredicate )
2506     myPredicate->UnRegister();
2507
2508   myPredicate = SMESH::GetPredicate(thePredicate);
2509
2510   if ( myPredicate )
2511   {
2512     myFilter.SetPredicate( myPredicate->GetPredicate() );
2513     myPredicate->Register();
2514     if ( const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh))
2515       myPredicate->GetPredicate()->SetMesh( aMesh );
2516     TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
2517   }
2518   NotifyerAndWaiter::Modified();
2519 }
2520
2521 //=======================================================================
2522 // name    : Filter_i::GetElementType
2523 // Purpose : Get entity type
2524 //=======================================================================
2525 SMESH::ElementType Filter_i::GetElementType()
2526 {
2527   return myPredicate != 0 ? myPredicate->GetElementType() : SMESH::ALL;
2528 }
2529
2530 //=======================================================================
2531 // name    : Filter_i::SetMesh
2532 // Purpose : Set mesh
2533 //=======================================================================
2534 void
2535 Filter_i::
2536 SetMesh( SMESH_Mesh_ptr theMesh )
2537 {
2538   if(!CORBA::is_nil(theMesh))
2539     theMesh->Register();
2540
2541   if(!CORBA::is_nil(myMesh))
2542     myMesh->UnRegister();
2543
2544   myMesh = SMESH_Mesh::_duplicate( theMesh );
2545   TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
2546
2547   if ( myPredicate )
2548     if ( const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
2549       myPredicate->GetPredicate()->SetMesh( aMesh );
2550 }
2551
2552 SMESH::long_array*
2553 Filter_i::
2554 GetIDs()
2555 {
2556   return GetElementsId(myMesh);
2557 }
2558
2559 //=======================================================================
2560 // name    : Filter_i::GetElementsId
2561 // Purpose : Get ids of entities
2562 //=======================================================================
2563 void
2564 Filter_i::
2565 GetElementsId( Predicate_i* thePredicate,
2566                const SMDS_Mesh* theMesh,
2567                Controls::Filter::TIdSequence& theSequence )
2568 {
2569   if (thePredicate)
2570     Controls::Filter::GetElementsId(theMesh,thePredicate->GetPredicate(),theSequence);
2571 }
2572
2573 void
2574 Filter_i::
2575 GetElementsId( Predicate_i* thePredicate,
2576                SMESH_Mesh_ptr theMesh,
2577                Controls::Filter::TIdSequence& theSequence )
2578 {
2579   if (thePredicate)
2580     if(const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
2581       Controls::Filter::GetElementsId(aMesh,thePredicate->GetPredicate(),theSequence);
2582 }
2583
2584 SMESH::long_array*
2585 Filter_i::
2586 GetElementsId( SMESH_Mesh_ptr theMesh )
2587 {
2588   SMESH::long_array_var anArray = new SMESH::long_array;
2589   if(!CORBA::is_nil(theMesh) && myPredicate){
2590     theMesh->Load();
2591     Controls::Filter::TIdSequence aSequence;
2592     GetElementsId(myPredicate,theMesh,aSequence);
2593     long i = 0, iEnd = aSequence.size();
2594     anArray->length( iEnd );
2595     for ( ; i < iEnd; i++ )
2596       anArray[ i ] = aSequence[i];
2597   }
2598   return anArray._retn();
2599 }
2600
2601 //=============================================================================
2602 /*!
2603  * \brief Returns number of mesh elements per each \a EntityType
2604  */
2605 //=============================================================================
2606
2607 SMESH::long_array* ::Filter_i::GetMeshInfo()
2608 {
2609   SMESH::long_array_var aRes = new SMESH::long_array();
2610   aRes->length(SMESH::Entity_Last);
2611   for (int i = 0; i < SMESH::Entity_Last; i++)
2612     aRes[i] = 0;
2613
2614   if ( !CORBA::is_nil(myMesh) && myPredicate )
2615   {
2616     const SMDS_Mesh*  aMesh = MeshPtr2SMDSMesh(myMesh);
2617     SMDS_ElemIteratorPtr it = aMesh->elementsIterator( SMDSAbs_ElementType( GetElementType() ));
2618     while ( it->more() )
2619     {
2620       const SMDS_MeshElement* anElem = it->next();
2621       if ( myPredicate->IsSatisfy( anElem->GetID() ) )
2622         aRes[ anElem->GetEntityType() ]++;
2623     }
2624   }
2625
2626   return aRes._retn();
2627 }
2628
2629 //=============================================================================
2630 /*!
2631  * \brief Returns number of mesh elements of each \a ElementType
2632  */
2633 //=============================================================================
2634
2635 SMESH::long_array* ::Filter_i::GetNbElementsByType()
2636 {
2637   SMESH::long_array_var aRes = new SMESH::long_array();
2638   aRes->length(SMESH::NB_ELEMENT_TYPES);
2639   for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
2640     aRes[i] = 0;
2641
2642   if ( !CORBA::is_nil(myMesh) && myPredicate ) {
2643     const SMDS_Mesh*  aMesh = MeshPtr2SMDSMesh(myMesh);
2644     SMDS_ElemIteratorPtr it = aMesh->elementsIterator( SMDSAbs_ElementType( GetElementType() ));
2645     CORBA::Long& nbElems = aRes[ GetElementType() ];
2646     while ( it->more() )
2647     {
2648       const SMDS_MeshElement* anElem = it->next();
2649       if ( myPredicate->IsSatisfy( anElem->GetID() ) )
2650         nbElems++;
2651     }
2652   }
2653
2654   return aRes._retn();
2655 }
2656
2657
2658 //================================================================================
2659 /*!
2660  * \brief Return GetElementType() within an array
2661  * Implement SMESH_IDSource interface
2662  */
2663 //================================================================================
2664
2665 SMESH::array_of_ElementType* Filter_i::GetTypes()
2666 {
2667   SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType;
2668
2669   // check if any element passes through the filter
2670   if ( !CORBA::is_nil(myMesh) && myPredicate )
2671   {
2672     const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh);
2673     SMDS_ElemIteratorPtr it = aMesh->elementsIterator( SMDSAbs_ElementType( GetElementType() ));
2674     bool satisfies = false;
2675     while ( !satisfies && it->more() )
2676       satisfies = myPredicate->IsSatisfy( it->next()->GetID() );
2677     if ( satisfies ) {
2678       types->length( 1 );
2679       types[0] = GetElementType();
2680     }
2681   }
2682   return types._retn();
2683 }
2684
2685 //=======================================================================
2686 //function : GetMesh
2687 //purpose  : Returns mesh
2688 //=======================================================================
2689
2690 SMESH::SMESH_Mesh_ptr Filter_i::GetMesh()
2691 {
2692   return SMESH_Mesh::_duplicate( myMesh );
2693 }
2694
2695 //=======================================================================
2696 //function : GetVtkUgStream
2697 //purpose  : Return data vtk unstructured grid (not implemented)
2698 //=======================================================================
2699
2700 SALOMEDS::TMPFile* Filter_i::GetVtkUgStream()
2701 {
2702   SALOMEDS::TMPFile_var SeqFile;
2703   return SeqFile._retn();
2704 }
2705 //=======================================================================
2706 // name    : getCriteria
2707 // Purpose : Retrieve criterions from predicate
2708 //=======================================================================
2709 static inline void getPrediacates( Predicate_i*                thePred,
2710                                    std::vector<Predicate_i*> & thePredVec )
2711 {
2712   const int aFType = thePred->GetFunctorType();
2713
2714   switch ( aFType )
2715   {
2716   case FT_LogicalNOT:
2717   {
2718     Predicate_i* aPred = ( dynamic_cast<LogicalNOT_i*>( thePred ) )->GetPredicate_i();
2719     getPrediacates( aPred, thePredVec );
2720     break;
2721   }
2722   case FT_LogicalAND:
2723   case FT_LogicalOR:
2724   {
2725     Predicate_i* aPred1 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate1_i();
2726     Predicate_i* aPred2 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate2_i();
2727     getPrediacates( aPred1, thePredVec );
2728     getPrediacates( aPred2, thePredVec );
2729     break;
2730    }
2731   default:;
2732   }
2733   thePredVec.push_back( thePred );
2734 }
2735
2736 //=======================================================================
2737 // name    : getCriteria
2738 // Purpose : Retrieve criterions from predicate
2739 //=======================================================================
2740 static inline bool getCriteria( Predicate_i*                thePred,
2741                                 SMESH::Filter::Criteria_out theCriteria )
2742 {
2743   const int aFType = thePred->GetFunctorType();
2744
2745   switch ( aFType )
2746   {
2747   case FT_LogicalNOT:
2748     {
2749       Predicate_i* aPred = ( dynamic_cast<LogicalNOT_i*>( thePred ) )->GetPredicate_i();
2750       getCriteria( aPred, theCriteria );
2751       theCriteria[ theCriteria->length() - 1 ].UnaryOp = FT_LogicalNOT;
2752     }
2753     return true;
2754
2755   case FT_LogicalAND:
2756   case FT_LogicalOR:
2757     {
2758       Predicate_i* aPred1 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate1_i();
2759       Predicate_i* aPred2 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate2_i();
2760       if ( !getCriteria( aPred1, theCriteria ) )
2761         return false;
2762       theCriteria[ theCriteria->length() - 1 ].BinaryOp = aFType;
2763       return getCriteria( aPred2, theCriteria );
2764     }
2765   case FT_Undefined:
2766     return false;
2767   }
2768
2769   // resize theCriteria
2770   CORBA::ULong i = theCriteria->length();
2771   theCriteria->length( i + 1 );
2772   theCriteria[ i ] = createCriterion();
2773
2774   // set members of the added Criterion
2775
2776   theCriteria[ i ].Type = aFType;
2777   theCriteria[ i ].TypeOfElement = thePred->GetElementType();
2778
2779   switch ( aFType )
2780   {
2781   case FT_FreeBorders:
2782   case FT_FreeEdges:
2783   case FT_FreeFaces:
2784   case FT_LinearOrQuadratic:
2785   case FT_FreeNodes:
2786   case FT_EqualEdges:
2787   case FT_EqualFaces:
2788   case FT_EqualVolumes:
2789   case FT_BadOrientedVolume:
2790   case FT_BareBorderVolume:
2791   case FT_BareBorderFace:
2792   case FT_OverConstrainedVolume:
2793   case FT_OverConstrainedFace:
2794     {
2795       return true;
2796     }
2797   case FT_BelongToMeshGroup:
2798     {
2799       BelongToMeshGroup_i* aPred = dynamic_cast<BelongToMeshGroup_i*>( thePred );
2800       SMESH::SMESH_GroupBase_var grp = aPred->GetGroup();
2801       if ( !grp->_is_nil() )
2802       {
2803         theCriteria[ i ].ThresholdStr = grp->GetName();
2804         theCriteria[ i ].ThresholdID  = aPred->GetGroupID().c_str();
2805       }
2806       return true;
2807     }
2808   case FT_BelongToGeom:
2809     {
2810       BelongToGeom_i* aPred = dynamic_cast<BelongToGeom_i*>( thePred );
2811       theCriteria[ i ].ThresholdStr  = aPred->GetShapeName();
2812       theCriteria[ i ].ThresholdID   = aPred->GetShapeID();
2813       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2814       return true;
2815     }
2816   case FT_BelongToPlane:
2817   case FT_BelongToCylinder:
2818   case FT_BelongToGenSurface:
2819     {
2820       BelongToSurface_i* aPred = dynamic_cast<BelongToSurface_i*>( thePred );
2821       theCriteria[ i ].ThresholdStr  = aPred->GetShapeName();
2822       theCriteria[ i ].ThresholdID   = aPred->GetShapeID();
2823       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2824       return true;
2825     }
2826   case FT_LyingOnGeom:
2827     {
2828       LyingOnGeom_i* aPred = dynamic_cast<LyingOnGeom_i*>( thePred );
2829       theCriteria[ i ].ThresholdStr  = aPred->GetShapeName();
2830       theCriteria[ i ].ThresholdID   = aPred->GetShapeID();
2831       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2832       return true;
2833     }
2834   case FT_CoplanarFaces:
2835     {
2836       CoplanarFaces_i* aPred = dynamic_cast<CoplanarFaces_i*>( thePred );
2837       theCriteria[ i ].ThresholdID   = aPred->GetFaceAsString();
2838       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2839       return true;
2840     }
2841   case FT_ConnectedElements:
2842     {
2843       ConnectedElements_i* aPred = dynamic_cast<ConnectedElements_i*>( thePred );
2844       SMESH::ConnectedElements::ThresholdType type;
2845       CORBA::String_var threshold = aPred->GetThreshold( type );
2846       switch ( type ) {
2847       case SMESH::ConnectedElements::POINT:
2848         theCriteria[ i ].ThresholdStr = threshold; break;
2849       case SMESH::ConnectedElements::VERTEX:
2850         theCriteria[ i ].ThresholdID = threshold; break;
2851       case SMESH::ConnectedElements::NODE:
2852         theCriteria[ i ].Threshold = atof( threshold.in() ); break;
2853       default:;
2854       }
2855       return true;
2856     }
2857   case FT_EqualNodes:
2858     {
2859       EqualNodes_i* aPred = dynamic_cast<EqualNodes_i*>( thePred );
2860       theCriteria[ i ].Tolerance  = aPred->GetTolerance();
2861       return true;
2862     }
2863   case FT_RangeOfIds:
2864     {
2865       RangeOfIds_i* aPred = dynamic_cast<RangeOfIds_i*>( thePred );
2866       theCriteria[ i ].ThresholdStr  = aPred->GetRangeStr();
2867       return true;
2868     }
2869   case FT_LessThan:
2870   case FT_MoreThan:
2871   case FT_EqualTo:
2872     {
2873       Comparator_i* aCompar = dynamic_cast<Comparator_i*>( thePred );
2874       theCriteria[ i ].Type      = aCompar->GetNumFunctor_i()->GetFunctorType();
2875       theCriteria[ i ].Compare   = aFType;
2876       theCriteria[ i ].Threshold = aCompar->GetMargin();
2877       if ( aFType == FT_EqualTo )
2878       {
2879         EqualTo_i* aCompar = dynamic_cast<EqualTo_i*>( thePred );
2880         theCriteria[ i ].Tolerance = aCompar->GetTolerance();
2881       }
2882       return true;
2883     }
2884   case FT_GroupColor:
2885     {
2886       GroupColor_i* aPred = dynamic_cast<GroupColor_i*>( thePred );
2887       theCriteria[ i ].ThresholdStr = aPred->GetColorStr();
2888       return true;
2889     }
2890   case FT_ElemGeomType:
2891     {
2892       ElemGeomType_i* aPred = dynamic_cast<ElemGeomType_i*>( thePred );
2893       theCriteria[ i ].Threshold = (double)aPred->GetGeometryType();
2894       return true;
2895     }
2896   case FT_EntityType:
2897     {
2898       ElemEntityType_i* aPred = dynamic_cast<ElemEntityType_i*>( thePred );
2899       theCriteria[ i ].Threshold = (double)aPred->GetEntityType();
2900       return true;
2901     }
2902   default:
2903     return false;
2904   }
2905 }
2906
2907 //=======================================================================
2908 // name    : Filter_i::GetCriteria
2909 // Purpose : Retrieve criterions from predicate
2910 //=======================================================================
2911 CORBA::Boolean Filter_i::GetCriteria( SMESH::Filter::Criteria_out theCriteria )
2912 {
2913   theCriteria = new SMESH::Filter::Criteria;
2914   return myPredicate != 0 ? getCriteria( myPredicate, theCriteria ) : true;
2915 }
2916
2917 //=======================================================================
2918 // name    : Filter_i::SetCriteria
2919 // Purpose : Create new predicate and set criterions in it
2920 //=======================================================================
2921 CORBA::Boolean Filter_i::SetCriteria( const SMESH::Filter::Criteria& theCriteria )
2922 {
2923   SetPredicate( SMESH::Predicate::_nil() );
2924
2925   SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
2926   FilterManager_ptr aFilterMgr = aFilter->_this();
2927
2928   // CREATE two lists ( PREDICATES  and LOG OP )
2929
2930   // Criterion
2931   TPythonDump()<<"aCriteria = []";
2932   std::list<SMESH::Predicate_ptr> aPredicates;
2933   std::list<int>                  aBinaries;
2934   for ( int i = 0, n = theCriteria.length(); i < n; i++ )
2935   {
2936     int         aCriterion    = theCriteria[ i ].Type;
2937     int         aCompare      = theCriteria[ i ].Compare;
2938     double      aThreshold    = theCriteria[ i ].Threshold;
2939     const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
2940     const char* aThresholdID  = theCriteria[ i ].ThresholdID;
2941     int         aUnary        = theCriteria[ i ].UnaryOp;
2942     int         aBinary       = theCriteria[ i ].BinaryOp;
2943     double      aTolerance    = theCriteria[ i ].Tolerance;
2944     ElementType aTypeOfElem   = theCriteria[ i ].TypeOfElement;
2945     long        aPrecision    = theCriteria[ i ].Precision;
2946
2947     {
2948       TPythonDump pd;
2949       pd << "aCriterion = SMESH.Filter.Criterion("
2950          << aCriterion    << ", "
2951          << aCompare      << ", "
2952          << aThreshold    << ", '"
2953          << aThresholdStr << "', '"
2954          << aThresholdID  << "', "
2955          << aUnary        << ", "
2956          << aBinary       << ", "
2957          << aTolerance    << ", "
2958          << aTypeOfElem   << ", "
2959          << aPrecision    << ")";
2960     }
2961     TPythonDump pd;
2962
2963     SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
2964     SMESH::NumericalFunctor_ptr aFunctor = SMESH::NumericalFunctor::_nil();
2965
2966     switch ( aCriterion )
2967     {
2968       // Functors
2969
2970       case SMESH::FT_MultiConnection:
2971         aFunctor = aFilterMgr->CreateMultiConnection();
2972         break;
2973       case SMESH::FT_MultiConnection2D:
2974         aFunctor = aFilterMgr->CreateMultiConnection2D();
2975         break;
2976       case SMESH::FT_Length:
2977         aFunctor = aFilterMgr->CreateLength();
2978         break;
2979       case SMESH::FT_Length2D:
2980         aFunctor = aFilterMgr->CreateLength2D();
2981         break;
2982       case SMESH::FT_Deflection2D:
2983         aFunctor = aFilterMgr->CreateDeflection2D();
2984         break;
2985       case SMESH::FT_AspectRatio:
2986         aFunctor = aFilterMgr->CreateAspectRatio();
2987         break;
2988       case SMESH::FT_AspectRatio3D:
2989         aFunctor = aFilterMgr->CreateAspectRatio3D();
2990         break;
2991       case SMESH::FT_Warping:
2992         aFunctor = aFilterMgr->CreateWarping();
2993         break;
2994       case SMESH::FT_MinimumAngle:
2995         aFunctor = aFilterMgr->CreateMinimumAngle();
2996         break;
2997       case SMESH::FT_Taper:
2998         aFunctor = aFilterMgr->CreateTaper();
2999         break;
3000       case SMESH::FT_Skew:
3001         aFunctor = aFilterMgr->CreateSkew();
3002         break;
3003       case SMESH::FT_Area:
3004         aFunctor = aFilterMgr->CreateArea();
3005         break;
3006       case SMESH::FT_Volume3D:
3007         aFunctor = aFilterMgr->CreateVolume3D();
3008         break;
3009       case SMESH::FT_MaxElementLength2D:
3010         aFunctor = aFilterMgr->CreateMaxElementLength2D();
3011         break;
3012       case SMESH::FT_MaxElementLength3D:
3013         aFunctor = aFilterMgr->CreateMaxElementLength3D();
3014         break;
3015       case SMESH::FT_BallDiameter:
3016         aFunctor = aFilterMgr->CreateBallDiameter();
3017         break;
3018       case SMESH::FT_NodeConnectivityNumber:
3019         aFunctor = aFilterMgr->CreateNodeConnectivityNumber();
3020         break;
3021
3022       // Predicates
3023
3024       case SMESH::FT_FreeBorders:
3025         aPredicate = aFilterMgr->CreateFreeBorders();
3026         break;
3027       case SMESH::FT_FreeEdges:
3028         aPredicate = aFilterMgr->CreateFreeEdges();
3029         break;
3030       case SMESH::FT_FreeFaces:
3031         aPredicate = aFilterMgr->CreateFreeFaces();
3032         break;
3033       case SMESH::FT_FreeNodes:
3034         aPredicate = aFilterMgr->CreateFreeNodes();
3035         break;
3036       case SMESH::FT_EqualNodes:
3037         {
3038           SMESH::EqualNodes_ptr pred = aFilterMgr->CreateEqualNodes();
3039           pred->SetTolerance( aTolerance );
3040           aPredicate = pred;
3041           break;
3042         }
3043       case SMESH::FT_EqualEdges:
3044         aPredicate = aFilterMgr->CreateEqualEdges();
3045         break;
3046       case SMESH::FT_EqualFaces:
3047         aPredicate = aFilterMgr->CreateEqualFaces();
3048         break;
3049       case SMESH::FT_EqualVolumes:
3050         aPredicate = aFilterMgr->CreateEqualVolumes();
3051         break;
3052       case SMESH::FT_BelongToMeshGroup:
3053         {
3054           SMESH::BelongToMeshGroup_ptr tmpPred = aFilterMgr->CreateBelongToMeshGroup();
3055           tmpPred->SetGroupID( aThresholdID );
3056           aPredicate = tmpPred;
3057         }
3058         break;
3059       case SMESH::FT_BelongToGeom:
3060         {
3061           SMESH::BelongToGeom_ptr tmpPred = aFilterMgr->CreateBelongToGeom();
3062           tmpPred->SetElementType( aTypeOfElem );
3063           tmpPred->SetShape( aThresholdID, aThresholdStr );
3064           tmpPred->SetTolerance( aTolerance );
3065           aPredicate = tmpPred;
3066         }
3067         break;
3068       case SMESH::FT_BelongToPlane:
3069       case SMESH::FT_BelongToCylinder:
3070       case SMESH::FT_BelongToGenSurface:
3071         {
3072           SMESH::BelongToSurface_ptr tmpPred;
3073           switch ( aCriterion ) {
3074           case SMESH::FT_BelongToPlane:
3075             tmpPred = aFilterMgr->CreateBelongToPlane(); break;
3076           case SMESH::FT_BelongToCylinder:
3077             tmpPred = aFilterMgr->CreateBelongToCylinder(); break;
3078           default:
3079             tmpPred = aFilterMgr->CreateBelongToGenSurface();
3080           }
3081           tmpPred->SetShape( aThresholdID, aThresholdStr, aTypeOfElem );
3082           tmpPred->SetTolerance( aTolerance );
3083           aPredicate = tmpPred;
3084         }
3085         break;
3086       case SMESH::FT_LyingOnGeom:
3087         {
3088           SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom();
3089           tmpPred->SetElementType( aTypeOfElem );
3090           tmpPred->SetShape( aThresholdID, aThresholdStr );
3091           tmpPred->SetTolerance( aTolerance );
3092           aPredicate = tmpPred;
3093         }
3094         break;
3095       case SMESH::FT_RangeOfIds:
3096         {
3097           SMESH::RangeOfIds_ptr tmpPred = aFilterMgr->CreateRangeOfIds();
3098           tmpPred->SetRangeStr( aThresholdStr );
3099           tmpPred->SetElementType( aTypeOfElem );
3100           aPredicate = tmpPred;
3101         }
3102         break;
3103       case SMESH::FT_BadOrientedVolume:
3104         {
3105           aPredicate = aFilterMgr->CreateBadOrientedVolume();
3106         }
3107         break;
3108       case SMESH::FT_BareBorderVolume:
3109         {
3110           aPredicate = aFilterMgr->CreateBareBorderVolume();
3111         }
3112         break;
3113       case SMESH::FT_BareBorderFace:
3114         {
3115           aPredicate = aFilterMgr->CreateBareBorderFace();
3116         }
3117         break;
3118       case SMESH::FT_OverConstrainedVolume:
3119         {
3120           aPredicate = aFilterMgr->CreateOverConstrainedVolume();
3121         }
3122         break;
3123       case SMESH::FT_OverConstrainedFace:
3124         {
3125           aPredicate = aFilterMgr->CreateOverConstrainedFace();
3126         }
3127         break;
3128       case SMESH::FT_LinearOrQuadratic:
3129         {
3130           SMESH::LinearOrQuadratic_ptr tmpPred = aFilterMgr->CreateLinearOrQuadratic();
3131           tmpPred->SetElementType( aTypeOfElem );
3132           aPredicate = tmpPred;
3133           break;
3134         }
3135       case SMESH::FT_GroupColor:
3136         {
3137           SMESH::GroupColor_ptr tmpPred = aFilterMgr->CreateGroupColor();
3138           tmpPred->SetElementType( aTypeOfElem );
3139           tmpPred->SetColorStr( aThresholdStr );
3140           aPredicate = tmpPred;
3141           break;
3142         }
3143       case SMESH::FT_ElemGeomType:
3144         {
3145           SMESH::ElemGeomType_ptr tmpPred = aFilterMgr->CreateElemGeomType();
3146           tmpPred->SetElementType( aTypeOfElem );
3147           tmpPred->SetGeometryType( (GeometryType)(int)(aThreshold + 0.5) );
3148           aPredicate = tmpPred;
3149           break;
3150         }
3151       case SMESH::FT_EntityType:
3152         {
3153           SMESH::ElemEntityType_ptr tmpPred = aFilterMgr->CreateElemEntityType();
3154           tmpPred->SetElementType( aTypeOfElem );
3155           tmpPred->SetEntityType( EntityType( (int (aThreshold + 0.5))));
3156           aPredicate = tmpPred;
3157           break;
3158         }
3159       case SMESH::FT_CoplanarFaces:
3160         {
3161           SMESH::CoplanarFaces_ptr tmpPred = aFilterMgr->CreateCoplanarFaces();
3162           tmpPred->SetFace( atol (aThresholdID ));
3163           tmpPred->SetTolerance( aTolerance );
3164           aPredicate = tmpPred;
3165           break;
3166         }
3167       case SMESH::FT_ConnectedElements:
3168         {
3169           SMESH::ConnectedElements_ptr tmpPred = aFilterMgr->CreateConnectedElements();
3170           if ( strlen( aThresholdID ) > 0 ) // shape ID
3171             tmpPred->SetThreshold( aThresholdID, SMESH::ConnectedElements::VERTEX );
3172           else if ( strlen( aThresholdStr ) > 0 ) // point coords
3173             tmpPred->SetThreshold( aThresholdStr, SMESH::ConnectedElements::POINT );
3174           else if ( aThreshold >= 1 )
3175             tmpPred->SetNode( (CORBA::Long) aThreshold ); // node ID
3176           tmpPred->SetElementType( aTypeOfElem );
3177           aPredicate = tmpPred;
3178           break;
3179         }
3180
3181       default:
3182         continue;
3183     }
3184
3185     // Comparator
3186     if ( !aFunctor->_is_nil() && aPredicate->_is_nil() )
3187     {
3188       SMESH::Comparator_ptr aComparator = SMESH::Comparator::_nil();
3189
3190       if ( aCompare == SMESH::FT_LessThan )
3191         aComparator = aFilterMgr->CreateLessThan();
3192       else if ( aCompare == SMESH::FT_MoreThan )
3193         aComparator = aFilterMgr->CreateMoreThan();
3194       else if ( aCompare == SMESH::FT_EqualTo )
3195         aComparator = aFilterMgr->CreateEqualTo();
3196       else
3197         continue;
3198
3199       aComparator->SetNumFunctor( aFunctor );
3200       aComparator->SetMargin( aThreshold );
3201
3202       if ( aCompare == FT_EqualTo )
3203       {
3204         SMESH::EqualTo_var anEqualTo = SMESH::EqualTo::_narrow( aComparator );
3205         anEqualTo->SetTolerance( aTolerance );
3206       }
3207
3208       aPredicate = aComparator;
3209
3210       aFunctor->SetPrecision( aPrecision );
3211     }
3212
3213     // Logical not
3214     if ( aUnary == FT_LogicalNOT )
3215     {
3216       SMESH::LogicalNOT_ptr aNotPred = aFilterMgr->CreateLogicalNOT();
3217       aNotPred->SetPredicate( aPredicate );
3218       aPredicate = aNotPred;
3219     }
3220
3221     // logical op
3222     aPredicates.push_back( aPredicate );
3223     aBinaries.push_back( aBinary );
3224     pd <<"aCriteria.append(aCriterion)";
3225
3226   } // end of for
3227   TPythonDump pd; pd<<this<<".SetCriteria(aCriteria)";
3228
3229   // CREATE ONE PREDICATE FROM PREVIOUSLY CREATED MAP
3230
3231   // combine all "AND" operations
3232
3233   std::list<SMESH::Predicate_ptr> aResList;
3234
3235   std::list<SMESH::Predicate_ptr>::iterator aPredIter;
3236   std::list<int>::iterator                  aBinaryIter;
3237
3238   SMESH::Predicate_ptr aPrevPredicate = SMESH::Predicate::_nil();
3239   int aPrevBinary = SMESH::FT_Undefined;
3240   if ( !aBinaries.empty() )
3241     aBinaries.back() = SMESH::FT_Undefined;
3242
3243   for ( aPredIter = aPredicates.begin(), aBinaryIter = aBinaries.begin();
3244         aPredIter != aPredicates.end() && aBinaryIter != aBinaries.end();
3245         ++aPredIter, ++aBinaryIter )
3246   {
3247     int aCurrBinary = *aBinaryIter;
3248
3249     SMESH::Predicate_ptr aCurrPred = SMESH::Predicate::_nil();
3250
3251     if ( aPrevBinary == SMESH::FT_LogicalAND )
3252     {
3253
3254       SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalAND();
3255       aBinaryPred->SetPredicate1( aPrevPredicate );
3256       aBinaryPred->SetPredicate2( *aPredIter );
3257       aCurrPred = aBinaryPred;
3258     }
3259     else
3260       aCurrPred = *aPredIter;
3261
3262     if ( aCurrBinary != SMESH::FT_LogicalAND )
3263       aResList.push_back( aCurrPred );
3264
3265     aPrevPredicate = aCurrPred;
3266     aPrevBinary = aCurrBinary;
3267   }
3268
3269   // combine all "OR" operations
3270
3271   SMESH::Predicate_ptr aResPredicate = SMESH::Predicate::_nil();
3272
3273   if ( aResList.size() == 1 )
3274     aResPredicate = *aResList.begin();
3275   else if ( aResList.size() > 1 )
3276   {
3277     std::list<SMESH::Predicate_ptr>::iterator anIter = aResList.begin();
3278     aResPredicate = *anIter;
3279     anIter++;
3280     for ( ; anIter != aResList.end(); ++anIter )
3281     {
3282       SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalOR();
3283       aBinaryPred->SetPredicate1( aResPredicate );
3284       aBinaryPred->SetPredicate2( *anIter );
3285       aResPredicate = aBinaryPred;
3286     }
3287   }
3288
3289   SetPredicate( aResPredicate );
3290   if ( !aResPredicate->_is_nil() )
3291     aResPredicate->UnRegister();
3292
3293   return !aResPredicate->_is_nil();
3294 }
3295
3296 //=======================================================================
3297 // name    : Filter_i::GetPredicate_i
3298 // Purpose : Get implementation of predicate
3299 //=======================================================================
3300 Predicate_i* Filter_i::GetPredicate_i()
3301 {
3302   return myPredicate;
3303 }
3304
3305 //=======================================================================
3306 // name    : Filter_i::GetPredicate
3307 // Purpose : Get predicate
3308 //=======================================================================
3309 Predicate_ptr Filter_i::GetPredicate()
3310 {
3311   if ( myPredicate == 0 )
3312     return SMESH::Predicate::_nil();
3313   else
3314   {
3315     SMESH::Predicate_var anObj = myPredicate->_this();
3316     // if ( SMESH::Functor_i* fun = SMESH::DownCast<SMESH::Functor_i*>( anObj ))
3317     //   TPythonDump() << fun << " = " << this << ".GetPredicate()";
3318     return anObj._retn();
3319   }
3320 }
3321
3322 //================================================================================
3323 /*!
3324  * \brief Find groups it depends on
3325  */
3326 //================================================================================
3327
3328 void Filter_i::FindBaseObjects()
3329 {
3330   // release current groups
3331   for ( size_t i = 0; i < myBaseGroups.size(); ++i )
3332     if ( myBaseGroups[i] )
3333     {
3334       myBaseGroups[i]->RemoveModifWaiter( this );
3335       myBaseGroups[i]->UnRegister();
3336     }
3337
3338   // remember new groups
3339   myBaseGroups.clear();
3340   if ( myPredicate )
3341   {
3342     std::vector<Predicate_i*> predicates;
3343     getPrediacates( myPredicate, predicates );
3344     for ( size_t i = 0; i < predicates.size(); ++i )
3345       if ( BelongToMeshGroup_i* bmg = dynamic_cast< BelongToMeshGroup_i* >( predicates[i] ))
3346       {
3347         SMESH::SMESH_GroupBase_var g = bmg->GetGroup();
3348         SMESH_GroupBase_i* g_i = SMESH::DownCast< SMESH_GroupBase_i*>( g );
3349         if ( g_i )
3350         {
3351           g_i->AddModifWaiter( this );
3352           g_i->Register();
3353           myBaseGroups.push_back( g_i );
3354         }
3355       }
3356   }
3357 }
3358
3359 //================================================================================
3360 /*!
3361  * \brief When notified on removal of myBaseGroups[i], remove a reference to a
3362  *        group from a predicate
3363  */
3364 //================================================================================
3365
3366 void Filter_i::OnBaseObjModified(NotifyerAndWaiter* group, bool removed)
3367 {
3368   if ( !removed )
3369     return; // a GroupOnFilter holding this filter is notified automatically
3370
3371   if ( myPredicate )
3372   {
3373     std::vector<Predicate_i*> predicates;
3374     getPrediacates( myPredicate, predicates );
3375     for ( size_t i = 0; i < predicates.size(); ++i )
3376       if ( BelongToMeshGroup_i* bmg = dynamic_cast< BelongToMeshGroup_i* >( predicates[i] ))
3377       {
3378         SMESH::SMESH_GroupBase_var g = bmg->GetGroup();
3379         SMESH_GroupBase_i* g_i = SMESH::DownCast< SMESH_GroupBase_i*>( g );
3380         if ( g_i == group )
3381         {
3382           bmg->SetGroup( SMESH::SMESH_GroupBase::_nil() );
3383           bmg->SetGroupID( "" );
3384         }
3385       }
3386   }
3387
3388   FindBaseObjects(); // release and update myBaseGroups;
3389 }
3390
3391 /*
3392                             FILTER LIBRARY
3393 */
3394
3395 #define ATTR_TYPE          "type"
3396 #define ATTR_COMPARE       "compare"
3397 #define ATTR_THRESHOLD     "threshold"
3398 #define ATTR_UNARY         "unary"
3399 #define ATTR_BINARY        "binary"
3400 #define ATTR_THRESHOLD_STR "threshold_str"
3401 #define ATTR_TOLERANCE     "tolerance"
3402 #define ATTR_ELEMENT_TYPE  "ElementType"
3403
3404 //=======================================================================
3405 // name    : toString
3406 // Purpose : Convert bool to LDOMString
3407 //=======================================================================
3408 static inline LDOMString toString( CORBA::Boolean val )
3409 {
3410   return val ? "logical not" : "";
3411 }
3412
3413 //=======================================================================
3414 // name    : toBool
3415 // Purpose : Convert LDOMString to bool
3416 //=======================================================================
3417 static inline bool toBool( const LDOMString& theStr )
3418 {
3419   return theStr.equals( "logical not" );
3420 }
3421
3422 //=======================================================================
3423 // name    : toString
3424 // Purpose : Convert double to LDOMString
3425 //=======================================================================
3426 static inline LDOMString toString( CORBA::Double val )
3427 {
3428   char a[ 255 ];
3429   sprintf( a, "%e", val );
3430   return LDOMString( a );
3431 }
3432
3433 //=======================================================================
3434 // name    : toDouble
3435 // Purpose : Convert LDOMString to double
3436 //=======================================================================
3437 static inline double toDouble( const LDOMString& theStr )
3438 {
3439   return atof( theStr.GetString() );
3440 }
3441
3442 //=======================================================================
3443 // name    : toString
3444 // Purpose : Convert functor type to LDOMString
3445 //=======================================================================
3446 static inline LDOMString toString( CORBA::Long theType )
3447 {
3448   switch ( theType )
3449   {
3450     case FT_AspectRatio           : return "Aspect ratio";
3451     case FT_Warping               : return "Warping";
3452     case FT_MinimumAngle          : return "Minimum angle";
3453     case FT_Taper                 : return "Taper";
3454     case FT_Skew                  : return "Skew";
3455     case FT_Area                  : return "Area";
3456     case FT_Volume3D              : return "Volume3D";
3457     case FT_MaxElementLength2D    : return "Max element length 2D";
3458     case FT_MaxElementLength3D    : return "Max element length 3D";
3459     case FT_BelongToMeshGroup     : return "Belong to Mesh Group";
3460     case FT_BelongToGeom          : return "Belong to Geom";
3461     case FT_BelongToPlane         : return "Belong to Plane";
3462     case FT_BelongToCylinder      : return "Belong to Cylinder";
3463     case FT_BelongToGenSurface    : return "Belong to Generic Surface";
3464     case FT_LyingOnGeom           : return "Lying on Geom";
3465     case FT_BadOrientedVolume     : return "Bad Oriented Volume";
3466     case FT_BareBorderVolume      : return "Volumes with bare border";
3467     case FT_BareBorderFace        : return "Faces with bare border";
3468     case FT_OverConstrainedVolume : return "Over-constrained Volumes";
3469     case FT_OverConstrainedFace   : return "Over-constrained Faces";
3470     case FT_RangeOfIds            : return "Range of IDs";
3471     case FT_FreeBorders           : return "Free borders";
3472     case FT_FreeEdges             : return "Free edges";
3473     case FT_FreeFaces             : return "Free faces";
3474     case FT_FreeNodes             : return "Free nodes";
3475     case FT_EqualNodes            : return "Equal nodes";
3476     case FT_EqualEdges            : return "Equal edges";
3477     case FT_EqualFaces            : return "Equal faces";
3478     case FT_EqualVolumes          : return "Equal volumes";
3479     case FT_MultiConnection       : return "Borders at multi-connections";
3480     case FT_MultiConnection2D     : return "Borders at multi-connections 2D";
3481     case FT_Length                : return "Length";
3482     case FT_Length2D              : return "Length 2D";
3483     case FT_Deflection2D          : return "Deflection 2D";
3484     case FT_LessThan              : return "Less than";
3485     case FT_MoreThan              : return "More than";
3486     case FT_EqualTo               : return "Equal to";
3487     case FT_LogicalNOT            : return "Not";
3488     case FT_LogicalAND            : return "And";
3489     case FT_LogicalOR             : return "Or";
3490     case FT_GroupColor            : return "Color of Group";
3491     case FT_LinearOrQuadratic     : return "Linear or Quadratic";
3492     case FT_ElemGeomType          : return "Element geomtry type";
3493     case FT_EntityType            : return "Entity type";
3494     case FT_Undefined             : return "";
3495     default                       : return "";
3496   }
3497 }
3498
3499 //=======================================================================
3500 // name    : toFunctorType
3501 // Purpose : Convert LDOMString to functor type
3502 //=======================================================================
3503 static inline SMESH::FunctorType toFunctorType( const LDOMString& theStr )
3504 {
3505   if      ( theStr.equals( "Aspect ratio"                 ) ) return FT_AspectRatio;
3506   else if ( theStr.equals( "Warping"                      ) ) return FT_Warping;
3507   else if ( theStr.equals( "Minimum angle"                ) ) return FT_MinimumAngle;
3508   else if ( theStr.equals( "Taper"                        ) ) return FT_Taper;
3509   else if ( theStr.equals( "Skew"                         ) ) return FT_Skew;
3510   else if ( theStr.equals( "Area"                         ) ) return FT_Area;
3511   else if ( theStr.equals( "Volume3D"                     ) ) return FT_Volume3D;
3512   else if ( theStr.equals( "Max element length 2D"        ) ) return FT_MaxElementLength2D;
3513   else if ( theStr.equals( "Max element length 3D"        ) ) return FT_MaxElementLength3D;
3514   else if ( theStr.equals( "Belong to Mesh Group"         ) ) return FT_BelongToMeshGroup;
3515   else if ( theStr.equals( "Belong to Geom"               ) ) return FT_BelongToGeom;
3516   else if ( theStr.equals( "Belong to Plane"              ) ) return FT_BelongToPlane;
3517   else if ( theStr.equals( "Belong to Cylinder"           ) ) return FT_BelongToCylinder;
3518   else if ( theStr.equals( "Belong to Generic Surface"    ) ) return FT_BelongToGenSurface;
3519   else if ( theStr.equals( "Lying on Geom"                ) ) return FT_LyingOnGeom;
3520   else if ( theStr.equals( "Free borders"                 ) ) return FT_FreeBorders;
3521   else if ( theStr.equals( "Free edges"                   ) ) return FT_FreeEdges;
3522   else if ( theStr.equals( "Free faces"                   ) ) return FT_FreeFaces;
3523   else if ( theStr.equals( "Free nodes"                   ) ) return FT_FreeNodes;
3524   else if ( theStr.equals( "Equal nodes"                  ) ) return FT_EqualNodes;
3525   else if ( theStr.equals( "Equal edges"                  ) ) return FT_EqualEdges;
3526   else if ( theStr.equals( "Equal faces"                  ) ) return FT_EqualFaces;
3527   else if ( theStr.equals( "Equal volumes"                ) ) return FT_EqualVolumes;
3528   else if ( theStr.equals( "Borders at multi-connections" ) ) return FT_MultiConnection;
3529   //  else if ( theStr.equals( "Borders at multi-connections 2D" ) ) return FT_MultiConnection2D;
3530   else if ( theStr.equals( "Length"                       ) ) return FT_Length;
3531   //  else if ( theStr.equals( "Length2D"                     ) ) return FT_Length2D;
3532   else if ( theStr.equals( "Deflection"                   ) ) return FT_Deflection2D;
3533   else if ( theStr.equals( "Range of IDs"                 ) ) return FT_RangeOfIds;
3534   else if ( theStr.equals( "Bad Oriented Volume"          ) ) return FT_BadOrientedVolume;
3535   else if ( theStr.equals( "Volumes with bare border"     ) ) return FT_BareBorderVolume;
3536   else if ( theStr.equals( "Faces with bare border"       ) ) return FT_BareBorderFace;
3537   else if ( theStr.equals( "Over-constrained Volumes"     ) ) return FT_OverConstrainedVolume;
3538   else if ( theStr.equals( "Over-constrained Faces"       ) ) return FT_OverConstrainedFace;
3539   else if ( theStr.equals( "Less than"                    ) ) return FT_LessThan;
3540   else if ( theStr.equals( "More than"                    ) ) return FT_MoreThan;
3541   else if ( theStr.equals( "Equal to"                     ) ) return FT_EqualTo;
3542   else if ( theStr.equals( "Not"                          ) ) return FT_LogicalNOT;
3543   else if ( theStr.equals( "And"                          ) ) return FT_LogicalAND;
3544   else if ( theStr.equals( "Or"                           ) ) return FT_LogicalOR;
3545   else if ( theStr.equals( "Color of Group"               ) ) return FT_GroupColor;
3546   else if ( theStr.equals( "Linear or Quadratic"          ) ) return FT_LinearOrQuadratic;
3547   else if ( theStr.equals( "Element geomtry type"         ) ) return FT_ElemGeomType;
3548   else if ( theStr.equals( "Entity type"                  ) ) return FT_EntityType;
3549   else if ( theStr.equals( ""                             ) ) return FT_Undefined;
3550   else  return FT_Undefined;
3551 }
3552
3553 //=======================================================================
3554 // name    : toFunctorType
3555 // Purpose : Convert LDOMString to value of ElementType enumeration
3556 //=======================================================================
3557 static inline SMESH::ElementType toElementType( const LDOMString& theStr )
3558 {
3559   if      ( theStr.equals( "NODE"   ) ) return SMESH::NODE;
3560   else if ( theStr.equals( "EDGE"   ) ) return SMESH::EDGE;
3561   else if ( theStr.equals( "FACE"   ) ) return SMESH::FACE;
3562   else if ( theStr.equals( "VOLUME" ) ) return SMESH::VOLUME;
3563   else                                  return SMESH::ALL;
3564 }
3565
3566 //=======================================================================
3567 // name    : toString
3568 // Purpose : Convert ElementType to string
3569 //=======================================================================
3570 static inline LDOMString toString( const SMESH::ElementType theType )
3571 {
3572   switch ( theType )
3573   {
3574     case SMESH::NODE   : return "NODE";
3575     case SMESH::EDGE   : return "EDGE";
3576     case SMESH::FACE   : return "FACE";
3577     case SMESH::VOLUME : return "VOLUME";
3578     case SMESH::ALL    : return "ALL";
3579     default            : return "";
3580   }
3581 }
3582
3583 //=======================================================================
3584 // name    : findFilter
3585 // Purpose : Find filter in document
3586 //=======================================================================
3587 static LDOM_Element findFilter( const char* theFilterName,
3588                                 const LDOM_Document& theDoc,
3589                                 LDOM_Node* theParent = 0 )
3590 {
3591   LDOM_Element aRootElement = theDoc.getDocumentElement();
3592   if ( aRootElement.isNull() || !aRootElement.hasChildNodes() )
3593     return LDOM_Element();
3594
3595   for ( LDOM_Node aTypeNode = aRootElement.getFirstChild();
3596         !aTypeNode.isNull(); aTypeNode = aTypeNode.getNextSibling() )
3597   {
3598     for ( LDOM_Node aFilter = aTypeNode.getFirstChild();
3599           !aFilter.isNull(); aFilter = aFilter.getNextSibling() )
3600     {
3601       LDOM_Element* anElem = ( LDOM_Element* )&aFilter;
3602       if ( anElem->getTagName().equals( LDOMString( "filter" ) ) &&
3603            anElem->getAttribute( "name" ).equals( LDOMString( theFilterName ) ) )
3604       {
3605         if ( theParent != 0  )
3606           *theParent = aTypeNode;
3607         return (LDOM_Element&)aFilter;
3608       }
3609     }
3610   }
3611   return LDOM_Element();
3612 }
3613
3614 //=======================================================================
3615 // name    : getSectionName
3616 // Purpose : Get name of section of filters
3617 //=======================================================================
3618 static const char* getSectionName( const ElementType theType )
3619 {
3620   switch ( theType )
3621   {
3622     case SMESH::NODE   : return "Filters for nodes";
3623     case SMESH::EDGE   : return "Filters for edges";
3624     case SMESH::FACE   : return "Filters for faces";
3625     case SMESH::VOLUME : return "Filters for volumes";
3626     case SMESH::ALL    : return "Filters for elements";
3627     default            : return "";
3628   }
3629 }
3630
3631 //=======================================================================
3632 // name    : getSection
3633 // Purpose : Create section for filters corresponding to the entity type
3634 //=======================================================================
3635 static LDOM_Node getSection( const ElementType theType,
3636                              LDOM_Document&    theDoc,
3637                              const bool        toCreate = false )
3638 {
3639   LDOM_Element aRootElement = theDoc.getDocumentElement();
3640   if ( aRootElement.isNull() )
3641     return LDOM_Node();
3642
3643   // Find section
3644   bool anExist = false;
3645   const char* aSectionName = getSectionName( theType );
3646   if ( strcmp( aSectionName, "" ) == 0 )
3647     return LDOM_Node();
3648
3649   LDOM_NodeList aSections = theDoc.getElementsByTagName( "section" );
3650   LDOM_Node aNode;
3651   for ( int i = 0, n = aSections.getLength(); i < n; i++ )
3652   {
3653     aNode = aSections.item( i );
3654     LDOM_Element& anItem = ( LDOM_Element& )aNode;
3655     if ( anItem.getAttribute( "name" ).equals( LDOMString( aSectionName ) ) )
3656     {
3657       anExist = true;
3658       break;
3659     }
3660   }
3661
3662   // Create new section if necessary
3663   if ( !anExist )
3664   {
3665     if ( toCreate )
3666     {
3667       LDOM_Element aNewItem = theDoc.createElement( "section" );
3668       aNewItem.setAttribute( "name", aSectionName );
3669       aRootElement.appendChild( aNewItem );
3670       return aNewItem;
3671     }
3672     else
3673       return LDOM_Node();
3674   }
3675   return
3676     aNode;
3677 }
3678
3679 //=======================================================================
3680 // name    : createFilterItem
3681 // Purpose : Create filter item or LDOM document
3682 //=======================================================================
3683 static LDOM_Element createFilterItem( const char*       theName,
3684                                       SMESH::Filter_ptr theFilter,
3685                                       LDOM_Document&    theDoc )
3686 {
3687   // create new filter in document
3688   LDOM_Element aFilterItem = theDoc.createElement( "filter" );
3689   aFilterItem.setAttribute( "name", theName );
3690
3691   // save filter criterions
3692   SMESH::Filter::Criteria_var aCriteria = new SMESH::Filter::Criteria;
3693
3694   if ( !theFilter->GetCriteria( aCriteria ) )
3695     return LDOM_Element();
3696
3697   for ( CORBA::ULong i = 0, n = aCriteria->length(); i < n; i++ )
3698   {
3699     LDOM_Element aCriterionItem = theDoc.createElement( "criterion" );
3700
3701     aCriterionItem.setAttribute( ATTR_TYPE         , toString(  aCriteria[ i ].Type) );
3702     aCriterionItem.setAttribute( ATTR_COMPARE      , toString(  aCriteria[ i ].Compare ) );
3703     aCriterionItem.setAttribute( ATTR_THRESHOLD    , toString(  aCriteria[ i ].Threshold ) );
3704     aCriterionItem.setAttribute( ATTR_UNARY        , toString(  aCriteria[ i ].UnaryOp ) );
3705     aCriterionItem.setAttribute( ATTR_BINARY       , toString(  aCriteria[ i ].BinaryOp ) );
3706
3707     aCriterionItem.setAttribute( ATTR_THRESHOLD_STR, (const char*)aCriteria[ i ].ThresholdStr );
3708     aCriterionItem.setAttribute( ATTR_TOLERANCE    , toString( aCriteria[ i ].Tolerance ) );
3709     aCriterionItem.setAttribute( ATTR_ELEMENT_TYPE ,
3710       toString( (SMESH::ElementType)aCriteria[ i ].TypeOfElement ) );
3711
3712     aFilterItem.appendChild( aCriterionItem );
3713   }
3714
3715   return aFilterItem;
3716 }
3717
3718 //=======================================================================
3719 // name    : FilterLibrary_i::FilterLibrary_i
3720 // Purpose : Constructor
3721 //=======================================================================
3722 FilterLibrary_i::FilterLibrary_i( const char* theFileName )
3723 {
3724   myFileName = CORBA::string_dup( theFileName );
3725   SMESH::FilterManager_i* aFilterMgr = new SMESH::FilterManager_i();
3726   myFilterMgr = aFilterMgr->_this();
3727
3728   LDOMParser aParser;
3729
3730   // Try to use existing library file
3731   bool anExists = false;
3732   if ( !aParser.parse( myFileName ) )
3733   {
3734     myDoc = aParser.getDocument();
3735     anExists = true;
3736   }
3737   // Create a new XML document if it doesn't exist
3738   else
3739     myDoc = LDOM_Document::createDocument( LDOMString() );
3740
3741   LDOM_Element aRootElement = myDoc.getDocumentElement();
3742   if ( aRootElement.isNull() )
3743   {
3744     // If the existing document is empty --> try to create a new one
3745     if ( anExists )
3746       myDoc = LDOM_Document::createDocument( LDOMString() );
3747   }
3748 }
3749
3750 //=======================================================================
3751 // name    : FilterLibrary_i::FilterLibrary_i
3752 // Purpose : Constructor
3753 //=======================================================================
3754 FilterLibrary_i::FilterLibrary_i()
3755 {
3756   myFileName = 0;
3757   SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
3758   myFilterMgr = aFilter->_this();
3759
3760   myDoc = LDOM_Document::createDocument( LDOMString() );
3761 }
3762
3763 FilterLibrary_i::~FilterLibrary_i()
3764 {
3765   CORBA::string_free( myFileName );
3766   //TPythonDump()<<this<<".UnRegister()";
3767 }
3768
3769 //=======================================================================
3770 // name    : FilterLibrary_i::Copy
3771 // Purpose : Create filter and initialize it with values from library
3772 //=======================================================================
3773 Filter_ptr FilterLibrary_i::Copy( const char* theFilterName )
3774 {
3775   Filter_ptr aRes = Filter::_nil();
3776   LDOM_Node aFilter = findFilter( theFilterName, myDoc );
3777
3778   if ( aFilter.isNull() )
3779     return aRes;
3780
3781   std::list<SMESH::Filter::Criterion> aCriteria;
3782
3783   for ( LDOM_Node aCritNode = aFilter.getFirstChild();
3784         !aCritNode.isNull() ; aCritNode = aCritNode.getNextSibling() )
3785   {
3786     LDOM_Element* aCrit = (LDOM_Element*)&aCritNode;
3787
3788     const char* aTypeStr      = aCrit->getAttribute( ATTR_TYPE          ).GetString();
3789     const char* aCompareStr   = aCrit->getAttribute( ATTR_COMPARE       ).GetString();
3790     const char* aUnaryStr     = aCrit->getAttribute( ATTR_UNARY         ).GetString();
3791     const char* aBinaryStr    = aCrit->getAttribute( ATTR_BINARY        ).GetString();
3792     const char* anElemTypeStr = aCrit->getAttribute( ATTR_ELEMENT_TYPE  ).GetString();
3793
3794     SMESH::Filter::Criterion aCriterion = createCriterion();
3795
3796     aCriterion.Type          = toFunctorType( aTypeStr );
3797     aCriterion.Compare       = toFunctorType( aCompareStr );
3798     aCriterion.UnaryOp       = toFunctorType( aUnaryStr );
3799     aCriterion.BinaryOp      = toFunctorType( aBinaryStr );
3800
3801     aCriterion.TypeOfElement = toElementType( anElemTypeStr );
3802
3803     LDOMString str = aCrit->getAttribute( ATTR_THRESHOLD );
3804     int val = 0;
3805     aCriterion.Threshold = str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val )
3806       ? val : atof( str.GetString() );
3807
3808     str = aCrit->getAttribute( ATTR_TOLERANCE );
3809     aCriterion.Tolerance = str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val )
3810       ? val : atof( str.GetString() );
3811
3812     str = aCrit->getAttribute( ATTR_THRESHOLD_STR );
3813     if ( str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val ) )
3814     {
3815       char a[ 255 ];
3816       sprintf( a, "%d", val );
3817       aCriterion.ThresholdStr = CORBA::string_dup( a );
3818     }
3819     else
3820       aCriterion.ThresholdStr = str.GetString();
3821
3822     aCriteria.push_back( aCriterion );
3823   }
3824
3825   SMESH::Filter::Criteria_var aCriteriaVar = new SMESH::Filter::Criteria;
3826   aCriteriaVar->length( aCriteria.size() );
3827
3828   CORBA::ULong i = 0;
3829   std::list<SMESH::Filter::Criterion>::iterator anIter = aCriteria.begin();
3830
3831   for( ; anIter != aCriteria.end(); ++anIter )
3832     aCriteriaVar[ i++ ] = *anIter;
3833
3834   aRes = myFilterMgr->CreateFilter();
3835   aRes->SetCriteria( aCriteriaVar.inout() );
3836
3837   TPythonDump()<<this<<".Copy('"<<theFilterName<<"')";
3838
3839   return aRes;
3840 }
3841
3842 //=======================================================================
3843 // name    : FilterLibrary_i::SetFileName
3844 // Purpose : Set file name for library
3845 //=======================================================================
3846 void FilterLibrary_i::SetFileName( const char* theFileName )
3847 {
3848   CORBA::string_free( myFileName );
3849   myFileName = CORBA::string_dup( theFileName );
3850   TPythonDump()<<this<<".SetFileName('"<<theFileName<<"')";
3851 }
3852
3853 //=======================================================================
3854 // name    : FilterLibrary_i::GetFileName
3855 // Purpose : Get file name of library
3856 //=======================================================================
3857 char* FilterLibrary_i::GetFileName()
3858 {
3859   return CORBA::string_dup( myFileName );
3860 }
3861
3862 //=======================================================================
3863 // name    : FilterLibrary_i::Add
3864 // Purpose : Add new filter to library
3865 //=======================================================================
3866 CORBA::Boolean FilterLibrary_i::Add( const char* theFilterName, Filter_ptr theFilter )
3867 {
3868   // if filter already in library or entry filter is null do nothing
3869   LDOM_Node aFilterNode = findFilter( theFilterName, myDoc );
3870   if ( !aFilterNode.isNull() || theFilter->_is_nil() )
3871     return false;
3872
3873   // get section corresponding to the filter type
3874   ElementType anEntType = theFilter->GetElementType();
3875
3876   LDOM_Node aSection = getSection( anEntType, myDoc, true );
3877   if ( aSection.isNull() )
3878     return false;
3879
3880   // create filter item
3881   LDOM_Element aFilterItem = createFilterItem( theFilterName, theFilter, myDoc );
3882   if ( aFilterItem.isNull() )
3883     return false;
3884   else
3885   {
3886     aSection.appendChild( aFilterItem );
3887     if(Filter_i* aFilter = DownCast<Filter_i*>(theFilter))
3888       TPythonDump()<<this<<".Add('"<<theFilterName<<"',"<<aFilter<<")";
3889     return true;
3890   }
3891 }
3892
3893 //=======================================================================
3894 // name    : FilterLibrary_i::Add
3895 // Purpose : Add new filter to library
3896 //=======================================================================
3897 CORBA::Boolean FilterLibrary_i::AddEmpty( const char* theFilterName, ElementType theType )
3898 {
3899   // if filter already in library or entry filter is null do nothing
3900   LDOM_Node aFilterNode = findFilter( theFilterName, myDoc );
3901   if ( !aFilterNode.isNull() )
3902     return false;
3903
3904   LDOM_Node aSection = getSection( theType, myDoc, true );
3905   if ( aSection.isNull() )
3906     return false;
3907
3908   // create filter item
3909   Filter_var aFilter = myFilterMgr->CreateFilter();
3910
3911   LDOM_Element aFilterItem = createFilterItem( theFilterName, aFilter, myDoc );
3912   if ( aFilterItem.isNull() )
3913     return false;
3914   else
3915   {
3916     aSection.appendChild( aFilterItem );
3917     TPythonDump()<<this<<".AddEmpty('"<<theFilterName<<"',"<<theType<<")";
3918     return true;
3919   }
3920 }
3921
3922 //=======================================================================
3923 // name    : FilterLibrary_i::Delete
3924 // Purpose : Delete filter from library
3925 //=======================================================================
3926 CORBA::Boolean FilterLibrary_i::Delete ( const char* theFilterName )
3927 {
3928   LDOM_Node aParentNode;
3929   LDOM_Node aFilterNode = findFilter( theFilterName, myDoc, &aParentNode );
3930   if ( aFilterNode.isNull() || aParentNode.isNull() )
3931     return false;
3932
3933   aParentNode.removeChild( aFilterNode );
3934   TPythonDump()<<this<<".Delete('"<<theFilterName<<"')";
3935   return true;
3936 }
3937
3938 //=======================================================================
3939 // name      : FilterLibrary_i::Replace
3940 // Purpose   : Replace existing filter with entry filter.
3941 // IMPORTANT : If filter does not exist it is not created
3942 //=======================================================================
3943 CORBA::Boolean FilterLibrary_i::Replace( const char* theFilterName,
3944                                          const char* theNewName,
3945                                          Filter_ptr  theFilter )
3946 {
3947   LDOM_Element aFilterItem = findFilter( theFilterName, myDoc );
3948   if ( aFilterItem.isNull() || theFilter->_is_nil() )
3949     return false;
3950
3951   LDOM_Element aNewItem = createFilterItem( theNewName, theFilter, myDoc );
3952   if ( aNewItem.isNull() )
3953     return false;
3954   else
3955   {
3956     aFilterItem.ReplaceElement( aNewItem );
3957     if(Filter_i* aFilter = DownCast<Filter_i*>(theFilter))
3958       TPythonDump()<<this<<".Replace('"<<theFilterName<<"','"<<theNewName<<"',"<<aFilter<<")";
3959     return true;
3960   }
3961 }
3962
3963 //=======================================================================
3964 // name    : FilterLibrary_i::Save
3965 // Purpose : Save library on disk
3966 //=======================================================================
3967 CORBA::Boolean FilterLibrary_i::Save()
3968 {
3969   if ( myFileName == 0 || strlen( myFileName ) == 0 )
3970     return false;
3971
3972 #if OCC_VERSION_MAJOR < 7
3973   FILE* aOutFile = fopen( myFileName, "wt" );
3974   if ( !aOutFile )
3975     return false;
3976
3977   LDOM_XmlWriter aWriter( aOutFile );
3978   aWriter.SetIndentation( 2 );
3979   aWriter << myDoc;
3980   fclose( aOutFile );
3981 #else
3982   std::filebuf fb;
3983   fb.open( myFileName, std::ios::out );
3984
3985   Standard_OStream os( &fb );
3986
3987   LDOM_XmlWriter aWriter;
3988   aWriter.SetIndentation( 2 );
3989   aWriter.Write( os, myDoc );
3990   fb.close();
3991 #endif
3992
3993   TPythonDump()<<this<<".Save()";
3994   return true;
3995 }
3996
3997 //=======================================================================
3998 // name    : FilterLibrary_i::SaveAs
3999 // Purpose : Save library on disk
4000 //=======================================================================
4001 CORBA::Boolean FilterLibrary_i::SaveAs( const char* aFileName )
4002 {
4003   myFileName = strdup ( aFileName );
4004   TPythonDump()<<this<<".SaveAs('"<<aFileName<<"')";
4005   return Save();
4006 }
4007
4008 //=======================================================================
4009 // name    : FilterLibrary_i::IsPresent
4010 // Purpose : Verify whether filter is in library
4011 //=======================================================================
4012 CORBA::Boolean FilterLibrary_i::IsPresent( const char* theFilterName )
4013 {
4014   return !findFilter( theFilterName, myDoc ).isNull();
4015 }
4016
4017 //=======================================================================
4018 // name    : FilterLibrary_i::NbFilters
4019 // Purpose : Return amount of filters in library
4020 //=======================================================================
4021 CORBA::Long FilterLibrary_i::NbFilters( ElementType theType )
4022 {
4023   string_array_var aNames = GetNames( theType );
4024   return aNames->length();
4025 }
4026
4027 //=======================================================================
4028 // name    : FilterLibrary_i::GetNames
4029 // Purpose : Get names of filters from library
4030 //=======================================================================
4031 string_array* FilterLibrary_i::GetNames( ElementType theType )
4032 {
4033   string_array_var anArray = new string_array;
4034   TColStd_SequenceOfHAsciiString aSeq;
4035
4036   LDOM_Node aSection = getSection( theType, myDoc, false );
4037
4038   if ( !aSection.isNull() )
4039   {
4040     for ( LDOM_Node aFilter = aSection.getFirstChild();
4041           !aFilter.isNull(); aFilter = aFilter.getNextSibling() )
4042     {
4043       LDOM_Element& anElem = ( LDOM_Element& )aFilter;
4044       aSeq.Append( new TCollection_HAsciiString(
4045          (Standard_CString)anElem.getAttribute( "name" ).GetString() ) );
4046     }
4047   }
4048
4049   anArray->length( aSeq.Length() );
4050   for ( int i = 1, n = aSeq.Length(); i <= n; i++ )
4051     anArray[ i - 1 ] = CORBA::string_dup( aSeq( i )->ToCString() );
4052
4053   return anArray._retn();
4054 }
4055
4056 //=======================================================================
4057 // name    : FilterLibrary_i::GetAllNames
4058 // Purpose : Get names of filters from library
4059 //=======================================================================
4060 string_array* FilterLibrary_i::GetAllNames()
4061 {
4062   string_array_var aResArray = new string_array;
4063   for ( int type = SMESH::ALL; type <= SMESH::VOLUME; type++ )
4064   {
4065     SMESH::string_array_var aNames = GetNames( (SMESH::ElementType)type );
4066
4067     int aPrevLength = aResArray->length();
4068     aResArray->length( aPrevLength + aNames->length() );
4069     for ( int i = 0, n = aNames->length(); i < n; i++ )
4070       aResArray[ aPrevLength + i ] = aNames[ i ];
4071   }
4072
4073   return aResArray._retn();
4074 }
4075
4076 //================================================================================
4077 /*!
4078  * \brief Return an array of strings corresponding to items of enum FunctorType
4079  */
4080 //================================================================================
4081
4082 static const char** getFunctNames()
4083 {
4084   static const char* functName[] = {
4085     // IT's necessary to update this array according to enum FunctorType (SMESH_Filter.idl)
4086     // The order is IMPORTANT !!!
4087     "FT_AspectRatio",
4088     "FT_AspectRatio3D",
4089     "FT_Warping",
4090     "FT_MinimumAngle",
4091     "FT_Taper",
4092     "FT_Skew",
4093     "FT_Area",
4094     "FT_Volume3D",
4095     "FT_MaxElementLength2D",
4096     "FT_MaxElementLength3D",
4097     "FT_FreeBorders",
4098     "FT_FreeEdges",
4099     "FT_FreeNodes",
4100     "FT_FreeFaces",
4101     "FT_EqualNodes",
4102     "FT_EqualEdges",
4103     "FT_EqualFaces",
4104     "FT_EqualVolumes",
4105     "FT_MultiConnection",
4106     "FT_MultiConnection2D",
4107     "FT_Length",
4108     "FT_Length2D",
4109     "FT_Deflection2D",
4110     "FT_NodeConnectivityNumber",
4111     "FT_BelongToMeshGroup",
4112     "FT_BelongToGeom",
4113     "FT_BelongToPlane",
4114     "FT_BelongToCylinder",
4115     "FT_BelongToGenSurface",
4116     "FT_LyingOnGeom",
4117     "FT_RangeOfIds",
4118     "FT_BadOrientedVolume",
4119     "FT_BareBorderVolume",
4120     "FT_BareBorderFace",
4121     "FT_OverConstrainedVolume",
4122     "FT_OverConstrainedFace",
4123     "FT_LinearOrQuadratic",
4124     "FT_GroupColor",
4125     "FT_ElemGeomType",
4126     "FT_EntityType",
4127     "FT_CoplanarFaces",
4128     "FT_BallDiameter",
4129     "FT_ConnectedElements",
4130     "FT_LessThan",
4131     "FT_MoreThan",
4132     "FT_EqualTo",
4133     "FT_LogicalNOT",
4134     "FT_LogicalAND",
4135     "FT_LogicalOR",
4136     "FT_Undefined"};
4137
4138 #ifdef _DEBUG_
4139   // check if functName is complete, compilation failure means that enum FunctorType changed
4140   const int nbFunctors = sizeof(functName) / sizeof(const char*);
4141   int _assert[( nbFunctors == SMESH::FT_Undefined + 1 ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
4142 #endif
4143
4144   return functName;
4145 }
4146
4147 //================================================================================
4148 /*!
4149  * \brief Return a string corresponding to an item of enum FunctorType
4150  */
4151 //================================================================================
4152
4153 const char* SMESH::FunctorTypeToString(SMESH::FunctorType ft)
4154 {
4155   if ( ft < 0 || ft > SMESH::FT_Undefined )
4156     return "FT_Undefined";
4157   return getFunctNames()[ ft ];
4158 }
4159
4160 //================================================================================
4161 /*!
4162  * \brief Converts a string to FunctorType. This is reverse of FunctorTypeToString()
4163  */
4164 //================================================================================
4165
4166 SMESH::FunctorType SMESH::StringToFunctorType(const char* str)
4167 {
4168   std::string name( str + 3 ); // skip "FT_"
4169   const char** functNames = getFunctNames();
4170   int ft = 0;
4171   for ( ; ft < SMESH::FT_Undefined; ++ft )
4172     if ( name == ( functNames[ft] + 3 ))
4173       break;
4174
4175   //ASSERT( strcmp( str, FunctorTypeToString( SMESH::FunctorType( ft ))) == 0 );
4176
4177   return SMESH::FunctorType( ft );
4178 }
4179
4180 //================================================================================
4181 /*!
4182  * \brief calls OnBaseObjModified(), if who != this, and myWaiters[i]->Modified(who)
4183  */
4184 //================================================================================
4185
4186 void NotifyerAndWaiter::Modified( bool removed, NotifyerAndWaiter* who )
4187 {
4188   if ( who != 0 && who != this )
4189     OnBaseObjModified( who, removed );
4190   else
4191     who = this;
4192
4193   std::list<NotifyerAndWaiter*> waiters = myWaiters; // myWaiters can be changed by Modified()
4194   std::list<NotifyerAndWaiter*>::iterator i = waiters.begin();
4195   for ( ; i != waiters.end(); ++i )
4196     (*i)->Modified( removed, who );
4197 }
4198
4199 //================================================================================
4200 /*!
4201  * \brief Stores an object to be notified on change of predicate
4202  */
4203 //================================================================================
4204
4205 void NotifyerAndWaiter::AddModifWaiter( NotifyerAndWaiter* waiter )
4206 {
4207   if ( waiter )
4208     myWaiters.push_back( waiter );
4209 }
4210
4211 //================================================================================
4212 /*!
4213  * \brief Removes an object to be notified on change of predicate
4214  */
4215 //================================================================================
4216
4217 void NotifyerAndWaiter::RemoveModifWaiter( NotifyerAndWaiter* waiter )
4218 {
4219   myWaiters.remove( waiter );
4220 }
4221
4222 //================================================================================
4223 /*!
4224  * \brief Checks if a waiter is among myWaiters, maybe nested
4225  */
4226 //================================================================================
4227
4228 bool NotifyerAndWaiter::ContainModifWaiter( NotifyerAndWaiter* waiter )
4229 {
4230   bool is = ( waiter == this );
4231
4232   std::list<NotifyerAndWaiter*>::iterator w = myWaiters.begin();
4233   for ( ; !is && w != myWaiters.end(); ++w )
4234     is = (*w)->ContainModifWaiter( waiter );
4235
4236   return is;
4237 }