Subversion Repositories Scribus

Rev

Rev 2046 | Rev 3079 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2036 craig 1
#include "pdfoptionsio.h"
2
#include "scribusstructs.h"
3
 
2042 craig 4
#include "qapplication.h"
5
 
2036 craig 6
const int PDFOptionsIO::formatVersion = 1300;
7
 
8
PDFOptionsIO::PDFOptionsIO(PDFOptions& opts) :
2043 craig 9
        m_doc(),
2038 craig 10
        m_root(),
11
        m_includePasswords(false),
12
        m_error()
2036 craig 13
{
2038 craig 14
        this->m_opts = &opts;
2036 craig 15
}
16
 
17
// writeTo(QString) is implemented separately to writeTo(QTextStream)
18
// because we don't want to clobber the output file until we know the
19
// data has been generated ok, and we can't avoid clobbering the file
20
// to create a QTextStream().
2038 craig 21
bool PDFOptionsIO::writeTo(QString outFileName, bool includePasswords)
2036 craig 22
{
2038 craig 23
        m_includePasswords = includePasswords;
2036 craig 24
        QString xml = buildXMLString();
25
        if (xml == QString::null)
26
                return false;
27
        QFile f(outFileName);
28
        if (!f.open(IO_WriteOnly|IO_Truncate))
29
        {
2217 cbradney 30
                m_error = QObject::tr("Could not open output file %1")
2042 craig 31
                        .arg(qApp->translate("QFile",f.errorString()));
2036 craig 32
                return false;
33
        }
34
        QTextStream ts(&f);
35
        ts.setEncoding(QTextStream::UnicodeUTF8);
36
        ts << xml;
2038 craig 37
        m_includePasswords = false; // just to be paranoid
38
        m_error = QString::null;
2036 craig 39
        return true;
40
}
41
 
2043 craig 42
bool PDFOptionsIO::writeTo(QIODevice& outDevice, bool includePasswords)
2036 craig 43
{
2038 craig 44
        m_includePasswords = includePasswords;
2043 craig 45
        if (!outDevice.isWritable())
2036 craig 46
        {
2038 craig 47
                m_error = QObject::tr("Output stream not writeable");
2036 craig 48
                return false;
49
        }
50
        QString xml = buildXMLString();
51
        if (xml == QString::null)
52
                return false;
2043 craig 53
        QTextStream ts(&outDevice);
54
        ts.setEncoding(QTextStream::UnicodeUTF8);
55
        ts << xml;
2038 craig 56
        m_includePasswords = false; // just to be paranoid
57
        m_error = QString::null;
2036 craig 58
        return true;
59
}
60
 
61
// Construct and return an XML string representing the settings
62
QString PDFOptionsIO::buildXMLString()
63
{
64
        // Verify to make sure our settings are sane
65
        QString vrfyError;
2046 craig 66
        // Make sure the options are sane
2038 craig 67
        PDFOptions::VerifyResults vr = m_opts->verify(&vrfyError);
2036 craig 68
        if (vr != PDFOptions::Verify_NoError)
69
        {
2038 craig 70
                m_error = QObject::tr("Verification of settings failed: %1").arg(vrfyError);
2036 craig 71
                return QString::null;
72
        }
73
        // Build the document. Initial implementation uses QDom.
2046 craig 74
        m_doc = QDomDocument();
2038 craig 75
        m_root = m_doc.createElement("ScribusPDFOptions");
76
        m_root.setAttribute("version", formatVersion);
77
        m_doc.appendChild(m_root);
2036 craig 78
        // Fill the guts of the document
79
        buildSettings();
80
        // We're done - return a string containing the document XML
2038 craig 81
        QString xml = m_doc.toString();
2046 craig 82
        xml.prepend(
83
                "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
84
                "<!DOCTYPE ScribusPDFOptions SYSTEM 'scribuspdfoptions.dtd'>\n"
85
                );
2036 craig 86
        return xml;
87
}
88
 
