New OutlinerWindow (new files)

src/ui/controller/CalculataModel.java

@@ -0,0 +1,72 @@
+package ui.controller;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.ListIterator;
+
+import classes.AbstractCpsObject;
+import classes.CpsEdge;
+import classes.HolonObject;
+import classes.HolonSwitch;
+import ui.model.MinimumModel;
+import ui.model.MinimumNetwork;
+
+public class CalculataModel {
+	public static ArrayList<MinimumNetwork> calculateNetworks(MinimumModel minModel, int Iteration){
+		ArrayList<MinimumNetwork> listOfNetworks = new ArrayList<MinimumNetwork>();
+		while(!minModel.getHolonObjectList().isEmpty()) {
+			//lookAt the first holonObject and find his neighbors
+			HolonObject lookAtObject = minModel.getHolonObjectList().get(0);
+			//delete out of list
+			minModel.getHolonObjectList().remove(0);
+			//create a new Network
+			MinimumNetwork actualNetwork = new MinimumNetwork(new ArrayList<HolonObject>(), new ArrayList<CpsEdge>());
+			actualNetwork.getHolonObjectList().add(lookAtObject);
+			//create List of neighbors
+			LinkedList<AbstractCpsObject> neighbors = new LinkedList<AbstractCpsObject>();
+			populateListOfNeighbors(minModel, lookAtObject, actualNetwork, neighbors);
+			while(!neighbors.isEmpty()) {
+				AbstractCpsObject lookAtNeighbor = neighbors.getFirst();
+				if(lookAtNeighbor instanceof HolonObject) {
+					actualNetwork.getHolonObjectList().add((HolonObject) lookAtNeighbor);
+					minModel.getHolonObjectList().remove(lookAtNeighbor);
+				}
+				//When HolonSwitch Check if closed
+				if(!(lookAtNeighbor instanceof HolonSwitch) || ((HolonSwitch)lookAtNeighbor).getState(Iteration)) {
+					populateListOfNeighbors(minModel, lookAtNeighbor, actualNetwork, neighbors);
+				}
+				
+				neighbors.removeFirst();
+			}
+			listOfNetworks.add(actualNetwork);
+		}	
+		return listOfNetworks;
+	}
+
+	private static void populateListOfNeighbors(MinimumModel minModel, AbstractCpsObject lookAtObject,
+			MinimumNetwork actualNetwork, LinkedList<AbstractCpsObject> neighbors) {
+		ListIterator<CpsEdge> iter = minModel.getEdgeList().listIterator();
+		while(iter.hasNext())
+		{
+			CpsEdge lookAtEdge = iter.next();
+			if(lookAtEdge.isConnectedTo(lookAtObject)) {
+				iter.remove();
+				actualNetwork.getEdgeList().add(lookAtEdge);
+				//Add neighbar
+				AbstractCpsObject edgeNeighbor;
+				if(lookAtEdge.getA().equals(lookAtObject)) {
+					edgeNeighbor = lookAtEdge.getB();
+				}else {
+					edgeNeighbor = lookAtEdge.getA();
+				}
+				if(!neighbors.contains(edgeNeighbor)) {
+					neighbors.add(edgeNeighbor);
+				}
+			}
+		}
+	}
+	
+	public static void calculateDecNetworkModel(MinimumNetwork actualNetwork) {
+		
+	}
+}

src/ui/model/Consumer.java

@@ -0,0 +1,82 @@
+package ui.model;
+
+import java.util.ArrayList;
+
+import classes.HolonObject;
+
+public class Consumer extends DecoratedHolonObject {
+
+	private ArrayList<SupplierListEntry> supplierList = new ArrayList<SupplierListEntry>();
+	private float energyFromNetwork;
+	private float minimumConsumingElementEnergy;
+	private float energyNeededFromNetwork;
+	private float energyFromConsumingElemnets;
+	private float energySelfSupplied;
+	public Consumer(HolonObject objectToLookAt) {
+		super(objectToLookAt);
+		energyNeededFromNetwork = 0.0f;
+	}
+
+	@Override
+	float getEnergy() {
+		return energyFromNetwork-energyNeededFromNetwork;
+	}
+	public float getEnergyFromNetwork() {
+		return energyFromNetwork;
+	}
+	public void setEnergyFromNetwork(float energyFromNetwork) {
+		this.energyFromNetwork = energyFromNetwork;
+	}
+
+	public float getMinimumConsumingElementEnergy() {
+		return minimumConsumingElementEnergy;
+	}
+
+	public void setMinimumConsumingElementEnergy(float minimumConsumingElementEnergy) {
+		this.minimumConsumingElementEnergy = minimumConsumingElementEnergy;
+	}
+
+	public ArrayList<SupplierListEntry> getSupplierList() {
+		return supplierList;
+	}
+
+	public void setSupplierList(ArrayList<SupplierListEntry> supplierList) {
+		this.supplierList = supplierList;
+	}
+
+	public float getEnergyNeededFromNetwork() {
+		return energyNeededFromNetwork;
+	}
+
+	public void setEnergyNeededFromNetwork(float energyNeededFromNetwork) {
+		this.energyNeededFromNetwork = energyNeededFromNetwork;
+	}
+	@Override
+	public String toString() {
+		return getModel().getName() + ":" + getModel().getId()  + ", Energy: "+ getEnergy() +
+				" [" + (energyFromNetwork + energySelfSupplied) +"/" + energyFromConsumingElemnets +"]";	
+	}
+	public float getEnergyFromConsumingElemnets() {
+		return energyFromConsumingElemnets;
+	}
+
+	public void setEnergyFromConsumingElemnets(float energyFromConsumingElemnets) {
+		this.energyFromConsumingElemnets = energyFromConsumingElemnets;
+	}
+	public float getEnergySelfSupplied() {
+		return energySelfSupplied;
+	}
+
+	public void setEnergySelfSupplied(float energySelfSupplied) {
+		this.energySelfSupplied = energySelfSupplied;
+	}
+	public class SupplierListEntry{
+		public Supplier supplier;
+		public float energyFromSupplier;
+		public SupplierListEntry(Supplier supplier,float energyFromSupplier) {
+			this.supplier = supplier;
+			this.energyFromSupplier = energyFromSupplier;
+		}
+	}
+
+}

