CircuitOnline/public/js/logix.js

// Size of canvas
var width;
var height;
var listenToSimulator=true; //enables key down listener on the simulator

var createNode=false //Flag to create node when its value ==true
var stopWire=true //flag for stopoing making Nodes when the second terminal reaches a Node (closed path)

uniqueIdCounter = 0; // To be deprecated
unit = 10; // size of each division/ not used everywhere, to be deprecated

wireToBeChecked = 0; // when node disconnects from another node
willBeUpdated = false; // scheduleUpdate() will be called if true
objectSelection = false; // Flag for object selection
errorDetected = false; // Flag for error detection

prevErrorMessage = undefined; // Global variable for error messages
prevShowMessage = undefined; // Global variable for error messages

updatePosition = true; // Flag for updating position
updateSimulation = true; // Flag for updating simulation
updateCanvas = true; // Flag for rendering

gridUpdate = true; // Flag for updating grid
updateSubcircuit = true; // Flag for updating subCircuits

loading = false; // Flag - all assets are loaded

DPR = 1; // devicePixelRatio, 2 for retina displays, 1 for low resolution displays

projectSaved = true; // Flag for project saved or not

lightMode = false; // To be deprecated

layoutMode = false; // Flag for mode

forceResetNodes = true; // FLag to reset all Nodes




//Exact same name as object constructor
//This list needs to be updated when new circuitselements are created


function setupElementLists() {

    $('#menu').empty();

    window.circuitElementList = metadata.circuitElementList;
    window.annotationList = metadata.annotationList;
    window.inputList = metadata.inputList;
    window.subCircuitInputList = metadata.subCircuitInputList;
    window.moduleList = [...circuitElementList, ...annotationList]
    window.updateOrder = ["wires", ...circuitElementList, "nodes", ...annotationList]; // Order of update
    window.renderOrder = [...(moduleList.slice().reverse()), "wires", "allNodes"]; // Order of render


    function createIcon(element) {
        return `<div class="icon logixModules pointerCursor" id="${element}" >
            <img src= "/img/${element}.svg" >
            <p class="img__description">${element}</p>
        </div>`;
    }

    let elementHierarchy = metadata.elementHierarchy;
    for (category in elementHierarchy) {
        let htmlIcons = '';

        let categoryData = elementHierarchy[category];

        for (let i = 0; i < categoryData.length; i++) {
            let element = categoryData[i];
            htmlIcons += createIcon(element);
        }

        let accordionData = `<div class="panelHeader">${category}</div>
            <div class="panel" style="overflow-y:hidden;">
              ${htmlIcons}
            </div>`;

        $('#menu').append(accordionData);

    }


}

// setupElementLists()


// circuitElementList = [
//     "Input", "Output", "NotGate", "OrGate", "AndGate", "NorGate", "NandGate", "XorGate", "XnorGate", "SevenSegDisplay", "SixteenSegDisplay", "HexDisplay",
//     "Multiplexer", "BitSelector", "Splitter", "Power", "Ground", "ConstantVal", "ControlledInverter", "TriState", "Adder", "Rom", "RAM", "EEPROM", "TflipFlop",
//     "JKflipFlop", "SRflipFlop", "DflipFlop", "TTY", "Keyboard", "Clock", "DigitalLed", "Stepper", "VariableLed", "RGBLed", "SquareRGBLed", "RGBLedMatrix", "Button", "Demultiplexer",
//     "Buffer", "SubCircuit", "Flag", "MSB", "LSB", "PriorityEncoder", "Tunnel", "ALU", "Decoder", "Random", "Counter", "Dlatch", "TB_Input", "TB_Output", "ForceGate",
// ];

// annotationList = ["Text", "Rectangle", "Arrow"]

// moduleList = [...circuitElementList, ...annotationList]
// updateOrder = ["wires", ...circuitElementList, "nodes", ...annotationList]; // Order of update
// renderOrder = [...(moduleList.slice().reverse()), "wires", "allNodes"]; // Order of render

// // Exact same name as object constructor
// // All the combinational modules which give rise to an value(independently)

// inputList = ["Random","Buffer", "Stepper", "Ground", "Power", "ConstantVal", "Input", "Clock", "Button","Dlatch","JKflipFlop","TflipFlop","SRflipFlop","DflipFlop"];
// subCircuitInputList=["Clock", "Button","Buffer", "Stepper", "Ground", "Power", "ConstantVal","Dlatch","JKflipFlop","TflipFlop","SRflipFlop","DflipFlop"]

// inputList = ["Random", "Dlatch", "JKflipFlop", "TflipFlop", "SRflipFlop", "DflipFlop", "Buffer", "Stepper", "Ground", "Power", "ConstantVal", "Input", "Clock", "Button", "Counter"];
// subCircuitInputList = ["Random", "Dlatch", "JKflipFlop", "TflipFlop", "SRflipFlop", "DflipFlop", "Buffer", "Stepper", "Ground", "Power", "ConstantVal", "Clock", "Button", "Counter"];

//Scope object for each circuit level, globalScope for outer level
scopeList = {};


// Helper function to show error
function showError(error) {
    errorDetected = true;
    if (error == prevErrorMessage) return;
    prevErrorMessage = error;
    var id = Math.floor(Math.random() * 10000);
    $('#MessageDiv').append("<div class='alert alert-danger' role='alert' id='" + id + "'> " + error + "</div>");
    setTimeout(function() {
        prevErrorMessage = undefined;
        $('#' + id).fadeOut();
    }, 1500);
}

function showRestricted() {
    $('#restrictedDiv').removeClass("display--none");
    // Show no help text for restricted elements
    $("#Help").removeClass("show");
    $('#restrictedDiv').html("The element has been restricted by mentor. Usage might lead to deduction in marks");
}

function hideRestricted() {
    $('#restrictedDiv').addClass("display--none");
}

function updateRestrictedElementsList() {
    if (restrictedElements.length === 0) return;

    const restrictedCircuitElementsUsed = globalScope.restrictedCircuitElementsUsed;
    let restrictedStr = "";

    restrictedCircuitElementsUsed.forEach((element) => {
        restrictedStr += `${element}, `;
    });

    if (restrictedStr === "") {
        restrictedStr = "None";
    } else {
        restrictedStr = restrictedStr.slice(0, -2);
    }

    $("#restrictedElementsDiv--list").html(restrictedStr);
}


