git.mjollnir.org Git - moodle.git/blob

   1 package flare.vis.operator.filter
   2 {
   3         import flare.vis.operator.Operator;
   4         import flare.animate.Transitioner;
   5         import flare.vis.data.NodeSprite;
   6         import flash.utils.Dictionary;
   7         import flare.vis.data.EdgeSprite;
   8         import flare.vis.data.DataSprite;
   9         import flare.vis.data.Data;
  10
  11         /**
  12          * Filter operator that sets visible all items within a specified graph
  13          * distance from a set of focus nodes.
  14          */
  15         public class GraphDistanceFilter extends Operator
  16         {
  17                 /** An array of focal NodeSprites. */
  18                 public var focusNodes:/*NodeSprite*/Array;
  19                 /** Graph distance within which which items wll be visible. */
  20                 public var distance:int;
  21                 /** Flag indicating which graph links to traverse. */
  22                 public var links:int;
  23
  24                 /**
  25                  * Creates a new GraphDistanceFilter.
  26                  * @param focusNodes an array of focal NodeSprites. Graph distance is
  27                  *  measured as the minimum number of edge-hops to one of these nodes.
  28                  * @param distance graph distance within which items will be visible
  29                  * @param links flag indicating which graph links to traverse. The
  30                  *  default value is <code>NodeSprite.GRAPH_LINKS</code>.
  31                  */
  32                 public function GraphDistanceFilter(focusNodes:Array, distance:int=1,
  33                         links:int=3/*NodeSprite.GRAPH_LINKS*/)
  34                 {
  35                         this.focusNodes = focusNodes;
  36                         this.distance = distance;
  37                         this.links = links;
  38                 }
  39
  40                 /** @inheritDoc */
  41                 public override function operate(t:Transitioner=null):void
  42                 {
  43                         t = (t==null ? Transitioner.DEFAULT : t);
  44
  45                 // initialize breadth-first traversal
  46                 var q:Array = [], depths:Dictionary = new Dictionary();
  47                         for each (var fn:NodeSprite in focusNodes) {
  48                                 depths[fn] = 0;
  49                                 fn.visitEdges(function(e:EdgeSprite):void {
  50                                         depths[e] = 1;
  51                                         q.push(e);
  52                                 }, links);
  53                         }
  54
  55                         // perform breadth-first traversal
  56                         var xe:EdgeSprite, xn:NodeSprite, d:int;
  57                         while (q.length > 0) {
  58                                 xe = q.shift(); d = depths[xe];
  59                                 xn = (depths[xe.source] == undefined ? xe.source : xe.target);
  60                                 depths[xn] = d;
  61                                 if (d == distance) continue; // stop traversal at max distance
  62
  63                                 xn.visitEdges(function(e:EdgeSprite):void {
  64                                         if (depths[e] == undefined) {
  65                                                 depths[e] = d+1;
  66                                                 q.push(e);
  67                                         }
  68                                 }, links);
  69                         }
  70
  71                         // now set visibility based on traversal results
  72                 visualization.data.visit(function(ds:DataSprite):void {
  73                         var visible:Boolean = (depths[ds] != undefined);
  74                         var alpha:Number = visible ? 1 : 0;
  75                                 var obj:Object = t.$(ds);
  76
  77                                 obj.alpha = alpha;
  78                                 if (ds is NodeSprite) {
  79                                         var ns:NodeSprite = ds as NodeSprite;
  80                                         ns.expanded = (visible && depths[ds] < distance);
  81                                 }
  82                                 if (t.immediate) {
  83                                         ds.visible = visible;
  84                                 } else {
  85                                         obj.visible = visible;
  86                                 }
  87                 }, Data.ALL);
  88                 }
  89
  90         } // end of class GraphDistanceFilter
  91 }