REString localized(const char * s)
{
REString resString;
if (s && _localizedTableName && _localizedBundle)
{
CFStringRef key = CFStringCreateWithCString(NULL, s ,kCFStringEncodingUTF8);
if (key)
{
CFStringRef loc = CFBundleCopyLocalizedString(_localizedBundle, key, key, _localizedTableName);
if (loc)
{
const size_t buffSize = 512 * sizeof(wchar_t);
char buff[buffSize] = { 0 };
if (CFStringGetCString(loc, buff, buffSize, kCFStringEncodingUTF8))
{
resString = buff;
}
CFRelease(loc);
}
CFRelease(key);
}
}
if (resString.isEmpty()) resString = s;
return resString;
}
int test1UUIDv4()
{
REStringList _uuids;
for (int i = 0; i < 10000; i++)
{
REString u = REUUIDv4().uuid();
if (u.length() != 36)
{
return EXIT_FAILURE;
}
// std::cout << u << std::endl;
if (_uuids.isContaines(u))
{
return EXIT_FAILURE;
}
_uuids.add(u);
}
return EXIT_SUCCESS;
}
REVector3 REVector3::fromString(const REString & string)
{
if (string.length() > 0)
{
REVector3 v;
if (REStringUtilsPrivate::readArrayF32(string.UTF8String(), v.coords, 3, ';') == 3)
{
return v;
}
}
return REVector3();
}
RESize RESize::fromString(const REString & string)
{
if (string.length() > 0)
{
RESize s;
if (REStringUtilsPrivate::readArrayF32(string.UTF8String(), s.size, 2, ';') == 2)
{
return s;
}
}
return RESize();
}
REAffineTransform REAffineTransform::fromString(const REString & string)
{
if (string.length() > 0)
{
REAffineTransform t;
if (REStringUtilsPrivate::readArrayF32(string.UTF8String(), t.arr, 6, ';') == 6)
{
return t;
}
}
return REAffineTransform();
}
REBOOL REData::initFromPath( const REString & filePath )
{
this->clear();
if (filePath.isEmpty())
{
return false;
}
const char * s = filePath.UTF8String();
const REUInt32 l = filePath.length();
return this->initFromPath(s, l);
}
REBOOL REXMLSerializableReader::Read(const REString & xmlString)
{
#ifndef __RE_NO_XML_PARSER_PRIVATE__
_totalElementsCount = 0;
_processedElementsCount = 0;
_isError = false;
if (_controller && _callBack.CreateNewObject)
{
XMLDocument doc;
doc.Parse(xmlString.UTF8String());
if (doc.Error()) { return false; }
XMLElement * root = doc.RootElement();
if (root == NULL) { return false; }
const char * rootVal = root->Value();
if (rootVal)
{
if (strcmp(rootVal, "viewcontroller") == 0)
{
_totalElementsCount = this->CalculateElements(root);
#if 0
if ( this->ParseObject(root, _controller, _controller) )
{
return true;
}
#endif
_isError = true;
}
}
}
#endif
return false;
}
void RETexture::deserializeWithDictionary(const RETypedPtr & dictionary)
{
RETypedPtr d(dictionary);
REDictionary * dict = d.dictionary();
if (dict)
{
REString * str = dict->valueForKey("frame").string();
if (str) { _frame = RETetragon::fromString(str->UTF8String()); }
RENumber * num = dict->valueForKey("filter").number();
const RETextureFilterType filter = num ? (RETextureFilterType)num->int32Value() : RETextureFilterLinear;
str = dict->valueForKey(RETexture::imagePathKey()).string();
if (str)
{
this->initWithImageFilePath(*str, filter);
}
}
}
void REView::deserializeWithDictionary(const RETypedPtr & dictionary)
{
REDictionary * dict = dictionary.dictionary();
if (dict)
{
REString * str = dict->valueForKey("frame").string();
if (str) { this->setFrame(RERect::fromString(str->UTF8String())); }
str = dict->valueForKey("color").string();
if (str) { this->setColor(REColor::fromString(str->UTF8String())); }
RENumber * num = dict->valueForKey("tag").number();
if (num) { this->setTag(num->int32Value()); }
num = dict->valueForKey("visible").number();
if (num) { this->setVisible(num->boolValue()); }
num = dict->valueForKey("responduseraction").number();
if (num) { this->setRespondsForUserAction(num->boolValue()); }
num = dict->valueForKey("interceptuseraction").number();
if (num) { this->setInterceptsUserAction(num->boolValue()); }
RETypedPtr textureDict(dict->valueForKey("texture"));
REDictionary * texture = textureDict.dictionary();
if (texture)
{
REGUIApplication * app = REGUIApplication::currentApplication();
if (app)
{
RETexture * t = app->createSerializableClassWithDictionary<RETexture>(textureDict);
if (t)
{
t->deserializeWithDictionary(textureDict);
this->setTexture(t);
t->release();
}
}
else { RELog::log("ERROR: REGUIApplication not initialized"); }
}
}
RESubviewsContainer::deserializeWithDictionary(dictionary);
}
REBOOL REFontObject::fillArrayWithCharsForText(REArray<RETTFFontChar*> * charsArray,
const REString & text)
{
if (charsArray && text.length())
{
REArray<RETTFFontChar*> * fontChars = this->getChars();
if (REArray<RETTFFontChar *>::isNotEmpty(fontChars))
{
return REFontObject::fillArrayWithCharsForTextFromFont(charsArray, text, fontChars);
}
}
return false;
}
void * REGUIApplication::createSerializableObjectWithDictionary(const RETypedPtr & dictionary)
{
REDictionary * dict = dictionary.dictionary();
if (dict)
{
REString * className = dict->valueForKey(RESerializable::classNameKey()).string();
if (className)
{
#if defined(__RE_DEBUG_MODE__) && defined(__DEBUG_MESSAGES_FOR_CREATE_SERIALIZABLE__)
RELog::log("GUI create '%s'", className->UTF8String());
#endif
void * object = this->createObjectWithClassName(className->UTF8String());
if (object)
{
RESerializable * serializableFromVoid = REPtrCast<RESerializable, void>(object);
if (serializableFromVoid)
{
RESerializable * serializable = dynamic_cast<RESerializable *>(serializableFromVoid);
if (serializable)
{
#if defined(__RE_DEBUG_MODE__) && defined(__DEBUG_MESSAGES_FOR_CREATE_SERIALIZABLE__)
const unsigned long long ___v0 = (unsigned long long)object;
const unsigned long long ___v1 = (unsigned long long)serializableFromVoid;
const unsigned long long ___v2 = (unsigned long long)serializable;
const bool ___allOK = ((___v0 == ___v1) && (___v0 == ___v2));
if (!___allOK)
{
RELog::log("GUI create '%s' void[%llu], ptrCast[%llu], dynCast[%llu]", className->UTF8String(), ___v0, ___v1, ___v2);
}
#endif
return object;
}
}
}
}
}
return NULL;
}
REBOOL REAudioPlayer::initFromFilePath(const REString & filePath)
{
if (filePath.isEmpty())
{
return false;
}
REData d;
if (d.initFromPath(filePath))
{
return this->initWithData(d);
}
return false;
}
REBOOL RETexture::initWithImageFilePath(const REString & imageFilePath,
const RETextureFilterType filterType)
{
if (imageFilePath.isNotEmpty() && (filterType != RETextureFilterNone))
{
REData data;
if (data.initFromPath(imageFilePath))
{
REImage image;
if (image.initFromFileData(data))
{
data.clear();
return this->initWithImage(image, filterType);
}
}
}
return false;
}
REMutableString::REMutableString(const REString & anotherString) :
REString(anotherString.UTF8String(), anotherString.length())
{
}
QString WebSocketQt::toString(const REString & s)
{
return s.isNotEmpty() ? QString(s.UTF8String()) : QString("");
}
