Inclusão da biblioteca tableexport

Edmar Moretti
1 parent 5ba7e71a
Showing 12 changed files with 4260 additions and 0 deletions Show diff stats
pacotes/tableexport/.gitignore
pacotes/tableexport/.gitmodules
pacotes/tableexport/.jshintrc
pacotes/tableexport/.travis.yml
pacotes/tableexport/README.md
pacotes/tableexport/html2canvas.js
pacotes/tableexport/jquery.base64.js
pacotes/tableexport/jspdf/jspdf.js
pacotes/tableexport/jspdf/libs/base64.js
pacotes/tableexport/jspdf/libs/sprintf.js
pacotes/tableexport/tableExport.jquery.json
pacotes/tableexport/tableExport.js
@@ -0,0 +1,11 @@
+/nbproject/
+image.jpg
+/.project
+/.settings/
+node_modules/
+.envrc
+*.sublime-workspace
+*.baseline
+*.iml
+.idea/
+.DS_Store
@@ -0,0 +1,3 @@
+[submodule "src/fabric"]
+	path = src/fabric
+	url = https://github.com/kangax/fabric.js.git
@@ -0,0 +1,19 @@
+{
+    "curly": true,
+    "eqeqeq": true,
+    "immed": true,
+    "latedef": false,
+    "newcap": true,
+    "noarg": true,
+    "sub": true,
+    "undef": true,
+    "boss": true,
+    "eqnull": true,
+    "browser": true,
+    "node": true,
+    "indent": 4,
+    "globals": {
+      "jQuery": true
+    },
+    "predef": ["-Promise"]
+}
@@ -0,0 +1,21 @@
+---
+language: node_js
+node_js:
+- '0.10'
+env:
+  global:
+  - secure: "eW41gIqOizwO4pTgWnAAbW75AP7F+CK9qfSed/fSh4sJ9HWMIY1YRIaY8gjr+6jV/f7XVHcXuym6ZxgINYSkVKbF1JKxBJNLOXtSgNbVHSic58pYFvUjwxIBI9aPig9uux1+DbnpWqXFDTcACJSevQZE0xwmjdrSkDLgB0G34v8="
+  - secure: "Y2Av+Gd3z9uQEB36GwdOOuGka0hx0/HeitASEo59z934O8RxnmN9eNTXS7dDT3XtKtwxIyLTOEpS7qlRdWahH28hr/dS4xJj6ao58C+1xMcDs6NAPGmDxUlcJWpcGEsnjmXjQCc3fBioSTdpIBrK/gdvgpNh77UKG74Sk7Z+YGk="
+  - secure: "YI+YbTOGf2x4fPMKW+KhJiZWswoXT6xOKGwLfsQsVwmFX1LerJouil5D5iYOQuL4FE3pNaoJSNakIsokJQuGKJMmnPc8rdhMZuBJBk6MRghurE2Xe9qBHfuUBPlfD61nARESm4WDcyMwM0QVYaOKeY6aIpZ91qbUbyc60EEx3C4="
+addons:
+  sauce_connect: true
+before_script:
+  - npm install -g grunt-cli
+  - npm install -g uglify-js
+notifications:
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/2b007d4f86de89588804
+    on_success: always
+    on_failure: always
+    on_start: false
@@ -0,0 +1,48 @@
+tableExport.jquery.plugin
+=========================
+
+<h3>Export HTML Table to</h3>
+<ul>
+<li> JSON
+<li> XML
+<li> PNG
+<li> CSV
+<li> TXT
+<li> SQL
+<li> MS-Word
+<li> Ms-Excel
+<li> Ms-Powerpoint
+<li> PDF
+</ul>
+
+Installation
+============
+jquery Plugin<BR>
+&lt;script type="text/javascript" src="tableExport.js"><BR>
+&lt;script type="text/javascript" src="jquery.base64.js"><BR>
+<BR>
+PNG Export
+==========
+&lt;script type="text/javascript" src="html2canvas.js">
+
+PDF Export
+==========
+&lt;script type="text/javascript" src="jspdf/libs/sprintf.js"><BR>
+&lt;script type="text/javascript" src="jspdf/jspdf.js"><BR>
+&lt;script type="text/javascript" src="jspdf/libs/base64.js"><BR>
+
+Usage
+======
+onClick ="$('#tableID').tableExport({type:'pdf',escape:'false'});"<BR>
+
+Options
+=======
+separator: ','<BR>
+ignoreColumn: [2,3],<BR>
+tableName:'yourTableName'<BR>
+type:'csv'<BR>
+pdfFontSize:14<BR>
+pdfLeftMargin:20<BR>
+escape:'true'<BR>
+htmlContent:'false'<BR>
+consoleLog:'false' <BR>
@@ -0,0 +1,3010 @@
+/*
+  html2canvas 0.4.1 <http://html2canvas.hertzen.com>
+  Copyright (c) 2013 Niklas von Hertzen
+
+  Released under MIT License
+*/
+
+(function(window, document, undefined){
+
+//"use strict";
+
+var _html2canvas = {},
+previousElement,
+computedCSS,
+html2canvas;
+
+_html2canvas.Util = {};
+
+_html2canvas.Util.log = function(a) {
+  if (_html2canvas.logging && window.console && window.console.log) {
+    window.console.log(a);
+  }
+};
+
+_html2canvas.Util.trimText = (function(isNative){
+  return function(input) {
+    return isNative ? isNative.apply(input) : ((input || '') + '').replace( /^\s+|\s+$/g , '' );
+  };
+})(String.prototype.trim);
+
+_html2canvas.Util.asFloat = function(v) {
+  return parseFloat(v);
+};
+
+(function() {
+  // TODO: support all possible length values
+  var TEXT_SHADOW_PROPERTY = /((rgba|rgb)\([^\)]+\)(\s-?\d+px){0,})/g;
+  var TEXT_SHADOW_VALUES = /(-?\d+px)|(#.+)|(rgb\(.+\))|(rgba\(.+\))/g;
+  _html2canvas.Util.parseTextShadows = function (value) {
+    if (!value || value === 'none') {
+      return [];
+    }
+
+    // find multiple shadow declarations
+    var shadows = value.match(TEXT_SHADOW_PROPERTY),
+      results = [];
+    for (var i = 0; shadows && (i < shadows.length); i++) {
+      var s = shadows[i].match(TEXT_SHADOW_VALUES);
+      results.push({
+        color: s[0],
+        offsetX: s[1] ? s[1].replace('px', '') : 0,
+        offsetY: s[2] ? s[2].replace('px', '') : 0,
+        blur: s[3] ? s[3].replace('px', '') : 0
+      });
+    }
+    return results;
+  };
+})();
+
+_html2canvas.Util.parseBackgroundImage = function (value) {
+    var whitespace = ' \r\n\t',
+        method, definition, prefix, prefix_i, block, results = [],
+        c, mode = 0, numParen = 0, quote, args;
+
+    var appendResult = function(){
+        if(method) {
+            if(definition.substr( 0, 1 ) === '"') {
+                definition = definition.substr( 1, definition.length - 2 );
+            }
+            if(definition) {
+                args.push(definition);
+            }
+            if(method.substr( 0, 1 ) === '-' &&
+                    (prefix_i = method.indexOf( '-', 1 ) + 1) > 0) {
+                prefix = method.substr( 0, prefix_i);
+                method = method.substr( prefix_i );
+            }
+            results.push({
+                prefix: prefix,
+                method: method.toLowerCase(),
+                value: block,
+                args: args
+            });
+        }
+        args = []; //for some odd reason, setting .length = 0 didn't work in safari
+        method =
+            prefix =
+            definition =
+            block = '';
+    };
+
+    appendResult();
+    for(var i = 0, ii = value.length; i<ii; i++) {
+        c = value[i];
+        if(mode === 0 && whitespace.indexOf( c ) > -1){
+            continue;
+        }
+        switch(c) {
+            case '"':
+                if(!quote) {
+                    quote = c;
+                }
+                else if(quote === c) {
+                    quote = null;
+                }
+                break;
+
+            case '(':
+                if(quote) { break; }
+                else if(mode === 0) {
+                    mode = 1;
+                    block += c;
+                    continue;
+                } else {
+                    numParen++;
+                }
+                break;
+
+            case ')':
+                if(quote) { break; }
+                else if(mode === 1) {
+                    if(numParen === 0) {
+                        mode = 0;
+                        block += c;
+                        appendResult();
+                        continue;
+                    } else {
+                        numParen--;
+                    }
+                }
+                break;
+
+            case ',':
+                if(quote) { break; }
+                else if(mode === 0) {
+                    appendResult();
+                    continue;
+                }
+                else if (mode === 1) {
+                    if(numParen === 0 && !method.match(/^url$/i)) {
+                        args.push(definition);
+                        definition = '';
+                        block += c;
+                        continue;
+                    }
+                }
+                break;
+        }
+
+        block += c;
+        if(mode === 0) { method += c; }
+        else { definition += c; }
+    }
+    appendResult();
+
+    return results;
+};
+
+_html2canvas.Util.Bounds = function (element) {
+  var clientRect, bounds = {};
+
+  if (element.getBoundingClientRect){
+    clientRect = element.getBoundingClientRect();
+
+    // TODO add scroll position to bounds, so no scrolling of window necessary
+    bounds.top = clientRect.top;
+    bounds.bottom = clientRect.bottom || (clientRect.top + clientRect.height);
+    bounds.left = clientRect.left;
+
+    bounds.width = element.offsetWidth;
+    bounds.height = element.offsetHeight;
+  }
+
+  return bounds;
+};
+
+// TODO ideally, we'd want everything to go through this function instead of Util.Bounds,
+// but would require further work to calculate the correct positions for elements with offsetParents
+_html2canvas.Util.OffsetBounds = function (element) {
+  var parent = element.offsetParent ? _html2canvas.Util.OffsetBounds(element.offsetParent) : {top: 0, left: 0};
+
+  return {
+    top: element.offsetTop + parent.top,
+    bottom: element.offsetTop + element.offsetHeight + parent.top,
+    left: element.offsetLeft + parent.left,
+    width: element.offsetWidth,
+    height: element.offsetHeight
+  };
+};
+
+function toPX(element, attribute, value ) {
+    var rsLeft = element.runtimeStyle && element.runtimeStyle[attribute],
+        left,
+        style = element.style;
+
+    // Check if we are not dealing with pixels, (Opera has issues with this)
+    // Ported from jQuery css.js
+    // From the awesome hack by Dean Edwards
+    // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
+
+    // If we're not dealing with a regular pixel number
+    // but a number that has a weird ending, we need to convert it to pixels
+
+    if ( !/^-?[0-9]+\.?[0-9]*(?:px)?$/i.test( value ) && /^-?\d/.test(value) ) {
+        // Remember the original values
+        left = style.left;
+
+        // Put in the new values to get a computed value out
+        if (rsLeft) {
+            element.runtimeStyle.left = element.currentStyle.left;
+        }
+        style.left = attribute === "fontSize" ? "1em" : (value || 0);
+        value = style.pixelLeft + "px";
+
+        // Revert the changed values
+        style.left = left;
+        if (rsLeft) {
+            element.runtimeStyle.left = rsLeft;
+        }
+    }
+
+    if (!/^(thin|medium|thick)$/i.test(value)) {
+        return Math.round(parseFloat(value)) + "px";
+    }
+
+    return value;
+}
+
+function asInt(val) {
+    return parseInt(val, 10);
+}
+
+function isPercentage(value) {
+  return value.toString().indexOf("%") !== -1;
+}
+
+function parseBackgroundSizePosition(value, element, attribute, index) {
+    value = (value || '').split(',');
+    value = value[index || 0] || value[0] || 'auto';
+    value = _html2canvas.Util.trimText(value).split(' ');
+    if(attribute === 'backgroundSize' && (value[0] && value[0].match(/^(cover|contain|auto)$/))) {
+        return value;
+    } else {
+        value[0] = (value[0].indexOf( "%" ) === -1) ? toPX(element, attribute + "X", value[0]) : value[0];
+        if(value[1] === undefined) {
+            if(attribute === 'backgroundSize') {
+                value[1] = 'auto';
+                return value;
+            } else {
+                // IE 9 doesn't return double digit always
+                value[1] = value[0];
+            }
+        }
+        value[1] = (value[1].indexOf("%") === -1) ? toPX(element, attribute + "Y", value[1]) : value[1];
+    }
+    return value;
+}
+
+_html2canvas.Util.getCSS = function (element, attribute, index) {
+    if (previousElement !== element) {
+      computedCSS = document.defaultView.getComputedStyle(element, null);
+    }
+
+    var value = computedCSS[attribute];
+
+    if (/^background(Size|Position)$/.test(attribute)) {
+        return parseBackgroundSizePosition(value, element, attribute, index);
+    } else if (/border(Top|Bottom)(Left|Right)Radius/.test(attribute)) {
+      var arr = value.split(" ");
+      if (arr.length <= 1) {
+          arr[1] = arr[0];
+      }
+      return arr.map(asInt);
+    }
+
+  return value;
+};
+
+_html2canvas.Util.resizeBounds = function( current_width, current_height, target_width, target_height, stretch_mode ){
+  var target_ratio = target_width / target_height,
+    current_ratio = current_width / current_height,
+    output_width, output_height;
+
+  if(!stretch_mode || stretch_mode === 'auto') {
+    output_width = target_width;
+    output_height = target_height;
+  } else if(target_ratio < current_ratio ^ stretch_mode === 'contain') {
+    output_height = target_height;
+    output_width = target_height * current_ratio;
+  } else {
+    output_width = target_width;
+    output_height = target_width / current_ratio;
+  }
+
+  return {
+    width: output_width,
+    height: output_height
+  };
+};
+
+_html2canvas.Util.BackgroundPosition = function(element, bounds, image, imageIndex, backgroundSize ) {
+    var backgroundPosition =  _html2canvas.Util.getCSS(element, 'backgroundPosition', imageIndex),
+        leftPosition,
+        topPosition;
+    if (backgroundPosition.length === 1){
+        backgroundPosition = [backgroundPosition[0], backgroundPosition[0]];
+    }
+
+    if (isPercentage(backgroundPosition[0])){
+        leftPosition = (bounds.width - (backgroundSize || image).width) * (parseFloat(backgroundPosition[0]) / 100);
+    } else {
+        leftPosition = parseInt(backgroundPosition[0], 10);
+    }
+
+    if (backgroundPosition[1] === 'auto') {
+        topPosition = leftPosition / image.width * image.height;
+    } else if (isPercentage(backgroundPosition[1])){
+        topPosition =  (bounds.height - (backgroundSize || image).height) * parseFloat(backgroundPosition[1]) / 100;
+    } else {
+        topPosition = parseInt(backgroundPosition[1], 10);
+    }
+
+    if (backgroundPosition[0] === 'auto') {
+        leftPosition = topPosition / image.height * image.width;
+    }
+
+    return {left: leftPosition, top: topPosition};
+};
+
+_html2canvas.Util.BackgroundSize = function(element, bounds, image, imageIndex) {
+  var backgroundSize =  _html2canvas.Util.getCSS(element, 'backgroundSize', imageIndex), width, height;
+
+  if (backgroundSize.length === 1) {
+    backgroundSize = [backgroundSize[0], backgroundSize[0]];
+  }
+
+  if (isPercentage(backgroundSize[0])) {
+    width = bounds.width * parseFloat(backgroundSize[0]) / 100;
+  } else if (/contain|cover/.test(backgroundSize[0])) {
+    return _html2canvas.Util.resizeBounds(image.width, image.height, bounds.width, bounds.height, backgroundSize[0]);
+  } else {
+    width = parseInt(backgroundSize[0], 10);
+  }
+
+  if (backgroundSize[0] === 'auto' && backgroundSize[1] === 'auto') {
+    height = image.height;
+  } else if (backgroundSize[1] === 'auto') {
+    height = width / image.width * image.height;
+  } else if (isPercentage(backgroundSize[1])) {
+    height =  bounds.height * parseFloat(backgroundSize[1]) / 100;
+  } else {
+    height = parseInt(backgroundSize[1], 10);
+  }
+
+  if (backgroundSize[0] === 'auto') {
+    width = height / image.height * image.width;
+  }
+
+  return {width: width, height: height};
+};
+
+_html2canvas.Util.BackgroundRepeat = function(element, imageIndex) {
+  var backgroundRepeat = _html2canvas.Util.getCSS(element, "backgroundRepeat").split(",").map(_html2canvas.Util.trimText);
+  return backgroundRepeat[imageIndex] || backgroundRepeat[0];
+};
+
+_html2canvas.Util.Extend = function (options, defaults) {
+  for (var key in options) {
+    if (options.hasOwnProperty(key)) {
+      defaults[key] = options[key];
+    }
+  }
+  return defaults;
+};
+
+
+/*
+ * Derived from jQuery.contents()
+ * Copyright 2010, John Resig
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ */
+_html2canvas.Util.Children = function( elem ) {
+  var children;
+  try {
+    children = (elem.nodeName && elem.nodeName.toUpperCase() === "IFRAME") ? elem.contentDocument || elem.contentWindow.document : (function(array) {
+      var ret = [];
+      if (array !== null) {
+        (function(first, second ) {
+          var i = first.length,
+          j = 0;
+
+          if (typeof second.length === "number") {
+            for (var l = second.length; j < l; j++) {
+              first[i++] = second[j];
+            }
+          } else {
+            while (second[j] !== undefined) {
+              first[i++] = second[j++];
+            }
+          }
+
+          first.length = i;
+
+          return first;
+        })(ret, array);
+      }
+      return ret;
+    })(elem.childNodes);
+
+  } catch (ex) {
+    _html2canvas.Util.log("html2canvas.Util.Children failed with exception: " + ex.message);
+    children = [];
+  }
+  return children;
+};
+
+_html2canvas.Util.isTransparent = function(backgroundColor) {
+  return (!backgroundColor || backgroundColor === "transparent" || backgroundColor === "rgba(0, 0, 0, 0)");
+};
+
+_html2canvas.Util.Font = (function () {
+
+  var fontData = {};
+
+  return function(font, fontSize, doc) {
+    if (fontData[font + "-" + fontSize] !== undefined) {
+      return fontData[font + "-" + fontSize];
+    }
+
+    var container = doc.createElement('div'),
+    img = doc.createElement('img'),
+    span = doc.createElement('span'),
+    sampleText = 'Hidden Text',
+    baseline,
+    middle,
+    metricsObj;
+
+    container.style.visibility = "hidden";
+    container.style.fontFamily = font;
+    container.style.fontSize = fontSize;
+    container.style.margin = 0;
+    container.style.padding = 0;
+
+    doc.body.appendChild(container);
+
+    // http://probablyprogramming.com/2009/03/15/the-tiniest-gif-ever (handtinywhite.gif)
+    img.src = "data:image/gif;base64,R0lGODlhAQABAIABAP///wAAACwAAAAAAQABAAACAkQBADs=";
+    img.width = 1;
+    img.height = 1;
+
+    img.style.margin = 0;
+    img.style.padding = 0;
+    img.style.verticalAlign = "baseline";
+
+    span.style.fontFamily = font;
+    span.style.fontSize = fontSize;
+    span.style.margin = 0;
+    span.style.padding = 0;
+
+    span.appendChild(doc.createTextNode(sampleText));
+    container.appendChild(span);
+    container.appendChild(img);
+    baseline = (img.offsetTop - span.offsetTop) + 1;
+
+    container.removeChild(span);
+    container.appendChild(doc.createTextNode(sampleText));
+
+    container.style.lineHeight = "normal";
+    img.style.verticalAlign = "super";
+
+    middle = (img.offsetTop-container.offsetTop) + 1;
+    metricsObj = {
+      baseline: baseline,
+      lineWidth: 1,
+      middle: middle
+    };
+
+    fontData[font + "-" + fontSize] = metricsObj;
+
+    doc.body.removeChild(container);
+
+    return metricsObj;
+  };
+})();
+
+(function(){
+  var Util = _html2canvas.Util,
+    Generate = {};
+
+  _html2canvas.Generate = Generate;
+
+  var reGradients = [
+  /^(-webkit-linear-gradient)\(([a-z\s]+)([\w\d\.\s,%\(\)]+)\)$/,
+  /^(-o-linear-gradient)\(([a-z\s]+)([\w\d\.\s,%\(\)]+)\)$/,
+  /^(-webkit-gradient)\((linear|radial),\s((?:\d{1,3}%?)\s(?:\d{1,3}%?),\s(?:\d{1,3}%?)\s(?:\d{1,3}%?))([\w\d\.\s,%\(\)\-]+)\)$/,
+  /^(-moz-linear-gradient)\(((?:\d{1,3}%?)\s(?:\d{1,3}%?))([\w\d\.\s,%\(\)]+)\)$/,
+  /^(-webkit-radial-gradient)\(((?:\d{1,3}%?)\s(?:\d{1,3}%?)),\s(\w+)\s([a-z\-]+)([\w\d\.\s,%\(\)]+)\)$/,
+  /^(-moz-radial-gradient)\(((?:\d{1,3}%?)\s(?:\d{1,3}%?)),\s(\w+)\s?([a-z\-]*)([\w\d\.\s,%\(\)]+)\)$/,
+  /^(-o-radial-gradient)\(((?:\d{1,3}%?)\s(?:\d{1,3}%?)),\s(\w+)\s([a-z\-]+)([\w\d\.\s,%\(\)]+)\)$/
+  ];
+
+  /*
+ * TODO: Add IE10 vendor prefix (-ms) support
+ * TODO: Add W3C gradient (linear-gradient) support
+ * TODO: Add old Webkit -webkit-gradient(radial, ...) support
+ * TODO: Maybe some RegExp optimizations are possible ;o)
+ */
+  Generate.parseGradient = function(css, bounds) {
+    var gradient, i, len = reGradients.length, m1, stop, m2, m2Len, step, m3, tl,tr,br,bl;
+
+    for(i = 0; i < len; i+=1){
+      m1 = css.match(reGradients[i]);
+      if(m1) {
+        break;
+      }
+    }
+
+    if(m1) {
+      switch(m1[1]) {
+        case '-webkit-linear-gradient':
+        case '-o-linear-gradient':
+
+          gradient = {
+            type: 'linear',
+            x0: null,
+            y0: null,
+            x1: null,
+            y1: null,
+            colorStops: []
+          };
+
+          // get coordinates
+          m2 = m1[2].match(/\w+/g);
+          if(m2){
+            m2Len = m2.length;
+            for(i = 0; i < m2Len; i+=1){
+              switch(m2[i]) {
+                case 'top':
+                  gradient.y0 = 0;
+                  gradient.y1 = bounds.height;
+                  break;
+
+                case 'right':
+                  gradient.x0 = bounds.width;
+                  gradient.x1 = 0;
+                  break;
+
+                case 'bottom':
+                  gradient.y0 = bounds.height;
+                  gradient.y1 = 0;
+                  break;
+
+                case 'left':
+                  gradient.x0 = 0;
+                  gradient.x1 = bounds.width;
+                  break;
+              }
+            }
+          }
+          if(gradient.x0 === null && gradient.x1 === null){ // center
+            gradient.x0 = gradient.x1 = bounds.width / 2;
+          }
+          if(gradient.y0 === null && gradient.y1 === null){ // center
+            gradient.y0 = gradient.y1 = bounds.height / 2;
+          }
+
+          // get colors and stops
+          m2 = m1[3].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\)(?:\s\d{1,3}(?:%|px))?)+/g);
+          if(m2){
+            m2Len = m2.length;
+            step = 1 / Math.max(m2Len - 1, 1);
+            for(i = 0; i < m2Len; i+=1){
+              m3 = m2[i].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\))\s*(\d{1,3})?(%|px)?/);
+              if(m3[2]){
+                stop = parseFloat(m3[2]);
+                if(m3[3] === '%'){
+                  stop /= 100;
+                } else { // px - stupid opera
+                  stop /= bounds.width;
+                }
+              } else {
+                stop = i * step;
+              }
+              gradient.colorStops.push({
+                color: m3[1],
+                stop: stop
+              });
+            }
+          }
+          break;
+
+        case '-webkit-gradient':
+
+          gradient = {
+            type: m1[2] === 'radial' ? 'circle' : m1[2], // TODO: Add radial gradient support for older mozilla definitions
+            x0: 0,
+            y0: 0,
+            x1: 0,
+            y1: 0,
+            colorStops: []
+          };
+
+          // get coordinates
+          m2 = m1[3].match(/(\d{1,3})%?\s(\d{1,3})%?,\s(\d{1,3})%?\s(\d{1,3})%?/);
+          if(m2){
+            gradient.x0 = (m2[1] * bounds.width) / 100;
+            gradient.y0 = (m2[2] * bounds.height) / 100;
+            gradient.x1 = (m2[3] * bounds.width) / 100;
+            gradient.y1 = (m2[4] * bounds.height) / 100;
+          }
+
+          // get colors and stops
+          m2 = m1[4].match(/((?:from|to|color-stop)\((?:[0-9\.]+,\s)?(?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\)\))+/g);
+          if(m2){
+            m2Len = m2.length;
+            for(i = 0; i < m2Len; i+=1){
+              m3 = m2[i].match(/(from|to|color-stop)\(([0-9\.]+)?(?:,\s)?((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\))\)/);
+              stop = parseFloat(m3[2]);
+              if(m3[1] === 'from') {
+                stop = 0.0;
+              }
+              if(m3[1] === 'to') {
+                stop = 1.0;
+              }
+              gradient.colorStops.push({
+                color: m3[3],
+                stop: stop
+              });
+            }
+          }
+          break;
+
+        case '-moz-linear-gradient':
+
+          gradient = {
+            type: 'linear',
+            x0: 0,
+            y0: 0,
+            x1: 0,
+            y1: 0,
+            colorStops: []
+          };
+
+          // get coordinates
+          m2 = m1[2].match(/(\d{1,3})%?\s(\d{1,3})%?/);
+
+          // m2[1] == 0%   -> left
+          // m2[1] == 50%  -> center
+          // m2[1] == 100% -> right
+
+          // m2[2] == 0%   -> top
+          // m2[2] == 50%  -> center
+          // m2[2] == 100% -> bottom
+
+          if(m2){
+            gradient.x0 = (m2[1] * bounds.width) / 100;
+            gradient.y0 = (m2[2] * bounds.height) / 100;
+            gradient.x1 = bounds.width - gradient.x0;
+            gradient.y1 = bounds.height - gradient.y0;
+          }
+
+          // get colors and stops
+          m2 = m1[3].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\)(?:\s\d{1,3}%)?)+/g);
+          if(m2){
+            m2Len = m2.length;
+            step = 1 / Math.max(m2Len - 1, 1);
+            for(i = 0; i < m2Len; i+=1){
+              m3 = m2[i].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\))\s*(\d{1,3})?(%)?/);
+              if(m3[2]){
+                stop = parseFloat(m3[2]);
+                if(m3[3]){ // percentage
+                  stop /= 100;
+                }
+              } else {
+                stop = i * step;
+              }
+              gradient.colorStops.push({
+                color: m3[1],
+                stop: stop
+              });
+            }
+          }
+          break;
+
+        case '-webkit-radial-gradient':
+        case '-moz-radial-gradient':
+        case '-o-radial-gradient':
+
+          gradient = {
+            type: 'circle',
+            x0: 0,
+            y0: 0,
+            x1: bounds.width,
+            y1: bounds.height,
+            cx: 0,
+            cy: 0,
+            rx: 0,
+            ry: 0,
+            colorStops: []
+          };
+
+          // center
+          m2 = m1[2].match(/(\d{1,3})%?\s(\d{1,3})%?/);
+          if(m2){
+            gradient.cx = (m2[1] * bounds.width) / 100;
+            gradient.cy = (m2[2] * bounds.height) / 100;
+          }
+
+          // size
+          m2 = m1[3].match(/\w+/);
+          m3 = m1[4].match(/[a-z\-]*/);
+          if(m2 && m3){
+            switch(m3[0]){
+              case 'farthest-corner':
+              case 'cover': // is equivalent to farthest-corner
+              case '': // mozilla removes "cover" from definition :(
+                tl = Math.sqrt(Math.pow(gradient.cx, 2) + Math.pow(gradient.cy, 2));
+                tr = Math.sqrt(Math.pow(gradient.cx, 2) + Math.pow(gradient.y1 - gradient.cy, 2));
+                br = Math.sqrt(Math.pow(gradient.x1 - gradient.cx, 2) + Math.pow(gradient.y1 - gradient.cy, 2));
+                bl = Math.sqrt(Math.pow(gradient.x1 - gradient.cx, 2) + Math.pow(gradient.cy, 2));
+                gradient.rx = gradient.ry = Math.max(tl, tr, br, bl);
+                break;
+              case 'closest-corner':
+                tl = Math.sqrt(Math.pow(gradient.cx, 2) + Math.pow(gradient.cy, 2));
+                tr = Math.sqrt(Math.pow(gradient.cx, 2) + Math.pow(gradient.y1 - gradient.cy, 2));
+                br = Math.sqrt(Math.pow(gradient.x1 - gradient.cx, 2) + Math.pow(gradient.y1 - gradient.cy, 2));
+                bl = Math.sqrt(Math.pow(gradient.x1 - gradient.cx, 2) + Math.pow(gradient.cy, 2));
+                gradient.rx = gradient.ry = Math.min(tl, tr, br, bl);
+                break;
+              case 'farthest-side':
+                if(m2[0] === 'circle'){
+                  gradient.rx = gradient.ry = Math.max(
+                    gradient.cx,
+                    gradient.cy,
+                    gradient.x1 - gradient.cx,
+                    gradient.y1 - gradient.cy
+                    );
+                } else { // ellipse
+
+                  gradient.type = m2[0];
+
+                  gradient.rx = Math.max(
+                    gradient.cx,
+                    gradient.x1 - gradient.cx
+                    );
+                  gradient.ry = Math.max(
+                    gradient.cy,
+                    gradient.y1 - gradient.cy
+                    );
+                }
+                break;
+              case 'closest-side':
+              case 'contain': // is equivalent to closest-side
+                if(m2[0] === 'circle'){
+                  gradient.rx = gradient.ry = Math.min(
+                    gradient.cx,
+                    gradient.cy,
+                    gradient.x1 - gradient.cx,
+                    gradient.y1 - gradient.cy
+                    );
+                } else { // ellipse
+
+                  gradient.type = m2[0];
+
+                  gradient.rx = Math.min(
+                    gradient.cx,
+                    gradient.x1 - gradient.cx
+                    );
+                  gradient.ry = Math.min(
+                    gradient.cy,
+                    gradient.y1 - gradient.cy
+                    );
+                }
+                break;
+
+            // TODO: add support for "30px 40px" sizes (webkit only)
+            }
+          }
+
+          // color stops
+          m2 = m1[5].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\)(?:\s\d{1,3}(?:%|px))?)+/g);
+          if(m2){
+            m2Len = m2.length;
+            step = 1 / Math.max(m2Len - 1, 1);
+            for(i = 0; i < m2Len; i+=1){
+              m3 = m2[i].match(/((?:rgb|rgba)\(\d{1,3},\s\d{1,3},\s\d{1,3}(?:,\s[0-9\.]+)?\))\s*(\d{1,3})?(%|px)?/);
+              if(m3[2]){
+                stop = parseFloat(m3[2]);
+                if(m3[3] === '%'){
+                  stop /= 100;
+                } else { // px - stupid opera
+                  stop /= bounds.width;
+                }
+              } else {
+                stop = i * step;
+              }
+              gradient.colorStops.push({
+                color: m3[1],
+                stop: stop
+              });
+            }
+          }
+          break;
+      }
+    }
+
+    return gradient;
+  };
+
+  function addScrollStops(grad) {
+    return function(colorStop) {
+      try {
+        grad.addColorStop(colorStop.stop, colorStop.color);
+      }
+      catch(e) {
+        Util.log(['failed to add color stop: ', e, '; tried to add: ', colorStop]);
+      }
+    };
+  }
+
+  Generate.Gradient = function(src, bounds) {
+    if(bounds.width === 0 || bounds.height === 0) {
+      return;
+    }
+
+    var canvas = document.createElement('canvas'),
+    ctx = canvas.getContext('2d'),
+    gradient, grad;
+
+    canvas.width = bounds.width;
+    canvas.height = bounds.height;
+
+    // TODO: add support for multi defined background gradients
+    gradient = _html2canvas.Generate.parseGradient(src, bounds);
+
+    if(gradient) {
+      switch(gradient.type) {
+        case 'linear':
+          grad = ctx.createLinearGradient(gradient.x0, gradient.y0, gradient.x1, gradient.y1);
+          gradient.colorStops.forEach(addScrollStops(grad));
+          ctx.fillStyle = grad;
+          ctx.fillRect(0, 0, bounds.width, bounds.height);
+          break;
+
+        case 'circle':
+          grad = ctx.createRadialGradient(gradient.cx, gradient.cy, 0, gradient.cx, gradient.cy, gradient.rx);
+          gradient.colorStops.forEach(addScrollStops(grad));
+          ctx.fillStyle = grad;
+          ctx.fillRect(0, 0, bounds.width, bounds.height);
+          break;
+
+        case 'ellipse':
+          var canvasRadial = document.createElement('canvas'),
+            ctxRadial = canvasRadial.getContext('2d'),
+            ri = Math.max(gradient.rx, gradient.ry),
+            di = ri * 2;
+
+          canvasRadial.width = canvasRadial.height = di;
+
+          grad = ctxRadial.createRadialGradient(gradient.rx, gradient.ry, 0, gradient.rx, gradient.ry, ri);
+          gradient.colorStops.forEach(addScrollStops(grad));
+
+          ctxRadial.fillStyle = grad;
+          ctxRadial.fillRect(0, 0, di, di);
+
+          ctx.fillStyle = gradient.colorStops[gradient.colorStops.length - 1].color;
+          ctx.fillRect(0, 0, canvas.width, canvas.height);
+          ctx.drawImage(canvasRadial, gradient.cx - gradient.rx, gradient.cy - gradient.ry, 2 * gradient.rx, 2 * gradient.ry);
+          break;
+      }
+    }
+
+    return canvas;
+  };
+
+  Generate.ListAlpha = function(number) {
+    var tmp = "",
+    modulus;
+
+    do {
+      modulus = number % 26;
+      tmp = String.fromCharCode((modulus) + 64) + tmp;
+      number = number / 26;
+    }while((number*26) > 26);
+
+    return tmp;
+  };
+
+  Generate.ListRoman = function(number) {
+    var romanArray = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"],
+    decimal = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1],
+    roman = "",
+    v,
+    len = romanArray.length;
+
+    if (number <= 0 || number >= 4000) {
+      return number;
+    }
+
+    for (v=0; v < len; v+=1) {
+      while (number >= decimal[v]) {
+        number -= decimal[v];
+        roman += romanArray[v];
+      }
+    }
+
+    return roman;
+  };
+})();
+function h2cRenderContext(width, height) {
+  var storage = [];
+  return {
+    storage: storage,
+    width: width,
+    height: height,
+    clip: function() {
+      storage.push({
+        type: "function",
+        name: "clip",
+        'arguments': arguments
+      });
+    },
+    translate: function() {
+      storage.push({
+        type: "function",
+        name: "translate",
+        'arguments': arguments
+      });
+    },
+    fill: function() {
+      storage.push({
+        type: "function",
+        name: "fill",
+        'arguments': arguments
+      });
+    },
+    save: function() {
+      storage.push({
+        type: "function",
+        name: "save",
+        'arguments': arguments
+      });
+    },
+    restore: function() {
+      storage.push({
+        type: "function",
+        name: "restore",
+        'arguments': arguments
+      });
+    },
+    fillRect: function () {
+      storage.push({
+        type: "function",
+        name: "fillRect",
+        'arguments': arguments
+      });
+    },
+    createPattern: function() {
+      storage.push({
+        type: "function",
+        name: "createPattern",
+        'arguments': arguments
+      });
+    },
+    drawShape: function() {
+
+      var shape = [];
+
+      storage.push({
+        type: "function",
+        name: "drawShape",
+        'arguments': shape
+      });
+
+      return {
+        moveTo: function() {
+          shape.push({
+            name: "moveTo",
+            'arguments': arguments
+          });
+        },
+        lineTo: function() {
+          shape.push({
+            name: "lineTo",
+            'arguments': arguments
+          });
+        },
+        arcTo: function() {
+          shape.push({
+            name: "arcTo",
+            'arguments': arguments
+          });
+        },
+        bezierCurveTo: function() {
+          shape.push({
+            name: "bezierCurveTo",
+            'arguments': arguments
+          });
+        },
+        quadraticCurveTo: function() {
+          shape.push({
+            name: "quadraticCurveTo",
+            'arguments': arguments
+          });
+        }
+      };
+
+    },
+    drawImage: function () {
+      storage.push({
+        type: "function",
+        name: "drawImage",
+        'arguments': arguments
+      });
+    },
+    fillText: function () {
+      storage.push({
+        type: "function",
+        name: "fillText",
+        'arguments': arguments
+      });
+    },
+    setVariable: function (variable, value) {
+      storage.push({
+        type: "variable",
+        name: variable,
+        'arguments': value
+      });
+      return value;
+    }
+  };
+}
+_html2canvas.Parse = function (images, options, cb) {
+  window.scroll(0,0);
+
+  var element = (( options.elements === undefined ) ? document.body : options.elements[0]), // select body by default
+  numDraws = 0,
+  doc = element.ownerDocument,
+  Util = _html2canvas.Util,
+  support = Util.Support(options, doc),
+  ignoreElementsRegExp = new RegExp("(" + options.ignoreElements + ")"),
+  body = doc.body,
+  getCSS = Util.getCSS,
+  pseudoHide = "___html2canvas___pseudoelement",
+  hidePseudoElementsStyles = doc.createElement('style');
+
+  hidePseudoElementsStyles.innerHTML = '.' + pseudoHide +
+  '-parent:before { content: "" !important; display: none !important; }' +
+  '.' + pseudoHide + '-parent:after { content: "" !important; display: none !important; }';
+
+  body.appendChild(hidePseudoElementsStyles);
+
+  images = images || {};
+
+  init();
+
+  function init() {
+    var background = getCSS(document.documentElement, "backgroundColor"),
+      transparentBackground = (Util.isTransparent(background) && element === document.body),
+      stack = renderElement(element, null, false, transparentBackground);
+
+    // create pseudo elements in a single pass to prevent synchronous layouts
+    addPseudoElements(element);
+
+    parseChildren(element, stack, function() {
+      if (transparentBackground) {
+        background = stack.backgroundColor;
+      }
+
+      removePseudoElements();
+
+      Util.log('Done parsing, moving to Render.');
+
+      cb({
+        backgroundColor: background,
+        stack: stack
+      });
+    });
+  }
+
+  // Given a root element, find all pseudo elements below, create elements mocking pseudo element styles
+  // so we can process them as normal elements, and hide the original pseudo elements so they don't interfere
+  // with layout.
+  function addPseudoElements(el) {
+    // These are done in discrete steps to prevent a relayout loop caused by addClass() invalidating
+    // layouts & getPseudoElement calling getComputedStyle.
+    var jobs = [], classes = [];
+    getPseudoElementClasses();
+    findPseudoElements(el);
+    runJobs();
+
+    function getPseudoElementClasses(){
+      var findPsuedoEls = /:before|:after/;
+      var sheets = document.styleSheets;
+      for (var i = 0, j = sheets.length; i < j; i++) {
+        try {
+          var rules = sheets[i].cssRules;
+          for (var k = 0, l = rules.length; k < l; k++) {
+            if(findPsuedoEls.test(rules[k].selectorText)) {
+              classes.push(rules[k].selectorText);
+            }
+          }
+        }
+        catch(e) { // will throw security exception for style sheets loaded from external domains
+        }
+      }
+
+      // Trim off the :after and :before (or ::after and ::before)
+      for (i = 0, j = classes.length; i < j; i++) {
+        classes[i] = classes[i].match(/(^[^:]*)/)[1];
+      }
+    }
+
+    // Using the list of elements we know how pseudo el styles, create fake pseudo elements.
+    function findPseudoElements(el) {
+      var els = document.querySelectorAll(classes.join(','));
+      for(var i = 0, j = els.length; i < j; i++) {
+        createPseudoElements(els[i]);
+      }
+    }
+
+    // Create pseudo elements & add them to a job queue.
+    function createPseudoElements(el) {
+      var before = getPseudoElement(el, ':before'),
+      after = getPseudoElement(el, ':after');
+
+      if(before) {
+        jobs.push({type: 'before', pseudo: before, el: el});
+      }
+
+      if (after) {
+        jobs.push({type: 'after', pseudo: after, el: el});
+      }
+    }
+
+    // Adds a class to the pseudo's parent to prevent the original before/after from messing
+    // with layouts.
+    // Execute the inserts & addClass() calls in a batch to prevent relayouts.
+    function runJobs() {
+      // Add Class
+      jobs.forEach(function(job){
+        addClass(job.el, pseudoHide + "-parent");
+      });
+
+      // Insert el
+      jobs.forEach(function(job){
+        if(job.type === 'before'){
+          job.el.insertBefore(job.pseudo, job.el.firstChild);
+        } else {
+          job.el.appendChild(job.pseudo);
+        }
+      });
+    }
+  }
+
+
+
+  // Delete our fake pseudo elements from the DOM. This will remove those actual elements
+  // and the classes on their parents that hide the actual pseudo elements.
+  // Note that NodeLists are 'live' collections so you can't use a for loop here. They are
+  // actually deleted from the NodeList after each iteration.
+  function removePseudoElements(){
+    // delete pseudo elements
+    body.removeChild(hidePseudoElementsStyles);
+    var pseudos = document.getElementsByClassName(pseudoHide + "-element");
+    while (pseudos.length) {
+      pseudos[0].parentNode.removeChild(pseudos[0]);
+    }
+
+    // Remove pseudo hiding classes
+    var parents = document.getElementsByClassName(pseudoHide + "-parent");
+    while(parents.length) {
+      removeClass(parents[0], pseudoHide + "-parent");
+    }
+  }
+
+  function addClass (el, className) {
+    if (el.classList) {
+      el.classList.add(className);
+    } else {
+      el.className = el.className + " " + className;
+    }
+  }
+
+  function removeClass (el, className) {
+    if (el.classList) {
+      el.classList.remove(className);
+    } else {
+      el.className = el.className.replace(className, "").trim();
+    }
+  }
+
+  function hasClass (el, className) {
+    return el.className.indexOf(className) > -1;
+  }
+
+  // Note that this doesn't work in < IE8, but we don't support that anyhow
+  function nodeListToArray (nodeList) {
+    return Array.prototype.slice.call(nodeList);
+  }
+
+  function documentWidth () {
+    return Math.max(
+      Math.max(doc.body.scrollWidth, doc.documentElement.scrollWidth),
+      Math.max(doc.body.offsetWidth, doc.documentElement.offsetWidth),
+      Math.max(doc.body.clientWidth, doc.documentElement.clientWidth)
+      );
+  }
+
+  function documentHeight () {
+    return Math.max(
+      Math.max(doc.body.scrollHeight, doc.documentElement.scrollHeight),
+      Math.max(doc.body.offsetHeight, doc.documentElement.offsetHeight),
+      Math.max(doc.body.clientHeight, doc.documentElement.clientHeight)
+      );
+  }
+
+  function getCSSInt(element, attribute) {
+    var val = parseInt(getCSS(element, attribute), 10);
+    return (isNaN(val)) ? 0 : val; // borders in old IE are throwing 'medium' for demo.html
+  }
+
+  function renderRect (ctx, x, y, w, h, bgcolor) {
+    if (bgcolor !== "transparent"){
+      ctx.setVariable("fillStyle", bgcolor);
+      ctx.fillRect(x, y, w, h);
+      numDraws+=1;
+    }
+  }
+
+  function capitalize(m, p1, p2) {
+    if (m.length > 0) {
+      return p1 + p2.toUpperCase();
+    }
+  }
+
+  function textTransform (text, transform) {
+    switch(transform){
+      case "lowercase":
+        return text.toLowerCase();
+      case "capitalize":
+        return text.replace( /(^|\s|:|-|\(|\))([a-z])/g, capitalize);
+      case "uppercase":
+        return text.toUpperCase();
+      default:
+        return text;
+    }
+  }
+
+  function noLetterSpacing(letter_spacing) {
+    return (/^(normal|none|0px)$/.test(letter_spacing));
+  }
+
+  function drawText(currentText, x, y, ctx){
+    if (currentText !== null && Util.trimText(currentText).length > 0) {
+      ctx.fillText(currentText, x, y);
+      numDraws+=1;
+    }
+  }
+
+  function setTextVariables(ctx, el, text_decoration, color) {
+    var align = false,
+    bold = getCSS(el, "fontWeight"),
+    family = getCSS(el, "fontFamily"),
+    size = getCSS(el, "fontSize"),
+    shadows = Util.parseTextShadows(getCSS(el, "textShadow"));
+
+    switch(parseInt(bold, 10)){
+      case 401:
+        bold = "bold";
+        break;
+      case 400:
+        bold = "normal";
+        break;
+    }
+
+    ctx.setVariable("fillStyle", color);
+    ctx.setVariable("font", [getCSS(el, "fontStyle"), getCSS(el, "fontVariant"), bold, size, family].join(" "));
+    ctx.setVariable("textAlign", (align) ? "right" : "left");
+
+    if (shadows.length) {
+      // TODO: support multiple text shadows
+      // apply the first text shadow
+      ctx.setVariable("shadowColor", shadows[0].color);
+      ctx.setVariable("shadowOffsetX", shadows[0].offsetX);
+      ctx.setVariable("shadowOffsetY", shadows[0].offsetY);
+      ctx.setVariable("shadowBlur", shadows[0].blur);
+    }
+
+    if (text_decoration !== "none"){
+      return Util.Font(family, size, doc);
+    }
+  }
+
+  function renderTextDecoration(ctx, text_decoration, bounds, metrics, color) {
+    switch(text_decoration) {
+      case "underline":
+        // Draws a line at the baseline of the font
+        // TODO As some browsers display the line as more than 1px if the font-size is big, need to take that into account both in position and size
+        renderRect(ctx, bounds.left, Math.round(bounds.top + metrics.baseline + metrics.lineWidth), bounds.width, 1, color);
+        break;
+      case "overline":
+        renderRect(ctx, bounds.left, Math.round(bounds.top), bounds.width, 1, color);
+        break;
+      case "line-through":
+        // TODO try and find exact position for line-through
+        renderRect(ctx, bounds.left, Math.ceil(bounds.top + metrics.middle + metrics.lineWidth), bounds.width, 1, color);
+        break;
+    }
+  }
+
+  function getTextBounds(state, text, textDecoration, isLast, transform) {
+    var bounds;
+    if (support.rangeBounds && !transform) {
+      if (textDecoration !== "none" || Util.trimText(text).length !== 0) {
+        bounds = textRangeBounds(text, state.node, state.textOffset);
+      }
+      state.textOffset += text.length;
+    } else if (state.node && typeof state.node.nodeValue === "string" ){
+      var newTextNode = (isLast) ? state.node.splitText(text.length) : null;
+      bounds = textWrapperBounds(state.node, transform);
+      state.node = newTextNode;
+    }
+    return bounds;
+  }
+
+  function textRangeBounds(text, textNode, textOffset) {
+    var range = doc.createRange();
+    range.setStart(textNode, textOffset);
+    range.setEnd(textNode, textOffset + text.length);
+    return range.getBoundingClientRect();
+  }
+
+  function textWrapperBounds(oldTextNode, transform) {
+    var parent = oldTextNode.parentNode,
+    wrapElement = doc.createElement('wrapper'),
+    backupText = oldTextNode.cloneNode(true);
+
+    wrapElement.appendChild(oldTextNode.cloneNode(true));
+    parent.replaceChild(wrapElement, oldTextNode);
+
+    var bounds = transform ? Util.OffsetBounds(wrapElement) : Util.Bounds(wrapElement);
+    parent.replaceChild(backupText, wrapElement);
+    return bounds;
+  }
+
+  function renderText(el, textNode, stack) {
+    var ctx = stack.ctx,
+    color = getCSS(el, "color"),
+    textDecoration = getCSS(el, "textDecoration"),
+    textAlign = getCSS(el, "textAlign"),
+    metrics,
+    textList,
+    state = {
+      node: textNode,
+      textOffset: 0
+    };
+
+    if (Util.trimText(textNode.nodeValue).length > 0) {
+      textNode.nodeValue = textTransform(textNode.nodeValue, getCSS(el, "textTransform"));
+      textAlign = textAlign.replace(["-webkit-auto"],["auto"]);
+
+      textList = (!options.letterRendering && /^(left|right|justify|auto)$/.test(textAlign) && noLetterSpacing(getCSS(el, "letterSpacing"))) ?
+      textNode.nodeValue.split(/(\b| )/)
+      : textNode.nodeValue.split("");
+
+      metrics = setTextVariables(ctx, el, textDecoration, color);
+
+      if (options.chinese) {
+        textList.forEach(function(word, index) {
+          if (/.*[\u4E00-\u9FA5].*$/.test(word)) {
+            word = word.split("");
+            word.unshift(index, 1);
+            textList.splice.apply(textList, word);
+          }
+        });
+      }
+
+      textList.forEach(function(text, index) {
+        var bounds = getTextBounds(state, text, textDecoration, (index < textList.length - 1), stack.transform.matrix);
+        if (bounds) {
+          drawText(text, bounds.left, bounds.bottom, ctx);
+          renderTextDecoration(ctx, textDecoration, bounds, metrics, color);
+        }
+      });
+    }
+  }
+
+  function listPosition (element, val) {
+    var boundElement = doc.createElement( "boundelement" ),
+    originalType,
+    bounds;
+
+    boundElement.style.display = "inline";
+
+    originalType = element.style.listStyleType;
+    element.style.listStyleType = "none";
+
+    boundElement.appendChild(doc.createTextNode(val));
+
+    element.insertBefore(boundElement, element.firstChild);
+
+    bounds = Util.Bounds(boundElement);
+    element.removeChild(boundElement);
+    element.style.listStyleType = originalType;
+    return bounds;
+  }
+
+  function elementIndex(el) {
+    var i = -1,
+    count = 1,
+    childs = el.parentNode.childNodes;
+
+    if (el.parentNode) {
+      while(childs[++i] !== el) {
+        if (childs[i].nodeType === 1) {
+          count++;
+        }
+      }
+      return count;
+    } else {
+      return -1;
+    }
+  }
+
+  function listItemText(element, type) {
+    var currentIndex = elementIndex(element), text;
+    switch(type){
+      case "decimal":
+        text = currentIndex;
+        break;
+      case "decimal-leading-zero":
+        text = (currentIndex.toString().length === 1) ? currentIndex = "0" + currentIndex.toString() : currentIndex.toString();
+        break;
+      case "upper-roman":
+        text = _html2canvas.Generate.ListRoman( currentIndex );
+        break;
+      case "lower-roman":
+        text = _html2canvas.Generate.ListRoman( currentIndex ).toLowerCase();
+        break;
+      case "lower-alpha":
+        text = _html2canvas.Generate.ListAlpha( currentIndex ).toLowerCase();
+        break;
+      case "upper-alpha":
+        text = _html2canvas.Generate.ListAlpha( currentIndex );
+        break;
+    }
+
+    return text + ". ";
+  }
+
+  function renderListItem(element, stack, elBounds) {
+    var x,
+    text,
+    ctx = stack.ctx,
+    type = getCSS(element, "listStyleType"),
+    listBounds;
+
+    if (/^(decimal|decimal-leading-zero|upper-alpha|upper-latin|upper-roman|lower-alpha|lower-greek|lower-latin|lower-roman)$/i.test(type)) {
+      text = listItemText(element, type);
+      listBounds = listPosition(element, text);
+      setTextVariables(ctx, element, "none", getCSS(element, "color"));
+
+      if (getCSS(element, "listStylePosition") === "inside") {
+        ctx.setVariable("textAlign", "left");
+        x = elBounds.left;
+      } else {
+        return;
+      }
+
+      drawText(text, x, listBounds.bottom, ctx);
+    }
+  }
+
+  function loadImage (src){
+    var img = images[src];
+    return (img && img.succeeded === true) ? img.img : false;
+  }
+
+  function clipBounds(src, dst){
+    var x = Math.max(src.left, dst.left),
+    y = Math.max(src.top, dst.top),
+    x2 = Math.min((src.left + src.width), (dst.left + dst.width)),
+    y2 = Math.min((src.top + src.height), (dst.top + dst.height));
+
+    return {
+      left:x,
+      top:y,
+      width:x2-x,
+      height:y2-y
+    };
+  }
+
+  function setZ(element, stack, parentStack){
+    var newContext,
+    isPositioned = stack.cssPosition !== 'static',
+    zIndex = isPositioned ? getCSS(element, 'zIndex') : 'auto',
+    opacity = getCSS(element, 'opacity'),
+    isFloated = getCSS(element, 'cssFloat') !== 'none';
+
+    // https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context
+    // When a new stacking context should be created:
+    // the root element (HTML),
+    // positioned (absolutely or relatively) with a z-index value other than "auto",
+    // elements with an opacity value less than 1. (See the specification for opacity),
+    // on mobile WebKit and Chrome 22+, position: fixed always creates a new stacking context, even when z-index is "auto" (See this post)
+
+    stack.zIndex = newContext = h2czContext(zIndex);
+    newContext.isPositioned = isPositioned;
+    newContext.isFloated = isFloated;
+    newContext.opacity = opacity;
+    newContext.ownStacking = (zIndex !== 'auto' || opacity < 1);
+    newContext.depth = parentStack ? (parentStack.zIndex.depth + 1) : 0;
+
+    if (parentStack) {
+      parentStack.zIndex.children.push(stack);
+    }
+  }
+
+  function h2czContext(zindex) {
+    return {
+      depth: 0,
+      zindex: zindex,
+      children: []
+    };
+  }
+
+  function renderImage(ctx, element, image, bounds, borders) {
+
+    var paddingLeft = getCSSInt(element, 'paddingLeft'),
+    paddingTop = getCSSInt(element, 'paddingTop'),
+    paddingRight = getCSSInt(element, 'paddingRight'),
+    paddingBottom = getCSSInt(element, 'paddingBottom');
+
+    drawImage(
+      ctx,
+      image,
+      0, //sx
+      0, //sy
+      image.width, //sw
+      image.height, //sh
+      bounds.left + paddingLeft + borders[3].width, //dx
+      bounds.top + paddingTop + borders[0].width, // dy
+      bounds.width - (borders[1].width + borders[3].width + paddingLeft + paddingRight), //dw
+      bounds.height - (borders[0].width + borders[2].width + paddingTop + paddingBottom) //dh
+      );
+  }
+
+  function getBorderData(element) {
+    return ["Top", "Right", "Bottom", "Left"].map(function(side) {
+      return {
+        width: getCSSInt(element, 'border' + side + 'Width'),
+        color: getCSS(element, 'border' + side + 'Color')
+      };
+    });
+  }
+
+  function getBorderRadiusData(element) {
+    return ["TopLeft", "TopRight", "BottomRight", "BottomLeft"].map(function(side) {
+      return getCSS(element, 'border' + side + 'Radius');
+    });
+  }
+
+  function getCurvePoints(x, y, r1, r2) {
+    var kappa = 4 * ((Math.sqrt(2) - 1) / 3);
+    var ox = (r1) * kappa, // control point offset horizontal
+    oy = (r2) * kappa, // control point offset vertical
+    xm = x + r1, // x-middle
+    ym = y + r2; // y-middle
+    return {
+      topLeft: bezierCurve({
+        x:x,
+        y:ym
+      }, {
+        x:x,
+        y:ym - oy
+      }, {
+        x:xm - ox,
+        y:y
+      }, {
+        x:xm,
+        y:y
+      }),
+      topRight: bezierCurve({
+        x:x,
+        y:y
+      }, {
+        x:x + ox,
+        y:y
+      }, {
+        x:xm,
+        y:ym - oy
+      }, {
+        x:xm,
+        y:ym
+      }),
+      bottomRight: bezierCurve({
+        x:xm,
+        y:y
+      }, {
+        x:xm,
+        y:y + oy
+      }, {
+        x:x + ox,
+        y:ym
+      }, {
+        x:x,
+        y:ym
+      }),
+      bottomLeft: bezierCurve({
+        x:xm,
+        y:ym
+      }, {
+        x:xm - ox,
+        y:ym
+      }, {
+        x:x,
+        y:y + oy
+      }, {
+        x:x,
+        y:y
+      })
+    };
+  }
+
+  function bezierCurve(start, startControl, endControl, end) {
+
+    var lerp = function (a, b, t) {
+      return {
+        x:a.x + (b.x - a.x) * t,
+        y:a.y + (b.y - a.y) * t
+      };
+    };
+
+    return {
+      start: start,
+      startControl: startControl,
+      endControl: endControl,
+      end: end,
+      subdivide: function(t) {
+        var ab = lerp(start, startControl, t),
+        bc = lerp(startControl, endControl, t),
+        cd = lerp(endControl, end, t),
+        abbc = lerp(ab, bc, t),
+        bccd = lerp(bc, cd, t),
+        dest = lerp(abbc, bccd, t);
+        return [bezierCurve(start, ab, abbc, dest), bezierCurve(dest, bccd, cd, end)];
+      },
+      curveTo: function(borderArgs) {
+        borderArgs.push(["bezierCurve", startControl.x, startControl.y, endControl.x, endControl.y, end.x, end.y]);
+      },
+      curveToReversed: function(borderArgs) {
+        borderArgs.push(["bezierCurve", endControl.x, endControl.y, startControl.x, startControl.y, start.x, start.y]);
+      }
+    };
+  }
+
+  function parseCorner(borderArgs, radius1, radius2, corner1, corner2, x, y) {
+    if (radius1[0] > 0 || radius1[1] > 0) {
+      borderArgs.push(["line", corner1[0].start.x, corner1[0].start.y]);
+      corner1[0].curveTo(borderArgs);
+      corner1[1].curveTo(borderArgs);
+    } else {
+      borderArgs.push(["line", x, y]);
+    }
+
+    if (radius2[0] > 0 || radius2[1] > 0) {
+      borderArgs.push(["line", corner2[0].start.x, corner2[0].start.y]);
+    }
+  }
+
+  function drawSide(borderData, radius1, radius2, outer1, inner1, outer2, inner2) {
+    var borderArgs = [];
+
+    if (radius1[0] > 0 || radius1[1] > 0) {
+      borderArgs.push(["line", outer1[1].start.x, outer1[1].start.y]);
+      outer1[1].curveTo(borderArgs);
+    } else {
+      borderArgs.push([ "line", borderData.c1[0], borderData.c1[1]]);
+    }
+
+    if (radius2[0] > 0 || radius2[1] > 0) {
+      borderArgs.push(["line", outer2[0].start.x, outer2[0].start.y]);
+      outer2[0].curveTo(borderArgs);
+      borderArgs.push(["line", inner2[0].end.x, inner2[0].end.y]);
+      inner2[0].curveToReversed(borderArgs);
+    } else {
+      borderArgs.push([ "line", borderData.c2[0], borderData.c2[1]]);
+      borderArgs.push([ "line", borderData.c3[0], borderData.c3[1]]);
+    }
+
+    if (radius1[0] > 0 || radius1[1] > 0) {
+      borderArgs.push(["line", inner1[1].end.x, inner1[1].end.y]);
+      inner1[1].curveToReversed(borderArgs);
+    } else {
+      borderArgs.push([ "line", borderData.c4[0], borderData.c4[1]]);
+    }
+
+    return borderArgs;
+  }
+
+  function calculateCurvePoints(bounds, borderRadius, borders) {
+
+    var x = bounds.left,
+    y = bounds.top,
+    width = bounds.width,
+    height = bounds.height,
+
+    tlh = borderRadius[0][0],
+    tlv = borderRadius[0][1],
+    trh = borderRadius[1][0],
+    trv = borderRadius[1][1],
+    brh = borderRadius[2][0],
+    brv = borderRadius[2][1],
+    blh = borderRadius[3][0],
+    blv = borderRadius[3][1],
+
+    topWidth = width - trh,
+    rightHeight = height - brv,
+    bottomWidth = width - brh,
+    leftHeight = height - blv;
+
+    return {
+      topLeftOuter: getCurvePoints(
+        x,
+        y,
+        tlh,
+        tlv
+        ).topLeft.subdivide(0.5),
+
+      topLeftInner: getCurvePoints(
+        x + borders[3].width,
+        y + borders[0].width,
+        Math.max(0, tlh - borders[3].width),
+        Math.max(0, tlv - borders[0].width)
+        ).topLeft.subdivide(0.5),
+
+      topRightOuter: getCurvePoints(
+        x + topWidth,
+        y,
+        trh,
+        trv
+        ).topRight.subdivide(0.5),
+
+      topRightInner: getCurvePoints(
+        x + Math.min(topWidth, width + borders[3].width),
+        y + borders[0].width,
+        (topWidth > width + borders[3].width) ? 0 :trh - borders[3].width,
+        trv - borders[0].width
+        ).topRight.subdivide(0.5),
+
+      bottomRightOuter: getCurvePoints(
+        x + bottomWidth,
+        y + rightHeight,
+        brh,
+        brv
+        ).bottomRight.subdivide(0.5),
+
+      bottomRightInner: getCurvePoints(
+        x + Math.min(bottomWidth, width + borders[3].width),
+        y + Math.min(rightHeight, height + borders[0].width),
+        Math.max(0, brh - borders[1].width),
+        Math.max(0, brv - borders[2].width)
+        ).bottomRight.subdivide(0.5),
+
+      bottomLeftOuter: getCurvePoints(
+        x,
+        y + leftHeight,
+        blh,
+        blv
+        ).bottomLeft.subdivide(0.5),
+
+      bottomLeftInner: getCurvePoints(
+        x + borders[3].width,
+        y + leftHeight,
+        Math.max(0, blh - borders[3].width),
+        Math.max(0, blv - borders[2].width)
+        ).bottomLeft.subdivide(0.5)
+    };
+  }
+
+  function getBorderClip(element, borderPoints, borders, radius, bounds) {
+    var backgroundClip = getCSS(element, 'backgroundClip'),
+    borderArgs = [];
+
+    switch(backgroundClip) {
+      case "content-box":
+      case "padding-box":
+        parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftInner, borderPoints.topRightInner, bounds.left + borders[3].width, bounds.top + borders[0].width);
+        parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightInner, borderPoints.bottomRightInner, bounds.left + bounds.width - borders[1].width, bounds.top + borders[0].width);
+        parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightInner, borderPoints.bottomLeftInner, bounds.left + bounds.width - borders[1].width, bounds.top + bounds.height - borders[2].width);
+        parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftInner, borderPoints.topLeftInner, bounds.left + borders[3].width, bounds.top + bounds.height - borders[2].width);
+        break;
+
+      default:
+        parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftOuter, borderPoints.topRightOuter, bounds.left, bounds.top);
+        parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightOuter, borderPoints.bottomRightOuter, bounds.left + bounds.width, bounds.top);
+        parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightOuter, borderPoints.bottomLeftOuter, bounds.left + bounds.width, bounds.top + bounds.height);
+        parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftOuter, borderPoints.topLeftOuter, bounds.left, bounds.top + bounds.height);
+        break;
+    }
+
+    return borderArgs;
+  }
+
+  function parseBorders(element, bounds, borders){
+    var x = bounds.left,
+    y = bounds.top,
+    width = bounds.width,
+    height = bounds.height,
+    borderSide,
+    bx,
+    by,
+    bw,
+    bh,
+    borderArgs,
+    // http://www.w3.org/TR/css3-background/#the-border-radius
+    borderRadius = getBorderRadiusData(element),
+    borderPoints = calculateCurvePoints(bounds, borderRadius, borders),
+    borderData = {
+      clip: getBorderClip(element, borderPoints, borders, borderRadius, bounds),
+      borders: []
+    };
+
+    for (borderSide = 0; borderSide < 4; borderSide++) {
+
+      if (borders[borderSide].width > 0) {
+        bx = x;
+        by = y;
+        bw = width;
+        bh = height - (borders[2].width);
+
+        switch(borderSide) {
+          case 0:
+            // top border
+            bh = borders[0].width;
+
+            borderArgs = drawSide({
+              c1: [bx, by],
+              c2: [bx + bw, by],
+              c3: [bx + bw - borders[1].width, by + bh],
+              c4: [bx + borders[3].width, by + bh]
+            }, borderRadius[0], borderRadius[1],
+            borderPoints.topLeftOuter, borderPoints.topLeftInner, borderPoints.topRightOuter, borderPoints.topRightInner);
+            break;
+          case 1:
+            // right border
+            bx = x + width - (borders[1].width);
+            bw = borders[1].width;
+
+            borderArgs = drawSide({
+              c1: [bx + bw, by],
+              c2: [bx + bw, by + bh + borders[2].width],
+              c3: [bx, by + bh],
+              c4: [bx, by + borders[0].width]
+            }, borderRadius[1], borderRadius[2],
+            borderPoints.topRightOuter, borderPoints.topRightInner, borderPoints.bottomRightOuter, borderPoints.bottomRightInner);
+            break;
+          case 2:
+            // bottom border
+            by = (by + height) - (borders[2].width);
+            bh = borders[2].width;
+
+            borderArgs = drawSide({
+              c1: [bx + bw, by + bh],
+              c2: [bx, by + bh],
+              c3: [bx + borders[3].width, by],
+              c4: [bx + bw - borders[3].width, by]
+            }, borderRadius[2], borderRadius[3],
+            borderPoints.bottomRightOuter, borderPoints.bottomRightInner, borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner);
+            break;
+          case 3:
+            // left border
+            bw = borders[3].width;
+
+            borderArgs = drawSide({
+              c1: [bx, by + bh + borders[2].width],
+              c2: [bx, by],
+              c3: [bx + bw, by + borders[0].width],
+              c4: [bx + bw, by + bh]
+            }, borderRadius[3], borderRadius[0],
+            borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner, borderPoints.topLeftOuter, borderPoints.topLeftInner);
+            break;
+        }
+
+        borderData.borders.push({
+          args: borderArgs,
+          color: borders[borderSide].color
+        });
+
+      }
+    }
+
+    return borderData;
+  }
+
+  function createShape(ctx, args) {
+    var shape = ctx.drawShape();
+    args.forEach(function(border, index) {
+      shape[(index === 0) ? "moveTo" : border[0] + "To" ].apply(null, border.slice(1));
+    });
+    return shape;
+  }
+
+  function renderBorders(ctx, borderArgs, color) {
+    if (color !== "transparent") {
+      ctx.setVariable( "fillStyle", color);
+      createShape(ctx, borderArgs);
+      ctx.fill();
+      numDraws+=1;
+    }
+  }
+
+  function renderFormValue (el, bounds, stack){
+
+    var valueWrap = doc.createElement('valuewrap'),
+    cssPropertyArray = ['lineHeight','textAlign','fontFamily','color','fontSize','paddingLeft','paddingTop','width','height','border','borderLeftWidth','borderTopWidth'],
+    textValue,
+    textNode;
+
+    cssPropertyArray.forEach(function(property) {
+      try {
+        valueWrap.style[property] = getCSS(el, property);
+      } catch(e) {
+        // Older IE has issues with "border"
+        Util.log("html2canvas: Parse: Exception caught in renderFormValue: " + e.message);
+      }
+    });
+
+    valueWrap.style.borderColor = "black";
+    valueWrap.style.borderStyle = "solid";
+    valueWrap.style.display = "block";
+    valueWrap.style.position = "absolute";
+
+    if (/^(submit|reset|button|text|password)$/.test(el.type) || el.nodeName === "SELECT"){
+      valueWrap.style.lineHeight = getCSS(el, "height");
+    }
+
+    valueWrap.style.top = bounds.top + "px";
+    valueWrap.style.left = bounds.left + "px";
+
+    textValue = (el.nodeName === "SELECT") ? (el.options[el.selectedIndex] || 0).text : el.value;
+    if(!textValue) {
+      textValue = el.placeholder;
+    }
+
+    textNode = doc.createTextNode(textValue);
+
+    valueWrap.appendChild(textNode);
+    body.appendChild(valueWrap);
+
+    renderText(el, textNode, stack);
+    body.removeChild(valueWrap);
+  }
+
+  function drawImage (ctx) {
+    ctx.drawImage.apply(ctx, Array.prototype.slice.call(arguments, 1));
+    numDraws+=1;
+  }
+
+  function getPseudoElement(el, which) {
+    var elStyle = window.getComputedStyle(el, which);
+    var parentStyle = window.getComputedStyle(el);
+    // If no content attribute is present, the pseudo element is hidden,
+    // or the parent has a content property equal to the content on the pseudo element,
+    // move along.
+    if(!elStyle || !elStyle.content || elStyle.content === "none" || elStyle.content === "-moz-alt-content" ||
+       elStyle.display === "none" || parentStyle.content === elStyle.content) {
+      return;
+    }
+    var content = elStyle.content + '';
+
+    // Strip inner quotes
+    if(content[0] === "'" || content[0] === "\"") {
+      content = content.replace(/(^['"])|(['"]$)/g, '');
+    }
+
+    var isImage = content.substr( 0, 3 ) === 'url',
+    elps = document.createElement( isImage ? 'img' : 'span' );
+
+    elps.className = pseudoHide + "-element ";
+
+    Object.keys(elStyle).filter(indexedProperty).forEach(function(prop) {
+      // Prevent assigning of read only CSS Rules, ex. length, parentRule
+      try {
+        elps.style[prop] = elStyle[prop];
+      } catch (e) {
+        Util.log(['Tried to assign readonly property ', prop, 'Error:', e]);
+      }
+    });
+
+    if(isImage) {
+      elps.src = Util.parseBackgroundImage(content)[0].args[0];
+    } else {
+      elps.innerHTML = content;
+    }
+    return elps;
+  }
+
+  function indexedProperty(property) {
+    return (isNaN(window.parseInt(property, 10)));
+  }
+
+  function renderBackgroundRepeat(ctx, image, backgroundPosition, bounds) {
+    var offsetX = Math.round(bounds.left + backgroundPosition.left),
+    offsetY = Math.round(bounds.top + backgroundPosition.top);
+
+    ctx.createPattern(image);
+    ctx.translate(offsetX, offsetY);
+    ctx.fill();
+    ctx.translate(-offsetX, -offsetY);
+  }
+
+  function backgroundRepeatShape(ctx, image, backgroundPosition, bounds, left, top, width, height) {
+    var args = [];
+    args.push(["line", Math.round(left), Math.round(top)]);
+    args.push(["line", Math.round(left + width), Math.round(top)]);
+    args.push(["line", Math.round(left + width), Math.round(height + top)]);
+    args.push(["line", Math.round(left), Math.round(height + top)]);
+    createShape(ctx, args);
+    ctx.save();
+    ctx.clip();
+    renderBackgroundRepeat(ctx, image, backgroundPosition, bounds);
+    ctx.restore();
+  }
+
+  function renderBackgroundColor(ctx, backgroundBounds, bgcolor) {
+    renderRect(
+      ctx,
+      backgroundBounds.left,
+      backgroundBounds.top,
+      backgroundBounds.width,
+      backgroundBounds.height,
+      bgcolor
+      );
+  }
+
+  function renderBackgroundRepeating(el, bounds, ctx, image, imageIndex) {
+    var backgroundSize = Util.BackgroundSize(el, bounds, image, imageIndex),
+    backgroundPosition = Util.BackgroundPosition(el, bounds, image, imageIndex, backgroundSize),
+    backgroundRepeat = Util.BackgroundRepeat(el, imageIndex);
+
+    image = resizeImage(image, backgroundSize);
+
+    switch (backgroundRepeat) {
+      case "repeat-x":
+      case "repeat no-repeat":
+        backgroundRepeatShape(ctx, image, backgroundPosition, bounds,
+          bounds.left, bounds.top + backgroundPosition.top, 99999, image.height);
+        break;
+      case "repeat-y":
+      case "no-repeat repeat":
+        backgroundRepeatShape(ctx, image, backgroundPosition, bounds,
+          bounds.left + backgroundPosition.left, bounds.top, image.width, 99999);
+        break;
+      case "no-repeat":
+        backgroundRepeatShape(ctx, image, backgroundPosition, bounds,
+          bounds.left + backgroundPosition.left, bounds.top + backgroundPosition.top, image.width, image.height);
+        break;
+      default:
+        renderBackgroundRepeat(ctx, image, backgroundPosition, {
+          top: bounds.top,
+          left: bounds.left,
+          width: image.width,
+          height: image.height
+        });
+        break;
+    }
+  }
+
+  function renderBackgroundImage(element, bounds, ctx) {
+    var backgroundImage = getCSS(element, "backgroundImage"),
+    backgroundImages = Util.parseBackgroundImage(backgroundImage),
+    image,
+    imageIndex = backgroundImages.length;
+
+    while(imageIndex--) {
+      backgroundImage = backgroundImages[imageIndex];
+
+      if (!backgroundImage.args || backgroundImage.args.length === 0) {
+        continue;
+      }
+
+      var key = backgroundImage.method === 'url' ?
+      backgroundImage.args[0] :
+      backgroundImage.value;
+
+      image = loadImage(key);
+
+      // TODO add support for background-origin
+      if (image) {
+        renderBackgroundRepeating(element, bounds, ctx, image, imageIndex);
+      } else {
+        Util.log("html2canvas: Error loading background:", backgroundImage);
+      }
+    }
+  }
+
+  function resizeImage(image, bounds) {
+    if(image.width === bounds.width && image.height === bounds.height) {
+      return image;
+    }
+
+    var ctx, canvas = doc.createElement('canvas');
+    canvas.width = bounds.width;
+    canvas.height = bounds.height;
+    ctx = canvas.getContext("2d");
+    drawImage(ctx, image, 0, 0, image.width, image.height, 0, 0, bounds.width, bounds.height );
+    return canvas;
+  }
+
+  function setOpacity(ctx, element, parentStack) {
+    return ctx.setVariable("globalAlpha", getCSS(element, "opacity") * ((parentStack) ? parentStack.opacity : 1));
+  }
+
+  function removePx(str) {
+    return str.replace("px", "");
+  }
+
+  function getTransform(element, parentStack) {
+    var transformRegExp = /(matrix)\((.+)\)/;
+    var transform = getCSS(element, "transform") || getCSS(element, "-webkit-transform") || getCSS(element, "-moz-transform") || getCSS(element, "-ms-transform") || getCSS(element, "-o-transform");
+    var transformOrigin = getCSS(element, "transform-origin") || getCSS(element, "-webkit-transform-origin") || getCSS(element, "-moz-transform-origin") || getCSS(element, "-ms-transform-origin") || getCSS(element, "-o-transform-origin") || "0px 0px";
+
+    transformOrigin = transformOrigin.split(" ").map(removePx).map(Util.asFloat);
+
+    var matrix;
+    if (transform && transform !== "none") {
+      var match = transform.match(transformRegExp);
+      if (match) {
+        switch(match[1]) {
+          case "matrix":
+            matrix = match[2].split(",").map(Util.trimText).map(Util.asFloat);
+            break;
+        }
+      }
+    }
+
+    return {
+      origin: transformOrigin,
+      matrix: matrix
+    };
+  }
+
+  function createStack(element, parentStack, bounds, transform) {
+    var ctx = h2cRenderContext((!parentStack) ? documentWidth() : bounds.width , (!parentStack) ? documentHeight() : bounds.height),
+    stack = {
+      ctx: ctx,
+      opacity: setOpacity(ctx, element, parentStack),
+      cssPosition: getCSS(element, "position"),
+      borders: getBorderData(element),
+      transform: transform,
+      clip: (parentStack && parentStack.clip) ? Util.Extend( {}, parentStack.clip ) : null
+    };
+
+    setZ(element, stack, parentStack);
+
+    // TODO correct overflow for absolute content residing under a static position
+    if (options.useOverflow === true && /(hidden|scroll|auto)/.test(getCSS(element, "overflow")) === true && /(BODY)/i.test(element.nodeName) === false){
+      stack.clip = (stack.clip) ? clipBounds(stack.clip, bounds) : bounds;
+    }
+
+    return stack;
+  }
+
+  function getBackgroundBounds(borders, bounds, clip) {
+    var backgroundBounds = {
+      left: bounds.left + borders[3].width,
+      top: bounds.top + borders[0].width,
+      width: bounds.width - (borders[1].width + borders[3].width),
+      height: bounds.height - (borders[0].width + borders[2].width)
+    };
+
+    if (clip) {
+      backgroundBounds = clipBounds(backgroundBounds, clip);
+    }
+
+    return backgroundBounds;
+  }
+
+  function getBounds(element, transform) {
+    var bounds = (transform.matrix) ? Util.OffsetBounds(element) : Util.Bounds(element);
+    transform.origin[0] += bounds.left;
+    transform.origin[1] += bounds.top;
+    return bounds;
+  }
+
+  function renderElement(element, parentStack, ignoreBackground) {
+    var transform = getTransform(element, parentStack),
+    bounds = getBounds(element, transform),
+    image,
+    stack = createStack(element, parentStack, bounds, transform),
+    borders = stack.borders,
+    ctx = stack.ctx,
+    backgroundBounds = getBackgroundBounds(borders, bounds, stack.clip),
+    borderData = parseBorders(element, bounds, borders),
+    backgroundColor = (ignoreElementsRegExp.test(element.nodeName)) ? "#efefef" : getCSS(element, "backgroundColor");
+
+
+    createShape(ctx, borderData.clip);
+
+    ctx.save();
+    ctx.clip();
+
+    if (backgroundBounds.height > 0 && backgroundBounds.width > 0 && !ignoreBackground) {
+      renderBackgroundColor(ctx, bounds, backgroundColor);
+      renderBackgroundImage(element, backgroundBounds, ctx);
+    } else if (ignoreBackground) {
+      stack.backgroundColor =  backgroundColor;
+    }
+
+    ctx.restore();
+
+    borderData.borders.forEach(function(border) {
+      renderBorders(ctx, border.args, border.color);
+    });
+
+    switch(element.nodeName){
+      case "IMG":
+        if ((image = loadImage(element.getAttribute('src')))) {
+          renderImage(ctx, element, image, bounds, borders);
+        } else {
+          Util.log("html2canvas: Error loading <img>:" + element.getAttribute('src'));
+        }
+        break;
+      case "INPUT":
+        // TODO add all relevant type's, i.e. HTML5 new stuff
+        // todo add support for placeholder attribute for browsers which support it
+        if (/^(text|url|email|submit|button|reset)$/.test(element.type) && (element.value || element.placeholder || "").length > 0){
+          renderFormValue(element, bounds, stack);
+        }
+        break;
+      case "TEXTAREA":
+        if ((element.value || element.placeholder || "").length > 0){
+          renderFormValue(element, bounds, stack);
+        }
+        break;
+      case "SELECT":
+        if ((element.options||element.placeholder || "").length > 0){
+          renderFormValue(element, bounds, stack);
+        }
+        break;
+      case "LI":
+        renderListItem(element, stack, backgroundBounds);
+        break;
+      case "CANVAS":
+        renderImage(ctx, element, element, bounds, borders);
+        break;
+    }
+
+    return stack;
+  }
+
+  function isElementVisible(element) {
+    return (getCSS(element, 'display') !== "none" && getCSS(element, 'visibility') !== "hidden" && !element.hasAttribute("data-html2canvas-ignore"));
+  }
+
+  function parseElement (element, stack, cb) {
+    if (!cb) {
+      cb = function(){};
+    }
+    if (isElementVisible(element)) {
+      stack = renderElement(element, stack, false) || stack;
+      if (!ignoreElementsRegExp.test(element.nodeName)) {
+        return parseChildren(element, stack, cb);
+      }
+    }
+    cb();
+  }
+
+  function parseChildren(element, stack, cb) {
+    var children = Util.Children(element);
+    // After all nodes have processed, finished() will call the cb.
+    // We add one and kick it off so this will still work when children.length === 0.
+    // Note that unless async is true, this will happen synchronously, just will callbacks.
+    var jobs = children.length + 1;
+    finished();
+
+    if (options.async) {
+      children.forEach(function(node) {
+        // Don't block the page from rendering
+        setTimeout(function(){ parseNode(node); }, 0);
+      });
+    } else {
+      children.forEach(parseNode);
+    }
+
+    function parseNode(node) {
+      if (node.nodeType === node.ELEMENT_NODE) {
+        parseElement(node, stack, finished);
+      } else if (node.nodeType === node.TEXT_NODE) {
+        renderText(element, node, stack);
+        finished();
+      } else {
+        finished();
+      }
+    }
+    function finished(el) {
+      if (--jobs <= 0){
+        Util.log("finished rendering " + children.length + " children.");
+        cb();
+      }
+    }
+  }
+};
+_html2canvas.Preload = function( options ) {
+
+  var images = {
+    numLoaded: 0,   // also failed are counted here
+    numFailed: 0,
+    numTotal: 0,
+    cleanupDone: false
+  },
+  pageOrigin,
+  Util = _html2canvas.Util,
+  methods,
+  i,
+  count = 0,
+  element = options.elements[0] || document.body,
+  doc = element.ownerDocument,
+  domImages = element.getElementsByTagName('img'), // Fetch images of the present element only
+  imgLen = domImages.length,
+  link = doc.createElement("a"),
+  supportCORS = (function( img ){
+    return (img.crossOrigin !== undefined);
+  })(new Image()),
+  timeoutTimer;
+
+  link.href = window.location.href;
+  pageOrigin  = link.protocol + link.host;
+
+  function isSameOrigin(url){
+    link.href = url;
+    link.href = link.href; // YES, BELIEVE IT OR NOT, that is required for IE9 - http://jsfiddle.net/niklasvh/2e48b/
+    var origin = link.protocol + link.host;
+    return (origin === pageOrigin);
+  }
+
+  function start(){
+    Util.log("html2canvas: start: images: " + images.numLoaded + " / " + images.numTotal + " (failed: " + images.numFailed + ")");
+    if (!images.firstRun && images.numLoaded >= images.numTotal){
+      Util.log("Finished loading images: # " + images.numTotal + " (failed: " + images.numFailed + ")");
+
+      if (typeof options.complete === "function"){
+        options.complete(images);
+      }
+
+    }
+  }
+
+  // TODO modify proxy to serve images with CORS enabled, where available
+  function proxyGetImage(url, img, imageObj){
+    var callback_name,
+    scriptUrl = options.proxy,
+    script;
+
+    link.href = url;
+    url = link.href; // work around for pages with base href="" set - WARNING: this may change the url
+
+    callback_name = 'html2canvas_' + (count++);
+    imageObj.callbackname = callback_name;
+
+    if (scriptUrl.indexOf("?") > -1) {
+      scriptUrl += "&";
+    } else {
+      scriptUrl += "?";
+    }
+    scriptUrl += 'url=' + encodeURIComponent(url) + '&callback=' + callback_name;
+    script = doc.createElement("script");
+
+    window[callback_name] = function(a){
+      if (a.substring(0,6) === "error:"){
+        imageObj.succeeded = false;
+        images.numLoaded++;
+        images.numFailed++;
+        start();
+      } else {
+        setImageLoadHandlers(img, imageObj);
+        img.src = a;
+      }
+      window[callback_name] = undefined; // to work with IE<9  // NOTE: that the undefined callback property-name still exists on the window object (for IE<9)
+      try {
+        delete window[callback_name];  // for all browser that support this
+      } catch(ex) {}
+      script.parentNode.removeChild(script);
+      script = null;
+      delete imageObj.script;
+      delete imageObj.callbackname;
+    };
+
+    script.setAttribute("type", "text/javascript");
+    script.setAttribute("src", scriptUrl);
+    imageObj.script = script;
+    window.document.body.appendChild(script);
+
+  }
+
+  function loadPseudoElement(element, type) {
+    var style = window.getComputedStyle(element, type),
+    content = style.content;
+    if (content.substr(0, 3) === 'url') {
+      methods.loadImage(_html2canvas.Util.parseBackgroundImage(content)[0].args[0]);
+    }
+    loadBackgroundImages(style.backgroundImage, element);
+  }
+
+  function loadPseudoElementImages(element) {
+    loadPseudoElement(element, ":before");
+    loadPseudoElement(element, ":after");
+  }
+
+  function loadGradientImage(backgroundImage, bounds) {
+    var img = _html2canvas.Generate.Gradient(backgroundImage, bounds);
+
+    if (img !== undefined){
+      images[backgroundImage] = {
+        img: img,
+        succeeded: true
+      };
+      images.numTotal++;
+      images.numLoaded++;
+      start();
+    }
+  }
+
+  function invalidBackgrounds(background_image) {
+    return (background_image && background_image.method && background_image.args && background_image.args.length > 0 );
+  }
+
+  function loadBackgroundImages(background_image, el) {
+    var bounds;
+
+    _html2canvas.Util.parseBackgroundImage(background_image).filter(invalidBackgrounds).forEach(function(background_image) {
+      if (background_image.method === 'url') {
+        methods.loadImage(background_image.args[0]);
+      } else if(background_image.method.match(/\-?gradient$/)) {
+        if(bounds === undefined) {
+          bounds = _html2canvas.Util.Bounds(el);
+        }
+        loadGradientImage(background_image.value, bounds);
+      }
+    });
+  }
+
+  function getImages (el) {
+    var elNodeType = false;
+
+    // Firefox fails with permission denied on pages with iframes
+    try {
+      Util.Children(el).forEach(getImages);
+    }
+    catch( e ) {}
+
+    try {
+      elNodeType = el.nodeType;
+    } catch (ex) {
+      elNodeType = false;
+      Util.log("html2canvas: failed to access some element's nodeType - Exception: " + ex.message);
+    }
+
+    if (elNodeType === 1 || elNodeType === undefined) {
+      loadPseudoElementImages(el);
+      try {
+        loadBackgroundImages(Util.getCSS(el, 'backgroundImage'), el);
+      } catch(e) {
+        Util.log("html2canvas: failed to get background-image - Exception: " + e.message);
+      }
+      loadBackgroundImages(el);
+    }
+  }
+
+  function setImageLoadHandlers(img, imageObj) {
+    img.onload = function() {
+      if ( imageObj.timer !== undefined ) {
+        // CORS succeeded
+        window.clearTimeout( imageObj.timer );
+      }
+
+      images.numLoaded++;
+      imageObj.succeeded = true;
+      img.onerror = img.onload = null;
+      start();
+    };
+    img.onerror = function() {
+      if (img.crossOrigin === "anonymous") {
+        // CORS failed
+        window.clearTimeout( imageObj.timer );
+
+        // let's try with proxy instead
+        if ( options.proxy ) {
+          var src = img.src;
+          img = new Image();
+          imageObj.img = img;
+          img.src = src;
+
+          proxyGetImage( img.src, img, imageObj );
+          return;
+        }
+      }
+
+      images.numLoaded++;
+      images.numFailed++;
+      imageObj.succeeded = false;
+      img.onerror = img.onload = null;
+      start();
+    };
+  }
+
+  methods = {
+    loadImage: function( src ) {
+      var img, imageObj;
+      if ( src && images[src] === undefined ) {
+        img = new Image();
+        if ( src.match(/data:image\/.*;base64,/i) ) {
+          img.src = src.replace(/url\(['"]{0,}|['"]{0,}\)$/ig, '');
+          imageObj = images[src] = {
+            img: img
+          };
+          images.numTotal++;
+          setImageLoadHandlers(img, imageObj);
+        } else if ( isSameOrigin( src ) || options.allowTaint ===  true ) {
+          imageObj = images[src] = {
+            img: img
+          };
+          images.numTotal++;
+          setImageLoadHandlers(img, imageObj);
+          img.src = src;
+        } else if ( supportCORS && !options.allowTaint && options.useCORS ) {
+          // attempt to load with CORS
+
+          img.crossOrigin = "anonymous";
+          imageObj = images[src] = {
+            img: img
+          };
+          images.numTotal++;
+          setImageLoadHandlers(img, imageObj);
+          img.src = src;
+        } else if ( options.proxy ) {
+          imageObj = images[src] = {
+            img: img
+          };
+          images.numTotal++;
+          proxyGetImage( src, img, imageObj );
+        }
+      }
+
+    },
+    cleanupDOM: function(cause) {
+      var img, src;
+      if (!images.cleanupDone) {
+        if (cause && typeof cause === "string") {
+          Util.log("html2canvas: Cleanup because: " + cause);
+        } else {
+          Util.log("html2canvas: Cleanup after timeout: " + options.timeout + " ms.");
+        }
+
+        for (src in images) {
+          if (images.hasOwnProperty(src)) {
+            img = images[src];
+            if (typeof img === "object" && img.callbackname && img.succeeded === undefined) {
+              // cancel proxy image request
+              window[img.callbackname] = undefined; // to work with IE<9  // NOTE: that the undefined callback property-name still exists on the window object (for IE<9)
+              try {
+                delete window[img.callbackname];  // for all browser that support this
+              } catch(ex) {}
+              if (img.script && img.script.parentNode) {
+                img.script.setAttribute("src", "about:blank");  // try to cancel running request
+                img.script.parentNode.removeChild(img.script);
+              }
+              images.numLoaded++;
+              images.numFailed++;
+              Util.log("html2canvas: Cleaned up failed img: '" + src + "' Steps: " + images.numLoaded + " / " + images.numTotal);
+            }
+          }
+        }
+
+        // cancel any pending requests
+        if(window.stop !== undefined) {
+          window.stop();
+        } else if(document.execCommand !== undefined) {
+          document.execCommand("Stop", false);
+        }
+        if (document.close !== undefined) {
+          document.close();
+        }
+        images.cleanupDone = true;
+        if (!(cause && typeof cause === "string")) {
+          start();
+        }
+      }
+    },
+
+    renderingDone: function() {
+      if (timeoutTimer) {
+        window.clearTimeout(timeoutTimer);
+      }
+    }
+  };
+
+  if (options.timeout > 0) {
+    timeoutTimer = window.setTimeout(methods.cleanupDOM, options.timeout);
+  }
+
+  Util.log('html2canvas: Preload starts: finding background-images');
+  images.firstRun = true;
+
+  getImages(element);
+
+  Util.log('html2canvas: Preload: Finding images');
+  // load <img> images
+  for (i = 0; i < imgLen; i+=1){
+    methods.loadImage( domImages[i].getAttribute( "src" ) );
+  }
+
+  images.firstRun = false;
+  Util.log('html2canvas: Preload: Done.');
+  if (images.numTotal === images.numLoaded) {
+    start();
+  }
+
+  return methods;
+};
+
+_html2canvas.Renderer = function(parseQueue, options){
+  function sortZindex(a, b) {
+    if (a === 'children') {
+      return -1;
+    } else if (b === 'children') {
+      return 1;
+    } else {
+      return a - b;
+    }
+  }
+
+  // http://www.w3.org/TR/CSS21/zindex.html
+  function createRenderQueue(parseQueue) {
+    var queue = [],
+    rootContext;
+
+    rootContext = (function buildStackingContext(rootNode) {
+      var rootContext = {};
+      function insert(context, node, specialParent) {
+        var zi = (node.zIndex.zindex === 'auto') ? 0 : Number(node.zIndex.zindex),
+        contextForChildren = context, // the stacking context for children
+        isPositioned = node.zIndex.isPositioned,
+        isFloated = node.zIndex.isFloated,
+        stub = {node: node},
+        childrenDest = specialParent; // where children without z-index should be pushed into
+
+        if (node.zIndex.ownStacking) {
+          contextForChildren = stub.context = {
+              children: [{node:node, children: []}]
+          };
+          childrenDest = undefined;
+        } else if (isPositioned || isFloated) {
+          childrenDest = stub.children = [];
+        }
+
+        if (zi === 0 && specialParent) {
+          specialParent.push(stub);
+        } else {
+          if (!context[zi]) { context[zi] = []; }
+          context[zi].push(stub);
+        }
+
+        node.zIndex.children.forEach(function(childNode) {
+          insert(contextForChildren, childNode, childrenDest);
+        });
+      }
+      insert(rootContext, rootNode);
+      return rootContext;
+    })(parseQueue);
+
+    function sortZ(context) {
+      Object.keys(context).sort(sortZindex).forEach(function(zi) {
+        var nonPositioned = [],
+        floated = [],
+        positioned = [],
+        list = [];
+
+        // positioned after static
+        context[zi].forEach(function(v) {
+          if (v.node.zIndex.isPositioned || v.node.zIndex.opacity < 1) {
+            // http://www.w3.org/TR/css3-color/#transparency
+            // non-positioned element with opactiy < 1 should be stacked as if it were a positioned element with ‘z-index: 0’ and ‘opacity: 1’.
+            positioned.push(v);
+          } else if (v.node.zIndex.isFloated) {
+            floated.push(v);
+          } else {
+            nonPositioned.push(v);
+          }
+        });
+
+        (function walk(arr) {
+          arr.forEach(function(v) {
+            list.push(v);
+            if (v.children) { walk(v.children); }
+          });
+        })(nonPositioned.concat(floated, positioned));
+
+        list.forEach(function(v) {
+          if (v.context) {
+            sortZ(v.context);
+          } else {
+            queue.push(v.node);
+          }
+        });
+      });
+    }
+
+    sortZ(rootContext);
+
+    return queue;
+  }
+
+  function getRenderer(rendererName) {
+    var renderer;
+
+    if (typeof options.renderer === "string" && _html2canvas.Renderer[rendererName] !== undefined) {
+      renderer = _html2canvas.Renderer[rendererName](options);
+    } else if (typeof rendererName === "function") {
+      renderer = rendererName(options);
+    } else {
+      throw new Error("Unknown renderer");
+    }
+
+    if ( typeof renderer !== "function" ) {
+      throw new Error("Invalid renderer defined");
+    }
+    return renderer;
+  }
+
+  return getRenderer(options.renderer)(parseQueue, options, document, createRenderQueue(parseQueue.stack), _html2canvas);
+};
+
+_html2canvas.Util.Support = function (options, doc) {
+
+  function supportSVGRendering() {
+    var img = new Image(),
+    canvas = doc.createElement("canvas"),
+    ctx = (canvas.getContext === undefined) ? false : canvas.getContext("2d");
+    if (ctx === false) {
+      return false;
+    }
+    canvas.width = canvas.height = 10;
+    img.src = [
+    "data:image/svg+xml,",
+    "<svg xmlns='http://www.w3.org/2000/svg' width='10' height='10'>",
+    "<foreignObject width='10' height='10'>",
+    "<div xmlns='http://www.w3.org/1999/xhtml' style='width:10;height:10;'>",
+    "sup",
+    "</div>",
+    "</foreignObject>",
+    "</svg>"
+    ].join("");
+    try {
+      ctx.drawImage(img, 0, 0);
+      canvas.toDataURL();
+    } catch(e) {
+      return false;
+    }
+    _html2canvas.Util.log('html2canvas: Parse: SVG powered rendering available');
+    return true;
+  }
+
+  // Test whether we can use ranges to measure bounding boxes
+  // Opera doesn't provide valid bounds.height/bottom even though it supports the method.
+
+  function supportRangeBounds() {
+    var r, testElement, rangeBounds, rangeHeight, support = false;
+
+    if (doc.createRange) {
+      r = doc.createRange();
+      if (r.getBoundingClientRect) {
+        testElement = doc.createElement('boundtest');
+        testElement.style.height = "123px";
+        testElement.style.display = "block";
+        doc.body.appendChild(testElement);
+
+        r.selectNode(testElement);
+        rangeBounds = r.getBoundingClientRect();
+        rangeHeight = rangeBounds.height;
+
+        if (rangeHeight === 123) {
+          support = true;
+        }
+        doc.body.removeChild(testElement);
+      }
+    }
+
+    return support;
+  }
+
+  return {
+    rangeBounds: supportRangeBounds(),
+    svgRendering: options.svgRendering && supportSVGRendering()
+  };
+};
+window.html2canvas = function(elements, opts) {
+  elements = (elements.length) ? elements : [elements];
+  var queue,
+  canvas,
+  options = {
+    // general
+    logging: false,
+    elements: elements,
+    background: "#fff",
+
+    // preload options
+    proxy: null,
+    timeout: 0,    // no timeout
+    useCORS: false, // try to load images as CORS (where available), before falling back to proxy
+    allowTaint: false, // whether to allow images to taint the canvas, won't need proxy if set to true
+
+    // parse options
+    svgRendering: false, // use svg powered rendering where available (FF11+)
+    ignoreElements: "IFRAME|OBJECT|PARAM",
+    useOverflow: true,
+    letterRendering: false,
+    chinese: false,
+    async: false, // If true, parsing will not block, but if the user scrolls during parse the image can get weird
+
+    // render options
+    width: null,
+    height: null,
+    taintTest: true, // do a taint test with all images before applying to canvas
+    renderer: "Canvas"
+  };
+
+  options = _html2canvas.Util.Extend(opts, options);
+
+  _html2canvas.logging = options.logging;
+  options.complete = function( images ) {
+
+    if (typeof options.onpreloaded === "function") {
+      if ( options.onpreloaded( images ) === false ) {
+        return;
+      }
+    }
+    _html2canvas.Parse( images, options, function(queue) {
+      if (typeof options.onparsed === "function") {
+        if ( options.onparsed( queue ) === false ) {
+          return;
+        }
+      }
+
+      canvas = _html2canvas.Renderer( queue, options );
+
+      if (typeof options.onrendered === "function") {
+        options.onrendered( canvas );
+      }
+    });
+  };
+
+  // for pages without images, we still want this to be async, i.e. return methods before executing
+  window.setTimeout( function(){
+    _html2canvas.Preload( options );
+  }, 0 );
+
+  return {
+    render: function( queue, opts ) {
+      return _html2canvas.Renderer( queue, _html2canvas.Util.Extend(opts, options) );
+    },
+    parse: function( images, opts ) {
+      return _html2canvas.Parse( images, _html2canvas.Util.Extend(opts, options) );
+    },
+    preload: function( opts ) {
+      return _html2canvas.Preload( _html2canvas.Util.Extend(opts, options) );
+    },
+    log: _html2canvas.Util.log
+  };
+};
+
+window.html2canvas.log = _html2canvas.Util.log; // for renderers
+window.html2canvas.Renderer = {
+  Canvas: undefined // We are assuming this will be used
+};
+_html2canvas.Renderer.Canvas = function(options) {
+  options = options || {};
+
+  var doc = document,
+  safeImages = [],
+  testCanvas = document.createElement("canvas"),
+  testctx = testCanvas.getContext("2d"),
+  Util = _html2canvas.Util,
+  canvas = options.canvas || doc.createElement('canvas');
+
+  function createShape(ctx, args) {
+    ctx.beginPath();
+    args.forEach(function(arg) {
+      ctx[arg.name].apply(ctx, arg['arguments']);
+    });
+    ctx.closePath();
+  }
+
+  function safeImage(item) {
+    if (safeImages.indexOf(item['arguments'][0].src) === -1) {
+      testctx.drawImage(item['arguments'][0], 0, 0);
+      try {
+        testctx.getImageData(0, 0, 1, 1);
+      } catch(e) {
+        testCanvas = doc.createElement("canvas");
+        testctx = testCanvas.getContext("2d");
+        return false;
+      }
+      safeImages.push(item['arguments'][0].src);
+    }
+    return true;
+  }
+
+  function renderItem(ctx, item) {
+    switch(item.type){
+      case "variable":
+        ctx[item.name] = item['arguments'];
+        break;
+      case "function":
+        switch(item.name) {
+          case "createPattern":
+            if (item['arguments'][0].width > 0 && item['arguments'][0].height > 0) {
+              try {
+                ctx.fillStyle = ctx.createPattern(item['arguments'][0], "repeat");
+              } catch(e) {
+                Util.log("html2canvas: Renderer: Error creating pattern", e.message);
+              }
+            }
+            break;
+          case "drawShape":
+            createShape(ctx, item['arguments']);
+            break;
+          case "drawImage":
+            if (item['arguments'][8] > 0 && item['arguments'][7] > 0) {
+              if (!options.taintTest || (options.taintTest && safeImage(item))) {
+                ctx.drawImage.apply( ctx, item['arguments'] );
+              }
+            }
+            break;
+          default:
+            ctx[item.name].apply(ctx, item['arguments']);
+        }
+        break;
+    }
+  }
+
+  return function(parsedData, options, document, queue, _html2canvas) {
+    var ctx = canvas.getContext("2d"),
+    newCanvas,
+    bounds,
+    fstyle,
+    zStack = parsedData.stack;
+
+    canvas.width = canvas.style.width =  options.width || zStack.ctx.width;
+    canvas.height = canvas.style.height = options.height || zStack.ctx.height;
+
+    fstyle = ctx.fillStyle;
+    ctx.fillStyle = (Util.isTransparent(parsedData.backgroundColor) && options.background !== undefined) ? options.background : parsedData.backgroundColor;
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    ctx.fillStyle = fstyle;
+    queue.forEach(function(storageContext) {
+      // set common settings for canvas
+      ctx.textBaseline = "bottom";
+      ctx.save();
+
+      if (storageContext.transform.matrix) {
+        ctx.translate(storageContext.transform.origin[0], storageContext.transform.origin[1]);
+        ctx.transform.apply(ctx, storageContext.transform.matrix);
+        ctx.translate(-storageContext.transform.origin[0], -storageContext.transform.origin[1]);
+      }
+
+      if (storageContext.clip){
+        ctx.beginPath();
+        ctx.rect(storageContext.clip.left, storageContext.clip.top, storageContext.clip.width, storageContext.clip.height);
+        ctx.clip();
+      }
+
+      if (storageContext.ctx.storage) {
+        storageContext.ctx.storage.forEach(function(item) {
+          renderItem(ctx, item);
+        });
+      }
+
+      ctx.restore();
+    });
+
+    Util.log("html2canvas: Renderer: Canvas renderer done - returning canvas obj");
+
+    if (options.elements.length === 1) {
+      if (typeof options.elements[0] === "object" && options.elements[0].nodeName !== "BODY") {
+        // crop image to the bounds of selected (single) element
+        bounds = _html2canvas.Util.Bounds(options.elements[0]);
+        newCanvas = document.createElement('canvas');
+        
+
+	    newCanvas.width = Math.ceil(bounds.width);
+        newCanvas.height = Math.ceil(bounds.height);
+   
+	  ctx = newCanvas.getContext("2d");
+      ctx.drawImage(canvas, bounds.left, bounds.top, bounds.width, bounds.height, 0, 0, bounds.width, bounds.height);
+
+		
+		
+		canvas = null;
+        return newCanvas;
+      }
+    }
+
+    return canvas;
+  };
+};
+})(window,document);
@@ -0,0 +1,190 @@
+/*jslint adsafe: false, bitwise: true, browser: true, cap: false, css: false,
+  debug: false, devel: true, eqeqeq: true, es5: false, evil: false,
+  forin: false, fragment: false, immed: true, laxbreak: false, newcap: true,
+  nomen: false, on: false, onevar: true, passfail: false, plusplus: true,
+  regexp: false, rhino: true, safe: false, strict: false, sub: false,
+  undef: true, white: false, widget: false, windows: false */
+/*global jQuery: false, window: false */
+//"use strict";
+
+/*
+ * Original code (c) 2010 Nick Galbreath
+ * http://code.google.com/p/stringencoders/source/browse/#svn/trunk/javascript
+ *
+ * jQuery port (c) 2010 Carlo Zottmann
+ * http://github.com/carlo/jquery-base64
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/* base64 encode/decode compatible with window.btoa/atob
+ *
+ * window.atob/btoa is a Firefox extension to convert binary data (the "b")
+ * to base64 (ascii, the "a").
+ *
+ * It is also found in Safari and Chrome.  It is not available in IE.
+ *
+ * if (!window.btoa) window.btoa = $.base64.encode
+ * if (!window.atob) window.atob = $.base64.decode
+ *
+ * The original spec's for atob/btoa are a bit lacking
+ * https://developer.mozilla.org/en/DOM/window.atob
+ * https://developer.mozilla.org/en/DOM/window.btoa
+ *
+ * window.btoa and $.base64.encode takes a string where charCodeAt is [0,255]
+ * If any character is not [0,255], then an exception is thrown.
+ *
+ * window.atob and $.base64.decode take a base64-encoded string
+ * If the input length is not a multiple of 4, or contains invalid characters
+ *   then an exception is thrown.
+ */
+ 
+jQuery.base64 = ( function( $ ) {
+  
+  var _PADCHAR = "=",
+    _ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+    _VERSION = "1.0";
+
+
+  function _getbyte64( s, i ) {
+    // This is oddly fast, except on Chrome/V8.
+    // Minimal or no improvement in performance by using a
+    // object with properties mapping chars to value (eg. 'A': 0)
+
+    var idx = _ALPHA.indexOf( s.charAt( i ) );
+
+    if ( idx === -1 ) {
+      throw "Cannot decode base64";
+    }
+
+    return idx;
+  }
+  
+  
+  function _decode( s ) {
+    var pads = 0,
+      i,
+      b10,
+      imax = s.length,
+      x = [];
+
+    s = String( s );
+    
+    if ( imax === 0 ) {
+      return s;
+    }
+
+    if ( imax % 4 !== 0 ) {
+      throw "Cannot decode base64";
+    }
+
+    if ( s.charAt( imax - 1 ) === _PADCHAR ) {
+      pads = 1;
+
+      if ( s.charAt( imax - 2 ) === _PADCHAR ) {
+        pads = 2;
+      }
+
+      // either way, we want to ignore this last block
+      imax -= 4;
+    }
+
+    for ( i = 0; i < imax; i += 4 ) {
+      b10 = ( _getbyte64( s, i ) << 18 ) | ( _getbyte64( s, i + 1 ) << 12 ) | ( _getbyte64( s, i + 2 ) << 6 ) | _getbyte64( s, i + 3 );
+      x.push( String.fromCharCode( b10 >> 16, ( b10 >> 8 ) & 0xff, b10 & 0xff ) );
+    }
+
+    switch ( pads ) {
+      case 1:
+        b10 = ( _getbyte64( s, i ) << 18 ) | ( _getbyte64( s, i + 1 ) << 12 ) | ( _getbyte64( s, i + 2 ) << 6 );
+        x.push( String.fromCharCode( b10 >> 16, ( b10 >> 8 ) & 0xff ) );
+        break;
+
+      case 2:
+        b10 = ( _getbyte64( s, i ) << 18) | ( _getbyte64( s, i + 1 ) << 12 );
+        x.push( String.fromCharCode( b10 >> 16 ) );
+        break;
+    }
+
+    return x.join( "" );
+  }
+  
+  
+  function _getbyte( s, i ) {
+    var x = s.charCodeAt( i );
+
+    if ( x > 255 ) {
+      throw "INVALID_CHARACTER_ERR: DOM Exception 5";
+    }
+    
+    return x;
+  }
+
+
+  function _encode( s ) {
+    if ( arguments.length !== 1 ) {
+      throw "SyntaxError: exactly one argument required";
+    }
+
+    s = String( s );
+
+    var i,
+      b10,
+      x = [],
+      imax = s.length - s.length % 3;
+
+    if ( s.length === 0 ) {
+      return s;
+    }
+
+    for ( i = 0; i < imax; i += 3 ) {
+      b10 = ( _getbyte( s, i ) << 16 ) | ( _getbyte( s, i + 1 ) << 8 ) | _getbyte( s, i + 2 );
+      x.push( _ALPHA.charAt( b10 >> 18 ) );
+      x.push( _ALPHA.charAt( ( b10 >> 12 ) & 0x3F ) );
+      x.push( _ALPHA.charAt( ( b10 >> 6 ) & 0x3f ) );
+      x.push( _ALPHA.charAt( b10 & 0x3f ) );
+    }
+
+    switch ( s.length - imax ) {
+      case 1:
+        b10 = _getbyte( s, i ) << 16;
+        x.push( _ALPHA.charAt( b10 >> 18 ) + _ALPHA.charAt( ( b10 >> 12 ) & 0x3F ) + _PADCHAR + _PADCHAR );
+        break;
+
+      case 2:
+        b10 = ( _getbyte( s, i ) << 16 ) | ( _getbyte( s, i + 1 ) << 8 );
+        x.push( _ALPHA.charAt( b10 >> 18 ) + _ALPHA.charAt( ( b10 >> 12 ) & 0x3F ) + _ALPHA.charAt( ( b10 >> 6 ) & 0x3f ) + _PADCHAR );
+        break;
+    }
+
+    return x.join( "" );
+  }
+
+
+  return {
+    decode: _decode,
+    encode: _encode,
+    VERSION: _VERSION
+  };
+      
+}( jQuery ) );
+
@@ -0,0 +1,303 @@
+/**
+ * jsPDF
+ * (c) 2009 James Hall
+ * 
+ * Some parts based on FPDF.
+ */
+
+var jsPDF = function(){
+	
+	// Private properties
+	var version = '20090504';
+	var buffer = '';
+	
+	var pdfVersion = '1.3'; // PDF Version
+	var defaultPageFormat = 'a4';
+	var pageFormats = { // Size in mm of various paper formats
+		'a3': [841.89, 1190.55],
+		'a4': [595.28, 841.89],
+		'a5': [420.94, 595.28],
+		'letter': [612, 792],
+		'legal': [612, 1008]
+	};
+	var textColor = '0 g';
+	var page = 0;
+	var objectNumber = 2; // 'n' Current object number
+	var state = 0; // Current document state
+	var pages = new Array();
+	var offsets = new Array(); // List of offsets
+	var lineWidth = 0.200025; // 2mm
+	var pageHeight;
+	var k; // Scale factor
+	var unit = 'mm'; // Default to mm for units
+	var fontNumber; // TODO: This is temp, replace with real font handling
+	var documentProperties = {};
+	var fontSize = 16; // Default font size
+	var pageFontSize = 16;
+
+	// Initilisation 
+	if (unit == 'pt') {
+		k = 1;
+	} else if(unit == 'mm') {
+		k = 72/25.4;
+	} else if(unit == 'cm') {
+		k = 72/2.54;
+	} else if(unit == 'in') {
+		k = 72;
+	}
+	
+	// Private functions
+	var newObject = function() {
+		//Begin a new object
+		objectNumber ++;
+		offsets[objectNumber] = buffer.length;
+		out(objectNumber + ' 0 obj');		
+	}
+	
+	
+	var putHeader = function() {
+		out('%PDF-' + pdfVersion);
+	}
+	
+	var putPages = function() {
+		
+		// TODO: Fix, hardcoded to a4 portrait
+		var wPt = pageWidth * k;
+		var hPt = pageHeight * k;
+
+		for(n=1; n <= page; n++) {
+			newObject();
+			out('<</Type /Page');
+			out('/Parent 1 0 R');	
+			out('/Resources 2 0 R');
+			out('/Contents ' + (objectNumber + 1) + ' 0 R>>');
+			out('endobj');
+			
+			//Page content
+			p = pages[n];
+			newObject();
+			out('<</Length ' + p.length  + '>>');
+			putStream(p);
+			out('endobj');					
+		}
+		offsets[1] = buffer.length;
+		out('1 0 obj');
+		out('<</Type /Pages');
+		var kids='/Kids [';
+		for (i = 0; i < page; i++) {
+			kids += (3 + 2 * i) + ' 0 R ';
+		}
+		out(kids + ']');
+		out('/Count ' + page);
+		out(sprintf('/MediaBox [0 0 %.2f %.2f]', wPt, hPt));
+		out('>>');
+		out('endobj');		
+	}
+	
+	var putStream = function(str) {
+		out('stream');
+		out(str);
+		out('endstream');
+	}
+	
+	var putResources = function() {
+		putFonts();
+		putImages();
+		
+		//Resource dictionary
+		offsets[2] = buffer.length;
+		out('2 0 obj');
+		out('<<');
+		putResourceDictionary();
+		out('>>');
+		out('endobj');
+	}	
+	
+	var putFonts = function() {
+		// TODO: Only supports core font hardcoded to Helvetica
+		newObject();
+		fontNumber = objectNumber;
+		name = 'Helvetica';
+		out('<</Type /Font');
+		out('/BaseFont /' + name);
+		out('/Subtype /Type1');
+		out('/Encoding /WinAnsiEncoding');
+		out('>>');
+		out('endobj');
+	}
+	
+	var putImages = function() {
+		// TODO
+	}
+	
+	var putResourceDictionary = function() {
+		out('/ProcSet [/PDF /Text /ImageB /ImageC /ImageI]');
+		out('/Font <<');
+		// Do this for each font, the '1' bit is the index of the font
+        // fontNumber is currently the object number related to 'putFonts'
+		out('/F1 ' + fontNumber + ' 0 R');
+		out('>>');
+		out('/XObject <<');
+		putXobjectDict();
+		out('>>');
+	}
+	
+	var putXobjectDict = function() {
+		// TODO
+		// Loop through images
+	}
+	
+	
+	var putInfo = function() {
+		out('/Producer (jsPDF ' + version + ')');
+		if(documentProperties.title != undefined) {
+			out('/Title (' + pdfEscape(documentProperties.title) + ')');
+		}
+		if(documentProperties.subject != undefined) {
+			out('/Subject (' + pdfEscape(documentProperties.subject) + ')');
+		}
+		if(documentProperties.author != undefined) {
+			out('/Author (' + pdfEscape(documentProperties.author) + ')');
+		}
+		if(documentProperties.keywords != undefined) {
+			out('/Keywords (' + pdfEscape(documentProperties.keywords) + ')');
+		}
+		if(documentProperties.creator != undefined) {
+			out('/Creator (' + pdfEscape(documentProperties.creator) + ')');
+		}		
+		var created = new Date();
+		var year = created.getFullYear();
+		var month = (created.getMonth() + 1);
+		var day = created.getDate();
+		var hour = created.getHours();
+		var minute = created.getMinutes();
+		var second = created.getSeconds();
+		out('/CreationDate (D:' + sprintf('%02d%02d%02d%02d%02d%02d', year, month, day, hour, minute, second) + ')');
+	}
+	
+	var putCatalog = function () {
+		out('/Type /Catalog');
+		out('/Pages 1 0 R');
+		// TODO: Add zoom and layout modes
+		out('/OpenAction [3 0 R /FitH null]');
+		out('/PageLayout /OneColumn');
+	}	
+	
+	function putTrailer() {
+		out('/Size ' + (objectNumber + 1));
+		out('/Root ' + objectNumber + ' 0 R');
+		out('/Info ' + (objectNumber - 1) + ' 0 R');
+	}	
+	
+	var endDocument = function() {
+		state = 1;
+		putHeader();
+		putPages();
+		
+		putResources();
+		//Info
+		newObject();
+		out('<<');
+		putInfo();
+		out('>>');
+		out('endobj');
+		
+		//Catalog
+		newObject();
+		out('<<');
+		putCatalog();
+		out('>>');
+		out('endobj');
+		
+		//Cross-ref
+		var o = buffer.length;
+		out('xref');
+		out('0 ' + (objectNumber + 1));
+		out('0000000000 65535 f ');
+		for (var i=1; i <= objectNumber; i++) {
+			out(sprintf('%010d 00000 n ', offsets[i]));
+		}
+		//Trailer
+		out('trailer');
+		out('<<');
+		putTrailer();
+		out('>>');
+		out('startxref');
+		out(o);
+		out('%%EOF');
+		state = 3;		
+	}
+	
+	var beginPage = function() {
+		page ++;
+		// Do dimension stuff
+		state = 2;
+		pages[page] = '';
+		
+		// TODO: Hardcoded at A4 and portrait
+		pageHeight = pageFormats['a4'][1] / k;
+		pageWidth = pageFormats['a4'][0] / k;
+	}
+	
+	var out = function(string) {
+		if(state == 2) {
+			pages[page] += string + '\n';
+		} else {
+			buffer += string + '\n';
+		}
+	}
+	
+	var _addPage = function() {
+		beginPage();
+		// Set line width
+		out(sprintf('%.2f w', (lineWidth * k)));
+		
+		// Set font - TODO
+		// 16 is the font size
+		pageFontSize = fontSize;
+		out('BT /F1 ' + parseInt(fontSize) + '.00 Tf ET'); 		
+	}
+	
+	// Add the first page automatically
+	_addPage();	
+
+	// Escape text
+	var pdfEscape = function(text) {
+		return text.replace(/\\/g, '\\\\').replace(/\(/g, '\\(').replace(/\)/g, '\\)');
+	}
+	
+	return {
+		addPage: function() {
+			_addPage();
+		},
+		text: function(x, y, text) {
+			// need page height
+			if(pageFontSize != fontSize) {
+				out('BT /F1 ' + parseInt(fontSize) + '.00 Tf ET');
+				pageFontSize = fontSize;
+			}
+			var str = sprintf('BT %.2f %.2f Td (%s) Tj ET', x * k, (pageHeight - y) * k, pdfEscape(text));
+			out(str);
+		},
+		setProperties: function(properties) {
+			documentProperties = properties;
+		},
+		addImage: function(imageData, format, x, y, w, h) {
+		
+		},
+		output: function(type, options) {
+			endDocument();
+			if(type == undefined) {
+				return buffer;
+			}
+			if(type == 'datauri') {
+				document.location.href = 'data:application/pdf;base64,' + Base64.encode(buffer);
+			}
+			// @TODO: Add different output options
+		},
+		setFontSize: function(size) {
+			fontSize = size;
+		}
+	}
+
+};
@@ -0,0 +1,143 @@
+
+/**
+*
+*  Base64 encode / decode
+*  http://www.webtoolkit.info/
+*
+**/
+
+var Base64 = {
+
+	// private property
+	_keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+
+	// public method for encoding
+	encode : function (input) {
+		var output = "";
+		var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+		var i = 0;
+
+		input = Base64._utf8_encode(input);
+
+		while (i < input.length) {
+
+			chr1 = input.charCodeAt(i++);
+			chr2 = input.charCodeAt(i++);
+			chr3 = input.charCodeAt(i++);
+
+			enc1 = chr1 >> 2;
+			enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+			enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+			enc4 = chr3 & 63;
+
+			if (isNaN(chr2)) {
+				enc3 = enc4 = 64;
+			} else if (isNaN(chr3)) {
+				enc4 = 64;
+			}
+
+			output = output +
+			this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2) +
+			this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);
+
+		}
+
+		return output;
+	},
+
+	// public method for decoding
+	decode : function (input) {
+		var output = "";
+		var chr1, chr2, chr3;
+		var enc1, enc2, enc3, enc4;
+		var i = 0;
+
+		input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+
+		while (i < input.length) {
+
+			enc1 = this._keyStr.indexOf(input.charAt(i++));
+			enc2 = this._keyStr.indexOf(input.charAt(i++));
+			enc3 = this._keyStr.indexOf(input.charAt(i++));
+			enc4 = this._keyStr.indexOf(input.charAt(i++));
+
+			chr1 = (enc1 << 2) | (enc2 >> 4);
+			chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+			chr3 = ((enc3 & 3) << 6) | enc4;
+
+			output = output + String.fromCharCode(chr1);
+
+			if (enc3 != 64) {
+				output = output + String.fromCharCode(chr2);
+			}
+			if (enc4 != 64) {
+				output = output + String.fromCharCode(chr3);
+			}
+
+		}
+
+		output = Base64._utf8_decode(output);
+
+		return output;
+
+	},
+
+	// private method for UTF-8 encoding
+	_utf8_encode : function (string) {
+		string = string.replace(/\r\n/g,"\n");
+		var utftext = "";
+
+		for (var n = 0; n < string.length; n++) {
+
+			var c = string.charCodeAt(n);
+
+			if (c < 128) {
+				utftext += String.fromCharCode(c);
+			}
+			else if((c > 127) && (c < 2048)) {
+				utftext += String.fromCharCode((c >> 6) | 192);
+				utftext += String.fromCharCode((c & 63) | 128);
+			}
+			else {
+				utftext += String.fromCharCode((c >> 12) | 224);
+				utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+				utftext += String.fromCharCode((c & 63) | 128);
+			}
+
+		}
+
+		return utftext;
+	},
+
+	// private method for UTF-8 decoding
+	_utf8_decode : function (utftext) {
+		var string = "";
+		var i = 0;
+		var c = c1 = c2 = 0;
+
+		while ( i < utftext.length ) {
+
+			c = utftext.charCodeAt(i);
+
+			if (c < 128) {
+				string += String.fromCharCode(c);
+				i++;
+			}
+			else if((c > 191) && (c < 224)) {
+				c2 = utftext.charCodeAt(i+1);
+				string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+				i += 2;
+			}
+			else {
+				c2 = utftext.charCodeAt(i+1);
+				c3 = utftext.charCodeAt(i+2);
+				string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+				i += 3;
+			}
+
+		}
+
+		return string;
+	}
+
+}
@@ -0,0 +1,152 @@
+
+
+function sprintf( ) {
+    // Return a formatted string  
+    // 
+    // version: 903.3016
+    // discuss at: http://phpjs.org/functions/sprintf
+    // +   original by: Ash Searle (http://hexmen.com/blog/)
+    // + namespaced by: Michael White (http://getsprink.com)
+    // +    tweaked by: Jack
+    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+    // +      input by: Paulo Ricardo F. Santos
+    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+    // +      input by: Brett Zamir (http://brettz9.blogspot.com)
+    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+    // *     example 1: sprintf("%01.2f", 123.1);
+    // *     returns 1: 123.10
+    // *     example 2: sprintf("[%10s]", 'monkey');
+    // *     returns 2: '[    monkey]'
+    // *     example 3: sprintf("[%'#10s]", 'monkey');
+    // *     returns 3: '[####monkey]'
+    var regex = /%%|%(\d+\$)?([-+\'#0 ]*)(\*\d+\$|\*|\d+)?(\.(\*\d+\$|\*|\d+))?([scboxXuidfegEG])/g;
+    var a = arguments, i = 0, format = a[i++];
+
+    // pad()
+    var pad = function(str, len, chr, leftJustify) {
+        if (!chr) chr = ' ';
+        var padding = (str.length >= len) ? '' : Array(1 + len - str.length >>> 0).join(chr);
+        return leftJustify ? str + padding : padding + str;
+    };
+
+    // justify()
+    var justify = function(value, prefix, leftJustify, minWidth, zeroPad, customPadChar) {
+        var diff = minWidth - value.length;
+        if (diff > 0) {
+            if (leftJustify || !zeroPad) {
+                value = pad(value, minWidth, customPadChar, leftJustify);
+            } else {
+                value = value.slice(0, prefix.length) + pad('', diff, '0', true) + value.slice(prefix.length);
+            }
+        }
+        return value;
+    };
+
+    // formatBaseX()
+    var formatBaseX = function(value, base, prefix, leftJustify, minWidth, precision, zeroPad) {
+        // Note: casts negative numbers to positive ones
+        var number = value >>> 0;
+        prefix = prefix && number && {'2': '0b', '8': '0', '16': '0x'}[base] || '';
+        value = prefix + pad(number.toString(base), precision || 0, '0', false);
+        return justify(value, prefix, leftJustify, minWidth, zeroPad);
+    };
+
+    // formatString()
+    var formatString = function(value, leftJustify, minWidth, precision, zeroPad, customPadChar) {
+        if (precision != null) {
+            value = value.slice(0, precision);
+        }
+        return justify(value, '', leftJustify, minWidth, zeroPad, customPadChar);
+    };
+
+    // doFormat()
+    var doFormat = function(substring, valueIndex, flags, minWidth, _, precision, type) {
+        var number;
+        var prefix;
+        var method;
+        var textTransform;
+        var value;
+
+        if (substring == '%%') return '%';
+
+        // parse flags
+        var leftJustify = false, positivePrefix = '', zeroPad = false, prefixBaseX = false, customPadChar = ' ';
+        var flagsl = flags.length;
+        for (var j = 0; flags && j < flagsl; j++) switch (flags.charAt(j)) {
+            case ' ': positivePrefix = ' '; break;
+            case '+': positivePrefix = '+'; break;
+            case '-': leftJustify = true; break;
+            case "'": customPadChar = flags.charAt(j+1); break;
+            case '0': zeroPad = true; break;
+            case '#': prefixBaseX = true; break;
+        }
+
+        // parameters may be null, undefined, empty-string or real valued
+        // we want to ignore null, undefined and empty-string values
+        if (!minWidth) {
+            minWidth = 0;
+        } else if (minWidth == '*') {
+            minWidth = +a[i++];
+        } else if (minWidth.charAt(0) == '*') {
+            minWidth = +a[minWidth.slice(1, -1)];
+        } else {
+            minWidth = +minWidth;
+        }
+
+        // Note: undocumented perl feature:
+        if (minWidth < 0) {
+            minWidth = -minWidth;
+            leftJustify = true;
+        }
+
+        if (!isFinite(minWidth)) {
+            throw new Error('sprintf: (minimum-)width must be finite');
+        }
+
+        if (!precision) {
+            precision = 'fFeE'.indexOf(type) > -1 ? 6 : (type == 'd') ? 0 : void(0);
+        } else if (precision == '*') {
+            precision = +a[i++];
+        } else if (precision.charAt(0) == '*') {
+            precision = +a[precision.slice(1, -1)];
+        } else {
+            precision = +precision;
+        }
+
+        // grab value using valueIndex if required?
+        value = valueIndex ? a[valueIndex.slice(0, -1)] : a[i++];
+
+        switch (type) {
+            case 's': return formatString(String(value), leftJustify, minWidth, precision, zeroPad, customPadChar);
+            case 'c': return formatString(String.fromCharCode(+value), leftJustify, minWidth, precision, zeroPad);
+            case 'b': return formatBaseX(value, 2, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'o': return formatBaseX(value, 8, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'x': return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'X': return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad).toUpperCase();
+            case 'u': return formatBaseX(value, 10, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'i':
+            case 'd': {
+                number = parseInt(+value);
+                prefix = number < 0 ? '-' : positivePrefix;
+                value = prefix + pad(String(Math.abs(number)), precision, '0', false);
+                return justify(value, prefix, leftJustify, minWidth, zeroPad);
+            }
+            case 'e':
+            case 'E':
+            case 'f':
+            case 'F':
+            case 'g':
+            case 'G': {
+                number = +value;
+                prefix = number < 0 ? '-' : positivePrefix;
+                method = ['toExponential', 'toFixed', 'toPrecision']['efg'.indexOf(type.toLowerCase())];
+                textTransform = ['toString', 'toUpperCase']['eEfFgG'.indexOf(type) % 2];
+                value = prefix + Math.abs(number)[method](precision);
+                return justify(value, prefix, leftJustify, minWidth, zeroPad)[textTransform]();
+            }
+            default: return substring;
+        }
+    };
+
+    return format.replace(regex, doFormat);
+}
@@ -0,0 +1,359 @@
+/*The MIT License (MIT)
+
+Copyright (c) 2014 https://github.com/kayalshri/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.*/
+
+(function($){
+        $.fn.extend({
+            tableExport: function(options) {
+                var defaults = {
+						separator: ',',
+						ignoreColumn: [],
+						tableName:'yourTableName',
+						type:'csv',
+						pdfFontSize:14,
+						pdfLeftMargin:20,
+						escape:'true',
+						htmlContent:'false',
+						consoleLog:'false'
+				};
+                
+				var options = $.extend(defaults, options);
+				var el = this;
+				
+				if(defaults.type == 'csv' || defaults.type == 'txt'){
+				
+					// Header
+					var tdData ="";
+					$(el).find('thead').find('tr').each(function() {
+					tdData += "\n";					
+						$(this).filter(':visible').find('th').each(function(index,data) {
+							if ($(this).css('display') != 'none'){
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									tdData += '"' + parseString($(this)) + '"' + defaults.separator;									
+								}
+							}
+							
+						});
+						tdData = $.trim(tdData);
+						tdData = $.trim(tdData).substring(0, tdData.length -1);
+					});
+					
+					// Row vs Column
+					$(el).find('tbody').find('tr').each(function() {
+					tdData += "\n";
+						$(this).filter(':visible').find('td').each(function(index,data) {
+							if ($(this).css('display') != 'none'){
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									tdData += '"'+ parseString($(this)) + '"'+ defaults.separator;
+								}
+							}
+						});
+						//tdData = $.trim(tdData);
+						tdData = $.trim(tdData).substring(0, tdData.length -1);
+					});
+					
+					//output
+					if(defaults.consoleLog == 'true'){
+						console.log(tdData);
+					}
+					var base64data = "base64," + $.base64.encode(tdData);
+					window.open('data:application/'+defaults.type+';filename=exportData;' + base64data);
+				}else if(defaults.type == 'sql'){
+				
+					// Header
+					var tdData ="INSERT INTO `"+defaults.tableName+"` (";
+					$(el).find('thead').find('tr').each(function() {
+					
+						$(this).filter(':visible').find('th').each(function(index,data) {
+							if ($(this).css('display') != 'none'){
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									tdData += '`' + parseString($(this)) + '`,' ;									
+								}
+							}
+							
+						});
+						tdData = $.trim(tdData);
+						tdData = $.trim(tdData).substring(0, tdData.length -1);
+					});
+					tdData += ") VALUES ";
+					// Row vs Column
+					$(el).find('tbody').find('tr').each(function() {
+					tdData += "(";
+						$(this).filter(':visible').find('td').each(function(index,data) {
+							if ($(this).css('display') != 'none'){
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									tdData += '"'+ parseString($(this)) + '",';
+								}
+							}
+						});
+						
+						tdData = $.trim(tdData).substring(0, tdData.length -1);
+						tdData += "),";
+					});
+					tdData = $.trim(tdData).substring(0, tdData.length -1);
+					tdData += ";";
+					
+					//output
+					//console.log(tdData);
+					
+					if(defaults.consoleLog == 'true'){
+						console.log(tdData);
+					}
+					
+					var base64data = "base64," + $.base64.encode(tdData);
+					window.open('data:application/sql;filename=exportData;' + base64data);
+					
+				
+				}else if(defaults.type == 'json'){
+				
+					var jsonHeaderArray = [];
+					$(el).find('thead').find('tr').each(function() {
+						var tdData ="";	
+						var jsonArrayTd = [];
+					
+						$(this).filter(':visible').find('th').each(function(index,data) {
+							if ($(this).css('display') != 'none'){
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									jsonArrayTd.push(parseString($(this)));									
+								}
+							}
+						});									
+						jsonHeaderArray.push(jsonArrayTd);						
+						
+					});
+					
+					var jsonArray = [];
+					$(el).find('tbody').find('tr').each(function() {
+						var tdData ="";	
+						var jsonArrayTd = [];
+					
+						$(this).filter(':visible').find('td').each(function(index,data) {
+							if ($(this).css('display') != 'none'){
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									jsonArrayTd.push(parseString($(this)));									
+								}
+							}
+						});									
+						jsonArray.push(jsonArrayTd);									
+						
+					});
+					
+					var jsonExportArray =[];
+					jsonExportArray.push({header:jsonHeaderArray,data:jsonArray});
+					
+					//Return as JSON
+					//console.log(JSON.stringify(jsonExportArray));
+					
+					//Return as Array
+					//console.log(jsonExportArray);
+					if(defaults.consoleLog == 'true'){
+						console.log(JSON.stringify(jsonExportArray));
+					}
+					var base64data = "base64," + $.base64.encode(JSON.stringify(jsonExportArray));
+					window.open('data:application/json;filename=exportData;' + base64data);
+				}else if(defaults.type == 'xml'){
+				
+					var xml = '<?xml version="1.0" encoding="utf-8"?>';
+					xml += '<tabledata><fields>';
+
+					// Header
+					$(el).find('thead').find('tr').each(function() {
+						$(this).filter(':visible').find('th').each(function(index,data) {
+							if ($(this).css('display') != 'none'){					
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									xml += "<field>" + parseString($(this)) + "</field>";
+								}
+							}
+						});									
+					});					
+					xml += '</fields><data>';
+					
+					// Row Vs Column
+					var rowCount=1;
+					$(el).find('tbody').find('tr').each(function() {
+						xml += '<row id="'+rowCount+'">';
+						var colCount=0;
+						$(this).filter(':visible').find('td').each(function(index,data) {
+							if ($(this).css('display') != 'none'){	
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									xml += "<column-"+colCount+">"+parseString($(this))+"</column-"+colCount+">";
+								}
+							}
+							colCount++;
+						});															
+						rowCount++;
+						xml += '</row>';
+					});					
+					xml += '</data></tabledata>'
+					
+					if(defaults.consoleLog == 'true'){
+						console.log(xml);
+					}
+					
+					var base64data = "base64," + $.base64.encode(xml);
+					window.open('data:application/xml;filename=exportData;' + base64data);
+
+				}else if(defaults.type == 'excel' || defaults.type == 'doc'|| defaults.type == 'powerpoint'  ){
+					//console.log($(this).html());
+					var excel="<table>";
+					// Header
+					$(el).find('thead').find('tr').each(function() {
+						excel += "<tr>";
+						$(this).filter(':visible').find('th').each(function(index,data) {
+							if ($(this).css('display') != 'none'){					
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									excel += "<td>" + parseString($(this))+ "</td>";
+								}
+							}
+						});	
+						excel += '</tr>';						
+						
+					});					
+					
+					
+					// Row Vs Column
+					var rowCount=1;
+					$(el).find('tbody').find('tr').each(function() {
+						excel += "<tr>";
+						var colCount=0;
+						$(this).filter(':visible').find('td').each(function(index,data) {
+							if ($(this).css('display') != 'none'){	
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									excel += "<td>"+parseString($(this))+"</td>";
+								}
+							}
+							colCount++;
+						});															
+						rowCount++;
+						excel += '</tr>';
+					});					
+					excel += '</table>'
+					
+					if(defaults.consoleLog == 'true'){
+						console.log(excel);
+					}
+					
+					var excelFile = "<html xmlns:o='urn:schemas-microsoft-com:office:office' xmlns:x='urn:schemas-microsoft-com:office:"+defaults.type+"' xmlns='http://www.w3.org/TR/REC-html40'>";
+					excelFile += "<head>";
+					excelFile += "<!--[if gte mso 9]>";
+					excelFile += "<xml>";
+					excelFile += "<x:ExcelWorkbook>";
+					excelFile += "<x:ExcelWorksheets>";
+					excelFile += "<x:ExcelWorksheet>";
+					excelFile += "<x:Name>";
+					excelFile += "{worksheet}";
+					excelFile += "</x:Name>";
+					excelFile += "<x:WorksheetOptions>";
+					excelFile += "<x:DisplayGridlines/>";
+					excelFile += "</x:WorksheetOptions>";
+					excelFile += "</x:ExcelWorksheet>";
+					excelFile += "</x:ExcelWorksheets>";
+					excelFile += "</x:ExcelWorkbook>";
+					excelFile += "</xml>";
+					excelFile += "<![endif]-->";
+					excelFile += "</head>";
+					excelFile += "<body>";
+					excelFile += excel;
+					excelFile += "</body>";
+					excelFile += "</html>";
+
+					var base64data = "base64," + $.base64.encode(excelFile);
+					window.open('data:application/vnd.ms-'+defaults.type+';filename=exportData.doc;' + base64data);
+					
+				}else if(defaults.type == 'png'){
+					html2canvas($(el), {
+						onrendered: function(canvas) {										
+							var img = canvas.toDataURL("image/png");
+							window.open(img);
+							
+							
+						}
+					});		
+				}else if(defaults.type == 'pdf'){
+	
+					var doc = new jsPDF('p','pt', 'a4', true);
+					doc.setFontSize(defaults.pdfFontSize);
+					
+					// Header
+					var startColPosition=defaults.pdfLeftMargin;
+					$(el).find('thead').find('tr').each(function() {
+						$(this).filter(':visible').find('th').each(function(index,data) {
+							if ($(this).css('display') != 'none'){					
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									var colPosition = startColPosition+ (index * 50);									
+									doc.text(colPosition,20, parseString($(this)));
+								}
+							}
+						});									
+					});					
+				
+				
+					// Row Vs Column
+					var startRowPosition = 20; var page =1;var rowPosition=0;
+					$(el).find('tbody').find('tr').each(function(index,data) {
+						rowCalc = index+1;
+						
+					if (rowCalc % 26 == 0){
+						doc.addPage();
+						page++;
+						startRowPosition=startRowPosition+10;
+					}
+					rowPosition=(startRowPosition + (rowCalc * 10)) - ((page -1) * 280);
+						
+						$(this).filter(':visible').find('td').each(function(index,data) {
+							if ($(this).css('display') != 'none'){	
+								if(defaults.ignoreColumn.indexOf(index) == -1){
+									var colPosition = startColPosition+ (index * 50);									
+									doc.text(colPosition,rowPosition, parseString($(this)));
+								}
+							}
+							
+						});															
+						
+					});					
+										
+					// Output as Data URI
+					doc.output('datauri');
+	
+				}
+				
+				
+				function parseString(data){
+				
+					if(defaults.htmlContent == 'true'){
+						content_data = data.html().trim();
+					}else{
+						content_data = data.text().trim();
+					}
+					
+					if(defaults.escape == 'true'){
+						content_data = escape(content_data);
+					}
+					
+					
+					
+					return content_data;
+				}
+			
+			}
+        });
+    })(jQuery);
+
@@ -0,0 +1,11 @@		@@ -0,0 +1,11 @@
	1	+/nbproject/
	2	+image.jpg
	3	+/.project
	4	+/.settings/
	5	+node_modules/
	6	+.envrc
	7	+*.sublime-workspace
	8	+*.baseline
	9	+*.iml
	10	+.idea/
	11	+.DS_Store