function updateRestrictedElementsInScope(scope = globalScope) {
    // Do nothing if no restricted elements
    if (restrictedElements.length === 0) return;

    let restrictedElementsUsed = [];
    restrictedElements.forEach((element) => {
        if (scope[element].length > 0) {
            restrictedElementsUsed.push(element);
        }
    });

    scope.restrictedCircuitElementsUsed = restrictedElementsUsed;
    updateRestrictedElementsList();
}

// Helper function to show message
function showMessage(mes) {
    if (mes == prevShowMessage) return;
    prevShowMessage = mes
    var id = Math.floor(Math.random() * 10000);
    $('#MessageDiv').append("<div class='alert alert-success' role='alert' id='" + id + "'> " + mes + "</div>");
    setTimeout(function() {
        prevShowMessage = undefined;
        $('#' + id).fadeOut()
    }, 2500);
}

// Helper function to open a new tab
function openInNewTab(url) {
    var win = window.open(url, '_blank');
    win.focus();
}

// Following function need to be improved - remove mutability etc
//fn to remove elem in array
Array.prototype.clean = function(deleteValue) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] == deleteValue) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
};

// Following function need to be improved
Array.prototype.extend = function(other_array) {
    /* you should include a test to check whether other_array really is an array */
    other_array.forEach(function(v) {
        this.push(v)
    }, this);
}

// Following function need to be improved
//fn to check if an elem is in an array
Array.prototype.contains = function(value) {
    return this.indexOf(value) > -1
};

// Helper function to return unique list
function uniq(a) {
    var seen = {};
    return a.filter(function(item) {
        return seen.hasOwnProperty(item) ? false : (seen[item] = true);
    });
}

// Currently Focussed circuit/scope
globalScope = undefined;

// Base circuit class
// All circuits are stored in a scope

function Scope(name = "localScope", id = undefined) {
    this.restrictedCircuitElementsUsed = [];
    this.id = id || Math.floor((Math.random() * 100000000000) + 1);
    this.CircuitElement = [];

    //root object for referring to main canvas - intermediate node uses this
    this.root = new CircuitElement(0, 0, this, "RIGHT", 1);
    this.backups = [];
    this.timeStamp = new Date().getTime();

    this.ox = 0;
    this.oy = 0;
    this.scale = DPR;
    this.tunnelList = {};
    this.stack = []

    this.name = name;
    this.pending = []
    this.nodes = []; //intermediate nodes only
    this.allNodes = [];
    this.wires = [];

    // Creating arrays for other module elements
    for (var i = 0; i < moduleList.length; i++) {
        this[moduleList[i]] = [];
    }

    // Setting default layout
    this.layout = { // default position
        width: 100,
        height: 40,
        title_x: 50,
        title_y: 13,
        titleEnabled: true,
    }


    // FOR SOME UNKNOWN REASON, MAKING THE COPY OF THE LIST COMMON
    // TO ALL SCOPES EITHER BY PROTOTYPE OR JUST BY REFERNCE IS CAUSING ISSUES
    // The issue comes regarding copy/paste operation, after 5-6 operations it becomes slow for unknown reasons
    // CHANGE/ REMOVE WITH CAUTION
    // this.objects = ["wires", ...circuitElementList, "nodes", ...annotationList];
    // this.renderObjectOrder = [ ...(moduleList.slice().reverse()), "wires", "allNodes"];
}

// Resets all nodes recursively
Scope.prototype.reset = function() {
    for (var i = 0; i < this.allNodes.length; i++)
        this.allNodes[i].reset();
    for (var i = 0; i < this.Splitter.length; i++) {
        this.Splitter[i].reset();
    }
    for (var i = 0; i < this.SubCircuit.length; i++) {
        this.SubCircuit[i].reset();
    }

}

// Adds all inputs to simulationQueue
Scope.prototype.addInputs = function() {
    for (var i = 0; i < inputList.length; i++) {
        for (var j = 0; j < this[inputList[i]].length; j++) {
            simulationArea.simulationQueue.add(this[inputList[i]][j], 0);
        }
    }

    for (let j = 0; j < this.SubCircuit.length; j++)
        this.SubCircuit[j].addInputs();

}

// Ticks clocks recursively -- needs to be deprecated and synchronize all clocks with a global clock
Scope.prototype.clockTick = function() {
    for (var i = 0; i < this.Clock.length; i++)
        this.Clock[i].toggleState(); //tick clock!
    for (var i = 0; i < this.SubCircuit.length; i++)
        this.SubCircuit[i].localScope.clockTick(); //tick clock!
}

// Checks if this circuit contains directly or indirectly scope with id
// Recursive nature
Scope.prototype.checkDependency = function(id) {
    if (id == this.id) return true;
    for (var i = 0; i < this.SubCircuit.length; i++)
        if (this.SubCircuit[i].id == id) return true;

    for (var i = 0; i < this.SubCircuit.length; i++)
        if (scopeList[this.SubCircuit[i].id].checkDependency(id)) return true;

    return false
}

// Get dependency list - list of all circuits, this circuit depends on
Scope.prototype.getDependencies = function() {
    var list = []
    for (var i = 0; i < this.SubCircuit.length; i++) {
        list.push(this.SubCircuit[i].id);
        list.extend(scopeList[this.SubCircuit[i].id].getDependencies());
    }
    return uniq(list);
}

// helper function to reduce layout size
Scope.prototype.fixLayout = function() {
    var max_y = 20;
    for (var i = 0; i < this.Input.length; i++)
        max_y = Math.max(this.Input[i].layoutProperties.y, max_y)
    for (var i = 0; i < this.Output.length; i++)
        max_y = Math.max(this.Output[i].layoutProperties.y, max_y)
    if (max_y != this.layout.height)
        this.layout.height = max_y + 10;
}

// Function which centers the circuit to the correct zoom level
Scope.prototype.centerFocus = function(zoomIn = true) {
    if (layoutMode) return;
    findDimensions(this);
    var minX = simulationArea.minWidth || 0;
    var minY = simulationArea.minHeight || 0;
    var maxX = simulationArea.maxWidth || 0;
    var maxY = simulationArea.maxHeight || 0;

    var reqWidth = maxX - minX + 150;
    var reqHeight = maxY - minY + 150;

    this.scale = Math.min(width / reqWidth, height / reqHeight)

    if (!zoomIn)
        this.scale = Math.min(this.scale, DPR);
    this.scale = Math.max(this.scale, DPR / 10);

    this.ox = (-minX) * this.scale + (width - (maxX - minX) * this.scale) / 2;
    this.oy = (-minY) * this.scale + (height - (maxY - minY) * this.scale) / 2;
}

