BrawlCrate.NodeWrappers.ARCWrapper Class Reference

Inheritance diagram for BrawlCrate.NodeWrappers.ARCWrapper:

Public Member Functions
	ARCWrapper ()
ARCNode	NewARC ()
BRRESNode	NewBRES ()
CollisionNode	NewCollision ()
BLOCNode	NewBLOC ()
MSBinNode	NewMSBin ()
SCLANode	NewSCLA ()
STPMNode	NewSTPM ()
ADSJNode	NewADSJ ()
ITOVNode	NewITOV ()
T	NewStageTable< T > ()
T	NewStageTable< T > (int numEntries)
HavokNode	NewHavok ()
ARCEntryNode	NewRedirect ()
void	ImportARC ()
void	ImportBRES ()
void	ImportBLOC ()
void	ImportCollision ()
void	ImportMSBin ()
void	ImportBinary ()
void	ImportSCLA ()
void	ImportSTPM ()
void	ImportSTDT ()
void	ImportTBCL ()
void	ImportTBGC ()
void	ImportTBGD ()
void	ImportTBGM ()
void	ImportTBLV ()
void	ImportTBRM ()
void	ImportTBST ()
void	ImportHavok ()
void	ImportADSJ ()
void	ImportITOV ()
void	LoadModels (ResourceNode node, List< IModel > models, List< CollisionNode > collisions)
void	PreviewAll ()
void	ExportAll ()
void	SortChildrenByFileIndex ()
void	ReplaceAll ()
Public Member Functions inherited from BrawlCrate.NodeWrappers.GenericWrapper
	GenericWrapper (IWin32Window owner)
	GenericWrapper ()
virtual void	Sort ()
void	MoveUp ()
virtual void	MoveUp (bool select)
void	MoveDown ()
virtual void	MoveDown (bool select)
void	DeleteSelected ()
void	ExportSelected ()
virtual string	Export ()
virtual void	OnExport (string outPath)
virtual void	Replace ()
virtual void	OnReplace (string inStream)
void	Restore ()
virtual void	Delete ()
void	Rename ()
virtual ResourceNode	Duplicate ()
virtual ResourceNode	Duplicate (bool changeName)
Public Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
void	Link (ResourceNode res)
void	Unlink ()

Static Protected Member Functions
static void	NewBRESAction (object sender, EventArgs e)
static void	NewARCAction (object sender, EventArgs e)
static void	NewMSBinAction (object sender, EventArgs e)
static void	NewCollisionAction (object sender, EventArgs e)
static void	NewBLOCAction (object sender, EventArgs e)
static void	NewSCLAAction (object sender, EventArgs e)
static void	NewSTPMAction (object sender, EventArgs e)
static void	NewADSJAction (object sender, EventArgs e)
static void	NewITOVAction (object sender, EventArgs e)
static void	NewStageTableAction< T > (object sender, EventArgs e)
static void	NewRedirectAction (object sender, EventArgs e)
static void	ImportBRESAction (object sender, EventArgs e)
static void	ImportARCAction (object sender, EventArgs e)
static void	ImportBLOCAction (object sender, EventArgs e)
static void	ImportCollisionAction (object sender, EventArgs e)
static void	ImportMSBinAction (object sender, EventArgs e)
static void	ImportBinaryAction (object sender, EventArgs e)
static void	ImportSCLAAction (object sender, EventArgs e)
static void	ImportSTDTAction (object sender, EventArgs e)
static void	ImportSTPMAction (object sender, EventArgs e)
static void	ImportADSJAction (object sender, EventArgs e)
static void	ImportTBCLAction (object sender, EventArgs e)
static void	ImportTBGCAction (object sender, EventArgs e)
static void	ImportTBGDAction (object sender, EventArgs e)
static void	ImportTBGMAction (object sender, EventArgs e)
static void	ImportTBLVAction (object sender, EventArgs e)
static void	ImportTBRMAction (object sender, EventArgs e)
static void	ImportTBSTAction (object sender, EventArgs e)
static void	ImportHavokAction (object sender, EventArgs e)
static void	ImportITOVAction (object sender, EventArgs e)
static void	PreviewAllAction (object sender, EventArgs e)
static void	ExportAllAction (object sender, EventArgs e)
static void	ReplaceAllAction (object sender, EventArgs e)
Static Protected Member Functions inherited from BrawlCrate.NodeWrappers.GenericWrapper
static void	MoveUpAction (object sender, EventArgs e)
static void	MoveDownAction (object sender, EventArgs e)
static void	ExportAction (object sender, EventArgs e)
static void	ExportSelectedAction (object sender, EventArgs e)
static void	DeleteSelectedAction (object sender, EventArgs e)
static void	DuplicateAction (object sender, EventArgs e)
static void	ReplaceAction (object sender, EventArgs e)
static void	RestoreAction (object sender, EventArgs e)
static void	DeleteAction (object sender, EventArgs e)
static void	RenameAction (object sender, EventArgs e)
static void	SortAction (object sender, EventArgs e)
Static Protected Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
static T	GetInstance< T > ()
static IEnumerable< T >	GetInstances< T > ()

