RelativePoint::RelativePoint (const String& s)
{
String::CharPointerType text (s.getCharPointer());
x = RelativeCoordinate (Expression::parse (text));
RelativePointHelpers::skipComma (text);
y = RelativeCoordinate (Expression::parse (text));
}
bool getIndentForCurrentBlock (CodeDocument::Position pos, const String& tab,
String& blockIndent, String& lastLineIndent)
{
int braceCount = 0;
bool indentFound = false;
while (pos.getLineNumber() > 0)
{
pos = pos.movedByLines (-1);
const String line (pos.getLineText());
const String trimmedLine (line.trimStart());
braceCount += getBraceCount (trimmedLine.getCharPointer());
if (braceCount > 0)
{
blockIndent = getLeadingWhitespace (line);
if (! indentFound)
lastLineIndent = blockIndent + tab;
return true;
}
if ((! indentFound) && trimmedLine.isNotEmpty())
{
indentFound = true;
lastLineIndent = getLeadingWhitespace (line);
}
}
return false;
}
//==============================================================================
void SystemClipboard::copyTextToClipboard (const String& text)
{
if (OpenClipboard (0) != 0)
{
if (EmptyClipboard() != 0)
{
const int bytesNeeded = CharPointer_UTF16::getBytesRequiredFor (text.getCharPointer()) + 4;
if (bytesNeeded > 0)
{
HGLOBAL bufH = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE | GMEM_ZEROINIT, bytesNeeded + sizeof (WCHAR));
if (bufH != 0)
{
WCHAR* const data = static_cast <WCHAR*> (GlobalLock (bufH));
text.copyToUTF16 (data, bytesNeeded);
GlobalUnlock (bufH);
SetClipboardData (CF_UNICODETEXT, bufH);
}
}
}
CloseClipboard();
}
}
static void createLines (Array <CodeDocumentLine*>& newLines, const String& text)
{
String::CharPointerType t (text.getCharPointer());
int charNumInFile = 0;
bool finished = false;
while (! (finished || t.isEmpty()))
{
String::CharPointerType startOfLine (t);
int startOfLineInFile = charNumInFile;
int lineLength = 0;
int numNewLineChars = 0;
for (;;)
{
const juce_wchar c = t.getAndAdvance();
if (c == 0)
{
finished = true;
break;
}
++charNumInFile;
++lineLength;
if (c == '\r')
{
++numNewLineChars;
if (*t == '\n')
{
++t;
++charNumInFile;
++lineLength;
++numNewLineChars;
}
break;
}
if (c == '\n')
{
++numNewLineChars;
break;
}
}
newLines.add (new CodeDocumentLine (startOfLine, lineLength,
numNewLineChars, startOfLineInFile));
}
jassert (charNumInFile == text.length());
}
String simplifyPath (const String& path)
{
#if JUCE_WINDOWS
if (path.contains ("\\..\\") || path.contains ("/../"))
#else
if (path.contains ("/../"))
#endif
return simplifyPath (path.getCharPointer());
return path;
}
//==============================================================================
String StringArray::joinIntoString (const String& separator, int start, int numberToJoin) const
{
const int last = (numberToJoin < 0) ? size()
: jmin (size(), start + numberToJoin);
if (start < 0)
start = 0;
if (start >= last)
return String::empty;
if (start == last - 1)
return strings.getReference (start);
const size_t separatorBytes = separator.getCharPointer().sizeInBytes() - sizeof (String::CharPointerType::CharType);
size_t bytesNeeded = separatorBytes * (last - start - 1);
for (int i = start; i < last; ++i)
bytesNeeded += strings.getReference(i).getCharPointer().sizeInBytes() - sizeof (String::CharPointerType::CharType);
String result;
result.preallocateBytes (bytesNeeded);
String::CharPointerType dest (result.getCharPointer());
while (start < last)
{
const String& s = strings.getReference (start);
if (! s.isEmpty())
dest.writeAll (s.getCharPointer());
if (++start < last && separatorBytes > 0)
dest.writeAll (separator.getCharPointer());
}
dest.writeNull();
return result;
}
int StringArray::addTokens (const String& text, const String& breakCharacters, const String& quoteCharacters)
{
int num = 0;
String::CharPointerType t (text.getCharPointer());
if (! t.isEmpty())
{
for (;;)
{
String::CharPointerType tokenEnd (CharacterFunctions::findEndOfToken (t,
breakCharacters.getCharPointer(),
quoteCharacters.getCharPointer()));
add (String (t, tokenEnd));
++num;
if (tokenEnd.isEmpty())
break;
t = ++tokenEnd;
}
}
return num;
}
XmlElement* XmlDocument::getDocumentElement (const bool onlyReadOuterDocumentElement)
{
String textToParse (originalText);
if (textToParse.isEmpty() && inputSource != nullptr)
{
ScopedPointer <InputStream> in (inputSource->createInputStream());
if (in != nullptr)
{
MemoryOutputStream data;
data.writeFromInputStream (*in, onlyReadOuterDocumentElement ? 8192 : -1);
textToParse = data.toString();
if (! onlyReadOuterDocumentElement)
originalText = textToParse;
}
}
input = textToParse.getCharPointer();
lastError = String::empty;
errorOccurred = false;
outOfData = false;
needToLoadDTD = true;
if (textToParse.isEmpty())
{
lastError = "not enough input";
}
else
{
skipHeader();
if (input.getAddress() != nullptr)
{
ScopedPointer <XmlElement> result (readNextElement (! onlyReadOuterDocumentElement));
if (! errorOccurred)
return result.release();
}
else
{
lastError = "incorrect xml header";
}
}
return nullptr;
}
//==============================================================================
StringPairArray parsePreprocessorDefs (const String& text)
{
StringPairArray result;
String::CharPointerType s (text.getCharPointer());
while (! s.isEmpty())
{
String token, value;
s = s.findEndOfWhitespace();
while ((! s.isEmpty()) && *s != '=' && ! s.isWhitespace())
token << s.getAndAdvance();
s = s.findEndOfWhitespace();
if (*s == '=')
{
++s;
while ((! s.isEmpty()) && *s == ' ')
++s;
while ((! s.isEmpty()) && ! s.isWhitespace())
{
if (*s == ',')
{
++s;
break;
}
if (*s == '\\' && (s[1] == ' ' || s[1] == ','))
++s;
value << s.getAndAdvance();
}
}
if (token.isNotEmpty())
result.set (token, value);
}
return result;
}
void GlyphArrangement::addCurtailedLineOfText (const Font& font,
const String& text,
const float xOffset,
const float yOffset,
const float maxWidthPixels,
const bool useEllipsis)
{
if (text.isNotEmpty())
{
Array <int> newGlyphs;
Array <float> xOffsets;
font.getGlyphPositions (text, newGlyphs, xOffsets);
const int textLen = newGlyphs.size();
glyphs.ensureStorageAllocated (glyphs.size() + textLen);
String::CharPointerType t (text.getCharPointer());
for (int i = 0; i < textLen; ++i)
{
const float thisX = xOffsets.getUnchecked (i);
const float nextX = xOffsets.getUnchecked (i + 1);
if (nextX > maxWidthPixels + 1.0f)
{
// curtail the string if it's too wide..
if (useEllipsis && textLen > 3 && glyphs.size() >= 3)
insertEllipsis (font, xOffset + maxWidthPixels, 0, glyphs.size());
break;
}
else
{
const bool isWhitespace = t.isWhitespace();
glyphs.add (new PositionedGlyph (font, t.getAndAdvance(),
newGlyphs.getUnchecked(i),
xOffset + thisX, yOffset,
nextX - thisX, isWhitespace));
}
}
}
}
int StringArray::addLines (const String& sourceText)
{
int numLines = 0;
String::CharPointerType text (sourceText.getCharPointer());
bool finished = text.isEmpty();
while (! finished)
{
String::CharPointerType startOfLine (text);
size_t numChars = 0;
for (;;)
{
const juce_wchar c = text.getAndAdvance();
if (c == 0)
{
finished = true;
break;
}
if (c == '\n')
break;
if (c == '\r')
{
if (*text == '\n')
++text;
break;
}
++numChars;
}
add (String (startOfLine, numChars));
++numLines;
}
return numLines;
}
void getGlyphPositions (const String& text, Array<int>& glyphs, Array<float>& xOffsets)
{
JNIEnv* env = getEnv();
const int numChars = text.length();
jfloatArray widths = env->NewFloatArray (numChars);
const int numDone = paint.callIntMethod (Paint.getTextWidths, javaString (text).get(), widths);
HeapBlock<jfloat> localWidths (numDone);
env->GetFloatArrayRegion (widths, 0, numDone, localWidths);
env->DeleteLocalRef (widths);
String::CharPointerType s (text.getCharPointer());
xOffsets.add (0);
float x = 0;
for (int i = 0; i < numDone; ++i)
{
glyphs.add ((int) s.getAndAdvance());
x += localWidths[i];
xOffsets.add (x * referenceFontToUnits);
}
}
void XmlDocument::readChildElements (XmlElement& parent)
{
LinkedListPointer<XmlElement>::Appender childAppender (parent.firstChildElement);
for (;;)
{
const String::CharPointerType preWhitespaceInput (input);
skipNextWhiteSpace();
if (outOfData)
{
setLastError ("unmatched tags", false);
break;
}
if (*input == '<')
{
const juce_wchar c1 = input[1];
if (c1 == '/')
{
// our close tag..
const int closeTag = input.indexOf ((juce_wchar) '>');
if (closeTag >= 0)
input += closeTag + 1;
break;
}
if (c1 == '!' && CharacterFunctions::compareUpTo (input + 2, CharPointer_ASCII ("[CDATA["), 7) == 0)
{
input += 9;
const String::CharPointerType inputStart (input);
for (;;)
{
const juce_wchar c0 = *input;
if (c0 == 0)
{
setLastError ("unterminated CDATA section", false);
outOfData = true;
break;
}
else if (c0 == ']'
&& input[1] == ']'
&& input[2] == '>')
{
childAppender.append (XmlElement::createTextElement (String (inputStart, input)));
input += 3;
break;
}
++input;
}
}
else
{
// this is some other element, so parse and add it..
if (XmlElement* const n = readNextElement (true))
childAppender.append (n);
else
break;
}
}
else // must be a character block
{
input = preWhitespaceInput; // roll back to include the leading whitespace
String textElementContent;
for (;;)
{
const juce_wchar c = *input;
if (c == '<')
{
if (input[1] == '!' && input[2] == '-' && input[3] == '-')
{
input += 4;
const int closeComment = input.indexOf (CharPointer_ASCII ("-->"));
if (closeComment < 0)
{
setLastError ("unterminated comment", false);
outOfData = true;
return;
}
input += closeComment + 3;
continue;
}
break;
}
if (c == 0)
{
setLastError ("unmatched tags", false);
outOfData = true;
return;
}
if (c == '&')
{
String entity;
readEntity (entity);
if (entity.startsWithChar ('<') && entity [1] != 0)
{
const String::CharPointerType oldInput (input);
const bool oldOutOfData = outOfData;
input = entity.getCharPointer();
outOfData = false;
for (;;)
{
XmlElement* const n = readNextElement (true);
if (n == nullptr)
break;
childAppender.append (n);
}
input = oldInput;
outOfData = oldOutOfData;
}
else
{
textElementContent += entity;
}
}
else
{
const String::CharPointerType start (input);
for (;;)
{
const juce_wchar nextChar = *input;
if (nextChar == '<' || nextChar == '&')
break;
if (nextChar == 0)
{
setLastError ("unmatched tags", false);
outOfData = true;
return;
}
++input;
}
textElementContent.appendCharPointer (start, input);
}
}
if ((! ignoreEmptyTextElements) || textElementContent.containsNonWhitespaceChars())
childAppender.append (XmlElement::createTextElement (textElementContent));
}
}
}
String getLeadingWhitespace (String line)
{
line = line.removeCharacters ("\r\n");
const String::CharPointerType endOfLeadingWS (line.getCharPointer().findEndOfWhitespace());
return String (line.getCharPointer(), endOfLeadingWS);
}
//==============================================================================
Drawable* parseSVGElement (const XmlPath& xml)
{
if (! xml->hasTagNameIgnoringNamespace ("svg"))
return nullptr;
DrawableComposite* const drawable = new DrawableComposite();
setCommonAttributes (*drawable, xml);
SVGState newState (*this);
if (xml->hasAttribute ("transform"))
newState.addTransform (xml);
newState.elementX = getCoordLength (xml->getStringAttribute ("x", String (newState.elementX)), viewBoxW);
newState.elementY = getCoordLength (xml->getStringAttribute ("y", String (newState.elementY)), viewBoxH);
newState.width = getCoordLength (xml->getStringAttribute ("width", String (newState.width)), viewBoxW);
newState.height = getCoordLength (xml->getStringAttribute ("height", String (newState.height)), viewBoxH);
if (newState.width <= 0) newState.width = 100;
if (newState.height <= 0) newState.height = 100;
Point<float> viewboxXY;
if (xml->hasAttribute ("viewBox"))
{
const String viewBoxAtt (xml->getStringAttribute ("viewBox"));
String::CharPointerType viewParams (viewBoxAtt.getCharPointer());
Point<float> vwh;
if (parseCoords (viewParams, viewboxXY, true)
&& parseCoords (viewParams, vwh, true)
&& vwh.x > 0
&& vwh.y > 0)
{
newState.viewBoxW = vwh.x;
newState.viewBoxH = vwh.y;
const int placementFlags = parsePlacementFlags (xml->getStringAttribute ("preserveAspectRatio").trim());
if (placementFlags != 0)
newState.transform = RectanglePlacement (placementFlags)
.getTransformToFit (Rectangle<float> (viewboxXY.x, viewboxXY.y, vwh.x, vwh.y),
Rectangle<float> (newState.width, newState.height))
.followedBy (newState.transform);
}
}
else
{
if (viewBoxW == 0) newState.viewBoxW = newState.width;
if (viewBoxH == 0) newState.viewBoxH = newState.height;
}
newState.parseSubElements (xml, *drawable);
drawable->setContentArea (RelativeRectangle (RelativeCoordinate (viewboxXY.x),
RelativeCoordinate (viewboxXY.x + newState.viewBoxW),
RelativeCoordinate (viewboxXY.y),
RelativeCoordinate (viewboxXY.y + newState.viewBoxH)));
drawable->resetBoundingBoxToContentArea();
return drawable;
}
StringRegion (const String& s) noexcept
: text (s.getCharPointer()), start (0), length (s.length()) {}
//==============================================================================
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;
}
}
//==============================================================================
Drawable* parseSVGElement (const XmlElement& xml)
{
if (! xml.hasTagNameIgnoringNamespace ("svg"))
return nullptr;
DrawableComposite* const drawable = new DrawableComposite();
drawable->setName (xml.getStringAttribute ("id"));
SVGState newState (*this);
if (xml.hasAttribute ("transform"))
newState.addTransform (xml);
newState.elementX = getCoordLength (xml.getStringAttribute ("x", String (newState.elementX)), viewBoxW);
newState.elementY = getCoordLength (xml.getStringAttribute ("y", String (newState.elementY)), viewBoxH);
newState.width = getCoordLength (xml.getStringAttribute ("width", String (newState.width)), viewBoxW);
newState.height = getCoordLength (xml.getStringAttribute ("height", String (newState.height)), viewBoxH);
if (newState.width <= 0) newState.width = 100;
if (newState.height <= 0) newState.height = 100;
if (xml.hasAttribute ("viewBox"))
{
const String viewBoxAtt (xml.getStringAttribute ("viewBox"));
String::CharPointerType viewParams (viewBoxAtt.getCharPointer());
Point<float> vxy, vwh;
if (parseCoords (viewParams, vxy, true)
&& parseCoords (viewParams, vwh, true)
&& vwh.x > 0
&& vwh.y > 0)
{
newState.viewBoxW = vwh.x;
newState.viewBoxH = vwh.y;
int placementFlags = 0;
const String aspect (xml.getStringAttribute ("preserveAspectRatio"));
if (aspect.containsIgnoreCase ("none"))
{
placementFlags = RectanglePlacement::stretchToFit;
}
else
{
if (aspect.containsIgnoreCase ("slice")) placementFlags |= RectanglePlacement::fillDestination;
if (aspect.containsIgnoreCase ("xMin")) placementFlags |= RectanglePlacement::xLeft;
else if (aspect.containsIgnoreCase ("xMax")) placementFlags |= RectanglePlacement::xRight;
else placementFlags |= RectanglePlacement::xMid;
if (aspect.containsIgnoreCase ("yMin")) placementFlags |= RectanglePlacement::yTop;
else if (aspect.containsIgnoreCase ("yMax")) placementFlags |= RectanglePlacement::yBottom;
else placementFlags |= RectanglePlacement::yMid;
}
newState.transform = RectanglePlacement (placementFlags)
.getTransformToFit (Rectangle<float> (vxy.x, vxy.y, vwh.x, vwh.y),
Rectangle<float> (newState.width, newState.height))
.followedBy (newState.transform);
}
}
else
{
if (viewBoxW == 0) newState.viewBoxW = newState.width;
if (viewBoxH == 0) newState.viewBoxH = newState.height;
}
newState.parseSubElements (xml, *drawable);
drawable->setContentArea (RelativeRectangle (Rectangle<float> (newState.viewBoxW, newState.viewBoxH)));
drawable->resetBoundingBoxToContentArea();
return drawable;
}