src/ui/model/DecoratedHolonObject.java

@@ -0,0 +1,24 @@
+package ui.model;
+
+import classes.HolonObject;
+
+public abstract class DecoratedHolonObject {
+	public enum HolonObjectState {
+		NO_ENERGY, NOT_SUPPLIED, SUPPLIED, PRODUCER, PARTIALLY_SUPPLIED, OVER_SUPPLIED
+	}
+	private HolonObject model;
+	private HolonObjectState state;
+	public DecoratedHolonObject(HolonObject objectToLookAt){
+		model = objectToLookAt;
+	}
+	abstract float getEnergy();
+	public HolonObject getModel() {
+		return model;
+	}
+	public HolonObjectState getState() {
+		return state;
+	}
+	public void setState(HolonObjectState state) {
+		this.state = state;
+	}
+}

src/ui/model/DecoratedNetwork.java

@@ -0,0 +1,211 @@
+package ui.model;
+
+import java.util.ArrayList;
+
+import classes.HolonObject;
+import ui.model.DecoratedHolonObject.HolonObjectState;
+
+public class DecoratedNetwork {
+	private ArrayList<Supplier> supplierList = new ArrayList<Supplier>();
+	private ArrayList<Consumer> consumerList = new ArrayList<Consumer>();
+	private ArrayList<Consumer> consumerSelfSuppliedList = new ArrayList<Consumer>();
+	private ArrayList<Passiv> passivNoEnergyList = new ArrayList<Passiv>();
+	public DecoratedNetwork(MinimumNetwork mm, int Iteration){
+		//Categorize
+		for(HolonObject hObject: mm.getHolonObjectList()) {
+			float energyNeeded = hObject.getEnergyNeededFromConsumingElements(Iteration);
+			float energySelfProducing = hObject.getEnergySelfProducingFromProducingElements(Iteration);
+			if(energyNeeded < energySelfProducing) {
+				Supplier sup = new Supplier(hObject);
+				sup.setEnergyToSupplyNetwork(energySelfProducing - energyNeeded);
+				supplierList.add(sup);
+			} else if (energyNeeded > energySelfProducing) {
+				Consumer con = new Consumer(hObject);
+				con.setEnergyNeededFromNetwork(energyNeeded - energySelfProducing);
+				con.setMinimumConsumingElementEnergy(hObject.getMinimumConsumingElementEnergy(Iteration));
+				con.setEnergyFromConsumingElemnets(hObject.getEnergyNeededFromConsumingElements(Iteration));
+				con.setEnergySelfSupplied(hObject.getEnergySelfProducingFromProducingElements(Iteration));
+				consumerList.add(con);
+			}else if(energyNeeded == energySelfProducing) {
+				
+				if (energySelfProducing == 0.0f) {
+					Passiv pas = new Passiv(hObject);
+					passivNoEnergyList.add(pas);
+				} else {
+					Consumer con = new Consumer(hObject);
+					con.setEnergyNeededFromNetwork(0.0f);
+					con.setMinimumConsumingElementEnergy(hObject.getMinimumConsumingElementEnergy(Iteration));
+					con.setEnergyFromConsumingElemnets(hObject.getEnergyNeededFromConsumingElements(Iteration));
+					con.setEnergySelfSupplied(hObject.getEnergySelfProducingFromProducingElements(Iteration));
+					consumerSelfSuppliedList.add(con);
+				}
+				
+			}
+		}
+		//Sort SupplierList according to the EnergyToSupplyNetwork maximum first.
+		//Sort ConsumerList according to the MinimumConsumingElementEnergy minimum first.
+		supplierList.sort((Supplier lhs,Supplier rhs) -> -Float.compare(lhs.getEnergyToSupplyNetwork(), rhs.getEnergyToSupplyNetwork()));
+		consumerList.sort((Consumer lhs,Consumer rhs) -> Float.compare(lhs.getMinimumConsumingElementEnergy()  , rhs.getMinimumConsumingElementEnergy()));
+		//consumerList.forEach((con) -> System.out.println(con.getMinimumConsumingElementEnergy()));
+		consumerList.forEach((con) -> System.out.println("AfterSorting" + con));
+		//Minimum demand first:
+		float energyToSupplyInTheNetwork = supplierList.stream().map(supplier -> supplier.getEnergyToSupplyNetwork() - supplier.getEnergySupplied()).reduce( 0.0f, (a, b) -> a + b);
+		outerLoop:
+		for(Consumer con : consumerList)
+		{
+			//gehe Supplier list durch wer ihn supplien kann.
+			for(Supplier sup : supplierList) {
+				float  energyRdyToSupply = sup.getEnergyToSupplyNetwork() - sup.getEnergySupplied();
+				if(energyRdyToSupply == 0.0f) continue;
+				float energyNeededForMinimumConsumingElement=con.getMinimumConsumingElementEnergy()-con.getEnergyFromNetwork();
+				if(energyNeededForMinimumConsumingElement>energyToSupplyInTheNetwork) {
+					//Dont supply a minimumElement when you cant supply it fully
+					break outerLoop;
+				}
+				if(energyRdyToSupply>=energyNeededForMinimumConsumingElement) {
+					energyToSupplyInTheNetwork -= energyNeededForMinimumConsumingElement;
+					supply(con, sup, energyNeededForMinimumConsumingElement);
+					continue outerLoop;
+				}else
+				{
+					energyToSupplyInTheNetwork -= energyRdyToSupply;
+					supply(con, sup, energyRdyToSupply);
+				}
+			}
+			//No more Energy in the network
+			break;
+		}
+		consumerList.forEach((con) -> System.out.println("AfterSuppliing MinimumDemand" + con));
+		
+		//Sort ConsumerList according to the EnergyNeeded to supply fully after minimum Demand First.
+		consumerList.sort((Consumer lhs,Consumer rhs) -> Float.compare(lhs.getEnergyNeededFromNetwork()-lhs.getEnergyFromNetwork() , rhs.getEnergyNeededFromNetwork()-rhs.getEnergyFromNetwork() ));
+		//Supply consumer fully 
+		outerLoop:
+		for(Consumer con : consumerList)
+		{
+			//gehe Supplier list durch wer ihn supplien kann.
+			for(Supplier sup : supplierList) {
+				float  energyRdyToSupply = sup.getEnergyToSupplyNetwork() - sup.getEnergySupplied();
+				if(energyRdyToSupply == 0.0f) continue;
+				float energyNeededForFullySupply = con.getEnergyNeededFromNetwork() - con.getEnergyFromNetwork();
+				if(energyNeededForFullySupply == 0.0f) continue;
+				if(energyRdyToSupply>=energyNeededForFullySupply) {
+					supply(con, sup, energyNeededForFullySupply);
+					continue outerLoop;
+				}else
+				{
+					supply(con, sup, energyRdyToSupply);
+				}
+			}
+			//No more Energy in the network
+			break;
+		}
+		consumerList.forEach((con) -> System.out.println("AfterFullySuplieing" + con));
+		//If Energy Left Supply all equal
+		//Count EnergyLeft
+		float energyLeft = supplierList.stream().map(supplier -> supplier.getEnergyToSupplyNetwork() - supplier.getEnergySupplied()).reduce( 0.0f, (a, b) -> a + b);
+		if(energyLeft > 0.0f && (consumerList.size() + consumerSelfSuppliedList.size() != 0))
+		{
+			float equalAmountOfEnergyToSupply = energyLeft / ((float)(consumerList.size() + consumerSelfSuppliedList.size()));
+			outerLoop:
+			for(Consumer con : consumerList)
+			{
+				//gehe Supplier list durch wer ihn supplien kann.
+				for(Supplier sup : supplierList) {
+					float  energyRdyToSupply = sup.getEnergyToSupplyNetwork() - sup.getEnergySupplied();
+					if(energyRdyToSupply == 0.0f) continue;
+					float energyNeededToSupplyConsumerTheEqualAmount = equalAmountOfEnergyToSupply +con.getEnergyNeededFromNetwork()- con.getEnergyFromNetwork();
+					if(energyRdyToSupply>=energyNeededToSupplyConsumerTheEqualAmount) {
+						supply(con, sup, energyNeededToSupplyConsumerTheEqualAmount);
+						continue outerLoop;
+					}else
+					{
+						supply(con, sup, energyRdyToSupply);
+					}
+				}
+				//No more Energy in the network
+				break;
+			}
+			outerLoop:
+			for(Consumer con : consumerSelfSuppliedList)
+			{
+				//gehe Supplier list durch wer ihn supplien kann.
+				for(Supplier sup : supplierList) {
+					float  energyRdyToSupply = sup.getEnergyToSupplyNetwork() - sup.getEnergySupplied();
+					if(energyRdyToSupply == 0.0f) continue;
+					float energyNeededToSupplyConsumerTheEqualAmount = equalAmountOfEnergyToSupply +con.getEnergyNeededFromNetwork()- con.getEnergyFromNetwork();
+					if(energyRdyToSupply>=energyNeededToSupplyConsumerTheEqualAmount) {
+						supply(con, sup, energyNeededToSupplyConsumerTheEqualAmount);
+						continue outerLoop;
+					}else
+					{
+						supply(con, sup, energyRdyToSupply);
+					}
+					
+				}
+				//No more Energy in the network
+				break;
+			}
+		}
+		consumerList.forEach((con) -> System.out.println("AfterOverSuppleiing" + con));
+		
+		consumerSelfSuppliedList.forEach((con) -> System.out.println("AfterOverSuppleiing" + con));
+		
+		//CalculateStates:
+		supplierList.forEach(sup -> sup.setState(HolonObjectState.PRODUCER));
+		passivNoEnergyList.forEach(sup -> sup.setState(HolonObjectState.NO_ENERGY));
+		for(Consumer con : this.consumerList)
+		{
+			setConsumerState(con);
+		}
+		for(Consumer con : this.consumerSelfSuppliedList)
+		{
+			setConsumerState(con);
+		}
+	}
+
+
+	private void setConsumerState(Consumer con) {
+		if(con.getEnergySelfSupplied() + con.getEnergyFromNetwork() > con.getEnergyFromConsumingElemnets()) {
+			con.setState(HolonObjectState.OVER_SUPPLIED);
+		}else if(con.getEnergySelfSupplied() + con.getEnergyFromNetwork() == con.getEnergyFromConsumingElemnets()) {
+			con.setState(HolonObjectState.SUPPLIED);
+		}else if(con.getEnergySelfSupplied() + con.getEnergyFromNetwork() >= con.getMinimumConsumingElementEnergy()) {
+			con.setState(HolonObjectState.PARTIALLY_SUPPLIED);
+		}else {
+			con.setState(HolonObjectState.NOT_SUPPLIED);
+		}
+	}
+	
+	
+	/**
+	 * No Checks.
+	 * @param con
+	 * @param sup
+	 * @param energy
+	 */
+	private void supply(Consumer con, Supplier sup, float energy) {
+		sup.getConsumerList().add(sup.new ConsumerListEntry(con , energy));
+		sup.setEnergySupplied(sup.getEnergySupplied() + energy);
+		con.getSupplierList().add(con.new SupplierListEntry(sup, energy));
+		con.setEnergyFromNetwork(con.getEnergyFromNetwork() + energy);
+	}
+	public ArrayList<Supplier> getSupplierList() {
+		return supplierList;
+	}
+
+
+	public ArrayList<Consumer> getConsumerList() {
+		return consumerList;
+	}
+
+
+	public ArrayList<Consumer> getConsumerSelfSuppliedList() {
+		return consumerSelfSuppliedList;
+	}
+
+
+	public ArrayList<Passiv> getPassivNoEnergyList() {
+		return passivNoEnergyList;
+	}
+}

