PublisherEditPart.java

Go to the documentation of this file.

package org.ros.model.ros.diagram.edit.parts;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.FlowLayout;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.LineBorder;
import org.eclipse.draw2d.MarginBorder;
import org.eclipse.draw2d.RectangleFigure;
import org.eclipse.draw2d.ScalablePolygonShape;
import org.eclipse.draw2d.Shape;
import org.eclipse.draw2d.StackLayout;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PrecisionPoint;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPolicy;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.editpolicies.LayoutEditPolicy;
import org.eclipse.gef.requests.CreateRequest;
import org.eclipse.gmf.runtime.diagram.ui.editparts.AbstractBorderItemEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.EditPolicyRoles;
import org.eclipse.gmf.runtime.diagram.ui.editpolicies.FlowLayoutEditPolicy;
import org.eclipse.gmf.runtime.draw2d.ui.figures.ConstrainedToolbarLayout;
import org.eclipse.gmf.runtime.draw2d.ui.figures.WrappingLabel;
import org.eclipse.gmf.runtime.draw2d.ui.mapmode.MapModeUtil;
import org.eclipse.gmf.runtime.emf.type.core.IElementType;
import org.eclipse.gmf.runtime.gef.ui.figures.DefaultSizeNodeFigure;
import org.eclipse.gmf.runtime.gef.ui.figures.NodeFigure;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.swt.graphics.Color;
import org.ros.model.ros.diagram.DefaultSizeNodeFigureWithFixedAnchors;
import org.ros.model.ros.diagram.edit.policies.PublisherItemSemanticEditPolicy;
import org.ros.model.ros.diagram.part.RosVisualIDRegistry;
import org.ros.model.ros.diagram.providers.RosElementTypes;

public class PublisherEditPart extends AbstractBorderItemEditPart {

        public static final int VISUAL_ID = 3003;

        protected IFigure contentPane;

        protected IFigure primaryShape;

        public PublisherEditPart(View view) {
                super(view);
        }

        protected void createDefaultEditPolicies() {
                super.createDefaultEditPolicies();
                installEditPolicy(EditPolicy.PRIMARY_DRAG_ROLE,
                                getPrimaryDragEditPolicy());
                installEditPolicy(EditPolicyRoles.SEMANTIC_ROLE,
                                new PublisherItemSemanticEditPolicy());
                installEditPolicy(EditPolicy.LAYOUT_ROLE, createLayoutEditPolicy());
                // XXX need an SCR to runtime to have another abstract superclass that would let children add reasonable editpolicies
                // removeEditPolicy(org.eclipse.gmf.runtime.diagram.ui.editpolicies.EditPolicyRoles.CONNECTION_HANDLES_ROLE);
        }

        protected LayoutEditPolicy createLayoutEditPolicy() {

                FlowLayoutEditPolicy lep = new FlowLayoutEditPolicy() {

                        protected Command createAddCommand(EditPart child, EditPart after) {
                                return null;
                        }

                        protected Command createMoveChildCommand(EditPart child,
                                        EditPart after) {
                                return null;
                        }

                        protected Command getCreateCommand(CreateRequest request) {
                                return null;
                        }
                };
                return lep;
        }

        protected IFigure createNodeShape() {
                return primaryShape = new Publisher2Figure();
        }

        public Publisher2Figure getPrimaryShape() {
                return (Publisher2Figure) primaryShape;
        }

        protected boolean addFixedChild(EditPart childEditPart) {
                if (childEditPart instanceof PublisherNameEditPart) {
                        ((PublisherNameEditPart) childEditPart).setLabel(getPrimaryShape()
                                        .getFigurePublisherNameFigure());
                        return true;
                }
                return false;
        }

        protected boolean removeFixedChild(EditPart childEditPart) {
                if (childEditPart instanceof PublisherNameEditPart) {
                        return true;
                }
                return false;
        }

        protected void addChildVisual(EditPart childEditPart, int index) {
                if (addFixedChild(childEditPart)) {
                        return;
                }
                super.addChildVisual(childEditPart, -1);
        }

        protected void removeChildVisual(EditPart childEditPart) {
                if (removeFixedChild(childEditPart)) {
                        return;
                }
                super.removeChildVisual(childEditPart);
        }

        protected IFigure getContentPaneFor(IGraphicalEditPart editPart) {
                return getContentPane();
        }

        protected NodeFigure createNodePlate() {
                HashMap<String, PrecisionPoint> anchorLocations = new HashMap<String, PrecisionPoint>();
                //anchorLocations.put("WEST", new PrecisionPoint(0, 0.5d));
                anchorLocations.put("EAST", new PrecisionPoint(1d, 0.5d));
                //anchorLocations.put("NORTH", new PrecisionPoint(0.5d, 0));
                //anchorLocations.put("SOUTH", new PrecisionPoint(0.5d, 1d));
                DefaultSizeNodeFigureWithFixedAnchors result = new DefaultSizeNodeFigureWithFixedAnchors(
                                60, 20, anchorLocations);
                //FIXME: workaround for #154536
                result.getBounds().setSize(result.getPreferredSize());
                return result;
        }

        protected NodeFigure createNodeFigure() {
                NodeFigure figure = createNodePlate();
                figure.setLayoutManager(new StackLayout());
                IFigure shape = createNodeShape();
                figure.add(shape);
                contentPane = setupContentPane(shape);
                return figure;
        }

        protected IFigure setupContentPane(IFigure nodeShape) {
                if (nodeShape.getLayoutManager() == null) {
                        ConstrainedToolbarLayout layout = new ConstrainedToolbarLayout();
                        layout.setSpacing(5);
                        nodeShape.setLayoutManager(layout);
                }
                return nodeShape; // use nodeShape itself as contentPane
        }