@@ -0,0 +1,3 @@		@@ -0,0 +1,3 @@
	1	+[submodule "src/fabric"]
	2	+ path = src/fabric
	3	+ url = https://github.com/kangax/fabric.js.git
@@ -0,0 +1,19 @@		@@ -0,0 +1,19 @@
	1	+{
	2	+ "curly": true,
	3	+ "eqeqeq": true,
	4	+ "immed": true,
	5	+ "latedef": false,
	6	+ "newcap": true,
	7	+ "noarg": true,
	8	+ "sub": true,
	9	+ "undef": true,
	10	+ "boss": true,
	11	+ "eqnull": true,
	12	+ "browser": true,
	13	+ "node": true,
	14	+ "indent": 4,
	15	+ "globals": {
	16	+ "jQuery": true
	17	+ },
	18	+ "predef": ["-Promise"]
	19	+}
@@ -0,0 +1,21 @@		@@ -0,0 +1,21 @@
	1	+---
	2	+language: node_js
	3	+node_js:
	4	+- '0.10'
	5	+env:
	6	+ global:
	7	+ - secure: "eW41gIqOizwO4pTgWnAAbW75AP7F+CK9qfSed/fSh4sJ9HWMIY1YRIaY8gjr+6jV/f7XVHcXuym6ZxgINYSkVKbF1JKxBJNLOXtSgNbVHSic58pYFvUjwxIBI9aPig9uux1+DbnpWqXFDTcACJSevQZE0xwmjdrSkDLgB0G34v8="
	8	+ - secure: "Y2Av+Gd3z9uQEB36GwdOOuGka0hx0/HeitASEo59z934O8RxnmN9eNTXS7dDT3XtKtwxIyLTOEpS7qlRdWahH28hr/dS4xJj6ao58C+1xMcDs6NAPGmDxUlcJWpcGEsnjmXjQCc3fBioSTdpIBrK/gdvgpNh77UKG74Sk7Z+YGk="
	9	+ - secure: "YI+YbTOGf2x4fPMKW+KhJiZWswoXT6xOKGwLfsQsVwmFX1LerJouil5D5iYOQuL4FE3pNaoJSNakIsokJQuGKJMmnPc8rdhMZuBJBk6MRghurE2Xe9qBHfuUBPlfD61nARESm4WDcyMwM0QVYaOKeY6aIpZ91qbUbyc60EEx3C4="
	10	+addons:
	11	+ sauce_connect: true
	12	+before_script:
	13	+ - npm install -g grunt-cli
	14	+ - npm install -g uglify-js
	15	+notifications:
	16	+ webhooks:
	17	+ urls:
	18	+ - https://webhooks.gitter.im/e/2b007d4f86de89588804
	19	+ on_success: always
	20	+ on_failure: always
	21	+ on_start: false
