sigma-rails 1.0.2

data/vendor/assets/javascripts/sigma.parsers.gexf/sigma.parsers.gexf.js

@@ -0,0 +1,108 @@
+;(function(undefined) {
+  'use strict';
+
+  if (typeof sigma === 'undefined')
+    throw 'sigma is not declared';
+
+  // Initialize package:
+  sigma.utils.pkg('sigma.parsers');
+
+  // Just a basic ID generator:
+  var _id = 0;
+  function edgeId() {
+    return 'e' + (_id++);
+  }
+
+  /**
+   * If the first arguments is a valid URL, this function loads a GEXF file and
+   * creates a new sigma instance or updates the graph of a given instance. It
+   * is possible to give a callback that will be executed at the end of the
+   * process. And if the first argument is a DOM element, it will skip the
+   * loading step and parse the given XML tree to fill the graph.
+   *
+   * @param  {string|DOMElement} target   The URL of the GEXF file or a valid
+   *                                      GEXF tree.
+   * @param  {object|sigma}      sig      A sigma configuration object or a
+   *                                      sigma instance.
+   * @param  {?function}         callback Eventually a callback to execute
+   *                                      after having parsed the file. It will
+   *                                      be called with the related sigma
+   *                                      instance as parameter.
+   */
+  sigma.parsers.gexf = function(target, sig, callback) {
+    var i,
+        l,
+        arr,
+        obj;
+
+    function parse(graph) {
+      // Adapt the graph:
+      arr = graph.nodes;
+      for (i = 0, l = arr.length; i < l; i++) {
+        obj = arr[i];
+
+        obj.id = obj.id;
+        if (obj.viz && typeof obj.viz === 'object') {
+          if (obj.viz.position && typeof obj.viz.position === 'object') {
+            obj.x = obj.viz.position.x;
+            obj.y = obj.viz.position.y;
+          }
+          obj.size = obj.viz.size;
+          obj.color = obj.viz.color;
+        }
+      }
+
+      arr = graph.edges;
+      for (i = 0, l = arr.length; i < l; i++) {
+        obj = arr[i];
+
+        obj.id = typeof obj.id === 'string' ? obj.id : edgeId();
+        obj.source = '' + obj.source;
+        obj.target = '' + obj.target;
+
+        if (obj.viz && typeof obj.viz === 'object') {
+          obj.color = obj.viz.color;
+          obj.size = obj.viz.thickness;
+        }
+
+        // Weight over viz.thickness?
+        obj.size = obj.weight;
+      }
+
+      // Update the instance's graph:
+      if (sig instanceof sigma) {
+        sig.graph.clear();
+
+        arr = graph.nodes;
+        for (i = 0, l = arr.length; i < l; i++)
+          sig.graph.addNode(arr[i]);
+
+        arr = graph.edges;
+        for (i = 0, l = arr.length; i < l; i++)
+          sig.graph.addEdge(arr[i]);
+
+      // ...or instanciate sigma if needed:
+      } else if (typeof sig === 'object') {
+        sig.graph = graph;
+        sig = new sigma(sig);
+
+      // ...or it's finally the callback:
+      } else if (typeof sig === 'function') {
+        callback = sig;
+        sig = null;
+      }
+
+      // Call the callback if specified:
+      if (callback) {
+        callback(sig || graph);
+        return;
+      } else
+        return graph;
+    }
+
+    if (typeof target === 'string')
+      gexf.fetch(target, parse);
+    else if (typeof target === 'object')
+      return parse(gexf.parse(target));
+  };
+}).call(this);

data/vendor/assets/javascripts/sigma.parsers.json/README.md

