/*
Copyright (C) 2006-2010 Ricardo Pescuma Domenecci
This is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this file; see the file license.txt. If
not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
#include "stdafx.h"
#define APPPATH L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\%s"
#define MUICACHE L"Software\\Microsoft\\Windows\\ShellNoRoam\\MUICache"
// Additional languages that i could not find in Windows
struct {
wchar_t *language;
wchar_t *localized_name;
} aditionalLanguages[] = {
{ L"tl_PH", LPGENW("Tagalog (Philippines)") },
{ L"de_frami_neu", LPGENW("German (Germany)") }
};
struct {
wchar_t *name;
wchar_t *key;
} otherHunspellApps[] = {
{ L"Thunderbird", L"thunderbird.exe" },
{ L"Firefox", L"firefox.exe" }
};
struct {
char *name;
UINT codepage;
} codepages[] = {
{ "ISO8859-1", 28591 },
{ "UTF-7", CP_UTF7 },
{ "UTF-8", CP_UTF8 },
{ "UTF7", CP_UTF7 },
{ "UTF8", CP_UTF8 },
{ "ISO8859-2", 28592 },
{ "ISO8859-3", 28593 },
{ "ISO8859-4", 28594 },
{ "ISO8859-5", 28595 },
{ "ISO8859-6", 28596 },
{ "ISO8859-7", 28597 },
{ "ISO8859-8", 28598 },
{ "ISO8859-9", 28599 },
{ "ASMO-708", 708 },
{ "DOS-720", 720 },
{ "iso-8859-6", 28596 },
{ "arabic", 28596 },
{ "csISOLatinArabic", 28596 },
{ "ECMA-114", 28596 },
{ "ISO_8859-6", 28596 },
{ "ISO_8859-6:1987", 28596 },
{ "iso-ir-127", 28596 },
{ "x-mac-arabic", 10004 },
{ "windows-1256", 1256 },
{ "cp1256", 1256 },
{ "ibm775", 775 },
{ "CP500", 775 },
{ "iso-8859-4", 28594 },
{ "csISOLatin4", 28594 },
{ "ISO_8859-4", 28594 },
{ "ISO_8859-4:1988", 28594 },
{ "iso-ir-110", 28594 },
{ "l4", 28594 },
{ "latin4", 28594 },
{ "windows-1257", 1257 },
{ "ibm852", 852 },
{ "cp852", 852 },
{ "iso-8859-2", 28592 },
{ "csISOLatin2", 28592 },
{ "iso_8859-2", 28592 },
{ "iso_8859-2:1987", 28592 },
{ "iso-ir-101", 28592 },
{ "l2", 28592 },
{ "latin2", 28592 },
{ "x-mac-ce", 10029 },
{ "windows-1250", 1250 },
{ "x-cp1250", 1250 },
{ "EUC-CN", 51936 },
{ "x-euc-cn", 51936 },
{ "gb2312", 936 },
{ "chinese", 936 },
{ "CN-GB", 936 },
{ "csGB2312", 936 },
{ "csGB231280", 936 },
{ "csISO58GB231280", 936 },
{ "GB_2312-80", 936 },
{ "GB231280", 936 },
{ "GB2312-80", 936 },
{ "GBK", 936 },
{ "iso-ir-58", 936 },
{ "hz-gb-2312", 52936 },
{ "x-mac-chinesesimp", 10008 },
{ "big5", 950 },
{ "cn-big5", 950 },
{ "csbig5", 950 },
{ "x-x-big5", 950 },
{ "x-Chinese-CNS", 20000 },
{ "x-Chinese-Eten", 20002 },
{ "x-mac-chinesetrad", 10002 },
{ "cp866", 866 },
{ "ibm866", 866 },
{ "iso-8859-5", 28595 },
{ "csISOLatin5", 28595 },
{ "csISOLatinCyrillic", 28595 },
{ "cyrillic", 28595 },
{ "ISO_8859-5", 28595 },
{ "ISO_8859-5:1988", 28595 },
{ "iso-ir-144", 28595 },
{ "l5", 28595 },
{ "KOI8-R", 20866 },
{ "csKOI8R", 20866 },
{ "koi", 20866 },
{ "koi8", 20866 },
{ "koi8r", 20866 },
{ "KOI8-U", 21866 },
{ "koi8-ru", 21866 },
{ "x-mac-cyrillic", 10007 },
{ "windows-1251", 1251 },
{ "Win1251", 1251 },
{ "x-cp1251", 1251 },
{ "x-Europa", 29001 },
{ "x-IA5-German", 20106 },
{ "ibm737", 737 },
{ "iso-8859-7", 28597 },
{ "csISOLatinGreek", 28597 },
{ "ECMA-118", 28597 },
{ "ELOT_928", 28597 },
{ "greek", 28597 },
{ "greek8", 28597 },
{ "ISO_8859-7", 28597 },
{ "ISO_8859-7:1987", 28597 },
{ "iso-ir-126", 28597 },
{ "x-mac-greek", 10006 },
{ "windows-1253", 1253 },
{ "ibm869", 869 },
{ "DOS-862", 862 },
{ "iso-8859-8-i", 38598 },
{ "logical", 38598 },
{ "iso-8859-8", 28598 },
{ "csISOLatinHebrew", 28598 },
{ "hebrew", 28598 },
{ "ISO_8859-8", 28598 },
{ "ISO_8859-8:1988", 28598 },
{ "ISO-8859-8", 28598 },
{ "iso-ir-138", 28598 },
{ "visual", 28598 },
{ "x-mac-hebrew", 10005 },
{ "windows-1255", 1255 },
{ "ISO_8859-8-I", 1255 },
{ "ISO-8859-8", 1255 },
{ "x-EBCDIC-Arabic", 20420 },
{ "x-EBCDIC-CyrillicRussian", 20880 },
{ "x-EBCDIC-CyrillicSerbianBulgarian", 21025 },
{ "x-EBCDIC-DenmarkNorway", 20277 },
{ "x-ebcdic-denmarknorway-euro", 1142 },
{ "x-EBCDIC-FinlandSweden", 20278 },
{ "x-ebcdic-finlandsweden-euro", 1143 },
{ "X-EBCDIC-France", 1143 },
{ "X-EBCDIC-France", 1143 },
{ "x-ebcdic-france-euro", 1147 },
{ "x-EBCDIC-Germany", 20273 },
{ "x-ebcdic-germany-euro", 1141 },
{ "x-EBCDIC-GreekModern", 875 },
{ "x-EBCDIC-Greek", 20423 },
{ "x-EBCDIC-Hebrew", 20424 },
{ "x-EBCDIC-Icelandic", 20871 },
{ "x-ebcdic-icelandic-euro", 1149 },
{ "x-ebcdic-international-euro", 1148 },
{ "x-EBCDIC-Italy", 20280 },
{ "x-ebcdic-italy-euro", 1144 },
{ "x-EBCDIC-JapaneseAndKana", 50930 },
{ "x-EBCDIC-JapaneseAndJapaneseLatin", 50939 },
{ "x-EBCDIC-JapaneseAndUSCanada", 50931 },
{ "x-EBCDIC-JapaneseKatakana", 20290 },
{ "x-EBCDIC-KoreanAndKoreanExtended", 50933 },
{ "x-EBCDIC-KoreanExtended", 20833 },
{ "CP870", 870 },
{ "x-EBCDIC-SimplifiedChinese", 50935 },
{ "X-EBCDIC-Spain", 20284 },
{ "x-ebcdic-spain-euro", 1145 },
{ "x-EBCDIC-Thai", 20838 },
{ "x-EBCDIC-TraditionalChinese", 50937 },
{ "CP1026", 1026 },
{ "x-EBCDIC-Turkish", 20905 },
{ "x-EBCDIC-UK", 20285 },
{ "x-ebcdic-uk-euro", 1146 },
{ "ebcdic-cp-us", 37 },
{ "x-ebcdic-cp-us-euro", 1140 },
{ "ibm861", 861 },
{ "x-mac-icelandic", 10079 },
{ "x-iscii-as", 57006 },
{ "x-iscii-be", 57003 },
{ "x-iscii-de", 57002 },
{ "x-iscii-gu", 57010 },
{ "x-iscii-ka", 57008 },
{ "x-iscii-ma", 57009 },
{ "x-iscii-or", 57007 },
{ "x-iscii-pa", 57011 },
{ "x-iscii-ta", 57004 },
{ "x-iscii-te", 57005 },
{ "euc-jp", 51932 },
{ "csEUCPkdFmtJapanese", 51932 },
{ "Extended_UNIX_Code_Packed_Format_for_Japanese", 51932 },
{ "x-euc", 51932 },
{ "x-euc-jp", 51932 },
{ "iso-2022-jp", 50220 },
{ "iso-2022-jp", 50222 },
{ "_iso-2022-jp$SIO", 50222 },
{ "csISO2022JP", 50221 },
{ "_iso-2022-jp", 50221 },
{ "x-mac-japanese", 10001 },
{ "shift_jis", 932 },
{ "csShiftJIS", 932 },
{ "csWindows31J", 932 },
{ "ms_Kanji", 932 },
{ "shift-jis", 932 },
{ "x-ms-cp932", 932 },
{ "x-sjis", 932 },
{ "ks_c_5601-1987", 949 },
{ "csKSC56011987", 949 },
{ "euc-kr", 949 },
{ "iso-ir-149", 949 },
{ "korean", 949 },
{ "ks_c_5601", 949 },
{ "ks_c_5601_1987", 949 },
{ "ks_c_5601-1989", 949 },
{ "KSC_5601", 949 },
{ "KSC5601", 949 },
{ "euc-kr", 51949 },
{ "csEUCKR", 51949 },
{ "iso-2022-kr", 50225 },
{ "csISO2022KR", 50225 },
{ "Johab", 1361 },
{ "x-mac-korean", 10003 },
{ "iso-8859-3", 28593 },
{ "csISO", 28593 },
{ "Latin3", 28593 },
{ "ISO_8859-3", 28593 },
{ "ISO_8859-3:1988", 28593 },
{ "iso-ir-109", 28593 },
{ "l3", 28593 },
{ "latin3", 28593 },
{ "iso-8859-15", 28605 },
{ "csISO", 28605 },
{ "Latin9", 28605 },
{ "ISO_8859-15", 28605 },
{ "l9", 28605 },
{ "latin9", 28605 },
{ "x-IA5-Norwegian", 20108 },
{ "IBM437", 437 },
{ "437", 437 },
{ "cp437", 437 },
{ "csPC8", 437 },
{ "CodePage437", 437 },
{ "x-IA5-Swedish", 20107 },
{ "windows-874", 874 },
{ "DOS-874", 874 },
{ "iso-8859-11", 874 },
{ "TIS-620", 874 },
{ "ibm857", 857 },
{ "iso-8859-9", 28599 },
{ "csISO", 28599 },
{ "Latin5", 28599 },
{ "ISO_8859-9", 28599 },
{ "ISO_8859-9:1989", 28599 },
{ "iso-ir-148", 28599 },
{ "l5", 28599 },
{ "latin5", 28599 },
{ "x-mac-turkish", 10081 },
{ "windows-1254", 1254 },
{ "ISO_8859-9", 1254 },
{ "ISO_8859-9:1989", 1254 },
{ "iso-8859-9", 1254 },
{ "iso-ir-148", 1254 },
{ "latin5", 1254 },
{ "unicode", 1200 },
{ "utf-16", 1200 },
{ "unicodeFFFE", 1201 },
{ "utf-7", 65000 },
{ "csUnicode11UTF7", 65000 },
{ "unicode-1-1-utf-7", 65000 },
{ "x-unicode-2-0-utf-7", 65000 },
{ "utf-8", 65001 },
{ "unicode-1-1-utf-8", 65001 },
{ "unicode-2-0-utf-8", 65001 },
{ "x-unicode-2-0-utf-8", 65001 },
{ "us-ascii", 20127 },
{ "ANSI_X3.4-1968", 20127 },
{ "ANSI_X3.4-1986", 20127 },
{ "ascii", 20127 },
{ "cp367", 20127 },
{ "csASCII", 20127 },
{ "IBM367", 20127 },
{ "ISO_646.irv:1991", 20127 },
{ "ISO646-US", 20127 },
{ "iso-ir-6us", 20127 },
{ "windows-1258", 1258 },
{ "ibm850", 850 },
{ "x-IA5", 20105 },
{ "iso-8859-1", 28591 },
{ "cp819", 28591 },
{ "csISO", 28591 },
{ "Latin1", 28591 },
{ "ibm819", 28591 },
{ "iso_8859-1", 28591 },
{ "iso_8859-1:1987", 28591 },
{ "iso-ir-100", 28591 },
{ "l1", 28591 },
{ "latin1", 28591 },
{ "macintosh", 10000 },
{ "Windows-1252", 1252 },
{ "ANSI_X3.4-1968", 1252 },
{ "ANSI_X3.4-1986", 1252 },
{ "ascii", 1252 },
{ "cp367", 1252 },
{ "cp819", 1252 },
{ "csASCII", 1252 },
{ "IBM367", 1252 },
{ "ibm819", 1252 },
{ "ISO_646.irv:1991", 1252 },
{ "iso_8859-1", 1252 },
{ "iso_8859-1:1987", 1252 },
{ "ISO646-US", 1252 },
{ "iso-ir-100", 1252 },
{ "iso-ir-6", 1252 },
{ "latin1", 1252 },
{ "us", 1252 },
{ "us-ascii", 1252 },
{ "x-ansi", 1252 },
{ "microsoft-cp1251", 1251 }
};
#define LANGUAGE_NOT_LOADED 1
#define LANGUAGE_LOADING -1
#define LANGUAGE_LOADED 0
void LoadThread(LPVOID hd);
class HunspellDictionary : public Dictionary
{
protected:
wchar_t fileWithoutExtension[1024];
wchar_t userPath[1024];
volatile int loaded;
Hunspell *hunspell;
wchar_t *wordChars;
UINT codePage;
void loadCustomDict()
{
wchar_t filename[1024];
mir_snwprintf(filename, L"%s\\%s.cdic", userPath, language);
FILE *file = _wfopen(filename, L"rb");
if (file != nullptr) {
char tmp[1024];
int c, pos = 0;
while ((c = fgetc(file)) != EOF) {
if (c == '\n' || c == '\r' || pos >= _countof(tmp) - 1) {
if (pos > 0) {
tmp[pos] = '\0';
hunspell->add(tmp);
pos = 0;
}
}
else {
tmp[pos] = (char)c;
pos++;
}
}
fclose(file);
}
}
void appendToCustomDict(const wchar_t *word)
{
CreateDirectoryTreeW(userPath);
wchar_t filename[1024];
mir_snwprintf(filename, L"%s\\%s.cdic", userPath, language);
FILE *file = _wfopen(filename, L"ab");
if (file != nullptr) {
char tmp[1024];
toHunspell(tmp, word, _countof(tmp));
fprintf(file, "%s\n", tmp);
fclose(file);
}
}
virtual void addWordInternal(const wchar_t * word)
{
if (loaded != LANGUAGE_LOADED)
return;
char hunspell_word[1024];
toHunspell(hunspell_word, word, _countof(hunspell_word));
hunspell->add(hunspell_word);
}
void toHunspell(char *hunspellWord, const wchar_t *word, size_t hunspellWordLen)
{
WideCharToMultiByte(codePage, 0, word, -1, hunspellWord, (int)hunspellWordLen, nullptr, nullptr);
}
wchar_t* fromHunspell(const char *hunspellWord)
{
int len = MultiByteToWideChar(codePage, 0, hunspellWord, -1, nullptr, 0);
wchar_t *ret = (wchar_t *)malloc((len + 1) * sizeof(wchar_t));
MultiByteToWideChar(codePage, 0, hunspellWord, -1, ret, len + 1);
return ret;
}
wchar_t* fromHunspellAndFree(const char *hunspellWord)
{
if (hunspellWord == nullptr)
return nullptr;
wchar_t *ret = fromHunspell(hunspellWord);
return ret;
}
public:
HunspellDictionary(wchar_t *aLanguage, wchar_t *aFileWithoutExtension, wchar_t *anUserPath, wchar_t *aSource)
{
mir_wstrncpy(language, aLanguage, _countof(language));
mir_wstrncpy(fileWithoutExtension, aFileWithoutExtension, _countof(fileWithoutExtension));
mir_wstrncpy(userPath, anUserPath, _countof(userPath));
if (aSource == nullptr)
source[0] = '\0';
else
mir_wstrncpy(source, aSource, _countof(source));
loaded = LANGUAGE_NOT_LOADED;
localized_name[0] = '\0';
english_name[0] = '\0';
full_name[0] = '\0';
hunspell = nullptr;
wordChars = nullptr;
codePage = CP_ACP;
autoReplace = nullptr;
}
virtual ~HunspellDictionary()
{
delete hunspell;
if (wordChars != nullptr)
free(wordChars);
}
wchar_t* merge(wchar_t * s1, wchar_t *s2)
{
size_t len1 = mir_wstrlen(s1);
size_t len2 = mir_wstrlen(s2);
wchar_t *ret;
if (len1 > 0 && len2 > 0) {
ret = (wchar_t *)malloc(sizeof(wchar_t) * (len1 + len2 + 1));
mir_wstrncpy(ret, s1, len1 + 1);
mir_wstrncpy(&ret[len1], s2, len2 + 1);
FREE(s1);
FREE(s2);
}
else if (len1 > 0) {
ret = s1;
FREE(s2);
}
else if (len2 > 0) {
ret = s2;
FREE(s1);
}
else {
ret = (wchar_t *)malloc(sizeof(wchar_t));
ret[0] = 0;
FREE(s1);
FREE(s2);
}
// Remove duplicated chars
size_t last = mir_wstrlen(ret) - 1;
for (size_t i = 0; i <= last; i++) {
wchar_t c = ret[i];
for (size_t j = last; j > i; j--) {
if (c != ret[j])
continue;
if (j != last)
ret[j] = ret[last];
ret[last] = '\0';
last--;
}
}
return ret;
}
void loadThread()
{
char dic[1024];
char aff[1024];
mir_snprintf(dic, "%S.dic", fileWithoutExtension);
mir_snprintf(aff, "%S.aff", fileWithoutExtension);
hunspell = new Hunspell(aff, dic);
// Get codepage
const char *dic_enc = hunspell->get_dic_encoding();
wchar_t *hwordchars;
if (mir_strcmp(dic_enc, "UTF-8") == 0) {
codePage = CP_UTF8;
const std::vector<w_char> wordchars_utf16 = hunspell->get_wordchars_utf16();
hwordchars = fromHunspell((char *)&wordchars_utf16[0]);
}
else {
for (auto &it : codepages) {
if (_strcmpi(it.name, dic_enc) == 0) {
if (IsValidCodePage(it.codepage))
codePage = it.codepage;
break;
}
}
hwordchars = fromHunspell(hunspell->get_wordchars());
}
wchar_t *casechars = fromHunspellAndFree(get_casechars(dic_enc).c_str());
wchar_t *try_string = fromHunspellAndFree(hunspell->get_try_string());
wordChars = merge(merge(casechars, hwordchars), try_string);
// Make a suggestion to load hunspell internalls
char ** words = nullptr;
int count = hunspell->suggest(&words, "asdf");
for (int i = 0; i < count; i++)
free(words[i]);
if (words != nullptr)
free(words);
loadCustomDict();
loaded = LANGUAGE_LOADED;
}
// Return TRUE if the word is correct
virtual BOOL spell(const wchar_t *word)
{
load();
if (loaded != LANGUAGE_LOADED)
return TRUE;
// TODO Check if it was generated by auto-replacement
char hunspell_word[1024];
toHunspell(hunspell_word, word, _countof(hunspell_word));
return hunspell->spell(hunspell_word);
}
// Return a list of suggestions to a word
virtual Suggestions suggest(const wchar_t * word)
{
Suggestions ret = {};
load();
if (loaded != LANGUAGE_LOADED)
return ret;
char hunspell_word[1024];
toHunspell(hunspell_word, word, _countof(hunspell_word));
char ** words = nullptr;
ret.count = hunspell->suggest(&words, hunspell_word);
if (ret.count > 0 && words != nullptr) {
// Oki, lets make our array
ret.words = (wchar_t **)malloc(ret.count * sizeof(wchar_t *));
for (unsigned i = 0; i < ret.count; i++) {
ret.words[i] = fromHunspell(words[i]);
free(words[i]);
}
}
if (words != nullptr)
free(words);
return ret;
}
// Return a list of auto suggestions to a word
virtual Suggestions autoSuggest(const wchar_t * word)
{
Suggestions ret = {};
load();
if (loaded != LANGUAGE_LOADED)
return ret;
char hunspell_word[1024];
toHunspell(hunspell_word, word, _countof(hunspell_word));
char ** words;
int count = hunspell->suggest(&words, hunspell_word);
if (count <= 0)
return ret;
// Oki, lets make our array
ret.count = count;
ret.words = (wchar_t **)malloc(ret.count * sizeof(wchar_t *));
for (int i = 0; i < count; i++) {
ret.words[i] = fromHunspell(words[i]);
free(words[i]);
}
free(words);
return ret;
}
// Return a list of auto suggestions to a word
// You have to free the list AND each item
virtual wchar_t * autoSuggestOne(const wchar_t * word)
{
load();
if (loaded != LANGUAGE_LOADED)
return nullptr;
char hunspell_word[1024];
toHunspell(hunspell_word, word, _countof(hunspell_word));
char **words;
int count = hunspell->suggest(&words, hunspell_word);
if (count <= 0)
return nullptr;
wchar_t *ret = fromHunspell(words[0]);
// Oki, lets make our array
for (int i = 0; i < count; i++)
free(words[i]);
free(words);
return ret;
}
// Return TRUE if the char is a word char
virtual BOOL isWordChar(wchar_t c)
{
if (c == 0)
return FALSE;
load();
if (loaded != LANGUAGE_LOADED)
return TRUE;
return wcschr(wordChars, c) != nullptr;
}
// Assert that all needed data is loaded
virtual void load()
{
if (loaded == LANGUAGE_NOT_LOADED) {
loaded = LANGUAGE_LOADING;
mir_forkthread(LoadThread, this);
}
}
virtual BOOL isLoaded()
{
return loaded == LANGUAGE_LOADED;
}
// Add a word to the user custom dict
virtual void addWord(const wchar_t * word)
{
addWordInternal(word);
appendToCustomDict(word);
}
// Add a word to the list of ignored words
virtual void ignoreWord(const wchar_t * word)
{
addWordInternal(word);
}
};
void LoadThread(LPVOID hd)
{
HunspellDictionary *dict = (HunspellDictionary *)hd;
dict->loadThread();
}
// To use with EnumLocalesProc :(
LIST<Dictionary> *tmp_dicts;
// To get the names of the languages
BOOL CALLBACK EnumLocalesProc(LPTSTR lpLocaleString)
{
wchar_t *stopped = nullptr;
USHORT langID = (USHORT)wcstol(lpLocaleString, &stopped, 16);
wchar_t ini[32];
wchar_t end[32];
GetLocaleInfo(MAKELCID(langID, 0), LOCALE_SISO639LANGNAME, ini, _countof(ini));
GetLocaleInfo(MAKELCID(langID, 0), LOCALE_SISO3166CTRYNAME, end, _countof(end));
wchar_t name[64];
mir_snwprintf(name, L"%s_%s", ini, end);
for (auto &dict : *tmp_dicts) {
if (mir_wstrcmpi(dict->language, name) == 0) {
GetLocaleInfo(MAKELCID(langID, 0), LOCALE_SENGLANGUAGE, dict->english_name, _countof(dict->english_name));
GetLocaleInfo(MAKELCID(langID, 0), LOCALE_SLANGUAGE, dict->localized_name, _countof(dict->localized_name));
if (dict->localized_name[0] == 0)
GetLocaleInfo(MAKELCID(langID, 0), LOCALE_SLOCALIZEDLANGUAGENAME, dict->localized_name, _countof(dict->localized_name));
if (dict->localized_name[0] == 0)
GetLocaleInfo(MAKELCID(langID, 0), LOCALE_SNATIVEDISPLAYNAME, dict->localized_name, _countof(dict->localized_name));
if (dict->localized_name[0] == 0 && dict->english_name[0] != 0) {
wchar_t country[1024];
GetLocaleInfo(MAKELCID(langID, 0), LOCALE_SENGCOUNTRY, country, _countof(country));
wchar_t localName[1024];
if (country[0] != 0)
mir_snwprintf(localName, L"%s (%s)", dict->english_name, country);
else
mir_wstrncpy(localName, dict->english_name, _countof(localName));
mir_wstrncpy(dict->localized_name, TranslateW(localName), _countof(dict->localized_name));
}
if (dict->localized_name[0] != 0) {
mir_snwprintf(dict->full_name, L"%s [%s]", dict->localized_name, dict->language);
}
break;
}
}
return TRUE;
}
void GetDictsInfo(LIST<Dictionary> &dicts)
{
tmp_dicts = &dicts;
EnumSystemLocales(EnumLocalesProc, LCID_SUPPORTED);
// Try to get name from DB
for (auto &dict : dicts) {
if (dict->full_name[0] == '\0') {
DBVARIANT dbv;
char lang[128];
WideCharToMultiByte(CP_ACP, 0, dict->language, -1, lang, sizeof(lang), nullptr, nullptr);
if (!g_plugin.getWString(lang, &dbv)) {
mir_wstrncpy(dict->localized_name, dbv.pwszVal, _countof(dict->localized_name));
db_free(&dbv);
}
if (dict->localized_name[0] == '\0') {
for (auto &it : aditionalLanguages) {
if (!mir_wstrcmp(it.language, dict->language)) {
mir_wstrncpy(dict->localized_name, TranslateW(it.localized_name), _countof(dict->localized_name));
break;
}
}
}
if (dict->localized_name[0] != '\0')
mir_snwprintf(dict->full_name, L"%s [%s]", dict->localized_name, dict->language);
else
mir_wstrncpy(dict->full_name, dict->language, _countof(dict->full_name));
}
}
}
void GetHunspellDictionariesFromFolder(LIST<Dictionary> &dicts, wchar_t *path, wchar_t *user_path, wchar_t *source)
{
// Load the language files and create an array with then
wchar_t file[1024] = { 0 };
mir_snwprintf(file, L"%s\\*.dic", path);
BOOL found = FALSE;
WIN32_FIND_DATA ffd = { 0 };
HANDLE hFFD = FindFirstFile(file, &ffd);
if (hFFD != INVALID_HANDLE_VALUE) {
do {
mir_snwprintf(file, L"%s\\%s", path, ffd.cFileName);
// Check .dic
uint32_t attrib = GetFileAttributes(file);
if (attrib == 0xFFFFFFFF || (attrib & FILE_ATTRIBUTE_DIRECTORY))
continue;
// See if .aff exists too
mir_wstrcpy(&file[mir_wstrlen(file) - 4], L".aff");
attrib = GetFileAttributes(file);
if (attrib == 0xFFFFFFFF || (attrib & FILE_ATTRIBUTE_DIRECTORY))
continue;
ffd.cFileName[mir_wstrlen(ffd.cFileName) - 4] = '\0';
wchar_t *lang = ffd.cFileName;
// Replace - for _
for (size_t i = 0; i < mir_wstrlen(lang); i++)
if (lang[i] == '-')
lang[i] = '_';
// Check if dict is new
bool exists = false;
for (auto &it : dicts)
if (mir_wstrcmp(it->language, lang) == 0) {
exists = true;
break;
}
if (!exists) {
found = TRUE;
file[mir_wstrlen(file) - 4] = '\0';
dicts.insert(new HunspellDictionary(lang, file, user_path, source));
}
} while (FindNextFile(hFFD, &ffd));
FindClose(hFFD);
}
}
// Return a list of avaible languages
void GetAvaibleDictionaries(LIST<Dictionary> &dicts, wchar_t *path, wchar_t *user_path)
{
// Get miranda folder dicts
GetHunspellDictionariesFromFolder(dicts, path, user_path, nullptr);
if (opts.use_other_apps_dicts) {
// Get other apps dicts
for (auto &it : otherHunspellApps) {
wchar_t key[1024];
mir_snwprintf(key, APPPATH, it.key);
HKEY hKey = nullptr;
LONG lResult = 0;
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, key, 0, KEY_QUERY_VALUE, &hKey)) {
DWORD size = _countof(key);
lResult = RegQueryValueEx(hKey, L"Path", nullptr, nullptr, (LPBYTE)key, &size);
RegCloseKey(hKey);
}
else {
// Not found in installed apps - Try MUICache
lResult = RegOpenKeyEx(HKEY_CURRENT_USER, MUICACHE, 0, KEY_QUERY_VALUE, &hKey);
if (ERROR_SUCCESS == lResult) {
DWORD numValues;
if (ERROR_SUCCESS != RegQueryInfoKey(hKey, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &numValues, nullptr, nullptr, nullptr, nullptr))
numValues = 0;
lResult = ERROR_NO_MORE_ITEMS;
for (uint32_t local = 0; local < numValues; local++) {
DWORD cchValue = _countof(key);
if (ERROR_SUCCESS != RegEnumValue(hKey, local, key, &cchValue, nullptr, nullptr, nullptr, nullptr))
break;
key[cchValue] = 0;
wchar_t *pos;
if (pos = wcsrchr(key, '\\')) {
if (!mir_wstrcmpi(&pos[1], it.key)) {
pos[0] = 0;
lResult = ERROR_SUCCESS;
break;
}
}
}
RegCloseKey(hKey);
}
}
if (ERROR_SUCCESS == lResult) {
wchar_t folder[1024];
mir_snwprintf(folder, L"%s\\Dictionaries", key);
GetHunspellDictionariesFromFolder(languages, folder, user_path, it.name);
}
}
}
GetDictsInfo(dicts);
// Yeah, yeah, yeah, I know, but this is the easiest way...
SortedList *sl = (SortedList *)&dicts;
// Sort dicts
for (int i = 0; i < dicts.getCount(); i++) {
for (int j = i + 1; j < dicts.getCount(); j++) {
if (mir_wstrcmp(dicts[i]->full_name, dicts[j]->full_name) > 0) {
Dictionary *dict = dicts[i];
sl->items[i] = dicts[j];
sl->items[j] = dict;
}
}
}
}
// Free the list returned by GetAvaibleDictionaries
void FreeDictionaries(LIST<Dictionary> &dicts)
{
for (auto &it : dicts)
delete it;
dicts.destroy();
}
Dictionary::~Dictionary()
{
delete autoReplace;
}
// Free the list returned by GetAvaibleDictionaries
void FreeSuggestions(Suggestions &suggestions)
{
for (size_t i = 0; i < suggestions.count; i++)
free(suggestions.words[i]);
free(suggestions.words);
suggestions.words = nullptr;
suggestions.count = 0;
}