//fn to setup environment
function setupEnvironment() {

    projectId = generateId();
    updateSimulation = true;
    DPR = window.devicePixelRatio || 1;
    newCircuit("Main");

    data = {}
    resetup();
}


function setup() {

    setupElementLists();
    setupEnvironment();
    if (!embed)
        setupUI();
    startListeners();

    // Load project data after 1 second - needs to be improved, delay needs to be eliminated
    setTimeout(function() {
        if (logix_project_id != 0) {
            $('.loadingIcon').fadeIn();
            $.ajax({
                url: '/simulator/get_data',
                type: 'POST',
                beforeSend: function(xhr) {
                    xhr.setRequestHeader('X-CSRF-Token', $('meta[name="csrf-token"]').attr('content'))
                },
                data: {
                    "id": logix_project_id
                },
                success: function(response) {
                    data = (response);

                    if (data) {
                        load(data);
                        simulationArea.changeClockTime(data["timePeriod"] || 500);
                    }
                    $('.loadingIcon').fadeOut();
                },
                failure: function() {
                    alert("Error: could not load ");
                    $('.loadingIcon').fadeOut();
                }
            });

        }

        // Restore unsaved data and save
        else if (localStorage.getItem("recover_login") && userSignedIn) {
            var data = JSON.parse(localStorage.getItem("recover_login"));
            load(data);
            localStorage.removeItem("recover");
            localStorage.removeItem("recover_login");
            save();
        }

        // Restore unsaved data which didn't get saved due to error
        else if (localStorage.getItem("recover")) {
            showMessage("We have detected that you did not save your last work. Don't worry we have recovered them. Access them using Project->Recover")
        }
    }, 1000);


}

// Helper function to recover unsaved data
function recoverProject() {
    if (localStorage.getItem("recover")) {
        var data = JSON.parse(localStorage.getItem("recover"));
        if (confirm("Would you like to recover: " + data.name)) {
            load(data);
        }
        localStorage.removeItem("recover");
    } else {
        showError("No recover project found")
    }
}

// Toggle light mode
function changeLightMode(val) {
    if (!val && lightMode) {
        lightMode = false;
        DPR = window.devicePixelRatio || 1;
        globalScope.scale *= DPR;
    } else if (val && !lightMode) {
        lightMode = true;
        globalScope.scale /= DPR;
        DPR = 1
        $('#miniMap').fadeOut('fast');
    }
    resetup();
}

//to resize window and setup things
function resetup() {

    DPR = window.devicePixelRatio || 1;
    if (lightMode)
        DPR = 1;
    width = document.getElementById("simulationArea").clientWidth * DPR;
    if (!embed) {
        height = (document.getElementById("simulation").clientHeight - document.getElementById("toolbar").clientHeight) * DPR;
    } else {
        height = (document.getElementById("simulation").clientHeight) * DPR;
    }

    //setup simulationArea
    backgroundArea.setup();
    if (!embed) plotArea.setup();
    simulationArea.setup();

    // update();
    dots();

    document.getElementById("backgroundArea").style.height = height / DPR + 100;
    document.getElementById("backgroundArea").style.width = width / DPR + 100;
    document.getElementById("canvasArea").style.height = height / DPR;
    simulationArea.canvas.width = width;
    simulationArea.canvas.height = height;
    backgroundArea.canvas.width = width + 100 * DPR;
    backgroundArea.canvas.height = height + 100 * DPR;
    if (!embed) {
        plotArea.c.width = document.getElementById("plot").clientWidth;
        plotArea.c.height = document.getElementById("plot").clientHeight
    }

    updateCanvas = true;
    update(); // INEFFICIENT, needs to be deprecated
    simulationArea.prevScale = 0;
    dots(true, false);
}

window.onresize = resetup; // listener
window.onorientationchange = resetup; // listener

//for mobiles
window.addEventListener('orientationchange', resetup); // listener

// Object that holds data and objects of grid canvas
var backgroundArea = {
    canvas: document.getElementById("backgroundArea"),
    setup: function() {
        this.canvas.width = width;
        this.canvas.height = height;
        this.context = this.canvas.getContext("2d");
        dots(true, false);
    },
    clear: function() {
        if (!this.context) return;
        this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
    }
}


//simulation environment object - holds simulation canvas
var simulationArea = {
    canvas: document.getElementById("simulationArea"),
    selected: false,
    hover: false,
    clockState: 0,
    clockEnabled: true,
    lastSelected: undefined,
    stack: [],
    prevScale: 0,
    oldx: 0,
    oldy: 0,
    objectList: [],
    maxHeight: 0,
    maxWidth: 0,
    minHeight: 0,
    minWidth: 0,
    multipleObjectSelections: [],
    copyList: [],
    shiftDown: false,
    controlDown: false,
    timePeriod: 500,
    mouseX: 0,
    mouseY: 0,
    mouseDownX: 0,
    mouseDownY: 0,
    simulationQueue: undefined,

    clickCount: 0, //double click
    lock: "unlocked",
    timer: function() {
        ckickTimer = setTimeout(function() {
            simulationArea.clickCount = 0;
        }, 600);
    },

    setup: function() {
        this.canvas.width = width;
        this.canvas.height = height;
        this.simulationQueue = new EventQueue(10000);
        this.context = this.canvas.getContext("2d");
        simulationArea.changeClockTime(simulationArea.timePeriod)
        this.mouseDown = false;
    },
    changeClockTime: function(t) {
        if (t < 50) return;
        clearInterval(simulationArea.ClockInterval);
        t = t || prompt("Enter Time Period:");
        simulationArea.timePeriod = t;
        simulationArea.ClockInterval = setInterval(clockTick, t);
    },
    clear: function() {
        if (!this.context) return;
        this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
    }
}
changeClockTime = simulationArea.changeClockTime

