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

package ui.view;

import java.io.File;
import java.util.ArrayList;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenuBar;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JTree;
import javax.swing.border.LineBorder;
import javax.swing.BoxLayout;
import javax.swing.JSplitPane;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTable;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeCellRenderer;

import ui.controller.Control;
import ui.model.*;

import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.JEditorPane;
import javax.swing.JFileChooser;
import javax.swing.table.DefaultTableModel;
import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.BorderLayout;

import javax.swing.JPanel;
import javax.swing.JToolBar;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.DefaultComboBoxModel;
import javax.swing.ImageIcon;

import classes.Category;
import classes.CpsEdge;
import classes.CpsObject;
import classes.HolonElement;
import classes.HolonObject;
import classes.HolonSwitch;
import classes.HolonTransformer;
import Interfaces.CategoryListener;

import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.awt.event.ActionEvent;
import javax.swing.JSlider;
import javax.swing.event.ChangeListener;
import javax.swing.event.ChangeEvent;

public class GUI implements CategoryListener {

	private JFrame frmCyberPhysical;

	private final JMenuBar menuBar = new JMenuBar();
	private final JMenu mnNewMenu = new JMenu("File");
	private final JMenu mnNewMenu_1 = new JMenu("Edit");
	private final JMenu mnNewMenu_2 = new JMenu("Options");
	private final JMenu mnNewMenu_3 = new JMenu("View");
	private final JMenu mnHelp = new JMenu("Help");
	private final JMenuItem mntmOpen = new JMenuItem("Open");
	private final JMenuItem mntmNew = new JMenuItem("New");
	private final JMenuItem mntmSave = new JMenuItem("Save");
	private final JMenuItem aboutUs = new JMenuItem("About Us");
	private final JSplitPane splitPane = new JSplitPane();
	private final JSplitPane splitPane_1 = new JSplitPane();
	private final JScrollPane scrollPane_1 = new JScrollPane();
	private final JTabbedPane tabbedPane = new JTabbedPane(JTabbedPane.TOP);
	private final JScrollPane scrollPane_2 = new JScrollPane();

	private final JLabel maxGraph = new JLabel("100%");
	private final JLabel medGraph = new JLabel("50%");
	private final JLabel minGraph = new JLabel("0%");
	private final JLabel elementGraph = new JLabel("None ");

	private final JTree tree = new JTree();
	private final JEditorPane dtrpnHereWillBe = new JEditorPane();
	/******************************************
	 ************* Right Container*************
	 ******************************************/
	// Right Container: here comes the information about the HolonObject, such
	// as HolonElements Information, Properties and Consumption/Production graph

	private final JSplitPane split_HolonEl_Pro = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
	private final JSplitPane split_Graph_HolonEl = new JSplitPane(JSplitPane.VERTICAL_SPLIT);

	// In this section are all the Holonelements that correspond to the clicked
	// HolonObject with consumption/production, name and amount.

	private JTable tableHolonElement = new JTable();
	private DefaultTableModel tableModelHolonElement = new DefaultTableModel();
	private final JPanel scrollElements = new JPanel();
	JScrollPane tableHolonElementScrollPane = new JScrollPane();

	// In this section are all the properties that correspond to the clicked
	// HolonObject, such as connections, name, Type, etc.

	private JTable tableProperties = new JTable();
	private DefaultTableModel tableModelProperties = new DefaultTableModel();
	private final JScrollPane scrollProperties = new JScrollPane();

	// In this section is the graph for the selected HolonElement of the clicked
	// HolonObject

	private JTable tableGraph = new JTable();
	private DefaultTableModel tableModelGraph = new DefaultTableModel();
	private final JScrollPane scrollGraph = new JScrollPane();

	private final Model model;
	private final Control controller;

	// Pop up Windows
	private AddObjectPopUp addObjectPopUP;
	private AboutUsPopUp aboutUsPopUp;
	private AddElementPopUp addElementPopUp;

	private final JPanel panel = new JPanel();
	private final JPanel panel_HolonEl = new JPanel();
	private final JComboBox comboBox = new JComboBox();
	private final JComboBox comboBoxGraph = new JComboBox();

