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

scribus-commit scribus-commit at lists.scribus.net
Fri Dec 30 15:29:34 UTC 2011


Author: jghali
Date: Fri Dec 30 15:29:34 2011
New Revision: 17153

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

Modified:
    branches/Version135/Scribus/scribus/util_math.cpp

Modified: branches/Version135/Scribus/scribus/util_math.cpp
URL: http://scribus.net/websvn/diff.php?repname=Scribus&rev=17153&path=/branches/Version135/Scribus/scribus/util_math.cpp
==============================================================================
--- branches/Version135/Scribus/scribus/util_math.cpp (original)
+++ branches/Version135/Scribus/scribus/util_math.cpp Fri Dec 30 15:29:34 2011
@@ -1,386 +1,386 @@
-/*
-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 "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 RegularPolygon(double w, double h, uint c, bool star, double factor, double rota, double factor2)
-{
-	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;
-	bool first = true;
-	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;
-	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;
-			}
-			mx = sin(sc / 180.0 * M_PI) * (wf) + (w/2.0);
-			my = cos(sc / 180.0 * M_PI) * (hf) + (h/2.0);
-			if (first)
-				pts.moveTo(mx, my);
-			else
-			{
-				if (factor2 != 0.0)
-				{
-					if (x % 2 != 0)
-					{
-						QPointF curr = pts.currentPosition();
-						double mxc = sin((sc + 90.0) / 180.0 * M_PI) * (-trueLength * factor2) + mx;
-						double myc = cos((sc + 90.0) / 180.0 * M_PI) * (-trueLength * factor2) + my;
-						pts.cubicTo(curr, QPointF(mxc, myc), QPointF(mx, my));
-					}
-					else
-					{
-						QPointF curr = pts.currentPosition();
-						double mxc = sin((sc - seg + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + curr.x();
-						double myc = cos((sc - seg + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + curr.y();
-						pts.cubicTo(QPointF(mxc, myc), QPointF(mx, my), QPointF(mx, my));
-					}
-				}
-				else
-					pts.lineTo(mx, my);
-			}
-		}
-		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);
-			if (first)
-				pts.moveTo(mx, my);
-			else
-				pts.lineTo(mx, my);
-		}
-		first = false;
-	}
-	if ((star) && (factor2 != 0.0))
-	{
-		sc = 360.0 + 180.0 + rota;
-		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);
-		QPointF curr = pts.currentPosition();
-		double mxc = sin((sc - seg + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + curr.x();
-		double myc = cos((sc - seg + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + curr.y();
-		pts.cubicTo(QPointF(mxc, myc), QPointF(mx, my), QPointF(mx, my));
-	}
-	pts.closeSubpath();
-	return pts;
-}
-
-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());
-}
-
+/*
+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 "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 RegularPolygon(double w, double h, uint c, bool star, double factor, double rota, double factor2)
+{
+	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;
+	bool first = true;
+	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;
+	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;
+			}
+			mx = sin(sc / 180.0 * M_PI) * (wf) + (w/2.0);
+			my = cos(sc / 180.0 * M_PI) * (hf) + (h/2.0);
+			if (first)
+				pts.moveTo(mx, my);
+			else
+			{
+				if (factor2 != 0.0)
+				{
+					if (x % 2 != 0)
+					{
+						QPointF curr = pts.currentPosition();
+						double mxc = sin((sc + 90.0) / 180.0 * M_PI) * (-trueLength * factor2) + mx;
+						double myc = cos((sc + 90.0) / 180.0 * M_PI) * (-trueLength * factor2) + my;
+						pts.cubicTo(curr, QPointF(mxc, myc), QPointF(mx, my));
+					}
+					else
+					{
+						QPointF curr = pts.currentPosition();
+						double mxc = sin((sc - seg + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + curr.x();
+						double myc = cos((sc - seg + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + curr.y();
+						pts.cubicTo(QPointF(mxc, myc), QPointF(mx, my), QPointF(mx, my));
+					}
+				}
+				else
+					pts.lineTo(mx, my);
+			}
+		}
+		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);
+			if (first)
+				pts.moveTo(mx, my);
+			else
+				pts.lineTo(mx, my);
+		}
+		first = false;
+	}
+	if ((star) && (factor2 != 0.0))
+	{
+		sc = 360.0 + 180.0 + rota;
+		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);
+		QPointF curr = pts.currentPosition();
+		double mxc = sin((sc - seg + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + curr.x();
+		double myc = cos((sc - seg + 90.0) / 180.0 * M_PI) * (trueLength * factor2) + curr.y();
+		pts.cubicTo(QPointF(mxc, myc), QPointF(mx, my), QPointF(mx, my));
+	}
+	pts.closeSubpath();
+	return pts;
+}
+
+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;*/
+	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 = 99999;
-	double my = 99999;
-	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(QMatrix& 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)
-		{
-			QMatrix 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;
-}
-
+}
+
+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 = 99999;
+	double my = 99999;
+	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(QMatrix& 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)
+		{
+			QMatrix 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;
+}
+




More information about the scribus-commit mailing list