GUI::Session::XML Namespace Reference

Namespaces
	Tags

Functions
void	assertExpectedTag (QXmlStreamReader *reader, const QString &tag)
void	gotoEndElementOfTag (QXmlStreamReader *reader, const QString &tag)
constexpr auto	InstrumentModelTag ("InstrumentModel")
constexpr auto	ItemTag ("Item")
constexpr auto	JobModelTag ("JobModel")
constexpr auto	ModelTypeAttribute ("ModelType")
constexpr auto	ParameterTag ("Parameter")
void	readAttribute (QXmlStreamReader *reader, const QString &attributeBaseName, complex_t *c)
void	readAttribute (QXmlStreamReader *reader, const QString &attributeBaseName, R3 *vec)
void	readAttribute (QXmlStreamReader *reader, const QString &attributeName, double *d)
void	readAttribute (QXmlStreamReader *reader, const QString &attributeName, QColor *c)
void	readAttribute (QXmlStreamReader *reader, const QString &attributeName, QString *s)
bool	readBoolAttribute (QXmlStreamReader *reader, const QString &attributeName)
void	readItems (QXmlStreamReader *reader, SessionItem *parent, QString topTag="", MessageService *messageService=nullptr)
QString	readProperty (QXmlStreamReader *reader, SessionItem *item)
unsigned	readUIntAttribute (QXmlStreamReader *reader, const QString &attributeName)
constexpr auto	RealDataModelTag ("RealDataModel")
constexpr auto	Version ("Version")
void	writeAttribute (QXmlStreamWriter *writer, const QString &attributeBaseName, const complex_t &c)
void	writeAttribute (QXmlStreamWriter *writer, const QString &attributeBaseName, const R3 &vec)
void	writeAttribute (QXmlStreamWriter *writer, const QString &attributeName, const QVariant &variant)
	Write the variant's value as an attribute. More...
void	writeAttribute (QXmlStreamWriter *writer, const QString &attributeName, double d)
void	writeAttribute (QXmlStreamWriter *writer, const QString &attributeName, int d)
void	writeAttribute (QXmlStreamWriter *writer, const QString &attributeName, unsigned d)
void	writeItemAndChildItems (QXmlStreamWriter *writer, const SessionItem *item)
void	writeModel (QXmlStreamWriter *writer, SessionItem *modelRootItem)
void	writeUid (QXmlStreamWriter *writer, const QString &id)
void	writeUid (QXmlStreamWriter *writer, const QUuid &id)
void	writeVariant (QXmlStreamWriter *writer, QVariant variant, int role)
	Write the variant as a complete tag, including the given role. More...

Variables
constexpr auto	ItemMimeType = "application/org.bornagainproject.xml.item.z"
constexpr auto	LinkMimeType = "application/org.bornagainproject.fittinglink"

Function Documentation

assertExpectedTag()

void GUI::Session::XML::assertExpectedTag	(	QXmlStreamReader *	reader,
		const QString &	tag
	)

Definition at line 199 of file UtilXML.cpp.

{
    if (reader->name() != expectedTag) {
#ifdef _DEBUG
        // to simplify debugging: what is the current tag
        QString foundTag = reader->name().toString();
        Q_UNUSED(foundTag);
#endif
        throw DeserializationException::streamError();
    }
}

References DeserializationException::streamError().

Referenced by ProjectDocument::readProject().

Here is the call graph for this function:

gotoEndElementOfTag()

void GUI::Session::XML::gotoEndElementOfTag	(	QXmlStreamReader *	reader,
		const QString &	tag
	)

Definition at line 49 of file UtilXML.cpp.

{
    ASSERT(reader);
    if (reader->name() != tag) {
        if (!reader->isEndElement())
            reader->skipCurrentElement();
        reader->skipCurrentElement();
    }
    assertCurrentTag(reader, tag);
    if (!reader->isEndElement())
        reader->skipCurrentElement();
 
    assertCurrentToken(reader, QXmlStreamReader::EndElement);
    assertCurrentTag(reader, tag);
}

Referenced by readItems(), and JobItem::readNonSessionItems().

InstrumentModelTag()

constexpr auto GUI::Session::XML::InstrumentModelTag ( "InstrumentModel"  )

constexpr

ItemTag()

constexpr auto GUI::Session::XML::ItemTag ( "Item"  )

constexpr

