rms/org.eclipse.ptp.rm.lml.core/src/org/eclipse/ptp/rm/lml/internal/core/model/LguiItem.java

/**
 * Copyright (c) 2011 Forschungszentrum Juelich GmbH
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 * 		Claudia Knobloch, Carsten Karbach, FZ Juelich
 */
package org.eclipse.ptp.rm.lml.internal.core.model;

import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;

import org.eclipse.ptp.rm.lml.core.LMLCorePlugin;
import org.eclipse.ptp.rm.lml.core.events.ILguiUpdatedEvent;
import org.eclipse.ptp.rm.lml.core.listeners.ILguiListener;
import org.eclipse.ptp.rm.lml.core.model.ILguiHandler;
import org.eclipse.ptp.rm.lml.core.model.ILguiItem;
import org.eclipse.ptp.rm.lml.internal.core.elements.LguiType;
import org.eclipse.ptp.rm.lml.internal.core.events.LguiUpdatedEvent;

/**
 * Class of the interface ILguiItem
 */
public class LguiItem implements ILguiItem {
	
	/*
	 * Source of the XML-file from which the LguiType was generated.
	 */
	private URL xmlFile;
	
	/*
	 * The generated LguiType 
	 */
	private LguiType lgui;
	
	/**
	 * collects listeners, which listen for changes in model
	 */
	private List<ILguiListener> listeners = new LinkedList<ILguiListener>();
	
	/**
	 * List of encapsulated classes, which handle parts of the lml-hierarchy
	 */
	private HashMap< Class<? extends ILguiHandler>, ILguiHandler > lguiHandlers = new HashMap< Class<? extends ILguiHandler>, ILguiHandler >();
	
	
//	private ListenerList listeners = new ListenerList();
	/**
	 * Create a manager for a LguiType-instance.
	 * @param pmodel LML-data-model, which is managed by this class
	 */
	public LguiItem(LguiType pmodel){
		
		lgui=pmodel;
		
		//globally accessible libraries, they encapsulate modules, which manage lml-datamodels
		
		createLguiHandlers();
	}
	
	/**
	 * Constructor with one argument, an URL.
	 * Within the constructor the method for parsing an XML-file into LguiItem is called.
	 * @param xmlFile the source of the XML file.
	 */
	public LguiItem(URL xmlFile) {
		
		this.xmlFile = xmlFile;
		try {
			lgui = parseLML(xmlFile);
		} catch (MalformedURLException e) {
			e.printStackTrace();
		}
		
		createLguiHandlers();
		
	}
	
	/**
	 * The instance lgui is filled with a new data-model. This method
	 * creates all modules, which handle the data. These modules can
	 * then be accessed by corresponding getter-functions.
	 */
	private void createLguiHandlers(){
		lguiHandlers.put(OverviewAccess.class, new OverviewAccess(this, lgui));
		lguiHandlers.put(LayoutAccess.class, new LayoutAccess(this, lgui));//component-id => component-layout
		lguiHandlers.put(OIDToObject.class, new OIDToObject(this, lgui));//get object-instance for object-ids and colors for ids
		lguiHandlers.put(ObjectStatus.class, new ObjectStatus(this, lgui));//get current interaction status for objects
		lguiHandlers.put(OIDToInformation.class, new OIDToInformation(this, lgui));//Get infos for objects
		lguiHandlers.put(TableHandler.class, new TableHandler(this, lgui));
		lguiHandlers.put(NodedisplayAccess.class, new NodedisplayAccess(this, lgui));//access to layouts of nodedisplays
		
	}

