ResInsight: Integrated from Caf trunc. Multi variable fields (multiselect) with option values now handled. Improved PdmUi layout. Improved Viewer widget size behaviour, Xml keyword check.

p4#: 18777

Author: Jacob Støren

cafAnimControl/CMakeLists.txt

@@ -7,7 +7,9 @@ set( QOBJECT_HEADERS
     cafAnimationToolBar.h
 )
 
-qt4_wrap_cpp( MOC_FILES_CPP ${QOBJECT_HEADERS} )
+if ( (${CMAKE_VERSION} VERSION_LESS 2.8.6) OR (NOT CMAKE_AUTOMOC) )
+    qt4_wrap_cpp( MOC_FILES_CPP ${QOBJECT_HEADERS} )
+endif()
 
 # NOTE! Resources in this subfolder appends to the variable QRC_FILES in parent scope
 # CMakeList.txt in the application folder (parent scope) must use the following syntax

cafProjectDataModel/cafPdmField.cpp

@@ -18,6 +18,7 @@
 //##################################################################################################
 
 #include "cafPdmField.h"
+#include "cafPdmObject.h"
 
 #include <iostream>
 
@@ -61,10 +62,24 @@ bool PdmFieldHandle::assertValid() const
         std::cout << "Detected use of non-initialized field\n";
         return false;
     }
-    else
+
+    if (!PdmObject::isValidXmlElementName(m_keyword))
     {
-        return true;
+        std::cout << "Detected keyword " << m_keyword.toStdString() << " which is an invalid Xml element name\n";
+        return false;
     }
+
+    return true;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void PdmFieldHandle::setKeyword(const QString& keyword)
+{
+    assert(PdmObject::isValidXmlElementName(keyword));
+
+    m_keyword = keyword;
 }
 
 //--------------------------------------------------------------------------------------------------

cafProjectDataModel/cafPdmField.h

@@ -54,7 +54,7 @@ class PdmFieldHandle : public PdmUiItem
     void             setIOWritable(bool isWritable)                 {  m_isIOWritable = isWritable; }
     void             setIOReadable(bool isReadable)                 {  m_isIOReadable = isReadable; }
 
-    void             setKeyword(const QString& keyword)             { m_keyword = keyword; }
+    void             setKeyword(const QString& keyword);
     QString          keyword() const                                { return m_keyword;    }
 
     void             setOwnerObject(PdmObject * owner)              { m_ownerObject = owner; }

cafProjectDataModel/cafPdmField.inl

