bbs/deb-goldedplus
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added support for MySpell spellchecker

Browse Source
This commit is contained in:
Ianos Gnatiuc 2006-03-11 17:04:06 +00:00
parent dbac4566d8
commit 8a041219e4
24 changed files with 489 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
golded3/gccfgg.cpp
View File

@ -545,9 +545,7 @@ GoldedCfgEdit::GoldedCfgEdit() {
str.push_back(""); cfg.external = str.size()-1;
str.push_back(GOLDED_MSG); cfg.file = str.size()-1;
str.push_back("<<"); cfg.hardline = str.size()-1;
#if defined(GCFG_NOSPELLDLL)
str.push_back(""); cfg.spellchecker = str.size()-1;
#endif
}
@ -770,10 +768,11 @@ CfgGed::CfgGed() {
replylinkfloat = true;
replylinklist = 0;
replylinkshowalways = true;
#if !defined(GCFG_NOSPELLDLL)
scheckerdeflang = 0xFFFF;
#if defined(GCFG_SPELL_INCLUDED)
scheckerenabled = NO;
strcpy(scheckerdeflang, "65535");
strcpy(scheckeruserdic, "user.dic");
strcpy(scheckerdicpath, "dicts");
#endif
screenblanker = 180;
screenblankertype = BLANK_SLIDEWIN;

7
golded3/gccfgg.h
View File

@ -167,9 +167,7 @@ const word CRC_EDITREPLYRE = 0x5D23;
const word CRC_EDITSAVEMENU = 0x7BC2;
const word CRC_EDITSAVEUTIL = 0xF411;
const word CRC_EDITSOFTCRXLAT = 0xA49A;
#if defined(GCFG_NOSPELLDLL)
const word CRC_EDITSPELLCHECK = 0xE167;
#endif
const word CRC_EDITUNDELETE = 0x4C34;
const word CRC_EMPTYTEARLINE = 0x8D0A;
const word CRC_ENCODEEMAILHEADERS=0xA843;
@ -322,10 +320,11 @@ const word CRC_REPLYLINKFLOAT = 0xA3EC;
const word CRC_REPLYLINKLIST = 0x104F;
const word CRC_REPLYLINKSHOWALWAYS = 0x2BCD;
const word CRC_ROBOTNAME = 0x7393;
#if !defined(GCFG_NOSPELLDLL)
const word CRC_SCHECKERDEFLANG = 0xBBEB;
#if defined(GCFG_SPELL_INCLUDED)
const word CRC_SCHECKERENABLED = 0x7394;
const word CRC_SCHECKERDEFLANG = 0xBBEB;
const word CRC_SCHECKERUSERDIC = 0x0753;
const word CRC_SCHECKERDICPATH = 0x4338;
#endif
const word CRC_SCREENBLANKER = 0x5CF7;
const word CRC_SCREENMAXCOL = 0xFFFC;

18
golded3/gccfgg0.cpp
View File

@ -323,9 +323,7 @@ SwitchE:
case CRC_EDITSAVEMENU : CfgEditsavemenu (); break;
case CRC_EDITSAVEUTIL : CfgEditsaveutil (); break;
case CRC_EDITSOFTCRXLAT : CfgEditsoftcrxlat (); break;
#if defined(GCFG_NOSPELLDLL)
case CRC_EDITSPELLCHECK : CfgEditspellcheck (); break;
#endif
case CRC_EDITUNDELETE : CfgEditundelete (); break;
case CRC_ENDGROUP : CfgEndgroup (); break;
case CRC_ENCODEEMAILHEADERS: CfgEncodeemailheaders(); break;
@ -523,11 +521,13 @@ SwitchR:
goto End;
SwitchS:
switch(crc) {
#if !defined(GCFG_NOSPELLDLL)
case CRC_SCHECKERDEFLANG : CfgScheckerdeflang (); break;
switch(crc)
{
#if defined(GCFG_SPELL_INCLUDED)
case CRC_SCHECKERENABLED : CfgScheckerenabled (); break;
case CRC_SCHECKERDEFLANG : CfgScheckerdeflang (); break;
case CRC_SCHECKERUSERDIC : CfgScheckeruserdic (); break;
case CRC_SCHECKERDICPATH : CfgScheckerdicpath (); break;
#endif
case CRC_SCREENBLANKER : CfgScreenblanker (); break;
case CRC_SCREENMAXCOL : CfgScreenmaxcol (); break;
@ -699,6 +699,14 @@ static int do_if(char* val) {
return false;
#endif
}
else if (strieql(val, "SPELL"))
{
#ifdef GCFG_SPELL_INCLUDED
return true;
#else
return false;
#endif
}
else if(strieql(val, "FIREBIRD"))
return true;
else if(strieql(val, "ASA") or strieql(val, "PLUS"))

3
golded3/gccfgg3.cpp
View File

@ -324,12 +324,11 @@ void CfgEditsoftcrxlat() {
// ------------------------------------------------------------------
#if defined(GCFG_NOSPELLDLL)
void CfgEditspellcheck() {
EDIT->SpellChecker(val);
}
#endif
// ------------------------------------------------------------------
void CfgEditundelete() {

21
golded3/gccfgg7.cpp
View File

@ -222,19 +222,17 @@ void CfgRobotname() {
// ------------------------------------------------------------------
#if !defined(GCFG_NOSPELLDLL)
void CfgScheckerdeflang()
#if defined(GCFG_SPELL_INCLUDED)
void CfgScheckerenabled()
{
CFG->scheckerdeflang = atoi(val);
if (CFG->scheckerdeflang == 0)
CFG->scheckerdeflang = 0xFFFF;
CFG->scheckerenabled = GetYesno(val);
}
// ------------------------------------------------------------------
void CfgScheckerenabled()
void CfgScheckerdeflang()
{
CFG->scheckerenabled = GetYesno(val);
strcpy(CFG->scheckerdeflang, val);
}
// ------------------------------------------------------------------
@ -243,7 +241,14 @@ void CfgScheckeruserdic()
{
strcpy(CFG->scheckeruserdic, StripQuotes(val));
}
#endif
// ------------------------------------------------------------------
void CfgScheckerdicpath()
{
strcpy(CFG->scheckerdicpath, StripQuotes(val));
}
#endif //#if defined(GCFG_SPELL_INCLUDED)
// ------------------------------------------------------------------

6
golded3/gckeys.cpp
View File

@ -119,9 +119,7 @@ CmdKey DefaultKeyset[] = {
{ Key_A_S , KK_EditSaveMsg , KT_E },
{ Key_C_Z , KK_EditSaveMsg , KT_E },
{ Key_F2 , KK_EditSaveMsg , KT_E },
#if defined(GCFG_NOSPELLDLL)
{ Key_F9 , KK_EditSpellCheck , KT_E },
#endif
{ Key_Tab , KK_EditTab , KT_E },
{ Key_S_Tab , KK_EditTabReverse , KT_E },
{ Key_A_3 , KK_EditToggleCase , KT_E },
@ -677,7 +675,7 @@ tglobalkey globalkeys[] = {
{ CRC_READSHOWDEL , KK_ReadShowDel , KT_R }, // 0x8615
{ CRC_K_ENTER , Key_Ent , 0 }, // 0x87BD
{ CRC_EDITGOTOPLINE , KK_EditGoTopLine , KT_E }, // 0x87C2
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
{ CRC_EDITSCHECKERMENU , KK_EditSCheckerMenu , KT_E }, // 0x881F
#endif
{ CRC_HEADERTOGGLEARCSENT , KK_HeaderToggleArcsent , KT_H }, // 0x88A7
@ -826,9 +824,7 @@ tglobalkey globalkeys[] = {
{ CRC_EDITBLOCKUP , KK_EditBlockUp , KT_E }, // 0xE004
{ CRC_EDITGOBEGLINE , KK_EditGoBegLine , KT_E }, // 0xE045
{ CRC_READGOTONEXTMSG , KK_ReadGotoNextMsg , KT_R }, // 0xE0F1
#if defined(GCFG_NOSPELLDLL)
{ CRC_EDITSPELLCHECK , KK_EditSpellCheck , KT_E }, // 0xE167
#endif
{ CRC_AREASCAN , KK_AreaScan , KT_A }, // 0xE440
{ CRC_EDITGOWORDLEFT , KK_EditGoWordLeft , KT_E }, // 0xE48C
{ CRC_EDITSCODENORMAL , KK_EditSCodeNormal , KT_E }, // 0xE4CE

4
golded3/gckeys.h
View File

@ -113,7 +113,7 @@ const word CRC_EDITQUITNOW = 0x80BA;
const word CRC_EDITREFLOW = 0x13F9;
const word CRC_EDITSAVEFILE = 0x64A4;
const word CRC_EDITSAVEMSG = 0x660C;
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
const word CRC_EDITSCHECKERMENU = 0x881F;
#endif
const word CRC_EDITSCODENORMAL = 0xE4CE;
@ -122,9 +122,7 @@ const word CRC_EDITSCODEITALIC = 0x487F;
const word CRC_EDITSCODEUNDERLINE = 0xB1D9;
const word CRC_EDITSCODEREVERSE = 0xFC0E;
const word CRC_EDITSOUNDKILL = 0xA9A7;
#if defined(GCFG_NOSPELLDLL)
const word CRC_EDITSPELLCHECK = 0xE167;
#endif
const word CRC_EDITTAB = 0x8C26;
const word CRC_EDITTABREVERSE = 0xF5B6;
const word CRC_EDITTOGGLECASE = 0xC282;

2
golded3/gclang.cpp
View File

@ -398,9 +398,7 @@ static LangCrc LangCrcs[] = {
{ CRC_IL_FOUNDPERSONAL , NULL , " Found %u personal mail%s in %u area%s " },
{ CRC_IL_NOPERSONAL , NULL , " No personal mail found " },
{ CRC_ST_ESCORCONTINUE , NULL , "ESC exits. Other keys: Tries to continue" },
#if defined(GCFG_NOSPELLDLL)
{ CRC_MS_SPELLCHECKER , NULL , "SpellChecker: %s" },
#endif
{ CRC_WT_INS , NULL , " Ins " },
{ CRC_WT_DRAWSL , NULL , " DL1 " },
{ CRC_WT_DRAWDL , NULL , " DL2 " },

2
golded3/gclang.h
View File

@ -401,9 +401,7 @@ const word CRC_WT_GRP = 0xD2EA;
const word CRC_IL_FOUNDPERSONAL = 0xA039;
const word CRC_IL_NOPERSONAL = 0x2813;
const word CRC_ST_ESCORCONTINUE = 0x4800;
#if defined(GCFG_NOSPELLDLL)
const word CRC_MS_SPELLCHECKER = 0x69B4;
#endif
const word CRC_WT_INS = 0x2F27;
const word CRC_WT_DRAWSL = 0x264D;
const word CRC_WT_DRAWDL = 0x314D;

6
golded3/gcmisc.cpp
View File

@ -225,7 +225,7 @@ const word CRC_STYLECODES = 0x4CB0;
// ------------------------------------------------------------------
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
const word CRC_SPELL = 0xB8AE;
const word CRC_SCERROR = 0xAB65;
#endif
@ -423,7 +423,7 @@ void GetColors(char* value) {
case CRC_STYLECODES:
wptr = &GC_STYLE_;
break;
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
case CRC_SPELL:
wptr = &GC_SPELL_;
break;
@ -591,7 +591,7 @@ void GetColors(char* value) {
wptr->_ReverseBoldItalicUnderscore = attr;
}
break;
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
case CRC_SCERROR:
wptr->_SpellError = attr;
break;

7
golded3/gcprot.h
View File

@ -165,9 +165,7 @@ void CfgEditreplyre ();
void CfgEditsavemenu ();
void CfgEditsaveutil ();
void CfgEditsoftcrxlat ();
#if defined(GCFG_NOSPELLDLL)
void CfgEditspellcheck ();
#endif
void CfgEditundelete ();
void CfgEmptytearline ();
void CfgEncodeemailheaders();
@ -308,10 +306,11 @@ void CfgReplylinklist ();
void CfgReplylinkshowalways();
void CfgReplyto ();
void CfgRobotname ();
#if !defined(GCFG_NOSPELLDLL)
void CfgScheckerdeflang ();
#if defined(GCFG_SPELL_INCLUDED)
void CfgScheckerenabled ();
void CfgScheckerdeflang ();
void CfgScheckeruserdic ();
void CfgScheckerdicpath ();
#endif
void CfgScreenblanker ();
void CfgScreenmaxcol ();

6
golded3/geall.h
View File

@ -638,7 +638,7 @@ struct SaveUtil {
#define GC_CFGB_ CFG->color[11]
#define GC_STYLE_ CFG->color[12]
#define GC_SHAD_ CFG->color[13]
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
#define GC_SPELL_ CFG->color[14]
#endif
@ -693,7 +693,7 @@ struct SaveUtil {
#define _ReverseItalicUnderscore c[14]
#define _ReverseBoldItalicUnderscore c[15]
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
#define _SpellError c[0]
#endif
@ -813,7 +813,7 @@ struct SaveUtil {
#define C_STYLERUI_ GC_STYLE_._ReverseItalicUnderscore
#define C_STYLERUIB GC_STYLE_._ReverseBoldItalicUnderscore
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
#define C_SCERROR GC_SPELL_._SpellError
#endif

11
golded3/gecfgg.h
View File

@ -310,10 +310,11 @@ public:
int replylinklist;
bool replylinkshowalways;
gstrarray robotname;
#if !defined(GCFG_NOSPELLDLL)
word scheckerdeflang;
#if defined(GCFG_SPELL_INCLUDED)
int scheckerenabled;
char scheckerdeflang[100];
Path scheckeruserdic;
Path scheckerdicpath;
#endif
int screenblanker; // blanktime;
int screenblankertype;
@ -469,9 +470,7 @@ protected:
int external;
int file;
int hardline;
#if defined(GCFG_NOSPELLDLL)
int spellchecker;
#endif
} cfg;
// -----------------------------------------------------------------
@ -522,9 +521,7 @@ public:
int ReplyRe() { return cfg.replyre; }
bool SaveMenu() { return cfg.savemenu; }
char SoftCrXlat() { return cfg.softcrxlat; }
#if defined(GCFG_NOSPELLDLL)
const char* SpellChecker() { return str[cfg.spellchecker].c_str(); }
#endif
int UnDelete() { return cfg.undelete; }
// -----------------------------------------------------------------
@ -555,9 +552,7 @@ public:
void ReplyRe(int s) { cfg.replyre = s; }
void SaveMenu(bool s) { cfg.savemenu = s; }
void SoftCrXlat(char s) { cfg.softcrxlat = s; }
#if defined(GCFG_NOSPELLDLL)
void SpellChecker(char* s) { str[cfg.spellchecker] = s; }
#endif
void UnDelete(int s) { cfg.undelete = s; }
};

22
golded3/geedit.cpp
View File

@ -95,7 +95,7 @@ void IEclass::debugtest(char* __test, int __a, int __b, char* __file, int __line
// ------------------------------------------------------------------
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
inline bool isscchar(int c)
{
return isxalnum(c) || (c == '-') || (c == '\'') || (c == '.') ;
@ -252,7 +252,7 @@ void IEclass::gotorowcol(uint __col, uint __row) {
// ------------------------------------------------------------------
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
void IEclass::dispstringsc(char *__buf, uint __beg, uint __end, uint __row, uint __col, char endchar)
{
char scbuf[EDIT_BUFLEN];
@ -448,7 +448,7 @@ void IEclass::dispstring(Line* line, uint __row)
GFTRK(NULL);
}
#else // #if !defined(GCFG_NOSPELLDLL)
#else // #if defined(GCFG_SPELL_INCLUDED)
// ------------------------------------------------------------------
@ -564,7 +564,7 @@ void IEclass::dispstring(const char* __string, uint __row, int attr, Line* line)
GFTRK(NULL);
}
#endif // #if !defined(GCFG_NOSPELLDLL)
#endif // #if defined(GCFG_SPELL_INCLUDED)
// ------------------------------------------------------------------
@ -604,7 +604,7 @@ void IEclass::displine(Line* __line, uint __row) {
// Display line
setcolor(__line);
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
dispstring(__line, __row);
#else
dispstring(__line->txt.c_str(), __row, -1, __line);
@ -652,7 +652,7 @@ void IEclass::refresh(Line* __currline, uint __row) {
}
// If we ran out of lines, blank the rest
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
if (__row <= maxrow)
editwin.fill(__row, mincol, __row, maxcol, _box_table(W_BREAD, 1), C_READB|ACSET);
if (++__row <= maxrow)
@ -2084,7 +2084,7 @@ void IEclass::SaveMsg() {
// ------------------------------------------------------------------
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
void IEclass::SCheckerMenu()
{
if (!schecker.IsLoaded())
@ -2783,13 +2783,11 @@ noselecting:
case KK_EditReflow: Reflow(); break;
case KK_EditSaveFile: SaveFile(); break;
case KK_EditSaveMsg: SaveMsg(); break;
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
case KK_EditSCheckerMenu: SCheckerMenu(); break;
#endif
case KK_EditSoundkill: Soundkill(); break;
#if defined(GCFG_NOSPELLDLL)
case KK_EditSpellCheck: SpellCheck(); break;
#endif
case KK_EditTab: Tab(); break;
case KK_EditTabReverse: ReTab(); break;
case KK_EditToggleCase: ToggleCase(); break;
@ -2840,10 +2838,10 @@ int IEclass::Start(int __mode, uint* __position, GMsg* __msg) {
msgmode = __mode;
currline = __msg->lin;
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
if (CFG->scheckerenabled)
{
schecker.Init();
schecker.Init(CFG->xlatlocalset, CFG->scheckerdicpath);
schecker.Load(CFG->scheckerdeflang, CFG->scheckeruserdic);
}
#endif

8
golded3/geedit.h
View File

@ -284,7 +284,7 @@ protected:
// ----------------------------------------------------------------
// Speller (DLL)
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
CSpellChecker schecker;
#endif
@ -299,7 +299,7 @@ protected:
void dispins ();
void dispdl ();
void displine (Line* __line, uint __row);
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
void dispstringsc (char *__buf, uint __beg, uint __end, uint __row, uint __col, char endchar);
void dispstring (Line* line, uint __row);
#else
@ -409,14 +409,12 @@ public:
void ReTab ();
void SaveFile ();
void SaveMsg ();
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
void SCheckerMenu ();
#endif
void Soundkill ();
#if defined(GCFG_NOSPELLDLL)
// External spell check tool
void SpellCheck ();
#endif
void Tab ();
void ToggleCase ();
void ToggleCaseBlock(gkey key);

6
golded3/geedit2.cpp
View File

@ -1311,9 +1311,8 @@ void IEclass::editexport(Line* __exportline, int __endat) {
// ------------------------------------------------------------------
#if defined(GCFG_NOSPELLDLL)
void IEclass::SpellCheck() {
void IEclass::SpellCheck()
{
GFTRK("EditSpellCheck");
char _buf[EDIT_BUFLEN];
@ -1330,7 +1329,6 @@ void IEclass::SpellCheck() {
GFTRK(NULL);
}
#endif
// ------------------------------------------------------------------

4
golded3/gekeys.h
View File

@ -169,9 +169,7 @@ const gkey KK_EditReflow = 0xFEEE;
const gkey KK_EditSaveFile = 0xFEEF;
const gkey KK_EditSaveMsg = 0xFEF0;
const gkey KK_EditSoundkill = 0xFEF1;
#if defined(GCFG_NOSPELLDLL)
const gkey KK_EditSpellCheck = 0xFEF2;
#endif
const gkey KK_EditTab = 0xFEF3;
const gkey KK_EditTabReverse = 0xFEF4;
const gkey KK_EditToggleCase = 0xFEF5;
@ -198,7 +196,7 @@ const gkey KK_EditSCodeBold = 0xFF09;
const gkey KK_EditSCodeItalic = 0xFF0A;
const gkey KK_EditSCodeUnderline = 0xFF0B;
const gkey KK_EditSCodeReverse = 0xFF0C;
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
const gkey KK_EditSCheckerMenu = 0xFF0D;
#endif
const gkey KK_EditDrawLines = 0xFF0E;

2
golded3/gelang.h
View File

@ -385,9 +385,7 @@ struct LangGed {
char* FoundPersonal; // IL_FOUNDPERSONAL
char* NoPersonal; // IL_NOPERSONAL
char* EscOrContinue; // ST_ESCORCONTINUE
#if defined(GCFG_NOSPELLDLL)
char* SpellChecker; // MS_SPELLCHECKER
#endif
char* Ins; // WT_INS
char* DrawSL; // WT_DRAWSL
char* DrawDL; // WT_DRAWDL

21
golded3/gemnus.cpp
View File

@ -1070,7 +1070,7 @@ int GMenuConfirm::Run() {
// ------------------------------------------------------------------
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
int GMenuSChecker::Run(CSpellChecker &schecker, const char *word)
{
enum
@ -1110,23 +1110,20 @@ int GMenuSChecker::Run(CSpellChecker &schecker, const char *word)
size_t numrows = 7;
CSpellLangV &langs = schecker.GetLangs();
LIDC lidc = schecker.GetLangCode();
const char *lcode = schecker.GetLangCode();
std::vector<std::string> langstr;
size_t langcount = langs.size();
for (idx = 0; idx < langcount; idx++)
{
char buff[10];
LIDC code = langs[idx].GetLangCode();
const char *code = langs[idx]->GetLangCode();
buff[0] = ' ';
buff[1] = (code == lidc) ? '\x10' : ' ';
std::string buff = " ";
buff += streql(lcode, code) ? '\x10' : ' ';
buff += code; buff += ' ';
itoa(code, &buff[2], 10);
strcat(buff, " ");
langstr.push_back(std::string(buff));
langstr.push_back(buff);
}
if (langcount)
@ -1143,7 +1140,7 @@ int GMenuSChecker::Run(CSpellChecker &schecker, const char *word)
End();
}
if (*word && schecker.IsUdrOpened())
if (*word && schecker.IsUdrLoaded())
{
Item(TAG_ADDWORD, "A Add Word... ");
numrows++;
@ -1199,7 +1196,7 @@ int GMenuSChecker::Run(CSpellChecker &schecker, const char *word)
}
else if ((finaltag > TAG_LANG) && (finaltag < TAG_MORE))
{
schecker.Load(langs[finaltag-TAG_LANG-1].GetLangCode(), CFG->scheckeruserdic);
schecker.Load(langs[finaltag-TAG_LANG-1]->GetLangCode(), CFG->scheckeruserdic);
return -2;
}

2
golded3/gemnus.h
View File

@ -304,7 +304,7 @@ public:
// ------------------------------------------------------------------
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
class GMenuSChecker : public GMnu
{
public:

6
golded3/getpls.cpp
View File

@ -113,9 +113,7 @@ int TemplateToText(int mode, GMsg* msg, GMsg* oldmsg, const char* tpl, int origa
TPLTOKEN_COMMENT,
TPLTOKEN_QUOTEBUF,
TPLTOKEN_ATTRIB,
#if defined(GCFG_NOSPELLDLL)
TPLTOKEN_SPELLCHECKER,
#endif
TPLTOKEN_SETSUBJ,
TPLTOKEN_SETFROM,
TPLTOKEN_SETTO,
@ -154,9 +152,7 @@ int TemplateToText(int mode, GMsg* msg, GMsg* oldmsg, const char* tpl, int origa
{ CSTR_COMMA_SIZEOF_CSTR("comment") },
{ CSTR_COMMA_SIZEOF_CSTR("quotebuf") },
{ CSTR_COMMA_SIZEOF_CSTR("attrib") },
#if defined(GCFG_NOSPELLDLL)
{ CSTR_COMMA_SIZEOF_CSTR("spellchecker") },
#endif
{ CSTR_COMMA_SIZEOF_CSTR("setsubj") },
{ CSTR_COMMA_SIZEOF_CSTR("setfrom") },
{ CSTR_COMMA_SIZEOF_CSTR("setto") },
@ -492,12 +488,10 @@ int TemplateToText(int mode, GMsg* msg, GMsg* oldmsg, const char* tpl, int origa
}
continue;
#if defined(GCFG_NOSPELLDLL)
case TPLTOKEN_SPELLCHECKER:
if(mode != MODE_QUOTEBUF)
EDIT->SpellChecker(strskip_wht(ptr));
continue;
#endif
case TPLTOKEN_SETSUBJ:
case TPLTOKEN_FORCESUBJ:

17
goldlib/gall/gdefs.h
View File

@ -101,18 +101,23 @@
#define NL "\n"
#endif
/* ----------------------------------------------------------------*/
/* ------------------------------------------------------------------
// Spellchecker */
#if !defined(__WIN32__) && !defined(GCFG_NO_MSSPELL)
#define GCFG_NO_MSSPELL
#endif
#if !defined(GCFG_NO_MSSPELL) && !defined(GCFG_NO_MYSPELL)
#define GCFG_SPELL_INCLUDED
#endif
/* ------------------------------------------------------------------ */
#if defined(_MSC_VER)
#define popen(f,m) _popen(f,m)
#define pclose(fh) _pclose(fh)
#endif
/* ------------------------------------------------------------------
// Spellchecker using dynamic library load */
#if !defined(GCFG_NOSPELLDLL) && !defined(__WIN32__)
#undef GCFG_NOSPELLDLL
#endif
/* ------------------------------------------------------------------
// Special character constants */

346
goldlib/gall/gespell.cpp
View File

@ -24,8 +24,6 @@
// SpellChecker functions.
// ------------------------------------------------------------------
#if !defined(GCFG_NOSPELLDLL)
#if defined(_MSC_VER)
/* C4786: 'identifier' : identifier was truncated to 'number'
characters in the debug information
@ -35,13 +33,38 @@
#include <vector>
#include <gdirposx.h>
#include <gstrall.h>
#include <myspell.hxx>
#include <gespell.h>
typedef char XlatName[17];
typedef byte ChsTab[4];
struct Chs
{
long id;
int version;
int level;
XlatName imp; // From Charset
XlatName exp; // To Charset
ChsTab t[256]; // The Translation Table
};
int LoadCharset(const char* imp, const char* exp, int query = 0);
char* XlatStr(char* dest, const char* src, int level, Chs* chrtbl, int qpencoded=false, bool i51=false);
extern Chs* CharTable;
// ------------------------------------------------------------------
#if defined(__WIN32__)
#if defined(GCFG_SPELL_INCLUDED)
// ------------------------------------------------------------------
#if !defined(GCFG_NO_MSSPELL)
// ------------------------------------------------------------------
@ -50,7 +73,6 @@
#define CHECK_NULL(ptr, jump) if (ptr == NULL) goto jump
#define CHECK_SEC(jump) if ((sec & 0xFF) != SC_SEC_NoErrors) goto jump
// ------------------------------------------------------------------
const char SC_RKEY_Prooftools[] = "Software\\Microsoft\\Shared Tools\\Proofing Tools";
@ -163,7 +185,7 @@ const dword SC_SO_RussianIO = 0x20000000;
// ------------------------------------------------------------------
bool CSpellLang::Init(HKEY hKey, const char *name)
bool CMSSpellLang::Init(HKEY hKey, const char *name)
{
bool result = false;
int error;
@ -175,8 +197,13 @@ bool CSpellLang::Init(HKEY hKey, const char *name)
unsigned long dsize = sizeof(dictionary);
mLIDC = atoi(name);
strcpy(mLangCode, name);
error = RegOpenKeyEx(hKey, name, 0, KEY_READ, &hKeyLang);
char name2[1024];
strcpy(name2, name);
strcat(name2, "\\Normal");
error = RegOpenKeyEx(hKey, name2, 0, KEY_READ, &hKeyLang);
CHECK_ERROR(cleanup0);
error = RegQueryValueEx(hKeyLang, "Engine", NULL, NULL, engine, &esize);
@ -198,7 +225,7 @@ cleanup0:
// ------------------------------------------------------------------
bool CSpellLang::Load(const char *userdic)
bool CMSSpellLang::Load(const char *codeset, const char *userdic)
{
bool result = false;
@ -267,18 +294,27 @@ cleanup1:
FreeLibrary(mLibrary);
mLibrary = NULL;
cleanup0:
if (result)
{
BuildRTable(codeset);
mIsMdrLoaded = (mSIB.cMdr != 0);
mIsUdrLoaded = (mSIB.cUdr != 0);
}
return result;
}
// ------------------------------------------------------------------
void CSpellLang::UnLoad()
void CMSSpellLang::UnLoad()
{
if (!mLibrary) return;
if (mSIB.cUdr) mSpellCloseUdr(mSLID, mUDR, TRUE);
if (mSIB.cMdr) mSpellCloseMdr(mSLID, &mMDRS);
if (mToDicTable) delete mToDicTable;
if (mToLocTable) delete mToLocTable;
mToDicTable = mToLocTable = NULL;
FreeLibrary(mLibrary);
mLibrary = NULL;
@ -287,9 +323,74 @@ void CSpellLang::UnLoad()
// ------------------------------------------------------------------
bool CSpellLang::SpellCheck(const char *text)
void CMSSpellLang::BuildRTable(const char *codeset)
{
if (!IsLoaded()) return true;
char codeset2[20];
sprintf(codeset2, "CP%i", GetACP());
LoadCharset(codeset, codeset2);
mToDicTable = new Chs;
memset(mToDicTable, 0, sizeof(Chs));
*mToDicTable = CharTable ? *CharTable : *mToDicTable;
LoadCharset(codeset2, codeset);
mToLocTable = new Chs;
memset(mToLocTable, 0, sizeof(Chs));
*mToLocTable = CharTable ? *CharTable : *mToLocTable;
}
// ------------------------------------------------------------------
void CMSSpellLang::RecodeText(const char *srcText, char *dstText, bool flag)
{
if (flag)
XlatStr(dstText, srcText, mToDicTable->level, mToDicTable);
else
XlatStr(dstText, srcText, mToLocTable->level, mToLocTable);
}
// ------------------------------------------------------------------
void CMSSpellLang::BuildSuggest(const char *text, CSpellSuggestV &suggest)
{
if (!SpellSuggest(text, false)) return;
bool flag = true;
bool more = false;
for (int idx = 0; idx < mSRB.cChrMac; idx++)
{
if (mSZ[idx] == 0) { idx++; flag = true; }
if (flag && mSZ[idx])
{
flag = false;
RecodeText(&mSZ[idx], &mSZ[idx], false);
suggest.push_back(std::pair<byte, std::string>(0, " " + std::string(&mSZ[idx]) + char(' ')));
}
else if (!more && !mSZ[idx])
{
more = true;
if (!SpellSuggest(text, more = true))
return;
else
{
flag = true;
idx = -1;
}
}
}
}
// ------------------------------------------------------------------
bool CMSSpellLang::SpellCheck(const char *text)
{
if (!IsMdrLoaded()) return true;
mSIB.wSpellState = 0;
mSIB.lrgChr = (char*)text;
@ -309,9 +410,9 @@ bool CSpellLang::SpellCheck(const char *text)
// ------------------------------------------------------------------
bool CSpellLang::SpellSuggest(const char *text, bool more)
bool CMSSpellLang::SpellSuggest(const char *text, bool more)
{
if (!IsLoaded()) return false;
if (!IsMdrLoaded()) return false;
mSIB.wSpellState = 0;
mSIB.lrgChr = (char*)text;
@ -331,14 +432,146 @@ bool CSpellLang::SpellSuggest(const char *text, bool more)
// ------------------------------------------------------------------
bool CSpellLang::AddWord(const char *text)
bool CMSSpellLang::AddWord(const char *text)
{
if (!IsLoaded()) return false;
if (!IsMdrLoaded()) return false;
SEC error = mSpellAddUdr(mSLID, mUDR, (char*)text);
return (error & 0xFF) == 0;
}
// ------------------------------------------------------------------
#endif //#if !defined(GCFG_NO_MSSPELL)
// ------------------------------------------------------------------
#if !defined(GCFG_NO_MYSPELL)
// ------------------------------------------------------------------
bool CMYSpellLang::Init(const gdirentry *entry)
{
gposixdir dir(entry->dirname);
std::string affname = entry->name.substr(0, entry->name.length()-4);
strcpy(mLangCode, affname.c_str());
const gdirentry *entry2 = dir.nextentry((affname+".aff").c_str(), true);
if (entry2)
{
strcpy(mEngine, entry2->dirname);
strcat(mEngine, "/");
strcat(mEngine, entry2->name.c_str());
strcpy(mDictionary, entry->dirname);
strcat(mDictionary, "/");
strcat(mDictionary, entry->name.c_str());
return true;
}
return false;
}
// ------------------------------------------------------------------
bool CMYSpellLang::Load(const char *codeset, const char *)
{
mMSpell = new MySpell(mEngine, mDictionary);
if (mMSpell)
{
BuildRTable(codeset);
return (mIsMdrLoaded = true);
}
return false;
}
// ------------------------------------------------------------------
void CMYSpellLang::UnLoad()
{
if (!mMSpell) return;
delete mMSpell;
mMSpell = NULL;
if (mToDicTable) delete mToDicTable;
if (mToLocTable) delete mToLocTable;
mToDicTable = mToLocTable = NULL;
}
// ------------------------------------------------------------------
void CMYSpellLang::BuildRTable(const char *codeset)
{
LoadCharset(codeset, mMSpell->get_dic_encoding());
mToDicTable = new Chs;
memset(mToDicTable, 0, sizeof(Chs));
*mToDicTable = CharTable ? *CharTable : *mToDicTable;
LoadCharset(mMSpell->get_dic_encoding(), codeset);
mToLocTable = new Chs;
memset(mToLocTable, 0, sizeof(Chs));
*mToLocTable = CharTable ? *CharTable : *mToLocTable;
}
// ------------------------------------------------------------------
void CMYSpellLang::RecodeText(const char *srcText, char *dstText, bool flag)
{
if (flag)
XlatStr(dstText, srcText, mToDicTable->level, mToDicTable);
else
XlatStr(dstText, srcText, mToLocTable->level, mToLocTable);
}
// ------------------------------------------------------------------
void CMYSpellLang::BuildSuggest(const char *text, CSpellSuggestV &suggest)
{
char ** wlst = NULL;
int ns = mMSpell->suggest(&wlst, text);
for (int i=0; i < ns; i++)
{
char buff[1024];
RecodeText(wlst[i], buff, false);
suggest.push_back(std::pair<byte, std::string>(0, " " + std::string(buff) + char(' ')));
free(wlst[i]);
}
free(wlst);
}
// ------------------------------------------------------------------
bool CMYSpellLang::SpellCheck(const char *text)
{
if (!IsMdrLoaded()) return true;
if (mMSpell->spell(text))
return true;
return false;
}
// ------------------------------------------------------------------
bool CMYSpellLang::SpellSuggest(const char *text, bool more)
{
return false;
}
// ------------------------------------------------------------------
CSpellChecker::CSpellChecker()
@ -348,10 +581,18 @@ CSpellChecker::CSpellChecker()
mText[0] = 0;
}
// ------------------------------------------------------------------
bool CSpellChecker::Init()
#endif //#if !defined(GCFG_NO_MYSPELL)
// ------------------------------------------------------------------
bool CSpellChecker::Init(const char *codeset, const char *dicPath)
{
#if !defined(GCFG_NO_MSSPELL)
int error;
unsigned long index = 0;
@ -372,8 +613,12 @@ bool CSpellChecker::Init()
error = RegEnumKeyEx(hKeySpelling, index, name, &nsize, NULL, NULL, NULL, NULL);
if (error == ERROR_SUCCESS)
{
strcat(name, "\\Normal");
AddLanguage(hKeySpelling, name);
CMSSpellLang *lang = new CMSSpellLang;
if (lang->Init(hKeySpelling, name))
mLangs.push_back(lang);
else
delete lang;
index++;
}
}
@ -383,6 +628,27 @@ bool CSpellChecker::Init()
cleanup1:
RegCloseKey(hKeyPTools);
cleanup0:
#endif //#if !defined(GCFG_NO_MSSPELL)
#if !defined(GCFG_NO_MYSPELL)
gposixdir d(dicPath);
const gdirentry *de;
while ((de = d.nextentry("*.dic", true)) != NULL)
{
CMYSpellLang *lang = new CMYSpellLang;
if (lang->Init(de))
mLangs.push_back(lang);
else
delete lang;
}
#endif //#if !defined(GCFG_NO_MSSPELL)
strcpy(mXlatLocalset, codeset);
return mInited = (mLangs.size() > 0);
}
@ -400,18 +666,19 @@ void CSpellChecker::Close()
// ------------------------------------------------------------------
bool CSpellChecker::Load(LIDC lidc, const char *userdic)
bool CSpellChecker::Load(const char *langId, const char *userDic)
{
if (!IsInited()) return false;
if (IsLoaded() && (mLang->GetLangCode() == lidc)) return true;
if (IsLoaded() && streql(mLang->GetLangCode(), langId)) return true;
CSpellLangV::iterator it;
for (it = mLangs.begin(); it != mLangs.end(); it++)
{
if ((it->GetLangCode() == lidc) && it->Load(userdic))
if (streql((*it)->GetLangCode(), langId) && (*it)->Load(mXlatLocalset, userDic))
{
UnLoad();
mLang = it;
mLang = *it;
break;
}
}
@ -436,7 +703,7 @@ bool CSpellChecker::Check(const char *text)
{
if (!IsLoaded()) return true;
OemToChar(text, mText);
mLang->RecodeText(text, mText, true);
return mLang->SpellCheck(mText);
}
@ -447,34 +714,8 @@ CSpellSuggestV &CSpellChecker::Suggest()
{
mSuggest.clear();
if (!IsLoaded()) return mSuggest;
if (!mLang->SpellSuggest(mText, false)) return mSuggest;
bool flag = true;
bool more = false;
for (int idx = 0; idx < mLang->mSRB.cChrMac; idx++)
{
if (mLang->mSZ[idx] == 0) { idx++; flag = true; }
if (flag && mLang->mSZ[idx])
{
flag = false;
CharToOem(&mLang->mSZ[idx], &mLang->mSZ[idx]);
mSuggest.push_back(std::pair<byte, std::string>(0, " " + std::string(&mLang->mSZ[idx]) + char(' ')));
}
else if (!more && !mLang->mSZ[idx])
{
more = true;
if (!mLang->SpellSuggest(mText, more = true))
return mSuggest;
else
{
flag = true;
idx = -1;
}
}
}
mLang->BuildSuggest(mText, mSuggest);
return mSuggest;
}
@ -489,11 +730,6 @@ CSpellSuggestV &CSpellChecker::Suggest()
// ------------------------------------------------------------------
#endif // #if defined(__WIN32__)
// ------------------------------------------------------------------
#endif // #if !defined(GCFG_NOSPELLDLL)
#endif //#if defined(GCFG_SPELL_INCLUDED)
// ------------------------------------------------------------------

153
goldlib/gall/gespell.h
View File

@ -30,16 +30,66 @@
// ------------------------------------------------------------------
#if !defined(GCFG_NOSPELLDLL)
#if defined(GCFG_SPELL_INCLUDED)
// ------------------------------------------------------------------
#if defined(__WIN32__)
#if defined (__WIN32__)
#include <windows.h>
#endif
// ------------------------------------------------------------------
typedef std::vector< std::pair<byte, std::string> > CSpellSuggestV;
struct Chs;
class CSpellLang
{
friend class CSpellChecker;
protected:
bool mIsMdrLoaded;
bool mIsUdrLoaded;
char mLangCode[100];
char mEngine[_MAX_PATH];
char mDictionary[_MAX_PATH];
Chs *mToDicTable;
Chs *mToLocTable;
public:
CSpellLang()
{
mIsMdrLoaded = mIsUdrLoaded = false;
mToDicTable = mToLocTable = NULL;
}
virtual ~CSpellLang() {}
void Close() { UnLoad(); }
virtual bool Load(const char *codeset, const char *userdic) = 0;
virtual void UnLoad() = 0;
virtual void BuildRTable(const char *codeset) = 0;
virtual void RecodeText(const char *srcText, char *dstText, bool flag) = 0;
virtual void BuildSuggest(const char *text, CSpellSuggestV &suggest) = 0;
virtual bool SpellCheck(const char *text) = 0;
virtual bool SpellSuggest(const char *text, bool more) = 0;
virtual bool AddWord(const char *text) = 0;
bool IsMdrLoaded() { return mIsMdrLoaded; }
bool IsUdrLoaded() { return mIsUdrLoaded; }
const char *GetLangCode() { return mLangCode; }
};
// ------------------------------------------------------------------
#if !defined(GCFG_NO_MSSPELL)
typedef uint32_t MDR; // Main Dictionary Reference
typedef uint32_t UDR; // User Dictionary Reference
typedef uint16_t SEC; // Spell Error Code
@ -113,7 +163,10 @@ typedef SEC (*SpellGetSizeUdr_fn ) (SLID, UDR, word*);
typedef SEC (*SpellGetListUdr_fn ) (SLID, UDR, word, SRB*);
typedef SEC (*SpellVerifyMdr_fn ) (char*, LIDC, LIDC*);
class CSpellLang
// ------------------------------------------------------------------
class CMSSpellLang: public CSpellLang
{
friend class CSpellChecker;
@ -128,9 +181,6 @@ private:
char mSZ[1024];
byte mRate[1024];
char mEngine[_MAX_PATH];
char mDictionary[_MAX_PATH];
HINSTANCE mLibrary;
SpellVer_fn mSpellVer;
@ -151,56 +201,86 @@ private:
SpellVerifyMdr_fn mSpellVerifyMdr;
public:
CSpellLang() { mLibrary = NULL; }
~CSpellLang() { Close(); }
CMSSpellLang() { mLibrary = NULL; }
~CMSSpellLang() { Close(); }
bool Init(HKEY hKey, const char *name);
void Close() { UnLoad(); }
bool Load(const char *userdic);
void UnLoad();
virtual bool Load(const char *codeset, const char *userdic);
virtual void UnLoad();
bool SpellCheck(const char *text);
bool SpellSuggest(const char *text, bool more);
bool AddWord(const char *text);
virtual void BuildRTable(const char *codeset);
virtual void RecodeText(const char *srcText, char *dstText, bool flag);
LIDC GetLangCode() { return mLIDC; }
virtual void BuildSuggest(const char *text, CSpellSuggestV &suggest);
bool IsLoaded() { return mLibrary != NULL; }
bool IsUdrOpened() { return mSIB.cUdr != 0; }
virtual bool SpellCheck(const char *text);
virtual bool SpellSuggest(const char *text, bool more);
virtual bool AddWord(const char *text);
};
#endif //#if !defined(GCFG_NO_MSSPELL)
typedef std::vector< std::pair<byte, std::string> > CSpellSuggestV;
typedef std::vector<CSpellLang> CSpellLangV;
#if !defined(GCFG_NO_MYSPELL)
class gdirentry;
class MySpell;
class CMYSpellLang: public CSpellLang
{
friend class CSpellChecker;
private:
MySpell *mMSpell;
public:
CMYSpellLang() { mMSpell = NULL; }
~CMYSpellLang() { Close(); }
bool Init(const gdirentry *entry);
virtual bool Load(const char *codeset, const char *);
virtual void UnLoad();
virtual void BuildRTable(const char *codeset);
virtual void RecodeText(const char *srcText, char *dstText, bool flag);
virtual void BuildSuggest(const char *text, CSpellSuggestV &suggest);
virtual bool SpellCheck(const char *text);
virtual bool SpellSuggest(const char *text, bool more);
virtual bool AddWord(const char *) { return false; }
};
#endif //#if !defined(GCFG_NO_MYSPELL)
typedef std::vector<CSpellLang*> CSpellLangV;
class CSpellChecker
{
private:
int mDicType;
bool mInited;
char mText[1024];
char mXlatLocalset[256];
CSpellLang *mLang;
CSpellLangV mLangs;
CSpellSuggestV mSuggest;
private:
void AddLanguage(HKEY hKey, const char *name)
{
CSpellLang lang;
if (lang.Init(hKey, name))
mLangs.push_back(lang);
}
void MSAddLanguage(HKEY hKey, const char *name);
public:
CSpellChecker();
~CSpellChecker() { Close(); }
bool Init();
bool Init(const char *codeset, const char *dicPath);
void Close();
bool Load(LIDC lidc, const char *userdic = NULL);
bool Load(const char *langId, const char *userDic);
void UnLoad();
bool Check(const char *text);
@ -212,8 +292,8 @@ public:
CSpellSuggestV &GetSuggest() { return mSuggest; }
CSpellLangV &GetLangs() { return mLangs; }
LIDC GetLangCode() { return IsLoaded() ? mLang->GetLangCode() : 0xFFFF; }
bool IsUdrOpened() { return IsLoaded() ? mLang->IsUdrOpened() : false; }
const char *GetLangCode() { return IsLoaded() ? mLang->GetLangCode() : "?*N/A*?"; }
bool IsUdrLoaded() { return IsLoaded() ? mLang->IsUdrLoaded() : false; }
bool IsInited() { return mInited; }
bool IsLoaded() { return mLang != NULL; }
@ -222,12 +302,7 @@ public:
// ------------------------------------------------------------------
#endif //#if defined(__WIN32__)
// ------------------------------------------------------------------
#endif //#if !defined(GCFG_NOSPELLDLL)
#endif //#if defined(GCFG_SPELL_INCLUDED)
// ------------------------------------------------------------------