gfdnavi 1.3.0.0

data/public/javascripts/application.js

@@ -0,0 +1,29 @@
+// Place your application-specific JavaScript functions and classes here
+// This file is automatically included by javascript_include_tag :defaults
+
+function setCookie(name,value,expire){
+    if (value) {
+	document.cookie = name + '=' + escape(value) + ((expire==null)?'':('; expires='+expire.toGMTString()));
+    } else {
+	expire = new Date();
+        var year = expire.getYear();
+	year = year < 1900 ? year + 1900 : year;
+	expire.setYear(year - 1);
+	document.cookie = name + '=null; expires='+expire.toGMTString();
+    }
+}
+
+function getCookie(name){
+  var search = name + '=';
+  if (document.cookie.length>0) {
+    offset = document.cookie.indexOf(search);
+    if (offset != -1){
+      offset += search.length;
+      end     = document.cookie.indexOf(';',offset);
+      if(end == -1)
+        end = document.cookie.length;
+      return unescape(document.cookie.substring(offset,end));
+    }
+  }
+  return null;
+}

data/public/javascripts/directory_tree.js

@@ -0,0 +1,102 @@
+var tree;
+var Tree = Class.create();
+Tree.imagefile = new Array(gfdnaviUrlRoot+"/images/tree/plus.gif",
+			 gfdnaviUrlRoot+"/images/tree/minus.gif");
+Tree.prototype = {
+    initialize: function(divId) {
+	this.divId = divId;
+	this.showDirDetailsAjax = null;
+	var imagefile = Tree.imagefile;
+	this.image = new Array(imagefile.length);
+	for (var count = 0; count < (imagefile.length - 1); count++){
+		this.image[count] = new Image();
+		this.image[count].src = imagefile[count];
+	}
+    },
+
+    create: function(path) {
+	var param = {asynchronous: false,
+		     method: 'get',
+		     evalScripts: true};
+	if (path)
+	    param.parameters = 'path='+path;
+	new Ajax.Updater(this.divId,
+			 gfdnaviUrlRoot + '/finder/create_tree',
+			 param
+			 );
+    },
+
+    open: function(path) {
+	new Ajax.Request(gfdnaviUrlRoot + '/finder/open_tree',
+                         {asynchronous: true,
+			  evalScripts: true,
+			  parameters: 'path=' + path,
+			  method: 'post'});
+    },
+
+    selectedFunction: null,
+    previousSelectedPath: null,
+
+    dirSelected: function(path, notopen) {
+	if (!notopen)
+	    this.dirShow(path,true);
+	this.selectedFunction(path);
+	if (this.previousSelectedPath)
+	    Element.removeClassName('dir_name' + this.previousSelectedPath,'selected');
+	Element.addClassName('dir_name' + path, 'selected');
+	this.previousSelectedPath = path;
+    },
+
+    dirChange: function(path) {
+	var dir_id = 'dir'+path;
+	var img_id = 'dir_img'+path;
+	if( Element.visible(dir_id) ) {
+	    this.dirHide(path);
+	} else {
+	    this.dirShow(path);
+	}
+    },
+
+    dirShow: function(path, selected) {
+	var dir_id = 'dir'+path;
+	var img_id = 'dir_img'+path;
+	$(img_id).src = Tree.imagefile[1];
+	Element.show(dir_id);
+	this.sendStatus('opened', path, selected);
+    },
+
+    dirHide: function(path) {
+	var dir_id = 'dir'+path;
+	var img_id = 'dir_img'+path;
+	$(img_id).src = Tree.imagefile[0];
+	Element.hide(dir_id);
+	this.sendStatus('closed', path);
+    },
+
+    sendStatus: function(status, path, selected) {
+	param = status + '=' + path;
+	if (selected)
+	    param = param + '&selected=true';
+	new Ajax.Request(gfdnaviUrlRoot + '/finder/dir_status',
+                         {asynchronous: true,
+			  evalScripts: true,
+			  parameters: param,
+			  method: 'post'});
+    },
+
+
+    dirDetailsDivId: null,
+
+    showDirDetails: function(path) {
+	if (this.showDirDetailsAjax)
+	    this.showDirDetailsAjax.transport.abort();
+	param = { method: 'get'};
+	if (path)
+	    param.parameters = 'path='+path;
+	this.showDirDetailsAjax = new Ajax.Updater(this.dirDetailsDivId,
+				      gfdnaviUrlRoot + '/finder/show_details',
+				      param
+		                      );
+    }
+
+};

