protected void CubeBlockPropertyChangedCallback(Object sender, PropertyChangedEventArgs e)
        {
            if (sender is CubeBlockEntityProxy)
            {
                try
                {
                    if (TRV_Entities.SelectedNode == null)
                    {
                        return;
                    }

                    TreeNode selectedNode = TRV_Entities.SelectedNode;
                    if (selectedNode.Tag == null)
                    {
                        return;
                    }
                    Object linkedObject = selectedNode.Tag;
                    if (linkedObject != sender)
                    {
                        return;
                    }

                    CubeGridEntityProxy  cubeGrid = (CubeGridEntityProxy)selectedNode.Parent.Parent.Tag;
                    CubeBlockEntityProxy entity   = (CubeBlockEntityProxy)sender;

                    m_serviceClient.UpdateCubeBlock(cubeGrid, entity);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }
            }
        }
        private void RenderCubeGridNodes(TreeNode rootNode)
        {
            if (rootNode == null)
            {
                return;
            }

            //List<CubeGridEntityProxy> list = m_sectorCubeGridEntities;
            List <CubeGridEntityProxy> list = new List <CubeGridEntityProxy>();

            foreach (var entry in m_sectorEntities)
            {
                if (entry is CubeGridEntityProxy)
                {
                    list.Add((CubeGridEntityProxy)entry);
                }
            }

            //Cleanup and update the existing nodes
            foreach (TreeNode node in rootNode.Nodes)
            {
                try
                {
                    if (node == null)
                    {
                        continue;
                    }
                    if (node.Tag == null)
                    {
                        node.Remove();
                        continue;
                    }

                    CubeGridEntityProxy item = (CubeGridEntityProxy)node.Tag;
                    bool foundMatch          = false;
                    foreach (CubeGridEntityProxy listItem in list)
                    {
                        if (listItem.EntityId == item.EntityId)
                        {
                            foundMatch = true;

                            Vector3 rawPosition = item.Position;
                            double  distance    = Math.Round(rawPosition.Length(), 0);
                            string  newNodeText = item.Name + " | Mass: " + Math.Floor(item.Mass).ToString() + "kg | Dist: " + distance.ToString() + "m";
                            node.Text = newNodeText;

                            list.Remove(listItem);

                            break;
                        }
                    }

                    if (!foundMatch)
                    {
                        node.Remove();
                        continue;
                    }
                }
                catch (Exception ex)
                {
                    LogManager.ErrorLog.WriteLine(ex);
                }
            }

            //Add new nodes
            foreach (var item in list)
            {
                try
                {
                    if (item == null)
                    {
                        continue;
                    }

                    Vector3 rawPosition = item.Position;
                    double  distance    = rawPosition.Length();

                    Type   sectorObjectType = item.GetType();
                    string nodeKey          = item.EntityId.ToString();

                    TreeNode newNode = rootNode.Nodes.Add(nodeKey, item.Name + " | Mass: " + Math.Floor(item.Mass).ToString() + "kg | Dist: " + distance.ToString() + "m");
                    newNode.Name = item.Name;
                    newNode.Tag  = item;
                }
                catch (Exception ex)
                {
                    LogManager.ErrorLog.WriteLine(ex);
                }
            }

            //Update node text
            rootNode.Text = rootNode.Name + " (" + rootNode.Nodes.Count.ToString() + ")";
        }
        private void RenderCubeGridChildNodes(CubeGridEntityProxy cubeGrid, TreeNode blocksNode)
        {
            TreeNode structuralBlocksNode;
            TreeNode containerBlocksNode;
            TreeNode productionBlocksNode;
            TreeNode energyBlocksNode;
            TreeNode conveyorBlocksNode;
            TreeNode utilityBlocksNode;
            TreeNode weaponBlocksNode;
            TreeNode toolBlocksNode;
            TreeNode lightBlocksNode;
            TreeNode miscBlocksNode;

            if (blocksNode.Nodes.Count < 9)
            {
                structuralBlocksNode = blocksNode.Nodes.Add("Structural");
                containerBlocksNode  = blocksNode.Nodes.Add("Containers");
                productionBlocksNode = blocksNode.Nodes.Add("Refinement and Production");
                energyBlocksNode     = blocksNode.Nodes.Add("Energy");
                conveyorBlocksNode   = blocksNode.Nodes.Add("Conveyor");
                utilityBlocksNode    = blocksNode.Nodes.Add("Utility");
                weaponBlocksNode     = blocksNode.Nodes.Add("Weapons");
                toolBlocksNode       = blocksNode.Nodes.Add("Tools");
                lightBlocksNode      = blocksNode.Nodes.Add("Lights");
                miscBlocksNode       = blocksNode.Nodes.Add("Misc");

                structuralBlocksNode.Name = structuralBlocksNode.Text;
                containerBlocksNode.Name  = containerBlocksNode.Text;
                productionBlocksNode.Name = productionBlocksNode.Text;
                energyBlocksNode.Name     = energyBlocksNode.Text;
                conveyorBlocksNode.Name   = conveyorBlocksNode.Text;
                utilityBlocksNode.Name    = utilityBlocksNode.Text;
                weaponBlocksNode.Name     = weaponBlocksNode.Text;
                toolBlocksNode.Name       = toolBlocksNode.Text;
                lightBlocksNode.Name      = lightBlocksNode.Text;
                miscBlocksNode.Name       = miscBlocksNode.Text;
            }
            else
            {
                structuralBlocksNode = blocksNode.Nodes[0];
                containerBlocksNode  = blocksNode.Nodes[1];
                productionBlocksNode = blocksNode.Nodes[2];
                energyBlocksNode     = blocksNode.Nodes[3];
                conveyorBlocksNode   = blocksNode.Nodes[4];
                utilityBlocksNode    = blocksNode.Nodes[5];
                weaponBlocksNode     = blocksNode.Nodes[6];
                toolBlocksNode       = blocksNode.Nodes[7];
                lightBlocksNode      = blocksNode.Nodes[8];
                miscBlocksNode       = blocksNode.Nodes[9];

                structuralBlocksNode.Nodes.Clear();
                containerBlocksNode.Nodes.Clear();
                productionBlocksNode.Nodes.Clear();
                energyBlocksNode.Nodes.Clear();
                conveyorBlocksNode.Nodes.Clear();
                utilityBlocksNode.Nodes.Clear();
                weaponBlocksNode.Nodes.Clear();
                toolBlocksNode.Nodes.Clear();
                lightBlocksNode.Nodes.Clear();
                miscBlocksNode.Nodes.Clear();
            }

            List <CubeBlockEntityProxy> cubeBlocks = m_serviceClient.GetCubeBlocks(cubeGrid.EntityId);

            foreach (var cubeBlock in cubeBlocks)
            {
                cubeBlock.PropertyChanged += CubeBlockPropertyChangedCallback;

                TreeNode newNode = new TreeNode(cubeBlock.Name);
                newNode.Name = newNode.Text;
                newNode.Tag  = cubeBlock;

                Type cubeBlockType = cubeBlock.GetType();

                if (cubeBlockType == typeof(CubeBlockEntityProxy))
                {
                    structuralBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is CargoContainerEntityProxy)
                {
                    containerBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is ReactorEntityProxy)
                {
                    energyBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is BatteryBlockEntityProxy)
                {
                    energyBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is BeaconEntityProxy)
                {
                    utilityBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is CockpitEntityProxy)
                {
                    utilityBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is GravityGeneratorEntityProxy)
                {
                    utilityBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is MedicalRoomEntityProxy)
                {
                    utilityBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is DoorEntityProxy)
                {
                    utilityBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is InteriorLightEntityProxy)
                {
                    lightBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is ReflectorLightEntityProxy)
                {
                    lightBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is RefineryEntityProxy)
                {
                    productionBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is AssemblerEntityProxy)
                {
                    productionBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is ConveyorBlockEntityProxy)
                {
                    conveyorBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is ConveyorTubeEntityProxy)
                {
                    conveyorBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is SolarPanelEntityProxy)
                {
                    energyBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is GatlingTurretEntityProxy)
                {
                    weaponBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is MissileTurretEntityProxy)
                {
                    weaponBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is ShipGrinderEntityProxy)
                {
                    toolBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is ShipWelderEntityProxy)
                {
                    toolBlocksNode.Nodes.Add(newNode);
                }
                else if (cubeBlock is ShipDrillEntityProxy)
                {
                    toolBlocksNode.Nodes.Add(newNode);
                }
                else
                {
                    miscBlocksNode.Nodes.Add(newNode);
                }
            }

            structuralBlocksNode.Text = structuralBlocksNode.Name + " (" + structuralBlocksNode.Nodes.Count.ToString() + ")";
            containerBlocksNode.Text  = containerBlocksNode.Name + " (" + containerBlocksNode.Nodes.Count.ToString() + ")";
            productionBlocksNode.Text = productionBlocksNode.Name + " (" + productionBlocksNode.Nodes.Count.ToString() + ")";
            energyBlocksNode.Text     = energyBlocksNode.Name + " (" + energyBlocksNode.Nodes.Count.ToString() + ")";
            conveyorBlocksNode.Text   = conveyorBlocksNode.Name + " (" + conveyorBlocksNode.Nodes.Count.ToString() + ")";
            utilityBlocksNode.Text    = utilityBlocksNode.Name + " (" + utilityBlocksNode.Nodes.Count.ToString() + ")";
            weaponBlocksNode.Text     = weaponBlocksNode.Name + " (" + weaponBlocksNode.Nodes.Count.ToString() + ")";
            toolBlocksNode.Text       = toolBlocksNode.Name + " (" + toolBlocksNode.Nodes.Count.ToString() + ")";
            lightBlocksNode.Text      = lightBlocksNode.Name + " (" + lightBlocksNode.Nodes.Count.ToString() + ")";
            miscBlocksNode.Text       = miscBlocksNode.Name + " (" + miscBlocksNode.Nodes.Count.ToString() + ")";
        }
        private void TRV_Entities_AfterSelect(object sender, TreeViewEventArgs e)
        {
            BTN_Entities_Export.Enabled = false;
            BTN_Entities_New.Enabled    = false;
            BTN_Entities_Delete.Enabled = false;

            TreeNode selectedNode = e.Node;

            if (selectedNode == null)
            {
                return;
            }

            TreeNode parentNode = e.Node.Parent;

            if (parentNode == null)
            {
                return;
            }

            if (selectedNode.Tag == null)
            {
                return;
            }

            var linkedObject = selectedNode.Tag;

            PG_Entities_Details.SelectedObject = linkedObject;

            if (linkedObject is CubeGridEntityProxy)
            {
                TRV_Entities.BeginUpdate();

                RenderCubeGridChildNodes((CubeGridEntityProxy)linkedObject, e.Node);

                TRV_Entities.EndUpdate();
            }

            if (linkedObject is CharacterEntityProxy)
            {
                CharacterEntityProxy character = (CharacterEntityProxy)linkedObject;

                if (e.Node.Nodes.Count < 1)
                {
                    TRV_Entities.BeginUpdate();

                    e.Node.Nodes.Clear();
                    TreeNode itemsNode = e.Node.Nodes.Add("Items");
                    itemsNode.Name = itemsNode.Text;
                    //itemsNode.Tag = character.Inventory;

                    TRV_Entities.EndUpdate();
                }
            }

            if (linkedObject is CargoContainerEntityProxy)
            {
                CargoContainerEntityProxy container = (CargoContainerEntityProxy)linkedObject;

                if (e.Node.Nodes.Count < 1)
                {
                    TRV_Entities.BeginUpdate();

                    e.Node.Nodes.Clear();
                    TreeNode itemsNode = e.Node.Nodes.Add("Items");
                    itemsNode.Name = itemsNode.Text;
                    itemsNode.Tag  = container.Inventory;

                    TRV_Entities.EndUpdate();
                }
            }

            if (linkedObject is ReactorEntityProxy)
            {
                ReactorEntityProxy reactor = (ReactorEntityProxy)linkedObject;

                if (e.Node.Nodes.Count < 1)
                {
                    TRV_Entities.BeginUpdate();

                    e.Node.Nodes.Clear();
                    TreeNode itemsNode = e.Node.Nodes.Add("Items");
                    itemsNode.Name = itemsNode.Text;
                    itemsNode.Tag  = reactor.Inventory;

                    TRV_Entities.EndUpdate();
                }
            }

            if (linkedObject is ShipToolBaseEntityProxy)
            {
                ShipToolBaseEntityProxy shipTool = (ShipToolBaseEntityProxy)linkedObject;

                if (e.Node.Nodes.Count < 1)
                {
                    TRV_Entities.BeginUpdate();

                    e.Node.Nodes.Clear();
                    TreeNode itemsNode = e.Node.Nodes.Add("Items");
                    itemsNode.Name = itemsNode.Text;
                    itemsNode.Tag  = shipTool.Inventory;

                    TRV_Entities.EndUpdate();
                }
            }

            if (linkedObject is ShipDrillEntityProxy)
            {
                ShipDrillEntityProxy shipDrill = (ShipDrillEntityProxy)linkedObject;

                if (e.Node.Nodes.Count < 1)
                {
                    TRV_Entities.BeginUpdate();

                    e.Node.Nodes.Clear();
                    TreeNode itemsNode = e.Node.Nodes.Add("Items");
                    itemsNode.Name = itemsNode.Text;
                    itemsNode.Tag  = shipDrill.Inventory;

                    TRV_Entities.EndUpdate();
                }
            }

            if (linkedObject is ProductionBlockEntityProxy)
            {
                ProductionBlockEntityProxy productionBlock = (ProductionBlockEntityProxy)linkedObject;

                if (e.Node.Nodes.Count < 2)
                {
                    TRV_Entities.BeginUpdate();

                    e.Node.Nodes.Clear();
                    TreeNode inputNode = e.Node.Nodes.Add("Input");
                    inputNode.Name = inputNode.Text;
                    inputNode.Tag  = productionBlock.InputInventory;
                    TreeNode outputNode = e.Node.Nodes.Add("Output");
                    outputNode.Name = outputNode.Text;
                    outputNode.Tag  = productionBlock.OutputInventory;

                    TRV_Entities.EndUpdate();
                }
            }

            if (linkedObject is InventoryEntityProxy)
            {
                InventoryEntityProxy inventory = (InventoryEntityProxy)linkedObject;

                if (parentNode.Tag is CubeBlockEntityProxy && parentNode.Parent.Parent.Tag is CubeGridEntityProxy)
                {
                    CubeGridEntityProxy  cubeGrid  = (CubeGridEntityProxy)parentNode.Parent.Parent.Tag;
                    CubeBlockEntityProxy cubeBlock = (CubeBlockEntityProxy)parentNode.Tag;

                    long   cubeGridEntityId  = cubeGrid.EntityId;
                    long   cubeBlockEntityId = cubeBlock.EntityId;
                    ushort inventoryIndex    = 0;
                    List <InventoryItemEntityProxy> inventoryItems = m_serviceClient.GetInventoryItems(cubeGridEntityId, cubeBlockEntityId, inventoryIndex);

                    UpdateNodeInventoryItemBranch <InventoryItemEntityProxy>(e.Node, inventoryItems);
                }
            }
        }