void StringArray::appendNumbersToDuplicates (bool ignoreCase,
bool appendNumberToFirstInstance,
CharPointer_UTF8 preNumberString,
CharPointer_UTF8 postNumberString)
{
if (preNumberString.getAddress() == nullptr)
preNumberString = CharPointer_UTF8 (" (");
if (postNumberString.getAddress() == nullptr)
postNumberString = CharPointer_UTF8 (")");
for (int i = 0; i < size() - 1; ++i)
{
auto& s = strings.getReference(i);
auto nextIndex = indexOf (s, ignoreCase, i + 1);
if (nextIndex >= 0)
{
auto original = s;
int number = 0;
if (appendNumberToFirstInstance)
s = original + String (preNumberString) + String (++number) + String (postNumberString);
else
++number;
while (nextIndex >= 0)
{
set (nextIndex, (*this)[nextIndex] + String (preNumberString) + String (++number) + String (postNumberString));
nextIndex = indexOf (original, ignoreCase, nextIndex + 1);
}
}
}
}
String MidiMessage::getTextFromTextMetaEvent() const
{
auto textData = reinterpret_cast<const char*> (getMetaEventData());
return String (CharPointer_UTF8 (textData),
CharPointer_UTF8 (textData + getMetaEventLength()));
}
File File::getSpecialLocation (const SpecialLocationType type)
{
switch (type)
{
case userHomeDirectory:
{
if (const char* homeDir = getenv ("HOME"))
return File (CharPointer_UTF8 (homeDir));
if (auto* pw = getpwuid (getuid()))
return File (CharPointer_UTF8 (pw->pw_dir));
return {};
}
case userDocumentsDirectory: return resolveXDGFolder ("XDG_DOCUMENTS_DIR", "~/Documents");
case userMusicDirectory: return resolveXDGFolder ("XDG_MUSIC_DIR", "~/Music");
case userMoviesDirectory: return resolveXDGFolder ("XDG_VIDEOS_DIR", "~/Videos");
case userPicturesDirectory: return resolveXDGFolder ("XDG_PICTURES_DIR", "~/Pictures");
case userDesktopDirectory: return resolveXDGFolder ("XDG_DESKTOP_DIR", "~/Desktop");
case userApplicationDataDirectory: return resolveXDGFolder ("XDG_CONFIG_HOME", "~/.config");
case commonDocumentsDirectory:
case commonApplicationDataDirectory: return File ("/opt");
case globalApplicationsDirectory: return File ("/usr");
case tempDirectory:
{
if (const char* tmpDir = getenv ("TMPDIR"))
return File (CharPointer_UTF8 (tmpDir));
return File ("/tmp");
}
case invokedExecutableFile:
if (juce_argv != nullptr && juce_argc > 0)
return File (CharPointer_UTF8 (juce_argv[0]));
// deliberate fall-through...
case currentExecutableFile:
case currentApplicationFile:
#if ! JUCE_STANDALONE_APPLICATION
return juce_getExecutableFile();
#endif
// deliberate fall-through if this is not a shared-library
case hostApplicationPath:
{
const File f ("/proc/self/exe");
return f.isSymbolicLink() ? f.getLinkedTarget() : juce_getExecutableFile();
}
default:
jassertfalse; // unknown type?
break;
}
return {};
}
void XmlDocument::skipHeader()
{
const int headerStart = input.indexOf (CharPointer_UTF8 ("<?xml"));
if (headerStart >= 0)
{
const int headerEnd = (input + headerStart).indexOf (CharPointer_UTF8 ("?>"));
if (headerEnd < 0)
return;
#if JUCE_DEBUG
const String header (input + headerStart, (size_t) (headerEnd - headerStart));
const String encoding (header.fromFirstOccurrenceOf ("encoding", false, true)
.fromFirstOccurrenceOf ("=", false, false)
.fromFirstOccurrenceOf ("\"", false, false)
.upToFirstOccurrenceOf ("\"", false, false).trim());
/* If you load an XML document with a non-UTF encoding type, it may have been
loaded wrongly.. Since all the files are read via the normal juce file streams,
they're treated as UTF-8, so by the time it gets to the parser, the encoding will
have been lost. Best plan is to stick to utf-8 or if you have specific files to
read, use your own code to convert them to a unicode String, and pass that to the
XML parser.
*/
jassert (encoding.isEmpty() || encoding.startsWithIgnoreCase ("utf-"));
#endif
input += headerEnd + 2;
}
skipNextWhiteSpace();
const int docTypeIndex = input.indexOf (CharPointer_UTF8 ("<!DOCTYPE"));
if (docTypeIndex < 0)
return;
input += docTypeIndex + 9;
const String::CharPointerType docType (input);
int n = 1;
while (n > 0)
{
const juce_wchar c = readNextChar();
if (outOfData)
return;
if (c == '<')
++n;
else if (c == '>')
--n;
}
dtdText = String (docType, (size_t) (input.getAddress() - (docType.getAddress() + 1))).trim();
}
File File::getSpecialLocation (const SpecialLocationType type)
{
switch (type)
{
case userHomeDirectory:
{
const char* homeDir = getenv ("HOME");
if (homeDir)
return File (CharPointer_UTF8 (homeDir));
if (struct passwd* const pw = getpwuid (getuid()))
return File (CharPointer_UTF8 (pw->pw_dir));
return File (CharPointer_UTF8 (homeDir));
}
case userDocumentsDirectory:
return resolveXDGFolder ("XDG_DOCUMENTS_DIR", "~");
case userMusicDirectory:
return resolveXDGFolder ("XDG_MUSIC_DIR", "~");
case userMoviesDirectory:
return resolveXDGFolder ("XDG_VIDEOS_DIR", "~");
case userPicturesDirectory:
return resolveXDGFolder ("XDG_PICTURES_DIR", "~");
case userDesktopDirectory:
return resolveXDGFolder ("XDG_DESKTOP_DIR", "~/Desktop");
case userApplicationDataDirectory:
return File ("~");
case commonDocumentsDirectory:
case commonApplicationDataDirectory:
return File ("/var");
case globalApplicationsDirectory:
return File ("/usr");
case tempDirectory:
{
File tmp ("/var/tmp");
if (! tmp.isDirectory())
{
tmp = "/tmp";
if (! tmp.isDirectory())
tmp = File::getCurrentWorkingDirectory();
}
return tmp;
}
default:
bassertfalse; // unknown type?
break;
}
return File::nonexistent ();
}
//==============================================================================
String SystemStats::getLogonName()
{
if (const char* user = getenv ("USER"))
return CharPointer_UTF8 (user);
if (struct passwd* const pw = getpwuid (getuid()))
return CharPointer_UTF8 (pw->pw_name);
return String();
}
void XmlDocument::skipNextWhiteSpace()
{
for (;;)
{
juce_wchar c = *input;
while (CharacterFunctions::isWhitespace (c))
c = *++input;
if (c == 0)
{
outOfData = true;
break;
}
else if (c == '<')
{
if (input[1] == '!'
&& input[2] == '-'
&& input[3] == '-')
{
input += 4;
const int closeComment = input.indexOf (CharPointer_UTF8 ("-->"));
if (closeComment < 0)
{
outOfData = true;
break;
}
input += closeComment + 3;
continue;
}
else if (input[1] == '?')
{
input += 2;
const int closeBracket = input.indexOf (CharPointer_UTF8 ("?>"));
if (closeBracket < 0)
{
outOfData = true;
break;
}
input += closeBracket + 2;
continue;
}
}
break;
}
}
void FilterGraph::mouseMove (const MouseEvent &event)
{
Point <int> mousePos = getMouseXYRelative();
int xPos = mousePos.getX();
float freq = xToFreq (xPos);
if (traceType == Magnitude)
{
float magnitude = (float) (filterVector [0].getResponse (freq).magnitudeValue);
for (int i = 1; i < numFilters; i++)
{
magnitude *= (float) (filterVector [i].getResponse (freq).magnitudeValue);
}
magnitude = 20 * log10 (magnitude);
setTooltip (String (freq, 1) + "Hz, " + String (magnitude, 1) + "dB");
}
if (traceType == Phase)
{
float phase = (float) (filterVector [0].getResponse (freq).phaseValue);
for (int i = 1; i < numFilters; i++)
{
phase += (float) (filterVector [i].getResponse (freq).phaseValue);
}
phase /= float_Pi;
setTooltip (String (freq, 1) + "Hz, " + String (phase, 2) + String (CharPointer_UTF8 ("\xcf\x80")) + "rad");
}
}
bool next (String& filenameFound,
bool* const isDir, bool* const isHidden, std::int64_t* const fileSize,
Time* const modTime, Time* const creationTime, bool* const isReadOnly)
{
if (dir != nullptr)
{
const char* wildcardUTF8 = nullptr;
for (;;)
{
struct dirent* const de = readdir (dir);
if (de == nullptr)
break;
if (wildcardUTF8 == nullptr)
wildcardUTF8 = wildCard.toUTF8();
if (fnmatch (wildcardUTF8, de->d_name, FNM_CASEFOLD) == 0)
{
filenameFound = CharPointer_UTF8 (de->d_name);
updateStatInfoForFile (parentDir + filenameFound, isDir, fileSize, modTime, creationTime, isReadOnly);
if (isHidden != nullptr)
*isHidden = filenameFound.startsWithChar ('.');
return true;
}
}
}
return false;
}
static String parseNameRecord (MemoryInputStream& input, const NameRecord& nameRecord,
const int64 directoryOffset, const int64 offsetOfStringStorage)
{
String result;
const int64 oldPos = input.getPosition();
input.setPosition (directoryOffset + offsetOfStringStorage + ByteOrder::swapIfLittleEndian (nameRecord.offsetFromStorageArea));
const int stringLength = (int) ByteOrder::swapIfLittleEndian (nameRecord.stringLength);
const int platformID = ByteOrder::swapIfLittleEndian (nameRecord.platformID);
if (platformID == 0 || platformID == 3)
{
const int numChars = stringLength / 2 + 1;
HeapBlock<uint16> buffer;
buffer.calloc (numChars + 1);
input.read (buffer, stringLength);
for (int i = 0; i < numChars; ++i)
buffer[i] = ByteOrder::swapIfLittleEndian (buffer[i]);
static_jassert (sizeof (CharPointer_UTF16::CharType) == sizeof (uint16));
result = CharPointer_UTF16 ((CharPointer_UTF16::CharType*) buffer.getData());
}
else
{
HeapBlock<char> buffer;
buffer.calloc (stringLength + 1);
input.read (buffer, stringLength);
result = CharPointer_UTF8 (buffer.getData());
}
input.setPosition (oldPos);
return result;
}
bool
LV2World::isPluginSupported (const LilvPlugin* plugin)
{
// Required features support
LilvNodes* nodes = lilv_plugin_get_required_features (plugin);
LILV_FOREACH (nodes, iter, nodes)
{
const LilvNode* node (lilv_nodes_get (nodes, iter));
if (! isFeatureSupported (CharPointer_UTF8 (lilv_node_as_uri (node)))) {
return false; // Feature not supported
}
}
lilv_nodes_free (nodes); nodes = nullptr;
// Check this plugin's port types are supported
const uint32 numPorts = lilv_plugin_get_num_ports (plugin);
for (uint32 i = 0; i < numPorts; ++i)
{
// const LilvPort* port (lilv_plugin_get_port_by_index (plugin, i));
// nothing here yet (or ever)
}
return true;
}
MainContentComponent::MainContentComponent()
: myFont (Typeface::createSystemTypefaceFor (BinaryData::myFont_ttf, BinaryData::myFont_ttfSize)),
myText (CharPointer_UTF8 ("H\xe2\x84\xae\xc5\x82\xc5\x82o W\xe2\x98\xba\xd2\x91\xc5\x82""d"))
{
myFont.setHeight (100.0f);
setSize (600, 400);
}
String
LV2Module::getClassLabel() const
{
if (const LilvPluginClass* klass = lilv_plugin_get_class (plugin))
if (const LilvNode* node = lilv_plugin_class_get_label (klass))
return CharPointer_UTF8 (lilv_node_as_string (node));
return String::empty;
}
String StringPool::getPooledString (const char* const newString)
{
if (newString == nullptr || *newString == 0)
return String();
const ScopedLock sl (lock);
garbageCollectIfNeeded();
return addPooledString (strings, CharPointer_UTF8 (newString));
}
String InputStream::readString()
{
MemoryBlock buffer (256);
char* data = static_cast<char*> (buffer.getData());
size_t i = 0;
while ((data[i] = readByte()) != 0)
{
if (++i >= buffer.getSize())
{
buffer.setSize (buffer.getSize() + 512);
data = static_cast<char*> (buffer.getData());
}
}
return String (CharPointer_UTF8 (data),
CharPointer_UTF8 (data + i));
}
bool next()
{
if (ports == nullptr || ports [index + 1] == nullptr)
return false;
name = CharPointer_UTF8 (ports[++index]);
clientName = name.upToFirstOccurrenceOf (":", false, false);
return true;
}
//==============================================================================
String SystemStats::getLogonName()
{
const char* user = getenv ("USER");
if (user == nullptr)
if (passwd* const pw = getpwuid (getuid()))
user = pw->pw_name;
return CharPointer_UTF8 (user);
}
bool MemoryOutputStream::appendUTF8Char (juce_wchar c)
{
if (char* dest = prepareToWrite (CharPointer_UTF8::getBytesRequiredFor (c)))
{
CharPointer_UTF8 (dest).write (c);
return true;
}
return false;
}
String
LV2Module::getAuthorName() const
{
if (LilvNode* node = lilv_plugin_get_author_name (plugin))
{
String name (CharPointer_UTF8 (lilv_node_as_string (node)));
lilv_node_free (node);
return name;
}
return String::empty;
}
//==============================================================================
String SystemStats::getLogonName()
{
const char* user = getenv ("USER");
if (user == 0)
{
struct passwd* const pw = getpwuid (getuid());
if (pw != 0)
user = pw->pw_name;
}
return CharPointer_UTF8 (user);
}
const String
LV2Module::getPortName (uint32 index) const
{
if (const LilvPort* port = getPort (index))
{
LilvNode* node = lilv_port_get_name (plugin, port);
const String name = CharPointer_UTF8 (lilv_node_as_string (node));
lilv_node_free (node);
return name;
}
return String::empty;
}
void PluginParameter::init (const String& name_, ParameterUnit unit_, String description_,
double value_, double min_, double max_, double default_,
double skewFactor_, double smoothCoeff_, double step_, String unitSuffix_)
{
name = name_;
unit = unit_;
description = description_;
min = min_;
max = max_;
setValue (value_);
defaultValue = default_;
smoothCoeff = smoothCoeff_;
smoothValue = getValue();
skewFactor = skewFactor_;
step = step_;
unitSuffix = unitSuffix_;
// default label suffix's, these can be changed later
switch (unit)
{
case UnitPercent: setUnitSuffix("%"); break;
case UnitSeconds: setUnitSuffix("s"); break;
case UnitPhase: setUnitSuffix(CharPointer_UTF8 ("\xc2\xb0")); break;
case UnitHertz: setUnitSuffix("Hz"); break;
case UnitDecibels: setUnitSuffix("dB"); break;
case UnitDegrees: setUnitSuffix(CharPointer_UTF8 ("\xc2\xb0")); break;
case UnitMeters: setUnitSuffix("m"); break;
case UnitBPM: setUnitSuffix("BPM"); break;
case UnitMilliseconds: setUnitSuffix("ms"); break;
default: break;
}
}
int doFTime (CharPointer_UTF32 dest, const size_t maxChars, const String& format, const struct tm* const tm) noexcept
{
#if JUCE_ANDROID
HeapBlock <char> tempDest;
tempDest.calloc (maxChars + 2);
const int result = (int) strftime (tempDest, maxChars, format.toUTF8(), tm);
if (result > 0)
dest.writeAll (CharPointer_UTF8 (tempDest.getData()));
return result;
#elif JUCE_WINDOWS
HeapBlock <wchar_t> tempDest;
tempDest.calloc (maxChars + 2);
const int result = (int) wcsftime (tempDest, maxChars, format.toWideCharPointer(), tm);
if (result > 0)
dest.writeAll (CharPointer_UTF16 (tempDest.getData()));
return result;
#else
return (int) wcsftime (dest.getAddress(), maxChars, format.toUTF32(), tm);
#endif
}
//==============================================================================
static String readResponse (const int socketHandle, const uint32 timeOutTime)
{
int bytesRead = 0, numConsecutiveLFs = 0;
MemoryBlock buffer (1024, true);
while (numConsecutiveLFs < 2 && bytesRead < 32768
&& Time::getMillisecondCounter() <= timeOutTime)
{
fd_set readbits;
FD_ZERO (&readbits);
FD_SET (socketHandle, &readbits);
struct timeval tv;
tv.tv_sec = jmax (1, (int) (timeOutTime - Time::getMillisecondCounter()) / 1000);
tv.tv_usec = 0;
if (select (socketHandle + 1, &readbits, 0, 0, &tv) <= 0)
return String::empty; // (timeout)
buffer.ensureSize (bytesRead + 8, true);
char* const dest = (char*) buffer.getData() + bytesRead;
if (recv (socketHandle, dest, 1, 0) == -1)
return String::empty;
const char lastByte = *dest;
++bytesRead;
if (lastByte == '\n')
++numConsecutiveLFs;
else if (lastByte != '\r')
numConsecutiveLFs = 0;
}
const String header (CharPointer_UTF8 ((const char*) buffer.getData()));
if (header.startsWithIgnoreCase ("HTTP/"))
return header.trimEnd();
return String::empty;
}
//==============================================================================
void NewComponent::paint (Graphics& g)
{
//[UserPrePaint] Add your own custom painting code here..
//[/UserPrePaint]
g.fillAll (Colour (0xff222222));
g.setGradientFill (ColourGradient (Colours::darkgrey,
128.0f, static_cast<float> (-56),
Colours::black,
128.0f, 80.0f,
false));
g.fillRect (0, 0, 350, 30);
g.setColour (Colour (0xffcfcfcf));
g.setFont (Font (14.00f, Font::plain));
g.drawText (TRANS("Amarras"),
27, 0, 152, 30,
Justification::centredLeft, true);
g.setColour (Colour (0xff666666));
g.setFont (Font (10.00f, Font::plain));
g.drawText (TRANS("1"),
3, 3, 13, 30,
Justification::centred, true);
g.setColour (Colour (0xff858585));
g.setFont (Font (14.00f, Font::plain));
g.drawText (CharPointer_UTF8 ("D\'Arienzo - Maur\xc3\xa9"),
185, 0, 125, 30,
Justification::centredLeft, true);
g.setColour (Colour (0xff858585));
g.setFont (Font (12.00f, Font::plain));
g.drawText (TRANS("1941"),
315, 0, 28, 30,
Justification::centredRight, true);
//[UserPaint] Add your own custom painting code here..
//[/UserPaint]
}
void jojo_bang (t_jojo *x)
{
const ScopedLock myLock (x->lock_);
post ("Public / %s", x->public_.toString().toRawUTF8());
post ("Private / %s", x->private_.toString().toRawUTF8());
String myText (CharPointer_UTF8 ("P\xc3\xa9p\xc3\xa9 p\xc3\xa8te en ao\xc3\xbbt!"));
post ("%s", myText.toRawUTF8());
const juce::MemoryBlock blockBegin (myText.toRawUTF8(), myText.getNumBytesAsUTF8() + 1);
BigInteger bitArray;
bitArray.loadFromMemoryBlock (blockBegin);
x->public_.applyToValue (bitArray); /* Encrypt with the public key. */
post ("%s", bitArray.toString (16).toRawUTF8());
x->private_.applyToValue (bitArray); /* Then decrypt with the private key. */
const juce::MemoryBlock blockEnd (bitArray.toMemoryBlock());
post ("%s", blockEnd.toString().toRawUTF8());
}
void MemoryOutputStream::appendUTF8Char (juce_wchar c)
{
CharPointer_UTF8 (prepareToWrite (CharPointer_UTF8::getBytesRequiredFor (c))).write (c);
}
void XmlDocument::readEntity (String& result)
{
// skip over the ampersand
++input;
if (input.compareIgnoreCaseUpTo (CharPointer_UTF8 ("amp;"), 4) == 0)
{
input += 4;
result += '&';
}
else if (input.compareIgnoreCaseUpTo (CharPointer_UTF8 ("quot;"), 5) == 0)
{
input += 5;
result += '"';
}
else if (input.compareIgnoreCaseUpTo (CharPointer_UTF8 ("apos;"), 5) == 0)
{
input += 5;
result += '\'';
}
else if (input.compareIgnoreCaseUpTo (CharPointer_UTF8 ("lt;"), 3) == 0)
{
input += 3;
result += '<';
}
else if (input.compareIgnoreCaseUpTo (CharPointer_UTF8 ("gt;"), 3) == 0)
{
input += 3;
result += '>';
}
else if (*input == '#')
{
int charCode = 0;
++input;
if (*input == 'x' || *input == 'X')
{
++input;
int numChars = 0;
while (input[0] != ';')
{
const int hexValue = CharacterFunctions::getHexDigitValue (input[0]);
if (hexValue < 0 || ++numChars > 8)
{
setLastError ("illegal escape sequence", true);
break;
}
charCode = (charCode << 4) | hexValue;
++input;
}
++input;
}
else if (input[0] >= '0' && input[0] <= '9')
{
int numChars = 0;
while (input[0] != ';')
{
if (++numChars > 12)
{
setLastError ("illegal escape sequence", true);
break;
}
charCode = charCode * 10 + ((int) input[0] - '0');
++input;
}
++input;
}
else
{
setLastError ("illegal escape sequence", true);
result += '&';
return;
}
result << (juce_wchar) charCode;
}
else
{
const String::CharPointerType entityNameStart (input);
const int closingSemiColon = input.indexOf ((juce_wchar) ';');
if (closingSemiColon < 0)
{
outOfData = true;
result += '&';
}
else
{
input += closingSemiColon + 1;
result += expandExternalEntity (String (entityNameStart, (size_t) closingSemiColon));
}
}
}
File File::getSpecialLocation (const SpecialLocationType type)
{
switch (type)
{
case userHomeDirectory:
{
const char* homeDir = getenv ("HOME");
if (homeDir == nullptr)
{
struct passwd* const pw = getpwuid (getuid());
if (pw != nullptr)
homeDir = pw->pw_dir;
}
return File (CharPointer_UTF8 (homeDir));
}
case userDocumentsDirectory:
case userMusicDirectory:
case userMoviesDirectory:
case userApplicationDataDirectory:
return File ("~");
case userDesktopDirectory:
return File ("~/Desktop");
case commonApplicationDataDirectory:
return File ("/var");
case globalApplicationsDirectory:
return File ("/usr");
case tempDirectory:
{
File tmp ("/var/tmp");
if (! tmp.isDirectory())
{
tmp = "/tmp";
if (! tmp.isDirectory())
tmp = File::getCurrentWorkingDirectory();
}
return tmp;
}
case invokedExecutableFile:
if (juce_Argv0 != nullptr)
return File (CharPointer_UTF8 (juce_Argv0));
// deliberate fall-through...
case currentExecutableFile:
case currentApplicationFile:
return juce_getExecutableFile();
case hostApplicationPath:
return juce_readlink ("/proc/self/exe", juce_getExecutableFile());
default:
jassertfalse; // unknown type?
break;
}
return File::nonexistent;
}
String MemoryOutputStream::toUTF8() const
{
const char* const d = static_cast<const char*> (getData());
return String (CharPointer_UTF8 (d), CharPointer_UTF8 (d + getDataSize()));
}