89
// Build up the stored settings into the passed DOM objects
90
void PDFOptionsIO::buildSettings()
91
{
2038 craig 92
        addElem(m_root, "thumbnails", m_opts->Thumbnails);
93
        addElem(m_root, "articles", m_opts->Articles);
94
        addElem(m_root, "useLayers", m_opts->useLayers);
95
        addElem(m_root, "compress", m_opts->Compress);
96
        addElem(m_root, "compressMethod", m_opts->CompressMethod);
97
        addElem(m_root, "quality", m_opts->Quality);
98
        addElem(m_root, "recalcPic", m_opts->RecalcPic);
99
        addElem(m_root, "bookmarks", m_opts->Bookmarks);
100
        addElem(m_root, "picRes", m_opts->PicRes);
2036 craig 101
        QString pdfVersString;
2038 craig 102
        switch (m_opts->Version)
2036 craig 103
        {
104
                case PDFOptions::PDFVersion_X3:
105
                        pdfVersString = "X3";
106
                        break;
107
                default:
2038 craig 108
                        pdfVersString = QString::number(m_opts->Version);
2036 craig 109
                        break;
110
        }
2038 craig 111
        addElem(m_root, "pdfVersion", pdfVersString);
112
        addElem(m_root, "resolution", m_opts->Resolution);
113
        addElem(m_root, "binding", m_opts->Binding);
114
        addList(m_root, "embedFonts", m_opts->EmbedList);
115
        addList(m_root, "subsetFonts", m_opts->SubsetList);
116
        addElem(m_root, "mirrorH", m_opts->MirrorH);
117
        addElem(m_root, "mirrorV", m_opts->MirrorV);
118
        addElem(m_root, "rotateDegrees", m_opts->RotateDeg);
119
        addElem(m_root, "presentMode", m_opts->PresentMode);
2036 craig 120
        addPresentationData();
2038 craig 121
        addElem(m_root, "filename", m_opts->Datei);
122
        addElem(m_root, "isGrayscale", m_opts->isGrayscale);
123
        addElem(m_root, "useRGB", m_opts->UseRGB);
124
        addElem(m_root, "useProfiles", m_opts->UseProfiles);
125
        addElem(m_root, "useProfiles2", m_opts->UseProfiles2);
126
        addElem(m_root, "useLPI", m_opts->UseLPI);
2036 craig 127
        addLPISettings();
2038 craig 128
        addElem(m_root, "solidProf", m_opts->SolidProf);
129
        addElem(m_root, "sComp", m_opts->SComp);
130
        addElem(m_root, "imageProf", m_opts->ImageProf);
131
        addElem(m_root, "embeddedI", m_opts->EmbeddedI);
132
        addElem(m_root, "intent2", m_opts->Intent2);
133
        addElem(m_root, "printProf", m_opts->PrintProf);
134
        addElem(m_root, "info", m_opts->Info);
135
        addElem(m_root, "intent", m_opts->Intent);
136
        addElem(m_root, "bleedTop", m_opts->BleedTop);
137
        addElem(m_root, "bleedLeft", m_opts->BleedLeft);
138
        addElem(m_root, "bleedRight", m_opts->BleedRight);
139
        addElem(m_root, "bleedBottom", m_opts->BleedBottom);
140
        addElem(m_root, "encrypt", m_opts->Encrypt);
141
        addElem(m_root, "passOwner", m_includePasswords ? m_opts->PassOwner : "");
142
        addElem(m_root, "passUser", m_includePasswords ? m_opts->PassUser : "");
143
        addElem(m_root, "permissions", m_opts->Permissions);
2036 craig 144
}
145
 
146
// Convenience functions to add a single-attribute element
147
// of a particular type to the tree at a given point.
148
 
149
void PDFOptionsIO::addElem(QDomElement& addTo, QString name, bool value)
150
{
2038 craig 151
        QDomElement elem = m_doc.createElement(name);
2046 craig 152
        elem.setAttribute("value", value ? "true" : "false" );
2036 craig 153
        addTo.appendChild(elem);
154
}
155
 
156
void PDFOptionsIO::addElem(QDomElement& addTo, QString name, QString value)
157
{
2038 craig 158
        QDomElement elem = m_doc.createElement(name);
2036 craig 159
        elem.setAttribute("value",value);
160
        addTo.appendChild(elem);
161
}
162
 
