r14347 by fschmid - HASH(0x8a630ac)
scribus-commit
scribus-commit at lists.scribus.net
Wed Nov 25 10:20:37 CET 2009
Revision: 14347
Author: fschmid
Date: 2009-11-25T00:05:17.930678Z
Commit message: HASH(0x8a630ac)
Changeset:
A /trunk/Scribus/scribus/plugins/import/aiimplugin
A /trunk/Scribus/scribus/plugins/import
M /trunk/Scribus/scribus/plugins/CMakeLists.txt
A /trunk/Scribus/scribus/plugins/import/CMakeLists.txt
Diffs:
Index: scribus/plugins/import/CMakeLists.txt
===================================================================
--- scribus/plugins/import/CMakeLists.txt (revision 0)
+++ scribus/plugins/import/CMakeLists.txt (revision 14347)
@@ -0,0 +1,2 @@
+ADD_SUBDIRECTORY(aiimplugin)
+
Index: scribus/plugins/import/aiimplugin/importaiplugin.cpp
===================================================================
--- scribus/plugins/import/aiimplugin/importaiplugin.cpp (revision 0)
+++ scribus/plugins/import/aiimplugin/importaiplugin.cpp (revision 14347)
@@ -0,0 +1,165 @@
+/*
+For general Scribus (>=1.3.2) copyright and licensing information please refer
+to the COPYING file provided with the program. Following this notice may exist
+a copyright and/or license notice that predates the release of Scribus 1.3.2
+for which a new license (GPL+exception) is in place.
+*/
+#include "commonstrings.h"
+#include "ui/customfdialog.h"
+#include "importai.h"
+#include "importaiplugin.h"
+#include "menumanager.h"
+#include "page.h"
+#include "prefscontext.h"
+#include "prefsfile.h"
+#include "prefsmanager.h"
+#include "scraction.h"
+#include "scribuscore.h"
+#include "undomanager.h"
+#include "util_formats.h"
+
+
+int importai_getPluginAPIVersion()
+{
+ return PLUGIN_API_VERSION;
+}
+
+ScPlugin* importai_getPlugin()
+{
+ ImportAIPlugin* plug = new ImportAIPlugin();
+ Q_CHECK_PTR(plug);
+ return plug;
+}
+
+void importai_freePlugin(ScPlugin* plugin)
+{
+ ImportAIPlugin* plug = dynamic_cast<ImportAIPlugin*>(plugin);
+ Q_ASSERT(plug);
+ delete plug;
+}
+
+ImportAIPlugin::ImportAIPlugin() : LoadSavePlugin(),
+ importAction(new ScrAction(ScrAction::DLL, QPixmap(), QPixmap(), "", QKeySequence(), this))
+{
+ // Set action info in languageChange, so we only have to do it in one
+ // place. This includes registering file format support.
+ languageChange();
+}
+/*
+void ImportAIPlugin::addToMainWindowMenu(ScribusMainWindow *mw)
+{
+ importAction->setEnabled(true);
+ connect( importAction, SIGNAL(triggered()), SLOT(import()) );
+ mw->scrMenuMgr->addMenuItem(importAction, "FileImport");
+}
+*/
+void ImportAIPlugin::languageChange()
+{
+ importAction->setText( tr("Import AI..."));
+ // (Re)register file format support
+ unregisterAll();
+ registerFormats();
+}
+
+ImportAIPlugin::~ImportAIPlugin()
+{
+ unregisterAll();
+};
+
+const QString ImportAIPlugin::fullTrName() const
+{
+ return QObject::tr("Adobe Illustrator Importer");
+}
+
+
+const ScActionPlugin::AboutData* ImportAIPlugin::getAboutData() const
+{
+ AboutData* about = new AboutData;
+ about->authors = "Franz Schmid <franz at scribus.info>";
+ about->shortDescription = tr("Imports Illustrator Files");
+ about->description = tr("Imports most Illustrator files into the current document,\nconverting their vector data into Scribus objects.");
+ about->license = "GPL";
+ Q_CHECK_PTR(about);
+ return about;
+}
+
+void ImportAIPlugin::deleteAboutData(const AboutData* about) const
+{
+ Q_ASSERT(about);
+ delete about;
+}
+
+void ImportAIPlugin::registerFormats()
+{
+ FileFormat fmt(this);
+ fmt.trName = FormatsManager::instance()->nameOfFormat(FormatsManager::AI); // Human readable name
+ fmt.formatId = FORMATID_AIIMPORT;
+ fmt.filter = FormatsManager::instance()->extensionsForFormat(FormatsManager::AI); // QFileDialog filter
+ fmt.nameMatch = QRegExp("\\."+FormatsManager::instance()->extensionListForFormat(FormatsManager::AI, 1)+"$", Qt::CaseInsensitive);
+ fmt.load = true;
+ fmt.save = false;
+ fmt.mimeTypes = FormatsManager::instance()->mimetypeOfFormat(FormatsManager::AI); // MIME types
+ fmt.priority = 64; // Priority
+ registerFormat(fmt);
+}
+
+bool ImportAIPlugin::fileSupported(QIODevice* /* file */, const QString & fileName) const
+{
+ // TODO: check for %!PS-Adobe
+ return true;
+}
+
+bool ImportAIPlugin::loadFile(const QString & fileName, const FileFormat &, int flags, int /*index*/)
+{
+ // There's only one format to handle, so we just call import(...)
+ return import(fileName, flags);
+}
+
+bool ImportAIPlugin::import(QString fileName, int flags)
+{
+ if (!checkFlags(flags))
+ return false;
+ if( fileName.isEmpty() )
+ {
+ flags |= lfInteractive;
+ PrefsContext* prefs = PrefsManager::instance()->prefsFile->getPluginContext("importai");
+ QString wdir = prefs->get("wdir", ".");
+ CustomFDialog diaf(ScCore->primaryMainWindow(), wdir, QObject::tr("Open"), FormatsManager::instance()->fileDialogFormatList(FormatsManager::AI));
+ if (diaf.exec())
+ {
+ fileName = diaf.selectedFile();
+ prefs->set("wdir", fileName.left(fileName.lastIndexOf("/")));
+ }
+ else
+ return true;
+ }
+ m_Doc=ScCore->primaryMainWindow()->doc;
+ UndoTransaction* activeTransaction = NULL;
+ bool emptyDoc = (m_Doc == NULL);
+ bool hasCurrentPage = (m_Doc && m_Doc->currentPage());
+ TransactionSettings trSettings;
+ trSettings.targetName = hasCurrentPage ? m_Doc->currentPage()->getUName() : "";
+ trSettings.targetPixmap = Um::IImageFrame;
+ trSettings.actionName = Um::ImportAI;
+ trSettings.description = fileName;
+ trSettings.actionPixmap = Um::IAI;
+ if (emptyDoc || !(flags & lfInteractive) || !(flags & lfScripted))
+ UndoManager::instance()->setUndoEnabled(false);
+ if (UndoManager::undoEnabled())
+ activeTransaction = new UndoTransaction(UndoManager::instance()->beginTransaction(trSettings));
+ AIPlug *dia = new AIPlug(m_Doc, flags);
+ Q_CHECK_PTR(dia);
+ bool success = dia->import(fileName, trSettings, flags);
+ if (activeTransaction)
+ {
+ activeTransaction->commit();
+ delete activeTransaction;
+ activeTransaction = NULL;
+ }
+ if (emptyDoc || !(flags & lfInteractive) || !(flags & lfScripted))
+ UndoManager::instance()->setUndoEnabled(true);
+ if (!success)
+ QMessageBox::warning(ScCore->primaryMainWindow(), CommonStrings::trWarning, tr("The file could not be imported"), 1, 0, 0);
+ delete dia;
+ return success;
+}
Index: scribus/plugins/import/aiimplugin/importai.cpp
===================================================================
--- scribus/plugins/import/aiimplugin/importai.cpp (revision 0)
+++ scribus/plugins/import/aiimplugin/importai.cpp (revision 14347)
@@ -0,0 +1,2591 @@
+/*
+For general Scribus (>=1.3.2) copyright and licensing information please refer
+to the COPYING file provided with the program. Following this notice may exist
+a copyright and/or license notice that predates the release of Scribus 1.3.2
+for which a new license (GPL+exception) is in place.
+*/
+
+#include <QByteArray>
+#include <QCursor>
+#include <QDrag>
+#include <QFile>
+#include <QList>
+#include <QMimeData>
+#include <QRegExp>
+#include <QStack>
+#include <QTemporaryFile>
+#include <QDebug>
+
+#include <cstdlib>
+#include <tiffio.h>
+#include <zlib.h>
+
+#include "commonstrings.h"
+
+#include "importai.h"
+#include "loadsaveplugin.h"
+#include "prefscontext.h"
+#include "prefsfile.h"
+#include "prefsmanager.h"
+#include "prefstable.h"
+#include "rawimage.h"
+#include "sccolorengine.h"
+#include "scconfig.h"
+#include "scclocale.h"
+#include "scmimedata.h"
+#include "scpaths.h"
+#include "scpattern.h"
+#include "scribus.h"
+#include "scribusXml.h"
+#include "scribuscore.h"
+#include "scribusdoc.h"
+#include "sctextstream.h"
+#include "selection.h"
+#include "text/specialchars.h"
+#include "ui/customfdialog.h"
+#include "ui/missing.h"
+#include "ui/multiprogressdialog.h"
+#include "ui/propertiespalette.h"
+#include "undomanager.h"
+#include "util.h"
+#include "util_color.h"
+#include "util_file.h"
+#include "util_formats.h"
+#include "util_icon.h"
+#include "util_math.h"
+
+#ifdef HAVE_CAIRO
+ #include <cairo.h>
+#endif
+
+#ifdef HAVE_PODOFO
+ #include <podofo/podofo.h>
+#endif
+
+extern SCRIBUS_API ScribusQApp * ScQApp;
+
+AIPlug::AIPlug(ScribusDoc* doc, int flags)
+{
+ tmpSel=new Selection(this, false);
+ m_Doc=doc;
+ interactive = (flags & LoadSavePlugin::lfInteractive);
+ progressDialog = NULL;
+}
+
+bool AIPlug::import(QString fNameIn, const TransactionSettings& trSettings, int flags, bool showProgress)
+{
+ QString fName = fNameIn;
+ bool success = false;
+ interactive = (flags & LoadSavePlugin::lfInteractive);
+ importerFlags = flags;
+ cancel = false;
+ double x, y, b, h;
+ bool ret = false;
+ convertedPDF = false;
+ CustColors.clear();
+ importedColors.clear();
+ importedGradients.clear();
+ importedPatterns.clear();
+ QFileInfo fi = QFileInfo(fName);
+// QString ext = fi.suffix().toLower();
+ if ( !ScCore->usingGUI() )
+ {
+ interactive = false;
+ showProgress = false;
+ }
+
+/* Check if the file is an old style AI or one of the newer PDF wrapped ones */
+ QFile fT(fName);
+ if (fT.open(QIODevice::ReadOnly))
+ {
+ QByteArray tempBuf(9, ' ');
+ fT.read(tempBuf.data(), 8);
+ fT.close();
+ if (tempBuf.startsWith("%PDF"))
+ {
+ QFileInfo bF2(fName);
+ QString tmpFile = ScPaths::getTempFileDir()+ "/"+bF2.baseName()+"_tmp.ai";
+ if (!extractFromPDF(fName, tmpFile))
+ return false;
+ convertedPDF = true;
+ fName = tmpFile;
+ }
+ }
+ QFile fT2(fName);
+ if (fT2.open(QIODevice::ReadOnly))
+ {
+ QByteArray tempBuf(25, ' ');
+ fT2.read(tempBuf.data(), 20);
+ fT2.close();
+ /* Illustrator CS files might be compressed
+ the compressed Data starts right after the "%AI12_CompressedData" comment
+ Compression is a simple zlib compression */
+ if (tempBuf.startsWith("%AI12_CompressedData"))
+ decompressAIData(fName);
+ }
+ if ( showProgress )
+ {
+ ScribusMainWindow* mw=(m_Doc==0) ? ScCore->primaryMainWindow() : m_Doc->scMW();
+ progressDialog = new MultiProgressDialog( tr("Importing: %1").arg(fi.fileName()), CommonStrings::tr_Cancel, mw );
+ QStringList barNames, barTexts;
+ barNames << "GI";
+ barTexts << tr("Analyzing File:");
+ QList<bool> barsNumeric;
+ barsNumeric << false;
+ progressDialog->addExtraProgressBars(barNames, barTexts, barsNumeric);
+ progressDialog->setOverallTotalSteps(3);
+ progressDialog->setOverallProgress(0);
+ progressDialog->setProgress("GI", 0);
+ progressDialog->show();
+ connect(progressDialog, SIGNAL(canceled()), this, SLOT(cancelRequested()));
+ qApp->processEvents();
+ }
+ else
+ progressDialog = NULL;
+/* Set default Page to size defined in Preferences */
+ x = 0.0;
+ y = 0.0;
+ b = PrefsManager::instance()->appPrefs.docSetupPrefs.pageWidth;
+ h = PrefsManager::instance()->appPrefs.docSetupPrefs.pageHeight;
+ if (progressDialog)
+ {
+ progressDialog->setOverallProgress(1);
+ qApp->processEvents();
+ }
+ parseHeader(fName, x, y, b, h);
+ docX = x;
+ docY = y;
+ docWidth = b - x;
+ docHeight = h - y;
+ baseX = 0;
+ baseY = 0;
+ if (!interactive || (flags & LoadSavePlugin::lfInsertPage))
+ {
+ m_Doc->setPage(b-x, h-y, 0, 0, 0, 0, 0, 0, false, false);
+ m_Doc->addPage(0);
+ m_Doc->view()->addPage(0, true);
+ baseX = 0;
+ baseY = 0;
+ }
+ else
+ {
+ if (!m_Doc || (flags & LoadSavePlugin::lfCreateDoc))
+ {
+ m_Doc=ScCore->primaryMainWindow()->doFileNew(b-x, h-y, 0, 0, 0, 0, 0, 0, false, false, 0, false, 0, 1, "Custom", true);
+ ScCore->primaryMainWindow()->HaveNewDoc();
+ ret = true;
+ baseX = 0;
+ baseY = 0;
+ }
+ }
+ if (flags & LoadSavePlugin::lfCreateDoc)
+ {
+ m_Doc->documentInfo.setAuthor(docCreator);
+ m_Doc->documentInfo.setPublisher(docOrganisation);
+ m_Doc->documentInfo.setTitle(docTitle);
+ m_Doc->documentInfo.setDate(docDate+" "+docTime);
+ }
+ if ((!ret) && (interactive))
+ {
+ baseX = m_Doc->currentPage()->xOffset();
+ baseY = m_Doc->currentPage()->yOffset();
+ }
+ if ((ret) || (!interactive))
+ {
+ if (b-x > h-y)
+ m_Doc->PageOri = 1;
+ else
+ m_Doc->PageOri = 0;
+ m_Doc->m_pageSize = "Custom";
+ }
+ ColorList::Iterator it;
+ for (it = CustColors.begin(); it != CustColors.end(); ++it)
+ {
+ if (!m_Doc->PageColors.contains(it.key()))
+ {
+ m_Doc->PageColors.insert(it.key(), it.value());
+ importedColors.append(it.key());
+ }
+ }
+ Elements.clear();
+ FPoint minSize = m_Doc->minCanvasCoordinate;
+ FPoint maxSize = m_Doc->maxCanvasCoordinate;
+ FPoint cOrigin = m_Doc->view()->canvasOrigin();
+ m_Doc->setLoading(true);
+ m_Doc->DoDrawing = false;
+ m_Doc->view()->updatesOn(false);
+ m_Doc->scMW()->ScriptRunning = true;
+ qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
+ QString CurDirP = QDir::currentPath();
+ QDir::setCurrent(fi.path());
+ if (convert(fName))
+ {
+ if (Elements.count() == 0)
+ {
+ if ((importedColors.count() != 0) && (!((flags & LoadSavePlugin::lfKeepGradients) || (flags & LoadSavePlugin::lfKeepColors) || (flags & LoadSavePlugin::lfKeepPatterns))))
+ {
+ for (int cd = 0; cd < importedColors.count(); cd++)
+ {
+ m_Doc->PageColors.remove(importedColors[cd]);
+ }
+ }
+ if ((importedGradients.count() != 0) && (!((flags & LoadSavePlugin::lfKeepGradients || (flags & LoadSavePlugin::lfKeepPatterns)))))
+ {
+ for (int cd = 0; cd < importedGradients.count(); cd++)
+ {
+ m_Doc->docGradients.remove(importedGradients[cd]);
+ }
+ }
+ if ((importedPatterns.count() != 0) && (!(flags & LoadSavePlugin::lfKeepPatterns)))
+ {
+ for (int cd = 0; cd < importedPatterns.count(); cd++)
+ {
+ m_Doc->docPatterns.remove(importedPatterns[cd]);
+ }
+ }
+ }
+ tmpSel->clear();
+ QDir::setCurrent(CurDirP);
+ if ((Elements.count() > 1) && (!(importerFlags & LoadSavePlugin::lfCreateDoc)))
+ {
+ bool isGroup = true;
+ int firstElem = -1;
+ if (Elements.at(0)->Groups.count() != 0)
+ firstElem = Elements.at(0)->Groups.top();
+ for (int bx = 0; bx < Elements.count(); ++bx)
+ {
+ PageItem* bxi = Elements.at(bx);
+ if (bxi->Groups.count() != 0)
+ {
+ if (bxi->Groups.top() != firstElem)
+ isGroup = false;
+ }
+ else
+ isGroup = false;
+ }
+ if (!isGroup)
+ {
+ double minx = 99999.9;
+ double miny = 99999.9;
+ double maxx = -99999.9;
+ double maxy = -99999.9;
+ uint lowestItem = 999999;
+ uint highestItem = 0;
+ for (int a = 0; a < Elements.count(); ++a)
+ {
+ Elements.at(a)->Groups.push(m_Doc->GroupCounter);
+ PageItem* currItem = Elements.at(a);
+ lowestItem = qMin(lowestItem, currItem->ItemNr);
+ highestItem = qMax(highestItem, currItem->ItemNr);
+ double x1, x2, y1, y2;
+ currItem->getVisualBoundingRect(&x1, &y1, &x2, &y2);
+ minx = qMin(minx, x1);
+ miny = qMin(miny, y1);
+ maxx = qMax(maxx, x2);
+ maxy = qMax(maxy, y2);
+ }
+ double gx = minx;
+ double gy = miny;
+ double gw = maxx - minx;
+ double gh = maxy - miny;
+ PageItem *high = m_Doc->Items->at(highestItem);
+ int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, gx, gy, gw, gh, 0, m_Doc->itemToolPrefs.shapeFillColor, m_Doc->itemToolPrefs.shapeLineColor, true);
+ PageItem *neu = m_Doc->Items->takeAt(z);
+ m_Doc->Items->insert(lowestItem, neu);
+ neu->Groups.push(m_Doc->GroupCounter);
+ neu->setItemName( tr("Group%1").arg(neu->Groups.top()));
+ neu->isGroupControl = true;
+ neu->groupsLastItem = high;
+ neu->setTextFlowMode(PageItem::TextFlowDisabled);
+ for (int a = 0; a < m_Doc->Items->count(); ++a)
+ {
+ m_Doc->Items->at(a)->ItemNr = a;
+ }
+ Elements.prepend(neu);
+ m_Doc->GroupCounter++;
+ }
+ }
+ m_Doc->DoDrawing = true;
+ m_Doc->scMW()->ScriptRunning = false;
+ m_Doc->setLoading(false);
+ qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
+ if ((Elements.count() > 0) && (!ret) && (interactive))
+ {
+ if (flags & LoadSavePlugin::lfScripted)
+ {
+ bool loadF = m_Doc->isLoading();
+ m_Doc->setLoading(false);
+ m_Doc->changed();
+ m_Doc->setLoading(loadF);
+ m_Doc->m_Selection->delaySignalsOn();
+ for (int dre=0; dre<Elements.count(); ++dre)
+ {
+ m_Doc->m_Selection->addItem(Elements.at(dre), true);
+ }
+ m_Doc->m_Selection->delaySignalsOff();
+ m_Doc->m_Selection->setGroupRect();
+ m_Doc->view()->updatesOn(true);
+ }
+ else
+ {
+ m_Doc->DragP = true;
+ m_Doc->DraggedElem = 0;
+ m_Doc->DragElements.clear();
+ m_Doc->m_Selection->delaySignalsOn();
+ for (int dre=0; dre<Elements.count(); ++dre)
+ {
+ m_Doc->DragElements.append(Elements.at(dre)->ItemNr);
+ tmpSel->addItem(Elements.at(dre), true);
+ }
+ tmpSel->setGroupRect();
+ ScriXmlDoc *ss = new ScriXmlDoc();
+ ScElemMimeData* md = new ScElemMimeData();
+ md->setScribusElem(ss->WriteElem(m_Doc, m_Doc->view(), tmpSel));
+ delete ss;
+/*#ifndef Q_WS_MAC*/
+// see #2196
+ m_Doc->itemSelection_DeleteItem(tmpSel);
+/*#else
+ qDebug("aiimport: leaving items on page");
+#endif*/
+ m_Doc->view()->updatesOn(true);
+ if ((importedColors.count() != 0) && (!((flags & LoadSavePlugin::lfKeepGradients) || (flags & LoadSavePlugin::lfKeepColors) || (flags & LoadSavePlugin::lfKeepPatterns))))
+ {
+ for (int cd = 0; cd < importedColors.count(); cd++)
+ {
+ m_Doc->PageColors.remove(importedColors[cd]);
+ }
+ }
+ if ((importedGradients.count() != 0) && (!((flags & LoadSavePlugin::lfKeepGradients || (flags & LoadSavePlugin::lfKeepPatterns)))))
+ {
+ for (int cd = 0; cd < importedGradients.count(); cd++)
+ {
+ m_Doc->docGradients.remove(importedGradients[cd]);
+ }
+ }
+ if ((importedPatterns.count() != 0) && (!(flags & LoadSavePlugin::lfKeepPatterns)))
+ {
+ for (int cd = 0; cd < importedPatterns.count(); cd++)
+ {
+ m_Doc->docPatterns.remove(importedPatterns[cd]);
+ }
+ }
+ m_Doc->m_Selection->delaySignalsOff();
+ // We must copy the TransationSettings object as it is owned
+ // by handleObjectImport method afterwards
+ TransactionSettings* transacSettings = new TransactionSettings(trSettings);
+ m_Doc->view()->handleObjectImport(md, transacSettings);
+ m_Doc->DragP = false;
+ m_Doc->DraggedElem = 0;
+ m_Doc->DragElements.clear();
+ }
+ }
+ else
+ {
+ m_Doc->changed();
+ m_Doc->reformPages();
+ m_Doc->view()->updatesOn(true);
+ }
+ success = true;
+ }
+ else
+ {
+ QDir::setCurrent(CurDirP);
+ m_Doc->DoDrawing = true;
+ m_Doc->scMW()->ScriptRunning = false;
+ m_Doc->view()->updatesOn(true);
+ qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
+ }
+ if (interactive)
+ m_Doc->setLoading(false);
+ //CB If we have a gui we must refresh it if we have used the progressbar
+ if ((showProgress) && (!interactive))
+ m_Doc->view()->DrawNew();
+ if (convertedPDF)
+ QFile::remove(fName);
+ return success;
+}
+
+AIPlug::~AIPlug()
+{
+ if (progressDialog)
+ delete progressDialog;
+ delete tmpSel;
+}
+
+bool AIPlug::extractFromPDF(QString infile, QString outfile)
+{
+ bool ret = false;
+#ifdef HAVE_PODOFO
+ QFile outf(outfile);
+ outf.open(QIODevice::WriteOnly);
+ try
+ {
+ PoDoFo::PdfError::EnableDebug( false );
+#if (PODOFO_VERSION == 0 && PODOFO_MINOR > 6)
+ PoDoFo::PdfError::EnableLogging( false );
+#endif
+#if (PODOFO_VERSION == 0 && PODOFO_MINOR == 5 && PODOFO_REVISION == 99) || PODOFO_MINOR > 5
+ PoDoFo::PdfMemDocument doc( infile.toLocal8Bit().data() );
+#else
+ PoDoFo::PdfDocument doc( infile.toLocal8Bit().data() );
+#endif
+ PoDoFo::PdfPage *curPage = doc.GetPage(0);
+ if (curPage != NULL)
+ {
+ PoDoFo::PdfObject *piece = curPage->GetObject()->GetIndirectKey("PieceInfo");
+ if (piece != NULL)
+ {
+ PoDoFo::PdfObject *illy = piece->GetIndirectKey("Illustrator");
+ if (illy != NULL)
+ {
+ PoDoFo::PdfObject *priv = illy->GetIndirectKey("Private");
+ if (priv == NULL)
+ priv = illy;
+ int num = 0;
+ PoDoFo::PdfObject *numBl = priv->GetIndirectKey("NumBlock");
+ if (numBl != NULL)
+ num = numBl->GetNumber() + 1;
+ if (num == 0)
+ num = 99999;
+ QString name = "AIPrivateData%1";
+ QString Key = name.arg(1);
+ PoDoFo::PdfObject *data = priv->GetIndirectKey(PoDoFo::PdfName(Key.toUtf8().data()));
+ if (data == NULL)
+ {
+ name = "AIPDFPrivateData%1";
+ Key = name.arg(1);
+ data = priv->GetIndirectKey(PoDoFo::PdfName(Key.toUtf8().data()));
+ }
+ if (data != NULL)
+ {
+ if (num == 2)
+ {
+ Key = name.arg(1);
+ data = priv->GetIndirectKey(PoDoFo::PdfName(Key.toUtf8().data()));
+ PoDoFo::PdfStream const *stream = data->GetStream();
+ PoDoFo::PdfMemoryOutputStream oStream(1);
+ stream->GetFilteredCopy(&oStream);
+ oStream.Close();
+ long bLen = oStream.GetLength();
+ char *Buffer = oStream.TakeBuffer();
+ outf.write(Buffer, bLen);
+ free( Buffer );
+ }
+ else
+ {
+ for (int a = 2; a < num; a++)
+ {
+ Key = name.arg(a);
+ data = priv->GetIndirectKey(PoDoFo::PdfName(Key.toUtf8().data()));
+ if (data == NULL)
+ break;
+ PoDoFo::PdfStream const *stream = data->GetStream();
+ PoDoFo::PdfMemoryOutputStream oStream(1);
+ stream->GetFilteredCopy(&oStream);
+ oStream.Close();
+ long bLen = oStream.GetLength();
+ char *Buffer = oStream.TakeBuffer();
+ outf.write(Buffer, bLen);
+ free( Buffer );
+ }
+ }
+ }
+ ret = true;
+ }
+ }
+ }
+ outf.close();
+ }
+ catch (PoDoFo::PdfError& e)
+ {
+ outf.close();
+ qDebug("Scribus caught and handled the following exception from PoDoFo while processing a PDF format ai file:\n----\n");
+ e.PrintErrorMsg();
+ qDebug("----\nThe ai file could not be imported.\n");
+ QFile::remove(outfile);
+ return false;
+ }
+#endif
+ return ret;
+}
+
+bool AIPlug::decompressAIData(QString &fName)
+{
+ QString f2 = fName+"_decom.ai";
+ FILE *source = fopen(fName.toLocal8Bit().constData(), "rb");
+ fseek(source, 20, SEEK_SET);
+ FILE *dest = fopen(f2.toLocal8Bit().constData(), "wb");
+ int ret;
+ unsigned have;
+ z_stream strm;
+ char in[4096];
+ char out[4096];
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit(&strm);
+ if (ret != Z_OK)
+ return false;
+ do
+ {
+ strm.avail_in = fread(in, 1, 4096, source);
+ if (ferror(source))
+ {
+ (void)inflateEnd(&strm);
+ return false;
+ }
+ if (strm.avail_in == 0)
+ break;
+ strm.next_in = (Bytef*)in;
+ do
+ {
+ strm.avail_out = 4096;
+ strm.next_out = (Bytef*)out;
+ ret = inflate(&strm, Z_NO_FLUSH);
+ assert(ret != Z_STREAM_ERROR);
+ switch (ret)
+ {
+ case Z_NEED_DICT:
+ ret = Z_DATA_ERROR;
+ case Z_DATA_ERROR:
+ case Z_MEM_ERROR:
+ (void)inflateEnd(&strm);
+ return false;
+ }
+ have = 4096 - strm.avail_out;
+ if (fwrite(out, 1, have, dest) != have || ferror(dest))
+ {
+ (void)inflateEnd(&strm);
+ return false;
+ }
+ }
+ while (strm.avail_out == 0);
+ }
+ while (ret != Z_STREAM_END);
+ (void)inflateEnd(&strm);
+ fclose(source);
+ fclose(dest);
+ if (!convertedPDF)
+ {
+ QFileInfo bF2(fName);
+ QString tmpFile = ScPaths::getTempFileDir()+ "/"+bF2.baseName()+"_tmp.ai";
+ moveFile(f2, tmpFile);
+ fName = tmpFile;
+ convertedPDF = true;
+ }
+ else
+ {
+ QFile::remove(fName);
+ fName = f2;
+ }
+ return true;
+}
+
+bool AIPlug::parseHeader(QString fName, double &x, double &y, double &b, double &h)
+{
+ QString tmp, BBox, tmp2, FarNam;
+ ScColor cc;
+// double c, m, yc, k;
+ bool found = false;
+ QFile f(fName);
+ if (f.open(QIODevice::ReadOnly))
+ {
+/* Try to find Bounding Box */
+ QDataStream ts(&f);
+ while (!ts.atEnd())
+ {
+ tmp = readLinefromDataStream(ts);
+ if (tmp.startsWith("%%BoundingBox:"))
+ {
+ found = true;
+ BBox = tmp.remove("%%BoundingBox:");
+ }
+ if (!found)
+ {
+ if (tmp.startsWith("%%BoundingBox"))
+ {
+ found = true;
+ BBox = tmp.remove("%%BoundingBox");
+ }
+ }
+ if (tmp.startsWith("%%HiResBoundingBox:"))
+ {
+ found = true;
+ BBox = tmp.remove("%%HiResBoundingBox:");
+ }
+ if (tmp.startsWith("%%For"))
+ {
+ QStringList res = getStrings(tmp);
+ if (res.count() > 1)
+ {
+ docCreator = res[0];
+ docOrganisation = res[1];
+ }
+ }
+ if (tmp.startsWith("%%CreationDate:"))
+ {
+ QStringList res = getStrings(tmp);
+ if (res.count() > 1)
+ {
+ docDate = res[0];
+ docTime = res[1];
+ }
+ else
+ {
+ docDate = tmp.remove("%%CreationDate: ");
+ docTime = "";
+ }
+ }
+ if (tmp.startsWith("%%Title"))
+ {
+ QStringList res = getStrings(tmp);
+ if (res.count() > 0)
+ docTitle = res[0];
+ }
+ if (tmp.startsWith("%%EndComments"))
+ break;
+ }
+ f.close();
+ if (found)
+ {
+ QStringList bb = BBox.split(" ", QString::SkipEmptyParts);
+ if (bb.count() == 4)
+ {
+ x = ScCLocale::toDoubleC(bb[0]);
+ y = ScCLocale::toDoubleC(bb[1]);
+ b = ScCLocale::toDoubleC(bb[2]);
+ h = ScCLocale::toDoubleC(bb[3]);
+ }
+ }
+ importColorsFromFile(fName, CustColors);
+ }
+ return found;
+}
+
+QString AIPlug::removeAIPrefix(QString comment)
+{
+ QString tmp;
+ if (comment.startsWith("%AI"))
+ {
+ int an = comment.indexOf("_");
+ tmp = comment.remove(0, an+1);
+ }
+ else
+ tmp = comment;
+ return tmp;
+}
+
+QString AIPlug::parseColor(QString data)
+{
+ QString ret = CommonStrings::None;
+ if (data.isEmpty())
+ return ret;
+ double c, m, y, k;
+ ScColor tmp;
+ ColorList::Iterator it;
+ ScTextStream Code(&data, QIODevice::ReadOnly);
+ bool found = false;
+ Code >> c;
+ Code >> m;
+ Code >> y;
+ Code >> k;
+ int Cc = qRound(c * 255);
+ int Mc = qRound(m * 255);
+ int Yc = qRound(y * 255);
+ int Kc = qRound(k * 255);
+ int hC, hM, hY, hK;
+ tmp.setColor(Cc, Mc, Yc, Kc);
+ for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
+ {
+ if (it.value().getColorModel() == colorModelCMYK)
+ {
+ it.value().getCMYK(&hC, &hM, &hY, &hK);
+ if ((Cc == hC) && (Mc == hM) && (Yc == hY) && (Kc == hK))
+ {
+ ret = it.key();
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found)
+ {
+ tmp.setSpotColor(false);
+ tmp.setRegistrationColor(false);
+ QString namPrefix = "FromAI";
+ m_Doc->PageColors.insert(namPrefix+tmp.name(), tmp);
+ importedColors.append(namPrefix+tmp.name());
+ ret = namPrefix+tmp.name();
+ }
+ return ret;
+}
+
+QString AIPlug::parseColorGray(QString data)
+{
+ QString ret = CommonStrings::None;
+ if (data.isEmpty())
+ return ret;
+ double k;
+ ScColor tmp;
+ ColorList::Iterator it;
+ ScTextStream Code(&data, QIODevice::ReadOnly);
+ bool found = false;
+ Code >> k;
+ int Kc = 255 - qRound(k * 255);
+ int hC, hM, hY, hK;
+ tmp.setColor(0, 0, 0, Kc);
+ for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
+ {
+ if (it.value().getColorModel() == colorModelCMYK)
+ {
+ it.value().getCMYK(&hC, &hM, &hY, &hK);
+ if ((hC == 0) && (hM == 0) && (hY == 0) && (Kc == hK))
+ {
+ ret = it.key();
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found)
+ {
+ tmp.setSpotColor(false);
+ tmp.setRegistrationColor(false);
+ QString namPrefix = "FromAI";
+ m_Doc->PageColors.insert(namPrefix+tmp.name(), tmp);
+ importedColors.append(namPrefix+tmp.name());
+ ret = namPrefix+tmp.name();
+ }
+ return ret;
+}
+
+QString AIPlug::parseColorRGB(QString data)
+{
+ QString ret = CommonStrings::None;
+ if (data.isEmpty())
+ return ret;
+ double r, g, b;
+ ScColor tmp;
+ ColorList::Iterator it;
+ ScTextStream Code(&data, QIODevice::ReadOnly);
+ bool found = false;
+ Code >> r;
+ Code >> g;
+ Code >> b;
+ int Rc = qRound(r * 255);
+ int Gc = qRound(g * 255);
+ int Bc = qRound(b * 255);
+ int hR, hG, hB;
+ tmp.setColorRGB(Rc, Gc, Bc);
+ for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
+ {
+ if (it.value().getColorModel() == colorModelRGB)
+ {
+ it.value().getRGB(&hR, &hG, &hB);
+ if ((Rc == hR) && (Gc == hG) && (Bc == hB))
+ {
+ ret = it.key();
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found)
+ {
+ tmp.setSpotColor(false);
+ tmp.setRegistrationColor(false);
+ QString namPrefix = "FromAI";
+ m_Doc->PageColors.insert(namPrefix+tmp.name(), tmp);
+ importedColors.append(namPrefix+tmp.name());
+ ret = namPrefix+tmp.name();
+ }
+ return ret;
+}
+
+QString AIPlug::parseCustomColor(QString data, double &shade)
+{
+ QString ret = CommonStrings::None;
+ if (data.isEmpty())
+ return ret;
+ double c, m, y, k, sh;
+ ScColor tmp;
+ ColorList::Iterator it;
+ ScTextStream Code(&data, QIODevice::ReadOnly);
+ bool found = false;
+ Code >> c;
+ Code >> m;
+ Code >> y;
+ Code >> k;
+ QString tmpS = data;
+ int an = data.indexOf("(");
+ int en = data.lastIndexOf(")");
+ QString FarNam = data.mid(an+1, en-an-1);
+ FarNam.remove("\\");
+ QString FarSha = data.mid(en+1, data.size() - en);
+ ScTextStream Val(&FarSha, QIODevice::ReadOnly);
+ Val >> sh;
+ shade = (1.0 - sh) * 100.0;
+ int Cc = qRound(c * 255);
+ int Mc = qRound(m * 255);
+ int Yc = qRound(y * 255);
+ int Kc = qRound(k * 255);
+ int hC, hM, hY, hK;
+ tmp.setColor(Cc, Mc, Yc, Kc);
+ for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
+ {
+ if (it.value().getColorModel() == colorModelCMYK)
+ {
+ it.value().getCMYK(&hC, &hM, &hY, &hK);
+ if ((Cc == hC) && (Mc == hM) && (Yc == hY) && (Kc == hK))
+ {
+ ret = it.key();
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found)
+ {
+ tmp.setSpotColor(true);
+ tmp.setRegistrationColor(false);
+ m_Doc->PageColors.insert(FarNam, tmp);
+ importedColors.append(FarNam);
+ ret = FarNam;
+ }
+ return ret;
+}
+
+QString AIPlug::parseCustomColorX(QString data, double &shade, QString type)
+{
+ QString ret = CommonStrings::None;
+ if (data.isEmpty())
+ return ret;
+ double c, m, y, k, sh, r, g, b;
+ ScColor tmp;
+ ColorList::Iterator it;
+ ScTextStream Code(&data, QIODevice::ReadOnly);
+ bool found = false;
+ if (type == "1")
+ {
+ Code >> r;
+ Code >> g;
+ Code >> b;
+ int Rc = qRound(r * 255);
+ int Gc = qRound(g * 255);
+ int Bc = qRound(b * 255);
+ int hR, hG, hB;
+ tmp.setColorRGB(Rc, Gc, Bc);
+ for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
+ {
+ if (it.value().getColorModel() == colorModelRGB)
+ {
+ it.value().getRGB(&hR, &hG, &hB);
+ if ((Rc == hR) && (Gc == hG) && (Bc == hB))
+ {
+ ret = it.key();
+ found = true;
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ Code >> c;
+ Code >> m;
+ Code >> y;
+ Code >> k;
+ int Cc = qRound(c * 255);
+ int Mc = qRound(m * 255);
+ int Yc = qRound(y * 255);
+ int Kc = qRound(k * 255);
+ int hC, hM, hY, hK;
+ tmp.setColor(Cc, Mc, Yc, Kc);
+ for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
+ {
+ if (it.value().getColorModel() == colorModelCMYK)
+ {
+ it.value().getCMYK(&hC, &hM, &hY, &hK);
+ if ((Cc == hC) && (Mc == hM) && (Yc == hY) && (Kc == hK))
+ {
+ ret = it.key();
+ found = true;
+ break;
+ }
+ }
+ }
+ }
+ QString tmpS = data;
+ int an = data.indexOf("(");
+ int en = data.lastIndexOf(")");
+ QString FarNam = data.mid(an+1, en-an-1);
+ FarNam.remove("\\");
+ QString FarSha = data.mid(en+1, data.size() - en);
+ ScTextStream Val(&FarSha, QIODevice::ReadOnly);
+ Val >> sh;
+ shade = (1.0 - sh) * 100.0;
+ if (!found)
+ {
+ if (type == "0")
+ tmp.setSpotColor(true);
+ tmp.setRegistrationColor(false);
+ m_Doc->PageColors.insert(FarNam, tmp);
+ importedColors.append(FarNam);
+ ret = FarNam;
+ }
+ return ret;
+}
+
+QStringList AIPlug::getStrings(QString data)
+{
+ QStringList result;
+ result.clear();
+ QChar tmp;
+ QString tmp2 = "";
+ QString tmp3 = "";
+ bool paran = false;
+ bool skip = false;
+ int digitCount = 0;
+ for (int a = 0; a < data.count(); a++)
+ {
+ tmp = data[a];
+ if (skip)
+ {
+ if (paran)
+ {
+ if (tmp.isDigit())
+ {
+ tmp3 += tmp;
+ digitCount++;
+ if (digitCount == 3)
+ {
+ bool ok = false;
+ int code = tmp3.toInt(&ok, 8);
+ if (ok)
+ tmp2 += QChar(code);
+ digitCount = 0;
+ tmp3 = "";
+ skip = false;
+ }
+ }
+ else
+ {
+ if (tmp == 'r')
+ tmp = SpecialChars::PARSEP;
+ tmp2 += tmp;
+ skip = false;
+ }
+ }
+ continue;
+ }
+ if (tmp == '(')
+ {
+ paran = true;
+ continue;
+ }
+ if (tmp == ')')
+ {
+ paran = false;
+ result.append(tmp2);
+ tmp2 = "";
+ continue;
+ }
+ if (tmp == '\\')
+ {
+ skip = true;
+ continue;
+ }
+ if (paran)
+ tmp2 += tmp;
+ }
+ return result;
+}
+
+void AIPlug::getCommands(QString data, QStringList &commands)
+{
+ QString tmp;
+ QString tmp2;
+ QString tmp3;
+ bool paran = false;
+ bool arra = false;
+ bool skip = false;
+ for (int a = 0; a < data.count(); a++)
+ {
+ tmp = data[a];
+ if (skip)
+ {
+ tmp2 += tmp;
+ skip = false;
+ continue;
+ }
+ if (tmp == "(")
+ {
+ paran = true;
+ tmp2 += tmp;
+ continue;
+ }
+ if (tmp == ")")
+ {
+ paran = false;
+ tmp2 += tmp;
+ continue;
+ }
+ if (tmp == "[")
+ {
+ arra = true;
+ tmp2 += tmp;
+ continue;
+ }
+ if (tmp == "]")
+ {
+ arra = false;
+ tmp2 += tmp;
+ continue;
+ }
+// if (tmp == "\\")
+// {
+// skip = true;
+// continue;
+// }
+ if (!paran)
+ {
+ if (tmp == " ")
+ {
+ tmp3 += " " + tmp2;
+ if (commandList.contains(tmp2))
+ {
+ commands.append(tmp3);
+ tmp3 = "";
+ }
+ tmp2 = "";
+ continue;
+ }
+ }
+ tmp2 += tmp;
+ }
+ if (!tmp2.isEmpty())
+ {
+ tmp3 += " " + tmp2;
+ commands.append(tmp3);
+ }
+}
+
+void AIPlug::processData(QString data)
+{
+ double x, y, x1, y1, x2, y2;
+ int z, tmpInt;
+ PageItem *ite;
+ QString command = "";
+ QString Cdata = "";
+ QStringList da;
+ getCommands(data, da);
+ for (int a = 0; a < da.count(); a++)
+ {
+ Cdata = da[a];
+ if (((Cdata.startsWith("%")) || (Cdata.startsWith(" %"))) && (!meshMode))
+ continue;
+ QStringList da2 = Cdata.split(" ", QString::SkipEmptyParts);
+ if (da2.count() == 0)
+ return;
+ command = da2[da2.count()-1];
+/* Start Path construction commands */
+ if (command == "m")
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> x >> y;
+ Coords.svgMoveTo(x - docX, docHeight - (y - docY));
+ currentPoint = FPoint(x - docX, docHeight - (y - docY));
+ }
+ else if ((command == "L") || (command == "l"))
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> x >> y;
+ Coords.svgLineTo(x - docX, docHeight - (y - docY));
+ currentPoint = FPoint(x - docX, docHeight - (y - docY));
+ }
+ else if ((command == "C") || (command == "c"))
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> x >> y >> x1 >> y1 >> x2 >> y2;
+ Coords.svgCurveToCubic(x - docX, docHeight - (y - docY),
+ x1 - docX, docHeight - (y1 - docY),
+ x2 - docX, docHeight - (y2 - docY));
+ currentPoint = FPoint(x2 - docX, docHeight - (y2 - docY));
+ }
+ else if ((command == "Y") || (command == "y"))
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> x1 >> y1 >> x2 >> y2;
+ Coords.svgCurveToCubic(currentPoint.x(), currentPoint.y(),
+ x1 - docX, docHeight - (y1 - docY),
+ x2 - docX, docHeight - (y2 - docY));
+ currentPoint = FPoint(x2 - docX, docHeight - (y2 - docY));
+ }
+ else if ((command == "V") || (command == "v"))
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> x >> y >> x2 >> y2;
+ Coords.svgCurveToCubic(x - docX, docHeight - (y - docY),
+ currentPoint.x(), currentPoint.y(),
+ x2 - docX, docHeight - (y2 - docY));
+ currentPoint = FPoint(x2 - docX, docHeight - (y2 - docY));
+ }
+/* End Path construction commands */
+/* Start Object creation commands */
+ else if ((command == "b") || (command == "B") || (command == "f") || (command == "F") || (command == "s") || (command == "S"))
+ {
+ if (Coords.size() > 3)
+ {
+ if ((!WasU) || ((WasU) && (FirstU)))
+ {
+ if ((command == "B") || (command == "F") || (command == "S"))
+ {
+ if (command == "F")
+ z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CommonStrings::None, true);
+ else if (command == "B")
+ z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
+ else
+ z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColorStroke, true);
+ }
+ else
+ {
+ if (command == "f")
+ z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CommonStrings::None, true);
+ else if (command == "b")
+ z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColorFill, CurrColorStroke, true);
+ else
+ z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColorStroke, true);
+ }
+ ite = m_Doc->Items->at(z);
+ ite->PoLine = Coords.copy();
+ ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
+ ite->ClipEdited = true;
+ ite->FrameType = 3;
+ ite->setFillShade(CurrFillShade);
+ ite->setLineShade(CurrStrokeShade);
+ ite->setFillEvenOdd(fillRule);
+ ite->setFillTransparency(1.0 - Opacity);
+ ite->setLineTransparency(1.0 - Opacity);
+#ifdef HAVE_CAIRO
+ #if (CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 9, 4))
+ ite->setFillBlendmode(blendMode);
+ ite->setLineBlendmode(blendMode);
+ #endif
+#endif
+ if (!currentPatternName.isEmpty())
+ {
+ ite->setPattern(currentPatternName);
+ ite->setPatternTransform(currentPatternXScale * 100, currentPatternYScale * 100, currentPatternX, currentPatternY, currentPatternRotation, 0.0, 0.0);
+ ite->GrType = 8;
+ currentPatternName = "";
+ }
+ if (!currentStrokePatternName.isEmpty())
+ {
+ ite->setStrokePattern(currentStrokePatternName);
+ ite->setStrokePatternTransform(currentStrokePatternXScale * 100, currentStrokePatternYScale * 100, currentStrokePatternX, currentStrokePatternY, currentStrokePatternRotation, 0.0, 0.0);
+ currentStrokePatternName = "";
+ }
+ ite->setLineEnd(CapStyle);
+ ite->setLineJoin(JoinStyle);
+ if (importerFlags & LoadSavePlugin::lfCreateDoc)
+ ite->setLocked(itemLocked);
+ if (!WasU)
+ {
+ FPoint wh = getMaxClipF(&ite->PoLine);
+ ite->setWidthHeight(wh.x(),wh.y());
+ ite->setTextFlowMode(PageItem::TextFlowDisabled);
+ m_Doc->AdjustItemSize(ite);
+ }
+ if (patternMode)
+ PatternElements.append(ite);
+ else
+ Elements.append(ite);
+ if (groupStack.count() != 0)
+ groupStack.top().append(ite);
+
+ }
+ else
+ {
+ ite = m_Doc->Items->at(m_Doc->Items->count()-1);
+ ite->PoLine.setMarker();
+ Coords.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
+ ite->PoLine.putPoints(ite->PoLine.size(), Coords.size(), Coords);
+ }
+ Coords.resize(0);
+ Coords.svgInit();
+ FirstU = false;
+ itemRendered = true;
+ }
+ }
+ else if (command == "*u")
+ {
+ FirstU = true;
+ WasU = true;
+ }
+ else if (command == "*U")
+ {
+ WasU = false;
+ ite = m_Doc->Items->at(m_Doc->Items->count()-1);
+ FPoint wh = getMaxClipF(&ite->PoLine);
+ ite->setWidthHeight(wh.x(),wh.y());
+ m_Doc->AdjustItemSize(ite);
+ }
+ else if ((command == "u") || (command == "q"))
+ {
+ QList<PageItem*> gElements;
+ groupStack.push(gElements);
+ }
+ else if ((command == "U") || (command == "Q"))
+ {
+ if (groupStack.count() != 0)
+ {
+ QList<PageItem*> gElements = groupStack.pop();
+ tmpSel->clear();
+ if (gElements.count() > 0)
+ {
+ for (int dre = 0; dre < gElements.count(); ++dre)
+ {
+ tmpSel->addItem(gElements.at(dre), true);
+ }
+ m_Doc->itemSelection_GroupObjects(false, false, tmpSel);
+ ite = tmpSel->itemAt(0);
+ if ((clipCoords.size() > 4) && (command == "Q"))
+ {
+ ite = tmpSel->itemAt(0);
+ clipCoords.translate(m_Doc->currentPage()->xOffset()-ite->xPos(), m_Doc->currentPage()->yOffset()-ite->yPos());
+ ite->PoLine = clipCoords.copy();
+ ite->PoLine.translate(baseX, baseY);
+ }
+ if (patternMode)
+ PatternElements.append(ite);
+ else
+ Elements.append(ite);
+ }
+ if (groupStack.count() != 0)
+ {
+ for (int as = 0; as < tmpSel->count(); ++as)
+ {
+ groupStack.top().append(tmpSel->itemAt(as));
+ }
+ }
+ tmpSel->clear();
+ }
+ if (command == "Q")
+ {
+ clipCoords.resize(0);
+ clipCoords.svgInit();
+ }
+ }
+ else if (command == "W")
+ {
+ if (clipCoords.size() > 0)
+ clipCoords.setMarker();
+ clipCoords.putPoints(clipCoords.size(), Coords.size(), Coords);
+ }
+/* End Object construction commands */
+/* Start Graphics state commands */
+ else if (command == "A")
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> tmpInt;
+ if (tmpInt == 1)
+ itemLocked = true;
+ else
+ itemLocked = false;
+ }
+ else if (command == "w")
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> LineW;
+ }
+ else if (command == "j")
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> tmpInt;
+ if (tmpInt == 0)
+ JoinStyle = Qt::MiterJoin;
+ else if (tmpInt == 1)
+ JoinStyle = Qt::RoundJoin;
+ else if (tmpInt == 1)
+ JoinStyle = Qt::BevelJoin;
+ }
+ else if (command == "J")
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> tmpInt;
+ if (tmpInt == 0)
+ CapStyle = Qt::FlatCap;
+ else if (tmpInt == 1)
+ CapStyle = Qt::RoundCap;
+ else if (tmpInt == 1)
+ CapStyle = Qt::SquareCap;
+ }
+ /* undocumented Command Xy
+ - has up to 5 Parameters
+ - first Parameter might be the Blendmode
+ - second Parameter is the Opacity
+ */
+ else if (command == "Xy")
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> blendMode >> Opacity;
+ }
+ else if (command == "XR")
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> tmpInt;
+ if (tmpInt == 1)
+ fillRule = true;
+ else
+ fillRule = false;
+ }
+ else if (command == "Bb")
+ {
+ gradientMode = true;
+ wasBC = false;
+ itemRendered = false;
+ startMatrix = QTransform();
+ endMatrix = QTransform();
+ }
+ else if (command == "Xm")
+ {
+ ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
+ double m1, m2, m3, m4, m5, m6;
+ gVals >> m1 >> m2 >> m3 >> m4 >> m5 >> m6;
+ startMatrix.translate(m5, -m6);
+ endMatrix.scale(m1, m4);
+ wasBC = true;
+ }
+ else if (command == "Bm")
+ {
+ if (m_gradients[currentGradientName].type() == 1)
+ {
+ ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
+ double m1, m2, m3, m4, m5, m6;
+ gVals >> m1 >> m2 >> m3 >> m4 >> m5 >> m6;
+ startMatrix.translate(m5, -m6);
+// endMatrix.scale(m1, m4);
+ endMatrix *= QTransform(m1, m2, m3, m4, 0, 0);
+// endMatrix = QTransform(m1, m2, m3, m4, m5, m6);
+ wasBC = true;
+ }
+ }
+ else if (command == "BB")
+ {
+ if (itemRendered)
+ {
+ gradientMode = false;
+ ite = m_Doc->Items->at(m_Doc->Items->count()-1);
+ ite->fill_gradient = m_gradients[currentGradientName];
+ ite->setGradient(currentGradientName);
+ if (ite->fill_gradient.type() == 0)
+ ite->GrType = 6;
+ else
+ ite->GrType = 7;
+ QTransform m1;
+ m1.translate(currentGradientOrigin.x() - ite->xPos(), currentGradientOrigin.y() - ite->yPos());
+ m1.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
+ m1.rotate(-currentGradientAngle);
+ ite->GrStartX = currentGradientOrigin.x() - ite->xPos() + m_Doc->currentPage()->xOffset();
+ ite->GrStartY = currentGradientOrigin.y() - ite->yPos() + m_Doc->currentPage()->yOffset();
+ QPointF target = m1.map(QPointF(currentGradientLenght, 0.0));
+ ite->GrEndX = target.x();
+ ite->GrEndY = target.y();
+ if (wasBC)
+ {
+ QPointF newS = startMatrix.map(QPointF(ite->GrStartX, ite->GrStartY));
+ ite->GrStartX = newS.x();
+ ite->GrStartY = newS.y();
+ QTransform m2;
+ m2.rotate(-currentGradientAngle);
+ m2 *= endMatrix;
+ QPointF target = m2.map(QPointF(currentGradientLenght, 0.0));
+ ite->GrEndX = target.x();
+ ite->GrEndY = target.y();
+ }
+ }
+ wasBC = false;
+ currentGradientMatrix = QTransform();
+ currentGradientOrigin = QPointF(0.0, 0.0);
+ currentGradientAngle = 0.0;
+ currentGradientLenght = 1.0;
+ itemRendered = false;
+ }
+ else if (command == "Bg")
+ {
+ int an = Cdata.indexOf("(");
+ int en = Cdata.lastIndexOf(")");
+ currentGradientName = Cdata.mid(an+1, en-an-1);
+ currentGradientName.remove("\\");
+ QString tmpS = Cdata.mid(en+1, Cdata.size() - en);
+ ScTextStream gVals(&tmpS, QIODevice::ReadOnly);
+ double xOrig, yOrig, m1, m2, m3, m4, m5, m6;
+ gVals >> xOrig >> yOrig >> currentGradientAngle >> currentGradientLenght >> m1 >> m2 >> m3 >> m4 >> m5 >> m6;
+ currentGradientOrigin = QPointF(xOrig - docX, docHeight - (yOrig - docY));
+ currentGradientMatrix = QTransform(m1, m2, m3, m4, m5, m6);
+ }
+/* End Graphics state commands */
+/* Start Color commands */
+ else if ((command == "G") || (command == "g"))
+ {
+ if (command == "G")
+ CurrColorStroke = parseColorGray(Cdata);
+ else
+ CurrColorFill = parseColorGray(Cdata);
+ }
+ else if ((command == "K") || (command == "k"))
+ {
+ if (command == "K")
+ CurrColorStroke = parseColor(Cdata);
+ else
+ CurrColorFill = parseColor(Cdata);
+ }
+ else if ((command == "XA") || (command == "Xa"))
+ {
+ QString Xdata = da2[da2.count()-4] + " " + da2[da2.count()-3] + " " + da2[da2.count()-2];
+ if (command == "XA")
+ CurrColorStroke = parseColorRGB(Xdata);
+ else
+ CurrColorFill = parseColorRGB(Xdata);
+ }
+ else if ((command == "XX") || (command == "Xx") || (command == "Xk"))
+ {
+ if (command == "XX")
+ CurrColorStroke = parseCustomColorX(Cdata, CurrStrokeShade, da2[da2.count()-2]);
+ else
+ CurrColorFill = parseCustomColorX(Cdata, CurrFillShade, da2[da2.count()-2]);
+ }
+ else if ((command == "X") || (command == "x"))
+ {
+ if (command == "X")
+ CurrColorStroke = parseCustomColor(Cdata, CurrStrokeShade);
+ else
+ CurrColorFill = parseCustomColor(Cdata, CurrFillShade);
+ }
+ else if (command == "p")
+ {
+ int an = Cdata.indexOf("(");
+ int en = Cdata.lastIndexOf(")");
+ currentPatternName = Cdata.mid(an+1, en-an-1);
+ currentPatternName.remove("\\");
+ currentPatternName = currentPatternName.trimmed().simplified().replace(" ", "_");
+ QString tmpS = Cdata.mid(en+1, Cdata.size() - en);
+ ScTextStream gVals(&tmpS, QIODevice::ReadOnly);
+ gVals >> currentPatternX >> currentPatternY >> currentPatternXScale >> currentPatternYScale >> currentPatternRotation;
+ }
+ else if (command == "P")
+ {
+ int an = Cdata.indexOf("(");
+ int en = Cdata.lastIndexOf(")");
+ currentStrokePatternName = Cdata.mid(an+1, en-an-1);
+ currentStrokePatternName.remove("\\");
+ currentStrokePatternName = currentPatternName.trimmed().simplified().replace(" ", "_");
+ QString tmpS = Cdata.mid(en+1, Cdata.size() - en);
+ ScTextStream gVals(&tmpS, QIODevice::ReadOnly);
+ gVals >> currentStrokePatternX >> currentStrokePatternY >> currentStrokePatternXScale >> currentStrokePatternYScale >> currentStrokePatternRotation;
+ }
+ else if (command == "X!")
+ {
+ if (Cdata.contains("/Mesh"))
+ {
+ QList<PageItem*> gElements;
+ groupStack.push(gElements);
+ meshMode = true;
+ meshNodeCounter = 0;
+ accumColorC = 0.0;
+ accumColorM = 0.0;
+ accumColorY = 0.0;
+ accumColorK = 0.0;
+ meshColorMode = 0;
+ // meshBoundingPath = QPainterPath();
+ }
+ if (Cdata.contains("/End"))
+ {
+ meshMode = false;
+ if (groupStack.count() != 0)
+ {
+ QList<PageItem*> gElements = groupStack.pop();
+ tmpSel->clear();
+ if (gElements.count() > 0)
+ {
+ for (int dre = 0; dre < gElements.count(); ++dre)
+ {
+ tmpSel->addItem(gElements.at(dre), true);
+ }
+ m_Doc->itemSelection_GroupObjects(false, false, tmpSel);
+ ite = tmpSel->itemAt(0);
+ /* if (!meshBoundingPath.isEmpty())
+ {
+ ite = tmpSel->itemAt(0);
+ clipCoords.fromQPainterPath(meshBoundingPath);
+ clipCoords.translate(m_Doc->currentPage()->xOffset()-ite->xPos(), m_Doc->currentPage()->yOffset()-ite->yPos());
+ ite->PoLine = clipCoords.copy();
+ ite->PoLine.translate(baseX, baseY);
+ } */
+ if (patternMode)
+ PatternElements.append(ite);
+ else
+ Elements.append(ite);
+ }
+ if (groupStack.count() != 0)
+ {
+ for (int as = 0; as < tmpSel->count(); ++as)
+ {
+ groupStack.top().append(tmpSel->itemAt(as));
+ }
+ }
+ tmpSel->clear();
+ }
+ }
+ }
+ else if (command == "X#")
+ {
+ int an = Cdata.indexOf("_");
+ QString cmdLine = Cdata.remove(0, an+1);
+ an = cmdLine.lastIndexOf("/");
+ QString tmpS = cmdLine.mid(an+1, Cdata.size());
+ ScTextStream mVals(&tmpS, QIODevice::ReadOnly);
+ QString mKey;
+ mVals >> mKey;
+ if (mKey == "Size")
+ {
+ int ans = cmdLine.indexOf("[");
+ int ens = cmdLine.lastIndexOf("]");
+ QString sizeVals = cmdLine.mid(ans+1, ens-ans-1);
+ ScTextStream mVals2(&sizeVals, QIODevice::ReadOnly);
+ mVals2 >> meshXSize >> meshYSize;
+ }
+ if (mKey == "P")
+ {
+ int ans = cmdLine.indexOf("[");
+ int ens = cmdLine.lastIndexOf("]");
+ QString posVals = cmdLine.mid(ans+1, ens-ans-1);
+ ScTextStream mVals3(&posVals, QIODevice::ReadOnly);
+ mVals3 >> currentMeshXPos >> currentMeshYPos;
+ accumColorC = 0.0;
+ accumColorM = 0.0;
+ accumColorY = 0.0;
+ accumColorK = 0.0;
+ }
+ if (mKey == "CS")
+ {
+ if (Cdata.contains("CMYK"))
+ meshColorMode = 0;
+ else if (Cdata.contains("RGB"))
+ meshColorMode = 1;
+ }
+ if (mKey == "E")
+ {
+ ScColor tmpColor;
+ ColorList::Iterator it;
+ int Cc = qRound((accumColorC / 4.0) * 255);
+ int Mc = qRound((accumColorM / 4.0) * 255);
+ int Yc = qRound((accumColorY / 4.0) * 255);
+ int Kc = qRound((accumColorK / 4.0) * 255);
+ int hC, hM, hY, hK;
+ bool found = false;
+ if (meshColorMode == 0)
+ {
+ tmpColor.setColor(Cc, Mc, Yc, Kc);
+ for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
+ {
+ if (it.value().getColorModel() == colorModelCMYK)
+ {
+ it.value().getCMYK(&hC, &hM, &hY, &hK);
+ if ((Cc == hC) && (Mc == hM) && (Yc == hY) && (Kc == hK))
+ {
+ CurrColorFill = it.key();
+ found = true;
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ tmpColor.setColorRGB(Cc, Mc, Yc);
+ for (it = m_Doc->PageColors.begin(); it != m_Doc->PageColors.end(); ++it)
+ {
+ if (it.value().getColorModel() == colorModelRGB)
+ {
+ it.value().getRGB(&hC, &hM, &hY);
+ if ((Cc == hC) && (Mc == hM) && (Yc == hY))
+ {
+ CurrColorFill = it.key();
+ found = true;
+ break;
+ }
+ }
+ }
+ }
+ if (!found)
+ {
+ tmpColor.setSpotColor(false);
+ tmpColor.setRegistrationColor(false);
+ QString namPrefix = "FromAI";
+ m_Doc->PageColors.insert(namPrefix+tmpColor.name(), tmpColor);
+ CurrColorFill = namPrefix+tmpColor.name();
+ }
+ meshNodeCounter = 0;
+ Coords.resize(0);
+ Coords.svgInit();
+ Coords.svgMoveTo(meshNode1PointX, meshNode1PointY);
+ Coords.svgCurveToCubic(meshNode1Control2X, meshNode1Control2Y, meshNode2Control1X, meshNode2Control1Y, meshNode2PointX, meshNode2PointY);
+ Coords.svgCurveToCubic(meshNode2Control2X, meshNode2Control2Y, meshNode3Control1X, meshNode3Control1Y, meshNode3PointX, meshNode3PointY);
+ Coords.svgCurveToCubic(meshNode3Control2X, meshNode3Control2Y, meshNode4Control1X, meshNode4Control1Y, meshNode4PointX, meshNode4PointY);
+ Coords.svgCurveToCubic(meshNode4Control2X, meshNode4Control2Y, meshNode1Control1X, meshNode1Control1Y, meshNode1PointX, meshNode1PointY);
+ z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, 0, CurrColorFill, CurrColorFill, true);
+ ite = m_Doc->Items->at(z);
+ ite->PoLine = Coords.copy();
+ // QPainterPath tmpPath = Coords.toQPainterPath(true);
+ // meshBoundingPath = meshBoundingPath.united(tmpPath);
+ ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
+ ite->ClipEdited = true;
+ ite->FrameType = 3;
+ ite->setFillShade(CurrFillShade);
+ ite->setLineShade(CurrFillShade);
+ ite->setFillEvenOdd(fillRule);
+ ite->setFillTransparency(1.0 - Opacity);
+ ite->setLineTransparency(1.0 - Opacity);
+ ite->setLineEnd(CapStyle);
+ ite->setLineJoin(JoinStyle);
+ if (importerFlags & LoadSavePlugin::lfCreateDoc)
+ ite->setLocked(itemLocked);
+ FPoint wh = getMaxClipF(&ite->PoLine);
+ ite->setWidthHeight(wh.x(),wh.y());
+ ite->setTextFlowMode(PageItem::TextFlowDisabled);
+ m_Doc->AdjustItemSize(ite);
+ if (patternMode)
+ PatternElements.append(ite);
+ else
+ Elements.append(ite);
+ if (groupStack.count() != 0)
+ groupStack.top().append(ite);
+ Coords.resize(0);
+ Coords.svgInit();
+ }
+ if (mKey == "N")
+ {
+ double cVal, mVal, yVal, kVal, coorX1, coorY1, coorX2, coorY2, coorX3, coorY3;
+ int dummy;
+ meshNodeCounter++;
+ int ans = cmdLine.indexOf("[");
+ int ens = cmdLine.lastIndexOf("]");
+ QString nodeVals = cmdLine.mid(ans+1, ens-ans-1);
+ ScTextStream mVals4(&nodeVals, QIODevice::ReadOnly);
+ kVal = 0.0;
+ if (meshColorMode == 0)
+ mVals4 >> cVal >> mVal >> yVal >> kVal >> coorX1 >> coorY1 >> coorX2 >> coorY2 >> dummy >> coorX3 >> coorY3;
+ else
+ mVals4 >> cVal >> mVal >> yVal >> coorX1 >> coorY1 >> coorX2 >> coorY2 >> dummy >> coorX3 >> coorY3;
+ accumColorC += cVal;
+ accumColorM += mVal;
+ accumColorY += yVal;
+ accumColorK += kVal;
+ if (meshNodeCounter == 1)
+ {
+ meshNode1PointX = coorX1 - docX;
+ meshNode1PointY = docHeight - (coorY1 - docY);
+ meshNode1Control2X = coorX2 - docX;
+ meshNode1Control2Y = docHeight - (coorY2 - docY);
+ meshNode1Control1X = coorX3 - docX;
+ meshNode1Control1Y = docHeight - (coorY3 - docY);
+ }
+ if (meshNodeCounter == 2)
+ {
+ meshNode2PointX = coorX1 - docX;
+ meshNode2PointY = docHeight - (coorY1 - docY);
+ meshNode2Control2X = coorX2 - docX;
+ meshNode2Control2Y = docHeight - (coorY2 - docY);
+ meshNode2Control1X = coorX3 - docX;
+ meshNode2Control1Y = docHeight - (coorY3 - docY);
+ }
+ if (meshNodeCounter == 3)
+ {
+ meshNode3PointX = coorX1 - docX;
+ meshNode3PointY = docHeight - (coorY1 - docY);
+ meshNode3Control2X = coorX2 - docX;
+ meshNode3Control2Y = docHeight - (coorY2 - docY);
+ meshNode3Control1X = coorX3 - docX;
+ meshNode3Control1Y = docHeight - (coorY3 - docY);
+ }
+ if (meshNodeCounter == 4)
+ {
+ meshNode4PointX = coorX1 - docX;
+ meshNode4PointY = docHeight - (coorY1 - docY);
+ meshNode4Control2X = coorX2 - docX;
+ meshNode4Control2Y = docHeight - (coorY2 - docY);
+ meshNode4Control1X = coorX3 - docX;
+ meshNode4Control1Y = docHeight - (coorY3 - docY);
+ }
+ }
+ }
+/* End Color commands */
+/* Start Layer commands */
+ else if (command == "Lb")
+ {
+ if (importerFlags & LoadSavePlugin::lfCreateDoc)
+ {
+ int visible, preview, enabled, printing, dummy, rc, gc, bc;
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> visible >> preview >> enabled >> printing >> dummy >> dummy >> dummy >> rc >> gc >> bc;
+ if (!firstLayer)
+ currentLayer = m_Doc->addLayer("Layer", true);
+ m_Doc->setLayerVisible(currentLayer, static_cast<bool>(visible));
+ m_Doc->setLayerOutline(currentLayer, static_cast<bool>(!preview));
+ m_Doc->setLayerLocked(currentLayer, static_cast<bool>(!enabled));
+ m_Doc->setLayerPrintable(currentLayer, static_cast<bool>(printing));
+ m_Doc->setLayerMarker(currentLayer, QColor(rc, gc, bc));
+ firstLayer = false;
+ }
+ Coords.resize(0);
+ Coords.svgInit();
+ }
+ else if (command == "LB")
+ {
+ Coords.resize(0);
+ Coords.svgInit();
+ }
+ else if (command == "Ln")
+ {
+ if (importerFlags & LoadSavePlugin::lfCreateDoc)
+ {
+ int an = Cdata.indexOf("(");
+ int en = Cdata.lastIndexOf(")");
+ QString LayerNam = Cdata.mid(an+1, en-an-1);
+ LayerNam.remove("\\");
+ m_Doc->changeLayerName(currentLayer, LayerNam);
+ }
+ }
+/* End Layer commands */
+/* Start Text commands */
+ else if (command == "To")
+ {
+ ScTextStream ts2(&Cdata, QIODevice::ReadOnly);
+ ts2 >> textMode;
+ textData.clear();
+ textMatrix = QTransform();
+ maxWidth = 0;
+ tempW = 0;
+ maxHeight = 0;
+ textKern = 0;
+ startCurrentTextRange = 0;
+ endCurrentTextRange = 0;
+ textScaleH = 1000;
+ textScaleV = 1000;
+ }
+ else if (command == "Tp")
+ {
+ ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
+ double m1, m2, m3, m4, m5, m6;
+ gVals >> m1 >> m2 >> m3 >> m4 >> m5 >> m6;
+ textMatrix = QTransform(m1, m2, m3, m4, m5, m6);
+ }
+ else if (command == "Tx") // || (command == "TX"))
+ {
+ QStringList res = getStrings(Cdata);
+ if (res.count() > 0)
+ {
+ QString tex = res[0];
+ double tempH = 0;
+ startCurrentTextRange = textData.length();
+ for (int tt = 0; tt < tex.length(); ++tt)
+ {
+ CharStyle nstyle;
+ QString ch = tex.mid(tt,1);
+ nstyle.setFont((*m_Doc->AllFonts)[textFont]);
+ nstyle.setFontSize(textSize);
+ nstyle.setFillColor(CurrColorFill);
+ nstyle.setTracking(textKern);
+ nstyle.setFillShade(100);
+ nstyle.setStrokeColor(CurrColorStroke);
+ nstyle.setStrokeShade(100);
+ nstyle.setScaleH(textScaleH);
+ nstyle.setScaleV(textScaleV);
+ nstyle.setBaselineOffset(0);
+ nstyle.setShadowXOffset(50);
+ nstyle.setShadowYOffset(-50);
+ nstyle.setOutlineWidth(10);
+ nstyle.setUnderlineOffset(-1);
+ nstyle.setUnderlineWidth(-1);
+ nstyle.setStrikethruOffset(-1);
+ nstyle.setStrikethruWidth(-1);
+ nstyle.setFeatures(StyleFlag(ScStyle_Default).featureList());
+ int pot = textData.length();
+ textData.insertChars(pot, ch);
+ textData.applyCharStyle(pot, 1, nstyle);
+ tempW += nstyle.font().realCharWidth(ch[0], nstyle.fontSize() / 10.0)+1;
+ tempH = qMax(tempH, nstyle.font().height(nstyle.fontSize() / 10.0) + 2.0);
+ maxWidth = qMax(tempW, maxWidth);
+ maxHeight = qMax(tempH, maxHeight);
+ if ((ch == SpecialChars::PARSEP) || (ch == SpecialChars::LINEBREAK))
+ {
+ maxHeight += nstyle.font().height(nstyle.fontSize() / 10.0);
+ tempW = 0;
+ }
+ endCurrentTextRange = pot;
+ }
+ }
+ }
+ else if (command == "Tk")
+ {
+ int flag;
+ double val;
+ ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
+ gVals >> flag >> val;
+ if (flag == 1)
+ val = 0;
+ double oldval = textData.charStyle(startCurrentTextRange).tracking();
+ CharStyle nstyle = textData.charStyle(startCurrentTextRange);
+ nstyle.setTracking(oldval + val);
+ textData.applyCharStyle(startCurrentTextRange, 1, nstyle);
+ }
+ else if (command == "Tc")
+ {
+ ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
+ gVals >> textKern;
+ textKern *= 100.0;
+ }
+ else if (command == "Tz")
+ {
+ ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
+ gVals >> textScaleH >> textScaleV;
+ textScaleH *= 10.0;
+ textScaleV *= 10.0;
+ }
+ else if (command == "T*")
+ {
+ CharStyle nstyle;
+ QString ch = SpecialChars::LINEBREAK;
+ nstyle.setFont((*m_Doc->AllFonts)[textFont]);
+ nstyle.setFontSize(textSize);
+ nstyle.setFillColor(CurrColorFill);
+ nstyle.setTracking(textKern);
+ nstyle.setFillShade(100);
+ nstyle.setStrokeColor(CurrColorStroke);
+ nstyle.setStrokeShade(100);
+ nstyle.setScaleH(textScaleH);
+ nstyle.setScaleV(textScaleV);
+ nstyle.setBaselineOffset(0);
+ nstyle.setShadowXOffset(50);
+ nstyle.setShadowYOffset(-50);
+ nstyle.setOutlineWidth(10);
+ nstyle.setUnderlineOffset(-1);
+ nstyle.setUnderlineWidth(-1);
+ nstyle.setStrikethruOffset(-1);
+ nstyle.setStrikethruWidth(-1);
+ nstyle.setFeatures(StyleFlag(ScStyle_Default).featureList());
+ int pot = textData.length();
+ textData.insertChars(pot, ch);
+ textData.applyCharStyle(pot, 1, nstyle);
+ maxHeight += nstyle.font().height(nstyle.fontSize() / 10.0) + 2.0;
+ tempW = 0;
+ }
+ else if (command == "Tf")
+ {
+ ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
+ gVals >> textFont >> textSize;
+ textFont.remove(0, 2);
+ QString family = textFont;
+ QString ret = "";
+ family.replace( QRegExp( "'" ) , QChar( ' ' ) );
+ textFont = m_Doc->itemToolPrefs.textFont;
+ bool found = false;
+ SCFontsIterator it(PrefsManager::instance()->appPrefs.fontPrefs.AvailFonts);
+ for ( ; it.hasNext(); it.next())
+ {
+ QString fam;
+ QString fn = it.current().scName();
+ int pos = fn.indexOf(" ");
+ fam = fn.left(pos);
+ if (fam == family)
+ {
+ found = true;
+ ret = fn;
+ }
+ }
+ if (found)
+ textFont = family;
+ else
+ {
+ if (!PrefsManager::instance()->appPrefs.fontPrefs.GFontSub.contains(family))
+ {
+ qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
+ MissingFont *dia = new MissingFont(0, family, m_Doc);
+ dia->exec();
+ QString tmpf = dia->getReplacementFont();
+ delete dia;
+ qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
+ PrefsManager::instance()->appPrefs.fontPrefs.GFontSub[family] = tmpf;
+ }
+ else
+ textFont = PrefsManager::instance()->appPrefs.fontPrefs.GFontSub[family];
+ }
+ textSize *= 10.0;
+ }
+ else if (command == "TO")
+ {
+ if (textData.length() > 0)
+ {
+ if (!((textData.length() == 1) && (textData.text(0) == SpecialChars::PARSEP)))
+ {
+ QPointF pos = QPointF(textMatrix.dx(), textMatrix.dy());
+ pos += QPointF(m_Doc->currentPage()->xOffset(), -m_Doc->currentPage()->yOffset());
+ pos += QPointF(0.0, textSize / 10.0 + 2.0);
+ z = m_Doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, pos.x() - docX, docHeight - (pos.y() - docY), 10, 10, 0, CommonStrings::None, CommonStrings::None, true);
+ ite = m_Doc->Items->at(z);
+ ite->setTextToFrameDist(0.0, 0.0, 0.0, 0.0);
+ ite->itemText.append(textData);
+ double xpos = ite->xPos();
+ double ypos = ite->yPos();
+ ite->setWidthHeight(qMax(ite->width(), maxWidth), qMax(ite->height(), maxHeight));
+ double xoffset = 0.0, yoffset = 0.0;
+ double rotation = getRotationFromMatrix(textMatrix, 0.0);
+ if (rotation != 0.0)
+ {
+ double temp = textSize / 10.0 + 2.0;
+ xoffset = sin(rotation) * temp;
+ yoffset = cos(rotation) * temp;
+ }
+ ite->setXPos(xpos + xoffset);
+ ite->setYPos(ypos + yoffset);
+ ite->setRotation(rotation * 180 / M_PI);
+ ite->SetRectFrame();
+ m_Doc->setRedrawBounding(ite);
+ ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
+ ite->setTextFlowMode(PageItem::TextFlowDisabled);
+ ite->setFillShade(CurrFillShade);
+ ite->setLineShade(CurrStrokeShade);
+ ite->setFillEvenOdd(fillRule);
+ ite->setFillTransparency(1.0 - Opacity);
+ ite->setLineTransparency(1.0 - Opacity);
+ ite->setLineEnd(CapStyle);
+ ite->setLineJoin(JoinStyle);
+ if (importerFlags & LoadSavePlugin::lfCreateDoc)
+ ite->setLocked(itemLocked);
+ if (patternMode)
+ PatternElements.append(ite);
+ else
+ Elements.append(ite);
+ if (groupStack.count() != 0)
+ groupStack.top().append(ite);
+ }
+ }
+ }
+/* End Text commands */
+/* Start special Commands */
+ else if (command == "*")
+ {
+ Coords.resize(0);
+ Coords.svgInit();
+ }
+ else if ((command == "N") || (command == "n"))
+ {
+ Coords.resize(0);
+ Coords.svgInit();
+ }
+ else if (command == "[")
+ {
+ Coords.resize(0);
+ Coords.svgInit();
+ int an = Cdata.indexOf("(");
+ int en = Cdata.lastIndexOf(")");
+ if ((an != -1) && (en != -1))
+ {
+ patternMode = true;
+ currentPatternDefName = Cdata.mid(an+1, en-an-1);
+ currentPatternDefName.remove("\\");
+ currentPatternDefName = currentPatternDefName.trimmed().simplified().replace(" ", "_");
+ QString tmpS = Cdata.mid(en+1, Cdata.size() - en);
+ ScTextStream gVals(&tmpS, QIODevice::ReadOnly);
+ gVals >> patternX1 >> patternY1 >> patternX2 >> patternY2;
+ }
+ }
+/* End special Commands */
+/* Skip everything else */
+// else
+// qDebug(command);
+ }
+}
+
+void AIPlug::processGradientData(QString data)
+{
+ QString command = "";
+ QString Cdata = "";
+ QStringList da;
+ getCommands(data, da);
+ for (int a = 0; a < da.count(); a++)
+ {
+ Cdata = da[a];
+ QStringList da2 = Cdata.split(" ", QString::SkipEmptyParts);
+ command = da2[da2.count()-1];
+ if (command == "Bd")
+ {
+ QString tmpS = Cdata;
+ int an = Cdata.indexOf("(");
+ int en = Cdata.lastIndexOf(")");
+ currentGradientName = Cdata.mid(an+1, en-an-1);
+ currentGradientName.remove("\\");
+ if (da2[da2.count()-3] == "0")
+ currentGradient = VGradient(VGradient::linear);
+ else
+ currentGradient = VGradient(VGradient::radial);
+ currentGradient.clearStops();
+ }
+ else if ((command == "%_Bs") || (command == "%_BS"))
+ {
+ QString stopName = "";
+ double stop = ScCLocale::toDoubleC(da2[da2.count()-2]) / 100.0;
+ double colorShade = 100.0;
+ int colortype = da2[da2.count()-4].toInt();
+ if (colortype == 0)
+ {
+ stopName = parseColorGray(Cdata);
+ const ScColor& gradC = m_Doc->PageColors[stopName];
+ currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), stop, 0.5, 1.0, stopName, 100 );
+ }
+ else if (colortype == 1)
+ {
+ stopName = parseColor(Cdata);
+ const ScColor& gradC = m_Doc->PageColors[stopName];
+ currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), stop, 0.5, 1.0, stopName, 100 );
+ }
+ else if (colortype == 2)
+ {
+ stopName = parseColor(Cdata);
+ const ScColor& gradC = m_Doc->PageColors[stopName];
+ currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), stop, 0.5, 1.0, stopName, 100 );
+ }
+ else if (colortype == 3)
+ {
+ stopName = parseCustomColor(Cdata, colorShade);
+ const ScColor& gradC = m_Doc->PageColors[stopName];
+ currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), stop, 0.5, 1.0, stopName, qRound(colorShade));
+ }
+ else if (colortype == 4)
+ {
+ stopName = parseCustomColorX(Cdata, colorShade, "0");
+ const ScColor& gradC = m_Doc->PageColors[stopName];
+ currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), stop, 0.5, 1.0, stopName, qRound(colorShade));
+ }
+ else if (colortype == 6)
+ {
+ stopName = parseColor(Cdata);
+ const ScColor& gradC = m_Doc->PageColors[stopName];
+ currentGradient.addStop( ScColorEngine::getRGBColor(gradC, m_Doc), stop, 0.5, 1.0, stopName, 100 );
+ }
+ }
+ else if (command == "BD")
+ {
+ m_gradients.insert(currentGradientName, currentGradient);
+ if (m_Doc->addGradient(currentGradientName, currentGradient))
+ importedGradients.append(currentGradientName);
+ currentGradient = VGradient(VGradient::linear);
+ currentGradient.clearStops();
+ currentGradient.setRepeatMethod( VGradient::none );
+ currentGradientName = "";
+ }
+ }
+}
+
+void AIPlug::processPattern(QDataStream &ts)
+{
+ QString tmp = "";
+ QString tmpData = "";
+ while (!ts.atEnd())
+ {
+ tmp = removeAIPrefix(readLinefromDataStream(ts));
+ if (patternMode)
+ {
+ if (tmp == "EndPattern")
+ {
+ tmpSel->clear();
+ if (PatternElements.count() > 0)
+ {
+ for (int dre = 0; dre < PatternElements.count(); ++dre)
+ {
+ tmpSel->addItem(PatternElements.at(dre), true);
+ }
+ if (PatternElements.count() > 1)
+ m_Doc->itemSelection_GroupObjects(false, false, tmpSel);
+ ScPattern pat = ScPattern();
+ pat.setDoc(m_Doc);
+ PageItem* currItem = tmpSel->itemAt(0);
+ currItem->setItemName(currentPatternDefName);
+ currItem->AutoName = false;
+ m_Doc->DoDrawing = true;
+ QImage tmpImg = currItem->DrawObj_toImage();
+ QImage retImg = QImage(qRound(patternX2 - patternX1), qRound(patternY2 - patternY1), QImage::Format_ARGB32);
+ retImg.fill( qRgba(255, 255, 255, 0) );
+ QPainter p;
+ p.begin(&retImg);
+ if (PatternElements.count() > 1)
+ p.drawImage(qRound(-patternX1), qRound(-patternY1), tmpImg);
+ else
+ p.drawImage(0, 0, tmpImg);
+ p.end();
+ pat.pattern = retImg;
+// pat.pattern = currItem->DrawObj_toImage();
+ m_Doc->DoDrawing = false;
+ // pat.width = currItem->gWidth;
+ // pat.height = currItem->gHeight;
+ pat.width = patternX2 - patternX1;
+ pat.height = patternY2 - patternY1;
+ pat.xoffset = -patternX1;
+ pat.yoffset = -patternY1;
+ for (int as = 0; as < tmpSel->count(); ++as)
+ {
+ PageItem* Neu = tmpSel->itemAt(as);
+ Neu->moveBy(-patternX1, -patternY1, true);
+ Neu->gXpos -= patternX1;
+ Neu->gYpos -= patternY1;
+ pat.items.append(Neu);
+ }
+ m_Doc->itemSelection_DeleteItem(tmpSel);
+ m_Doc->addPattern(currentPatternDefName, pat);
+ }
+ importedPatterns.append(currentPatternDefName);
+ PatternElements.clear();
+ currentPatternDefName = "";
+ break;
+ }
+ else if (tmp.startsWith("Tile"))
+ continue;
+ else if (tmp.contains(") @"))
+ {
+ tmpData += tmp;
+ tmpData.remove(") @");
+ processData(tmpData);
+ tmpData = "";
+ }
+ else if (tmp.contains(") &"))
+ {
+ tmpData += tmp;
+ tmpData.remove(") &");
+ processData(tmpData);
+ tmpData = "";
+ }
+ else
+ {
+ if (tmp.startsWith("("))
+ tmp.remove(0, 1);
+ tmpData += " "+tmp;
+ }
+ }
+ else if (tmp == "EndPattern")
+ {
+ PatternElements.clear();
+ currentPatternDefName = "";
+ break;
+ }
+ else
+ processData(tmp);
+ }
+ patternMode = false;
+}
+
+void AIPlug::processRaster(QDataStream &ts)
+{
+ double m1, m2, m3, m4, m5, m6, x1, y1, x2, y2, dummy;
+ int w, h, type, alpha, bin, bits;
+ QString tmp = "";
+ QString cumulated = "";
+ while (!ts.atEnd())
+ {
+ tmp = readLinefromDataStream(ts);
+ if (tmp.startsWith("%"))
+ break;
+ tmp.remove("[");
+ tmp.remove("]");
+ if (!tmp.isEmpty())
+ cumulated += " " + tmp;
+ }
+ QString Cdata = "";
+ QStringList da;
+ getCommands(cumulated, da);
+ Cdata = da[da.count()-1];
+ ScTextStream gVals(&Cdata, QIODevice::ReadOnly);
+ gVals >> m1 >> m2 >> m3 >> m4 >> m5 >> m6 >> x1 >> y1 >> x2 >> y2 >> w >> h >> bits >> type >> alpha >> dummy >> bin;
+// qDebug() << QString("Matrix: %1 %2 %3 %4 %5 %6").arg(m1).arg(m2).arg(m3).arg(m4).arg(m5).arg(m6);
+// qDebug() << QString("Bounds: %1 %2 %3 %4").arg(x1).arg(y1).arg(x2).arg(y2);
+// qDebug() << QString("Size: %1 %2").arg(w).arg(h);
+// qDebug() << QString("Bits: %1").arg(bits);
+// qDebug() << QString("Typ: %1").arg(type);
+// qDebug() << QString("Alpha-Channels: %1").arg(alpha);
+// qDebug() << QString("Encoding: %1").arg(bin);
+ uint dataSize = w * h * (type + alpha);
+ uint alphaData = w * h * type;
+ bool cmyk = false;
+ if (type == 4)
+ cmyk = true;
+ if (tmp.startsWith("%%BeginData"))
+ {
+ QString dummyS;
+ ScTextStream gVals2(&tmp, QIODevice::ReadOnly);
+ tmp = readLinefromDataStream(ts);
+ }
+ QByteArray psdata;
+ psdata.resize(dataSize);
+ RawImage m_image;
+ if (type == 4)
+ {
+ if (alpha > 0)
+ m_image.create(w, 1, 5);
+ else
+ m_image.create(w, 1, 4);
+ }
+ else
+ {
+ if (alpha > 0)
+ m_image.create(w, 1, 4);
+ else
+ m_image.create(w, 1, 3);
+ }
+ bool first = false;
+ if (bin == 0) // 0 = ASCII encoded data
+ {
+ uint dataPointer = 0;
+ while (!ts.atEnd())
+ {
+ if (first)
+ tmp = readLinefromDataStream(ts);
+ first = true;
+ if (tmp.startsWith("%AI5_EndRaster"))
+ break;
+ for (int a = 1; a < tmp.length(); a += 2)
+ {
+ bool ok;
+ ushort data = tmp.mid(a, 2).toUShort(&ok, 16);
+ psdata[dataPointer++] = data;
+ }
+ }
+ }
+ else
+ {
+ psdata.resize(dataSize);
+ ts.readRawData(psdata.data(), dataSize);
+ }
+ QTransform imgMatrix = QTransform(m1, m2, m3, m4, m5, m6);
+ QPointF pos = QPointF(imgMatrix.dx(), imgMatrix.dy());
+ pos += QPointF(m_Doc->currentPage()->xOffset(), -m_Doc->currentPage()->yOffset());
+ pos += QPointF(baseX, -baseY);
+ int z = m_Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, pos.x() - docX, docHeight - (pos.y() - docY), 10, 10, 0, CurrColorFill, CurrColorStroke, true);
+ PageItem* ite = m_Doc->Items->at(z);
+ ite->setWidthHeight(w * m1, h * m4);
+ double rotation = getRotationFromMatrix(imgMatrix, 0.0);
+ ite->setRotation(rotation * 180 / M_PI);
+ ite->SetRectFrame();
+ m_Doc->setRedrawBounding(ite);
+ ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
+ ite->setTextFlowMode(PageItem::TextFlowDisabled);
+ ite->setFillShade(CurrFillShade);
+ ite->setLineShade(CurrStrokeShade);
+ ite->setFillEvenOdd(fillRule);
+ ite->setFillTransparency(1.0 - Opacity);
+ ite->setLineTransparency(1.0 - Opacity);
+ ite->setLineEnd(CapStyle);
+ ite->setLineJoin(JoinStyle);
+ uchar *p;
+ uint yCount = 0;
+ ite->tempImageFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_ai_XXXXXX.tif");
+ ite->tempImageFile->open();
+ QString imgName = getLongPathName(ite->tempImageFile->fileName());
+ ite->tempImageFile->close();
+ ite->isInlineImage = true;
+ TIFF* tif = TIFFOpen(imgName.toLocal8Bit().data(), "w");
+ if (tif)
+ {
+ TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, w);
+ TIFFSetField(tif, TIFFTAG_IMAGELENGTH, h);
+ TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
+ TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, m_image.channels());
+ TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+ if (type == 4)
+ TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_SEPARATED);
+ else
+ TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
+ TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
+ for (int y = 0; y < h; ++y)
+ {
+ p = m_image.scanLine( 0 );
+ for (int xh = 0; xh < m_image.width(); ++xh )
+ {
+ p[0] = psdata[yCount++];
+ if (type > 1)
+ {
+ p[1] = psdata[yCount++];
+ p[2] = psdata[yCount++];
+ if (type == 4)
+ p[3] = psdata[yCount++];
+ }
+ else
+ {
+ p[1] = p[0];
+ p[2] = p[0];
+ }
+ if (alpha == 1)
+ {
+ if (type == 4)
+ p[4] = psdata[alphaData++];
+ else
+ p[3] = psdata[alphaData++];
+ }
+ p += m_image.channels();
+ }
+ TIFFWriteScanline(tif, m_image.scanLine(0), y);
+ }
+ TIFFClose(tif);
+ }
+ m_Doc->LoadPict(imgName, z);
+ if (ite->PictureIsAvailable)
+ ite->setImageXYScale(ite->width() / ite->pixm.width(), ite->height() / ite->pixm.height());
+ if (importerFlags & LoadSavePlugin::lfCreateDoc)
+ ite->setLocked(itemLocked);
+ if (patternMode)
+ PatternElements.append(ite);
+ else
+ Elements.append(ite);
+ if (groupStack.count() != 0)
+ groupStack.top().append(ite);
+}
+
+void AIPlug::processComment(QDataStream &ts, QString comment)
+{
+ QString tmp = removeAIPrefix(comment);
+ if (tmp.startsWith("Begin_NonPrinting"))
+ {
+ while (!ts.atEnd())
+ {
+ tmp = removeAIPrefix(readLinefromDataStream(ts));
+ if (tmp.startsWith("BeginGradient"))
+ {
+ while (!ts.atEnd())
+ {
+ tmp = removeAIPrefix(readLinefromDataStream(ts));
+ if (tmp.startsWith("EndGradient"))
+ break;
+ else
+ processGradientData(tmp);
+ }
+ }
+ if (tmp.startsWith("BeginPattern:"))
+ processPattern(ts);
+ if (tmp.startsWith("End_NonPrinting"))
+ break;
+ progressDialog->setProgress("GI", ts.device()->pos());
+ qApp->processEvents();
+ }
+ }
+ else if (tmp.startsWith("BeginPattern:"))
+ processPattern(ts);
+ else if (tmp.startsWith("BeginGradient"))
+ {
+ while (!ts.atEnd())
+ {
+ tmp = removeAIPrefix(readLinefromDataStream(ts));
+ if (tmp.startsWith("EndGradient"))
+ break;
+ else
+ processGradientData(tmp);
+ progressDialog->setProgress("GI", ts.device()->pos());
+ qApp->processEvents();
+ }
+ }
+ else if (tmp.startsWith("BeginPalette"))
+ {
+ while (!ts.atEnd())
+ {
+ tmp = removeAIPrefix(readLinefromDataStream(ts));
+ if (tmp.startsWith("EndPalette"))
+ break;
+ progressDialog->setProgress("GI", ts.device()->pos());
+ qApp->processEvents();
+ }
+ }
+ else if (tmp.startsWith("BeginSymbol"))
+ {
+ while (!ts.atEnd())
+ {
+ tmp = removeAIPrefix(readLinefromDataStream(ts));
+ if (tmp.startsWith("EndSymbol"))
+ break;
+ progressDialog->setProgress("GI", ts.device()->pos());
+ qApp->processEvents();
+ }
+ }
+ else if (tmp.startsWith("BeginDocumentData"))
+ {
+ while (!ts.atEnd())
+ {
+ tmp = removeAIPrefix(readLinefromDataStream(ts));
+ if (tmp.startsWith("EndDocumentData"))
+ break;
+ progressDialog->setProgress("GI", ts.device()->pos());
+ qApp->processEvents();
+ }
+ }
+ else if (tmp.startsWith("%%BeginProlog"))
+ {
+ while (!ts.atEnd())
+ {
+ tmp = removeAIPrefix(readLinefromDataStream(ts));
+ if (tmp.startsWith("%%EndProlog"))
+ break;
+ progressDialog->setProgress("GI", ts.device()->pos());
+ qApp->processEvents();
+ }
+ }
+ else if (tmp.startsWith("%%BeginData"))
+ {
+ while (!ts.atEnd())
+ {
+ tmp = removeAIPrefix(readLinefromDataStream(ts));
+ if (tmp.startsWith("%%EndData"))
+ break;
+ progressDialog->setProgress("GI", ts.device()->pos());
+ qApp->processEvents();
+ }
+ }
+ else if (tmp.startsWith("%%BeginCrops"))
+ {
+ while (!ts.atEnd())
+ {
+ tmp = removeAIPrefix(readLinefromDataStream(ts));
+ if (tmp.startsWith("%%EndCrops"))
+ break;
+ progressDialog->setProgress("GI", ts.device()->pos());
+ qApp->processEvents();
+ }
+ }
+ else if (tmp.startsWith("BeginRaster"))
+ {
+ processRaster(ts);
+ progressDialog->setProgress("GI", ts.device()->pos());
+ qApp->processEvents();
+ }
+ else if (tmp.startsWith("BeginLayer"))
+ {
+ while (!ts.atEnd())
+ {
+ tmp = removeAIPrefix(readLinefromDataStream(ts));
+ if (tmp.startsWith("BeginRaster"))
+ {
+ processRaster(ts);
+ continue;
+ }
+ if (tmp.startsWith("EndLayer"))
+ break;
+ else
+ processData(tmp);
+ progressDialog->setProgress("GI", ts.device()->pos());
+ qApp->processEvents();
+ }
+ }
+}
+
+bool AIPlug::convert(QString fn)
+{
+ QString tmp;
+ LineW = 1.0;
+ Opacity = 1.0;
+ blendMode = 0;
+ CurrColorFill = "White";
+ CurrFillShade = 100.0;
+ CurrColorStroke = "Black";
+ CurrStrokeShade = 100.0;
+ JoinStyle = Qt::MiterJoin;
+ CapStyle = Qt::FlatCap;
+ DashPattern.clear();
+ DashOffset = 0.0;
+ fillRule = false;
+ FirstU = false;
+ WasU = false;
+ firstLayer = true;
+ patternMode = false;
+ meshMode = false;
+ itemLocked = false;
+ patternX1 = 0.0;
+ patternY1 = 0.0;
+ patternX2 = 0.0;
+ patternY2 = 0.0;
+ Coords.resize(0);
+ Coords.svgInit();
+ clipCoords.resize(0);
+ clipCoords.svgInit();
+ currentPoint = FPoint(0.0, 0.0);
+ currentLayer = 0;
+ currentGradient = VGradient(VGradient::linear);
+ currentGradient.clearStops();
+ currentGradient.setRepeatMethod( VGradient::none );
+ currentGradientName = "";
+ currentGradientMatrix = QTransform();
+ currentGradientOrigin = QPointF(0.0, 0.0);
+ currentGradientAngle = 0.0;
+ currentGradientLenght = 1.0;
+ currentPatternName = "";
+ currentPatternX = 0.0;
+ currentPatternY = 0.0;
+ currentPatternXScale = 1.0;
+ currentPatternYScale = 1.0;
+ currentPatternRotation = 0.0;
+ currentStrokePatternName = "";
+ currentStrokePatternX = 0.0;
+ currentStrokePatternY = 0.0;
+ currentStrokePatternXScale = 1.0;
+ currentStrokePatternYScale = 1.0;
+ currentStrokePatternRotation = 0.0;
+ QList<PageItem*> gElements;
+ groupStack.push(gElements);
+ commandList << "m" << "l" << "L" << "c" << "C" << "v" << "V" << "y" << "Y"; // Path construction
+ commandList << "b" << "B" << "f" << "F" << "s" << "S" << "*u" << "*U"; // Object creation
+ commandList << "u" << "U" << "W" << "q" << "Q"; // Object creation
+ commandList << "A" << "w" << "j" << "J" << "Xy" << "XR"; // Graphic state
+ commandList << "k" << "K" << "Xa" << "XA" << "x" << "X" << "XX" << "Xx"; // Color commands
+ commandList << "Xk" << "g" << "G" << "p" << "P"; // Color commands
+ commandList << "Ln" << "Lb" << "LB"; // Layer commands
+ commandList << "Bd" << "BD" << "%_Bs" << "Bg" << "Bb" << "BB" << "Bm" << "Xm"; // Gradient commands
+ commandList << "To" << "TO" << "Tf" << "Tp" << "Tx" << "TX" << "T*" << "Tk"; // Text commands
+ commandList << "Tc" << "Tz"; // Text commands
+ commandList << "XI" << "XG" << "Xh"; // Image commands
+ commandList << "n" << "N" << "*" << "["; // Special commands
+ commandList << "X!" << "X#"; // Mesh commands
+ commandList << "M" << "d" << "D" << "E"; // unimplemented
+ commandList << "h" << "H" << "i" << "I" << "Np" << "O"; // unimplemented
+ commandList << "P" << "R"; // unimplemented
+ commandList << "XI" << "XF" << "XG" << "XT" << "Z" << "`" << "~" << "_" << "@"; // unimplemented
+ commandList << "&" << "*w" << "*W" << "Ap" << "Ar"; // unimplemented
+ if(progressDialog)
+ {
+ progressDialog->setOverallProgress(2);
+ progressDialog->setLabel("GI", tr("Generating Items"));
+ qApp->processEvents();
+ }
+ QFile f(fn);
+ if (f.open(QIODevice::ReadOnly))
+ {
+ int fSize = (int) f.size();
+ if (progressDialog)
+ {
+ progressDialog->setTotalSteps("GI", fSize);
+ qApp->processEvents();
+ }
+ QDataStream ts(&f);
+ while (!ts.atEnd())
+ {
+ tmp = readLinefromDataStream(ts);
+ if (tmp.startsWith("%"))
+ processComment(ts, tmp);
+ else
+ processData(tmp);
+ progressDialog->setProgress("GI", ts.device()->pos());
+ qApp->processEvents();
+ }
+ f.close();
+ }
+ if (progressDialog)
+ progressDialog->close();
+ return true;
+}
Index: scribus/plugins/import/aiimplugin/importaiplugin.h
===================================================================
--- scribus/plugins/import/aiimplugin/importaiplugin.h (revision 0)
+++ scribus/plugins/import/aiimplugin/importaiplugin.h (revision 14347)
@@ -0,0 +1,57 @@
+/*
+For general Scribus (>=1.3.2) copyright and licensing information please refer
+to the COPYING file provided with the program. Following this notice may exist
+a copyright and/or license notice that predates the release of Scribus 1.3.2
+for which a new license (GPL+exception) is in place.
+*/
+#ifndef IMPORTAIPLUGIN_H
+#define IMPORTAIPLUGIN_H
+
+#include "pluginapi.h"
+#include "loadsaveplugin.h"
+#include "../formatidlist.h"
+
+class ScrAction;
+
+class PLUGIN_API ImportAIPlugin : public LoadSavePlugin
+{
+ Q_OBJECT
+
+ public:
+ // Standard plugin implementation
+ ImportAIPlugin();
+ virtual ~ImportAIPlugin();
+ /*!
+ \author Franz Schmid
+ \date
+ \brief Returns name of plugin
+ \retval QString containing name of plugin: Import EPS/PDF/PS...
+ */
+ virtual const QString fullTrName() const;
+ virtual const AboutData* getAboutData() const;
+ virtual void deleteAboutData(const AboutData* about) const;
+ virtual void languageChange();
+ virtual bool fileSupported(QIODevice* file, const QString & fileName=QString::null) const;
+ virtual bool loadFile(const QString & fileName, const FileFormat & fmt, int flags, int index = 0);
+ virtual void addToMainWindowMenu(ScribusMainWindow *) {};
+
+ public slots:
+ /*!
+ \author Franz Schmid
+ \date
+ \brief Run the EPS import
+ \param fileName input filename, or QString::null to prompt.
+ \retval bool always true
+ */
+ virtual bool import(QString fileName = QString::null, int flags = lfUseCurrentPage|lfInteractive);
+
+ private:
+ void registerFormats();
+ ScrAction* importAction;
+};
+
+extern "C" PLUGIN_API int importai_getPluginAPIVersion();
+extern "C" PLUGIN_API ScPlugin* importai_getPlugin();
+extern "C" PLUGIN_API void importai_freePlugin(ScPlugin* plugin);
+
+#endif
Index: scribus/plugins/import/aiimplugin/importai.h
===================================================================
--- scribus/plugins/import/aiimplugin/importai.h (revision 0)
+++ scribus/plugins/import/aiimplugin/importai.h (revision 14347)
@@ -0,0 +1,198 @@
+/*
+For general Scribus (>=1.3.2) copyright and licensing information please refer
+to the COPYING file provided with the program. Following this notice may exist
+a copyright and/or license notice that predates the release of Scribus 1.3.2
+for which a new license (GPL+exception) is in place.
+*/
+#ifndef IMPORTAI_H
+#define IMPORTAI_H
+
+#include <QList>
+#include <QTransform>
+#include <QObject>
+#include <QString>
+
+#include "pluginapi.h"
+
+#include "fpointarray.h"
+#include "sccolor.h"
+#include "text/storytext.h"
+#include "vgradient.h"
+
+class MultiProgressDialog;
+class PageItem;
+class ScribusDoc;
+class Selection;
+class TransactionSettings;
+
+//! \brief Adobe Illustrator importer plugin
+class AIPlug : public QObject
+{
+ Q_OBJECT
+
+public:
+ /*!
+ \author Franz Schmid
+ \date
+ \brief Create the AI importer window.
+ \param doc a Scribus document reference
+ \param flags combination of loadFlags - see loadFlags in LoadSavePlugin
+ */
+ AIPlug( ScribusDoc* doc, int flags );
+ ~AIPlug();
+
+ /*!
+ \author Franz Schmid
+ \date
+ \brief Perform import.
+ \param fNameIn QString a filename to import
+ \param trSettings undo transaction settings
+ \param flags combination of loadFlags in LoadSavePlugin
+ \param showProgress if progress must be displayed
+ \retval bool true if import was ok
+ */
+ bool import(QString fNameIn, const TransactionSettings& trSettings, int flags, bool showProgress = true);
+
+private:
+
+ /*!
+ \author Franz Schmid
+ \date
+ \brief Does the conversion.
+ \param infile a filename
+ \param outfile a filename for output
+ \retval bool true if conversion was ok
+ */
+ bool extractFromPDF(QString infile, QString outfile);
+
+ bool decompressAIData(QString &fName);
+ bool parseHeader(QString fName, double &x, double &y, double &b, double &h);
+ QString removeAIPrefix(QString comment);
+ QString parseColor(QString data);
+ QString parseColorGray(QString data);
+ QString parseColorRGB(QString data);
+ QString parseCustomColor(QString data, double &shade);
+ QString parseCustomColorX(QString data, double &shade, QString type);
+ QStringList getStrings(QString data);
+ void getCommands(QString data, QStringList &commands);
+ void processData(QString data);
+ void processGradientData(QString data);
+ void processPattern(QDataStream &ts);
+ void processRaster(QDataStream &ts);
+ void processComment(QDataStream &ts, QString comment);
+ bool convert(QString fn);
+
+ QList<PageItem*> Elements;
+ QList<PageItem*> PatternElements;
+ QStack<QList<PageItem*> > groupStack;
+ ColorList CustColors;
+ QStringList importedColors;
+ QStringList importedGradients;
+ QStringList importedPatterns;
+ double baseX, baseY;
+ double docX;
+ double docY;
+ double docWidth;
+ double docHeight;
+
+ double LineW;
+ Qt::PenCapStyle CapStyle;
+ Qt::PenJoinStyle JoinStyle;
+ double DashOffset;
+ QList<double> DashPattern;
+ double Opacity;
+ int blendMode;
+ QString CurrColorFill;
+ QString CurrColorStroke;
+ double CurrStrokeShade;
+ double CurrFillShade;
+ bool fillRule;
+ bool itemLocked;
+
+ FPointArray Coords;
+ FPointArray clipCoords;
+ FPoint currentPoint;
+ int currentLayer;
+ bool firstLayer;
+ bool FirstU, WasU, ClosedPath;
+ bool interactive;
+ MultiProgressDialog * progressDialog;
+ bool cancel;
+ ScribusDoc* m_Doc;
+ Selection* tmpSel;
+ int importerFlags;
+ QStringList commandList;
+ bool convertedPDF;
+ QMap<QString, VGradient> m_gradients;
+ VGradient currentGradient;
+ QString currentGradientName;
+ QTransform currentGradientMatrix;
+ QPointF currentGradientOrigin;
+ double currentGradientAngle;
+ double currentGradientLenght;
+ bool gradientMode;
+ bool wasBC;
+ bool itemRendered;
+ QTransform startMatrix;
+ QTransform endMatrix;
+ bool patternMode;
+ QString currentPatternDefName;
+ QString currentPatternName;
+ double patternX1;
+ double patternY1;
+ double patternX2;
+ double patternY2;
+ double currentPatternX;
+ double currentPatternY;
+ double currentPatternXScale;
+ double currentPatternYScale;
+ double currentPatternRotation;
+ QString currentStrokePatternName;
+ double currentStrokePatternX;
+ double currentStrokePatternY;
+ double currentStrokePatternXScale;
+ double currentStrokePatternYScale;
+ double currentStrokePatternRotation;
+ bool meshMode;
+ int meshXSize, meshYSize;
+ int currentMeshXPos, currentMeshYPos;
+ int meshNodeCounter;
+ int meshColorMode;
+ double meshNode1PointX, meshNode1PointY;
+ double meshNode1Control1X, meshNode1Control1Y;
+ double meshNode1Control2X, meshNode1Control2Y;
+ double meshNode2PointX, meshNode2PointY;
+ double meshNode2Control1X, meshNode2Control1Y;
+ double meshNode2Control2X, meshNode2Control2Y;
+ double meshNode3PointX, meshNode3PointY;
+ double meshNode3Control1X, meshNode3Control1Y;
+ double meshNode3Control2X, meshNode3Control2Y;
+ double meshNode4PointX, meshNode4PointY;
+ double meshNode4Control1X, meshNode4Control1Y;
+ double meshNode4Control2X, meshNode4Control2Y;
+ double accumColorC, accumColorM, accumColorY, accumColorK;
+// QPainterPath meshBoundingPath;
+ QString docCreator;
+ QString docDate;
+ QString docTime;
+ QString docOrganisation;
+ QString docTitle;
+ int textMode;
+ QTransform textMatrix;
+ StoryText textData;
+ QString textFont;
+ double textSize;
+ double maxWidth;
+ double tempW;
+ double maxHeight;
+ double textKern;
+ double textScaleH;
+ double textScaleV;
+ int startCurrentTextRange;
+ int endCurrentTextRange;
+
+public slots:
+ void cancelRequested() { cancel = true; }
+};
+
+#endif
Index: scribus/plugins/import/aiimplugin/CMakeLists.txt
===================================================================
--- scribus/plugins/import/aiimplugin/CMakeLists.txt (revision 0)
+++ scribus/plugins/import/aiimplugin/CMakeLists.txt (revision 14347)
@@ -0,0 +1,53 @@
+INCLUDE_DIRECTORIES(
+${CMAKE_SOURCE_DIR}
+${CMAKE_SOURCE_DIR}/scribus
+${PODOFO_INCLUDES}
+)
+
+IF(HAVE_PODOFO)
+ INCLUDE_DIRECTORIES(
+ ${LIBPODOFO_INCLUDE_DIR}
+ )
+ENDIF(HAVE_PODOFO)
+
+SET(IMPORTAI_PLUGIN_MOC_CLASSES
+ importai.h
+ importaiplugin.h
+)
+
+SET(IMPORTAI_PLUGIN_SOURCES
+ importai.cpp
+ importaiplugin.cpp
+)
+
+SET(SCRIBUS_IMPORTAI_PLUGIN "importai")
+
+QT4_WRAP_CPP(IMPORTAI_PLUGIN_MOC_SOURCES ${IMPORTAI_PLUGIN_MOC_CLASSES})
+
+ADD_LIBRARY(${SCRIBUS_IMPORTAI_PLUGIN} MODULE ${IMPORTAI_PLUGIN_SOURCES} ${IMPORTAI_PLUGIN_MOC_SOURCES})
+
+
+IF(WIN32)
+ TARGET_LINK_LIBRARIES(${SCRIBUS_IMPORTAI_PLUGIN}
+ ${PLUGIN_LIBRARIES}
+ ${TIFF_LIBRARIES}
+ ${JPEG_LIBRARIES})
+ELSE(WIN32)
+ TARGET_LINK_LIBRARIES(${SCRIBUS_IMPORTAI_PLUGIN} ${PLUGIN_LIBRARIES})
+ENDIF(WIN32)
+
+IF(HAVE_PODOFO)
+ TARGET_LINK_LIBRARIES(${SCRIBUS_IMPORTAI_PLUGIN}
+ ${LIBPODOFO_LIBRARY}
+ )
+ENDIF(HAVE_PODOFO)
+
+INSTALL(TARGETS ${SCRIBUS_IMPORTAI_PLUGIN}
+ LIBRARY
+ DESTINATION ${PLUGINDIR}
+ PERMISSIONS ${PLUGIN_PERMISSIONS}
+)
+
+ADD_DEPENDENCIES(${SCRIBUS_IMPORTAI_PLUGIN} ${EXE_NAME})
+
+# SET_TARGET_PROPERTIES(${SCRIBUS_FONTPREVIEW_PLUGIN} PROPERTIES VERSION "0.0.0")
Property changes on: scribus/plugins/import/aiimplugin
___________________________________________________________________
Added: svn:mergeinfo
Index: scribus/plugins/CMakeLists.txt
===================================================================
--- scribus/plugins/CMakeLists.txt (revision 14346)
+++ scribus/plugins/CMakeLists.txt (revision 14347)
@@ -1,4 +1,4 @@
-ADD_SUBDIRECTORY(aiimplugin)
+ADD_SUBDIRECTORY(import)
ADD_SUBDIRECTORY(barcodegenerator)
ADD_SUBDIRECTORY(colorwheel)
ADD_SUBDIRECTORY(fileloader)
More information about the scribus-commit
mailing list