Update
This commit is contained in:
Tony Garnock-Jones
parent
d477e3d7dd
commit
423145e1aa
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,26 @@
|
|||
<!doctype html>
|
||||
<html>
|
||||
<head>
|
||||
<title>Syndicate: Motion</title>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<link href="style.css" rel="stylesheet">
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/mustache.js/2.2.1/mustache.min.js"></script>
|
||||
<script src="tinycolor.js"></script>
|
||||
<script src="../../dist/syndicatecompiler.js"></script>
|
||||
<script src="../../dist/syndicate.js"></script>
|
||||
<script type="text/syndicate-js" src="index.js"></script>
|
||||
</head>
|
||||
<body>
|
||||
<svg width="100%" viewBox="-10 -10 20 20" id="container">
|
||||
<rect x="-10" y="-10" width="1" height="1" id="my_color"/>
|
||||
</svg>
|
||||
<template id="circle-template">
|
||||
<circle fill="{{ color }}" r="0.2" cx="{{ x }}" cy ="{{ y }}" />
|
||||
</template>
|
||||
</div>
|
||||
|
||||
<!-- <hr> -->
|
||||
<!-- <pre id="ds-state"></pre> -->
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
assertion type point(color, x, y);
|
||||
|
||||
var brokerConnection = Syndicate.Broker.brokerConnection;
|
||||
var toBroker = Syndicate.Broker.toBroker;
|
||||
var fromBroker = Syndicate.Broker.fromBroker;
|
||||
|
||||
ground dataspace G {
|
||||
Syndicate.UI.spawnUIDriver();
|
||||
Syndicate.Timer.spawnTimerDriver();
|
||||
Syndicate.Broker.spawnBrokerClientDriver();
|
||||
|
||||
actor {
|
||||
var ui = new Syndicate.UI.Anchor();
|
||||
var color = tinycolor('hsl ' + (Math.random() * 360 | 0) + ' 100% 50%').toHexString();
|
||||
var x = 0;
|
||||
var y = 0;
|
||||
var publishedX = x;
|
||||
var publishedY = y;
|
||||
|
||||
function clamp(v) {
|
||||
var limit = 9.8;
|
||||
return Math.max(Math.min(v, limit), -limit);
|
||||
}
|
||||
|
||||
var wsurl = 'ws://demo-broker.syndicate-lang.org:8000/';
|
||||
react {
|
||||
assert brokerConnection(wsurl);
|
||||
|
||||
assert Syndicate.UI.uiAttribute('rect#my_color', 'fill', color);
|
||||
|
||||
assert toBroker(wsurl, point(color, publishedX, publishedY));
|
||||
on message Syndicate.Timer.periodicTick(100) {
|
||||
publishedX = x;
|
||||
publishedY = y;
|
||||
}
|
||||
|
||||
on message Syndicate.UI.windowEvent('deviceorientation', $e) {
|
||||
var scale = 0.5;
|
||||
x = clamp(e.gamma * scale);
|
||||
y = clamp((e.beta - 40) * scale);
|
||||
}
|
||||
|
||||
during fromBroker(wsurl, point($oc, $ox, $oy)) {
|
||||
assert ui.context(oc)
|
||||
.html('#container',
|
||||
Mustache.render(document.getElementById('circle-template').innerHTML, {
|
||||
color: oc,
|
||||
x: ox,
|
||||
y: oy
|
||||
}));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// G.dataspace.setOnStateChange(function (mux, patch) {
|
||||
// document.getElementById("ds-state").innerText = Syndicate.prettyTrie(mux.routingTable);
|
||||
// });
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
template {
|
||||
display: none;
|
||||
}
|
||||
|
||||
svg {
|
||||
border: solid black 1px;
|
||||
}
|
||||
|
|
@ -0,0 +1,897 @@
|
|||
// TinyColor v0.9.14+
|
||||
// https://github.com/bgrins/TinyColor
|
||||
// 2013-02-24, Brian Grinstead, MIT License
|
||||
|
||||
(function(root) {
|
||||
|
||||
var trimLeft = /^[\s,#]+/,
|
||||
trimRight = /\s+$/,
|
||||
tinyCounter = 0,
|
||||
math = Math,
|
||||
mathRound = math.round,
|
||||
mathMin = math.min,
|
||||
mathMax = math.max,
|
||||
mathRandom = math.random;
|
||||
|
||||
function tinycolor (color, opts) {
|
||||
|
||||
color = (color) ? color : '';
|
||||
opts = opts || { };
|
||||
|
||||
// If input is already a tinycolor, return itself
|
||||
if (typeof color == "object" && color.hasOwnProperty("_tc_id")) {
|
||||
return color;
|
||||
}
|
||||
|
||||
var rgb = inputToRGB(color);
|
||||
var r = rgb.r,
|
||||
g = rgb.g,
|
||||
b = rgb.b,
|
||||
a = rgb.a,
|
||||
roundA = mathRound(100*a) / 100,
|
||||
format = opts.format || rgb.format;
|
||||
|
||||
// Don't let the range of [0,255] come back in [0,1].
|
||||
// Potentially lose a little bit of precision here, but will fix issues where
|
||||
// .5 gets interpreted as half of the total, instead of half of 1
|
||||
// If it was supposed to be 128, this was already taken care of by `inputToRgb`
|
||||
if (r < 1) { r = mathRound(r); }
|
||||
if (g < 1) { g = mathRound(g); }
|
||||
if (b < 1) { b = mathRound(b); }
|
||||
|
||||
return {
|
||||
ok: rgb.ok,
|
||||
format: format,
|
||||
_tc_id: tinyCounter++,
|
||||
alpha: a,
|
||||
toHsv: function() {
|
||||
var hsv = rgbToHsv(r, g, b);
|
||||
return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: a };
|
||||
},
|
||||
toHsvString: function() {
|
||||
var hsv = rgbToHsv(r, g, b);
|
||||
var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100);
|
||||
return (a == 1) ?
|
||||
"hsv(" + h + ", " + s + "%, " + v + "%)" :
|
||||
"hsva(" + h + ", " + s + "%, " + v + "%, "+ roundA + ")";
|
||||
},
|
||||
toHsl: function() {
|
||||
var hsl = rgbToHsl(r, g, b);
|
||||
return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: a };
|
||||
},
|
||||
toHslString: function() {
|
||||
var hsl = rgbToHsl(r, g, b);
|
||||
var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100);
|
||||
return (a == 1) ?
|
||||
"hsl(" + h + ", " + s + "%, " + l + "%)" :
|
||||
"hsla(" + h + ", " + s + "%, " + l + "%, "+ roundA + ")";
|
||||
},
|
||||
toHex: function(allow3Char) {
|
||||
return rgbToHex(r, g, b, allow3Char);
|
||||
},
|
||||
toHexString: function(allow3Char) {
|
||||
return '#' + rgbToHex(r, g, b, allow3Char);
|
||||
},
|
||||
toRgb: function() {
|
||||
return { r: mathRound(r), g: mathRound(g), b: mathRound(b), a: a };
|
||||
},
|
||||
toRgbString: function() {
|
||||
return (a == 1) ?
|
||||
"rgb(" + mathRound(r) + ", " + mathRound(g) + ", " + mathRound(b) + ")" :
|
||||
"rgba(" + mathRound(r) + ", " + mathRound(g) + ", " + mathRound(b) + ", " + roundA + ")";
|
||||
},
|
||||
toPercentageRgb: function() {
|
||||
return { r: mathRound(bound01(r, 255) * 100) + "%", g: mathRound(bound01(g, 255) * 100) + "%", b: mathRound(bound01(b, 255) * 100) + "%", a: a };
|
||||
},
|
||||
toPercentageRgbString: function() {
|
||||
return (a == 1) ?
|
||||
"rgb(" + mathRound(bound01(r, 255) * 100) + "%, " + mathRound(bound01(g, 255) * 100) + "%, " + mathRound(bound01(b, 255) * 100) + "%)" :
|
||||
"rgba(" + mathRound(bound01(r, 255) * 100) + "%, " + mathRound(bound01(g, 255) * 100) + "%, " + mathRound(bound01(b, 255) * 100) + "%, " + roundA + ")";
|
||||
},
|
||||
toName: function() {
|
||||
if (a === 0) {
|
||||
return "transparent";
|
||||
}
|
||||
|
||||
return hexNames[rgbToHex(r, g, b, true)] || false;
|
||||
},
|
||||
toFilter: function(secondColor) {
|
||||
var hex = rgbToHex(r, g, b);
|
||||
var secondHex = hex;
|
||||
var alphaHex = Math.round(parseFloat(a) * 255).toString(16);
|
||||
var secondAlphaHex = alphaHex;
|
||||
var gradientType = opts && opts.gradientType ? "GradientType = 1, " : "";
|
||||
|
||||
if (secondColor) {
|
||||
var s = tinycolor(secondColor);
|
||||
secondHex = s.toHex();
|
||||
secondAlphaHex = Math.round(parseFloat(s.alpha) * 255).toString(16);
|
||||
}
|
||||
|
||||
return "progid:DXImageTransform.Microsoft.gradient("+gradientType+"startColorstr=#" + pad2(alphaHex) + hex + ",endColorstr=#" + pad2(secondAlphaHex) + secondHex + ")";
|
||||
},
|
||||
toString: function(format) {
|
||||
format = format || this.format;
|
||||
var formattedString = false;
|
||||
if (format === "rgb") {
|
||||
formattedString = this.toRgbString();
|
||||
}
|
||||
if (format === "prgb") {
|
||||
formattedString = this.toPercentageRgbString();
|
||||
}
|
||||
if (format === "hex" || format === "hex6") {
|
||||
formattedString = this.toHexString();
|
||||
}
|
||||
if (format === "hex3") {
|
||||
formattedString = this.toHexString(true);
|
||||
}
|
||||
if (format === "name") {
|
||||
formattedString = this.toName();
|
||||
}
|
||||
if (format === "hsl") {
|
||||
formattedString = this.toHslString();
|
||||
}
|
||||
if (format === "hsv") {
|
||||
formattedString = this.toHsvString();
|
||||
}
|
||||
|
||||
return formattedString || this.toHexString();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// If input is an object, force 1 into "1.0" to handle ratios properly
|
||||
// String input requires "1.0" as input, so 1 will be treated as 1
|
||||
tinycolor.fromRatio = function(color, opts) {
|
||||
if (typeof color == "object") {
|
||||
var newColor = {};
|
||||
for (var i in color) {
|
||||
if (color.hasOwnProperty(i)) {
|
||||
if (i === "a") {
|
||||
newColor[i] = color[i];
|
||||
}
|
||||
else {
|
||||
newColor[i] = convertToPercentage(color[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
color = newColor;
|
||||
}
|
||||
|
||||
return tinycolor(color, opts);
|
||||
};
|
||||
|
||||
// Given a string or object, convert that input to RGB
|
||||
// Possible string inputs:
|
||||
//
|
||||
// "red"
|
||||
// "#f00" or "f00"
|
||||
// "#ff0000" or "ff0000"
|
||||
// "rgb 255 0 0" or "rgb (255, 0, 0)"
|
||||
// "rgb 1.0 0 0" or "rgb (1, 0, 0)"
|
||||
// "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
|
||||
// "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
|
||||
// "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
|
||||
// "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
|
||||
// "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
|
||||
//
|
||||
function inputToRGB(color) {
|
||||
|
||||
var rgb = { r: 0, g: 0, b: 0 };
|
||||
var a = 1;
|
||||
var ok = false;
|
||||
var format = false;
|
||||
|
||||
if (typeof color == "string") {
|
||||
color = stringInputToObject(color);
|
||||
}
|
||||
|
||||
if (typeof color == "object") {
|
||||
if (color.hasOwnProperty("r") && color.hasOwnProperty("g") && color.hasOwnProperty("b")) {
|
||||
rgb = rgbToRgb(color.r, color.g, color.b);
|
||||
ok = true;
|
||||
format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
|
||||
}
|
||||
else if (color.hasOwnProperty("h") && color.hasOwnProperty("s") && color.hasOwnProperty("v")) {
|
||||
color.s = convertToPercentage(color.s);
|
||||
color.v = convertToPercentage(color.v);
|
||||
rgb = hsvToRgb(color.h, color.s, color.v);
|
||||
ok = true;
|
||||
format = "hsv";
|
||||
}
|
||||
else if (color.hasOwnProperty("h") && color.hasOwnProperty("s") && color.hasOwnProperty("l")) {
|
||||
color.s = convertToPercentage(color.s);
|
||||
color.l = convertToPercentage(color.l);
|
||||
rgb = hslToRgb(color.h, color.s, color.l);
|
||||
ok = true;
|
||||
format = "hsl";
|
||||
}
|
||||
|
||||
if (color.hasOwnProperty("a")) {
|
||||
a = color.a;
|
||||
}
|
||||
}
|
||||
|
||||
a = parseFloat(a);
|
||||
|
||||
// Handle invalid alpha characters by setting to 1
|
||||
if (isNaN(a) || a < 0 || a > 1) {
|
||||
a = 1;
|
||||
}
|
||||
|
||||
return {
|
||||
ok: ok,
|
||||
format: color.format || format,
|
||||
r: mathMin(255, mathMax(rgb.r, 0)),
|
||||
g: mathMin(255, mathMax(rgb.g, 0)),
|
||||
b: mathMin(255, mathMax(rgb.b, 0)),
|
||||
a: a
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Conversion Functions
|
||||
// --------------------
|
||||
|
||||
// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:
|
||||
// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>
|
||||
|
||||
// `rgbToRgb`
|
||||
// Handle bounds / percentage checking to conform to CSS color spec
|
||||
// <http://www.w3.org/TR/css3-color/>
|
||||
// *Assumes:* r, g, b in [0, 255] or [0, 1]
|
||||
// *Returns:* { r, g, b } in [0, 255]
|
||||
function rgbToRgb(r, g, b){
|
||||
return {
|
||||
r: bound01(r, 255) * 255,
|
||||
g: bound01(g, 255) * 255,
|
||||
b: bound01(b, 255) * 255
|
||||
};
|
||||
}
|
||||
|
||||
// `rgbToHsl`
|
||||
// Converts an RGB color value to HSL.
|
||||
// *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
|
||||
// *Returns:* { h, s, l } in [0,1]
|
||||
function rgbToHsl(r, g, b) {
|
||||
|
||||
r = bound01(r, 255);
|
||||
g = bound01(g, 255);
|
||||
b = bound01(b, 255);
|
||||
|
||||
var max = mathMax(r, g, b), min = mathMin(r, g, b);
|
||||
var h, s, l = (max + min) / 2;
|
||||
|
||||
if(max == min) {
|
||||
h = s = 0; // achromatic
|
||||
}
|
||||
else {
|
||||
var d = max - min;
|
||||
s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
|
||||
switch(max) {
|
||||
case r: h = (g - b) / d + (g < b ? 6 : 0); break;
|
||||
case g: h = (b - r) / d + 2; break;
|
||||
case b: h = (r - g) / d + 4; break;
|
||||
}
|
||||
|
||||
h /= 6;
|
||||
}
|
||||
|
||||
return { h: h, s: s, l: l };
|
||||
}
|
||||
|
||||
// `hslToRgb`
|
||||
// Converts an HSL color value to RGB.
|
||||
// *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
|
||||
// *Returns:* { r, g, b } in the set [0, 255]
|
||||
function hslToRgb(h, s, l) {
|
||||
var r, g, b;
|
||||
|
||||
h = bound01(h, 360);
|
||||
s = bound01(s, 100);
|
||||
l = bound01(l, 100);
|
||||
|
||||
function hue2rgb(p, q, t) {
|
||||
if(t < 0) t += 1;
|
||||
if(t > 1) t -= 1;
|
||||
if(t < 1/6) return p + (q - p) * 6 * t;
|
||||
if(t < 1/2) return q;
|
||||
if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;
|
||||
return p;
|
||||
}
|
||||
|
||||
if(s === 0) {
|
||||
r = g = b = l; // achromatic
|
||||
}
|
||||
else {
|
||||
var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
|
||||
var p = 2 * l - q;
|
||||
r = hue2rgb(p, q, h + 1/3);
|
||||
g = hue2rgb(p, q, h);
|
||||
b = hue2rgb(p, q, h - 1/3);
|
||||
}
|
||||
|
||||
return { r: r * 255, g: g * 255, b: b * 255 };
|
||||
}
|
||||
|
||||
// `rgbToHsv`
|
||||
// Converts an RGB color value to HSV
|
||||
// *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
|
||||
// *Returns:* { h, s, v } in [0,1]
|
||||
function rgbToHsv(r, g, b) {
|
||||
|
||||
r = bound01(r, 255);
|
||||
g = bound01(g, 255);
|
||||
b = bound01(b, 255);
|
||||
|
||||
var max = mathMax(r, g, b), min = mathMin(r, g, b);
|
||||
var h, s, v = max;
|
||||
|
||||
var d = max - min;
|
||||
s = max === 0 ? 0 : d / max;
|
||||
|
||||
if(max == min) {
|
||||
h = 0; // achromatic
|
||||
}
|
||||
else {
|
||||
switch(max) {
|
||||
case r: h = (g - b) / d + (g < b ? 6 : 0); break;
|
||||
case g: h = (b - r) / d + 2; break;
|
||||
case b: h = (r - g) / d + 4; break;
|
||||
}
|
||||
h /= 6;
|
||||
}
|
||||
return { h: h, s: s, v: v };
|
||||
}
|
||||
|
||||
// `hsvToRgb`
|
||||
// Converts an HSV color value to RGB.
|
||||
// *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
|
||||
// *Returns:* { r, g, b } in the set [0, 255]
|
||||
function hsvToRgb(h, s, v) {
|
||||
|
||||
h = bound01(h, 360) * 6;
|
||||
s = bound01(s, 100);
|
||||
v = bound01(v, 100);
|
||||
|
||||
var i = math.floor(h),
|
||||
f = h - i,
|
||||
p = v * (1 - s),
|
||||
q = v * (1 - f * s),
|
||||
t = v * (1 - (1 - f) * s),
|
||||
mod = i % 6,
|
||||
r = [v, q, p, p, t, v][mod],
|
||||
g = [t, v, v, q, p, p][mod],
|
||||
b = [p, p, t, v, v, q][mod];
|
||||
|
||||
return { r: r * 255, g: g * 255, b: b * 255 };
|
||||
}
|
||||
|
||||
// `rgbToHex`
|
||||
// Converts an RGB color to hex
|
||||
// Assumes r, g, and b are contained in the set [0, 255]
|
||||
// Returns a 3 or 6 character hex
|
||||
function rgbToHex(r, g, b, allow3Char) {
|
||||
|
||||
var hex = [
|
||||
pad2(mathRound(r).toString(16)),
|
||||
pad2(mathRound(g).toString(16)),
|
||||
pad2(mathRound(b).toString(16))
|
||||
];
|
||||
|
||||
// Return a 3 character hex if possible
|
||||
if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {
|
||||
return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
|
||||
}
|
||||
|
||||
return hex.join("");
|
||||
}
|
||||
|
||||
// `equals`
|
||||
// Can be called with any tinycolor input
|
||||
tinycolor.equals = function (color1, color2) {
|
||||
if (!color1 || !color2) { return false; }
|
||||
return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();
|
||||
};
|
||||
tinycolor.random = function() {
|
||||
return tinycolor.fromRatio({
|
||||
r: mathRandom(),
|
||||
g: mathRandom(),
|
||||
b: mathRandom()
|
||||
});
|
||||
};
|
||||
|
||||
|
||||
// Modification Functions
|
||||
// ----------------------
|
||||
// Thanks to less.js for some of the basics here
|
||||
// <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>
|
||||
|
||||
|
||||
tinycolor.desaturate = function (color, amount) {
|
||||
var hsl = tinycolor(color).toHsl();
|
||||
hsl.s -= ((amount || 10) / 100);
|
||||
hsl.s = clamp01(hsl.s);
|
||||
return tinycolor(hsl);
|
||||
};
|
||||
tinycolor.saturate = function (color, amount) {
|
||||
var hsl = tinycolor(color).toHsl();
|
||||
hsl.s += ((amount || 10) / 100);
|
||||
hsl.s = clamp01(hsl.s);
|
||||
return tinycolor(hsl);
|
||||
};
|
||||
tinycolor.greyscale = function(color) {
|
||||
return tinycolor.desaturate(color, 100);
|
||||
};
|
||||
tinycolor.lighten = function(color, amount) {
|
||||
var hsl = tinycolor(color).toHsl();
|
||||
hsl.l += ((amount || 10) / 100);
|
||||
hsl.l = clamp01(hsl.l);
|
||||
return tinycolor(hsl);
|
||||
};
|
||||
tinycolor.darken = function (color, amount) {
|
||||
var hsl = tinycolor(color).toHsl();
|
||||
hsl.l -= ((amount || 10) / 100);
|
||||
hsl.l = clamp01(hsl.l);
|
||||
return tinycolor(hsl);
|
||||
};
|
||||
tinycolor.complement = function(color) {
|
||||
var hsl = tinycolor(color).toHsl();
|
||||
hsl.h = (hsl.h + 180) % 360;
|
||||
return tinycolor(hsl);
|
||||
};
|
||||
|
||||
|
||||
// Combination Functions
|
||||
// ---------------------
|
||||
// Thanks to jQuery xColor for some of the ideas behind these
|
||||
// <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>
|
||||
|
||||
tinycolor.triad = function(color) {
|
||||
var hsl = tinycolor(color).toHsl();
|
||||
var h = hsl.h;
|
||||
return [
|
||||
tinycolor(color),
|
||||
tinycolor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }),
|
||||
tinycolor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l })
|
||||
];
|
||||
};
|
||||
tinycolor.tetrad = function(color) {
|
||||
var hsl = tinycolor(color).toHsl();
|
||||
var h = hsl.h;
|
||||
return [
|
||||
tinycolor(color),
|
||||
tinycolor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }),
|
||||
tinycolor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }),
|
||||
tinycolor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l })
|
||||
];
|
||||
};
|
||||
tinycolor.splitcomplement = function(color) {
|
||||
var hsl = tinycolor(color).toHsl();
|
||||
var h = hsl.h;
|
||||
return [
|
||||
tinycolor(color),
|
||||
tinycolor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l}),
|
||||
tinycolor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l})
|
||||
];
|
||||
};
|
||||
tinycolor.analogous = function(color, results, slices) {
|
||||
results = results || 6;
|
||||
slices = slices || 30;
|
||||
|
||||
var hsl = tinycolor(color).toHsl();
|
||||
var part = 360 / slices;
|
||||
var ret = [tinycolor(color)];
|
||||
|
||||
for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) {
|
||||
hsl.h = (hsl.h + part) % 360;
|
||||
ret.push(tinycolor(hsl));
|
||||
}
|
||||
return ret;
|
||||
};
|
||||
tinycolor.monochromatic = function(color, results) {
|
||||
results = results || 6;
|
||||
var hsv = tinycolor(color).toHsv();
|
||||
var h = hsv.h, s = hsv.s, v = hsv.v;
|
||||
var ret = [];
|
||||
var modification = 1 / results;
|
||||
|
||||
while (results--) {
|
||||
ret.push(tinycolor({ h: h, s: s, v: v}));
|
||||
v = (v + modification) % 1;
|
||||
}
|
||||
|
||||
return ret;
|
||||
};
|
||||
|
||||
// Readability Functions
|
||||
// ---------------------
|
||||
// <http://www.w3.org/TR/AERT#color-contrast>
|
||||
|
||||
// `readability`
|
||||
// Analyze the 2 colors and returns an object with the following properties:
|
||||
// `brightness`: difference in brightness between the two colors
|
||||
// `color`: difference in color/hue between the two colors
|
||||
tinycolor.readability = function(color1, color2) {
|
||||
var a = tinycolor(color1).toRgb();
|
||||
var b = tinycolor(color2).toRgb();
|
||||
var brightnessA = (a.r * 299 + a.g * 587 + a.b * 114) / 1000;
|
||||
var brightnessB = (b.r * 299 + b.g * 587 + b.b * 114) / 1000;
|
||||
var colorDiff = (
|
||||
Math.max(a.r, b.r) - Math.min(a.r, b.r) +
|
||||
Math.max(a.g, b.g) - Math.min(a.g, b.g) +
|
||||
Math.max(a.b, b.b) - Math.min(a.b, b.b)
|
||||
);
|
||||
|
||||
return {
|
||||
brightness: Math.abs(brightnessA - brightnessB),
|
||||
color: colorDiff
|
||||
};
|
||||
};
|
||||
|
||||
// `readable`
|
||||
// http://www.w3.org/TR/AERT#color-contrast
|
||||
// Ensure that foreground and background color combinations provide sufficient contrast.
|
||||
// *Example*
|
||||
// tinycolor.readable("#000", "#111") => false
|
||||
tinycolor.readable = function(color1, color2) {
|
||||
var readability = tinycolor.readability(color1, color2);
|
||||
return readability.brightness > 125 && readability.color > 500;
|
||||
};
|
||||
|
||||
// `mostReadable`
|
||||
// Given a base color and a list of possible foreground or background
|
||||
// colors for that base, returns the most readable color.
|
||||
// *Example*
|
||||
// tinycolor.mostReadable("#123", ["#fff", "#000"]) => "#000"
|
||||
tinycolor.mostReadable = function(baseColor, colorList) {
|
||||
var bestColor = null;
|
||||
var bestScore = 0;
|
||||
var bestIsReadable = false;
|
||||
for (var i=0; i < colorList.length; i++) {
|
||||
|
||||
// We normalize both around the "acceptable" breaking point,
|
||||
// but rank brightness constrast higher than hue.
|
||||
|
||||
var readability = tinycolor.readability(baseColor, colorList[i]);
|
||||
var readable = readability.brightness > 125 && readability.color > 500;
|
||||
var score = 3 * (readability.brightness / 125) + (readability.color / 500);
|
||||
|
||||
if ((readable && ! bestIsReadable) ||
|
||||
(readable && bestIsReadable && score > bestScore) ||
|
||||
((! readable) && (! bestIsReadable) && score > bestScore)) {
|
||||
bestIsReadable = readable;
|
||||
bestScore = score;
|
||||
bestColor = tinycolor(colorList[i]);
|
||||
}
|
||||
}
|
||||
return bestColor;
|
||||
};
|
||||
|
||||
|
||||
// Big List of Colors
|
||||
// ------------------
|
||||
// <http://www.w3.org/TR/css3-color/#svg-color>
|
||||
var names = tinycolor.names = {
|
||||
aliceblue: "f0f8ff",
|
||||
antiquewhite: "faebd7",
|
||||
aqua: "0ff",
|
||||
aquamarine: "7fffd4",
|
||||
azure: "f0ffff",
|
||||
beige: "f5f5dc",
|
||||
bisque: "ffe4c4",
|
||||
black: "000",
|
||||
blanchedalmond: "ffebcd",
|
||||
blue: "00f",
|
||||
blueviolet: "8a2be2",
|
||||
brown: "a52a2a",
|
||||
burlywood: "deb887",
|
||||
burntsienna: "ea7e5d",
|
||||
cadetblue: "5f9ea0",
|
||||
chartreuse: "7fff00",
|
||||
chocolate: "d2691e",
|
||||
coral: "ff7f50",
|
||||
cornflowerblue: "6495ed",
|
||||
cornsilk: "fff8dc",
|
||||
crimson: "dc143c",
|
||||
cyan: "0ff",
|
||||
darkblue: "00008b",
|
||||
darkcyan: "008b8b",
|
||||
darkgoldenrod: "b8860b",
|
||||
darkgray: "a9a9a9",
|
||||
darkgreen: "006400",
|
||||
darkgrey: "a9a9a9",
|
||||
darkkhaki: "bdb76b",
|
||||
darkmagenta: "8b008b",
|
||||
darkolivegreen: "556b2f",
|
||||
darkorange: "ff8c00",
|
||||
darkorchid: "9932cc",
|
||||
darkred: "8b0000",
|
||||
darksalmon: "e9967a",
|
||||
darkseagreen: "8fbc8f",
|
||||
darkslateblue: "483d8b",
|
||||
darkslategray: "2f4f4f",
|
||||
darkslategrey: "2f4f4f",
|
||||
darkturquoise: "00ced1",
|
||||
darkviolet: "9400d3",
|
||||
deeppink: "ff1493",
|
||||
deepskyblue: "00bfff",
|
||||
dimgray: "696969",
|
||||
dimgrey: "696969",
|
||||
dodgerblue: "1e90ff",
|
||||
firebrick: "b22222",
|
||||
floralwhite: "fffaf0",
|
||||
forestgreen: "228b22",
|
||||
fuchsia: "f0f",
|
||||
gainsboro: "dcdcdc",
|
||||
ghostwhite: "f8f8ff",
|
||||
gold: "ffd700",
|
||||
goldenrod: "daa520",
|
||||
gray: "808080",
|
||||
green: "008000",
|
||||
greenyellow: "adff2f",
|
||||
grey: "808080",
|
||||
honeydew: "f0fff0",
|
||||
hotpink: "ff69b4",
|
||||
indianred: "cd5c5c",
|
||||
indigo: "4b0082",
|
||||
ivory: "fffff0",
|
||||
khaki: "f0e68c",
|
||||
lavender: "e6e6fa",
|
||||
lavenderblush: "fff0f5",
|
||||
lawngreen: "7cfc00",
|
||||
lemonchiffon: "fffacd",
|
||||
lightblue: "add8e6",
|
||||
lightcoral: "f08080",
|
||||
lightcyan: "e0ffff",
|
||||
lightgoldenrodyellow: "fafad2",
|
||||
lightgray: "d3d3d3",
|
||||
lightgreen: "90ee90",
|
||||
lightgrey: "d3d3d3",
|
||||
lightpink: "ffb6c1",
|
||||
lightsalmon: "ffa07a",
|
||||
lightseagreen: "20b2aa",
|
||||
lightskyblue: "87cefa",
|
||||
lightslategray: "789",
|
||||
lightslategrey: "789",
|
||||
lightsteelblue: "b0c4de",
|
||||
lightyellow: "ffffe0",
|
||||
lime: "0f0",
|
||||
limegreen: "32cd32",
|
||||
linen: "faf0e6",
|
||||
magenta: "f0f",
|
||||
maroon: "800000",
|
||||
mediumaquamarine: "66cdaa",
|
||||
mediumblue: "0000cd",
|
||||
mediumorchid: "ba55d3",
|
||||
mediumpurple: "9370db",
|
||||
mediumseagreen: "3cb371",
|
||||
mediumslateblue: "7b68ee",
|
||||
mediumspringgreen: "00fa9a",
|
||||
mediumturquoise: "48d1cc",
|
||||
mediumvioletred: "c71585",
|
||||
midnightblue: "191970",
|
||||
mintcream: "f5fffa",
|
||||
mistyrose: "ffe4e1",
|
||||
moccasin: "ffe4b5",
|
||||
navajowhite: "ffdead",
|
||||
navy: "000080",
|
||||
oldlace: "fdf5e6",
|
||||
olive: "808000",
|
||||
olivedrab: "6b8e23",
|
||||
orange: "ffa500",
|
||||
orangered: "ff4500",
|
||||
orchid: "da70d6",
|
||||
palegoldenrod: "eee8aa",
|
||||
palegreen: "98fb98",
|
||||
paleturquoise: "afeeee",
|
||||
palevioletred: "db7093",
|
||||
papayawhip: "ffefd5",
|
||||
peachpuff: "ffdab9",
|
||||
peru: "cd853f",
|
||||
pink: "ffc0cb",
|
||||
plum: "dda0dd",
|
||||
powderblue: "b0e0e6",
|
||||
purple: "800080",
|
||||
red: "f00",
|
||||
rosybrown: "bc8f8f",
|
||||
royalblue: "4169e1",
|
||||
saddlebrown: "8b4513",
|
||||
salmon: "fa8072",
|
||||
sandybrown: "f4a460",
|
||||
seagreen: "2e8b57",
|
||||
seashell: "fff5ee",
|
||||
sienna: "a0522d",
|
||||
silver: "c0c0c0",
|
||||
skyblue: "87ceeb",
|
||||
slateblue: "6a5acd",
|
||||
slategray: "708090",
|
||||
slategrey: "708090",
|
||||
snow: "fffafa",
|
||||
springgreen: "00ff7f",
|
||||
steelblue: "4682b4",
|
||||
tan: "d2b48c",
|
||||
teal: "008080",
|
||||
thistle: "d8bfd8",
|
||||
tomato: "ff6347",
|
||||
turquoise: "40e0d0",
|
||||
violet: "ee82ee",
|
||||
wheat: "f5deb3",
|
||||
white: "fff",
|
||||
whitesmoke: "f5f5f5",
|
||||
yellow: "ff0",
|
||||
yellowgreen: "9acd32"
|
||||
};
|
||||
|
||||
// Make it easy to access colors via `hexNames[hex]`
|
||||
var hexNames = tinycolor.hexNames = flip(names);
|
||||
|
||||
|
||||
// Utilities
|
||||
// ---------
|
||||
|
||||
// `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`
|
||||
function flip(o) {
|
||||
var flipped = { };
|
||||
for (var i in o) {
|
||||
if (o.hasOwnProperty(i)) {
|
||||
flipped[o[i]] = i;
|
||||
}
|
||||
}
|
||||
return flipped;
|
||||
}
|
||||
|
||||
// Take input from [0, n] and return it as [0, 1]
|
||||
function bound01(n, max) {
|
||||
if (isOnePointZero(n)) { n = "100%"; }
|
||||
|
||||
var processPercent = isPercentage(n);
|
||||
n = mathMin(max, mathMax(0, parseFloat(n)));
|
||||
|
||||
// Automatically convert percentage into number
|
||||
if (processPercent) {
|
||||
n = parseInt(n * max, 10) / 100;
|
||||
}
|
||||
|
||||
// Handle floating point rounding errors
|
||||
if ((math.abs(n - max) < 0.000001)) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Convert into [0, 1] range if it isn't already
|
||||
return (n % max) / parseFloat(max);
|
||||
}
|
||||
|
||||
// Force a number between 0 and 1
|
||||
function clamp01(val) {
|
||||
return mathMin(1, mathMax(0, val));
|
||||
}
|
||||
|
||||
// Parse an integer into hex
|
||||
function parseHex(val) {
|
||||
return parseInt(val, 16);
|
||||
}
|
||||
|
||||
// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
|
||||
// <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
|
||||
function isOnePointZero(n) {
|
||||
return typeof n == "string" && n.indexOf('.') != -1 && parseFloat(n) === 1;
|
||||
}
|
||||
|
||||
// Check to see if string passed in is a percentage
|
||||
function isPercentage(n) {
|
||||
return typeof n === "string" && n.indexOf('%') != -1;
|
||||
}
|
||||
|
||||
// Force a hex value to have 2 characters
|
||||
function pad2(c) {
|
||||
return c.length == 1 ? '0' + c : '' + c;
|
||||
}
|
||||
|
||||
// Replace a decimal with it's percentage value
|
||||
function convertToPercentage(n) {
|
||||
if (n <= 1) {
|
||||
n = (n * 100) + "%";
|
||||
}
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
var matchers = (function() {
|
||||
|
||||
// <http://www.w3.org/TR/css3-values/#integers>
|
||||
var CSS_INTEGER = "[-\\+]?\\d+%?";
|
||||
|
||||
// <http://www.w3.org/TR/css3-values/#number-value>
|
||||
var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
|
||||
|
||||
// Allow positive/negative integer/number. Don't capture the either/or, just the entire outcome.
|
||||
var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
|
||||
|
||||
// Actual matching.
|
||||
// Parentheses and commas are optional, but not required.
|
||||
// Whitespace can take the place of commas or opening paren
|
||||
var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
|
||||
var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
|
||||
|
||||
return {
|
||||
rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
|
||||
rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
|
||||
hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
|
||||
hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
|
||||
hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
|
||||
hex3: /^([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
|
||||
hex6: /^([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
|
||||
};
|
||||
})();
|
||||
|
||||
// `stringInputToObject`
|
||||
// Permissive string parsing. Take in a number of formats, and output an object
|
||||
// based on detected format. Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
|
||||
function stringInputToObject(color) {
|
||||
|
||||
color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase();
|
||||
var named = false;
|
||||
if (names[color]) {
|
||||
color = names[color];
|
||||
named = true;
|
||||
}
|
||||
else if (color == 'transparent') {
|
||||
return { r: 0, g: 0, b: 0, a: 0, format: "name" };
|
||||
}
|
||||
|
||||
// Try to match string input using regular expressions.
|
||||
// Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
|
||||
// Just return an object and let the conversion functions handle that.
|
||||
// This way the result will be the same whether the tinycolor is initialized with string or object.
|
||||
var match;
|
||||
if ((match = matchers.rgb.exec(color))) {
|
||||
return { r: match[1], g: match[2], b: match[3] };
|
||||
}
|
||||
if ((match = matchers.rgba.exec(color))) {
|
||||
return { r: match[1], g: match[2], b: match[3], a: match[4] };
|
||||
}
|
||||
if ((match = matchers.hsl.exec(color))) {
|
||||
return { h: match[1], s: match[2], l: match[3] };
|
||||
}
|
||||
if ((match = matchers.hsla.exec(color))) {
|
||||
return { h: match[1], s: match[2], l: match[3], a: match[4] };
|
||||
}
|
||||
if ((match = matchers.hsv.exec(color))) {
|
||||
return { h: match[1], s: match[2], v: match[3] };
|
||||
}
|
||||
if ((match = matchers.hex6.exec(color))) {
|
||||
return {
|
||||
r: parseHex(match[1]),
|
||||
g: parseHex(match[2]),
|
||||
b: parseHex(match[3]),
|
||||
format: named ? "name" : "hex"
|
||||
};
|
||||
}
|
||||
if ((match = matchers.hex3.exec(color))) {
|
||||
return {
|
||||
r: parseHex(match[1] + '' + match[1]),
|
||||
g: parseHex(match[2] + '' + match[2]),
|
||||
b: parseHex(match[3] + '' + match[3]),
|
||||
format: named ? "name" : "hex"
|
||||
};
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// Node: Export function
|
||||
if (typeof module !== "undefined" && module.exports) {
|
||||
module.exports = tinycolor;
|
||||
}
|
||||
// AMD/requirejs: Define the module
|
||||
else if (typeof define !== "undefined") {
|
||||
define(function () {return tinycolor;});
|
||||
}
|
||||
// Browser: Expose to window
|
||||
else {
|
||||
root.tinycolor = tinycolor;
|
||||
}
|
||||
|
||||
})(this);
|
||||
Loading…
Reference in New Issue