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