src/ui/model/MinimumModel.java

@@ -0,0 +1,53 @@
+package ui.model;
+
+import java.util.ArrayList;
+
+import classes.AbstractCpsObject;
+import classes.CpsEdge;
+import classes.CpsNode;
+import classes.HolonObject;
+import classes.HolonSwitch;
+
+public class MinimumModel {
+	private ArrayList<HolonObject> holonObjectList = new ArrayList<HolonObject>();
+	private ArrayList<CpsEdge> edgeList = new ArrayList<CpsEdge>();
+	private ArrayList<CpsNode> nodeList = new ArrayList<CpsNode>();
+	private ArrayList<HolonSwitch> switchList = new ArrayList<HolonSwitch>();
+	
+	public MinimumModel(ArrayList<AbstractCpsObject> abstractObjectList, ArrayList<CpsEdge> edgeList) {// Contructor because of old Model TODO:Replace the whole Program
+		for (AbstractCpsObject aCps : abstractObjectList) {
+			if (aCps instanceof HolonObject) holonObjectList.add((HolonObject) aCps);
+			else if (aCps instanceof CpsNode) nodeList.add((CpsNode) aCps);
+			else if (aCps instanceof HolonSwitch) switchList.add((HolonSwitch) aCps);
+		}
+		for (CpsEdge edge : edgeList) {
+			this.edgeList.add(edge);
+		}
+	}
+	
+	public ArrayList<HolonObject> getHolonObjectList() {
+		return holonObjectList;
+	}
+	public void setHolonObjectList(ArrayList<HolonObject> holonObjectList) {
+		this.holonObjectList = holonObjectList;
+	}
+	public ArrayList<CpsEdge> getEdgeList() {
+		return edgeList;
+	}
+	public void setEdgeList(ArrayList<CpsEdge> edgeList) {
+		this.edgeList = edgeList;
+	}
+	public ArrayList<CpsNode> getNodeList() {
+		return nodeList;
+	}
+	public void setNodeList(ArrayList<CpsNode> nodeList) {
+		this.nodeList = nodeList;
+	}
+	public ArrayList<HolonSwitch> getSwitchList() {
+		return switchList;
+	}
+	public void setSwitchList(ArrayList<HolonSwitch> switchList) {
+		this.switchList = switchList;
+	}
+	
+}

