void operator()(const std::u16string& str) {
m_serializer->acquire(sizeof(std::uint32_t) + str.size());
write_int(m_serializer, static_cast<std::uint32_t>(str.size()));
for (char16_t c : str) {
// force writer to use exactly 16 bit
write_int(m_serializer, static_cast<std::uint16_t>(c));
}
}
TEST(InputU16StringBufferTest, CopiesValue)
{
std::u16string const data(u"dummy data");
cpp_odbc::level2::input_u16string_buffer buffer(data);
ASSERT_EQ(data.size(), buffer.size());
for (std::size_t i = 0; i < data.size(); ++i) {
EXPECT_EQ(data[i], buffer.data_pointer()[i]);
}
}
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::
void LineEdit::IntValidator::erase(std::u16string &string,
size_t &scursor,
size_t &ecursor) const {
Validator::erase(string,scursor,ecursor);
if(string.size()==1 && string[0]=='-')
string[0] = '0';
if(string.empty())
string.push_back('0');
}
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;
}
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<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 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);
}
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;
}
}
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';
}
}
}
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;
}
}
std::string CodeConvertU16(const std::u16string & s)
{
const int Max_In_Size = 4;
std::locale sys_loc("");
const char16_t * src_insrc = s.c_str();
const size_t BUFFER_SIZE = s.size() * Max_In_Size;
const size_t OUT_SIZE = sizeof(char);
// TODO:
// reasonable size , it may be too large the allocation to
// on the Out[BUFFER_SIZE]
char * extern_buffer = new char[BUFFER_SIZE];
memset(extern_buffer, 0, BUFFER_SIZE * OUT_SIZE);
const char16_t * intern_from = src_insrc;
const char16_t * intern_from_end = intern_from + s.size();
const char16_t * intern_from_next = 0;
char * extern_from = extern_buffer;
char * extern_from_end = extern_from + BUFFER_SIZE;
char * extern_from_next = 0;
typedef std::codecvt<char16_t, char, std::mbstate_t> CodeCvtFacet;
// TODO:
// it is required to have the typename in front of the
// CodeCvtFacet
// It is because of the CodeCvtFacet is a dependent scope, which means it required
// to explicitly tell the compiler that the CodeCvtFacet is a type
//
typename CodeCvtFacet::result cvt_rst = std::use_facet<CodeCvtFacet>(sys_loc).out(
out_cvt_state,
intern_from,
intern_from_end,
intern_from_next,
extern_from,
extern_from_end,
extern_from_next
);
if (cvt_rst != CodeCvtFacet::ok) {
switch (cvt_rst) {
case CodeCvtFacet::error:
std::cerr << "partial";
break;
case CodeCvtFacet::partial:
std::cerr << "partial";
break;
case CodeCvtFacet::noconv:
std::cerr << "noconv";
break;
default:
std::cerr << "unknown";
break;
}
std::cerr << ", please check out_cvt_state."
<< std::endl;
}
std::string result = extern_buffer;
delete[] extern_buffer;
return result;
}
// Takes UTF16 input in logical order and applies Arabic shaping to the input while maintaining
// logical order. Output won't be intelligible until the bidirectional algorithm is applied
std::u16string applyArabicShaping(const std::u16string& input) {
UErrorCode errorCode = U_ZERO_ERROR;
const int32_t outputLength =
u_shapeArabic(mbgl::utf16char_cast<const UChar*>(input.c_str()), static_cast<int32_t>(input.size()), nullptr, 0,
(U_SHAPE_LETTERS_SHAPE & U_SHAPE_LETTERS_MASK) |
(U_SHAPE_TEXT_DIRECTION_LOGICAL & U_SHAPE_TEXT_DIRECTION_MASK),
&errorCode);
// Pre-flighting will always set U_BUFFER_OVERFLOW_ERROR
errorCode = U_ZERO_ERROR;
std::u16string outputText(outputLength, 0);
u_shapeArabic(mbgl::utf16char_cast<const UChar*>(input.c_str()), static_cast<int32_t>(input.size()), mbgl::utf16char_cast<UChar*>(&outputText[0]), outputLength,
(U_SHAPE_LETTERS_SHAPE & U_SHAPE_LETTERS_MASK) |
(U_SHAPE_TEXT_DIRECTION_LOGICAL & U_SHAPE_TEXT_DIRECTION_MASK),
&errorCode);
// If the algorithm fails for any reason, fall back to non-transformed text
if (U_FAILURE(errorCode))
return input;
return outputText;
}
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);
}
input_u16string_buffer::input_u16string_buffer(std::u16string const & data) :
data_(data.size() + 1)
{
memcpy(data_.data(), data.data(), data_.size() * sizeof(char16_t));
}
std::string to_utf8(const std::u16string &s)
{
std::wstring_convert<std::codecvt_utf8<int16_t>, int16_t> convert;
auto p = reinterpret_cast<const int16_t *>(s.data());
return convert.to_bytes(p, p + s.size());
}
// VS 2015 Bug: https://social.msdn.microsoft.com/Forums/en-US/8f40dcd8-c67f-4eba-9134-a19b9178e481/vs-2015-rc-linker-stdcodecvt-error?forum=vcgeneral
std::string utf16_to_utf8(std::u16string utf16_string)
{
std::wstring_convert<std::codecvt_utf8_utf16<int16_t>, int16_t> convert;
auto p = reinterpret_cast<const int16_t *>(utf16_string.data());
return convert.to_bytes(p, p + utf16_string.size());
}
void RenderString::CreateRenderCharacters(const std::u16string& newString) {
if (!newString.empty() && mFont) {
int advanceAccum = 0; // the accumulated horizontal advance for the current line
int kerningAccum = 0; // the accumulated kerning offset for the current line
int lineOffset = 0; // the vertical offset of the current line
int lineHeight = mFont->GetLineHeight(); // retrieve and store the new line offset
if (!mString.empty() && !mRenderChars.empty()) { // if we already have characters entered...
if (mString.back() == u'\n') { // if the last character entered was a new line...
lineOffset = mRenderChars.back().mLineHeight + lineHeight; // adjust the line offset for following characters
}
else {
// laod the states of the accumulators from the previous characters entered
advanceAccum = mRenderChars.back().mAdvanceAccum;
kerningAccum = mRenderChars.back().mKerningAccum;
lineOffset = mRenderChars.back().mLineHeight;
kerningAccum += mFont->GetKerning(mString.back(), newString.front()); // adjust the kerning offset for the new character
}
}
for (unsigned int i = 0u; i < newString.size(); ++i) {
char16_t codePoint = newString.at(i);
if (codePoint == u'\n') { // if the current character is a new line...
advanceAccum = 0; // reset the horizontal advance
kerningAccum = 0; // reset the kerning offset
lineOffset += lineHeight; // increment the vertical offset by the new line height
continue; // go to the next character
}
try {
const FontBase::Glyph& glyph = mFont->GetGlyph(codePoint); // get the glyph object for the current character
Shape shape = glyph.mBaseShape; // get the glyph shape from the glyph object
float height = 0.0f; // the height of the glyph shape used for positional offsetting
{
const std::vector<glm::vec2>& bbox = shape.GetLocalBoundingBox(); // get the bounding box of the glyph
if (!bbox.empty()) { // if the bounding box is valid...
height = bbox.at(2).y - bbox.at(0).y; // calculate the height of the glyph shape
}
}
shape.SetPosition(glm::vec2((advanceAccum + kerningAccum) + glyph.mBearing.x,
((mFont->GetBearingMax().y - glyph.mBearing.y) - mFont->GetBearingMax().y) + lineOffset)); // position the glyph shape
{ // update the local bounding box
// get the bounding box of the newly added character
std::vector<glm::vec2> bbox = shape.GetGlobalBoundingBox();
if (bbox.size() > 3) { // if the bounding box is valid...
mTopLeft.x = std::min(bbox.at(0).x, mTopLeft.x);
mTopLeft.y = std::min(bbox.at(0).y, mTopLeft.y);
mBottomRight.x = std::max(bbox.at(2).x, mBottomRight.x);
mBottomRight.y = std::max(bbox.at(2).y, mBottomRight.y);
}
}
advanceAccum += glyph.mAdvance; // increment the horizontal advance accumulator by the current glyph's advance metric
if (i != newString.size() - 1) { // if this is not the final character in the string...
kerningAccum += mFont->GetKerning(codePoint, newString.at(i + 1)); // increment the kerning offset by the kerning value of this and the next character
}
mRenderChars.push_back({std::move(shape), advanceAccum, kerningAccum, lineOffset,
mTopLeft, mBottomRight});
} catch(std::exception& e) {
std::cout << "unknown codepoint: " << codePoint << std::endl;
}
}
// update the full sized (not yet scaled) local bounding box
glm::vec2 dimensions = mBottomRight - mTopLeft;
mLocalBoundingBoxFull.clear();
mLocalBoundingBoxFull.emplace_back(0.0f, 0.0f);
mLocalBoundingBoxFull.emplace_back(dimensions.x, 0.0f);
mLocalBoundingBoxFull.emplace_back(dimensions.x, dimensions.y);
mLocalBoundingBoxFull.emplace_back(0.0f, dimensions.y);
}
}
Tempest::Size Tempest::FontElement::textSize(const std::u16string &str ) const {
return textSize( str.c_str(), str.c_str()+str.size() );
}