@@ -0,0 +1,48 @@		@@ -0,0 +1,48 @@
	1	+tableExport.jquery.plugin
	2	+=========================
	3	+
	4	+<h3>Export HTML Table to</h3>
	5	+<ul>
	6	+<li> JSON
	7	+<li> XML
	8	+<li> PNG
	9	+<li> CSV
	10	+<li> TXT
	11	+<li> SQL
	12	+<li> MS-Word
	13	+<li> Ms-Excel
	14	+<li> Ms-Powerpoint
	15	+<li> PDF
	16	+</ul>
	17	+
	18	+Installation
	19	+============
	20	+jquery Plugin<BR>
	21	+<script type="text/javascript" src="tableExport.js"><BR>
	22	+<script type="text/javascript" src="jquery.base64.js"><BR>
	23	+<BR>
	24	+PNG Export
	25	+==========
	26	+<script type="text/javascript" src="html2canvas.js">
	27	+
	28	+PDF Export
	29	+==========
	30	+<script type="text/javascript" src="jspdf/libs/sprintf.js"><BR>
	31	+<script type="text/javascript" src="jspdf/jspdf.js"><BR>
	32	+<script type="text/javascript" src="jspdf/libs/base64.js"><BR>
	33	+
	34	+Usage
	35	+======
	36	+onClick ="$('#tableID').tableExport({type:'pdf',escape:'false'});"<BR>
	37	+
	38	+Options
	39	+=======
	40	+separator: ','<BR>
	41	+ignoreColumn: [2,3],<BR>
	42	+tableName:'yourTableName'<BR>
	43	+type:'csv'<BR>
	44	+pdfFontSize:14<BR>
	45	+pdfLeftMargin:20<BR>
	46	+escape:'true'<BR>
	47	+htmlContent:'false'<BR>
	48	+consoleLog:'false' <BR>
