diff --git a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationDataMgr.cpp b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationDataMgr.cpp index d961d12c..cf9ee052 100644 --- a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationDataMgr.cpp +++ b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationDataMgr.cpp @@ -84,34 +84,34 @@ public: static void XMLCALL HandleData(void *userData, const XML_Char *data, int stringLength); friend class LocalizationDatabase; - // first wstring is language, second is data - typedef std::map element; + // first string is language, second is data + typedef std::map element; - // the wstring is the element name - typedef std::map set; + // the string is the element name + typedef std::map set; - // the wstring is the set name - typedef std::map age; + // the string is the set name + typedef std::map age; - // the wstring is the age name - typedef std::map ageMap; + // the string is the age name + typedef std::map ageMap; protected: bool fWeExploded; // alternative to massive error stack - std::string fFilename; + plString fFilename; XML_Parser fParser; struct tagInfo { - std::wstring fTag; - std::map fAttributes; + plString fTag; + std::map fAttributes; }; std::stack fTagStack; int fSkipDepth; // if we need to skip a block, this is the depth we need to skip to bool fIgnoreContents; // are we ignoring the contents between tags? - std::wstring fCurrentAge, fCurrentSet, fCurrentElement, fCurrentTranslation; + plString fCurrentAge, fCurrentSet, fCurrentElement, fCurrentTranslation; ageMap fData; @@ -126,8 +126,8 @@ protected: public: LocalizationXMLFile() : fWeExploded(false), fFilename("") { } - bool Parse(const std::string & fileName); // returns false on failure - void AddError(const plString& errorText); + bool Parse(const plString & fileName); // returns false on failure + void AddError(const plString & errorText); }; // A few small helper structs @@ -177,12 +177,12 @@ XML_Memory_Handling_Suite gHeapAllocator = { //metmet remove static void XMLCALL LocalizationXMLFile::StartTag(void *userData, const XML_Char *element, const XML_Char **attributes) { - std::wstring wElement = element; + plString wElement = plString::FromWchar(element); LocalizationXMLFile *file = (LocalizationXMLFile*)userData; - std::map wAttributes; + std::map wAttributes; for (int i = 0; attributes[i]; i += 2) - wAttributes[attributes[i]] = attributes[i+1]; + wAttributes[plString::FromWchar(static_cast(attributes[i]))] = plString::FromWchar(static_cast(attributes[i+1])); LocalizationXMLFile::tagInfo parentTag; if (!file->fTagStack.empty()) @@ -198,15 +198,15 @@ void XMLCALL LocalizationXMLFile::StartTag(void *userData, const XML_Char *eleme return; // now we handle this tag - if (wElement == L"localizations") + if (wElement == "localizations") file->IHandleLocalizationsTag(parentTag, newTag); - else if (wElement == L"age") + else if (wElement == "age") file->IHandleAgeTag(parentTag, newTag); - else if (wElement == L"set") + else if (wElement == "set") file->IHandleSetTag(parentTag, newTag); - else if (wElement == L"element") + else if (wElement == "element") file->IHandleElementTag(parentTag, newTag); - else if (wElement == L"translation") + else if (wElement == "translation") file->IHandleTranslationTag(parentTag, newTag); else file->AddError(plString::Format("Unknown tag %S found", wElement.c_str())); @@ -214,7 +214,7 @@ void XMLCALL LocalizationXMLFile::StartTag(void *userData, const XML_Char *eleme //metmet remove static and include the function inside LocalizationXMLFile void XMLCALL LocalizationXMLFile::EndTag(void *userData, const XML_Char *element) { - std::wstring wElement = element; + plString wElement = plString::FromWchar(element); LocalizationXMLFile *file = (LocalizationXMLFile*)userData; if (file->fSkipDepth != -1) // we're currently skipping @@ -224,16 +224,16 @@ void XMLCALL LocalizationXMLFile::EndTag(void *userData, const XML_Char *element file->fSkipDepth = -1; // we're done skipping } - if (wElement == L"age") // we left the age block - file->fCurrentAge = L""; - else if (wElement == L"set") // we left the set block - file->fCurrentSet = L""; - else if (wElement == L"element") // we left the element block - file->fCurrentElement = L""; - else if (wElement == L"translation") // we left the translation block + if (wElement == "age") // we left the age block + file->fCurrentAge = ""; + else if (wElement == "set") // we left the set block + file->fCurrentSet = ""; + else if (wElement == "element") // we left the element block + file->fCurrentElement = ""; + else if (wElement == "translation") // we left the translation block { file->fIgnoreContents = true; - file->fCurrentTranslation = L""; + file->fCurrentTranslation = ""; } file->fTagStack.pop(); @@ -249,7 +249,7 @@ void XMLCALL LocalizationXMLFile::HandleData(void *userData, const XML_Char *dat // This gets all data between tags, including indentation and newlines // so we'll have to ignore data when we aren't expecting it (not in a translation tag) - std::wstring wData = std::wstring(data, stringLength); + plString wData = plString::FromWchar(data); // we must be in a translation tag since that's the only tag that doesn't ignore the contents file->fData[file->fCurrentAge][file->fCurrentSet][file->fCurrentElement][file->fCurrentTranslation] += wData; @@ -265,7 +265,7 @@ void XMLCALL LocalizationXMLFile::HandleData(void *userData, const XML_Char *dat void LocalizationXMLFile::IHandleLocalizationsTag(const LocalizationXMLFile::tagInfo & parentTag, const LocalizationXMLFile::tagInfo & thisTag) { - if (parentTag.fTag != L"") // we only allow tags at root level + if (parentTag.fTag != "") // we only allow tags at root level { AddError("localizations tag only allowed at root level"); return; @@ -277,20 +277,20 @@ void LocalizationXMLFile::IHandleLocalizationsTag(const LocalizationXMLFile::tag void LocalizationXMLFile::IHandleAgeTag(const LocalizationXMLFile::tagInfo & parentTag, const LocalizationXMLFile::tagInfo & thisTag) { // it has to be inside the subtitles tag - if (parentTag.fTag != L"localizations") + if (parentTag.fTag != "localizations") { AddError("age tag can only be directly inside a localizations tag"); return; } // we have to have a name attribute - if (thisTag.fAttributes.find(L"name") == thisTag.fAttributes.end()) + if (thisTag.fAttributes.find("name") == thisTag.fAttributes.end()) { AddError("age tag is missing the name attribute"); return; } - fCurrentAge = thisTag.fAttributes.find(L"name")->second; + fCurrentAge = thisTag.fAttributes.find("name")->second; } //// IHandleSetTag() ///////////////////////////////////////////////// @@ -298,20 +298,20 @@ void LocalizationXMLFile::IHandleAgeTag(const LocalizationXMLFile::tagInfo & par void LocalizationXMLFile::IHandleSetTag(const LocalizationXMLFile::tagInfo & parentTag, const LocalizationXMLFile::tagInfo & thisTag) { // it has to be inside the age tag - if (parentTag.fTag != L"age") + if (parentTag.fTag != "age") { AddError("set tag can only be directly inside a age tag"); return; } // we have to have a name attribute - if (thisTag.fAttributes.find(L"name") == thisTag.fAttributes.end()) + if (thisTag.fAttributes.find("name") == thisTag.fAttributes.end()) { AddError("set tag is missing the name attribute"); return; } - fCurrentSet = thisTag.fAttributes.find(L"name")->second; + fCurrentSet = thisTag.fAttributes.find("name")->second; } //// IHandleElementTag() ///////////////////////////////////////////// @@ -319,20 +319,20 @@ void LocalizationXMLFile::IHandleSetTag(const LocalizationXMLFile::tagInfo & par void LocalizationXMLFile::IHandleElementTag(const LocalizationXMLFile::tagInfo & parentTag, const LocalizationXMLFile::tagInfo & thisTag) { // it has to be inside the element tag - if (parentTag.fTag != L"set") + if (parentTag.fTag != "set") { AddError("element tag can only be directly inside a set tag"); return; } // we have to have a name attribute - if (thisTag.fAttributes.find(L"name") == thisTag.fAttributes.end()) + if (thisTag.fAttributes.find("name") == thisTag.fAttributes.end()) { AddError("element tag is missing the name attribute"); return; } - fCurrentElement = thisTag.fAttributes.find(L"name")->second; + fCurrentElement = thisTag.fAttributes.find("name")->second; } //// IHandleTranslationTag() ///////////////////////////////////////// @@ -340,36 +340,36 @@ void LocalizationXMLFile::IHandleElementTag(const LocalizationXMLFile::tagInfo & void LocalizationXMLFile::IHandleTranslationTag(const LocalizationXMLFile::tagInfo & parentTag, const LocalizationXMLFile::tagInfo & thisTag) { // it has to be inside the element tag - if (parentTag.fTag != L"element") + if (parentTag.fTag != "element") { AddError("translation tag can only be directly inside a element tag"); return; } // we have to have a language attribute - if (thisTag.fAttributes.find(L"language") == thisTag.fAttributes.end()) + if (thisTag.fAttributes.find("language") == thisTag.fAttributes.end()) { AddError("translation tag is missing the language attribute"); return; } fIgnoreContents = false; // we now want contents between tags - fCurrentTranslation = thisTag.fAttributes.find(L"language")->second; + fCurrentTranslation = thisTag.fAttributes.find("language")->second; } //// Parse() ///////////////////////////////////////////////////////// -bool LocalizationXMLFile::Parse(const std::string & fileName) +bool LocalizationXMLFile::Parse(const plString & fileName) { fFilename = fileName; while (!fTagStack.empty()) fTagStack.pop(); - fCurrentAge = L""; - fCurrentSet = L""; - fCurrentElement = L""; - fCurrentTranslation = L""; + fCurrentAge = ""; + fCurrentSet = ""; + fCurrentElement = ""; + fCurrentTranslation = ""; fIgnoreContents = true; fSkipDepth = -1; @@ -390,7 +390,7 @@ bool LocalizationXMLFile::Parse(const std::string & fileName) hsStream *xmlStream = plEncryptedStream::OpenEncryptedFile(fileName.c_str()); if (!xmlStream) { - pfLocalizationDataMgr::GetLog()->AddLineF("ERROR: Can't open file stream for %s", fileName.c_str()); + pfLocalizationDataMgr::GetLog()->AddLineF("ERROR: Can't open file stream for %S", fileName.c_str()); return false; } @@ -424,7 +424,7 @@ bool LocalizationXMLFile::Parse(const std::string & fileName) void LocalizationXMLFile::AddError(const plString& errorText) { - pfLocalizationDataMgr::GetLog()->AddLineF("ERROR (line %d): %s", + pfLocalizationDataMgr::GetLog()->AddLineF("ERROR (line %d): %S", XML_GetCurrentLineNumber(fParser), errorText.c_str()); fSkipDepth = fTagStack.size(); // skip this block fWeExploded = true; @@ -442,27 +442,27 @@ void LocalizationXMLFile::AddError(const plString& errorText) class LocalizationDatabase { protected: - std::string fDirectory; // the directory we're supposed to parse + plString fDirectory; // the directory we're supposed to parse + plString fErrorString; // total sum of all errors encountered (also has warnings and status messages) std::vector fFiles; // the various XML files in that directory LocalizationXMLFile::ageMap fData; - LocalizationXMLFile::element IMergeElementData(LocalizationXMLFile::element firstElement, LocalizationXMLFile::element secondElement, const std::wstring & fileName, const std::wstring & path); - LocalizationXMLFile::set IMergeSetData(LocalizationXMLFile::set firstSet, LocalizationXMLFile::set secondSet, const std::wstring & fileName, const std::wstring & path); - LocalizationXMLFile::age IMergeAgeData(LocalizationXMLFile::age firstAge, LocalizationXMLFile::age secondAge, const std::wstring & fileName, const std::wstring & path); + LocalizationXMLFile::element IMergeElementData(LocalizationXMLFile::element firstElement, LocalizationXMLFile::element secondElement, const plString & fileName, const plString & path); + LocalizationXMLFile::set IMergeSetData(LocalizationXMLFile::set firstSet, LocalizationXMLFile::set secondSet, const plString & fileName, const plString & path); + LocalizationXMLFile::age IMergeAgeData(LocalizationXMLFile::age firstAge, LocalizationXMLFile::age secondAge, const plString & fileName, const plString & path); void IMergeData(); // merge all localization data in the files - void IVerifyElement(const std::wstring &ageName, const std::wstring &setName, LocalizationXMLFile::set::iterator& curElement); - void IVerifySet(const std::wstring &ageName, const std::wstring &setName); - void IVerifyAge(const std::wstring &ageName); + void IVerifyElement(const plString &ageName, const plString &setName, LocalizationXMLFile::set::iterator& curElement); + void IVerifySet(const plString &ageName, const plString &setName); + void IVerifyAge(const plString &ageName); void IVerifyData(); // verify the localization data once it has been merged in public: LocalizationDatabase() {} - void Parse(const std::string & directory); - + void Parse(const plString & directory); LocalizationXMLFile::ageMap GetData() {return fData;} }; @@ -472,7 +472,7 @@ public: //// IMergeElementData /////////////////////////////////////////////// -LocalizationXMLFile::element LocalizationDatabase::IMergeElementData(LocalizationXMLFile::element firstElement, LocalizationXMLFile::element secondElement, const std::wstring & fileName, const std::wstring & path) +LocalizationXMLFile::element LocalizationDatabase::IMergeElementData(LocalizationXMLFile::element firstElement, LocalizationXMLFile::element secondElement, const plString & fileName, const plString & path) { // copy the data over, alerting the user to any duplicate translations LocalizationXMLFile::element::iterator curTranslation; @@ -492,7 +492,7 @@ LocalizationXMLFile::element LocalizationDatabase::IMergeElementData(Localizatio //// IMergeSetData /////////////////////////////////////////////////// -LocalizationXMLFile::set LocalizationDatabase::IMergeSetData(LocalizationXMLFile::set firstSet, LocalizationXMLFile::set secondSet, const std::wstring & fileName, const std::wstring & path) +LocalizationXMLFile::set LocalizationDatabase::IMergeSetData(LocalizationXMLFile::set firstSet, LocalizationXMLFile::set secondSet, const plString & fileName, const plString & path) { // Merge all the elements LocalizationXMLFile::set::iterator curElement; @@ -502,7 +502,7 @@ LocalizationXMLFile::set LocalizationDatabase::IMergeSetData(LocalizationXMLFile if (firstSet.find(curElement->first) == firstSet.end()) firstSet[curElement->first] = curElement->second; else // merge the element in - firstSet[curElement->first] = IMergeElementData(firstSet[curElement->first], curElement->second, fileName, path + L"." + curElement->first); + firstSet[curElement->first] = IMergeElementData(firstSet[curElement->first], curElement->second, fileName, path + "." + curElement->first); } return firstSet; @@ -510,7 +510,7 @@ LocalizationXMLFile::set LocalizationDatabase::IMergeSetData(LocalizationXMLFile //// IMergeAgeData /////////////////////////////////////////////////// -LocalizationXMLFile::age LocalizationDatabase::IMergeAgeData(LocalizationXMLFile::age firstAge, LocalizationXMLFile::age secondAge, const std::wstring & fileName, const std::wstring & path) +LocalizationXMLFile::age LocalizationDatabase::IMergeAgeData(LocalizationXMLFile::age firstAge, LocalizationXMLFile::age secondAge, const plString & fileName, const plString & path) { // Merge all the sets LocalizationXMLFile::age::iterator curSet; @@ -520,7 +520,7 @@ LocalizationXMLFile::age LocalizationDatabase::IMergeAgeData(LocalizationXMLFile if (firstAge.find(curSet->first) == firstAge.end()) firstAge[curSet->first] = curSet->second; else // merge the data in - firstAge[curSet->first] = IMergeSetData(firstAge[curSet->first], curSet->second, fileName, path + L"." + curSet->first); + firstAge[curSet->first] = IMergeSetData(firstAge[curSet->first], curSet->second, fileName, path + "." + curSet->first); } return firstAge; @@ -532,11 +532,6 @@ void LocalizationDatabase::IMergeData() { for (int i = 0; i < fFiles.size(); i++) { - std::wstring wFilename; - wchar_t *buff = hsStringToWString(fFiles[i].fFilename.c_str()); - wFilename = buff; - delete [] buff; - LocalizationXMLFile::ageMap fileData = fFiles[i].fData; LocalizationXMLFile::ageMap::iterator curAge; for (curAge = fileData.begin(); curAge != fileData.end(); curAge++) @@ -545,29 +540,27 @@ void LocalizationDatabase::IMergeData() if (fData.find(curAge->first) == fData.end()) fData[curAge->first] = curAge->second; else // otherwise, merge the data in - fData[curAge->first] = IMergeAgeData(fData[curAge->first], curAge->second, wFilename, curAge->first); + fData[curAge->first] = IMergeAgeData(fData[curAge->first], curAge->second, fFiles[i].fFilename, curAge->first); } } } //// IVerifyElement() //////////////////////////////////////////////// -void LocalizationDatabase::IVerifyElement(const std::wstring &ageName, const std::wstring &setName, LocalizationXMLFile::set::iterator& curElement) +void LocalizationDatabase::IVerifyElement(const plString &ageName, const plString &setName, LocalizationXMLFile::set::iterator& curElement) { - WStringVector languageNames; - std::wstring defaultLanguage; + std::vector languageNames; + plString defaultLanguage; int numLocales = plLocalization::GetNumLocales(); for (int curLocale = 0; curLocale <= numLocales; curLocale++) { - const char *name = plLocalization::GetLanguageName((plLocalization::Language)curLocale); - wchar_t *wName = hsStringToWString(name); - languageNames.push_back(wName); - delete [] wName; + plString name = plLocalization::GetLanguageName((plLocalization::Language)curLocale); + languageNames.push_back(name); } defaultLanguage = languageNames[0]; - std::wstring elementName = curElement->first; + plString elementName = curElement->first; LocalizationXMLFile::element& theElement = curElement->second; LocalizationXMLFile::element::iterator curTranslation = theElement.begin(); @@ -606,13 +599,12 @@ void LocalizationDatabase::IVerifyElement(const std::wstring &ageName, const std //// IVerifySet() //////////////////////////////////////////////////// -void LocalizationDatabase::IVerifySet(const std::wstring &ageName, const std::wstring &setName) +void LocalizationDatabase::IVerifySet(const plString &ageName, const plString &setName) { LocalizationXMLFile::set& theSet = fData[ageName][setName]; LocalizationXMLFile::set::iterator curElement = theSet.begin(); - wchar_t *wDefLang = hsStringToWString(plLocalization::GetLanguageName((plLocalization::Language)0)); - std::wstring defaultLanguage = wDefLang; - delete [] wDefLang; + + plString defaultLanguage = plLocalization::GetLanguageName((plLocalization::Language)0); while (curElement != theSet.end()) { @@ -633,7 +625,7 @@ void LocalizationDatabase::IVerifySet(const std::wstring &ageName, const std::ws //// IVerifyAge() //////////////////////////////////////////////////// -void LocalizationDatabase::IVerifyAge(const std::wstring &ageName) +void LocalizationDatabase::IVerifyAge(const plString &ageName) { LocalizationXMLFile::age& theAge = fData[ageName]; LocalizationXMLFile::age::iterator curSet; @@ -652,13 +644,13 @@ void LocalizationDatabase::IVerifyData() //// Parse() ///////////////////////////////////////////////////////// -void LocalizationDatabase::Parse(const std::string & directory) +void LocalizationDatabase::Parse(const plString & directory) { fDirectory = directory; fFiles.clear(); char filename[255]; - hsFolderIterator xmlFolder((directory+PATH_SEPARATOR_STR).c_str()); + hsFolderIterator xmlFolder((directory + PATH_SEPARATOR_STR).c_str()); while(xmlFolder.NextFileSuffix(".loc")) { xmlFolder.GetPathAndName(filename); @@ -685,30 +677,32 @@ void LocalizationDatabase::Parse(const std::string & directory) //// ISplitString() ////////////////////////////////////////////////// template -void pfLocalizationDataMgr::pf3PartMap::ISplitString(std::wstring key, std::wstring &age, std::wstring &set, std::wstring &name) +void pfLocalizationDataMgr::pf3PartMap::ISplitString(plString key, plString &age, plString &set, plString &name) { - std::wstring::size_type periodLoc = key.find(L"."); - age = key.substr(0, periodLoc); - if (periodLoc >= key.length()) + int periodLoc = key.Find("."); + age = key.Substr(0, periodLoc); + if (periodLoc >= key.GetSize()) { return; // don't get set or name if there isn't any period + } - key = key.substr(periodLoc + 1, key.length()); - periodLoc = key.find(L"."); - set = key.substr(0, periodLoc); - if (periodLoc >= key.length()) + key = key.Substr(periodLoc + 1, key.GetSize()); + periodLoc = key.Find("."); + set = key.Substr(0, periodLoc); + if (periodLoc >= key.GetSize()) { return; // don't get name if there isn't another period + } - name = key.substr(periodLoc + 1, key.length()); + name = key.Substr(periodLoc + 1, key.GetSize()); } //// exists() //////////////////////////////////////////////////////// template -bool pfLocalizationDataMgr::pf3PartMap::exists(const std::wstring & key) +bool pfLocalizationDataMgr::pf3PartMap::exists(const plString & key) { - std::wstring age, set, name; + plString age, set, name; ISplitString(key, age, set, name); - if (age == L"" || set == L"" || name == L"") // if any are missing, it's invalid, so we don't have it + if (age == "" || set == "" || name == "") // if any are missing, it's invalid, so we don't have it return false; // now check individually @@ -726,11 +720,11 @@ bool pfLocalizationDataMgr::pf3PartMap::exists(const std::wstring & key) //// setExists() ///////////////////////////////////////////////////// template -bool pfLocalizationDataMgr::pf3PartMap::setExists(const std::wstring & key) +bool pfLocalizationDataMgr::pf3PartMap::setExists(const plString & key) { - std::wstring age, set, name; + plString age, set, name; ISplitString(key, age, set, name); - if (age == L"" || set == L"") // if any are missing, it's invalid, so we don't have it (ignoring name) + if (age == "" || set == "") // if any are missing, it's invalid, so we don't have it (ignoring name) return false; // now check individually @@ -746,11 +740,11 @@ bool pfLocalizationDataMgr::pf3PartMap::setExists(const std::wstring & key //// erase() ///////////////////////////////////////////////////////// template -void pfLocalizationDataMgr::pf3PartMap::erase(const std::wstring & key) +void pfLocalizationDataMgr::pf3PartMap::erase(const plString & key) { - std::wstring age, set, name; + plString age, set, name; ISplitString(key, age, set, name); - if (age == L"" || set == L"" || name == L"") // if any are missing, it's invalid, so we don't delete it + if (age == "" || set == "" || name == "") // if any are missing, it's invalid, so we don't delete it return; // now check individually @@ -772,9 +766,9 @@ void pfLocalizationDataMgr::pf3PartMap::erase(const std::wstring & key) //// operator[]() //////////////////////////////////////////////////// template -mapT &pfLocalizationDataMgr::pf3PartMap::operator[](const std::wstring &key) +mapT &pfLocalizationDataMgr::pf3PartMap::operator[](const plString &key) { - std::wstring age, set, name; + plString age, set, name; ISplitString(key, age, set, name); return fData[age][set][name]; } @@ -782,9 +776,9 @@ mapT &pfLocalizationDataMgr::pf3PartMap::operator[](const std::wstring &ke //// getAgeList() //////////////////////////////////////////////////// template -WStringVector pfLocalizationDataMgr::pf3PartMap::getAgeList() +std::vector pfLocalizationDataMgr::pf3PartMap::getAgeList() { - WStringVector retVal; + std::vector retVal; typename ThreePartMap::iterator curAge; for (curAge = fData.begin(); curAge != fData.end(); curAge++) @@ -796,10 +790,10 @@ WStringVector pfLocalizationDataMgr::pf3PartMap::getAgeList() //// getSetList() //////////////////////////////////////////////////// template -WStringVector pfLocalizationDataMgr::pf3PartMap::getSetList(const std::wstring & age) +std::vector pfLocalizationDataMgr::pf3PartMap::getSetList(const plString & age) { - WStringVector retVal; - typename std::map >::iterator curSet; + std::vector retVal; + typename std::map >::iterator curSet; if (fData.find(age) == fData.end()) return retVal; // return an empty list, the age doesn't exist @@ -813,10 +807,10 @@ WStringVector pfLocalizationDataMgr::pf3PartMap::getSetList(const std::wst //// getNameList() /////////////////////////////////////////////////// template -WStringVector pfLocalizationDataMgr::pf3PartMap::getNameList(const std::wstring & age, const std::wstring & set) +std::vector pfLocalizationDataMgr::pf3PartMap::getNameList(const plString & age, const plString & set) { - WStringVector retVal; - typename std::map::iterator curName; + std::vector retVal; + typename std::map::iterator curName; if (fData.find(age) == fData.end()) return retVal; // return an empty list, the age doesn't exist @@ -839,7 +833,7 @@ plStatusLog *pfLocalizationDataMgr::fLog = nil; // output logfile //// Constructor/Destructor ////////////////////////////////////////// -pfLocalizationDataMgr::pfLocalizationDataMgr(const std::string & path) +pfLocalizationDataMgr::pfLocalizationDataMgr(const plString & path) { hsAssert(!fInstance, "Tried to create the localization data manager more than once!"); fInstance = this; @@ -869,10 +863,8 @@ pfLocalizationDataMgr::localizedElement pfLocalizationDataMgr::ICreateLocalizedE for (int curLocale = 0; curLocale <= numLocales; curLocale++) { - const char *name = plLocalization::GetLanguageName((plLocalization::Language)curLocale); - wchar_t *wName = hsStringToWString(name); - retVal[wName] = L""; - delete [] wName; + plString name = plLocalization::GetLanguageName((plLocalization::Language)curLocale); + retVal[name] = ""; } return retVal; @@ -880,29 +872,23 @@ pfLocalizationDataMgr::localizedElement pfLocalizationDataMgr::ICreateLocalizedE //// IGetCurrentLanguageName ///////////////////////////////////////// -std::wstring pfLocalizationDataMgr::IGetCurrentLanguageName() +plString pfLocalizationDataMgr::IGetCurrentLanguageName() { - std::wstring retVal; - const char *name = plLocalization::GetLanguageName(plLocalization::GetLanguage()); - wchar_t *wName = hsStringToWString(name); - retVal = wName; - delete [] wName; + plString retVal = plLocalization::GetLanguageName(plLocalization::GetLanguage()); return retVal; } //// IGetAllLanguageNames //////////////////////////////////////////// -WStringVector pfLocalizationDataMgr::IGetAllLanguageNames() +std::vector pfLocalizationDataMgr::IGetAllLanguageNames() { int numLocales = plLocalization::GetNumLocales(); - WStringVector retVal; + std::vector retVal; for (int curLocale = 0; curLocale <= numLocales; curLocale++) { - const char *name = plLocalization::GetLanguageName((plLocalization::Language)curLocale); - wchar_t *wName = hsStringToWString(name); - retVal.push_back(wName); - delete [] wName; + plString name = plLocalization::GetLanguageName((plLocalization::Language)curLocale); + retVal.push_back(name); } return retVal; @@ -910,7 +896,7 @@ WStringVector pfLocalizationDataMgr::IGetAllLanguageNames() //// IConvertSubtitle //////////////////////////////////////////////// -void pfLocalizationDataMgr::IConvertElement(LocElementInfo *elementInfo, const std::wstring & curPath) +void pfLocalizationDataMgr::IConvertElement(LocElementInfo *elementInfo, const plString & curPath) { pfLocalizationDataMgr::localizedElement newElement; int16_t numArgs = -1; @@ -931,7 +917,7 @@ void pfLocalizationDataMgr::IConvertElement(LocElementInfo *elementInfo, const s //// IConvertSet ///////////////////////////////////////////////////// -void pfLocalizationDataMgr::IConvertSet(LocSetInfo *setInfo, const std::wstring & curPath) +void pfLocalizationDataMgr::IConvertSet(LocSetInfo *setInfo, const plString & curPath) { LocalizationXMLFile::set::iterator curElement; for (curElement = setInfo->fSet.begin(); curElement != setInfo->fSet.end(); curElement++) @@ -939,13 +925,13 @@ void pfLocalizationDataMgr::IConvertSet(LocSetInfo *setInfo, const std::wstring LocElementInfo elementInfo; elementInfo.fElement = curElement->second; - IConvertElement(&elementInfo, curPath + L"." + curElement->first); + IConvertElement(&elementInfo, plString::Format("%S.%S", curPath.c_str(), curElement->first.c_str())); } } //// IConvertAge ///////////////////////////////////////////////////// -void pfLocalizationDataMgr::IConvertAge(LocAgeInfo *ageInfo, const std::wstring & curPath) +void pfLocalizationDataMgr::IConvertAge(LocAgeInfo *ageInfo, const plString & curPath) { LocalizationXMLFile::age::iterator curSet; for (curSet = ageInfo->fAge.begin(); curSet != ageInfo->fAge.end(); curSet++) @@ -953,98 +939,70 @@ void pfLocalizationDataMgr::IConvertAge(LocAgeInfo *ageInfo, const std::wstring LocSetInfo setInfo; setInfo.fSet = curSet->second; - IConvertSet(&setInfo, curPath + L"." + curSet->first); - } -} - -//// IConvertToByteStream //////////////////////////////////////////// - -char *pfLocalizationDataMgr::IConvertToByteStream(const std::wstring & data, uint32_t &len) -{ - len = data.length() * 2 + 2; // each wchar_t is two chars and add two bytes for the header - char *retVal = new char[len]; // we don't add an extra byte for the 0 because the parser doesn't need it - char lowByte = 0, highByte = 0; - retVal[0] = (char)0xFF; // insert FFFE for little-endian UTF-16 (big-endian would be FEFF) - retVal[1] = (char)0xFE; - int curByteStreamPos = 2; - for (int curLoc = 0; curLoc < data.length(); curLoc++) - { - wchar_t curChar = data[curLoc]; - lowByte = (char)(curChar & 0x00FF); - highByte = (char)((curChar & 0xFF00) >> 8); - - // since the data is AABBCCDD, we need to put in in our uint8_t stream as BBAADDCC - // (so it kinda looks backward because we're storing this as little-endian) - retVal[curByteStreamPos + 1] = highByte; - retVal[curByteStreamPos] = lowByte; - curByteStreamPos += 2; + IConvertSet(&setInfo, plString::Format("%S.%S", curPath.c_str(), curSet->first.c_str())); } - return retVal; } //// IWriteText ////////////////////////////////////////////////////// -void pfLocalizationDataMgr::IWriteText(const std::string & filename, const std::wstring & ageName, const std::wstring & languageName) +void pfLocalizationDataMgr::IWriteText(const plString & filename, const plString & ageName, const plString & languageName) { bool weWroteData = false; // did we actually write any data of consequence? bool setEmpty = true; // we will try to pretty print it all so it's easy to read for the devs - std::wstring fileData = L"\n"; // stores the xml we are going to write to the file (UTF-16 format) - fileData += L"\n"; - fileData += L"\t\n"; + plStringStream fileData; + fileData << "\n"; // stores the xml we are going to write to the file (UTF-16 format) + fileData << "\n"; + fileData << plString::Format("\t\n", ageName.c_str()); - WStringVector setNames = GetSetList(ageName); + std::vector setNames = GetSetList(ageName); for (int curSet = 0; curSet < setNames.size(); curSet++) { setEmpty = true; // so far, this set is empty - std::wstring setCode = L""; - setCode += L"\t\t\n"; + plStringStream setCode; + setCode << plString::Format("\t\t\n", setNames[curSet].c_str()); - WStringVector elementNames = GetElementList(ageName, setNames[curSet]); + std::vector elementNames = GetElementList(ageName, setNames[curSet]); for (int curElement = 0; curElement < elementNames.size(); curElement++) { - setCode += L"\t\t\t\n"; - std::wstring key = ageName + L"." + setNames[curSet] + L"." + elementNames[curElement]; + setCode << plString::Format("\t\t\t\n", elementNames[curElement].c_str()); + plString key = plString::Format("%S.%S.%S", ageName.c_str(), setNames[curSet].c_str(), elementNames[curElement].c_str()); if (fLocalizedElements[key].find(languageName) != fLocalizedElements[key].end()) { - std::wstring key = ageName + L"." + setNames[curSet] + L"." + elementNames[curElement]; weWroteData = true; setEmpty = false; - setCode += L"\t\t\t\t"; - setCode += fLocalizedElements[key][languageName].ToXML(); - setCode += L"\n"; + setCode << plString::Format("\t\t\t\t", languageName.c_str()); + setCode << fLocalizedElements[key][languageName].ToXML(); + setCode << "\n"; } - setCode += L"\t\t\t\n"; + setCode << "\t\t\t\n"; } - setCode += L"\t\t\n"; + setCode << "\t\t\n"; if (!setEmpty) - fileData += setCode; + fileData << setCode.GetString(); } - fileData += L"\t\n"; - fileData += L"\n"; + fileData << "\t\n"; + fileData << "\n"; if (weWroteData) { // now spit the results out to the file - uint32_t numBytes; - char *byteStream = IConvertToByteStream(fileData, numBytes); hsStream *xmlStream = plEncryptedStream::OpenEncryptedFileWrite(filename.c_str()); - xmlStream->Write(numBytes, byteStream); + xmlStream->Write(fileData.GetLength(), fileData.GetString().c_str()); xmlStream->Close(); delete xmlStream; - delete [] byteStream; } } //// Initialize ////////////////////////////////////////////////////// -void pfLocalizationDataMgr::Initialize(const std::string & path) +void pfLocalizationDataMgr::Initialize(const plString & path) { if (fInstance) return; @@ -1102,17 +1060,17 @@ void pfLocalizationDataMgr::SetupData() //// GetElement ////////////////////////////////////////////////////// -pfLocalizedString pfLocalizationDataMgr::GetElement(const std::wstring & name) +pfLocalizedString pfLocalizationDataMgr::GetElement(const plString & name) { pfLocalizedString retVal; // if this returns before we initialize it, it will be empty, indicating failure if (!fLocalizedElements.exists(name)) // does the requested element exist? return retVal; // nope, so return failure - std::wstring languageName = IGetCurrentLanguageName(); + plString languageName = IGetCurrentLanguageName(); if (fLocalizedElements[name].find(languageName) == fLocalizedElements[name].end()) // current language isn't specified { - languageName = L"English"; // force to english + languageName = "English"; // force to english if (fLocalizedElements[name].find(languageName) == fLocalizedElements[name].end()) // make sure english exists return retVal; // language doesn't exist } @@ -1122,7 +1080,7 @@ pfLocalizedString pfLocalizationDataMgr::GetElement(const std::wstring & name) //// GetSpecificElement ////////////////////////////////////////////// -pfLocalizedString pfLocalizationDataMgr::GetSpecificElement(const std::wstring & name, const std::wstring & language) +pfLocalizedString pfLocalizationDataMgr::GetSpecificElement(const plString & name, const plString & language) { pfLocalizedString retVal; // if this returns before we initialize it, it will have an ID of 0, indicating failure @@ -1138,10 +1096,10 @@ pfLocalizedString pfLocalizationDataMgr::GetSpecificElement(const std::wstring & //// GetLanguages //////////////////////////////////////////////////// -WStringVector pfLocalizationDataMgr::GetLanguages(const std::wstring & ageName, const std::wstring & setName, const std::wstring & elementName) +std::vector pfLocalizationDataMgr::GetLanguages(const plString & ageName, const plString & setName, const plString & elementName) { - WStringVector retVal; - std::wstring key = ageName + L"." + setName + L"." + elementName; + std::vector retVal; + plString key = plString::Format("%S.%S.%S", ageName.c_str(), setName.c_str(), elementName.c_str()); if (fLocalizedElements.exists(key)) { // age, set, and element exists @@ -1149,8 +1107,8 @@ WStringVector pfLocalizationDataMgr::GetLanguages(const std::wstring & ageName, localizedElement::iterator curLanguage; for (curLanguage = elem.begin(); curLanguage != elem.end(); curLanguage++) { - std::wstring language = curLanguage->first; - if (!language.empty()) // somehow blank language names sneak in... so don't return them + plString language = curLanguage->first; + if (!language.IsEmpty()) // somehow blank language names sneak in... so don't return them retVal.push_back(curLanguage->first); } } @@ -1159,9 +1117,9 @@ WStringVector pfLocalizationDataMgr::GetLanguages(const std::wstring & ageName, //// GetElementXMLData /////////////////////////////////////////////// -std::wstring pfLocalizationDataMgr::GetElementXMLData(const std::wstring & name, const std::wstring & languageName) +plString pfLocalizationDataMgr::GetElementXMLData(const plString & name, const plString & languageName) { - std::wstring retVal = L""; + plString retVal = ""; if (fLocalizedElements.exists(name)) { if (fLocalizedElements[name].find(languageName) != fLocalizedElements[name].end()) @@ -1172,9 +1130,9 @@ std::wstring pfLocalizationDataMgr::GetElementXMLData(const std::wstring & name, //// GetElementPlainTextData ///////////////////////////////////////// -std::wstring pfLocalizationDataMgr::GetElementPlainTextData(const std::wstring & name, const std::wstring & languageName) +plString pfLocalizationDataMgr::GetElementPlainTextData(const plString & name, const plString & languageName) { - std::wstring retVal = L""; + plString retVal = ""; if (fLocalizedElements.exists(name)) { if (fLocalizedElements[name].find(languageName) != fLocalizedElements[name].end()) @@ -1185,7 +1143,7 @@ std::wstring pfLocalizationDataMgr::GetElementPlainTextData(const std::wstring & //// SetElementXMLData /////////////////////////////////////////////// -bool pfLocalizationDataMgr::SetElementXMLData(const std::wstring & name, const std::wstring & languageName, const std::wstring & xmlData) +bool pfLocalizationDataMgr::SetElementXMLData(const plString & name, const plString & languageName, const plString & xmlData) { if (!fLocalizedElements.exists(name)) return false; // doesn't exist @@ -1196,7 +1154,7 @@ bool pfLocalizationDataMgr::SetElementXMLData(const std::wstring & name, const s //// SetElementPlainTextData ///////////////////////////////////////// -bool pfLocalizationDataMgr::SetElementPlainTextData(const std::wstring & name, const std::wstring & languageName, const std::wstring & plainText) +bool pfLocalizationDataMgr::SetElementPlainTextData(const plString & name, const plString & languageName, const plString & plainText) { if (!fLocalizedElements.exists(name)) return false; // doesn't exist @@ -1207,31 +1165,31 @@ bool pfLocalizationDataMgr::SetElementPlainTextData(const std::wstring & name, c //// AddLocalization ///////////////////////////////////////////////// -bool pfLocalizationDataMgr::AddLocalization(const std::wstring & name, const std::wstring & newLanguage) +bool pfLocalizationDataMgr::AddLocalization(const plString & name, const plString & newLanguage) { if (!fLocalizedElements.exists(name)) return false; // doesn't exist // copy the english over so it can be localized - fLocalizedElements[name][newLanguage] = fLocalizedElements[name][L"English"]; + fLocalizedElements[name][newLanguage] = fLocalizedElements[name]["English"]; return true; } //// AddElement ////////////////////////////////////////////////////// -bool pfLocalizationDataMgr::AddElement(const std::wstring & name) +bool pfLocalizationDataMgr::AddElement(const plString & name) { if (fLocalizedElements.exists(name)) return false; // already exists pfLocalizedString newElement; - fLocalizedElements[name][L"English"] = newElement; + fLocalizedElements[name]["English"] = newElement; return true; } //// DeleteLocalization ////////////////////////////////////////////// -bool pfLocalizationDataMgr::DeleteLocalization(const std::wstring & name, const std::wstring & languageName) +bool pfLocalizationDataMgr::DeleteLocalization(const plString & name, const plString & languageName) { if (!fLocalizedElements.exists(name)) return false; // doesn't exist @@ -1245,7 +1203,7 @@ bool pfLocalizationDataMgr::DeleteLocalization(const std::wstring & name, const //// DeleteElement /////////////////////////////////////////////////// -bool pfLocalizationDataMgr::DeleteElement(const std::wstring & name) +bool pfLocalizationDataMgr::DeleteElement(const plString & name) { if (!fLocalizedElements.exists(name)) return false; // doesn't exist @@ -1257,24 +1215,16 @@ bool pfLocalizationDataMgr::DeleteElement(const std::wstring & name) //// WriteDatabaseToDisk ///////////////////////////////////////////// -void pfLocalizationDataMgr::WriteDatabaseToDisk(const std::string & path) +void pfLocalizationDataMgr::WriteDatabaseToDisk(const plString & path) { // first, write the styles and panel settings to styles.sub - WStringVector ageNames = GetAgeList(); - WStringVector languageNames = IGetAllLanguageNames(); + std::vector ageNames = GetAgeList(); + std::vector languageNames = IGetAllLanguageNames(); for (int curAge = 0; curAge < ageNames.size(); curAge++) { for (int curLanguage = 0; curLanguage < languageNames.size(); curLanguage++) { - std::string cAgeName, cLanguageName; - char *temp = hsWStringToString(ageNames[curAge].c_str()); - cAgeName = temp; - delete [] temp; - temp = hsWStringToString(languageNames[curLanguage].c_str()); - cLanguageName = temp; - delete [] temp; - - IWriteText(path + "/" + cAgeName + cLanguageName + ".loc", ageNames[curAge], languageNames[curLanguage]); + IWriteText(plString::Format("%S/%S%S.loc", path, ageNames[curAge].c_str(), languageNames[curLanguage].c_str()), ageNames[curAge], languageNames[curLanguage]); } } } @@ -1283,26 +1233,26 @@ void pfLocalizationDataMgr::WriteDatabaseToDisk(const std::string & path) void pfLocalizationDataMgr::OutputTreeToLog() { - WStringVector ages = GetAgeList(); + std::vector ages = GetAgeList(); fLog->AddLine("\n"); fLog->AddLine("Localization tree:\n"); - for (WStringVector::iterator i = ages.begin(); i != ages.end(); ++i) + for (std::vector::iterator i = ages.begin(); i != ages.end(); ++i) { - std::wstring age = *i; + plString age = *i; fLog->AddLineF("\t%S", age.c_str()); - WStringVector sets = GetSetList(age); - for (WStringVector::iterator j = sets.begin(); j != sets.end(); ++j) + std::vector sets = GetSetList(age); + for (std::vector::iterator j = sets.begin(); j != sets.end(); ++j) { - std::wstring set = (*j); + plString set = (*j); fLog->AddLineF("\t\t%S", set.c_str()); - WStringVector names = GetElementList(age, set); - for (WStringVector::iterator k = names.begin(); k != names.end(); ++k) + std::vector names = GetElementList(age, set); + for (std::vector::iterator k = names.begin(); k != names.end(); ++k) { - std::wstring name = (*k); + plString name = (*k); fLog->AddLineF("\t\t\t%S", name.c_str()); } } diff --git a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationDataMgr.h b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationDataMgr.h index fbbc7832..52b2ec03 100644 --- a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationDataMgr.h +++ b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationDataMgr.h @@ -55,6 +55,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com #include "pfLocalizedString.h" class plStatusLog; +class plString; // Helper classes/structs that are only used in this main class class LocalizationDatabase; @@ -81,49 +82,48 @@ protected: { protected: // Outer map is Age, then Set, finally Name - typedef std::map > > ThreePartMap; + typedef std::map > > ThreePartMap; ThreePartMap fData; - void ISplitString(std::wstring key, std::wstring &age, std::wstring &set, std::wstring &name); + void ISplitString(plString key, plString &age, plString &set, plString &name); public: // We will just have very basic functionality - bool exists(const std::wstring & key); // returns true if the key exists - bool setExists(const std::wstring & key); // returns true if the age.set exists (ignores name if passed in) - void erase(const std::wstring & key); // erases the key from the map + bool exists(const plString & key); // returns true if the key exists + bool setExists(const plString & key); // returns true if the age.set exists (ignores name if passed in) + void erase(const plString & key); // erases the key from the map - mapT &operator[](const std::wstring &key); // returns the item referenced by the key (and creates if necessary) + mapT &operator[](const plString &key); // returns the item referenced by the key (and creates if necessary) - WStringVector getAgeList(); // returns a list of all ages in this map - WStringVector getSetList(const std::wstring & age); // returns a list of all sets in the specified age - WStringVector getNameList(const std::wstring & age, const std::wstring & set); + std::vector getAgeList(); // returns a list of all ages in this map + std::vector getSetList(const plString & age); // returns a list of all sets in the specified age + std::vector getNameList(const plString & age, const plString & set); }; LocalizationDatabase *fDatabase; - typedef std::map localizedElement; + typedef std::map localizedElement; // Contains all localized strings, the key is the Age.Set.Name specified by XML, in localizedElement, the key is the language string pf3PartMap fLocalizedElements; - std::string fDataPath; + plString fDataPath; localizedElement ICreateLocalizedElement(); // ease of use function that creates a basic localized element object - std::wstring IGetCurrentLanguageName(); // get the name of the current language - WStringVector IGetAllLanguageNames(); + plString IGetCurrentLanguageName(); // get the name of the current language + std::vector IGetAllLanguageNames(); - void IConvertElement(LocElementInfo *elementInfo, const std::wstring & curPath); - void IConvertSet(LocSetInfo *setInfo, const std::wstring & curPath); - void IConvertAge(LocAgeInfo *ageInfo, const std::wstring & curPath); + void IConvertElement(LocElementInfo *elementInfo, const plString & curPath); + void IConvertSet(LocSetInfo *setInfo, const plString & curPath); + void IConvertAge(LocAgeInfo *ageInfo, const plString & curPath); - char *IConvertToByteStream(const std::wstring & data, uint32_t &len); // converts the wstring data to a string of bytes for file writing - void IWriteText(const std::string & filename, const std::wstring & ageName, const std::wstring & languageName); // Write localization text to the specified file + void IWriteText(const plString & filename, const plString & ageName, const plString & languageName); // Write localization text to the specified file - pfLocalizationDataMgr(const std::string & path); + pfLocalizationDataMgr(const plString & path); public: virtual ~pfLocalizationDataMgr(); - static void Initialize(const std::string & path); + static void Initialize(const plString & path); static void Shutdown(); static pfLocalizationDataMgr &Instance(void) {return *fInstance;} static bool InstanceValid(void) {return fInstance != nil;} @@ -131,32 +131,38 @@ public: void SetupData(); - pfLocalizedString GetElement(const std::wstring & name); - pfLocalizedString GetSpecificElement(const std::wstring & name, const std::wstring & languageName); + pfLocalizedString GetElement(const plString & name); + pfLocalizedString GetSpecificElement(const plString & name, const plString & languageName); - WStringVector GetAgeList() { return fLocalizedElements.getAgeList(); } - WStringVector GetSetList(const std::wstring & ageName) { return fLocalizedElements.getSetList(ageName); } - WStringVector GetElementList(const std::wstring & ageName, const std::wstring & setName) + std::vector GetAgeList() + { + return fLocalizedElements.getAgeList(); + } + std::vector GetSetList(const plString & ageName) + { + return fLocalizedElements.getSetList(ageName); + } + std::vector GetElementList(const plString & ageName, const plString & setName) { return fLocalizedElements.getNameList(ageName, setName); } - WStringVector GetLanguages(const std::wstring & ageName, const std::wstring & setName, const std::wstring & elementName); + std::vector GetLanguages(const plString & ageName, const plString & setName, const plString & elementName); - std::wstring GetElementXMLData(const std::wstring & name, const std::wstring & languageName); - std::wstring GetElementPlainTextData(const std::wstring & name, const std::wstring & languageName); + plString GetElementXMLData(const plString & name, const plString & languageName); + plString GetElementPlainTextData(const plString & name, const plString & languageName); // These convert the XML data to the actual subtitle and return true if successful (editor only) - bool SetElementXMLData(const std::wstring & name, const std::wstring & languageName, const std::wstring & xmlData); - bool SetElementPlainTextData(const std::wstring & name, const std::wstring & languageName, const std::wstring & plainText); + bool SetElementXMLData(const plString & name, const plString & languageName, const plString & xmlData); + bool SetElementPlainTextData(const plString & name, const plString & languageName, const plString & plainText); // Addition and deletion functions, return true if successful (editor only) - bool AddLocalization(const std::wstring & name, const std::wstring & newLanguage); - bool AddElement(const std::wstring & name); - bool DeleteLocalization(const std::wstring & name, const std::wstring & languageName); - bool DeleteElement(const std::wstring & name); + bool AddLocalization(const plString & name, const plString & newLanguage); + bool AddElement(const plString & name); + bool DeleteLocalization(const plString & name, const plString & languageName); + bool DeleteElement(const plString & name); // Writes the current database to the disk (editor only). It will create all the files and put them into path - void WriteDatabaseToDisk(const std::string & path); + void WriteDatabaseToDisk(const plString & path); void OutputTreeToLog(); // prints the localization tree to the log file }; diff --git a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationMgr.cpp b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationMgr.cpp index a91eaa89..3d47e5fe 100644 --- a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationMgr.cpp +++ b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationMgr.cpp @@ -79,7 +79,7 @@ void pfLocalizationMgr::Initialize(const std::string & dataPath) return; fInstance = new pfLocalizationMgr(); - pfLocalizationDataMgr::Initialize(dataPath); // set up the data manager + pfLocalizationDataMgr::Initialize(dataPath.c_str()); // set up the data manager } //// Shutdown //////////////////////////////////////////////////////// @@ -95,13 +95,13 @@ void pfLocalizationMgr::Shutdown() //// GetString /////////////////////////////////////////////////////// -std::wstring pfLocalizationMgr::GetString(const std::wstring & path, const std::vector & args) +plString pfLocalizationMgr::GetString(const plString & path, const std::vector & args) { return pfLocalizationDataMgr::Instance().GetElement(path) % args; } -std::wstring pfLocalizationMgr::GetString(const std::wstring & path) +plString pfLocalizationMgr::GetString(const plString & path) { - std::vector args; // blank args so that % signs are still handled correctly + std::vector args; // blank args so that % signs are still handled correctly return pfLocalizationDataMgr::Instance().GetElement(path) % args; } diff --git a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationMgr.h b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationMgr.h index ccb10063..e8df4234 100644 --- a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationMgr.h +++ b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationMgr.h @@ -70,8 +70,8 @@ public: // want the arguments in a different order (like you had to switch things around for a specific language) // then you use %1s, %2s, %3s and so on to specify arguments, these two cannot be mixed and you won't get // the results you expect if you do mix them. Path is specified by Age.Set.Name - std::wstring GetString(const std::wstring & path, const std::vector & args); - std::wstring GetString(const std::wstring & path); + plString GetString(const plString & path, const std::vector & args); + plString GetString(const plString & path); }; #endif diff --git a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizedString.cpp b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizedString.cpp index 704215f7..404d94e4 100644 --- a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizedString.cpp +++ b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizedString.cpp @@ -62,13 +62,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com //// Constructors //////////////////////////////////////////////////// -pfLocalizedString::pfLocalizedString(const wchar_t *plainText) -{ - fNumArguments = 0; - IConvertFromPlainText(plainText); -} - -pfLocalizedString::pfLocalizedString(const std::wstring & plainText) +pfLocalizedString::pfLocalizedString(const plString & plainText) { fNumArguments = 0; IConvertFromPlainText(plainText); @@ -76,7 +70,7 @@ pfLocalizedString::pfLocalizedString(const std::wstring & plainText) //// IConvertFromPlainText /////////////////////////////////////////// -void pfLocalizedString::IConvertFromPlainText(const std::wstring & plainText) +void pfLocalizedString::IConvertFromPlainText(const plString & plainText) { textBlock curTextBlock; fText.clear(); @@ -84,22 +78,23 @@ void pfLocalizedString::IConvertFromPlainText(const std::wstring & plainText) fNumArguments = 0; // reset the argument count int curParameter = 0; - for (std::wstring::size_type curIndex = 0; curIndex < plainText.size(); curIndex++) + plString::iterator iter = plainText.GetIterator(); + while (!iter.AtEnd()) { - wchar_t curChar = plainText[curIndex]; - bool isLastChar = (curIndex == (plainText.length() - 1)); + wchar_t curChar = *iter; + bool isLastChar = iter.AtEnd(); switch (curChar) { case L'\\': if (!isLastChar) { // we need to see the next character - curIndex++; - wchar_t nextChar = plainText[curIndex]; + iter++; + wchar_t nextChar = *iter; if ((nextChar == L'%')||(nextChar == L'\\')) { // we recognize it as an escaped character, so add it to the text - curTextBlock.fText += nextChar; + curTextBlock.fText += plString::FromWchar((const wchar_t *)(nextChar)); } // otherwise we don't recognize it and it will be skipped } @@ -157,28 +152,24 @@ void pfLocalizedString::IConvertFromPlainText(const std::wstring & plainText) void pfLocalizedString::IUpdatePlainText() { - fPlainTextRep = L""; - for (std::vector::size_type curIndex = 0; curIndex < fText.size(); curIndex++) + fPlainTextRep = ""; + + for (std::vector::size_type curIndex = 0; curIndex < fText.size(); curIndex++) { textBlock curTextBlock = fText[curIndex]; if (curTextBlock.fIsParam) { - std::wstring paramStr = L"%"; - wchar_t buff[256]; - swprintf(buff, 256, L"%d", curTextBlock.fParamIndex + 1); - paramStr += buff; - paramStr += L"s"; - fPlainTextRep += paramStr; + fPlainTextRep += plString::Format("%%%ds", curTextBlock.fParamIndex + 1); } else { // otherwise, we need to copy all the text over, making sure that % and \ are properly escaped - for (std::wstring::size_type curChar = 0; curChar < curTextBlock.fText.size(); curChar++) + for (plString::iterator iter = curTextBlock.fText.GetIterator(); !iter.AtEnd(); iter++) { - if ((curTextBlock.fText[curChar] == L'\\')||(curTextBlock.fText[curChar] == L'%')) - fPlainTextRep += L"\\"; - fPlainTextRep += curTextBlock.fText[curChar]; + if (((*iter) == L'\\') || ((*iter) == L'%')) + fPlainTextRep += "\\"; + fPlainTextRep += plString::FromWchar((const wchar_t *)(*iter)); } } } @@ -186,7 +177,7 @@ void pfLocalizedString::IUpdatePlainText() //// IConvertFromXML ///////////////////////////////////////////////// -void pfLocalizedString::IConvertFromXML(const std::wstring & xml) +void pfLocalizedString::IConvertFromXML(const plString & xml) { textBlock curTextBlock; fText.clear(); @@ -267,35 +258,32 @@ void pfLocalizedString::IConvertFromXML(const std::wstring & xml) void pfLocalizedString::IUpdateXML() { - fXMLRep = L""; - for (std::vector::size_type curIndex = 0; curIndex < fText.size(); curIndex++) + fXMLRep = ""; + for (std::vector::size_type curIndex = 0; curIndex < fText.size(); curIndex++) { textBlock curTextBlock = fText[curIndex]; if (curTextBlock.fIsParam) { - std::wstring paramStr = L"%"; - wchar_t buff[256]; - swprintf(buff, 256, L"%d", curTextBlock.fParamIndex + 1); - paramStr += buff; - paramStr += L"s"; + plString paramStr = plString::Format("%%%ds", curTextBlock.fParamIndex + 1); fXMLRep += paramStr; } else { // otherwise, we need to copy all the text over, making sure that %, &, <, and > are properly converted - for (std::wstring::size_type curChar = 0; curChar < curTextBlock.fText.size(); curChar++) + for (plString::iterator iter = curTextBlock.fText.GetIterator(); !iter.AtEnd(); iter++) { - if (curTextBlock.fText[curChar] == L'%') - fXMLRep += L"\\%"; - else if (curTextBlock.fText[curChar] == L'&') - fXMLRep += L"&"; - else if (curTextBlock.fText[curChar] == L'<') - fXMLRep += L"<"; - else if (curTextBlock.fText[curChar] == L'>') - fXMLRep += L">"; + UniChar curChar = *iter; + if (curChar == L'%') + fXMLRep += "\\%"; + else if (curChar == L'&') + fXMLRep += "&"; + else if (curChar == L'<') + fXMLRep += "<"; + else if (curChar == L'>') + fXMLRep += ">"; else - fXMLRep += curTextBlock.fText[curChar]; + fXMLRep += plString::FromWchar((const wchar_t *)curChar); } } } @@ -303,7 +291,7 @@ void pfLocalizedString::IUpdateXML() //// FromXML ///////////////////////////////////////////////////////// -void pfLocalizedString::FromXML(const std::wstring & xml) +void pfLocalizedString::FromXML(const plString & xml) { IConvertFromXML(xml); } @@ -354,22 +342,16 @@ pfLocalizedString &pfLocalizedString::operator+=(pfLocalizedString &obj) return *this; } -pfLocalizedString &pfLocalizedString::operator=(const std::wstring & plainText) -{ - IConvertFromPlainText(plainText); - return *this; -} - -pfLocalizedString &pfLocalizedString::operator=(const wchar_t *plainText) +pfLocalizedString &pfLocalizedString::operator=(const plString & plainText) { IConvertFromPlainText(plainText); return *this; } -std::wstring pfLocalizedString::operator%(const std::vector & arguments) +plString pfLocalizedString::operator%(const std::vector & arguments) { - std::wstring retVal = L""; - for (std::vector::size_type curIndex = 0; curIndex < fText.size(); curIndex++) + plString retVal = ""; + for (std::vector::size_type curIndex = 0; curIndex < fText.size(); curIndex++) { if (fText[curIndex].fIsParam) { diff --git a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizedString.h b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizedString.h index fc5f4f3f..58350353 100644 --- a/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizedString.h +++ b/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizedString.h @@ -51,9 +51,8 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com #define _pfLocalizedString_h #include "HeadSpin.h" +#include "plString.h" #include -#include - //// pfLocalizedString Class Definition ////////////////////////////// // a small class to handle localized strings and which can take @@ -67,30 +66,29 @@ protected: struct textBlock { bool fIsParam; // if true, then this is a parameter, not a string - std::wstring fText; - uint8_t fParamIndex; + plString fText; + uint8_t fParamIndex; textBlock() : fIsParam(false), fParamIndex(0) {} }; - std::vector fText; // the individual text elements that make up this string - std::wstring fXMLRep; // the XML representation of this string - std::wstring fPlainTextRep; // the plain text representation of this string - uint16_t fNumArguments; // number of arguments this string has + std::vector fText; // the individual text elements that make up this string + plString fXMLRep; // the XML representation of this string + plString fPlainTextRep; // the plain text representation of this string + uint16_t fNumArguments; // number of arguments this string has - void IConvertFromPlainText(const std::wstring & plainText); + void IConvertFromPlainText(const plString & plainText); void IUpdatePlainText(); // from the internal representation - void IConvertFromXML(const std::wstring & xml); + void IConvertFromXML(const plString & xml); void IUpdateXML(); // from the internal representation public: pfLocalizedString() : fNumArguments(0) {} - pfLocalizedString(const wchar_t *plainText); - pfLocalizedString(const std::wstring & plainText); + pfLocalizedString(const plString & plainText); virtual ~pfLocalizedString() {} // To translate to and from xml format (where <, > and other signs can't be used) - void FromXML(const std::wstring & xml); - std::wstring ToXML() {return fXMLRep;} + void FromXML(const plString & xml); + plString ToXML() {return fXMLRep;} uint16_t GetArgumentCount() {return fNumArguments;} @@ -103,17 +101,14 @@ public: bool operator>=(pfLocalizedString &obj); bool operator!=(pfLocalizedString &obj); - //operator const wchar_t *() {return fPlainTextRep.c_str();} - operator std::wstring() {return fPlainTextRep;} + operator plString() {return fPlainTextRep;} pfLocalizedString operator+(pfLocalizedString &obj); pfLocalizedString &operator+=(pfLocalizedString &obj); - - pfLocalizedString &operator=(const std::wstring & plainText); - pfLocalizedString &operator=(const wchar_t *plainText); + pfLocalizedString &operator=(const plString & plainText); // Specialized operator for replacing text with arguments - std::wstring operator%(const std::vector & arguments); + plString operator%(const std::vector & arguments); }; #endif