weka.gui.beans.BeanConnection Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of weka-dev Show documentation
The Waikato Environment for Knowledge Analysis (WEKA), a machine learning workbench. This version represents the developer version, the "bleeding edge" of development, you could say. New functionality gets added to this version.
There is a newer version: 3.9.6
Show newest version
/*
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program 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 General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see .
 */

/*
 *    BeanConnection.java
 *    Copyright (C) 2002-2012 University of Waikato, Hamilton, New Zealand
 *
 */

package weka.gui.beans;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.BeanInfo;
import java.beans.EventSetDescriptor;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Vector;

import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.SwingConstants;

/**
 * Class for encapsulating a connection between two beans. Also maintains a list
 * of all connections
 * 
 * @author Mark Hall
 * @version $Revision: 10221 $
 */
public class BeanConnection implements Serializable {

  /** for serialization */
  private static final long serialVersionUID = 8804264241791332064L;

  private static ArrayList> TABBED_CONNECTIONS = new ArrayList>();

  /*
   * static { Vector initial = new Vector(); TABBED_CONNECTIONS.add(initial); }
   */

  // details for this connection
  private final BeanInstance m_source;
  private final BeanInstance m_target;

  /**
   * The name of the event for this connection
   */
  private final String m_eventName;

  // Should the connection be painted?
  private boolean m_hidden = false;

  /**
   * Sets up just a single collection of bean connections in the first element
   * of the list. This is useful for clients that are using XMLBeans to load
   * beans.
   */
  public static void init() {
    // CONNECTIONS = new Vector();

    // TODO remove this soon!!!
    // TABBED_CONNECTIONS.set(0, new Vector());
    TABBED_CONNECTIONS.clear();
    TABBED_CONNECTIONS.add(new Vector());
  }

  /**
   * Returns the list of connections
   * 
   * @return the list of connections
   */
  public static Vector getConnections(Integer... tab) {
    Vector returnV = null;
    int index = 0;
    if (tab.length > 0) {
      index = tab[0].intValue();
    }

    if (TABBED_CONNECTIONS.size() > 0) {
      returnV = TABBED_CONNECTIONS.get(index);
    }

    return returnV;
  }

  /**
   * Describe setConnections method here.
   * 
   * @param connections a Vector value
   */
  public static void setConnections(Vector connections,
    Integer... tab) {
    int index = 0;
    if (tab.length > 0) {
      index = tab[0].intValue();
    }

    if (index < TABBED_CONNECTIONS.size()) {
      TABBED_CONNECTIONS.set(index, connections);
    }
  }

  /**
   * Add the supplied collection of connections to the end of the list.
   * 
   * 
   * @param connections the connections to add
   */
  public static void addConnections(Vector connections) {
    TABBED_CONNECTIONS.add(connections);
  }

  /**
   * Append the supplied connections to the list for the given tab index
   * 
   * @param connections the connections to append
   * @param tab the index of the list to append to
   */
  public static void appendConnections(Vector connections,
    int tab) {
    if (tab < TABBED_CONNECTIONS.size()) {
      Vector cons = TABBED_CONNECTIONS.get(tab);

      for (int i = 0; i < connections.size(); i++) {
        cons.add(connections.get(i));
      }
    }
  }

  /**
   * Returns true if there is a link between the supplied source and target
   * BeanInstances at an earlier index than the supplied index
   * 
   * @param source the source BeanInstance
   * @param target the target BeanInstance
   * @param index the index to compare to
   * @return true if there is already a link at an earlier index
   */
  private static boolean previousLink(BeanInstance source, BeanInstance target,
    int index, Integer... tab) {
    int tabIndex = 0;
    if (tab.length > 0) {
      tabIndex = tab[0].intValue();
    }

    Vector connections = TABBED_CONNECTIONS.get(tabIndex);

    for (int i = 0; i < connections.size(); i++) {
      BeanConnection bc = connections.elementAt(i);
      BeanInstance compSource = bc.getSource();
      BeanInstance compTarget = bc.getTarget();

      if (compSource == source && compTarget == target && index < i) {
        return true;
      }
    }
    return false;
  }

  /**
   * A candidate BeanInstance can't be an input if it is the target of a
   * connection from a source that is in the listToCheck
   */
  private static boolean checkTargetConstraint(BeanInstance candidate,
    Vector