Properties
override string	ExportFilter [get]
override string	ImportFilter [get]
Properties inherited from BrawlCrate.NodeWrappers.GenericWrapper
virtual ContextMenuStrip	MultiSelectMenuStrip [get]
virtual string	DefaultName [get]
virtual string	ExportFilter [get]
virtual string	ImportFilter [get]
virtual string	ReplaceFilter [get]
Properties inherited from BrawlCrate.NodeWrappers.BaseWrapper
ResourceNode	Resource [get]
virtual ? Color	DefaultBackColor [get]
virtual ? Color	DefaultForeColor [get]
Properties inherited from BrawlCrate.NodeWrappers.MultiSelectableWrapper
ContextMenuStrip	MultiSelectMenuStrip [get]

Additional Inherited Members
Static Public Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
static BaseWrapper[]	GetAllNodes (BaseWrapper root)
static BaseWrapper	Wrap (ResourceNode node)
static BaseWrapper	Wrap (IWin32Window owner, ResourceNode node)
Static Public Attributes inherited from BrawlCrate.NodeWrappers.BaseWrapper
static IWin32Window	_owner
Protected Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
	BaseWrapper ()
Protected Attributes inherited from BrawlCrate.NodeWrappers.BaseWrapper
bool	_discovered
ResourceNode	_resource
Static Protected Attributes inherited from BrawlCrate.NodeWrappers.BaseWrapper
static readonly ContextMenuStrip	_emptyMenu = new ContextMenuStrip()

Constructor & Destructor Documentation

ARCWrapper()

BrawlCrate.NodeWrappers.ARCWrapper.ARCWrapper ( )

inline

        {
            ContextMenuStrip = _menu;
        }

Member Function Documentation

ExportAll()

void BrawlCrate.NodeWrappers.ARCWrapper.ExportAll ( )

inline

        {
            string path = Program.ChooseFolder();
            if (path == null)
            {
                return;
            }
            var hasTextures = Resource.GetChildrenRecursive().Any(c => c is TEX0Node);
            if (hasTextures)
            {
                ExportAllFormatDialog dialog =
                    new ExportAllFormatDialog("Export All", typeof(TEX0Node), FileFilters.TEX0);
 
                if (dialog.ShowDialog() == DialogResult.OK)
                {
                    ((ARCNode)_resource).ExtractToFolder(path, dialog.SelectedExtension);
                }
            }
            else
            {
                ((ARCNode)_resource).ExtractToFolder(path);
            }
        }

ExportAllAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ExportAllAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ExportAll();
        }

ImportADSJ()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportADSJ ( )

inline

        {
            if (Program.OpenFiles(FileFilters.ADSJ, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewADSJ().Replace(path);
                }
            }
        }

ImportADSJAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportADSJAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportADSJ();
        }

ImportARC()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportARC ( )

inline

        {
            if (Program.OpenFiles(FileFilters.ARCImport, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewARC().Replace(path);
                }
            }
        }

ImportARCAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportARCAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportARC();
        }

ImportBinary()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportBinary ( )