Referenced by SessionModel::canDropMimeData(), readItems(), and writeItemAndChildItems().

JobModelTag()

constexpr auto GUI::Session::XML::JobModelTag ( "JobModel"  )

constexpr

Referenced by JobModel::JobModel().

ModelTypeAttribute()

constexpr auto GUI::Session::XML::ModelTypeAttribute ( "ModelType"  )

constexpr

Referenced by SessionModel::canDropMimeData(), readItems(), and writeItemAndChildItems().

ParameterTag()

constexpr auto GUI::Session::XML::ParameterTag ( "Parameter"  )

constexpr

Referenced by readItems(), and writeVariant().

readAttribute() [1/5]

void GUI::Session::XML::readAttribute	(	QXmlStreamReader *	reader,
		const QString &	attributeBaseName,
		complex_t *	c
	)

Definition at line 183 of file UtilXML.cpp.

{
    double r, i;
    readAttribute(reader, attributeBaseName + "Re", &r);
    readAttribute(reader, attributeBaseName + "Im", &i);
    c->real(r);
    c->imag(i);
}

References readAttribute().

Here is the call graph for this function:

readAttribute() [2/5]

void GUI::Session::XML::readAttribute	(	QXmlStreamReader *	reader,
		const QString &	attributeBaseName,
		R3 *	vec
	)

Definition at line 173 of file UtilXML.cpp.

{
    double x, y, z;
    readAttribute(reader, attributeBaseName + "X", &x);
    readAttribute(reader, attributeBaseName + "Y", &y);
    readAttribute(reader, attributeBaseName + "Z", &z);
    *vec = {x, y, z};
}

References readAttribute().

Here is the call graph for this function:

readAttribute() [3/5]

void GUI::Session::XML::readAttribute	(	QXmlStreamReader *	reader,
		const QString &	attributeName,
		double *	d
	)

Definition at line 193 of file UtilXML.cpp.

{
    *d = reader->attributes().value(attributeName).toDouble();
}

Referenced by readAttribute(), ParameterContainerItem::readContentFrom(), MaterialItem::readContentFrom(), Serialize::rwProperty(), and Serialize::rwValue().

readAttribute() [4/5]

void GUI::Session::XML::readAttribute	(	QXmlStreamReader *	reader,
		const QString &	attributeName,
		QColor *	c
	)

Definition at line 166 of file UtilXML.cpp.

{
    const QString parameter_value = reader->attributes().value(attributeName).toString();
    *c = QColor(parameter_value);
}

readAttribute() [5/5]

void GUI::Session::XML::readAttribute	(	QXmlStreamReader *	reader,
		const QString &	attributeName,
		QString *	s
	)

Definition at line 160 of file UtilXML.cpp.

{
    *s = reader->attributes().value(attributeName).toString();
}

readBoolAttribute()

bool GUI::Session::XML::readBoolAttribute	(	QXmlStreamReader *	reader,
		const QString &	attributeName
	)

Definition at line 149 of file UtilXML.cpp.

{
    return reader->attributes().value(attributeName).toUInt() != 0;
}

Referenced by SimulationOptionsItem::readContentFrom().

readItems()

void GUI::Session::XML::readItems	(	QXmlStreamReader *	reader,
		SessionItem *	parent,
		QString	topTag = "",
		MessageService *	messageService = nullptr
	)

Definition at line 113 of file SessionXML.cpp.

