otg/core/src/types.rs

@@ -3,9 +3,9 @@ use config::define_config;
 use config_derive::ConfigOption;
 use serde::{Deserialize, Serialize};
 use sgf::GameNode;
-use std::{cell::RefCell, collections::VecDeque, fmt, path::PathBuf, time::Duration};
-use thiserror::Error;
 use uuid::Uuid;
+use std::{cell::RefCell, fmt, path::PathBuf, time::Duration};
+use thiserror::Error;
 
 define_config! {
     LibraryPath(LibraryPath),
@@ -235,13 +235,13 @@ impl GameState {
 //
 // So, what is the maximum depth of the tree? Follow all paths and see how far I get in every case.
 // I could do this by just generating an intermediate tree and numbering each level.
+
 pub struct Tree<T> {
     nodes: Vec<Node<T>>,
 }
 
-#[derive(Debug)]
-pub struct Node<T> {
-    pub id: usize,
+struct Node<T> {
+    id: usize,
     node: T,
     parent: Option<usize>,
     depth: usize,
@@ -294,17 +294,6 @@ impl<T> Tree<T> {
         )
     }
 
-    // Since I know the width of a node, now I want to figure out its placement in the larger
-    // scheme of things.
-    //
-    // One thought I have is that I could just develop a grid virtually and start placing nodes.
-    // Whenever I notice a collision, I can just move the node over. But I'd like to see if I can
-    // be a bit smarter than doing it as just a vec into which I place things, as though it's a
-    // game board. So, given a game node, I want to figure out it's position along the X axis.
-    //
-    // Just having the node is greatly insufficient. I can get better results if I'm calculating
-    // the position of its children.
-    //
     // indent represents the indentation that should be applied to all children in this tree. It
     // amounts to the position of the parent node.
     pub fn position(&self, indent: usize, idx: usize) -> (usize, usize) {
@@ -321,22 +310,12 @@ impl<T> Tree<T> {
                 println!("[{}] sibling width {}", idx, sibling_width);
                 (node.depth, indent + sibling_width)
             }
-
+            
             // Root nodes won't have a parent, so just put them in the first column
             None => (0, 0),
         }
     }
 
-    // Given a node, do a postorder traversal to figure out the width of the node based on all of
-    // its children. This is equivalent to the widest of all of its children at all depths.
-    //
-    // There are some collapse rules that I could take into account here, but that I haven't
-    // figured out yet. If two nodes are side by side, and one of them has some wide children but
-    // the other has no children, then they are effectively the same width. The second node only
-    // needs to be moved out if it has children that would overlap the children of the first node.
-    //
-    // My algorithm right now is likely to generate unnecessarily wide trees in a complex game
-    // review.
     fn width(&self, id: usize) -> usize {
         println!("[{}] calculating width", id);
         let node = &self.nodes[id];
@@ -354,12 +333,6 @@ impl<T> Tree<T> {
 
         width
     }
-
-    pub fn bfs_iter<'a>(&'a self) -> BFSIter<T> {
-        let mut queue = VecDeque::new();
-        queue.push_back(&self.nodes[0]);
-        BFSIter { tree: self, queue }
-    }
 }
 
 impl<'a> From<&'a GameNode> for Tree<Uuid> {
@@ -392,30 +365,9 @@ impl<'a> From<&'a GameNode> for Tree<Uuid> {
     }
 }
 
-pub struct BFSIter<'a, T> {
-    tree: &'a Tree<T>,
-    queue: VecDeque<&'a Node<T>>,
-}
-
-impl<'a, T> Iterator for BFSIter<'a, T> {
-    type Item = &'a Node<T>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let retval = self.queue.pop_front();
-        if let Some(ref retval) = retval {
-            retval
-                .children
-                .iter()
-                .for_each(|idx| self.queue.push_back(&self.tree.nodes[*idx]));
-        }
-        retval
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
-    use cool_asserts::assert_matches;
     use sgf::{Move, MoveNode};
 
     #[test]
@@ -546,45 +498,4 @@ mod test {
         assert_eq!(tree.position(0, 6), (1, 3));
         assert_eq!(tree.position(0, 7), (1, 4));
     }
-
-    #[test]
-    fn breadth_first_iter() {
-        let mut node_a = MoveNode::new(sgf::Color::Black, Move::Move("dp".to_owned()));
-        let mut node_b = MoveNode::new(sgf::Color::Black, Move::Move("dp".to_owned()));
-        let mut node_c = MoveNode::new(sgf::Color::Black, Move::Move("dp".to_owned()));
-        let node_d = MoveNode::new(sgf::Color::Black, Move::Move("dp".to_owned()));
-        let node_e = MoveNode::new(sgf::Color::Black, Move::Move("dp".to_owned()));
-        let node_f = MoveNode::new(sgf::Color::Black, Move::Move("dp".to_owned()));
-        let node_g = MoveNode::new(sgf::Color::Black, Move::Move("dp".to_owned()));
-        let mut node_h = MoveNode::new(sgf::Color::Black, Move::Move("dp".to_owned()));
-        let node_i = MoveNode::new(sgf::Color::Black, Move::Move("dp".to_owned()));
-
-        node_c.children.push(GameNode::MoveNode(node_d.clone()));
-        node_c.children.push(GameNode::MoveNode(node_e.clone()));
-        node_c.children.push(GameNode::MoveNode(node_f.clone()));
-
-        node_b.children.push(GameNode::MoveNode(node_c.clone()));
-
-        node_h.children.push(GameNode::MoveNode(node_i.clone()));
-
-        node_a.children.push(GameNode::MoveNode(node_b.clone()));
-        node_a.children.push(GameNode::MoveNode(node_g.clone()));
-        node_a.children.push(GameNode::MoveNode(node_h.clone()));
-
-        let game_tree = GameNode::MoveNode(node_a.clone());
-
-        let tree = Tree::from(&game_tree);
-
-        let mut iter = tree.bfs_iter();
-
-        assert_matches!(iter.next(), Some(Node { node: uuid, .. }) => assert_eq!(*uuid, node_a.id));
-        assert_matches!(iter.next(), Some(Node { node: uuid, .. }) => assert_eq!(*uuid, node_b.id));
-        assert_matches!(iter.next(), Some(Node { node: uuid, .. }) => assert_eq!(*uuid, node_g.id));
-        assert_matches!(iter.next(), Some(Node { node: uuid, .. }) => assert_eq!(*uuid, node_h.id));
-        assert_matches!(iter.next(), Some(Node { node: uuid, .. }) => assert_eq!(*uuid, node_c.id));
-        assert_matches!(iter.next(), Some(Node { node: uuid, .. }) => assert_eq!(*uuid, node_i.id));
-        assert_matches!(iter.next(), Some(Node { node: uuid, .. }) => assert_eq!(*uuid, node_d.id));
-        assert_matches!(iter.next(), Some(Node { node: uuid, .. }) => assert_eq!(*uuid, node_e.id));
-        assert_matches!(iter.next(), Some(Node { node: uuid, .. }) => assert_eq!(*uuid, node_f.id));
-    }
 }

