void ScreenPainter::drawGlyphOutline(const GlyphLayout gl, bool fill)
{
if (fill)
drawGlyph(gl);
m_painter->save();
bool fr = m_painter->fillRule();
m_painter->setFillRule(false);
setupState(false);
m_painter->translate(0, -(fontSize() * gl.scaleV));
FPointArray outline = font().glyphOutline(gl.glyph);
double scaleHv = gl.scaleH * fontSize() / 10.0;
double scaleVv = gl.scaleV * fontSize() / 10.0;
QTransform trans;
trans.scale(scaleHv, scaleVv);
outline.map(trans);
m_painter->setupPolygon(&outline, true);
if (outline.size() > 3)
{
m_painter->setLineWidth(strokeWidth());
m_painter->strokePath();
}
m_painter->setFillRule(fr);
m_painter->restore();
}
void CanvasMode_EditArc::mouseMoveEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m->accept();
double newX = mousePointDoc.x();
double newY = mousePointDoc.y();
if (m_canvas->m_viewMode.m_MouseButtonPressed && m_view->moveTimerElapsed())
{
PageItem *currItem = m_doc->m_Selection->itemAt(0);
QTransform itemMatrix = currItem->getTransform();
QPointF sPoint = currItem->PoLine.pointQF(0);
QPointF smPoint = itemMatrix.map(sPoint);
QLineF stLinA = QLineF(smPoint, QPointF(m_Mxp, m_Myp));
QLineF stLinM = QLineF(smPoint, QPointF(newX, newY));
double deltaAngle = stLinM.angle() - stLinA.angle();
QPainterPath pp;
if (m_arcPoint == useControlStart)
m_startAngle += deltaAngle;
else if (m_arcPoint == useControlSweep)
m_endAngle += deltaAngle;
else if (m_arcPoint == useControlHeight)
m_heightPoint = QPointF(m_heightPoint.x(), m_heightPoint.y() + (newY - m_Myp));
else if (m_arcPoint == useControlWidth)
m_widthPoint = QPointF(m_widthPoint.x() + (newX - m_Mxp), m_widthPoint.y());
double nSweep = m_endAngle - m_startAngle;
if (nSweep < 0)
nSweep += 360;
double nWidth = sPoint.x() - m_widthPoint.x();
double nHeight = sPoint.y() - m_heightPoint.y();
if ((nWidth > 0) && (nHeight > 0))
{
pp.moveTo(sPoint);
pp.arcTo(QRectF(sPoint.x() - nWidth, sPoint.y() - nHeight, nWidth * 2, nHeight * 2), m_startAngle, nSweep);
pp.closeSubpath();
FPointArray ar;
ar.fromQPainterPath(pp);
if (m_arcPoint == useControlStart)
{
m_startPoint = ar.pointQF(2);
QLineF stLinA = QLineF(smPoint, itemMatrix.map(m_startPoint));
m_canvas->displayRotHUD(m->globalPos(), 360.0 - stLinA.angle());
}
else if (m_arcPoint == useControlSweep)
{
m_endPoint = ar.pointQF(ar.size() - 4);
QLineF stLinA = QLineF(smPoint, itemMatrix.map(m_endPoint));
m_canvas->displayRotHUD(m->globalPos(), 360.0 - stLinA.angle());
}
QLineF res = QLineF(m_centerPoint, m_startPoint);
QLineF swe = QLineF(m_centerPoint, m_endPoint);
vectorDialog->setValues(res.angle(), swe.angle(), nHeight * 2, nWidth * 2);
blockUpdateFromItem(true);
currItem->update();
blockUpdateFromItem(false);
m_doc->regionsChanged()->update(itemMatrix.mapRect(QRectF(0, 0, currItem->width(), currItem->height())).adjusted(-nWidth, -nHeight, nWidth, nHeight));
}
}
m_Mxp = newX;
m_Myp = newY;
}
void KCurve::keyPressEvent(QKeyEvent *e)
{
if(e->key() == Qt::Key_Delete || e->key() == Qt::Key_Backspace)
{
if (m_points.size() > 2)
{
FPoint closest_point = m_points.point(0);
FPoint p = m_points.point(0);
int pos = 0;
int cc = 0;
double distance = 1000; // just a big number
while(cc < m_points.size())
{
p = m_points.point(cc);
if (fabs (m_grab_point.x() - p.x()) < distance)
{
distance = fabs(m_grab_point.x() - p.x());
closest_point = p;
m_pos = pos;
}
cc++;
pos++;
}
FPointArray cli;
cli.putPoints(0, m_pos, m_points);
cli.putPoints(cli.size(), m_points.size()-m_pos-1, m_points, m_pos+1);
m_points.resize(0);
m_points = cli.copy();
m_grab_point = closest_point;
repaint();
emit modified();
QWidget::keyPressEvent(e);
}
}
}
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;
}
void NodePalette::ToggleAbsMode()
{
if (doc==0)
return;
FPoint zp(0.0, 0.0);
disconnect(XSpin, SIGNAL(valueChanged(double)), this, SLOT(MovePoint()));
disconnect(YSpin, SIGNAL(valueChanged(double)), this, SLOT(MovePoint()));
FPointArray Clip;
FPoint np(0.0, 0.0);
if (EditCont->isChecked())
Clip = doc->m_Selection->itemAt(0)->ContourLine;
else
Clip = doc->m_Selection->itemAt(0)->PoLine;
if (doc->nodeEdit.SelNode.count() != 0)
np = Clip.point(doc->nodeEdit.SelNode.at(0));
if (AbsMode->isChecked())
{
XSpin->setMinimum(-16777215);
YSpin->setMinimum(-16777215);
if (absToCanvas->isChecked())
zp = FPoint(doc->m_Selection->itemAt(0)->xPos(), doc->m_Selection->itemAt(0)->yPos());
else
zp = FPoint(doc->m_Selection->itemAt(0)->xPos() - doc->currentPage()->xOffset(), doc->m_Selection->itemAt(0)->yPos() - doc->currentPage()->yOffset());
}
else
{
XSpin->setMinimum(0);
YSpin->setMinimum(0);
}
XSpin->setValue((np.x() + zp.x())*doc->unitRatio());
YSpin->setValue((np.y() + zp.y())*doc->unitRatio());
connect(XSpin, SIGNAL(valueChanged(double)), this, SLOT(MovePoint()));
connect(YSpin, SIGNAL(valueChanged(double)), this, SLOT(MovePoint()));
}
void CurveWidget::doInvert()
{
FPointArray curve = cDisplay->getCurve();
for (int a = 0; a < curve.size(); a++)
{
FPoint p = curve.point(a);
curve.setPoint(a, p.x(), 1.0 - p.y());
}
cDisplay->setCurve(curve);
}
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;
}
FPointArray ScFace::ScFaceData::glyphOutline(gid_type gl, qreal sz) const
{
if (gl >= CONTROL_GLYPHS)
return FPointArray();
else if (! m_glyphWidth.contains(gl)) {
loadGlyph(gl);
}
FPointArray res = m_glyphOutline[gl].Outlines.copy();
if (sz != 1.0)
res.scale(sz, sz);
return res;
}
void KCurve::setCurve(FPointArray inlist)
{
m_points_back = m_points.copy();
m_points.resize(0);
m_points = inlist.copy();
repaint();
emit modified();
}
: QDialog( parent, Qt::FramelessWindowHint)
#endif
{
int base = 48;
int size = base + qRound(-face.descent() * base) + 3;
int sizex = size + 2, sizey = size + 20;
resize(sizex, sizey);
setMinimumSize(sizex, sizey);
setMaximumSize(sizex, sizey);
pixm = QPixmap(size, size);
QImage pix(size, size, QImage::Format_ARGB32_Premultiplied);
ScPainter *p = new ScPainter(&pix, size, size);
p->clear();
pixm.fill(Qt::white);
QTransform chma;
chma.scale(4.8, 4.8);
uint gl = face.char2CMap(currentChar);
FPointArray gly = face.glyphOutline(gl);
double ww = size - face.glyphWidth(gl, base);
if (gly.size() > 4)
{
gly.map(chma);
p->translate(ww / 2, 1);
p->setBrush(Qt::black);
p->setFillMode(1);
p->setupPolygon(&gly);
p->fillPath();
p->end();
}
delete p;
pixm=QPixmap::fromImage(pix);
QString tmp;
tmp.sprintf("%04X", currentChar);
valu = "0x"+tmp;
}
void CurveWidget::doLoad()
{
QString fileName;
PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
QString wdir = dirs->get("curves", ".");
CustomFDialog dia(this, wdir, tr("Open"), tr("Curve Files (*.scu *.SCU);;All Files (*)"), fdHidePreviewCheckBox | fdExistingFiles);
if (dia.exec() == QDialog::Accepted)
fileName = dia.selectedFile();
else
return;
if (!fileName.isEmpty())
{
dirs->set("curves", fileName.left(fileName.lastIndexOf("/")));
QFile f(fileName);
if (f.open(QIODevice::ReadOnly))
{
QTextStream fp(&f);
int numVals;
double xval, yval;
FPointArray curve;
curve.resize(0);
fp >> numVals;
for (int nv = 0; nv < numVals; nv++)
{
QString s;
fp >> s;
xval = ScCLocale::toDoubleC(s);
fp >> s;
yval = ScCLocale::toDoubleC(s);
curve.addPoint(xval, yval);
}
cDisplay->setCurve(curve);
int lin;
fp >> lin;
cDisplay->setLinear(lin);
}
void ArrowChooser::rebuildList(QList<ArrowDesc> *arrowStyles)
{
clear();
FPointArray Path;
Path.resize(0);
addItem(CommonStrings::tr_None);
for (int a = 0; a < arrowStyles->count(); ++a)
{
QImage image(22, 22, QImage::Format_ARGB32);
ScPainter *painter = new ScPainter(&image, 22, 22);
painter->clear();
painter->setBrush(qRgb(0, 0, 0));
painter->setPen(qRgb(0, 0, 0));
painter->setFillMode(1);
painter->translate(3.0, 3.0);
Path.resize(0);
Path = arrowStyles->at(a).points.copy();
FPoint min = getMinClipF(&Path);
Path.translate(-min.x(), -min.y());
FPoint max = Path.WidthHeight();
QMatrix mm;
QMatrix mm2;
if (arrowDirection)
{
mm2.scale(-1, 1);
mm2.translate(-max.x(), 0);
}
mm.scale(16.0 / qMax(max.x(), max.y()), 16.0 / qMax(max.x(), max.y()));
Path.map(mm2 * mm);
painter->setupPolygon(&Path);
painter->setLineWidth(1.0);
painter->drawPolygon();
painter->drawPolyLine();
painter->end();
delete painter;
int wi = image.width();
int hi = image.height();
for( int yi=0; yi < hi; ++yi )
{
QRgb *s = (QRgb*)(image.scanLine( yi ));
for(int xi=0; xi < wi; ++xi )
{
if((*s) == 0xffffffff)
(*s) &= 0x00ffffff;
s++;
}
}
QPixmap Ico;
Ico=QPixmap::fromImage(image);
addItem(Ico, arrowStyles->at(a).name);
}
}
FPointArray ScFace::ScFaceData::glyphOutline(uint gl, qreal sz) const
{
if (gl >= CONTROL_GLYPHS)
return FPointArray();
else if (gl == 0) {
sz *= 10;
FPointArray sq;
sq.addQuadPoint(0,0,0,0,sz,0,sz,0);
sq.addQuadPoint(sz,0,sz,0,sz,sz,sz,sz);
sq.addQuadPoint(sz,sz,sz,sz,0,sz,0,sz);
sq.addQuadPoint(0,sz,0,sz,0,0,0,0);
return sq;
}
else if (! m_glyphWidth.contains(gl)) {
loadGlyph(gl);
}
FPointArray res = m_glyphOutline[gl].Outlines.copy();
if (sz != 1.0)
res.scale(sz, sz);
return res;
}
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;
}
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;
}
void KCurve::mousePressEvent ( QMouseEvent * e )
{
FPoint closest_point = FPoint();
double distance;
if (e->button() != Qt::LeftButton)
return;
double x = e->pos().x() / (float)width();
double y = 1.0 - e->pos().y() / (float)height();
distance = 1000; // just a big number
FPoint p = m_points.point(0);
int insert_pos =0;
int pos = 0;
int cc = 0;
while(cc < m_points.size())
{
p = m_points.point(cc);
if (fabs (x - p.x()) < distance)
{
distance = fabs(x - p.x());
closest_point = p;
insert_pos = pos;
}
cc++;
pos++;
}
m_pos = insert_pos;
m_grab_point = closest_point;
m_grabOffsetX = m_grab_point.x() - x;
m_grabOffsetY = m_grab_point.y() - y;
m_grab_point = FPoint(x + m_grabOffsetX, y + m_grabOffsetY);
double curveVal = getCurveValue(x);
if(distance * width() > 5)
{
m_dragging = false;
if(fabs(y - curveVal) * width() > 5)
return;
if (m_points.size() < 14)
{
if (x > closest_point.x())
m_pos++;
FPointArray cli;
cli.putPoints(0, m_pos, m_points);
cli.resize(cli.size()+1);
cli.putPoints(cli.size()-1, 1, x, curveVal);
cli.putPoints(cli.size(), m_points.size()-m_pos, m_points, m_pos);
m_points.resize(0);
m_points = cli.copy();
m_dragging = true;
m_grab_point = m_points.point(m_pos);
m_grabOffsetX = m_grab_point.x() - x;
m_grabOffsetY = m_grab_point.y() - curveVal;
m_grab_point = FPoint(x + m_grabOffsetX, curveVal + m_grabOffsetY);
setCursor(QCursor(Qt::CrossCursor));
}
}
else
{
if(fabs(y - closest_point.y()) * width() > 5)
return;
m_dragging = true;
setCursor(QCursor(Qt::CrossCursor));
}
// Determine the leftmost and rightmost points.
m_leftmost = 0;
m_rightmost = 1;
cc = 0;
while(cc < m_points.size())
{
p = m_points.point(cc);
if (p != m_grab_point)
{
if(p.x() > m_leftmost && p.x() < x)
m_leftmost = p.x();
if(p.x() < m_rightmost && p.x() > x)
m_rightmost = p.x();
}
cc++;
}
repaint();
emit modified();
}
void PageItem_PolyLine::DrawObj_Item(ScPainter *p, QRectF /*e*/)
{
if (!m_Doc->RePos && PoLine.size()>=4)
{
if (!m_Doc->layerOutline(LayerID))
{
if ((fillColor() != CommonStrings::None) || (GrType != 0))
{
FPointArray cli;
FPoint Start;
bool firstp = true;
for (uint n = 0; n < PoLine.size()-3; n += 4)
{
if (firstp)
{
Start = PoLine.point(n);
firstp = false;
}
if (PoLine.point(n).x() > 900000)
{
cli.addPoint(PoLine.point(n-2));
cli.addPoint(PoLine.point(n-2));
cli.addPoint(Start);
cli.addPoint(Start);
cli.setMarker();
firstp = true;
continue;
}
cli.addPoint(PoLine.point(n));
cli.addPoint(PoLine.point(n+1));
cli.addPoint(PoLine.point(n+2));
cli.addPoint(PoLine.point(n+3));
}
if (cli.size() > 2)
{
FPoint l1 = cli.point(cli.size()-2);
cli.addPoint(l1);
cli.addPoint(l1);
cli.addPoint(Start);
cli.addPoint(Start);
}
p->setupPolygon(&cli);
p->fillPath();
}
p->setupPolygon(&PoLine, false);
if (NamedLStyle.isEmpty())
{
if ((!patternStrokeVal.isEmpty()) && (m_Doc->docPatterns.contains(patternStrokeVal)))
{
if (patternStrokePath)
{
QPainterPath guidePath = PoLine.toQPainterPath(false);
DrawStrokePattern(p, guidePath);
}
else
{
p->setPattern(&m_Doc->docPatterns[patternStrokeVal], patternStrokeScaleX, patternStrokeScaleY, patternStrokeOffsetX, patternStrokeOffsetY, patternStrokeRotation, patternStrokeSkewX, patternStrokeSkewY, patternStrokeMirrorX, patternStrokeMirrorY);
p->setStrokeMode(ScPainter::Pattern);
p->strokePath();
}
}
else if (GrTypeStroke > 0)
{
if ((!gradientStrokeVal.isEmpty()) && (!m_Doc->docGradients.contains(gradientStrokeVal)))
gradientStrokeVal = "";
if (!(gradientStrokeVal.isEmpty()) && (m_Doc->docGradients.contains(gradientStrokeVal)))
stroke_gradient = m_Doc->docGradients[gradientStrokeVal];
if (stroke_gradient.Stops() < 2) // fall back to solid stroking if there are not enough colorstops in the gradient.
{
if (lineColor() != CommonStrings::None)
{
p->setBrush(strokeQColor);
p->setStrokeMode(ScPainter::Solid);
}
else
p->setStrokeMode(ScPainter::None);
}
else
{
p->setStrokeMode(ScPainter::Gradient);
p->stroke_gradient = stroke_gradient;
if (GrTypeStroke == 6)
p->setGradient(VGradient::linear, FPoint(GrStrokeStartX, GrStrokeStartY), FPoint(GrStrokeEndX, GrStrokeEndY), FPoint(GrStrokeStartX, GrStrokeStartY), GrStrokeScale, GrStrokeSkew);
else
p->setGradient(VGradient::radial, FPoint(GrStrokeStartX, GrStrokeStartY), FPoint(GrStrokeEndX, GrStrokeEndY), FPoint(GrStrokeFocalX, GrStrokeFocalY), GrStrokeScale, GrStrokeSkew);
}
p->strokePath();
}
else if (lineColor() != CommonStrings::None)
{
p->setStrokeMode(ScPainter::Solid);
p->strokePath();
}
}
else
{
p->setStrokeMode(ScPainter::Solid);
multiLine ml = m_Doc->MLineStyles[NamedLStyle];
QColor tmp;
for (int it = ml.size()-1; it > -1; it--)
{
if (ml[it].Color != CommonStrings::None) // && (ml[it].Width != 0))
{
SetQColor(&tmp, ml[it].Color, ml[it].Shade);
p->setPen(tmp, ml[it].Width, static_cast<Qt::PenStyle>(ml[it].Dash), static_cast<Qt::PenCapStyle>(ml[it].LineEnd), static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
p->strokePath();
}
}
}
}
if (m_startArrowIndex != 0)
{
FPoint Start = PoLine.point(0);
for (uint xx = 1; xx < PoLine.size(); xx += 2)
{
FPoint Vector = 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);
QTransform arrowTrans;
arrowTrans.translate(Start.x(), Start.y());
arrowTrans.rotate(r);
drawArrow(p, arrowTrans, m_startArrowIndex);
break;
}
}
}
if (m_endArrowIndex != 0)
{
FPoint End = PoLine.point(PoLine.size()-2);
for (uint xx = PoLine.size()-1; xx > 0; xx -= 2)
{
FPoint Vector = 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);
QTransform arrowTrans;
arrowTrans.translate(End.x(), End.y());
arrowTrans.rotate(r);
drawArrow(p, arrowTrans, m_endArrowIndex);
break;
}
}
}
}
}
QVariant CharTableModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || m_doc == 0)
return QVariant();
int ix = index.row() * m_cols + index.column();
uint currentChar;
QString currentFont = m_fontInUse;
if (ix < m_characters.count())
{
currentChar = m_characters[ix];
currentFont = m_fonts[ix];
}
else
return QVariant();
// for mimeData()
if (role == CharTableModel::CharTextRole)
return QString("%1").arg(QChar(currentChar));
if (role == CharTableModel::CharTextAndFontRole)
return QString("%1#%2").arg(currentChar).arg(currentFont);
// tooltip
if (role == Qt::ToolTipRole)
return QString("Unicode:\n0x%1").arg(currentChar, 4, 16, QChar('0'));
// status tip
if ( role == Qt::StatusTipRole )
{
QString tmp = QString("%1").arg(currentChar, 4, 16, QChar('0')).toUpper();
QStringList lst;
lst << tmp << currentFont;
return lst;
}
// pixmap
if (role == Qt::DecorationRole)
{
// m_cols should not become 0. Never.
int baseSize = m_viewWidth / m_cols;
QTransform chma;
chma.scale(baseSize/10, baseSize/10);
ScFace face = (*m_doc->AllFonts)[currentFont];
uint gl = face.char2CMap(currentChar);
int size = baseSize + qRound(-face.descent() * baseSize) + 1;
double ww = baseSize - face.glyphWidth(gl, baseSize);
QImage pix(baseSize, size, QImage::Format_ARGB32_Premultiplied);
ScPainter *p = new ScPainter(&pix, baseSize, size);
p->clear();
FPointArray gly = face.glyphOutline(gl, 1);
if (gly.size() > 4)
{
gly.map(chma);
p->translate(ww / 2, 1);
p->setBrush(Qt::black);
p->setFillMode(1);
p->setupPolygon(&gly);
p->fillPath();
p->end();
}
delete p;
return QVariant(QPixmap::fromImage(pix));
}
// trash
return QVariant();
}
double getCurveYValue(FPointArray &curve, double x, bool linear)
{
double t;
FPoint p;
FPoint p0,p1,p2,p3;
double c0,c1,c2,c3;
double val = 0.5;
if(curve.size() == 0)
return 0.5;
// First find curve segment
p = curve.point(0);
if(x < p.x())
return p.y();
p = curve.point(curve.size()-1);
if(x >= p.x())
return p.y();
uint cc = 0;
// Find the four control points (two on each side of x)
p = curve.point(0);
while(x >= p.x())
{
cc++;
p = curve.point(cc);
}
if (cc > 1)
{
p0 = curve.point(cc-2);
p1 = curve.point(cc-1);
}
else
p1 = p0 = curve.point(0);
p2 = p;
if (cc < curve.size()-1)
p3 = curve.point(cc+1);
else
p3 = p;
// Calculate the value
if (linear)
{
double mc;
if (p1.x() - p2.x() != 0.0)
mc = (p1.y() - p2.y()) / (p1.x() - p2.x());
else
mc = p2.y() / p2.x();
val = (x - p1.x()) * mc + p1.y();
}
else
{
t = (x - p1.x()) / (p2.x() - p1.x());
c2 = (p2.y() - p0.y()) * (p2.x()-p1.x()) / (p2.x()-p0.x());
c3 = p1.y();
c0 = -2*p2.y() + 2*c3 + c2 + (p3.y() - p1.y()) * (p2.x() - p1.x()) / (p3.x() - p1.x());
c1 = p2.y() - c3 - c2 - c0;
val = ((c0*t + c1)*t + c2)*t + c3;
}
if(val < 0.0)
val = 0.0;
if(val > 1.0)
val = 1.0;
return val;
}
LensDialog::LensDialog(QWidget* parent, ScribusDoc *doc) : QDialog(parent)
{
setupUi(this);
buttonRemove->setEnabled(false);
setModal(true);
buttonZoomOut->setIcon(QIcon(loadIcon("16/zoom-out.png")));
buttonZoomI->setIcon(QIcon(loadIcon("16/zoom-in.png")));
PageItem *currItem;
double gx, gy, gh, gw;
doc->m_Selection->setGroupRect();
doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
uint selectedItemCount = doc->m_Selection->count();
QStack<PageItem*> groupStack;
QStack<QGraphicsPathItem*> groupStack2;
QStack<PageItem*> groupStack3;
groupStack2.push(0);
for (uint i = 0; i < selectedItemCount; ++i)
{
currItem = doc->m_Selection->itemAt(i);
FPointArray path = currItem->PoLine;
QPainterPath pp;
if (currItem->itemType() == PageItem::PolyLine)
pp = path.toQPainterPath(false);
else
pp = path.toQPainterPath(true);
origPath.append(pp);
QGraphicsPathItem* pItem = new QGraphicsPathItem(pp, groupStack2.top());
if (groupStack2.top() == 0)
{
scene.addItem(pItem);
pItem->setPos(currItem->xPos() - gx, currItem->yPos() - gy);
pItem->rotate(currItem->rotation());
}
else
{
PageItem* parent = groupStack3.top();
QMatrix mm;
mm.rotate(-parent->rotation());
mm.translate(-parent->xPos(), -parent->yPos());
pItem->setPos(mm.map(QPointF(currItem->xPos(), currItem->yPos())));
}
pItem->setZValue(i);
origPathItem.append(pItem);
if (((currItem->fillColor() == CommonStrings::None) && (currItem->GrType == 0)) || (currItem->controlsGroup()))
pItem->setBrush(Qt::NoBrush);
else
{
if (currItem->GrType != 0)
{
if (currItem->GrType != 8)
{
QGradient pat;
double x1 = currItem->GrStartX;
double y1 = currItem->GrStartY;
double x2 = currItem->GrEndX;
double y2 = currItem->GrEndY;
switch (currItem->GrType)
{
case 1:
case 2:
case 3:
case 4:
case 6:
pat = QLinearGradient(x1, y1, x2, y2);
break;
case 5:
case 7:
pat = QRadialGradient(x1, y1, sqrt(pow(x2 - x1, 2) + pow(y2 - y1,2)), x1, y1);
break;
}
QList<VColorStop*> colorStops = currItem->fill_gradient.colorStops();
QColor qStopColor;
for( int offset = 0 ; offset < colorStops.count() ; offset++ )
{
qStopColor = colorStops[ offset ]->color;
int h, s, v, sneu, vneu;
int shad = colorStops[offset]->shade;
qStopColor.getHsv(&h, &s, &v);
sneu = s * shad / 100;
vneu = 255 - ((255 - v) * shad / 100);
qStopColor.setHsv(h, sneu, vneu);
qStopColor.setAlphaF(colorStops[offset]->opacity);
pat.setColorAt(colorStops[ offset ]->rampPoint, qStopColor);
}
pItem->setBrush(pat);
}
else if ((currItem->GrType == 8) && (!currItem->pattern().isEmpty()) && (doc->docPatterns.contains(currItem->pattern())))
{
double patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation;
currItem->patternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation);
QMatrix qmatrix;
qmatrix.translate(patternOffsetX, patternOffsetY);
qmatrix.rotate(patternRotation);
qmatrix.scale(patternScaleX / 100.0, patternScaleY / 100.0);
QImage pat = *doc->docPatterns[currItem->pattern()].getPattern();
QBrush brush = QBrush(pat);
brush.setMatrix(qmatrix);
pItem->setBrush(brush);
}
}
else
{
QColor paint = ScColorEngine::getShadeColorProof(doc->PageColors[currItem->fillColor()], doc, currItem->fillShade());
paint.setAlphaF(1.0 - currItem->fillTransparency());
pItem->setBrush(paint);
}
}
if ((currItem->lineColor() == CommonStrings::None) || (currItem->controlsGroup()))
pItem->setPen(Qt::NoPen);
else
{
QColor paint = ScColorEngine::getShadeColorProof(doc->PageColors[currItem->lineColor()], doc, currItem->lineShade());
paint.setAlphaF(1.0 - currItem->lineTransparency());
pItem->setPen(QPen(paint, currItem->lineWidth(), currItem->lineStyle(), currItem->lineEnd(), currItem->lineJoin()));
}
if (currItem->controlsGroup())
{
groupStack.push(currItem->groupsLastItem);
groupStack2.push(pItem);
groupStack3.push(currItem);
pItem->setFlags(QGraphicsItem::ItemClipsChildrenToShape);
}
if (groupStack.count() != 0)
{
while (currItem == groupStack.top())
{
groupStack3.pop();
groupStack2.pop();
groupStack.pop();
if (groupStack.count() == 0)
break;
}
}
}
previewWidget->setRenderHint(QPainter::Antialiasing);
previewWidget->setScene(&scene);
isFirst = true;
addLens();
connect(spinXPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensX(double)));
connect(spinYPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensY(double)));
connect(spinRadius, SIGNAL(valueChanged(double)), this, SLOT(setNewLensRadius(double)));
connect(spinStrength, SIGNAL(valueChanged(double)), this, SLOT(setNewLensStrength(double)));
connect(buttonAdd, SIGNAL(clicked()), this, SLOT(addLens()));
connect(buttonRemove, SIGNAL(clicked()), this, SLOT(removeLens()));
connect(buttonMagnify, SIGNAL(toggled(bool)), this, SLOT(changeLens()));
connect(buttonZoomI, SIGNAL(clicked()), this, SLOT(doZoomIn()));
connect(buttonZoomOut, SIGNAL(clicked()), this, SLOT(doZoomOut()));
connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
connect(&scene, SIGNAL(selectionChanged()), this, SLOT(selectionHasChanged()));
}
void meshPoint::transform(QTransform t)
{
FPointArray gr;
gr.addPoint(gridPoint);
gr.addPoint(controlTop);
gr.addPoint(controlBottom);
gr.addPoint(controlLeft);
gr.addPoint(controlRight);
gr.map(t);
gridPoint = gr.point(0);
controlTop = gr.point(1);
controlBottom = gr.point(2);
controlLeft = gr.point(3);
controlRight = gr.point(4);
}
void PageItem_PolyLine::DrawObj_Item(ScPainter *p, QRectF /*e*/, double /*sc*/)
{
if (!m_Doc->RePos && PoLine.size()>=4)
{
if (!m_Doc->layerOutline(LayerNr))
{
if ((fillColor() != CommonStrings::None) || (GrType != 0))
{
FPointArray cli;
FPoint Start;
bool firstp = true;
for (uint n = 0; n < PoLine.size()-3; n += 4)
{
if (firstp)
{
Start = PoLine.point(n);
firstp = false;
}
if (PoLine.point(n).x() > 900000)
{
cli.addPoint(PoLine.point(n-2));
cli.addPoint(PoLine.point(n-2));
cli.addPoint(Start);
cli.addPoint(Start);
cli.setMarker();
firstp = true;
continue;
}
cli.addPoint(PoLine.point(n));
cli.addPoint(PoLine.point(n+1));
cli.addPoint(PoLine.point(n+2));
cli.addPoint(PoLine.point(n+3));
}
if (cli.size() > 2)
{
FPoint l1 = cli.point(cli.size()-2);
cli.addPoint(l1);
cli.addPoint(l1);
cli.addPoint(Start);
cli.addPoint(Start);
}
p->setupPolygon(&cli);
p->fillPath();
}
p->setupPolygon(&PoLine, false);
if (NamedLStyle.isEmpty())
{
if (lineColor() != CommonStrings::None)
p->strokePath();
}
else
{
multiLine ml = m_Doc->MLineStyles[NamedLStyle];
QColor tmp;
for (int it = ml.size()-1; it > -1; it--)
{
if (ml[it].Color != CommonStrings::None) // && (ml[it].Width != 0))
{
SetQColor(&tmp, ml[it].Color, ml[it].Shade);
p->setPen(tmp, ml[it].Width, static_cast<Qt::PenStyle>(ml[it].Dash), static_cast<Qt::PenCapStyle>(ml[it].LineEnd), static_cast<Qt::PenJoinStyle>(ml[it].LineJoin));
p->strokePath();
}
}
}
}
if (m_startArrowIndex != 0)
{
FPoint Start = PoLine.point(0);
for (uint xx = 1; xx < PoLine.size(); xx += 2)
{
FPoint Vector = 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;
arrowTrans.translate(Start.x(), Start.y());
arrowTrans.rotate(r);
drawArrow(p, arrowTrans, m_startArrowIndex);
break;
}
}
}
if (m_endArrowIndex != 0)
{
FPoint End = PoLine.point(PoLine.size()-2);
for (uint xx = PoLine.size()-1; xx > 0; xx -= 2)
{
FPoint Vector = 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;
arrowTrans.translate(End.x(), End.y());
arrowTrans.rotate(r);
drawArrow(p, arrowTrans, m_endArrowIndex);
break;
}
}
}
}
}
void ShapePlug::parseGroup(QDomNode &DOC)
{
QString tmp = "";
QString FillCol = "White";
QString StrokeCol = "Black";
QString defFillCol = "White";
QString defStrokeCol = "Black";
QColor stroke = Qt::black;
QColor fill = Qt::white;
// Qt::PenStyle Dash = Qt::SolidLine;
Qt::PenCapStyle LineEnd = Qt::FlatCap;
Qt::PenJoinStyle LineJoin = Qt::MiterJoin;
// int fillStyle = 1;
double strokewidth = 0.1;
// bool poly = false;
while(!DOC.isNull())
{
double x1, y1, x2, y2;
StrokeCol = defStrokeCol;
FillCol = defFillCol;
stroke = Qt::black;
fill = Qt::white;
// fillStyle = 1;
strokewidth = 1.0;
// Dash = Qt::SolidLine;
LineEnd = Qt::FlatCap;
LineJoin = Qt::MiterJoin;
FPointArray PoLine;
PoLine.resize(0);
QDomElement pg = DOC.toElement();
QString STag = pg.tagName();
QString style = pg.attribute( "style", "" ).simplified();
if (style.isEmpty())
style = pg.attribute( "svg:style", "" ).simplified();
QStringList substyles = style.split(';', QString::SkipEmptyParts);
for( QStringList::Iterator it = substyles.begin(); it != substyles.end(); ++it )
{
QStringList substyle = (*it).split(':', QString::SkipEmptyParts);
QString command(substyle[0].trimmed());
QString params(substyle[1].trimmed());
if (command == "fill")
{
if (!((params == "foreground") || (params == "background") || (params == "fg") || (params == "bg") || (params == "none") || (params == "default") || (params == "inverse")))
{
if (params == "nofill")
FillCol = CommonStrings::None;
else
{
fill.setNamedColor( params );
FillCol = "FromDia"+fill.name();
ScColor tmp;
tmp.fromQColor(fill);
tmp.setSpotColor(false);
tmp.setRegistrationColor(false);
QString fNam = m_Doc->PageColors.tryAddColor(FillCol, tmp);
if (fNam == FillCol)
importedColors.append(FillCol);
FillCol = fNam;
}
}
}
else if (command == "stroke")
{
if (!((params == "foreground") || (params == "background") || (params == "fg") || (params == "bg") || (params == "none") || (params == "default")) || (params == "inverse"))
{
stroke.setNamedColor( params );
StrokeCol = "FromDia"+stroke.name();
ScColor tmp;
tmp.fromQColor(stroke);
tmp.setSpotColor(false);
tmp.setRegistrationColor(false);
QString fNam = m_Doc->PageColors.tryAddColor(StrokeCol, tmp);
if (fNam == StrokeCol)
importedColors.append(StrokeCol);
StrokeCol = fNam;
}
}
else if (command == "stroke-width")
strokewidth = ScCLocale::toDoubleC(params);
else if( command == "stroke-linejoin" )
{
if( params == "miter" )
LineJoin = Qt::MiterJoin;
else if( params == "round" )
LineJoin = Qt::RoundJoin;
else if( params == "bevel" )
LineJoin = Qt::BevelJoin;
}
else if( command == "stroke-linecap" )
{
if( params == "butt" )
LineEnd = Qt::FlatCap;
else if( params == "round" )
LineEnd = Qt::RoundCap;
else if( params == "square" )
LineEnd = Qt::SquareCap;
}
}
if (STag == "svg:line")
{
x1 = ScCLocale::toDoubleC(pg.attribute("x1")) * Conversion;
y1 = ScCLocale::toDoubleC(pg.attribute("y1")) * Conversion;
x2 = ScCLocale::toDoubleC(pg.attribute("x2")) * Conversion;
y2 = ScCLocale::toDoubleC(pg.attribute("y2")) * Conversion;
PoLine.addPoint(x1, y1);
PoLine.addPoint(x1, y1);
PoLine.addPoint(x2, y2);
PoLine.addPoint(x2, y2);
int z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, strokewidth, CommonStrings::None, StrokeCol);
m_Doc->Items->at(z)->PoLine = PoLine.copy();
finishItem(m_Doc->Items->at(z));
}
else if (STag == "svg:rect")
{
x1 = ScCLocale::toDoubleC(pg.attribute("x")) * Conversion;
y1 = ScCLocale::toDoubleC(pg.attribute("y")) * Conversion;
x2 = ScCLocale::toDoubleC(pg.attribute("width")) * Conversion;
y2 = ScCLocale::toDoubleC(pg.attribute("height")) * Conversion;
int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, baseX + x1, baseY + y1, x2, y2, strokewidth, FillCol, StrokeCol);
m_Doc->Items->at(z)->setLineJoin(LineJoin);
m_Doc->Items->at(z)->setLineEnd(LineEnd);
finishItem(m_Doc->Items->at(z));
}
else if ((STag == "svg:polygon") || (STag == "svg:polyline"))
{
bool bFirst = true;
double x = 0.0;
double y = 0.0;
QString points = pg.attribute( "points" ).simplified().replace(',', " ");
QStringList pointList = points.split(' ', QString::SkipEmptyParts);
FirstM = true;
for( QStringList::Iterator it = pointList.begin(); it != pointList.end(); it++ )
{
x = ScCLocale::toDoubleC(*(it++));
y = ScCLocale::toDoubleC(*it);
if( bFirst )
{
svgMoveTo(x * Conversion, y * Conversion);
bFirst = false;
WasM = true;
}
else
{
svgLineTo(&PoLine, x * Conversion, y * Conversion);
}
}
if (STag == "svg:polygon")
svgClosePath(&PoLine);
if (PoLine.size() < 4)
{
DOC = DOC.nextSibling();
continue;
}
int z;
if (STag == "svg:polygon")
z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, strokewidth, FillCol, StrokeCol);
else
z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, strokewidth, CommonStrings::None, StrokeCol);
m_Doc->Items->at(z)->PoLine = PoLine.copy();
finishItem(m_Doc->Items->at(z));
}
else if ((STag == "svg:circle") || (STag == "svg:ellipse"))
{
x1 = ScCLocale::toDoubleC(pg.attribute("r")) * Conversion;
y1 = ScCLocale::toDoubleC(pg.attribute("r")) * Conversion;
x2 = ScCLocale::toDoubleC(pg.attribute("cx")) * Conversion - x1;
y2 = ScCLocale::toDoubleC(pg.attribute("cy")) * Conversion - y1;
x1 *= 2.0;
y1 *= 2.0;
int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Ellipse, baseX + x1, baseY + y1, x2, y2, strokewidth, FillCol, StrokeCol);
m_Doc->Items->at(z)->setLineJoin(LineJoin);
m_Doc->Items->at(z)->setLineEnd(LineEnd);
finishItem(m_Doc->Items->at(z));
}
else if (STag == "svg:path")
{
// poly =
parseSVG( pg.attribute( "d" ), &PoLine );
if (PoLine.size() < 4)
{
DOC = DOC.nextSibling();
continue;
}
int z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, strokewidth, FillCol, StrokeCol);
m_Doc->Items->at(z)->PoLine = PoLine.copy();
finishItem(m_Doc->Items->at(z));
}
else if (STag == "svg:g")
{
int z = m_Doc->itemAdd(PageItem::Group, PageItem::Rectangle, baseX, baseX, 1, 1, 0, CommonStrings::None, CommonStrings::None);
PageItem *neu = m_Doc->Items->at(z);
Elements.append(neu);
if (groupStack.count() > 0)
groupStack.top().append(neu);
QList<PageItem*> gElements;
groupStack.push(gElements);
QDomNode child = DOC.firstChild();
parseGroup(child);
if (gElements.count() == 0)
{
groupStack.pop();
Elements.removeAll(neu);
groupStack.top().removeAll(neu);
Selection tmpSelection(m_Doc, false);
tmpSelection.addItem(neu);
m_Doc->itemSelection_DeleteItem(&tmpSelection);
}
else
{
QList<PageItem*> gElem = groupStack.pop();
double minx = std::numeric_limits<double>::max();
double miny = std::numeric_limits<double>::max();
double maxx = -std::numeric_limits<double>::max();
double maxy = -std::numeric_limits<double>::max();
for (int gr = 0; gr < gElements.count(); ++gr)
{
PageItem* currItem = gElem.at(gr);
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;
neu->setXYPos(gx, gy, true);
neu->setWidthHeight(gw, gh, true);
neu->SetRectFrame();
neu->Clip = FlattenPath(neu->PoLine, neu->Segments);
neu->setItemName( tr("Group%1").arg(m_Doc->GroupCounter));
neu->AutoName = false;
neu->gXpos = neu->xPos() - gx;
neu->gYpos = neu->yPos() - gy;
neu->groupWidth = gw;
neu->groupHeight = gh;
for (int gr = 0; gr < gElem.count(); ++gr)
{
PageItem* currItem = gElem.at(gr);
currItem->gXpos = currItem->xPos() - gx;
currItem->gYpos = currItem->yPos() - gy;
currItem->gWidth = gw;
currItem->gHeight = gh;
currItem->Parent = neu;
neu->groupItemList.append(currItem);
m_Doc->Items->removeAll(currItem);
Elements.removeAll(currItem);
}
neu->setRedrawBounding();
neu->setTextFlowMode(PageItem::TextFlowDisabled);
m_Doc->GroupCounter++;
}
}
DOC = DOC.nextSibling();
}
}
void ScreenPainter::drawGlyph(const GlyphLayout gl)
{
bool showControls = (m_item->doc()->guidesPrefs().showControls) &&
(gl.glyph == font().char2CMap(QChar(' ')) || gl.glyph >= ScFace::CONTROL_GLYPHS);
#if CAIRO_HAS_FC_FONT
if (m_painter->fillMode() == 1 && m_painter->maskMode() <= 0 && !showControls)
{
m_painter->save();
setupState(false);
cairo_t* cr = m_painter->context();
double r, g, b;
m_painter->brush().getRgbF(&r, &g, &b);
cairo_set_source_rgba(cr, r, g, b, m_painter->brushOpacity());
m_painter->setRasterOp(m_painter->blendModeFill());
if (m_fontPath != font().fontFilePath() || m_faceIndex != font().faceIndex() || m_cairoFace == NULL)
{
m_fontPath = font().fontFilePath();
m_faceIndex = font().faceIndex();
// A very ugly hack as we can’t use the font().ftFace() because
// Scribus liberally calls FT_Set_CharSize() with all sorts of
// crazy values, breaking any subsequent call to the layout
// painter. FIXME: drop the FontConfig dependency here once
// Scribus font handling code is made sane!
FcPattern *pattern = FcPatternBuild(NULL,
FC_FILE, FcTypeString, QFile::encodeName(font().fontFilePath()).data(),
FC_INDEX, FcTypeInteger, font().faceIndex(),
NULL);
m_cairoFace = cairo_ft_font_face_create_for_pattern(pattern);
FcPatternDestroy(pattern);
}
cairo_set_font_face(cr, m_cairoFace);
cairo_set_font_size(cr, fontSize());
cairo_scale(cr, gl.scaleH, gl.scaleV);
cairo_glyph_t glyph = { gl.glyph, 0, 0 };
cairo_show_glyphs(cr, &glyph, 1);
m_painter->restore();
return;
}
#endif
m_painter->save();
setupState(false);
bool fr = m_painter->fillRule();
m_painter->setFillRule(false);
uint gid = gl.glyph;
if (showControls)
{
bool stroke = false;
if (gid >= ScFace::CONTROL_GLYPHS)
gid -= ScFace::CONTROL_GLYPHS;
else
gid = 32;
QTransform chma, chma4;
FPointArray outline;
if (gid == SpecialChars::TAB.unicode())
{
outline = m_item->doc()->symTab.copy();
chma4.translate(gl.xadvance - fontSize() * gl.scaleH * 0.7, -fontSize() * gl.scaleV * 0.5);
}
else if (gid == SpecialChars::COLBREAK.unicode())
{
outline = m_item->doc()->symNewCol.copy();
chma4.translate(0, -fontSize() * gl.scaleV * 0.6);
}
else if (gid == SpecialChars::FRAMEBREAK.unicode())
{
outline = m_item->doc()->symNewFrame.copy();
chma4.translate(0, -fontSize() * gl.scaleV * 0.6);
}
else if (gid == SpecialChars::PARSEP.unicode())
{
outline = m_item->doc()->symReturn.copy();
chma4.translate(0, -fontSize() * gl.scaleV * 0.8);
}
else if (gid == SpecialChars::LINEBREAK.unicode())
{
outline = m_item->doc()->symNewLine.copy();
chma4.translate(0, -fontSize() * gl.scaleV * 0.4);
}
else if (gid == SpecialChars::NBSPACE.unicode() || gid == 32)
{
stroke = (gid == 32);
outline = m_item->doc()->symNonBreak.copy();
chma4.translate(0, -fontSize() * gl.scaleV * 0.4);
}
else if (gid == SpecialChars::NBHYPHEN.unicode())
{
outline = font().glyphOutline(font().char2CMap(QChar('-')), fontSize());
chma4.translate(0, -fontSize() * gl.scaleV);
}
else if (gid == SpecialChars::SHYPHEN.unicode())
{
outline.resize(0);
outline.addQuadPoint(0, -10, 0, -10, 0, -6, 0, -6);
stroke = true;
}
else if (gid == SpecialChars::OBJECT.unicode())
{
//for showing marks entries as control chars
outline.resize(0);
outline.addQuadPoint(0, -8, 1, -8, 0, -6, 1, -6);
stroke = true;
}
else // ???
{
outline.resize(0);
outline.addQuadPoint(0, -10, 0, -10, 0, -9, 0, -9);
outline.addQuadPoint(0, -9, 0, -9, 1, -9, 1, -9);
outline.addQuadPoint(1, -9, 1, -9, 1, -10, 1, -10);
outline.addQuadPoint(1, -10, 1, -10, 0, -10, 0, -10);
}
chma.scale(gl.scaleH * fontSize() / 10.0, gl.scaleV * fontSize() / 10.0);
outline.map(chma * chma4);
m_painter->setupPolygon(&outline, true);
QColor oldBrush = m_painter->brush();
// FIXME
/* p->setBrush( (flags & ScLayout_SuppressSpace) ? Qt::green
: PrefsManager::instance()->appPrefs.displayPrefs.controlCharColor);*/
m_painter->setBrush(PrefsManager::instance()->appPrefs.displayPrefs.controlCharColor);
if (stroke)
{
QColor tmp = m_painter->pen();
m_painter->setStrokeMode(1);
m_painter->setPen(m_painter->brush(), 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
m_painter->setLineWidth(fontSize() * gl.scaleV / 20.0);
m_painter->strokePath();
m_painter->setPen(tmp, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
}
else
{
m_painter->setFillMode(1);
m_painter->fillPath();
}
m_painter->setBrush(oldBrush);
}
else
{
m_painter->translate(0, -(fontSize() * gl.scaleV));
double scaleH = gl.scaleH * fontSize() / 10.0;
double scaleV = gl.scaleV * fontSize() / 10.0;
m_painter->scale(scaleH, scaleV);
FPointArray outline = font().glyphOutline(gid);
m_painter->setupPolygon(&outline, true);
if (outline.size() > 3)
m_painter->fillPath();
}
m_painter->setFillRule(fr);
m_painter->restore();
}
void CanvasMode_EditPolygon::mouseMoveEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m->accept();
double newX = mousePointDoc.x();
double newY = mousePointDoc.y();
if (m_canvas->m_viewMode.m_MouseButtonPressed && m_view->moveTimerElapsed())
{
PageItem *currItem = m_doc->m_Selection->itemAt(0);
QTransform itemMatrix = currItem->getTransform();
QPointF cPoint = itemMatrix.map(centerPoint);
QLineF stLinA = QLineF(cPoint, QPointF(newX, newY));
uint cx = polyUseFactor ? polyCorners * 2 : polyCorners;
double seg = 360.0 / cx;
double trueLength = sqrt(pow(sin(seg / 180.0 * M_PI) * (currItem->width() / 2.0), 2) + pow(cos(seg / 180.0 * M_PI) * (currItem->height() / 2.0) + (currItem->height()/2.0) - currItem->height(), 2));
if (m_polygonPoint == useControlInner)
{
polyInnerRot = stLinA.angle() - 90 - polyRotation - seg;
double factor = stLinA.length() / sqrt(pow(sin(stLinA.angle() * M_PI / 180.0) * currItem->height() / 2.0, 2) + pow(cos(stLinA.angle() * M_PI / 180.0) * currItem->width() / 2.0, 2));
int maxF = qRound(getUserValFromFactor(factor));
if (maxF <= 100)
polyFactor = factor;
}
if (m_polygonPoint == useControlOuter)
{
polyRotation = stLinA.angle() - 90;
if (polyRotation < -180)
polyRotation += 360;
if (polyRotation > 180)
polyRotation -= 360;
}
if (m_polygonPoint == useControlInnerCurve)
{
QPointF ePoint = itemMatrix.map(endPoint);
QLineF stLinC = QLineF(ePoint, QPointF(newX, newY));
polyCurvature = stLinC.length() / trueLength;
}
if (m_polygonPoint == useControlOuterCurve)
{
QPointF sPoint = itemMatrix.map(startPoint);
QPointF sPoint2 = itemMatrix.map(currItem->PoLine.pointQF(6));
QLineF stLinCo = QLineF(sPoint, QPointF(newX, newY));
QLineF stLinCo2 = QLineF(sPoint, sPoint2);
polyOuterCurvature = stLinCo.length() / stLinCo2.length();
}
QPainterPath path = RegularPolygonPath(currItem->width(), currItem->height(), polyCorners, polyUseFactor, polyFactor, polyRotation, polyCurvature, polyInnerRot, polyOuterCurvature);
FPointArray ar;
ar.fromQPainterPath(path);
endPoint = ar.pointQF(2);
startPoint = ar.pointQF(0);
QLineF innerLine = QLineF(endPoint, centerPoint);
innerLine.setAngle(innerLine.angle() + 90);
innerLine.setLength(trueLength * polyCurvature);
innerCPoint = innerLine.p2();
QLineF outerLine = QLineF(startPoint, ar.pointQF(6));
outerLine.setLength(outerLine.length() * polyOuterCurvature);
outerCPoint = outerLine.p2();
VectorDialog->setValues(polyCorners, polyFactor, polyUseFactor, polyRotation, polyCurvature, polyInnerRot, polyOuterCurvature);
blockUpdateFromItem(true);
currItem->update();
blockUpdateFromItem(false);
path = itemMatrix.map(path);
m_doc->regionsChanged()->update(path.boundingRect().adjusted(-5, -5, 10, 10));
}
Mxp = newX;
Myp = newY;
}
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;
}
void CanvasMode_EditArc::mouseMoveEvent(QMouseEvent *m)
{
const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
m->accept();
double newX = mousePointDoc.x();
double newY = mousePointDoc.y();
if (m_canvas->m_viewMode.m_MouseButtonPressed && m_view->moveTimerElapsed())
{
PageItem *currItem = m_doc->m_Selection->itemAt(0);
QTransform itemMatrix;
itemMatrix.translate(currItem->xPos(), currItem->yPos());
itemMatrix.rotate(currItem->rotation());
QPointF sPoint = currItem->PoLine.pointQF(0);
QPointF smPoint = itemMatrix.map(sPoint);
QLineF stLinA = QLineF(smPoint, QPointF(Mxp, Myp));
QLineF stLinM = QLineF(smPoint, QPointF(newX, newY));
double deltaAngle = stLinM.angle() - stLinA.angle();
QPainterPath pp;
if (m_arcPoint == useControlStart)
startAngle += deltaAngle;
else if (m_arcPoint == useControlSweep)
endAngle += deltaAngle;
else if (m_arcPoint == useControlHeight)
heightPoint = QPointF(heightPoint.x(), heightPoint.y() + (newY - Myp));
else if (m_arcPoint == useControlWidth)
widthPoint = QPointF(widthPoint.x() + (newX - Mxp), widthPoint.y());
double nSweep = endAngle - startAngle;
if (nSweep < 0)
nSweep += 360;
double nWidth = sPoint.x() - widthPoint.x();
double nHeight = sPoint.y() - heightPoint.y();
pp.moveTo(sPoint);
pp.arcTo(QRectF(sPoint.x() - nWidth, sPoint.y() - nHeight, nWidth * 2, nHeight * 2), startAngle, nSweep);
pp.closeSubpath();
FPointArray ar;
ar.fromQPainterPath(pp);
if (m_arcPoint == useControlStart)
{
startPoint = ar.pointQF(2);
QLineF stLinA = QLineF(smPoint, itemMatrix.map(startPoint));
m_canvas->displayRotHUD(m->globalPos(), 360.0 - stLinA.angle());
}
else if (m_arcPoint == useControlSweep)
{
endPoint = ar.pointQF(ar.size() - 4);
QLineF stLinA = QLineF(smPoint, itemMatrix.map(endPoint));
m_canvas->displayRotHUD(m->globalPos(), 360.0 - stLinA.angle());
}
QLineF res = QLineF(centerPoint, startPoint);
QLineF swe = QLineF(centerPoint, endPoint);
VectorDialog->setValues(res.angle(), swe.angle(), nHeight * 2, nWidth * 2);
blockUpdateFromItem(true);
currItem->update();
blockUpdateFromItem(false);
QRectF upRect;
upRect = QRectF(QPointF(0, 0), QPointF(currItem->width(), currItem->height())).normalized();
upRect.translate(currItem->xPos(), currItem->yPos());
m_doc->regionsChanged()->update(upRect.adjusted(-10.0 - currItem->width() / 2.0, -10.0 - currItem->height() / 2.0, 10.0 + currItem->width() / 2.0, 10.0 + currItem->height() / 2.0));
}
Mxp = newX;
Myp = newY;
}
void CreateMode::drawControls(QPainter* p)
{
if (!inItemCreation) return;
QPointF topLeft(createObjectPos.x(), createObjectPos.y());
QPointF btRight(canvasCurrCoord.x(), canvasCurrCoord.y());
QColor drawColor = qApp->palette().color(QPalette::Active, QPalette::Highlight);
if (createObjectMode != modeDrawLine)
{
QRectF bounds = QRectF(topLeft, btRight).normalized();
//Lock Height to Width for Control Modifier for region drawing
if (modifiers==Qt::ControlModifier)
{
bounds.setHeight(bounds.width());
if (btRight.y()<topLeft.y())
bounds.moveBottom(topLeft.y());
if (btRight.x()<topLeft.x() && btRight.y()>topLeft.y())
bounds.moveTop(topLeft.y());
}
QRect localRect = m_canvas->canvasToLocal(bounds);
if (localRect.width() <= 0 || localRect.height() <= 0)
return;
p->setRenderHint(QPainter::Antialiasing);
p->save();
p->setPen(QPen(drawColor, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
drawColor.setAlpha(64);
p->setBrush(drawColor);
p->drawRect(localRect);
drawColor.setAlpha(255);
p->setBrush(Qt::NoBrush);
p->setPen(QPen(drawColor, 1, Qt::DashLine, Qt::FlatCap, Qt::MiterJoin));
int frameType = 0, itemType = 0;
getFrameItemTypes(itemType, frameType);
if (frameType == PageItem::Ellipse)
{
p->drawEllipse(localRect);
}
else if (createObjectMode == modeDrawArc)
{
QPainterPath path;
path.moveTo(localRect.width() / 2.0, localRect.height() / 2.0);
path.arcTo(0.0, 0.0, localRect.width(), localRect.height(), m_doc->itemToolPrefs().arcStartAngle, m_doc->itemToolPrefs().arcSweepAngle);
path.closeSubpath();
p->translate(localRect.left(), localRect.top());
p->drawPath(path);
}
else if (createObjectMode == modeDrawRegularPolygon)
{
QPainterPath path = RegularPolygonPath(localRect.width(), localRect.height(), m_doc->itemToolPrefs().polyCorners, m_doc->itemToolPrefs().polyUseFactor, m_doc->itemToolPrefs().polyFactor, m_doc->itemToolPrefs().polyRotation, m_doc->itemToolPrefs().polyCurvature, m_doc->itemToolPrefs().polyInnerRot, m_doc->itemToolPrefs().polyOuterCurvature);
p->translate(localRect.left(), localRect.top());
p->drawPath(path);
}
else if (createObjectMode == modeDrawSpiral)
{
QPainterPath path = SpiralPath(localRect.width(), localRect.height(), m_doc->itemToolPrefs().spiralStartAngle, m_doc->itemToolPrefs().spiralEndAngle, m_doc->itemToolPrefs().spiralFactor);
p->translate(localRect.left(), localRect.top());
p->drawPath(path);
}
else if ((createObjectMode == modeDrawShapes) && (createObjectSubMode > 1))
{
FPointArray poly;
int valCount = m_doc->ValCount;
double *vals = m_doc->ShapeValues;
for (int a = 0; a < valCount-3; a += 4)
{
if (vals[a] < 0)
{
poly.setMarker();
continue;
}
double x1 = localRect.width() * vals[a] / 100.0;
double y1 = localRect.height() * vals[a+1] / 100.0;
double x2 = localRect.width() * vals[a+2] / 100.0;
double y2 = localRect.height() * vals[a+3] / 100.0;
poly.addPoint(x1, y1);
poly.addPoint(x2, y2);
}
QPainterPath path = poly.toQPainterPath(false);
p->translate(localRect.left(), localRect.top());
p->drawPath(path);
}
p->restore();
}
else
{
QPoint p1 = m_canvas->canvasToLocal(topLeft);
QPoint p2 = m_canvas->canvasToLocal(btRight);
p->save();
p->setPen(QPen(drawColor, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
p->setBrush(drawColor);
p->drawLine(p1, p2);
p->restore();
}
}
void XfigPlug::processArrows(int forward_arrow, QString fArrowData, int backward_arrow, QString bArrowData, int depth, PageItem *ite)
{
int arrow_typeAF; // (enumeration type)
int arrow_styleAF; // (enumeration type)
float arrow_thicknessAF; // (1/80 inch)
float arrow_widthAF; // (Fig units)
float arrow_heightAF; // (Fig units)
int arrow_typeAB; // (enumeration type)
int arrow_styleAB; // (enumeration type)
float arrow_thicknessAB; // (1/80 inch)
float arrow_widthAB; // (Fig units)
float arrow_heightAB; // (Fig units)
FPointArray arrow;
int z = -1;
PageItem::ItemType iteType;
if (forward_arrow == 1)
{
arrow.resize(0);
ScTextStream CodeAF(&fArrowData, QIODevice::ReadOnly);
CodeAF >> arrow_typeAF >> arrow_styleAF >> arrow_thicknessAF >> arrow_widthAF >> arrow_heightAF;
arrow_widthAF = fig2Pts(arrow_widthAF);
arrow_heightAF = fig2Pts(arrow_heightAF);
arrow_thicknessAF = arrow_thicknessAF / 80.0 * 72.0;
FPoint End = ite->PoLine.point(ite->PoLine.size()-2);
for (uint xx = ite->PoLine.size()-1; xx > 0; xx -= 2)
{
FPoint Vector = ite->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);
QTransform arrowTrans;
if (arrow_typeAF == 0)
arrow.parseSVG("M -1, -0.5 L 0, 0 L -1, 0.5");
else if (arrow_typeAF == 1)
arrow.parseSVG("M -1, -0.5 L 0, 0 L -1, 0.5 z");
else if (arrow_typeAF == 2)
arrow.parseSVG("M -1, -0.5 L 0, 0 L -1, 0.5 L -0.7 0 z");
else if (arrow_typeAF == 3)
arrow.parseSVG("M -0.7, -0.5 L 0, 0 L -0.7, 0.5 L -1 0 z");
arrowTrans.translate(End.x(), End.y());
arrowTrans.rotate(r);
arrowTrans.scale(arrow_heightAF, arrow_widthAF);
arrow.map(arrowTrans);
break;
}
}
QString fillC = "White";
if (arrow_styleAF == 1)
fillC = CurrColorStroke;
if (arrow_typeAF == 0)
{
fillC = CommonStrings::None;
iteType = PageItem::PolyLine;
}
else
iteType = PageItem::Polygon;
z = m_Doc->itemAdd(iteType, PageItem::Unspecified, ite->xPos(), ite->yPos(), 10, 10, arrow_thicknessAF, fillC, CurrColorStroke);
if (z >= 0)
{
PageItem *item = m_Doc->Items->at(z);
item->PoLine = arrow.copy();
item->ClipEdited = true;
item->FrameType = 3;
item->setFillShade(CurrFillShade);
item->setLineShade(CurrStrokeShade);
FPoint wh = getMaxClipF(&item->PoLine);
item->setWidthHeight(wh.x(),wh.y());
item->setTextFlowMode(PageItem::TextFlowDisabled);
m_Doc->adjustItemSize(item);
item->setWidthHeight(qMax(item->width(), 1.0), qMax(item->height(), 1.0));
depthMap.insert(999 - depth, currentItemNr);
currentItemNr++;
}
}
void ShapePlug::parseGroupProperties(QDomNode &DOC, double &minXCoor, double &minYCoor, double &maxXCoor, double &maxYCoor, bool &firstCheck)
{
QString FillCol = "White";
QString StrokeCol = "Black";
while(!DOC.isNull())
{
double x1, y1, x2, y2;
FPointArray PoLine;
PoLine.resize(0);
QDomElement pg = DOC.toElement();
QString STag = pg.tagName();
if (STag == "svg:line")
{
x1 = ScCLocale::toDoubleC(pg.attribute("x1")) * Conversion;
y1 = ScCLocale::toDoubleC(pg.attribute("y1")) * Conversion;
x2 = ScCLocale::toDoubleC(pg.attribute("x2")) * Conversion;
y2 = ScCLocale::toDoubleC(pg.attribute("y2")) * Conversion;
PoLine.addPoint(x1, y1);
PoLine.addPoint(x1, y1);
PoLine.addPoint(x2, y2);
PoLine.addPoint(x2, y2);
}
else if (STag == "svg:rect")
{
x1 = ScCLocale::toDoubleC(pg.attribute("x")) * Conversion;
y1 = ScCLocale::toDoubleC(pg.attribute("y")) * Conversion;
x2 = ScCLocale::toDoubleC(pg.attribute("width")) * Conversion;
y2 = ScCLocale::toDoubleC(pg.attribute("height")) * Conversion;
static double rect[] = {0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0,
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0,
0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0
};
for (int a = 0; a < 29; a += 4)
{
double xa = x2 * rect[a];
double ya = y2 * rect[a+1];
double xb = x2 * rect[a+2];
double yb = y2 * rect[a+3];
PoLine.addPoint(x1+xa, y1+ya);
PoLine.addPoint(x1+xb, y1+yb);
}
}
else if ((STag == "svg:polygon") || (STag == "svg:polyline"))
{
bool bFirst = true;
double x = 0.0;
double y = 0.0;
QString points = pg.attribute( "points" ).simplified().replace(',', " ");
QStringList pointList = points.split(' ', QString::SkipEmptyParts);
FirstM = true;
for( QStringList::Iterator it1 = pointList.begin(); it1 != pointList.end(); it1++ )
{
x = ScCLocale::toDoubleC(*(it1++));
y = ScCLocale::toDoubleC(*it1);
if( bFirst )
{
svgMoveTo(x * Conversion, y * Conversion);
bFirst = false;
WasM = true;
}
else
{
svgLineTo(&PoLine, x * Conversion, y * Conversion);
}
}
if (STag == "svg:polygon")
svgClosePath(&PoLine);
if (PoLine.size() < 4)
{
DOC = DOC.nextSibling();
continue;
}
}
else if (STag == "svg:circle")
{
x1 = ScCLocale::toDoubleC(pg.attribute("r")) * Conversion;
y1 = ScCLocale::toDoubleC(pg.attribute("r")) * Conversion;
x2 = ScCLocale::toDoubleC(pg.attribute("cx")) * Conversion - x1;
y2 = ScCLocale::toDoubleC(pg.attribute("cy")) * Conversion - y1;
x1 *= 2.0;
y1 *= 2.0;
static double rect[] = {1.0, 0.5, 1.0, 0.77615235,0.5, 1.0, 0.77615235, 1.0,
0.5, 1.0, 0.22385765, 1.0, 0.0, 0.5, 0.0, 0.77615235,
0.0, 0.5, 0.0, 0.22385765, 0.5, 0.0, 0.22385765, 0.0,
0.5, 0.0, 0.77615235, 0.0, 1.0, 0.5, 1.0, 0.22385765
};
for (int a = 0; a < 29; a += 4)
{
double xa = x1 * rect[a];
double ya = y1 * rect[a+1];
double xb = x1 * rect[a+2];
double yb = y1 * rect[a+3];
PoLine.addPoint(x2+xa, y2+ya);
PoLine.addPoint(x2+xb, y2+yb);
}
}
else if (STag == "svg:ellipse")
{
x1 = ScCLocale::toDoubleC(pg.attribute("rx")) * Conversion;
y1 = ScCLocale::toDoubleC(pg.attribute("ry")) * Conversion;
x2 = ScCLocale::toDoubleC(pg.attribute("cx")) * Conversion - x1;
y2 = ScCLocale::toDoubleC(pg.attribute("cy")) * Conversion - y1;
x1 *= 2.0;
y1 *= 2.0;
static double rect[] = {1.0, 0.5, 1.0, 0.77615235,0.5, 1.0, 0.77615235, 1.0,
0.5, 1.0, 0.22385765, 1.0, 0.0, 0.5, 0.0, 0.77615235,
0.0, 0.5, 0.0, 0.22385765, 0.5, 0.0, 0.22385765, 0.0,
0.5, 0.0, 0.77615235, 0.0, 1.0, 0.5, 1.0, 0.22385765
};
for (int a = 0; a < 29; a += 4)
{
double xa = x1 * rect[a];
double ya = y1 * rect[a+1];
double xb = x1 * rect[a+2];
double yb = y1 * rect[a+3];
PoLine.addPoint(x2+xa, y2+ya);
PoLine.addPoint(x2+xb, y2+yb);
}
}
else if (STag == "svg:path")
{
parseSVG( pg.attribute( "d" ), &PoLine );
if (PoLine.size() < 4)
{
DOC = DOC.nextSibling();
continue;
}
}
else if (STag == "svg:g")
{
QDomNode child = DOC.firstChild();
parseGroupProperties(child, minXCoor, minYCoor, maxXCoor, maxYCoor, firstCheck);
}
if (PoLine.size() < 4)
{
DOC = DOC.nextSibling();
continue;
}
FPoint tp2(getMinClipF(&PoLine));
PoLine.translate(-tp2.x(), -tp2.y());
FPoint wh(getMaxClipF(&PoLine));
if (firstCheck)
{
minXCoor = tp2.x();
minYCoor = tp2.y();
maxXCoor = tp2.x() + wh.x();
maxYCoor = tp2.y() + wh.y();
firstCheck = false;
}
else
{
minXCoor = qMin(minXCoor, tp2.x());
minYCoor = qMin(minYCoor, tp2.y());
maxXCoor = qMax(maxXCoor, tp2.x() + wh.x());
maxYCoor = qMax(maxYCoor, tp2.y() + wh.y());
}
DOC = DOC.nextSibling();
}
}
