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

Go to the documentation of this file.

package m2m.frontend.dynamicview.model;

import java.util.Vector;

import m2m.backend.structure.Operation;
import m2m.backend.structure.StructTreatment;
import m2m.frontend.dynamicview.figure.InternPointConnectionFigure;
import m2m.frontend.dynamicview.figure.LoopIteratorFigure;
import m2m.frontend.view.Editor;

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

public class GraphicLoopIterator extends Node
{
        private boolean selectAll;
        private String startInitialisation;
        private String incrementation;
        private String endCondition;
        private InternPointConnection outPoint = new InternPointConnection();
        private PointConnection outputPointConnection = null;
        private Vector<Node> conditionNodes = new Vector<Node>();
        private Operation iterOperation;
        
        public GraphicLoopIterator ()
        {
                super();
                
                startInitialisation = "Unknown";
                incrementation = "Unknown";
                endCondition = "Unknown";
                
                /* Initialisation of the out intern connection point */
                outPoint.setName("out");
            outPoint.setParent(this);
            outPoint.setLayout(new Rectangle (LoopIteratorFigure.OUT_POINT_X_POSITION, LoopIteratorFigure.OUT_POINT_Y_POSITION,
                                                      InternPointConnectionFigure.WIDTH, InternPointConnectionFigure.HEIGHT));
            
            iterOperation = null;
        }
        
        
        public GraphicLoopIterator (String startInit, String inc, String endCond, Operation op)
        {
                super();
                
                startInitialisation = startInit;
                incrementation = inc;
                endCondition = endCond;
                
                /* Initialisation of the out intern connection point */
                outPoint.setName("out");
            outPoint.setParent(this);
            outPoint.setLayout(new Rectangle (LoopIteratorFigure.OUT_POINT_X_POSITION, LoopIteratorFigure.OUT_POINT_Y_POSITION,
                                                      InternPointConnectionFigure.WIDTH, InternPointConnectionFigure.HEIGHT));
            
            iterOperation = op;
        }
        
        
        public boolean getMonitor()
        {
                return getElement().getMonitor();
        }
        
        
        public void setMonitor(boolean monitor)
        { 
                Editor editor = (Editor)PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
                StructTreatment treatment = editor.getM2MProject().getStructTreatment();

                getElement().setMonitor(monitor,treatment);
        }
        
        
        public String getStartInitialisation()
        {
                return startInitialisation;
        }
        
        
        public void setStartInitialisation(String startInit)
        {
                startInitialisation = startInit;
        }
        
        
        public String getIncrementation()
        {
                return incrementation;
        }
        
        
        public void setIncrementation(String inc)
        {
                incrementation = inc;
        }
        
        
        public String getEndCondition()
        {
                return endCondition;
        }
        
        
        public void setEndCondition(String endCond)
        {
                endCondition = endCond;
        }
        
        
        public InternPointConnection getOutPoint()
        {
                return outPoint;
        }
                
        
    public Vector<Node> getChildrenArray() 
    {
        Vector<Node> children = new Vector<Node>();
        children.add(outPoint);
        return children;
    }
    
    
    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 void setVisible(boolean visible) 
    {
                super.setVisible(visible);
                outPoint.setVisible(visible);
    }     
    
    
        public PointConnection getOutputPointConnection()
        {
                return outputPointConnection;
        }
        
        
        public void setOutputPointConnexion(PointConnection pc)
        {
                outputPointConnection = pc;
                pc.setOutputResult(this);
        }
        
        
        public Operation getIterOperation() {
                return iterOperation;   
        }

        
        public void setIterOperation(Operation op) {
                iterOperation = op;
        }
        
        public void setSelectAll(boolean val)
        {
                this.selectAll = val;
        }
        
        
        public boolean getSelectAll()
        {
                return selectAll;
        }
        
        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;
        }
}