setTargetDecoration(null);
        setSourceDecoration(null);

        add(_firstLabel);

        refresh();
    }

    @Override
    public void setPoints(PointList points) {
        float angle = getAngle(points);
        setLabelsBounds(points, angle);
    }

    private float getAngle(PointList points) {
        float dx = points.getLastPoint().x - points.getFirstPoint().x;
        float dy = points.getLastPoint().y - points.getFirstPoint().y;
        return (float)Math.atan2(dx, dy);
    }

    private Point getMiddlePoint(PointList points) {
        int x = (points.getLastPoint().x + points.getFirstPoint().x) / 2;
        int y = (points.getLastPoint().y + points.getFirstPoint().y) / 2;
        return new Point(x, y);
    }

    private void setLabelsBounds(PointList firstLinePoints, float angle) {
        Point firstLabelPoint = getMiddlePoint(firstLinePoints);
        Dimension firstLabelSize = _firstLabel.getPreferredSize();

        _firstLabel.setBounds(new Rectangle(firstLabelPoint, firstLabelSize));
    }

    @Override
    public void refresh() {
        _firstLabel.setText((String)_connectionGroup.getAttributeValue(ConnectionGroup.SINGLE_CONNECTION_LABEL)
                .getValue());

        HexColor hexColor = (HexColor)_connectionGroup.getAttributeValue(ConnectionGroup.LINE_COLOR).getValue();
        this.setForegroundColor(new Color(null, hexColor.getRed(), hexColor.getGreen(), hexColor.getBlue()));

    }

    @SuppressWarnings("unchecked")
    @Override
    public Command getCommand(Request request) {
        if (RequestConstants.REQ_DELETE.equals(request.getType()) && request instanceof GroupRequest) {
            GroupRequest groupReq = (GroupRequest)request;

            DeleteModelElementsCommand cmd = null;
            if (groupReq.getExtendedData().containsKey(DeleteModelElementsCommand.ID)) {
                cmd = (DeleteModelElementsCommand)groupReq.getExtendedData().get(DeleteModelElementsCommand.ID);
            } else {

        double angle = angleRange / (orderedList.size() * 1.0);
        int counter = 0;
        int figureRadius = 0;

        for (Node node : orderedList) {
            int currentFigureRadius = CIRCLE_MINIMUM_DISTANCE
                    + (int)Math.max(node.getDimensions().width / 2, node.getDimensions().height / 2);
            figureRadius = Math.max(figureRadius, currentFigureRadius);
            figureRadius = Math.min(figureRadius, MAXIMUM_FIGURE_RADIUS);
        }

		menu.appendToGroup(GEFActionConstants.GROUP_EDIT, getAction(InvertSelectionAction.ID));

		MenuManager connectionSettingsSubMenu = new MenuManager(Messages.SchemaEditorContextMenuProvider_0);

		GEFActionConstants.addStandardActionGroups(connectionSettingsSubMenu);

		connectionSettingsSubMenu.appendToGroup(GEFActionConstants.GROUP_VIEW, getAction(SingleConnectionAction.ID));

		connectionSettingsSubMenu.appendToGroup(GEFActionConstants.GROUP_VIEW, getAction(DoubleConnectionAction.ID));

		connectionSettingsSubMenu.appendToGroup(GEFActionConstants.GROUP_VIEW, getAction(VariableThicknessAction.ID));

		connectionSettingsSubMenu.appendToGroup(GEFActionConstants.GROUP_REST, getAction(ResetThicknessAction.ID));

    private int radius(int r, int n) {
        int circleRadius = (int)(Math.max(((10 * r) / Math.PI), ((n * r) / Math.PI)));
        return Math.min(circleRadius, MAXIMUM_CIRCLE_RADIUS);
    }

    @Override
    protected int getWorkUnits(int nodesCount) {
        return nodesCount;

    public VariableThicknessPolylineConnection(ConnectionGroup connectionGroup) {
        _firstLabel = new Label((String)connectionGroup.getAttributeValue(ConnectionGroup.SINGLE_CONNECTION_LABEL)
                .getValue());
        _firstLabel.setBackgroundColor(Display.getCurrent().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
        _firstLabel.setOpaque(true);

        _connectionGroup = connectionGroup;

        setTargetDecoration(new PolygonDecoration());
        setLineStyle(Graphics.LINE_SOLID);

        return (float)Math.atan2(dx, dy);
    }

    private Point getMiddlePoint(PointList points) {
        int x = (points.getLastPoint().x + points.getFirstPoint().x) / 2;
        int y = (points.getLastPoint().y + points.getFirstPoint().y) / 2;
        return new Point(x, y);
    }

                double sqrt = Math.sqrt(a * a + b * b);
                double w = getWeight(e.n1, e.n2);
                w *= DISTANCE_FACTOR;

                result += -(2 * a * w * (w * sqrt - 1)) / sqrt;
            }
        }
        return result;
    }

    /**
     * This method is just a trial, it calculates potential for changed arrangement of nodes using gradient multiplied
     * by multiplier
     *
     * @param gradient
     *            vector of derivatives for all nodes, defines the directions for nodes to move
     * @param multiplier
     *            number that says how big the jump of nodes has to be
     * @param edges
     *            list of all edges between nodes
     * @return value of calculated potential
     */
    private double potentialForGradient(double[] gradient, int multiplier, List<Edge> edges) {

    }

    private int radius(int r, int n) {
        int circleRadius = (int)(Math.max(((10 * r) / Math.PI), ((n * r) / Math.PI)));
        return Math.min(circleRadius, MAXIMUM_CIRCLE_RADIUS);
    }

            AttributeValue property = _connectionGroup.getAttributeValue(ConnectionGroup.LINE_THICKNESS);
            Object value = property.getValue();
            if (value instanceof String) {
                setLineWidth(Integer.parseInt((String)value));
            } else {
                setLineWidth((Integer)value);
            }
        } catch (NumberFormatException ex) {
            setLineWidth(1);
        }

    public static int radius(int r, int n) {
        int circleRadius = (int)(Math.max(((10 * r) / Math.PI), ((n * r) / Math.PI)));
        return Math.min(circleRadius, MAXIMUM_CIRCLE_RADIUS);
    }

    public void dispose() {
        IWorkbenchPart part = getWorkbenchPart().getSite().getPart();
        if (null != getCommandStack() && part instanceof SchemaEditor) {
            SchemaEditor schemaEditor = (SchemaEditor)part;
            SchemaDiagram model = (SchemaDiagram)((DiagramEditorInput)schemaEditor.getEditorInput()).getDiagram();

    protected boolean calculateEnabled() {
        IWorkbenchPart part = getWorkbenchPart().getSite().getPart();
        if (null != getCommandStack() && part instanceof SchemaEditor) {
            SchemaEditor schemaEditor = (SchemaEditor)part;
            IDiagram model = ((DiagramEditorInput)schemaEditor.getEditorInput()).getDiagram();

        _firstLabel.setText((String)_connectionGroup.getAttributeValue(ConnectionGroup.SINGLE_CONNECTION_LABEL)
                .getValue());

        HexColor hexColor = (HexColor)_connectionGroup.getAttributeValue(ConnectionGroup.LINE_COLOR).getValue();
        this.setForegroundColor(new Color(null, hexColor.getRed(), hexColor.getGreen(), hexColor.getBlue()));

        IWorkbenchPart part = getWorkbenchPart().getSite().getPart();
        if (null != getCommandStack() && part instanceof SchemaEditor) {
            SchemaEditor schemaEditor = (SchemaEditor)part;
            SchemaDiagram model = (SchemaDiagram)((DiagramEditorInput)schemaEditor.getEditorInput()).getDiagram();
            model.getSettings().removePropertyChangeListener(this);

        double x2 = 0;
        for (Edge e : edges) {
            if (e.n1 == n || e.n2 == n) {
                if (e.n1 == n) {
                    x2 = e.n2.getLocation().y;

	public void run() {
		if (getWorkbenchPart() instanceof SchemaEditor) {
			SchemaEditor schemaEditor = (SchemaEditor)getWorkbenchPart();
			SchemaDiagram schemaDiagram = (SchemaDiagram)(
					(DiagramEditorInput)schemaEditor.getEditorInput()).getDiagram();

	public SelectLeafNodesAction(IWorkbenchPart part) {
		super(part);
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.jface.action.Action#getId()
	 */
	@Override
	public String getId() {
		return ID;
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.jface.action.Action#getText()
	 */
	@Override
	public String getText() {
		return MENU_TEXT;
	}

	/**
	 * (@inheritDoc)
	 * 
	 * @see org.eclipse.gef.ui.actions.WorkbenchPartAction#calculateEnabled()
	 */
	@Override
	protected boolean calculateEnabled() {
		return true;

        super(part);
        if (null != getCommandStack() && part instanceof SchemaEditor) {
            SchemaEditor schemaEditor = (SchemaEditor)part;
            SchemaDiagram model = (SchemaDiagram)((DiagramEditorInput)schemaEditor.getEditorInput()).getDiagram();

    public void runWithEvent(Event event) {

        IWorkbenchPart part = getWorkbenchPart().getSite().getPart();
        if (null != getCommandStack() && part instanceof SchemaEditor) {
            SchemaEditor schemaEditor = (SchemaEditor)part;

                for (Object item : structuredSelection.toList()) {
                    if (item instanceof SchemaNodeEditPart) {
                        SchemaNodeEditPart ep = (SchemaNodeEditPart)item;
                        _selectedNodes.add(ep.getModelCasted());
                    }
                }
            }
        }

        if (null != getCommandStack() && part instanceof SchemaEditor) {
            SchemaEditor schemaEditor = (SchemaEditor)part;
            SchemaDiagram model = (SchemaDiagram)((DiagramEditorInput)schemaEditor.getEditorInput()).getDiagram();

                cmd = new DeleteModelElementsCommand((SchemaDiagram)getParent().getModel());
                groupReq.getExtendedData().put(DeleteModelElementsCommand.ID, cmd);
            }

            cmd.add(getModelCasted());
            return cmd;

        }
        return super.getCommand(request);
    }

}

    protected boolean calculateEnabled() {
        IWorkbenchPart part = getWorkbenchPart().getSite().getPart();
        if (null != getCommandStack() && part instanceof SchemaEditor) {
            SchemaEditor schemaEditor = (SchemaEditor)part;

        for (Node node : orderedList) {
            Point location = node.getLocation();

            // lay out in circle only these figures which don't have
            // preferred location set
            location = new Point((int)(xCenter - circleRadius * Math.sin(angle * counter + startingAngle) - node

    protected boolean calculateEnabled() {
        IWorkbenchPart part = getWorkbenchPart().getSite().getPart();
        if (null != getCommandStack() && part instanceof SchemaEditor) {
            SchemaEditor schemaEditor = (SchemaEditor)part;

    @Override
    public String getId() {
        return ID;
    }

    @Override
    public String getText() {
        return MENU_TEXT;
    }

    @Override
    protected boolean calculateEnabled() {
        return _enabled;
    }

    @SuppressWarnings("unchecked")

    }

    /**
     * {@inheritDoc}
     * 
     * @see pl.edu.agh.cast.model.visual.backward.Diagram#propertyChange(java.beans.PropertyChangeEvent)
     */
    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        super.propertyChange(evt);
        if (SchemaDiagramSettings.CONNECTION_TYPE.equals(evt.getPropertyName())) {

    public void runWithEvent(Event event) {
        ISelection selObj = getWorkbenchPart().getSite().getSelectionProvider().getSelection();
        if (!(selObj instanceof IStructuredSelection)) {
            return;

    @Override
    public String getId() {
        return ID;
    }

    @Override
    public String getText() {
        return MENU_TEXT;
    }

    @Override
    protected boolean calculateEnabled() {
        return _enabled;

        return (SchemaDiagram)getModel();
    }

    @Override
    public void deactivate() {
        super.deactivate();
        getModelCasted().removePropertyChangeListener(this);
    }

    /*
     * (non-Javadoc)
     *
     * @seejava.beans.PropertyChangeListener#propertyChange(java.beans. PropertyChangeEvent)
     */
    public void propertyChange(PropertyChangeEvent event) {

				}
			}, new IExceptionHandler() {
				public void handleException(Exception e) {
					Activator.getLogger().error(Messages.SchemaEditor_1, e);

            } else {
                this.setNode(n, deepLevel + 1, this.countChildren(n), angle, this.ANGLE_RANGE_FACTOR * temp,
                        this.radiusScaleFactor);

            n.setLocation(new Point(x + gradient[i++] / multiplier, y + gradient[i++] / multiplier));
        }

                            } else {
                                this.distancesTable.get(neighbourID).put(nodeID, distancesFromNode.get(nodeID) + 1);
                                wasChange = true;
                            }
                        }

        for (Node n : nodes) {
            int x = n.getLocation().x;
            int y = n.getLocation().y;

            location = new Point((int)(xCenter - circleRadius * Math.sin(angle * counter + startingAngle) - node
                    .getDimensions().width / 2), (int)(yCenter - circleRadius
                    * Math.cos(angle * counter + startingAngle) - node.getDimensions().height / 2));

        if (upperLeftCorner.x != 0 || upperLeftCorner.y != 0) {
            for (Node node : nodes) {
                Point loc = new Point(node.getLocation().x - upperLeftCorner.x, node.getLocation().y

        _secondPolyline.setForegroundColor(new Color(null, hexColor.getRed(), hexColor.getGreen(), hexColor.getBlue()));

            location = new Point((int)(xCenter - circleRadius * Math.sin(counter) - node.getDimensions().width / 2),
                    (int)(yCenter - circleRadius * Math.cos(counter) - node.getDimensions().height / 2));

        List<ConnectionGroup> targetConns = new LinkedList<ConnectionGroup>();
        for (ConnectionGroup group : getModelCasted().getConnectionGroups()) {
            if (group.getTarget().equals(getModelCasted())) {

        for (Object item : structuredSelection.toList()) {
            if (item instanceof SchemaNodeEditPart) {
                SchemaNodeEditPart ep = (SchemaNodeEditPart)item;

        super.dispose();
    }

    @Override
    public String getId() {
        return ID;
    }

    @Override
    public String getText() {
        return MENU_TEXT;
    }

    @Override

        for (Object item : structuredSelection.toList()) {
            if (item instanceof SchemaNodeEditPart) {
                SchemaNodeEditPart ep = (SchemaNodeEditPart)item;

            location = new Point((int)(xCenter - circleRadius * Math.sin(angle * counter + startingAngle) - node
                    .getDimensions().width / 2), (int)(yCenter - circleRadius
                    * Math.cos(angle * counter + startingAngle) - node.getDimensions().height / 2));

            for (Node n : list) {
                for (ConnectionGroup e : n.getConnectionGroups()) {
                    if (e.getAllConnections().size() > maxno) {

    protected List<Node> getNotConnected(Collection<Node> nodes) {
        List<Node> result = new LinkedList<Node>();
        for (Node node : nodes) {
            if (node.getConnectionGroups().size() == 0) {

        for (Node node : _changedNodes) {
            node.setAttributeValue(NodeAttributeManager.PERMANENT_ISMAIN, Boolean.TRUE);
        }
    }

    @Override
    public String getLabel() {

        super(part, ConnectionType.VARIABLE_THICKNESS_CONNECTION);
    }

    @Override
    public String getId() {
        return ID;
    }

    @Override
    public String getText() {
        return MENU_TEXT;
    }
}

    private double derivativeY(List<Edge> edges, Node n) {
        double result = 0;
        double x1 = n.getLocation().y;

                .getValue());
        _firstLabel.setBackgroundColor(Display.getCurrent().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
        _firstLabel.setOpaque(true);

        super(part, ConnectionType.SINGLE_CONNECTION);
    }

    @Override
    public String getId() {
        return ID;
    }

    @Override
    public String getText() {
        return MENU_TEXT;
    }

    @Override
    public String getId() {
        return ID;
    }

    @Override
    public String getText() {
        return MENU_TEXT;
    }

    @Override

		super(part);
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.jface.action.Action#getId()
	 */
	@Override
	public String getId() {
		return ID;
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.jface.action.Action#getText()
	 */
	@Override
	public String getText() {
		return MENU_TEXT;
	}

    public void propertyChange(PropertyChangeEvent evt) {
        if (SchemaDiagramSettings.CONNECTION_TYPE.equals(evt.getPropertyName())) {

        for (Node node : getNodes()) {
            for (ConnectionGroup group : node.getConnectionGroups()) {

                double elementRadius = (margin + localRadius * (counter % circleNo + 1));

                // lay out in circle only these figures which don't have
                // preferred location set
                location = new Point((int)(xTailCenter - elementRadius * elementXangle),

            } else {
                this.setNode(treeRoot, 2, countChildren(treeRoot), alfa, this.ANGLE_RANGE_FACTOR * temp,

                    + (int)Math.max(node.getDimensions().width / 2, node.getDimensions().height / 2);
            figureRadius = Math.max(figureRadius, currentFigureRadius);
            figureRadius = Math.min(figureRadius, MAXIMUM_FIGURE_RADIUS);
        }

    @Override
    /*
     * This method sets nodes positions on board.
     *
     * @param positionNodes collection of nodes to position.
     */
    protected void setNodesPositions(Collection<Node> positionNodes, IProgressMonitor monitor) {

        monitor.subTask(Messages.Peacock3LayoutAlgorithm_0);

                    + (int)Math.max(figure.getDimensions().width /* / 2 */, figure.getDimensions().height /* / 2 */);
            figureRadius = Math.max(figureRadius, currentFigureRadius);
            figureRadius = Math.min(figureRadius, MAXIMUM_FIGURE_RADIUS);
        }

    }

    @Override
    public void refresh() {
        _firstLabel.setText((String)_connectionGroup.getAttributeValue(ConnectionGroup.SINGLE_CONNECTION_LABEL)

        int newY = (int)(original.y + LinesDistance * Math.sin(angle) / 2);
        return new Point(newX, newY);
    }

    private Point getMiddlePoint(PointList points) {

        add(_firstLabel);

        refresh();
    }

    @Override
    public void setPoints(PointList points) {
        float angle = getAngle(points);

    }

    @Override
    public void activate() {
        super.activate();
        getModelCasted().addPropertyChangeListener(this);

    @Override
    public String getId() {
        return ID;
    }

    @Override
    public String getText() {
        return MENU_TEXT;
    }

            int x = (int)((this.AREA_CENTER_X - this.radius * radiusFactor * deepLevel) * Math.cos(angle + temp / 2.0));
            int y = (int)((this.AREA_CENTER_Y - this.radius * radiusFactor * deepLevel) * Math.sin(angle + temp / 2.0));

                    (int)(yCenter - circleRadius * Math.cos(counter) - node.getDimensions().height / 2));
            // }

            node.setLocation(location);

            counter += angle * cycleChildren.get(node).intValue() / 2.0;

            double scalingFactor, Point center) {

        if (positionNodes.size() == 0) {
            return;
        }

        List<Node> orderedList = new LinkedList<Node>(positionNodes);

                        - upperLeftCorner.y);
                node.setLocation(loc);
            }
        }
        monitor.worked(nodes.size());

        int newX = (int)(original.x - LinesDistance * Math.cos(angle) / 2);
        int newY = (int)(original.y + LinesDistance * Math.sin(angle) / 2);

    public void redo() {
        for (Node node : _changedNodes) {
            node.setAttributeValue(NodeAttributeManager.PERMANENT_ISMAIN, Boolean.TRUE);

            return ConnectionType.VARIABLE_THICKNESS_CONNECTION.equals(((SchemaDiagramSettings)model.getSettings())
                    .getConnectionType());

            IDiagram model = ((DiagramEditorInput)schemaEditor.getEditorInput()).getDiagram();

            getCommandStack().execute(new ResetThicknessCommand(model));

            n.node.setLocation(new Point(x, y));

            if (radiusFactorInvert) {
                this.setNode(n, deepLevel + 1, this.countChildren(n), angle, this.ANGLE_RANGE_FACTOR * temp,

    private static final int MAXIMUM_CIRCLE_RADIUS = 500;

    private static final int MAXIMUM_FIGURE_RADIUS = 80;

    private static final int CIRCLE_MINIMUM_DISTANCE = 5;

    private void setLabelsBounds(PointList firstLinePoints, float angle) {
        Point firstLabelPoint = getMiddlePoint(firstLinePoints);
        Dimension firstLabelSize = _firstLabel.getPreferredSize();

        IEditorPart editor = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();

        ISelection selection = getWorkbenchPart().getSite().getSelectionProvider().getSelection();
        if (!(selection instanceof IStructuredSelection)) {

        ISelection selection = getWorkbenchPart().getSite().getSelectionProvider().getSelection();
        if (!(selection instanceof IStructuredSelection)) {

        if (null != getCommandStack() && part instanceof SchemaEditor) {
            SchemaEditor schemaEditor = (SchemaEditor)part;