praktikum-holons/src/ui/view/MyCanvas.java

package ui.view;

import classes.*;
import com.google.gson.JsonParseException;
import ui.controller.Control;
import ui.controller.UpdateController;
import ui.model.Model;

import javax.swing.*;
import java.awt.*;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.event.*;
import java.awt.geom.Line2D;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Timer;
import java.util.TimerTask;

/**
 * This Class is the Canvas. All Objects will be visualized here
 *
 * @author Gruppe14
 */
public class MyCanvas extends JPanel implements MouseListener, MouseMotionListener {

    private static final long serialVersionUID = 1L;
    public final JMenuItem itemPaste = new JMenuItem(Languages.getLanguage()[97]);
    // edge Object Start Point
    private final Model model;
    private final Control controller;
    private final float scalediv20;
    private final UpdateController updCon;
    private final boolean[] showedInformation = new boolean[5];
    // PopUpMenu
    private final JPopupMenu popmenu = new JPopupMenu();
    private final JMenuItem itemDelete = new JMenuItem(Languages.getLanguage()[98]);
    private final JMenuItem itemCut = new JMenuItem(Languages.getLanguage()[95]);
    private final JMenuItem itemCopy = new JMenuItem(Languages.getLanguage()[96]);
    private final JMenuItem itemGroup = new JMenuItem(Languages.getLanguage()[99]);
    private final JMenuItem itemUngroup = new JMenuItem(Languages.getLanguage()[100]);
    private final JMenuItem itemTrack = new JMenuItem(Languages.getLanguage()[101]);
    private final JMenuItem itemUntrack = new JMenuItem(Languages.getLanguage()[102]);
    private final Position toolTipPos = new Position(); // Tooltip Position
    private final int ANIMTIME = 500; // animation Time
    private final int animFPS = 60;
    private final int animDelay = 1000 / animFPS; // animation Delay
    public AbstractCpsObject tempCps = null;
    ArrayList<HolonElement> dataSelected = new ArrayList<>();
    ArrayList<AbstractCpsObject> tempSelected = new ArrayList<>();
    private Image img = null; // Contains the image to draw on MyCanvas
    private int x = 0;
    private int y = 0;
    private Graphics2D g2; // For Painting
    private int cx, cy;
    private int sx, sy; // Mark Coords
    private Position unPos;
    private ArrayList<Position> savePos;
    private boolean dragging = false; // for dragging
    private boolean dragged = false; // if an object/objects was/were dragged
    private boolean drawEdge = false; // for drawing edges
    private boolean click = false; // for double click
    private boolean doMark = false; // for double click
    private CpsEdge edgeHighlight = null;
    // rightclicked
    // Tooltip
    private boolean toolTip; // Tooltip on or off
    private String toolTipText = "";
    private Point mousePosition = new Point(); // Mouse Position when
    // Animation Stuff
    private javax.swing.Timer animT; // animation Timer
    private ArrayList<AbstractCpsObject> animCps = null;
    private int animDuration = ANIMTIME; // animation Duration
    private int animSteps = animDuration / animDelay; // animation Steps;

    // contains the value of the Capacity for new created Edges

