/**
 * jscolor - JavaScript Color Picker
 *
 * @link    http://jscolor.com
 * @license For open source use: GPLv3
 *          For commercial use: JSColor Commercial License
 * @author  Jan Odvarko
 * @version 2.0.4
 *
 * See usage examples at http://jscolor.com/examples/
 */


"use strict";


if (!window.jscolor) { window.jscolor = (function () {


var jsc = {


  register : function () {
    jsc.attachDOMReadyEvent(jsc.init);
    jsc.attachEvent(document, 'mousedown', jsc.onDocumentMouseDown);
    jsc.attachEvent(document, 'touchstart', jsc.onDocumentTouchStart);
    jsc.attachEvent(window, 'resize', jsc.onWindowResize);
  },


  init : function () {
    if (jsc.jscolor.lookupClass) {
      jsc.jscolor.installByClassName(jsc.jscolor.lookupClass);
    }
  },


  tryInstallOnElements : function (elms, className) {
    var matchClass = new RegExp('(^|\\s)(' + className + ')(\\s*(\\{[^}]*\\})|\\s|$)', 'i');

    for (var i = 0; i < elms.length; i += 1) {
      if (elms[i].type !== undefined && elms[i].type.toLowerCase() == 'color') {
        if (jsc.isColorAttrSupported) {
          // skip inputs of type 'color' if supported by the browser
          continue;
        }
      }
      var m;
      if (!elms[i].jscolor && elms[i].className && (m = elms[i].className.match(matchClass))) {
        var targetElm = elms[i];
        var optsStr = null;

        var dataOptions = jsc.getDataAttr(targetElm, 'jscolor');
        if (dataOptions !== null) {
          optsStr = dataOptions;
        } else if (m[4]) {
          optsStr = m[4];
        }

        var opts = {};
        if (optsStr) {
          try {
            opts = (new Function ('return (' + optsStr + ')'))();
          } catch(eParseError) {
            jsc.warn('Error parsing jscolor options: ' + eParseError + ':\n' + optsStr);
          }
        }
        targetElm.jscolor = new jsc.jscolor(targetElm, opts);
      }
    }
  },


  isColorAttrSupported : (function () {
    var elm = document.createElement('input');
    if (elm.setAttribute) {
      elm.setAttribute('type', 'color');
      if (elm.type.toLowerCase() == 'color') {
        return true;
      }
    }
    return false;
  })(),


  isCanvasSupported : (function () {
    var elm = document.createElement('canvas');
    return !!(elm.getContext && elm.getContext('2d'));
  })(),


  fetchElement : function (mixed) {
    return typeof mixed === 'string' ? document.getElementById(mixed) : mixed;
  },


  isElementType : function (elm, type) {
    return elm.nodeName.toLowerCase() === type.toLowerCase();
  },


  getDataAttr : function (el, name) {
    var attrName = 'data-' + name;
    var attrValue = el.getAttribute(attrName);
    if (attrValue !== null) {
      return attrValue;
    }
    return null;
  },


  attachEvent : function (el, evnt, func) {
    if (el.addEventListener) {
      el.addEventListener(evnt, func, false);
    } else if (el.attachEvent) {
      el.attachEvent('on' + evnt, func);
    }
  },


  detachEvent : function (el, evnt, func) {
    if (el.removeEventListener) {
      el.removeEventListener(evnt, func, false);
    } else if (el.detachEvent) {
      el.detachEvent('on' + evnt, func);
    }
  },


  _attachedGroupEvents : {},


  attachGroupEvent : function (groupName, el, evnt, func) {
    if (!jsc._attachedGroupEvents.hasOwnProperty(groupName)) {
      jsc._attachedGroupEvents[groupName] = [];
    }
    jsc._attachedGroupEvents[groupName].push([el, evnt, func]);
    jsc.attachEvent(el, evnt, func);
  },


  detachGroupEvents : function (groupName) {
    if (jsc._attachedGroupEvents.hasOwnProperty(groupName)) {
      for (var i = 0; i < jsc._attachedGroupEvents[groupName].length; i += 1) {
        var evt = jsc._attachedGroupEvents[groupName][i];
        jsc.detachEvent(evt[0], evt[1], evt[2]);
      }
      delete jsc._attachedGroupEvents[groupName];
    }
  },


  attachDOMReadyEvent : function (func) {
    var fired = false;
    var fireOnce = function () {
      if (!fired) {
        fired = true;
        func();
      }
    };

    if (document.readyState === 'complete') {
      setTimeout(fireOnce, 1); // async
      return;
    }

    if (document.addEventListener) {
      document.addEventListener('DOMContentLoaded', fireOnce, false);

      // Fallback
      window.addEventListener('load', fireOnce, false);

    } else if (document.attachEvent) {
      // IE
      document.attachEvent('onreadystatechange', function () {
        if (document.readyState === 'complete') {
          document.detachEvent('onreadystatechange', arguments.callee);
          fireOnce();
        }
      })

      // Fallback
      window.attachEvent('onload', fireOnce);

      // IE7/8
      if (document.documentElement.doScroll && window == window.top) {
        var tryScroll = function () {
          if (!document.body) { return; }
          try {
            document.documentElement.doScroll('left');
            fireOnce();
          } catch (e) {
            setTimeout(tryScroll, 1);
          }
        };
        tryScroll();
      }
    }
  },


  warn : function (msg) {
    if (window.console && window.console.warn) {
      window.console.warn(msg);
    }
  },


  preventDefault : function (e) {
    if (e.preventDefault) { e.preventDefault(); }
    e.returnValue = false;
  },


  captureTarget : function (target) {
    // IE
    if (target.setCapture) {
      jsc._capturedTarget = target;
      jsc._capturedTarget.setCapture();
    }
  },


  releaseTarget : function () {
    // IE
    if (jsc._capturedTarget) {
      jsc._capturedTarget.releaseCapture();
      jsc._capturedTarget = null;
    }
  },


  fireEvent : function (el, evnt) {
    if (!el) {
      return;
    }
    if (document.createEvent) {
      var ev = document.createEvent('HTMLEvents');
      ev.initEvent(evnt, true, true);
      el.dispatchEvent(ev);
    } else if (document.createEventObject) {
      var ev = document.createEventObject();
      el.fireEvent('on' + evnt, ev);
    } else if (el['on' + evnt]) { // alternatively use the traditional event model
      el['on' + evnt]();
    }
  },


  classNameToList : function (className) {
    return className.replace(/^\s+|\s+$/g, '').split(/\s+/);
  },


  // The className parameter (str) can only contain a single class name
  hasClass : function (elm, className) {
    if (!className) {
      return false;
    }
    return -1 != (' ' + elm.className.replace(/\s+/g, ' ') + ' ').indexOf(' ' + className + ' ');
  },


  // The className parameter (str) can contain multiple class names separated by whitespace
  setClass : function (elm, className) {
    var classList = jsc.classNameToList(className);
    for (var i = 0; i < classList.length; i += 1) {
      if (!jsc.hasClass(elm, classList[i])) {
        elm.className += (elm.className ? ' ' : '') + classList[i];
      }
    }
  },


  // The className parameter (str) can contain multiple class names separated by whitespace
  unsetClass : function (elm, className) {
    var classList = jsc.classNameToList(className);
    for (var i = 0; i < classList.length; i += 1) {
      var repl = new RegExp(
        '^\\s*' + classList[i] + '\\s*|' +
        '\\s*' + classList[i] + '\\s*$|' +
        '\\s+' + classList[i] + '(\\s+)',
        'g'
      );
      elm.className = elm.className.replace(repl, '$1');
    }
  },


  getStyle : function (elm) {
    return window.getComputedStyle ? window.getComputedStyle(elm) : elm.currentStyle;
  },


  setStyle : (function () {
    var helper = document.createElement('div');
    var getSupportedProp = function (names) {
      for (var i = 0; i < names.length; i += 1) {
        if (names[i] in helper.style) {
          return names[i];
        }
      }
    };
    var props = {
      borderRadius: getSupportedProp(['borderRadius', 'MozBorderRadius', 'webkitBorderRadius']),
      boxShadow: getSupportedProp(['boxShadow', 'MozBoxShadow', 'webkitBoxShadow'])
    };
    return function (elm, prop, value) {
      switch (prop.toLowerCase()) {
      case 'opacity':
        var alphaOpacity = Math.round(parseFloat(value) * 100);
        elm.style.opacity = value;
        elm.style.filter = 'alpha(opacity=' + alphaOpacity + ')';
        break;
      default:
        elm.style[props[prop]] = value;
        break;
      }
    };
  })(),


  setBorderRadius : function (elm, value) {
    jsc.setStyle(elm, 'borderRadius', value || '0');
  },


  setBoxShadow : function (elm, value) {
    jsc.setStyle(elm, 'boxShadow', value || 'none');
  },


  getElementPos : function (e, relativeToViewport) {
    var x=0, y=0;
    var rect = e.getBoundingClientRect();
    x = rect.left;
    y = rect.top;
    if (!relativeToViewport) {
      var viewPos = jsc.getViewPos();
      x += viewPos[0];
      y += viewPos[1];
    }
    return [x, y];
  },


  getElementSize : function (e) {
    return [e.offsetWidth, e.offsetHeight];
  },


  // get pointer's X/Y coordinates relative to viewport
  getAbsPointerPos : function (e) {
    if (!e) { e = window.event; }
    var x = 0, y = 0;
    if (typeof e.changedTouches !== 'undefined' && e.changedTouches.length) {
      // touch devices
      x = e.changedTouches[0].clientX;
      y = e.changedTouches[0].clientY;
    } else if (typeof e.clientX === 'number') {
      x = e.clientX;
      y = e.clientY;
    }
    return { x: x, y: y };
  },


  // get pointer's X/Y coordinates relative to target element
  getRelPointerPos : function (e) {
    if (!e) { e = window.event; }
    var target = e.target || e.srcElement;
    var targetRect = target.getBoundingClientRect();

    var x = 0, y = 0;

    var clientX = 0, clientY = 0;
    if (typeof e.changedTouches !== 'undefined' && e.changedTouches.length) {
      // touch devices
      clientX = e.changedTouches[0].clientX;
      clientY = e.changedTouches[0].clientY;
    } else if (typeof e.clientX === 'number') {
      clientX = e.clientX;
      clientY = e.clientY;
    }

    x = clientX - targetRect.left;
    y = clientY - targetRect.top;
    return { x: x, y: y };
  },


  getViewPos : function () {
    var doc = document.documentElement;
    return [
      (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0),
      (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0)
    ];
  },


  getViewSize : function () {
    var doc = document.documentElement;
    return [
      (window.innerWidth || doc.clientWidth),
      (window.innerHeight || doc.clientHeight),
    ];
  },


  redrawPosition : function () {

    if (jsc.picker && jsc.picker.owner) {
      var thisObj = jsc.picker.owner;

      var tp, vp;

      if (thisObj.fixed) {
        // Fixed elements are positioned relative to viewport,
        // therefore we can ignore the scroll offset
        tp = jsc.getElementPos(thisObj.targetElement, true); // target pos
        vp = [0, 0]; // view pos
      } else {
        tp = jsc.getElementPos(thisObj.targetElement); // target pos
        vp = jsc.getViewPos(); // view pos
      }

      var ts = jsc.getElementSize(thisObj.targetElement); // target size
      var vs = jsc.getViewSize(); // view size
      var ps = jsc.getPickerOuterDims(thisObj); // picker size
      var a, b, c;
      switch (thisObj.position.toLowerCase()) {
        case 'left': a=1; b=0; c=-1; break;
        case 'right':a=1; b=0; c=1; break;
        case 'top':  a=0; b=1; c=-1; break;
        default:     a=0; b=1; c=1; break;
      }
      var l = (ts[b]+ps[b])/2;

      // compute picker position
      if (!thisObj.smartPosition) {
        var pp = [
          tp[a],
          tp[b]+ts[b]-l+l*c
        ];
      } else {
        var pp = [
          -vp[a]+tp[a]+ps[a] > vs[a] ?
            (-vp[a]+tp[a]+ts[a]/2 > vs[a]/2 && tp[a]+ts[a]-ps[a] >= 0 ? tp[a]+ts[a]-ps[a] : tp[a]) :
            tp[a],
          -vp[b]+tp[b]+ts[b]+ps[b]-l+l*c > vs[b] ?
            (-vp[b]+tp[b]+ts[b]/2 > vs[b]/2 && tp[b]+ts[b]-l-l*c >= 0 ? tp[b]+ts[b]-l-l*c : tp[b]+ts[b]-l+l*c) :
            (tp[b]+ts[b]-l+l*c >= 0 ? tp[b]+ts[b]-l+l*c : tp[b]+ts[b]-l-l*c)
        ];
      }

      var x = pp[a];
      var y = pp[b];
      var positionValue = thisObj.fixed ? 'fixed' : 'absolute';
      var contractShadow =
        (pp[0] + ps[0] > tp[0] || pp[0] < tp[0] + ts[0]) &&
        (pp[1] + ps[1] < tp[1] + ts[1]);

      jsc._drawPosition(thisObj, x, y, positionValue, contractShadow);
    }
  },


  _drawPosition : function (thisObj, x, y, positionValue, contractShadow) {
    var vShadow = contractShadow ? 0 : thisObj.shadowBlur; // px

    jsc.picker.wrap.style.position = positionValue;
    jsc.picker.wrap.style.left = x + 'px';
    jsc.picker.wrap.style.top = y + 'px';

    jsc.setBoxShadow(
      jsc.picker.boxS,
      thisObj.shadow ?
        new jsc.BoxShadow(0, vShadow, thisObj.shadowBlur, 0, thisObj.shadowColor) :
        null);
  },


  getPickerDims : function (thisObj) {
    var displaySlider = !!jsc.getSliderComponent(thisObj);
    var dims = [
      2 * thisObj.insetWidth + 2 * thisObj.padding + thisObj.width +
        (displaySlider ? 2 * thisObj.insetWidth + jsc.getPadToSliderPadding(thisObj) + thisObj.sliderSize : 0),
      2 * thisObj.insetWidth + 2 * thisObj.padding + thisObj.height +
        (thisObj.closable ? 2 * thisObj.insetWidth + thisObj.padding + thisObj.buttonHeight : 0)
    ];
    return dims;
  },


  getPickerOuterDims : function (thisObj) {
    var dims = jsc.getPickerDims(thisObj);
    return [
      dims[0] + 2 * thisObj.borderWidth,
      dims[1] + 2 * thisObj.borderWidth
    ];
  },


  getPadToSliderPadding : function (thisObj) {
    return Math.max(thisObj.padding, 1.5 * (2 * thisObj.pointerBorderWidth + thisObj.pointerThickness));
  },


  getPadYComponent : function (thisObj) {
    switch (thisObj.mode.charAt(1).toLowerCase()) {
      case 'v': return 'v'; break;
    }
    return 's';
  },


  getSliderComponent : function (thisObj) {
    if (thisObj.mode.length > 2) {
      switch (thisObj.mode.charAt(2).toLowerCase()) {
        case 's': return 's'; break;
        case 'v': return 'v'; break;
      }
    }
    return null;
  },


  onDocumentMouseDown : function (e) {
    if (!e) { e = window.event; }
    var target = e.target || e.srcElement;

    if (target._jscLinkedInstance) {
      if (target._jscLinkedInstance.showOnClick) {
        target._jscLinkedInstance.show();
      }
    } else if (target._jscControlName) {
      jsc.onControlPointerStart(e, target, target._jscControlName, 'mouse');
    } else {
      // Mouse is outside the picker controls -> hide the color picker!
      if (jsc.picker && jsc.picker.owner) {
        jsc.picker.owner.hide();
      }
    }
  },


  onDocumentTouchStart : function (e) {
    if (!e) { e = window.event; }
    var target = e.target || e.srcElement;

    if (target._jscLinkedInstance) {
      if (target._jscLinkedInstance.showOnClick) {
        target._jscLinkedInstance.show();
      }
    } else if (target._jscControlName) {
      jsc.onControlPointerStart(e, target, target._jscControlName, 'touch');
    } else {
      if (jsc.picker && jsc.picker.owner) {
        jsc.picker.owner.hide();
      }
    }
  },


  onWindowResize : function (e) {
    jsc.redrawPosition();
  },


  onParentScroll : function (e) {
    // hide the picker when one of the parent elements is scrolled
    if (jsc.picker && jsc.picker.owner) {
      jsc.picker.owner.hide();
    }
  },


  _pointerMoveEvent : {
    mouse: 'mousemove',
    touch: 'touchmove'
  },
  _pointerEndEvent : {
    mouse: 'mouseup',
    touch: 'touchend'
  },


  _pointerOrigin : null,
  _capturedTarget : null,


  onControlPointerStart : function (e, target, controlName, pointerType) {
    var thisObj = target._jscInstance;

    jsc.preventDefault(e);
    jsc.captureTarget(target);

    var registerDragEvents = function (doc, offset) {
      jsc.attachGroupEvent('drag', doc, jsc._pointerMoveEvent[pointerType],
        jsc.onDocumentPointerMove(e, target, controlName, pointerType, offset));
      jsc.attachGroupEvent('drag', doc, jsc._pointerEndEvent[pointerType],
        jsc.onDocumentPointerEnd(e, target, controlName, pointerType));
    };

    registerDragEvents(document, [0, 0]);

    if (window.parent && window.frameElement) {
      var rect = window.frameElement.getBoundingClientRect();
      var ofs = [-rect.left, -rect.top];
      registerDragEvents(window.parent.window.document, ofs);
    }

    var abs = jsc.getAbsPointerPos(e);
    var rel = jsc.getRelPointerPos(e);
    jsc._pointerOrigin = {
      x: abs.x - rel.x,
      y: abs.y - rel.y
    };

    switch (controlName) {
    case 'pad':
      // if the slider is at the bottom, move it up
      switch (jsc.getSliderComponent(thisObj)) {
      case 's': if (thisObj.hsv[1] === 0) { thisObj.fromHSV(null, 100, null); }; break;
      case 'v': if (thisObj.hsv[2] === 0) { thisObj.fromHSV(null, null, 100); }; break;
      }
      jsc.setPad(thisObj, e, 0, 0);
      break;

    case 'sld':
      jsc.setSld(thisObj, e, 0);
      break;
    }

    jsc.dispatchFineChange(thisObj);
  },


  onDocumentPointerMove : function (e, target, controlName, pointerType, offset) {
    return function (e) {
      var thisObj = target._jscInstance;
      switch (controlName) {
      case 'pad':
        if (!e) { e = window.event; }
        jsc.setPad(thisObj, e, offset[0], offset[1]);
        jsc.dispatchFineChange(thisObj);
        break;

      case 'sld':
        if (!e) { e = window.event; }
        jsc.setSld(thisObj, e, offset[1]);
        jsc.dispatchFineChange(thisObj);
        break;
      }
    }
  },


  onDocumentPointerEnd : function (e, target, controlName, pointerType) {
    return function (e) {
      var thisObj = target._jscInstance;
      jsc.detachGroupEvents('drag');
      jsc.releaseTarget();
      // Always dispatch changes after detaching outstanding mouse handlers,
      // in case some user interaction will occur in user's onchange callback
      // that would intrude with current mouse events
      jsc.dispatchChange(thisObj);
    };
  },


  dispatchChange : function (thisObj) {
    if (thisObj.valueElement) {
      if (jsc.isElementType(thisObj.valueElement, 'input')) {
        jsc.fireEvent(thisObj.valueElement, 'change');
      }
    }
  },


  dispatchFineChange : function (thisObj) {
    if (thisObj.onFineChange) {
      var callback;
      if (typeof thisObj.onFineChange === 'string') {
        callback = new Function (thisObj.onFineChange);
      } else {
        callback = thisObj.onFineChange;
      }
      callback.call(thisObj);
    }
  },


  setPad : function (thisObj, e, ofsX, ofsY) {
    var pointerAbs = jsc.getAbsPointerPos(e);
    var x = ofsX + pointerAbs.x - jsc._pointerOrigin.x - thisObj.padding - thisObj.insetWidth;
    var y = ofsY + pointerAbs.y - jsc._pointerOrigin.y - thisObj.padding - thisObj.insetWidth;

    var xVal = x * (360 / (thisObj.width - 1));
    var yVal = 100 - (y * (100 / (thisObj.height - 1)));

    switch (jsc.getPadYComponent(thisObj)) {
    case 's': thisObj.fromHSV(xVal, yVal, null, jsc.leaveSld); break;
    case 'v': thisObj.fromHSV(xVal, null, yVal, jsc.leaveSld); break;
    }
  },


  setSld : function (thisObj, e, ofsY) {
    var pointerAbs = jsc.getAbsPointerPos(e);
    var y = ofsY + pointerAbs.y - jsc._pointerOrigin.y - thisObj.padding - thisObj.insetWidth;

    var yVal = 100 - (y * (100 / (thisObj.height - 1)));

    switch (jsc.getSliderComponent(thisObj)) {
    case 's': thisObj.fromHSV(null, yVal, null, jsc.leavePad); break;
    case 'v': thisObj.fromHSV(null, null, yVal, jsc.leavePad); break;
    }
  },


  _vmlNS : 'jsc_vml_',
  _vmlCSS : 'jsc_vml_css_',
  _vmlReady : false,


  initVML : function () {
    if (!jsc._vmlReady) {
      // init VML namespace
      var doc = document;
      if (!doc.namespaces[jsc._vmlNS]) {
        doc.namespaces.add(jsc._vmlNS, 'urn:schemas-microsoft-com:vml');
      }
      if (!doc.styleSheets[jsc._vmlCSS]) {
        var tags = ['shape', 'shapetype', 'group', 'background', 'path', 'formulas', 'handles', 'fill', 'stroke', 'shadow', 'textbox', 'textpath', 'imagedata', 'line', 'polyline', 'curve', 'rect', 'roundrect', 'oval', 'arc', 'image'];
        var ss = doc.createStyleSheet();
        ss.owningElement.id = jsc._vmlCSS;
        for (var i = 0; i < tags.length; i += 1) {
          ss.addRule(jsc._vmlNS + '\\:' + tags[i], 'behavior:url(#default#VML);');
        }
      }
      jsc._vmlReady = true;
    }
  },


  createPalette : function () {

    var paletteObj = {
      elm: null,
      draw: null
    };

    if (jsc.isCanvasSupported) {
      // Canvas implementation for modern browsers

      var canvas = document.createElement('canvas');
      var ctx = canvas.getContext('2d');

      var drawFunc = function (width, height, type) {
        canvas.width = width;
        canvas.height = height;

        ctx.clearRect(0, 0, canvas.width, canvas.height);

        var hGrad = ctx.createLinearGradient(0, 0, canvas.width, 0);
        hGrad.addColorStop(0 / 6, '#F00');
        hGrad.addColorStop(1 / 6, '#FF0');
        hGrad.addColorStop(2 / 6, '#0F0');
        hGrad.addColorStop(3 / 6, '#0FF');
        hGrad.addColorStop(4 / 6, '#00F');
        hGrad.addColorStop(5 / 6, '#F0F');
        hGrad.addColorStop(6 / 6, '#F00');

        ctx.fillStyle = hGrad;
        ctx.fillRect(0, 0, canvas.width, canvas.height);

        var vGrad = ctx.createLinearGradient(0, 0, 0, canvas.height);
        switch (type.toLowerCase()) {
        case 's':
          vGrad.addColorStop(0, 'rgba(255,255,255,0)');
          vGrad.addColorStop(1, 'rgba(255,255,255,1)');
          break;
        case 'v':
          vGrad.addColorStop(0, 'rgba(0,0,0,0)');
          vGrad.addColorStop(1, 'rgba(0,0,0,1)');
          break;
        }
        ctx.fillStyle = vGrad;
        ctx.fillRect(0, 0, canvas.width, canvas.height);
      };

      paletteObj.elm = canvas;
      paletteObj.draw = drawFunc;

    } else {
      // VML fallback for IE 7 and 8

      jsc.initVML();

      var vmlContainer = document.createElement('div');
      vmlContainer.style.position = 'relative';
      vmlContainer.style.overflow = 'hidden';

      var hGrad = document.createElement(jsc._vmlNS + ':fill');
      hGrad.type = 'gradient';
      hGrad.method = 'linear';
      hGrad.angle = '90';
      hGrad.colors = '16.67% #F0F, 33.33% #00F, 50% #0FF, 66.67% #0F0, 83.33% #FF0'

      var hRect = document.createElement(jsc._vmlNS + ':rect');
      hRect.style.position = 'absolute';
      hRect.style.left = -1 + 'px';
      hRect.style.top = -1 + 'px';
      hRect.stroked = false;
      hRect.appendChild(hGrad);
      vmlContainer.appendChild(hRect);

      var vGrad = document.createElement(jsc._vmlNS + ':fill');
      vGrad.type = 'gradient';
      vGrad.method = 'linear';
      vGrad.angle = '180';
      vGrad.opacity = '0';

      var vRect = document.createElement(jsc._vmlNS + ':rect');
      vRect.style.position = 'absolute';
      vRect.style.left = -1 + 'px';
      vRect.style.top = -1 + 'px';
      vRect.stroked = false;
      vRect.appendChild(vGrad);
      vmlContainer.appendChild(vRect);

      var drawFunc = function (width, height, type) {
        vmlContainer.style.width = width + 'px';
        vmlContainer.style.height = height + 'px';

        hRect.style.width =
        vRect.style.width =
          (width + 1) + 'px';
        hRect.style.height =
        vRect.style.height =
          (height + 1) + 'px';

        // Colors must be specified during every redraw, otherwise IE won't display
        // a full gradient during a subsequential redraw
        hGrad.color = '#F00';
        hGrad.color2 = '#F00';

        switch (type.toLowerCase()) {
        case 's':
          vGrad.color = vGrad.color2 = '#FFF';
          break;
        case 'v':
          vGrad.color = vGrad.color2 = '#000';
          break;
        }
      };
      
      paletteObj.elm = vmlContainer;
      paletteObj.draw = drawFunc;
    }

    return paletteObj;
  },


  createSliderGradient : function () {

    var sliderObj = {
      elm: null,
      draw: null
    };

    if (jsc.isCanvasSupported) {
      // Canvas implementation for modern browsers

      var canvas = document.createElement('canvas');
      var ctx = canvas.getContext('2d');

      var drawFunc = function (width, height, color1, color2) {
        canvas.width = width;
        canvas.height = height;

        ctx.clearRect(0, 0, canvas.width, canvas.height);

        var grad = ctx.createLinearGradient(0, 0, 0, canvas.height);
        grad.addColorStop(0, color1);
        grad.addColorStop(1, color2);

        ctx.fillStyle = grad;
        ctx.fillRect(0, 0, canvas.width, canvas.height);
      };

      sliderObj.elm = canvas;
      sliderObj.draw = drawFunc;

    } else {
      // VML fallback for IE 7 and 8

      jsc.initVML();

      var vmlContainer = document.createElement('div');
      vmlContainer.style.position = 'relative';
      vmlContainer.style.overflow = 'hidden';

      var grad = document.createElement(jsc._vmlNS + ':fill');
      grad.type = 'gradient';
      grad.method = 'linear';
      grad.angle = '180';

      var rect = document.createElement(jsc._vmlNS + ':rect');
      rect.style.position = 'absolute';
      rect.style.left = -1 + 'px';
      rect.style.top = -1 + 'px';
      rect.stroked = false;
      rect.appendChild(grad);
      vmlContainer.appendChild(rect);

      var drawFunc = function (width, height, color1, color2) {
        vmlContainer.style.width = width + 'px';
        vmlContainer.style.height = height + 'px';

        rect.style.width = (width + 1) + 'px';
        rect.style.height = (height + 1) + 'px';

        grad.color = color1;
        grad.color2 = color2;
      };
      
      sliderObj.elm = vmlContainer;
      sliderObj.draw = drawFunc;
    }

    return sliderObj;
  },


  leaveValue : 1<<0,
  leaveStyle : 1<<1,
  leavePad : 1<<2,
  leaveSld : 1<<3,


  BoxShadow : (function () {
    var BoxShadow = function (hShadow, vShadow, blur, spread, color, inset) {
      this.hShadow = hShadow;
      this.vShadow = vShadow;
      this.blur = blur;
      this.spread = spread;
      this.color = color;
      this.inset = !!inset;
    };

    BoxShadow.prototype.toString = function () {
      var vals = [
        Math.round(this.hShadow) + 'px',
        Math.round(this.vShadow) + 'px',
        Math.round(this.blur) + 'px',
        Math.round(this.spread) + 'px',
        this.color
      ];
      if (this.inset) {
        vals.push('inset');
      }
      return vals.join(' ');
    };

    return BoxShadow;
  })(),


  //
  // Usage:
  // var myColor = new jscolor(<targetElement> [, <options>])
  //

  jscolor : function (targetElement, options) {

    // General options
    //
    this.value = null; // initial HEX color. To change it later, use methods fromString(), fromHSV() and fromRGB()
    this.valueElement = targetElement; // element that will be used to display and input the color code
    this.styleElement = targetElement; // element that will preview the picked color using CSS backgroundColor
    this.required = true; // whether the associated text <input> can be left empty
    this.refine = true; // whether to refine the entered color code (e.g. uppercase it and remove whitespace)
    this.hash = false; // whether to prefix the HEX color code with # symbol
    this.uppercase = true; // whether to uppercase the color code
    this.onFineChange = null; // called instantly every time the color changes (value can be either a function or a string with javascript code)
    this.activeClass = 'jscolor-active'; // class to be set to the target element when a picker window is open on it
    this.minS = 0; // min allowed saturation (0 - 100)
    this.maxS = 100; // max allowed saturation (0 - 100)
    this.minV = 0; // min allowed value (brightness) (0 - 100)
    this.maxV = 100; // max allowed value (brightness) (0 - 100)

    // Accessing the picked color
    //
    this.hsv = [0, 0, 100]; // read-only  [0-360, 0-100, 0-100]
    this.rgb = [255, 255, 255]; // read-only  [0-255, 0-255, 0-255]

    // Color Picker options
    //
    this.width = 181; // width of color palette (in px)
    this.height = 101; // height of color palette (in px)
    this.showOnClick = true; // whether to display the color picker when user clicks on its target element
    this.mode = 'HSV'; // HSV | HVS | HS | HV - layout of the color picker controls
    this.position = 'bottom'; // left | right | top | bottom - position relative to the target element
    this.smartPosition = true; // automatically change picker position when there is not enough space for it
    this.sliderSize = 16; // px
    this.crossSize = 8; // px
    this.closable = false; // whether to display the Close button
    this.closeText = 'Close';
    this.buttonColor = '#000000'; // CSS color
    this.buttonHeight = 18; // px
    this.padding = 12; // px
    this.backgroundColor = '#FFFFFF'; // CSS color
    this.borderWidth = 1; // px
    this.borderColor = '#BBBBBB'; // CSS color
    this.borderRadius = 8; // px
    this.insetWidth = 1; // px
    this.insetColor = '#BBBBBB'; // CSS color
    this.shadow = true; // whether to display shadow
    this.shadowBlur = 15; // px
    this.shadowColor = 'rgba(0,0,0,0.2)'; // CSS color
    this.pointerColor = '#4C4C4C'; // px
    this.pointerBorderColor = '#FFFFFF'; // px
        this.pointerBorderWidth = 1; // px
        this.pointerThickness = 2; // px
    this.zIndex = 1000;
    this.container = null; // where to append the color picker (BODY element by default)


    for (var opt in options) {
      if (options.hasOwnProperty(opt)) {
        this[opt] = options[opt];
      }
    }


    this.hide = function () {
      if (isPickerOwner()) {
        detachPicker();
      }
    };


    this.show = function () {
      drawPicker();
    };


    this.redraw = function () {
      if (isPickerOwner()) {
        drawPicker();
      }
    };


    this.importColor = function () {
      if (!this.valueElement) {
        this.exportColor();
      } else {
        if (jsc.isElementType(this.valueElement, 'input')) {
          if (!this.refine) {
            if (!this.fromString(this.valueElement.value, jsc.leaveValue)) {
              if (this.styleElement) {
                this.styleElement.style.backgroundImage = this.styleElement._jscOrigStyle.backgroundImage;
                this.styleElement.style.backgroundColor = this.styleElement._jscOrigStyle.backgroundColor;
                this.styleElement.style.color = this.styleElement._jscOrigStyle.color;
              }
              this.exportColor(jsc.leaveValue | jsc.leaveStyle);
            }
          } else if (!this.required && /^\s*$/.test(this.valueElement.value)) {
            this.valueElement.value = '';
            if (this.styleElement) {
              this.styleElement.style.backgroundImage = this.styleElement._jscOrigStyle.backgroundImage;
              this.styleElement.style.backgroundColor = this.styleElement._jscOrigStyle.backgroundColor;
              this.styleElement.style.color = this.styleElement._jscOrigStyle.color;
            }
            this.exportColor(jsc.leaveValue | jsc.leaveStyle);

          } else if (this.fromString(this.valueElement.value)) {
            // managed to import color successfully from the value -> OK, don't do anything
          } else {
            this.exportColor();
          }
        } else {
          // not an input element -> doesn't have any value
          this.exportColor();
        }
      }
    };


    this.exportColor = function (flags) {
      if (!(flags & jsc.leaveValue) && this.valueElement) {
        var value = this.toString();
        if (this.uppercase) { value = value.toUpperCase(); }
        if (this.hash) { value = '#' + value; }

        if (jsc.isElementType(this.valueElement, 'input')) {
          this.valueElement.value = value;
        } else {
          this.valueElement.innerHTML = value;
        }
      }
      if (!(flags & jsc.leaveStyle)) {
        if (this.styleElement) {
          this.styleElement.style.backgroundImage = 'none';
          this.styleElement.style.backgroundColor = '#' + this.toString();
          this.styleElement.style.color = this.isLight() ? '#000' : '#FFF';
        }
      }
      if (!(flags & jsc.leavePad) && isPickerOwner()) {
        redrawPad();
      }
      if (!(flags & jsc.leaveSld) && isPickerOwner()) {
        redrawSld();
      }
    };


    // h: 0-360
    // s: 0-100
    // v: 0-100
    //
    this.fromHSV = function (h, s, v, flags) { // null = don't change
      if (h !== null) {
        if (isNaN(h)) { return false; }
        h = Math.max(0, Math.min(360, h));
      }
      if (s !== null) {
        if (isNaN(s)) { return false; }
        s = Math.max(0, Math.min(100, this.maxS, s), this.minS);
      }
      if (v !== null) {
        if (isNaN(v)) { return false; }
        v = Math.max(0, Math.min(100, this.maxV, v), this.minV);
      }

      this.rgb = HSV_RGB(
        h===null ? this.hsv[0] : (this.hsv[0]=h),
        s===null ? this.hsv[1] : (this.hsv[1]=s),
        v===null ? this.hsv[2] : (this.hsv[2]=v)
      );

      this.exportColor(flags);
    };


    // r: 0-255
    // g: 0-255
    // b: 0-255
    //
    this.fromRGB = function (r, g, b, flags) { // null = don't change
      if (r !== null) {
        if (isNaN(r)) { return false; }
        r = Math.max(0, Math.min(255, r));
      }
      if (g !== null) {
        if (isNaN(g)) { return false; }
        g = Math.max(0, Math.min(255, g));
      }
      if (b !== null) {
        if (isNaN(b)) { return false; }
        b = Math.max(0, Math.min(255, b));
      }

      var hsv = RGB_HSV(
        r===null ? this.rgb[0] : r,
        g===null ? this.rgb[1] : g,
        b===null ? this.rgb[2] : b
      );
      if (hsv[0] !== null) {
        this.hsv[0] = Math.max(0, Math.min(360, hsv[0]));
      }
      if (hsv[2] !== 0) {
        this.hsv[1] = hsv[1]===null ? null : Math.max(0, this.minS, Math.min(100, this.maxS, hsv[1]));
      }
      this.hsv[2] = hsv[2]===null ? null : Math.max(0, this.minV, Math.min(100, this.maxV, hsv[2]));

      // update RGB according to final HSV, as some values might be trimmed
      var rgb = HSV_RGB(this.hsv[0], this.hsv[1], this.hsv[2]);
      this.rgb[0] = rgb[0];
      this.rgb[1] = rgb[1];
      this.rgb[2] = rgb[2];

      this.exportColor(flags);
    };


    this.fromString = function (str, flags) {
      var m;
      if (m = str.match(/^\W*([0-9A-F]{3}([0-9A-F]{3})?)\W*$/i)) {
        // HEX notation
        //

        if (m[1].length === 6) {
          // 6-char notation
          this.fromRGB(
            parseInt(m[1].substr(0,2),16),
            parseInt(m[1].substr(2,2),16),
            parseInt(m[1].substr(4,2),16),
            flags
          );
        } else {
          // 3-char notation
          this.fromRGB(
            parseInt(m[1].charAt(0) + m[1].charAt(0),16),
            parseInt(m[1].charAt(1) + m[1].charAt(1),16),
            parseInt(m[1].charAt(2) + m[1].charAt(2),16),
            flags
          );
        }
        return true;

      } else if (m = str.match(/^\W*rgba?\(([^)]*)\)\W*$/i)) {
        var params = m[1].split(',');
        var re = /^\s*(\d*)(\.\d+)?\s*$/;
        var mR, mG, mB;
        if (
          params.length >= 3 &&
          (mR = params[0].match(re)) &&
          (mG = params[1].match(re)) &&
          (mB = params[2].match(re))
        ) {
          var r = parseFloat((mR[1] || '0') + (mR[2] || ''));
          var g = parseFloat((mG[1] || '0') + (mG[2] || ''));
          var b = parseFloat((mB[1] || '0') + (mB[2] || ''));
          this.fromRGB(r, g, b, flags);
          return true;
        }
      }
      return false;
    };


    this.toString = function () {
      return (
        (0x100 | Math.round(this.rgb[0])).toString(16).substr(1) +
        (0x100 | Math.round(this.rgb[1])).toString(16).substr(1) +
        (0x100 | Math.round(this.rgb[2])).toString(16).substr(1)
      );
    };


    this.toHEXString = function () {
      return '#' + this.toString().toUpperCase();
    };


    this.toRGBString = function () {
      return ('rgb(' +
        Math.round(this.rgb[0]) + ',' +
        Math.round(this.rgb[1]) + ',' +
        Math.round(this.rgb[2]) + ')'
      );
    };


    this.isLight = function () {
      return (
        0.213 * this.rgb[0] +
        0.715 * this.rgb[1] +
        0.072 * this.rgb[2] >
        255 / 2
      );
    };


    this._processParentElementsInDOM = function () {
      if (this._linkedElementsProcessed) { return; }
      this._linkedElementsProcessed = true;

      var elm = this.targetElement;
      do {
        // If the target element or one of its parent nodes has fixed position,
        // then use fixed positioning instead
        //
        // Note: In Firefox, getComputedStyle returns null in a hidden iframe,
        // that's why we need to check if the returned style object is non-empty
        var currStyle = jsc.getStyle(elm);
        if (currStyle && currStyle.position.toLowerCase() === 'fixed') {
          this.fixed = true;
        }

        if (elm !== this.targetElement) {
          // Ensure to attach onParentScroll only once to each parent element
          // (multiple targetElements can share the same parent nodes)
          //
          // Note: It's not just offsetParents that can be scrollable,
          // that's why we loop through all parent nodes
          if (!elm._jscEventsAttached) {
            jsc.attachEvent(elm, 'scroll', jsc.onParentScroll);
            elm._jscEventsAttached = true;
          }
        }
      } while ((elm = elm.parentNode) && !jsc.isElementType(elm, 'body'));
    };


    // r: 0-255
    // g: 0-255
    // b: 0-255
    //
    // returns: [ 0-360, 0-100, 0-100 ]
    //
    function RGB_HSV (r, g, b) {
      r /= 255;
      g /= 255;
      b /= 255;
      var n = Math.min(Math.min(r,g),b);
      var v = Math.max(Math.max(r,g),b);
      var m = v - n;
      if (m === 0) { return [ null, 0, 100 * v ]; }
      var h = r===n ? 3+(b-g)/m : (g===n ? 5+(r-b)/m : 1+(g-r)/m);
      return [
        60 * (h===6?0:h),
        100 * (m/v),
        100 * v
      ];
    }


    // h: 0-360
    // s: 0-100
    // v: 0-100
    //
    // returns: [ 0-255, 0-255, 0-255 ]
    //
    function HSV_RGB (h, s, v) {
      var u = 255 * (v / 100);

      if (h === null) {
        return [ u, u, u ];
      }

      h /= 60;
      s /= 100;

      var i = Math.floor(h);
      var f = i%2 ? h-i : 1-(h-i);
      var m = u * (1 - s);
      var n = u * (1 - s * f);
      switch (i) {
        case 6:
        case 0: return [u,n,m];
        case 1: return [n,u,m];
        case 2: return [m,u,n];
        case 3: return [m,n,u];
        case 4: return [n,m,u];
        case 5: return [u,m,n];
      }
    }


    function detachPicker () {
      jsc.unsetClass(THIS.targetElement, THIS.activeClass);
      jsc.picker.wrap.parentNode.removeChild(jsc.picker.wrap);
      delete jsc.picker.owner;
    }


    function drawPicker () {

      // At this point, when drawing the picker, we know what the parent elements are
      // and we can do all related DOM operations, such as registering events on them
      // or checking their positioning
      THIS._processParentElementsInDOM();

      if (!jsc.picker) {
        jsc.picker = {
          owner: null,
          wrap : document.createElement('div'),
          box : document.createElement('div'),
          boxS : document.createElement('div'), // shadow area
          boxB : document.createElement('div'), // border
          pad : document.createElement('div'),
          padB : document.createElement('div'), // border
          padM : document.createElement('div'), // mouse/touch area
          padPal : jsc.createPalette(),
          cross : document.createElement('div'),
          crossBY : document.createElement('div'), // border Y
          crossBX : document.createElement('div'), // border X
          crossLY : document.createElement('div'), // line Y
          crossLX : document.createElement('div'), // line X
          sld : document.createElement('div'),
          sldB : document.createElement('div'), // border
          sldM : document.createElement('div'), // mouse/touch area
          sldGrad : jsc.createSliderGradient(),
          sldPtrS : document.createElement('div'), // slider pointer spacer
          sldPtrIB : document.createElement('div'), // slider pointer inner border
          sldPtrMB : document.createElement('div'), // slider pointer middle border
          sldPtrOB : document.createElement('div'), // slider pointer outer border
          btn : document.createElement('div'),
          btnT : document.createElement('span') // text
        };

        jsc.picker.pad.appendChild(jsc.picker.padPal.elm);
        jsc.picker.padB.appendChild(jsc.picker.pad);
        jsc.picker.cross.appendChild(jsc.picker.crossBY);
        jsc.picker.cross.appendChild(jsc.picker.crossBX);
        jsc.picker.cross.appendChild(jsc.picker.crossLY);
        jsc.picker.cross.appendChild(jsc.picker.crossLX);
        jsc.picker.padB.appendChild(jsc.picker.cross);
        jsc.picker.box.appendChild(jsc.picker.padB);
        jsc.picker.box.appendChild(jsc.picker.padM);

        jsc.picker.sld.appendChild(jsc.picker.sldGrad.elm);
        jsc.picker.sldB.appendChild(jsc.picker.sld);
        jsc.picker.sldB.appendChild(jsc.picker.sldPtrOB);
        jsc.picker.sldPtrOB.appendChild(jsc.picker.sldPtrMB);
        jsc.picker.sldPtrMB.appendChild(jsc.picker.sldPtrIB);
        jsc.picker.sldPtrIB.appendChild(jsc.picker.sldPtrS);
        jsc.picker.box.appendChild(jsc.picker.sldB);
        jsc.picker.box.appendChild(jsc.picker.sldM);

        jsc.picker.btn.appendChild(jsc.picker.btnT);
        jsc.picker.box.appendChild(jsc.picker.btn);

        jsc.picker.boxB.appendChild(jsc.picker.box);
        jsc.picker.wrap.appendChild(jsc.picker.boxS);
        jsc.picker.wrap.appendChild(jsc.picker.boxB);
      }

      var p = jsc.picker;

      var displaySlider = !!jsc.getSliderComponent(THIS);
      var dims = jsc.getPickerDims(THIS);
      var crossOuterSize = (2 * THIS.pointerBorderWidth + THIS.pointerThickness + 2 * THIS.crossSize);
      var padToSliderPadding = jsc.getPadToSliderPadding(THIS);
      var borderRadius = Math.min(
        THIS.borderRadius,
        Math.round(THIS.padding * Math.PI)); // px
      var padCursor = 'crosshair';

      // wrap
      p.wrap.style.clear = 'both';
      p.wrap.style.width = (dims[0] + 2 * THIS.borderWidth) + 'px';
      p.wrap.style.height = (dims[1] + 2 * THIS.borderWidth) + 'px';
      p.wrap.style.zIndex = THIS.zIndex;

      // picker
      p.box.style.width = dims[0] + 'px';
      p.box.style.height = dims[1] + 'px';

      p.boxS.style.position = 'absolute';
      p.boxS.style.left = '0';
      p.boxS.style.top = '0';
      p.boxS.style.width = '100%';
      p.boxS.style.height = '100%';
      jsc.setBorderRadius(p.boxS, borderRadius + 'px');

      // picker border
      p.boxB.style.position = 'relative';
      p.boxB.style.border = THIS.borderWidth + 'px solid';
      p.boxB.style.borderColor = THIS.borderColor;
      p.boxB.style.background = THIS.backgroundColor;
      jsc.setBorderRadius(p.boxB, borderRadius + 'px');

      // IE hack:
      // If the element is transparent, IE will trigger the event on the elements under it,
      // e.g. on Canvas or on elements with border
      p.padM.style.background =
      p.sldM.style.background =
        '#FFF';
      jsc.setStyle(p.padM, 'opacity', '0');
      jsc.setStyle(p.sldM, 'opacity', '0');

      // pad
      p.pad.style.position = 'relative';
      p.pad.style.width = THIS.width + 'px';
      p.pad.style.height = THIS.height + 'px';

      // pad palettes (HSV and HVS)
      p.padPal.draw(THIS.width, THIS.height, jsc.getPadYComponent(THIS));

      // pad border
      p.padB.style.position = 'absolute';
      p.padB.style.left = THIS.padding + 'px';
      p.padB.style.top = THIS.padding + 'px';
      p.padB.style.border = THIS.insetWidth + 'px solid';
      p.padB.style.borderColor = THIS.insetColor;

      // pad mouse area
      p.padM._jscInstance = THIS;
      p.padM._jscControlName = 'pad';
      p.padM.style.position = 'absolute';
      p.padM.style.left = '0';
      p.padM.style.top = '0';
      p.padM.style.width = (THIS.padding + 2 * THIS.insetWidth + THIS.width + padToSliderPadding / 2) + 'px';
      p.padM.style.height = dims[1] + 'px';
      p.padM.style.cursor = padCursor;

      // pad cross
      p.cross.style.position = 'absolute';
      p.cross.style.left =
      p.cross.style.top =
        '0';
      p.cross.style.width =
      p.cross.style.height =
        crossOuterSize + 'px';

      // pad cross border Y and X
      p.crossBY.style.position =
      p.crossBX.style.position =
        'absolute';
      p.crossBY.style.background =
      p.crossBX.style.background =
        THIS.pointerBorderColor;
      p.crossBY.style.width =
      p.crossBX.style.height =
        (2 * THIS.pointerBorderWidth + THIS.pointerThickness) + 'px';
      p.crossBY.style.height =
      p.crossBX.style.width =
        crossOuterSize + 'px';
      p.crossBY.style.left =
      p.crossBX.style.top =
        (Math.floor(crossOuterSize / 2) - Math.floor(THIS.pointerThickness / 2) - THIS.pointerBorderWidth) + 'px';
      p.crossBY.style.top =
      p.crossBX.style.left =
        '0';

      // pad cross line Y and X
      p.crossLY.style.position =
      p.crossLX.style.position =
        'absolute';
      p.crossLY.style.background =
      p.crossLX.style.background =
        THIS.pointerColor;
      p.crossLY.style.height =
      p.crossLX.style.width =
        (crossOuterSize - 2 * THIS.pointerBorderWidth) + 'px';
      p.crossLY.style.width =
      p.crossLX.style.height =
        THIS.pointerThickness + 'px';
      p.crossLY.style.left =
      p.crossLX.style.top =
        (Math.floor(crossOuterSize / 2) - Math.floor(THIS.pointerThickness / 2)) + 'px';
      p.crossLY.style.top =
      p.crossLX.style.left =
        THIS.pointerBorderWidth + 'px';

      // slider
      p.sld.style.overflow = 'hidden';
      p.sld.style.width = THIS.sliderSize + 'px';
      p.sld.style.height = THIS.height + 'px';

      // slider gradient
      p.sldGrad.draw(THIS.sliderSize, THIS.height, '#000', '#000');

      // slider border
      p.sldB.style.display = displaySlider ? 'block' : 'none';
      p.sldB.style.position = 'absolute';
      p.sldB.style.right = THIS.padding + 'px';
      p.sldB.style.top = THIS.padding + 'px';
      p.sldB.style.border = THIS.insetWidth + 'px solid';
      p.sldB.style.borderColor = THIS.insetColor;

      // slider mouse area
      p.sldM._jscInstance = THIS;
      p.sldM._jscControlName = 'sld';
      p.sldM.style.display = displaySlider ? 'block' : 'none';
      p.sldM.style.position = 'absolute';
      p.sldM.style.right = '0';
      p.sldM.style.top = '0';
      p.sldM.style.width = (THIS.sliderSize + padToSliderPadding / 2 + THIS.padding + 2 * THIS.insetWidth) + 'px';
      p.sldM.style.height = dims[1] + 'px';
      p.sldM.style.cursor = 'default';

      // slider pointer inner and outer border
      p.sldPtrIB.style.border =
      p.sldPtrOB.style.border =
        THIS.pointerBorderWidth + 'px solid ' + THIS.pointerBorderColor;

      // slider pointer outer border
      p.sldPtrOB.style.position = 'absolute';
      p.sldPtrOB.style.left = -(2 * THIS.pointerBorderWidth + THIS.pointerThickness) + 'px';
      p.sldPtrOB.style.top = '0';

      // slider pointer middle border
      p.sldPtrMB.style.border = THIS.pointerThickness + 'px solid ' + THIS.pointerColor;

      // slider pointer spacer
      p.sldPtrS.style.width = THIS.sliderSize + 'px';
      p.sldPtrS.style.height = sliderPtrSpace + 'px';

      // the Close button
      function setBtnBorder () {
        var insetColors = THIS.insetColor.split(/\s+/);
        var outsetColor = insetColors.length < 2 ? insetColors[0] : insetColors[1] + ' ' + insetColors[0] + ' ' + insetColors[0] + ' ' + insetColors[1];
        p.btn.style.borderColor = outsetColor;
      }
      p.btn.style.display = THIS.closable ? 'block' : 'none';
      p.btn.style.position = 'absolute';
      p.btn.style.left = THIS.padding + 'px';
      p.btn.style.bottom = THIS.padding + 'px';
      p.btn.style.padding = '0 15px';
      p.btn.style.height = THIS.buttonHeight + 'px';
      p.btn.style.border = THIS.insetWidth + 'px solid';
      setBtnBorder();
      p.btn.style.color = THIS.buttonColor;
      p.btn.style.font = '12px sans-serif';
      p.btn.style.textAlign = 'center';
      try {
        p.btn.style.cursor = 'pointer';
      } catch(eOldIE) {
        p.btn.style.cursor = 'hand';
      }
      p.btn.onmousedown = function () {
        THIS.hide();
      };
      p.btnT.style.lineHeight = THIS.buttonHeight + 'px';
      p.btnT.innerHTML = '';
      p.btnT.appendChild(document.createTextNode(THIS.closeText));

      // place pointers
      redrawPad();
      redrawSld();

      // If we are changing the owner without first closing the picker,
      // make sure to first deal with the old owner
      if (jsc.picker.owner && jsc.picker.owner !== THIS) {
        jsc.unsetClass(jsc.picker.owner.targetElement, THIS.activeClass);
      }

      // Set the new picker owner
      jsc.picker.owner = THIS;

      // The redrawPosition() method needs picker.owner to be set, that's why we call it here,
      // after setting the owner
      if (jsc.isElementType(container, 'body')) {
        jsc.redrawPosition();
      } else {
        jsc._drawPosition(THIS, 0, 0, 'relative', false);
      }

      if (p.wrap.parentNode != container) {
        container.appendChild(p.wrap);
      }

      jsc.setClass(THIS.targetElement, THIS.activeClass);
    }


    function redrawPad () {
      // redraw the pad pointer
      switch (jsc.getPadYComponent(THIS)) {
      case 's': var yComponent = 1; break;
      case 'v': var yComponent = 2; break;
      }
      var x = Math.round((THIS.hsv[0] / 360) * (THIS.width - 1));
      var y = Math.round((1 - THIS.hsv[yComponent] / 100) * (THIS.height - 1));
      var crossOuterSize = (2 * THIS.pointerBorderWidth + THIS.pointerThickness + 2 * THIS.crossSize);
      var ofs = -Math.floor(crossOuterSize / 2);
      jsc.picker.cross.style.left = (x + ofs) + 'px';
      jsc.picker.cross.style.top = (y + ofs) + 'px';

      // redraw the slider
      switch (jsc.getSliderComponent(THIS)) {
      case 's':
        var rgb1 = HSV_RGB(THIS.hsv[0], 100, THIS.hsv[2]);
        var rgb2 = HSV_RGB(THIS.hsv[0], 0, THIS.hsv[2]);
        var color1 = 'rgb(' +
          Math.round(rgb1[0]) + ',' +
          Math.round(rgb1[1]) + ',' +
          Math.round(rgb1[2]) + ')';
        var color2 = 'rgb(' +
          Math.round(rgb2[0]) + ',' +
          Math.round(rgb2[1]) + ',' +
          Math.round(rgb2[2]) + ')';
        jsc.picker.sldGrad.draw(THIS.sliderSize, THIS.height, color1, color2);
        break;
      case 'v':
        var rgb = HSV_RGB(THIS.hsv[0], THIS.hsv[1], 100);
        var color1 = 'rgb(' +
          Math.round(rgb[0]) + ',' +
          Math.round(rgb[1]) + ',' +
          Math.round(rgb[2]) + ')';
        var color2 = '#000';
        jsc.picker.sldGrad.draw(THIS.sliderSize, THIS.height, color1, color2);
        break;
      }
    }


    function redrawSld () {
      var sldComponent = jsc.getSliderComponent(THIS);
      if (sldComponent) {
        // redraw the slider pointer
        switch (sldComponent) {
        case 's': var yComponent = 1; break;
        case 'v': var yComponent = 2; break;
        }
        var y = Math.round((1 - THIS.hsv[yComponent] / 100) * (THIS.height - 1));
        jsc.picker.sldPtrOB.style.top = (y - (2 * THIS.pointerBorderWidth + THIS.pointerThickness) - Math.floor(sliderPtrSpace / 2)) + 'px';
      }
    }


    function isPickerOwner () {
      return jsc.picker && jsc.picker.owner === THIS;
    }


    function blurValue () {
      THIS.importColor();
    }


    // Find the target element
    if (typeof targetElement === 'string') {
      var id = targetElement;
      var elm = document.getElementById(id);
      if (elm) {
        this.targetElement = elm;
      } else {
        jsc.warn('Could not find target element with ID \'' + id + '\'');
      }
    } else if (targetElement) {
      this.targetElement = targetElement;
    } else {
      jsc.warn('Invalid target element: \'' + targetElement + '\'');
    }

    if (this.targetElement._jscLinkedInstance) {
      jsc.warn('Cannot link jscolor twice to the same element. Skipping.');
      return;
    }
    this.targetElement._jscLinkedInstance = this;

    // Find the value element
    this.valueElement = jsc.fetchElement(this.valueElement);
    // Find the style element
    this.styleElement = jsc.fetchElement(this.styleElement);

    var THIS = this;
    var container =
      this.container ?
      jsc.fetchElement(this.container) :
      document.getElementsByTagName('body')[0];
    var sliderPtrSpace = 3; // px

    // For BUTTON elements it's important to stop them from sending the form when clicked
    // (e.g. in Safari)
    if (jsc.isElementType(this.targetElement, 'button')) {
      if (this.targetElement.onclick) {
        var origCallback = this.targetElement.onclick;
        this.targetElement.onclick = function (evt) {
          origCallback.call(this, evt);
          return false;
        };
      } else {
        this.targetElement.onclick = function () { return false; };
      }
    }

    /*
    var elm = this.targetElement;
    do {
      // If the target element or one of its offsetParents has fixed position,
      // then use fixed positioning instead
      //
      // Note: In Firefox, getComputedStyle returns null in a hidden iframe,
      // that's why we need to check if the returned style object is non-empty
      var currStyle = jsc.getStyle(elm);
      if (currStyle && currStyle.position.toLowerCase() === 'fixed') {
        this.fixed = true;
      }

      if (elm !== this.targetElement) {
        // attach onParentScroll so that we can recompute the picker position
        // when one of the offsetParents is scrolled
        if (!elm._jscEventsAttached) {
          jsc.attachEvent(elm, 'scroll', jsc.onParentScroll);
          elm._jscEventsAttached = true;
        }
      }
    } while ((elm = elm.offsetParent) && !jsc.isElementType(elm, 'body'));
    */

    // valueElement
    if (this.valueElement) {
      if (jsc.isElementType(this.valueElement, 'input')) {
        var updateField = function () {
          THIS.fromString(THIS.valueElement.value, jsc.leaveValue);
          jsc.dispatchFineChange(THIS);
        };
        jsc.attachEvent(this.valueElement, 'keyup', updateField);
        jsc.attachEvent(this.valueElement, 'input', updateField);
        jsc.attachEvent(this.valueElement, 'blur', blurValue);
        this.valueElement.setAttribute('autocomplete', 'off');
      }
    }

    // styleElement
    if (this.styleElement) {
      this.styleElement._jscOrigStyle = {
        backgroundImage : this.styleElement.style.backgroundImage,
        backgroundColor : this.styleElement.style.backgroundColor,
        color : this.styleElement.style.color
      };
    }

    if (this.value) {
      // Try to set the color from the .value option and if unsuccessful,
      // export the current color
      this.fromString(this.value) || this.exportColor();
    } else {
      this.importColor();
    }
  }

};


//================================
// Public properties and methods
//================================


// By default, search for all elements with class="jscolor" and install a color picker on them.
//
// You can change what class name will be looked for by setting the property jscolor.lookupClass
// anywhere in your HTML document. To completely disable the automatic lookup, set it to null.
//
jsc.jscolor.lookupClass = 'jscolor';


jsc.jscolor.installByClassName = function (className) {
  var inputElms = document.getElementsByTagName('input');
  var buttonElms = document.getElementsByTagName('button');

  jsc.tryInstallOnElements(inputElms, className);
  jsc.tryInstallOnElements(buttonElms, className);
};


jsc.register();


return jsc.jscolor;


})(); }