	// Buttons
	private final JButton btnAdd = new JButton("+");
	private final JButton btnDel = new JButton("-");
	private final JButton btnAddHolEL = new JButton("+");
	private final JButton btnDelHolEL = new JButton("-");
	private final JButton resetGraphBtn = new JButton("Reset");

	private final JToolBar toolBar = new JToolBar();
	private final JToolBar toolBarHolonEl = new JToolBar();
	private final JToolBar toolBarGraph = new JToolBar();

	// variables
	private boolean dragging = false;
	private String actualObjectClicked;
	private Image img = null;
	private CpsObject tempCps = null;
	private HolonElement tempElement = null;
	private int yValueElements = 0;

	private MyCanvas canvas;
	private UnitGraph testgraph; // for testing, remove later
	private final JSplitPane splitPane_3 = new JSplitPane();
	private final JSlider sizeSlider = new JSlider();
	private final JLabel lblImageSize = new JLabel("Image Size");
	// Time Stuff
	private final TimePanel timePanel;

	/**
	 * Create the application.
	 */
	public GUI(Control control) {
		this.controller = control;
		this.model = control.getModel();
		this.canvas = new MyCanvas(model, control);
		this.testgraph = new UnitGraph(model, control); // for testing, remove

		timePanel = new TimePanel(model, controller);
		timePanel.setBorder(null);

		// later
		control.initListener(this);
		initialize();
		updateCategories(model.getCategories());
	}

