using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Xml;

namespace FCC_Uber_MDX_Configurator
{
    public partial class CustomFunctionForm : Form
    {
        public bool isEditingRootNode = false;
        public bool showTextValues = true;
        public LogicModules.FunctionMDX _CurrentFunction = new LogicModules.FunctionMDX();
        public List<ToolStripButton> _Global_List_TSB = new List<ToolStripButton>();
        private string isAdding = null;
        public List<Rectangle> ModuleNoGood = new List<Rectangle>();
        public Cursor LastCursorBeforeHand = Cursors.Arrow;
        public LogicModules.Module isMoving = null;
        public static int NodeDisplay_Offset_Horizontal = 0;
        public static int NodeDisplay_Offset_Vertical = 0;
        public bool AllowDropOfObject = true;
        public LogicModules.Module HoveringModule = null;
        public LogicModules.Node.ConnectLink isConnecting = null;
        public bool isSavedandNotChanged = true;
        private string isSaved_PreviousXML = "";
        private string isSaved_PreviousDesignerXML = "";
        public Bitmap Draw2Bitmap;
        public FileSystemWatcher AllFunctionsDirectoryWatcher;
        public string string_CustomFunctionDropDown = null;
        public string string_DropDownItem = null;
        public static List<string> Module_Possibilities = new List<string>(new string[] { "AND", "OR", "NOT", "NAND", "NOR", "XOR", "LESS THAN",
            "LESS THAN OR EQUAL TO", "GREATER THAN", "GREATER THAN OR EQUAL TO", "EQUAL TO", "NOT EQUAL TO", "BETWEEN EE", "BETWEEN EI", "BETWEEN IE", "BETWEEN II",
            "ADD", "SUBTRACT", "MULTIPLY", "DIVIDE", "NUMBER", "INPUT", "OUTPUT", "ANALOGUEINPUT", "DIGITALOUTPUT", "VARIABLE" });

        #region Backup Code Because Visual Studio Keeps Deleting Code...
        /*
         * BACKUP
         * 
        this.TS_MAINTOP.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
            this.TSB_Save,
            this.TSB_OpenFile,
            this.toolStripSeparator1,
            this.TSB_GRAPHICS,
            this.TSB_TEXTBASED,
            this.TSB_Properties,
            this.toolStripSeparator2,
            this.TSB_MAINHELP});
        */

        /*
         * BACKUP
         * 
        this.TSBDROP_BOOLEAN.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
            this.TSB_LOGIC_AND, this.TSB_LOGIC_OR, this.TSB_LOGIC_NOT,
            this.TSB_LOGIC_NAND, this.TSB_LOGIC_NOR, this.TSB_LOGIC_XOR});
        */

        /*
         * BACKUP
         * 
        this.TSBDROP_NUMERICOPERATIONS.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
            this.TSB_LOGIC_ADD, this.TSB_LOGIC_SUBTRACT, this.TSB_LOGIC_MULTIPLY, this.TSB_LOGIC_DIVIDE});
        */

        /*
             * BACKUP
             * 
            this.TSBDROP_COMPARATIVEMODULES.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
                this.TSB_LOGIC_EQUALS, this.TSB_LOGIC_NOTEQUAL,
                this.TSB_LOGIC_LESSTHAN, this.TSB_LOGIC_LESSTHANOREQUALTO,
                this.TSB_LOGIC_GREATERTHAN, this.TSB_LOGIC_GREATERTHANOREQUALTO});
            */
        #endregion

        #region Initialization
        public void CustomFunctionFormInitialization()
        {
            InitializeComponent();
            InitializeLogicToolstrip();
            UpdateThisFunction();
            CONTEXT_STRIP_LogicDesigner_Module.Hide();
            InitializeFunctionWatcher();
            if (isEditingRootNode)
            {
                this.Text = "If/Then Logic Block Builder Form";
            }
            else
            {
                this.Text = "Custom Function Builder Form";
            }
            this.Update();
        }

        public CustomFunctionForm()
        {
            isEditingRootNode = false;
            CustomFunctionFormInitialization();
        }

        public CustomFunctionForm(LogicModules.PsuedoFunctionMDX input_Function)
        {
            isEditingRootNode = false;
            CustomFunctionFormInitialization();
            if (!OpenFunction(GlobalStaticClass.FUNCTION_DIRECTORY + "\\" + input_Function._id + ".designer"))
            {
                this.DialogResult = DialogResult.Cancel;
                this.Close();
            }
        }

        public CustomFunctionForm(bool input_isEditingRootNode)
        {
            isEditingRootNode = input_isEditingRootNode;
            if (isEditingRootNode)
            {
                _CurrentFunction._FunctionID = GlobalStaticClass._GlobalFunctionsClass.GetUniqueName();
            }
            CustomFunctionFormInitialization();
        }

        public CustomFunctionForm(GlobalStaticClass._GlobalFunctionsClass input_GFC)
        {
            isEditingRootNode = true;
            _CurrentFunction = input_GFC._function;
            CustomFunctionFormInitialization();
        }

        public void InitializeLogicToolstrip()
        {
            TSB_AddAnalogue.Visible = isEditingRootNode;
            TSB_DigitalOutput.Visible = isEditingRootNode;
            TSB_Variable.Visible = isEditingRootNode;
            TSB_INPUTICON.Visible = !isEditingRootNode;
            TSB_NEW.Visible = !isEditingRootNode;
            TSB_OpenFile.Visible = !isEditingRootNode;
            TSB_ThenIcon.Visible = isEditingRootNode;
            TSB_TIMER.Visible = isEditingRootNode;

            TSB_DigitalOutput.DropDownItems.Clear();
            TSB_AddAnalogue.DropDownItems.Clear();
            TSB_Variable.DropDownItems.Clear();

            foreach (GlobalStaticClass._GlobalDigitalOutputClass _GDOC in GlobalStaticClass._Global_List_DigitalOutputs)
            {
                TSB_DigitalOutput.DropDownItems.Add(_GDOC.id, global::FCC_Uber_MDX_Configurator.Properties.Resources.OutputIcon);
            }
            foreach (GlobalStaticClass._GlobalAnalogueInputClass _GAIC in GlobalStaticClass._Global_List_AnalogueInputs)
            {
                TSB_AddAnalogue.DropDownItems.Add(_GAIC.id, global::FCC_Uber_MDX_Configurator.Properties.Resources.InputIcon);
            }
            foreach (GlobalStaticClass._GlobalVariableClass _GVC in GlobalStaticClass._Global_List_Variables)
            {
                ToolStripMenuItem _tsmi = new ToolStripMenuItem(_GVC._id, global::FCC_Uber_MDX_Configurator.Properties.Resources.VariableIcon);
                _tsmi.DropDownItems.Add("Get");
                _tsmi.DropDownItems.Add("Set");
                _tsmi.DropDownItemClicked += new ToolStripItemClickedEventHandler(TSB_Variable_DropDownItemClicked);
                TSB_Variable.DropDownItems.Add(_tsmi);
            }

            if (TSB_DigitalOutput.DropDownItems.Count == 0)
            {
                TSB_DigitalOutput.Enabled = false;
            }
            if (TSB_AddAnalogue.DropDownItems.Count == 0)
            {
                TSB_AddAnalogue.Enabled = false;
            }
            if (TSB_Variable.DropDownItems.Count == 0)
            {
                TSB_Variable.Enabled = false;
            }
        }

        public void InitializeFunctionWatcher()
        {
            AllFunctionsDirectoryWatcher = new FileSystemWatcher(GlobalStaticClass.FUNCTION_DIRECTORY);
            AllFunctionsDirectoryWatcher.IncludeSubdirectories = true;
            AllFunctionsDirectoryWatcher.Filter = "*.xml";
            AllFunctionsDirectoryWatcher.Created += new FileSystemEventHandler(AllFunctionsDirectoryWatcher_ChangedOrCreated);
            AllFunctionsDirectoryWatcher.Changed += new FileSystemEventHandler(AllFunctionsDirectoryWatcher_ChangedOrCreated);
            AllFunctionsDirectoryWatcher.Deleted += new FileSystemEventHandler(AllFunctionsDirectoryWatcher_ChangedOrCreated);
            AllFunctionsDirectoryWatcher.EnableRaisingEvents = true;
            ReloadAllFunctions();
        }
        #endregion

        #region Properties Icon Clicked
        private void TSB_Properties_Click(object sender, EventArgs e)
        {
            FunctionPropertiesForm _tempFUNCP = (new FunctionPropertiesForm(_CurrentFunction._FunctionID, isEditingRootNode));
            if (_tempFUNCP.ShowDialog() == DialogResult.OK)
            {
                string temp_returned = _tempFUNCP.GetFunctionID();
                if (temp_returned == null)
                {
                    return;
                }
                else
                {
                    _CurrentFunction._FunctionID = temp_returned;
                    UpdateThisFunction();
                }
            }
            this.DialogResult = DialogResult.None;
        }
        #endregion

        #region Update This Function
        public void UpdateThisFunction()
        {
            UpdateGraphicsOfFunction();
            string newXML = UpdateXML();
            string newDesignerXML = SaveDesignerInfo();
            if (showTextValues)
            {
                TSB_SHOWTEXTTOGGLE.Image = global::FCC_Uber_MDX_Configurator.Properties.Resources.ShowTextIcon;
            }
            else
            {
                TSB_SHOWTEXTTOGGLE.Image = global::FCC_Uber_MDX_Configurator.Properties.Resources.ShowTextIcon_NOT;
            }

            if (newXML == isSaved_PreviousXML && newDesignerXML == isSaved_PreviousDesignerXML)
            {
                isSavedandNotChanged = true;
            }
            else
            {
                isSavedandNotChanged = false;
                isSaved_PreviousXML = newXML;
                isSaved_PreviousDesignerXML = newDesignerXML;
            }
        }