    /**
     * Constructor.
     *
     * @param mod       the Model
     * @param control   the Controller
     * @param unitGraph
     */
    public MyCanvas(Model mod, Control control, UnitGraph unitGraph) {
        toolTip = false;
        this.controller = control;
        this.model = mod;
        scalediv20 = model.getScale() / 20;

        showedInformation[0] = true;
        showedInformation[1] = true;
        showedInformation[3] = false;
        showedInformation[4] = true;
        control.setMaxCapacity(10000);

        popmenu.add(itemCut);
        popmenu.add(itemCopy);
        popmenu.add(itemPaste);
        popmenu.add(itemDelete);
        popmenu.addSeparator();
        popmenu.add(itemGroup);
        popmenu.add(itemUngroup);
        popmenu.add(itemTrack);
        popmenu.add(itemUntrack);

        updCon = new UpdateController(mod, control);

        itemDelete.setEnabled(false);
        itemCut.setEnabled(false);
        itemCopy.setEnabled(false);
        itemPaste.setEnabled(true);
        itemGroup.setEnabled(false);
        itemUngroup.setEnabled(false);
        itemTrack.setEnabled(false);
        itemUntrack.setEnabled(false);

        itemCut.setText(Languages.getLanguage()[95]);

        itemGroup.addActionListener(actionEvent -> {
            // calculate uppernode pos (taken from the controller)
            unPos = new Position(0, 0);
            animCps = new ArrayList<>();
            for (AbstractCpsObject cps : model.getSelectedCpsObjects()) {
                animCps.add(cps); // add to animation Cps ArrayList
                unPos.x += cps.getPosition().x;
                unPos.y += cps.getPosition().y;
            }
            unPos.x /= animCps.size();
            unPos.y /= animCps.size();

            // save old Position
            savePos = new ArrayList<>();
            for (int i = 0; i < animCps.size(); i++) {
                savePos.add(new Position(0, 0));
                savePos.get(i).x = animCps.get(i).getPosition().x;
                savePos.get(i).y = animCps.get(i).getPosition().y;
            }

            animT = new javax.swing.Timer(animDelay, new ActionListener() {

                @Override
                public void actionPerformed(ActionEvent e) {
                    if (animDuration - animDelay > 0 && animCps.size() > 1) {
                        for (AbstractCpsObject animCpObject : animCps) {
                            double x1 = animCpObject.getPosition().x - unPos.x;
                            double y1 = animCpObject.getPosition().y - unPos.y;
                            animCpObject.getPosition().x -= x1 / animSteps;
                            animCpObject.getPosition().y -= y1 / animSteps;
                        }
                        repaint();
                        animDuration -= animDelay;
                        animSteps--;
                    } else {
                        animDuration = ANIMTIME;
                        animSteps = animDuration / animDelay;
                        animT.stop();
                        for (int i = 0; i < animCps.size(); i++) {
                            animCps.get(i).getPosition().x = savePos.get(i).x;
                            animCps.get(i).getPosition().y = savePos.get(i).y;
                        }
                        controller.addUpperNode("NodeOfNode", null, animCps);
                        controller.calculateStateForCurrentTimeStep();
                        repaint();
                    }
                }
            });
            animT.start();
        });

        itemUngroup.addActionListener(actionEvent -> {
            // save old Position
            JTabbedPane tabbedPaneInner = (JTabbedPane) getParent().getParent().getParent();
            for (int i = 1; i < tabbedPaneInner.getTabCount(); i++) {
                if (((UpperNodeCanvas) ((JScrollPane) tabbedPaneInner.getComponentAt(i)).getViewport()
                        .getComponent(0)).upperNode.getId() == tempCps.getId()) {
                    tabbedPaneInner.remove(i);
                    break;
                }
            }

            savePos = new ArrayList<>();
            animCps = ((CpsUpperNode) tempCps).getNodes();
            controller.delUpperNode((CpsUpperNode) tempCps, null);

            for (int i = 0; i < animCps.size(); i++) {
                savePos.add(new Position(0, 0));
                savePos.get(i).x = animCps.get(i).getPosition().x;
                savePos.get(i).y = animCps.get(i).getPosition().y;
            }
            for (AbstractCpsObject cps : animCps) {
                int x = tempCps.getPosition().x;
                int y = tempCps.getPosition().y;

                cps.setPosition(new Position(x, y));
            }

            animT = new javax.swing.Timer(animDelay, new ActionListener() {

                @Override
                public void actionPerformed(ActionEvent e) {
                    if (animDuration - animDelay >= 0) {
                        for (int i = 0; i < animCps.size(); i++) {
                            double x1 = animCps.get(i).getPosition().x - savePos.get(i).x;
                            double y1 = animCps.get(i).getPosition().y - savePos.get(i).y;
                            animCps.get(i).getPosition().x -= x1 / animSteps;
                            animCps.get(i).getPosition().y -= y1 / animSteps;
                        }
                        repaint();
                        animDuration -= animDelay;
                        animSteps--;
                    } else {
                        animDuration = ANIMTIME;
                        animSteps = animDuration / animDelay;
                        animT.stop();
                        for (int i = 0; i < animCps.size(); i++) {
                            animCps.get(i).getPosition().x = savePos.get(i).x;
                            animCps.get(i).getPosition().y = savePos.get(i).y;
                        }

                        controller.calculateStateForCurrentTimeStep();
                        repaint();
                    }
                }
            });
            animT.start();
        });

        // adds the selected object(s) to the statistic panel
        itemTrack.addActionListener(actionEvent -> {
            for (AbstractCpsObject o : model.getSelectedCpsObjects()) {
                boolean found = false;
                if (controller.getTrackingObj() != null) {
                    if (controller.getTrackingObj().contains(o)) {
                        found = true;
                    }
                }
                if (!found) {
                    controller.addTrackingObj(o);
                    if (o instanceof HolonObject) {
                        ((HolonObject) o).updateTrackingInfo();
                    }
                }
                if (model.getShowConsoleLog()) {
                    controller.addTextToConsole("Tracking: ", Color.BLACK, 12, false, false, false);
                    controller.addTextToConsole("" + o.getName(), Color.BLUE, 12, true, false, false);
                    controller.addTextToConsole(", ID:", Color.BLACK, 12, false, false, false);
                    controller.addTextToConsole("" + o.getId(), Color.RED, 12, true, false, true);
                }
            }
        });

        itemUntrack.addActionListener(actionEvent -> {
            for (AbstractCpsObject o : model.getSelectedCpsObjects()) {
                if (o instanceof HolonObject) {
                    boolean found = false;
                    if (controller.getTrackingObj() != null) {
                        for (AbstractCpsObject obj : controller.getTrackingObj()) {
                            if (obj instanceof HolonObject) {
                                if (obj.getId() == o.getId()) {
                                    found = true;
                                }
                            }
                        }
                    }
                    if (found) {
                        // Removed from tracking array and tracking
                        // information reseted
                        controller.removeTrackingObj(o);
                        ((HolonObject) o).setTrackingProd(new float[100]);
                        ((HolonObject) o).setTrackingCons(new float[100]);
                    }
                    if (model.getShowConsoleLog()) {
                        controller.addTextToConsole("Untracking: ", Color.BLACK, 12, false, false, false);
                        controller.addTextToConsole("" + o.getName(), Color.BLUE, 12, true, false, false);
                        controller.addTextToConsole(", ID:", Color.BLACK, 12, false, false, false);
                        controller.addTextToConsole("" + o.getId(), Color.RED, 12, true, false, true);
                    }
                }
            }
        });

        itemDelete.addActionListener(actionEvent -> {
            // Remove the selected Object objects
            boolean save = false;
            for (int j = 0; j < model.getSelectedCpsObjects().size(); j++) {
                AbstractCpsObject cps = model.getSelectedCpsObjects().get(j);
                if (j == model.getSelectedCpsObjects().size() - 1)
                    save = true;
                controller.delCanvasObject(cps, save);
                controller.removeTrackingObj(cps);
                // Remove UpperNodeTab if UpperNode deleted
                if (cps instanceof CpsUpperNode) {
                    JSplitPane tempSplit = (JSplitPane) getParent().getParent().getParent().getParent();
                    JTabbedPane tabbedPane;
                    JTabbedPane tabbedPane2;
                    // if SplitView is activated
                    if (tempSplit.getLeftComponent() instanceof JTabbedPane
                            && tempSplit.getRightComponent() instanceof JTabbedPane) {
                        tabbedPane = (JTabbedPane) tempSplit.getLeftComponent();
                        tabbedPane2 = (JTabbedPane) tempSplit.getRightComponent();
                    } else {
                        tabbedPane = (JTabbedPane) tempSplit.getLeftComponent();
                        tabbedPane2 = null;
                    }
                    // Look if the uppernode is open in a Tab
                    for (int i = 4; i < tabbedPane.getTabCount(); i++) {
                        if (tabbedPane.getComponentAt(i) == null) {
                        } else if (((UpperNodeCanvas) ((JScrollPane) tabbedPane.getComponentAt(i)).getViewport()
                                .getComponent(0)).upperNode.getId() == cps.getId()) {
                            ((ButtonTabComponent) tabbedPane.getTabComponentAt(i)).removeTabs();
                            break;
                        }
                    }
                    // If SplitView is on and the view on
                    // tabbedPane2 is the deleted upperNode
                    try {
                        if (tabbedPane2 != null
                                && ((UpperNodeCanvas) ((JScrollPane) tabbedPane2.getSelectedComponent())
                                .getViewport().getComponent(0)).upperNode.getId() == cps.getId()) {
                            ((ButtonTabComponent) tabbedPane.getTabComponentAt(tabbedPane2.getSelectedIndex()))
                                    .removeTabs();
                        }
                    } catch (Exception e2) {
                    }
                }
                toolTip = false;
            }
            model.getSelectedCpsObjects().clear();
            tempCps = null;
            repaint();
        });

        itemCut.addActionListener(actionEvent
                -> {
            controller.cut(null);
            itemPaste.setEnabled(true);
            repaint();
        });

        itemCopy.addActionListener(actionEvent -> {
            controller.copy(null);
            itemPaste.setEnabled(true);
            repaint();
        });

        itemPaste.addActionListener(actionEvent -> {
            try {
                controller.paste(null, mousePosition);
                unitGraph.update(model.getSelectedCpsObjects());

            } catch (JsonParseException | UnsupportedFlavorException | IOException e1) {
                // TODO Auto-generated catch block
                JLabel message = new JLabel("The Clipboard information cannot be pastet into Application.");
                JOptionPane.showMessageDialog(null, message, "", JOptionPane.ERROR_MESSAGE);
            }
            repaint();
        });

        this.addMouseListener(this);
        this.addMouseMotionListener(this);
    }