data/public/javascripts/draw_method.js

@@ -0,0 +1,83 @@
+var numInputs = 1;
+var numAttrs = 0;
+
+function changeVars() {
+  numInputs = $('draw_method_nvars').selectedIndex + 1;
+  var ary = new Array(numAttrs+numInputs);
+  for (i=0; i<numInputs; i++) {
+      if (i==0)
+	  ary[i] = 'gphys';
+      else
+	  ary[i] = 'gphys' + i;
+  }
+  ary[numInputs] = "opt";
+  Element.update('vizshot_args', ary.join(", "));
+  ary[numInputs] = "newfrm";
+  ary[numInputs+1] = "opt";
+  Element.update('ggraph_args', ary.join(", "));
+}
+
+var numAttrMax=0;
+function changeAttributes() {
+  numAttrs = $('attribute_num').selectedIndex;
+  changeVars();
+
+  for (i=0; i<[numAttrs,numAttrMax].min(); i++)
+      Element.show('attr_'+i);
+  for (i=numAttrs;i<numAttrMax; i++)
+      Element.hide('attr_'+i);
+
+  html = "";
+  for (i=numAttrMax; i<numAttrs; i++) {
+    html += "<div id='attr_" + i + "'>\n";
+    html += "<h4>attribute " + i +"</h4>\n";
+    html += "<table>\n";
+    html += "  <tr>\n";
+    html += "    <td>\n";
+    html += "      <label for='attribute_" + i + "_name'>name</label>\n";
+    html += "    </td>\n";
+    html += "    <td>\n";
+    html += "      <input type='text' name='attribute[" + i + "][name]' id='attribute_" + i + "_name'></input>\n";
+    html += "    </td>\n";
+    html += "  </tr>\n";
+    html += "  <tr>\n";
+    html += "    <td>\n";
+    html += "      <label for='attribute_" + i + "_default'>default</label>\n";
+    html += "    </td>\n";
+    html += "    <td>\n";
+    html += "      <input type='text' size='10' name='attribute[" + i + "][default]' id='attribute_" + i + "_default'/>\n";
+    html += "    </td>\n";
+    html += "  </tr>\n";
+    html += "  <tr>\n";
+    html += "    <td>\n";
+    html += "      <label for='attribute_" + i + "_value_type'>value type</label>\n";
+    html += "    </td>\n";
+    html += "    <td>\n";
+    html += "      <select id='attribute_" + i + "_value_type' name='attribute[" + i + "][value_type]'>\n";
+    html += "        <option selected>int</option>\n";
+    html += "        <option>float</option>\n";
+    html += "        <option>string</option>\n";
+    html += "        <option>boolean</option>\n";
+    html += "        <option>array_int</option>\n";
+    html += "        <option>array_float</option>\n";
+    html += "      </select>\n";
+    html += "    </td>\n";
+    html += "  </tr>\n";
+    html += "  <tr>\n";
+    html += "    <td>\n";
+    html += "      <label for='attribute_" + i + "_parser'>parser</label>\n";
+    html += "    </td>\n";
+    html += "    <td>\n";
+    html += "      <select id='attribute_" + i + "_parser' name='attribute[" + i + "][parser]'>\n";
+    html += "        <option selected>vizshot</option>\n";
+    html += "        <option>ggraph</option>\n";
+    html += "      </select>\n";
+    html += "    </td>\n";
+    html += "  </tr>\n";
+    html += "</table>\n";
+    html += "</div>\n";
+    numAttrMax = i+1;
+  }
+  new Insertion.Bottom('attributes_table', html);
+}
+

data/public/javascripts/excanvas.js