{
    bool legacyDistributionFound = false;
    ASSERT(reader);
    ASSERT(parent);
    const QString start_type = parent->model()->getModelTag();
    while (!reader->atEnd()) {
        reader->readNext();
        if (reader->isStartElement()) {
            if (reader->name() == XML::ItemTag) {
                const QString model_type =
                    reader->attributes().value(Tags::ModelTypeAttribute).toString();
 
                if (model_type == "ParticleDistribution") {
                    if (!legacyDistributionFound) {
                        QString message(
                            "This file contains particle distributions in the sample. Elements of "
                            "this type are not supported any more. Reading the file will be "
                            "continued as much as possible, but you should review the sample.");
 
                        report_error(messageService, parent->model(), message);
                    }
                    legacyDistributionFound = true;
                    reader->skipCurrentElement();
                    continue;
                }
 
                QString tag = reader->attributes().value(Tags::TagAttribute).toString();
                QString displayName =
                    reader->attributes().value(Tags::DisplayNameAttribute).toString();
 
                if (!topTag.isEmpty()) {
                    // to handle copying of item to another parent
                    tag = topTag;
                    topTag.clear();
                }
                auto* newItem = createItem(parent, model_type, tag);
                if (!newItem) {
                    QString message = QString("Error while parsing XML. Can't create item of "
                                              "modelType '%1' for tag '%2', parent '%3'")
                                          .arg(model_type, tag, parent->itemName());
                    report_error(messageService, parent->model(), message);
                    // risky attempt to recover the rest of the project
                    reader->skipCurrentElement();
                } else {
                    parent = newItem;
                    parent->setDisplayName(displayName);
                }
                ASSERT(reader->name() == ItemTag);
            } else if (reader->name() == ParameterTag) {
                readProperty(reader, parent);
                gotoEndElementOfTag(reader, ParameterTag);
            } else if (reader->name() == Tags::BinaryData) {
                if (reader->attributes().value(XML::Version).toInt() == 1) {
                    QString valueAsBase64 =
                        reader->readElementText(QXmlStreamReader::SkipChildElements);
                    const auto data = QByteArray::fromBase64(
                        valueAsBase64.toLatin1()); // #baimport add a unit test for this!
                    parent->deserializeBinaryData(data);
                } else
                    throw DeserializationException::tooNew();
                gotoEndElementOfTag(reader, Tags::BinaryData);
            } else if (reader->name() == Tags::NonSessionItemData) {
                parent->readNonSessionItems(reader);
                gotoEndElementOfTag(reader, Tags::NonSessionItemData);
            }
        } else if (reader->isEndElement()) {
            if (reader->name() == XML::ItemTag && parent)
                parent = parent->parentItem();
            if (reader->name() == start_type)
                break;
        }
    }
}

References GUI::Session::XML::Tags::BinaryData(), SessionItem::deserializeBinaryData(), GUI::Session::XML::Tags::DisplayNameAttribute(), SessionModel::getModelTag(), gotoEndElementOfTag(), SessionItem::itemName(), ItemTag(), SessionItem::model(), ModelTypeAttribute(), GUI::Session::XML::Tags::NonSessionItemData(), ParameterTag(), SessionItem::parentItem(), SessionItem::readNonSessionItems(), readProperty(), SessionItem::setDisplayName(), GUI::Session::XML::Tags::TagAttribute(), DeserializationException::tooNew(), and XML::Tags::Version().

Referenced by SessionModel::copy(), and SessionModel::readFrom().

Here is the call graph for this function:

readProperty()

QString GUI::Session::XML::readProperty	(	QXmlStreamReader *	reader,
		SessionItem *	item
	)

Definition at line 189 of file SessionXML.cpp.