    /**
     * Paints all Components on the Canvas.
     *
     * @param g Graphics
     */
    public void paintComponent(Graphics g) {
        String maxCap;
        super.paintComponent(g);
        // Rendering
        g2 = (Graphics2D) g;
        RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setRenderingHints(rh);

        // Paint the Background
        if (!model.getCanvasImagePath().isEmpty()) {
            img = new ImageIcon(model.getCanvasImagePath()).getImage();
            switch (model.getCanvasImageMode()) {
                case BackgroundPopUp.IMAGE_PIXELS:
                    g2.drawImage(img, 0, 0, img.getWidth(null), img.getHeight(null), null);
                    break;
                case BackgroundPopUp.STRETCHED:
                    g2.drawImage(img, 0, 0, model.getCanvasX(), model.getCanvasY(), null);
                    break;
                case BackgroundPopUp.CUSTOM:
                    g2.drawImage(img, 0, 0, model.getCanvasImageWidth(), model.getCanvasImageHeight(), null);
                    break;
                default:
                    break;
            }
        }

        // SubNet Coloring
        int i = 0;
        for (SubNet s : controller.getSimManager().getSubNets()) {

            if (model.getSubNetColors().size() - 1 < i) {
                controller.addSubNetColor(new Color((int) (Math.random() * 255), (int) (Math.random() * 255),
                        (int) (Math.random() * 255)));
            }
            if (showedInformation[3]) {
                for (HolonObject cps : s.getObjects()) {
                    cps.setBorderColor(model.getSubNetColors().get(i));
                }
            }
            i++;
        }

        // drawEdges that is being dragged
        if (drawEdge) {
            g2.setColor(Color.BLACK);
            g2.setStroke(new BasicStroke(2));
            g2.drawLine(tempCps.getPosition().x, tempCps.getPosition().y, x, y);
        }

        for (CpsEdge con : model.getEdgesOnCanvas()) {
            if (con.getA().getId() != model.getSelectedObjectID() && con.getB().getId() != model.getSelectedObjectID()
                    && con != edgeHighlight) {
                if (con.getConnected() == 0) {
                    if (con.getState()) {
                        g2.setColor(Color.GREEN);
                        if (con.getCapacity() != -1) {
                            g2.setStroke(new BasicStroke(Math.min(((con.getFlow() / con.getCapacity() * 3) + 1), 4)));
                        }
                    } else {
                        g2.setColor(Color.RED);
                        g2.setStroke(new BasicStroke(2));
                    }
                } else {
                    g2.setColor(Color.DARK_GRAY);
                    g2.setStroke(new BasicStroke(2));
                }
                g2.drawLine(con.getA().getPosition().x, con.getA().getPosition().y, con.getB().getPosition().x,
                        con.getB().getPosition().y);

                if (con.getCapacity() == -1) {
                    maxCap = Character.toString('\u221e');
                } else if (con.getCapacity() == -2) {
                    maxCap = "???";
                } else {
                    maxCap = String.valueOf(con.getCapacity());
                }
                if (showedInformation[0]) {
                    if (con.getConnected() == 0 || con.getConnected() == 1) {
                        g2.drawString(con.getFlow() + "/" + maxCap,
                                (con.getA().getPosition().x + con.getB().getPosition().x) / 2,
                                (con.getA().getPosition().y + con.getB().getPosition().y) / 2);
                    } else {
                        g2.drawString("not connected", (con.getA().getPosition().x + con.getB().getPosition().x) / 2,
                                (con.getA().getPosition().y + con.getB().getPosition().y) / 2);
                    }
                }
            }
        }

        // Highlighted Edge
        if (model.getSelectedObjectID() > 0 || !model.getSelectedCpsObjects().isEmpty() || !tempSelected.isEmpty()) {
            g2.setColor(Color.BLUE);
            for (CpsEdge con : model.getEdgesOnCanvas()) {
                if (con.getFlow() <= con.getCapacity()) {
                    g2.setStroke(new BasicStroke(Math.min(((con.getFlow() / con.getCapacity() * 3) + 1), 4)));
                } else {
                    g2.setStroke(new BasicStroke(2));
                }
                if (con.getA().getId() == model.getSelectedObjectID()
                        || model.getSelectedCpsObjects().contains(con.getA()) || tempSelected.contains(con.getA())
                        || con.getB().getId() == model.getSelectedObjectID()
                        || model.getSelectedCpsObjects().contains(con.getB())
                        || tempSelected.contains(con.getB()) && con != edgeHighlight) {
                    g2.drawLine(con.getA().getPosition().x, con.getA().getPosition().y, con.getB().getPosition().x,
                            con.getB().getPosition().y);

                    if (con.getCapacity() == -1) {
                        maxCap = Character.toString('\u221e');
                    } else if (con.getCapacity() == -2) {
                        maxCap = "???";
                    } else {
                        maxCap = String.valueOf(con.getCapacity());
                    }
                    if (showedInformation[0]) {
                        if (con.getConnected() == 0 || con.getConnected() == 1) {
                            g2.drawString(con.getFlow() + "/" + maxCap,
                                    (con.getA().getPosition().x + con.getB().getPosition().x) / 2,
                                    (con.getA().getPosition().y + con.getB().getPosition().y) / 2);
                        } else {
                            g2.drawString("not connected",
                                    (con.getA().getPosition().x + con.getB().getPosition().x) / 2,
                                    (con.getA().getPosition().y + con.getB().getPosition().y) / 2);
                        }
                    }
                }
            }
        } else if (edgeHighlight != null) {
            g2.setColor(Color.BLUE);
            if (edgeHighlight.getFlow() <= edgeHighlight.getCapacity()) {
                g2.setStroke(new BasicStroke(
                        Math.min(((edgeHighlight.getFlow() / edgeHighlight.getCapacity() * 3) + 1), 4)));
            } else {
                g2.setStroke(new BasicStroke(2));
            }
            g2.drawLine(edgeHighlight.getA().getPosition().x, edgeHighlight.getA().getPosition().y,
                    edgeHighlight.getB().getPosition().x, edgeHighlight.getB().getPosition().y);

            if (edgeHighlight.getCapacity() == -1) {
                maxCap = Character.toString('\u221e');
            } else if (edgeHighlight.getCapacity() == -2) {
                maxCap = "???";
            } else {
                maxCap = String.valueOf(edgeHighlight.getCapacity());
            }
            if (showedInformation[0]) {
                g2.drawString(edgeHighlight.getFlow() + "/" + maxCap,
                        (edgeHighlight.getA().getPosition().x + edgeHighlight.getB().getPosition().x) / 2,
                        (edgeHighlight.getA().getPosition().y + edgeHighlight.getB().getPosition().y) / 2);
            }
        }

        // Objects
        for (AbstractCpsObject cps : model.getObjectsOnCanvas()) {
            // Border Highlighting
            if (showedInformation[3]) {
                g2.setColor(cps.getBorderColor());
                if (g2.getColor() != Color.WHITE && !(cps instanceof CpsNode)) {
                    g2.fillRect((int) (cps.getPosition().x - controller.getScaleDiv2() - scalediv20 - 3),
                            (int) (cps.getPosition().y - controller.getScaleDiv2() - scalediv20 - 3),
                            (int) (controller.getScale() + ((scalediv20 + 3) * 2)),
                            (int) (controller.getScale() + ((scalediv20 + 3) * 2)));
                }
            }
            // node image
            if (cps instanceof CpsNode && (cps == tempCps || model.getSelectedCpsObject() == cps
                    || model.getSelectedCpsObjects().contains(cps) || tempSelected.contains(cps))) {
                img = new ImageIcon(this.getClass().getResource("/Images/node_selected.png")).getImage();
            } else {
                if (cps instanceof HolonSwitch) {
                    if (((HolonSwitch) cps).getActiveAt()[model.getCurIteration()]) {
                        ((HolonSwitch) cps).setAutoState(true);
                    } else {
                        ((HolonSwitch) cps).setAutoState(false);
                    }
                }
                // Highlighting
                if ((cps == tempCps && model.getSelectedCpsObjects().size() == 0 && tempSelected.size() == 0)
                        || model.getSelectedCpsObjects().contains(cps) || tempSelected.contains(cps)) {
                    g2.setColor(Color.BLUE);
                    g2.fillRect((int) (cps.getPosition().x - controller.getScaleDiv2() - scalediv20),
                            (int) (cps.getPosition().y - controller.getScaleDiv2() - scalediv20),
                            (int) (controller.getScale() + (scalediv20 * 2)),
                            (int) (controller.getScale() + (scalediv20 * 2)));
                    if (showedInformation[1] && cps instanceof HolonObject) {
                        g2.setColor(Color.BLACK);
                        float totalEnergy = ((HolonObject) cps).getCurrentEnergyAtTimeStep(model.getCurIteration());
                        g2.drawString(Float.toString(totalEnergy), cps.getPosition().x - controller.getScaleDiv2(),
                                cps.getPosition().y - controller.getScaleDiv2() - 10);
                    }
                } else if (cps instanceof HolonObject) {
                    g2.setColor(((HolonObject) cps).getColor());

                    g2.fillRect((int) (cps.getPosition().x - controller.getScaleDiv2() - scalediv20),
                            (int) (cps.getPosition().y - controller.getScaleDiv2() - scalediv20),
                            (int) (controller.getScale() + (scalediv20 * 2)),
                            (int) (controller.getScale() + (scalediv20 * 2)));

                    if (showedInformation[1]) {
                        g2.setColor(Color.BLACK);
                        float totalEnergy = ((HolonObject) cps).getCurrentEnergyAtTimeStep(model.getCurIteration());
                        g2.drawString(Float.toString(totalEnergy), cps.getPosition().x - controller.getScaleDiv2(),
                                cps.getPosition().y - controller.getScaleDiv2() - 10);
                    }
                }
                // draw image
                File checkPath = new File(cps.getImage());
                if (checkPath.exists()) {
                    img = new ImageIcon(cps.getImage()).getImage();
                } else {
                    img = new ImageIcon(this.getClass().getResource(cps.getImage())).getImage();
                }
            }
            g2.drawImage(img, cps.getPosition().x - controller.getScaleDiv2(),
                    cps.getPosition().y - controller.getScaleDiv2(), controller.getScale(), controller.getScale(),
                    null);

        }

        // Dragged marker Highlighting
        if (doMark) {
            g2.setColor(Color.BLACK);
            g2.setStroke(new BasicStroke(1));
            if (sx > x && sy > y) {
                g2.drawRect(x, y, sx - x, sy - y);
            } else if (sx < x && sy < y) {
                g2.drawRect(sx, sy, x - sx, y - sy);
            } else if (sx >= x) {
                g2.drawRect(x, sy, sx - x, y - sy);
            } else if (sy >= y) {
                g2.drawRect(sx, y, x - sx, sy - y);
            }
        }
        // Tooltip
        if (toolTip) {
            g2.setColor(new Color(255, 225, 150));
            g2.setStroke(new BasicStroke(1));
            int textWidth = g.getFontMetrics().stringWidth(toolTipText) + 2; // Text
            // width

            // fixed x and y Position to the screen
            int fixXPos = toolTipPos.x - (textWidth >> 1) + model.getScaleDiv2();
            int fixYPos = toolTipPos.y;

            if (fixXPos < 0) {
                fixXPos = 0;
            } else if (fixXPos + textWidth + 1 > this.getWidth()) {
                fixXPos -= (fixXPos + textWidth + 1) - this.getWidth();
            }
            if (fixYPos + 16 > this.getHeight()) {
                fixYPos -= (fixYPos + 16) - this.getHeight();
            }
            g2.fillRect(fixXPos, fixYPos, textWidth, 15);
            g2.setColor(Color.BLACK);
            g2.drawRect(fixXPos, fixYPos, textWidth, 15);
            g2.drawString(toolTipText, fixXPos + 2, fixYPos + 12);
        }
    }