163
void PDFOptionsIO::addElem(QDomElement& addTo, QString name, int value)
164
{
2038 craig 165
        QDomElement elem = m_doc.createElement(name);
2036 craig 166
        elem.setAttribute("value",value);
167
        addTo.appendChild(elem);
168
}
169
 
170
void PDFOptionsIO::addElem(QDomElement& addTo, QString name, double value)
171
{
2038 craig 172
        QDomElement elem = m_doc.createElement(name);
2036 craig 173
        elem.setAttribute("value",value);
174
        addTo.appendChild(elem);
175
}
176
 
177
// Save a QValueList<String> or QStringList as a list of
178
// <item value=""> elements
179
void PDFOptionsIO::addList(QDomElement& addTo, QString name, QValueList<QString>& value)
180
{
181
        // List base element has no attributes, only children
2038 craig 182
        QDomElement listbase = m_doc.createElement(name);
2036 craig 183
        addTo.appendChild(listbase);
184
        QValueList<QString>::iterator it;
185
        for (it = value.begin(); it != value.end(); ++it)
186
                addElem(listbase, "item", *(it));
187
}
188
 
189
// save PDFOptions::PresentVals
190
void PDFOptionsIO::addPresentationData()
191
{
192
        // PDFOptions::PresentVals is a QValueList<PDFPresentationData>
193
        //
194
        // XML structure will be like this:
195
        // <presentationSettings>
196
        //   <presentationSettingsEntry>
197
        //     <pageEffectDuration value="0"/>
198
        //     <pageViewDuration value="0"/>
199
        //     <effectType value="0"/>
200
        //     <dm value="0"/>
201
        //     <m value="0"/>
202
        //     <di value="0"/>
203
        //   </presentationSettingsEntry>
204
        //   <presentationSettingsEntry>
205
        //     ...
206
        //   </presentationSettingsEntry>
207
        //   ...
208
        // </presentationSettings>
2038 craig 209
        QDomElement presentationSettings = m_doc.createElement("presentationSettings");
210
        m_root.appendChild(presentationSettings);
2036 craig 211
        QValueList<PDFPresentationData>::iterator it;
2038 craig 212
        for (it = m_opts->PresentVals.begin(); it != m_opts->PresentVals.end(); ++it)
2036 craig 213
        {
214
                // Settings entry has no attributes, only children
2038 craig 215
                QDomElement psEntry = m_doc.createElement("presentationSettingsEntry");
2036 craig 216
                presentationSettings.appendChild(psEntry);
217
                // Children:
218
                addElem(psEntry, "pageEffectDuration", (*it).pageEffectDuration);
219
                addElem(psEntry, "pageViewDuration", (*it).pageViewDuration);
220
                addElem(psEntry, "effectType", (*it).effectType);
221
                addElem(psEntry, "dm", (*it).Dm);
222
                addElem(psEntry, "m", (*it).M);
223
                addElem(psEntry, "di", (*it).Di);
224
        }
225
}
226
 
227
// Save PDFOptions::LPISettings
228
void PDFOptionsIO::addLPISettings()
229
{
230
        // PDFOptions::LPISettings is a QMap<QString,LPIData>
231
        //
232
        // XML structure will be like this:
233
        // <lpiSettings>
234
        //   <lpiSettingsEntry name="blah">
235
        //     <frequency value="0">
236
        //     <angle value="0">
237
        //     <spotFunc value="0">
238
        //   </lpiSettingsEntry>
239
        //   <lpiSettingsEntry name="blah2">
240
        //     ...
241
        //   </lpiSettingsEntry>
242
        //   ...
243
        // </lpiSettings>
2038 craig 244
        QDomElement lpiSettings = m_doc.createElement("lpiSettings");
245
        m_root.appendChild(lpiSettings);
2036 craig 246
        QMap<QString,LPIData>::iterator it;
2038 craig 247
        for (it = m_opts->LPISettings.begin(); it != m_opts->LPISettings.end(); ++it)
2036 craig 248
        {
249
                // Settings entry has no attributes, only children
2038 craig 250
                QDomElement lpiEntry = m_doc.createElement("lpiSettingsEntry");
2036 craig 251
                lpiEntry.setAttribute("name", it.key());
252
                lpiSettings.appendChild(lpiEntry);
253
                // Children:
254
                addElem(lpiEntry, "frequency", (*it).Frequency);
255
                addElem(lpiEntry, "angle", (*it).Angle);
256
                addElem(lpiEntry, "spotFunc", (*it).SpotFunc);
257
        }
258
 
259
}
260
 