        public void UpdateGraphicsOfFunction()
        {
            ModuleNoGood.Clear();
            Draw2Bitmap = new Bitmap(LOGIC_PANEL.Width, LOGIC_PANEL.Height);
            Graphics LogicPanelGraphics = Graphics.FromImage(Draw2Bitmap);
            LogicPanelGraphics.Clear(Color.White);
            List<string> AllInputModules = new List<string>();
            TSB_INPUTICON.DropDownItems.Clear();
            foreach (LogicModules.Module _mod in _CurrentFunction._Modules)
            {
                DrawNode(LogicPanelGraphics, _mod, ModuleNoGood, AllInputModules, showTextValues);
            }
            LogicPanelGraphics.Dispose();
            foreach (string _allID in AllInputModules)
            {
                TSB_INPUTICON.DropDownItems.Add(_allID, global::FCC_Uber_MDX_Configurator.Properties.Resources.LogicInputIcon);
            }
            LOGIC_PANEL.BackgroundImage = Draw2Bitmap;
            LOGIC_PANEL.BackgroundImageLayout = ImageLayout.None;
            LOGIC_PANEL.Invalidate();
            LOGIC_PANEL.Update();
        }

        /// <summary>
        /// Draw All Nodes To a specified Graphics area and update some Lists
        /// </summary>
        /// <param name="input_DrawArea">The graphics object to draw to</param>
        /// <param name="input_Module">The module to draw</param>
        /// <param name="inputModuleNoGood">A List of Module bounds updated each call</param>
        /// <param name="input_AllInputModules">A List of all input modules, can be null</param>
        public static void DrawNode(Graphics input_DrawArea, LogicModules.Module input_Module, List<Rectangle> inputModuleNoGood, List<string> input_AllInputModules, bool showText)
        {
            if (input_Module == null)
            {
                return;
            }
            
            int[] SideNodesCount = new int[4];
            for (int i = 0; i < input_Module.Input_Nodes.Count; i++)
            {
                SideNodesCount[(int)input_Module.Input_Nodes[i].Module_Face]++;
            }
            for (int i = 0; i < input_Module.Output_Nodes.Count; i++)
            {
                SideNodesCount[(int)input_Module.Output_Nodes[i].Module_Face]++;
            }

            //Rectangle _rect = new Rectangle(input_Module.ModuleLocation.X - global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT.Width,
            //    input_Module.ModuleLocation.Y - global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Height,
            //    global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT.Width + input_Module.ModuleSize.Width + global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_RIGHT.Width + NodeDisplay_Offset_Horizontal,
            //    global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Width + input_Module.ModuleSize.Height + global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_BOTTOM.Height + NodeDisplay_Offset_Vertical);
            Rectangle _rect = new Rectangle(input_Module.ModuleLocation.X, input_Module.ModuleLocation.Y, input_Module.ModuleSize.Width, input_Module.ModuleSize.Height);

            // L,R,U,D
            if (SideNodesCount[0] > 0) {
                _rect.X -= global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT.Width - NodeDisplay_Offset_Horizontal;
                _rect.Width += global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT.Width + NodeDisplay_Offset_Horizontal;
            }
            if (SideNodesCount[1] > 0) { _rect.Width += global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_RIGHT.Width + NodeDisplay_Offset_Horizontal; }
            if (SideNodesCount[2] > 0)
            {
                _rect.Y -= global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Height - NodeDisplay_Offset_Vertical;
                _rect.Height += global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Height + NodeDisplay_Offset_Vertical;
            }
            if (SideNodesCount[3] > 0) { _rect.Height += global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_BOTTOM.Height + NodeDisplay_Offset_Vertical; }

            input_Module.ModuleBounds = _rect;
            inputModuleNoGood.Add(_rect);

            int l = 0, r = 0, u = 0, d = 0;
            for (int i = 0; i < input_Module.Input_Nodes.Count; i++)
            {
                if (input_Module.Input_Nodes[i].Module_Face == LogicModules.ModuleFace.LeftSide)
                {
                    input_Module.Input_Nodes[i].SetNodeBounds(new Rectangle(new Point((input_Module.ModuleLocation.X) - (global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT.Width), (input_Module.ModuleLocation.Y + (int)(((float)((input_Module.ModuleSize.Height * (l + 1)) / (SideNodesCount[(int)input_Module.Input_Nodes[i].Module_Face] + 1))) - (float)(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT.Height / 2)))), global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT.Size));
                    input_DrawArea.DrawImage(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT, input_Module.Input_Nodes[i].Node_Bounds);
                    l++;
                }
                else if (input_Module.Input_Nodes[i].Module_Face == LogicModules.ModuleFace.RightSide)
                {
                    input_Module.Input_Nodes[i].SetNodeBounds(new Rectangle(new Point((input_Module.ModuleLocation.X) + input_Module.ModuleSize.Width, (input_Module.ModuleLocation.Y + (int)(((float)((input_Module.ModuleSize.Height * (r + 1)) / (SideNodesCount[(int)input_Module.Input_Nodes[i].Module_Face] + 1))) - (float)(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_RIGHT.Height / 2)))), global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Size));
                    input_DrawArea.DrawImage(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_RIGHT, input_Module.Input_Nodes[i].Node_Bounds);
                    r++;
                }
                else if (input_Module.Input_Nodes[i].Module_Face == LogicModules.ModuleFace.UpSide)
                {
                    input_Module.Input_Nodes[i].SetNodeBounds(new Rectangle(new Point(input_Module.ModuleLocation.X + (int)((float)(input_Module.ModuleSize.Width * (u + 1)) / (SideNodesCount[(int)input_Module.Input_Nodes[i].Module_Face] + 1)) - (int)(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Width / 2), input_Module.ModuleLocation.Y - global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Height), global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Size));
                    input_DrawArea.DrawImage(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP, input_Module.Input_Nodes[i].Node_Bounds);
                    u++;
                }
                else if (input_Module.Input_Nodes[i].Module_Face == LogicModules.ModuleFace.DownSide)
                {
                    input_Module.Input_Nodes[i].SetNodeBounds(new Rectangle(new Point(input_Module.ModuleLocation.X + (int)((float)(input_Module.ModuleSize.Width * (d + 1)) / (SideNodesCount[(int)input_Module.Input_Nodes[i].Module_Face] + 1)) - (int)(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_BOTTOM.Width / 2), input_Module.ModuleLocation.Y + input_Module.ModuleSize.Height), global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_BOTTOM.Size));
                    input_DrawArea.DrawImage(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_BOTTOM, input_Module.Input_Nodes[i].Node_Bounds);
                    d++;
                }               
            }
            for (int i = 0; i < input_Module.Output_Nodes.Count; i++)
            {
                if (input_Module.Output_Nodes[i].Module_Face == LogicModules.ModuleFace.LeftSide)
                {
                    input_Module.Output_Nodes[i].SetNodeBounds(new Rectangle(new Point((input_Module.ModuleLocation.X) - (global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT.Width), (input_Module.ModuleLocation.Y + (int)(((float)((input_Module.ModuleSize.Height * (l + 1)) / (SideNodesCount[(int)input_Module.Output_Nodes[i].Module_Face] + 1))) - (float)(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT.Height / 2)))), global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT.Size));
                    input_DrawArea.DrawImage(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT, input_Module.Output_Nodes[i].Node_Bounds);
                    l++;
                }
                else if (input_Module.Output_Nodes[i].Module_Face == LogicModules.ModuleFace.RightSide)
                {
                    input_Module.Output_Nodes[i].SetNodeBounds(new Rectangle(new Point((input_Module.ModuleLocation.X) + input_Module.ModuleSize.Width, (input_Module.ModuleLocation.Y + (int)(((float)((input_Module.ModuleSize.Height * (r + 1)) / (SideNodesCount[(int)input_Module.Output_Nodes[i].Module_Face] + 1))) - (float)(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_RIGHT.Height / 2)))), global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_RIGHT.Size));
                    input_DrawArea.DrawImage(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_RIGHT, input_Module.Output_Nodes[i].Node_Bounds);
                    r++;
                }
                else if (input_Module.Output_Nodes[i].Module_Face == LogicModules.ModuleFace.UpSide)
                {
                    input_Module.Output_Nodes[i].SetNodeBounds(new Rectangle(new Point(input_Module.ModuleLocation.X + (int)((float)(input_Module.ModuleSize.Width * (u + 1)) / (SideNodesCount[(int)input_Module.Output_Nodes[i].Module_Face] + 1)) - (int)(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Width / 2), input_Module.ModuleLocation.Y - global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Height), global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Size));
                    input_DrawArea.DrawImage(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP, input_Module.Output_Nodes[i].Node_Bounds);
                    u++;
                }
                else if (input_Module.Output_Nodes[i].Module_Face == LogicModules.ModuleFace.DownSide)
                {
                    input_Module.Output_Nodes[i].SetNodeBounds(new Rectangle(new Point(input_Module.ModuleLocation.X + (int)((float)(input_Module.ModuleSize.Width * (d + 1)) / (SideNodesCount[(int)input_Module.Output_Nodes[i].Module_Face] + 1)) - (int)(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_BOTTOM.Width / 2), input_Module.ModuleLocation.Y + input_Module.ModuleSize.Height), global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_BOTTOM.Size));
                    input_DrawArea.DrawImage(global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_BOTTOM, input_Module.Output_Nodes[i].Node_Bounds);
                    d++;
                }
            }
            for (int i = 0; i < input_Module.Output_Nodes.Count; i++)
            {
                if (input_Module.Output_Nodes[i].isConnected())
                {
                    input_DrawArea.DrawLines(new Pen(Color.Blue, 3.0f), new Point[] {
                        new Point(input_Module.Output_Nodes[i].Node_Bounds.X + (input_Module.Output_Nodes[i].Node_Bounds.Size.Width / 2), input_Module.Output_Nodes[i].Node_Bounds.Y + (input_Module.Output_Nodes[i].Node_Bounds.Size.Height / 2)),
                        new Point(input_Module.Output_Nodes[i].LinkTo.Link_Node.Node_Bounds.X + (input_Module.Output_Nodes[i].LinkTo.Link_Node.Node_Bounds.Size.Width / 2), input_Module.Output_Nodes[i].LinkTo.Link_Node.Node_Bounds.Y + (input_Module.Output_Nodes[i].LinkTo.Link_Node.Node_Bounds.Height / 2))});
                }
            }
            input_Module.ModuleBounds_NonTerminal = new Rectangle(new Point(input_Module.ModuleLocation.X + NodeDisplay_Offset_Horizontal, input_Module.ModuleLocation.Y + NodeDisplay_Offset_Vertical), input_Module.ModuleSize);
            input_DrawArea.DrawImage(input_Module.ModuleImage, input_Module.ModuleBounds_NonTerminal);
            if (input_Module.id == "NUMBER")
            {
                double _temp_double = ((LogicModules.LogicModule_Number)input_Module).NumberValue;
                Font _tempFont = new Font(new FontFamily("Arial"), 16.0f);
                RectangleF _tempRf = new RectangleF(input_Module.ModuleBounds_NonTerminal.Location, input_Module.ModuleBounds_NonTerminal.Size);
                string _tempDoubleString = _temp_double.ToString();
                SizeF _tempSizeFont = input_DrawArea.MeasureString(_tempDoubleString, _tempFont);
                input_DrawArea.DrawString(_tempDoubleString, _tempFont, Brushes.Black,
                    new PointF(input_Module.ModuleBounds_NonTerminal.Location.X + (input_Module.ModuleBounds_NonTerminal.Width / 2) - (_tempSizeFont.Width / 2),
                    input_Module.ModuleBounds_NonTerminal.Y + (input_Module.ModuleBounds_NonTerminal.Height / 2) - (_tempSizeFont.Height / 2)));
            }
            else if (input_Module.id == "INPUT")
            {
                if (input_AllInputModules != null)
                {
                    bool _inputTSB_alreadyAdded = false;
                    for (int _inputTSB_i = 0; _inputTSB_i < input_AllInputModules.Count; _inputTSB_i++)
                    {
                        if (input_AllInputModules[_inputTSB_i].ToLower() == ((LogicModules.LogicModule_INPUT)input_Module).referenceID.ToLower())
                        {
                            _inputTSB_alreadyAdded = true;
                            break;
                        }
                    }
                    if (!_inputTSB_alreadyAdded)
                    {
                        input_AllInputModules.Add(((LogicModules.LogicModule_INPUT)input_Module).referenceID);
                    }
                }
            }
            if (!Module_Possibilities.Contains(input_Module.id) || input_Module.id == "DIGITALOUTPUT" || input_Module.id == "VARIABLE" || input_Module.id == "ANALOGUEINPUT" || input_Module.id == "INPUT")
            {
                if (showText)
                {
                    bool hasBottomNodes = false;
                    foreach (LogicModules.Node _nnn in input_Module.Input_Nodes)
                    {
                        if (_nnn.Module_Face == LogicModules.ModuleFace.DownSide)
                        {
                            hasBottomNodes = true;
                            break;
                        }
                    }
                    foreach (LogicModules.Node _nnn2 in input_Module.Output_Nodes)
                    {
                        if (_nnn2.Module_Face == LogicModules.ModuleFace.DownSide)
                        {
                            hasBottomNodes = false;
                            break;
                        }
                    }
                    int _customYoffset = 5;
                    if (hasBottomNodes)
                    {
                        _customYoffset = (global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_BOTTOM.Height) + 5;
                    }
                    Font _tempFont = new Font(new FontFamily("Arial"), 16.0f);
                    RectangleF _tempRf = new RectangleF(input_Module.ModuleBounds_NonTerminal.Location, input_Module.ModuleBounds_NonTerminal.Size);
                    string _tempString = "";
                    if (!Module_Possibilities.Contains(input_Module.id))
                    {
                        _tempString = input_Module.id;
                    }
                    else
                    {
                        switch (input_Module.id)
                        {
                            case "ANALOGUEINPUT":
                                {
                                    _tempString = ((LogicModules.LogicModule_ANALOGUEINPUT)input_Module).referenceID;
                                }
                                break;
                            case "DIGITALOUTPUT":
                                {
                                    _tempString = ((LogicModules.LogicModule_DIGITALOUTPUT)input_Module).referenceID;
                                }
                                break;
                            case "VARIABLE":
                                {
                                    _tempString = ((LogicModules.LogicModule_VARIABLE)input_Module).referenceID;
                                }
                                break;
                            case "INPUT":
                                {
                                    _tempString = ((LogicModules.LogicModule_INPUT)input_Module).referenceID;
                                }
                                break;
                            default:
                                break;
                        }
                    }
                    SizeF _tempSizeFont = input_DrawArea.MeasureString(_tempString, _tempFont);
                    input_DrawArea.DrawString(_tempString, _tempFont, Brushes.Black,
                        new PointF(input_Module.ModuleBounds_NonTerminal.Location.X + (input_Module.ModuleBounds_NonTerminal.Width / 2) - (_tempSizeFont.Width / 2),
                        input_Module.ModuleBounds_NonTerminal.Y + input_Module.ModuleBounds_NonTerminal.Height + _customYoffset));
                }
            }
        }

