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