	/*
	 * Methods for operating with the system
	 */
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ptp.rm.lml.core.elements.ILguiItem#getXMLFile()
	 */
	public URL getXmlFile() {
		return xmlFile;
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ptp.rm.lml.core.elements.ILguiItem#toString
	 */
	public String toString() {
		if (getXmlFile().getPath() == null) {
			return "es gibt hier nix";
		}
		return getXmlFile().getPath();
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ptp.rm.lml.core.elements.ILguiItem#getVersion()
	 */
	public String getVersion() {
		return lgui.getVersion();
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ptp.rm.lml.core.elements.ILguiItem#isLayout()
	 */
	public boolean isLayout() {
		return lgui.isLayout();
	}
	
	public LguiType getLguiType() {
		return lgui;
	}
	
	
	
	/**
	 * Parsing an XML file.
	 * The method generates from an XML file an instance of LguiType.
	 * @param xml the URL source of the XML file
	 * @return sthe generated LguiType
	 * @throws MalformedURLException 
	 * @throws JAXBException
	 */
	private static LguiType parseLML(URL xml) throws MalformedURLException{
		LguiType lml = null;
		try {
			Unmarshaller unmarshaller = LMLCorePlugin.getDefault().getUnmarshaller();
			
			JAXBElement<LguiType> doc = (JAXBElement<LguiType>)unmarshaller.unmarshal(xml);
			
			lml = doc.getValue();
		} catch (JAXBException e) {
			e.printStackTrace();
		}
		
		return lml;
		
	}
	
	public OverviewAccess getOverviewAccess() {
		if (lguiHandlers.get(OverviewAccess.class) == null) {
			return null;
		}
		return (OverviewAccess) lguiHandlers.get(OverviewAccess.class);
	}
	
	public TableHandler getTableHandler() {
		if(lguiHandlers.get( TableHandler.class)==null)
			return null;
		return (TableHandler) lguiHandlers.get(TableHandler.class);
	}
	
	/**
	 * Add a lml-data-listener. It listens for data-changes.
	 * @param listener new listening instance
	 */
	public void addListener( ILguiListener listener ) 
	{ 
		listeners.add( listener ); 
	} 
	
	/**
	 * Remove a lml-data-listener.
	 * @param listener listening instance
	 */
	public void removeListener( ILguiListener listener ) 
	{ 
		listeners.remove( listener ); 
	}
	
	/**
	 * @return a class, which provides an index for fast access
     * to objects within the objects tag of LML. You can pass
     * the id of the objects to the returned object. It then returns
     * the corresponding objects.
	 */
	public OIDToObject getOIDToObject(){
		if(lguiHandlers.get( OIDToObject.class)==null)
			return null;
		return (OIDToObject)lguiHandlers.get( OIDToObject.class);
	}
	
	/**
	 * @return a object, which saves which object has to be highlighted. All
	 * user interactions are saved globally for all components in this object.
	 */
	public ObjectStatus getObjectStatus(){
		if(lguiHandlers.get( ObjectStatus.class)==null)
			return null;
		return (ObjectStatus)lguiHandlers.get( ObjectStatus.class);
	}
	
	/**
	 * @return object for getting infos for objects
	 */
	public OIDToInformation getOIDToInformation(){
		if(lguiHandlers.get( OIDToInformation.class)==null)
			return null;
		return (OIDToInformation)lguiHandlers.get( OIDToInformation.class);
	}
	
	/**
	 * @return NodedisplayAccess-instance for accessing layouts of nodedisplays
	 */
	public NodedisplayAccess getNodedisplayAccess(){
		if(lguiHandlers.get( NodedisplayAccess.class)==null)
			return null;
		return (NodedisplayAccess)lguiHandlers.get( NodedisplayAccess.class);
	}
	
	/**
	 * @return object to map component-ids to corresponding layout definitions 
	 */
	public LayoutAccess getLayoutAccess(){
		if(lguiHandlers.get( LayoutAccess.class)==null)
			return null;
		return (LayoutAccess)lguiHandlers.get( LayoutAccess.class);
	}

	/**
	 * Call this method, if lml-model changed. The new model is passed
	 * to the listening handlers. All getter-functions accessing the handler will
	 * then return data, which is collected from this new model
	 * @param model new lml-data-model
	 */
	public void updateData(LguiType pmodel) {
		
		lgui=pmodel;
		
		LguiUpdatedEvent event = new LguiUpdatedEvent(this);
		
		//Inform all listener
		for ( ILguiListener l : listeners ) 
		      l.handleEvent(event);
	}
	
	public void update() {
		for (ILguiListener listener : listeners) {
			ILguiUpdatedEvent e = new LguiUpdatedEvent(this);
			listener.handleEvent(e);
		}
	}

}