    @Override
    public void mouseClicked(MouseEvent e) {
        if (e.getButton() == MouseEvent.BUTTON1) {
            if (model.getPropertyTable().getRowCount() > 0) {
                for (int i = model.getPropertyTable().getRowCount() - 1; i > -1; i--) {
                    model.getPropertyTable().removeRow(i);
                }
            }
            updCon.paintProperties(tempCps);
            updCon.refreshTableHolonElement(model.getMultiTable(), model.getSingleTable());
            updCon.refreshTableProperties(model.getPropertyTable());
        }
    }

    @Override
    public void mouseEntered(MouseEvent e) {
    }

    @Override
    public void mouseExited(MouseEvent e) {
    }

    @Override
    public void mousePressed(MouseEvent e) {
        tempCps = null;
        edgeHighlight = null;
        controller.setSelecteEdge(null);
        // Object Selection
        for (AbstractCpsObject cps : model.getObjectsOnCanvas()) {
            cx = cps.getPosition().x - controller.getScaleDiv2();
            cy = cps.getPosition().y - controller.getScaleDiv2();
            if (x - controller.getScale() <= cx && y - controller.getScale() <= cy && x >= cx && y >= cy) {
                tempCps = cps;
                if (model.getShowConsoleLog()) {
                    controller.addTextToConsole("Selected: ", Color.BLACK, 12, false, false, false);
                    controller.addTextToConsole("" + cps.getName(), Color.BLUE, 12, true, false, false);
                    controller.addTextToConsole(", ID:", Color.BLACK, 12, false, false, false);
                    controller.addTextToConsole("" + cps.getId(), Color.RED, 12, true, false, true);
                }
                dragging = true;
                if (e.isControlDown() && tempCps != null) {
                    if (model.getSelectedCpsObjects().contains(tempCps)) {
                        controller.deleteSelectedObject(tempCps);
                    } else {
                        controller.addSelectedObject(tempCps);
                    }

                }

                // If drawing an Edge (CTRL down)
                if (tempCps.getClass() == HolonObject.class) {
                    HolonObject tempObj = ((HolonObject) tempCps);
                    dataSelected = tempObj.getElements();
                }
                if (e.isShiftDown()) {
                    drawEdge = true;
                    dragging = false;
                }
            }
        }

        // Edge Selection
        if (tempCps == null) {
            edgeHighlight = mousePositionOnEdge(x, y);
            controller.setSelecteEdge(edgeHighlight);
            controller.setSelectedObjectID(0);
            if (!e.isControlDown() && e.getButton() != MouseEvent.BUTTON3) {
                model.getSelectedCpsObjects().clear();
            }
        }

        if (edgeHighlight == null && tempCps == null) {
            sx = e.getX();
            sy = e.getY();
            doMark = true;
        }

        repaint();
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        x = e.getX();
        y = e.getY();

        dragging = false;

        if (drawEdge) {
            drawEdge = false;
            drawDeleteEdge();
        }

        if (dragged) {
            try {
                controller.autoSave();
            } catch (IOException ex) {
                // TODO Auto-generated catch block
                ex.printStackTrace();
            }
        }

        if (!e.isControlDown() && !dragged && tempCps != null && MouseEvent.BUTTON3 != e.getButton()) {
            model.getSelectedCpsObjects().clear();
            controller.addSelectedObject(tempCps);
        }

        dragged = false;

        // Rightclick List
        if (e.getButton() == MouseEvent.BUTTON3) {
            if (e.getButton() == MouseEvent.BUTTON3 && tempCps != null) {
                itemDelete.setEnabled(true);
                itemCut.setEnabled(true);
                itemCopy.setEnabled(true);
                if (tempCps != null) {
                    itemGroup.setEnabled(true);
                    itemTrack.setEnabled(true);
                    itemUntrack.setEnabled(true);
                }
                if (tempCps instanceof CpsUpperNode)
                    itemUngroup.setEnabled(true);
                else
                    itemUngroup.setEnabled(false);
                if (model.getSelectedCpsObjects().size() == 0) {
                    controller.addSelectedObject(tempCps);
                }
            } else {
                itemCut.setEnabled(false);
                itemCopy.setEnabled(false);
                itemDelete.setEnabled(false);
                itemGroup.setEnabled(false);
                itemUngroup.setEnabled(false);
                itemTrack.setEnabled(false);
                itemUntrack.setEnabled(false);
            }
            mousePosition = this.getMousePosition();
            popmenu.show(e.getComponent(), e.getX(), e.getY());
        }

        if (doMark) {
            doMark = false;
            for (AbstractCpsObject cps : tempSelected) {
                if (!model.getSelectedCpsObjects().contains(cps)) {
                    controller.addSelectedObject(cps);
                }
            }
            controller.getObjectsInDepth();
            tempSelected.clear();
        }

        if (doubleClick() && tempCps != null && tempCps instanceof HolonSwitch && MouseEvent.BUTTON3 != e.getButton()) {
            ((HolonSwitch) tempCps).switchState();
        }

        controller.calculateStateForTimeStep(model.getCurIteration());

        updCon.refreshTableHolonElement(model.getMultiTable(), model.getSingleTable());
        updCon.refreshTableProperties(model.getPropertyTable());

        repaint();

    }