	/**
	 * Initialize the contents of the frame.
	 */
	@SuppressWarnings({ "serial", "unchecked" })
	private void initialize() {
		frmCyberPhysical = new JFrame();
		frmCyberPhysical.setTitle("Cyber Physical Systems Model");
		frmCyberPhysical.setBounds(100, 100, 1000, 800);
		frmCyberPhysical.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		frmCyberPhysical.setJMenuBar(menuBar);

		frmCyberPhysical.setIconImage(new ImageIcon(this.getClass().getResource("/Images/Dummy_House.png")).getImage()
				.getScaledInstance(30, 30, Image.SCALE_SMOOTH));

		menuBar.add(mnNewMenu);

		mnNewMenu.add(mntmNew);

		mnNewMenu.add(mntmOpen);

		mnNewMenu.add(mntmSave);

		menuBar.add(mnNewMenu_1);

		menuBar.add(mnNewMenu_2);

		menuBar.add(mnNewMenu_3);

		mnNewMenu_3.add(splitPane_3);

		sizeSlider.setMinimum(15);
		sizeSlider.setMaximum(115);
		sizeSlider.addChangeListener(new ChangeListener() {
			@Override
			public void stateChanged(ChangeEvent e) {
				controller.setScale(sizeSlider.getValue());
				tree.setRowHeight(model.getScale());
				canvas.objectSelectionHighlighting();
				canvas.repaint();
			}
		});
		splitPane_3.setRightComponent(sizeSlider);

		splitPane_3.setLeftComponent(lblImageSize);

		menuBar.add(mnHelp);

		mnHelp.add(aboutUs);

		testgraph.setBackground(Color.WHITE);

		canvas.setBackground(Color.WHITE);
		canvas.setPreferredSize(new Dimension(10000, 10000));
		JScrollPane canvasSP = new JScrollPane(canvas);
		canvasSP.setBorder(null);

		tabbedPane.addTab("Modeling", new ImageIcon(new ImageIcon(this.getClass().getResource("/Images/home.png"))
				.getImage().getScaledInstance(30, 30, Image.SCALE_SMOOTH)), canvasSP, "Model a CPS");

		tabbedPane.addTab("Simulation",
				new ImageIcon(new ImageIcon(this.getClass().getResource("/Images/Dummy_House.png")).getImage()
						.getScaledInstance(30, 30, Image.SCALE_SMOOTH)),
				scrollPane_2, "Simulate the CPS");
		dtrpnHereWillBe.setText("Here will be the Simulation");

		scrollPane_2.setViewportView(dtrpnHereWillBe);

		/*
		 * Right Container Set up
		 */

		// Set up of the HolonElements section
		Object[] columnNames = { "Device", "Energy", "Quantity" };
		tableModelHolonElement.setColumnIdentifiers(columnNames);
		tableHolonElement.setBorder(null);
		tableHolonElement.setModel(tableModelHolonElement);
		tableHolonElement.setFillsViewportHeight(true);
		tableHolonElement.setCellSelectionEnabled(true);
		tableHolonElement.setColumnSelectionAllowed(true);

		// Set up of the Properties section
		Object[] colNames = { "Field", "Information" };
		tableModelProperties.setColumnIdentifiers(colNames);
		tableProperties.setModel(tableModelProperties);
		tableProperties.setFillsViewportHeight(true);
		tableProperties.setCellSelectionEnabled(true);
		tableProperties.setColumnSelectionAllowed(true);

		// Set up of the Graph section

		Object[] tempText = { "Here comes the graph for each clicked HolonElement" };
		tableModelGraph.setColumnIdentifiers(tempText);
		tableGraph.setModel(tableModelGraph);
		tableGraph.setFillsViewportHeight(true);
		tableGraph.setCellSelectionEnabled(true);
		tableGraph.setColumnSelectionAllowed(true);

		/*
		 * End of right container setup
		 */
		scrollProperties.setViewportView(tableProperties);
		tableHolonElementScrollPane.setViewportView(tableHolonElement);
		scrollGraph.setViewportView(testgraph);
		JPanel graphLabel = new JPanel();
		graphLabel.setLayout(new BoxLayout(graphLabel, BoxLayout.Y_AXIS));
		minGraph.setBounds(0, 150, 10, 10);
		graphLabel.add(maxGraph);
		graphLabel.add(medGraph);
		graphLabel.add(minGraph);
		toolBarGraph.add(elementGraph);
		comboBoxGraph.setModel(new DefaultComboBoxModel(new String[] { "Day", "Month", "Year" }));
		toolBarGraph.add(comboBoxGraph);
		toolBarGraph.add(resetGraphBtn);
		toolBarGraph.setFloatable(false);
		scrollGraph.setRowHeaderView(graphLabel);
		scrollGraph.setColumnHeaderView(toolBarGraph);
		scrollElements.setLayout(new BorderLayout(0, 0));
		scrollElements.add(panel_HolonEl, BorderLayout.NORTH);
		scrollElements.add(tableHolonElementScrollPane);

		panel_HolonEl.setLayout(new BoxLayout(panel_HolonEl, BoxLayout.X_AXIS));
		toolBarHolonEl.setFloatable(false);

		panel_HolonEl.add(toolBarHolonEl);
		toolBarHolonEl.add(btnAddHolEL);
		btnAddHolEL.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {
				CpsObject tempCpsObject = getActualCps();
				if (tempCpsObject != null && tempCpsObject.getClass() == HolonObject.class
						&& tempCpsObject.getID() != 0) {
					addElementPopUp = new AddElementPopUp();
					addElementPopUp.setVisible(true);
<<<<<<< HEAD
					controller.addElementCanvasObject(tempCpsObject.getID(), addElementPopUp.getElement().getEleName(),
							addElementPopUp.getElement().getAmount(), addElementPopUp.getElement().getEnergy());
=======
					controller.addElementCanvasObject(tempCpsObject.getID(),
							addElementPopUp.getElement().getEleName(), addElementPopUp.getElement().getAmount(),
							addElementPopUp.getElement().getEnergy());
					refreshTableHolonElement();
>>>>>>> e4dd5230480ec56a5237cc665a0168f4a8b095d8
				}
			}
		});
		resetGraphBtn.addActionListener(new ActionListener() {

			public void actionPerformed(ActionEvent arg0) {
				testgraph.reset();
			}
		});
		toolBarHolonEl.add(btnDelHolEL);
		btnDelHolEL.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {
				if (getActualCps().getClass() == HolonObject.class) {
					HolonObject obj = (HolonObject) getActualCps();
					tempElement = getActualHolonElement(obj, yValueElements);
					if (tempElement != null && obj.getClass() == HolonObject.class && obj.getID() != 0) {
						controller.deleteElementCanvas(obj.getID(), tempElement.getEleName());
						refreshTableHolonElement();
					}
				}
			}
		});

		tableHolonElement.addMouseListener(new MouseAdapter() {
			public void mousePressed(MouseEvent e) {
				HolonObject obj = (HolonObject) getActualCps();
				yValueElements = e.getY();
				HolonElement ele = getActualHolonElement(obj, yValueElements);
				if (ele != null) {
					elementGraph.setText(ele.getEleName() + " ");
					testgraph.repaintWithNewElement(ele);
				} else {
					elementGraph.setText("None ");
				}
			}
		});
		frmCyberPhysical.getContentPane().setLayout(new BorderLayout(0, 0));

		TreeCellRenderer customRenderer = new TreeCellRenderer() {
			@Override
			public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded,
					boolean leaf, int row, boolean hasFocus) {
				JLabel label = new JLabel();
				Image imgR = null;
				if (leaf) {
					for (Category cat : model.getCategories()) {
						for (CpsObject cps : cat.getObjects()) {
							if (value.toString().compareTo(cps.getCompareName()) == 0) {
								imgR = new ImageIcon(this.getClass().getResource(cps.getImage())).getImage()
										.getScaledInstance(controller.getScale(), controller.getScale(),
												java.awt.Image.SCALE_SMOOTH);
								if (imgR != null) {
									label.setIcon(new ImageIcon(imgR));
								}
								label.setText(cps.getName());
							}
						}
					}
				}
				tree.setRowHeight(controller.getScale());
				if (hasFocus) {
					label.setForeground(new Color(0, 0, 255));
					label.setOpaque(true);
				}
				if (label.getText().length() == 0) {
					label.setText(value.toString());
					if (value.toString().compareTo("Categories") != 0) {
						label.setIcon(new ImageIcon(this.getClass().getResource("/Images/folder.png")));
					}
				}

				return label;

			}
		};

		tree.setCellRenderer(customRenderer);

		tree.addMouseListener(new MouseAdapter() {
			public void mouseReleased(MouseEvent e) {
				try {
					if (dragging) {
						int x = (int) canvas.getMousePosition().getX();
						int y = (int) canvas.getMousePosition().getY();
						CpsObject h = null;
						if (tempCps.getClass() == HolonObject.class) {
							h = new HolonObject(tempCps);
						}
						if (tempCps.getClass() == HolonSwitch.class) {
							h = new HolonSwitch(tempCps);
						}
						if (tempCps.getClass() == HolonTransformer.class) {
							h = new HolonTransformer(tempCps);
						}

						h.setPosition(x, y);
						controller.addObjectCanvas(h);
						for (int i = 0; i < model.getObjectsOnCanvas().size(); i++) {
							CpsObject temp = model.getObjectsOnCanvas().get(i);
							String output = "Element: " + temp.getObjName() + " with ID: " + temp.getID();

							if (temp.getClass() == HolonObject.class) {
								output = output + " and Elements: " + ((HolonObject) temp).toStringElements();
							}
							System.out.println(output);
						}
						canvas.repaint();
						dragging = false;
					}
				} catch (Exception e2) {
				}
				frmCyberPhysical.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
			}
		});

		tree.addMouseListener(new MouseAdapter() {
			public void mousePressed(MouseEvent e) {
				try {
					actualObjectClicked = tree.getPathForLocation(e.getX(), e.getY()).getLastPathComponent().toString();
					for (Category cat : model.getCategories()) {
						for (CpsObject cps : cat.getObjects()) {
							if (actualObjectClicked.compareTo(cps.getCompareName()) == 0) {
								img = new ImageIcon(this.getClass().getResource(cps.getImage())).getImage()
										.getScaledInstance(controller.getScale(), controller.getScale(),
												java.awt.Image.SCALE_SMOOTH);
								tempCps = cps;
								dragging = true;
								Cursor cursor = Toolkit.getDefaultToolkit().createCustomCursor(img, new Point(0, 0),
										"Image");
								frmCyberPhysical.setCursor(cursor);
							}
						}
					}
				} catch (Exception e2) {
				}
			}
		});

		scrollPane_1.setViewportView(tree);

		scrollPane_1.setColumnHeaderView(panel);
		panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
		toolBar.setFloatable(false);

		panel.add(toolBar);
		toolBar.add(comboBox);
		comboBox.setModel(new DefaultComboBoxModel(new String[] { "Category", "Object", "Transformer", "Switch" }));
		// Add Button
		btnAdd.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {

				Object nodeInfo = tree.getLastSelectedPathComponent();
				String selectedOption = comboBox.getSelectedItem().toString();
				DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) nodeInfo;

				switch (selectedOption) {

				case "Category":
					String catName = JOptionPane.showInputDialog("Please enter a Name for Category ");
					if (catName.length() != 0) {
						controller.addCategory(catName);
					}
					break;

				case "Object":
					if (selectedNode == null) {
						JOptionPane.showMessageDialog(new JFrame(),
								"Please select a Category first before adding " + selectedOption + ".");
					}
					if (selectedNode.getLevel() == 1) {
						addObjectPopUP = new AddObjectPopUp();
						addObjectPopUP.setVisible(true);
						addObjectPopUP.setController(controller);
						addObjectPopUP.setCategory(selectedNode.toString());
					}
					break;

				default:
					addObjectAction(selectedOption, selectedNode);
					break;
				}
			}
		});
		/**
		 * Pop up - About Us with some important information about the
		 * developers, source and programming stuff
		 */
		aboutUs.addMouseListener(new MouseAdapter() {
			@Override
			public void mousePressed(MouseEvent e) {
				aboutUsPopUp = new AboutUsPopUp();
				aboutUsPopUp.setVisible(true);
			}
		});

		/**
		 * Update of every interaction between the user and the canvas (only on
		 * the canvas). Basically the update of all the information concerning
		 * the clicked HolonObject
		 */
		canvas.addMouseListener(new MouseAdapter() {
			@Override
			public void mousePressed(MouseEvent e) {
				// Update of the Information about the HolonElements - only for
				refreshTableHolonElement();

				// Update of the Information about the Properties - only for
				// CpsObjects
				// Erase old data
				if (tableModelProperties.getRowCount() > 0) {
					for (int i = tableModelProperties.getRowCount() - 1; i > -1; i--) {
						tableModelProperties.removeRow(i);
					}
				}
				// Write new data
				if (canvas.tempCps != null) {
					Object[] tempName = { "Name", canvas.tempCps.getName() };
					tableModelProperties.addRow(tempName);
					Object[] tempId = { "ID", canvas.tempCps.getID() };
					tableModelProperties.addRow(tempId);
					if (canvas.tempCps.getClass() == HolonObject.class) {
						Object[] tempEnergy = { "Total Energy", ((HolonObject) canvas.tempCps).getCurrentEnergy() };
						tableModelProperties.addRow(tempEnergy);
					}
					ArrayList<CpsEdge> temp_array = canvas.tempCps.getConnectedTo();
					if (!temp_array.isEmpty()) {
						boolean first = true;
						for (CpsEdge temp : temp_array) {
							if (first) {
								first = false;
								if (canvas.tempCps.getName().compareTo(temp.getA().getCompareName()) == 0) {
									Object[] tempConnection = { canvas.tempCps.getName() + " is connected to",
											temp.getB().getName() + " with ID: " + temp.getB().getID() };
									tableModelProperties.addRow(tempConnection);
								} else {
									Object[] tempConnection = { canvas.tempCps.getName() + " is connected to",
											temp.getA().getName() + " with ID: " + temp.getA().getID() };
									tableModelProperties.addRow(tempConnection);
								}

							} else {
								if (canvas.tempCps.getName().compareTo(temp.getA().getCompareName()) == 0) {
									Object[] tempConnection = { "",
											temp.getB().getName() + " with ID: " + temp.getB().getID() };
									tableModelProperties.addRow(tempConnection);
								} else {
									Object[] tempConnection = { "",
											temp.getA().getName() + " with ID: " + temp.getA().getID() };
									tableModelProperties.addRow(tempConnection);
								}

							}
						}
					}
				}
			}

		});

		tableHolonElement.addPropertyChangeListener(new PropertyChangeListener() {
			@Override
			public void propertyChange(PropertyChangeEvent evt) {
				try {

					tempCps = controller.searchByID(model.getSelectedObjectID());
					if (tempCps != null) {
						// System.out.println("change: " + tempCps.toString());
						for (int r = 0; r < tableModelHolonElement.getRowCount(); r++) {
							ArrayList<Object> temp = new ArrayList<>();
							for (int c = 0; c < tableModelHolonElement.getColumnCount(); c++) {
								temp.add(tableHolonElement.getValueAt(r, c));
							}
							float ch;
							if (temp.get(1).toString().compareTo("-") == 0) {
								ch = -1;
							} else {
								ch = 1;
							}
							float fa = Float.parseFloat(temp.get(2).toString());
							int i = Integer.parseInt(temp.get(3).toString());
							((HolonObject) tempCps).getElements().get(r).setEleName((String) temp.get(0));
							((HolonObject) tempCps).getElements().get(r).setSign(ch);
							((HolonObject) tempCps).getElements().get(r).setEnergy(fa);
							((HolonObject) tempCps).getElements().get(r).setAmount(i);
							// System.out.println(tableHolonElement.getRowCount()
							// + " " + temp.get(0) + " " + ch + " " + fa
							// + " " + i);
						}
						if (tableModelHolonElement.getRowCount() > 0) {
							for (int i = tableModelHolonElement.getRowCount() - 1; i > -1; i--) {
								tableModelHolonElement.removeRow(i);
							}
						}
						for (HolonElement he : canvas.dataSelected) {
							Object[] temp = { he.getEleName(), he.getEnergy(), he.getAmount() };
							tableModelHolonElement.addRow(temp);
						}
					}
				} catch (Exception e) {

				}
			}
		});

		toolBar.add(btnAdd);

		// Del Button
		btnDel.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {

				Object nodeInfo = tree.getLastSelectedPathComponent();
				if (nodeInfo != null) {
					DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) nodeInfo;
					String nodeName = selectedNode.getUserObject().toString();
					int depthOfNode = selectedNode.getLevel();

					switch (depthOfNode) {
					case 1:
						int dialogResult = JOptionPane.showConfirmDialog(null,
								"Do you realy want to delete the Category " + nodeName + "?", "Warning",
								JOptionPane.YES_NO_OPTION);
						if (dialogResult == JOptionPane.YES_OPTION) {
							controller.deleteCategory(nodeName);
							break;
						} else {
							break;
						}
					case 2:
						DefaultMutableTreeNode parent = (DefaultMutableTreeNode) selectedNode.getParent();
						controller.delObjectCategory(nodeName, parent.getUserObject().toString());
						break;

					default:
						JOptionPane.showMessageDialog(new JFrame(),
								"Please select a Category or an Object in order to delete something.");
					}
				} else {
					JOptionPane.showMessageDialog(new JFrame(),
							"Please select a Category or an Object in order to delete something.");
				}

			}
		});
		toolBar.add(btnDel);

		frmCyberPhysical.getContentPane().add(splitPane);

		mntmOpen.addActionListener(new java.awt.event.ActionListener() {
			@Override
			public void actionPerformed(java.awt.event.ActionEvent evt) {
				menuFileExitActionPerformed(evt);
			}

			private void menuFileExitActionPerformed(java.awt.event.ActionEvent evt) {
				JFileChooser fileChooser = new JFileChooser();
				JFrame test = new JFrame();
				if (fileChooser.showOpenDialog(test) == JFileChooser.APPROVE_OPTION) {
					File file = fileChooser.getSelectedFile();
					System.out.println("File Path is: " + file.toString());
				}
			}
		});

		splitPane.setRightComponent(splitPane_1);
		splitPane.setDividerLocation(200);
		splitPane_1.setDividerLocation(500);

		splitPane.setLeftComponent(scrollPane_1);
		splitPane_1.setLeftComponent(tabbedPane);
		splitPane_1.setRightComponent(split_HolonEl_Pro);
		split_HolonEl_Pro.setDividerLocation(600);
		split_HolonEl_Pro.setTopComponent(split_Graph_HolonEl);
		split_HolonEl_Pro.setBottomComponent(scrollProperties);
		split_Graph_HolonEl.setDividerLocation(150);
		split_Graph_HolonEl.setTopComponent(scrollGraph);
		split_Graph_HolonEl.setBottomComponent(scrollElements);

		tabbedPane.setBorder(null);
		scrollProperties.setBorder(null);
		scrollGraph.setBorder(null);
		scrollElements.setBorder(null);
		splitPane.setBorder(null);
		splitPane_1.setBorder(null);
		split_HolonEl_Pro.setBorder(null);
		split_Graph_HolonEl.setBorder(null);
		scrollPane_2.setBorder(null);
		panel_HolonEl.setBorder(null);
		tableHolonElementScrollPane.setBorder(null);

		frmCyberPhysical.getContentPane().add(timePanel, BorderLayout.SOUTH);
	}

	/*
	 * adds a specific object type to selected Category also handles input
	 * windows and illegal inputs
	 */
	public void addObjectAction(String objType, DefaultMutableTreeNode selectedNode) {
		if (selectedNode == null) {
			JOptionPane.showMessageDialog(new JFrame(),
					"Please select a Category first before adding " + objType + ".");
		}
		// if selected node is a directory for Categories
		else {
			if (selectedNode.getLevel() == 1) {
				String objname = JOptionPane.showInputDialog("Please enter a Name for the " + objType);
				Category cat = controller.searchCategory(selectedNode.getUserObject().toString());

				if (objname.length() != 0) {
					switch (objType) {

					case "Switch":
						controller.addSwitch(cat, objname, objType);
						break;

					case "Transformer":
						controller.addTransformer(cat, objname, objType);
						break;
					}
				}
			} else {
				JOptionPane.showMessageDialog(new JFrame(),
						"Objects can not be added to Objects. Please select a Category.");
			}
		}
	}

	/**
	 * reloads the Categories from Model
	 */
	public void updateCategories(final ArrayList<Category> categories) {
		tree.setModel(new DefaultTreeModel(new DefaultMutableTreeNode("Categories") {
			{
				DefaultMutableTreeNode node_1;
				for (Category c : categories) {
					node_1 = new DefaultMutableTreeNode(c.getName());

					// kann eventuell umgeändert werden
					for (CpsObject obj : c.getObjects()) {
						node_1.add(new DefaultMutableTreeNode(obj.getObjName()));
					}
					add(node_1);
				}

			}
		}));
	}

	/**
	 * 
	 */
	public void onChange(ArrayList<Category> categories) {
		DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
		updateCategories(categories);
		model.reload();
	}

	/**
	 * 
	 * @return
	 */
	public JFrame getFrmCyberPhysical() {
		return frmCyberPhysical;
	}

	public CpsObject getActualCps() {
		int tempID = model.getSelectedObjectID();
		CpsObject tempCps = controller.searchByID(tempID);
		return tempCps;
	}

	public HolonElement getActualHolonElement(HolonObject obj, int yValue) {
		HolonObject tempCps = obj;
		final int yTemp = (int) Math.floor(yValue / 16);
		int rowsTotal = tableModelHolonElement.getRowCount();
		if (rowsTotal != 0 && rowsTotal > yTemp) {
			model.setSelectedHolonElement(obj.getElements().get(yTemp));
			return obj.getElements().get(yTemp);
		} else {
			model.setSelectedHolonElement(null);
			return null;
		}
	}
	
	/*
	 * Refresh the Table displaying the Holon Elements
	 */
	public void refreshTableHolonElement() {
		// Update of the Information about the HolonElements - only for
		// HolonObjects
		if (tableModelHolonElement.getRowCount() > 0) {
			for (int i = tableModelHolonElement.getRowCount() - 1; i > -1; i--) {
				tableModelHolonElement.removeRow(i);
			}
		}
		if (canvas.dataSelected != null) {
			for (HolonElement he : canvas.dataSelected) {
				Object[] temp = { he.getEleName(), he.getEnergy(), he.getAmount() };
				tableModelHolonElement.addRow(temp);
			}
		}
	}
}