QScriptValue
REcmaLinetypePattern::isSymmetrical
(QScriptContext* context, QScriptEngine* engine)
{
//REcmaHelper::functionStart("REcmaLinetypePattern::isSymmetrical", context, engine);
//qDebug() << "ECMAScript WRAPPER: REcmaLinetypePattern::isSymmetrical";
//QCoreApplication::processEvents();
QScriptValue result = engine->undefinedValue();
// public function: can be called from ECMA wrapper of ECMA shell:
RLinetypePattern* self =
getSelf("isSymmetrical", context);
//Q_ASSERT(self!=NULL);
if (self==NULL) {
return REcmaHelper::throwError("self is NULL", context);
}
if( context->argumentCount() ==
1 && (
context->argument(0).isNumber()
) /* type: int */
){
// prepare arguments:
// argument isStandardType
int
a0 =
(int)
context->argument( 0 ).
toNumber();
// end of arguments
// call C++ function:
// return type 'bool'
bool cppResult =
self->isSymmetrical(a0);
// return type: bool
// standard Type
result = QScriptValue(cppResult);
} else
{
return REcmaHelper::throwError("Wrong number/types of arguments for RLinetypePattern.isSymmetrical().",
context);
}
//REcmaHelper::functionEnd("REcmaLinetypePattern::isSymmetrical", context, engine);
return result;
}
void RExporter::exportSpline(const RSpline& spline, double offset) {
RLinetypePattern p = getLinetypePattern();
bool continuous = false;
if (getEntity() == NULL || !p.isValid() || p.getNumDashes() == 1 || draftMode || screenBasedLinetypes) {
continuous = true;
}
if (!continuous) {
p.scale(getPatternFactor());
if (RMath::isNaN(offset)) {
double length = spline.getLength();
offset = getPatternOffset(length, p);
}
exportExplodable(spline, offset);
}
else {
// version <= 3.0.0 was (line interpolation):
//exportExplodable(spline, offset);
// performance improvement (using real splines):
RPainterPath pp;
pp.setPen(QPen(Qt::SolidLine));
pp.addSpline(spline);
exportPainterPaths(QList<RPainterPath>() << pp);
}
/*
RLinetypePattern p = getLinetypePattern();
p.scale(getPatternFactor());
if (RMath::isNaN(offset)) {
double length = spline.getLength();
offset = getPatternOffset(length, p);
}
double currentOffset = offset;
QList<QSharedPointer<RShape> > sub = spline.getExploded();
QList<QSharedPointer<RShape> >::iterator it;
for (it=sub.begin(); it!=sub.end(); ++it) {
QSharedPointer<RLine> line = (*it).dynamicCast<RLine>();
if (!line.isNull()) {
exportLine(*line.data(), currentOffset);
currentOffset -= line->getLength();
}
QSharedPointer<RArc> arc = (*it).dynamicCast<RArc>();
if (!arc.isNull()) {
exportArc(*arc.data(), currentOffset);
currentOffset -= arc->getLength();
}
}
*/
}
// public methods:
QScriptValue
REcmaLinetypePattern::set
(QScriptContext* context, QScriptEngine* engine)
{
//REcmaHelper::functionStart("REcmaLinetypePattern::set", context, engine);
//qDebug() << "ECMAScript WRAPPER: REcmaLinetypePattern::set";
//QCoreApplication::processEvents();
QScriptValue result = engine->undefinedValue();
// public function: can be called from ECMA wrapper of ECMA shell:
RLinetypePattern* self =
getSelf("set", context);
//Q_ASSERT(self!=NULL);
if (self==NULL) {
return REcmaHelper::throwError("self is NULL", context);
}
if( context->argumentCount() ==
1 && (
context->argument(0).isArray()
) /* type: QList < double > */
){
// prepare arguments:
// argument isArray
QList < double >
a0;
REcmaHelper::fromScriptValue(
engine,
context->argument(0),
a0
);
// end of arguments
// call C++ function:
// return type 'void'
self->set(a0);
} else
{
return REcmaHelper::throwError("Wrong number/types of arguments for RLinetypePattern.set().",
context);
}
//REcmaHelper::functionEnd("REcmaLinetypePattern::set", context, engine);
return result;
}
QScriptValue
REcmaLinetypePattern::getLargestGap
(QScriptContext* context, QScriptEngine* engine)
{
//REcmaHelper::functionStart("REcmaLinetypePattern::getLargestGap", context, engine);
//qDebug() << "ECMAScript WRAPPER: REcmaLinetypePattern::getLargestGap";
//QCoreApplication::processEvents();
QScriptValue result = engine->undefinedValue();
// public function: can be called from ECMA wrapper of ECMA shell:
RLinetypePattern* self =
getSelf("getLargestGap", context);
//Q_ASSERT(self!=NULL);
if (self==NULL) {
return REcmaHelper::throwError("self is NULL", context);
}
if( context->argumentCount() ==
0
){
// prepare arguments:
// end of arguments
// call C++ function:
// return type 'double'
double cppResult =
self->getLargestGap();
// return type: double
// standard Type
result = QScriptValue(cppResult);
} else
{
return REcmaHelper::throwError("Wrong number/types of arguments for RLinetypePattern.getLargestGap().",
context);
}
//REcmaHelper::functionEnd("REcmaLinetypePattern::getLargestGap", context, engine);
return result;
}
void RExporter::exportExplodable(const RExplodable& explodable, double offset) {
QList<QSharedPointer<RShape> > sub = explodable.getExploded();
RLinetypePattern p = getLinetypePattern();
if (!p.isValid() || p.getNumDashes() <= 1 || draftMode || screenBasedLinetypes || twoColorSelectedMode) {
for (int i=0; i<sub.length(); i++) {
QSharedPointer<RLine> lineP = sub[i].dynamicCast<RLine>();
if (!lineP.isNull()) {
exportLine(*lineP.data());
continue;
}
QSharedPointer<RArc> arc = sub[i].dynamicCast<RArc>();
if (!arc.isNull()) {
exportArc(*arc.data());
continue;
}
}
return;
}
if (getEntity()!=NULL && (getEntity()->getType()!=RS::EntitySpline || RSpline::hasProxy())) {
// all explodable entities including splines if we have a spline proxy:
RShapesExporter(*this, sub, offset);
return;
}
// use alternative algorithm for splines if we don't have a spline proxy:
double dist;
for (int i=0; i<sub.length(); i++) {
QSharedPointer<RLine> lineP = sub[i].dynamicCast<RLine>();
if (!lineP.isNull()) {
RLine line = *lineP.data();
dist = exportLine(line, offset);
offset -= lineP->getLength();
continue;
}
QSharedPointer<RArc> arc = sub[i].dynamicCast<RArc>();
if (!arc.isNull()) {
exportArc(*arc.data(), offset);
offset -= arc->getLength();
continue;
}
}
}
bool REntity::setProperty(RPropertyTypeId propertyTypeId, const QVariant& value, RTransaction* transaction) {
bool ret = RObject::setProperty(propertyTypeId, value, transaction);
if (propertyTypeId == PropertyBlock) {
ret = ret || RObject::setMember(getData().blockId, value.toInt(), true);
} else if (propertyTypeId == PropertyLayer) {
if (value.type() == QVariant::Int || value.type() == QVariant::LongLong) {
ret = ret || RObject::setMember(getData().layerId, value.toInt(), true);
} else if (value.type() == QVariant::String) {
RDocument* document = getData().getDocument();
if (document != NULL) {
ret = ret || RObject::setMember(getData().layerId,
document->getLayerId(value.toString()), true);
}
}
} else if (propertyTypeId == PropertyLinetype) {
if (value.type() == QVariant::Int || value.type() == QVariant::LongLong) {
ret = ret || RObject::setMember(getData().linetypeId, value.toInt(), true);
} else {
RDocument* document = getData().getDocument();
if (document != NULL) {
RLinetypePattern t = value.value<RLinetypePattern> ();
int id = document->getLinetypeId(t.getName());
ret = ret || RObject::setMember(getData().linetypeId, id, true);
}
}
} else if (propertyTypeId == PropertyLinetypeScale) {
ret = ret || RObject::setMember(getData().linetypeScale, value.toDouble(), true);
} else if (propertyTypeId == PropertyLineweight) {
if (value.type()==QVariant::Int || value.type()==QVariant::Double) {
ret = ret || RObject::setMember((int&)getData().lineweight,
value.value<int>(), true);
}
else {
ret = ret || RObject::setMember((int&)getData().lineweight,
(int)value.value<RLineweight::Lineweight>(), true);
}
} else if (propertyTypeId == PropertyColor) {
ret = ret || RObject::setMember(getData().color, value, true);
} else if (propertyTypeId == PropertyDrawOrder) {
ret = ret || RObject::setMember(getData().drawOrder, value, true);
}
return ret;
}
/**
* \return Offset to use to apply the given pattern to an entity of the
* given length that the pattern is symmetrical.
*/
double RExporter::getPatternOffset(double length,
const RLinetypePattern& pattern) {
double optOffset = 0.0;
double gap = 0.0;
double maxGap = RMINDOUBLE;
for (int i = 0; i < pattern.getNumDashes(); ++i) {
if (!pattern.isSymmetrical(i)) {
continue;
}
double offset = getPatternOffset(length, pattern, i, &gap);
if (gap > maxGap) {
maxGap = gap;
optOffset = offset;
// qDebug(QString("RExporter::getPatternOffset: i=%1").arg(i));
}
}
return optOffset;
}
void RExporter::exportPolyline(const RPolyline& polyline, double offset) {
RLinetypePattern p = getLinetypePattern();
bool continuous = false;
if (getEntity() == NULL || !p.isValid() || p.getNumDashes() == 1 || draftMode || screenBasedLinetypes) {
continuous = true;
}
if (!continuous) {
p.scale(getPatternFactor());
if (RMath::isNaN(offset)) {
double length = polyline.getLength();
offset = getPatternOffset(length, p);
}
}
exportExplodable(polyline, offset);
}
double RExporter::getPatternOffset(double length,
const RLinetypePattern& pattern, int index, double* gap) {
double patternLength = pattern.getPatternLength();
if (patternLength<RS::PointTolerance) {
return 0.0;
}
double po = fabs(pattern.getDashLengthAt(index)) / 2;
for (int i = index - 1; i >= 0; --i) {
po += fabs(pattern.getDashLengthAt(i));
}
double offset = length / 2 - po;
int m = (int) RMath::trunc(offset / patternLength);
offset -= (m + 1) * patternLength;
if (gap != NULL) {
*gap = pattern.getDelta(-offset);
}
return offset;
}
/**
* \param polylineGen True: use pattern along whole polyline, False: pattern per segment.
*/
void RExporter::exportPolyline(const RPolyline& polyline, bool polylineGen, double offset) {
RLinetypePattern p = getLinetypePattern();
bool continuous = false;
if (getEntity() == NULL || !p.isValid() || p.getNumDashes() <= 1 || draftMode || screenBasedLinetypes || twoColorSelectedMode) {
continuous = true;
}
if (!continuous) {
p.scale(getLineTypePatternScale(p));
if (RMath::isNaN(offset)) {
double length = polyline.getLength();
offset = p.getPatternOffset(length);
}
}
if (polylineGen) {
// pattern along whole polyline:
exportExplodable(polyline, offset);
}
else {
// pattern for each individual segment:
for (int i=0; i<polyline.countSegments(); i++) {
QSharedPointer<RShape> shape = polyline.getSegmentAt(i);
QSharedPointer<RLine> line = shape.dynamicCast<RLine>();
if (!line.isNull()) {
RExporter::exportLine(*line);
}
QSharedPointer<RArc> arc = shape.dynamicCast<RArc>();
if (!arc.isNull()) {
RExporter::exportArc(*arc);
}
}
}
}
void REntityData::setLinetypePattern(const RLinetypePattern& linetypePattern) {
if (document!=NULL) {
this->linetypeId = document->getLinetypeId(linetypePattern.getName());
}
}
void RStorage::setCurrentLinetypePattern(const RLinetypePattern& p) {
setCurrentLinetype(p.getName());
}
void RExporter::exportLine(const RLine& line, double offset) {
if (!line.isValid()) {
return;
}
double length = line.getLength();
if (length>1e100 || length<RS::PointTolerance) {
return;
}
RLinetypePattern p = getLinetypePattern();
// continuous line or
// we are in draft mode or
// QCAD is configured to show screen based line patterns
if (!p.isValid() || p.getNumDashes() == 1 || draftMode || screenBasedLinetypes) {
exportLineSegment(line);
return;
}
p.scale(getPatternFactor());
double patternLength = p.getPatternLength();
// avoid huge number of small segments due to very fine
// pattern or long lines:
if (patternLength<RS::PointTolerance || length / patternLength > 5000) {
exportLineSegment(line);
return;
}
double angle = line.getAngle();
RVector* vp = NULL;
vp = new RVector[p.getNumDashes()];
for (int i = 0; i < p.getNumDashes(); ++i) {
vp[i] = RVector(cos(angle) * fabs(p.getDashLengthAt(i)),
sin(angle) * fabs(p.getDashLengthAt(i)));
}
bool optimizeEnds = false;
if (RMath::isNaN(offset)) {
offset = getPatternOffset(length, p);
optimizeEnds = true;
}
else {
double num = ceil(offset / patternLength);
offset -= num * patternLength;
}
bool done = false;
int i = 0;
RVector cursor(line.getStartPoint() + RVector::createPolar(offset, angle));
double total = offset;
bool dashFound = false;
bool gapFound = false;
RVector p1 = line.getStartPoint();
RVector p2 = p1;
do {
if (dashFound && !gapFound) {
// don't shoot over end of line:
if (total + fabs(p.getDashLengthAt(i)) >= length - 1.0e-6) {
if (optimizeEnds) {
exportLineSegment(RLine(p1, line.endPoint));
}
else {
exportLineSegment(RLine(p1, p2));
}
break;
}
exportLineSegment(RLine(p1, p2));
}
// dash, no gap. note that a dash can have a length of 0.0 (point):
if (p.getDashLengthAt(i) > -RS::PointTolerance) {
// check if we're on the line already:
if (total + p.getDashLengthAt(i) > 0) {
p1 = cursor;
// no gap at the beginning of the line:
if (total < 0 || (!dashFound && optimizeEnds)) {
p1 = line.startPoint;
}
p2 = cursor + vp[i];
if (!p2.equalsFuzzy(line.startPoint, 1.0e-6)) {
dashFound = true;
}
}
gapFound = false;
}
// gap:
else {
gapFound = true;
}
cursor += vp[i];
total += fabs(p.getDashLengthAt(i));
done = total > length;
++i;
if (i >= p.getNumDashes()) {
i = 0;
}
} while (!done);
if (!gapFound || !dashFound) {
if (total + fabs(p.getDashLengthAt(i)) >= length - 1.0e-6) {
if (optimizeEnds || (total>length && !gapFound)) {
exportLineSegment(RLine(p1, line.endPoint));
}
else {
exportLineSegment(RLine(p1, p2));
}
} else {
exportLineSegment(RLine(p1, p2));
}
}
delete[] vp;
}
double RExporter::getLineTypePatternScale(const RLinetypePattern& p) const {
if (document==NULL) {
return 1.0;
}
double factor = 1.0;
// document wide linetype scale:
double docLinetypeScale = document->getKnownVariable(RS::LTSCALE).toDouble();
if (docLinetypeScale>1e-6) {
// LTSCALE might be zero:
factor *= docLinetypeScale;
}
//qDebug() << "factor (doc): " << factor;
// drawing unit scale:
if (p.isMetric()) {
// metric line type patterns are defined in mm:
factor *= RUnit::convert(1.0, RS::Millimeter, document->getUnit());
}
else {
// imperial line type patterns are defined in inches:
factor *= RUnit::convert(1.0, RS::Inch, document->getUnit());
}
//qDebug() << "factor (unit): " << factor;
// entity line type scale:
const REntity* entity = getEntity();
if (entity!=NULL) {
double entityLinetypeScale = entity->getLinetypeScale();
if (!RMath::fuzzyCompare(entityLinetypeScale, 1.0)) {
if (entityLinetypeScale>1e-6) {
factor *= entityLinetypeScale;
}
}
}
//qDebug() << "factor (entity): " << factor;
// optional: automatic scaling by line weight:
if (RSettings::getAutoScaleLinetypePatterns()) {
if (currentPen.widthF()<1e-6) {
// line pattern factor for lines of width 0:
int zww = RSettings::getZeroWeightWeight()/100.0;
if (zww<=0) {
zww = 1.0;
}
//factor *= RUnit::convert(zww/100.0, RS::Millimeter, document->getUnit());
factor *= zww;
}
else {
//qDebug() << "currentPen.widthF(): " << currentPen.widthF();
//qDebug() << "currentPen.widthF() mm: " << RUnit::convert(currentPen.widthF(), document->getUnit(), RS::Millimeter);
factor *= RUnit::convert(currentPen.widthF(), document->getUnit(), RS::Millimeter);
}
}
//qDebug() << "factor: " << factor;
return factor;
}
void RExporter::exportSpline(const RSpline& spline, double offset) {
RLinetypePattern p = getLinetypePattern();
bool continuous = false;
if (getEntity() == NULL || !p.isValid() || p.getNumDashes() <= 1 || draftMode || screenBasedLinetypes || twoColorSelectedMode) {
continuous = true;
}
p.scale(getLineTypePatternScale(p));
double patternLength = p.getPatternLength();
if (patternLength<RS::PointTolerance || spline.getLength() / patternLength > RSettings::getDashThreshold()) {
continuous = true;
}
if (!continuous) {
if (getEntity()!=NULL && (getEntity()->getType()!=RS::EntitySpline || RSpline::hasProxy())) {
// we have a spline proxy:
RShapesExporter(*this, QList<QSharedPointer<RShape> >() << QSharedPointer<RShape>(spline.clone()), offset);
}
else {
// fallback if we don't have a spline proxy:
p.scale(getLineTypePatternScale(p));
if (RMath::isNaN(offset)) {
double length = spline.getLength();
offset = p.getPatternOffset(length);
}
exportExplodable(spline, offset);
}
}
else {
// version <= 3.0.0 was (line interpolation):
//exportExplodable(spline, offset);
// performance improvement (using real splines):
RPainterPath pp;
pp.setPen(currentPen);
pp.setInheritPen(true);
pp.addSpline(spline);
exportPainterPaths(QList<RPainterPath>() << pp);
}
/*
RLinetypePattern p = getLinetypePattern();
p.scale(getLineTypePatternScale(p));
if (RMath::isNaN(offset)) {
double length = spline.getLength();
offset = p.getPatternOffset(length);
}
double currentOffset = offset;
QList<QSharedPointer<RShape> > sub = spline.getExploded();
QList<QSharedPointer<RShape> >::iterator it;
for (it=sub.begin(); it!=sub.end(); ++it) {
QSharedPointer<RLine> line = (*it).dynamicCast<RLine>();
if (!line.isNull()) {
exportLine(*line.data(), currentOffset);
currentOffset -= line->getLength();
}
QSharedPointer<RArc> arc = (*it).dynamicCast<RArc>();
if (!arc.isNull()) {
exportArc(*arc.data(), currentOffset);
currentOffset -= arc->getLength();
}
}
*/
}
void RExporter::setLinetypePattern(const RLinetypePattern& ltPattern) {
Q_ASSERT(ltPattern.isValid());
currentLinetypePattern = ltPattern;
}
double RExporter::exportLine(const RLine& line, double offset) {
double ret = RNANDOUBLE;
if (!line.isValid()) {
return ret;
}
double length = line.getLength();
if (length>1e100 || length<RS::PointTolerance) {
return ret;
}
double angle = line.getAngle();
// continuous line or
// we are in draft mode or
// QCAD is configured to show screen based line patterns
if (draftMode || screenBasedLinetypes || twoColorSelectedMode) {
exportLineSegment(line, angle);
return ret;
}
RLinetypePattern p = getLinetypePattern();
if (!p.isValid() || p.getNumDashes() <= 1) {
exportLineSegment(line, angle);
return ret;
}
p.scale(getLineTypePatternScale(p));
double patternLength = p.getPatternLength();
// avoid huge number of small segments due to very fine
// pattern or long lines:
if (patternLength<RS::PointTolerance || length / patternLength > RSettings::getDashThreshold()) {
exportLineSegment(line, angle);
return ret;
}
RVector* vp = NULL;
vp = new RVector[p.getNumDashes()];
for (int i = 0; i < p.getNumDashes(); ++i) {
vp[i] = RVector(cos(angle) * fabs(p.getDashLengthAt(i)),
sin(angle) * fabs(p.getDashLengthAt(i)));
}
if (RMath::isNaN(offset)) {
offset = p.getPatternOffset(length);
}
else {
double num = ceil(offset / patternLength);
offset -= num * patternLength;
}
bool done = false;
int i = 0;
RVector cursor(line.getStartPoint() + RVector::createPolar(offset, angle));
double total = offset;
double nextTotal;
bool isGap = false;
RLine dash;
do {
double dashLength = p.getDashLengthAt(i);
nextTotal = total + fabs(dashLength);
//qDebug() << "total: " << total;
//qDebug() << "nextTotal: " << nextTotal;
// dash, no gap. note that a dash can have a length of 0.0 (point):
if (dashLength > -RS::PointTolerance) {
isGap = false;
}
// gap:
else {
isGap = true;
}
// check if we're on the line already
// (since we might start before the line due to pattern offset):
if (nextTotal > 0.0) {
dash = RLine(cursor, cursor + vp[i]);
if (!isGap) {
// fist part is gap, then dash
ret = -nextTotal;
}
else {
// fist part is dash, then gap
ret = nextTotal;
}
// shorten at start of line:
if (total < 0.0 /*&& nextTotal > 0.0*/) {
dash.startPoint = line.startPoint;
ret = RNANDOUBLE;
}
// shorten at end of line:
if (/*total < length &&*/ nextTotal >= length - 1.0e-6) {
dash.endPoint = line.endPoint;
ret = RINFDOUBLE;
}
if (!isGap) {
exportLineSegment(dash, angle);
ret = nextTotal;
}
}
cursor += vp[i];
total = nextTotal;
done = total > length;
// export shape (zigzag, text, etc.) at end of dash / gap:
if (p.hasShapeAt(i)) {
QList<RPainterPath> pps = p.getShapeAt(i);
exportLinetypeShape(pps, line, total, length, angle, cursor);
}
++i;
if (i >= p.getNumDashes()) {
i = 0;
}
} while (!done);
delete[] vp;
return ret;
}
void RExporter::exportArc(const RArc& arc, double offset) {
if (!arc.isValid()) {
return;
}
RLinetypePattern p = getLinetypePattern();
if (getEntity() == NULL || !p.isValid() || p.getNumDashes() == 1 || draftMode || screenBasedLinetypes) {
exportArcSegment(arc);
return;
}
RArc normalArc = arc;
if (arc.isReversed()) {
normalArc.reverse();
}
if (normalArc.radius < 1.0e-12) {
return;
}
p.scale(getPatternFactor());
double length = normalArc.getLength();
double patternLength = p.getPatternLength();
// avoid huge number of small segments due to very fine
// pattern or long lines:
if (patternLength<RS::PointTolerance || length / patternLength > 5000) {
exportArcSegment(arc);
return;
}
double* vp = NULL;
vp = new double[p.getNumDashes()];
for (int i = 0; i < p.getNumDashes(); ++i) {
vp[i] = fabs(p.getDashLengthAt(i)) / normalArc.radius;
}
if (RMath::isNaN(offset)) {
offset = getPatternOffset(length, p);
}
QList<RArc> arcSegments;
bool done = false;
int i = 0;
double cursor = normalArc.getStartAngle() + offset / normalArc.radius;
double total = offset;
bool dashFound = false;
bool gapFound = false;
double a1 = normalArc.getStartAngle();
double a2;
do {
if (dashFound && !gapFound) {
if (total + fabs(p.getDashLengthAt(i)) >= length - 1.0e-6) {
arcSegments.append(RArc(normalArc.getCenter(), normalArc.getRadius(), a1, normalArc.getEndAngle()));
break;
}
arcSegments.append(RArc(normalArc.getCenter(), normalArc.getRadius(), a1, a2));
}
if (p.getDashLengthAt(i) > 0) {
// dash, no gap
if (total + p.getDashLengthAt(i) > 0) {
a1 = cursor;
if (total < 0 || !dashFound) {
a1 = normalArc.startAngle;
}
a2 = cursor + vp[i];
if (fabs(a2 - normalArc.getStartAngle()) > 1.0e-6) {
dashFound = true;
}
}
gapFound = false;
} else {
gapFound = true;
}
cursor += vp[i];
total += fabs(p.getDashLengthAt(i));
done = total > length;
++i;
if (i >= p.getNumDashes()) {
i = 0;
}
} while (!done);
if (!gapFound || !dashFound) {
if (total + fabs(p.getDashLengthAt(i)) >= length - 1.0e-6) {
arcSegments.append(RArc(normalArc.getCenter(), normalArc.getRadius(), a1, normalArc.getEndAngle()));
} else {
arcSegments.append(RArc(normalArc.getCenter(), normalArc.getRadius(), a1, a2));
}
}
if (arc.isReversed()) {
for (int i=arcSegments.length()-1; i>=0; i--) {
arcSegments[i].reverse();
exportArcSegment(arcSegments[i]);
}
}
else {
for (int i=0; i<arcSegments.length(); i++) {
exportArcSegment(arcSegments[i]);
}
}
delete[] vp;
}
void RExporter::exportArc(const RArc& arc, double offset) {
if (!arc.isValid()) {
return;
}
if (getEntity() == NULL || draftMode || screenBasedLinetypes || twoColorSelectedMode) {
exportArcSegment(arc);
return;
}
RLinetypePattern p = getLinetypePattern();
if (!p.isValid() || p.getNumDashes() <= 1) {
exportArcSegment(arc);
return;
}
p.scale(getLineTypePatternScale(p));
double patternLength = p.getPatternLength();
if (patternLength<RS::PointTolerance || arc.getLength() / patternLength > RSettings::getDashThreshold()) {
exportArcSegment(arc);
return;
}
RArc normalArc = arc;
if (arc.isReversed()) {
normalArc.reverse();
}
if (normalArc.radius < 1.0e-12) {
return;
}
RArcExporter(*this, arc, offset);
/*
p.scale(getLineTypePatternScale(p));
double length = normalArc.getLength();
double patternLength = p.getPatternLength();
// avoid huge number of small segments due to very fine
// pattern or long lines:
if (patternLength<RS::PointTolerance || length / patternLength > 5000) {
exportArcSegment(arc);
return;
}
double* vp = NULL;
vp = new double[p.getNumDashes()];
for (int i = 0; i < p.getNumDashes(); ++i) {
vp[i] = fabs(p.getDashLengthAt(i)) / normalArc.radius;
}
//bool optimizeEnds = false;
if (RMath::isNaN(offset)) {
offset = p.getPatternOffset(length);
//optimizeEnds = true;
}
QList<RArc> arcSegments;
bool done = false;
int i = 0;
double cursor = normalArc.getStartAngle() + offset / normalArc.radius;
double total = offset;
bool dashFound = false;
bool gapFound = false;
double a1 = normalArc.getStartAngle();
double a2 = 0.0;
do {
if (dashFound && !gapFound) {
if (total + fabs(p.getDashLengthAt(i)) >= length - 1.0e-6) {
arcSegments.append(RArc(normalArc.getCenter(), normalArc.getRadius(), a1, normalArc.getEndAngle()));
break;
}
arcSegments.append(RArc(normalArc.getCenter(), normalArc.getRadius(), a1, a2));
}
if (p.getDashLengthAt(i) >= 0.0) {
// dash, no gap
if (total + p.getDashLengthAt(i) >= 0.0) {
a1 = cursor;
if (total < 0.0 || !dashFound) {
a1 = normalArc.startAngle;
}
a2 = cursor + vp[i];
if (fabs(a2 - normalArc.getStartAngle()) > 1.0e-6) {
dashFound = true;
}
}
gapFound = false;
} else {
gapFound = true;
}
cursor += vp[i];
total += fabs(p.getDashLengthAt(i));
done = total > length;
if (!done && total>0.0) {
// handle shape at end of dash / gap:
if (p.hasShapeAt(i)) {
QList<RPainterPath> pps = p.getShapeAt(i);
// RVector min = RPainterPath::getMinList(pps);
// RVector max = RPainterPath::getMaxList(pps);
RPainterPath::rotateList(pps, cursor+M_PI/2);
RPainterPath::translateList(pps, normalArc.getPointAtAngle(cursor));
exportPainterPaths(pps);
}
}
++i;
if (i >= p.getNumDashes()) {
i = 0;
}
} while (!done);
if (!gapFound || !dashFound) {
if (total + fabs(p.getDashLengthAt(i)) >= length - 1.0e-6) {
arcSegments.append(RArc(normalArc.getCenter(), normalArc.getRadius(), a1, normalArc.getEndAngle()));
} else {
arcSegments.append(RArc(normalArc.getCenter(), normalArc.getRadius(), a1, a2));
}
}
if (arc.isReversed()) {
for (int i=arcSegments.length()-1; i>=0; i--) {
arcSegments[i].reverse();
exportArcSegment(arcSegments[i], true);
}
}
else {
for (int i=0; i<arcSegments.length(); i++) {
exportArcSegment(arcSegments[i], true);
}
}
delete[] vp;
*/
}
