source: trunk/gli/src/org/greenstone/gatherer/util/TreeModelTest.java@ 8213

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * 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 2 of the License, or
 * (at your option) any later version.
 *
 * <BR><BR>
 *
 * 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.
 *
 * <BR><BR>
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.util;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.tree.*;
import org.greenstone.gatherer.gui.GLIButton;
import org.greenstone.gatherer.util.DefaultSynchronizedTreeNode;
import org.greenstone.gatherer.util.SynchronizedTreeModel;
import org.greenstone.gatherer.util.SynchronizedTreeNode;

public class TreeModelTest
    extends JFrame {

    /** Testing - test frame size. */
    static final private Dimension SIZE = new Dimension(400,400);

    /** Testing - should a debug file be written. */
    static private boolean debug = false;

    /** Testing - debug output stream. */
    static private FileOutputStream output = null;

    /** Testing - write a message to the debug file. */
    static void debug(String message) {
    if(debug) {
        try {
        if(output == null) {
            output = new FileOutputStream(new File("debug.txt"));
        }
        output.write(message.getBytes());
        output.flush();
        }
        catch (Exception error) {
        error.printStackTrace();
        }
    }
    }

    /** Testing - usage message. */
    static void printUsage() {
    System.out.println("Usage: java Test3 [-safe] [-debug]");
    System.out.println(" safe  - use SynchronizedTreeModel");
    System.out.println(" debug - write debug messages to debug.txt file\n");
    System.out.println("Actions:");
    System.out.println(" 'Add Node' - Adds a new node to the selected node. Since this happens on the AWTEvent Thread it should always be safe.");
    System.out.println(" 'Remove Node' - Removes the selected node. Since this happens on the AWTEvent Thread it should always be safe.");
    System.out.println(" 'Preset Structure' - Generates a small preset structure on a seperate (dangerous) thread.");
    System.out.println(" 'Dangerous' - The ultimate test. Hammers the model with incessant random mutations from a separate thread.");
    System.exit(0);
    }
    /** Testing - creates a frame containing a JTree backed by either a normal DefaultTreeModel or a SynchronizedTreeModel depending on arguments. There are also several actions you can perform by clicking on buttons. */
    static public void main(String[] args) {
    boolean safe = false;
    if(args.length <= 2) {
        for(int i = 0; i < args.length; i++) {
        String arg = args[i];
        if(arg.equalsIgnoreCase("-safe")) {
            safe = true;
        }
        else if(arg.equalsIgnoreCase("-debug")) {
            debug = true;
        }
        else {
            printUsage();
        }
        }
    }
    else {
        printUsage();
    }
    new TreeModelTest(safe);
    }

    /** Testing - a dangerous thread which hammers the mutable tree model. */
    private DangerousTask task;

    /** Testing - a dangerous thread which builds a preset structure. */
    private DangerousTask preset_task;

    /** Testing - the tree model, which may be a SynchronizedTreeModel. */
    private DefaultTreeModel model;

    /** Testing - a button for toggling the dangerous thread on and off. */
    private JToggleButton dangerous_button;

    /** Testing - the tree used during testing. */
    private JTree tree;

    TreeModelTest(boolean safe) {
    super("Testing");
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setSize(SIZE);
    JPanel content_panel = (JPanel) getContentPane();

    // Creation
    task = new DangerousTask(false);
    preset_task = new DangerousTask(true);

    if(safe) {
        model = new SynchronizedTreeModel(new DefaultSynchronizedTreeNode("Root"));
    }
    else {
        model = new DefaultTreeModel(new DefaultMutableTreeNode("Root"));
    }
    
    tree = new JTree(model);

    JPanel button_panel = new JPanel();
    JButton add_button = new GLIButton("Add Node");
    add_button.setMnemonic(KeyEvent.VK_A);
    dangerous_button = new JToggleButton("Dangerous!");
    dangerous_button.setSelected(false);
    JButton remove_button = new GLIButton("Remove Node");
    remove_button.setMnemonic(KeyEvent.VK_R);
    JButton preset_button = new GLIButton("Preset Structure");
    preset_button.setMnemonic(KeyEvent.VK_P);

    // Connection
    add_button.addActionListener(new AddListener());
    dangerous_button.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent event) {
            if(dangerous_button.isSelected()) {
            task.start();
            }
            else {
            task.exit = true;
            }
        }
        });
    remove_button.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent event) {
            ///ystem.err.println("*** Start Remove ***");
            // Get the selected node
            TreePath selected_path = tree.getSelectionPath();
            if(selected_path != null) {
            DefaultMutableTreeNode old_child = (DefaultMutableTreeNode)     selected_path.getLastPathComponent();
            if(!old_child.isRoot()) {
                // Remove node.
                model.removeNodeFromParent(old_child);
            }
            }
            ///ystem.err.println("*** End Remove ***\n");
        }
        });
    preset_button.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent event) {
            preset_task.start();
        }
        });
    
    // Layout
    button_panel.setLayout(new GridLayout(2,2));
    button_panel.add(add_button);
    button_panel.add(remove_button);
    button_panel.add(preset_button);
    button_panel.add(dangerous_button);
    
    content_panel.setLayout(new BorderLayout());
    content_panel.add(new JScrollPane(tree), BorderLayout.CENTER);
    content_panel.add(button_panel, BorderLayout.SOUTH);

    // Display
    Dimension screen_size = Toolkit.getDefaultToolkit().getScreenSize();
    setLocation((screen_size.width - SIZE.width) / 2, (screen_size.height - SIZE.height) / 2);
    show();
    }

    private class AddListener
    implements ActionListener {
    public void actionPerformed(ActionEvent event) {
        ///ystem.err.println("*** Start Add ***");
        // Get the selected node
        TreePath selected_path = tree.getSelectionPath();
        if(selected_path != null) {
        DefaultMutableTreeNode parent = (DefaultMutableTreeNode)    selected_path.getLastPathComponent();
        // Create a new node
        MutableTreeNode new_child = new DefaultSynchronizedTreeNode(    String.valueOf(System.currentTimeMillis()));
        // Insert node.
        model.insertNodeInto(new_child, parent, parent.getChildCount());
        }
        ///ystem.err.println("*** End Add ***\n");
    }
    }

    private class DangerousTask
    extends Thread {

    private boolean exit = false;
    private boolean preset = false;

    DangerousTask(boolean preset) {
        this.preset = preset;
    }

    public void run() {
        if(preset) {
        DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
        MutableTreeNode alpha = new DefaultSynchronizedTreeNode("Alpha");
        MutableTreeNode beta = new DefaultSynchronizedTreeNode("Beta");
        MutableTreeNode delta = new DefaultSynchronizedTreeNode("Delta");
        MutableTreeNode gamma = new DefaultSynchronizedTreeNode("Gamma");
        MutableTreeNode epsilon = new DefaultSynchronizedTreeNode("Epsilon");
        MutableTreeNode rho = new DefaultSynchronizedTreeNode("Rho");
        MutableTreeNode pi = new DefaultSynchronizedTreeNode("Pi");
        MutableTreeNode xhi = new DefaultSynchronizedTreeNode("Xhi");
        MutableTreeNode kappa = new DefaultSynchronizedTreeNode("Kappa");
        MutableTreeNode lambda = new DefaultSynchronizedTreeNode("Lambda");
        MutableTreeNode omega = new DefaultSynchronizedTreeNode("Omega");MutableTreeNode tau = new DefaultSynchronizedTreeNode("Tau");
        
        model.insertNodeInto(alpha, root, 0);
        model.insertNodeInto(omega, root, 1);
        model.insertNodeInto(pi, root, 1);

        model.insertNodeInto(beta, alpha, 0);
        model.insertNodeInto(delta, beta, 0);
        model.insertNodeInto(epsilon, delta, 0);
        model.insertNodeInto(gamma, delta, 0);
        model.insertNodeInto(rho, pi, 0);
        model.insertNodeInto(xhi, alpha, 0);
        model.insertNodeInto(kappa, root, 1);

        debug("Root has: " + model.getChildCount(model.getRoot()));
        }
        else {
        exit = false;
        while(!exit) {
            // Find a random node
            DefaultMutableTreeNode current = (DefaultMutableTreeNode) model.getRoot();
            while(Math.random() > 0.3 && model.getChildCount(current) > 0) {
            int index = (int)(Math.random() * (model.getChildCount(current) - 1));
            current = (DefaultMutableTreeNode) model.getChild(current, index);
            }
            // Either add or remove a random node.
            if(Math.random() > 0.9) {
            ///ystem.err.println("<< Expand >>");
            TreePath path = new TreePath(model.getPathToRoot(current));
            tree.expandPath(path);
            }
            else if(Math.random() > 0.4 || current.isRoot()) {
            if(model.getChildCount(current) < 25) {
                ///ystem.err.println("<<< Add >>>");
                // Add a new node
                MutableTreeNode new_child = new DefaultSynchronizedTreeNode(String.valueOf(System.currentTimeMillis()));
                // Insert node.
                model.insertNodeInto(new_child, current, model. getChildCount(current));
                ///ystem.err.println("<<<     >>>\n");
            }
            }
            else {
            ///ystem.err.println("<<< Remove >>>");
            // Remove node.
            model.removeNodeFromParent(current);
            ///ystem.err.println("<<<        >>>\n");
            }

            // Wait some random minute amount of time
            try {
            synchronized(this) {
                wait((int)(5 * Math.random()) + 1);
            }
            } catch (Exception exception) {
            exception.printStackTrace();
            }
        }
        }
    }
    }
}