void FontAtlas::findNewCharacters(const std::u16string& u16Text, std::unordered_map<unsigned short, unsigned short>& charCodeMap) { std::u16string newChars; FT_Encoding charEncoding = _fontFreeType->getEncoding(); //find new characters if (_letterDefinitions.empty()) { // fixed #16169: new android project crash in android 5.0.2 device (Nexus 7) when use 3.12. // While using clang compiler with gnustl_static on android, the copy assignment operator of `std::u16string` // will affect the memory validity, it means after `newChars` is destroyed, the memory of `u16Text` holds // will be a dead region. `u16text` represents the variable in `Label::_utf16Text`, when somewhere // allocates memory by `malloc, realloc, new, new[]`, the generated memory address may be the same // as `Label::_utf16Text` holds. If doing a `memset` or other memory operations, the orignal `Label::_utf16Text` // will be in an unknown state. Meanwhile, a bunch lots of logic which depends on `Label::_utf16Text` // will be broken. // newChars = u16Text; // Using `append` method is a workaround for this issue. So please be carefuly while using the assignment operator // of `std::u16string`. newChars.append(u16Text); } else { auto length = u16Text.length(); newChars.reserve(length); for (size_t i = 0; i < length; ++i) { auto outIterator = _letterDefinitions.find(u16Text[i]); if (outIterator == _letterDefinitions.end()) { newChars.push_back(u16Text[i]); } } } if (!newChars.empty()) { switch (charEncoding) { case FT_ENCODING_UNICODE: { for (auto u16Code : newChars) { charCodeMap[u16Code] = u16Code; } break; } case FT_ENCODING_GB2312: { conversionU16TOGB2312(newChars, charCodeMap); break; } default: OUTPUT_LOG("FontAtlas::findNewCharacters: Unsupported encoding:%d", charEncoding); break; } } }
bool mapToPixelLength(std::u16string& value) { if (stripLeadingWhitespace(value).empty()) return false; const char16_t* input = value.c_str(); const char16_t* end = input + value.length(); int u; end = parseInt(input, end, u); if (!end || u < 0) return false; if (0 < u) value.replace(end - input, std::u16string::npos, u"px"); else value.erase(end - input); return true; }
bool UTF8ToUTF16(const std::string& utf8, std::u16string& outUtf16) { if (utf8.empty()) { outUtf16.clear(); return true; } bool ret = false; const size_t utf16Bytes = (utf8.length()+1) * sizeof(char16_t); char16_t* utf16 = (char16_t*)malloc(utf16Bytes); memset(utf16, 0, utf16Bytes); char* utf16ptr = reinterpret_cast<char*>(utf16); const UTF8* error = NULL; if (llvm::ConvertUTF8toWide(2, utf8, utf16ptr, error)) { outUtf16 = utf16; ret = true; } free(utf16); return ret; }
void MediaListImp::setMediaText(const std::u16string& mediaText) { clear(); if (!mediaText.empty()) { CSSParser parser; *this = *parser.parseMediaList(mediaText); } }
void KMX_Environment::Load(std::u16string const & key, std::u16string const & value) { assert(!key.empty()); if (!u16icmp(key.c_str(), KM_KBP_KMX_ENV_PLATFORM)) { _platform = value; } else if (!u16icmp(key.c_str(), KM_KBP_KMX_ENV_BASELAYOUT)) { _baseLayout = value; } else if (!u16icmp(key.c_str(), KM_KBP_KMX_ENV_BASELAYOUTALT)) { _baseLayoutAlt = value; } else if (!u16icmp(key.c_str(), KM_KBP_KMX_ENV_SIMULATEALTGR)) { _simulateAltGr = value == u"1"; } else if (!u16icmp(key.c_str(), KM_KBP_KMX_ENV_CAPSLOCK)) { _capsLock = value == u"1"; } else if (!u16icmp(key.c_str(), KM_KBP_KMX_ENV_BASELAYOUTGIVESCTRLRALTFORRALT)) { _baseLayoutGivesCtrlRAltForRAlt = value == u"1"; } else { // Unsupported key assert(false); } }
TextFlow::Word TextFlow::calculateWord(std::u16string content, float scale) const { // Empty word Word word; word.spVertices = std::shared_ptr<std::vector<glm::vec3> >(new std::vector<glm::vec3>); word.spTextureCoordinates = std::shared_ptr<std::vector<glm::vec2> >(new std::vector<glm::vec2>); // Fill word with data float xPixelPen = 0; for (uint i = 0; i < content.size(); i++) { Glyph const * pGlyph = mpFont->getGlyph(mFontSize, content[i]); if (pGlyph == NULL) { throwWarning( OperationNotifier::Operation::RUNTIME, "TextFlow has character in content not covered by character set"); continue; } float yPixelPen = 0 - (scale * (float)(pGlyph->size.y - pGlyph->bearing.y)); // Vertices for this quad glm::vec3 vertexA = glm::vec3(xPixelPen, yPixelPen, 0); glm::vec3 vertexB = glm::vec3(xPixelPen + (scale * pGlyph->size.x), yPixelPen, 0); glm::vec3 vertexC = glm::vec3(xPixelPen + (scale * pGlyph->size.x), yPixelPen + (scale * pGlyph->size.y), 0); glm::vec3 vertexD = glm::vec3(xPixelPen, yPixelPen + (scale * pGlyph->size.y), 0); // Texture coordinates for this quad glm::vec2 textureCoordinateA = glm::vec2(pGlyph->atlasPosition.x, pGlyph->atlasPosition.y); glm::vec2 textureCoordinateB = glm::vec2(pGlyph->atlasPosition.z, pGlyph->atlasPosition.y); glm::vec2 textureCoordinateC = glm::vec2(pGlyph->atlasPosition.z, pGlyph->atlasPosition.w); glm::vec2 textureCoordinateD = glm::vec2(pGlyph->atlasPosition.x, pGlyph->atlasPosition.w); xPixelPen += scale * pGlyph->advance.x; // Fill into data blocks word.spVertices->push_back(vertexA); word.spVertices->push_back(vertexB); word.spVertices->push_back(vertexC); word.spVertices->push_back(vertexC); word.spVertices->push_back(vertexD); word.spVertices->push_back(vertexA); word.spTextureCoordinates->push_back(textureCoordinateA); word.spTextureCoordinates->push_back(textureCoordinateB); word.spTextureCoordinates->push_back(textureCoordinateC); word.spTextureCoordinates->push_back(textureCoordinateC); word.spTextureCoordinates->push_back(textureCoordinateD); word.spTextureCoordinates->push_back(textureCoordinateA); } // Set width of whole word word.pixelWidth = xPixelPen; return word; }
inline binding_string::binding_string(handles* hnd, size_t order, const std::string& str, ub1 cs_form) : m_str(brig::unicode::transform<char16_t>(str)) { const size_t size((m_str.size() + 1) * sizeof(char16_t)); if (size > SHRT_MAX) throw std::runtime_error("OCI type error"); m_ind = OCIInd(size); OCIBind* bnd(0); hnd->check(lib::singleton().p_OCIBindByPos(hnd->stmt, &bnd, hnd->err, ub4(order), (void*)m_str.c_str(), m_ind, SQLT_STR, &m_ind, 0, 0, 0, 0, OCI_DEFAULT)); hnd->check(lib::singleton().p_OCIAttrSet(bnd, OCI_HTYPE_BIND, (void*)&cs_form, 0, OCI_ATTR_CHARSET_FORM, hnd->err)); } // binding_string::
bool UTF16ToUTF8(const std::u16string& utf16, std::string& outUtf8) { if (utf16.empty()) { outUtf8.clear(); return true; } return llvm::convertUTF16ToUTF8String(utf16, outUtf8); }
Value:: Value(const std::u16string& s): type(ConstCharType().make_array(s.size()+1)), base_address(0), size(sizeof(char16_t)*(s.size()+1)) { data = new uint8_t[size]; auto dst = reinterpret_cast<char16_t*>(data); auto src = s.cbegin(); while(*src) { *dst++ = *src++; } dst = 0; }
void TextLabels::renderString( const std::u16string &str, vec2 *cursor, float stretch ) { std::u16string::const_iterator itr; for( itr = str.begin(); itr != str.end(); ++itr ) { // retrieve character code uint16_t id = (uint16_t)*itr; if( mFont->contains( id ) ) { // get metrics for this character to speed up measurements Font::Metrics m = mFont->getMetrics( id ); // skip whitespace characters if( !isWhitespaceUtf16( id ) ) { size_t index = mVertices.size(); Rectf bounds = mFont->getBounds( m, mFontSize ); mVertices.push_back( vec3( *cursor + bounds.getUpperLeft(), 0 ) ); mVertices.push_back( vec3( *cursor + bounds.getUpperRight(), 0 ) ); mVertices.push_back( vec3( *cursor + bounds.getLowerRight(), 0 ) ); mVertices.push_back( vec3( *cursor + bounds.getLowerLeft(), 0 ) ); bounds = mFont->getTexCoords( m ); mTexcoords.push_back( bounds.getUpperLeft() ); mTexcoords.push_back( bounds.getUpperRight() ); mTexcoords.push_back( bounds.getLowerRight() ); mTexcoords.push_back( bounds.getLowerLeft() ); mIndices.push_back( index + 0 ); mIndices.push_back( index + 3 ); mIndices.push_back( index + 1 ); mIndices.push_back( index + 1 ); mIndices.push_back( index + 3 ); mIndices.push_back( index + 2 ); mOffsets.insert( mOffsets.end(), 4, mOffset ); } if( id == 32 ) cursor->x += stretch * mFont->getAdvance( m, mFontSize ); else cursor->x += mFont->getAdvance( m, mFontSize ); } } // mBoundsInvalid = true; }
void UserDictionaryDecoder::DecodeHeading(IBitStream *bstr, unsigned len, std::u16string &res) { res.clear(); unsigned symIdx; for (size_t i = 0; i < len; i++) { _ltHeadings.Decode(*bstr, symIdx); unsigned sym = _headingSymbols.at(symIdx); assert(sym <= 0xffff); res += (char16_t)sym; } }
bool RegexStore::patternMatch(std::u16string& in_string) { //No pattern matches when we don't have a valid pattern if (not is_compiled) { return false; } //Check for a match regmatch_t pmatch; std::string tmp_str(in_string.begin(), in_string.end()); int match = regexec(&exp, tmp_str.c_str(), 1, &pmatch, 0); //Make sure that each character was matched and that the entire input string //was consumed by the pattern if (0 == match and 0 == pmatch.rm_so and in_string.size() == pmatch.rm_eo) { return true; } else { return false; } }
SimpleString::SimpleString(const std::u16string _str) { length = _str.size(); s_value = new char16_t[length + 1]; for (unsigned int i = 0; i < _str.size(); ++i) s_value[i] = _str[i]; s_value[length] = u'\0'; // calculate hash; _hash = 5381; int c = 0; char16_t * sptr = s_value; while ((c = *sptr++)) _hash = ((_hash << 5) + _hash) + c; }
std::vector<char16_t> getChar16VectorFromUTF16String(const std::u16string& utf16) { std::vector<char16_t> ret; size_t len = utf16.length(); ret.reserve(len); for (size_t i = 0; i < len; ++i) { ret.push_back(utf16[i]); } return ret; }
bool convertUTF16ToUTF8String(const std::u16string& utf16, std::string &Out) { assert(Out.empty()); // Avoid OOB by returning early on empty input. if (utf16.empty()) return true; const UTF16 *Src = reinterpret_cast<const UTF16 *>(utf16.data()); const UTF16 *SrcEnd = reinterpret_cast<const UTF16 *>(utf16.data() + utf16.length()); // Byteswap if necessary. std::vector<UTF16> ByteSwapped; if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_SWAPPED) { ByteSwapped.insert(ByteSwapped.end(), Src, SrcEnd); for (size_t I = 0, E = ByteSwapped.size(); I != E; ++I) ByteSwapped[I] = SwapByteOrder_16(ByteSwapped[I]); Src = &ByteSwapped[0]; SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1; } // Skip the BOM for conversion. if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_NATIVE) Src++; // Just allocate enough space up front. We'll shrink it later. Out.resize(utf16.length() * UNI_MAX_UTF8_BYTES_PER_CODE_POINT + 1); UTF8 *Dst = reinterpret_cast<UTF8 *>(&Out[0]); UTF8 *DstEnd = Dst + Out.size(); ConversionResult CR = ConvertUTF16toUTF8(&Src, SrcEnd, &Dst, DstEnd, strictConversion); assert(CR != targetExhausted); if (CR != conversionOK) { Out.clear(); return false; } Out.resize(reinterpret_cast<char *>(Dst) - &Out[0]); return true; }
std::string to_utf8(const std::u16string& str) { icu_handle::get(); static_assert(sizeof(char16_t) == sizeof(UChar), "Invalid UChar definition in ICU"); // looks dangerous, but isn't: UChar is guaranteed to be a 16-bit // integer type, so all we're doing here is going between signed vs. // unsigned auto buf = reinterpret_cast<const UChar*>(str.c_str()); icu::UnicodeString u16str{buf}; return icu_to_u8str(u16str); }
std::vector<TextFlow::Word> TextFlow::calculateFitWord(std::u16string content, int maxPixelWidth, float scale) const { // Calculate word from content Word word = calculateWord(content, scale); // End of recursion if ((content.size() == 1 && word.pixelWidth > maxPixelWidth) || content.empty()) { // Return empty vector as signal of failure return std::vector<Word>(); } else if (word.pixelWidth <= maxPixelWidth) { // If word length is ok, just return it return std::vector<Word>(1, word); } else { // Word is too wide and content longer than 1, split it! int length = (int)content.size(); int left = length / 2; int right = length - left; // Combine results from recursive call std::vector<Word> leftWord = calculateFitWord(content.substr(0, left), maxPixelWidth, scale); std::vector<Word> rightWord = calculateFitWord(content.substr(left+1, right), maxPixelWidth, scale); // If one or more of both are empty, forget it if (leftWord.empty() || rightWord.empty()) { return std::vector<Word>(); } else { std::vector<Word> words(leftWord); words.insert(words.end(), rightWord.begin(), rightWord.end()); return words; } } }
float Font::render(const std::u16string &text, glm::vec2 position, HexColor color, int caretPosition){ empty[g_UILayer] = false; LastTextHeight = 0; LastTextLength = 0; lastTextSize = text.size(); glm::vec2 currentPosition = position; char16_t letter; for (u32 i = 0; i < text.size(); i++){ letter = text[i]; auto &letterInfo = fontInfo->m_letters[letter]; if (letter == '\n'){ // new line LastTextLength = std::max(LastTextLength, currentPosition[0] - position.x); LastTextHeight += height; currentPosition = position - glm::vec2(0, LastTextHeight); continue; } if (letter > L'\u00ff'){ currentPosition.x += genSingleSymbol(letter, currentPosition, color); continue; } else if (i > 0){ // kerning currentPosition[0] += letterInfo.kerning[text[i - 1]]; } renderedFonts[g_UILayer].m_size++; renderedFonts[g_UILayer].positions.push_back(currentPosition + letterInfo.offset); renderedFonts[g_UILayer].sizes.push_back(letterInfo.size); renderedFonts[g_UILayer].uvs.push_back(letterInfo.uv); renderedFonts[g_UILayer].colors.push_back(color); currentPosition.x += letterInfo.advance; } if (lastTextSize > 0) // compute len LastTextLength = currentPosition[0] - position.x; // placeCaret(text, position, color, caretPosition); renderedFonts[g_UILayer].m_size = renderedFonts[g_UILayer].uvs.size(); return LastTextLength + 1.f; }
void LineEdit::IntValidator::assign(std::u16string &string, const std::u16string &arg) const { if(arg.size()==0){ if(string.size()==0){ string.resize(1); string[0] = '0'; } return; } bool good=true; if(arg[0]=='-'){ if(arg.size()!=1){ if(arg[1]=='0' && arg.size()!=2) good=false; for(size_t i=1; good && i<arg.size(); ++i ){ const char16_t c = arg[i]; good &= ('0'<=c && c<='9'); } } else { good = false; } } else { if(arg[0]=='0' && arg.size()!=1) good=false; for(size_t i=0; good && i<arg.size(); ++i ){ const char16_t c = arg[i]; good &= ('0'<=c && c<='9'); } } if(good){ string = arg; } else { if(string.size()==0){ string.resize(1); string[0] = '0'; } } }
std::vector<std::u16string> BiDi::processText(const std::u16string& input, std::set<std::size_t> lineBreakPoints) { UErrorCode errorCode = U_ZERO_ERROR; ubidi_setPara(impl->bidiText, mbgl::utf16char_cast<const UChar*>(input.c_str()), static_cast<int32_t>(input.size()), UBIDI_DEFAULT_LTR, nullptr, &errorCode); if (U_FAILURE(errorCode)) { throw std::runtime_error(std::string("BiDi::processText: ") + u_errorName(errorCode)); } return applyLineBreaking(lineBreakPoints); }
void IPv6AddressToString(IPv6Address address, std::uint32_t scopeId, std::u16string& buffer) { const char* const InvalidIPv6AddressStr = "Invalid IPv6 address!"; ::in6_addr v6Addr; auto& desAddrBytes = v6Addr.s6_addr; auto& srcAddrBytes = address.Bytes; for (std::size_t i = 0; i < kIPv4AddressBytes; ++i) desAddrBytes[i] = static_cast<uchar>(srcAddrBytes[i]); const auto& ntFunctions = GetNtFunctions(); ulong bufferLength = {}; auto errCode = ntFunctions.RtlIpv6AddressToStringEx(&v6Addr, static_cast<ulong>(scopeId), 0, nullptr, &bufferLength); Try<std::invalid_argument>(bufferLength != 0, InvalidIPv6AddressStr); buffer.resize(static_cast<std::size_t>(bufferLength)); errCode = ntFunctions.RtlIpv6AddressToStringEx(&v6Addr, static_cast<ulong>(scopeId), 0, reinterpret_cast<wchar_t*>(&buffer[0]), &bufferLength); assert(errCode == NtFunctions::NtSuccess); buffer.pop_back(); }
bool HTMLElementImp::toPxOrPercentage(std::u16string& value) { stripLeadingAndTrailingWhitespace(value); if (value.empty()) return false; const char16_t* s = value.c_str(); while (*s) { if (*s == '%') break; if (!isDigit(*s)) return false; ++s; } if (!*s) { value += u"px"; return true; } assert(*s == '%'); if (!s[1] && 1 < value.length()) return true; return false; }
std::string utf16_to_ascii8(const std::u16string& utf16_string) { // Strip extended codes, map to '#' instead (placeholder) std::vector<u8> out; out.reserve(utf16_string.length() + 1); for (const auto& code : utf16_string) { out.push_back(code > 0xFF ? '#': (u8)code); } out.push_back(0); return { reinterpret_cast<char*>(out.data()) }; }
void WordSuggest::suggest(std::u16string input, Dictionary const * pDictionary, std::u16string& rBestSuggestion) { // Clear up mSuggestions.clear(); mThresholds.clear(); // Fallback for suggestion rBestSuggestion = u""; // Only do something when there is input if (!input.empty()) { // Decide whether word should start with big letter bool startsWithUpperCase = false; char16_t lowerCaseLetter = input[0]; if (toLower(lowerCaseLetter)) { startsWithUpperCase = lowerCaseLetter != input[0]; } // Ask for suggestions std::vector<std::u16string> suggestions = pDictionary->similarWords(input, startsWithUpperCase); uint i = 0; for (const std::u16string& rSuggestion : suggestions) { mSuggestions.push_back(std::move(mpAssetManager->createTextSimple(mFontSize, 1, rSuggestion))); // Only add maximal allowed number of suggestions if (++i >= WORD_SUGGEST_MAX_SUGGESTIONS) { break; } } // Save best suggestion if (!suggestions.empty()) { // First one is best rBestSuggestion = suggestions[0]; } // Prepare thresholds mThresholds.resize(mSuggestions.size(), LerpValue(0)); // Transform and position the suggestions initially transformSuggestions(); positionSuggestions(); } }
bool UserDictionaryDecoder::DecodeArticle( IBitStream *bstr, std::u16string &res, std::u16string const& prefix, LenTable& ltArticles, std::vector<char32_t>& articleSymbols) { unsigned len = bstr->read(16); if (len == 0xFFFF) { len = bstr->read(32); } res.clear(); unsigned symIdx; std::vector<uint32_t> vec; while ((unsigned)res.length() < len) { ltArticles.Decode(*bstr, symIdx); unsigned sym = articleSymbols.at(symIdx); vec.push_back(sym); if (sym >= 0x10000) { if (sym >= 0x10040) { unsigned startIdx = bstr->read(BitLength(len)); unsigned len = sym - 0x1003d; res += res.substr(startIdx, len); vec.push_back(startIdx); } else { unsigned startIdx = bstr->read(BitLength(prefix.length())); unsigned len = sym - 0xfffd; res += prefix.substr(startIdx, len); vec.push_back(startIdx); } } else { res += (char16_t)sym; } } return true; }
/* * Create a new regex pattern if necessary, or keep the old one if the * pattern has not changed * Returns true on success, false on failure. */ bool RegexStore::preparePattern(std::u16string& patt) { //New pattern? Clear out the existing regex_t if (is_compiled and this->pattern != patt) { //std::cerr<<"Replacing pattern "<<std::string(pattern.begin(), pattern.end())<<" with "<<std::string(patt.begin(), patt.end()) regfree(&exp); is_compiled = false; } //Do we need to compile a new regex pattern? if (not is_compiled) { //Compile a new regex pattern using the ascii string representation std::string tmp_string(patt.begin(), patt.end()); int err = regcomp(&exp, tmp_string.c_str(), REG_EXTENDED); //Return without creating an expression if this failed if (0 != err) { return false; //is_compiled remains false } else { pattern = patt; is_compiled = true; } } return true; }
//same thing as contructor. can be used to reinit dirList too void dirList::reassign(const std::u16string p) { entry.clear(); FSUSER_OpenDirectory(&d, a, fsMakePath(PATH_UTF16, p.data())); u32 read = 0; do { FS_DirectoryEntry getEnt; FSDIR_Read(d, &read, 1, &getEnt); entry.push_back(getEnt); }while(read > 0); FSDIR_Close(d); }
void FontAtlas::findNewCharacters(const std::u16string& u16Text, std::unordered_map<unsigned short, unsigned short>& charCodeMap) { std::u16string newChars; FT_Encoding charEncoding = _fontFreeType->getEncoding(); //find new characters if (_letterDefinitions.empty()) { newChars = u16Text; } else { auto length = u16Text.length(); newChars.reserve(length); for (size_t i = 0; i < length; ++i) { auto outIterator = _letterDefinitions.find(u16Text[i]); if (outIterator == _letterDefinitions.end()) { newChars.push_back(u16Text[i]); } } } if (!newChars.empty()) { switch (charEncoding) { case FT_ENCODING_UNICODE: { for (auto u16Code : newChars) { charCodeMap[u16Code] = u16Code; } break; } case FT_ENCODING_GB2312: { conversionU16TOGB2312(newChars, charCodeMap); break; } default: CCLOG("FontAtlas::findNewCharacters: Unsupported encoding:%d", charEncoding); break; } } }
void LineEdit::IntValidator::insert(std::u16string &string, size_t &cursor, size_t &ecursor, char16_t data) const { if( cursor==0 ){ if(!string.empty() && string[0]=='-') return; if(data=='-' && !(string.size()>=1 && string[0]=='0')){ Validator::insert(string,cursor,ecursor,data); return; } if(data=='0' && ((string.size()==1 && string[0]=='-') || string.size()==0)){ Validator::insert(string,cursor,ecursor,data); return; } if(('1'<=data && data<='9') || data=='-'){ Validator::insert(string,cursor,ecursor,data); return; } return; } const size_t pos = cursor-1; if( data=='0' && !(pos<string.size() && string[pos]=='-') && !(string.size()==1 && string[0]=='0') ){ Validator::insert(string,cursor,ecursor,data); return; } if('1'<=data && data<='9'){ if(string.size()==1 && string[0]=='0'){ string.clear(); cursor = 0; ecursor = cursor; } Validator::insert(string,cursor,ecursor,data); return; } }
void Label::DetermineTokenWidths(const std::u16string& text, double heuristicCharWidth, std::vector<double>& tokenWidths) { double tokenWidth = 0; int textSize = text.size(); for(int i = 0; i < textSize; ++i) { if (text[i] != ' ') { tokenWidth += heuristicCharWidth; } else { tokenWidths.push_back(tokenWidth); tokenWidth = 0; } } tokenWidths.push_back(tokenWidth); }