inline

        {
            if (Program.OpenFiles(FileFilters.Raw, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    ResourceNode n = NodeFactory.FromFile(null, path);
                    if (n is ARCEntryNode r)
                    {
                        r.FileType = ARCFileType.MiscData;
                    }
                    else
                    {
                        n.Dispose();
                        n = NodeFactory.FromFile(null, path, typeof(ARCEntryNode));
                        ((ARCEntryNode)n).FileType = ARCFileType.MiscData;
                    }
                    Resource.AddChild(n);
                    n.Name = "Misc Data [0]";
 
                    BaseWrapper w = FindResource(n, false);
                    w.EnsureVisible();
                    w.TreeView.SelectedNode = w;
                }
            }
        }

ImportBinaryAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportBinaryAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportBinary();
        }

ImportBLOC()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportBLOC ( )

inline

        {
            if (Program.OpenFiles(FileFilters.BLOC, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewBLOC().Replace(path);
                }
            }
        }

ImportBLOCAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportBLOCAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportBLOC();
        }

ImportBRES()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportBRES ( )

inline

        {
            if (Program.OpenFiles(FileFilters.BRES, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewBRES().Replace(path);
                }
            }
        }

ImportBRESAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportBRESAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportBRES();
        }

ImportCollision()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportCollision ( )

inline

        {
            if (Program.OpenFiles(FileFilters.CollisionDef, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewCollision().Replace(path);
                }
            }
        }

ImportCollisionAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportCollisionAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportCollision();
        }

ImportHavok()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportHavok ( )

inline

        {
            if (Program.OpenFiles(FileFilters.Havok, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewHavok().Replace(path);
                }
            }
        }

ImportHavokAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportHavokAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportHavok();
        }

ImportITOV()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportITOV ( )

inline

        {
            if (Program.OpenFiles(FileFilters.ITOV, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewITOV().Replace(path);
                }
            }
        }

ImportITOVAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportITOVAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportITOV();
        }

ImportMSBin()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportMSBin ( )

inline

        {
            if (Program.OpenFiles(FileFilters.MSBin, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewMSBin().Replace(path);
                }
            }
        }

ImportMSBinAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportMSBinAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportMSBin();
        }

ImportSCLA()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportSCLA ( )

inline

        {
            if (Program.OpenFiles(FileFilters.SCLA, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewSCLA().Replace(path);
                }
            }
        }

ImportSCLAAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportSCLAAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportSCLA();
        }

ImportSTDT()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportSTDT ( )

inline

        {
            if (Program.OpenFiles(FileFilters.STDT, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewStageTable<STDTNode>().Replace(path);
                }
            }
        }

ImportSTDTAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportSTDTAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportSTDT();
        }

ImportSTPM()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportSTPM ( )

inline

        {
            if (Program.OpenFiles(FileFilters.STPM, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    NewSTPM().Replace(path);
                }
            }
        }

ImportSTPMAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportSTPMAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportSTPM();
        }

ImportTBCL()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBCL ( )

inline

        {
            if (Program.OpenFiles(FileFilters.TBCL, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    //NewStageTable<TBCLNode>().Replace(path);
                }
            }
        }

ImportTBCLAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBCLAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportTBCL();
        }

ImportTBGC()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBGC ( )

inline

        {
            if (Program.OpenFiles(FileFilters.TBGC, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    //NewStageTable<TBGCNode>().Replace(path);
                }
            }
        }

ImportTBGCAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBGCAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportTBGC();
        }

ImportTBGD()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBGD ( )

inline

        {
            if (Program.OpenFiles(FileFilters.TBGD, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    //NewStageTable<TBGDNode>().Replace(path);
                }
            }
        }

ImportTBGDAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBGDAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportTBGD();
        }

ImportTBGM()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBGM ( )

inline

        {
            if (Program.OpenFiles(FileFilters.TBGM, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    //NewStageTable<TBGMNode>().Replace(path);
                }
            }
        }

ImportTBGMAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBGMAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportTBGM();
        }

ImportTBLV()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBLV ( )

inline

        {
            if (Program.OpenFiles(FileFilters.TBLV, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    //NewStageTable<TBLVNode>().Replace(path);
                }
            }
        }

ImportTBLVAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBLVAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportTBLV();
        }

