Merge from V6_main 12/04/2013

configure.ac

@@ -576,6 +576,8 @@ AC_OUTPUT([ \
   src/Tools/Makefile \
   src/Tools/MeshCut/Makefile \
   src/Tools/YamsPlug/Makefile \
+  src/Tools/YamsPlug/doc/Makefile \
+  src/Tools/YamsPlug/doc/conf.py \
   src/Tools/padder/Makefile \
   src/Tools/padder/meshjob/Makefile \
   src/Tools/padder/meshjob/idl/Makefile \

resources/SalomeApp.xml.in

@@ -112,6 +112,7 @@
   <section name="smesh_help" >
     <parameter name="sub_menu"          value="%1 module"/>
     <parameter name="User's Guide"      value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/index.html"/>
+    <parameter name="Plug-ins/Yams plugin User's Guide" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/yams/index.html"/>
     <parameter name="Developer's Guide" value="%SMESH_ROOT_DIR%/share/doc/salome/tui/SMESH/index.html"/>
   </section>
   <section name="resources">

src/Controls/SMESH_Controls.cxx

@@ -65,6 +65,7 @@
 #include <set>
 #include <limits>
 
+#include <Basics_Utils.hxx>
 
 /*
                             AUXILIARY METHODS
@@ -2662,6 +2663,7 @@ void GroupColor::SetMesh( const SMDS_Mesh* theMesh )
 
 void GroupColor::SetColorStr( const TCollection_AsciiString& theStr )
 {
+  Kernel_Utils::Localizer loc;
   TCollection_AsciiString aStr = theStr;
   aStr.RemoveAll( ' ' );
   aStr.RemoveAll( '\t' );

src/SMESH/SMESH_Gen.cxx

@@ -149,11 +149,12 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
   else
     computeEvent = SMESH_subMesh::COMPUTE_SUBMESH;
 
-  if ( anUpward ) // is called from below code here
+  if ( anUpward ) // is called from the below code in this method
   {
-    // -----------------------------------------------
+    // ===============================================
-    // mesh all the sub-shapes starting from vertices
+    // Mesh all the sub-shapes starting from vertices
-    // -----------------------------------------------
+    // ===============================================
+
     smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
     while ( smIt->more() )
     {
@@ -193,19 +194,21 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
   }
   else
   {
-    // -----------------------------------------------------------------
+    // ================================================================
-    // apply algos that DO NOT require Discreteized boundaries and DO NOT
+    // Apply algos that do NOT require discreteized boundaries
-    // support submeshes, starting from the most complex shapes
+    // ("all-dimensional") and do NOT support sub-meshes, starting from
-    // and collect submeshes with algos that DO support submeshes
+    // the most complex shapes and collect sub-meshes with algos that 
-    // -----------------------------------------------------------------
+    // DO support sub-meshes
-    list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes;
+    // ================================================================
+
+    list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes[4]; // for each dim
 
     // map to sort sm with same dim algos according to dim of
     // the shape the algo assigned to (issue 0021217)
     multimap< int, SMESH_subMesh* > shDim2sm;
     multimap< int, SMESH_subMesh* >::reverse_iterator shDim2smIt;
     TopoDS_Shape algoShape;
-    int prevShapeDim = -1;
+    int prevShapeDim = -1, aShapeDim;
 
     smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst);
     while ( smIt->more() )
@@ -215,7 +218,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
         continue;
 
       const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
-      int aShapeDim = GetShapeDim( aSubShape );
+      aShapeDim = GetShapeDim( aSubShape );
       if ( aShapeDim < 1 ) break;
       
       // check for preview dimension limitations
@@ -234,9 +237,9 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
             prevShapeDim = aShapeDim;
             for ( shDim2smIt = shDim2sm.rbegin(); shDim2smIt != shDim2sm.rend(); ++shDim2smIt )
               if ( shDim2smIt->first == globalAlgoDim )
-                smWithAlgoSupportingSubmeshes.push_back( shDim2smIt->second );
+                smWithAlgoSupportingSubmeshes[ aShapeDim ].push_back( shDim2smIt->second );
               else
-                smWithAlgoSupportingSubmeshes.push_front( shDim2smIt->second );
+                smWithAlgoSupportingSubmeshes[ aShapeDim ].push_front( shDim2smIt->second );
             shDim2sm.clear();
           }
           // add smToCompute to shDim2sm map
@@ -255,7 +258,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
           }
           shDim2sm.insert( make_pair( aShapeDim, smToCompute ));
         }
-        else
+        else // Compute w/o support of sub-meshes
         {
           if (_compute_canceled)
             return false;
@@ -270,22 +273,28 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
     // reload sub-meshes from shDim2sm into smWithAlgoSupportingSubmeshes
     for ( shDim2smIt = shDim2sm.rbegin(); shDim2smIt != shDim2sm.rend(); ++shDim2smIt )
       if ( shDim2smIt->first == globalAlgoDim )
-        smWithAlgoSupportingSubmeshes.push_back( shDim2smIt->second );
+        smWithAlgoSupportingSubmeshes[0].push_back( shDim2smIt->second );
       else
-        smWithAlgoSupportingSubmeshes.push_front( shDim2smIt->second );
+        smWithAlgoSupportingSubmeshes[0].push_front( shDim2smIt->second );
+
+    // ======================================================
+    // Apply all-dimensional algorithms supporing sub-meshes
+    // ======================================================
+
+    for ( aShapeDim = 0; aShapeDim < 4; ++aShapeDim )
+    {
+      // ------------------------------------------------
+      // sort list of sub-meshes according to mesh order
+      // ------------------------------------------------
+      aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes[ aShapeDim ] );
 
       // ------------------------------------------------------------
-    // sort list of submeshes according to mesh order
+      // compute sub-meshes with local uni-dimensional algos under
-    // ------------------------------------------------------------
+      // sub-meshes with all-dimensional algos
-    aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes );
-
-    // ------------------------------------------------------------
-    // compute submeshes under shapes with algos that DO NOT require
-    // Discreteized boundaries and DO support submeshes
       // ------------------------------------------------------------
       list< SMESH_subMesh* >::iterator subIt, subEnd;
-    subIt  = smWithAlgoSupportingSubmeshes.begin();
+      subIt  = smWithAlgoSupportingSubmeshes[ aShapeDim ].begin();
-    subEnd = smWithAlgoSupportingSubmeshes.end();
+      subEnd = smWithAlgoSupportingSubmeshes[ aShapeDim ].end();
       // start from lower shapes
       for ( ; subIt != subEnd; ++subIt )
       {
@@ -324,10 +333,11 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
           }
         }
       }
-    // ----------------------------------------------------------
+      // --------------------------------
-    // apply the algos that do not require Discreteized boundaries
+      // apply the all-dimensional algos
-    // ----------------------------------------------------------
+      // --------------------------------
-    for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt )
+      subIt  = smWithAlgoSupportingSubmeshes[ aShapeDim ].begin();
+      for ( ; subIt != subEnd; ++subIt )
       {
         sm = *subIt;
         if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
@@ -346,6 +356,8 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
             aShapesId->insert( sm->GetId() );
         }
       }
+    } // loop on shape dimensions
+
     // -----------------------------------------------
     // mesh the rest sub-shapes starting from vertices
     // -----------------------------------------------
@@ -451,8 +463,8 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh &          aMesh,
   else {
     // -----------------------------------------------------------------
     // apply algos that DO NOT require Discreteized boundaries and DO NOT
-    // support submeshes, starting from the most complex shapes
+    // support sub-meshes, starting from the most complex shapes
-    // and collect submeshes with algos that DO support submeshes
+    // and collect sub-meshes with algos that DO support sub-meshes
     // -----------------------------------------------------------------
     list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes;
     smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst);
@@ -481,8 +493,8 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh &          aMesh,
     aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes );
 
     // ------------------------------------------------------------
-    // compute submeshes under shapes with algos that DO NOT require
+    // compute sub-meshes under shapes with algos that DO NOT require
-    // Discreteized boundaries and DO support submeshes
+    // Discreteized boundaries and DO support sub-meshes
     // ------------------------------------------------------------
     list< SMESH_subMesh* >::iterator subIt, subEnd;
     subIt  = smWithAlgoSupportingSubmeshes.begin();
@@ -650,9 +662,9 @@ static bool checkMissing(SMESH_Gen*                aGen,
   {
   case TopAbs_EDGE:
   case TopAbs_FACE:
-  case TopAbs_SOLID: break; // check this submesh, it can be meshed
+  case TopAbs_SOLID: break; // check this sub-mesh, it can be meshed
   default:
-    return true; // not meshable submesh
+    return true; // not meshable sub-mesh
   }
   if ( aCheckedMap.count( aSubMesh ))
     return true;

src/SMESH/SMESH_MeshEditor.cxx

@@ -6065,7 +6065,26 @@ SMESH_MeshEditor::generateGroups(const SMESH_SequenceOfElemPtr& nodeGens,
           if ( resElem != sourceElem )
             resultElems.push_back( resElem );
 
-      // add resultElems to groups made by ones the sourceElem belongs to
+      // there must be a top element
+      const SMDS_MeshElement* topElem = 0;
+      if ( isNodes )
+      {
+        topElem = resultElems.back();
+        resultElems.pop_back();
+      }
+      else
+      {
+        list< const SMDS_MeshElement* >::reverse_iterator resElemIt = resultElems.rbegin();
+        for ( ; resElemIt != resultElems.rend() ; ++resElemIt )
+          if ( (*resElemIt)->GetType() == sourceElem->GetType() )
+          {
+            topElem = *resElemIt;
+            resultElems.erase( --(resElemIt.base()) ); // erase *resElemIt
+            break;
+          }
+      }
+
+      // add resultElems to groups originted from ones the sourceElem belongs to
       list< TOldNewGroup >::iterator gOldNew, gLast = groupsOldNew.end();
       for ( gOldNew = groupsOldNew.begin(); gOldNew != gLast; ++gOldNew )
       {
@@ -6074,19 +6093,15 @@ SMESH_MeshEditor::generateGroups(const SMESH_SequenceOfElemPtr& nodeGens,
         {
           // fill in a new group
           SMDS_MeshGroup & newGroup = gOldNew->get<1>()->SMDSGroup();
-          list< const SMDS_MeshElement* > rejectedElems; // elements of other type
           list< const SMDS_MeshElement* >::iterator resLast = resultElems.end(), resElemIt;
           for ( resElemIt = resultElems.begin(); resElemIt != resLast; ++resElemIt )
-            if ( !newGroup.Add( *resElemIt ))
+            newGroup.Add( *resElemIt );
-              rejectedElems.push_back( *resElemIt );
 
-          // fill "top" group
+          // fill a "top" group
-          if ( !rejectedElems.empty() )
+          if ( topElem )
           {
             SMDS_MeshGroup & newTopGroup = gOldNew->get<2>()->SMDSGroup();
-            resLast = rejectedElems.end();
+            newTopGroup.Add( topElem );
-            for ( resElemIt = rejectedElems.begin(); resElemIt != resLast; ++resElemIt )
-              !newTopGroup.Add( *resElemIt );
           }
         }
       }
@@ -6116,7 +6131,9 @@ SMESH_MeshEditor::generateGroups(const SMESH_SequenceOfElemPtr& nodeGens,
 
         // make a name
         const bool isTop = ( nbNewGroups == 2 &&
-                             newGroupDS->GetType() == oldGroupDS->GetType() );
+                             newGroupDS->GetType() == oldGroupDS->GetType() &&
+                             is2nd );
+
         string name = oldGroupDS->GetStoreName();
         if ( !targetMesh ) {
           string suffix = ( isTop ? "top": postfix.c_str() );

src/SMESHGUI/SMESHGUI_FilterDlg.cxx

@@ -67,6 +67,7 @@
 
 // SALOME KERNEL includes
 #include <SALOMEDSClient_Study.hxx>
+#include <Basics_Utils.hxx>
 
 // OCCT includes
 #include <StdSelect_TypeOfFace.hxx>
@@ -1246,6 +1247,7 @@ void SMESHGUI_FilterTable::GetCriterion (const int                 theRow,
     QtxColorButton* clrBtn = qobject_cast<QtxColorButton*>(aTable->cellWidget(theRow, 2));
     if ( clrBtn )
     {
+      Kernel_Utils::Localizer loc;
       const QColor qClr = clrBtn->color();
       QString clrStr = QString( "%1;%2;%3" ).
         arg( qClr.red()/256. ).arg( qClr.green()/256. ).arg( qClr.blue()/256. );

src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx

@@ -607,7 +607,9 @@ void SMESHGUI_MultiEditDlg::onSelectionDone()
           anItem->setSelected(true);
       }
     }
-    myMesh = SMESH::GetMeshByIO(anIO);
+    SMESH::SMESH_Mesh_var aSelMesh = SMESH::GetMeshByIO(anIO);
+    if (!aSelMesh->_is_nil())
+      myMesh = aSelMesh;
   }
 
   if (nbSel > 0) {
@@ -662,6 +664,7 @@ void SMESHGUI_MultiEditDlg::onFilterBtn()
 
   myFilterDlg->SetSelection();
   myFilterDlg->SetMesh(myMesh);
+  myFilterDlg->SetSourceWg(myListBox, false);
 
   myFilterDlg->show();
 }
@@ -975,7 +978,7 @@ void SMESHGUI_MultiEditDlg::setSelectionMode()
 {
   SMESH::RemoveFilters();
 
-  mySelectionMgr->clearSelected();
+  //  mySelectionMgr->clearSelected();
   mySelectionMgr->clearFilters();
 
   if (mySubmeshChk->isChecked()) {

src/StdMeshers/StdMeshers_ProjectionUtils.cxx

@@ -1000,7 +1000,8 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
       // get outer edge of theShape1
       TopoDS_Shape wire = OuterShape( face1, TopAbs_WIRE );
       //edge1 = TopoDS::Edge( OuterShape( face1, TopAbs_EDGE ));
-      map<int,TopoDS_Edge> propag_edges; // use map to find the closest propagation edge
+      // use map to find the closest propagation edge
+      map<int, pair< TopoDS_Edge, TopoDS_Edge > > propag_edges;
       for ( TopoDS_Iterator edgeIt( wire ); edgeIt.More(); edgeIt.Next() )
       {
         edge1 = TopoDS::Edge( edgeIt.Value() );
@@ -1009,7 +1010,8 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
           edge2 = TopoDS::Edge( exp.Current() );
           pair<int,TopoDS_Edge> step_edge = GetPropagationEdge( theMesh1, edge2, edge1 );
           if ( !step_edge.second.IsNull() ) { // propagation found
-            propag_edges.insert( step_edge );
+            propag_edges.insert( make_pair( step_edge.first,
+                                            ( make_pair( edge1, step_edge.second ))));
             if ( step_edge.first == 1 ) break; // most close found
           }
         }
@@ -1017,7 +1019,8 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
       }
       if ( !propag_edges.empty() ) // propagation found
       {
-        edge2 = propag_edges.begin()->second;
+        edge1 = propag_edges.begin()->second.first;
+        edge2 = propag_edges.begin()->second.second;
         TopoDS_Vertex VV1[2], VV2[2];
         TopExp::Vertices( edge1, VV1[0], VV1[1], true );
         TopExp::Vertices( edge2, VV2[0], VV2[1], true );

src/Tools/YamsPlug/Makefile.am

@@ -17,6 +17,8 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+SUBDIRS = doc
+
 include $(top_srcdir)/adm_local/unix/make_common_starter.am
 
 UIPY_FILES = YamsPlugDialog.py  ViewText.py 

src/Tools/YamsPlug/doc/Makefile.am

@@ -0,0 +1,72 @@
+# Makefile for Sphinx documentation
+#
+
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+yamsdocdir=$(docdir)/gui/SMESH/yams
+
+
+RSTFILES = lct.rst \
+	   index.rst \
+	   editHypo.rst \
+	   Mandatory_params.rst \
+	   Generics_params.rst \
+	   Advanced_params.rst
+
+EXTRA_DIST += $(RSTFILES)
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SOURCEDIR     = $(srcdir)
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = _build
+CONF_FILE_DIR = .
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees -c $(CONF_FILE_DIR) $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) $(SOURCEDIR)
+
+.PHONY: help clean html latexpdf 
+
+all:
+	make html
+
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+
+install-data-local: all
+	test -z $(yamsdocdir) || mkdir -p $(yamsdocdir)
+	cp -rf $(BUILDDIR)/html/* $(yamsdocdir) ;
+
+clean:
+	-rm -rf $(BUILDDIR)/*
+
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+

src/Tools/YamsPlug/doc/conf.py.in

@@ -35,16 +35,16 @@ source_suffix = '.rst'
 master_doc = 'index'
 
 # General substitutions.
-project = 'YAMS Plug_in'
+project = 'YAMS Plug-in'
 copyright = '2011, Pascale Noyret'
 
 # The default replacements for |version| and |release|, also used in various
 # other places throughout the built documents.
 #
 # The short X.Y version.
-version = '6.4'
+version = '@VERSION@'
 # The full version, including alpha/beta/rc tags.
-release = '6.4.0'
+release = '@VERSION@'
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used: