BrawlCrate.NodeWrappers.BaseWrapper Class Reference

Inheritance diagram for BrawlCrate.NodeWrappers.BaseWrapper:

Public Member Functions
void	Link (ResourceNode res)
void	Unlink ()

Static Public Member Functions
static BaseWrapper[]	GetAllNodes (BaseWrapper root)
static BaseWrapper	Wrap (ResourceNode node)
static BaseWrapper	Wrap (IWin32Window owner, ResourceNode node)

Static Public Attributes
static IWin32Window	_owner

Protected Member Functions
	BaseWrapper ()

Static Protected Member Functions
static T	GetInstance< T > ()
static IEnumerable< T >	GetInstances< T > ()

Protected Attributes
bool	_discovered
ResourceNode	_resource

Static Protected Attributes
static readonly ContextMenuStrip	_emptyMenu = new ContextMenuStrip()

Properties
ResourceNode	Resource [get]
virtual ? Color	DefaultBackColor [get]
virtual ? Color	DefaultForeColor [get]

Constructor & Destructor Documentation

BaseWrapper()

BrawlCrate.NodeWrappers.BaseWrapper.BaseWrapper ( )

inlineprotected

        {
        }

Member Function Documentation

GetAllNodes()

static BaseWrapper[] BrawlCrate.NodeWrappers.BaseWrapper.GetAllNodes ( BaseWrapper  root )

inlinestatic

        {
            List<BaseWrapper> result = new List<BaseWrapper>();
            result.Add(root);
            foreach (TreeNode child in root.Nodes)
            {
                if (child is BaseWrapper b && b.Resource != null)
                {
                    bool expanded = b.IsExpanded;
                    b.Expand();
                    result.AddRange(GetAllNodes(b));
                    if (!expanded)
                    {
                        b.Collapse();
                    }
                }
            }
 
            return result.ToArray();
        }

GetInstance< T >()

static T BrawlCrate.NodeWrappers.BaseWrapper.GetInstance< T > ( )

inlinestaticprotected

Type Constraints

T

:

BaseWrapper

                                                    : BaseWrapper
        {
            return MainForm.Instance.resourceTree.SelectedNode as T;
        }

GetInstances< T >()

static IEnumerable< T > BrawlCrate.NodeWrappers.BaseWrapper.GetInstances< T > ( )

inlinestaticprotected

Type Constraints

T

:

BaseWrapper

                                                                  : BaseWrapper
        {
            return MainForm.Instance.resourceTree.SelectedNodes.Select(n => n as T).Where(n => n != null);
        }

Link()

void BrawlCrate.NodeWrappers.BaseWrapper.Link ( ResourceNode  res )

inline

        {
            Unlink();
            if (res != null)
            {
                Text = res.Name;
                TreeNodeCollection nodes = Nodes;
 
                //Should we continue down the tree?
                if (IsExpanded && res.HasChildren)
                {
                    //Add/link each resource node
                    foreach (ResourceNode n in res.Children)
                    {
                        bool found = false;
                        foreach (BaseWrapper tn in nodes)
                        {
                            if (tn.Text == n.Name)
                            {
                                tn.Link(n);
                                found = true;
                                // Move node to bottom, to ensure that nodes are shown and saved in the same order as in the original data
                                nodes.Remove(tn);
                                nodes.Add(tn);
                                break;
                            }
                        }
 
                        if (!found)
                        {
                            nodes.Add(Wrap(_owner, n));
                        }
                    }
 
                    //Remove empty nodes
                    for (int i = 0; i < nodes.Count;)
                    {
                        BaseWrapper n = nodes[i] as BaseWrapper;
                        if (n._resource == null)
                        {
                            n.Remove();
                        }
                        else
                        {
                            i++;
                        }
                    }
 
                    _discovered = true;
                }
                else
                {
                    //Node will be reset and undiscovered
                    nodes.Clear();
                    //Collapse();
                    if (res.HasChildren)
                    {
                        nodes.Add(new GenericWrapper());
                        _discovered = false;
                    }
                    else
                    {
                        _discovered = true;
                    }
                }
 
                SelectedImageIndex = ImageIndex = Icons.getImageIndex(res.ResourceFileType);
 
                res.SelectChild += OnSelectChild;
                res.ChildAdded += OnChildAdded;
                res.ChildRemoved += OnChildRemoved;
                res.ChildInserted += OnChildInserted;
                res.Replaced += OnReplaced;
                res.Restored += OnRestored;
                res.Renamed += OnRenamed;
                res.MovedUp += OnMovedUp;
                res.MovedDown += OnMovedDown;
                res.PropertyChanged += OnPropertyChanged;
                res.UpdateProps += OnUpdateProperties;
                res.UpdateControl += OnUpdateCurrentControl;
            }
 
            _resource = res;
            if (DefaultBackColor != null)
            {
                BackColor = (Color)DefaultBackColor;
            }
 
            if (DefaultForeColor != null)
            {
                ForeColor = (Color)DefaultForeColor;
            }
        }

Unlink()

void BrawlCrate.NodeWrappers.BaseWrapper.Unlink ( )

inline

        {
            if (_resource != null)
            {
                _resource.SelectChild -= OnSelectChild;
                _resource.ChildAdded -= OnChildAdded;
                _resource.ChildRemoved -= OnChildRemoved;
                _resource.ChildInserted -= OnChildInserted;
                _resource.Replaced -= OnReplaced;
                _resource.Restored -= OnRestored;
                _resource.Renamed -= OnRenamed;
                _resource.MovedUp -= OnMovedUp;
                _resource.MovedDown -= OnMovedDown;
                _resource.PropertyChanged -= OnPropertyChanged;
                _resource.UpdateProps -= OnUpdateProperties;
                _resource.UpdateControl -= OnUpdateCurrentControl;
                _resource = null;
            }
 
            foreach (BaseWrapper n in Nodes)
            {
                n.Unlink();
            }
        }

Wrap() [1/2]

static BaseWrapper BrawlCrate.NodeWrappers.BaseWrapper.Wrap ( IWin32Window  owner, ResourceNode  node  )

inlinestatic

        {
            _owner = owner;
            BaseWrapper w;
            if (NodeWrapperAttribute.PluginTypeWrappers.ContainsKey(node.GetType()))
            {
                w = NodeWrapperAttribute.PluginTypeWrappers[node.GetType()].GetInstance();
            }
            else if (NodeWrapperAttribute.PluginResourceWrappers.ContainsKey(node.ResourceFileType))
            {
                w = NodeWrapperAttribute.PluginResourceWrappers[node.ResourceFileType].GetInstance();
            }
            else if (NodeWrapperAttribute.ResourceWrappers.ContainsKey(node.ResourceFileType))
            {
                w = Activator.CreateInstance(NodeWrapperAttribute.ResourceWrappers[node.ResourceFileType]) as
                    BaseWrapper;
            }
            else
            {
                w = new GenericWrapper();
            }
 
            w.Link(node);
            return w;
        }

Wrap() [2/2]

static BaseWrapper BrawlCrate.NodeWrappers.BaseWrapper.Wrap ( ResourceNode  node )

inlinestatic

        {
            return Wrap(null, node);
        }

Member Data Documentation

_discovered

bool BrawlCrate.NodeWrappers.BaseWrapper._discovered

protected

_emptyMenu

readonly ContextMenuStrip BrawlCrate.NodeWrappers.BaseWrapper._emptyMenu = new ContextMenuStrip()

staticprotected

_owner

IWin32Window BrawlCrate.NodeWrappers.BaseWrapper._owner

static

_resource

ResourceNode BrawlCrate.NodeWrappers.BaseWrapper._resource

protected

Property Documentation

DefaultBackColor

virtual ? Color BrawlCrate.NodeWrappers.BaseWrapper.DefaultBackColor

get

DefaultForeColor

virtual ? Color BrawlCrate.NodeWrappers.BaseWrapper.DefaultForeColor

get

Resource

ResourceNode BrawlCrate.NodeWrappers.BaseWrapper.Resource

get

---

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

• BrawlCrate/NodeWrappers/BaseWrapper.cs