//---------------------------------------
// getEntry
//---------------------------------------
public QueryDictResult getEntry(string inText)
{
QueryDictResult result = new QueryDictResult("");
try
{
using (var streamdb = Eviroment.getR_W_fromResource(localBaseFileName))
using (var db = new LiteDatabase(streamdb))
{
var dictionary = db.GetCollection <DictEntry>("Dictionary");
var dictSqlReg = new DictEntry();
dictionary.EnsureIndex(x => x.EntryData.sourceText);
var entries = dictionary.Find(x => x.EntryData.sourceText == inText);
if (entries.OfType <DictEntry>().Count() > 0)
{
result = entries.First().EntryData;
}
}
}
catch (Exception ex)
{
log.Debug(ex.StackTrace);
log.Debug("Setting result to empty object");
result = new QueryDictResult(inText);
}
return(result);
}
static void display(IEngToSpaDictSrv dictSrv, IMainView view, QueryDictResult result)
{
try
{
// status banner
view.displayText(Constants.BANNER_SEPARATOR + Constants.BRLINE);
if (!result.IsEmpty)
{
view.displayText(LocationLangSrv.getTagValue(Constants.TAG_DICT_TEXT_FOUND) + Constants.BRLINE);
view.addEntryToSuggestList(result.sourceText);
}
else
{
view.displayText(string.Format(LocationLangSrv.getTagValue(Constants.TAG_DICT_TEXT_NOT_FOUND), result.sourceText) + Constants.BRLINE);
}
//result
view.displayText(Constants.BANNER_SEPARATOR + Constants.BRLINE);
view.displayText(QueryDictResultFormater.toSimpleText(result));
// banner dict. resume
view.displayText(Constants.BANNER_SEPARATOR + Constants.BRLINE);
var totalEntriesText = string.Format(LocationLangSrv.getTagValue(Constants.TAG_DICT_RESUME_DATA), dictSrv.totalEntries());
view.displayText(totalEntriesText + Constants.BRLINE);
view.displayText(Constants.BANNER_SEPARATOR + Constants.BRLINE);
view.displayScrollUpFirstLine();
}
catch (Exception ex)
{
log.Debug(ex.StackTrace);
}
}
static void displayDictResult(QueryDictResult inResult)
{
display(dictSrv, view, inResult);
view.clearUserInput();
inputUser.ClearFocus();
view.setFocusOnResult();
}
public QueryDictResult getTranslation(string inText)
{
QueryDictResult result = new QueryDictResult(inText);
// search in local dictionary
try
{
QueryDictResult localDictResult = dictDAO.getEntry(inText.ToUpper());
if (!localDictResult.IsEmpty)
{
localDictResult.sourceText = localDictResult.sourceText.ToLower();
Macros.userMsg(Constants.LOCAL_DICT_WORD_FOUND);
return(localDictResult);
}
else
{
Macros.userMsg(Constants.LOCAL_DICT_WORD_NOT_FOUND);
}
}
catch (Exception ex)
{
log.Debug(ex.StackTrace);
log.Debug("Setting result to empty object");
Macros.userMsg(Constants.LOCAL_DICT_WORD_FAIL, ex.Message);
result = new QueryDictResult(inText);
}
// search in web dictionary
try
{
Macros.userMsg(Constants.WEB_DICT_SEARCH);
var webDict = new WebDictEngToSpa();
var webResult = new QueryDictResult(inText);
webDict.searchText(inText, webResult);
if (!webResult.IsEmpty)
{
QueryDictResult resultToSave = webResult.getClone();
// normalize text
resultToSave.sourceText = resultToSave.sourceText.ToUpper();
dictDAO.saveEntry(resultToSave);
result = webResult;
return(result);
}
}
catch (Exception ex)
{
log.Debug(ex.StackTrace);
log.Debug("Setting result to empty object");
Macros.userMsg(Constants.WEB_DICT_FAIL, ex.Message);
result = new QueryDictResult(inText);
result.sourceText = inText;
}
result.sourceText = inText;
return(result);
}
public void saveEntry(QueryDictResult inDictData)
{
try
{
using (var streamdb = Eviroment.getR_W_fromResource(localBaseFileName))
using (var db = new LiteDatabase(streamdb))
{
var dictionary = db.GetCollection <DictEntry>("Dictionary");
if (!inDictData.IsEmpty && !dictionary.Exists(x => x.EntryData.sourceText == inDictData.sourceText))
{
var dictSqlReg = new DictEntry();
dictSqlReg.EntryData = inDictData;
dictionary.EnsureIndex(x => x.EntryData.sourceText);
dictionary.Insert(dictSqlReg);
}
}
}
catch (Exception ex)
{
log.Debug(ex.StackTrace);
}
}
//---------------------------------------------------------------------------
// searchText
//---------------------------------------------------------------------------
public void searchText(string inText, QueryDictResult inResult)
{
if (!this.loadConfigFlag)
{
inResult.resetAttrs();
return;
}
// search pronunciation
try
{
var textNormalice = inText.Replace(" ", "+");
Macros.userMsg(LocationLangSrv.getTagValue(Constants.SEARCHING_PR));
MatchSiteResult result = searchFirstOcurrence(textNormalice, dicConf.Pronunciation.Sites);
if (result.IsMatch)
{
var pattern = (PrPattern)result.Pattern;
var idxPr = pattern.IdxPrGroup;
var prData = idxPr > -1 ? result.Matches[0].Groups[idxPr + 1].Value : "";
if (pattern.CleanResult)
{
inResult.pronunciation = Regex.Replace(prData, pattern.CleanPattern, "", RegexOptions.IgnoreCase);
}
}
}
catch (Exception ex)
{
log.Debug(ex.StackTrace);
log.Debug("Setting pronunciation to empty string value");
inResult.pronunciation = "";
}
// search translations
try
{
Macros.userMsg(LocationLangSrv.getTagValue(Constants.SEARCHING_TR));
MatchSiteResult result = this.searchFirstOcurrence(inText, this.dicConf.Translation.Sites);
if (result.IsMatch)
{
if (result.TextFound != inText)
{
return;
}
inResult.IsEmpty = false;
var pattern = (TrPattern)result.Pattern;
foreach (Match match in result.Matches)
{
var idxTr = pattern.IdxTrGroup;
var idxTrType = pattern.IdxTrTypeGroup;
DictTrEntry trEntry = new DictTrEntry();
trEntry.translation = idxTr > -1 ? match.Groups[idxTr].Value : "";
trEntry.type = idxTrType > -1 ? match.Groups[idxTrType].Value : "";
if (pattern.CleanTypeResult)
{
trEntry.type = Regex.Replace(trEntry.type, pattern.CleanTypePattern, "", RegexOptions.IgnoreCase);
}
inResult.translations.Add(trEntry);
}
//inResult.translations = inResult.translations.GroupBy(x => x.translation).Select(g => g.First()).ToList();
}
}
catch (Exception ex)
{
log.Debug(ex.StackTrace);
log.Debug("Removing last translation entry");
if (inResult.translations.Count > 0)
{
inResult.translations.RemoveAt(inResult.translations.Count - 1);
}
}
}
static void searchDictHandler(string inText)
{
var viewLocal = view;
lock (searchLock)
{
if (MainActivity.isSearching)
{
return;
}
}
try
{
lock (searchLock)
{
MainActivity.isSearching = true;
}
view.hideKeyboard();
view.clearStatusArea();
view.clearDisplay();
view.displayStatus(LocationLangSrv.getTagValue(Constants.SEARCHING_DICT_TEXT) + "[" + inText + "]" + Constants.BRLINE);
QueryDictResult result = null;
var searchThread = new Thread(new ThreadStart(() =>
{
// start time out thread
var timerThread = new Thread(new ThreadStart(() =>
{
Thread.Sleep(15000);
if (result == null)
{
viewLocal.displayText(LocationLangSrv.getTagValue(Constants.TIME_OUT_ERROR) + Constants.BRLINE);
lock (searchLock)
{
MainActivity.isSearching = false;
}
}
}));
timerThread.Start();
viewLocal.displayText(LocationLangSrv.getTagValue(Constants.SEARCHING_INFO) + "[" + inText + "]" + Constants.BRLINE);
result = dictSrv.getTranslation(inText);
mainActivity.RunOnUiThread(() =>
{
viewLocal.clearDisplay();
});
mainActivity.RunOnUiThread(() => displayDictResult(result));
lock (searchLock)
{
MainActivity.isSearching = false;;
}
}));
searchThread.Start();
}
catch (Exception ex)
{
viewLocal.displayText(LocationLangSrv.getTagValue(Constants.RUNTIME_ERROR_TAG) + Constants.BRLINE);
log.Debug(ex.StackTrace);
lock (searchLock)
{
MainActivity.isSearching = false;
}
}
}
