mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
481 lines
16 KiB
C++
481 lines
16 KiB
C++
//##################################################################################################
|
|
//
|
|
// Custom Visualization Core library
|
|
// Copyright (C) 2011-2013 Ceetron AS
|
|
//
|
|
// This library may be used under the terms of either the GNU General Public License or
|
|
// the GNU Lesser General Public License as follows:
|
|
//
|
|
// GNU General Public License Usage
|
|
// This library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
// FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// See the GNU General Public License at <<http://www.gnu.org/licenses/gpl.html>>
|
|
// for more details.
|
|
//
|
|
// GNU Lesser General Public License Usage
|
|
// This library is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation; either version 2.1 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
// FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// See the GNU Lesser General Public License at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
|
|
// for more details.
|
|
//
|
|
//##################################################################################################
|
|
|
|
|
|
#include "cafPdmField.h"
|
|
#include "cafPdmObject.h"
|
|
|
|
#include <iostream>
|
|
|
|
#include <QXmlStreamReader>
|
|
#include <QXmlStreamWriter>
|
|
#include "cafPdmObjectFactory.h"
|
|
#include "cafPdmDocument.h"
|
|
#include "cafPdmUiTreeOrdering.h"
|
|
|
|
namespace caf
|
|
{
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Reads all the fields into this PdmObject
|
|
/// Assumes xmlStream points to the start element token of the PdmObject for which to read fields.
|
|
/// ( and not first token of object content)
|
|
/// This makes attribute based field storage possible.
|
|
/// Leaves the xmlStream pointing to the EndElement of the PdmObject.
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::readFields (QXmlStreamReader& xmlStream )
|
|
{
|
|
bool isObjectFinished = false;
|
|
QXmlStreamReader::TokenType type;
|
|
while(!isObjectFinished)
|
|
{
|
|
type = xmlStream.readNext();
|
|
|
|
switch (type)
|
|
{
|
|
case QXmlStreamReader::StartElement:
|
|
{
|
|
QString name = xmlStream.name().toString();
|
|
if (name == QString("SimpleObjPtrField"))
|
|
{
|
|
int a;
|
|
a = 2 + 7;
|
|
}
|
|
PdmFieldHandle* currentField = findField(name);
|
|
if (currentField)
|
|
{
|
|
if (currentField->isIOReadable())
|
|
{
|
|
// readFieldData assumes that the xmlStream points to first token of field content.
|
|
// After reading, the xmlStream is supposed to point to the first token after the field content.
|
|
// (typically an "endElement")
|
|
QXmlStreamReader::TokenType tt;
|
|
tt = xmlStream.readNext();
|
|
currentField->readFieldData( xmlStream );
|
|
}
|
|
else
|
|
{
|
|
xmlStream.skipCurrentElement();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::cout << "Line "<< xmlStream.lineNumber() << ": Warning: Could not find a field with name " << name.toLatin1().data() << " in the current object : " << classKeyword().toLatin1().data() << std::endl;
|
|
xmlStream.skipCurrentElement();
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case QXmlStreamReader::EndElement:
|
|
{
|
|
// End of object.
|
|
QString name = xmlStream.name().toString(); // For debugging
|
|
isObjectFinished = true;
|
|
}
|
|
break;
|
|
case QXmlStreamReader::EndDocument:
|
|
{
|
|
// End of object.
|
|
isObjectFinished = true;
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
// Just read on
|
|
// Todo: Error handling
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::writeFields(QXmlStreamWriter& xmlStream)
|
|
{
|
|
std::vector<PdmFieldHandle*>::iterator it;
|
|
for (it = m_fields.begin(); it != m_fields.end(); ++it)
|
|
{
|
|
PdmFieldHandle* field = *it;
|
|
if (field->isIOWritable())
|
|
{
|
|
QString keyword = field->keyword();
|
|
assert(PdmObject::isValidXmlElementName(keyword));
|
|
|
|
xmlStream.writeStartElement("", keyword);
|
|
field->writeFieldData(xmlStream);
|
|
xmlStream.writeEndElement();
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
PdmFieldHandle* PdmObject::findField(const QString& keyword)
|
|
{
|
|
std::vector<PdmFieldHandle*>::iterator it;
|
|
for (it = m_fields.begin(); it != m_fields.end(); it++)
|
|
{
|
|
PdmFieldHandle* obj = *it;
|
|
if (obj->keyword() == keyword)
|
|
{
|
|
return obj;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
PdmObject::~PdmObject()
|
|
{
|
|
// Set all guarded pointers pointing to this to NULL
|
|
|
|
std::set<PdmObject**>::iterator it;
|
|
for (it = m_pointersReferencingMe.begin(); it != m_pointersReferencingMe.end() ; ++it)
|
|
{
|
|
(**it) = NULL;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::fields(std::vector<PdmFieldHandle*>& fields) const
|
|
{
|
|
fields = m_fields;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::addParentField(PdmFieldHandle* parentField)
|
|
{
|
|
if (parentField != NULL) m_parentFields.insert(parentField);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::removeParentField(PdmFieldHandle* parentField)
|
|
{
|
|
if (parentField != NULL) m_parentFields.erase(parentField);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Appends pointers to all the PdmFields/PdmPointerFields containing a pointer to this object.
|
|
/// As the PdmPointersField can hold several pointers to the same object, the returned vector can
|
|
/// contain multiple pointers to the same field.
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::parentFields(std::vector<PdmFieldHandle*>& parentFields) const
|
|
{
|
|
std::multiset<PdmFieldHandle*>::const_iterator it;
|
|
|
|
for (it = m_parentFields.begin(); it != m_parentFields.end(); ++it)
|
|
{
|
|
parentFields.push_back(*it);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::parentObjects(std::vector<PdmObject*>& objects) const
|
|
{
|
|
std::vector<caf::PdmFieldHandle*> parentFields;
|
|
this->parentFields(parentFields);
|
|
size_t i;
|
|
for (i = 0; i < parentFields.size(); i++)
|
|
{
|
|
objects.push_back(parentFields[i]->ownerObject());
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::removeFromParentFields()
|
|
{
|
|
std::vector<caf::PdmFieldHandle*> parentFields;
|
|
this->parentFields(parentFields);
|
|
size_t i;
|
|
for (i = 0; i < parentFields.size(); i++)
|
|
{
|
|
parentFields[i]->removeChildObject(this);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::addFieldNoDefault(PdmFieldHandle* field, const QString& keyword, PdmUiItemInfo * fieldDescription)
|
|
{
|
|
field->setUiItemInfo(fieldDescription);
|
|
field->setKeyword(keyword);
|
|
field->setOwnerObject(this);
|
|
|
|
assert(findField(keyword) == NULL);
|
|
m_fields.push_back(field);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::uiOrdering(QString uiConfigName, PdmUiOrdering& uiOrdering)
|
|
{
|
|
this->defineUiOrdering(uiConfigName, uiOrdering);
|
|
if (!uiOrdering.forgetRemainingFields())
|
|
{
|
|
// Add the remaining Fields To UiConfig
|
|
|
|
for (size_t i = 0; i < m_fields.size(); ++i)
|
|
{
|
|
if (!uiOrdering.contains(m_fields[i]))
|
|
{
|
|
uiOrdering.add( m_fields[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::editorAttribute(const PdmFieldHandle* field, QString uiConfigName, PdmUiEditorAttribute * attribute)
|
|
{
|
|
this->defineEditorAttribute(field, uiConfigName, attribute);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::objectEditorAttribute(QString uiConfigName, PdmUiEditorAttribute* attribute)
|
|
{
|
|
this->defineObjectEditorAttribute(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;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
PdmObject* PdmObject::deepCopy()
|
|
{
|
|
QString encodedXml;
|
|
|
|
{
|
|
PdmObjectGroup typedObjectGroup;
|
|
typedObjectGroup.addObject(this);
|
|
|
|
QXmlStreamWriter xmlStream(&encodedXml);
|
|
xmlStream.setAutoFormatting(true);
|
|
|
|
typedObjectGroup.writeFields(xmlStream);
|
|
}
|
|
|
|
PdmObject* pdmCopy = NULL;
|
|
{
|
|
// Read back XML into object group, factory methods will be called that will create new objects
|
|
PdmObjectGroup destinationObjectGroup;
|
|
QXmlStreamReader xmlStream(encodedXml);
|
|
destinationObjectGroup.readFields(xmlStream);
|
|
|
|
if (destinationObjectGroup.objects.size() == 1)
|
|
{
|
|
pdmCopy = destinationObjectGroup.objects[0];
|
|
}
|
|
}
|
|
|
|
return pdmCopy;
|
|
|
|
/*
|
|
PdmObject* cloneRoot = PdmObjectFactory::instance()->create(this->classKeyword());
|
|
|
|
|
|
|
|
QString encodedXml;
|
|
{
|
|
QXmlStreamWriter xmlStream(&encodedXml);
|
|
xmlStream.setAutoFormatting(true);
|
|
|
|
this->writeFields(xmlStream);
|
|
}
|
|
|
|
QXmlStreamReader xmlStream(encodedXml);
|
|
cloneRoot->readFields(xmlStream);
|
|
|
|
return cloneRoot;
|
|
*/
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// This method is to be used to create a tree-representation of the object hierarchy starting at this
|
|
/// object. The caller is responsible to delete the returned PdmUiTreeOrdering
|
|
//--------------------------------------------------------------------------------------------------
|
|
PdmUiTreeOrdering* PdmObject::uiTreeOrdering(QString uiConfigName /*= ""*/)
|
|
{
|
|
PdmUiTreeOrdering* uiTreeOrdering = new PdmUiTreeOrdering(NULL, -1, this);
|
|
|
|
this->defineUiTreeOrdering(*uiTreeOrdering, uiConfigName);
|
|
|
|
if (!uiTreeOrdering->forgetRemainingFields())
|
|
{
|
|
// Add the remaining Fields To UiConfig
|
|
|
|
for (size_t fIdx = 0; fIdx < m_fields.size(); ++fIdx)
|
|
{
|
|
if (m_fields[fIdx]->hasChildObjects() && !uiTreeOrdering->containsField(m_fields[fIdx]))
|
|
{
|
|
if (m_fields[fIdx]->isUiHidden() && !m_fields[fIdx]->isUiChildrenHidden())
|
|
{
|
|
std::vector<PdmObject*> children;
|
|
m_fields[fIdx]->childObjects(&children);
|
|
|
|
for (size_t cIdx = 0; cIdx < children.size(); cIdx++)
|
|
{
|
|
if (!uiTreeOrdering->containsObject(children[cIdx]))
|
|
{
|
|
uiTreeOrdering->add(children[cIdx]);
|
|
}
|
|
}
|
|
}
|
|
else if ( !m_fields[fIdx]->isUiHidden())
|
|
{
|
|
uiTreeOrdering->add(m_fields[fIdx]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
addUiTreeChildren(uiTreeOrdering, uiConfigName);
|
|
return uiTreeOrdering;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::addUiTreeChildren(PdmUiTreeOrdering* root, QString uiConfigName /*= "" */)
|
|
{
|
|
if (!root) return;
|
|
|
|
if ( root->childCount() == 0) // This means that no one has tried to expand it.
|
|
{
|
|
if (!root->ignoreSubTree() && root->dataObject())
|
|
{
|
|
|
|
if (root->m_field && !root->m_field->isUiChildrenHidden(uiConfigName))
|
|
{
|
|
std::vector<PdmObject*> fieldsChildObjects;
|
|
root->m_field->childObjects(&fieldsChildObjects);
|
|
for (size_t cIdx = 0; cIdx < fieldsChildObjects.size(); ++cIdx)
|
|
{
|
|
root->add(fieldsChildObjects[cIdx]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
root->object()->defineUiTreeOrdering(*root, uiConfigName);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int cIdx = 0; cIdx < root->childCount(); ++cIdx)
|
|
{
|
|
PdmUiTreeOrdering* child = dynamic_cast<PdmUiTreeOrdering*>(root->child(cIdx));
|
|
if (!child->ignoreSubTree())
|
|
{
|
|
addUiTreeChildren(child);
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void PdmObject::updateUiIconFromToggleField()
|
|
{
|
|
if (objectToggleField())
|
|
{
|
|
bool active = objectToggleField()->uiValue().toBool();
|
|
updateUiIconFromState(active);
|
|
}
|
|
}
|
|
|
|
|
|
} //End of namespace caf
|