private void CreateTryAWordSandbox()
{
// skip if it's before we've set the word
if (m_sWordForm == null)
{
return;
}
// skip if it's before we've set up the rootsite control
if (m_rootb == null)
{
return;
}
// skip if we're not visible
if (!Visible)
{
return;
}
//Debug.WriteLine("TryAWordRootSite:WordForm - creating sandbox for " + m_sWordForm.Text);
NonUndoableUnitOfWorkHelper.Do(m_fdoCache.ActionHandlerAccessor, () =>
{
m_wordform = WfiWordformServices.FindOrCreateWordform(m_fdoCache, m_sWordForm);
});
//if (m_fdoCache.IsDummyObject(hvo))
// m_wordform = new WfiWordform();
IAnalysis analysis = m_vc.GetGuessForWordform(m_wordform, m_fdoCache.DefaultVernWs);
if (analysis is NullWAG)
{
analysis = m_wordform;
}
m_rootb.SetRootObject(analysis.Hvo, m_vc, m_kfragSingleInterlinearAnalysisWithLabels, m_styleSheet);
//Debug.Assert(m_tryAWordSandbox == null);
m_tryAWordSandbox = new TryAWordSandbox(m_fdoCache,
Mediator,
StyleSheet,
m_vc.LineChoices,
analysis);
m_tryAWordSandbox.Visible = false;
Controls.Add(m_tryAWordSandbox);
SetSandboxSize();
SetSandboxLocation();
m_tryAWordSandbox.Visible = true;
SetBackgroundColor();
int height = Math.Max(ScrollRange.Height, m_tryAWordSandbox.Height) + SystemInformation.HorizontalScrollBarHeight;
if (Height != height)
{
Height = height;
}
m_tryAWordSandbox.SizeChanged += m_tryAWordSandbox_SizeChanged;
//m_tryAWordSandbox.Focus();
}
/// <summary>
/// Handles the xWorks message to insert a new FsFeatDefn.
/// Invoked by the RecordClerk via a main menu.
/// </summary>
/// <param name="argument">The xCore Command object.</param>
/// <returns>true, if we handled the message, otherwise false, if there was an unsupported 'classname' parameter</returns>
public override bool OnDialogInsertItemInVector(object argument)
{
CheckDisposed();
Debug.Assert(argument != null && argument is XCore.Command);
string className = XmlUtils.GetOptionalAttributeValue(
(argument as XCore.Command).Parameters[0], "className");
if ((className == null) || (className != "FsClosedFeature"))
{
return(false);
}
if (className == "FsClosedFeature" && (argument as XCore.Command).Id != "CmdInsertPhonologicalClosedFeature")
{
return(false);
}
using (MasterPhonologicalFeatureListDlg dlg = new MasterPhonologicalFeatureListDlg(className))
{
LcmCache cache = m_propertyTable.GetValue <LcmCache>("cache");
Debug.Assert(cache != null);
string sXmlFile = Path.Combine(FwDirectoryFinder.CodeDirectory, String.Format("Language Explorer{0}MGA{0}GlossLists{0}PhonFeatsEticGlossList.xml", Path.DirectorySeparatorChar));
if (cache.LanguageProject.PhFeatureSystemOA == null)
{
// Mainly for Memory-only backend, makes system more self-repairing.
NonUndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(cache.ActionHandlerAccessor,
() =>
{
cache.LanguageProject.PhFeatureSystemOA =
cache.ServiceLocator.GetInstance <IFsFeatureSystemFactory>().Create();
});
}
dlg.SetDlginfo(cache.LangProject.PhFeatureSystemOA, m_mediator, m_propertyTable, true, "masterPhonFeatListDlg", sXmlFile);
switch (dlg.ShowDialog(m_propertyTable.GetValue <Form>("window")))
{
case DialogResult.OK: // Fall through.
case DialogResult.Yes:
//m_mediator.SendMessage("JumpToRecord", dlg.SelectedFeatDefn.Hvo);
// This is the equivalent functionality, but is deferred processing.
// This is done so that the JumpToRecord can be processed last.
if (dlg.SelectedFeatDefn != null)
{
m_mediator.BroadcastMessageUntilHandled("JumpToRecord", dlg.SelectedFeatDefn.Hvo);
}
// LT-6412: this call will now cause the Mediator to be disposed while it is busy processing
// this call, so there is code in the Mediator to handle in the middle of a msg the case
// where the object is nolonger valid. This has happend before and was being handled, this
// call "SendMessageToAllNow" has not had the code to handle the exception, so it was added.
m_mediator.SendMessageToAllNow("MasterRefresh", cache.LangProject.PhFeatureSystemOA);
break;
}
}
return(true); // We "handled" the message, regardless of what happened.
}
private void CommonAddWS(bool isAnalysis, MenuItem selectedMI)
{
CoreWritingSystemDefinition ws = null;
if (selectedMI.Text == LexTextControls.ks_DefineNew_)
{
if (FwWritingSystemSetupDlg.ShowNewDialog(FindForm(), m_cache, m_helpTopicProvider, m_app,
isAnalysis ? FwWritingSystemSetupModel.ListType.Analysis : FwWritingSystemSetupModel.ListType.Vernacular,
out var newWritingSystems))
{
ws = newWritingSystems.FirstOrDefault();
}
}
else
{
ws = selectedMI.Tag as CoreWritingSystemDefinition;
}
if (ws != null)
{
m_wsNew = ws;
// now add the ws to the FDO list for it
NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () =>
{
// Add a global writing system to the local writing system store. (Replace
// does this if there's nothing to replace.)
if (m_wsNew.Handle == 0)
{
m_cache.ServiceLocator.WritingSystemManager.Replace(m_wsNew);
}
if (isAnalysis)
{
m_cache.ServiceLocator.WritingSystems.AnalysisWritingSystems.Add(m_wsNew);
if (!m_cache.ServiceLocator.WritingSystems.CurrentAnalysisWritingSystems.Contains(m_wsNew))
{
m_cache.ServiceLocator.WritingSystems.CurrentAnalysisWritingSystems.Add(m_wsNew);
}
}
else
{
m_cache.ServiceLocator.WritingSystems.VernacularWritingSystems.Add(m_wsNew);
if (!m_cache.ServiceLocator.WritingSystems.CurrentVernacularWritingSystems.Contains(m_wsNew))
{
m_cache.ServiceLocator.WritingSystems.CurrentVernacularWritingSystems.Add(m_wsNew);
}
}
ProgressDialogWithTask.ImportTranslatedListsForWs(this.FindForm(), m_cache, m_wsNew.IcuLocale);
});
if (WritingSystemAdded != null)
{
WritingSystemAdded(this, new EventArgs());
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Fixture setup - define Scripture Check IDs.
/// </summary>
/// ------------------------------------------------------------------------------------
public override void FixtureSetup()
{
base.FixtureSetup();
// force scripture check definitions to be created - don't want this done as
// part of the normal undoable work.
NonUndoableUnitOfWorkHelper.Do(m_actionHandler, () =>
{
InstalledScriptureChecks.GetChecks(new ScrChecksDataSource(m_scr.Cache,
ResourceHelper.GetResourceString("kstidPunctCheckWhitespaceChar"), FwDirectoryFinder.LegacyWordformingCharOverridesFile));
});
}
/// <summary>
/// If there are no pronunciation writing systems selected, make a default set, with IPA variants
/// coming before EMC variants (if either of those exist). If neither exists, the primary
/// vernacular writing system is selected.
/// </summary>
private void InitializePronunciationWritingSystems()
{
if (m_currentPronunciationWritingSystems.Count > 0)
{
return;
}
NonUndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(Cache.ActionHandlerAccessor,
() =>
{
var writingSystems = m_vernacularWritingSystems;
var wsVern = DefaultVernacularWritingSystem;
var sVern = wsVern.IcuLocale.ToLower();
var idx = sVern.IndexOf("_");
sVern = idx > 0 ? sVern.Substring(0, idx + 1) : sVern + '_';
// Add any relevant IPA writing systems: those that match the default vernacular at the start and end with _ipa
foreach (var nws in writingSystems)
{
var icuLocale = nws.IcuLocale.ToLower();
if (icuLocale.IndexOf(sVern) != 0)
{
continue;
}
idx = icuLocale.LastIndexOf("_ipa");
if (idx >= sVern.Length && idx == icuLocale.Length - 4)
{
m_currentPronunciationWritingSystems.Add(nws);
}
}
// Add any relevant EMC writing systems: match default vern at start and end with _emc.
foreach (var nws in writingSystems)
{
var icuLocale = nws.IcuLocale.ToLower();
if (icuLocale.IndexOf(sVern) != 0)
{
continue;
}
idx = icuLocale.LastIndexOf("_emc");
if (idx < sVern.Length || idx != icuLocale.Length - 4)
{
continue;
}
m_currentPronunciationWritingSystems.Add(nws);
}
// Add the primary vernacular writing system if nothing else fits.
if (m_currentPronunciationWritingSystems.Count == 0)
{
m_currentPronunciationWritingSystems.Add(wsVern);
}
});
}
/// <summary>
/// If a localized lists file is available for the specified ws, load the information.
/// Note: call this only when you are sure the WS is new to this project. It takes considerable time
/// to run if it finds a localized list file.
/// Our current strategy for loading localized lists is to have one file per localization.
/// It is always LocalizedLists-XX.zip, where XX is the ICU locale for the writing system.
/// (The zip file contains a single file, LocalizedLists-XX.xml.)
/// So if such a file exists for this WS, we can import lists for that writing system.
/// </summary>
/// <param name="ws"></param>
/// <param name="cache"></param>
/// <param name="templateDir"></param>
/// <param name="progress"> </param>
public static void ImportTranslatedListsForWs(string ws, FdoCache cache, string templateDir, IProgress progress)
{
string path = TranslatedListsPathForWs(ws, templateDir);
if (File.Exists(path))
{
var instance = new XmlTranslatedLists();
NonUndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(cache.ActionHandlerAccessor,
() => instance.ImportTranslatedLists(path, cache, progress));
}
}
private void SetParaToReparse(IStTxtPara para)
{
if (Cache.ActionHandlerAccessor.CurrentDepth > 0)
{
para.ParseIsCurrent = false;
}
else
{
NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor, () => para.ParseIsCurrent = false);
}
}
public void NullLexemeForm()
{
NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () =>
{
ILexEntry entry = m_cache.ServiceLocator.GetInstance <ILexEntryFactory>().Create(m_cache.ServiceLocator.GetInstance <IMoMorphTypeRepository>().GetObject(MoMorphTypeTags.kguidMorphStem),
m_cache.TsStrFactory.MakeString("form", m_cache.ServiceLocator.WritingSystems.VernacularWritingSystems.ElementAt(1).Handle), "gloss", new SandboxGenericMSA());
entry.LexemeFormOA = null;
});
Assert.That(m_lexicon.Lexemes.Count(), Is.EqualTo(1));
Assert.That(m_lexicon.Lexemes.Single().LexicalForm, Is.EqualTo(string.Empty));
}
private void ReparseParaInUowIfNeeded(IStTxtPara para)
{
if (Cache.ActionHandlerAccessor.CurrentDepth > 0)
{
ReparseParagraph(para);
}
else
{
NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor, () => ReparseParagraph(para));
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// ------------------------------------------------------------------------------------
private void btnOk_Click(object sender, EventArgs e)
{
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(
m_cache.ServiceLocator.GetInstance<IActionHandler>()))
{
m_filter.ColumnInfo = string.Empty;
m_filter.RowsOS[0].CellsOS.Clear();
tvCategories.UpdateFilter(m_filter);
undoHelper.RollBack = false;
}
}
public void CreateOrRemoveReversalIndexConfigurationFiles_DeletethNotValidConfigs()
{
const string nonExtantWs = "es";
var analWss = new[] { "en", "fr", "de" };
NonUndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(Cache.ActionHandlerAccessor,
() => Cache.LangProject.AnalysisWss = string.Join(" ", analWss));
using (var tfProject = new TemporaryFolder("ProjForDontDeleteRealReversals"))
{
var projectsDir = Path.GetDirectoryName(tfProject.Path);
var projectName = Path.GetFileName(tfProject.Path);
var riConfigDir = Path.Combine(tfProject.Path, RIS.ConfigDir, RIS.RevIndexDir);
FileUtils.EnsureDirectoryExists(riConfigDir);
var crazyFilename = Path.Combine(riConfigDir, "FilenameHasNoWS" + RIS.ConfigFileExtension);
CreateDummyConfigForWS(crazyFilename, analWss[0]);
var nonExtantWsFilename = GetFilenameForWs(riConfigDir, nonExtantWs);
CreateDummyConfigForWS(nonExtantWsFilename, nonExtantWs);
var wrongWsFilename = GetFilenameForWs(riConfigDir, analWss[1]);
CreateDummyConfigForWS(wrongWsFilename, analWss[2]);
var allReversalsFilename = Path.Combine(riConfigDir, RIS.AllIndexesFileName + RIS.ConfigFileExtension);
CreateDummyConfigForWS(allReversalsFilename, "");
// A file with the expected name that the user had modified
var normalFilename = GetFilenameForWs(riConfigDir, analWss[2]);
const string normalFileModified = "2015-03-14"; // arbitrary date in the past
CreateDummyConfigForWS(normalFilename, analWss[2]);
XAttribute normalFileModifiedAtt;
var normalFile = GetLastModifiedAttributeFromFile(normalFilename, out normalFileModifiedAtt);
normalFileModifiedAtt.Value = normalFileModified;
normalFile.Save(normalFilename);
ReversalIndexServices.CreateOrRemoveReversalIndexConfigurationFiles(WSMgr, Cache, FwDirectoryFinder.DefaultConfigurations,
projectsDir, projectName);
Assert.That(File.Exists(crazyFilename), crazyFilename + " should not have been deleted");
Assert.AreEqual(analWss[0], GetWsFromFile(crazyFilename), "WS in custom-named file should not have been changed");
Assert.That(!File.Exists(nonExtantWsFilename));
Assert.That(File.Exists(wrongWsFilename));
Assert.AreEqual(analWss[1], GetWsFromFile(wrongWsFilename), "WS in wrong ws-named file should have been changed (we think)");
Assert.That(File.Exists(allReversalsFilename));
Assert.AreEqual(string.Empty, GetWsFromFile(allReversalsFilename), "All reversals should not have a writing system");
foreach (var ws in analWss)
{
var filename = GetFilenameForWs(riConfigDir, ws);
Assert.That(File.Exists(filename), "No file for WS: " + ws);
Assert.AreEqual(ws, GetWsFromFile(filename), "Incorrect WS attribute in file");
}
XAttribute modifiedAtt;
GetLastModifiedAttributeFromFile(normalFilename, out modifiedAtt);
Assert.AreEqual(normalFileModified, modifiedAtt.Value, "File with proper name and WS should not have been modified");
}
}
public void RemoveGloss(string language)
{
NonUndoableUnitOfWorkHelper.Do(m_gloss.Cache.ActionHandlerAccessor, () =>
{
CoreWritingSystemDefinition ws;
if (!m_lexicon.Cache.ServiceLocator.WritingSystemManager.TryGet(language, out ws))
{
throw new ArgumentException("The specified language is unrecognized.", "language");
}
m_gloss.Form.set_String(ws.Handle, (ITsString)null);
});
}
protected void CreateAndInitializeNewWindow()
{
m_window = new MockFwXWindow(m_application, m_configFilePath); // (MockFwXApp)
((MockFwXWindow)m_window).Init(Cache); // initializes Mediator values
m_mediator = m_window.Mediator;
((MockFwXWindow)m_window).ClearReplacements();
// delete property table settings.
Properties.RemoveLocalAndGlobalSettings();
ProcessPendingItems();
m_window.LoadUI(m_configFilePath); // actually loads UI here.
NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor, CreateTestData);
}
/// ------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// ------------------------------------------------------------------------------------
private void btnOk_Click(object sender, EventArgs e)
{
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(
m_cache.ServiceLocator.GetInstance <IActionHandler>()))
{
m_filter.ColumnInfo = string.Empty;
m_filter.RowsOS[0].CellsOS.Clear();
tvCategories.UpdateFilter(m_filter);
undoHelper.RollBack = false;
}
}
void soundFieldControl_SoundDeleted(object sender, EventArgs e)
{
// We don't want the file name hanging aroudn once we deleted the file.
var sc = (ShortSoundFieldControl)sender;
int dummy;
var ws = WsForSoundField(sc, out dummy);
var handle = ws == null ? 0 : ws.Handle;
NonUndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(m_innerView.Cache.ActionHandlerAccessor,
() => m_innerView.Cache.DomainDataByFlid.SetMultiStringAlt(m_innerView.HvoObj, m_innerView.Flid, handle,
m_innerView.Cache.TsStrFactory.MakeString("", handle)));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Does setup for all the tests
/// </summary>
/// ------------------------------------------------------------------------------------
public override void FixtureSetup()
{
base.FixtureSetup();
Cache.ServiceLocator.WritingSystemManager.GetOrSet("de", out m_wsGerman);
Cache.ServiceLocator.WritingSystemManager.GetOrSet("fr", out m_wsFrench);
Cache.ServiceLocator.WritingSystemManager.GetOrSet("es", out m_wsSpanish);
NonUndoableUnitOfWorkHelper.Do(m_actionHandler, () =>
{
ChangeDefaultAnalWs(m_wsGerman);
Cache.LangProject.AddToCurrentAnalysisWritingSystems(m_wsSpanish);
});
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Adds a new sense to the lexeme with the specified information
/// </summary>
/// ------------------------------------------------------------------------------------
public LexSense AddSenseToEntry(LexemeType type, string lexicalForm, int homograph)
{
LexicalProviderManager.ResetLexicalProviderTimer();
Logger.WriteEvent("Adding new sense to lexeme '" + lexicalForm + "' from an external application");
return(NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () =>
{
string guid = string.Empty;
switch (type)
{
case LexemeType.Word:
{
IWfiWordform dbWordform = GetDbWordform(lexicalForm);
if (dbWordform == null)
{
throw new ArgumentException("Entry in the lexicon not found for the specified information");
}
// For wordforms, our "senses" could be new meanings of an analysis for the word
// or it could be a brand new analysis. Because we have no idea what the user actually
// wanted, we just assume the worst (they want to create a new analysis for the word
// with a new meaning).
IWfiAnalysis dbAnalysis = m_cache.ServiceLocator.GetInstance <IWfiAnalysisFactory>().Create();
dbWordform.AnalysesOC.Add(dbAnalysis);
guid = kAnalysisPrefix + dbAnalysis.Guid;
break;
}
default:
{
ILexEntry dbEntry = GetDbLexeme(type, lexicalForm, homograph);
if (dbEntry == null)
{
throw new ArgumentException("Entry in the lexicon not found for the specified information");
}
if (dbEntry.SensesOS.Count == 1 && dbEntry.SensesOS[0].Gloss.StringCount == 0)
{
// An empty sense exists (probably was created during a call to AddLexeme)
guid = dbEntry.SensesOS[0].Guid.ToString();
break;
}
ILexSense newSense = m_cache.ServiceLocator.GetInstance <ILexSenseFactory>().Create(
dbEntry, new SandboxGenericMSA(), null);
guid = newSense.Guid.ToString();
break;
}
}
return new LexSense(guid);
}));
}
public LexiconSense AddSense()
{
LexiconSense sense = null;
bool lexemeAdded = false;
using (m_lexicon.ActivationContext.Activate())
{
NonUndoableUnitOfWorkHelper.Do(m_lexicon.Cache.ActionHandlerAccessor, () =>
{
IWfiWordform wordform;
if (!m_lexicon.TryGetWordform(m_key.LexicalForm, out wordform))
{
wordform = m_lexicon.CreateWordform(m_key.LexicalForm);
lexemeAdded = true;
}
// For wordforms, our "senses" could be new meanings of an analysis for the word
// or it could be a brand new analysis. Because we have no idea what the user actually
// wanted, we just assume the worst (they want to create a new analysis for the word
// with a new meaning).
IWfiAnalysis analysis = m_lexicon.Cache.ServiceLocator.GetInstance <IWfiAnalysisFactory>().Create();
wordform.AnalysesOC.Add(analysis);
analysis.ApprovalStatusIcon = (int)Opinions.approves; // Assume the analysis from the external application is user approved
IMoStemAllomorph morph = m_lexicon.Cache.ServiceLocator.GetInstance <IMoStemAllomorphRepository>().AllInstances().FirstOrDefault(allo =>
{
ITsString tss = allo.Form.StringOrNull(m_lexicon.DefaultVernWs);
if (tss != null)
{
return(tss.Text == LexicalForm.Normalize(NormalizationForm.FormD));
}
return(false);
});
if (morph != null)
{
IWfiMorphBundle mb = m_lexicon.Cache.ServiceLocator.GetInstance <IWfiMorphBundleFactory>().Create();
analysis.MorphBundlesOS.Add(mb);
mb.MorphRA = morph;
var entry = morph.OwnerOfClass <ILexEntry>();
mb.SenseRA = entry.SensesOS[0];
mb.MsaRA = entry.SensesOS[0].MorphoSyntaxAnalysisRA;
}
IWfiGloss gloss = m_lexicon.Cache.ServiceLocator.GetInstance <IWfiGlossFactory>().Create();
analysis.MeaningsOC.Add(gloss);
sense = new WfiGlossLexiconSense(m_lexicon, m_key, gloss);
});
}
if (lexemeAdded)
{
m_lexicon.OnLexemeAdded(this);
}
m_lexicon.OnLexiconSenseAdded(this, sense);
return(sense);
}
public void SetAndAccessDummyList()
{
ILexDb lexDb = Cache.LangProject.LexDbOA;
ILexEntry entry1 = null;
ICmResource res1 = null;
NonUndoableUnitOfWorkHelper.Do(m_actionHandler, () =>
{
var leFactory = Cache.ServiceLocator.GetInstance <ILexEntryFactory>();
entry1 = leFactory.Create();
ILexEntry entry2 = leFactory.Create();
res1 = Cache.ServiceLocator.GetInstance <ICmResourceFactory>().Create();
lexDb.ResourcesOC.Add(res1);
});
int hvoRoot = 10578;
ObjectListPublisher publisher = new ObjectListPublisher(Cache.MainCacheAccessor as ISilDataAccessManaged, ObjectListFlid);
var values = new int[] { 23, 56, 2048 };
Notifiee recorder = new Notifiee();
publisher.AddNotification(recorder);
publisher.CacheVecProp(hvoRoot, values);
Assert.AreEqual(values.Length, publisher.get_VecSize(hvoRoot, ObjectListFlid), "override of vec size");
//Assert.AreEqual(Cache.LangProject.Texts.Count, publisher.get_VecSize(Cache.LangProject.Hvo, LangProjectTags.kflidTexts), "base vec size");
Assert.AreEqual(23, publisher.get_VecItem(hvoRoot, ObjectListFlid, 0), "override of vec item");
Assert.AreEqual(res1.Hvo, publisher.get_VecItem(lexDb.Hvo, LexDbTags.kflidResources, 0), "base vec item");
Assert.AreEqual(56, publisher.get_VecItem(hvoRoot, ObjectListFlid, 1), "override of vec item, non-zero index");
VerifyCurrentValue(hvoRoot, publisher, values, "original value");
Assert.AreEqual(lexDb.ResourcesOC.Count(), publisher.VecProp(lexDb.Hvo, LexDbTags.kflidResources).Length, "base VecProp");
recorder.CheckChanges(new ChangeInformationTest[] { new ChangeInformationTest(hvoRoot, ObjectListFlid, 0, values.Length, 0) },
"expected PropChanged from caching HVOs");
publisher.RemoveNotification(recorder);
recorder = new Notifiee();
publisher.AddNotification(recorder);
publisher.Replace(hvoRoot, 1, new int[] { 97, 98 }, 0);
VerifyCurrentValue(hvoRoot, publisher, new int[] { 23, 97, 98, 56, 2048 }, "after inserting 97, 98");
recorder.CheckChanges(new ChangeInformationTest[] { new ChangeInformationTest(hvoRoot, ObjectListFlid, 1, 2, 0) },
"expected PropChanged from caching HVOs");
publisher.RemoveNotification(recorder);
recorder = new Notifiee();
publisher.AddNotification(recorder);
publisher.Replace(hvoRoot, 1, new int[0], 2);
VerifyCurrentValue(hvoRoot, publisher, new int[] { 23, 56, 2048 }, "after deleting 97, 98");
recorder.CheckChanges(new ChangeInformationTest[] { new ChangeInformationTest(hvoRoot, ObjectListFlid, 1, 0, 2) },
"expected PropChanged from caching HVOs");
publisher.RemoveNotification(recorder);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// If a test overrides this, it should call this base implementation.
/// </summary>
/// ------------------------------------------------------------------------------------
public override void FixtureSetup()
{
base.FixtureSetup();
var servLoc = Cache.ServiceLocator;
NonUndoableUnitOfWorkHelper.Do(m_actionHandler, () =>
{
Cache.LanguageProject.PeopleOA = servLoc.GetInstance <ICmPossibilityListFactory>().Create();
Cache.LanguageProject.PeopleOA.PossibilitiesOS.Add(servLoc.GetInstance <ICmPersonFactory>().Create());
});
m_possListFactory = servLoc.GetInstance <ICmPossibilityListFactory>();
}
public void kcptTimeTests()
{
var servLoc = Cache.ServiceLocator;
var lp = servLoc.GetInstance <ILangProjectRepository>().AllInstances().First();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
lp.DateCreated = DateTime.Now;
undoHelper.RollBack = false;
}
CheckChanges(1, 0, lp.Hvo, CmProjectTags.kflidDateCreated, 0, 0, 0);
ClearChanges();
}
public override void TestTearDown()
{
base.TestTearDown();
var repo = Cache.ServiceLocator.GetInstance <ITextRepository>();
NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor, () =>
{
foreach (var text in repo.AllInstances())
{
text.Delete();
}
});
}
public void Process()
{
var cache = (FdoCache)Dialog.Mediator.PropertyTable.GetValue("cache");
NonUndoableUnitOfWorkHelper.DoSomehow(cache.ActionHandlerAccessor, () =>
{
var fixedGuids = ReplacePOSGuidsWithGoldEticGuids(cache);
var caption = fixedGuids ? LexEdStrings.GoldEticGuidFixer_Guids_changed_Title : LexEdStrings.GoldEticGuidFixer_NoChangeTitle;
var content = fixedGuids ? LexEdStrings.GoldEticGuidFixer_GuidsChangedContent
: LexEdStrings.GoldEticGuidFixer_NoChangeContent;
MessageBox.Show(Dialog, content, caption, MessageBoxButtons.OK, MessageBoxIcon.Information);
});
}
public static ICmPossibility AddPublicationType(string name, LcmCache cache)
{
Debug.Assert(cache.LangProject.LexDbOA.PublicationTypesOA != null);
var item = cache.ServiceLocator.GetInstance <ICmPossibilityFactory>().Create();
NonUndoableUnitOfWorkHelper.DoSomehow(cache.ActionHandlerAccessor, () =>
{
cache.LangProject.LexDbOA.PublicationTypesOA.PossibilitiesOS.Add(item);
item.Name.set_String(cache.DefaultAnalWs, name);
});
return(item);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the ChooseScriptureDialog class.
/// WARNING: this constructor is called by reflection, at least in the Interlinear
/// Text DLL. If you change its parameters be SURE to find and fix those callers also.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="objList">A list of texts and books to check as an array of hvos</param>
/// <param name="helpTopicProvider">The help topic provider.</param>
/// <param name="importer">The Paratext book importer.</param>
/// ------------------------------------------------------------------------------------
public FilterTextsDialogTE(FdoCache cache, IStText[] objList,
IHelpTopicProvider helpTopicProvider, IBookImporter importer)
: base(cache, objList, helpTopicProvider)
{
m_bookImporter = importer;
using (var progressDlg = new ProgressDialogWithTask(null, cache.ThreadHelper))
{
NonUndoableUnitOfWorkHelper.Do(cache.ActionHandlerAccessor, () =>
TeScrInitializer.EnsureMinimalScriptureInitialization(cache, progressDlg,
(IHelpTopicProvider)DynamicLoader.CreateObject(DirectoryFinder.TeDll,
"SIL.FieldWorks.TE.TeHelpTopicProvider")));
}
}
/// <summary>
/// This class creates text, it must delete it here when UNDO is commanded
/// so it can update InterestingTexts.
/// </summary>
/* public override void PropChanged(int hvo, int tag, int ivMin, int cvIns, int cvDel)
* {
* if (cvDel != 1)
* return;
* SaveOnChangeRecord();
* SuppressSaveOnChangeRecord = true;
* try
* {
* m_list.DeleteCurrentObject();
* }
* finally
* {
* SuppressSaveOnChangeRecord = false;
* }
* GetInterestingTextList().UpdateInterestingTexts();
* } */
#region IBookImporter Members
/// ------------------------------------------------------------------------------------
/// <summary>
/// Imports the specified book.
/// </summary>
/// <param name="bookNum">The canonical book number.</param>
/// <param name="owningForm">Form that can be used as the owner of progress dialogs and
/// message boxes.</param>
/// <param name="importBt">True to import only the back translation, false to import
/// only the main translation</param>
/// <returns>
/// The ScrBook created to hold the imported data
/// </returns>
/// ------------------------------------------------------------------------------------
public IScrBook Import(int bookNum, Form owningForm, bool importBt)
{
IScripture scr = Cache.LangProject.TranslatedScriptureOA;
bool haveSomethingToImport = NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor, () =>
{
IScrImportSet importSettings = scr.FindOrCreateDefaultImportSettings(TypeOfImport.Paratext6);
importSettings.StyleSheet = ScriptureStylesheet;
IScrText paratextProj = ParatextHelper.GetAssociatedProject(Cache.ProjectId);
importSettings.ParatextScrProj = paratextProj.Name;
importSettings.StartRef = new BCVRef(bookNum, 0, 0);
int chapter = paratextProj.Versification.LastChapter(bookNum);
importSettings.EndRef = new BCVRef(bookNum, chapter, paratextProj.Versification.LastVerse(bookNum, chapter));
if (!importBt)
{
importSettings.ImportTranslation = true;
importSettings.ImportBackTranslation = false;
}
else
{
List <IScrText> btProjects = ParatextHelper.GetBtsForProject(paratextProj).ToList();
if (btProjects.Count > 0 && (string.IsNullOrEmpty(importSettings.ParatextBTProj) ||
!btProjects.Any(st => st.Name == importSettings.ParatextBTProj)))
{
importSettings.ParatextBTProj = btProjects[0].Name;
}
if (string.IsNullOrEmpty(importSettings.ParatextBTProj))
{
return(false);
}
importSettings.ImportTranslation = false;
importSettings.ImportBackTranslation = true;
}
ParatextHelper.LoadProjectMappings(importSettings);
ScrMappingList importMap = importSettings.GetMappingListForDomain(ImportDomain.Main);
ImportMappingInfo figureInfo = importMap[@"\fig"];
if (figureInfo != null)
{
figureInfo.IsExcluded = true;
}
importSettings.SaveSettings();
return(true);
});
if (haveSomethingToImport && ReflectionHelper.GetBoolResult(ReflectionHelper.GetType("TeImportExport.dll",
"SIL.FieldWorks.TE.TeImportManager"), "ImportParatext", owningForm, ScriptureStylesheet,
(FwApp)m_mediator.PropertyTable.GetValue("App")))
{
return(scr.FindBook(bookNum));
}
return(null);
}
internal static void ReferenceBreaker(FdoCache cache, out int m_count, out int m_circular, out string m_report)
{
m_count = cache.ServiceLocator.GetInstance <ILexEntryRefRepository>().AllInstances().Count(r => r.RefType == LexEntryRefTags.krtComplexForm);
var list = cache.ServiceLocator.GetInstance <ILexEntryRefRepository>().AllInstances().Where(r => r.RefType == LexEntryRefTags.krtComplexForm);
var bldr = new StringBuilder();
var circularRef = m_circular = 0;
NonUndoableUnitOfWorkHelper.Do(cache.ServiceLocator.GetInstance <IActionHandler>(), () =>
{
foreach (var ler in list)
{
if (!ler.IsValidObject)
{
continue; // we can remove LexEntryRef objects during processing, making them invalid.
}
m_refsProcessed.Clear();
m_entriesEncountered.Clear();
if (CheckForCircularRef(ler))
{
#if DEBUG
Debug.Assert(m_refsProcessed.Count > 1);
ShowFullProcessedRefs();
#endif
++circularRef;
var lim = m_refsProcessed.Count - 1;
var entry1 = m_refsProcessed[0].OwningEntry;
var entry2 = m_refsProcessed[lim].OwningEntry;
// Assume that the entry with the longer headword is probably the actual complex form, so remove that one
// from the references owned by the other entry. If this assumption is somehow wrong, at least the user
// is going to be notified of what happened.
if (entry1.HeadWord.Text.Length > entry2.HeadWord.Text.Length)
{
RemoveEntryFromLexEntryRef(m_refsProcessed[lim], entry1, bldr);
}
else
{
RemoveEntryFromLexEntryRef(m_refsProcessed[0], entry2, bldr);
}
bldr.AppendLine();
}
}
});
if (bldr.Length > 0)
{
bldr.Insert(0, Environment.NewLine);
}
m_circular = circularRef;
bldr.Insert(0, String.Format(Strings.ksFoundNCircularReferences, m_circular, m_count));
m_report = bldr.ToString();
}
void soundFieldControl_BeforeStartingToRecord(object sender, EventArgs e)
{
var sc = (ShortSoundFieldControl)sender;
string path;
string filename = CreateNewSoundFilename(out path);
sc.Path = path;
int dummy;
var ws = WsForSoundField(sc, out dummy);
NonUndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(m_innerView.Cache.ActionHandlerAccessor,
() => m_innerView.Cache.DomainDataByFlid.SetMultiStringAlt(m_innerView.HvoObj, m_innerView.Flid,
ws.Handle, m_innerView.Cache.TsStrFactory.MakeString(filename, ws.Handle)));
}
///-------------------------------------------------------------------------------
/// <summary>
/// When the Source button is clicked, display the import wizard.
/// </summary>
///-------------------------------------------------------------------------------
private void btnSource_Click(object sender, System.EventArgs e)
{
using (ImportWizard importWizard = new ImportWizard(m_scr.Cache.ProjectId.Name,
m_scr, m_StyleSheet, m_helpTopicProvider, m_app))
{
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(ActionHandler))
{
if (importWizard.ShowDialog() == DialogResult.Cancel)
{
// Ditch any in-memory changes made to the settings. Reload from the DB.
m_importSettings.RevertToSaved();
}
else
{
undoHelper.RollBack = false;
}
}
// If there are no files after showing the wizard, close the import dialog
if (InitBookNameList() == 0)
{
MessageBox.Show(this, DlgResources.ResourceString("kstidImportFilesUnavailable"),
m_app.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Information);
Close();
return;
}
// The default set of settings may have changed.
m_importSettings = m_scr.DefaultImportSettings;
// Update the file ranges for import because they may have changed.
InitializeStartAndEndRefControls();
// Update the passage controls to reflect the new range of files available
// Only make changes that do not expand the available range of books since a
// range may have been specified before the wizard was run that we do not
// want to overwrite
if (!scrPsgFrom.IsReferenceValid(scrPsgFrom.ScReference))
{
SetStartRefToFirstImportableBook();
}
if (!scrPsgTo.IsReferenceValid(scrPsgTo.ScReference))
{
SetEndRefToLastImportableBook();
}
}
btnOK.Focus();
}
void soundFieldControl_SoundRecorded(object sender, EventArgs e)
{
var sc = (ShortSoundFieldControl)sender;
int dummy;
var ws = WsForSoundField(sc, out dummy);
var filenameNew = Path.GetFileName(sc.Path);
var filenameOld = m_innerView.Cache.DomainDataByFlid.get_MultiStringAlt(m_innerView.HvoObj, m_innerView.Flid, ws.Handle).Text ?? "";
if (filenameNew != filenameOld)
{
NonUndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(m_innerView.Cache.ActionHandlerAccessor,
() => m_innerView.Cache.DomainDataByFlid.SetMultiStringAlt(m_innerView.HvoObj, m_innerView.Flid,
ws.Handle, m_innerView.Cache.TsStrFactory.MakeString(filenameNew, ws.Handle)));
}
}
/// <summary>
/// Get the language project's list of pronunciation writing systems into sync with the supplied list.
/// </summary>
private void UpdatePronunciationWritingSystems(IEnumerable <IWritingSystem> newValues)
{
if (newValues.Count() != m_cache.ServiceLocator.WritingSystems.CurrentPronunciationWritingSystems.Count ||
!m_cache.ServiceLocator.WritingSystems.CurrentPronunciationWritingSystems.SequenceEqual(newValues))
{
NonUndoableUnitOfWorkHelper.Do(m_cache.ServiceLocator.GetInstance <IActionHandler>(), () =>
{
m_cache.ServiceLocator.WritingSystems.CurrentPronunciationWritingSystems.Clear();
foreach (IWritingSystem ws in newValues)
{
m_cache.ServiceLocator.WritingSystems.CurrentPronunciationWritingSystems.Add(ws);
}
});
}
}
/// <summary>
/// Create a new Language Project.
/// </summary>
internal static void BootstrapNewSystem(IServiceLocator servLoc)
{
using (var nonUndoableUOW = new NonUndoableUnitOfWorkHelper(servLoc.GetInstance<IActionHandler>()))
{
var lp = servLoc.GetInstance<ILangProjectFactory>().Create();
BootstrapWritingSystems(lp);
// Add some required objects.
SetupVariousPossibilityLists(lp);
lp.MsFeatureSystemOA = servLoc.GetInstance<IFsFeatureSystemFactory>().Create();
lp.PhFeatureSystemOA = servLoc.GetInstance<IFsFeatureSystemFactory>().Create();
lp.PhonologicalDataOA = servLoc.GetInstance<IPhPhonDataFactory>().Create();
lp.MorphologicalDataOA = servLoc.GetInstance<IMoMorphDataFactory>().Create();
// This should possibly be in SetupVariousPossibilityLists, if we did that after making the owner.
lp.MorphologicalDataOA.ProdRestrictOA = servLoc.GetInstance<ICmPossibilityListFactory>().Create();
lp.MorphologicalDataOA.ProdRestrictOA.ItemClsid = CmPossibilityTags.kClassId;
lp.PhonologicalDataOA.PhonRuleFeatsOA = servLoc.GetInstance<ICmPossibilityListFactory>().Create();
lp.PhonologicalDataOA.PhonRuleFeatsOA.ItemClsid = PhPhonRuleFeatTags.kClassId;
lp.ResearchNotebookOA = servLoc.GetInstance<IRnResearchNbkFactory>().Create();
InitializeLexDb(lp);
// Add all fixed Guid objects here.
SetupAnnotationDefns(lp);
SetupAgents(lp);
// Translation Types Possibility List and KeyTerms List
SetupTranslationTypesAndKeyTermsList(lp);
// If there are any exceptions before this point,
// then the whole mess gets rolled back.
nonUndoableUOW.RollBack = false;
}
}
public void kcptBinaryTests()
{
IUserConfigAcctFactory acctFactory = Cache.ServiceLocator.GetInstance<IUserConfigAcctFactory>();
IUserConfigAcct acct;
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
acct = acctFactory.Create();
Cache.LanguageProject.UserAccountsOC.Add(acct);
undoHelper.RollBack = false;
}
CheckChanges(1, 0, Cache.LanguageProject.Hvo, LangProjectTags.kflidUserAccounts, 0, 1, 0);
ClearChanges();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
acct.Sid = new byte[] { 1, 2, 3 };
undoHelper.RollBack = false;
}
// Changing a prop on an unowned object does make one PC.
CheckChanges(1, 0, acct.Hvo, UserConfigAcctTags.kflidSid, 0, 0, 0);
ClearChanges();
}
public void UnknownTests()
{
var lp = Cache.LanguageProject;
var styleFactory = Cache.ServiceLocator.GetInstance<IStStyleFactory>();
IStStyle style;
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
style = styleFactory.Create();
lp.StylesOC.Add(style);
undoHelper.RollBack = false;
}
// Should be one PC.
CheckChanges(1, 0, lp.Hvo, LangProjectTags.kflidStyles, 0, 1, 0);
ClearChanges();
var userWs = Cache.WritingSystemFactory.UserWs;
var bldr = TsPropsBldrClass.Create();
bldr.SetStrPropValue((int)FwTextPropType.ktptNamedStyle, "Arial");
bldr.SetIntPropValues((int)FwTextPropType.ktptWs, 0, userWs);
var tpp = bldr.GetTextProps();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
style.Rules = tpp;
undoHelper.RollBack = false;
}
// Should be one PC.
CheckChanges(1, 0, style.Hvo, StStyleTags.kflidRules, 0, 0, 0);
ClearChanges();
}
public void kcptStringTests()
{
ILexEntry le;
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
le = Cache.ServiceLocator.GetInstance<ILexEntryFactory>().Create();
undoHelper.RollBack = false;
}
// Skip the main checking on the vector prop.
CheckChanges(1, -1, 0, 0, 0, 0, 0);
ClearChanges();
var tsf = Cache.TsStrFactory;
var userWs = Cache.WritingSystemFactory.UserWs;
ITsString importResidue;
int originalImportResidueLength = 0;
UndoableUnitOfWorkHelper.Do("Undo stuff", "Redo stuff", m_actionHandler, () =>
{
importResidue = tsf.MakeString("import residue", userWs);
originalImportResidueLength = importResidue.Length;
le.ImportResidue = importResidue;
});
// Null to new value should have cvIns be the new length and cvDel be 0.
CheckChanges(1, 0, le.Hvo, LexEntryTags.kflidImportResidue, 0, originalImportResidueLength, 0);
ClearChanges();
m_actionHandler.Undo();
CheckChanges(1, 0, le.Hvo, LexEntryTags.kflidImportResidue, 0, 0, originalImportResidueLength);
m_actionHandler.Redo();
ClearChanges();
int newImportResidueLength = 0;
UndoableUnitOfWorkHelper.Do("Undo stuff", "Redo stuff", m_actionHandler, () =>
{
importResidue = tsf.MakeString("new import residue", userWs);
newImportResidueLength = importResidue.Length;
le.ImportResidue = importResidue;
});
// Old value to new value should have cvIns be the new length and cvDel be old value length.
CheckChanges(1, 0, le.Hvo, LexEntryTags.kflidImportResidue, 0, newImportResidueLength, originalImportResidueLength);
ClearChanges();
m_actionHandler.Undo();
CheckChanges(1, 0, le.Hvo, LexEntryTags.kflidImportResidue, 0, originalImportResidueLength, newImportResidueLength);
m_actionHandler.Redo();
ClearChanges();
UndoableUnitOfWorkHelper.Do("Undo stuff", "Redo stuff", m_actionHandler, () => le.ImportResidue = null);
// Old value to null should have cvIns be 0 and cvDel be old value length.
CheckChanges(1, 0, le.Hvo, LexEntryTags.kflidImportResidue, 0, 0, newImportResidueLength);
ClearChanges();
m_actionHandler.Undo();
CheckChanges(1, 0, le.Hvo, LexEntryTags.kflidImportResidue, 0, newImportResidueLength, 0);
m_actionHandler.Redo();
ClearChanges();
}
public void MultiUnicodeTests()
{
var tsf = Cache.TsStrFactory;
var englishWsHvo = Cache.WritingSystemFactory.GetWsFromStr("en");
var spanishWsHvo = Cache.WritingSystemFactory.GetWsFromStr("es");
var lp = Cache.LanguageProject;
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
// Description is MultiString
// Set LP's Description.
lp.Description.set_String(
englishWsHvo,
tsf.MakeString("Stateful FDO Test Language Project: Desc", englishWsHvo));
lp.Description.set_String(
spanishWsHvo,
tsf.MakeString("Proyecto de prueba: FDO: desc", spanishWsHvo));
undoHelper.RollBack = false;
}
// Should be two PCs on LP.
CheckChanges(2, 0, lp.Hvo, CmProjectTags.kflidDescription, englishWsHvo, 0, 0);
CheckChanges(2, 1, lp.Hvo, CmProjectTags.kflidDescription, spanishWsHvo, 0, 0);
ClearChanges();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes the specified application and creates a new main window for it. Also
/// does application-specific cache initialization.
/// </summary>
/// <param name="app">The application</param>
/// <param name="progressDlg">The progress dialog.</param>
/// <returns>True if the application was started successfully, false otherwise</returns>
/// ------------------------------------------------------------------------------------
private static bool InitializeApp(FwApp app, IThreadedProgress progressDlg)
{
using (new DataUpdateMonitor(null, "Application Initialization"))
app.DoApplicationInitialization(progressDlg);
using (new DataUpdateMonitor(null, "Loading Application Settings"))
app.LoadSettings();
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(
s_cache.ServiceLocator.GetInstance<IActionHandler>()))
using (new DataUpdateMonitor(null, "Application Cache Initialization"))
{
try
{
if (!app.InitCacheForApp(progressDlg))
throw new StartupException(Properties.Resources.kstidCacheInitFailure);
}
catch (Exception e)
{
if (e is StartupException)
throw;
throw new StartupException(Properties.Resources.kstidCacheInitFailure, e, true);
}
undoHelper.RollBack = false;
}
if (s_cache.ServiceLocator.GetInstance<IUndoStackManager>().HasUnsavedChanges)
{
if (progressDlg != null)
{
progressDlg.Message = String.Format(Properties.Resources.kstidSaving, s_cache.ProjectId.UiName);
progressDlg.IsIndeterminate = true;
}
s_cache.ServiceLocator.GetInstance<IUndoStackManager>().Save();
if (progressDlg != null)
progressDlg.IsIndeterminate = false;
}
return CreateAndInitNewMainWindow(app, true, null, false);
}
public void KeyTermInit_DashDescription()
{
BiblicalTermsList terms = new BiblicalTermsList();
terms.Version = Guid.NewGuid();
terms.KeyTerms = new List<Term>();
terms.KeyTerms.Add(new Term(56, "FA", "\u1F00\u03B5\u03C4\u1F79\u03C2", "Greek",
"eagle; vulture", null, null,
4002402809, 4201703717, 6600400728, 6600801306, 6601201409));
List<BiblicalTermsLocalization> localizations = new List<BiblicalTermsLocalization>(1);
BiblicalTermsLocalization loc = new BiblicalTermsLocalization(1);
loc.WritingSystemHvo = m_wsEn;
loc.Categories.Add(new CategoryLocalization("FA", "Fauna"));
loc.Terms.Add(new TermLocalization(56, "eagle; vulture", "\t-"));
localizations.Add(loc);
ICmPossibilityList chkTermsList = Cache.ServiceLocator.GetInstance<ICmPossibilityListFactory>().Create();
m_lp.CheckListsOC.Add(chkTermsList);
// Load the term
m_actionHandler.EndUndoTask();
try
{
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
DummyTeKeyTermsInit.CallLoadKeyTerms(chkTermsList, terms, localizations);
undoHelper.RollBack = false;
}
}
finally
{
m_actionHandler.BeginUndoTask("bla", "bla");
}
int wsGreek = m_wsf.GetWsFromStr("grc");
// Make sure there is one category (possibility)
Assert.AreEqual(1, chkTermsList.PossibilitiesOS.Count);
ICmPossibility faCategory = chkTermsList.PossibilitiesOS[0];
Assert.AreEqual("FA", faCategory.Abbreviation.get_String(m_wsEn).Text);
// Make sure there is one entry in the Fauna category
Assert.AreEqual(1, faCategory.SubPossibilitiesOS.Count);
// Look at the contents of the ChkTerm
IChkTerm keyterm = (IChkTerm)faCategory.SubPossibilitiesOS[0];
Assert.AreEqual(56, keyterm.TermId);
Assert.AreEqual("\u1F00\u03B5\u03C4\u1F79\u03C2".Normalize(NormalizationForm.FormD), keyterm.Name.get_String(wsGreek).Text);
Assert.AreEqual("eagle", keyterm.Name.get_String(m_wsEn).Text);
Assert.IsNull(keyterm.Description.get_String(m_wsEn).Text);
Assert.AreEqual("vulture", keyterm.SeeAlso.get_String(m_wsEn).Text);
Assert.AreEqual(0, keyterm.RenderingsOC.Count);
// There should be 5 references for this key term
Assert.AreEqual(5, keyterm.OccurrencesOS.Count);
IChkRef reference = keyterm.OccurrencesOS[0];
Assert.AreEqual(40024028, reference.Ref);
Assert.AreEqual("\u1F00\u03B5\u03C4\u1F79\u03C2".Normalize(NormalizationForm.FormD), reference.KeyWord.Text);
Assert.AreEqual(9, reference.Location);
reference = keyterm.OccurrencesOS[1];
Assert.AreEqual(42017037, reference.Ref);
Assert.AreEqual("\u1F00\u03B5\u03C4\u1F79\u03C2".Normalize(NormalizationForm.FormD), reference.KeyWord.Text);
Assert.AreEqual(17, reference.Location);
reference = keyterm.OccurrencesOS[2];
Assert.AreEqual(66004007, reference.Ref);
Assert.AreEqual("\u1F00\u03B5\u03C4\u1F79\u03C2".Normalize(NormalizationForm.FormD), reference.KeyWord.Text);
Assert.AreEqual(28, reference.Location);
reference = keyterm.OccurrencesOS[3];
Assert.AreEqual(66008013, reference.Ref);
Assert.AreEqual("\u1F00\u03B5\u03C4\u1F79\u03C2".Normalize(NormalizationForm.FormD), reference.KeyWord.Text);
Assert.AreEqual(6, reference.Location);
reference = keyterm.OccurrencesOS[4];
Assert.AreEqual(66012014, reference.Ref);
Assert.AreEqual("\u1F00\u03B5\u03C4\u1F79\u03C2".Normalize(NormalizationForm.FormD), reference.KeyWord.Text);
Assert.AreEqual(9, reference.Location);
bool fFoundResource = false;
foreach (ICmResource resource in m_lp.TranslatedScriptureOA.ResourcesOC)
{
if (resource.Name == "BiblicalTerms")
{
Assert.AreEqual(terms.Version, resource.Version);
fFoundResource = true;
}
}
Assert.IsTrue(fFoundResource);
}
public void kcptIntegerTests()
{
var servLoc = Cache.ServiceLocator;
var lp = servLoc.GetInstance<ILangProjectRepository>().AllInstances().First();
ICmPossibilityList peopleList;
ICmPerson firstPerson;
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
lp.PeopleOA = servLoc.GetInstance<ICmPossibilityListFactory>().Create();
peopleList = lp.PeopleOA;
firstPerson = servLoc.GetInstance<ICmPersonFactory>().Create();
peopleList.PossibilitiesOS.Add(firstPerson);
undoHelper.RollBack = false;
}
// Two new objects (nested) should only make one PC on the top owner.
CheckChanges(1, 0, lp.Hvo, LangProjectTags.kflidPeople, 0, 1, 0);
ClearChanges();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
peopleList.Depth += 1;
undoHelper.RollBack = false;
}
CheckChanges(1, 0, peopleList.Hvo, CmPossibilityListTags.kflidDepth, 0, 0, 0);
ClearChanges();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
// Get rid of the list.
lp.PeopleOA = null;
undoHelper.RollBack = false;
}
ClearChanges();
}
public void kcptGuidTests()
{
ICmPossibilityListFactory possFactory = Cache.ServiceLocator.GetInstance<ICmPossibilityListFactory>();
ICmPossibilityList possList;
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
possList = possFactory.Create();
Cache.LanguageProject.TimeOfDayOA = possList;
undoHelper.RollBack = false;
}
CheckChanges(1, 0, Cache.LanguageProject.Hvo, LangProjectTags.kflidTimeOfDay, 0, 1, 0);
ClearChanges();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
possList.ListVersion = Guid.NewGuid();
undoHelper.RollBack = false;
}
// Changing a prop on an unowned object does make one PC.
CheckChanges(1, 0, possList.Hvo, CmPossibilityListTags.kflidListVersion, 0, 0, 0);
ClearChanges();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
possList.ListVersion = Guid.NewGuid();
possList.ListVersion = Guid.NewGuid();
undoHelper.RollBack = false;
}
// Changing a prop twice in one UOW only makes one PC for the property.
CheckChanges(1, 0, possList.Hvo, CmPossibilityListTags.kflidListVersion, 0, 0, 0);
ClearChanges();
// TODO: Delete unowned uv, as that should also not produce a PC.
}
public void kcptBooleanTests()
{
var servLoc = Cache.ServiceLocator;
var lp = servLoc.GetInstance<ILangProjectRepository>().AllInstances().First();
ICmPossibilityList peopleList;
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
lp.PeopleOA = servLoc.GetInstance<ICmPossibilityListFactory>().Create();
peopleList = lp.PeopleOA;
undoHelper.RollBack = false;
}
CheckChanges(1, -1, 0, 0, 0, 0, 0);
ClearChanges();
using (var undoHelper = new UndoableUnitOfWorkHelper(m_actionHandler, "set boolean"))
{
peopleList.IsVernacular = !peopleList.IsVernacular;
undoHelper.RollBack = false;
}
CheckChanges(1, 0, peopleList.Hvo, CmPossibilityListTags.kflidIsVernacular, 0, 0, 0);
ClearChanges();
// Check Undo/Redo to ensure they fire PropChanges.
m_actionHandler.Undo();
CheckChanges(1, 0, peopleList.Hvo, CmPossibilityListTags.kflidIsVernacular, 0, 0, 0);
ClearChanges();
m_actionHandler.Redo();
CheckChanges(1, 0, peopleList.Hvo, CmPossibilityListTags.kflidIsVernacular, 0, 0, 0);
ClearChanges();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
// Get rid of the list.
lp.PeopleOA = null;
undoHelper.RollBack = false;
}
ClearChanges();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Get the settings for Import, either from database or from wizard
/// </summary>
/// <returns>Import settings, or <c>null</c> if user canceled dialog.</returns>
/// ------------------------------------------------------------------------------------
protected IScrImportSet GetImportSettings()
{
ILangProject proj = m_cache.LangProject;
IScripture scr = proj.TranslatedScriptureOA;
IScrImportSet importSettings = null;
NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () =>
{
importSettings =
scr.FindOrCreateDefaultImportSettings(TypeOfImport.Unknown);
});
importSettings.StyleSheet = m_styleSheet;
importSettings.OverlappingFileResolver = new ConfirmOverlappingFileReplaceDialog(m_helpTopicProvider);
if (!importSettings.BasicSettingsExist)
{
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(
m_cache.ServiceLocator.GetInstance<IActionHandler>()))
{
using (ImportWizard importWizard = new ImportWizard(m_cache.ProjectId.Name,
scr, m_styleSheet, m_helpTopicProvider, m_app))
{
if (importWizard.ShowDialog() == DialogResult.Cancel)
return null;
// Scripture reference range may have changed
ImportDialog.ClearDialogReferences();
importSettings = scr.DefaultImportSettings;
}
undoHelper.RollBack = false;
}
}
else
{
StringCollection sInvalidFiles;
bool fCompletedWizard = false;
while (!importSettings.ImportProjectIsAccessible(out sInvalidFiles))
{
// Display the "Project Not Found" message box
using (ScrImportSetMessage dlg = new ScrImportSetMessage())
{
string[] files = new string[sInvalidFiles.Count];
sInvalidFiles.CopyTo(files, 0);
dlg.InvalidFiles = files;
dlg.HelpURL = m_helpTopicProvider.HelpFile;
dlg.HelpTopic = "/Beginning_Tasks/Import_Standard_Format/Project_Files_Unavailable.htm";
dlg.DisplaySetupOption = true;
switch(dlg.ShowDialog())
{
case DialogResult.OK: // Setup...
{
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(
m_cache.ServiceLocator.GetInstance<IActionHandler>()))
{
using (ImportWizard importWizard = new ImportWizard(
m_cache.ProjectId.Name, scr, m_styleSheet, m_helpTopicProvider, m_app))
{
if (importWizard.ShowDialog() == DialogResult.Cancel)
return null;
// Scripture reference range may have changed
ImportDialog.ClearDialogReferences();
importSettings = scr.DefaultImportSettings;
fCompletedWizard = true;
}
undoHelper.RollBack = false;
}
break;
}
case DialogResult.Cancel:
return null;
case DialogResult.Retry:
// Loop around until user gets tired.
break;
}
}
}
if (!fCompletedWizard)
{
if (ParatextProjHasUnmappedMarkers(importSettings))
{
// TODO: Show message box and then bring up import wizard
}
}
}
return importSettings;
}
/// <summary>
/// Here's where the rubber meets the road. We have the settings, let's do the import!
/// </summary>
private object ImportStdFmtFile(IThreadedProgress progressDlg, object[] parameters)
{
int lineNumber = 0;
using (var uowHelper = new NonUndoableUnitOfWorkHelper(m_cache.ActionHandlerAccessor))
{
try
{
m_dtStart = DateTime.Now;
FixSettingsForThisDatabase();
int cLines = m_SfmFile.Lines.Count;
progressDlg.Title = String.Format(LexTextControls.ksImportingFrom0, Path.GetFileName(m_sSfmDataFile));
progressDlg.StepSize = 1;
int cExistingRecords = m_cache.LangProject.ResearchNotebookOA.RecordsOC.Count;
if (m_rbReplaceAllEntries.Checked && cExistingRecords > 0)
{
progressDlg.Minimum = 0;
progressDlg.Maximum = cLines + 50;
progressDlg.Message = LexTextControls.ksDeletingExistingRecords;
// This is rather drastic, but it's what the user asked for!
// REVIEW: Should we ask for confirmation before doing this?
m_cRecordsDeleted = cExistingRecords;
m_cache.LangProject.ResearchNotebookOA.RecordsOC.Clear();
progressDlg.Step(50);
}
else
{
m_cRecordsDeleted = 0;
progressDlg.Minimum = 0;
progressDlg.Maximum = cLines;
}
progressDlg.Message = LexTextControls.ksImportingNewRecords;
IRnGenericRec recPrev = null;
IRnGenericRec rec = null;
IRnGenericRecFactory factRec = m_cache.ServiceLocator.GetInstance<IRnGenericRecFactory>();
IRnGenericRecRepository repoRec = m_cache.ServiceLocator.GetInstance<IRnGenericRecRepository>();
ICmPossibilityRepository repoPoss = m_cache.ServiceLocator.GetInstance<ICmPossibilityRepository>();
ICmPossibility defaultType = repoPoss.GetObject(RnResearchNbkTags.kguidRecObservation);
for (int i = 0; i < cLines; ++i)
{
progressDlg.Step(1);
if (progressDlg.Canceled)
{
LogMessage(LexTextControls.ksImportCanceledByUser, lineNumber);
break;
}
Sfm2Xml.SfmField field = m_SfmFile.Lines[i];
lineNumber = field.LineNumber;
if (field.Marker.StartsWith("_"))
continue;
RnSfMarker rsf;
if (!m_mapMkrRsf.TryGetValue(field.Marker, out rsf))
{
// complain? log complaint? throw a fit?
continue;
}
if (rsf.m_nLevel == 1)
{
recPrev = rec;
rec = factRec.Create();
m_cache.LangProject.ResearchNotebookOA.RecordsOC.Add(rec);
rec.TypeRA = defaultType;
++m_cRecordsRead;
}
else if (rsf.m_nLevel > 1)
{
// we don't handle this yet!
}
if (rsf.m_flid == 0)
continue;
CellarPropertyType cpt = (CellarPropertyType) m_mdc.GetFieldType(rsf.m_flid);
int clidDst;
switch (cpt)
{
case CellarPropertyType.ReferenceAtomic:
case CellarPropertyType.ReferenceCollection:
case CellarPropertyType.ReferenceSequence:
clidDst = m_mdc.GetDstClsId(rsf.m_flid);
switch (clidDst)
{
case RnGenericRecTags.kClassId:
StoreLinkData(rec, rsf, field);
break;
case CrossReferenceTags.kClassId:
case ReminderTags.kClassId:
// we don't handle these yet
break;
default:
int clidBase = clidDst;
while (clidBase != 0 && clidBase != CmPossibilityTags.kClassId)
clidBase = m_mdc.GetBaseClsId(clidBase);
if (clidBase == CmPossibilityTags.kClassId)
SetListReference(rec, rsf, field);
break;
}
break;
case CellarPropertyType.OwningAtomic:
case CellarPropertyType.OwningCollection:
case CellarPropertyType.OwningSequence:
clidDst = m_mdc.GetDstClsId(rsf.m_flid);
switch (clidDst)
{
case StTextTags.kClassId:
Debug.Assert(cpt == CellarPropertyType.OwningAtomic);
SetTextContent(rec, rsf, field);
break;
case RnRoledParticTags.kClassId:
SetListReference(rec, rsf, field);
break;
case RnGenericRecTags.kClassId:
break;
default:
// we don't handle these yet.
MessageBox.Show("Need to handle owned RnGenericRec", "DEBUG");
break;
}
break;
case CellarPropertyType.MultiString:
case CellarPropertyType.MultiUnicode:
case CellarPropertyType.String:
SetStringValue(rec, rsf, field, cpt);
break;
case CellarPropertyType.GenDate:
SetGenDateValue(rec, rsf, field);
break;
case CellarPropertyType.Time:
SetDateTimeValue(rec, rsf, field);
break;
case CellarPropertyType.Unicode:
case CellarPropertyType.Binary:
case CellarPropertyType.Image:
case CellarPropertyType.Boolean:
case CellarPropertyType.Float:
case CellarPropertyType.Guid:
case CellarPropertyType.Integer:
case CellarPropertyType.Numeric:
break;
}
}
ProcessStoredLinkData();
uowHelper.RollBack = false;
}
catch (Exception e)
{
string sMsg = String.Format(LexTextControls.ksProblemImportingFrom,
m_tbDatabaseFileName.Text, e.Message);
LogMessage(sMsg, lineNumber);
System.Windows.Forms.MessageBox.Show(this, sMsg);
}
}
m_dtEnd = DateTime.Now;
progressDlg.Message = LexTextControls.ksCreatingImportLog;
return CreateImportReport();
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Create the client windows and add corresponding stuff to the sidebar, View menu,
/// etc.
/// </summary>
///
/// <exception cref="Exception">Invalid user view type in database</exception>
/// -----------------------------------------------------------------------------------
public override void InitAndShowClient()
{
CheckDisposed();
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(
m_cache.ServiceLocator.GetInstance<IActionHandler>()))
{
CreateBookFilterIfMissing();
// Add the user views to the sidebar, menu, info bar
AddUserViews();
// Add the filters too
AddFilters();
undoHelper.RollBack = false;
}
if (SIBAdapter != null)
{
SIBAdapter.SetupViewMenuForSideBarTabs(TMAdapter, "mnuFilters");
SIBAdapter.LoadSettings(MainWndSettingsKey);
}
GotoReferenceControl.PassageChanged +=
new ScrPassageControl.PassageChangedHandler(OnPassageChanged);
}
public void NumberOfSenses()
{
ILexEntry entry;
ILexSense sense2, sense2_2;
ILexSense senseInserted;
using (var helper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
entry = m_entryFactory.Create();
var sense = m_senseFactory.Create();
entry.SensesOS.Add(sense);
Assert.AreEqual(1, entry.NumberOfSensesForEntry);
sense2 = m_senseFactory.Create();
entry.SensesOS.Add(sense2);
Assert.AreEqual(2, entry.NumberOfSensesForEntry);
var sense3 = m_senseFactory.Create();
entry.SensesOS.Add(sense3);
Assert.AreEqual(3, entry.NumberOfSensesForEntry);
var sense2_1 = m_senseFactory.Create();
sense2.SensesOS.Add(sense2_1);
Assert.AreEqual(4, entry.NumberOfSensesForEntry);
sense2_2 = m_senseFactory.Create();
sense2.SensesOS.Add(sense2_2);
Assert.AreEqual(5, entry.NumberOfSensesForEntry);
var sense2_1_1 = m_senseFactory.Create();
sense2_1.SensesOS.Add(sense2_1_1);
Assert.AreEqual(6, entry.NumberOfSensesForEntry);
var sense2_2_1 = m_senseFactory.Create();
sense2_2.SensesOS.Add(sense2_2_1);
Assert.AreEqual(7, entry.NumberOfSensesForEntry);
helper.RollBack = false;
}
m_notifiee = new Notifiee();
IFwMetaDataCache mdc = m_sda.MetaDataCache;
int nosFlid = mdc.GetFieldId("LexEntry", "NumberOfSensesForEntry", false);
m_sda.AddNotification(m_notifiee);
using (var helper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
senseInserted = m_senseFactory.Create();
entry.SensesOS.Insert(1, senseInserted);
Assert.AreEqual(8, entry.NumberOfSensesForEntry); // Added one top-level sense
helper.RollBack = false;
}
m_notifiee.CheckChangesWeaker(new[]
{
new ChangeInformationTest(entry.Hvo, LexEntryTags.kflidSenses, 1, 1, 0),
new ChangeInformationTest(entry.Hvo, nosFlid, 0, 0, 0),
}, "insert second sense in entry");
m_sda.RemoveNotification(m_notifiee);
m_notifiee = new Notifiee();
m_sda.AddNotification(m_notifiee);
using (var helper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
entry.SensesOS.Remove(senseInserted);
helper.RollBack = false;
}
m_notifiee.CheckChangesWeaker(new[]
{
new ChangeInformationTest(entry.Hvo, LexEntryTags.kflidSenses, 1, 0, 1),
new ChangeInformationTest(entry.Hvo, nosFlid, 0, 0, 0),
}, "delete second sense in entry");
m_sda.RemoveNotification(m_notifiee);
Assert.AreEqual(7, entry.NumberOfSensesForEntry);
m_notifiee = new Notifiee();
m_sda.AddNotification(m_notifiee);
using (var helper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
senseInserted = m_senseFactory.Create();
sense2.SensesOS.Insert(1, senseInserted);
Assert.AreEqual(8, entry.NumberOfSensesForEntry); // Added a subsense.
helper.RollBack = false;
}
m_notifiee.CheckChangesWeaker(new[]
{
new ChangeInformationTest(sense2.Hvo, LexSenseTags.kflidSenses, 1, 1, 0),
new ChangeInformationTest(entry.Hvo, nosFlid, 0, 0, 0),
}, "insert subsense in sense");
m_sda.RemoveNotification(m_notifiee);
Assert.AreEqual(8, entry.NumberOfSensesForEntry);
m_notifiee = new Notifiee();
m_sda.AddNotification(m_notifiee);
using (var helper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
sense2.SensesOS.Remove(senseInserted);
helper.RollBack = false;
}
m_notifiee.CheckChangesWeaker(new[]
{
new ChangeInformationTest(sense2.Hvo, LexSenseTags.kflidSenses, 1, 0, 1),
new ChangeInformationTest(entry.Hvo, nosFlid, 0, 0, 0),
}, "remove subsense from sense");
m_sda.RemoveNotification(m_notifiee);
Assert.AreEqual(7, entry.NumberOfSensesForEntry);
}
public void kcptTimeTests()
{
var servLoc = Cache.ServiceLocator;
var lp = servLoc.GetInstance<ILangProjectRepository>().AllInstances().First();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
lp.DateCreated = DateTime.Now;
undoHelper.RollBack = false;
}
CheckChanges(1, 0, lp.Hvo, CmProjectTags.kflidDateCreated, 0, 0, 0);
ClearChanges();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Handles the Click event of the m_btnOk control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="T:System.EventArgs"/> instance containing the event data.</param>
/// ------------------------------------------------------------------------------------
private void btnOk_Click(object sender, EventArgs e)
{
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(m_cache.ActionHandlerAccessor))
{
ICmCell cell;
string fmtClassFlid = ScrScriptureNoteTags.kClassId + ",{0}|";
StringBuilder bldr = new StringBuilder();
m_filter.RowsOS[0].CellsOS.Clear();
if (chkStatus.Checked)
{
bldr.AppendFormat(fmtClassFlid, ScrScriptureNoteTags.kflidResolutionStatus);
cell = m_cellFactory.Create();
m_filter.RowsOS[0].CellsOS.Add(cell);
int value = (rbResolved.Checked ? 1 : 0);
cell.SetIntegerMatchCriteria(ComparisonTypes.kEquals, value);
}
if (chkType.Checked)
{
bldr.AppendFormat(fmtClassFlid, CmAnnotationTags.kflidAnnotationType);
cell = m_cellFactory.Create();
m_filter.RowsOS[0].CellsOS.Add(cell);
ICmAnnotationDefn type =
m_cache.ServiceLocator.GetInstance<ICmAnnotationDefnRepository>().GetObject(
rbConsultant.Checked ? CmAnnotationDefnTags.kguidAnnConsultantNote :
CmAnnotationDefnTags.kguidAnnTranslatorNote);
cell.SetObjectMatchCriteria(type, false, false);
}
if (chkScrRange.Checked)
{
bldr.AppendFormat(fmtClassFlid, CmBaseAnnotationTags.kflidBeginRef);
bldr.AppendFormat(fmtClassFlid, CmBaseAnnotationTags.kflidBeginRef);
ScrReference startRef = (scrBookFrom.ScReference.Chapter == 1 && scrBookFrom.ScReference.Verse == 1) ?
new ScrReference(scrBookFrom.ScReference.Book, 0, 0, m_scr.Versification) :
scrBookFrom.ScReference;
cell = m_cellFactory.Create();
m_filter.RowsOS[0].CellsOS.Add(cell);
cell.SetIntegerMatchCriteria(ComparisonTypes.kGreaterThanEqual, startRef);
cell = m_cellFactory.Create();
m_filter.RowsOS[0].CellsOS.Add(cell);
cell.SetIntegerMatchCriteria(ComparisonTypes.kLessThanEqual, scrBookTo.ScReference);
}
m_filter.ColumnInfo = bldr.ToString().TrimEnd('|');
if (chkCategory.Checked)
tvCatagories.UpdateFilter(m_filter);
undoHelper.RollBack = false;
}
}
public void kcptGenDateTests()
{
var servLoc = Cache.ServiceLocator;
var lp = servLoc.GetInstance<ILangProjectRepository>().AllInstances().First();
ICmPossibilityList peopleList;
ICmPerson firstPerson;
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
lp.PeopleOA = servLoc.GetInstance<ICmPossibilityListFactory>().Create();
peopleList = lp.PeopleOA;
firstPerson = servLoc.GetInstance<ICmPersonFactory>().Create();
peopleList.PossibilitiesOS.Add(firstPerson);
undoHelper.RollBack = false;
}
ClearChanges();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
firstPerson.DateOfBirth = new GenDate(GenDate.PrecisionType.Before, 1, 1, 3000, true);
undoHelper.RollBack = false;
}
CheckChanges(1, 0, firstPerson.Hvo, CmPersonTags.kflidDateOfBirth, 0, 0, 0);
ClearChanges();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
// Get rid of the list.
lp.PeopleOA = null;
undoHelper.RollBack = false;
}
ClearChanges();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Adds the "invalid" character as a valid character.
/// </summary>
/// <param name="addedCharError">The checking error containing the character that will
/// be added to the valid character inventory.</param>
/// ------------------------------------------------------------------------------------
private void AddAsValidCharacter(CheckingError addedCharError)
{
Debug.Assert(addedCharError.CheckId == StandardCheckIds.kguidCharacters,
"Checking error should be from the valid characters check");
IWritingSystem ws = m_cache.ServiceLocator.WritingSystems.DefaultVernacularWritingSystem;
if (TsStringUtils.IsCharacterDefined(addedCharError.MyNote.CitedText))
{
using (new WaitCursor(Parent))
{
// Get the valid characters from the database
ValidCharacters validChars = ValidCharacters.Load(ws, ValidCharsLoadException, FwDirectoryFinder.LegacyWordformingCharOverridesFile);
if (validChars != null)
{
validChars.AddCharacter(addedCharError.MyNote.CitedText);
ws.ValidChars = validChars.XmlString;
m_cache.ServiceLocator.WritingSystemManager.Save();
}
// Mark all data grid view rows containing the newly-defined valid character to irrelevant.
for (int iRow = 0; iRow < m_list.Count; iRow++)
{
CheckingError checkError = GetCheckingError(iRow);
if (((IStTxtPara)checkError.MyNote.QuoteOA.ParagraphsOS[0]).Contents.Text ==
addedCharError.MyNote.CitedText)
{
// We don't want to create an undoable action, so we suppress subtasks.
using (var unitOfWork =
new NonUndoableUnitOfWorkHelper(m_cache.ServiceLocator.GetInstance<IActionHandler>()))
{
checkError.Status = CheckingStatus.StatusEnum.Irrelevant;
unitOfWork.RollBack = false;
}
}
}
IsStale = true;
m_dataGridView.Invalidate();
}
}
else
{
string msg = ResourceHelper.GetResourceString("kstidUndefinedCharacterMsg");
MessageBox.Show(this, msg, m_mainWnd.App.ApplicationName,
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
public void CustomPropertyTests()
{
var servLoc = Cache.ServiceLocator;
var sda = Cache.DomainDataByFlid;
var mdc = servLoc.GetInstance<IFwMetaDataCacheManaged>();
var customCertifiedFlid = mdc.AddCustomField("WfiWordform", "Certified", CellarPropertyType.Boolean, 0);
var customITsStringFlid = mdc.AddCustomField("WfiWordform", "NewTsStringProp", CellarPropertyType.String, 0);
var customMultiUnicodeFlid = mdc.AddCustomField("WfiWordform", "MultiUnicodeProp", CellarPropertyType.MultiUnicode, 0);
var customAtomicReferenceFlid = mdc.AddCustomField("WfiWordform", "NewAtomicRef", CellarPropertyType.ReferenceAtomic, CmPersonTags.kClassId);
var lp = servLoc.GetInstance<ILangProjectRepository>().AllInstances().First();
// Add wordform & person.
IWfiWordform wf;
ICmPerson person;
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
// This does not fire a PC, since the wf is not owned.
wf = servLoc.GetInstance<IWfiWordformFactory>().Create();
lp.PeopleOA = servLoc.GetInstance<ICmPossibilityListFactory>().Create();
var personFactory = servLoc.GetInstance<ICmPersonFactory>();
person = personFactory.Create();
lp.PeopleOA.PossibilitiesOS.Add(person);
undoHelper.RollBack = false;
}
CheckChanges(1, -1, 0, 0, 0, 0, 0);
ClearChanges();
// Set custom value.
var userWs = Cache.WritingSystemFactory.UserWs;
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
sda.SetBoolean(wf.Hvo, customCertifiedFlid, false);
var tsf = Cache.TsStrFactory;
sda.SetString(wf.Hvo, customITsStringFlid,
tsf.MakeString("New ITsString", userWs));
sda.SetMultiStringAlt(wf.Hvo, customMultiUnicodeFlid,
userWs, tsf.MakeString("New unicode ITsString", userWs));
sda.SetObjProp(wf.Hvo, customAtomicReferenceFlid, person.Hvo);
undoHelper.RollBack = false;
}
CheckChanges(4, 0, wf.Hvo, customCertifiedFlid, 0, 0, 0);
CheckChanges(4, 1, wf.Hvo, customITsStringFlid, 0, 0, 0);
CheckChanges(4, 2, wf.Hvo, customMultiUnicodeFlid, userWs, 0, 0);
CheckChanges(4, 3, wf.Hvo, customAtomicReferenceFlid, 0, 0, 0);
ClearChanges();
using (var undoHelper = new NonUndoableUnitOfWorkHelper(m_actionHandler))
{
// Get rid of the list.
lp.PeopleOA = null;
undoHelper.RollBack = false;
}
ClearChanges();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates the Back Translation/Print Layout View
/// </summary>
/// <param name="viewName">Name of the view.</param>
/// <param name="viewType">Type of the view.</param>
/// <param name="pubName">Name of the publication.</param>
/// <param name="tabItem">The tab item.</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
protected ISelectableView CreateBackTransPrintLayoutView(string viewName,
TeViewType viewType, string pubName, SBTabItemProperties tabItem)
{
// Construct the publication control (client window)
IPublication pub =
Cache.ServiceLocator.GetInstance<IPublicationRepository>().FindByName(pubName);
int ws = GetBackTranslationWsForView(TeEditingHelper.ViewTypeString(viewType));
ScripturePublication pubControl = CreatePublicationView(pub, viewType, ws);
pubControl.BaseInfoBarCaption = viewName;
IWritingSystem wsObj = m_cache.ServiceLocator.WritingSystemManager.Get(ws);
using (NonUndoableUnitOfWorkHelper uowHelper =
new NonUndoableUnitOfWorkHelper(m_cache.ServiceLocator.ActionHandler))
{
pub.IsLeftBound = !wsObj.RightToLeftScript;
uowHelper.RollBack = false;
}
if (tabItem != null)
{
tabItem.Tag = pubControl;
tabItem.Update = true;
}
ClientControls.Add(pubControl);
// Bring the publication to the top of the z-order, so that
// (if it is the active view) it fills only the remaining space
ClientControls.SetChildIndex(pubControl, 0);
m_rgClientViews.Add(TeEditingHelper.ViewTypeString(viewType), pubControl);
m_uncreatedViews.Remove(viewType);
return pubControl;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Determines if a dialog box asking for user settings is necessary and, if so,
/// shows the dialog box.
/// </summary>
/// ------------------------------------------------------------------------------------
private bool GetFilterValuesFromUser(ICmFilter userFilter)
{
if (userFilter == null)
return true;
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(
Cache.ServiceLocator.GetInstance<IActionHandler>()))
{
userFilter.ShowPrompt = 0;
undoHelper.RollBack = false;
}
switch (userFilter.FilterName)
{
case "kstidNoteMultiFilter":
using (MultipleFilterDlg dlg = new MultipleFilterDlg(Cache,
m_helpTopicProvider, userFilter))
{
if (dlg.ShowDialog() != DialogResult.OK)
return false;
}
break;
case "kstidCategoryNoteFilter":
using (CategoryFilterDlg dlg = new CategoryFilterDlg(Cache,
m_helpTopicProvider, userFilter))
{
if (dlg.ShowDialog() != DialogResult.OK)
return false;
}
break;
}
return true;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Called when the run checks button is clicked.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="T:System.EventArgs"/> instance containing the event
/// data.</param>
/// ------------------------------------------------------------------------------------
private void OnRunChecks(object sender, EventArgs e)
{
if (!AreAllSelectedChecksRunable)
return;
if (m_bookFilter.BookCount == 0)
{
m_btnRunChecks.Enabled = false;
return;
}
if (RunChecksClick != null)
RunChecksClick(this, EventArgs.Empty);
if (m_ComboBox.DropDown.Visible)
m_ComboBox.HideDropDown();
using (var unitOfWork =
new NonUndoableUnitOfWorkHelper(m_cache.ServiceLocator.GetInstance<IActionHandler>()))
{
Logger.WriteEvent("Running editorial checks");
using (new WaitCursor(Parent))
{
foreach (int bookId in m_bookFilter.BookIds)
{
m_chkDataSource.GetText(bookId, 0);
foreach (IScriptureCheck check in SelectedChecks)
m_chkDataSource.RunCheck(check);
}
m_btnApplyFilter.Enabled = false;
unitOfWork.RollBack = false;
}
}
OnErrorsUpdated();
RefreshCheckTree();
}
// Not much to do except to initialize the edit box embedded in the combobox with
// the proper writing system factory, writing system, and TsString.
public override void SetupCombo()
{
CheckDisposed();
base.SetupCombo();
int hvoEmptyGloss = 0;
ITsStrBldr tsb = TsStrBldrClass.Create();
ComboList.WritingSystemFactory =
m_caches.MainCache.LanguageWritingSystemFactoryAccessor;
// Find the WfiAnalysis (from existing analysis or guess) to provide its word glosses as options (cf. LT-1428)
IWfiAnalysis wa = m_sandbox.GetWfiAnalysisInUse();
if (wa != null)
{
AddComboItems(ref hvoEmptyGloss, tsb, wa);
}
// TODO: Maybe this should merge invisibly with the current top of the undo stack? or start an
// invisible top?
using (var helper = new NonUndoableUnitOfWorkHelper(m_caches.MainCache.ActionHandlerAccessor))
{
var analMethod = m_sandbox.CreateRealWfiAnalysisMethod();
IAnalysis anal = analMethod.Run();
helper.RollBack = false;
if (anal is IWfiAnalysis && anal.Guid != wa.Guid)
{
AddComboItems(ref hvoEmptyGloss, tsb, anal as IWfiAnalysis);
}
Debug.Assert(analMethod.ObsoleteAnalysis == null);
//if (analMethod.ObsoleteAnalysis != null)
//{
// // Should we worry about fixing up a reference in a Segment.AnalysesOC?
// analMethod.ObsoleteAnalysis.Delete();
//}
}
ComboList.Items.Add(new HvoTssComboItem(hvoEmptyGloss,
TsStringUtils.MakeTss(ITextStrings.ksNewWordGloss2, m_caches.MainCache.DefaultUserWs)));
// Set combo selection to current selection.
ComboList.SelectedIndex = this.IndexOfCurrentItem;
// Enhance JohnT: if the analysts decide so, here we add all the other glosses from other analyses.
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// User clicked OK button
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// ------------------------------------------------------------------------------------
private void OnOk(object sender, System.EventArgs e)
{
using (new WaitCursor(this))
{
StepThroughNodesAndAddToList(m_treeView.Nodes[0]);
if (m_BooksToSave.Count == 0)
{
Close();
return;
}
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(
m_cache.ServiceLocator.GetInstance<IActionHandler>()))
{
m_SavedVersion = m_cache.ServiceLocator.GetInstance<IScrDraftFactory>().Create(
m_description.Text, m_BooksToSave);
undoHelper.RollBack = false;
}
Close();
}
}
///-------------------------------------------------------------------------------
/// <summary>
/// When the Source button is clicked, display the import wizard.
/// </summary>
///-------------------------------------------------------------------------------
private void btnSource_Click(object sender, System.EventArgs e)
{
using (ImportWizard importWizard = new ImportWizard(m_scr.Cache.ProjectId.Name,
m_scr, m_StyleSheet, m_helpTopicProvider, m_app))
{
using (NonUndoableUnitOfWorkHelper undoHelper = new NonUndoableUnitOfWorkHelper(ActionHandler))
{
if (importWizard.ShowDialog() == DialogResult.Cancel)
{
// Ditch any in-memory changes made to the settings. Reload from the DB.
m_importSettings.RevertToSaved();
}
else
undoHelper.RollBack = false;
}
// If there are no files after showing the wizard, close the import dialog
if (InitBookNameList() == 0)
{
MessageBox.Show(this, DlgResources.ResourceString("kstidImportFilesUnavailable"),
m_app.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Information);
Close();
return;
}
// The default set of settings may have changed.
m_importSettings = m_scr.DefaultImportSettings;
// Update the file ranges for import because they may have changed.
InitializeStartAndEndRefControls();
// Update the passage controls to reflect the new range of files available
// Only make changes that do not expand the available range of books since a
// range may have been specified before the wizard was run that we do not
// want to overwrite
if (!scrPsgFrom.IsReferenceValid(scrPsgFrom.ScReference))
SetStartRefToFirstImportableBook();
if (!scrPsgTo.IsReferenceValid(scrPsgTo.ScReference))
SetEndRefToLastImportableBook();
}
btnOK.Focus();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Raises the <see cref="E:System.Windows.Forms.Control.HandleCreated"/> event.
/// </summary>
/// <param name="e">An <see cref="T:System.EventArgs"/> that contains the event data.</param>
/// ------------------------------------------------------------------------------------
protected override void OnHandleCreated(EventArgs e)
{
base.OnHandleCreated(e);
try
{
using (NonUndoableUnitOfWorkHelper unitOfWork = new NonUndoableUnitOfWorkHelper(
m_cache.ServiceLocator.GetInstance<IActionHandler>()))
{
m_scrCheckList = InstalledScriptureChecks.GetChecks(m_chkDataSource);
unitOfWork.RollBack = false;
}
}
catch (ApplicationException exception)
{
// REVIEW: what do we do in this case?
Logger.WriteEvent("Got exception loading Scripture checks: ");
Logger.WriteError(exception);
MessageBox.Show(exception.Message, m_app.ApplicationName,
MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
FillAvailableChecksTree(m_scrCheckList);
if (m_checkErrorsList != null)
{
OnErrorsUpdated();
m_btnApplyFilter.Enabled = false;
}
if (m_persistence != null)
OnLoadSettings(m_persistence.SettingsKey);
}