ImportTBRM()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBRM ( )

inline

        {
            if (Program.OpenFiles(FileFilters.TBRM, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    //NewStageTable<TBRMNode>().Replace(path);
                }
            }
        }

ImportTBRMAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBRMAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportTBRM();
        }

ImportTBST()

void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBST ( )

inline

        {
            if (Program.OpenFiles(FileFilters.TBST, out string[] paths) > 0)
            {
                foreach (string path in paths)
                {
                    //NewStageTable<TBSTNode>().Replace(path);
                }
            }
        }

ImportTBSTAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ImportTBSTAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ImportTBST();
        }

LoadModels()

void BrawlCrate.NodeWrappers.ARCWrapper.LoadModels ( ResourceNode  node, List< IModel >  models, List< CollisionNode >  collisions  )

inline

        {
            switch (node.ResourceFileType)
            {
                case ResourceType.ARC:
                case ResourceType.MRG:
                case ResourceType.U8:
                case ResourceType.U8Folder:
                case ResourceType.BRES:
                case ResourceType.BRESGroup:
                    foreach (ResourceNode n in node.Children)
                    {
                        LoadModels(n, models, collisions);
                    }
 
                    break;
                case ResourceType.MDL0:
                    models.Add((IModel) node);
                    break;
                case ResourceType.CollisionDef:
                    collisions.Add((CollisionNode) node);
                    break;
            }
        }

NewADSJ()

ADSJNode BrawlCrate.NodeWrappers.ARCWrapper.NewADSJ ( )

inline

        {
            ADSJNode node = new ADSJNode { FileType = ARCFileType.MiscData };
            _resource.AddChild(node);
            node.UpdateName();
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewADSJAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.NewADSJAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().NewADSJ();
        }

NewARC()

ARCNode BrawlCrate.NodeWrappers.ARCWrapper.NewARC ( )

inline

        {
            ARCNode node = new ARCNode {Name = _resource.FindName("NewARChive"), FileType = ARCFileType.MiscData};
            _resource.AddChild(node);
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewARCAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.NewARCAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().NewARC();
        }

NewBLOC()

BLOCNode BrawlCrate.NodeWrappers.ARCWrapper.NewBLOC ( )

inline

        {
            BLOCNode node = new BLOCNode {FileType = ARCFileType.MiscData};
            _resource.AddChild(node);
            node.UpdateName();
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewBLOCAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.NewBLOCAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().NewBLOC();
        }

NewBRES()

BRRESNode BrawlCrate.NodeWrappers.ARCWrapper.NewBRES ( )

inline

        {
            BRRESNode node = new BRRESNode {FileType = ARCFileType.MiscData};
            _resource.AddChild(node);
            node.UpdateName();
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewBRESAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.NewBRESAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().NewBRES();
        }

NewCollision()

CollisionNode BrawlCrate.NodeWrappers.ARCWrapper.NewCollision ( )

inline

        {
            CollisionNode node = new CollisionNode {FileType = ARCFileType.MiscData};
            _resource.AddChild(node);
            node.UpdateName();
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewCollisionAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.NewCollisionAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().NewCollision();
        }

NewHavok()

HavokNode BrawlCrate.NodeWrappers.ARCWrapper.NewHavok ( )

