public static void AddFiles(IPackage package, List <string> sourceFilePaths)
{
List <TGIN> addedResourceKeys = new List <TGIN>();
for (int sourceFilePathIndex = 0; sourceFilePathIndex < sourceFilePaths.Count; sourceFilePathIndex++)
{
string sourceInfoFilePath = sourceFilePaths[sourceFilePathIndex] + "." + SourceInfoFileExtension;
TGIN targetResourceKeyTGIN = Path.GetFileName(sourceFilePaths[sourceFilePathIndex]);
if (File.Exists(sourceInfoFilePath))
{
try {
SourceInfo sourceInfo = (SourceInfo)Tools.ReadXML <SourceInfo>(sourceInfoFilePath);
targetResourceKeyTGIN = sourceInfo.ToTGIN();
} catch (Exception e) {
Console.Error.Write("Failed to read source info file.\n" + sourceInfoFilePath + "\n" + e.ToString());
}
}
AResourceKey targetResourceKey = targetResourceKeyTGIN;
MemoryStream sourceStream = new MemoryStream();
BinaryWriter sourceStreamWriter = new BinaryWriter(sourceStream);
using (BinaryReader sourceFileReader = new BinaryReader(new FileStream(sourceFilePaths[sourceFilePathIndex], FileMode.Open, FileAccess.Read))) {
sourceStreamWriter.Write(sourceFileReader.ReadBytes((int)sourceFileReader.BaseStream.Length));
sourceStreamWriter.Flush();
}
IResourceIndexEntry targetPreviousEntry = package.Find(targetResourceKey.Equals);
while (targetPreviousEntry != null)
{
package.DeleteResource(targetPreviousEntry);
targetPreviousEntry = package.Find(targetResourceKey.Equals);
}
IResourceIndexEntry targetEntry = package.AddResource(targetResourceKey, sourceStream, false);
if (targetEntry == null)
{
continue;
}
targetEntry.Compressed = 23106;
addedResourceKeys.Add(targetResourceKeyTGIN);
}
GenerateNameMap(package, addedResourceKeys, null);
}
public IPackage CreatePackage()
{
IPackage result = s3pi.Package.Package.NewPackage(0);
GraphNode node;
int i, count = this.nodeLookupTable.Count;
// Commit changes to resource data
Diagnostics.Log("Committing Resource Data Changes...");
for (i = 0; i < count; i++)
{
node = this.nodeLookupTable[i];
if (!node.Core.CommitChanges())
{
Diagnostics.Log("CommitChanges Failed for "
+ PrintRKTag(node.Key, node.ExtensionTag));
}
}
// Write resource data and names to package
Diagnostics.Log("Writing Resource Data To Package...");
NameMap.PackagedNMap nmap = new NameMap.PackagedNMap(result, true);
for (i = 0; i < count; i++)
{
node = this.nodeLookupTable[i];
if ((node.NodeActions & ResourceDataActions.Write) == ResourceDataActions.None)
{
continue;
}
// TODO: Ensure every resource is forced to update its stream
result.AddResource(node.Key, node.Core.Resource.Stream, false);
if (!nmap.SetName(node.Key.Instance, node.Name, false))
{
Diagnostics.Log("Failed to set NameMap Entry for "
+ PrintRKTag(node.Key, node.ExtensionTag)
+ ": \"" + node.Name + "\"");
}
}
Diagnostics.Log("Writing NameMap To Package...");
nmap.CommitChanges();
Diagnostics.Log("COMPLETE! Package is now ready to be saved.");
return(result);
}
public Resource NewResource(uint resourceType, uint resourceGroup, ulong instance, string name = null)
{
IResource res = WrapperDealer.CreateNewResource(0, "0x" + resourceType.ToString("X8"));
if (res == null)
{
return(default(Resource));
}
IResourceIndexEntry rie = _package.AddResource(new ResourceKey {
ResourceType = resourceType, ResourceGroup = resourceGroup, Instance = instance
}, res.Stream, true);
if (name != null)
{
ResourceName(rie.Instance, name);
}
return(GetResource(rie));
}
public PackagedNMap(IPackage package, bool create)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
IResource nmap;
List <IResourceIndexEntry> rieList = package.FindAll(IsNameMap);
if ((rieList == null || rieList.Count == 0) && create)
{
TGIBlock tgi = new TGIBlock(0, null, NameMapTID, 0u, 0ul);
nmap = WrapperDealer.CreateNewResource(0, NameMapTIDStr);
IResourceIndexEntry rie
= package.AddResource(tgi, nmap.Stream, false);
this.nmaps.Add(new KeyValuePair <IResourceIndexEntry,
IResource>(rie, nmap));
}
else
{
int i, count = rieList.Count;
for (i = 0; i < count; i++)
{
nmap = null;
try
{
nmap = WrapperDealer.GetResource(0, package, rieList[i]);
}
catch { }
if (nmap != null)
{
this.nmaps.Add(new KeyValuePair <IResourceIndexEntry,
IResource>(rieList[i], nmap));
}
}
}
}
public bool AddNew(ulong instance, IPackage package, bool autoSet)
{
mPackage = package;
string filename = GetFilename(autoSet, true);
if (string.IsNullOrEmpty(filename))
{
return(false);
}
string name = CreateInstance(filename, ref instance);
if (instance == 0)
{
return(false);
}
Set(mPackage.AddResource(new AResource.TGIBlock(0, null, (uint)Type, 0, instance), null, false), mPackage);
if (mEntry == null)
{
return(false);
}
if (File.Exists(filename))
{
Filename = filename;
}
else
{
mPackage.ReplaceResource(mEntry, ResourceHandlers.CreateResource(mEntry, mPackage));
}
Name = name;
return(true);
}
private void setEffectNameTSMI_Click(object sender, EventArgs e)
{
VisualEffectHandleContainer container = this.outputEffectLST.SelectedItem as VisualEffectHandleContainer;
if (container != null)
{
container.SetEffectName(this.PromptForEffectName(container.Handle.EffectName));
int index = this.outputEffectLST.SelectedIndex;
this.outputEffectLST.Items.RemoveAt(index);
this.outputEffectLST.Items.Insert(index, container);/**/
//this.outputEffectLST.Invalidate();
}
}
private void LocateMetaReferences(VisualEffectName handle, EffectResource resource,
List <VisualEffectHandleContainer> references)
{
MetaparticleEffect[] metaEffects = EffectHelper.FindEffects <MetaparticleEffect>(handle, resource);
if (metaEffects != null && metaEffects.Length > 0)
{
int i, j;
VisualEffectName dep;
string effectName;
bool flag = false;
for (i = 0; i < metaEffects.Length; i++)
{
// compensate for variations in casing
effectName = metaEffects[i].ComponentName.ToLowerInvariant();
for (j = 0; j < references.Count && !flag; j++)
{
if (references[j].OriginalName == effectName)
{
//references[j].Dependents.Add(metaEffects[i]);
flag = true;
}
}
if (!flag)
{
dep = EffectHelper.FindVisualEffectHandle(effectName, resource);
if (dep != null)
{
references.Add(new VisualEffectHandleContainer(
new VisualEffectName(0, null, dep), resource));
this.LocateMetaReferences(dep, resource, references);
}
}
flag = false;
// compensate for variations in casing
effectName = metaEffects[i].ComponentType.ToLowerInvariant();
for (j = 0; j < references.Count && !flag; j++)
{
if (references[j].OriginalName == effectName)
{
//references[j].Dependents.Add(metaEffects[i]);
flag = true;
}
}
if (!flag)
{
dep = EffectHelper.FindVisualEffectHandle(effectName, resource);
if (dep != null)
{
references.Add(new VisualEffectHandleContainer(
new VisualEffectName(0, null, dep), resource));
this.LocateMetaReferences(dep, resource, references);
}
}
flag = false;
}
}
}
private void LocateSeqReferences(VisualEffectName handle, EffectResource resource,
List <VisualEffectHandleContainer> references)
{
SequenceEffect[] seqEffects = EffectHelper.FindEffects <SequenceEffect>(handle, resource);
if (seqEffects != null && seqEffects.Length > 0)
{
int i, j, k;
VisualEffectName dep;
SequenceEffect seqEffect;
string effectName;
bool flag = false;
for (i = 0; i < seqEffects.Length; i++)
{
seqEffect = seqEffects[i];
for (j = 0; j < seqEffect.Elements.Count; j++)
{
// compensate for variations in casing
effectName = seqEffect.Elements[j].EffectName.ToLowerInvariant();
for (k = 0; k < references.Count && !flag; k++)
{
if (references[k].OriginalName == effectName)
{
//references[j].Dependents.Add(seqEffects[i]);
flag = true;
}
}
if (!flag)
{
dep = EffectHelper.FindVisualEffectHandle(effectName, resource);
if (dep != null)
{
references.Add(new VisualEffectHandleContainer(
new VisualEffectName(0, null, dep), resource));
this.LocateSeqReferences(dep, resource, references);
}
}
flag = false;
}
}
}
}
private void cloneEffect_Click(object sender, EventArgs e)
{
VisualEffectName handle = (this.inputEffectLST.SelectedItem as VisualEffectHandleContainer).Handle;
EffectResource owner = (this.inputEffectLST.SelectedItem as VisualEffectHandleContainer).Owner;
if (handle != null)
{
VisualEffectHandleContainer con;
foreach (VisualEffectHandleContainer container in this.outputEffectLST.Items)
{
if (container.Handle.Index == handle.Index)
{
MessageBox.Show("Selected effect has already been cloned.");
return;
}
}
con = new VisualEffectHandleContainer(new VisualEffectName(0, null, handle), owner);
con.SetEffectName(this.PromptForEffectName(con.OriginalName));
this.outputEffectLST.Items.Add(con);
List <VisualEffectHandleContainer> references = new List <VisualEffectHandleContainer>();
this.LocateMetaReferences(handle, owner, references);
int metaCount = references.Count;
this.LocateSeqReferences(handle, owner, references);
int seqCount = references.Count - metaCount;
if (references.Count > 0)
{
string format;
if (metaCount > 0)
{
if (seqCount > 0)
{
format = "{0} has metaparticle and sequence effects.\n";
}
else
{
format = "{0} has metaparticle effects.\n";
}
}
else
{
format = "{0} has sequence effects.\n";
}
DialogResult result = MessageBox.Show(
//string.Concat(handle.EffectName, " has metaparticle and/or sequence effects.\n",
string.Concat(string.Format(format, handle.EffectName),
"Would you like to clone all effects referenced by them?"),
"Clone Referenced Effects", MessageBoxButtons.YesNo);
if (result == System.Windows.Forms.DialogResult.Yes)
{
for (int i = 0; i < references.Count; i++)
{
con = references[i];
con.SetEffectName(this.PromptForEffectName(con.OriginalName));
this.outputEffectLST.Items.Add(con);
}
}
}
this.saveOutputBTN.Enabled = true;
this.printOutputBTN.Enabled = true;
}
}
private void removeEffect_Click(object sender, EventArgs e)
{
int index = this.outputEffectLST.SelectedIndex;
if (index >= 0)
{
this.outputEffectLST.Items.RemoveAt(index);
}
if (this.outputEffectLST.Items.Count == 0)
{
this.saveOutputBTN.Enabled = false;
this.printOutputBTN.Enabled = false;
}
}
private void saveOutput_Click(object sender, EventArgs e)
{
/*if (this.mEffectResource == null)
* {
* MessageBox.Show("Please open an effect file to clone effects from it.");
* return;
* }
* if (this.outputEffectLST.Items.Count == 0)
* {
* MessageBox.Show("Please select at least one effect from the left list to clone.");
* return;
* }/**/
using (SaveFileDialog dialog = new SaveFileDialog())
{
dialog.Title = "Save Effect Clone";
dialog.Filter = kEffectDialogFilter;
dialog.AddExtension = true;
dialog.OverwritePrompt = true;
DialogResult result = dialog.ShowDialog();
if (result == DialogResult.OK)
{
string resName = Path.GetFileNameWithoutExtension(dialog.FileName);
ulong resHash = System.Security.Cryptography.FNV64.GetHash(resName);
string fileName = dialog.FileName;
string extension = Path.GetExtension(fileName).ToLowerInvariant();
if (extension == ".effects")
{
resName = kEffectS3piNameHead + resHash.ToString("X16") + "_" + resName
+ kEffectS3piNameTail;
string prompt = "Would you like to save the effect file as:\n\n" + resName
+ "\n\ninstead of:\n\n" + Path.GetFileName(fileName);
result = MessageBox.Show(prompt, "Make S3PI File Name?", MessageBoxButtons.YesNo);
if (result == DialogResult.Yes)
{
fileName = dialog.FileName.Replace(Path.GetFileNameWithoutExtension(fileName), resName);
}
else
{
fileName = dialog.FileName;
}
}
VisualEffectHandleContainer con;
int i, count = this.outputEffectLST.Items.Count;
for (i = 0; i < count; i++)
{
con = this.outputEffectLST.Items[i] as VisualEffectHandleContainer;
this.mOutputEffectResBuilder.AddVisualEffect(con.Handle, con.Owner);
}
this.mOutputEffectResBuilder.FlushEffects();
for (i = 0; i < count; i++)
{
con = this.outputEffectLST.Items[i] as VisualEffectHandleContainer;
this.mOutputEffectResBuilder.SetAllEffectReferences(con.OriginalName, con.Handle.EffectName);
}
//EffectResource output = this.mInputEffectResBuilder.BuildResource();
//this.mInputEffectResBuilder.ResetOld();
if (extension == ".effects")
{
using (FileStream fileStream = new FileStream(fileName, FileMode.Create))
{
this.mOutputEffectResBuilder.UnParse(fileStream);
/*Stream stream = output.Stream;
* int length = (int)stream.Length;
* byte[] buffer = new byte[length];
* stream.Read(buffer, 0, length);
* fileStream.Write(buffer, 0, length);/**/
}
}
else if (extension == ".package")
{
// Fail-safe to prevent accidental collision with existing SWB resources
//resHash = System.Security.Cryptography.FNV64.GetHash(resName + DateTime.Now.ToString());
TGIBlock effectKey = new TGIBlock(0, null, kEffectTID, kEffectGID, resHash);
MemoryStream mStream = new MemoryStream();
this.mOutputEffectResBuilder.UnParse(mStream);
TGIBlock nameMapKey = new TGIBlock(0, null, 0x0166038C, 0, 0L);
NameMapResource.NameMapResource nameMap
= new NameMapResource.NameMapResource(0, null);
nameMap.Add(resHash, resName);
IPackage effectPackage = s3pi.Package.Package.NewPackage(0);
effectPackage.AddResource(effectKey, mStream, false);
effectPackage.AddResource(nameMapKey, nameMap.Stream, false);
effectPackage.SaveAs(fileName);
}
this.outputEffectLST.Items.Clear();
this.mOutputEffectResBuilder = new EffectResourceBuilder();
}
}
}
private void exportResourceToPackage(IPackage tgtpkg, IResourceIndexEntry srcrie, bool replace)
{
IResourceIndexEntry rie = tgtpkg.Find(x => ((IResourceKey)srcrie).Equals(x));
if (rie != null)
{
if (!replace) return;
tgtpkg.DeleteResource(rie);
}
rie = tgtpkg.AddResource(srcrie, null, true);
if (rie == null) return;
rie.Compressed = srcrie.Compressed;
IResource srcres = s4pi.WrapperDealer.WrapperDealer.GetResource(0, CurrentPackage, srcrie, true);//Don't need wrapper
tgtpkg.ReplaceResource(rie, srcres);
}
static void Translate(FileInfo inFile, String outPath, XmlDictionary dict)
{
if (!File.Exists(inFile.FullName))
{
throw new FileNotFoundException(inFile.FullName);
}
String _outFile = outPath + "\\" + inFile.Name;
if (!Directory.Exists(outPath))
{
Directory.CreateDirectory(outPath);
}
IPackage _package = Package.OpenPackage(-1, inFile.FullName);
Byte _targetCode = 0;
var _stblIndexEntry = new List <KeyValuePair <IResourceIndexEntry, IResourceIndexEntry> >();
{
List <IResourceIndexEntry> _resourceEntry = _package.GetResourceList;
var _stblRes = _resourceEntry.Where((o) => { return(o.ResourceType == 0x220557DA); });
Byte _sourceCode = dict.To == TranslateTo.B ? dict.LanguageA : dict.LanguageB;
IEnumerable <IResourceIndexEntry> _stblScoure = _stblRes.Where((o) => { return(GetLanguageCode(o.Instance) == _sourceCode); });
_targetCode = dict.To == TranslateTo.A ? dict.LanguageA : dict.LanguageB;
IEnumerable <IResourceIndexEntry> _stblTarget = _stblRes.Where((o) => { return(GetLanguageCode(o.Instance) == _targetCode); });
foreach (var s in _stblScoure)
{
Boolean hasTarget = false;
UInt64 _is = s.Instance << (4 * 2);
foreach (var t in _stblTarget)
{
UInt64 _it = t.Instance << (4 * 2);
if (s.ResourceType == t.ResourceType &&
s.ResourceGroup == t.ResourceGroup &&
_is == _it)
{
hasTarget = true;
_stblIndexEntry.Add(new KeyValuePair <IResourceIndexEntry, IResourceIndexEntry>(s, t));
break;
}
}
if (!hasTarget)
{
_stblIndexEntry.Add(new KeyValuePair <IResourceIndexEntry, IResourceIndexEntry>(s, null));
}
}
}
if (_stblIndexEntry.Count() == 0)
{
_package.SaveAs(_outFile);
throw new ApplicationException($"源语言不存在，文件未修改。文件：{_outFile}");
}
else
{
var _newDict = new XmlDictionary(dict.LanguageA, dict.LanguageB, dict.To);
Int32 _changedCount = 0;
foreach (var item in _stblIndexEntry)
{
IResource res = WrapperDealer.GetResource(-1, _package, item.Key, false);
Stream _fs = res.Stream;
List <StringEntry> _stringList = ReadStbl(inFile.Name, _fs, item.Key);
foreach (var str in _stringList)
{
if (dict.TryFind(str.Text, inFile.Name, str.Ident, out String s))
{
str.Text = s;
_changedCount++;
}
else
{
Entry _entry = new Entry(str.Text, str.Text, str.Ident, inFile.Name);
_newDict.Add(_entry);
}
}
var _ms = new MemoryStream();
StringListToStbl(_ms, _stringList);
if (item.Value == null)
{
var _rk = new TranslateResourceIndexEntry();
_rk.ResourceGroup = item.Key.ResourceGroup;
_rk.ResourceType = item.Key.ResourceType;
_rk.Instance = item.Key.Instance;
_rk.Instance = _rk.Instance << (4 * 2);
_rk.Instance = _rk.Instance >> (4 * 2);
_rk.Instance = _rk.Instance + ((( UInt64 )_targetCode) << (4 * 14));
_package.AddResource(_rk, _ms, true);
}
else
{
var _st = new StblResource.StblResource(0, _ms);
_package.ReplaceResource(item.Value, _st);
}
_package.SaveAs(_outFile);
}
if (_newDict.Count != 0)
{
throw new EntryNotFoundException(_newDict, _changedCount);
}
}
}
public bool MergeNamemap(IEnumerable <KeyValuePair <ulong, string> > newMap, bool create, bool replace)
{
if (nameMap == null)
{
CreateNameMap();
}
if (nameMap == null || nameMap.Count == 0 && create)
{
IResourceIndexEntry rie = pkg.AddResource(new TGIBlock(0, null, 0x0166038C, 0, 0), null, false);
if (rie != null)
{
Add(rie, false);
}
CreateNameMap();
if (nameMap == null)
{
string s = "Resource names cannot be added. Other than that, you should be fine. Carry on.";
CopyableMessageBox.Show(s, "s3pe", CopyableMessageBoxButtons.OK, CopyableMessageBoxIcon.Warning);
return(false);
}
}
try
{
IDictionary <ulong, string> nmap = nameMap[0] as IDictionary <ulong, string>;
if (nmap == null)
{
return(false);
}
foreach (var kvp in newMap)
{
if (nmap.ContainsKey(kvp.Key))
{
if (replace)
{
nmap[kvp.Key] = kvp.Value;
}
}
else
{
nmap.Add(kvp.Key, kvp.Value);
}
}
pkg.ReplaceResource(nameMapRIEs[0], nameMap[0]);
if (selectedResource != null && selectedResource.Tag as IResourceIndexEntry == nameMapRIEs[0])
{
OnSelectedResourceChanged(this, new ResourceChangedEventArgs(selectedResource));
}
}
catch (Exception ex)
{
string s = "Resource names cannot be added. Other than that, you should be fine. Carry on.";
s += String.Format("\n\nError updating _KEY {0}\n", "" + nameMapRIEs[0]);
MainForm.IssueException(ex, s);
return(false);
}
return(true);
}
private void CompareFiles_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(LeftText.Text))
{
System.Windows.Forms.MessageBox.Show("The Left File has not been selected.", "Compare", MessageBoxButtons.OK);
return;
}
else if (string.IsNullOrEmpty(RightText.Text))
{
System.Windows.Forms.MessageBox.Show("The Right File has not been selected.", "Compare", MessageBoxButtons.OK);
return;
}
else if (string.IsNullOrEmpty(ResultsText.Text))
{
System.Windows.Forms.MessageBox.Show("The Results File has not been selected.", "Compare", MessageBoxButtons.OK);
return;
}
IPackage leftPackage = Package.OpenPackage(0, LeftText.Text);
if (leftPackage == null)
{
System.Windows.Forms.MessageBox.Show("The Left File could not be opened.", "Compare", MessageBoxButtons.OK);
return;
}
IPackage rightPackage = Package.OpenPackage(0, RightText.Text);
if (rightPackage == null)
{
System.Windows.Forms.MessageBox.Show("The Right File could not be opened.", "Compare", MessageBoxButtons.OK);
Package.ClosePackage(0, leftPackage);
return;
}
IPackage resultsPackage = Package.NewPackage(0);
if (resultsPackage == null)
{
System.Windows.Forms.MessageBox.Show("The Right File could not be opened.", "Compare", MessageBoxButtons.OK);
Package.ClosePackage(0, leftPackage);
Package.ClosePackage(0, rightPackage);
return;
}
try
{
UseWaitCursor = true;
NameMapResource.NameMapResource keyResource = null;
IResourceIndexEntry leftKey = leftPackage.Find(key => key.ResourceType == (uint)ResourceType._KEY);
if (leftKey != null)
{
NameMapResource.NameMapResource leftResource = ResourceHandlers.CreateResource(leftKey, leftPackage) as NameMapResource.NameMapResource;
IResourceIndexEntry keyEntry = resultsPackage.AddResource(new AResource.TGIBlock(0, null, leftKey.ResourceType, leftKey.ResourceGroup, leftKey.Instance), leftResource.Stream, false);
if (keyEntry != null)
{
keyResource = ResourceHandlers.CreateResource(keyEntry, resultsPackage) as NameMapResource.NameMapResource;
}
}
IResourceIndexEntry rightKey = rightPackage.Find(key => key.ResourceType == (uint)ResourceType._KEY);
if (rightKey != null)
{
NameMapResource.NameMapResource rightResource = ResourceHandlers.CreateResource(rightKey, rightPackage) as NameMapResource.NameMapResource;
if (keyResource == null)
{
IResourceIndexEntry keyEntry = resultsPackage.AddResource(new AResource.TGIBlock(0, null, rightKey.ResourceType, rightKey.ResourceGroup, rightKey.Instance), rightResource.Stream, false);
if (keyEntry != null)
{
keyResource = ResourceHandlers.CreateResource(keyEntry, resultsPackage) as NameMapResource.NameMapResource;
}
}
else
{
foreach (KeyValuePair <ulong, string> element in rightResource)
{
if (keyResource.ContainsKey(element.Key))
{
continue;
}
keyResource.Add(element.Key, element.Value);
}
}
}
IList <IResourceIndexEntry> leftList = leftPackage.FindAll(value => { return(true); });
foreach (IResourceIndexEntry left in leftList)
{
ResourceType type = (ResourceType)left.ResourceType;
bool test = false;
switch (type)
{
case ResourceType._XML:
case ResourceType.ITUN:
test = true;
break;
}
if (!test)
{
continue;
}
IResourceIndexEntry right = rightPackage.Find(value => { return((value.Instance == left.Instance) && (value.ResourceGroup == left.ResourceGroup) && (value.ResourceType == left.ResourceType)); });
if (right == null)
{
if (CheckCopyMissing.Checked)
{
TextResource.TextResource leftResource = ResourceHandlers.CreateResource(left, leftPackage) as TextResource.TextResource;
resultsPackage.AddResource(new AResource.TGIBlock(0, null, left.ResourceType, left.ResourceGroup, left.Instance), leftResource.Stream, false);
}
}
else
{
TextResource.TextResource leftResource = ResourceHandlers.CreateResource(left, leftPackage) as TextResource.TextResource;
StreamReader leftReader = leftResource.TextFileReader as StreamReader;
leftReader.BaseStream.Position = 0;
string leftText = leftReader.ReadToEnd();
TextResource.TextResource rightResource = ResourceHandlers.CreateResource(right, rightPackage) as TextResource.TextResource;
StreamReader rightReader = rightResource.TextFileReader as StreamReader;
rightReader.BaseStream.Position = 0;
string rightText = rightReader.ReadToEnd();
if (!leftText.Equals(rightText))
{
resultsPackage.AddResource(new AResource.TGIBlock(0, null, left.ResourceType, left.ResourceGroup, left.Instance), leftResource.Stream, false);
}
}
}
IList <IResourceIndexEntry> rightList = rightPackage.FindAll(value => { return(true); });
foreach (IResourceIndexEntry right in rightList)
{
ResourceType type = (ResourceType)right.ResourceType;
bool test = false;
switch (type)
{
case ResourceType._XML:
case ResourceType.ITUN:
test = true;
break;
}
if (!test)
{
continue;
}
IResourceIndexEntry left = rightPackage.Find(value => { return((value.Instance == right.Instance) && (value.ResourceGroup == right.ResourceGroup) && (value.ResourceType == right.ResourceType)); });
if (left == null)
{
if (CheckCopyMissing.Checked)
{
TextResource.TextResource rightResource = ResourceHandlers.CreateResource(right, rightPackage) as TextResource.TextResource;
resultsPackage.AddResource(new AResource.TGIBlock(0, null, right.ResourceType, right.ResourceGroup, right.Instance), rightResource.Stream, false);
}
}
}
resultsPackage.SaveAs(ResultsText.Text);
}
finally
{
Package.ClosePackage(0, leftPackage);
Package.ClosePackage(0, rightPackage);
Package.ClosePackage(0, resultsPackage);
UseWaitCursor = false;
}
System.Windows.Forms.MessageBox.Show("Complete.", "Compare", MessageBoxButtons.OK);
}
public static void GenerateNameMap(IPackage package, List <TGIN> addedResourceKeys, List <TGIN> removedResourceKeys)
{
AResourceKey nameMapKey = new TGIBlock(0, null, 23462796u, 0u, 0uL);
IResourceIndexEntry nameMapEntry = package.Find(nameMapKey.Equals);
if (nameMapEntry == null)
{
nameMapEntry = package.AddResource(nameMapKey, null, false);
}
if (nameMapEntry != null)
{
NameMapResource.NameMapResource nameMapResource = (NameMapResource.NameMapResource)WrapperDealer.GetResource(0, package, nameMapEntry);
if (nameMapResource == null || !typeof(IDictionary <ulong, string>).IsAssignableFrom(nameMapResource.GetType()))
{
package.DeleteResource(nameMapEntry);
nameMapEntry = package.AddResource(nameMapKey, null, false);
nameMapResource = (NameMapResource.NameMapResource)WrapperDealer.GetResource(0, package, nameMapEntry);
}
if (removedResourceKeys != null)
{
for (int removedResourceKeyIndex = 0; removedResourceKeyIndex < removedResourceKeys.Count; removedResourceKeyIndex++)
{
if (nameMapResource.Contains(removedResourceKeys[removedResourceKeyIndex].ResInstance))
{
nameMapResource.Remove(removedResourceKeys[removedResourceKeyIndex].ResInstance);
}
}
}
if (addedResourceKeys != null)
{
for (int addedResourceKeyIndex = 0; addedResourceKeyIndex < addedResourceKeys.Count; addedResourceKeyIndex++)
{
if (addedResourceKeys[addedResourceKeyIndex].ResName == null)
{
continue;
}
if (nameMapResource.Contains(addedResourceKeys[addedResourceKeyIndex].ResInstance))
{
nameMapResource[addedResourceKeys[addedResourceKeyIndex].ResInstance] = addedResourceKeys[addedResourceKeyIndex].ResName;
}
else
{
nameMapResource.Add(addedResourceKeys[addedResourceKeyIndex].ResInstance, addedResourceKeys[addedResourceKeyIndex].ResName);
}
}
}
List <KeyValuePair <ulong, string> > orderedNameMapResource = nameMapResource.ToList();
orderedNameMapResource.Sort((pair1, pair2) => pair1.Value.CompareTo(pair2.Value));
nameMapResource.Clear();
for (int orderedNameMapResourceIndex = 0; orderedNameMapResourceIndex < orderedNameMapResource.Count; orderedNameMapResourceIndex++)
{
nameMapResource.Add(orderedNameMapResource[orderedNameMapResourceIndex].Key, orderedNameMapResource[orderedNameMapResourceIndex].Value);
}
package.ReplaceResource(nameMapEntry, nameMapResource);
}
}
public bool AddNew(ulong instance, IPackage package, bool autoSet)
{
mPackage = package;
string filename = GetFilename(autoSet, true);
if (string.IsNullOrEmpty(filename)) return false;
string name = CreateInstance(filename, ref instance);
if (instance == 0) return false;
Set (mPackage.AddResource(new AResource.TGIBlock(0, null, (uint)Type, 0, instance), null, false), mPackage);
if (mEntry == null) return false;
if (File.Exists(filename))
{
Filename = filename;
}
else
{
mPackage.ReplaceResource(mEntry, ResourceHandlers.CreateResource(mEntry, mPackage));
}
Name = name;
return true;
}