@@ -0,0 +1,190 @@		@@ -0,0 +1,190 @@
	1	+/*jslint adsafe: false, bitwise: true, browser: true, cap: false, css: false,
	2	+ debug: false, devel: true, eqeqeq: true, es5: false, evil: false,
	3	+ forin: false, fragment: false, immed: true, laxbreak: false, newcap: true,
	4	+ nomen: false, on: false, onevar: true, passfail: false, plusplus: true,
	5	+ regexp: false, rhino: true, safe: false, strict: false, sub: false,
	6	+ undef: true, white: false, widget: false, windows: false */
	7	+/global jQuery: false, window: false /
	8	+//"use strict";
	9	+
	10	+/*
	11	+ * Original code (c) 2010 Nick Galbreath
	12	+ * http://code.google.com/p/stringencoders/source/browse/#svn/trunk/javascript
	13	+ *
	14	+ * jQuery port (c) 2010 Carlo Zottmann
	15	+ * http://github.com/carlo/jquery-base64
	16	+ *
	17	+ * Permission is hereby granted, free of charge, to any person
	18	+ * obtaining a copy of this software and associated documentation
	19	+ * files (the "Software"), to deal in the Software without
	20	+ * restriction, including without limitation the rights to use,
	21	+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
	22	+ * copies of the Software, and to permit persons to whom the
	23	+ * Software is furnished to do so, subject to the following
	24	+ * conditions:
	25	+ *
	26	+ * The above copyright notice and this permission notice shall be
	27	+ * included in all copies or substantial portions of the Software.
	28	+ *
	29	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	30	+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
	31	+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	32	+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
	33	+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	34	+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	35	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	36	+ * OTHER DEALINGS IN THE SOFTWARE.
	37	+*/
	38	+
	39	+/* base64 encode/decode compatible with window.btoa/atob
	40	+ *
	41	+ * window.atob/btoa is a Firefox extension to convert binary data (the "b")
	42	+ * to base64 (ascii, the "a").
	43	+ *
	44	+ * It is also found in Safari and Chrome. It is not available in IE.
	45	+ *
	46	+ * if (!window.btoa) window.btoa = $.base64.encode
	47	+ * if (!window.atob) window.atob = $.base64.decode
	48	+ *
	49	+ * The original spec's for atob/btoa are a bit lacking
	50	+ * https://developer.mozilla.org/en/DOM/window.atob
	51	+ * https://developer.mozilla.org/en/DOM/window.btoa
	52	+ *
	53	+ * window.btoa and $.base64.encode takes a string where charCodeAt is [0,255]
	54	+ * If any character is not [0,255], then an exception is thrown.
	55	+ *
	56	+ * window.atob and $.base64.decode take a base64-encoded string
	57	+ * If the input length is not a multiple of 4, or contains invalid characters
	58	+ * then an exception is thrown.
	59	+ */
	60	+
	61	+jQuery.base64 = ( function( $ ) {
	62	+
	63	+ var _PADCHAR = "=",
	64	+ _ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
	65	+ _VERSION = "1.0";
	66	+
	67	+
	68	+ function _getbyte64( s, i ) {
	69	+ // This is oddly fast, except on Chrome/V8.
	70	+ // Minimal or no improvement in performance by using a
	71	+ // object with properties mapping chars to value (eg. 'A': 0)
	72	+
	73	+ var idx = _ALPHA.indexOf( s.charAt( i ) );
	74	+
	75	+ if ( idx === -1 ) {
	76	+ throw "Cannot decode base64";
	77	+ }
	78	+
	79	+ return idx;
	80	+ }
	81	+
	82	+
	83	+ function _decode( s ) {
	84	+ var pads = 0,
	85	+ i,
	86	+ b10,
	87	+ imax = s.length,
	88	+ x = [];
	89	+
	90	+ s = String( s );
	91	+
	92	+ if ( imax === 0 ) {
	93	+ return s;
	94	+ }
	95	+
	96	+ if ( imax % 4 !== 0 ) {
	97	+ throw "Cannot decode base64";
	98	+ }
	99	+
	100	+ if ( s.charAt( imax - 1 ) === _PADCHAR ) {
	101	+ pads = 1;
	102	+
	103	+ if ( s.charAt( imax - 2 ) === _PADCHAR ) {
	104	+ pads = 2;
	105	+ }
	106	+
	107	+ // either way, we want to ignore this last block
	108	+ imax -= 4;
	109	+ }
	110	+
	111	+ for ( i = 0; i < imax; i += 4 ) {
	112	+ b10 = ( _getbyte64( s, i ) << 18 ) \| ( _getbyte64( s, i + 1 ) << 12 ) \| ( _getbyte64( s, i + 2 ) << 6 ) \| _getbyte64( s, i + 3 );
	113	+ x.push( String.fromCharCode( b10 >> 16, ( b10 >> 8 ) & 0xff, b10 & 0xff ) );
	114	+ }
	115	+
	116	+ switch ( pads ) {
	117	+ case 1:
	118	+ b10 = ( _getbyte64( s, i ) << 18 ) \| ( _getbyte64( s, i + 1 ) << 12 ) \| ( _getbyte64( s, i + 2 ) << 6 );
	119	+ x.push( String.fromCharCode( b10 >> 16, ( b10 >> 8 ) & 0xff ) );
	120	+ break;
	121	+
	122	+ case 2:
	123	+ b10 = ( _getbyte64( s, i ) << 18) \| ( _getbyte64( s, i + 1 ) << 12 );
	124	+ x.push( String.fromCharCode( b10 >> 16 ) );
	125	+ break;
	126	+ }
	127	+
	128	+ return x.join( "" );
	129	+ }
	130	+
	131	+
	132	+ function _getbyte( s, i ) {
	133	+ var x = s.charCodeAt( i );
	134	+
	135	+ if ( x > 255 ) {
	136	+ throw "INVALID_CHARACTER_ERR: DOM Exception 5";
	137	+ }
	138	+
	139	+ return x;
	140	+ }
	141	+
	142	+
	143	+ function _encode( s ) {
	144	+ if ( arguments.length !== 1 ) {
	145	+ throw "SyntaxError: exactly one argument required";
	146	+ }
	147	+
	148	+ s = String( s );
	149	+
	150	+ var i,
	151	+ b10,
	152	+ x = [],
	153	+ imax = s.length - s.length % 3;
	154	+
	155	+ if ( s.length === 0 ) {
	156	+ return s;
	157	+ }
	158	+
	159	+ for ( i = 0; i < imax; i += 3 ) {
	160	+ b10 = ( _getbyte( s, i ) << 16 ) \| ( _getbyte( s, i + 1 ) << 8 ) \| _getbyte( s, i + 2 );
	161	+ x.push( _ALPHA.charAt( b10 >> 18 ) );
	162	+ x.push( _ALPHA.charAt( ( b10 >> 12 ) & 0x3F ) );
	163	+ x.push( _ALPHA.charAt( ( b10 >> 6 ) & 0x3f ) );
	164	+ x.push( _ALPHA.charAt( b10 & 0x3f ) );
	165	+ }
	166	+
	167	+ switch ( s.length - imax ) {
	168	+ case 1:
	169	+ b10 = _getbyte( s, i ) << 16;
	170	+ x.push( _ALPHA.charAt( b10 >> 18 ) + _ALPHA.charAt( ( b10 >> 12 ) & 0x3F ) + _PADCHAR + _PADCHAR );
	171	+ break;
	172	+
	173	+ case 2:
	174	+ b10 = ( _getbyte( s, i ) << 16 ) \| ( _getbyte( s, i + 1 ) << 8 );
	175	+ x.push( _ALPHA.charAt( b10 >> 18 ) + _ALPHA.charAt( ( b10 >> 12 ) & 0x3F ) + _ALPHA.charAt( ( b10 >> 6 ) & 0x3f ) + _PADCHAR );
	176	+ break;
	177	+ }
	178	+
	179	+ return x.join( "" );
	180	+ }
	181	+
	182	+
	183	+ return {
	184	+ decode: _decode,
	185	+ encode: _encode,
	186	+ VERSION: _VERSION
	187	+ };
	188	+
	189	+}( jQuery ) );
	190	+
