public void Setup()
{
_tempFolder = new TemporaryFolder();
_filePath = _tempFolder.GetTemporaryFile();
WeSayProjectTestHelper.InitializeForTests();
string[] vernacularWritingSystemIds = new string[]
{
WritingSystemsIdsForTests.VernacularIdForTest
};
_viewTemplate = new ViewTemplate();
_viewTemplate.Add(new Field(Field.FieldNames.EntryLexicalForm.ToString(),
"LexEntry",
vernacularWritingSystemIds));
_viewTemplate.Add(new Field("Note",
"LexEntry",
new string[] { "en" },
Field.MultiplicityType.ZeroOr1,
"MultiText"));
_lexEntryRepository = new LexEntryRepository(_filePath);
EntryViewControl.Factory entryViewFactory = (() => new EntryViewControl());
_dictControlFactory = (memory => new DictionaryControl(entryViewFactory, _lexEntryRepository, _viewTemplate, memory, new StringLogger()));
_taskMemoryRepository = new TaskMemoryRepository();
_task = new DictionaryTask(_dictControlFactory, DictionaryBrowseAndEditConfiguration.CreateForTests("definition"), _lexEntryRepository,
_taskMemoryRepository);
// _task = new DictionaryTask( DictionaryBrowseAndEditConfiguration.CreateForTests(), _lexEntryRepository,
// _viewTemplate, new TaskMemoryRepository(), new StringLogger())};//, new UserSettingsForTask());
}
public GatherBySemanticDomainTask(
GatherBySemanticDomainConfig config,
LexEntryRepository lexEntryRepository,
ViewTemplate viewTemplate,
TaskMemoryRepository taskMemoryRepository,
ILogger logger
) :
base(
config,
lexEntryRepository,
viewTemplate, taskMemoryRepository
)
{
ViewTemplate = viewTemplate;
Guard.AgainstNull(config, "config");
Guard.AgainstNull(viewTemplate, "viewTemplate");
_config = config;
_logger = logger;
_taskMemory = taskMemoryRepository.FindOrCreateSettingsByTaskId(config.TaskName);
_currentDomainIndex = -1;
_currentQuestionIndex = 0;
_words = null;
_semanticDomainField = viewTemplate.GetField(LexSense.WellKnownProperties.SemanticDomainDdp4);
var definitionWsId = viewTemplate.GetField(LexSense.WellKnownProperties.Definition).WritingSystemIds.First();
IWritingSystemDefinition writingSystemForDefinition = viewTemplate.WritingSystems.Get(definitionWsId);
Guard.AgainstNull(writingSystemForDefinition, "Definition input System");
DefinitionWritingSystem = writingSystemForDefinition;
}
public AddPicturesTask(AddPicturesConfig config,
LexEntryRepository lexEntryRepository,
TaskMemoryRepository taskMemoryRepository,
IFileLocator fileLocator)
: base(config, lexEntryRepository, taskMemoryRepository)
{
_config = config;
}
public AdvancedHistoryTask(IAdvancedHistoryConfig config,
LexEntryRepository lexEntryRepository,
TaskMemoryRepository taskMemoryRepository,
IComponentContext diContainer)
: base(config, lexEntryRepository, taskMemoryRepository)
{
_config = config;
_diContainer = diContainer;
}
public void FindOrCreateSettingsByTaskId_NotFound_CreatesNew()
{
using (var dir = new TemporaryFolder("TaskMemoryRepositoryTests"))
{
using (var repo = TaskMemoryRepository.CreateOrLoadTaskMemoryRepository("foo", dir.FolderPath))
{
Assert.IsNotNull(repo.FindOrCreateSettingsByTaskId("NewGuy"));
}
}
}
public void FindOrCreateSettingsByTaskId_FileCorrupt_CreatesNew()
{
using (var dir = new TemporaryFolder("TaskMemoryRepositoryTests"))
{
File.WriteAllText(dir.Combine("foo" + TaskMemoryRepository.FileExtensionWithDot), "I am corrupt");
using (var seeIfWeCanLoad = TaskMemoryRepository.CreateOrLoadTaskMemoryRepository("foo", dir.FolderPath))
{
}
}
}
public void CreateAndDispose_NoExistingFile_LeavesFile()
{
using (var dir = new TemporaryFolder("TaskMemoryRepositoryTests"))
{
using (var repo = TaskMemoryRepository.CreateOrLoadTaskMemoryRepository("foo", dir.FolderPath))
{
Assert.IsNotNull(repo);
}
Assert.IsTrue(File.Exists(dir.Combine("foo" + TaskMemoryRepository.FileExtensionWithDot)));
}
}
public NotesBrowserTask(INotesBrowserConfig config,
LexEntryRepository lexEntryRepository,
TaskMemoryRepository taskMemoryRepository,
System.Func <Chorus.UI.Notes.Browser.NotesBrowserPage> getBrowserPage
)
: base(config, lexEntryRepository, taskMemoryRepository)
{
_getBrowserPage = getBrowserPage;
// _diContainer = diContainer;
}
public void FindOrCreateSettingsByTaskId_IsFound_GivesOldMemory()
{
using (var dir = new TemporaryFolder("TaskMemoryRepositoryTests"))
{
using (var repo = TaskMemoryRepository.CreateOrLoadTaskMemoryRepository("foo", dir.FolderPath))
{
repo.FindOrCreateSettingsByTaskId("NewGuy").Set("color", "blue");
}
using (var repo = TaskMemoryRepository.CreateOrLoadTaskMemoryRepository("foo", dir.FolderPath))
{
Assert.AreEqual("blue", repo.FindOrCreateSettingsByTaskId("NewGuy").Get("color", "blah"));
}
}
}
public GatherWordListTask(IGatherWordListConfig config,
LexEntryRepository lexEntryRepository,
ViewTemplate viewTemplate,
TaskMemoryRepository taskMemoryRepository)
: base(config, lexEntryRepository, viewTemplate, taskMemoryRepository)
{
_viewTemplate = viewTemplate;
Guard.AgainstNull(config.WordListFileName, "config.WordListFileName");
Guard.AgainstNull(config.WordListWritingSystemIdOfOldFlatWordList, "config.WordListWritingSystemIdOfOldFlatWordList");
Guard.AgainstNull(viewTemplate, "viewTemplate");
//enhance: this isn't really true anymore, as we're moving to wordpack (where it's the folder)
//for now, this is figure out more carefully in GetPathToUse
_usingLiftFile = ".lift" == Path.GetExtension(config.WordListFileName).ToLower();
_lexicalUnitWritingSystem =
viewTemplate.GetFirstNonVoiceWritingSystemForFieldOrThrow(Field.FieldNames.EntryLexicalForm.ToString());
_lexemeFormListFileName = config.WordListFileName;
_words = null;
_preferredPromptingWritingSystemId = config.WordListWritingSystemIdOfOldFlatWordList;
var f = viewTemplate.GetField(LexSense.WellKnownProperties.Definition);
Guard.AgainstNull(f, "No field for definition");
_definitionWritingSystemIds = f.WritingSystemIds;
f = viewTemplate.GetField(LexSense.WellKnownProperties.Gloss);
if (f != null)
{
_glossWritingSystemIds = f.WritingSystemIds;
}
else
{
_glossWritingSystemIds = new List <string>();
}
if (f != null && f.IsMeaningField)
{
_glossMeaningField = true;
_meaningWritingSystemIds = _glossWritingSystemIds;
}
else
{
_meaningWritingSystemIds = _definitionWritingSystemIds;
}
if (_meaningWritingSystemIds.Count > 0)
{
_preferredPromptingWritingSystemId = _meaningWritingSystemIds[0];
}
}
public DictionaryTask(DictionaryControl.Factory dictionaryControlFactory,
DictionaryBrowseAndEditConfiguration config,
LexEntryRepository lexEntryRepository,
TaskMemoryRepository taskMemoryRepository)
: base(config, lexEntryRepository, taskMemoryRepository)
{
_dictionaryControlFactory = dictionaryControlFactory;
// if (viewTemplate == null)
// {
// throw new ArgumentNullException("viewTemplate");
// }
// _viewTemplate = viewTemplate;
// _logger = logger;
_taskMemory = taskMemoryRepository.FindOrCreateSettingsByTaskId(config.TaskName);
}
public void PersistThenGet_TwoTasksWithSameKey_GivesCorrectValue()
{
using (var dir = new TemporaryFolder("TaskMemoryRepositoryTests"))
{
using (var repo = TaskMemoryRepository.CreateOrLoadTaskMemoryRepository("foo", dir.FolderPath))
{
repo.FindOrCreateSettingsByTaskId("one").Set("common", "forOne");
repo.FindOrCreateSettingsByTaskId("two").Set("common", "forTwo");
Assert.AreEqual("forOne", repo.FindOrCreateSettingsByTaskId("one").Get("common", "blah"));
Assert.AreEqual("forTwo", repo.FindOrCreateSettingsByTaskId("two").Get("common", "blah"));
}
//now reopen and verify
using (var repo = TaskMemoryRepository.CreateOrLoadTaskMemoryRepository("foo", dir.FolderPath))
{
Assert.AreEqual("forOne", repo.FindOrCreateSettingsByTaskId("one").Get("common", "blah"));
Assert.AreEqual("forTwo", repo.FindOrCreateSettingsByTaskId("two").Get("common", "blah"));
}
}
}
public MissingInfoTask(MissingInfoConfiguration config,
LexEntryRepository lexEntryRepository,
ViewTemplate defaultViewTemplate,
TaskMemoryRepository taskMemoryRepository)
: base(config, lexEntryRepository, taskMemoryRepository)
{
Guard.AgainstNull(config.MissingInfoFieldName, "MissingInfoFieldName");
Guard.AgainstNull(defaultViewTemplate, "viewTemplate");
Debug.Assert(config.WritingSystemsWeWantToFillInArray == null ||
config.WritingSystemsWeWantToFillInArray.Length == 0 ||
!string.IsNullOrEmpty(config.WritingSystemsWeWantToFillInArray[0]));
_config = config;
_taskMemory = taskMemoryRepository.FindOrCreateSettingsByTaskId(config.TaskName);
_missingInfoField = defaultViewTemplate[config.MissingInfoFieldName];
_viewTemplate = config.CreateViewTemplate(defaultViewTemplate);
}
private void StartUserInterface()
{
try
{
_project.AddToContainer(
b => b.Register <StatusBarController>(
container =>
{
var controller = new StatusBarController(container.Resolve <ICountGiver>());
controller.ShowConfigLauncher = _commandLineArguments.launchedByConfigTool;
return(controller);
}));
_project.AddToContainer(b => b.RegisterType <TabbedForm>());
_tabbedForm = _project.Container.Resolve <TabbedForm>();
_tabbedForm.Show(); // so the user sees that we did launch
var versionString = BasilProject.VersionString;
var title = StringCatalog.Get("~WeSay", "It's up to you whether to bother translating this or not.");
if (title != "WeSay")
{
_tabbedForm.Font = (System.Drawing.Font)StringCatalog.LabelFont.Clone();
}
_tabbedForm.Text = String.Format(
"{0} {1}: {2}",
title,
versionString,
_project.Name
);
Application.DoEvents();
//todo: this is what we're supposed to use the autofac "modules" for
//couldn't get this to work: _project.AddToContainer(typeof(ICurrentWorkTask), _tabbedForm as ICurrentWorkTask);
_project.AddToContainer(b => b.RegisterInstance <ICurrentWorkTask>(_tabbedForm));
_project.AddToContainer(b => b.RegisterInstance(_tabbedForm.StatusStrip));
_project.AddToContainer(
b =>
b.RegisterInstance(
TaskMemoryRepository.CreateOrLoadTaskMemoryRepository(
_project.Name, _project.PathToWeSaySpecificFilesDirectoryInProject)));
_project.LoadTasksFromConfigFile();
Application.DoEvents();
_tabbedForm.ContinueLaunchingAfterInitialDisplay();
_tabbedForm.Activate();
_tabbedForm.BringToFront(); //needed if we were previously in server mode
#if (!__MonoCS__)
if (WeSayWordsProject.GeckoOption)
{
// Currently with Gecko 29 on Windows systems, the browser objects do
// not size properly without this process at startup
_tabbedForm.WindowState = FormWindowState.Minimized;
_tabbedForm.WindowState = FormWindowState.Maximized;
}
#endif
RtfRenderer.HeadWordWritingSystemId =
_project.DefaultViewTemplate.HeadwordWritingSystem.Id;
HtmlRenderer.HeadWordWritingSystemId = _project.DefaultViewTemplate.HeadwordWritingSystem.Id;
#if __MonoCS__
UglyHackForXkbIndicator();
#endif
//run the ui
Application.Run(_tabbedForm);
Settings.Default.SkinName = DisplaySettings.Default.SkinName;
}
catch (IOException e)
{
ErrorReport.NotifyUserOfProblem(e.Message);
}
}
