RankingUIModel.java

/*
Copyright 2008-2010 Gephi
Authors : Mathieu Bastian <mathieu.bastian@gephi.org>
Website : http://www.gephi.org

This file is part of Gephi.

Gephi is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.

Gephi is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with Gephi.  If not, see <http://www.gnu.org/licenses/>.
*/
package org.gephi.ranking.api;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.List;
import org.openide.util.Lookup;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 *
 * @author Mathieu Bastian
 */
public class RankingUIModel {

    //Const
    public static final int NODE_RANKING = 1;
    public static final int EDGE_RANKING = 2;
    //Model
    protected int ranking;
    protected boolean barChartVisible;
    protected boolean listVisible;
    protected Class nodeTransformer;
    protected Class edgeTransformer;
    protected List<Transformer> nodeTransformers;
    protected List<Transformer> edgeTransformers;
    protected String selectedNodeRanking;
    protected String selectedEdgeRanking;
    //Listener
    protected List<PropertyChangeListener> listeners = new ArrayList<PropertyChangeListener>();

    public RankingUIModel() {
        //DefaultValues
        ranking = NODE_RANKING;
        barChartVisible = false;
        listVisible = false;
        nodeTransformers = new ArrayList<Transformer>();
        edgeTransformers = new ArrayList<Transformer>();
    }

    public Class getNodeTransformer() {
        return nodeTransformer;
    }

    public Class getEdgeTransformer() {
        return edgeTransformer;
    }

    public String getSelectedEdgeRanking() {
        return selectedEdgeRanking;
    }

    public String getSelectedNodeRanking() {
        return selectedNodeRanking;
    }

    public void setNodeTransformer(Class nodeTransformer) {
        if (this.nodeTransformer != null && this.nodeTransformer.equals(nodeTransformer)) {
            return;
        }
        Class oldValue = this.nodeTransformer;
        this.nodeTransformer = nodeTransformer;
        firePropertyChangeEvent("nodeTransformer", oldValue, nodeTransformer);
    }

    public void setEdgeTransformer(Class edgeTransformer) {
        if (this.edgeTransformer != null && this.edgeTransformer.equals(edgeTransformer)) {
            return;
        }
        Class oldValue = this.edgeTransformer;
        this.edgeTransformer = edgeTransformer;
        firePropertyChangeEvent("edgeTransformer", oldValue, edgeTransformer);
    }

    public void setSelectedEdgeRanking(String selectedEdgeRanking) {
        if (this.selectedEdgeRanking != null && this.selectedEdgeRanking.equals(selectedEdgeRanking)) {
            return;
        }
        if (this.selectedEdgeRanking == null && selectedEdgeRanking == null) {
            return;
        }
        String oldValue = this.selectedEdgeRanking;
        this.selectedEdgeRanking = selectedEdgeRanking;
        firePropertyChangeEvent("selectedEdgeRanking", oldValue, selectedEdgeRanking);
    }

    public void setSelectedNodeRanking(String selectedNodeRanking) {
        if (this.selectedNodeRanking != null && this.selectedNodeRanking.equals(selectedNodeRanking)) {
            return;
        }
        if (this.selectedNodeRanking == null && selectedNodeRanking == null) {
            return;
        }
        String oldValue = this.selectedNodeRanking;
        this.selectedNodeRanking = selectedNodeRanking;
        firePropertyChangeEvent("selectedNodeRanking", oldValue, selectedNodeRanking);
    }

    public Transformer getSelectedNodeTransformer() {
        if (nodeTransformer != null) {
            for (Transformer t : nodeTransformers) {
                if (nodeTransformer.isAssignableFrom(t.getClass())) {
                    return t;
                }
            }
        }
        return null;
    }

    public Transformer getSelectedEdgeTransformer() {
        if (edgeTransformer != null) {
            for (Transformer t : edgeTransformers) {
                if (edgeTransformer.isAssignableFrom(t.getClass())) {
                    return t;
                }
            }
        }
        return null;
    }

    public void addNodeTransformer(Transformer transformer) {
        nodeTransformers.add(transformer);
    }

    public void addEdgeTransformer(Transformer transformer) {
        edgeTransformers.add(transformer);
    }

    public void resetNodeTransformers() {
        nodeTransformers.clear();
    }

    public void resetEdgeTransformers() {
        edgeTransformers.clear();
    }

    public int getRanking() {
        return ranking;
    }

    public boolean isBarChartVisible() {
        return barChartVisible;
    }

    public boolean isListVisible() {
        return listVisible;
    }