// Kept for archival purposes - needs to be removed
//
// function copyPaste(copyList) {
//     if(copyList.length==0)return;
//     tempScope = new Scope(globalScope.name,globalScope.id);
//     var oldOx=globalScope.ox;
//     var oldOy=globalScope.oy;
//     var oldScale=globalScope.scale;
//     d = backUp(globalScope);
//     loadScope(tempScope, d);
//     scopeList[tempScope.id]=tempScope;
//     tempScope.backups=globalScope.backups;
//     for (var i = 0; i < updateOrder.length; i++){
//         var prevLength=globalScope[updateOrder[i]].length; // LOL length of list will reduce automatically when deletion starts
//         // if(globalScope[updateOrder[i]].length)////console.log("deleting, ",globalScope[updateOrder[i]]);
//         for (var j = 0; j < globalScope[updateOrder[i]].length; j++) {
//             var obj = globalScope[updateOrder[i]][j];
//             if (obj.objectType != 'Wire') { //}&&obj.objectType!='CircuitElement'){//}&&(obj.objectType!='Node'||obj.type==2)){
//                 if (!copyList.contains(globalScope[updateOrder[i]][j])) {
//                     ////console.log("DELETE:", globalScope[updateOrder[i]][j]);
//                     globalScope[updateOrder[i]][j].cleanDelete();
//                 }
//             }
//
//             if(globalScope[updateOrder[i]].length!=prevLength){
//                 prevLength--;
//                 j--;
//             }
//         }
//     }
//
//     // updateSimulation = true;
//     // update(globalScope);
//     ////console.log("DEBUG1",globalScope.wires.length)
//     var prevLength=globalScope.wires.length;
//     for (var i = 0; i < globalScope.wires.length; i++) {
//         globalScope.wires[i].checkConnections();
//         if(globalScope.wires.length!=prevLength){
//             prevLength--;
//             i--;
//         }
//     }
//     ////console.log(globalScope.wires,globalScope.allNodes)
//     ////console.log("DEBUG2",globalScope.wires.length)
//     // update(globalScope);
//     // ////console.log(globalScope.wires.length)
//
//     var approxX=0;
//     var approxY=0;
//     for (var i = 0; i < copyList.length; i++) {
//         approxX+=copyList[i].x;
//         approxY+=copyList[i].y;
//     }
//     approxX/=copyList.length;
//     approxY/=copyList.length;
//
//     approxX=Math.round(approxX/10)*10
//     approxY=Math.round(approxY/10)*10
//     for (var i = 0; i < updateOrder.length; i++)
//         for (var j = 0; j < globalScope[updateOrder[i]].length; j++) {
//             var obj = globalScope[updateOrder[i]][j];
//             obj.updateScope(tempScope);
//         }
//
//
//     for (var i = 0; i < copyList.length; i++) {
//         // ////console.log(copyList[i]);
//         copyList[i].x += simulationArea.mouseX-approxX;
//         copyList[i].y += simulationArea.mouseY-approxY;
//
//     }
//
//
//     // for (var i = 0; i < globalScope.wires.length; i++) {
//     //     globalScope.wires[i].updateScope(tempScope);
//     // }
//
//     for (l in globalScope) {
//         if (globalScope[l] instanceof Array && l != "objects") {
//             tempScope[l].extend(globalScope[l]);
//             // ////console.log("Copying , ",l);
//         }
//     }
//
//     // update(tempScope);
//
//
//     simulationArea.multipleObjectSelections = [];//copyList.slice();
//     simulationArea.copyList = [];//copyList.slice();
//     canvasUpdate=true;
//     updateSimulation = true;
//     globalScope = tempScope;
//     scheduleUpdate();
//     globalScope.ox=oldOx;
//     globalScope.oy=oldOy;
//     globalScope.scale=oldScale;
//
// // }

// paste function
function paste(copyData) {

    if (copyData == undefined) return;
    var data = JSON.parse(copyData);
    if (!data["logixClipBoardData"]) return;

    var currentScopeId = globalScope.id;
    for (var i = 0; i < data.scopes.length; i++) {
        if (scopeList[data.scopes[i].id] == undefined) {
            var scope = newCircuit(data.scopes[i].name, data.scopes[i].id);
            loadScope(scope, data.scopes[i]);
            scopeList[data.scopes[i].id] = scope;
        }
    }

    switchCircuit(currentScopeId);
    var tempScope = new Scope(globalScope.name, globalScope.id);
    var oldOx = globalScope.ox;
    var oldOy = globalScope.oy;
    var oldScale = globalScope.scale;
    loadScope(tempScope, data);

    var prevLength = tempScope.allNodes.length
    for (var i = 0; i < tempScope.allNodes.length; i++) {
        tempScope.allNodes[i].checkDeleted();
        if (tempScope.allNodes.length != prevLength) {
            prevLength--;
            i--;
        }
    }

    var approxX = 0;
    var approxY = 0;
    var count = 0

    for (var i = 0; i < updateOrder.length; i++) {
        for (var j = 0; j < tempScope[updateOrder[i]].length; j++) {
            var obj = tempScope[updateOrder[i]][j];
            obj.updateScope(globalScope);
            if (obj.objectType != "Wire") {
                approxX += obj.x;
                approxY += obj.y;
                count++;
            }
        }
    }

    for (var j = 0; j < tempScope.CircuitElement.length; j++) {
        var obj = tempScope.CircuitElement[j]
        obj.updateScope(globalScope);
    }

    approxX /= count
    approxY /= count

    approxX = Math.round(approxX / 10) * 10
    approxY = Math.round(approxY / 10) * 10


    for (var i = 0; i < updateOrder.length; i++) {
        for (var j = 0; j < tempScope[updateOrder[i]].length; j++) {
            var obj = tempScope[updateOrder[i]][j];
            if (obj.objectType != "Wire") {
                obj.x += simulationArea.mouseX - approxX;
                obj.y += simulationArea.mouseY - approxY;
            }
        }
    }

    for (l in tempScope) {
        if (tempScope[l] instanceof Array && l != "objects" && l != "CircuitElement") {
            globalScope[l].extend(tempScope[l]);
        }
    }
    for (var i = 0; i < tempScope.Input.length; i++) {
        tempScope.Input[i].layoutProperties.y = get_next_position(0, globalScope);
        tempScope.Input[i].layoutProperties.id = generateId();
    }
    for (var i = 0; i < tempScope.Output.length; i++) {
        tempScope.Output[i].layoutProperties.x = globalScope.layout.width;
        tempScope.Output[i].layoutProperties.id = generateId();
        tempScope.Output[i].layoutProperties.y = get_next_position(globalScope.layout.width, globalScope);
    }

    canvasUpdate = true;
    updateSimulation = true;
    updateSubcircuit = true;
    scheduleUpdate();
    globalScope.ox = oldOx;
    globalScope.oy = oldOy;
    globalScope.scale = oldScale;


    forceResetNodes = true
}