        public string UpdateXML()
        {
            string _XML = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\r\n<function>";
            LogicModules.Module _mod = null;
            foreach (LogicModules.Module _Tmod in _CurrentFunction._Modules)
            {
                if (_Tmod.id == "OUTPUT")
                {
                    _mod = _Tmod;
                    break;
                }
            }
            if(_mod == null)
            {
                return "";
            }
            if(_mod.Input_Nodes.Count != 1)
            {
                return "";
            }
            int _temp_Input_i = 0;
            List<string> _temp_Input_alreadyAdded = new List<string>();
            foreach(LogicModules.Module _mod2 in _CurrentFunction._Modules)
            {
                if(_mod2.id == "INPUT")
                {
                    bool isAlreadyAddedToFunctionInput = false;
                    foreach (string _sss in _temp_Input_alreadyAdded)
                    {
                        if (_sss.ToLower() == ((LogicModules.LogicModule_INPUT)_mod2).referenceID.ToLower())
                        {
                            isAlreadyAddedToFunctionInput = true;
                            break;
                        }
                    }
                    if (!isAlreadyAddedToFunctionInput)
                    {
                        _temp_Input_i++;
                        _temp_Input_alreadyAdded.Add(((LogicModules.LogicModule_INPUT)_mod2).referenceID);
                        _XML += "\r\n  <input order=\"" + _temp_Input_i.ToString() + "\">" + ((LogicModules.LogicModule_INPUT)_mod2).referenceID + "</input>";
                    }
                }
            }
            if (_temp_Input_i == 0)
            {
                if (isEditingRootNode)
                {
                    if (!VerifyNoEmptyNodes(_mod))
                    {
                        return "";
                    }
                }
                else
                {
                    return "";
                }
            }
            if (!_mod.Input_Nodes[0].isConnected())
            {
                return "";
            }
            if (!isEditingRootNode)
            {
                switch (_mod.Input_Nodes[0].LinkTo.Link_Module.id)
                {
                    case "AND":
                    case "OR":
                    case "NOT":
                    case "NAND":
                    case "NOR":
                    case "XOR":
                    case "LESS THAN":
                    case "LESS THAN OR EQUAL TO":
                    case "GREATER THAN":
                    case "GREATER THAN OR EQUAL TO":
                    case "BETWEEN II":
                    case "BETWEEN EE":
                    case "BETWEEN IE":
                    case "BETWEEN EI":
                    case "EQUAL TO":
                    case "NOT EQUAL TO":
                        _XML += "\r\n  <return type=\"boolean\">";
                        break;
                    case "ADD":
                    case "SUBTRACT":
                    case "MULTIPLY":
                    case "DIVIDE":
                    case "NUMBER":
                        _XML += "\r\n  <return type=\"numeric\">";
                        break;
                    default:
                        //Error
                        //Custom Function...
                        _XML += "\r\n  <return type=\"numeric\">";
                        break;
                }
            }
            string _funcString = "";
            _funcString = XML_IterateFunctionModules(_mod.Input_Nodes[0].LinkTo.Link_Module, _funcString, 0);
            if (isEditingRootNode)
            {
                _XML = "<if fire_on=\"" + _CurrentFunction._timerID + "\">" + _funcString + "\r\n</if>";
                TXT_FUNCTION.Text = _XML;
                this.Update();
                return _XML;
            }
            _XML += _funcString;
            _XML += "\r\n  </return>";
            _XML += "\r\n</function>";
            TXT_FUNCTION.Text = _XML;
            this.Update();
            return _XML;
        }
        #endregion

