X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI_HypothesesUtils.cxx;h=556dc5591ffda71982444351eefd0765be1905b0;hp=96f59ae8af1c8c99463bb220e114fb358b7a0377;hb=69a203b6d49da1ff98aaf5c53842ee6ab9efcec1;hpb=f4cb697fcc605c3b9cdb517f9b4eef6b8532dc1a

diff --git a/src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx b/src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx
index 96f59ae8a..556dc5591 100644
--- a/src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx
+++ b/src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx
@@ -66,14 +66,7 @@ namespace SMESH{
   typedef map<string,SMESHGUI_GenericHypothesisCreator*> THypCreatorMap;
   THypCreatorMap myHypCreatorMap;
 
-  void addMap(const THypothesisDataMap& theMap,
-	       THypothesisDataMap& toMap)
-  {
-    THypothesisDataMap::const_iterator it;
-    for (it = theMap.begin(); it != theMap.end(); it++)
-      toMap.insert(*it);
-  }
-
+  list<HypothesesSet*> myListOfHypothesesSets;
 
   void processHypothesisStatus(const int theHypStatus,
 			       SMESH::SMESH_Hypothesis_ptr theHyp,
@@ -160,8 +153,12 @@ namespace SMESH{
 	  bool ok = reader.parse(source);
 	  file.close();
 	  if (ok) {
-	    addMap(aXmlHandler->myHypothesesMap, myHypothesesMap);
-	    addMap(aXmlHandler->myAlgorithmsMap, myAlgorithmsMap);
+            myHypothesesMap.insert( aXmlHandler->myHypothesesMap.begin(),
+                                    aXmlHandler->myHypothesesMap.end() );
+            myAlgorithmsMap.insert( aXmlHandler->myAlgorithmsMap.begin(),
+                                    aXmlHandler->myAlgorithmsMap.end() );
+            myListOfHypothesesSets.splice( myListOfHypothesesSets.begin(),
+                                           aXmlHandler->myListOfHypothesesSets );
 	  }
 	  else {
 	    SUIT_MessageBox::error1(SMESHGUI::desktop(),
@@ -215,6 +212,37 @@ namespace SMESH{
   }
 
 
+  QStringList GetHypothesesSets()
+  {
+    QStringList aSetNameList;
+
+    // Init list of available hypotheses, if needed
+    InitAvailableHypotheses();
+
+    list<HypothesesSet*>::iterator hypoSet = myListOfHypothesesSets.begin();
+    for ( ; hypoSet != myListOfHypothesesSets.end(); ++hypoSet )
+    {
+      HypothesesSet* aSet = *hypoSet;
+      if ( aSet && aSet->AlgoList.count() ) {
+        aSetNameList.append( aSet->HypoSetName );
+      }
+    }
+
+    return aSetNameList;
+  }
+
+  HypothesesSet* GetHypothesesSet(const QString theSetName)
+  {
+    list<HypothesesSet*>::iterator hypoSet = myListOfHypothesesSets.begin();
+    for ( ; hypoSet != myListOfHypothesesSets.end(); ++hypoSet )
+    {
+      HypothesesSet* aSet = *hypoSet;
+      if ( aSet && aSet->HypoSetName == theSetName )
+        return aSet;
+    }
+    return 0;
+  }
+
   HypothesisData* GetHypothesisData (const char* aHypType)
   {
     HypothesisData* aHypData = 0;
@@ -222,17 +250,50 @@ namespace SMESH{
     // Init list of available hypotheses, if needed
     InitAvailableHypotheses();
 
-    if (myHypothesesMap.find(aHypType) == myHypothesesMap.end()) {
-      if (myAlgorithmsMap.find(aHypType) != myAlgorithmsMap.end()) {
-	aHypData = myAlgorithmsMap[aHypType];
-      }
+    THypothesisDataMap::iterator type_data = myHypothesesMap.find(aHypType);
+    if (type_data != myHypothesesMap.end()) {
+      aHypData = type_data->second;
     }
     else {
-      aHypData = myHypothesesMap[aHypType];
+      type_data = myAlgorithmsMap.find(aHypType);
+      if (type_data != myAlgorithmsMap.end())
+        aHypData = type_data->second;
     }
     return aHypData;
   }
 
+  bool IsAvailableHypothesis(const HypothesisData* algoData,
+                             const QString&        hypType,
+                             bool&                 isAuxiliary)
+  {
+    isAuxiliary = false;
+    if ( !algoData )
+      return false;
+    if ( algoData->NeededHypos.contains( hypType ))
+      return true;
+    if ( algoData->OptionalHypos.contains( hypType)) {
+      isAuxiliary = true;
+      return true;
+    }
+    return false;
+  }
+
+  bool IsCompatibleAlgorithm(const HypothesisData* algo1Data,
+                             const HypothesisData* algo2Data)
+  {
+    if ( !algo1Data || !algo2Data )
+      return false;
+    const HypothesisData* algoIn = algo1Data, *algoMain = algo2Data;
+    if ( algoIn->Dim.first() > algoMain->Dim.first() ) {
+      algoIn = algo2Data; algoMain = algo1Data;
+    }
+    // look for any output type of algoIn between input types of algoMain
+    QStringList::const_iterator inElemType = algoIn->OutputTypes.begin();
+    for ( ; inElemType != algoIn->OutputTypes.end(); ++inElemType )
+      if ( algoMain->InputTypes.contains( *inElemType ))
+        return true;
+    return false;
+  }
 
   SMESHGUI_GenericHypothesisCreator* GetHypothesisCreator(const char* aHypType)
   {
@@ -269,7 +330,7 @@ namespace SMESH{
 	  // get method, returning hypothesis creator
 	  if(MYDEBUG) MESSAGE("Find GetHypothesisCreator() method ...");
 	  typedef SMESHGUI_GenericHypothesisCreator* (*GetHypothesisCreator) \
-	    (QString aHypType, QString aServerLibName, SMESHGUI* aSMESHGUI);
+	    ( const QString& );
 	  GetHypothesisCreator procHandle =
 	    (GetHypothesisCreator)dlsym(libHandle, "GetHypothesisCreator");
 	  if (!procHandle) {
@@ -279,7 +340,7 @@ namespace SMESH{
 	  else {
 	    // get hypothesis creator
 	    if(MYDEBUG) MESSAGE("Get Hypothesis Creator for " << aHypType);
-	    aCreator = procHandle(aHypType, aServerLibName, SMESHGUI::GetSMESHGUI());
+	    aCreator = procHandle( aHypType );
 	    if (!aCreator) {
 	      if(MYDEBUG) MESSAGE("no such a hypothesis in this plugin");
 	    }
@@ -347,8 +408,8 @@ namespace SMESH{
       try {
 	res = aMesh->AddHypothesis(aShapeObject, aHyp);
 	if (res < SMESH::HYP_UNKNOWN_FATAL) {
-	  _PTR(SObject) SH = SMESH::FindSObject(aHyp);
-	  if (SM && SH) {
+	  _PTR(SObject) aSH = SMESH::FindSObject(aHyp);
+	  if (SM && aSH) {
 	    SMESH::ModifiedMesh(SM, false);
 	  }
 	}
@@ -521,4 +582,35 @@ namespace SMESH{
     if (MYDEBUG) MESSAGE("SMESHGUI::GetMeshesUsingAlgoOrHypothesis(): completed");
     return listSOmesh;
   }
+
+#define CASE2MESSAGE(enum) case SMESH::enum: msg = QObject::tr( #enum ); break;
+  QString GetMessageOnAlgoStateErrors(const algo_error_array& errors)
+  {
+    QString resMsg = QObject::tr("SMESH_WRN_MISSING_PARAMETERS") + ":\n";
+    for ( int i = 0; i < errors.length(); ++i ) {
+      const SMESH::AlgoStateError & error = errors[ i ];
+      QString msg;
+      switch( error.name ) {
+        CASE2MESSAGE( MISSING_ALGO );
+        CASE2MESSAGE( MISSING_HYPO );
+        CASE2MESSAGE( NOT_CONFORM_MESH );
+      default: continue;
+      }
+      // apply args to message:
+      // %1 - algo name
+      if ( error.algoName.in() != 0 )
+        msg = msg.arg( error.algoName.in() );
+      // %2 - dimention
+      msg = msg.arg( error.algoDim );
+      // %3 - global/local
+      msg = msg.arg( QObject::tr( error.isGlobalAlgo ? "GLOBAL_ALGO" : "LOCAL_ALGO" ));
+      // %4 - hypothesis dim == algoDim
+      msg = msg.arg( error.algoDim );
+
+      if ( i ) resMsg += ";\n";
+      resMsg += msg;
+    }
+    return resMsg;
+  }
+
 }