otg/gtk/src/components/review_tree.rs

@@ -66,29 +66,8 @@ impl ReviewTree {
         s
     }
 
-    pub fn redraw(&self, ctx: &Context, _width: i32, _height: i32) {
-        println!("redraw");
-        let tree: &Option<Tree<Uuid>> = &self.imp().tree.borrow();
-        match tree {
-            Some(ref tree) => {
-                for node in tree.bfs_iter() {
-                    // draw a circle given the coordinates of the nodes
-                    // I don't know the indent. How do I keep track of that? Do I track the position of
-                    // the parent? do I need to just make it more intrinsically a part of the position
-                    // code?
-                    ctx.set_source_rgb(0.7, 0.7, 0.7);
-                    let (row, column) = tree.position(0, node.id);
-                    println!("[{}] {} x {}", node.id, row, column);
-                    let y = (row as f64) * 20. + 10.;
-                    let x = (column as f64) * 20. + 10.;
-                    ctx.arc(x, y, 5., 0., 2. * std::f64::consts::PI);
-                    let _ = ctx.stroke();
-                }
-            }
-            None => {
-                // if there is no tree present, then there's nothing to draw!
-            }
-        }
+    pub fn redraw(&self, _ctx: &Context, _width: i32, _height: i32) {
+        // Implement the tree-drawing algorithm here
     }
 }
 
@@ -131,6 +110,43 @@ struct Tree {
 }
 */
 
+// Given a node, do a postorder traversal to figure out the width of the node based on all of its
+// children. This is equivalent to the widest of all of its children at all depths.
+//
+// There are some collapse rules that I could take into account here, but that I haven't figured
+// out yet. If two nodes are side by side, and one of them has some wide children but the other has
+// no children, then they are effectively the same width. The second node only needs to be moved
+// out if it has children that would overlap the children of the first node.
+//
+// My algorithm right now is likely to generate unnecessarily wide trees in a complex game review.
+#[allow(dead_code)]
+fn node_width(node: &GameNode) -> usize {
+    let children: &Vec<GameNode> = match node {
+        GameNode::MoveNode(mn) => &mn.children,
+        GameNode::SetupNode(sn) => &sn.children,
+    };
+
+    if children.is_empty() {
+        return 1;
+    }
+
+    // If there is more than one child, run node_width on each one and add them together.
+    children
+        .iter()
+        .fold(0, |acc, child| acc + node_width(child))
+}
+
+// Since I know the width of a node, now I want to figure out its placement in the larger scheme of
+// things.
+//
+// One thought I have is that I could just develop a grid virtually and start placing nodes.
+// Whenever I notice a collision, I can just move the node over. But I'd like to see if I can be a
+// bit smarter than doing it as just a vec into which I place things, as though it's a game board.
+// So, given a game node, I want to figure out it's position along the X axis.
+//
+// Just having the node is greatly insufficient. I can get better results if I'm calculating the
+// position of its children.
+
 #[cfg(test)]
 mod test {
     use super::*;