most of the way through implementing hiding changes of unattached links... what a headache! (Every time I touch ModeVersions it's a headache though so I should have known...)

Author: zackriegman

src/org/argmap/client/ModeVersions.java

@@ -11,6 +11,7 @@
 import org.argmap.client.ArgMapService.NodeChangesMaps;
 import org.argmap.client.ArgMapService.NodeChangesMapsAndRootChanges;
 import org.argmap.client.ArgMapService.NodeWithChanges;
+import org.argmap.client.Change.ChangeType;
 
 import com.google.gwt.dom.client.Style;
 import com.google.gwt.dom.client.Style.Unit;
@@ -372,7 +373,8 @@ private SortedMultiMap<Date, ViewChange> prepTreeWithDeletedNodesAndChangesAndBu
 		for (int i = 0; i < treeClone.getItemCount(); i++) {
 			ViewPropVer viewPropVer = (ViewPropVer) treeClone.getItem(i);
 			recursivePrepAndBuild(viewPropVer, timeMachineMap, changesMaps, log);
-			recursiveHideLinkedSubtreesDuringUnlinkedPeriods(viewPropVer);
+			recursiveHideLinkedSubtreesDuringUnlinkedPeriods(viewPropVer,
+					new TimePeriods());
 		}
 		log.finish();
 		return timeMachineMap;
@@ -499,20 +501,109 @@ private void loadChangesIntoNodeAndMap(ViewNodeVer viewNode,
 		}
 	}
 