2042 craig 261
// overload of bool readFrom(QTextStream& inStream)
262
bool PDFOptionsIO::readFrom(QString inFileName)
263
{
264
        QFile f(inFileName);
265
        if (!f.open(IO_ReadOnly))
266
        {
2217 cbradney 267
                m_error = QObject::tr("Could not open input file %1")
2042 craig 268
                        .arg(qApp->translate("QFile",f.errorString()));
269
                return false;
270
        }
2043 craig 271
        return readFrom(f);
2042 craig 272
}
273
 
2043 craig 274
bool PDFOptionsIO::readFrom(QIODevice& inDevice)
2036 craig 275
{
2043 craig 276
        if (!inDevice.isReadable())
2036 craig 277
                return false;
2043 craig 278
        QString domError;
279
        int errorLine, errorColumn;
280
        if (!m_doc.setContent(&inDevice, &domError, &errorLine, &errorColumn))
281
        {
282
                m_error = QObject::tr("Unable to read settings XML:")
283
                        .arg(QObject::tr("%1 (line %2 col %3)", "Load PDF settings")
284
                                .arg(domError).arg(errorLine).arg(errorColumn)
285
                        );
286
                return false;
287
        }
288
        if (!readSettings())
289
                // m_error should already be set
290
                return false;
291
        m_error = QString::null;
292
        return true;
2036 craig 293
}
294
 
2043 craig 295
// Helper for readFrom(...) to read settings from the DOM
296
bool PDFOptionsIO::readSettings()
297
{
298
        // Get the root element
299
        m_root = m_doc.documentElement();
300
        if (m_root.isNull())
301
        {
302
                m_error = QObject::tr("Unable to read settings XML: %1")
303
                        .arg(QObject::tr("null root node", "Load PDF settings"));
304
        }
305
        // and start processing elements
2044 craig 306
        if (!readElem(m_root, "thumbnails", &m_opts->Thumbnails))
2043 craig 307
                return false;
2045 craig 308
        if (!readElem(m_root, "articles", &m_opts->Articles))
309
                return false;
310
        if (!readElem(m_root, "useLayers", &m_opts->useLayers))
311
                return false;
312
        if (!readElem(m_root, "compress", &m_opts->Compress))
313
                return false;
314
        if (!readElem(m_root, "compressMethod", &m_opts->CompressMethod))
315
                return false;
316
        if (!readElem(m_root, "quality", &m_opts->Quality))
317
                return false;
318
        if (!readElem(m_root, "recalcPic", &m_opts->RecalcPic))
319
                return false;
320
        if (!readElem(m_root, "bookmarks", &m_opts->Bookmarks))
321
                return false;
322
        if (!readElem(m_root, "picRes", &m_opts->PicRes))
323
                return false;
324
        readPDFVersion();
325
        if (!readElem(m_root, "resolution", &m_opts->Resolution))
326
                return false;
327
        if (!readElem(m_root, "binding", &m_opts->Binding))
328
                return false;
329
        if (!readList(m_root, "embedFonts", &m_opts->EmbedList))
330
                return false;
331
        if (!readList(m_root, "subsetFonts", &m_opts->SubsetList))
332
                return false;
333
        if (!readElem(m_root, "mirrorH", &m_opts->MirrorH))
334
                return false;
335
        if (!readElem(m_root, "mirrorV", &m_opts->MirrorV))
336
                return false;
337
        if (!readElem(m_root, "rotateDegrees", &m_opts->RotateDeg))
338
                return false;
339
        if (!readElem(m_root, "presentMode", &m_opts->PresentMode))
340
                return false;
341
        if (!readPresentationData())
342
                return false;
343
        if (!readElem(m_root, "filename", &m_opts->Datei))
344
                return false;
345
        if (!readElem(m_root, "isGrayscale", &m_opts->isGrayscale))
346
                return false;
347
        if (!readElem(m_root, "useRGB", &m_opts->UseRGB))
348
                return false;
349
        if (!readElem(m_root, "useProfiles", &m_opts->UseProfiles))
350
                return false;
351
        if (!readElem(m_root, "useProfiles2", &m_opts->UseProfiles2))
352
                return false;
353
        if (!readElem(m_root, "useLPI", &m_opts->UseLPI))
354
                return false;
355
        if (!readLPISettings())
356
                return false;
357
        if (!readElem(m_root, "solidProf", &m_opts->SolidProf))
358
                return false;
359
        if (!readElem(m_root, "sComp", &m_opts->SComp))
360
                return false;
361
        if (!readElem(m_root, "imageProf", &m_opts->ImageProf))
362
                return false;
363
        if (!readElem(m_root, "embeddedI", &m_opts->EmbeddedI))
364
                return false;
365
        if (!readElem(m_root, "intent2", &m_opts->Intent2))
366
                return false;
367
        if (!readElem(m_root, "printProf", &m_opts->PrintProf))
368
                return false;
369
        if (!readElem(m_root, "info", &m_opts->Info))
370
                return false;
371
        if (!readElem(m_root, "intent", &m_opts->Intent))
372
                return false;
373
        if (!readElem(m_root, "bleedTop", &m_opts->BleedTop))
374
                return false;
375
        if (!readElem(m_root, "bleedLeft", &m_opts->BleedLeft))
376
                return false;
377
        if (!readElem(m_root, "bleedRight", &m_opts->BleedRight))
378
                return false;
379
        if (!readElem(m_root, "bleedBottom", &m_opts->BleedBottom))
380
                return false;
381
        if (!readElem(m_root, "encrypt", &m_opts->Encrypt))
382
                return false;
383
        if (!readElem(m_root, "passOwner", &m_opts->PassOwner))
384
                return false;
385
        if (!readElem(m_root, "passUser", &m_opts->PassUser))
386
                return false;
387
        if (!readElem(m_root, "permissions", &m_opts->Permissions))
388
                return false;
2043 craig 389
        return true;
390
}
391
 
