Genealogy Tree : Tree « Swing JFC « Java

Home
Java
1.2D Graphics GUI
2.3D
3.Advanced Graphics
4.Ant
5.Apache Common
6.Chart
7.Class
8.Collections Data Structure
9.Data Type
10.Database SQL JDBC
11.Design Pattern
12.Development Class
13.EJB3
14.Email
15.Event
16.File Input Output
17.Game
18.Generics
19.GWT
20.Hibernate
21.I18N
22.J2EE
23.J2ME
24.JDK 6
25.JNDI LDAP
26.JPA
27.JSP
28.JSTL
29.Language Basics
30.Network Protocol
31.PDF RTF
32.Reflection
33.Regular Expressions
34.Scripting
35.Security
36.Servlets
37.Spring
38.Swing Components
39.Swing JFC
40.SWT JFace Eclipse
41.Threads
42.Tiny Application
43.Velocity
44.Web Services SOA
45.XML
Java » Swing JFC » TreeScreenshots 
Genealogy Tree
Genealogy Tree
    
/* From http://java.sun.com/docs/books/tutorial/index.html */
/*
 * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * -Redistribution of source code must retain the above copyright notice, this
 *  list of conditions and the following disclaimer.
 *
 * -Redistribution in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed, licensed or intended
 * for use in the design, construction, operation or maintenance of any
 * nuclear facility.
 */
/*
 * A 1.4 example that uses the following files: GenealogyModel.java Person.java
 
 * Based on an example provided by tutorial reader Olivier Berlanger.
 */

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;

import javax.swing.ButtonGroup;
import javax.swing.Icon;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

public class GenealogyExample extends JPanel implements ActionListener {
  GenealogyTree tree;

  private static String SHOW_ANCESTOR_CMD = "showAncestor";

  public GenealogyExample() {
    super(new BorderLayout());

    //Construct the panel with the toggle buttons.
    JRadioButton showDescendant = new JRadioButton("Show descendants"true);
    final JRadioButton showAncestor = new JRadioButton("Show ancestors");
    ButtonGroup bGroup = new ButtonGroup();
    bGroup.add(showDescendant);
    bGroup.add(showAncestor);
    showDescendant.addActionListener(this);
    showAncestor.addActionListener(this);
    showAncestor.setActionCommand(SHOW_ANCESTOR_CMD);
    JPanel buttonPanel = new JPanel();
    buttonPanel.add(showDescendant);
    buttonPanel.add(showAncestor);

    //Construct the tree.
    tree = new GenealogyTree(getGenealogyGraph());
    JScrollPane scrollPane = new JScrollPane(tree);
    scrollPane.setPreferredSize(new Dimension(200200));

    //Add everything to this panel.
    add(buttonPanel, BorderLayout.PAGE_START);
    add(scrollPane, BorderLayout.CENTER);
  }