-	public void recursiveHideLinkedSubtreesDuringUnlinkedPeriods(
-			ViewNodeVer viewPNodeVer, List list) {
+	/*
+	 * TODO still need to make alwaysHidden Changes actually hidden when
+	 * building the change list.
+	 * 
+	 * TODO this just does the initial hide... need to redo this every time the
+	 * user opens and loads unloaded children for the first time... right?
+	 * 
+	 * TODO explain what this function does in a comment here
+	 */
+	private void recursiveHideLinkedSubtreesDuringUnlinkedPeriods(
+			ViewNodeVer viewNodeVer, TimePeriods hidePeriods) {
+		if (viewNodeVer instanceof ViewDummyVer) {
+			return;
+		}
+
+		List<ViewChange> viewChangeList = viewNodeVer.getViewChangeList();
+
 		// hide all changes of this node that occur within a period in list
+		for (ViewChange viewChange : viewChangeList) {
+			if (hidePeriods.covers(viewChange.change.date)) {
+				viewChange.alwaysHidden = true;
+			}
+		}
 
-		// * for each child node
+		if (viewNodeVer instanceof ViewArgVer) {
+			// sort the node's viewChangeList
+			Collections.sort(viewChangeList, ViewChange.DATE_COMPARATOR);
 
-		// * * if this is an argument and the child is a linked node
-		// * * * build a list of periods that the node is unlinked
-		// * * * build a newList of periods that the node is unlinked including
-		// * * * * those from the argument and those from the list just build
+			/*
+			 * start building more restrictive hidePeriods for the children that
+			 * need them
+			 */
+			Map<Long, TimePeriods> newPeriods = new HashMap<Long, TimePeriods>();
+			Map<Long, ViewChange> lastChanges = new HashMap<Long, ViewChange>();
+			for (ViewChange viewChange : viewChangeList) {
+				Long propID = viewChange.change.propID;
+				if (viewChange.change.changeType == ChangeType.PROP_LINK) {
+
+					TimePeriods newPeriod = newPeriods.get(propID);
+					if (newPeriod == null) {
+						newPeriod = hidePeriods.copy();
+						newPeriods.put(propID, newPeriod);
+					}
 
-		// * * recursiveHideLinkedSubtreesDuringUnlinkedPeriods( either list or
-		// * * * newList)
+					ViewChange lastViewChange = lastChanges.get(propID);
+					if (lastViewChange != null
+							&& lastViewChange.change.changeType == ChangeType.PROP_UNLINK) {
+						newPeriod.addPeriod(lastViewChange.change.date,
+								viewChange.change.date);
+					} else {
+						newPeriod.addPeriod(TimePeriods.THIRTY_YEARS_AGO,
+								viewChange.change.date);
+					}
 
+					lastChanges.put(propID, viewChange);
+				} else if (viewChange.change.changeType == ChangeType.PROP_UNLINK) {
+					lastChanges.put(propID, viewChange);
+				}
+			}
+
+			// for each child node
+			for (ViewNodeVer child : new ViewNodeVer.CombinedViewIterator(
+					viewNodeVer)) {
+				Long propID = child.getNodeID();
+
+				/*
+				 * finish building a more restrictive hide period if this child
+				 * needs it
+				 */
+				ViewChange lastViewChange = lastChanges.get(propID);
+				if (lastViewChange != null
+						&& lastViewChange.change.changeType == ChangeType.PROP_UNLINK) {
+					TimePeriods newPeriod = newPeriods.get(propID);
+					if (newPeriod == null) {
+						newPeriod = hidePeriods.copy();
+						newPeriods.put(propID, newPeriod);
+					}
+					/*
+					 * we got here because lastChanges for propID was never set
+					 * to a Change of type PROP_LINK, which means we had a
+					 * PROP_UNLINK with no following link, which means that all
+					 * subsequent changes should be hidden. So we add a hide
+					 * period from the last change to 100 years from now.
+					 */
+					newPeriod.addPeriod(lastViewChange.change.date,
+							TimePeriods.ONE_HUNDRED_YEARS_FROM_NOW);
+				}
+
+				if (newPeriods.containsKey(propID)) {
+					recursiveHideLinkedSubtreesDuringUnlinkedPeriods(child,
+							newPeriods.get(propID));
+				} else {
+					recursiveHideLinkedSubtreesDuringUnlinkedPeriods(child,
+							hidePeriods);
+				}
+			}
+		} else {
+			for (ViewNodeVer child : new ViewNodeVer.CombinedViewIterator(
+					viewNodeVer)) {
+				recursiveHideLinkedSubtreesDuringUnlinkedPeriods(child,
+						hidePeriods);
+			}
+		}
 	}
 
 	private void loadVersionListFromTimeMachine() {

src/org/argmap/client/TimePeriods.java

@@ -156,7 +156,7 @@ public void addPeriod(Date start, Date end) {
 	 * because it comes after the previous start and before the marked end,
 	 * therefore return true.
 	 */
-	public boolean inPeriod(Date date) {
+	public boolean covers(Date date) {
 		for (Marker marker : periods) {
 			if (date.before(marker.date)) {
 				if (marker.start) {
@@ -179,6 +179,14 @@ public TimePeriods copy() {
 		return new TimePeriods(new ArrayList<Marker>(periods));
 	}
 
+	private static long YEAR_IN_MILLIS = 365 * 24 * 60 * 60 * 1000;
+
+	public static Date THIRTY_YEARS_AGO = new Date(System.currentTimeMillis()
+			- 30 * YEAR_IN_MILLIS);
+
+	public static Date ONE_HUNDRED_YEARS_FROM_NOW = new Date(
+			System.currentTimeMillis() + 100 * YEAR_IN_MILLIS);
+
 	/******************************************************
 	 * TEST METHODS (COMMENT THESE OUT WHEN NOT TESTING ) *
 	 ******************************************************/

src/org/argmap/client/ViewArgVer.java

@@ -9,21 +9,20 @@
 
 import org.argmap.client.ArgMapService.NodeChangesMaps;
 
-
 public class ViewArgVer extends ViewArg implements ViewNodeVer {
 	public List<ViewChange> viewChanges = new ArrayList<ViewChange>();
 	public Map<Long, ViewNodeVer> deletedViews = new HashMap<Long, ViewNodeVer>();
 	public Date closedDate;
-	
-	public Date getClosedDate(){
+
+	public Date getClosedDate() {
 		return closedDate;
 	}
-	
-	public void setClosedDate( Date closedDate ){
+
+	public void setClosedDate(Date closedDate) {
 		this.closedDate = closedDate;
 	}
-	
-	public ViewArgVer(){
+
+	public ViewArgVer() {
 		super();
 		textBox.setReadOnly(true);
 	}
@@ -45,59 +44,56 @@ public void removeAndSaveChildView(Long id) {
 
 	public void reviveDeletedView(Long id, int index) {
 		ViewNode viewNode = (ViewNode) deletedViews.remove(id);
-		assert viewNode != null ;
+		assert viewNode != null;
 		insertItem(index, viewNode);
 	}
 
-//	public ViewPropVer createDeletedView(Long id) {
-//		/*
-//		 * this view is just empty; can set to false, because real value will be
-//		 * set before it is used when the time machine goes back in time...
-//		 */
-//		ViewPropVer deletedView = new ViewPropVer(id);
-//		deletedView.setState(true);
-//		deletedViews.put(id, deletedView);
-//		return deletedView;
-//	}
-	
+	// public ViewPropVer createDeletedView(Long id) {
+	// /*
+	// * this view is just empty; can set to false, because real value will be
+	// * set before it is used when the time machine goes back in time...
+	// */
+	// ViewPropVer deletedView = new ViewPropVer(id);
+	// deletedView.setState(true);
+	// deletedViews.put(id, deletedView);
+	// return deletedView;
+	// }
+
 	@Override
-	public ViewNode createChild(){
+	public ViewNode createChild() {
 		return new ViewPropVer();
 	}
-	
+
 	@Override
 	public ViewNodeVer createChild(Node node) {
-		return new ViewPropVer( (Proposition) node );
+		return new ViewPropVer((Proposition) node);
 	}
-	
+
 	@Override
 	public ViewNodeVer createChild(Long nodeID) {
-		return new ViewPropVer( nodeID );
+		return new ViewPropVer(nodeID);
 	}
-	
-	public void addDeletedItem( ViewNodeVer viewNodeVer ){
+
+	public void addDeletedItem(ViewNodeVer viewNodeVer) {
 		assert viewNodeVer.getNodeID() != null;
-		deletedViews.put( viewNodeVer.getNodeID(), viewNodeVer );
-		
+		deletedViews.put(viewNodeVer.getNodeID(), viewNodeVer);
+
 	}
-	
+
 	/*
-	@Override
-	public ViewNodeVer createDeletedDummyView(Long id) {
-		ViewDummyVer deletedView = new ViewDummyVer(id);
-		deletedViews.put(id, deletedView );
-		return deletedView;
-	}
-	*/
+	 * @Override public ViewNodeVer createDeletedDummyView(Long id) {
+	 * ViewDummyVer deletedView = new ViewDummyVer(id); deletedViews.put(id,
+	 * deletedView ); return deletedView; }
+	 */
 
 	public List<ViewChange> getViewChangeList() {
 		return viewChanges;
 	}
-	
-	public List<ViewChange> getViewChangeHideList(){
+
+	public List<ViewChange> getViewChangeHideList() {
 		List<ViewChange> list = new ArrayList<ViewChange>();
-		for( ViewChange viewChange : viewChanges ){
-			switch( viewChange.change.changeType ){
+		for (ViewChange viewChange : viewChanges) {
+			switch (viewChange.change.changeType) {
 			case PROP_ADDITION:
 			case PROP_DELETION:
 			case PROP_LINK:
@@ -110,7 +106,7 @@ public List<ViewChange> getViewChangeHideList(){
 				assert false;
 				break;
 			case ARG_MODIFICATION:
-				//do nothing
+				// do nothing
 				break;
 			}
 		}
@@ -120,8 +116,8 @@ public List<ViewChange> getViewChangeHideList(){
 	public ViewNodeVer getChildViewNode(int i) {
 		return (ViewNodeVer) getChild(i);
 	}
-	
-	public Collection<ViewNodeVer> getDeletedViewList(){
+
+	public Collection<ViewNodeVer> getDeletedViewList() {
 		return deletedViews.values();
 	}
 
@@ -133,7 +129,5 @@ public NodeChanges chooseNodeChanges(NodeChangesMaps changesMaps) {
 	@Override
 	public void clearDeletedViews() {
 		deletedViews.clear();
-		
 	}
-
 }

src/org/argmap/client/ViewChange.java

@@ -1,5 +1,7 @@
 package org.argmap.client;
 
+import java.util.Comparator;
+
 public class ViewChange {
 	Change change;
 	ViewNodeVer viewNode;
@@ -11,4 +13,13 @@ public String toString() {
 		return "change: " + change + "; viewNode:" + viewNode + "; hidden:"
 				+ hidden + "; alwaysHidden:" + alwaysHidden;
 	}
+
+	public static final Comparator<ViewChange> DATE_COMPARATOR = new Comparator<ViewChange>() {
+
+		@Override
+		public int compare(ViewChange first, ViewChange second) {
+			return first.change.date.compareTo(second.change.date);
+		}
+
+	};
 }