@@ -0,0 +1,303 @@		@@ -0,0 +1,303 @@
	1	+/**
	2	+ * jsPDF
	3	+ * (c) 2009 James Hall
	4	+ *
	5	+ * Some parts based on FPDF.
	6	+ */
	7	+
	8	+var jsPDF = function(){
	9	+
	10	+ // Private properties
	11	+ var version = '20090504';
	12	+ var buffer = '';
	13	+
	14	+ var pdfVersion = '1.3'; // PDF Version
	15	+ var defaultPageFormat = 'a4';
	16	+ var pageFormats = { // Size in mm of various paper formats
	17	+ 'a3': [841.89, 1190.55],
	18	+ 'a4': [595.28, 841.89],
	19	+ 'a5': [420.94, 595.28],
	20	+ 'letter': [612, 792],
	21	+ 'legal': [612, 1008]
	22	+ };
	23	+ var textColor = '0 g';
	24	+ var page = 0;
	25	+ var objectNumber = 2; // 'n' Current object number
	26	+ var state = 0; // Current document state
	27	+ var pages = new Array();
	28	+ var offsets = new Array(); // List of offsets
	29	+ var lineWidth = 0.200025; // 2mm
	30	+ var pageHeight;
	31	+ var k; // Scale factor
	32	+ var unit = 'mm'; // Default to mm for units
	33	+ var fontNumber; // TODO: This is temp, replace with real font handling
	34	+ var documentProperties = {};
	35	+ var fontSize = 16; // Default font size
	36	+ var pageFontSize = 16;
	37	+
	38	+ // Initilisation
	39	+ if (unit == 'pt') {
	40	+ k = 1;
	41	+ } else if(unit == 'mm') {
	42	+ k = 72/25.4;
	43	+ } else if(unit == 'cm') {
	44	+ k = 72/2.54;
	45	+ } else if(unit == 'in') {
	46	+ k = 72;
	47	+ }
	48	+
	49	+ // Private functions
	50	+ var newObject = function() {
	51	+ //Begin a new object
	52	+ objectNumber ++;
	53	+ offsets[objectNumber] = buffer.length;
	54	+ out(objectNumber + ' 0 obj');
	55	+ }
	56	+
	57	+
	58	+ var putHeader = function() {
	59	+ out('%PDF-' + pdfVersion);
	60	+ }
	61	+
	62	+ var putPages = function() {
	63	+
	64	+ // TODO: Fix, hardcoded to a4 portrait
	65	+ var wPt = pageWidth * k;
	66	+ var hPt = pageHeight * k;
	67	+
	68	+ for(n=1; n <= page; n++) {
	69	+ newObject();
	70	+ out('<</Type /Page');
	71	+ out('/Parent 1 0 R');
	72	+ out('/Resources 2 0 R');
	73	+ out('/Contents ' + (objectNumber + 1) + ' 0 R>>');
	74	+ out('endobj');
	75	+
	76	+ //Page content
	77	+ p = pages[n];
	78	+ newObject();
	79	+ out('<</Length ' + p.length + '>>');
	80	+ putStream(p);
	81	+ out('endobj');
	82	+ }
	83	+ offsets[1] = buffer.length;
	84	+ out('1 0 obj');
	85	+ out('<</Type /Pages');
	86	+ var kids='/Kids [';
	87	+ for (i = 0; i < page; i++) {
	88	+ kids += (3 + 2 * i) + ' 0 R ';
	89	+ }
	90	+ out(kids + ']');
	91	+ out('/Count ' + page);
	92	+ out(sprintf('/MediaBox [0 0 %.2f %.2f]', wPt, hPt));
	93	+ out('>>');
	94	+ out('endobj');
	95	+ }
	96	+
	97	+ var putStream = function(str) {
	98	+ out('stream');
	99	+ out(str);
	100	+ out('endstream');
	101	+ }
	102	+
	103	+ var putResources = function() {
	104	+ putFonts();
	105	+ putImages();
	106	+
	107	+ //Resource dictionary
	108	+ offsets[2] = buffer.length;
	109	+ out('2 0 obj');
	110	+ out('<<');
	111	+ putResourceDictionary();
	112	+ out('>>');
	113	+ out('endobj');
	114	+ }
	115	+
	116	+ var putFonts = function() {
	117	+ // TODO: Only supports core font hardcoded to Helvetica
	118	+ newObject();
	119	+ fontNumber = objectNumber;
	120	+ name = 'Helvetica';
	121	+ out('<</Type /Font');
	122	+ out('/BaseFont /' + name);
	123	+ out('/Subtype /Type1');
	124	+ out('/Encoding /WinAnsiEncoding');
	125	+ out('>>');
	126	+ out('endobj');
	127	+ }
	128	+
	129	+ var putImages = function() {
	130	+ // TODO
	131	+ }
	132	+
	133	+ var putResourceDictionary = function() {
	134	+ out('/ProcSet [/PDF /Text /ImageB /ImageC /ImageI]');
	135	+ out('/Font <<');
	136	+ // Do this for each font, the '1' bit is the index of the font
	137	+ // fontNumber is currently the object number related to 'putFonts'
	138	+ out('/F1 ' + fontNumber + ' 0 R');
	139	+ out('>>');
	140	+ out('/XObject <<');
	141	+ putXobjectDict();
	142	+ out('>>');
	143	+ }
	144	+
	145	+ var putXobjectDict = function() {
	146	+ // TODO
	147	+ // Loop through images
	148	+ }
	149	+
	150	+
	151	+ var putInfo = function() {
	152	+ out('/Producer (jsPDF ' + version + ')');
	153	+ if(documentProperties.title != undefined) {
	154	+ out('/Title (' + pdfEscape(documentProperties.title) + ')');
	155	+ }
	156	+ if(documentProperties.subject != undefined) {
	157	+ out('/Subject (' + pdfEscape(documentProperties.subject) + ')');
	158	+ }
	159	+ if(documentProperties.author != undefined) {
	160	+ out('/Author (' + pdfEscape(documentProperties.author) + ')');
	161	+ }
	162	+ if(documentProperties.keywords != undefined) {
	163	+ out('/Keywords (' + pdfEscape(documentProperties.keywords) + ')');
	164	+ }
	165	+ if(documentProperties.creator != undefined) {
	166	+ out('/Creator (' + pdfEscape(documentProperties.creator) + ')');
	167	+ }
	168	+ var created = new Date();
	169	+ var year = created.getFullYear();
	170	+ var month = (created.getMonth() + 1);
	171	+ var day = created.getDate();
	172	+ var hour = created.getHours();
	173	+ var minute = created.getMinutes();
	174	+ var second = created.getSeconds();
	175	+ out('/CreationDate (D:' + sprintf('%02d%02d%02d%02d%02d%02d', year, month, day, hour, minute, second) + ')');
	176	+ }
	177	+
	178	+ var putCatalog = function () {
	179	+ out('/Type /Catalog');
	180	+ out('/Pages 1 0 R');
	181	+ // TODO: Add zoom and layout modes
	182	+ out('/OpenAction [3 0 R /FitH null]');
	183	+ out('/PageLayout /OneColumn');
	184	+ }
	185	+
	186	+ function putTrailer() {
	187	+ out('/Size ' + (objectNumber + 1));
	188	+ out('/Root ' + objectNumber + ' 0 R');
	189	+ out('/Info ' + (objectNumber - 1) + ' 0 R');
	190	+ }
	191	+
	192	+ var endDocument = function() {
	193	+ state = 1;
	194	+ putHeader();
	195	+ putPages();
	196	+
	197	+ putResources();
	198	+ //Info
	199	+ newObject();
	200	+ out('<<');
	201	+ putInfo();
	202	+ out('>>');
	203	+ out('endobj');
	204	+
	205	+ //Catalog
	206	+ newObject();
	207	+ out('<<');
	208	+ putCatalog();
	209	+ out('>>');
	210	+ out('endobj');
	211	+
	212	+ //Cross-ref
	213	+ var o = buffer.length;
	214	+ out('xref');
	215	+ out('0 ' + (objectNumber + 1));
	216	+ out('0000000000 65535 f ');
	217	+ for (var i=1; i <= objectNumber; i++) {
	218	+ out(sprintf('%010d 00000 n ', offsets[i]));
	219	+ }
	220	+ //Trailer
	221	+ out('trailer');
	222	+ out('<<');
	223	+ putTrailer();
	224	+ out('>>');
	225	+ out('startxref');
	226	+ out(o);
	227	+ out('%%EOF');
	228	+ state = 3;
	229	+ }
	230	+
	231	+ var beginPage = function() {
	232	+ page ++;
	233	+ // Do dimension stuff
	234	+ state = 2;
	235	+ pages[page] = '';
	236	+
	237	+ // TODO: Hardcoded at A4 and portrait
	238	+ pageHeight = pageFormats['a4'][1] / k;
	239	+ pageWidth = pageFormats['a4'][0] / k;
	240	+ }
	241	+
	242	+ var out = function(string) {
	243	+ if(state == 2) {
	244	+ pages[page] += string + '\n';
	245	+ } else {
	246	+ buffer += string + '\n';
	247	+ }
	248	+ }
	249	+
	250	+ var _addPage = function() {
	251	+ beginPage();
	252	+ // Set line width
	253	+ out(sprintf('%.2f w', (lineWidth * k)));
	254	+
	255	+ // Set font - TODO
	256	+ // 16 is the font size
	257	+ pageFontSize = fontSize;
	258	+ out('BT /F1 ' + parseInt(fontSize) + '.00 Tf ET');
	259	+ }
	260	+
	261	+ // Add the first page automatically
	262	+ _addPage();
	263	+
	264	+ // Escape text
	265	+ var pdfEscape = function(text) {
	266	+ return text.replace(/\\/g, '\\\\').replace(/\(/g, '\\(').replace(/\)/g, '\\)');
	267	+ }
	268	+
	269	+ return {
	270	+ addPage: function() {
	271	+ _addPage();
	272	+ },
	273	+ text: function(x, y, text) {
	274	+ // need page height
	275	+ if(pageFontSize != fontSize) {
	276	+ out('BT /F1 ' + parseInt(fontSize) + '.00 Tf ET');
	277	+ pageFontSize = fontSize;
	278	+ }
	279	+ var str = sprintf('BT %.2f %.2f Td (%s) Tj ET', x * k, (pageHeight - y) * k, pdfEscape(text));
	280	+ out(str);
	281	+ },
	282	+ setProperties: function(properties) {
	283	+ documentProperties = properties;
	284	+ },
	285	+ addImage: function(imageData, format, x, y, w, h) {
	286	+
	287	+ },
	288	+ output: function(type, options) {
	289	+ endDocument();
	290	+ if(type == undefined) {
	291	+ return buffer;
	292	+ }
	293	+ if(type == 'datauri') {
	294	+ document.location.href = 'data:application/pdf;base64,' + Base64.encode(buffer);
	295	+ }
	296	+ // @TODO: Add different output options
	297	+ },
	298	+ setFontSize: function(size) {
	299	+ fontSize = size;
	300	+ }
	301	+ }
	302	+
	303	+};