  /**
   * Required by the ActionListener interface. Handle events on the
   * showDescendant and showAncestore buttons.
   */
  public void actionPerformed(ActionEvent ae) {
    if (ae.getActionCommand() == SHOW_ANCESTOR_CMD) {
      tree.showAncestor(true);
    else {
      tree.showAncestor(false);
    }
  }

  /**
   * Constructs the genealogy graph used by the model.
   */
  public Person getGenealogyGraph() {
    //the greatgrandparent generation
    Person a1 = new Person("Jack (great-granddaddy)");
    Person a2 = new Person("Jean (great-granny)");
    Person a3 = new Person("Albert (great-granddaddy)");
    Person a4 = new Person("Rae (great-granny)");
    Person a5 = new Person("Paul (great-granddaddy)");
    Person a6 = new Person("Josie (great-granny)");

    //the grandparent generation
    Person b1 = new Person("Peter (grandpa)");
    Person b2 = new Person("Zoe (grandma)");
    Person b3 = new Person("Simon (grandpa)");
    Person b4 = new Person("James (grandpa)");
    Person b5 = new Person("Bertha (grandma)");
    Person b6 = new Person("Veronica (grandma)");
    Person b7 = new Person("Anne (grandma)");
    Person b8 = new Person("Renee (grandma)");
    Person b9 = new Person("Joseph (grandpa)");

    //the parent generation
    Person c1 = new Person("Isabelle (mom)");
    Person c2 = new Person("Frank (dad)");
    Person c3 = new Person("Louis (dad)");
    Person c4 = new Person("Laurence (dad)");
    Person c5 = new Person("Valerie (mom)");
    Person c6 = new Person("Marie (mom)");
    Person c7 = new Person("Helen (mom)");
    Person c8 = new Person("Mark (dad)");
    Person c9 = new Person("Oliver (dad)");

    //the youngest generation
    Person d1 = new Person("Clement (boy)");
    Person d2 = new Person("Colin (boy)");

    Person.linkFamily(a1, a2, new Person[] { b1, b2, b3, b4 });
    Person.linkFamily(a3, a4, new Person[] { b5, b6, b7 });
    Person.linkFamily(a5, a6, new Person[] { b8, b9 });
    Person.linkFamily(b3, b6, new Person[] { c1, c2, c3 });
    Person.linkFamily(b4, b5, new Person[] { c4, c5, c6 });
    Person.linkFamily(b8, b7, new Person[] { c7, c8, c9 });
    Person.linkFamily(c4, c7, new Person[] { d1, d2 });

    return a1;
  }

  /**
   * Create the GUI and show it. For thread safety, this method should be
   * invoked from the event-dispatching thread.
   */
  private static void createAndShowGUI() {
    //Make sure we have nice window decorations.
    JFrame.setDefaultLookAndFeelDecorated(true);

    //Create and set up the window.
    JFrame frame = new JFrame("GenealogyExample");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    //Create and set up the content pane.
    GenealogyExample newContentPane = new GenealogyExample();
    newContentPane.setOpaque(true)//content panes must be opaque
    frame.setContentPane(newContentPane);

    //Display the window.
    frame.pack();
    frame.setVisible(true);
  }

  public static void main(String[] args) {
    //Schedule a job for the event-dispatching thread:
    //creating and showing this application's GUI.
    javax.swing.SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        createAndShowGUI();
      }
    });
  }
}

class GenealogyModel implements TreeModel {
  private boolean showAncestors;

  private Vector treeModelListeners = new Vector();

  private Person rootPerson;

  public GenealogyModel(Person root) {
    showAncestors = false;
    rootPerson = root;
  }