    @Override
    public void mouseDragged(MouseEvent e) {
        // If Edge is drawn
        x = e.getX();
        y = e.getY();
        if (!model.getSelectedCpsObjects().contains(tempCps) && !doMark) {
            model.getSelectedCpsObjects().clear();
            if (tempCps != null) {
                controller.addSelectedObject(tempCps);
            }
        }
        if (dragging) {
            try {
                dragged = true;
                float xDist, yDist; // Distance

                x = e.getX();
                y = e.getY();

                // Make sure its in bounds
                if (e.getX() < controller.getScaleDiv2())
                    x = controller.getScaleDiv2();
                else if (e.getX() > this.getWidth() - controller.getScaleDiv2())
                    x = this.getWidth() - controller.getScaleDiv2();
                if (e.getY() < controller.getScaleDiv2())
                    y = controller.getScaleDiv2();
                else if (e.getY() > this.getHeight() - controller.getScaleDiv2())
                    y = this.getHeight() - controller.getScaleDiv2();

                // Distance
                xDist = x - tempCps.getPosition().x;
                yDist = y - tempCps.getPosition().y;

                tempCps.setPosition(x, y); // Drag Position
                // ToolTipText Position and name
                toolTip = true;
                toolTipText = tempCps.getName() + ", " + tempCps.getId();
                toolTipPos.x = tempCps.getPosition().x - controller.getScaleDiv2();
                toolTipPos.y = tempCps.getPosition().y + controller.getScaleDiv2();

                // All Selected Objects
                for (AbstractCpsObject cps : model.getSelectedCpsObjects()) {
                    if (cps != tempCps) {
                        x = (int) (cps.getPosition().x + xDist);
                        y = (int) (cps.getPosition().y + yDist);

                        // Make sure its in bounds
                        if (x <= controller.getScaleDiv2())
                            x = controller.getScaleDiv2();
                        else if (x > this.getWidth() - controller.getScaleDiv2())
                            x = this.getWidth() - controller.getScaleDiv2();
                        if (y <= controller.getScaleDiv2())
                            y = controller.getScaleDiv2();
                        else if (y > this.getHeight() - controller.getScaleDiv2())
                            y = this.getHeight() - controller.getScaleDiv2();

                        cps.setPosition(x, y);
                    }
                }
                repaint();
            } catch (Exception eex) {

            }
        }

        // Mark Objects
        if (doMark) {
            tempSelected.clear();
            for (AbstractCpsObject cps : model.getObjectsOnCanvas()) {
                int x1 = sx, x2 = x, y1 = sy, y2 = y;

                if (sx >= x) {
                    x1 = x;
                    x2 = sx;
                }
                if (sy >= y) {
                    y1 = y;
                    y2 = sy;
                }
                if (x1 <= cps.getPosition().x + model.getScaleDiv2() && y1 <= cps.getPosition().y + model.getScaleDiv2()
                        && x2 >= cps.getPosition().x && y2 >= cps.getPosition().y) {
                    tempSelected.add(cps);

                }
            }
        }

        repaint();

    }