@@ -36,21 +36,61 @@ void caf::PdmField<DataType>::setValueFromUi(const QVariant& uiValue)
 {
     QVariant oldValue = PdmFieldTypeSpecialization<DataType>::convert(m_fieldValue);
 
+    // Check whether we are handling selections of values or actual values
     if (m_optionEntryCache.size())
     {
-        // Check if we got an index into the option list
+       // This has an option based GUI, the uiValue is only indexes into the m_optionEntryCache
         if (uiValue.type() == QVariant::UInt)
         {
             assert(uiValue.toUInt() < static_cast<unsigned int>(m_optionEntryCache.size()));
             PdmFieldTypeSpecialization<DataType>::setFromVariant(m_optionEntryCache[uiValue.toUInt()].value, m_fieldValue); 
         }
-        else
+        else if (uiValue.type() == QVariant::List)
         {
+            QList<QVariant> selectedIndexes = uiValue.toList();
+            QList<QVariant> valuesToSetInField;
+
+            if (selectedIndexes.isEmpty())
+            {
+                PdmFieldTypeSpecialization<DataType>::setFromVariant(valuesToSetInField, m_fieldValue);
+            }
+            else
+            {
+                if (selectedIndexes.front().type() == QVariant::UInt)
+                {
+                    for (int i = 0; i < selectedIndexes.size(); ++i)
+                    {
+                        unsigned int opIdx = selectedIndexes[i].toUInt();
+                        if (opIdx < static_cast<unsigned int>(m_optionEntryCache.size()))
+                        {
+                            valuesToSetInField.push_back(m_optionEntryCache[opIdx].value);
+                        }
+                    }
+
+                    PdmFieldTypeSpecialization<DataType>::setFromVariant(valuesToSetInField, m_fieldValue);
+                }
+                else
+                {
+                    // We are not getting indexes as expected from the UI. For now assert, to catch this condition
+                    // but it should possibly be handled as setting the values explicitly. The code for that is below the assert
+                    assert(false);
+                    PdmFieldTypeSpecialization<DataType>::setFromVariant(uiValue, m_fieldValue);
+                    m_optionEntryCache.clear();
+                }
+            }
+
+        }
+        else 
+        { 
+            // We are not getting indexes as expected from the UI. For now assert, to catch this condition
+            // but it should possibly be handled as setting the values explicitly. The code for that is below the assert
+            assert(false);
+            PdmFieldTypeSpecialization<DataType>::setFromVariant(uiValue, m_fieldValue);
             m_optionEntryCache.clear();
         }
     }
     else
-    {
+    {   // Not an option based GUI, the uiValue is a real field value
         PdmFieldTypeSpecialization<DataType>::setFromVariant(uiValue, m_fieldValue);
     }
 
@@ -68,51 +108,109 @@ void caf::PdmField<DataType>::setValueFromUi(const QVariant& uiValue)
 } 
 
 //--------------------------------------------------------------------------------------------------
-/// 
+/// Returns the option values that is to be displayed in the UI for this field. 
+/// This method calls the virtual PdmObject::calculateValueOptions to get the list provided from the 
+/// application, then possibly adds the current field value(s) to the list, to 
+/// make sure the actual values are shown
 //--------------------------------------------------------------------------------------------------
 template<typename DataType >
 QList<PdmOptionItemInfo> caf::PdmField<DataType>::valueOptions(bool* useOptionsOnly)
 {
+    // First check if the owner PdmObject has a value options specification. 
+    // if it has, use it.
     if (m_ownerObject)
     {
         m_optionEntryCache = m_ownerObject->calculateValueOptions(this, useOptionsOnly);
         if (m_optionEntryCache.size())
         {
-            // Find this field value in the list if present
+            // Make sure the options contain the field values, event though they not necessarily 
+            // is supplied as possible options by the application. This is a convenience making sure
+            // the actual data in the pdmObject is shown correctly in the UI, and to prevent accidental 
+            // changes of the field values
+
+            // Find the field value(s) in the list if present
+
             QVariant convertedFieldValue = PdmFieldTypeSpecialization<DataType>::convert(m_fieldValue);
-            unsigned int index;
-            bool foundFieldValue = PdmOptionItemInfo::findValue(m_optionEntryCache, convertedFieldValue, &index);
 
-            // If not found, we have to add it to the list, to be able to show it
+            std::vector<unsigned int> foundIndexes;
+            bool foundAllFieldValues = PdmOptionItemInfo::findValues(m_optionEntryCache, convertedFieldValue, foundIndexes);
+            
+            // If not all are found, we have to add the missing to the list, to be able to show it
 
-            if (!foundFieldValue)
+            if (!foundAllFieldValues)
             {
-                m_optionEntryCache.push_front(PdmOptionItemInfo(convertedFieldValue.toString(), convertedFieldValue, true, QIcon()));
+                if (convertedFieldValue.type() != QVariant::List)  // Single value field
+                {
+                    m_optionEntryCache.push_front(PdmOptionItemInfo(convertedFieldValue.toString(), convertedFieldValue, true, QIcon()));
+                }
+                else // The field value is a list of values 
+                {
+                    QList<QVariant> valuesSelectedInField = convertedFieldValue.toList();
+                    for (int i= 0 ; i < valuesSelectedInField.size(); ++i)
+                    {
+                        bool isFound = false;
+                        for (unsigned int opIdx = 0; opIdx < static_cast<unsigned int>(m_optionEntryCache.size()); ++opIdx)
+                        {
+                            if (valuesSelectedInField[i] == m_optionEntryCache[opIdx].value) isFound = true;
+                        }
+
+                        if (!isFound)
+                        {
+                            m_optionEntryCache.push_front(PdmOptionItemInfo(valuesSelectedInField[i].toString(), valuesSelectedInField[i], true, QIcon()));
+                        }
+                    }
+                }
             }
 
-            if (m_optionEntryCache.size()) return m_optionEntryCache;
+            return m_optionEntryCache;
         }
     }
 
+    // If we have no options, use the options defined by the type. Normally only caf::AppEnum type
+
     return PdmFieldTypeSpecialization<DataType>::valueOptions(useOptionsOnly, m_fieldValue);
 }
 
 //--------------------------------------------------------------------------------------------------
-/// 
+/// Extracts a QVariant representation of the data in the field to be used in the UI. 
+/// Note that for fields with a none empty valueOptions list the returned QVariant contains the 
+/// indexes to the selected options rather than the actual values, if they can be found.
+/// If we cant find them, the method asserts, forcing the valueOptions to always contain the field values
 //--------------------------------------------------------------------------------------------------
 template<typename DataType >
 QVariant caf::PdmField<DataType>::uiValue() const
 {
     if (m_optionEntryCache.size())
     {
         QVariant convertedFieldValue = PdmFieldTypeSpecialization<DataType>::convert(m_fieldValue);
-        unsigned int index;
-        bool foundFieldValue = PdmOptionItemInfo::findValue(m_optionEntryCache, convertedFieldValue, &index);
-        assert(foundFieldValue);
-        return QVariant(index);
-    }
+        std::vector<unsigned int> indexes;
+        PdmOptionItemInfo::findValues(m_optionEntryCache, convertedFieldValue, indexes);
+        if (convertedFieldValue.type() == QVariant::List)
+        {
+            if (indexes.size() == convertedFieldValue.toList().size())
+            {
+                QList<QVariant> returnList;
+                for(size_t i = 0; i < indexes.size(); ++i)
+                {
+                    returnList.push_back(QVariant(indexes[i]));
+                }
+                return QVariant(returnList);
+            }
+            assert(false); // Did not find all the field values among the options available.
+        }
+        else
+        {
+            if (indexes.size() == 1) return QVariant(indexes.front());
+        }
 
-    return PdmFieldTypeSpecialization<DataType>::convert(m_fieldValue);
+        assert(false);
+        return convertedFieldValue;
+    }
+    else
+    {
+        return PdmFieldTypeSpecialization<DataType>::convert(m_fieldValue);
+    }
+    
 }
 
 //==================================================================================================

