Ejemplo n.º 1
0
    @Override
    public void refreshGraphFunctions() {
      if (!rankings.containsKey(getIdStr(GraphFunction.EDGE_WEIGHT.getId()))) {
        rankings.put(getIdStr(GraphFunction.EDGE_WEIGHT.getId()), new EdgeWeightRankingImpl(graph));
      }
      if (graph.getModel().isMultiGraph()) {
        if (!partitions.containsKey(getIdStr(GraphFunction.EDGE_TYPE.getId()))) {
          partitions.put(
              getIdStr(GraphFunction.EDGE_TYPE.getId()), new EdgeTypePartitionImpl(graph));
        }
      } else {
        partitions.remove(getIdStr(GraphFunction.EDGE_TYPE.getId()));
      }

      // Weight function
      for (Transformer t : getRankingTransformers()) {
        String weightId = getId(t, GraphFunction.EDGE_WEIGHT.getId());
        RankingImpl ranking = rankings.get(getIdStr(GraphFunction.EDGE_WEIGHT.getId()));
        if (!graphFunctions.containsKey(weightId)) {
          String name =
              NbBundle.getMessage(AppearanceModelImpl.class, "EdgeGraphFunction.Weight.name");
          graphFunctions.put(
              weightId,
              new GraphFunctionImpl(
                  weightId,
                  name,
                  Edge.class,
                  graph,
                  t,
                  getTransformerUI(t),
                  ranking,
                  defaultInterpolator));
        }
        ranking.refresh();
      }

      // Type Function
      for (Transformer t : getPartitionTransformers()) {
        String typeId = getId(t, GraphFunction.EDGE_TYPE.getId());
        PartitionImpl partition = partitions.get(getIdStr(GraphFunction.EDGE_TYPE.getId()));
        if (partition != null) {
          if (!graphFunctions.containsKey(typeId)) {
            String name =
                NbBundle.getMessage(AppearanceModelImpl.class, "EdgeGraphFunction.Type.name");
            graphFunctions.put(
                typeId,
                new GraphFunctionImpl(
                    typeId, name, Edge.class, graph, t, getTransformerUI(t), partition));
          }
          partition.refresh();
        } else {
          graphFunctions.remove(typeId);
        }
      }
    }
Ejemplo n.º 2
0
    private void refreshAttributeFunctions(boolean graphHasChanged) {
      Set<Column> columns = new HashSet<Column>();
      for (Column column : getTable()) {
        if (!column.isProperty()) {
          columns.add(column);
        }
      }

      // Clean
      for (Iterator<Map.Entry<Column, ColumnObserver>> itr = columnObservers.entrySet().iterator();
          itr.hasNext(); ) {
        Map.Entry<Column, ColumnObserver> entry = itr.next();
        if (!columns.contains(entry.getKey()) || forcedColumnsRefresh.contains(entry.getKey())) {
          rankings.remove(getIdCol(entry.getKey()));
          partitions.remove(getIdCol(entry.getKey()));
          for (Transformer t : getTransformers()) {
            attributeFunctions.remove(getId(t, entry.getKey()));
          }
          itr.remove();
          if (!entry.getValue().isDestroyed()) {
            entry.getValue().destroy();
          }
        }
      }

      // Get columns to be refreshed
      Set<Column> toRefreshColumns = new HashSet<Column>(forcedColumnsRefresh);
      for (Column column : columns) {
        if (!columnObservers.containsKey(column)) {
          columnObservers.put(column, column.createColumnObserver());
          toRefreshColumns.add(column);
        } else if (columnObservers.get(column).hasColumnChanged() || graphHasChanged) {
          toRefreshColumns.add(column);
        }
      }
      forcedColumnsRefresh.clear();

      // Refresh ranking and partitions
      for (Column column : toRefreshColumns) {
        RankingImpl ranking = rankings.get(getIdCol(column));
        PartitionImpl partition = partitions.get(getIdCol(column));
        if (ranking == null && partition == null) {
          String id = getIdCol(column);
          if (forcedPartition.contains(id)
              || (!forcedRanking.contains(id) && isPartition(graph, column))) {
            if (column.isIndexed()) {
              partition = new AttributePartitionImpl(column, getIndex(false));
            } else {
              partition = new AttributePartitionImpl(column, graph);
            }
            partitions.put(getIdCol(column), partition);
          }

          if (forcedRanking.contains(id) || isRanking(graph, column)) {
            if (column.isIndexed()) {
              ranking = new AttributeRankingImpl(column, getIndex(localScale));
            } else {
              ranking = new AttributeRankingImpl(column, graph);
            }
            rankings.put(getIdCol(column), ranking);
          }
        }
        if (ranking != null) {
          ranking.refresh();
        }
        if (partition != null) {
          partition.refresh();
        }
      }

      // Ranking functions
      for (Transformer t : getRankingTransformers()) {
        for (Column col : toRefreshColumns) {
          RankingImpl ranking = rankings.get(getIdCol(col));
          if (ranking != null) {
            String id = getId(t, col);
            if (!attributeFunctions.containsKey(id)) {
              attributeFunctions.put(
                  id,
                  new AttributeFunctionImpl(
                      id, graph, col, t, getTransformerUI(t), ranking, defaultInterpolator));
            }
          }
        }
      }

      // Partition functions
      for (Transformer t : getPartitionTransformers()) {
        for (Column col : toRefreshColumns) {
          PartitionImpl partition = partitions.get(getIdCol(col));
          if (partition != null) {
            String id = getId(t, col);
            if (!attributeFunctions.containsKey(id)) {
              attributeFunctions.put(
                  id, new AttributeFunctionImpl(id, graph, col, t, getTransformerUI(t), partition));
            }
          }
        }
      }
    }