    @Override
    public void mouseMoved(MouseEvent e) {
        x = e.getX();
        y = e.getY();

        // Everytghing for the tooltip :)
        boolean on = false;
        for (AbstractCpsObject cps : model.getObjectsOnCanvas()) {
            cx = cps.getPosition().x - controller.getScaleDiv2();
            cy = cps.getPosition().y - controller.getScaleDiv2();
            if (x - controller.getScale() <= cx && y - controller.getScale() <= cy && x >= cx && y >= cy) {
                on = true;
                toolTipPos.x = cps.getPosition().x - controller.getScaleDiv2();
                toolTipPos.y = cps.getPosition().y + controller.getScaleDiv2();
                toolTipText = cps.getName() + ", " + cps.getId();
            }
        }
        toolTip = on;
        repaint();
    }

    /**
     * Draws or Deletes an Edge.
     */
    private void drawDeleteEdge() {
        if (getMousePosition() != null) {
            boolean node = true;
            boolean newEdge = true;
            boolean onEdge = true;
            boolean deleteNode = false;
            CpsEdge e = null;
            for (AbstractCpsObject cps : model.getObjectsOnCanvas()) {
                cx = cps.getPosition().x - controller.getScaleDiv2();
                cy = cps.getPosition().y - controller.getScaleDiv2();
                if (x - controller.getScale() <= cx && y - controller.getScale() <= cy && x >= cx && y >= cy
                        && cps != tempCps) {
                    node = false;
                    onEdge = false;
                    for (CpsEdge p : tempCps.getConnections()) {
                        if ((p.getA() == tempCps && p.getB() == cps) || (p.getB() == tempCps && p.getA() == cps)) {
                            newEdge = false;
                            e = p;
                        }
                    }
                    if (!newEdge) {
                        controller.removeEdgesOnCanvas(e);
                        // Node ohne Edge?
                        if (e.getA().getClass() == CpsNode.class && e.getA().getConnections().isEmpty()) {
                            tempCps = e.getA();
                            deleteNode = true;
                        }
                        if (e.getB().getClass() == CpsNode.class && e.getB().getConnections().isEmpty()) {
                            deleteNode = true;
                        }
                    }
                    if (newEdge) {
                        e = new CpsEdge(cps, tempCps, model.getMaxCapacity());
                        controller.addEdgeOnCanvas(e);
                    }
                }
            }
            // Edge auf eine Edge gezogen?
            if (onEdge) {
                CpsEdge p = mousePositionOnEdge(x, y);
                if (p != null) {
                    CpsEdge e1;
                    CpsEdge e2;

                    node = false;

                    CpsNode n = new CpsNode("Node");

                    n.setPosition(x, y);
                    controller.addObjectCanvas(n);

                    AbstractCpsObject r, k;
                    r = p.getA();
                    k = p.getB();

                    e = new CpsEdge(n, tempCps, model.getMaxCapacity());

                    e1 = new CpsEdge(n, r, model.getMaxCapacity());

                    e2 = new CpsEdge(n, k, model.getMaxCapacity());

                    controller.removeEdgesOnCanvas(p);
                    controller.addEdgeOnCanvas(e);
                    controller.addEdgeOnCanvas(e1);
                    controller.addEdgeOnCanvas(e2);
                }
            }

            // ins leere Gedragged
            if (node) {
                CpsNode n = new CpsNode("Node");

                n.setPosition(x, y);
                controller.addObjectCanvas(n);

                e = new CpsEdge(n, tempCps, model.getMaxCapacity());

                controller.addEdgeOnCanvas(e);
            }

            // Wenn ein Node ohne Connections da ist
            if (deleteNode) {
                controller.delCanvasObject(tempCps, true);
                tempCps = null;
            }
        }
    }