src/ui/model/MinimumNetwork.java

@@ -0,0 +1,35 @@
+package ui.model;
+
+import java.util.ArrayList;
+
+import classes.CpsEdge;
+import classes.HolonObject;
+
+public class MinimumNetwork {
+	private ArrayList<HolonObject> holonObjectList = new ArrayList<HolonObject>();
+	private ArrayList<CpsEdge> edgeList = new ArrayList<CpsEdge>();
+	public MinimumNetwork(ArrayList<HolonObject> holonObjectList, ArrayList<CpsEdge> edgeList){
+		this.holonObjectList = holonObjectList;
+		this.edgeList = edgeList;
+	}
+	public ArrayList<HolonObject> getHolonObjectList() {
+		return holonObjectList;
+	}
+	public ArrayList<CpsEdge> getEdgeList() {
+		return edgeList;
+	}
+	public String toString()
+	{
+		String objecte = "[";
+		for(HolonObject object :holonObjectList) {
+			objecte += " " + object.getObjName();
+		}
+		objecte += "]";
+		String edges = "[";
+		for(CpsEdge edge :edgeList) {
+			edges += " " + edge;
+		}
+		edges += "]";
+		return objecte + edges;
+	}
+}

src/ui/model/Passiv.java

@@ -0,0 +1,15 @@
+package ui.model;
+
+import classes.HolonObject;
+
+public class Passiv extends DecoratedHolonObject {
+	public Passiv(HolonObject objectToLookAt) {
+		super(objectToLookAt);
+	}
+	
+	@Override
+	float getEnergy() {
+		return 0;
+	}
+
+}

