☰

style

biblioteca script

此腳本不應該直接安裝，它是一個供其他腳本使用的函式庫。欲使用本函式庫，請在腳本 metadata 寫上： // @require https://update.cn-greasyfork.org/scripts/38435/251227/style.js 

  1. /**
  2.  * jscolor - JavaScript Color Picker
  3.  *
  4.  * @link    http://jscolor.com
  5.  * @license For open source use: GPLv3
  6.  *          For commercial use: JSColor Commercial License
  7.  * @author  Jan Odvarko
  8.  * @version 2.0.4
  9.  *
  10.  * See usage examples at http://jscolor.com/examples/
  11.  */
  12.  
  13.  
  14. "use strict";
  15.  
  16.  
  17. if (!window.jscolor) { window.jscolor = (function () {
  18.  
  19.  
  20. var jsc = {
  21.  
  22.  
  23. 	register : function () {
  24. 		jsc.attachDOMReadyEvent(jsc.init);
  25. 		jsc.attachEvent(document, 'mousedown', jsc.onDocumentMouseDown);
  26. 		jsc.attachEvent(document, 'touchstart', jsc.onDocumentTouchStart);
  27. 		jsc.attachEvent(window, 'resize', jsc.onWindowResize);
  28. 	},
  29.  
  30.  
  31. 	init : function () {
  32. 		if (jsc.jscolor.lookupClass) {
  33. 			jsc.jscolor.installByClassName(jsc.jscolor.lookupClass);
  34. 		}
  35. 	},
  36.  
  37.  
  38. 	tryInstallOnElements : function (elms, className) {
  39. 		var matchClass = new RegExp('(^|\\s)(' + className + ')(\\s*(\\{[^}]*\\})|\\s|$)', 'i');
  40.  
  41. 		for (var i = 0; i < elms.length; i += 1) {
  42. 			if (elms[i].type !== undefined && elms[i].type.toLowerCase() == 'color') {
  43. 				if (jsc.isColorAttrSupported) {
  44. 					// skip inputs of type 'color' if supported by the browser
  45. 					continue;
  46. 				}
  47. 			}
  48. 			var m;
  49. 			if (!elms[i].jscolor && elms[i].className && (m = elms[i].className.match(matchClass))) {
  50. 				var targetElm = elms[i];
  51. 				var optsStr = null;
  52.  
  53. 				var dataOptions = jsc.getDataAttr(targetElm, 'jscolor');
  54. 				if (dataOptions !== null) {
  55. 					optsStr = dataOptions;
  56. 				} else if (m[4]) {
  57. 					optsStr = m[4];
  58. 				}
  59.  
  60. 				var opts = {};
  61. 				if (optsStr) {
  62. 					try {
  63. 						opts = (new Function ('return (' + optsStr + ')'))();
  64. 					} catch(eParseError) {
  65. 						jsc.warn('Error parsing jscolor options: ' + eParseError + ':\n' + optsStr);
  66. 					}
  67. 				}
  68. 				targetElm.jscolor = new jsc.jscolor(targetElm, opts);
  69. 			}
  70. 		}
  71. 	},
  72.  
  73.  
  74. 	isColorAttrSupported : (function () {
  75. 		var elm = document.createElement('input');
  76. 		if (elm.setAttribute) {
  77. 			elm.setAttribute('type', 'color');
  78. 			if (elm.type.toLowerCase() == 'color') {
  79. 				return true;
  80. 			}
  81. 		}
  82. 		return false;
  83. 	})(),
  84.  
  85.  
  86. 	isCanvasSupported : (function () {
  87. 		var elm = document.createElement('canvas');
  88. 		return !!(elm.getContext && elm.getContext('2d'));
  89. 	})(),
  90.  
  91.  
  92. 	fetchElement : function (mixed) {
  93. 		return typeof mixed === 'string' ? document.getElementById(mixed) : mixed;
  94. 	},
  95.  
  96.  
  97. 	isElementType : function (elm, type) {
  98. 		return elm.nodeName.toLowerCase() === type.toLowerCase();
  99. 	},
  100.  
  101.  
  102. 	getDataAttr : function (el, name) {
  103. 		var attrName = 'data-' + name;
  104. 		var attrValue = el.getAttribute(attrName);
  105. 		if (attrValue !== null) {
  106. 			return attrValue;
  107. 		}
  108. 		return null;
  109. 	},
  110.  
  111.  
  112. 	attachEvent : function (el, evnt, func) {
  113. 		if (el.addEventListener) {
  114. 			el.addEventListener(evnt, func, false);
  115. 		} else if (el.attachEvent) {
  116. 			el.attachEvent('on' + evnt, func);
  117. 		}
  118. 	},
  119.  
  120.  
  121. 	detachEvent : function (el, evnt, func) {
  122. 		if (el.removeEventListener) {
  123. 			el.removeEventListener(evnt, func, false);
  124. 		} else if (el.detachEvent) {
  125. 			el.detachEvent('on' + evnt, func);
  126. 		}
  127. 	},
  128.  
  129.  
  130. 	_attachedGroupEvents : {},
  131.  
  132.  
  133. 	attachGroupEvent : function (groupName, el, evnt, func) {
  134. 		if (!jsc._attachedGroupEvents.hasOwnProperty(groupName)) {
  135. 			jsc._attachedGroupEvents[groupName] = [];
  136. 		}
  137. 		jsc._attachedGroupEvents[groupName].push([el, evnt, func]);
  138. 		jsc.attachEvent(el, evnt, func);
  139. 	},
  140.  
  141.  
  142. 	detachGroupEvents : function (groupName) {
  143. 		if (jsc._attachedGroupEvents.hasOwnProperty(groupName)) {
  144. 			for (var i = 0; i < jsc._attachedGroupEvents[groupName].length; i += 1) {
  145. 				var evt = jsc._attachedGroupEvents[groupName][i];
  146. 				jsc.detachEvent(evt[0], evt[1], evt[2]);
  147. 			}
  148. 			delete jsc._attachedGroupEvents[groupName];
  149. 		}
  150. 	},
  151.  
  152.  
  153. 	attachDOMReadyEvent : function (func) {
  154. 		var fired = false;
  155. 		var fireOnce = function () {
  156. 			if (!fired) {
  157. 				fired = true;
  158. 				func();
  159. 			}
  160. 		};
  161.  
  162. 		if (document.readyState === 'complete') {
  163. 			setTimeout(fireOnce, 1); // async
  164. 			return;
  165. 		}
  166.  
  167. 		if (document.addEventListener) {
  168. 			document.addEventListener('DOMContentLoaded', fireOnce, false);
  169.  
  170. 			// Fallback
  171. 			window.addEventListener('load', fireOnce, false);
  172.  
  173. 		} else if (document.attachEvent) {
  174. 			// IE
  175. 			document.attachEvent('onreadystatechange', function () {
  176. 				if (document.readyState === 'complete') {
  177. 					document.detachEvent('onreadystatechange', arguments.callee);
  178. 					fireOnce();
  179. 				}
  180. 			})
  181.  
  182. 			// Fallback
  183. 			window.attachEvent('onload', fireOnce);
  184.  
  185. 			// IE7/8
  186. 			if (document.documentElement.doScroll && window == window.top) {
  187. 				var tryScroll = function () {
  188. 					if (!document.body) { return; }
  189. 					try {
  190. 						document.documentElement.doScroll('left');
  191. 						fireOnce();
  192. 					} catch (e) {
  193. 						setTimeout(tryScroll, 1);
  194. 					}
  195. 				};
  196. 				tryScroll();
  197. 			}
  198. 		}
  199. 	},
  200.  
  201.  
  202. 	warn : function (msg) {
  203. 		if (window.console && window.console.warn) {
  204. 			window.console.warn(msg);
  205. 		}
  206. 	},
  207.  
  208.  
  209. 	preventDefault : function (e) {
  210. 		if (e.preventDefault) { e.preventDefault(); }
  211. 		e.returnValue = false;
  212. 	},
  213.  
  214.  
  215. 	captureTarget : function (target) {
  216. 		// IE
  217. 		if (target.setCapture) {
  218. 			jsc._capturedTarget = target;
  219. 			jsc._capturedTarget.setCapture();
  220. 		}
  221. 	},
  222.  
  223.  
  224. 	releaseTarget : function () {
  225. 		// IE
  226. 		if (jsc._capturedTarget) {
  227. 			jsc._capturedTarget.releaseCapture();
  228. 			jsc._capturedTarget = null;
  229. 		}
  230. 	},
  231.  
  232.  
  233. 	fireEvent : function (el, evnt) {
  234. 		if (!el) {
  235. 			return;
  236. 		}
  237. 		if (document.createEvent) {
  238. 			var ev = document.createEvent('HTMLEvents');
  239. 			ev.initEvent(evnt, true, true);
  240. 			el.dispatchEvent(ev);
  241. 		} else if (document.createEventObject) {
  242. 			var ev = document.createEventObject();
  243. 			el.fireEvent('on' + evnt, ev);
  244. 		} else if (el['on' + evnt]) { // alternatively use the traditional event model
  245. 			el['on' + evnt]();
  246. 		}
  247. 	},
  248.  
  249.  
  250. 	classNameToList : function (className) {
  251. 		return className.replace(/^\s+|\s+$/g, '').split(/\s+/);
  252. 	},
  253.  
  254.  
  255. 	// The className parameter (str) can only contain a single class name
  256. 	hasClass : function (elm, className) {
  257. 		if (!className) {
  258. 			return false;
  259. 		}
  260. 		return -1 != (' ' + elm.className.replace(/\s+/g, ' ') + ' ').indexOf(' ' + className + ' ');
  261. 	},
  262.  
  263.  
  264. 	// The className parameter (str) can contain multiple class names separated by whitespace
  265. 	setClass : function (elm, className) {
  266. 		var classList = jsc.classNameToList(className);
  267. 		for (var i = 0; i < classList.length; i += 1) {
  268. 			if (!jsc.hasClass(elm, classList[i])) {
  269. 				elm.className += (elm.className ? ' ' : '') + classList[i];
  270. 			}
  271. 		}
  272. 	},
  273.  
  274.  
  275. 	// The className parameter (str) can contain multiple class names separated by whitespace
  276. 	unsetClass : function (elm, className) {
  277. 		var classList = jsc.classNameToList(className);
  278. 		for (var i = 0; i < classList.length; i += 1) {
  279. 			var repl = new RegExp(
  280. 				'^\\s*' + classList[i] + '\\s*|' +
  281. 				'\\s*' + classList[i] + '\\s*$|' +
  282. 				'\\s+' + classList[i] + '(\\s+)',
  283. 				'g'
  284. 			);
  285. 			elm.className = elm.className.replace(repl, '$1');
  286. 		}
  287. 	},
  288.  
  289.  
  290. 	getStyle : function (elm) {
  291. 		return window.getComputedStyle ? window.getComputedStyle(elm) : elm.currentStyle;
  292. 	},
  293.  
  294.  
  295. 	setStyle : (function () {
  296. 		var helper = document.createElement('div');
  297. 		var getSupportedProp = function (names) {
  298. 			for (var i = 0; i < names.length; i += 1) {
  299. 				if (names[i] in helper.style) {
  300. 					return names[i];
  301. 				}
  302. 			}
  303. 		};
  304. 		var props = {
  305. 			borderRadius: getSupportedProp(['borderRadius', 'MozBorderRadius', 'webkitBorderRadius']),
  306. 			boxShadow: getSupportedProp(['boxShadow', 'MozBoxShadow', 'webkitBoxShadow'])
  307. 		};
  308. 		return function (elm, prop, value) {
  309. 			switch (prop.toLowerCase()) {
  310. 			case 'opacity':
  311. 				var alphaOpacity = Math.round(parseFloat(value) * 100);
  312. 				elm.style.opacity = value;
  313. 				elm.style.filter = 'alpha(opacity=' + alphaOpacity + ')';
  314. 				break;
  315. 			default:
  316. 				elm.style[props[prop]] = value;
  317. 				break;
  318. 			}
  319. 		};
  320. 	})(),
  321.  
  322.  
  323. 	setBorderRadius : function (elm, value) {
  324. 		jsc.setStyle(elm, 'borderRadius', value || '0');
  325. 	},
  326.  
  327.  
  328. 	setBoxShadow : function (elm, value) {
  329. 		jsc.setStyle(elm, 'boxShadow', value || 'none');
  330. 	},
  331.  
  332.  
  333. 	getElementPos : function (e, relativeToViewport) {
  334. 		var x=0, y=0;
  335. 		var rect = e.getBoundingClientRect();
  336. 		x = rect.left;
  337. 		y = rect.top;
  338. 		if (!relativeToViewport) {
  339. 			var viewPos = jsc.getViewPos();
  340. 			x += viewPos[0];
  341. 			y += viewPos[1];
  342. 		}
  343. 		return [x, y];
  344. 	},
  345.  
  346.  
  347. 	getElementSize : function (e) {
  348. 		return [e.offsetWidth, e.offsetHeight];
  349. 	},
  350.  
  351.  
  352. 	// get pointer's X/Y coordinates relative to viewport
  353. 	getAbsPointerPos : function (e) {
  354. 		if (!e) { e = window.event; }
  355. 		var x = 0, y = 0;
  356. 		if (typeof e.changedTouches !== 'undefined' && e.changedTouches.length) {
  357. 			// touch devices
  358. 			x = e.changedTouches[0].clientX;
  359. 			y = e.changedTouches[0].clientY;
  360. 		} else if (typeof e.clientX === 'number') {
  361. 			x = e.clientX;
  362. 			y = e.clientY;
  363. 		}
  364. 		return { x: x, y: y };
  365. 	},
  366.  
  367.  
  368. 	// get pointer's X/Y coordinates relative to target element
  369. 	getRelPointerPos : function (e) {
  370. 		if (!e) { e = window.event; }
  371. 		var target = e.target || e.srcElement;
  372. 		var targetRect = target.getBoundingClientRect();
  373.  
  374. 		var x = 0, y = 0;
  375.  
  376. 		var clientX = 0, clientY = 0;
  377. 		if (typeof e.changedTouches !== 'undefined' && e.changedTouches.length) {
  378. 			// touch devices
  379. 			clientX = e.changedTouches[0].clientX;
  380. 			clientY = e.changedTouches[0].clientY;
  381. 		} else if (typeof e.clientX === 'number') {
  382. 			clientX = e.clientX;
  383. 			clientY = e.clientY;
  384. 		}
  385.  
  386. 		x = clientX - targetRect.left;
  387. 		y = clientY - targetRect.top;
  388. 		return { x: x, y: y };
  389. 	},
  390.  
  391.  
  392. 	getViewPos : function () {
  393. 		var doc = document.documentElement;
  394. 		return [
  395. 			(window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0),
  396. 			(window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0)
  397. 		];
  398. 	},
  399.  
  400.  
  401. 	getViewSize : function () {
  402. 		var doc = document.documentElement;
  403. 		return [
  404. 			(window.innerWidth || doc.clientWidth),
  405. 			(window.innerHeight || doc.clientHeight),
  406. 		];
  407. 	},
  408.  
  409.  
  410. 	redrawPosition : function () {
  411.  
  412. 		if (jsc.picker && jsc.picker.owner) {
  413. 			var thisObj = jsc.picker.owner;
  414.  
  415. 			var tp, vp;
  416.  
  417. 			if (thisObj.fixed) {
  418. 				// Fixed elements are positioned relative to viewport,
  419. 				// therefore we can ignore the scroll offset
  420. 				tp = jsc.getElementPos(thisObj.targetElement, true); // target pos
  421. 				vp = [0, 0]; // view pos
  422. 			} else {
  423. 				tp = jsc.getElementPos(thisObj.targetElement); // target pos
  424. 				vp = jsc.getViewPos(); // view pos
  425. 			}
  426.  
  427. 			var ts = jsc.getElementSize(thisObj.targetElement); // target size
  428. 			var vs = jsc.getViewSize(); // view size
  429. 			var ps = jsc.getPickerOuterDims(thisObj); // picker size
  430. 			var a, b, c;
  431. 			switch (thisObj.position.toLowerCase()) {
  432. 				case 'left': a=1; b=0; c=-1; break;
  433. 				case 'right':a=1; b=0; c=1; break;
  434. 				case 'top':  a=0; b=1; c=-1; break;
  435. 				default:     a=0; b=1; c=1; break;
  436. 			}
  437. 			var l = (ts[b]+ps[b])/2;
  438.  
  439. 			// compute picker position
  440. 			if (!thisObj.smartPosition) {
  441. 				var pp = [
  442. 					tp[a],
  443. 					tp[b]+ts[b]-l+l*c
  444. 				];
  445. 			} else {
  446. 				var pp = [
  447. 					-vp[a]+tp[a]+ps[a] > vs[a] ?
  448. 						(-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]) :
  449. 						tp[a],
  450. 					-vp[b]+tp[b]+ts[b]+ps[b]-l+l*c > vs[b] ?
  451. 						(-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) :
  452. 						(tp[b]+ts[b]-l+l*c >= 0 ? tp[b]+ts[b]-l+l*c : tp[b]+ts[b]-l-l*c)
  453. 				];
  454. 			}
  455.  
  456. 			var x = pp[a];
  457. 			var y = pp[b];
  458. 			var positionValue = thisObj.fixed ? 'fixed' : 'absolute';
  459. 			var contractShadow =
  460. 				(pp[0] + ps[0] > tp[0] || pp[0] < tp[0] + ts[0]) &&
  461. 				(pp[1] + ps[1] < tp[1] + ts[1]);
  462.  
  463. 			jsc._drawPosition(thisObj, x, y, positionValue, contractShadow);
  464. 		}
  465. 	},
  466.  
  467.  
  468. 	_drawPosition : function (thisObj, x, y, positionValue, contractShadow) {
  469. 		var vShadow = contractShadow ? 0 : thisObj.shadowBlur; // px
  470.  
  471. 		jsc.picker.wrap.style.position = positionValue;
  472. 		jsc.picker.wrap.style.left = x + 'px';
  473. 		jsc.picker.wrap.style.top = y + 'px';
  474.  
  475. 		jsc.setBoxShadow(
  476. 			jsc.picker.boxS,
  477. 			thisObj.shadow ?
  478. 				new jsc.BoxShadow(0, vShadow, thisObj.shadowBlur, 0, thisObj.shadowColor) :
  479. 				null);
  480. 	},
  481.  
  482.  
  483. 	getPickerDims : function (thisObj) {
  484. 		var displaySlider = !!jsc.getSliderComponent(thisObj);
  485. 		var dims = [
  486. 			2 * thisObj.insetWidth + 2 * thisObj.padding + thisObj.width +
  487. 				(displaySlider ? 2 * thisObj.insetWidth + jsc.getPadToSliderPadding(thisObj) + thisObj.sliderSize : 0),
  488. 			2 * thisObj.insetWidth + 2 * thisObj.padding + thisObj.height +
  489. 				(thisObj.closable ? 2 * thisObj.insetWidth + thisObj.padding + thisObj.buttonHeight : 0)
  490. 		];
  491. 		return dims;
  492. 	},
  493.  
  494.  
  495. 	getPickerOuterDims : function (thisObj) {
  496. 		var dims = jsc.getPickerDims(thisObj);
  497. 		return [
  498. 			dims[0] + 2 * thisObj.borderWidth,
  499. 			dims[1] + 2 * thisObj.borderWidth
  500. 		];
  501. 	},
  502.  
  503.  
  504. 	getPadToSliderPadding : function (thisObj) {
  505. 		return Math.max(thisObj.padding, 1.5 * (2 * thisObj.pointerBorderWidth + thisObj.pointerThickness));
  506. 	},
  507.  
  508.  
  509. 	getPadYComponent : function (thisObj) {
  510. 		switch (thisObj.mode.charAt(1).toLowerCase()) {
  511. 			case 'v': return 'v'; break;
  512. 		}
  513. 		return 's';
  514. 	},
  515.  
  516.  
  517. 	getSliderComponent : function (thisObj) {
  518. 		if (thisObj.mode.length > 2) {
  519. 			switch (thisObj.mode.charAt(2).toLowerCase()) {
  520. 				case 's': return 's'; break;
  521. 				case 'v': return 'v'; break;
  522. 			}
  523. 		}
  524. 		return null;
  525. 	},
  526.  
  527.  
  528. 	onDocumentMouseDown : function (e) {
  529. 		if (!e) { e = window.event; }
  530. 		var target = e.target || e.srcElement;
  531.  
  532. 		if (target._jscLinkedInstance) {
  533. 			if (target._jscLinkedInstance.showOnClick) {
  534. 				target._jscLinkedInstance.show();
  535. 			}
  536. 		} else if (target._jscControlName) {
  537. 			jsc.onControlPointerStart(e, target, target._jscControlName, 'mouse');
  538. 		} else {
  539. 			// Mouse is outside the picker controls -> hide the color picker!
  540. 			if (jsc.picker && jsc.picker.owner) {
  541. 				jsc.picker.owner.hide();
  542. 			}
  543. 		}
  544. 	},
  545.  
  546.  
  547. 	onDocumentTouchStart : function (e) {
  548. 		if (!e) { e = window.event; }
  549. 		var target = e.target || e.srcElement;
  550.  
  551. 		if (target._jscLinkedInstance) {
  552. 			if (target._jscLinkedInstance.showOnClick) {
  553. 				target._jscLinkedInstance.show();
  554. 			}
  555. 		} else if (target._jscControlName) {
  556. 			jsc.onControlPointerStart(e, target, target._jscControlName, 'touch');
  557. 		} else {
  558. 			if (jsc.picker && jsc.picker.owner) {
  559. 				jsc.picker.owner.hide();
  560. 			}
  561. 		}
  562. 	},
  563.  
  564.  
  565. 	onWindowResize : function (e) {
  566. 		jsc.redrawPosition();
  567. 	},
  568.  
  569.  
  570. 	onParentScroll : function (e) {
  571. 		// hide the picker when one of the parent elements is scrolled
  572. 		if (jsc.picker && jsc.picker.owner) {
  573. 			jsc.picker.owner.hide();
  574. 		}
  575. 	},
  576.  
  577.  
  578. 	_pointerMoveEvent : {
  579. 		mouse: 'mousemove',
  580. 		touch: 'touchmove'
  581. 	},
  582. 	_pointerEndEvent : {
  583. 		mouse: 'mouseup',
  584. 		touch: 'touchend'
  585. 	},
  586.  
  587.  
  588. 	_pointerOrigin : null,
  589. 	_capturedTarget : null,
  590.  
  591.  
  592. 	onControlPointerStart : function (e, target, controlName, pointerType) {
  593. 		var thisObj = target._jscInstance;
  594.  
  595. 		jsc.preventDefault(e);
  596. 		jsc.captureTarget(target);
  597.  
  598. 		var registerDragEvents = function (doc, offset) {
  599. 			jsc.attachGroupEvent('drag', doc, jsc._pointerMoveEvent[pointerType],
  600. 				jsc.onDocumentPointerMove(e, target, controlName, pointerType, offset));
  601. 			jsc.attachGroupEvent('drag', doc, jsc._pointerEndEvent[pointerType],
  602. 				jsc.onDocumentPointerEnd(e, target, controlName, pointerType));
  603. 		};
  604.  
  605. 		registerDragEvents(document, [0, 0]);
  606.  
  607. 		if (window.parent && window.frameElement) {
  608. 			var rect = window.frameElement.getBoundingClientRect();
  609. 			var ofs = [-rect.left, -rect.top];
  610. 			registerDragEvents(window.parent.window.document, ofs);
  611. 		}
  612.  
  613. 		var abs = jsc.getAbsPointerPos(e);
  614. 		var rel = jsc.getRelPointerPos(e);
  615. 		jsc._pointerOrigin = {
  616. 			x: abs.x - rel.x,
  617. 			y: abs.y - rel.y
  618. 		};
  619.  
  620. 		switch (controlName) {
  621. 		case 'pad':
  622. 			// if the slider is at the bottom, move it up
  623. 			switch (jsc.getSliderComponent(thisObj)) {
  624. 			case 's': if (thisObj.hsv[1] === 0) { thisObj.fromHSV(null, 100, null); }; break;
  625. 			case 'v': if (thisObj.hsv[2] === 0) { thisObj.fromHSV(null, null, 100); }; break;
  626. 			}
  627. 			jsc.setPad(thisObj, e, 0, 0);
  628. 			break;
  629.  
  630. 		case 'sld':
  631. 			jsc.setSld(thisObj, e, 0);
  632. 			break;
  633. 		}
  634.  
  635. 		jsc.dispatchFineChange(thisObj);
  636. 	},
  637.  
  638.  
  639. 	onDocumentPointerMove : function (e, target, controlName, pointerType, offset) {
  640. 		return function (e) {
  641. 			var thisObj = target._jscInstance;
  642. 			switch (controlName) {
  643. 			case 'pad':
  644. 				if (!e) { e = window.event; }
  645. 				jsc.setPad(thisObj, e, offset[0], offset[1]);
  646. 				jsc.dispatchFineChange(thisObj);
  647. 				break;
  648.  
  649. 			case 'sld':
  650. 				if (!e) { e = window.event; }
  651. 				jsc.setSld(thisObj, e, offset[1]);
  652. 				jsc.dispatchFineChange(thisObj);
  653. 				break;
  654. 			}
  655. 		}
  656. 	},
  657.  
  658.  
  659. 	onDocumentPointerEnd : function (e, target, controlName, pointerType) {
  660. 		return function (e) {
  661. 			var thisObj = target._jscInstance;
  662. 			jsc.detachGroupEvents('drag');
  663. 			jsc.releaseTarget();
  664. 			// Always dispatch changes after detaching outstanding mouse handlers,
  665. 			// in case some user interaction will occur in user's onchange callback
  666. 			// that would intrude with current mouse events
  667. 			jsc.dispatchChange(thisObj);
  668.                         jsc.dispatchOnChange(thisObj);
  669. 		};
  670. 	},
  671.  
  672.  
  673. 	dispatchChange : function (thisObj) {
  674. 		if (thisObj.valueElement) {
  675. 			if (jsc.isElementType(thisObj.valueElement, 'input')) {
  676. 				jsc.fireEvent(thisObj.valueElement, 'change');
  677. 			}
  678. 		}
  679. 	},
  680.  
  681.         dispatchOnChange : function(thisObj){
  682.                 if(thisObj.onChange){
  683.                    var callback;
  684.                    if (typeof thisObj.onChange === 'string'){
  685. 				callback = new Function (thisObj.onChange);
  686. 			} else {
  687. 				callback = thisObj.onChange;
  688. 			}
  689. 			callback.call(thisObj);
  690.                 }
  691.         },
  692.  
  693.  
  694. 	dispatchFineChange : function (thisObj) {
  695. 		if (thisObj.onFineChange) {
  696. 			var callback;
  697. 			if (typeof thisObj.onFineChange === 'string') {
  698. 				callback = new Function (thisObj.onFineChange);
  699. 			} else {
  700. 				callback = thisObj.onFineChange;
  701. 			}
  702. 			callback.call(thisObj);
  703. 		}
  704. 	},
  705.  
  706.  
  707. 	setPad : function (thisObj, e, ofsX, ofsY) {
  708. 		var pointerAbs = jsc.getAbsPointerPos(e);
  709. 		var x = ofsX + pointerAbs.x - jsc._pointerOrigin.x - thisObj.padding - thisObj.insetWidth;
  710. 		var y = ofsY + pointerAbs.y - jsc._pointerOrigin.y - thisObj.padding - thisObj.insetWidth;
  711.  
  712. 		var xVal = x * (360 / (thisObj.width - 1));
  713. 		var yVal = 100 - (y * (100 / (thisObj.height - 1)));
  714.  
  715. 		switch (jsc.getPadYComponent(thisObj)) {
  716. 		case 's': thisObj.fromHSV(xVal, yVal, null, jsc.leaveSld); break;
  717. 		case 'v': thisObj.fromHSV(xVal, null, yVal, jsc.leaveSld); break;
  718. 		}
  719. 	},
  720.  
  721.  
  722. 	setSld : function (thisObj, e, ofsY) {
  723. 		var pointerAbs = jsc.getAbsPointerPos(e);
  724. 		var y = ofsY + pointerAbs.y - jsc._pointerOrigin.y - thisObj.padding - thisObj.insetWidth;
  725.  
  726. 		var yVal = 100 - (y * (100 / (thisObj.height - 1)));
  727.  
  728. 		switch (jsc.getSliderComponent(thisObj)) {
  729. 		case 's': thisObj.fromHSV(null, yVal, null, jsc.leavePad); break;
  730. 		case 'v': thisObj.fromHSV(null, null, yVal, jsc.leavePad); break;
  731. 		}
  732. 	},
  733.  
  734.  
  735. 	_vmlNS : 'jsc_vml_',
  736. 	_vmlCSS : 'jsc_vml_css_',
  737. 	_vmlReady : false,
  738.  
  739.  
  740. 	initVML : function () {
  741. 		if (!jsc._vmlReady) {
  742. 			// init VML namespace
  743. 			var doc = document;
  744. 			if (!doc.namespaces[jsc._vmlNS]) {
  745. 				doc.namespaces.add(jsc._vmlNS, 'urn:schemas-microsoft-com:vml');
  746. 			}
  747. 			if (!doc.styleSheets[jsc._vmlCSS]) {
  748. 				var tags = ['shape', 'shapetype', 'group', 'background', 'path', 'formulas', 'handles', 'fill', 'stroke', 'shadow', 'textbox', 'textpath', 'imagedata', 'line', 'polyline', 'curve', 'rect', 'roundrect', 'oval', 'arc', 'image'];
  749. 				var ss = doc.createStyleSheet();
  750. 				ss.owningElement.id = jsc._vmlCSS;
  751. 				for (var i = 0; i < tags.length; i += 1) {
  752. 					ss.addRule(jsc._vmlNS + '\\:' + tags[i], 'behavior:url(#default#VML);');
  753. 				}
  754. 			}
  755. 			jsc._vmlReady = true;
  756. 		}
  757. 	},
  758.  
  759.  
  760. 	createPalette : function () {
  761.  
  762. 		var paletteObj = {
  763. 			elm: null,
  764. 			draw: null
  765. 		};
  766.  
  767. 		if (jsc.isCanvasSupported) {
  768. 			// Canvas implementation for modern browsers
  769.  
  770. 			var canvas = document.createElement('canvas');
  771. 			var ctx = canvas.getContext('2d');
  772.  
  773. 			var drawFunc = function (width, height, type) {
  774. 				canvas.width = width;
  775. 				canvas.height = height;
  776.  
  777. 				ctx.clearRect(0, 0, canvas.width, canvas.height);
  778.  
  779. 				var hGrad = ctx.createLinearGradient(0, 0, canvas.width, 0);
  780. 				hGrad.addColorStop(0 / 6, '#F00');
  781. 				hGrad.addColorStop(1 / 6, '#FF0');
  782. 				hGrad.addColorStop(2 / 6, '#0F0');
  783. 				hGrad.addColorStop(3 / 6, '#0FF');
  784. 				hGrad.addColorStop(4 / 6, '#00F');
  785. 				hGrad.addColorStop(5 / 6, '#F0F');
  786. 				hGrad.addColorStop(6 / 6, '#F00');
  787.  
  788. 				ctx.fillStyle = hGrad;
  789. 				ctx.fillRect(0, 0, canvas.width, canvas.height);
  790.  
  791. 				var vGrad = ctx.createLinearGradient(0, 0, 0, canvas.height);
  792. 				switch (type.toLowerCase()) {
  793. 				case 's':
  794. 					vGrad.addColorStop(0, 'rgba(255,255,255,0)');
  795. 					vGrad.addColorStop(1, 'rgba(255,255,255,1)');
  796. 					break;
  797. 				case 'v':
  798. 					vGrad.addColorStop(0, 'rgba(0,0,0,0)');
  799. 					vGrad.addColorStop(1, 'rgba(0,0,0,1)');
  800. 					break;
  801. 				}
  802. 				ctx.fillStyle = vGrad;
  803. 				ctx.fillRect(0, 0, canvas.width, canvas.height);
  804. 			};
  805.  
  806. 			paletteObj.elm = canvas;
  807. 			paletteObj.draw = drawFunc;
  808.  
  809. 		} else {
  810. 			// VML fallback for IE 7 and 8
  811.  
  812. 			jsc.initVML();
  813.  
  814. 			var vmlContainer = document.createElement('div');
  815. 			vmlContainer.style.position = 'relative';
  816. 			vmlContainer.style.overflow = 'hidden';
  817.  
  818. 			var hGrad = document.createElement(jsc._vmlNS + ':fill');
  819. 			hGrad.type = 'gradient';
  820. 			hGrad.method = 'linear';
  821. 			hGrad.angle = '90';
  822. 			hGrad.colors = '16.67% #F0F, 33.33% #00F, 50% #0FF, 66.67% #0F0, 83.33% #FF0'
  823.  
  824. 			var hRect = document.createElement(jsc._vmlNS + ':rect');
  825. 			hRect.style.position = 'absolute';
  826. 			hRect.style.left = -1 + 'px';
  827. 			hRect.style.top = -1 + 'px';
  828. 			hRect.stroked = false;
  829. 			hRect.appendChild(hGrad);
  830. 			vmlContainer.appendChild(hRect);
  831.  
  832. 			var vGrad = document.createElement(jsc._vmlNS + ':fill');
  833. 			vGrad.type = 'gradient';
  834. 			vGrad.method = 'linear';
  835. 			vGrad.angle = '180';
  836. 			vGrad.opacity = '0';
  837.  
  838. 			var vRect = document.createElement(jsc._vmlNS + ':rect');
  839. 			vRect.style.position = 'absolute';
  840. 			vRect.style.left = -1 + 'px';
  841. 			vRect.style.top = -1 + 'px';
  842. 			vRect.stroked = false;
  843. 			vRect.appendChild(vGrad);
  844. 			vmlContainer.appendChild(vRect);
  845.  
  846. 			var drawFunc = function (width, height, type) {
  847. 				vmlContainer.style.width = width + 'px';
  848. 				vmlContainer.style.height = height + 'px';
  849.  
  850. 				hRect.style.width =
  851. 				vRect.style.width =
  852. 					(width + 1) + 'px';
  853. 				hRect.style.height =
  854. 				vRect.style.height =
  855. 					(height + 1) + 'px';
  856.  
  857. 				// Colors must be specified during every redraw, otherwise IE won't display
  858. 				// a full gradient during a subsequential redraw
  859. 				hGrad.color = '#F00';
  860. 				hGrad.color2 = '#F00';
  861.  
  862. 				switch (type.toLowerCase()) {
  863. 				case 's':
  864. 					vGrad.color = vGrad.color2 = '#FFF';
  865. 					break;
  866. 				case 'v':
  867. 					vGrad.color = vGrad.color2 = '#000';
  868. 					break;
  869. 				}
  870. 			};
  871. 			
  872. 			paletteObj.elm = vmlContainer;
  873. 			paletteObj.draw = drawFunc;
  874. 		}
  875.  
  876. 		return paletteObj;
  877. 	},
  878.  
  879.  
  880. 	createSliderGradient : function () {
  881.  
  882. 		var sliderObj = {
  883. 			elm: null,
  884. 			draw: null
  885. 		};
  886.  
  887. 		if (jsc.isCanvasSupported) {
  888. 			// Canvas implementation for modern browsers
  889.  
  890. 			var canvas = document.createElement('canvas');
  891. 			var ctx = canvas.getContext('2d');
  892.  
  893. 			var drawFunc = function (width, height, color1, color2) {
  894. 				canvas.width = width;
  895. 				canvas.height = height;
  896.  
  897. 				ctx.clearRect(0, 0, canvas.width, canvas.height);
  898.  
  899. 				var grad = ctx.createLinearGradient(0, 0, 0, canvas.height);
  900. 				grad.addColorStop(0, color1);
  901. 				grad.addColorStop(1, color2);
  902.  
  903. 				ctx.fillStyle = grad;
  904. 				ctx.fillRect(0, 0, canvas.width, canvas.height);
  905. 			};
  906.  
  907. 			sliderObj.elm = canvas;
  908. 			sliderObj.draw = drawFunc;
  909.  
  910. 		} else {
  911. 			// VML fallback for IE 7 and 8
  912.  
  913. 			jsc.initVML();
  914.  
  915. 			var vmlContainer = document.createElement('div');
  916. 			vmlContainer.style.position = 'relative';
  917. 			vmlContainer.style.overflow = 'hidden';
  918.  
  919. 			var grad = document.createElement(jsc._vmlNS + ':fill');
  920. 			grad.type = 'gradient';
  921. 			grad.method = 'linear';
  922. 			grad.angle = '180';
  923.  
  924. 			var rect = document.createElement(jsc._vmlNS + ':rect');
  925. 			rect.style.position = 'absolute';
  926. 			rect.style.left = -1 + 'px';
  927. 			rect.style.top = -1 + 'px';
  928. 			rect.stroked = false;
  929. 			rect.appendChild(grad);
  930. 			vmlContainer.appendChild(rect);
  931.  
  932. 			var drawFunc = function (width, height, color1, color2) {
  933. 				vmlContainer.style.width = width + 'px';
  934. 				vmlContainer.style.height = height + 'px';
  935.  
  936. 				rect.style.width = (width + 1) + 'px';
  937. 				rect.style.height = (height + 1) + 'px';
  938.  
  939. 				grad.color = color1;
  940. 				grad.color2 = color2;
  941. 			};
  942. 			
  943. 			sliderObj.elm = vmlContainer;
  944. 			sliderObj.draw = drawFunc;
  945. 		}
  946.  
  947. 		return sliderObj;
  948. 	},
  949.  
  950.  
  951. 	leaveValue : 1<<0,
  952. 	leaveStyle : 1<<1,
  953. 	leavePad : 1<<2,
  954. 	leaveSld : 1<<3,
  955.  
  956.  
  957. 	BoxShadow : (function () {
  958. 		var BoxShadow = function (hShadow, vShadow, blur, spread, color, inset) {
  959. 			this.hShadow = hShadow;
  960. 			this.vShadow = vShadow;
  961. 			this.blur = blur;
  962. 			this.spread = spread;
  963. 			this.color = color;
  964. 			this.inset = !!inset;
  965. 		};
  966.  
  967. 		BoxShadow.prototype.toString = function () {
  968. 			var vals = [
  969. 				Math.round(this.hShadow) + 'px',
  970. 				Math.round(this.vShadow) + 'px',
  971. 				Math.round(this.blur) + 'px',
  972. 				Math.round(this.spread) + 'px',
  973. 				this.color
  974. 			];
  975. 			if (this.inset) {
  976. 				vals.push('inset');
  977. 			}
  978. 			return vals.join(' ');
  979. 		};
  980.  
  981. 		return BoxShadow;
  982. 	})(),
  983.  
  984.  
  985. 	//
  986. 	// Usage:
  987. 	// var myColor = new jscolor(<targetElement> [, <options>])
  988. 	//
  989.  
  990. 	jscolor : function (targetElement, options) {
  991.  
  992. 		// General options
  993. 		//
  994. 		this.value = null; // initial HEX color. To change it later, use methods fromString(), fromHSV() and fromRGB()
  995. 		this.valueElement = targetElement; // element that will be used to display and input the color code
  996. 		this.styleElement = targetElement; // element that will preview the picked color using CSS backgroundColor
  997. 		this.required = true; // whether the associated text <input> can be left empty
  998. 		this.refine = true; // whether to refine the entered color code (e.g. uppercase it and remove whitespace)
  999. 		this.hash = false; // whether to prefix the HEX color code with # symbol
  1000. 		this.uppercase = true; // whether to uppercase the color code
  1001. 		this.onFineChange = null; // called instantly every time the color changes (value can be either a function or a string with javascript code)
  1002.                 this.onChange = null;
  1003. 		this.activeClass = 'jscolor-active'; // class to be set to the target element when a picker window is open on it
  1004. 		this.minS = 0; // min allowed saturation (0 - 100)
  1005. 		this.maxS = 100; // max allowed saturation (0 - 100)
  1006. 		this.minV = 0; // min allowed value (brightness) (0 - 100)
  1007. 		this.maxV = 100; // max allowed value (brightness) (0 - 100)
  1008.  
  1009. 		// Accessing the picked color
  1010. 		//
  1011. 		this.hsv = [0, 0, 100]; // read-only  [0-360, 0-100, 0-100]
  1012. 		this.rgb = [255, 255, 255]; // read-only  [0-255, 0-255, 0-255]
  1013.  
  1014. 		// Color Picker options
  1015. 		//
  1016. 		this.width = 181; // width of color palette (in px)
  1017. 		this.height = 101; // height of color palette (in px)
  1018. 		this.showOnClick = true; // whether to display the color picker when user clicks on its target element
  1019. 		this.mode = 'HSV'; // HSV | HVS | HS | HV - layout of the color picker controls
  1020. 		this.position = 'bottom'; // left | right | top | bottom - position relative to the target element
  1021. 		this.smartPosition = true; // automatically change picker position when there is not enough space for it
  1022. 		this.sliderSize = 16; // px
  1023. 		this.crossSize = 8; // px
  1024. 		this.closable = false; // whether to display the Close button
  1025. 		this.closeText = 'Close';
  1026. 		this.buttonColor = '#000000'; // CSS color
  1027. 		this.buttonHeight = 18; // px
  1028. 		this.padding = 12; // px
  1029. 		this.backgroundColor = '#FFFFFF'; // CSS color
  1030. 		this.borderWidth = 1; // px
  1031. 		this.borderColor = '#BBBBBB'; // CSS color
  1032. 		this.borderRadius = 8; // px
  1033. 		this.insetWidth = 1; // px
  1034. 		this.insetColor = '#BBBBBB'; // CSS color
  1035. 		this.shadow = true; // whether to display shadow
  1036. 		this.shadowBlur = 15; // px
  1037. 		this.shadowColor = 'rgba(0,0,0,0.2)'; // CSS color
  1038. 		this.pointerColor = '#4C4C4C'; // px
  1039. 		this.pointerBorderColor = '#FFFFFF'; // px
  1040.         this.pointerBorderWidth = 1; // px
  1041.         this.pointerThickness = 2; // px
  1042. 		this.zIndex = 1000;
  1043. 		this.container = null; // where to append the color picker (BODY element by default)
  1044.  
  1045.  
  1046. 		for (var opt in options) {
  1047. 			if (options.hasOwnProperty(opt)) {
  1048. 				this[opt] = options[opt];
  1049. 			}
  1050. 		}
  1051.  
  1052.  
  1053. 		this.hide = function () {
  1054. 			if (isPickerOwner()) {
  1055. 				detachPicker();
  1056. 			}
  1057. 		};
  1058.  
  1059.  
  1060. 		this.show = function () {
  1061. 			drawPicker();
  1062. 		};
  1063.  
  1064.  
  1065. 		this.redraw = function () {
  1066. 			if (isPickerOwner()) {
  1067. 				drawPicker();
  1068. 			}
  1069. 		};
  1070.  
  1071.  
  1072. 		this.importColor = function () {
  1073. 			if (!this.valueElement) {
  1074. 				this.exportColor();
  1075. 			} else {
  1076. 				if (jsc.isElementType(this.valueElement, 'input')) {
  1077. 					if (!this.refine) {
  1078. 						if (!this.fromString(this.valueElement.value, jsc.leaveValue)) {
  1079. 							if (this.styleElement) {
  1080. 								this.styleElement.style.backgroundImage = this.styleElement._jscOrigStyle.backgroundImage;
  1081. 								this.styleElement.style.backgroundColor = this.styleElement._jscOrigStyle.backgroundColor;
  1082. 								this.styleElement.style.color = this.styleElement._jscOrigStyle.color;
  1083. 							}
  1084. 							this.exportColor(jsc.leaveValue | jsc.leaveStyle);
  1085. 						}
  1086. 					} else if (!this.required && /^\s*$/.test(this.valueElement.value)) {
  1087. 						this.valueElement.value = '';
  1088. 						if (this.styleElement) {
  1089. 							this.styleElement.style.backgroundImage = this.styleElement._jscOrigStyle.backgroundImage;
  1090. 							this.styleElement.style.backgroundColor = this.styleElement._jscOrigStyle.backgroundColor;
  1091. 							this.styleElement.style.color = this.styleElement._jscOrigStyle.color;
  1092. 						}
  1093. 						this.exportColor(jsc.leaveValue | jsc.leaveStyle);
  1094.  
  1095. 					} else if (this.fromString(this.valueElement.value)) {
  1096. 						// managed to import color successfully from the value -> OK, don't do anything
  1097. 					} else {
  1098. 						this.exportColor();
  1099. 					}
  1100. 				} else {
  1101. 					// not an input element -> doesn't have any value
  1102. 					this.exportColor();
  1103. 				}
  1104. 			}
  1105. 		};
  1106.  
  1107.  
  1108. 		this.exportColor = function (flags) {
  1109. 			if (!(flags & jsc.leaveValue) && this.valueElement) {
  1110. 				var value = this.toString();
  1111. 				if (this.uppercase) { value = value.toUpperCase(); }
  1112. 				if (this.hash) { value = '#' + value; }
  1113.  
  1114. 				if (jsc.isElementType(this.valueElement, 'input')) {
  1115. 					this.valueElement.value = value;
  1116. 				} else {
  1117. 					this.valueElement.innerHTML = value;
  1118. 				}
  1119. 			}
  1120. 			if (!(flags & jsc.leaveStyle)) {
  1121. 				if (this.styleElement) {
  1122. 					this.styleElement.style.backgroundImage = 'none';
  1123. 					this.styleElement.style.backgroundColor = '#' + this.toString();
  1124. 					this.styleElement.style.color = this.isLight() ? '#000' : '#FFF';
  1125. 				}
  1126. 			}
  1127. 			if (!(flags & jsc.leavePad) && isPickerOwner()) {
  1128. 				redrawPad();
  1129. 			}
  1130. 			if (!(flags & jsc.leaveSld) && isPickerOwner()) {
  1131. 				redrawSld();
  1132. 			}
  1133. 		};
  1134.  
  1135.  
  1136. 		// h: 0-360
  1137. 		// s: 0-100
  1138. 		// v: 0-100
  1139. 		//
  1140. 		this.fromHSV = function (h, s, v, flags) { // null = don't change
  1141. 			if (h !== null) {
  1142. 				if (isNaN(h)) { return false; }
  1143. 				h = Math.max(0, Math.min(360, h));
  1144. 			}
  1145. 			if (s !== null) {
  1146. 				if (isNaN(s)) { return false; }
  1147. 				s = Math.max(0, Math.min(100, this.maxS, s), this.minS);
  1148. 			}
  1149. 			if (v !== null) {
  1150. 				if (isNaN(v)) { return false; }
  1151. 				v = Math.max(0, Math.min(100, this.maxV, v), this.minV);
  1152. 			}
  1153.  
  1154. 			this.rgb = HSV_RGB(
  1155. 				h===null ? this.hsv[0] : (this.hsv[0]=h),
  1156. 				s===null ? this.hsv[1] : (this.hsv[1]=s),
  1157. 				v===null ? this.hsv[2] : (this.hsv[2]=v)
  1158. 			);
  1159.  
  1160. 			this.exportColor(flags);
  1161. 		};
  1162.  
  1163.  
  1164. 		// r: 0-255
  1165. 		// g: 0-255
  1166. 		// b: 0-255
  1167. 		//
  1168. 		this.fromRGB = function (r, g, b, flags) { // null = don't change
  1169. 			if (r !== null) {
  1170. 				if (isNaN(r)) { return false; }
  1171. 				r = Math.max(0, Math.min(255, r));
  1172. 			}
  1173. 			if (g !== null) {
  1174. 				if (isNaN(g)) { return false; }
  1175. 				g = Math.max(0, Math.min(255, g));
  1176. 			}
  1177. 			if (b !== null) {
  1178. 				if (isNaN(b)) { return false; }
  1179. 				b = Math.max(0, Math.min(255, b));
  1180. 			}
  1181.  
  1182. 			var hsv = RGB_HSV(
  1183. 				r===null ? this.rgb[0] : r,
  1184. 				g===null ? this.rgb[1] : g,
  1185. 				b===null ? this.rgb[2] : b
  1186. 			);
  1187. 			if (hsv[0] !== null) {
  1188. 				this.hsv[0] = Math.max(0, Math.min(360, hsv[0]));
  1189. 			}
  1190. 			if (hsv[2] !== 0) {
  1191. 				this.hsv[1] = hsv[1]===null ? null : Math.max(0, this.minS, Math.min(100, this.maxS, hsv[1]));
  1192. 			}
  1193. 			this.hsv[2] = hsv[2]===null ? null : Math.max(0, this.minV, Math.min(100, this.maxV, hsv[2]));
  1194.  
  1195. 			// update RGB according to final HSV, as some values might be trimmed
  1196. 			var rgb = HSV_RGB(this.hsv[0], this.hsv[1], this.hsv[2]);
  1197. 			this.rgb[0] = rgb[0];
  1198. 			this.rgb[1] = rgb[1];
  1199. 			this.rgb[2] = rgb[2];
  1200.  
  1201. 			this.exportColor(flags);
  1202. 		};
  1203.  
  1204.  
  1205. 		this.fromString = function (str, flags) {
  1206. 			var m;
  1207. 			if (m = str.match(/^\W*([0-9A-F]{3}([0-9A-F]{3})?)\W*$/i)) {
  1208. 				// HEX notation
  1209. 				//
  1210.  
  1211. 				if (m[1].length === 6) {
  1212. 					// 6-char notation
  1213. 					this.fromRGB(
  1214. 						parseInt(m[1].substr(0,2),16),
  1215. 						parseInt(m[1].substr(2,2),16),
  1216. 						parseInt(m[1].substr(4,2),16),
  1217. 						flags
  1218. 					);
  1219. 				} else {
  1220. 					// 3-char notation
  1221. 					this.fromRGB(
  1222. 						parseInt(m[1].charAt(0) + m[1].charAt(0),16),
  1223. 						parseInt(m[1].charAt(1) + m[1].charAt(1),16),
  1224. 						parseInt(m[1].charAt(2) + m[1].charAt(2),16),
  1225. 						flags
  1226. 					);
  1227. 				}
  1228. 				return true;
  1229.  
  1230. 			} else if (m = str.match(/^\W*rgba?\(([^)]*)\)\W*$/i)) {
  1231. 				var params = m[1].split(',');
  1232. 				var re = /^\s*(\d*)(\.\d+)?\s*$/;
  1233. 				var mR, mG, mB;
  1234. 				if (
  1235. 					params.length >= 3 &&
  1236. 					(mR = params[0].match(re)) &&
  1237. 					(mG = params[1].match(re)) &&
  1238. 					(mB = params[2].match(re))
  1239. 				) {
  1240. 					var r = parseFloat((mR[1] || '0') + (mR[2] || ''));
  1241. 					var g = parseFloat((mG[1] || '0') + (mG[2] || ''));
  1242. 					var b = parseFloat((mB[1] || '0') + (mB[2] || ''));
  1243. 					this.fromRGB(r, g, b, flags);
  1244. 					return true;
  1245. 				}
  1246. 			}
  1247. 			return false;
  1248. 		};
  1249.  
  1250.  
  1251. 		this.toString = function () {
  1252. 			return (
  1253. 				(0x100 | Math.round(this.rgb[0])).toString(16).substr(1) +
  1254. 				(0x100 | Math.round(this.rgb[1])).toString(16).substr(1) +
  1255. 				(0x100 | Math.round(this.rgb[2])).toString(16).substr(1)
  1256. 			);
  1257. 		};
  1258.  
  1259.  
  1260. 		this.toHEXString = function () {
  1261. 			return '#' + this.toString().toUpperCase();
  1262. 		};
  1263.  
  1264.  
  1265. 		this.toRGBString = function () {
  1266. 			return ('rgb(' +
  1267. 				Math.round(this.rgb[0]) + ',' +
  1268. 				Math.round(this.rgb[1]) + ',' +
  1269. 				Math.round(this.rgb[2]) + ')'
  1270. 			);
  1271. 		};
  1272.  
  1273.  
  1274. 		this.isLight = function () {
  1275. 			return (
  1276. 				0.213 * this.rgb[0] +
  1277. 				0.715 * this.rgb[1] +
  1278. 				0.072 * this.rgb[2] >
  1279. 				255 / 2
  1280. 			);
  1281. 		};
  1282.  
  1283.  
  1284. 		this._processParentElementsInDOM = function () {
  1285. 			if (this._linkedElementsProcessed) { return; }
  1286. 			this._linkedElementsProcessed = true;
  1287.  
  1288. 			var elm = this.targetElement;
  1289. 			do {
  1290. 				// If the target element or one of its parent nodes has fixed position,
  1291. 				// then use fixed positioning instead
  1292. 				//
  1293. 				// Note: In Firefox, getComputedStyle returns null in a hidden iframe,
  1294. 				// that's why we need to check if the returned style object is non-empty
  1295. 				var currStyle = jsc.getStyle(elm);
  1296. 				if (currStyle && currStyle.position.toLowerCase() === 'fixed') {
  1297. 					this.fixed = true;
  1298. 				}
  1299.  
  1300. 				if (elm !== this.targetElement) {
  1301. 					// Ensure to attach onParentScroll only once to each parent element
  1302. 					// (multiple targetElements can share the same parent nodes)
  1303. 					//
  1304. 					// Note: It's not just offsetParents that can be scrollable,
  1305. 					// that's why we loop through all parent nodes
  1306. 					if (!elm._jscEventsAttached) {
  1307. 						jsc.attachEvent(elm, 'scroll', jsc.onParentScroll);
  1308. 						elm._jscEventsAttached = true;
  1309. 					}
  1310. 				}
  1311. 			} while ((elm = elm.parentNode) && !jsc.isElementType(elm, 'body'));
  1312. 		};
  1313.  
  1314.  
  1315. 		// r: 0-255
  1316. 		// g: 0-255
  1317. 		// b: 0-255
  1318. 		//
  1319. 		// returns: [ 0-360, 0-100, 0-100 ]
  1320. 		//
  1321. 		function RGB_HSV (r, g, b) {
  1322. 			r /= 255;
  1323. 			g /= 255;
  1324. 			b /= 255;
  1325. 			var n = Math.min(Math.min(r,g),b);
  1326. 			var v = Math.max(Math.max(r,g),b);
  1327. 			var m = v - n;
  1328. 			if (m === 0) { return [ null, 0, 100 * v ]; }
  1329. 			var h = r===n ? 3+(b-g)/m : (g===n ? 5+(r-b)/m : 1+(g-r)/m);
  1330. 			return [
  1331. 				60 * (h===6?0:h),
  1332. 				100 * (m/v),
  1333. 				100 * v
  1334. 			];
  1335. 		}
  1336.  
  1337.  
  1338. 		// h: 0-360
  1339. 		// s: 0-100
  1340. 		// v: 0-100
  1341. 		//
  1342. 		// returns: [ 0-255, 0-255, 0-255 ]
  1343. 		//
  1344. 		function HSV_RGB (h, s, v) {
  1345. 			var u = 255 * (v / 100);
  1346.  
  1347. 			if (h === null) {
  1348. 				return [ u, u, u ];
  1349. 			}
  1350.  
  1351. 			h /= 60;
  1352. 			s /= 100;
  1353.  
  1354. 			var i = Math.floor(h);
  1355. 			var f = i%2 ? h-i : 1-(h-i);
  1356. 			var m = u * (1 - s);
  1357. 			var n = u * (1 - s * f);
  1358. 			switch (i) {
  1359. 				case 6:
  1360. 				case 0: return [u,n,m];
  1361. 				case 1: return [n,u,m];
  1362. 				case 2: return [m,u,n];
  1363. 				case 3: return [m,n,u];
  1364. 				case 4: return [n,m,u];
  1365. 				case 5: return [u,m,n];
  1366. 			}
  1367. 		}
  1368.  
  1369.  
  1370. 		function detachPicker () {
  1371. 			jsc.unsetClass(THIS.targetElement, THIS.activeClass);
  1372. 			jsc.picker.wrap.parentNode.removeChild(jsc.picker.wrap);
  1373. 			delete jsc.picker.owner;
  1374. 		}
  1375.  
  1376.  
  1377. 		function drawPicker () {
  1378.  
  1379. 			// At this point, when drawing the picker, we know what the parent elements are
  1380. 			// and we can do all related DOM operations, such as registering events on them
  1381. 			// or checking their positioning
  1382. 			THIS._processParentElementsInDOM();
  1383.  
  1384. 			if (!jsc.picker) {
  1385. 				jsc.picker = {
  1386. 					owner: null,
  1387. 					wrap : document.createElement('div'),
  1388. 					box : document.createElement('div'),
  1389. 					boxS : document.createElement('div'), // shadow area
  1390. 					boxB : document.createElement('div'), // border
  1391. 					pad : document.createElement('div'),
  1392. 					padB : document.createElement('div'), // border
  1393. 					padM : document.createElement('div'), // mouse/touch area
  1394. 					padPal : jsc.createPalette(),
  1395. 					cross : document.createElement('div'),
  1396. 					crossBY : document.createElement('div'), // border Y
  1397. 					crossBX : document.createElement('div'), // border X
  1398. 					crossLY : document.createElement('div'), // line Y
  1399. 					crossLX : document.createElement('div'), // line X
  1400. 					sld : document.createElement('div'),
  1401. 					sldB : document.createElement('div'), // border
  1402. 					sldM : document.createElement('div'), // mouse/touch area
  1403. 					sldGrad : jsc.createSliderGradient(),
  1404. 					sldPtrS : document.createElement('div'), // slider pointer spacer
  1405. 					sldPtrIB : document.createElement('div'), // slider pointer inner border
  1406. 					sldPtrMB : document.createElement('div'), // slider pointer middle border
  1407. 					sldPtrOB : document.createElement('div'), // slider pointer outer border
  1408. 					btn : document.createElement('div'),
  1409. 					btnT : document.createElement('span') // text
  1410. 				};
  1411.  
  1412. 				jsc.picker.pad.appendChild(jsc.picker.padPal.elm);
  1413. 				jsc.picker.padB.appendChild(jsc.picker.pad);
  1414. 				jsc.picker.cross.appendChild(jsc.picker.crossBY);
  1415. 				jsc.picker.cross.appendChild(jsc.picker.crossBX);
  1416. 				jsc.picker.cross.appendChild(jsc.picker.crossLY);
  1417. 				jsc.picker.cross.appendChild(jsc.picker.crossLX);
  1418. 				jsc.picker.padB.appendChild(jsc.picker.cross);
  1419. 				jsc.picker.box.appendChild(jsc.picker.padB);
  1420. 				jsc.picker.box.appendChild(jsc.picker.padM);
  1421.  
  1422. 				jsc.picker.sld.appendChild(jsc.picker.sldGrad.elm);
  1423. 				jsc.picker.sldB.appendChild(jsc.picker.sld);
  1424. 				jsc.picker.sldB.appendChild(jsc.picker.sldPtrOB);
  1425. 				jsc.picker.sldPtrOB.appendChild(jsc.picker.sldPtrMB);
  1426. 				jsc.picker.sldPtrMB.appendChild(jsc.picker.sldPtrIB);
  1427. 				jsc.picker.sldPtrIB.appendChild(jsc.picker.sldPtrS);
  1428. 				jsc.picker.box.appendChild(jsc.picker.sldB);
  1429. 				jsc.picker.box.appendChild(jsc.picker.sldM);
  1430.  
  1431. 				jsc.picker.btn.appendChild(jsc.picker.btnT);
  1432. 				jsc.picker.box.appendChild(jsc.picker.btn);
  1433.  
  1434. 				jsc.picker.boxB.appendChild(jsc.picker.box);
  1435. 				jsc.picker.wrap.appendChild(jsc.picker.boxS);
  1436. 				jsc.picker.wrap.appendChild(jsc.picker.boxB);
  1437. 			}
  1438.  
  1439. 			var p = jsc.picker;
  1440.  
  1441. 			var displaySlider = !!jsc.getSliderComponent(THIS);
  1442. 			var dims = jsc.getPickerDims(THIS);
  1443. 			var crossOuterSize = (2 * THIS.pointerBorderWidth + THIS.pointerThickness + 2 * THIS.crossSize);
  1444. 			var padToSliderPadding = jsc.getPadToSliderPadding(THIS);
  1445. 			var borderRadius = Math.min(
  1446. 				THIS.borderRadius,
  1447. 				Math.round(THIS.padding * Math.PI)); // px
  1448. 			var padCursor = 'crosshair';
  1449.  
  1450. 			// wrap
  1451. 			p.wrap.style.clear = 'both';
  1452. 			p.wrap.style.width = (dims[0] + 2 * THIS.borderWidth) + 'px';
  1453. 			p.wrap.style.height = (dims[1] + 2 * THIS.borderWidth) + 'px';
  1454. 			p.wrap.style.zIndex = THIS.zIndex;
  1455.  
  1456. 			// picker
  1457. 			p.box.style.width = dims[0] + 'px';
  1458. 			p.box.style.height = dims[1] + 'px';
  1459.  
  1460. 			p.boxS.style.position = 'absolute';
  1461. 			p.boxS.style.left = '0';
  1462. 			p.boxS.style.top = '0';
  1463. 			p.boxS.style.width = '100%';
  1464. 			p.boxS.style.height = '100%';
  1465. 			jsc.setBorderRadius(p.boxS, borderRadius + 'px');
  1466.  
  1467. 			// picker border
  1468. 			p.boxB.style.position = 'relative';
  1469. 			p.boxB.style.border = THIS.borderWidth + 'px solid';
  1470. 			p.boxB.style.borderColor = THIS.borderColor;
  1471. 			p.boxB.style.background = THIS.backgroundColor;
  1472. 			jsc.setBorderRadius(p.boxB, borderRadius + 'px');
  1473.  
  1474. 			// IE hack:
  1475. 			// If the element is transparent, IE will trigger the event on the elements under it,
  1476. 			// e.g. on Canvas or on elements with border
  1477. 			p.padM.style.background =
  1478. 			p.sldM.style.background =
  1479. 				'#FFF';
  1480. 			jsc.setStyle(p.padM, 'opacity', '0');
  1481. 			jsc.setStyle(p.sldM, 'opacity', '0');
  1482.  
  1483. 			// pad
  1484. 			p.pad.style.position = 'relative';
  1485. 			p.pad.style.width = THIS.width + 'px';
  1486. 			p.pad.style.height = THIS.height + 'px';
  1487.  
  1488. 			// pad palettes (HSV and HVS)
  1489. 			p.padPal.draw(THIS.width, THIS.height, jsc.getPadYComponent(THIS));
  1490.  
  1491. 			// pad border
  1492. 			p.padB.style.position = 'absolute';
  1493. 			p.padB.style.left = THIS.padding + 'px';
  1494. 			p.padB.style.top = THIS.padding + 'px';
  1495. 			p.padB.style.border = THIS.insetWidth + 'px solid';
  1496. 			p.padB.style.borderColor = THIS.insetColor;
  1497.  
  1498. 			// pad mouse area
  1499. 			p.padM._jscInstance = THIS;
  1500. 			p.padM._jscControlName = 'pad';
  1501. 			p.padM.style.position = 'absolute';
  1502. 			p.padM.style.left = '0';
  1503. 			p.padM.style.top = '0';
  1504. 			p.padM.style.width = (THIS.padding + 2 * THIS.insetWidth + THIS.width + padToSliderPadding / 2) + 'px';
  1505. 			p.padM.style.height = dims[1] + 'px';
  1506. 			p.padM.style.cursor = padCursor;
  1507.  
  1508. 			// pad cross
  1509. 			p.cross.style.position = 'absolute';
  1510. 			p.cross.style.left =
  1511. 			p.cross.style.top =
  1512. 				'0';
  1513. 			p.cross.style.width =
  1514. 			p.cross.style.height =
  1515. 				crossOuterSize + 'px';
  1516.  
  1517. 			// pad cross border Y and X
  1518. 			p.crossBY.style.position =
  1519. 			p.crossBX.style.position =
  1520. 				'absolute';
  1521. 			p.crossBY.style.background =
  1522. 			p.crossBX.style.background =
  1523. 				THIS.pointerBorderColor;
  1524. 			p.crossBY.style.width =
  1525. 			p.crossBX.style.height =
  1526. 				(2 * THIS.pointerBorderWidth + THIS.pointerThickness) + 'px';
  1527. 			p.crossBY.style.height =
  1528. 			p.crossBX.style.width =
  1529. 				crossOuterSize + 'px';
  1530. 			p.crossBY.style.left =
  1531. 			p.crossBX.style.top =
  1532. 				(Math.floor(crossOuterSize / 2) - Math.floor(THIS.pointerThickness / 2) - THIS.pointerBorderWidth) + 'px';
  1533. 			p.crossBY.style.top =
  1534. 			p.crossBX.style.left =
  1535. 				'0';
  1536.  
  1537. 			// pad cross line Y and X
  1538. 			p.crossLY.style.position =
  1539. 			p.crossLX.style.position =
  1540. 				'absolute';
  1541. 			p.crossLY.style.background =
  1542. 			p.crossLX.style.background =
  1543. 				THIS.pointerColor;
  1544. 			p.crossLY.style.height =
  1545. 			p.crossLX.style.width =
  1546. 				(crossOuterSize - 2 * THIS.pointerBorderWidth) + 'px';
  1547. 			p.crossLY.style.width =
  1548. 			p.crossLX.style.height =
  1549. 				THIS.pointerThickness + 'px';
  1550. 			p.crossLY.style.left =
  1551. 			p.crossLX.style.top =
  1552. 				(Math.floor(crossOuterSize / 2) - Math.floor(THIS.pointerThickness / 2)) + 'px';
  1553. 			p.crossLY.style.top =
  1554. 			p.crossLX.style.left =
  1555. 				THIS.pointerBorderWidth + 'px';
  1556.  
  1557. 			// slider
  1558. 			p.sld.style.overflow = 'hidden';
  1559. 			p.sld.style.width = THIS.sliderSize + 'px';
  1560. 			p.sld.style.height = THIS.height + 'px';
  1561.  
  1562. 			// slider gradient
  1563. 			p.sldGrad.draw(THIS.sliderSize, THIS.height, '#000', '#000');
  1564.  
  1565. 			// slider border
  1566. 			p.sldB.style.display = displaySlider ? 'block' : 'none';
  1567. 			p.sldB.style.position = 'absolute';
  1568. 			p.sldB.style.right = THIS.padding + 'px';
  1569. 			p.sldB.style.top = THIS.padding + 'px';
  1570. 			p.sldB.style.border = THIS.insetWidth + 'px solid';
  1571. 			p.sldB.style.borderColor = THIS.insetColor;
  1572.  
  1573. 			// slider mouse area
  1574. 			p.sldM._jscInstance = THIS;
  1575. 			p.sldM._jscControlName = 'sld';
  1576. 			p.sldM.style.display = displaySlider ? 'block' : 'none';
  1577. 			p.sldM.style.position = 'absolute';
  1578. 			p.sldM.style.right = '0';
  1579. 			p.sldM.style.top = '0';
  1580. 			p.sldM.style.width = (THIS.sliderSize + padToSliderPadding / 2 + THIS.padding + 2 * THIS.insetWidth) + 'px';
  1581. 			p.sldM.style.height = dims[1] + 'px';
  1582. 			p.sldM.style.cursor = 'default';
  1583.  
  1584. 			// slider pointer inner and outer border
  1585. 			p.sldPtrIB.style.border =
  1586. 			p.sldPtrOB.style.border =
  1587. 				THIS.pointerBorderWidth + 'px solid ' + THIS.pointerBorderColor;
  1588.  
  1589. 			// slider pointer outer border
  1590. 			p.sldPtrOB.style.position = 'absolute';
  1591. 			p.sldPtrOB.style.left = -(2 * THIS.pointerBorderWidth + THIS.pointerThickness) + 'px';
  1592. 			p.sldPtrOB.style.top = '0';
  1593.  
  1594. 			// slider pointer middle border
  1595. 			p.sldPtrMB.style.border = THIS.pointerThickness + 'px solid ' + THIS.pointerColor;
  1596.  
  1597. 			// slider pointer spacer
  1598. 			p.sldPtrS.style.width = THIS.sliderSize + 'px';
  1599. 			p.sldPtrS.style.height = sliderPtrSpace + 'px';
  1600.  
  1601. 			// the Close button
  1602. 			function setBtnBorder () {
  1603. 				var insetColors = THIS.insetColor.split(/\s+/);
  1604. 				var outsetColor = insetColors.length < 2 ? insetColors[0] : insetColors[1] + ' ' + insetColors[0] + ' ' + insetColors[0] + ' ' + insetColors[1];
  1605. 				p.btn.style.borderColor = outsetColor;
  1606. 			}
  1607. 			p.btn.style.display = THIS.closable ? 'block' : 'none';
  1608. 			p.btn.style.position = 'absolute';
  1609. 			p.btn.style.left = THIS.padding + 'px';
  1610. 			p.btn.style.bottom = THIS.padding + 'px';
  1611. 			p.btn.style.padding = '0 15px';
  1612. 			p.btn.style.height = THIS.buttonHeight + 'px';
  1613. 			p.btn.style.border = THIS.insetWidth + 'px solid';
  1614. 			setBtnBorder();
  1615. 			p.btn.style.color = THIS.buttonColor;
  1616. 			p.btn.style.font = '12px sans-serif';
  1617. 			p.btn.style.textAlign = 'center';
  1618. 			try {
  1619. 				p.btn.style.cursor = 'pointer';
  1620. 			} catch(eOldIE) {
  1621. 				p.btn.style.cursor = 'hand';
  1622. 			}
  1623. 			p.btn.onmousedown = function () {
  1624. 				THIS.hide();
  1625. 			};
  1626. 			p.btnT.style.lineHeight = THIS.buttonHeight + 'px';
  1627. 			p.btnT.innerHTML = '';
  1628. 			p.btnT.appendChild(document.createTextNode(THIS.closeText));
  1629.  
  1630. 			// place pointers
  1631. 			redrawPad();
  1632. 			redrawSld();
  1633.  
  1634. 			// If we are changing the owner without first closing the picker,
  1635. 			// make sure to first deal with the old owner
  1636. 			if (jsc.picker.owner && jsc.picker.owner !== THIS) {
  1637. 				jsc.unsetClass(jsc.picker.owner.targetElement, THIS.activeClass);
  1638. 			}
  1639.  
  1640. 			// Set the new picker owner
  1641. 			jsc.picker.owner = THIS;
  1642.  
  1643. 			// The redrawPosition() method needs picker.owner to be set, that's why we call it here,
  1644. 			// after setting the owner
  1645. 			if (jsc.isElementType(container, 'body')) {
  1646. 				jsc.redrawPosition();
  1647. 			} else {
  1648. 				jsc._drawPosition(THIS, 0, 0, 'relative', false);
  1649. 			}
  1650.  
  1651. 			if (p.wrap.parentNode != container) {
  1652. 				container.appendChild(p.wrap);
  1653. 			}
  1654.  
  1655. 			jsc.setClass(THIS.targetElement, THIS.activeClass);
  1656. 		}
  1657.  
  1658.  
  1659. 		function redrawPad () {
  1660. 			// redraw the pad pointer
  1661. 			switch (jsc.getPadYComponent(THIS)) {
  1662. 			case 's': var yComponent = 1; break;
  1663. 			case 'v': var yComponent = 2; break;
  1664. 			}
  1665. 			var x = Math.round((THIS.hsv[0] / 360) * (THIS.width - 1));
  1666. 			var y = Math.round((1 - THIS.hsv[yComponent] / 100) * (THIS.height - 1));
  1667. 			var crossOuterSize = (2 * THIS.pointerBorderWidth + THIS.pointerThickness + 2 * THIS.crossSize);
  1668. 			var ofs = -Math.floor(crossOuterSize / 2);
  1669. 			jsc.picker.cross.style.left = (x + ofs) + 'px';
  1670. 			jsc.picker.cross.style.top = (y + ofs) + 'px';
  1671.  
  1672. 			// redraw the slider
  1673. 			switch (jsc.getSliderComponent(THIS)) {
  1674. 			case 's':
  1675. 				var rgb1 = HSV_RGB(THIS.hsv[0], 100, THIS.hsv[2]);
  1676. 				var rgb2 = HSV_RGB(THIS.hsv[0], 0, THIS.hsv[2]);
  1677. 				var color1 = 'rgb(' +
  1678. 					Math.round(rgb1[0]) + ',' +
  1679. 					Math.round(rgb1[1]) + ',' +
  1680. 					Math.round(rgb1[2]) + ')';
  1681. 				var color2 = 'rgb(' +
  1682. 					Math.round(rgb2[0]) + ',' +
  1683. 					Math.round(rgb2[1]) + ',' +
  1684. 					Math.round(rgb2[2]) + ')';
  1685. 				jsc.picker.sldGrad.draw(THIS.sliderSize, THIS.height, color1, color2);
  1686. 				break;
  1687. 			case 'v':
  1688. 				var rgb = HSV_RGB(THIS.hsv[0], THIS.hsv[1], 100);
  1689. 				var color1 = 'rgb(' +
  1690. 					Math.round(rgb[0]) + ',' +
  1691. 					Math.round(rgb[1]) + ',' +
  1692. 					Math.round(rgb[2]) + ')';
  1693. 				var color2 = '#000';
  1694. 				jsc.picker.sldGrad.draw(THIS.sliderSize, THIS.height, color1, color2);
  1695. 				break;
  1696. 			}
  1697. 		}
  1698.  
  1699.  
  1700. 		function redrawSld () {
  1701. 			var sldComponent = jsc.getSliderComponent(THIS);
  1702. 			if (sldComponent) {
  1703. 				// redraw the slider pointer
  1704. 				switch (sldComponent) {
  1705. 				case 's': var yComponent = 1; break;
  1706. 				case 'v': var yComponent = 2; break;
  1707. 				}
  1708. 				var y = Math.round((1 - THIS.hsv[yComponent] / 100) * (THIS.height - 1));
  1709. 				jsc.picker.sldPtrOB.style.top = (y - (2 * THIS.pointerBorderWidth + THIS.pointerThickness) - Math.floor(sliderPtrSpace / 2)) + 'px';
  1710. 			}
  1711. 		}
  1712.  
  1713.  
  1714. 		function isPickerOwner () {
  1715. 			return jsc.picker && jsc.picker.owner === THIS;
  1716. 		}
  1717.  
  1718.  
  1719. 		function blurValue () {
  1720. 			THIS.importColor();
  1721. 		}
  1722.  
  1723.  
  1724. 		// Find the target element
  1725. 		if (typeof targetElement === 'string') {
  1726. 			var id = targetElement;
  1727. 			var elm = document.getElementById(id);
  1728. 			if (elm) {
  1729. 				this.targetElement = elm;
  1730. 			} else {
  1731. 				jsc.warn('Could not find target element with ID \'' + id + '\'');
  1732. 			}
  1733. 		} else if (targetElement) {
  1734. 			this.targetElement = targetElement;
  1735. 		} else {
  1736. 			jsc.warn('Invalid target element: \'' + targetElement + '\'');
  1737. 		}
  1738.  
  1739. 		if (this.targetElement._jscLinkedInstance) {
  1740. 			jsc.warn('Cannot link jscolor twice to the same element. Skipping.');
  1741. 			return;
  1742. 		}
  1743. 		this.targetElement._jscLinkedInstance = this;
  1744.  
  1745. 		// Find the value element
  1746. 		this.valueElement = jsc.fetchElement(this.valueElement);
  1747. 		// Find the style element
  1748. 		this.styleElement = jsc.fetchElement(this.styleElement);
  1749.  
  1750. 		var THIS = this;
  1751. 		var container =
  1752. 			this.container ?
  1753. 			jsc.fetchElement(this.container) :
  1754. 			document.getElementsByTagName('body')[0];
  1755. 		var sliderPtrSpace = 3; // px
  1756.  
  1757. 		// For BUTTON elements it's important to stop them from sending the form when clicked
  1758. 		// (e.g. in Safari)
  1759. 		if (jsc.isElementType(this.targetElement, 'button')) {
  1760. 			if (this.targetElement.onclick) {
  1761. 				var origCallback = this.targetElement.onclick;
  1762. 				this.targetElement.onclick = function (evt) {
  1763. 					origCallback.call(this, evt);
  1764. 					return false;
  1765. 				};
  1766. 			} else {
  1767. 				this.targetElement.onclick = function () { return false; };
  1768. 			}
  1769. 		}
  1770.  
  1771. 		/*
  1772. 		var elm = this.targetElement;
  1773. 		do {
  1774. 			// If the target element or one of its offsetParents has fixed position,
  1775. 			// then use fixed positioning instead
  1776. 			//
  1777. 			// Note: In Firefox, getComputedStyle returns null in a hidden iframe,
  1778. 			// that's why we need to check if the returned style object is non-empty
  1779. 			var currStyle = jsc.getStyle(elm);
  1780. 			if (currStyle && currStyle.position.toLowerCase() === 'fixed') {
  1781. 				this.fixed = true;
  1782. 			}
  1783.  
  1784. 			if (elm !== this.targetElement) {
  1785. 				// attach onParentScroll so that we can recompute the picker position
  1786. 				// when one of the offsetParents is scrolled
  1787. 				if (!elm._jscEventsAttached) {
  1788. 					jsc.attachEvent(elm, 'scroll', jsc.onParentScroll);
  1789. 					elm._jscEventsAttached = true;
  1790. 				}
  1791. 			}
  1792. 		} while ((elm = elm.offsetParent) && !jsc.isElementType(elm, 'body'));
  1793. 		*/
  1794.  
  1795. 		// valueElement
  1796. 		if (this.valueElement) {
  1797. 			if (jsc.isElementType(this.valueElement, 'input')) {
  1798. 				var updateField = function () {
  1799. 					THIS.fromString(THIS.valueElement.value, jsc.leaveValue);
  1800. 					jsc.dispatchFineChange(THIS);
  1801. 				};
  1802. 				jsc.attachEvent(this.valueElement, 'keyup', updateField);
  1803. 				jsc.attachEvent(this.valueElement, 'input', updateField);
  1804. 				jsc.attachEvent(this.valueElement, 'blur', blurValue);
  1805. 				this.valueElement.setAttribute('autocomplete', 'off');
  1806. 			}
  1807. 		}
  1808.  
  1809. 		// styleElement
  1810. 		if (this.styleElement) {
  1811. 			this.styleElement._jscOrigStyle = {
  1812. 				backgroundImage : this.styleElement.style.backgroundImage,
  1813. 				backgroundColor : this.styleElement.style.backgroundColor,
  1814. 				color : this.styleElement.style.color
  1815. 			};
  1816. 		}
  1817.  
  1818. 		if (this.value) {
  1819. 			// Try to set the color from the .value option and if unsuccessful,
  1820. 			// export the current color
  1821. 			this.fromString(this.value) || this.exportColor();
  1822. 		} else {
  1823. 			this.importColor();
  1824. 		}
  1825. 	}
  1826.  
  1827. };
  1828.  
  1829.  
  1830. //================================
  1831. // Public properties and methods
  1832. //================================
  1833.  
  1834.  
  1835. // By default, search for all elements with class="jscolor" and install a color picker on them.
  1836. //
  1837. // You can change what class name will be looked for by setting the property jscolor.lookupClass
  1838. // anywhere in your HTML document. To completely disable the automatic lookup, set it to null.
  1839. //
  1840. jsc.jscolor.lookupClass = 'jscolor';
  1841.  
  1842.  
  1843. jsc.jscolor.installByClassName = function (className) {
  1844. 	var inputElms = document.getElementsByTagName('input');
  1845. 	var buttonElms = document.getElementsByTagName('button');
  1846.  
  1847. 	jsc.tryInstallOnElements(inputElms, className);
  1848. 	jsc.tryInstallOnElements(buttonElms, className);
  1849. };
  1850.  
  1851.  
  1852. jsc.register();
  1853.  
  1854.  
  1855. return jsc.jscolor;
  1856.  
  1857.  
  1858. })(); }