function cut(copyList) {
    if (copyList.length == 0) return;
    var tempScope = new Scope(globalScope.name, globalScope.id);
    var oldOx = globalScope.ox;
    var oldOy = globalScope.oy;
    var oldScale = globalScope.scale;
    d = backUp(globalScope);
    loadScope(tempScope, d);
    scopeList[tempScope.id] = tempScope;

    for (var i = 0; i < copyList.length; i++) {
        var obj = copyList[i];
        if (obj.objectType == "Node") obj.objectType = "allNodes"
        for (var j = 0; j < tempScope[obj.objectType].length; j++) {
            if (tempScope[obj.objectType][j].x == obj.x && tempScope[obj.objectType][j].y == obj.y && (obj.objectType != "Node" || obj.type == 2)) {
                tempScope[obj.objectType][j].delete();
                break;
            }

        }
    }
    tempScope.backups = globalScope.backups;
    for (var i = 0; i < updateOrder.length; i++) {
        var prevLength = globalScope[updateOrder[i]].length; // LOL length of list will reduce automatically when deletion starts
        for (var j = 0; j < globalScope[updateOrder[i]].length; j++) {
            var obj = globalScope[updateOrder[i]][j];
            if (obj.objectType != 'Wire') { //}&&obj.objectType!='CircuitElement'){//}&&(obj.objectType!='Node'||obj.type==2)){
                if (!copyList.contains(globalScope[updateOrder[i]][j])) {
                    globalScope[updateOrder[i]][j].cleanDelete();
                }
            }

            if (globalScope[updateOrder[i]].length != prevLength) {
                prevLength--;
                j--;
            }
        }
    }

    var prevLength = globalScope.wires.length;
    for (var i = 0; i < globalScope.wires.length; i++) {
        globalScope.wires[i].checkConnections();
        if (globalScope.wires.length != prevLength) {
            prevLength--;
            i--;
        }
    }

    updateSimulation = true;

    var data = backUp(globalScope);
    data['logixClipBoardData'] = true;
    var dependencyList = globalScope.getDependencies();
    data["dependencies"] = {};
    for (dependency in dependencyList)
        data.dependencies[dependency] = backUp(scopeList[dependency]);
    data['logixClipBoardData'] = true;
    data = JSON.stringify(data);

    simulationArea.multipleObjectSelections = []; //copyList.slice();
    simulationArea.copyList = []; //copyList.slice();
    canvasUpdate = true;
    updateSimulation = true;
    globalScope = tempScope;
    scheduleUpdate();
    globalScope.ox = oldOx;
    globalScope.oy = oldOy;
    globalScope.scale = oldScale;
    forceResetNodes = true
    return data;
}

function copy(copyList, cut = false) {

    if (copyList.length == 0) return;
    var tempScope = new Scope(globalScope.name, globalScope.id);
    var oldOx = globalScope.ox;
    var oldOy = globalScope.oy;
    var oldScale = globalScope.scale;
    var d = backUp(globalScope);

    loadScope(tempScope, d);
    scopeList[tempScope.id] = tempScope;

    if (cut) {
        for (var i = 0; i < copyList.length; i++) {
            var obj = copyList[i];
            if (obj.objectType == "Node") obj.objectType = "allNodes"
            for (var j = 0; j < tempScope[obj.objectType].length; j++) {
                if (tempScope[obj.objectType][j].x == obj.x && tempScope[obj.objectType][j].y == obj.y && (obj.objectType != "Node" || obj.type == 2)) {
                    tempScope[obj.objectType][j].delete();
                    break;
                }

            }
        }
    }
    tempScope.backups = globalScope.backups;
    for (var i = 0; i < updateOrder.length; i++) {
        var prevLength = globalScope[updateOrder[i]].length; // LOL length of list will reduce automatically when deletion starts
        for (var j = 0; j < globalScope[updateOrder[i]].length; j++) {
            var obj = globalScope[updateOrder[i]][j];
            if (obj.objectType != 'Wire') { //}&&obj.objectType!='CircuitElement'){//}&&(obj.objectType!='Node'||obj.type==2)){
                if (!copyList.contains(globalScope[updateOrder[i]][j])) {
                    ////console.log("DELETE:", globalScope[updateOrder[i]][j]);
                    globalScope[updateOrder[i]][j].cleanDelete();
                }
            }

            if (globalScope[updateOrder[i]].length != prevLength) {
                prevLength--;
                j--;
            }
        }
    }

    var prevLength = globalScope.wires.length;
    for (var i = 0; i < globalScope.wires.length; i++) {
        globalScope.wires[i].checkConnections();
        if (globalScope.wires.length != prevLength) {
            prevLength--;
            i--;
        }
    }

    updateSimulation = true;

    var data = backUp(globalScope);
    data.scopes = []
    var dependencyList = {};
    var requiredDependencies = globalScope.getDependencies();
    var completed = {};
    for (id in scopeList)
        dependencyList[id] = scopeList[id].getDependencies();

    function saveScope(id) {

        if (completed[id]) return;
        for (var i = 0; i < dependencyList[id].length; i++)
            saveScope(dependencyList[id][i]);
        completed[id] = true;
        data.scopes.push(backUp(scopeList[id]));

    }

    for (var i = 0; i < requiredDependencies.length; i++)
        saveScope(requiredDependencies[i]);

    data['logixClipBoardData'] = true;
    data = JSON.stringify(data);

    simulationArea.multipleObjectSelections = []; //copyList.slice();
    simulationArea.copyList = []; //copyList.slice();
    canvasUpdate = true;
    updateSimulation = true;
    globalScope = tempScope;
    scheduleUpdate();
    globalScope.ox = oldOx;
    globalScope.oy = oldOy;
    globalScope.scale = oldScale;
    forceResetNodes = true
    return data;
}

// Function selects all the elements from the scope
function selectAll(scope = globalScope) {
    circuitElementList.forEach((val, _, __) => {
        if (scope.hasOwnProperty(val)) {
            simulationArea.multipleObjectSelections.push(...scope[val]);
        }
    });

    if (scope.nodes) {
        simulationArea.multipleObjectSelections.push(...scope.nodes);
    }
}

// The Circuit element class serves as the abstract class for all circuit elements.
// Data Members: /* Insert Description */
// Prototype Methods:
//          - update: Used to update the state of object on mouse applicationCache
//          - isHover: Used to check if mouse is hovering over object