src/ui/model/Supplier.java

@@ -0,0 +1,52 @@
+package ui.model;
+
+import java.util.ArrayList;
+
+import classes.HolonObject;
+
+public class Supplier extends DecoratedHolonObject {
+
+	private ArrayList<ConsumerListEntry> consumerList = new ArrayList<ConsumerListEntry>();
+	private float energyToSupplyNetwork;
+	private float energySupplied;
+	public Supplier(HolonObject objectToLookAt) {
+		super(objectToLookAt);
+		energySupplied = 0.0f;
+	}
+
+	@Override
+	float getEnergy() {
+		return energyToSupplyNetwork;
+	}
+
+	public ArrayList<ConsumerListEntry> getConsumerList() {
+		return consumerList;
+	}
+
+	public void setConsumerList(ArrayList<ConsumerListEntry> consumerList) {
+		this.consumerList = consumerList;
+	}
+
+	public float getEnergyToSupplyNetwork() {
+		return energyToSupplyNetwork;
+	}
+
+	public void setEnergyToSupplyNetwork(float energyToSupplyNetwork) {
+		this.energyToSupplyNetwork = energyToSupplyNetwork;
+	}
+	public float getEnergySupplied() {
+		return energySupplied;
+	}
+
+	public void setEnergySupplied(float energySupplied) {
+		this.energySupplied = energySupplied;
+	}
+	public class ConsumerListEntry{
+		public Consumer consumer;
+		public float energyToConsumer;
+		public ConsumerListEntry(Consumer consumer, float energyToConsumer) {
+			this.consumer= consumer;
+			this.energyToConsumer = energyToConsumer;
+		}
+	}
+}

src/ui/view/Outliner.java