@@ -0,0 +1,704 @@
+// Copyright 2006 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// TODO: Patterns
+// TODO: Radial gradient
+// TODO: Clipping paths
+// TODO: Coordsize
+// TODO: Painting mode
+// TODO: Optimize
+// TODO: canvas width/height sets content size in moz, border size in ie
+// TODO: Painting outside the canvas should not be allowed
+
+// only add this code if we do not already have a canvas implementation
+if (!window.CanvasRenderingContext2D) {
+
+(function () {
+
+  var G_vmlCanvasManager_ = {
+    init: function (opt_doc) {
+      var doc = opt_doc || document;
+      if (/MSIE/.test(navigator.userAgent) && !window.opera) {
+        var self = this;
+        doc.attachEvent("onreadystatechange", function () {
+          self.init_(doc);
+        });
+      }
+    },
+
+    init_: function (doc, e) {
+      if (doc.readyState == "complete") {
+        // create xmlns
+        if (!doc.namespaces["g_vml_"]) {
+          doc.namespaces.add("g_vml_", "urn:schemas-microsoft-com:vml");
+        }
+
+        // setup default css
+        var ss = doc.createStyleSheet();
+        ss.cssText = "canvas{display:inline-block;overflow:hidden;" +
+            "text-align:left;}" +
+            "canvas *{behavior:url(#default#VML)}";
+
+        // find all canvas elements
+        var els = doc.getElementsByTagName("canvas");
+        for (var i = 0; i < els.length; i++) {
+          if (!els[i].getContext) {
+            this.initElement(els[i]);
+          }
+        }
+      }
+    },
+
+    fixElement_: function (el) {
+      // in IE before version 5.5 we would need to add HTML: to the tag name
+      // but we do not care about IE before version 6
+      var outerHTML = el.outerHTML;
+      var newEl = document.createElement(outerHTML);
+      // if the tag is still open IE has created the children as siblings and
+      // it has also created a tag with the name "/FOO"
+      if (outerHTML.slice(-2) != "/>") {
+        var tagName = "/" + el.tagName;
+        var ns;
+        // remove content
+        while ((ns = el.nextSibling) && ns.tagName != tagName) {
+          ns.removeNode();
+        }
+        // remove the incorrect closing tag
+        if (ns) {
+          ns.removeNode();
+        }
+      }
+      el.parentNode.replaceChild(newEl, el);
+      return newEl;
+    },
+
+    /**
+     * Public initializes a canvas element so that it can be used as canvas
+     * element from now on. This is called automatically before the page is
+     * loaded but if you are creating elements using createElement yuo need to
+     * make sure this is called on the element.
+     * @param el {HTMLElement} The canvas element to initialize.
+     */
+    initElement: function (el) {
+      el = this.fixElement_(el);
+      el.getContext = function () {
+        if (this.context_) {
+          return this.context_;
+        }
+        return this.context_ = new CanvasRenderingContext2D_(this);
+      };
+
+      var self = this; //bind
+      el.attachEvent("onpropertychange", function (e) {
+        // we need to watch changes to width and height
+        switch (e.propertyName) {
+          case "width":
+          case "height":
+            // coord size changed?
+            break;
+        }
+      });
+
+      // if style.height is set
+
+      var attrs = el.attributes;
+      if (attrs.width && attrs.width.specified) {
+        // TODO: use runtimeStyle and coordsize
+        // el.getContext().setWidth_(attrs.width.nodeValue);
+        el.style.width = attrs.width.nodeValue + "px";
+      }
+      if (attrs.height && attrs.height.specified) {
+        // TODO: use runtimeStyle and coordsize
+        // el.getContext().setHeight_(attrs.height.nodeValue);
+        el.style.height = attrs.height.nodeValue + "px";
+      }
+      //el.getContext().setCoordsize_()
+    }
+  };
+
+  G_vmlCanvasManager_.init();
+
+  // precompute "00" to "FF"
+  var dec2hex = [];
+  for (var i = 0; i < 16; i++) {
+    for (var j = 0; j < 16; j++) {
+      dec2hex[i * 16 + j] = i.toString(16) + j.toString(16);
+    }
+  }
+
+  function createMatrixIdentity() {
+    return [
+      [1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1]
+    ];
+  }
+
+  function matrixMultiply(m1, m2) {
+    var result = createMatrixIdentity();
+
+    for (var x = 0; x < 3; x++) {
+      for (var y = 0; y < 3; y++) {
+        var sum = 0;
+
+        for (var z = 0; z < 3; z++) {
+          sum += m1[x][z] * m2[z][y];
+        }
+
+        result[x][y] = sum;
+      }
+    }
+    return result;
+  }
+
+  function copyState(o1, o2) {
+    o2.fillStyle     = o1.fillStyle;
+    o2.lineCap       = o1.lineCap;
+    o2.lineJoin      = o1.lineJoin;
+    o2.lineWidth     = o1.lineWidth;
+    o2.miterLimit    = o1.miterLimit;
+    o2.shadowBlur    = o1.shadowBlur;
+    o2.shadowColor   = o1.shadowColor;
+    o2.shadowOffsetX = o1.shadowOffsetX;
+    o2.shadowOffsetY = o1.shadowOffsetY;
+    o2.strokeStyle   = o1.strokeStyle;
+  }
+
+  function processStyle(styleString) {
+    var str, alpha = 1;
+
+    styleString = String(styleString);
+    if (styleString.substring(0, 3) == "rgb") {
+      var start = styleString.indexOf("(", 3);
+      var end = styleString.indexOf(")", start + 1);
+      var guts = styleString.substring(start + 1, end).split(",");
+
+      str = "#";
+      for (var i = 0; i < 3; i++) {
+        str += dec2hex[parseInt(guts[i])];
+      }
+
+      if ((guts.length == 4) && (styleString.substr(3, 1) == "a")) {
+        alpha = guts[3];
+      }
+    } else {
+      str = styleString;
+    }
+
+    return [str, alpha];
+  }
+
+  function processLineCap(lineCap) {
+    switch (lineCap) {
+      case "butt":
+        return "flat";
+      case "round":
+        return "round";
+      case "square":
+      default:
+        return "square";
+    }
+  }
+
+  /**
+   * This class implements CanvasRenderingContext2D interface as described by
+   * the WHATWG.
+   * @param surfaceElement {HTMLElement} The element that the 2D context should
+   * be associated with
+   */
+   function CanvasRenderingContext2D_(surfaceElement) {
+    this.m_ = createMatrixIdentity();
+    this.element_ = surfaceElement;
+
+    this.mStack_ = [];
+    this.aStack_ = [];
+    this.currentPath_ = [];
+
+    // Canvas context properties
+    this.strokeStyle = "#000";
+    this.fillStyle = "#ccc";
+
+    this.lineWidth = 1;
+    this.lineJoin = "miter";
+    this.lineCap = "butt";
+    this.miterLimit = 10;
+    this.globalAlpha = 1;
+  };
+
+  var contextPrototype = CanvasRenderingContext2D_.prototype;
+  contextPrototype.clearRect = function() {
+    this.element_.innerHTML = "";
+    this.currentPath_ = [];
+  };
+
+  contextPrototype.beginPath = function() {
+    // TODO: Branch current matrix so that save/restore has no effect
+    //       as per safari docs.
+
+    this.currentPath_ = [];
+  };
+
+  contextPrototype.moveTo = function(aX, aY) {
+    this.currentPath_.push({type: "moveTo", x: aX, y: aY});
+  };
+
+  contextPrototype.lineTo = function(aX, aY) {
+    this.currentPath_.push({type: "lineTo", x: aX, y: aY});
+  };
+
+  contextPrototype.bezierCurveTo = function(aCP1x, aCP1y,
+                                            aCP2x, aCP2y,
+                                            aX, aY) {
+    this.currentPath_.push({type: "bezierCurveTo",
+                           cp1x: aCP1x,
+                           cp1y: aCP1y,
+                           cp2x: aCP2x,
+                           cp2y: aCP2y,
+                           x: aX,
+                           y: aY});
+  };
+
+  contextPrototype.quadraticCurveTo = function(aCPx, aCPy, aX, aY) {
+    // VML's qb produces different output to Firefox's
+    // FF's behaviour seems to have changed in 1.5.0.1, check this
+    this.bezierCurveTo(aCPx, aCPy, aCPx, aCPy, aX, aY);
+  };
+
+  contextPrototype.arc = function(aX, aY, aRadius,
+                                  aStartAngle, aEndAngle, aClockwise) {
+    if (!aClockwise) {
+      var t = aStartAngle;
+      aStartAngle = aEndAngle;
+      aEndAngle = t;
+    }
+
+    var xStart = aX + (Math.cos(aStartAngle) * aRadius);
+    var yStart = aY + (Math.sin(aStartAngle) * aRadius);
+
+    var xEnd = aX + (Math.cos(aEndAngle) * aRadius);
+    var yEnd = aY + (Math.sin(aEndAngle) * aRadius);
+
+    this.currentPath_.push({type: "arc",
+                           x: aX,
+                           y: aY,
+                           radius: aRadius,
+                           xStart: xStart,
+                           yStart: yStart,
+                           xEnd: xEnd,
+                           yEnd: yEnd});
+
+  };
+
+  contextPrototype.rect = function(aX, aY, aWidth, aHeight) {
+    this.moveTo(aX, aY);
+    this.lineTo(aX + aWidth, aY);
+    this.lineTo(aX + aWidth, aY + aHeight);
+    this.lineTo(aX, aY + aHeight);
+    this.closePath();
+  };
+
+  contextPrototype.strokeRect = function(aX, aY, aWidth, aHeight) {
+    // Will destroy any existing path (same as FF behaviour)
+    this.beginPath();
+    this.moveTo(aX, aY);
+    this.lineTo(aX + aWidth, aY);
+    this.lineTo(aX + aWidth, aY + aHeight);
+    this.lineTo(aX, aY + aHeight);
+    this.closePath();
+    this.stroke();
+  };
+
+  contextPrototype.fillRect = function(aX, aY, aWidth, aHeight) {
+    // Will destroy any existing path (same as FF behaviour)
+    this.beginPath();
+    this.moveTo(aX, aY);
+    this.lineTo(aX + aWidth, aY);
+    this.lineTo(aX + aWidth, aY + aHeight);
+    this.lineTo(aX, aY + aHeight);
+    this.closePath();
+    this.fill();
+  };
+
+  contextPrototype.createLinearGradient = function(aX0, aY0, aX1, aY1) {
+    var gradient = new CanvasGradient_("gradient");
+    return gradient;
+  };
+
+  contextPrototype.createRadialGradient = function(aX0, aY0,
+                                                   aR0, aX1,
+                                                   aY1, aR1) {
+    var gradient = new CanvasGradient_("gradientradial");
+    gradient.radius1_ = aR0;
+    gradient.radius2_ = aR1;
+    gradient.focus_.x = aX0;
+    gradient.focus_.y = aY0;
+    return gradient;
+  };
+
+  contextPrototype.drawImage = function (image, var_args) {
+    var dx, dy, dw, dh, sx, sy, sw, sh;
+    var w = image.width;
+    var h = image.height;
+
+    if (arguments.length == 3) {
+      dx = arguments[1];
+      dy = arguments[2];
+      sx = sy = 0;
+      sw = dw = w;
+      sh = dh = h;
+    } else if (arguments.length == 5) {
+      dx = arguments[1];
+      dy = arguments[2];
+      dw = arguments[3];
+      dh = arguments[4];
+      sx = sy = 0;
+      sw = w;
+      sh = h;
+    } else if (arguments.length == 9) {
+      sx = arguments[1];
+      sy = arguments[2];
+      sw = arguments[3];
+      sh = arguments[4];
+      dx = arguments[5];
+      dy = arguments[6];
+      dw = arguments[7];
+      dh = arguments[8];
+    } else {
+      throw "Invalid number of arguments";
+    }
+
+    var d = this.getCoords_(dx, dy);
+
+    var w2 = (sw / 2);
+    var h2 = (sh / 2);
+
+    var vmlStr = [];
+
+    // For some reason that I've now forgotten, using divs didn't work
+    vmlStr.push(' <g_vml_:group',
+                ' coordsize="100,100"',
+                ' coordorigin="0, 0"' ,
+                ' style="width:100px;height:100px;position:absolute;');
+
+    // If filters are necessary (rotation exists), create them
+    // filters are bog-slow, so only create them if abbsolutely necessary
+    // The following check doesn't account for skews (which don't exist
+    // in the canvas spec (yet) anyway.
+
+    if (this.m_[0][0] != 1 || this.m_[0][1]) {
+      var filter = [];
+
+      // Note the 12/21 reversal
+      filter.push("M11='", this.m_[0][0], "',",
+                  "M12='", this.m_[1][0], "',",
+                  "M21='", this.m_[0][1], "',",
+                  "M22='", this.m_[1][1], "',",
+                  "Dx='", d.x, "',",
+                  "Dy='", d.y, "'");
+
+      // Bounding box calculation (need to minimize displayed area so that
+      // filters don't waste time on unused pixels.
+      var max = d;
+      var c2 = this.getCoords_(dx+dw, dy);
+      var c3 = this.getCoords_(dx, dy+dh);
+      var c4 = this.getCoords_(dx+dw, dy+dh);
+
+      max.x = Math.max(max.x, c2.x, c3.x, c4.x);
+      max.y = Math.max(max.y, c2.y, c3.y, c4.y);
+
+      vmlStr.push(" padding:0 ", Math.floor(max.x), "px ", Math.floor(max.y),
+                  "px 0;filter:progid:DXImageTransform.Microsoft.Matrix(",
+                  filter.join(""), ", sizingmethod='clip');")
+    } else {
+      vmlStr.push(" top:", d.y, "px;left:", d.x, "px;")
+    }
+
+    vmlStr.push(' ">' ,
+                '<g_vml_:image src="', image.src, '"',
+                ' style="width:', dw, ';',
+                ' height:', dh, ';"',
+                ' cropleft="', sx / w, '"',
+                ' croptop="', sy / h, '"',
+                ' cropright="', (w - sx - sw) / w, '"',
+                ' cropbottom="', (h - sy - sh) / h, '"',
+                ' />',
+                '</g_vml_:group>');
+
+    this.element_.insertAdjacentHTML("BeforeEnd",
+                                    vmlStr.join(""));
+  };
+
+  contextPrototype.stroke = function(aFill) {
+    var lineStr = [];
+    var lineOpen = false;
+    var a = processStyle(aFill ? this.fillStyle : this.strokeStyle);
+    var color = a[0];
+    var opacity = a[1] * this.globalAlpha;
+
+    lineStr.push('<g_vml_:shape',
+                 ' fillcolor="', color, '"',
+                 ' filled="', Boolean(aFill), '"',
+                 ' style="position:absolute;width:10;height:10;"',
+                 ' coordorigin="0 0" coordsize="10 10"',
+                 ' stroked="', !aFill, '"',
+                 ' strokeweight="', this.lineWidth, '"',
+                 ' strokecolor="', color, '"',
+                 ' path="');
+
+    var newSeq = false;
+    var min = {x: null, y: null};
+    var max = {x: null, y: null};
+
+    for (var i = 0; i < this.currentPath_.length; i++) {
+      var p = this.currentPath_[i];
+
+      if (p.type == "moveTo") {
+        lineStr.push(" m ");
+        var c = this.getCoords_(p.x, p.y);
+        lineStr.push(Math.floor(c.x), ",", Math.floor(c.y));
+      } else if (p.type == "lineTo") {
+        lineStr.push(" l ");
+        var c = this.getCoords_(p.x, p.y);
+        lineStr.push(Math.floor(c.x), ",", Math.floor(c.y));
+      } else if (p.type == "close") {
+        lineStr.push(" x ");
+      } else if (p.type == "bezierCurveTo") {
+        lineStr.push(" c ");
+        var c = this.getCoords_(p.x, p.y);
+        var c1 = this.getCoords_(p.cp1x, p.cp1y);
+        var c2 = this.getCoords_(p.cp2x, p.cp2y);
+        lineStr.push(Math.floor(c1.x), ",", Math.floor(c1.y), ",",
+                     Math.floor(c2.x), ",", Math.floor(c2.y), ",",
+                     Math.floor(c.x), ",", Math.floor(c.y));
+      } else if (p.type == "arc") {
+        lineStr.push(" ar ");
+        var c  = this.getCoords_(p.x, p.y);
+        var cStart = this.getCoords_(p.xStart, p.yStart);
+        var cEnd = this.getCoords_(p.xEnd, p.yEnd);
+
+        // TODO: FIX (matricies (scale+rotation) now buggered this up)
+        //       VML arc also doesn't seem able to do rotated non-circular
+        //       arcs without parent grouping.
+        var absXScale = this.m_[0][0];
+        var absYScale = this.m_[1][1];
+
+        lineStr.push(Math.floor(c.x - absXScale * p.radius), ",",
+                     Math.floor(c.y - absYScale * p.radius), " ",
+                     Math.floor(c.x + absXScale * p.radius), ",",
+                     Math.floor(c.y + absYScale * p.radius), " ",
+                     Math.floor(cStart.x), ",", Math.floor(cStart.y), " ",
+                     Math.floor(cEnd.x), ",", Math.floor(cEnd.y));
+      }
+
+
+      // TODO: Following is broken for curves due to
+      //       move to proper paths.
+
+      // Figure out dimensions so we can do gradient fills
+      // properly
+      if(c) {
+        if (min.x == null || c.x < min.x) {
+          min.x = c.x;
+        }
+        if (max.x == null || c.x > max.x) {
+          max.x = c.x;
+        }
+        if (min.y == null || c.y < min.y) {
+          min.y = c.y;
+        }
+        if (max.y == null || c.y > max.y) {
+          max.y = c.y;
+        }
+      }
+    }
+    lineStr.push(' ">');
+
+    if (typeof this.fillStyle == "object") {
+      var focus = {x: "50%", y: "50%"};
+      var width = (max.x - min.x);
+      var height = (max.y - min.y);
+      var dimension = (width > height) ? width : height;
+
+      focus.x = Math.floor((this.fillStyle.focus_.x / width) * 100 + 50) + "%";
+      focus.y = Math.floor((this.fillStyle.focus_.y / height) * 100 + 50) + "%";
+
+      var colors = [];
+
+      // inside radius (%)
+      if (this.fillStyle.type_ == "gradientradial") {
+        var inside = (this.fillStyle.radius1_ / dimension * 100);
+
+        // percentage that outside radius exceeds inside radius
+        var expansion = (this.fillStyle.radius2_ / dimension * 100) - inside;
+      } else {
+        var inside = 0;
+        var expansion = 100;
+      }
+
+      var insidecolor = {offset: null, color: null};
+      var outsidecolor = {offset: null, color: null};
+
+      // We need to sort 'colors' by percentage, from 0 > 100 otherwise ie
+      // won't interpret it correctly
+      this.fillStyle.colors_.sort(function (cs1, cs2) {
+        return cs1.offset - cs2.offset;
+      });
+
+      for (var i = 0; i < this.fillStyle.colors_.length; i++) {
+        var fs = this.fillStyle.colors_[i];
+
+        colors.push( (fs.offset * expansion) + inside, "% ", fs.color, ",");
+
+        if (fs.offset > insidecolor.offset || insidecolor.offset == null) {
+          insidecolor.offset = fs.offset;
+          insidecolor.color = fs.color;
+        }
+
+        if (fs.offset < outsidecolor.offset || outsidecolor.offset == null) {
+          outsidecolor.offset = fs.offset;
+          outsidecolor.color = fs.color;
+        }
+      }
+      colors.pop();
+
+      lineStr.push('<g_vml_:fill',
+                   ' color="', outsidecolor.color, '"',
+                   ' color2="', insidecolor.color, '"',
+                   ' type="', this.fillStyle.type_, '"',
+                   ' focusposition="', focus.x, ', ', focus.y, '"',
+                   ' colors="', colors.join(""), '"',
+                   ' opacity="', opacity, '" />');
+    } else if (aFill) {
+      lineStr.push('<g_vml_:fill color="', color, '" opacity="', opacity, '" />');
+    } else {
+      lineStr.push(
+        '<g_vml_:stroke',
+        ' opacity="', opacity,'"',
+        ' joinstyle="', this.lineJoin, '"',
+        ' miterlimit="', this.miterLimit, '"',
+        ' endcap="', processLineCap(this.lineCap) ,'"',
+        ' weight="', this.lineWidth, 'px"',
+        ' color="', color,'" />'
+      );
+    }
+
+    lineStr.push("</g_vml_:shape>");
+
+    this.element_.insertAdjacentHTML("beforeEnd", lineStr.join(""));
+
+    this.currentPath_ = [];
+  };
+
+  contextPrototype.fill = function() {
+    this.stroke(true);
+  }
+
+  contextPrototype.closePath = function() {
+    this.currentPath_.push({type: "close"});
+  };
+
+  /**
+   * @private
+   */
+  contextPrototype.getCoords_ = function(aX, aY) {
+    return {
+      x: (aX * this.m_[0][0] + aY * this.m_[1][0] + this.m_[2][0]),
+      y: (aX * this.m_[0][1] + aY * this.m_[1][1] + this.m_[2][1])
+    }
+  };
+
+  contextPrototype.save = function() {
+    var o = {};
+    copyState(this, o);
+    this.aStack_.push(o);
+    this.mStack_.push(this.m_);
+    this.m_ = matrixMultiply(createMatrixIdentity(), this.m_);
+  };
+
+  contextPrototype.restore = function() {
+    copyState(this.aStack_.pop(), this);
+    this.m_ = this.mStack_.pop();
+  };
+
+  contextPrototype.translate = function(aX, aY) {
+    var m1 = [
+      [1,  0,  0],
+      [0,  1,  0],
+      [aX, aY, 1]
+    ];
+
+    this.m_ = matrixMultiply(m1, this.m_);
+  };
+
+  contextPrototype.rotate = function(aRot) {
+    var c = Math.cos(aRot);
+    var s = Math.sin(aRot);
+
+    var m1 = [
+      [c,  s, 0],
+      [-s, c, 0],
+      [0,  0, 1]
+    ];
+
+    this.m_ = matrixMultiply(m1, this.m_);
+  };
+
+  contextPrototype.scale = function(aX, aY) {
+    var m1 = [
+      [aX, 0,  0],
+      [0,  aY, 0],
+      [0,  0,  1]
+    ];
+
+    this.m_ = matrixMultiply(m1, this.m_);
+  };
+
+  /******** STUBS ********/
+  contextPrototype.clip = function() {
+    // TODO: Implement
+  };
+
+  contextPrototype.arcTo = function() {
+    // TODO: Implement
+  };
+
+  contextPrototype.createPattern = function() {
+    return new CanvasPattern_;
+  };
+
+  // Gradient / Pattern Stubs
+  function CanvasGradient_(aType) {
+    this.type_ = aType;
+    this.radius1_ = 0;
+    this.radius2_ = 0;
+    this.colors_ = [];
+    this.focus_ = {x: 0, y: 0};
+  }
+
+  CanvasGradient_.prototype.addColorStop = function(aOffset, aColor) {
+    aColor = processStyle(aColor);
+    this.colors_.push({offset: 1-aOffset, color: aColor});
+  };
+
+  function CanvasPattern_() {}
+
+  // set up externs
+  G_vmlCanvasManager = G_vmlCanvasManager_;
+  CanvasRenderingContext2D = CanvasRenderingContext2D_;
+  CanvasGradient = CanvasGradient_;
+  CanvasPattern = CanvasPattern_;
+
+})();
+
+} // if