function CircuitElement(x, y, scope, dir, bitWidth) {
    // Data member initializations
    this.objectType = this.constructor.name;
    this.x = x;
    this.y = y;

    this.hover = false;
    if (this.x == undefined || this.y == undefined) {
        this.x = simulationArea.mouseX;
        this.y = simulationArea.mouseY;
        this.newElement = true;
        this.hover = true;
    }

    this.deleteNodesWhenDeleted = true; // FOR NOW - TO CHECK LATER

    this.nodeList = []
    this.clicked = false;

    this.oldx = x;
    this.oldy = y;

    /**
     The following attributes help in setting the touch area bound. They are the distances from the center.
     Note they are all positive distances from center. They will automatically be rotated when direction is changed.
     To stop the rotation when direction is changed, check overrideDirectionRotation attribute.
     **/
    this.leftDimensionX = 10;
    this.rightDimensionX = 10;
    this.upDimensionY = 10;
    this.downDimensionY = 10;

    this.rectangleObject = true;
    this.label = "";
    this.scope = scope;

    this.scope[this.objectType].push(this);

    this.bitWidth = bitWidth || parseInt(prompt("Enter bitWidth"), 10) || 1;
    this.direction = dir;
    this.directionFixed = false;
    this.labelDirectionFixed = false;
    this.labelDirection = oppositeDirection[dir];
    this.orientationFixed = true;
    this.fixedBitWidth = false;

    scheduleUpdate();

    this.queueProperties = {
        inQueue: false,
        time: undefined,
        index: undefined,
    }

}

CircuitElement.prototype.alwaysResolve = false
CircuitElement.prototype.propagationDelay = 100
CircuitElement.prototype.flipBits = function(val) {
    return ((~val >>> 0) << (32 - this.bitWidth)) >>> (32 - this.bitWidth);
}
CircuitElement.prototype.absX = function() {
    return this.x;
}
CircuitElement.prototype.absY = function() {
    return this.y;
}
CircuitElement.prototype.copyFrom = function(obj) {
    var properties = ["label", "labelDirection"];
    for (var i = 0; i < properties.length; i++) {
        if (obj[properties[i]] !== undefined)
            this[properties[i]] = obj[properties[i]];
    }
}

/* Methods to be Implemented for derivedClass
        saveObject(); //To generate JSON-safe data that can be loaded
        customDraw(); //This is to draw the custom design of the circuit(Optional)
        resolve(); // To execute digital logic(Optional)
        override isResolvable(); // custom logic for checking if module is ready
        override newDirection(dir) //To implement custom direction logic(Optional)
        newOrientation(dir) //To implement custom orientation logic(Optional)
    */

// Method definitions

CircuitElement.prototype.updateScope = function(scope) {
    this.scope = scope;
    for (var i = 0; i < this.nodeList.length; i++)
        this.nodeList[i].scope = scope;
}

CircuitElement.prototype.saveObject = function() {
    var data = {
        x: this.x,
        y: this.y,
        objectType: this.objectType,
        label: this.label,
        direction: this.direction,
        labelDirection: this.labelDirection,
        propagationDelay: this.propagationDelay,
        customData: this.customSave()
    }
    return data;

}
CircuitElement.prototype.customSave = function() {
    return {
        values: {},
        nodes: {},
        constructorParamaters: [],
    }
}

CircuitElement.prototype.checkHover = function() {

    if (simulationArea.mouseDown) return;
    for (var i = 0; i < this.nodeList.length; i++) {
        this.nodeList[i].checkHover();
    }
    if (!simulationArea.mouseDown) {
        if (simulationArea.hover == this) {
            this.hover = this.isHover();
            if (!this.hover) simulationArea.hover = undefined;
        } else if (!simulationArea.hover) {
            this.hover = this.isHover();
            if (this.hover) simulationArea.hover = this;
        } else {
            this.hover = false
        }
    }
}

//This sets the width and height of the element if its rectangular
// and the reference point is at the center of the object.
//width and height define the X and Y distance from the center.
//Effectively HALF the actual width and height.
// NOT OVERRIDABLE
CircuitElement.prototype.setDimensions = function(width, height) {
    this.leftDimensionX = this.rightDimensionX = width;
    this.downDimensionY = this.upDimensionY = height;
}
CircuitElement.prototype.setWidth = function(width) {
    this.leftDimensionX = this.rightDimensionX = width;
}
CircuitElement.prototype.setHeight = function(height) {
    this.downDimensionY = this.upDimensionY = height;
}

// The update method is used to change the parameters of the object on mouse click and hover.
// Return Value: true if state has changed else false
// NOT OVERRIDABLE

// When true this.isHover() will not rotate bounds. To be used when bounds are set manually.
CircuitElement.prototype.overrideDirectionRotation = false;

CircuitElement.prototype.startDragging = function() {
    this.oldx = this.x;
    this.oldy = this.y;
}
CircuitElement.prototype.drag = function() {
    this.x = this.oldx + simulationArea.mouseX - simulationArea.mouseDownX;
    this.y = this.oldy + simulationArea.mouseY - simulationArea.mouseDownY;
}
CircuitElement.prototype.update = function() {

    var update = false;

    update |= this.newElement;
    if (this.newElement) {
        if (this.centerElement) {
            this.x = Math.round((simulationArea.mouseX - (this.rightDimensionX - this.leftDimensionX) / 2) / 10) * 10;
            this.y = Math.round((simulationArea.mouseY - (this.downDimensionY - this.upDimensionY) / 2) / 10) * 10;
        } else {
            this.x = simulationArea.mouseX;
            this.y = simulationArea.mouseY;
        }

        if (simulationArea.mouseDown) {
            this.newElement = false;
            simulationArea.lastSelected = this;
        } else return;
    }

    for (var i = 0; i < this.nodeList.length; i++) {
        update |= this.nodeList[i].update();
    }

    if (!simulationArea.hover || simulationArea.hover == this)
        this.hover = this.isHover();

    if (!simulationArea.mouseDown) this.hover = false;


    if ((this.clicked || !simulationArea.hover) && this.isHover()) {
        this.hover = true;
        simulationArea.hover = this;
    } else if (!simulationArea.mouseDown && this.hover && this.isHover() == false) {
        if (this.hover) simulationArea.hover = undefined;
        this.hover = false;
    }

    if (simulationArea.mouseDown && (this.clicked)) {

        this.drag();
        if (!simulationArea.shiftDown && simulationArea.multipleObjectSelections.contains(this)) {
            for (var i = 0; i < simulationArea.multipleObjectSelections.length; i++) {
                simulationArea.multipleObjectSelections[i].drag();
            }
        }

        update |= true;
    } else if (simulationArea.mouseDown && !simulationArea.selected) {

        this.startDragging();
        if (!simulationArea.shiftDown && simulationArea.multipleObjectSelections.contains(this)) {
            for (var i = 0; i < simulationArea.multipleObjectSelections.length; i++) {
                simulationArea.multipleObjectSelections[i].startDragging();
            }
        }
        simulationArea.selected = this.clicked = this.hover;

        update |= this.clicked;
    } else {
        if (this.clicked) simulationArea.selected = false;
        this.clicked = false;
        this.wasClicked = false;
    }

    if (simulationArea.mouseDown && !this.wasClicked) {
        if (this.clicked) {
            this.wasClicked = true;
            if (this.click) this.click();
            if (simulationArea.shiftDown) {
                simulationArea.lastSelected = undefined;
                if (simulationArea.multipleObjectSelections.contains(this)) {
                    simulationArea.multipleObjectSelections.clean(this);
                } else {
                    simulationArea.multipleObjectSelections.push(this);
                }
            } else {
                simulationArea.lastSelected = this;
            }
        }
    }

    return update;
}

