X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FConfig%2FConfig_FeatureReader.cpp;h=2b024061a5335aa2ee405d36c6ddaca7726516e1;hb=e9f48e35e26dfce648e2f6ecbe1e43c51ba32a7e;hp=91e59df393658825a7fe3e4bf852d71c3adc13ef;hpb=55106ca3aef765fc36d57720060c185d745f25db;p=modules%2Fshaper.git

diff --git a/src/Config/Config_FeatureReader.cpp b/src/Config/Config_FeatureReader.cpp
index 91e59df39..2b024061a 100644
--- a/src/Config/Config_FeatureReader.cpp
+++ b/src/Config/Config_FeatureReader.cpp
@@ -1,3 +1,5 @@
+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
+
 /*
  * Config_FeatureReader.cpp
  *
@@ -49,7 +51,7 @@ void Config_FeatureReader::processNode(xmlNodePtr theNode)
   Events_ID aMenuItemEvent = Events_Loop::eventByName(myEventGenerated);
   if (isNode(theNode, NODE_FEATURE, NULL)) {
     storeAttribute(theNode, _ID);
-    boost::shared_ptr<Config_FeatureMessage> aMessage(new Config_FeatureMessage(aMenuItemEvent, this));
+    std::shared_ptr<Config_FeatureMessage> aMessage(new Config_FeatureMessage(aMenuItemEvent, this));
     fillFeature(theNode, aMessage);
     myFeatures.push_back(getProperty(theNode, _ID));
     //If a feature has xml definition for it's widget:
@@ -59,71 +61,81 @@ void Config_FeatureReader::processNode(xmlNodePtr theNode)
   } else if (isNode(theNode, NODE_WORKBENCH, NODE_GROUP, NULL)) {
     storeAttribute(theNode, _ID);
     storeAttribute(theNode, WORKBENCH_DOC);
-  } else if (myIsProcessWidgets && isWidgetNode(theNode)) {
-    boost::shared_ptr<Config_AttributeMessage> aMessage(new Config_AttributeMessage(aMenuItemEvent, this));
-    aMessage->setFeatureId(restoreAttribute(NODE_FEATURE, _ID));
-    aMessage->setAttributeId(getProperty(theNode, _ID));
-    aMessage->setObligatory(getBooleanAttribute(theNode, ATTRIBUTE_OBLIGATORY, true));
-    aMessage->setConcealment(getBooleanAttribute(theNode, ATTRIBUTE_CONCEALMENT, false));
-    Events_Loop::loop()->send(aMessage);
+  } else if (myIsProcessWidgets) {
+    // widgets, like shape_selector or containers, like toolbox
+    if (isAttributeNode(theNode)) {
+      std::shared_ptr<Config_AttributeMessage> aMessage(new Config_AttributeMessage(aMenuItemEvent, this));
+      aMessage->setFeatureId(restoreAttribute(NODE_FEATURE, _ID));
+      std::string anAttributeID = getProperty(theNode, _ID);
+      if (!anAttributeID.empty()) {
+        aMessage->setAttributeId(anAttributeID);
+        aMessage->setObligatory(getBooleanAttribute(theNode, ATTR_OBLIGATORY, true));
+        aMessage->setConcealment(getBooleanAttribute(theNode, ATTR_CONCEALMENT, false));
+        // nested "paged" widgets are not allowed, this issue may be resolved here:
+        if (hasParent(theNode, WDG_SWITCH_CASE, WDG_TOOLBOX_BOX, NULL)) {
+          const char* kWdgCase = hasParent(theNode, WDG_SWITCH_CASE, NULL)
+                                 ? WDG_SWITCH_CASE
+                                 : WDG_TOOLBOX_BOX;
+          const char* kWdgSwitch = hasParent(theNode, WDG_SWITCH_CASE, NULL)
+                                   ? WDG_SWITCH
+                                   : WDG_TOOLBOX;
+          aMessage->setCaseId(restoreAttribute(kWdgCase, _ID));
+          aMessage->setSwitchId(restoreAttribute(kWdgSwitch, _ID));
+        }
+        Events_Loop::loop()->send(aMessage);
+      }
+    // container pages, like "case" or "box"
+    } else if (isNode(theNode, WDG_SWITCH, WDG_SWITCH_CASE, WDG_TOOLBOX, WDG_TOOLBOX_BOX, NULL)) {
+      storeAttribute(theNode, _ID); // save case:caseId (or box:boxId)
+    }
   }
-  //Process SOURCE, VALIDATOR nodes.
+  //Process SOURCE nodes.
   Config_XMLReader::processNode(theNode);
 }
 
+void Config_FeatureReader::cleanup(xmlNodePtr theNode)
+{
+  if (isNode(theNode, WDG_SWITCH, WDG_SWITCH_CASE, WDG_TOOLBOX, WDG_TOOLBOX_BOX, NULL)) {
+    // cleanup id of cases when leave case node
+    cleanupAttribute(theNode, _ID);
+  }
+}
+
 bool Config_FeatureReader::processChildren(xmlNodePtr theNode)
 {
   bool result = isNode(theNode, NODE_WORKBENCH, NODE_GROUP, NULL);
   if(!result && myIsProcessWidgets) {
-    result = isNode(theNode, NODE_FEATURE, NULL);
+    result = isNode(theNode, NODE_FEATURE, 
+                             WDG_TOOLBOX, WDG_TOOLBOX_BOX,
+                             WDG_SWITCH, WDG_SWITCH_CASE, NULL);
   }
   return result;
 }
 
-void Config_FeatureReader::fillFeature(xmlNodePtr theNode, 
-  const boost::shared_ptr<Config_FeatureMessage>& outFeatureMessage)
+void Config_FeatureReader::fillFeature(xmlNodePtr theFeatureNode,
+  const std::shared_ptr<Config_FeatureMessage>& outFeatureMessage)
 {
-  outFeatureMessage->setId(getProperty(theNode, _ID));
+  outFeatureMessage->setId(getProperty(theFeatureNode, _ID));
   outFeatureMessage->setPluginLibrary(myLibraryName);
-  outFeatureMessage->setNestedFeatures(getProperty(theNode, FEATURE_NESTED));
+  outFeatureMessage->setNestedFeatures(getProperty(theFeatureNode, FEATURE_NESTED));
+  outFeatureMessage->setActionsWhenNested(getNormalizedProperty(theFeatureNode, FEATURE_WHEN_NESTED));
 
-  bool isInternal = getBooleanAttribute(theNode, ATTRIBUTE_INTERNAL, false);
+  bool isInternal = getBooleanAttribute(theFeatureNode, ATTR_INTERNAL, false);
   outFeatureMessage->setInternal(isInternal);
   if (isInternal) {
     //Internal feature has no visual representation.
     return;
   }
-  outFeatureMessage->setText(getProperty(theNode, FEATURE_TEXT));
-  outFeatureMessage->setTooltip(getProperty(theNode, FEATURE_TOOLTIP));
-  outFeatureMessage->setIcon(getProperty(theNode, FEATURE_ICON));
-  outFeatureMessage->setKeysequence(getProperty(theNode, FEATURE_KEYSEQUENCE));
+  outFeatureMessage->setText(getProperty(theFeatureNode, FEATURE_TEXT));
+  outFeatureMessage->setTooltip(getProperty(theFeatureNode, FEATURE_TOOLTIP));
+  outFeatureMessage->setIcon(getProperty(theFeatureNode, FEATURE_ICON));
+  outFeatureMessage->setKeysequence(getProperty(theFeatureNode, FEATURE_KEYSEQUENCE));
   outFeatureMessage->setGroupId(restoreAttribute(NODE_GROUP, _ID));
   outFeatureMessage->setWorkbenchId(restoreAttribute(NODE_WORKBENCH, _ID));
-  outFeatureMessage->setDocumentKind(restoreAttribute(NODE_WORKBENCH, WORKBENCH_DOC));
-}
-
-void Config_FeatureReader::storeAttribute(xmlNodePtr theNode,
-                                          const char* theNodeAttribute)
-{
-  std::string aKey = getNodeName(theNode) + ":" + std::string(theNodeAttribute);
-  std::string aValue = getProperty(theNode, theNodeAttribute);
-  if(!aValue.empty()) {
-    myParentAttributes[aKey] = aValue;
-  }
-}
-
-std::string Config_FeatureReader::restoreAttribute(xmlNodePtr theNode,
-                                                   const char* theNodeAttribute)
-{
-  return restoreAttribute(getNodeName(theNode).c_str(), theNodeAttribute);
-}
-std::string Config_FeatureReader::restoreAttribute(const char* theNodeName,
-                                                   const char* theNodeAttribute)
-{
-  std::string aKey = std::string(theNodeName) + ":" + std::string(theNodeAttribute);
-  std::string result = "";
-  if(myParentAttributes.find(aKey) != myParentAttributes.end()) {
-    result = myParentAttributes[aKey];
+  // Get document kind of a feature, if empty set workbench's kind (might be empty too)
+  std::string aDocKind = getProperty(theFeatureNode, FEATURE_DOC);
+  if(aDocKind.empty()) {
+    aDocKind = restoreAttribute(NODE_WORKBENCH, WORKBENCH_DOC);
   }
-  return result;
+  outFeatureMessage->setDocumentKind(aDocKind);
 }