/// <summary>
/// Adds the Folder to the Project xml file
/// </summary>
/// <param name="folderNameWithPath">Folder with full path</param>
/// <param name="destPathParent">Parent of current folder - used for recursive copy</param>
/// <returns>Returns True/False</returns>
private bool AddFolderToXML(string folderNameWithPath, string destPathParent)
{
try
{
if (Directory.Exists(folderNameWithPath))
{
return(false);
}
Directory.CreateDirectory(folderNameWithPath);
}
catch (Exception ex)
{
var msg = new[] { ex.Message };
LocDB.Message("defErrMsg", ex.Message, msg, LocDB.MessageTypes.Error, LocDB.MessageDefault.First);
return(false);
}
string folderName = Path.GetFileName(folderNameWithPath);
bool returnValue = XMLOperation(folderName, 'D', "", false, "", destPathParent, true);
if (destPathParent == "")
{
PopulateDicExplorer(_dictExplorer);
}
return(returnValue);
}
public void ImportImperatorCharacters(Imperator.World impWorld,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
TraitMapper traitMapper,
NicknameMapper nicknameMapper,
LocDB locDB,
ProvinceMapper provinceMapper,
DeathReasonMapper deathReasonMapper,
Date endDate,
Date ck3BookmarkDate
)
{
Logger.Info("Importing Imperator Characters...");
foreach (var character in impWorld.Characters)
{
ImportImperatorCharacter(
character,
religionMapper,
cultureMapper,
traitMapper,
nicknameMapper,
locDB,
provinceMapper,
deathReasonMapper,
endDate,
ck3BookmarkDate
);
}
Logger.Info($"{Count} total characters recognized.");
LinkMothersAndFathers();
LinkSpouses();
LinkPrisoners();
}
public Title Add(
Governorship governorship,
Country country,
Imperator.Characters.CharacterCollection imperatorCharacters,
bool regionHasMultipleGovernorships,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
TagTitleMapper tagTitleMapper,
DefiniteFormMapper definiteFormMapper,
ImperatorRegionMapper imperatorRegionMapper
)
{
var newTitle = new Title(this,
governorship,
country,
imperatorCharacters,
regionHasMultipleGovernorships,
locDB,
provinceMapper,
coaMapper,
tagTitleMapper,
definiteFormMapper,
imperatorRegionMapper
);
dict[newTitle.Id] = newTitle;
return(newTitle);
}
public LocBlock?GetNameLocBlock(LocDB locDB, CountryCollection imperatorCountries)
{
var directNameLocMatch = locDB.GetLocBlockForKey(Name);
if (directNameLocMatch is null || Name != "CIVILWAR_FACTION_NAME")
{
return(directNameLocMatch);
}
// special case for revolts
if (BaseName is null)
{
return(directNameLocMatch);
}
var baseAdjLoc = BaseName.GetAdjectiveLocBlock(locDB, imperatorCountries);
if (baseAdjLoc is null)
{
return(directNameLocMatch);
}
directNameLocMatch.ModifyForEveryLanguage(baseAdjLoc,
(orig, modifying) => orig.Replace("$ADJ$", modifying)
);
return(directNameLocMatch);
}
// Command Handlers ------------------------------------------------------------------
#region Cmd: cmdLoad
private void cmdLoad(object sender, EventArgs e)
{
LocDB.Localize(this, null); // Form Controls
ShowHelp.ShowHelpTopic(this, "Localization.htm", Common.IsUnixOS(), false);
// Populate the Filter Combo
FilterCombo.Items.Add(c_ShowAll);
FilterCombo.Items.Add(c_ThoseNeedingAttention);
FilterCombo.Items.Add(c_TranslatorItems);
FilterCombo.Items.Add(c_TranslatorItemsNeedingAttention);
FilterCombo.Items.Add(c_AdvisorItems);
FilterCombo.Items.Add(c_AdvisorItemsNeedingAttention);
FilterCombo.Text = c_ShowAll;
// Populate the Language Combo
PopulateLanguageCombo();
// Populate the Tree
PopulateTree();
// Populate the Shortcut Key Combo
for (int i = 0; i < 26; i++)
{
m_comboShortcutKey.Items.Add("Ctrl+" + ((char)((int)'A' + i)).ToString());
}
// Initialize the form to the first item
if (Tree.Nodes.Count > 0)
{
Tree.SelectedNode = Tree.Nodes[0];
}
}
private void PublicationTask_Load(object sender, EventArgs e)
{
LocDB.Localize(this, null);
Param.SetupHelp(this);
try
{
if (Param.Value.ContainsKey(Param.InputType))
{
Param.SetValue(Param.InputType, "");
}
Param.LoadSettings();
ScreenAdjustment();
BtConfigure.Visible = Param.UserRole != "Output User";
if (Param.Value.ContainsKey(Param.InputType))
{
Param.SetValue(Param.InputType, InputType);
}
Param.LoadSettings();
TaskAdjustment();
DoLoad();
}
catch (InvalidStyleSettingsException err)
{
var msg = new[] { err.FullFilePath };
LocDB.Message("errNotValidXml", err.ToString(), msg, LocDB.MessageTypes.Warning, LocDB.MessageDefault.First);
return;
}
}
/// <summary>
/// Add files to an existing Zip archive,
/// </summary>
/// <param name="filename">Array of path / filenames to add to the archive</param>
/// <param name="archive">Zip archive that we want to add the file to</param>
public void AddToZip(string[] filename, string archive)
{
if (!File.Exists(archive))
{
return;
}
try
{
ZipFile zf = new ZipFile(archive);
zf.BeginUpdate();
// path relative to the archive
zf.NameTransform = new ZipNameTransform(Path.GetDirectoryName(archive));
foreach (var file in filename)
{
// skip if this isn't a real file
if (!File.Exists(file))
{
continue;
}
zf.Add(file, CompressionMethod.Deflated);
}
zf.CommitUpdate();
zf.Close();
}
catch (Exception e)
{
if (e.Message != null)
{
var msg = new[] { e.Message };
LocDB.Message("defErrMsg", e.Message, msg, LocDB.MessageTypes.Error, LocDB.MessageDefault.First);
}
}
}
private Title(
LandedTitles parentCollection,
Governorship governorship,
Country country,
Imperator.Characters.CharacterCollection imperatorCharacters,
bool regionHasMultipleGovernorships,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
TagTitleMapper tagTitleMapper,
DefiniteFormMapper definiteFormMapper,
ImperatorRegionMapper imperatorRegionMapper
)
{
this.parentCollection = parentCollection;
Id = DetermineName(governorship, country, tagTitleMapper);
SetRank();
InitializeFromGovernorship(
governorship,
country,
imperatorCharacters,
regionHasMultipleGovernorships,
locDB,
provinceMapper,
definiteFormMapper,
imperatorRegionMapper
);
}
private void ImportImperatorCharacter(
Imperator.Characters.Character character,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
TraitMapper traitMapper,
NicknameMapper nicknameMapper,
LocDB locDB,
ProvinceMapper provinceMapper,
DeathReasonMapper deathReasonMapper,
Date endDate,
Date ck3BookmarkDate
)
{
// Create a new CK3 character
var newCharacter = new Character(
character,
religionMapper,
cultureMapper,
traitMapper,
nicknameMapper,
locDB,
provinceMapper,
deathReasonMapper,
endDate,
ck3BookmarkDate
);
character.CK3Character = newCharacter;
Add(newCharacter);
}
private void ImportImperatorCountry(
Country country,
CountryCollection imperatorCountries,
TagTitleMapper tagTitleMapper,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
GovernmentMapper governmentMapper,
SuccessionLawMapper successionLawMapper,
DefiniteFormMapper definiteFormMapper,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
NicknameMapper nicknameMapper,
CharacterCollection characters,
Date conversionDate
)
{
// Create a new title or update existing title
var name = DetermineName(country, imperatorCountries, tagTitleMapper, locDB);
if (TryGetValue(name, out var existingTitle))
{
existingTitle.InitializeFromTag(
country,
imperatorCountries,
locDB,
provinceMapper,
coaMapper,
governmentMapper,
successionLawMapper,
definiteFormMapper,
religionMapper,
cultureMapper,
nicknameMapper,
characters,
conversionDate
);
}
else
{
Add(
country,
imperatorCountries,
locDB,
provinceMapper,
coaMapper,
tagTitleMapper,
governmentMapper,
successionLawMapper,
definiteFormMapper,
religionMapper,
cultureMapper,
nicknameMapper,
characters,
conversionDate
);
}
}
public void AdjLocBlockDefaultsToNull()
{
var reader = new BufferedReader(string.Empty);
var countryName = ImperatorToCK3.Imperator.Countries.CountryName.Parse(reader);
var locDB = new LocDB("english");
Assert.Null(countryName.GetAdjectiveLocBlock(locDB, new()));
}
public void AdjLocBlockReturnsCorrectLocForRevolts()
{
var reader = new BufferedReader(
"adjective = CIVILWAR_FACTION_ADJECTIVE \n base = { name = someName adjective = someAdjective }"
);
var countryName = ImperatorToCK3.Imperator.Countries.CountryName.Parse(reader);
var locDB = new LocDB("english");
var locBlock1 = locDB.AddLocBlock("CIVILWAR_FACTION_ADJECTIVE");
locBlock1["english"] = "$ADJ$";
var locBlock2 = locDB.AddLocBlock("someAdjective");
locBlock2["english"] = "Roman";
Assert.Equal("Roman", countryName.GetAdjectiveLocBlock(locDB, new()) !["english"]);
public void ImportImperatorFamilies(Imperator.World impWorld, LocDB locDB)
{
Logger.Info("Importing Imperator Families...");
// the collection only holds dynasties converted from Imperator families, as vanilla ones aren't modified
foreach (var family in impWorld.Families)
{
if (family.Minor)
{
continue;
}
var newDynasty = new Dynasty(family, locDB);
Add(newDynasty);
}
Logger.Info($"{Count} total families imported.");
}
public LocBlock?GetAdjectiveLocBlock(LocDB locDB, CountryCollection imperatorCountries)
{
var adj = GetAdjective();
var directAdjLocMatch = locDB.GetLocBlockForKey(adj);
if (directAdjLocMatch is not null && adj == "CIVILWAR_FACTION_ADJECTIVE")
{
// special case for revolts
var baseAdjLoc = BaseName?.GetAdjectiveLocBlock(locDB, imperatorCountries);
if (baseAdjLoc is not null)
{
directAdjLocMatch.ModifyForEveryLanguage(baseAdjLoc, (orig, modifying) =>
orig.Replace("$ADJ$", modifying)
);
return(directAdjLocMatch);
}
}
public Dynasty(Family imperatorFamily, LocDB locDB)
{
Id = $"dynn_IMPTOCK3_{imperatorFamily.Id}";
Name = Id;
var imperatorMembers = imperatorFamily.Members;
if (imperatorMembers.Count > 0)
{
Imperator.Characters.Character?firstMember = imperatorMembers[0] as Imperator.Characters.Character;
if (firstMember?.CK3Character is not null)
{
Culture = firstMember.CK3Character.Culture; // make head's culture the dynasty culture
}
}
else
{
Logger.Warn($"Couldn't determine culture for dynasty {Id}, needs manual setting!");
}
foreach (var member in imperatorMembers.Values)
{
var ck3Member = (member as Imperator.Characters.Character)?.CK3Character;
if (ck3Member is not null)
{
ck3Member.DynastyId = Id;
}
}
var impFamilyLocKey = imperatorFamily.Key;
var impFamilyLoc = locDB.GetLocBlockForKey(impFamilyLocKey);
if (impFamilyLoc is not null)
{
Localization = new(Name, impFamilyLoc);
}
else // fallback: use unlocalized Imperator family key
{
var locBlock = new LocBlock("english", "french", "german", "russian", "simp_chinese", "spanish")
{
["english"] = impFamilyLocKey
};
locBlock.FillMissingLocWithBaseLanguageLoc();
Localization = new(Name, locBlock);
}
}
// Scaffolding -----------------------------------------------------------------------
#region Constructor(LocDB)
public Localizer(LocDB _DB)
{
m_DB = _DB;
InitializeComponent();
LocLanguage language = _DB.PrimaryLanguage;
if (null != language)
{
m_iLanguage = language.Index;
}
else if (_DB.Languages.Length > 0)
{
m_iLanguage = 0;
}
}
private void ImportImperatorGovernorship(
Governorship governorship,
CountryCollection imperatorCountries,
Imperator.Characters.CharacterCollection imperatorCharacters,
bool regionHasMultipleGovernorships,
TagTitleMapper tagTitleMapper,
LocDB locDB,
ProvinceMapper provinceMapper,
DefiniteFormMapper definiteFormMapper,
ImperatorRegionMapper imperatorRegionMapper,
CoaMapper coaMapper)
{
var country = imperatorCountries[governorship.CountryId];
// Create a new title or update existing title
var name = DetermineName(governorship, country, tagTitleMapper);
if (TryGetValue(name, out var existingTitle))
{
existingTitle.InitializeFromGovernorship(
governorship,
country,
imperatorCharacters,
regionHasMultipleGovernorships,
locDB,
provinceMapper,
definiteFormMapper,
imperatorRegionMapper
);
}
else
{
Add(
governorship,
country,
imperatorCharacters,
regionHasMultipleGovernorships,
locDB,
provinceMapper,
coaMapper,
tagTitleMapper,
definiteFormMapper,
imperatorRegionMapper
);
}
}
public void ImportImperatorCountries(
CountryCollection imperatorCountries,
TagTitleMapper tagTitleMapper,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
GovernmentMapper governmentMapper,
SuccessionLawMapper successionLawMapper,
DefiniteFormMapper definiteFormMapper,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
NicknameMapper nicknameMapper,
CharacterCollection characters,
Date conversionDate
)
{
Logger.Info("Importing Imperator Countries...");
// landedTitles holds all titles imported from CK3. We'll now overwrite some and
// add new ones from Imperator tags.
var counter = 0;
// We don't need pirates, barbarians etc.
foreach (var country in imperatorCountries.Where(c => c.CountryType == CountryType.real))
{
ImportImperatorCountry(
country,
imperatorCountries,
tagTitleMapper,
locDB,
provinceMapper,
coaMapper,
governmentMapper,
successionLawMapper,
definiteFormMapper,
religionMapper,
cultureMapper,
nicknameMapper,
characters,
conversionDate
);
++counter;
}
Logger.Info($"Imported {counter} countries from I:R.");
}
public string CreatePreview()
{
Debug.Assert(ParentForm != null);
if (inProcess)
{
return(string.Empty);
}
inProcess = true;
var cr = ParentForm.Cursor;
ParentForm.Cursor = Cursors.WaitCursor;
Debug.Assert(!string.IsNullOrEmpty(Param.Value[Param.CurrentInput]), "The given key was not present in the dictionary.");
var xhtml = Param.Value[Param.CurrentInput];
if (string.IsNullOrEmpty(xhtml) || !File.Exists(xhtml))
{
return(string.Empty);
}
string PreviewCSSPath = Param.StylePath(Sheet);
var mergedCss = new MergeCss();
string cssCombine = mergedCss.Make(PreviewCSSPath, "Temp1.css");
var returnXhtml = CreatePreviewFile(xhtml, cssCombine, "preview", true);
var pdf = new Pdf(returnXhtml, cssCombine);
var outName = Common.PathCombine(Param.Value[Param.OutputPath], Path.GetFileNameWithoutExtension(xhtml) + ".pdf");
try
{
pdf.Create(outName);
}
catch (Pdf.MISSINGPRINCE)
{
LocDB.Message("errInstallPrinceXML", "PrinceXML must be downloaded and installed from www.PrinceXML.com", null, LocDB.MessageTypes.Error,
LocDB.MessageDefault.First);
ParentForm.Cursor = cr;
inProcess = false;
return(string.Empty);
}
ParentForm.Cursor = cr;
inProcess = false;
return(outName);
}
public void ImportImperatorGovernorships(
Imperator.World impWorld,
TagTitleMapper tagTitleMapper,
LocDB locDB,
ProvinceMapper provinceMapper,
DefiniteFormMapper definiteFormMapper,
ImperatorRegionMapper imperatorRegionMapper,
CoaMapper coaMapper
)
{
Logger.Info("Importing Imperator Governorships...");
var governorships = impWorld.Jobs.Governorships;
var imperatorCountries = impWorld.Countries;
var governorshipsPerRegion = governorships.GroupBy(g => g.RegionName)
.ToDictionary(g => g.Key, g => g.Count());
// landedTitles holds all titles imported from CK3. We'll now overwrite some and
// add new ones from Imperator governorships.
var counter = 0;
foreach (var governorship in governorships)
{
ImportImperatorGovernorship(
governorship,
imperatorCountries,
impWorld.Characters,
governorshipsPerRegion[governorship.RegionName] > 1,
tagTitleMapper,
locDB,
provinceMapper,
definiteFormMapper,
imperatorRegionMapper,
coaMapper
);
++counter;
}
Logger.Info($"Imported {counter} governorships from I:R.");
}
private void ExportDlg_Load(object sender, EventArgs e)
{
LocDB.Localize(this, null); // Form Controls
_helpTopic = "Exporting.htm";
ShowHelp.ShowHelpTopic(this, _helpTopic, Common.IsUnixOS(), false);
ArrayList exportType = Backend.GetExportType(ExportType);
if (exportType.Count > 0)
{
foreach (string item in exportType)
{
cmbExportType.Items.Add(item);
}
cmbExportType.SelectedIndex = 0;
}
else
{
var msg = new[] { "Please Install the Plugin Backends" };
LocDB.Message("defErrMsg", "Please Install the Plugin Backends", msg, LocDB.MessageTypes.Error, LocDB.MessageDefault.First);
this.Close();
}
}
public RulerTerm(
Imperator.Countries.RulerTerm imperatorRulerTerm,
Characters.CharacterCollection characters,
GovernmentMapper governmentMapper,
LocDB locDB,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
NicknameMapper nicknameMapper,
ProvinceMapper provinceMapper
)
{
if (imperatorRulerTerm.CharacterId is not null)
{
CharacterId = $"imperator{imperatorRulerTerm.CharacterId}";
}
StartDate = imperatorRulerTerm.StartDate;
if (imperatorRulerTerm.Government is not null)
{
Government = governmentMapper.GetCK3GovernmentForImperatorGovernment(imperatorRulerTerm.Government);
}
PreImperatorRuler = imperatorRulerTerm.PreImperatorRuler;
if (PreImperatorRuler?.Country is not null)
{
// create a new ruler character
var character = new Character(
PreImperatorRuler,
StartDate,
PreImperatorRuler.Country,
locDB,
religionMapper,
cultureMapper,
nicknameMapper,
provinceMapper
);
characters.Add(character);
CharacterId = character.Id;
}
}
private void Launch(string ldmlFullName)
{
try
{
Common.OpenOutput(ldmlFullName);
}
catch (System.ComponentModel.Win32Exception ex)
{
if (ex.NativeErrorCode == 1155)
{
string installedLocation = string.Empty;
if (File.Exists(ldmlFullName))
{
installedLocation = ldmlFullName;
var msg = new[] { "Indesign application." };
LocDB.Message("errInstallFile", "The output has been saved in " + installedLocation, "Please install " + msg, msg, LocDB.MessageTypes.Error, LocDB.MessageDefault.First);
}
}
}
}
public Title Add(
Country country,
CountryCollection imperatorCountries,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
TagTitleMapper tagTitleMapper,
GovernmentMapper governmentMapper,
SuccessionLawMapper successionLawMapper,
DefiniteFormMapper definiteFormMapper,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
NicknameMapper nicknameMapper,
CharacterCollection characters,
Date conversionDate
)
{
var newTitle = new Title(this,
country,
imperatorCountries,
locDB,
provinceMapper,
coaMapper,
tagTitleMapper,
governmentMapper,
successionLawMapper,
definiteFormMapper,
religionMapper,
cultureMapper,
nicknameMapper,
characters,
conversionDate
);
dict[newTitle.Id] = newTitle;
return(newTitle);
}
private Title(LandedTitles parentCollection,
Country country,
CountryCollection imperatorCountries,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
TagTitleMapper tagTitleMapper,
GovernmentMapper governmentMapper,
SuccessionLawMapper successionLawMapper,
DefiniteFormMapper definiteFormMapper,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
NicknameMapper nicknameMapper,
CharacterCollection characters,
Date conversionDate
)
{
this.parentCollection = parentCollection;
Id = DetermineName(country, imperatorCountries, tagTitleMapper, locDB);
SetRank();
InitializeFromTag(
country,
imperatorCountries,
locDB,
provinceMapper,
coaMapper,
governmentMapper,
successionLawMapper,
definiteFormMapper,
religionMapper,
cultureMapper,
nicknameMapper,
characters,
conversionDate
);
}
public void DynastiesAreOutputted()
{
const string outputModName = "outputMod";
var locDB = new LocDB("english");
var dynasties = new DynastyCollection();
var family1 = new Family(1);
var dynasty1 = new Dynasty(family1, locDB);
dynasties.Add(dynasty1);
var family2 = new Family(2);
var dynasty2 = new Dynasty(family2, locDB)
{
Culture = "roman"
};
dynasties.Add(dynasty2);
var outputPath = Path.Combine("output", outputModName, "common", "dynasties", "imp_dynasties.txt");
SystemUtils.TryCreateFolder(CommonFunctions.GetPath(outputPath));
DynastiesOutputter.OutputDynasties(outputModName, dynasties);
using var file = File.OpenRead(outputPath);
var reader = new StreamReader(file);
Assert.Equal("dynn_IMPTOCK3_1={", reader.ReadLine());
Assert.Equal("\tname=\"dynn_IMPTOCK3_1\"", reader.ReadLine());
Assert.Equal("}", reader.ReadLine());
Assert.Equal("dynn_IMPTOCK3_2={", reader.ReadLine());
Assert.Equal("\tname=\"dynn_IMPTOCK3_2\"", reader.ReadLine());
Assert.Equal("\tculture=\"roman\"", reader.ReadLine());
Assert.Equal("}", reader.ReadLine());
Assert.True(reader.EndOfStream);
}
/// <summary>
/// To sets the projects type/version and date of creation/modification
/// </summary>
/// <param name="mode">The Project mode (new / open)</param>
public void ProjectProperty(string mode)
{
try
{
XmlNode propertyCreated;
XmlNode propertyCreatedOn;
XmlNode searchNode = null;
XmlNode modifyNode = null;
XmlAttribute xattribute;
XmlElement root = _DeXml.DocumentElement;
string xPath = "PropertyGroup";
if (root != null)
{
searchNode = root.SelectSingleNode(xPath);
if (searchNode == null)
{
searchNode = _DeXml.CreateNode("element", "PropertyGroup", "");
root.AppendChild(searchNode);
mode = "new";
}
if (mode == "new")
{
//Setting Project Type and Version.
xattribute = _DeXml.CreateAttribute("Type");
xattribute.Value = _projectInputType;
root.Attributes.Append(xattribute);
xattribute = _DeXml.CreateAttribute("Version");
xattribute.Value = Assembly.GetExecutingAssembly().GetName().Version.ToString();
root.Attributes.Append(xattribute);
xattribute = _DeXml.CreateAttribute("ShowError");
xattribute.Value = "True";
root.Attributes.Append(xattribute);
// Setting User, Date
propertyCreated = _DeXml.CreateNode("element", "Creation", "");
propertyCreatedOn = _DeXml.CreateNode("element", "CreatedOn", "");
propertyCreatedOn.InnerText = DateTime.Now.ToString("dd-MMM-yyyy HH:mm:ss");
propertyCreated.AppendChild(propertyCreatedOn);
propertyCreatedOn = _DeXml.CreateNode("element", "CreatedBy", "");
propertyCreatedOn.InnerText = Environment.UserName;
propertyCreated.AppendChild(propertyCreatedOn);
searchNode.AppendChild(propertyCreated);
}
}
xPath = "/Project/PropertyGroup/Modification";
if (root != null)
{
modifyNode = root.SelectSingleNode(xPath);
}
if (modifyNode != null)
{
searchNode.RemoveChild(modifyNode);
}
propertyCreated = _DeXml.CreateNode("element", "Modification", "");
propertyCreatedOn = _DeXml.CreateNode("element", "ModifiedOn", "");
propertyCreatedOn.InnerText = DateTime.Now.ToString("dd-MMM-yyyy HH:mm:ss");
propertyCreated.AppendChild(propertyCreatedOn);
propertyCreatedOn = _DeXml.CreateNode("element", "ModifiedBy", "");
propertyCreatedOn.InnerText = Environment.UserName;
propertyCreated.AppendChild(propertyCreatedOn);
if (searchNode != null)
{
searchNode.AppendChild(propertyCreated);
}
_DeXml.Save(_projectFileWithPath);
}
catch (Exception ex)
{
var msg = new[] { ex.Message };
LocDB.Message("defErrMsg", ex.Message, msg, LocDB.MessageTypes.Error, LocDB.MessageDefault.First);
}
}
/// <summary>
/// Add the given file to the Project xml file
/// </summary>
/// <param name="fullFileName">File with full path</param>
/// <param name="setDefault">Used to set default css</param>
/// <param name="addToParentFolder">Forced to add in root of Solution Explorer</param>
/// <param name="destPathParent">Parent of current folder - used for recursive copy</param>
/// <param name="showFileExist">To Show the information about file already exist</param>
/// <param name="visible"></param>
/// <returns>Returns True/False</returns>
public bool AddFileToXML(string fullFileName, string setDefault, bool addToParentFolder, string destPathParent, bool showFileExist, bool visible)
{
if (!File.Exists(fullFileName))
{
return(false);
}
string fileName = Path.GetFileName(fullFileName);
string fileNamePath;
// Root directory
if (addToParentFolder)
{
fileNamePath = Common.PathCombine(_dictionaryPath, fileName);
}
else
{
if (destPathParent != "")
{
// used for recursive copy
fileNamePath = Common.PathCombine(_fullPath + destPathParent, fileName);
}
else
{
// sub directory
fileNamePath = Common.PathCombine(_fullPath, fileName);
}
}
if (IsFileExist(Path.GetFileName(fileNamePath), "True"))
{
if (showFileExist)
{
var msg = new[] { "File Already Exist in Dictionary Express." };
LocDB.Message("defErrMsg", "File Already Exist in Dictionary Express.", msg, LocDB.MessageTypes.Info, LocDB.MessageDefault.First);
}
}
else
{
try
{
// Remove if file Visible="False"
if (IsFileExist(Path.GetFileName(fileNamePath), "False"))
{
RemoveFile(Path.GetFileName(fileNamePath));
}
if (fullFileName != fileNamePath)
{
File.Copy(fullFileName, fileNamePath, true);
}
// File
bool returnValue = XMLOperation(fileName, 'F', setDefault, addToParentFolder, "", destPathParent, visible);
if (destPathParent == "")
{
PopulateDicExplorer(_dictExplorer);
}
return(returnValue);
}
catch
{
}
}
return(false);
}
public void InitializeFromTag(
Country country,
CountryCollection imperatorCountries,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
GovernmentMapper governmentMapper,
SuccessionLawMapper successionLawMapper,
DefiniteFormMapper definiteFormMapper,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
NicknameMapper nicknameMapper,
CharacterCollection characters,
Date conversionDate
)
{
IsImportedOrUpdatedFromImperator = true;
ImperatorCountry = country;
ImperatorCountry.CK3Title = this;
LocBlock?validatedName = GetValidatedName(country, imperatorCountries, locDB);
HasDefiniteForm.Value = definiteFormMapper.IsDefiniteForm(ImperatorCountry.Name);
RulerUsesTitleName.Value = false;
PlayerCountry = ImperatorCountry.PlayerCountry;
ClearHolderSpecificHistory();
FillHolderAndGovernmentHistory();
// ------------------ determine color
var color1Opt = ImperatorCountry.Color1;
if (color1Opt is not null)
{
Color1 = color1Opt;
}
var color2Opt = ImperatorCountry.Color2;
if (color2Opt is not null)
{
Color2 = color2Opt;
}
// determine successions laws
history.InternalHistory.AddFieldValue("succession_laws",
successionLawMapper.GetCK3LawsForImperatorLaws(ImperatorCountry.GetLaws()),
conversionDate,
"succession_laws"
);
// determine CoA
CoA = coaMapper.GetCoaForFlagName(ImperatorCountry.Flag);
// determine other attributes
var srcCapital = ImperatorCountry.Capital;
if (srcCapital is not null)
{
var provMappingsForImperatorCapital = provinceMapper.GetCK3ProvinceNumbers((ulong)srcCapital);
if (provMappingsForImperatorCapital.Count > 0)
{
var foundCounty = parentCollection.GetCountyForProvince(provMappingsForImperatorCapital[0]);
if (foundCounty is not null)
{
CapitalCounty = foundCounty;
}
}
}
// determine country name localization
var nameSet = false;
if (validatedName is not null)
{
var nameLocBlock = Localizations.AddLocBlock(Id);
nameLocBlock.CopyFrom(validatedName);
nameSet = true;
}
if (!nameSet)
{
var impTagLoc = locDB.GetLocBlockForKey(ImperatorCountry.Tag);
if (impTagLoc is not null)
{
var nameLocBlock = Localizations.AddLocBlock(Id);
nameLocBlock.CopyFrom(impTagLoc);
nameSet = true;
}
}
if (!nameSet)
{
// use unlocalized name if not empty
var name = ImperatorCountry.Name;
if (!string.IsNullOrEmpty(name))
{
Logger.Warn($"Using unlocalized Imperator name {name} as name for {Id}!");
var nameLocBlock = Localizations.AddLocBlock(Id);
nameLocBlock["english"] = name;
nameLocBlock.FillMissingLocWithBaseLanguageLoc();
nameSet = true;
}
}
// giving up
if (!nameSet)
{
Logger.Warn($"{Id} needs help with localization! {ImperatorCountry.Name}?");
}
// determine adjective localization
TrySetAdjectiveLoc(locDB, imperatorCountries);
void FillHolderAndGovernmentHistory()
{
// ------------------ determine previous and current holders
// there was no 0 AD, but year 0 works in game and serves well for adding BC characters to holder history
var firstPossibleDate = new Date(0, 1, 1);
foreach (var impRulerTerm in ImperatorCountry.RulerTerms)
{
var rulerTerm = new RulerTerm(
impRulerTerm,
characters,
governmentMapper,
locDB,
religionMapper,
cultureMapper,
nicknameMapper,
provinceMapper
);
var characterId = rulerTerm.CharacterId;
var gov = rulerTerm.Government;
var startDate = new Date(rulerTerm.StartDate);
if (startDate < firstPossibleDate)
{
startDate = new Date(firstPossibleDate); // TODO: remove this workaround if CK3 supports negative dates
firstPossibleDate.ChangeByDays(1);
}
history.InternalHistory.AddFieldValue("holder", characterId, startDate, "holder");
if (gov is not null)
{
history.InternalHistory.AddFieldValue("government", gov, startDate, "government");
}
}
if (ImperatorCountry.Government is not null)
{
var lastCK3TermGov = history.GetGovernment(conversionDate);
var ck3CountryGov = governmentMapper.GetCK3GovernmentForImperatorGovernment(ImperatorCountry.Government);
if (lastCK3TermGov != ck3CountryGov && ck3CountryGov is not null)
{
history.InternalHistory.AddFieldValue("government", ck3CountryGov, conversionDate, "government");
}
}
}
}
private void StyleCategories_Load(object sender, EventArgs e)
{
LocDB.Localize(this, null);
Param.SetupHelp(this);
var cats = Param.GetItems("categories/category/item");
DgStyleCategories.ColumnCount = cats.Count;
DgStyleCategories.ColumnHeadersVisible = true;
var hdrStyle = new DataGridViewCellStyle
{
BackColor = Color.Gray,
Font = new Font("Charis SIL", 8, FontStyle.Bold),
WrapMode = DataGridViewTriState.True,
Alignment = DataGridViewContentAlignment.MiddleCenter
};
DgStyleCategories.ColumnHeadersDefaultCellStyle = hdrStyle;
for (var i = 0; i < cats.Count; i++)
{
DgStyleCategories.Columns[i].Name = string.Format("{1}: {0}", cats[i].Attributes["name"].Value, cats[i].ParentNode.Attributes["name"].Value);
}
var styles = Param.GetItems("styles/paper/style");
DgStyleCategories.RowCount = styles.Count;
DgStyleCategories.RowHeadersVisible = true;
var rhdrStyle = new DataGridViewCellStyle
{
BackColor = Color.Gray,
Font = new Font("Charis SIL", 8, FontStyle.Bold)
};
DgStyleCategories.RowHeadersDefaultCellStyle = rhdrStyle;
for (var i = 0; i < styles.Count; i++)
{
DgStyleCategories.Rows[i].HeaderCell.Value = styles[i].Attributes["name"].Value;
}
DgStyleCategories.AutoResizeRowHeadersWidth(DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders);
var windings = new Font("Wingdings", 10);
var middleCenter = DataGridViewContentAlignment.MiddleCenter;
DgStyleCategories.DefaultCellStyle.Font = windings;
DgStyleCategories.DefaultCellStyle.Alignment = middleCenter;
DgStyleCategories.RowHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
DataGridViewCell cell;
for (var r = 0; r < styles.Count; r++)
{
for (var c = 0; c < cats.Count; c++)
{
cell = DgStyleCategories.Rows[r].Cells[c];
if (cell.Value == null)
{
continue;
}
cell.Value = Param.LoadStyleCategories(Param.Name(styles[r]), Param.Name(cats[c].ParentNode), Param.Name(cats[c]));
cell.Style.ForeColor = (string)cell.Value == YES ? Color.Green : Color.Red;
}
}
}