        public IFigure getContentPane() {
                if (contentPane != null) {
                        return contentPane;
                }
                return super.getContentPane();
        }

        protected void setForegroundColor(Color color) {
                if (primaryShape != null) {
                        primaryShape.setForegroundColor(color);
                }
        }

        protected void setBackgroundColor(Color color) {
                if (primaryShape != null) {
                        primaryShape.setBackgroundColor(color);
                }
        }

        protected void setLineWidth(int width) {
                if (primaryShape instanceof Shape) {
                        ((Shape) primaryShape).setLineWidth(width);
                }
        }

        protected void setLineType(int style) {
                if (primaryShape instanceof Shape) {
                        ((Shape) primaryShape).setLineStyle(style);
                }
        }

        public EditPart getPrimaryChildEditPart() {
                return getChildBySemanticHint(RosVisualIDRegistry
                                .getType(PublisherNameEditPart.VISUAL_ID));
        }

        public List<IElementType> getMARelTypesOnSource() {
                ArrayList<IElementType> types = new ArrayList<IElementType>(1);
                types.add(RosElementTypes.Topic_4001);
                return types;
        }

        public List<IElementType> getMARelTypesOnSourceAndTarget(
                        IGraphicalEditPart targetEditPart) {
                LinkedList<IElementType> types = new LinkedList<IElementType>();
                if (targetEditPart instanceof SubscriberEditPart) {
                        types.add(RosElementTypes.Topic_4001);
                }
                return types;
        }

        public List<IElementType> getMATypesForTarget(IElementType relationshipType) {
                LinkedList<IElementType> types = new LinkedList<IElementType>();
                if (relationshipType == RosElementTypes.Topic_4001) {
                        types.add(RosElementTypes.Subscriber_3004);
                }
                return types;
        }

        public class Publisher2Figure extends ScalablePolygonShape {
                public static final int BLUR_SHADOW_WIDTH = 5;

                @Override
                public void paintFigure(Graphics graphics) {
                        drawBlurredShadow(graphics);
                        super.paintFigure(graphics);
                }

                private void drawBlurredShadow(Graphics graphics) {
                        // draw the shadow...
                        graphics.pushState();

                        int size = MapModeUtil.getMapMode(this).DPtoLP(BLUR_SHADOW_WIDTH);
                        int step = MapModeUtil.getMapMode(this).DPtoLP(-1);

                        graphics.setForegroundColor(ColorConstants.gray);
                        graphics.setLineWidth(MapModeUtil.getMapMode(this).DPtoLP(2));
                        graphics.translate(size, size);
                        graphics.setClip(graphics.getClip(new Rectangle(getBounds()))
                                        .expand(size, size));
                        graphics.setAlpha(20);
                        outlineShape(graphics);
                        graphics.translate(step, step);
                        graphics.setAlpha(30);
                        outlineShape(graphics);
                        graphics.translate(step, step);
                        graphics.setAlpha(60);
                        outlineShape(graphics);
                        graphics.translate(step, step);
                        graphics.setAlpha(100);
                        outlineShape(graphics);
                        graphics.translate(step, step);
                        graphics.setAlpha(150);
                        outlineShape(graphics);

                        graphics.popState();
                }

                private WrappingLabel fFigurePublisherNameFigure;

                public Publisher2Figure() {

                        FlowLayout layoutThis = new FlowLayout();
                        layoutThis.setStretchMinorAxis(false);
                        layoutThis.setMinorAlignment(FlowLayout.ALIGN_CENTER);

                        layoutThis.setMajorAlignment(FlowLayout.ALIGN_CENTER);
                        layoutThis.setMajorSpacing(5);
                        layoutThis.setMinorSpacing(5);
                        layoutThis.setHorizontal(false);

                        this.setLayoutManager(layoutThis);

                        this.addPoint(new Point(getMapMode().DPtoLP(0), getMapMode()
                                        .DPtoLP(0)));
                        this.addPoint(new Point(getMapMode().DPtoLP(30), getMapMode()
                                        .DPtoLP(0)));
                        this.addPoint(new Point(getMapMode().DPtoLP(40), getMapMode()
                                        .DPtoLP(20)));
                        this.addPoint(new Point(getMapMode().DPtoLP(30), getMapMode()
                                        .DPtoLP(40)));
                        this.addPoint(new Point(getMapMode().DPtoLP(0), getMapMode()
                                        .DPtoLP(40)));
                        this.setFill(true);
                        this.setForegroundColor(THIS_FORE);
                        this.setBackgroundColor(THIS_BACK);
                        this.setPreferredSize(new Dimension(getMapMode().DPtoLP(80),
                                        getMapMode().DPtoLP(20)));

                        this.setBorder(new MarginBorder(getMapMode().DPtoLP(2),
                                        getMapMode().DPtoLP(2), getMapMode().DPtoLP(2),
                                        getMapMode().DPtoLP(2)));
                        createContents();
                }

                private void createContents() {

                        fFigurePublisherNameFigure = new WrappingLabel();

                        fFigurePublisherNameFigure.setText("<...>");

                        this.add(fFigurePublisherNameFigure);

                }

                public WrappingLabel getFigurePublisherNameFigure() {
                        return fFigurePublisherNameFigure;
                }

        }

        static final Color THIS_FORE = new Color(null, 211, 72, 54);

        static final Color THIS_BACK = new Color(null, 211, 72, 54);

}