rubyvis 0.6.0 → 0.6.1

data/vendor/protovis/src/mark/Ease.js

@@ -1,150 +0,0 @@
-/*
- * TERMS OF USE - EASING EQUATIONS
- *
- * Open source under the BSD License.
- *
- * Copyright 2001 Robert Penner
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * - Redistributions of source code must retain the above copyright notice, this
- *   list of conditions and the following disclaimer.
- *
- * - Redistributions in binary form must reproduce the above copyright notice,
- *   this list of conditions and the following disclaimer in the documentation
- *   and/or other materials provided with the distribution.
- *
- * - Neither the name of the author nor the names of contributors may be used to
- *   endorse or promote products derived from this software without specific
- *   prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-pv.Ease = (function() {
-
-  function reverse(f) {
-    return function(t) {
-      return 1 - f(1 - t);
-    };
-  }
-
-  function reflect(f) {
-    return function(t) {
-      return .5 * (t < .5 ? f(2 * t) : (2 - f(2 - 2 * t)));
-    };
-  }
-
-  function poly(e) {
-    return function(t) {
-      return t < 0 ? 0 : t > 1 ? 1 : Math.pow(t, e);
-    }
-  }
-
-  function sin(t) {
-    return 1 - Math.cos(t * Math.PI / 2);
-  }
-
-  function exp(t) {
-    return t ? Math.pow(2, 10 * (t - 1)) - 0.001 : 0;
-  }
-
-  function circle(t) {
-    return -(Math.sqrt(1 - t * t) - 1);
-  }
-
-  function elastic(a, p) {
-    var s;
-    if (!p) p = 0.45;
-    if (!a || a < 1) { a = 1; s = p / 4; }
-    else s = p / (2 * Math.PI) * Math.asin(1 / a);
-    return function(t) {
-      return t <= 0 || t >= 1 ? t
-          : -(a * Math.pow(2, 10 * (--t)) * Math.sin((t - s) * (2 * Math.PI) / p));
-    };
-  }
-
-  function back(s) {
-    if (!s) s = 1.70158;
-    return function(t) {
-      return t * t * ((s + 1) * t - s);
-    };
-  }
-
-  function bounce(t) {
-    return t < 1 / 2.75 ? 7.5625 * t * t
-        : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75
-        : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375
-        : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;
-  }
-
-  var quad = poly(2),
-      cubic = poly(3),
-      elasticDefault = elastic(),
-      backDefault = back();
-
-  var eases = {
-    "linear": pv.identity,
-    "quad-in": quad,
-    "quad-out": reverse(quad),
-    "quad-in-out": reflect(quad),
-    "quad-out-in": reflect(reverse(quad)),
-    "cubic-in": cubic,
-    "cubic-out": reverse(cubic),
-    "cubic-in-out": reflect(cubic),
-    "cubic-out-in": reflect(reverse(cubic)),
-    "sin-in": sin,
-    "sin-out": reverse(sin),
-    "sin-in-out": reflect(sin),
-    "sin-out-in": reflect(reverse(sin)),
-    "exp-in": exp,
-    "exp-out": reverse(exp),
-    "exp-in-out": reflect(exp),
-    "exp-out-in": reflect(reverse(exp)),
-    "circle-in": circle,
-    "circle-out": reverse(circle),
-    "circle-in-out": reflect(circle),
-    "circle-out-in": reflect(reverse(circle)),
-    "elastic-in": elasticDefault,
-    "elastic-out": reverse(elasticDefault),
-    "elastic-in-out": reflect(elasticDefault),
-    "elastic-out-in": reflect(reverse(elasticDefault)),
-    "back-in": backDefault,
-    "back-out": reverse(backDefault),
-    "back-in-out": reflect(backDefault),
-    "back-out-in": reflect(reverse(backDefault)),
-    "bounce-in": bounce,
-    "bounce-out": reverse(bounce),
-    "bounce-in-out": reflect(bounce),
-    "bounce-out-in": reflect(reverse(bounce))
-  };
-
-  pv.ease = function(f) {
-    return eases[f];
-  };
-
-  return {
-    reverse: reverse,
-    reflect: reflect,
-    linear: function() { return pv.identity; },
-    sin: function() { return sin; },
-    exp: function() { return exp; },
-    circle: function() { return circle; },
-    elastic: elastic,
-    back: back,
-    bounce: bounce,
-    poly: poly
-  };
-})();

data/vendor/protovis/src/mark/Image.js

@@ -1,154 +0,0 @@
-/**
- * Constructs a new image with default properties. Images are not typically
- * constructed directly, but by adding to a panel or an existing mark via
- * {@link pv.Mark#add}.
- *
- * @class Represents an image, either a static resource or a dynamically-
- * generated pixel buffer. Images share the same layout and style properties as
- * bars. The external image resource is specified via the {@link #url}
- * property. The optional fill, if specified, appears beneath the image, while
- * the optional stroke appears above the image.
- *
- * <p>Dynamic images such as heatmaps are supported using the {@link #image}
- * psuedo-property. This function is passed the <i>x</i> and <i>y</i> index, in
- * addition to the current data stack. The return value is a {@link pv.Color},
- * or null for transparent. A string can also be returned, which will be parsed
- * into a color; however, it is typically much faster to return an object with
- * <tt>r</tt>, <tt>g</tt>, <tt>b</tt> and <tt>a</tt> attributes, to avoid the
- * cost of parsing and object instantiation.
- *
- * <p>See {@link pv.Bar} for details on positioning properties.
- *
- * @extends pv.Bar
- */
-pv.Image = function() {
-  pv.Bar.call(this);
-};
-
-pv.Image.prototype = pv.extend(pv.Bar)
-    .property("url", String)
-    .property("imageWidth", Number)
-    .property("imageHeight", Number);
-
-pv.Image.prototype.type = "image";
-
-/**
- * The URL of the image to display. The set of supported image types is
- * browser-dependent; PNG and JPEG are recommended.
- *
- * @type string
- * @name pv.Image.prototype.url
- */
-
-/**
- * The width of the image in pixels. For static images, this property is
- * computed implicitly from the loaded image resources. For dynamic images, this
- * property can be used to specify the width of the pixel buffer; otherwise, the
- * value is derived from the <tt>width</tt> property.
- *
- * @type number
- * @name pv.Image.prototype.imageWidth
- */
-
-/**
- * The height of the image in pixels. For static images, this property is
- * computed implicitly from the loaded image resources. For dynamic images, this
- * property can be used to specify the height of the pixel buffer; otherwise, the
- * value is derived from the <tt>height</tt> property.
- *
- * @type number
- * @name pv.Image.prototype.imageHeight
- */
-
-/**
- * Default properties for images. By default, there is no stroke or fill style.
- *
- * @type pv.Image
- */
-pv.Image.prototype.defaults = new pv.Image()
-    .extend(pv.Bar.prototype.defaults)
-    .fillStyle(null);
-
-/**
- * Specifies the dynamic image function. By default, no image function is
- * specified and the <tt>url</tt> property is used to load a static image
- * resource. If an image function is specified, it will be invoked for each
- * pixel in the image, based on the related <tt>imageWidth</tt> and
- * <tt>imageHeight</tt> properties.
- *
- * <p>For example, given a two-dimensional array <tt>heatmap</tt>, containing
- * numbers in the range [0, 1] in row-major order, a simple monochrome heatmap
- * image can be specified as:
- *
- * <pre>vis.add(pv.Image)
- *     .imageWidth(heatmap[0].length)
- *     .imageHeight(heatmap.length)
- *     .image(pv.ramp("white", "black").by(function(x, y) heatmap[y][x]));</pre>
- *
- * For fastest performance, use an ordinal scale which caches the fixed color
- * palette, or return an object literal with <tt>r</tt>, <tt>g</tt>, <tt>b</tt>
- * and <tt>a</tt> attributes. A {@link pv.Color} or string can also be returned,
- * though this typically results in slower performance.
- *
- * @param {function} f the new sizing function.
- * @returns {pv.Layout.Pack} this.
- */
-pv.Image.prototype.image = function(f) {
-  /** @private */
-  this.$image = function() {
-      var c = f.apply(this, arguments);
-      return c == null ? pv.Color.transparent
-          : typeof c == "string" ? pv.color(c)
-          : c;
-    };
-  return this;
-};
-
-/** @private Scan the proto chain for an image function. */
-pv.Image.prototype.bind = function() {
-  pv.Bar.prototype.bind.call(this);
-  var binds = this.binds, mark = this;
-  do {
-    binds.image = mark.$image;
-  } while (!binds.image && (mark = mark.proto));
-};
-
-/** @private */
-pv.Image.prototype.buildImplied = function(s) {
-  pv.Bar.prototype.buildImplied.call(this, s);
-  if (!s.visible) return;
-
-  /* Compute the implied image dimensions. */
-  if (s.imageWidth == null) s.imageWidth = s.width;
-  if (s.imageHeight == null) s.imageHeight = s.height;
-
-  /* Compute the pixel values. */
-  if ((s.url == null) && this.binds.image) {
-
-    /* Cache the canvas element to reuse across renders. */
-    var canvas = this.$canvas || (this.$canvas = document.createElement("canvas")),
-        context = canvas.getContext("2d"),
-        w = s.imageWidth,
-        h = s.imageHeight,
-        stack = pv.Mark.stack,
-        data;
-
-    /* Evaluate the image function, storing into a CanvasPixelArray. */
-    canvas.width = w;
-    canvas.height = h;
-    data = (s.image = context.createImageData(w, h)).data;
-    stack.unshift(null, null);
-    for (var y = 0, p = 0; y < h; y++) {
-      stack[1] = y;
-      for (var x = 0; x < w; x++) {
-        stack[0] = x;
-        var color = this.binds.image.apply(this, stack);
-        data[p++] = color.r;
-        data[p++] = color.g;
-        data[p++] = color.b;
-        data[p++] = 255 * color.a;
-      }
-    }
-    stack.splice(0, 2);
-  }
-};

