You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
140 lines
4.9 KiB
140 lines
4.9 KiB
/*==LICENSE==* |
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools |
|
Copyright (C) 2011 Cyan Worlds, Inc. |
|
|
|
This program is free software: you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation, either version 3 of the License, or |
|
(at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
|
Additional permissions under GNU GPL version 3 section 7 |
|
|
|
If you modify this Program, or any covered work, by linking or |
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
(or a modified version of those libraries), |
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
licensors of this Program grant you additional |
|
permission to convey the resulting work. Corresponding Source for a |
|
non-source form of such a combination shall include the source code for |
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
work. |
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
|
or by snail mail at: |
|
Cyan Worlds, Inc. |
|
14617 N Newport Hwy |
|
Mead, WA 99021 |
|
|
|
*==LICENSE==*/ |
|
#ifndef plLocalization_h_inc |
|
#define plLocalization_h_inc |
|
|
|
#include "hsStlUtils.h" |
|
#include <set> |
|
|
|
class plLocalization |
|
{ |
|
public: |
|
enum Language |
|
{ |
|
kEnglish, |
|
kFrench, |
|
kGerman, |
|
kSpanish, |
|
kItalian, |
|
kJapanese, |
|
|
|
kNumLanguages, |
|
}; |
|
|
|
typedef enum encodingTypes |
|
{ |
|
Enc_Unencoded, // This can also mean that python did the decoding for us and we don't need to tweak it on our end |
|
Enc_Split_String, |
|
Enc_Hybrid_Split_String, |
|
Enc_UTF8, |
|
Enc_UTF16, |
|
Enc_Unicode_Escape, |
|
Enc_Raw_Unicode_Escape, |
|
Enc_Latin_1, |
|
Enc_ASCII, |
|
Enc_MBCS |
|
}; |
|
|
|
protected: |
|
static Language fLanguage; |
|
static const char* fLangTags[kNumLanguages]; |
|
#if defined(_MSC_VER) && (_MSC_VER >= 1600) |
|
static const std::set<std::string> fLangCodes[kNumLanguages]; |
|
#endif |
|
static const char* fLangNames[kNumLanguages]; |
|
static bool fUsesUnicode[kNumLanguages]; |
|
static encodingTypes fUnicodeEncoding[kNumLanguages]; |
|
|
|
static hsBool IGetLocalized(const char* name, Language lang, char* localizedName); |
|
|
|
public: |
|
// Sets the default language, as determined by the installer |
|
static void SetDefaultLanguage(); |
|
|
|
static void SetLanguage(Language lang) { fLanguage = lang; } |
|
static Language GetLanguage() { return fLanguage; } |
|
|
|
static const char* GetLanguageName(Language lang) { return fLangNames[lang]; } |
|
#if defined(_MSC_VER) && _MSC_VER >= 1600 |
|
static std::set<std::string> GetLanguageCodes(Language lang) { return fLangCodes[lang]; } |
|
#endif |
|
|
|
static hsBool UsingUnicode() { return fUsesUnicode[fLanguage]; } |
|
static encodingTypes UnicodeEncoding() { return fUnicodeEncoding[fLanguage]; } |
|
|
|
// Returns true if we're using localized assets. If it returns false, you |
|
// don't need to bother calling GetLocalized |
|
static hsBool IsLocalized() { return fLanguage != kEnglish; } |
|
|
|
// Pass in a key name and this will give you the localized name |
|
// Returns false if the original keyname is not for a localized asset |
|
static hsBool GetLocalized(const char* name, char* localizedName) { return IGetLocalized(name, fLanguage, localizedName); } |
|
|
|
// |
|
// Export only |
|
// |
|
// When you're exporting an asset that could be localized, you'll want to do |
|
// a loop something like this to try and find any localized versions. |
|
// |
|
// for (int i = 0; i < plLocalization::GetNumLocales(); i++) |
|
// { |
|
// char localName[MAX_PATH]; |
|
// if (plLocalization::ExportGetLocalized(fileName, i, localName)) |
|
// { |
|
// ... |
|
// } |
|
// } |
|
// |
|
static int GetNumLocales() { return kNumLanguages - 1; } |
|
static hsBool ExportGetLocalized(const char* name, int lang, char* localizedName); |
|
// Just tells us if this is localized, doesn't actually convert it for us |
|
static hsBool IsLocalizedName(const char* name) { return IGetLocalized(name, kEnglish, nil); } |
|
|
|
// Converts a vector of translated strings to a encoded string that can be decoded by StringToLocal() |
|
// The index in the vector of a string is it's language |
|
static std::string LocalToString(const std::vector<std::string> & localizedText); |
|
// Converts a string encoded by LocalToString to a vector of translated strings |
|
static std::vector<std::string> StringToLocal(const std::string & localizedText); |
|
static std::vector<std::wstring> StringToLocal(const std::wstring & localizedText); |
|
}; |
|
|
|
#endif // plLocalization_h_inc
|
|
|