        #region Iterate Through Function
        public static string XML_IterateFunctionModules(LogicModules.Module input_mod, string input_string, int input_level)
        {
            string PADDINGSTRING = "\r\n  ";
            for (int i = 0; i < input_level; i++)
            {
                PADDINGSTRING += "  ";
            }
            LogicModules.Module _mod = input_mod;
            if (_mod != null)
            {
                switch (_mod.id.ToUpper())
                {
                    case "AND":
                    case "OR":
                    case "NOT":
                    case "NAND":
                    case "NOR":
                    case "XOR":
                    case "LESS THAN":
                    case "LESS THAN OR EQUAL TO":
                    case "GREATER THAN":
                    case "GREATER THAN OR EQUAL TO":
                    case "BETWEEN II":
                    case "BETWEEN EE":
                    case "BETWEEN IE":
                    case "BETWEEN EI":
                    case "EQUAL TO":
                    case "NOT EQUAL TO":
                        input_string += PADDINGSTRING + "<boolean_operation type=\"" + (_mod.id.ToLower()) + "\">";
                        {
                            for (int i_param = 0; i_param < _mod.Input_Nodes.Count; i_param++)
                            {
                                if (_mod.Input_Nodes[i_param].isConnected())
                                {
                                    input_string += PADDINGSTRING + "  " + "<parameter" + (i_param + 1) + ">";
                                    input_string = XML_IterateFunctionModules(_mod.Input_Nodes[i_param].LinkTo.Link_Module, input_string, (input_level + 2));
                                    input_string += PADDINGSTRING + "  " + "</parameter" + (i_param + 1) + ">";
                                }
                            }
                        }
                        input_string += PADDINGSTRING + "</boolean_operation>";
                        break;
                    case "ADD":
                    case "SUBTRACT":
                    case "MULTIPLY":
                    case "DIVIDE":
                        input_string += PADDINGSTRING + "<operation type=\"" + (_mod.id.ToLower()) + "\">";
                        {
                            for (int i_param = 0; i_param < _mod.Input_Nodes.Count; i_param++)
                            {
                                if (_mod.Input_Nodes[i_param].isConnected())
                                {
                                    input_string += PADDINGSTRING + "  " + "<parameter" + (i_param + 1) + ">";
                                    input_string = XML_IterateFunctionModules(_mod.Input_Nodes[i_param].LinkTo.Link_Module, input_string, (input_level + 2));
                                    input_string += PADDINGSTRING + "  " + "</parameter" + (i_param + 1) + ">";
                                }
                            }
                        }
                        input_string += PADDINGSTRING + "</operation>";
                        return input_string;
                        break;
                    case "INPUT":
                        {
                            input_string += PADDINGSTRING + "<variable do=\"get\">" + ((LogicModules.LogicModule_INPUT)_mod).referenceID + "</variable>";
                            return input_string;
                        }
                        break;
                    case "NUMBER":
                        {
                            input_string += PADDINGSTRING + "<number>" + ((LogicModules.LogicModule_Number)_mod).NumberValue.ToString() + "</number>";
                            return input_string;
                        }
                        break;
                    case "VARIABLE":
                        {
                            string temp_VariableGetOrSet = ((LogicModules.LogicModule_VARIABLE)_mod).getOrSet.ToLower();
                            if (temp_VariableGetOrSet == "set")
                            {
                                input_string += PADDINGSTRING + "<variable do=\"" + temp_VariableGetOrSet + "\" name=\"" + ((LogicModules.LogicModule_VARIABLE)_mod).referenceID + "\">";
                                if (_mod.Input_Nodes.Count == 1)
                                {
                                    input_string = XML_IterateFunctionModules(_mod.Input_Nodes[0].LinkTo.Link_Module, input_string, (input_level + 2));
                                }
                                else { }
                                input_string += PADDINGSTRING + "</variable>";
                                return input_string;
                            }
                            else
                            {
                                input_string += PADDINGSTRING + "<variable do=\"" + temp_VariableGetOrSet + "\" name=\"" + ((LogicModules.LogicModule_VARIABLE)_mod).referenceID + "\"></variable>";
                                return input_string;
                            }
                        }
                        break;
                    case "ANALOGUEINPUT":
                        {
                            input_string += PADDINGSTRING + "<analogue id=\"" + ((LogicModules.LogicModule_ANALOGUEINPUT)_mod).referenceID + "\" time=\"0\"></analogue>";
                            return input_string;
                        }
                        break;
                    case "DIGITALOUTPUT":
                        {
                            input_string += PADDINGSTRING + "<output id=\"" + ((LogicModules.LogicModule_DIGITALOUTPUT)_mod).referenceID + "\"></output>";
                            return input_string;
                        }
                        break;
                    default:
                        //Custom Function
                        {
                            input_string += PADDINGSTRING + "<evaluate function=\"" + (_mod.id.ToLower()) + "\">";
                            LogicModules.Module_FunctionMDX _tempMDX_Function = (LogicModules.Module_FunctionMDX)_mod;
                            for (int i_input = 0; i_input < _tempMDX_Function.Input_Nodes.Count; i_input++)
                            {
                                input_string += PADDINGSTRING + "  " + "<input order=\"" + (i_input + 1) + "\">";
                                input_string = XML_IterateFunctionModules(_mod.Input_Nodes[i_input].LinkTo.Link_Module, input_string, (input_level + 2));
                                input_string += PADDINGSTRING + "  " + "</input>";
                            }
                            input_string += PADDINGSTRING + "</evaluate>";
                        }
                        break;
                }
            }
            return input_string;
        }
        #endregion

        #region Get Info Back
        public List<object> GetThisFunctionDataBack()
        {
            if (_CurrentFunction == null || _CurrentFunction._FunctionID == "")
            {
                return null;
            }
            return new List<object>(new object[] { (object)_CurrentFunction });
        }
        #endregion

        #region Verify No Empty Nodes for Root Node Editing
        public bool VerifyNoEmptyNodes(LogicModules.Module input_mod)
        {
            foreach (LogicModules.Module _mod in _CurrentFunction._Modules)
            {
                foreach (LogicModules.Node _nodeA in _mod.Input_Nodes)
                {
                    if (!_nodeA.isConnected())
                    {
                        return false;
                    }
                }
                foreach (LogicModules.Node _nodeB in _mod.Output_Nodes)
                {
                    if (!_nodeB.isConnected())
                    {
                        return false;
                    }
                }
            }
            return true;
        }
        #endregion

        #region Save Icon Clicked
        private void TSB_Save_Click(object sender, EventArgs e)
        {
            SaveFunction();
        }
        #endregion

        #region Open Icon Clicked
        private void TSB_OpenFile_Click(object sender, EventArgs e)
        {
            if (!Directory.Exists(GlobalStaticClass.FUNCTION_DIRECTORY))
            {
                (new ErrorForm("No Function Directory Exists", "No function directory exists, so there are no functions to open.")).ShowDialog();
                return;
            }
            string[] fI = Directory.GetFiles(GlobalStaticClass.FUNCTION_DIRECTORY, "*.xml");
            List<string> GoodFilesToOpen = new List<string>();
            foreach (string _fI_des in fI)
            {
                string _temp_DES = _fI_des;
                if (_temp_DES.EndsWith(".xml"))
                {
                    _temp_DES = _temp_DES.Replace(".xml", ".designer");
                }
                else { continue; }
                if (File.Exists(_temp_DES))
                {
                    GoodFilesToOpen.Add(_temp_DES);
                }
            }
            if (GoodFilesToOpen.Count == 0)
            {
                (new ErrorForm("No Compatible Files", "There are no files that can be read in by this version of the Uber MDX COnfigurator.\r\n" +
                    "Verify that you have both a *.xml and a *.designer file for each function.")).ShowDialog();
                return;
            }
            OpenFileDialog _oFD = new OpenFileDialog();
            _oFD.InitialDirectory = GlobalStaticClass.FUNCTION_DIRECTORY;
            _oFD.Filter = "Uber MDX Designer (*.designer) | *.designer";
            if (_oFD.ShowDialog() != DialogResult.OK)
            {
                return;
            }
            string _toOpen = _oFD.FileName;
            OpenFunction(_toOpen);
        }

        public bool OpenFunction(string _toOpen)
        {
            if (!File.Exists(_toOpen))
            {
                (new ErrorForm("Invalid File", "File Does not exist")).ShowDialog();
                return false;
            }

            string _toOpenContents = "";
            FileStream fs = new FileStream(_toOpen, FileMode.Open, FileAccess.Read);
            StreamReader sr = new StreamReader(fs);
            _toOpenContents = sr.ReadToEnd();
            sr.Close();
            fs.Close();
            if (_toOpenContents == "")
            {
                (new ErrorForm("Empty File", "File is empty")).ShowDialog();
                return false;
            }
            string[] _fullFileName = _toOpen.Split(new char[] { '\\' });
            string _temp_FuncName = "";
            if (_fullFileName[_fullFileName.Length - 1].EndsWith(".designer"))
            {
                _temp_FuncName = _fullFileName[_fullFileName.Length - 1];
                _temp_FuncName = _temp_FuncName.Substring(0, _temp_FuncName.Length - ".designer".Length);
                _CurrentFunction._FunctionID = _temp_FuncName;
            }
            if (!TextToDesigner(_toOpenContents))
            {
                PrepareNewFunction();
            }
            else
            {
                _CurrentFunction._FunctionID = _temp_FuncName;
            }
            ReloadAllFunctions();
            return true;
        }
        #endregion