{
    ASSERT(reader);
    const QString parameter_name =
        reader->attributes().value(Tags::ParameterNameAttribute).toString();
    const QString parameter_type =
        reader->attributes().value(Tags::ParameterTypeAttribute).toString();
    const int role = reader->attributes().value(Tags::ParameterRoleAttribute).toInt();
 
    if (!item)
        throw Error(
            QString("Attempt to set property '%1' for non existing item").arg(parameter_name));
 
    QVariant variant;
    if (parameter_type == "double") {
        double parameter_value =
            reader->attributes().value(Tags::ParameterValueAttribute).toDouble();
        variant = parameter_value;
    } else if (parameter_type == "int") {
        int parameter_value = reader->attributes().value(Tags::ParameterValueAttribute).toInt();
        variant = parameter_value;
    } else if (parameter_type == "uint") {
        unsigned parameter_value =
            reader->attributes().value(Tags::ParameterValueAttribute).toUInt();
        variant = parameter_value;
    } else if (parameter_type == "bool") {
        bool parameter_value = reader->attributes().value(Tags::ParameterValueAttribute).toInt();
        variant = parameter_value;
    } else if (parameter_type == "QString") {
        QString parameter_value =
            reader->attributes().value(Tags::ParameterValueAttribute).toString();
        variant = parameter_value;
    } else if (parameter_type == "QColor") {
        QString parameter_value =
            reader->attributes().value(Tags::ParameterValueAttribute).toString();
        variant = QColor(parameter_value);
    } else if (parameter_type == "ExternalProperty") {
        const bool isMaterialItemColor =
            item->parentItem() != nullptr && dynamic_cast<MaterialItem*>(item->parentItem());
 
        if (isMaterialItemColor) {
            // This handles legacy XML files for MaterialItem:
            // In former times, the color of a MaterialItem was held as an "ExternalProperty". This
            // has been changed to a simple QColor property => use only the color value of the
            // "ExternalProperty" and store it as QColor in the variant
            const QString colorName =
                reader->attributes().value(Tags::ExternalPropertyColorAtt).toString();
            variant = QColor(colorName);
        } else {
            // This handles legacy XML files for items referring to a material:
            // In former times, the material in e.g. a ParticleItem was held as an
            // "ExternalProperty". This has been changed to the material's identifier only (as
            // QString)
            // => use only the identifier value of the "ExternalProperty" and store it as QString in
            // the variant
            const QString identifier =
                reader->attributes().value(Tags::ExternalPropertyIdentifierAtt).toString();
            variant = identifier;
        }
    } else if (parameter_type == "ComboProperty") {
        QString selections = reader->attributes().value(Tags::ParameterValueAttribute).toString();
        QString values = reader->attributes().value(Tags::ParameterExtAttribute).toString();
 
        ComboProperty combo_property;
        combo_property.setStringOfValues(values);
        combo_property.setStringOfSelections(selections);
 
        variant = combo_property.variant();
    } else {
        QString message = QString("SessionModel::readProperty: parameter type not supported '"
                                  + parameter_type + "'");
        throw Error(message);
    }
 
    if (variant.isValid())
        item->setRoleProperty(role, variant);
 
    return parameter_name;
}

References GUI::Session::XML::Tags::ExternalPropertyColorAtt(), GUI::Session::XML::Tags::ExternalPropertyIdentifierAtt(), GUI::Session::XML::Tags::ParameterExtAttribute(), GUI::Session::XML::Tags::ParameterNameAttribute(), GUI::Session::XML::Tags::ParameterRoleAttribute(), GUI::Session::XML::Tags::ParameterTypeAttribute(), GUI::Session::XML::Tags::ParameterValueAttribute(), SessionItem::parentItem(), SessionItem::setRoleProperty(), ComboProperty::setStringOfSelections(), ComboProperty::setStringOfValues(), and ComboProperty::variant().

Referenced by readItems().

Here is the call graph for this function:

readUIntAttribute()

unsigned GUI::Session::XML::readUIntAttribute	(	QXmlStreamReader *	reader,
		const QString &	attributeName
	)

Definition at line 154 of file UtilXML.cpp.

{
    return reader->attributes().value(attributeName).toUInt();
}

Referenced by SimulationOptionsItem::readContentFrom().

RealDataModelTag()

constexpr auto GUI::Session::XML::RealDataModelTag ( "RealDataModel"  )

constexpr

Referenced by RealDataModel::RealDataModel().

Version()

constexpr auto GUI::Session::XML::Version ( "Version"  )

constexpr

Referenced by ParameterContainerItem::readContentFrom(), MaterialItem::readContentFrom(), SimulationOptionsItem::readContentFrom(), JobItem::readNonSessionItems(), ParameterContainerItem::writeContentTo(), MaterialItem::writeContentTo(), SimulationOptionsItem::writeContentTo(), and JobItem::writeNonSessionItems().

writeAttribute() [1/6]

void GUI::Session::XML::writeAttribute	(	QXmlStreamWriter *	writer,
		const QString &	attributeBaseName,
		const complex_t &	c
	)

Definition at line 102 of file UtilXML.cpp.

{
    writeAttribute(writer, attributeBaseName + "Re", c.real());
    writeAttribute(writer, attributeBaseName + "Im", c.imag());
}

References writeAttribute().

Here is the call graph for this function:

writeAttribute() [2/6]

void GUI::Session::XML::writeAttribute	(	QXmlStreamWriter *	writer,
		const QString &	attributeBaseName,
		const R3 &	vec
	)

Definition at line 94 of file UtilXML.cpp.

{
    writeAttribute(writer, attributeBaseName + "X", vec.x());
    writeAttribute(writer, attributeBaseName + "Y", vec.y());
    writeAttribute(writer, attributeBaseName + "Z", vec.z());
}

References writeAttribute().

Here is the call graph for this function:

writeAttribute() [3/6]