    /**
     * Checks if the mouse is on an Edge.
     *
     * @param x Position of the Mouse
     * @param y Position of the Mouse
     * @return CpsEdge the Mouse is on, null if the mouse is not on an Edge
     */
    private CpsEdge mousePositionOnEdge(int x, int y) {
        x += controller.getScaleDiv2();
        y += controller.getScaleDiv2();
        int lx, ly, hx, hy;
        for (CpsEdge p : model.getEdgesOnCanvas()) {
            Line2D l = new Line2D.Float(p.getA().getPosition().x, p.getA().getPosition().y, p.getB().getPosition().x,
                    p.getB().getPosition().y);
            if (p.getA().getPosition().x > p.getB().getPosition().x) {
                hx = p.getA().getPosition().x + model.getScaleDiv2() + 7;
                lx = p.getB().getPosition().x + model.getScaleDiv2() - 7;
            } else {
                lx = p.getA().getPosition().x + model.getScaleDiv2() - 7;
                hx = p.getB().getPosition().x + model.getScaleDiv2() + 7;
            }
            if (p.getA().getPosition().y > p.getB().getPosition().y) {
                hy = p.getA().getPosition().y + model.getScaleDiv2() + 7;
                ly = p.getB().getPosition().y + model.getScaleDiv2() - 7;
            } else {
                ly = p.getA().getPosition().y + model.getScaleDiv2() - 7;
                hy = p.getB().getPosition().y + model.getScaleDiv2() + 7;
            }

            // distance from a point to a line and between both Objects
            if (l.ptLineDistSq(x - model.getScaleDiv2(), y - model.getScaleDiv2()) < 20 && x > lx && x < hx && y > ly
                    && y < hy) {
                return p;
            }
        }
        return null;
    }

