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);
}
}
}
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 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);
}
: 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 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 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 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();
}
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;
}
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 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();
}
}
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 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;
}
}
}
}
}
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;
}