CircuitElement.prototype.fixDirection = function() {
    this.direction = fixDirection[this.direction] || this.direction;
    this.labelDirection = fixDirection[this.labelDirection] || this.labelDirection;
}

// The isHover method is used to check if the mouse is hovering over the object.
// Return Value: true if mouse is hovering over object else false
// NOT OVERRIDABLE
CircuitElement.prototype.isHover = function() {

    var mX = simulationArea.mouseXf - this.x;
    var mY = this.y - simulationArea.mouseYf;

    var rX = this.rightDimensionX;
    var lX = this.leftDimensionX;
    var uY = this.upDimensionY;
    var dY = this.downDimensionY;

    if (!this.directionFixed && !this.overrideDirectionRotation) {
        if (this.direction == "LEFT") {
            lX = this.rightDimensionX;
            rX = this.leftDimensionX
        } else if (this.direction == "DOWN") {
            lX = this.downDimensionY;
            rX = this.upDimensionY;
            uY = this.leftDimensionX;
            dY = this.rightDimensionX;
        } else if (this.direction == "UP") {
            lX = this.downDimensionY;
            rX = this.upDimensionY;
            dY = this.leftDimensionX;
            uY = this.rightDimensionX;
        }
    }

    return -lX <= mX && mX <= rX && -dY <= mY && mY <= uY;
};

CircuitElement.prototype.setLabel = function(label) {
    this.label = label || ""
}

CircuitElement.prototype.propagationDelayFixed = false;

//Method that draws the outline of the module and calls draw function on module Nodes.
//NOT OVERRIDABLE
CircuitElement.prototype.draw = function() {
    var ctx = simulationArea.context;
    this.checkHover();
    if (this.x * this.scope.scale + this.scope.ox < -this.rightDimensionX * this.scope.scale - 00 || this.x * this.scope.scale + this.scope.ox > width + this.leftDimensionX * this.scope.scale + 00 || this.y * this.scope.scale + this.scope.oy < -this.downDimensionY * this.scope.scale - 00 || this.y * this.scope.scale + this.scope.oy > height + 00 + this.upDimensionY * this.scope.scale) return;

    // Draws rectangle and highlights
    if (this.rectangleObject) {
        ctx.strokeStyle = "black";
        ctx.fillStyle = "white";
        ctx.lineWidth = correctWidth(3);
        ctx.beginPath();
        rect2(ctx, -this.leftDimensionX, -this.upDimensionY, this.leftDimensionX + this.rightDimensionX, this.upDimensionY + this.downDimensionY, this.x, this.y, [this.direction, "RIGHT"][+this.directionFixed]);
        if ((this.hover && !simulationArea.shiftDown) || simulationArea.lastSelected == this || simulationArea.multipleObjectSelections.contains(this)) ctx.fillStyle = "rgba(255, 255, 32,0.8)";
        ctx.fill();
        ctx.stroke();
    }
    if (this.label != "") {
        var rX = this.rightDimensionX;
        var lX = this.leftDimensionX;
        var uY = this.upDimensionY;
        var dY = this.downDimensionY;
        if (!this.directionFixed) {
            if (this.direction == "LEFT") {
                lX = this.rightDimensionX;
                rX = this.leftDimensionX
            } else if (this.direction == "DOWN") {
                lX = this.downDimensionY;
                rX = this.upDimensionY;
                uY = this.leftDimensionX;
                dY = this.rightDimensionX;
            } else if (this.direction == "UP") {
                lX = this.downDimensionY;
                rX = this.upDimensionY;
                dY = this.leftDimensionX;
                uY = this.rightDimensionX;
            }
        }

        if (this.labelDirection == "LEFT") {
            ctx.beginPath();
            ctx.textAlign = "right";
            ctx.fillStyle = "black";
            fillText(ctx, this.label, this.x - lX - 10, this.y + 5, 14);
            ctx.fill();
        } else if (this.labelDirection == "RIGHT") {
            ctx.beginPath();
            ctx.textAlign = "left";
            ctx.fillStyle = "black";
            fillText(ctx, this.label, this.x + rX + 10, this.y + 5, 14);
            ctx.fill();
        } else if (this.labelDirection == "UP") {
            ctx.beginPath();
            ctx.textAlign = "center";
            ctx.fillStyle = "black";
            fillText(ctx, this.label, this.x, this.y + 5 - uY - 10, 14);
            ctx.fill();
        } else if (this.labelDirection == "DOWN") {
            ctx.beginPath();
            ctx.textAlign = "center";
            ctx.fillStyle = "black";
            fillText(ctx, this.label, this.x, this.y + 5 + dY + 10, 14);
            ctx.fill();
        }
    }

    // calls the custom circuit design
    if (this.customDraw)
        this.customDraw();

    //draws nodes - Moved to renderCanvas
    // for (var i = 0; i < this.nodeList.length; i++)
    //     this.nodeList[i].draw();
}

