private static void ChangeOwnershipToNearestPlayer( MyTerminalBlock block )
        {
            Wrapper.GameAction( () =>
                                {
                                    double minDist = 0;
                                    MyPlayer nearest = null;

                                    foreach ( var player in MySession.Static.Players.GetOnlinePlayers() )
                                    {
                                        var dist = Vector3D.DistanceSquared( player.GetPosition(), block.PositionComp.GetPosition() );

                                        if ( nearest == null )
                                        {
                                            nearest = player;
                                            minDist = dist;
                                        }
                                        else if ( dist < minDist )
                                            nearest = player;
                                    }

                                    if ( nearest == null )
                                        return;
                                    MyAPIGateway.Utilities.InvokeOnGameThread(()=>block.ChangeBlockOwnerRequest( nearest.Identity.IdentityId, MyOwnershipShareModeEnum.Faction ));
                                } );
        }

 private void AddRow(MyTerminalBlock block)
 {
     MyGuiControlTable.Row row;
     MyGuiControlTable.Cell cell;
     row = new MyGuiControlTable.Row(block);
     cell = new MyGuiControlTable.Cell(block.CustomName);
     row.AddCell(cell);
     m_selectedBlocks.Add(row);
 }

 private static void AddToClipboard(MyTerminalBlock block)
 {
     if (MySession.Static.ElapsedGameTime != m_lastAccess)
     {
         Clipboard.Clear();
         m_lastAccess = MySession.Static.ElapsedGameTime;
     }
     Clipboard.Add(block);
 }

        public void Add(MyTerminalBlock block)
        {
            if (block.MarkedForClose)
                return;
            Debug.Assert(!m_blocks.Contains(block), "Block to add is already in terminal");
            m_blocks.Add(block);

            var handler = BlockAdded;
            if (handler != null) handler(block);
        }

        public void Add(MyTerminalBlock block)
        {
            if (block.MarkedForClose || block.IsBeeingRemoved)
                return;
            Debug.Assert(!m_blockTable.ContainsKey(block.EntityId), "Block to add is already in terminal");
            m_blockTable.Add(block.EntityId, block);
            m_blocks.Add(block);

            var handler = BlockAdded;
            if (handler != null) handler(block);
        }

        public void Initialize(Vector3 panelOrientation, bool isTwoSided, float panelOffset, MyTerminalBlock solarBlock)
        {
            m_initialized = true;

            m_panelOrientation = panelOrientation;
            m_isTwoSided = isTwoSided;
            m_panelOffset = panelOffset;
            m_solarBlock = solarBlock;

            //Warning: this will change the NeedsUpdate variable on the entity
            NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME;
        }

        public MyDebugRenderComponentSolarPanel(MyTerminalBlock solarBlock):base(solarBlock)
        {
            m_solarBlock = solarBlock;

            MyGameLogicComponent logicComponent;
            if (m_solarBlock.Components.TryGet(out logicComponent))
            {
                m_solarComponent = logicComponent as MySolarGameLogicComponent;
            }

            if (m_solarComponent == null)
            {
                System.Diagnostics.Debug.Fail("No solar component was found!");
            }
        }

        public void Remove(MyTerminalBlock block)
        {
            if (block.MarkedForClose)
                return;
            Debug.Assert(m_blocks.Contains(block), "Block to remove is not in terminal");
            m_blocks.Remove(block);

            for (int i = 0; i < BlockGroups.Count; i++)
            {
                var group = BlockGroups[i];
                if (group.Blocks.Contains(block))
                    group.Blocks.Remove(block);
                if (group.Blocks.Count == 0)
                {
                    RemoveGroup(group);
                    i--;
                }
            }

            var handler = BlockRemoved;
            if (handler != null) handler(block);
        }

 void TerminalSystem_BlockRemoved(MyTerminalBlock obj)
 {
     obj.CustomNameChanged -= block_CustomNameChanged;
     obj.PropertiesChanged -= block_CustomNameChanged;
     Debug.Assert(m_blockListbox != null);
     if (m_blockListbox != null && (obj.ShowInTerminal || m_showAllTerminalBlocks))
     { 
         m_blockListbox.Remove((item) => (item.UserData == obj));
     }
 }

 void TerminalSystem_BlockAdded(MyTerminalBlock obj)
 {
     AddBlockToList(obj);
 }

 private void thrust_EnabledChanged(MyTerminalBlock obj)
 {
     MarkDirty();
     if (CubeGrid.Physics != null && !CubeGrid.Physics.RigidBody.IsActive)
         CubeGrid.ActivatePhysics();
 }

 private void reflector_EnabledChanged(MyTerminalBlock obj)
 {
     Debug.Assert(obj is MyReflectorLight);
     m_reflectorsEnabledNeedsRefresh = true;
 }

 void block_ShowInTerminalChanged(MyTerminalBlock obj)
 {
     ClearBlockList();
     PopulateBlockList();
 }

        public void UpdateCubeBlock(MyTerminalBlock block)
        {

            if (block == null)
                return;

            if (m_terminalSystem != null)
            {
                m_terminalSystem.BlockAdded -= TerminalSystem_BlockAdded;
                m_terminalSystem.BlockRemoved -= TerminalSystem_BlockRemoved;
                m_terminalSystem.GroupAdded -= TerminalSystem_GroupAdded;
                m_terminalSystem.GroupRemoved -= TerminalSystem_GroupRemoved;
            }

            var grid = block.CubeGrid;
            m_terminalSystem = grid.GridSystems.TerminalSystem;
            m_tmpGroup = new MyBlockGroup(grid);

            m_terminalSystem.BlockAdded += TerminalSystem_BlockAdded;
            m_terminalSystem.BlockRemoved += TerminalSystem_BlockRemoved;
            m_terminalSystem.GroupAdded += TerminalSystem_GroupAdded;
            m_terminalSystem.GroupRemoved += TerminalSystem_GroupRemoved;

            SelectBlocks(new MyTerminalBlock[] { block });


        }

        void block_CustomNameChanged(MyTerminalBlock obj)
        {
            System.Diagnostics.Debug.Assert(m_blockListbox != null, "block_CustomNameChanged was not unregistered!");

            if (m_blockListbox == null)
                return;

            ProfilerShort.Begin("MyTerminalControlPanel.block_CustomNameChanged");
            foreach (var item in m_blockListbox.Items)
            {
                if (item.UserData == obj)
                {
                    UpdateItemAppearance(obj, item);
                    break;
                }
            }

            if (CurrentBlocks.Count > 0 && CurrentBlocks[0] == obj)
                m_blockNameLabel.Text = obj.CustomName.ToString();

            ProfilerShort.End();
        }

        void assembler_CustomNameChanged(MyTerminalBlock block)
        {
            Debug.Assert(block is MyAssembler && m_assemblersByKey.ContainsValue(block as MyAssembler));

            foreach (var entry in m_assemblersByKey)
            {
                if (entry.Value == block)
                {
                    var comboItem = m_comboboxAssemblers.TryGetItemByKey(entry.Key);
                    comboItem.Value.Clear().AppendStringBuilder(block.CustomName);
                }
            }
        }

        void TerminalSystem_BlockRemoved(MyTerminalBlock obj)
        {
            var removedAssembler = obj as MyAssembler;
            if (removedAssembler != null)
            {
                removedAssembler.CustomNameChanged -= assembler_CustomNameChanged;
                int? key = null;
                foreach (var entry in m_assemblersByKey)
                {
                    if (entry.Value == removedAssembler)
                    {
                        key = entry.Key;
                        break;
                    }
                }
                if (key.HasValue)
                {
                    m_assemblersByKey.Remove(key.Value);
                    m_comboboxAssemblers.RemoveItem(key.Value);
                }

                if (removedAssembler == m_selectedAssembler)
                {
                    if (m_assemblersByKey.Count > 0)
                        m_comboboxAssemblers.SelectItemByIndex(0);
                    else
                        ShowError(MySpaceTexts.ScreenTerminalError_NoAssemblers, m_controlsParent);
                }
            }
        }

 void TerminalSystem_BlockAdded(MyTerminalBlock obj)
 {
     var assembler = obj as MyAssembler;
     if (assembler != null)
     {
         if (m_assemblersByKey.Count == 0)
         {
             HideError(m_controlsParent);
         }
         var key = m_assemblerKeyCounter++;
         m_assemblersByKey.Add(key, assembler);
         m_comboboxAssemblers.AddItem(key, assembler.CustomName);
         if (m_assemblersByKey.Count == 1)
             m_comboboxAssemblers.SelectItemByIndex(0);
         assembler.CustomNameChanged += assembler_CustomNameChanged;
     }
 }

 private void UpdateReceiver(MyTerminalBlock block)
 {
     ResourceSink.Update();
 }

 void gyro_PropertiesChanged(MyTerminalBlock sender)
 {
     MarkDirty();
 }