public void SetDefaultWs_PreservesCheckState()
{
var model = new FwNewLangProjectModel(true)
{
LoadProjectNameSetup = () => { },
LoadVernacularSetup = () => { },
ProjectName = DbName
};
model.Next();
var french = new CoreWritingSystemDefinition("fr");
var esperanto = new CoreWritingSystemDefinition("eo");
var english = new CoreWritingSystemDefinition("en");
model.WritingSystemContainer.AddToCurrentVernacularWritingSystems(french); // selected
model.WritingSystemContainer.AddToCurrentVernacularWritingSystems(esperanto); // selected
model.WritingSystemContainer.VernacularWritingSystems.Add(english); // deselected
model.SetDefaultWs(new LanguageInfo {
LanguageTag = "de"
});
Assert.That(model.WritingSystemContainer.VernacularWritingSystems.Count, Is.EqualTo(3), "should be three total");
Assert.That(model.WritingSystemContainer.VernacularWritingSystems.First().LanguageTag, Is.EqualTo("de"), "first should be German");
Assert.That(model.WritingSystemContainer.VernacularWritingSystems.Contains(esperanto), "should contain Esperanto");
Assert.That(model.WritingSystemContainer.VernacularWritingSystems.Contains(english), "should contain English");
Assert.That(model.WritingSystemContainer.CurrentVernacularWritingSystems.Count, Is.EqualTo(2), "should be two selected");
Assert.That(model.WritingSystemContainer.CurrentVernacularWritingSystems[0].LanguageTag, Is.EqualTo("de"), "default should be German");
Assert.Contains(esperanto, (ICollection)model.WritingSystemContainer.CurrentVernacularWritingSystems, "Esperanto should be selected");
}
public void SetDefaultWs_Analysis()
{
var model = new FwNewLangProjectModel(true)
{
LoadProjectNameSetup = () => { },
LoadVernacularSetup = () => { },
LoadAnalysisSetup = () => { },
ProjectName = DbName
};
model.Next();
model.WritingSystemContainer.AddToCurrentVernacularWritingSystems(new CoreWritingSystemDefinition("fr"));
model.Next();
// English is the default Analysis WS, so we do not need to set it here.
Assert.That(model.WritingSystemContainer.AnalysisWritingSystems.Count, Is.EqualTo(1), "Test setup problem");
Assert.That(model.WritingSystemContainer.AnalysisWritingSystems.First().LanguageTag, Is.EqualTo("en"), "Test setup problem");
Assert.That(model.WritingSystemContainer.CurrentAnalysisWritingSystems.Count, Is.EqualTo(1), "Test setup problem");
Assert.That(model.WritingSystemContainer.CurrentAnalysisWritingSystems.First().LanguageTag, Is.EqualTo("en"), "Test setup problem");
model.SetDefaultWs(new LanguageInfo {
LanguageTag = "de"
});
Assert.That(model.WritingSystemContainer.AnalysisWritingSystems.Count, Is.EqualTo(1), "all");
Assert.That(model.WritingSystemContainer.AnalysisWritingSystems.First().LanguageTag, Is.EqualTo("de"), "should be German");
Assert.That(model.WritingSystemContainer.CurrentAnalysisWritingSystems.Count, Is.EqualTo(1), "current");
Assert.That(model.WritingSystemContainer.CurrentAnalysisWritingSystems[0].LanguageTag, Is.EqualTo("de"), "default should be German");
}
private void BindWizardStepControls(FwNewLangProjectModel model)
{
if (model == null) // Designer
{
return;
}
_stepsPanel.ColumnCount = model.Steps.Count();
for (var index = 0; index < model.Steps.Count(); ++index)
{
if (_stepsPanel.Controls.Count < model.Steps.Count())
{
var stepControl = new WizardStep();
stepControl.Bind(model.Steps.ElementAt(index), index == 0, index == model.Steps.Count() - 1);
if (_stepsPanel.ColumnStyles.Count <= index)
{
_stepsPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, stepControl.Width));
}
else
{
_stepsPanel.ColumnStyles[index].SizeType = SizeType.Absolute;
_stepsPanel.ColumnStyles[index].Width = stepControl.Width;
}
_stepsPanel.Controls.Add(stepControl, index, 0);
}
else
{
var stepControl = (WizardStep)_stepsPanel.Controls[index];
stepControl.Bind(model.Steps.ElementAt(index), index == 0, index == model.Steps.Count() - 1);
}
}
}
public void FwNewLangProjectModel_ProjectNameIsUnique()
{
try
{
CreateDb(DbName);
string errorMessage;
Assert.True(FwNewLangProjectModel.CheckForUniqueProjectName("something else"), "unique name should be unique");
Assert.False(FwNewLangProjectModel.CheckForUniqueProjectName(DbName), "duplicate name should not be unique");
// Creating a new project is expensive (several seconds), so test this property that also checks uniqueness here:
var testModel = new FwNewLangProjectModel
{
LoadProjectNameSetup = () => { },
ProjectName = "something new"
};
Assert.True(testModel.IsProjectNameValid, "unique name should be valid");
testModel.ProjectName = DbName;
Assert.False(testModel.IsProjectNameValid, "duplicate name should not be valid");
}
finally
{
// Blow away the database to clean things up
DestroyDb(DbName, false);
}
}
private void Bind(FwNewLangProjectModel model)
{
BindWizardStepControls(model);
_previous.Enabled = model.CanGoBack();
_next.Enabled = model.CanGoNext();
btnOK.Enabled = model.CanFinish();
}
public void FwNewLangProjectModel_VernacularAndAnalysisSame_WarningIssued()
{
bool warningIssued = false;
var model = new FwNewLangProjectModel();
model.LoadProjectNameSetup = () => { };
model.LoadVernacularSetup = () => { };
model.LoadAnalysisSetup = () => { };
model.LoadAnalysisSameAsVernacularWarning = () => { warningIssued = true; };
model.ProjectName = DbName;
var fakeTestWs = new CoreWritingSystemDefinition("fr");
model.WritingSystemContainer.CurrentVernacularWritingSystems.Add(fakeTestWs);
model.WritingSystemContainer.VernacularWritingSystems.Add(fakeTestWs);
model.WritingSystemContainer.CurrentAnalysisWritingSystems.Add(fakeTestWs);
model.WritingSystemContainer.AnalysisWritingSystems.Add(fakeTestWs);
Assert.True(model.CanGoNext());
model.Next(); // Move to choose default vernacular
Assert.True(model.CanGoNext());
model.Next(); // Move to choose default analysis
model.SetDefaultWs(new LanguageInfo()
{
LanguageTag = "fr"
});
Assert.True(warningIssued, "Warning for analysis same as vernacular not triggered");
Assert.True(model.CanGoNext()); // The user can ignore the warning
}
public void FwNewLangProjectModel_CannotClickFinishWithBlankProjectName()
{
var model = new FwNewLangProjectModel();
model.LoadProjectNameSetup = () => { };
model.LoadVernacularSetup = () => { };
model.LoadAnalysisSetup = () => { };
model.LoadAdvancedWsSetup = () => { };
model.LoadAnthropologySetup = () => { };
model.ProjectName = DbName;
var fakeTestWs = new CoreWritingSystemDefinition("fr");
model.WritingSystemContainer.CurrentVernacularWritingSystems.Add(fakeTestWs);
model.WritingSystemContainer.VernacularWritingSystems.Add(fakeTestWs);
model.WritingSystemContainer.CurrentAnalysisWritingSystems.Add(fakeTestWs);
model.WritingSystemContainer.AnalysisWritingSystems.Add(fakeTestWs);
Assert.True(model.CanGoNext());
model.Next(); // Vernacular
model.Next(); // Analysis
Assert.True(model.CanFinish());
model.Back();
model.Back();
model.ProjectName = "";
Assert.False(model.CanFinish());
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Update the name when the data changes.
/// </summary>
/// ------------------------------------------------------------------------------------
private void m_txtProjName_TextChanged(object sender, EventArgs e)
{
// If the project name is unchanged (or changed back), don't check for validity. (This will allow users who have already
// given their projects non-ASCII names to change other project properties without having to change their project names)
if (!OriginalProjectName.Equals(m_txtProjName.Text))
{
string errorMessage;
var projectName = m_txtProjName.Text;
if (!FwNewLangProjectModel.CheckForSafeProjectName(ref projectName, out errorMessage))
{
MessageBox.Show(errorMessage, FwCoreDlgs.FwProjProperties_PickDifferentProjName, MessageBoxButtons.OK, MessageBoxIcon.Error);
m_txtProjName.TextChanged -= m_txtProjName_TextChanged;
m_txtProjName.Text = projectName;
m_txtProjName.TextChanged += m_txtProjName_TextChanged;
}
if (!FwNewLangProjectModel.CheckForUniqueProjectName(projectName))
{
MessageBox.Show(string.Format(FwCoreDlgs.FwProjProperties_DuplicateProjectName, projectName, OriginalProjectName),
FwCoreDlgs.FwProjProperties_PickDifferentProjName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
m_btnOK.Enabled = m_txtProjName.Text.Trim().Length > 0 &&
(OriginalProjectName.Equals(m_txtProjName.Text) || FwNewLangProjectModel.CheckForUniqueProjectName(m_txtProjName.Text));
m_lblProjName.Text = m_txtProjName.Text;
}
/// <summary/>
public void Bind(FwNewLangProjectModel model)
{
_model = model;
// Do not re-bind the project name contents to avoid UX trouble (flickering and text selection issues)
_projectNameErrorLabel.Visible = !model.IsProjectNameValid;
_errorImage.Visible = !model.IsProjectNameValid;
_projectNameErrorLabel.Text = model.InvalidProjectNameMessage;
}
/// <summary/>
public FwNewProjectProjectNameControl(FwNewLangProjectModel model)
{
InitializeComponent();
_model = model;
m_txtName.Text = _model.ProjectName;
m_txtName.TextChanged += ProjectNameTextChanged;
_errorImage.Visible = false;
_projectNameErrorLabel.Visible = false;
}
public void FwNewLangProjectModel_CanFinish_FalseIfNoneComplete()
{
var testModel = new FwNewLangProjectModel();
foreach (var step in testModel.Steps)
{
step.IsComplete = false;
}
Assert.False(testModel.CanFinish());
}
public void FwNewLangProjectModel_CanFinish_TrueIfAllComplete()
{
var testModel = new FwNewLangProjectModel();
foreach (var step in testModel.Steps)
{
step.IsComplete = true;
}
Assert.True(testModel.CanFinish());
}
[TestCase("\u0344", false)] // non-ASCII is forbidden
public void FwNewLangProjectModel_ProjectNameIsValid(string projName, bool expectedResult)
{
var testModel = new FwNewLangProjectModel
{
LoadProjectNameSetup = () => { },
ProjectName = projName
};
Assert.That(testModel.IsProjectNameValid, Is.EqualTo(expectedResult));
}
public void FwNewLangProjectModel_CanGoBack()
{
var model = new FwNewLangProjectModel();
model.LoadProjectNameSetup = () => { };
model.LoadVernacularSetup = () => { };
model.ProjectName = DbName;
Assert.False(model.CanGoBack());
model.Next();
Assert.True(model.CanGoBack());
model.Back();
Assert.False(model.CanGoBack());
}
public void FwNewLangProjectModel_CanFinish_TrueIfAllNonOptionalComplete()
{
var testModel = new FwNewLangProjectModel();
Assert.True(testModel.Steps.Any(step => step.IsOptional), "Test data is invalid, no optional steps present");
foreach (var step in testModel.Steps)
{
if (!step.IsOptional)
{
step.IsComplete = true;
}
else
{
step.IsComplete = false;
}
}
Assert.True(testModel.CanFinish());
}
public void FwNewLangProjectModel_InvalidProjectNameMessage_NonRoman()
{
var testModel = new FwNewLangProjectModel
{
LoadProjectNameSetup = () => { },
ProjectName = "\u0344"
};
var messageStart = FwCoreDlgs.ksIllegalNameNonRomanMsg;
var firstParamPos = messageStart.IndexOf("{");
if (firstParamPos > 0)
{
messageStart = messageStart.Substring(0, firstParamPos - 1);
}
var messageActual = testModel.InvalidProjectNameMessage;
Assert.That(messageActual, Is.StringStarting(messageStart));
Assert.That(messageActual, Is.StringContaining(FwCoreDlgs.ksIllegalNameExplanation));
}
public void SetDefaultWs_DoesNotDuplicate()
{
var model = new FwNewLangProjectModel(true)
{
LoadProjectNameSetup = () => { },
LoadVernacularSetup = () => { },
ProjectName = DbName
};
model.Next();
model.WritingSystemContainer.AddToCurrentVernacularWritingSystems(new CoreWritingSystemDefinition("de"));
model.SetDefaultWs(new LanguageInfo {
LanguageTag = "de"
});
Assert.That(model.WritingSystemContainer.VernacularWritingSystems.Count, Is.EqualTo(1), "should be only one WS");
Assert.That(model.WritingSystemContainer.VernacularWritingSystems.First().LanguageTag, Is.EqualTo("de"), "should be German");
Assert.That(model.WritingSystemContainer.CurrentVernacularWritingSystems.Count, Is.EqualTo(1), "should be only one current");
Assert.That(model.WritingSystemContainer.CurrentVernacularWritingSystems.First().LanguageTag, Is.EqualTo("de"),
"default should be German");
}
public void SetDefaultWs_ReplacesExistingDefault()
{
var model = new FwNewLangProjectModel(true)
{
LoadProjectNameSetup = () => { },
LoadVernacularSetup = () => { },
ProjectName = DbName
};
model.Next();
model.WritingSystemContainer.AddToCurrentVernacularWritingSystems(new CoreWritingSystemDefinition("fr"));
model.WritingSystemContainer.AddToCurrentVernacularWritingSystems(new CoreWritingSystemDefinition("en"));
model.SetDefaultWs(new LanguageInfo {
LanguageTag = "de"
});
Assert.That(model.WritingSystemContainer.VernacularWritingSystems.Count, Is.EqualTo(2), "all");
Assert.That(model.WritingSystemContainer.VernacularWritingSystems.First().LanguageTag, Is.EqualTo("de"), "first should be German");
Assert.That(model.WritingSystemContainer.CurrentVernacularWritingSystems.Count, Is.EqualTo(2), "current");
Assert.That(model.WritingSystemContainer.CurrentVernacularWritingSystems.First().LanguageTag, Is.EqualTo("de"),
"default should be German");
}
public void SetDefaultWs_ManyExist_OthersArePreservedInOrder()
{
var model = new FwNewLangProjectModel(true)
{
LoadProjectNameSetup = () => { },
LoadVernacularSetup = () => { },
ProjectName = DbName
};
model.Next();
model.WritingSystemContainer.AddToCurrentVernacularWritingSystems(new CoreWritingSystemDefinition("en"));
model.WritingSystemContainer.AddToCurrentVernacularWritingSystems(new CoreWritingSystemDefinition("de"));
model.WritingSystemContainer.AddToCurrentVernacularWritingSystems(new CoreWritingSystemDefinition("fr"));
model.SetDefaultWs(new LanguageInfo {
LanguageTag = "de"
});
Assert.That(model.WritingSystemContainer.VernacularWritingSystems.Count, Is.EqualTo(3), "all");
Assert.That(model.WritingSystemContainer.VernacularWritingSystems.First().LanguageTag, Is.EqualTo("de"), "first should be German");
Assert.That(model.WritingSystemContainer.CurrentVernacularWritingSystems.Count, Is.EqualTo(3), "current");
Assert.That(model.WritingSystemContainer.CurrentVernacularWritingSystems[0].LanguageTag, Is.EqualTo("de"), "default should be German");
Assert.That(model.WritingSystemContainer.CurrentVernacularWritingSystems[1].LanguageTag, Is.EqualTo("en"), "econd should be English");
Assert.That(model.WritingSystemContainer.CurrentVernacularWritingSystems[2].LanguageTag, Is.EqualTo("fr"), "third should be French");
}
private static void CreateDb(string dbName, string vernWs = "fr")
{
var testProject = new FwNewLangProjectModel(true)
{
LoadProjectNameSetup = () => { },
LoadVernacularSetup = () => { },
LoadAnalysisSetup = () => { },
ProjectName = dbName,
AnthroModel = new FwChooseAnthroListModel {
CurrentList = FwChooseAnthroListModel.ListChoice.UserDef
}
};
testProject.Next();
testProject.SetDefaultWs(new LanguageInfo {
LanguageTag = vernWs
});
testProject.Next();
using (var threadHelper = new ThreadHelper())
{
testProject.CreateNewLangProj(new DummyProgressDlg(), threadHelper);
}
}
/// <summary/>
public FwNewLangProjWritingSystemsControl(FwNewLangProjectModel model, FwWritingSystemSetupModel.ListType type)
{
InitializeComponent();
if (type != FwWritingSystemSetupModel.ListType.Vernacular &&
type != FwWritingSystemSetupModel.ListType.Analysis)
{
throw new ArgumentException("Unsupported list type", nameof(type));
}
_model = model;
_listType = type;
m_defaultAnalysisAndVernSameIcon.Visible = false;
m_defaultAnalysisAndVernSame.Visible = false;
if (type == FwWritingSystemSetupModel.ListType.Analysis)
{
m_lblWsTypeHeader.Text = FwCoreDlgs.NewProjectWizard_AnalysisHeader;
m_lblExplainWsTypeUsage.Text = FwCoreDlgs.NewLangProjWizard_AnalysisWritingSystemExplanation;
if (model.WritingSystemContainer.CurrentAnalysisWritingSystems.Count > 0)
{
m_defaultWsLabel.Text = model.WritingSystemContainer.CurrentAnalysisWritingSystems[0].DisplayLabel;
}
if (model.WritingSystemContainer.CurrentVernacularWritingSystems.First() ==
model.WritingSystemContainer.CurrentAnalysisWritingSystems.First())
{
m_defaultAnalysisAndVernSameIcon.Visible = true;
m_defaultAnalysisAndVernSame.Visible = true;
}
}
else
{
if (model.WritingSystemContainer.CurrentVernacularWritingSystems.Count > 0)
{
m_defaultWsLabel.Text = model.WritingSystemContainer.CurrentVernacularWritingSystems[0].DisplayLabel;
}
}
}
/// <summary>
/// Constructs a new instance of the <see cref="FwNewLangProject"/> class.
/// </summary>
public FwNewLangProject(FwNewLangProjectModel model, IHelpTopicProvider helpTopicProvider = null)
{
Logger.WriteEvent("Opening New Language Project dialog");
//
// Required for Windows Form Designer support
//
InitializeComponent();
AccessibleName = GetType().Name;
m_model = model;
m_wsManager = m_model.WritingSystemManager;
model.LoadProjectNameSetup = LoadProjectNameSetup;
model.LoadVernacularSetup = LoadVernacularSetup;
model.LoadAnalysisSetup = LoadAnalysisSetup;
model.LoadAnalysisSameAsVernacularWarning = () =>
{
MessageBox.Show(FwCoreDlgs.NewProjectWizard_MonolingualMessage,
FwCoreDlgs.NewProjectWizard_MonolingualCaption, MessageBoxButtons.OK,
MessageBoxIcon.Information);
};
model.LoadAdvancedWsSetup = LoadAdvancedWsSetup;
model.LoadAnthropologySetup = LoadAnthropologySetup;
LoadProjectNameSetup();
m_helpTopicProvider = helpTopicProvider;
}
/// <summary/>
public FwNewLangProjMoreWsControl(FwNewLangProjectModel model = null, IHelpTopicProvider helpTopicProvider = null)
{
InitializeComponent();
_model = model;
_helpTopicProvider = helpTopicProvider;
}
public void FwNewLangProjectModel_VerifyCreateNewLangProject()
{
LcmCache cache = null;
var testProject = new FwNewLangProjectModel(true)
{
LoadProjectNameSetup = () => { },
LoadVernacularSetup = () => { },
LoadAnalysisSetup = () => { },
AnthroModel = new FwChooseAnthroListModel {
CurrentList = FwChooseAnthroListModel.ListChoice.UserDef
}
};
try
{
testProject.ProjectName = DbName;
testProject.Next();
testProject.SetDefaultWs(new LanguageInfo {
LanguageTag = "fr"
});
testProject.Next();
testProject.SetDefaultWs(new LanguageInfo {
LanguageTag = "de"
});
using (var threadHelper = new ThreadHelper())
{
testProject.CreateNewLangProj(new DummyProgressDlg(), threadHelper);
}
Assert.IsTrue(DbExists(DbName));
// despite of the name is DummyProgressDlg no real dialog (doesn't derive from Control), so
// we don't need a 'using'
cache = LcmCache.CreateCacheFromExistingData(
new TestProjectId(BackendProviderType.kXMLWithMemoryOnlyWsMgr, DbFilename(DbName)), "en", new DummyLcmUI(),
FwDirectoryFinder.LcmDirectories, new LcmSettings(), new DummyProgressDlg());
CheckInitialSetOfPartsOfSpeech(cache);
Assert.AreEqual(2, cache.ServiceLocator.WritingSystems.AnalysisWritingSystems.Count);
Assert.AreEqual("German", cache.ServiceLocator.WritingSystems.AnalysisWritingSystems.First().LanguageName);
Assert.AreEqual("English", cache.ServiceLocator.WritingSystems.AnalysisWritingSystems.Last().LanguageName);
Assert.AreEqual(2, cache.ServiceLocator.WritingSystems.CurrentAnalysisWritingSystems.Count);
Assert.AreEqual("German", cache.ServiceLocator.WritingSystems.DefaultAnalysisWritingSystem.LanguageName);
Assert.AreEqual("English", cache.ServiceLocator.WritingSystems.CurrentAnalysisWritingSystems.Last().LanguageName,
"English should be selected as an analysis writing system even if the user tried to remove it");
Assert.AreEqual(1, cache.ServiceLocator.WritingSystems.VernacularWritingSystems.Count);
Assert.AreEqual("French", cache.ServiceLocator.WritingSystems.VernacularWritingSystems.First().LanguageName);
Assert.AreEqual(1, cache.ServiceLocator.WritingSystems.CurrentVernacularWritingSystems.Count);
Assert.AreEqual("French", cache.ServiceLocator.WritingSystems.DefaultVernacularWritingSystem.LanguageName);
}
finally
{
// Blow away the database to clean things up
if (cache != null)
{
cache.Dispose();
}
DestroyDb(DbName, false);
}
}
