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

Go to the documentation of this file.

package m2m.frontend.dynamicview.model;

import java.util.Vector;

import m2m.backend.structure.IfThenElse;
import m2m.backend.structure.Multiplexer;
import m2m.backend.structure.Operation;
import m2m.backend.structure.StructTreatment;
import m2m.frontend.dynamicview.figure.IfFigure;
import m2m.frontend.dynamicview.figure.InternPointConnectionFigure;
import m2m.frontend.view.Editor;

import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.ui.PlatformUI;



public class GraphicIf extends Node
{
        private String condition;
        private InternPointConnection truePoint = new InternPointConnection();
        private InternPointConnection falsePoint = new InternPointConnection();
        private InternPointConnection outPoint = new InternPointConnection();
        private PointConnection outputPointConnection = null;
        private Vector<Node> conditionNodes = new Vector<Node>();
        
        
        public GraphicIf()
        {
                super();
                
                /* Initialisation of the true intern connection point */
        truePoint.setName("true");
        truePoint.setParent(this);
        truePoint.setLayout(new Rectangle (IfFigure.TRUE_POINT_X_POSITION,IfFigure.TRUE_POINT_Y_POSITION,
                                                   InternPointConnectionFigure.WIDTH, InternPointConnectionFigure.HEIGHT));    
        
        /* Initialisation of the false intern connection point */
        falsePoint.setName("false");
        falsePoint.setParent(this);
        falsePoint.setLayout(new Rectangle (IfFigure.FALSE_POINT_X_POSITION,IfFigure.FALSE_POINT_Y_POSITION,
                                                    InternPointConnectionFigure.WIDTH, InternPointConnectionFigure.HEIGHT));       
        
        /* Initialisation of the out intern connection point */
        outPoint.setName("out");
        outPoint.setParent(this);
        outPoint.setLayout(new Rectangle (IfFigure.OUT_POINT_X_POSITION,IfFigure.OUT_POINT_Y_POSITION,
                                                  InternPointConnectionFigure.WIDTH, InternPointConnectionFigure.HEIGHT));      
        }
        
        
        public PointConnection getOutputPointConnection()
        {
                return outputPointConnection;
        }
        
        
        public void setOutputPointConnexion(PointConnection pc)
        {
                outputPointConnection = pc;
                pc.setOutputResult(this);
        }
        
        
        public boolean getMonitor()
        {
                if(getElement() instanceof Multiplexer)
                        return ((Multiplexer)getElement()).getSel().getMonitor();
                else
                        return ((Operation)((IfThenElse)getElement()).getCond().firstElement()).getInputAt(0).getMonitor();
        }
        
        
        public void setMonitor(boolean monitor)
        {
                Editor editor = (Editor)PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
                StructTreatment treatment = editor.getM2MProject().getStructTreatment();
                
                if(getElement() instanceof Multiplexer)
                        ((Multiplexer)getElement()).getSel().setMonitor(monitor,treatment);
                else
                        ((Operation)((IfThenElse)getElement()).getCond().firstElement()).getInputAt(0).setMonitor(monitor,treatment);
        }
        
        
        public String getCondition()
        {
                return condition;
        }
        
        
        public void setCondition(String cond)
        {
                condition = cond;
        }
        
        
        public InternPointConnection getTruePoint()
        {
                return truePoint;
                
        }
        
        
        public InternPointConnection getFalsePoint()
        {
                return falsePoint;
        }
        
        
        public InternPointConnection getOutPoint()
        {
                return outPoint;
        }
        
        
    public void addConditionNodes(Node node) 
        {
        if (node == null)
            throw new IllegalArgumentException();
        else 
                conditionNodes.add(node);     
    }
        
    
    public void removeConditionNodes(Node node) 
        {
        if (node == null)
            throw new IllegalArgumentException();
        else 
                conditionNodes.remove(node);     
    }
        
        
        public Vector<Node> getConditionNodes() 
        {
        return conditionNodes;
        }
        
        
    public Vector<Node> getChildrenArray() 
    {
        Vector<Node> children = new Vector<Node>();
        children.add(truePoint);
        children.add(falsePoint);
        children.add(outPoint);
        return children;
    }
    
    
    public void setVisible(boolean visible) 
    {
                super.setVisible(visible);
                truePoint.setVisible(visible);
                falsePoint.setVisible(visible);
                outPoint.setVisible(visible);
    }     
    
    
        public boolean CanSetLayout(Rectangle layoutTest)
        {
                /* Check if the new layout is inside its parent */
                if(!isInParent(layoutTest))
                        return false;
                
                /* Check if the new layout is under connection points */
                for(Node node : getParent().getChildrenArray())
                {
                        if(node != this && node != outputPointConnection)
                                if(nodeUnderNode(layoutTest, node.getLayout()))
                                        return false;
                }               
                return true;
        }
}