@@ -0,0 +1,386 @@
+package ui.view;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.util.ArrayList;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTabbedPane;
+import javax.swing.JTree;
+import javax.swing.event.TreeModelEvent;
+import javax.swing.event.TreeModelListener;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeCellRenderer;
+import javax.swing.tree.DefaultTreeModel;
+
+import classes.AbstractCpsObject;
+import classes.CpsEdge;
+import classes.HolonObject;
+import ui.controller.CalculataModel;
+import ui.controller.Control;
+import ui.controller.UpdateController;
+import ui.model.Consumer;
+import ui.model.Consumer.SupplierListEntry;
+import ui.model.DecoratedHolonObject;
+import ui.model.DecoratedHolonObject.HolonObjectState;
+import ui.model.DecoratedNetwork;
+import ui.model.MinimumModel;
+import ui.model.MinimumNetwork;
+import ui.model.Model;
+import ui.model.Supplier;
+
+
+
+
+
+public class Outliner extends JFrame {
+	private static final long serialVersionUID = 1L;
+	private JTree tree;
+	DefaultMutableTreeNode objects = new DefaultMutableTreeNode("HolonObjects");
+	DefaultMutableTreeNode cables = new DefaultMutableTreeNode("Cable");
+	DefaultMutableTreeNode switches = new DefaultMutableTreeNode("Switches");
+	DefaultMutableTreeNode nodes = new DefaultMutableTreeNode("Nodes");
+	
+	ArrayList<MinimumNetwork> list;
+	
+	Outliner(JFrame parentFrame, Model model, Control controller, GUI gui){ 
+		setBounds(0, 0, 400, parentFrame.getHeight());
+		this.setIconImage(Util.loadImage("/Images/Holeg.png", 30, 30));
+		this.setTitle("Outliner");
+		setLocationRelativeTo(parentFrame);
+		this.setVisible(true);
+		JTabbedPane tabbedPane = new JTabbedPane();
+		JPanel listPanel = createOutlinerListPanel(model, controller, gui);
+		tabbedPane.addTab("List", listPanel);
+		MinimumModel mm = new MinimumModel(model.getObjectsOnCanvas(), model.getEdgesOnCanvas());
+		list = CalculataModel.calculateNetworks(mm, model.getCurIteration());
+		JPanel networkPanel = createNetworkPanel();
+		tabbedPane.addTab("Networks", networkPanel);
+		ArrayList<DecoratedNetwork> computedList = new ArrayList<DecoratedNetwork>();
+		for (MinimumNetwork net : list) {
+			computedList.add(new DecoratedNetwork(net, model.getCurIteration()));
+		}
+		JPanel decoratedNetworkPanel = generateDecoratedNetworkPanel(computedList);
+		tabbedPane.addTab("Computed Networks", decoratedNetworkPanel);
+		this.getContentPane().add(tabbedPane);
+	}
+
+
+
+
+	private JPanel generateDecoratedNetworkPanel(ArrayList<DecoratedNetwork> computedList) {
+		JPanel decoratedNetworkPanel = new JPanel(new BorderLayout());
+		DefaultMutableTreeNode top = new DefaultMutableTreeNode();
+		for (DecoratedNetwork dNet : computedList) {
+			DefaultMutableTreeNode networkNode = new DefaultMutableTreeNode("Network");
+			DefaultMutableTreeNode consumerListNode = new DefaultMutableTreeNode("ConsumerList");
+			DefaultMutableTreeNode supplierListNode = new DefaultMutableTreeNode("SupplierList");
+			if (!dNet.getConsumerList().isEmpty() || !dNet.getConsumerSelfSuppliedList().isEmpty()) {
+				for (Consumer con : dNet.getConsumerList()) {
+					DefaultMutableTreeNode consumerNode = new ColoredTreeNode(con.toString(),con.getState().toString(), getStateColor(con.getState()) );
+					for(Consumer.SupplierListEntry sup: con.getSupplierList())
+					{
+						consumerNode.add(new DefaultMutableTreeNode(sup.supplier.getModel().getName() + " Energy:" + sup.energyFromSupplier));
+					}
+					consumerListNode.add(consumerNode);
+				}
+				for (Consumer con : dNet.getConsumerSelfSuppliedList()) {
+					DefaultMutableTreeNode consumerNode = new DefaultMutableTreeNode(con.toString() + con.getState());
+					for(Consumer.SupplierListEntry sup: con.getSupplierList())
+					{
+						consumerNode.add(new DefaultMutableTreeNode(sup.supplier.getModel().getName() + " Energy:" + sup.energyFromSupplier));
+					}
+					consumerListNode.add(consumerNode);
+				}
+				networkNode.add(consumerListNode);
+			}
+			if (!dNet.getSupplierList().isEmpty()) {
+				networkNode.add(supplierListNode);
+				for (Supplier sup : dNet.getSupplierList()) {
+					supplierListNode.add(new DefaultMutableTreeNode(new AbstractCpsObjectInfo(sup.getModel())));
+				}
+			}
+			top.add(networkNode);
+		}
+		JTree networkTree = new JTree(top);
+		signIconsForTree(networkTree);
+		networkTree.setRootVisible(false);
+		for (int i = 0; i < networkTree.getRowCount(); i++) {
+			networkTree.expandRow(i);
+		}
+		JScrollPane listScroller = new JScrollPane(networkTree);
+		decoratedNetworkPanel.add(listScroller);
+		return decoratedNetworkPanel;
+	}
+
+
+
+
+	private JPanel createNetworkPanel() {
+		JPanel networkPanel = new JPanel(new BorderLayout());
+		DefaultMutableTreeNode top = new DefaultMutableTreeNode();
+		for (MinimumNetwork net : list) {
+			DefaultMutableTreeNode networkNode = new DefaultMutableTreeNode("Network");
+			for (HolonObject hObject : net.getHolonObjectList()) {
+				networkNode.add(new DefaultMutableTreeNode(new AbstractCpsObjectInfo(hObject)));
+			}
+			top.add(networkNode);
+		}
+
+		JTree networkTree = new JTree(top);
+		signIconsForTree(networkTree);
+		networkTree.setRootVisible(false);
+		for (int i = 0; i < networkTree.getRowCount(); i++) {
+			networkTree.expandRow(i);
+		}
+		JScrollPane listScroller = new JScrollPane(networkTree);
+		networkPanel.add(listScroller);
+		return networkPanel;
+	}
+	
+	
+	
+	
+	private JPanel createOutlinerListPanel(Model model, Control controller, GUI gui) {
+		JPanel contentPanel = new JPanel(new BorderLayout());
+		DefaultMutableTreeNode top =new DefaultMutableTreeNode();
+		DefaultTreeModel treeModel = new DefaultTreeModel(top);
+		treeModel.addTreeModelListener(new MyTreeModelListener());
+		
+		createCategorys(top);
+		popullateCategorys(model);
+		tree = new JTree(treeModel);
+		tree.setRootVisible(false);	
+		UpdateController updCon = new UpdateController(model, controller);	
+		tree.addTreeSelectionListener(tsl -> {
+			if(tree.getSelectionPath() == null) return;
+			DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) tsl.getPath().getLastPathComponent();
+			System.out.println(tsl.getPath().getPathCount());
+			if(tsl.getPath().getPathCount() == 3) // 2 is Category 3 is ObjectIn Category
+			{
+				if(selectedNode.getParent().equals(objects))
+				{
+					AbstractCpsObjectInfo info = (AbstractCpsObjectInfo)selectedNode.getUserObject();
+					//treeModel.nodeChanged(selectedNode);
+					
+					model.getSelectedCpsObjects().clear();
+					controller.addSelectedObject(info.getAbstractCpsObject());
+					if(info.getAbstractCpsObject() instanceof HolonObject)
+					{
+						HolonObject hO = (HolonObject) info.getAbstractCpsObject();
+						System.out.println("HolonObject" + hO);
+						System.out.println("getEnergyAtTimestep:" + hO.getEnergyAtTimeStep(0));
+						System.out.println("getEnergyNeededFromConsumingElements:" + hO.getEnergyNeededFromConsumingElements(0));
+						System.out.println("getEnergySelfProducing:" + hO.getEnergySelfProducingFromProducingElements(0));
+						System.out.println("getMinimumConsumingElement:" + hO.getMinimumConsumingElement(0));
+						System.out.println("countConsumingElements:" + hO.countConsumingElements(0));
+						System.out.println("countProducingElements:" + hO.countProducingElements(0));
+					}
+					DefaulTable propertyTable = model.getPropertyTable();
+					if (propertyTable.getRowCount() > 0) {
+						for (int i = propertyTable.getRowCount() - 1; i > -1; i--) {
+							propertyTable.removeRow(i);
+						}
+					}
+					
+					updCon.paintProperties(info.getAbstractCpsObject());
+					updCon.refreshTableHolonElement(model.getMultiTable(), model.getSingleTable());
+					updCon.refreshTableProperties(model.getPropertyTable());
+					gui.getFrmCyberPhysical().repaint();
+				}
+				else if(selectedNode.getParent().equals(cables))
+				{
+					EdgeInfo info = (EdgeInfo)selectedNode.getUserObject();
+					model.setSelectedEdge(info.getEdge());
+					DefaulTable propertyTable = model.getPropertyTable();
+					if (propertyTable.getRowCount() > 0) {
+						for (int i = propertyTable.getRowCount() - 1; i > -1; i--) {
+							propertyTable.removeRow(i);
+						}
+					}
+					controller.setSelecteEdge(info.getEdge());
+					//controller.setSelectedObjectID(0);
+					updCon.refreshTableHolonElement(model.getMultiTable(), model.getSingleTable());
+					updCon.refreshTableProperties(model.getPropertyTable());
+					gui.getFrmCyberPhysical().repaint();
+				}
+			}
+		});
+		signIconsForTree(tree);
+		for (int i = 0; i < tree.getRowCount(); i++) {
+			tree.expandRow(i);
+		}
+		JScrollPane listScroller = new JScrollPane(tree);
+		contentPanel.add(listScroller);
+		return contentPanel;
+	}
+
+
+
+
+	private void signIconsForTree(JTree t) {
+		ImageIcon ClosedIcon = new ImageIcon(Util.loadImage("/Button_Images/Close.png",9,9));
+		ImageIcon OpenIcon = new ImageIcon(Util.loadImage("/Button_Images/Open.png",9,9));
+		ImageIcon LeafIcon = new ImageIcon(Util.loadImage("/Button_Images/Leaf.png",9,9));
+		if (ClosedIcon != null && OpenIcon != null && LeafIcon!= null) {
+		    DefaultTreeCellRenderer renderer = 
+		        new DefaultTreeCellRenderer();
+		    renderer.setClosedIcon(ClosedIcon);
+		    renderer.setOpenIcon(OpenIcon);
+		    renderer.setLeafIcon(LeafIcon);
+		    t.setCellRenderer(renderer);
+		}
+	}
+	private void createCategorys(DefaultMutableTreeNode top) {
+		top.add(objects);
+		top.add(cables);
+		top.add(switches);
+		top.add(nodes);	
+	}
+	private void popullateCategorys(Model m)
+	{
+		m.defineLists();
+		for(AbstractCpsObject aCps :m.getHolonObjectsOnCanvas())
+		{
+			objects.add(new DefaultMutableTreeNode(new AbstractCpsObjectInfo(aCps)));
+		}
+		for(AbstractCpsObject aCps :m.getNodesOnCanvas())
+		{
+			nodes.add(new DefaultMutableTreeNode(new AbstractCpsObjectInfo(aCps)));
+		}
+		for(AbstractCpsObject aCps :m.getSwitchsOnCanvas())
+		{
+			switches.add(new DefaultMutableTreeNode(new AbstractCpsObjectInfo(aCps)));
+		}
+		for(CpsEdge edge :m.getEdgesOnCanvas())
+		{
+			cables.add(new DefaultMutableTreeNode(new EdgeInfo(edge)));
+		}
+	}
+	class MyTreeModelListener implements TreeModelListener {
+
+		@Override
+		public void treeNodesChanged(TreeModelEvent tmE) {
+			// TODO Auto-generated method stub
+			System.out.println("treeNodesChanged");
+		}
+
+		@Override
+		public void treeNodesInserted(TreeModelEvent tmE) {
+			// TODO Auto-generated method stub
+			System.out.println("treeNodesInserted");
+		}
+
+		@Override
+		public void treeNodesRemoved(TreeModelEvent tmE) {
+			// TODO Auto-generated method stub
+			System.out.println("treeNodesRemoved");
+		}
+
+		@Override
+		public void treeStructureChanged(TreeModelEvent tmE) {
+			// TODO Auto-generated method stub
+			System.out.println("treeStructureChanged");
+		}
+	
+	}
+	/*
+	 * 
+	 * case NO_ENERGY:
+                stateColor = Color.WHITE;
+                break;
+
+            case NOT_SUPPLIED:
+                stateColor = new Color(230, 120, 100);
+                break;
+
+            case SUPPLIED:
+                stateColor = Color.GREEN;
+                break;
+
+            case PRODUCER:
+                stateColor = Color.lightGray;
+                break;
+
+            case PARTIALLY_SUPPLIED:
+                stateColor = Color.YELLOW;
+                break;
+
+            case OVER_SUPPLIED:
+                // find different purple-tones at
+                // http://www.rapidtables.com/web/color/purple-color.htm
+                stateColor = new Color(138, 43, 226);
+	 */
+	private Color getStateColor(HolonObjectState state) {
+		switch(state) {
+		case NOT_SUPPLIED:
+			return new Color(230, 120, 100);
+		case NO_ENERGY:
+			return Color.WHITE;
+		case OVER_SUPPLIED:
+			return new Color(138, 43, 226);
+		case PARTIALLY_SUPPLIED:
+			return Color.YELLOW;
+		case PRODUCER:
+			return Color.lightGray;
+		case SUPPLIED:
+			return Color.GREEN;
+		default:
+			return null;
+		}
+	}
+	
+	
+	@SuppressWarnings("serial")
+	class ColoredTreeNode extends DefaultMutableTreeNode{
+		private Color color;
+		public ColoredTreeNode(String string, String state, Color color) {
+			//"<html>Some text <font color='red'>" + "bla" + "some text in red</font></html>"
+			//Integer.toHexString(color.getRGB()).substring(2)
+			//String c = string + "<html><font bgcolor='#132122'>" + state +"</font></html>";
+			super(( "<html>" + string + "<font bgcolor='#" + Integer.toHexString(color.getRGB()).substring(2) + "'>" + state +"</font></html>"));
+			//this.color = color;
+		}
+		public Color getColor(){
+			return color;
+		}
+		public void setColor(Color color) {
+			this.color = color;
+		}
+		
+	}
+	
+	class AbstractCpsObjectInfo {
+		private AbstractCpsObject aCps;
+		AbstractCpsObjectInfo(AbstractCpsObject aCps){
+			this.aCps = aCps;
+		}
+		@Override
+		public String toString(){
+			return aCps.getName() + " Id:"+ aCps.getId();
+		}
+		
+		public AbstractCpsObject getAbstractCpsObject()
+		{
+			return aCps;
+		}
+	}
+	class EdgeInfo {
+		private CpsEdge aEdge;
+		EdgeInfo(CpsEdge aEdge){
+			this.aEdge = aEdge;
+		}
+		@Override
+		public String toString(){
+			return aEdge.toString();
+		}
+		public CpsEdge getEdge()
+		{
+			return aEdge;
+		}
+	}
+}