r17154 by jghali - fix inconsistent line endings in util_math.cpp

scribus-commit scribus-commit at lists.scribus.net
Fri Dec 30 15:32:12 UTC 2011


Author: jghali
Date: Fri Dec 30 15:32:12 2011
New Revision: 17154

URL: http://scribus.net/websvn/listing.php?repname=Scribus&sc=1&rev=17154
Log:
fix inconsistent line endings in util_math.cpp

Modified:
    trunk/Scribus/scribus/util_math.cpp

Modified: trunk/Scribus/scribus/util_math.cpp
URL: http://scribus.net/websvn/diff.php?repname=Scribus&rev=17154&path=/trunk/Scribus/scribus/util_math.cpp
==============================================================================
--- trunk/Scribus/scribus/util_math.cpp (original)
+++ trunk/Scribus/scribus/util_math.cpp Fri Dec 30 15:32:12 2011
@@ -1,531 +1,531 @@
-/*
-For general Scribus (>=1.3.2) copyright and licensing information please refer
-to the COPYING file provided with the program. Following this notice may exist
-a copyright and/or license notice that predates the release of Scribus 1.3.2
-for which a new license (GPL+exception) is in place.
-*/
-/***************************************************************************
-                          util.cpp  -  description
-                             -------------------
-    begin                : Fri Sep 14 2001
-    copyright            : (C) 2001 by Franz Schmid
-    email                : Franz.Schmid at altmuehlnet.de
- ***************************************************************************/
-
-/***************************************************************************
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- ***************************************************************************/
-
-#include <QRegion> 
-#include "util_math.h"
-#include "scconfig.h"
-#include "sclimits.h"
-#include "fpoint.h"
-#include "fpointarray.h"
-
-using namespace std;
-
-uint getDouble(const QByteArray in, bool raw)
-{
-	QByteArray bb(4, ' ');
-	if (raw)
-	{
-		// Qt4
-/*		bb[3] = static_cast<uchar>(QChar(in.at(0)));
-		bb[2] = static_cast<uchar>(QChar(in.at(1)));
-		bb[1] = static_cast<uchar>(QChar(in.at(2)));
-		bb[0] = static_cast<uchar>(QChar(in.at(3)));*/
-		bb[3] = in.at(0);
-		bb[2] = in.at(1);
-		bb[1] = in.at(2);
-		bb[0] = in.at(3);
-	}
-	else
-	{
-		// Qt4
-// 		bb[0] = static_cast<uchar>(QChar(in.at(0)));
-// 		bb[1] = static_cast<uchar>(QChar(in.at(1)));
-// 		bb[2] = static_cast<uchar>(QChar(in.at(2)));
-// 		bb[3] = static_cast<uchar>(QChar(in.at(3)));
-		bb[0] = in.at(0);
-		bb[1] = in.at(1);
-		bb[2] = in.at(2);
-		bb[3] = in.at(3);
-	}
-	uint ret;
-	ret = bb[0] & 0xff;
-	ret |= (bb[1] << 8) & 0xff00;
-	ret |= (bb[2] << 16) & 0xff0000;
-	ret |= (bb[3] << 24) & 0xff000000;
-	return ret;
-}
-
-QPainterPath RegularPolygonPath(double w, double h, uint c, bool star, double factor, double rota, double factor2, double innerRot, double factor3)
-{
-	uint cx = star ? c * 2 : c;
-	double seg = 360.0 / cx;
-	double sc = rota + 180.0;
-	double di = factor;
-	double mx = 0;
-	double my = 0;
-	double trueLength = sqrt(pow(sin(seg / 180.0 * M_PI) * (w / 2.0), 2) + pow(cos(seg / 180.0 * M_PI) * (h / 2.0) + (h/2.0) - h, 2));
-	QPainterPath pts;
-	// calculate corner Points first
-	QList<QPointF> cornerPoints;
-	for (uint x = 0; x < cx; ++x)
-	{
-		sc = seg * x + 180.0 + rota;
-		if (star)
-		{
-			double wf = w / 2.0;
-			double hf = h / 2.0;
-			if (x % 2 != 0)
-			{
-				wf *= di;
-				hf *= di;
-				sc += innerRot;
-			}
-			mx = sin(sc / 180.0 * M_PI) * (wf) + (w/2.0);
-			my = cos(sc / 180.0 * M_PI) * (hf) + (h/2.0);
-		}
-		else
-		{
-			mx = sin(sc / 180.0 * M_PI) * (w/2.0) + (w/2.0);
-			my = cos(sc / 180.0 * M_PI) * (h/2.0) + (h/2.0);
-		}
-		cornerPoints.append(QPointF(mx, my));
-	}
-	// now calculate bezier control points if needed;
-	if (star)
-	{
-		pts.moveTo(cornerPoints[0]);
-		double mxc1, myc1, mxc2, myc2;
-		for (int a = 0; a < cornerPoints.count() - 2; a++)
-		{
-			sc = seg * a + 180.0 + rota;
-			if (a % 2 != 0)
-			{
-				// outer control point
-				QLineF oline = QLineF(cornerPoints[a+1], cornerPoints[a-1]);
-				mxc1 = oline.pointAt(factor3).x();
-				myc1 = oline.pointAt(factor3).y();
-				// inner control point
-				mxc2 = sin((sc + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[a].x();
-				myc2 = cos((sc + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[a].y();
-				pts.cubicTo(QPointF(mxc2, myc2), QPointF(mxc1, myc1), cornerPoints[a+1]);
-			}
-			else
-			{
-				// outer control point
-				QLineF oline = QLineF(cornerPoints[a], cornerPoints[a+2]);
-				mxc1 = oline.pointAt(factor3).x();
-				myc1 = oline.pointAt(factor3).y();
-				// inner control point
-				mxc2 = sin((sc - 90.0 + seg) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[a+1].x();
-				myc2 = cos((sc - 90.0 + seg) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[a+1].y();
-				pts.cubicTo(QPointF(mxc1, myc1), QPointF(mxc2, myc2), cornerPoints[a+1]);
-			}
-		}
-		// outer control point
-		QLineF oline = QLineF(cornerPoints[cornerPoints.count()-2], cornerPoints[0]);
-		mxc1 = oline.pointAt(factor3).x();
-		myc1 = oline.pointAt(factor3).y();
-		// inner control point
-		sc = seg * (cornerPoints.count()-1) + 180.0 + rota;
-		mxc2 = sin((sc - 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[cornerPoints.count()-1].x();
-		myc2 = cos((sc - 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[cornerPoints.count()-1].y();
-		pts.cubicTo(QPointF(mxc1, myc1), QPointF(mxc2, myc2), cornerPoints[cornerPoints.count()-1]);
-		oline = QLineF(cornerPoints[0], cornerPoints[cornerPoints.count()-2]);
-		mxc1 = oline.pointAt(factor3).x();
-		myc1 = oline.pointAt(factor3).y();
-		// inner control point
-		mxc2 = sin((sc + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[cornerPoints.count()-1].x();
-		myc2 = cos((sc + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[cornerPoints.count()-1].y();
-		pts.cubicTo(QPointF(mxc2, myc2), QPointF(mxc1, myc1), cornerPoints[0]);
-		pts.closeSubpath();
-	}
-	else
-	{
-		pts.moveTo(cornerPoints[0]);
-		for (int a = 1; a < cornerPoints.count(); a++)
-		{
-			pts.lineTo(cornerPoints[a]);
-		}
-		pts.closeSubpath();
-	}
-	return pts;
-}
-
-QPainterPath SpiralPath(double spiralWidth, double spiralHeight, double spiralStartAngle, double spiralEndAngle, double spiralFactor)
-{
-	if (spiralStartAngle >= spiralEndAngle)
-		return QPainterPath();
-	double startAngleK = spiralStartAngle;
-	double endAngleK = spiralEndAngle;
-	QPainterPath path, path2;
-	double sh = spiralHeight / (spiralFactor + 1.0);
-	double sw = 0.0;
-	double ww = spiralWidth;
-	double hh = spiralHeight - sh;
-	double segStart = 0.0;
-	double segEnd = 180.0;
-	double spanAngle = 180.0;
-	double startAngle = 0.0;
-	bool segPart = true;
-	bool draw = false;
-	QPointF tp;
-	path2.moveTo(sw, sh);
-	while (segStart < endAngleK)
-	{
-		if (startAngleK >= segEnd)
-		{
-			tp = path2.currentPosition();
-			if (segPart)
-			{
-				sw = tp.x();
-				sh = spiralHeight / (spiralFactor + 1.0);
-				path2.arcTo(sw, sh - hh, ww, hh * 2, 180, 180);
-			}
-			else
-			{
-				sw = tp.x() - ww;
-				sh = spiralHeight / (spiralFactor + 1.0) - hh;
-				path2.arcTo(sw, sh, ww, hh * 2, 0, 180);
-			}
-			segPart = !segPart;
-			ww /= spiralFactor;
-			hh /= spiralFactor;
-			segStart += 180.0;
-			segEnd += 180.0;
-			spanAngle = 180.0;
-			continue;
-		}
-		if ((startAngleK >= segStart) && (startAngleK <= segEnd))
-		{
-			startAngle = startAngleK + 180;
-			spanAngle = segEnd - startAngleK;
-			if ((endAngleK >= segStart) && (endAngleK <= segEnd))
-				spanAngle -= segEnd - endAngleK;
-			if (segPart)
-			{
-				sw = tp.x();
-				sh = spiralHeight / (spiralFactor + 1.0);
-				path.arcMoveTo(sw, sh - hh, ww, hh * 2, startAngle);
-				path.arcTo(sw, sh - hh, ww, hh * 2, startAngle, spanAngle);
-				startAngle = 0.0;
-			}
-			else
-			{
-				sw = tp.x() - ww;
-				sh = spiralHeight / (spiralFactor + 1.0) - hh;
-				path.arcMoveTo(sw, sh, ww, hh * 2, startAngle);
-				path.arcTo(sw, sh, ww, hh * 2, startAngle, spanAngle);
-				startAngle = 180.0;
-			}
-			draw = true;
-			segPart = !segPart;
-			ww /= spiralFactor;
-			hh /= spiralFactor;
-			if ((endAngleK >= segStart) && (endAngleK <= segEnd))
-				break;
-			segStart += 180.0;
-			segEnd += 180.0;
-			spanAngle = 180.0;
-			continue;
-		}
-		if ((endAngleK >= segStart) && (endAngleK <= segEnd))
-			spanAngle -= segEnd - endAngleK;
-		tp = path.currentPosition();
-		if (segPart)
-		{
-			sw = tp.x();
-			sh = tp.y();
-			if (draw)
-				path.arcTo(sw, sh - hh, ww, hh * 2, startAngle, spanAngle);
-			startAngle = 0.0;
-		}
-		else
-		{
-			sw = tp.x() - ww;
-			sh = tp.y() - hh;
-			if (draw)
-				path.arcTo(sw, sh, ww, hh * 2, startAngle, spanAngle);
-			startAngle = 180.0;
-		}
-		segPart = !segPart;
-		ww /= spiralFactor;
-		hh /= spiralFactor;
-		if ((endAngleK >= segStart) && (endAngleK <= segEnd))
-			break;
-		segStart += 180.0;
-		segEnd += 180.0;
-		spanAngle = 180.0;
-	}
-	return path;
-}
-
-QList<QPainterPath> decomposePath(QPainterPath &path)
-{
-	QList<QPainterPath> ret;
-	ret.clear();
-	QPainterPath part;
-	part = QPainterPath();
-	bool first = true;
-	for (int i = 0; i < path.elementCount(); ++i)
-	{
-		const QPainterPath::Element &elm = path.elementAt(i);
-		if ((first) && (elm.type != QPainterPath::MoveToElement))
-			part.moveTo(elm.x, elm.y);
-		switch (elm.type)
-		{
-			case QPainterPath::MoveToElement:
-				if (!first)
-				{
-					ret.append(part);
-					part = QPainterPath();
-				}
-				first = false;
-				part.moveTo(elm.x, elm.y);
-				break;
-			case QPainterPath::LineToElement:
-				part.lineTo(elm.x, elm.y);
-				break;
-			case QPainterPath::CurveToElement:
-				part.cubicTo(elm.x, elm.y, path.elementAt(i+1).x, path.elementAt(i+1).y, path.elementAt(i+2).x, path.elementAt(i+2).y );
-				break;
-			default:
-				break;
-		}
-	}
-	if (!part.isEmpty())
-		ret.append(part);
-	return ret;
-}
-
-FPoint projectPointOnLine(FPoint p, QPointF lineStart, QPointF lineEnd)
-{
-	if (lineStart == lineEnd)
-		return FPoint(lineStart.x(), lineStart.y());
-	
-	// move lineStart to Origin
-	p -= FPoint(lineStart.x(), lineStart.y());
-	lineEnd -= lineStart;
-	// calc dot product
-	double lineLengthSquare = lineEnd.x() * lineEnd.x() + lineEnd.y() * lineEnd.y();
-	double partOfLine = p.x() * lineEnd.x() + p.y() * lineEnd.y() / lineLengthSquare;
-	// return point on line
-	return FPoint(lineStart.x() + partOfLine * lineEnd.x(), lineStart.y() + partOfLine * lineEnd.y());
-}
-
-bool regionContainsRect(const QRegion& shape, QRect rect)
-{
-	/*bool oldResult = QRegion(rect).subtracted(shape).isEmpty();*/
-
-	// Code adapted from Qt RectInRegion (cf. qregion.cpp) to detect
-	// if a specific rect is stricly contained in a specific region
-	const QRect *pbox, *pboxEnd;
-    bool partIn(false), partOut(false);
-
-	QRect *prect = ▭
-	int rx = rect.left();
-	int ry = rect.top();
-   
-	int rectCount = shape.rectCount();
-	QRect boundingRect = shape.boundingRect();
-    if (rectCount == 0 || !boundingRect.contains(rect))
-        return false;
-
-    /* can stop when both partOut and partIn are true, or we reach prect->y2 */
-	const QVector<QRect> rects = shape.rects();
-    pbox = (rectCount == 1) ? &boundingRect : rects.constData();
-    pboxEnd = pbox + rectCount;
-    for (; pbox < pboxEnd; ++pbox) {
-        if (pbox->bottom() < ry)
-           continue;
-
-        if (pbox->top() > ry) {
-           partOut = true;
-           if (partIn || pbox->top() > prect->bottom())
-              break;
-           ry = pbox->top();
-        }
-
-        if (pbox->right() < rx)
-           continue;            /* not far enough over yet */
-
-        if (pbox->left() > rx) {
-           partOut = true;      /* missed part of rectangle to left */
-           if (partIn)
-              break;
-        }
-
-        if (pbox->left() <= prect->right()) {
-            partIn = true;      /* definitely overlap */
-            if (partOut)
-               break;
-        }
-
-        if (pbox->right() >= prect->right()) {
-           ry = pbox->bottom() + 1;     /* finished with this band */
-           if (ry > prect->bottom())
-              break;
-           rx = prect->left();  /* reset x out to left again */
-        } else {
-            /*
-             * Because boxes in a band are maximal width, if the first box
-             * to overlap the rectangle doesn't completely cover it in that
-             * band, the rectangle must be partially out, since some of it
-             * will be uncovered in that band. partIn will have been set true
-             * by now...
-             */
-            break;
-        }
-    }
-	/*bool newResult = partIn ? ((ry <= prect->bottom()) ? false : true) : false;
-	if (oldResult != newResult)
-		int test = 0;*/
-    return partIn ? ((ry <= prect->bottom()) ? false : true) : false;
-}
-
-QPolygon FlattenPath(const FPointArray& ina, QList<uint> &Segs)
-{
-	QPolygon cli, outa;
-	Segs.clear();
-	if (ina.size() > 3)
-	{
-		for (uint poi=0; poi<ina.size()-3; poi += 4)
-		{
-			if (ina.point(poi).x() > 900000) // && cli.size() > 0)
-			{
-//				outa << cli.point(cli.size()-1);
-				Segs.append(outa.size());
-				continue;
-			}
-			FPoint a1 = ina.point(poi);
-			FPoint a2 = ina.point(poi+1);
-			FPoint a3 = ina.point(poi+3);
-			FPoint a4 = ina.point(poi+2);
-			QPainterPath Bez;
-			Bez.moveTo(a1.x(), a1.y());
-			Bez.cubicTo(a2.x(), a2.y(), a3.x(), a3.y(), a4.x(), a4.y());
-			cli = Bez.toFillPolygon().toPolygon();
-			if (cli.size() > 1)
-				outa.putPoints(outa.size(), cli.size()-2, cli);
-			else
-				outa << QPoint(qRound(a4.x()), qRound(a4.y()));
-		}
-//		if (cli.size() > 0)
-//			outa << cli.point(cli.size()-1);
-	}
-	return outa;
-}
-
-FPoint getMaxClipF(FPointArray* Clip)
-{
-	FPoint np, rp;
-	double mx = 0;
-	double my = 0;
-	uint clipSize=Clip->size();
-	for (uint c = 0; c < clipSize; ++c)
-	{
-		np = Clip->point(c);
-		if (np.x() > 900000)
-			continue;
-		if (np.x() > mx)
-			mx = np.x();
-		if (np.y() > my)
-			my = np.y();
-	}
-	rp.setXY(mx, my);
-	return rp;
-}
-
-FPoint getMinClipF(FPointArray* Clip)
-{
-	FPoint np, rp;
-	double mx =  std::numeric_limits<double>::max();
-	double my =  std::numeric_limits<double>::max();
-	uint clipSize=Clip->size();
-	for (uint c = 0; c < clipSize; ++c)
-	{
-		np = Clip->point(c);
-		if (np.x() > 900000)
-			continue;
-		if (np.x() < mx)
-			mx = np.x();
-		if (np.y() < my)
-			my = np.y();
-	}
-	rp.setXY(mx, my);
-	return rp;
-}
-
-
-bool compareDouble(double a, double b)
-{
-	if(a > -21473 && b > -21473 && a < 21474 && b < 21474)
-	{
-		long al = static_cast<long>(10000 * a);
-		long bl = static_cast<long>(10000 * b);
-		return al == bl;
-	}
-	return a == b;
-}
-
-
-double constrainAngle(double angle, double constrain)
-{
-	double newAngle=angle;
-	double constrainTo=constrain;
-	if (newAngle<0.0)
-		newAngle+=360.0;
-	newAngle=qRound(angle/constrainTo)*constrainTo;
-	if (newAngle==360.0)
-		newAngle=0.0;
-	return newAngle;
-}
-
-double getRotationFromMatrix(QTransform& matrix, double def)
-{
-	double value = def;
-	double norm = sqrt(fabs(matrix.det()));
-	if (norm > 0.0000001)
-	{
-		double m11 = matrix.m11() / norm;
-		double m12 = matrix.m12() / norm;
-		double m21 = matrix.m21() / norm;
-		double m22 = matrix.m22() / norm;
-		if (fabs(m11) <= 1.0 && fabs(m12) <= 1.0 && fabs(m21) <= 1.0 && fabs(m22) <= 1.0)
-		{
-			QTransform mat(m11, m12, m21, m22, 0, 0);
-			if (abs(mat.det()-1.0) < 0.00001 && (mat.m12() == -mat.m21()))
-			{
-				double ac = acos(mat.m11());
-				value = (mat.m21() >= 0.0) ? ac : (-ac);
-			}
-		}
-	}
-	return value;
-}
-
-double getRotationDFromMatrix(QTransform& matrix)
-{
-	QLineF line = QLineF(0.0, 0.0, 1.0, 0.0);
-	line = matrix.map(line);
-	return line.angle();
-}
-
-void getScaleFromMatrix(QTransform &matrix, double &scX, double &scY)
-{
-	QLineF lineX = QLineF(0.0, 0.0, 1.0, 0.0);
-	QLineF lineY = QLineF(0.0, 0.0, 0.0, 1.0);
-	lineX = matrix.map(lineX);
-	lineY = matrix.map(lineY);
-	scX = lineX.length();
-	scY = lineY.length();
-}
+/*
+For general Scribus (>=1.3.2) copyright and licensing information please refer
+to the COPYING file provided with the program. Following this notice may exist
+a copyright and/or license notice that predates the release of Scribus 1.3.2
+for which a new license (GPL+exception) is in place.
+*/
+/***************************************************************************
+                          util.cpp  -  description
+                             -------------------
+    begin                : Fri Sep 14 2001
+    copyright            : (C) 2001 by Franz Schmid
+    email                : Franz.Schmid at altmuehlnet.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include <QRegion> 
+#include "util_math.h"
+#include "scconfig.h"
+#include "sclimits.h"
+#include "fpoint.h"
+#include "fpointarray.h"
+
+using namespace std;
+
+uint getDouble(const QByteArray in, bool raw)
+{
+	QByteArray bb(4, ' ');
+	if (raw)
+	{
+		// Qt4
+/*		bb[3] = static_cast<uchar>(QChar(in.at(0)));
+		bb[2] = static_cast<uchar>(QChar(in.at(1)));
+		bb[1] = static_cast<uchar>(QChar(in.at(2)));
+		bb[0] = static_cast<uchar>(QChar(in.at(3)));*/
+		bb[3] = in.at(0);
+		bb[2] = in.at(1);
+		bb[1] = in.at(2);
+		bb[0] = in.at(3);
+	}
+	else
+	{
+		// Qt4
+// 		bb[0] = static_cast<uchar>(QChar(in.at(0)));
+// 		bb[1] = static_cast<uchar>(QChar(in.at(1)));
+// 		bb[2] = static_cast<uchar>(QChar(in.at(2)));
+// 		bb[3] = static_cast<uchar>(QChar(in.at(3)));
+		bb[0] = in.at(0);
+		bb[1] = in.at(1);
+		bb[2] = in.at(2);
+		bb[3] = in.at(3);
+	}
+	uint ret;
+	ret = bb[0] & 0xff;
+	ret |= (bb[1] << 8) & 0xff00;
+	ret |= (bb[2] << 16) & 0xff0000;
+	ret |= (bb[3] << 24) & 0xff000000;
+	return ret;
+}
+
+QPainterPath RegularPolygonPath(double w, double h, uint c, bool star, double factor, double rota, double factor2, double innerRot, double factor3)
+{
+	uint cx = star ? c * 2 : c;
+	double seg = 360.0 / cx;
+	double sc = rota + 180.0;
+	double di = factor;
+	double mx = 0;
+	double my = 0;
+	double trueLength = sqrt(pow(sin(seg / 180.0 * M_PI) * (w / 2.0), 2) + pow(cos(seg / 180.0 * M_PI) * (h / 2.0) + (h/2.0) - h, 2));
+	QPainterPath pts;
+	// calculate corner Points first
+	QList<QPointF> cornerPoints;
+	for (uint x = 0; x < cx; ++x)
+	{
+		sc = seg * x + 180.0 + rota;
+		if (star)
+		{
+			double wf = w / 2.0;
+			double hf = h / 2.0;
+			if (x % 2 != 0)
+			{
+				wf *= di;
+				hf *= di;
+				sc += innerRot;
+			}
+			mx = sin(sc / 180.0 * M_PI) * (wf) + (w/2.0);
+			my = cos(sc / 180.0 * M_PI) * (hf) + (h/2.0);
+		}
+		else
+		{
+			mx = sin(sc / 180.0 * M_PI) * (w/2.0) + (w/2.0);
+			my = cos(sc / 180.0 * M_PI) * (h/2.0) + (h/2.0);
+		}
+		cornerPoints.append(QPointF(mx, my));
+	}
+	// now calculate bezier control points if needed;
+	if (star)
+	{
+		pts.moveTo(cornerPoints[0]);
+		double mxc1, myc1, mxc2, myc2;
+		for (int a = 0; a < cornerPoints.count() - 2; a++)
+		{
+			sc = seg * a + 180.0 + rota;
+			if (a % 2 != 0)
+			{
+				// outer control point
+				QLineF oline = QLineF(cornerPoints[a+1], cornerPoints[a-1]);
+				mxc1 = oline.pointAt(factor3).x();
+				myc1 = oline.pointAt(factor3).y();
+				// inner control point
+				mxc2 = sin((sc + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[a].x();
+				myc2 = cos((sc + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[a].y();
+				pts.cubicTo(QPointF(mxc2, myc2), QPointF(mxc1, myc1), cornerPoints[a+1]);
+			}
+			else
+			{
+				// outer control point
+				QLineF oline = QLineF(cornerPoints[a], cornerPoints[a+2]);
+				mxc1 = oline.pointAt(factor3).x();
+				myc1 = oline.pointAt(factor3).y();
+				// inner control point
+				mxc2 = sin((sc - 90.0 + seg) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[a+1].x();
+				myc2 = cos((sc - 90.0 + seg) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[a+1].y();
+				pts.cubicTo(QPointF(mxc1, myc1), QPointF(mxc2, myc2), cornerPoints[a+1]);
+			}
+		}
+		// outer control point
+		QLineF oline = QLineF(cornerPoints[cornerPoints.count()-2], cornerPoints[0]);
+		mxc1 = oline.pointAt(factor3).x();
+		myc1 = oline.pointAt(factor3).y();
+		// inner control point
+		sc = seg * (cornerPoints.count()-1) + 180.0 + rota;
+		mxc2 = sin((sc - 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[cornerPoints.count()-1].x();
+		myc2 = cos((sc - 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[cornerPoints.count()-1].y();
+		pts.cubicTo(QPointF(mxc1, myc1), QPointF(mxc2, myc2), cornerPoints[cornerPoints.count()-1]);
+		oline = QLineF(cornerPoints[0], cornerPoints[cornerPoints.count()-2]);
+		mxc1 = oline.pointAt(factor3).x();
+		myc1 = oline.pointAt(factor3).y();
+		// inner control point
+		mxc2 = sin((sc + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[cornerPoints.count()-1].x();
+		myc2 = cos((sc + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + cornerPoints[cornerPoints.count()-1].y();
+		pts.cubicTo(QPointF(mxc2, myc2), QPointF(mxc1, myc1), cornerPoints[0]);
+		pts.closeSubpath();
+	}
+	else
+	{
+		pts.moveTo(cornerPoints[0]);
+		for (int a = 1; a < cornerPoints.count(); a++)
+		{
+			pts.lineTo(cornerPoints[a]);
+		}
+		pts.closeSubpath();
+	}
+	return pts;
+}
+
+QPainterPath SpiralPath(double spiralWidth, double spiralHeight, double spiralStartAngle, double spiralEndAngle, double spiralFactor)
+{
+	if (spiralStartAngle >= spiralEndAngle)
+		return QPainterPath();
+	double startAngleK = spiralStartAngle;
+	double endAngleK = spiralEndAngle;
+	QPainterPath path, path2;
+	double sh = spiralHeight / (spiralFactor + 1.0);
+	double sw = 0.0;
+	double ww = spiralWidth;
+	double hh = spiralHeight - sh;
+	double segStart = 0.0;
+	double segEnd = 180.0;
+	double spanAngle = 180.0;
+	double startAngle = 0.0;
+	bool segPart = true;
+	bool draw = false;
+	QPointF tp;
+	path2.moveTo(sw, sh);
+	while (segStart < endAngleK)
+	{
+		if (startAngleK >= segEnd)
+		{
+			tp = path2.currentPosition();
+			if (segPart)
+			{
+				sw = tp.x();
+				sh = spiralHeight / (spiralFactor + 1.0);
+				path2.arcTo(sw, sh - hh, ww, hh * 2, 180, 180);
+			}
+			else
+			{
+				sw = tp.x() - ww;
+				sh = spiralHeight / (spiralFactor + 1.0) - hh;
+				path2.arcTo(sw, sh, ww, hh * 2, 0, 180);
+			}
+			segPart = !segPart;
+			ww /= spiralFactor;
+			hh /= spiralFactor;
+			segStart += 180.0;
+			segEnd += 180.0;
+			spanAngle = 180.0;
+			continue;
+		}
+		if ((startAngleK >= segStart) && (startAngleK <= segEnd))
+		{
+			startAngle = startAngleK + 180;
+			spanAngle = segEnd - startAngleK;
+			if ((endAngleK >= segStart) && (endAngleK <= segEnd))
+				spanAngle -= segEnd - endAngleK;
+			if (segPart)
+			{
+				sw = tp.x();
+				sh = spiralHeight / (spiralFactor + 1.0);
+				path.arcMoveTo(sw, sh - hh, ww, hh * 2, startAngle);
+				path.arcTo(sw, sh - hh, ww, hh * 2, startAngle, spanAngle);
+				startAngle = 0.0;
+			}
+			else
+			{
+				sw = tp.x() - ww;
+				sh = spiralHeight / (spiralFactor + 1.0) - hh;
+				path.arcMoveTo(sw, sh, ww, hh * 2, startAngle);
+				path.arcTo(sw, sh, ww, hh * 2, startAngle, spanAngle);
+				startAngle = 180.0;
+			}
+			draw = true;
+			segPart = !segPart;
+			ww /= spiralFactor;
+			hh /= spiralFactor;
+			if ((endAngleK >= segStart) && (endAngleK <= segEnd))
+				break;
+			segStart += 180.0;
+			segEnd += 180.0;
+			spanAngle = 180.0;
+			continue;
+		}
+		if ((endAngleK >= segStart) && (endAngleK <= segEnd))
+			spanAngle -= segEnd - endAngleK;
+		tp = path.currentPosition();
+		if (segPart)
+		{
+			sw = tp.x();
+			sh = tp.y();
+			if (draw)
+				path.arcTo(sw, sh - hh, ww, hh * 2, startAngle, spanAngle);
+			startAngle = 0.0;
+		}
+		else
+		{
+			sw = tp.x() - ww;
+			sh = tp.y() - hh;
+			if (draw)
+				path.arcTo(sw, sh, ww, hh * 2, startAngle, spanAngle);
+			startAngle = 180.0;
+		}
+		segPart = !segPart;
+		ww /= spiralFactor;
+		hh /= spiralFactor;
+		if ((endAngleK >= segStart) && (endAngleK <= segEnd))
+			break;
+		segStart += 180.0;
+		segEnd += 180.0;
+		spanAngle = 180.0;
+	}
+	return path;
+}
+
+QList<QPainterPath> decomposePath(QPainterPath &path)
+{
+	QList<QPainterPath> ret;
+	ret.clear();
+	QPainterPath part;
+	part = QPainterPath();
+	bool first = true;
+	for (int i = 0; i < path.elementCount(); ++i)
+	{
+		const QPainterPath::Element &elm = path.elementAt(i);
+		if ((first) && (elm.type != QPainterPath::MoveToElement))
+			part.moveTo(elm.x, elm.y);
+		switch (elm.type)
+		{
+			case QPainterPath::MoveToElement:
+				if (!first)
+				{
+					ret.append(part);
+					part = QPainterPath();
+				}
+				first = false;
+				part.moveTo(elm.x, elm.y);
+				break;
+			case QPainterPath::LineToElement:
+				part.lineTo(elm.x, elm.y);
+				break;
+			case QPainterPath::CurveToElement:
+				part.cubicTo(elm.x, elm.y, path.elementAt(i+1).x, path.elementAt(i+1).y, path.elementAt(i+2).x, path.elementAt(i+2).y );
+				break;
+			default:
+				break;
+		}
+	}
+	if (!part.isEmpty())
+		ret.append(part);
+	return ret;
+}
+
+FPoint projectPointOnLine(FPoint p, QPointF lineStart, QPointF lineEnd)
+{
+	if (lineStart == lineEnd)
+		return FPoint(lineStart.x(), lineStart.y());
+	
+	// move lineStart to Origin
+	p -= FPoint(lineStart.x(), lineStart.y());
+	lineEnd -= lineStart;
+	// calc dot product
+	double lineLengthSquare = lineEnd.x() * lineEnd.x() + lineEnd.y() * lineEnd.y();
+	double partOfLine = p.x() * lineEnd.x() + p.y() * lineEnd.y() / lineLengthSquare;
+	// return point on line
+	return FPoint(lineStart.x() + partOfLine * lineEnd.x(), lineStart.y() + partOfLine * lineEnd.y());
+}
+
+bool regionContainsRect(const QRegion& shape, QRect rect)
+{
+	/*bool oldResult = QRegion(rect).subtracted(shape).isEmpty();*/
+
+	// Code adapted from Qt RectInRegion (cf. qregion.cpp) to detect
+	// if a specific rect is stricly contained in a specific region
+	const QRect *pbox, *pboxEnd;
+    bool partIn(false), partOut(false);
+
+	QRect *prect = ▭
+	int rx = rect.left();
+	int ry = rect.top();
+   
+	int rectCount = shape.rectCount();
+	QRect boundingRect = shape.boundingRect();
+    if (rectCount == 0 || !boundingRect.contains(rect))
+        return false;
+
+    /* can stop when both partOut and partIn are true, or we reach prect->y2 */
+	const QVector<QRect> rects = shape.rects();
+    pbox = (rectCount == 1) ? &boundingRect : rects.constData();
+    pboxEnd = pbox + rectCount;
+    for (; pbox < pboxEnd; ++pbox) {
+        if (pbox->bottom() < ry)
+           continue;
+
+        if (pbox->top() > ry) {
+           partOut = true;
+           if (partIn || pbox->top() > prect->bottom())
+              break;
+           ry = pbox->top();
+        }
+
+        if (pbox->right() < rx)
+           continue;            /* not far enough over yet */
+
+        if (pbox->left() > rx) {
+           partOut = true;      /* missed part of rectangle to left */
+           if (partIn)
+              break;
+        }
+
+        if (pbox->left() <= prect->right()) {
+            partIn = true;      /* definitely overlap */
+            if (partOut)
+               break;
+        }
+
+        if (pbox->right() >= prect->right()) {
+           ry = pbox->bottom() + 1;     /* finished with this band */
+           if (ry > prect->bottom())
+              break;
+           rx = prect->left();  /* reset x out to left again */
+        } else {
+            /*
+             * Because boxes in a band are maximal width, if the first box
+             * to overlap the rectangle doesn't completely cover it in that
+             * band, the rectangle must be partially out, since some of it
+             * will be uncovered in that band. partIn will have been set true
+             * by now...
+             */
+            break;
+        }
+    }
+	/*bool newResult = partIn ? ((ry <= prect->bottom()) ? false : true) : false;
+	if (oldResult != newResult)
+		int test = 0;*/
+    return partIn ? ((ry <= prect->bottom()) ? false : true) : false;
+}
+
+QPolygon FlattenPath(const FPointArray& ina, QList<uint> &Segs)
+{
+	QPolygon cli, outa;
+	Segs.clear();
+	if (ina.size() > 3)
+	{
+		for (uint poi=0; poi<ina.size()-3; poi += 4)
+		{
+			if (ina.point(poi).x() > 900000) // && cli.size() > 0)
+			{
+//				outa << cli.point(cli.size()-1);
+				Segs.append(outa.size());
+				continue;
+			}
+			FPoint a1 = ina.point(poi);
+			FPoint a2 = ina.point(poi+1);
+			FPoint a3 = ina.point(poi+3);
+			FPoint a4 = ina.point(poi+2);
+			QPainterPath Bez;
+			Bez.moveTo(a1.x(), a1.y());
+			Bez.cubicTo(a2.x(), a2.y(), a3.x(), a3.y(), a4.x(), a4.y());
+			cli = Bez.toFillPolygon().toPolygon();
+			if (cli.size() > 1)
+				outa.putPoints(outa.size(), cli.size()-2, cli);
+			else
+				outa << QPoint(qRound(a4.x()), qRound(a4.y()));
+		}
+//		if (cli.size() > 0)
+//			outa << cli.point(cli.size()-1);
+	}
+	return outa;
+}
+
+FPoint getMaxClipF(FPointArray* Clip)
+{
+	FPoint np, rp;
+	double mx = 0;
+	double my = 0;
+	uint clipSize=Clip->size();
+	for (uint c = 0; c < clipSize; ++c)
+	{
+		np = Clip->point(c);
+		if (np.x() > 900000)
+			continue;
+		if (np.x() > mx)
+			mx = np.x();
+		if (np.y() > my)
+			my = np.y();
+	}
+	rp.setXY(mx, my);
+	return rp;
+}
+
+FPoint getMinClipF(FPointArray* Clip)
+{
+	FPoint np, rp;
+	double mx =  std::numeric_limits<double>::max();
+	double my =  std::numeric_limits<double>::max();
+	uint clipSize=Clip->size();
+	for (uint c = 0; c < clipSize; ++c)
+	{
+		np = Clip->point(c);
+		if (np.x() > 900000)
+			continue;
+		if (np.x() < mx)
+			mx = np.x();
+		if (np.y() < my)
+			my = np.y();
+	}
+	rp.setXY(mx, my);
+	return rp;
+}
+
+
+bool compareDouble(double a, double b)
+{
+	if(a > -21473 && b > -21473 && a < 21474 && b < 21474)
+	{
+		long al = static_cast<long>(10000 * a);
+		long bl = static_cast<long>(10000 * b);
+		return al == bl;
+	}
+	return a == b;
+}
+
+
+double constrainAngle(double angle, double constrain)
+{
+	double newAngle=angle;
+	double constrainTo=constrain;
+	if (newAngle<0.0)
+		newAngle+=360.0;
+	newAngle=qRound(angle/constrainTo)*constrainTo;
+	if (newAngle==360.0)
+		newAngle=0.0;
+	return newAngle;
+}
+
+double getRotationFromMatrix(QTransform& matrix, double def)
+{
+	double value = def;
+	double norm = sqrt(fabs(matrix.det()));
+	if (norm > 0.0000001)
+	{
+		double m11 = matrix.m11() / norm;
+		double m12 = matrix.m12() / norm;
+		double m21 = matrix.m21() / norm;
+		double m22 = matrix.m22() / norm;
+		if (fabs(m11) <= 1.0 && fabs(m12) <= 1.0 && fabs(m21) <= 1.0 && fabs(m22) <= 1.0)
+		{
+			QTransform mat(m11, m12, m21, m22, 0, 0);
+			if (abs(mat.det()-1.0) < 0.00001 && (mat.m12() == -mat.m21()))
+			{
+				double ac = acos(mat.m11());
+				value = (mat.m21() >= 0.0) ? ac : (-ac);
+			}
+		}
+	}
+	return value;
+}
+
+double getRotationDFromMatrix(QTransform& matrix)
+{
+	QLineF line = QLineF(0.0, 0.0, 1.0, 0.0);
+	line = matrix.map(line);
+	return line.angle();
+}
+
+void getScaleFromMatrix(QTransform &matrix, double &scX, double &scY)
+{
+	QLineF lineX = QLineF(0.0, 0.0, 1.0, 0.0);
+	QLineF lineY = QLineF(0.0, 0.0, 0.0, 1.0);
+	lineX = matrix.map(lineX);
+	lineY = matrix.map(lineY);
+	scX = lineX.length();
+	scY = lineY.length();
+}




More information about the scribus-commit mailing list