PyObject* scribus_deletemasterpage(PyObject* /* self */, PyObject* args)
{
char* name = nullptr;
if (!PyArg_ParseTuple(args, "es", const_cast<char*>("utf-8"), &name))
return nullptr;
if (!checkHaveDocument())
return nullptr;
const QString masterPageName(name);
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
if (!currentDoc->MasterNames.contains(masterPageName))
{
PyErr_SetString(PyExc_ValueError, "Master page does not exist");
return nullptr;
}
if (masterPageName == "Normal")
{
PyErr_SetString(PyExc_ValueError, "Can not delete the Normal master page");
return nullptr;
}
bool oldMode = currentDoc->masterPageMode();
currentDoc->setMasterPageMode(true);
ScCore->primaryMainWindow()->deletePage2(currentDoc->MasterNames[masterPageName]);
currentDoc->setMasterPageMode(oldMode);
Py_RETURN_NONE;
}
void PagePalette::startMasterPageMode(QString masterPage)
{
m_view->Deselect(true);
QStackedWidget* stackedWidget = this->stackedWidget();
if (stackedWidget->count() < 2)
{
PagePalette_MasterPages* mpWidget = new PagePalette_MasterPages(stackedWidget, m_view, masterPage);
mpWidget->setObjectName(QString::fromLocal8Bit("PagePalette_MasterPages"));
stackedWidget->addWidget(mpWidget);
connect(mpWidget, SIGNAL(removePage(int )), m_scMW, SLOT(deletePage2(int )));
connect(mpWidget, SIGNAL(finished()) , m_scMW, SLOT(manageMasterPagesEnd()));
}
else
{
ScribusDoc* doc = m_view->Doc;
PagePalette_MasterPages* mpWidget = this->masterpageWidget();
if (mpWidget->currentView != m_view)
mpWidget->setView(m_view, masterPage);
mpWidget->updateMasterPageList(masterPage);
if (doc->currentPage()->pageName() != masterPage)
mpWidget->selectMasterPage(masterPage);
}
// Set focus to page palette or focus may be set to wrong document window
this->setFocus();
stackedWidget->setCurrentIndex(1);
}
// This function is used by scribus_importpage() to add new pages
void import_addpages(int total, int pos)
{
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
for (int i=0; i<total; i++)
{
int locreal = pos + i;
int loc = pos + i + 1;
if (loc > currentDoc->Pages->count())
loc = currentDoc->Pages->count();
QString qName(CommonStrings::trMasterPageNormal);
if (currentDoc->pageSets()[currentDoc->pagePositioning()].Columns != 1) {
currentDoc->locationOfPage(loc);
switch (currentDoc->locationOfPage(loc))
{
case LeftPage:
qName = CommonStrings::trMasterPageNormalLeft;
break;
case RightPage:
qName = CommonStrings::trMasterPageNormalRight;
break;
case MiddlePage:
qName = CommonStrings::trMasterPageNormalMiddle;
break;
}
}
ScCore->primaryMainWindow()->slotNewPageP(locreal, qName);
}
}
PyObject* scribus_applymasterpage(PyObject* /* self */, PyObject* args)
{
char* name = nullptr;
int page = 0;
if (!PyArg_ParseTuple(args, "esi", const_cast<char*>("utf-8"), &name, &page))
return nullptr;
if (!checkHaveDocument())
return nullptr;
const QString masterPageName(name);
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
if (!currentDoc->MasterNames.contains(masterPageName))
{
PyErr_SetString(PyExc_ValueError, QObject::tr("Master page does not exist: '%1'","python error").arg(masterPageName).toLocal8Bit().constData());
return nullptr;
}
if ((page < 1) || (page > static_cast<int>(currentDoc->Pages->count())))
{
PyErr_SetString(PyExc_IndexError, QObject::tr("Page number out of range: %1.","python error").arg(page).toLocal8Bit().constData());
return nullptr;
}
if (!currentDoc->applyMasterPage(masterPageName, page-1))
{
PyErr_SetString(ScribusException, QObject::tr("Failed to apply masterpage '%1' on page: %2","python error").arg(masterPageName).arg(page).toLocal8Bit().constData());
return nullptr;
}
Py_RETURN_NONE;
}
bool LensEffectsPlugin::run(ScribusDoc* doc, QString)
{
ScribusDoc* currDoc = doc;
if (currDoc == 0)
currDoc = ScCore->primaryMainWindow()->doc;
if (currDoc->m_Selection->count() > 0)
{
LensDialog *dia = new LensDialog(currDoc->scMW(), currDoc);
if (dia->exec())
{
for (int a = 0; a < dia->origPathItem.count(); a++)
{
PageItem *currItem = currDoc->m_Selection->itemAt(a);
if (currItem->itemType() == PageItem::Line)
continue;
QPainterPath path = dia->origPathItem[a]->path();
FPointArray points;
points.fromQPainterPath(path);
currItem->PoLine = points;
currItem->Frame = false;
currItem->ClipEdited = true;
currItem->FrameType = 3;
currDoc->AdjustItemSize(currItem);
currItem->OldB2 = currItem->width();
currItem->OldH2 = currItem->height();
currItem->updateClip();
currItem->ContourLine = currItem->PoLine.copy();
}
currDoc->changed();
}
delete dia;
}
return true;
}
PyObject *scribus_setVguides(PyObject* /* self */, PyObject* args)
{
PyObject *l;
if (!PyArg_ParseTuple(args, "O", &l))
return nullptr;
if (!checkHaveDocument())
return nullptr;
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
if (!PyList_Check(l))
{
PyErr_SetString(PyExc_TypeError, QObject::tr("argument is not list: must be list of float values.","python error").toLocal8Bit().constData());
return nullptr;
}
int i, n;
n = PyList_Size(l);
double guide;
currentDoc->currentPage()->guides.clearVerticals(GuideManagerCore::Standard);
for (i=0; i<n; i++)
{
if (!PyArg_Parse(PyList_GetItem(l, i), "d", &guide))
{
PyErr_SetString(PyExc_TypeError, QObject::tr("argument contains no-numeric values: must be list of float values.","python error").toLocal8Bit().constData());
return nullptr;
}
currentDoc->currentPage()->guides.addVertical(ValueToPoint(guide), GuideManagerCore::Standard);
}
// Py_INCREF(Py_None);
// return Py_None;
Py_RETURN_NONE;
}
PyObject *scribus_getpageitems(PyObject* /* self */)
{
if (!checkHaveDocument())
return nullptr;
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
if (currentDoc->Items->count() == 0)
return Py_BuildValue((char*)"[]");
uint counter = 0;
int pageNr = currentDoc->currentPageNumber();
for (int lam2 = 0; lam2 < currentDoc->Items->count(); ++lam2)
{
if (pageNr == currentDoc->Items->at(lam2)->OwnPage)
counter++;
}
PyObject *l = PyList_New(counter);
PyObject *row;
counter = 0;
for (int i = 0; i<currentDoc->Items->count(); ++i)
{
if (pageNr == currentDoc->Items->at(i)->OwnPage)
{
row = Py_BuildValue((char*)"(sii)",
currentDoc->Items->at(i)->itemName().toUtf8().constData(),
currentDoc->Items->at(i)->itemType(),
currentDoc->Items->at(i)->uniqueNr
);
PyList_SetItem(l, counter, row);
counter++;
}
} // for
return l;
}
bool SmoothPathPlugin::run(ScribusDoc* doc, QString)
{
ScribusDoc* currDoc = doc;
if (currDoc == 0)
currDoc = ScCore->primaryMainWindow()->doc;
if (currDoc->m_Selection->count() > 0)
{
PageItem *currItem = currDoc->m_Selection->itemAt(0);
QPainterPath pp;
if (currItem->itemType() == PageItem::PolyLine)
pp = currItem->PoLine.toQPainterPath(false);
else
pp = currItem->PoLine.toQPainterPath(true);
QList<QPolygonF> polyList = pp.toSubpathPolygons();
QPainterPath result;
for (int a = 0; a < polyList.count(); a++)
{
result.addPath(bezierFit(polyList[a], 5.0));
}
currItem->PoLine.fromQPainterPath(result);
currItem->ClipEdited = true;
currItem->FrameType = 3;
currDoc->AdjustItemSize(currItem);
currItem->OldB2 = currItem->width();
currItem->OldH2 = currItem->height();
currItem->updateClip();
currDoc->regionsChanged()->update(QRectF());
currDoc->changed();
}
return true;
}
bool ScPrintEngine_GDI::print( ScribusDoc& doc, PrintOptions& options )
{
bool toFile;
bool success;
HDC printerDC;
QString diaSelection, docDir, prefsDocDir;
QString printerName = options.printer;
QByteArray devMode = options.devMode;
QString fileName;
if( options.toFile )
return false;
resetData();
toFile = printerUseFilePort( options.printer );
if ( toFile )
{
diaSelection = doc.DocName.right( doc.DocName.length() - doc.DocName.lastIndexOf("/") - 1 );
diaSelection = diaSelection.left( diaSelection.indexOf(".") );
diaSelection += ".prn";
PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
QString prefsDocDir = PrefsManager::instance()->documentDir();
if (!prefsDocDir.isEmpty())
docDir = dirs->get("winprn", prefsDocDir);
else
docDir = ".";
CustomFDialog dia( doc.scMW()->view, docDir, QObject::tr("Save As"), "Spool Files (*.prn *.ps);;All Files (*)", fdNone);
dia.setSelection( diaSelection );
if (dia.exec() == QDialog::Accepted)
{
QString selectedFile = dia.selectedFile();
if ( overwrite(doc.scMW()->view, selectedFile) )
{
dirs->set("winprn", selectedFile.left(selectedFile.lastIndexOf("/")));
fileName = QDir::toNativeSeparators( selectedFile );
}
}
else
return true;
}
// Set user options in the DEVmode structure
setDeviceParams( &doc, options, (DEVMODEW*) devMode.data() );
// Create the device context
printerDC = CreateDCW( NULL, (LPCWSTR) printerName.utf16(), NULL, (DEVMODEW*) devMode.data() );
if( printerDC )
{
success = printPages( &doc, options, printerDC, (DEVMODEW*) devMode.data(), fileName);
DeleteDC( printerDC );
}
else
{
qWarning("doPrintPages : the device context could not be created");
success = false;
}
return success;
}
PyObject *scribus_newpage(PyObject* /* self */, PyObject* args)
{
int e;
char *name = const_cast<char*>("");
QString qName(CommonStrings::trMasterPageNormal);
if (!PyArg_ParseTuple(args, "i|es", &e, "utf-8", &name))
return nullptr;
if (!checkHaveDocument())
return nullptr;
ScribusMainWindow* mainWin = ScCore->primaryMainWindow();
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
int loc = (e > -1) ? e : currentDoc->Pages->count();
if (currentDoc->pageSets()[currentDoc->pagePositioning()].Columns != 1)
{
switch (currentDoc->locationOfPage(loc))
{
case LeftPage:
qName = CommonStrings::trMasterPageNormalLeft;
break;
case RightPage:
qName = CommonStrings::trMasterPageNormalRight;
break;
case MiddlePage:
qName = CommonStrings::trMasterPageNormalMiddle;
break;
}
}
if (QString(name).length() != 0)
qName = QString::fromUtf8(name);
if (!currentDoc->MasterNames.contains(qName))
{
PyErr_SetString(PyExc_IndexError, QObject::tr("Given master page name does not match any existing.","python error").toLocal8Bit().constData());
return nullptr;
}
if (e < 0)
mainWin->slotNewPageP(loc, qName);
else
{
e--;
if ((e < 0) || (e > static_cast<int>(loc - 1)))
{
PyErr_SetString(PyExc_IndexError, QObject::tr("Page number out of range.","python error").toLocal8Bit().constData());
return nullptr;
}
mainWin->slotNewPageP(e, qName);
}
// Py_INCREF(Py_None);
// return Py_None;
Py_RETURN_NONE;
}
PyObject *scribus_getpagemargins(PyObject* /* self */)
{
PyObject *margins = nullptr;
if (!checkHaveDocument())
return nullptr;
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
margins = Py_BuildValue("ffff", PointToValue(currentDoc->margins()->top()),
PointToValue(currentDoc->margins()->left()),
PointToValue(currentDoc->margins()->right()),
PointToValue(currentDoc->margins()->bottom()));
return margins;
}
PyObject *scribus_pagedimension(PyObject* /* self */)
{
if (!checkHaveDocument())
return nullptr;
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
PyObject *t;
t = Py_BuildValue(
"(dd)",
PointToValue(currentDoc->pageWidth()), // it's just view scale... * ScCore->primaryMainWindow()->doc->Scale),
PointToValue(currentDoc->pageHeight()) // * ScCore->primaryMainWindow()->doc->Scale)
);
return t;
}
PyObject *scribus_setbaseline(PyObject* /* self */, PyObject* args)
{
double grid, offset;
if (!PyArg_ParseTuple(args, "dd", &grid, &offset))
return nullptr;
if (!checkHaveDocument())
return nullptr;
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
ScribusView* currentView = ScCore->primaryMainWindow()->view;
currentDoc->guidesPrefs().valueBaselineGrid = ValueToPoint(grid);
currentDoc->guidesPrefs().offsetBaselineGrid = ValueToPoint(offset);
//currentView->reformPages();
currentDoc->setModified(true);
//currentView->GotoPage(currentDoc->currentPageNumber());
currentView->DrawNew();
Py_RETURN_NONE;
}
PyObject *scribus_setmargins(PyObject* /* self */, PyObject* args)
{
double lr, tpr, btr, rr;
if (!PyArg_ParseTuple(args, "dddd", &lr, &rr, &tpr, &btr))
return nullptr;
if (!checkHaveDocument())
return nullptr;
MarginStruct margins(ValueToPoint(tpr), ValueToPoint(lr), ValueToPoint(btr), ValueToPoint(rr));
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
ScribusView* currentView = ScCore->primaryMainWindow()->view;
currentDoc->resetPage(currentDoc->pagePositioning(), &margins);
currentView->reformPages();
currentDoc->setModified(true);
currentView->GotoPage(currentDoc->currentPageNumber());
currentView->DrawNew();
Py_RETURN_NONE;
}
PyObject* scribus_createmasterpage(PyObject* /* self */, PyObject* args)
{
char* name = nullptr;
if (!PyArg_ParseTuple(args, "es", const_cast<char*>("utf-8"), &name))
return nullptr;
if (!checkHaveDocument())
return nullptr;
const QString masterPageName(name);
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
if (currentDoc->MasterNames.contains(masterPageName))
{
PyErr_SetString(PyExc_ValueError, "Master page already exists");
return nullptr;
}
currentDoc->addMasterPage(currentDoc->MasterPages.count(), masterPageName);
Py_RETURN_NONE;
}
PyObject *scribus_setdoctype(PyObject* /* self */, PyObject* args)
{
int fp, fsl;
if (!PyArg_ParseTuple(args, "ii", &fp, &fsl))
return nullptr;
if (!checkHaveDocument())
return nullptr;
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
ScribusView* currentView = ScCore->primaryMainWindow()->view;
if (currentDoc->pagePositioning() == fp)
currentDoc->setPageSetFirstPage(currentDoc->pagePositioning(), fsl);
currentView->reformPages();
currentView->GotoPage(currentDoc->currentPageNumber()); // is this needed?
currentView->DrawNew(); // is this needed?
//CB TODO ScCore->primaryMainWindow()->pagePalette->RebuildPage(); // is this needed?
ScCore->primaryMainWindow()->slotDocCh();
Py_RETURN_NONE;
}
bool LensEffectsPlugin::run(ScribusDoc* doc, QString)
{
ScribusDoc* currDoc = doc;
if (currDoc == 0)
currDoc = ScCore->primaryMainWindow()->doc;
if (currDoc->m_Selection->count() > 0)
{
LensDialog *dia = new LensDialog(currDoc->scMW(), currDoc);
if (dia->exec())
{
for (int a = 0; a < dia->origPathItem.count(); a++)
{
PageItem *currItem = dia->origPageItem[a];
if (currItem->itemType() == PageItem::Line)
continue;
QPainterPath path = dia->origPathItem[a]->path();
FPointArray points;
points.fromQPainterPath(path);
currItem->PoLine = points;
currItem->ClipEdited = true;
currItem->FrameType = 3;
double oW = currItem->width();
double oH = currItem->height();
currDoc->adjustItemSize(currItem, true);
currItem->OldB2 = currItem->width();
currItem->OldH2 = currItem->height();
if (currItem->isGroup())
{
currItem->groupWidth = currItem->groupWidth * (currItem->OldB2 / oW);
currItem->groupHeight = currItem->groupHeight * (currItem->OldH2 / oH);
}
currItem->updateClip();
if (currItem->isGroup())
{
currDoc->resizeGroupToContents(currItem);
currItem->SetRectFrame();
}
currItem->ContourLine = currItem->PoLine.copy();
}
if (currDoc->m_Selection->count() > 0)
{
PageItem *m_patternItem = currDoc->m_Selection->itemAt(0);
if (m_patternItem->isGroup())
{
currDoc->resizeGroupToContents(m_patternItem);
m_patternItem->SetRectFrame();
}
}
currDoc->changed();
currDoc->view()->DrawNew();
}
delete dia;
}
return true;
}
void PagePalette::setView(ScribusView *view)
{
PagePalette_Pages* pageWidget = dynamic_cast<PagePalette_Pages*>(this->currentWidget());
if (pageWidget)
pageWidget->setView(view);
PagePalette_MasterPages* mpWidget = dynamic_cast<PagePalette_MasterPages*>(this->currentWidget());
if (mpWidget)
mpWidget->setView(view);
m_view = view;
if (!m_view)
return;
ScribusDoc* doc = m_view->Doc;
if (doc->masterPageMode())
{
QString pageName = doc->currentPage()->pageName();
startMasterPageMode(pageName);
}
else if (masterPageMode())
{
endMasterPageMode();
}
}
void PagePalette::startMasterPageMode(QString masterPage)
{
ScribusDoc* doc = m_view->Doc;
bool mustDeselect = false;
mustDeselect |= (!doc->masterPageMode());
mustDeselect |= (doc->masterPageMode() && doc->currentPage()->pageName() != masterPage);
if (mustDeselect)
{
// We must avoid deselecting directly if doc is in an edit mode,
// otherwise that would cause an inconsistent state. In such case,
// fallback to normal mode by precaution
if (doc->appMode != modeNormal)
m_view->requestMode(modeNormal);
m_view->Deselect(true);
}
QStackedWidget* stackedWidget = this->stackedWidget();
if (stackedWidget->count() < 2)
{
PagePalette_MasterPages* mpWidget = new PagePalette_MasterPages(stackedWidget, m_view, masterPage);
mpWidget->setObjectName(QString::fromLocal8Bit("PagePalette_MasterPages"));
stackedWidget->addWidget(mpWidget);
connect(mpWidget, SIGNAL(removePage(int )), m_scMW, SLOT(deletePage2(int )));
connect(mpWidget, SIGNAL(finished()) , m_scMW, SLOT(editMasterPagesEnd()));
}
else
{
ScribusDoc* doc = m_view->Doc;
PagePalette_MasterPages* mpWidget = this->masterpageWidget();
if (mpWidget->m_view != m_view)
mpWidget->setView(m_view, masterPage);
mpWidget->updateMasterPageList(masterPage);
if (doc->currentPage()->pageName() != masterPage)
mpWidget->selectMasterPage(masterPage);
}
// Set focus to page palette or focus may be set to wrong document window
this->setFocus();
stackedWidget->setCurrentIndex(1);
}
bool PathFinderPlugin::run(ScribusDoc* doc, QString)
{
QString vers = QString(qVersion()).left(5);
if (vers < "4.3.3")
{
QMessageBox::information(doc->scMW(), tr("Qt Version too old"), tr("This plugin requires at least version 4.3.3 of the Qt library"));
return true;
}
ScribusDoc* currDoc = doc;
if (currDoc == 0)
currDoc = ScCore->primaryMainWindow()->doc;
if (currDoc->m_Selection->count() > 1)
{
PageItem *Item1 = currDoc->m_Selection->itemAt(0);
PageItem *Item2 = currDoc->m_Selection->itemAt(1);
PathFinderDialog *dia = new PathFinderDialog(currDoc->scMW(), currDoc, Item1, Item2);
if (dia->exec())
{
if (dia->keepItem1)
{
PageItem *newItem;
if (dia->swapped)
{
newItem = new PageItem_Polygon(*Item2);
newItem->setSelected(false);
currDoc->Items->insert(Item2->ItemNr, newItem);
}
else
{
newItem = new PageItem_Polygon(*Item1);
newItem->setSelected(false);
currDoc->Items->insert(Item1->ItemNr, newItem);
}
}
if (dia->keepItem2)
{
PageItem *newItem;
if (dia->swapped)
{
newItem = new PageItem_Polygon(*Item1);
newItem->setSelected(false);
currDoc->Items->insert(Item1->ItemNr, newItem);
}
else
{
newItem = new PageItem_Polygon(*Item2);
newItem->setSelected(false);
currDoc->Items->insert(Item2->ItemNr, newItem);
}
}
if (dia->keepItem1 || dia->keepItem2)
currDoc->renumberItemsInListOrder();
if (dia->opMode != 4)
{
PageItem *currItem;
QPainterPath path;
FPointArray points;
if (dia->targetColor == 0)
{
currItem = Item1;
if (dia->swapped)
{
currItem = Item2;
currItem->setXYPos(Item1->xPos(), Item1->yPos());
currItem->setRotation(0.0);
}
}
else
{
if (dia->swapped)
currItem = Item1;
else
{
currItem = Item2;
currItem->setXYPos(Item1->xPos(), Item1->yPos());
currItem->setRotation(0.0);
}
}
path = dia->result;
points.fromQPainterPath(path);
currItem->PoLine = points;
currItem->Frame = false;
currItem->ClipEdited = true;
currItem->FrameType = 3;
currDoc->AdjustItemSize(currItem);
currItem->OldB2 = currItem->width();
currItem->OldH2 = currItem->height();
currItem->updateClip();
currItem->ContourLine = currItem->PoLine.copy();
currDoc->m_Selection->removeItem(currItem);
currDoc->itemSelection_DeleteItem();
}
else
{
QPainterPath path;
FPointArray points;
PageItem *newItem;
double i1x = Item1->xPos();
double i1y = Item1->yPos();
path = dia->result;
if (!path.isEmpty())
{
points.fromQPainterPath(path);
Item1->PoLine = points;
Item1->Frame = false;
Item1->ClipEdited = true;
Item1->FrameType = 3;
currDoc->AdjustItemSize(Item1);
Item1->OldB2 = Item1->width();
Item1->OldH2 = Item1->height();
Item1->updateClip();
Item1->ContourLine = Item1->PoLine.copy();
}
path = QPainterPath();
path = dia->result1;
if (!path.isEmpty())
{
points.fromQPainterPath(path);
Item2->setXYPos(i1x, i1y);
Item2->setRotation(0.0);
Item2->PoLine = points;
Item2->Frame = false;
Item2->ClipEdited = true;
Item2->FrameType = 3;
currDoc->AdjustItemSize(Item2);
Item2->OldB2 = Item2->width();
Item2->OldH2 = Item2->height();
Item2->updateClip();
Item2->ContourLine = Item2->PoLine.copy();
}
path = QPainterPath();
path = dia->result2;
if (!path.isEmpty())
{
if (dia->targetColor == 0)
{
newItem = new PageItem_Polygon(*Item1);
newItem->setXYPos(i1x, i1y);
}
else
{
newItem = new PageItem_Polygon(*Item2);
newItem->setXYPos(i1x, i1y);
newItem->setRotation(0.0);
}
currDoc->Items->append(newItem);
newItem->ItemNr = currDoc->Items->count()-1;
newItem->setSelected(false);
points.fromQPainterPath(path);
newItem->PoLine = points;
newItem->Frame = false;
newItem->ClipEdited = true;
newItem->FrameType = 3;
currDoc->AdjustItemSize(newItem);
newItem->OldB2 = newItem->width();
newItem->OldH2 = newItem->height();
newItem->updateClip();
newItem->ContourLine = newItem->PoLine.copy();
if (dia->targetColor == 2)
{
QString fill = dia->getOtherFillColor();
if (fill == CommonStrings::tr_NoneColor)
fill = CommonStrings::None;
newItem->setFillColor(fill);
QString stroke = dia->getOtherLineColor();
if (stroke == CommonStrings::tr_NoneColor)
stroke = CommonStrings::None;
newItem->setLineColor(stroke);
}
}
currDoc->m_Selection->clear();
currDoc->view()->Deselect(true);
}
currDoc->changed();
currDoc->view()->DrawNew();
}
delete dia;
}
return true;
}
/*!
\fn scribus_importpage(PyObject*, PyObject* args)
\author Alessandro Pira <*****@*****.**>
\date 11-11-2007
\param PyObject unused reference
\param args Python function args ("fromDoc", (pageList), [create, imortwhere, importwherePage])
\retval Py_RETURN_NONE if ok, null if error
*/
PyObject *scribus_importpage(PyObject* /* self */, PyObject* args)
{
char *doc = nullptr;
PyObject *pages = nullptr;
int createPageI = 1;
int importWhere = 2;
int importWherePage = 0;
if (!PyArg_ParseTuple(args, "sO|iii", &doc, &pages, &createPageI, &importWhere, &importWherePage))
return nullptr;
if (!checkHaveDocument())
return nullptr;
if (!PyTuple_Check(pages))
{
PyErr_SetString(PyExc_TypeError, QObject::tr("second argument is not tuple: must be tuple of integer values.","python error").toLocal8Bit().constData());
return nullptr;
}
Py_INCREF(pages);
std::vector<int> pageNs;
int i, n, p;
n = PyTuple_Size(pages);
for (i=0; i<n; i++)
{
if (!PyArg_Parse(PyTuple_GetItem(pages, i), "i", &p))
{
PyErr_SetString(PyExc_TypeError, QObject::tr("second argument contains non-numeric values: must be list of integer values.","python error").toLocal8Bit().constData());
Py_DECREF(pages);
return nullptr;
}
pageNs.push_back(p);
}
Py_DECREF(pages);
QString fromDoc = QString(doc);
bool createPage = (createPageI != 0);
int startPage=0, nrToImport=pageNs.size();
bool doIt = true;
ScribusDoc* currentDoc = ScCore->primaryMainWindow()->doc;
if (currentDoc->masterPageMode())
{
if (nrToImport > 1)
ScCore->primaryMainWindow()->loadPage(fromDoc, pageNs[0] - 1, false);
doIt = false;
}
else if (createPage)
{
if (importWhere == 0) //Before page
startPage = importWherePage;
else if (importWhere == 1) //After page
startPage = importWherePage + 1;
else //at end
startPage = currentDoc->DocPages.count();// + 1;
import_addpages(nrToImport, startPage);
}
else
{
startPage = currentDoc->currentPage()->pageNr() + 1;
if (nrToImport > (currentDoc->DocPages.count() - currentDoc->currentPage()->pageNr()))
{
int tmp=nrToImport - (currentDoc->DocPages.count() - currentDoc->currentPage()->pageNr());
import_addpages(tmp, currentDoc->DocPages.count());
}
}
if (doIt)
{
if (nrToImport > 0)
{
int counter = startPage + 1;
for (int i = 0; i < nrToImport; ++i)
{
ScCore->primaryMainWindow()->view->GotoPa(counter);
ScCore->primaryMainWindow()->loadPage(fromDoc, pageNs[i] - 1, false);
counter++;
}
}
}
Py_RETURN_NONE;
}
bool ScPrintEngine_PS::print(ScribusDoc& doc, PrintOptions& options)
{
bool retw = false;
ColorList usedColors;
QMap<QString, QMap<uint, FPointArray> > usedFonts;
QString filename(options.filename);
doc.getUsedFonts(usedFonts);
doc.getUsedColors(usedColors);
PrefsManager *prefsManager = PrefsManager::instance();
PSLib *dd = new PSLib(options, true, prefsManager->appPrefs.AvailFonts, usedFonts, usedColors, options.includePDFMarks, options.useSpotColors);
if (dd != NULL)
{
if (!options.toFile)
filename = prefsManager->preferencesLocation()+"/tmp.ps";
bool PSfile = dd->PS_set_file(filename);
filename = QDir::toNativeSeparators(filename);
if (PSfile)
{
// Write the PS to a file
int psCreationRetVal=dd->CreatePS(&doc, options);
if (psCreationRetVal!=0)
{
QFile::remove(filename);
if (psCreationRetVal==2)
return true;
else
{
m_errorMessage = dd->errorMessage();
return false;
}
}
if (options.prnEngine != PostScript3 && ScCore->haveGS())
{
// use gs to convert our PS to a lower version
QString tmp;
QStringList opts;
opts.append( QString("-dDEVICEWIDTHPOINTS=%1").arg(tmp.setNum(doc.pageWidth)) );
opts.append( QString("-dDEVICEHEIGHTPOINTS=%1").arg(tmp.setNum(doc.pageHeight)) );
convertPS2PS(filename, filename + ".tmp", opts, options.prnEngine);
moveFile( filename + ".tmp", filename );
}
if (!options.toFile)
{
// print and delete the PS file
QByteArray cmd;
if (options.useAltPrintCommand)
{
cmd += options.printerCommand;
cmd += " ";
cmd += filename;
system(cmd.data());
}
else
{
QByteArray cc;
cmd += "lpr -P '";
cmd += options.printer;
cmd += "'";
if (options.copies > 1)
cmd += " -#" + cc.setNum(options.copies);
cmd += options.printerOptions;
cmd += " "+filename;
system(cmd.data());
}
// Disabled that for now, as kprinter won't work otherwise
// leaving that file around doesn't harm, as it will be overwritten the next time.
// unlink(filename);
}
retw = true;
}
else
retw = false;
delete dd;
}
return retw;
}
bool PathFinderPlugin::run(ScribusDoc* doc, QString)
{
ScribusDoc* currDoc = doc;
if (currDoc == 0)
currDoc = ScCore->primaryMainWindow()->doc;
if (currDoc->m_Selection->count() <= 1)
return true;
//<<#9046
UndoTransaction* activeTransaction = NULL;
UndoManager* undoManager = UndoManager::instance();
if (UndoManager::undoEnabled())
activeTransaction = new UndoTransaction(undoManager->beginTransaction(Um::SelectionGroup, Um::IDocument, Um::PathOperation, "", Um::IPolygon));
//>>#9046
PageItem *Item1 = currDoc->m_Selection->itemAt(0);
PageItem *Item2 = currDoc->m_Selection->itemAt(1);
PathFinderDialog *dia = new PathFinderDialog(currDoc->scMW(), currDoc, Item1, Item2);
if (dia->exec())
{
int opMode=dia->opMode;
if (dia->keepItem1)
{
PageItem *newItem;
if (dia->swapped)
{
newItem = new PageItem_Polygon(*Item2);
newItem->setSelected(false);
currDoc->Items->insert(currDoc->Items->indexOf(Item2), newItem);
}
else
{
newItem = new PageItem_Polygon(*Item1);
newItem->setSelected(false);
currDoc->Items->insert(currDoc->Items->indexOf(Item1), newItem);
}
if (UndoManager::undoEnabled())
{
ScItemState<PageItem*> *is = new ScItemState<PageItem*>("Create PageItem");
is->set("CREATE_ITEM", "create_item");
is->setItem(newItem);
UndoObject *target = currDoc->Pages->at(Item1->OwnPage);
undoManager->action(target, is);
}
}
if (dia->keepItem2)
{
PageItem *newItem;
if (dia->swapped)
{
newItem = new PageItem_Polygon(*Item1);
newItem->setSelected(false);
currDoc->Items->insert(currDoc->Items->indexOf(Item1), newItem);
}
else
{
newItem = new PageItem_Polygon(*Item2);
newItem->setSelected(false);
currDoc->Items->insert(currDoc->Items->indexOf(Item2), newItem);
}
if (UndoManager::undoEnabled())
{
ScItemState<PageItem*> *is = new ScItemState<PageItem*>("Create PageItem");
is->set("CREATE_ITEM", "create_item");
is->setItem(newItem);
UndoObject *target = currDoc->Pages->at(Item1->OwnPage);
undoManager->action(target, is);
}
}
if (opMode != 4)
{
PageItem *currItem;
QPainterPath path;
FPointArray points;
if (dia->targetColor == 0)
{
currItem = Item1;
if (dia->swapped)
{
currItem = Item2;
currItem->setXYPos(Item1->xPos(), Item1->yPos());
currItem->setRotation(0.0);
}
}
else
{
if (dia->swapped)
currItem = Item1;
else
{
currItem = Item2;
currItem->setXYPos(Item1->xPos(), Item1->yPos());
currItem->setRotation(0.0);
}
}
path = dia->result;
points.fromQPainterPath(path);
//<<#9046
FPointArray oldPOLine=currItem->PoLine;
FPointArray oldContourLine=currItem->ContourLine;
ScItemState<QPair<QPair<FPointArray, FPointArray>, QPair<FPointArray, FPointArray> > >* state = NULL;
if (UndoManager::undoEnabled())
{
state = new ScItemState<QPair<QPair<FPointArray, FPointArray>, QPair<FPointArray, FPointArray> > >(Um::PathOperation);
state->set("PATH_OPERATION", "path_operation");
state->set("PATH_OP_OLD_FRAME", currItem->Frame);
state->set("PATH_OP_OLD_CLIPEDITED", currItem->ClipEdited);
state->set("PATH_OP_OLD_FRAMETYPE", currItem->FrameType);
state->set("PATH_OP_OLD_OLDB2", currItem->OldB2);
state->set("PATH_OP_OLD_OLDH2", currItem->OldH2);
state->set("PATH_OP_NEW_FRAME", false);
state->set("PATH_OP_NEW_CLIPEDITED", true);
state->set("PATH_OP_NEW_FRAMETYPE", 3);
}
//>>#9046
currItem->PoLine = points;
currItem->Frame = false;
currItem->ClipEdited = true;
currItem->FrameType = 3;
currDoc->AdjustItemSize(currItem);
currItem->OldB2 = currItem->width();
currItem->OldH2 = currItem->height();
currItem->updateClip();
currItem->ContourLine = currItem->PoLine.copy();
//<<#9046
if (UndoManager::undoEnabled())
{
state->set("PATH_OP_NEW_OLDB2", currItem->OldB2);
state->set("PATH_OP_NEW_OLDH2", currItem->OldH2);
state->setItem(QPair<QPair<FPointArray, FPointArray>, QPair<FPointArray, FPointArray> >(QPair<FPointArray, FPointArray>(oldPOLine, oldContourLine), QPair<FPointArray, FPointArray>(points, currItem->ContourLine)));
undoManager->action(currItem, state);
}
//>>#9046
currDoc->m_Selection->removeItem(currItem);
currDoc->itemSelection_DeleteItem();
}
else
{
QPainterPath path;
FPointArray points;
PageItem *newItem;
double i1x = Item1->xPos();
double i1y = Item1->yPos();
path = dia->result;
if (!path.isEmpty())
{
points.fromQPainterPath(path);
//<<#9046
FPointArray oldPOLine=Item1->PoLine;
FPointArray oldContourLine=Item1->ContourLine;
ScItemState<QPair<QPair<FPointArray, FPointArray>, QPair<FPointArray, FPointArray> > >* state = NULL;
if (UndoManager::undoEnabled())
{
state = new ScItemState<QPair<QPair<FPointArray, FPointArray>, QPair<FPointArray, FPointArray> > >(Um::PathOperation);
state->set("PATH_OPERATION", "path_operation");
state->set("PATH_OP_OLD_FRAME", Item1->Frame);
state->set("PATH_OP_OLD_CLIPEDITED", Item1->ClipEdited);
state->set("PATH_OP_OLD_FRAMETYPE", Item1->FrameType);
state->set("PATH_OP_OLD_OLDB2", Item1->OldB2);
state->set("PATH_OP_OLD_OLDH2", Item1->OldH2);
state->set("PATH_OP_NEW_FRAME", false);
state->set("PATH_OP_NEW_CLIPEDITED", true);
state->set("PATH_OP_NEW_FRAMETYPE", 3);
}
//>>#9046
Item1->PoLine = points;
Item1->Frame = false;
Item1->ClipEdited = true;
Item1->FrameType = 3;
currDoc->AdjustItemSize(Item1);
Item1->OldB2 = Item1->width();
Item1->OldH2 = Item1->height();
Item1->updateClip();
Item1->ContourLine = Item1->PoLine.copy();
//<<#9046
if (UndoManager::undoEnabled())
{
state->set("PATH_OP_NEW_OLDB2", Item1->OldB2);
state->set("PATH_OP_NEW_OLDH2", Item1->OldH2);
state->setItem(QPair<QPair<FPointArray, FPointArray>, QPair<FPointArray, FPointArray> >(QPair<FPointArray, FPointArray>(oldPOLine, oldContourLine), QPair<FPointArray, FPointArray>(Item1->PoLine, Item1->ContourLine)));
undoManager->action(Item1, state);
}
//>>#9046
}
path = QPainterPath();
path = dia->result1;
if (!path.isEmpty())
{
points.fromQPainterPath(path);
//<<#9046
FPointArray oldPOLine=Item2->PoLine;
FPointArray oldContourLine=Item2->ContourLine;
ScItemState<QPair<QPair<FPointArray, FPointArray>, QPair<FPointArray, FPointArray> > >* state = NULL;
if (UndoManager::undoEnabled())
{
state = new ScItemState<QPair<QPair<FPointArray, FPointArray>, QPair<FPointArray, FPointArray> > >(Um::PathOperation);
state->set("PATH_OPERATION", "path_operation");
state->set("PATH_OP_OLD_FRAME", Item2->Frame);
state->set("PATH_OP_OLD_CLIPEDITED", Item2->ClipEdited);
state->set("PATH_OP_OLD_FRAMETYPE", Item2->FrameType);
state->set("PATH_OP_OLD_OLDB2", Item2->OldB2);
state->set("PATH_OP_OLD_OLDH2", Item2->OldH2);
state->set("PATH_OP_NEW_FRAME", false);
state->set("PATH_OP_NEW_CLIPEDITED", true);
state->set("PATH_OP_NEW_FRAMETYPE", 3);
}
//>>#9046
Item2->setXYPos(i1x, i1y);
Item2->setRotation(0.0);
Item2->PoLine = points;
Item2->Frame = false;
Item2->ClipEdited = true;
Item2->FrameType = 3;
currDoc->AdjustItemSize(Item2);
Item2->OldB2 = Item2->width();
Item2->OldH2 = Item2->height();
Item2->updateClip();
Item2->ContourLine = Item2->PoLine.copy();
//<<#9046
if (UndoManager::undoEnabled())
{
state->set("PATH_OP_NEW_OLDB2", Item2->OldB2);
state->set("PATH_OP_NEW_OLDH2", Item2->OldH2);
state->setItem(QPair<QPair<FPointArray, FPointArray>, QPair<FPointArray, FPointArray> >(QPair<FPointArray, FPointArray>(oldPOLine, oldContourLine), QPair<FPointArray, FPointArray>(Item2->PoLine, Item2->ContourLine)));
undoManager->action(Item2, state);
}
//>>#9046
}
path = QPainterPath();
path = dia->result2;
if (!path.isEmpty())
{
if (dia->targetColor == 0)
{
newItem = new PageItem_Polygon(*Item1);
newItem->setXYPos(i1x, i1y);
}
else
{
newItem = new PageItem_Polygon(*Item2);
newItem->setXYPos(i1x, i1y);
newItem->setRotation(0.0);
}
currDoc->Items->append(newItem);
newItem->setSelected(false);
points.fromQPainterPath(path);
newItem->PoLine = points;
newItem->Frame = false;
newItem->ClipEdited = true;
newItem->FrameType = 3;
currDoc->AdjustItemSize(newItem);
newItem->OldB2 = newItem->width();
newItem->OldH2 = newItem->height();
newItem->updateClip();
newItem->ContourLine = newItem->PoLine.copy();
if (dia->targetColor == 2)
{
QString fill = dia->getOtherFillColor();
if (fill == CommonStrings::tr_NoneColor)
fill = CommonStrings::None;
newItem->setFillColor(fill);
QString stroke = dia->getOtherLineColor();
if (stroke == CommonStrings::tr_NoneColor)
stroke = CommonStrings::None;
newItem->setLineColor(stroke);
}
}
currDoc->m_Selection->clear();
currDoc->view()->Deselect(true);
}
currDoc->changed();
currDoc->view()->DrawNew();
}
delete dia;
//<<#9046
if (activeTransaction)
{
activeTransaction->commit();
delete activeTransaction;
activeTransaction = NULL;
}
//>>#9046
return true;
}
bool PathCutPlugin::run(ScribusDoc* doc, QString)
{
QString vers = QString(qVersion()).left(5);
if (vers < "4.3.3")
{
QMessageBox::information(doc->scMW(), tr("Qt Version too old"), tr("This plugin requires at least version 4.3.3 of the Qt library"));
return true;
}
ScribusDoc* currDoc = doc;
if (currDoc == 0)
currDoc = ScCore->primaryMainWindow()->doc;
if (currDoc->m_Selection->count() > 1)
{
PageItem *Item1 = currDoc->m_Selection->itemAt(0);
PageItem *Item2 = currDoc->m_Selection->itemAt(1);
if (Item1->itemType() != PageItem::PolyLine)
{
Item1 = currDoc->m_Selection->itemAt(1);
Item2 = currDoc->m_Selection->itemAt(0);
}
FPointArray path = Item1->PoLine;
QPainterPathStroker stroke;
stroke.setWidth(Item1->lineWidth());
QPainterPath cutter = stroke.createStroke(path.toQPainterPath(false));
QMatrix ms;
ms.translate(Item1->xPos() - Item2->xPos(), Item1->yPos() - Item2->yPos());
ms.rotate(Item1->rotation());
cutter = ms.map(cutter);
path.map(ms);
FPoint start = path.point(0);
FPoint end = path.point(path.size()-2);
QMatrix mm;
mm.rotate(Item2->rotation());
QPainterPath objekt = mm.map(Item2->PoLine.toQPainterPath(true));
if ((objekt.contains(QPointF(start.x(), start.y()))) || (objekt.contains(QPointF(end.x(), end.y()))))
{
QMessageBox::information(doc->scMW(), tr("Error"), tr("The cutting line must cross the polygon and\nboth end points must lie outside of the polygon"));
return true;
}
QPainterPath result = objekt.subtracted(cutter);
FPointArray points;
points.fromQPainterPath(result);
Item2->PoLine = points;
Item2->Frame = false;
Item2->ClipEdited = true;
Item2->FrameType = 3;
currDoc->AdjustItemSize(Item2);
Item2->OldB2 = Item2->width();
Item2->OldH2 = Item2->height();
Item2->updateClip();
Item2->ContourLine = Item2->PoLine.copy();
currDoc->m_Selection->clear();
currDoc->m_Selection->addItem(Item1);
currDoc->itemSelection_DeleteItem();
currDoc->m_Selection->clear();
currDoc->m_Selection->addItem(Item2);
currDoc->itemSelection_SplitItems();
currDoc->changed();
}
return true;
}
bool SubdividePlugin::run(ScribusDoc* doc, QString)
{
ScribusDoc* currDoc = doc;
if (currDoc == 0)
currDoc = ScCore->primaryMainWindow()->doc;
double nearT = 0.5;
uint docSelectionCount = currDoc->m_Selection->count();
if (docSelectionCount != 0)
{
for (uint aa = 0; aa < docSelectionCount; ++aa)
{
FPointArray points;
PageItem *currItem = currDoc->m_Selection->itemAt(aa);
if (currDoc->nodeEdit.isContourLine)
{
uint psize = currItem->ContourLine.size();
for (uint a = 0; a < psize-3; a += 4)
{
if (currItem->ContourLine.point(a).x() > 900000)
{
points.setMarker();
continue;
}
FPoint base = currItem->ContourLine.point(a);
FPoint c1 = currItem->ContourLine.point(a+1);
FPoint base2 = currItem->ContourLine.point(a+2);
FPoint c2 = currItem->ContourLine.point(a+3);
FPoint cn1 = (1.0 - nearT) * base + nearT * c1;
FPoint cn2 = (1.0 - nearT) * cn1 + nearT * ((1.0 - nearT) * c1 + nearT * c2);
FPoint cn3 = (1.0 - nearT) * ((1.0 - nearT) * c1 + nearT * c2) + nearT * ((1.0 - nearT) * c2 + nearT * base2);
FPoint cn4 = (1.0 - nearT) * c2 + nearT * base2;
FPoint bp1 = (1.0 - nearT) * cn2 + nearT * cn3;
if ((base == c1) && (base2 == c2))
{
points.addPoint(base);
points.addPoint(c1);
points.addPoint(bp1);
points.addPoint(bp1);
points.addPoint(bp1);
points.addPoint(bp1);
points.addPoint(base2);
points.addPoint(c2);
}
else
{
points.addPoint(base);
points.addPoint(cn1);
points.addPoint(bp1);
points.addPoint(cn2);
points.addPoint(bp1);
points.addPoint(cn3);
points.addPoint(base2);
points.addPoint(cn4);
}
}
currItem->ContourLine = points;
}
else
{
uint psize = currItem->PoLine.size();
for (uint a = 0; a < psize-3; a += 4)
{
if (currItem->PoLine.point(a).x() > 900000)
{
points.setMarker();
continue;
}
FPoint base = currItem->PoLine.point(a);
FPoint c1 = currItem->PoLine.point(a+1);
FPoint base2 = currItem->PoLine.point(a+2);
FPoint c2 = currItem->PoLine.point(a+3);
FPoint cn1 = (1.0 - nearT) * base + nearT * c1;
FPoint cn2 = (1.0 - nearT) * cn1 + nearT * ((1.0 - nearT) * c1 + nearT * c2);
FPoint cn3 = (1.0 - nearT) * ((1.0 - nearT) * c1 + nearT * c2) + nearT * ((1.0 - nearT) * c2 + nearT * base2);
FPoint cn4 = (1.0 - nearT) * c2 + nearT * base2;
FPoint bp1 = (1.0 - nearT) * cn2 + nearT * cn3;
if ((base == c1) && (base2 == c2))
{
points.addPoint(base);
points.addPoint(c1);
points.addPoint(bp1);
points.addPoint(bp1);
points.addPoint(bp1);
points.addPoint(bp1);
points.addPoint(base2);
points.addPoint(c2);
}
else
{
points.addPoint(base);
points.addPoint(cn1);
points.addPoint(bp1);
points.addPoint(cn2);
points.addPoint(bp1);
points.addPoint(cn3);
points.addPoint(base2);
points.addPoint(cn4);
}
}
currItem->PoLine = points;
currItem->Frame = false;
currItem->ClipEdited = true;
currItem->FrameType = 3;
currDoc->AdjustItemSize(currItem);
currItem->OldB2 = currItem->width();
currItem->OldH2 = currItem->height();
currItem->updateClip();
}
}
currDoc->regionsChanged()->update(QRectF());
currDoc->changed();
}
return true;
}
void Serializer::serializeObjects(const Selection& selection, SaxHandler& outputhandler)
{
Xml_attr attr;
UniqueID handler( & outputhandler );
handler.beginDoc();
handler.begin("SCRIBUSFRAGMENT", attr);
ScribusDoc* doc = selection.itemAt(0)->doc();
QMap<QString,int>::Iterator itf;
for (itf = doc->UsedFonts.begin(); itf != doc->UsedFonts.end(); ++itf)
{
attr["name"] = itf.key();
handler.beginEnd("font", attr);
}
ColorList usedColors;
doc->getUsedColors(usedColors, false);
ColorList::Iterator itc;
for (itc = usedColors.begin(); itc != usedColors.end(); ++itc)
{
Xml_attr cattr;
cattr["name"] = itc.key();
if (doc->PageColors[itc.key()].getColorModel() == colorModelRGB)
cattr["RGB"] = doc->PageColors[itc.key()].nameRGB();
else
cattr["CMYK"] = doc->PageColors[itc.key()].nameCMYK();
cattr["Spot"] = toXMLString(doc->PageColors[itc.key()].isSpotColor());
cattr["Register"] = toXMLString(doc->PageColors[itc.key()].isRegistrationColor());
handler.beginEnd("color", cattr);
}
ResourceCollection lists;
for (int i=0; i < doc->Items->count(); ++i)
doc->Items->at(i)->getNamedResources(lists);
QList<QString>::Iterator it;
QList<QString> names = lists.styleNames();
for (it = names.begin(); it != names.end(); ++it)
doc->paragraphStyles().get(*it).saxx(handler);
names = lists.charStyleNames();
for (it = names.begin(); it != names.end(); ++it)
doc->charStyles().get(*it).saxx(handler);
names = lists.lineStyleNames();
for (it = names.begin(); it != names.end(); ++it)
{
Xml_attr multiattr;
multiattr["Name"] = *it;
handler.begin("MultiLine", multiattr);
multiLine ml = doc->MLineStyles[*it];
multiLine::Iterator itMU2;
for (itMU2 = ml.begin(); itMU2 != ml.end(); ++itMU2)
{
Xml_attr lineattr;
lineattr["Color"] = (*itMU2).Color;
lineattr["Shade"] = toXMLString((*itMU2).Shade);
lineattr["Dash"] = toXMLString((*itMU2).Dash);
lineattr["LineEnd"] = toXMLString((*itMU2).LineEnd);
lineattr["LineJoin"] = toXMLString((*itMU2).LineJoin);
lineattr["Width"] = toXMLString((*itMU2).Width);
handler.beginEnd("SubLine", lineattr);
}
handler.end("MultiLine");
}
/* names = lists.patterns();
for (it = names.begin(); it != names.end(); ++it)
doc->patterns[*it].saxx(handler);
*/
/*
QStringList patterns = doc->getUsedPatternsSelection((Selection*)&selection);
for (int c = 0; c < patterns.count(); ++c)
{
ScPattern& pa = doc->docPatterns[patterns[c]];
Xml_attr cattr;
cattr["Name"] = patterns[c];
cattr["scaleX"] = toXMLString(pa.scaleX);
cattr["scaleY"] = toXMLString(pa.scaleY);
cattr["width"] = toXMLString(pa.width);
cattr["height"] = toXMLString(pa.height);
cattr["xoffset"] = toXMLString(pa.xoffset);
cattr["yoffset"] = toXMLString(pa.yoffset);
handler.begin("Pattern", cattr);
for (int o = 0; o < pa.items.count(); o++)
{
pa.items.at(o)->saxx(handler);
}
handler.end("Pattern");
}
*/
for (int i=0; i < doc->Items->count(); ++i)
{
int k = selection.findItem(doc->Items->at(i));
if (k >=0)
doc->Items->at(i)->saxx(handler);
}
handler.end("SCRIBUSFRAGMENT");
handler.endDoc();
}
bool PathStrokerPlugin::run(ScribusDoc* doc, QString)
{
ScribusDoc* currDoc = doc;
if (currDoc == 0)
currDoc = ScCore->primaryMainWindow()->doc;
if (currDoc->m_Selection->count() > 0)
{
QVector<double> m_array;
PageItem *currItem = currDoc->m_Selection->itemAt(0);
FPointArray path = currItem->PoLine;
QPainterPath pp;
if (currItem->itemType() == PageItem::PolyLine)
pp = path.toQPainterPath(false);
else
pp = path.toQPainterPath(true);
if (currItem->NamedLStyle.isEmpty())
{
QPainterPathStroker stroke;
stroke.setCapStyle(currItem->lineEnd());
stroke.setJoinStyle(currItem->lineJoin());
if (currItem->lineStyle() == Qt::SolidLine)
stroke.setDashPattern(currItem->lineStyle());
else
{
getDashArray(currItem->lineStyle(), 1, m_array);
stroke.setDashPattern(m_array);
}
stroke.setWidth(currItem->lineWidth());
QPainterPath result = stroke.createStroke(pp).simplified();
if (currItem->startArrowIndex() != 0)
{
FPoint Start = currItem->PoLine.point(0);
for (uint xx = 1; xx < currItem->PoLine.size(); xx += 2)
{
FPoint Vector = currItem->PoLine.point(xx);
if ((Start.x() != Vector.x()) || (Start.y() != Vector.y()))
{
double r = atan2(Start.y()-Vector.y(),Start.x()-Vector.x())*(180.0/M_PI);
QMatrix arrowTrans;
FPointArray arrow = currDoc->arrowStyles.at(currItem->startArrowIndex()-1).points.copy();
arrowTrans.translate(Start.x(), Start.y());
arrowTrans.rotate(r);
arrowTrans.scale(currItem->lineWidth(), currItem->lineWidth());
arrow.map(arrowTrans);
result.addPath(arrow.toQPainterPath(true));
break;
}
}
}
if (currItem->endArrowIndex() != 0)
{
FPoint End = currItem->PoLine.point(currItem->PoLine.size()-2);
for (uint xx = currItem->PoLine.size()-1; xx > 0; xx -= 2)
{
FPoint Vector = currItem->PoLine.point(xx);
if ((End.x() != Vector.x()) || (End.y() != Vector.y()))
{
double r = atan2(End.y()-Vector.y(),End.x()-Vector.x())*(180.0/M_PI);
QMatrix arrowTrans;
FPointArray arrow = currDoc->arrowStyles.at(currItem->endArrowIndex()-1).points.copy();
arrowTrans.translate(End.x(), End.y());
arrowTrans.rotate(r);
arrowTrans.scale(currItem->lineWidth(), currItem->lineWidth());
arrow.map(arrowTrans);
result.addPath(arrow.toQPainterPath(true));
break;
}
}
}
currDoc->m_Selection->clear();
PageItem* newItem = currDoc->convertItemTo(currItem, PageItem::Polygon);
newItem->setLineWidth(0);
newItem->setLineStyle(Qt::SolidLine);
newItem->setFillColor(newItem->lineColor());
newItem->setFillShade(newItem->lineShade());
newItem->setFillTransparency(newItem->lineTransparency());
newItem->setFillBlendmode(newItem->lineBlendmode());
FPointArray points;
points.fromQPainterPath(result);
newItem->PoLine = points;
newItem->Frame = false;
newItem->ClipEdited = true;
newItem->FrameType = 3;
currDoc->AdjustItemSize(newItem);
newItem->OldB2 = newItem->width();
newItem->OldH2 = newItem->height();
newItem->updateClip();
newItem->ContourLine = newItem->PoLine.copy();
newItem->setFillEvenOdd(true);
currDoc->m_Selection->addItem(newItem);
}
else
{
currDoc->m_Selection->clear();
multiLine ml = currDoc->MLineStyles[currItem->NamedLStyle];
bool first = true;
for (int it = ml.size()-1; it > -1; it--)
{
if ((ml[it].Color != CommonStrings::None) && (ml[it].Width != 0))
{
QPainterPathStroker stroke;
stroke.setCapStyle(static_cast<Qt::PenCapStyle>(ml[it].LineEnd));
stroke.setJoinStyle(static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
if (static_cast<Qt::PenStyle>(ml[it].Dash) == Qt::SolidLine)
stroke.setDashPattern(static_cast<Qt::PenStyle>(ml[it].Dash));
else
{
getDashArray(static_cast<Qt::PenStyle>(ml[it].Dash), 1, m_array);
stroke.setDashPattern(m_array);
}
stroke.setWidth(ml[it].Width);
QPainterPath result = stroke.createStroke(pp).simplified();
PageItem* newItem;
if (first)
{
newItem = currDoc->convertItemTo(currItem, PageItem::Polygon);
}
else
{
newItem = new PageItem_Polygon(*currItem);
newItem->convertTo(PageItem::Polygon);
currDoc->Items->append(newItem);
}
first = false;
newItem->ItemNr = currDoc->Items->count()-1;
newItem->setLineStyle(Qt::SolidLine);
newItem->setFillColor(ml[it].Color);
newItem->setFillShade(ml[it].Shade);
newItem->setFillTransparency(newItem->lineTransparency());
newItem->setFillBlendmode(newItem->lineBlendmode());
newItem->setLineColor(CommonStrings::None);
newItem->setCustomLineStyle("");
FPointArray points;
points.fromQPainterPath(result);
newItem->PoLine = points;
newItem->Frame = false;
newItem->ClipEdited = true;
newItem->FrameType = 3;
currDoc->AdjustItemSize(newItem);
newItem->OldB2 = newItem->width();
newItem->OldH2 = newItem->height();
newItem->updateClip();
newItem->ContourLine = newItem->PoLine.copy();
newItem->setFillEvenOdd(true);
currDoc->m_Selection->addItem(newItem);
}
}
if (currItem->startArrowIndex() != 0)
{
FPoint Start = currItem->PoLine.point(0);
for (uint xx = 1; xx < currItem->PoLine.size(); xx += 2)
{
FPoint Vector = currItem->PoLine.point(xx);
if ((Start.x() != Vector.x()) || (Start.y() != Vector.y()))
{
double r = atan2(Start.y()-Vector.y(),Start.x()-Vector.x())*(180.0/M_PI);
QMatrix arrowTrans;
FPointArray arrow = currDoc->arrowStyles.at(currItem->startArrowIndex()-1).points.copy();
arrowTrans.translate(Start.x(), Start.y());
arrowTrans.rotate(r);
arrowTrans.scale(currItem->lineWidth(), currItem->lineWidth());
arrow.map(arrowTrans);
PageItem* newItem = new PageItem_Polygon(*currItem);
currDoc->Items->append(newItem);
newItem->ItemNr = currDoc->Items->count()-1;
newItem->setLineWidth(0);
newItem->setLineStyle(Qt::SolidLine);
newItem->setCustomLineStyle("");
newItem->setFillColor(newItem->lineColor());
newItem->setFillShade(newItem->lineShade());
newItem->setFillTransparency(newItem->lineTransparency());
newItem->setFillBlendmode(newItem->lineBlendmode());
newItem->PoLine = arrow;
newItem->Frame = false;
newItem->ClipEdited = true;
newItem->FrameType = 3;
currDoc->AdjustItemSize(newItem);
newItem->OldB2 = newItem->width();
newItem->OldH2 = newItem->height();
newItem->updateClip();
newItem->ContourLine = newItem->PoLine.copy();
newItem->setFillEvenOdd(true);
currDoc->m_Selection->addItem(newItem);
break;
}
}
}
if (currItem->endArrowIndex() != 0)
{
FPoint End = currItem->PoLine.point(currItem->PoLine.size()-2);
for (uint xx = currItem->PoLine.size()-1; xx > 0; xx -= 2)
{
FPoint Vector = currItem->PoLine.point(xx);
if ((End.x() != Vector.x()) || (End.y() != Vector.y()))
{
double r = atan2(End.y()-Vector.y(),End.x()-Vector.x())*(180.0/M_PI);
QMatrix arrowTrans;
FPointArray arrow = currDoc->arrowStyles.at(currItem->endArrowIndex()-1).points.copy();
arrowTrans.translate(End.x(), End.y());
arrowTrans.rotate(r);
arrowTrans.scale(currItem->lineWidth(), currItem->lineWidth());
arrow.map(arrowTrans);
PageItem* newItem = new PageItem_Polygon(*currItem);
currDoc->Items->append(newItem);
newItem->ItemNr = currDoc->Items->count()-1;
newItem->setLineWidth(0);
newItem->setLineStyle(Qt::SolidLine);
newItem->setCustomLineStyle("");
newItem->setFillColor(newItem->lineColor());
newItem->setFillShade(newItem->lineShade());
newItem->setFillTransparency(newItem->lineTransparency());
newItem->setFillBlendmode(newItem->lineBlendmode());
newItem->PoLine = arrow;
newItem->Frame = false;
newItem->ClipEdited = true;
newItem->FrameType = 3;
currDoc->AdjustItemSize(newItem);
newItem->OldB2 = newItem->width();
newItem->OldH2 = newItem->height();
newItem->updateClip();
newItem->ContourLine = newItem->PoLine.copy();
newItem->setFillEvenOdd(true);
currDoc->m_Selection->addItem(newItem);
break;
}
}
}
if (currDoc->m_Selection->count() > 1)
currDoc->itemSelection_GroupObjects(false, false);
currDoc->m_Selection->itemAt(0)->emitAllToGUI();
}
currDoc->changed();
}
return true;
}
