code
stringlengths 2
1.05M
|
|---|
/**
xxHash64 implementation in pure Javascript
Copyright (C) 2016, Pierre Curto
MIT license
*/
var UINT64 = require('cuint').UINT64
/*
* Constants
*/
var PRIME64_1 = UINT64( '11400714785074694791' )
var PRIME64_2 = UINT64( '14029467366897019727' )
var PRIME64_3 = UINT64( '1609587929392839161' )
var PRIME64_4 = UINT64( '9650029242287828579' )
var PRIME64_5 = UINT64( '2870177450012600261' )
/**
* Convert string to proper UTF-8 array
* @param str Input string
* @returns {Uint8Array} UTF8 array is returned as uint8 array
*/
function toUTF8Array (str) {
var utf8 = []
for (var i=0, n=str.length; i < n; i++) {
var charcode = str.charCodeAt(i)
if (charcode < 0x80) utf8.push(charcode)
else if (charcode < 0x800) {
utf8.push(0xc0 | (charcode >> 6),
0x80 | (charcode & 0x3f))
}
else if (charcode < 0xd800 || charcode >= 0xe000) {
utf8.push(0xe0 | (charcode >> 12),
0x80 | ((charcode>>6) & 0x3f),
0x80 | (charcode & 0x3f))
}
// surrogate pair
else {
i++;
// UTF-16 encodes 0x10000-0x10FFFF by
// subtracting 0x10000 and splitting the
// 20 bits of 0x0-0xFFFFF into two halves
charcode = 0x10000 + (((charcode & 0x3ff)<<10)
| (str.charCodeAt(i) & 0x3ff))
utf8.push(0xf0 | (charcode >>18),
0x80 | ((charcode>>12) & 0x3f),
0x80 | ((charcode>>6) & 0x3f),
0x80 | (charcode & 0x3f))
}
}
return new Uint8Array(utf8)
}
/**
* XXH64 object used as a constructor or a function
* @constructor
* or
* @param {Object|String} input data
* @param {Number|UINT64} seed
* @return ThisExpression
* or
* @return {UINT64} xxHash
*/
function XXH64 () {
if (arguments.length == 2)
return new XXH64( arguments[1] ).update( arguments[0] ).digest()
if (!(this instanceof XXH64))
return new XXH64( arguments[0] )
init.call(this, arguments[0])
}
/**
* Initialize the XXH64 instance with the given seed
* @method init
* @param {Number|Object} seed as a number or an unsigned 32 bits integer
* @return ThisExpression
*/
function init (seed) {
this.seed = seed instanceof UINT64 ? seed.clone() : UINT64(seed)
this.v1 = this.seed.clone().add(PRIME64_1).add(PRIME64_2)
this.v2 = this.seed.clone().add(PRIME64_2)
this.v3 = this.seed.clone()
this.v4 = this.seed.clone().subtract(PRIME64_1)
this.total_len = 0
this.memsize = 0
this.memory = null
return this
}
XXH64.prototype.init = init
/**
* Add data to be computed for the XXH64 hash
* @method update
* @param {String|Buffer|ArrayBuffer} input as a string or nodejs Buffer or ArrayBuffer
* @return ThisExpression
*/
XXH64.prototype.update = function (input) {
var isArrayBuffer
// Convert all strings to utf-8 first (issue #5)
if (typeof input == 'string') {
input = toUTF8Array(input)
isArrayBuffer = true
}
if (typeof ArrayBuffer !== "undefined" && input instanceof ArrayBuffer)
{
isArrayBuffer = true
input = new Uint8Array(input);
}
var p = 0
var len = input.length
var bEnd = p + len
if (len == 0) return this
this.total_len += len
if (this.memsize == 0)
{
if (isArrayBuffer) {
this.memory = new Uint8Array(32)
} else {
this.memory = new Buffer(32)
}
}
if (this.memsize + len < 32) // fill in tmp buffer
{
// XXH64_memcpy(this.memory + this.memsize, input, len)
if (isArrayBuffer) {
this.memory.set( input.subarray(0, len), this.memsize )
} else {
input.copy( this.memory, this.memsize, 0, len )
}
this.memsize += len
return this
}
if (this.memsize > 0) // some data left from previous update
{
// XXH64_memcpy(this.memory + this.memsize, input, 16-this.memsize);
if (isArrayBuffer) {
this.memory.set( input.subarray(0, 32 - this.memsize), this.memsize )
} else {
input.copy( this.memory, this.memsize, 0, 32 - this.memsize )
}
var p64 = 0
var other
other = UINT64(
(this.memory[p64+1] << 8) | this.memory[p64]
, (this.memory[p64+3] << 8) | this.memory[p64+2]
, (this.memory[p64+5] << 8) | this.memory[p64+4]
, (this.memory[p64+7] << 8) | this.memory[p64+6]
)
this.v1.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
p64 += 8
other = UINT64(
(this.memory[p64+1] << 8) | this.memory[p64]
, (this.memory[p64+3] << 8) | this.memory[p64+2]
, (this.memory[p64+5] << 8) | this.memory[p64+4]
, (this.memory[p64+7] << 8) | this.memory[p64+6]
)
this.v2.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
p64 += 8
other = UINT64(
(this.memory[p64+1] << 8) | this.memory[p64]
, (this.memory[p64+3] << 8) | this.memory[p64+2]
, (this.memory[p64+5] << 8) | this.memory[p64+4]
, (this.memory[p64+7] << 8) | this.memory[p64+6]
)
this.v3.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
p64 += 8
other = UINT64(
(this.memory[p64+1] << 8) | this.memory[p64]
, (this.memory[p64+3] << 8) | this.memory[p64+2]
, (this.memory[p64+5] << 8) | this.memory[p64+4]
, (this.memory[p64+7] << 8) | this.memory[p64+6]
)
this.v4.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
p += 32 - this.memsize
this.memsize = 0
}
if (p <= bEnd - 32)
{
var limit = bEnd - 32
do
{
var other
other = UINT64(
(input[p+1] << 8) | input[p]
, (input[p+3] << 8) | input[p+2]
, (input[p+5] << 8) | input[p+4]
, (input[p+7] << 8) | input[p+6]
)
this.v1.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
p += 8
other = UINT64(
(input[p+1] << 8) | input[p]
, (input[p+3] << 8) | input[p+2]
, (input[p+5] << 8) | input[p+4]
, (input[p+7] << 8) | input[p+6]
)
this.v2.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
p += 8
other = UINT64(
(input[p+1] << 8) | input[p]
, (input[p+3] << 8) | input[p+2]
, (input[p+5] << 8) | input[p+4]
, (input[p+7] << 8) | input[p+6]
)
this.v3.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
p += 8
other = UINT64(
(input[p+1] << 8) | input[p]
, (input[p+3] << 8) | input[p+2]
, (input[p+5] << 8) | input[p+4]
, (input[p+7] << 8) | input[p+6]
)
this.v4.add( other.multiply(PRIME64_2) ).rotl(31).multiply(PRIME64_1);
p += 8
} while (p <= limit)
}
if (p < bEnd)
{
// XXH64_memcpy(this.memory, p, bEnd-p);
if (isArrayBuffer) {
this.memory.set( input.subarray(p, bEnd), this.memsize )
} else {
input.copy( this.memory, this.memsize, p, bEnd )
}
this.memsize = bEnd - p
}
return this
}
/**
* Finalize the XXH64 computation. The XXH64 instance is ready for reuse for the given seed
* @method digest
* @return {UINT64} xxHash
*/
XXH64.prototype.digest = function () {
var input = this.memory
var p = 0
var bEnd = this.memsize
var h64, h
var u = new UINT64
if (this.total_len >= 32)
{
h64 = this.v1.clone().rotl(1)
h64.add( this.v2.clone().rotl(7) )
h64.add( this.v3.clone().rotl(12) )
h64.add( this.v4.clone().rotl(18) )
h64.xor( this.v1.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1) )
h64.multiply(PRIME64_1).add(PRIME64_4)
h64.xor( this.v2.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1) )
h64.multiply(PRIME64_1).add(PRIME64_4)
h64.xor( this.v3.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1) )
h64.multiply(PRIME64_1).add(PRIME64_4)
h64.xor( this.v4.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1) )
h64.multiply(PRIME64_1).add(PRIME64_4)
}
else
{
h64 = this.seed.clone().add( PRIME64_5 )
}
h64.add( u.fromNumber(this.total_len) )
while (p <= bEnd - 8)
{
u.fromBits(
(input[p+1] << 8) | input[p]
, (input[p+3] << 8) | input[p+2]
, (input[p+5] << 8) | input[p+4]
, (input[p+7] << 8) | input[p+6]
)
u.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1)
h64
.xor(u)
.rotl(27)
.multiply( PRIME64_1 )
.add( PRIME64_4 )
p += 8
}
if (p + 4 <= bEnd) {
u.fromBits(
(input[p+1] << 8) | input[p]
, (input[p+3] << 8) | input[p+2]
, 0
, 0
)
h64
.xor( u.multiply(PRIME64_1) )
.rotl(23)
.multiply( PRIME64_2 )
.add( PRIME64_3 )
p += 4
}
while (p < bEnd)
{
u.fromBits( input[p++], 0, 0, 0 )
h64
.xor( u.multiply(PRIME64_5) )
.rotl(11)
.multiply(PRIME64_1)
}
h = h64.clone().shiftRight(33)
h64.xor(h).multiply(PRIME64_2)
h = h64.clone().shiftRight(29)
h64.xor(h).multiply(PRIME64_3)
h = h64.clone().shiftRight(32)
h64.xor(h)
// Reset the state
this.init( this.seed )
return h64
}
module.exports = XXH64
|
'use strict';
var _ = require('underscore');
module.exports = _.extend(
require('./env/all'),
require('./env/' + process.env.NODE_ENV) || {}
); |
<canvas id="drawing" width="200" height="200">A drawing of something.</canvas>
|
// instanciando módulos
var gulp = require('gulp');
var watch = require('gulp-watch');
var del = require('del');
var shell = require('gulp-shell');
var connect = require('gulp-connect');
gulp.task('run:pelican', shell.task([
'pelican content -s pelicanconf.py'
]));
gulp.task('clean:pelican', function () {
return del([
'output/*'
]);
});
gulp.task('connect', function(){
connect.server({
root: ['output'],
port: 1337,
livereload: true
});
});
gulp.task('reload:output', function () {
connect.reload();
});
gulp.task('watch', function(){
// watch('content/*', gulp.series('run:pelican', 'reload:output'));
// watch('*', gulp.series('run:pelican', 'reload:output'));
// watch('theme/*', gulp.series('run:pelican', 'reload:output'));
// watch('theme/templates/*', gulp.series('run:pelican', 'reload:output'));
// watch('theme/static/css/*', gulp.series('run:pelican', 'reload:output'));
// watch('theme/static/js/*', gulp.series('run:pelican', 'reload:output'));
})
gulp.task('serve', gulp.parallel('connect','run:pelican', 'watch'));
|
var smidig = smidig || {};
smidig.voter = (function($) {
var talk_id, $form, $notice, $loader;
function supports_html5_storage() {
try {
return 'localStorage' in window && window['localStorage'] !== null;
} catch (e) {
return false;
}
}
function save_vote($form, talk_id) {
var votes = JSON.parse(localStorage.getItem("votes")) || {};
votes[talk_id] = true;
localStorage.setItem("votes", JSON.stringify(votes));
finished($form);
}
function bind($form, talk_id) {
$form.find("input[name='commit']").click(function() {
var data = $form.serializeObject();
if(!data["feedback_vote[vote]"]) {
alert("Du må gi minst 1 stjerne!");
return;
}
$form.find(".inputs").hide();
$form.find(".ajaxloader").show();
$form.find(".ajaxloader").css("visibility", "visible")
$.ajax({
type: "POST",
url: $form.attr("action"),
dataType: 'json',
data: data,
complete: function(xhr) {
if (xhr.readyState == 4) {
if (xhr.status == 201) {
smidig.voter.save_vote($form, talk_id);
}
} else {
alert("Det skjedde noe galt ved lagring. Prøv igjen");
$form.find(".ajaxloader").hide();
$form.find(".inputs").show();
}
}
});
//cancel submit event..
return false;
});
}
function init($form, talk_id) {
if(!supports_html5_storage()) {
$notice.text("Din enhet støttes ikke");
finished($form);
}
var votes = JSON.parse(localStorage.getItem("votes")) || {};
if(votes[talk_id]) {
finished($form);
} else {
bind($form, talk_id);
}
}
function finished($form) {
$form.empty();
$form.append("<em>(Du har stemt)</em>");
$form.show();
}
return {
init: init,
save_vote: save_vote
};
})(jQuery);
//Document on load!
$(function() {
$(".talk").each(function() {
var talk_id = $(this).data("talkid");
if(talk_id) {
var voteTmpl = $("#tmplVote").tmpl({talk_id: talk_id});
voteTmpl.find("input.star").rating();
$(this).find(".description").append(voteTmpl);
smidig.voter.init(voteTmpl, talk_id);
}
});
});
//Extensions to serialize a form to a js-object.
$.fn.serializeObject = function(){
var o = {};
var a = this.serializeArray();
$.each(a, function() {
if (o[this.name] !== undefined) {
if (!o[this.name].push) {
o[this.name] = [o[this.name]];
}
o[this.name].push(this.value || '');
} else {
o[this.name] = this.value || '';
}
});
return o;
}; |
import express from 'express';
import LessonController from '../controllers/LessonController';
const router = express.Router();
/* eslint-disable no-unused-vars */
const LessonsPath = '/api/lessonplans';
const teacherName = 'yonderWay';
const subjectName = 'theatre1';
const lessonNumber = '/:id';
// the data access should look something like this:
// '/api/teachers/{name}/{class}/{lesson#}'
router.post(LessonsPath, LessonController.create);
router.get(LessonsPath, LessonController.list);
router.get(LessonsPath + '/:id', LessonController.listOne);
router.put(LessonsPath + '/:id', LessonController.update);
router.delete(LessonsPath + '/:id', LessonController.delete);
export default router;
|
export { default, email } from '@abcum/ember-helpers/helpers/email';
|
module.exports = (function () {
'use strict';
var strings = require('../../strings').dead,
style = require('../../style');
return {
create: function(){
this.game.world.width = this.game.canvas.width;
this.game.world.height = this.game.canvas.height;
this.game.camera.reset();
this.game.stage.backgroundColor = style.color.three;
var deadText = this.game.add.text(
this.game.world.centerX,
200,
strings.gregory,
{
font: 'bold 60px ' + style.font.regular,
fill: style.color.white,
align: 'center'
}
);
deadText.anchor.setTo(0.5);
this.game.stage.backgroundColor = style.color.three;
var face = this.game.add.text(
this.game.world.centerX,
320,
strings.face,
{
font: 'bold 85px ' + style.font.regular,
fill: style.color.white,
align: 'center'
}
);
face.anchor.setTo(0.5);
this.game.stage.backgroundColor = style.color.three;
var instructions = this.game.add.text(
this.game.world.centerX,
430,
strings.instructions,
{
font: 'bold 20px ' + style.font.regular,
fill: style.color.white,
align: 'center'
}
);
instructions.anchor.setTo(0.5);
},
capabilities: {
'revive': function(){this.game.state.start('map');}
}
};
})(); |
// We only need to import the modules necessary for initial render
import CoreLayout from '../layouts/CoreLayout';
import Home from './Home';
import CounterRoute from './Counter';
/* Note: Instead of using JSX, we recommend using react-router
PlainRoute objects to build route definitions. */
export const createRoutes = () => ({
path : '/',
component : CoreLayout,
indexRoute : Home,
childRoutes : [
CounterRoute
]
});
/* Note: childRoutes can be chunked or otherwise loaded programmatically
using getChildRoutes with the following signature:
getChildRoutes (location, cb) {
require.ensure([], (require) => {
cb(null, [
// Remove imports!
require('./Counter').default(store)
])
})
}
However, this is not necessary for code-splitting! It simply provides
an API for async route definitions. Your code splitting should occur
inside the route `getComponent` function, since it is only invoked
when the route exists and matches.
*/
export default createRoutes;
|
import Colors from './Colors';
import Fonts from './Fonts';
import Metrics from './Metrics';
import Images from './Images';
import ApplicationStyles from './ApplicationStyles';
export { Colors, Fonts, Images, Metrics, ApplicationStyles };
|
import React from 'react';
import PropTypes from 'prop-types';
import Tooltip from '../Tooltip';
import SvgExclamation from '../svg/Exclamation.js';
import styles from './Input.scss';
class InputErrorSuffix extends React.Component {
render() {
return (
<Tooltip
dataHook="input-tooltip"
disabled={this.props.errorMessage.length === 0}
placement="top"
alignment="center"
textAlign="left"
content={this.props.errorMessage}
overlay=""
theme="dark"
maxWidth="230px"
hideDelay={150}
>
<div className={styles.exclamation}><SvgExclamation width={2} height={11}/></div>
</Tooltip>
);
}
}
InputErrorSuffix.propTypes = {
theme: PropTypes.oneOf(['normal', 'paneltitle', 'material', 'amaterial']),
errorMessage: PropTypes.string.isRequired,
focused: PropTypes.bool
};
export default InputErrorSuffix;
|
const fs = require("fs");
const path = require("path");
const {template} = require("lodash");
const minimist = require("minimist");
const yaml = require("js-yaml");
const argv = minimist(process.argv.slice(2));
const conf = {};
try {
const src = fs.readFileSync(path.resolve(__dirname, "../deploy-config.yml"));
const yml = yaml.safeLoad(src);
Object.assign(conf, yml);
if (argv.env && yml[argv.env]) Object.assign(conf, yml[argv.env]);
else if (yml.env && yml[yml.env]) Object.assign(conf, yml[yml.env]);
} catch(e) {
if (e.code !== "ENOENT") console.error(e);
}
Object.assign(conf, argv);
function walkfs(file, exts, fn) {
const stat = fs.statSync(file);
if (stat.isDirectory()) {
fs.readdirSync(file).forEach(name => {
walkfs(path.join(file, name), exts, fn);
});
} else if (exts.includes(path.extname(file))) {
const src = fs.readFileSync(file, "utf-8");
fn(src, file);
}
}
function build(dir, out, exts, join="", mode) {
const result = [];
walkfs(dir, exts, (src, file) => {
const data = Object.assign({}, conf, {
__filename: file,
__dirname: path.dirname(file)
});
const opts = {
variable: "$",
imports: {}
};
result.push(template(src, opts)(data).trim() + "\n");
});
if (result) {
fs.writeFileSync(out, result.join(join + "\n"), { mode });
}
}
build(
path.join(__dirname, "kube-conf"),
path.resolve(__dirname, "../kubernetes.yml"),
[ ".yml" ],
"---"
);
|
var set = new HashSet();
//Array size
var arrElementWidth = 150;
var arrElementHeight = 40;
//Key size
var keyWidth = 50;
var keyMargin = 5;
var width = 800;
var height = DEFAULT_TABLE_SIZE * (arrElementHeight + 5);
//Hash function block size
var blockWidth = keyWidth + keyMargin + arrElementWidth;
var blockHeight = DEFAULT_TABLE_SIZE * (arrElementHeight + 5);
var blockMargin = 30;
var codeDisplayManager = new CodeDisplayManager('javascript', 'hashSet');
var drawingArea;
var hashFunctionBlock;
var bucket;
var keys;
var newestElement;
var arrow;
//Panning
var pan;
$(document).ready(function () {
drawingArea = d3.select("#hash")
.append("svg:svg")
.attr("width", $('#graphics').width())
.attr("height", $('#graphics').height())
.append('g');
hashFunctionBlock = drawingArea.append("g");
keys = drawingArea.append("g");
bucket = drawingArea.append("g");
hashFunctionBlock.attr("id", "hashFunctionBlock");
keys.attr("id", "keys");
bucket.attr("id", "bucket");
hashFunctionBlock.append("rect")
.attr("width", blockWidth)
.attr("height", blockHeight)
.attr("x", width - arrElementWidth - keyWidth - blockWidth - blockMargin)
.attr("fill", "cornflowerBlue");
hashFunctionBlock.append("text")
.attr("width", blockWidth)
.attr("height", blockHeight)
.attr("y", blockHeight - 10)
.attr("x", width + 10 - arrElementWidth - keyWidth - blockWidth - blockMargin)
.text("")
.attr("class", 'noselect');
createKeysAndBuckets(DEFAULT_TABLE_SIZE, "1");
// arrow marker
drawingArea.append('defs').append('marker')
.attr('id', 'end-arrow')
.attr('viewBox', '0 -5 10 10')
.attr('refX', 6)
.attr('markerWidth', 3)
.attr('markerHeight', 3)
.attr('orient', 'auto')
.append('svg:path')
.attr('d', 'M0,-5L10,0L0,5')
.attr('fill', 'red');
arrow = drawingArea.append("path")
.attr("id", "arrow")
.attr("fill", "none")
.attr("stroke", "red")
.attr("stroke-width", "4")
.attr("opacity", "0")
.style('marker-end', 'url(#end-arrow)');
pan = d3.zoom()
.scaleExtent([1 / 10, 1])
.on("zoom", panning);
drawingArea.call(pan);
drawingArea.attr("transform", "translate(50,20) scale(0.70)");
});
function runAdd(x, probing, hashFunc) {
set.probingType = probing == "Quadratic" ? "quadratic" : "linear";
set.hashFunc = hashFunc == "Simple" ? getSimpleHashCode : getHashCode;
codeDisplayManager.loadFunctions('add', 'rehash');
codeDisplayManager.changeFunction('add');
set.add(x);
}
function runRemove(x) {
codeDisplayManager.loadFunctions('remove', 'rehash', 'add');
codeDisplayManager.changeFunction('remove');
set.remove(x);
}
function panning() {
drawingArea.attr("transform", d3.event.transform);
}
function updateArrow(index) {
unhighlightKey();
var targetY = index * (arrElementHeight + 5);
var lineData = [{ "x": arrElementWidth, "y": height / 2 + arrElementHeight / 2 },
{ "x": width + 30 - blockWidth - arrElementWidth - keyWidth - blockMargin, "y": height / 2 + arrElementHeight / 2 },
{ "x": width - 30 - arrElementWidth - keyWidth - blockMargin, "y": targetY + arrElementHeight / 2 },
{ "x": width - arrElementWidth - keyWidth - keyMargin, "y": targetY + arrElementHeight / 2 }];
var lineFunction = d3.line()
.x(function (d) { return d.x; })
.y(function (d) { return d.y; });
appendAnimation(null, [{ e: '#arrow', p: { attr: { d: lineFunction(lineData), opacity: 1 } }, o: { duration: 1 } }], null);
highlightKey(index);
}
function clearHighlight(array) {
appendAnimation(null, [{ e: $(array + " rect"), p: { attr: { fill: "cornflowerBlue" } }, o: { duration: 1 } }], null);
}
function add(value) {
prevOffset = 0;
hideHash();
newestElement = bucket.append("svg:g")
.attr("transform", "translate(0," + height / 2 + ")")
.attr("class", "newElement")
.attr("opacity", 0);
newestElement.append("rect")
.attr("width", arrElementWidth)
.attr("height", arrElementHeight)
.attr("fill", "#9c6dfc");
newestElement.append("text")
.style("text-anchor", "middle")
.attr("x", arrElementWidth / 2)
.attr("y", arrElementHeight / 2 + 7)
.text(value)
.style("font-size", "22px")
.style("font-weight", "bold");
appendAnimation(null, [{ e: newestElement.node(), p: { attr: { opacity: "1" } }, o: { duration: 1 } }], null);
}
function moveToHashFunctionBlock() {
appendAnimation(null, [
{ e: newestElement.node(), p: { x: width + 10 - blockWidth - arrElementWidth - keyWidth - blockMargin }, o: { duration: 1 } },
{ e: $("#arrow"), p: { attr: { opacity: 0, d: "" } }, o: { duration: 1, position: '-=1' } }
], null);
}
function replaceElement(index) {
moveToHashFunctionBlock();
appendAnimation(6, [
{ e: $("#bucket").filter(".element" + index), p: { attr: { opacity: 0 } }, o: { duration: 1 } },
{ e: newestElement.node(), p: { x: width - arrElementWidth, y: index * (arrElementHeight + 5) }, o: { duration: 1, position: '-=1' } },
], codeDisplayManager);
$("#bucket").filter(".element" + index).attr("class", "removed");
$(newestElement).attr("class", "element" + index);
}
function highlightKey(index) {
appendAnimation(null, [{ e: $("#keys rect").filter(".key" + index), p: { attr: { stroke: "red" } }, o: { duration: 1 } }], null);
}
function unhighlightKey() {
appendAnimation(null, [{ e: $("#keys rect"), p: { attr: { stroke: "none" } }, o: { duration: 1 } }], null);
}
function removeElement(index) {
appendAnimation(4, [
{ e: $(".element" + index), p: { attr: { stroke: "red", "stroke-width": "2" } }, o: { duration: 1 } },
{ e: $("#arrow"), p: { attr: { opacity: 0, d: "" } }, o: { duration: 1, position: '-=1' } }
], codeDisplayManager);
}
var prevOffset = 0;
function displayHash(hashValue, length, offset) {
var hashString;
if (set.probingType != "quadratic") {
if (offset == 0) {
hashString = hashValue + " % " + length + " = " + Math.abs(hashValue % length);
}
prevOffset += offset;
hashString = hashValue + " % " + length + " + " + prevOffset + " = " + (Math.abs(hashValue % length) + prevOffset);
} else {
if (offset == 0) {
hashString = hashValue + " % " + length + " = " + Math.abs(hashValue % length);
}
prevOffset += offset;
hashString = hashValue + " % " + length + " + " + offset + " * " + offset + " = " + (Math.abs(hashValue % length) + offset * offset);
}
appendAnimation(null, [
{ e: $("#hashFunctionBlock text"), p: { attr: { stroke: "red" }, text: hashString }, o: { duration: 1 } },
{ e: $("#hashFunctionBlock text"), p: { attr: { stroke: "black" } }, o: { duration: 1 } }
], null);
}
function hideHash() {
appendAnimation(null, [{ e: $("#hashFunctionBlock text"), p: { text: "" }, o: { duration: 1 } }], null);
}
function renewTable(length) {
appendAnimation(null, [
{ e: $("#bucket, #bucket *"), p: { attr: { opacity: 0 } }, o: { duration: 1 } },
{ e: $("#keys, #keys *"), p: { attr: { opacity: 0 } }, o: { duration: 1, position: '-=1' } }
], null);
$("#bucket *").attr("class", "removed");
$("#keys *").attr("class", "removed");
createKeysAndBuckets(length, "0");
appendAnimation(3, [
{ e: $("#bucket, #bucket *").filter(":not(.removed)"), p: { attr: { opacity: 1 } }, o: { duration: 1 } },
{ e: $("#keys, #keys *").filter(":not(.removed)"), p: { attr: { opacity: 1 } }, o: { duration: 1, position: '-=1' } }
], codeDisplayManager);
}
function createKeysAndBuckets(length, opacity) {
for (var i = 0; i < length; i++) {
//Key
var keyPosX = width - arrElementWidth - keyWidth - keyMargin;
var keyPosY = i * (arrElementHeight + 5);
var keyGroup = keys.append("svg:g")
.attr("transform", "translate(" + keyPosX + "," + keyPosY + ")");
keyGroup.append("svg:rect")
.attr("height", arrElementHeight)
.attr("width", keyWidth)
.attr("fill", "cornflowerBlue")
.attr("opacity", opacity)
.attr("class", "key" + i);
keyGroup.append("svg:text")
.text(i)
.attr("x", keyWidth / 2)
.attr("y", arrElementHeight / 2 + 7)
.attr("opacity", opacity)
.attr("text-anchor", "middle")
.style("font-size", "22px")
.style("font-weight", "bold");
//Bucket
var valueGroup = bucket.append("svg:g")
.attr("transform", "translate(" + (width - arrElementWidth) + "," + i * (arrElementHeight + 5) + ")")
.attr("class", "element" + i)
.attr("opacity", opacity);
valueGroup.append("svg:rect")
.attr("width", arrElementWidth)
.attr("height", arrElementHeight)
.attr("fill", "cornflowerBlue");
valueGroup.append("svg:text")
.style("text-anchor", "middle")
.attr("x", arrElementWidth / 2)
.attr("y", arrElementHeight / 2 + 7)
.style("font-size", "22px")
.style("font-weight", "bold");
}
}
function highlightCode(lines, functionName) {
if (functionName)
codeDisplayManager.changeFunction(functionName);
appendCodeLines(lines, codeDisplayManager);
}
|
"use strict";
function Wall(layer, id) {
powerupjs.GameObject.call(this, layer, id);
// Some physical properties of the wall
this.strokeColor = 'none';
this.fillColor = 'none';
this.scoreFrontColor = "#FFC800";
this.scoreSideColor = "#B28C00";
this.defaultFrontColor = '#0018FF';
this.defaultSideColor = '#0010B2';
this.frontColor = this.defaultFrontColor;
this.sideColor = this.defaultSideColor;
this._minVelocity = -250;
this._minDiameterY = 200;
this._maxDiameterY = 300;
this.diameterX = 100;
this.diameterY = 200;
this.wallWidth = this.diameterX;
this.wallThickness = this.wallWidth / 9;
this.smartWall = false;
this.smartWallRate = 2;
this.initX = powerupjs.Game.size.x + 100;
this.position = this.randomHolePosition();
this.velocity = new powerupjs.Vector2(this._minVelocity, 0);
}
Wall.prototype = Object.create(powerupjs.GameObject.prototype);
Object.defineProperty(Wall.prototype, "minDiameterY",
{
get: function () {
return this._minDiameterY;
}
});
Object.defineProperty(Wall.prototype, "maxDiameterY",
{
get: function () {
return this._maxDiameterY;
}
});
Object.defineProperty(Wall.prototype, "resetXOffset",
{
get: function () {
return this.initX - this.diameterX / 2;
}
});
Object.defineProperty(Wall.prototype, "boundingBox",
{
get: function () {
return new powerupjs.Rectangle(this.position.x - this.diameterX / 2,
this.position.y - this.diameterY / 2,
this.diameterX, this.diameterY);
}
});
Wall.prototype.reset = function() {
var playingState = powerupjs.GameStateManager.get(ID.game_state_playing);
this.frontColor = this.defaultFrontColor;
this.sideColor = this.defaultSideColor;
this.diameterY = this.randomHoleSize();
this.position = this.randomHolePosition();
this.scored = false;
// Smart wall = moving hole
if (playingState.score.score >= playingState.initSmartWallScore )
this.smartWall = true;
else
this.smartWall = false;
};
Wall.prototype.update = function(delta) {
//GameObject.prototype.update.call(this,delta);
// Contains all playing objects
var playingState = powerupjs.GameStateManager.get(ID.game_state_playing);
// If wall goes off screen
if (playingState.isOutsideWorld(this)) {
this.reset();
//this.velocity = new Vector2(this._minVelocity - (20 * score.score), 0);
}
// Move the hole
if (this.smartWall)
this.moveHole(delta);
// Determine if user collides with wall.
if (this.position.x <= playingState.user.boundingBox.right &&
this.position.x > playingState.user.boundingBox.center.x) {
if (this.isColliding(playingState.user)) {
playingState.lives -= 1;
playingState.isDying = true;
}
// If no collision and wall is behind user, score it.
} else if (this.position.x <= playingState.user.boundingBox.center.x && !this.scored) {
playingState.score.score += 1;
this.frontColor = this.scoreFrontColor;
this.sideColor = this.scoreSideColor;
this.scored = true;
sounds.beep.play();
}
// Add moving hole
//this.position.y += 1;
};
Wall.prototype.draw = function() {
powerupjs.Canvas2D.drawPath(this.calculateWallPath('topFront'), this.frontColor, this.strokeColor);
powerupjs.Canvas2D.drawPath(this.calculateWallPath('holeLeft'), this.frontColor, this.strokeColor);
powerupjs.Canvas2D.drawPath(this.calculateWallPath('bottomFront'), this.frontColor, this.strokeColor);
powerupjs.Canvas2D.drawPath(this.calculateWallPath('holeSide'), this.sideColor, this.strokeColor);
};
Wall.prototype.moveHole = function(delta) {
if (this.boundingBox.bottom > powerupjs.Game.size.y ||
this.boundingBox.top < 0)
this.smartWallRate *= -1;
this.position.y += this.smartWallRate;
};
Wall.prototype.isColliding = function(user) {
var userCenter = { x : user.boundingBox.center.x,
y : user.boundingBox.center.y};
var holeTop = this.position.y - this.diameterY / 2;
var holeBottom = this.position.y + this.diameterY / 2;
var overlap = this.position.x - userCenter.x;
var theta = Math.acos(overlap / (user.width / 2));
var userTop = userCenter.y - (user.height / 2) * Math.sin(theta);
var userBottom = (user.height / 2) * Math.sin(theta) + userCenter.y;
if (userTop > holeTop && userBottom < holeBottom) {
return false;
} else {
return true;
}
};
Wall.prototype.randomHoleSize = function() {
//console.log(Math.floor(Math.random() * (this.maxDiameterY - this.minDiameterY)) + this.minDiameterY);
return Math.floor(Math.random() * (this.maxDiameterY - this.minDiameterY)) + this.minDiameterY;
};
Wall.prototype.randomHolePosition = function() {
var newY = Math.random() * (powerupjs.Game.size.y - this.diameterY) +
this.diameterY / 2;
return new powerupjs.Vector2(this.initX, newY);
};
/*Wall.prototype.calculateRandomPosition = function() {
//var calcNewY = this.calculateRandomY;
var enemy = this.root.find(ID.enemy1);
if (enemy) {
console.log("here");
var newY = null;
while (! newY || (((newY - this.diameterY / 2) <= enemy.position.y + enemy.height) &&
((newY + this.diameterY / 2) >= enemy.position.y) )) {
newY = this.calculateRandomY();
console.log(newY);
}
return new powerupjs.Vector2(this.initX, newY);
} else {
return new powerupjs.Vector2(this.initX, this.calculateRandomY());
}
};*/
Wall.prototype.calculateWallPath = function(type) {
var xPoints = [];
var yPoints = [];
var pathType = [];
// Default values
// Wall bounds
var thick = this.wallThickness;
var left = this.position.x - this.diameterX / 2;
var right = this.position.x + (this.diameterX / 2) + thick;
var shiftedCenter = left + (this.diameterX / 2) + thick;
var top = 0;
var bottom = powerupjs.Game.size.y;
// Circle bounds
var cBase = this.position.y + this.diameterY / 2;
var cTop = this.position.y - this.diameterY / 2;
var cLeft = shiftedCenter - this.diameterX / 2;
var cRight = shiftedCenter + this.diameterX / 2;
switch(type){
case "holeLeft" :
top = cTop - 5;
bottom = cBase + 5;
right = shiftedCenter;
xPoints = [left, left, right, right,
[cLeft, cLeft, right],
right, left];
yPoints = [top, bottom, bottom, cBase,
[cBase, cTop, cTop],
top, top];
pathType = ['line','line','line','bezierCurve','line', 'line'];
break;
case "holeRight" :
top = cTop - 1;
bottom = cBase + 1;
left = shiftedCenter;
xPoints = [left, left,
[cRight, cRight, left],
left, right, right, left];
yPoints = [top, cTop,
[cTop, cBase, cBase],
bottom, bottom, top, top];
pathType = ['line','bezierCurve','line', 'line', 'line', 'line'];
break;
case "holeSide" :
thick = thick;
right = shiftedCenter;
xPoints = [right - thick,
[cLeft - thick, cLeft - thick, right - thick],
right,
[cLeft, cLeft, right],
right - thick];
yPoints = [cTop,
[cTop, cBase, cBase],
cBase,
[cBase, cTop, cTop],
cTop];
pathType = ['bezierCurve','line','bezierCurve','line'];
break;
case "topFront" :
bottom = cTop;
//right = shiftedCenter + 5;
xPoints = [left, left, right, right, left];
yPoints = [top, bottom, bottom, top, top];
pathType = ['line','line','line','line'];
break;
case "bottomFront" :
top = cBase;
//right = shiftedCenter + 5;
xPoints = [left, left, right, right, left];
yPoints = [top, bottom, bottom, top, top];
pathType = ['line','line','line','line'];
break;
case "rightSide" :
right = right - 1;
left = right;
right = right + thick;
xPoints = [left, left, right, right, left];
yPoints = [top, bottom, bottom, top, top];
pathType = ['line','line','line','line'];
break;
}
return { xPoints : xPoints, yPoints : yPoints,
pathType : pathType };
};
|
export default function createRegistry(repositories) {
const storage = { ...repositories };
const registry = {
register(repositoryName, repository) {
storage[repositoryName] = repository;
return registry;
},
has(repositoryName) {
return !!storage[repositoryName];
},
get(repositoryName) {
return storage[repositoryName];
},
reduce(reducer, initialValue) {
return Object
.keys(storage)
.reduce((previous, repositoryName) => reducer(
previous,
storage[repositoryName],
repositoryName,
), initialValue);
},
};
return registry;
}
|
/**
* Created by cc on 15-8-1.
*/
angular.module('app.services').factory('loginWithCode', ['app.api.http', '$ionicPopup','Storage','ENV','$state', function (http, $ionicPopup,Storage,ENV,$state) {
var dataJSON = {}
function login(){
if(ENV.code){
http.get('loginWithCode', {code:ENV.code}).success(function (data, status, headers, config) {
console.log("loginWithCode:回调返回数据:"+JSON.stringify(data))
if(data.status == 200){
openIdLogin(data)
}
})
}
}
function openIdLogin(data){
if(data.user){
Storage.setUserInfo(data.user);
}
if(data.authInfo){
Storage.setAccessToken(data.authInfo);
}
if(data.openId){
Storage.set("openId",{openId:data.openId})
dataJSON['openId'] = data.openId
}
//自动登陆后,如果在登陆,注册,或忘记密码页面则跳到个人中心
if(data.user && data.authInfo &&
($state.$current.name == 'forgetPass' ||
$state.$current.name == 'login' ||
$state.$current.name == 'signup')){
$state.go('tabs.usercenterMine')
}
}
return {
login:function(){
login()
},
addOpenId:function(params){
console.log("addOpenId:"+JSON.stringify(params))
return angular.extend({openId:dataJSON.openId},params)
}
}
}]); |
import React, { PropTypes, Component } from 'react';
import { View, ScrollView, Text, TouchableOpacity, Keyboard, ListView, Platform,
AsyncStorage } from 'react-native';
import getEmojiData from './data';
import ScrollableTabView from 'react-native-scrollable-tab-view';
const STORAGE_KEY = 'RNEI-latest';
class EmojiSelector extends Component {
constructor(props) {
super(props);
this.state = {
visible: props.defaultVisible || false,
height: (props.defaultVisible || false) ? props.containerHeight : 0,
emoji: [],
latest: [],
counts: {}
};
}
componentWillMount() {
this.setState({
emoji: getEmojiData()
});
if (this.props.history) {
AsyncStorage.getItem(STORAGE_KEY).then( value => {
if (value) {
var counts = JSON.parse(value);
this.setState({
counts: counts || {}
}, () => {
this.refreshLatest()
})
}
});
}
}
saveCounts() {
if (this.props.history) {
AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(this.state.counts));
}
}
render() {
const { headerStyle, containerBackgroundColor, emojiSize, onPick, tabBorderColor } = this.props;
return (
<View style={[{height: this.state.height, overflow: 'hidden'}]}>
<ScrollableTabView
tabBarUnderlineStyle={{
backgroundColor: this.props.tabBorderColor
}}
tabBarTextStyle={styles.tabBarText}
style={styles.picker}
>
{this.state.latest.length?
<EmojiCategory
key={'latest'}
tabLabel={'🕰'}
emojiSize={emojiSize}
items={this.state.latest}
onPick={this.onPress.bind(this)}
/>
:null}
{this.state.emoji.map((category, idx) => (
<EmojiCategory
key={idx}
tabLabel={category.items[0]}
headerStyle={headerStyle}
emojiSize={emojiSize}
name={category.category}
items={category.items}
onPick={this.onPress.bind(this)}
/>
))}
</ScrollableTabView>
</View>
);
}
onPress(em) {
if (this.props.onPick) {
this.props.onPick(em);
} else if (this.onPick) {
this.onPick(em);
}
this.increaseCount(em);
}
show() {
this.setState({visible: true, height: this.props.containerHeight});
}
hide() {
this.setState({visible: false, height: 0});
}
increaseCount(em) {
if (!this.props.history) return;
var counts = this.state.counts;
if (!counts[em]) {
counts[em] = 0;
}
counts[em] ++ ;
this.setState({
counts
}, () => {
this.refreshLatest();
this.saveCounts();
})
}
refreshLatest() {
if (!this.props.history) return;
var latest = this.state.latest;
var counts = this.state.counts;
var sortable = [];
Object.keys(counts).map(em => {
sortable.push([em, counts[em]]);
});
sortable.sort((a, b) => {
return b[1] - a[1];
});
latest = sortable.map(s => {
return s[0];
});
this.setState({
latest
})
}
}
EmojiSelector.propTypes = {
onPick: PropTypes.func,
headerStyle: PropTypes.object,
containerHeight: PropTypes.number.isRequired,
containerBackgroundColor: PropTypes.string.isRequired,
emojiSize: PropTypes.number.isRequired,
};
EmojiSelector.defaultProps = {
containerHeight: 240,
containerBackgroundColor: 'rgba(0, 0, 0, 0.1)',
tabBorderColor: "#09837d",
emojiSize: 40,
history: true
};
class EmojiCategory extends Component {
constructor(props) {
super(props);
this.state={
items:[...props.items]
};
}
componentDidMount() {
var ds = new ListView.DataSource({rowHasChanged: (r1, r2) => r1 !== r2});
this.setState({
dataSource: ds.cloneWithRows(this.props.items)
});
}
componentWillReceiveProps(nextProps) {
if (nextProps.items!=this.state.items) {
this.setState({
dataSource: this.state.dataSource.cloneWithRows(nextProps.items),
items: [...nextProps.items]
});
}
}
render() {
if (!this.state.dataSource) {
return null;
}
const { emojiSize, name, items, onPick } = this.props;
return (
<View style={styles.categoryTab}>
<ListView contentContainerStyle={styles.categoryItems}
dataSource={this.state.dataSource}
renderRow={this._renderRow.bind(this)}
initialListSize={1000}
/>
</View>
);
}
_renderRow(item) {
var size = this.props.emojiSize;
// const fontSize = Platform.OS == 'android' ? size / 5 * 3 : size / 4 * 3;
const fontSize = Platform.OS == 'android' ? size / 4 * 3 : size / 4 * 3;
const width = Platform.OS == 'android' ? size + 8 : size;
return (
<TouchableOpacity style={{ flex: 0, height: size, width }} onPress={() => this.props.onPick(item)}>
<View style={{ flex: 0, height: size, width, justifyContent: 'center' }}>
<Text style={{ flex: 0, fontSize, paddingBottom: 2, color: 'black' }}>
{item}
</Text>
</View>
</TouchableOpacity>
)
}
}
const styles = {
picker: {
// flex: 1,
borderTopWidth: 1,
borderTopColor: "#ddd",
},
categoryTab: {
flex: 1,
paddingHorizontal: 5,
justifyContent: 'center'
// paddingLeft: Platform.OS=='android' ? 20 : 5,
// paddingTop: 42,
},
categoryItems: {
// flex: 1,
flexDirection: 'row',
flexWrap: 'wrap',
},
tabBarText: {
fontSize: Platform.OS == 'android' ? 26 : 24,
}
};
export default EmojiSelector;
|
version https://git-lfs.github.com/spec/v1
oid sha256:07f4bf13ba69118ebd88b07b6c66f211f610acc3cdf0a9322352a6b8100ba3ce
size 682
|
import * as React from 'react';
import {Items,Item,Row,Col,Table,Code} from 'yrui';
let thead=[{
key:'key',
value:'参数',
},{
key:'expr',
value:'说明',
},{
key:'type',
value:'类型',
},{
key:'values',
value:'可选值',
},{
key:'default',
value:'默认值',
}];
//
let route=[{
key:'url',
expr:'路径',
type:'string',
values:'-',
default:'-',
},{
key:'component',
expr:'页面组件',
type:'object|function',
values:'-',
default:'-',
},{
key:'asyncComponent',
expr:'按需加载组件',
type:'function',
values:'-',
default:'-',
},{
key:'name',
expr:'标题',
type:'string',
values:'-',
default:'-',
},{
key:'icon',
expr:'路由左侧图标',
type:'string',
values:'-',
default:'-',
},{
key:'noMenu',
expr:'不显示菜单栏',
type:'boolean',
values:'-',
default:'false',
},{
key:'noFrame',
expr:'不显框架信息',
type:'boolean',
values:'-',
default:'false',
},{
key:'child',
expr:'子路由',
type:'array',
values:'-',
default:'-',
}];
//
let brand=[{
key:'logo',
expr:'是否在brand上显示logo',
type:'string',
values:'-',
default:'-',
},{
key:'title',
expr:'标题',
type:'string',
values:'-',
default:'-',
},{
key:'subtitle',
expr:'副标题',
type:'string',
values:'-',
default:'-',
}];
//
let navbar=[{
key:'leftNav',
expr:'头部左侧内容',
type:'array',
values:'-',
default:'-',
},{
key:'rightNav',
expr:'头部右侧内容',
type:'array',
values:'-',
default:'-',
},{
key:'click',
expr:'返回当前点击nav的数据(click(v))',
type:'function',
values:'-',
default:'-',
},{
key:'collapse',
expr:'左侧菜单栏切换事件',
type:'function',
values:'-',
default:'-',
}];
//
let leftNav=[{
key:'name',
expr:'下拉菜单名',
type:'string',
values:'-',
default:'-',
},{
key:'icon',
expr:'下拉菜单图标',
type:'string',
values:'-',
default:'-',
},{
key:'img',
expr:'下拉菜单图标',
type:'string',
values:'-',
default:'-',
},{
key:'animate',
expr:'下拉菜单动画',
type:'string',
values:'up/down/left/right',
default:'up',
},{
key:'msg',
expr:'下拉菜单消息提示',
type:'string',
values:'-',
default:'-',
},{
key:'drop',
expr:'下拉菜单内容',
type:'function|string',
values:'-',
default:'-',
},{
key:'url',
expr:'菜单链接',
type:'string',
values:'-',
default:'javascript:;',
}];
//
let sidebar=[{
key:'projectList',
expr:'项目列表',
type:'array',
values:'-',
default:'-',
},{
key:'showSidebarTitle',
expr:'是否隐藏侧边栏title',
type:'boolean',
values:'true/false',
default:'false',
},{
key:'userInfo',
expr:'用户信息展示',
type:'object',
values:'-',
default:'-',
}];
let userinfo=[{
key:'name',
expr:'已登陆用户名',
type:'string',
values:'-',
default:'-',
},{
key:'logo',
expr:'已登陆用户头像',
type:'string|object',
values:'-',
default:'-',
},{
key:'email',
expr:'已登陆用户邮箱',
type:'string',
values:'-',
default:'-',
}];
//
let main=[{
key:'showBreadcrumb',
expr:'是否显示面包屑',
type:'boolean',
values:'true/false',
default:'true',
},{
key:'showPagetitle',
expr:'是否显示面包屑上面标题',
type:'boolean',
values:'true/false',
default:'false',
}];
//
let routers=[{
key:'routers',
expr:'路由表',
type:'array',
values:'-',
default:'-',
},{
key:'horizontal',
expr:'是否为水平菜单栏',
type:'boolean',
values:'true/false',
default:'false',
},{
key:'brand',
expr:'头部brand配置',
type:'object',
values:'-',
default:'-',
},{
key:'navbar',
expr:'头部nav配置',
type:'object',
values:'-',
default:'-',
},{
key:'main',
expr:'主页面头部配置',
type:'object',
values:'-',
default:'-',
},{
key:'sidebar',
expr:'左侧边栏配置',
type:'object',
values:'-',
default:'-',
},{
key:'rightbar',
expr:'右侧边栏配置',
type:'object|string',
values:'-',
default:'-',
},{
key:'footer',
expr:'底部栏配置',
type:'object|string',
values:'-',
default:'-',
},{
key:'browserRouter',
expr:'是否是真实路径',
type:'boolean',
values:'true/false',
default:'false',
},{
key:'routeAnimate',
expr:'路由切换动画',
type:'string',
values:'scale/down/right/no',
default:'scale',
},{
key:'theme',
expr:'用户自定义主题',
type:'string',
values:'-',
default:'-',
}];
//
let others=[{
key:'rightbar',
expr:'右侧边栏',
type:'object|string',
values:'-',
default:'-',
},{
key:'footer',
expr:'底部栏配置',
type:'object|string',
values:'-',
default:'-',
},{
key:'browserRouter',
expr:'是否是真实路径',
type:'boolean',
values:'true/false',
default:'false',
},{
key:'routeAnimate',
expr:'路由切换动画',
type:'string',
values:'scale/down/right/no',
default:'scale',
},{
key:'horizontal',
expr:'是否为水平菜单栏',
type:'boolean',
values:'true/false',
default:'false',
},{
key:'theme',
expr:'用户自定义主题',
type:'string',
values:'-',
default:'-',
}];
const t=`const app={
brand:{
title:'Phoenix',//
subtitle:'UI Demo',//
logo:require('./styles/images/usr.jpg'),//
},
navbar:{
leftNav:null,
rightNav:null,
click:(v)=>{console.log(v);},//点击头部菜单事件
collapse:()=>{console.log('collapse');},//左侧菜单栏切换事件
},
sidebar:{
projectList:null,//菜单项目列表，可忽略
showSidebarTitle:false,//显示侧边栏标题
userInfo:null,//用户信息
},
rightbar:'<h2>111</h2>',//右侧边栏component
main:{
showBreadcrumb:true,//显示面包屑
showPagetitle:false,//显示头部标题
},
footer:'<p>版权所有 © 2017-2020 Phoenix 团队</p>',//底部栏component
routers:sidebarMenu,//侧边栏，路由
routeAnimate:'scale',//路由切换动画,设置为'no'取消动画效果
browserRouter:false,//是否使用真实路径
horizontal:false,//是否为水平菜单栏
theme:'',//用户自定义主题
};
<Router {...app} />
`;
export default class Frame extends React.Component {
render() {
return (
<Items>
<Item>
<Row>
<Col span={12}>
<h2>routers配置</h2>
<Table thead={thead} tbody={routers} />
</Col>
</Row>
<Row gutter={8}>
<Col span={12}>
<div className="txt-area">
<h2>配置</h2>
{/*<p>brand navbar sidebar rightbar main</p>*/}
<Code title="demo" code={t} />
</div>
</Col>
</Row>
<Row gutter={8}>
<Col span={12}>
<h2>route配置</h2>
<Table thead={thead} tbody={route} />
</Col>
</Row>
<Row gutter={8}>
<Col span={12}>
<h2>brand配置</h2>
<Table thead={thead} tbody={brand} />
</Col>
</Row>
<Row gutter={8}>
<Col span={12}>
<h2>navbar配置</h2>
<Table thead={thead} tbody={navbar} />
</Col>
</Row>
<Row gutter={8}>
<Col span={12}>
<h2>sidebar配置</h2>
<Table thead={thead} tbody={sidebar} />
</Col>
</Row>
<Row gutter={8}>
<Col span={12}>
<h2>userinfo配置</h2>
<Table thead={thead} tbody={userinfo} />
</Col>
</Row>
<Row gutter={8}>
<Col span={12}>
<h2>main配置</h2>
<Table thead={thead} tbody={main} />
</Col>
</Row>
<Row gutter={8}>
<Col span={12}>
<h2>leftNav、leftNav配置</h2>
<Table thead={thead} tbody={leftNav} />
</Col>
</Row>
</Item>
</Items>
);
}
}
|
'use strict';
/**
* Module dependencies.
*/
var mongoose = require('mongoose'),
errorHandler = require('./errors.server.controller'),
Product = mongoose.model('Product'),
multiparty = require('multiparty'),
uuid = require('node-uuid'),
fs = require('fs'),
_ = require('lodash');
/**
* Create a Product
*/
exports.create = function(req, res, next) {
var form = new multiparty.Form();
form.parse(req, function(err, fields, files) {
var file = files.file[0];
var contentType = file.headers['content-type'];
var tmpPath = file.path;
var extIndex = tmpPath.lastIndexOf('.');
var extension = (extIndex < 0) ? '' : tmpPath.substr(extIndex);
// uuid is for generating unique filenames.
var fileName = uuid.v4() + extension;
var destPath = '/home/blaze/Sites/github/yaltashop/uploads/' + fileName;
//fs.rename(tmpPath, destPath, function(err) {
if (err) {
console.log('there was an error during saving file');
next(err);
}
var product = new Product(fields);
file.name = file.originalFilename;
product.photo.file = file;
product.user = req.user;
product.save(function(err) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.jsonp(product);
}
});
//});
});
};
/**
* Show the current Product
*/
exports.read = function(req, res) {
res.jsonp(req.product);
};
/**
* Update a Product
*/
exports.update = function(req, res) {
var product = req.product ;
product = _.extend(product , req.body);
product.save(function(err) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.jsonp(product);
}
});
};
/**
* Delete an Product
*/
exports.delete = function(req, res) {
var product = req.product ;
product.remove(function(err) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.jsonp(product);
}
});
};
/**
* List of Products
*/
exports.list = function(req, res) {
Product.find().sort('-created').populate('user', 'displayName').exec(function(err, products) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.jsonp(products);
}
});
};
/**
* Product middleware
*/
exports.productByID = function(req, res, next, id) {
Product.findById(id).populate('user', 'displayName').exec(function(err, product) {
if (err) return next(err);
if (! product) return next(new Error('Failed to load Product ' + id));
req.product = product ;
next();
});
};
/**
* Product authorization middleware
*/
exports.hasAuthorization = function(req, res, next) {
if (req.product.user.id !== req.user.id) {
return res.status(403).send('User is not authorized');
}
next();
};
|
/*! jQuery UI - v1.10.4 - 2018-06-10
* http://jqueryui.com
* Copyright jQuery Foundation and other contributors; Licensed MIT */
jQuery(function(t){t.datepicker.regional["en-GB"]={closeText:"Done",prevText:"Prev",nextText:"Next",currentText:"Today",monthNames:["January","February","March","April","May","June","July","August","September","October","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],weekHeader:"Wk",dateFormat:"dd/mm/yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""},t.datepicker.setDefaults(t.datepicker.regional["en-GB"])}); |
var mongoose = require('mongoose');
var BaseModel = require("./base_model");
var Schema = mongoose.Schema;
var ObjectId = Schema.ObjectId;
var UserFollowSchema = new Schema({
user_id: { type: ObjectId },
kind: { type: String },
object_id: { type: ObjectId },
create_at: { type: Date, default: Date.now }
});
UserFollowSchema.plugin(BaseModel);
UserFollowSchema.index({user_id: 1, object_id: 1}, {unique: true});
mongoose.model('UserFollow', UserFollowSchema);
|
'use strict'
const path = require('path')
const webpack = require('webpack')
const HtmlWebpackPlugin = require('html-webpack-plugin')
const ExtractTextPlugin = require('extract-text-webpack-plugin')
const ManifestPlugin = require('webpack-manifest-plugin')
const InterpolateHtmlPlugin = require('react-dev-utils/InterpolateHtmlPlugin')
const SWPrecacheWebpackPlugin = require('sw-precache-webpack-plugin')
const ModuleScopePlugin = require('react-dev-utils/ModuleScopePlugin')
const paths = require('./paths')
const getClientEnvironment = require('./env')
// Webpack uses `publicPath` to determine where the app is being served from.
// It requires a trailing slash, or the file assets will get an incorrect path.
const publicPath = paths.servedPath
// Some apps do not use client-side routing with pushState.
// For these, "homepage" can be set to "." to enable relative asset paths.
const shouldUseRelativeAssetPaths = publicPath === './'
// `publicUrl` is just like `publicPath`, but we will provide it to our app
// as %PUBLIC_URL% in `index.html` and `process.env.PUBLIC_URL` in JavaScript.
// Omit trailing slash as %PUBLIC_URL%/xyz looks better than %PUBLIC_URL%xyz.
const publicUrl = publicPath.slice(0, -1)
// Get environment variables to inject into our app.
const env = getClientEnvironment(publicUrl)
// Assert this just to be safe.
// Development builds of React are slow and not intended for production.
if (env.stringified['process.env'].NODE_ENV !== '"production"') {
throw new Error('Production builds must have NODE_ENV=production.')
}
// Note: defined here because it will be used more than once.
const cssFilename = 'static/css/[name].[contenthash:8].css'
// ExtractTextPlugin expects the build output to be flat.
// (See https://github.com/webpack-contrib/extract-text-webpack-plugin/issues/27)
// However, our output is structured with css, js and media folders.
// To have this structure working with relative paths, we have to use custom options.
const extractTextPluginOptions = shouldUseRelativeAssetPaths
// Making sure that the publicPath goes back to to build folder.
? { publicPath: Array(cssFilename.split('/').length).join('../') }
: {}
// This is the production configuration.
// It compiles slowly and is focused on producing a fast and minimal bundle.
// The development configuration is different and lives in a separate file.
module.exports = {
// Don't attempt to continue if there are any errors.
bail: true,
// We generate sourcemaps in production. This is slow but gives good results.
// You can exclude the *.map files from the build during deployment.
devtool: 'source-map',
// In production, we only want to load the polyfills and the app code.
entry: [require.resolve('./polyfills'), paths.appIndexJs],
output: {
// The build folder.
path: paths.appBuild,
// Generated JS file names (with nested folders).
// There will be one main bundle, and one file per asynchronous chunk.
// We don't currently advertise code splitting but Webpack supports it.
filename: 'static/js/[name].[chunkhash:8].js',
chunkFilename: 'static/js/[name].[chunkhash:8].chunk.js',
// We inferred the "public path" (such as / or /my-project) from homepage.
publicPath: publicPath,
// Point sourcemap entries to original disk location
devtoolModuleFilenameTemplate: info =>
path.relative(paths.appSrc, info.absoluteResourcePath)
},
resolve: {
// This allows you to set a fallback for where Webpack should look for modules.
// We placed these paths second because we want `node_modules` to "win"
// if there are any conflicts. This matches Node resolution mechanism.
// https://github.com/facebookincubator/create-react-app/issues/253
modules: ['node_modules', paths.appNodeModules].concat(
// It is guaranteed to exist because we tweak it in `env.js`
process.env.NODE_PATH.split(path.delimiter).filter(Boolean)
),
// These are the reasonable defaults supported by the Node ecosystem.
// We also include JSX as a common component filename extension to support
// some tools, although we do not recommend using it, see:
// https://github.com/facebookincubator/create-react-app/issues/290
extensions: ['.js', '.json', '.jsx'],
alias: {
// Support React Native Web
// https://www.smashingmagazine.com/2016/08/a-glimpse-into-the-future-with-react-native-for-web/
'react-native': 'react-native-web',
Components: path.resolve(__dirname, '../src/components'),
Util: path.resolve(__dirname, '../src/util'),
Actions: path.resolve(__dirname, '../src/actions'),
Selectors: path.resolve(__dirname, '../src/selectors')
},
plugins: [
// Prevents users from importing files from outside of src/ (or node_modules/).
// This often causes confusion because we only process files within src/ with babel.
// To fix this, we prevent you from importing files out of src/ -- if you'd like to,
// please link the files into your node_modules/ and let module-resolution kick in.
// Make sure your source files are compiled, as they will not be processed in any way.
new ModuleScopePlugin(paths.appSrc)
]
},
module: {
strictExportPresence: true,
rules: [
// TODO: Disable require.ensure as it's not a standard language feature.
// We are waiting for https://github.com/facebookincubator/create-react-app/issues/2176.
// { parser: { requireEnsure: false } },
// First, run the linter.
// It's important to do this before Babel processes the JS.
{
test: /\.(js|jsx)$/,
enforce: 'pre',
loader: 'standard-loader',
options: {
error: true
},
include: paths.appSrc
},
// ** ADDING/UPDATING LOADERS **
// The "file" loader handles all assets unless explicitly excluded.
// The `exclude` list *must* be updated with every change to loader extensions.
// When adding a new loader, you must add its `test`
// as a new entry in the `exclude` list in the "file" loader.
// "file" loader makes sure those assets end up in the `build` folder.
// When you `import` an asset, you get its filename.
{
exclude: [
/\.html$/,
/\.(js|jsx)$/,
/\.css$/,
/\.scss$/,
/\.json$/,
/\.bmp$/,
/\.gif$/,
/\.jpe?g$/,
/\.png$/
],
loader: require.resolve('file-loader'),
options: {
name: 'static/media/[name].[hash:8].[ext]'
}
},
// "url" loader works just like "file" loader but it also embeds
// assets smaller than specified size as data URLs to avoid requests.
{
test: [/\.bmp$/, /\.gif$/, /\.jpe?g$/, /\.png$/],
loader: require.resolve('url-loader'),
options: {
limit: 10000,
name: 'static/media/[name].[hash:8].[ext]'
}
},
// Process JS with Babel.
{
test: /\.(js|jsx)$/,
include: paths.appSrc,
loader: require.resolve('babel-loader')
},
// The notation here is somewhat confusing.
// "postcss" loader applies autoprefixer to our CSS.
// "css" loader resolves paths in CSS and adds assets as dependencies.
// "style" loader normally turns CSS into JS modules injecting <style>,
// but unlike in development configuration, we do something different.
// `ExtractTextPlugin` first applies the "postcss" and "css" loaders
// (second argument), then grabs the result CSS and puts it into a
// separate file in our build process. This way we actually ship
// a single CSS file in production instead of JS code injecting <style>
// tags. If you use code splitting, however, any async bundles will still
// use the "style" loader inside the async code so CSS from them won't be
// in the main CSS file.
{
test: /\.css$/,
loader: ExtractTextPlugin.extract(
Object.assign(
{
fallback: require.resolve('style-loader'),
use: [
{
loader: require.resolve('css-loader'),
options: {
importLoaders: 1,
minimize: true,
sourceMap: true
}
}
// {
// loader: require.resolve('postcss-loader'),
// options: {
// ident: 'postcss', // https://webpack.js.org/guides/migrating/#complex-options
// plugins: () => [
// require('postcss-flexbugs-fixes'),
// autoprefixer({
// browsers: [
// '>1%',
// 'last 4 versions',
// 'Firefox ESR',
// 'not ie < 9', // React doesn't support IE8 anyway
// ],
// flexbox: 'no-2009',
// }),
// ],
// },
// },
]
},
extractTextPluginOptions
)
)
// Note: this won't work without `new ExtractTextPlugin()` in `plugins`.
}
// ** STOP ** Are you adding a new loader?
// Remember to add the new extension(s) to the "file" loader exclusion list.
]
},
plugins: [
// Makes some environment variables available in index.html.
// The public URL is available as %PUBLIC_URL% in index.html, e.g.:
// <link rel="shortcut icon" href="%PUBLIC_URL%/favicon.ico">
// In production, it will be an empty string unless you specify "homepage"
// in `package.json`, in which case it will be the pathname of that URL.
new InterpolateHtmlPlugin(env.raw),
// Generates an `index.html` file with the <script> injected.
new HtmlWebpackPlugin({
inject: true,
template: paths.appHtml,
minify: {
removeComments: true,
collapseWhitespace: true,
removeRedundantAttributes: true,
useShortDoctype: true,
removeEmptyAttributes: true,
removeStyleLinkTypeAttributes: true,
keepClosingSlash: true,
minifyJS: true,
minifyCSS: true,
minifyURLs: true
}
}),
// Makes some environment variables available to the JS code, for example:
// if (process.env.NODE_ENV === 'production') { ... }. See `./env.js`.
// It is absolutely essential that NODE_ENV was set to production here.
// Otherwise React will be compiled in the very slow development mode.
new webpack.DefinePlugin(env.stringified),
// Minify the code.
new webpack.optimize.UglifyJsPlugin({
compress: {
warnings: false,
// This feature has been reported as buggy a few times, such as:
// https://github.com/mishoo/UglifyJS2/issues/1964
// We'll wait with enabling it by default until it is more solid.
reduce_vars: false
},
output: {
comments: false
},
sourceMap: true
}),
// Note: this won't work without ExtractTextPlugin.extract(..) in `loaders`.
new ExtractTextPlugin({
filename: cssFilename
}),
// Generate a manifest file which contains a mapping of all asset filenames
// to their corresponding output file so that tools can pick it up without
// having to parse `index.html`.
new ManifestPlugin({
fileName: 'asset-manifest.json'
}),
// Generate a service worker script that will precache, and keep up to date,
// the HTML & assets that are part of the Webpack build.
new SWPrecacheWebpackPlugin({
// By default, a cache-busting query parameter is appended to requests
// used to populate the caches, to ensure the responses are fresh.
// If a URL is already hashed by Webpack, then there is no concern
// about it being stale, and the cache-busting can be skipped.
dontCacheBustUrlsMatching: /\.\w{8}\./,
filename: 'service-worker.js',
logger (message) {
if (message.indexOf('Total precache size is') === 0) {
// This message occurs for every build and is a bit too noisy.
return
}
console.log(message)
},
minify: true,
navigateFallback: publicUrl + '/index.html',
staticFileGlobsIgnorePatterns: [/\.map$/, /asset-manifest\.json$/],
// Work around Windows path issue in SWPrecacheWebpackPlugin:
// https://github.com/facebookincubator/create-react-app/issues/2235
stripPrefix: paths.appBuild.replace(/\\/g, '/') + '/'
}),
// Moment.js is an extremely popular library that bundles large locale files
// by default due to how Webpack interprets its code. This is a practical
// solution that requires the user to opt into importing specific locales.
// https://github.com/jmblog/how-to-optimize-momentjs-with-webpack
// You can remove this if you don't use Moment.js:
new webpack.IgnorePlugin(/^\.\/locale$/, /moment$/)
],
// Some libraries import Node modules but don't use them in the browser.
// Tell Webpack to provide empty mocks for them so importing them works.
node: {
fs: 'empty',
net: 'empty',
tls: 'empty'
}
}
|
"use strict"
const messages = require("..").messages
const ruleName = require("..").ruleName
const rules = require("../../../rules")
const rule = rules[ruleName]
testRule(rule, {
ruleName,
config: ["always"],
accept: [ {
code: "a { color :pink }",
description: "space only before",
}, {
code: "a { color : pink }",
description: "space before and after",
}, {
code: "a { color :\npink }",
description: "space before and newline after",
}, {
code: "a { color :\r\npink }",
description: "space before and CRLF after",
}, {
code: "$map:(key:value)",
description: "SCSS map with no newlines",
}, {
code: "$list:('value1', 'value2')",
description: "SCSS list with no newlines",
}, {
code: "a { background : url(data:application/font-woff;...); }",
description: "data URI",
} ],
reject: [ {
code: "a { color: pink; }",
description: "no space before",
message: messages.expectedBefore(),
line: 1,
column: 11,
}, {
code: "a { color : pink; }",
description: "two spaces before",
message: messages.expectedBefore(),
line: 1,
column: 11,
}, {
code: "a { color\t: pink; }",
description: "tab before",
message: messages.expectedBefore(),
line: 1,
column: 11,
}, {
code: "a { color\n: pink; }",
description: "newline before",
message: messages.expectedBefore(),
line: 2,
column: 1,
}, {
code: "a { color\r\n: pink; }",
description: "CRLF before",
message: messages.expectedBefore(),
line: 1,
column: 11,
} ],
})
testRule(rule, {
ruleName,
config: ["never"],
accept: [ {
code: "a { color:pink }",
description: "no space before and after",
}, {
code: "a { color: pink }",
description: "no space before and space after",
}, {
code: "a { color:\npink }",
description: "no space before and newline after",
}, {
code: "a { color:\r\npink }",
description: "no space before and CRLF after",
}, {
code: "$map :(key :value)",
description: "SCSS map with no newlines",
} ],
reject: [ {
code: "a { color : pink; }",
description: "space before",
message: messages.rejectedBefore(),
line: 1,
column: 11,
}, {
code: "a { color : pink; }",
description: "two spaces before",
message: messages.rejectedBefore(),
line: 1,
column: 11,
}, {
code: "a { color\t: pink; }",
description: "tab before",
message: messages.rejectedBefore(),
line: 1,
column: 11,
}, {
code: "a { color\n: pink; }",
description: "newline before",
message: messages.rejectedBefore(),
line: 2,
column: 1,
}, {
code: "a { color\r\n: pink; }",
description: "CRLF before",
message: messages.rejectedBefore(),
line: 1,
column: 11,
} ],
})
|
var scene;
var camera;
var renderer;
var stats;
var geometry;
var material;
var line;
var ambientLight;
var loader;
var cow;
var cowMixer;
var walkCow;
var walkCowMixer;
var cowStatus = "walkings"; // none standing walking
cowCur = "walking"; // standing
var milk;
var loopAnim;
var loopFallMilk; // 循环滴落奶
var grass;
var grassMixer;
var grass2;
var grass3;
var grassList = [
{
mesh: undefined,
x: 300,
y: 120,
z: -50
}, {
mesh: undefined,
x: -160,
y: 120,
z: -300
}, {
mesh: undefined,
x: 200,
y: 120,
z: -600
}, {
mesh: undefined,
x: -400,
y: 120,
z: -1400
},
]
var clock = new THREE.Clock();
var webglContainer = document.getElementById('webgl-container');
var $cowNaz = $('#cow-naz');
var milkBoxStatus = 0; // 装满级别 1 2 3
var milkBoxLoading = false;
var timeHandle;
var cowFile;
var walkCowFile;
var grassFile;
// 函数定义---------------------------------
function init() {
var scalePoint = 1;
var animations;
var animation;
//- 创建场景
scene = new THREE.Scene();
//- 创建相机
camera = new THREE.PerspectiveCamera( 75, window.innerWidth / window.innerHeight, 0.1, 1000000 );
camera.position.z = 550;
camera.position.y = 380;
camera.position.x = 30;
// camera.lookAt(scene.position);
//- 渲染
renderer = new THREE.WebGLRenderer({antialias: false, alpha: true});
renderer.setPixelRatio( window.devicePixelRatio );
renderer.setSize( window.innerWidth, window.innerHeight );
renderer.shadowMap.enabled = true;
renderer.shadowMap.type = THREE.PCFSoftShadowMap;
renderer.domElement.className = 'webgl-container';
webglContainer.appendChild(renderer.domElement);
// - 平面坐標系
var CoSystem = new THREEex.CoSystem(500, 50, 0x000000);
line = CoSystem.create();
scene.add(line);
//- gltf 3d模型导入
loader = new THREE.GLTFLoader();
loader.setCrossOrigin('https://ossgw.alicdn.com');
var shanurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/51ff6704e19375613c3d4d3563348b7f.gltf';
var grassurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/5e6c2c4bb052ef7562b52654c5635127.gltf'
var bburl = 'https://ossgw.alicdn.com/tmall-c3/tmx/7554d11d494d79413fc665e9ef140aa6.gltf'
// var walkCowUrl = 'https://ossgw.alicdn.com/tmall-c3/tmx/3972247d3c4e96d1ac7e83a173e3a331.gltf'; // 1
// var walkCowUrl = 'https://ossgw.alicdn.com/tmall-c3/tmx/95628df6d8a8dc3adc3c41b97ba2e49c.gltf'; // 2
var walkCowUrl = 'https://ossgw.alicdn.com/tmall-c3/tmx/15e972f4cc71db07fee122da7a125e5b.gltf'; // 3
var cowurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/2f17ddef947a7b6c702af69ff0e5b95f.gltf';
var doorurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/203247ec660952407695fdfaf45812af.gltf';
var demourl = 'https://ossgw.alicdn.com/tmall-c3/tmx/25ed65d4e9684567962230671512f731.gltf'
var lanurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/1e1dfc4da8dfe2d7f14f23f0996c7feb.gltf'
var daiurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/e68183de37ea4bed1787f6051b1d1f94.gltf'
var douurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/0ca2926cbf4bc664ff00b03c1a5d1f66.gltf'
var fishurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/03807648cf70d99a7c1d3d634a2d4ea3.gltf';
var fishActiveurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/bb90ddfe2542267c142e892ab91f60ad.gltf';
var fishBowUrl = 'https://ossgw.alicdn.com/tmall-c3/tmx/c5e934aae17373e927fe98aaf1f71767.gltf'
// cow
// loader.load(cowurl, function(data) {
// var scalePoint = 1;
// var animations;
// var animation;
// gltf = data;
// cow = gltf.scene;
// cow.position.set(650, 240, 180);
// // cow.position.set(0, 0, -240);
// cow.rotation.y = -Math.PI / 2;
// cow.scale.set(scalePoint, scalePoint, scalePoint);
// animations = data.animations;
// if (animations && animations.length) {
// cowMixer = new THREE.AnimationMixer(cow);
// for (var i = 0; i < animations.length; i++) {
// var animation = animations[i];
// cowMixer.clipAction(animation).play();
// }
// }
// // scene.add(cow);
// })
cow = cowFile.scene;
cow.position.set(650, 240, 180);
// cow.position.set(0, 0, -240);
cow.rotation.y = -Math.PI / 2;
cow.scale.set(scalePoint, scalePoint, scalePoint);
animations = cowFile.animations;
if (animations && animations.length) {
cowMixer = new THREE.AnimationMixer(cow);
for (var i = 0; i < animations.length; i++) {
var animation = animations[i];
cowMixer.clipAction(animation).play();
}
}
// loader.load(walkCowUrl, function(data) {
// var scalePoint = 1;
// var animations;
// var animation;
// gltf = data;
// walkCow = gltf.scene;
// walkCow.position.set(650, 240, 180);
// walkCow.rotation.y = -Math.PI / 2;
// walkCow.scale.set(scalePoint, scalePoint, scalePoint);
// animations = data.animations;
// if (animations && animations.length) {
// walkCowMixer = new THREE.AnimationMixer(walkCow);
// for (var i = 0; i < animations.length; i++) {
// var animation = animations[i];
// walkCowMixer.clipAction(animation).play();
// }
// }
// scene.add(walkCow);
// cowWalkIn();
// })
walkCow = walkCowFile.scene;
walkCow.position.set(650, 240, 180);
walkCow.rotation.y = -Math.PI / 2;
walkCow.scale.set(scalePoint, scalePoint, scalePoint);
animations = walkCowFile.animations;
if (animations && animations.length) {
walkCowMixer = new THREE.AnimationMixer(walkCow);
for (var i = 0; i < animations.length; i++) {
var animation = animations[i];
walkCowMixer.clipAction(animation).play();
}
}
scene.add(walkCow);
cowWalkIn();
// loader.load(grassurl, function(data) {
// var scalePoint = .005;
// var animations;
// var animation;
// gltf = data;
// grass = gltf.scene;
// window.wgrass = grass;
// grass.scale.set(scalePoint, scalePoint, scalePoint);
// for (var i = grassList.length - 1; i >= 0; i--) {
// grassList[i].mesh = grass.clone();
// grassList[i].mesh.position.set(grassList[i].x, grassList[i].y, grassList[i].z)
// scene.add(grassList[i].mesh);
// }
// // 草从小变大
// new TWEEN.Tween({scalePoint: .01})
// .to({scalePoint: .4}, 2000)
// .onUpdate(function() {
// // console.log('scalePoint loop: ', this);
// var scalePoint = this.scalePoint;
// for (var i = grassList.length - 1; i >= 0; i--) {
// grassList[i].mesh.scale.set(scalePoint, scalePoint, scalePoint);
// }
// })
// .start();
// new TWEEN.Tween(this)
// .to({}, 4000)
// .onUpdate(function() {
// render();
// })
// .start();
// })
scalePoint = 0.005;
grass = grassFile.scene;
grass.scale.set(scalePoint, scalePoint, scalePoint);
for (var i = grassList.length - 1; i >= 0; i--) {
grassList[i].mesh = grass.clone();
grassList[i].mesh.position.set(grassList[i].x, grassList[i].y, grassList[i].z)
scene.add(grassList[i].mesh);
}
// 草从小变大
new TWEEN.Tween({scalePoint: .01})
.to({scalePoint: .4}, 2000)
.onUpdate(function() {
// console.log('scalePoint loop: ', this);
var scalePoint = this.scalePoint;
for (var i = grassList.length - 1; i >= 0; i--) {
grassList[i].mesh.scale.set(scalePoint, scalePoint, scalePoint);
}
})
.start();
new TWEEN.Tween(this)
.to({}, 4000)
.onUpdate(function() {
render();
})
.start();
//- 环境灯
ambientLight = new THREE.AmbientLight(0xffffff);
scene.add(ambientLight);
//- 直射灯
// var directionalLight = new THREE.DirectionalLight( 0xdddddd );
// directionalLight.position.set( 0, 0, 1 ).normalize();
// scene.add( directionalLight );
// //- 点灯
// var light = new THREE.PointLight(0xFFFFFF);
// light.position.set(50000, 50000, 50000);
// scene.add(light);
//- 绑定窗口大小，自适应
var threeexResize = new THREEex.WindowResize(renderer, camera);
//- threejs 的控制器
// var controls = new THREE.OrbitControls( camera, renderer.domElement );
// controls.target = new THREE.Vector3(0,15,0);
//- controls.maxPolarAngle = Math.PI / 2;
//- controls.addEventListener( 'change', function() { renderer.render(scene, camera); } ); // add this only if there is no animation loop (requestAnimationFrame)
// 监听挤奶事件
$cowNaz.on('click', function() {
console.log('click naz', milkBoxLoading);
if (milkBoxLoading === true) return;
milkBoxLoading = true;
milkBoxStatus++;
// console.log('click milk', milkBoxStatus);
// addMilk();
addMilk2();
startFallMilk();
})
}
// 显示空白瓶子
function showEmptyMilk() {
var $milkBox = $('.milkbox');
$milkBox.animate({
bottom: '-140px'
}, 2000);
}
// 显示挤奶那妞
function showCowNaz() {
$cowNaz.show();
}
// showCowNaz();
// showEmptyMilk();
function cowWalkIn() {
cowStatus = 'walking';
// 头部先进 最后到
var headIn = new TWEEN.Tween(walkCow.position)
.to({
x: 320
}, 6000)
.delay(1000)
// .easing(TWEEN.Easing.Exponential.InOut)
var legIn = new TWEEN.Tween(walkCow.position)
.to({
x: -250
}, 3500)
.onComplete(function() {
cowStatus = 'standing'
})
.delay(2000);
var downCamera = new TWEEN.Tween(camera.position)
.to({
z: 540,
y: 250,
x: 0
}, 1000)
.easing(TWEEN.Easing.Exponential.InOut)
.onStart(function() {
showEmptyMilk();
})
.onComplete(function() {
showCowNaz()
})
legIn.chain(downCamera);
headIn.chain(legIn);
headIn.start();
new TWEEN.Tween(this)
.to({}, 4000 * 2)
.onUpdate(function() {
render();
})
.start();
}
// 合并图挤奶
function addMilk2() {
var anim;
var milkID = '#milkbox' + milkBoxStatus;
$('.milkbox').addClass('hide');
$('' + milkID).removeClass('hide');
if (loopAnim) {
loopAnim.stop();
}
anim = frameAnimation.anims($('' + milkID), 5625, 25, 2, 1, function() {
if (milkBoxStatus === 3) {
$('.milkbox').hide();
$('#milkink').hide();
$cowNaz.hide();
showJinDian();
}
if (milkBoxStatus !== 3) {
loopMilk();
}
stopFallMilk();
milkBoxLoading = false;
});
anim.start();
}
// 循环播放最后8帧
function loopMilk() {
var milkID = '#milkbox' + milkBoxStatus;
if (loopAnim) {
loopAnim.stop();
}
console.log('loopMilk:', milkID);
loopAnim = frameAnimation.anims($('' + milkID), 5625, 25, 3, 0, function() {}, 18);
loopAnim.start();
}
// 滴落奶
function startFallMilk() {
$('#milkink').removeClass('hide');
if (!loopFallMilk) {
loopFallMilk = frameAnimation.anims($('#milkink'), 1875, 25, 1, 0);
}
loopFallMilk.start();
}
window.startFallMilk = startFallMilk;
function stopFallMilk() {
$('#milkink').addClass('hide');
loopFallMilk.stop(true);
}
function showJinDian() {
TWEEN.removeAll();
new TWEEN.Tween(camera.position)
.to({
z: 4000
}, 4000)
.onUpdate(function() {
var op = 1 - this.z / 4000;
$(webglContainer).css({opacity: op});
render();
})
.onComplete(function() {
var $milk = $("#milk");
$(webglContainer).hide();
$milk.animate({'bottom': '250px'}, 600);
})
.start();
}
function animate() {
requestAnimationFrame(animate);
// camera.lookAt(scene.position);
if (cowStatus === 'walking' && cowCur !== 'walking') {
walkCow.position = cow.position;
scene.add(walkCow);
scene.remove(cow);
cowCur = 'walking'
}
if (cowStatus === 'standing' && cowCur !== 'standing') {
// console.log('walkCow.position:', walkCow.position, cow.position);
cow.position = walkCow.position;
cow.position.x = walkCow.position.x;
cow.position.y = walkCow.position.y;
cow.position.z = walkCow.position.z;
scene.add(cow);
scene.remove(walkCow);
cowCur = 'standing';
// console.log('walkCow.position:', walkCow.position, cow.position);
}
if (cowMixer && cowCur === 'standing') {
cowMixer.update(clock.getDelta());
}
if (walkCowMixer && cowCur === 'walking') {
walkCowMixer.update(clock.getDelta());
}
TWEEN.update();
// stats.begin();
render();
// stats.end();
}
//- 循环体-渲染
function render() {
renderer.render( scene, camera );
}
// 加载图片
function preLoadImg(url) {
var def = $.Deferred();
var img = new Image();
img.src = url;
if (img.complete) {
def.resolve({
img: img,
url: url
})
}
img.onload = function() {
def.resolve({
img: img,
url: url
});
}
img.onerror = function() {
def.resolve({
img: null,
url: url
})
}
return def.promise();
}
// 加载单张图片
function loadImage(url, callback) {
var img = new Image(); //创建一个Image对象，实现图片的预下载
img.src = url;
if (img.complete) { // 如果图片已经存在于浏览器缓存，直接调用回调函数
callback.call(img);
return; // 直接返回，不用再处理onload事件
}
img.onload = function () { //图片下载完毕时异步调用callback函数。
callback.call(img);//将回调函数的this替换为Image对象
};
}
// 加载所有图片
function loadAllImage(imgList) {
var defList = [];
var i = 0;
var len;
var def = $.Deferred();
for (i = 0, len = imgList.length; i < len; i++) {
defList[i] = preLoadImg(imgList[i])
}
$.when.apply(this, defList)
.then(function() {
var retData = Array.prototype.slice.apply(arguments);
def.resolve(retData);
})
return def.promise();
}
// 隐藏加载
function hideLoading() {
$('#loading').hide();
}
// 3d模型def 加载
function loadGltf(url) {
var def = $.Deferred();
var loader = new THREE.GLTFLoader();
loader.setCrossOrigin('https://ossgw.alicdn.com');
loader.load(url, function(data) {
def.resolve(data);
})
return def.promise();
}
// 加载所有3d模型
function loadAllGltf(list) {
var defList = [];
var i = 0;
var len;
var def = $.Deferred();
for (i = 0, len = list.length; i < len; i++) {
defList[i] = loadGltf(list[i])
}
$.when.apply(this, defList)
.then(function() {
var retData = Array.prototype.slice.apply(arguments);
def.resolve(retData);
})
return def.promise();
}
// 加载雪山
function loadCowGltf() {
var def = $.Deferred();
var shanurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/51ff6704e19375613c3d4d3563348b7f.gltf';
var grassurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/5e6c2c4bb052ef7562b52654c5635127.gltf'
var bburl = 'https://ossgw.alicdn.com/tmall-c3/tmx/7554d11d494d79413fc665e9ef140aa6.gltf'
// var walkCowUrl = 'https://ossgw.alicdn.com/tmall-c3/tmx/3972247d3c4e96d1ac7e83a173e3a331.gltf'; // 1
var walkCowUrl = 'https://ossgw.alicdn.com/tmall-c3/tmx/95628df6d8a8dc3adc3c41b97ba2e49c.gltf'; // 2
// var walkCowUrl = 'https://ossgw.alicdn.com/tmall-c3/tmx/15e972f4cc71db07fee122da7a125e5b.gltf'; // 3
var cowurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/2f17ddef947a7b6c702af69ff0e5b95f.gltf';
var doorurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/203247ec660952407695fdfaf45812af.gltf';
var demourl = 'https://ossgw.alicdn.com/tmall-c3/tmx/25ed65d4e9684567962230671512f731.gltf'
var lanurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/1e1dfc4da8dfe2d7f14f23f0996c7feb.gltf'
var daiurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/e68183de37ea4bed1787f6051b1d1f94.gltf'
var douurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/0ca2926cbf4bc664ff00b03c1a5d1f66.gltf'
var fishurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/03807648cf70d99a7c1d3d634a2d4ea3.gltf';
var fishActiveurl = 'https://ossgw.alicdn.com/tmall-c3/tmx/bb90ddfe2542267c142e892ab91f60ad.gltf';
var fishBowUrl = 'https://ossgw.alicdn.com/tmall-c3/tmx/c5e934aae17373e927fe98aaf1f71767.gltf'
$.when(loadGltf(cowurl), loadGltf(walkCowUrl), loadGltf(grassurl))
.then(function(cowData, walkCowData, grassData) {
cowFile = cowData;
walkCowFile = walkCowData;
grassFile = grassData
def.resolve([cowurl, walkCowUrl, grassurl]);
})
return def.promise();
}
// 函数定义---------------------------------
// 开始-----------------------
var imgList = [
'/threejs/static/img/canvas_milk_out.png',
'/threejs/static/img/canvas_milk1.png',
'/threejs/static/img/canvas_milk2.png',
'/threejs/static/img/canvas_milk3.png',
'/threejs/static/img/box.png',
'/threejs/static/img/fly.png'
]
loadAllImage(imgList)
.then(function(imgData) {
loadCowGltf()
.then(function(gltfdata) {
hideLoading();
main();
})
})
function main() {
init();
animate();
}
// 开始----------------------- |
version https://git-lfs.github.com/spec/v1
oid sha256:012c0c10efb1958941ed2fd9f393df39f1ae6f76369bf56e500e39ade0496295
size 8392
|
/**
* Инициализация модуля.
*/
/*global define*/
define(['./poke-control', './poke-history', 'jquery'], function (pokeControl, pokeHistory, $) {
'use strict';
var pokeSettings = {
pokeControl: {
selector: '.poke-control-container',
template: '<form class="form"><div class="form-group"><label for="bdoChannel">Канал:</label><select class="form-control" name="bdoChannel" id="bdoChannel"></select></div><div class="form-group"><label for="bdoQuest">Квест:</label><select class="form-control" name="bdoQuest" id="bdoQuest"></select></div><button class="btn btn-success">Отправить</button></form>'
},
pokeHistory: {
selector: '.poke-history-container',
template: '<table id="eventsHistory" class="table table-condensed table-hover table-striped"><thead><tr><th data-column-id="startDate">Начало</th><th data-column-id="channel" data-type="numeric">Канал</th><th data-column-id="event">Событие</th></tr></thead></table>',
tableSelector: '#eventsHistory'
}
},
create;
create = function (options) {
pokeSettings = $.extend(pokeSettings, options);
pokeControl.initialize(pokeSettings.pokeControl);
pokeHistory.initialize(pokeSettings.pokeHistory);
};
return {
create: create
};
}); |
var list = {
"Manual": {
"Getting Started": {
"Creating a scene": "manual/introduction/Creating-a-scene",
"Import via modules": "manual/introduction/Import-via-modules",
"Browser support": "manual/introduction/Browser-support",
"WebGL compatibility check": "manual/introduction/WebGL-compatibility-check",
"How to run things locally": "manual/introduction/How-to-run-things-locally",
"Drawing Lines": "manual/introduction/Drawing-lines",
"Creating Text": "manual/introduction/Creating-text",
"Migration Guide": "manual/introduction/Migration-guide",
"Code Style Guide": "manual/introduction/Code-style-guide",
"FAQ": "manual/introduction/FAQ",
"Useful links": "manual/introduction/Useful-links"
},
"Next Steps": {
"How to update things": "manual/introduction/How-to-update-things",
"Matrix transformations": "manual/introduction/Matrix-transformations",
"Animation System": "manual/introduction/Animation-system"
},
"Build Tools": {
"Testing with NPM": "manual/buildTools/Testing-with-NPM"
}
},
"Reference": {
"Animation": {
"AnimationAction": "api/animation/AnimationAction",
"AnimationClip": "api/animation/AnimationClip",
"AnimationMixer": "api/animation/AnimationMixer",
"AnimationObjectGroup": "api/animation/AnimationObjectGroup",
"AnimationUtils": "api/animation/AnimationUtils",
"KeyframeTrack": "api/animation/KeyframeTrack",
"PropertyBinding": "api/animation/PropertyBinding",
"PropertyMixer": "api/animation/PropertyMixer"
},
"Animation / Tracks": {
"BooleanKeyframeTrack": "api/animation/tracks/BooleanKeyframeTrack",
"ColorKeyframeTrack": "api/animation/tracks/ColorKeyframeTrack",
"NumberKeyframeTrack": "api/animation/tracks/NumberKeyframeTrack",
"QuaternionKeyframeTrack": "api/animation/tracks/QuaternionKeyframeTrack",
"StringKeyframeTrack": "api/animation/tracks/StringKeyframeTrack",
"VectorKeyframeTrack": "api/animation/tracks/VectorKeyframeTrack"
},
"Audio": {
"Audio": "api/audio/Audio",
"AudioAnalyser": "api/audio/AudioAnalyser",
"AudioContext": "api/audio/AudioContext",
"AudioListener": "api/audio/AudioListener",
"PositionalAudio": "api/audio/PositionalAudio"
},
"Cameras": {
"Camera": "api/cameras/Camera",
"CubeCamera": "api/cameras/CubeCamera",
"OrthographicCamera": "api/cameras/OrthographicCamera",
"PerspectiveCamera": "api/cameras/PerspectiveCamera",
"StereoCamera": "api/cameras/StereoCamera"
},
"Constants": {
"Animation": "api/constants/Animation",
"Core": "api/constants/Core",
"CustomBlendingEquation": "api/constants/CustomBlendingEquations",
"DrawModes": "api/constants/DrawModes",
"Materials": "api/constants/Materials",
"Renderer": "api/constants/Renderer",
"Textures": "api/constants/Textures"
},
"Core": {
"BufferAttribute": "api/core/BufferAttribute",
"BufferGeometry": "api/core/BufferGeometry",
"Clock": "api/core/Clock",
"DirectGeometry": "api/core/DirectGeometry",
"EventDispatcher": "api/core/EventDispatcher",
"Face3": "api/core/Face3",
"Geometry": "api/core/Geometry",
"InstancedBufferAttribute": "api/core/InstancedBufferAttribute",
"InstancedBufferGeometry": "api/core/InstancedBufferGeometry",
"InstancedInterleavedBuffer": "api/core/InstancedInterleavedBuffer",
"InterleavedBuffer": "api/core/InterleavedBuffer",
"InterleavedBufferAttribute": "api/core/InterleavedBufferAttribute",
"Layers": "api/core/Layers",
"Object3D": "api/core/Object3D",
"Raycaster": "api/core/Raycaster",
"Uniform": "api/core/Uniform"
},
"Core / BufferAttributes": {
"BufferAttribute Types": "api/core/bufferAttributeTypes/BufferAttributeTypes"
},
"Deprecated": {
"DeprecatedList": "api/deprecated/DeprecatedList"
},
"Extras": {
"Earcut": "api/extras/Earcut",
"ShapeUtils": "api/extras/ShapeUtils"
},
"Extras / Core": {
"Curve": "api/extras/core/Curve",
"CurvePath": "api/extras/core/CurvePath",
"Font": "api/extras/core/Font",
"Interpolations": "api/extras/core/Interpolations",
"Path": "api/extras/core/Path",
"Shape": "api/extras/core/Shape",
"ShapePath": "api/extras/core/ShapePath"
},
"Extras / Curves": {
"ArcCurve": "api/extras/curves/ArcCurve",
"CatmullRomCurve3": "api/extras/curves/CatmullRomCurve3",
"CubicBezierCurve": "api/extras/curves/CubicBezierCurve",
"CubicBezierCurve3": "api/extras/curves/CubicBezierCurve3",
"EllipseCurve": "api/extras/curves/EllipseCurve",
"LineCurve": "api/extras/curves/LineCurve",
"LineCurve3": "api/extras/curves/LineCurve3",
"QuadraticBezierCurve": "api/extras/curves/QuadraticBezierCurve",
"QuadraticBezierCurve3": "api/extras/curves/QuadraticBezierCurve3",
"SplineCurve": "api/extras/curves/SplineCurve"
},
"Extras / Objects": {
"ImmediateRenderObject": "api/extras/objects/ImmediateRenderObject",
},
"Geometries": {
"BoxBufferGeometry": "api/geometries/BoxBufferGeometry",
"BoxGeometry": "api/geometries/BoxGeometry",
"CircleBufferGeometry": "api/geometries/CircleBufferGeometry",
"CircleGeometry": "api/geometries/CircleGeometry",
"ConeBufferGeometry": "api/geometries/ConeBufferGeometry",
"ConeGeometry": "api/geometries/ConeGeometry",
"CylinderBufferGeometry": "api/geometries/CylinderBufferGeometry",
"CylinderGeometry": "api/geometries/CylinderGeometry",
"DodecahedronBufferGeometry": "api/geometries/DodecahedronBufferGeometry",
"DodecahedronGeometry": "api/geometries/DodecahedronGeometry",
"EdgesGeometry": "api/geometries/EdgesGeometry",
"ExtrudeBufferGeometry": "api/geometries/ExtrudeBufferGeometry",
"ExtrudeGeometry": "api/geometries/ExtrudeGeometry",
"IcosahedronBufferGeometry": "api/geometries/IcosahedronBufferGeometry",
"IcosahedronGeometry": "api/geometries/IcosahedronGeometry",
"LatheBufferGeometry": "api/geometries/LatheBufferGeometry",
"LatheGeometry": "api/geometries/LatheGeometry",
"OctahedronBufferGeometry": "api/geometries/OctahedronBufferGeometry",
"OctahedronGeometry": "api/geometries/OctahedronGeometry",
"ParametricBufferGeometry": "api/geometries/ParametricBufferGeometry",
"ParametricGeometry": "api/geometries/ParametricGeometry",
"PlaneBufferGeometry": "api/geometries/PlaneBufferGeometry",
"PlaneGeometry": "api/geometries/PlaneGeometry",
"PolyhedronBufferGeometry": "api/geometries/PolyhedronBufferGeometry",
"PolyhedronGeometry": "api/geometries/PolyhedronGeometry",
"RingBufferGeometry": "api/geometries/RingBufferGeometry",
"RingGeometry": "api/geometries/RingGeometry",
"ShapeBufferGeometry": "api/geometries/ShapeBufferGeometry",
"ShapeGeometry": "api/geometries/ShapeGeometry",
"SphereBufferGeometry": "api/geometries/SphereBufferGeometry",
"SphereGeometry": "api/geometries/SphereGeometry",
"TetrahedronBufferGeometry": "api/geometries/TetrahedronBufferGeometry",
"TetrahedronGeometry": "api/geometries/TetrahedronGeometry",
"TextBufferGeometry": "api/geometries/TextBufferGeometry",
"TextGeometry": "api/geometries/TextGeometry",
"TorusBufferGeometry": "api/geometries/TorusBufferGeometry",
"TorusGeometry": "api/geometries/TorusGeometry",
"TorusKnotBufferGeometry": "api/geometries/TorusKnotBufferGeometry",
"TorusKnotGeometry": "api/geometries/TorusKnotGeometry",
"TubeBufferGeometry": "api/geometries/TubeBufferGeometry",
"TubeGeometry": "api/geometries/TubeGeometry",
"WireframeGeometry": "api/geometries/WireframeGeometry"
},
"Helpers": {
"ArrowHelper": "api/helpers/ArrowHelper",
"AxesHelper": "api/helpers/AxesHelper",
"BoxHelper": "api/helpers/BoxHelper",
"Box3Helper": "api/helpers/Box3Helper",
"CameraHelper": "api/helpers/CameraHelper",
"DirectionalLightHelper": "api/helpers/DirectionalLightHelper",
"FaceNormalsHelper": "api/helpers/FaceNormalsHelper",
"GridHelper": "api/helpers/GridHelper",
"PolarGridHelper": "api/helpers/PolarGridHelper",
"HemisphereLightHelper": "api/helpers/HemisphereLightHelper",
"PlaneHelper": "api/helpers/PlaneHelper",
"PointLightHelper": "api/helpers/PointLightHelper",
"RectAreaLightHelper": "api/helpers/RectAreaLightHelper",
"SkeletonHelper": "api/helpers/SkeletonHelper",
"SpotLightHelper": "api/helpers/SpotLightHelper",
"VertexNormalsHelper": "api/helpers/VertexNormalsHelper"
},
"Lights": {
"AmbientLight": "api/lights/AmbientLight",
"DirectionalLight": "api/lights/DirectionalLight",
"HemisphereLight": "api/lights/HemisphereLight",
"Light": "api/lights/Light",
"PointLight": "api/lights/PointLight",
"RectAreaLight": "api/lights/RectAreaLight",
"SpotLight": "api/lights/SpotLight"
},
"Lights / Shadows": {
"DirectionalLightShadow": "api/lights/shadows/DirectionalLightShadow",
"LightShadow": "api/lights/shadows/LightShadow",
"SpotLightShadow": "api/lights/shadows/SpotLightShadow"
},
"Loaders": {
"AnimationLoader": "api/loaders/AnimationLoader",
"AudioLoader": "api/loaders/AudioLoader",
"BufferGeometryLoader": "api/loaders/BufferGeometryLoader",
"Cache": "api/loaders/Cache",
"CompressedTextureLoader": "api/loaders/CompressedTextureLoader",
"CubeTextureLoader": "api/loaders/CubeTextureLoader",
"DataTextureLoader": "api/loaders/DataTextureLoader",
"FileLoader": "api/loaders/FileLoader",
"FontLoader": "api/loaders/FontLoader",
"ImageBitmapLoader": "api/loaders/ImageBitmapLoader",
"ImageLoader": "api/loaders/ImageLoader",
"JSONLoader": "api/loaders/JSONLoader",
"Loader": "api/loaders/Loader",
"LoaderUtils": "api/loaders/LoaderUtils",
"MaterialLoader": "api/loaders/MaterialLoader",
"ObjectLoader": "api/loaders/ObjectLoader",
"TextureLoader": "api/loaders/TextureLoader"
},
"Loaders / Managers": {
"DefaultLoadingManager": "api/loaders/managers/DefaultLoadingManager",
"LoadingManager": "api/loaders/managers/LoadingManager"
},
"Materials": {
"LineBasicMaterial": "api/materials/LineBasicMaterial",
"LineDashedMaterial": "api/materials/LineDashedMaterial",
"Material": "api/materials/Material",
"MeshBasicMaterial": "api/materials/MeshBasicMaterial",
"MeshDepthMaterial": "api/materials/MeshDepthMaterial",
"MeshLambertMaterial": "api/materials/MeshLambertMaterial",
"MeshNormalMaterial": "api/materials/MeshNormalMaterial",
"MeshPhongMaterial": "api/materials/MeshPhongMaterial",
"MeshPhysicalMaterial": "api/materials/MeshPhysicalMaterial",
"MeshStandardMaterial": "api/materials/MeshStandardMaterial",
"MeshToonMaterial": "api/materials/MeshToonMaterial",
"PointsMaterial": "api/materials/PointsMaterial",
"RawShaderMaterial": "api/materials/RawShaderMaterial",
"ShaderMaterial": "api/materials/ShaderMaterial",
"ShadowMaterial": "api/materials/ShadowMaterial",
"SpriteMaterial": "api/materials/SpriteMaterial"
},
"Math": {
"Box2": "api/math/Box2",
"Box3": "api/math/Box3",
"Color": "api/math/Color",
"Cylindrical": "api/math/Cylindrical",
"Euler": "api/math/Euler",
"Frustum": "api/math/Frustum",
"Interpolant": "api/math/Interpolant",
"Line3": "api/math/Line3",
"Math": "api/math/Math",
"Matrix3": "api/math/Matrix3",
"Matrix4": "api/math/Matrix4",
"Plane": "api/math/Plane",
"Quaternion": "api/math/Quaternion",
"Ray": "api/math/Ray",
"Sphere": "api/math/Sphere",
"Spherical": "api/math/Spherical",
"Triangle": "api/math/Triangle",
"Vector2": "api/math/Vector2",
"Vector3": "api/math/Vector3",
"Vector4": "api/math/Vector4"
},
"Math / Interpolants": {
"CubicInterpolant": "api/math/interpolants/CubicInterpolant",
"DiscreteInterpolant": "api/math/interpolants/DiscreteInterpolant",
"LinearInterpolant": "api/math/interpolants/LinearInterpolant",
"QuaternionLinearInterpolant": "api/math/interpolants/QuaternionLinearInterpolant"
},
"Objects": {
"Bone": "api/objects/Bone",
"Group": "api/objects/Group",
"Line": "api/objects/Line",
"LineLoop": "api/objects/LineLoop",
"LineSegments": "api/objects/LineSegments",
"LOD": "api/objects/LOD",
"Mesh": "api/objects/Mesh",
"Points": "api/objects/Points",
"Skeleton": "api/objects/Skeleton",
"SkinnedMesh": "api/objects/SkinnedMesh",
"Sprite": "api/objects/Sprite"
},
"Renderers": {
"WebGLRenderer": "api/renderers/WebGLRenderer",
"WebGLRenderTarget": "api/renderers/WebGLRenderTarget",
"WebGLRenderTargetCube": "api/renderers/WebGLRenderTargetCube"
},
"Renderers / Shaders": {
"ShaderChunk": "api/renderers/shaders/ShaderChunk",
"ShaderLib": "api/renderers/shaders/ShaderLib",
"UniformsLib": "api/renderers/shaders/UniformsLib",
"UniformsUtils": "api/renderers/shaders/UniformsUtils"
},
"Scenes": {
"Fog": "api/scenes/Fog",
"FogExp2": "api/scenes/FogExp2",
"Scene": "api/scenes/Scene"
},
"Textures": {
"CanvasTexture": "api/textures/CanvasTexture",
"CompressedTexture": "api/textures/CompressedTexture",
"CubeTexture": "api/textures/CubeTexture",
"DataTexture": "api/textures/DataTexture",
"DepthTexture": "api/textures/DepthTexture",
"Texture": "api/textures/Texture",
"VideoTexture": "api/textures/VideoTexture"
}
},
"Examples": {
"Controls": {
"OrbitControls": "examples/controls/OrbitControls"
},
"Geometries": {
"ConvexBufferGeometry": "examples/geometries/ConvexBufferGeometry",
"ConvexGeometry": "examples/geometries/ConvexGeometry",
"DecalGeometry": "examples/geometries/DecalGeometry"
},
"Loaders": {
"BabylonLoader": "examples/loaders/BabylonLoader",
"GLTFLoader": "examples/loaders/GLTFLoader",
"MTLLoader": "examples/loaders/MTLLoader",
"OBJLoader": "examples/loaders/OBJLoader",
"OBJLoader2": "examples/loaders/OBJLoader2",
"LoaderSupport": "examples/loaders/LoaderSupport",
"PCDLoader": "examples/loaders/PCDLoader",
"PDBLoader": "examples/loaders/PDBLoader",
"SVGLoader": "examples/loaders/SVGLoader",
"TGALoader": "examples/loaders/TGALoader",
"PRWMLoader": "examples/loaders/PRWMLoader"
},
"Objects": {
"Lensflare": "examples/objects/Lensflare",
},
"Exporters": {
"GLTFExporter": "examples/exporters/GLTFExporter"
},
"Plugins": {
"LookupTable": "examples/Lut",
"SpriteCanvasMaterial": "examples/SpriteCanvasMaterial"
},
"QuickHull": {
"Face": "examples/quickhull/Face",
"HalfEdge": "examples/quickhull/HalfEdge",
"QuickHull": "examples/quickhull/QuickHull",
"VertexNode": "examples/quickhull/VertexNode",
"VertexList": "examples/quickhull/VertexList"
},
"Renderers": {
"CanvasRenderer": "examples/renderers/CanvasRenderer",
"CSS3DRenderer": "examples/renderers/CSS3DRenderer",
"CSS2DRenderer": "examples/renderers/CSS2DRenderer"
},
"Utils": {
"BufferGeometryUtils": "examples/BufferGeometryUtils",
"SceneUtils": "examples/utils/SceneUtils"
}
},
"Developer Reference": {
"Polyfills": {
"Polyfills": "api/Polyfills"
},
"WebGLRenderer": {
"WebGLProgram": "api/renderers/webgl/WebGLProgram",
"WebGLShader": "api/renderers/webgl/WebGLShader",
"WebGLState": "api/renderers/webgl/WebGLState"
},
"WebGLRenderer / Plugins": {
"SpritePlugin": "api/renderers/webgl/plugins/SpritePlugin"
}
}
};
|
db.groups.update(
{lname: "marrasputki"},
{$set:{users: ["Jörö"], description: "Marrasputki 2018"}}) |
document.body.onkeydown = function( e ) {
var keys = {
37: 'left',
39: 'right',
40: 'down',
38: 'rotate',
80: 'pause'
};
if ( typeof keys[ e.keyCode ] != 'undefined' ) {
keyPress( keys[ e.keyCode ] );
render();
}
};
|
module.exports = {
'plugins': {
'local': {
'browsers': [ 'chrome', 'firefox' ]
}
}
}
|
// JScript File
var borderstyle
function editorOn(divid){
$('#'+divid).parent().parent().find(' >*:last-child img').css('visibility','hidden');
borderstyle = $('#'+divid).parent().parent().css('border');
$('#'+divid).parent().parent().css('border','')
}
function editorOff(divid){
$('#'+divid).parent().parent().find(' >*:last-child img').css('visibility','');
$('#'+divid).parent().parent().css('border',borderstyle);
} |
(function () {
'use strict';
// var matcher = require('../../lib/matchUsers');
angular
.module('chat.routes')
.config(routeConfig);
routeConfig.$inject = ['$stateProvider'];
var c = "/room";// need to make this somehow return the correct room
function routeConfig($stateProvider) {
$stateProvider
.state('chat', {
url: c,
templateUrl: '/modules/chat/client/views/chat.client.view.html',
controller: 'ChatController',
controllerAs: 'vm',
data: {
roles: ['user', 'admin'],
pageTitle: 'Chat'
}
});
}
}());
|
import React from 'react';
import { shallow } from 'enzyme';
import { expect } from 'chai';
import sinon from 'sinon';
import RadioInput from './';
describe('RadioInput', () => {
let wrapper;
let value;
let style;
let onChange;
beforeEach(() => {
value = 'test';
style = { backgroundColor: 'blue' };
onChange = sinon.spy();
wrapper = shallow(
<RadioInput
style={style}
value={value}
onChange={onChange}
/>
);
});
it('should render a radio tag', () => {
expect(wrapper.find('radio')).to.have.length(1);
});
it('should have a style value set via the style prop', () => {
expect(wrapper.find('radio')).to.have.style('background-color', 'blue');
});
it('should have a value set via the value prop', () => {
expect(wrapper.find('radio').text()).to.equal(value);
});
it('should call onChange on change', () => {
wrapper.find('radio').simulate('change');
expect(onChange.calledOnce).to.equal(true);
});
}); |
/*global describe, beforeEach, it*/
'use strict';
var assert = require('assert');
describe('ttwebapp generator', function () {
it('can be imported without blowing up', function () {
var app = require('../app');
assert(app !== undefined);
});
});
|
//setup Dependencies
var connect = require('connect');
//Setup Express
var express = require('express');
var path = require('path');
let app = express();
var server = require('http').Server(app);
var io = require('socket.io')(server);
var keypress = require('keypress');
var port = (process.env.PORT || 8081);
var muted = false;
const debug = true;
app.set("view engine", "pug");
app.set("views", path.join(__dirname, "views"));
app.use(express.static(path.join(__dirname, "public")));
app.set('env', 'development');
server.listen(port);
var message = '';
var main_socket;
var auksalaq_mode = 'chatMode';
//Setup Socket.IO
io.on('connection', function(socket){
if(debug){
console.log('Client Connected');
}
main_socket = socket;
//start time
setInterval(sendTime, 1000);
//ceiling
socket.on('ceiling_newuser', function (data) {
if(debug){
console.log('new user added! ' + data.username);
console.log(data);
}
socket.emit('ceiling_user_confirmed', data);
socket.broadcast.emit('ceiling_user_confirmed', data);
});
//see NomadsMobileClient.js for data var
socket.on('ceiling_message', function(data){
socket.broadcast.emit('ceiling_proc_update',data); //send data to all clients for processing sketch
socket.broadcast.emit('ceiling_client_update',data); //send data back to all clients?
if(debug){
console.log(data);
}
});
//auksalaq
socket.on('auksalaq_newuser', function (data) {
if(debug){
console.log('new user added! ' + data.username);
console.log(data);
}
data.mode = auksalaq_mode;
data.muted = muted;
socket.emit('auksalaq_user_confirmed', data);
socket.broadcast.emit('auksalaq_user_confirmed', data);
});
//see NomadsMobileClient.js for data var
socket.on('auksalaq_message', function(data){
//socket.broadcast.emit('auksalaq_proc_update',data); //send data to all clients for processing sketch
socket.broadcast.emit('auksalaq_client_update',data);
socket.emit('auksalaq_client_update',data);
if(debug){
console.log(data);
}
});
//mode change from controller
socket.on('auksalaq_mode', function(data){
socket.broadcast.emit('auksalaq_mode', data);
auksalaq_mode = data;
if(debug){
console.log(data);
}
});
socket.on('mute_state', function(data){
muted = data;
socket.broadcast.emit('mute_state', data);
console.log(data);
});
//clocky
socket.on('clock_start', function(data){
socket.broadcast.emit('clock_start', data);
if(debug){
console.log(data);
}
});
socket.on('clock_stop', function(data){
socket.broadcast.emit('clock_stop', data);
if(debug){
console.log(data);
}
});
socket.on('clock_reset', function(data){
socket.broadcast.emit('clock_reset', data);
if(debug){
console.log("resettting clock");
}
});
/*
socket.on('begin_ceiling', function(){
;
});
socket.on('begin_auksalak', function(){
;
});
socket.on('stop_ceiling', function(){
;
});
socket.on('stop_auksalak', function(){
;
});
*/
socket.on('disconnect', function(){
if(debug){
console.log('Client Disconnected.');
}
});
});
///////////////////////////////////////////
// Routes //
///////////////////////////////////////////
/////// ADD ALL YOUR ROUTES HERE /////////
app.get('/', function(req,res){
//res.send('hello world');
res.render('index.pug', {
locals : {
title : 'Nomads'
,description: 'Nomads System'
,author: 'TThatcher'
,analyticssiteid: 'XXXXXXX'
,cache: 'false'
}
});
});
// The Ceiling Floats Away Routes
app.get('/ceiling', function(req,res){
res.render('ceiling/ceiling_client.pug', {
locals : {
title : 'The Ceiling Floats Away'
,description: 'The Ceiluing Floats Away'
,author: 'TThatcher'
,analyticssiteid: 'XXXXXXX'
}
});
});
app.get('/ceiling_display', function(req,res){
res.render('ceiling/ceiling_display.pug', {
locals : {
title : 'The Ceiling Floats Away'
,description: 'Ceiling Nomads message disply'
,author: 'TThatcher'
,analyticssiteid: 'XXXXXXX'
}
});
});
app.get('/ceiling_control', function(req,res){
res.render('ceiling/ceiling_control.pug', {
locals : {
title : 'The Ceiling Floats Away Control'
,description: 'Ceiling Nomads System Control'
,author: 'TThatcher'
,analyticssiteid: 'XXXXXXX'
}
});
});
// Auksalaq Routes
app.get('/auksalaq', function(req,res){
res.render('auksalaq/auksalaq_client.pug', {
locals : {
title : 'Auksalaq'
,description: 'Auksalaq Nomads System'
,author: 'TThatcher'
,analyticssiteid: 'XXXXXXX'
}
});
});
app.get('/auksalaq_display', function(req,res){
res.render('auksalaq/auksalaq_display.pug', {
locals : {
title : 'Auksalaq'
,description: 'Auksalaq Nomads message disply'
,author: 'TThatcher'
,analyticssiteid: 'XXXXXXX'
}
});
});
app.get('/auksalaq_control', function(req,res){
res.render('auksalaq/auksalaq_control.pug', {
locals : {
title : 'Auksalaq Control'
,description: 'Auksalaq Nomads System Control'
,author: 'TThatcher'
,analyticssiteid: 'XXXXXXX'
}
});
});
app.get('/auksalaq_clock', function(req,res){
res.render('auksalaq/auksalaq_clock.pug', {
locals : {
title : 'Auksalaq Clock'
,description: 'Auksalaq Nomads System Clock'
,author: 'TThatcher'
,analyticssiteid: 'XXXXXXX'
}
});
});
// catch 404 and forward to error handler
app.use(function(req, res, next) {
var err = new Error('Not Found '+req);
err.status = 404;
next(err);
});
// error handler
app.use(function(err, req, res, next) {
// set locals, only providing error in development
res.locals.message = err.message;
res.locals.error = req.app.get('env') === 'development' ? err : {};
// very basic!
if(debug){
console.error(err.stack);
}
// render the error page
res.status(err.status || 500);
res.render('404');
});
function NotFound(msg){
this.name = 'NotFound';
Error.call(this, msg);
Error.captureStackTrace(this, arguments.callee);
}
if(debug){
console.log('Listening on http://127.0.0.1:' + port );
}
//for testing
sendChat = function(data, type){
if(debug)
console.log("sending data ", data);
var messageToSend = {};
messageToSend.id = 123;
messageToSend.username = "Nomads_Server";
messageToSend.type = type;
messageToSend.messageText = data;
messageToSend.location = 0;
messageToSend.latitude = 0;
messageToSend.longitude = 0;
messageToSend.x = 0;
messageToSend.y = 0;
var date = new Date();
d = date.getMonth()+1+"."+date.getDate()+"."+date.getFullYear()+ " at " + date.getHours()+":"+date.getMinutes()+":"+date.getSeconds();
messageToSend.timestamp = d;
main_socket.broadcast.emit('auksalaq_client_update', messageToSend);
}
sendTime = function(){
var d = new Date();
main_socket.broadcast.emit('clock_update', d.getTime());
}
|
/**
* Created by Tivie on 12-11-2014.
*/
module.exports = function (grunt) {
// Project configuration.
var config = {
pkg: grunt.file.readJSON('package.json'),
concat: {
options: {
sourceMap: true,
banner: ';/*! <%= pkg.name %> <%= grunt.template.today("dd-mm-yyyy") %> */\n(function(){\n',
footer: '}).call(this);'
},
dist: {
src: [
'src/showdown.js',
'src/helpers.js',
'src/converter.js',
'src/subParsers/*.js',
'src/loader.js'
],
dest: 'dist/<%= pkg.name %>.js'
}
},
uglify: {
options: {
sourceMap: true,
banner: '/*! <%= pkg.name %> <%= grunt.template.today("dd-mm-yyyy") %> */\n'
},
dist: {
files: {
'dist/<%= pkg.name %>.min.js': ['<%= concat.dist.dest %>']
}
}
},
jshint: {
options: {
jshintrc: '.jshintrc'
},
files: [
'Gruntfile.js',
'src/**/*.js',
'test/**/*.js'
]
},
jscs: {
options: {
config: '.jscs.json'
},
files: {
src: [
'Gruntfile.js',
'src/**/*.js',
'test/**/*.js'
]
}
},
changelog: {
options: {
repository: 'http://github.com/showdownjs/showdown',
dest: 'CHANGELOG.md'
}
},
bump: {
options: {
files: ['package.json'],
updateConfigs: [],
commit: true,
commitMessage: 'Release version %VERSION%',
commitFiles: ['package.json'],
createTag: true,
tagName: '%VERSION%',
tagMessage: 'Version %VERSION%',
push: true,
pushTo: 'upstream',
gitDescribeOptions: '--tags --always --abbrev=1 --dirty=-d',
globalReplace: false,
prereleaseName: 'alpha',
regExp: false
}
},
simplemocha: {
node: {
src: 'test/node/**/*.js',
options: {
globals: ['should'],
timeout: 3000,
ignoreLeaks: false,
reporter: 'spec'
}
},
karlcow: {
src: 'test/node/testsuite.karlcow.js',
options: {
globals: ['should'],
timeout: 3000,
ignoreLeaks: false,
reporter: 'spec'
}
},
browser: {
src: 'test/browser/**/*.js',
options: {
reporter: 'spec'
}
}
}
};
grunt.initConfig(config);
require('load-grunt-tasks')(grunt);
grunt.registerTask('concatenate', ['concat']);
grunt.registerTask('lint', ['jshint', 'jscs']);
grunt.registerTask('test', ['lint', 'concat', 'simplemocha:node']);
grunt.registerTask('test-without-building', ['simplemocha:node']);
grunt.registerTask('build', ['test', 'uglify']);
grunt.registerTask('prep-release', ['build', 'changelog']);
// Default task(s).
grunt.registerTask('default', ['test']);
};
|
// Export modules to global scope as necessary (only for testing)
if (typeof process !== 'undefined' && process.title === 'node') {
// We are in node. Require modules.
expect = require('chai').expect;
sinon = require('sinon');
num = require('..');
isBrowser = false;
} else {
// We are in the browser. Set up variables like above using served js files.
expect = chai.expect;
// num and sinon already exported globally in the browser.
isBrowser = true;
} |
export var lusolveDocs = {
name: 'lusolve',
category: 'Algebra',
syntax: ['x=lusolve(A, b)', 'x=lusolve(lu, b)'],
description: 'Solves the linear system A * x = b where A is an [n x n] matrix and b is a [n] column vector.',
examples: ['a = [-2, 3; 2, 1]', 'b = [11, 9]', 'x = lusolve(a, b)'],
seealso: ['lup', 'slu', 'lsolve', 'usolve', 'matrix', 'sparse']
}; |
/*
Copyright (c) 2017, Dogan Yazar
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/**
* Remove commonly used diacritic marks from a string as these
* are not used in a consistent manner. Leave only ä, ö, å.
*/
var remove_diacritics = function(text) {
text = text.replace('à', 'a');
text = text.replace('À', 'A');
text = text.replace('á', 'a');
text = text.replace('Á', 'A');
text = text.replace('è', 'e');
text = text.replace('È', 'E');
text = text.replace('é', 'e');
text = text.replace('É', 'E');
return text;
};
// export the relevant stuff.
exports.remove_diacritics = remove_diacritics;
|
import { StyleSheet } from "react-native";
const styles = StyleSheet.create({
container: {
flex: 1,
justifyContent: "flex-start",
alignItems: "center",
backgroundColor: "#669999"
},
buttons: {
// flex: 0.15,
flexDirection: "row",
alignItems: "center",
marginVertical: 20
},
button: {
marginHorizontal: 20,
padding: 20,
backgroundColor: "#0D4D4D",
color: "white",
textAlign: "center"
},
selectedButton: {
backgroundColor: "#006699"
},
body: {
// flex: 0.8,
justifyContent: "flex-start",
alignItems: "center"
},
subTitle: {
marginVertical: 10
},
viewport: {
// flex: 1,
alignSelf: "center",
backgroundColor: "white"
}
});
export default styles;
|
var express = require('express');
var router = express.Router();
/* GET home page. */
router.get('/', function (req, res, next) {
res.render('index', { title: 'Express' });
});
//test canvas
router.get('/canvas', function (req, res, next) {
res.render('canvas');
});
module.exports = router;
|
'use strict';
module.exports = {
"definitions": {
"validation-error": {
"type": "object",
"description": "Validation error",
"properties": {
"param": {
"type": "string",
"description": "The parameter in error"
},
"msg": {
"type": "string",
"enum": ["invalid","required"],
"description": "The error code"
}
}
},
"validation-errors": {
"type": "array",
"description": "Validation errors",
"items": {
"$ref": "#/definitions/validation-error"
}
},
"system-error": {
"type": "object",
"description": "System error",
"properties": {
"error": {
"type": "string",
"description": "The error message"
}
}
}
}
}; |
version https://git-lfs.github.com/spec/v1
oid sha256:2e65db5b56d276f8bcf293bede932b782ec29e72a25125d3412f81315301ecc4
size 14066
|
import { subtract } from '../subtract';
describe('Core.subtract', () => {
test('Subtracts the second argument from the first', () => {
expect(subtract(10, 8)).toBe(2);
});
});
|
'use strict';
describe('AutoFormatter', function() {
var event = require('../polyfill/event');
var AutoFormatter = require('../src/auto-formatter');
var autoFormatter;
var inputNode;
var config = {
limitToMaxLength: true,
recurringPattern: false
};
before(function() {
inputNode = document.createElement('input');
document.body.appendChild(inputNode);
config.targetNode = inputNode;
autoFormatter = new AutoFormatter(config);
});
it('should return an function', function() {
assert.isFunction(AutoFormatter);
});
describe('invoked with new operator', function() {
it('should return an object with enableFormatting & disableFormatting method', function() {
assert.isObject(autoFormatter);
assert.isFunction(autoFormatter.enableFormatting);
assert.isFunction(autoFormatter.disableFormatting);
});
});
describe('new AutoFormatter()', function() {
describe('.enableFormatting', function() {
before(function() {
autoFormatter = new AutoFormatter(config);
inputNode.value = '1234567890';
inputNode.setAttribute('data-format', '(XXX) XXX-XXXX');
autoFormatter.enableFormatting();
});
it('should format 1234567890 in (XXX) XXX-XXXX format', function() {
assert.equal(inputNode.value, '(123) 456-7890');
});
it('should format if the keyCode is between 48 & 90 and 96 && 105', function() {
inputNode.value = '1234567890';
event.triggerKeyupEvent(inputNode, 48);
assert.equal(inputNode.value, '(123) 456-7890');
inputNode.value = '1234567890';
event.triggerKeyupEvent(inputNode, 96);
assert.equal(inputNode.value, '(123) 456-7890');
});
it('should not format if the keyCode is not between 48 & 90 and 96 && 105', function() {
inputNode.value = '1234567890';
event.triggerKeyupEvent(inputNode, 8);
assert.equal(inputNode.value, '1234567890');
});
it('should format if the last chracter typed is a separator and also a modifier key', function() {
inputNode.value = '(123) 456-7890';
inputNode.selectionStart = 10;
inputNode.selectionEnd = 10;
event.triggerKeyupEvent(inputNode, 8);
assert.equal(inputNode.value, '(123) 456-7890');
});
it('should not format if the last chracter typed is a separator and not a modifier key', function() {
inputNode.value = '(123) 456-7890';
inputNode.selectionStart = 10;
inputNode.selectionEnd = 10;
event.triggerKeyupEvent(inputNode, 47);
assert.equal(inputNode.value, '(123) 456-7890');
});
it('should format 1234567890 in XXXXX-XXXXX format', function() {
inputNode.value = '1234567890';
inputNode.setAttribute('data-format', 'XXXXX-XXXXX');
autoFormatter.enableFormatting();
assert.equal(inputNode.value, '12345-67890');
});
it('should not add format listenter if data-format attribute is not present', function() {
inputNode.value = '1234567890';
inputNode.removeAttribute('data-format');
autoFormatter.enableFormatting();
event.triggerKeyupEvent(inputNode, 48);
assert.equal(inputNode.value, '1234567890');
});
it('should not format if the value is empty even if data-format attribute is present', function() {
inputNode.value = '';
inputNode.setAttribute('data-format', 'XXXXX-XXXXX');
autoFormatter.enableFormatting();
assert.equal(inputNode.value, '');
});
it('should not format if the value length is shorter than separatorIndex', function() {
inputNode.value = '1234';
inputNode.setAttribute('data-format', 'XXXXX-XXXXX');
autoFormatter.enableFormatting();
assert.equal(inputNode.value, '1234');
});
it('should increment the caretIndex if the current caretIndex is equal to the index of next sperator', function() {
inputNode.value = '12345';
inputNode.setAttribute('data-format', 'XXXXX-XXXXX');
autoFormatter.enableFormatting();
assert.equal(inputNode.value, '12345-');
});
it('should set the caretIndex properly', function() {
inputNode.setAttribute('data-format', 'XXXXX-XXXXX');
autoFormatter.enableFormatting();
inputNode.value = '1234567890';
inputNode.selectionStart = 6;
inputNode.selectionEnd = 6;
event.triggerKeyupEvent(inputNode, 48);
assert.equal(inputNode.value, '12345-67890');
assert.equal(inputNode.selectionStart, 7);
inputNode.setAttribute('data-format', '(XXX) XXX-XXXX');
autoFormatter.enableFormatting();
inputNode.value = '(123';
inputNode.selectionStart = 4;
inputNode.selectionEnd = 4;
event.triggerKeyupEvent(inputNode, 48);
assert.equal(inputNode.selectionStart, 6);
});
it('should add maxlength attribute to the input node if limitToMaxLength is passed as true', function() {
autoFormatter.disableFormatting();
inputNode.setAttribute('data-format', 'XXXXX-XXXXX');
inputNode.value = '12345678901234567890';
autoFormatter = new AutoFormatter(config);
autoFormatter.enableFormatting();
assert.equal(inputNode.getAttribute('maxlength'), '11');
});
it('should limit the maximum character to the format length', function() {
autoFormatter.disableFormatting();
inputNode.setAttribute('data-format', '(XXX) XXX-XXXX');
inputNode.value = '12345678901234567890';
autoFormatter = new AutoFormatter(config);
autoFormatter.enableFormatting();
event.triggerKeyupEvent(inputNode, 48);
assert.equal(inputNode.value, '(123) 456-7890');
});
it('should format recurringly w.r.t the last seperator if desired', function() {
autoFormatter.disableFormatting();
inputNode.setAttribute('data-format', '(XXX) XXX-XXXX');
inputNode.value = '12345678901234567890';
config.limitToMaxLength = false;
config.recurringPattern = true;
autoFormatter = new AutoFormatter(config);
autoFormatter.enableFormatting();
event.triggerKeyupEvent(inputNode, 48);
assert.equal(inputNode.value, '(123) 456-7890-1234-5678-90');
autoFormatter.disableFormatting();
inputNode.setAttribute('data-format', 'XXXXX-XXXXX');
inputNode.value = '1234567890123456789';
autoFormatter = new AutoFormatter(config);
autoFormatter.enableFormatting();
event.triggerKeyupEvent(inputNode, 48);
assert.equal(inputNode.value, '12345-67890-12345-6789');
autoFormatter.disableFormatting();
inputNode.setAttribute('data-format', 'X-XX');
inputNode.value = '12345678';
autoFormatter = new AutoFormatter(config);
autoFormatter.enableFormatting();
event.triggerKeyupEvent(inputNode, 48);
assert.equal(inputNode.value, '1-23-45-67-8');
});
it('should format in rtl manner, recurringly if desired', function() {
autoFormatter.disableFormatting();
inputNode.setAttribute('data-format', 'XXX,XXX.XX');
inputNode.value = '1234567890';
config.direction = 'rtl';
autoFormatter = new AutoFormatter(config);
autoFormatter.enableFormatting();
event.triggerKeyupEvent(inputNode, 48);
assert.equal(inputNode.value, '12,345,678.90');
autoFormatter.disableFormatting();
inputNode.setAttribute('data-format', 'XXX,XXX.XX');
inputNode.value = '12345';
autoFormatter = new AutoFormatter(config);
autoFormatter.enableFormatting();
event.triggerKeyupEvent(inputNode, 48);
assert.equal(inputNode.value, '123.45');
});
});
});
describe('.format', function() {
it('should return the value as is if no format has been provided', function() {
config.value = '1234567890';
config.format = '';
assert.equal(AutoFormatter.format(config), '1234567890');
});
it('should return the value as is if no value has been provided', function() {
config.value = '';
config.format = '(XXX) XXX-XXXX';
assert.equal(AutoFormatter.format(config), '');
});
it('should return the value as is if its length is less than the first separatorIndex', function() {
config.value = '1234';
config.format = 'XXXXX-XXXXX';
assert.equal(AutoFormatter.format(config), '1234');
});
it('should format the value with respect to passed format', function() {
config.value = '1234567890';
config.format = '(XXX) XXX-XXXX';
config.recurringPattern = false;
assert.equal(AutoFormatter.format(config), '(123) 456-7890');
});
it('should format and limit the maximum character to the format length', function() {
config.value = '12345678901234567890';
config.format = '(XXX) XXX-XXXX';
config.limitToMaxLength = true;
config.direction = false;
assert.equal(AutoFormatter.format(config), '(123) 456-7890');
});
it('should format recurringly w.r.t the last seperator if desired', function() {
config.value = '12345678901234567890';
config.format = '(XXX) XXX-XXXX';
config.limitToMaxLength = false;
config.recurringPattern = true;
assert.equal(AutoFormatter.format(config), '(123) 456-7890-1234-5678-90');
config.format = 'XXXXX-XXXXX';
assert.equal(AutoFormatter.format(config), '12345-67890-12345-67890');
config.value = '123456789012345678';
assert.equal(AutoFormatter.format(config), '12345-67890-12345-678');
config.value = '123456789';
config.format = 'X-XX';
assert.equal(AutoFormatter.format(config), '1-23-45-67-89');
});
it('should not format recurringly and limit the maximum character to the format length if desired', function() {
config.value = '12345678901234567890';
config.format = '(XXX) XXX-XXXX';
config.limitToMaxLength = true;
config.recurringPattern = true;
assert.equal(AutoFormatter.format(config), '(123) 456-7890');
config.format = 'XXXXX-XXXXX';
assert.equal(AutoFormatter.format(config), '12345-67890');
config.value = '123456789';
config.format = 'X-XX';
assert.equal(AutoFormatter.format(config), '1-23');
});
it('should format in rtl manner, recurringly if desired', function() {
config.limitToMaxLength = false;
config.recurringPattern = true;
config.direction = 'rtl';
config.value = '1234567890';
config.format = 'XXX,XXX.XX';
assert.equal(AutoFormatter.format(config), '12,345,678.90');
config.value = '12345';
config.format = 'XXX,XXX.XX';
assert.equal(AutoFormatter.format(config), '123.45');
});
});
});
|
/*jslint node: true */
'use strict';
var _ = require('underscore.string'),
inquirer = require('inquirer'),
path = require('path'),
chalk = require('chalk-log');
module.exports = function() {
return function (done) {
var prompts = [{
name: 'taglibName',
message: 'What is the name of your taglib or taglibs (, separated) ?',
}, {
name: 'appName',
message: 'For which app (empty: global) ?'
}, {
type: 'confirm',
name: 'moveon',
message: 'Continue?'
}];
//Ask
inquirer.prompt(prompts,
function (answers) {
if (!answers.moveon) {
return done();
}
if (_.isBlank(answers.taglibName)) {
chalk.error('Taglib name can NOT be empty');
done();
}
answers.taglibName = _.clean(answers.taglibName);
var appPath = path.join('./apps', answers.appName);
var targetDir = _.isBlank(answers.appName) ? './apps/_global' : appPath;
var createTagLib = require('./create-taglib');
if (answers.taglibName.match(/,/)) {
var taglibs = answers.taglibName.split(',').map(function(taglib) {
return _.clean(taglib);
});
for (let taglib of taglibs) {
answers = {taglibName: taglib, appName: answers.appName};
createTagLib(answers, targetDir);
}
} else {
createTagLib(answers, targetDir);
}
}
);
};
};
|
'use strict';
var _ = require('lodash');
var Q = require('q');
var util = require('util');
var should = require('./utils/should');
var descriptors = require('./utils/descriptors');
var Attribute = require('./attribute');
var AssertionResult = require('./assertion-result');
var PropertyAssertion = require('./assertions/property-assertion');
var StateAssertion = require('./assertions/state-assertion');
var tinto = {};
tinto.Entity = function Entity() {
this._properties = {};
this._states = {};
/**
* @name tinto.Entity#should
* @type {tinto.Assertion}
*/
/**
* @name tinto.Entity#should
* @function
* @param {...tinto.Assertion} assertions
*/
Object.defineProperty(this, 'should', {
get: should
});
};
/**
* @param {string} state
* @returns {function() : Promise.<tinto.AssertionResult>}
*/
tinto.Entity.prototype.is = function(state) {
var self = this;
if (!this._states[state]) {
throw new Error(util.format('Unsupported state "%s"', state));
}
return function() {
return self._states[state].call(self).then(function(result) {
return new AssertionResult(result);
});
};
};
/**
* @param {string} property
* @param {*} expected
* @returns {function() : Promise.<tinto.AssertionResult>}
*/
tinto.Entity.prototype.has = function(property, expected) {
if (typeof property === 'number') {
return hasCount.call(this, expected, property);
} else {
return hasValue.call(this, property, expected);
}
};
/**
* @param {string} name
* @param {function} [matcher]
* @param {Array.<*>} [args]
*/
tinto.Entity.prototype.state = function(name, matcher, args) {
this._states[name] = wrap(matcher, args);
StateAssertion.register(name);
};
/**
* @param {Object.<string, function>} mappings
*/
tinto.Entity.prototype.states = function() {
processMappings.call(this, 'state', arguments);
};
/**
* @param {string} name
* @param {function} [matcher]
* @param {Array.<*>} [args]
*/
tinto.Entity.prototype.property = function(name, matcher, args) {
this._properties[name] = wrap(matcher, args);
PropertyAssertion.register(name);
this.getter(name, function() {
return new Attribute(this, name, matcher.call(this));
});
};
/**
* @param {Object.<string, function>} mappings
*/
tinto.Entity.prototype.properties = function() {
processMappings.call(this, 'property', arguments);
};
/**
* @param {string} prop
* @param {function()} func
*/
tinto.Entity.prototype.getter = function(prop, func) {
Object.defineProperty(this, prop, {
get: func,
enumerable: true,
configurable: true
});
};
/**
* @param {Object} props
*/
tinto.Entity.prototype.getters = function(props) {
_.forIn(descriptors(props), function(descriptor, prop) {
if (descriptor.enumerable) {
if (descriptor.get) {
this.getter(prop, descriptor.get);
} else if (descriptor.value && typeof descriptor.value === 'function') {
this.getter(prop, descriptor.value);
}
}
}, this);
};
/**
* @private
* @param {function()} matcher
* @param {Array.<*>} args
* @returns {Function}
*/
function wrap(matcher, args) {
return function() {
return Q.when(args ? matcher.apply(this, args) : matcher.call(this));
};
}
/**
* @private
* @param {string} property
* @param {*} value
* @returns {function() : Promise.<tinto.AssertionResult>}
*/
function hasValue(property, value) {
var self = this;
if (!this._properties[property]) {
throw new Error(util.format('Unsupported property "%s"', property));
}
return function() {
return self._properties[property].call(self).then(function(actual) {
return new AssertionResult(_.isEqual(value, actual), value, actual);
});
};
}
/**
* @private
* @param {string} property
* @param {Number} count
* @returns {function() : Promise.<tinto.AssertionResult>}
*/
function hasCount(property, count) {
var collection = this[property];
if (collection.count === undefined || typeof collection.count !== 'function') {
throw new Error('Count assertions can only be applied to collections');
}
return function() {
return Q.resolve(collection.count()).then(function(length) {
return new AssertionResult(count === length, count, length);
});
};
}
/**
* @private
* @param {string} type
* @param {Array.<string|Object>} mappings
*/
function processMappings(type, mappings) {
var self = this;
mappings = Array.prototype.slice.call(mappings, 0);
mappings.forEach(function(mapping) {
if (typeof mapping === 'string') {
self[type](mapping);
} else {
_.forEach(mapping, function(matcher, name) {
self[type](name, matcher);
}, self);
}
});
}
module.exports = tinto.Entity;
|
import React from 'react'
import MediaSummary from './MediaSummary'
import { Button } from 'semantic-ui-react'
import './mediaverticallist.css'
export default class MediaVerticalList extends React.Component {
render () {
var arr = this.props.data
if (arr === undefined) {
arr = []
}
var mediaNodes = arr.map((media, idx) => {
return (
<MediaSummary key={media.id + '-' + idx} logo_url={media.logo_url} />
)
})
return (
<div>
<h3 className='text-centered'>{this.props.title}</h3>
{mediaNodes}
<Button fluid size='huge'>3 Media Lainnya</Button>
</div>
)
}
}
|
/* global window beforeEach jasmine it xit fit */
if (typeof global === 'undefined') {
global = window; // eslint-disable-line
}
const customMatchers = {
toAlmostEqual: (util, customEqualityTesters) => ({
compare: (actual, expected) => {
const cleanActual = actual
.trim()
.replace(/\n/g, '')
.replace(/\s+/g, ' '); // remove extra whitespace
const cleanExpected = expected
.trim()
.replace(/\n/g, '')
.replace(/\s+/g, ' '); // remove extra whitespace
return {
pass: util.equals(cleanActual, cleanExpected, customEqualityTesters),
};
},
}),
};
beforeEach(() => {
jasmine.addMatchers(customMatchers);
});
function addDataTableSupport() {
function executeTest(name, fn, entries, override) {
entries.forEach((entry) => {
const itName = `${name} ${entry.name}`;
const itFn = () => fn(...entry.params);
(override || entry.proxy)(itName, itFn);
});
}
global.entry = (name, ...params) => {
const result = {
name,
params,
proxy: it,
};
return result;
};
global.fentry = (name, ...params) => {
const result = {
name,
params,
proxy: fit,
};
return result;
};
global.xentry = (name, ...params) => {
const result = {
name,
params,
proxy: xit,
};
return result;
};
global.describeTable = (name, fn, ...entries) => {
executeTest(name, fn, entries);
};
global.fdescribeTable = (name, fn, ...entries) => {
executeTest(name, fn, entries, fit);
};
global.xdescribeTable = (name, fn, ...entries) => {
executeTest(name, fn, entries, xit);
};
}
addDataTableSupport();
|
/**
* Created by Wayne on 16/3/16.
*/
'use strict';
var tender = require('../controllers/tender'),
cardContr = require('../controllers/card'),
cardFilter = require('../../../libraries/filters/card'),
truckFileter = require('../../../libraries/filters/truck'),
driverFilter = require('../../../libraries/filters/driver');
module.exports = function (app) {
// app.route('/tender/wechat2/details').get(driverFilter.requi, cardContr.create);
// app.route('/tender/driver/card/bindTruck').post(driverFilter.requireDriver, cardFilter.requireById, truckFileter.requireById, cardContr.bindTruck);
};
|
/**
* Imports
*/
import React from 'react';
import connectToStores from 'fluxible-addons-react/connectToStores';
import {RouteHandler} from 'react-router';
import {slugify} from '../../../utils/strings';
// Flux
import AccountStore from '../../../stores/Account/AccountStore';
import ApplicationStore from '../../../stores/Application/ApplicationStore';
import CollectionsStore from '../../../stores/Collections/CollectionsStore';
import DrawerStore from '../../../stores/Application/DrawerStore';
import IntlStore from '../../../stores/Application/IntlStore';
import NotificationQueueStore from '../../../stores/Application/NotificationQueueStore';
import PageLoadingStore from '../../../stores/Application/PageLoadingStore';
import popNotification from '../../../actions/Application/popNotification';
import triggerDrawer from '../../../actions/Application/triggerDrawer';
// Required components
import Drawer from '../../common/layout/Drawer/Drawer';
import Footer from '../../common/layout/Footer';
import Header from '../../common/layout/Header';
import Heading from '../../common/typography/Heading';
import OverlayLoader from '../../common/indicators/OverlayLoader';
import SideCart from '../../common/cart/SideCart';
import SideMenu from '../../common/navigation/SideMenu';
import PopTopNotification from '../../common/notifications/PopTopNotification';
/**
* Component
*/
class Application extends React.Component {
static contextTypes = {
executeAction: React.PropTypes.func.isRequired,
getStore: React.PropTypes.func.isRequired,
router: React.PropTypes.func.isRequired
};
//*** Initial State ***//
state = {
navCollections: this.context.getStore(CollectionsStore).getMainNavigationCollections(),
collectionsTree: this.context.getStore(CollectionsStore).getCollectionsTree(),
notification: this.context.getStore(NotificationQueueStore).pop(),
openedDrawer: this.context.getStore(DrawerStore).getOpenedDrawer(),
pageLoading: this.context.getStore(PageLoadingStore).isLoading()
};
//*** Component Lifecycle ***//
componentDidMount() {
// Load styles
require('./Application.scss');
}
componentWillReceiveProps(nextProps) {
this.setState({
navCollections: nextProps._navCollections,
collectionsTree: nextProps._collectionsTree,
notification: nextProps._notification,
openedDrawer: nextProps._openedDrawer,
pageLoading: nextProps._pageLoading
});
}
//*** View Controllers ***//
handleNotificationDismissClick = () => {
this.context.executeAction(popNotification);
};
handleOverlayClick = () => {
this.context.executeAction(triggerDrawer, null);
};
//*** Template ***//
render() {
let intlStore = this.context.getStore(IntlStore);
// Main navigation menu items
let collections = this.state.navCollections.map(function (collection) {
return {
name: intlStore.getMessage(collection.name),
to: 'collection-slug',
params: {
collectionId: collection.id,
collectionSlug: slugify(intlStore.getMessage(collection.name))
}
};
});
// Compute CSS classes for the overlay
let overlayClass = 'application__overlay';
if (this.state.openedDrawer === 'menu') {
overlayClass += ' application__overlay--left-drawer-open';
} else if (this.state.openedDrawer === 'cart') {
overlayClass += ' application__overlay--right-drawer-open';
}
// Compute CSS classes for the content
let contentClass = 'application__container';
if (this.state.openedDrawer === 'menu') {
contentClass += ' application__container--left-drawer-open';
} else if (this.state.openedDrawer === 'cart') {
contentClass += ' application__container--right-drawer-open';
}
// Check if user logged-in is an Admin
//let isAdmin = this.context.getStore(AccountStore).isAuthorized(['admin']);
// Return
return (
<div className="application">
{this.state.pageLoading ?
<OverlayLoader />
:
null
}
{this.state.notification ?
<PopTopNotification key={this.context.getStore(ApplicationStore).uniqueId()}
type={this.state.notification.type}
onDismissClick={this.handleNotificationDismissClick}>
{this.state.notification.message}
</PopTopNotification>
:
null
}
<Drawer position="left" open={this.state.openedDrawer === 'menu'}>
<SideMenu collections={collections} />
</Drawer>
<Drawer position="right" open={this.state.openedDrawer === 'cart'}>
<SideCart />
</Drawer>
<div className={overlayClass} onClick={this.handleOverlayClick}>
<div className="application__overlay-content"></div>
</div>
<div className={contentClass}>
<Header collections={collections} collectionsTree={this.state.collectionsTree} />
<div className="application__container-wrapper">
<div className="application__container-content">
<RouteHandler />
</div>
</div>
<Footer />
</div>
</div>
);
}
}
/**
* Flux
*/
Application = connectToStores(Application, [
AccountStore,
CollectionsStore,
DrawerStore,
NotificationQueueStore,
PageLoadingStore
], (context) => {
return {
_navCollections: context.getStore(CollectionsStore).getMainNavigationCollections(),
_collectionsTree: context.getStore(CollectionsStore).getCollectionsTree(),
_notification: context.getStore(NotificationQueueStore).pop(),
_openedDrawer: context.getStore(DrawerStore).getOpenedDrawer(),
_pageLoading: context.getStore(PageLoadingStore).isLoading()
};
});
/**
* Exports
*/
export default Application;
|
/**
* The main purpose of this in my mind is for navigation
* this way when this route is entered either via direct url
* or by a link-to etc you send a ping so that nav can be updated
* in the hierarchy.
*
* curious about feedback. I have used something similar in practice
* but it's mainly for keeping the ui correct and things like that
* without tightly coupling things together or at least that is my
* hope.
*/
export default Ember.Route.extend({
beforeModel: function(trans) {
trans.send('ping', this.routeName);
}
});
|
import React, { PropTypes } from 'react';
import { Provider } from 'react-redux';
import Routers from './Routers';
/**
* Component is exported for conditional usage in Root.js
*/
const Root = ({ store }) => (
/**
* Provider is a component provided to us by the 'react-redux' bindings that
* wraps our app - thus making the Redux store/state available to our 'connect()'
* calls in component hierarchy below.
*/
<Provider store={store}>
<div>
{Routers}
</div>
</Provider>
);
Root.propTypes = {
store: PropTypes.object.isRequired // eslint-disable-line react/forbid-prop-types
};
module.exports = Root;
|
import actions from './shortcuts';
class MockClientStore {
update(cb) {
this.updateCallback = cb;
}
}
describe('manager.shortcuts.actions.shortcuts', () => {
describe('setOptions', () => {
test('should update options', () => {
const clientStore = new MockClientStore();
actions.setOptions({ clientStore }, { abc: 10 });
const state = {
shortcutOptions: { bbc: 50, abc: 40 },
};
const stateUpdates = clientStore.updateCallback(state);
expect(stateUpdates).toEqual({
shortcutOptions: { bbc: 50, abc: 10 },
});
});
test('should only update options for the key already defined', () => {
const clientStore = new MockClientStore();
actions.setOptions({ clientStore }, { abc: 10, kki: 50 });
const state = {
shortcutOptions: { bbc: 50, abc: 40 },
};
const stateUpdates = clientStore.updateCallback(state);
expect(stateUpdates).toEqual({
shortcutOptions: { bbc: 50, abc: 10 },
});
});
test('should warn about deprecated option names', () => {
const clientStore = new MockClientStore();
const spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
actions.setOptions(
{ clientStore },
{
showLeftPanel: 1,
showDownPanel: 2,
downPanelInRight: 3,
}
);
const state = {
shortcutOptions: {},
};
const stateUpdates = clientStore.updateCallback(state);
expect(spy).toHaveBeenCalledTimes(3);
expect(stateUpdates).toEqual({
shortcutOptions: {
showStoriesPanel: 1,
showAddonPanel: 2,
addonPanelInRight: 3,
},
});
spy.mockReset();
spy.mockRestore();
});
});
});
|
ScalaJS.impls.scala_PartialFunction$class__orElse__Lscala_PartialFunction__Lscala_PartialFunction__Lscala_PartialFunction = (function($$this, that) {
return new ScalaJS.c.scala_PartialFunction$OrElse().init___Lscala_PartialFunction__Lscala_PartialFunction($$this, that)
});
ScalaJS.impls.scala_PartialFunction$class__andThen__Lscala_PartialFunction__Lscala_Function1__Lscala_PartialFunction = (function($$this, k) {
return new ScalaJS.c.scala_PartialFunction$AndThen().init___Lscala_PartialFunction__Lscala_Function1($$this, k)
});
ScalaJS.impls.scala_PartialFunction$class__lift__Lscala_PartialFunction__Lscala_Function1 = (function($$this) {
return new ScalaJS.c.scala_PartialFunction$Lifted().init___Lscala_PartialFunction($$this)
});
ScalaJS.impls.scala_PartialFunction$class__applyOrElse__Lscala_PartialFunction__O__Lscala_Function1__O = (function($$this, x, default$2) {
if ($$this.isDefinedAt__O__Z(x)) {
return $$this.apply__O__O(x)
} else {
return default$2.apply__O__O(x)
}
});
ScalaJS.impls.scala_PartialFunction$class__runWith__Lscala_PartialFunction__Lscala_Function1__Lscala_Function1 = (function($$this, action) {
return new ScalaJS.c.scala_scalajs_runtime_AnonFunction1().init___Lscala_scalajs_js_Function1((function(arg$outer, action$1) {
return (function(x) {
var z = arg$outer.applyOrElse__O__Lscala_Function1__O(x, ScalaJS.modules.scala_PartialFunction().scala$PartialFunction$$checkFallback__Lscala_PartialFunction());
if ((!ScalaJS.modules.scala_PartialFunction().scala$PartialFunction$$fallbackOccurred__O__Z(z))) {
action$1.apply__O__O(z);
var jsx$1 = true
} else {
var jsx$1 = false
};
return ScalaJS.bZ(jsx$1)
})
})($$this, action))
});
ScalaJS.impls.scala_PartialFunction$class__$init$__Lscala_PartialFunction__V = (function($$this) {
/*<skip>*/
});
//@ sourceMappingURL=PartialFunction$class.js.map
|
function autonomous_start() {
autonomousStartTime = gameVideo.currentTime;
initializeEvents();
} |
// --------- This code has been automatically generated !!! Wed Jul 22 2015 13:15:44 GMT+0000 (UTC)
/**
* @module opcua.address_space.types
*/
var doDebug = false;
var assert = require("better-assert");
var util = require("util");
var _ = require("underscore");
var makeNodeId = require("../lib/datamodel/nodeid").makeNodeId;
var schema_helpers = require("../lib/misc/factories_schema_helpers");
var extract_all_fields = schema_helpers.extract_all_fields;
var resolve_schema_field_types = schema_helpers.resolve_schema_field_types;
var initialize_field = schema_helpers.initialize_field;
var initialize_field_array = schema_helpers.initialize_field_array;
var check_options_correctness_against_schema = schema_helpers.check_options_correctness_against_schema;
var _defaultTypeMap = require("../lib/misc/factories_builtin_types")._defaultTypeMap;
var ec= require("../lib/misc/encode_decode");
var encodeArray= ec.encodeArray;
var decodeArray= ec.decodeArray;
var makeExpandedNodeId= ec.makeExpandedNodeId;
var generate_new_id = require("../lib/misc/factories").generate_new_id;
var _enumerations = require("../lib/misc/factories_enumerations")._private._enumerations;
var schema = require("../schemas/ChannelSecurityToken_schema").ChannelSecurityToken_Schema;
var BaseUAObject = require("../lib/misc/factories_baseobject").BaseUAObject;
/**
*
* @class ChannelSecurityToken
* @constructor
* @extends BaseUAObject
* @param options {Object}
* @param [options.secureChannelId] {UInt32}
* @param [options.tokenId] {UInt32}
* @param [options.createdAt = Wed Jul 22 2015 13:15:44 GMT+0000 (UTC)] {UtcTime}
* @param [options.revisedLifeTime = 30000] {UInt32}
*/
function ChannelSecurityToken(options)
{
options = options || {};
/* istanbul ignore next */
if (doDebug) { check_options_correctness_against_schema(this,schema,options); }
var self = this;
assert(this instanceof BaseUAObject); // ' keyword "new" is required for constructor call')
resolve_schema_field_types(schema);
BaseUAObject.call(this,options);
/**
*
* @property secureChannelId
* @type {UInt32}
*/
self.secureChannelId = initialize_field(schema.fields[0], options.secureChannelId);
/**
*
* @property tokenId
* @type {UInt32}
*/
self.tokenId = initialize_field(schema.fields[1], options.tokenId);
/**
*
* @property createdAt
* @type {UtcTime}
* @default function () {
return new Date();
}
*/
self.createdAt = initialize_field(schema.fields[2], options.createdAt);
/**
*
* @property revisedLifeTime
* @type {UInt32}
* @default 30000
*/
self.revisedLifeTime = initialize_field(schema.fields[3], options.revisedLifeTime);
// Object.preventExtensions(self);
}
util.inherits(ChannelSecurityToken,BaseUAObject);
ChannelSecurityToken.prototype.encodingDefaultBinary =makeExpandedNodeId(443,0);
ChannelSecurityToken.prototype._schema = schema;
var encode_UInt32 = _defaultTypeMap.UInt32.encode;
var decode_UInt32 = _defaultTypeMap.UInt32.decode;
var encode_UtcTime = _defaultTypeMap.UtcTime.encode;
var decode_UtcTime = _defaultTypeMap.UtcTime.decode;
/**
* encode the object into a binary stream
* @method encode
*
* @param stream {BinaryStream}
*/
ChannelSecurityToken.prototype.encode = function(stream,options) {
// call base class implementation first
BaseUAObject.prototype.encode.call(this,stream,options);
encode_UInt32(this.secureChannelId,stream);
encode_UInt32(this.tokenId,stream);
encode_UtcTime(this.createdAt,stream);
encode_UInt32(this.revisedLifeTime,stream);
};
ChannelSecurityToken.prototype.decode = function(stream,options) {
// call base class implementation first
BaseUAObject.prototype.decode.call(this,stream,options);
this.secureChannelId = decode_UInt32(stream,options);
this.tokenId = decode_UInt32(stream,options);
this.createdAt = decode_UtcTime(stream,options);
this.revisedLifeTime = decode_UInt32(stream,options);
};
ChannelSecurityToken.possibleFields = function() {
return [
"secureChannelId",
"tokenId",
"createdAt",
"revisedLifeTime"
];
}();
exports.ChannelSecurityToken = ChannelSecurityToken;
var register_class_definition = require("../lib/misc/factories_factories").register_class_definition;
register_class_definition("ChannelSecurityToken",ChannelSecurityToken); |
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _css = require('antd/lib/message/style/css');
var _message = require('antd/lib/message');
var _message2 = _interopRequireDefault(_message);
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _react = require('react');
var _react2 = _interopRequireDefault(_react);
var _reactDom = require('react-dom');
var _reactDom2 = _interopRequireDefault(_reactDom);
var _draftJsWhkfzyx = require('draft-js-whkfzyx');
var _decoratorStyle = require('./decoratorStyle.css');
var _decoratorStyle2 = _interopRequireDefault(_decoratorStyle);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var ImageSpan = function (_Component) {
_inherits(ImageSpan, _Component);
function ImageSpan(props) {
_classCallCheck(this, ImageSpan);
var _this = _possibleConstructorReturn(this, (ImageSpan.__proto__ || Object.getPrototypeOf(ImageSpan)).call(this, props));
var entity = _draftJsWhkfzyx.Entity.get(_this.props.entityKey);
var _entity$getData = entity.getData(),
width = _entity$getData.width,
height = _entity$getData.height;
_this.state = {
width: width,
height: height,
imageSrc: ''
};
_this.onImageClick = _this._onImageClick.bind(_this);
_this.onDoubleClick = _this._onDoubleClick.bind(_this);
return _this;
}
_createClass(ImageSpan, [{
key: 'componentDidMount',
value: function componentDidMount() {
var _this2 = this;
var _state = this.state,
width = _state.width,
height = _state.height;
var entity = _draftJsWhkfzyx.Entity.get(this.props.entityKey);
var image = new Image();
var _entity$getData2 = entity.getData(),
src = _entity$getData2.src;
src = src.replace(/[?#&].*$/g, "");
this.setState({ imageSrc: src });
image.src = this.state.imageSrc;
image.onload = function () {
if (width == null || height == null) {
_this2.setState({ width: image.width, height: image.height });
_draftJsWhkfzyx.Entity.mergeData(_this2.props.entityKey, {
width: image.width,
height: image.height,
originalWidth: image.width,
originalHeight: image.height
});
}
};
}
}, {
key: 'render',
value: function render() {
var _this3 = this;
var _state2 = this.state,
width = _state2.width,
height = _state2.height;
var key = this.props.entityKey;
var entity = _draftJsWhkfzyx.Entity.get(key);
var _entity$getData3 = entity.getData(),
src = _entity$getData3.src;
var imageStyle = {
verticalAlign: 'bottom',
backgroundImage: 'url("' + this.state.imageSrc + '")',
backgroundSize: width + 'px ' + height + 'px',
lineHeight: height + 'px',
fontSize: height + 'px',
width: width,
height: height,
letterSpacing: width
};
return _react2.default.createElement(
'div',
{ className: 'editor-inline-image', onClick: this._onClick },
_react2.default.createElement('img', { src: '' + this.state.imageSrc, className: 'media-image', onClick: function onClick(event) {
_this3.onImageClick(event, key);event.stopPropagation();
}, onDoubleClick: this.onDoubleClick })
);
}
}, {
key: '_onDoubleClick',
value: function _onDoubleClick() {
var currentPicture = _reactDom2.default.findDOMNode(this).querySelector("img");
var pictureWidth = currentPicture.naturalWidth;
var pictureSrc = currentPicture.src;
}
}, {
key: '_onImageClick',
value: function _onImageClick(e, key) {
var currentPicture = _reactDom2.default.findDOMNode(this).querySelector("img");
var pictureWidth = currentPicture.naturalWidth;
var editorState = _draftJsWhkfzyx.EditorState.createEmpty();
var selection = editorState.getSelection();
var blockTree = editorState.getBlockTree(this.props.children[0].key);
if (pictureWidth == 0) {
_message2.default.error("图片地址错误！");
} else if (pictureWidth > 650) {
_message2.default.error("图片尺寸过大将会导致用户流量浪费！请调整至最大650px。", 10);
}
}
}, {
key: '_handleResize',
value: function _handleResize(event, data) {
var _data$size = data.size,
width = _data$size.width,
height = _data$size.height;
this.setState({ width: width, height: height });
_draftJsWhkfzyx.Entity.mergeData(this.props.entityKey, { width: width, height: height });
}
}]);
return ImageSpan;
}(_react.Component);
exports.default = ImageSpan;
ImageSpan.defaultProps = {
children: null,
entityKey: "",
className: ""
}; |
(function () {
'use strict';
angular
.module("myApp.presents")
.factory("dataGiftService", dataGiftService);
function dataGiftService($mdToast, $mdDialog) {
var dataGiftService = {
notification: notification,
pleaseWaitDialog: pleaseWaitDialog
};
function notification(status, msg, time) {
if (angular.isUndefined(time))
time = 3000;
$mdToast.show(
$mdToast.simple()
.textContent(msg)
.position("top right")
.hideDelay(time)
.theme(status)
);
}
function pleaseWaitDialog(msg, parentEl) {
if (angular.isUndefined(parentEl)) {
parentEl = angular.element(document.body);
}
$mdDialog.show({
parent: parentEl,
template: '<md-dialog class="wait-dialog" aria-label="Please wait">' +
' <md-dialog-content layout="column" layour-align="center center">' +
'<h1 class="text-center">Proszę czekać</h1>' +
'<md-content class="text-center">' + msg + '</md-content>'+
' </md-dialog-content>' +
'</md-dialog>'
});
}
return dataGiftService;
}
})(); |
///////////////////////////////////////////////////////////////////////////
// Copyright © Esri. All Rights Reserved.
//
// Licensed under the Apache License Version 2.0 (the 'License');
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an 'AS IS' BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
///////////////////////////////////////////////////////////////////////////
define({
"_widgetLabel": "Penyaringan",
"geometryServicesNotFound": "Service geometri tidak tersedia.",
"unableToDrawBuffer": "Tidak dapat menggambar buffer. Harap coba lagi.",
"invalidConfiguration": "Konfigurasi tidak valid.",
"clearAOIButtonLabel": "Mulai Ulang",
"noGraphicsShapefile": "Shapefile yang diunggah tidak berisi grafis.",
"zoomToLocationTooltipText": "Zoom ke lokasi",
"noGraphicsToZoomMessage": "Tidak ada grafik yang ditemukan untuk memperbesar.",
"placenameWidget": {
"placenameLabel": "Cari lokasi"
},
"drawToolWidget": {
"useDrawToolForAOILabel": "Pilih mode gambar",
"toggleSelectability": "Klik untuk beralih selektabilitas",
"chooseLayerTitle": "Pilih layer yang dapat dipilih",
"selectAllLayersText": "Pilih Semua",
"layerSelectionWarningTooltip": "Setidaknya satu layer harus dipilih untuk membuat AOI",
"selectToolLabel": "Pilih alat"
},
"shapefileWidget": {
"shapefileLabel": "Unggah shapefile zip",
"uploadShapefileButtonText": "Unggah",
"unableToUploadShapefileMessage": "Tidak dapat mengunggah shapefile."
},
"coordinatesWidget": {
"selectStartPointFromSearchText": "Tentukan titik awal",
"addButtonTitle": "Tambah",
"deleteButtonTitle": "Hapus",
"mapTooltipForStartPoint": "Klik pada peta untuk menentukan titik awal",
"mapTooltipForUpdateStartPoint": "Klik pada peta untuk memperbarui titik awal",
"locateText": "Temukan",
"locateByMapClickText": "Pilih koordinat awal",
"enterBearingAndDistanceLabel": "Masukkan poros dan jarak dari titik awal",
"bearingTitle": "Poros",
"distanceTitle": "Jarak",
"planSettingTooltip": "Pengaturan Rencana",
"invalidLatLongMessage": "Harap masukkan nilai yang valid."
},
"bufferDistanceAndUnit": {
"bufferInputTitle": "Jarak buffer (opsional)",
"bufferInputLabel": "Tampilkan hasil dalam",
"bufferDistanceLabel": "Jarak buffer",
"bufferUnitLabel": "Unit buffer"
},
"traverseSettings": {
"bearingLabel": "Poros",
"lengthLabel": "Panjang",
"addButtonTitle": "Tambah",
"deleteButtonTitle": "Hapus",
"deleteBearingAndLengthLabel": "Hapus poros dan baris panjang",
"addButtonLabel": "Hapus poros dan panjang"
},
"planSettings": {
"expandGridTooltipText": "Perluas grid",
"collapseGridTooltipText": "Ciutkan grid",
"directionUnitLabelText": "Unit Arah",
"distanceUnitLabelText": "Unit Jarak dan Panjang",
"planSettingsComingSoonText": "Segera Datang"
},
"newTraverse": {
"invalidBearingMessage": "Poros Tidak Valid.",
"invalidLengthMessage": "Panjang Tidak Valid.",
"negativeLengthMessage": "Panjang Negatif"
},
"reportsTab": {
"aoiAreaText": "Area AOI",
"downloadButtonTooltip": "Unduh",
"printButtonTooltip": "Cetak",
"uploadShapefileForAnalysisText": "Unggah shapefile untuk disertakan dalam analisis",
"uploadShapefileForButtonText": "Telusuri",
"downloadLabelText": "Pilih Format :",
"downloadBtnText": "Unduh",
"noDetailsAvailableText": "Tidak ada hasil yang ditemukan",
"featureCountText": "Jumlah",
"featureAreaText": "Area",
"featureLengthText": "Panjang",
"attributeChooserTooltip": "Pilih atribut untuk ditampilkan",
"csv": "CSV",
"filegdb": "File Geodatabase",
"shapefile": "Shapefile",
"noFeaturesFound": "Tidak ada hasil yang ditemukan untuk format file yang dipilih",
"selectReportFieldTitle": "Pilih kolom",
"noFieldsSelected": "Tidak ada kolom yang dipilih",
"intersectingFeatureExceedsMsgOnCompletion": "Penghitungan jumlah maksimum catatan telah tercapai untuk satu atau beberapa layer.",
"unableToAnalyzeText": "Tidak dapat menganalisis, jumlah catatan maksimum telah tercapai.",
"errorInPrintingReport": "Tidak dapat mencetak laporan. Harap periksa apakah pengaturan laporan valid.",
"aoiInformationTitle": "Informasi Area Pilihan (AOI)",
"summaryReportTitle": "Ringkasan",
"notApplicableText": "T/A",
"downloadReportConfirmTitle": "Konfirmasi pengunduhan",
"downloadReportConfirmMessage": "Anda yakin ingin mengunduh?",
"noDataText": "Tidak Ada Data",
"createReplicaFailedMessage": "Operasi unduhan gagal untuk layer berikut: <br/> ${layerNames}",
"extractDataTaskFailedMessage": "Operasi mengunduh gagal.",
"printLayoutLabelText": "Tata Letak",
"printBtnText": "Cetak",
"printDialogHint": "Catatan: Judul laporan dan komentar dapat diedit dalam pratinjau laporan.",
"unableToDownloadFileGDBText": "Geodatabase file tidak dapat diunduh untuk AOI yang berisi lokasi titik atau garis",
"unableToDownloadShapefileText": "Shapefile tidak dapat diunduh untuk AOI yang berisi lokasi titik atau garis",
"analysisAreaUnitLabelText": "Tampilkan hasil luas dalam :",
"analysisLengthUnitLabelText": "Tampilkan hasil panjang dalam :",
"analysisUnitButtonTooltip": "Pilih unit untuk analisis",
"analysisCloseBtnText": "Tutup",
"areaSquareFeetUnit": "Kaki Persegi",
"areaAcresUnit": "Acre",
"areaSquareMetersUnit": "Meter Persegi",
"areaSquareKilometersUnit": "Kilometer Persegi",
"areaHectaresUnit": "Hektare",
"lengthFeetUnit": "Kaki",
"lengthMilesUnit": "Mil",
"lengthMetersUnit": "Meter",
"lengthKilometersUnit": "Kilometer",
"hectaresAbbr": "hektar",
"layerNotVisibleText": "Tidak dapat menganalisis. Layer dimatikan atau di luar rentang visibilitas skala.",
"refreshBtnTooltip": "Muat ulang laporan",
"featureCSVAreaText": "Area Berpotongan",
"featureCSVLengthText": "Panjang Berpotongan",
"errorInFetchingPrintTask": "Kesalahan saat mengambil informasi tugas cetak. Silakan coba lagi.",
"selectAllLabel": "Pilih Semua",
"errorInLoadingProjectionModule": "Kesalahan saat memuat dependensi modul proyeksi. Harap coba mengunduh file kembali.",
"expandCollapseIconLabel": "Fitur berpotongan",
"intersectedFeatureLabel": "Detail fitur berpotongan",
"valueAriaLabel": "Nilai",
"countAriaLabel": "Jumlah"
}
}); |
module.exports = `
type SimpleBudgetDetail {
account_type: String,
account_name: String,
fund_name: String,
department_name: String,
division_name: String,
costcenter_name: String,
function_name: String,
charcode_name: String,
organization_name: String,
category_name: String,
budget_section_name: String,
object_name: String,
year: Int,
budget: Float,
actual: Float,
full_account_id: String,
org_id: String,
obj_id: String,
fund_id: String,
dept_id: String,
div_id: String,
cost_id: String,
func_id: String,
charcode: String,
category_id: String,
budget_section_id: String,
proj_id: String,
is_proposed: String
use_actual: String
}
type SimpleBudgetSummary {
account_type: String,
category_name: String,
year: Int,
total_budget: Float,
total_actual: Float
use_actual: String
}
type BudgetCashFlow {
account_type: String,
category_name: String,
category_id: String,
dept_id: String,
department_name: String,
fund_id: String,
fund_name: String,
budget: Float,
year: Int
}
type BudgetParameters {
start_year: Int
end_year: Int
in_budget_season: Boolean
}
`;
|
module.exports = client => {
console.log(`Reconnecting... [at ${new Date()}]`);
}; |
ig.module(
'game.entities.abstract.friendly-unit'
).requires(
'game.entities.abstract.unit'
).defines(function () {
FriendlyUnit = Unit.extend({
// Nothing yet!
});
}); |
/**
* Ajax函数
*/
// 创建一个XMLHttpRequest对象
var createXHR;
if (window.XMLHttpRequest) {
createXHR = function() {
return new XMLHttpRequest();
};
} else if (window.ActiveXObject) {
createXHR = function() {
return new ActiveXObject('Microsoft.XMLHTTP');
};
}
// 发起异步请求，默认为GET请求
function ajax(url, opts) {
var type = opts.type || 'get',
async = opts.async || true,
data = opts.data || null,
headers = opts.headers || {};
var xhr = createXHR();
xhr.onreadystatechange = function() {
if (xhr.readyState == 4 && xhr.status == 200) {
opts.onsuccess && opts.onsuccess(xhr.responseText);
} else {
opts.onerror && opts.onerror();
}
};
xhr.open(url, type, async);
for (var p in headers) {
xhr.setRequestHeader(p, headers[p]);
}
xhr.send(data);
} |
import { addTimer } from './timer/timer';
import { showProfile } from './profile/profile';
import { showHelp } from './help/help';
import { getAllUsers } from './timer/listUtil/getAllUsers';
import { isWorking } from './timer/listUtil/isWorking';
import { timerTimeout } from './timer/listUtil/timerTimeout';
import { refreshPoints } from './timer/listUtil/refreshPoints';
import { minusStackCalculate } from './timer/listUtil/minusStackCalculate';
import { updUsrList } from './timer/listUtil/updUsrList';
const emojiMap = { '⏺': addTimer, '👤': showProfile, '❓': showHelp };
async function menuGUI(res, bot) {
const channel = bot.channel;
const timerList = {};
let userList = await getAllUsers(); // eslint-disable-line
const menuMsg = await channel.send('', {
embed: { description: '`⏺ Start Recording! | 👤 Your Profile | ❓ Need help?`' },
});
// add reactions to message
for (const emoji in emojiMap) {
await menuMsg.react(emoji);
}
await channel.send('▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬');
await menuMsg.createReactionCollector(async (reaction, user) => {
if (user.bot) return false;
// run the emoji command logic and remove the reaction
if (emojiMap[reaction.emoji.name]) {
emojiMap[reaction.emoji.name](bot, user, timerList);
}
await reaction.remove(user);
return false;
});
res();
setInterval(() => {
timerTimeout(bot, timerList);
}, 60000);
setInterval(async () => {
refreshPoints(timerList);
isWorking(userList, timerList);
minusStackCalculate();
updUsrList(userList);
}, 60000);
}
module.exports = {
init: (bot) => {
return new Promise((res) => {
menuGUI(res, bot);
});
},
};
|
/**
* Created by:homelan
* User: [email protected]
* Date: 2017/7/31
* Time: 17:38
*
*/
import React from 'react';
import icons from '../utils/parseIcon';
import {connect} from 'react-redux';
import {lockPlayer} from '../store/action/actionindex';
class LockBar extends React.Component {
render() {
const {handleClick}=this.props;
let styleObj1={};
styleObj1.background='url('+icons.playbar+')';
return (
<div className="updn" >
<div className='lock-bg' style={styleObj1}>
<a className={this.props.locked?'btn':'btn-unlock'} style={styleObj1} onClick={e=>handleClick(e)}></a>
</div>
<div className="lock-bg2" style={styleObj1} ></div>
</div>
)
}
}
const mapStateToProps=(state)=>{
return {locked:state.locked}
}
const mapDispatchToProps=(dispatch)=> {
return {
handleClick: (e) => {
dispatch(lockPlayer())
e.preventDefault();
e.stopPropagation()
}
}
};
export default connect(mapStateToProps,mapDispatchToProps)(LockBar);//important
/*function mapDispatchToProps(dispatch) {
return {
handleClick: () => dispatch(lockPlayer())
};
}
connect(
mapDispatchToProps
)(LockBar);
*/
|
var express = require('express');
var app = module.exports = express();
var api = require('lib/db-api');
var config = require('lib/config');
var path = require('path');
var url = require('url');
var resolve = path.resolve;
var strip = require('strip');
var log = require('debug')('democracyos:facebook-card');
app.get('/topic/:id', function(req, res, next){
log('Facebook Request /topic/%s', req.params.id);
api.topic.get(req.params.id, function (err, topicDoc) {
if (err) return _handleError(err, req, res);
log('Serving Facebook topic %s', topicDoc.id);
var baseUrl = url.format({
protocol: config.protocol
, hostname: config.host
, port: config.publicPort
});
res.render(resolve(__dirname, 'topic.jade'),
{ topic: topicDoc,
baseUrl : baseUrl,
config : config,
strip: strip
});
});
})
app.get('*', function(req, res, next){
log('Facebook Request generic page');
var baseUrl = url.format({
protocol: config.protocol
, hostname: config.host
, port: config.publicPort
});
res.render(resolve(__dirname, 'generic.jade'),
{ baseUrl : baseUrl,
config : config});
}) |
import Html from "./Html";
import { YatinSelectMin, YatinSelectMax } from "../parts/YatinSelect";
export default class YatinSection extends Html {
constructor(min="", max="") {
super();
var $yatinSection = $(`
<section class="yatin-section">
<h2>￥家賃</h2>
<div class="center"></div>
</section>
`);
var selectMin = new YatinSelectMin(min);
var selectMax = new YatinSelectMax(max);
$yatinSection.find(".center").append( selectMin.getHtml() );
$yatinSection.find(".center").append( $(`<div class="kara">〜</div>`) );
$yatinSection.find(".center").append( selectMax.getHtml() );
this.$html = $yatinSection
}
} |
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _react = require('react');
var _react2 = _interopRequireDefault(_react);
var _reactAddonsShallowCompare = require('react-addons-shallow-compare');
var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);
var _path = require('path');
var _path2 = _interopRequireDefault(_path);
var _NodeCaret = require('./NodeCaret');
var _NodeCaret2 = _interopRequireDefault(_NodeCaret);
var _styles = require('./styles');
var _styles2 = _interopRequireDefault(_styles);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var isDirectory = function isDirectory(type) {
return type === 'directory';
};
var Node = function (_Component) {
_inherits(Node, _Component);
function Node() {
_classCallCheck(this, Node);
var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Node).call(this));
_this.state = {};
return _this;
}
// shouldComponentUpdate(nextProps, nextState, nextContext) {
// const shouldUpdate = shallowCompare(this, nextProps, nextState)
//
// // console.log('update', shouldUpdate, nextProps.node.path)
//
// return shouldUpdate
// }
_createClass(Node, [{
key: 'render',
value: function render() {
var _this2 = this;
var _props = this.props;
var node = _props.node;
var metadata = _props.metadata;
var depth = _props.depth;
var type = node.type;
var name = node.name;
var path = node.path;
var expanded = metadata.expanded;
var selected = metadata.selected;
var hover = this.state.hover;
return _react2.default.createElement(
'div',
{ style: (0, _styles.getPaddedStyle)(depth, selected, hover),
onMouseEnter: function onMouseEnter() {
return _this2.setState({ hover: true });
},
onMouseLeave: function onMouseLeave() {
return _this2.setState({ hover: false });
}
},
isDirectory(type) && _react2.default.createElement(_NodeCaret2.default, {
expanded: expanded
}),
_react2.default.createElement(
'div',
{ style: _styles2.default.nodeText },
name
)
);
}
}]);
return Node;
}(_react.Component);
exports.default = Node; |
var game = new Phaser.Game(375, 667, Phaser.AUTO, 'gameDiv');
// var game = new Phaser.Game(720, 1280, Phaser.AUTO, 'gameDiv');
game.global = {
taps: 0,
enemyHP: 0,
enemyHPTotal: 0,
level: 1,
enemyNumber: 1,
coins: 0,
player: {
name: 'mr. hero',
level: 1,
skillLevel: [0, 0, 0, 0, 0, 0]
}
};
game.state.add('boot', bootState);
game.state.add('load', loadState);
game.state.add('menu', menuState);
game.state.add('play', playState);
game.state.start('boot'); |
/**
* Default model configuration
* (sails.config.models)
*
* Unless you override them, the following properties will be included
* in each of your models.
*
* For more info on Sails models, see:
* http://sailsjs.org/#!/documentation/concepts/ORM
*/
module.exports.models = {
/***************************************************************************
* *
* Your app's default connection. i.e. the name of one of your app's *
* connections (see `config/connections.js`) *
* *
***************************************************************************/
// connection: 'localDiskDb',
/***************************************************************************
* *
* How and whether Sails will attempt to automatically rebuild the *
* tables/collections/etc. in your schema. *
* *
* See http://sailsjs.org/#!/documentation/concepts/ORM/model-settings.html *
* *
***************************************************************************/
migrate: 'safe',
schema: true,
/**
* This method adds records to the database
*
* To use add a variable 'seedData' in your model and call the
* method in the bootstrap.js file
*/
seed: function (callback) {
var self = this;
var modelName = self.adapter.identity.charAt(0).toUpperCase() + self.adapter.identity.slice(1);
if (!self.seedData) {
sails.log.debug('No data avaliable to seed ' + modelName);
callback();
return;
}
self.count().exec(function (err, count) {
if (!err && count === 0) {
sails.log.debug('Seeding ' + modelName + '...');
if (self.seedData instanceof Array) {
self.seedArray(callback);
}else{
self.seedObject(callback);
}
} else {
sails.log.debug(modelName + ' had models, so no seed needed');
callback();
}
});
},
seedArray: function (callback) {
var self = this;
var modelName = self.adapter.identity.charAt(0).toUpperCase() + self.adapter.identity.slice(1);
self.createEach(self.seedData).exec(function (err, results) {
if (err) {
sails.log.debug(err);
callback();
} else {
sails.log.debug(modelName + ' seed planted');
callback();
}
});
},
seedObject: function (callback) {
var self = this;
var modelName = self.adapter.identity.charAt(0).toUpperCase() + self.adapter.identity.slice(1);
self.create(self.seedData).exec(function (err, results) {
if (err) {
sails.log.debug(err);
callback();
} else {
sails.log.debug(modelName + ' seed planted');
callback();
}
});
}
};
|
'use strict';
const mongoose = require('mongoose-q')(require('mongoose'));
const League = mongoose.model('League');
function LeagueHandler (leagueService) {
this.service = leagueService;
}
LeagueHandler.prototype.getLeaguesByCountry = function(req, res, next) {
return this.service.getByCountry(req.params.country)
.then(function(countryLeagues) {
return res.status(200).send(countryLeagues)
})
.catch(function(err) {
next(err)
})
};
module.exports = LeagueHandler; |
app.controller('JoinGameController', function ($scope, $location, authorization, identity, ticTacToeData, notifier) {
'use strict';
$scope.joinGame = function (gameId) {
if (identity.isAuthenticated() === true) {
ticTacToeData.joinGame(authorization.getAuthorizationHeader(), gameId)
.then(function () {
notifier.success('Game joined!');
}, function () {
notifier.error('Invalid data!');
});
} else {
notifier.error('Please login!');
}
};
$scope.joinRandomGame = function () {
if (identity.isAuthenticated() === true) {
ticTacToeData.joinRandomGame(authorization.getAuthorizationHeader())
.then(function () {
notifier.success('Game joined!');
});
} else {
notifier.error('Please login!');
}
}
}); |
'use strict';
function Level(args) {
if(!(this instanceof Level))
return new Level(args);
this.context = args.context;
this.player = args.player;
this.gameplayObjects = args.gameplayObjects;
this.outcomeListeners = [];
this.finalMessageListeners = [];
this.respawnInfoListeners = [];
this.victoryMessages = args.victoryMessages;
this.failureMessages = args.failureMessages;
this.isPaused = true;
this.isFinished = false;
this.handleRespawnInfo(args.respawnInfo);
this.player.setParentLevel(this);
this.gameplayObjects.forEach(o => o.beginObservingPlayer(this.player));
}
Level.prototype.draw = function() {
this.context.clearRect(0, 0, this.context.canvas.width, this.context.canvas.height);
this.gameplayObjects.forEach(o => o.draw(this.context));
this.player.draw(this.context);
}
Level.prototype.update = function(dt) {
this.player.update(dt);
}
Level.prototype.frame = function(dt) {
this.update(dt);
this.draw();
}
Level.prototype.startGameLoop = function() {
const gameLoopFrame = now => {
if(!this.isPaused) {
const dt = now - this.lastFrameTime;
this.frame(dt);
window.requestAnimationFrame(gameLoopFrame);
}
this.lastFrameTime = now;
}
this.isPaused = false;
this.lastFrameTime = performance.now();
window.requestAnimationFrame(gameLoopFrame);
}
Level.prototype.pauseGameLoop = function() {
this.isPaused = true;
}
Level.prototype.addOutcomeListener = function(listener) {
this.outcomeListeners.push(listener);
}
Level.prototype.addFinalMessageListener = function(listener) {
this.finalMessageListeners.push(listener);
}
Level.prototype.addRespawnInfoListener = function(listener) {
this.respawnInfoListeners.push(listener);
}
Level.prototype.generateRespawnInfo = function() {
return this.player.generateRespawnInfo();
}
Level.prototype.handleRespawnInfo = function(respawnInfo) {
this.player.handleRespawnInfo(respawnInfo);
}
Level.prototype.win = function() {
this.finishWithOutcome(true);
}
Level.prototype.lose = function() {
this.finishWithOutcome(false);
}
Level.prototype.finishWithOutcome = function(outcome) {
if(this.isFinished)
return;
this.isFinished = true;
this.pauseGameLoop();
this.player.stop();
this.outcomeListeners.forEach(listener => listener(outcome));
const finalMessage = this.getMessageForOutcome(outcome);
this.finalMessageListeners.forEach(listener => listener(finalMessage));
if(!outcome) {
const respawnInfo = this.generateRespawnInfo();
Object.freeze(respawnInfo);
this.respawnInfoListeners.forEach(listener => listener(respawnInfo));
}
}
Level.prototype.getMessageForOutcome = function(outcome) {
if(outcome)
return mathUtils.randomArrayElement(this.victoryMessages);
else return mathUtils.randomArrayElement(this.failureMessages);
} |
require("./18.js");
require("./37.js");
require("./74.js");
require("./147.js");
module.exports = 148; |
var Leap = require("leapjs");
var keyboard = require('node_keyboard');
//Each var individually declared below so they refence different objects in memory. I.e work independantly.
//These vars log when a particular action / gesture last ran.
var last_fav = new Date().getTime();
var last_swipe = new Date().getTime();
var last_up = new Date().getTime();
var last_down = new Date().getTime();
var current_time;
var delay = 1000; //Number of milliseconds forced between each gesture.
var controller = Leap.loop({enableGestures: true}, function(frame){
if(frame.valid && frame.gestures.length > 0){
frame.gestures.forEach(function(gesture){
switch (gesture.type){
case "circle":
current_time = new Date().getTime();
if(last_fav+delay < current_time){
keyboard.press(keyboard.Key_Numpad0);
keyboard.release(keyboard.Key_Numpad0);
console.log("Circle Gesture");
last_fav = new Date().getTime();
}
break;
case "swipe":
current_time = new Date().getTime();
if(last_swipe+delay < current_time){
//Classify swipe as either horizontal or vertical
var isHorizontal = Math.abs(gesture.direction[0]) > Math.abs(gesture.direction[1]);
//Classify as right-left or up-down
if(isHorizontal){
if(gesture.direction[0] > 0){
swipeDirection = "Swipe Right";
keyboard.press(keyboard.Key_Up); //Key_Up keycode and Key_Right keycode are swapped in node_keyboard dependancy
keyboard.release(keyboard.Key_Up);//Key_Up keycode and Key_Right keycode are swapped in node_keyboard dependancy
} else {
swipeDirection = "Swipe Left";
keyboard.press(keyboard.Key_Left);
keyboard.release(keyboard.Key_Left);
}
} else { //vertical
if(gesture.direction[1] > 0){
swipeDirection = "Swipe Up";
} else {
swipeDirection = "Swipe Down";
}
}
console.log(swipeDirection);
last_swipe = new Date().getTime();
}
break;
}
});
}
if(frame.pointables.length == 5){
var pointable = frame.pointables;
current_time = new Date().getTime();
if(last_up+delay < current_time){
if(pointable[0].direction[1] > 0.78 && pointable[1].direction[1] > 0.78 && pointable[2].direction[1] > 0.78 && pointable[3].direction[1] > 0.78 && pointable[4].direction[1] > 0.78 ){
console.log("Up Vote");
keyboard.press(keyboard.Key_NumpadAdd);
keyboard.release(keyboard.Key_NumpadAdd);
last_up = new Date().getTime();
}
}
if(last_down+delay < current_time){
if(pointable[0].direction[1] < -0.78 && pointable[1].direction[1] < -0.78 && pointable[2].direction[1] < -0.78 && pointable[3].direction[1] < -0.78 && pointable[4].direction[1] < -0.78 ){
console.log("Down Vote");
keyboard.press(keyboard.Key_NumpadSubtract);
keyboard.release(keyboard.Key_NumpadSubtract);
last_down = new Date().getTime();
}
}
}
});
console.log('Leap Imgur Controller Running'); |
// eslint-disable-next-line
function getCookie(cname) {
const name = `${cname}=`;
const ca = document.cookie.split(';');
for (let i = 0; i < ca.length; i += 1) {
let c = ca[i];
while (c.charAt(0) === ' ') c = c.substring(1);
if (c.indexOf(name) !== -1) return c.substring(name.length, c.length);
}
return '';
}
|
/*
* Kendo UI v2015.1.408 (http://www.telerik.com/kendo-ui)
* Copyright 2015 Telerik AD. All rights reserved.
*
* Kendo UI commercial licenses may be obtained at
* http://www.telerik.com/purchase/license-agreement/kendo-ui-complete
* If you do not own a commercial license, this file shall be governed by the trial license terms.
*/
(function(f, define){
define([], f);
})(function(){
(function( window, undefined ) {
var kendo = window.kendo || (window.kendo = { cultures: {} });
kendo.cultures["kok"] = {
name: "kok",
numberFormat: {
pattern: ["-n"],
decimals: 2,
",": ",",
".": ".",
groupSize: [3,2],
percent: {
pattern: ["-n %","n %"],
decimals: 2,
",": ",",
".": ".",
groupSize: [3,2],
symbol: "%"
},
currency: {
pattern: ["$ -n","$ n"],
decimals: 2,
",": ",",
".": ".",
groupSize: [3,2],
symbol: "₹"
}
},
calendars: {
standard: {
days: {
names: ["आयतार","सोमार","मंगळार","बुधवार","बिरेस्तार","सुक्रार","शेनवार"],
namesAbbr: ["आय.","सोम.","मंगळ.","बुध.","बिरे.","सुक्र.","शेन."],
namesShort: ["आ","स","म","ब","ब","स","श"]
},
months: {
names: ["जानेवारी","फेब्रुवारी","मार्च","एप्रिल","मे","जून","जुलै","ऑगस्ट","सप्टेंबर","ऑक्टोबर","नोवेम्बर","डिसेंबर"],
namesAbbr: ["जाने","फेब्रु","मार्च","एप्रिल","मे","जून","जुलै","ऑग.","सप्टें.","ऑक्टो.","नोवे.","डिसें"]
},
AM: ["म.पू.","म.पू.","म.पू."],
PM: ["म.नं.","म.नं.","म.नं."],
patterns: {
d: "dd-MM-yyyy",
D: "dd MMMM yyyy",
F: "dd MMMM yyyy HH:mm:ss",
g: "dd-MM-yyyy HH:mm",
G: "dd-MM-yyyy HH:mm:ss",
m: "dd MMMM",
M: "dd MMMM",
s: "yyyy'-'MM'-'dd'T'HH':'mm':'ss",
t: "HH:mm",
T: "HH:mm:ss",
u: "yyyy'-'MM'-'dd HH':'mm':'ss'Z'",
y: "MMMM, yyyy",
Y: "MMMM, yyyy"
},
"/": "-",
":": ":",
firstDay: 1
}
}
}
})(this);
return window.kendo;
}, typeof define == 'function' && define.amd ? define : function(_, f){ f(); }); |
(function (window) {
'use strict';
/*global define, module, exports, require */
var c3 = { version: "0.4.11" };
var c3_chart_fn,
c3_chart_internal_fn,
c3_chart_internal_axis_fn;
function API(owner) {
this.owner = owner;
}
function inherit(base, derived) {
if (Object.create) {
derived.prototype = Object.create(base.prototype);
} else {
var f = function f() {};
f.prototype = base.prototype;
derived.prototype = new f();
}
derived.prototype.constructor = derived;
return derived;
}
function Chart(config) {
var $$ = this.internal = new ChartInternal(this);
$$.loadConfig(config);
$$.beforeInit(config);
$$.init();
$$.afterInit(config);
// bind "this" to nested API
(function bindThis(fn, target, argThis) {
Object.keys(fn).forEach(function (key) {
target[key] = fn[key].bind(argThis);
if (Object.keys(fn[key]).length > 0) {
bindThis(fn[key], target[key], argThis);
}
});
})(c3_chart_fn, this, this);
}
function ChartInternal(api) {
var $$ = this;
$$.d3 = window.d3 ? window.d3 : typeof require !== 'undefined' ? require("d3") : undefined;
$$.api = api;
$$.config = $$.getDefaultConfig();
$$.data = {};
$$.cache = {};
$$.axes = {};
}
c3.generate = function (config) {
return new Chart(config);
};
c3.chart = {
fn: Chart.prototype,
internal: {
fn: ChartInternal.prototype,
axis: {
fn: Axis.prototype
}
}
};
c3_chart_fn = c3.chart.fn;
c3_chart_internal_fn = c3.chart.internal.fn;
c3_chart_internal_axis_fn = c3.chart.internal.axis.fn;
c3_chart_internal_fn.beforeInit = function () {
// can do something
};
c3_chart_internal_fn.afterInit = function () {
// can do something
};
c3_chart_internal_fn.init = function () {
var $$ = this, config = $$.config;
$$.initParams();
if (config.data_url) {
$$.convertUrlToData(config.data_url, config.data_mimeType, config.data_headers, config.data_keys, $$.initWithData);
}
else if (config.data_json) {
$$.initWithData($$.convertJsonToData(config.data_json, config.data_keys));
}
else if (config.data_rows) {
$$.initWithData($$.convertRowsToData(config.data_rows));
}
else if (config.data_columns) {
$$.initWithData($$.convertColumnsToData(config.data_columns));
}
else {
throw Error('url or json or rows or columns is required.');
}
};
c3_chart_internal_fn.initParams = function () {
var $$ = this, d3 = $$.d3, config = $$.config;
// MEMO: clipId needs to be unique because it conflicts when multiple charts exist
$$.clipId = "c3-" + (+new Date()) + '-clip',
$$.clipIdForXAxis = $$.clipId + '-xaxis',
$$.clipIdForYAxis = $$.clipId + '-yaxis',
$$.clipIdForGrid = $$.clipId + '-grid',
$$.clipIdForSubchart = $$.clipId + '-subchart',
$$.clipPath = $$.getClipPath($$.clipId),
$$.clipPathForXAxis = $$.getClipPath($$.clipIdForXAxis),
$$.clipPathForYAxis = $$.getClipPath($$.clipIdForYAxis);
$$.clipPathForGrid = $$.getClipPath($$.clipIdForGrid),
$$.clipPathForSubchart = $$.getClipPath($$.clipIdForSubchart),
$$.dragStart = null;
$$.dragging = false;
$$.flowing = false;
$$.cancelClick = false;
$$.mouseover = false;
$$.transiting = false;
$$.color = $$.generateColor();
$$.levelColor = $$.generateLevelColor();
$$.dataTimeFormat = config.data_xLocaltime ? d3.time.format : d3.time.format.utc;
$$.axisTimeFormat = config.axis_x_localtime ? d3.time.format : d3.time.format.utc;
$$.defaultAxisTimeFormat = $$.axisTimeFormat.multi([
[".%L", function (d) { return d.getMilliseconds(); }],
[":%S", function (d) { return d.getSeconds(); }],
["%I:%M", function (d) { return d.getMinutes(); }],
["%I %p", function (d) { return d.getHours(); }],
["%-m/%-d", function (d) { return d.getDay() && d.getDate() !== 1; }],
["%-m/%-d", function (d) { return d.getDate() !== 1; }],
["%-m/%-d", function (d) { return d.getMonth(); }],
["%Y/%-m/%-d", function () { return true; }]
]);
$$.hiddenTargetIds = [];
$$.hiddenLegendIds = [];
$$.focusedTargetIds = [];
$$.defocusedTargetIds = [];
$$.xOrient = config.axis_rotated ? "left" : "bottom";
$$.yOrient = config.axis_rotated ? (config.axis_y_inner ? "top" : "bottom") : (config.axis_y_inner ? "right" : "left");
$$.y2Orient = config.axis_rotated ? (config.axis_y2_inner ? "bottom" : "top") : (config.axis_y2_inner ? "left" : "right");
$$.subXOrient = config.axis_rotated ? "left" : "bottom";
$$.isLegendRight = config.legend_position === 'right';
$$.isLegendInset = config.legend_position === 'inset';
$$.isLegendTop = config.legend_inset_anchor === 'top-left' || config.legend_inset_anchor === 'top-right';
$$.isLegendLeft = config.legend_inset_anchor === 'top-left' || config.legend_inset_anchor === 'bottom-left';
$$.legendStep = 0;
$$.legendItemWidth = 0;
$$.legendItemHeight = 0;
$$.currentMaxTickWidths = {
x: 0,
y: 0,
y2: 0
};
$$.rotated_padding_left = 30;
$$.rotated_padding_right = config.axis_rotated && !config.axis_x_show ? 0 : 30;
$$.rotated_padding_top = 5;
$$.withoutFadeIn = {};
$$.intervalForObserveInserted = undefined;
$$.axes.subx = d3.selectAll([]); // needs when excluding subchart.js
};
c3_chart_internal_fn.initChartElements = function () {
if (this.initBar) { this.initBar(); }
if (this.initLine) { this.initLine(); }
if (this.initArc) { this.initArc(); }
if (this.initGauge) { this.initGauge(); }
if (this.initText) { this.initText(); }
};
c3_chart_internal_fn.initWithData = function (data) {
var $$ = this, d3 = $$.d3, config = $$.config;
var defs, main, binding = true;
$$.axis = new Axis($$);
if ($$.initPie) { $$.initPie(); }
if ($$.initBrush) { $$.initBrush(); }
if ($$.initZoom) { $$.initZoom(); }
if (!config.bindto) {
$$.selectChart = d3.selectAll([]);
}
else if (typeof config.bindto.node === 'function') {
$$.selectChart = config.bindto;
}
else {
$$.selectChart = d3.select(config.bindto);
}
if ($$.selectChart.empty()) {
$$.selectChart = d3.select(document.createElement('div')).style('opacity', 0);
$$.observeInserted($$.selectChart);
binding = false;
}
$$.selectChart.html("").classed("c3", true);
// Init data as targets
$$.data.xs = {};
$$.data.targets = $$.convertDataToTargets(data);
if (config.data_filter) {
$$.data.targets = $$.data.targets.filter(config.data_filter);
}
// Set targets to hide if needed
if (config.data_hide) {
$$.addHiddenTargetIds(config.data_hide === true ? $$.mapToIds($$.data.targets) : config.data_hide);
}
if (config.legend_hide) {
$$.addHiddenLegendIds(config.legend_hide === true ? $$.mapToIds($$.data.targets) : config.legend_hide);
}
// when gauge, hide legend // TODO: fix
if ($$.hasType('gauge')) {
config.legend_show = false;
}
// Init sizes and scales
$$.updateSizes();
$$.updateScales();
// Set domains for each scale
$$.x.domain(d3.extent($$.getXDomain($$.data.targets)));
$$.y.domain($$.getYDomain($$.data.targets, 'y'));
$$.y2.domain($$.getYDomain($$.data.targets, 'y2'));
$$.subX.domain($$.x.domain());
$$.subY.domain($$.y.domain());
$$.subY2.domain($$.y2.domain());
// Save original x domain for zoom update
$$.orgXDomain = $$.x.domain();
// Set initialized scales to brush and zoom
if ($$.brush) { $$.brush.scale($$.subX); }
if (config.zoom_enabled) { $$.zoom.scale($$.x); }
/*-- Basic Elements --*/
// Define svgs
$$.svg = $$.selectChart.append("svg")
.style("overflow", "hidden")
.on('mouseenter', function () { return config.onmouseover.call($$); })
.on('mouseleave', function () { return config.onmouseout.call($$); });
if ($$.config.svg_classname) {
$$.svg.attr('class', $$.config.svg_classname);
}
// Define defs
defs = $$.svg.append("defs");
$$.clipChart = $$.appendClip(defs, $$.clipId);
$$.clipXAxis = $$.appendClip(defs, $$.clipIdForXAxis);
$$.clipYAxis = $$.appendClip(defs, $$.clipIdForYAxis);
$$.clipGrid = $$.appendClip(defs, $$.clipIdForGrid);
$$.clipSubchart = $$.appendClip(defs, $$.clipIdForSubchart);
$$.updateSvgSize();
// Define regions
main = $$.main = $$.svg.append("g").attr("transform", $$.getTranslate('main'));
if ($$.initSubchart) { $$.initSubchart(); }
if ($$.initTooltip) { $$.initTooltip(); }
if ($$.initLegend) { $$.initLegend(); }
if ($$.initTitle) { $$.initTitle(); }
/*-- Main Region --*/
// text when empty
main.append("text")
.attr("class", CLASS.text + ' ' + CLASS.empty)
.attr("text-anchor", "middle") // horizontal centering of text at x position in all browsers.
.attr("dominant-baseline", "middle"); // vertical centering of text at y position in all browsers, except IE.
// Regions
$$.initRegion();
// Grids
$$.initGrid();
// Define g for chart area
main.append('g')
.attr("clip-path", $$.clipPath)
.attr('class', CLASS.chart);
// Grid lines
if (config.grid_lines_front) { $$.initGridLines(); }
// Cover whole with rects for events
$$.initEventRect();
// Define g for chart
$$.initChartElements();
// if zoom privileged, insert rect to forefront
// TODO: is this needed?
main.insert('rect', config.zoom_privileged ? null : 'g.' + CLASS.regions)
.attr('class', CLASS.zoomRect)
.attr('width', $$.width)
.attr('height', $$.height)
.style('opacity', 0)
.on("dblclick.zoom", null);
// Set default extent if defined
if (config.axis_x_extent) { $$.brush.extent($$.getDefaultExtent()); }
// Add Axis
$$.axis.init();
// Set targets
$$.updateTargets($$.data.targets);
// Draw with targets
if (binding) {
$$.updateDimension();
$$.config.oninit.call($$);
$$.redraw({
withTransition: false,
withTransform: true,
withUpdateXDomain: true,
withUpdateOrgXDomain: true,
withTransitionForAxis: false
});
}
// Bind resize event
$$.bindResize();
// export element of the chart
$$.api.element = $$.selectChart.node();
};
c3_chart_internal_fn.smoothLines = function (el, type) {
var $$ = this;
if (type === 'grid') {
el.each(function () {
var g = $$.d3.select(this),
x1 = g.attr('x1'),
x2 = g.attr('x2'),
y1 = g.attr('y1'),
y2 = g.attr('y2');
g.attr({
'x1': Math.ceil(x1),
'x2': Math.ceil(x2),
'y1': Math.ceil(y1),
'y2': Math.ceil(y2)
});
});
}
};
c3_chart_internal_fn.updateSizes = function () {
var $$ = this, config = $$.config;
var legendHeight = $$.legend ? $$.getLegendHeight() : 0,
legendWidth = $$.legend ? $$.getLegendWidth() : 0,
legendHeightForBottom = $$.isLegendRight || $$.isLegendInset ? 0 : legendHeight,
hasArc = $$.hasArcType(),
xAxisHeight = config.axis_rotated || hasArc ? 0 : $$.getHorizontalAxisHeight('x'),
subchartHeight = config.subchart_show && !hasArc ? (config.subchart_size_height + xAxisHeight) : 0;
$$.currentWidth = $$.getCurrentWidth();
$$.currentHeight = $$.getCurrentHeight();
// for main
$$.margin = config.axis_rotated ? {
top: $$.getHorizontalAxisHeight('y2') + $$.getCurrentPaddingTop(),
right: hasArc ? 0 : $$.getCurrentPaddingRight(),
bottom: $$.getHorizontalAxisHeight('y') + legendHeightForBottom + $$.getCurrentPaddingBottom(),
left: subchartHeight + (hasArc ? 0 : $$.getCurrentPaddingLeft())
} : {
top: 4 + $$.getCurrentPaddingTop(), // for top tick text
right: hasArc ? 0 : $$.getCurrentPaddingRight(),
bottom: xAxisHeight + subchartHeight + legendHeightForBottom + $$.getCurrentPaddingBottom(),
left: hasArc ? 0 : $$.getCurrentPaddingLeft()
};
// for subchart
$$.margin2 = config.axis_rotated ? {
top: $$.margin.top,
right: NaN,
bottom: 20 + legendHeightForBottom,
left: $$.rotated_padding_left
} : {
top: $$.currentHeight - subchartHeight - legendHeightForBottom,
right: NaN,
bottom: xAxisHeight + legendHeightForBottom,
left: $$.margin.left
};
// for legend
$$.margin3 = {
top: 0,
right: NaN,
bottom: 0,
left: 0
};
if ($$.updateSizeForLegend) { $$.updateSizeForLegend(legendHeight, legendWidth); }
$$.width = $$.currentWidth - $$.margin.left - $$.margin.right;
$$.height = $$.currentHeight - $$.margin.top - $$.margin.bottom;
if ($$.width < 0) { $$.width = 0; }
if ($$.height < 0) { $$.height = 0; }
$$.width2 = config.axis_rotated ? $$.margin.left - $$.rotated_padding_left - $$.rotated_padding_right : $$.width;
$$.height2 = config.axis_rotated ? $$.height : $$.currentHeight - $$.margin2.top - $$.margin2.bottom;
if ($$.width2 < 0) { $$.width2 = 0; }
if ($$.height2 < 0) { $$.height2 = 0; }
// for arc
$$.arcWidth = $$.width - ($$.isLegendRight ? legendWidth + 10 : 0);
$$.arcHeight = $$.height - ($$.isLegendRight ? 0 : 10);
if ($$.hasType('gauge') && !config.gauge_fullCircle) {
$$.arcHeight += $$.height - $$.getGaugeLabelHeight();
}
if ($$.updateRadius) { $$.updateRadius(); }
if ($$.isLegendRight && hasArc) {
$$.margin3.left = $$.arcWidth / 2 + $$.radiusExpanded * 1.1;
}
};
c3_chart_internal_fn.updateTargets = function (targets) {
var $$ = this;
/*-- Main --*/
//-- Text --//
$$.updateTargetsForText(targets);
//-- Bar --//
$$.updateTargetsForBar(targets);
//-- Line --//
$$.updateTargetsForLine(targets);
//-- Arc --//
if ($$.hasArcType() && $$.updateTargetsForArc) { $$.updateTargetsForArc(targets); }
/*-- Sub --*/
if ($$.updateTargetsForSubchart) { $$.updateTargetsForSubchart(targets); }
// Fade-in each chart
$$.showTargets();
};
c3_chart_internal_fn.showTargets = function () {
var $$ = this;
$$.svg.selectAll('.' + CLASS.target).filter(function (d) { return $$.isTargetToShow(d.id); })
.transition().duration($$.config.transition_duration)
.style("opacity", 1);
};
c3_chart_internal_fn.redraw = function (options, transitions) {
var $$ = this, main = $$.main, d3 = $$.d3, config = $$.config;
var areaIndices = $$.getShapeIndices($$.isAreaType), barIndices = $$.getShapeIndices($$.isBarType), lineIndices = $$.getShapeIndices($$.isLineType);
var withY, withSubchart, withTransition, withTransitionForExit, withTransitionForAxis,
withTransform, withUpdateXDomain, withUpdateOrgXDomain, withTrimXDomain, withLegend,
withEventRect, withDimension, withUpdateXAxis;
var hideAxis = $$.hasArcType();
var drawArea, drawBar, drawLine, xForText, yForText;
var duration, durationForExit, durationForAxis;
var waitForDraw, flow;
var targetsToShow = $$.filterTargetsToShow($$.data.targets), tickValues, i, intervalForCulling, xDomainForZoom;
var xv = $$.xv.bind($$), cx, cy;
options = options || {};
withY = getOption(options, "withY", true);
withSubchart = getOption(options, "withSubchart", true);
withTransition = getOption(options, "withTransition", true);
withTransform = getOption(options, "withTransform", false);
withUpdateXDomain = getOption(options, "withUpdateXDomain", false);
withUpdateOrgXDomain = getOption(options, "withUpdateOrgXDomain", false);
withTrimXDomain = getOption(options, "withTrimXDomain", true);
withUpdateXAxis = getOption(options, "withUpdateXAxis", withUpdateXDomain);
withLegend = getOption(options, "withLegend", false);
withEventRect = getOption(options, "withEventRect", true);
withDimension = getOption(options, "withDimension", true);
withTransitionForExit = getOption(options, "withTransitionForExit", withTransition);
withTransitionForAxis = getOption(options, "withTransitionForAxis", withTransition);
duration = withTransition ? config.transition_duration : 0;
durationForExit = withTransitionForExit ? duration : 0;
durationForAxis = withTransitionForAxis ? duration : 0;
transitions = transitions || $$.axis.generateTransitions(durationForAxis);
// update legend and transform each g
if (withLegend && config.legend_show) {
$$.updateLegend($$.mapToIds($$.data.targets), options, transitions);
} else if (withDimension) {
// need to update dimension (e.g. axis.y.tick.values) because y tick values should change
// no need to update axis in it because they will be updated in redraw()
$$.updateDimension(true);
}
// MEMO: needed for grids calculation
if ($$.isCategorized() && targetsToShow.length === 0) {
$$.x.domain([0, $$.axes.x.selectAll('.tick').size()]);
}
if (targetsToShow.length) {
$$.updateXDomain(targetsToShow, withUpdateXDomain, withUpdateOrgXDomain, withTrimXDomain);
if (!config.axis_x_tick_values) {
tickValues = $$.axis.updateXAxisTickValues(targetsToShow);
}
} else {
$$.xAxis.tickValues([]);
$$.subXAxis.tickValues([]);
}
if (config.zoom_rescale && !options.flow) {
xDomainForZoom = $$.x.orgDomain();
}
$$.y.domain($$.getYDomain(targetsToShow, 'y', xDomainForZoom));
$$.y2.domain($$.getYDomain(targetsToShow, 'y2', xDomainForZoom));
if (!config.axis_y_tick_values && config.axis_y_tick_count) {
$$.yAxis.tickValues($$.axis.generateTickValues($$.y.domain(), config.axis_y_tick_count));
}
if (!config.axis_y2_tick_values && config.axis_y2_tick_count) {
$$.y2Axis.tickValues($$.axis.generateTickValues($$.y2.domain(), config.axis_y2_tick_count));
}
// axes
$$.axis.redraw(transitions, hideAxis);
// Update axis label
$$.axis.updateLabels(withTransition);
// show/hide if manual culling needed
if ((withUpdateXDomain || withUpdateXAxis) && targetsToShow.length) {
if (config.axis_x_tick_culling && tickValues) {
for (i = 1; i < tickValues.length; i++) {
if (tickValues.length / i < config.axis_x_tick_culling_max) {
intervalForCulling = i;
break;
}
}
$$.svg.selectAll('.' + CLASS.axisX + ' .tick text').each(function (e) {
var index = tickValues.indexOf(e);
if (index >= 0) {
d3.select(this).style('display', index % intervalForCulling ? 'none' : 'block');
}
});
} else {
$$.svg.selectAll('.' + CLASS.axisX + ' .tick text').style('display', 'block');
}
}
// setup drawer - MEMO: these must be called after axis updated
drawArea = $$.generateDrawArea ? $$.generateDrawArea(areaIndices, false) : undefined;
drawBar = $$.generateDrawBar ? $$.generateDrawBar(barIndices) : undefined;
drawLine = $$.generateDrawLine ? $$.generateDrawLine(lineIndices, false) : undefined;
xForText = $$.generateXYForText(areaIndices, barIndices, lineIndices, true);
yForText = $$.generateXYForText(areaIndices, barIndices, lineIndices, false);
// Update sub domain
if (withY) {
$$.subY.domain($$.getYDomain(targetsToShow, 'y'));
$$.subY2.domain($$.getYDomain(targetsToShow, 'y2'));
}
// xgrid focus
$$.updateXgridFocus();
// Data empty label positioning and text.
main.select("text." + CLASS.text + '.' + CLASS.empty)
.attr("x", $$.width / 2)
.attr("y", $$.height / 2)
.text(config.data_empty_label_text)
.transition()
.style('opacity', targetsToShow.length ? 0 : 1);
// grid
$$.updateGrid(duration);
// rect for regions
$$.updateRegion(duration);
// bars
$$.updateBar(durationForExit);
// lines, areas and cricles
$$.updateLine(durationForExit);
$$.updateArea(durationForExit);
$$.updateCircle();
// text
if ($$.hasDataLabel()) {
$$.updateText(durationForExit);
}
// title
if ($$.redrawTitle) { $$.redrawTitle(); }
// arc
if ($$.redrawArc) { $$.redrawArc(duration, durationForExit, withTransform); }
// subchart
if ($$.redrawSubchart) {
$$.redrawSubchart(withSubchart, transitions, duration, durationForExit, areaIndices, barIndices, lineIndices);
}
// circles for select
main.selectAll('.' + CLASS.selectedCircles)
.filter($$.isBarType.bind($$))
.selectAll('circle')
.remove();
// event rects will redrawn when flow called
if (config.interaction_enabled && !options.flow && withEventRect) {
$$.redrawEventRect();
if ($$.updateZoom) { $$.updateZoom(); }
}
// update circleY based on updated parameters
$$.updateCircleY();
// generate circle x/y functions depending on updated params
cx = ($$.config.axis_rotated ? $$.circleY : $$.circleX).bind($$);
cy = ($$.config.axis_rotated ? $$.circleX : $$.circleY).bind($$);
if (options.flow) {
flow = $$.generateFlow({
targets: targetsToShow,
flow: options.flow,
duration: options.flow.duration,
drawBar: drawBar,
drawLine: drawLine,
drawArea: drawArea,
cx: cx,
cy: cy,
xv: xv,
xForText: xForText,
yForText: yForText
});
}
if ((duration || flow) && $$.isTabVisible()) { // Only use transition if tab visible. See #938.
// transition should be derived from one transition
d3.transition().duration(duration).each(function () {
var transitionsToWait = [];
// redraw and gather transitions
[
$$.redrawBar(drawBar, true),
$$.redrawLine(drawLine, true),
$$.redrawArea(drawArea, true),
$$.redrawCircle(cx, cy, true),
$$.redrawText(xForText, yForText, options.flow, true),
$$.redrawRegion(true),
$$.redrawGrid(true),
].forEach(function (transitions) {
transitions.forEach(function (transition) {
transitionsToWait.push(transition);
});
});
// Wait for end of transitions to call flow and onrendered callback
waitForDraw = $$.generateWait();
transitionsToWait.forEach(function (t) {
waitForDraw.add(t);
});
})
.call(waitForDraw, function () {
if (flow) {
flow();
}
if (config.onrendered) {
config.onrendered.call($$);
}
});
}
else {
$$.redrawBar(drawBar);
$$.redrawLine(drawLine);
$$.redrawArea(drawArea);
$$.redrawCircle(cx, cy);
$$.redrawText(xForText, yForText, options.flow);
$$.redrawRegion();
$$.redrawGrid();
if (config.onrendered) {
config.onrendered.call($$);
}
}
// update fadein condition
$$.mapToIds($$.data.targets).forEach(function (id) {
$$.withoutFadeIn[id] = true;
});
};
c3_chart_internal_fn.updateAndRedraw = function (options) {
var $$ = this, config = $$.config, transitions;
options = options || {};
// same with redraw
options.withTransition = getOption(options, "withTransition", true);
options.withTransform = getOption(options, "withTransform", false);
options.withLegend = getOption(options, "withLegend", false);
// NOT same with redraw
options.withUpdateXDomain = true;
options.withUpdateOrgXDomain = true;
options.withTransitionForExit = false;
options.withTransitionForTransform = getOption(options, "withTransitionForTransform", options.withTransition);
// MEMO: this needs to be called before updateLegend and it means this ALWAYS needs to be called)
$$.updateSizes();
// MEMO: called in updateLegend in redraw if withLegend
if (!(options.withLegend && config.legend_show)) {
transitions = $$.axis.generateTransitions(options.withTransitionForAxis ? config.transition_duration : 0);
// Update scales
$$.updateScales();
$$.updateSvgSize();
// Update g positions
$$.transformAll(options.withTransitionForTransform, transitions);
}
// Draw with new sizes & scales
$$.redraw(options, transitions);
};
c3_chart_internal_fn.redrawWithoutRescale = function () {
this.redraw({
withY: false,
withSubchart: false,
withEventRect: false,
withTransitionForAxis: false
});
};
c3_chart_internal_fn.isTimeSeries = function () {
return this.config.axis_x_type === 'timeseries';
};
c3_chart_internal_fn.isCategorized = function () {
return this.config.axis_x_type.indexOf('categor') >= 0;
};
c3_chart_internal_fn.isCustomX = function () {
var $$ = this, config = $$.config;
return !$$.isTimeSeries() && (config.data_x || notEmpty(config.data_xs));
};
c3_chart_internal_fn.isTimeSeriesY = function () {
return this.config.axis_y_type === 'timeseries';
};
c3_chart_internal_fn.getTranslate = function (target) {
var $$ = this, config = $$.config, x, y;
if (target === 'main') {
x = asHalfPixel($$.margin.left);
y = asHalfPixel($$.margin.top);
} else if (target === 'context') {
x = asHalfPixel($$.margin2.left);
y = asHalfPixel($$.margin2.top);
} else if (target === 'legend') {
x = $$.margin3.left;
y = $$.margin3.top;
} else if (target === 'x') {
x = 0;
y = config.axis_rotated ? 0 : $$.height;
} else if (target === 'y') {
x = 0;
y = config.axis_rotated ? $$.height : 0;
} else if (target === 'y2') {
x = config.axis_rotated ? 0 : $$.width;
y = config.axis_rotated ? 1 : 0;
} else if (target === 'subx') {
x = 0;
y = config.axis_rotated ? 0 : $$.height2;
} else if (target === 'arc') {
x = $$.arcWidth / 2;
y = $$.arcHeight / 2;
}
return "translate(" + x + "," + y + ")";
};
c3_chart_internal_fn.initialOpacity = function (d) {
return d.value !== null && this.withoutFadeIn[d.id] ? 1 : 0;
};
c3_chart_internal_fn.initialOpacityForCircle = function (d) {
return d.value !== null && this.withoutFadeIn[d.id] ? this.opacityForCircle(d) : 0;
};
c3_chart_internal_fn.opacityForCircle = function (d) {
var opacity = this.config.point_show ? 1 : 0;
return isValue(d.value) ? (this.isScatterType(d) ? 0.5 : opacity) : 0;
};
c3_chart_internal_fn.opacityForText = function () {
return this.hasDataLabel() ? 1 : 0;
};
c3_chart_internal_fn.xx = function (d) {
return d ? this.x(d.x) : null;
};
c3_chart_internal_fn.xv = function (d) {
var $$ = this, value = d.value;
if ($$.isTimeSeries()) {
value = $$.parseDate(d.value);
}
else if ($$.isCategorized() && typeof d.value === 'string') {
value = $$.config.axis_x_categories.indexOf(d.value);
}
return Math.ceil($$.x(value));
};
c3_chart_internal_fn.yv = function (d) {
var $$ = this,
yScale = d.axis && d.axis === 'y2' ? $$.y2 : $$.y;
return Math.ceil(yScale(d.value));
};
c3_chart_internal_fn.subxx = function (d) {
return d ? this.subX(d.x) : null;
};
c3_chart_internal_fn.transformMain = function (withTransition, transitions) {
var $$ = this,
xAxis, yAxis, y2Axis;
if (transitions && transitions.axisX) {
xAxis = transitions.axisX;
} else {
xAxis = $$.main.select('.' + CLASS.axisX);
if (withTransition) { xAxis = xAxis.transition(); }
}
if (transitions && transitions.axisY) {
yAxis = transitions.axisY;
} else {
yAxis = $$.main.select('.' + CLASS.axisY);
if (withTransition) { yAxis = yAxis.transition(); }
}
if (transitions && transitions.axisY2) {
y2Axis = transitions.axisY2;
} else {
y2Axis = $$.main.select('.' + CLASS.axisY2);
if (withTransition) { y2Axis = y2Axis.transition(); }
}
(withTransition ? $$.main.transition() : $$.main).attr("transform", $$.getTranslate('main'));
xAxis.attr("transform", $$.getTranslate('x'));
yAxis.attr("transform", $$.getTranslate('y'));
y2Axis.attr("transform", $$.getTranslate('y2'));
$$.main.select('.' + CLASS.chartArcs).attr("transform", $$.getTranslate('arc'));
};
c3_chart_internal_fn.transformAll = function (withTransition, transitions) {
var $$ = this;
$$.transformMain(withTransition, transitions);
if ($$.config.subchart_show) { $$.transformContext(withTransition, transitions); }
if ($$.legend) { $$.transformLegend(withTransition); }
};
c3_chart_internal_fn.updateSvgSize = function () {
var $$ = this,
brush = $$.svg.select(".c3-brush .background");
$$.svg.attr('width', $$.currentWidth).attr('height', $$.currentHeight);
$$.svg.selectAll(['#' + $$.clipId, '#' + $$.clipIdForGrid]).select('rect')
.attr('width', $$.width)
.attr('height', $$.height);
$$.svg.select('#' + $$.clipIdForXAxis).select('rect')
.attr('x', $$.getXAxisClipX.bind($$))
.attr('y', $$.getXAxisClipY.bind($$))
.attr('width', $$.getXAxisClipWidth.bind($$))
.attr('height', $$.getXAxisClipHeight.bind($$));
$$.svg.select('#' + $$.clipIdForYAxis).select('rect')
.attr('x', $$.getYAxisClipX.bind($$))
.attr('y', $$.getYAxisClipY.bind($$))
.attr('width', $$.getYAxisClipWidth.bind($$))
.attr('height', $$.getYAxisClipHeight.bind($$));
$$.svg.select('#' + $$.clipIdForSubchart).select('rect')
.attr('width', $$.width)
.attr('height', brush.size() ? brush.attr('height') : 0);
$$.svg.select('.' + CLASS.zoomRect)
.attr('width', $$.width)
.attr('height', $$.height);
// MEMO: parent div's height will be bigger than svg when <!DOCTYPE html>
$$.selectChart.style('max-height', $$.currentHeight + "px");
};
c3_chart_internal_fn.updateDimension = function (withoutAxis) {
var $$ = this;
if (!withoutAxis) {
if ($$.config.axis_rotated) {
$$.axes.x.call($$.xAxis);
$$.axes.subx.call($$.subXAxis);
} else {
$$.axes.y.call($$.yAxis);
$$.axes.y2.call($$.y2Axis);
}
}
$$.updateSizes();
$$.updateScales();
$$.updateSvgSize();
$$.transformAll(false);
};
c3_chart_internal_fn.observeInserted = function (selection) {
var $$ = this, observer;
if (typeof MutationObserver === 'undefined') {
window.console.error("MutationObserver not defined.");
return;
}
observer= new MutationObserver(function (mutations) {
mutations.forEach(function (mutation) {
if (mutation.type === 'childList' && mutation.previousSibling) {
observer.disconnect();
// need to wait for completion of load because size calculation requires the actual sizes determined after that completion
$$.intervalForObserveInserted = window.setInterval(function () {
// parentNode will NOT be null when completed
if (selection.node().parentNode) {
window.clearInterval($$.intervalForObserveInserted);
$$.updateDimension();
if ($$.brush) { $$.brush.update(); }
$$.config.oninit.call($$);
$$.redraw({
withTransform: true,
withUpdateXDomain: true,
withUpdateOrgXDomain: true,
withTransition: false,
withTransitionForTransform: false,
withLegend: true
});
selection.transition().style('opacity', 1);
}
}, 10);
}
});
});
observer.observe(selection.node(), {attributes: true, childList: true, characterData: true});
};
c3_chart_internal_fn.bindResize = function () {
var $$ = this, config = $$.config;
$$.resizeFunction = $$.generateResize();
$$.resizeFunction.add(function () {
config.onresize.call($$);
});
if (config.resize_auto) {
$$.resizeFunction.add(function () {
if ($$.resizeTimeout !== undefined) {
window.clearTimeout($$.resizeTimeout);
}
$$.resizeTimeout = window.setTimeout(function () {
delete $$.resizeTimeout;
$$.api.flush();
}, 100);
});
}
$$.resizeFunction.add(function () {
config.onresized.call($$);
});
if (window.attachEvent) {
window.attachEvent('onresize', $$.resizeFunction);
} else if (window.addEventListener) {
window.addEventListener('resize', $$.resizeFunction, false);
} else {
// fallback to this, if this is a very old browser
var wrapper = window.onresize;
if (!wrapper) {
// create a wrapper that will call all charts
wrapper = $$.generateResize();
} else if (!wrapper.add || !wrapper.remove) {
// there is already a handler registered, make sure we call it too
wrapper = $$.generateResize();
wrapper.add(window.onresize);
}
// add this graph to the wrapper, we will be removed if the user calls destroy
wrapper.add($$.resizeFunction);
window.onresize = wrapper;
}
};
c3_chart_internal_fn.generateResize = function () {
var resizeFunctions = [];
function callResizeFunctions() {
resizeFunctions.forEach(function (f) {
f();
});
}
callResizeFunctions.add = function (f) {
resizeFunctions.push(f);
};
callResizeFunctions.remove = function (f) {
for (var i = 0; i < resizeFunctions.length; i++) {
if (resizeFunctions[i] === f) {
resizeFunctions.splice(i, 1);
break;
}
}
};
return callResizeFunctions;
};
c3_chart_internal_fn.endall = function (transition, callback) {
var n = 0;
transition
.each(function () { ++n; })
.each("end", function () {
if (!--n) { callback.apply(this, arguments); }
});
};
c3_chart_internal_fn.generateWait = function () {
var transitionsToWait = [],
f = function (transition, callback) {
var timer = setInterval(function () {
var done = 0;
transitionsToWait.forEach(function (t) {
if (t.empty()) {
done += 1;
return;
}
try {
t.transition();
} catch (e) {
done += 1;
}
});
if (done === transitionsToWait.length) {
clearInterval(timer);
if (callback) { callback(); }
}
}, 10);
};
f.add = function (transition) {
transitionsToWait.push(transition);
};
return f;
};
c3_chart_internal_fn.parseDate = function (date) {
var $$ = this, parsedDate;
if (date instanceof Date) {
parsedDate = date;
} else if (typeof date === 'string') {
parsedDate = $$.dataTimeFormat($$.config.data_xFormat).parse(date);
} else if (typeof date === 'number' && !isNaN(date)) {
parsedDate = new Date(+date);
}
if (!parsedDate || isNaN(+parsedDate)) {
window.console.error("Failed to parse x '" + date + "' to Date object");
}
return parsedDate;
};
c3_chart_internal_fn.isTabVisible = function () {
var hidden;
if (typeof document.hidden !== "undefined") { // Opera 12.10 and Firefox 18 and later support
hidden = "hidden";
} else if (typeof document.mozHidden !== "undefined") {
hidden = "mozHidden";
} else if (typeof document.msHidden !== "undefined") {
hidden = "msHidden";
} else if (typeof document.webkitHidden !== "undefined") {
hidden = "webkitHidden";
}
return document[hidden] ? false : true;
};
c3_chart_internal_fn.getDefaultConfig = function () {
var config = {
bindto: '#chart',
svg_classname: undefined,
size_width: undefined,
size_height: undefined,
padding_left: undefined,
padding_right: undefined,
padding_top: undefined,
padding_bottom: undefined,
resize_auto: true,
zoom_enabled: false,
zoom_extent: undefined,
zoom_privileged: false,
zoom_rescale: false,
zoom_onzoom: function () {},
zoom_onzoomstart: function () {},
zoom_onzoomend: function () {},
zoom_x_min: undefined,
zoom_x_max: undefined,
interaction_brighten: true,
interaction_enabled: true,
onmouseover: function () {},
onmouseout: function () {},
onresize: function () {},
onresized: function () {},
oninit: function () {},
onrendered: function () {},
transition_duration: 350,
data_x: undefined,
data_xs: {},
data_xFormat: '%Y-%m-%d',
data_xLocaltime: true,
data_xSort: true,
data_idConverter: function (id) { return id; },
data_names: {},
data_classes: {},
data_groups: [],
data_axes: {},
data_type: undefined,
data_types: {},
data_labels: {},
data_order: 'desc',
data_regions: {},
data_color: undefined,
data_colors: {},
data_hide: false,
data_filter: undefined,
data_selection_enabled: false,
data_selection_grouped: false,
data_selection_isselectable: function () { return true; },
data_selection_multiple: true,
data_selection_draggable: false,
data_onclick: function () {},
data_onmouseover: function () {},
data_onmouseout: function () {},
data_onselected: function () {},
data_onunselected: function () {},
data_url: undefined,
data_headers: undefined,
data_json: undefined,
data_rows: undefined,
data_columns: undefined,
data_mimeType: undefined,
data_keys: undefined,
// configuration for no plot-able data supplied.
data_empty_label_text: "",
// subchart
subchart_show: false,
subchart_size_height: 60,
subchart_axis_x_show: true,
subchart_onbrush: function () {},
// color
color_pattern: [],
color_threshold: {},
// legend
legend_show: true,
legend_hide: false,
legend_position: 'bottom',
legend_inset_anchor: 'top-left',
legend_inset_x: 10,
legend_inset_y: 0,
legend_inset_step: undefined,
legend_item_onclick: undefined,
legend_item_onmouseover: undefined,
legend_item_onmouseout: undefined,
legend_equally: false,
legend_padding: 0,
legend_item_tile_width: 10,
legend_item_tile_height: 10,
// axis
axis_rotated: false,
axis_x_show: true,
axis_x_type: 'indexed',
axis_x_localtime: true,
axis_x_categories: [],
axis_x_tick_centered: false,
axis_x_tick_format: undefined,
axis_x_tick_culling: {},
axis_x_tick_culling_max: 10,
axis_x_tick_count: undefined,
axis_x_tick_fit: true,
axis_x_tick_values: null,
axis_x_tick_rotate: 0,
axis_x_tick_outer: true,
axis_x_tick_multiline: true,
axis_x_tick_width: null,
axis_x_max: undefined,
axis_x_min: undefined,
axis_x_padding: {},
axis_x_height: undefined,
axis_x_extent: undefined,
axis_x_label: {},
axis_y_show: true,
axis_y_type: undefined,
axis_y_max: undefined,
axis_y_min: undefined,
axis_y_inverted: false,
axis_y_center: undefined,
axis_y_inner: undefined,
axis_y_label: {},
axis_y_tick_format: undefined,
axis_y_tick_outer: true,
axis_y_tick_values: null,
axis_y_tick_rotate: 0,
axis_y_tick_count: undefined,
axis_y_tick_time_value: undefined,
axis_y_tick_time_interval: undefined,
axis_y_padding: {},
axis_y_default: undefined,
axis_y2_show: false,
axis_y2_max: undefined,
axis_y2_min: undefined,
axis_y2_inverted: false,
axis_y2_center: undefined,
axis_y2_inner: undefined,
axis_y2_label: {},
axis_y2_tick_format: undefined,
axis_y2_tick_outer: true,
axis_y2_tick_values: null,
axis_y2_tick_count: undefined,
axis_y2_padding: {},
axis_y2_default: undefined,
// grid
grid_x_show: false,
grid_x_type: 'tick',
grid_x_lines: [],
grid_y_show: false,
// not used
// grid_y_type: 'tick',
grid_y_lines: [],
grid_y_ticks: 10,
grid_focus_show: true,
grid_lines_front: true,
// point - point of each data
point_show: true,
point_r: 2.5,
point_sensitivity: 10,
point_focus_expand_enabled: true,
point_focus_expand_r: undefined,
point_select_r: undefined,
// line
line_connectNull: false,
line_step_type: 'step',
// bar
bar_width: undefined,
bar_width_ratio: 0.6,
bar_width_max: undefined,
bar_zerobased: true,
// area
area_zerobased: true,
area_above: false,
// pie
pie_label_show: true,
pie_label_format: undefined,
pie_label_threshold: 0.05,
pie_label_ratio: undefined,
pie_expand: {},
pie_expand_duration: 50,
// gauge
gauge_fullCircle: false,
gauge_label_show: true,
gauge_label_format: undefined,
gauge_min: 0,
gauge_max: 100,
gauge_startingAngle: -1 * Math.PI/2,
gauge_units: undefined,
gauge_width: undefined,
gauge_expand: {},
gauge_expand_duration: 50,
// donut
donut_label_show: true,
donut_label_format: undefined,
donut_label_threshold: 0.05,
donut_label_ratio: undefined,
donut_width: undefined,
donut_title: "",
donut_expand: {},
donut_expand_duration: 50,
// spline
spline_interpolation_type: 'cardinal',
// region - region to change style
regions: [],
// tooltip - show when mouseover on each data
tooltip_show: true,
tooltip_grouped: true,
tooltip_format_title: undefined,
tooltip_format_name: undefined,
tooltip_format_value: undefined,
tooltip_position: undefined,
tooltip_contents: function (d, defaultTitleFormat, defaultValueFormat, color) {
return this.getTooltipContent ? this.getTooltipContent(d, defaultTitleFormat, defaultValueFormat, color) : '';
},
tooltip_init_show: false,
tooltip_init_x: 0,
tooltip_init_position: {top: '0px', left: '50px'},
tooltip_onshow: function () {},
tooltip_onhide: function () {},
// title
title_text: undefined,
title_padding: {
top: 0,
right: 0,
bottom: 0,
left: 0
},
title_position: 'top-center',
};
Object.keys(this.additionalConfig).forEach(function (key) {
config[key] = this.additionalConfig[key];
}, this);
return config;
};
c3_chart_internal_fn.additionalConfig = {};
c3_chart_internal_fn.loadConfig = function (config) {
var this_config = this.config, target, keys, read;
function find() {
var key = keys.shift();
// console.log("key =>", key, ", target =>", target);
if (key && target && typeof target === 'object' && key in target) {
target = target[key];
return find();
}
else if (!key) {
return target;
}
else {
return undefined;
}
}
Object.keys(this_config).forEach(function (key) {
target = config;
keys = key.split('_');
read = find();
// console.log("CONFIG : ", key, read);
if (isDefined(read)) {
this_config[key] = read;
}
});
};
c3_chart_internal_fn.getScale = function (min, max, forTimeseries) {
return (forTimeseries ? this.d3.time.scale() : this.d3.scale.linear()).range([min, max]);
};
c3_chart_internal_fn.getX = function (min, max, domain, offset) {
var $$ = this,
scale = $$.getScale(min, max, $$.isTimeSeries()),
_scale = domain ? scale.domain(domain) : scale, key;
// Define customized scale if categorized axis
if ($$.isCategorized()) {
offset = offset || function () { return 0; };
scale = function (d, raw) {
var v = _scale(d) + offset(d);
return raw ? v : Math.ceil(v);
};
} else {
scale = function (d, raw) {
var v = _scale(d);
return raw ? v : Math.ceil(v);
};
}
// define functions
for (key in _scale) {
scale[key] = _scale[key];
}
scale.orgDomain = function () {
return _scale.domain();
};
// define custom domain() for categorized axis
if ($$.isCategorized()) {
scale.domain = function (domain) {
if (!arguments.length) {
domain = this.orgDomain();
return [domain[0], domain[1] + 1];
}
_scale.domain(domain);
return scale;
};
}
return scale;
};
c3_chart_internal_fn.getY = function (min, max, domain) {
var scale = this.getScale(min, max, this.isTimeSeriesY());
if (domain) { scale.domain(domain); }
return scale;
};
c3_chart_internal_fn.getYScale = function (id) {
return this.axis.getId(id) === 'y2' ? this.y2 : this.y;
};
c3_chart_internal_fn.getSubYScale = function (id) {
return this.axis.getId(id) === 'y2' ? this.subY2 : this.subY;
};
c3_chart_internal_fn.updateScales = function () {
var $$ = this, config = $$.config,
forInit = !$$.x;
// update edges
$$.xMin = config.axis_rotated ? 1 : 0;
$$.xMax = config.axis_rotated ? $$.height : $$.width;
$$.yMin = config.axis_rotated ? 0 : $$.height;
$$.yMax = config.axis_rotated ? $$.width : 1;
$$.subXMin = $$.xMin;
$$.subXMax = $$.xMax;
$$.subYMin = config.axis_rotated ? 0 : $$.height2;
$$.subYMax = config.axis_rotated ? $$.width2 : 1;
// update scales
$$.x = $$.getX($$.xMin, $$.xMax, forInit ? undefined : $$.x.orgDomain(), function () { return $$.xAxis.tickOffset(); });
$$.y = $$.getY($$.yMin, $$.yMax, forInit ? config.axis_y_default : $$.y.domain());
$$.y2 = $$.getY($$.yMin, $$.yMax, forInit ? config.axis_y2_default : $$.y2.domain());
$$.subX = $$.getX($$.xMin, $$.xMax, $$.orgXDomain, function (d) { return d % 1 ? 0 : $$.subXAxis.tickOffset(); });
$$.subY = $$.getY($$.subYMin, $$.subYMax, forInit ? config.axis_y_default : $$.subY.domain());
$$.subY2 = $$.getY($$.subYMin, $$.subYMax, forInit ? config.axis_y2_default : $$.subY2.domain());
// update axes
$$.xAxisTickFormat = $$.axis.getXAxisTickFormat();
$$.xAxisTickValues = $$.axis.getXAxisTickValues();
$$.yAxisTickValues = $$.axis.getYAxisTickValues();
$$.y2AxisTickValues = $$.axis.getY2AxisTickValues();
$$.xAxis = $$.axis.getXAxis($$.x, $$.xOrient, $$.xAxisTickFormat, $$.xAxisTickValues, config.axis_x_tick_outer);
$$.subXAxis = $$.axis.getXAxis($$.subX, $$.subXOrient, $$.xAxisTickFormat, $$.xAxisTickValues, config.axis_x_tick_outer);
$$.yAxis = $$.axis.getYAxis($$.y, $$.yOrient, config.axis_y_tick_format, $$.yAxisTickValues, config.axis_y_tick_outer);
$$.y2Axis = $$.axis.getYAxis($$.y2, $$.y2Orient, config.axis_y2_tick_format, $$.y2AxisTickValues, config.axis_y2_tick_outer);
// Set initialized scales to brush and zoom
if (!forInit) {
if ($$.brush) { $$.brush.scale($$.subX); }
if (config.zoom_enabled) { $$.zoom.scale($$.x); }
}
// update for arc
if ($$.updateArc) { $$.updateArc(); }
};
c3_chart_internal_fn.getYDomainMin = function (targets) {
var $$ = this, config = $$.config,
ids = $$.mapToIds(targets), ys = $$.getValuesAsIdKeyed(targets),
j, k, baseId, idsInGroup, id, hasNegativeValue;
if (config.data_groups.length > 0) {
hasNegativeValue = $$.hasNegativeValueInTargets(targets);
for (j = 0; j < config.data_groups.length; j++) {
// Determine baseId
idsInGroup = config.data_groups[j].filter(function (id) { return ids.indexOf(id) >= 0; });
if (idsInGroup.length === 0) { continue; }
baseId = idsInGroup[0];
// Consider negative values
if (hasNegativeValue && ys[baseId]) {
ys[baseId].forEach(function (v, i) {
ys[baseId][i] = v < 0 ? v : 0;
});
}
// Compute min
for (k = 1; k < idsInGroup.length; k++) {
id = idsInGroup[k];
if (! ys[id]) { continue; }
ys[id].forEach(function (v, i) {
if ($$.axis.getId(id) === $$.axis.getId(baseId) && ys[baseId] && !(hasNegativeValue && +v > 0)) {
ys[baseId][i] += +v;
}
});
}
}
}
return $$.d3.min(Object.keys(ys).map(function (key) { return $$.d3.min(ys[key]); }));
};
c3_chart_internal_fn.getYDomainMax = function (targets) {
var $$ = this, config = $$.config,
ids = $$.mapToIds(targets), ys = $$.getValuesAsIdKeyed(targets),
j, k, baseId, idsInGroup, id, hasPositiveValue;
if (config.data_groups.length > 0) {
hasPositiveValue = $$.hasPositiveValueInTargets(targets);
for (j = 0; j < config.data_groups.length; j++) {
// Determine baseId
idsInGroup = config.data_groups[j].filter(function (id) { return ids.indexOf(id) >= 0; });
if (idsInGroup.length === 0) { continue; }
baseId = idsInGroup[0];
// Consider positive values
if (hasPositiveValue && ys[baseId]) {
ys[baseId].forEach(function (v, i) {
ys[baseId][i] = v > 0 ? v : 0;
});
}
// Compute max
for (k = 1; k < idsInGroup.length; k++) {
id = idsInGroup[k];
if (! ys[id]) { continue; }
ys[id].forEach(function (v, i) {
if ($$.axis.getId(id) === $$.axis.getId(baseId) && ys[baseId] && !(hasPositiveValue && +v < 0)) {
ys[baseId][i] += +v;
}
});
}
}
}
return $$.d3.max(Object.keys(ys).map(function (key) { return $$.d3.max(ys[key]); }));
};
c3_chart_internal_fn.getYDomain = function (targets, axisId, xDomain) {
var $$ = this, config = $$.config,
targetsByAxisId = targets.filter(function (t) { return $$.axis.getId(t.id) === axisId; }),
yTargets = xDomain ? $$.filterByXDomain(targetsByAxisId, xDomain) : targetsByAxisId,
yMin = axisId === 'y2' ? config.axis_y2_min : config.axis_y_min,
yMax = axisId === 'y2' ? config.axis_y2_max : config.axis_y_max,
yDomainMin = $$.getYDomainMin(yTargets),
yDomainMax = $$.getYDomainMax(yTargets),
domain, domainLength, padding, padding_top, padding_bottom,
center = axisId === 'y2' ? config.axis_y2_center : config.axis_y_center,
yDomainAbs, lengths, diff, ratio, isAllPositive, isAllNegative,
isZeroBased = ($$.hasType('bar', yTargets) && config.bar_zerobased) || ($$.hasType('area', yTargets) && config.area_zerobased),
isInverted = axisId === 'y2' ? config.axis_y2_inverted : config.axis_y_inverted,
showHorizontalDataLabel = $$.hasDataLabel() && config.axis_rotated,
showVerticalDataLabel = $$.hasDataLabel() && !config.axis_rotated;
// MEMO: avoid inverting domain unexpectedly
yDomainMin = isValue(yMin) ? yMin : isValue(yMax) ? (yDomainMin < yMax ? yDomainMin : yMax - 10) : yDomainMin;
yDomainMax = isValue(yMax) ? yMax : isValue(yMin) ? (yMin < yDomainMax ? yDomainMax : yMin + 10) : yDomainMax;
if (yTargets.length === 0) { // use current domain if target of axisId is none
return axisId === 'y2' ? $$.y2.domain() : $$.y.domain();
}
if (isNaN(yDomainMin)) { // set minimum to zero when not number
yDomainMin = 0;
}
if (isNaN(yDomainMax)) { // set maximum to have same value as yDomainMin
yDomainMax = yDomainMin;
}
if (yDomainMin === yDomainMax) {
yDomainMin < 0 ? yDomainMax = 0 : yDomainMin = 0;
}
isAllPositive = yDomainMin >= 0 && yDomainMax >= 0;
isAllNegative = yDomainMin <= 0 && yDomainMax <= 0;
// Cancel zerobased if axis_*_min / axis_*_max specified
if ((isValue(yMin) && isAllPositive) || (isValue(yMax) && isAllNegative)) {
isZeroBased = false;
}
// Bar/Area chart should be 0-based if all positive|negative
if (isZeroBased) {
if (isAllPositive) { yDomainMin = 0; }
if (isAllNegative) { yDomainMax = 0; }
}
domainLength = Math.abs(yDomainMax - yDomainMin);
padding = padding_top = padding_bottom = domainLength * 0.1;
if (typeof center !== 'undefined') {
yDomainAbs = Math.max(Math.abs(yDomainMin), Math.abs(yDomainMax));
yDomainMax = center + yDomainAbs;
yDomainMin = center - yDomainAbs;
}
// add padding for data label
if (showHorizontalDataLabel) {
lengths = $$.getDataLabelLength(yDomainMin, yDomainMax, 'width');
diff = diffDomain($$.y.range());
ratio = [lengths[0] / diff, lengths[1] / diff];
padding_top += domainLength * (ratio[1] / (1 - ratio[0] - ratio[1]));
padding_bottom += domainLength * (ratio[0] / (1 - ratio[0] - ratio[1]));
} else if (showVerticalDataLabel) {
lengths = $$.getDataLabelLength(yDomainMin, yDomainMax, 'height');
padding_top += $$.axis.convertPixelsToAxisPadding(lengths[1], domainLength);
padding_bottom += $$.axis.convertPixelsToAxisPadding(lengths[0], domainLength);
}
if (axisId === 'y' && notEmpty(config.axis_y_padding)) {
padding_top = $$.axis.getPadding(config.axis_y_padding, 'top', padding_top, domainLength);
padding_bottom = $$.axis.getPadding(config.axis_y_padding, 'bottom', padding_bottom, domainLength);
}
if (axisId === 'y2' && notEmpty(config.axis_y2_padding)) {
padding_top = $$.axis.getPadding(config.axis_y2_padding, 'top', padding_top, domainLength);
padding_bottom = $$.axis.getPadding(config.axis_y2_padding, 'bottom', padding_bottom, domainLength);
}
// Bar/Area chart should be 0-based if all positive|negative
if (isZeroBased) {
if (isAllPositive) { padding_bottom = yDomainMin; }
if (isAllNegative) { padding_top = -yDomainMax; }
}
domain = [yDomainMin - padding_bottom, yDomainMax + padding_top];
return isInverted ? domain.reverse() : domain;
};
c3_chart_internal_fn.getXDomainMin = function (targets) {
var $$ = this, config = $$.config;
return isDefined(config.axis_x_min) ?
($$.isTimeSeries() ? this.parseDate(config.axis_x_min) : config.axis_x_min) :
$$.d3.min(targets, function (t) { return $$.d3.min(t.values, function (v) { return v.x; }); });
};
c3_chart_internal_fn.getXDomainMax = function (targets) {
var $$ = this, config = $$.config;
return isDefined(config.axis_x_max) ?
($$.isTimeSeries() ? this.parseDate(config.axis_x_max) : config.axis_x_max) :
$$.d3.max(targets, function (t) { return $$.d3.max(t.values, function (v) { return v.x; }); });
};
c3_chart_internal_fn.getXDomainPadding = function (domain) {
var $$ = this, config = $$.config,
diff = domain[1] - domain[0],
maxDataCount, padding, paddingLeft, paddingRight;
if ($$.isCategorized()) {
padding = 0;
} else if ($$.hasType('bar')) {
maxDataCount = $$.getMaxDataCount();
padding = maxDataCount > 1 ? (diff / (maxDataCount - 1)) / 2 : 0.5;
} else {
padding = diff * 0.01;
}
if (typeof config.axis_x_padding === 'object' && notEmpty(config.axis_x_padding)) {
paddingLeft = isValue(config.axis_x_padding.left) ? config.axis_x_padding.left : padding;
paddingRight = isValue(config.axis_x_padding.right) ? config.axis_x_padding.right : padding;
} else if (typeof config.axis_x_padding === 'number') {
paddingLeft = paddingRight = config.axis_x_padding;
} else {
paddingLeft = paddingRight = padding;
}
return {left: paddingLeft, right: paddingRight};
};
c3_chart_internal_fn.getXDomain = function (targets) {
var $$ = this,
xDomain = [$$.getXDomainMin(targets), $$.getXDomainMax(targets)],
firstX = xDomain[0], lastX = xDomain[1],
padding = $$.getXDomainPadding(xDomain),
min = 0, max = 0;
// show center of x domain if min and max are the same
if ((firstX - lastX) === 0 && !$$.isCategorized()) {
if ($$.isTimeSeries()) {
firstX = new Date(firstX.getTime() * 0.5);
lastX = new Date(lastX.getTime() * 1.5);
} else {
firstX = firstX === 0 ? 1 : (firstX * 0.5);
lastX = lastX === 0 ? -1 : (lastX * 1.5);
}
}
if (firstX || firstX === 0) {
min = $$.isTimeSeries() ? new Date(firstX.getTime() - padding.left) : firstX - padding.left;
}
if (lastX || lastX === 0) {
max = $$.isTimeSeries() ? new Date(lastX.getTime() + padding.right) : lastX + padding.right;
}
return [min, max];
};
c3_chart_internal_fn.updateXDomain = function (targets, withUpdateXDomain, withUpdateOrgXDomain, withTrim, domain) {
var $$ = this, config = $$.config;
if (withUpdateOrgXDomain) {
$$.x.domain(domain ? domain : $$.d3.extent($$.getXDomain(targets)));
$$.orgXDomain = $$.x.domain();
if (config.zoom_enabled) { $$.zoom.scale($$.x).updateScaleExtent(); }
$$.subX.domain($$.x.domain());
if ($$.brush) { $$.brush.scale($$.subX); }
}
if (withUpdateXDomain) {
$$.x.domain(domain ? domain : (!$$.brush || $$.brush.empty()) ? $$.orgXDomain : $$.brush.extent());
if (config.zoom_enabled) { $$.zoom.scale($$.x).updateScaleExtent(); }
}
// Trim domain when too big by zoom mousemove event
if (withTrim) { $$.x.domain($$.trimXDomain($$.x.orgDomain())); }
return $$.x.domain();
};
c3_chart_internal_fn.trimXDomain = function (domain) {
var zoomDomain = this.getZoomDomain(),
min = zoomDomain[0], max = zoomDomain[1];
if (domain[0] <= min) {
domain[1] = +domain[1] + (min - domain[0]);
domain[0] = min;
}
if (max <= domain[1]) {
domain[0] = +domain[0] - (domain[1] - max);
domain[1] = max;
}
return domain;
};
c3_chart_internal_fn.isX = function (key) {
var $$ = this, config = $$.config;
return (config.data_x && key === config.data_x) || (notEmpty(config.data_xs) && hasValue(config.data_xs, key));
};
c3_chart_internal_fn.isNotX = function (key) {
return !this.isX(key);
};
c3_chart_internal_fn.getXKey = function (id) {
var $$ = this, config = $$.config;
return config.data_x ? config.data_x : notEmpty(config.data_xs) ? config.data_xs[id] : null;
};
c3_chart_internal_fn.getXValuesOfXKey = function (key, targets) {
var $$ = this,
xValues, ids = targets && notEmpty(targets) ? $$.mapToIds(targets) : [];
ids.forEach(function (id) {
if ($$.getXKey(id) === key) {
xValues = $$.data.xs[id];
}
});
return xValues;
};
c3_chart_internal_fn.getIndexByX = function (x) {
var $$ = this,
data = $$.filterByX($$.data.targets, x);
return data.length ? data[0].index : null;
};
c3_chart_internal_fn.getXValue = function (id, i) {
var $$ = this;
return id in $$.data.xs && $$.data.xs[id] && isValue($$.data.xs[id][i]) ? $$.data.xs[id][i] : i;
};
c3_chart_internal_fn.getOtherTargetXs = function () {
var $$ = this,
idsForX = Object.keys($$.data.xs);
return idsForX.length ? $$.data.xs[idsForX[0]] : null;
};
c3_chart_internal_fn.getOtherTargetX = function (index) {
var xs = this.getOtherTargetXs();
return xs && index < xs.length ? xs[index] : null;
};
c3_chart_internal_fn.addXs = function (xs) {
var $$ = this;
Object.keys(xs).forEach(function (id) {
$$.config.data_xs[id] = xs[id];
});
};
c3_chart_internal_fn.hasMultipleX = function (xs) {
return this.d3.set(Object.keys(xs).map(function (id) { return xs[id]; })).size() > 1;
};
c3_chart_internal_fn.isMultipleX = function () {
return notEmpty(this.config.data_xs) || !this.config.data_xSort || this.hasType('scatter');
};
c3_chart_internal_fn.addName = function (data) {
var $$ = this, name;
if (data) {
name = $$.config.data_names[data.id];
data.name = name !== undefined ? name : data.id;
}
return data;
};
c3_chart_internal_fn.getValueOnIndex = function (values, index) {
var valueOnIndex = values.filter(function (v) { return v.index === index; });
return valueOnIndex.length ? valueOnIndex[0] : null;
};
c3_chart_internal_fn.updateTargetX = function (targets, x) {
var $$ = this;
targets.forEach(function (t) {
t.values.forEach(function (v, i) {
v.x = $$.generateTargetX(x[i], t.id, i);
});
$$.data.xs[t.id] = x;
});
};
c3_chart_internal_fn.updateTargetXs = function (targets, xs) {
var $$ = this;
targets.forEach(function (t) {
if (xs[t.id]) {
$$.updateTargetX([t], xs[t.id]);
}
});
};
c3_chart_internal_fn.generateTargetX = function (rawX, id, index) {
var $$ = this, x;
if ($$.isTimeSeries()) {
x = rawX ? $$.parseDate(rawX) : $$.parseDate($$.getXValue(id, index));
}
else if ($$.isCustomX() && !$$.isCategorized()) {
x = isValue(rawX) ? +rawX : $$.getXValue(id, index);
}
else {
x = index;
}
return x;
};
c3_chart_internal_fn.cloneTarget = function (target) {
return {
id : target.id,
id_org : target.id_org,
values : target.values.map(function (d) {
return {x: d.x, value: d.value, id: d.id};
})
};
};
c3_chart_internal_fn.updateXs = function () {
var $$ = this;
if ($$.data.targets.length) {
$$.xs = [];
$$.data.targets[0].values.forEach(function (v) {
$$.xs[v.index] = v.x;
});
}
};
c3_chart_internal_fn.getPrevX = function (i) {
var x = this.xs[i - 1];
return typeof x !== 'undefined' ? x : null;
};
c3_chart_internal_fn.getNextX = function (i) {
var x = this.xs[i + 1];
return typeof x !== 'undefined' ? x : null;
};
c3_chart_internal_fn.getMaxDataCount = function () {
var $$ = this;
return $$.d3.max($$.data.targets, function (t) { return t.values.length; });
};
c3_chart_internal_fn.getMaxDataCountTarget = function (targets) {
var length = targets.length, max = 0, maxTarget;
if (length > 1) {
targets.forEach(function (t) {
if (t.values.length > max) {
maxTarget = t;
max = t.values.length;
}
});
} else {
maxTarget = length ? targets[0] : null;
}
return maxTarget;
};
c3_chart_internal_fn.getEdgeX = function (targets) {
var $$ = this;
return !targets.length ? [0, 0] : [
$$.d3.min(targets, function (t) { return t.values[0].x; }),
$$.d3.max(targets, function (t) { return t.values[t.values.length - 1].x; })
];
};
c3_chart_internal_fn.mapToIds = function (targets) {
return targets.map(function (d) { return d.id; });
};
c3_chart_internal_fn.mapToTargetIds = function (ids) {
var $$ = this;
return ids ? [].concat(ids) : $$.mapToIds($$.data.targets);
};
c3_chart_internal_fn.hasTarget = function (targets, id) {
var ids = this.mapToIds(targets), i;
for (i = 0; i < ids.length; i++) {
if (ids[i] === id) {
return true;
}
}
return false;
};
c3_chart_internal_fn.isTargetToShow = function (targetId) {
return this.hiddenTargetIds.indexOf(targetId) < 0;
};
c3_chart_internal_fn.isLegendToShow = function (targetId) {
return this.hiddenLegendIds.indexOf(targetId) < 0;
};
c3_chart_internal_fn.filterTargetsToShow = function (targets) {
var $$ = this;
return targets.filter(function (t) { return $$.isTargetToShow(t.id); });
};
c3_chart_internal_fn.mapTargetsToUniqueXs = function (targets) {
var $$ = this;
var xs = $$.d3.set($$.d3.merge(targets.map(function (t) { return t.values.map(function (v) { return +v.x; }); }))).values();
xs = $$.isTimeSeries() ? xs.map(function (x) { return new Date(+x); }) : xs.map(function (x) { return +x; });
return xs.sort(function (a, b) { return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; });
};
c3_chart_internal_fn.addHiddenTargetIds = function (targetIds) {
this.hiddenTargetIds = this.hiddenTargetIds.concat(targetIds);
};
c3_chart_internal_fn.removeHiddenTargetIds = function (targetIds) {
this.hiddenTargetIds = this.hiddenTargetIds.filter(function (id) { return targetIds.indexOf(id) < 0; });
};
c3_chart_internal_fn.addHiddenLegendIds = function (targetIds) {
this.hiddenLegendIds = this.hiddenLegendIds.concat(targetIds);
};
c3_chart_internal_fn.removeHiddenLegendIds = function (targetIds) {
this.hiddenLegendIds = this.hiddenLegendIds.filter(function (id) { return targetIds.indexOf(id) < 0; });
};
c3_chart_internal_fn.getValuesAsIdKeyed = function (targets) {
var ys = {};
targets.forEach(function (t) {
ys[t.id] = [];
t.values.forEach(function (v) {
ys[t.id].push(v.value);
});
});
return ys;
};
c3_chart_internal_fn.checkValueInTargets = function (targets, checker) {
var ids = Object.keys(targets), i, j, values;
for (i = 0; i < ids.length; i++) {
values = targets[ids[i]].values;
for (j = 0; j < values.length; j++) {
if (checker(values[j].value)) {
return true;
}
}
}
return false;
};
c3_chart_internal_fn.hasNegativeValueInTargets = function (targets) {
return this.checkValueInTargets(targets, function (v) { return v < 0; });
};
c3_chart_internal_fn.hasPositiveValueInTargets = function (targets) {
return this.checkValueInTargets(targets, function (v) { return v > 0; });
};
c3_chart_internal_fn.isOrderDesc = function () {
var config = this.config;
return typeof(config.data_order) === 'string' && config.data_order.toLowerCase() === 'desc';
};
c3_chart_internal_fn.isOrderAsc = function () {
var config = this.config;
return typeof(config.data_order) === 'string' && config.data_order.toLowerCase() === 'asc';
};
c3_chart_internal_fn.orderTargets = function (targets) {
var $$ = this, config = $$.config, orderAsc = $$.isOrderAsc(), orderDesc = $$.isOrderDesc();
if (orderAsc || orderDesc) {
targets.sort(function (t1, t2) {
var reducer = function (p, c) { return p + Math.abs(c.value); };
var t1Sum = t1.values.reduce(reducer, 0),
t2Sum = t2.values.reduce(reducer, 0);
return orderAsc ? t2Sum - t1Sum : t1Sum - t2Sum;
});
} else if (isFunction(config.data_order)) {
targets.sort(config.data_order);
} // TODO: accept name array for order
return targets;
};
c3_chart_internal_fn.filterByX = function (targets, x) {
return this.d3.merge(targets.map(function (t) { return t.values; })).filter(function (v) { return v.x - x === 0; });
};
c3_chart_internal_fn.filterRemoveNull = function (data) {
return data.filter(function (d) { return isValue(d.value); });
};
c3_chart_internal_fn.filterByXDomain = function (targets, xDomain) {
return targets.map(function (t) {
return {
id: t.id,
id_org: t.id_org,
values: t.values.filter(function (v) {
return xDomain[0] <= v.x && v.x <= xDomain[1];
})
};
});
};
c3_chart_internal_fn.hasDataLabel = function () {
var config = this.config;
if (typeof config.data_labels === 'boolean' && config.data_labels) {
return true;
} else if (typeof config.data_labels === 'object' && notEmpty(config.data_labels)) {
return true;
}
return false;
};
c3_chart_internal_fn.getDataLabelLength = function (min, max, key) {
var $$ = this,
lengths = [0, 0], paddingCoef = 1.3;
$$.selectChart.select('svg').selectAll('.dummy')
.data([min, max])
.enter().append('text')
.text(function (d) { return $$.dataLabelFormat(d.id)(d); })
.each(function (d, i) {
lengths[i] = this.getBoundingClientRect()[key] * paddingCoef;
})
.remove();
return lengths;
};
c3_chart_internal_fn.isNoneArc = function (d) {
return this.hasTarget(this.data.targets, d.id);
},
c3_chart_internal_fn.isArc = function (d) {
return 'data' in d && this.hasTarget(this.data.targets, d.data.id);
};
c3_chart_internal_fn.findSameXOfValues = function (values, index) {
var i, targetX = values[index].x, sames = [];
for (i = index - 1; i >= 0; i--) {
if (targetX !== values[i].x) { break; }
sames.push(values[i]);
}
for (i = index; i < values.length; i++) {
if (targetX !== values[i].x) { break; }
sames.push(values[i]);
}
return sames;
};
c3_chart_internal_fn.findClosestFromTargets = function (targets, pos) {
var $$ = this, candidates;
// map to array of closest points of each target
candidates = targets.map(function (target) {
return $$.findClosest(target.values, pos);
});
// decide closest point and return
return $$.findClosest(candidates, pos);
};
c3_chart_internal_fn.findClosest = function (values, pos) {
var $$ = this, minDist = $$.config.point_sensitivity, closest;
// find mouseovering bar
values.filter(function (v) { return v && $$.isBarType(v.id); }).forEach(function (v) {
var shape = $$.main.select('.' + CLASS.bars + $$.getTargetSelectorSuffix(v.id) + ' .' + CLASS.bar + '-' + v.index).node();
if (!closest && $$.isWithinBar(shape)) {
closest = v;
}
});
// find closest point from non-bar
values.filter(function (v) { return v && !$$.isBarType(v.id); }).forEach(function (v) {
var d = $$.dist(v, pos);
if (d < minDist) {
minDist = d;
closest = v;
}
});
return closest;
};
c3_chart_internal_fn.dist = function (data, pos) {
var $$ = this, config = $$.config,
xIndex = config.axis_rotated ? 1 : 0,
yIndex = config.axis_rotated ? 0 : 1,
y = $$.circleY(data, data.index),
x = $$.x(data.x);
return Math.sqrt(Math.pow(x - pos[xIndex], 2) + Math.pow(y - pos[yIndex], 2));
};
c3_chart_internal_fn.convertValuesToStep = function (values) {
var converted = [].concat(values), i;
if (!this.isCategorized()) {
return values;
}
for (i = values.length + 1; 0 < i; i--) {
converted[i] = converted[i - 1];
}
converted[0] = {
x: converted[0].x - 1,
value: converted[0].value,
id: converted[0].id
};
converted[values.length + 1] = {
x: converted[values.length].x + 1,
value: converted[values.length].value,
id: converted[values.length].id
};
return converted;
};
c3_chart_internal_fn.updateDataAttributes = function (name, attrs) {
var $$ = this, config = $$.config, current = config['data_' + name];
if (typeof attrs === 'undefined') { return current; }
Object.keys(attrs).forEach(function (id) {
current[id] = attrs[id];
});
$$.redraw({withLegend: true});
return current;
};
c3_chart_internal_fn.convertUrlToData = function (url, mimeType, headers, keys, done) {
var $$ = this, type = mimeType ? mimeType : 'csv';
var req = $$.d3.xhr(url);
if (headers) {
Object.keys(headers).forEach(function (header) {
req.header(header, headers[header]);
});
}
req.get(function (error, data) {
var d;
if (!data) {
throw new Error(error.responseURL + ' ' + error.status + ' (' + error.statusText + ')');
}
if (type === 'json') {
d = $$.convertJsonToData(JSON.parse(data.response), keys);
} else if (type === 'tsv') {
d = $$.convertTsvToData(data.response);
} else {
d = $$.convertCsvToData(data.response);
}
done.call($$, d);
});
};
c3_chart_internal_fn.convertXsvToData = function (xsv, parser) {
var rows = parser.parseRows(xsv), d;
if (rows.length === 1) {
d = [{}];
rows[0].forEach(function (id) {
d[0][id] = null;
});
} else {
d = parser.parse(xsv);
}
return d;
};
c3_chart_internal_fn.convertCsvToData = function (csv) {
return this.convertXsvToData(csv, this.d3.csv);
};
c3_chart_internal_fn.convertTsvToData = function (tsv) {
return this.convertXsvToData(tsv, this.d3.tsv);
};
c3_chart_internal_fn.convertJsonToData = function (json, keys) {
var $$ = this,
new_rows = [], targetKeys, data;
if (keys) { // when keys specified, json would be an array that includes objects
if (keys.x) {
targetKeys = keys.value.concat(keys.x);
$$.config.data_x = keys.x;
} else {
targetKeys = keys.value;
}
new_rows.push(targetKeys);
json.forEach(function (o) {
var new_row = [];
targetKeys.forEach(function (key) {
// convert undefined to null because undefined data will be removed in convertDataToTargets()
var v = $$.findValueInJson(o, key);
if (isUndefined(v)) {
v = null;
}
new_row.push(v);
});
new_rows.push(new_row);
});
data = $$.convertRowsToData(new_rows);
} else {
Object.keys(json).forEach(function (key) {
new_rows.push([key].concat(json[key]));
});
data = $$.convertColumnsToData(new_rows);
}
return data;
};
c3_chart_internal_fn.findValueInJson = function (object, path) {
path = path.replace(/\[(\w+)\]/g, '.$1'); // convert indexes to properties (replace [] with .)
path = path.replace(/^\./, ''); // strip a leading dot
var pathArray = path.split('.');
for (var i = 0; i < pathArray.length; ++i) {
var k = pathArray[i];
if (k in object) {
object = object[k];
} else {
return;
}
}
return object;
};
c3_chart_internal_fn.convertRowsToData = function (rows) {
var keys = rows[0], new_row = {}, new_rows = [], i, j;
for (i = 1; i < rows.length; i++) {
new_row = {};
for (j = 0; j < rows[i].length; j++) {
if (isUndefined(rows[i][j])) {
throw new Error("Source data is missing a component at (" + i + "," + j + ")!");
}
new_row[keys[j]] = rows[i][j];
}
new_rows.push(new_row);
}
return new_rows;
};
c3_chart_internal_fn.convertColumnsToData = function (columns) {
var new_rows = [], i, j, key;
for (i = 0; i < columns.length; i++) {
key = columns[i][0];
for (j = 1; j < columns[i].length; j++) {
if (isUndefined(new_rows[j - 1])) {
new_rows[j - 1] = {};
}
if (isUndefined(columns[i][j])) {
throw new Error("Source data is missing a component at (" + i + "," + j + ")!");
}
new_rows[j - 1][key] = columns[i][j];
}
}
return new_rows;
};
c3_chart_internal_fn.convertDataToTargets = function (data, appendXs) {
var $$ = this, config = $$.config,
ids = $$.d3.keys(data[0]).filter($$.isNotX, $$),
xs = $$.d3.keys(data[0]).filter($$.isX, $$),
targets;
// save x for update data by load when custom x and c3.x API
ids.forEach(function (id) {
var xKey = $$.getXKey(id);
if ($$.isCustomX() || $$.isTimeSeries()) {
// if included in input data
if (xs.indexOf(xKey) >= 0) {
$$.data.xs[id] = (appendXs && $$.data.xs[id] ? $$.data.xs[id] : []).concat(
data.map(function (d) { return d[xKey]; })
.filter(isValue)
.map(function (rawX, i) { return $$.generateTargetX(rawX, id, i); })
);
}
// if not included in input data, find from preloaded data of other id's x
else if (config.data_x) {
$$.data.xs[id] = $$.getOtherTargetXs();
}
// if not included in input data, find from preloaded data
else if (notEmpty(config.data_xs)) {
$$.data.xs[id] = $$.getXValuesOfXKey(xKey, $$.data.targets);
}
// MEMO: if no x included, use same x of current will be used
} else {
$$.data.xs[id] = data.map(function (d, i) { return i; });
}
});
// check x is defined
ids.forEach(function (id) {
if (!$$.data.xs[id]) {
throw new Error('x is not defined for id = "' + id + '".');
}
});
// convert to target
targets = ids.map(function (id, index) {
var convertedId = config.data_idConverter(id);
return {
id: convertedId,
id_org: id,
values: data.map(function (d, i) {
var xKey = $$.getXKey(id), rawX = d[xKey],
value = d[id] !== null && !isNaN(d[id]) ? +d[id] : null, x;
// use x as categories if custom x and categorized
if ($$.isCustomX() && $$.isCategorized() && index === 0 && !isUndefined(rawX)) {
if (index === 0 && i === 0) {
config.axis_x_categories = [];
}
x = config.axis_x_categories.indexOf(rawX);
if (x === -1) {
x = config.axis_x_categories.length;
config.axis_x_categories.push(rawX);
}
} else {
x = $$.generateTargetX(rawX, id, i);
}
// mark as x = undefined if value is undefined and filter to remove after mapped
if (isUndefined(d[id]) || $$.data.xs[id].length <= i) {
x = undefined;
}
return {x: x, value: value, id: convertedId};
}).filter(function (v) { return isDefined(v.x); })
};
});
// finish targets
targets.forEach(function (t) {
var i;
// sort values by its x
if (config.data_xSort) {
t.values = t.values.sort(function (v1, v2) {
var x1 = v1.x || v1.x === 0 ? v1.x : Infinity,
x2 = v2.x || v2.x === 0 ? v2.x : Infinity;
return x1 - x2;
});
}
// indexing each value
i = 0;
t.values.forEach(function (v) {
v.index = i++;
});
// this needs to be sorted because its index and value.index is identical
$$.data.xs[t.id].sort(function (v1, v2) {
return v1 - v2;
});
});
// cache information about values
$$.hasNegativeValue = $$.hasNegativeValueInTargets(targets);
$$.hasPositiveValue = $$.hasPositiveValueInTargets(targets);
// set target types
if (config.data_type) {
$$.setTargetType($$.mapToIds(targets).filter(function (id) { return ! (id in config.data_types); }), config.data_type);
}
// cache as original id keyed
targets.forEach(function (d) {
$$.addCache(d.id_org, d);
});
return targets;
};
c3_chart_internal_fn.load = function (targets, args) {
var $$ = this;
if (targets) {
// filter loading targets if needed
if (args.filter) {
targets = targets.filter(args.filter);
}
// set type if args.types || args.type specified
if (args.type || args.types) {
targets.forEach(function (t) {
var type = args.types && args.types[t.id] ? args.types[t.id] : args.type;
$$.setTargetType(t.id, type);
});
}
// Update/Add data
$$.data.targets.forEach(function (d) {
for (var i = 0; i < targets.length; i++) {
if (d.id === targets[i].id) {
d.values = targets[i].values;
targets.splice(i, 1);
break;
}
}
});
$$.data.targets = $$.data.targets.concat(targets); // add remained
}
// Set targets
$$.updateTargets($$.data.targets);
// Redraw with new targets
$$.redraw({withUpdateOrgXDomain: true, withUpdateXDomain: true, withLegend: true});
if (args.done) { args.done(); }
};
c3_chart_internal_fn.loadFromArgs = function (args) {
var $$ = this;
if (args.data) {
$$.load($$.convertDataToTargets(args.data), args);
}
else if (args.url) {
$$.convertUrlToData(args.url, args.mimeType, args.headers, args.keys, function (data) {
$$.load($$.convertDataToTargets(data), args);
});
}
else if (args.json) {
$$.load($$.convertDataToTargets($$.convertJsonToData(args.json, args.keys)), args);
}
else if (args.rows) {
$$.load($$.convertDataToTargets($$.convertRowsToData(args.rows)), args);
}
else if (args.columns) {
$$.load($$.convertDataToTargets($$.convertColumnsToData(args.columns)), args);
}
else {
$$.load(null, args);
}
};
c3_chart_internal_fn.unload = function (targetIds, done) {
var $$ = this;
if (!done) {
done = function () {};
}
// filter existing target
targetIds = targetIds.filter(function (id) { return $$.hasTarget($$.data.targets, id); });
// If no target, call done and return
if (!targetIds || targetIds.length === 0) {
done();
return;
}
$$.svg.selectAll(targetIds.map(function (id) { return $$.selectorTarget(id); }))
.transition()
.style('opacity', 0)
.remove()
.call($$.endall, done);
targetIds.forEach(function (id) {
// Reset fadein for future load
$$.withoutFadeIn[id] = false;
// Remove target's elements
if ($$.legend) {
$$.legend.selectAll('.' + CLASS.legendItem + $$.getTargetSelectorSuffix(id)).remove();
}
// Remove target
$$.data.targets = $$.data.targets.filter(function (t) {
return t.id !== id;
});
});
};
c3_chart_internal_fn.categoryName = function (i) {
var config = this.config;
return i < config.axis_x_categories.length ? config.axis_x_categories[i] : i;
};
c3_chart_internal_fn.initEventRect = function () {
var $$ = this;
$$.main.select('.' + CLASS.chart).append("g")
.attr("class", CLASS.eventRects)
.style('fill-opacity', 0);
};
c3_chart_internal_fn.redrawEventRect = function () {
var $$ = this, config = $$.config,
eventRectUpdate, maxDataCountTarget,
isMultipleX = $$.isMultipleX();
// rects for mouseover
var eventRects = $$.main.select('.' + CLASS.eventRects)
.style('cursor', config.zoom_enabled ? config.axis_rotated ? 'ns-resize' : 'ew-resize' : null)
.classed(CLASS.eventRectsMultiple, isMultipleX)
.classed(CLASS.eventRectsSingle, !isMultipleX);
// clear old rects
eventRects.selectAll('.' + CLASS.eventRect).remove();
// open as public variable
$$.eventRect = eventRects.selectAll('.' + CLASS.eventRect);
if (isMultipleX) {
eventRectUpdate = $$.eventRect.data([0]);
// enter : only one rect will be added
$$.generateEventRectsForMultipleXs(eventRectUpdate.enter());
// update
$$.updateEventRect(eventRectUpdate);
// exit : not needed because always only one rect exists
}
else {
// Set data and update $$.eventRect
maxDataCountTarget = $$.getMaxDataCountTarget($$.data.targets);
eventRects.datum(maxDataCountTarget ? maxDataCountTarget.values : []);
$$.eventRect = eventRects.selectAll('.' + CLASS.eventRect);
eventRectUpdate = $$.eventRect.data(function (d) { return d; });
// enter
$$.generateEventRectsForSingleX(eventRectUpdate.enter());
// update
$$.updateEventRect(eventRectUpdate);
// exit
eventRectUpdate.exit().remove();
}
};
c3_chart_internal_fn.updateEventRect = function (eventRectUpdate) {
var $$ = this, config = $$.config,
x, y, w, h, rectW, rectX;
// set update selection if null
eventRectUpdate = eventRectUpdate || $$.eventRect.data(function (d) { return d; });
if ($$.isMultipleX()) {
// TODO: rotated not supported yet
x = 0;
y = 0;
w = $$.width;
h = $$.height;
}
else {
if (($$.isCustomX() || $$.isTimeSeries()) && !$$.isCategorized()) {
// update index for x that is used by prevX and nextX
$$.updateXs();
rectW = function (d) {
var prevX = $$.getPrevX(d.index), nextX = $$.getNextX(d.index);
// if there this is a single data point make the eventRect full width (or height)
if (prevX === null && nextX === null) {
return config.axis_rotated ? $$.height : $$.width;
}
if (prevX === null) { prevX = $$.x.domain()[0]; }
if (nextX === null) { nextX = $$.x.domain()[1]; }
return Math.max(0, ($$.x(nextX) - $$.x(prevX)) / 2);
};
rectX = function (d) {
var prevX = $$.getPrevX(d.index), nextX = $$.getNextX(d.index),
thisX = $$.data.xs[d.id][d.index];
// if there this is a single data point position the eventRect at 0
if (prevX === null && nextX === null) {
return 0;
}
if (prevX === null) { prevX = $$.x.domain()[0]; }
return ($$.x(thisX) + $$.x(prevX)) / 2;
};
} else {
rectW = $$.getEventRectWidth();
rectX = function (d) {
return $$.x(d.x) - (rectW / 2);
};
}
x = config.axis_rotated ? 0 : rectX;
y = config.axis_rotated ? rectX : 0;
w = config.axis_rotated ? $$.width : rectW;
h = config.axis_rotated ? rectW : $$.height;
}
eventRectUpdate
.attr('class', $$.classEvent.bind($$))
.attr("x", x)
.attr("y", y)
.attr("width", w)
.attr("height", h);
};
c3_chart_internal_fn.generateEventRectsForSingleX = function (eventRectEnter) {
var $$ = this, d3 = $$.d3, config = $$.config;
eventRectEnter.append("rect")
.attr("class", $$.classEvent.bind($$))
.style("cursor", config.data_selection_enabled && config.data_selection_grouped ? "pointer" : null)
.on('mouseover', function (d) {
var index = d.index;
if ($$.dragging || $$.flowing) { return; } // do nothing while dragging/flowing
if ($$.hasArcType()) { return; }
// Expand shapes for selection
if (config.point_focus_expand_enabled) { $$.expandCircles(index, null, true); }
$$.expandBars(index, null, true);
// Call event handler
$$.main.selectAll('.' + CLASS.shape + '-' + index).each(function (d) {
config.data_onmouseover.call($$.api, d);
});
})
.on('mouseout', function (d) {
var index = d.index;
if (!$$.config) { return; } // chart is destroyed
if ($$.hasArcType()) { return; }
$$.hideXGridFocus();
$$.hideTooltip();
// Undo expanded shapes
$$.unexpandCircles();
$$.unexpandBars();
// Call event handler
$$.main.selectAll('.' + CLASS.shape + '-' + index).each(function (d) {
config.data_onmouseout.call($$.api, d);
});
})
.on('mousemove', function (d) {
var selectedData, index = d.index,
eventRect = $$.svg.select('.' + CLASS.eventRect + '-' + index);
if ($$.dragging || $$.flowing) { return; } // do nothing while dragging/flowing
if ($$.hasArcType()) { return; }
if ($$.isStepType(d) && $$.config.line_step_type === 'step-after' && d3.mouse(this)[0] < $$.x($$.getXValue(d.id, index))) {
index -= 1;
}
// Show tooltip
selectedData = $$.filterTargetsToShow($$.data.targets).map(function (t) {
return $$.addName($$.getValueOnIndex(t.values, index));
});
if (config.tooltip_grouped) {
$$.showTooltip(selectedData, this);
$$.showXGridFocus(selectedData);
}
if (config.tooltip_grouped && (!config.data_selection_enabled || config.data_selection_grouped)) {
return;
}
$$.main.selectAll('.' + CLASS.shape + '-' + index)
.each(function () {
d3.select(this).classed(CLASS.EXPANDED, true);
if (config.data_selection_enabled) {
eventRect.style('cursor', config.data_selection_grouped ? 'pointer' : null);
}
if (!config.tooltip_grouped) {
$$.hideXGridFocus();
$$.hideTooltip();
if (!config.data_selection_grouped) {
$$.unexpandCircles(index);
$$.unexpandBars(index);
}
}
})
.filter(function (d) {
return $$.isWithinShape(this, d);
})
.each(function (d) {
if (config.data_selection_enabled && (config.data_selection_grouped || config.data_selection_isselectable(d))) {
eventRect.style('cursor', 'pointer');
}
if (!config.tooltip_grouped) {
$$.showTooltip([d], this);
$$.showXGridFocus([d]);
if (config.point_focus_expand_enabled) { $$.expandCircles(index, d.id, true); }
$$.expandBars(index, d.id, true);
}
});
})
.on('click', function (d) {
var index = d.index;
if ($$.hasArcType() || !$$.toggleShape) { return; }
if ($$.cancelClick) {
$$.cancelClick = false;
return;
}
if ($$.isStepType(d) && config.line_step_type === 'step-after' && d3.mouse(this)[0] < $$.x($$.getXValue(d.id, index))) {
index -= 1;
}
$$.main.selectAll('.' + CLASS.shape + '-' + index).each(function (d) {
if (config.data_selection_grouped || $$.isWithinShape(this, d)) {
$$.toggleShape(this, d, index);
$$.config.data_onclick.call($$.api, d, this);
}
});
})
.call(
config.data_selection_draggable && $$.drag ? (
d3.behavior.drag().origin(Object)
.on('drag', function () { $$.drag(d3.mouse(this)); })
.on('dragstart', function () { $$.dragstart(d3.mouse(this)); })
.on('dragend', function () { $$.dragend(); })
) : function () {}
);
};
c3_chart_internal_fn.generateEventRectsForMultipleXs = function (eventRectEnter) {
var $$ = this, d3 = $$.d3, config = $$.config;
function mouseout() {
$$.svg.select('.' + CLASS.eventRect).style('cursor', null);
$$.hideXGridFocus();
$$.hideTooltip();
$$.unexpandCircles();
$$.unexpandBars();
}
eventRectEnter.append('rect')
.attr('x', 0)
.attr('y', 0)
.attr('width', $$.width)
.attr('height', $$.height)
.attr('class', CLASS.eventRect)
.on('mouseout', function () {
if (!$$.config) { return; } // chart is destroyed
if ($$.hasArcType()) { return; }
mouseout();
})
.on('mousemove', function () {
var targetsToShow = $$.filterTargetsToShow($$.data.targets);
var mouse, closest, sameXData, selectedData;
if ($$.dragging) { return; } // do nothing when dragging
if ($$.hasArcType(targetsToShow)) { return; }
mouse = d3.mouse(this);
closest = $$.findClosestFromTargets(targetsToShow, mouse);
if ($$.mouseover && (!closest || closest.id !== $$.mouseover.id)) {
config.data_onmouseout.call($$.api, $$.mouseover);
$$.mouseover = undefined;
}
if (! closest) {
mouseout();
return;
}
if ($$.isScatterType(closest) || !config.tooltip_grouped) {
sameXData = [closest];
} else {
sameXData = $$.filterByX(targetsToShow, closest.x);
}
// show tooltip when cursor is close to some point
selectedData = sameXData.map(function (d) {
return $$.addName(d);
});
$$.showTooltip(selectedData, this);
// expand points
if (config.point_focus_expand_enabled) {
$$.expandCircles(closest.index, closest.id, true);
}
$$.expandBars(closest.index, closest.id, true);
// Show xgrid focus line
$$.showXGridFocus(selectedData);
// Show cursor as pointer if point is close to mouse position
if ($$.isBarType(closest.id) || $$.dist(closest, mouse) < config.point_sensitivity) {
$$.svg.select('.' + CLASS.eventRect).style('cursor', 'pointer');
if (!$$.mouseover) {
config.data_onmouseover.call($$.api, closest);
$$.mouseover = closest;
}
}
})
.on('click', function () {
var targetsToShow = $$.filterTargetsToShow($$.data.targets);
var mouse, closest;
if ($$.hasArcType(targetsToShow)) { return; }
mouse = d3.mouse(this);
closest = $$.findClosestFromTargets(targetsToShow, mouse);
if (! closest) { return; }
// select if selection enabled
if ($$.isBarType(closest.id) || $$.dist(closest, mouse) < config.point_sensitivity) {
$$.main.selectAll('.' + CLASS.shapes + $$.getTargetSelectorSuffix(closest.id)).selectAll('.' + CLASS.shape + '-' + closest.index).each(function () {
if (config.data_selection_grouped || $$.isWithinShape(this, closest)) {
$$.toggleShape(this, closest, closest.index);
$$.config.data_onclick.call($$.api, closest, this);
}
});
}
})
.call(
config.data_selection_draggable && $$.drag ? (
d3.behavior.drag().origin(Object)
.on('drag', function () { $$.drag(d3.mouse(this)); })
.on('dragstart', function () { $$.dragstart(d3.mouse(this)); })
.on('dragend', function () { $$.dragend(); })
) : function () {}
);
};
c3_chart_internal_fn.dispatchEvent = function (type, index, mouse) {
var $$ = this,
selector = '.' + CLASS.eventRect + (!$$.isMultipleX() ? '-' + index : ''),
eventRect = $$.main.select(selector).node(),
box = eventRect.getBoundingClientRect(),
x = box.left + (mouse ? mouse[0] : 0),
y = box.top + (mouse ? mouse[1] : 0),
event = document.createEvent("MouseEvents");
event.initMouseEvent(type, true, true, window, 0, x, y, x, y,
false, false, false, false, 0, null);
eventRect.dispatchEvent(event);
};
c3_chart_internal_fn.getCurrentWidth = function () {
var $$ = this, config = $$.config;
return config.size_width ? config.size_width : $$.getParentWidth();
};
c3_chart_internal_fn.getCurrentHeight = function () {
var $$ = this, config = $$.config,
h = config.size_height ? config.size_height : $$.getParentHeight();
return h > 0 ? h : 320 / ($$.hasType('gauge') && !config.gauge_fullCircle ? 2 : 1);
};
c3_chart_internal_fn.getCurrentPaddingTop = function () {
var $$ = this,
config = $$.config,
padding = isValue(config.padding_top) ? config.padding_top : 0;
if ($$.title && $$.title.node()) {
padding += $$.getTitlePadding();
}
return padding;
};
c3_chart_internal_fn.getCurrentPaddingBottom = function () {
var config = this.config;
return isValue(config.padding_bottom) ? config.padding_bottom : 0;
};
c3_chart_internal_fn.getCurrentPaddingLeft = function (withoutRecompute) {
var $$ = this, config = $$.config;
if (isValue(config.padding_left)) {
return config.padding_left;
} else if (config.axis_rotated) {
return !config.axis_x_show ? 1 : Math.max(ceil10($$.getAxisWidthByAxisId('x', withoutRecompute)), 40);
} else if (!config.axis_y_show || config.axis_y_inner) { // && !config.axis_rotated
return $$.axis.getYAxisLabelPosition().isOuter ? 30 : 1;
} else {
return ceil10($$.getAxisWidthByAxisId('y', withoutRecompute));
}
};
c3_chart_internal_fn.getCurrentPaddingRight = function () {
var $$ = this, config = $$.config,
defaultPadding = 10, legendWidthOnRight = $$.isLegendRight ? $$.getLegendWidth() + 20 : 0;
if (isValue(config.padding_right)) {
return config.padding_right + 1; // 1 is needed not to hide tick line
} else if (config.axis_rotated) {
return defaultPadding + legendWidthOnRight;
} else if (!config.axis_y2_show || config.axis_y2_inner) { // && !config.axis_rotated
return 2 + legendWidthOnRight + ($$.axis.getY2AxisLabelPosition().isOuter ? 20 : 0);
} else {
return ceil10($$.getAxisWidthByAxisId('y2')) + legendWidthOnRight;
}
};
c3_chart_internal_fn.getParentRectValue = function (key) {
var parent = this.selectChart.node(), v;
while (parent && parent.tagName !== 'BODY') {
try {
v = parent.getBoundingClientRect()[key];
} catch(e) {
if (key === 'width') {
// In IE in certain cases getBoundingClientRect
// will cause an "unspecified error"
v = parent.offsetWidth;
}
}
if (v) {
break;
}
parent = parent.parentNode;
}
return v;
};
c3_chart_internal_fn.getParentWidth = function () {
return this.getParentRectValue('width');
};
c3_chart_internal_fn.getParentHeight = function () {
var h = this.selectChart.style('height');
return h.indexOf('px') > 0 ? +h.replace('px', '') : 0;
};
c3_chart_internal_fn.getSvgLeft = function (withoutRecompute) {
var $$ = this, config = $$.config,
hasLeftAxisRect = config.axis_rotated || (!config.axis_rotated && !config.axis_y_inner),
leftAxisClass = config.axis_rotated ? CLASS.axisX : CLASS.axisY,
leftAxis = $$.main.select('.' + leftAxisClass).node(),
svgRect = leftAxis && hasLeftAxisRect ? leftAxis.getBoundingClientRect() : {right: 0},
chartRect = $$.selectChart.node().getBoundingClientRect(),
hasArc = $$.hasArcType(),
svgLeft = svgRect.right - chartRect.left - (hasArc ? 0 : $$.getCurrentPaddingLeft(withoutRecompute));
return svgLeft > 0 ? svgLeft : 0;
};
c3_chart_internal_fn.getAxisWidthByAxisId = function (id, withoutRecompute) {
var $$ = this, position = $$.axis.getLabelPositionById(id);
return $$.axis.getMaxTickWidth(id, withoutRecompute) + (position.isInner ? 20 : 40);
};
c3_chart_internal_fn.getHorizontalAxisHeight = function (axisId) {
var $$ = this, config = $$.config, h = 30;
if (axisId === 'x' && !config.axis_x_show) { return 8; }
if (axisId === 'x' && config.axis_x_height) { return config.axis_x_height; }
if (axisId === 'y' && !config.axis_y_show) {
return config.legend_show && !$$.isLegendRight && !$$.isLegendInset ? 10 : 1;
}
if (axisId === 'y2' && !config.axis_y2_show) { return $$.rotated_padding_top; }
// Calculate x axis height when tick rotated
if (axisId === 'x' && !config.axis_rotated && config.axis_x_tick_rotate) {
h = 30 + $$.axis.getMaxTickWidth(axisId) * Math.cos(Math.PI * (90 - config.axis_x_tick_rotate) / 180);
}
// Calculate y axis height when tick rotated
if (axisId === 'y' && config.axis_rotated && config.axis_y_tick_rotate) {
h = 30 + $$.axis.getMaxTickWidth(axisId) * Math.cos(Math.PI * (90 - config.axis_y_tick_rotate) / 180);
}
return h + ($$.axis.getLabelPositionById(axisId).isInner ? 0 : 10) + (axisId === 'y2' ? -10 : 0);
};
c3_chart_internal_fn.getEventRectWidth = function () {
return Math.max(0, this.xAxis.tickInterval());
};
c3_chart_internal_fn.getShapeIndices = function (typeFilter) {
var $$ = this, config = $$.config,
indices = {}, i = 0, j, k;
$$.filterTargetsToShow($$.data.targets.filter(typeFilter, $$)).forEach(function (d) {
for (j = 0; j < config.data_groups.length; j++) {
if (config.data_groups[j].indexOf(d.id) < 0) { continue; }
for (k = 0; k < config.data_groups[j].length; k++) {
if (config.data_groups[j][k] in indices) {
indices[d.id] = indices[config.data_groups[j][k]];
break;
}
}
}
if (isUndefined(indices[d.id])) { indices[d.id] = i++; }
});
indices.__max__ = i - 1;
return indices;
};
c3_chart_internal_fn.getShapeX = function (offset, targetsNum, indices, isSub) {
var $$ = this, scale = isSub ? $$.subX : $$.x;
return function (d) {
var index = d.id in indices ? indices[d.id] : 0;
return d.x || d.x === 0 ? scale(d.x) - offset * (targetsNum / 2 - index) : 0;
};
};
c3_chart_internal_fn.getShapeY = function (isSub) {
var $$ = this;
return function (d) {
var scale = isSub ? $$.getSubYScale(d.id) : $$.getYScale(d.id);
return scale(d.value);
};
};
c3_chart_internal_fn.getShapeOffset = function (typeFilter, indices, isSub) {
var $$ = this,
targets = $$.orderTargets($$.filterTargetsToShow($$.data.targets.filter(typeFilter, $$))),
targetIds = targets.map(function (t) { return t.id; });
return function (d, i) {
var scale = isSub ? $$.getSubYScale(d.id) : $$.getYScale(d.id),
y0 = scale(0), offset = y0;
targets.forEach(function (t) {
var values = $$.isStepType(d) ? $$.convertValuesToStep(t.values) : t.values;
if (t.id === d.id || indices[t.id] !== indices[d.id]) { return; }
if (targetIds.indexOf(t.id) < targetIds.indexOf(d.id)) {
// check if the x values line up
if (typeof values[i] === 'undefined' || +values[i].x !== +d.x) { // "+" for timeseries
// if not, try to find the value that does line up
i = -1;
values.forEach(function (v, j) {
if (v.x === d.x) {
i = j;
}
});
}
if (i in values && values[i].value * d.value >= 0) {
offset += scale(values[i].value) - y0;
}
}
});
return offset;
};
};
c3_chart_internal_fn.isWithinShape = function (that, d) {
var $$ = this,
shape = $$.d3.select(that), isWithin;
if (!$$.isTargetToShow(d.id)) {
isWithin = false;
}
else if (that.nodeName === 'circle') {
isWithin = $$.isStepType(d) ? $$.isWithinStep(that, $$.getYScale(d.id)(d.value)) : $$.isWithinCircle(that, $$.pointSelectR(d) * 1.5);
}
else if (that.nodeName === 'path') {
isWithin = shape.classed(CLASS.bar) ? $$.isWithinBar(that) : true;
}
return isWithin;
};
c3_chart_internal_fn.getInterpolate = function (d) {
var $$ = this,
interpolation = $$.isInterpolationType($$.config.spline_interpolation_type) ? $$.config.spline_interpolation_type : 'cardinal';
return $$.isSplineType(d) ? interpolation : $$.isStepType(d) ? $$.config.line_step_type : "linear";
};
c3_chart_internal_fn.initLine = function () {
var $$ = this;
$$.main.select('.' + CLASS.chart).append("g")
.attr("class", CLASS.chartLines);
};
c3_chart_internal_fn.updateTargetsForLine = function (targets) {
var $$ = this, config = $$.config,
mainLineUpdate, mainLineEnter,
classChartLine = $$.classChartLine.bind($$),
classLines = $$.classLines.bind($$),
classAreas = $$.classAreas.bind($$),
classCircles = $$.classCircles.bind($$),
classFocus = $$.classFocus.bind($$);
mainLineUpdate = $$.main.select('.' + CLASS.chartLines).selectAll('.' + CLASS.chartLine)
.data(targets)
.attr('class', function (d) { return classChartLine(d) + classFocus(d); });
mainLineEnter = mainLineUpdate.enter().append('g')
.attr('class', classChartLine)
.style('opacity', 0)
.style("pointer-events", "none");
// Lines for each data
mainLineEnter.append('g')
.attr("class", classLines);
// Areas
mainLineEnter.append('g')
.attr('class', classAreas);
// Circles for each data point on lines
mainLineEnter.append('g')
.attr("class", function (d) { return $$.generateClass(CLASS.selectedCircles, d.id); });
mainLineEnter.append('g')
.attr("class", classCircles)
.style("cursor", function (d) { return config.data_selection_isselectable(d) ? "pointer" : null; });
// Update date for selected circles
targets.forEach(function (t) {
$$.main.selectAll('.' + CLASS.selectedCircles + $$.getTargetSelectorSuffix(t.id)).selectAll('.' + CLASS.selectedCircle).each(function (d) {
d.value = t.values[d.index].value;
});
});
// MEMO: can not keep same color...
//mainLineUpdate.exit().remove();
};
c3_chart_internal_fn.updateLine = function (durationForExit) {
var $$ = this;
$$.mainLine = $$.main.selectAll('.' + CLASS.lines).selectAll('.' + CLASS.line)
.data($$.lineData.bind($$));
$$.mainLine.enter().append('path')
.attr('class', $$.classLine.bind($$))
.style("stroke", $$.color);
$$.mainLine
.style("opacity", $$.initialOpacity.bind($$))
.style('shape-rendering', function (d) { return $$.isStepType(d) ? 'crispEdges' : ''; })
.attr('transform', null);
$$.mainLine.exit().transition().duration(durationForExit)
.style('opacity', 0)
.remove();
};
c3_chart_internal_fn.redrawLine = function (drawLine, withTransition) {
return [
(withTransition ? this.mainLine.transition(Math.random().toString()) : this.mainLine)
.attr("d", drawLine)
.style("stroke", this.color)
.style("opacity", 1)
];
};
c3_chart_internal_fn.generateDrawLine = function (lineIndices, isSub) {
var $$ = this, config = $$.config,
line = $$.d3.svg.line(),
getPoints = $$.generateGetLinePoints(lineIndices, isSub),
yScaleGetter = isSub ? $$.getSubYScale : $$.getYScale,
xValue = function (d) { return (isSub ? $$.subxx : $$.xx).call($$, d); },
yValue = function (d, i) {
return config.data_groups.length > 0 ? getPoints(d, i)[0][1] : yScaleGetter.call($$, d.id)(d.value);
};
line = config.axis_rotated ? line.x(yValue).y(xValue) : line.x(xValue).y(yValue);
if (!config.line_connectNull) { line = line.defined(function (d) { return d.value != null; }); }
return function (d) {
var values = config.line_connectNull ? $$.filterRemoveNull(d.values) : d.values,
x = isSub ? $$.x : $$.subX, y = yScaleGetter.call($$, d.id), x0 = 0, y0 = 0, path;
if ($$.isLineType(d)) {
if (config.data_regions[d.id]) {
path = $$.lineWithRegions(values, x, y, config.data_regions[d.id]);
} else {
if ($$.isStepType(d)) { values = $$.convertValuesToStep(values); }
path = line.interpolate($$.getInterpolate(d))(values);
}
} else {
if (values[0]) {
x0 = x(values[0].x);
y0 = y(values[0].value);
}
path = config.axis_rotated ? "M " + y0 + " " + x0 : "M " + x0 + " " + y0;
}
return path ? path : "M 0 0";
};
};
c3_chart_internal_fn.generateGetLinePoints = function (lineIndices, isSub) { // partial duplication of generateGetBarPoints
var $$ = this, config = $$.config,
lineTargetsNum = lineIndices.__max__ + 1,
x = $$.getShapeX(0, lineTargetsNum, lineIndices, !!isSub),
y = $$.getShapeY(!!isSub),
lineOffset = $$.getShapeOffset($$.isLineType, lineIndices, !!isSub),
yScale = isSub ? $$.getSubYScale : $$.getYScale;
return function (d, i) {
var y0 = yScale.call($$, d.id)(0),
offset = lineOffset(d, i) || y0, // offset is for stacked area chart
posX = x(d), posY = y(d);
// fix posY not to overflow opposite quadrant
if (config.axis_rotated) {
if ((0 < d.value && posY < y0) || (d.value < 0 && y0 < posY)) { posY = y0; }
}
// 1 point that marks the line position
return [
[posX, posY - (y0 - offset)],
[posX, posY - (y0 - offset)], // needed for compatibility
[posX, posY - (y0 - offset)], // needed for compatibility
[posX, posY - (y0 - offset)] // needed for compatibility
];
};
};
c3_chart_internal_fn.lineWithRegions = function (d, x, y, _regions) {
var $$ = this, config = $$.config,
prev = -1, i, j,
s = "M", sWithRegion,
xp, yp, dx, dy, dd, diff, diffx2,
xOffset = $$.isCategorized() ? 0.5 : 0,
xValue, yValue,
regions = [];
function isWithinRegions(x, regions) {
var i;
for (i = 0; i < regions.length; i++) {
if (regions[i].start < x && x <= regions[i].end) { return true; }
}
return false;
}
// Check start/end of regions
if (isDefined(_regions)) {
for (i = 0; i < _regions.length; i++) {
regions[i] = {};
if (isUndefined(_regions[i].start)) {
regions[i].start = d[0].x;
} else {
regions[i].start = $$.isTimeSeries() ? $$.parseDate(_regions[i].start) : _regions[i].start;
}
if (isUndefined(_regions[i].end)) {
regions[i].end = d[d.length - 1].x;
} else {
regions[i].end = $$.isTimeSeries() ? $$.parseDate(_regions[i].end) : _regions[i].end;
}
}
}
// Set scales
xValue = config.axis_rotated ? function (d) { return y(d.value); } : function (d) { return x(d.x); };
yValue = config.axis_rotated ? function (d) { return x(d.x); } : function (d) { return y(d.value); };
// Define svg generator function for region
function generateM(points) {
return 'M' + points[0][0] + ' ' + points[0][1] + ' ' + points[1][0] + ' ' + points[1][1];
}
if ($$.isTimeSeries()) {
sWithRegion = function (d0, d1, j, diff) {
var x0 = d0.x.getTime(), x_diff = d1.x - d0.x,
xv0 = new Date(x0 + x_diff * j),
xv1 = new Date(x0 + x_diff * (j + diff)),
points;
if (config.axis_rotated) {
points = [[y(yp(j)), x(xv0)], [y(yp(j + diff)), x(xv1)]];
} else {
points = [[x(xv0), y(yp(j))], [x(xv1), y(yp(j + diff))]];
}
return generateM(points);
};
} else {
sWithRegion = function (d0, d1, j, diff) {
var points;
if (config.axis_rotated) {
points = [[y(yp(j), true), x(xp(j))], [y(yp(j + diff), true), x(xp(j + diff))]];
} else {
points = [[x(xp(j), true), y(yp(j))], [x(xp(j + diff), true), y(yp(j + diff))]];
}
return generateM(points);
};
}
// Generate
for (i = 0; i < d.length; i++) {
// Draw as normal
if (isUndefined(regions) || ! isWithinRegions(d[i].x, regions)) {
s += " " + xValue(d[i]) + " " + yValue(d[i]);
}
// Draw with region // TODO: Fix for horizotal charts
else {
xp = $$.getScale(d[i - 1].x + xOffset, d[i].x + xOffset, $$.isTimeSeries());
yp = $$.getScale(d[i - 1].value, d[i].value);
dx = x(d[i].x) - x(d[i - 1].x);
dy = y(d[i].value) - y(d[i - 1].value);
dd = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
diff = 2 / dd;
diffx2 = diff * 2;
for (j = diff; j <= 1; j += diffx2) {
s += sWithRegion(d[i - 1], d[i], j, diff);
}
}
prev = d[i].x;
}
return s;
};
c3_chart_internal_fn.updateArea = function (durationForExit) {
var $$ = this, d3 = $$.d3;
$$.mainArea = $$.main.selectAll('.' + CLASS.areas).selectAll('.' + CLASS.area)
.data($$.lineData.bind($$));
$$.mainArea.enter().append('path')
.attr("class", $$.classArea.bind($$))
.style("fill", $$.color)
.style("opacity", function () { $$.orgAreaOpacity = +d3.select(this).style('opacity'); return 0; });
$$.mainArea
.style("opacity", $$.orgAreaOpacity);
$$.mainArea.exit().transition().duration(durationForExit)
.style('opacity', 0)
.remove();
};
c3_chart_internal_fn.redrawArea = function (drawArea, withTransition) {
return [
(withTransition ? this.mainArea.transition(Math.random().toString()) : this.mainArea)
.attr("d", drawArea)
.style("fill", this.color)
.style("opacity", this.orgAreaOpacity)
];
};
c3_chart_internal_fn.generateDrawArea = function (areaIndices, isSub) {
var $$ = this, config = $$.config, area = $$.d3.svg.area(),
getPoints = $$.generateGetAreaPoints(areaIndices, isSub),
yScaleGetter = isSub ? $$.getSubYScale : $$.getYScale,
xValue = function (d) { return (isSub ? $$.subxx : $$.xx).call($$, d); },
value0 = function (d, i) {
return config.data_groups.length > 0 ? getPoints(d, i)[0][1] : yScaleGetter.call($$, d.id)($$.getAreaBaseValue(d.id));
},
value1 = function (d, i) {
return config.data_groups.length > 0 ? getPoints(d, i)[1][1] : yScaleGetter.call($$, d.id)(d.value);
};
area = config.axis_rotated ? area.x0(value0).x1(value1).y(xValue) : area.x(xValue).y0(config.area_above ? 0 : value0).y1(value1);
if (!config.line_connectNull) {
area = area.defined(function (d) { return d.value !== null; });
}
return function (d) {
var values = config.line_connectNull ? $$.filterRemoveNull(d.values) : d.values,
x0 = 0, y0 = 0, path;
if ($$.isAreaType(d)) {
if ($$.isStepType(d)) { values = $$.convertValuesToStep(values); }
path = area.interpolate($$.getInterpolate(d))(values);
} else {
if (values[0]) {
x0 = $$.x(values[0].x);
y0 = $$.getYScale(d.id)(values[0].value);
}
path = config.axis_rotated ? "M " + y0 + " " + x0 : "M " + x0 + " " + y0;
}
return path ? path : "M 0 0";
};
};
c3_chart_internal_fn.getAreaBaseValue = function () {
return 0;
};
c3_chart_internal_fn.generateGetAreaPoints = function (areaIndices, isSub) { // partial duplication of generateGetBarPoints
var $$ = this, config = $$.config,
areaTargetsNum = areaIndices.__max__ + 1,
x = $$.getShapeX(0, areaTargetsNum, areaIndices, !!isSub),
y = $$.getShapeY(!!isSub),
areaOffset = $$.getShapeOffset($$.isAreaType, areaIndices, !!isSub),
yScale = isSub ? $$.getSubYScale : $$.getYScale;
return function (d, i) {
var y0 = yScale.call($$, d.id)(0),
offset = areaOffset(d, i) || y0, // offset is for stacked area chart
posX = x(d), posY = y(d);
// fix posY not to overflow opposite quadrant
if (config.axis_rotated) {
if ((0 < d.value && posY < y0) || (d.value < 0 && y0 < posY)) { posY = y0; }
}
// 1 point that marks the area position
return [
[posX, offset],
[posX, posY - (y0 - offset)],
[posX, posY - (y0 - offset)], // needed for compatibility
[posX, offset] // needed for compatibility
];
};
};
c3_chart_internal_fn.updateCircle = function () {
var $$ = this;
$$.mainCircle = $$.main.selectAll('.' + CLASS.circles).selectAll('.' + CLASS.circle)
.data($$.lineOrScatterData.bind($$));
$$.mainCircle.enter().append("circle")
.attr("class", $$.classCircle.bind($$))
.attr("r", $$.pointR.bind($$))
.style("fill", $$.color);
$$.mainCircle
.style("opacity", $$.initialOpacityForCircle.bind($$));
$$.mainCircle.exit().remove();
};
c3_chart_internal_fn.redrawCircle = function (cx, cy, withTransition) {
var selectedCircles = this.main.selectAll('.' + CLASS.selectedCircle);
return [
(withTransition ? this.mainCircle.transition(Math.random().toString()) : this.mainCircle)
.style('opacity', this.opacityForCircle.bind(this))
.style("fill", this.color)
.attr("cx", cx)
.attr("cy", cy),
(withTransition ? selectedCircles.transition(Math.random().toString()) : selectedCircles)
.attr("cx", cx)
.attr("cy", cy)
];
};
c3_chart_internal_fn.circleX = function (d) {
return d.x || d.x === 0 ? this.x(d.x) : null;
};
c3_chart_internal_fn.updateCircleY = function () {
var $$ = this, lineIndices, getPoints;
if ($$.config.data_groups.length > 0) {
lineIndices = $$.getShapeIndices($$.isLineType),
getPoints = $$.generateGetLinePoints(lineIndices);
$$.circleY = function (d, i) {
return getPoints(d, i)[0][1];
};
} else {
$$.circleY = function (d) {
return $$.getYScale(d.id)(d.value);
};
}
};
c3_chart_internal_fn.getCircles = function (i, id) {
var $$ = this;
return (id ? $$.main.selectAll('.' + CLASS.circles + $$.getTargetSelectorSuffix(id)) : $$.main).selectAll('.' + CLASS.circle + (isValue(i) ? '-' + i : ''));
};
c3_chart_internal_fn.expandCircles = function (i, id, reset) {
var $$ = this,
r = $$.pointExpandedR.bind($$);
if (reset) { $$.unexpandCircles(); }
$$.getCircles(i, id)
.classed(CLASS.EXPANDED, true)
.attr('r', r);
};
c3_chart_internal_fn.unexpandCircles = function (i) {
var $$ = this,
r = $$.pointR.bind($$);
$$.getCircles(i)
.filter(function () { return $$.d3.select(this).classed(CLASS.EXPANDED); })
.classed(CLASS.EXPANDED, false)
.attr('r', r);
};
c3_chart_internal_fn.pointR = function (d) {
var $$ = this, config = $$.config;
return $$.isStepType(d) ? 0 : (isFunction(config.point_r) ? config.point_r(d) : config.point_r);
};
c3_chart_internal_fn.pointExpandedR = function (d) {
var $$ = this, config = $$.config;
return config.point_focus_expand_enabled ? (config.point_focus_expand_r ? config.point_focus_expand_r : $$.pointR(d) * 1.75) : $$.pointR(d);
};
c3_chart_internal_fn.pointSelectR = function (d) {
var $$ = this, config = $$.config;
return isFunction(config.point_select_r) ? config.point_select_r(d) : ((config.point_select_r) ? config.point_select_r : $$.pointR(d) * 4);
};
c3_chart_internal_fn.isWithinCircle = function (that, r) {
var d3 = this.d3,
mouse = d3.mouse(that), d3_this = d3.select(that),
cx = +d3_this.attr("cx"), cy = +d3_this.attr("cy");
return Math.sqrt(Math.pow(cx - mouse[0], 2) + Math.pow(cy - mouse[1], 2)) < r;
};
c3_chart_internal_fn.isWithinStep = function (that, y) {
return Math.abs(y - this.d3.mouse(that)[1]) < 30;
};
c3_chart_internal_fn.initBar = function () {
var $$ = this;
$$.main.select('.' + CLASS.chart).append("g")
.attr("class", CLASS.chartBars);
};
c3_chart_internal_fn.updateTargetsForBar = function (targets) {
var $$ = this, config = $$.config,
mainBarUpdate, mainBarEnter,
classChartBar = $$.classChartBar.bind($$),
classBars = $$.classBars.bind($$),
classFocus = $$.classFocus.bind($$);
mainBarUpdate = $$.main.select('.' + CLASS.chartBars).selectAll('.' + CLASS.chartBar)
.data(targets)
.attr('class', function (d) { return classChartBar(d) + classFocus(d); });
mainBarEnter = mainBarUpdate.enter().append('g')
.attr('class', classChartBar)
.style('opacity', 0)
.style("pointer-events", "none");
// Bars for each data
mainBarEnter.append('g')
.attr("class", classBars)
.style("cursor", function (d) { return config.data_selection_isselectable(d) ? "pointer" : null; });
};
c3_chart_internal_fn.updateBar = function (durationForExit) {
var $$ = this,
barData = $$.barData.bind($$),
classBar = $$.classBar.bind($$),
initialOpacity = $$.initialOpacity.bind($$),
color = function (d) { return $$.color(d.id); };
$$.mainBar = $$.main.selectAll('.' + CLASS.bars).selectAll('.' + CLASS.bar)
.data(barData);
$$.mainBar.enter().append('path')
.attr("class", classBar)
.style("stroke", color)
.style("fill", color);
$$.mainBar
.style("opacity", initialOpacity);
$$.mainBar.exit().transition().duration(durationForExit)
.style('opacity', 0)
.remove();
};
c3_chart_internal_fn.redrawBar = function (drawBar, withTransition) {
return [
(withTransition ? this.mainBar.transition(Math.random().toString()) : this.mainBar)
.attr('d', drawBar)
.style("fill", this.color)
.style("opacity", 1)
];
};
c3_chart_internal_fn.getBarW = function (axis, barTargetsNum) {
var $$ = this, config = $$.config,
w = typeof config.bar_width === 'number' ? config.bar_width : barTargetsNum ? (axis.tickInterval() * config.bar_width_ratio) / barTargetsNum : 0;
return config.bar_width_max && w > config.bar_width_max ? config.bar_width_max : w;
};
c3_chart_internal_fn.getBars = function (i, id) {
var $$ = this;
return (id ? $$.main.selectAll('.' + CLASS.bars + $$.getTargetSelectorSuffix(id)) : $$.main).selectAll('.' + CLASS.bar + (isValue(i) ? '-' + i : ''));
};
c3_chart_internal_fn.expandBars = function (i, id, reset) {
var $$ = this;
if (reset) { $$.unexpandBars(); }
$$.getBars(i, id).classed(CLASS.EXPANDED, true);
};
c3_chart_internal_fn.unexpandBars = function (i) {
var $$ = this;
$$.getBars(i).classed(CLASS.EXPANDED, false);
};
c3_chart_internal_fn.generateDrawBar = function (barIndices, isSub) {
var $$ = this, config = $$.config,
getPoints = $$.generateGetBarPoints(barIndices, isSub);
return function (d, i) {
// 4 points that make a bar
var points = getPoints(d, i);
// switch points if axis is rotated, not applicable for sub chart
var indexX = config.axis_rotated ? 1 : 0;
var indexY = config.axis_rotated ? 0 : 1;
var path = 'M ' + points[0][indexX] + ',' + points[0][indexY] + ' ' +
'L' + points[1][indexX] + ',' + points[1][indexY] + ' ' +
'L' + points[2][indexX] + ',' + points[2][indexY] + ' ' +
'L' + points[3][indexX] + ',' + points[3][indexY] + ' ' +
'z';
return path;
};
};
c3_chart_internal_fn.generateGetBarPoints = function (barIndices, isSub) {
var $$ = this,
axis = isSub ? $$.subXAxis : $$.xAxis,
barTargetsNum = barIndices.__max__ + 1,
barW = $$.getBarW(axis, barTargetsNum),
barX = $$.getShapeX(barW, barTargetsNum, barIndices, !!isSub),
barY = $$.getShapeY(!!isSub),
barOffset = $$.getShapeOffset($$.isBarType, barIndices, !!isSub),
yScale = isSub ? $$.getSubYScale : $$.getYScale;
return function (d, i) {
var y0 = yScale.call($$, d.id)(0),
offset = barOffset(d, i) || y0, // offset is for stacked bar chart
posX = barX(d), posY = barY(d);
// fix posY not to overflow opposite quadrant
if ($$.config.axis_rotated) {
if ((0 < d.value && posY < y0) || (d.value < 0 && y0 < posY)) { posY = y0; }
}
// 4 points that make a bar
return [
[posX, offset],
[posX, posY - (y0 - offset)],
[posX + barW, posY - (y0 - offset)],
[posX + barW, offset]
];
};
};
c3_chart_internal_fn.isWithinBar = function (that) {
var mouse = this.d3.mouse(that), box = that.getBoundingClientRect(),
seg0 = that.pathSegList.getItem(0), seg1 = that.pathSegList.getItem(1),
x = Math.min(seg0.x, seg1.x), y = Math.min(seg0.y, seg1.y),
w = box.width, h = box.height, offset = 2,
sx = x - offset, ex = x + w + offset, sy = y + h + offset, ey = y - offset;
return sx < mouse[0] && mouse[0] < ex && ey < mouse[1] && mouse[1] < sy;
};
c3_chart_internal_fn.initText = function () {
var $$ = this;
$$.main.select('.' + CLASS.chart).append("g")
.attr("class", CLASS.chartTexts);
$$.mainText = $$.d3.selectAll([]);
};
c3_chart_internal_fn.updateTargetsForText = function (targets) {
var $$ = this, mainTextUpdate, mainTextEnter,
classChartText = $$.classChartText.bind($$),
classTexts = $$.classTexts.bind($$),
classFocus = $$.classFocus.bind($$);
mainTextUpdate = $$.main.select('.' + CLASS.chartTexts).selectAll('.' + CLASS.chartText)
.data(targets)
.attr('class', function (d) { return classChartText(d) + classFocus(d); });
mainTextEnter = mainTextUpdate.enter().append('g')
.attr('class', classChartText)
.style('opacity', 0)
.style("pointer-events", "none");
mainTextEnter.append('g')
.attr('class', classTexts);
};
c3_chart_internal_fn.updateText = function (durationForExit) {
var $$ = this, config = $$.config,
barOrLineData = $$.barOrLineData.bind($$),
classText = $$.classText.bind($$);
$$.mainText = $$.main.selectAll('.' + CLASS.texts).selectAll('.' + CLASS.text)
.data(barOrLineData);
$$.mainText.enter().append('text')
.attr("class", classText)
.attr('text-anchor', function (d) { return config.axis_rotated ? (d.value < 0 ? 'end' : 'start') : 'middle'; })
.style("stroke", 'none')
.style("fill", function (d) { return $$.color(d); })
.style("fill-opacity", 0);
$$.mainText
.text(function (d, i, j) { return $$.dataLabelFormat(d.id)(d.value, d.id, i, j); });
$$.mainText.exit()
.transition().duration(durationForExit)
.style('fill-opacity', 0)
.remove();
};
c3_chart_internal_fn.redrawText = function (xForText, yForText, forFlow, withTransition) {
return [
(withTransition ? this.mainText.transition() : this.mainText)
.attr('x', xForText)
.attr('y', yForText)
.style("fill", this.color)
.style("fill-opacity", forFlow ? 0 : this.opacityForText.bind(this))
];
};
c3_chart_internal_fn.getTextRect = function (text, cls, element) {
var dummy = this.d3.select('body').append('div').classed('c3', true),
svg = dummy.append("svg").style('visibility', 'hidden').style('position', 'fixed').style('top', 0).style('left', 0),
font = this.d3.select(element).style('font'),
rect;
svg.selectAll('.dummy')
.data([text])
.enter().append('text')
.classed(cls ? cls : "", true)
.style('font', font)
.text(text)
.each(function () { rect = this.getBoundingClientRect(); });
dummy.remove();
return rect;
};
c3_chart_internal_fn.generateXYForText = function (areaIndices, barIndices, lineIndices, forX) {
var $$ = this,
getAreaPoints = $$.generateGetAreaPoints(areaIndices, false),
getBarPoints = $$.generateGetBarPoints(barIndices, false),
getLinePoints = $$.generateGetLinePoints(lineIndices, false),
getter = forX ? $$.getXForText : $$.getYForText;
return function (d, i) {
var getPoints = $$.isAreaType(d) ? getAreaPoints : $$.isBarType(d) ? getBarPoints : getLinePoints;
return getter.call($$, getPoints(d, i), d, this);
};
};
c3_chart_internal_fn.getXForText = function (points, d, textElement) {
var $$ = this,
box = textElement.getBoundingClientRect(), xPos, padding;
if ($$.config.axis_rotated) {
padding = $$.isBarType(d) ? 4 : 6;
xPos = points[2][1] + padding * (d.value < 0 ? -1 : 1);
} else {
xPos = $$.hasType('bar') ? (points[2][0] + points[0][0]) / 2 : points[0][0];
}
// show labels regardless of the domain if value is null
if (d.value === null) {
if (xPos > $$.width) {
xPos = $$.width - box.width;
} else if (xPos < 0) {
xPos = 4;
}
}
return xPos;
};
c3_chart_internal_fn.getYForText = function (points, d, textElement) {
var $$ = this,
box = textElement.getBoundingClientRect(),
yPos;
if ($$.config.axis_rotated) {
yPos = (points[0][0] + points[2][0] + box.height * 0.6) / 2;
} else {
yPos = points[2][1];
if (d.value < 0 || (d.value === 0 && !$$.hasPositiveValue)) {
yPos += box.height;
if ($$.isBarType(d) && $$.isSafari()) {
yPos -= 3;
}
else if (!$$.isBarType(d) && $$.isChrome()) {
yPos += 3;
}
} else {
yPos += $$.isBarType(d) ? -3 : -6;
}
}
// show labels regardless of the domain if value is null
if (d.value === null && !$$.config.axis_rotated) {
if (yPos < box.height) {
yPos = box.height;
} else if (yPos > this.height) {
yPos = this.height - 4;
}
}
return yPos;
};
c3_chart_internal_fn.setTargetType = function (targetIds, type) {
var $$ = this, config = $$.config;
$$.mapToTargetIds(targetIds).forEach(function (id) {
$$.withoutFadeIn[id] = (type === config.data_types[id]);
config.data_types[id] = type;
});
if (!targetIds) {
config.data_type = type;
}
};
c3_chart_internal_fn.hasType = function (type, targets) {
var $$ = this, types = $$.config.data_types, has = false;
targets = targets || $$.data.targets;
if (targets && targets.length) {
targets.forEach(function (target) {
var t = types[target.id];
if ((t && t.indexOf(type) >= 0) || (!t && type === 'line')) {
has = true;
}
});
} else if (Object.keys(types).length) {
Object.keys(types).forEach(function (id) {
if (types[id] === type) { has = true; }
});
} else {
has = $$.config.data_type === type;
}
return has;
};
c3_chart_internal_fn.hasArcType = function (targets) {
return this.hasType('pie', targets) || this.hasType('donut', targets) || this.hasType('gauge', targets);
};
c3_chart_internal_fn.isLineType = function (d) {
var config = this.config, id = isString(d) ? d : d.id;
return !config.data_types[id] || ['line', 'spline', 'area', 'area-spline', 'step', 'area-step'].indexOf(config.data_types[id]) >= 0;
};
c3_chart_internal_fn.isStepType = function (d) {
var id = isString(d) ? d : d.id;
return ['step', 'area-step'].indexOf(this.config.data_types[id]) >= 0;
};
c3_chart_internal_fn.isSplineType = function (d) {
var id = isString(d) ? d : d.id;
return ['spline', 'area-spline'].indexOf(this.config.data_types[id]) >= 0;
};
c3_chart_internal_fn.isAreaType = function (d) {
var id = isString(d) ? d : d.id;
return ['area', 'area-spline', 'area-step'].indexOf(this.config.data_types[id]) >= 0;
};
c3_chart_internal_fn.isBarType = function (d) {
var id = isString(d) ? d : d.id;
return this.config.data_types[id] === 'bar';
};
c3_chart_internal_fn.isScatterType = function (d) {
var id = isString(d) ? d : d.id;
return this.config.data_types[id] === 'scatter';
};
c3_chart_internal_fn.isPieType = function (d) {
var id = isString(d) ? d : d.id;
return this.config.data_types[id] === 'pie';
};
c3_chart_internal_fn.isGaugeType = function (d) {
var id = isString(d) ? d : d.id;
return this.config.data_types[id] === 'gauge';
};
c3_chart_internal_fn.isDonutType = function (d) {
var id = isString(d) ? d : d.id;
return this.config.data_types[id] === 'donut';
};
c3_chart_internal_fn.isArcType = function (d) {
return this.isPieType(d) || this.isDonutType(d) || this.isGaugeType(d);
};
c3_chart_internal_fn.lineData = function (d) {
return this.isLineType(d) ? [d] : [];
};
c3_chart_internal_fn.arcData = function (d) {
return this.isArcType(d.data) ? [d] : [];
};
/* not used
function scatterData(d) {
return isScatterType(d) ? d.values : [];
}
*/
c3_chart_internal_fn.barData = function (d) {
return this.isBarType(d) ? d.values : [];
};
c3_chart_internal_fn.lineOrScatterData = function (d) {
return this.isLineType(d) || this.isScatterType(d) ? d.values : [];
};
c3_chart_internal_fn.barOrLineData = function (d) {
return this.isBarType(d) || this.isLineType(d) ? d.values : [];
};
c3_chart_internal_fn.isInterpolationType = function (type) {
return ['linear', 'linear-closed', 'basis', 'basis-open', 'basis-closed', 'bundle', 'cardinal', 'cardinal-open', 'cardinal-closed', 'monotone'].indexOf(type) >= 0;
};
c3_chart_internal_fn.initGrid = function () {
var $$ = this, config = $$.config, d3 = $$.d3;
$$.grid = $$.main.append('g')
.attr("clip-path", $$.clipPathForGrid)
.attr('class', CLASS.grid);
if (config.grid_x_show) {
$$.grid.append("g").attr("class", CLASS.xgrids);
}
if (config.grid_y_show) {
$$.grid.append('g').attr('class', CLASS.ygrids);
}
if (config.grid_focus_show) {
$$.grid.append('g')
.attr("class", CLASS.xgridFocus)
.append('line')
.attr('class', CLASS.xgridFocus);
}
$$.xgrid = d3.selectAll([]);
if (!config.grid_lines_front) { $$.initGridLines(); }
};
c3_chart_internal_fn.initGridLines = function () {
var $$ = this, d3 = $$.d3;
$$.gridLines = $$.main.append('g')
.attr("clip-path", $$.clipPathForGrid)
.attr('class', CLASS.grid + ' ' + CLASS.gridLines);
$$.gridLines.append('g').attr("class", CLASS.xgridLines);
$$.gridLines.append('g').attr('class', CLASS.ygridLines);
$$.xgridLines = d3.selectAll([]);
};
c3_chart_internal_fn.updateXGrid = function (withoutUpdate) {
var $$ = this, config = $$.config, d3 = $$.d3,
xgridData = $$.generateGridData(config.grid_x_type, $$.x),
tickOffset = $$.isCategorized() ? $$.xAxis.tickOffset() : 0;
$$.xgridAttr = config.axis_rotated ? {
'x1': 0,
'x2': $$.width,
'y1': function (d) { return $$.x(d) - tickOffset; },
'y2': function (d) { return $$.x(d) - tickOffset; }
} : {
'x1': function (d) { return $$.x(d) + tickOffset; },
'x2': function (d) { return $$.x(d) + tickOffset; },
'y1': 0,
'y2': $$.height
};
$$.xgrid = $$.main.select('.' + CLASS.xgrids).selectAll('.' + CLASS.xgrid)
.data(xgridData);
$$.xgrid.enter().append('line').attr("class", CLASS.xgrid);
if (!withoutUpdate) {
$$.xgrid.attr($$.xgridAttr)
.style("opacity", function () { return +d3.select(this).attr(config.axis_rotated ? 'y1' : 'x1') === (config.axis_rotated ? $$.height : 0) ? 0 : 1; });
}
$$.xgrid.exit().remove();
};
c3_chart_internal_fn.updateYGrid = function () {
var $$ = this, config = $$.config,
gridValues = $$.yAxis.tickValues() || $$.y.ticks(config.grid_y_ticks);
$$.ygrid = $$.main.select('.' + CLASS.ygrids).selectAll('.' + CLASS.ygrid)
.data(gridValues);
$$.ygrid.enter().append('line')
.attr('class', CLASS.ygrid);
$$.ygrid.attr("x1", config.axis_rotated ? $$.y : 0)
.attr("x2", config.axis_rotated ? $$.y : $$.width)
.attr("y1", config.axis_rotated ? 0 : $$.y)
.attr("y2", config.axis_rotated ? $$.height : $$.y);
$$.ygrid.exit().remove();
$$.smoothLines($$.ygrid, 'grid');
};
c3_chart_internal_fn.gridTextAnchor = function (d) {
return d.position ? d.position : "end";
};
c3_chart_internal_fn.gridTextDx = function (d) {
return d.position === 'start' ? 4 : d.position === 'middle' ? 0 : -4;
};
c3_chart_internal_fn.xGridTextX = function (d) {
return d.position === 'start' ? -this.height : d.position === 'middle' ? -this.height / 2 : 0;
};
c3_chart_internal_fn.yGridTextX = function (d) {
return d.position === 'start' ? 0 : d.position === 'middle' ? this.width / 2 : this.width;
};
c3_chart_internal_fn.updateGrid = function (duration) {
var $$ = this, main = $$.main, config = $$.config,
xgridLine, ygridLine, yv;
// hide if arc type
$$.grid.style('visibility', $$.hasArcType() ? 'hidden' : 'visible');
main.select('line.' + CLASS.xgridFocus).style("visibility", "hidden");
if (config.grid_x_show) {
$$.updateXGrid();
}
$$.xgridLines = main.select('.' + CLASS.xgridLines).selectAll('.' + CLASS.xgridLine)
.data(config.grid_x_lines);
// enter
xgridLine = $$.xgridLines.enter().append('g')
.attr("class", function (d) { return CLASS.xgridLine + (d['class'] ? ' ' + d['class'] : ''); });
xgridLine.append('line')
.style("opacity", 0);
xgridLine.append('text')
.attr("text-anchor", $$.gridTextAnchor)
.attr("transform", config.axis_rotated ? "" : "rotate(-90)")
.attr('dx', $$.gridTextDx)
.attr('dy', -5)
.style("opacity", 0);
// udpate
// done in d3.transition() of the end of this function
// exit
$$.xgridLines.exit().transition().duration(duration)
.style("opacity", 0)
.remove();
// Y-Grid
if (config.grid_y_show) {
$$.updateYGrid();
}
$$.ygridLines = main.select('.' + CLASS.ygridLines).selectAll('.' + CLASS.ygridLine)
.data(config.grid_y_lines);
// enter
ygridLine = $$.ygridLines.enter().append('g')
.attr("class", function (d) { return CLASS.ygridLine + (d['class'] ? ' ' + d['class'] : ''); });
ygridLine.append('line')
.style("opacity", 0);
ygridLine.append('text')
.attr("text-anchor", $$.gridTextAnchor)
.attr("transform", config.axis_rotated ? "rotate(-90)" : "")
.attr('dx', $$.gridTextDx)
.attr('dy', -5)
.style("opacity", 0);
// update
yv = $$.yv.bind($$);
$$.ygridLines.select('line')
.transition().duration(duration)
.attr("x1", config.axis_rotated ? yv : 0)
.attr("x2", config.axis_rotated ? yv : $$.width)
.attr("y1", config.axis_rotated ? 0 : yv)
.attr("y2", config.axis_rotated ? $$.height : yv)
.style("opacity", 1);
$$.ygridLines.select('text')
.transition().duration(duration)
.attr("x", config.axis_rotated ? $$.xGridTextX.bind($$) : $$.yGridTextX.bind($$))
.attr("y", yv)
.text(function (d) { return d.text; })
.style("opacity", 1);
// exit
$$.ygridLines.exit().transition().duration(duration)
.style("opacity", 0)
.remove();
};
c3_chart_internal_fn.redrawGrid = function (withTransition) {
var $$ = this, config = $$.config, xv = $$.xv.bind($$),
lines = $$.xgridLines.select('line'),
texts = $$.xgridLines.select('text');
return [
(withTransition ? lines.transition() : lines)
.attr("x1", config.axis_rotated ? 0 : xv)
.attr("x2", config.axis_rotated ? $$.width : xv)
.attr("y1", config.axis_rotated ? xv : 0)
.attr("y2", config.axis_rotated ? xv : $$.height)
.style("opacity", 1),
(withTransition ? texts.transition() : texts)
.attr("x", config.axis_rotated ? $$.yGridTextX.bind($$) : $$.xGridTextX.bind($$))
.attr("y", xv)
.text(function (d) { return d.text; })
.style("opacity", 1)
];
};
c3_chart_internal_fn.showXGridFocus = function (selectedData) {
var $$ = this, config = $$.config,
dataToShow = selectedData.filter(function (d) { return d && isValue(d.value); }),
focusEl = $$.main.selectAll('line.' + CLASS.xgridFocus),
xx = $$.xx.bind($$);
if (! config.tooltip_show) { return; }
// Hide when scatter plot exists
if ($$.hasType('scatter') || $$.hasArcType()) { return; }
focusEl
.style("visibility", "visible")
.data([dataToShow[0]])
.attr(config.axis_rotated ? 'y1' : 'x1', xx)
.attr(config.axis_rotated ? 'y2' : 'x2', xx);
$$.smoothLines(focusEl, 'grid');
};
c3_chart_internal_fn.hideXGridFocus = function () {
this.main.select('line.' + CLASS.xgridFocus).style("visibility", "hidden");
};
c3_chart_internal_fn.updateXgridFocus = function () {
var $$ = this, config = $$.config;
$$.main.select('line.' + CLASS.xgridFocus)
.attr("x1", config.axis_rotated ? 0 : -10)
.attr("x2", config.axis_rotated ? $$.width : -10)
.attr("y1", config.axis_rotated ? -10 : 0)
.attr("y2", config.axis_rotated ? -10 : $$.height);
};
c3_chart_internal_fn.generateGridData = function (type, scale) {
var $$ = this,
gridData = [], xDomain, firstYear, lastYear, i,
tickNum = $$.main.select("." + CLASS.axisX).selectAll('.tick').size();
if (type === 'year') {
xDomain = $$.getXDomain();
firstYear = xDomain[0].getFullYear();
lastYear = xDomain[1].getFullYear();
for (i = firstYear; i <= lastYear; i++) {
gridData.push(new Date(i + '-01-01 00:00:00'));
}
} else {
gridData = scale.ticks(10);
if (gridData.length > tickNum) { // use only int
gridData = gridData.filter(function (d) { return ("" + d).indexOf('.') < 0; });
}
}
return gridData;
};
c3_chart_internal_fn.getGridFilterToRemove = function (params) {
return params ? function (line) {
var found = false;
[].concat(params).forEach(function (param) {
if ((('value' in param && line.value === param.value) || ('class' in param && line['class'] === param['class']))) {
found = true;
}
});
return found;
} : function () { return true; };
};
c3_chart_internal_fn.removeGridLines = function (params, forX) {
var $$ = this, config = $$.config,
toRemove = $$.getGridFilterToRemove(params),
toShow = function (line) { return !toRemove(line); },
classLines = forX ? CLASS.xgridLines : CLASS.ygridLines,
classLine = forX ? CLASS.xgridLine : CLASS.ygridLine;
$$.main.select('.' + classLines).selectAll('.' + classLine).filter(toRemove)
.transition().duration(config.transition_duration)
.style('opacity', 0).remove();
if (forX) {
config.grid_x_lines = config.grid_x_lines.filter(toShow);
} else {
config.grid_y_lines = config.grid_y_lines.filter(toShow);
}
};
c3_chart_internal_fn.initTooltip = function () {
var $$ = this, config = $$.config, i;
$$.tooltip = $$.selectChart
.style("position", "relative")
.append("div")
.attr('class', CLASS.tooltipContainer)
.style("position", "absolute")
.style("pointer-events", "none")
.style("display", "none");
// Show tooltip if needed
if (config.tooltip_init_show) {
if ($$.isTimeSeries() && isString(config.tooltip_init_x)) {
config.tooltip_init_x = $$.parseDate(config.tooltip_init_x);
for (i = 0; i < $$.data.targets[0].values.length; i++) {
if (($$.data.targets[0].values[i].x - config.tooltip_init_x) === 0) { break; }
}
config.tooltip_init_x = i;
}
$$.tooltip.html(config.tooltip_contents.call($$, $$.data.targets.map(function (d) {
return $$.addName(d.values[config.tooltip_init_x]);
}), $$.axis.getXAxisTickFormat(), $$.getYFormat($$.hasArcType()), $$.color));
$$.tooltip.style("top", config.tooltip_init_position.top)
.style("left", config.tooltip_init_position.left)
.style("display", "block");
}
};
c3_chart_internal_fn.getTooltipContent = function (d, defaultTitleFormat, defaultValueFormat, color) {
var $$ = this, config = $$.config,
titleFormat = config.tooltip_format_title || defaultTitleFormat,
nameFormat = config.tooltip_format_name || function (name) { return name; },
valueFormat = config.tooltip_format_value || defaultValueFormat,
text, i, title, value, name, bgcolor,
orderAsc = $$.isOrderAsc();
if (config.data_groups.length === 0) {
d.sort(function(a, b){
var v1 = a ? a.value : null, v2 = b ? b.value : null;
return orderAsc ? v1 - v2 : v2 - v1;
});
} else {
var ids = $$.orderTargets($$.data.targets).map(function (i) {
return i.id;
});
d.sort(function(a, b) {
var v1 = a ? a.value : null, v2 = b ? b.value : null;
if (v1 > 0 && v2 > 0) {
v1 = a ? ids.indexOf(a.id) : null;
v2 = b ? ids.indexOf(b.id) : null;
}
return orderAsc ? v1 - v2 : v2 - v1;
});
}
for (i = 0; i < d.length; i++) {
if (! (d[i] && (d[i].value || d[i].value === 0))) { continue; }
if (! text) {
title = sanitise(titleFormat ? titleFormat(d[i].x) : d[i].x);
text = "<table class='" + $$.CLASS.tooltip + "'>" + (title || title === 0 ? "<tr><th colspan='2'>" + title + "</th></tr>" : "");
}
value = sanitise(valueFormat(d[i].value, d[i].ratio, d[i].id, d[i].index, d));
if (value !== undefined) {
// Skip elements when their name is set to null
if (d[i].name === null) { continue; }
name = sanitise(nameFormat(d[i].name, d[i].ratio, d[i].id, d[i].index));
bgcolor = $$.levelColor ? $$.levelColor(d[i].value) : color(d[i].id);
text += "<tr class='" + $$.CLASS.tooltipName + "-" + $$.getTargetSelectorSuffix(d[i].id) + "'>";
text += "<td class='name'><span style='background-color:" + bgcolor + "'></span>" + name + "</td>";
text += "<td class='value'>" + value + "</td>";
text += "</tr>";
}
}
return text + "</table>";
};
c3_chart_internal_fn.tooltipPosition = function (dataToShow, tWidth, tHeight, element) {
var $$ = this, config = $$.config, d3 = $$.d3;
var svgLeft, tooltipLeft, tooltipRight, tooltipTop, chartRight;
var forArc = $$.hasArcType(),
mouse = d3.mouse(element);
// Determin tooltip position
if (forArc) {
tooltipLeft = (($$.width - ($$.isLegendRight ? $$.getLegendWidth() : 0)) / 2) + mouse[0];
tooltipTop = ($$.height / 2) + mouse[1] + 20;
} else {
svgLeft = $$.getSvgLeft(true);
if (config.axis_rotated) {
tooltipLeft = svgLeft + mouse[0] + 100;
tooltipRight = tooltipLeft + tWidth;
chartRight = $$.currentWidth - $$.getCurrentPaddingRight();
tooltipTop = $$.x(dataToShow[0].x) + 20;
} else {
tooltipLeft = svgLeft + $$.getCurrentPaddingLeft(true) + $$.x(dataToShow[0].x) + 20;
tooltipRight = tooltipLeft + tWidth;
chartRight = svgLeft + $$.currentWidth - $$.getCurrentPaddingRight();
tooltipTop = mouse[1] + 15;
}
if (tooltipRight > chartRight) {
// 20 is needed for Firefox to keep tooltip width
tooltipLeft -= tooltipRight - chartRight + 20;
}
if (tooltipTop + tHeight > $$.currentHeight) {
tooltipTop -= tHeight + 30;
}
}
if (tooltipTop < 0) {
tooltipTop = 0;
}
return {top: tooltipTop, left: tooltipLeft};
};
c3_chart_internal_fn.showTooltip = function (selectedData, element) {
var $$ = this, config = $$.config;
var tWidth, tHeight, position;
var forArc = $$.hasArcType(),
dataToShow = selectedData.filter(function (d) { return d && isValue(d.value); }),
positionFunction = config.tooltip_position || c3_chart_internal_fn.tooltipPosition;
if (dataToShow.length === 0 || !config.tooltip_show) {
return;
}
$$.tooltip.html(config.tooltip_contents.call($$, selectedData, $$.axis.getXAxisTickFormat(), $$.getYFormat(forArc), $$.color)).style("display", "block");
// Get tooltip dimensions
tWidth = $$.tooltip.property('offsetWidth');
tHeight = $$.tooltip.property('offsetHeight');
position = positionFunction.call(this, dataToShow, tWidth, tHeight, element);
// Set tooltip
$$.tooltip
.style("top", position.top + "px")
.style("left", position.left + 'px');
};
c3_chart_internal_fn.hideTooltip = function () {
this.tooltip.style("display", "none");
};
c3_chart_internal_fn.initLegend = function () {
var $$ = this;
$$.legendItemTextBox = {};
$$.legendHasRendered = false;
$$.legend = $$.svg.append("g").attr("transform", $$.getTranslate('legend'));
if (!$$.config.legend_show) {
$$.legend.style('visibility', 'hidden');
$$.hiddenLegendIds = $$.mapToIds($$.data.targets);
return;
}
// MEMO: call here to update legend box and tranlate for all
// MEMO: translate will be upated by this, so transform not needed in updateLegend()
$$.updateLegendWithDefaults();
};
c3_chart_internal_fn.updateLegendWithDefaults = function () {
var $$ = this;
$$.updateLegend($$.mapToIds($$.data.targets), {withTransform: false, withTransitionForTransform: false, withTransition: false});
};
c3_chart_internal_fn.updateSizeForLegend = function (legendHeight, legendWidth) {
var $$ = this, config = $$.config, insetLegendPosition = {
top: $$.isLegendTop ? $$.getCurrentPaddingTop() + config.legend_inset_y + 5.5 : $$.currentHeight - legendHeight - $$.getCurrentPaddingBottom() - config.legend_inset_y,
left: $$.isLegendLeft ? $$.getCurrentPaddingLeft() + config.legend_inset_x + 0.5 : $$.currentWidth - legendWidth - $$.getCurrentPaddingRight() - config.legend_inset_x + 0.5
};
$$.margin3 = {
top: $$.isLegendRight ? 0 : $$.isLegendInset ? insetLegendPosition.top : $$.currentHeight - legendHeight,
right: NaN,
bottom: 0,
left: $$.isLegendRight ? $$.currentWidth - legendWidth : $$.isLegendInset ? insetLegendPosition.left : 0
};
};
c3_chart_internal_fn.transformLegend = function (withTransition) {
var $$ = this;
(withTransition ? $$.legend.transition() : $$.legend).attr("transform", $$.getTranslate('legend'));
};
c3_chart_internal_fn.updateLegendStep = function (step) {
this.legendStep = step;
};
c3_chart_internal_fn.updateLegendItemWidth = function (w) {
this.legendItemWidth = w;
};
c3_chart_internal_fn.updateLegendItemHeight = function (h) {
this.legendItemHeight = h;
};
c3_chart_internal_fn.getLegendWidth = function () {
var $$ = this;
return $$.config.legend_show ? $$.isLegendRight || $$.isLegendInset ? $$.legendItemWidth * ($$.legendStep + 1) : $$.currentWidth : 0;
};
c3_chart_internal_fn.getLegendHeight = function () {
var $$ = this, h = 0;
if ($$.config.legend_show) {
if ($$.isLegendRight) {
h = $$.currentHeight;
} else {
h = Math.max(20, $$.legendItemHeight) * ($$.legendStep + 1);
}
}
return h;
};
c3_chart_internal_fn.opacityForLegend = function (legendItem) {
return legendItem.classed(CLASS.legendItemHidden) ? null : 1;
};
c3_chart_internal_fn.opacityForUnfocusedLegend = function (legendItem) {
return legendItem.classed(CLASS.legendItemHidden) ? null : 0.3;
};
c3_chart_internal_fn.toggleFocusLegend = function (targetIds, focus) {
var $$ = this;
targetIds = $$.mapToTargetIds(targetIds);
$$.legend.selectAll('.' + CLASS.legendItem)
.filter(function (id) { return targetIds.indexOf(id) >= 0; })
.classed(CLASS.legendItemFocused, focus)
.transition().duration(100)
.style('opacity', function () {
var opacity = focus ? $$.opacityForLegend : $$.opacityForUnfocusedLegend;
return opacity.call($$, $$.d3.select(this));
});
};
c3_chart_internal_fn.revertLegend = function () {
var $$ = this, d3 = $$.d3;
$$.legend.selectAll('.' + CLASS.legendItem)
.classed(CLASS.legendItemFocused, false)
.transition().duration(100)
.style('opacity', function () { return $$.opacityForLegend(d3.select(this)); });
};
c3_chart_internal_fn.showLegend = function (targetIds) {
var $$ = this, config = $$.config;
if (!config.legend_show) {
config.legend_show = true;
$$.legend.style('visibility', 'visible');
if (!$$.legendHasRendered) {
$$.updateLegendWithDefaults();
}
}
$$.removeHiddenLegendIds(targetIds);
$$.legend.selectAll($$.selectorLegends(targetIds))
.style('visibility', 'visible')
.transition()
.style('opacity', function () { return $$.opacityForLegend($$.d3.select(this)); });
};
c3_chart_internal_fn.hideLegend = function (targetIds) {
var $$ = this, config = $$.config;
if (config.legend_show && isEmpty(targetIds)) {
config.legend_show = false;
$$.legend.style('visibility', 'hidden');
}
$$.addHiddenLegendIds(targetIds);
$$.legend.selectAll($$.selectorLegends(targetIds))
.style('opacity', 0)
.style('visibility', 'hidden');
};
c3_chart_internal_fn.clearLegendItemTextBoxCache = function () {
this.legendItemTextBox = {};
};
c3_chart_internal_fn.updateLegend = function (targetIds, options, transitions) {
var $$ = this, config = $$.config;
var xForLegend, xForLegendText, xForLegendRect, yForLegend, yForLegendText, yForLegendRect, x1ForLegendTile, x2ForLegendTile, yForLegendTile;
var paddingTop = 4, paddingRight = 10, maxWidth = 0, maxHeight = 0, posMin = 10, tileWidth = config.legend_item_tile_width + 5;
var l, totalLength = 0, offsets = {}, widths = {}, heights = {}, margins = [0], steps = {}, step = 0;
var withTransition, withTransitionForTransform;
var texts, rects, tiles, background;
// Skip elements when their name is set to null
targetIds = targetIds.filter(function(id) {
return !isDefined(config.data_names[id]) || config.data_names[id] !== null;
});
options = options || {};
withTransition = getOption(options, "withTransition", true);
withTransitionForTransform = getOption(options, "withTransitionForTransform", true);
function getTextBox(textElement, id) {
if (!$$.legendItemTextBox[id]) {
$$.legendItemTextBox[id] = $$.getTextRect(textElement.textContent, CLASS.legendItem, textElement);
}
return $$.legendItemTextBox[id];
}
function updatePositions(textElement, id, index) {
var reset = index === 0, isLast = index === targetIds.length - 1,
box = getTextBox(textElement, id),
itemWidth = box.width + tileWidth + (isLast && !($$.isLegendRight || $$.isLegendInset) ? 0 : paddingRight) + config.legend_padding,
itemHeight = box.height + paddingTop,
itemLength = $$.isLegendRight || $$.isLegendInset ? itemHeight : itemWidth,
areaLength = $$.isLegendRight || $$.isLegendInset ? $$.getLegendHeight() : $$.getLegendWidth(),
margin, maxLength;
// MEMO: care about condifion of step, totalLength
function updateValues(id, withoutStep) {
if (!withoutStep) {
margin = (areaLength - totalLength - itemLength) / 2;
if (margin < posMin) {
margin = (areaLength - itemLength) / 2;
totalLength = 0;
step++;
}
}
steps[id] = step;
margins[step] = $$.isLegendInset ? 10 : margin;
offsets[id] = totalLength;
totalLength += itemLength;
}
if (reset) {
totalLength = 0;
step = 0;
maxWidth = 0;
maxHeight = 0;
}
if (config.legend_show && !$$.isLegendToShow(id)) {
widths[id] = heights[id] = steps[id] = offsets[id] = 0;
return;
}
widths[id] = itemWidth;
heights[id] = itemHeight;
if (!maxWidth || itemWidth >= maxWidth) { maxWidth = itemWidth; }
if (!maxHeight || itemHeight >= maxHeight) { maxHeight = itemHeight; }
maxLength = $$.isLegendRight || $$.isLegendInset ? maxHeight : maxWidth;
if (config.legend_equally) {
Object.keys(widths).forEach(function (id) { widths[id] = maxWidth; });
Object.keys(heights).forEach(function (id) { heights[id] = maxHeight; });
margin = (areaLength - maxLength * targetIds.length) / 2;
if (margin < posMin) {
totalLength = 0;
step = 0;
targetIds.forEach(function (id) { updateValues(id); });
}
else {
updateValues(id, true);
}
} else {
updateValues(id);
}
}
if ($$.isLegendInset) {
step = config.legend_inset_step ? config.legend_inset_step : targetIds.length;
$$.updateLegendStep(step);
}
if ($$.isLegendRight) {
xForLegend = function (id) { return maxWidth * steps[id]; };
yForLegend = function (id) { return margins[steps[id]] + offsets[id]; };
} else if ($$.isLegendInset) {
xForLegend = function (id) { return maxWidth * steps[id] + 10; };
yForLegend = function (id) { return margins[steps[id]] + offsets[id]; };
} else {
xForLegend = function (id) { return margins[steps[id]] + offsets[id]; };
yForLegend = function (id) { return maxHeight * steps[id]; };
}
xForLegendText = function (id, i) { return xForLegend(id, i) + 4 + config.legend_item_tile_width; };
yForLegendText = function (id, i) { return yForLegend(id, i) + 9; };
xForLegendRect = function (id, i) { return xForLegend(id, i); };
yForLegendRect = function (id, i) { return yForLegend(id, i) - 5; };
x1ForLegendTile = function (id, i) { return xForLegend(id, i) - 2; };
x2ForLegendTile = function (id, i) { return xForLegend(id, i) - 2 + config.legend_item_tile_width; };
yForLegendTile = function (id, i) { return yForLegend(id, i) + 4; };
// Define g for legend area
l = $$.legend.selectAll('.' + CLASS.legendItem)
.data(targetIds)
.enter().append('g')
.attr('class', function (id) { return $$.generateClass(CLASS.legendItem, id); })
.style('visibility', function (id) { return $$.isLegendToShow(id) ? 'visible' : 'hidden'; })
.style('cursor', 'pointer')
.on('click', function (id) {
if (config.legend_item_onclick) {
config.legend_item_onclick.call($$, id);
} else {
if ($$.d3.event.altKey) {
$$.api.hide();
$$.api.show(id);
} else {
$$.api.toggle(id);
$$.isTargetToShow(id) ? $$.api.focus(id) : $$.api.revert();
}
}
})
.on('mouseover', function (id) {
if (config.legend_item_onmouseover) {
config.legend_item_onmouseover.call($$, id);
}
else {
$$.d3.select(this).classed(CLASS.legendItemFocused, true);
if (!$$.transiting && $$.isTargetToShow(id)) {
$$.api.focus(id);
}
}
})
.on('mouseout', function (id) {
if (config.legend_item_onmouseout) {
config.legend_item_onmouseout.call($$, id);
}
else {
$$.d3.select(this).classed(CLASS.legendItemFocused, false);
$$.api.revert();
}
});
l.append('text')
.text(function (id) { return isDefined(config.data_names[id]) ? config.data_names[id] : id; })
.each(function (id, i) { updatePositions(this, id, i); })
.style("pointer-events", "none")
.attr('x', $$.isLegendRight || $$.isLegendInset ? xForLegendText : -200)
.attr('y', $$.isLegendRight || $$.isLegendInset ? -200 : yForLegendText);
l.append('rect')
.attr("class", CLASS.legendItemEvent)
.style('fill-opacity', 0)
.attr('x', $$.isLegendRight || $$.isLegendInset ? xForLegendRect : -200)
.attr('y', $$.isLegendRight || $$.isLegendInset ? -200 : yForLegendRect);
l.append('line')
.attr('class', CLASS.legendItemTile)
.style('stroke', $$.color)
.style("pointer-events", "none")
.attr('x1', $$.isLegendRight || $$.isLegendInset ? x1ForLegendTile : -200)
.attr('y1', $$.isLegendRight || $$.isLegendInset ? -200 : yForLegendTile)
.attr('x2', $$.isLegendRight || $$.isLegendInset ? x2ForLegendTile : -200)
.attr('y2', $$.isLegendRight || $$.isLegendInset ? -200 : yForLegendTile)
.attr('stroke-width', config.legend_item_tile_height);
// Set background for inset legend
background = $$.legend.select('.' + CLASS.legendBackground + ' rect');
if ($$.isLegendInset && maxWidth > 0 && background.size() === 0) {
background = $$.legend.insert('g', '.' + CLASS.legendItem)
.attr("class", CLASS.legendBackground)
.append('rect');
}
texts = $$.legend.selectAll('text')
.data(targetIds)
.text(function (id) { return isDefined(config.data_names[id]) ? config.data_names[id] : id; }) // MEMO: needed for update
.each(function (id, i) { updatePositions(this, id, i); });
(withTransition ? texts.transition() : texts)
.attr('x', xForLegendText)
.attr('y', yForLegendText);
rects = $$.legend.selectAll('rect.' + CLASS.legendItemEvent)
.data(targetIds);
(withTransition ? rects.transition() : rects)
.attr('width', function (id) { return widths[id]; })
.attr('height', function (id) { return heights[id]; })
.attr('x', xForLegendRect)
.attr('y', yForLegendRect);
tiles = $$.legend.selectAll('line.' + CLASS.legendItemTile)
.data(targetIds);
(withTransition ? tiles.transition() : tiles)
.style('stroke', $$.color)
.attr('x1', x1ForLegendTile)
.attr('y1', yForLegendTile)
.attr('x2', x2ForLegendTile)
.attr('y2', yForLegendTile);
if (background) {
(withTransition ? background.transition() : background)
.attr('height', $$.getLegendHeight() - 12)
.attr('width', maxWidth * (step + 1) + 10);
}
// toggle legend state
$$.legend.selectAll('.' + CLASS.legendItem)
.classed(CLASS.legendItemHidden, function (id) { return !$$.isTargetToShow(id); });
// Update all to reflect change of legend
$$.updateLegendItemWidth(maxWidth);
$$.updateLegendItemHeight(maxHeight);
$$.updateLegendStep(step);
// Update size and scale
$$.updateSizes();
$$.updateScales();
$$.updateSvgSize();
// Update g positions
$$.transformAll(withTransitionForTransform, transitions);
$$.legendHasRendered = true;
};
c3_chart_internal_fn.initTitle = function () {
var $$ = this;
$$.title = $$.svg.append("text")
.text($$.config.title_text)
.attr("class", $$.CLASS.title);
};
c3_chart_internal_fn.redrawTitle = function () {
var $$ = this;
$$.title
.attr("x", $$.xForTitle.bind($$))
.attr("y", $$.yForTitle.bind($$));
};
c3_chart_internal_fn.xForTitle = function () {
var $$ = this, config = $$.config, position = config.title_position || 'left', x;
if (position.indexOf('right') >= 0) {
x = $$.currentWidth - $$.getTextRect($$.title.node().textContent, $$.CLASS.title, $$.title.node()).width - config.title_padding.right;
} else if (position.indexOf('center') >= 0) {
x = ($$.currentWidth - $$.getTextRect($$.title.node().textContent, $$.CLASS.title, $$.title.node()).width) / 2;
} else { // left
x = config.title_padding.left;
}
return x;
};
c3_chart_internal_fn.yForTitle = function () {
var $$ = this;
return $$.config.title_padding.top + $$.getTextRect($$.title.node().textContent, $$.CLASS.title, $$.title.node()).height;
};
c3_chart_internal_fn.getTitlePadding = function() {
var $$ = this;
return $$.yForTitle() + $$.config.title_padding.bottom;
};
function Axis(owner) {
API.call(this, owner);
}
inherit(API, Axis);
Axis.prototype.init = function init() {
var $$ = this.owner, config = $$.config, main = $$.main;
$$.axes.x = main.append("g")
.attr("class", CLASS.axis + ' ' + CLASS.axisX)
.attr("clip-path", $$.clipPathForXAxis)
.attr("transform", $$.getTranslate('x'))
.style("visibility", config.axis_x_show ? 'visible' : 'hidden');
$$.axes.x.append("text")
.attr("class", CLASS.axisXLabel)
.attr("transform", config.axis_rotated ? "rotate(-90)" : "")
.style("text-anchor", this.textAnchorForXAxisLabel.bind(this));
$$.axes.y = main.append("g")
.attr("class", CLASS.axis + ' ' + CLASS.axisY)
.attr("clip-path", config.axis_y_inner ? "" : $$.clipPathForYAxis)
.attr("transform", $$.getTranslate('y'))
.style("visibility", config.axis_y_show ? 'visible' : 'hidden');
$$.axes.y.append("text")
.attr("class", CLASS.axisYLabel)
.attr("transform", config.axis_rotated ? "" : "rotate(-90)")
.style("text-anchor", this.textAnchorForYAxisLabel.bind(this));
$$.axes.y2 = main.append("g")
.attr("class", CLASS.axis + ' ' + CLASS.axisY2)
// clip-path?
.attr("transform", $$.getTranslate('y2'))
.style("visibility", config.axis_y2_show ? 'visible' : 'hidden');
$$.axes.y2.append("text")
.attr("class", CLASS.axisY2Label)
.attr("transform", config.axis_rotated ? "" : "rotate(-90)")
.style("text-anchor", this.textAnchorForY2AxisLabel.bind(this));
};
Axis.prototype.getXAxis = function getXAxis(scale, orient, tickFormat, tickValues, withOuterTick, withoutTransition, withoutRotateTickText) {
var $$ = this.owner, config = $$.config,
axisParams = {
isCategory: $$.isCategorized(),
withOuterTick: withOuterTick,
tickMultiline: config.axis_x_tick_multiline,
tickWidth: config.axis_x_tick_width,
tickTextRotate: withoutRotateTickText ? 0 : config.axis_x_tick_rotate,
withoutTransition: withoutTransition,
},
axis = c3_axis($$.d3, axisParams).scale(scale).orient(orient);
if ($$.isTimeSeries() && tickValues && typeof tickValues !== "function") {
tickValues = tickValues.map(function (v) { return $$.parseDate(v); });
}
// Set tick
axis.tickFormat(tickFormat).tickValues(tickValues);
if ($$.isCategorized()) {
axis.tickCentered(config.axis_x_tick_centered);
if (isEmpty(config.axis_x_tick_culling)) {
config.axis_x_tick_culling = false;
}
}
return axis;
};
Axis.prototype.updateXAxisTickValues = function updateXAxisTickValues(targets, axis) {
var $$ = this.owner, config = $$.config, tickValues;
if (config.axis_x_tick_fit || config.axis_x_tick_count) {
tickValues = this.generateTickValues($$.mapTargetsToUniqueXs(targets), config.axis_x_tick_count, $$.isTimeSeries());
}
if (axis) {
axis.tickValues(tickValues);
} else {
$$.xAxis.tickValues(tickValues);
$$.subXAxis.tickValues(tickValues);
}
return tickValues;
};
Axis.prototype.getYAxis = function getYAxis(scale, orient, tickFormat, tickValues, withOuterTick, withoutTransition, withoutRotateTickText) {
var $$ = this.owner, config = $$.config,
axisParams = {
withOuterTick: withOuterTick,
withoutTransition: withoutTransition,
tickTextRotate: withoutRotateTickText ? 0 : config.axis_y_tick_rotate
},
axis = c3_axis($$.d3, axisParams).scale(scale).orient(orient).tickFormat(tickFormat);
if ($$.isTimeSeriesY()) {
axis.ticks($$.d3.time[config.axis_y_tick_time_value], config.axis_y_tick_time_interval);
} else {
axis.tickValues(tickValues);
}
return axis;
};
Axis.prototype.getId = function getId(id) {
var config = this.owner.config;
return id in config.data_axes ? config.data_axes[id] : 'y';
};
Axis.prototype.getXAxisTickFormat = function getXAxisTickFormat() {
var $$ = this.owner, config = $$.config,
format = $$.isTimeSeries() ? $$.defaultAxisTimeFormat : $$.isCategorized() ? $$.categoryName : function (v) { return v < 0 ? v.toFixed(0) : v; };
if (config.axis_x_tick_format) {
if (isFunction(config.axis_x_tick_format)) {
format = config.axis_x_tick_format;
} else if ($$.isTimeSeries()) {
format = function (date) {
return date ? $$.axisTimeFormat(config.axis_x_tick_format)(date) : "";
};
}
}
return isFunction(format) ? function (v) { return format.call($$, v); } : format;
};
Axis.prototype.getTickValues = function getTickValues(tickValues, axis) {
return tickValues ? tickValues : axis ? axis.tickValues() : undefined;
};
Axis.prototype.getXAxisTickValues = function getXAxisTickValues() {
return this.getTickValues(this.owner.config.axis_x_tick_values, this.owner.xAxis);
};
Axis.prototype.getYAxisTickValues = function getYAxisTickValues() {
return this.getTickValues(this.owner.config.axis_y_tick_values, this.owner.yAxis);
};
Axis.prototype.getY2AxisTickValues = function getY2AxisTickValues() {
return this.getTickValues(this.owner.config.axis_y2_tick_values, this.owner.y2Axis);
};
Axis.prototype.getLabelOptionByAxisId = function getLabelOptionByAxisId(axisId) {
var $$ = this.owner, config = $$.config, option;
if (axisId === 'y') {
option = config.axis_y_label;
} else if (axisId === 'y2') {
option = config.axis_y2_label;
} else if (axisId === 'x') {
option = config.axis_x_label;
}
return option;
};
Axis.prototype.getLabelText = function getLabelText(axisId) {
var option = this.getLabelOptionByAxisId(axisId);
return isString(option) ? option : option ? option.text : null;
};
Axis.prototype.setLabelText = function setLabelText(axisId, text) {
var $$ = this.owner, config = $$.config,
option = this.getLabelOptionByAxisId(axisId);
if (isString(option)) {
if (axisId === 'y') {
config.axis_y_label = text;
} else if (axisId === 'y2') {
config.axis_y2_label = text;
} else if (axisId === 'x') {
config.axis_x_label = text;
}
} else if (option) {
option.text = text;
}
};
Axis.prototype.getLabelPosition = function getLabelPosition(axisId, defaultPosition) {
var option = this.getLabelOptionByAxisId(axisId),
position = (option && typeof option === 'object' && option.position) ? option.position : defaultPosition;
return {
isInner: position.indexOf('inner') >= 0,
isOuter: position.indexOf('outer') >= 0,
isLeft: position.indexOf('left') >= 0,
isCenter: position.indexOf('center') >= 0,
isRight: position.indexOf('right') >= 0,
isTop: position.indexOf('top') >= 0,
isMiddle: position.indexOf('middle') >= 0,
isBottom: position.indexOf('bottom') >= 0
};
};
Axis.prototype.getXAxisLabelPosition = function getXAxisLabelPosition() {
return this.getLabelPosition('x', this.owner.config.axis_rotated ? 'inner-top' : 'inner-right');
};
Axis.prototype.getYAxisLabelPosition = function getYAxisLabelPosition() {
return this.getLabelPosition('y', this.owner.config.axis_rotated ? 'inner-right' : 'inner-top');
};
Axis.prototype.getY2AxisLabelPosition = function getY2AxisLabelPosition() {
return this.getLabelPosition('y2', this.owner.config.axis_rotated ? 'inner-right' : 'inner-top');
};
Axis.prototype.getLabelPositionById = function getLabelPositionById(id) {
return id === 'y2' ? this.getY2AxisLabelPosition() : id === 'y' ? this.getYAxisLabelPosition() : this.getXAxisLabelPosition();
};
Axis.prototype.textForXAxisLabel = function textForXAxisLabel() {
return this.getLabelText('x');
};
Axis.prototype.textForYAxisLabel = function textForYAxisLabel() {
return this.getLabelText('y');
};
Axis.prototype.textForY2AxisLabel = function textForY2AxisLabel() {
return this.getLabelText('y2');
};
Axis.prototype.xForAxisLabel = function xForAxisLabel(forHorizontal, position) {
var $$ = this.owner;
if (forHorizontal) {
return position.isLeft ? 0 : position.isCenter ? $$.width / 2 : $$.width;
} else {
return position.isBottom ? -$$.height : position.isMiddle ? -$$.height / 2 : 0;
}
};
Axis.prototype.dxForAxisLabel = function dxForAxisLabel(forHorizontal, position) {
if (forHorizontal) {
return position.isLeft ? "0.5em" : position.isRight ? "-0.5em" : "0";
} else {
return position.isTop ? "-0.5em" : position.isBottom ? "0.5em" : "0";
}
};
Axis.prototype.textAnchorForAxisLabel = function textAnchorForAxisLabel(forHorizontal, position) {
if (forHorizontal) {
return position.isLeft ? 'start' : position.isCenter ? 'middle' : 'end';
} else {
return position.isBottom ? 'start' : position.isMiddle ? 'middle' : 'end';
}
};
Axis.prototype.xForXAxisLabel = function xForXAxisLabel() {
return this.xForAxisLabel(!this.owner.config.axis_rotated, this.getXAxisLabelPosition());
};
Axis.prototype.xForYAxisLabel = function xForYAxisLabel() {
return this.xForAxisLabel(this.owner.config.axis_rotated, this.getYAxisLabelPosition());
};
Axis.prototype.xForY2AxisLabel = function xForY2AxisLabel() {
return this.xForAxisLabel(this.owner.config.axis_rotated, this.getY2AxisLabelPosition());
};
Axis.prototype.dxForXAxisLabel = function dxForXAxisLabel() {
return this.dxForAxisLabel(!this.owner.config.axis_rotated, this.getXAxisLabelPosition());
};
Axis.prototype.dxForYAxisLabel = function dxForYAxisLabel() {
return this.dxForAxisLabel(this.owner.config.axis_rotated, this.getYAxisLabelPosition());
};
Axis.prototype.dxForY2AxisLabel = function dxForY2AxisLabel() {
return this.dxForAxisLabel(this.owner.config.axis_rotated, this.getY2AxisLabelPosition());
};
Axis.prototype.dyForXAxisLabel = function dyForXAxisLabel() {
var $$ = this.owner, config = $$.config,
position = this.getXAxisLabelPosition();
if (config.axis_rotated) {
return position.isInner ? "1.2em" : -25 - this.getMaxTickWidth('x');
} else {
return position.isInner ? "-0.5em" : config.axis_x_height ? config.axis_x_height - 10 : "3em";
}
};
Axis.prototype.dyForYAxisLabel = function dyForYAxisLabel() {
var $$ = this.owner,
position = this.getYAxisLabelPosition();
if ($$.config.axis_rotated) {
return position.isInner ? "-0.5em" : "3em";
} else {
return position.isInner ? "1.2em" : -10 - ($$.config.axis_y_inner ? 0 : (this.getMaxTickWidth('y') + 10));
}
};
Axis.prototype.dyForY2AxisLabel = function dyForY2AxisLabel() {
var $$ = this.owner,
position = this.getY2AxisLabelPosition();
if ($$.config.axis_rotated) {
return position.isInner ? "1.2em" : "-2.2em";
} else {
return position.isInner ? "-0.5em" : 15 + ($$.config.axis_y2_inner ? 0 : (this.getMaxTickWidth('y2') + 15));
}
};
Axis.prototype.textAnchorForXAxisLabel = function textAnchorForXAxisLabel() {
var $$ = this.owner;
return this.textAnchorForAxisLabel(!$$.config.axis_rotated, this.getXAxisLabelPosition());
};
Axis.prototype.textAnchorForYAxisLabel = function textAnchorForYAxisLabel() {
var $$ = this.owner;
return this.textAnchorForAxisLabel($$.config.axis_rotated, this.getYAxisLabelPosition());
};
Axis.prototype.textAnchorForY2AxisLabel = function textAnchorForY2AxisLabel() {
var $$ = this.owner;
return this.textAnchorForAxisLabel($$.config.axis_rotated, this.getY2AxisLabelPosition());
};
Axis.prototype.getMaxTickWidth = function getMaxTickWidth(id, withoutRecompute) {
var $$ = this.owner, config = $$.config,
maxWidth = 0, targetsToShow, scale, axis, dummy, svg;
if (withoutRecompute && $$.currentMaxTickWidths[id]) {
return $$.currentMaxTickWidths[id];
}
if ($$.svg) {
targetsToShow = $$.filterTargetsToShow($$.data.targets);
if (id === 'y') {
scale = $$.y.copy().domain($$.getYDomain(targetsToShow, 'y'));
axis = this.getYAxis(scale, $$.yOrient, config.axis_y_tick_format, $$.yAxisTickValues, false, true, true);
} else if (id === 'y2') {
scale = $$.y2.copy().domain($$.getYDomain(targetsToShow, 'y2'));
axis = this.getYAxis(scale, $$.y2Orient, config.axis_y2_tick_format, $$.y2AxisTickValues, false, true, true);
} else {
scale = $$.x.copy().domain($$.getXDomain(targetsToShow));
axis = this.getXAxis(scale, $$.xOrient, $$.xAxisTickFormat, $$.xAxisTickValues, false, true, true);
this.updateXAxisTickValues(targetsToShow, axis);
}
dummy = $$.d3.select('body').append('div').classed('c3', true);
svg = dummy.append("svg").style('visibility', 'hidden').style('position', 'fixed').style('top', 0).style('left', 0),
svg.append('g').call(axis).each(function () {
$$.d3.select(this).selectAll('text').each(function () {
var box = this.getBoundingClientRect();
if (maxWidth < box.width) { maxWidth = box.width; }
});
dummy.remove();
});
}
$$.currentMaxTickWidths[id] = maxWidth <= 0 ? $$.currentMaxTickWidths[id] : maxWidth;
return $$.currentMaxTickWidths[id];
};
Axis.prototype.updateLabels = function updateLabels(withTransition) {
var $$ = this.owner;
var axisXLabel = $$.main.select('.' + CLASS.axisX + ' .' + CLASS.axisXLabel),
axisYLabel = $$.main.select('.' + CLASS.axisY + ' .' + CLASS.axisYLabel),
axisY2Label = $$.main.select('.' + CLASS.axisY2 + ' .' + CLASS.axisY2Label);
(withTransition ? axisXLabel.transition() : axisXLabel)
.attr("x", this.xForXAxisLabel.bind(this))
.attr("dx", this.dxForXAxisLabel.bind(this))
.attr("dy", this.dyForXAxisLabel.bind(this))
.text(this.textForXAxisLabel.bind(this));
(withTransition ? axisYLabel.transition() : axisYLabel)
.attr("x", this.xForYAxisLabel.bind(this))
.attr("dx", this.dxForYAxisLabel.bind(this))
.attr("dy", this.dyForYAxisLabel.bind(this))
.text(this.textForYAxisLabel.bind(this));
(withTransition ? axisY2Label.transition() : axisY2Label)
.attr("x", this.xForY2AxisLabel.bind(this))
.attr("dx", this.dxForY2AxisLabel.bind(this))
.attr("dy", this.dyForY2AxisLabel.bind(this))
.text(this.textForY2AxisLabel.bind(this));
};
Axis.prototype.getPadding = function getPadding(padding, key, defaultValue, domainLength) {
var p = typeof padding === 'number' ? padding : padding[key];
if (!isValue(p)) {
return defaultValue;
}
if (padding.unit === 'ratio') {
return padding[key] * domainLength;
}
// assume padding is pixels if unit is not specified
return this.convertPixelsToAxisPadding(p, domainLength);
};
Axis.prototype.convertPixelsToAxisPadding = function convertPixelsToAxisPadding(pixels, domainLength) {
var $$ = this.owner,
length = $$.config.axis_rotated ? $$.width : $$.height;
return domainLength * (pixels / length);
};
Axis.prototype.generateTickValues = function generateTickValues(values, tickCount, forTimeSeries) {
var tickValues = values, targetCount, start, end, count, interval, i, tickValue;
if (tickCount) {
targetCount = isFunction(tickCount) ? tickCount() : tickCount;
// compute ticks according to tickCount
if (targetCount === 1) {
tickValues = [values[0]];
} else if (targetCount === 2) {
tickValues = [values[0], values[values.length - 1]];
} else if (targetCount > 2) {
count = targetCount - 2;
start = values[0];
end = values[values.length - 1];
interval = (end - start) / (count + 1);
// re-construct unique values
tickValues = [start];
for (i = 0; i < count; i++) {
tickValue = +start + interval * (i + 1);
tickValues.push(forTimeSeries ? new Date(tickValue) : tickValue);
}
tickValues.push(end);
}
}
if (!forTimeSeries) { tickValues = tickValues.sort(function (a, b) { return a - b; }); }
return tickValues;
};
Axis.prototype.generateTransitions = function generateTransitions(duration) {
var $$ = this.owner, axes = $$.axes;
return {
axisX: duration ? axes.x.transition().duration(duration) : axes.x,
axisY: duration ? axes.y.transition().duration(duration) : axes.y,
axisY2: duration ? axes.y2.transition().duration(duration) : axes.y2,
axisSubX: duration ? axes.subx.transition().duration(duration) : axes.subx
};
};
Axis.prototype.redraw = function redraw(transitions, isHidden) {
var $$ = this.owner;
$$.axes.x.style("opacity", isHidden ? 0 : 1);
$$.axes.y.style("opacity", isHidden ? 0 : 1);
$$.axes.y2.style("opacity", isHidden ? 0 : 1);
$$.axes.subx.style("opacity", isHidden ? 0 : 1);
transitions.axisX.call($$.xAxis);
transitions.axisY.call($$.yAxis);
transitions.axisY2.call($$.y2Axis);
transitions.axisSubX.call($$.subXAxis);
};
c3_chart_internal_fn.getClipPath = function (id) {
var isIE9 = window.navigator.appVersion.toLowerCase().indexOf("msie 9.") >= 0;
return "url(" + (isIE9 ? "" : document.URL.split('#')[0]) + "#" + id + ")";
};
c3_chart_internal_fn.appendClip = function (parent, id) {
return parent.append("clipPath").attr("id", id).append("rect");
};
c3_chart_internal_fn.getAxisClipX = function (forHorizontal) {
// axis line width + padding for left
var left = Math.max(30, this.margin.left);
return forHorizontal ? -(1 + left) : -(left - 1);
};
c3_chart_internal_fn.getAxisClipY = function (forHorizontal) {
return forHorizontal ? -20 : -this.margin.top;
};
c3_chart_internal_fn.getXAxisClipX = function () {
var $$ = this;
return $$.getAxisClipX(!$$.config.axis_rotated);
};
c3_chart_internal_fn.getXAxisClipY = function () {
var $$ = this;
return $$.getAxisClipY(!$$.config.axis_rotated);
};
c3_chart_internal_fn.getYAxisClipX = function () {
var $$ = this;
return $$.config.axis_y_inner ? -1 : $$.getAxisClipX($$.config.axis_rotated);
};
c3_chart_internal_fn.getYAxisClipY = function () {
var $$ = this;
return $$.getAxisClipY($$.config.axis_rotated);
};
c3_chart_internal_fn.getAxisClipWidth = function (forHorizontal) {
var $$ = this,
left = Math.max(30, $$.margin.left),
right = Math.max(30, $$.margin.right);
// width + axis line width + padding for left/right
return forHorizontal ? $$.width + 2 + left + right : $$.margin.left + 20;
};
c3_chart_internal_fn.getAxisClipHeight = function (forHorizontal) {
// less than 20 is not enough to show the axis label 'outer' without legend
return (forHorizontal ? this.margin.bottom : (this.margin.top + this.height)) + 20;
};
c3_chart_internal_fn.getXAxisClipWidth = function () {
var $$ = this;
return $$.getAxisClipWidth(!$$.config.axis_rotated);
};
c3_chart_internal_fn.getXAxisClipHeight = function () {
var $$ = this;
return $$.getAxisClipHeight(!$$.config.axis_rotated);
};
c3_chart_internal_fn.getYAxisClipWidth = function () {
var $$ = this;
return $$.getAxisClipWidth($$.config.axis_rotated) + ($$.config.axis_y_inner ? 20 : 0);
};
c3_chart_internal_fn.getYAxisClipHeight = function () {
var $$ = this;
return $$.getAxisClipHeight($$.config.axis_rotated);
};
c3_chart_internal_fn.initPie = function () {
var $$ = this, d3 = $$.d3, config = $$.config;
$$.pie = d3.layout.pie().value(function (d) {
return d.values.reduce(function (a, b) { return a + b.value; }, 0);
});
if (!config.data_order) {
$$.pie.sort(null);
}
};
c3_chart_internal_fn.updateRadius = function () {
var $$ = this, config = $$.config,
w = config.gauge_width || config.donut_width;
$$.radiusExpanded = Math.min($$.arcWidth, $$.arcHeight) / 2;
$$.radius = $$.radiusExpanded * 0.95;
$$.innerRadiusRatio = w ? ($$.radius - w) / $$.radius : 0.6;
$$.innerRadius = $$.hasType('donut') || $$.hasType('gauge') ? $$.radius * $$.innerRadiusRatio : 0;
};
c3_chart_internal_fn.updateArc = function () {
var $$ = this;
$$.svgArc = $$.getSvgArc();
$$.svgArcExpanded = $$.getSvgArcExpanded();
$$.svgArcExpandedSub = $$.getSvgArcExpanded(0.98);
};
c3_chart_internal_fn.updateAngle = function (d) {
var $$ = this, config = $$.config,
found = false, index = 0,
gMin, gMax, gTic, gValue;
if (!config) {
return null;
}
$$.pie($$.filterTargetsToShow($$.data.targets)).forEach(function (t) {
if (! found && t.data.id === d.data.id) {
found = true;
d = t;
d.index = index;
}
index++;
});
if (isNaN(d.startAngle)) {
d.startAngle = 0;
}
if (isNaN(d.endAngle)) {
d.endAngle = d.startAngle;
}
if ($$.isGaugeType(d.data)) {
gMin = config.gauge_min;
gMax = config.gauge_max;
gTic = (Math.PI * (config.gauge_fullCircle ? 2 : 1)) / (gMax - gMin);
gValue = d.value < gMin ? 0 : d.value < gMax ? d.value - gMin : (gMax - gMin);
d.startAngle = config.gauge_startingAngle;
d.endAngle = d.startAngle + gTic * gValue;
}
return found ? d : null;
};
c3_chart_internal_fn.getSvgArc = function () {
var $$ = this,
arc = $$.d3.svg.arc().outerRadius($$.radius).innerRadius($$.innerRadius),
newArc = function (d, withoutUpdate) {
var updated;
if (withoutUpdate) { return arc(d); } // for interpolate
updated = $$.updateAngle(d);
return updated ? arc(updated) : "M 0 0";
};
// TODO: extends all function
newArc.centroid = arc.centroid;
return newArc;
};
c3_chart_internal_fn.getSvgArcExpanded = function (rate) {
var $$ = this,
arc = $$.d3.svg.arc().outerRadius($$.radiusExpanded * (rate ? rate : 1)).innerRadius($$.innerRadius);
return function (d) {
var updated = $$.updateAngle(d);
return updated ? arc(updated) : "M 0 0";
};
};
c3_chart_internal_fn.getArc = function (d, withoutUpdate, force) {
return force || this.isArcType(d.data) ? this.svgArc(d, withoutUpdate) : "M 0 0";
};
c3_chart_internal_fn.transformForArcLabel = function (d) {
var $$ = this, config = $$.config,
updated = $$.updateAngle(d), c, x, y, h, ratio, translate = "";
if (updated && !$$.hasType('gauge')) {
c = this.svgArc.centroid(updated);
x = isNaN(c[0]) ? 0 : c[0];
y = isNaN(c[1]) ? 0 : c[1];
h = Math.sqrt(x * x + y * y);
if ($$.hasType('donut') && config.donut_label_ratio) {
ratio = isFunction(config.donut_label_ratio) ? config.donut_label_ratio(d, $$.radius, h) : config.donut_label_ratio;
} else if ($$.hasType('pie') && config.pie_label_ratio) {
ratio = isFunction(config.pie_label_ratio) ? config.pie_label_ratio(d, $$.radius, h) : config.pie_label_ratio;
} else {
ratio = $$.radius && h ? (36 / $$.radius > 0.375 ? 1.175 - 36 / $$.radius : 0.8) * $$.radius / h : 0;
}
translate = "translate(" + (x * ratio) + ',' + (y * ratio) + ")";
}
return translate;
};
c3_chart_internal_fn.getArcRatio = function (d) {
var $$ = this,
config = $$.config,
whole = Math.PI * ($$.hasType('gauge') && !config.gauge_fullCircle ? 1 : 2);
return d ? (d.endAngle - d.startAngle) / whole : null;
};
c3_chart_internal_fn.convertToArcData = function (d) {
return this.addName({
id: d.data.id,
value: d.value,
ratio: this.getArcRatio(d),
index: d.index
});
};
c3_chart_internal_fn.textForArcLabel = function (d) {
var $$ = this,
updated, value, ratio, id, format;
if (! $$.shouldShowArcLabel()) { return ""; }
updated = $$.updateAngle(d);
value = updated ? updated.value : null;
ratio = $$.getArcRatio(updated);
id = d.data.id;
if (! $$.hasType('gauge') && ! $$.meetsArcLabelThreshold(ratio)) { return ""; }
format = $$.getArcLabelFormat();
return format ? format(value, ratio, id) : $$.defaultArcValueFormat(value, ratio);
};
c3_chart_internal_fn.expandArc = function (targetIds) {
var $$ = this, interval;
// MEMO: avoid to cancel transition
if ($$.transiting) {
interval = window.setInterval(function () {
if (!$$.transiting) {
window.clearInterval(interval);
if ($$.legend.selectAll('.c3-legend-item-focused').size() > 0) {
$$.expandArc(targetIds);
}
}
}, 10);
return;
}
targetIds = $$.mapToTargetIds(targetIds);
$$.svg.selectAll($$.selectorTargets(targetIds, '.' + CLASS.chartArc)).each(function (d) {
if (! $$.shouldExpand(d.data.id)) { return; }
$$.d3.select(this).selectAll('path')
.transition().duration($$.expandDuration(d.data.id))
.attr("d", $$.svgArcExpanded)
.transition().duration($$.expandDuration(d.data.id) * 2)
.attr("d", $$.svgArcExpandedSub)
.each(function (d) {
if ($$.isDonutType(d.data)) {
// callback here
}
});
});
};
c3_chart_internal_fn.unexpandArc = function (targetIds) {
var $$ = this;
if ($$.transiting) { return; }
targetIds = $$.mapToTargetIds(targetIds);
$$.svg.selectAll($$.selectorTargets(targetIds, '.' + CLASS.chartArc)).selectAll('path')
.transition().duration(function(d) {
return $$.expandDuration(d.data.id);
})
.attr("d", $$.svgArc);
$$.svg.selectAll('.' + CLASS.arc)
.style("opacity", 1);
};
c3_chart_internal_fn.expandDuration = function (id) {
var $$ = this, config = $$.config;
if ($$.isDonutType(id)) {
return config.donut_expand_duration;
} else if ($$.isGaugeType(id)) {
return config.gauge_expand_duration;
} else if ($$.isPieType(id)) {
return config.pie_expand_duration;
} else {
return 50;
}
};
c3_chart_internal_fn.shouldExpand = function (id) {
var $$ = this, config = $$.config;
return ($$.isDonutType(id) && config.donut_expand) ||
($$.isGaugeType(id) && config.gauge_expand) ||
($$.isPieType(id) && config.pie_expand);
};
c3_chart_internal_fn.shouldShowArcLabel = function () {
var $$ = this, config = $$.config, shouldShow = true;
if ($$.hasType('donut')) {
shouldShow = config.donut_label_show;
} else if ($$.hasType('pie')) {
shouldShow = config.pie_label_show;
}
// when gauge, always true
return shouldShow;
};
c3_chart_internal_fn.meetsArcLabelThreshold = function (ratio) {
var $$ = this, config = $$.config,
threshold = $$.hasType('donut') ? config.donut_label_threshold : config.pie_label_threshold;
return ratio >= threshold;
};
c3_chart_internal_fn.getArcLabelFormat = function () {
var $$ = this, config = $$.config,
format = config.pie_label_format;
if ($$.hasType('gauge')) {
format = config.gauge_label_format;
} else if ($$.hasType('donut')) {
format = config.donut_label_format;
}
return format;
};
c3_chart_internal_fn.getArcTitle = function () {
var $$ = this;
return $$.hasType('donut') ? $$.config.donut_title : "";
};
c3_chart_internal_fn.updateTargetsForArc = function (targets) {
var $$ = this, main = $$.main,
mainPieUpdate, mainPieEnter,
classChartArc = $$.classChartArc.bind($$),
classArcs = $$.classArcs.bind($$),
classFocus = $$.classFocus.bind($$);
mainPieUpdate = main.select('.' + CLASS.chartArcs).selectAll('.' + CLASS.chartArc)
.data($$.pie(targets))
.attr("class", function (d) { return classChartArc(d) + classFocus(d.data); });
mainPieEnter = mainPieUpdate.enter().append("g")
.attr("class", classChartArc);
mainPieEnter.append('g')
.attr('class', classArcs);
mainPieEnter.append("text")
.attr("dy", $$.hasType('gauge') ? "-.1em" : ".35em")
.style("opacity", 0)
.style("text-anchor", "middle")
.style("pointer-events", "none");
// MEMO: can not keep same color..., but not bad to update color in redraw
//mainPieUpdate.exit().remove();
};
c3_chart_internal_fn.initArc = function () {
var $$ = this;
$$.arcs = $$.main.select('.' + CLASS.chart).append("g")
.attr("class", CLASS.chartArcs)
.attr("transform", $$.getTranslate('arc'));
$$.arcs.append('text')
.attr('class', CLASS.chartArcsTitle)
.style("text-anchor", "middle")
.text($$.getArcTitle());
};
c3_chart_internal_fn.redrawArc = function (duration, durationForExit, withTransform) {
var $$ = this, d3 = $$.d3, config = $$.config, main = $$.main,
mainArc;
mainArc = main.selectAll('.' + CLASS.arcs).selectAll('.' + CLASS.arc)
.data($$.arcData.bind($$));
mainArc.enter().append('path')
.attr("class", $$.classArc.bind($$))
.style("fill", function (d) { return $$.color(d.data); })
.style("cursor", function (d) { return config.interaction_enabled && config.data_selection_isselectable(d) ? "pointer" : null; })
.style("opacity", 0)
.each(function (d) {
if ($$.isGaugeType(d.data)) {
d.startAngle = d.endAngle = config.gauge_startingAngle;
}
this._current = d;
});
mainArc
.attr("transform", function (d) { return !$$.isGaugeType(d.data) && withTransform ? "scale(0)" : ""; })
.style("opacity", function (d) { return d === this._current ? 0 : 1; })
.on('mouseover', config.interaction_enabled ? function (d) {
var updated, arcData;
if ($$.transiting) { // skip while transiting
return;
}
updated = $$.updateAngle(d);
if (updated) {
arcData = $$.convertToArcData(updated);
// transitions
$$.expandArc(updated.data.id);
$$.api.focus(updated.data.id);
$$.toggleFocusLegend(updated.data.id, true);
$$.config.data_onmouseover(arcData, this);
}
} : null)
.on('mousemove', config.interaction_enabled ? function (d) {
var updated = $$.updateAngle(d), arcData, selectedData;
if (updated) {
arcData = $$.convertToArcData(updated),
selectedData = [arcData];
$$.showTooltip(selectedData, this);
}
} : null)
.on('mouseout', config.interaction_enabled ? function (d) {
var updated, arcData;
if ($$.transiting) { // skip while transiting
return;
}
updated = $$.updateAngle(d);
if (updated) {
arcData = $$.convertToArcData(updated);
// transitions
$$.unexpandArc(updated.data.id);
$$.api.revert();
$$.revertLegend();
$$.hideTooltip();
$$.config.data_onmouseout(arcData, this);
}
} : null)
.on('click', config.interaction_enabled ? function (d, i) {
var updated = $$.updateAngle(d), arcData;
if (updated) {
arcData = $$.convertToArcData(updated);
if ($$.toggleShape) {
$$.toggleShape(this, arcData, i);
}
$$.config.data_onclick.call($$.api, arcData, this);
}
} : null)
.each(function () { $$.transiting = true; })
.transition().duration(duration)
.attrTween("d", function (d) {
var updated = $$.updateAngle(d), interpolate;
if (! updated) {
return function () { return "M 0 0"; };
}
// if (this._current === d) {
// this._current = {
// startAngle: Math.PI*2,
// endAngle: Math.PI*2,
// };
// }
if (isNaN(this._current.startAngle)) {
this._current.startAngle = 0;
}
if (isNaN(this._current.endAngle)) {
this._current.endAngle = this._current.startAngle;
}
interpolate = d3.interpolate(this._current, updated);
this._current = interpolate(0);
return function (t) {
var interpolated = interpolate(t);
interpolated.data = d.data; // data.id will be updated by interporator
return $$.getArc(interpolated, true);
};
})
.attr("transform", withTransform ? "scale(1)" : "")
.style("fill", function (d) {
return $$.levelColor ? $$.levelColor(d.data.values[0].value) : $$.color(d.data.id);
}) // Where gauge reading color would receive customization.
.style("opacity", 1)
.call($$.endall, function () {
$$.transiting = false;
});
mainArc.exit().transition().duration(durationForExit)
.style('opacity', 0)
.remove();
main.selectAll('.' + CLASS.chartArc).select('text')
.style("opacity", 0)
.attr('class', function (d) { return $$.isGaugeType(d.data) ? CLASS.gaugeValue : ''; })
.text($$.textForArcLabel.bind($$))
.attr("transform", $$.transformForArcLabel.bind($$))
.style('font-size', function (d) { return $$.isGaugeType(d.data) ? Math.round($$.radius / 5) + 'px' : ''; })
.transition().duration(duration)
.style("opacity", function (d) { return $$.isTargetToShow(d.data.id) && $$.isArcType(d.data) ? 1 : 0; });
main.select('.' + CLASS.chartArcsTitle)
.style("opacity", $$.hasType('donut') || $$.hasType('gauge') ? 1 : 0);
if ($$.hasType('gauge')) {
$$.arcs.select('.' + CLASS.chartArcsBackground)
.attr("d", function () {
var d = {
data: [{value: config.gauge_max}],
startAngle: config.gauge_startingAngle,
endAngle: -1 * config.gauge_startingAngle
};
return $$.getArc(d, true, true);
});
$$.arcs.select('.' + CLASS.chartArcsGaugeUnit)
.attr("dy", ".75em")
.text(config.gauge_label_show ? config.gauge_units : '');
$$.arcs.select('.' + CLASS.chartArcsGaugeMin)
.attr("dx", -1 * ($$.innerRadius + (($$.radius - $$.innerRadius) / (config.gauge_fullCircle ? 1 : 2))) + "px")
.attr("dy", "1.2em")
.text(config.gauge_label_show ? config.gauge_min : '');
$$.arcs.select('.' + CLASS.chartArcsGaugeMax)
.attr("dx", $$.innerRadius + (($$.radius - $$.innerRadius) / (config.gauge_fullCircle ? 1 : 2)) + "px")
.attr("dy", "1.2em")
.text(config.gauge_label_show ? config.gauge_max : '');
}
};
c3_chart_internal_fn.initGauge = function () {
var arcs = this.arcs;
if (this.hasType('gauge')) {
arcs.append('path')
.attr("class", CLASS.chartArcsBackground);
arcs.append("text")
.attr("class", CLASS.chartArcsGaugeUnit)
.style("text-anchor", "middle")
.style("pointer-events", "none");
arcs.append("text")
.attr("class", CLASS.chartArcsGaugeMin)
.style("text-anchor", "middle")
.style("pointer-events", "none");
arcs.append("text")
.attr("class", CLASS.chartArcsGaugeMax)
.style("text-anchor", "middle")
.style("pointer-events", "none");
}
};
c3_chart_internal_fn.getGaugeLabelHeight = function () {
return this.config.gauge_label_show ? 20 : 0;
};
c3_chart_internal_fn.initRegion = function () {
var $$ = this;
$$.region = $$.main.append('g')
.attr("clip-path", $$.clipPath)
.attr("class", CLASS.regions);
};
c3_chart_internal_fn.updateRegion = function (duration) {
var $$ = this, config = $$.config;
// hide if arc type
$$.region.style('visibility', $$.hasArcType() ? 'hidden' : 'visible');
$$.mainRegion = $$.main.select('.' + CLASS.regions).selectAll('.' + CLASS.region)
.data(config.regions);
$$.mainRegion.enter().append('g')
.append('rect')
.style("fill-opacity", 0);
$$.mainRegion
.attr('class', $$.classRegion.bind($$));
$$.mainRegion.exit().transition().duration(duration)
.style("opacity", 0)
.remove();
};
c3_chart_internal_fn.redrawRegion = function (withTransition) {
var $$ = this,
regions = $$.mainRegion.selectAll('rect').each(function () {
// data is binded to g and it's not transferred to rect (child node) automatically,
// then data of each rect has to be updated manually.
// TODO: there should be more efficient way to solve this?
var parentData = $$.d3.select(this.parentNode).datum();
$$.d3.select(this).datum(parentData);
}),
x = $$.regionX.bind($$),
y = $$.regionY.bind($$),
w = $$.regionWidth.bind($$),
h = $$.regionHeight.bind($$);
return [
(withTransition ? regions.transition() : regions)
.attr("x", x)
.attr("y", y)
.attr("width", w)
.attr("height", h)
.style("fill-opacity", function (d) { return isValue(d.opacity) ? d.opacity : 0.1; })
];
};
c3_chart_internal_fn.regionX = function (d) {
var $$ = this, config = $$.config,
xPos, yScale = d.axis === 'y' ? $$.y : $$.y2;
if (d.axis === 'y' || d.axis === 'y2') {
xPos = config.axis_rotated ? ('start' in d ? yScale(d.start) : 0) : 0;
} else {
xPos = config.axis_rotated ? 0 : ('start' in d ? $$.x($$.isTimeSeries() ? $$.parseDate(d.start) : d.start) : 0);
}
return xPos;
};
c3_chart_internal_fn.regionY = function (d) {
var $$ = this, config = $$.config,
yPos, yScale = d.axis === 'y' ? $$.y : $$.y2;
if (d.axis === 'y' || d.axis === 'y2') {
yPos = config.axis_rotated ? 0 : ('end' in d ? yScale(d.end) : 0);
} else {
yPos = config.axis_rotated ? ('start' in d ? $$.x($$.isTimeSeries() ? $$.parseDate(d.start) : d.start) : 0) : 0;
}
return yPos;
};
c3_chart_internal_fn.regionWidth = function (d) {
var $$ = this, config = $$.config,
start = $$.regionX(d), end, yScale = d.axis === 'y' ? $$.y : $$.y2;
if (d.axis === 'y' || d.axis === 'y2') {
end = config.axis_rotated ? ('end' in d ? yScale(d.end) : $$.width) : $$.width;
} else {
end = config.axis_rotated ? $$.width : ('end' in d ? $$.x($$.isTimeSeries() ? $$.parseDate(d.end) : d.end) : $$.width);
}
return end < start ? 0 : end - start;
};
c3_chart_internal_fn.regionHeight = function (d) {
var $$ = this, config = $$.config,
start = this.regionY(d), end, yScale = d.axis === 'y' ? $$.y : $$.y2;
if (d.axis === 'y' || d.axis === 'y2') {
end = config.axis_rotated ? $$.height : ('start' in d ? yScale(d.start) : $$.height);
} else {
end = config.axis_rotated ? ('end' in d ? $$.x($$.isTimeSeries() ? $$.parseDate(d.end) : d.end) : $$.height) : $$.height;
}
return end < start ? 0 : end - start;
};
c3_chart_internal_fn.isRegionOnX = function (d) {
return !d.axis || d.axis === 'x';
};
c3_chart_internal_fn.drag = function (mouse) {
var $$ = this, config = $$.config, main = $$.main, d3 = $$.d3;
var sx, sy, mx, my, minX, maxX, minY, maxY;
if ($$.hasArcType()) { return; }
if (! config.data_selection_enabled) { return; } // do nothing if not selectable
if (config.zoom_enabled && ! $$.zoom.altDomain) { return; } // skip if zoomable because of conflict drag dehavior
if (!config.data_selection_multiple) { return; } // skip when single selection because drag is used for multiple selection
sx = $$.dragStart[0];
sy = $$.dragStart[1];
mx = mouse[0];
my = mouse[1];
minX = Math.min(sx, mx);
maxX = Math.max(sx, mx);
minY = (config.data_selection_grouped) ? $$.margin.top : Math.min(sy, my);
maxY = (config.data_selection_grouped) ? $$.height : Math.max(sy, my);
main.select('.' + CLASS.dragarea)
.attr('x', minX)
.attr('y', minY)
.attr('width', maxX - minX)
.attr('height', maxY - minY);
// TODO: binary search when multiple xs
main.selectAll('.' + CLASS.shapes).selectAll('.' + CLASS.shape)
.filter(function (d) { return config.data_selection_isselectable(d); })
.each(function (d, i) {
var shape = d3.select(this),
isSelected = shape.classed(CLASS.SELECTED),
isIncluded = shape.classed(CLASS.INCLUDED),
_x, _y, _w, _h, toggle, isWithin = false, box;
if (shape.classed(CLASS.circle)) {
_x = shape.attr("cx") * 1;
_y = shape.attr("cy") * 1;
toggle = $$.togglePoint;
isWithin = minX < _x && _x < maxX && minY < _y && _y < maxY;
}
else if (shape.classed(CLASS.bar)) {
box = getPathBox(this);
_x = box.x;
_y = box.y;
_w = box.width;
_h = box.height;
toggle = $$.togglePath;
isWithin = !(maxX < _x || _x + _w < minX) && !(maxY < _y || _y + _h < minY);
} else {
// line/area selection not supported yet
return;
}
if (isWithin ^ isIncluded) {
shape.classed(CLASS.INCLUDED, !isIncluded);
// TODO: included/unincluded callback here
shape.classed(CLASS.SELECTED, !isSelected);
toggle.call($$, !isSelected, shape, d, i);
}
});
};
c3_chart_internal_fn.dragstart = function (mouse) {
var $$ = this, config = $$.config;
if ($$.hasArcType()) { return; }
if (! config.data_selection_enabled) { return; } // do nothing if not selectable
$$.dragStart = mouse;
$$.main.select('.' + CLASS.chart).append('rect')
.attr('class', CLASS.dragarea)
.style('opacity', 0.1);
$$.dragging = true;
};
c3_chart_internal_fn.dragend = function () {
var $$ = this, config = $$.config;
if ($$.hasArcType()) { return; }
if (! config.data_selection_enabled) { return; } // do nothing if not selectable
$$.main.select('.' + CLASS.dragarea)
.transition().duration(100)
.style('opacity', 0)
.remove();
$$.main.selectAll('.' + CLASS.shape)
.classed(CLASS.INCLUDED, false);
$$.dragging = false;
};
c3_chart_internal_fn.selectPoint = function (target, d, i) {
var $$ = this, config = $$.config,
cx = (config.axis_rotated ? $$.circleY : $$.circleX).bind($$),
cy = (config.axis_rotated ? $$.circleX : $$.circleY).bind($$),
r = $$.pointSelectR.bind($$);
config.data_onselected.call($$.api, d, target.node());
// add selected-circle on low layer g
$$.main.select('.' + CLASS.selectedCircles + $$.getTargetSelectorSuffix(d.id)).selectAll('.' + CLASS.selectedCircle + '-' + i)
.data([d])
.enter().append('circle')
.attr("class", function () { return $$.generateClass(CLASS.selectedCircle, i); })
.attr("cx", cx)
.attr("cy", cy)
.attr("stroke", function () { return $$.color(d); })
.attr("r", function (d) { return $$.pointSelectR(d) * 1.4; })
.transition().duration(100)
.attr("r", r);
};
c3_chart_internal_fn.unselectPoint = function (target, d, i) {
var $$ = this;
$$.config.data_onunselected.call($$.api, d, target.node());
// remove selected-circle from low layer g
$$.main.select('.' + CLASS.selectedCircles + $$.getTargetSelectorSuffix(d.id)).selectAll('.' + CLASS.selectedCircle + '-' + i)
.transition().duration(100).attr('r', 0)
.remove();
};
c3_chart_internal_fn.togglePoint = function (selected, target, d, i) {
selected ? this.selectPoint(target, d, i) : this.unselectPoint(target, d, i);
};
c3_chart_internal_fn.selectPath = function (target, d) {
var $$ = this;
$$.config.data_onselected.call($$, d, target.node());
if ($$.config.interaction_brighten) {
target.transition().duration(100)
.style("fill", function () { return $$.d3.rgb($$.color(d)).brighter(0.75); });
}
};
c3_chart_internal_fn.unselectPath = function (target, d) {
var $$ = this;
$$.config.data_onunselected.call($$, d, target.node());
if ($$.config.interaction_brighten) {
target.transition().duration(100)
.style("fill", function () { return $$.color(d); });
}
};
c3_chart_internal_fn.togglePath = function (selected, target, d, i) {
selected ? this.selectPath(target, d, i) : this.unselectPath(target, d, i);
};
c3_chart_internal_fn.getToggle = function (that, d) {
var $$ = this, toggle;
if (that.nodeName === 'circle') {
if ($$.isStepType(d)) {
// circle is hidden in step chart, so treat as within the click area
toggle = function () {}; // TODO: how to select step chart?
} else {
toggle = $$.togglePoint;
}
}
else if (that.nodeName === 'path') {
toggle = $$.togglePath;
}
return toggle;
};
c3_chart_internal_fn.toggleShape = function (that, d, i) {
var $$ = this, d3 = $$.d3, config = $$.config,
shape = d3.select(that), isSelected = shape.classed(CLASS.SELECTED),
toggle = $$.getToggle(that, d).bind($$);
if (config.data_selection_enabled && config.data_selection_isselectable(d)) {
if (!config.data_selection_multiple) {
$$.main.selectAll('.' + CLASS.shapes + (config.data_selection_grouped ? $$.getTargetSelectorSuffix(d.id) : "")).selectAll('.' + CLASS.shape).each(function (d, i) {
var shape = d3.select(this);
if (shape.classed(CLASS.SELECTED)) { toggle(false, shape.classed(CLASS.SELECTED, false), d, i); }
});
}
shape.classed(CLASS.SELECTED, !isSelected);
toggle(!isSelected, shape, d, i);
}
};
c3_chart_internal_fn.initBrush = function () {
var $$ = this, d3 = $$.d3;
$$.brush = d3.svg.brush().on("brush", function () { $$.redrawForBrush(); });
$$.brush.update = function () {
if ($$.context) { $$.context.select('.' + CLASS.brush).call(this); }
return this;
};
$$.brush.scale = function (scale) {
return $$.config.axis_rotated ? this.y(scale) : this.x(scale);
};
};
c3_chart_internal_fn.initSubchart = function () {
var $$ = this, config = $$.config,
context = $$.context = $$.svg.append("g").attr("transform", $$.getTranslate('context')),
visibility = config.subchart_show ? 'visible' : 'hidden';
context.style('visibility', visibility);
// Define g for chart area
context.append('g')
.attr("clip-path", $$.clipPathForSubchart)
.attr('class', CLASS.chart);
// Define g for bar chart area
context.select('.' + CLASS.chart).append("g")
.attr("class", CLASS.chartBars);
// Define g for line chart area
context.select('.' + CLASS.chart).append("g")
.attr("class", CLASS.chartLines);
// Add extent rect for Brush
context.append("g")
.attr("clip-path", $$.clipPath)
.attr("class", CLASS.brush)
.call($$.brush);
// ATTENTION: This must be called AFTER chart added
// Add Axis
$$.axes.subx = context.append("g")
.attr("class", CLASS.axisX)
.attr("transform", $$.getTranslate('subx'))
.attr("clip-path", config.axis_rotated ? "" : $$.clipPathForXAxis)
.style("visibility", config.subchart_axis_x_show ? visibility : 'hidden');
};
c3_chart_internal_fn.updateTargetsForSubchart = function (targets) {
var $$ = this, context = $$.context, config = $$.config,
contextLineEnter, contextLineUpdate, contextBarEnter, contextBarUpdate,
classChartBar = $$.classChartBar.bind($$),
classBars = $$.classBars.bind($$),
classChartLine = $$.classChartLine.bind($$),
classLines = $$.classLines.bind($$),
classAreas = $$.classAreas.bind($$);
if (config.subchart_show) {
//-- Bar --//
contextBarUpdate = context.select('.' + CLASS.chartBars).selectAll('.' + CLASS.chartBar)
.data(targets)
.attr('class', classChartBar);
contextBarEnter = contextBarUpdate.enter().append('g')
.style('opacity', 0)
.attr('class', classChartBar);
// Bars for each data
contextBarEnter.append('g')
.attr("class", classBars);
//-- Line --//
contextLineUpdate = context.select('.' + CLASS.chartLines).selectAll('.' + CLASS.chartLine)
.data(targets)
.attr('class', classChartLine);
contextLineEnter = contextLineUpdate.enter().append('g')
.style('opacity', 0)
.attr('class', classChartLine);
// Lines for each data
contextLineEnter.append("g")
.attr("class", classLines);
// Area
contextLineEnter.append("g")
.attr("class", classAreas);
//-- Brush --//
context.selectAll('.' + CLASS.brush + ' rect')
.attr(config.axis_rotated ? "width" : "height", config.axis_rotated ? $$.width2 : $$.height2);
}
};
c3_chart_internal_fn.updateBarForSubchart = function (durationForExit) {
var $$ = this;
$$.contextBar = $$.context.selectAll('.' + CLASS.bars).selectAll('.' + CLASS.bar)
.data($$.barData.bind($$));
$$.contextBar.enter().append('path')
.attr("class", $$.classBar.bind($$))
.style("stroke", 'none')
.style("fill", $$.color);
$$.contextBar
.style("opacity", $$.initialOpacity.bind($$));
$$.contextBar.exit().transition().duration(durationForExit)
.style('opacity', 0)
.remove();
};
c3_chart_internal_fn.redrawBarForSubchart = function (drawBarOnSub, withTransition, duration) {
(withTransition ? this.contextBar.transition(Math.random().toString()).duration(duration) : this.contextBar)
.attr('d', drawBarOnSub)
.style('opacity', 1);
};
c3_chart_internal_fn.updateLineForSubchart = function (durationForExit) {
var $$ = this;
$$.contextLine = $$.context.selectAll('.' + CLASS.lines).selectAll('.' + CLASS.line)
.data($$.lineData.bind($$));
$$.contextLine.enter().append('path')
.attr('class', $$.classLine.bind($$))
.style('stroke', $$.color);
$$.contextLine
.style("opacity", $$.initialOpacity.bind($$));
$$.contextLine.exit().transition().duration(durationForExit)
.style('opacity', 0)
.remove();
};
c3_chart_internal_fn.redrawLineForSubchart = function (drawLineOnSub, withTransition, duration) {
(withTransition ? this.contextLine.transition(Math.random().toString()).duration(duration) : this.contextLine)
.attr("d", drawLineOnSub)
.style('opacity', 1);
};
c3_chart_internal_fn.updateAreaForSubchart = function (durationForExit) {
var $$ = this, d3 = $$.d3;
$$.contextArea = $$.context.selectAll('.' + CLASS.areas).selectAll('.' + CLASS.area)
.data($$.lineData.bind($$));
$$.contextArea.enter().append('path')
.attr("class", $$.classArea.bind($$))
.style("fill", $$.color)
.style("opacity", function () { $$.orgAreaOpacity = +d3.select(this).style('opacity'); return 0; });
$$.contextArea
.style("opacity", 0);
$$.contextArea.exit().transition().duration(durationForExit)
.style('opacity', 0)
.remove();
};
c3_chart_internal_fn.redrawAreaForSubchart = function (drawAreaOnSub, withTransition, duration) {
(withTransition ? this.contextArea.transition(Math.random().toString()).duration(duration) : this.contextArea)
.attr("d", drawAreaOnSub)
.style("fill", this.color)
.style("opacity", this.orgAreaOpacity);
};
c3_chart_internal_fn.redrawSubchart = function (withSubchart, transitions, duration, durationForExit, areaIndices, barIndices, lineIndices) {
var $$ = this, d3 = $$.d3, config = $$.config,
drawAreaOnSub, drawBarOnSub, drawLineOnSub;
$$.context.style('visibility', config.subchart_show ? 'visible' : 'hidden');
// subchart
if (config.subchart_show) {
// reflect main chart to extent on subchart if zoomed
if (d3.event && d3.event.type === 'zoom') {
$$.brush.extent($$.x.orgDomain()).update();
}
// update subchart elements if needed
if (withSubchart) {
// extent rect
if (!$$.brush.empty()) {
$$.brush.extent($$.x.orgDomain()).update();
}
// setup drawer - MEMO: this must be called after axis updated
drawAreaOnSub = $$.generateDrawArea(areaIndices, true);
drawBarOnSub = $$.generateDrawBar(barIndices, true);
drawLineOnSub = $$.generateDrawLine(lineIndices, true);
$$.updateBarForSubchart(duration);
$$.updateLineForSubchart(duration);
$$.updateAreaForSubchart(duration);
$$.redrawBarForSubchart(drawBarOnSub, duration, duration);
$$.redrawLineForSubchart(drawLineOnSub, duration, duration);
$$.redrawAreaForSubchart(drawAreaOnSub, duration, duration);
}
}
};
c3_chart_internal_fn.redrawForBrush = function () {
var $$ = this, x = $$.x;
$$.redraw({
withTransition: false,
withY: $$.config.zoom_rescale,
withSubchart: false,
withUpdateXDomain: true,
withDimension: false
});
$$.config.subchart_onbrush.call($$.api, x.orgDomain());
};
c3_chart_internal_fn.transformContext = function (withTransition, transitions) {
var $$ = this, subXAxis;
if (transitions && transitions.axisSubX) {
subXAxis = transitions.axisSubX;
} else {
subXAxis = $$.context.select('.' + CLASS.axisX);
if (withTransition) { subXAxis = subXAxis.transition(); }
}
$$.context.attr("transform", $$.getTranslate('context'));
subXAxis.attr("transform", $$.getTranslate('subx'));
};
c3_chart_internal_fn.getDefaultExtent = function () {
var $$ = this, config = $$.config,
extent = isFunction(config.axis_x_extent) ? config.axis_x_extent($$.getXDomain($$.data.targets)) : config.axis_x_extent;
if ($$.isTimeSeries()) {
extent = [$$.parseDate(extent[0]), $$.parseDate(extent[1])];
}
return extent;
};
c3_chart_internal_fn.initZoom = function () {
var $$ = this, d3 = $$.d3, config = $$.config, startEvent;
$$.zoom = d3.behavior.zoom()
.on("zoomstart", function () {
startEvent = d3.event.sourceEvent;
$$.zoom.altDomain = d3.event.sourceEvent.altKey ? $$.x.orgDomain() : null;
config.zoom_onzoomstart.call($$.api, d3.event.sourceEvent);
})
.on("zoom", function () {
$$.redrawForZoom.call($$);
})
.on('zoomend', function () {
var event = d3.event.sourceEvent;
// if click, do nothing. otherwise, click interaction will be canceled.
if (event && startEvent.clientX === event.clientX && startEvent.clientY === event.clientY) {
return;
}
$$.redrawEventRect();
$$.updateZoom();
config.zoom_onzoomend.call($$.api, $$.x.orgDomain());
});
$$.zoom.scale = function (scale) {
return config.axis_rotated ? this.y(scale) : this.x(scale);
};
$$.zoom.orgScaleExtent = function () {
var extent = config.zoom_extent ? config.zoom_extent : [1, 10];
return [extent[0], Math.max($$.getMaxDataCount() / extent[1], extent[1])];
};
$$.zoom.updateScaleExtent = function () {
var ratio = diffDomain($$.x.orgDomain()) / diffDomain($$.getZoomDomain()),
extent = this.orgScaleExtent();
this.scaleExtent([extent[0] * ratio, extent[1] * ratio]);
return this;
};
};
c3_chart_internal_fn.getZoomDomain = function () {
var $$ = this, config = $$.config, d3 = $$.d3,
min = d3.min([$$.orgXDomain[0], config.zoom_x_min]),
max = d3.max([$$.orgXDomain[1], config.zoom_x_max]);
return [min, max];
};
c3_chart_internal_fn.updateZoom = function () {
var $$ = this, z = $$.config.zoom_enabled ? $$.zoom : function () {};
$$.main.select('.' + CLASS.zoomRect).call(z).on("dblclick.zoom", null);
$$.main.selectAll('.' + CLASS.eventRect).call(z).on("dblclick.zoom", null);
};
c3_chart_internal_fn.redrawForZoom = function () {
var $$ = this, d3 = $$.d3, config = $$.config, zoom = $$.zoom, x = $$.x;
if (!config.zoom_enabled) {
return;
}
if ($$.filterTargetsToShow($$.data.targets).length === 0) {
return;
}
if (d3.event.sourceEvent.type === 'mousemove' && zoom.altDomain) {
x.domain(zoom.altDomain);
zoom.scale(x).updateScaleExtent();
return;
}
if ($$.isCategorized() && x.orgDomain()[0] === $$.orgXDomain[0]) {
x.domain([$$.orgXDomain[0] - 1e-10, x.orgDomain()[1]]);
}
$$.redraw({
withTransition: false,
withY: config.zoom_rescale,
withSubchart: false,
withEventRect: false,
withDimension: false
});
if (d3.event.sourceEvent.type === 'mousemove') {
$$.cancelClick = true;
}
config.zoom_onzoom.call($$.api, x.orgDomain());
};
c3_chart_internal_fn.generateColor = function () {
var $$ = this, config = $$.config, d3 = $$.d3,
colors = config.data_colors,
pattern = notEmpty(config.color_pattern) ? config.color_pattern : d3.scale.category10().range(),
callback = config.data_color,
ids = [];
return function (d) {
var id = d.id || (d.data && d.data.id) || d, color;
// if callback function is provided
if (colors[id] instanceof Function) {
color = colors[id](d);
}
// if specified, choose that color
else if (colors[id]) {
color = colors[id];
}
// if not specified, choose from pattern
else {
if (ids.indexOf(id) < 0) { ids.push(id); }
color = pattern[ids.indexOf(id) % pattern.length];
colors[id] = color;
}
return callback instanceof Function ? callback(color, d) : color;
};
};
c3_chart_internal_fn.generateLevelColor = function () {
var $$ = this, config = $$.config,
colors = config.color_pattern,
threshold = config.color_threshold,
asValue = threshold.unit === 'value',
values = threshold.values && threshold.values.length ? threshold.values : [],
max = threshold.max || 100;
return notEmpty(config.color_threshold) ? function (value) {
var i, v, color = colors[colors.length - 1];
for (i = 0; i < values.length; i++) {
v = asValue ? value : (value * 100 / max);
if (v < values[i]) {
color = colors[i];
break;
}
}
return color;
} : null;
};
c3_chart_internal_fn.getYFormat = function (forArc) {
var $$ = this,
formatForY = forArc && !$$.hasType('gauge') ? $$.defaultArcValueFormat : $$.yFormat,
formatForY2 = forArc && !$$.hasType('gauge') ? $$.defaultArcValueFormat : $$.y2Format;
return function (v, ratio, id) {
var format = $$.axis.getId(id) === 'y2' ? formatForY2 : formatForY;
return format.call($$, v, ratio);
};
};
c3_chart_internal_fn.yFormat = function (v) {
var $$ = this, config = $$.config,
format = config.axis_y_tick_format ? config.axis_y_tick_format : $$.defaultValueFormat;
return format(v);
};
c3_chart_internal_fn.y2Format = function (v) {
var $$ = this, config = $$.config,
format = config.axis_y2_tick_format ? config.axis_y2_tick_format : $$.defaultValueFormat;
return format(v);
};
c3_chart_internal_fn.defaultValueFormat = function (v) {
return isValue(v) ? +v : "";
};
c3_chart_internal_fn.defaultArcValueFormat = function (v, ratio) {
return (ratio * 100).toFixed(1) + '%';
};
c3_chart_internal_fn.dataLabelFormat = function (targetId) {
var $$ = this, data_labels = $$.config.data_labels,
format, defaultFormat = function (v) { return isValue(v) ? +v : ""; };
// find format according to axis id
if (typeof data_labels.format === 'function') {
format = data_labels.format;
} else if (typeof data_labels.format === 'object') {
if (data_labels.format[targetId]) {
format = data_labels.format[targetId] === true ? defaultFormat : data_labels.format[targetId];
} else {
format = function () { return ''; };
}
} else {
format = defaultFormat;
}
return format;
};
c3_chart_internal_fn.hasCaches = function (ids) {
for (var i = 0; i < ids.length; i++) {
if (! (ids[i] in this.cache)) { return false; }
}
return true;
};
c3_chart_internal_fn.addCache = function (id, target) {
this.cache[id] = this.cloneTarget(target);
};
c3_chart_internal_fn.getCaches = function (ids) {
var targets = [], i;
for (i = 0; i < ids.length; i++) {
if (ids[i] in this.cache) { targets.push(this.cloneTarget(this.cache[ids[i]])); }
}
return targets;
};
var CLASS = c3_chart_internal_fn.CLASS = {
target: 'c3-target',
chart: 'c3-chart',
chartLine: 'c3-chart-line',
chartLines: 'c3-chart-lines',
chartBar: 'c3-chart-bar',
chartBars: 'c3-chart-bars',
chartText: 'c3-chart-text',
chartTexts: 'c3-chart-texts',
chartArc: 'c3-chart-arc',
chartArcs: 'c3-chart-arcs',
chartArcsTitle: 'c3-chart-arcs-title',
chartArcsBackground: 'c3-chart-arcs-background',
chartArcsGaugeUnit: 'c3-chart-arcs-gauge-unit',
chartArcsGaugeMax: 'c3-chart-arcs-gauge-max',
chartArcsGaugeMin: 'c3-chart-arcs-gauge-min',
selectedCircle: 'c3-selected-circle',
selectedCircles: 'c3-selected-circles',
eventRect: 'c3-event-rect',
eventRects: 'c3-event-rects',
eventRectsSingle: 'c3-event-rects-single',
eventRectsMultiple: 'c3-event-rects-multiple',
zoomRect: 'c3-zoom-rect',
brush: 'c3-brush',
focused: 'c3-focused',
defocused: 'c3-defocused',
region: 'c3-region',
regions: 'c3-regions',
title: 'c3-title',
tooltipContainer: 'c3-tooltip-container',
tooltip: 'c3-tooltip',
tooltipName: 'c3-tooltip-name',
shape: 'c3-shape',
shapes: 'c3-shapes',
line: 'c3-line',
lines: 'c3-lines',
bar: 'c3-bar',
bars: 'c3-bars',
circle: 'c3-circle',
circles: 'c3-circles',
arc: 'c3-arc',
arcs: 'c3-arcs',
area: 'c3-area',
areas: 'c3-areas',
empty: 'c3-empty',
text: 'c3-text',
texts: 'c3-texts',
gaugeValue: 'c3-gauge-value',
grid: 'c3-grid',
gridLines: 'c3-grid-lines',
xgrid: 'c3-xgrid',
xgrids: 'c3-xgrids',
xgridLine: 'c3-xgrid-line',
xgridLines: 'c3-xgrid-lines',
xgridFocus: 'c3-xgrid-focus',
ygrid: 'c3-ygrid',
ygrids: 'c3-ygrids',
ygridLine: 'c3-ygrid-line',
ygridLines: 'c3-ygrid-lines',
axis: 'c3-axis',
axisX: 'c3-axis-x',
axisXLabel: 'c3-axis-x-label',
axisY: 'c3-axis-y',
axisYLabel: 'c3-axis-y-label',
axisY2: 'c3-axis-y2',
axisY2Label: 'c3-axis-y2-label',
legendBackground: 'c3-legend-background',
legendItem: 'c3-legend-item',
legendItemEvent: 'c3-legend-item-event',
legendItemTile: 'c3-legend-item-tile',
legendItemHidden: 'c3-legend-item-hidden',
legendItemFocused: 'c3-legend-item-focused',
dragarea: 'c3-dragarea',
EXPANDED: '_expanded_',
SELECTED: '_selected_',
INCLUDED: '_included_'
};
c3_chart_internal_fn.generateClass = function (prefix, targetId) {
return " " + prefix + " " + prefix + this.getTargetSelectorSuffix(targetId);
};
c3_chart_internal_fn.classText = function (d) {
return this.generateClass(CLASS.text, d.index);
};
c3_chart_internal_fn.classTexts = function (d) {
return this.generateClass(CLASS.texts, d.id);
};
c3_chart_internal_fn.classShape = function (d) {
return this.generateClass(CLASS.shape, d.index);
};
c3_chart_internal_fn.classShapes = function (d) {
return this.generateClass(CLASS.shapes, d.id);
};
c3_chart_internal_fn.classLine = function (d) {
return this.classShape(d) + this.generateClass(CLASS.line, d.id);
};
c3_chart_internal_fn.classLines = function (d) {
return this.classShapes(d) + this.generateClass(CLASS.lines, d.id);
};
c3_chart_internal_fn.classCircle = function (d) {
return this.classShape(d) + this.generateClass(CLASS.circle, d.index);
};
c3_chart_internal_fn.classCircles = function (d) {
return this.classShapes(d) + this.generateClass(CLASS.circles, d.id);
};
c3_chart_internal_fn.classBar = function (d) {
return this.classShape(d) + this.generateClass(CLASS.bar, d.index);
};
c3_chart_internal_fn.classBars = function (d) {
return this.classShapes(d) + this.generateClass(CLASS.bars, d.id);
};
c3_chart_internal_fn.classArc = function (d) {
return this.classShape(d.data) + this.generateClass(CLASS.arc, d.data.id);
};
c3_chart_internal_fn.classArcs = function (d) {
return this.classShapes(d.data) + this.generateClass(CLASS.arcs, d.data.id);
};
c3_chart_internal_fn.classArea = function (d) {
return this.classShape(d) + this.generateClass(CLASS.area, d.id);
};
c3_chart_internal_fn.classAreas = function (d) {
return this.classShapes(d) + this.generateClass(CLASS.areas, d.id);
};
c3_chart_internal_fn.classRegion = function (d, i) {
return this.generateClass(CLASS.region, i) + ' ' + ('class' in d ? d['class'] : '');
};
c3_chart_internal_fn.classEvent = function (d) {
return this.generateClass(CLASS.eventRect, d.index);
};
c3_chart_internal_fn.classTarget = function (id) {
var $$ = this;
var additionalClassSuffix = $$.config.data_classes[id], additionalClass = '';
if (additionalClassSuffix) {
additionalClass = ' ' + CLASS.target + '-' + additionalClassSuffix;
}
return $$.generateClass(CLASS.target, id) + additionalClass;
};
c3_chart_internal_fn.classFocus = function (d) {
return this.classFocused(d) + this.classDefocused(d);
};
c3_chart_internal_fn.classFocused = function (d) {
return ' ' + (this.focusedTargetIds.indexOf(d.id) >= 0 ? CLASS.focused : '');
};
c3_chart_internal_fn.classDefocused = function (d) {
return ' ' + (this.defocusedTargetIds.indexOf(d.id) >= 0 ? CLASS.defocused : '');
};
c3_chart_internal_fn.classChartText = function (d) {
return CLASS.chartText + this.classTarget(d.id);
};
c3_chart_internal_fn.classChartLine = function (d) {
return CLASS.chartLine + this.classTarget(d.id);
};
c3_chart_internal_fn.classChartBar = function (d) {
return CLASS.chartBar + this.classTarget(d.id);
};
c3_chart_internal_fn.classChartArc = function (d) {
return CLASS.chartArc + this.classTarget(d.data.id);
};
c3_chart_internal_fn.getTargetSelectorSuffix = function (targetId) {
return targetId || targetId === 0 ? ('-' + targetId).replace(/[\s?!@#$%^&*()_=+,.<>'":;\[\]\/|~`{}\\]/g, '-') : '';
};
c3_chart_internal_fn.selectorTarget = function (id, prefix) {
return (prefix || '') + '.' + CLASS.target + this.getTargetSelectorSuffix(id);
};
c3_chart_internal_fn.selectorTargets = function (ids, prefix) {
var $$ = this;
ids = ids || [];
return ids.length ? ids.map(function (id) { return $$.selectorTarget(id, prefix); }) : null;
};
c3_chart_internal_fn.selectorLegend = function (id) {
return '.' + CLASS.legendItem + this.getTargetSelectorSuffix(id);
};
c3_chart_internal_fn.selectorLegends = function (ids) {
var $$ = this;
return ids && ids.length ? ids.map(function (id) { return $$.selectorLegend(id); }) : null;
};
var isValue = c3_chart_internal_fn.isValue = function (v) {
return v || v === 0;
},
isFunction = c3_chart_internal_fn.isFunction = function (o) {
return typeof o === 'function';
},
isString = c3_chart_internal_fn.isString = function (o) {
return typeof o === 'string';
},
isUndefined = c3_chart_internal_fn.isUndefined = function (v) {
return typeof v === 'undefined';
},
isDefined = c3_chart_internal_fn.isDefined = function (v) {
return typeof v !== 'undefined';
},
ceil10 = c3_chart_internal_fn.ceil10 = function (v) {
return Math.ceil(v / 10) * 10;
},
asHalfPixel = c3_chart_internal_fn.asHalfPixel = function (n) {
return Math.ceil(n) + 0.5;
},
diffDomain = c3_chart_internal_fn.diffDomain = function (d) {
return d[1] - d[0];
},
isEmpty = c3_chart_internal_fn.isEmpty = function (o) {
return typeof o === 'undefined' || o === null || (isString(o) && o.length === 0) || (typeof o === 'object' && Object.keys(o).length === 0);
},
notEmpty = c3_chart_internal_fn.notEmpty = function (o) {
return !c3_chart_internal_fn.isEmpty(o);
},
getOption = c3_chart_internal_fn.getOption = function (options, key, defaultValue) {
return isDefined(options[key]) ? options[key] : defaultValue;
},
hasValue = c3_chart_internal_fn.hasValue = function (dict, value) {
var found = false;
Object.keys(dict).forEach(function (key) {
if (dict[key] === value) { found = true; }
});
return found;
},
sanitise = c3_chart_internal_fn.sanitise = function (str) {
return typeof str === 'string' ? str.replace(/</g, '<').replace(/>/g, '>') : str;
},
getPathBox = c3_chart_internal_fn.getPathBox = function (path) {
var box = path.getBoundingClientRect(),
items = [path.pathSegList.getItem(0), path.pathSegList.getItem(1)],
minX = items[0].x, minY = Math.min(items[0].y, items[1].y);
return {x: minX, y: minY, width: box.width, height: box.height};
};
c3_chart_fn.focus = function (targetIds) {
var $$ = this.internal, candidates;
targetIds = $$.mapToTargetIds(targetIds);
candidates = $$.svg.selectAll($$.selectorTargets(targetIds.filter($$.isTargetToShow, $$))),
this.revert();
this.defocus();
candidates.classed(CLASS.focused, true).classed(CLASS.defocused, false);
if ($$.hasArcType()) {
$$.expandArc(targetIds);
}
$$.toggleFocusLegend(targetIds, true);
$$.focusedTargetIds = targetIds;
$$.defocusedTargetIds = $$.defocusedTargetIds.filter(function (id) {
return targetIds.indexOf(id) < 0;
});
};
c3_chart_fn.defocus = function (targetIds) {
var $$ = this.internal, candidates;
targetIds = $$.mapToTargetIds(targetIds);
candidates = $$.svg.selectAll($$.selectorTargets(targetIds.filter($$.isTargetToShow, $$))),
candidates.classed(CLASS.focused, false).classed(CLASS.defocused, true);
if ($$.hasArcType()) {
$$.unexpandArc(targetIds);
}
$$.toggleFocusLegend(targetIds, false);
$$.focusedTargetIds = $$.focusedTargetIds.filter(function (id) {
return targetIds.indexOf(id) < 0;
});
$$.defocusedTargetIds = targetIds;
};
c3_chart_fn.revert = function (targetIds) {
var $$ = this.internal, candidates;
targetIds = $$.mapToTargetIds(targetIds);
candidates = $$.svg.selectAll($$.selectorTargets(targetIds)); // should be for all targets
candidates.classed(CLASS.focused, false).classed(CLASS.defocused, false);
if ($$.hasArcType()) {
$$.unexpandArc(targetIds);
}
if ($$.config.legend_show) {
$$.showLegend(targetIds.filter($$.isLegendToShow.bind($$)));
$$.legend.selectAll($$.selectorLegends(targetIds))
.filter(function () {
return $$.d3.select(this).classed(CLASS.legendItemFocused);
})
.classed(CLASS.legendItemFocused, false);
}
$$.focusedTargetIds = [];
$$.defocusedTargetIds = [];
};
c3_chart_fn.show = function (targetIds, options) {
var $$ = this.internal, targets;
targetIds = $$.mapToTargetIds(targetIds);
options = options || {};
$$.removeHiddenTargetIds(targetIds);
targets = $$.svg.selectAll($$.selectorTargets(targetIds));
targets.transition()
.style('opacity', 1, 'important')
.call($$.endall, function () {
targets.style('opacity', null).style('opacity', 1);
});
if (options.withLegend) {
$$.showLegend(targetIds);
}
$$.redraw({withUpdateOrgXDomain: true, withUpdateXDomain: true, withLegend: true});
};
c3_chart_fn.hide = function (targetIds, options) {
var $$ = this.internal, targets;
targetIds = $$.mapToTargetIds(targetIds);
options = options || {};
$$.addHiddenTargetIds(targetIds);
targets = $$.svg.selectAll($$.selectorTargets(targetIds));
targets.transition()
.style('opacity', 0, 'important')
.call($$.endall, function () {
targets.style('opacity', null).style('opacity', 0);
});
if (options.withLegend) {
$$.hideLegend(targetIds);
}
$$.redraw({withUpdateOrgXDomain: true, withUpdateXDomain: true, withLegend: true});
};
c3_chart_fn.toggle = function (targetIds, options) {
var that = this, $$ = this.internal;
$$.mapToTargetIds(targetIds).forEach(function (targetId) {
$$.isTargetToShow(targetId) ? that.hide(targetId, options) : that.show(targetId, options);
});
};
c3_chart_fn.zoom = function (domain) {
var $$ = this.internal;
if (domain) {
if ($$.isTimeSeries()) {
domain = domain.map(function (x) { return $$.parseDate(x); });
}
$$.brush.extent(domain);
$$.redraw({withUpdateXDomain: true, withY: $$.config.zoom_rescale});
$$.config.zoom_onzoom.call(this, $$.x.orgDomain());
}
return $$.brush.extent();
};
c3_chart_fn.zoom.enable = function (enabled) {
var $$ = this.internal;
$$.config.zoom_enabled = enabled;
$$.updateAndRedraw();
};
c3_chart_fn.unzoom = function () {
var $$ = this.internal;
$$.brush.clear().update();
$$.redraw({withUpdateXDomain: true});
};
c3_chart_fn.zoom.max = function (max) {
var $$ = this.internal, config = $$.config, d3 = $$.d3;
if (max === 0 || max) {
config.zoom_x_max = d3.max([$$.orgXDomain[1], max]);
}
else {
return config.zoom_x_max;
}
};
c3_chart_fn.zoom.min = function (min) {
var $$ = this.internal, config = $$.config, d3 = $$.d3;
if (min === 0 || min) {
config.zoom_x_min = d3.min([$$.orgXDomain[0], min]);
}
else {
return config.zoom_x_min;
}
};
c3_chart_fn.zoom.range = function (range) {
if (arguments.length) {
if (isDefined(range.max)) { this.domain.max(range.max); }
if (isDefined(range.min)) { this.domain.min(range.min); }
} else {
return {
max: this.domain.max(),
min: this.domain.min()
};
}
};
c3_chart_fn.load = function (args) {
var $$ = this.internal, config = $$.config;
// update xs if specified
if (args.xs) {
$$.addXs(args.xs);
}
// update names if exists
if ('names' in args) {
c3_chart_fn.data.names.bind(this)(args.names);
}
// update classes if exists
if ('classes' in args) {
Object.keys(args.classes).forEach(function (id) {
config.data_classes[id] = args.classes[id];
});
}
// update categories if exists
if ('categories' in args && $$.isCategorized()) {
config.axis_x_categories = args.categories;
}
// update axes if exists
if ('axes' in args) {
Object.keys(args.axes).forEach(function (id) {
config.data_axes[id] = args.axes[id];
});
}
// update colors if exists
if ('colors' in args) {
Object.keys(args.colors).forEach(function (id) {
config.data_colors[id] = args.colors[id];
});
}
// use cache if exists
if ('cacheIds' in args && $$.hasCaches(args.cacheIds)) {
$$.load($$.getCaches(args.cacheIds), args.done);
return;
}
// unload if needed
if ('unload' in args) {
// TODO: do not unload if target will load (included in url/rows/columns)
$$.unload($$.mapToTargetIds((typeof args.unload === 'boolean' && args.unload) ? null : args.unload), function () {
$$.loadFromArgs(args);
});
} else {
$$.loadFromArgs(args);
}
};
c3_chart_fn.unload = function (args) {
var $$ = this.internal;
args = args || {};
if (args instanceof Array) {
args = {ids: args};
} else if (typeof args === 'string') {
args = {ids: [args]};
}
$$.unload($$.mapToTargetIds(args.ids), function () {
$$.redraw({withUpdateOrgXDomain: true, withUpdateXDomain: true, withLegend: true});
if (args.done) { args.done(); }
});
};
c3_chart_fn.flow = function (args) {
var $$ = this.internal,
targets, data, notfoundIds = [], orgDataCount = $$.getMaxDataCount(),
dataCount, domain, baseTarget, baseValue, length = 0, tail = 0, diff, to;
if (args.json) {
data = $$.convertJsonToData(args.json, args.keys);
}
else if (args.rows) {
data = $$.convertRowsToData(args.rows);
}
else if (args.columns) {
data = $$.convertColumnsToData(args.columns);
}
else {
return;
}
targets = $$.convertDataToTargets(data, true);
// Update/Add data
$$.data.targets.forEach(function (t) {
var found = false, i, j;
for (i = 0; i < targets.length; i++) {
if (t.id === targets[i].id) {
found = true;
if (t.values[t.values.length - 1]) {
tail = t.values[t.values.length - 1].index + 1;
}
length = targets[i].values.length;
for (j = 0; j < length; j++) {
targets[i].values[j].index = tail + j;
if (!$$.isTimeSeries()) {
targets[i].values[j].x = tail + j;
}
}
t.values = t.values.concat(targets[i].values);
targets.splice(i, 1);
break;
}
}
if (!found) { notfoundIds.push(t.id); }
});
// Append null for not found targets
$$.data.targets.forEach(function (t) {
var i, j;
for (i = 0; i < notfoundIds.length; i++) {
if (t.id === notfoundIds[i]) {
tail = t.values[t.values.length - 1].index + 1;
for (j = 0; j < length; j++) {
t.values.push({
id: t.id,
index: tail + j,
x: $$.isTimeSeries() ? $$.getOtherTargetX(tail + j) : tail + j,
value: null
});
}
}
}
});
// Generate null values for new target
if ($$.data.targets.length) {
targets.forEach(function (t) {
var i, missing = [];
for (i = $$.data.targets[0].values[0].index; i < tail; i++) {
missing.push({
id: t.id,
index: i,
x: $$.isTimeSeries() ? $$.getOtherTargetX(i) : i,
value: null
});
}
t.values.forEach(function (v) {
v.index += tail;
if (!$$.isTimeSeries()) {
v.x += tail;
}
});
t.values = missing.concat(t.values);
});
}
$$.data.targets = $$.data.targets.concat(targets); // add remained
// check data count because behavior needs to change when it's only one
dataCount = $$.getMaxDataCount();
baseTarget = $$.data.targets[0];
baseValue = baseTarget.values[0];
// Update length to flow if needed
if (isDefined(args.to)) {
length = 0;
to = $$.isTimeSeries() ? $$.parseDate(args.to) : args.to;
baseTarget.values.forEach(function (v) {
if (v.x < to) { length++; }
});
} else if (isDefined(args.length)) {
length = args.length;
}
// If only one data, update the domain to flow from left edge of the chart
if (!orgDataCount) {
if ($$.isTimeSeries()) {
if (baseTarget.values.length > 1) {
diff = baseTarget.values[baseTarget.values.length - 1].x - baseValue.x;
} else {
diff = baseValue.x - $$.getXDomain($$.data.targets)[0];
}
} else {
diff = 1;
}
domain = [baseValue.x - diff, baseValue.x];
$$.updateXDomain(null, true, true, false, domain);
} else if (orgDataCount === 1) {
if ($$.isTimeSeries()) {
diff = (baseTarget.values[baseTarget.values.length - 1].x - baseValue.x) / 2;
domain = [new Date(+baseValue.x - diff), new Date(+baseValue.x + diff)];
$$.updateXDomain(null, true, true, false, domain);
}
}
// Set targets
$$.updateTargets($$.data.targets);
// Redraw with new targets
$$.redraw({
flow: {
index: baseValue.index,
length: length,
duration: isValue(args.duration) ? args.duration : $$.config.transition_duration,
done: args.done,
orgDataCount: orgDataCount,
},
withLegend: true,
withTransition: orgDataCount > 1,
withTrimXDomain: false,
withUpdateXAxis: true,
});
};
c3_chart_internal_fn.generateFlow = function (args) {
var $$ = this, config = $$.config, d3 = $$.d3;
return function () {
var targets = args.targets,
flow = args.flow,
drawBar = args.drawBar,
drawLine = args.drawLine,
drawArea = args.drawArea,
cx = args.cx,
cy = args.cy,
xv = args.xv,
xForText = args.xForText,
yForText = args.yForText,
duration = args.duration;
var translateX, scaleX = 1, transform,
flowIndex = flow.index,
flowLength = flow.length,
flowStart = $$.getValueOnIndex($$.data.targets[0].values, flowIndex),
flowEnd = $$.getValueOnIndex($$.data.targets[0].values, flowIndex + flowLength),
orgDomain = $$.x.domain(), domain,
durationForFlow = flow.duration || duration,
done = flow.done || function () {},
wait = $$.generateWait();
var xgrid = $$.xgrid || d3.selectAll([]),
xgridLines = $$.xgridLines || d3.selectAll([]),
mainRegion = $$.mainRegion || d3.selectAll([]),
mainText = $$.mainText || d3.selectAll([]),
mainBar = $$.mainBar || d3.selectAll([]),
mainLine = $$.mainLine || d3.selectAll([]),
mainArea = $$.mainArea || d3.selectAll([]),
mainCircle = $$.mainCircle || d3.selectAll([]);
// set flag
$$.flowing = true;
// remove head data after rendered
$$.data.targets.forEach(function (d) {
d.values.splice(0, flowLength);
});
// update x domain to generate axis elements for flow
domain = $$.updateXDomain(targets, true, true);
// update elements related to x scale
if ($$.updateXGrid) { $$.updateXGrid(true); }
// generate transform to flow
if (!flow.orgDataCount) { // if empty
if ($$.data.targets[0].values.length !== 1) {
translateX = $$.x(orgDomain[0]) - $$.x(domain[0]);
} else {
if ($$.isTimeSeries()) {
flowStart = $$.getValueOnIndex($$.data.targets[0].values, 0);
flowEnd = $$.getValueOnIndex($$.data.targets[0].values, $$.data.targets[0].values.length - 1);
translateX = $$.x(flowStart.x) - $$.x(flowEnd.x);
} else {
translateX = diffDomain(domain) / 2;
}
}
} else if (flow.orgDataCount === 1 || (flowStart && flowStart.x) === (flowEnd && flowEnd.x)) {
translateX = $$.x(orgDomain[0]) - $$.x(domain[0]);
} else {
if ($$.isTimeSeries()) {
translateX = ($$.x(orgDomain[0]) - $$.x(domain[0]));
} else {
translateX = ($$.x(flowStart.x) - $$.x(flowEnd.x));
}
}
scaleX = (diffDomain(orgDomain) / diffDomain(domain));
transform = 'translate(' + translateX + ',0) scale(' + scaleX + ',1)';
$$.hideXGridFocus();
d3.transition().ease('linear').duration(durationForFlow).each(function () {
wait.add($$.axes.x.transition().call($$.xAxis));
wait.add(mainBar.transition().attr('transform', transform));
wait.add(mainLine.transition().attr('transform', transform));
wait.add(mainArea.transition().attr('transform', transform));
wait.add(mainCircle.transition().attr('transform', transform));
wait.add(mainText.transition().attr('transform', transform));
wait.add(mainRegion.filter($$.isRegionOnX).transition().attr('transform', transform));
wait.add(xgrid.transition().attr('transform', transform));
wait.add(xgridLines.transition().attr('transform', transform));
})
.call(wait, function () {
var i, shapes = [], texts = [], eventRects = [];
// remove flowed elements
if (flowLength) {
for (i = 0; i < flowLength; i++) {
shapes.push('.' + CLASS.shape + '-' + (flowIndex + i));
texts.push('.' + CLASS.text + '-' + (flowIndex + i));
eventRects.push('.' + CLASS.eventRect + '-' + (flowIndex + i));
}
$$.svg.selectAll('.' + CLASS.shapes).selectAll(shapes).remove();
$$.svg.selectAll('.' + CLASS.texts).selectAll(texts).remove();
$$.svg.selectAll('.' + CLASS.eventRects).selectAll(eventRects).remove();
$$.svg.select('.' + CLASS.xgrid).remove();
}
// draw again for removing flowed elements and reverting attr
xgrid
.attr('transform', null)
.attr($$.xgridAttr);
xgridLines
.attr('transform', null);
xgridLines.select('line')
.attr("x1", config.axis_rotated ? 0 : xv)
.attr("x2", config.axis_rotated ? $$.width : xv);
xgridLines.select('text')
.attr("x", config.axis_rotated ? $$.width : 0)
.attr("y", xv);
mainBar
.attr('transform', null)
.attr("d", drawBar);
mainLine
.attr('transform', null)
.attr("d", drawLine);
mainArea
.attr('transform', null)
.attr("d", drawArea);
mainCircle
.attr('transform', null)
.attr("cx", cx)
.attr("cy", cy);
mainText
.attr('transform', null)
.attr('x', xForText)
.attr('y', yForText)
.style('fill-opacity', $$.opacityForText.bind($$));
mainRegion
.attr('transform', null);
mainRegion.select('rect').filter($$.isRegionOnX)
.attr("x", $$.regionX.bind($$))
.attr("width", $$.regionWidth.bind($$));
if (config.interaction_enabled) {
$$.redrawEventRect();
}
// callback for end of flow
done();
$$.flowing = false;
});
};
};
c3_chart_fn.selected = function (targetId) {
var $$ = this.internal, d3 = $$.d3;
return d3.merge(
$$.main.selectAll('.' + CLASS.shapes + $$.getTargetSelectorSuffix(targetId)).selectAll('.' + CLASS.shape)
.filter(function () { return d3.select(this).classed(CLASS.SELECTED); })
.map(function (d) { return d.map(function (d) { var data = d.__data__; return data.data ? data.data : data; }); })
);
};
c3_chart_fn.select = function (ids, indices, resetOther) {
var $$ = this.internal, d3 = $$.d3, config = $$.config;
if (! config.data_selection_enabled) { return; }
$$.main.selectAll('.' + CLASS.shapes).selectAll('.' + CLASS.shape).each(function (d, i) {
var shape = d3.select(this), id = d.data ? d.data.id : d.id,
toggle = $$.getToggle(this, d).bind($$),
isTargetId = config.data_selection_grouped || !ids || ids.indexOf(id) >= 0,
isTargetIndex = !indices || indices.indexOf(i) >= 0,
isSelected = shape.classed(CLASS.SELECTED);
// line/area selection not supported yet
if (shape.classed(CLASS.line) || shape.classed(CLASS.area)) {
return;
}
if (isTargetId && isTargetIndex) {
if (config.data_selection_isselectable(d) && !isSelected) {
toggle(true, shape.classed(CLASS.SELECTED, true), d, i);
}
} else if (isDefined(resetOther) && resetOther) {
if (isSelected) {
toggle(false, shape.classed(CLASS.SELECTED, false), d, i);
}
}
});
};
c3_chart_fn.unselect = function (ids, indices) {
var $$ = this.internal, d3 = $$.d3, config = $$.config;
if (! config.data_selection_enabled) { return; }
$$.main.selectAll('.' + CLASS.shapes).selectAll('.' + CLASS.shape).each(function (d, i) {
var shape = d3.select(this), id = d.data ? d.data.id : d.id,
toggle = $$.getToggle(this, d).bind($$),
isTargetId = config.data_selection_grouped || !ids || ids.indexOf(id) >= 0,
isTargetIndex = !indices || indices.indexOf(i) >= 0,
isSelected = shape.classed(CLASS.SELECTED);
// line/area selection not supported yet
if (shape.classed(CLASS.line) || shape.classed(CLASS.area)) {
return;
}
if (isTargetId && isTargetIndex) {
if (config.data_selection_isselectable(d)) {
if (isSelected) {
toggle(false, shape.classed(CLASS.SELECTED, false), d, i);
}
}
}
});
};
c3_chart_fn.transform = function (type, targetIds) {
var $$ = this.internal,
options = ['pie', 'donut'].indexOf(type) >= 0 ? {withTransform: true} : null;
$$.transformTo(targetIds, type, options);
};
c3_chart_internal_fn.transformTo = function (targetIds, type, optionsForRedraw) {
var $$ = this,
withTransitionForAxis = !$$.hasArcType(),
options = optionsForRedraw || {withTransitionForAxis: withTransitionForAxis};
options.withTransitionForTransform = false;
$$.transiting = false;
$$.setTargetType(targetIds, type);
$$.updateTargets($$.data.targets); // this is needed when transforming to arc
$$.updateAndRedraw(options);
};
c3_chart_fn.groups = function (groups) {
var $$ = this.internal, config = $$.config;
if (isUndefined(groups)) { return config.data_groups; }
config.data_groups = groups;
$$.redraw();
return config.data_groups;
};
c3_chart_fn.xgrids = function (grids) {
var $$ = this.internal, config = $$.config;
if (! grids) { return config.grid_x_lines; }
config.grid_x_lines = grids;
$$.redrawWithoutRescale();
return config.grid_x_lines;
};
c3_chart_fn.xgrids.add = function (grids) {
var $$ = this.internal;
return this.xgrids($$.config.grid_x_lines.concat(grids ? grids : []));
};
c3_chart_fn.xgrids.remove = function (params) { // TODO: multiple
var $$ = this.internal;
$$.removeGridLines(params, true);
};
c3_chart_fn.ygrids = function (grids) {
var $$ = this.internal, config = $$.config;
if (! grids) { return config.grid_y_lines; }
config.grid_y_lines = grids;
$$.redrawWithoutRescale();
return config.grid_y_lines;
};
c3_chart_fn.ygrids.add = function (grids) {
var $$ = this.internal;
return this.ygrids($$.config.grid_y_lines.concat(grids ? grids : []));
};
c3_chart_fn.ygrids.remove = function (params) { // TODO: multiple
var $$ = this.internal;
$$.removeGridLines(params, false);
};
c3_chart_fn.regions = function (regions) {
var $$ = this.internal, config = $$.config;
if (!regions) { return config.regions; }
config.regions = regions;
$$.redrawWithoutRescale();
return config.regions;
};
c3_chart_fn.regions.add = function (regions) {
var $$ = this.internal, config = $$.config;
if (!regions) { return config.regions; }
config.regions = config.regions.concat(regions);
$$.redrawWithoutRescale();
return config.regions;
};
c3_chart_fn.regions.remove = function (options) {
var $$ = this.internal, config = $$.config,
duration, classes, regions;
options = options || {};
duration = $$.getOption(options, "duration", config.transition_duration);
classes = $$.getOption(options, "classes", [CLASS.region]);
regions = $$.main.select('.' + CLASS.regions).selectAll(classes.map(function (c) { return '.' + c; }));
(duration ? regions.transition().duration(duration) : regions)
.style('opacity', 0)
.remove();
config.regions = config.regions.filter(function (region) {
var found = false;
if (!region['class']) {
return true;
}
region['class'].split(' ').forEach(function (c) {
if (classes.indexOf(c) >= 0) { found = true; }
});
return !found;
});
return config.regions;
};
c3_chart_fn.data = function (targetIds) {
var targets = this.internal.data.targets;
return typeof targetIds === 'undefined' ? targets : targets.filter(function (t) {
return [].concat(targetIds).indexOf(t.id) >= 0;
});
};
c3_chart_fn.data.shown = function (targetIds) {
return this.internal.filterTargetsToShow(this.data(targetIds));
};
c3_chart_fn.data.values = function (targetId) {
var targets, values = null;
if (targetId) {
targets = this.data(targetId);
values = targets[0] ? targets[0].values.map(function (d) { return d.value; }) : null;
}
return values;
};
c3_chart_fn.data.names = function (names) {
this.internal.clearLegendItemTextBoxCache();
return this.internal.updateDataAttributes('names', names);
};
c3_chart_fn.data.colors = function (colors) {
return this.internal.updateDataAttributes('colors', colors);
};
c3_chart_fn.data.axes = function (axes) {
return this.internal.updateDataAttributes('axes', axes);
};
c3_chart_fn.category = function (i, category) {
var $$ = this.internal, config = $$.config;
if (arguments.length > 1) {
config.axis_x_categories[i] = category;
$$.redraw();
}
return config.axis_x_categories[i];
};
c3_chart_fn.categories = function (categories) {
var $$ = this.internal, config = $$.config;
if (!arguments.length) { return config.axis_x_categories; }
config.axis_x_categories = categories;
$$.redraw();
return config.axis_x_categories;
};
// TODO: fix
c3_chart_fn.color = function (id) {
var $$ = this.internal;
return $$.color(id); // more patterns
};
c3_chart_fn.x = function (x) {
var $$ = this.internal;
if (arguments.length) {
$$.updateTargetX($$.data.targets, x);
$$.redraw({withUpdateOrgXDomain: true, withUpdateXDomain: true});
}
return $$.data.xs;
};
c3_chart_fn.xs = function (xs) {
var $$ = this.internal;
if (arguments.length) {
$$.updateTargetXs($$.data.targets, xs);
$$.redraw({withUpdateOrgXDomain: true, withUpdateXDomain: true});
}
return $$.data.xs;
};
c3_chart_fn.axis = function () {};
c3_chart_fn.axis.labels = function (labels) {
var $$ = this.internal;
if (arguments.length) {
Object.keys(labels).forEach(function (axisId) {
$$.axis.setLabelText(axisId, labels[axisId]);
});
$$.axis.updateLabels();
}
// TODO: return some values?
};
c3_chart_fn.axis.max = function (max) {
var $$ = this.internal, config = $$.config;
if (arguments.length) {
if (typeof max === 'object') {
if (isValue(max.x)) { config.axis_x_max = max.x; }
if (isValue(max.y)) { config.axis_y_max = max.y; }
if (isValue(max.y2)) { config.axis_y2_max = max.y2; }
} else {
config.axis_y_max = config.axis_y2_max = max;
}
$$.redraw({withUpdateOrgXDomain: true, withUpdateXDomain: true});
} else {
return {
x: config.axis_x_max,
y: config.axis_y_max,
y2: config.axis_y2_max
};
}
};
c3_chart_fn.axis.min = function (min) {
var $$ = this.internal, config = $$.config;
if (arguments.length) {
if (typeof min === 'object') {
if (isValue(min.x)) { config.axis_x_min = min.x; }
if (isValue(min.y)) { config.axis_y_min = min.y; }
if (isValue(min.y2)) { config.axis_y2_min = min.y2; }
} else {
config.axis_y_min = config.axis_y2_min = min;
}
$$.redraw({withUpdateOrgXDomain: true, withUpdateXDomain: true});
} else {
return {
x: config.axis_x_min,
y: config.axis_y_min,
y2: config.axis_y2_min
};
}
};
c3_chart_fn.axis.range = function (range) {
if (arguments.length) {
if (isDefined(range.max)) { this.axis.max(range.max); }
if (isDefined(range.min)) { this.axis.min(range.min); }
} else {
return {
max: this.axis.max(),
min: this.axis.min()
};
}
};
c3_chart_fn.legend = function () {};
c3_chart_fn.legend.show = function (targetIds) {
var $$ = this.internal;
$$.showLegend($$.mapToTargetIds(targetIds));
$$.updateAndRedraw({withLegend: true});
};
c3_chart_fn.legend.hide = function (targetIds) {
var $$ = this.internal;
$$.hideLegend($$.mapToTargetIds(targetIds));
$$.updateAndRedraw({withLegend: true});
};
c3_chart_fn.resize = function (size) {
var $$ = this.internal, config = $$.config;
config.size_width = size ? size.width : null;
config.size_height = size ? size.height : null;
this.flush();
};
c3_chart_fn.flush = function () {
var $$ = this.internal;
$$.updateAndRedraw({withLegend: true, withTransition: false, withTransitionForTransform: false});
};
c3_chart_fn.destroy = function () {
var $$ = this.internal;
window.clearInterval($$.intervalForObserveInserted);
if ($$.resizeTimeout !== undefined) {
window.clearTimeout($$.resizeTimeout);
}
if (window.detachEvent) {
window.detachEvent('onresize', $$.resizeFunction);
} else if (window.removeEventListener) {
window.removeEventListener('resize', $$.resizeFunction);
} else {
var wrapper = window.onresize;
// check if no one else removed our wrapper and remove our resizeFunction from it
if (wrapper && wrapper.add && wrapper.remove) {
wrapper.remove($$.resizeFunction);
}
}
$$.selectChart.classed('c3', false).html("");
// MEMO: this is needed because the reference of some elements will not be released, then memory leak will happen.
Object.keys($$).forEach(function (key) {
$$[key] = null;
});
return null;
};
c3_chart_fn.tooltip = function () {};
c3_chart_fn.tooltip.show = function (args) {
var $$ = this.internal, index, mouse;
// determine mouse position on the chart
if (args.mouse) {
mouse = args.mouse;
}
// determine focus data
if (args.data) {
if ($$.isMultipleX()) {
// if multiple xs, target point will be determined by mouse
mouse = [$$.x(args.data.x), $$.getYScale(args.data.id)(args.data.value)];
index = null;
} else {
// TODO: when tooltip_grouped = false
index = isValue(args.data.index) ? args.data.index : $$.getIndexByX(args.data.x);
}
}
else if (typeof args.x !== 'undefined') {
index = $$.getIndexByX(args.x);
}
else if (typeof args.index !== 'undefined') {
index = args.index;
}
// emulate mouse events to show
$$.dispatchEvent('mouseover', index, mouse);
$$.dispatchEvent('mousemove', index, mouse);
$$.config.tooltip_onshow.call($$, args.data);
};
c3_chart_fn.tooltip.hide = function () {
// TODO: get target data by checking the state of focus
this.internal.dispatchEvent('mouseout', 0);
this.internal.config.tooltip_onhide.call(this);
};
// Features:
// 1. category axis
// 2. ceil values of translate/x/y to int for half pixel antialiasing
// 3. multiline tick text
var tickTextCharSize;
function c3_axis(d3, params) {
var scale = d3.scale.linear(), orient = "bottom", innerTickSize = 6, outerTickSize, tickPadding = 3, tickValues = null, tickFormat, tickArguments;
var tickOffset = 0, tickCulling = true, tickCentered;
params = params || {};
outerTickSize = params.withOuterTick ? 6 : 0;
function axisX(selection, x) {
selection.attr("transform", function (d) {
return "translate(" + Math.ceil(x(d) + tickOffset) + ", 0)";
});
}
function axisY(selection, y) {
selection.attr("transform", function (d) {
return "translate(0," + Math.ceil(y(d)) + ")";
});
}
function scaleExtent(domain) {
var start = domain[0], stop = domain[domain.length - 1];
return start < stop ? [ start, stop ] : [ stop, start ];
}
function generateTicks(scale) {
var i, domain, ticks = [];
if (scale.ticks) {
return scale.ticks.apply(scale, tickArguments);
}
domain = scale.domain();
for (i = Math.ceil(domain[0]); i < domain[1]; i++) {
ticks.push(i);
}
if (ticks.length > 0 && ticks[0] > 0) {
ticks.unshift(ticks[0] - (ticks[1] - ticks[0]));
}
return ticks;
}
function copyScale() {
var newScale = scale.copy(), domain;
if (params.isCategory) {
domain = scale.domain();
newScale.domain([domain[0], domain[1] - 1]);
}
return newScale;
}
function textFormatted(v) {
var formatted = tickFormat ? tickFormat(v) : v;
return typeof formatted !== 'undefined' ? formatted : '';
}
function getSizeFor1Char(tick) {
if (tickTextCharSize) {
return tickTextCharSize;
}
var size = {
h: 11.5,
w: 5.5
};
tick.select('text').text(textFormatted).each(function (d) {
var box = this.getBoundingClientRect(),
text = textFormatted(d),
h = box.height,
w = text ? (box.width / text.length) : undefined;
if (h && w) {
size.h = h;
size.w = w;
}
}).text('');
tickTextCharSize = size;
return size;
}
function transitionise(selection) {
return params.withoutTransition ? selection : d3.transition(selection);
}
function axis(g) {
g.each(function () {
var g = axis.g = d3.select(this);
var scale0 = this.__chart__ || scale, scale1 = this.__chart__ = copyScale();
var ticks = tickValues ? tickValues : generateTicks(scale1),
tick = g.selectAll(".tick").data(ticks, scale1),
tickEnter = tick.enter().insert("g", ".domain").attr("class", "tick").style("opacity", 1e-6),
// MEMO: No exit transition. The reason is this transition affects max tick width calculation because old tick will be included in the ticks.
tickExit = tick.exit().remove(),
tickUpdate = transitionise(tick).style("opacity", 1),
tickTransform, tickX, tickY;
var range = scale.rangeExtent ? scale.rangeExtent() : scaleExtent(scale.range()),
path = g.selectAll(".domain").data([ 0 ]),
pathUpdate = (path.enter().append("path").attr("class", "domain"), transitionise(path));
tickEnter.append("line");
tickEnter.append("text");
var lineEnter = tickEnter.select("line"),
lineUpdate = tickUpdate.select("line"),
textEnter = tickEnter.select("text"),
textUpdate = tickUpdate.select("text");
if (params.isCategory) {
tickOffset = Math.ceil((scale1(1) - scale1(0)) / 2);
tickX = tickCentered ? 0 : tickOffset;
tickY = tickCentered ? tickOffset : 0;
} else {
tickOffset = tickX = 0;
}
var text, tspan, sizeFor1Char = getSizeFor1Char(g.select('.tick')), counts = [];
var tickLength = Math.max(innerTickSize, 0) + tickPadding,
isVertical = orient === 'left' || orient === 'right';
// this should be called only when category axis
function splitTickText(d, maxWidth) {
var tickText = textFormatted(d),
subtext, spaceIndex, textWidth, splitted = [];
if (Object.prototype.toString.call(tickText) === "[object Array]") {
return tickText;
}
if (!maxWidth || maxWidth <= 0) {
maxWidth = isVertical ? 95 : params.isCategory ? (Math.ceil(scale1(ticks[1]) - scale1(ticks[0])) - 12) : 110;
}
function split(splitted, text) {
spaceIndex = undefined;
for (var i = 1; i < text.length; i++) {
if (text.charAt(i) === ' ') {
spaceIndex = i;
}
subtext = text.substr(0, i + 1);
textWidth = sizeFor1Char.w * subtext.length;
// if text width gets over tick width, split by space index or crrent index
if (maxWidth < textWidth) {
return split(
splitted.concat(text.substr(0, spaceIndex ? spaceIndex : i)),
text.slice(spaceIndex ? spaceIndex + 1 : i)
);
}
}
return splitted.concat(text);
}
return split(splitted, tickText + "");
}
function tspanDy(d, i) {
var dy = sizeFor1Char.h;
if (i === 0) {
if (orient === 'left' || orient === 'right') {
dy = -((counts[d.index] - 1) * (sizeFor1Char.h / 2) - 3);
} else {
dy = ".71em";
}
}
return dy;
}
function tickSize(d) {
var tickPosition = scale(d) + (tickCentered ? 0 : tickOffset);
return range[0] < tickPosition && tickPosition < range[1] ? innerTickSize : 0;
}
text = tick.select("text");
tspan = text.selectAll('tspan')
.data(function (d, i) {
var splitted = params.tickMultiline ? splitTickText(d, params.tickWidth) : [].concat(textFormatted(d));
counts[i] = splitted.length;
return splitted.map(function (s) {
return { index: i, splitted: s };
});
});
tspan.enter().append('tspan');
tspan.exit().remove();
tspan.text(function (d) { return d.splitted; });
var rotate = params.tickTextRotate;
function textAnchorForText(rotate) {
if (!rotate) {
return 'middle';
}
return rotate > 0 ? "start" : "end";
}
function textTransform(rotate) {
if (!rotate) {
return '';
}
return "rotate(" + rotate + ")";
}
function dxForText(rotate) {
if (!rotate) {
return 0;
}
return 8 * Math.sin(Math.PI * (rotate / 180));
}
function yForText(rotate) {
if (!rotate) {
return tickLength;
}
return 11.5 - 2.5 * (rotate / 15) * (rotate > 0 ? 1 : -1);
}
switch (orient) {
case "bottom":
{
tickTransform = axisX;
lineEnter.attr("y2", innerTickSize);
textEnter.attr("y", tickLength);
lineUpdate.attr("x1", tickX).attr("x2", tickX).attr("y2", tickSize);
textUpdate.attr("x", 0).attr("y", yForText(rotate))
.style("text-anchor", textAnchorForText(rotate))
.attr("transform", textTransform(rotate));
tspan.attr('x', 0).attr("dy", tspanDy).attr('dx', dxForText(rotate));
pathUpdate.attr("d", "M" + range[0] + "," + outerTickSize + "V0H" + range[1] + "V" + outerTickSize);
break;
}
case "top":
{
// TODO: rotated tick text
tickTransform = axisX;
lineEnter.attr("y2", -innerTickSize);
textEnter.attr("y", -tickLength);
lineUpdate.attr("x2", 0).attr("y2", -innerTickSize);
textUpdate.attr("x", 0).attr("y", -tickLength);
text.style("text-anchor", "middle");
tspan.attr('x', 0).attr("dy", "0em");
pathUpdate.attr("d", "M" + range[0] + "," + -outerTickSize + "V0H" + range[1] + "V" + -outerTickSize);
break;
}
case "left":
{
tickTransform = axisY;
lineEnter.attr("x2", -innerTickSize);
textEnter.attr("x", -tickLength);
lineUpdate.attr("x2", -innerTickSize).attr("y1", tickY).attr("y2", tickY);
textUpdate.attr("x", -tickLength).attr("y", tickOffset);
text.style("text-anchor", "end");
tspan.attr('x', -tickLength).attr("dy", tspanDy);
pathUpdate.attr("d", "M" + -outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + -outerTickSize);
break;
}
case "right":
{
tickTransform = axisY;
lineEnter.attr("x2", innerTickSize);
textEnter.attr("x", tickLength);
lineUpdate.attr("x2", innerTickSize).attr("y2", 0);
textUpdate.attr("x", tickLength).attr("y", 0);
text.style("text-anchor", "start");
tspan.attr('x', tickLength).attr("dy", tspanDy);
pathUpdate.attr("d", "M" + outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + outerTickSize);
break;
}
}
if (scale1.rangeBand) {
var x = scale1, dx = x.rangeBand() / 2;
scale0 = scale1 = function (d) {
return x(d) + dx;
};
} else if (scale0.rangeBand) {
scale0 = scale1;
} else {
tickExit.call(tickTransform, scale1);
}
tickEnter.call(tickTransform, scale0);
tickUpdate.call(tickTransform, scale1);
});
}
axis.scale = function (x) {
if (!arguments.length) { return scale; }
scale = x;
return axis;
};
axis.orient = function (x) {
if (!arguments.length) { return orient; }
orient = x in {top: 1, right: 1, bottom: 1, left: 1} ? x + "" : "bottom";
return axis;
};
axis.tickFormat = function (format) {
if (!arguments.length) { return tickFormat; }
tickFormat = format;
return axis;
};
axis.tickCentered = function (isCentered) {
if (!arguments.length) { return tickCentered; }
tickCentered = isCentered;
return axis;
};
axis.tickOffset = function () {
return tickOffset;
};
axis.tickInterval = function () {
var interval, length;
if (params.isCategory) {
interval = tickOffset * 2;
}
else {
length = axis.g.select('path.domain').node().getTotalLength() - outerTickSize * 2;
interval = length / axis.g.selectAll('line').size();
}
return interval === Infinity ? 0 : interval;
};
axis.ticks = function () {
if (!arguments.length) { return tickArguments; }
tickArguments = arguments;
return axis;
};
axis.tickCulling = function (culling) {
if (!arguments.length) { return tickCulling; }
tickCulling = culling;
return axis;
};
axis.tickValues = function (x) {
if (typeof x === 'function') {
tickValues = function () {
return x(scale.domain());
};
}
else {
if (!arguments.length) { return tickValues; }
tickValues = x;
}
return axis;
};
return axis;
}
c3_chart_internal_fn.isSafari = function () {
var ua = window.navigator.userAgent;
return ua.indexOf('Safari') >= 0 && ua.indexOf('Chrome') < 0;
};
c3_chart_internal_fn.isChrome = function () {
var ua = window.navigator.userAgent;
return ua.indexOf('Chrome') >= 0;
};
/* jshint ignore:start */
// PhantomJS doesn't have support for Function.prototype.bind, which has caused confusion. Use
// this polyfill to avoid the confusion.
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind#Polyfill
if (!Function.prototype.bind) {
Function.prototype.bind = function(oThis) {
if (typeof this !== 'function') {
// closest thing possible to the ECMAScript 5
// internal IsCallable function
throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
}
var aArgs = Array.prototype.slice.call(arguments, 1),
fToBind = this,
fNOP = function() {},
fBound = function() {
return fToBind.apply(this instanceof fNOP ? this : oThis, aArgs.concat(Array.prototype.slice.call(arguments)));
};
fNOP.prototype = this.prototype;
fBound.prototype = new fNOP();
return fBound;
};
}
//SVGPathSeg API polyfill
//https://github.com/progers/pathseg
//
//This is a drop-in replacement for the SVGPathSeg and SVGPathSegList APIs that were removed from
//SVG2 (https://lists.w3.org/Archives/Public/www-svg/2015Jun/0044.html), including the latest spec
//changes which were implemented in Firefox 43 and Chrome 46.
//Chrome 48 removes these APIs, so this polyfill is required.
(function() { "use strict";
if (!("SVGPathSeg" in window)) {
// Spec: http://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSeg
window.SVGPathSeg = function(type, typeAsLetter, owningPathSegList) {
this.pathSegType = type;
this.pathSegTypeAsLetter = typeAsLetter;
this._owningPathSegList = owningPathSegList;
}
SVGPathSeg.PATHSEG_UNKNOWN = 0;
SVGPathSeg.PATHSEG_CLOSEPATH = 1;
SVGPathSeg.PATHSEG_MOVETO_ABS = 2;
SVGPathSeg.PATHSEG_MOVETO_REL = 3;
SVGPathSeg.PATHSEG_LINETO_ABS = 4;
SVGPathSeg.PATHSEG_LINETO_REL = 5;
SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS = 6;
SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL = 7;
SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS = 8;
SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL = 9;
SVGPathSeg.PATHSEG_ARC_ABS = 10;
SVGPathSeg.PATHSEG_ARC_REL = 11;
SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS = 12;
SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL = 13;
SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS = 14;
SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL = 15;
SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16;
SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17;
SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18;
SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19;
// Notify owning PathSegList on any changes so they can be synchronized back to the path element.
SVGPathSeg.prototype._segmentChanged = function() {
if (this._owningPathSegList)
this._owningPathSegList.segmentChanged(this);
}
window.SVGPathSegClosePath = function(owningPathSegList) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CLOSEPATH, "z", owningPathSegList);
}
SVGPathSegClosePath.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegClosePath.prototype.toString = function() { return "[object SVGPathSegClosePath]"; }
SVGPathSegClosePath.prototype._asPathString = function() { return this.pathSegTypeAsLetter; }
SVGPathSegClosePath.prototype.clone = function() { return new SVGPathSegClosePath(undefined); }
window.SVGPathSegMovetoAbs = function(owningPathSegList, x, y) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_MOVETO_ABS, "M", owningPathSegList);
this._x = x;
this._y = y;
}
SVGPathSegMovetoAbs.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegMovetoAbs.prototype.toString = function() { return "[object SVGPathSegMovetoAbs]"; }
SVGPathSegMovetoAbs.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x + " " + this._y; }
SVGPathSegMovetoAbs.prototype.clone = function() { return new SVGPathSegMovetoAbs(undefined, this._x, this._y); }
Object.defineProperty(SVGPathSegMovetoAbs.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegMovetoAbs.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegMovetoRel = function(owningPathSegList, x, y) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_MOVETO_REL, "m", owningPathSegList);
this._x = x;
this._y = y;
}
SVGPathSegMovetoRel.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegMovetoRel.prototype.toString = function() { return "[object SVGPathSegMovetoRel]"; }
SVGPathSegMovetoRel.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x + " " + this._y; }
SVGPathSegMovetoRel.prototype.clone = function() { return new SVGPathSegMovetoRel(undefined, this._x, this._y); }
Object.defineProperty(SVGPathSegMovetoRel.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegMovetoRel.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegLinetoAbs = function(owningPathSegList, x, y) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_ABS, "L", owningPathSegList);
this._x = x;
this._y = y;
}
SVGPathSegLinetoAbs.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegLinetoAbs.prototype.toString = function() { return "[object SVGPathSegLinetoAbs]"; }
SVGPathSegLinetoAbs.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x + " " + this._y; }
SVGPathSegLinetoAbs.prototype.clone = function() { return new SVGPathSegLinetoAbs(undefined, this._x, this._y); }
Object.defineProperty(SVGPathSegLinetoAbs.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegLinetoAbs.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegLinetoRel = function(owningPathSegList, x, y) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_REL, "l", owningPathSegList);
this._x = x;
this._y = y;
}
SVGPathSegLinetoRel.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegLinetoRel.prototype.toString = function() { return "[object SVGPathSegLinetoRel]"; }
SVGPathSegLinetoRel.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x + " " + this._y; }
SVGPathSegLinetoRel.prototype.clone = function() { return new SVGPathSegLinetoRel(undefined, this._x, this._y); }
Object.defineProperty(SVGPathSegLinetoRel.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegLinetoRel.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegCurvetoCubicAbs = function(owningPathSegList, x, y, x1, y1, x2, y2) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS, "C", owningPathSegList);
this._x = x;
this._y = y;
this._x1 = x1;
this._y1 = y1;
this._x2 = x2;
this._y2 = y2;
}
SVGPathSegCurvetoCubicAbs.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegCurvetoCubicAbs.prototype.toString = function() { return "[object SVGPathSegCurvetoCubicAbs]"; }
SVGPathSegCurvetoCubicAbs.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x1 + " " + this._y1 + " " + this._x2 + " " + this._y2 + " " + this._x + " " + this._y; }
SVGPathSegCurvetoCubicAbs.prototype.clone = function() { return new SVGPathSegCurvetoCubicAbs(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2); }
Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, "x1", { get: function() { return this._x1; }, set: function(x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, "y1", { get: function() { return this._y1; }, set: function(y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, "x2", { get: function() { return this._x2; }, set: function(x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, "y2", { get: function() { return this._y2; }, set: function(y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegCurvetoCubicRel = function(owningPathSegList, x, y, x1, y1, x2, y2) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL, "c", owningPathSegList);
this._x = x;
this._y = y;
this._x1 = x1;
this._y1 = y1;
this._x2 = x2;
this._y2 = y2;
}
SVGPathSegCurvetoCubicRel.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegCurvetoCubicRel.prototype.toString = function() { return "[object SVGPathSegCurvetoCubicRel]"; }
SVGPathSegCurvetoCubicRel.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x1 + " " + this._y1 + " " + this._x2 + " " + this._y2 + " " + this._x + " " + this._y; }
SVGPathSegCurvetoCubicRel.prototype.clone = function() { return new SVGPathSegCurvetoCubicRel(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2); }
Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, "x1", { get: function() { return this._x1; }, set: function(x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, "y1", { get: function() { return this._y1; }, set: function(y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, "x2", { get: function() { return this._x2; }, set: function(x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, "y2", { get: function() { return this._y2; }, set: function(y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegCurvetoQuadraticAbs = function(owningPathSegList, x, y, x1, y1) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS, "Q", owningPathSegList);
this._x = x;
this._y = y;
this._x1 = x1;
this._y1 = y1;
}
SVGPathSegCurvetoQuadraticAbs.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegCurvetoQuadraticAbs.prototype.toString = function() { return "[object SVGPathSegCurvetoQuadraticAbs]"; }
SVGPathSegCurvetoQuadraticAbs.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x1 + " " + this._y1 + " " + this._x + " " + this._y; }
SVGPathSegCurvetoQuadraticAbs.prototype.clone = function() { return new SVGPathSegCurvetoQuadraticAbs(undefined, this._x, this._y, this._x1, this._y1); }
Object.defineProperty(SVGPathSegCurvetoQuadraticAbs.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoQuadraticAbs.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoQuadraticAbs.prototype, "x1", { get: function() { return this._x1; }, set: function(x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoQuadraticAbs.prototype, "y1", { get: function() { return this._y1; }, set: function(y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegCurvetoQuadraticRel = function(owningPathSegList, x, y, x1, y1) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL, "q", owningPathSegList);
this._x = x;
this._y = y;
this._x1 = x1;
this._y1 = y1;
}
SVGPathSegCurvetoQuadraticRel.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegCurvetoQuadraticRel.prototype.toString = function() { return "[object SVGPathSegCurvetoQuadraticRel]"; }
SVGPathSegCurvetoQuadraticRel.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x1 + " " + this._y1 + " " + this._x + " " + this._y; }
SVGPathSegCurvetoQuadraticRel.prototype.clone = function() { return new SVGPathSegCurvetoQuadraticRel(undefined, this._x, this._y, this._x1, this._y1); }
Object.defineProperty(SVGPathSegCurvetoQuadraticRel.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoQuadraticRel.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoQuadraticRel.prototype, "x1", { get: function() { return this._x1; }, set: function(x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoQuadraticRel.prototype, "y1", { get: function() { return this._y1; }, set: function(y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegArcAbs = function(owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_ARC_ABS, "A", owningPathSegList);
this._x = x;
this._y = y;
this._r1 = r1;
this._r2 = r2;
this._angle = angle;
this._largeArcFlag = largeArcFlag;
this._sweepFlag = sweepFlag;
}
SVGPathSegArcAbs.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegArcAbs.prototype.toString = function() { return "[object SVGPathSegArcAbs]"; }
SVGPathSegArcAbs.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._r1 + " " + this._r2 + " " + this._angle + " " + (this._largeArcFlag ? "1" : "0") + " " + (this._sweepFlag ? "1" : "0") + " " + this._x + " " + this._y; }
SVGPathSegArcAbs.prototype.clone = function() { return new SVGPathSegArcAbs(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag); }
Object.defineProperty(SVGPathSegArcAbs.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcAbs.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcAbs.prototype, "r1", { get: function() { return this._r1; }, set: function(r1) { this._r1 = r1; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcAbs.prototype, "r2", { get: function() { return this._r2; }, set: function(r2) { this._r2 = r2; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcAbs.prototype, "angle", { get: function() { return this._angle; }, set: function(angle) { this._angle = angle; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcAbs.prototype, "largeArcFlag", { get: function() { return this._largeArcFlag; }, set: function(largeArcFlag) { this._largeArcFlag = largeArcFlag; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcAbs.prototype, "sweepFlag", { get: function() { return this._sweepFlag; }, set: function(sweepFlag) { this._sweepFlag = sweepFlag; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegArcRel = function(owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_ARC_REL, "a", owningPathSegList);
this._x = x;
this._y = y;
this._r1 = r1;
this._r2 = r2;
this._angle = angle;
this._largeArcFlag = largeArcFlag;
this._sweepFlag = sweepFlag;
}
SVGPathSegArcRel.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegArcRel.prototype.toString = function() { return "[object SVGPathSegArcRel]"; }
SVGPathSegArcRel.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._r1 + " " + this._r2 + " " + this._angle + " " + (this._largeArcFlag ? "1" : "0") + " " + (this._sweepFlag ? "1" : "0") + " " + this._x + " " + this._y; }
SVGPathSegArcRel.prototype.clone = function() { return new SVGPathSegArcRel(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag); }
Object.defineProperty(SVGPathSegArcRel.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcRel.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcRel.prototype, "r1", { get: function() { return this._r1; }, set: function(r1) { this._r1 = r1; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcRel.prototype, "r2", { get: function() { return this._r2; }, set: function(r2) { this._r2 = r2; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcRel.prototype, "angle", { get: function() { return this._angle; }, set: function(angle) { this._angle = angle; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcRel.prototype, "largeArcFlag", { get: function() { return this._largeArcFlag; }, set: function(largeArcFlag) { this._largeArcFlag = largeArcFlag; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegArcRel.prototype, "sweepFlag", { get: function() { return this._sweepFlag; }, set: function(sweepFlag) { this._sweepFlag = sweepFlag; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegLinetoHorizontalAbs = function(owningPathSegList, x) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS, "H", owningPathSegList);
this._x = x;
}
SVGPathSegLinetoHorizontalAbs.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegLinetoHorizontalAbs.prototype.toString = function() { return "[object SVGPathSegLinetoHorizontalAbs]"; }
SVGPathSegLinetoHorizontalAbs.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x; }
SVGPathSegLinetoHorizontalAbs.prototype.clone = function() { return new SVGPathSegLinetoHorizontalAbs(undefined, this._x); }
Object.defineProperty(SVGPathSegLinetoHorizontalAbs.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegLinetoHorizontalRel = function(owningPathSegList, x) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL, "h", owningPathSegList);
this._x = x;
}
SVGPathSegLinetoHorizontalRel.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegLinetoHorizontalRel.prototype.toString = function() { return "[object SVGPathSegLinetoHorizontalRel]"; }
SVGPathSegLinetoHorizontalRel.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x; }
SVGPathSegLinetoHorizontalRel.prototype.clone = function() { return new SVGPathSegLinetoHorizontalRel(undefined, this._x); }
Object.defineProperty(SVGPathSegLinetoHorizontalRel.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegLinetoVerticalAbs = function(owningPathSegList, y) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS, "V", owningPathSegList);
this._y = y;
}
SVGPathSegLinetoVerticalAbs.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegLinetoVerticalAbs.prototype.toString = function() { return "[object SVGPathSegLinetoVerticalAbs]"; }
SVGPathSegLinetoVerticalAbs.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._y; }
SVGPathSegLinetoVerticalAbs.prototype.clone = function() { return new SVGPathSegLinetoVerticalAbs(undefined, this._y); }
Object.defineProperty(SVGPathSegLinetoVerticalAbs.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegLinetoVerticalRel = function(owningPathSegList, y) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL, "v", owningPathSegList);
this._y = y;
}
SVGPathSegLinetoVerticalRel.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegLinetoVerticalRel.prototype.toString = function() { return "[object SVGPathSegLinetoVerticalRel]"; }
SVGPathSegLinetoVerticalRel.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._y; }
SVGPathSegLinetoVerticalRel.prototype.clone = function() { return new SVGPathSegLinetoVerticalRel(undefined, this._y); }
Object.defineProperty(SVGPathSegLinetoVerticalRel.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegCurvetoCubicSmoothAbs = function(owningPathSegList, x, y, x2, y2) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS, "S", owningPathSegList);
this._x = x;
this._y = y;
this._x2 = x2;
this._y2 = y2;
}
SVGPathSegCurvetoCubicSmoothAbs.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegCurvetoCubicSmoothAbs.prototype.toString = function() { return "[object SVGPathSegCurvetoCubicSmoothAbs]"; }
SVGPathSegCurvetoCubicSmoothAbs.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x2 + " " + this._y2 + " " + this._x + " " + this._y; }
SVGPathSegCurvetoCubicSmoothAbs.prototype.clone = function() { return new SVGPathSegCurvetoCubicSmoothAbs(undefined, this._x, this._y, this._x2, this._y2); }
Object.defineProperty(SVGPathSegCurvetoCubicSmoothAbs.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicSmoothAbs.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicSmoothAbs.prototype, "x2", { get: function() { return this._x2; }, set: function(x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicSmoothAbs.prototype, "y2", { get: function() { return this._y2; }, set: function(y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegCurvetoCubicSmoothRel = function(owningPathSegList, x, y, x2, y2) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL, "s", owningPathSegList);
this._x = x;
this._y = y;
this._x2 = x2;
this._y2 = y2;
}
SVGPathSegCurvetoCubicSmoothRel.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegCurvetoCubicSmoothRel.prototype.toString = function() { return "[object SVGPathSegCurvetoCubicSmoothRel]"; }
SVGPathSegCurvetoCubicSmoothRel.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x2 + " " + this._y2 + " " + this._x + " " + this._y; }
SVGPathSegCurvetoCubicSmoothRel.prototype.clone = function() { return new SVGPathSegCurvetoCubicSmoothRel(undefined, this._x, this._y, this._x2, this._y2); }
Object.defineProperty(SVGPathSegCurvetoCubicSmoothRel.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicSmoothRel.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicSmoothRel.prototype, "x2", { get: function() { return this._x2; }, set: function(x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoCubicSmoothRel.prototype, "y2", { get: function() { return this._y2; }, set: function(y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegCurvetoQuadraticSmoothAbs = function(owningPathSegList, x, y) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS, "T", owningPathSegList);
this._x = x;
this._y = y;
}
SVGPathSegCurvetoQuadraticSmoothAbs.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegCurvetoQuadraticSmoothAbs.prototype.toString = function() { return "[object SVGPathSegCurvetoQuadraticSmoothAbs]"; }
SVGPathSegCurvetoQuadraticSmoothAbs.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x + " " + this._y; }
SVGPathSegCurvetoQuadraticSmoothAbs.prototype.clone = function() { return new SVGPathSegCurvetoQuadraticSmoothAbs(undefined, this._x, this._y); }
Object.defineProperty(SVGPathSegCurvetoQuadraticSmoothAbs.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoQuadraticSmoothAbs.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
window.SVGPathSegCurvetoQuadraticSmoothRel = function(owningPathSegList, x, y) {
SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL, "t", owningPathSegList);
this._x = x;
this._y = y;
}
SVGPathSegCurvetoQuadraticSmoothRel.prototype = Object.create(SVGPathSeg.prototype);
SVGPathSegCurvetoQuadraticSmoothRel.prototype.toString = function() { return "[object SVGPathSegCurvetoQuadraticSmoothRel]"; }
SVGPathSegCurvetoQuadraticSmoothRel.prototype._asPathString = function() { return this.pathSegTypeAsLetter + " " + this._x + " " + this._y; }
SVGPathSegCurvetoQuadraticSmoothRel.prototype.clone = function() { return new SVGPathSegCurvetoQuadraticSmoothRel(undefined, this._x, this._y); }
Object.defineProperty(SVGPathSegCurvetoQuadraticSmoothRel.prototype, "x", { get: function() { return this._x; }, set: function(x) { this._x = x; this._segmentChanged(); }, enumerable: true });
Object.defineProperty(SVGPathSegCurvetoQuadraticSmoothRel.prototype, "y", { get: function() { return this._y; }, set: function(y) { this._y = y; this._segmentChanged(); }, enumerable: true });
// Add createSVGPathSeg* functions to SVGPathElement.
// Spec: http://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathElement.
SVGPathElement.prototype.createSVGPathSegClosePath = function() { return new SVGPathSegClosePath(undefined); }
SVGPathElement.prototype.createSVGPathSegMovetoAbs = function(x, y) { return new SVGPathSegMovetoAbs(undefined, x, y); }
SVGPathElement.prototype.createSVGPathSegMovetoRel = function(x, y) { return new SVGPathSegMovetoRel(undefined, x, y); }
SVGPathElement.prototype.createSVGPathSegLinetoAbs = function(x, y) { return new SVGPathSegLinetoAbs(undefined, x, y); }
SVGPathElement.prototype.createSVGPathSegLinetoRel = function(x, y) { return new SVGPathSegLinetoRel(undefined, x, y); }
SVGPathElement.prototype.createSVGPathSegCurvetoCubicAbs = function(x, y, x1, y1, x2, y2) { return new SVGPathSegCurvetoCubicAbs(undefined, x, y, x1, y1, x2, y2); }
SVGPathElement.prototype.createSVGPathSegCurvetoCubicRel = function(x, y, x1, y1, x2, y2) { return new SVGPathSegCurvetoCubicRel(undefined, x, y, x1, y1, x2, y2); }
SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticAbs = function(x, y, x1, y1) { return new SVGPathSegCurvetoQuadraticAbs(undefined, x, y, x1, y1); }
SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticRel = function(x, y, x1, y1) { return new SVGPathSegCurvetoQuadraticRel(undefined, x, y, x1, y1); }
SVGPathElement.prototype.createSVGPathSegArcAbs = function(x, y, r1, r2, angle, largeArcFlag, sweepFlag) { return new SVGPathSegArcAbs(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag); }
SVGPathElement.prototype.createSVGPathSegArcRel = function(x, y, r1, r2, angle, largeArcFlag, sweepFlag) { return new SVGPathSegArcRel(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag); }
SVGPathElement.prototype.createSVGPathSegLinetoHorizontalAbs = function(x) { return new SVGPathSegLinetoHorizontalAbs(undefined, x); }
SVGPathElement.prototype.createSVGPathSegLinetoHorizontalRel = function(x) { return new SVGPathSegLinetoHorizontalRel(undefined, x); }
SVGPathElement.prototype.createSVGPathSegLinetoVerticalAbs = function(y) { return new SVGPathSegLinetoVerticalAbs(undefined, y); }
SVGPathElement.prototype.createSVGPathSegLinetoVerticalRel = function(y) { return new SVGPathSegLinetoVerticalRel(undefined, y); }
SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothAbs = function(x, y, x2, y2) { return new SVGPathSegCurvetoCubicSmoothAbs(undefined, x, y, x2, y2); }
SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothRel = function(x, y, x2, y2) { return new SVGPathSegCurvetoCubicSmoothRel(undefined, x, y, x2, y2); }
SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothAbs = function(x, y) { return new SVGPathSegCurvetoQuadraticSmoothAbs(undefined, x, y); }
SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothRel = function(x, y) { return new SVGPathSegCurvetoQuadraticSmoothRel(undefined, x, y); }
}
if (!("SVGPathSegList" in window)) {
// Spec: http://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSegList
window.SVGPathSegList = function(pathElement) {
this._pathElement = pathElement;
this._list = this._parsePath(this._pathElement.getAttribute("d"));
// Use a MutationObserver to catch changes to the path's "d" attribute.
this._mutationObserverConfig = { "attributes": true, "attributeFilter": ["d"] };
this._pathElementMutationObserver = new MutationObserver(this._updateListFromPathMutations.bind(this));
this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig);
}
Object.defineProperty(SVGPathSegList.prototype, "numberOfItems", {
get: function() {
this._checkPathSynchronizedToList();
return this._list.length;
},
enumerable: true
});
// Add the pathSegList accessors to SVGPathElement.
// Spec: http://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGAnimatedPathData
Object.defineProperty(SVGPathElement.prototype, "pathSegList", {
get: function() {
if (!this._pathSegList)
this._pathSegList = new SVGPathSegList(this);
return this._pathSegList;
},
enumerable: true
});
// FIXME: The following are not implemented and simply return SVGPathElement.pathSegList.
Object.defineProperty(SVGPathElement.prototype, "normalizedPathSegList", { get: function() { return this.pathSegList; }, enumerable: true });
Object.defineProperty(SVGPathElement.prototype, "animatedPathSegList", { get: function() { return this.pathSegList; }, enumerable: true });
Object.defineProperty(SVGPathElement.prototype, "animatedNormalizedPathSegList", { get: function() { return this.pathSegList; }, enumerable: true });
// Process any pending mutations to the path element and update the list as needed.
// This should be the first call of all public functions and is needed because
// MutationObservers are not synchronous so we can have pending asynchronous mutations.
SVGPathSegList.prototype._checkPathSynchronizedToList = function() {
this._updateListFromPathMutations(this._pathElementMutationObserver.takeRecords());
}
SVGPathSegList.prototype._updateListFromPathMutations = function(mutationRecords) {
if (!this._pathElement)
return;
var hasPathMutations = false;
mutationRecords.forEach(function(record) {
if (record.attributeName == "d")
hasPathMutations = true;
});
if (hasPathMutations)
this._list = this._parsePath(this._pathElement.getAttribute("d"));
}
// Serialize the list and update the path's 'd' attribute.
SVGPathSegList.prototype._writeListToPath = function() {
this._pathElementMutationObserver.disconnect();
this._pathElement.setAttribute("d", SVGPathSegList._pathSegArrayAsString(this._list));
this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig);
}
// When a path segment changes the list needs to be synchronized back to the path element.
SVGPathSegList.prototype.segmentChanged = function(pathSeg) {
this._writeListToPath();
}
SVGPathSegList.prototype.clear = function() {
this._checkPathSynchronizedToList();
this._list.forEach(function(pathSeg) {
pathSeg._owningPathSegList = null;
});
this._list = [];
this._writeListToPath();
}
SVGPathSegList.prototype.initialize = function(newItem) {
this._checkPathSynchronizedToList();
this._list = [newItem];
newItem._owningPathSegList = this;
this._writeListToPath();
return newItem;
}
SVGPathSegList.prototype._checkValidIndex = function(index) {
if (isNaN(index) || index < 0 || index >= this.numberOfItems)
throw "INDEX_SIZE_ERR";
}
SVGPathSegList.prototype.getItem = function(index) {
this._checkPathSynchronizedToList();
this._checkValidIndex(index);
return this._list[index];
}
SVGPathSegList.prototype.insertItemBefore = function(newItem, index) {
this._checkPathSynchronizedToList();
// Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list.
if (index > this.numberOfItems)
index = this.numberOfItems;
if (newItem._owningPathSegList) {
// SVG2 spec says to make a copy.
newItem = newItem.clone();
}
this._list.splice(index, 0, newItem);
newItem._owningPathSegList = this;
this._writeListToPath();
return newItem;
}
SVGPathSegList.prototype.replaceItem = function(newItem, index) {
this._checkPathSynchronizedToList();
if (newItem._owningPathSegList) {
// SVG2 spec says to make a copy.
newItem = newItem.clone();
}
this._checkValidIndex(index);
this._list[index] = newItem;
newItem._owningPathSegList = this;
this._writeListToPath();
return newItem;
}
SVGPathSegList.prototype.removeItem = function(index) {
this._checkPathSynchronizedToList();
this._checkValidIndex(index);
var item = this._list[index];
this._list.splice(index, 1);
this._writeListToPath();
return item;
}
SVGPathSegList.prototype.appendItem = function(newItem) {
this._checkPathSynchronizedToList();
if (newItem._owningPathSegList) {
// SVG2 spec says to make a copy.
newItem = newItem.clone();
}
this._list.push(newItem);
newItem._owningPathSegList = this;
// TODO: Optimize this to just append to the existing attribute.
this._writeListToPath();
return newItem;
}
SVGPathSegList._pathSegArrayAsString = function(pathSegArray) {
var string = "";
var first = true;
pathSegArray.forEach(function(pathSeg) {
if (first) {
first = false;
string += pathSeg._asPathString();
} else {
string += " " + pathSeg._asPathString();
}
});
return string;
}
// This closely follows SVGPathParser::parsePath from Source/core/svg/SVGPathParser.cpp.
SVGPathSegList.prototype._parsePath = function(string) {
if (!string || string.length == 0)
return [];
var owningPathSegList = this;
var Builder = function() {
this.pathSegList = [];
}
Builder.prototype.appendSegment = function(pathSeg) {
this.pathSegList.push(pathSeg);
}
var Source = function(string) {
this._string = string;
this._currentIndex = 0;
this._endIndex = this._string.length;
this._previousCommand = SVGPathSeg.PATHSEG_UNKNOWN;
this._skipOptionalSpaces();
}
Source.prototype._isCurrentSpace = function() {
var character = this._string[this._currentIndex];
return character <= " " && (character == " " || character == "\n" || character == "\t" || character == "\r" || character == "\f");
}
Source.prototype._skipOptionalSpaces = function() {
while (this._currentIndex < this._endIndex && this._isCurrentSpace())
this._currentIndex++;
return this._currentIndex < this._endIndex;
}
Source.prototype._skipOptionalSpacesOrDelimiter = function() {
if (this._currentIndex < this._endIndex && !this._isCurrentSpace() && this._string.charAt(this._currentIndex) != ",")
return false;
if (this._skipOptionalSpaces()) {
if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) == ",") {
this._currentIndex++;
this._skipOptionalSpaces();
}
}
return this._currentIndex < this._endIndex;
}
Source.prototype.hasMoreData = function() {
return this._currentIndex < this._endIndex;
}
Source.prototype.peekSegmentType = function() {
var lookahead = this._string[this._currentIndex];
return this._pathSegTypeFromChar(lookahead);
}
Source.prototype._pathSegTypeFromChar = function(lookahead) {
switch (lookahead) {
case "Z":
case "z":
return SVGPathSeg.PATHSEG_CLOSEPATH;
case "M":
return SVGPathSeg.PATHSEG_MOVETO_ABS;
case "m":
return SVGPathSeg.PATHSEG_MOVETO_REL;
case "L":
return SVGPathSeg.PATHSEG_LINETO_ABS;
case "l":
return SVGPathSeg.PATHSEG_LINETO_REL;
case "C":
return SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS;
case "c":
return SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL;
case "Q":
return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS;
case "q":
return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL;
case "A":
return SVGPathSeg.PATHSEG_ARC_ABS;
case "a":
return SVGPathSeg.PATHSEG_ARC_REL;
case "H":
return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS;
case "h":
return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL;
case "V":
return SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS;
case "v":
return SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL;
case "S":
return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;
case "s":
return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL;
case "T":
return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;
case "t":
return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;
default:
return SVGPathSeg.PATHSEG_UNKNOWN;
}
}
Source.prototype._nextCommandHelper = function(lookahead, previousCommand) {
// Check for remaining coordinates in the current command.
if ((lookahead == "+" || lookahead == "-" || lookahead == "." || (lookahead >= "0" && lookahead <= "9")) && previousCommand != SVGPathSeg.PATHSEG_CLOSEPATH) {
if (previousCommand == SVGPathSeg.PATHSEG_MOVETO_ABS)
return SVGPathSeg.PATHSEG_LINETO_ABS;
if (previousCommand == SVGPathSeg.PATHSEG_MOVETO_REL)
return SVGPathSeg.PATHSEG_LINETO_REL;
return previousCommand;
}
return SVGPathSeg.PATHSEG_UNKNOWN;
}
Source.prototype.initialCommandIsMoveTo = function() {
// If the path is empty it is still valid, so return true.
if (!this.hasMoreData())
return true;
var command = this.peekSegmentType();
// Path must start with moveTo.
return command == SVGPathSeg.PATHSEG_MOVETO_ABS || command == SVGPathSeg.PATHSEG_MOVETO_REL;
}
// Parse a number from an SVG path. This very closely follows genericParseNumber(...) from Source/core/svg/SVGParserUtilities.cpp.
// Spec: http://www.w3.org/TR/SVG11/single-page.html#paths-PathDataBNF
Source.prototype._parseNumber = function() {
var exponent = 0;
var integer = 0;
var frac = 1;
var decimal = 0;
var sign = 1;
var expsign = 1;
var startIndex = this._currentIndex;
this._skipOptionalSpaces();
// Read the sign.
if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) == "+")
this._currentIndex++;
else if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) == "-") {
this._currentIndex++;
sign = -1;
}
if (this._currentIndex == this._endIndex || ((this._string.charAt(this._currentIndex) < "0" || this._string.charAt(this._currentIndex) > "9") && this._string.charAt(this._currentIndex) != "."))
// The first character of a number must be one of [0-9+-.].
return undefined;
// Read the integer part, build right-to-left.
var startIntPartIndex = this._currentIndex;
while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= "0" && this._string.charAt(this._currentIndex) <= "9")
this._currentIndex++; // Advance to first non-digit.
if (this._currentIndex != startIntPartIndex) {
var scanIntPartIndex = this._currentIndex - 1;
var multiplier = 1;
while (scanIntPartIndex >= startIntPartIndex) {
integer += multiplier * (this._string.charAt(scanIntPartIndex--) - "0");
multiplier *= 10;
}
}
// Read the decimals.
if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) == ".") {
this._currentIndex++;
// There must be a least one digit following the .
if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < "0" || this._string.charAt(this._currentIndex) > "9")
return undefined;
while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= "0" && this._string.charAt(this._currentIndex) <= "9")
decimal += (this._string.charAt(this._currentIndex++) - "0") * (frac *= 0.1);
}
// Read the exponent part.
if (this._currentIndex != startIndex && this._currentIndex + 1 < this._endIndex && (this._string.charAt(this._currentIndex) == "e" || this._string.charAt(this._currentIndex) == "E") && (this._string.charAt(this._currentIndex + 1) != "x" && this._string.charAt(this._currentIndex + 1) != "m")) {
this._currentIndex++;
// Read the sign of the exponent.
if (this._string.charAt(this._currentIndex) == "+") {
this._currentIndex++;
} else if (this._string.charAt(this._currentIndex) == "-") {
this._currentIndex++;
expsign = -1;
}
// There must be an exponent.
if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < "0" || this._string.charAt(this._currentIndex) > "9")
return undefined;
while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= "0" && this._string.charAt(this._currentIndex) <= "9") {
exponent *= 10;
exponent += (this._string.charAt(this._currentIndex) - "0");
this._currentIndex++;
}
}
var number = integer + decimal;
number *= sign;
if (exponent)
number *= Math.pow(10, expsign * exponent);
if (startIndex == this._currentIndex)
return undefined;
this._skipOptionalSpacesOrDelimiter();
return number;
}
Source.prototype._parseArcFlag = function() {
if (this._currentIndex >= this._endIndex)
return undefined;
var flag = false;
var flagChar = this._string.charAt(this._currentIndex++);
if (flagChar == "0")
flag = false;
else if (flagChar == "1")
flag = true;
else
return undefined;
this._skipOptionalSpacesOrDelimiter();
return flag;
}
Source.prototype.parseSegment = function() {
var lookahead = this._string[this._currentIndex];
var command = this._pathSegTypeFromChar(lookahead);
if (command == SVGPathSeg.PATHSEG_UNKNOWN) {
// Possibly an implicit command. Not allowed if this is the first command.
if (this._previousCommand == SVGPathSeg.PATHSEG_UNKNOWN)
return null;
command = this._nextCommandHelper(lookahead, this._previousCommand);
if (command == SVGPathSeg.PATHSEG_UNKNOWN)
return null;
} else {
this._currentIndex++;
}
this._previousCommand = command;
switch (command) {
case SVGPathSeg.PATHSEG_MOVETO_REL:
return new SVGPathSegMovetoRel(owningPathSegList, this._parseNumber(), this._parseNumber());
case SVGPathSeg.PATHSEG_MOVETO_ABS:
return new SVGPathSegMovetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber());
case SVGPathSeg.PATHSEG_LINETO_REL:
return new SVGPathSegLinetoRel(owningPathSegList, this._parseNumber(), this._parseNumber());
case SVGPathSeg.PATHSEG_LINETO_ABS:
return new SVGPathSegLinetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber());
case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL:
return new SVGPathSegLinetoHorizontalRel(owningPathSegList, this._parseNumber());
case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS:
return new SVGPathSegLinetoHorizontalAbs(owningPathSegList, this._parseNumber());
case SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL:
return new SVGPathSegLinetoVerticalRel(owningPathSegList, this._parseNumber());
case SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS:
return new SVGPathSegLinetoVerticalAbs(owningPathSegList, this._parseNumber());
case SVGPathSeg.PATHSEG_CLOSEPATH:
this._skipOptionalSpaces();
return new SVGPathSegClosePath(owningPathSegList);
case SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL:
var points = {x1: this._parseNumber(), y1: this._parseNumber(), x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};
return new SVGPathSegCurvetoCubicRel(owningPathSegList, points.x, points.y, points.x1, points.y1, points.x2, points.y2);
case SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS:
var points = {x1: this._parseNumber(), y1: this._parseNumber(), x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};
return new SVGPathSegCurvetoCubicAbs(owningPathSegList, points.x, points.y, points.x1, points.y1, points.x2, points.y2);
case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL:
var points = {x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};
return new SVGPathSegCurvetoCubicSmoothRel(owningPathSegList, points.x, points.y, points.x2, points.y2);
case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS:
var points = {x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};
return new SVGPathSegCurvetoCubicSmoothAbs(owningPathSegList, points.x, points.y, points.x2, points.y2);
case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL:
var points = {x1: this._parseNumber(), y1: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};
return new SVGPathSegCurvetoQuadraticRel(owningPathSegList, points.x, points.y, points.x1, points.y1);
case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS:
var points = {x1: this._parseNumber(), y1: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};
return new SVGPathSegCurvetoQuadraticAbs(owningPathSegList, points.x, points.y, points.x1, points.y1);
case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL:
return new SVGPathSegCurvetoQuadraticSmoothRel(owningPathSegList, this._parseNumber(), this._parseNumber());
case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS:
return new SVGPathSegCurvetoQuadraticSmoothAbs(owningPathSegList, this._parseNumber(), this._parseNumber());
case SVGPathSeg.PATHSEG_ARC_REL:
var points = {x1: this._parseNumber(), y1: this._parseNumber(), arcAngle: this._parseNumber(), arcLarge: this._parseArcFlag(), arcSweep: this._parseArcFlag(), x: this._parseNumber(), y: this._parseNumber()};
return new SVGPathSegArcRel(owningPathSegList, points.x, points.y, points.x1, points.y1, points.arcAngle, points.arcLarge, points.arcSweep);
case SVGPathSeg.PATHSEG_ARC_ABS:
var points = {x1: this._parseNumber(), y1: this._parseNumber(), arcAngle: this._parseNumber(), arcLarge: this._parseArcFlag(), arcSweep: this._parseArcFlag(), x: this._parseNumber(), y: this._parseNumber()};
return new SVGPathSegArcAbs(owningPathSegList, points.x, points.y, points.x1, points.y1, points.arcAngle, points.arcLarge, points.arcSweep);
default:
throw "Unknown path seg type."
}
}
var builder = new Builder();
var source = new Source(string);
if (!source.initialCommandIsMoveTo())
return [];
while (source.hasMoreData()) {
var pathSeg = source.parseSegment();
if (!pathSeg)
return [];
builder.appendSegment(pathSeg);
}
return builder.pathSegList;
}
}
}());
/* jshint ignore:end */
if (typeof define === 'function' && define.amd) {
define("c3", ["d3"], function () { return c3; });
} else if ('undefined' !== typeof exports && 'undefined' !== typeof module) {
module.exports = c3;
} else {
window.c3 = c3;
}
})(window);
|
function solve(args) {
const module = 1024;
let numbers = args.slice(1).map(Number),
current,
result = 0,
i = 0;
while (true) {
if (i === 0) {
current = numbers[i];
if (numbers.length === 1) {
result = current;
break;
}
i++;
}
if (numbers[i] % 2 === 0 || numbers[i] === 0) {
current += numbers[i];
current = current % module;
i += 2;
if (i > numbers.length - 1) {
result = current;
break;
}
} else if (numbers[i] % 2 !== 0 || numbers[i] === 1) {
current *= numbers[i];
current = current % module;
i++;
if (i > numbers.length - 1) {
result = current;
break;
}
}
}
console.log(result);
}
// tests
solve([
'10',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
'8',
'9',
'0'
]);
console.log('------------');
solve([
'9',
'9',
'9',
'9',
'9',
'9',
'9',
'9',
'9',
'9'
]);
solve(['2', '2', '2', '2', '2', '2', '2', '2', '2']); |
function populate(form)
{
form.options.length = 0;
form.options[0] = new Option("Select a county of Georgia","");
form.options[1] = new Option("Appling County","Appling County");
form.options[2] = new Option("Atkinson County","Atkinson County");
form.options[3] = new Option("Bacon County","Bacon County");
form.options[4] = new Option("Baker County","Baker County");
form.options[5] = new Option("Baldwin County","Baldwin County");
form.options[6] = new Option("Banks County","Banks County");
form.options[7] = new Option("Barrow County","Barrow County");
form.options[8] = new Option("Bartow County","Bartow County");
form.options[9] = new Option("Ben Hill County","Ben Hill County");
form.options[10] = new Option("Berrien County","Berrien County");
form.options[11] = new Option("Bibb County","Bibb County");
form.options[12] = new Option("Bleckley County","Bleckley County");
form.options[13] = new Option("Brantley County","Brantley County");
form.options[14] = new Option("Brooks County","Brooks County");
form.options[15] = new Option("Bryan County","Bryan County");
form.options[16] = new Option("Bulloch County","Bulloch County");
form.options[17] = new Option("Burke County","Burke County");
form.options[18] = new Option("Butts County","Butts County");
form.options[19] = new Option("Calhoun County","Calhoun County");
form.options[20] = new Option("Camden County","Camden County");
form.options[21] = new Option("Candler County","Candler County");
form.options[22] = new Option("Carroll County","Carroll County");
form.options[23] = new Option("Catoosa County","Catoosa County");
form.options[24] = new Option("Charlton County","Charlton County");
form.options[25] = new Option("Chatham County","Chatham County");
form.options[26] = new Option("Chattahoochee County","Chattahoochee County");
form.options[27] = new Option("Chattooga County","Chattooga County");
form.options[28] = new Option("Cherokee County","Cherokee County");
form.options[29] = new Option("Clarke County","Clarke County");
form.options[30] = new Option("Clay County","Clay County");
form.options[31] = new Option("Clayton County","Clayton County");
form.options[32] = new Option("Clinch County","Clinch County");
form.options[33] = new Option("Cobb County","Cobb County");
form.options[34] = new Option("Coffee County","Coffee County");
form.options[35] = new Option("Colquitt County","Colquitt County");
form.options[36] = new Option("Columbia County","Columbia County");
form.options[37] = new Option("Cook County","Cook County");
form.options[38] = new Option("Coweta County","Coweta County");
form.options[39] = new Option("Crawford County","Crawford County");
form.options[40] = new Option("Crisp County","Crisp County");
form.options[41] = new Option("Dade County","Dade County");
form.options[42] = new Option("Dawson County","Dawson County");
form.options[43] = new Option("Decatur County","Decatur County");
form.options[44] = new Option("DeKalb County","DeKalb County");
form.options[45] = new Option("Dodge County","Dodge County");
form.options[46] = new Option("Dooly County","Dooly County");
form.options[47] = new Option("Dougherty County","Dougherty County");
form.options[48] = new Option("Douglas County","Douglas County");
form.options[49] = new Option("Early County","Early County");
form.options[50] = new Option("Echols County","Echols County");
form.options[51] = new Option("Effingham County","Effingham County");
form.options[52] = new Option("Elbert County","Elbert County");
form.options[53] = new Option("Emanuel County","Emanuel County");
form.options[54] = new Option("Evans County","Evans County");
form.options[55] = new Option("Fannin County","Fannin County");
form.options[56] = new Option("Fayette County","Fayette County");
form.options[57] = new Option("Floyd County","Floyd County");
form.options[58] = new Option("Forsyth County","Forsyth County");
form.options[59] = new Option("Franklin County","Franklin County");
form.options[60] = new Option("Fulton County","Fulton County");
form.options[61] = new Option("Gilmer County","Gilmer County");
form.options[62] = new Option("Glascock County","Glascock County");
form.options[63] = new Option("Glynn County","Glynn County");
form.options[64] = new Option("Gordon County","Gordon County");
form.options[65] = new Option("Grady County","Grady County");
form.options[66] = new Option("Greene County","Greene County");
form.options[67] = new Option("Gwinnett County","Gwinnett County");
form.options[68] = new Option("Habersham County","Habersham County");
form.options[69] = new Option("Hall County","Hall County");
form.options[70] = new Option("Hancock County","Hancock County");
form.options[71] = new Option("Haralson County","Haralson County");
form.options[72] = new Option("Harris County","Harris County");
form.options[73] = new Option("Hart County","Hart County");
form.options[74] = new Option("Heard County","Heard County");
form.options[75] = new Option("Henry County","Henry County");
form.options[76] = new Option("Houston County","Houston County");
form.options[77] = new Option("Irwin County","Irwin County");
form.options[78] = new Option("Jackson County","Jackson County");
form.options[79] = new Option("Jasper County","Jasper County");
form.options[80] = new Option("Jeff Davis County","Jeff Davis County");
form.options[81] = new Option("Jefferson County","Jefferson County");
form.options[82] = new Option("Jenkins County","Jenkins County");
form.options[83] = new Option("Johnson County","Johnson County");
form.options[84] = new Option("Jones County","Jones County");
form.options[85] = new Option("Lamar County","Lamar County");
form.options[86] = new Option("Lanier County","Lanier County");
form.options[87] = new Option("Laurens County","Laurens County");
form.options[88] = new Option("Lee County","Lee County");
form.options[89] = new Option("Liberty County","Liberty County");
form.options[90] = new Option("Lincoln County","Lincoln County");
form.options[91] = new Option("Long County","Long County");
form.options[92] = new Option("Lowndes County","Lowndes County");
form.options[93] = new Option("Lumpkin County","Lumpkin County");
form.options[94] = new Option("Macon County","Macon County");
form.options[95] = new Option("Madison County","Madison County");
form.options[96] = new Option("Marion County","Marion County");
form.options[97] = new Option("McDuffie County","McDuffie County");
form.options[98] = new Option("McIntosh County","McIntosh County");
form.options[99] = new Option("Meriwether County","Meriwether County");
form.options[100] = new Option("Miller County","Miller County");
form.options[101] = new Option("Mitchell County","Mitchell County");
form.options[102] = new Option("Monroe County","Monroe County");
form.options[103] = new Option("Montgomery County","Montgomery County");
form.options[104] = new Option("Morgan County","Morgan County");
form.options[105] = new Option("Murray County","Murray County");
form.options[106] = new Option("Muscogee County","Muscogee County");
form.options[107] = new Option("Newton County","Newton County");
form.options[108] = new Option("Oconee County","Oconee County");
form.options[109] = new Option("Oglethorpe County","Oglethorpe County");
form.options[110] = new Option("Paulding County","Paulding County");
form.options[111] = new Option("Peach County","Peach County");
form.options[112] = new Option("Pickens County","Pickens County");
form.options[113] = new Option("Pierce County","Pierce County");
form.options[114] = new Option("Pike County","Pike County");
form.options[115] = new Option("Polk County","Polk County");
form.options[116] = new Option("Pulaski County","Pulaski County");
form.options[117] = new Option("Putnam County","Putnam County");
form.options[118] = new Option("Quitman County","Quitman County");
form.options[119] = new Option("Rabun County","Rabun County");
form.options[120] = new Option("Randolph County","Randolph County");
form.options[121] = new Option("Richmond County","Richmond County");
form.options[122] = new Option("Rockdale County","Rockdale County");
form.options[123] = new Option("Schley County","Schley County");
form.options[124] = new Option("Screven County","Screven County");
form.options[125] = new Option("Seminole County","Seminole County");
form.options[126] = new Option("Spalding County","Spalding County");
form.options[127] = new Option("Stephens County","Stephens County");
form.options[128] = new Option("Stewart County","Stewart County");
form.options[129] = new Option("Sumter County","Sumter County");
form.options[130] = new Option("Talbot County","Talbot County");
form.options[131] = new Option("Taliaferro County","Taliaferro County");
form.options[132] = new Option("Tattnall County","Tattnall County");
form.options[133] = new Option("Taylor County","Taylor County");
form.options[134] = new Option("Telfair County","Telfair County");
form.options[135] = new Option("Terrell County","Terrell County");
form.options[136] = new Option("Thomas County","Thomas County");
form.options[137] = new Option("Tift County","Tift County");
form.options[138] = new Option("Toombs County","Toombs County");
form.options[139] = new Option("Towns County","Towns County");
form.options[140] = new Option("Treutlen County","Treutlen County");
form.options[141] = new Option("Troup County","Troup County");
form.options[142] = new Option("Turner County","Turner County");
form.options[143] = new Option("Twiggs County","Twiggs County");
form.options[144] = new Option("Union County","Union County");
form.options[145] = new Option("Upson County","Upson County");
form.options[146] = new Option("Walker County","Walker County");
form.options[147] = new Option("Walton County","Walton County");
form.options[148] = new Option("Ware County","Ware County");
form.options[149] = new Option("Warren County","Warren County");
form.options[150] = new Option("Washington County","Washington County");
form.options[151] = new Option("Wayne County","Wayne County");
form.options[152] = new Option("Webster County","Webster County");
form.options[153] = new Option("Wheeler County","Wheeler County");
form.options[154] = new Option("White County","White County");
form.options[155] = new Option("Whitfield County","Whitfield County");
form.options[156] = new Option("Wilcox County","Wilcox County");
form.options[157] = new Option("Wilkes County","Wilkes County");
form.options[158] = new Option("Wilkinson County","Wilkinson County");
form.options[159] = new Option("Worth County","Worth County");
} |
/**
* Created by chenqx on 8/5/15.
* @hack 添加三角形绘制提交方式
*/
/**
* 以四边形填充
* @constant
* @type {number}
*/
qc.BATCH_QUAD = 0;
/**
* 以三角形填充
* @constant
* @type {number}
*/
qc.BATCH_TRIANGLES = 1;
var oldWebGLSpriteBatchSetContext = PIXI.WebGLSpriteBatch.prototype.setContext;
PIXI.WebGLSpriteBatch.prototype.setContext = function(gl) {
oldWebGLSpriteBatchSetContext.call(this, gl);
this.quadSize = this.size;
this.triangleSize = 300;
this.batchIndexNumber = 6;
var triangleIndicesNum = this.triangleSize * 3;
this.triangleIndices = new PIXI.Uint16Array(triangleIndicesNum);
for (var i = 0; i < triangleIndicesNum; ++i) {
this.triangleIndices[i] = i;
}
this._batchType = qc.BATCH_QUAD;
this.quadIndexBuffer = this.indexBuffer;
this.triangleIndexBuffer = gl.createBuffer();
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.triangleIndexBuffer);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, this.triangleIndices, gl.STATIC_DRAW);
};
var oldWebGLSpriteBatchDestroy = PIXI.WebGLSpriteBatch.prototype.destroy;
PIXI.WebGLSpriteBatch.prototype.destroy = function() {
this.triangleIndices = null;
this.gl.deleteBuffer(this.triangleIndexBuffer);
oldWebGLSpriteBatchDestroy.call(this);
}
Object.defineProperties(PIXI.WebGLSpriteBatch.prototype,{
batchType : {
get : function() { return this._batchType; },
set : function(v) {
if (v === this._batchType) {
return;
}
this.stop();
// 切换IndexBuffer，Size
if (v === qc.BATCH_TRIANGLES) {
this.size = this.triangleSize;
this.indexBuffer = this.triangleIndexBuffer;
this._batchType = v;
this.batchIndexNumber = 3;
}
else {
this.size = this.quadSize;
this.indexBuffer = this.quadIndexBuffer;
this._batchType = v;
this.batchIndexNumber = 6;
}
this.start();
}
}
});
/**
* @method renderBatch
* @param texture {Texture}
* @param size {Number}
* @param startIndex {Number}
*/
PIXI.WebGLSpriteBatch.prototype.renderBatch = function(texture, size, startIndex)
{
if(size === 0)return;
var gl = this.gl;
// check if a texture is dirty..
if(texture._dirty[gl.id])
{
this.renderSession.renderer.updateTexture(texture);
}
else
{
// bind the current texture
gl.bindTexture(gl.TEXTURE_2D, texture._glTextures[gl.id]);
}
//gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.batchIndexNumber === 3 ? this.triangleIndexBuffer : this.indexBuffer);
// now draw those suckas!
gl.drawElements(gl.TRIANGLES, size * this.batchIndexNumber, gl.UNSIGNED_SHORT, startIndex * this.batchIndexNumber * 2);
// increment the draw count
this.renderSession.drawCount++;
}; |
#!/usr/bin/env node
// Fires up a console with Valid loaded.
// Allows you to quickly play with Valid on the console.
Valid = require('./lib/valid');
require('repl').start();
|
import * as React from 'react';
import createSvgIcon from './utils/createSvgIcon';
export default createSvgIcon(
<path d="M4 18h11c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1zm0-5h8c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1zM3 7c0 .55.45 1 1 1h11c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1zm17.3 7.88L17.42 12l2.88-2.88c.39-.39.39-1.02 0-1.41a.9959.9959 0 00-1.41 0L15.3 11.3c-.39.39-.39 1.02 0 1.41l3.59 3.59c.39.39 1.02.39 1.41 0 .38-.39.39-1.03 0-1.42z" />
, 'MenuOpenRounded');
|
'use strict';
describe('Service: awesomeThings', function() {
// load the service's module
beforeEach(module('initApp'));
// instantiate service
var awesomeThings;
beforeEach(inject(function(_awesomeThings_) {
awesomeThings = _awesomeThings_;
}));
it('should return all the awesomeThings at the static list', function() {
expect(awesomeThings.getAll().length).toBe(4);
});
it('should return an specific awesome thing', function() {
// We can test the object itself here. Not doing for simplicity
expect(awesomeThings.get('2').name).toBe('AngularJS');
});
});
|
'use strict';
var matrix = require( 'dstructs-matrix' ),
ekurtosis = require( './../lib' );
var k,
mat,
out,
tmp,
i;
// ----
// Plain arrays...
k = new Array( 10 );
for ( i = 0; i < k.length; i++ ) {
k[ i ] = i;
}
out = ekurtosis( k );
console.log( 'Arrays: %s\n', out );
// ----
// Object arrays (accessors)...
function getValue( d ) {
return d.x;
}
for ( i = 0; i < k.length; i++ ) {
k[ i ] = {
'x': k[ i ]
};
}
out = ekurtosis( k, {
'accessor': getValue
});
console.log( 'Accessors: %s\n', out );
// ----
// Deep set arrays...
for ( i = 0; i < k.length; i++ ) {
k[ i ] = {
'x': [ i, k[ i ].x ]
};
}
out = ekurtosis( k, {
'path': 'x/1',
'sep': '/'
});
console.log( 'Deepset:');
console.dir( out );
console.log( '\n' );
// ----
// Typed arrays...
k = new Float64Array( 10 );
for ( i = 0; i < k.length; i++ ) {
k[ i ] = i;
}
tmp = ekurtosis( k );
out = '';
for ( i = 0; i < k.length; i++ ) {
out += tmp[ i ];
if ( i < k.length-1 ) {
out += ',';
}
}
console.log( 'Typed arrays: %s\n', out );
// ----
// Matrices...
mat = matrix( k, [5,2], 'float64' );
out = ekurtosis( mat );
console.log( 'Matrix: %s\n', out.toString() );
// ----
// Matrices (custom output data type)...
out = ekurtosis( mat, {
'dtype': 'uint8'
});
console.log( 'Matrix (%s): %s\n', out.dtype, out.toString() );
|
/* public/core.js */
var angTodo = angular.module('angTodo', []);
function mainController($scope, $http) {
$scope.formData = {};
/* when landing on the page, get all todos and show them */
$http.get('/api/todos')
.success(function(data) {
$scope.todos = data;
console.log(data);
})
.error(function(data) {
console.log('Error: ' + data);
});
/* when submitting the add form, send the text to the node API */
$scope.createTodo = function() {
$http.post('/api/todos', $scope.formData)
.success(function(data) {
$scope.formData = {}; // clear the form so another todo can be entered
$scope.todos = data;
console.log(data);
})
.error(function(data) {
console.log('Error: ' + data);
});
};
/* delete a todo after checking it */
$scope.deleteTodo = function(id) {
$http.delete('/api/todos/' + id)
.success(function(data) {
$scope.todos = data;
console.log(data);
})
.error(function(data) {
console.log('Error: ' + data);
});
};
} /* function mainController */
|
define([], function() {
return function($translateProvider) {
$translateProvider.translations('en', {
WELCOME_TO_PIO: 'Welcome to PIO',
SIGN_IN: 'Sign in',
SIGN_UP: 'Sign up',
SIGN_OUT: 'Sign out',
FORGOT_PASSWORD: 'Forgot password?',
DO_NOT_HAVE_AN_ACCOUNT: 'Do not have an account?',
CREATE_AN_ACCOUNT: 'Create an account',
POLLS: 'Polls',
ADMINISTRATION: 'Administration',
TITLE: 'Title',
USERS: 'Users',
CREATE: 'Create',
DASHBOARD: 'Dashboard',
DETAILS: 'Details',
DETAIL: 'Detail',
CREATE_POLL: 'Create poll',
CREATE_USER: 'Create user',
POLL_DETAILS: 'Poll details',
USER_DETAILS: 'User details',
TAGS: 'Tags',
SUMMARY: 'Summary',
STATUS: 'Status',
NAME: 'Name',
AVATAR: 'Avatar',
POLLINGS: 'Pollings',
NOTES: 'Notes',
EMAIL: 'Email',
DATE: 'Date',
SAVE: 'Save',
CANCEL: 'Cancel'
});
$translateProvider.translations('es', {
WELCOME_TO_PIO: 'Bienvenido a PIO',
SIGN_IN: 'Acceder',
SIGN_UP: 'Registro',
SIGN_OUT: 'Salir',
FORGOT_PASSWORD: '¿Olvidó la contraseña?',
DO_NOT_HAVE_AN_ACCOUNT: '¿No tiene una cuenta?',
CREATE_AN_ACCOUNT: 'Crear un acuenta',
POLLS: 'Encuestas',
ADMINISTRATION: 'Administración',
TITLE: 'Título',
USERS: 'Usuarios',
CREATE: 'Crear',
DASHBOARD: 'Panel',
DETAILS: 'Detalles',
DETAIL: 'Detalle',
CREATE_POLL: 'Crear encuesta',
CREATE_USER: 'Crear usuario',
POLL_DETAILS: 'Detalles de encuesta',
USER_DETAILS: 'Detalles de usuario',
TAGS: 'Etiquetas',
SUMMARY: 'Resumen',
STATUS: 'Estado',
NAME: 'Nombre',
AVATAR: 'Avatar',
POLLINGS: 'Votaciones',
NOTES: 'Notas',
EMAIL: 'Correo',
DATE: 'Fecha',
SAVE: 'Guardar',
CANCEL: 'Cancelar'
});
$translateProvider.useSanitizeValueStrategy('escapeParameters');
$translateProvider.preferredLanguage('es');
};
});
|
{
document.getElementsByClassName('close')[0].addEventListener('click', function() {
window.close();
});
} |
'use strict';
angular.module('com.module.sandbox')
.controller('DatepickerDemoCtrl', function ($scope) {
$scope.today = function () {
$scope.dt = new Date();
};
$scope.today();
$scope.clear = function () {
$scope.dt = null;
};
$scope.disabled = function (date, mode) {
return (mode === 'day' && (date.getDay() === 0 || date.getDay() === 6));
};
$scope.toggleMin = function () {
$scope.minDate = $scope.minDate ? null : new Date();
};
$scope.toggleMin();
$scope.open = function ($event) {
$event.preventDefault();
$event.stopPropagation();
$scope.opened = true;
};
$scope.dateOptions = {
formatYear: 'yy',
startingDay: 1
};
$scope.formats = [
'dd-MMMM-yyyy',
'yyyy/MM/dd',
'dd.MM.yyyy',
'shortDate'
];
$scope.format = $scope.formats[0];
});
|
import Ember from 'ember';
const { computed } = Ember;
let IronSelector = Ember.Component.extend({
attributeBindings: [
'selected',
'role',
'attrForSelected',
'multi'
],
selectedItem: computed({
get() {},
set(key, value) {
let items = this.get('items');
let idx = -1;
if (items) {
idx = this.get('items').indexOf(value);
}
if (this.getSelectedIndex() !== idx && idx !== -1) {
this.set('selected', idx);
}
return value;
}
}),
getSelectedIndex() {
let el = this.element;
if (el) {
return typeof el.selected === 'number' ?
el.selected :
el.indexOf(el.selectedItem);
} else {
return -1;
}
},
didInsertElement() {
this._super(...arguments);
this.$().on('iron-select', () => {
let el = this.element;
let items = this.get('items');
if (items) {
this.set('selectedItem', items[this.getSelectedIndex()]);
} else {
this.set('selectedItem', el.selected);
}
});
// initial selection
let selectedItem = this.get('selectedItem');
if (selectedItem) {
let items = this.get('items');
if (items) {
this.element.select(selectedItem === 'number' ?
selectedItem :
items.indexOf(selectedItem));
} else {
this.element.select(selectedItem === 'number' ?
selectedItem :
this.element.items.indexOf(selectedItem));
}
}
}
});
IronSelector.reopenClass({
positionalParams: [ 'items' ]
});
export default IronSelector;
|
var Component = new Brick.Component();
Component.requires = {
mod: [
{name: '{C#MODNAME}', files: ['mail.js']}
]
};
Component.entryPoint = function(NS){
var Y = Brick.YUI,
COMPONENT = this,
SYS = Brick.mod.sys;
NS.MailTestWidget = Y.Base.create('MailTestWidget', SYS.AppWidget, [], {
onInitAppWidget: function(err, appInstance, options){
},
destructor: function(){
this.hideResult();
},
sendTestMail: function(){
var tp = this.template,
email = tp.getValue('email');
this.set('waiting', true);
this.get('appInstance').mailTestSend(email, function(err, result){
this.set('waiting', false);
if (!err){
this.showResult(result.mailTestSend);
}
}, this);
},
showResult: function(mail){
var tp = this.template;
tp.show('resultPanel');
this._resultMailWidget = new NS.MailViewWidget({
srcNode: tp.append('resultMail', '<div></div>'),
mail: mail
});
},
hideResult: function(){
var widget = this._resultMailWidget;
if (!widget){
return;
}
widget.destroy();
this._resultMailWidget = null;
this.template.hide('resultPanel');
}
}, {
ATTRS: {
component: {value: COMPONENT},
templateBlockName: {value: 'widget'},
},
CLICKS: {
send: 'sendTestMail'
},
});
}; |
export default function reducer (state = {}, action) {
return state;
};
|
/*
var jsonfile = require('jsonfile');
var file = '../data1.json';
var tasksController = require('../public/js/tasks.js');
jsonfile.writeFile(file,data1);
*/
// var User = require('../public/js/mongoUser.js');
var Task = require('../public/js/mongoTasks.js');
var MongoClient = require('mongodb').MongoClient, format = require('util').format;
var dJ = require('../data1.json');
var tasksCount, taskList, groupList;
exports.viewTasks = function(req, res){
MongoClient.connect('mongodb://heroku_2s7m53vj:[email protected]:53677/heroku_2s7m53vj', function(err, db) {
if(err) throw err;
var collection = db.collection('tasks');
var collection2 = db.collection('groups');
// collection.count(function(err, count) {
// //console.log(format("count = %s", count));
// tasksCount = count;
// });
// Locate all the entries using find
collection.find().toArray(function(err, results) {
taskList = results;
});
collection2.find().toArray(function(err,results) {
groupList = results;
// console.dir(groupList);
});
db.close();
})
res.render('tasks', {
dataJson: dJ,
tasks: taskList,
groups: groupList
});
};
exports.updateTasks = function(req,res) {
var name = req.body.name;
var reward = req.body.reward;
var description = req.body.description;
var userSelected = "";
var newTask = new Task({
name: name,
reward: reward,
description: description,
userSelected: userSelected
});
Task.createTask(newTask, function(err,task) {
if(err) throw err;
//console.log(task);
});
res.redirect(req.get('referer'));
// res.redirect('/index');
}
exports.editTasks = function(req,res) {
MongoClient.connect('mongodb://heroku_2s7m53vj:[email protected]:53677/heroku_2s7m53vj', function(err, db) {
if(err) throw err;
var collection = db.collection('tasks');
var oldName = req.body.oldName || req.query.oldName;
var oldReward = req.body.oldReward || req.query.oldReward;
var oldDescription = req.body.oldDescription || req.query.oldDescription;
var taskName = req.body.taskName || req.query.taskName;
var taskReward = req.body.taskReward || req.query.taskReward;
var taskDescription = req.body.taskDescription || req.query.taskDescription;
//console.dir(taskName);
//collection.remove({"name": memberName});
collection.update({'name': oldName},{$set:{'name':taskName}});
collection.update({'reward': parseInt(oldReward)},{$set:{'reward': parseInt(taskReward)}});
collection.update({'description': oldDescription},{$set:{'description':taskDescription}});
db.close()
// Group.removeMember(memberName, function(err,group){
// if(err) throw err;
// console.log(group);
// })
})
res.redirect(req.get('referer'));
}
exports.removeTasks = function(req,res){
MongoClient.connect('mongodb://heroku_2s7m53vj:[email protected]:53677/heroku_2s7m53vj', function(err, db) {
if(err) throw err;
var collection = db.collection('tasks');
var taskName = req.body.taskID || req.query.taskID;
//console.dir(taskName);
collection.remove({ $or: [{"name": taskName}, {"name": ''}] });
db.close()
// Group.removeMember(memberName, function(err,group){
// if(err) throw err;
// console.log(group);
// })
})
res.redirect(req.get('referer'));
}
exports.selectUser = function(req,res){
MongoClient.connect('mongodb://heroku_2s7m53vj:[email protected]:53677/heroku_2s7m53vj', function(err, db) {
if(err) throw err;
var collection = db.collection('tasks');
var selectedUser = req.body.selectedUser || req.query.selectedUser;
var taskName = req.body.taskName || req.query.taskName;
// console.dir(selectedUser);
collection.update({'name': taskName},{$set:{'userSelected': selectedUser}});
db.close()
})
}
|
module.exports = {
flyers: {
testRail: {
projectId: 6,
},
confluence: {
space: '~adam.petrie'
}
}
}
|
'use strict';
const Joi = require('joi');
const uuid = require('uuid');
const reqUtils = require('../utils/requestUtils');
const R = require('ramda');
//fixme: allow unknown fields and just require absolutely mandatory ones
const cucumberSchema = Joi.array().items(Joi.object().keys({
id: Joi.string().required(),
name: Joi.string().required(),
description: Joi.string(),
line: Joi.number().integer(),
keyword: Joi.string(),
uri: Joi.string(),
elements: Joi.array().items(Joi.object().keys({
name: Joi.string().required(),
id: Joi.string().required(),
line: Joi.number().integer(),
keyword: Joi.string(),
description: Joi.string(),
type: Joi.string().required(),
steps: Joi.array().items(Joi.object().keys({
name: Joi.string(),
line: Joi.number().integer(),
keyword: Joi.string(),
result: Joi.object().keys({
status: Joi.string(),
duration: Joi.number().integer()
}),
match: Joi.object().keys({
location: Joi.string()
})
}))
}))
}));
module.exports = function (server, emitter) {
server.route({
method: 'POST',
path: '/upload/cucumber',
config: {
tags: ['upload'],
payload: {
//allow: ['multipart/form-data'],
parse: true,
output: 'stream'
},
validate: {
query: {
evaluation: Joi.string().min(1).required(),
evaluationTag: Joi.string().min(1).required(),
subject: Joi.string().min(1).required()
}
}
},
handler: function(request, reply) {
return reqUtils.getObject(request, 'cucumber')
.then(o => reqUtils.validateObject(o, cucumberSchema))
.then(report => {
emitter.emit(
'uploads/cucumber',
R.assoc('report', report, R.pick(['subject', 'evaluation', 'evaluationTag'], request.query))
);
return reply().code(202);
})
// fixme: this will resolve even internal errors as 429's
// break the initial processing (which returns 429 codes)
// from the final one (which returns 5xx codes)
.catch(e => {
return reply(e.message).code(400);
});
}
});
};
|
'use strict';
/**
* @ngdoc service
* @name publicApp.AuthInterceptor
* @description
* # AuthInterceptor
* Factory in the publicApp.
*/
angular.module('publicApp')
.factory('AuthInterceptor', function(JwtFactory) {
// Public API here
return {
request: function(config) {
config.headers.Authorization = JwtFactory.getJwt();
return config;
}
};
}); |
var accessToken="i7LM4k7JcSKs4ucCpxpgNPcs3i1kRbNKyUE8aPGKZzZWASagz9uZiuLgmgDgBJzY";
$(window).load(function() {
$('#pseudo_submit').click(function() {
NProgress.start();
$.ajax({
type: "POST",
url: "../db-app/signdown.php",
dataType: 'text',
data: {
password: $("#basic_pass").val()
},
complete: function(xhr, statusText){
NProgress.done();
},
success: function (res) {
console.log(res);
if(res.indexOf("ERR")==-1) {
delete_schedule(res);
}
else {
new PNotify({
title: 'Error :(',
text: "Something went wrong",
type: 'error',
styling: 'bootstrap3'
});
}
}
});
});
});
function delete_schedule(id) {
NProgress.start();
var del_url = "https://api.whenhub.com/api/schedules/"+id+"?access_token="+accessToken;
$.ajax({
type: "DELETE",
url: del_url,
complete: function(xhr, statusText){
NProgress.done();
console.log(xhr.status+" "+statusText);
},
success: function (data) {
console.log(data);
window.location.href = "account_deleted.php";
},
error: function(xhr, statusText, err){
console.log(xhr);
console.log(statusText);
console.log(err);
}
});
} |
import React from 'react';
import IconBase from '@suitejs/icon-base';
function MdFlashOn(props) {
return (
<IconBase viewBox="0 0 48 48" {...props}>
<polygon points="14 4 14 26 20 26 20 44 34 20 26 20 34 4" />
</IconBase>
);
}
export default MdFlashOn;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.