I would save you energy for a more interesting project, just get gramps, its brilliant and free. Failing that, it is open source and python based so should get some clues from the source.

thanks for the reference -- but i really want to learn the principles of tree traversal and creating a recursive data structure by building this sketch out.

i've played around with the sketch a bit, and think i made some progress nesting a newNode as a descendant of a previous Node. but it's getting wonky in the insertNode() method. a child Node is being nested multiple times...
my mind is getting tangled figuring out the recursion process. any help would be really appreciated (i know this isn't the most advanced of a question).

i figured out a version using nested hashMaps to create a force directed graph using the toxiclibs library, but i want to be able to control each Node as an individual particle in a system and feel the hashMap method is limiting me (or maybe this is the way to go?)

thank you!

1. 
   // each category is a Node object
   // 1. grandparent
   // 2. parent
   // 3. child
   
   // each Node knows that its name and who its children are
   
   // test data for Node class (real data will be parsed from .csv file)
   PVector randomVec = new PVector (random (400), random (400));
   PVector randomVec1 = new PVector (random (400), random (400));
   PVector randomVec2 = new PVector (random (400), random (400));
   PVector randomVec3 = new PVector (random (400), random (400));
   
   
   Tree tree;
   // this will later be an ArrayList pulled from parseData(familyTree.csv)
   Node root, grandparent, parent, parent1, child, child1, child2, grandparent2, parent2;
   
   // all Nodes
   ArrayList <Node> allNodes = new ArrayList <Node> ();
   
   
   void setup () {
     size (400, 400);
     background (0);
   
     tree = new Tree();
     // sample Node data point (will later be pulled from a .csv file)
     root = new Node ("Dori", randomVec);
     parent1 = new Node ("Greg", randomVec1);
     parent2 = new Node ("Donald", randomVec2);
     child1 = new Node ("Kimi", randomVec3);
   
    
     // this would later by an ArrayList of data (Nodes) being passed into the tree
     /*
     for (Node n: data) {
      tree.insertNode (n);
      }
      */
   
     tree.insertNode (root);
     tree.insertNode (parent1);   // "greg"
     tree.insertNode (parent2);   // "donald"
     tree.insertNode (child1);    // "kimi"
   
     tree.print();
   }
   
   void draw () {
   
     for (Node n: allNodes) {
       n.display();
     }
     root.display();
   }

1. // Node class keeps track of
   // 1. its parent
   // 2. its children
   
   
   class Node {
     PVector location;
     int x, y;
     String label;
     color col = color (255, 0, 0);
     int count;
   
     // test -- practice recursion of method insertNode()
     Node child;
   
     // Node test will later be replace by ArrayList <Node> children
     // a local ArrayList of a particular Node's children
     ArrayList <Node> children;
   
     Node (String label_, PVector loc) {
       location = loc;
       label = label_;
       children = new ArrayList <Node> ();
       count = 1;
       x = 10;
       y = 10;
   
     }
   
     void display () {
       noStroke ();
       fill (col);
       ellipse (location.x, location.y, 5, 5);
     }
   
     void insertNode (Node newNode) {
       // add ALL inserted Nodes into the allNodes ArrayList
       allNodes.add (newNode);
   
       // recursive tree method (newNode is nested in parent Node, and so on)
       // insert a new node
       // if the spot is empty (insert here, ie = parent)
       //int depth = child.depth;
       //  println (depth + ":: CHILD");
   
       if (child == null) {
         child = newNode;
         println ("child1 is " + child.label + ", " + count);
         location.x = width/2-x;
         location.y = height/2-y;
         //println (location.x);
       }
       // otherwise subNode is populated
       // insert newNode as new child of descendant of subNode
       else {
         child.insertNode (newNode);
         println ("child2 inserted " + child.label + ", " + count);
         location.x = width/2-x*2;
         location.y = height/2-y*2;
         //println (location.x);
       }
       count++;
     }
   
     void printNodes () {
       for (Node n: children) {
         println (n.label + " " + count);
       }
     }
   }
   

1. class Tree {
     Node root;
     color col = color (0, 255, 0);
   
     Tree () {
       root = null;
     }
   
     void insertNode (Node newNode) {
   
       if (root == null) {
         root = newNode;
         // println (root.label);
       }
       else {
         root.insertNode (newNode);
       }
     }
   
   
     // display root in green at center of screen
     void displayRoot () {
       noStroke ();
       fill (col);
       ellipse (width/2, height/2, 5, 5);
     }
   
   
     // print out Node labels that are in the Tree
     void print () {
       // if the Tree is populated (initialized with a root)
       if (root != null) {
         root.printNodes();
       }
     }
   }