00001
00002
00003
00004
00005
00006
00007 #include "CallbackAddPointsInCurvesGraphs.h"
00008 #include "CallbackBoundingRects.h"
00009 #include "CallbackCheckAddPointAxis.h"
00010 #include "CallbackCheckEditPointAxis.h"
00011 #include "CallbackNextOrdinal.h"
00012 #include "CallbackRemovePointsInCurvesGraphs.h"
00013 #include "Curve.h"
00014 #include "CurvesGraphs.h"
00015 #include "CurveStyles.h"
00016 #include "Document.h"
00017 #include "DocumentSerialize.h"
00018 #include "EngaugeAssert.h"
00019 #include "EnumsToQt.h"
00020 #include "GridInitializer.h"
00021 #include <iostream>
00022 #include "Logger.h"
00023 #include "OrdinalGenerator.h"
00024 #include "Point.h"
00025 #include <QByteArray>
00026 #include <QDataStream>
00027 #include <QDebug>
00028 #include <QDomDocument>
00029 #include <QFile>
00030 #include <QImage>
00031 #include <qmath.h>
00032 #include <QObject>
00033 #include <QtToString.h>
00034 #include <QXmlStreamReader>
00035 #include <QXmlStreamWriter>
00036 #include "SettingsForGraph.h"
00037 #include "Transformation.h"
00038 #include "Version.h"
00039 #include "Xml.h"
00040
00041 const int FOUR_BYTES = 4;
00042 const int NOMINAL_COORD_SYSTEM_COUNT = 1;
00043 const int VERSION_6 = 6;
00044 const int VERSION_7 = 7;
00045 const int VERSION_8 = 8;
00046 const int VERSION_9 = 9;
00047
00048 Document::Document (const QImage &image) :
00049 m_name ("untitled"),
00050 m_documentAxesPointsRequired (DOCUMENT_AXES_POINTS_REQUIRED_3)
00051 {
00052 LOG4CPP_INFO_S ((*mainCat)) << "Document::Document"
00053 << " image=" << image.width() << "x" << image.height();
00054
00055 m_coordSystemContext.addCoordSystems(m_documentAxesPointsRequired,
00056 NOMINAL_COORD_SYSTEM_COUNT);
00057
00058 m_successfulRead = true;
00059
00060 m_pixmap.convertFromImage (image);
00061 }
00062
00063 Document::Document (const QString &fileName) :
00064 m_name (fileName),
00065 m_documentAxesPointsRequired (DOCUMENT_AXES_POINTS_REQUIRED_3)
00066 {
00067 LOG4CPP_INFO_S ((*mainCat)) << "Document::Document"
00068 << " fileName=" << fileName.toLatin1().data();
00069
00070 m_successfulRead = true;
00071
00072
00073 QFile *file = new QFile (fileName);
00074 if (file->open(QIODevice::ReadOnly)) {
00075
00076 QByteArray bytesStart = file->read (FOUR_BYTES);
00077 file->close ();
00078
00079 if (bytesIndicatePreVersion6 (bytesStart)) {
00080
00081 QFile *file = new QFile (fileName);
00082 if (file->open (QIODevice::ReadOnly)) {
00083 QDataStream str (file);
00084
00085 m_coordSystemContext.addCoordSystems(m_documentAxesPointsRequired,
00086 NOMINAL_COORD_SYSTEM_COUNT);
00087 loadPreVersion6 (str);
00088
00089 } else {
00090
00091 m_successfulRead = false;
00092 m_reasonForUnsuccessfulRead = QObject::tr ("Operating system says file is not readable");
00093
00094 }
00095 } else {
00096
00097 QFile *file = new QFile (fileName);
00098 if (file->open (QIODevice::ReadOnly | QIODevice::Text)) {
00099
00100 int version = versionFromFile (file);
00101 switch (version)
00102 {
00103 case VERSION_6:
00104 loadVersion6 (file);
00105 break;
00106
00107 case VERSION_7:
00108 case VERSION_8:
00109 case VERSION_9:
00110 loadVersions7AndUp (file);
00111 break;
00112
00113 default:
00114 m_successfulRead = false;
00115 m_reasonForUnsuccessfulRead = QString ("Engauge %1 %2 %3 %4 Engauge")
00116 .arg (VERSION_NUMBER)
00117 .arg (QObject::tr ("cannot read newer files from version"))
00118 .arg (version)
00119 .arg (QObject::tr ("of"));
00120 break;
00121 }
00122
00123
00124 file->close ();
00125 delete file;
00126 file = 0;
00127
00128 } else {
00129
00130 m_successfulRead = false;
00131 m_reasonForUnsuccessfulRead = QObject::tr ("Operating system says file is not readable");
00132 }
00133 }
00134 } else {
00135 file->close ();
00136 m_successfulRead = false;
00137 m_reasonForUnsuccessfulRead = QString ("%1 '%2' %3")
00138 .arg (QObject::tr ("File"))
00139 .arg (fileName)
00140 .arg (QObject::tr ("was not found"));
00141
00142 }
00143 }
00144
00145 void Document::addCoordSystems(unsigned int numberCoordSystemToAdd)
00146 {
00147 LOG4CPP_INFO_S ((*mainCat)) << "Document::addCoordSystems"
00148 << " toAdd=" << numberCoordSystemToAdd;
00149
00150 m_coordSystemContext.addCoordSystems(m_documentAxesPointsRequired,
00151 numberCoordSystemToAdd);
00152 }
00153
00154 void Document::addGraphCurveAtEnd (const QString &curveName)
00155 {
00156 LOG4CPP_INFO_S ((*mainCat)) << "Document::addGraphCurveAtEnd";
00157
00158 m_coordSystemContext.addGraphCurveAtEnd (curveName);
00159 }
00160
00161 void Document::addPointAxisWithGeneratedIdentifier (const QPointF &posScreen,
00162 const QPointF &posGraph,
00163 QString &identifier,
00164 double ordinal,
00165 bool isXOnly)
00166 {
00167 LOG4CPP_INFO_S ((*mainCat)) << "Document::addPointAxisWithGeneratedIdentifier";
00168
00169 m_coordSystemContext.addPointAxisWithGeneratedIdentifier(posScreen,
00170 posGraph,
00171 identifier,
00172 ordinal,
00173 isXOnly);
00174 }
00175
00176 void Document::addPointAxisWithSpecifiedIdentifier (const QPointF &posScreen,
00177 const QPointF &posGraph,
00178 const QString &identifier,
00179 double ordinal,
00180 bool isXOnly)
00181 {
00182 LOG4CPP_INFO_S ((*mainCat)) << "Document::addPointAxisWithSpecifiedIdentifier";
00183
00184 m_coordSystemContext.addPointAxisWithSpecifiedIdentifier(posScreen,
00185 posGraph,
00186 identifier,
00187 ordinal,
00188 isXOnly);
00189 }
00190
00191 void Document::addPointGraphWithGeneratedIdentifier (const QString &curveName,
00192 const QPointF &posScreen,
00193 QString &identifier,
00194 double ordinal)
00195 {
00196 LOG4CPP_INFO_S ((*mainCat)) << "Document::addPointGraphWithGeneratedIdentifier";
00197
00198 m_coordSystemContext.addPointGraphWithGeneratedIdentifier(curveName,
00199 posScreen,
00200 identifier,
00201 ordinal);
00202 }
00203
00204 void Document::addPointGraphWithSpecifiedIdentifier (const QString &curveName,
00205 const QPointF &posScreen,
00206 const QString &identifier,
00207 double ordinal)
00208 {
00209 LOG4CPP_INFO_S ((*mainCat)) << "Document::addPointGraphWithSpecifiedIdentifier";
00210
00211 m_coordSystemContext.addPointGraphWithSpecifiedIdentifier(curveName,
00212 posScreen,
00213 identifier,
00214 ordinal);
00215 }
00216
00217 void Document::addPointsInCurvesGraphs (CurvesGraphs &curvesGraphs)
00218 {
00219 LOG4CPP_INFO_S ((*mainCat)) << "Document::addPointsInCurvesGraphs";
00220
00221 m_coordSystemContext.addPointsInCurvesGraphs(curvesGraphs);
00222 }
00223
00224 bool Document::bytesIndicatePreVersion6 (const QByteArray &bytes) const
00225 {
00226 LOG4CPP_INFO_S ((*mainCat)) << "Document::bytesIndicatePreVersion6";
00227
00228 QByteArray preVersion6MagicNumber;
00229 preVersion6MagicNumber.resize (FOUR_BYTES);
00230
00231
00232 preVersion6MagicNumber[0] = '\x00';
00233 preVersion6MagicNumber[1] = '\x00';
00234 preVersion6MagicNumber[2] = '\xCA';
00235 preVersion6MagicNumber[3] = '\xFE';
00236
00237 return (bytes == preVersion6MagicNumber);
00238 }
00239
00240 void Document::checkAddPointAxis (const QPointF &posScreen,
00241 const QPointF &posGraph,
00242 bool &isError,
00243 QString &errorMessage,
00244 bool isXOnly)
00245 {
00246 LOG4CPP_INFO_S ((*mainCat)) << "Document::checkAddPointAxis";
00247
00248 m_coordSystemContext.checkAddPointAxis(posScreen,
00249 posGraph,
00250 isError,
00251 errorMessage,
00252 isXOnly);
00253 }
00254
00255 void Document::checkEditPointAxis (const QString &pointIdentifier,
00256 const QPointF &posScreen,
00257 const QPointF &posGraph,
00258 bool &isError,
00259 QString &errorMessage)
00260 {
00261 LOG4CPP_INFO_S ((*mainCat)) << "Document::checkEditPointAxis";
00262
00263 m_coordSystemContext.checkEditPointAxis(pointIdentifier,
00264 posScreen,
00265 posGraph,
00266 isError,
00267 errorMessage);
00268 }
00269
00270 const CoordSystem &Document::coordSystem() const
00271 {
00272 LOG4CPP_INFO_S ((*mainCat)) << "Document::coordSystem";
00273
00274 return m_coordSystemContext.coordSystem();
00275 }
00276
00277 unsigned int Document::coordSystemCount () const
00278 {
00279 LOG4CPP_INFO_S ((*mainCat)) << "Document::coordSystemCount";
00280
00281 return m_coordSystemContext.coordSystemCount();
00282 }
00283
00284 CoordSystemIndex Document::coordSystemIndex() const
00285 {
00286 LOG4CPP_INFO_S ((*mainCat)) << "Document::coordSystemIndex";
00287
00288 return m_coordSystemContext.coordSystemIndex();
00289 }
00290
00291 const Curve &Document::curveAxes () const
00292 {
00293 LOG4CPP_INFO_S ((*mainCat)) << "Document::curveAxes";
00294
00295 return m_coordSystemContext.curveAxes();
00296 }
00297
00298 Curve *Document::curveForCurveName (const QString &curveName)
00299 {
00300 LOG4CPP_INFO_S ((*mainCat)) << "Document::curveForCurveName";
00301
00302 return m_coordSystemContext.curveForCurveName(curveName);
00303 }
00304
00305 const Curve *Document::curveForCurveName (const QString &curveName) const
00306 {
00307 LOG4CPP_INFO_S ((*mainCat)) << "Document::curveForCurveName";
00308
00309 return m_coordSystemContext.curveForCurveName (curveName);
00310 }
00311
00312 const CurvesGraphs &Document::curvesGraphs () const
00313 {
00314 LOG4CPP_INFO_S ((*mainCat)) << "Document::curvesGraphs";
00315
00316 return m_coordSystemContext.curvesGraphs();
00317 }
00318
00319 QStringList Document::curvesGraphsNames() const
00320 {
00321 LOG4CPP_INFO_S ((*mainCat)) << "Document::curvesGraphsNames";
00322
00323 return m_coordSystemContext.curvesGraphsNames();
00324 }
00325
00326 int Document::curvesGraphsNumPoints(const QString &curveName) const
00327 {
00328 LOG4CPP_INFO_S ((*mainCat)) << "Document::curvesGraphsNumPoints";
00329
00330 return m_coordSystemContext.curvesGraphsNumPoints(curveName);
00331 }
00332
00333 DocumentAxesPointsRequired Document::documentAxesPointsRequired () const
00334 {
00335 return m_documentAxesPointsRequired;
00336 }
00337
00338 void Document::editPointAxis (const QPointF &posGraph,
00339 const QString &identifier)
00340 {
00341 LOG4CPP_INFO_S ((*mainCat)) << "Document::editPointAxis";
00342
00343 m_coordSystemContext.editPointAxis(posGraph,
00344 identifier);
00345 }
00346
00347 void Document::editPointGraph (bool isX,
00348 bool isY,
00349 double x,
00350 double y,
00351 const QStringList &identifiers,
00352 const Transformation &transformation)
00353 {
00354 LOG4CPP_INFO_S ((*mainCat)) << "Document::editPointCurve";
00355
00356 m_coordSystemContext.editPointGraph (isX,
00357 isY,
00358 x,
00359 y,
00360 identifiers,
00361 transformation);
00362 }
00363
00364 void Document::generateEmptyPixmap(const QXmlStreamAttributes &attributes)
00365 {
00366 LOG4CPP_INFO_S ((*mainCat)) << "Document::generateEmptyPixmap";
00367
00368 int width = 800, height = 500;
00369
00370 if (attributes.hasAttribute (DOCUMENT_SERIALIZE_IMAGE_WIDTH) &&
00371 attributes.hasAttribute (DOCUMENT_SERIALIZE_IMAGE_HEIGHT)) {
00372
00373 width = attributes.value (DOCUMENT_SERIALIZE_IMAGE_WIDTH).toInt();
00374 height = attributes.value (DOCUMENT_SERIALIZE_IMAGE_HEIGHT).toInt();
00375
00376 }
00377
00378 m_pixmap = QPixmap (width, height);
00379 }
00380
00381 void Document::initializeGridDisplay (const Transformation &transformation)
00382 {
00383 LOG4CPP_INFO_S ((*mainCat)) << "Document::initializeGridDisplay";
00384
00385 ENGAUGE_ASSERT (!m_coordSystemContext.modelGridDisplay().stable());
00386
00387
00388 CallbackBoundingRects ftor (transformation);
00389
00390 Functor2wRet<const QString &, const Point &, CallbackSearchReturn> ftorWithCallback = functor_ret (ftor,
00391 &CallbackBoundingRects::callback);
00392
00393 iterateThroughCurvePointsAxes (ftorWithCallback);
00394
00395
00396 bool isEmpty;
00397 QRectF boundingRectGraph = ftor.boundingRectGraph(isEmpty);
00398 if (!isEmpty) {
00399
00400 GridInitializer gridInitializer;
00401
00402 DocumentModelGridDisplay modelGridDisplay = gridInitializer.initializeWithWidePolarCoverage (boundingRectGraph,
00403 modelCoords(),
00404 transformation,
00405 m_pixmap.size ());
00406
00407 m_coordSystemContext.setModelGridDisplay (modelGridDisplay);
00408 }
00409 }
00410
00411 bool Document::isXOnly (const QString &pointIdentifier) const
00412 {
00413 return m_coordSystemContext.isXOnly (pointIdentifier);
00414 }
00415
00416 void Document::iterateThroughCurvePointsAxes (const Functor2wRet<const QString &, const Point &, CallbackSearchReturn> &ftorWithCallback)
00417 {
00418 LOG4CPP_INFO_S ((*mainCat)) << "Document::iterateThroughCurvePointsAxes";
00419
00420 m_coordSystemContext.iterateThroughCurvePointsAxes(ftorWithCallback);
00421 }
00422
00423 void Document::iterateThroughCurvePointsAxes (const Functor2wRet<const QString &, const Point &, CallbackSearchReturn> &ftorWithCallback) const
00424 {
00425 LOG4CPP_INFO_S ((*mainCat)) << "Document::iterateThroughCurvePointsAxes";
00426
00427 m_coordSystemContext.iterateThroughCurvePointsAxes(ftorWithCallback);
00428 }
00429
00430 void Document::iterateThroughCurveSegments (const QString &curveName,
00431 const Functor2wRet<const Point &, const Point &, CallbackSearchReturn> &ftorWithCallback) const
00432 {
00433 LOG4CPP_INFO_S ((*mainCat)) << "Document::iterateThroughCurveSegments";
00434
00435 m_coordSystemContext.iterateThroughCurveSegments(curveName,
00436 ftorWithCallback);
00437 }
00438
00439 void Document::iterateThroughCurvesPointsGraphs (const Functor2wRet<const QString &, const Point &, CallbackSearchReturn> &ftorWithCallback)
00440 {
00441 LOG4CPP_INFO_S ((*mainCat)) << "Document::iterateThroughCurvesPointsGraphs";
00442
00443 m_coordSystemContext.iterateThroughCurvesPointsGraphs(ftorWithCallback);
00444 }
00445
00446 void Document::iterateThroughCurvesPointsGraphs (const Functor2wRet<const QString &, const Point &, CallbackSearchReturn> &ftorWithCallback) const
00447 {
00448 LOG4CPP_INFO_S ((*mainCat)) << "Document::iterateThroughCurvesPointsGraphs";
00449
00450 m_coordSystemContext.iterateThroughCurvesPointsGraphs(ftorWithCallback);
00451 }
00452
00453 void Document::loadImage(QXmlStreamReader &reader)
00454 {
00455 LOG4CPP_INFO_S ((*mainCat)) << "Document::loadImage";
00456
00457 loadNextFromReader(reader);
00458 if (reader.isCDATA ()) {
00459
00460
00461 QByteArray array64 = reader.text().toString().toUtf8();
00462
00463
00464 QByteArray array;
00465 array = QByteArray::fromBase64(array64);
00466
00467
00468 QDataStream str (&array, QIODevice::ReadOnly);
00469 QImage img = m_pixmap.toImage ();
00470 str >> img;
00471 m_pixmap = QPixmap::fromImage (img);
00472
00473
00474 while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
00475 (reader.name() != DOCUMENT_SERIALIZE_IMAGE)){
00476 loadNextFromReader(reader);
00477 }
00478
00479 } else {
00480
00481
00482
00483
00484 reader.raiseError (QObject::tr ("Cannot read image data"));
00485 }
00486 }
00487
00488 void Document::loadPreVersion6 (QDataStream &str)
00489 {
00490 LOG4CPP_INFO_S ((*mainCat)) << "Document::loadPreVersion6";
00491
00492 qint32 int32;
00493 double version;
00494 QString st;
00495
00496 m_documentAxesPointsRequired = DOCUMENT_AXES_POINTS_REQUIRED_3;
00497
00498 str >> int32;
00499 str >> version;
00500 str >> st;
00501 str >> int32;
00502 str >> m_pixmap;
00503 str >> m_name;
00504
00505 m_coordSystemContext.loadPreVersion6 (str,
00506 version);
00507 }
00508
00509 void Document::loadVersion6 (QFile *file)
00510 {
00511 LOG4CPP_INFO_S ((*mainCat)) << "Document::loadVersion6";
00512
00513 QXmlStreamReader reader (file);
00514
00515 m_documentAxesPointsRequired = DOCUMENT_AXES_POINTS_REQUIRED_3;
00516
00517
00518 m_coordSystemContext.addCoordSystems(m_documentAxesPointsRequired,
00519 NOMINAL_COORD_SYSTEM_COUNT);
00520
00521
00522
00523 bool inDocumentSubtree = false;
00524
00525
00526 while (!reader.atEnd() &&
00527 !reader.hasError()) {
00528 QXmlStreamReader::TokenType tokenType = loadNextFromReader(reader);
00529
00530
00531 if ((reader.name() == DOCUMENT_SERIALIZE_IMAGE) &&
00532 (tokenType == QXmlStreamReader::StartElement)) {
00533
00534 generateEmptyPixmap (reader.attributes());
00535 }
00536
00537
00538 if ((reader.name() == DOCUMENT_SERIALIZE_DOCUMENT) &&
00539 (tokenType == QXmlStreamReader::StartElement)) {
00540
00541 inDocumentSubtree = true;
00542
00543 } else if ((reader.name() == DOCUMENT_SERIALIZE_DOCUMENT) &&
00544 (tokenType == QXmlStreamReader::EndElement)) {
00545
00546
00547 break;
00548 }
00549
00550 if (inDocumentSubtree) {
00551
00552
00553 if (tokenType == QXmlStreamReader::StartElement) {
00554
00555
00556 QString tag = reader.name().toString();
00557 if (tag == DOCUMENT_SERIALIZE_IMAGE) {
00558
00559 loadImage(reader);
00560
00561
00562 m_coordSystemContext.loadVersion6 (reader);
00563
00564
00565 break;
00566 }
00567 }
00568 }
00569 }
00570 if (reader.hasError ()) {
00571
00572 m_successfulRead = false;
00573 m_reasonForUnsuccessfulRead = reader.errorString();
00574 }
00575
00576
00577 }
00578
00579 void Document::loadVersions7AndUp (QFile *file)
00580 {
00581 LOG4CPP_INFO_S ((*mainCat)) << "Document::loadVersions7AndUp";
00582
00583 const int ONE_COORDINATE_SYSTEM = 1;
00584
00585 QXmlStreamReader reader (file);
00586
00587
00588
00589 bool inDocumentSubtree = false;
00590
00591
00592 while (!reader.atEnd() &&
00593 !reader.hasError()) {
00594 QXmlStreamReader::TokenType tokenType = loadNextFromReader(reader);
00595
00596
00597 if ((reader.name() == DOCUMENT_SERIALIZE_IMAGE) &&
00598 (tokenType == QXmlStreamReader::StartElement)) {
00599
00600 generateEmptyPixmap (reader.attributes());
00601 }
00602
00603
00604 if ((reader.name() == DOCUMENT_SERIALIZE_DOCUMENT) &&
00605 (tokenType == QXmlStreamReader::StartElement)) {
00606
00607 inDocumentSubtree = true;
00608
00609 QXmlStreamAttributes attributes = reader.attributes();
00610 if (attributes.hasAttribute (DOCUMENT_SERIALIZE_AXES_POINTS_REQUIRED)) {
00611 m_documentAxesPointsRequired = (DocumentAxesPointsRequired) attributes.value (DOCUMENT_SERIALIZE_AXES_POINTS_REQUIRED).toInt();
00612 } else {
00613 m_documentAxesPointsRequired = DOCUMENT_AXES_POINTS_REQUIRED_3;
00614 }
00615
00616 } else if ((reader.name() == DOCUMENT_SERIALIZE_DOCUMENT) &&
00617 (tokenType == QXmlStreamReader::EndElement)) {
00618
00619
00620 break;
00621 }
00622
00623 if (inDocumentSubtree) {
00624
00625
00626 if (tokenType == QXmlStreamReader::StartElement) {
00627
00628
00629 QString tag = reader.name().toString();
00630 if (tag == DOCUMENT_SERIALIZE_COORD_SYSTEM) {
00631 m_coordSystemContext.addCoordSystems (m_documentAxesPointsRequired,
00632 ONE_COORDINATE_SYSTEM);
00633 m_coordSystemContext.loadVersions7AndUp (reader,
00634 m_documentAxesPointsRequired);
00635 } else if (tag == DOCUMENT_SERIALIZE_IMAGE) {
00636
00637 loadImage(reader);
00638 }
00639 }
00640 }
00641 }
00642 if (reader.hasError ()) {
00643
00644 m_successfulRead = false;
00645 m_reasonForUnsuccessfulRead = reader.errorString();
00646 }
00647
00648
00649 }
00650
00651 DocumentModelAxesChecker Document::modelAxesChecker() const
00652 {
00653 LOG4CPP_DEBUG_S ((*mainCat)) << "Document::modelAxesChecker";
00654
00655 return m_coordSystemContext.modelAxesChecker();
00656 }
00657
00658 DocumentModelColorFilter Document::modelColorFilter() const
00659 {
00660 LOG4CPP_DEBUG_S ((*mainCat)) << "Document::modelColorFilter";
00661
00662 return m_coordSystemContext.modelColorFilter();
00663 }
00664
00665 DocumentModelCoords Document::modelCoords() const
00666 {
00667 LOG4CPP_DEBUG_S ((*mainCat)) << "Document::modelCoords";
00668
00669 return m_coordSystemContext.modelCoords();
00670 }
00671
00672 CurveStyles Document::modelCurveStyles() const
00673 {
00674 LOG4CPP_DEBUG_S ((*mainCat)) << "Document::modelCurveStyles";
00675
00676 return m_coordSystemContext.modelCurveStyles();
00677 }
00678
00679 DocumentModelDigitizeCurve Document::modelDigitizeCurve() const
00680 {
00681 LOG4CPP_DEBUG_S ((*mainCat)) << "Document::modelDigitizeCurve";
00682
00683 return m_coordSystemContext.modelDigitizeCurve();
00684 }
00685
00686 DocumentModelExportFormat Document::modelExport() const
00687 {
00688 LOG4CPP_DEBUG_S ((*mainCat)) << "Document::modelExport";
00689
00690 return m_coordSystemContext.modelExport();
00691 }
00692
00693 DocumentModelGeneral Document::modelGeneral() const
00694 {
00695 LOG4CPP_DEBUG_S ((*mainCat)) << "Document::modelGeneral";
00696
00697 return m_coordSystemContext.modelGeneral();
00698 }
00699
00700 DocumentModelGridDisplay Document::modelGridDisplay() const
00701 {
00702 LOG4CPP_DEBUG_S ((*mainCat)) << "Document::modelGridDisplay";
00703
00704 return m_coordSystemContext.modelGridDisplay();
00705 }
00706
00707 DocumentModelGridRemoval Document::modelGridRemoval() const
00708 {
00709 LOG4CPP_DEBUG_S ((*mainCat)) << "Document::modelGridRemoval";
00710
00711 return m_coordSystemContext.modelGridRemoval();
00712 }
00713
00714 DocumentModelPointMatch Document::modelPointMatch() const
00715 {
00716 LOG4CPP_DEBUG_S ((*mainCat)) << "Document::modelPointMatch";
00717
00718 return m_coordSystemContext.modelPointMatch();
00719 }
00720
00721 DocumentModelSegments Document::modelSegments() const
00722 {
00723 LOG4CPP_DEBUG_S ((*mainCat)) << "Document::modelSegments";
00724
00725 return m_coordSystemContext.modelSegments();
00726 }
00727
00728 void Document::movePoint (const QString &pointIdentifier,
00729 const QPointF &deltaScreen)
00730 {
00731 m_coordSystemContext.movePoint (pointIdentifier,
00732 deltaScreen);
00733 }
00734
00735 int Document::nextOrdinalForCurve (const QString &curveName) const
00736 {
00737 LOG4CPP_INFO_S ((*mainCat)) << "Document::nextOrdinalForCurve";
00738
00739 return m_coordSystemContext.nextOrdinalForCurve(curveName);
00740 }
00741
00742 QPixmap Document::pixmap () const
00743 {
00744 return m_pixmap;
00745 }
00746
00747 QPointF Document::positionGraph (const QString &pointIdentifier) const
00748 {
00749 return m_coordSystemContext.positionGraph(pointIdentifier);
00750 }
00751
00752 QPointF Document::positionScreen (const QString &pointIdentifier) const
00753 {
00754 return m_coordSystemContext.positionScreen(pointIdentifier);
00755 }
00756
00757 void Document::print () const
00758 {
00759 QString text;
00760 QTextStream str (&text);
00761
00762 printStream ("",
00763 str);
00764 std::cerr << text.toLatin1().data();
00765 }
00766
00767 void Document::printStream (QString indentation,
00768 QTextStream &str) const
00769 {
00770 str << indentation << "Document\n";
00771
00772 indentation += INDENTATION_DELTA;
00773
00774 str << indentation << "name=" << m_name << "\n";
00775 str << indentation << "pixmap=" << m_pixmap.width() << "x" << m_pixmap.height() << "\n";
00776
00777 m_coordSystemContext.printStream(indentation,
00778 str);
00779 }
00780
00781 QString Document::reasonForUnsuccessfulRead () const
00782 {
00783 ENGAUGE_ASSERT (!m_successfulRead);
00784
00785 return m_reasonForUnsuccessfulRead;
00786 }
00787
00788 void Document::removePointAxis (const QString &identifier)
00789 {
00790 LOG4CPP_INFO_S ((*mainCat)) << "Document::removePointAxis";
00791
00792 m_coordSystemContext.removePointAxis(identifier);
00793 }
00794
00795 void Document::removePointGraph (const QString &identifier)
00796 {
00797 LOG4CPP_INFO_S ((*mainCat)) << "Document::removePointGraph";
00798
00799 m_coordSystemContext.removePointGraph(identifier);
00800 }
00801
00802 void Document::removePointsInCurvesGraphs (CurvesGraphs &curvesGraphs)
00803 {
00804 LOG4CPP_INFO_S ((*mainCat)) << "Document::removePointsInCurvesGraphs";
00805
00806 m_coordSystemContext.removePointsInCurvesGraphs(curvesGraphs);
00807 }
00808
00809 void Document::saveXml (QXmlStreamWriter &writer) const
00810 {
00811 writer.writeStartElement(DOCUMENT_SERIALIZE_DOCUMENT);
00812
00813
00814
00815 writer.writeAttribute(DOCUMENT_SERIALIZE_APPLICATION_VERSION_NUMBER, VERSION_NUMBER);
00816
00817
00818 writer.writeAttribute(DOCUMENT_SERIALIZE_AXES_POINTS_REQUIRED, QString::number (m_documentAxesPointsRequired));
00819
00820
00821 QByteArray array;
00822 QDataStream str (&array, QIODevice::WriteOnly);
00823 QImage img = m_pixmap.toImage ();
00824 str << img;
00825 writer.writeStartElement(DOCUMENT_SERIALIZE_IMAGE);
00826
00827
00828
00829 writer.writeAttribute(DOCUMENT_SERIALIZE_IMAGE_WIDTH, QString::number (img.width()));
00830 writer.writeAttribute(DOCUMENT_SERIALIZE_IMAGE_HEIGHT, QString::number (img.height()));
00831
00832 writer.writeCDATA (array.toBase64 ());
00833 writer.writeEndElement();
00834
00835 m_coordSystemContext.saveXml (writer);
00836 }
00837
00838 QString Document::selectedCurveName() const
00839 {
00840 return m_coordSystemContext.selectedCurveName();
00841 }
00842
00843 void Document::setCoordSystemIndex(CoordSystemIndex coordSystemIndex)
00844 {
00845 LOG4CPP_INFO_S ((*mainCat)) << "Document::setCoordSystemIndex";
00846
00847 m_coordSystemContext.setCoordSystemIndex (coordSystemIndex);
00848 }
00849
00850 void Document::setCurveAxes (const Curve &curveAxes)
00851 {
00852 LOG4CPP_INFO_S ((*mainCat)) << "Document::setCurveAxes";
00853
00854 m_coordSystemContext.setCurveAxes (curveAxes);
00855 }
00856
00857 void Document::setCurvesGraphs (const CurvesGraphs &curvesGraphs)
00858 {
00859 LOG4CPP_INFO_S ((*mainCat)) << "Document::setCurvesGraphs";
00860
00861 m_coordSystemContext.setCurvesGraphs(curvesGraphs);
00862 }
00863
00864 void Document::setDocumentAxesPointsRequired(DocumentAxesPointsRequired documentAxesPointsRequired)
00865 {
00866 LOG4CPP_INFO_S ((*mainCat)) << "Document::setDocumentAxesPointsRequired";
00867
00868 m_documentAxesPointsRequired = documentAxesPointsRequired;
00869 }
00870
00871 void Document::setModelAxesChecker(const DocumentModelAxesChecker &modelAxesChecker)
00872 {
00873 LOG4CPP_INFO_S ((*mainCat)) << "Document::setModelAxesChecker";
00874
00875 m_coordSystemContext.setModelAxesChecker(modelAxesChecker);
00876 }
00877
00878 void Document::setModelColorFilter(const DocumentModelColorFilter &modelColorFilter)
00879 {
00880 LOG4CPP_INFO_S ((*mainCat)) << "Document::setModelColorFilter";
00881
00882
00883 ColorFilterSettingsList::const_iterator itr;
00884 for (itr = modelColorFilter.colorFilterSettingsList().constBegin ();
00885 itr != modelColorFilter.colorFilterSettingsList().constEnd();
00886 itr++) {
00887
00888 QString curveName = itr.key();
00889 const ColorFilterSettings &colorFilterSettings = itr.value();
00890
00891 Curve *curve = curveForCurveName (curveName);
00892 curve->setColorFilterSettings (colorFilterSettings);
00893 }
00894 }
00895
00896 void Document::setModelCoords (const DocumentModelCoords &modelCoords)
00897 {
00898 LOG4CPP_INFO_S ((*mainCat)) << "Document::setModelCoords";
00899
00900 m_coordSystemContext.setModelCoords(modelCoords);
00901 }
00902
00903 void Document::setModelCurveStyles(const CurveStyles &modelCurveStyles)
00904 {
00905 LOG4CPP_INFO_S ((*mainCat)) << "Document::setModelCurveStyles";
00906
00907
00908 QStringList curveNames = modelCurveStyles.curveNames();
00909 QStringList::iterator itr;
00910 for (itr = curveNames.begin(); itr != curveNames.end(); itr++) {
00911
00912 QString curveName = *itr;
00913 const CurveStyle &curveStyle = modelCurveStyles.curveStyle (curveName);
00914
00915 Curve *curve = curveForCurveName (curveName);
00916 curve->setCurveStyle (curveStyle);
00917 }
00918 }
00919
00920 void Document::setModelDigitizeCurve (const DocumentModelDigitizeCurve &modelDigitizeCurve)
00921 {
00922 LOG4CPP_INFO_S ((*mainCat)) << "Document::setModelDigitizeCurve";
00923
00924 m_coordSystemContext.setModelDigitizeCurve(modelDigitizeCurve);
00925 }
00926
00927 void Document::setModelExport(const DocumentModelExportFormat &modelExport)
00928 {
00929 LOG4CPP_INFO_S ((*mainCat)) << "Document::setModelExport";
00930
00931 m_coordSystemContext.setModelExport (modelExport);
00932 }
00933
00934 void Document::setModelGeneral (const DocumentModelGeneral &modelGeneral)
00935 {
00936 LOG4CPP_INFO_S ((*mainCat)) << "Document::setModelGeneral";
00937
00938 m_coordSystemContext.setModelGeneral(modelGeneral);
00939 }
00940
00941 void Document::setModelGridDisplay(const DocumentModelGridDisplay &modelGridDisplay)
00942 {
00943 LOG4CPP_INFO_S ((*mainCat)) << "Document::setModelGridDisplay";
00944
00945 m_coordSystemContext.setModelGridDisplay(modelGridDisplay);
00946 }
00947
00948 void Document::setModelGridRemoval(const DocumentModelGridRemoval &modelGridRemoval)
00949 {
00950 LOG4CPP_INFO_S ((*mainCat)) << "Document::setModelGridRemoval";
00951
00952 m_coordSystemContext.setModelGridRemoval(modelGridRemoval);
00953 }
00954
00955 void Document::setModelPointMatch(const DocumentModelPointMatch &modelPointMatch)
00956 {
00957 LOG4CPP_INFO_S ((*mainCat)) << "Document::setModelPointMatch";
00958
00959 m_coordSystemContext.setModelPointMatch(modelPointMatch);
00960 }
00961
00962 void Document::setModelSegments(const DocumentModelSegments &modelSegments)
00963 {
00964 LOG4CPP_INFO_S ((*mainCat)) << "Document::setModelSegments";
00965
00966 m_coordSystemContext.setModelSegments (modelSegments);
00967 }
00968
00969 void Document::setPixmap(const QImage &image)
00970 {
00971 LOG4CPP_INFO_S ((*mainCat)) << "Document::setPixmap";
00972
00973 m_pixmap = QPixmap::fromImage (image);
00974 }
00975
00976 void Document::setSelectedCurveName(const QString &selectedCurveName)
00977 {
00978 m_coordSystemContext.setSelectedCurveName (selectedCurveName);
00979 }
00980
00981 bool Document::successfulRead () const
00982 {
00983 return m_successfulRead;
00984 }
00985
00986 void Document::updatePointOrdinals (const Transformation &transformation)
00987 {
00988 LOG4CPP_INFO_S ((*mainCat)) << "Document::updatePointOrdinals";
00989
00990 m_coordSystemContext.updatePointOrdinals(transformation);
00991 }
00992
00993 int Document::versionFromFile (QFile *file) const
00994 {
00995 LOG4CPP_INFO_S ((*mainCat)) << "Document::versionFromFile";
00996
00997 int version = VERSION_6;
00998
00999 QDomDocument doc;
01000 if (doc.setContent (file)) {
01001
01002 QDomNodeList nodes = doc.elementsByTagName (DOCUMENT_SERIALIZE_DOCUMENT);
01003 if (nodes.count() > 0) {
01004 QDomNode node = nodes.at (0);
01005
01006 QDomNamedNodeMap attributes = node.attributes();
01007
01008 if (attributes.contains (DOCUMENT_SERIALIZE_APPLICATION_VERSION_NUMBER)) {
01009
01010 QDomElement elem = node.toElement();
01011 version = (int) elem.attribute (DOCUMENT_SERIALIZE_APPLICATION_VERSION_NUMBER).toDouble();
01012 }
01013 }
01014 }
01015
01016 file->seek (0);
01017
01018 return version;
01019 }