void
win32_test_special_locales(void)
{
nsresult result;
nsCOMPtr<nsIWin32Locale> win32Locale;
nsCOMPtr<nsILocaleFactory> xp_locale_factory;
nsCOMPtr<nsILocale> xp_locale;
nsString* locale, *result_locale, *category;
LCID sys_lcid, user_lcid;
PRUnichar *lc_name_unichar;
win32Locale = do_CreateInstance(kWin32LocaleFactoryCID, &result);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
xp_locale_factory = do_GetClassObject(kLocaleFactoryCID, &result);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
category = new nsString(localeCategoryList[0]);
//
// derive a system locale
//
result = xp_locale_factory->GetSystemLocale(getter_AddRefs(xp_locale));
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
sys_lcid = GetSystemDefaultLCID();
locale = new nsString();
result_locale = new nsString();
result = win32Locale->GetXPLocale(sys_lcid,locale);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
result = xp_locale->GetCategory(category, &lc_name_unichar);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
result_locale->SetString(lc_name_unichar);
delete result_locale;
//
// derive a system locale
//
result = xp_locale_factory->GetApplicationLocale(getter_AddRefs(xp_locale));
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
user_lcid = GetUserDefaultLCID();
locale = new nsString();
result_locale = new nsString();
result = win32Locale->GetXPLocale(user_lcid,locale);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
result = xp_locale->GetCategory(category, &lc_name_unichar);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
result_locale->SetString(lc_name_unichar);
delete result_locale;
delete category;
}
LanguageType Application::getCurrentLanguage()
{
LanguageType ret = LanguageType::ENGLISH;
LCID localeID = GetUserDefaultLCID();
unsigned short primaryLanguageID = localeID & 0xFF;
switch (primaryLanguageID)
{
case LANG_CHINESE:
ret = LanguageType::CHINESE;
break;
case LANG_ENGLISH:
ret = LanguageType::ENGLISH;
break;
case LANG_FRENCH:
ret = LanguageType::FRENCH;
break;
case LANG_ITALIAN:
ret = LanguageType::ITALIAN;
break;
case LANG_GERMAN:
ret = LanguageType::GERMAN;
break;
case LANG_SPANISH:
ret = LanguageType::SPANISH;
break;
case LANG_DUTCH:
ret = LanguageType::DUTCH;
break;
case LANG_RUSSIAN:
ret = LanguageType::RUSSIAN;
break;
case LANG_KOREAN:
ret = LanguageType::KOREAN;
break;
case LANG_JAPANESE:
ret = LanguageType::JAPANESE;
break;
case LANG_HUNGARIAN:
ret = LanguageType::HUNGARIAN;
break;
case LANG_PORTUGUESE:
ret = LanguageType::PORTUGUESE;
break;
case LANG_ARABIC:
ret = LanguageType::ARABIC;
break;
case LANG_NORWEGIAN:
ret = LanguageType::NORWEGIAN;
break;
case LANG_POLISH:
ret = LanguageType::POLISH;
break;
}
return ret;
}
static UINT CDECL nulldrv_GetKeyboardLayoutList( INT size, HKL *layouts )
{
HKEY hKeyKeyboard;
DWORD rc;
INT count = 0;
ULONG_PTR baselayout;
LANGID langid;
static const WCHAR szKeyboardReg[] = {'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','K','e','y','b','o','a','r','d',' ','L','a','y','o','u','t','s',0};
baselayout = GetUserDefaultLCID();
langid = PRIMARYLANGID(LANGIDFROMLCID(baselayout));
if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
baselayout = MAKELONG( baselayout, 0xe001 ); /* IME */
else
baselayout |= baselayout << 16;
/* Enumerate the Registry */
rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,szKeyboardReg,&hKeyKeyboard);
if (rc == ERROR_SUCCESS)
{
do {
WCHAR szKeyName[9];
HKL layout;
rc = RegEnumKeyW(hKeyKeyboard, count, szKeyName, 9);
if (rc == ERROR_SUCCESS)
{
layout = (HKL)(ULONG_PTR)strtoulW(szKeyName,NULL,16);
if (baselayout != 0 && layout == (HKL)baselayout)
baselayout = 0; /* found in the registry do not add again */
if (size && layouts)
{
if (count >= size ) break;
layouts[count] = layout;
}
count ++;
}
} while (rc == ERROR_SUCCESS);
RegCloseKey(hKeyKeyboard);
}
/* make sure our base layout is on the list */
if (baselayout != 0)
{
if (size && layouts)
{
if (count < size)
{
layouts[count] = (HKL)baselayout;
count++;
}
}
else
count++;
}
return count;
}
BOOL CErrorsDialog::OnInitDialog()
{
CDialog::OnInitDialog();
// Set the help button to be inactive
m_ctlHelp.EnableWindow(FALSE);
// Read in the error information from IErrorRecords
CDBErrorInfo errInfo;
ULONG ulRecords = 0;
HRESULT hr;
hr = errInfo.GetErrorRecords(m_spUnk, m_iid, &ulRecords);
if (FAILED(hr) || hr == S_FALSE || ulRecords == 0)
{
CString strError;
if( strError.LoadString(IDS_NOSPECIFIED_SOURCE) == FALSE)
{
AfxThrowResourceException();
}
m_ctlListSource.AddString(strError);
}
else
{
LCID lcid = GetUserDefaultLCID();
for (ULONG l=0; l<ulRecords; l++)
{
// Get the error information from the source
struct MYERRORINFO* pInfo = new MYERRORINFO;
#pragma warning(disable: 6011) // unexpected null dereference prefast warning
hr = errInfo.GetAllErrorInfo(l, lcid, &pInfo->bstrDescription,
&pInfo->bstrSource, &pInfo->guid, &pInfo->dwHelpContext,
&pInfo->bstrHelpFile);
#pragma warning(default: 6011) // unexpected null dereference prefast warning
if (FAILED(hr))
{
delete pInfo;
continue;
}
m_listErrorInfo.AddTail(pInfo);
// Add the information to the list view
if (pInfo->bstrSource)
m_ctlListSource.AddString(COLE2T(pInfo->bstrSource));
else
m_ctlListSource.AddString(_T("Unspecified error."));
}
}
m_ctlListSource.SetCurSel(0);
SelectSource(0);
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
static HRESULT call_disp_func(IDispatch *disp, DISPPARAMS *dp, VARIANT *retv)
{
IDispatchEx *dispex;
EXCEPINFO ei;
HRESULT hres;
memset(&ei, 0, sizeof(ei));
hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
if(SUCCEEDED(hres)) {
hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL);
IDispatchEx_Release(dispex);
}else {
TRACE("Could not get IDispatchEx interface: %08x\n", hres);
hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD,
dp, retv, &ei, NULL);
}
return hres;
}
MCLocaleRef MCS_getsystemlocale()
{
// Get the identifier for the system locale
LCID t_system_lcid;
t_system_lcid = GetUserDefaultLCID();
// Create a locale object
MCLocaleRef t_locale;
/* UNCHECKED */ MCLocaleCreateWithLCID(t_system_lcid, t_locale);
return t_locale;
}
void CAboutDlg::OnCrystalDewWorld()
{
if(GetUserDefaultLCID() == 0x0411)// Japanese
{
OpenUrl(URL_CRYSTAL_DEW_WORLD_JA);
}
else // Other Language
{
OpenUrl(URL_CRYSTAL_DEW_WORLD_EN);
}
}
HRESULT WINAPI GetAcceptLanguagesW(WCHAR *langbuf, DWORD *buflen)
{
static const WCHAR keyW[] = {
'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\',
'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
static const WCHAR valueW[] = {'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
DWORD mystrlen, mytype;
WCHAR *mystr;
LCID mylcid;
HKEY mykey;
LONG lres;
DWORD len;
TRACE("%p, %p, *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
if (!langbuf || !buflen || !*buflen)
return E_FAIL;
mystrlen = (*buflen > 20) ? *buflen : 20 ;
len = mystrlen * sizeof(WCHAR);
mystr = heap_alloc(len);
mystr[0] = 0;
RegOpenKeyW(HKEY_CURRENT_USER, keyW, &mykey);
lres = RegQueryValueExW(mykey, valueW, 0, &mytype, (PBYTE)mystr, &len);
RegCloseKey(mykey);
len = lstrlenW(mystr);
if (!lres && (*buflen > len))
{
lstrcpyW(langbuf, mystr);
*buflen = len;
heap_free(mystr);
return S_OK;
}
/* Did not find a value in the registry or the user buffer is too small */
mylcid = GetUserDefaultLCID();
lcid_to_rfc1766(mylcid, mystr, mystrlen);
len = lstrlenW(mystr);
memcpy(langbuf, mystr, min(*buflen, len + 1)*sizeof(WCHAR));
heap_free(mystr);
if (*buflen > len)
{
*buflen = len;
return S_OK;
}
*buflen = 0;
return E_NOT_SUFFICIENT_BUFFER;
}
/**
*
* Determine and set Grisbi locale as follows (in order of priority):
* - Value of HKCU\SOFTWARE\GRISBI\LANG
* - Value of %LANG% (LANG con content a LOCALE definition or a LCID value)
* - Default user value
*
* @return Does the function change the application context LANG value
* @retval TRUE a value have set to LANG
* @retval FALSE LANG has not been modified for any reason.
*
*/
gboolean win32_set_locale()
{ /* {{{ */
gchar* gzLocale = NULL;
BOOL bFound = FALSE;
// ---------------------------------------------------------------------
// Grisbi language has been configured through the specific application
// ---------------------------------------------------------------------
// 1 - look into HKCU/SOFTWARE/GRISBI/LANG
gzLocale = win32_strdup_registry(HKEY_CURRENT_USER,"SOFTWARE\\GRISBI","LANG",REG_SZ);
bFound = (BOOL)(gzLocale && (*gzLocale));
// ---------------------------------------------------------------------
// Try to find language setting using the LANG environment variable
// ---------------------------------------------------------------------
if(!bFound)
{
g_unsetenv("LANG");
gzLocale = g_getenv("LANG");
bFound = (BOOL)(gzLocale && (*gzLocale));
if (bFound)
{
// LANG can contain the Windows LCID instead of the LC_LOCALE value, in this case we need to convert it
// LANG can the LCID given in decimal
// LANG can the LCID given is hexadecimal
// When LANG is the LCID its size is 3 or 4 and start with a digit
// In other case we suppose LANG to be a valid LC_LOCALE value
int len = strlen(gzLocale);
if ( (len==3||len==4)&&(g_ascii_isdigit(*gzLocale)))
{
gzLocale = win32_lcid_to_lang(atoi(gzLocale));
bFound = (BOOL)(gzLocale && (*gzLocale));
}
}
}
// ---------------------------------------------------------------------
// Last change: retrieve current Windows value
// ---------------------------------------------------------------------
if ( (!bFound) || (!gzLocale) || ( (gzLocale) && (!(*gzLocale)) ) )
{
gzLocale = win32_lcid_to_lang(GetUserDefaultLCID());
}
if ((gzLocale)&&(*gzLocale))
{
bFound = TRUE;
g_setenv("LANG",gzLocale,TRUE);
g_free(gzLocale);
gzLocale = NULL;
}
return bFound;
} /* }}} */
TSystemTime::TSystemTime(const tstring& s, LCID locale)
{
_USES_CONVERSION_A;
LPCOLESTR olestr = _A2W_A(s.c_str());
const LCID lcid = locale ? locale : GetUserDefaultLCID();
const ULONG flags = 0;
DATE date;
HRESULT hr = VarDateFromStr(VARDATEFROMSTR_PARAM1(olestr), lcid, flags, &date);
if (hr != S_OK) TXOwl::Raise(IDS_SYSTEMTIMEPARSEFAIL);
int r = VariantTimeToSystemTime(date, this);
if (r == FALSE) TXOwl::Raise(IDS_SYSTEMTIMEPARSEFAIL);
}
/*
* Convert UTF-8 to a platform string
*/
int
convertUft8ToPlatformString(char* utf8_str, int utf8_len, char* platform_str, int platform_len) {
LANGID langID;
LCID localeID;
TCHAR strCodePage[7]; // ANSI code page id
UINT codePage;
int wlen, plen;
WCHAR* wstr;
/*
* Get the code page for this locale
*/
langID = LANGIDFROMLCID(GetUserDefaultLCID());
localeID = MAKELCID(langID, SORT_DEFAULT);
if (GetLocaleInfo(localeID, LOCALE_IDEFAULTANSICODEPAGE,
strCodePage, sizeof(strCodePage)/sizeof(TCHAR)) > 0 ) {
codePage = atoi(strCodePage);
} else {
codePage = GetACP();
}
/*
* To convert the string to platform encoding we must first convert
* to unicode, and then convert to the platform encoding
*/
plen = -1;
wlen = MultiByteToWideChar(CP_UTF8, 0, utf8_str, utf8_len, NULL, 0);
if (wlen > 0) {
wstr = (WCHAR*)malloc(wlen * sizeof(WCHAR));
if (wstr != NULL) {
if (MultiByteToWideChar(CP_UTF8,
0,
utf8_str,
utf8_len,
wstr, wlen) > 0) {
plen = WideCharToMultiByte(codePage,
0,
wstr,
wlen,
platform_str,
platform_len,
NULL,
NULL);
if (plen >= 0) {
platform_str[plen] = '\0';
}
free(wstr);
}
}
}
return plen;
}
ccLanguageType CCApplication::getCurrentLanguage()
{
ccLanguageType ret = kLanguageEnglish;
LCID localeID = GetUserDefaultLCID();
unsigned short primaryLanguageID = localeID & 0xFF;
switch (primaryLanguageID)
{
case LANG_CHINESE:
ret = kLanguageChinese;
break;
case LANG_ENGLISH:
ret = kLanguageEnglish;
break;
case LANG_FRENCH:
ret = kLanguageFrench;
break;
case LANG_ITALIAN:
ret = kLanguageItalian;
break;
case LANG_GERMAN:
ret = kLanguageGerman;
break;
case LANG_SPANISH:
ret = kLanguageSpanish;
break;
case LANG_DUTCH:
ret = kLanguageDutch;
break;
case LANG_RUSSIAN:
ret = kLanguageRussian;
break;
case LANG_KOREAN:
ret = kLanguageKorean;
break;
case LANG_JAPANESE:
ret = kLanguageJapanese;
break;
case LANG_HUNGARIAN:
ret = kLanguageHungarian;
break;
case LANG_PORTUGUESE:
ret = kLanguagePortuguese;
break;
case LANG_ARABIC:
ret = kLanguageArabic;
break;
}
return ret;
}
HRESULT primLoadRegTypeLib
( GUID* rguid
, short wMaj
, short wMin
, LCID lcid
, void** ppv
)
{
HRESULT hr;
hr = LoadRegTypeLib(rguid, wMaj, wMin, GetUserDefaultLCID(), (IUnknown**)ppv);
return hr;
}
std::string PATH_INFO::find_translated_file( const std::string &pathid,
const std::string &extension, const std::string &fallbackid )
{
const std::string base_path = FILENAMES[pathid];
#if defined LOCALIZE && ! defined __CYGWIN__
std::string loc_name;
if( get_option<std::string>( "USE_LANG" ).empty() ) {
#if (defined _WIN32 || defined WINDOWS)
loc_name = getLangFromLCID( GetUserDefaultLCID() );
if( !loc_name.empty() ) {
const std::string local_path = base_path + loc_name + extension;
if( file_exist( local_path ) ) {
return local_path;
}
}
#endif
const char *v = setlocale( LC_ALL, NULL );
if( v != NULL ) {
loc_name = v;
}
} else {
loc_name = get_option<std::string>( "USE_LANG" );
}
if( loc_name == "C" ) {
loc_name = "en";
}
if( !loc_name.empty() ) {
const size_t dotpos = loc_name.find( '.' );
if( dotpos != std::string::npos ) {
loc_name.erase( dotpos );
}
// complete locale: en_NZ
const std::string local_path = base_path + loc_name + extension;
if( file_exist( local_path ) ) {
return local_path;
}
const size_t p = loc_name.find( '_' );
if( p != std::string::npos ) {
// only the first part: en
const std::string local_path = base_path + loc_name.substr( 0, p ) + extension;
if( file_exist( local_path ) ) {
return local_path;
}
}
}
#endif
(void) extension;
return FILENAMES[fallbackid];
}
std::string getLocale()
{
TCHAR szBuff1[10], szBuff2[10];
LCID lcid = GetUserDefaultLCID();
GetLocaleInfo(lcid, LOCALE_SISO639LANGNAME, szBuff1, 10);
GetLocaleInfo(lcid, LOCALE_SISO3166CTRYNAME, szBuff2, 10);
strcat(szBuff1,"_");
strcat(szBuff1,szBuff2);
return szBuff1;
}
void CWordPadApp::LoadOptions()
{
BYTE* pb = NULL;
UINT nLen = 0;
HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
if (hFont == NULL)
hFont = (HFONT)GetStockObject(ANSI_VAR_FONT);
VERIFY(::GetObject(hFont, sizeof(LOGFONT), &m_lf));
m_bWordSel = GetProfileInt(szSection, szWordSel, TRUE);
TCHAR buf[2];
buf[0] = NULL;
GetLocaleInfo(GetUserDefaultLCID(), LOCALE_IMEASURE, buf, 2);
int nDefUnits = buf[0] == '1' ? 0 : 1;
SetUnits(GetProfileInt(szSection, szUnits, nDefUnits));
m_bMaximized = GetProfileInt(szSection, szMaximized, (int)FALSE);
if (GetProfileBinary(szSection, szFrameRect, &pb, &nLen))
{
ASSERT(nLen == sizeof(CRect));
memcpy(&m_rectInitialFrame, pb, sizeof(CRect));
delete pb;
}
else
m_rectInitialFrame.SetRect(0,0,0,0);
CRect rectScreen(0, 0, GetSystemMetrics(SM_CXSCREEN),
GetSystemMetrics(SM_CYSCREEN));
CRect rectInt;
rectInt.IntersectRect(&rectScreen, &m_rectInitialFrame);
if (rectInt.Width() < 10 || rectInt.Height() < 10)
m_rectInitialFrame.SetRect(0, 0, 0, 0);
if (GetProfileBinary(szSection, szPageMargin, &pb, &nLen))
{
ASSERT(nLen == sizeof(CRect));
memcpy(&m_rectPageMargin, pb, sizeof(CRect));
delete pb;
}
else
m_rectPageMargin.SetRect(1800, 1440, 1800, 1440);
m_optionsText.LoadOptions(szTextSection);
m_optionsRTF.LoadOptions(szRTFSection);
m_optionsWord.LoadOptions(szWordSection);
m_optionsWrite.LoadOptions(szWriteSection);
m_optionsIP.LoadOptions(szIPSection);
}
/*##{method}####################################################################
--------------------------------------------------------------------------------
Description: Ausgabe eines Fehlers
Parameters:
Return Values:
--------------------------------------------------------------------------------
History:
#######################################################################{end}##*/
long COPCItem :: OutPutError(HRESULT hError)
{
HRESULT hRes;
WCHAR *pszError;
hRes = mOPCServer->GetErrorString(hError, GetUserDefaultLCID(), &pszError);
if (FAILED(hRes))
{
CString strError;
strError.Format("Error: 0x%08X", hError);
return 1;
}
printf("Error: %ls\n", pszError);
CoTaskMemFree(pszError);
return 0;
}
static std::wstring get_system_language()
{
LCID locale = GetUserDefaultLCID();
wchar_t buffer[9];
int length = ::GetLocaleInfoW(locale, LOCALE_SISO639LANGNAME, &buffer[0], _countof(buffer));
if (length <= 1)
return std::move(std::wstring());
std::wstring res(buffer);
if (SUBLANGID(locale) == SUBLANG_NEUTRAL)
return std::move(language);
length = ::GetLocaleInfoW(locale, LOCALE_SISO3166CTRYNAME, &buffer[0], _countof(buffer));
if (length <= 1)
return std::move(language);
return std::move(res.append(1, '-').append(buffer));
}
VOID
SetCBFromRes(
HWND HwndCB,
DWORD ResId,
DWORD Default,
BOOL CheckDecimal)
{
TCHAR szTemp[258], szDecSep[2], cSep;
LPTSTR pThis, pThat, pDecSep;
int iRV;
if (CheckDecimal) {
iRV = GetLocaleInfo(GetUserDefaultLCID(), LOCALE_SDECIMAL,szDecSep,2);
if (iRV == 0) {
//
// following code can take only one char for decimal separator,
// better leave the point as separator
//
CheckDecimal = FALSE;
}
}
if (!LoadString(g_hInst, ResId, szTemp, ARRAYSIZE(szTemp)))
return;
for (pThis = szTemp, cSep = *pThis++; pThis; pThis = pThat) {
if (pThat = _tcschr( pThis, cSep))
*pThat++ = TEXT('\0');
if(CheckDecimal) {
//
// Assume dec separator in resource is '.', comment was put to this
// effect
//
pDecSep = _tcschr(pThis,TEXT('.'));
if (pDecSep) {
//
// assume decimal sep width == 1
//
*pDecSep = *szDecSep;
}
}
SendMessage(HwndCB, CB_ADDSTRING, 0, (LPARAM) pThis);
}
SendMessage(HwndCB, CB_SETCURSEL, Default, 0L);
}
BSTR primQueryPathOfRegTypeLib ( GUID* rguid
, unsigned short maj
, unsigned short min
)
{
BSTR bs;
HRESULT hr;
bs = SysAllocStringByteLen (NULL, 255);
hr = QueryPathOfRegTypeLib ( rguid, maj, min, GetUserDefaultLCID(), &bs);
if (FAILED(hr)) {
SysFreeString(bs);
return NULL;
}
return bs;
}
BOOL CDateDialog::OnInitDialog()
{
CCSDialog::OnInitDialog();
m_pListBox = &m_listBox; // set static member
GetLocalTime(&m_time);
m_id = GetUserDefaultLCID();
EnumDateFormats(DateFmtEnumProc, m_id, DATE_SHORTDATE);
EnumDateFormats(DateFmtEnumProc, m_id, DATE_LONGDATE);
EnumTimeFormats(TimeFmtEnumProc, m_id, 0);
m_pListBox = NULL;
m_listBox.SetCurSel(0);
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
static VOID
CreateLanguagesList(HWND hwnd)
{
WCHAR langSel[255];
hList = hwnd;
bSpain = FALSE;
EnumSystemLocalesW(LocalesEnumProc, LCID_SUPPORTED);
/* Select current locale */
/* or should it be System and not user? */
GetLocaleInfoW(GetUserDefaultLCID(), LOCALE_SLANGUAGE, langSel, sizeof(langSel)/sizeof(WCHAR));
SendMessageW(hList,
CB_SELECTSTRING,
-1,
(LPARAM)langSel);
}
HRESULT CScriptManager::GetItemTypeInfo( LPCTSTR pszItemName,
ITypeInfo** ppTypeInfo )
{
IProvideClassInfoPtr pProvideClassInfo;
IDispatch* pDispatch;
HRESULT hResult;
BOOL tFound;
ENSURE( pszItemName != NULL );
ENSURE( ppTypeInfo != NULL );
*ppTypeInfo = NULL;
if( strcmp( pszItemName, "TCForm" ) == 0 )
{
hResult = m_pDoc->GetTypeInfoOfGuid( GetUserDefaultLCID(),
__uuidof( Document ), ppTypeInfo );
if( SUCCEEDED( hResult ) )
{
return( S_OK );
}
}
else
{
tFound = m_mapNamedItems.Lookup( pszItemName, pDispatch );
if( tFound )
{
pProvideClassInfo = pDispatch;
if( pProvideClassInfo != NULL )
{
hResult = pProvideClassInfo->GetClassInfo( ppTypeInfo );
if( SUCCEEDED( hResult ) )
{
return( S_OK );
}
}
}
}
return( TYPE_E_ELEMENTNOTFOUND );
}
const char*
default_codeset (void)
{
const char* fromcode = 0;
#if defined HAVE_LOCALE_CHARSET
debug_printf ("Using locale_charset() to get system codeset.\n");
fromcode = locale_charset ();
#elif defined HAVE_LANGINFO_CODESET
debug_printf ("Using nl_langinfo() to get system codeset.\n");
fromcode = nl_langinfo (CODESET);
#else
debug_printf ("No way to get system codeset.\n");
#endif
if (!fromcode || !fromcode[0]) {
debug_printf ("No default codeset, using ISO-8859-1.\n");
fromcode = "ISO-8859-1";
} else {
debug_printf ("Found default codeset %s\n", fromcode);
}
#if defined (WIN32)
{
/* This is just for debugging */
LCID lcid;
lcid = GetSystemDefaultLCID ();
debug_printf ("SystemDefaultLCID: %04x\n", lcid);
lcid = GetUserDefaultLCID ();
debug_printf ("UserDefaultLCID: %04x\n", lcid);
}
#endif
#if defined HAVE_ICONV
debug_printf ("Have iconv.\n");
#else
debug_printf ("No iconv.\n");
#endif
return fromcode;
}
std::string getUserLanguage() {
const char* pLang = NULL;
fprintf(stdout,"Detecting locale...\t\t"); fflush(stdout);
#if defined (_WIN32)
char ISO639_LanguageName[10];
if(GetLocaleInfo(GetUserDefaultLCID(), LOCALE_SISO639LANGNAME, ISO639_LanguageName, sizeof(ISO639_LanguageName)) == 0) {
return "";
} else {
pLang = ISO639_LanguageName;
}
#elif defined (__APPLE__)
pLang = getMacLanguage();
if(pLang == NULL) {
return "";
}
#else
// should work on most unices
pLang = getenv("LC_ALL");
if(pLang == NULL) {
// try LANG
pLang = getenv("LANG");
if(pLang == NULL) {
return "";
}
}
#endif
fprintf(stderr, "'%s'\n", pLang); fflush(stdout);
if(strlen(pLang) < 2) {
return "";
} else {
return strToLower(std::string(pLang, 2));
}
}
/* Determine and set Pidgin locale as follows (in order of priority):
- Check PIDGINLANG env var
- Check NSIS Installer Language reg value
- Use default user locale
*/
static const char *winpidgin_get_locale() {
const char *locale = NULL;
LCID lcid;
char data[10];
DWORD datalen = 10;
/* Check if user set PIDGINLANG env var */
if ((locale = getenv("PIDGINLANG")))
return locale;
if (!portable_mode && read_reg_string(HKEY_CURRENT_USER, "SOFTWARE\\pidgin",
"Installer Language", (LPBYTE) &data, &datalen)) {
if ((locale = winpidgin_lcid_to_posix(atoi(data))))
return locale;
}
lcid = GetUserDefaultLCID();
if ((locale = winpidgin_lcid_to_posix(lcid)))
return locale;
return "en";
}
int GetUserLanguage() {
const char* pLang = NULL;
#if defined (_WIN32)
char ISO639_LanguageName[10];
if(GetLocaleInfo(GetUserDefaultLCID(), LOCALE_SISO639LANGNAME, ISO639_LanguageName, sizeof(ISO639_LanguageName)) == 0) {
return LNG_UNKNOWN;
} else {
pLang = ISO639_LanguageName;
}
#elif defined (__APPLE__)
pLang = getMacLanguage();
if(pLang == NULL) {
return LNG_UNKNOWN;
}
#else
// should work most unices
pLang = getenv("LC_ALL");
if(pLang == NULL) {
// try LANG
pLang = getenv("LANG");
if(pLang == NULL) {
return LNG_UNKNOWN;
}
}
#endif
if((pLang[0] == 'f' || pLang[0] == 'F') && (pLang[1] == 'r' || pLang[1] == 'R')) {
return LNG_FRE;
} else if((pLang[0] == 'd' || pLang[0] == 'D') && (pLang[1] == 'e' || pLang[1] == 'E')) {
return LNG_GER;
} else if((pLang[0] == 'e' || pLang[0] == 'E') && (pLang[1] == 'n' || pLang[1] == 'N')) {
return LNG_ENG;
} else {
return LNG_UNKNOWN;
}
}
/* Determine and set Pidgin locale as follows (in order of priority):
- Check PIDGINLANG env var
- Check NSIS Installer Language reg value
- Use default user locale
*/
static const wchar_t *winpidgin_get_locale() {
const wchar_t *locale = NULL;
LCID lcid;
wchar_t data[10];
DWORD datalen = sizeof(data) / sizeof(wchar_t);
/* Check if user set PIDGINLANG env var */
if ((locale = _wgetenv(L"PIDGINLANG")))
return locale;
if (!portable_mode && read_reg_string(HKEY_CURRENT_USER, L"SOFTWARE\\pidgin",
L"Installer Language", (LPBYTE) &data, &datalen)) {
if ((locale = winpidgin_lcid_to_posix(_wtoi(data))))
return locale;
}
lcid = GetUserDefaultLCID();
if ((locale = winpidgin_lcid_to_posix(lcid)))
return locale;
return L"en";
}
CJSProxyObj::CJSProxyObj(CJSExtender* _pJSExtender, IDispatch *pDisp, const GUID iid, CString strPrefix) :
m_dwCookie(0xFEFEFEFE), m_pDisp(pDisp), m_EventIID(iid)
{
m_pEventObj = nullptr;
ITypeInfo* pTypeInfo = nullptr;
m_pJSExtender = _pJSExtender;
if (theApp.m_pEventProxy)
{
m_pEventObj = theApp.m_pEventProxy;
theApp.m_pEventProxy = nullptr;
}
else
{
pDisp->GetTypeInfo(0, GetUserDefaultLCID(), &pTypeInfo);
if (pTypeInfo)
{
CComPtr<ITypeLib> pTypeLib;
UINT nIndex = 0;
pTypeInfo->GetContainingTypeLib(&pTypeLib, &nIndex);
pTypeLib->GetTypeInfoOfGuid(iid, &m_pTypeInfo);
pTypeInfo->Release();
}
}
CString strName = strPrefix;
auto it = m_pJSExtender->m_mapCloudJSObject.find(strName);
if (it != m_pJSExtender->m_mapCloudJSObject.end())
{
int nSize = m_pJSExtender->m_mapCloudJSObject.size();
CString s = _T("");
s.Format(_T("%s_%d_"), strName, nSize);
strName = s;
}
m_bstrPrefix = CComBSTR(strName);
SetEventNames();
m_pJSExtender->m_mapCloudJSObject[strName] = this;
HRESULT hr = AtlAdvise(m_pDisp, this, m_EventIID, &m_dwCookie);
}
void _imp_getProcessLocale( rtl_Locale ** ppLocale )
{
WCHAR langCode[ELP_LANGUAGE_FIELD_LENGTH];
WCHAR ctryCode[ELP_COUNTRY_FIELD_LENGTH];
LCID localeId;
OSL_ASSERT( ppLocale );
/* get the LCID to retrieve information from */
localeId = GetUserDefaultLCID();
/* call GetLocaleInfo to retrieve the iso codes */
if( GetLocaleInfo( localeId, LOCALE_SISO639LANGNAME , langCode, ELP_LANGUAGE_FIELD_LENGTH ) &&
GetLocaleInfo( localeId, LOCALE_SISO3166CTRYNAME , ctryCode, ELP_COUNTRY_FIELD_LENGTH ) )
{
*ppLocale = rtl_locale_register( langCode, ctryCode, L"" );
}
else
{
*ppLocale = rtl_locale_register( L"C", L"", L"" );
}
}