@@ -0,0 +1,143 @@		@@ -0,0 +1,143 @@
	1	+
	2	+/**
	3	+*
	4	+* Base64 encode / decode
	5	+* http://www.webtoolkit.info/
	6	+*
	7	+**/
	8	+
	9	+var Base64 = {
	10	+
	11	+ // private property
	12	+ _keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
	13	+
	14	+ // public method for encoding
	15	+ encode : function (input) {
	16	+ var output = "";
	17	+ var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
	18	+ var i = 0;
	19	+
	20	+ input = Base64._utf8_encode(input);
	21	+
	22	+ while (i < input.length) {
	23	+
	24	+ chr1 = input.charCodeAt(i++);
	25	+ chr2 = input.charCodeAt(i++);
	26	+ chr3 = input.charCodeAt(i++);
	27	+
	28	+ enc1 = chr1 >> 2;
	29	+ enc2 = ((chr1 & 3) << 4) \| (chr2 >> 4);
	30	+ enc3 = ((chr2 & 15) << 2) \| (chr3 >> 6);
	31	+ enc4 = chr3 & 63;
	32	+
	33	+ if (isNaN(chr2)) {
	34	+ enc3 = enc4 = 64;
	35	+ } else if (isNaN(chr3)) {
	36	+ enc4 = 64;
	37	+ }
	38	+
	39	+ output = output +
	40	+ this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2) +
	41	+ this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);
	42	+
	43	+ }
	44	+
	45	+ return output;
	46	+ },
	47	+
	48	+ // public method for decoding
	49	+ decode : function (input) {
	50	+ var output = "";
	51	+ var chr1, chr2, chr3;
	52	+ var enc1, enc2, enc3, enc4;
	53	+ var i = 0;
	54	+
	55	+ input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
	56	+
	57	+ while (i < input.length) {
	58	+
	59	+ enc1 = this._keyStr.indexOf(input.charAt(i++));
	60	+ enc2 = this._keyStr.indexOf(input.charAt(i++));
	61	+ enc3 = this._keyStr.indexOf(input.charAt(i++));
	62	+ enc4 = this._keyStr.indexOf(input.charAt(i++));
	63	+
	64	+ chr1 = (enc1 << 2) \| (enc2 >> 4);
	65	+ chr2 = ((enc2 & 15) << 4) \| (enc3 >> 2);
	66	+ chr3 = ((enc3 & 3) << 6) \| enc4;
	67	+
	68	+ output = output + String.fromCharCode(chr1);
	69	+
	70	+ if (enc3 != 64) {
	71	+ output = output + String.fromCharCode(chr2);
	72	+ }
	73	+ if (enc4 != 64) {
	74	+ output = output + String.fromCharCode(chr3);
	75	+ }
	76	+
	77	+ }
	78	+
	79	+ output = Base64._utf8_decode(output);
	80	+
	81	+ return output;
	82	+
	83	+ },
	84	+
	85	+ // private method for UTF-8 encoding
	86	+ _utf8_encode : function (string) {
	87	+ string = string.replace(/\r\n/g,"\n");
	88	+ var utftext = "";
	89	+
	90	+ for (var n = 0; n < string.length; n++) {
	91	+
	92	+ var c = string.charCodeAt(n);
	93	+
	94	+ if (c < 128) {
	95	+ utftext += String.fromCharCode(c);
	96	+ }
	97	+ else if((c > 127) && (c < 2048)) {
	98	+ utftext += String.fromCharCode((c >> 6) \| 192);
	99	+ utftext += String.fromCharCode((c & 63) \| 128);
	100	+ }
	101	+ else {
	102	+ utftext += String.fromCharCode((c >> 12) \| 224);
	103	+ utftext += String.fromCharCode(((c >> 6) & 63) \| 128);
	104	+ utftext += String.fromCharCode((c & 63) \| 128);
	105	+ }
	106	+
	107	+ }
	108	+
	109	+ return utftext;
	110	+ },
	111	+
	112	+ // private method for UTF-8 decoding
	113	+ _utf8_decode : function (utftext) {
	114	+ var string = "";
	115	+ var i = 0;
	116	+ var c = c1 = c2 = 0;
	117	+
	118	+ while ( i < utftext.length ) {
	119	+
	120	+ c = utftext.charCodeAt(i);
	121	+
	122	+ if (c < 128) {
	123	+ string += String.fromCharCode(c);
	124	+ i++;
	125	+ }
	126	+ else if((c > 191) && (c < 224)) {
	127	+ c2 = utftext.charCodeAt(i+1);
	128	+ string += String.fromCharCode(((c & 31) << 6) \| (c2 & 63));
	129	+ i += 2;
	130	+ }
	131	+ else {
	132	+ c2 = utftext.charCodeAt(i+1);
	133	+ c3 = utftext.charCodeAt(i+2);
	134	+ string += String.fromCharCode(((c & 15) << 12) \| ((c2 & 63) << 6) \| (c3 & 63));
	135	+ i += 3;
	136	+ }
	137	+
	138	+ }
	139	+
	140	+ return string;
	141	+ }
	142	+
	143	+}