2045 craig 392
bool PDFOptionsIO::readPDFVersion()
393
{
394
        QString pdfVersString;
395
        if (!readElem(m_root, "pdfVersion", &pdfVersString))
396
                return false;
397
        if (pdfVersString == "X3")
398
        {
399
                m_opts->Version = PDFOptions::PDFVersion_X3;
400
                return true;
401
        }
402
        else if (pdfVersString == "13")
403
        {
404
                m_opts->Version = PDFOptions::PDFVersion_13;
405
                return true;
406
        }
407
        else if (pdfVersString == "14")
408
        {
409
                m_opts->Version = PDFOptions::PDFVersion_14;
410
                return true;
411
        }
412
        else if (pdfVersString == "15")
413
        {
414
                m_opts->Version = PDFOptions::PDFVersion_15;
415
                return true;
416
        }
417
        else
418
        {
419
                m_error = QObject::tr("Unable to read settings XML:")
420
                        .arg(QObject::tr("<pdfVersion> invalid", "Load PDF settings"));
421
                return false;
422
        }
423
}
424
 
2043 craig 425
// returns a null node on failure
2045 craig 426
QDomNode PDFOptionsIO::getUniqueNode(QDomElement& parent, QString name)
2043 craig 427
{
428
        QDomNodeList nodes = parent.elementsByTagName(name);
429
        if (nodes.count() != 1)
430
        {
431
                m_error = QObject::tr("Unable to read settings XML:")
432
                        .arg(QObject::tr("found %1 <%2> nodes, need 1.", "Load PDF settings")
433
                                .arg(nodes.count()).arg(name)
434
                        );
2045 craig 435
                return QDomNode();
2043 craig 436
        }
2045 craig 437
        return nodes.item(0);
438
}
439
 