void GUI::Session::XML::writeAttribute	(	QXmlStreamWriter *	writer,
		const QString &	attributeName,
		const QVariant &	variant
	)

Write the variant's value as an attribute.

Definition at line 65 of file UtilXML.cpp.

{
    ASSERT(writer);
    ASSERT(variant.isValid());
 
    if (variant.type() == QVariant::Double)
        writeAttribute(writer, attributeName, variant.toDouble());
    else if (variant.type() == QVariant::Int)
        writeAttribute(writer, attributeName, variant.toInt());
    else if (variant.type() == QVariant::UInt)
        writeAttribute(writer, attributeName, variant.toUInt());
    else if (variant.type() == QVariant::Bool)
        writer->writeAttribute(attributeName, QString::number(variant.toBool()));
    else if (variant.type() == QVariant::String)
        writer->writeAttribute(attributeName, variant.toString());
    else if (variant.type() == QVariant::Color) {
        const auto col = variant.value<QColor>();
        const QString tcol = col.isValid() ? col.name(QColor::HexArgb) : "";
        writer->writeAttribute(attributeName, tcol);
    } else if (QString(variant.typeName()) == "ComboProperty") {
        auto combo = variant.value<ComboProperty>();
        writer->writeAttribute(attributeName, combo.stringOfSelections());
        writer->writeAttribute(Tags::ParameterExtAttribute, combo.stringOfValues());
    } else
        throw Error("GUI::Session::XML::writeVariant: Parameter type not supported "
                    + QString(variant.typeName()));
}

References GUI::Session::XML::Tags::ParameterExtAttribute().

Referenced by Serialize::rwProperty(), Serialize::rwValue(), writeAttribute(), ParameterContainerItem::writeContentTo(), MaterialItem::writeContentTo(), SimulationOptionsItem::writeContentTo(), JobItem::writeNonSessionItems(), and writeVariant().

Here is the call graph for this function:

writeAttribute() [4/6]

void GUI::Session::XML::writeAttribute	(	QXmlStreamWriter *	writer,
		const QString &	attributeName,
		double	d
	)

Definition at line 109 of file UtilXML.cpp.

{
    writer->writeAttribute(attributeName, d == 0.0 ? "0" : QString::number(d, 'e', 12));
}

writeAttribute() [5/6]

void GUI::Session::XML::writeAttribute	(	QXmlStreamWriter *	writer,
		const QString &	attributeName,
		int	d
	)

Definition at line 115 of file UtilXML.cpp.

{
    writer->writeAttribute(attributeName, QString::number(d));
}

writeAttribute() [6/6]

void GUI::Session::XML::writeAttribute	(	QXmlStreamWriter *	writer,
		const QString &	attributeName,
		unsigned	d
	)

Definition at line 121 of file UtilXML.cpp.

{
    writer->writeAttribute(attributeName, QString::number(d));
}

writeItemAndChildItems()

void GUI::Session::XML::writeItemAndChildItems	(	QXmlStreamWriter *	writer,
		const SessionItem *	item
	)

Definition at line 70 of file SessionXML.cpp.

{
    ASSERT(item);
    if (item->parentItem()) {
        writer->writeStartElement(ItemTag);
        writer->writeAttribute(ModelTypeAttribute, item->modelType());
        QString tag = item->parentItem()->tagFromItem(item);
        writer->writeAttribute(Tags::TagAttribute, tag);
        writer->writeAttribute(Tags::DisplayNameAttribute,
                               item->roleProperty(SessionFlags::DisplayNameRole).toString());
        for (int role : item->getRoles()) {
            if (role == Qt::DisplayRole || role == Qt::EditRole)
                writeVariant(writer, item->value(), role);
        }
    }
 
    for (auto* child : item->children())
        if (item->allowWritingChildToXml(child))
            writeItemAndChildItems(writer, child);
 
    QByteArray a = item->serializeBinaryData();
    if (!a.isEmpty()) {
        writer->writeStartElement(Tags::BinaryData);
        writer->writeAttribute(XML::Version, "1");
        writer->writeCharacters(a.toBase64());
        writer->writeEndElement();
    }
 
    QString nonSessionItemContent;
    QXmlStreamWriter nonSessionItemStream(&nonSessionItemContent);
    nonSessionItemStream.writeStartElement(Tags::NonSessionItemData); // for following writeAttrib
    const auto sizeBefore = nonSessionItemContent.size();
    item->writeNonSessionItems(&nonSessionItemStream);
    if (sizeBefore != nonSessionItemContent.size()) {
        writer->writeStartElement(Tags::NonSessionItemData);
        item->writeNonSessionItems(writer);
        writer->writeEndElement();
    }
 
    if (item->parentItem())
        writer->writeEndElement(); // ItemTag
}