    public RankingUIModel saveModel() {
        RankingUIModel save = new RankingUIModel();
        save.barChartVisible = this.barChartVisible;
        save.edgeTransformer = this.edgeTransformer;
        save.listVisible = this.listVisible;
        save.nodeTransformer = this.nodeTransformer;
        save.ranking = this.ranking;
        save.selectedNodeRanking = this.selectedNodeRanking;
        save.selectedEdgeRanking = this.selectedEdgeRanking;
        save.nodeTransformers.addAll(this.nodeTransformers);
        save.edgeTransformers.addAll(this.edgeTransformers);
        return save;
    }

    public void loadModel(RankingUIModel model) {
        this.nodeTransformers.clear();
        this.edgeTransformers.clear();
//        this.barChartVisible = model.barChartVisible;
//        this.edgeTransformer = model.edgeTransformer;
//        this.listVisible = model.listVisible;
//        this.nodeTransformer = model.nodeTransformer;
//        this.ranking = model.ranking;
//        this.selectedNodeRanking = model.selectedNodeRanking;
//        this.selectedEdgeRanking = model.selectedEdgeRanking;
        this.nodeTransformers.addAll(model.nodeTransformers);
        this.edgeTransformers.addAll(model.edgeTransformers);
        setBarChartVisible(model.barChartVisible);
        setListVisible(model.listVisible);
        setNodeTransformer(model.nodeTransformer);
        setEdgeTransformer(model.edgeTransformer);
        setRanking(model.ranking);
        setSelectedEdgeRanking(model.selectedEdgeRanking);
        setSelectedNodeRanking(model.selectedNodeRanking);
    }

    public void setListVisible(boolean listVisible) {
        if (this.listVisible == listVisible) {
            return;
        }
        boolean oldValue = this.listVisible;
        this.listVisible = listVisible;
        firePropertyChangeEvent("listVisible", oldValue, listVisible);
    }

    public void setBarChartVisible(boolean barChartVisible) {
        if (this.barChartVisible == barChartVisible) {
            return;
        }
        boolean oldValue = this.barChartVisible;
        this.barChartVisible = barChartVisible;
        firePropertyChangeEvent("barChartVisible", oldValue, barChartVisible);
    }

    public void setRanking(int ranking) {
        if (ranking != NODE_RANKING && ranking != EDGE_RANKING) {
            throw new IllegalArgumentException("Ranking must be NODE_RANKING or EDGE_RANKING");
        }
        if (this.ranking == ranking) {
            return;
        }
        int oldValue = this.ranking;
        this.ranking = ranking;
        firePropertyChangeEvent("ranking", oldValue, ranking);
    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        if (!listeners.contains(listener)) {
            listeners.add(listener);
        }
    }

    public void removePropertyChangeListener(PropertyChangeListener listener) {
        listeners.remove(listener);
    }

    private void firePropertyChangeEvent(String propertyName, Object beforeValue, Object afterValue) {
        PropertyChangeEvent event = new PropertyChangeEvent(this, propertyName, beforeValue, afterValue);
        for (PropertyChangeListener listener : listeners) {
            listener.propertyChange(event);
        }
    }

    //XML
    public void readXML(Element modelElement) {
        Element rankingE = (Element) modelElement.getElementsByTagName("ranking").item(0);
        ranking = Integer.parseInt(rankingE.getTextContent());

        Element barchartvisibleE = (Element) modelElement.getElementsByTagName("barchartvisible").item(0);
        barChartVisible = Boolean.parseBoolean(barchartvisibleE.getTextContent());

        Element listvisibleE = (Element) modelElement.getElementsByTagName("listvisible").item(0);
        listVisible = Boolean.parseBoolean(listvisibleE.getTextContent());

    }

    public Element writeXML(Document document) {
        Element rankingModelE = document.createElement("rankinguimodel");

        Element rankingE = document.createElement("ranking");
        rankingE.setTextContent(String.valueOf(ranking));
        rankingModelE.appendChild(rankingE);

        Element barChartE = document.createElement("barchartvisible");
        barChartE.setTextContent(String.valueOf(barChartVisible));
        rankingModelE.appendChild(barChartE);

        Element listE = document.createElement("listvisible");
        listE.setTextContent(String.valueOf(listVisible));
        rankingModelE.appendChild(barChartE);

        /*Element nodeTransformerE = document.createElement("nodetransformer");
        nodeTransformerE.setTextContent(String.valueOf(nodeTransformer));
        rankingModelE.appendChild(nodeTransformerE);

        Element edgeTransformerE = document.createElement("edgetransformer");
        edgeTransformerE.setTextContent(String.valueOf(edgeTransformer));
        rankingModelE.appendChild(edgeTransformerE);*/

        return rankingModelE;
    }
}