440
// Return the node as a QDomElement iff it is a QDomElement with
441
// a `value' attribute; otherwise return a null element.
442
QDomElement PDFOptionsIO::getValueElement(QDomNode& node, QString name, bool isValue)
443
{
2043 craig 444
        if (node.isNull())
445
        {
446
                m_error = QObject::tr("Unable to read settings XML:")
447
                        .arg(QObject::tr("unexpected null <%2> node", "Load PDF settings")
448
                                .arg(name)
449
                        );
450
                return QDomNode().toElement();
451
        }
452
        if (!node.isElement())
453
        {
454
                m_error = QObject::tr("Unable to read settings XML:")
455
                        .arg(QObject::tr("node <%1> not an element", "Load PDF settings")
456
                                .arg(name)
457
                        );
458
                return QDomNode().toElement();
459
        }
460
        QDomElement elem = node.toElement();
2045 craig 461
        if (elem.tagName() != name)
2043 craig 462
        {
2045 craig 463
                m_error = QObject::tr("Unable to read settings XML:")
464
                        .arg(QString("Internal error: element named <%1> not expected <%2>")
465
                                        .arg(elem.tagName()).arg(name)
466
                        );
467
                return QDomNode().toElement();
468
        }
469
        if (isValue)
470
        {
2043 craig 471
                // We need to check that it has a `value' attribute
472
                if (!elem.hasAttribute("value"))
473
                {
474
                        m_error = QObject::tr("Unable to read settings XML:")
475
                                .arg(QObject::tr("element <%1> lacks `value' attribute", "Load PDF settings")
476
                                        .arg(name)
477
                                );
478
                        return QDomNode().toElement();
479
                }
480
        }
481
        return elem;
482
}
483
 
2044 craig 484
bool PDFOptionsIO::readElem(QDomElement& parent, QString name, bool* value)
2043 craig 485
{
2045 craig 486
        QDomNode node = getUniqueNode(parent, name);
487
        QDomElement elem = getValueElement(node, name);
2043 craig 488
        if (elem.isNull())
489
                return false;
490
        QString elementText = elem.attribute("value");
491
        if (elementText == "true")
492
        {
493
                (*value) = true;
494
                return true;
495
        }
496
        else if (elementText == "false")
497
        {
498
                (*value) = false;
499
                return true;
500
        }
501
        else
502
        {
503
                m_error = QObject::tr("Unable to read settings XML:")
504
                        .arg(QObject::tr("element <%1> value must be `true' or `false'", "Load PDF settings")
505
                                .arg(name)
506
                        );
507
                return false;
508
        }
509
}
510
 
2044 craig 511
bool PDFOptionsIO::readElem(QDomElement& parent, QString name, int* value)
512
{
2045 craig 513
        QDomNode node = getUniqueNode(parent, name);
514
        QDomElement elem = getValueElement(node, name);
2044 craig 515
        if (elem.isNull())
516
                return false;
517
        bool ok = false;
518
        int result = elem.attribute("value").toInt(&ok);
519
        if (ok)
520
                (*value) = result;
521
        return ok;
522
}
523
 
524
bool PDFOptionsIO::readElem(QDomElement& parent, QString name, double* value)
525
{
2045 craig 526
        QDomNode node = getUniqueNode(parent, name);
527
        QDomElement elem = getValueElement(node, name);
2044 craig 528
        if (elem.isNull())
529
                return false;
530
        bool ok = false;
531
        double result = elem.attribute("value").toDouble(&ok);
532
        if (ok)
533
                (*value) = result;
534
        return ok;
535
}
536
 
537
bool PDFOptionsIO::readElem(QDomElement& parent, QString name, QString* value)
538
{
2045 craig 539
        QDomNode node = getUniqueNode(parent, name);
540
        QDomElement elem = getValueElement(node, name);
2044 craig 541
        if (elem.isNull())
542
                return false;
543
        QString result = elem.attribute("value");
544
        bool ok = result != QString::null;
545
        if (ok)
546
                (*value) = result;
547
        return ok;
548
}
549
 
2045 craig 550
// Read a stringlist saved as a list of child <item value=""> elements
551
bool PDFOptionsIO::readList(QDomElement& parent, QString name, QValueList<QString>* value)
552
{
553
        QDomNode basenode = getUniqueNode(parent, name);
554
        QDomElement listbase = getValueElement(basenode, name, false);
555
        if (listbase.isNull())
556
                return false;
557
        QValueList<QString> list;
558
        for (QDomNode node = listbase.firstChild(); !node.isNull(); node = node.nextSibling())
559
        {
560
                QDomElement elem = getValueElement(node, "item");
561
                if (elem.isNull())
562
                        return false;
563
                list.append(elem.attribute("value"));
564
        }
565
        (*value) = list;
566
        return true;
567
}
568
 
