language_c::language_c(char * setupLang, SystemDefault_c * SystemDefault) : collection_c() {
current = -1;
langDir = new char[MAX_PATH];
strcpy(langDir,SystemDefault->PrgPath);
strcat(langDir,"lang\\");
char * SerPath = new char[MAX_PATH];
strcpy(SerPath,langDir);
strcat(SerPath,"*.xml");
WIN32_FIND_DATA FindFileData;
HANDLE hFind;
hFind = FindFirstFile(SerPath, &FindFileData);
if (hFind != INVALID_HANDLE_VALUE) {
LoadLanguageFile(FindFileData.cFileName);
while (FindNextFile(hFind,&FindFileData )) {
LoadLanguageFile(FindFileData.cFileName);
}
FindClose(hFind);
}
delete[] SerPath;
//////////////////////////////
// Detect Systemdefault
//////////////////////////////
// setup = aSetup;
int ConfigLang = hexToInt(setupLang);
current = getLangID(ConfigLang);
if (current == -1) {
int UserLang = GetUserDefaultUILanguage();
if (current == -1) {current = getLangID(UserLang);}
if (current == -1) {current = getLangIDMain(PRIMARYLANGID(UserLang));}
int SysLang = GetSystemDefaultUILanguage();
if (current == -1) {current = getLangID(SysLang);}
if (current == -1) {current = getLangIDMain(PRIMARYLANGID(SysLang));}
}
}
StringTable::LangId NativeApp::RAD_IMPLEMENT_GET(systemLangId) {
StringTable::LangId id = StringTable::LangId_EN;
LANGID winId = GetUserDefaultUILanguage();
switch (winId&0xff) {
case LANG_CHINESE:
id = StringTable::LangId_CH;
break;
case LANG_FRENCH:
id = StringTable::LangId_FR;
break;
case LANG_GERMAN:
id = StringTable::LangId_GR;
break;
case LANG_ITALIAN:
id = StringTable::LangId_IT;
break;
case LANG_JAPANESE:
id = StringTable::LangId_JP;
break;
case LANG_RUSSIAN:
case LANG_UKRAINIAN:
id = StringTable::LangId_RU;
break;
case LANG_SPANISH:
id = StringTable::LangId_SP;
break;
default:
break;
}
return id;
}
CefString ClientApp::GetCurrentLanguage()
{
// Get the user's selected language
// Defaults to the system installed language if not using MUI.
LANGID langID = GetUserDefaultUILanguage();
// Convert LANGID to a RFC 4646 language tag (per navigator.language)
int langSize = GetLocaleInfo(langID, LOCALE_SISO639LANGNAME, NULL, 0);
int countrySize = GetLocaleInfo(langID, LOCALE_SISO3166CTRYNAME, NULL, 0);
wchar_t *lang = new wchar_t[langSize + countrySize + 1];
wchar_t *country = new wchar_t[countrySize];
GetLocaleInfo(langID, LOCALE_SISO639LANGNAME, lang, langSize);
GetLocaleInfo(langID, LOCALE_SISO3166CTRYNAME, country, countrySize);
// add hyphen
wcscat(wcscat(lang, L"-"), country);
std::wstring locale(lang);
delete [] lang;
delete [] country;
return CefString(locale);
}
static HRESULT WINAPI OmNavigator_get_browserLanguage(IOmNavigator *iface, BSTR *p)
{
OmNavigator *This = impl_from_IOmNavigator(iface);
TRACE("(%p)->(%p)\n", This, p);
return get_language_string(GetUserDefaultUILanguage(), p);
}
LANGID Translations::SetDefaultLanguage()
{
auto languageResource = GetLanguageResourceByLocaleID(GetUserDefaultUILanguage());
// Try to set the language resource but don't fail if it can't be loaded
// English will we used instead in case of error
return SetLanguage(languageResource, false) ? languageResource.localeID : 0;
}
static unsigned
AutoDetect()
{
#ifndef HAVE_POSIX
// Retrieve the default user language identifier from the OS
LANGID lang_id = GetUserDefaultUILanguage();
LogFormat("Units: GetUserDefaultUILanguage() = 0x%x", (int)lang_id);
if (lang_id == 0)
return 0;
return FindLanguage(lang_id);
#elif defined(ANDROID)
JNIEnv *env = Java::GetEnv();
Java::Class cls(env, "java/util/Locale");
// Call static function Locale.getDefault() that
// returns the user's default Locale object
jmethodID cid = env->GetStaticMethodID(cls, "getDefault",
"()Ljava/util/Locale;");
assert(cid != nullptr);
Java::LocalObject obj(env, env->CallStaticObjectMethod(cls, cid));
if (!obj)
return 0;
// Call function Locale.getLanguage() that
// returns a two-letter language string
jstring language = Java::Object::toString(env, obj);
if (language == nullptr)
return 0;
// Convert the jstring to a char string
const char *language2 = env->GetStringUTFChars(language, nullptr);
if (language2 == nullptr) {
env->DeleteLocalRef(language);
return 0;
}
unsigned id = FindLanguage(language2);
// Clean up the memory
env->ReleaseStringUTFChars(language, language2);
env->DeleteLocalRef(language);
// Return e.g. "de.mo"
return id;
#else
// Metric default on Linux
return 0;
#endif
}
const char * Application::getCurrentLanguageCode()
{
LANGID lid = GetUserDefaultUILanguage();
const LCID locale_id = MAKELCID(lid, SORT_DEFAULT);
static char code[3] = { 0 };
GetLocaleInfoA(locale_id, LOCALE_SISO639LANGNAME, code, sizeof(code));
code[2] = '\0';
return code;
}
int APIENTRY wWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPWSTR lpCmdLine,
int nCmdShow)
{
MSG msg;
HACCEL hAccel;
UNREFERENCED_PARAMETER(hPrevInstance);
if (ProcessCmdLine(lpCmdLine))
{
return 0;
}
/* Initialize global strings */
LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadStringW(hInstance, IDC_REGEDIT_FRAME, szFrameClass, MAX_LOADSTRING);
LoadStringW(hInstance, IDC_REGEDIT, szChildClass, MAX_LOADSTRING);
switch (GetUserDefaultUILanguage())
{
case MAKELANGID(LANG_HEBREW, SUBLANG_DEFAULT):
SetProcessDefaultLayout(LAYOUT_RTL);
break;
default:
break;
}
/* Store instance handle in our global variable */
hInst = hInstance;
/* Perform application initialization */
if (!InitInstance(hInstance, nCmdShow))
{
return 0;
}
hAccel = LoadAcceleratorsW(hInstance, MAKEINTRESOURCEW(ID_ACCEL));
/* Main message loop */
while (GetMessageW(&msg, NULL, 0, 0))
{
if (!TranslateAcceleratorW(hFrameWnd, hAccel, &msg) &&
!TranslateChildTabMessage(&msg))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
ExitInstance(hInstance);
return (int)msg.wParam;
}
enum retro_language frontend_win32_get_user_language(void)
{
enum retro_language lang = RETRO_LANGUAGE_ENGLISH;
#if defined(HAVE_LANGEXTRA) && !defined(_XBOX)
#if (defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0500) || !defined(_MSC_VER)
LANGID langid = GetUserDefaultUILanguage();
unsigned i;
struct lang_pair
{
unsigned short lang_ident;
enum retro_language lang;
};
/* https://docs.microsoft.com/en-us/windows/desktop/Intl/language-identifier-constants-and-strings */
const struct lang_pair pairs[] =
{
{0x9, RETRO_LANGUAGE_ENGLISH},
{0x11, RETRO_LANGUAGE_JAPANESE},
{0xc, RETRO_LANGUAGE_FRENCH},
{0xa, RETRO_LANGUAGE_SPANISH},
{0x7, RETRO_LANGUAGE_GERMAN},
{0x10, RETRO_LANGUAGE_ITALIAN},
{0x13, RETRO_LANGUAGE_DUTCH},
{0x416, RETRO_LANGUAGE_PORTUGUESE_BRAZIL},
{0x816, RETRO_LANGUAGE_PORTUGUESE_PORTUGAL},
{0x16, RETRO_LANGUAGE_PORTUGUESE_PORTUGAL},
{0x19, RETRO_LANGUAGE_RUSSIAN},
{0x12, RETRO_LANGUAGE_KOREAN},
{0xC04, RETRO_LANGUAGE_CHINESE_TRADITIONAL}, /* HK/PRC */
{0x1404, RETRO_LANGUAGE_CHINESE_TRADITIONAL}, /* MO */
{0x1004, RETRO_LANGUAGE_CHINESE_SIMPLIFIED}, /* SG */
{0x7c04, RETRO_LANGUAGE_CHINESE_TRADITIONAL}, /* neutral */
{0x4, RETRO_LANGUAGE_CHINESE_SIMPLIFIED}, /* neutral */
/* MS does not support Esperanto */
/*{0x0, RETRO_LANGUAGE_ESPERANTO},*/
{0x15, RETRO_LANGUAGE_POLISH},
{0x2a, RETRO_LANGUAGE_VIETNAMESE},
{0x1, RETRO_LANGUAGE_ARABIC},
{0x8, RETRO_LANGUAGE_GREEK},
};
for (i = 0; i < sizeof(pairs) / sizeof(pairs[0]); i++)
{
if ((langid & pairs[i].lang_ident) == pairs[i].lang_ident)
{
lang = pairs[i].lang;
break;
}
}
#endif
#endif
return lang;
}
Common::String OSystem_SDL::getSystemLanguage() const {
#if defined(USE_DETECTLANG) && !defined(_WIN32_WCE)
#ifdef WIN32
// We can not use "setlocale" (at least not for MSVC builds), since it
// will return locales like: "English_USA.1252", thus we need a special
// way to determine the locale string for Win32.
char langName[9];
char ctryName[9];
const LCID languageIdentifier = GetUserDefaultUILanguage();
if (GetLocaleInfo(languageIdentifier, LOCALE_SISO639LANGNAME, langName, sizeof(langName)) != 0 &&
GetLocaleInfo(languageIdentifier, LOCALE_SISO3166CTRYNAME, ctryName, sizeof(ctryName)) != 0) {
Common::String localeName = langName;
localeName += "_";
localeName += ctryName;
return localeName;
} else {
return ModularBackend::getSystemLanguage();
}
#else // WIN32
// Activating current locale settings
const Common::String locale = setlocale(LC_ALL, "");
// Restore default C locale to prevent issues with
// portability of sscanf(), atof(), etc.
// See bug #3615148
setlocale(LC_ALL, "C");
// Detect the language from the locale
if (locale.empty()) {
return ModularBackend::getSystemLanguage();
} else {
int length = 0;
// Strip out additional information, like
// ".UTF-8" or the like. We do this, since
// our translation languages are usually
// specified without any charset information.
for (int size = locale.size(); length < size; ++length) {
// TODO: Check whether "@" should really be checked
// here.
if (locale[length] == '.' || locale[length] == ' ' || locale[length] == '@')
break;
}
return Common::String(locale.c_str(), length);
}
#endif // WIN32
#else // USE_DETECTLANG
return ModularBackend::getSystemLanguage();
#endif // USE_DETECTLANG
}
const char * GetBestMatchedLanguageString()
{
// LCID localeid = GetSystemDefaultLCID();
LANGID langid = GetUserDefaultUILanguage ();
switch (langid & 0xF) {
case 0x04: // zh related
return "cn";
default :
return "en";
}
}
static int lua_MessageBox(lua_State *L)
{
HWND hwnd = (HWND)lua_touserdata(L, 1);
ptrT text(mir_utf8decodeT(lua_tostring(L, 2)));
ptrT caption(mir_utf8decodeT(lua_tostring(L, 3)));
UINT flags = lua_tointeger(L, 4);
LANGID langId = GetUserDefaultUILanguage();
DWORD timeout = luaL_optinteger(L, 5, 0xFFFFFFFF);
int res = ::MessageBoxTimeout(hwnd, text, caption, flags, langId, timeout);
lua_pushinteger(L, res);
return 1;
}
/**************************************************************************
* FGetComponentPath (MAPI32.254)
* FGetComponentPath@20 (MAPI32.255)
*
* Return the installed component path, usually to the private mapi32.dll.
*
* PARAMS
* component [I] Component ID
* qualifier [I] Application LCID
* dll_path [O] returned component path
* dll_path_length [I] component path length
* install [I] install mode
*
* RETURNS
* Success: TRUE.
* Failure: FALSE.
*
* NOTES
* Previously documented in Q229700 "How to locate the correct path
* to the Mapisvc.inf file in Microsoft Outlook".
*/
BOOL WINAPI FGetComponentPath(LPCSTR component, LPCSTR qualifier, LPSTR dll_path,
DWORD dll_path_length, BOOL install)
{
BOOL ret = FALSE;
HMODULE hmsi;
TRACE("%s %s %p %u %d\n", component, qualifier, dll_path, dll_path_length, install);
if (mapiFunctions.FGetComponentPath)
return mapiFunctions.FGetComponentPath(component, qualifier, dll_path, dll_path_length, install);
dll_path[0] = 0;
hmsi = LoadLibraryA("msi.dll");
if (hmsi)
{
UINT (WINAPI *pMsiProvideQualifiedComponentA)(LPCSTR, LPCSTR, DWORD, LPSTR, LPDWORD);
pMsiProvideQualifiedComponentA = (void *)GetProcAddress(hmsi, "MsiProvideQualifiedComponentA");
if (pMsiProvideQualifiedComponentA)
{
static const char * const fmt[] = { "%d\\NT", "%d\\95", "%d" };
char lcid_ver[20];
UINT i;
for (i = 0; i < sizeof(fmt)/sizeof(fmt[0]); i++)
{
/* FIXME: what's the correct behaviour here? */
if (!qualifier || qualifier == lcid_ver)
{
sprintf(lcid_ver, fmt[i], GetUserDefaultUILanguage());
qualifier = lcid_ver;
}
if (pMsiProvideQualifiedComponentA(component, qualifier,
install ? INSTALLMODE_DEFAULT : INSTALLMODE_EXISTING,
dll_path, &dll_path_length) == ERROR_SUCCESS)
{
ret = TRUE;
break;
}
if (qualifier != lcid_ver) break;
}
}
FreeLibrary(hmsi);
}
return ret;
}
LANGID FindDefaultLang()
{
const LANGID sysLID = GetUserDefaultUILanguage();
if (IsLangSupport(sysLID))
return sysLID;
else {
switch (sysLID & 0x00FF) {
case 0x04:
if (sysLID != 0x0804)
return LANGID_ZH_TW;
break;
}
}
return LANGID_EN_US;
}
static String localeInfo(LCTYPE localeType, const String& fallback)
{
LANGID langID = GetUserDefaultUILanguage();
int localeChars = GetLocaleInfo(langID, localeType, 0, 0);
if (!localeChars)
return fallback;
Vector<WCHAR> localeNameBuf(localeChars);
localeChars = GetLocaleInfo(langID, localeType, localeNameBuf.data(), localeChars);
if (!localeChars)
return fallback;
String localeName = String::adopt(localeNameBuf);
if (localeName.isEmpty())
return fallback;
return localeName;
}
BSTR charset_string_from_cp(UINT cp)
{
MIMECPINFO info;
HRESULT hres;
if(!ensure_mlang())
return SysAllocString(NULL);
hres = IMultiLanguage2_GetCodePageInfo(mlang, cp, GetUserDefaultUILanguage(), &info);
if(FAILED(hres)) {
ERR("GetCodePageInfo failed: %08x\n", hres);
return SysAllocString(NULL);
}
return SysAllocString(info.wszWebCharset);
}
static String localeInfo(LCTYPE localeType, const String& fallback)
{
LANGID langID = GetUserDefaultUILanguage();
int localeChars = GetLocaleInfo(langID, localeType, 0, 0);
if (!localeChars)
return fallback;
UChar* localeNameBuf;
String localeName = String::createUninitialized(localeChars, localeNameBuf);
localeChars = GetLocaleInfo(langID, localeType, localeNameBuf, localeChars);
if (!localeChars)
return fallback;
if (localeName.isEmpty())
return fallback;
return localeName;
}
std::string
translation_c::get_default_ui_locale() {
std::string locale;
#if defined(HAVE_LIBINTL_H)
bool debug = debugging_c::requested("locale");
# if defined(SYS_WINDOWS)
std::string env_var = mtx::sys::get_environment_variable("LC_MESSAGES");
if (!env_var.empty() && (-1 != look_up_translation(env_var)))
return env_var;
env_var = mtx::sys::get_environment_variable("LANG");
if (!env_var.empty() && (-1 != look_up_translation(env_var)))
return env_var;
auto lang_id = GetUserDefaultUILanguage();
int idx = translation_c::look_up_translation(lang_id & 0x3ff, (lang_id >> 10) & 0x3f);
if (-1 != idx)
locale = ms_available_translations[idx].get_locale();
mxdebug_if(debug, boost::format("[lang_id %|1$04x| idx %2% locale %3%\n") % lang_id % idx % locale);
# else // SYS_WINDOWS
char *data = setlocale(LC_MESSAGES, nullptr);
if (data) {
std::string previous_locale = data;
mxdebug_if(debug, boost::format("[get_default_ui_locale previous %1%]\n") % previous_locale);
setlocale(LC_MESSAGES, "");
data = setlocale(LC_MESSAGES, nullptr);
if (data)
locale = data;
mxdebug_if(debug, boost::format("[get_default_ui_locale new %1%]\n") % locale);
setlocale(LC_MESSAGES, previous_locale.c_str());
} else
mxdebug_if(debug, boost::format("[get_default_ui_locale get previous failed]\n"));
# endif // SYS_WINDOWS
#endif // HAVE_LIBINTL_H
return locale;
}
static LANGID
GetGUILanguage(void)
{
if (gui_language != 0)
return gui_language;
HKEY regkey;
DWORD value = 0;
LONG status = RegOpenKeyEx(HKEY_CURRENT_USER, GUI_REGKEY_HKCU, 0, KEY_READ, ®key);
if (status == ERROR_SUCCESS)
GetRegistryValueNumeric(regkey, _T("ui_language"), &value);
gui_language = ( value != 0 ? value : GetUserDefaultUILanguage() );
InitMUILanguage(gui_language);
return gui_language;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
MSG msg;
HACCEL hAccelTable;
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
switch (GetUserDefaultUILanguage())
{
case MAKELANGID(LANG_HEBREW, SUBLANG_DEFAULT):
SetProcessDefaultLayout(LAYOUT_RTL);
break;
default:
break;
}
/* Initialize global strings */
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
MyRegisterClass(hInstance);
/* Perform application initialization */
if (!InitInstance(hInstance, nCmdShow))
return FALSE;
hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_MAGNIFIER));
/* Main message loop */
while (GetMessage(&msg, NULL, 0, 0))
{
if (!TranslateAccelerator(hMainWnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
SelectObject(hdcOffscreen, hbmpOld);
DeleteObject (hbmpOffscreen);
DeleteDC(hdcOffscreen);
return (int) msg.wParam;
}
QVariant QSystemLocalePrivate::uiLanguages()
{
if (QSysInfo::windowsVersion() >= QSysInfo::WV_VISTA) {
typedef BOOL (WINAPI *GetUserPreferredUILanguagesFunc) (
DWORD dwFlags,
PULONG pulNumLanguages,
PWSTR pwszLanguagesBuffer,
PULONG pcchLanguagesBuffer);
static GetUserPreferredUILanguagesFunc GetUserPreferredUILanguages_ptr = 0;
if (!GetUserPreferredUILanguages_ptr) {
QSystemLibrary lib(QLatin1String("kernel32"));
if (lib.load())
GetUserPreferredUILanguages_ptr = (GetUserPreferredUILanguagesFunc)lib.resolve("GetUserPreferredUILanguages");
}
if (GetUserPreferredUILanguages_ptr) {
unsigned long cnt = 0;
QVarLengthArray<wchar_t, 64> buf(64);
unsigned long size = buf.size();
if (!GetUserPreferredUILanguages_ptr(MUI_LANGUAGE_NAME, &cnt, buf.data(), &size)) {
size = 0;
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER &&
GetUserPreferredUILanguages_ptr(MUI_LANGUAGE_NAME, &cnt, NULL, &size)) {
buf.resize(size);
if (!GetUserPreferredUILanguages_ptr(MUI_LANGUAGE_NAME, &cnt, buf.data(), &size))
return QStringList();
}
}
QStringList result;
result.reserve(cnt);
const wchar_t *str = buf.constData();
for (; cnt > 0; --cnt) {
QString s = QString::fromWCharArray(str);
if (s.isEmpty())
break; // something is wrong
result.append(s);
str += s.size()+1;
}
return result;
}
}
// old Windows before Vista
return QStringList(QString::fromLatin1(winLangCodeToIsoName(GetUserDefaultUILanguage())));
}
// FindLocaleDirectory: Search the provided path for one of the expected code page subdirectories
// Returns empty string on failure, or the full path to the c:\my\directory\1033\myrcfile.dll
static MyString FindLocaleDirectory(const MyString &path, const MyString &dllName)
{
// We'll be checking for 3 different locales: The user's default locale
// The user's primary language locale, and english (in that order)
const LCID lcidUser = MAKELCID(GetUserDefaultUILanguage(), SORT_DEFAULT);
LCID rglcid[3] = {lcidUser, MAKELCID(MAKELANGID(PRIMARYLANGID(lcidUser), SUBLANG_DEFAULT), SORTIDFROMLCID(lcidUser)), ENGLISH_LCID};
for (int i = 0; i < _countof(rglcid); i++)
{
LCID lcid = rglcid[i];
// Turn the LCID into a string
wchar_t wzNumBuf[12];
_itow_s(lcid, wzNumBuf, _countof(wzNumBuf), 10);
MyString localePath = MakePath(path, wzNumBuf, dllName);
// Check to see if the file exists
if (FileExists(localePath))
{
// make sure the console can support a codepage for this language.
UINT ConsoleCP = GetConsoleOutputCP();
// Dev10 #843375: For a GUI application, GetConsoleOutputCP returns 0
// If that's the case, we don't care about capabilities of the console,
// since we're not outputting to the console, anyway...
if ( ConsoleCP != 0 && lcid != ENGLISH_LCID )
{
LANGID LanguageID = MAKELANGID( lcid, SUBLANGID(lcid) );
// we know the console cannot support arabic or hebrew (right to left scripts?)
if( PRIMARYLANGID(LanguageID) == LANG_ARABIC || PRIMARYLANGID(LanguageID) == LANG_HEBREW )
continue;
UINT LangOEMCodepage = GetCodePage(LanguageID, LOCALE_IDEFAULTCODEPAGE);
UINT LangANSICodepage = GetCodePage(LanguageID, LOCALE_IDEFAULTANSICODEPAGE);
// We can only support it if the console's code page is UTF8, OEM, or ANSI
if( ConsoleCP != CP_UTF8 && ConsoleCP != LangOEMCodepage && ConsoleCP != LangANSICodepage )
continue;
}
return localePath;
}
}
return W("");
}
// Parses the settings from an ini file. Supports UTF16, UTF8 or ANSI files
// Use forceLang for force a specific language
void ParseTranslations( const wchar_t *fname, const wchar_t *forceLang )
{
g_Translations.Reset();
if (fname)
{
if (!g_Translations.LoadText(fname)) return;
g_Translations.ParseText();
}
wchar_t languages[100]={0};
if (forceLang && *forceLang)
{
int len=(int)wcslen(forceLang);
if (len>5) len=5;
memcpy(languages,forceLang,len*2);
wcscpy_s(languages+len+1,10,L"default");
}
else
{
ULONG size=4; // up to 4 languages
ULONG len=_countof(languages);
GetThreadPreferredUILanguages(MUI_LANGUAGE_NAME,&size,languages,&len);
wcscpy_s(languages+len-1,10,L"default");
languages[len+7]=0;
}
g_Translations.FilterLanguages(languages);
// Checks for right-to-left languages
g_bRTL=false;
LOCALESIGNATURE localesig;
LANGID language=GetUserDefaultUILanguage();
if (forceLang && *forceLang)
{
if (GetLocaleInfoEx(forceLang,LOCALE_FONTSIGNATURE,(LPWSTR)&localesig,(sizeof(localesig)/sizeof(wchar_t))) && (localesig.lsUsb[3]&0x08000000))
g_bRTL=true;
}
else
{
if (GetLocaleInfoW(language,LOCALE_FONTSIGNATURE,(LPWSTR)&localesig,(sizeof(localesig)/sizeof(wchar_t))) && (localesig.lsUsb[3]&0x08000000))
g_bRTL=true;
}
}
const char *GuessLanguage()
{
LANGID langId = GetUserDefaultUILanguage();
LANGID langIdNoSublang = MAKELANGID(PRIMARYLANGID(langId), SUBLANG_NEUTRAL);
const char *langCode = NULL;
// Either find the exact primary/sub lang id match, or a neutral sublang if it exists
// (don't return any sublang for a given language, it might be too different)
for (int i = 0; i < LANGS_COUNT; i++) {
if (langId == gLangData[i].id)
return gLangData[i].code;
if (langIdNoSublang == gLangData[i].id)
langCode = gLangData[i].code;
// continue searching after finding a match with a neutral sublanguage
}
return langCode;
}
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
// TODO: Place code here.
MSG msg;
HACCEL hAccelTable;
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
switch (GetUserDefaultUILanguage())
{
case MAKELANGID(LANG_HEBREW, SUBLANG_DEFAULT):
SetProcessDefaultLayout(LAYOUT_RTL);
break;
default:
break;
}
// Initialize global strings
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
MyRegisterClass(hInstance);
// Perform application initialization:
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_MAGNIFIER));
// Main message loop:
while (GetMessage(&msg, NULL, 0, 0))
{
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int) msg.wParam;
}
void SelectTranslation(const WCHAR *exePath=NULL)
{
LANGID langId = GetUserDefaultUILanguage();
int idx = GetLanguageIndex(langId);
if (-1 == idx) {
// try a neutral language if the specific sublanguage isn't available
langId = MAKELANGID(PRIMARYLANGID(langId), SUBLANG_NEUTRAL);
idx = GetLanguageIndex(langId);
}
if (-1 != idx) {
gTranslationIdx = idx;
plogf("sp: Detected language %s (%d)", gLanguages[idx / gTranslationsCount], idx);
}
// try to extract the language used by SumatraPDF
ScopedMem<WCHAR> path;
if (exePath) {
path.Set(path::GetDir(exePath));
path.Set(path::Join(path, PREFS_FILE_NAME));
}
if (!file::Exists(path)) {
path.Set(GetSpecialFolder(CSIDL_APPDATA));
path.Set(path::Join(path, L"SumatraPDF\\" PREFS_FILE_NAME));
}
if (!file::Exists(path))
return;
plogf("sp: Found preferences at %S", path);
ScopedMem<char> prefsData(file::ReadAll(path, NULL));
SquareTree sqt(prefsData);
const char *langCode = sqt.root ? sqt.root->GetValue("UiLanguage") : NULL;
if (langCode) {
plogf("sp: UiLanguage from preferences: %s", langCode);
for (int i = 0; gLanguages[i]; i++) {
if (str::Eq(gLanguages[i], langCode)) {
gTranslationIdx = i * gTranslationsCount;
break;
}
}
}
}
int WINAPI
wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nShowCmd)
{
WNDCLASSEXW WndClass = {0};
WCHAR szWindowClass[] = L"ROSAPPMGR";
WCHAR szWindowName[MAX_STR_LEN];
WCHAR szErrorText[MAX_STR_LEN];
HANDLE hMutex = NULL;
MSG Msg;
switch (GetUserDefaultUILanguage())
{
case MAKELANGID(LANG_HEBREW, SUBLANG_DEFAULT):
SetProcessDefaultLayout(LAYOUT_RTL);
break;
default:
break;
}
hInst = hInstance;
if (!IsUserAnAdmin())
{
LoadStringW(hInst, IDS_USER_NOT_ADMIN, szErrorText, sizeof(szErrorText) / sizeof(WCHAR));
MessageBox(0, szErrorText, NULL, MB_OK | MB_ICONWARNING);
return 1;
}
hMutex = CreateMutexW(NULL, FALSE, szWindowClass);
if ((!hMutex) || (GetLastError() == ERROR_ALREADY_EXISTS))
{
/* If already started, it is found its window */
HWND hWindow = FindWindowW(szWindowClass, NULL);
/* Activate window */
ShowWindow(hWindow, SW_SHOWNORMAL);
SetForegroundWindow(hWindow);
return 1;
}
if (!LoadSettings())
{
FillDefaultSettings(&SettingsInfo);
}
InitLogs();
InitCommonControls();
/* Create the window */
WndClass.cbSize = sizeof(WNDCLASSEXW);
WndClass.lpszClassName = szWindowClass;
WndClass.lpfnWndProc = MainWindowProc;
WndClass.hInstance = hInstance;
WndClass.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MAIN));
WndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
WndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
WndClass.lpszMenuName = MAKEINTRESOURCEW(IDR_MAINMENU);
if (RegisterClassExW(&WndClass) == (ATOM)0) goto Exit;
LoadStringW(hInst, IDS_APPTITLE, szWindowName, sizeof(szWindowName) / sizeof(WCHAR));
hMainWnd = CreateWindowExW(WS_EX_WINDOWEDGE,
szWindowClass,
szWindowName,
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
CW_USEDEFAULT,
CW_USEDEFAULT,
680,
450,
NULL,
NULL,
hInstance,
NULL);
if (!hMainWnd) goto Exit;
/* Show it */
ShowWindow(hMainWnd, SW_SHOW);
UpdateWindow(hMainWnd);
/* Message Loop */
while (GetMessage(&Msg, NULL, 0, 0))
{
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
Exit:
if (hMutex) CloseHandle(hMutex);
return 0;
}
bool _GetDescription(ISpObjectToken *p_token, WCHAR **r_description)
{
typedef HRESULT (WINAPI *_RegLoadMUIStringWPtr)(HKEY, LPCWSTR, LPWSTR, DWORD, LPDWORD, DWORD, LPCWSTR);
static HMODULE s_advapi32 = NULL;
static _RegLoadMUIStringWPtr s_RegLoadMUIStringW = NULL;
if (s_advapi32 == NULL)
{
// Attempt to load function RegLoadMUIStringW which should be available if we're running on Vista & later
s_advapi32 = LoadLibraryA("advapi32.dll");
if(s_advapi32 != NULL)
s_RegLoadMUIStringW = (_RegLoadMUIStringWPtr)GetProcAddress(s_advapi32, "RegLoadMUIStringW");
}
bool t_success = true;
if (r_description == NULL)
{
return false;
}
WCHAR *t_description = NULL;
if(s_RegLoadMUIStringW != NULL)
{
WCHAR* t_path = NULL;
WCHAR* t_reg_key = NULL;
HKEY t_hkey = NULL;
t_success = SUCCEEDED(p_token->GetId(&t_reg_key));
if (t_success)
{
// Split the path & base of the registry key - path is invalid if there is no separator
t_path = wcschr(t_reg_key, L'\\');
t_success = t_path != NULL;
}
if(t_success)
{
*t_path++ = L'\0';
if (wcscmp(t_reg_key, L"HKEY_LOCAL_MACHINE") == 0)
t_success = ERROR_SUCCESS == RegOpenKeyExW(HKEY_LOCAL_MACHINE, t_path, 0, KEY_QUERY_VALUE, &t_hkey);
else if (wcscmp(t_reg_key, L"HKEY_CURRENT_USER") == 0)
t_success = ERROR_SUCCESS == RegOpenKeyExW(HKEY_CURRENT_USER, t_path, 0, KEY_QUERY_VALUE, &t_hkey);
else
t_success = false;
DWORD t_size = 0;
if (t_success)
t_success = ERROR_MORE_DATA == s_RegLoadMUIStringW(t_hkey, L"Description", NULL, 0, &t_size, 0, NULL);
if (t_success)
t_success = NULL != (t_description = (WCHAR*) CoTaskMemAlloc(t_size));
if (t_success)
t_success = ERROR_SUCCESS == s_RegLoadMUIStringW(t_hkey, L"Description", t_description, t_size, NULL, 0, NULL);
}
// Cleanup
if(t_hkey)
RegCloseKey(t_hkey);
if(t_reg_key)
CoTaskMemFree(t_reg_key);
if (!t_success && t_description != NULL)
{
CoTaskMemFree(t_description);
t_description = NULL;
}
}
// fetch from the registry - if all else fails, fallback to the default attribute
if (s_RegLoadMUIStringW == NULL || !t_success)
{
WCHAR t_lang_id[10];
if (_ultow_s(GetUserDefaultUILanguage(), t_lang_id, 9, 16))
{
t_lang_id[0] = L'0';
t_lang_id[1] = 0;
}
HRESULT hr;
hr = p_token->GetStringValue(t_lang_id, &t_description);
if (hr == SPERR_NOT_FOUND)
{
hr = p_token->GetStringValue(NULL, &t_description);
}
t_success = SUCCEEDED(hr);
}
if (t_success)
*r_description = t_description;
return t_success;
}
int WINAPI
WinMain (HINSTANCE hThisInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
int argc;
WCHAR** argv;
WCHAR szFileName[MAX_PATH] = L"";
DWORD dwSize;
HWND hMainWnd;
MSG msg;
WNDCLASSEXW wincl;
LPCWSTR fileName;
switch (GetUserDefaultUILanguage())
{
case MAKELANGID(LANG_HEBREW, SUBLANG_DEFAULT):
SetProcessDefaultLayout(LAYOUT_RTL);
break;
default:
break;
}
g_hInstance = hThisInstance;
/* Get unicode command line */
argv = CommandLineToArgvW(GetCommandLineW(), &argc);
if (argc < 2)
{
OPENFILENAMEW fontOpen;
WCHAR filter[MAX_PATH], dialogTitle[MAX_PATH];
LoadStringW(NULL, IDS_OPEN, dialogTitle, MAX_PATH);
LoadStringW(NULL, IDS_FILTER_LIST, filter, MAX_PATH);
/* Clears out any values of fontOpen before we use it */
ZeroMemory(&fontOpen, sizeof(fontOpen));
/* Sets up the open dialog box */
fontOpen.lStructSize = sizeof(fontOpen);
fontOpen.hwndOwner = NULL;
fontOpen.lpstrFilter = filter;
fontOpen.lpstrFile = szFileName;
fontOpen.lpstrTitle = dialogTitle;
fontOpen.nMaxFile = MAX_PATH;
fontOpen.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
fontOpen.lpstrDefExt = L"ttf";
/* Opens up the Open File dialog box in order to chose a font file. */
if(GetOpenFileNameW(&fontOpen))
{
fileName = fontOpen.lpstrFile;
g_fileName = fileName;
} else {
/* If the user decides to close out of the open dialog effectively
exiting the program altogether */
return 0;
}
}
else
{
/* Try to add the font resource from command line */
fileName = argv[1];
g_fileName = fileName;
}
if (!AddFontResourceW(fileName))
{
ErrorMsgBox(0, IDS_ERROR_NOFONT, fileName);
return -1;
}
/* Get the font name */
dwSize = sizeof(g_ExtLogFontW.elfFullName);
if (!GetFontResourceInfoW(fileName, &dwSize, g_ExtLogFontW.elfFullName, 1))
{
ErrorMsgBox(0, IDS_ERROR_NOFONT, fileName);
return -1;
}
dwSize = sizeof(LOGFONTW);
if (!GetFontResourceInfoW(fileName, &dwSize, &g_ExtLogFontW.elfLogFont, 2))
{
ErrorMsgBox(0, IDS_ERROR_NOFONT, fileName);
return -1;
}
if (!Display_InitClass(hThisInstance))
{
ErrorMsgBox(0, IDS_ERROR_NOCLASS);
return -1;
}
/* The main window class */
wincl.cbSize = sizeof (WNDCLASSEXW);
wincl.style = CS_DBLCLKS;
wincl.lpfnWndProc = MainWndProc;
wincl.cbClsExtra = 0;
wincl.cbWndExtra = 0;
wincl.hInstance = hThisInstance;
wincl.hIcon = LoadIcon (GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_TT));
wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
wincl.hbrBackground = (HBRUSH)COLOR_BACKGROUND;
wincl.lpszMenuName = NULL;
wincl.lpszClassName = g_szFontViewClassName;
wincl.hIconSm = LoadIcon (GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_TT));
/* Register the window class, and if it fails quit the program */
if (!RegisterClassExW (&wincl))
{
ErrorMsgBox(0, IDS_ERROR_NOCLASS);
return 0;
}
/* The class is registered, let's create the main window */
hMainWnd = CreateWindowExW(
0, /* Extended possibilites for variation */
g_szFontViewClassName, /* Classname */
g_ExtLogFontW.elfFullName,/* Title Text */
WS_OVERLAPPEDWINDOW, /* default window */
CW_USEDEFAULT, /* Windows decides the position */
CW_USEDEFAULT, /* where the window ends up on the screen */
544, /* The programs width */
375, /* and height in pixels */
HWND_DESKTOP, /* The window is a child-window to desktop */
NULL, /* No menu */
hThisInstance, /* Program Instance handler */
NULL /* No Window Creation data */
);
ShowWindow(hMainWnd, nCmdShow);
/* Main message loop */
while (GetMessage (&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
RemoveFontResourceW(argv[1]);
return (int)msg.wParam;
}
void GetDefaultLang()
{
// calculate the langpacks' root
PathToAbsoluteT(_T("\\Languages"), g_tszRoot);
if (_taccess(g_tszRoot, 0) != 0) // directory Languages exists
PathToAbsoluteT(_T("."), g_tszRoot);
// look into mirandaboot.ini
TCHAR tszPath[MAX_PATH], tszLangName[256];
PathToAbsoluteT(_T("\\mirandaboot.ini"), tszPath);
GetPrivateProfileString(_T("Language"), _T("DefaultLanguage"), _T(""), tszLangName, _countof(tszLangName), tszPath);
if (tszLangName[0]) {
if (!mir_tstrcmpi(tszLangName, _T("default"))) {
db_set_ts(NULL, "Langpack", "Current", _T("default"));
return;
}
if (!LoadLangPack(tszLangName)) {
db_set_ts(NULL, "Langpack", "Current", tszLangName);
return;
}
}
// try to load langpack that matches UserDefaultUILanguage
if (GetLocaleInfo(MAKELCID(GetUserDefaultUILanguage(), SORT_DEFAULT), LOCALE_SENGLANGUAGE, tszLangName, _countof(tszLangName))) {
mir_sntprintf(tszPath, _T("langpack_%s.txt"), _tcslwr(tszLangName));
if (!LoadLangPack(tszPath)) {
db_set_ts(NULL, "Langpack", "Current", tszPath);
return;
}
}
// finally try to load first file
mir_sntprintf(tszPath, _T("%s\\langpack_*.txt"), g_tszRoot);
WIN32_FIND_DATA fd;
HANDLE hFind = FindFirstFile(tszPath, &fd);
if (hFind != INVALID_HANDLE_VALUE) {
do {
/* search first langpack that could be loaded */
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
continue;
if (!LoadLangPack(fd.cFileName)) {
db_set_ts(NULL, "Langpack", "Current", fd.cFileName);
break;
}
} while (FindNextFile(hFind, &fd));
FindClose(hFind);
}
else db_set_ts(NULL, "Langpack", "Current", _T("default"));
}
