public void Setup()
{
BasilProject.InitializeForTests();
_FilePath = Path.GetTempFileName();
_lexEntryRepository = new LexEntryRepository(_FilePath);
_outputPath = Path.Combine(Path.GetTempPath(), Path.GetTempFileName());
_writingSystemIds = new List<string>(new string[] {"red", "green", "blue"});
_headwordWritingSystem = new WritingSystem(_writingSystemIds[0],
new Font(FontFamily.GenericSansSerif, 10));
_viewTemplate = new ViewTemplate();
_viewTemplate.Add(new Field(LexEntry.WellKnownProperties.Citation,
"LexEntry",
new string[] {"blue", "red"}));
_viewTemplate.Add(new Field(LexEntry.WellKnownProperties.LexicalUnit,
"LexEntry",
new string[] {"red", "green", "blue"}));
_viewTemplate.Add(new Field(LexEntry.WellKnownProperties.BaseForm,
"LexEntry",
_writingSystemIds));
Field visibleCustom = new Field("VisibleCustom",
"LexEntry",
_writingSystemIds,
Field.MultiplicityType.ZeroOr1,
"MultiText");
visibleCustom.Visibility = CommonEnumerations.VisibilitySetting.Visible;
visibleCustom.DisplayName = "VisibleCustom";
_viewTemplate.Add(visibleCustom);
}
public void Setup()
{
Field field = new Field(Field.FieldNames.ExampleTranslation.ToString(),
"LexExampleSentence",
new string[] {"analysis"});
_missingExampleTranslationFilter = new MissingFieldQuery(field);
}
public void Setup()
{
Field field = new Field(LexSense.WellKnownProperties.Definition,
"LexSense",
new string[] {"analysis"});
_missingMeaningFilter = new MissingFieldQuery(field);
}
public void Setup()
{
Field field = new Field(Field.FieldNames.ExampleSentence.ToString(),
"LexExampleSentence",
new string[] {"vernacular"});
_missingExampleSentenceFilter = new MissingFieldQuery(field);
}
public void Setup()
{
Field field = new Field(Field.FieldNames.EntryLexicalForm.ToString(),
"LexEntry",
new string[] {"vernacular"});
_missingLexicalFormFilter = new MissingFieldQuery(field);
}
public void Setup()
{
WeSayWordsProject.InitializeForTests();
_tempFolder = new TemporaryFolder();
_filePath = _tempFolder.GetTemporaryFile();
_lexEntryRepository = new LexEntryRepository(_filePath);
_target = CreateEntry("one", "single item");
_source = CreateEntry("single", "one item");
CreateEntry("verde", "green");
CreateEntry("amarelho", "yellow");
CreateEntry("azul", "blue");
_synonymsRelationField = new Field("synonyms",
"LexEntry",
new string[] {"vernacular"},
Field.MultiplicityType.ZeroOrMore,
"RelationToOneEntry");
_synonymsRelationType = new LexRelationType("synonyms",
LexRelationType.Multiplicities.Many,
LexRelationType.TargetTypes.Sense);
_singleSynonymRelationField = new Field("synonym",
"LexEntry",
new string[] {"vernacular"},
Field.MultiplicityType.ZeroOr1,
"RelationToOneEntry");
_singleSynonymRelationType = new LexRelationType("synonym",
LexRelationType.Multiplicities.One,
LexRelationType.TargetTypes.Sense);
}
public void Setup()
{
BasilProject.InitializeForTests();
_control = new FieldDetailControl();
_field = new Field("test", "LexEntry", new string[] {"en_US"});
_control.CurrentField = _field;
}
public MissingInfoTask(MissingInfoConfiguration config,
LexEntryRepository lexEntryRepository,
ViewTemplate viewTemplate)
: base( config, lexEntryRepository)
{
if (config.MissingInfoField == null)
{
throw new ArgumentNullException("MissingInfoField");
}
if (viewTemplate == null)
{
throw new ArgumentNullException("viewTemplate");
}
_missingInfoField = viewTemplate[config.MissingInfoField];
_viewTemplate = CreateViewTemplateFromListOfFields(viewTemplate, config.FieldsToShow);
MarkReadOnlyFields(config.FieldsToShowReadOnly);
//hack until we overhaul how Tasks are setup:
_isBaseFormFillingTask = config.FieldsToShow.Contains(LexEntry.WellKnownProperties.BaseForm);
if (_isBaseFormFillingTask)
{
Field flagField = new Field();
flagField.DisplayName = StringCatalog.Get("~This word has no Base Form",
"The user will click this to say that this word has no baseform. E.g. Kindess has Kind as a baseform, but Kind has no other word as a baseform.");
flagField.DataTypeName = "Flag";
flagField.ClassName = "LexEntry";
flagField.FieldName = "flag_skip_" + config.MissingInfoField;
flagField.Enabled = true;
_viewTemplate.Add(flagField);
}
_writingSystem = BasilProject.Project.WritingSystems.UnknownVernacularWritingSystem;
// use the master view Template instead of the one for this task. (most likely the one for this
// task doesn't have the EntryLexicalForm field specified but the Master (Default) one will
Field fieldDefn =
WeSayWordsProject.Project.DefaultViewTemplate.GetField(
Field.FieldNames.EntryLexicalForm.ToString());
if (fieldDefn != null)
{
if (fieldDefn.WritingSystemIds.Count > 0)
{
_writingSystem = BasilProject.Project.WritingSystems[fieldDefn.WritingSystemIds[0]];
}
else
{
throw new ConfigurationException("There are no writing systems enabled for the Field '{0}'",
fieldDefn.FieldName);
}
}
}
public void SerializedFieldHasExpectedXml()
{
Field f = new Field("one", "LexEntry", new string[] {"xx", "yy"});
string s = NetReflector.Write(f);
XmlDocument doc = new XmlDocument();
doc.LoadXml(s);
Assert.AreEqual(1, doc.SelectNodes("field/fieldName").Count);
Assert.AreEqual("one", doc.SelectNodes("field/fieldName")[0].InnerText);
Assert.AreEqual("Visible", doc.SelectNodes("field/visibility")[0].InnerText);
Assert.AreEqual(2, doc.SelectNodes("field/writingSystems/id").Count);
Assert.AreEqual("xx", doc.SelectNodes("field/writingSystems/id")[0].InnerText);
Assert.AreEqual("yy", doc.SelectNodes("field/writingSystems/id")[1].InnerText);
}
public void Setup()
{
_tempFolder = new TemporaryFolder();
_filePath = _tempFolder.GetTemporaryFile();
_lexEntryRepository = new LexEntryRepository(_filePath);
_target = _lexEntryRepository.CreateItem();
_source = _lexEntryRepository.CreateItem();
Field relationField = new Field("synonyms",
"LexEntry",
new string[] {"vernacular"},
Field.MultiplicityType.ZeroOr1,
"RelationToOneEntry");
_missingRelationFieldFilter = new MissingFieldQuery(relationField);
}
private static ViewTemplate MakeViewTemplate(string nameAndQuestionWritingSystem)
{
Field semanticDomainField = new Field(LexSense.WellKnownProperties.SemanticDomainsDdp4,
"LexSense",
new string[] {nameAndQuestionWritingSystem});
semanticDomainField.OptionsListFile = "Ddp4.xml";
semanticDomainField.DataTypeName = "OptionRefCollection";
ViewTemplate v = new ViewTemplate();
Field lexicalFormField = new Field(Field.FieldNames.EntryLexicalForm.ToString(),
"LexEntry",
new string[] {"br"});
lexicalFormField.DataTypeName = "MultiText";
v.Add(lexicalFormField);
v.Add(semanticDomainField);
return v;
}
public void SetUp()
{
WeSayWordsProject.InitializeForTests();
_tempFolder = new TemporaryFolder();
_filePath = _tempFolder.GetTemporaryFile();
_lexEntryRepository = new LexEntryRepository(_filePath);
_writingSystem = new WritingSystem("pretendVernacular",
new Font(FontFamily.GenericSansSerif, 24));
CreateTestEntry("apple", "red thing", "An apple a day keeps the doctor away.");
CreateTestEntry("banana", "yellow food", "Monkeys like to eat bananas.");
CreateTestEntry("car",
"small motorized vehicle",
"Watch out for cars when you cross the street.");
CreateTestEntry("dog", "animal with four legs; man's best friend", "He walked his dog.");
string[] analysisWritingSystemIds = new string[] {"analysis"};
string[] vernacularWritingSystemIds = new string[] {_writingSystem.Id};
RtfRenderer.HeadWordWritingSystemId = vernacularWritingSystemIds[0];
_viewTemplate = new ViewTemplate();
_viewTemplate.Add(new Field(Field.FieldNames.EntryLexicalForm.ToString(),
"LexEntry",
vernacularWritingSystemIds));
_viewTemplate.Add(new Field(LexSense.WellKnownProperties.Definition,
"LexSense",
analysisWritingSystemIds));
_viewTemplate.Add(new Field(Field.FieldNames.ExampleSentence.ToString(),
"LexExampleSentence",
vernacularWritingSystemIds));
Field exampleTranslationField = new Field(
Field.FieldNames.ExampleTranslation.ToString(),
"LexExampleSentence",
analysisWritingSystemIds);
_viewTemplate.Add(exampleTranslationField);
_missingTranslationRecordList =
_lexEntryRepository.GetEntriesWithMissingFieldSortedByLexicalUnit(
exampleTranslationField, _writingSystem);
}
public void MakeFieldNameChange_FileLocked_NotifiesUser()
{
using (ProjectDirectorySetupForTesting p = new ProjectDirectorySetupForTesting("<entry id='foo1'><lexical-unit><form lang='v'><text>fooOne</text></form></lexical-unit></entry>"))
{
WeSayWordsProject project = p.CreateLoadedProject();
using (File.OpenWrite(p.PathToLiftFile))
{
using (new Palaso.Reporting.ErrorReport.NonFatalErrorReportExpected())
{
Field f = new Field("old", "LexEntry", new string[] {"en"});
project.ViewTemplates[0].Add(f);
project.Save();
f.FieldName = "new";
Assert.IsFalse(project.MakeFieldNameChange(f, "old"));
}
}
}
}
public void HiddenFields_AreNotOutput()
{
LexEntry e1 = _lexEntryRepository.CreateItem();
e1.LexicalForm["test"] = "sunset";
e1.GetOrCreateProperty<MultiText>("color").SetAlternative(_writingSystemIds[0], "red");
_lexEntryRepository.SaveItem(e1);
Field color = new Field("color",
"LexEntry",
_writingSystemIds,
Field.MultiplicityType.ZeroOr1,
"MultiText");
color.DisplayName = "color";
_viewTemplate.Add(color);
Make(_viewTemplate, _outputPath);
AssertXPathNotNull(_outputPath,
"lift/entry[@id='" + e1.Id + "']/field[@type='" + "color" + "']");
//now make it invisible and it should disappear
_viewTemplate.GetField("color").Enabled = false;
Make(_viewTemplate, _outputPath);
AssertNoMatchForXPath(_outputPath, "lift/entry[@id='" + e1.Id + "']/field");
}
public void CorrectFieldToOptionListNameDictionary()
{
using (ProjectDirectorySetupForTesting p = new ProjectDirectorySetupForTesting(""))
{
Field f = new Field();
f.OptionsListFile = "PartsOfSpeech.xml";
WeSayWordsProject project = p.CreateLoadedProject();
Dictionary<string, string> dict = project.GetFieldToOptionListNameDictionary();
Assert.AreEqual("PartsOfSpeech", dict[LexSense.WellKnownProperties.PartOfSpeech]);
}
}
public OptionsList GetOptionsList(Field field, bool createIfFileMissing)
{
if (String.IsNullOrEmpty(field.OptionsListFile))
{
throw new ConfigurationException(
"The administrator needs to declare an options list file for the field {0}. This can be done under the Fields tab of the WeSay Configuration Tool.",
field.FieldName);
}
OptionsList list;
if (_optionLists.TryGetValue(field.OptionsListFile, out list))
{
return list;
}
string pathInProject = Path.Combine(PathToWeSaySpecificFilesDirectoryInProject,
field.OptionsListFile);
if (File.Exists(pathInProject))
{
LoadOptionsList(pathInProject);
}
else
{
string pathInProgramDir = Path.Combine(ApplicationCommonDirectory,
field.OptionsListFile);
if (!File.Exists(pathInProgramDir))
{
if (createIfFileMissing)
{
list = new OptionsList();
_optionLists.Add(Path.GetFileName(pathInProject), list);
return list;
}
else
{
throw new ConfigurationException(
"Could not find the optionsList file {0}. Expected to find it at: {1} or {2}",
field.OptionsListFile,
pathInProject,
pathInProgramDir);
}
}
LoadOptionsList(pathInProgramDir);
}
return _optionLists[field.OptionsListFile];
}
public bool MakeFieldNameChange(Field field, string oldName)
{
Debug.Assert(!String.IsNullOrEmpty(oldName));
if (string.IsNullOrEmpty(oldName))
{
return false;
}
oldName = Regex.Escape(oldName);
//NB: we're just using regex, here, not xpaths which in this case
//would be nice (e.g., "name" is a pretty generic thing to be changing)
return DoSomethingToLiftFile((p) =>
{
//traits
if (field.DataTypeName == Field.BuiltInDataType.Option.ToString() ||
field.DataTypeName ==
Field.BuiltInDataType.OptionCollection.ToString())
{
GrepFile(p,
string.Format("name\\s*=\\s*[\"']{0}[\"']", oldName),
string.Format("name=\"{0}\"", field.FieldName));
}
else
{
//<field>s
GrepFile(p,
string.Format("type\\s*=\\s*[\"']{0}[\"']", oldName),
string.Format("type=\"{0}\"", field.FieldName));
}
});
return true;
}
public static void ModifyMasterFromUser(Field master, Field user)
{
// this worked so long as the master had all possible valid writing systems in each field
// master.WritingSystemIds = GetIntersectionOfWsIdLists(master, user);
master.WritingSystemIds = user.WritingSystemIds;
master.Visibility = user.Visibility;
}
public Field(Field field)
{
FieldName = field.FieldName;
ClassName = field.ClassName;
_writingSystemIds = new List<string>();
foreach (string id in field.WritingSystemIds)
{
WritingSystemIds.Add(id);
}
Description = field.Description;
DisplayName = field.DisplayName;
Multiplicity = field.Multiplicity;
Visibility = field.Visibility;
DataTypeName = field.DataTypeName;
OptionsListFile = field.OptionsListFile;
Enabled = field.Enabled;
}
private void MarkReadOnlyFields(string fieldsToShowReadOnly)
{
string[] readOnlyFields = SplitUpFieldNames(fieldsToShowReadOnly);
for (int i = 0;i < _viewTemplate.Count;i++)
{
Field field = _viewTemplate[i];
foreach (string s in readOnlyFields)
{
if (s == field.FieldName)
{
Field readOnlyVersion = new Field(field);
readOnlyVersion.Visibility = CommonEnumerations.VisibilitySetting.ReadOnly;
_viewTemplate.Remove(field);
_viewTemplate.Insert(i, readOnlyVersion);
}
}
}
}
private void AddWritingSystemToPicker(WritingSystem writingSystem, Field field)
{
MenuItem item =
new MenuItem(writingSystem.Id + "\t" + StringCatalog.Get(field.DisplayName),
OnCmWritingSystemClicked);
item.RadioCheck = true;
item.Tag = writingSystem;
_cmWritingSystems.MenuItems.Add(item);
}
private DetailList MakeDetailList(bool showNormallyHiddenFields)
{
string[] analysisWritingSystemIds = new string[]
{
BasilProject.Project.WritingSystems.
TestWritingSystemAnalId
};
string[] vernacularWritingSystemIds = new string[]
{
BasilProject.Project.WritingSystems.
TestWritingSystemVernId
};
ViewTemplate viewTemplate = new ViewTemplate();
Field field = new Field(Field.FieldNames.EntryLexicalForm.ToString(),
"LexEntry",
vernacularWritingSystemIds);
field.DisplayName = "Word";
viewTemplate.Add(field);
#if GlossMeaning
string meaningFieldName = Field.FieldNames.SenseGloss.ToString();
#else
string meaningFieldName = LexSense.WellKnownProperties.Definition;
#endif
viewTemplate.Add(new Field(meaningFieldName, "LexSense", analysisWritingSystemIds));
viewTemplate.Add(new Field(Field.FieldNames.ExampleSentence.ToString(),
"LexExampleSentence",
vernacularWritingSystemIds));
viewTemplate.Add(new Field(Field.FieldNames.ExampleTranslation.ToString(),
"LexExampleSentence",
analysisWritingSystemIds));
Field rare = new Field("rare", "LexSense", analysisWritingSystemIds);
rare.Visibility = CommonEnumerations.VisibilitySetting.NormallyHidden;
viewTemplate.Add(rare);
//TODO need tests for other data types when made optional
//TODO need tests for showing non-empty optional tests in non-show-all mode
LexEntry entry = GetNewEntry();
DetailList dl = new DetailList();
LexEntryLayouter layout = new LexEntryLayouter(dl, viewTemplate, null);
layout.ShowNormallyHiddenFields = showNormallyHiddenFields;
_rowCount = layout.AddWidgets(entry);
return dl;
}
public GatherBySemanticDomainTask(IGatherBySemanticDomainsConfig config,
LexEntryRepository lexEntryRepository,
ViewTemplate viewTemplate)
: base(
config,
lexEntryRepository,
viewTemplate)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (string.IsNullOrEmpty(config.semanticDomainsQuestionFileName))
{
throw new ArgumentNullException("config.semanticDomainsQuestionFileName");
}
if (viewTemplate == null)
{
throw new ArgumentNullException("viewTemplate");
}
_currentDomainIndex = -1;
_currentQuestionIndex = 0;
_words = null;
_semanticDomainQuestionsFileName =
DetermineActualQuestionsFileName(config.semanticDomainsQuestionFileName);
if (!File.Exists(_semanticDomainQuestionsFileName))
{
string pathInProject =
Path.Combine(
WeSayWordsProject.Project.PathToWeSaySpecificFilesDirectoryInProject,
_semanticDomainQuestionsFileName);
if (File.Exists(pathInProject))
{
_semanticDomainQuestionsFileName = pathInProject;
}
else
{
string pathInProgramDir = Path.Combine(BasilProject.ApplicationCommonDirectory,
_semanticDomainQuestionsFileName);
if (!File.Exists(pathInProgramDir))
{
throw new ApplicationException(
string.Format(
"Could not find the semanticDomainQuestions file {0}. Expected to find it at: {1} or {2}. The name of the file is influenced by the first enabled writing system for the Semantic Domain Field.",
_semanticDomainQuestionsFileName,
pathInProject,
pathInProgramDir));
}
_semanticDomainQuestionsFileName = pathInProgramDir;
}
}
_semanticDomainField = viewTemplate.GetField("SemanticDomainDdp4");
}
private static ViewTemplate MakeSampleInventory()
{
ViewTemplate f = new ViewTemplate();
f.Add(new Field(Field.FieldNames.EntryLexicalForm.ToString(),
"LexEntry",
new string[] {"xx", "yy"}));
Field field = new Field(LexSense.WellKnownProperties.Gloss,
"LexSense",
new string[] {"zz"});
field.Enabled = false;
//field.Visibility = CommonEnumerations.VisibilitySetting.Invisible;
f.Add(field);
return f;
}
public void LoadPartsOfSpeechList()
{
using (ProjectDirectorySetupForTesting p = new ProjectDirectorySetupForTesting(""))
{
// WeSayWordsProject p = CreateAndLoad();
Field f = new Field();
f.OptionsListFile = "PartsOfSpeech.xml";
OptionsList list = p.CreateLoadedProject().GetOptionsList(f, false);
Assert.IsTrue(list.Options.Count > 2);
}
}
private static string RenderField(MultiText text,
CurrentItemEventArgs currentItem,
int sizeBoost,
Field field)
{
StringBuilder rtfBuilder = new StringBuilder();
if (text != null)
{
if (text.Count == 0 && currentItem != null && text == currentItem.DataTarget)
{
rtfBuilder.Append(RenderBlankPosition());
}
if (field == null) // show them all
{
foreach (LanguageForm l in text)
{
RenderForm(text, currentItem, rtfBuilder, l, sizeBoost);
}
}
else //todo: show all those turned on for the field?
{
LanguageForm form = text.GetBestAlternative(field.WritingSystemIds);
if (form != null)
{
RenderForm(text, currentItem, rtfBuilder, form, sizeBoost);
}
}
}
return rtfBuilder.ToString();
}
private void LoadList(Field field)
{
try
{
SaveCurrentList();
_currentField = field;
_currentList = WeSayWordsProject.Project.GetOptionsList(_currentField, true);
_listBox.Items.Clear();
_currentListWasModified = false;
foreach (Option option in _currentList.Options)
{
_listBox.Items.Add(option.GetDisplayProxy(PreferredWritingSystem));
}
if (_listBox.Items.Count > 0)
{
_listBox.SelectedIndex = 0;
}
_fieldChooser.SelectedItem = field;
UpdateDisplay();
}
catch (ConfigurationException e)
{
ErrorReport.ReportNonFatalMessage(e.Message);
}
}
public override void Setup()
{
base.Setup();
_tempFolder = new TemporaryFolder();
_vernacularWritingSystem =
new WritingSystem(BasilProject.Project.WritingSystems.TestWritingSystemVernId,
SystemFonts.DefaultFont);
RtfRenderer.HeadWordWritingSystemId = _vernacularWritingSystem.Id;
_filePath = _tempFolder.GetTemporaryFile();
_lexEntryRepository = new LexEntryRepository(_filePath);
string[] analysisWritingSystemIds = new string[]
{
BasilProject.Project.WritingSystems.
TestWritingSystemAnalId
};
string[] vernacularWritingSystemIds = new string[] {_vernacularWritingSystem.Id};
ViewTemplate viewTemplate = new ViewTemplate();
viewTemplate.Add(new Field(Field.FieldNames.EntryLexicalForm.ToString(),
"LexEntry",
vernacularWritingSystemIds));
viewTemplate.Add(new Field("focusOnMe",
"LexEntry",
analysisWritingSystemIds,
Field.MultiplicityType.ZeroOr1,
"MultiText"));
viewTemplate.Add(new Field("MyEntryCustom",
"LexEntry",
analysisWritingSystemIds,
Field.MultiplicityType.ZeroOr1,
"MultiText"));
Field readOnlySemanticDomain =
new Field(LexSense.WellKnownProperties.SemanticDomainsDdp4,
"LexSense",
analysisWritingSystemIds);
readOnlySemanticDomain.Visibility = CommonEnumerations.VisibilitySetting.ReadOnly;
viewTemplate.Add(readOnlySemanticDomain);
Field shy1 = new Field("MyShyEntryCustom",
"LexEntry",
analysisWritingSystemIds,
Field.MultiplicityType.ZeroOr1,
"MultiText");
shy1.Visibility = CommonEnumerations.VisibilitySetting.NormallyHidden;
shy1.DisplayName = "MyShyEntryCustom";
viewTemplate.Add(shy1);
#if GlossMeaning
viewTemplate.Add(new Field(Field.FieldNames.SenseGloss.ToString(), "LexSense", analysisWritingSystemIds));
#else
_definitionField = new Field(LexSense.WellKnownProperties.Definition,
"LexSense",
analysisWritingSystemIds);
viewTemplate.Add(_definitionField);
#endif
viewTemplate.Add(new Field("MySenseCustom",
"LexSense",
analysisWritingSystemIds,
Field.MultiplicityType.ZeroOr1,
"MultiText"));
viewTemplate.Add(new Field(Field.FieldNames.ExampleSentence.ToString(),
"LexExampleSentence",
vernacularWritingSystemIds));
viewTemplate.Add(new Field(Field.FieldNames.ExampleTranslation.ToString(),
"LexExampleSentence",
analysisWritingSystemIds));
_firstEntryGuid = AddEntry("Initial", analysisWritingSystemIds[0], "meaning", true);
_secondEntryGuid = AddEntry("Secondary", analysisWritingSystemIds[0], "secondarymeaning", false);
AddEntry("Tertiary", analysisWritingSystemIds[0], "meaning", true);
Field customField = new Field("SemanticDomains",
"LexSense",
analysisWritingSystemIds,
Field.MultiplicityType.ZeroOr1,
"OptionCollection");
customField.DisplayName = "Sem Dom";
customField.OptionsListFile = "SemanticDomains.xml";
viewTemplate.Add(customField);
Field customPOSField = new Field(LexSense.WellKnownProperties.PartOfSpeech,
"LexSense",
analysisWritingSystemIds,
Field.MultiplicityType.ZeroOr1,
"Option");
customPOSField.DisplayName = "POS";
customPOSField.OptionsListFile = "PartsOfSpeech.xml";
viewTemplate.Add(customPOSField);
Field customNotesField = new Field(WeSayDataObject.WellKnownProperties.Note,
"LexSense",
analysisWritingSystemIds);
customNotesField.DisplayName = "s-note";
viewTemplate.Add(customNotesField);
Field exampleNotesField = new Field(WeSayDataObject.WellKnownProperties.Note,
"LexExampleSentence",
analysisWritingSystemIds);
exampleNotesField.DisplayName = "ex-note";
viewTemplate.Add(exampleNotesField);
_task = new DictionaryTask(DictionaryBrowseAndEditConfiguration.CreateForTests(), _lexEntryRepository, viewTemplate);//, new UserSettingsForTask());
_detailTaskPage = new TabPage();
ActivateTask();
_tabControl = new TabControl();
_tabControl.Dock = DockStyle.Fill;
_tabControl.TabPages.Add(_detailTaskPage);
_tabControl.TabPages.Add(new TabPage("Dummy"));
_window = new Form();
_window.Controls.Add(_tabControl);
_window.Width = 700;
_window.Height = 500;
_window.Show();
}
private static void TryFieldNameChangeAfterMakingSafe(string oldName, string newName)
{
using (
ProjectDirectorySetupForTesting dir =
new ProjectDirectorySetupForTesting(string.Empty))
{
WeSayWordsProject p = dir.CreateLoadedProject();
p.ViewTemplates.Add(new ViewTemplate());
oldName = Field.MakeFieldNameSafe(oldName);
newName = Field.MakeFieldNameSafe(newName);
Field f = new Field(oldName, "LexEntry", new string[] {"en"});
p.ViewTemplates[0].Add(f);
using (File.OpenWrite(dir.PathToConfigFile))
{
}
p.Save();
f.FieldName = newName;
p.MakeFieldNameChange(f, oldName);
}
}
private static ViewTemplate CreateViewTemplateFromListOfFields(IEnumerable<Field> fieldList,
string fieldsToShow)
{
string[] fields = SplitUpFieldNames(fieldsToShow);
ViewTemplate viewTemplate = new ViewTemplate();
foreach (Field field in fieldList)
{
if (Array.IndexOf(fields, field.FieldName) >= 0)
{
if (field.Enabled == false)
//make sure specified fields are shown (greg's ws-356)
{
Field enabledField = new Field(field);
enabledField.Visibility = CommonEnumerations.VisibilitySetting.Visible;
enabledField.Enabled = true;
viewTemplate.Add(enabledField);
}
else
{
if (field.Visibility != CommonEnumerations.VisibilitySetting.Visible)
//make sure specified fields are visible (not in 'rare mode)
{
Field visibleField = new Field(field);
visibleField.Visibility = CommonEnumerations.VisibilitySetting.Visible;
viewTemplate.Add(visibleField);
}
else
{
viewTemplate.Add(field);
}
}
}
}
return viewTemplate;
}