569
bool PDFOptionsIO::readPresentationData()
570
{
571
        // XML structure will be like this:
572
        // <presentationSettings>
573
        //   <presentationSettingsEntry>
574
        //     <pageEffectDuration value="0"/>
575
        //     <pageViewDuration value="0"/>
576
        //     <effectType value="0"/>
577
        //     <dm value="0"/>
578
        //     <m value="0"/>
579
        //     <di value="0"/>
580
        //   </presentationSettingsEntry>
581
        //   <presentationSettingsEntry>
582
        //     ...
583
        //   </presentationSettingsEntry>
584
        //   ...
585
        // </presentationSettings>
586
        QDomNode basenode = getUniqueNode(m_root, "presentationSettings");
587
        QDomElement pSettings = getValueElement(basenode, "presentationSettings", false);
588
        if (pSettings.isNull())
589
                return false;
590
        QValueList<PDFPresentationData> pList;
591
        for (QDomNode node = pSettings.firstChild(); !node.isNull(); node = node.nextSibling())
592
        {
593
                QDomElement elem = getValueElement(basenode, "presentationSettingsEntry", false);
594
                if (elem.isNull())
595
                        return false;
596
                PDFPresentationData pres;
597
                if (!readElem(elem, "pageEffectDuration", &pres.pageEffectDuration))
598
                        return false;
599
                if (!readElem(elem, "pageViewDuration", &pres.pageViewDuration))
600
                        return false;
601
                if (!readElem(elem, "effectType", &pres.effectType))
602
                        return false;
603
                if (!readElem(elem, "dm", &pres.Dm))
604
                        return false;
605
                if (!readElem(elem, "m", &pres.M))
606
                        return false;
607
                if (!readElem(elem, "di", &pres.Di))
608
                        return false;
609
                pList.append(pres);
610
        }
611
        return true;
612
}
613
 
614
bool PDFOptionsIO::readLPISettings()
615
{
616
        // XML structure will be like this:
617
        // <lpiSettings>
618
        //   <lpiSettingsEntry name="blah">
619
        //     <frequency value="0">
620
        //     <angle value="0">
621
        //     <spotFunc value="0">
622
        //   </lpiSettingsEntry>
623
        //   <lpiSettingsEntry name="blah2">
624
        //     ...
625
        //   </lpiSettingsEntry>
626
        //   ...
627
        // </lpiSettings>
628
        QDomNode basenode = getUniqueNode(m_root, "lpiSettings");
629
        QDomElement lpiSettings = getValueElement(basenode, "lpiSettings", false);
630
        if (lpiSettings.isNull())
631
                return false;
632
        QMap<QString,LPIData> lpiMap;
633
        for (QDomNode node = lpiSettings.firstChild(); !node.isNull(); node = node.nextSibling())
634
        {
635
                QDomElement elem = getValueElement(basenode, "lpiSettingsEntry", false);
636
                if (elem.isNull())
637
                        return false;
638
                QString name = elem.attribute("name");
639
                if (name == QString::null)
640
                {
641
                        m_error = QObject::tr("Unable to read settings XML:")
642
                                .arg(QObject::tr("element <lpiSettingsEntry> lacks `name' attribute", "Load PDF settings")
643
                                        .arg(name)
644
                                );
645
                        return false;
646
                }
647
                LPIData lpi;
648
                if (!readElem(elem, "frequency", &lpi.Frequency))
649
                        return false;
650
                if (!readElem(elem, "angle", &lpi.Angle))
651
                        return false;
652
                if (!readElem(elem, "spotFunc", &lpi.SpotFunc))
653
                        return false;
654
                lpiMap[name] = lpi;
655
        }
656
        return true;
657
}
658
 
2036 craig 659
const QString& PDFOptionsIO::lastError() const
660
{
2038 craig 661
        return m_error;
2036 craig 662
}