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())); }