cafProjectDataModel/cafPdmFieldImpl.h

@@ -262,7 +262,7 @@ class PdmFieldTypeSpecialization < caf::AppEnum<T> >
         int i;
         for (i = 0; i < optionTexts.size(); ++i)
         {
-            optionList.push_back(PdmOptionItemInfo(optionTexts[i]));
+            optionList.push_back(PdmOptionItemInfo(optionTexts[i], static_cast<unsigned int>(i)));
         }
 
         return optionList;

cafProjectDataModel/cafPdmObject.cpp

@@ -130,6 +130,8 @@ void PdmObject::writeFields(QXmlStreamWriter& xmlStream)
         if (field->isIOWritable())
         {
             QString keyword = field->keyword();
+            assert(PdmObject::isValidXmlElementName(keyword));
+
             xmlStream.writeStartElement("", keyword);
             field->writeFieldData(xmlStream);
             xmlStream.writeEndElement();
@@ -277,5 +279,43 @@ void PdmObject::editorAttribute(const PdmFieldHandle* field, QString uiConfigNam
     this->defineEditorAttribute(field, uiConfigName, attribute);
 }
 
+//--------------------------------------------------------------------------------------------------
+/// Check if a string is a valid Xml element name
+//
+/// http://www.w3schools.com/xml/xml_elements.asp
+///
+/// XML elements must follow these naming rules:
+///   Names can contain letters, numbers, and other characters
+///   Names cannot start with a number or punctuation character
+///   Names cannot start with the letters xml (or XML, or Xml, etc)
+///   Names cannot contain spaces
+//--------------------------------------------------------------------------------------------------
+bool PdmObject::isValidXmlElementName(const QString& name)
+{
+    if (name.size() > 0)
+    {
+        QChar firstChar = name[0];
+        if (firstChar.isDigit() || firstChar == '.')
+        {
+            return false;
+        }
+    }
+
+    if (name.size() >= 3)
+    {
+        if (name.left(3).compare("xml", Qt::CaseInsensitive) == 0)
+        {
+            return false;
+        }
+    }
+
+    if (name.contains(' '))
+    {
+        return false;
+    }
+
+    return true;
+}
+
 
 } //End of namespace caf

cafProjectDataModel/cafPdmObject.h

@@ -67,7 +67,7 @@ public: \
 /// Place this in the cpp file, preferably above the constructor
 
 #define CAF_PDM_SOURCE_INIT(ClassName, keyword) \
-    QString ClassName::classKeywordStatic() { return keyword;   } \
+    QString ClassName::classKeywordStatic() { assert(PdmObject::isValidXmlElementName(keyword)); return keyword;   } \
     static bool PDM_OBJECT_STRING_CONCATENATE(pdm_object_factory_init_, __LINE__) = caf::PdmObjectFactory::instance()->registerCreator<ClassName>()
 
 /// InitObject sets up the user interface related information for the object
@@ -143,6 +143,11 @@ class PdmObject : public PdmUiItem
                             calculateValueOptions(const PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) { return QList<PdmOptionItemInfo>(); }
     // For later // virtual void editorAttributeChangedByUI(const PdmFieldHandle* field, QString uiConfigName, const PdmUiAttributeHandle * attributes);
 
+
+public:
+    /// Check if a string is a valid Xml element name
+    static bool isValidXmlElementName(const QString& name);
+
 protected: // Virtual 
     /// Method gets called from PdmDocument after all objects are read. 
     /// Re-implement to set up internal pointers etc. in your data structure