/home/ythoma/docs/math2mat/svn/wp1/framework/m2mGUI/src/m2m/frontend/dynamicview/editPart/FunctionPart.java

Go to the documentation of this file.

package m2m.frontend.dynamicview.editPart;

import java.beans.PropertyChangeEvent;
import java.util.Vector;

import org.eclipse.draw2d.ActionEvent;
import org.eclipse.draw2d.ActionListener;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.EditPolicy;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;

import m2m.backend.structure.Function;
import m2m.frontend.dynamicview.ThreadRouteConnections;
import m2m.frontend.dynamicview.editpolicies.EditLayoutPolicy;
import m2m.frontend.dynamicview.figure.FunctionFigure;
import m2m.frontend.dynamicview.figure.PointConnectionFigure;
import m2m.frontend.dynamicview.model.Connection;
import m2m.frontend.dynamicview.model.GraphicFunction;
import m2m.frontend.dynamicview.model.GraphicLoop;
import m2m.frontend.dynamicview.model.Node;
import m2m.frontend.dynamicview.model.PointConnection;
import m2m.frontend.view.Editor;



public class FunctionPart extends AbstractEditPart implements ActionListener
{
        private int redInY;
        private int redOutY;
        
        
    @Override
    protected IFigure createFigure() 
    {
        IFigure figure = new FunctionFigure();
        ((FunctionFigure) figure).getBtnMinimize().addActionListener(this);
        ((FunctionFigure) figure).addMouseMotionListener(this);
        ((FunctionFigure) figure).addMouseListener(this);
        return figure;
    }

    
    @Override
    protected void createEditPolicies() 
    {
        installEditPolicy(EditPolicy.LAYOUT_ROLE, new EditLayoutPolicy()); 
    }
    
    
    protected void refreshVisuals()
    { 
        /* Get the figure and the model */
        FunctionFigure figure = (FunctionFigure)getFigure();
        GraphicFunction model = (GraphicFunction)getModel();

        /* Update the figure with the model */
        figure.setName(model.getName());
        figure.setLayout(model.getLayout());
        figure.setVisible(model.getVisible());
    }

    
    public Vector<Node> getModelChildren()
    {
        return ((GraphicFunction)getModel()).getChildrenArray();
    }
    
    
    
        @Override
        public void propertyChange(PropertyChangeEvent evt) 
        {
                 if (evt.getPropertyName().equals(Node.LAYOUT)) 
                         refreshVisuals();
                 else if(evt.getPropertyName().equals(Node.VISIBLE_COMPONENT))
                         refreshVisuals();
        }