@@ -0,0 +1,29 @@
+sigma.parsers.json
+==================
+
+Plugin developed by [Alexis Jacomy](https://github.com/jacomyal).
+
+---
+
+This plugin provides a single function, `sigma.parsers.json()`, that will load a JSON encoded file, parse it, eventually instanciate sigma and fill the graph with the `graph.read()` method. The main goal is to avoid using jQuery only to load an external JSON file.
+
+The most basic way to use this helper is to call it with a path and a sigma configuration object. It will then instanciate sigma, but after having added the graph into the config object.
+
+````javascript
+sigma.parsers.json(
+  'myGraph.json',
+  { container: 'myContainer' }
+);
+````
+
+It is also possible to update an existing instance's graph instead.
+
+````javascript
+sigma.parsers.json(
+  'myGraph.json',
+  myExistingInstance,
+  function() {
+    myExistingInstance.refresh();
+  }
+);
+````

data/vendor/assets/javascripts/sigma.parsers.json/sigma.parsers.json.js

@@ -0,0 +1,88 @@
+;(function(undefined) {
+  'use strict';
+
+  if (typeof sigma === 'undefined')
+    throw 'sigma is not declared';
+
+  // Initialize package:
+  sigma.utils.pkg('sigma.parsers');
+  sigma.utils.pkg('sigma.utils');
+
+  /**
+   * Just an XmlHttpRequest polyfill for different IE versions.
+   *
+   * @return {*} The XHR like object.
+   */
+  sigma.utils.xhr = function() {
+    if (window.XMLHttpRequest)
+      return new XMLHttpRequest();
+
+    var names,
+        i;
+
+    if (window.ActiveXObject) {
+      names = [
+        'Msxml2.XMLHTTP.6.0',
+        'Msxml2.XMLHTTP.3.0',
+        'Msxml2.XMLHTTP',
+        'Microsoft.XMLHTTP'
+      ];
+
+      for (i in names)
+        try {
+          return new ActiveXObject(names[i]);
+        } catch (e) {}
+    }
+
+    return null;
+  };
+
+  /**
+   * This function loads a JSON file and creates a new sigma instance or
+   * updates the graph of a given instance. It is possible to give a callback
+   * that will be executed at the end of the process.
+   *
+   * @param  {string}       url      The URL of the JSON file.
+   * @param  {object|sigma} sig      A sigma configuration object or a sigma
+   *                                 instance.
+   * @param  {?function}    callback Eventually a callback to execute after
+   *                                 having parsed the file. It will be called
+   *                                 with the related sigma instance as
+   *                                 parameter.
+   */
+  sigma.parsers.json = function(url, sig, callback) {
+    var graph,
+        xhr = sigma.utils.xhr();
+
+    if (!xhr)
+      throw 'XMLHttpRequest not supported, cannot load the file.';
+
+    xhr.open('GET', url, true);
+    xhr.onreadystatechange = function() {
+      if (xhr.readyState === 4) {
+        graph = JSON.parse(xhr.responseText);
+
+        // Update the instance's graph:
+        if (sig instanceof sigma) {
+          sig.graph.clear();
+          sig.graph.read(graph);
+
+        // ...or instanciate sigma if needed:
+        } else if (typeof sig === 'object') {
+          sig.graph = graph;
+          sig = new sigma(sig);
+
+        // ...or it's finally the callback:
+        } else if (typeof sig === 'function') {
+          callback = sig;
+          sig = null;
+        }
+
+        // Call the callback if specified:
+        if (callback)
+          callback(sig || graph);
+      }
+    };
+    xhr.send();
+  };
+}).call(this);

data/vendor/assets/javascripts/sigma.plugins.animate/README.md

@@ -0,0 +1,8 @@
+sigma.plugins.animate
+=====================
+
+Plugin developed by [Alexis Jacomy](https://github.com/jacomyal).
+
+---
+
+This plugin provides a method to animate a sigma instance by interpolating some node properties. Check the `sigma.plugins.animate` function doc or the `examples/animate.html` code sample to know more.

data/vendor/assets/javascripts/sigma.plugins.animate/sigma.plugins.animate.js

@@ -0,0 +1,165 @@
+/**
+ * This plugin provides a method to animate a sigma instance by interpolating
+ * some node properties. Check the sigma.plugins.animate function doc or the
+ * examples/animate.html code sample to know more.
+ */
+(function() {
+  'use strict';
+
+  if (typeof sigma === 'undefined')
+    throw 'sigma is not declared';
+
+  sigma.utils.pkg('sigma.plugins');
+
+  var _id = 0,
+      _cache = {};
+
+  // TOOLING FUNCTIONS:
+  // ******************
+  function parseColor(val) {
+    if (_cache[val])
+      return _cache[val];
+
+    var result = [0, 0, 0];
+
+    if (val.match(/^#/)) {
+      val = (val || '').replace(/^#/, '');
+      result = (val.length === 3) ?
+        [
+          parseInt(val.charAt(0) + val.charAt(0), 16),
+          parseInt(val.charAt(1) + val.charAt(1), 16),
+          parseInt(val.charAt(2) + val.charAt(2), 16)
+        ] :
+        [
+          parseInt(val.charAt(0) + val.charAt(1), 16),
+          parseInt(val.charAt(2) + val.charAt(3), 16),
+          parseInt(val.charAt(4) + val.charAt(5), 16)
+        ];
+    } else if (val.match(/^ *rgba? *\(/)) {
+      val = val.match(
+        /^ *rgba? *\( *([0-9]*) *, *([0-9]*) *, *([0-9]*) *(,.*)?\) *$/
+      );
+      result = [
+        +val[1],
+        +val[2],
+        +val[3]
+      ];
+    }
+
+    _cache[val] = {
+      r: result[0],
+      g: result[1],
+      b: result[2]
+    };
+
+    return _cache[val];
+  }
+
+  function interpolateColors(c1, c2, p) {
+    c1 = parseColor(c1);
+    c2 = parseColor(c2);
+
+    var c = {
+      r: c1.r * (1 - p) + c2.r * p,
+      g: c1.g * (1 - p) + c2.g * p,
+      b: c1.b * (1 - p) + c2.b * p
+    };
+
+    return 'rgb(' + [c.r | 0, c.g | 0, c.b | 0].join(',') + ')';
+  }
+
+  /**
+   * This function will animate some specified node properties. It will
+   * basically call requestAnimationFrame, interpolate the values and call the
+   * refresh method during a specified duration.
+   *
+   * Recognized parameters:
+   * **********************
+   * Here is the exhaustive list of every accepted parameters in the settings
+   * object:
+   *
+   *   {?(function|string)} easing     Either the name of an easing in the
+   *                                   sigma.utils.easings package or a
+   *                                   function. If not specified, the
+   *                                   quadraticInOut easing from this package
+   *                                   will be used instead.
+   *   {?number}            duration   The duration of the animation. If not
+   *                                   specified, the "animationsTime" setting
+   *                                   value of the sigma instance will be used
+   *                                   instead.
+   *   {?function}          onComplete Eventually a function to call when the
+   *                                   animation is ended.
+   *
+   * @param  {sigma}   s       The related sigma instance.
+   * @param  {object}  animate An hash with the keys being the node properties
+   *                           to interpolate, and the values being the related
+   *                           target values.
+   * @param  {?object} options Eventually an object with options.
+   */
+  sigma.plugins.animate = function(s, animate, options) {
+    var o = options || {},
+        id = ++_id,
+        duration = o.duration || s.settings('animationsTime'),
+        easing = typeof o.easing === 'string' ?
+          sigma.utils.easings[o.easing] :
+          typeof o.easing === 'function' ?
+          o.easing :
+          sigma.utils.easings.quadraticInOut,
+        start = sigma.utils.dateNow(),
+        // Store initial positions:
+        startPositions = s.graph.nodes().reduce(function(res, node) {
+          var k;
+          res[node.id] = {};
+          for (k in animate)
+            if (k in node)
+              res[node.id][k] = node[k];
+          return res;
+        }, {});
+
+    s.animations = s.animations || Object.create({});
+    sigma.plugins.kill(s);
+
+    function step() {
+      var p = (sigma.utils.dateNow() - start) / duration;
+
+      if (p >= 1) {
+        s.graph.nodes().forEach(function(node) {
+          for (var k in animate)
+            if (k in animate)
+              node[k] = node[animate[k]];
+        });
+
+        s.refresh();
+        if (typeof o.onComplete === 'function')
+          o.onComplete();
+      } else {
+        p = easing(p);
+        s.graph.nodes().forEach(function(node) {
+          for (var k in animate)
+            if (k in animate) {
+              if (k.match(/color$/))
+                node[k] = interpolateColors(
+                  startPositions[node.id][k],
+                  node[animate[k]],
+                  p
+                );
+              else
+                node[k] =
+                  node[animate[k]] * p +
+                  startPositions[node.id][k] * (1 - p);
+            }
+        });
+
+        s.refresh();
+        s.animations[id] = requestAnimationFrame(step);
+      }
+    }
+
+    step();
+  };
+
+  sigma.plugins.kill = function(s) {
+    for (var k in (s.animations || {}))
+      cancelAnimationFrame(s.animations[k]);
+  };
+}).call(window);

data/vendor/assets/javascripts/sigma.plugins.dragNodes/README.md

@@ -0,0 +1,8 @@
+sigma.plugins.dragNodes
+=====================
+
+Plugin developed by [José M. Camacho](https://github.com/josemazo).
+
+---
+
+This plugin provides a method to drag & drop nodes. At the moment, this plugin is not compatible with the WebGL renderer. Check the sigma.plugins.dragNodes function doc or the examples/drag-nodes.html code sample to know more.

data/vendor/assets/javascripts/sigma.plugins.dragNodes/sigma.plugins.dragNodes.js

@@ -0,0 +1,135 @@
+/**
+ * This plugin provides a method to drag & drop nodes. Check the
+ * sigma.plugins.dragNodes function doc or the examples/basic.html &
+ * examples/api-candy.html code samples to know more.
+ */
+(function() {
+  'use strict';
+
+  if (typeof sigma === 'undefined')
+    throw 'sigma is not declared';
+
+  sigma.utils.pkg('sigma.plugins');
+
+  /**
+   * This function will add `mousedown`, `mouseup` & `mousemove` events to the
+   * nodes in the `overNode`event to perform drag & drop operations. It uses
+   * `linear interpolation` [http://en.wikipedia.org/wiki/Linear_interpolation]
+   * and `rotation matrix` [http://en.wikipedia.org/wiki/Rotation_matrix] to
+   * calculate the X and Y coordinates from the `cam` or `renderer` node
+   * attributes. These attributes represent the coordinates of the nodes in
+   * the real container, not in canvas.
+   *
+   * Recognized parameters:
+   * **********************
+   * @param  {sigma}    s        The related sigma instance.
+   * @param  {renderer} renderer The related renderer instance.
+   */
+  sigma.plugins.dragNodes = function(s, renderer) {
+    // A quick hardcoded rule to prevent people from using this plugin with the
+    // WebGL renderer (which is impossible at the moment):
+    if (
+      sigma.renderers.webgl &&
+      renderer instanceof sigma.renderers.webgl
+    )
+      throw new Error(
+        'The sigma.plugins.dragNodes is not compatible with the WebGL renderer'
+      );
+
+    var _body = document.body,
+        _container = renderer.container,
+        _mouse = _container.lastChild,
+        _camera = renderer.camera,
+        _node = null,
+        _prefix = '',
+        _isOverNode = false,
+        _isMouseOverCanvas = false;
+
+    // It removes the initial substring ('read_') if it's a WegGL renderer.
+    if (renderer instanceof sigma.renderers.webgl) {
+      _prefix = renderer.options.prefix.substr(5);
+    } else {
+      _prefix = renderer.options.prefix;
+    }
+
+    var nodeMouseOver = function(event) {
+      if (!_isOverNode) {
+        _node = event.data.node;
+        _mouse.addEventListener('mousedown', nodeMouseDown);
+        _isOverNode = true;
+      }
+    };
+
+    var treatOutNode = function(event) {
+      if (_isOverNode) {
+        _mouse.removeEventListener('mousedown', nodeMouseDown);
+        _isOverNode = false;
+      }
+    };
+
+    var nodeMouseDown = function(event) {
+      var size = s.graph.nodes().length;
+      if (size > 1) {
+        _mouse.removeEventListener('mousedown', nodeMouseDown);
+        _body.addEventListener('mousemove', nodeMouseMove);
+        _body.addEventListener('mouseup', nodeMouseUp);
+
+        renderer.unbind('outNode', treatOutNode);
+
+        // Deactivate drag graph.
+        renderer.settings({mouseEnabled: false, enableHovering: false});
+        s.refresh();
+      }
+    };
+
+    var nodeMouseUp = function(event) {
+      _mouse.addEventListener('mousedown', nodeMouseDown);
+      _body.removeEventListener('mousemove', nodeMouseMove);
+      _body.removeEventListener('mouseup', nodeMouseUp);
+
+      treatOutNode();
+      renderer.bind('outNode', treatOutNode);
+
+      // Activate drag graph.
+      renderer.settings({mouseEnabled: true, enableHovering: true});
+      s.refresh();
+    };
+
+    var nodeMouseMove = function(event) {
+      var x = event.pageX - _container.offsetLeft,
+          y = event.pageY - _container.offsetTop,
+          cos = Math.cos(_camera.angle),
+          sin = Math.sin(_camera.angle),
+          nodes = s.graph.nodes(),
+          ref = [];
+
+      // Getting and derotating the reference coordinates.
+      for (var i = 0; i < 2; i++) {
+        var n = nodes[i];
+        var aux = {
+          x: n.x * cos + n.y * sin,
+          y: n.y * cos - n.x * sin,
+          renX: n[_prefix + 'x'],
+          renY: n[_prefix + 'y'],
+        };
+        ref.push(aux);
+      }
+
+      // Applying linear interpolation.
+      x = ((x - ref[0].renX) / (ref[1].renX - ref[0].renX)) *
+        (ref[1].x - ref[0].x) + ref[0].x;
+      y = ((y - ref[0].renY) / (ref[1].renY - ref[0].renY)) *
+        (ref[1].y - ref[0].y) + ref[0].y;
+
+      // Rotating the coordinates.
+      _node.x = x * cos - y * sin;
+      _node.y = y * cos + x * sin;
+
+      s.refresh();
+    };
+
+    renderer.bind('overNode', nodeMouseOver);
+    renderer.bind('outNode', treatOutNode);
+  };
+
+}).call(window);