X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FConfig%2FConfig_Common.cpp;h=bb5ddeed9b001da3700fd3298a3e8eb7e1e79d4f;hb=077c2197bae13c5a45842f12845ef0491d4905c7;hp=1f6ca635630f025a1c781a674ad7e13c76b8b75d;hpb=9ade3feafa3ee13af4f9eaf8ffa2b96f7973709b;p=modules%2Fshaper.git

diff --git a/src/Config/Config_Common.cpp b/src/Config/Config_Common.cpp
index 1f6ca6356..bb5ddeed9 100644
--- a/src/Config/Config_Common.cpp
+++ b/src/Config/Config_Common.cpp
@@ -17,15 +17,17 @@
 
 #include <string>
 #include <algorithm> // for std::transform
+#include <vector>
 
 bool isElementNode(xmlNodePtr theNode)
 {
+  if (!theNode)
+    return false;
   return theNode->type == XML_ELEMENT_NODE;
 }
 
 bool isNode(xmlNodePtr theNode, const char* theNodeName, ...)
 {
-  bool result = false;
   const xmlChar* aName = theNode->name;
   if (!aName || !isElementNode(theNode)) {
     return false;
@@ -48,19 +50,46 @@ bool isNode(xmlNodePtr theNode, const char* theNodeName, ...)
   return false;
 }
 
+bool isAttributeNode(xmlNodePtr theNode)
+{
+  if(!isElementNode(theNode))
+    return false;
+  // it's parent is "feature" or "source" or page ("case" or "box")
+  if(!hasParent(theNode, NODE_FEATURE, NODE_SOURCE, 
+                         WDG_GROUP, WDG_CHECK_GROUP,
+                         WDG_TOOLBOX_BOX, WDG_SWITCH_CASE, NULL))
+    return false;
+
+  //it should not be a "source" or a "validator" node
+  bool isLogical = isNode(theNode, NODE_SOURCE, NODE_VALIDATOR, NODE_SELFILTER, NULL);
+  bool isPagedContainer = isNode(theNode, WDG_TOOLBOX, WDG_TOOLBOX_BOX,
+                                          WDG_GROUP, WDG_CHECK_GROUP,
+                                          WDG_SWITCH, WDG_SWITCH_CASE,  NULL);
+  return !isLogical && !isPagedContainer;
+}
+
 bool isWidgetNode(xmlNodePtr theNode)
 {
   if(!isElementNode(theNode))
     return false;
-  // it's parent is "feature" or "source"
-  xmlNodePtr aParentNode = theNode->parent;
-  if(!isNode(aParentNode, NODE_FEATURE, NODE_SOURCE, NULL))
+  // it's parent is "feature" or "source" or a page ("box", "case")
+  if(!hasParent(theNode, NODE_FEATURE, NODE_SOURCE, WDG_GROUP,
+                         WDG_TOOLBOX_BOX, WDG_SWITCH_CASE, NULL))
     return false;
 
   //it should not be a "source" or a "validator" node
   return !isNode(theNode, NODE_SOURCE, NODE_VALIDATOR, NODE_SELFILTER, NULL);
 }
 
+// widget api?
+bool isCaseNode(xmlNodePtr theNode)
+{
+  if(!isElementNode(theNode))
+    return false;
+
+  return isNode(theNode, WDG_SWITCH_CASE, WDG_TOOLBOX_BOX, NULL);
+}
+
 bool hasChild(xmlNodePtr theNode)
 {
   xmlNodePtr aNode = theNode->children;
@@ -72,25 +101,100 @@ bool hasChild(xmlNodePtr theNode)
   return false;
 }
 
-bool getParametersInfo(xmlNodePtr theNode, std::string& outValidatorId,
+bool hasParent(xmlNodePtr theNode)
+{
+  xmlNodePtr aNode = theNode->parent;
+  if (!aNode) {
+    return false;
+  }
+  for (; aNode; aNode = aNode->next) {
+    if (isElementNode(theNode)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool hasParent(xmlNodePtr theNode, const char* theNodeName, ...)
+{
+  if (!hasParent(theNode)) {
+    return false; // have no parents at all
+  }
+  xmlNodePtr aNode = theNode->parent;
+  const xmlChar* aName = aNode->name;
+  if (!aName || !isElementNode(aNode)) {
+    return false;
+  }
+  if (!xmlStrcmp(aName, (const xmlChar *) theNodeName)) {
+    return true;
+  }
+  va_list args;  // define argument list variable
+  va_start(args, theNodeName);  // init list; point to last defined argument
+  while (true) {
+    char *anArg = va_arg (args, char*);  // get next argument
+    if (anArg == NULL)
+      break;
+    if (!xmlStrcmp(aName, (const xmlChar *) anArg)) {
+      va_end(args);  // cleanup the system stack
+      return true;
+    }
+  }
+  va_end(args);  // cleanup the system stack
+  return false;
+}
+
+bool hasParentRecursive(xmlNodePtr theNode, const std::vector<const char*>& theNodeNames)
+{
+  if (!hasParent(theNode)) {
+    return false; // have no parents at all
+  }
+  xmlNodePtr aNode = theNode->parent;
+  const xmlChar* aName = aNode->name;
+  if (!aName || !isElementNode(aNode)) {
+    return false;
+  }
+  for (size_t anIndex = 0; anIndex < theNodeNames.size(); ++anIndex) {
+    if (!xmlStrcmp(aName, (const xmlChar *) theNodeNames[anIndex]))
+      return true;
+  }
+  return hasParentRecursive(aNode, theNodeNames);
+}
+
+bool hasParentRecursive(xmlNodePtr theNode, const char* theNodeName, ...)
+{
+  std::vector<const char*> aNodeNames;
+  va_list args;  // define argument list variable
+  va_start(args, theNodeName);  // init list; point to last defined argument
+  aNodeNames.push_back(theNodeName);
+  while (true) {
+    char *anArg = va_arg (args, char*);  // get next argument
+    if (anArg == NULL)
+      break;
+    aNodeNames.push_back(anArg);
+  }
+  va_end(args);  // cleanup the system stack
+  return hasParentRecursive(theNode, aNodeNames);
+}
+
+bool getParametersInfo(xmlNodePtr theNode, std::string& outPropertyId,
                       std::list<std::string>& outValidatorParameters)
 {
-  //Validator id:
+  //Property id:
   char* anIdProp = (char*) xmlGetProp(theNode, BAD_CAST _ID);
   if (!anIdProp || anIdProp[0] == 0) {
     return false;
   }
-  outValidatorId = std::string(anIdProp);
+  outPropertyId = std::string(anIdProp);
 
-  //Validator parameters:
+  //Property parameters:
   char* aParamProp = (char*) xmlGetProp(theNode, BAD_CAST _PARAMETERS);
   if (aParamProp && aParamProp[0] != 0) {
     std::string aPropString = std::string(aParamProp);
     std::stringstream aPropStringStream(aPropString);
     char COMMA_DELIM = ',';
-    std::string aValidatorParameter;
-    while (std::getline(aPropStringStream, aValidatorParameter, ',')) {
-      outValidatorParameters.push_back(aValidatorParameter);
+    std::string aParameter;
+    while (std::getline(aPropStringStream, aParameter, ',')) {
+      outValidatorParameters.push_back(aParameter);
     }
   }
   return true;
@@ -126,10 +230,14 @@ std::string getProperty(xmlNodePtr theNode, const char* thePropName)
   return result;
 }
 
+std::string getNormalizedProperty(xmlNodePtr theNode, const char* thePropName)
+{
+  return normalize(getProperty(theNode, thePropName));
+}
+
 bool getBooleanAttribute(xmlNodePtr theNode, const char* theAttributeName, bool theDefault)
 {
-  std::string prop = getProperty(theNode, theAttributeName);
-  std::transform(prop.begin(), prop.end(), prop.begin(), ::tolower);
+  std::string prop = normalize(getProperty(theNode, theAttributeName));
   bool result = theDefault;
   if (prop == "true" || prop == "1") {
     result = true;
@@ -138,3 +246,17 @@ bool getBooleanAttribute(xmlNodePtr theNode, const char* theAttributeName, bool
   }
   return result;
 }
+
+CONFIG_EXPORT std::string normalize(const char* theString)
+{
+  if (!theString)
+    return std::string();
+  return normalize(std::string(theString));
+}
+
+CONFIG_EXPORT std::string normalize(const std::string& theString)
+{
+  std::string result = theString;
+  std::transform(result.begin(), result.end(), result.begin(), ::tolower);
+  return result;
+}