com.jorambarrez.ModelingPanel.java Source code

Introduction

Here is the source code for com.jorambarrez.ModelingPanel.java

Source

/* Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.jorambarrez;

import com.jorambarrez.Node.STATE;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.Component;
import com.vaadin.ui.VerticalLayout;

/**
 * @author Joram Barrez
 */
public class ModelingPanel extends VerticalLayout {

    private static final long serialVersionUID = 1L;

    public ModelingPanel() {
    }

    @Override
    public void attach() {
        setSpacing(false);
        setMargin(false);

        setHeight(Node.DEFAULT_NODE_HEIGHT * 2 + 2 * Node.EMPTY_NODE_HEIGHT, UNITS_PIXELS);

        // Initial setup
        addEmptyNode();
        addDefaultStartNode();
        addEmptyNode();
        addCandidateNode();
    }

    protected void addDefaultStartNode() {
        Node startNode = createNode(STATE.PROCESS_STEP, "Step 1");
        addComponent(startNode);
    }

    public Node addEmptyNode() {
        Node emptyNode = createNode(STATE.EMPTY);
        addComponent(emptyNode);
        return emptyNode;
    }

    public Node addEmptyNode(int row) {
        Node emptyNode = createNode(STATE.EMPTY);
        addComponent(emptyNode, row);
        return emptyNode;
    }

    public Node addCandidateNode() {
        Node candidateNode = createNode(STATE.CANDIDATE);
        addComponent(candidateNode);
        return candidateNode;
    }

    public Node addCandidateNode(int row) {
        Node candidateNode = createNode(STATE.CANDIDATE);
        addComponent(candidateNode, row);
        return candidateNode;
    }

    protected Node createNode(STATE state) {
        return new DndNode(state);
    }

    protected Node createNode(STATE state, String text) {
        return new DndNode(state, text);
    }

    @Override
    public void addComponent(Component c) {
        super.addComponent(c);
        setComponentAlignment(c, Alignment.MIDDLE_CENTER);
    }

    @Override
    public void addComponent(Component c, int index) {
        super.addComponent(c, index);
        setComponentAlignment(c, Alignment.MIDDLE_CENTER);
    }

    public Node getNode(int row) {
        if (row >= getComponentCount()) {
            return null;
        }
        return (Node) getComponent(row);
    }

    public int getRow(Node node) {
        return getComponentIndex(node);
    }

    public void removeNode(Node node) {
        if (getComponentCount() > 4) { // 2 empty, 1 process step and 1 candidate
            removeComponent(node);
        }
    }

    public void replaceEmptyNode(Node emptyNode, Node newNode) {
        if (!emptyNode.isEmpty()) {
            throw new RuntimeException("Only possible to replace empty nodes");
        }
        replaceComponent(emptyNode, newNode); // and place it where the empty node was
        setComponentAlignment(newNode, Alignment.MIDDLE_CENTER);
        notifyNodesChanged();
    }

    public void notifyNodesChanged() {

        // Add empty node when there is not one at the start
        if (!getNode(0).isEmpty()) {
            addEmptyNode(0);
        }

        int index = 0;
        int newHeight = 0;

        while (index < getComponentCount()) {

            boolean nextNodeRemoved = false;
            Node node = getNode(index);
            Node nextNode = getNode(index + 1);
            if (node.isProcessStep()) {
                if ((nextNode != null && !nextNode.isEmpty()) || nextNode == null) {
                    addEmptyNode(index + 1);
                }
            } else if (node.isEmpty() && nextNode != null && nextNode.isEmpty()) {
                removeNode(nextNode);
                nextNodeRemoved = true;
            }

            if (!nextNodeRemoved) {
                node.setIndex(index);
                newHeight += node.getHeight();
                index++;
            }
        }

        // Alway add candidate node at the end
        if (!getNode(getComponentCount() - 1).isCandidate()) {
            Node candidateNode = addCandidateNode();
            candidateNode.setIndex(index + 1);
            newHeight += candidateNode.getNodeHeight();
        }

        // Change total layout size
        setHeight(newHeight, UNITS_PIXELS);

    }

}