void Document::loadImage(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "Document::loadImage";
loadNextFromReader(reader); // Read to CDATA
if (reader.isCDATA ()) {
// Get base64 array
QByteArray array64 = reader.text().toString().toUtf8();
// Decoded array
QByteArray array;
array = QByteArray::fromBase64(array64);
// Read decoded array into image
QDataStream str (&array, QIODevice::ReadOnly);
QImage img = m_pixmap.toImage ();
str >> img;
m_pixmap = QPixmap::fromImage (img);
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_IMAGE)){
loadNextFromReader(reader);
}
} else {
void DocumentModelPointMatch::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "DocumentModelPointMatch::loadXml";
bool success = true;
QXmlStreamAttributes attributes = reader.attributes();
if (attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_MATCH_POINT_SIZE) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_MATCH_COLOR_ACCEPTED) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_MATCH_COLOR_CANDIDATE) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_MATCH_COLOR_REJECTED)) {
setMaxPointSize (attributes.value(DOCUMENT_SERIALIZE_POINT_MATCH_POINT_SIZE).toDouble());
setPaletteColorAccepted ((ColorPalette) attributes.value(DOCUMENT_SERIALIZE_POINT_MATCH_COLOR_ACCEPTED).toInt());
setPaletteColorCandidate ((ColorPalette) attributes.value(DOCUMENT_SERIALIZE_POINT_MATCH_COLOR_CANDIDATE).toInt());
setPaletteColorRejected ((ColorPalette) attributes.value(DOCUMENT_SERIALIZE_POINT_MATCH_COLOR_REJECTED).toInt());
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_POINT_MATCH)){
loadNextFromReader(reader);
if (reader.atEnd()) {
success = false;
break;
}
}
}
if (!success) {
reader.raiseError (QObject::tr ("Cannot read point match data"));
}
}
void PointStyle::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "PointStyle::loadXml";
QXmlStreamAttributes attributes = reader.attributes();
if (attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_STYLE_RADIUS) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_STYLE_LINE_WIDTH) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_STYLE_COLOR) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_STYLE_SHAPE)) {
setRadius (attributes.value(DOCUMENT_SERIALIZE_POINT_STYLE_RADIUS).toInt());
setLineWidth (attributes.value(DOCUMENT_SERIALIZE_POINT_STYLE_LINE_WIDTH).toInt());
setPaletteColor ((ColorPalette) attributes.value(DOCUMENT_SERIALIZE_POINT_STYLE_COLOR).toInt());
setShape ((PointShape) attributes.value(DOCUMENT_SERIALIZE_POINT_STYLE_SHAPE).toInt());
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_POINT_STYLE)){
loadNextFromReader(reader);
}
} else {
reader.raiseError ("Cannot read point style data");
}
}
CmdSettingsCurveAddRemove::CmdSettingsCurveAddRemove (MainWindow &mainWindow,
Document &document,
const QString &cmdDescription,
QXmlStreamReader &reader) :
CmdAbstract (mainWindow,
document,
cmdDescription)
{
LOG4CPP_INFO_S ((*mainCat)) << "CmdSettingsCurveAddRemove::CmdSettingsCurveAddRemove";
bool success = true;
// Read until end of this subtree
bool isBefore = true;
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_CMD)) {
loadNextFromReader(reader);
if (reader.atEnd()) {
xmlExitWithError (reader,
QString ("%1 %2")
.arg (QObject::tr ("Reached end of file before finding end element for"))
.arg (DOCUMENT_SERIALIZE_CMD));
success = false;
break;
}
if ((reader.tokenType() == QXmlStreamReader::StartElement) &&
(reader.name() == DOCUMENT_SERIALIZE_CURVES_GRAPHS)) {
if (isBefore) {
m_curvesGraphsBefore.loadXml (reader);
isBefore = false;
} else {
m_curvesGraphsAfter.loadXml (reader);
}
}
}
if (!success) {
reader.raiseError ("Cannot read curve add/remove settings");
}
}
CmdSettingsColorFilter::CmdSettingsColorFilter (MainWindow &mainWindow,
Document &document,
const QString &cmdDescription,
QXmlStreamReader &reader) :
CmdAbstract (mainWindow,
document,
cmdDescription)
{
LOG4CPP_INFO_S ((*mainCat)) << "CmdSettingsColorFilter::CmdSettingsColorFilter";
bool success = true;
// Read until end of this subtree
bool isBefore = true;
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_CMD)){
loadNextFromReader(reader);
if (reader.atEnd()) {
xmlExitWithError (reader,
QString ("Reached end of file before finding end element for %1")
.arg (DOCUMENT_SERIALIZE_CMD));
success = false;
break;
}
if ((reader.tokenType() == QXmlStreamReader::StartElement) &&
(reader.name() == DOCUMENT_SERIALIZE_FILTER)) {
if (isBefore) {
m_modelColorFilterBefore.loadXml (reader);
isBefore = false;
} else {
m_modelColorFilterAfter.loadXml (reader);
}
}
}
if (!success) {
reader.raiseError ("Cannot read color filter settings");
}
}
void CurvesGraphs::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "CurvesGraphs::loadXml";
bool success = true;
// Remove previous Curves. There is a DEFAULT_GRAPH_CURVE_NAME by default
m_curvesGraphs.clear();
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_CURVES_GRAPHS)){
loadNextFromReader(reader);
if (reader.atEnd()) {
success = false;
break;
}
if ((reader.tokenType() == QXmlStreamReader::StartElement) &&
(reader.name () == DOCUMENT_SERIALIZE_CURVE)) {
Curve curve (reader);
// Version 6 of Engauge let users create multiple curves with the same name. Reading a file with duplicate
// curve names can result in crashes and/or corruption, so we deconflict duplicate curve names here
QString DUPLICATE = QString ("-%1").arg (QObject::tr ("DUPLICATE"));
QString curveName = curve.curveName();
while (curvesGraphsNames().contains (curveName)) {
curveName += DUPLICATE;
}
curve.setCurveName (curveName); // No effect if curve name was not a duplicate
// Add the curve
m_curvesGraphs.push_back (curve);
}
}
if (!success) {
reader.raiseError (QObject::tr ("Cannot read graph curves data"));
}
}
QString CurveStyle::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "CurveStyle::loadXml";
bool success = true;
QString curveName;
QXmlStreamAttributes attributes = reader.attributes();
if (attributes.hasAttribute(DOCUMENT_SERIALIZE_CURVE_NAME)) {
curveName = attributes.value (DOCUMENT_SERIALIZE_CURVE_NAME).toString();
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_POINT_STYLE)) {
loadNextFromReader(reader);
if (reader.atEnd()) {
success = false;
break;
}
if ((reader.tokenType() == QXmlStreamReader::StartElement) &&
(reader.name() == DOCUMENT_SERIALIZE_LINE_STYLE)) {
m_lineStyle.loadXml (reader);
} else if ((reader.tokenType() == QXmlStreamReader::StartElement) &
(reader.name() == DOCUMENT_SERIALIZE_POINT_STYLE)) {
m_pointStyle.loadXml (reader);
}
}
}
if (!success) {
reader.raiseError ("Cannot read curve style data");
}
return curveName;
}
void MainWindowModel::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "MainWindowModel::loadXml";
bool success = true;
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_MAIN_WINDOW)){
loadNextFromReader(reader);
if (reader.atEnd()) {
success = false;
break;
}
}
if (!success) {
reader.raiseError (QObject::tr ("Cannot read main window data"));
}
}
void DocumentModelSegments::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "DocumentModelSegments::loadXml";
bool success = true;
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_SEGMENTS)){
loadNextFromReader(reader);
if (reader.atEnd()) {
success = false;
break;
}
}
if (!success) {
reader.raiseError("Cannot read segment data");
}
}
void LineStyle::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "LineStyle::loadXml";
QXmlStreamAttributes attributes = reader.attributes();
if (attributes.hasAttribute(DOCUMENT_SERIALIZE_LINE_STYLE_WIDTH) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_LINE_STYLE_COLOR) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_LINE_STYLE_CONNECT_AS)) {
setWidth (attributes.value(DOCUMENT_SERIALIZE_LINE_STYLE_WIDTH).toInt());
setPaletteColor ((ColorPalette) attributes.value(DOCUMENT_SERIALIZE_LINE_STYLE_COLOR).toInt());
setCurveConnectAs ((CurveConnectAs) attributes.value(DOCUMENT_SERIALIZE_COLOR_FILTER_INTENSITY_HIGH).toInt());
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_LINE_STYLE)){
loadNextFromReader(reader);
}
} else {
reader.raiseError ("Cannot read line style data");
}
}
void DocumentModelDigitizeCurve::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "DocumentModelDigitizeCurve::loadXml";
bool success = true;
QXmlStreamAttributes attributes = reader.attributes();
if (attributes.hasAttribute(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_INNER_RADIUS) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_LINE_WIDTH) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_SIZE) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_STANDARD_CROSS)) {
// Boolean values
QString standardCrossValue = attributes.value(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_STANDARD_CROSS).toString();
setCursorInnerRadius (attributes.value(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_INNER_RADIUS).toInt());
setCursorLineWidth (attributes.value(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_LINE_WIDTH).toInt());
setCursorSize ((CursorSize) attributes.value(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_SIZE).toInt());
setCursorStandardCross (standardCrossValue == DOCUMENT_SERIALIZE_BOOL_TRUE);
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_DIGITIZE_CURVE)){
loadNextFromReader(reader);
if (reader.atEnd()) {
success = false;
break;
}
}
}
if (!success) {
reader.raiseError ("Cannot read digitize curve data");
}
}
void CurvesGraphs::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "CurvesGraphs::loadXml";
bool success = true;
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_CURVES_GRAPHS)){
if ((reader.tokenType() == QXmlStreamReader::StartElement) &&
(reader.name () == DOCUMENT_SERIALIZE_CURVE)) {
Curve curve (reader);
m_curvesGraphs.push_back (curve);
} else {
loadNextFromReader(reader);
if (reader.hasError()) {
// No need to set success flag, which raises the error, since error was already raised. Just
// need to exit loop immediately
break;
}
if (reader.atEnd()) {
success = false;
break;
}
}
}
if (!success) {
reader.raiseError ("Cannot read graph curves data");
}
}
void DocumentModelExportFormat::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "DocumentModelExportFormat::loadXml";
bool success = true;
QXmlStreamAttributes attributes = reader.attributes();
if (attributes.hasAttribute(DOCUMENT_SERIALIZE_EXPORT_POINTS_SELECTION_FUNCTIONS) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_EXPORT_POINTS_INTERVAL_FUNCTIONS) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_EXPORT_POINTS_INTERVAL_UNITS_FUNCTIONS) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_EXPORT_POINTS_SELECTION_RELATIONS) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_EXPORT_POINTS_INTERVAL_RELATIONS) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_EXPORT_POINTS_INTERVAL_UNITS_RELATIONS) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_EXPORT_LAYOUT_FUNCTIONS) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_EXPORT_DELIMITER) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_EXPORT_HEADER) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_EXPORT_X_LABEL)) {
setPointsSelectionFunctions ((ExportPointsSelectionFunctions) attributes.value(DOCUMENT_SERIALIZE_EXPORT_POINTS_SELECTION_FUNCTIONS).toInt());
setPointsIntervalFunctions (attributes.value(DOCUMENT_SERIALIZE_EXPORT_POINTS_INTERVAL_FUNCTIONS).toDouble());
setPointsIntervalUnitsFunctions ((ExportPointsIntervalUnits) attributes.value(DOCUMENT_SERIALIZE_EXPORT_POINTS_INTERVAL_UNITS_FUNCTIONS).toInt());
setPointsSelectionRelations ((ExportPointsSelectionRelations) attributes.value(DOCUMENT_SERIALIZE_COORDS_SCALE_Y_RADIUS).toInt());
setPointsIntervalRelations (attributes.value(DOCUMENT_SERIALIZE_EXPORT_POINTS_INTERVAL_RELATIONS).toDouble());
setPointsIntervalUnitsRelations ((ExportPointsIntervalUnits) attributes.value(DOCUMENT_SERIALIZE_EXPORT_POINTS_INTERVAL_UNITS_RELATIONS).toInt());
setLayoutFunctions ((ExportLayoutFunctions) attributes.value(DOCUMENT_SERIALIZE_EXPORT_LAYOUT_FUNCTIONS).toInt());
setDelimiter ((ExportDelimiter) attributes.value (DOCUMENT_SERIALIZE_EXPORT_DELIMITER).toInt());
setHeader ((ExportHeader) attributes.value(DOCUMENT_SERIALIZE_EXPORT_HEADER).toInt());
setXLabel (attributes.value(DOCUMENT_SERIALIZE_EXPORT_X_LABEL).toString());
// Read element containing excluded curve names
while ((loadNextFromReader (reader) != QXmlStreamReader::StartElement) ||
(reader.name() != DOCUMENT_SERIALIZE_EXPORT_CURVE_NAMES_NOT_EXPORTED)) {
if (reader.atEnd()) {
success = false;
break;
}
}
if (success) {
QStringList curveNamesNotExported;
QXmlStreamReader::TokenType tokenType = loadNextFromReader(reader);
while (tokenType == QXmlStreamReader::StartElement) {
if (reader.name() == DOCUMENT_SERIALIZE_EXPORT_CURVE_NAME_NOT_EXPORTED) {
curveNamesNotExported << reader.text().toString();
}
tokenType = loadNextFromReader(reader);
}
// Save curve names
setCurveNamesNotExported(curveNamesNotExported);
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_EXPORT)){
loadNextFromReader(reader);
if (reader.atEnd()) {
success = false;
break;
}
}
}
}
if (!success) {
reader.raiseError ("Cannot read export data");
}
}
void Point::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "Point::loadXml";
bool success = true;
QXmlStreamAttributes attributes = reader.attributes();
if (attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_IDENTIFIER) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_ORDINAL) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_IDENTIFIER_INDEX)) {
m_identifier = attributes.value(DOCUMENT_SERIALIZE_POINT_IDENTIFIER).toString();
m_ordinal = attributes.value(DOCUMENT_SERIALIZE_POINT_ORDINAL).toDouble();
m_identifierIndex = attributes.value(DOCUMENT_SERIALIZE_POINT_IDENTIFIER_INDEX).toInt();
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name () != DOCUMENT_SERIALIZE_POINT)) {
loadNextFromReader(reader);
if (reader.atEnd()) {
success = false;
break;
}
if (reader.tokenType () == QXmlStreamReader::StartElement) {
if (reader.name() == DOCUMENT_SERIALIZE_POINT_POSITION_SCREEN) {
attributes = reader.attributes();
if (attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_X) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_Y)) {
m_posScreen.setX (attributes.value(DOCUMENT_SERIALIZE_POINT_X).toDouble());
m_posScreen.setY (attributes.value(DOCUMENT_SERIALIZE_POINT_Y).toDouble());
} else {
success = false;
break;
}
} else if (reader.name() == DOCUMENT_SERIALIZE_POINT_POSITION_GRAPH) {
attributes = reader.attributes();
if (attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_X) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_POINT_Y)) {
m_posGraph.setX (attributes.value(DOCUMENT_SERIALIZE_POINT_X).toDouble());
m_posGraph.setY (attributes.value(DOCUMENT_SERIALIZE_POINT_Y).toDouble());
} else {
success = false;
break;
}
}
}
}
} else {
success = false;
}
if (!success) {
reader.raiseError("Cannot read point data");
}
}