inline

        {
            HavokNode node = new HavokNode {Name = _resource.FindName("NewHavokData"), FileType = ARCFileType.MiscData};
            _resource.AddChild(node);
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewITOV()

ITOVNode BrawlCrate.NodeWrappers.ARCWrapper.NewITOV ( )

inline

        {
            ITOVNode node = new ITOVNode { FileType = ARCFileType.MiscData, FileIndex = 20000 };
            _resource.AddChild(node);
            node.UpdateName();
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewITOVAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.NewITOVAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().NewITOV();
        }

NewMSBin()

MSBinNode BrawlCrate.NodeWrappers.ARCWrapper.NewMSBin ( )

inline

        {
            MSBinNode node = new MSBinNode {FileType = ARCFileType.MiscData};
            _resource.AddChild(node);
            node.UpdateName();
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewMSBinAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.NewMSBinAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().NewMSBin();
        }

NewRedirect()

ARCEntryNode BrawlCrate.NodeWrappers.ARCWrapper.NewRedirect ( )

inline

        {
            ARCEntryNode node = new ARCEntryNode
                {FileType = ARCFileType.MiscData, _resourceType = ResourceType.Redirect};
            _resource.AddChild(node);
            node.RedirectIndex = 0;
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewRedirectAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.NewRedirectAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().NewRedirect();
        }

NewSCLA()

SCLANode BrawlCrate.NodeWrappers.ARCWrapper.NewSCLA ( )

inline

        {
            SCLANode node = new SCLANode {FileType = ARCFileType.MiscData};
            _resource.AddChild(node);
            node.UpdateName();
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewSCLAAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.NewSCLAAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().NewSCLA();
        }

NewStageTable< T >() [1/2]

T BrawlCrate.NodeWrappers.ARCWrapper.NewStageTable< T > ( )

inline

Type Constraints

T	:	StageTableNode
T	:	new()

                                            : StageTableNode, new()
        {
            return NewStageTable<T>(0);
        }

NewStageTable< T >() [2/2]

T BrawlCrate.NodeWrappers.ARCWrapper.NewStageTable< T > ( int  numEntries )

inline

Type Constraints

T	:	StageTableNode
T	:	new()

                                                          : StageTableNode, new()
        {
            T node = new T {FileType = ARCFileType.MiscData};
            while (node.NumEntries < numEntries)
            {
                node.EntryList.Add(0);
            }
 
            _resource.AddChild(node);
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewStageTableAction< T >()

static void BrawlCrate.NodeWrappers.ARCWrapper.NewStageTableAction< T > ( object  sender, EventArgs  e  )

inlinestaticprotected

Type Constraints

T	:	StageTableNode
T	:	new()

                                                                                         : StageTableNode, new()
        {
            using (NumericInputForm entryCount = new NumericInputForm())
            {
                if (entryCount.ShowDialog($"{typeof(T).Name} Generation", "Number of Entries:") == DialogResult.OK)
                {
                    GetInstance<ARCWrapper>().NewStageTable<T>(entryCount.NewValue);
                }
            }
        }

NewSTPM()

STPMNode BrawlCrate.NodeWrappers.ARCWrapper.NewSTPM ( )

inline

        {
            STPMNode node = new STPMNode {FileType = ARCFileType.MiscData};
            _resource.AddChild(node);
            node.UpdateName();
 
            BaseWrapper w = FindResource(node, false);
            w.EnsureVisible();
            w.TreeView.SelectedNode = w;
            return node;
        }

NewSTPMAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.NewSTPMAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().NewSTPM();
        }

PreviewAll()

void BrawlCrate.NodeWrappers.ARCWrapper.PreviewAll ( )

inline

        {
            List<IModel> models = new List<IModel>();
            List<CollisionNode> collisions = new List<CollisionNode>();
            LoadModels(_resource, models, collisions);
            new ModelForm().Show(_owner, models, collisions);
        }

PreviewAllAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.PreviewAllAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().PreviewAll();
        }

ReplaceAll()

void BrawlCrate.NodeWrappers.ARCWrapper.ReplaceAll ( )

inline

        {
            string path = Program.ChooseFolder();
            if (path == null)
            {
                return;
            }
 
            ((ARCNode) _resource).ReplaceFromFolder(path);
        }

ReplaceAllAction()

static void BrawlCrate.NodeWrappers.ARCWrapper.ReplaceAllAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<ARCWrapper>().ReplaceAll();
        }

SortChildrenByFileIndex()

void BrawlCrate.NodeWrappers.ARCWrapper.SortChildrenByFileIndex ( )

inline

        {
            ((ARCNode)_resource).SortChildrenByFileIndex();
            RefreshView(_resource);
        }

Property Documentation

ExportFilter

override string BrawlCrate.NodeWrappers.ARCWrapper.ExportFilter

get

ImportFilter

override string BrawlCrate.NodeWrappers.ARCWrapper.ImportFilter

get

---

The documentation for this class was generated from the following file:

• BrawlCrate/NodeWrappers/Archives/ARCWrapper.cs