    public void updateLanguages() {
        itemCut.setText(Languages.getLanguage()[95]);
        itemCopy.setText(Languages.getLanguage()[96]);
        itemPaste.setText(Languages.getLanguage()[97]);
        itemDelete.setText(Languages.getLanguage()[98]);
        itemGroup.setText(Languages.getLanguage()[99]);
        itemUngroup.setText(Languages.getLanguage()[100]);
        itemTrack.setText(Languages.getLanguage()[101]);
        itemUntrack.setText(Languages.getLanguage()[102]);
    }

    /**
     * Checks if a double click was made.
     *
     * @return true if doublecklick, false if not
     */
    private boolean doubleClick() {
        if (click) {
            click = false;
            return true;
        } else {
            click = true;
            Timer t = new Timer("doubleclickTimer", false);
            t.schedule(new TimerTask() {
                @Override
                public void run() {
                    click = false;
                }
            }, 500);
        }
        return false;
    }

    /**
     * Set if Information should be shown.
     *
     * @param connection boolean for conecction
     * @param object     boolean for objects
     * @param nodeOfnode
     */
    public void setShowedInformation(boolean connection, boolean object, boolean border, boolean nodeOfnode) {
        showedInformation[0] = connection;
        showedInformation[1] = object;
        showedInformation[3] = border;
        showedInformation[4] = nodeOfnode;
    }

    /**
     * Returns if Information should be shown.
     *
     * @return Array of boolean [0] = connection, [1] = objects
     */
    public boolean[] getShowedInformation() {
        return showedInformation;
    }

    /**
     * set toolTip
     *
     * @param bool
     */
    public void setToolTip(boolean bool) {
        this.toolTip = bool;
    }

    /**
     * Set the Mouse
     *
     * @param x
     * @param y
     */
    public void setXY(int x, int y) {
        this.x = x;
        this.y = y;
    }

}