praktikum-holons/src/holeg/ui/view/main/Gui.java

package holeg.ui.view.main;

import holeg.interfaces.LocalMode;
import holeg.model.*;
import holeg.preferences.ColorPreference;
import holeg.preferences.ImagePreference;
import holeg.preferences.PreferenceKeys;
import holeg.ui.controller.Control;
import holeg.ui.model.GuiSettings;
import holeg.ui.view.canvas.Canvas;
import holeg.ui.view.category.CategoryPanel;
import holeg.ui.view.component.ButtonTabComponent;
import holeg.ui.view.dialog.*;
import holeg.ui.view.image.Import;
import holeg.ui.view.information.HolonInformationPanel;
import holeg.ui.view.inspector.Inspector;
import holeg.ui.view.inspector.UnitGraph;
import holeg.ui.view.window.AddOnWindow;
import holeg.ui.view.window.FlexWindow;
import holeg.ui.view.window.Outliner;
import holeg.utility.listener.WindowClosingListener;

import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.filechooser.FileSystemView;
import java.awt.*;
import java.awt.event.*;
import java.io.File;
import java.net.URI;
import java.util.logging.Logger;
import java.util.prefs.Preferences;

/**
 * Graphical User Interface.
 *
 * @author Gruppe14
 */
public class Gui extends JFrame{
    private static final Logger log = Logger.getLogger(Model.class.getName());
    private static final Preferences prefs = Preferences.userNodeForPackage(Gui.class);

    private final JSplitPane splitPane = new JSplitPane();
    private final JSplitPane splitPane1 = new JSplitPane();
    private final JPanel myPanel = new JPanel(new BorderLayout());
    // the tabbed canvas containing the different sub-net tabs of the grid (Main
    // Grid + Nodes of Nodes)
    private final JTabbedPane tabbedPaneInnerOriginal = new JTabbedPane(JTabbedPane.TOP);
    // the main canvas where we can see the grid currently displayed
    private final JScrollPane canvasSP = new JScrollPane();
    private final CategoryPanel categoryPanel;
    // private final JScrollPane holonSP = new JScrollPane();
    // the original tabbed Pane (containing tabs for view, statistics, holon,
    // flexibility)
    private final JTabbedPane tabbedPaneOriginal = new JTabbedPane(JTabbedPane.TOP);


    /******************************************
     ************* Right Container*************
     ******************************************
     * Right Container: here comes the information about the HolonObject, such as
     * HolonElements Information, Properties and Consumption/Production graph.
     **/
    private final Inspector inspector;
    private final HolonInformationPanel informationPanel;
    private final JSplitPane splitHolonElPro = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
    private final JScrollPane scrollProperties = new JScrollPane();

    // In this section is the graph for the selected HolonElement of the clicked
    private final Control control;
    // In this section are all the Holonelements that correspond to the clicked
    // HolonObject with consumption/production, name and amount.

    private final UnitGraph unitGraph;
    /**
     * Textfield to show the period of an element
     */
    private final JTextField unitGraphLocalPeriod = new JTextField(6);
    private final Canvas canvas;

    // tabbedPaneOriginal or tabbedPaneSplit
    private JTabbedPane tabTemp;
    private Canvas actualOpenCanvas;
    private JPanel contentPane;
    // Time Stuff
    private TimePanel timePanel;



    /**
     * Create the application.
     *
     * @param control the Controller
     */
    public Gui(Control control) {
        this.control = control;
        this.informationPanel = new HolonInformationPanel(control);
        inspector = new Inspector(control);
        control.calculateStateAndVisualForCurrentTimeStep();
        this.unitGraph = new UnitGraph(control);
        this.canvas = new Canvas(control, control.getModel().getCanvas());
        this.categoryPanel = new CategoryPanel(control, this);
        this.actualOpenCanvas = this.canvas;
        initialize();
    }

    public TimePanel getTimePanel() {
        return timePanel;
    }

