1 /*
2 For general Scribus (>=1.3.2) copyright and licensing information please refer
3 to the COPYING file provided with the program. Following this notice may exist
4 a copyright and/or license notice that predates the release of Scribus 1.3.2
5 for which a new license (GPL+exception) is in place.
6 */
7 #include "scribus12format.h"
8 #include "scribus12formatimpl.h"
9
10 #include <QApplication>
11 #include <QByteArray>
12 #include <QCursor>
13 #include <QDir>
14 #include <QFileInfo>
15 #include <QList>
16 #include <QMessageBox>
17
18 #include "../../formatidlist.h"
19 #include "commonstrings.h"
20 #include "langmgr.h"
21 #include "ui/missing.h"
22 #include "prefsmanager.h"
23 #include "pageitem_latexframe.h"
24 #include "pageitem_line.h"
25 #include "pageitem_group.h"
26 #include "qtiocompressor.h"
27 #include "scconfig.h"
28 #include "scclocale.h"
29 #include "scribusdoc.h"
30 #include "scribusview.h"
31 #include "scribuscore.h"
32 #include "sctextstream.h"
33 #include "ui/scmessagebox.h"
34 #include "units.h"
35 #include "util.h"
36 #include "util_color.h"
37 #include "util_layer.h"
38 #include "util_math.h"
39
40 // See scplugin.h and pluginmanager.{cpp,h} for detail on what these methods
41 // do. That documentatation is not duplicated here.
42 // Please don't implement the functionality of your plugin here; do that
43 // in scribus12formatimpl.h and scribus12formatimpl.cpp .
44
Scribus12Format()45 Scribus12Format::Scribus12Format()
46 {
47 VorlC = -1;
48
49 // Set action info in languageChange, so we only have to do
50 // it in one place. This includes registering file formats.
51 registerFormats();
52 languageChange();
53 }
54
~Scribus12Format()55 Scribus12Format::~Scribus12Format()
56 {
57 unregisterAll();
58 }
59
languageChange()60 void Scribus12Format::languageChange()
61 {
62 FileFormat* fmt = getFormatByID(FORMATID_SLA12XIMPORT);
63 fmt->trName = tr("Scribus 1.2.x Document");
64 fmt->filter = fmt->trName + " (*.sla *.SLA *.sla.gz *.SLA.GZ *.scd *.SCD *.scd.gz *.SCD.GZ)";
65 }
66
fullTrName() const67 QString Scribus12Format::fullTrName() const
68 {
69 return QObject::tr("Scribus 1.2.x Support");
70 }
71
getAboutData() const72 const ScActionPlugin::AboutData* Scribus12Format::getAboutData() const
73 {
74 AboutData* about = new AboutData;
75 Q_CHECK_PTR(about);
76 about->authors = QString::fromUtf8(
77 "Franz Schmid <franz@scribus.info>, "
78 "The Scribus Team");
79 about->shortDescription = tr("Scribus 1.2.x File Format Support");
80 about->description = tr("Allows Scribus to read Scribus 1.2.x formatted files.");
81 // about->version
82 // about->releaseDate
83 // about->copyright
84 about->license = "GPL";
85 return about;
86 }
87
deleteAboutData(const AboutData * about) const88 void Scribus12Format::deleteAboutData(const AboutData* about) const
89 {
90 Q_ASSERT(about);
91 delete about;
92 }
93
94 // Low level plugin API
scribus12format_getPluginAPIVersion()95 int scribus12format_getPluginAPIVersion()
96 {
97 return PLUGIN_API_VERSION;
98 }
99
scribus12format_getPlugin()100 ScPlugin* scribus12format_getPlugin()
101 {
102 Scribus12Format* plug = new Scribus12Format();
103 Q_CHECK_PTR(plug);
104 return plug;
105 }
106
scribus12format_freePlugin(ScPlugin * plugin)107 void scribus12format_freePlugin(ScPlugin* plugin)
108 {
109 Scribus12Format* plug = qobject_cast<Scribus12Format*>(plugin);
110 Q_ASSERT(plug);
111 delete plug;
112 }
113
114
115
registerFormats()116 void Scribus12Format::registerFormats()
117 {
118 FileFormat fmt(this);
119 fmt.trName = tr("Scribus 1.2.x Document");
120 fmt.formatId = FORMATID_SLA12XIMPORT;
121 fmt.load = true;
122 fmt.save = false;
123 fmt.colorReading = true;
124 fmt.filter = fmt.trName + " (*.sla *.SLA *.sla.gz *.SLA.GZ *.scd *.SCD *.scd.gz *.SCD.GZ)";
125 fmt.mimeTypes = QStringList();
126 fmt.mimeTypes.append("application/x-scribus");
127 fmt.fileExtensions = QStringList() << "sla" << "sla.gz" << "scd" << "scd.gz";
128 fmt.priority = 64;
129 fmt.nativeScribus = true;
130 registerFormat(fmt);
131 }
132
fileSupported(QIODevice *,const QString & fileName) const133 bool Scribus12Format::fileSupported(QIODevice* /* file */, const QString & fileName) const
134 {
135 QByteArray docBytes("");
136 if (fileName.right(2) == "gz")
137 {
138 QFile file(fileName);
139 QtIOCompressor compressor(&file);
140 compressor.setStreamFormat(QtIOCompressor::GzipFormat);
141 compressor.open(QIODevice::ReadOnly);
142 docBytes = compressor.read(1024);
143 compressor.close();
144 if (docBytes.isEmpty())
145 return false;
146 }
147 else
148 {
149 // Not gzip encoded, just load it
150 loadRawText(fileName, docBytes);
151 }
152 return docBytes.left(16) != "<SCRIBUSUTF8NEW " && (docBytes.left(12) == "<SCRIBUSUTF8" || docBytes.left(9) == "<SCRIBUS>");
153 }
154
readSLA(const QString & fileName)155 QString Scribus12Format::readSLA(const QString & fileName)
156 {
157 QByteArray docBytes("");
158 if (fileName.right(2) == "gz")
159 {
160 QFile file(fileName);
161 QtIOCompressor compressor(&file);
162 compressor.setStreamFormat(QtIOCompressor::GzipFormat);
163 compressor.open(QIODevice::ReadOnly);
164 docBytes = compressor.readAll();
165 compressor.close();
166 if (docBytes.isEmpty())
167 return QString();
168 }
169 else
170 {
171 // Not gzip encoded, just load it
172 loadRawText(fileName, docBytes);
173 }
174 QString docText("");
175 if (docBytes.left(16) != "<SCRIBUSUTF8NEW ") // Not a 1.3.x doc
176 {
177 if (docBytes.left(12) == "<SCRIBUSUTF8") // 1.2.x UTF8 doc
178 docText = QString::fromUtf8(docBytes);
179 else if (docBytes.left(9) == "<SCRIBUS>") // Older non utf8 doc
180 docText = QString::fromLocal8Bit(docBytes);
181 else
182 return QString();
183 }
184 else
185 {
186 qDebug("scribus12format: SCRIBUSUTF8NEW");
187 return QString();
188 }
189 if (docText.endsWith(QChar(10)) || docText.endsWith(QChar(13)))
190 docText.truncate(docText.length()-1);
191 return docText;
192 }
193
PasteItem(struct CopyPasteBuffer * Buffer,bool drag,bool resize)194 void Scribus12Format::PasteItem(struct CopyPasteBuffer *Buffer, bool drag, bool resize)
195 {
196 QColor tmp;
197 double x = Buffer->Xpos;
198 double y = Buffer->Ypos;
199 double w = Buffer->Width;
200 double h = Buffer->Height;
201 double pw = Buffer->Pwidth;
202 int z = 0;
203 PageItem *currItem = nullptr;
204 switch (Buffer->PType)
205 {
206 // OBSOLETE CR 2005-02-06
207 case PageItem::ItemType1:
208 z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Ellipse, x, y, w, h, pw, Buffer->Pcolor, Buffer->Pcolor2);
209 break;
210 //
211 case PageItem::ImageFrame:
212 z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, x, y, w, h, 1, m_Doc->prefsData().itemToolPrefs.imageFillColor, CommonStrings::None);
213 // undoManager->setUndoEnabled(false);
214 currItem = m_Doc->Items->at(z);
215 currItem->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
216 currItem->setImageXYOffset(Buffer->LocalX, Buffer->LocalY);
217 currItem->setImageRotation(Buffer->LocalRot);
218 currItem->Pfile = Buffer->Pfile;
219 currItem->ImageProfile = Buffer->ImageProfile;
220 currItem->ImageIntent = Buffer->ImageIntent;
221 currItem->EmbeddedProfile = Buffer->EmbeddedProfile;
222 currItem->UseEmbedded = Buffer->UseEmbedded;
223 if (!currItem->Pfile.isEmpty())
224 m_Doc->loadPict(currItem->Pfile, currItem);
225 currItem->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
226 currItem->setImageVisible(Buffer->PicArt);
227 currItem->ScaleType = Buffer->ScaleType;
228 currItem->AspectRatio = Buffer->AspectRatio;
229 currItem->setLineWidth(Buffer->Pwidth);
230 // undoManager->setUndoEnabled(true);
231 break;
232 // OBSOLETE CR 2005-02-06
233 case PageItem::ItemType3:
234 z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, x, y, w, h, pw, Buffer->Pcolor, Buffer->Pcolor2);
235 break;
236 //
237 case PageItem::PathText:
238 case PageItem::TextFrame:
239 if (Buffer->PType == PageItem::PathText)
240 z = m_Doc->itemAdd(PageItem::PathText, PageItem::Unspecified, x, y, w, h, pw, CommonStrings::None, Buffer->Pcolor);
241 else
242 z = m_Doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, x, y, w, h, pw, CommonStrings::None, Buffer->Pcolor);
243 // undoManager->setUndoEnabled(false);
244 currItem = m_Doc->Items->at(z);
245 if ((Buffer->m_isAnnotation) && (Buffer->m_annotation.UseIcons()))
246 {
247 currItem->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
248 currItem->setImageXYOffset(Buffer->LocalX, Buffer->LocalY);
249 currItem->setImageRotation(Buffer->LocalRot);
250 currItem->Pfile = Buffer->Pfile;
251 currItem->Pfile2 = Buffer->Pfile2;
252 currItem->Pfile3 = Buffer->Pfile3;
253 currItem->ImageProfile = Buffer->ImageProfile;
254 currItem->ImageIntent = Buffer->ImageIntent;
255 currItem->EmbeddedProfile = Buffer->EmbeddedProfile;
256 currItem->UseEmbedded = Buffer->UseEmbedded;
257 m_Doc->loadPict(currItem->Pfile, currItem);
258 currItem->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
259 currItem->setImageVisible(Buffer->PicArt);
260 }
261 if (!Buffer->itemText.isEmpty())
262 {
263 QTextStream t(&Buffer->itemText, QIODevice::ReadOnly);
264 QString cc;
265 while (!t.atEnd())
266 {
267 cc = t.readLine();
268 if (cc.isEmpty())
269 continue;
270 QStringList wt;
271 QStringList::Iterator it;
272 wt = cc.split("\t", Qt::SkipEmptyParts);
273 it = wt.begin();
274 CharStyle nstyle;
275 QString ch = (*it);
276 if (ch == QChar(5))
277 ch = SpecialChars::PARSEP;
278 if (ch == QChar(4))
279 ch = SpecialChars::TAB;
280 it++;
281 nstyle.setFont((*m_Doc->AllFonts)[*it]);
282 it++;
283 nstyle.setFontSize(qRound(ScCLocale::toDoubleC((*it)) * 10));
284 it++;
285 nstyle.setFillColor(*it);
286 it++;
287 nstyle.setTracking((*it).toInt());
288 it++;
289 nstyle.setFillShade((*it).toInt());
290 it++;
291 nstyle.setFeatures(static_cast<StyleFlag>(it == wt.end() ? 0 : (*it).toInt()).featureList());
292 it++;
293 int cab = it == wt.end() ? 0 : (*it).toInt();
294 it++;
295 nstyle.setStrokeColor(it == wt.end() ? CommonStrings::None : *it);
296 it++;
297 nstyle.setStrokeShade(it == wt.end() ? 100 : (*it).toInt());
298 it++;
299 if (it == wt.end())
300 nstyle.setScaleH(1000);
301 else
302 nstyle.setScaleH(qMin(qMax((*it).toInt(), 100), 4000));
303 it++;
304 if (it == wt.end())
305 nstyle.setScaleV(1000);
306 else
307 nstyle.setScaleV(qMin(qMax((*it).toInt(), 100), 4000));
308 it++;
309 nstyle.setBaselineOffset(it == wt.end() ? 0 : (*it).toInt());
310 it++;
311 nstyle.setShadowXOffset(it == wt.end() ? 50 : (*it).toInt());
312 it++;
313 nstyle.setShadowYOffset(it == wt.end() ? -50 : (*it).toInt());
314 it++;
315 nstyle.setOutlineWidth(it == wt.end() ? 10 : (*it).toInt());
316 it++;
317 nstyle.setUnderlineOffset(it == wt.end() ? -1 : (*it).toInt());
318 it++;
319 nstyle.setUnderlineWidth(it == wt.end() ? -1 : (*it).toInt());
320 it++;
321 nstyle.setStrikethruOffset(it == wt.end() ? -1 : (*it).toInt());
322 it++;
323 nstyle.setStrikethruWidth(it == wt.end() ? -1 : (*it).toInt());
324 uint pos = currItem->itemText.length();
325 currItem->itemText.insertChars(pos, ch);
326 if (ch == SpecialChars::PARSEP && cab > 0) {
327 ParagraphStyle pstyle;
328 pstyle.setParent(m_Doc->paragraphStyles()[cab].name());
329 currItem->itemText.applyStyle(pos, pstyle);
330 }
331 else {
332 currItem->itemText.applyCharStyle(pos, 1, nstyle);
333 }
334 }
335 }
336 {
337 ParagraphStyle pstyle;
338 pstyle.setAlignment(static_cast<ParagraphStyle::AlignmentType>(Buffer->textAlignment));
339 if (Buffer->Reverse)
340 pstyle.setDirection(ParagraphStyle::RTL);
341 pstyle.setLineSpacing(Buffer->LineSp);
342 pstyle.setLineSpacingMode(static_cast<ParagraphStyle::LineSpacingMode>(Buffer->LineSpMode));
343 if (m_Doc->AllFonts->contains(Buffer->IFont))
344 pstyle.charStyle().setFont((*m_Doc->AllFonts)[Buffer->IFont]);
345 else
346 pstyle.charStyle().setFont((*m_Doc->AllFonts)[m_Doc->prefsData().itemToolPrefs.textFont]);
347 pstyle.charStyle().setFontSize(Buffer->ISize);
348 pstyle.charStyle().setFillColor(Buffer->TxtFill);
349 pstyle.charStyle().setStrokeColor(Buffer->TxtStroke);
350 pstyle.charStyle().setFillShade(Buffer->ShTxtFill);
351 pstyle.charStyle().setStrokeShade(Buffer->ShTxtStroke);
352 pstyle.charStyle().setScaleH(Buffer->TxtScale);
353 pstyle.charStyle().setScaleV(Buffer->TxtScaleV);
354 pstyle.charStyle().setBaselineOffset(Buffer->TxTBase);
355 pstyle.charStyle().setFeatures(StyleFlag(Buffer->TxTStyle).featureList());
356 pstyle.charStyle().setShadowXOffset(Buffer->TxtShadowX);
357 pstyle.charStyle().setShadowYOffset(Buffer->TxtShadowY);
358 pstyle.charStyle().setOutlineWidth(Buffer->TxtOutline);
359 pstyle.charStyle().setUnderlineOffset(Buffer->TxtUnderPos);
360 pstyle.charStyle().setUnderlineWidth(Buffer->TxtUnderWidth);
361 pstyle.charStyle().setStrikethruOffset(Buffer->TxtStrikePos);
362 pstyle.charStyle().setStrikethruWidth(Buffer->TxtStrikeWidth);
363 currItem->itemText.setDefaultStyle(pstyle);
364 }
365 // undoManager->setUndoEnabled(true);
366 break;
367 case PageItem::Line:
368 z = m_Doc->itemAdd(PageItem::Line, PageItem::Unspecified, x, y, w ,0, pw, CommonStrings::None, Buffer->Pcolor2);
369 break;
370 case PageItem::Polygon:
371 z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, x, y, w, h, pw, Buffer->Pcolor, Buffer->Pcolor2);
372 break;
373 case PageItem::PolyLine:
374 z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, x, y, w, h, pw, Buffer->Pcolor, Buffer->Pcolor2);
375 break;
376 case PageItem::Symbol:
377 z = m_Doc->itemAdd(PageItem::Symbol, PageItem::Unspecified, x, y, w, h, 0, CommonStrings::None, CommonStrings::None);
378 m_Doc->Items->at(z)->setPattern(Buffer->pattern);
379 break;
380 case PageItem::Group:
381 z = m_Doc->itemAdd(PageItem::Group, PageItem::Unspecified, x, y, w, h, 0, CommonStrings::None, CommonStrings::None);
382 m_Doc->Items->at(z)->groupWidth = Buffer->groupWidth;
383 m_Doc->Items->at(z)->groupHeight = Buffer->groupHeight;
384 break;
385 case PageItem::Multiple:
386 case PageItem::RegularPolygon:
387 case PageItem::Arc:
388 case PageItem::Spiral:
389 case PageItem::Table:
390 case PageItem::NoteFrame:
391 Q_ASSERT(false);
392 break;
393 case PageItem::LatexFrame:
394 {
395 z = m_Doc->itemAdd(PageItem::LatexFrame, PageItem::Unspecified, x, y, w, h, 1, m_Doc->prefsData().itemToolPrefs.imageFillColor, CommonStrings::None);
396 // undoManager->setUndoEnabled(false);
397 currItem = m_Doc->Items->at(z);
398 currItem->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
399 currItem->setImageXYOffset(Buffer->LocalX, Buffer->LocalY);
400 currItem->setImageRotation(Buffer->LocalRot);
401 currItem->Pfile = Buffer->Pfile;
402 currItem->ImageProfile = Buffer->ImageProfile;
403 currItem->ImageIntent = Buffer->ImageIntent;
404 currItem->EmbeddedProfile = Buffer->EmbeddedProfile;
405 currItem->UseEmbedded = Buffer->UseEmbedded;
406 if (!currItem->Pfile.isEmpty())
407 m_Doc->loadPict(currItem->Pfile, currItem);
408 currItem->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
409 currItem->setImageVisible(Buffer->PicArt);
410 currItem->ScaleType = Buffer->ScaleType;
411 currItem->AspectRatio = Buffer->AspectRatio;
412 currItem->setLineWidth(Buffer->Pwidth);
413 PageItem_LatexFrame *latexframe = currItem->asLatexFrame();
414 latexframe->setFormula(Buffer->itemText); //itemText seems to be a good choice...
415 // undoManager->setUndoEnabled(true);
416 break;
417 }
418 case PageItem::OSGFrame:
419 #ifdef HAVE_OSG
420 z = m_Doc->itemAdd(PageItem::OSGFrame, PageItem::Unspecified, x, y, w, h, 1, m_Doc->prefsData().itemToolPrefs.imageFillColor, CommonStrings::None);
421 // undoManager->setUndoEnabled(false);
422 currItem = m_Doc->Items->at(z);
423 currItem->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
424 currItem->setImageXYOffset(Buffer->LocalX, Buffer->LocalY);
425 currItem->setImageRotation(Buffer->LocalRot);
426 currItem->Pfile = Buffer->Pfile;
427 currItem->ImageProfile = Buffer->ImageProfile;
428 currItem->ImageIntent = Buffer->ImageIntent;
429 currItem->EmbeddedProfile = Buffer->EmbeddedProfile;
430 currItem->UseEmbedded = Buffer->UseEmbedded;
431 if (!currItem->Pfile.isEmpty())
432 m_Doc->loadPict(currItem->Pfile, currItem);
433 currItem->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
434 currItem->setImageVisible(Buffer->PicArt);
435 currItem->ScaleType = Buffer->ScaleType;
436 currItem->AspectRatio = Buffer->AspectRatio;
437 currItem->setLineWidth(Buffer->Pwidth);
438 // undoManager->setUndoEnabled(true);
439 #endif
440 break;
441 }
442 currItem = m_Doc->Items->at(z);
443 // undoManager->setUndoEnabled(false);
444 /*FIXME
445 currItem->setLineSpacingMode(Buffer->LineSpMode);
446 if (currItem->lineSpacingMode() == 3)
447 {
448 currItem->setLineSpacing(Doc->typographicSettings.valueBaseGrid-1);
449 }
450 */
451 currItem->setImageFlippedH(Buffer->flippedH);
452 currItem->setImageFlippedV(Buffer->flippedV);
453 currItem->setCornerRadius(Buffer->RadRect);
454 currItem->FrameType = Buffer->FrameType;
455 currItem->ClipEdited = Buffer->ClipEdited;
456 currItem->setFillColor(Buffer->Pcolor);
457 currItem->setLineColor(Buffer->Pcolor2);
458 currItem->setFillShade(Buffer->Shade);
459 currItem->setLineShade(Buffer->Shade2);
460 currItem->fillRule = Buffer->FillRule;
461 currItem->setRotation(Buffer->Rot);
462 currItem->oldRot = currItem->rotation();
463 currItem->setTextToFrameDist(Buffer->Extra, Buffer->RExtra, Buffer->TExtra, Buffer->BExtra);
464 currItem->PLineArt = Qt::PenStyle(Buffer->PLineArt);
465 currItem->PLineEnd = Qt::PenCapStyle(Buffer->PLineEnd);
466 currItem->PLineJoin = Qt::PenJoinStyle(Buffer->PLineJoin);
467 currItem->setPrintEnabled(Buffer->isPrintable);
468 currItem->isBookmark = Buffer->isBookmark;
469 currItem->setIsAnnotation(Buffer->m_isAnnotation);
470 currItem->setAnnotation(Buffer->m_annotation);
471 if (!Buffer->itemName.isEmpty())
472 {
473 if (!drag)
474 {
475 if (currItem->itemName() == Buffer->itemName)
476 currItem->AutoName = true;
477 else
478 {
479 currItem->setItemName(Buffer->itemName);
480 currItem->AutoName = false;
481 }
482 }
483 else
484 {
485 currItem->setItemName(Buffer->itemName);
486 currItem->AutoName = false;
487 }
488 }
489 else
490 {
491 if (currItem->isGroup())
492 currItem->setItemName( tr("Group%1").arg(m_Doc->GroupCounter));
493 }
494
495 currItem->TopLine = Buffer->TopLine;
496 currItem->RightLine = Buffer->RightLine;
497 currItem->LeftLine = Buffer->LeftLine;
498 currItem->BottomLine = Buffer->BottomLine;
499 currItem->isTableItem = Buffer->isTableItem;
500 currItem->TopLinkID = Buffer->TopLinkID;
501 currItem->LeftLinkID = Buffer->LeftLinkID;
502 currItem->RightLinkID = Buffer->RightLinkID;
503 currItem->BottomLinkID = Buffer->BottomLinkID;
504 currItem->Clip = Buffer->Clip; //irrelevant, overwritten below
505 currItem->PoShow = Buffer->PoShow;
506 currItem->BaseOffs = Buffer->BaseOffs;
507 currItem->textPathFlipped = Buffer->textPathFlipped;
508 currItem->textPathType = Buffer->textPathType;
509 currItem->setTextFlowMode((PageItem::TextFlowMode) Buffer->TextflowMode);
510 currItem->DashValues = Buffer->DashValues;
511 currItem->DashOffset = Buffer->DashOffset;
512 currItem->setLocked(Buffer->Locked);
513 currItem->setSizeLocked(Buffer->LockRes);
514 currItem->setFillTransparency(Buffer->Transparency);
515 currItem->setLineTransparency(Buffer->TranspStroke);
516 currItem->setFillBlendmode(Buffer->TransBlend);
517 currItem->setLineBlendmode(Buffer->TransBlendS);
518 currItem->setStartArrowIndex(Buffer->startArrowIndex);
519 currItem->setEndArrowIndex(Buffer->endArrowIndex);
520 currItem->setStartArrowScale(Buffer->startArrowScale);
521 currItem->setEndArrowScale(Buffer->endArrowScale);
522 currItem->NamedLStyle = Buffer->NamedLStyle;
523 currItem->m_columns = Buffer->Cols;
524 currItem->m_columnGap = Buffer->ColGap;
525 currItem->setFirstLineOffset(Buffer->firstLineOffsetP);
526 if (Buffer->LayerID != -1)
527 currItem->setLayer(Buffer->LayerID);
528 currItem->PoLine = Buffer->PoLine.copy();
529 currItem->setTextFlowMode((PageItem::TextFlowMode) Buffer->TextflowMode);
530 if (Buffer->ContourLine.empty())
531 currItem->ContourLine = currItem->PoLine.copy();
532 else
533 currItem->ContourLine = Buffer->ContourLine.copy();
534 if (!currItem->asLine())
535 {
536 // OBSOLETE CR 2005-02-06
537 if ((currItem->PoLine.empty()) && (currItem->itemType() != PageItem::ItemType1))
538 currItem->convertClip();
539 else
540 //
541 currItem->Clip = flattenPath(currItem->PoLine, currItem->Segments);
542 }
543 else
544 {
545 currItem->Segments.clear();
546 currItem->PoLine.resize(0);
547 currItem->setHeight(1.0);
548 currItem->asLine()->setLineClip();
549 }
550 // OBSOLETE CR 2005-02-06
551 if (currItem->itemType() == PageItem::ItemType1)
552 {
553 currItem->SetOvalFrame();
554 m_Doc->setRedrawBounding(currItem);
555 }
556 // OBSOLETE CR 2005-02-06
557 if (currItem->itemType() == PageItem::ItemType3)
558 {
559 if (currItem->cornerRadius() != 0.0)
560 {
561 currItem->SetFrameRound();
562 m_Doc->setRedrawBounding(currItem);
563 }
564 else
565 {
566 currItem->SetRectFrame();
567 m_Doc->setRedrawBounding(currItem);
568 }
569 currItem->ClipEdited = true;
570 }
571 if (currItem->isImageFrame())
572 currItem->adjustPictScale();
573 if (currItem->isPathText())
574 {
575 currItem->ClipEdited = true;
576 currItem->FrameType = 3;
577 currItem->updatePolyClip();
578 }
579 if (Buffer->GrType != 0)
580 {
581 currItem->GrType = Buffer->GrType;
582 if (Buffer->GrType == Gradient_Pattern)
583 {
584 currItem->setPattern(Buffer->pattern);
585 currItem->setPatternTransform(Buffer->patternScaleX, Buffer->patternScaleY, Buffer->patternOffsetX, Buffer->patternOffsetY, Buffer->patternRotation, Buffer->patternSkewX, Buffer->patternSkewY);
586 currItem->setPatternFlip(Buffer->patternMirrorX, Buffer->patternMirrorY);
587 }
588 else if (Buffer->GrType == Gradient_Mesh)
589 {
590 currItem->meshGradientArray = Buffer->meshGradientArray;
591 }
592 else
593 {
594 if ((!Buffer->GrColor.isEmpty()) && (!Buffer->GrColor2.isEmpty()))
595 {
596 currItem->fill_gradient.clearStops();
597 if (Buffer->GrType == Gradient_RadialLegacy5)
598 {
599 if ((Buffer->GrColor != CommonStrings::None) && (!Buffer->GrColor.isEmpty()))
600 currItem->SetQColor(&tmp, Buffer->GrColor, Buffer->GrShade);
601 currItem->fill_gradient.addStop(tmp, 0.0, 0.5, 1.0, Buffer->GrColor, Buffer->GrShade);
602 if ((Buffer->GrColor2 != CommonStrings::None) && (!Buffer->GrColor2.isEmpty()))
603 currItem->SetQColor(&tmp, Buffer->GrColor2, Buffer->GrShade2);
604 currItem->fill_gradient.addStop(tmp, 1.0, 0.5, 1.0, Buffer->GrColor2, Buffer->GrShade2);
605 }
606 else
607 {
608 if ((Buffer->GrColor2 != CommonStrings::None) && (!Buffer->GrColor2.isEmpty()))
609 currItem->SetQColor(&tmp, Buffer->GrColor2, Buffer->GrShade2);
610 currItem->fill_gradient.addStop(tmp, 0.0, 0.5, 1.0, Buffer->GrColor2, Buffer->GrShade2);
611 if ((Buffer->GrColor != CommonStrings::None) && (!Buffer->GrColor.isEmpty()))
612 currItem->SetQColor(&tmp, Buffer->GrColor, Buffer->GrShade);
613 currItem->fill_gradient.addStop(tmp, 1.0, 0.5, 1.0, Buffer->GrColor, Buffer->GrShade);
614 }
615 }
616 else
617 currItem->fill_gradient = Buffer->fill_gradient;
618 currItem->GrStartX = Buffer->GrStartX;
619 currItem->GrStartY = Buffer->GrStartY;
620 currItem->GrEndX = Buffer->GrEndX;
621 currItem->GrEndY = Buffer->GrEndY;
622 currItem->GrFocalX = Buffer->GrFocalX;
623 currItem->GrFocalY = Buffer->GrFocalY;
624 currItem->GrScale = Buffer->GrScale;
625 currItem->GrSkew = Buffer->GrSkew;
626 currItem->GrControl1 = Buffer->GrControl1;
627 currItem->GrControl2 = Buffer->GrControl2;
628 currItem->GrControl3 = Buffer->GrControl3;
629 currItem->GrControl4 = Buffer->GrControl4;
630 currItem->GrControl5 = Buffer->GrControl5;
631 currItem->GrColorP1 = Buffer->GrColorP1;
632 currItem->GrColorP2 = Buffer->GrColorP2;
633 currItem->GrColorP3 = Buffer->GrColorP3;
634 currItem->GrColorP4 = Buffer->GrColorP4;
635 currItem->GrCol1transp = Buffer->GrCol1transp;
636 currItem->GrCol2transp = Buffer->GrCol2transp;
637 currItem->GrCol3transp = Buffer->GrCol3transp;
638 currItem->GrCol4transp = Buffer->GrCol4transp;
639 currItem->GrCol1Shade = Buffer->GrCol1Shade;
640 currItem->GrCol2Shade = Buffer->GrCol2Shade;
641 currItem->GrCol3Shade = Buffer->GrCol3Shade;
642 currItem->GrCol4Shade = Buffer->GrCol4Shade;
643 currItem->set4ColorColors(currItem->GrColorP1, currItem->GrColorP2, currItem->GrColorP3, currItem->GrColorP4);
644 }
645 switch (currItem->GrType)
646 {
647 case Gradient_LinearLegacy1:
648 case Gradient_LinearLegacy2:
649 case Gradient_LinearLegacy3:
650 case Gradient_LinearLegacy4:
651 currItem->GrType = Gradient_Linear;
652 break;
653 case Gradient_RadialLegacy5:
654 currItem->GrType = Gradient_Radial;
655 break;
656 default:
657 break;
658 }
659 }
660 if (Buffer->GrTypeStroke > 0)
661 {
662 currItem->stroke_gradient = Buffer->stroke_gradient;
663 currItem->GrTypeStroke = Buffer->GrTypeStroke;
664 currItem->GrStrokeStartX = Buffer->GrStrokeStartX;
665 currItem->GrStrokeStartY = Buffer->GrStrokeStartY;
666 currItem->GrStrokeEndX = Buffer->GrStrokeEndX;
667 currItem->GrStrokeEndY = Buffer->GrStrokeEndY;
668 currItem->GrStrokeFocalX = Buffer->GrStrokeFocalX;
669 currItem->GrStrokeFocalY = Buffer->GrStrokeFocalY;
670 currItem->GrStrokeScale = Buffer->GrStrokeScale;
671 currItem->GrStrokeSkew = Buffer->GrStrokeSkew;
672 }
673 currItem->GrMask = Buffer->GrMask;
674 if ((currItem->GrMask == GradMask_Linear) || (currItem->GrMask == GradMask_Radial) || (currItem->GrMask == GradMask_LinearLumAlpha) || (currItem->GrMask == GradMask_RadialLumAlpha))
675 {
676 currItem->mask_gradient = Buffer->mask_gradient;
677 currItem->GrMaskStartX = Buffer->GrMaskStartX;
678 currItem->GrMaskStartY = Buffer->GrMaskStartY;
679 currItem->GrMaskEndX = Buffer->GrMaskEndX;
680 currItem->GrMaskEndY = Buffer->GrMaskEndY;
681 currItem->GrMaskFocalX = Buffer->GrMaskFocalX;
682 currItem->GrMaskFocalY = Buffer->GrMaskFocalY;
683 currItem->GrMaskScale = Buffer->GrMaskScale;
684 currItem->GrMaskSkew = Buffer->GrMaskSkew;
685 }
686 else if ((currItem->GrMask == GradMask_Pattern) || (currItem->GrMask == GradMask_PatternLumAlpha))
687 {
688 currItem->setPatternMask(Buffer->patternMaskVal);
689 currItem->setMaskTransform(Buffer->patternMaskScaleX, Buffer->patternMaskScaleY, Buffer->patternMaskOffsetX, Buffer->patternMaskOffsetY, Buffer->patternMaskRotation, Buffer->patternMaskSkewX, Buffer->patternMaskSkewY);
690 currItem->setMaskFlip(Buffer->patternMaskMirrorX, Buffer->patternMaskMirrorY);
691 }
692 currItem->updateGradientVectors();
693 currItem->setObjectAttributes(&(Buffer->pageItemAttributes));
694 if (resize)
695 m_Doc->setRedrawBounding(currItem);
696 currItem->setOwnerPage(m_Doc->OnPage(currItem));
697 // undoManager->setUndoEnabled(true);
698 }
699
700
getReplacedFontData(bool & getNewReplacement,QMap<QString,QString> & getReplacedFonts,QList<ScFace> & getDummyScFaces)701 void Scribus12Format::getReplacedFontData(bool& getNewReplacement, QMap<QString,QString> &getReplacedFonts, QList<ScFace> &getDummyScFaces)
702 {
703 getNewReplacement=false;
704 getReplacedFonts.clear();
705 getDummyScFaces.clear();
706 }
707
scribus12itemID(int itemNr,int pageNr)708 static long long scribus12itemID(int itemNr, int pageNr)
709 {
710 return 100000 * ((long long) itemNr) + pageNr;
711 }
712
loadFile(const QString & fileName,const FileFormat &,int,int)713 bool Scribus12Format::loadFile(const QString& fileName, const FileFormat & /* fmt */, int /* flags */, int /* index */)
714 {
715 if (m_Doc==nullptr || m_View==nullptr || m_AvailableFonts==nullptr)
716 {
717 Q_ASSERT(m_Doc==nullptr || m_View==nullptr || m_AvailableFonts==nullptr);
718 return false;
719 }
720 // ReplacedFonts.clear();
721 // newReplacement = false;
722 // dummyScFaces.clear();
723 DoVorl.clear();
724 DoVorl[0] = "";
725 DoVorl[1] = "";
726 DoVorl[2] = "";
727 DoVorl[3] = "";
728 DoVorl[4] = "";
729 VorlC = 5;
730
731 //start old ReadDoc
732 //Scribus 1.2 docs, see fileloader.cpp for 1.3 docs
733 struct CopyPasteBuffer OB;
734 ParagraphStyle vg;
735 struct ScribusDoc::BookMa bok;
736 int counter;
737 bool newVersion = false;
738 QString tmp, tmpf, pageName, Defont;
739 QMap<int,int> TableID;
740 QList<PageItem*> TableItems;
741 int x, a;
742 PageItem *newItem;
743 groupRemap.clear();
744 itemRemap.clear();
745 itemNext.clear();
746 QDomDocument docu("scridoc");
747 QFile fi(fileName);
748 // Load the document text
749 QString f(readSLA(fileName));
750 if (f.isEmpty())
751 {
752 setFileReadError();
753 return false;
754 }
755 // Build the DOM from it
756 QString errorMsg;
757 int errorLine, errorColumn;
758 if (!docu.setContent(f, &errorMsg, &errorLine, &errorColumn))
759 {
760 setDomParsingError(errorMsg, errorLine, errorColumn);
761 return false;
762 }
763 // Get file directory
764 QString fileDir = QFileInfo(fileName).absolutePath();
765 // and begin loading the doc
766 m_Doc->PageColors.clear();
767 m_Doc->Layers.clear();
768 ScColor lf = ScColor();
769 QDomElement elem=docu.documentElement();
770 if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
771 return false;
772 if (elem.hasAttribute("Version"))
773 newVersion = true;
774 QDomNode docNode = elem.firstChild();
775 if (m_mwProgressBar!=nullptr)
776 {
777 m_mwProgressBar->setMaximum(docNode.childNodes().count());
778 m_mwProgressBar->setValue(0);
779 }
780 int ObCount = 0;
781 int activeLayer = 0;
782 PrefsManager& prefsManager = PrefsManager::instance();
783 while (!docNode.isNull())
784 {
785 QDomElement dc = docNode.toElement();
786 /*
787 * Attribute von DOCUMENT auslesen
788 */
789 if (dc.hasAttribute("PAGEWIDTH"))
790 m_Doc->setPageWidth(ScCLocale::toDoubleC(dc.attribute("PAGEWIDTH")));
791 else
792 m_Doc->setPageWidth(ScCLocale::toDoubleC(dc.attribute("PAGEWITH")));
793 m_Doc->setPageHeight(ScCLocale::toDoubleC(dc.attribute("PAGEHEIGHT")));
794 m_Doc->margins()->setLeft(qMax(0.0, ScCLocale::toDoubleC(dc.attribute("BORDERLEFT"))));
795 m_Doc->margins()->setRight(qMax(0.0, ScCLocale::toDoubleC(dc.attribute("BORDERRIGHT"))));
796 m_Doc->margins()->setTop(qMax(0.0, ScCLocale::toDoubleC(dc.attribute("BORDERTOP"))));
797 m_Doc->margins()->setBottom(qMax(0.0, ScCLocale::toDoubleC(dc.attribute("BORDERBOTTOM"))));
798 m_Doc->setMarginPreset(dc.attribute("PRESET", "0").toInt());
799 m_Doc->setPageOrientation(dc.attribute("ORIENTATION", "0").toInt());
800 m_Doc->setPageSize(dc.attribute("PAGESIZE"));
801 m_Doc->FirstPnum = dc.attribute("FIRSTNUM", "1").toInt();
802 m_Doc->setPagePositioning(dc.attribute("BOOK", "0").toInt());
803 int fp;
804 if (dc.attribute("FIRSTLEFT", "0").toInt() == 1)
805 fp = 0;
806 else
807 fp = 1;
808 if (m_Doc->pagePositioning() == 0)
809 fp = 0;
810 m_Doc->setPageSetFirstPage(m_Doc->pagePositioning(), fp);
811 m_Doc->setUsesAutomaticTextFrames(dc.attribute("AUTOTEXT").toInt());
812 m_Doc->PageSp=dc.attribute("AUTOSPALTEN").toInt();
813 m_Doc->PageSpa=ScCLocale::toDoubleC(dc.attribute("ABSTSPALTEN"));
814 m_Doc->setUnitIndex(dc.attribute("UNITS", "0").toInt());
815 m_Doc->guidesPrefs().gridShown = prefsManager.appPrefs.guidesPrefs.gridShown;
816 m_Doc->guidesPrefs().guidesShown = prefsManager.appPrefs.guidesPrefs.guidesShown;
817 m_Doc->guidesPrefs().colBordersShown = prefsManager.appPrefs.guidesPrefs.colBordersShown;
818 m_Doc->guidesPrefs().framesShown = prefsManager.appPrefs.guidesPrefs.framesShown;
819 m_Doc->guidesPrefs().layerMarkersShown = prefsManager.appPrefs.guidesPrefs.layerMarkersShown;
820 m_Doc->guidesPrefs().marginsShown = prefsManager.appPrefs.guidesPrefs.marginsShown;
821 m_Doc->guidesPrefs().baselineGridShown = prefsManager.appPrefs.guidesPrefs.baselineGridShown;
822 m_Doc->guidesPrefs().linkShown = prefsManager.appPrefs.guidesPrefs.linkShown;
823 m_Doc->guidesPrefs().showPic = true;
824 m_Doc->guidesPrefs().showControls = false;
825 m_Doc->guidesPrefs().renderStackOrder.clear();
826 m_Doc->guidesPrefs().renderStackOrder << 0 << 1 << 2 << 3 << 4;
827 m_Doc->guidesPrefs().gridType = 0;
828 // DoFonts.clear();
829 m_Doc->itemToolPrefs().textSize=qRound(ScCLocale::toDoubleC(dc.attribute("DSIZE")) * 10);
830 Defont = dc.attribute("DFONT");
831 m_Doc->itemToolPrefs().textFont = prefsManager.appPrefs.itemToolPrefs.textFont;
832 m_AvailableFonts->findFont(Defont, m_Doc);
833 m_Doc->itemToolPrefs().textFont = Defont;
834 m_Doc->itemToolPrefs().textColumns = dc.attribute("DCOL", "1").toInt();
835 m_Doc->itemToolPrefs().textColumnGap = ScCLocale::toDoubleC(dc.attribute("DGAP"), 0.0);
836 DocumentInformation di;
837 di.setAuthor(dc.attribute("AUTHOR"));
838 di.setComments(dc.attribute("COMMENTS"));
839 di.setKeywords(dc.attribute("KEYWORDS",""));
840 di.setTitle(dc.attribute("TITLE"));
841 di.setPublisher(dc.attribute("PUBLISHER", ""));
842 di.setDate(dc.attribute("DOCDATE", ""));
843 di.setType(dc.attribute("DOCTYPE", ""));
844 di.setFormat(dc.attribute("DOCFORMAT", ""));
845 di.setIdent(dc.attribute("DOCIDENT", ""));
846 di.setSource(dc.attribute("DOCSOURCE", ""));
847 di.setLangInfo(dc.attribute("DOCLANGINFO", ""));
848 di.setRelation(dc.attribute("DOCRELATION", ""));
849 di.setCover(dc.attribute("DOCCOVER", ""));
850 di.setRights(dc.attribute("DOCRIGHTS", ""));
851 di.setContrib(dc.attribute("DOCCONTRIB", ""));
852 m_Doc->setDocumentInfo(di);
853 m_Doc->typographicPrefs().valueSuperScript = dc.attribute("VHOCH").toInt();
854 m_Doc->typographicPrefs().scalingSuperScript = dc.attribute("VHOCHSC").toInt();
855 m_Doc->typographicPrefs().valueSubScript = dc.attribute("VTIEF").toInt();
856 m_Doc->typographicPrefs().scalingSubScript = dc.attribute("VTIEFSC").toInt();
857 m_Doc->typographicPrefs().valueSmallCaps = dc.attribute("VKAPIT").toInt();
858 m_Doc->guidesPrefs().valueBaselineGrid = ScCLocale::toDoubleC(dc.attribute("BASEGRID"), 12.0);
859 m_Doc->guidesPrefs().offsetBaselineGrid = ScCLocale::toDoubleC(dc.attribute("BASEO"), 0.0);
860 // #9621 : autolinespacing is now express as a percentage of the font height
861 m_Doc->typographicPrefs().autoLineSpacing = 100 /*dc.attribute("AUTOL", "20").toInt()*/;
862 m_Doc->GroupCounter = 1 /*dc.attribute("GROUPC", "1").toInt()*/;
863 //m_Doc->HasCMS = static_cast<bool>(dc.attribute("HCMS", "0").toInt());
864 m_Doc->cmsSettings().SoftProofOn = static_cast<bool>(dc.attribute("DPSo", "0").toInt());
865 m_Doc->cmsSettings().SoftProofFullOn = static_cast<bool>(dc.attribute("DPSFo", "0").toInt());
866 m_Doc->cmsSettings().CMSinUse = static_cast<bool>(dc.attribute("DPuse", "0").toInt());
867 m_Doc->cmsSettings().GamutCheck = static_cast<bool>(dc.attribute("DPgam", "0").toInt());
868 m_Doc->cmsSettings().BlackPoint = static_cast<bool>(dc.attribute("DPbla", "1").toInt());
869 m_Doc->cmsSettings().DefaultMonitorProfile = prefsManager.appPrefs.colorPrefs.DCMSset.DefaultMonitorProfile;
870 m_Doc->cmsSettings().DefaultPrinterProfile = dc.attribute("DPPr","");
871 m_Doc->cmsSettings().DefaultImageRGBProfile = dc.attribute("DPIn","");
872 m_Doc->cmsSettings().DefaultImageCMYKProfile = dc.attribute("DPPr",""); // Use DPPr to match 1.2.x behavior
873 m_Doc->cmsSettings().DefaultSolidColorRGBProfile = dc.attribute("DPIn2","");
874 m_Doc->cmsSettings().DefaultSolidColorCMYKProfile = dc.attribute("DPPr",""); // Use DPPr to match 1.2.x behavior
875 //m_Doc->CMSSettings.DefaultIntentPrinter = dc.attribute("DIPr", "0").toInt();
876 //m_Doc->CMSSettings.DefaultIntentMonitor = dc.attribute("DIMo", "1").toInt();
877 m_Doc->cmsSettings().DefaultIntentColors = (eRenderIntent) dc.attribute("DISc", "1").toInt();
878 m_Doc->cmsSettings().DefaultIntentImages = (eRenderIntent) dc.attribute("DIIm", "0").toInt();
879 activeLayer = dc.attribute("ALAYER", "0").toInt();
880 //m_Doc->setHyphLanguage(dc.attribute("LANGUAGE", ""));
881 static const QString LANGUAGE("LANGUAGE");
882 QString l(dc.attribute(LANGUAGE, "en"));
883 if (LanguageManager::instance()->langTableIndex(l) != -1)
884 m_Doc->setLanguage(l); //new style storage
885 else
886 { //old style storage
887 QString lnew = LanguageManager::instance()->getAbbrevFromLang(l, false);
888 if (lnew.isEmpty())
889 lnew = LanguageManager::instance()->getAbbrevFromLang(l, false);
890 m_Doc->setLanguage(lnew);
891 }
892 // m_Doc->setHyphMinimumWordLength(dc.attribute("MINWORDLEN", "3").toInt());
893 // m_Doc->setHyphConsecutiveLines(dc.attribute("HYCOUNT", "2").toInt());
894 m_Doc->setHyphAutomatic(static_cast<bool>(dc.attribute("AUTOMATIC", "1").toInt()));
895 m_Doc->setHyphAutoCheck(static_cast<bool>(dc.attribute("AUTOCHECK", "0").toInt()));
896 m_Doc->GuideLock = static_cast<bool>(dc.attribute("GUIDELOCK", "0").toInt());
897 m_Doc->SnapGuides = static_cast<bool>(dc.attribute("SnapToGuides", "0").toInt());
898 m_Doc->SnapGrid = static_cast<bool>(dc.attribute("SnapToGrid", "0").toInt());
899 m_Doc->guidesPrefs().minorGridSpacing = ScCLocale::toDoubleC(dc.attribute("MINGRID"), prefsManager.appPrefs.guidesPrefs.minorGridSpacing);
900 m_Doc->guidesPrefs().majorGridSpacing = ScCLocale::toDoubleC(dc.attribute("MAJGRID"), prefsManager.appPrefs.guidesPrefs.majorGridSpacing);
901 m_Doc->itemToolPrefs().lineStartArrow = 0;
902 m_Doc->itemToolPrefs().lineEndArrow = 0;
903 m_Doc->LastAuto = nullptr;
904 QDomNode pageNode = docNode.firstChild();
905 counter = 0;
906 while (!pageNode.isNull())
907 {
908 ObCount++;
909 if (m_mwProgressBar!=nullptr)
910 m_mwProgressBar->setValue(ObCount);
911 QDomElement pg = pageNode.toElement();
912 // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
913 if (pg.tagName() == "COLOR" && pg.attribute("NAME") != CommonStrings::None)
914 {
915 if (pg.hasAttribute("CMYK"))
916 lf.setNamedColor(pg.attribute("CMYK"));
917 else
918 lf.fromQColor(QColor(pg.attribute("RGB")));
919 lf.setSpotColor(false);
920 lf.setRegistrationColor(false);
921 m_Doc->PageColors.insert(pg.attribute("NAME"), lf);
922 }
923 if (pg.tagName() == "STYLE")
924 {
925 vg.erase();
926 GetStyle(&pg, &vg, nullptr, m_Doc, true);
927 StyleSet<ParagraphStyle> temp;
928 temp.create(vg);
929 m_Doc->redefineStyles(temp, false);
930 }
931 if (pg.tagName() == "JAVA")
932 m_Doc->JavaScripts[pg.attribute("NAME")] = pg.attribute("SCRIPT");
933 if (pg.tagName() == "LAYERS")
934 {
935 int lId = pg.attribute("NUMMER").toInt();
936 int level = pg.attribute("LEVEL").toInt();
937 ScLayer la( pg.attribute("NAME"), level, lId);
938 la.isViewable = pg.attribute("SICHTBAR").toInt();
939 la.isPrintable = pg.attribute("DRUCKEN").toInt();
940 m_Doc->Layers.append(la);
941 }
942 if (pg.tagName() == "MultiLine")
943 {
944 multiLine ml;
945 QDomNode MuLn = pageNode.firstChild();
946 while (!MuLn.isNull())
947 {
948 QDomElement MuL = MuLn.toElement();
949 struct SingleLine sl;
950 sl.Color = MuL.attribute("Color");
951 sl.Dash = MuL.attribute("Dash").toInt();
952 sl.LineEnd = MuL.attribute("LineEnd").toInt();
953 sl.LineJoin = MuL.attribute("LineJoin").toInt();
954 sl.Shade = MuL.attribute("Shade").toInt();
955 sl.Width = ScCLocale::toDoubleC(MuL.attribute("Width"));
956 ml.push_back(sl);
957 MuLn = MuLn.nextSibling();
958 }
959 m_Doc->docLineStyles.insert(pg.attribute("Name"), ml);
960 }
961 if (pg.tagName() == "PAGE")
962 {
963 TableItems.clear();
964 TableID.clear();
965 /*
966 * Attribute von PAGE auslesen
967 */
968 a = pg.attribute("NUM").toInt();
969 pageName = "";
970 pageName = pg.attribute("NAM", "");
971 QString Mus = "";
972 Mus = pg.attribute("MNAM","Normal");
973 if (pageName.isEmpty())
974 {
975 //We store the pages master page but do not apply it now
976 //as it may not exist yet. They are applied in scribus.cpp for now.
977 m_Doc->setMasterPageMode(false);
978 m_Doc->setCurrentPage(m_Doc->addPage(a));
979 m_Doc->currentPage()->setMasterPageName(Mus);
980 }
981 else
982 {
983 m_Doc->setMasterPageMode(true);
984 m_Doc->setCurrentPage(m_Doc->addMasterPage(a, pageName));
985 }
986 //CB: Remove this unnecessarily "slow" slot call when we have no gui for the doc yet!
987 //Items dont appear in the right place if we just m_Doc->addPage(a); for <=1.2.x docs
988 //so we have to call the view, but we certainly dont need to emit to the mainwindow!
989 //This call now picks up the added page and does some view black magic. A must for
990 //1.2.x docs!
991 m_View->addPage(a);
992 //emit NewPage(a);
993 m_Doc->Pages->at(a)->LeftPg=pg.attribute("LEFT", "0").toInt();
994 m_Doc->Pages->at(a)->marginPreset = pg.attribute("PRESET", "0").toInt();
995
996 // guides reading
997 tmp = "";
998 GuideManagerIO::readVerticalGuides(pg.attribute("VerticalGuides"),
999 m_Doc->Pages->at(a),
1000 GuideManagerCore::Standard,
1001 pg.hasAttribute("NumVGuides"));
1002 GuideManagerIO::readHorizontalGuides(pg.attribute("HorizontalGuides"),
1003 m_Doc->Pages->at(a),
1004 GuideManagerCore::Standard,
1005 pg.hasAttribute("NumHGuides"));
1006
1007 QDomNode objNode = pageNode.firstChild();
1008 int pageNo = a;
1009 int pageItem = 0;
1010 while (!objNode.isNull())
1011 {
1012 QDomElement obj = objNode.toElement();
1013 /*
1014 * Attribute von OBJECT auslesen
1015 */
1016 if (!m_Doc->masterPageMode())
1017 {
1018 const long long itemID = scribus12itemID(pageItem++, pageNo);
1019 // qDebug() << QString("1.2 remap: %1 -> %2 [%3 on page %4]").arg(itemID).arg(m_Doc->Items->count()).arg(pageItem-1).arg(pageNo);
1020 itemRemap[itemID] = m_Doc->Items->count();
1021 if (obj.tagName() == "PAGEOBJECT")
1022 {
1023 // member of linked chain?
1024 if (obj.attribute("NEXTITEM").toInt() != -1)
1025 {
1026 itemNext[m_Doc->Items->count()] = scribus12itemID(obj.attribute("NEXTITEM").toInt(), obj.attribute("NEXTPAGE").toInt());
1027 }
1028 }
1029 }
1030 GetItemProps(&obj, &OB, fileDir, newVersion);
1031 OB.Xpos = ScCLocale::toDoubleC(obj.attribute("XPOS"))+m_Doc->Pages->at(a)->xOffset();
1032 OB.Ypos = ScCLocale::toDoubleC(obj.attribute("YPOS"))+m_Doc->Pages->at(a)->yOffset();
1033 OB.NamedLStyle = obj.attribute("NAMEDLST", "");
1034 OB.isBookmark = obj.attribute("BOOKMARK").toInt();
1035 OB.textAlignment = obj.attribute("ALIGN", "0").toInt();
1036 OB.startArrowIndex = 0;
1037 OB.endArrowIndex = 0;
1038 OB.startArrowScale = 100;
1039 OB.endArrowScale = 100;
1040 tmpf = obj.attribute("IFONT", m_Doc->itemToolPrefs().textFont);
1041 m_AvailableFonts->findFont(tmpf, m_Doc);
1042 OB.IFont = tmpf;
1043 OB.LayerID = obj.attribute("LAYER", "0").toInt();
1044 OB.Language = obj.attribute("LANGUAGE", m_Doc->language());
1045 tmp = "";
1046 if ((obj.hasAttribute("GROUPS")) && (obj.attribute("NUMGROUP", "0").toInt() != 0))
1047 {
1048 QMap<int, int>::ConstIterator gIt;
1049 int groupMax = m_Doc->GroupCounter;
1050 tmp = obj.attribute("GROUPS");
1051 ScTextStream fg(&tmp, QIODevice::ReadOnly);
1052 OB.Groups.clear();
1053 for (int cx = 0; cx < obj.attribute("NUMGROUP", "0").toInt(); ++cx)
1054 {
1055 fg >> x;
1056 gIt = groupRemap.constFind(x);
1057 if (gIt != groupRemap.constEnd())
1058 OB.Groups.push(gIt.value());
1059 else
1060 {
1061 OB.Groups.push(groupMax);
1062 groupRemap.insert(x, groupMax);
1063 ++groupMax;
1064 }
1065 }
1066 m_Doc->GroupCounter = groupMax;
1067 tmp = "";
1068 }
1069 else
1070 OB.Groups.clear();
1071 QDomNode node = objNode.firstChild();
1072 while (!node.isNull())
1073 {
1074 QDomElement it = node.toElement();
1075 if (it.tagName() == "CSTOP")
1076 {
1077 QString name = it.attribute("NAME");
1078 double ramp = ScCLocale::toDoubleC(it.attribute("RAMP"), 0.0);
1079 int shade = it.attribute("SHADE", "100").toInt();
1080 double opa = ScCLocale::toDoubleC(it.attribute("TRANS"), 1.0);
1081 handleOldColorShade(m_Doc, name, shade);
1082 OB.fill_gradient.addStop(SetColor(m_Doc, name, shade), ramp, 0.5, opa, name, shade);
1083 OB.GrColor = "";
1084 OB.GrColor2 = "";
1085 }
1086 node = node.nextSibling();
1087 }
1088 OB.itemText = "";
1089 /*int docGc = m_Doc->GroupCounter;
1090 m_Doc->GroupCounter = 0;*/
1091 uint last = m_Doc->Items->count();
1092 PasteItem(&OB);
1093 /*m_Doc->GroupCounter = docGc;*/
1094 newItem = m_Doc->Items->at(last);
1095 newItem->setMasterPageName(pageName);
1096 newItem->setOwnerPage(a); //No need to scan for OnPage as we know page by page in 1.2.x
1097 newItem->oldOwnPage = 0;
1098 newItem->setRedrawBounding();
1099 node = objNode.firstChild();
1100 LastStyles * lastS = new LastStyles();
1101 while (!node.isNull())
1102 {
1103 QDomElement it = node.toElement();
1104 if (it.tagName() == "ITEXT")
1105 GetItemText(&it, m_Doc, true, false, newItem, lastS);
1106 node = node.nextSibling();
1107 }
1108 delete lastS;
1109 newItem->isAutoText=static_cast<bool>(obj.attribute("AUTOTEXT").toInt());
1110 if (newItem->isAutoText)
1111 m_Doc->LastAuto = newItem;
1112 // newItem->NextIt = obj.attribute("NEXTITEM").toInt();
1113 // nextPg[newItem->ItemNr] = obj.attribute("NEXTPAGE").toInt();
1114 if (newItem->isTableItem)
1115 {
1116 TableItems.append(newItem);
1117 TableID.insert(obj.attribute("OwnLINK", "0").toInt(), last);
1118 }
1119 counter++;
1120 objNode = objNode.nextSibling();
1121 }
1122 if (TableItems.count() != 0)
1123 {
1124 for (int ttc = 0; ttc < TableItems.count(); ++ttc)
1125 {
1126 PageItem* ta = TableItems.at(ttc);
1127 if (ta->TopLinkID != -1)
1128 ta->m_topLink = m_Doc->Items->at(TableID[ta->TopLinkID]);
1129 else
1130 ta->m_topLink = nullptr;
1131 if (ta->LeftLinkID != -1)
1132 ta->m_leftLink = m_Doc->Items->at(TableID[ta->LeftLinkID]);
1133 else
1134 ta->m_leftLink = nullptr;
1135 if (ta->RightLinkID != -1)
1136 ta->m_rightLink = m_Doc->Items->at(TableID[ta->RightLinkID]);
1137 else
1138 ta->m_rightLink = nullptr;
1139 if (ta->BottomLinkID != -1)
1140 ta->m_bottomLink = m_Doc->Items->at(TableID[ta->BottomLinkID]);
1141 else
1142 ta->m_bottomLink = nullptr;
1143 }
1144 }
1145 }
1146 pageNode = pageNode.nextSibling();
1147 }
1148 m_Doc->setMasterPageMode(false);
1149
1150 pageNode = docNode.firstChild();
1151 while (!pageNode.isNull())
1152 {
1153 QDomElement pg = pageNode.toElement();
1154 if (pg.tagName() == "Bookmark")
1155 {
1156 int elem = pg.attribute("Element").toInt();
1157 if (elem < m_Doc->Items->count())
1158 {
1159 bok.Title = pg.attribute("Title");
1160 bok.Text = pg.attribute("Text");
1161 bok.Aktion = pg.attribute("Aktion");
1162 bok.ItemNr = pg.attribute("ItemNr").toInt();
1163 bok.PageObject = m_Doc->Items->at(elem);
1164 bok.First = pg.attribute("First").toInt();
1165 bok.Last = pg.attribute("Last").toInt();
1166 bok.Prev = pg.attribute("Prev").toInt();
1167 bok.Next = pg.attribute("Next").toInt();
1168 bok.Parent = pg.attribute("Parent").toInt();
1169 m_Doc->BookMarks.append(bok);
1170 }
1171 }
1172 if (pg.tagName() == "PDF")
1173 {
1174 m_Doc->pdfOptions().Articles = static_cast<bool>(pg.attribute("Articles").toInt());
1175 m_Doc->pdfOptions().Thumbnails = static_cast<bool>(pg.attribute("Thumbnails").toInt());
1176 m_Doc->pdfOptions().Compress = static_cast<bool>(pg.attribute("Compress").toInt());
1177 m_Doc->pdfOptions().CompressMethod = (PDFOptions::PDFCompression) pg.attribute("CMethod", "0").toInt();
1178 m_Doc->pdfOptions().Quality = pg.attribute("Quality", "0").toInt();
1179 m_Doc->pdfOptions().RecalcPic = static_cast<bool>(pg.attribute("RecalcPic").toInt());
1180 m_Doc->pdfOptions().Bookmarks = static_cast<bool>(pg.attribute("Bookmarks").toInt());
1181 if (pg.hasAttribute("MirrorH"))
1182 m_Doc->pdfOptions().MirrorH = static_cast<bool>(pg.attribute("MirrorH").toInt());
1183 else
1184 m_Doc->pdfOptions().MirrorH = false;
1185 if (pg.hasAttribute("MirrorV"))
1186 m_Doc->pdfOptions().MirrorV = static_cast<bool>(pg.attribute("MirrorV").toInt());
1187 else
1188 m_Doc->pdfOptions().MirrorV = false;
1189 if (pg.hasAttribute("RotateDeg"))
1190 m_Doc->pdfOptions().RotateDeg = pg.attribute("RotateDeg", "0").toInt();
1191 else
1192 m_Doc->pdfOptions().RotateDeg = 0;
1193 m_Doc->pdfOptions().PresentMode = static_cast<bool>(pg.attribute("PresentMode").toInt());
1194 m_Doc->pdfOptions().PicRes = pg.attribute("PicRes").toInt();
1195 m_Doc->pdfOptions().Version = (PDFVersion::Version) pg.attribute("Version").toInt();
1196 m_Doc->pdfOptions().Resolution = pg.attribute("Resolution").toInt();
1197 m_Doc->pdfOptions().Binding = pg.attribute("Binding").toInt();
1198 m_Doc->pdfOptions().fileName = "";
1199 m_Doc->pdfOptions().FontEmbedding = PDFOptions::EmbedFonts;
1200 m_Doc->pdfOptions().isGrayscale = false;
1201 m_Doc->pdfOptions().UseRGB = static_cast<bool>(pg.attribute("RGBMode", "0").toInt());
1202 m_Doc->pdfOptions().UseProfiles = static_cast<bool>(pg.attribute("UseProfiles", "0").toInt());
1203 m_Doc->pdfOptions().UseProfiles2 = static_cast<bool>(pg.attribute("UseProfiles2", "0").toInt());
1204 m_Doc->pdfOptions().Intent = pg.attribute("Intent", "1").toInt();
1205 m_Doc->pdfOptions().Intent2 = pg.attribute("Intent2", "1").toInt();
1206 m_Doc->pdfOptions().SolidProf = pg.attribute("SolidP", "");
1207 m_Doc->pdfOptions().ImageProf = pg.attribute("ImageP", "");
1208 m_Doc->pdfOptions().PrintProf = pg.attribute("PrintP", "");
1209 m_Doc->pdfOptions().Info = pg.attribute("InfoString", "");
1210 m_Doc->pdfOptions().bleeds.setTop(ScCLocale::toDoubleC(pg.attribute("BTop"), 0.0));
1211 m_Doc->pdfOptions().bleeds.setLeft(ScCLocale::toDoubleC(pg.attribute("BLeft"), 0.0));
1212 m_Doc->pdfOptions().bleeds.setRight(ScCLocale::toDoubleC(pg.attribute("BRight"), 0.0));
1213 m_Doc->pdfOptions().bleeds.setBottom(ScCLocale::toDoubleC(pg.attribute("BBottom"), 0.0));
1214 m_Doc->pdfOptions().EmbeddedI = static_cast<bool>(pg.attribute("ImagePr", "0").toInt());
1215 m_Doc->pdfOptions().PassOwner = pg.attribute("PassOwner", "");
1216 m_Doc->pdfOptions().PassUser = pg.attribute("PassUser", "");
1217 m_Doc->pdfOptions().Permissions = pg.attribute("Permissions", "-4").toInt();
1218 m_Doc->pdfOptions().Encrypt = static_cast<bool>(pg.attribute("Encrypt", "0").toInt());
1219 m_Doc->pdfOptions().useLayers = static_cast<bool>(pg.attribute("UseLayers", "0").toInt());
1220 m_Doc->pdfOptions().UseLPI = static_cast<bool>(pg.attribute("UseLpi", "0").toInt());
1221 m_Doc->pdfOptions().UseSpotColors = true;
1222 m_Doc->pdfOptions().doMultiFile = false;
1223 QDomNode PFO = pageNode.firstChild();
1224 while (!PFO.isNull())
1225 {
1226 QDomElement pdfF = PFO.toElement();
1227 if (pdfF.tagName() == "LPI")
1228 {
1229 struct LPIData lpo;
1230 lpo.Angle = pdfF.attribute("Angle").toInt();
1231 lpo.Frequency = pdfF.attribute("Frequency").toInt();
1232 lpo.SpotFunc = pdfF.attribute("SpotFunction").toInt();
1233 m_Doc->pdfOptions().LPISettings[pdfF.attribute("Color")] = lpo;
1234 }
1235 if (pdfF.tagName() == "Fonts")
1236 {
1237 if (!m_Doc->pdfOptions().EmbedList.contains(pdfF.attribute("Name")))
1238 m_Doc->pdfOptions().EmbedList.append(pdfF.attribute("Name"));
1239 }
1240 if (pdfF.tagName() == "Subset")
1241 {
1242 if (!m_Doc->pdfOptions().SubsetList.contains(pdfF.attribute("Name")))
1243 m_Doc->pdfOptions().SubsetList.append(pdfF.attribute("Name"));
1244 }
1245 if (pdfF.tagName() == "Effekte")
1246 {
1247 struct PDFPresentationData ef;
1248 ef.pageEffectDuration = pdfF.attribute("pageEffectDuration").toInt();
1249 ef.pageViewDuration = pdfF.attribute("pageViewDuration").toInt();
1250 ef.effectType = pdfF.attribute("effectType").toInt();
1251 ef.Dm = pdfF.attribute("Dm").toInt();
1252 ef.M = pdfF.attribute("M").toInt();
1253 ef.Di = pdfF.attribute("Di").toInt();
1254 EffVal.append(ef);
1255 }
1256 PFO = PFO.nextSibling();
1257 }
1258 }
1259 pageNode = pageNode.nextSibling();
1260 }
1261 docNode = docNode.nextSibling();
1262 }
1263 //m_Doc->Pages = &m_Doc->DocPages;
1264 //m_Doc->pageCount = m_Doc->Pages->count();
1265 //m_Doc->Items = m_Doc->DocItems;
1266 m_Doc->setMasterPageMode(false);
1267 m_View->reformPages();
1268 if (!EffVal.isEmpty())
1269 {
1270 for (int pdoE = 0; pdoE < EffVal.count(); ++pdoE)
1271 {
1272 if (pdoE < m_Doc->Pages->count())
1273 m_Doc->Pages->at(pdoE)->PresentVals = EffVal[pdoE];
1274 }
1275 }
1276
1277 handleOldLayerBehavior(m_Doc);
1278 if (m_Doc->layerCount() == 0)
1279 {
1280 ScLayer* nl = m_Doc->Layers.newLayer( QObject::tr("Background") );
1281 nl->flowControl = false;
1282 activeLayer = nl->ID;
1283 }
1284 m_Doc->setActiveLayer(activeLayer);
1285
1286 // reestablish textframe links
1287 if (itemNext.count() != 0)
1288 {
1289 QMap<int,long long>::Iterator lc;
1290 for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
1291 {
1292 // qDebug() << QString("1.2 textframe links: %1->%2[%3]").arg(lc.key()).arg(itemRemap[lc.data()]).arg(lc.data());
1293 PageItem *Its = m_Doc->Items->at(lc.key());
1294 PageItem *Itn = m_Doc->Items->at(itemRemap[lc.value()]);
1295 assert(Its && Its->asTextFrame());
1296 assert(Itn && Itn->asTextFrame());
1297 if (!Its->canBeLinkedTo(Itn))
1298 {
1299 qDebug("scribus12format: corruption in linked textframes detected");
1300 continue;
1301 }
1302 Its->link(Itn);
1303 }
1304 }
1305
1306 // reestablish first/lastAuto
1307 m_Doc->FirstAuto = m_Doc->LastAuto;
1308 if (m_Doc->LastAuto)
1309 {
1310 while (m_Doc->LastAuto->nextInChain())
1311 m_Doc->LastAuto = m_Doc->LastAuto->nextInChain();
1312 while (m_Doc->FirstAuto->prevInChain())
1313 m_Doc->FirstAuto = m_Doc->FirstAuto->prevInChain();
1314 }
1315
1316 // fix legacy char formatting
1317 for (int i = 0; i < m_Doc->DocItems.count(); ++i)
1318 {
1319 PageItem* item = m_Doc->DocItems.at(i);
1320 if (item->prevInChain() == nullptr && item->itemText.length() > 0)
1321 item->itemText.fixLegacyFormatting();
1322 }
1323 for (int i = 0; i < m_Doc->MasterItems.count(); ++i)
1324 {
1325 PageItem* item = m_Doc->MasterItems.at(i);
1326 if (item->prevInChain() == nullptr && item->itemText.length() > 0)
1327 item->itemText.fixLegacyFormatting();
1328 }
1329 for (auto itf = m_Doc->FrameItems.begin(); itf != m_Doc->FrameItems.end(); ++itf)
1330 {
1331 PageItem *item = itf.value();
1332 if (item->prevInChain() == nullptr && item->itemText.length() > 0)
1333 item->itemText.fixLegacyFormatting();
1334 }
1335 for (int i = 0; i < m_Doc->DocItems.count(); ++i)
1336 {
1337 QList<PageItem*> allItems;
1338 PageItem* item = m_Doc->DocItems.at(i);
1339 if (item->isGroup())
1340 allItems = item->getAllChildren();
1341 else
1342 allItems.append(item);
1343 for (int ii = 0; ii < allItems.count(); ii++)
1344 {
1345 PageItem* gItem = allItems[ii];
1346 if (gItem->isGroup() && gItem->groupItemList[0]->isTableItem)
1347 {
1348 if (gItem->isGroupChild())
1349 convertOldTable(m_Doc, gItem, gItem->groupItemList, nullptr, &(gItem->asGroupFrame()->groupItemList));
1350 else
1351 convertOldTable(m_Doc, gItem, gItem->groupItemList, nullptr, &m_Doc->DocItems);
1352 }
1353 }
1354 allItems.clear();
1355 }
1356 for (int i = 0; i < m_Doc->MasterItems.count(); ++i)
1357 {
1358 QList<PageItem*> allItems;
1359 PageItem* item = m_Doc->MasterItems.at(i);
1360 if (item->isGroup())
1361 allItems = item->getAllChildren();
1362 else
1363 allItems.append(item);
1364 for (int ii = 0; ii < allItems.count(); ii++)
1365 {
1366 PageItem* gItem = allItems[ii];
1367 if (gItem->isGroup() && gItem->groupItemList[0]->isTableItem)
1368 {
1369 if (gItem->isGroupChild())
1370 convertOldTable(m_Doc, gItem, gItem->groupItemList, nullptr, &(gItem->asGroupFrame()->groupItemList));
1371 else
1372 convertOldTable(m_Doc, gItem, gItem->groupItemList, nullptr, &m_Doc->MasterItems);
1373 }
1374 }
1375 allItems.clear();
1376 }
1377
1378 setCurrentComboItem(m_ScMW->unitSwitcher, unitGetStrFromIndex(m_Doc->unitIndex()));
1379 if (m_mwProgressBar!=nullptr)
1380 m_mwProgressBar->setValue(docNode.childNodes().count());
1381
1382 ScMessageBox::warning(ScCore->primaryMainWindow(),
1383 CommonStrings::trWarning,
1384 tr("You have opened a file produced by Scribus 1.2.x.\n"
1385 "If you save it in this version, it will no longer be readable by older Scribus versions."));
1386
1387 return true;
1388 //end old ReadDoc
1389
1390
1391 //return false;
1392 }
1393
saveFile(const QString &,const FileFormat &)1394 bool Scribus12Format::saveFile(const QString & /* fileName */, const FileFormat & /* fmt */)
1395 {
1396 return false;
1397 }
1398
GetItemProps(QDomElement * obj,struct CopyPasteBuffer * OB,const QString & baseDir,bool newVersion)1399 void Scribus12Format::GetItemProps(QDomElement *obj, struct CopyPasteBuffer *OB, const QString& baseDir, bool newVersion)
1400 {
1401 QString tmp;
1402 int x, y;
1403 double xf, yf, xf2;
1404 OB->PType = static_cast<PageItem::ItemType>(obj->attribute("PTYPE").toInt());
1405 OB->Width=ScCLocale::toDoubleC(obj->attribute("WIDTH"));
1406 OB->Height=ScCLocale::toDoubleC(obj->attribute("HEIGHT"));
1407 OB->RadRect = ScCLocale::toDoubleC(obj->attribute("RADRECT"), 0.0);
1408 OB->ClipEdited = obj->attribute("CLIPEDIT", "0").toInt();
1409 OB->FrameType = obj->attribute("FRTYPE", "0").toInt();
1410 OB->Pwidth=ScCLocale::toDoubleC(obj->attribute("PWIDTH"));
1411 OB->Pcolor = obj->attribute("PCOLOR");
1412 if ((!newVersion) && (OB->PType == 4))
1413 {
1414 OB->TxtFill = obj->attribute("PCOLOR2");
1415 OB->Pcolor2 = CommonStrings::None;
1416 }
1417 else
1418 {
1419 OB->Pcolor2 = obj->attribute("PCOLOR2");
1420 OB->TxtFill = obj->attribute("TXTFILL", "Black");
1421 }
1422 if (OB->Pwidth == 0.0)
1423 OB->Pcolor2 = CommonStrings::None;
1424 OB->Shade = obj->attribute("SHADE").toInt();
1425 OB->Shade2 = obj->attribute("SHADE2").toInt();
1426 OB->FillRule = obj->attribute("fillRule", "1").toInt();
1427 OB->TxtStroke=obj->attribute("TXTSTROKE", CommonStrings::None);
1428 OB->ShTxtFill=obj->attribute("TXTFILLSH", "100").toInt();
1429 OB->ShTxtStroke=obj->attribute("TXTSTRSH", "100").toInt();
1430 OB->TxtScale=qRound(ScCLocale::toDoubleC(obj->attribute("TXTSCALE"), 100.0) * 10);
1431 OB->TxtScaleV=qRound(ScCLocale::toDoubleC(obj->attribute("TXTSCALEV"), 100.0) * 10);
1432 OB->TxTBase=qRound(ScCLocale::toDoubleC(obj->attribute("TXTBASE"), 0.0) * 10);
1433 OB->TxTStyle=obj->attribute("TXTSTYLE", "0").toInt();
1434 OB->TxtShadowX=qRound(ScCLocale::toDoubleC(obj->attribute("TXTSHX"), 5.0) * 10);
1435 OB->TxtShadowY=qRound(ScCLocale::toDoubleC(obj->attribute("TXTSHY"), -5.0) * 10);
1436 OB->TxtOutline=qRound(ScCLocale::toDoubleC(obj->attribute("TXTOUT"), 1.0) * 10);
1437 OB->TxtUnderPos=qRound(ScCLocale::toDoubleC(obj->attribute("TXTULP"), -0.1) * 10);
1438 OB->TxtUnderWidth=qRound(ScCLocale::toDoubleC(obj->attribute("TXTULW"), -0.1) * 10);
1439 OB->TxtStrikePos=qRound(ScCLocale::toDoubleC(obj->attribute("TXTSTP"), -0.1) * 10);
1440 OB->TxtStrikeWidth=qRound(ScCLocale::toDoubleC(obj->attribute("TXTSTW"), -0.1) * 10);
1441 OB->Cols = obj->attribute("COLUMNS", "1").toInt();
1442 OB->ColGap = ScCLocale::toDoubleC(obj->attribute("COLGAP"), 0.0);
1443 OB->GrType = obj->attribute("GRTYP", "0").toInt();
1444 OB->fill_gradient.clearStops();
1445 if (OB->GrType != 0)
1446 {
1447 if (OB->GrType == Gradient_Pattern)
1448 {
1449 OB->pattern = obj->attribute("pattern", "");
1450 OB->patternScaleX = ScCLocale::toDoubleC(obj->attribute("pScaleX"), 100.0);
1451 OB->patternScaleY = ScCLocale::toDoubleC(obj->attribute("pScaleY"), 100.0);
1452 OB->patternOffsetX = ScCLocale::toDoubleC(obj->attribute("pOffsetX"), 0.0);
1453 OB->patternOffsetY = ScCLocale::toDoubleC(obj->attribute("pOffsetY"), 0.0);
1454 OB->patternRotation = ScCLocale::toDoubleC(obj->attribute("pRotation"), 0.0);
1455 }
1456 else
1457 {
1458 OB->GrStartX = ScCLocale::toDoubleC(obj->attribute("GRSTARTX"), 0.0);
1459 OB->GrStartY = ScCLocale::toDoubleC(obj->attribute("GRSTARTY"), 0.0);
1460 OB->GrEndX = ScCLocale::toDoubleC(obj->attribute("GRENDX"), 0.0);
1461 OB->GrEndY = ScCLocale::toDoubleC(obj->attribute("GRENDY"), 0.0);
1462 OB->GrFocalX = OB->GrStartX;
1463 OB->GrFocalY = OB->GrStartY;
1464 OB->GrScale = 1.0;
1465 OB->GrSkew = 0.0;
1466 OB->GrColor = obj->attribute("GRCOLOR","");
1467 if (OB->GrColor.isEmpty())
1468 OB->GrColor = "Black";
1469 OB->GrColor2 = obj->attribute("GRCOLOR2","Black");
1470 if (OB->GrColor2.isEmpty())
1471 OB->GrColor2 = "Black";
1472 OB->GrShade = obj->attribute("GRSHADE", "100").toInt();
1473 OB->GrShade2 = obj->attribute("GRSHADE2", "100").toInt();
1474 }
1475 }
1476
1477 OB->GrControl1 = FPoint(0,0);
1478 OB->GrControl2 = FPoint(OB->Width, 0);
1479 OB->GrControl3 = FPoint(OB->Width, OB->Height);
1480 OB->GrControl4 = FPoint(0, OB->Height);
1481 OB->GrControl5 = FPoint(OB->Width / 2.0, OB->Height / 2.0);
1482 OB->GrColorP1 = "Black";
1483 OB->GrColorP2 = "Black";
1484 OB->GrColorP3 = "Black";
1485 OB->GrColorP4 = "Black";
1486 OB->GrCol1transp = 1.0;
1487 OB->GrCol2transp = 1.0;
1488 OB->GrCol3transp = 1.0;
1489 OB->GrCol4transp = 1.0;
1490 OB->GrCol1Shade = 100;
1491 OB->GrCol2Shade = 100;
1492 OB->GrCol3Shade = 100;
1493 OB->GrCol4Shade = 100;
1494 OB->GrTypeStroke = 0;
1495 OB->GrStrokeStartX = 0;
1496 OB->GrStrokeStartY = 0;
1497 OB->GrStrokeEndX = OB->Width;
1498 OB->GrStrokeEndY = 0;
1499 OB->GrStrokeFocalX = 0;
1500 OB->GrStrokeFocalY = 0;
1501 OB->GrStrokeScale = 1;
1502 OB->GrStrokeSkew = 0;
1503 OB->GrMask = 0;
1504 OB->GrMaskStartX = 0;
1505 OB->GrMaskStartY = 0;
1506 OB->GrMaskEndX = OB->Width;
1507 OB->GrMaskEndY = 0;
1508 OB->GrMaskFocalX = 0;
1509 OB->GrMaskFocalY = 0;
1510 OB->GrMaskScale = 1;
1511 OB->GrMaskSkew = 0;
1512
1513 switch (OB->GrType)
1514 {
1515 case Gradient_LinearLegacy1:
1516 case Gradient_LinearLegacy2:
1517 case Gradient_LinearLegacy3:
1518 case Gradient_LinearLegacy4:
1519 OB->GrType = Gradient_Linear;
1520 break;
1521 case Gradient_RadialLegacy5:
1522 OB->GrType = Gradient_Radial;
1523 break;
1524 default:
1525 break;
1526 }
1527 OB->Rot = ScCLocale::toDoubleC(obj->attribute("ROT"));
1528 OB->PLineArt = Qt::PenStyle(obj->attribute("PLINEART").toInt());
1529 OB->PLineEnd = Qt::PenCapStyle(obj->attribute("PLINEEND", "0").toInt());
1530 OB->PLineJoin = Qt::PenJoinStyle(obj->attribute("PLINEJOIN", "0").toInt());
1531 OB->LineSp = ScCLocale::toDoubleC(obj->attribute("LINESP"));
1532 OB->LineSpMode = obj->attribute("LINESPMode", "0").toInt();
1533 OB->LocalScX = ScCLocale::toDoubleC(obj->attribute("LOCALSCX"));
1534 OB->LocalScY = ScCLocale::toDoubleC(obj->attribute("LOCALSCY"));
1535 OB->LocalX = ScCLocale::toDoubleC(obj->attribute("LOCALX"));
1536 OB->LocalY = ScCLocale::toDoubleC(obj->attribute("LOCALY"));
1537 OB->LocalRot = 0.0;
1538 OB->PicArt=obj->attribute("PICART").toInt();
1539 OB->flippedH = obj->attribute("FLIPPEDH").toInt() % 2;
1540 OB->flippedV = obj->attribute("FLIPPEDV").toInt() % 2;
1541 /* OB->BBoxX=ScCLocale::toDoubleC(obj->attribute("BBOXX"));
1542 OB->BBoxH=ScCLocale::toDoubleC(obj->attribute("BBOXH")); */
1543 OB->ScaleType = obj->attribute("SCALETYPE", "1").toInt();
1544 OB->AspectRatio = obj->attribute("RATIO", "0").toInt();
1545 OB->isPrintable=obj->attribute("PRINTABLE").toInt();
1546 OB->m_isAnnotation=obj->attribute("ANNOTATION", "0").toInt();
1547 OB->m_annotation.setType(obj->attribute("ANTYPE", "0").toInt());
1548 OB->m_annotation.setAction(obj->attribute("ANACTION",""));
1549 OB->m_annotation.setE_act(obj->attribute("ANEACT",""));
1550 OB->m_annotation.setX_act(obj->attribute("ANXACT",""));
1551 OB->m_annotation.setD_act(obj->attribute("ANDACT",""));
1552 OB->m_annotation.setFo_act(obj->attribute("ANFOACT",""));
1553 OB->m_annotation.setBl_act(obj->attribute("ANBLACT",""));
1554 OB->m_annotation.setK_act(obj->attribute("ANKACT",""));
1555 OB->m_annotation.setF_act(obj->attribute("ANFACT",""));
1556 OB->m_annotation.setV_act(obj->attribute("ANVACT",""));
1557 OB->m_annotation.setC_act(obj->attribute("ANCACT",""));
1558 OB->m_annotation.setActionType(obj->attribute("ANACTYP", "0").toInt());
1559 OB->m_annotation.setExtern(obj->attribute("ANEXTERN",""));
1560 if ((!OB->m_annotation.Extern().isEmpty()) && (OB->m_annotation.ActionType() != 8))
1561 {
1562 QFileInfo efp(OB->m_annotation.Extern());
1563 OB->m_annotation.setExtern(efp.absoluteFilePath());
1564 }
1565 OB->m_annotation.setZiel(obj->attribute("ANZIEL", "0").toInt());
1566 OB->itemName=obj->attribute("ANNAME","");
1567 OB->m_annotation.setToolTip(obj->attribute("ANTOOLTIP",""));
1568 OB->m_annotation.setRollOver(obj->attribute("ANROLL",""));
1569 OB->m_annotation.setDown(obj->attribute("ANDOWN",""));
1570 OB->m_annotation.setBorderWidth(obj->attribute("ANBWID", "1").toInt());
1571 OB->m_annotation.setBorderStyle(obj->attribute("ANBSTY", "0").toInt());
1572 OB->m_annotation.setFeed(obj->attribute("ANFEED", "1").toInt());
1573 OB->m_annotation.setFlag(obj->attribute("ANFLAG", "0").toInt());
1574 OB->m_annotation.setFont(obj->attribute("ANFONT", "4").toInt());
1575 OB->m_annotation.setFormat(obj->attribute("ANFORMAT", "0").toInt());
1576 OB->m_annotation.setVis(obj->attribute("ANVIS", "0").toInt());
1577 OB->m_annotation.setIsChk(static_cast<bool>(obj->attribute("ANCHK", "0").toInt()));
1578 OB->m_annotation.setCheckState(OB->m_annotation.IsChk());
1579 OB->m_annotation.setAAact(static_cast<bool>(obj->attribute("ANAA", "0").toInt()));
1580 OB->m_annotation.setHTML(obj->attribute("ANHTML", "0").toInt());
1581 OB->m_annotation.setUseIcons(static_cast<bool>(obj->attribute("ANICON", "0").toInt()));
1582 OB->m_annotation.setChkStil(obj->attribute("ANCHKS", "0").toInt());
1583 OB->m_annotation.setMaxChar(obj->attribute("ANMC", "-1").toInt());
1584 OB->m_annotation.setBorderColor(obj->attribute("ANBCOL",CommonStrings::None));
1585 OB->m_annotation.setIPlace(obj->attribute("ANPLACE", "1").toInt());
1586 OB->m_annotation.setScaleW(obj->attribute("ANSCALE", "0").toInt());
1587 if (obj->attribute("TRANSPARENT", "0").toInt() == 1)
1588 OB->Pcolor = CommonStrings::None;
1589 OB->textAlignment=obj->attribute("ALIGN", "0").toInt();
1590 if ( obj->hasAttribute("TEXTFLOWMODE") )
1591 OB->TextflowMode = (PageItem::TextFlowMode) obj->attribute("TEXTFLOWMODE", "0").toInt();
1592 else if ( obj->attribute("TEXTFLOW").toInt() )
1593 {
1594 if (obj->attribute("TEXTFLOW2", "0").toInt())
1595 OB->TextflowMode = PageItem::TextFlowUsesBoundingBox;
1596 else if (obj->attribute("TEXTFLOW3", "0").toInt())
1597 OB->TextflowMode = PageItem::TextFlowUsesContourLine;
1598 else
1599 OB->TextflowMode = PageItem::TextFlowUsesFrameShape;
1600 }
1601 else
1602 OB->TextflowMode = PageItem::TextFlowDisabled;
1603 OB->Extra=ScCLocale::toDoubleC(obj->attribute("EXTRA"));
1604 OB->TExtra=ScCLocale::toDoubleC(obj->attribute("TEXTRA"), 1.0);
1605 OB->BExtra=ScCLocale::toDoubleC(obj->attribute("BEXTRA"), 1.0);
1606 OB->RExtra=ScCLocale::toDoubleC(obj->attribute("REXTRA"), 1.0);
1607 OB->PoShow = obj->attribute("PLTSHOW", "0").toInt();
1608 OB->BaseOffs = ScCLocale::toDoubleC(obj->attribute("BASEOF"), 0.0);
1609 OB->textPathType = obj->attribute("textPathType", "0").toInt();
1610 OB->textPathFlipped = static_cast<bool>(obj->attribute("textPathFlipped", "0").toInt());
1611 OB->ISize = qRound(ScCLocale::toDoubleC(obj->attribute("ISIZE"), 12.0) * 10);
1612 if (obj->hasAttribute("EXTRAV"))
1613 OB->ExtraV = qRound(ScCLocale::toDoubleC(obj->attribute("EXTRAV"), 0.0) / ScCLocale::toDoubleC(obj->attribute("ISIZE"), 12.0) * 1000.0);
1614 else
1615 OB->ExtraV = obj->attribute("TXTKERN").toInt();
1616 OB->Pfile = Relative2Path(obj->attribute("PFILE" ,""), baseDir);
1617 OB->Pfile2 = Relative2Path(obj->attribute("PFILE2",""), baseDir);
1618 OB->Pfile3 = Relative2Path(obj->attribute("PFILE3",""), baseDir);
1619 OB->Pfile = QDir::fromNativeSeparators(OB->Pfile);
1620 OB->Pfile2 = QDir::fromNativeSeparators(OB->Pfile2);
1621 OB->Pfile3 = QDir::fromNativeSeparators(OB->Pfile3);
1622 OB->ImageProfile = obj->attribute("PRFILE","");
1623 OB->ImageIntent = (eRenderIntent) obj->attribute("IRENDER", "1").toInt();
1624 OB->EmbeddedProfile = obj->attribute("EPROF","");
1625 OB->UseEmbedded = obj->attribute("EMBEDDED", "1").toInt();
1626 OB->Locked = static_cast<bool>(obj->attribute("LOCK", "0").toInt());
1627 OB->LockRes = static_cast<bool>(obj->attribute("LOCKR", "0").toInt());
1628 OB->Reverse = static_cast<bool>(obj->attribute("REVERS", "0").toInt());
1629 OB->isTableItem = static_cast<bool>(obj->attribute("isTableItem", "0").toInt());
1630 OB->TopLine = static_cast<bool>(obj->attribute("TopLine", "0").toInt());
1631 OB->LeftLine = static_cast<bool>(obj->attribute("LeftLine", "0").toInt());
1632 OB->RightLine = static_cast<bool>(obj->attribute("RightLine", "0").toInt());
1633 OB->BottomLine = static_cast<bool>(obj->attribute("BottomLine", "0").toInt());
1634 OB->TopLinkID = obj->attribute("TopLINK", "-1").toInt();
1635 OB->LeftLinkID = obj->attribute("LeftLINK", "-1").toInt();
1636 OB->RightLinkID = obj->attribute("RightLINK", "-1").toInt();
1637 OB->BottomLinkID = obj->attribute("BottomLINK", "-1").toInt();
1638 OB->Transparency = ScCLocale::toDoubleC(obj->attribute("TransValue"), 0.0);
1639 if (obj->hasAttribute("TransValueS"))
1640 OB->TranspStroke = ScCLocale::toDoubleC(obj->attribute("TransValueS"), 0.0);
1641 else
1642 OB->TranspStroke = OB->Transparency;
1643 OB->TransBlend = obj->attribute("TransBlend", "0").toInt();
1644 OB->TransBlendS = obj->attribute("TransBlendS", "0").toInt();
1645 tmp = "";
1646 if (obj->hasAttribute("NUMCLIP"))
1647 {
1648 OB->Clip.resize(obj->attribute("NUMCLIP").toUInt());
1649 tmp = obj->attribute("CLIPCOOR");
1650 ScTextStream fc(&tmp, QIODevice::ReadOnly);
1651 for (uint c=0; c<obj->attribute("NUMCLIP").toUInt(); ++c)
1652 {
1653 fc >> x;
1654 fc >> y;
1655 OB->Clip.setPoint(c, x, y);
1656 }
1657 }
1658 else
1659 OB->Clip.resize(0);
1660 tmp = "";
1661 if (obj->hasAttribute("NUMPO"))
1662 {
1663 OB->PoLine.resize(obj->attribute("NUMPO").toUInt());
1664 tmp = obj->attribute("POCOOR");
1665 double maxVal = std::numeric_limits<double>::max() / 2.0;
1666 ScTextStream fp(&tmp, QIODevice::ReadOnly);
1667 for (uint cx=0; cx<obj->attribute("NUMPO").toUInt(); ++cx)
1668 {
1669 fp >> xf;
1670 fp >> yf;
1671 if (xf >= 999999)
1672 xf = maxVal;
1673 if (yf >= 999999)
1674 yf = maxVal;
1675 OB->PoLine.setPoint(cx, xf, yf);
1676 }
1677 }
1678 else
1679 OB->PoLine.resize(0);
1680 tmp = "";
1681 if (obj->hasAttribute("NUMCO"))
1682 {
1683 OB->ContourLine.resize(obj->attribute("NUMCO").toUInt());
1684 tmp = obj->attribute("COCOOR");
1685 double maxVal = std::numeric_limits<double>::max() / 2.0;
1686 ScTextStream fp(&tmp, QIODevice::ReadOnly);
1687 for (uint cx=0; cx<obj->attribute("NUMCO").toUInt(); ++cx)
1688 {
1689 fp >> xf;
1690 fp >> yf;
1691 if (xf >= 999999)
1692 xf = maxVal;
1693 if (yf >= 999999)
1694 yf = maxVal;
1695 OB->ContourLine.setPoint(cx, xf, yf);
1696 }
1697 }
1698 else
1699 OB->ContourLine.resize(0);
1700 tmp = "";
1701 if ((obj->hasAttribute("NUMTAB")) && (obj->attribute("NUMTAB", "0").toInt() != 0))
1702 {
1703 ParagraphStyle::TabRecord tb;
1704 tmp = obj->attribute("TABS");
1705 ScTextStream tgv(&tmp, QIODevice::ReadOnly);
1706 OB->TabValues.clear();
1707 for (int cxv = 0; cxv < obj->attribute("NUMTAB", "0").toInt(); cxv += 2)
1708 {
1709 tgv >> xf;
1710 tgv >> xf2;
1711 tb.tabPosition = xf2;
1712 tb.tabType = static_cast<int>(xf);
1713 tb.tabFillChar = QChar();
1714 OB->TabValues.append(tb);
1715 }
1716 tmp = "";
1717 }
1718 else
1719 OB->TabValues.clear();
1720 if ((obj->hasAttribute("NUMDASH")) && (obj->attribute("NUMDASH", "0").toInt() != 0))
1721 {
1722 tmp = obj->attribute("DASHS");
1723 ScTextStream dgv(&tmp, QIODevice::ReadOnly);
1724 OB->DashValues.clear();
1725 for (int cxv = 0; cxv < obj->attribute("NUMDASH", "0").toInt(); ++cxv)
1726 {
1727 dgv >> xf;
1728 OB->DashValues.append(xf);
1729 }
1730 tmp = "";
1731 }
1732 else
1733 OB->DashValues.clear();
1734 OB->DashOffset = ScCLocale::toDoubleC(obj->attribute("DASHOFF"), 0.0);
1735 }
1736
GetItemText(QDomElement * it,ScribusDoc * doc,bool VorLFound,bool impo,PageItem * obj,LastStyles * last)1737 void Scribus12Format::GetItemText(QDomElement *it, ScribusDoc *doc, bool VorLFound, bool impo, PageItem* obj, LastStyles* last)
1738 {
1739 QString tmp2(it->attribute("CH"));
1740 tmp2.replace(QRegExp("\r"), QChar(5));
1741 tmp2.replace(QRegExp("\n"), QChar(5));
1742 tmp2.replace(QRegExp("\t"), QChar(4));
1743 tmp2.replace(SpecialChars::OLD_LINEBREAK, SpecialChars::LINEBREAK);
1744 tmp2.replace(SpecialChars::OLD_NBHYPHEN, SpecialChars::NBHYPHEN);
1745 tmp2.replace(SpecialChars::OLD_NBSPACE, SpecialChars::NBSPACE);
1746 QString tmpf(it->attribute("CFONT", doc->itemToolPrefs().textFont));
1747 doc->AllFonts->findFont(tmpf, doc);
1748 int size = qRound(ScCLocale::toDoubleC(it->attribute("CSIZE")) * 10);
1749 QString fcolor = it->attribute("CCOLOR");
1750 int shade = it->attribute("CSHADE").toInt();
1751 handleOldColorShade(doc, fcolor, shade);
1752 int extra;
1753 if (it->hasAttribute("CEXTRA"))
1754 extra = qRound(ScCLocale::toDoubleC(it->attribute("CEXTRA")) / ScCLocale::toDoubleC(it->attribute("CSIZE")) * 1000.0);
1755 else
1756 extra = it->attribute("CKERN").toInt();
1757 int cstyle = it->attribute("CSTYLE").toInt() & 255;
1758 int ab = it->attribute("CAB", "0").toInt();
1759 QString stroke = it->attribute("CSTROKE",CommonStrings::None);
1760 int shade2 = it->attribute("CSHADE2", "100").toInt();
1761 handleOldColorShade(doc, stroke, shade2);
1762 int scale = qRound(ScCLocale::toDoubleC(it->attribute("CSCALE"), 100.0) * 10);
1763 int scalev = qRound(ScCLocale::toDoubleC(it->attribute("CSCALEV"), 100.0) * 10);
1764 int base = qRound(ScCLocale::toDoubleC(it->attribute("CBASE"), 0.0) * 10);
1765 int shX = qRound(ScCLocale::toDoubleC(it->attribute("CSHX"), 5.0) * 10);
1766 int shY = qRound(ScCLocale::toDoubleC(it->attribute("CSHY"), -5.0) * 10);
1767 int outL = qRound(ScCLocale::toDoubleC(it->attribute("COUT"), 1.0) * 10);
1768 int ulp = qRound(ScCLocale::toDoubleC(it->attribute("CULP"), -0.1) * 10);
1769 int ulw = qRound(ScCLocale::toDoubleC(it->attribute("CULW"), -0.1) * 10);
1770 int stp = qRound(ScCLocale::toDoubleC(it->attribute("CSTP"), -0.1) * 10);
1771 int stw = qRound(ScCLocale::toDoubleC(it->attribute("CSTW"), -0.1) * 10);
1772
1773 CharStyle style;
1774 style.setFont((*doc->AllFonts)[tmpf]);
1775 style.setFontSize(size);
1776 style.setFillColor(fcolor);
1777 style.setTracking(extra);
1778 style.setFillShade(shade);
1779 style.setFeatures(static_cast<StyleFlag>(cstyle).featureList());
1780 style.setStrokeColor(stroke);
1781 style.setStrokeShade(shade2);
1782 style.setScaleH(qMin(qMax(scale, 100), 4000));
1783 style.setScaleV(qMin(qMax(scalev, 100), 4000));
1784 style.setBaselineOffset(base);
1785 style.setShadowXOffset(shX);
1786 style.setShadowYOffset(shY);
1787 style.setOutlineWidth(outL);
1788 style.setUnderlineOffset(ulp);
1789 style.setUnderlineWidth(ulw);
1790 style.setStrikethruOffset(stp);
1791 style.setStrikethruWidth(stw);
1792
1793 int pos = obj->itemText.length();
1794 if (style != last->Style) {
1795 last->Style = style;
1796 last->StyleStart = pos;
1797 }
1798
1799
1800 for (int cxx=0; cxx<tmp2.length(); ++cxx)
1801 {
1802 QChar ch = tmp2.at(cxx);
1803 if (ch == QChar(5))
1804 ch = SpecialChars::PARSEP;
1805 if (ch == QChar(4))
1806 ch = SpecialChars::TAB;
1807 int pos = obj->itemText.length();
1808 obj->itemText.insertChars(pos, QString(ch));
1809
1810 if (ch == SpecialChars::PARSEP || cxx+1 == tmp2.length()) {
1811 // qDebug() << QString("scribus12 para: %1 %2 %3 %4").arg(ab)
1812 // .arg(ab < signed(DoVorl.size())? DoVorl[ab] : QString("./."))
1813 // .arg(VorLFound).arg(DoVorl.size());
1814 ParagraphStyle pstyle;
1815 if (ab < 5) {
1816 pstyle.setAlignment(static_cast<ParagraphStyle::AlignmentType>(ab));
1817 }
1818 else if (VorLFound) {
1819 pstyle.setParent( DoVorl[ab] );
1820 }
1821 obj->itemText.applyStyle(pos, pstyle);
1822 }
1823 }
1824 obj->itemText.applyCharStyle(last->StyleStart, obj->itemText.length()-last->StyleStart, last->Style);
1825 }
1826
loadPage(const QString & fileName,int pageNumber,bool Mpage,const QString &)1827 bool Scribus12Format::loadPage(const QString & fileName, int pageNumber, bool Mpage, const QString& /*renamedPageName*/)
1828 {
1829 // qDebug() << QString("loading page %2 from file '%1' from 1.2.x plugin").arg(fileName).arg(pageNumber);
1830 if (m_Doc==nullptr || m_View==nullptr || m_AvailableFonts==nullptr)
1831 {
1832 Q_ASSERT(m_Doc==nullptr || m_View==nullptr|| m_AvailableFonts==nullptr);
1833 return false;
1834 }
1835
1836 struct CopyPasteBuffer OB;
1837 ParagraphStyle vg;
1838 struct ScribusDoc::BookMa bok;
1839 PageItem *newItem;
1840 groupRemap.clear();
1841 itemRemap.clear();
1842 itemNext.clear();
1843 QString tmp, tmpf;
1844 QMap<int,int> TableID;
1845 QList<PageItem*> TableItems;
1846 int x, a, counter; //, baseobj;
1847 bool newVersion = false;
1848 bool VorLFound = false;
1849 QMap<int,int> layerTrans;
1850 int maxLayer = 0;
1851 int maxLevel = 0;
1852 layerTrans.clear();
1853 uint layerCount=m_Doc->layerCount();
1854 for (uint la2 = 0; la2 < layerCount; ++la2)
1855 {
1856 maxLayer = qMax(m_Doc->Layers[la2].ID, maxLayer);
1857 maxLevel = qMax(m_Doc->Layers[la2].Level, maxLevel);
1858 }
1859 DoVorl.clear();
1860 DoVorl[0] = "";
1861 DoVorl[1] = "";
1862 DoVorl[2] = "";
1863 DoVorl[3] = "";
1864 DoVorl[4] = "";
1865 VorlC = 5;
1866 QDomDocument docu("scridoc");
1867 QString f(readSLA(fileName));
1868 if (f.isEmpty())
1869 {
1870 setFileReadError();
1871 return false;
1872 }
1873 QString errorMsg;
1874 int errorLine, errorColumn;
1875 if (!docu.setContent(f, &errorMsg, &errorLine, &errorColumn))
1876 {
1877 setDomParsingError(errorMsg, errorLine, errorColumn);
1878 return false;
1879 }
1880 QString fileDir = QFileInfo(fileName).absolutePath();
1881 ScColor lf = ScColor();
1882 QDomElement elem=docu.documentElement();
1883 if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
1884 return false;
1885 if (elem.hasAttribute("Version"))
1886 newVersion = true;
1887 QDomNode docNode = elem.firstChild();
1888 while (!docNode.isNull())
1889 {
1890 QDomElement dc = docNode.toElement();
1891 /*
1892 * Attribute von DOCUMENT auslesen
1893 */
1894 QDomNode pageNode = docNode.firstChild();
1895 while (!pageNode.isNull())
1896 {
1897 QDomElement pg = pageNode.toElement();
1898 // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
1899 if (pg.tagName() == "COLOR" && pg.attribute("NAME") != CommonStrings::None)
1900 {
1901 if (pg.hasAttribute("CMYK"))
1902 lf.setNamedColor(pg.attribute("CMYK"));
1903 else
1904 lf.fromQColor(QColor(pg.attribute("RGB")));
1905 lf.setSpotColor(false);
1906 lf.setRegistrationColor(false);
1907 m_Doc->PageColors.insert(pg.attribute("NAME"), lf);
1908 }
1909 if (pg.tagName() == "STYLE")
1910 {
1911 GetStyle(&pg, &vg, nullptr, m_Doc, true);
1912 VorLFound = true;
1913 }
1914 if (pg.tagName() == "JAVA")
1915 m_Doc->JavaScripts[pg.attribute("NAME")] = pg.attribute("SCRIPT");
1916 if (pg.tagName() == "LAYERS")
1917 {
1918 int lId = pg.attribute("NUMMER").toInt();
1919 int level = pg.attribute("LEVEL").toInt();
1920 ScLayer la( pg.attribute("NAME"), level, lId );
1921 la.isViewable = pg.attribute("SICHTBAR").toInt();
1922 la.isPrintable = pg.attribute("DRUCKEN").toInt();
1923 la.flowControl = true;
1924 const ScLayer* la2 = m_Doc->Layers.layerByName(la.Name);
1925 if (la2)
1926 layerTrans.insert(la.ID, la2->ID);
1927 else
1928 {
1929 maxLayer++;
1930 maxLevel++;
1931 layerTrans.insert(la.ID, maxLayer);
1932 la.ID = maxLayer;
1933 la.Level = maxLevel;
1934 m_Doc->Layers.append(la);
1935 }
1936 }
1937 if (pg.tagName() == "MultiLine")
1938 {
1939 multiLine ml;
1940 QDomNode MuLn = pageNode.firstChild();
1941 while (!MuLn.isNull())
1942 {
1943 QDomElement MuL = MuLn.toElement();
1944 struct SingleLine sl;
1945 sl.Color = MuL.attribute("Color");
1946 sl.Dash = MuL.attribute("Dash").toInt();
1947 sl.LineEnd = MuL.attribute("LineEnd").toInt();
1948 sl.LineJoin = MuL.attribute("LineJoin").toInt();
1949 sl.Shade = MuL.attribute("Shade").toInt();
1950 sl.Width = ScCLocale::toDoubleC(MuL.attribute("Width"));
1951 ml.push_back(sl);
1952 MuLn = MuLn.nextSibling();
1953 }
1954 QString mlName = pg.attribute("Name");
1955 QString mlName2 = mlName;
1956 QHash<QString,multiLine>::ConstIterator mlit = m_Doc->docLineStyles.find(mlName2);
1957 if (mlit != m_Doc->docLineStyles.constEnd() && ml != mlit.value())
1958 mlName2 = getUniqueName(mlName2, m_Doc->docLineStyles);
1959 m_Doc->docLineStyles.insert(mlName2, ml);
1960 }
1961 if ((pg.tagName() == "PAGE") && (pg.attribute("NUM").toInt() == pageNumber))
1962 {
1963 a = m_Doc->currentPage()->pageNr();
1964 if (Mpage)
1965 {
1966 if (pg.attribute("NAM", "").isEmpty())
1967 {
1968 pageNode = pageNode.nextSibling();
1969 continue;
1970 }
1971 }
1972 else
1973 {
1974 if (!pg.attribute("NAM", "").isEmpty())
1975 {
1976 pageNode = pageNode.nextSibling();
1977 continue;
1978 }
1979 }
1980 /* if ((pg.attribute("NAM", "").isEmpty()) && (Mpage))
1981 {
1982 pageNode = pageNode.nextSibling();
1983 continue;
1984 } */
1985 if (Mpage)
1986 {
1987 m_Doc->Pages->at(a)->LeftPg=pg.attribute("LEFT", "0").toInt();
1988 m_Doc->Pages->at(a)->setPageName(pg.attribute("NAM",""));
1989 }
1990 TableItems.clear();
1991 TableID.clear();
1992 /*
1993 * Attribute von PAGE auslesen
1994 */
1995 tmp = "";
1996 GuideManagerIO::readVerticalGuides(pg.attribute("VerticalGuides"),
1997 m_Doc->Pages->at(a),
1998 GuideManagerCore::Standard,
1999 pg.hasAttribute("NumVGuides"));
2000 GuideManagerIO::readHorizontalGuides(pg.attribute("HorizontalGuides"),
2001 m_Doc->Pages->at(a),
2002 GuideManagerCore::Standard,
2003 pg.hasAttribute("NumHGuides"));
2004 m_Doc->Pages->at(a)->marginPreset = pg.attribute("PRESET", "0").toInt();
2005
2006 QDomNode objNode = pageNode.firstChild();
2007 counter = m_Doc->Items->count();
2008 // baseobj = counter;
2009 int pageItem = 0;
2010 while (!objNode.isNull())
2011 {
2012 QDomElement obj = objNode.toElement();
2013 /*
2014 * Attribute von OBJECT auslesen
2015 */
2016 itemRemap[scribus12itemID(pageItem++, pageNumber)] = m_Doc->Items->count();
2017 if (obj.tagName() == "PAGEOBJECT")
2018 {
2019 // member of linked chain?
2020 if ((obj.attribute("NEXTITEM").toInt() != -1) && (obj.attribute("NEXTPAGE").toInt() == pageNumber))
2021 {
2022 itemNext[m_Doc->Items->count()] = scribus12itemID(obj.attribute("NEXTITEM").toInt(), pageNumber);
2023 }
2024 }
2025 GetItemProps(&obj, &OB, fileDir, newVersion);
2026 OB.Xpos = ScCLocale::toDoubleC(obj.attribute("XPOS"))+m_Doc->Pages->at(a)->xOffset();
2027 OB.Ypos=ScCLocale::toDoubleC(obj.attribute("YPOS"))+m_Doc->Pages->at(a)->yOffset();
2028 OB.NamedLStyle = obj.attribute("NAMEDLST", "");
2029 if (!m_Doc->docLineStyles.contains(OB.NamedLStyle))
2030 OB.NamedLStyle = "";
2031 OB.startArrowIndex = 0;
2032 OB.endArrowIndex = 0;
2033 OB.startArrowScale = 100;
2034 OB.endArrowScale = 100;
2035 OB.isBookmark = obj.attribute("BOOKMARK").toInt();
2036 OB.textAlignment = obj.attribute("ALIGN", "0").toInt();
2037 tmpf = obj.attribute("IFONT", m_Doc->itemToolPrefs().textFont);
2038 if (tmpf.isEmpty())
2039 tmpf = m_Doc->itemToolPrefs().textFont;
2040 m_AvailableFonts->findFont(tmpf, m_Doc);
2041 OB.IFont = tmpf;
2042 OB.LayerID = layerTrans[obj.attribute("LAYER", "0").toInt()];
2043 OB.Language = obj.attribute("LANGUAGE", m_Doc->language());
2044 tmp = "";
2045 if ((obj.hasAttribute("GROUPS")) && (obj.attribute("NUMGROUP", "0").toInt() != 0))
2046 {
2047 int groupMax = m_Doc->GroupCounter;
2048 QMap<int, int>::ConstIterator gIt;
2049 tmp = obj.attribute("GROUPS");
2050 ScTextStream fg(&tmp, QIODevice::ReadOnly);
2051 OB.Groups.clear();
2052 for (int cx = 0; cx < obj.attribute("NUMGROUP", "0").toInt(); ++cx)
2053 {
2054 fg >> x;
2055 gIt = groupRemap.constFind(x);
2056 if (gIt != groupRemap.constEnd())
2057 OB.Groups.push(gIt.value());
2058 else
2059 {
2060 OB.Groups.push(groupMax);
2061 groupRemap.insert(x, groupMax);
2062 ++groupMax;
2063 }
2064 }
2065 m_Doc->GroupCounter = groupMax;
2066 tmp = "";
2067 }
2068 else
2069 OB.Groups.clear();
2070 QDomNode node = objNode.firstChild();
2071 while (!node.isNull())
2072 {
2073 QDomElement it = node.toElement();
2074 if (it.tagName() == "CSTOP")
2075 {
2076 QString name = it.attribute("NAME");
2077 double ramp = ScCLocale::toDoubleC(it.attribute("RAMP"), 0.0);
2078 int shade = it.attribute("SHADE", "100").toInt();
2079 double opa = ScCLocale::toDoubleC(it.attribute("TRANS"), 1.0);
2080 handleOldColorShade(m_Doc, name, shade);
2081 OB.fill_gradient.addStop(SetColor(m_Doc, name, shade), ramp, 0.5, opa, name, shade);
2082 OB.GrColor = "";
2083 OB.GrColor2 = "";
2084 }
2085 node = node.nextSibling();
2086 }
2087 OB.itemText = "";
2088 PasteItem(&OB);
2089 newItem = m_Doc->Items->at(counter);
2090 node = objNode.firstChild();
2091 LastStyles* last = new LastStyles();
2092 while (!node.isNull())
2093 {
2094 QDomElement it = node.toElement();
2095 if (it.tagName() == "ITEXT")
2096 GetItemText(&it, m_Doc, VorLFound, true, newItem, last);
2097 node = node.nextSibling();
2098 }
2099 delete last;
2100
2101 // if (obj.attribute("NEXTPAGE").toInt() == pageNumber)
2102 // {
2103 // newItem->NextIt = baseobj + obj.attribute("NEXTITEM").toInt();
2104 // nextPg[newItem->ItemNr] = a; // obj.attribute("NEXTPAGE").toInt();
2105 // }
2106 // else
2107 // newItem->NextIt = -1;
2108 if (newItem->isTableItem)
2109 {
2110 TableItems.append(newItem);
2111 TableID.insert(obj.attribute("OwnLINK", "0").toInt(), counter);
2112 }
2113 counter++;
2114 objNode = objNode.nextSibling();
2115 }
2116 if (TableItems.count() != 0)
2117 {
2118 for (int ttc = 0; ttc < TableItems.count(); ++ttc)
2119 {
2120 PageItem* ta = TableItems.at(ttc);
2121 if (ta->TopLinkID != -1)
2122 ta->m_topLink = m_Doc->Items->at(TableID[ta->TopLinkID]);
2123 else
2124 ta->m_topLink = nullptr;
2125 if (ta->LeftLinkID != -1)
2126 ta->m_leftLink = m_Doc->Items->at(TableID[ta->LeftLinkID]);
2127 else
2128 ta->m_leftLink = nullptr;
2129 if (ta->RightLinkID != -1)
2130 ta->m_rightLink = m_Doc->Items->at(TableID[ta->RightLinkID]);
2131 else
2132 ta->m_rightLink = nullptr;
2133 if (ta->BottomLinkID != -1)
2134 ta->m_bottomLink = m_Doc->Items->at(TableID[ta->BottomLinkID]);
2135 else
2136 ta->m_bottomLink = nullptr;
2137 }
2138 }
2139 // reestablish textframe links
2140 if (itemNext.count() != 0)
2141 {
2142 QMap<int,long long>::Iterator lc;
2143 for (lc = itemNext.begin(); lc != itemNext.end(); ++lc)
2144 {
2145 PageItem *Its = m_Doc->Items->at(lc.key());
2146 PageItem *Itn = m_Doc->Items->at(itemRemap[lc.value()]);
2147 assert(Its && Its->asTextFrame());
2148 assert(Itn && Itn->asTextFrame());
2149 if (!Its->canBeLinkedTo(Itn))
2150 {
2151 qDebug("scribus12format: corruption in linked textframes detected");
2152 continue;
2153 }
2154 Its->link(Itn);
2155 }
2156 }
2157
2158 // fix legacy char formatting
2159 for (int i = 0; i < m_Doc->DocItems.count(); ++i)
2160 {
2161 PageItem* item = m_Doc->DocItems.at(i);
2162 if (item->prevInChain() == nullptr && item->itemText.length() > 0)
2163 item->itemText.fixLegacyFormatting();
2164 }
2165 for (int i = 0; i < m_Doc->MasterItems.count(); ++i)
2166 {
2167 PageItem* item = m_Doc->MasterItems.at(i);
2168 if (item->prevInChain() == nullptr && item->itemText.length() > 0)
2169 item->itemText.fixLegacyFormatting();
2170 }
2171 for (auto itf = m_Doc->FrameItems.begin(); itf != m_Doc->FrameItems.end(); ++itf)
2172 {
2173 PageItem *item = itf.value();
2174 if (item->prevInChain() == nullptr && item->itemText.length() > 0)
2175 item->itemText.fixLegacyFormatting();
2176 }
2177 for (int i = 0; i < m_Doc->DocItems.count(); ++i)
2178 {
2179 QList<PageItem*> allItems;
2180 PageItem* item = m_Doc->DocItems.at(i);
2181 if (item->isGroup())
2182 allItems = item->getAllChildren();
2183 else
2184 allItems.append(item);
2185 for (int ii = 0; ii < allItems.count(); ii++)
2186 {
2187 PageItem* gItem = allItems[ii];
2188 if (gItem->isGroup() && gItem->groupItemList[0]->isTableItem)
2189 {
2190 if (gItem->isGroupChild())
2191 convertOldTable(m_Doc, gItem, gItem->groupItemList, nullptr, &(gItem->asGroupFrame()->groupItemList));
2192 else
2193 convertOldTable(m_Doc, gItem, gItem->groupItemList, nullptr, &m_Doc->DocItems);
2194 }
2195 }
2196 allItems.clear();
2197 }
2198 for (int i = 0; i < m_Doc->MasterItems.count(); ++i)
2199 {
2200 QList<PageItem*> allItems;
2201 PageItem* item = m_Doc->MasterItems.at(i);
2202 if (item->isGroup())
2203 allItems = item->getAllChildren();
2204 else
2205 allItems.append(item);
2206 for (int ii = 0; ii < allItems.count(); ii++)
2207 {
2208 PageItem* gItem = allItems[ii];
2209 if (gItem->isGroup() && gItem->groupItemList[0]->isTableItem)
2210 {
2211 if (gItem->isGroupChild())
2212 convertOldTable(m_Doc, gItem, gItem->groupItemList, nullptr, &(gItem->asGroupFrame()->groupItemList));
2213 else
2214 convertOldTable(m_Doc, gItem, gItem->groupItemList, nullptr, &m_Doc->MasterItems);
2215 }
2216 }
2217 allItems.clear();
2218 }
2219
2220 if (!Mpage)
2221 m_View->reformPages();
2222 pageNode = docNode.firstChild();
2223 while (!pageNode.isNull())
2224 {
2225 QDomElement pg = pageNode.toElement();
2226 if (pg.tagName() == "Bookmark")
2227 {
2228 int elem = pg.attribute("Element").toInt();
2229 if (elem < m_Doc->Items->count())
2230 {
2231 bok.Title = pg.attribute("Title");
2232 bok.Text = pg.attribute("Text");
2233 bok.Aktion = pg.attribute("Aktion");
2234 bok.ItemNr = pg.attribute("ItemNr").toInt();
2235 bok.PageObject = m_Doc->Items->at(elem);
2236 bok.First = pg.attribute("First").toInt();
2237 bok.Last = pg.attribute("Last").toInt();
2238 bok.Prev = pg.attribute("Prev").toInt();
2239 bok.Next = pg.attribute("Next").toInt();
2240 bok.Parent = pg.attribute("Parent").toInt();
2241 m_Doc->BookMarks.append(bok);
2242 }
2243 }
2244 pageNode = pageNode.nextSibling();
2245 }
2246 return true;
2247 }
2248 pageNode = pageNode.nextSibling();
2249 }
2250 docNode = docNode.nextSibling();
2251 }
2252 return false;
2253 }
2254
GetStyle(QDomElement * pg,ParagraphStyle * vg,StyleSet<ParagraphStyle> * tempParagraphStyles,ScribusDoc * doc,bool fl)2255 void Scribus12Format::GetStyle(QDomElement *pg, ParagraphStyle *vg, StyleSet<ParagraphStyle> * tempParagraphStyles, ScribusDoc* doc, bool fl)
2256 {
2257 int fShade, sShade;
2258 QString fColor, sColor;
2259 QString tmpf;
2260 double xf, xf2;
2261 bool found = false;
2262 const StyleSet<ParagraphStyle> & docParagraphStyles(tempParagraphStyles? *tempParagraphStyles : doc->paragraphStyles());
2263
2264 vg->setName(pg->attribute("NAME"));
2265 vg->setLineSpacingMode(static_cast<ParagraphStyle::LineSpacingMode>(pg->attribute("LINESPMode", "0").toInt()));
2266 vg->setLineSpacing(ScCLocale::toDoubleC(pg->attribute("LINESP")));
2267 vg->setLeftMargin(ScCLocale::toDoubleC(pg->attribute("INDENT"), 0.0));
2268 vg->setFirstIndent(ScCLocale::toDoubleC(pg->attribute("FIRST"), 0.0));
2269 vg->setAlignment(static_cast<ParagraphStyle::AlignmentType>(pg->attribute("ALIGN").toInt()));
2270 vg->setGapBefore(ScCLocale::toDoubleC(pg->attribute("VOR"), 0.0));
2271 vg->setGapAfter(ScCLocale::toDoubleC(pg->attribute("NACH"), 0.0));
2272 tmpf = pg->attribute("FONT", doc->itemToolPrefs().textFont);
2273 if (tmpf.isEmpty())
2274 tmpf = doc->itemToolPrefs().textFont;
2275 PrefsManager& prefsManager=PrefsManager::instance();
2276 prefsManager.appPrefs.fontPrefs.AvailFonts.findFont(tmpf, doc);
2277 vg->charStyle().setFont(prefsManager.appPrefs.fontPrefs.AvailFonts[tmpf]);
2278 vg->charStyle().setFontSize(qRound(ScCLocale::toDoubleC(pg->attribute("FONTSIZE"), 12.0) * 10.0));
2279 vg->setHasDropCap(static_cast<bool>(pg->attribute("DROP", "0").toInt()));
2280 vg->setDropCapLines(pg->attribute("DROPLIN", "2").toInt());
2281 vg->setParEffectOffset(ScCLocale::toDoubleC(pg->attribute("DROPDIST"), 0.0));
2282 vg->charStyle().setFeatures(static_cast<StyleFlag>((pg->attribute("EFFECT", "0").toInt())).featureList());
2283 fColor = pg->attribute("FCOLOR", doc->itemToolPrefs().shapeFillColor);
2284 fShade = pg->attribute("FSHADE", "100").toInt();
2285 handleOldColorShade(doc, fColor, fShade);
2286 sColor = pg->attribute("SCOLOR", doc->itemToolPrefs().shapeLineColor);
2287 sShade = pg->attribute("SSHADE", "100").toInt();
2288 handleOldColorShade(doc, sColor, sShade);
2289 vg->charStyle().setFillColor(fColor);
2290 vg->charStyle().setFillShade(fShade);
2291 vg->charStyle().setStrokeColor(sColor);
2292 vg->charStyle().setStrokeShade(sShade);
2293 if (static_cast<bool>(pg->attribute("BASE", "0").toInt()))
2294 vg->setLineSpacingMode(ParagraphStyle::BaselineGridLineSpacing);
2295 vg->charStyle().setShadowXOffset(qRound(ScCLocale::toDoubleC(pg->attribute("TXTSHX"), 5.0) * 10));
2296 vg->charStyle().setShadowYOffset(qRound(ScCLocale::toDoubleC(pg->attribute("TXTSHY"), -5.0) * 10));
2297 vg->charStyle().setOutlineWidth(qRound(ScCLocale::toDoubleC(pg->attribute("TXTOUT"), 1.0) * 10));
2298 vg->charStyle().setUnderlineOffset(qRound(ScCLocale::toDoubleC(pg->attribute("TXTULP"), -0.1) * 10));
2299 vg->charStyle().setUnderlineWidth(qRound(ScCLocale::toDoubleC(pg->attribute("TXTULW"), -0.1) * 10));
2300 vg->charStyle().setStrikethruOffset(qRound(ScCLocale::toDoubleC(pg->attribute("TXTSTP"), -0.1) * 10));
2301 vg->charStyle().setStrikethruWidth(qRound(ScCLocale::toDoubleC(pg->attribute("TXTSTW"), -0.1) * 10));
2302 vg->charStyle().setScaleH(qRound(ScCLocale::toDoubleC(pg->attribute("SCALEH"), 100.0) * 10));
2303 vg->charStyle().setScaleV(qRound(ScCLocale::toDoubleC(pg->attribute("SCALEV"), 100.0) * 10));
2304 vg->charStyle().setBaselineOffset(qRound(ScCLocale::toDoubleC(pg->attribute("BASEO"), 0.0) * 10));
2305 vg->charStyle().setTracking(qRound(ScCLocale::toDoubleC(pg->attribute("KERN"), 0.0) * 10));
2306 // vg->tabValues().clear();
2307 if ((pg->hasAttribute("NUMTAB")) && (pg->attribute("NUMTAB", "0").toInt() != 0))
2308 {
2309 QList<ParagraphStyle::TabRecord> tbs;
2310 ParagraphStyle::TabRecord tb;
2311 QString tmp = pg->attribute("TABS");
2312 ScTextStream tgv(&tmp, QIODevice::ReadOnly);
2313 for (int cxv = 0; cxv < pg->attribute("NUMTAB", "0").toInt(); cxv += 2)
2314 {
2315 tgv >> xf;
2316 tgv >> xf2;
2317 tb.tabPosition = xf2;
2318 tb.tabType = static_cast<int>(xf);
2319 tb.tabFillChar = QChar();
2320 tbs.append(tb);
2321 }
2322 vg->setTabValues(tbs);
2323 tmp.clear();
2324 }
2325 else
2326 {
2327 QList<ParagraphStyle::TabRecord> tbs;
2328 QDomNode node = pg->firstChild();
2329 while (!node.isNull())
2330 {
2331 QDomElement it = node.toElement();
2332 if (it.tagName() == "Tabs")
2333 {
2334 ParagraphStyle::TabRecord tb;
2335 tb.tabPosition = ScCLocale::toDoubleC(it.attribute("Pos"));
2336 tb.tabType = it.attribute("Type").toInt();
2337 QString tbCh = "";
2338 tbCh = it.attribute("Fill","");
2339 if (tbCh.isEmpty())
2340 tb.tabFillChar = QChar();
2341 else
2342 tb.tabFillChar = tbCh[0];
2343 tbs.append(tb);
2344 }
2345 vg->setTabValues(tbs);
2346 node = node.nextSibling();
2347 }
2348 }
2349 for (int i = 0; i < docParagraphStyles.count(); ++i)
2350 {
2351 const ParagraphStyle& paraStyle = docParagraphStyles[i];
2352 if (vg->name() == paraStyle.name())
2353 {
2354 //Compare the attributes of the pasted styles vs existing ones
2355 if (vg->equiv(paraStyle))
2356 {
2357 if (fl)
2358 {
2359 DoVorl[VorlC] = paraStyle.name();
2360 VorlC++;
2361 }
2362 found = true;
2363 }
2364 else
2365 {
2366 vg->setName(docParagraphStyles.getUniqueCopyName(paraStyle.name()));
2367 found = false;
2368 }
2369 break;
2370 }
2371 }
2372 if (!found)
2373 {
2374 for (int i = 0; i < docParagraphStyles.count(); ++i)
2375 {
2376 const ParagraphStyle& paraStyle = docParagraphStyles[i];
2377 if (vg->equiv(paraStyle))
2378 {
2379 vg->setName(paraStyle.name());
2380 found = true;
2381 if (fl)
2382 {
2383 DoVorl[VorlC] = paraStyle.name();
2384 VorlC++;
2385 }
2386 break;
2387 }
2388 }
2389 }
2390 if (!found)
2391 {
2392 if (tempParagraphStyles)
2393 tempParagraphStyles->create(*vg);
2394 else {
2395 StyleSet<ParagraphStyle> temp;
2396 temp.create(*vg);
2397 doc->redefineStyles(temp, false);
2398 }
2399 if (fl)
2400 {
2401 DoVorl[VorlC] = vg->name();
2402 VorlC++;
2403 }
2404 }
2405 }
2406
readStyles(const QString & fileName,ScribusDoc * doc,StyleSet<ParagraphStyle> & docParagraphStyles)2407 bool Scribus12Format::readStyles(const QString& fileName, ScribusDoc* doc, StyleSet<ParagraphStyle> &docParagraphStyles)
2408 {
2409 ParagraphStyle pstyle;
2410 QDomDocument docu("scridoc");
2411 QString f (readSLA(fileName));
2412 if (f.isEmpty())
2413 return false;
2414 if (!docu.setContent(f))
2415 return false;
2416 QDomElement elem = docu.documentElement();
2417 if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
2418 return false;
2419 QDomNode docNode = elem.firstChild();
2420 while (!docNode.isNull())
2421 {
2422 QDomElement dc = docNode.toElement();
2423 QDomNode pageNode = docNode.firstChild();
2424 while (!pageNode.isNull())
2425 {
2426 QDomElement pg = pageNode.toElement();
2427 if (pg.tagName() == "STYLE")
2428 {
2429 pstyle.erase();
2430 GetStyle(&pg, &pstyle, &docParagraphStyles, doc, false);
2431 }
2432 pageNode = pageNode.nextSibling();
2433 }
2434 docNode = docNode.nextSibling();
2435 }
2436 return true;
2437 }
2438
readLineStyles(const QString & fileName,QHash<QString,multiLine> * Sty)2439 bool Scribus12Format::readLineStyles(const QString& fileName, QHash<QString,multiLine> *Sty)
2440 {
2441 QDomDocument docu("scridoc");
2442 QString f(readSLA(fileName));
2443 if (f.isEmpty())
2444 return false;
2445 if (!docu.setContent(f))
2446 return false;
2447 QDomElement elem=docu.documentElement();
2448 if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
2449 return false;
2450 QDomNode docNode = elem.firstChild();
2451 while (!docNode.isNull())
2452 {
2453 QDomElement dc = docNode.toElement();
2454 QDomNode pageNode = docNode.firstChild();
2455 while (!pageNode.isNull())
2456 {
2457 QDomElement pg = pageNode.toElement();
2458 if (pg.tagName() == "MultiLine")
2459 {
2460 multiLine ml;
2461 QDomNode MuLn = pageNode.firstChild();
2462 while (!MuLn.isNull())
2463 {
2464 QDomElement MuL = MuLn.toElement();
2465 struct SingleLine sl;
2466 sl.Color = MuL.attribute("Color");
2467 sl.Dash = MuL.attribute("Dash").toInt();
2468 sl.LineEnd = MuL.attribute("LineEnd").toInt();
2469 sl.LineJoin = MuL.attribute("LineJoin").toInt();
2470 sl.Shade = MuL.attribute("Shade").toInt();
2471 sl.Width = ScCLocale::toDoubleC(MuL.attribute("Width"));
2472 ml.push_back(sl);
2473 MuLn = MuLn.nextSibling();
2474 }
2475 QString Nam(pg.attribute("Name"));
2476 QString Nam2(Nam);
2477 int copyC = 1;
2478 QHash<QString,multiLine>::ConstIterator mlit = Sty->find(Nam2);
2479 if (mlit != Sty->constEnd() && ml != mlit.value())
2480 {
2481 while (Sty->contains(Nam2))
2482 {
2483 Nam2 = tr("Copy #%1 of ").arg(copyC)+Nam;
2484 copyC++;
2485 }
2486 }
2487 Sty->insert(Nam2, ml);
2488 }
2489 pageNode = pageNode.nextSibling();
2490 }
2491 docNode = docNode.nextSibling();
2492 }
2493 return true;
2494 }
2495
2496
readColors(const QString & fileName,ColorList & colors)2497 bool Scribus12Format::readColors(const QString& fileName, ColorList & colors)
2498 {
2499 QString f(readSLA(fileName));
2500 if (f.isEmpty())
2501 return false;
2502 QDomDocument docu("scridoc");
2503 if (!docu.setContent(f))
2504 return false;
2505 colors.clear();
2506 ScColor lf = ScColor();
2507 QDomElement elem=docu.documentElement();
2508 if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
2509 return false;
2510 QDomNode docNode = elem.firstChild();
2511 while (!docNode.isNull())
2512 {
2513 QDomElement dc = docNode.toElement();
2514 QDomNode pageNode = docNode.firstChild();
2515 while (!pageNode.isNull())
2516 {
2517 QDomElement pg = pageNode.toElement();
2518 // 10/25/2004 pv - None is "reserved" color. cannot be defined in any file...
2519 if (pg.tagName() == "COLOR" && pg.attribute("NAME") != CommonStrings::None)
2520 {
2521 if (pg.hasAttribute("CMYK"))
2522 lf.setNamedColor(pg.attribute("CMYK"));
2523 else
2524 lf.fromQColor(QColor(pg.attribute("RGB")));
2525 if (pg.hasAttribute("Spot"))
2526 lf.setSpotColor(static_cast<bool>(pg.attribute("Spot").toInt()));
2527 else
2528 lf.setSpotColor(false);
2529 if (pg.hasAttribute("Register"))
2530 lf.setRegistrationColor(static_cast<bool>(pg.attribute("Register").toInt()));
2531 else
2532 lf.setRegistrationColor(false);
2533 colors.insert(pg.attribute("NAME"), lf);
2534 }
2535 pageNode = pageNode.nextSibling();
2536 }
2537 docNode = docNode.nextSibling();
2538 }
2539 return true;
2540 }
2541
readPageCount(const QString & fileName,int * num1,int * num2,QStringList & masterPageNames)2542 bool Scribus12Format::readPageCount(const QString& fileName, int *num1, int *num2, QStringList & masterPageNames)
2543 {
2544 QString pageName;
2545 int counter = 0;
2546 int counter2 = 0;
2547 QDomDocument docu("scridoc");
2548 QString f(readSLA(fileName));
2549 if (f.isEmpty())
2550 return false;
2551 if (!docu.setContent(f))
2552 return false;
2553 QDomElement elem=docu.documentElement();
2554 if ((elem.tagName() != "SCRIBUS") && (elem.tagName() != "SCRIBUSUTF8"))
2555 return false;
2556 QDomNode docNode = elem.firstChild();
2557 while (!docNode.isNull())
2558 {
2559 QDomNode pageNode = docNode.firstChild();
2560 while (!pageNode.isNull())
2561 {
2562 QDomElement pg = pageNode.toElement();
2563 if (pg.tagName() == "PAGE")
2564 {
2565 pageName = pg.attribute("NAM", "");
2566 if (pageName.isEmpty())
2567 counter++;
2568 else
2569 {
2570 counter2++;
2571 masterPageNames.append(pageName);
2572 }
2573 }
2574 pageNode = pageNode.nextSibling();
2575 }
2576 docNode = docNode.nextSibling();
2577 }
2578 *num1 = counter;
2579 *num2 = counter2;
2580 return true;
2581 }
2582