  /**
   * Used to toggle between show ancestors/show descendant and to change the
   * root of the tree.
   */
  public void showAncestor(boolean b, Object newRoot) {
    showAncestors = b;
    Person oldRoot = rootPerson;
    if (newRoot != null) {
      rootPerson = (PersonnewRoot;
    }
    fireTreeStructureChanged(oldRoot);
  }

  //////////////// Fire events //////////////////////////////////////////////

  /**
   * The only event raised by this model is TreeStructureChanged with the root
   * as path, i.e. the whole tree has changed.
   */
  protected void fireTreeStructureChanged(Person oldRoot) {
    int len = treeModelListeners.size();
    TreeModelEvent e = new TreeModelEvent(this, new Object[] { oldRoot });
    for (int i = 0; i < len; i++) {
      ((TreeModelListenertreeModelListeners.elementAt(i))
          .treeStructureChanged(e);
    }
  }

  //////////////// TreeModel interface implementation ///////////////////////

  /**
   * Adds a listener for the TreeModelEvent posted after the tree changes.
   */
  public void addTreeModelListener(TreeModelListener l) {
    treeModelListeners.addElement(l);
  }

  /**
   * Returns the child of parent at index index in the parent's child array.
   */
  public Object getChild(Object parent, int index) {
    Person p = (Personparent;
    if (showAncestors) {
      if ((index > 0&& (p.getFather() != null)) {
        return p.getMother();
      }
      return p.getFather();
    }
    return p.getChildAt(index);
  }

  /**
   * Returns the number of children of parent.
   */
  public int getChildCount(Object parent) {
    Person p = (Personparent;
    if (showAncestors) {
      int count = 0;
      if (p.getFather() != null) {
        count++;
      }
      if (p.getMother() != null) {
        count++;
      }
      return count;
    }
    return p.getChildCount();
  }

  /**
   * Returns the index of child in parent.
   */
  public int getIndexOfChild(Object parent, Object child) {
    Person p = (Personparent;
    if (showAncestors) {
      int count = 0;
      Person father = p.getFather();
      if (father != null) {
        count++;
        if (father == child) {
          return 0;
        }
      }
      if (p.getMother() != child) {
        return count;
      }
      return -1;
    }
    return p.getIndexOfChild((Personchild);
  }

  /**
   * Returns the root of the tree.
   */
  public Object getRoot() {
    return rootPerson;
  }

  /**
   * Returns true if node is a leaf.
   */
  public boolean isLeaf(Object node) {
    Person p = (Personnode;
    if (showAncestors) {
      return ((p.getFather() == null&& (p.getMother() == null));
    }
    return p.getChildCount() == 0;
  }

  /**
   * Removes a listener previously added with addTreeModelListener().
   */
  public void removeTreeModelListener(TreeModelListener l) {
    treeModelListeners.removeElement(l);
  }

  /**
   * Messaged when the user has altered the value for the item identified by
   * path to newValue. Not used by this model.
   */
  public void valueForPathChanged(TreePath path, Object newValue) {
    System.out.println("*** valueForPathChanged : " + path + " --> "
        + newValue);
  }
}

class Person {
  Person father;

  Person mother;

  Vector children;

  private String name;

  public Person(String name) {
    this.name = name;
    mother = father = null;
    children = new Vector();
  }

  /**
   * Link together all members of a family.
   
   @param pa
   *            the father
   @param ma
   *            the mother
   @param kids
   *            the children
   */
  public static void linkFamily(Person pa, Person ma, Person[] kids) {
    int len = kids.length;
    Person kid = null;
    for (int i = 0; i < len; i++) {
      kid = kids[i];
      pa.children.addElement(kid);
      ma.children.addElement(kid);
      kid.father = pa;
      kid.mother = ma;
    }
  }

  /// getter methods ///////////////////////////////////

  public String toString() {
    return name;
  }

  public String getName() {
    return name;
  }

  public Person getFather() {
    return father;
  }

  public Person getMother() {
    return mother;
  }

  public int getChildCount() {
    return children.size();
  }

  public Person getChildAt(int i) {
    return (Personchildren.elementAt(i);
  }

  public int getIndexOfChild(Person kid) {
    return children.indexOf(kid);
  }
}

class GenealogyTree extends JTree {
  GenealogyModel model;

  public GenealogyTree(Person graphNode) {
    super(new GenealogyModel(graphNode));
    getSelectionModel().setSelectionMode(
        TreeSelectionModel.SINGLE_TREE_SELECTION);
    DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
    Icon personIcon = null;
    renderer.setLeafIcon(personIcon);
    renderer.setClosedIcon(personIcon);
    renderer.setOpenIcon(personIcon);
    setCellRenderer(renderer);
  }

  /**
   * Get the selected item in the tree, and call showAncestor with this item
   * on the model.
   */
  public void showAncestor(boolean b) {
    Object newRoot = null;
    TreePath path = getSelectionModel().getSelectionPath();
    if (path != null) {
      newRoot = path.getLastPathComponent();
    }
    ((GenealogyModelgetModel()).showAncestor(b, newRoot);
  }
}

           
         
    
    
    
  
Related examples in the same category
1.Build a tree based on DefaultMutableTreeNodeBuild a tree based on DefaultMutableTreeNode
2.Add Tree to JScrollPaneAdd Tree to JScrollPane
3.Tree LinesTree Lines
4.DefaultMutableTreeNode Node Tree SampleDefaultMutableTreeNode Node Tree Sample
5.Display a file system in a JTree viewDisplay a file system in a JTree view
6.implements TreeSelectionListener to create your own listenerimplements TreeSelectionListener  to create your own listener
7.File folder Tree with iconsFile folder Tree with icons
8.File Tree with Popup MenuFile Tree with Popup Menu
9.File Tree with TooltipsFile Tree with Tooltips
10.Ancestor Tree with IconsAncestor Tree with Icons
11.Tree Icon DemoTree Icon Demo
12.DefaultMutableTreeNode and user objectDefaultMutableTreeNode and user object
13.Display user object in a treeDisplay user object in a tree
14.Tree Expand Event DemoTree Expand Event Demo
15.Tree: Drag and DropTree: Drag and Drop
16.Tree open IconTree open Icon
17.Traverse TreeTraverse Tree
18.Tree based on Array structureTree based on Array structure
19.Tree will Expand event and listenerTree will Expand event and listener
20.Set the Tree LineSet the Tree Line
21.Tree Selection RowTree Selection Row
22.JTree.DynamicUtilTreeNode.createChildrenJTree.DynamicUtilTreeNode.createChildren
23.Install ToolTips for Tree (JTree)Install ToolTips for Tree (JTree)
24.Tree Expand Event Demo 2Tree Expand Event Demo 2
25.A tree with componentA tree with component
26.A sample component for dragging and dropping a collection of files into a tree.A sample component for dragging and dropping a collection of files into a tree.
27.DnD (drag and drop)JTree code DnD (drag and drop)JTree code
28.Build a tree and populate it from hashtablesBuild a tree and populate it from hashtables
29.A simple test to see how we can build a tree and populate itA simple test to see how we can build a tree and populate it
30.Installs custom iconsInstalls custom icons
31.Build a tree and customize its iconsBuild a tree and customize its icons
32.Displaying Hierarchical Data within a JTreeDisplaying Hierarchical Data within a JTree
33.Add and remove tree Node and expand the tree node
34.File System Tree
35.TreeExpansionListener and TreeExpansionEventTreeExpansionListener and TreeExpansionEvent
36.Enabling and Disabling Multiple Selections in a JTree Component
37.Allow only a single node to be selected (default)
38.Allow selection to span one vertical contiguous set of visible nodes
39.Allow multiple selections of visible nodes
40.Setting the Row Height of a JTree
41.All rows will be given 15 pixels of height
42.Have the row height for each row computed individually
43.Flush the internal cache of Row height
44.Preventing Expansion or Collapse of a Node in a JTree: override JTree.setExpandedState()
45.Removing a Node to a JTree Component
46.JTree root cannot be removed with removeNodeFromParent(), use DefaultTreeModel.setRoot() to remove the root
47.Listening for Expansion and Collapse Events in a JTree Component
48.Expansion and Collapse Events in a JTree are fired before a node is expanded or collapsed can be vetoed, thereby preventing the operation.
49.Creating a JTree Component
50.Changing and Removing the Default Icons in a JTree Component
51.Use UIManager to change the default icon for JTree
52.Getting the Selected Nodes in a JTree Component
53.Visiting All the Nodes in a JTree Component
54.Traverse all expanded nodes in tree
55.Finding a Node in a JTree Component
56.Search backward from last visible row looking for any visible node whose name starts with prefix.
57.Find the path regardless of visibility that matches the specified sequence of names
58.Adding a Node to a JTree Component
59.Returns a TreePath containing the specified node.
60.Converting All Nodes in a JTree Component to a TreePath Array
61.Get path for all expanded or not expanded tree pathes
62.Expanding or Collapsing All Nodes in a JTree Component
63.Preventing the Expansion or Collapse of a Node in a JTree Component
64.Listening for Selection Events in a JTree Component
65.Have a popup attached to a JTree
66.Deleting nodes from JTree
67.Adding editable nodes to JTree
68.Searching node in a JTree
69.Drag and drop of a group of files into a tree
70.JTree drag and drop utilites
71.Expand All for a tree path
72.Get tree path from TreeNode
73.JTree Utilities
74.Expand JTree
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.