References SessionItem::allowWritingChildToXml(), GUI::Session::XML::Tags::BinaryData(), SessionItem::children(), GUI::Session::XML::Tags::DisplayNameAttribute(), SessionFlags::DisplayNameRole, SessionItem::getRoles(), ItemTag(), SessionItem::modelType(), ModelTypeAttribute(), GUI::Session::XML::Tags::NonSessionItemData(), SessionItem::parentItem(), SessionItem::roleProperty(), SessionItem::serializeBinaryData(), GUI::Session::XML::Tags::TagAttribute(), SessionItem::tagFromItem(), SessionItem::value(), XML::Tags::Version(), SessionItem::writeNonSessionItems(), and writeVariant().

Referenced by SessionModel::copy(), SessionModel::mimeData(), and writeModel().

Here is the call graph for this function:

writeModel()

void GUI::Session::XML::writeModel	(	QXmlStreamWriter *	writer,
		SessionItem *	modelRootItem
	)

Definition at line 59 of file SessionXML.cpp.

{
    ASSERT(writer);
    ASSERT(modelRootItem);
    writer->writeStartElement(modelRootItem->model()->getModelTag());
 
    writeItemAndChildItems(writer, modelRootItem);
 
    writer->writeEndElement(); // m_model_tag
}

References SessionModel::getModelTag(), SessionItem::model(), and writeItemAndChildItems().

Referenced by SessionModel::writeTo().

Here is the call graph for this function:

writeUid() [1/2]

void GUI::Session::XML::writeUid	(	QXmlStreamWriter *	writer,
		const QString &	id
	)

Definition at line 127 of file UtilXML.cpp.

{
    writer->writeAttribute(Tags::Id, id);
}

References XML::Tags::Id().

Referenced by Serialize::rwProperty().

Here is the call graph for this function:

writeUid() [2/2]

void GUI::Session::XML::writeUid	(	QXmlStreamWriter *	writer,
		const QUuid &	id
	)

Definition at line 132 of file UtilXML.cpp.

{
    writer->writeAttribute(Tags::Id, id.toString());
}

References XML::Tags::Id(), and GUI::View::PropertyEditorFactory::toString().

Here is the call graph for this function:

writeVariant()

void GUI::Session::XML::writeVariant	(	QXmlStreamWriter *	writer,
		QVariant	variant,
		int	role
	)

Write the variant as a complete tag, including the given role.

Definition at line 137 of file UtilXML.cpp.

{
    ASSERT(writer);
    if (variant.isValid()) {
        writer->writeStartElement(Tags::ParameterTag);
        writer->writeAttribute(Tags::ParameterTypeAttribute, variant.typeName());
        writer->writeAttribute(Tags::ParameterRoleAttribute, QString::number(role));
        writeAttribute(writer, Tags::ParameterValueAttribute, variant);
        writer->writeEndElement(); // end ParameterTag
    }
}

References GUI::Session::XML::Tags::ParameterRoleAttribute(), ParameterTag(), GUI::Session::XML::Tags::ParameterTypeAttribute(), GUI::Session::XML::Tags::ParameterValueAttribute(), and writeAttribute().

Referenced by writeItemAndChildItems().

Here is the call graph for this function:

Variable Documentation

ItemMimeType

constexpr auto GUI::Session::XML::ItemMimeType = "application/org.bornagainproject.xml.item.z"

constexpr

Definition at line 30 of file SessionXML.h.

Referenced by SessionModel::canDropMimeData(), SessionModel::dropMimeData(), SessionModel::mimeData(), and SessionModel::mimeTypes().

LinkMimeType

constexpr auto GUI::Session::XML::LinkMimeType = "application/org.bornagainproject.fittinglink"

constexpr

Definition at line 31 of file SessionXML.h.

Referenced by FitParameterModel::dropMimeData(), FitParameterModel::mimeData(), ParameterTuningModel::mimeData(), and FitParameterModel::mimeTypes().