static std::string
WideStringToString(WideString const &str)
{
int size = WideCharToMultiByte(CP_UTF8, 0, str.data(), (int)str.size(), NULL, 0, NULL, NULL);
std::string multi = std::string();
multi.resize(size);
WideCharToMultiByte(CP_UTF8, 0, str.data(), (int)str.size(), &multi[0], size, NULL, NULL);
return multi;
}
ScValue *SXString::scGetProperty(const Common::String &name) {
_scValue->setNULL();
//////////////////////////////////////////////////////////////////////////
// Type (RO)
//////////////////////////////////////////////////////////////////////////
if (name == "Type") {
_scValue->setString("string");
return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// Length (RO)
//////////////////////////////////////////////////////////////////////////
else if (name == "Length") {
if (_gameRef->_textEncoding == TEXT_UTF8) {
WideString wstr = StringUtil::utf8ToWide(_string);
_scValue->setInt(wstr.size());
} else {
_scValue->setInt(strlen(_string));
}
return _scValue;
}
//////////////////////////////////////////////////////////////////////////
// Capacity
//////////////////////////////////////////////////////////////////////////
else if (name == "Capacity") {
_scValue->setInt(_capacity);
return _scValue;
} else {
return _scValue;
}
}
ScValue *ScValue::getProp(const char *name) {
if (_type == VAL_VARIABLE_REF) {
return _valRef->getProp(name);
}
if (_type == VAL_STRING && strcmp(name, "Length") == 0) {
_gameRef->_scValue->_type = VAL_INT;
if (_gameRef->_textEncoding == TEXT_ANSI) {
_gameRef->_scValue->setInt(strlen(_valString));
} else {
WideString wstr = StringUtil::utf8ToWide(_valString);
_gameRef->_scValue->setInt(wstr.size());
}
return _gameRef->_scValue;
}
ScValue *ret = nullptr;
if (_type == VAL_NATIVE && _valNative) {
ret = _valNative->scGetProperty(name);
}
if (ret == nullptr) {
_valIter = _valObject.find(name);
if (_valIter != _valObject.end()) {
ret = _valIter->_value;
}
}
return ret;
}
void Font::AddCurrentLine(const WideString & text, const int32 pos, SeparatorPositions & separatorPosition, Vector<WideString> & resultVector) const
{
WideString currentLine = text.substr(separatorPosition.currentLineStart, pos - separatorPosition.currentLineStart);
//Trim whitespace at begin/end line
while(currentLine.size() > 1 && IsSpace(currentLine[0]))
{
currentLine.erase(currentLine.begin());
}
while(currentLine.size() > 1 && IsSpace(currentLine[currentLine.size() - 1]))
{
currentLine.erase(currentLine.end() - 1);
}
resultVector.push_back(currentLine);
separatorPosition.Reset();
}
//=====================================================================================
String IC_StrConv::toString( const WideString str )
{
int len = str.size() + 1;
c8* buf = new c8[len];
::wcstombs( buf, str.c_str(), len );
String wstr = buf;
delete[] buf;
return wstr;
}
inline bool hasWildcard(const WideString preedit)
{
for (int i = 0; i < preedit.size(); i++)
{
ucs4_t ch = preedit[i];
if (ch == '*' || ch == '?')
return true;
}
return false;
}
String
utf8_wcstombs (const WideString & wstr)
{
String str;
char utf8 [6];
int un = 0;
for (unsigned int i = 0; i<wstr.size (); ++i) {
un = utf8_wctomb ((unsigned char*)utf8, wstr [i], 6);
if (un > 0)
str.append (utf8, un);
}
return str;
}
int BaseFontTT::getTextWidth(const byte *text, int maxLength) {
WideString textStr;
if (_gameRef->_textEncoding == TEXT_UTF8) {
textStr = StringUtil::utf8ToWide((const char *)text);
} else {
textStr = StringUtil::ansiToWide((const char *)text);
}
if (maxLength >= 0 && textStr.size() > (uint32)maxLength) {
textStr = WideString(textStr.c_str(), (uint32)maxLength);
}
//text = text.substr(0, MaxLength); // TODO: Remove
int textWidth, textHeight;
measureText(textStr, -1, -1, textWidth, textHeight);
return textWidth;
}
void BaseFontTT::drawText(const byte *text, int x, int y, int width, TTextAlign align, int maxHeight, int maxLength) {
if (text == nullptr || strcmp((const char *)text, "") == 0) {
return;
}
WideString textStr;
// TODO: Why do we still insist on Widestrings everywhere?
// HACK: J.U.L.I.A. uses CP1252, we need to fix that,
// And we still don't have any UTF8-support.
if (_gameRef->_textEncoding == TEXT_UTF8) {
textStr = StringUtil::utf8ToWide((const char *)text);
} else {
textStr = StringUtil::ansiToWide((const char *)text);
}
if (maxLength >= 0 && textStr.size() > (uint32)maxLength) {
textStr = WideString(textStr.c_str(), (uint32)maxLength);
}
//text = text.substr(0, MaxLength); // TODO: Remove
BaseRenderer *renderer = _gameRef->_renderer;
// find cached surface, if exists
uint32 minUseTime = UINT_MAX;
int minIndex = -1;
BaseSurface *surface = nullptr;
int textOffset = 0;
for (int i = 0; i < NUM_CACHED_TEXTS; i++) {
if (_cachedTexts[i] == nullptr) {
minUseTime = 0;
minIndex = i;
} else {
if (_cachedTexts[i]->_text == textStr && _cachedTexts[i]->_align == align && _cachedTexts[i]->_width == width && _cachedTexts[i]->_maxHeight == maxHeight && _cachedTexts[i]->_maxLength == maxLength) {
surface = _cachedTexts[i]->_surface;
textOffset = _cachedTexts[i]->_textOffset;
_cachedTexts[i]->_marked = true;
_cachedTexts[i]->_lastUsed = g_system->getMillis();
break;
} else {
if (_cachedTexts[i]->_lastUsed < minUseTime) {
minUseTime = _cachedTexts[i]->_lastUsed;
minIndex = i;
}
}
}
}
// not found, create one
if (!surface) {
debugC(kWintermuteDebugFont, "Draw text: %s", text);
surface = renderTextToTexture(textStr, width, align, maxHeight, textOffset);
if (surface) {
// write surface to cache
if (_cachedTexts[minIndex] != nullptr) {
delete _cachedTexts[minIndex];
}
_cachedTexts[minIndex] = new BaseCachedTTFontText;
_cachedTexts[minIndex]->_surface = surface;
_cachedTexts[minIndex]->_align = align;
_cachedTexts[minIndex]->_width = width;
_cachedTexts[minIndex]->_maxHeight = maxHeight;
_cachedTexts[minIndex]->_maxLength = maxLength;
_cachedTexts[minIndex]->_text = textStr;
_cachedTexts[minIndex]->_textOffset = textOffset;
_cachedTexts[minIndex]->_marked = true;
_cachedTexts[minIndex]->_lastUsed = g_system->getMillis();
}
}
// and paint it
if (surface) {
Rect32 rc;
rc.setRect(0, 0, surface->getWidth(), surface->getHeight());
for (uint32 i = 0; i < _layers.size(); i++) {
uint32 color = _layers[i]->_color;
uint32 origForceAlpha = renderer->_forceAlphaColor;
if (renderer->_forceAlphaColor != 0) {
color = BYTETORGBA(RGBCOLGetR(color), RGBCOLGetG(color), RGBCOLGetB(color), RGBCOLGetA(renderer->_forceAlphaColor));
renderer->_forceAlphaColor = 0;
}
surface->displayTransOffset(x, y - textOffset, rc, color, Graphics::BLEND_NORMAL, false, false, _layers[i]->_offsetX, _layers[i]->_offsetY);
renderer->_forceAlphaColor = origForceAlpha;
}
}
}
bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
//////////////////////////////////////////////////////////////////////////
// Substring
//////////////////////////////////////////////////////////////////////////
if (strcmp(name, "Substring") == 0) {
stack->correctParams(2);
int start = stack->pop()->getInt();
int end = stack->pop()->getInt();
if (end < start) {
BaseUtils::swap(&start, &end);
}
//try {
WideString str;
if (_gameRef->_textEncoding == TEXT_UTF8) {
str = StringUtil::utf8ToWide(_string);
} else {
str = StringUtil::ansiToWide(_string);
}
//WideString subStr = str.substr(start, end - start + 1);
WideString subStr(str.c_str() + start, end - start + 1);
if (_gameRef->_textEncoding == TEXT_UTF8) {
stack->pushString(StringUtil::wideToUtf8(subStr).c_str());
} else {
stack->pushString(StringUtil::wideToAnsi(subStr).c_str());
}
// } catch (std::exception &) {
// stack->pushNULL();
// }
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// Substr
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "Substr") == 0) {
stack->correctParams(2);
int start = stack->pop()->getInt();
ScValue *val = stack->pop();
int len = val->getInt();
if (!val->isNULL() && len <= 0) {
stack->pushString("");
return STATUS_OK;
}
if (val->isNULL()) {
len = strlen(_string) - start;
}
// try {
WideString str;
if (_gameRef->_textEncoding == TEXT_UTF8) {
str = StringUtil::utf8ToWide(_string);
} else {
str = StringUtil::ansiToWide(_string);
}
// WideString subStr = str.substr(start, len);
WideString subStr(str.c_str() + start, len);
if (_gameRef->_textEncoding == TEXT_UTF8) {
stack->pushString(StringUtil::wideToUtf8(subStr).c_str());
} else {
stack->pushString(StringUtil::wideToAnsi(subStr).c_str());
}
// } catch (std::exception &) {
// stack->pushNULL();
// }
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// ToUpperCase
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "ToUpperCase") == 0) {
stack->correctParams(0);
WideString str;
if (_gameRef->_textEncoding == TEXT_UTF8) {
str = StringUtil::utf8ToWide(_string);
} else {
str = StringUtil::ansiToWide(_string);
}
str.toUppercase();
if (_gameRef->_textEncoding == TEXT_UTF8) {
stack->pushString(StringUtil::wideToUtf8(str).c_str());
} else {
stack->pushString(StringUtil::wideToAnsi(str).c_str());
}
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// ToLowerCase
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "ToLowerCase") == 0) {
stack->correctParams(0);
WideString str;
if (_gameRef->_textEncoding == TEXT_UTF8) {
str = StringUtil::utf8ToWide(_string);
} else {
str = StringUtil::ansiToWide(_string);
}
str.toLowercase();
if (_gameRef->_textEncoding == TEXT_UTF8) {
stack->pushString(StringUtil::wideToUtf8(str).c_str());
} else {
stack->pushString(StringUtil::wideToAnsi(str).c_str());
}
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// IndexOf
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "IndexOf") == 0) {
stack->correctParams(2);
const char *strToFind = stack->pop()->getString();
int index = stack->pop()->getInt();
WideString str;
if (_gameRef->_textEncoding == TEXT_UTF8) {
str = StringUtil::utf8ToWide(_string);
} else {
str = StringUtil::ansiToWide(_string);
}
WideString toFind;
if (_gameRef->_textEncoding == TEXT_UTF8) {
toFind = StringUtil::utf8ToWide(strToFind);
} else {
toFind = StringUtil::ansiToWide(strToFind);
}
int indexOf = StringUtil::indexOf(str, toFind, index);
stack->pushInt(indexOf);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
// Split
//////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "Split") == 0) {
stack->correctParams(1);
ScValue *val = stack->pop();
char separators[MAX_PATH_LENGTH] = ",";
if (!val->isNULL()) {
strcpy(separators, val->getString());
}
SXArray *array = new SXArray(_gameRef);
if (!array) {
stack->pushNULL();
return STATUS_OK;
}
WideString str;
if (_gameRef->_textEncoding == TEXT_UTF8) {
str = StringUtil::utf8ToWide(_string);
} else {
str = StringUtil::ansiToWide(_string);
}
WideString delims;
if (_gameRef->_textEncoding == TEXT_UTF8) {
delims = StringUtil::utf8ToWide(separators);
} else {
delims = StringUtil::ansiToWide(separators);
}
Common::Array<WideString> parts;
uint32 start = 0;
for(uint32 i = 0; i < str.size() + 1; i++) {
char ch = str.c_str()[i];
if(ch=='\0' || delims.contains(ch))
{
char *part = new char[i - start + 1];
if(i != start) {
Common::strlcpy(part, str.c_str() + start, i - start + 1);
part[i - start] = '\0';
} else {
part[0] = '\0';
}
val = new ScValue(_gameRef, part);
array->push(val);
delete[] part;
delete val;
val = nullptr;
start = i + 1;
}
}
for (Common::Array<WideString>::iterator it = parts.begin(); it != parts.end(); ++it) {
WideString &part = (*it);
if (_gameRef->_textEncoding == TEXT_UTF8) {
val = new ScValue(_gameRef, StringUtil::wideToUtf8(part).c_str());
} else {
val = new ScValue(_gameRef, StringUtil::wideToAnsi(part).c_str());
}
array->push(val);
delete val;
val = nullptr;
}
stack->pushNative(array, false);
return STATUS_OK;
} else {
return STATUS_FAILED;
}
}
