Svelte/src/edu/berkeley/cs/bodik/svelte/plugin/bfsliceview/BFSliceContentProvider.java

   1 package edu.berkeley.cs.bodik.svelte.plugin.bfsliceview;
   2
   3 import java.util.ArrayList;
   4
   5 import org.eclipse.jface.viewers.AbstractTreeViewer;
   6 import org.eclipse.jface.viewers.ITreeContentProvider;
   7 import org.eclipse.jface.viewers.StructuredSelection;
   8 import org.eclipse.jface.viewers.TreeViewer;
   9 import org.eclipse.jface.viewers.Viewer;
  10
  11 import edu.berkeley.cs.bodik.svelte.plugin.EclipseUtils;
  12
  13
  14 public class BFSliceContentProvider
  15 implements ITreeContentProvider //, WordFile.Listener
  16 {
  17         BFSliceInput input;
  18         TreeViewer viewer;
  19         ArrayList<BFSliceStatement> predStack;
  20         ArrayList<BFSliceStatement> children;
  21
  22         private BFSliceStatement activeNode() {
  23                 return predStack.get(predStack.size()-1);
  24         }
  25
  26         /**
  27          * @param s
  28          * @return
  29          * true if the Statement (not BFSliceStatement, but Statement) is in the predStack (including activeNode)
  30          */
  31         public boolean inPredStack(BFSliceStatement s1) {
  32                 for ( BFSliceStatement s2: predStack)
  33                         if ( s1.getStatement() == s2.getStatement() )
  34                                 return true;
  35                 return false;
  36         }
  37
  38         private void recalculateChildren() {
  39                 children = activeNode().getChildren();
  40         }
  41
  42         /**
  43          * @see IStructuredContentProvider#getElements(Object)
  44          */
  45         public Object[] getElements(Object element) {
  46                 return predStack.toArray();
  47         }
  48
  49         /**
  50          * @see IContentProvider#dispose()
  51          */
  52         public void dispose() {
  53                 input = null;
  54                 viewer = null;
  55                 predStack = null;
  56                 children = null;
  57         }
  58
  59         /**
  60          * @see IContentProvider#inputChanged(Viewer, Object, Object)
  61          */
  62         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
  63                 if (viewer instanceof TreeViewer) {
  64                         this.viewer = (TreeViewer)viewer;
  65                         if (newInput instanceof BFSliceInput) {
  66                                 input = (BFSliceInput)newInput;
  67                                 BFSliceStatement root = input.getRoot();
  68                                 predStack = new ArrayList<BFSliceStatement>();
  69                                 predStack.add(root); // first seed now active node
  70                                 children = new ArrayList<BFSliceStatement>();
  71                                 recalculateChildren();
  72 //                              this.viewer.setExpandedState(root, true);
  73 //                              if ( children.size() > 0 )
  74 //                                      viewer.setSelection(new StructuredSelection(children.get(0)));
  75 //                              input.setListener(this);
  76                         }
  77                 }
  78         }
  79
  80         @Override
  81         public Object[] getChildren(Object parentElement) {
  82                 if ( parentElement == activeNode() )
  83                         return children.toArray();
  84
  85                 // TRUETREE
  86                 //              return ((BFSliceStatement)parentElement).getChildren().toArray();
  87                 return null;
  88         }
  89
  90         @Override
  91         public Object getParent(Object element) {
  92                 if ( predStack.contains(element) )
  93                         return input;
  94                 return activeNode(); // in children
  95         }
  96
  97         @Override
  98         public boolean hasChildren(Object element) {
  99                 return element == activeNode();
 100                 // TRUETREE
 101 //              return true;
 102         }
 103
 104         public void followDown(Object firstElement) {
 105                 // TODO: could change to not-linear search, or search predStack like done above
 106                 if ( firstElement instanceof BFSliceStatement && children.contains(firstElement) ) {
 107                         predStack.add((BFSliceStatement) firstElement);
 108                         recalculateChildren();
 109                         viewer.refresh(predStack.get(predStack.size()-2)); // old activeNode() -- upon calling getChildren()/hasChildren(), viewer suddenly realizes it doesn't have any
 110                         viewer.add(input, firstElement);
 111
 112                         viewer.setExpandedState(firstElement, true);
 113                         if ( children.size() > 0 ) {
 114                                 viewer.setSelection(new StructuredSelection(children.get(0)));
 115                                 EclipseUtils.gotoStatement(children.get(0).getStatement());
 116                         }
 117                 }
 118         }
 119
 120         public void backUp() {
 121                 if ( predStack.size() >= 2) {
 122                         BFSliceStatement oldActiveNode = predStack.get(predStack.size()-1);
 123                         BFSliceStatement newActiveNode = predStack.get(predStack.size()-2);
 124
 125                         oldActiveNode.freeChildren(); // frees memory by forgetting about children, we can make more later
 126                         viewer.remove(input,predStack.size()-1); // remove oldActiveNode from the view (it will be added back as a child)
 127                         predStack.remove(predStack.size()-1); // pop oldActiveNode
 128                         recalculateChildren();
 129                         viewer.refresh(newActiveNode); // re-expand old activeNode, it will discovered the new children.
 130
 131                         viewer.setExpandedState(newActiveNode, true);
 132                         viewer.setSelection(new StructuredSelection(oldActiveNode));
 133                         EclipseUtils.gotoStatement(oldActiveNode.getStatement());
 134                 }
 135         }
 136
 137         public void nextQuestion(Object object) {
 138         }
 139
 140         public void nextCheck(Object object) {
 141                 int childindex = children.indexOf(object);
 142                 if ( childindex != -1 ) {
 143                         ((BFSliceStatement)object).markCheck();
 144                         viewer.refresh(object);
 145                 }
 146                 if ( childindex+1 < children.size() ) {
 147                         viewer.setSelection(new StructuredSelection(children.get(childindex+1)));
 148                         EclipseUtils.gotoStatement(children.get(childindex+1).getStatement());
 149                 }
 150         }
 151
 152
 153 //      /**
 154 //      * @see Listener#added()
 155 //      */
 156 //      public void added(Word e) {
 157 //      if (viewer != null)
 158 //      viewer.add(e);
 159 //      }
 160
 161 //      /**
 162 //      * @see Listener#removed()
 163 //      */
 164 //      public void removed(Word e) {
 165 //      if (viewer != null) {
 166 //      viewer.setSelection(null);
 167 //      viewer.remove(e);
 168 //      }
 169 //      }
 170 }
 171