        #region Loading New Function
        public bool TextToDesigner(string _input)
        {
            PrepareNewFunction();

            try
            {
                XmlDocument _XMLDoc = new XmlDocument();
                _XMLDoc.LoadXml(_input);

                XmlNode _root = _XMLDoc.SelectSingleNode("function_designer");
                List<int[]> _temp_LinkTo = new List<int[]>();

                int _mod_index = -1;
                foreach (XmlNode _XML_modules in _root.ChildNodes)
                {
                    if (_XML_modules.Name.ToLower() == "module")
                    {
                        _mod_index++;
                        foreach (XmlNode _linkToNode in _XML_modules.ChildNodes)
                        {
                            if (_linkToNode.Name.ToLower() == "link")
                            {
                                string _linkNode_moduleString = _linkToNode.Attributes.GetNamedItem("module").Value;
                                string _linkNode_nodeString = _linkToNode.Attributes.GetNamedItem("node").Value;
                                string _linkNode_nodeFromString = _linkToNode.Attributes.GetNamedItem("from_node").Value;
                                _temp_LinkTo.Add(new int[] { _mod_index, int.Parse(_linkNode_nodeFromString), int.Parse(_linkNode_moduleString), int.Parse(_linkNode_nodeString) });
                            }
                        }
                        String[] _locString = _XML_modules.Attributes.GetNamedItem("location").Value.Split(new char[] { ',' });
                        if (_locString.Length != 2)
                        {
                            //Error, Too many splits
                            return false;
                        }
                        int[] _locInt = new int[2];
                        if (!int.TryParse(_locString[0], out _locInt[0]) || !int.TryParse(_locString[1], out _locInt[1]))
                        {
                            //Error, Didnt parse
                            return false;
                        }
                        Point _loc = new Point(_locInt[0], _locInt[1]);
                        LogicModules.Module _tempModule = null;

                        switch (_XML_modules.Attributes.GetNamedItem("type").Value)
                        {
                            case "AND":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_And2(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.AND_Icon, null));
                                }
                                break;
                            case "OR":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Or2(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.OR_Icon, null));
                                }
                                break;
                            case "NOT":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Not2(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.NOT_Icon, null));
                                }
                                break;
                            case "NAND":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Nand2(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.NAND_Icon, null));
                                }
                                break;
                            case "NOR":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Nor2(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.NOR_Icon, null));
                                }
                                break;
                            case "XOR":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Xor2(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.XOR_Icon, null));
                                }
                                break;
                            case "ADD":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Add(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Addition_Icon, null));
                                }
                                break;
                            case "SUBTRACT":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Subtraction(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Subtraction_Icon, null));
                                }
                                break;
                            case "MULTIPLY":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Multiplication(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Multiplication_Icon, null));
                                }
                                break;
                            case "DIVIDE":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Division(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Division_Icon, null));
                                }
                                break;
                            case "EQUAL TO":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Equals(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Equals_Icon, null));
                                }
                                break;
                            case "NOT EQUAL TO":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_NotEquals(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_NotEqual_Icon, null));
                                }
                                break;
                            case "LESS THAN":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_LessThan(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_LessThan_icon, null));
                                }
                                break;
                            case "GREATER THAN":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_GreaterThan(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_GreaterThan_Icon, null));
                                }
                                break;
                            case "LESS THAN OR EQUAL TO":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_LessThanOrEqualTo(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_LessThanOrEqualTo_icon, null));
                                }
                                break;
                            case "GREATER THAN OR EQUAL TO":
                                {
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_GreaterThanOrEqualTo(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_GreaterThanOrEqualTo_Icon, null));
                                }
                                break;
                            case "NUMBER":
                                {
                                    string _valueString = _XML_modules.Attributes.GetNamedItem("number_value").Value;
                                    double _value = 0.0;
                                    if (!double.TryParse(_valueString, out _value))
                                    {
                                        return false;
                                    }
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Number(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.NumberIconTransparent, null, _value));
                                }
                                break;
                            case "INPUT":
                                {
                                    string _valueString = _XML_modules.Attributes.GetNamedItem("input_reference_id").Value;
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_INPUT(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.LogicInputIcon, null, _valueString));
                                }
                                break;
                            case "OUTPUT":
                                _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_OUTPUT(_loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.LogicOutputIcon, null));
                                break;
                            default:
                                //Error
                                Console.WriteLine(_XML_modules.Attributes.GetNamedItem("type").Value);
                                foreach (LogicModules.PsuedoFunctionMDX _psu in LogicModules._Global_FunctionsList)
                                {
                                    if (_psu._id.ToLower() == _XML_modules.Attributes.GetNamedItem("type").Value.ToLower())
                                    {
                                        _tempModule = (LogicModules.Module)(new LogicModules.Module_FunctionMDX(_psu, _loc, global::FCC_Uber_MDX_Configurator.Properties.Resources.FunctionIcon));
                                        break;
                                    }
                                }
                                break;
                        }
                        if (_tempModule == null)
                        {
                            return false;
                        }
                        _CurrentFunction._Modules.Add(_tempModule);
                    }
                }
                
                foreach (int[] _iA in _temp_LinkTo)
                {
                    LogicModules.Module _LinkFromModule = _CurrentFunction._Modules[_iA[0]];
                    LogicModules.Module _LinkToModule = _CurrentFunction._Modules[_iA[2]];
                    LogicModules.Node _LinkFromNode = _LinkFromModule.Output_Nodes[_iA[1]];
                    LogicModules.Node _LinkToNode = _LinkToModule.Input_Nodes[_iA[3]];
                    _LinkFromModule.Output_Nodes[_iA[1]].LinkTo = new LogicModules.Node.ConnectLink(_LinkToModule, LogicModules.Node.LinkDirection.INPUT, _LinkToNode);
                    _LinkToModule.Input_Nodes[_iA[3]].LinkTo = new LogicModules.Node.ConnectLink(_LinkFromModule, LogicModules.Node.LinkDirection.OUTPUT, _LinkFromNode);
                }
                UpdateThisFunction();
                return true;
            }
            catch (Exception e)
            {
                (new ErrorForm("Unknown Error", e.ToString())).ShowDialog();
                return false;
            }
        }
        #endregion

        #region Reload Already Made Functions
        void AllFunctionsDirectoryWatcher_ChangedOrCreated(object sender, FileSystemEventArgs e)
        {
            CheckForIllegalCrossThreadCalls = false;
            ReloadAllFunctions();
            CheckForIllegalCrossThreadCalls = true;
        }

        public void ReloadAllFunctions()
        {
            LogicModules.ReadInAllFunctions();
            TSBDROP_ADD_PREMADE_FUNCTION.DropDownItems.Clear();
            foreach (LogicModules.PsuedoFunctionMDX temp_psuedo in LogicModules._Global_FunctionsList)
            {
                if (temp_psuedo._id.ToLower() != _CurrentFunction._FunctionID.ToLower())
                {
                    TSBDROP_ADD_PREMADE_FUNCTION.DropDownItems.Add(temp_psuedo._id, global::FCC_Uber_MDX_Configurator.Properties.Resources.FunctionIcon);
                }
            }
            if (TSBDROP_ADD_PREMADE_FUNCTION.DropDownItems.Count > 0)
            {
                TSBDROP_ADD_PREMADE_FUNCTION.Enabled = true;
            }
            else
            {
                TSBDROP_ADD_PREMADE_FUNCTION.Enabled = false;
            }
        }
        #endregion

        #region Location of Cursor
        public Point CursorToPointForModule(Point Location)
        {
            return new Point(Location.X - (this.Cursor.Size.Width / 2) - (global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_LEFT.Width / 2), Location.Y - (this.Cursor.Size.Height / 2) - (global::FCC_Uber_MDX_Configurator.Properties.Resources.Terminal_TOP.Height / 2));
        }
        #endregion

        #region Setup New Module
        public void SetupANewModule(string isAddingString, Bitmap newCursorImage)
        {
            isAdding = isAddingString;
            LastCursorBeforeHand = new Cursor(newCursorImage.GetHicon());
            this.Cursor = LastCursorBeforeHand;
            this.Update();
        }
        #endregion

        #region Mouse Click Handler
        private void LOGIC_PANEL_MouseClick(object sender, MouseEventArgs e)
        {
            #region Left Button Clicked
            if (e.Button == MouseButtons.Left)
            {
                if (!AllowDropOfObject)
                {
                    return;
                }

                this.Cursor = System.Windows.Forms.Cursors.Arrow;
                if (isAdding == null)
                {
                    if (isMoving == null)
                    {
                        //Find and Move current object...
                        foreach (LogicModules.Module _mod in _CurrentFunction._Modules)
                        {
                            if (_mod.ModuleBounds != null)
                            {
                                if (_mod.ModuleBounds.Contains(e.Location))
                                {
                                    if (_mod.ModuleBounds_NonTerminal.Contains(e.Location))
                                    {
                                        LastCursorBeforeHand = _mod.ModuleCursor;
                                        this.Cursor = _mod.ModuleCursor;
                                        isMoving = _mod;
                                        return;
                                    }
                                    else
                                    {
                                        if (isConnecting != null)
                                        {
                                            if (isConnecting.Link_Module == _mod)
                                            {
                                                (new ErrorForm("Invalid Node Link", "You cannot link the output of a Module to its own input")).ShowDialog();
                                                isConnecting = null;
                                                return;
                                            }
                                            Console.Write("Terminal [" + _CurrentFunction._Modules.IndexOf(_mod) + "]: ");
                                            LogicModules.Node _node = null;
                                            for (int node_in_i = 0; node_in_i < _mod.Input_Nodes.Count; node_in_i++)
                                            {
                                                if (_mod.Input_Nodes[node_in_i].Node_Bounds.Contains(e.Location))
                                                {
                                                    Console.WriteLine("IN " + node_in_i.ToString() + " Connecting");
                                                    _node = _mod.Input_Nodes[node_in_i];
                                                    if (isConnecting.Link_Direction == LogicModules.Node.LinkDirection.INPUT)
                                                    {
                                                        (new ErrorForm("Invalid Node Link", "You cannot link an input to an input")).ShowDialog();
                                                        isConnecting = null;
                                                        return;
                                                    }
                                                    if (isConnectingToParentNode(_mod, isConnecting.Link_Module))
                                                    {
                                                        (new ErrorForm("Invalid Node Link", "You cannot link an child module to a parent module, or any module with a higher order")).ShowDialog();
                                                        isConnecting = null;
                                                        return;
                                                    }
                                                    if (!VerifyOutputIsABooleanIfIsEditingRootNode(isConnecting.Link_Module, _mod))
                                                    {
                                                        (new ErrorForm("Invalid Node Link", "You cannot link a non-boolean module to the output of an if/then node")).ShowDialog();
                                                        isConnecting = null;
                                                        return;
                                                    }
                                                    NodeIsAlreadyConnectedSoDeleteDuplicateReference(_node);
                                                    _node.LinkTo = new LogicModules.Node.ConnectLink(isConnecting.Link_Module, isConnecting.Link_Direction, isConnecting.Link_Node);
                                                    isConnecting.Link_Node.LinkTo = new LogicModules.Node.ConnectLink(_mod, LogicModules.Node.LinkDirection.INPUT, _node);
                                                    isConnecting = null;
                                                    UpdateThisFunction();
                                                    return;
                                                }
                                            }
                                            for (int node_out_i = 0; node_out_i < _mod.Output_Nodes.Count; node_out_i++)
                                            {
                                                if (_mod.Output_Nodes[node_out_i].Node_Bounds.Contains(e.Location))
                                                {
                                                    Console.WriteLine("OUT " + node_out_i.ToString() + " Connecting");
                                                    (new ErrorForm("Invalid Node Link", "You cannot link an output to an output")).ShowDialog();
                                                    isConnecting = null;
                                                    return;
                                                }
                                            }
                                            Console.WriteLine();
                                           
                                        }
                                        return;
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        isMoving.ModuleLocation = CursorToPointForModule(e.Location);
                        LastCursorBeforeHand = Cursors.Arrow;
                        this.Cursor = Cursors.Arrow;
                        isMoving = null;
                        UpdateThisFunction();
                        this.Invalidate(true);
                        return;
                    }
                }
                LogicModules.Module _tempModule = null;

                switch (isAdding)
                {
                    case "INPUT":
                        {
                            if (string_DropDownItem == null)
                            {
                                FunctionInputAddingForm _tempFUNCInput = new FunctionInputAddingForm();
                                if (_tempFUNCInput.ShowDialog() == DialogResult.OK)
                                {
                                    object tempReturned = _tempFUNCInput.GetReturnNameInfoBack();
                                    if (tempReturned != null)
                                    {
                                        string tempReturned_string = (string)tempReturned;
                                        if (!MakeSureItIsntADuplicateNameInput(tempReturned_string))
                                        {
                                            (new ErrorForm("Invalid Input Name", "The name \"" + tempReturned_string + "\" is already in use by another input. You cannot have duplicate inputs.")).ShowDialog();
                                            break;
                                        }
                                        else
                                        {
                                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_INPUT(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.LogicInputIcon, null, tempReturned_string));
                                        }
                                    }
                                }
                            }
                            else
                            {
                                _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_INPUT(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.LogicInputIcon, null, string_DropDownItem));
                            }
                        }
                        break;
                    case "OUTPUT":
                        {
                            if (MakeSureThereIsOnlyOneOutput())
                            {
                                _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_OUTPUT(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.LogicOutputIcon, null));
                            }
                            else
                            {
                                (new ErrorForm("Multiple Outputs", "A Function may have only 1 Output. There is already an output added.")).ShowDialog();
                                break;
                            }
                        }
                        break;
                    case "DIGITALOUTPUT":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_DIGITALOUTPUT(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.OutputIcon, null, string_DropDownItem));
                        }
                        break;
                    case "ANALOGUEINPUT":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_ANALOGUEINPUT(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.InputIcon, null, string_DropDownItem));
                        }
                        break;
                    case "VARIABLE_SET":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_VARIABLE(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.VariableIcon, null, string_DropDownItem, "set"));
                        }
                        break;
                    case "VARIABLE_GET":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_VARIABLE(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.VariableIcon, null, string_DropDownItem, "get"));
                        }
                        break;
                    case "NUMBER":
                        {
                            FunctionNumberAddingForm temp_FUNCForm = new FunctionNumberAddingForm();
                            if (temp_FUNCForm.ShowDialog() == DialogResult.OK)
                            {
                                object temp_returned = temp_FUNCForm.GetNumberValueBack();
                                if (temp_returned != null)
                                {
                                    double temp_double = (double)temp_returned;
                                    _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Number(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.NumberIconTransparent, null, temp_double));
                                }
                            }
                            else
                            {
                                break;
                            }
                        }
                        break;
                    case "AND":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_And2(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.AND_Icon, null));
                        }
                        break;
                    case "OR":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Or2(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.OR_Icon, null));
                        }
                        break;
                    case "NOT":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Not2(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.NOT_Icon, null));
                        }
                        break;
                    case "NAND":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Nand2(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.NAND_Icon, null));
                        }
                        break;
                    case "NOR":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Nor2(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.NOR_Icon, null));
                        }
                        break;
                    case "XOR":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Xor2(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.XOR_Icon, null));
                        }
                        break;
                    case "ADD":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Add(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Addition_Icon, null));
                        }
                        break;
                    case "SUBTRACT":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Subtraction(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Subtraction_Icon, null));
                        }
                        break;
                    case "MULTIPLY":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Multiplication(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Multiplication_Icon, null));
                        }
                        break;
                    case "DIVIDE":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Division(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Division_Icon, null));
                        }
                        break;
                    case "EQUAL TO":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_Equals(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Equals_Icon, null));
                        }
                        break;
                    case "NOT EQUAL TO":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_NotEquals(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_NotEqual_Icon, null));
                        }
                        break;
                    case "LESS THAN":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_LessThan(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_LessThan_icon, null));
                        }
                        break;
                    case "GREATER THAN":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_GreaterThan(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_GreaterThan_Icon, null));
                        }
                        break;
                    case "LESS THAN OR EQUAL TO":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_LessThanOrEqualTo(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_LessThanOrEqualTo_icon, null));
                        }
                        break;
                    case "GREATER THAN OR EQUAL TO":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_GreaterThanOrEqualTo(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_GreaterThanOrEqualTo_Icon, null));
                        }
                        break;
                    case "CUSTOM FUNCTION":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.Module_FunctionMDX(FindPsuedoFromReferenceID(string_CustomFunctionDropDown), CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.FunctionIcon));
                        }
                        break;
                    case "BETWEEN II":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_BetweenII(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Between_Inclusive_Inclusive, null));
                        }
                        break;
                    case "BETWEEN IE":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_BetweenIE(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Between_Inclusive_Exclusive, null));
                        }
                        break;
                    case "BETWEEN EI":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_BetweenEI(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Between_Exclusive_Inclusive, null));
                        }
                        break;
                    case "BETWEEN EE":
                        {
                            _tempModule = (LogicModules.Module)(new LogicModules.LogicModule_BetweenEE(CursorToPointForModule(e.Location), global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Between_Exclusive_Exclusive, null));
                        }
                        break;
                    default:
                        break;
                }
                if (_tempModule == null)
                {
                    return;
                }
                _CurrentFunction._Modules.Add(_tempModule);
                isAdding = null;
                string_CustomFunctionDropDown = null;
                string_DropDownItem = null;
                UpdateThisFunction();
            }
            #endregion

            #region Right Button Clicked
            else if (e.Button == MouseButtons.Right)
            {
                foreach (Rectangle _r in ModuleNoGood)
                {
                    if (_r.Contains(e.Location))
                    {
                        foreach (LogicModules.Module _m in _CurrentFunction._Modules)
                        {
                            if (_m.ModuleBounds == _r)
                            {
                                if (_m.ModuleBounds_NonTerminal.Contains(e.Location))
                                {
                                    isConnecting = null;
                                    HoveringModule = _m;
                                    CONTEXT_STRIP_LogicDesigner_Module.Show(LOGIC_PANEL, e.Location);
                                    return;
                                }
                                else
                                {
                                    Console.Write("Terminal [" + _CurrentFunction._Modules.IndexOf(_m) + "]: ");
                                    for (int node_in_i = 0; node_in_i < _m.Input_Nodes.Count; node_in_i++)
                                    {
                                        if (_m.Input_Nodes[node_in_i].Node_Bounds.Contains(e.Location))
                                        {
                                            Console.WriteLine("IN " + node_in_i.ToString());
                                            //isConnecting = new LogicModules.Node.ConnectLink(_m, LogicModules.Node.LinkDirection.INPUT, _m.Input_Nodes[node_in_i]);
                                            (new ErrorForm("Invalid Node Link", "You cannot start a link from an input. Start a link with an output.")).ShowDialog();
                                            isConnecting = null; 
                                            return;
                                        }
                                    }
                                    for (int node_out_i = 0; node_out_i < _m.Output_Nodes.Count; node_out_i++)
                                    {
                                        if (_m.Output_Nodes[node_out_i].Node_Bounds.Contains(e.Location))
                                        {
                                            Console.WriteLine("OUT " + node_out_i.ToString());
                                            isConnecting = new LogicModules.Node.ConnectLink(_m, LogicModules.Node.LinkDirection.OUTPUT, _m.Output_Nodes[node_out_i]);
                                            return;
                                        }
                                    }
                                    Console.WriteLine();
                                    return;
                                }
                            }
                        }
                    }
                }
                return;
            }
            #endregion

            #region Error
            else { };
            #endregion
        }
        #endregion

        #region Find Psuedo Function from ID
        public static LogicModules.PsuedoFunctionMDX FindPsuedoFromReferenceID(string input_searchstring)
        {
            foreach (LogicModules.PsuedoFunctionMDX _p in LogicModules._Global_FunctionsList)
            {
                if (_p._id.ToLower() == input_searchstring.ToLower())
                {
                    return _p;
                }
            }
            return null;
        }
        #endregion

        #region Verify Only One Output
        public bool MakeSureThereIsOnlyOneOutput()
        {
            foreach (LogicModules.Module _mod in _CurrentFunction._Modules)
            {
                if (_mod.id == "OUTPUT")
                {
                    return false;
                }
            }
            return true;
        }
        #endregion

        #region Verify Output is Boolean if isEditingRootNode
        public bool VerifyOutputIsABooleanIfIsEditingRootNode(LogicModules.Module _mod, LogicModules.Module _testForOutputModule)
        {
            if (_testForOutputModule.id != "OUTPUT")
            {
                return true;
            }
            if (isEditingRootNode)
            {
                switch (_mod.id)
                {
                    case "AND":
                    case "OR":
                    case "NOT":
                    case "NAND":
                    case "NOR":
                    case "XOR":
                    case "LESS THAN":
                    case "LESS THAN OR EQUAL TO":
                    case "GREATER THAN":
                    case "GREATER THAN OR EQUAL TO":
                    case "EQUAL TO":
                    case "NOT EQUAL TO":
                    case "DIGITALOUTPUT":
                    case "BETWEEN EE":
                    case "BETWEEN IE":
                    case "BETWEEN EI":
                    case "BETWEEN II":
                        return true;
                    case "ADD":
                    case "SUBTRACT":
                    case "MULTIPLY":
                    case "DIVIDE":
                    case "NUMBER":
                        return false;
                    case "VARIABLE":
                        {
                            string _varTestID = ((LogicModules.LogicModule_VARIABLE)_mod).referenceID.ToLower();
                            foreach (GlobalStaticClass._GlobalVariableClass _var in GlobalStaticClass._Global_List_Variables)
                            {
                                if (_var._id.ToLower() == _varTestID)
                                {
                                    if (((LogicModules.LogicModule_VARIABLE)_mod).getOrSet.ToLower() == "set")
                                    {
                                        return true;
                                    }
                                    else
                                    {
                                        object _o = _var._value;
                                        bool _b;
                                        if (bool.TryParse(_o.ToString(), out _b))
                                        {
                                            return true;
                                        }
                                        else
                                        {
                                            return false;
                                        }
                                    }
                                }
                            }
                            ErrorForm _tempError = (new ErrorForm("Output Directly Linked To Variable", "Currently I cannot check the return type of a variable to verify it gives a boolean value from here. By linking this variable directly to the if/then node output, it MUST be a boolean value or the program will error. I will assume it is, and you should check this.", true));
                            _tempError.MakeBigger(650, 250);
                            _tempError.ShowDialog();
                            return true;
                        }
                        return false;
                    default:
                        //Error
                        {
                            //Custom Function...
                            //Need To Check The linking function...
                            ErrorForm _tempError = (new ErrorForm("Output Directly Linked To Function", "Currently I cannot check the return type of a function to verify it gives a boolean value from here. By linking this function directly to the if/then node output, it MUST return a boolean value or the program will error. I will assume it is, and you should check this.", true));
                            _tempError.MakeBigger(650, 250);
                            _tempError.ShowDialog();
                            return true;
                        }
                }
            }
            return true;
        }
        #endregion

        #region Make Sure Input Reference is Unique
        public bool MakeSureItIsntADuplicateNameInput(string teststring)
        {
            foreach (LogicModules.Module _testMOD in _CurrentFunction._Modules)
            {
                if (_testMOD.id == "INPUT")
                {
                    if (((LogicModules.LogicModule_INPUT)_testMOD).referenceID.ToLower() == teststring.ToLower())
                    {
                        return false;
                    }
                }
            }
            return true;
        }
        #endregion

        #region Verify Not Connecting to a Parent Node
        public bool isConnectingToParentNode(LogicModules.Module _tryingToConnectTo, LogicModules.Module _TryingToConnectFrom)
        {
            for (int i = 0; i < _tryingToConnectTo.Output_Nodes.Count; i++)
            {
                if (_tryingToConnectTo.Output_Nodes[i].isConnected())
                {
                    if (_tryingToConnectTo.Output_Nodes[i].LinkTo.Link_Module == _TryingToConnectFrom)
                    {
                        return true;
                    }
                    else
                    {
                        return isConnectingToParentNode(_tryingToConnectTo.Output_Nodes[i].LinkTo.Link_Module, _TryingToConnectFrom);
                    }
                }
            }
            return false;
        }
        #endregion

        #region Clean up References for Moving/Deleting
        public void NodeIsAlreadyConnectedSoDeleteDuplicateReference(LogicModules.Node _node)
        {
            if (_node.isConnected())
            {
                foreach (LogicModules.Module _testmod in _CurrentFunction._Modules)
                {
                    foreach (LogicModules.Node _outNode in _testmod.Output_Nodes)
                    {
                        if (_outNode.LinkTo != null)
                        {
                            if (_outNode.LinkTo.Link_Node == _node)
                            {
                                _outNode.LinkTo = null;
                                return;
                            }
                        }
                    }
                }
            }
        }
        #endregion

        #region Mouse Leaving Panel
        private void LOGIC_PANEL_MouseLeave(object sender, EventArgs e)
        {
            this.Cursor = System.Windows.Forms.Cursors.Arrow;
            isAdding = null;
            string_CustomFunctionDropDown = null;
            string_DropDownItem = null;
            isMoving = null;
        }
        #endregion

        #region Mouse Entering Panel
        private void LOGIC_PANEL_MouseEnter(object sender, EventArgs e)
        {
            if (isAdding == null)
            {
                this.Cursor = System.Windows.Forms.Cursors.Arrow;
            }
        }
        #endregion

        #region Mouse Moving in Panel
        private void LOGIC_PANEL_MouseMove(object sender, MouseEventArgs e)
        {
            if (isAdding != null || isMoving != null)
            {
                foreach (Rectangle _r in ModuleNoGood)
                {
                    if (_r.Contains(e.Location))
                    {
                        if (isMoving != null)
                        {
                            if (isMoving.ModuleBounds == _r)
                            {
                                continue;
                            }
                        }
                        this.Cursor = System.Windows.Forms.Cursors.No;
                        AllowDropOfObject = false;
                        return;
                    }
                }
                this.Cursor = LastCursorBeforeHand;
                AllowDropOfObject = true;
            }
        }
        #endregion

        #region Popup Menu Clicked
        private void CONTEXT_STRIP_LogicDesigner_Module_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            if (HoveringModule == null)
            {
                return;
            }
            if (e.ClickedItem.ToString() == "Delete")
            {
                if ((new ConfirmDeleteForm(HoveringModule.id)).ShowDialog() == DialogResult.OK)
                {
                    foreach (LogicModules.Module _mod in _CurrentFunction._Modules)
                    {
                        foreach (LogicModules.Node _nod in _mod.Output_Nodes)
                        {
                            if (_nod.isConnected())
                            {
                                if (_nod.LinkTo.Link_Module == HoveringModule)
                                {
                                    _nod.LinkTo = null;
                                }
                            }
                        }
                    }
                    _CurrentFunction._Modules.Remove(HoveringModule);
                    UpdateThisFunction();
                }
            }
            else if (e.ClickedItem.ToString() == "About")
            {
                TOOLTIP_MODULEHELP.ToolTipTitle = HoveringModule.id;
                TOOLTIP_MODULEHELP.ToolTipIcon = ToolTipIcon.Info;
                TOOLTIP_MODULEHELP.UseFading = true;
                CONTEXT_STRIP_LogicDesigner_Module.Hide();
                TOOLTIP_MODULEHELP.Show(HoveringModule.HelpText, LOGIC_PANEL, 5000);
            }
        }
        #endregion

        #region Form Painting
        private void CustomFunctionForm_Paint(object sender, PaintEventArgs e)
        {
            UpdateGraphicsOfFunction();
        }
        #endregion

        #region Add Various Modules
        private void TSBDROP_ADD_PREMADE_FUNCTION_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            string_CustomFunctionDropDown = e.ClickedItem.ToString();
            SetupANewModule("CUSTOM FUNCTION", global::FCC_Uber_MDX_Configurator.Properties.Resources.FunctionIcon);
        }

        private void TSB_LOGIC_AND_Click(object sender, EventArgs e)
        {
            SetupANewModule("AND", global::FCC_Uber_MDX_Configurator.Properties.Resources.AND_Icon);
        }

        private void TSB_LOGIC_OR_Click(object sender, EventArgs e)
        {
            SetupANewModule("OR", global::FCC_Uber_MDX_Configurator.Properties.Resources.OR_Icon);
        }

        private void TSB_LOGIC_NOT_Click(object sender, EventArgs e)
        {
            SetupANewModule("NOT", global::FCC_Uber_MDX_Configurator.Properties.Resources.NOT_Icon);
        }

        private void TSB_LOGIC_NAND_Click(object sender, EventArgs e)
        {
            SetupANewModule("NAND", global::FCC_Uber_MDX_Configurator.Properties.Resources.NAND_Icon);
        }

        private void TSB_LOGIC_NOR_Click(object sender, EventArgs e)
        {
            SetupANewModule("NOR", global::FCC_Uber_MDX_Configurator.Properties.Resources.NOR_Icon);
        }

        private void TSB_LOGIC_XOR_Click(object sender, EventArgs e)
        {
            SetupANewModule("XOR", global::FCC_Uber_MDX_Configurator.Properties.Resources.XOR_Icon);
        }

        private void TSB_INPUTICON_Click(object sender, EventArgs e)
        {
            SetupANewModule("INPUT", global::FCC_Uber_MDX_Configurator.Properties.Resources.LogicInputIcon);
        }

        private void TSB_OUTPUTICON_Click(object sender, EventArgs e)
        {
            SetupANewModule("OUTPUT", global::FCC_Uber_MDX_Configurator.Properties.Resources.LogicOutputIcon);
        }

        private void TSB_LOGIC_ADD_Click(object sender, EventArgs e)
        {
            SetupANewModule("ADD", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Addition_Icon);
        }

        private void TSB_LOGIC_SUBTRACT_Click(object sender, EventArgs e)
        {
            SetupANewModule("SUBTRACT", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Subtraction_Icon);
        }

        private void TSB_LOGIC_MULTIPLY_Click(object sender, EventArgs e)
        {
            SetupANewModule("MULTIPLY", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Multiplication_Icon);
        }

        private void TSB_LOGIC_DIVIDE_Click(object sender, EventArgs e)
        {
            SetupANewModule("DIVIDE", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Division_Icon);
        }

        private void TSB_LOGIC_EQUALS_Click(object sender, EventArgs e)
        {
            SetupANewModule("EQUAL TO", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Equals_Icon);
        }

        private void TSB_LOGIC_NOTEQUAL_Click(object sender, EventArgs e)
        {
            SetupANewModule("NOT EQUAL TO", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_NotEqual_Icon);
        }

        private void TSB_LOGIC_LESSTHANOREQUALTO_Click(object sender, EventArgs e)
        {
            SetupANewModule("LESS THAN OR EQUAL TO", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_LessThanOrEqualTo_icon);
        }

        private void TSB_LOGIC_GREATERTHANOREQUALTO_Click(object sender, EventArgs e)
        {
            SetupANewModule("GREATER THAN OR EQUAL TO", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_GreaterThanOrEqualTo_Icon);
        }

        private void TSB_LOGIC_GREATERTHAN_Click(object sender, EventArgs e)
        {
            SetupANewModule("GREATER THAN", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_GreaterThan_Icon);
        }

        private void TSB_LOGIC_LESSTHAN_Click(object sender, EventArgs e)
        {
            SetupANewModule("LESS THAN", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_LessThan_icon);
        }

        private void TSB_NUMBER_Click(object sender, EventArgs e)
        {
            SetupANewModule("NUMBER", global::FCC_Uber_MDX_Configurator.Properties.Resources.NumberIcon);
        }

        private void TSB_INPUTICON_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            string_DropDownItem = e.ClickedItem.ToString();
            SetupANewModule("INPUT", global::FCC_Uber_MDX_Configurator.Properties.Resources.LogicInputIcon);
        }

        private void TSB_AddAnalogue_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            string_DropDownItem = e.ClickedItem.ToString();
            SetupANewModule("ANALOGUEINPUT", global::FCC_Uber_MDX_Configurator.Properties.Resources.InputIcon);
        }

        private void TSB_DigitalOutput_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            string_DropDownItem = e.ClickedItem.ToString();
            SetupANewModule("DIGITALOUTPUT", global::FCC_Uber_MDX_Configurator.Properties.Resources.OutputIcon);
        }

        private void TSB_Variable_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            string_DropDownItem = sender.ToString();
            if (e.ClickedItem.ToString().ToLower() == "set")
            {
                SetupANewModule("VARIABLE_SET", global::FCC_Uber_MDX_Configurator.Properties.Resources.VariableIcon);
            }
            else if (e.ClickedItem.ToString().ToLower() == "get")
            {
                SetupANewModule("VARIABLE_GET", global::FCC_Uber_MDX_Configurator.Properties.Resources.VariableIcon);
            }
            else { }
        }

        private void TSB_BETWEEN_II_Click(object sender, EventArgs e)
        {
            SetupANewModule("BETWEEN II", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Between_Inclusive_Inclusive);
        }

        private void TSB_BETWEEN_EE_Click(object sender, EventArgs e)
        {
            SetupANewModule("BETWEEN EE", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Between_Exclusive_Exclusive);
        }

        private void TSB_BETWEEN_EI_Click(object sender, EventArgs e)
        {
            SetupANewModule("BETWEEN EI", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Between_Exclusive_Inclusive);
        }

        private void TSB_BETWEEN_IE_Click(object sender, EventArgs e)
        {
            SetupANewModule("BETWEEN IE", global::FCC_Uber_MDX_Configurator.Properties.Resources.Text_Between_Inclusive_Exclusive);
        }
        #endregion

        #region Switch to Text Mode
        private void TSB_TEXTBASED_Click(object sender, EventArgs e)
        {
            foreach (LogicModules.Module _mod in _CurrentFunction._Modules)
            {
                foreach (LogicModules.Node _node in _mod.Input_Nodes)
                {
                    if (!_node.isConnected())
                    {
                        (new ErrorForm("Unconnected Nodes", "There are unconnected nodes in your logic diagram. Every node must be connected. If you want the unconnected node to be an input, place an input module and connect it.\r\n\r\n" +
                            "The first node found that was not connected: " + _node.NodeName)).ShowDialog();
                        return;
                    }
                }
            }
            if (MakeSureThereIsOnlyOneOutput())
            {
                (new ErrorForm("No Output Node", "There is no output node specified. You must specify 1 output node.")).ShowDialog();
                return;
            }
            SPLIT_DESIGNER.Panel2Collapsed = true;
            SPLIT_DESIGNER.Panel1Collapsed = false;
            UpdateXML();
        }
        #endregion

        #region Switch to Graphics Mode
        private void TSB_GRAPHICS_Click(object sender, EventArgs e)
        {
            SPLIT_DESIGNER.Panel2Collapsed = false;
            SPLIT_DESIGNER.Panel1Collapsed = true;
        }
        #endregion

        #region Form Closing
        private void CustomFunctionForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            DialogResult DR = DialogResult.Cancel;
            if (_CurrentFunction._Modules.Count > 0)
            {
                if (!isSavedandNotChanged)
                {
                    DR = WouldYouLikeToSaveFirst();
                }
                else
                {
                    DR = DialogResult.OK;
                }
            }
            else
            {
                DR = DialogResult.Abort;
            }
            if (DR == DialogResult.OK)
            {
                if (VerifyNoEmptyNodes(null))
                {
                    AllFunctionsDirectoryWatcher.EnableRaisingEvents = false;
                    SaveFunction();
                }
                else
                {
                    (new ErrorForm("Function Not Saved", "There are unconnected nodes, making this function unsaveable. To delete functions, right click the module, and choose delete.")).ShowDialog();
                    e.Cancel = true;
                    this.DialogResult = DialogResult.None;
                    return;
                }
            }
            else if (DR == DialogResult.Abort)
            {
                AllFunctionsDirectoryWatcher.EnableRaisingEvents = false;
            }
            else
            {
                e.Cancel = true;
                return;
            }
        }
        #endregion

        #region Save First Confirmation
        public DialogResult WouldYouLikeToSaveFirst()
        {
            return (new ConfirmDialogForm("Save Before Close?", "Save Before Close", "Would you like to save your current configuration before exiting?")).ShowDialog();
        }
        #endregion

        #region Save Function
        public void SaveFunction()
        {
            string toSave = UpdateXML();
            string toSaveDesigner = SaveDesignerInfo();
            if (toSave == "" || toSaveDesigner == "")
            {
                (new ErrorForm("Nothing Saved", "The Function is incomplete, nothing was saved.")).ShowDialog();
                this.DialogResult = DialogResult.None;
                return;
            }
            isSavedandNotChanged = true;
            if (isEditingRootNode)
            {
                this.DialogResult = DialogResult.OK;
                return;
            }
            try
            {
                string _savePath = Application.StartupPath + "\\functions\\" + _CurrentFunction._FunctionID + ".xml";
                if (!Directory.Exists(GlobalStaticClass.FUNCTION_DIRECTORY))
                {
                    Directory.CreateDirectory(GlobalStaticClass.FUNCTION_DIRECTORY);
                }
                if (File.Exists(_savePath))
                {
                    FileInfo _fileInfo = new FileInfo(Application.StartupPath + "\\functions\\" + _CurrentFunction._FunctionID + ".xml");
                    if ((new ConfirmDialogForm("Overwrite Custom Function?", "Overwrite File?", "There already exists a function with this ID created on " + _fileInfo.LastWriteTime.ToLongDateString() + " at " + _fileInfo.LastWriteTime.ToLongTimeString() + ".\r\nOverwrite File?")).ShowDialog() != DialogResult.OK)
                    {
                        return;
                    }
                }
                FileStream fs = new FileStream(_savePath, FileMode.Create, FileAccess.Write);
                StreamWriter sw = new StreamWriter(fs);
                sw.Write(toSave);
                sw.Close();
                fs.Close();
                fs = new FileStream(Application.StartupPath + "\\functions\\" + _CurrentFunction._FunctionID + ".designer", FileMode.Create, FileAccess.Write);
                sw = new StreamWriter(fs);
                sw.Write(toSaveDesigner);
                sw.Close();
                fs.Close();
                (new FinishedSavingForm()).Show();
            }
            catch (Exception e)
            {
                (new ErrorForm("Unknown Error", "There was an unknown error thrown when saving this function:\r\n" + e.ToString())).ShowDialog();
                return;
            }
        }
        #endregion

        #region Save Designer Information
        public string SaveDesignerInfo()
        {
            string _XML = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\r\n<function_designer>";
            foreach (LogicModules.Module _mod in _CurrentFunction._Modules)
            {
                _XML += "\r\n  <module type=\"" + _mod.id + "\" location=\"" + _mod.ModuleLocation.X.ToString() + "," + _mod.ModuleLocation.Y.ToString() + "\"";
                switch (_mod.id)
                {
                    case "NUMBER":
                        _XML += " number_value=\"" + ((LogicModules.LogicModule_Number)_mod).NumberValue.ToString() + "\">";
                        break;
                    case "INPUT":
                        _XML += " input_reference_id=\"" + ((LogicModules.LogicModule_INPUT)_mod).referenceID + "\">";
                        break;
                    case "DIGITALOUTPUT":
                        _XML += " digital_output_reference_id=\"" + ((LogicModules.LogicModule_DIGITALOUTPUT)_mod).referenceID + "\">";
                        break;
                    case "ANALOGUEINPUT":
                        _XML += " analogue_input_reference_id=\"" + ((LogicModules.LogicModule_ANALOGUEINPUT)_mod).referenceID + "\">";
                        break;
                    case "VARIABLE":
                        _XML += " variable_reference_id=\"" + ((LogicModules.LogicModule_VARIABLE)_mod).referenceID + "\"";
                        _XML += " variable_get_or_set=\"" + ((LogicModules.LogicModule_VARIABLE)_mod).getOrSet + "\">";
                        break;
                    default:
                        _XML += ">";
                        break;
                }
                for(int i = 0; i < _mod.Output_Nodes.Count; i++)
                {
                    LogicModules.Node _node = _mod.Output_Nodes[i];
                    if (_node.isConnected())
                    {
                        int _mod_index = _CurrentFunction._Modules.IndexOf(_node.LinkTo.Link_Module);
                        int _node_index = _CurrentFunction._Modules[_mod_index].Input_Nodes.IndexOf(_node.LinkTo.Link_Node);
                        _XML += "\r\n    <link from_node=\"" + i.ToString() +"\" module=\"" + _mod_index.ToString() + "\" node=\"" + _node_index.ToString() + "\"></link>";
                    }
                }
                
                _XML += "\r\n  </module>";
            }
            _XML += "\r\n</function_designer>";
            return _XML;
        }
        #endregion

        #region New Function Icon Clicked
        private void TSB_NEW_Click(object sender, EventArgs e)
        {
            DialogResult DR = WouldYouLikeToSaveFirst();
            if (DR == DialogResult.OK)
            {
                SaveFunction();
                PrepareNewFunction();
            }
            else if (DR == DialogResult.Abort)
            {
                PrepareNewFunction();
            }
            else
            {
                return;
            }
        }
        #endregion

        #region Prepare New Function
        public void PrepareNewFunction()
        {
            _CurrentFunction = new LogicModules.FunctionMDX();
            isAdding = null;
            string_CustomFunctionDropDown = null;
            string_DropDownItem = null;
            ModuleNoGood = new List<Rectangle>();
            LastCursorBeforeHand = Cursors.Arrow;
            isMoving = null;
            AllowDropOfObject = true;
            HoveringModule = null;
            isConnecting = null;
        }
        #endregion

        private void BTN_TIMER_Click(object sender, EventArgs e)
        {
            LogicItemPropertyForm _tempWTF = new LogicItemPropertyForm(_CurrentFunction._timerID, _CurrentFunction._TimeInbetween);
            if (_tempWTF.ShowDialog() == DialogResult.OK)
            {
                string _tempReturned = _tempWTF.GetBackTheTimer();
                if (_tempReturned != null)
                {
                    _CurrentFunction._timerID = _tempReturned;
                    _CurrentFunction._TimeInbetween = _tempWTF.GetBackTheDeltaTime();
                    UpdateThisFunction();
                }
            }
            this.DialogResult = DialogResult.None;
        }

        private void TSB_ThenIcon_Click(object sender, EventArgs e)
        {
            ThenDoForm _tempThenDo = new ThenDoForm(_CurrentFunction._ThenList);
            if (_tempThenDo.ShowDialog() == DialogResult.OK)
            {
                _CurrentFunction._ThenList = _tempThenDo._CurrentDoThenList;
            }
        }

        private void TSB_AntiThenIcon_Click(object sender, EventArgs e)
        {
            ThenDoForm _tempThenDo = new ThenDoForm(_CurrentFunction._AntiThenList);
            if (_tempThenDo.ShowDialog() == DialogResult.OK)
            {
                _CurrentFunction._AntiThenList = _tempThenDo._CurrentDoThenList;
            }
        }

        private void TSB_SHOWTEXTTOGGLE_Click(object sender, EventArgs e)
        {
            showTextValues = !showTextValues;
            UpdateThisFunction();
        }

        private void TSBDROP_ADD_PREMADE_FUNCTION_Click(object sender, EventArgs e)
        {
            TSBDROP_ADD_PREMADE_FUNCTION.ShowDropDown();
        }

        private void TSBDROP_BOOLEAN_ButtonClick(object sender, EventArgs e)
        {
            TSBDROP_BOOLEAN.ShowDropDown();
        }

        private void TSBDROP_NUMERICOPERATIONS_Click(object sender, EventArgs e)
        {
            TSBDROP_NUMERICOPERATIONS.ShowDropDown();
        }

        private void TSBDROP_COMPARATIVEMODULES_Click(object sender, EventArgs e)
        {
            TSBDROP_COMPARATIVEMODULES.ShowDropDown();
        }

        private void TSB_DigitalOutput_ButtonClick(object sender, EventArgs e)
        {
            TSB_DigitalOutput.ShowDropDown();
        }

        private void TSB_AddAnalogue_ButtonClick(object sender, EventArgs e)
        {
            TSB_AddAnalogue.ShowDropDown();
        }

        private void TSB_Variable_ButtonClick(object sender, EventArgs e)
        {
            TSB_Variable.ShowDropDown();
        }
    }
}