void SVGPolyParser::parsePoints(const DeprecatedString &s) const
{
if (!s.isEmpty()) {
DeprecatedString pointData = s;
pointData = pointData.replace(',', ' ');
pointData = pointData.simplifyWhiteSpace();
const char* currSegment = pointData.latin1();
const char* eoString = pointData.latin1() + pointData.length();
int segmentNum = 0;
while (currSegment < eoString) {
const char* prevSegment = currSegment;
double xPos = 0;
currSegment = parseCoord(currSegment, xPos);
if (currSegment == prevSegment)
break;
if (*currSegment == ',' || *currSegment == ' ')
currSegment++;
prevSegment = currSegment;
double yPos = 0;
currSegment = parseCoord(currSegment, yPos);
if (currSegment == prevSegment)
break;
svgPolyTo(xPos, yPos, segmentNum++);
if (*currSegment == ' ')
currSegment++;
}
}
}
STATUS _minParse(char* inputBuffer, min_parser_data* result) {
currentBuffer = inputBuffer;
for (char i=0;i < MIN_PARSER_INTERNAL_BUFFER_SIZE;i++) {
char c = inputBuffer[i];
switch(state) {
case SEARCHING_HEADER: searchHeader(c); break;
case SKIPPING_TIME: skipTime(c, i); break;
case PARSING_STATUS: parseStatus(c, i); break;
case PARSING_LAT_COORD: parseCoord(c, i, &(result->latCoord), PARSING_LAT_HEM); break;
case PARSING_LAT_HEM: parseHem(c, i, &(result->latHem), PARSING_LONG_COORD); break;
case PARSING_LONG_COORD: parseCoord(c, i, &(result->longCoord), PARSING_LONG_HEM); break;
case PARSING_LONG_HEM: parseHem(c, i, &(result->longHem), DONE); break;
case DONE: status = 1; break;
default: state = SEARCHING_HEADER; break;
}
}
memcpy(previousBuffer, currentBuffer, MIN_PARSER_INTERNAL_BUFFER_SIZE);
return status;
}
bool parseGpsText(const QString &gps_text, double *latitude, double *longitude)
{
static const QString POS_LAT = QString("+N") + translate("gettextFromC", "N");
static const QString NEG_LAT = QString("-S") + translate("gettextFromC", "S");
static const QString POS_LON = QString("+E") + translate("gettextFromC", "E");
static const QString NEG_LON = QString("-W") + translate("gettextFromC", "W");
//remove the useless spaces (but keep the ones separating numbers)
static const QRegExp SPACE_CLEANER("\\s*([" + POS_LAT + NEG_LAT + POS_LON +
NEG_LON + DEGREE_SIGNS + "'\"\\s])\\s*");
const QString normalized = gps_text.trimmed().toUpper().replace(SPACE_CLEANER, "\\1");
if (normalized.isEmpty()) {
*latitude = 0.0;
*longitude = 0.0;
return true;
}
if (parseSpecialCoords(normalized, *latitude, *longitude))
return true;
int pos = 0;
return parseCoord(normalized, pos, POS_LAT, NEG_LAT, POS_LON + NEG_LON, *latitude) &&
parseCoord(normalized, pos, POS_LON, NEG_LON, "", *longitude) &&
pos == normalized.size();
}
//==============================================================================
void parsePathString (Path& path, const String& pathString) const
{
String::CharPointerType d (pathString.getCharPointer().findEndOfWhitespace());
Point<float> subpathStart, last, last2, p1, p2, p3;
juce_wchar lastCommandChar = 0;
bool isRelative = true;
bool carryOn = true;
const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");
while (! d.isEmpty())
{
if (validCommandChars.indexOf (*d) >= 0)
{
lastCommandChar = d.getAndAdvance();
isRelative = (lastCommandChar >= 'a' && lastCommandChar <= 'z');
}
switch (lastCommandChar)
{
case 'M':
case 'm':
case 'L':
case 'l':
if (parseCoordsOrSkip (d, p1, false))
{
if (isRelative)
p1 += last;
if (lastCommandChar == 'M' || lastCommandChar == 'm')
{
subpathStart = p1;
path.startNewSubPath (p1);
lastCommandChar = 'l';
}
else
path.lineTo (p1);
last2 = last;
last = p1;
}
break;
case 'H':
case 'h':
if (parseCoord (d, p1.x, false, true))
{
if (isRelative)
p1.x += last.x;
path.lineTo (p1.x, last.y);
last2.x = last.x;
last.x = p1.x;
}
else
{
++d;
}
break;
case 'V':
case 'v':
if (parseCoord (d, p1.y, false, false))
{
if (isRelative)
p1.y += last.y;
path.lineTo (last.x, p1.y);
last2.y = last.y;
last.y = p1.y;
}
else
{
++d;
}
break;
case 'C':
case 'c':
if (parseCoordsOrSkip (d, p1, false)
&& parseCoordsOrSkip (d, p2, false)
&& parseCoordsOrSkip (d, p3, false))
{
if (isRelative)
{
p1 += last;
p2 += last;
p3 += last;
}
path.cubicTo (p1, p2, p3);
last2 = p2;
last = p3;
}
break;
case 'S':
case 's':
if (parseCoordsOrSkip (d, p1, false)
&& parseCoordsOrSkip (d, p3, false))
{
if (isRelative)
{
p1 += last;
p3 += last;
}
p2 = last + (last - last2);
path.cubicTo (p2, p1, p3);
last2 = p1;
last = p3;
}
break;
case 'Q':
case 'q':
if (parseCoordsOrSkip (d, p1, false)
&& parseCoordsOrSkip (d, p2, false))
{
if (isRelative)
{
p1 += last;
p2 += last;
}
path.quadraticTo (p1, p2);
last2 = p1;
last = p2;
}
break;
case 'T':
case 't':
if (parseCoordsOrSkip (d, p1, false))
{
if (isRelative)
p1 += last;
p2 = last + (last - last2);
path.quadraticTo (p2, p1);
last2 = p2;
last = p1;
}
break;
case 'A':
case 'a':
if (parseCoordsOrSkip (d, p1, false))
{
String num;
if (parseNextNumber (d, num, false))
{
const float angle = num.getFloatValue() * (180.0f / float_Pi);
if (parseNextNumber (d, num, false))
{
const bool largeArc = num.getIntValue() != 0;
if (parseNextNumber (d, num, false))
{
const bool sweep = num.getIntValue() != 0;
if (parseCoordsOrSkip (d, p2, false))
{
if (isRelative)
p2 += last;
if (last != p2)
{
double centreX, centreY, startAngle, deltaAngle;
double rx = p1.x, ry = p1.y;
endpointToCentreParameters (last.x, last.y, p2.x, p2.y,
angle, largeArc, sweep,
rx, ry, centreX, centreY,
startAngle, deltaAngle);
path.addCentredArc ((float) centreX, (float) centreY,
(float) rx, (float) ry,
angle, (float) startAngle, (float) (startAngle + deltaAngle),
false);
path.lineTo (p2);
}
last2 = last;
last = p2;
}
}
}
}
}
break;
case 'Z':
case 'z':
path.closeSubPath();
last = last2 = subpathStart;
d = d.findEndOfWhitespace();
lastCommandChar = 'M';
break;
default:
carryOn = false;
break;
}
if (! carryOn)
break;
}
// paths that finish back at their start position often seem to be
// left without a 'z', so need to be closed explicitly..
if (path.getCurrentPosition() == subpathStart)
path.closeSubPath();
}
void
SVGPathParser::parseSVG( const DeprecatedString &s, bool process )
{
if(!s.isEmpty())
{
DeprecatedString d = s;
d = d.replace(',', ' ');
d = d.simplifyWhiteSpace();
const char *ptr = d.latin1();
const char *end = d.latin1() + d.length() + 1;
double contrlx, contrly, curx, cury, subpathx, subpathy, tox, toy, x1, y1, x2, y2, xc, yc;
double px1, py1, px2, py2, px3, py3;
bool relative, closed = true;
char command = *(ptr++), lastCommand = ' ';
subpathx = subpathy = curx = cury = contrlx = contrly = 0.0;
while( ptr < end )
{
if( *ptr == ' ' )
ptr++;
relative = false;
//std::cout << "Command : " << command << std::endl;
switch( command )
{
case 'm':
relative = true;
case 'M':
{
ptr = parseCoord( ptr, tox );
ptr = parseCoord( ptr, toy );
if( process )
{
subpathx = curx = relative ? curx + tox : tox;
subpathy = cury = relative ? cury + toy : toy;
svgMoveTo( curx, cury, closed );
}
else
svgMoveTo( tox, toy, closed, !relative );
closed = false;
break;
}
case 'l':
relative = true;
case 'L':
{
ptr = parseCoord( ptr, tox );
ptr = parseCoord( ptr, toy );
if( process )
{
curx = relative ? curx + tox : tox;
cury = relative ? cury + toy : toy;
svgLineTo( curx, cury );
}
else
svgLineTo( tox, toy, !relative );
break;
}
case 'h':
{
ptr = parseCoord( ptr, tox );
if( process )
{
curx = curx + tox;
svgLineTo( curx, cury );
}
else
svgLineToHorizontal( tox, false );
break;
}
case 'H':
{
ptr = parseCoord( ptr, tox );
if( process )
{
curx = tox;
svgLineTo( curx, cury );
}
else
svgLineToHorizontal( tox );
break;
}
case 'v':
{
ptr = parseCoord( ptr, toy );
if( process )
{
cury = cury + toy;
svgLineTo( curx, cury );
}
else
svgLineToVertical( toy, false );
break;
}
case 'V':
{
ptr = parseCoord( ptr, toy );
if( process )
{
cury = toy;
svgLineTo( curx, cury );
}
else
svgLineToVertical( toy );
break;
}
case 'z':
case 'Z':
{
// reset curx, cury for next path
if( process )
{
curx = subpathx;
cury = subpathy;
}
closed = true;
svgClosePath();
break;
}
case 'c':
relative = true;
case 'C':
{
ptr = parseCoord( ptr, x1 );
ptr = parseCoord( ptr, y1 );
ptr = parseCoord( ptr, x2 );
ptr = parseCoord( ptr, y2 );
ptr = parseCoord( ptr, tox );
ptr = parseCoord( ptr, toy );
if( process )
{
px1 = relative ? curx + x1 : x1;
py1 = relative ? cury + y1 : y1;
px2 = relative ? curx + x2 : x2;
py2 = relative ? cury + y2 : y2;
px3 = relative ? curx + tox : tox;
py3 = relative ? cury + toy : toy;
svgCurveToCubic( px1, py1, px2, py2, px3, py3 );
contrlx = relative ? curx + x2 : x2;
contrly = relative ? cury + y2 : y2;
curx = relative ? curx + tox : tox;
cury = relative ? cury + toy : toy;
}
else
svgCurveToCubic( x1, y1, x2, y2, tox, toy, !relative );
break;
}
case 's':
relative = true;
case 'S':
{
ptr = parseCoord( ptr, x2 );
ptr = parseCoord( ptr, y2 );
ptr = parseCoord( ptr, tox );
ptr = parseCoord( ptr, toy );
if(!(lastCommand == 'c' || lastCommand == 'C' ||
lastCommand == 's' || lastCommand == 'S')) {
contrlx = curx;
contrly = cury;
}
if( process )
{
px1 = 2 * curx - contrlx;
py1 = 2 * cury - contrly;
px2 = relative ? curx + x2 : x2;
py2 = relative ? cury + y2 : y2;
px3 = relative ? curx + tox : tox;
py3 = relative ? cury + toy : toy;
svgCurveToCubic( px1, py1, px2, py2, px3, py3 );
contrlx = relative ? curx + x2 : x2;
contrly = relative ? cury + y2 : y2;
curx = relative ? curx + tox : tox;
cury = relative ? cury + toy : toy;
}
else
svgCurveToCubicSmooth( x2, y2, tox, toy, !relative );
break;
}
case 'q':
relative = true;
case 'Q':
{
ptr = parseCoord( ptr, x1 );
ptr = parseCoord( ptr, y1 );
ptr = parseCoord( ptr, tox );
ptr = parseCoord( ptr, toy );
if( process )
{
px1 = relative ? (curx + 2 * (x1 + curx)) * (1.0 / 3.0) : (curx + 2 * x1) * (1.0 / 3.0);
py1 = relative ? (cury + 2 * (y1 + cury)) * (1.0 / 3.0) : (cury + 2 * y1) * (1.0 / 3.0);
px2 = relative ? ((curx + tox) + 2 * (x1 + curx)) * (1.0 / 3.0) : (tox + 2 * x1) * (1.0 / 3.0);
py2 = relative ? ((cury + toy) + 2 * (y1 + cury)) * (1.0 / 3.0) : (toy + 2 * y1) * (1.0 / 3.0);
px3 = relative ? curx + tox : tox;
py3 = relative ? cury + toy : toy;
svgCurveToCubic( px1, py1, px2, py2, px3, py3 );
contrlx = relative ? curx + x1 : x1;
contrly = relative ? cury + y1 : y1;
curx = relative ? curx + tox : tox;
cury = relative ? cury + toy : toy;
}
else
svgCurveToQuadratic( x1, y1, tox, toy, !relative );
break;
}
case 't':
relative = true;
case 'T':
{
ptr = parseCoord(ptr, tox);
ptr = parseCoord(ptr, toy);
if(!(lastCommand == 'q' || lastCommand == 'Q' ||
lastCommand == 't' || lastCommand == 'T')) {
contrlx = curx;
contrly = cury;
}
if( process )
{
xc = 2 * curx - contrlx;
yc = 2 * cury - contrly;
px1 = relative ? (curx + 2 * xc) * (1.0 / 3.0) : (curx + 2 * xc) * (1.0 / 3.0);
py1 = relative ? (cury + 2 * yc) * (1.0 / 3.0) : (cury + 2 * yc) * (1.0 / 3.0);
px2 = relative ? ((curx + tox) + 2 * xc) * (1.0 / 3.0) : (tox + 2 * xc) * (1.0 / 3.0);
py2 = relative ? ((cury + toy) + 2 * yc) * (1.0 / 3.0) : (toy + 2 * yc) * (1.0 / 3.0);
px3 = relative ? curx + tox : tox;
py3 = relative ? cury + toy : toy;
svgCurveToCubic( px1, py1, px2, py2, px3, py3 );
contrlx = xc;
contrly = yc;
curx = relative ? curx + tox : tox;
cury = relative ? cury + toy : toy;
}
else
svgCurveToQuadraticSmooth( tox, toy, !relative );
break;
}
case 'a':
relative = true;
case 'A':
{
bool largeArc, sweep;
double angle, rx, ry;
ptr = parseCoord( ptr, rx );
ptr = parseCoord( ptr, ry );
ptr = parseCoord( ptr, angle );
ptr = parseCoord( ptr, tox );
largeArc = tox == 1;
ptr = parseCoord( ptr, tox );
sweep = tox == 1;
ptr = parseCoord( ptr, tox );
ptr = parseCoord( ptr, toy );
// Spec: radii are nonnegative numbers
rx = fabs(rx);
ry = fabs(ry);
if( process )
calculateArc( relative, curx, cury, angle, tox, toy, rx, ry, largeArc, sweep );
else
svgArcTo( tox, toy, rx, ry, angle, largeArc, sweep, !relative );
break;
}
default:
// FIXME: An error should go to the JavaScript console, or the like.
return;
}
lastCommand = command;
if(*ptr == '+' || *ptr == '-' || (*ptr >= '0' && *ptr <= '9'))
{
// there are still coords in this command
if(command == 'M')
command = 'L';
else if(command == 'm')
command = 'l';
}
else
command = *(ptr++);
if( lastCommand != 'C' && lastCommand != 'c' &&
lastCommand != 'S' && lastCommand != 's' &&
lastCommand != 'Q' && lastCommand != 'q' &&
lastCommand != 'T' && lastCommand != 't' )
{
contrlx = curx;
contrly = cury;
}
}
}
}