    /**
     * Initialize the contents of the frame.
     */
    private void initialize() {
        this.setTitle("HOLEG Simulator");
        this.setBounds(new Rectangle(1200, 800));
        //Center
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

        this.addWindowListener((WindowClosingListener) e -> {
            if (JOptionPane.showConfirmDialog(this, "Are you sure you want to exit?", "HOLEG",
                    JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION) {
                System.exit(0);
            }
        });

        contentPane = (JPanel) this.getContentPane();

        int condition = JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT;
        InputMap inputMap = contentPane.getInputMap(condition);
        ActionMap actionMap = contentPane.getActionMap();

        String cntrlZDown = "controlZ";
        inputMap.put(KeyStroke.getKeyStroke("control Z"), cntrlZDown);
        actionMap.put(cntrlZDown, new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //TODO(Tom2022-01-27): CtrlZ
            }
        });

        String cntrlYDown = "controlY";
        inputMap.put(KeyStroke.getKeyStroke("control Y"), cntrlYDown);
        actionMap.put(cntrlYDown, new AbstractAction() {

            @Override
            public void actionPerformed(ActionEvent e) {
                //TODO Ctrl Y
            }
        });

        String cntrlADown = "controlA";
        inputMap.put(KeyStroke.getKeyStroke("control A"), cntrlADown);
        AbstractAction controlA = new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                GuiSettings.getSelectedObjects().clear();
                //TODO(Tom2022-01-27): Ctrl A
            }
        };
        actionMap.put(cntrlADown, controlA);

        String delDown = "delete";
        inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0, false), delDown);
        actionMap.put(delDown, new AbstractAction() {

            private static final long serialVersionUID = 1L;

            @Override
            public void actionPerformed(ActionEvent e) {
                chooseTabTemp();
                //TODO(Tom2022-01-27): delete
                GuiSettings.getSelectedObjects().clear();
            }
        });
        String cntrlCDown = "controlC";
        inputMap.put(KeyStroke.getKeyStroke("control C"), cntrlCDown);
        AbstractAction controlC = new AbstractAction() {
            private static final long serialVersionUID = 1L;

            @Override
            public void actionPerformed(ActionEvent e) {
                chooseTabTemp();
                JScrollPane scrollPane = getScrollPaneFromTabbedPane();
                if (!GuiSettings.getSelectedObjects().isEmpty()) {
                    if (scrollPane.getViewport().getComponent(0) instanceof Canvas groupNodeCanvas)
                        control.copy(groupNodeCanvas.getGroupNode());
                    else
                        control.copy(null);
                    if (!GuiSettings.getClipboardObjects().isEmpty()) {
                        //TODO(Tom2022-01-14): old code changes itemPaste
                        //OLD: canvas.itemPaste.setEnabled(true);
                    }
                }
            }
        };
        actionMap.put(cntrlCDown, controlC);

        String cntrlVDown = "controlV";
        inputMap.put(KeyStroke.getKeyStroke("control V"), cntrlVDown);
        AbstractAction controlV = new AbstractAction() {
            private static final long serialVersionUID = 1L;

            @Override
            public void actionPerformed(ActionEvent e) {
                //TODO(Tom2022-01-27): Paste
            }
        };
        actionMap.put(cntrlVDown, controlV);

        String cntrlXDown = "controlX";
        inputMap.put(KeyStroke.getKeyStroke("control X"), cntrlXDown);
        AbstractAction controlX = new AbstractAction() {
            private static final long serialVersionUID = 1L;

            @Override
            public void actionPerformed(ActionEvent e) {
                chooseTabTemp();
                JScrollPane scrollPane = getScrollPaneFromTabbedPane();
                if (!GuiSettings.getSelectedObjects().isEmpty()) {
                    if (scrollPane.getViewport().getComponent(0) instanceof Canvas groupNodeCanvas) {
                        control.cut(groupNodeCanvas.getGroupNode());
                        control.calculateStateAndVisualForCurrentTimeStep();
                        scrollPane.getViewport().getComponent(0).repaint();
                    } else {
                        control.cut(null);
                        control.calculateStateAndVisualForCurrentTimeStep();
                        log.info("canvas.repaint3");
                        canvas.repaint();
                    }
                    if (!GuiSettings.getClipboardObjects().isEmpty()) {
                        //TODO(Tom2022-01-14): old code changes itemPaste
                        //OLD: canvas.itemPaste.setEnabled(true);
                    }
                }
            }
        };
        actionMap.put(cntrlXDown, controlX);
        this.setJMenuBar(new GuiMenuBar());

        this.setIconImage(Import.loadImage(ImagePreference.Logo, 30, 30));




        tabbedPaneInnerOriginal.addChangeListener(change -> {
            control.clearSelection();
        });

        /**
         * add Help Menu and its items
         */

        canvas.setBackground(Color.WHITE);
        canvas.setPreferredSize(new Dimension(GuiSettings.canvasSize.getX(), GuiSettings.canvasSize.getY()));

        /***********************
         * HolonElement Graph Actions
         **********************/

        /*
         * Update Local Period of an Element Graph
         */
        unitGraphLocalPeriod.addKeyListener(new KeyAdapter() {
            @Override
            public void keyReleased(KeyEvent e) {
                try {
                    int localLength = Integer.parseInt(unitGraphLocalPeriod.getText());
                    unitGraphLocalPeriod.setBackground(Color.WHITE);
                    /**
                     * set local graph Period
                     */
                    if (e.getKeyCode() == KeyEvent.VK_ENTER) {
                        LocalMode.Period period = new LocalMode.Period(localLength);
                        period.setInterval(localLength);
                        unitGraph.setPeriod(period);
                    }
                } catch (NumberFormatException ex) {
                    unitGraphLocalPeriod.setBackground(ColorPreference.GUI.PALE_RED);
                }

            }
        });

        /*****************************
         * RIGHT CONTAINER DONE
         *****************************/

        this.getContentPane().setLayout(new BorderLayout(0, 0));
        /****************
         * Tree Stuff
         ****************/








        this.getContentPane().add(splitPane);

        timePanel = new TimePanel(control);
        timePanel.setBorder(null);
        timePanel.getTimeSlider().addChangeListener(changeEvent -> {
            // TimeSliderChanged event
            control.calculateStateAndVisualForTimeStep(timePanel.getTimeSlider().getValue());
            unitGraph.repaint();
            contentPane.updateUI();
        });
        splitPane1.setMinimumSize(new Dimension(0, 25));
        splitPane.setRightComponent(splitPane1);
        splitPane.setDividerLocation(200);
        splitPane1.setDividerLocation(500);

        splitPane.setLeftComponent(categoryPanel);
        tabbedPaneOriginal.addTab("View", tabbedPaneInnerOriginal);

        myPanel.add(canvasSP, BorderLayout.CENTER);

        tabbedPaneInnerOriginal.addTab("Main Grid", myPanel);
        splitPane1.setLeftComponent(tabbedPaneOriginal);
        splitPane1.setRightComponent(splitHolonElPro);

        splitPane1.setResizeWeight(0.9);

        splitHolonElPro.setDividerLocation(700);
        // containing the graph and the elements-list
        splitHolonElPro.setTopComponent(inspector);
        // containing the object's properties
        splitHolonElPro.setBottomComponent(scrollProperties);

        canvasSP.setViewportView(canvas);
        // Set up of the Properties section
        scrollProperties.setViewportView(this.informationPanel);
        scrollProperties.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
        scrollProperties.getVerticalScrollBar().setUnitIncrement(16);

        tabbedPaneOriginal.setBorder(null);
        scrollProperties.setBorder(null);
        splitPane.setBorder(null);
        splitPane1.setBorder(null);
        splitHolonElPro.setBorder(null);
        canvasSP.setBorder(null);

        this.getContentPane().add(timePanel, BorderLayout.SOUTH);

        canvasSP.addComponentListener(new ComponentAdapter() {
            @Override
            public void componentResized(ComponentEvent e) {
                GuiSettings.canvasSize.setX(Math.max(GuiSettings.canvasSize.getX(), canvasSP.getViewport().getWidth()));
                GuiSettings.canvasSize
                        .setY(Math.max(GuiSettings.canvasSize.getY(), canvasSP.getViewport().getHeight()));
                log.info("canvas.repaint11");
                canvas.repaint();
            }
        });
    }

    /*
     * Open a new Tab with an UpperNodeCanvas
     */
    public void openNewUpperNodeTab(GroupNode node) {
        chooseTabTemp();

        JScrollPane scrollPane = getScrollPaneFromTabbedPane();
        if (scrollPane.getViewport().getComponent(0) instanceof Canvas canvasPanel) {
            actualOpenCanvas = new Canvas(control, node);
        }

        // check if tab already open for clicked NodeOfNode
        boolean dupl = false;

        for (int i = 1; i < tabbedPaneInnerOriginal.getTabCount(); i++) {
            JScrollPane paneOriginal = (JScrollPane) tabbedPaneInnerOriginal.getComponentAt(i);
            if (paneOriginal != null && ((Canvas) paneOriginal.getViewport().getComponent(0)).getGroupNode()
                    .getId() == node.getId()) {
                dupl = true;
                // set selected component to view
                tabbedPaneOriginal.setSelectedComponent(tabbedPaneInnerOriginal);
                // set selected tab in view to found upper-node-canvas
                tabbedPaneInnerOriginal.setSelectedComponent(tabbedPaneInnerOriginal.getComponentAt(i));
            }

            // if we found a duplicate, break
            if (dupl) {
                break;
            }
        }
        if (!dupl) {
            JScrollPane sp = new JScrollPane(actualOpenCanvas);
            sp.setBorder(null);

            // Selected tabbed Pane = tabbedPaneOriginal or tabbedPaneSplit
            if (tabTemp == tabbedPaneOriginal) {
                this.tabbedPaneInnerOriginal.add(node.getName(), sp);
                this.tabbedPaneInnerOriginal.setSelectedComponent(sp);
                this.tabbedPaneInnerOriginal.setTabComponentAt(this.tabbedPaneInnerOriginal.getTabCount() - 1,
                        new ButtonTabComponent(this.tabbedPaneInnerOriginal));

            }
        }
    }

    /**
     * Removes UpperNodeTab if UpperNode was deleted
     *
     * @param cps the CPS object that is currently selected
     */
    private void removeUpperNodeTab(AbstractCanvasObject cps) {
        if (cps instanceof GroupNode) {
            for (int i = 1; i < tabbedPaneInnerOriginal.getTabCount(); i++) {
                JScrollPane scrollPaneOriginal = (JScrollPane) tabbedPaneInnerOriginal.getComponentAt(i);

                if (scrollPaneOriginal == null) {
                } else if (((Canvas) scrollPaneOriginal.getViewport().getComponent(0)).getGroupNode()
                        .getId() == cps.getId()) {
                    ((ButtonTabComponent) tabbedPaneInnerOriginal.getTabComponentAt(i)).removeTabs();
                    break;
                }
            }
        }
    }

    /**
     * chooses whether to set the tabTemp to tabbedPaneOriginal or tabbedPaneSplit
     */
    private void chooseTabTemp() {
        // TODO(Tom2021-12-1) Remove tabTabbed
        tabTemp = tabbedPaneOriginal;
    }

    private JScrollPane getScrollPaneFromTabbedPane() {
        return getScrollPaneFromTabbedPane(-1);
    }

    private JScrollPane getScrollPaneFromTabbedPane(int index) {
        Component upperLevelSelectedComponent;
        if (tabTemp == null) {
            return null;
        }
        if (index == -1) {
            upperLevelSelectedComponent = tabTemp.getSelectedComponent();
        } else {
            upperLevelSelectedComponent = tabTemp.getComponentAt(index);
        }
        if (upperLevelSelectedComponent instanceof JTabbedPane) {
            Component nextLevel = ((JTabbedPane) upperLevelSelectedComponent).getSelectedComponent();
            if (nextLevel instanceof JPanel panel)
                return (JScrollPane) panel.getComponent(0);
            else
                return (JScrollPane) nextLevel;

        } else if (upperLevelSelectedComponent instanceof JScrollPane scrollPane) {
            return scrollPane;
        } else {
            return null;
        }
    }

    private void openWebpage(String URL) {
        try {
            java.awt.Desktop.getDesktop().browse(new URI(URL));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * closes all UpperNodeTabs, that don't have a valid UpperNode (e.g. if it was
     * ungrouped/deleted/replaced and so on)
     */
    private void closeInvalidUpperNodeTabs() {
        /**
         * close bugged Tabs
         */
        for (int i = 1; i < tabbedPaneInnerOriginal.getTabCount(); i++) {
            JScrollPane scrollPaneOriginal = (JScrollPane) tabbedPaneInnerOriginal.getComponentAt(i);
            if (((Canvas) scrollPaneOriginal.getViewport().getComponent(0)).getGroupNode() == null) {
                ((ButtonTabComponent) tabbedPaneInnerOriginal.getTabComponentAt(i)).removeTabs();
                break;
            }
        }
    }

    public Canvas getCanvas() {
        return canvas;
    }

    public JFrame getFrame() {
        return this;
    }


    private class GuiMenuBar extends JMenuBar {
        //Menus
        private final JMenu fileMenu = new JMenu("File");
        private final JMenu editMenu = new JMenu("Edit");
        private final JMenu viewMenu = new JMenu("View");
        private final JMenu windowMenu = new JMenu("Window");
        private final JMenu helpMenu = new JMenu("Help");

        // FileMenu
        private final JMenuItem newMenuButton = new JMenuItem("New");
        private final JMenuItem openMenuButton = new JMenuItem("Open..");
        private final JMenuItem saveMenuButton = new JMenuItem("Save");
        private final JMenuItem saveAsMenuButton = new JMenuItem("Save..");

        // EditMenu
        private final JMenuItem undoButton = new JMenuItem("Undo");
        private final JMenuItem redoButton = new JMenuItem("Redo");
        private final JMenuItem edgePropertiesButton = new JMenuItem("Edge Properties");
        private final JMenuItem alignAllButton = new JMenuItem("Align All");
        private final JMenu resetMenu = new JMenu("Reset");
        private final JMenuItem resetCategoryButton = new JMenuItem("Categories");


        //HelpMenu
        private final JMenuItem introductionButton = new JMenuItem("Introduction");
        private final JMenuItem userManualButton = new JMenuItem("User Manual");
        private final JMenuItem algorithmHelpButton = new JMenuItem("Algorithm Introduction");
        private final JMenuItem codeDocumentationButton = new JMenuItem("Code Documentation");
        private final JMenuItem aboutUsButton = new JMenuItem("About Us");

        //ViewMenu
        private final JMenu appearanceMenu = new JMenu("Appearance");
        private final JMenuItem canvasSizeButton = new JMenuItem("Set View Size");
        private final JCheckBoxMenuItem showSupplyBarsCheckBox = new JCheckBoxMenuItem("Show supply bars.", true);
        private final JFileChooser fileChooser = initFileChooser();
        //WindowMenu
        JMenuItem algorithmButton = new JMenuItem("Algorithm Panel", new ImageIcon(Import
                .loadImage(ImagePreference.Button.Menu.Algo).getScaledInstance(20, 20, java.awt.Image.SCALE_SMOOTH)));
        JMenuItem outlinerButton = new JMenuItem("Outliner", new ImageIcon(Import
                .loadImage(ImagePreference.Button.Menu.Outliner).getScaledInstance(20, 20, java.awt.Image.SCALE_SMOOTH)));
        JMenuItem flexMenuButton = new JMenuItem("Flexibility Panel", new ImageIcon(Import
                .loadImage(ImagePreference.Button.Menu.Algo).getScaledInstance(20, 20, java.awt.Image.SCALE_SMOOTH)));

        GuiMenuBar() {
            initMenuLayout();
            initButtonActions();
            initButtonShortCuts();
        }

        private static JFileChooser initFileChooser() {
            JFileChooser safeLoadFileChooser = new JFileChooser(prefs.get(PreferenceKeys.Gui.DefaultFolder,
                    FileSystemView.getFileSystemView().getDefaultDirectory().getPath()));
            safeLoadFileChooser.setFileFilter(new FileNameExtensionFilter("Holeg json files", "json"));
            safeLoadFileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
            safeLoadFileChooser.setAcceptAllFileFilterUsed(false);
            return safeLoadFileChooser;
        }

        private void initMenuLayout() {
            add(fileMenu);
            add(editMenu);
            add(viewMenu);
            add(windowMenu);
            add(helpMenu);

            fileMenu.add(newMenuButton);
            fileMenu.add(openMenuButton);
            fileMenu.addSeparator();
            fileMenu.add(saveMenuButton);
            fileMenu.add(saveAsMenuButton);

            editMenu.add(undoButton);
            editMenu.add(redoButton);
            editMenu.add(edgePropertiesButton);
            editMenu.add(alignAllButton);
            editMenu.add(resetMenu);
            resetMenu.add(resetCategoryButton);

            helpMenu.add(introductionButton);
            helpMenu.add(userManualButton);
            helpMenu.add(algorithmHelpButton);
            helpMenu.add(codeDocumentationButton);
            helpMenu.add(aboutUsButton);

            viewMenu.add(appearanceMenu);
            appearanceMenu.add(showSupplyBarsCheckBox);
            viewMenu.add(canvasSizeButton);

            windowMenu.add(algorithmButton);
            windowMenu.add(outlinerButton);
            windowMenu.add(flexMenuButton);
        }

        private void initButtonActions() {
            newMenuButton.addActionListener(clicked -> newFile());
            openMenuButton.addActionListener(clicked -> openFile());
            saveMenuButton.addActionListener(clicked -> saveFile());
            saveAsMenuButton.addActionListener(clicked -> saveNewFile());
            edgePropertiesButton.addActionListener(actionEvent -> new EditEdgesPopUp(Gui.this, control));
            //TODO(Tom2022-01-14): recreateTryToAlignObjects
            alignAllButton.addActionListener(clicked -> {
                log.info("Not implemented yet.");
            });
            resetCategoryButton.addActionListener(clicked -> control.resetCategories());

            showSupplyBarsCheckBox.addActionListener(clicked -> toggleSupplyBarAppearance());
            canvasSizeButton.addActionListener(clicked -> new CanvasResizePopUp(control, canvas, tabbedPaneInnerOriginal,
                    Gui.this));


            algorithmButton.addActionListener(clicked -> new AddOnWindow(Gui.this, control));
            outlinerButton.addActionListener(clicked -> new Outliner(Gui.this, control));
            flexMenuButton.addActionListener(clicked -> new FlexWindow(Gui.this, control));


            String tkWikiWebpage = "https://git.tk.informatik.tu-darmstadt.de/carlos.garcia/praktikum-holons/wiki/";
            introductionButton.addActionListener(clicked -> openWebpage(tkWikiWebpage + "Introduction+V2.1"));
            userManualButton.addActionListener(clicked -> openWebpage(tkWikiWebpage + "User+Manual+V2.1"));
            algorithmHelpButton.addActionListener(clicked -> openWebpage(tkWikiWebpage + "Algorithms+V2.1"));
            codeDocumentationButton.addActionListener(clicked -> openWebpage(tkWikiWebpage + "Code+documentation+V2.1"));
            aboutUsButton.addActionListener(clicked -> new AboutUsPopUp(Gui.this));
        }

        private void initButtonShortCuts() {
            int defaultModifier = Toolkit.getDefaultToolkit().getMenuShortcutKeyMaskEx();
            saveMenuButton.setAccelerator(KeyStroke.getKeyStroke('S', defaultModifier));
            saveAsMenuButton.setAccelerator(KeyStroke.getKeyStroke('S', defaultModifier + InputEvent.SHIFT_DOWN_MASK));
            openMenuButton.setAccelerator(KeyStroke.getKeyStroke('O', defaultModifier));
            newMenuButton.setAccelerator(KeyStroke.getKeyStroke('N', defaultModifier));
        }

        private void toggleSupplyBarAppearance() {
            GuiSettings.showSupplyBars = showSupplyBarsCheckBox.isSelected();
            log.info("canvas.repaint4");
            canvas.repaint();
        }

        private void saveFile(){
            GuiSettings.getActualSaveFile().ifPresentOrElse(control::saveFile, this::saveNewFile);
        }
        private void saveNewFile() {
            if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
                String path = fileChooser.getSelectedFile().getPath();
                if (!path.endsWith(".json")) {
                    path += ".json";
                }
                prefs.put(PreferenceKeys.Gui.DefaultFolder, fileChooser.getCurrentDirectory().getPath());
                control.saveFile(new File(path));
            }
        }
        private void openFile() {
            if (fileChooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
                prefs.put(PreferenceKeys.Gui.DefaultFolder, fileChooser.getCurrentDirectory().getPath());
                control.loadFile(fileChooser.getSelectedFile());
                //TODO(Tom2022-01-27): make better
                canvas.setGroupNode(control.getModel().getCanvas());
                canvas.repaint();
            }
        }

        private void newFile() {
            if (control.getModel().getCanvas().getObjectsInThisLayer().findAny().isPresent()) {
                int selectedOption = JOptionPane.showConfirmDialog(this, "Do you want to save your current model?",
                        "Warning", JOptionPane.YES_NO_OPTION);
                if (selectedOption == JOptionPane.YES_OPTION) {
                    saveNewFile();
                }
            }
            control.clearModel();
        }

    }

}