//method to delete object
//OVERRIDE WITH CAUTION
CircuitElement.prototype.delete = function() {
    simulationArea.lastSelected = undefined;
    this.scope[this.objectType].clean(this); // CHECK IF THIS IS VALID
    if (this.deleteNodesWhenDeleted)
        this.deleteNodes();
    else
        for (var i = 0; i < this.nodeList.length; i++)
            if (this.nodeList[i].connections.length)
                this.nodeList[i].converToIntermediate();
            else
                this.nodeList[i].delete();
    this.deleted = true;
}

CircuitElement.prototype.cleanDelete = function() {
    this.deleteNodesWhenDeleted = true;
    this.delete();
}

CircuitElement.prototype.deleteNodes = function() {
    for (var i = 0; i < this.nodeList.length; i++)
        this.nodeList[i].delete();
}

//method to change direction
//OVERRIDE WITH CAUTION
CircuitElement.prototype.newDirection = function(dir) {
    if (this.direction == dir) return;
    // Leave this for now
    if (this.directionFixed && this.orientationFixed) return;
    else if (this.directionFixed) {
        this.newOrientation(dir);
        return; // Should it return ?
    }

    // if (obj.direction == undefined) return;
    this.direction = dir;
    for (var i = 0; i < this.nodeList.length; i++) {
        this.nodeList[i].refresh();
    }

}

CircuitElement.prototype.newLabelDirection = function(dir) {
    this.labelDirection = dir;
}

//Method to check if object can be resolved
//OVERRIDE if necessary
CircuitElement.prototype.isResolvable = function() {
    if (this.alwaysResolve) return true;
    for (var i = 0; i < this.nodeList.length; i++)
        if (this.nodeList[i].type == 0 && this.nodeList[i].value == undefined) return false;
    return true;
}

//Method to change object Bitwidth
//OVERRIDE if necessary
CircuitElement.prototype.newBitWidth = function(bitWidth) {
    if (this.fixedBitWidth) return;
    if (this.bitWidth == undefined) return;
    if (this.bitWidth < 1) return;
    this.bitWidth = bitWidth;
    for (var i = 0; i < this.nodeList.length; i++)
        this.nodeList[i].bitWidth = bitWidth;
}

//Method to change object delay
//OVERRIDE if necessary
CircuitElement.prototype.changePropagationDelay = function(delay) {
    if (this.propagationDelayFixed) return;
    if (delay == undefined) return;
    if (delay == "") return;
    delay = parseInt(delay, 10)
    if (delay < 0) return;
    this.propagationDelay = delay;
}

//Dummy resolve function
//OVERRIDE if necessary
CircuitElement.prototype.resolve = function() {

}

// Graph algorithm to resolve verilog wire labels
CircuitElement.prototype.processVerilog = function() {
    // Output count used to sanitize output
    var output_total = 0;
    for (var i = 0; i < this.nodeList.length; i++) {
        if (this.nodeList[i].type == NODE_OUTPUT && this.nodeList[i].connections.length > 0)
          output_total++;
    }

    var output_count = 0;
    for (var i = 0; i < this.nodeList.length; i++) {
        if (this.nodeList[i].type == NODE_OUTPUT) {
            if (this.objectType != "Input" && this.objectType != "Clock" && this.nodeList[i].connections.length > 0) {
                this.nodeList[i].verilogLabel =
                    verilog.generateNodeName(this.nodeList[i], output_count, output_total);

                if (!this.scope.verilogWireList[this.nodeList[i].bitWidth].contains(this.nodeList[i].verilogLabel))
                    this.scope.verilogWireList[this.nodeList[i].bitWidth].push(this.nodeList[i].verilogLabel);
                output_count++;
            }
            this.scope.stack.push(this.nodeList[i]);
        }
    }
}

CircuitElement.prototype.removePropagation = function() {
    for (var i = 0; i < this.nodeList.length; i++) {
        if (this.nodeList[i].type == NODE_OUTPUT) {
            if (this.nodeList[i].value !== undefined) {
                this.nodeList[i].value = undefined;
                simulationArea.simulationQueue.add(this.nodeList[i]);
            }
        }
    }
}

CircuitElement.prototype.verilogName = function() {
    return this.verilogType || this.objectType;
}

CircuitElement.prototype.verilogBaseType = function() {
    return this.verilogName();
}

CircuitElement.prototype.verilogParametrizedType = function() {
    var type = this.verilogBaseType();
    // Suffix bitwidth for multi-bit inputs
    // Example: DflipFlop #(2) DflipFlop_0
    if (this.bitWidth != undefined && this.bitWidth > 1)
        type += " #(" + this.bitWidth + ")";
    return type
}

// Generates final verilog code for each element
CircuitElement.prototype.generateVerilog = function() {
    // Example: and and_1(_out, _out, _Q[0]);
    var inputs = [];
    var outputs = [];

    for (var i = 0; i < this.nodeList.length; i++) {
        if (this.nodeList[i].type == NODE_INPUT) {
            inputs.push(this.nodeList[i]);
        } else {
            if (this.nodeList[i].connections.length > 0)
                outputs.push(this.nodeList[i]);
            else
                outputs.push(""); // Don't create a wire
        }
    }

    var list = outputs.concat(inputs);
    var res = this.verilogParametrizedType();
    var moduleParams = list.map(x => x.verilogLabel).join(", ");
    res += ` ${this.verilogLabel}(${moduleParams});`;
    return res;
}

// Generates final verilog code for each element
// Gate = &/|/^
// Invert is true for xNor, Nor, Nand
function gateGenerateVerilog(gate, invert = false) {
    var inputs = [];
    var outputs = [];

    for (var i = 0; i < this.nodeList.length; i++) {
        if (this.nodeList[i].type == NODE_INPUT) {
            inputs.push(this.nodeList[i]);
        } else {
            if (this.nodeList[i].connections.length > 0)
                outputs.push(this.nodeList[i]);
            else
                outputs.push(""); // Don't create a wire
        }
    }

    var res = "assign ";
    if (outputs.length == 1)
        res += outputs[0].verilogLabel;
    else
        res += `{${outputs.map(x => x.verilogLabel).join(", ")}}`;

    res += " = ";

    var inputParams = inputs.map(x => x.verilogLabel).join(` ${gate} `);
    if(invert) {
        res += `~(${inputParams});`;
    }
    else {
        res += inputParams + ';';
    }
    return res;
}

function distance(x1, y1, x2, y2) {
    return Math.sqrt(Math.pow((x2 - x1), 2) + Math.pow((y2 - y1), 2));
}