private position()

in sim/visuals/layoutView.ts [272:425]
121 lines of code
14 McCabe index (conditional complexity)

        private position() {
            if (!this.hasDimensions) {
                return;
            }

            this.offsets = [];

            const contentWidth = this.width;
            if (!contentWidth) return;
            const contentHeight = this.height;
            if (!contentHeight) return;

            const noConnections = this.outputs.concat(this.inputs).filter(m => m.getId() != NodeType.Port).length == 0;

            this.outputs.concat(this.inputs).forEach(m => m.setVisible(true));

            const moduleHeight = this.getModuleHeight();

            const brickHeight = this.getBrickHeight();
            const brickWidth = this.brick.getInnerWidth() / this.brick.getInnerHeight() * brickHeight;
            const brickPadding = (contentWidth - brickWidth) / 2;

            const modulePadding = this.getModulePadding();
            const moduleSpacing = contentWidth / 4;
            let currentX = this.getModulePadding();
            let currentY = 0;
            this.outputs.forEach((n, i) => {
                this.outputContainers[i].translate(currentX + (this.getAbosluteModuleWidth() - this.getInnerModuleWidth()) / 2, currentY);
                if (this.outputs[i]) {
                    const view = this.outputs[i];
                    const outputPadding = this.getInnerModuleWidth() * view.getPaddingRatio();
                    const outputHeight = this.getModuleHeight();
                    const outputWidth = this.getInnerModuleWidth();

                    // Translate and resize view
                    view.resize(outputWidth - outputPadding * 2, outputHeight);
                    // const viewHeight = view.getInnerHeight() / view.getInnerWidth() * outputWidth;
                    // view.translate(outputPadding + ((desiredOutputWidth - outputWidth) / 2), outputHeight - viewHeight, true);
                    const viewHeight = view.getActualHeight();
                    view.translate(outputPadding, outputHeight - viewHeight, true);

                    // Resize control
                    const control = this.outputControls[i];
                    if (control) {
                        const controlWidth = outputWidth;
                        const closeIconOffset = (this.getCloseIconSize() * (1 + CLOSE_ICON_GAP_MULTIPLIER));
                        const controlHeight = outputHeight - closeIconOffset;
                        control.resize(controlWidth, controlHeight);
                        control.translate((controlWidth - control.getActualWidth()) / 2,
                            closeIconOffset + ((controlHeight - control.getActualHeight()) / 2), true)

                        // Translate and resize close icon
                        const closeIcon = this.outputCloseIcons[i];
                        if (closeIcon) {
                            const closeIconSize = this.getCloseIconSize();
                            closeIcon.resize(closeIconSize, closeIconSize);
                            closeIcon.translate((outputWidth - closeIcon.getActualWidth()) / 2, (CLOSE_ICON_GAP_MULTIPLIER * closeIcon.getActualHeight()), true);
                        }
                    }

                    // Resize background
                    const backgroundView = this.inputBackgroundViews[i];
                    if (backgroundView) {
                        backgroundView.resize(this.getInnerModuleWidth(), outputHeight);
                        backgroundView.translate(0, 0, true)
                }
                }
                currentX += moduleSpacing;
            })

            currentX = 0;
            currentY = moduleHeight;

            const wireBrickSpacing = brickWidth / 5;
            const wiringYPadding = 5;
            let wireStartX = 0;
            let wireEndX = brickPadding + wireBrickSpacing;
            let wireEndY = currentY + this.getWiringHeight() + wiringYPadding;
            let wireStartY = currentY - wiringYPadding;

            // Draw output lines
            for (let port = 0; port < DAL.NUM_OUTPUTS; port++) {
                this.outputWires[port].updateDimensions(wireStartX + moduleSpacing * this.outputs[port].getWiringRatio(), wireStartY, wireEndX, wireEndY);
                this.outputWires[port].setSelected(this.outputs[port].getId() == NodeType.Port);
                wireStartX += moduleSpacing;
                wireEndX += wireBrickSpacing;
            }

            currentX = brickPadding;
            currentY += this.getWiringHeight();

            // Render the brick in the middle
            this.brick.resize(brickWidth, brickHeight);
            this.brick.translate(currentX, currentY);
            this.brickLandscape.resize(contentWidth, brickHeight);
            this.brickLandscape.translate((contentWidth - this.brickLandscape.getContentWidth()) / 2, currentY);

            currentX = modulePadding;
            currentY += brickHeight + this.getWiringHeight();

            this.inputs.forEach((n, i) => {
                this.inputContainers[i].translate(currentX + (this.getAbosluteModuleWidth() - this.getInnerModuleWidth()) / 2, currentY);
                if (this.inputs[i]) {
                    const view = this.inputs[i];
                    const inputPadding = this.getInnerModuleWidth() * view.getPaddingRatio();
                    const inputHeight = this.getModuleHeight();
                    const inputWidth = this.getInnerModuleWidth();

                    // Translate and resize view
                    view.resize(inputWidth - inputPadding * 2, inputHeight);
                    const viewHeight = Math.max(view.getActualHeight(), MIN_MODULE_HEIGHT);
                    view.translate(inputPadding, 0, true);

                    // Resize control
                    const control = this.inputControls[i];
                    if (control) {
                        const controlWidth = inputWidth;
                        const controlHeight = inputHeight - viewHeight - (this.getCloseIconSize() * (1 + CLOSE_ICON_GAP_MULTIPLIER));
                        control.resize(controlWidth, controlHeight);
                        control.translate((controlWidth - control.getActualWidth()) / 2,
                            viewHeight + ((controlHeight - control.getActualHeight()) / 2), true)

                        // Translate and resize close icon
                        const closeIcon = this.inputCloseIcons[i];
                        if (closeIcon) {
                            const closeIconSize = this.getCloseIconSize();
                            closeIcon.resize(closeIconSize, closeIconSize);
                            closeIcon.translate((inputWidth - closeIcon.getActualWidth()) / 2, inputHeight - ((1 + CLOSE_ICON_GAP_MULTIPLIER) * closeIcon.getActualHeight()), true);
                        }
                        }

                    // Resize background
                    const backgroundView = this.inputBackgroundViews[i];
                    if (backgroundView) {
                        backgroundView.resize(this.getInnerModuleWidth(), inputHeight, true);
                        backgroundView.translate(0, 0, true)
                    }
                }
                currentX += moduleSpacing;
            })

            wireStartX = moduleSpacing / 2;
            wireEndX = brickPadding + wireBrickSpacing;
            wireEndY = currentY - this.getWiringHeight() - wiringYPadding;
            wireStartY = currentY + wiringYPadding;

            // Draw input lines
            for (let port = 0; port < DAL.NUM_INPUTS; port++) {
                this.inputWires[port].updateDimensions(wireStartX, wireStartY, wireEndX, wireEndY);
                this.inputWires[port].setSelected(this.inputs[port].getId() == NodeType.Port);
                wireStartX += moduleSpacing;
                wireEndX += wireBrickSpacing;
            }
        }