/home/ythoma/docs/math2mat/svn/wp1/framework/m2mGUI/src/m2m/frontend/dynamicview/model/Node.java

Go to the documentation of this file.

package m2m.frontend.dynamicview.model;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.Vector;

import m2m.backend.structure.Element;

import org.eclipse.draw2d.geometry.Rectangle;


public abstract class Node
{
    public static final String LAYOUT = "Layout";
    public static final String VISIBLE_COMPONENT = "VisibleComponent";
        public static final String CHANGE_COLOR = "ChangeColor";
        
        
    private String name;
    private Rectangle layout;
    private Vector<Rectangle> layoutReduction = new Vector<Rectangle>();
    private Vector<Node> children;
    private Node parent;
    private boolean visible = true;
    private PropertyChangeSupport listeners;
        private Vector<Connection> sourceConnections = new Vector<Connection>();
        private Vector<Connection> targetConnections = new Vector<Connection>();
    private boolean colorConditionSelected = false;
    private int level;
    private int depthLevel;
    private Element element;
        
        
    public Node()
    {
        this.name = "Unknown";
        this.layout = new Rectangle(10, 10, 100, 100);
        this.children = new Vector<Node>();
        this.parent = null;
        this.listeners = new PropertyChangeSupport(this);
    }
    
    
    public void setLevel(int level)
    {
        this.level = level;
    }
    
    
    public int getLevel()
    {
        return level;
    }
    
    
    public void setElement(Element element)
    {
        this.element = element;
    }
    
    
    public Element getElement()
    {
        return element;
    }
    
    
    public void addConnection(Connection conn) 
        {
        if (conn == null || conn.getSource() == conn.getTarget()) 
            throw new IllegalArgumentException();
        if (conn.getSource() == this) 
            sourceConnections.add(conn);
        else if (conn.getTarget() == this) 
            targetConnections.add(conn);     
    }
        
    
        public void removeConnection(Connection conn) 
        {
        if (conn == null) 
            throw new IllegalArgumentException();
        if (conn.getSource() == this) 
            sourceConnections.remove(conn);
        else if (conn.getTarget() == this) 
            targetConnections.remove(conn);
    }
        
        
        public Vector<Connection> getSourceConnections() 
        {
        return sourceConnections;
    }
    
        
        public Vector<Connection> getTargetConnections()
        {
        return targetConnections;
    }
   
    
    public void setName(String name) 
    {
        this.name = name;
    }
    
    
    public String getName() 
    {
        return this.name;
    }
    

    public boolean getVisible() 
    {
        return this.visible;
    }
       
    
    public void setVisible(boolean visible) 
    {
                boolean odlValue = this.visible;
                this.visible = visible;
                firePropertyChange(Node.VISIBLE_COMPONENT, odlValue, visible);
    }       
       
    
    public void setLayout(Rectangle newLayout) 
    {
        Rectangle oldLayout = this.layout;
        this.layout = newLayout;
        getListeners().firePropertyChange(LAYOUT, oldLayout, newLayout);
    }
    
    
    public void setLayoutReduction(Rectangle newLayout) 
    {
        layoutReduction.add(0, new Rectangle(layout));
        this.layout = newLayout;
        getListeners().firePropertyChange(LAYOUT, layoutReduction.firstElement(), newLayout);
    }
    
    
    public Rectangle getLayout() 
    {
        return this.layout;
    }
    
    
    public Rectangle getLayoutReduction() 
    {
        return layoutReduction.firstElement();
    }
    
    
    public void removeLayoutReduction() 
    {
        layoutReduction.remove(layoutReduction.firstElement());
    }
    
    
    public void addChild(Node child) 
    {
        child.setParent(this);
        this.children.add(child);
    }
    
    
    public void removeChild(Node child) 
    {
        this.children.remove(child);
    }
    
    
    public Vector<Node> getChildrenArray() 
    {
        return this.children;
    }
    
    
    public void setParent(Node parent) 
    {
        this.parent = parent;
    }
    
    
    public Node getParent() 
    {
        return this.parent;
    }
       
    
        public boolean getColorConditionSelected()
        {
                return colorConditionSelected;
        }
        
        
        public void setColorConditionSelected(boolean colorConditionSelected)
        {
                boolean odlValue = this.colorConditionSelected;
                this.colorConditionSelected = colorConditionSelected;
                firePropertyChange(Node.CHANGE_COLOR, odlValue, colorConditionSelected);        
        }
        
        
    public void addPropertyChangeListener(PropertyChangeListener listener) 
    {
        listeners.addPropertyChangeListener(listener);
        }
          
    
        public void removePropertyChangeListener(PropertyChangeListener listener) 
        {
            listeners.removePropertyChangeListener(listener);
        }
        
    
        public PropertyChangeSupport getListeners() 
        {  
            return listeners;
        }
        
        
        protected void firePropertyChange(String property, Object oldValue, Object newValue) 
        {
                if (listeners.hasListeners(property))
                        listeners.firePropertyChange(property, oldValue, newValue);
        }
        
        
        public boolean CanSetLayout(Rectangle layoutTest)
        {
                /* Check if the new layout is under a node */
                for(Node node : parent.getChildrenArray())
                {
                        if(node != this)
                                if(nodeUnderNode(layoutTest, node.getLayout()))
                                        return false;
                }               
                
                return true;
        }
        
        
        public boolean nodeUnderNode(Rectangle layoutTest, Rectangle layoutNode)
        {
                Rectangle tempLayoutTest = new Rectangle(layoutTest.x-5, layoutTest.y-5, layoutTest.width+10, layoutTest.height+10); 
                Rectangle tempLayoutNode = new Rectangle(layoutNode.x-5, layoutNode.y-5, layoutNode.width+10, layoutNode.height+10);
                
                return tempLayoutTest.intersects(tempLayoutNode);
        }
        
        
        public boolean isInParent(Rectangle layoutTest)
        {
                Rectangle parentLayout = parent.getLayout();
                
                if(layoutTest.x < 0 || layoutTest.y < 0)
                        return false;
                
                if(!(parent instanceof Schema) && (layoutTest.x+layoutTest.width > parentLayout.width || layoutTest.y+layoutTest.height > parentLayout.height))
                        return false;
                
                return true;
        }
        
        public void setDepthLevel()
        {
                Node node = this;
                int level = 0;
                
                while(!(node instanceof Schema))
                {
                        if(node instanceof InternPointConnection)
                                node = node.getParent();
                        
                        level++;
                        node = node.getParent();
                }
                
                depthLevel = level;
        }
        
        public int getDepthLevel()
        {
                return depthLevel;
        }
}