Coverage Report

Coverage Report - org.kuali.student.core.statement.ui.client.widgets.table.TreeTable

Classes in this File

Line Coverage

Branch Coverage

Complexity

TreeTable

0/74

0/44

3.7

 /**
  * Copyright 2010 The Kuali Foundation Licensed under the
  * Educational Community License, Version 2.0 (the "License"); you may
  * not use this file except in compliance with the License. You may
  * obtain a copy of the License at
  *
  * http://www.osedu.org/licenses/ECL-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an "AS IS"
  * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing
  * permissions and limitations under the License.
  */
 
 package org.kuali.student.core.statement.ui.client.widgets.table;
 
 import org.kuali.student.core.statement.ui.client.widgets.rules.Token;
 
 import com.google.gwt.user.client.ui.FlexTable;
 
 /**
  * Layout the token tree in GWT FlexTable.
  * 
  * */
 public class TreeTable extends FlexTable {
 
     public TreeTable() {
         super();
         setBorderWidth(1);
     }
 
     public NodeWidget getRootNodeWidget(){
         return (NodeWidget)super.getWidget(0, 0);
     }
 
     private void initTable(Node root) {
         super.clear();
         int column = root.getMaxLevelDistance() + 1; // 1 is for root
         int row = root.getAllLeafCount();
 
         for (int i = 0; i < row; i++) {
             for (int j = 0; j < column; j++) {
                 Node emptyNode = new Node();
                 emptyNode.setUserObject("Empty:" + i + ":" + j);
                 setWidget(i, j, new NodeWidget(emptyNode));
             }
         }
     }
 
     public void buildTable(Node root) {
         root = ExpressionParser.mergeBinaryTree(root);
         //root = ExpressionParser.reStructure(root);
         initTable(root);
         buildTable(root, 0);
         for (int i = 0; i < getRowCount(); i++) {
             for (int j = getCellCount(i) - 1; j >= 0; j--) {
                 NodeWidget w = (NodeWidget) getWidget(i, j);
                 if (w.getNode().isLeaf() == false) {
                     mergeCellAcrossRow(i, j, w.getNode().getAllLeafCount() - 1);
                 }
             }
         }
         for (int i = 0; i < getRowCount(); i++) {
             for (int j = getCellCount(i) - 1; j >= 0; j--) {
                 NodeWidget w = (NodeWidget) getWidget(i, j);
                 if (w.getNode().getUserObject().toString().startsWith("Empty")) {
                     // mergeCellAcrossRow(i, j, w.getNode().getAllLeafCount()-1);
                     NodeWidget n = ((NodeWidget) super.getWidget(i, j - 1));
                     mergeCellAcrossColumn(i, j - 1);
                     setWidget(i, j - 1, n);
                 }
             }
         }
     }
     /** Get the row index for siblings*/
     private int getRowIndexAmongSibings(Node node) {
         Node parent = node.getParent();
         if (parent == null) {
             return 0;
         }
 
         int count = getParentRowIndex(node);
         for (int i = 0; i < parent.getChildCount(); i++) {
             Node child = parent.getChildAt(i);
             if (child == node) {
                 return count;
             }
             if (child.isLeaf()) {
                 count++;
             } else {
                 count += child.getAllLeafCount();
             }
 
         }
         return count;
     }
     
     public NodeWidget getNodeWidget(Node node) {
         NodeWidget result = null;
         for (int i = 0; i < getRowCount(); i++) {
             for (int j =0; j < getCellCount(i); j++) {
                 NodeWidget w = (NodeWidget) getWidget(i, j);
                 if (w.getNode() == node) {
                     return w;
                 }
             }
         }
         return result;
     }
     
     /**
      * Get the starting row for node passed in
      * 
      * @param node target node
      * */
     public int getParentRowIndex(Node node) {
         Node parent = node.getParent();
         if (parent == null) {
             return 0;
         }
         for (int i = 0; i < getRowCount(); i++) {
             for (int j = 0; j < getCellCount(i); j++) {
                 NodeWidget w = (NodeWidget) getWidget(i, j);
                 if (w.getNode() == node.getParent()) {
                     return i;
                 }
             }
         }
         return 0;
     }
     /** Build table for node passed in at columnIndex
      * 
      * @param node target node
      * @Param columnIndex column index
      * */
     private void buildTable(Node<Token> node, int columnIndex) {
         int rowIndex = getRowIndexAmongSibings(node);
         setWidget(rowIndex, columnIndex, new NodeWidget(node));
 
         for (int i = 0; i < node.getChildCount(); i++) {
             Node child = node.getChildAt(i);
             if (child.isLeaf()) {
                 int childRowIndex = getRowIndexAmongSibings(child);
                 ((NodeWidget) super.getWidget(childRowIndex, columnIndex + 1)).setNode(child);
             } else {
                 buildTable(child, columnIndex + 1);
             }
         }
 
     }
     /** Merge rows.
      * 
      * @param row row index
      * @param column column index
      * @param count row count
      * 
      * */
     public void mergeCellAcrossRow(int row, int column, int count) {
         for (int i = 1; i <= count; i++) {
             removeCell(row + i, column);
         }
         getFlexCellFormatter().setRowSpan(row, column, count + 1);
     }
     /**
      * Merge columns
      * 
      * @param row row index
      * @param column column index
      * */
     
     public void mergeCellAcrossColumn(int row, int column) {
         removeCell(row, column);
         getFlexCellFormatter().setColSpan(row, column, 10);
     }
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		package org.kuali.student.core.statement.ui.client.widgets.table;
17
18		import org.kuali.student.core.statement.ui.client.widgets.rules.Token;
19
20		import com.google.gwt.user.client.ui.FlexTable;
21
22		/**
23		* Layout the token tree in GWT FlexTable.
24		*
25		* */
26		public class TreeTable extends FlexTable {
27
28		public TreeTable() {
29	0	super();
30	0	setBorderWidth(1);
31	0	}
32
33		public NodeWidget getRootNodeWidget(){
34	0	return (NodeWidget)super.getWidget(0, 0);
35		}
36
37		private void initTable(Node root) {
38	0	super.clear();
39	0	int column = root.getMaxLevelDistance() + 1; // 1 is for root
40	0	int row = root.getAllLeafCount();
41
42	0	for (int i = 0; i < row; i++) {
43	0	for (int j = 0; j < column; j++) {
44	0	Node emptyNode = new Node();
45	0	emptyNode.setUserObject("Empty:" + i + ":" + j);
46	0	setWidget(i, j, new NodeWidget(emptyNode));
47		}
48		}
49	0	}
50
51		public void buildTable(Node root) {
52	0	root = ExpressionParser.mergeBinaryTree(root);
53		//root = ExpressionParser.reStructure(root);
54	0	initTable(root);
55	0	buildTable(root, 0);
56	0	for (int i = 0; i < getRowCount(); i++) {
57	0	for (int j = getCellCount(i) - 1; j >= 0; j--) {
58	0	NodeWidget w = (NodeWidget) getWidget(i, j);
59	0	if (w.getNode().isLeaf() == false) {
60	0	mergeCellAcrossRow(i, j, w.getNode().getAllLeafCount() - 1);
61		}
62		}
63		}
64	0	for (int i = 0; i < getRowCount(); i++) {
65	0	for (int j = getCellCount(i) - 1; j >= 0; j--) {
66	0	NodeWidget w = (NodeWidget) getWidget(i, j);
67	0	if (w.getNode().getUserObject().toString().startsWith("Empty")) {
68		// mergeCellAcrossRow(i, j, w.getNode().getAllLeafCount()-1);
69	0	NodeWidget n = ((NodeWidget) super.getWidget(i, j - 1));
70	0	mergeCellAcrossColumn(i, j - 1);
71	0	setWidget(i, j - 1, n);
72		}
73		}
74		}
75	0	}
76		/** Get the row index for siblings*/
77		private int getRowIndexAmongSibings(Node node) {
78	0	Node parent = node.getParent();
79	0	if (parent == null) {
80	0	return 0;
81		}
82
83	0	int count = getParentRowIndex(node);
84	0	for (int i = 0; i < parent.getChildCount(); i++) {
85	0	Node child = parent.getChildAt(i);
86	0	if (child == node) {
87	0	return count;
88		}
89	0	if (child.isLeaf()) {
90	0	count++;
91		} else {
92	0	count += child.getAllLeafCount();
93		}
94
95		}
96	0	return count;
97		}
98
99		public NodeWidget getNodeWidget(Node node) {
100	0	NodeWidget result = null;
101	0	for (int i = 0; i < getRowCount(); i++) {
102	0	for (int j =0; j < getCellCount(i); j++) {
103	0	NodeWidget w = (NodeWidget) getWidget(i, j);
104	0	if (w.getNode() == node) {
105	0	return w;
106		}
107		}
108		}
109	0	return result;
110		}
111
112		/**
113		* Get the starting row for node passed in
114		*
115		* @param node target node
116		* */
117		public int getParentRowIndex(Node node) {
118	0	Node parent = node.getParent();
119	0	if (parent == null) {
120	0	return 0;
121		}
122	0	for (int i = 0; i < getRowCount(); i++) {
123	0	for (int j = 0; j < getCellCount(i); j++) {
124	0	NodeWidget w = (NodeWidget) getWidget(i, j);
125	0	if (w.getNode() == node.getParent()) {
126	0	return i;
127		}
128		}
129		}
130	0	return 0;
131		}
132		/** Build table for node passed in at columnIndex
133		*
134		* @param node target node
135		* @Param columnIndex column index
136		* */
137		private void buildTable(Node<Token> node, int columnIndex) {
138	0	int rowIndex = getRowIndexAmongSibings(node);
139	0	setWidget(rowIndex, columnIndex, new NodeWidget(node));
140
141	0	for (int i = 0; i < node.getChildCount(); i++) {
142	0	Node child = node.getChildAt(i);
143	0	if (child.isLeaf()) {
144	0	int childRowIndex = getRowIndexAmongSibings(child);
145	0	((NodeWidget) super.getWidget(childRowIndex, columnIndex + 1)).setNode(child);
146	0	} else {
147	0	buildTable(child, columnIndex + 1);
148		}
149		}
150
151	0	}
152		/** Merge rows.
153		*
154		* @param row row index
155		* @param column column index
156		* @param count row count
157		*
158		* */
159		public void mergeCellAcrossRow(int row, int column, int count) {
160	0	for (int i = 1; i <= count; i++) {
161	0	removeCell(row + i, column);
162		}
163	0	getFlexCellFormatter().setRowSpan(row, column, count + 1);
164	0	}
165		/**
166		* Merge columns
167		*
168		* @param row row index
169		* @param column column index
170		* */
171
172		public void mergeCellAcrossColumn(int row, int column) {
173	0	removeCell(row, column);
174	0	getFlexCellFormatter().setColSpan(row, column, 10);
175	0	}
176		}