@@ -0,0 +1,152 @@		@@ -0,0 +1,152 @@
	1	+
	2	+
	3	+function sprintf( ) {
	4	+ // Return a formatted string
	5	+ //
	6	+ // version: 903.3016
	7	+ // discuss at: http://phpjs.org/functions/sprintf
	8	+ // + original by: Ash Searle (http://hexmen.com/blog/)
	9	+ // + namespaced by: Michael White (http://getsprink.com)
	10	+ // + tweaked by: Jack
	11	+ // + improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	12	+ // + input by: Paulo Ricardo F. Santos
	13	+ // + improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	14	+ // + input by: Brett Zamir (http://brettz9.blogspot.com)
	15	+ // + improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	16	+ // * example 1: sprintf("%01.2f", 123.1);
	17	+ // * returns 1: 123.10
	18	+ // * example 2: sprintf("[%10s]", 'monkey');
	19	+ // * returns 2: '[ monkey]'
	20	+ // * example 3: sprintf("[%'#10s]", 'monkey');
	21	+ // * returns 3: '[####monkey]'
	22	+ var regex = /%%\|%(\d+\$)?([-+\'#0 ])(\\d+\$\|\\|\d+)?(\.(\\d+\$\|\*\|\d+))?([scboxXuidfegEG])/g;
	23	+ var a = arguments, i = 0, format = a[i++];
	24	+
	25	+ // pad()
	26	+ var pad = function(str, len, chr, leftJustify) {
	27	+ if (!chr) chr = ' ';
	28	+ var padding = (str.length >= len) ? '' : Array(1 + len - str.length >>> 0).join(chr);
	29	+ return leftJustify ? str + padding : padding + str;
	30	+ };
	31	+
	32	+ // justify()
	33	+ var justify = function(value, prefix, leftJustify, minWidth, zeroPad, customPadChar) {
	34	+ var diff = minWidth - value.length;
	35	+ if (diff > 0) {
	36	+ if (leftJustify \|\| !zeroPad) {
	37	+ value = pad(value, minWidth, customPadChar, leftJustify);
	38	+ } else {
	39	+ value = value.slice(0, prefix.length) + pad('', diff, '0', true) + value.slice(prefix.length);
	40	+ }
	41	+ }
	42	+ return value;
	43	+ };
	44	+
	45	+ // formatBaseX()
	46	+ var formatBaseX = function(value, base, prefix, leftJustify, minWidth, precision, zeroPad) {
	47	+ // Note: casts negative numbers to positive ones
	48	+ var number = value >>> 0;
	49	+ prefix = prefix && number && {'2': '0b', '8': '0', '16': '0x'}[base] \|\| '';
	50	+ value = prefix + pad(number.toString(base), precision \|\| 0, '0', false);
	51	+ return justify(value, prefix, leftJustify, minWidth, zeroPad);
	52	+ };
	53	+
	54	+ // formatString()
	55	+ var formatString = function(value, leftJustify, minWidth, precision, zeroPad, customPadChar) {
	56	+ if (precision != null) {
	57	+ value = value.slice(0, precision);
	58	+ }
	59	+ return justify(value, '', leftJustify, minWidth, zeroPad, customPadChar);
	60	+ };
	61	+
	62	+ // doFormat()
	63	+ var doFormat = function(substring, valueIndex, flags, minWidth, _, precision, type) {
	64	+ var number;
	65	+ var prefix;
	66	+ var method;
	67	+ var textTransform;
	68	+ var value;
	69	+
	70	+ if (substring == '%%') return '%';
	71	+
	72	+ // parse flags
	73	+ var leftJustify = false, positivePrefix = '', zeroPad = false, prefixBaseX = false, customPadChar = ' ';
	74	+ var flagsl = flags.length;
	75	+ for (var j = 0; flags && j < flagsl; j++) switch (flags.charAt(j)) {
	76	+ case ' ': positivePrefix = ' '; break;
	77	+ case '+': positivePrefix = '+'; break;
	78	+ case '-': leftJustify = true; break;
	79	+ case "'": customPadChar = flags.charAt(j+1); break;
	80	+ case '0': zeroPad = true; break;
	81	+ case '#': prefixBaseX = true; break;
	82	+ }
	83	+
	84	+ // parameters may be null, undefined, empty-string or real valued
	85	+ // we want to ignore null, undefined and empty-string values
	86	+ if (!minWidth) {
	87	+ minWidth = 0;
	88	+ } else if (minWidth == '*') {
	89	+ minWidth = +a[i++];
	90	+ } else if (minWidth.charAt(0) == '*') {
	91	+ minWidth = +a[minWidth.slice(1, -1)];
	92	+ } else {
	93	+ minWidth = +minWidth;
	94	+ }
	95	+
	96	+ // Note: undocumented perl feature:
	97	+ if (minWidth < 0) {
	98	+ minWidth = -minWidth;
	99	+ leftJustify = true;
	100	+ }
	101	+
	102	+ if (!isFinite(minWidth)) {
	103	+ throw new Error('sprintf: (minimum-)width must be finite');
	104	+ }
	105	+
	106	+ if (!precision) {
	107	+ precision = 'fFeE'.indexOf(type) > -1 ? 6 : (type == 'd') ? 0 : void(0);
	108	+ } else if (precision == '*') {
	109	+ precision = +a[i++];
	110	+ } else if (precision.charAt(0) == '*') {
	111	+ precision = +a[precision.slice(1, -1)];
	112	+ } else {
	113	+ precision = +precision;
	114	+ }
	115	+
	116	+ // grab value using valueIndex if required?
	117	+ value = valueIndex ? a[valueIndex.slice(0, -1)] : a[i++];
	118	+
	119	+ switch (type) {
	120	+ case 's': return formatString(String(value), leftJustify, minWidth, precision, zeroPad, customPadChar);
	121	+ case 'c': return formatString(String.fromCharCode(+value), leftJustify, minWidth, precision, zeroPad);
	122	+ case 'b': return formatBaseX(value, 2, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
	123	+ case 'o': return formatBaseX(value, 8, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
	124	+ case 'x': return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
	125	+ case 'X': return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad).toUpperCase();
	126	+ case 'u': return formatBaseX(value, 10, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
	127	+ case 'i':
	128	+ case 'd': {
	129	+ number = parseInt(+value);
	130	+ prefix = number < 0 ? '-' : positivePrefix;
	131	+ value = prefix + pad(String(Math.abs(number)), precision, '0', false);
	132	+ return justify(value, prefix, leftJustify, minWidth, zeroPad);
	133	+ }
	134	+ case 'e':
	135	+ case 'E':
	136	+ case 'f':
	137	+ case 'F':
	138	+ case 'g':
	139	+ case 'G': {
	140	+ number = +value;
	141	+ prefix = number < 0 ? '-' : positivePrefix;
	142	+ method = ['toExponential', 'toFixed', 'toPrecision']['efg'.indexOf(type.toLowerCase())];
	143	+ textTransform = ['toString', 'toUpperCase']['eEfFgG'.indexOf(type) % 2];
	144	+ value = prefix + Math.abs(number)[method](precision);
	145	+ return justify(value, prefix, leftJustify, minWidth, zeroPad)[textTransform]();
	146	+ }
	147	+ default: return substring;
	148	+ }
	149	+ };
	150	+
	151	+ return format.replace(regex, doFormat);
	152	+}
@@ -0,0 +1,359 @@		@@ -0,0 +1,359 @@
	1	+/*The MIT License (MIT)
	2	+
	3	+Copyright (c) 2014 https://github.com/kayalshri/
	4	+
	5	+Permission is hereby granted, free of charge, to any person obtaining a copy
	6	+of this software and associated documentation files (the "Software"), to deal
	7	+in the Software without restriction, including without limitation the rights
	8	+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	9	+copies of the Software, and to permit persons to whom the Software is
	10	+furnished to do so, subject to the following conditions:
	11	+
	12	+The above copyright notice and this permission notice shall be included in
	13	+all copies or substantial portions of the Software.
	14	+
	15	+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	18	+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	21	+THE SOFTWARE.*/
	22	+
	23	+(function($){
	24	+ $.fn.extend({
	25	+ tableExport: function(options) {
	26	+ var defaults = {
	27	+ separator: ',',
	28	+ ignoreColumn: [],
	29	+ tableName:'yourTableName',
	30	+ type:'csv',
	31	+ pdfFontSize:14,
	32	+ pdfLeftMargin:20,
	33	+ escape:'true',
	34	+ htmlContent:'false',
	35	+ consoleLog:'false'
	36	+ };
	37	+
	38	+ var options = $.extend(defaults, options);
	39	+ var el = this;
	40	+
	41	+ if(defaults.type == 'csv' \|\| defaults.type == 'txt'){
	42	+
	43	+ // Header
	44	+ var tdData ="";
	45	+ $(el).find('thead').find('tr').each(function() {
	46	+ tdData += "\n";
	47	+ $(this).filter(':visible').find('th').each(function(index,data) {
	48	+ if ($(this).css('display') != 'none'){
	49	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	50	+ tdData += '"' + parseString($(this)) + '"' + defaults.separator;
	51	+ }
	52	+ }
	53	+
	54	+ });
	55	+ tdData = $.trim(tdData);
	56	+ tdData = $.trim(tdData).substring(0, tdData.length -1);
	57	+ });
	58	+
	59	+ // Row vs Column
	60	+ $(el).find('tbody').find('tr').each(function() {
	61	+ tdData += "\n";
	62	+ $(this).filter(':visible').find('td').each(function(index,data) {
	63	+ if ($(this).css('display') != 'none'){
	64	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	65	+ tdData += '"'+ parseString($(this)) + '"'+ defaults.separator;
	66	+ }
	67	+ }
	68	+ });
	69	+ //tdData = $.trim(tdData);
	70	+ tdData = $.trim(tdData).substring(0, tdData.length -1);
	71	+ });
	72	+
	73	+ //output
	74	+ if(defaults.consoleLog == 'true'){
	75	+ console.log(tdData);
	76	+ }
	77	+ var base64data = "base64," + $.base64.encode(tdData);
	78	+ window.open('data:application/'+defaults.type+';filename=exportData;' + base64data);
	79	+ }else if(defaults.type == 'sql'){
	80	+
	81	+ // Header
	82	+ var tdData ="INSERT INTO `"+defaults.tableName+"` (";
	83	+ $(el).find('thead').find('tr').each(function() {
	84	+
	85	+ $(this).filter(':visible').find('th').each(function(index,data) {
	86	+ if ($(this).css('display') != 'none'){
	87	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	88	+ tdData += '`' + parseString($(this)) + '`,' ;
	89	+ }
	90	+ }
	91	+
	92	+ });
	93	+ tdData = $.trim(tdData);
	94	+ tdData = $.trim(tdData).substring(0, tdData.length -1);
	95	+ });
	96	+ tdData += ") VALUES ";
	97	+ // Row vs Column
	98	+ $(el).find('tbody').find('tr').each(function() {
	99	+ tdData += "(";
	100	+ $(this).filter(':visible').find('td').each(function(index,data) {
	101	+ if ($(this).css('display') != 'none'){
	102	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	103	+ tdData += '"'+ parseString($(this)) + '",';
	104	+ }
	105	+ }
	106	+ });
	107	+
	108	+ tdData = $.trim(tdData).substring(0, tdData.length -1);
	109	+ tdData += "),";
	110	+ });
	111	+ tdData = $.trim(tdData).substring(0, tdData.length -1);
	112	+ tdData += ";";
	113	+
	114	+ //output
	115	+ //console.log(tdData);
	116	+
	117	+ if(defaults.consoleLog == 'true'){
	118	+ console.log(tdData);
	119	+ }
	120	+
	121	+ var base64data = "base64," + $.base64.encode(tdData);
	122	+ window.open('data:application/sql;filename=exportData;' + base64data);
	123	+
	124	+
	125	+ }else if(defaults.type == 'json'){
	126	+
	127	+ var jsonHeaderArray = [];
	128	+ $(el).find('thead').find('tr').each(function() {
	129	+ var tdData ="";
	130	+ var jsonArrayTd = [];
	131	+
	132	+ $(this).filter(':visible').find('th').each(function(index,data) {
	133	+ if ($(this).css('display') != 'none'){
	134	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	135	+ jsonArrayTd.push(parseString($(this)));
	136	+ }
	137	+ }
	138	+ });
	139	+ jsonHeaderArray.push(jsonArrayTd);
	140	+
	141	+ });
	142	+
	143	+ var jsonArray = [];
	144	+ $(el).find('tbody').find('tr').each(function() {
	145	+ var tdData ="";
	146	+ var jsonArrayTd = [];
	147	+
	148	+ $(this).filter(':visible').find('td').each(function(index,data) {
	149	+ if ($(this).css('display') != 'none'){
	150	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	151	+ jsonArrayTd.push(parseString($(this)));
	152	+ }
	153	+ }
	154	+ });
	155	+ jsonArray.push(jsonArrayTd);
	156	+
	157	+ });
	158	+
	159	+ var jsonExportArray =[];
	160	+ jsonExportArray.push({header:jsonHeaderArray,data:jsonArray});
	161	+
	162	+ //Return as JSON
	163	+ //console.log(JSON.stringify(jsonExportArray));
	164	+
	165	+ //Return as Array
	166	+ //console.log(jsonExportArray);
	167	+ if(defaults.consoleLog == 'true'){
	168	+ console.log(JSON.stringify(jsonExportArray));
	169	+ }
	170	+ var base64data = "base64," + $.base64.encode(JSON.stringify(jsonExportArray));
	171	+ window.open('data:application/json;filename=exportData;' + base64data);
	172	+ }else if(defaults.type == 'xml'){
	173	+
	174	+ var xml = '<?xml version="1.0" encoding="utf-8"?>';
	175	+ xml += '<tabledata><fields>';
	176	+
	177	+ // Header
	178	+ $(el).find('thead').find('tr').each(function() {
	179	+ $(this).filter(':visible').find('th').each(function(index,data) {
	180	+ if ($(this).css('display') != 'none'){
	181	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	182	+ xml += "<field>" + parseString($(this)) + "</field>";
	183	+ }
	184	+ }
	185	+ });
	186	+ });
	187	+ xml += '</fields><data>';
	188	+
	189	+ // Row Vs Column
	190	+ var rowCount=1;
	191	+ $(el).find('tbody').find('tr').each(function() {
	192	+ xml += '<row id="'+rowCount+'">';
	193	+ var colCount=0;
	194	+ $(this).filter(':visible').find('td').each(function(index,data) {
	195	+ if ($(this).css('display') != 'none'){
	196	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	197	+ xml += "<column-"+colCount+">"+parseString($(this))+"</column-"+colCount+">";
	198	+ }
	199	+ }
	200	+ colCount++;
	201	+ });
	202	+ rowCount++;
	203	+ xml += '</row>';
	204	+ });
	205	+ xml += '</data></tabledata>'
	206	+
	207	+ if(defaults.consoleLog == 'true'){
	208	+ console.log(xml);
	209	+ }
	210	+
	211	+ var base64data = "base64," + $.base64.encode(xml);
	212	+ window.open('data:application/xml;filename=exportData;' + base64data);
	213	+
	214	+ }else if(defaults.type == 'excel' \|\| defaults.type == 'doc'\|\| defaults.type == 'powerpoint' ){
	215	+ //console.log($(this).html());
	216	+ var excel="<table>";
	217	+ // Header
	218	+ $(el).find('thead').find('tr').each(function() {
	219	+ excel += "<tr>";
	220	+ $(this).filter(':visible').find('th').each(function(index,data) {
	221	+ if ($(this).css('display') != 'none'){
	222	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	223	+ excel += "<td>" + parseString($(this))+ "</td>";
	224	+ }
	225	+ }
	226	+ });
	227	+ excel += '</tr>';
	228	+
	229	+ });
	230	+
	231	+
	232	+ // Row Vs Column
	233	+ var rowCount=1;
	234	+ $(el).find('tbody').find('tr').each(function() {
	235	+ excel += "<tr>";
	236	+ var colCount=0;
	237	+ $(this).filter(':visible').find('td').each(function(index,data) {
	238	+ if ($(this).css('display') != 'none'){
	239	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	240	+ excel += "<td>"+parseString($(this))+"</td>";
	241	+ }
	242	+ }
	243	+ colCount++;
	244	+ });
	245	+ rowCount++;
	246	+ excel += '</tr>';
	247	+ });
	248	+ excel += '</table>'
	249	+
	250	+ if(defaults.consoleLog == 'true'){
	251	+ console.log(excel);
	252	+ }
	253	+
	254	+ var excelFile = "<html xmlns:o='urn:schemas-microsoft-com:office:office' xmlns:x='urn:schemas-microsoft-com:office:"+defaults.type+"' xmlns='http://www.w3.org/TR/REC-html40'>";
	255	+ excelFile += "<head>";
	256	+ excelFile += "<!--[if gte mso 9]>";
	257	+ excelFile += "<xml>";
	258	+ excelFile += "<x:ExcelWorkbook>";
	259	+ excelFile += "<x:ExcelWorksheets>";
	260	+ excelFile += "<x:ExcelWorksheet>";
	261	+ excelFile += "<x:Name>";
	262	+ excelFile += "{worksheet}";
	263	+ excelFile += "</x:Name>";
	264	+ excelFile += "<x:WorksheetOptions>";
	265	+ excelFile += "<x:DisplayGridlines/>";
	266	+ excelFile += "</x:WorksheetOptions>";
	267	+ excelFile += "</x:ExcelWorksheet>";
	268	+ excelFile += "</x:ExcelWorksheets>";
	269	+ excelFile += "</x:ExcelWorkbook>";
	270	+ excelFile += "</xml>";
	271	+ excelFile += "<![endif]-->";
	272	+ excelFile += "</head>";
	273	+ excelFile += "<body>";
	274	+ excelFile += excel;
	275	+ excelFile += "</body>";
	276	+ excelFile += "</html>";
	277	+
	278	+ var base64data = "base64," + $.base64.encode(excelFile);
	279	+ window.open('data:application/vnd.ms-'+defaults.type+';filename=exportData.doc;' + base64data);
	280	+
	281	+ }else if(defaults.type == 'png'){
	282	+ html2canvas($(el), {
	283	+ onrendered: function(canvas) {
	284	+ var img = canvas.toDataURL("image/png");
	285	+ window.open(img);
	286	+
	287	+
	288	+ }
	289	+ });
	290	+ }else if(defaults.type == 'pdf'){
	291	+
	292	+ var doc = new jsPDF('p','pt', 'a4', true);
	293	+ doc.setFontSize(defaults.pdfFontSize);
	294	+
	295	+ // Header
	296	+ var startColPosition=defaults.pdfLeftMargin;
	297	+ $(el).find('thead').find('tr').each(function() {
	298	+ $(this).filter(':visible').find('th').each(function(index,data) {
	299	+ if ($(this).css('display') != 'none'){
	300	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	301	+ var colPosition = startColPosition+ (index * 50);
	302	+ doc.text(colPosition,20, parseString($(this)));
	303	+ }
	304	+ }
	305	+ });
	306	+ });
	307	+
	308	+
	309	+ // Row Vs Column
	310	+ var startRowPosition = 20; var page =1;var rowPosition=0;
	311	+ $(el).find('tbody').find('tr').each(function(index,data) {
	312	+ rowCalc = index+1;
	313	+
	314	+ if (rowCalc % 26 == 0){
	315	+ doc.addPage();
	316	+ page++;
	317	+ startRowPosition=startRowPosition+10;
	318	+ }
	319	+ rowPosition=(startRowPosition + (rowCalc * 10)) - ((page -1) * 280);
	320	+
	321	+ $(this).filter(':visible').find('td').each(function(index,data) {
	322	+ if ($(this).css('display') != 'none'){
	323	+ if(defaults.ignoreColumn.indexOf(index) == -1){
	324	+ var colPosition = startColPosition+ (index * 50);
	325	+ doc.text(colPosition,rowPosition, parseString($(this)));
	326	+ }
	327	+ }
	328	+
	329	+ });
	330	+
	331	+ });
	332	+
	333	+ // Output as Data URI
	334	+ doc.output('datauri');
	335	+
	336	+ }
	337	+
	338	+
	339	+ function parseString(data){
	340	+
	341	+ if(defaults.htmlContent == 'true'){
	342	+ content_data = data.html().trim();
	343	+ }else{
	344	+ content_data = data.text().trim();
	345	+ }
	346	+
	347	+ if(defaults.escape == 'true'){
	348	+ content_data = escape(content_data);
	349	+ }
	350	+
	351	+
	352	+
	353	+ return content_data;
	354	+ }
	355	+
	356	+ }
	357	+ });
	358	+ })(jQuery);
	359	+