Ejemplo n.º 3
0
    @Override
    public void refreshGraphFunctions() {
      if (!rankings.containsKey(getIdStr(GraphFunction.NODE_DEGREE.getId()))) {
        rankings.put(getIdStr(GraphFunction.NODE_DEGREE.getId()), new DegreeRankingImpl(graph));
      }
      if (graph.isDirected()) {
        if (!rankings.containsKey(getIdStr(GraphFunction.NODE_INDEGREE.getId()))) {
          DirectedGraph directedGraph = (DirectedGraph) graph;
          rankings.put(
              getIdStr(GraphFunction.NODE_INDEGREE.getId()),
              new InDegreeRankingImpl(directedGraph));
          rankings.put(
              getIdStr(GraphFunction.NODE_OUTDEGREE.getId()),
              new OutDegreeRankingImpl(directedGraph));
        }
      } else {
        rankings.remove(getIdStr(GraphFunction.NODE_INDEGREE.getId()));
        rankings.remove(getIdStr(GraphFunction.NODE_OUTDEGREE.getId()));
      }

      // Degree functions
      for (Transformer t : getRankingTransformers()) {
        String degreeId = getId(t, GraphFunction.NODE_DEGREE.getId());
        RankingImpl degreeRanking = rankings.get(getIdStr(GraphFunction.NODE_DEGREE.getId()));
        if (!graphFunctions.containsKey(degreeId)) {
          String name =
              NbBundle.getMessage(AppearanceModelImpl.class, "NodeGraphFunction.Degree.name");
          graphFunctions.put(
              degreeId,
              new GraphFunctionImpl(
                  degreeId,
                  name,
                  Node.class,
                  graph,
                  t,
                  getTransformerUI(t),
                  degreeRanking,
                  defaultInterpolator));
        }
        degreeRanking.refresh();

        String indegreeId = getId(t, GraphFunction.NODE_INDEGREE.getId());
        String outdegreeId = getId(t, GraphFunction.NODE_OUTDEGREE.getId());

        RankingImpl indegreeRanking = rankings.get(getIdStr(GraphFunction.NODE_INDEGREE.getId()));
        RankingImpl outdegreeRanking = rankings.get(getIdStr(GraphFunction.NODE_OUTDEGREE.getId()));
        if (indegreeRanking != null && outdegreeRanking != null) {
          if (!graphFunctions.containsKey(indegreeId)) {
            String inDegreeName =
                NbBundle.getMessage(AppearanceModelImpl.class, "NodeGraphFunction.InDegree.name");
            String outDegreeName =
                NbBundle.getMessage(AppearanceModelImpl.class, "NodeGraphFunction.OutDegree.name");
            graphFunctions.put(
                indegreeId,
                new GraphFunctionImpl(
                    indegreeId,
                    inDegreeName,
                    Node.class,
                    graph,
                    t,
                    getTransformerUI(t),
                    indegreeRanking,
                    defaultInterpolator));
            graphFunctions.put(
                outdegreeId,
                new GraphFunctionImpl(
                    outdegreeId,
                    outDegreeName,
                    Node.class,
                    graph,
                    t,
                    getTransformerUI(t),
                    outdegreeRanking,
                    defaultInterpolator));
          }
          indegreeRanking.refresh();
          outdegreeRanking.refresh();
        } else {
          graphFunctions.remove(indegreeId);
          graphFunctions.remove(outdegreeId);
        }
      }
    }