        @Override
        public void actionPerformed(ActionEvent arg0) 
        {               
                ((GraphicFunction)getModel()).setNotReduct(!((GraphicFunction)getModel()).getNotReduct());
                ((GraphicFunction)getModel()).setNotReduct(reductionWindow(((GraphicFunction)getModel()).getNotReduct()));
        }
        
        
        public boolean reductionWindow(boolean visible)
        {
        int x;
        int y;  
        
                /* Initialize the y reduction position of input and output connection point */
                redInY  = FunctionFigure.SPACE_REDUCTION;
                redOutY = FunctionFigure.SPACE_REDUCTION;
                int maxInOut;
                        
                // Get the function model
        GraphicFunction model = (GraphicFunction)getModel();
        
        // Check if the function can be maximize
        if(!visible || (visible && model.CanSetLayout(new Rectangle(model.getLayout().x, model.getLayout().y, model.getLayoutReduction().width, model.getLayoutReduction().height))))
        {               
                Vector<Node> nodes = new Vector<Node>();
                
                /* Reverse the children vector of the function */
                        for(Node node : model.getChildrenArray()) 
                                nodes.add(0, node);
                        
                        for(Node node : nodes)
                        {
                                /* Mask/Unmask the nodes who has no connections outside the function */
                                if(!hasExternConnection(node, visible))
                                        node.setVisible(visible);
                                
                                if(node instanceof GraphicLoop && !((GraphicLoop)node).getIsReduct())
                                        ((GraphicLoop)node).setConnectionsVisible(visible);
                                else
                                {
                                        /* Mask/Unmask the sources connections inside the function */
                                        for(Connection conn : node.getSourceConnections())
                                                if((children.contains(conn.getTarget()) || !(conn.getTarget().getParent() == conn.getSource().getParent().getParent())))
                                                        conn.setVisible(visible);
                                                
                                        /* Mask/Unmask the targets connections inside the function */
                                        for(Connection conn : node.getTargetConnections())
                                                if( (children.contains(conn.getSource()) || !(conn.getSource().getParent() == conn.getTarget().getParent().getParent())))
                                                        conn.setVisible(visible);
                                }
                        }               
                        
                        int space = 1;
                        
                        /* Set the layout of the output connection points and the function */
                        if(!visible)
                        {                               
                                for(PointConnection pc : model.getOutputPointsConnection())
                                {
                                x =  model.getLayout().x + model.getReductSizeWidth() + 15;
                                y =  model.getLayout().y + FunctionFigure.SPACE_REDUCTION*space + 2;                    
                                pc.setLayoutReduction(new Rectangle(x, y, 10, 10));
                                space++;
                                }
                                maxInOut = Math.max(model.getOutputPointsConnection().size(), ((Function)model.getElement()).getInput().size())+1;
                                model.setSize(model.getReductSizeWidth(), maxInOut*FunctionFigure.SPACE_REDUCTION+model.getReductSizeHeight()); 
                        }               
                        else
                        {
                        for(PointConnection pc : model.getOutputPointsConnection())
                                {
                                        x =  pc.getLayoutReduction().x + model.getLayout().x - model.getLayoutReduction().x;
                                y =  pc.getLayoutReduction().y + model.getLayout().y - model.getLayoutReduction().y;
                                pc.setLayout(new Rectangle(x, y, PointConnectionFigure.WIDTH, PointConnectionFigure.HEIGHT));
                                pc.removeLayoutReduction();
                                }       
                        model.setSize(model.getFullSizeWidth(), model.getFullSizeHeight());     
                        }
                        
                        if(model instanceof GraphicLoop)
                                ((GraphicLoop)model).setIsReduct(!((GraphicLoop)model).getIsReduct());
                        
                        // Route Connections
                        Display.getCurrent().asyncExec(new ThreadRouteConnections());
                        return visible;
        }
       
        Editor editor = (Editor)PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
            MessageDialog.openError(editor.getSite().getShell(), "Error", "This action is not allowed!");
            
        return !visible;        
        }
        
        
        public boolean hasExternConnection(Node node, boolean visible)
        {
                // Get the list of children of the function
                Vector<Node> children = ((GraphicFunction) getModel()).getChildrenArray();      
                                
                /* Check if the node has extern source connection */
                for(Connection conn : node.getSourceConnections())
                {
                        if(!children.contains(conn.getTarget()) && (conn.getTarget().getParent() == conn.getSource().getParent().getParent()))
                        {
                                /* Set the new layout of the PointConnection */
                                if(!visible)
                                {
                                        node.setLayoutReduction(new Rectangle(((GraphicFunction) getModel()).getReductSizeWidth()-PointConnectionFigure.WIDTH-12, redOutY, 10, 10));                            
                                        redOutY += FunctionFigure.SPACE_REDUCTION;
                                }
                                else
                                {
                                        node.setLayout(node.getLayoutReduction());              
                                        node.removeLayoutReduction();
                                }
                                return true;
                        }
                }
                
                /* Check if the node has extern target connection */
                for(Connection conn : node.getTargetConnections())
                {
                        if(!children.contains(conn.getSource()) && (conn.getSource().getParent() == conn.getTarget().getParent().getParent()))
                        {
                                /* Set the new layout of the PointConnection */
                                if(!visible)
                                {
                                        node.setLayoutReduction(new Rectangle(0, redInY, 10, 10));                              
                                        redInY += FunctionFigure.SPACE_REDUCTION;
                                }
                                else
                                {
                                        node.setLayout(node.getLayoutReduction());              
                                        node.removeLayoutReduction();
                                }
                                return true;
                        }
                }
                
                return false;
        }
}