data/vendor/protovis/src/mark/Label.js

@@ -1,155 +0,0 @@
-/**
- * Constructs a new label mark with default properties. Labels are not typically
- * constructed directly, but by adding to a panel or an existing mark via
- * {@link pv.Mark#add}.
- *
- * @class Represents a text label, allowing textual annotation of other marks or
- * arbitrary text within the visualization. The character data must be plain
- * text (unicode), though the text can be styled using the {@link #font}
- * property. If rich text is needed, external HTML elements can be overlaid on
- * the canvas by hand.
- *
- * <p>Labels are positioned using the box model, similarly to {@link Dot}. Thus,
- * a label has no width or height, but merely a text anchor location. The text
- * is positioned relative to this anchor location based on the
- * {@link #textAlign}, {@link #textBaseline} and {@link #textMargin} properties.
- * Furthermore, the text may be rotated using {@link #textAngle}.
- *
- * <p>Labels ignore events, so as to not interfere with event handlers on
- * underlying marks, such as bars. In the future, we may support event handlers
- * on labels.
- *
- * <p>See also the <a href="../../api/Label.html">Label guide</a>.
- *
- * @extends pv.Mark
- */
-pv.Label = function() {
-  pv.Mark.call(this);
-};
-
-pv.Label.prototype = pv.extend(pv.Mark)
-    .property("text", String)
-    .property("font", String)
-    .property("textAngle", Number)
-    .property("textStyle", pv.color)
-    .property("textAlign", String)
-    .property("textBaseline", String)
-    .property("textMargin", Number)
-    .property("textDecoration", String)
-    .property("textShadow", String);
-
-pv.Label.prototype.type = "label";
-
-/**
- * The character data to render; a string. The default value of the text
- * property is the identity function, meaning the label's associated datum will
- * be rendered using its <tt>toString</tt>.
- *
- * @type string
- * @name pv.Label.prototype.text
- */
-
-/**
- * The font format, per the CSS Level 2 specification. The default font is "10px
- * sans-serif", for consistency with the HTML 5 canvas element specification.
- * Note that since text is not wrapped, any line-height property will be
- * ignored. The other font-style, font-variant, font-weight, font-size and
- * font-family properties are supported.
- *
- * @see <a href="http://www.w3.org/TR/CSS2/fonts.html#font-shorthand">CSS2 fonts</a>
- * @type string
- * @name pv.Label.prototype.font
- */
-
-/**
- * The rotation angle, in radians. Text is rotated clockwise relative to the
- * anchor location. For example, with the default left alignment, an angle of
- * Math.PI / 2 causes text to proceed downwards. The default angle is zero.
- *
- * @type number
- * @name pv.Label.prototype.textAngle
- */
-
-/**
- * The text color. The name "textStyle" is used for consistency with "fillStyle"
- * and "strokeStyle", although it might be better to rename this property (and
- * perhaps use the same name as "strokeStyle"). The default color is black.
- *
- * @type string
- * @name pv.Label.prototype.textStyle
- * @see pv.color
- */
-
-/**
- * The horizontal text alignment. One of:<ul>
- *
- * <li>left
- * <li>center
- * <li>right
- *
- * </ul>The default horizontal alignment is left.
- *
- * @type string
- * @name pv.Label.prototype.textAlign
- */
-
-/**
- * The vertical text alignment. One of:<ul>
- *
- * <li>top
- * <li>middle
- * <li>bottom
- *
- * </ul>The default vertical alignment is bottom.
- *
- * @type string
- * @name pv.Label.prototype.textBaseline
- */
-
-/**
- * The text margin; may be specified in pixels, or in font-dependent units (such
- * as ".1ex"). The margin can be used to pad text away from its anchor location,
- * in a direction dependent on the horizontal and vertical alignment
- * properties. For example, if the text is left- and middle-aligned, the margin
- * shifts the text to the right. The default margin is 3 pixels.
- *
- * @type number
- * @name pv.Label.prototype.textMargin
- */
-
-/**
- * A list of shadow effects to be applied to text, per the CSS Text Level 3
- * text-shadow property. An example specification is "0.1em 0.1em 0.1em
- * rgba(0,0,0,.5)"; the first length is the horizontal offset, the second the
- * vertical offset, and the third the blur radius.
- *
- * @see <a href="http://www.w3.org/TR/css3-text/#text-shadow">CSS3 text</a>
- * @type string
- * @name pv.Label.prototype.textShadow
- */
-
-/**
- * A list of decoration to be applied to text, per the CSS Text Level 3
- * text-decoration property. An example specification is "underline".
- *
- * @see <a href="http://www.w3.org/TR/css3-text/#text-decoration">CSS3 text</a>
- * @type string
- * @name pv.Label.prototype.textDecoration
- */
-
-/**
- * Default properties for labels. See the individual properties for the default
- * values.
- *
- * @type pv.Label
- */
-pv.Label.prototype.defaults = new pv.Label()
-    .extend(pv.Mark.prototype.defaults)
-    .events("none")
-    .text(pv.identity)
-    .font("10px sans-serif")
-    .textAngle(0)
-    .textStyle("black")
-    .textAlign("left")
-    .textBaseline("bottom")
-    .textMargin(3);