/// <summary>
/// Serializes a the Attributes stored in this Instance to the BinaryStream
/// </summary>
/// <param name="writer">The Stream the Data should be stored to</param>
/// <remarks>
/// Be sure that the Position of the stream is Proper on
/// return (i.e. must point to the first Byte after your actual File)
/// </remarks>
protected override void Serialize(System.IO.BinaryWriter writer)
{
if (duff)
{
return;
}
writer.Write(count == 0xffff0001 ? count : (uint)reffiles.Length);
writer.Write((uint)reffiles.Length);
for (int i = 0; i < reffiles.Length; i++)
{
SimPe.Packages.PackedFileDescriptor pfd = (SimPe.Packages.PackedFileDescriptor)reffiles[i];
writer.Write(pfd.Group);
writer.Write(pfd.Instance);
if (count == 0xffff0001)
{
writer.Write(pfd.SubType);
}
writer.Write(pfd.Type);
}
writer.Write((uint)blocks.Length);
for (int i = 0; i < blocks.Length; i++)
{
writer.Write(blocks[i].BlockID);
}
for (int i = 0; i < blocks.Length; i++)
{
IRcolBlock wrp = blocks[i];
WriteBlock(wrp, writer);
}
writer.Write(oversize);
}
/// <summary>
/// Called whenever the Data stored in the Filedescriptor gets changed
/// </summary>
/// <param name="sender"></param>
private void FileDescriptor_ChangedUserData(SimPe.Interfaces.Files.IPackedFileDescriptor sender)
{
SimPe.Packages.PackedFileDescriptor pfd = (SimPe.Packages.PackedFileDescriptor)sender;
TD.SandDock.DockControl doc = this.GetDocument(pfd);
if (doc != null)
{
SimPe.Interfaces.Plugin.IFileWrapper wrapper = (SimPe.Interfaces.Plugin.IFileWrapper)doc.Tag;
if (wrapper != null)
{
if (wrapper.Package != null)
{
string flname = wrapper.Package.FileName;
if (flname == null)
{
flname = "";
}
System.Windows.Forms.DialogResult dr = System.Windows.Forms.DialogResult.Yes;
if (!Helper.WindowsRegistry.Silent)
{
dr = Message.Show(SimPe.Localization.GetString("reschanged").Replace("{name}", doc.Text).Replace("{filename}", flname), SimPe.Localization.GetString("changed?"), System.Windows.Forms.MessageBoxButtons.YesNo);
}
if (dr == System.Windows.Forms.DialogResult.Yes)
{
wrapper.Refresh();
}
}
}
}
}
private void RcolSearch(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
if (cbusefileindex.Checked)
{
WaitingScreen.Wait();
try { SimPe.FileTable.FileIndex.Load(); }
finally { WaitingScreen.Stop(this); }
lblist.Items.Clear();
SimPe.Packages.PackedFileDescriptor pfd = new SimPe.Packages.PackedFileDescriptor();
pfd.SubType = Hashes.SubTypeHash(Hashes.StripHashFromName(tbflname.Text));
pfd.Instance = Hashes.InstanceHash(Hashes.StripHashFromName(tbflname.Text));
SimPe.Interfaces.Scenegraph.IScenegraphFileIndexItem[] items = FileTable.FileIndex.FindFileByInstance(pfd.LongInstance);
//short Index
if (items.Length == 0)
{
pfd.SubType = 0;
items = FileTable.FileIndex.FindFileByInstance(pfd.LongInstance);
}
foreach (SimPe.Interfaces.Scenegraph.IScenegraphFileIndexItem item in items)
{
lblist.Items.Add(item.Package.FileName);
}
btopen.Tag = true;
}
else
{
this.StartSearch(new SeekerFunction(this.RcolSearch), package.FindFile(Hashes.StripHashFromName(tbflname.Text)));
}
}
/// <summary>
/// Called when a Descriptor get's marked for Deletion
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DeletedDescriptor(object sender, EventArgs e)
{
SimPe.Packages.PackedFileDescriptor pfd = (SimPe.Packages.PackedFileDescriptor)sender;
TD.SandDock.DockControl doc = this.GetDocument(pfd);
if (doc != null)
{
this.CloseDocument(doc);
}
}
/// <summary>
/// Create a clone of the Descriptor, so changes won't affect the source Package anymore!
/// </summary>
/// <param name="item">Clone the Descriptor in this Item</param>
public static SimPe.Packages.PackedFileDescriptor Clone(SimPe.Interfaces.Files.IPackedFileDescriptor org)
{
SimPe.Packages.PackedFileDescriptor pfd = new SimPe.Packages.PackedFileDescriptor();
pfd.Type = org.Type;
pfd.Group = org.Group;
pfd.LongInstance = org.LongInstance;
return(pfd);
}
/// <summary>
/// Returns all matching FileIndexItems for the passed type
/// </summary>
/// <param name="type">the Type of the Files</param>
/// <param name="group">the Group of the Files</param>
/// <param name="instance">Instance Number of the File</param>
/// <returns>all FileIndexItems</returns>
public PackedFileDescriptors FindFile(uint type, uint group, ulong instance)
{
SimPe.Packages.PackedFileDescriptor pfd = new SimPe.Packages.PackedFileDescriptor();
pfd.Group = group;
pfd.Type = type;
pfd.LongInstance = instance;
return(FindFile(pfd));
}
/// <summary>
/// Create a clone of the Descriptor, so changes won't affect the source Package anymore!
/// </summary>
/// <param name="item">Clone the Descriptor in this Item</param>
public static void Clone(Interfaces.Scenegraph.IScenegraphFileIndexItem item)
{
SimPe.Packages.PackedFileDescriptor pfd = new SimPe.Packages.PackedFileDescriptor();
pfd.Type = item.FileDescriptor.Type;
pfd.Group = item.FileDescriptor.Group;
pfd.LongInstance = item.FileDescriptor.LongInstance;
pfd.Offset = item.FileDescriptor.Offset;
pfd.Size = item.FileDescriptor.Size;
pfd.UserData = item.FileDescriptor.UserData;
item.FileDescriptor = pfd;
}
public override void ExecuteEventHandler(object sender, SimPe.Events.ResourceEventArgs es)
{
if (!ChangeEnabledStateEventHandler(null, es))
{
return;
}
bool multi = es.Count > 1;
string flname = SetupSaveDialog(es[0].Resource.FileDescriptor.ExportFileName, multi);
if (flname == null)
{
return;
}
#if !DEBUG
try
#endif
{
if (!multi) //extract one File
{
SimPe.Packages.PackedFileDescriptor pfd = (SimPe.Packages.PackedFileDescriptor)es[0].Resource.FileDescriptor;
ToolLoaderItemExt.SavePackedFile(flname, true, pfd, es.LoadedPackage.Package);
pfd.Path = null;
}
else //extract multiple Files
{
SimPe.Collections.PackedFileDescriptors pfds = new SimPe.Collections.PackedFileDescriptors();
foreach (SimPe.Events.ResourceContainer e in es)
{
if (e.HasFileDescriptor)
{
pfds.Add(e.Resource.FileDescriptor);
}
}
SimPe.Interfaces.Files.IPackedFileDescriptor[] ar = new SimPe.Interfaces.Files.IPackedFileDescriptor[pfds.Length];
pfds.CopyTo(ar);
ExtractAllFiles(flname, ar, es.LoadedPackage.Package);
}
}
#if !DEBUG
catch (Exception ex)
{
Helper.ExceptionMessage(Localization.Manager.GetString("err002") + flname, ex);
}
#endif
}
/// <summary>
/// Reads all Data from the Objects.package blonging to the same group as the passed pfd
/// </summary>
/// <param name="localgroup">Thr Group of the Source Object</param>
/// <param name="package">The package that should get the Files</param>
/// <param name="pkgcontainsbase">true, if the package does already contain the Base Object</param>
/// <returns>The Modlename of that Object or null if none</returns>
public static string[] BaseClone(uint localgroup, SimPe.Packages.File package, bool pkgcontainsbase)
{
//Get the Base Object Data from the Objects.package File
ArrayList list = new ArrayList();
if (pkgcontainsbase)
{
foreach (SimPe.Interfaces.Files.IPackedFileDescriptor pfd in package.Index)
{
if ((pfd.Instance == 0x85) && (pfd.Type == Data.MetaData.STRING_FILE))
{
LoadModelName(list, pfd, package);
}
}
}
else
{
Interfaces.Scenegraph.IScenegraphFileIndexItem[] files = FileTable.FileIndex.FindFileByGroup(localgroup);
foreach (Interfaces.Scenegraph.IScenegraphFileIndexItem item in files)
{
Interfaces.Files.IPackedFile file = item.Package.Read(item.FileDescriptor);
SimPe.Packages.PackedFileDescriptor npfd = new SimPe.Packages.PackedFileDescriptor();
npfd.UserData = file.UncompressedData;
npfd.Group = item.FileDescriptor.Group;
npfd.Instance = item.FileDescriptor.Instance;
npfd.SubType = item.FileDescriptor.SubType;
npfd.Type = item.FileDescriptor.Type;
if (package.FindFile(npfd) == null)
{
package.Add(npfd);
}
if ((npfd.Instance == 0x85) && (npfd.Type == Data.MetaData.STRING_FILE))
{
LoadModelName(list, npfd, item.Package);
}
}
}
string[] refname = new string[list.Count];
list.CopyTo(refname);
return(refname);
}
/// <summary>
/// Returns a PackedFile Descriptor for the given filename
/// </summary>
/// <param name="flname"></param>
/// <param name="type"></param>
/// <param name="defgroup"></param>
/// <returns></returns>
public static Interfaces.Files.IPackedFileDescriptor BuildPfd(string flname, uint type, uint defgroup)
{
string name = Hashes.StripHashFromName(flname);
SimPe.Packages.PackedFileDescriptor pfd = new SimPe.Packages.PackedFileDescriptor();
pfd.Type = type;
pfd.Group = Hashes.GetHashGroupFromName(flname, defgroup);
pfd.Instance = Hashes.InstanceHash(name);
pfd.SubType = Hashes.SubTypeHash(name);
pfd.Filename = flname;
pfd.UserData = new byte[0];
return(pfd);
}
public void AddResourceLoop(long fid, SimPe.Packages.PackedFileDescriptor pfd, SimPe.Interfaces.Plugin.Internal.IPackedFileWrapper wrp)
{
DataRow row = tbl.NewRow();
row[1] = pfd.Type;
row[2] = pfd.Group;
row[3] = pfd.SubType;
row[4] = pfd.Instance;
if (wrp != null)
{
row[5] = wrp.ResourceName;
}
else
{
row[5] = "";
}
row[6] = 1;
tbl.Rows.Add(row);
}
protected void AddToFileIndex(SimPe.Packages.GeneratableFile file, SimPe.Packages.PackedFileDescriptor pfd)
{
file.Add(pfd);
}
private void ImportFiles(object sender, System.EventArgs e)
{
this.Cursor = Cursors.WaitCursor;
//first find the highest Instance of a BHAV, BCON in the package
Interfaces.Files.IPackedFileDescriptor[] pfds = package.FindFiles(Data.MetaData.BHAV_FILE);
uint maxbhavinst = 0x1000;
foreach (Interfaces.Files.IPackedFileDescriptor pfd in pfds)
{
if ((pfd.Instance < 0x2000) && (pfd.Instance > maxbhavinst))
{
maxbhavinst = pfd.Instance;
}
}
Hashtable bhavalias = new Hashtable();
maxbhavinst++;
//her is the BCOn part
pfds = package.FindFiles(0x42434F4E);
uint maxbconinst = 0x1000;
foreach (Interfaces.Files.IPackedFileDescriptor pfd in pfds)
{
if ((pfd.Instance < 0x2000) && (pfd.Instance > maxbconinst))
{
maxbconinst = pfd.Instance;
}
}
Hashtable bconalias = new Hashtable();
maxbconinst++;
ArrayList bhavs = new ArrayList();
ArrayList ttabs = new ArrayList();
package.BeginUpdate();
try
{
for (int i = 0; i < lbfiles.Items.Count; i++)
{
if (!lbfiles.GetItemChecked(i))
{
continue;
}
Interfaces.Scenegraph.IScenegraphFileIndexItem item = (Interfaces.Scenegraph.IScenegraphFileIndexItem)lbfiles.Items[i];
SimPe.Packages.PackedFileDescriptor npfd = new SimPe.Packages.PackedFileDescriptor();
npfd.Type = item.FileDescriptor.Type;
npfd.Group = item.FileDescriptor.Group;
npfd.Instance = item.FileDescriptor.Instance;
npfd.SubType = item.FileDescriptor.SubType;
npfd.UserData = item.Package.Read(item.FileDescriptor).UncompressedData;
package.Add(npfd);
if (npfd.Type == Data.MetaData.BHAV_FILE)
{
maxbhavinst++;
npfd.Group = 0xffffffff;
bhavalias[(ushort)npfd.Instance] = (ushort)maxbhavinst;
npfd.Instance = maxbhavinst;
SimPe.Plugin.Bhav bhav = new SimPe.Plugin.Bhav(prov.OpcodeProvider);
bhav.ProcessData(npfd, package);
if (cbname.Checked)
{
bhav.FileName = "[" + cbsemi.Text + "] " + bhav.FileName;
}
bhav.SynchronizeUserData();
bhavs.Add(bhav);
}
else if (npfd.Type == 0x42434F4E) //BCON
{
npfd.Instance = maxbconinst++;
npfd.Group = 0xffffffff;
bconalias[(ushort)npfd.Instance] = (ushort)npfd.Instance;
SimPe.Plugin.Bcon bcon = new SimPe.Plugin.Bcon();
bcon.ProcessData(npfd, package);
if (cbname.Checked)
{
bcon.FileName = "[" + cbsemi.Text + "] " + bcon.FileName;
}
bcon.SynchronizeUserData();
}
else if (npfd.Type == 0x54544142) //TTAB
{
SimPe.Plugin.Ttab ttab = new SimPe.Plugin.Ttab(prov.OpcodeProvider);
ttab.ProcessData(npfd, package);
ttabs.Add(ttab);
}
}
if (cbfix.Checked)
{
pfds = package.FindFiles(Data.MetaData.BHAV_FILE);
foreach (Interfaces.Files.IPackedFileDescriptor pfd in pfds)
{
SimPe.Plugin.Bhav bhav = new SimPe.Plugin.Bhav(prov.OpcodeProvider);
bhav.ProcessData(pfd, package);
bhavs.Add(bhav);
}
pfds = package.FindFiles(0x54544142);
foreach (Interfaces.Files.IPackedFileDescriptor pfd in pfds)
{
SimPe.Plugin.Ttab ttab = new SimPe.Plugin.Ttab(prov.OpcodeProvider);
ttab.ProcessData(pfd, package);
ttabs.Add(ttab);
}
}
//Relink all SemiGlobals in imported BHAV's
foreach (SimPe.Plugin.Bhav bhav in bhavs)
{
foreach (SimPe.PackedFiles.Wrapper.Instruction i in bhav)
{
if (bhavalias.Contains(i.OpCode))
{
i.OpCode = (ushort)bhavalias[i.OpCode];
}
}
bhav.SynchronizeUserData();
}
//Relink all TTAbs
foreach (SimPe.Plugin.Ttab ttab in ttabs)
{
foreach (SimPe.PackedFiles.Wrapper.TtabItem item in ttab)
{
if (bhavalias.Contains(item.Guardian))
{
item.Guardian = (ushort)bhavalias[item.Guardian];
}
if (bhavalias.Contains(item.Action))
{
item.Action = (ushort)bhavalias[item.Action];
}
}
ttab.SynchronizeUserData();
}
}
finally
{
package.EndUpdate();
}
this.Cursor = Cursors.Default;
Close();
}
/// <summary>
/// Creates a new File Descriptor (with Userdata) as defined by the XmlNode
/// </summary>
/// <param name="parentpath">The Path where the Package xml is located</param>
/// <param name="node">packedfile XML-Node</param>
/// <returns>A PackedFile Descriptor</returns>
protected static SimPe.Packages.PackedFileDescriptor CreateDescriptor(string parentpath, XmlNode node)
{
SimPe.Packages.PackedFileDescriptor pfd = new SimPe.Packages.PackedFileDescriptor();
foreach (XmlNode subnode in node)
{
switch (subnode.Name)
{
case "type":
{
foreach (XmlNode typenode in subnode)
{
switch (typenode.Name)
{
case "number":
{
pfd.Type = Convert.ToUInt32(typenode.InnerText);
break;
}
}
}
break;
}
case "classid":
{
pfd.SubType = Convert.ToUInt32(subnode.InnerText);
break;
}
case "group":
{
pfd.Group = Convert.ToUInt32(subnode.InnerText);
break;
}
case "instance":
{
pfd.Instance = Convert.ToUInt32(subnode.InnerText);
break;
}
}
}
//now load the Files Data
object flname = node.Attributes["name"].Value; if (flname == null)
{
flname = "";
}
object path = node.Attributes["path"].Value; if (path == null)
{
path = "";
}
pfd.Path = path.ToString();
pfd.Filename = flname.ToString();
flname = System.IO.Path.Combine(parentpath, System.IO.Path.Combine(path.ToString(), flname.ToString()));
if (File.Exists(flname.ToString()))
{
FileStream fs = System.IO.File.OpenRead(flname.ToString());
System.IO.BinaryReader mbr = new System.IO.BinaryReader(fs);
try
{
byte[] data = new byte[mbr.BaseStream.Length];
for (int i = 0; i < data.Length; i++)
{
data[i] = mbr.ReadByte();
}
pfd.UserData = data;
}
finally
{
mbr.Close();
mbr = null;
fs.Close();
fs.Dispose();
fs = null;
}
}
return(pfd);
}
/// <summary>
/// Load FileDescriptors that are stored in the given File
/// </summary>
/// <param name="flname"></param>
/// <param name="list">null or the list that should be used to add the Items</param>
/// <returns></returns>
public static void LoadDescriptorsFromDisk(string flname, PackedFileDescriptors list)
{
if (list == null)
{
return;
}
bool run = WaitingScreen.Running;
if (!run)
{
WaitingScreen.Wait();
}
WaitingScreen.UpdateMessage("Load Descriptors From Disk");
//list = new PackedFileDescriptors();
try
{
if (flname.ToLower().EndsWith("package.xml"))
{
SimPe.Packages.File pkg = Packages.GeneratableFile.LoadFromStream(XmlPackageReader.OpenExtractedPackage(null, flname));
foreach (Interfaces.Files.IPackedFileDescriptor pfd in pkg.Index)
{
Interfaces.Files.IPackedFile file = pkg.Read(pfd);
pfd.UserData = file.UncompressedData;
if (!list.Contains(pfd))
{
list.Add(pfd);
}
}
}
else if (flname.ToLower().EndsWith(".xml"))
{
Interfaces.Files.IPackedFileDescriptor pfd = XmlPackageReader.OpenExtractedPackedFile(flname);
if (!list.Contains(pfd))
{
list.Add(pfd);
}
}
else if (flname.ToLower().EndsWith(".package") || flname.ToLower().EndsWith(".simpedis"))
{
SimPe.Packages.File pkg = SimPe.Packages.File.LoadFromFile(flname);
foreach (Interfaces.Files.IPackedFileDescriptor pfd in pkg.Index)
{
Interfaces.Files.IPackedFile file = pkg.Read(pfd);
pfd.UserData = file.UncompressedData;
if (!list.Contains(pfd))
{
list.Add(pfd);
}
}
}
else
{
Packages.PackedFileDescriptor pfd = new SimPe.Packages.PackedFileDescriptor();
pfd.Type = 0xffffffff;
ToolLoaderItemExt.OpenPackedFile(flname, ref pfd);
list.Add(pfd);
}
}
finally
{
if (!run)
{
WaitingScreen.Stop();
}
}
}
public void ExecuteEventHandler(object sender, SimPe.Events.ResourceEventArgs es)
{
if (!RealChangeEnabledStateEventHandler(null, es))
{
System.Windows.Forms.MessageBox.Show(Localization.GetString("This is not an appropriate context in which to use this tool"),
Localization.GetString(this.ToString()));
return;
}
SimPe.Interfaces.Files.IPackedFileDescriptor pfd = null;
for (int i = 0; i < es.Count; i++)
{
if (es[i].HasFileDescriptor)
{
pfd = es[i].Resource.FileDescriptor; break;
}
}
Data.TypeAlias a = Helper.TGILoader.GetByType(pfd.Type);
if (Data.MetaData.RcolList.Contains(a.Id))
{
SimPe.Packages.PackedFileDescriptor fd = new SimPe.Packages.PackedFileDescriptor();
fd.Type = Data.MetaData.NAME_MAP;
fd.Group = 0x52737256;
fd.Instance = a.Id;
fd.SubType = 0;
SimPe.Plugin.Nmap nmap = new SimPe.Plugin.Nmap(FileTable.ProviderRegistry);
nmap.FileDescriptor = fd;
bool add = false;
if (es.LoadedPackage.Package.FindFile(fd) == null)
{
add = true;
}
System.Collections.ArrayList list = new System.Collections.ArrayList();
foreach (SimPe.Events.ResourceContainer e in es)
{
if (!e.HasFileDescriptor)
{
continue;
}
if (e.Resource.FileDescriptor.Type != a.Id)
{
continue;
}
try
{
SimPe.Packages.PackedFileDescriptor p = (SimPe.Packages.PackedFileDescriptor)e.Resource.FileDescriptor;
SimPe.Plugin.Rcol rcol = new SimPe.Plugin.GenericRcol(null, false);
rcol.ProcessData(p, es.LoadedPackage.Package);
p.Filename = rcol.FileName;
list.Add(p);
}
catch (Exception) {}
} //foreach
nmap.Items = new SimPe.Packages.PackedFileDescriptor[list.Count];
list.CopyTo(nmap.Items);
nmap.SynchronizeUserData();
if (add)
{
es.LoadedPackage.Package.Add(nmap.FileDescriptor);
}
}
}
/// <summary>
/// Unserializes a BinaryStream into the Attributes of this Instance
/// </summary>
/// <param name="reader">The Stream that contains the FileData</param>
protected override void Unserialize(System.IO.BinaryReader reader)
{
duff = false;
this.e = null;
count = reader.ReadUInt32();
try
{
reffiles = new Interfaces.Files.IPackedFileDescriptor[count == 0xffff0001 ? reader.ReadUInt32() : count];
for (int i = 0; i < reffiles.Length; i++)
{
SimPe.Packages.PackedFileDescriptor pfd = new SimPe.Packages.PackedFileDescriptor();
pfd.Group = reader.ReadUInt32();
pfd.Instance = reader.ReadUInt32();
pfd.SubType = (count == 0xffff0001) ? reader.ReadUInt32() : 0;
pfd.Type = reader.ReadUInt32();
reffiles[i] = pfd;
}
uint nn = reader.ReadUInt32();
index = new uint[nn];
blocks = new IRcolBlock[index.Length];
for (int i = 0; i < index.Length; i++)
{
index[i] = reader.ReadUInt32();
}
for (int i = 0; i < index.Length; i++)
{
uint id = index[i];
IRcolBlock wrp = ReadBlock(id, reader);
if (wrp == null)
{
break;
}
blocks[i] = wrp;
}
if (!fast)
{
long size = reader.BaseStream.Length - reader.BaseStream.Position;
if (size > 0)
{
oversize = reader.ReadBytes((int)size);
}
else
{
oversize = new byte[0];
}
}
}
catch (Exception e)
{
duff = true;
this.e = e;
//SimPe.Helper.ExceptionMessage(e);
}
finally { }
}
/// <summary>
/// List available resources of a given type, allowing the user to select one.
/// </summary>
/// <param name="resourceType">Type of resource to list</param>
/// <param name="group">Group number of "this" group</param>
/// <param name="form">Parent form</param>
/// <param name="skip_pages">A flag per page (this package, private, semi, global, prim) to suppress pages</param>
/// <param name="canDoEA">Whether to differentiate overriding resources</param>
/// <returns>The chosen resource entry</returns>
public pjse.FileTable.Entry Execute(uint resourceType, uint group, Control form, bool canDoEA, Boolset skip_pages)
{
CanDoEA = canDoEA;
form.Cursor = Cursors.WaitCursor;
this.Cursor = Cursors.WaitCursor;
List <TabPage> ltp = new List <TabPage>(new TabPage[] { tpPackage, tpGroup, tpSemiGroup, tpGlobalGroup, tpBuiltIn });
btnViewBHAV.Visible = resourceType == SimPe.Data.MetaData.BHAV_FILE;
this.tcResources.TabPages.Clear();
// There doesn't appear to be a way to compare two paths and have the OS decide if they refer to the same object
if (!skip_pages[0] &&
pjse.FileTable.GFT.CurrentPackage != null &&
pjse.FileTable.GFT.CurrentPackage.FileName != null &&
!pjse.FileTable.GFT.CurrentPackage.FileName.ToLower().EndsWith("objects.package"))
{
FillPackage(resourceType, this.lvPackage, this.tpPackage);
}
if (!skip_pages[1])
{
FillGroup(resourceType, group, this.lvGroup, this.tpGroup);
}
if (!skip_pages[2])
{
Glob g = pjse.BhavWiz.GlobByGroup(group);
if (g != null)
{
FillGroup(resourceType, g.SemiGlobalGroup, this.lvSemi, this.tpSemiGroup);
this.tpSemiGroup.Text = g.SemiGlobalName;
}
}
if (!skip_pages[3] && group != (uint)Group.Global)
{
FillGroup(resourceType, (uint)Group.Global, this.lvGlobal, this.tpGlobalGroup);
}
if (!skip_pages[4] && resourceType == SimPe.Data.MetaData.BHAV_FILE)
{
FillBuiltIn(resourceType, this.lvPrim, this.tpBuiltIn);
}
if (this.tcResources.TabCount > 0)
{
if (tcResources.Contains(ltp[PersistentTab]))
{
tcResources.SelectTab(ltp[PersistentTab]);
}
else
{
this.tcResources.SelectedIndex = 0;
}
}
form.Cursor = Cursors.Default;
this.Cursor = Cursors.Default;
this.Size = ChooserSize;
DialogResult dr = ShowDialog();
while (dr == DialogResult.Retry)
{
dr = ShowDialog();
}
ChooserSize = this.Size;
PersistentTab = ltp.IndexOf(this.tcResources.SelectedTab);
Close();
if (dr == System.Windows.Forms.DialogResult.OK)
{
ListView lv = getListView();
if (lv != null)
{
if (lv != lvPrim)
{
return((pjse.FileTable.Entry)lv.SelectedItems[0].Tag);
}
else
{
IPackedFileDescriptor pfd = new SimPe.Packages.PackedFileDescriptor();
pfd.Instance = (uint)lvPrim.SelectedItems[0].Tag;
return(new pjse.FileTable.Entry(null, pfd, true, true));
}
}
}
return(null);
}
