Rev 2045 | Rev 2217 | 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 | { |
||
2043 | craig | 30 | m_error = QObject::tr("Couldn't 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 | { |
||
2043 | craig | 267 | m_error = QObject::tr("Couldn't 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 | } |