public ResourceKey(int APIversion, EventHandler handler, IResourceKey basis) : this(APIversion, handler) { this.instance = basis.Instance; this.ResourceGroup = basis.ResourceGroup; this.ResourceType = basis.ResourceType; }
/// <summary> /// Take into account some of the weird ways in which one resource refers to another, based on resource type. /// </summary> /// <param name="rk">An <c>IResourceKey</c> to compare with.</param> /// <returns></returns> public new int CompareTo(IResourceKey rk) { int res = this.ResourceType.CompareTo(rk.ResourceType); if (res != 0) return res; res = (this.ResourceGroup & 0x07FFFFFF).CompareTo(rk.ResourceGroup & 0x07FFFFFF); if (res != 0) return res; return ((this.ResourceType == 0x736884F1 && this.Instance >> 32 == 0) ? this.Instance & 0x07FFFFFF : this.Instance) .CompareTo(((rk.ResourceType == 0x736884F1 && rk.Instance >> 32 == 0) ? rk.Instance & 0x07FFFFFF : rk.Instance)); }
/// <summary> /// Instantiate a new <see cref="TGIN"/> based on the <see cref="IResourceKey"/> and <paramref name="name"/>. /// </summary> /// <param name="rk">An <see cref="IResourceKey"/>.</param> /// <param name="name">A <see cref="String"/>, the name of the resource.</param> public TGIN(IResourceKey rk, string name) { this.ResType = rk.ResourceType; this.ResGroup = rk.ResourceGroup; this.ResInstance = rk.Instance; this.ResName = name; }
public static bool Contains(IResourceKey rk) { return(ExcludedResources != null && ExcludedResources.Exists(mrk => (!mrk.ResourceType.HasValue || mrk.ResourceType.Value == rk.ResourceType) && (!mrk.ResourceGroup.HasValue || mrk.ResourceGroup.Value == rk.ResourceGroup) && (!mrk.Instance.HasValue || mrk.Instance.Value == rk.Instance))); }
public override void CreateKindredRK(IResourceKey parentKey, IResourceKey newParentKey, ref IResourceKey kindredKey) { kindredKey.ResourceType = this.thumType; kindredKey.ResourceGroup = (uint)(this.isCWAL ? 1 : 0); kindredKey.Instance = newParentKey.Instance; }
protected override bool ICanSlurpRK(IResourceKey key) { // From Catlg_removeRefdCatlgs return (!Enum.IsDefined(typeof(CatalogType), key.ResourceType) || key.Instance == base.originalKey.Instance) && (base.includeDDSes || !ResourceGraph.IsDDS(key.ResourceType)); }
string Compare(IPackage pkgA, IPackage pkgB, IResourceKey rk) { IResource left = s3pi.WrapperDealer.WrapperDealer.GetResource(0, pkgA, pkgA.Find(x => x.CompareTo(rk) == 0), true); IResource right = s3pi.WrapperDealer.WrapperDealer.GetResource(0, pkgB, pkgB.Find(x => x.CompareTo(rk) == 0), true); return(left.AsBytes.CompareTo(right.AsBytes) == 0 ? "=" : "!"); }
bool importFile(string filename, TGIN tgin, bool useName, bool rename, bool compress, DuplicateHandling dups, bool select) { IResourceKey rk = (TGIBlock)tgin; string resName = tgin.ResName; bool nmOK = true; MemoryStream ms = new MemoryStream(); BinaryWriter w = new BinaryWriter(ms); BinaryReader r = new BinaryReader(new FileStream(filename, FileMode.Open, FileAccess.Read)); w.Write(r.ReadBytes((int)r.BaseStream.Length)); r.Close(); w.Flush(); if (useName && resName != null && resName.Length > 0) { nmOK = browserWidget1.ResourceName(rk.Instance, resName, true, rename); } IResourceIndexEntry rie = NewResource(rk, ms, dups, compress); if (rie != null) { browserWidget1.Add(rie, select); } return(nmOK); }
public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { AApiVersionedFieldsCTD.TypedValuePropertyDescriptor pd = (AApiVersionedFieldsCTD.TypedValuePropertyDescriptor)context.PropertyDescriptor; IResourceKeyCTD rkCTD = (IResourceKeyCTD)pd.GetValue(null); AApiVersionedFields owner = rkCTD.owner; string field = rkCTD.field; object component = rkCTD.component; IResourceKey rk = (IResourceKey)AApiVersionedFieldsCTD.GetFieldValue(owner, field).Value; if (typeof(IResourceKey).IsAssignableFrom(value.GetType())) { IResourceKey rkNew = (IResourceKey)value; rk.ResourceType = rkNew.ResourceType; rk.ResourceGroup = rkNew.ResourceGroup; rk.Instance = rkNew.Instance; return(rk); } if (value != null && value is string) { if (AResourceKey.TryParse((string)value, rk)) { return(rk); } else { throw new NotSupportedException("Invalid data: " + (string)value); } } return(base.ConvertFrom(context, culture, value)); }
MemoryStream TextEdit(IResourceKey key, IResource res) { return(s3pi.Helpers.HelperManager.Edit(key, res, Settings.Default.TextEditorCmd, Settings.Default.TextEditorWantsQuotes, Settings.Default.TextEditorIgnoreTS)); }
public DefaultConnection(IResourceKey rk, RKContainer rkContainer, ResourceDataActions childActions, string absolutePath) : base(rk, absolutePath, childActions) { this.rkContainer = rkContainer; }
public bool Equals(IResourceKey other) { return(other != null && this.IID == other.Instance && this.GID == other.ResourceGroup && this.TID == other.ResourceType); }
MemoryStream HexEdit(IResourceKey key, IResource res) { return(s4pi.Helpers.HelperManager.Edit(key, res, S4PIDemoFE.Properties.Settings.Default.HexEditorCmd, S4PIDemoFE.Properties.Settings.Default.HexEditorWantsQuotes, S4PIDemoFE.Properties.Settings.Default.HexEditorIgnoreTS)); }
protected internal void SetKindredRK(IResourceKey newParentKey) { IResourceKey kinKey = this.Child.Key; this.Core.CreateKindredRK(this.Parent.OriginalKey, newParentKey, ref kinKey); this.Child.Key = new RK(kinKey); }
public GraphNode(ResourceGraph graph, IResourceKey originalKey, IResourceNode core, PathPackageTuple origin, ResourceDataActions nodeActions, RFileType fileType = RFileType.Unknown) { this.Graph = graph; this.key = new RK(originalKey); this.OriginalKey = new RK(originalKey); this.ExtensionTag = s3pi.Extensions.ExtList.Ext[originalKey.ResourceType][0]; this.NodeActions = nodeActions; this.Core = core; this.Origin = origin; if (fileType == RFileType.Unknown) { this.fileType = ResourceGraph.GetFileType(originalKey.ResourceType); } else { this.fileType = fileType; } switch (this.fileType) { case RFileType.Game: this.name = NameMap.GameNMap.GetName(originalKey.Instance, origin); break; case RFileType.DDS: this.name = NameMap.DDSNMap.GetName(originalKey.Instance, origin); break; case RFileType.Thum: this.name = NameMap.ThumNMap.GetName(originalKey.Instance, origin); break; } this.originalName = this.name; }
public static List <SpecificResource> SlurpKindredResources( IResourceKey parentKey, IResourceKinHelper kinHelper) { List <SpecificResource> resources = new List <SpecificResource>(); int i, j; List <PathPackageTuple> ppts = FileTable.GameContent; if (kinHelper.IsKinDDS) { ppts = FileTable.DDSImages; } if (kinHelper.IsKinThum) { ppts = FileTable.Thumbnails; } if (ppts != null) { SlurpKindredRKsHelper helper = new SlurpKindredRKsHelper(parentKey, kinHelper); List <IResourceIndexEntry> entries; for (i = 0; i < ppts.Count; i++) { entries = ppts[i].Package.FindAll(helper.IsKindred); if (entries != null) { for (j = 0; j < entries.Count; j++) { helper.Seen.Add(entries[j]); resources.Add(new SpecificResource(ppts[i], entries[j])); } } } } return(resources); }
protected override bool ICanSlurpRK(IResourceKey key) { // From Catlg_removeRefdCatlgs return((!Enum.IsDefined(typeof(CatalogType), key.ResourceType) || key.Instance == base.originalKey.Instance) && (base.includeDDSes || !ResourceGraph.IsDDS(key.ResourceType))); }
public ResourceDetails(IResourceKey key, bool useName = true) { AvaloniaXamlLoader.Load(this); DataContext = new ResourceDetailsViewModel(useName, key); SetupDragAndDrop(); }
/*public override bool SetParentReferenceRK(IResourceKey newKey) * { * string[] fieldNames = this.contentFieldPath.Split(new char[] { '.' }, * StringSplitOptions.RemoveEmptyEntries); * if (fieldNames.Length == 1) * { * IResourceKey rk = this.rootField as IResourceKey; * rk.Instance = newKey.Instance; * } * int i, j, index, indexStrStart, indexStrLength; * TypedValue tv; * string name; * AApiVersionedFields field = this.rootField; * for (i = 1; i < fieldNames.Length; i++) * { * name = fieldNames[i]; * indexStrStart = name.IndexOf('['); * if (indexStrStart == -1) * { * tv = field[name]; * // TODO: Should we account for the possibility of value type resource keys? * if (typeof(IResourceKey).IsAssignableFrom(tv.Type)) * { * IResourceKey rk = tv.Value as IResourceKey; * rk.Instance = newKey.Instance; * field[name] = tv; * return true; * } * if (typeof(TextReader).IsAssignableFrom(tv.Type)) * { * this.textFieldHelper.SetReferenceRK(base.OriginalChildKey, newKey); * field[name] = new TypedValue(tv.Type, this.textFieldHelper.FlushReferenceRKs()); * } * field = tv.Value as AApiVersionedFields; * } * else * { * indexStrLength = name.IndexOf(']'); * if (indexStrLength == -1) * indexStrLength = name.Length - 1 - indexStrStart; * else * indexStrLength = indexStrLength - 1 - indexStrStart; * index = int.Parse(name.Substring(indexStrStart, indexStrLength)); * tv = field[name.Substring(0, indexStrStart)]; * j = -1; * foreach (var e in tv.Value as IEnumerable) * { * if (index == ++j) * { * if (e is IResourceKey) * { * IResourceKey rk = e as IResourceKey; * rk.Instance = newKey.Instance; * return true; * } * else if (e is IEnumerable) * { * IEnumerable list = e as IEnumerable; * string suffix = name.Substring(indexStrStart + indexStrLength + 1); * indexStrStart = suffix.IndexOf('['); * while (indexStrStart != -1) * { * indexStrLength = suffix.IndexOf(']'); * if (indexStrLength == -1) * indexStrLength = suffix.Length - 1 - indexStrStart; * else * indexStrLength = indexStrLength - 1 - indexStrStart; * int subIndex = int.Parse(suffix.Substring(indexStrStart, indexStrLength)); * int k = -1; * foreach (var f in list) * { * if (index == ++k) * { * if (f is IResourceKey) * { * IResourceKey rk = f as IResourceKey; * rk.Instance = newKey.Instance; * return true; * } * else if (f is IEnumerable) * { * list = f as IEnumerable; * suffix = suffix.Substring(indexStrStart + indexStrLength + 1); * indexStrStart = suffix.IndexOf('['); * } * else * { * field = f as AApiVersionedFields; * } * } * } * } * } * else * { * field = e as AApiVersionedFields; * } * } * } * } * } * return false; * }/**/ public DefaultConnection(IResourceKey rk, AApiVersionedFields rkField, ResourceDataActions childActions, string absolutePath, string rkFieldPath = "root", Predicate <IResourceKey> validate = null) : base(rk, absolutePath, childActions) { this.rkContainer = new RKContainer(rkFieldPath, rkField, absolutePath, validate); }
protected override bool ICanSlurpRK(IResourceKey key) { return key.ResourceType != 0x034AEECB //CASP && base.isDeepClone || ( key.ResourceType != 0x00B2D882 //_IMG && key.ResourceType != 0x0333406C //_XML && key.ResourceType != 0x8FFB80F6 //_DDS ); }
protected override bool ICanSlurpRK(IResourceKey key) { return(key.ResourceType != 0x034AEECB && //CASP base.isDeepClone || ( key.ResourceType != 0x00B2D882 && //_IMG key.ResourceType != 0x0333406C && //_XML key.ResourceType != 0x8FFB80F6 //_DDS )); }
public AResourceConnection(IResourceKey childKey, string path, ResourceDataActions childActions) { this.absolutePath = path; this.originalChildKey = childKey; this.childDataActions = childActions; this.isChildDDS = ResourceGraph.IsDDS(childKey.ResourceType); this.isChildThum = ResourceGraph.IsThum(childKey.ResourceType); }
public int Add(IResourceKey key) { if (mKeys.Contains(key)) { return(mKeys.IndexOf(key)); } mKeys.Add(key); return(mKeys.Count - 1); }
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { if (destinationType.Equals(typeof(string))) { IResourceKeyCTD ctd = value as IResourceKeyCTD; IResourceKey rk = (IResourceKey)GetFieldValue(ctd.owner, ctd.field).Value; return("" + rk); } return(base.ConvertTo(context, culture, value, destinationType)); }
/// <summary> /// Add a resource, identified by <paramref name="rk"/> with the content from <paramref name="stream"/> /// the package referenced by this <see cref="PathPackageTuple"/>. The new <see cref="SpecificResource"/> /// value is returned. /// </summary> /// <param name="rk">The <see cref="IResourceKey"/> to use to identify the new resource.</param> /// <param name="stream">A <see cref="Stream"/> of data to use to populate the new resource.</param> /// <returns>The <see cref="SpecificResource"/> representing the newly added <see cref="IResourceIndexEntry"/>.</returns> public SpecificResource AddResource(IResourceKey rk, Stream stream = null) { IResourceIndexEntry rie = Package.AddResource(rk, stream, true); if (rie == null) { return(null); } return(new SpecificResource(this, rie)); }
public TrackMask(int APIversion, EventHandler handler, uint version, IResourceKey rigKey, float vertexAnimBlendWeight, byte[] unused, TrackMaskList trackMasks) : base(APIversion, handler, null) { mVersion = version; mRigKey = rigKey == null ? new TGIBlock(APIversion, handler, kRigKeyOrder) : new TGIBlock(APIversion, handler, kRigKeyOrder, rigKey); mVertexAnimBlendWeight = vertexAnimBlendWeight; mUnused = unused ?? (version < 0x201 ? new byte[48] : new byte[28]); mTrackMasks = trackMasks ?? new TrackMaskList(handler); }
public override bool SetRK(IResourceKey newKey, IResourceKey originalKey) { bool success = true; int i, count = this.kindredRCOLChunkKeys.Count; for (i = 0; i < count; i++) { this.kindredRCOLChunkKeys[i].Instance = newKey.Instance; } return(success && base.SetRK(newKey, originalKey)); }
/// <summary> /// Retrieve a resource node to contain the given resource, /// readying the appropriate node class or the default node class /// </summary> /// <param name="resource">The resource to contain in a resource node</param> /// <param name="resourceKey">The identifying key of the given resource, /// which is used to find the right node to contain it</param> /// <param name="AlwaysDefault">When true, indicates ResourceNodeDealer /// should always use the <see cref="DefaultNode"/> class</param> /// <returns>A resource node containing the given resource</returns> public static IResourceNode GetResource(IResource resource, IResourceKey resourceKey, bool AlwaysDefault = false) { if (AlwaysDefault) { return(new DefaultNode(resource, resourceKey)); } else { return(NodeForType(resource, resourceKey)); } }
public override bool IsKindred(IResourceKey parentKey, IResourceKey key) { if (this.thumInstance != 0) { return(key.ResourceType == this.thumType && key.Instance == this.thumInstance && (!this.isCWAL || (key.ResourceGroup & 0x00FFFFFF) > 0)); } return(key.ResourceType == this.thumType && key.Instance == parentKey.Instance && (!this.isCWAL || (key.ResourceGroup & 0x00FFFFFF) > 0)); }
public ResourceDetails(bool useName, bool displayFilename, IResourceKey rk) : this(useName, displayFilename) { internalchg = true; try { ResourceType = rk.ResourceType; ResourceGroup = rk.ResourceGroup; Instance = rk.Instance; btnOK.Enabled = btnOKCanEnable; } finally { internalchg = false; UpdateTGIN(); } }
/// <summary> /// Compare this <see cref="AResourceKey"/> to another <see cref="IResourceKey"/> for sort order purposes /// </summary> /// <param name="other">Target <see cref="IResourceKey"/></param> /// <returns>A 32-bit signed integer that indicates the relative order of the objects being compared. The return value has these meanings: /// <table> /// <thead><tr><td><strong>Value</strong></td><td><strong>Meaning</strong></td></tr></thead> /// <tbody> /// <tr><td>Less than zero</td><td>This instance is less than <paramref name="other"/>.</td></tr> /// <tr><td>Zero</td><td>This instance is equal to <paramref name="other"/>.</td></tr> /// <tr><td>Greater than zero</td><td>This instance is greater than <paramref name="other"/>.</td></tr> /// </tbody> /// </table> /// </returns> /// <exception cref="NotImplementedException">Either this object's Type or the target's is not comparable</exception> /// <exception cref="ArgumentException">The target is not comparable with this object</exception> public int CompareTo(IResourceKey other) { int res = ResourceType.CompareTo(other.ResourceType); if (res != 0) { return(res); } res = ResourceGroup.CompareTo(other.ResourceGroup); if (res != 0) { return(res); } return(Instance.CompareTo(other.Instance)); }
public IResourceIndexEntry Add(IResourceKey rk) { ResourceIndexEntry rc = new ResourceIndexEntry(new Int32[Hdrsize], new Int32[numFields - Hdrsize]); rc.ResourceType = rk.ResourceType; rc.ResourceGroup = rk.ResourceGroup; rc.Instance = rk.Instance; rc.Chunkoffset = 0xffffffff; rc.Unknown2 = 1; rc.ResourceStream = null; base.Add(rc); return(rc); }
public override bool SetRK(IResourceKey oldKey, IResourceKey newKey) { RKPos rkPos; int foundIndex = -1; for (int i = 0; i < this.oldToNewRKs.Count; i++) { rkPos = this.oldToNewRKs[i]; if (rkPos.OldResourceKey.Equals(oldKey)) { rkPos.NewResourceKey = new RK(newKey); foundIndex = i; } } return foundIndex != -1; }
static uint CreateReferenceHelper(GenericRCOLResource rcol, IResourceKey rk) { int i = rcol.ChunkEntries.FindIndex(x => x.TGIBlock.Equals(rk)); if (i < 0) { i = rcol.Resources.FindIndex(x => x.Equals(rk)); return(i < 0 ? 0 : (uint)(i + 1) | 0x30000000); } else { i++; return(i < rcol.publicChunks ? (uint)i : (uint)i | 0x10000000); } }
/// <summary> /// Add a resource to the package /// </summary> /// <param name="rk">The resource key</param> /// <param name="stream">The stream that contains the resource data</param> /// <param name="rejectDups">If true, fail if the resource key already exists</param> /// <returns>Null if rejectDups and the resource key exists; else the new IResourceIndexEntry</returns> public override IResourceIndexEntry AddResource(IResourceKey rk, Stream stream, bool rejectDups) { if (rejectDups && Index[rk] != null && !Index[rk].IsDeleted) { return(null); } IResourceIndexEntry newrc = Index.Add(rk); if (stream != null) { (newrc as ResourceIndexEntry).ResourceStream = stream; } return(newrc); }
public override List<SpecificResource> FindKindredResources(IResourceKey parentKey) { if (this.thumType == 0) return null; if (this.isCWAL) return ResourceGraph.SlurpKindredResources(parentKey, this); List<SpecificResource> results = new List<SpecificResource>(); SpecificResource sr = THUM.getItem(this.isPNG, this.thumInstance != 0 ? this.thumInstance : parentKey.Instance, this.thumType); if (sr != null && sr.Resource != null) results.Add(sr); return results; }
public static bool TryParse(string value, out IResourceKey result) { result = (AResourceKey)new s4pi.Extensions.TGIN(); string[] tgi = value.Trim().ToLower().Split('-'); if (tgi.Length != 3) return false; foreach (var x in tgi) if (!x.StartsWith("0x")) return false; uint tg; if (!uint.TryParse(tgi[0].Substring(2), System.Globalization.NumberStyles.HexNumber, null, out tg)) return false; result.ResourceType = tg; if (!uint.TryParse(tgi[1].Substring(2), System.Globalization.NumberStyles.HexNumber, null, out tg)) return false; result.ResourceGroup = tg; ulong i; if (!ulong.TryParse(tgi[2].Substring(2), System.Globalization.NumberStyles.HexNumber, null, out i)) return false; result.Instance = i; return true; }
public ThumbnailKinFinder(IResourceKey parentKey, IResource parent, THUM.THUMSize size) : base(size.ToString()) { this.isPNG = false; if (THUM.CType(parentKey) == CatalogType.ModularResource) { this.thumType = 0; } else if (THUM.CType(parentKey) == CatalogType.CAS_Part) { this.thumType = THUM.getThumbType(parentKey.ResourceType, size, false); } else { this.thumInstance = (parent != null) ? (ulong)parent["CommonBlock.PngInstance"].Value : 0; this.isPNG = this.thumInstance != 0; this.thumType = THUM.getThumbType(parentKey.ResourceType, size, this.isPNG); } this.CompleteKinName(); }
//find the chunk, replace the chunk, perhaps create or remove the reference public static void ReplaceChunk(this GenericRCOLResource rcolResource, MLOD.Mesh mesh, string field, IResourceKey rk, ARCOLBlock block) { ARCOLBlock current = GenericRCOLResource.ChunkReference.GetBlock(rcolResource, (GenericRCOLResource.ChunkReference)mesh[field].Value) as ARCOLBlock; if (block != null) { if (current != null) // replacing is easy { if (current.Tag != block.Tag) throw new Exception(string.Format("mesh field {0} is '{1}' but replacement is '{2}'.", field, current.Tag, block.Tag)); // ...not entirely sure if these are required... current.Data = block.Data; block = current; } else // adding is okay { rcolResource.ChunkEntries.Add(new GenericRCOLResource.ChunkEntry(0, null, new TGIBlock(0, null, rk), block)); mesh[field] = new TypedValue(typeof(GenericRCOLResource.ChunkReference), GenericRCOLResource.ChunkReference.CreateReference(rcolResource, rk), "X"); } } else // deleting is not allowed - we can only null the reference, not remove the chunk { mesh[field] = new TypedValue(typeof(GenericRCOLResource.ChunkReference), new GenericRCOLResource.ChunkReference(0, null, 0), "X"); } }
public virtual bool IsKindred(IResourceKey parentKey, IResourceKey key) { return key.Instance == parentKey.Instance; }
public virtual bool SetRK(IResourceKey newKey, IResourceKey originalKey) { return true; }
/// <summary> /// Instantiate a new <see cref="TGIN"/> based on the <see cref="IResourceKey"/> and <paramref name="name"/>. /// </summary> /// <param name="rk">An <see cref="IResourceKey"/>.</param> /// <param name="name">A <see cref="String"/>, the name of the resource.</param> public TGIN(IResourceKey rk, string name) { ResType = rk.ResourceType; ResGroup = rk.ResourceGroup; ResInstance = rk.Instance; ResName = name; }
/// <summary> /// Add a resource to the package /// </summary> /// <param name="rk">The resource key</param> /// <param name="stream">The stream that contains the resource data</param> /// <param name="rejectDups">If true, fail if the resource key already exists</param> /// <returns>Null if rejectDups and the resource key exists; else the new IResourceIndexEntry</returns> public abstract IResourceIndexEntry AddResource(IResourceKey rk, Stream stream, bool rejectDups);
void HexEdit(IResourceKey key, IResource res) { try { this.Enabled = false; Application.DoEvents(); MemoryStream ms = s4pi.Helpers.HelperManager.Edit(key, res, S4PIDemoFE.Properties.Settings.Default.HexEditorCmd, S4PIDemoFE.Properties.Settings.Default.HexEditorWantsQuotes, S4PIDemoFE.Properties.Settings.Default.HexEditorIgnoreTS); MakeFormVisible(); Application.DoEvents(); afterEdit(ms); } finally { this.Enabled = true; } }
public int CompareTo(IResourceKey other) { int res = ResourceType.CompareTo(other.ResourceType); if (res != 0) return res; res = ResourceGroup.CompareTo(other.ResourceGroup); if (res != 0) return res; return Instance.CompareTo(other.Instance); }
public abstract IResourceNode CreateKin(IResource resource, IResourceKey originalKey, object constraints);
public bool Equals(IResourceKey x, IResourceKey y) { return x.Equals(y); }
public CatalogObjectNode(IResource resource, IResourceKey originalKey) : base(resource, originalKey) { }
public CASPresetXmlNode(IResource resource, IResourceKey originalKey) : base(resource, originalKey) { }
public override bool SetRK(IResourceKey oldKey, IResourceKey newKey) { RKElem elem; bool success = false; for (int i = 0; i < this.oldToNewRKs.Count; i++) { elem = this.oldToNewRKs[i]; if (elem.OldResourceKey.Equals(oldKey)) { elem.NewResourceKey = new RK(newKey); success = true; } } return success; }
public int GetHashCode(IResourceKey obj) { return obj.GetHashCode(); }
public bool Equals(IResourceKey other) { return CompareTo(other) == 0; }
MemoryStream HexEdit(IResourceKey key, IResource res) { return s4pi.Helpers.HelperManager.Edit(key, res, S4PIDemoFE.Properties.Settings.Default.HexEditorCmd, S4PIDemoFE.Properties.Settings.Default.HexEditorWantsQuotes, S4PIDemoFE.Properties.Settings.Default.HexEditorIgnoreTS); }
public virtual void CreateKindredRK(IResourceKey parentKey, IResourceKey newParentKey, ref IResourceKey kindredKey) { kindredKey.Instance = newParentKey.Instance; }
private IResourceIndexEntry NewResource(IResourceKey rk, MemoryStream ms, DuplicateHandling dups, bool compress) { IResourceIndexEntry rie = CurrentPackage.Find(x => rk.Equals(x)); if (rie != null) { if (dups == DuplicateHandling.reject) return null; if (dups == DuplicateHandling.replace) CurrentPackage.DeleteResource(rie); } rie = CurrentPackage.AddResource(rk, ms, false);//we do NOT want to search again... if (rie == null) return null; rie.Compressed = (ushort)(compress ? 0x5A42 : 0); IsPackageDirty = true; return rie; }
public AResourceNode(IResource resource, IResourceKey originalKey) { this.resource = resource; }
/// <summary> /// Add a resource to the package /// </summary> /// <param name="rk">The resource key</param> /// <param name="stream">The stream that contains the resource data</param> /// <param name="rejectDups">If true, fail if the resource key already exists</param> /// <returns>Null if rejectDups and the resource key exists; else the new IResourceIndexEntry</returns> public override IResourceIndexEntry AddResource(IResourceKey rk, Stream stream, bool rejectDups) { if (rejectDups && Index[rk] != null && !Index[rk].IsDeleted) return null; IResourceIndexEntry newrc = Index.Add(rk); if (stream != null) (newrc as ResourceIndexEntry).ResourceStream = stream; return newrc; }