https://strg-n.com/assets/js/paper.js

1/*!
2 * Paper.js v0.9.24 - The Swiss Army Knife of Vector Graphics Scripting.
3 * http://paperjs.org/
4 *
5 * Copyright (c) 2011 - 2014, Juerg Lehni & Jonathan Puckey
6 * http://scratchdisk.com/ & http://jonathanpuckey.com/
7 *
8 * Distributed under the MIT license. See LICENSE file for details.
9 *
10 * All rights reserved.
11 *
12 * Date: Fri Aug 21 16:39:41 2015 +0200
13 *
14 ***
15 *
16 * Straps.js - Class inheritance library with support for bean-style accessors
17 *
18 * Copyright (c) 2006 - 2013 Juerg Lehni
19 * http://scratchdisk.com/
20 *
21 * Distributed under the MIT license.
22 *
23 ***
24 *
25 * Acorn.js
26 * http://marijnhaverbeke.nl/acorn/
27 *
28 * Acorn is a tiny, fast JavaScript parser written in JavaScript,
29 * created by Marijn Haverbeke and released under an MIT license.
30 *
31 */
32
33var paper = new function(undefined) {
34
35var Base = new function() {
36	var hidden = /^(statics|enumerable|beans|preserve)$/,
37
38		forEach = [].forEach || function(iter, bind) {
39			for (var i = 0, l = this.length; i < l; i++)
40				iter.call(bind, this[i], i, this);
41		},
42
43		forIn = function(iter, bind) {
44			for (var i in this)
45				if (this.hasOwnProperty(i))
46					iter.call(bind, this[i], i, this);
47		},
48
49		create = Object.create || function(proto) {
50			return { __proto__: proto };
51		},
52
53		describe = Object.getOwnPropertyDescriptor || function(obj, name) {
54			var get = obj.__lookupGetter__ && obj.__lookupGetter__(name);
55			return get
56					? { get: get, set: obj.__lookupSetter__(name),
57						enumerable: true, configurable: true }
58					: obj.hasOwnProperty(name)
59						? { value: obj[name], enumerable: true,
60							configurable: true, writable: true }
61						: null;
62		},
63
64		_define = Object.defineProperty || function(obj, name, desc) {
65			if ((desc.get || desc.set) && obj.__defineGetter__) {
66				if (desc.get)
67					obj.__defineGetter__(name, desc.get);
68				if (desc.set)
69					obj.__defineSetter__(name, desc.set);
70			} else {
71				obj[name] = desc.value;
72			}
73			return obj;
74		},
75
76		define = function(obj, name, desc) {
77			delete obj[name];
78			return _define(obj, name, desc);
79		};
80
81	function inject(dest, src, enumerable, beans, preserve) {
82		var beansNames = {};
83
84		function field(name, val) {
85			val = val || (val = describe(src, name))
86					&& (val.get ? val : val.value);
87			if (typeof val === 'string' && val[0] === '#')
88				val = dest[val.substring(1)] || val;
89			var isFunc = typeof val === 'function',
90				res = val,
91				prev = preserve || isFunc && !val.base
92						? (val && val.get ? name in dest : dest[name])
93						: null,
94				bean;
95			if (!preserve || !prev) {
96				if (isFunc && prev)
97					val.base = prev;
98				if (isFunc && beans !== false
99						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
100					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
101				if (!res || isFunc || !res.get || typeof res.get !== 'function'
102						|| !Base.isPlainObject(res))
103					res = { value: res, writable: true };
104				if ((describe(dest, name)
105						|| { configurable: true }).configurable) {
106					res.configurable = true;
107					res.enumerable = enumerable;
108				}
109				define(dest, name, res);
110			}
111		}
112		if (src) {
113			for (var name in src) {
114				if (src.hasOwnProperty(name) && !hidden.test(name))
115					field(name);
116			}
117			for (var name in beansNames) {
118				var part = beansNames[name],
119					set = dest['set' + part],
120					get = dest['get' + part] || set && dest['is' + part];
121				if (get && (beans === true || get.length === 0))
122					field(name, { get: get, set: set });
123			}
124		}
125		return dest;
126	}
127
128	function each(obj, iter, bind) {
129		if (obj)
130			('length' in obj && !obj.getLength
131					&& typeof obj.length === 'number'
132				? forEach
133				: forIn).call(obj, iter, bind = bind || obj);
134		return bind;
135	}
136
137	function set(obj, props, exclude) {
138		for (var key in props)
139			if (props.hasOwnProperty(key) && !(exclude && exclude[key]))
140				obj[key] = props[key];
141		return obj;
142	}
143
144	return inject(function Base() {
145		for (var i = 0, l = arguments.length; i < l; i++)
146			set(this, arguments[i]);
147	}, {
148		inject: function(src) {
149			if (src) {
150				var statics = src.statics === true ? src : src.statics,
151					beans = src.beans,
152					preserve = src.preserve;
153				if (statics !== src)
154					inject(this.prototype, src, src.enumerable, beans, preserve);
155				inject(this, statics, true, beans, preserve);
156			}
157			for (var i = 1, l = arguments.length; i < l; i++)
158				this.inject(arguments[i]);
159			return this;
160		},
161
162		extend: function() {
163			var base = this,
164				ctor,
165				proto;
166			for (var i = 0, l = arguments.length; i < l; i++)
167				if (ctor = arguments[i].initialize)
168					break;
169			ctor = ctor || function() {
170				base.apply(this, arguments);
171			};
172			proto = ctor.prototype = create(this.prototype);
173			define(proto, 'constructor',
174					{ value: ctor, writable: true, configurable: true });
175			inject(ctor, this, true);
176			if (arguments.length)
177				this.inject.apply(ctor, arguments);
178			ctor.base = base;
179			return ctor;
180		}
181	}, true).inject({
182		inject: function() {
183			for (var i = 0, l = arguments.length; i < l; i++) {
184				var src = arguments[i];
185				if (src)
186					inject(this, src, src.enumerable, src.beans, src.preserve);
187			}
188			return this;
189		},
190
191		extend: function() {
192			var res = create(this);
193			return res.inject.apply(res, arguments);
194		},
195
196		each: function(iter, bind) {
197			return each(this, iter, bind);
198		},
199
200		set: function(props) {
201			return set(this, props);
202		},
203
204		clone: function() {
205			return new this.constructor(this);
206		},
207
208		statics: {
209			each: each,
210			create: create,
211			define: define,
212			describe: describe,
213			set: set,
214
215			clone: function(obj) {
216				return set(new obj.constructor(), obj);
217			},
218
219			isPlainObject: function(obj) {
220				var ctor = obj != null && obj.constructor;
221				return ctor && (ctor === Object || ctor === Base
222						|| ctor.name === 'Object');
223			},
224
225			pick: function(a, b) {
226				return a !== undefined ? a : b;
227			}
228		}
229	});
230};
231
232if (typeof module !== 'undefined')
233	module.exports = Base;
234
235Base.inject({
236	toString: function() {
237		return this._id != null
238			?  (this._class || 'Object') + (this._name
239				? " '" + this._name + "'"
240				: ' @' + this._id)
241			: '{ ' + Base.each(this, function(value, key) {
242				if (!/^_/.test(key)) {
243					var type = typeof value;
244					this.push(key + ': ' + (type === 'number'
245							? Formatter.instance.number(value)
246							: type === 'string' ? "'" + value + "'" : value));
247				}
248			}, []).join(', ') + ' }';
249	},
250
251	getClassName: function() {
252		return this._class || '';
253	},
254
255	exportJSON: function(options) {
256		return Base.exportJSON(this, options);
257	},
258
259	toJSON: function() {
260		return Base.serialize(this);
261	},
262
263	_set: function(props, exclude, dontCheck) {
264		if (props && (dontCheck || Base.isPlainObject(props))) {
265			var keys = Object.keys(props._filtering || props);

266			for (var i = 0, l = keys.length; i < l; i++) {
267				var key = keys[i];
268				if (!(exclude && exclude[key])) {
269					var value = props[key];
270					if (value !== undefined)
271						this[key] = value;
272				}
273			}
274			return true;
275		}
276	},
277
278	statics: {
279
280		exports: {
281			enumerable: true
282		},
283
284		extend: function extend() {
285			var res = extend.base.apply(this, arguments),
286				name = res.prototype._class;
287			if (name && !Base.exports[name])
288				Base.exports[name] = res;
289			return res;
290		},
291
292		equals: function(obj1, obj2) {
293			if (obj1 === obj2)
294				return true;
295			if (obj1 && obj1.equals)
296				return obj1.equals(obj2);
297			if (obj2 && obj2.equals)
298				return obj2.equals(obj1);
299			if (obj1 && obj2
300					&& typeof obj1 === 'object' && typeof obj2 === 'object') {
301				if (Array.isArray(obj1) && Array.isArray(obj2)) {
302					var length = obj1.length;
303					if (length !== obj2.length)
304						return false;
305					while (length--) {
306						if (!Base.equals(obj1[length], obj2[length]))
307							return false;
308					}
309				} else {
310					var keys = Object.keys(obj1),
311						length = keys.length;
312					if (length !== Object.keys(obj2).length)
313						return false;
314					while (length--) {
315						var key = keys[length];
316						if (!(obj2.hasOwnProperty(key)
317								&& Base.equals(obj1[key], obj2[key])))
318							return false;
319					}
320				}
321				return true;
322			}
323			return false;
324		},
325
326		read: function(list, start, options, length) {
327			if (this === Base) {
328				var value = this.peek(list, start);
329				list.__index++;
330				return value;
331			}
332			var proto = this.prototype,
333				readIndex = proto._readIndex,
334				index = start || readIndex && list.__index || 0;
335			if (!length)
336				length = list.length - index;
337			var obj = list[index];
338			if (obj instanceof this
339				|| options && options.readNull && obj == null && length <= 1) {
340				if (readIndex)
341					list.__index = index + 1;
342				return obj && options && options.clone ? obj.clone() : obj;
343			}
344			obj = Base.create(this.prototype);
345			if (readIndex)
346				obj.__read = true;
347			obj = obj.initialize.apply(obj, index > 0 || length < list.length
348				? Array.prototype.slice.call(list, index, index + length)
349				: list) || obj;
350			if (readIndex) {
351				list.__index = index + obj.__read;
352				obj.__read = undefined;
353			}
354			return obj;
355		},
356
357		peek: function(list, start) {
358			return list[list.__index = start || list.__index || 0];
359		},
360
361		remain: function(list) {
362			return list.length - (list.__index || 0);
363		},
364
365		readAll: function(list, start, options) {
366			var res = [],
367				entry;
368			for (var i = start || 0, l = list.length; i < l; i++) {
369				res.push(Array.isArray(entry = list[i])
370						? this.read(entry, 0, options)
371						: this.read(list, i, options, 1));
372			}
373			return res;
374		},
375
376		readNamed: function(list, name, start, options, length) {
377			var value = this.getNamed(list, name),
378				hasObject = value !== undefined;
379			if (hasObject) {
380				var filtered = list._filtered;
381				if (!filtered) {
382					filtered = list._filtered = Base.create(list[0]);
383					filtered._filtering = list[0];
384				}
385				filtered[name] = undefined;
386			}
387			return this.read(hasObject ? [value] : list, start, options, length);
388		},
389
390		getNamed: function(list, name) {
391			var arg = list[0];
392			if (list._hasObject === undefined)
393				list._hasObject = list.length === 1 && Base.isPlainObject(arg);
394			if (list._hasObject)
395				return name ? arg[name] : list._filtered || arg;
396		},
397
398		hasNamed: function(list, name) {
399			return !!this.getNamed(list, name);
400		},
401
402		isPlainValue: function(obj, asString) {
403			return this.isPlainObject(obj) || Array.isArray(obj)
404					|| asString && typeof obj === 'string';
405		},
406
407		serialize: function(obj, options, compact, dictionary) {
408			options = options || {};
409
410			var root = !dictionary,
411				res;
412			if (root) {
413				options.formatter = new Formatter(options.precision);
414				dictionary = {
415					length: 0,
416					definitions: {},
417					references: {},
418					add: function(item, create) {
419						var id = '#' + item._id,
420							ref = this.references[id];
421						if (!ref) {
422							this.length++;
423							var res = create.call(item),
424								name = item._class;
425							if (name && res[0] !== name)
426								res.unshift(name);
427							this.definitions[id] = res;
428							ref = this.references[id] = [id];
429						}
430						return ref;
431					}
432				};
433			}
434			if (obj && obj._serialize) {
435				res = obj._serialize(options, dictionary);
436				var name = obj._class;
437				if (name && !compact && !res._compact && res[0] !== name)
438					res.unshift(name);
439			} else if (Array.isArray(obj)) {
440				res = [];
441				for (var i = 0, l = obj.length; i < l; i++)
442					res[i] = Base.serialize(obj[i], options, compact,
443							dictionary);
444				if (compact)
445					res._compact = true;
446			} else if (Base.isPlainObject(obj)) {
447				res = {};
448				var keys = Object.keys(obj);

449				for (var i = 0, l = keys.length; i < l; i++) {
450					var key = keys[i];
451					res[key] = Base.serialize(obj[key], options, compact,
452							dictionary);
453				}
454			} else if (typeof obj === 'number') {
455				res = options.formatter.number(obj, options.precision);
456			} else {
457				res = obj;
458			}
459			return root && dictionary.length > 0
460					? [['dictionary', dictionary.definitions], res]
461					: res;
462		},
463
464		deserialize: function(json, create, _data, _isDictionary) {
465			var res = json,
466				isRoot = !_data;
467			_data = _data || {};
468			if (Array.isArray(json)) {
469				var type = json[0],
470					isDictionary = type === 'dictionary';
471				if (json.length == 1 && /^#/.test(type))
472					return _data.dictionary[type];
473				type = Base.exports[type];
474				res = [];
475				if (_isDictionary)
476					_data.dictionary = res;
477				for (var i = type ? 1 : 0, l = json.length; i < l; i++)
478					res.push(Base.deserialize(json[i], create, _data,
479							isDictionary));
480				if (type) {
481					var args = res;
482					if (create) {
483						res = create(type, args);
484					} else {
485						res = Base.create(type.prototype);
486						type.apply(res, args);
487					}
488				}
489			} else if (Base.isPlainObject(json)) {
490				res = {};
491				if (_isDictionary)
492					_data.dictionary = res;
493				for (var key in json)
494					res[key] = Base.deserialize(json[key], create, _data);
495			}
496			return isRoot && json && json.length && json[0][0] === 'dictionary'
497					? res[1]
498					: res;
499		},
500
501		exportJSON: function(obj, options) {
502			var json = Base.serialize(obj, options);
503			return options && options.asString === false
504					? json
505					: JSON.stringify(json);
506		},
507
508		importJSON: function(json, target) {
509			return Base.deserialize(
510					typeof json === 'string' ? JSON.parse(json) : json,
511					function(type, args) {
512						var obj = target && target.constructor === type
513								? target
514								: Base.create(type.prototype),
515							isTarget = obj === target;
516						if (args.length === 1 && obj instanceof Item
517								&& (isTarget || !(obj instanceof Layer))) {
518							var arg = args[0];
519							if (Base.isPlainObject(arg))
520								arg.insert = false;
521						}
522						type.apply(obj, args);
523						if (isTarget)
524							target = null;
525						return obj;
526					});
527		},
528
529		splice: function(list, items, index, remove) {
530			var amount = items && items.length,
531				append = index === undefined;
532			index = append ? list.length : index;
533			if (index > list.length)
534				index = list.length;
535			for (var i = 0; i < amount; i++)
536				items[i]._index = index + i;
537			if (append) {
538				list.push.apply(list, items);
539				return [];
540			} else {
541				var args = [index, remove];
542				if (items)
543					args.push.apply(args, items);

544				var removed = list.splice.apply(list, args);
545				for (var i = 0, l = removed.length; i < l; i++)
546					removed[i]._index = undefined;
547				for (var i = index + amount, l = list.length; i < l; i++)
548					list[i]._index = i;
549				return removed;
550			}
551		},
552
553		capitalize: function(str) {
554			return str.replace(/\b[a-z]/g, function(match) {
555				return match.toUpperCase();
556			});
557		},
558
559		camelize: function(str) {
560			return str.replace(/-(.)/g, function(all, chr) {
561				return chr.toUpperCase();
562			});
563		},
564
565		hyphenate: function(str) {
566			return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
567		}
568	}
569});
570
571var Emitter = {
572	on: function(type, func) {
573		if (typeof type !== 'string') {
574			Base.each(type, function(value, key) {
575				this.on(key, value);
576			}, this);
577		} else {
578			var types = this._eventTypes,
579				entry = types && types[type],
580				handlers = this._callbacks = this._callbacks || {};
581			handlers = handlers[type] = handlers[type] || [];
582			if (handlers.indexOf(func) === -1) {
583				handlers.push(func);
584				if (entry && entry.install && handlers.length == 1)
585					entry.install.call(this, type);
586			}
587		}
588		return this;
589	},
590
591	off: function(type, func) {
592		if (typeof type !== 'string') {
593			Base.each(type, function(value, key) {
594				this.off(key, value);
595			}, this);
596			return;
597		}
598		var types = this._eventTypes,
599			entry = types && types[type],
600			handlers = this._callbacks && this._callbacks[type],
601			index;
602		if (handlers) {
603			if (!func || (index = handlers.indexOf(func)) !== -1
604					&& handlers.length === 1) {
605				if (entry && entry.uninstall)
606					entry.uninstall.call(this, type);
607				delete this._callbacks[type];
608			} else if (index !== -1) {
609				handlers.splice(index, 1);
610			}
611		}
612		return this;
613	},
614
615	once: function(type, func) {
616		return this.on(type, function() {
617			func.apply(this, arguments);
618			this.off(type, func);
619		});
620	},
621
622	emit: function(type, event) {
623		var handlers = this._callbacks && this._callbacks[type];
624		if (!handlers)
625			return false;
626		var args = [].slice.call(arguments, 1);
627		handlers = handlers.slice();
628		for (var i = 0, l = handlers.length; i < l; i++) {
629			if (handlers[i].apply(this, args) === false) {
630				if (event && event.stop)
631					event.stop();
632				break;
633			}
634		}
635		return true;
636	},
637
638	responds: function(type) {
639		return !!(this._callbacks && this._callbacks[type]);
640	},
641
642	attach: '#on',
643	detach: '#off',
644	fire: '#emit',
645
646	_installEvents: function(install) {
647		var handlers = this._callbacks,
648			key = install ? 'install' : 'uninstall';
649		for (var type in handlers) {
650			if (handlers[type].length > 0) {
651				var types = this._eventTypes,
652					entry = types && types[type],
653					func = entry && entry[key];
654				if (func)
655					func.call(this, type);
656			}
657		}
658	},
659
660	statics: {
661		inject: function inject(src) {
662			var events = src._events;
663			if (events) {
664				var types = {};
665				Base.each(events, function(entry, key) {
666					var isString = typeof entry === 'string',
667						name = isString ? entry : key,
668						part = Base.capitalize(name),
669						type = name.substring(2).toLowerCase();
670					types[type] = isString ? {} : entry;
671					name = '_' + name;
672					src['get' + part] = function() {
673						return this[name];
674					};
675					src['set' + part] = function(func) {
676						var prev = this[name];
677						if (prev)
678							this.off(type, prev);
679						if (func)
680							this.on(type, func);
681						this[name] = func;
682					};
683				});
684				src._eventTypes = types;
685			}
686			return inject.base.apply(this, arguments);
687		}
688	}
689};
690
691var PaperScope = Base.extend({
692	_class: 'PaperScope',
693
694	initialize: function PaperScope() {
695		paper = this;
696		this.settings = new Base({
697			applyMatrix: true,
698			handleSize: 4,
699			hitTolerance: 0
700		});
701		this.project = null;
702		this.projects = [];
703		this.tools = [];
704		this.palettes = [];
705		this._id = PaperScope._id++;
706		PaperScope._scopes[this._id] = this;
707		var proto = PaperScope.prototype;
708		if (!this.support) {
709			var ctx = CanvasProvider.getContext(1, 1);
710			proto.support = {
711				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
712				nativeBlendModes: BlendMode.nativeModes
713			};
714			CanvasProvider.release(ctx);
715		}
716
717		if (!this.browser) {
718			var agent = navigator.userAgent.toLowerCase(),
719				platform = (/(win)/.exec(agent)
720						|| /(mac)/.exec(agent)
721						|| /(linux)/.exec(agent)
722						|| [])[0],
723				browser = proto.browser = { platform: platform };
724			if (platform)
725				browser[platform] = true;
726			agent.replace(
727				/(opera|chrome|safari|webkit|firefox|msie|trident|atom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:([.\d]+))?/g,
728				function(all, n, v1, v2, rv) {
729					if (!browser.chrome) {
730						var v = n === 'opera' ? v2 : v1;
731						if (n === 'trident') {
732							v = rv;
733							n = 'msie';
734						}
735						browser.version = v;
736						browser.versionNumber = parseFloat(v);
737						browser.name = n;
738						browser[n] = true;
739					}
740				}
741			);
742			if (browser.chrome)
743				delete browser.webkit;
744			if (browser.atom)
745				delete browser.chrome;
746		}
747	},
748
749	version: '0.9.24',
750
751	getView: function() {
752		return this.project && this.project.getView();
753	},
754
755	getPaper: function() {
756		return this;
757	},
758
759	execute: function(code, url, options) {
760		paper.PaperScript.execute(code, this, url, options);
761		View.updateFocus();
762	},
763
764	install: function(scope) {
765		var that = this;
766		Base.each(['project', 'view', 'tool'], function(key) {
767			Base.define(scope, key, {
768				configurable: true,
769				get: function() {

770					return that[key];
771				}
772			});
773		});
774		for (var key in this)
775			if (!/^_/.test(key) && this[key])
776				scope[key] = this[key];
777	},
778
779	setup: function(element) {
780		paper = this;
781		this.project = new Project(element);
782		return this;
783	},
784
785	activate: function() {
786		paper = this;
787	},
788
789	clear: function() {
790		for (var i = this.projects.length - 1; i >= 0; i--)
791			this.projects[i].remove();
792		for (var i = this.tools.length - 1; i >= 0; i--)
793			this.tools[i].remove();
794		for (var i = this.palettes.length - 1; i >= 0; i--)
795			this.palettes[i].remove();
796	},
797
798	remove: function() {
799		this.clear();
800		delete PaperScope._scopes[this._id];
801	},
802
803	statics: new function() {
804		function handleAttribute(name) {
805			name += 'Attribute';
806			return function(el, attr) {
807				return el[name](attr) || el[name]('data-paper-' + attr);
808			};
809		}
810
811		return {
812			_scopes: {},
813			_id: 0,
814
815			get: function(id) {
816				return this._scopes[id] || null;
817			},
818
819			getAttribute: handleAttribute('get'),
820			hasAttribute: handleAttribute('has')
821		};
822	}
823});
824
825var PaperScopeItem = Base.extend(Emitter, {
826
827	initialize: function(activate) {
828		this._scope = paper;
829		this._index = this._scope[this._list].push(this) - 1;
830		if (activate || !this._scope[this._reference])
831			this.activate();
832	},
833
834	activate: function() {
835		if (!this._scope)
836			return false;
837		var prev = this._scope[this._reference];
838		if (prev && prev !== this)
839			prev.emit('deactivate');
840		this._scope[this._reference] = this;
841		this.emit('activate', prev);
842		return true;
843	},
844
845	isActive: function() {
846		return this._scope[this._reference] === this;
847	},
848
849	remove: function() {
850		if (this._index == null)
851			return false;
852		Base.splice(this._scope[this._list], null, this._index, 1);
853		if (this._scope[this._reference] == this)
854			this._scope[this._reference] = null;
855		this._scope = null;
856		return true;
857	}
858});
859
860var Formatter = Base.extend({
861	initialize: function(precision) {
862		this.precision = precision || 5;
863		this.multiplier = Math.pow(10, this.precision);
864	},
865
866	number: function(val) {
867		return Math.round(val * this.multiplier) / this.multiplier;
868	},
869
870	pair: function(val1, val2, separator) {
871		return this.number(val1) + (separator || ',') + this.number(val2);
872	},
873
874	point: function(val, separator) {
875		return this.number(val.x) + (separator || ',') + this.number(val.y);
876	},
877
878	size: function(val, separator) {
879		return this.number(val.width) + (separator || ',')
880				+ this.number(val.height);
881	},
882
883	rectangle: function(val, separator) {
884		return this.point(val, separator) + (separator || ',')
885				+ this.size(val, separator);
886	}
887});
888
889Formatter.instance = new Formatter();
890
891var Numerical = new function() {
892
893	var abscissas = [
894		[  0.5773502691896257645091488],
895		[0,0.7745966692414833770358531],
896		[  0.3399810435848562648026658,0.8611363115940525752239465],
897		[0,0.5384693101056830910363144,0.9061798459386639927976269],
898		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
899		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
900		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
901		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
902		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
903		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
904		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
905		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
906		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
907		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
908		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
909	];
910
911	var weights = [
912		[1],
913		[0.8888888888888888888888889,0.5555555555555555555555556],
914		[0.6521451548625461426269361,0.3478548451374538573730639],
915		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
916		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],

917		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
918		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
919		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
920		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
921		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
922		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
923		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
924		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
925		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
926		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
927	];
928
929	var abs = Math.abs,
930		sqrt = Math.sqrt,
931		pow = Math.pow,
932		TOLERANCE = 1e-6,
933		EPSILON = 1e-12,
934		MACHINE_EPSILON = 1.12e-16;
935
936	return {
937		TOLERANCE: TOLERANCE,
938		EPSILON: EPSILON,
939		MACHINE_EPSILON: MACHINE_EPSILON,
940		KAPPA: 4 * (sqrt(2) - 1) / 3,
941
942		isZero: function(val) {
943			return abs(val) <= EPSILON;
944		},
945
946		integrate: function(f, a, b, n) {
947			var x = abscissas[n - 2],
948				w = weights[n - 2],
949				A = (b - a) * 0.5,
950				B = A + a,
951				i = 0,
952				m = (n + 1) >> 1,
953				sum = n & 1 ? w[i++] * f(B) : 0;
954			while (i < m) {
955				var Ax = A * x[i];
956				sum += w[i++] * (f(B + Ax) + f(B - Ax));
957			}
958			return A * sum;
959		},
960
961		findRoot: function(f, df, x, a, b, n, tolerance) {
962			for (var i = 0; i < n; i++) {
963				var fx = f(x),
964					dx = fx / df(x),
965					nx = x - dx;
966				if (abs(dx) < tolerance)
967					return nx;
968				if (fx > 0) {
969					b = x;
970					x = nx <= a ? (a + b) * 0.5 : nx;
971				} else {
972					a = x;
973					x = nx >= b ? (a + b) * 0.5 : nx;
974				}
975			}
976			return x;
977		},
978
979		solveQuadratic: function(a, b, c, roots, min, max) {
980			var count = 0,
981				x1, x2 = Infinity,
982				B = b,
983				D;
984			b /= 2;
985			D = b * b - a * c;
986			if (D !== 0 && abs(D) < MACHINE_EPSILON) {
987				var gmC = pow(abs(a * b * c), 1 / 3);
988				if (gmC < 1e-8) {
989					var mult = pow(10, abs(
990						Math.floor(Math.log(gmC) * Math.LOG10E)));
991					if (!isFinite(mult))
992						mult = 0;
993					a *= mult;
994					b *= mult;
995					c *= mult;
996					D = b * b - a * c;
997				}
998			}

999			if (abs(a) < EPSILON) {
1000				if (abs(B) < EPSILON)
1001					return abs(c) < EPSILON ? -1 : 0;
1002				x1 = -c / B;
1003			} else {
1004				if (D >= -MACHINE_EPSILON) {
1005					D = D < 0 ? 0 : D;
1006					var R = sqrt(D);
1007					if (b >= MACHINE_EPSILON && b <= MACHINE_EPSILON) {
1008						x1 = abs(a) >= abs(c) ? R / a : -c / R;
1009						x2 = -x1;
1010					} else {
1011						var q = -(b + (b < 0 ? -1 : 1) * R);
1012						x1 = q / a;
1013						x2 = c / q;
1014					}
1015				}
1016			}
1017			if (isFinite(x1) && (min == null || x1 >= min && x1 <= max))
1018				roots[count++] = x1;
1019			if (x2 !== x1
1020					&& isFinite(x2) && (min == null || x2 >= min && x2 <= max))
1021				roots[count++] = x2;
1022			return count;
1023		},
1024
1025		solveCubic: function(a, b, c, d, roots, min, max) {
1026			var count = 0,
1027				x, b1, c2;
1028			if (abs(a) < EPSILON) {
1029				a = b;
1030				b1 = c;
1031				c2 = d;
1032				x = Infinity;
1033			} else if (abs(d) < EPSILON) {
1034				b1 = b;
1035				c2 = c;
1036				x = 0;
1037			} else {
1038				var ec = 1 + MACHINE_EPSILON,
1039					x0, q, qd, t, r, s, tmp;
1040				x = -(b / a) / 3;
1041				tmp = a * x,
1042				b1 = tmp + b,
1043				c2 = b1 * x + c,
1044				qd = (tmp + b1) * x + c2,
1045				q = c2 * x + d;
1046				t = q /a;
1047				r = pow(abs(t), 1/3);
1048				s = t < 0 ? -1 : 1;
1049				t = -qd / a;
1050				r = t > 0 ? 1.3247179572 * Math.max(r, sqrt(t)) : r;
1051				x0 = x - s * r;
1052				if (x0 !== x) {
1053					do {
1054						x = x0;
1055						tmp = a * x,
1056						b1 = tmp + b,
1057						c2 = b1 * x + c,
1058						qd = (tmp + b1) * x + c2,
1059						q = c2 * x + d;
1060						x0 = qd === 0 ? x : x - q / qd / ec;
1061						if (x0 === x) {
1062							x = x0;
1063							break;
1064						}
1065					} while (s * x0 > s * x);
1066					if (abs(a) * x * x > abs(d / x)) {
1067						c2 = -d / x;
1068						b1 = (c2 - c) / x;
1069					}
1070				}
1071			}
1072			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max);
1073			if (isFinite(x) && (count === 0 || x !== roots[count - 1])
1074					&& (min == null || x >= min && x <= max))
1075				roots[count++] = x;
1076			return count;
1077		}
1078	};
1079};
1080
1081var UID = {
1082	_id: 1,
1083	_pools: {},
1084
1085	get: function(ctor) {
1086		if (ctor) {
1087			var name = ctor._class,
1088				pool = this._pools[name];
1089			if (!pool)
1090				pool = this._pools[name] = { _id: 1 };
1091			return pool._id++;
1092		} else {
1093			return this._id++;
1094		}
1095	}
1096};
1097
1098var Point = Base.extend({
1099	_class: 'Point',
1100	_readIndex: true,
1101
1102	initialize: function Point(arg0, arg1) {
1103		var type = typeof arg0;
1104		if (type === 'number') {
1105			var hasY = typeof arg1 === 'number';
1106			this.x = arg0;
1107			this.y = hasY ? arg1 : arg0;
1108			if (this.__read)
1109				this.__read = hasY ? 2 : 1;
1110		} else if (type === 'undefined' || arg0 === null) {
1111			this.x = this.y = 0;
1112			if (this.__read)
1113				this.__read = arg0 === null ? 1 : 0;
1114		} else {
1115			if (Array.isArray(arg0)) {
1116				this.x = arg0[0];
1117				this.y = arg0.length > 1 ? arg0[1] : arg0[0];
1118			} else if (arg0.x != null) {
1119				this.x = arg0.x;
1120				this.y = arg0.y;
1121			} else if (arg0.width != null) {
1122				this.x = arg0.width;
1123				this.y = arg0.height;
1124			} else if (arg0.angle != null) {
1125				this.x = arg0.length;
1126				this.y = 0;
1127				this.setAngle(arg0.angle);
1128			} else {
1129				this.x = this.y = 0;
1130				if (this.__read)
1131					this.__read = 0;
1132			}
1133			if (this.__read)
1134				this.__read = 1;
1135		}
1136	},
1137
1138	set: function(x, y) {
1139		this.x = x;
1140		this.y = y;
1141		return this;
1142	},
1143
1144	equals: function(point) {
1145		return this === point || point
1146				&& (this.x === point.x && this.y === point.y
1147					|| Array.isArray(point)
1148						&& this.x === point[0] && this.y === point[1])
1149				|| false;
1150	},
1151
1152	clone: function() {
1153		return new Point(this.x, this.y);
1154	},
1155
1156	toString: function() {
1157		var f = Formatter.instance;
1158		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
1159	},
1160
1161	_serialize: function(options) {
1162		var f = options.formatter;
1163		return [f.number(this.x), f.number(this.y)];
1164	},
1165
1166	getLength: function() {
1167		return Math.sqrt(this.x * this.x + this.y * this.y);
1168	},
1169
1170	setLength: function(length) {
1171		if (this.isZero()) {
1172			var angle = this._angle || 0;
1173			this.set(
1174				Math.cos(angle) * length,
1175				Math.sin(angle) * length
1176			);
1177		} else {
1178			var scale = length / this.getLength();
1179			if (Numerical.isZero(scale))
1180				this.getAngle();
1181			this.set(
1182				this.x * scale,
1183				this.y * scale
1184			);
1185		}
1186	},
1187	getAngle: function() {
1188		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
1189	},
1190
1191	setAngle: function(angle) {
1192		this.setAngleInRadians.call(this, angle * Math.PI / 180);
1193	},
1194
1195	getAngleInDegrees: '#getAngle',
1196	setAngleInDegrees: '#setAngle',
1197
1198	getAngleInRadians: function() {
1199		if (!arguments.length) {
1200			return this.isZero()
1201					? this._angle || 0
1202					: this._angle = Math.atan2(this.y, this.x);
1203		} else {
1204			var point = Point.read(arguments),
1205				div = this.getLength() * point.getLength();
1206			if (Numerical.isZero(div)) {
1207				return NaN;
1208			} else {
1209				var a = this.dot(point) / div;
1210				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
1211			}
1212		}
1213	},
1214
1215	setAngleInRadians: function(angle) {
1216		this._angle = angle;
1217		if (!this.isZero()) {
1218			var length = this.getLength();
1219			this.set(
1220				Math.cos(angle) * length,
1221				Math.sin(angle) * length
1222			);
1223		}
1224	},
1225
1226	getQuadrant: function() {
1227		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
1228	}
1229}, {

1230	beans: false,
1231
1232	getDirectedAngle: function() {
1233		var point = Point.read(arguments);
1234		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
1235	},
1236
1237	getDistance: function() {
1238		var point = Point.read(arguments),
1239			x = point.x - this.x,
1240			y = point.y - this.y,
1241			d = x * x + y * y,
1242			squared = Base.read(arguments);
1243		return squared ? d : Math.sqrt(d);
1244	},
1245
1246	normalize: function(length) {
1247		if (length === undefined)
1248			length = 1;
1249		var current = this.getLength(),
1250			scale = current !== 0 ? length / current : 0,
1251			point = new Point(this.x * scale, this.y * scale);
1252		if (scale >= 0)
1253			point._angle = this._angle;
1254		return point;
1255	},
1256
1257	rotate: function(angle, center) {
1258		if (angle === 0)
1259			return this.clone();
1260		angle = angle * Math.PI / 180;
1261		var point = center ? this.subtract(center) : this,
1262			s = Math.sin(angle),
1263			c = Math.cos(angle);
1264		point = new Point(
1265			point.x * c - point.y * s,
1266			point.x * s + point.y * c
1267		);
1268		return center ? point.add(center) : point;
1269	},
1270
1271	transform: function(matrix) {
1272		return matrix ? matrix._transformPoint(this) : this;
1273	},
1274
1275	add: function() {
1276		var point = Point.read(arguments);
1277		return new Point(this.x + point.x, this.y + point.y);
1278	},
1279
1280	subtract: function() {
1281		var point = Point.read(arguments);
1282		return new Point(this.x - point.x, this.y - point.y);
1283	},
1284
1285	multiply: function() {
1286		var point = Point.read(arguments);
1287		return new Point(this.x * point.x, this.y * point.y);
1288	},
1289
1290	divide: function() {
1291		var point = Point.read(arguments);
1292		return new Point(this.x / point.x, this.y / point.y);
1293	},
1294
1295	modulo: function() {
1296		var point = Point.read(arguments);
1297		return new Point(this.x % point.x, this.y % point.y);
1298	},
1299
1300	negate: function() {
1301		return new Point(-this.x, -this.y);
1302	},
1303
1304	isInside: function() {
1305		return Rectangle.read(arguments).contains(this);
1306	},
1307
1308	isClose: function(point, tolerance) {
1309		return this.getDistance(point) < tolerance;
1310	},
1311
1312	isCollinear: function(point) {
1313		return Math.abs(this.cross(point)) < 0.000001;
1314	},
1315
1316	isColinear: '#isCollinear',
1317
1318	isOrthogonal: function(point) {
1319		return Math.abs(this.dot(point)) < 0.000001;
1320	},
1321
1322	isZero: function() {
1323		return Numerical.isZero(this.x) && Numerical.isZero(this.y);
1324	},
1325
1326	isNaN: function() {
1327		return isNaN(this.x) || isNaN(this.y);
1328	},
1329
1330	dot: function() {
1331		var point = Point.read(arguments);
1332		return this.x * point.x + this.y * point.y;
1333	},
1334
1335	cross: function() {
1336		var point = Point.read(arguments);
1337		return this.x * point.y - this.y * point.x;
1338	},
1339
1340	project: function() {
1341		var point = Point.read(arguments);
1342		if (point.isZero()) {
1343			return new Point(0, 0);
1344		} else {
1345			var scale = this.dot(point) / point.dot(point);
1346			return new Point(
1347				point.x * scale,
1348				point.y * scale
1349			);
1350		}
1351	},
1352
1353	statics: {
1354		min: function() {
1355			var point1 = Point.read(arguments),
1356				point2 = Point.read(arguments);
1357			return new Point(
1358				Math.min(point1.x, point2.x),
1359				Math.min(point1.y, point2.y)
1360			);
1361		},
1362
1363		max: function() {
1364			var point1 = Point.read(arguments),
1365				point2 = Point.read(arguments);
1366			return new Point(
1367				Math.max(point1.x, point2.x),
1368				Math.max(point1.y, point2.y)
1369			);
1370		},
1371
1372		random: function() {
1373			return new Point(Math.random(), Math.random());
1374		}
1375	}
1376}, Base.each(['round', 'ceil', 'floor', 'abs'], function(name) {
1377	var op = Math[name];
1378	this[name] = function() {
1379		return new Point(op(this.x), op(this.y));
1380	};
1381}, {}));
1382
1383var LinkedPoint = Point.extend({
1384	initialize: function Point(x, y, owner, setter) {
1385		this._x = x;
1386		this._y = y;
1387		this._owner = owner;
1388		this._setter = setter;
1389	},
1390
1391	set: function(x, y, _dontNotify) {
1392		this._x = x;
1393		this._y = y;
1394		if (!_dontNotify)
1395			this._owner[this._setter](this);
1396		return this;
1397	},
1398
1399	getX: function() {
1400		return this._x;
1401	},
1402
1403	setX: function(x) {
1404		this._x = x;
1405		this._owner[this._setter](this);
1406	},
1407
1408	getY: function() {
1409		return this._y;
1410	},
1411
1412	setY: function(y) {
1413		this._y = y;
1414		this._owner[this._setter](this);
1415	}
1416});
1417
1418var Size = Base.extend({
1419	_class: 'Size',
1420	_readIndex: true,
1421
1422	initialize: function Size(arg0, arg1) {
1423		var type = typeof arg0;
1424		if (type === 'number') {
1425			var hasHeight = typeof arg1 === 'number';
1426			this.width = arg0;
1427			this.height = hasHeight ? arg1 : arg0;
1428			if (this.__read)
1429				this.__read = hasHeight ? 2 : 1;
1430		} else if (type === 'undefined' || arg0 === null) {
1431			this.width = this.height = 0;
1432			if (this.__read)
1433				this.__read = arg0 === null ? 1 : 0;
1434		} else {
1435			if (Array.isArray(arg0)) {
1436				this.width = arg0[0];
1437				this.height = arg0.length > 1 ? arg0[1] : arg0[0];
1438			} else if (arg0.width != null) {
1439				this.width = arg0.width;
1440				this.height = arg0.height;
1441			} else if (arg0.x != null) {
1442				this.width = arg0.x;
1443				this.height = arg0.y;
1444			} else {
1445				this.width = this.height = 0;
1446				if (this.__read)
1447					this.__read = 0;
1448			}
1449			if (this.__read)
1450				this.__read = 1;
1451		}
1452	},
1453
1454	set: function(width, height) {
1455		this.width = width;
1456		this.height = height;
1457		return this;
1458	},
1459
1460	equals: function(size) {
1461		return size === this || size && (this.width === size.width
1462				&& this.height === size.height
1463				|| Array.isArray(size) && this.width === size[0]
1464					&& this.height === size[1]) || false;
1465	},
1466
1467	clone: function() {
1468		return new Size(this.width, this.height);
1469	},
1470
1471	toString: function() {
1472		var f = Formatter.instance;
1473		return '{ width: ' + f.number(this.width)
1474				+ ', height: ' + f.number(this.height) + ' }';
1475	},
1476

1477	_serialize: function(options) {
1478		var f = options.formatter;
1479		return [f.number(this.width),
1480				f.number(this.height)];
1481	},
1482
1483	add: function() {
1484		var size = Size.read(arguments);
1485		return new Size(this.width + size.width, this.height + size.height);
1486	},
1487
1488	subtract: function() {
1489		var size = Size.read(arguments);
1490		return new Size(this.width - size.width, this.height - size.height);
1491	},
1492
1493	multiply: function() {
1494		var size = Size.read(arguments);
1495		return new Size(this.width * size.width, this.height * size.height);
1496	},
1497
1498	divide: function() {
1499		var size = Size.read(arguments);
1500		return new Size(this.width / size.width, this.height / size.height);
1501	},
1502
1503	modulo: function() {
1504		var size = Size.read(arguments);
1505		return new Size(this.width % size.width, this.height % size.height);
1506	},
1507
1508	negate: function() {
1509		return new Size(-this.width, -this.height);
1510	},
1511
1512	isZero: function() {
1513		return Numerical.isZero(this.width) && Numerical.isZero(this.height);
1514	},
1515
1516	isNaN: function() {
1517		return isNaN(this.width) || isNaN(this.height);
1518	},
1519
1520	statics: {
1521		min: function(size1, size2) {
1522			return new Size(
1523				Math.min(size1.width, size2.width),
1524				Math.min(size1.height, size2.height));
1525		},
1526
1527		max: function(size1, size2) {
1528			return new Size(
1529				Math.max(size1.width, size2.width),
1530				Math.max(size1.height, size2.height));
1531		},
1532
1533		random: function() {
1534			return new Size(Math.random(), Math.random());
1535		}
1536	}
1537}, Base.each(['round', 'ceil', 'floor', 'abs'], function(name) {
1538	var op = Math[name];
1539	this[name] = function() {
1540		return new Size(op(this.width), op(this.height));
1541	};
1542}, {}));
1543
1544var LinkedSize = Size.extend({
1545	initialize: function Size(width, height, owner, setter) {
1546		this._width = width;
1547		this._height = height;
1548		this._owner = owner;
1549		this._setter = setter;
1550	},
1551
1552	set: function(width, height, _dontNotify) {
1553		this._width = width;
1554		this._height = height;
1555		if (!_dontNotify)
1556			this._owner[this._setter](this);
1557		return this;
1558	},
1559
1560	getWidth: function() {
1561		return this._width;
1562	},
1563
1564	setWidth: function(width) {
1565		this._width = width;
1566		this._owner[this._setter](this);
1567	},
1568
1569	getHeight: function() {
1570		return this._height;
1571	},
1572
1573	setHeight: function(height) {
1574		this._height = height;
1575		this._owner[this._setter](this);
1576	}
1577});
1578
1579var Rectangle = Base.extend({
1580	_class: 'Rectangle',
1581	_readIndex: true,
1582	beans: true,
1583
1584	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
1585		var type = typeof arg0,
1586			read = 0;
1587		if (type === 'number') {
1588			this.x = arg0;
1589			this.y = arg1;
1590			this.width = arg2;
1591			this.height = arg3;
1592			read = 4;
1593		} else if (type === 'undefined' || arg0 === null) {
1594			this.x = this.y = this.width = this.height = 0;
1595			read = arg0 === null ? 1 : 0;
1596		} else if (arguments.length === 1) {
1597			if (Array.isArray(arg0)) {
1598				this.x = arg0[0];
1599				this.y = arg0[1];
1600				this.width = arg0[2];
1601				this.height = arg0[3];
1602				read = 1;
1603			} else if (arg0.x !== undefined || arg0.width !== undefined) {
1604				this.x = arg0.x || 0;
1605				this.y = arg0.y || 0;
1606				this.width = arg0.width || 0;
1607				this.height = arg0.height || 0;
1608				read = 1;
1609			} else if (arg0.from === undefined && arg0.to === undefined) {
1610				this.x = this.y = this.width = this.height = 0;
1611				this._set(arg0);
1612				read = 1;
1613			}
1614		}
1615		if (!read) {
1616			var point = Point.readNamed(arguments, 'from'),
1617				next = Base.peek(arguments);
1618			this.x = point.x;
1619			this.y = point.y;
1620			if (next && next.x !== undefined || Base.hasNamed(arguments, 'to')) {
1621				var to = Point.readNamed(arguments, 'to');
1622				this.width = to.x - point.x;
1623				this.height = to.y - point.y;
1624				if (this.width < 0) {
1625					this.x = to.x;
1626					this.width = -this.width;
1627				}
1628				if (this.height < 0) {
1629					this.y = to.y;
1630					this.height = -this.height;
1631				}
1632			} else {
1633				var size = Size.read(arguments);
1634				this.width = size.width;
1635				this.height = size.height;
1636			}
1637			read = arguments.__index;
1638		}
1639		if (this.__read)
1640			this.__read = read;
1641	},
1642
1643	set: function(x, y, width, height) {
1644		this.x = x;
1645		this.y = y;
1646		this.width = width;
1647		this.height = height;
1648		return this;
1649	},
1650
1651	clone: function() {
1652		return new Rectangle(this.x, this.y, this.width, this.height);
1653	},
1654
1655	equals: function(rect) {
1656		var rt = Base.isPlainValue(rect)
1657				? Rectangle.read(arguments)
1658				: rect;
1659		return rt === this
1660				|| rt && this.x === rt.x && this.y === rt.y
1661					&& this.width === rt.width && this.height === rt.height
1662				|| false;
1663	},
1664
1665	toString: function() {
1666		var f = Formatter.instance;
1667		return '{ x: ' + f.number(this.x)
1668				+ ', y: ' + f.number(this.y)
1669				+ ', width: ' + f.number(this.width)
1670				+ ', height: ' + f.number(this.height)
1671				+ ' }';
1672	},
1673

1674	_serialize: function(options) {
1675		var f = options.formatter;
1676		return [f.number(this.x),
1677				f.number(this.y),
1678				f.number(this.width),
1679				f.number(this.height)];
1680	},
1681
1682	getPoint: function(_dontLink) {
1683		var ctor = _dontLink ? Point : LinkedPoint;
1684		return new ctor(this.x, this.y, this, 'setPoint');
1685	},
1686
1687	setPoint: function() {
1688		var point = Point.read(arguments);
1689		this.x = point.x;
1690		this.y = point.y;
1691	},
1692
1693	getSize: function(_dontLink) {
1694		var ctor = _dontLink ? Size : LinkedSize;
1695		return new ctor(this.width, this.height, this, 'setSize');
1696	},
1697
1698	setSize: function() {
1699		var size = Size.read(arguments);
1700		if (this._fixX)
1701			this.x += (this.width - size.width) * this._fixX;
1702		if (this._fixY)
1703			this.y += (this.height - size.height) * this._fixY;
1704		this.width = size.width;
1705		this.height = size.height;
1706		this._fixW = 1;
1707		this._fixH = 1;
1708	},
1709
1710	getLeft: function() {
1711		return this.x;
1712	},
1713
1714	setLeft: function(left) {
1715		if (!this._fixW)
1716			this.width -= left - this.x;
1717		this.x = left;
1718		this._fixX = 0;
1719	},
1720
1721	getTop: function() {
1722		return this.y;
1723	},
1724
1725	setTop: function(top) {
1726		if (!this._fixH)
1727			this.height -= top - this.y;
1728		this.y = top;
1729		this._fixY = 0;
1730	},
1731
1732	getRight: function() {
1733		return this.x + this.width;
1734	},
1735
1736	setRight: function(right) {
1737		if (this._fixX !== undefined && this._fixX !== 1)
1738			this._fixW = 0;
1739		if (this._fixW)
1740			this.x = right - this.width;
1741		else
1742			this.width = right - this.x;
1743		this._fixX = 1;
1744	},
1745
1746	getBottom: function() {
1747		return this.y + this.height;
1748	},
1749
1750	setBottom: function(bottom) {
1751		if (this._fixY !== undefined && this._fixY !== 1)
1752			this._fixH = 0;
1753		if (this._fixH)
1754			this.y = bottom - this.height;
1755		else
1756			this.height = bottom - this.y;
1757		this._fixY = 1;
1758	},
1759
1760	getCenterX: function() {
1761		return this.x + this.width * 0.5;
1762	},
1763
1764	setCenterX: function(x) {
1765		this.x = x - this.width * 0.5;
1766		this._fixX = 0.5;
1767	},
1768
1769	getCenterY: function() {
1770		return this.y + this.height * 0.5;
1771	},
1772
1773	setCenterY: function(y) {
1774		this.y = y - this.height * 0.5;
1775		this._fixY = 0.5;
1776	},
1777
1778	getCenter: function(_dontLink) {
1779		var ctor = _dontLink ? Point : LinkedPoint;
1780		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
1781	},
1782
1783	setCenter: function() {
1784		var point = Point.read(arguments);
1785		this.setCenterX(point.x);
1786		this.setCenterY(point.y);
1787		return this;
1788	},
1789
1790	getArea: function() {
1791		return this.width * this.height;
1792	},
1793
1794	isEmpty: function() {
1795		return this.width === 0 || this.height === 0;
1796	},
1797
1798	contains: function(arg) {
1799		return arg && arg.width !== undefined
1800				|| (Array.isArray(arg) ? arg : arguments).length == 4
1801				? this._containsRectangle(Rectangle.read(arguments))
1802				: this._containsPoint(Point.read(arguments));
1803	},
1804
1805	_containsPoint: function(point) {
1806		var x = point.x,
1807			y = point.y;
1808		return x >= this.x && y >= this.y
1809				&& x <= this.x + this.width
1810				&& y <= this.y + this.height;
1811	},
1812
1813	_containsRectangle: function(rect) {
1814		var x = rect.x,
1815			y = rect.y;
1816		return x >= this.x && y >= this.y
1817				&& x + rect.width <= this.x + this.width
1818				&& y + rect.height <= this.y + this.height;
1819	},
1820
1821	intersects: function() {
1822		var rect = Rectangle.read(arguments);
1823		return rect.x + rect.width > this.x
1824				&& rect.y + rect.height > this.y
1825				&& rect.x < this.x + this.width
1826				&& rect.y < this.y + this.height;
1827	},
1828
1829	touches: function() {
1830		var rect = Rectangle.read(arguments);
1831		return rect.x + rect.width >= this.x
1832				&& rect.y + rect.height >= this.y
1833				&& rect.x <= this.x + this.width
1834				&& rect.y <= this.y + this.height;
1835	},
1836
1837	intersect: function() {
1838		var rect = Rectangle.read(arguments),
1839			x1 = Math.max(this.x, rect.x),
1840			y1 = Math.max(this.y, rect.y),
1841			x2 = Math.min(this.x + this.width, rect.x + rect.width),
1842			y2 = Math.min(this.y + this.height, rect.y + rect.height);
1843		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
1844	},
1845
1846	unite: function() {
1847		var rect = Rectangle.read(arguments),
1848			x1 = Math.min(this.x, rect.x),
1849			y1 = Math.min(this.y, rect.y),
1850			x2 = Math.max(this.x + this.width, rect.x + rect.width),
1851			y2 = Math.max(this.y + this.height, rect.y + rect.height);
1852		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
1853	},
1854
1855	include: function() {
1856		var point = Point.read(arguments);
1857		var x1 = Math.min(this.x, point.x),
1858			y1 = Math.min(this.y, point.y),
1859			x2 = Math.max(this.x + this.width, point.x),
1860			y2 = Math.max(this.y + this.height, point.y);
1861		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
1862	},
1863
1864	expand: function() {
1865		var amount = Size.read(arguments),
1866			hor = amount.width,
1867			ver = amount.height;
1868		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
1869				this.width + hor, this.height + ver);
1870	},
1871
1872	scale: function(hor, ver) {
1873		return this.expand(this.width * hor - this.width,
1874				this.height * (ver === undefined ? hor : ver) - this.height);
1875	}
1876}, Base.each([
1877		['Top', 'Left'], ['Top', 'Right'],
1878		['Bottom', 'Left'], ['Bottom', 'Right'],
1879		['Left', 'Center'], ['Top', 'Center'],
1880		['Right', 'Center'], ['Bottom', 'Center']
1881	],
1882	function(parts, index) {
1883		var part = parts.join('');
1884		var xFirst = /^[RL]/.test(part);
1885		if (index >= 4)
1886			parts[1] += xFirst ? 'Y' : 'X';
1887		var x = parts[xFirst ? 0 : 1],
1888			y = parts[xFirst ? 1 : 0],
1889			getX = 'get' + x,
1890			getY = 'get' + y,
1891			setX = 'set' + x,
1892			setY = 'set' + y,
1893			get = 'get' + part,
1894			set = 'set' + part;

1895		this[get] = function(_dontLink) {
1896			var ctor = _dontLink ? Point : LinkedPoint;
1897			return new ctor(this[getX](), this[getY](), this, set);
1898		};
1899		this[set] = function() {
1900			var point = Point.read(arguments);
1901			this[setX](point.x);
1902			this[setY](point.y);
1903		};
1904	}, {
1905		beans: true
1906	}
1907));
1908
1909var LinkedRectangle = Rectangle.extend({
1910	initialize: function Rectangle(x, y, width, height, owner, setter) {
1911		this.set(x, y, width, height, true);
1912		this._owner = owner;
1913		this._setter = setter;
1914	},
1915
1916	set: function(x, y, width, height, _dontNotify) {
1917		this._x = x;
1918		this._y = y;
1919		this._width = width;
1920		this._height = height;
1921		if (!_dontNotify)
1922			this._owner[this._setter](this);
1923		return this;
1924	}
1925}, new function() {
1926	var proto = Rectangle.prototype;
1927
1928	return Base.each(['x', 'y', 'width', 'height'], function(key) {
1929		var part = Base.capitalize(key);
1930		var internal = '_' + key;
1931		this['get' + part] = function() {
1932			return this[internal];
1933		};
1934
1935		this['set' + part] = function(value) {
1936			this[internal] = value;
1937			if (!this._dontNotify)
1938				this._owner[this._setter](this);
1939		};
1940	}, Base.each(['Point', 'Size', 'Center',
1941			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
1942			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
1943			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
1944		function(key) {
1945			var name = 'set' + key;
1946			this[name] = function() {
1947				this._dontNotify = true;
1948				proto[name].apply(this, arguments);
1949				this._dontNotify = false;
1950				this._owner[this._setter](this);
1951			};
1952		}, {
1953			isSelected: function() {
1954				return this._owner._boundsSelected;
1955			},
1956
1957			setSelected: function(selected) {
1958				var owner = this._owner;
1959				if (owner.setSelected) {
1960					owner._boundsSelected = selected;
1961					owner.setSelected(selected || owner._selectedSegmentState > 0);
1962				}
1963			}
1964		})
1965	);
1966});
1967
1968var Matrix = Base.extend({
1969	_class: 'Matrix',
1970
1971	initialize: function Matrix(arg) {
1972		var count = arguments.length,
1973			ok = true;
1974		if (count === 6) {
1975			this.set.apply(this, arguments);
1976		} else if (count === 1) {
1977			if (arg instanceof Matrix) {
1978				this.set(arg._a, arg._c, arg._b, arg._d, arg._tx, arg._ty);
1979			} else if (Array.isArray(arg)) {
1980				this.set.apply(this, arg);
1981			} else {
1982				ok = false;
1983			}
1984		} else if (count === 0) {
1985			this.reset();
1986		} else {
1987			ok = false;
1988		}
1989		if (!ok)
1990			throw new Error('Unsupported matrix parameters');
1991	},
1992
1993	set: function(a, c, b, d, tx, ty, _dontNotify) {
1994		this._a = a;
1995		this._c = c;
1996		this._b = b;
1997		this._d = d;
1998		this._tx = tx;
1999		this._ty = ty;
2000		if (!_dontNotify)
2001			this._changed();
2002		return this;
2003	},
2004
2005	_serialize: function(options) {
2006		return Base.serialize(this.getValues(), options);
2007	},
2008
2009	_changed: function() {
2010		var owner = this._owner;
2011		if (owner) {
2012			if (owner._applyMatrix) {
2013				owner.transform(null, true);
2014			} else {
2015				owner._changed(9);
2016			}
2017		}
2018	},
2019
2020	clone: function() {
2021		return new Matrix(this._a, this._c, this._b, this._d,
2022				this._tx, this._ty);
2023	},
2024
2025	equals: function(mx) {
2026		return mx === this || mx && this._a === mx._a && this._b === mx._b
2027				&& this._c === mx._c && this._d === mx._d
2028				&& this._tx === mx._tx && this._ty === mx._ty
2029				|| false;
2030	},
2031
2032	toString: function() {
2033		var f = Formatter.instance;
2034		return '[[' + [f.number(this._a), f.number(this._b),
2035					f.number(this._tx)].join(', ') + '], ['
2036				+ [f.number(this._c), f.number(this._d),
2037					f.number(this._ty)].join(', ') + ']]';
2038	},
2039
2040	reset: function(_dontNotify) {
2041		this._a = this._d = 1;
2042		this._c = this._b = this._tx = this._ty = 0;
2043		if (!_dontNotify)
2044			this._changed();
2045		return this;
2046	},
2047
2048	apply: function(recursively, _setApplyMatrix) {
2049		var owner = this._owner;
2050		if (owner) {
2051			owner.transform(null, true, Base.pick(recursively, true),
2052					_setApplyMatrix);
2053			return this.isIdentity();
2054		}
2055		return false;
2056	},
2057
2058	translate: function() {
2059		var point = Point.read(arguments),
2060			x = point.x,
2061			y = point.y;
2062		this._tx += x * this._a + y * this._b;
2063		this._ty += x * this._c + y * this._d;
2064		this._changed();
2065		return this;
2066	},
2067
2068	scale: function() {
2069		var scale = Point.read(arguments),
2070			center = Point.read(arguments, 0, { readNull: true });
2071		if (center)
2072			this.translate(center);
2073		this._a *= scale.x;
2074		this._c *= scale.x;
2075		this._b *= scale.y;
2076		this._d *= scale.y;
2077		if (center)
2078			this.translate(center.negate());
2079		this._changed();
2080		return this;
2081	},
2082
2083	rotate: function(angle ) {
2084		angle *= Math.PI / 180;
2085		var center = Point.read(arguments, 1),
2086			x = center.x,
2087			y = center.y,
2088			cos = Math.cos(angle),
2089			sin = Math.sin(angle),

2090			tx = x - x * cos + y * sin,
2091			ty = y - x * sin - y * cos,
2092			a = this._a,
2093			b = this._b,
2094			c = this._c,
2095			d = this._d;
2096		this._a = cos * a + sin * b;
2097		this._b = -sin * a + cos * b;
2098		this._c = cos * c + sin * d;
2099		this._d = -sin * c + cos * d;
2100		this._tx += tx * a + ty * b;
2101		this._ty += tx * c + ty * d;
2102		this._changed();
2103		return this;
2104	},
2105
2106	shear: function() {
2107		var shear = Point.read(arguments),
2108			center = Point.read(arguments, 0, { readNull: true });
2109		if (center)
2110			this.translate(center);
2111		var a = this._a,
2112			c = this._c;
2113		this._a += shear.y * this._b;
2114		this._c += shear.y * this._d;
2115		this._b += shear.x * a;
2116		this._d += shear.x * c;
2117		if (center)
2118			this.translate(center.negate());
2119		this._changed();
2120		return this;
2121	},
2122
2123	skew: function() {
2124		var skew = Point.read(arguments),
2125			center = Point.read(arguments, 0, { readNull: true }),
2126			toRadians = Math.PI / 180,
2127			shear = new Point(Math.tan(skew.x * toRadians),
2128				Math.tan(skew.y * toRadians));
2129		return this.shear(shear, center);
2130	},
2131
2132	concatenate: function(mx) {
2133		var a1 = this._a,
2134			b1 = this._b,
2135			c1 = this._c,
2136			d1 = this._d,
2137			a2 = mx._a,
2138			b2 = mx._b,
2139			c2 = mx._c,
2140			d2 = mx._d,
2141			tx2 = mx._tx,
2142			ty2 = mx._ty;
2143		this._a = a2 * a1 + c2 * b1;
2144		this._b = b2 * a1 + d2 * b1;
2145		this._c = a2 * c1 + c2 * d1;
2146		this._d = b2 * c1 + d2 * d1;
2147		this._tx += tx2 * a1 + ty2 * b1;
2148		this._ty += tx2 * c1 + ty2 * d1;
2149		this._changed();
2150		return this;
2151	},
2152
2153	preConcatenate: function(mx) {
2154		var a1 = this._a,
2155			b1 = this._b,
2156			c1 = this._c,
2157			d1 = this._d,
2158			tx1 = this._tx,
2159			ty1 = this._ty,
2160			a2 = mx._a,
2161			b2 = mx._b,
2162			c2 = mx._c,
2163			d2 = mx._d,
2164			tx2 = mx._tx,
2165			ty2 = mx._ty;
2166		this._a = a2 * a1 + b2 * c1;
2167		this._b = a2 * b1 + b2 * d1;
2168		this._c = c2 * a1 + d2 * c1;
2169		this._d = c2 * b1 + d2 * d1;
2170		this._tx = a2 * tx1 + b2 * ty1 + tx2;
2171		this._ty = c2 * tx1 + d2 * ty1 + ty2;
2172		this._changed();
2173		return this;
2174	},
2175
2176	chain: function(mx) {
2177		var a1 = this._a,
2178			b1 = this._b,
2179			c1 = this._c,
2180			d1 = this._d,
2181			tx1 = this._tx,
2182			ty1 = this._ty,
2183			a2 = mx._a,
2184			b2 = mx._b,
2185			c2 = mx._c,
2186			d2 = mx._d,
2187			tx2 = mx._tx,
2188			ty2 = mx._ty;
2189		return new Matrix(
2190				a2 * a1 + c2 * b1,
2191				a2 * c1 + c2 * d1,
2192				b2 * a1 + d2 * b1,
2193				b2 * c1 + d2 * d1,
2194				tx1 + tx2 * a1 + ty2 * b1,
2195				ty1 + tx2 * c1 + ty2 * d1);
2196	},
2197
2198	isIdentity: function() {
2199		return this._a === 1 && this._c === 0 && this._b === 0 && this._d === 1
2200				&& this._tx === 0 && this._ty === 0;
2201	},
2202
2203	orNullIfIdentity: function() {
2204		return this.isIdentity() ? null : this;
2205	},
2206
2207	isInvertible: function() {
2208		return !!this._getDeterminant();
2209	},
2210
2211	isSingular: function() {
2212		return !this._getDeterminant();
2213	},
2214
2215	transform: function( src, dst, count) {
2216		return arguments.length < 3
2217			? this._transformPoint(Point.read(arguments))
2218			: this._transformCoordinates(src, dst, count);
2219	},
2220
2221	_transformPoint: function(point, dest, _dontNotify) {
2222		var x = point.x,
2223			y = point.y;
2224		if (!dest)
2225			dest = new Point();
2226		return dest.set(
2227			x * this._a + y * this._b + this._tx,
2228			x * this._c + y * this._d + this._ty,
2229			_dontNotify
2230		);
2231	},
2232
2233	_transformCoordinates: function(src, dst, count) {
2234		var i = 0,
2235			j = 0,
2236			max = 2 * count;
2237		while (i < max) {
2238			var x = src[i++],
2239				y = src[i++];
2240			dst[j++] = x * this._a + y * this._b + this._tx;
2241			dst[j++] = x * this._c + y * this._d + this._ty;
2242		}
2243		return dst;
2244	},
2245
2246	_transformCorners: function(rect) {
2247		var x1 = rect.x,
2248			y1 = rect.y,
2249			x2 = x1 + rect.width,
2250			y2 = y1 + rect.height,
2251			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
2252		return this._transformCoordinates(coords, coords, 4);
2253	},
2254
2255	_transformBounds: function(bounds, dest, _dontNotify) {
2256		var coords = this._transformCorners(bounds),
2257			min = coords.slice(0, 2),
2258			max = coords.slice();
2259		for (var i = 2; i < 8; i++) {
2260			var val = coords[i],
2261				j = i & 1;
2262			if (val < min[j])
2263				min[j] = val;
2264			else if (val > max[j])
2265				max[j] = val;
2266		}
2267		if (!dest)
2268			dest = new Rectangle();
2269		return dest.set(min[0], min[1], max[0] - min[0], max[1] - min[1],
2270				_dontNotify);
2271	},
2272
2273	inverseTransform: function() {
2274		return this._inverseTransform(Point.read(arguments));
2275	},
2276
2277	_getDeterminant: function() {
2278		var det = this._a * this._d - this._b * this._c;
2279		return isFinite(det) && !Numerical.isZero(det)
2280				&& isFinite(this._tx) && isFinite(this._ty)
2281				? det : null;
2282	},
2283
2284	_inverseTransform: function(point, dest, _dontNotify) {
2285		var det = this._getDeterminant();
2286		if (!det)
2287			return null;
2288		var x = point.x - this._tx,
2289			y = point.y - this._ty;
2290		if (!dest)
2291			dest = new Point();
2292		return dest.set(
2293			(x * this._d - y * this._b) / det,
2294			(y * this._a - x * this._c) / det,
2295			_dontNotify
2296		);
2297	},
2298
2299	decompose: function() {
2300		var a = this._a, b = this._b, c = this._c, d = this._d;

2301		if (Numerical.isZero(a * d - b * c))
2302			return null;
2303
2304		var scaleX = Math.sqrt(a * a + b * b);
2305		a /= scaleX;
2306		b /= scaleX;
2307
2308		var shear = a * c + b * d;
2309		c -= a * shear;
2310		d -= b * shear;
2311
2312		var scaleY = Math.sqrt(c * c + d * d);
2313		c /= scaleY;
2314		d /= scaleY;
2315		shear /= scaleY;
2316
2317		if (a * d < b * c) {
2318			a = -a;
2319			b = -b;
2320			shear = -shear;
2321			scaleX = -scaleX;
2322		}
2323
2324		return {
2325			scaling: new Point(scaleX, scaleY),
2326			rotation: -Math.atan2(b, a) * 180 / Math.PI,
2327			shearing: shear
2328		};
2329	},
2330
2331	getValues: function() {
2332		return [ this._a, this._c, this._b, this._d, this._tx, this._ty ];
2333	},
2334
2335	getTranslation: function() {
2336		return new Point(this._tx, this._ty);
2337	},
2338
2339	getScaling: function() {
2340		return (this.decompose() || {}).scaling;
2341	},
2342
2343	getRotation: function() {
2344		return (this.decompose() || {}).rotation;
2345	},
2346
2347	inverted: function() {
2348		var det = this._getDeterminant();
2349		return det && new Matrix(
2350				this._d / det,
2351				-this._c / det,
2352				-this._b / det,
2353				this._a / det,
2354				(this._b * this._ty - this._d * this._tx) / det,
2355				(this._c * this._tx - this._a * this._ty) / det);
2356	},
2357
2358	shiftless: function() {
2359		return new Matrix(this._a, this._c, this._b, this._d, 0, 0);
2360	},
2361
2362	applyToContext: function(ctx) {
2363		ctx.transform(this._a, this._c, this._b, this._d, this._tx, this._ty);
2364	}
2365}, Base.each(['a', 'c', 'b', 'd', 'tx', 'ty'], function(name) {
2366	var part = Base.capitalize(name),
2367		prop = '_' + name;
2368	this['get' + part] = function() {
2369		return this[prop];
2370	};
2371	this['set' + part] = function(value) {
2372		this[prop] = value;
2373		this._changed();
2374	};
2375}, {}));
2376
2377var Line = Base.extend({
2378	_class: 'Line',
2379
2380	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
2381		var asVector = false;
2382		if (arguments.length >= 4) {
2383			this._px = arg0;
2384			this._py = arg1;
2385			this._vx = arg2;
2386			this._vy = arg3;
2387			asVector = arg4;
2388		} else {
2389			this._px = arg0.x;
2390			this._py = arg0.y;
2391			this._vx = arg1.x;
2392			this._vy = arg1.y;
2393			asVector = arg2;
2394		}
2395		if (!asVector) {
2396			this._vx -= this._px;
2397			this._vy -= this._py;
2398		}
2399	},
2400
2401	getPoint: function() {
2402		return new Point(this._px, this._py);
2403	},
2404
2405	getVector: function() {
2406		return new Point(this._vx, this._vy);
2407	},
2408
2409	getLength: function() {
2410		return this.getVector().getLength();
2411	},
2412
2413	intersect: function(line, isInfinite) {
2414		return Line.intersect(
2415				this._px, this._py, this._vx, this._vy,
2416				line._px, line._py, line._vx, line._vy,
2417				true, isInfinite);
2418	},
2419
2420	getSide: function(point) {
2421		return Line.getSide(
2422				this._px, this._py, this._vx, this._vy,
2423				point.x, point.y, true);
2424	},
2425
2426	getDistance: function(point) {
2427		return Math.abs(Line.getSignedDistance(
2428				this._px, this._py, this._vx, this._vy,
2429				point.x, point.y, true));
2430	},
2431
2432	statics: {
2433		intersect: function(apx, apy, avx, avy, bpx, bpy, bvx, bvy, asVector,
2434				isInfinite) {
2435			if (!asVector) {
2436				avx -= apx;
2437				avy -= apy;
2438				bvx -= bpx;
2439				bvy -= bpy;
2440			}
2441			var cross = avx * bvy - avy * bvx;
2442			if (!Numerical.isZero(cross)) {
2443				var dx = apx - bpx,
2444					dy = apy - bpy,
2445					ta = (bvx * dy - bvy * dx) / cross,
2446					tb = (avx * dy - avy * dx) / cross;
2447				if (isInfinite || 0 <= ta && ta <= 1 && 0 <= tb && tb <= 1)
2448					return new Point(
2449								apx + ta * avx,
2450								apy + ta * avy);
2451			}
2452		},
2453
2454		getSide: function(px, py, vx, vy, x, y, asVector) {
2455			if (!asVector) {
2456				vx -= px;
2457				vy -= py;
2458			}
2459			var v2x = x - px,
2460				v2y = y - py,
2461				ccw = v2x * vy - v2y * vx;
2462			if (ccw === 0) {
2463				ccw = v2x * vx + v2y * vy;
2464				if (ccw > 0) {
2465					v2x -= vx;
2466					v2y -= vy;
2467					ccw = v2x * vx + v2y * vy;
2468					if (ccw < 0)
2469						ccw = 0;
2470				}
2471			}
2472			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
2473		},
2474
2475		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
2476			if (!asVector) {
2477				vx -= px;
2478				vy -= py;
2479			}
2480			return Numerical.isZero(vx)
2481					? vy >= 0 ? px - x : x - px
2482					: Numerical.isZero(vy)
2483						? vx >= 0 ? y - py : py - y
2484						: (vx * (y - py) - vy * (x - px)) / Math.sqrt(vx * vx + vy * vy);
2485		}
2486	}
2487});
2488
2489var Project = PaperScopeItem.extend({
2490	_class: 'Project',
2491	_list: 'projects',
2492	_reference: 'project',
2493
2494	initialize: function Project(element) {
2495		PaperScopeItem.call(this, true);
2496		this.layers = [];
2497		this._activeLayer = null;
2498		this.symbols = [];
2499		this._currentStyle = new Style(null, null, this);
2500		this._view = View.create(this,
2501				element || CanvasProvider.getCanvas(1, 1));
2502		this._selectedItems = {};
2503		this._selectedItemCount = 0;
2504		this._updateVersion = 0;
2505	},
2506

2507	_serialize: function(options, dictionary) {
2508		return Base.serialize(this.layers, options, true, dictionary);
2509	},
2510
2511	clear: function() {
2512		for (var i = this.layers.length - 1; i >= 0; i--)
2513			this.layers[i].remove();
2514		this.symbols = [];
2515	},
2516
2517	isEmpty: function() {
2518		return this.layers.length === 0;
2519	},
2520
2521	remove: function remove() {
2522		if (!remove.base.call(this))
2523			return false;
2524		if (this._view)
2525			this._view.remove();
2526		return true;
2527	},
2528
2529	getView: function() {
2530		return this._view;
2531	},
2532
2533	getCurrentStyle: function() {
2534		return this._currentStyle;
2535	},
2536
2537	setCurrentStyle: function(style) {
2538		this._currentStyle.initialize(style);
2539	},
2540
2541	getIndex: function() {
2542		return this._index;
2543	},
2544
2545	getOptions: function() {
2546		return this._scope.settings;
2547	},
2548
2549	getActiveLayer: function() {
2550		return this._activeLayer || new Layer({ project: this });
2551	},
2552
2553	getSelectedItems: function() {
2554		var items = [];
2555		for (var id in this._selectedItems) {
2556			var item = this._selectedItems[id];
2557			if (item.isInserted())
2558				items.push(item);
2559		}
2560		return items;
2561	},
2562
2563	insertChild: function(index, item, _preserve) {
2564		if (item instanceof Layer) {
2565			item._remove(false, true);
2566			Base.splice(this.layers, [item], index, 0);
2567			item._setProject(this, true);
2568			if (this._changes)
2569				item._changed(5);
2570			if (!this._activeLayer)
2571				this._activeLayer = item;
2572		} else if (item instanceof Item) {
2573			(this._activeLayer
2574				|| this.insertChild(index, new Layer(Item.NO_INSERT)))
2575					.insertChild(index, item, _preserve);
2576		} else {
2577			item = null;
2578		}
2579		return item;
2580	},
2581
2582	addChild: function(item, _preserve) {
2583		return this.insertChild(undefined, item, _preserve);
2584	},
2585
2586	_updateSelection: function(item) {
2587		var id = item._id,
2588			selectedItems = this._selectedItems;
2589		if (item._selected) {
2590			if (selectedItems[id] !== item) {
2591				this._selectedItemCount++;
2592				selectedItems[id] = item;
2593			}
2594		} else if (selectedItems[id] === item) {
2595			this._selectedItemCount--;
2596			delete selectedItems[id];
2597		}
2598	},
2599
2600	selectAll: function() {
2601		var layers = this.layers;
2602		for (var i = 0, l = layers.length; i < l; i++)
2603			layers[i].setFullySelected(true);
2604	},
2605
2606	deselectAll: function() {
2607		var selectedItems = this._selectedItems;
2608		for (var i in selectedItems)
2609			selectedItems[i].setFullySelected(false);
2610	},
2611
2612	hitTest: function() {
2613		var point = Point.read(arguments),
2614			options = HitResult.getOptions(Base.read(arguments));
2615		for (var i = this.layers.length - 1; i >= 0; i--) {
2616			var res = this.layers[i]._hitTest(point, options);
2617			if (res) return res;
2618		}
2619		return null;
2620	},
2621
2622	getItems: function(match) {
2623		return Item._getItems(this.layers, match);
2624	},
2625
2626	getItem: function(match) {
2627		return Item._getItems(this.layers, match, null, null, true)[0] || null;
2628	},
2629
2630	importJSON: function(json) {
2631		this.activate();
2632		var layer = this._activeLayer;
2633		return Base.importJSON(json, layer && layer.isEmpty() && layer);
2634	},
2635
2636	draw: function(ctx, matrix, pixelRatio) {
2637		this._updateVersion++;
2638		ctx.save();
2639		matrix.applyToContext(ctx);
2640		var param = new Base({
2641			offset: new Point(0, 0),
2642			pixelRatio: pixelRatio,
2643			viewMatrix: matrix.isIdentity() ? null : matrix,
2644			matrices: [new Matrix()],
2645			updateMatrix: true
2646		});
2647		for (var i = 0, layers = this.layers, l = layers.length; i < l; i++)
2648			layers[i].draw(ctx, param);
2649		ctx.restore();
2650
2651		if (this._selectedItemCount > 0) {
2652			ctx.save();
2653			ctx.strokeWidth = 1;
2654			var items = this._selectedItems,
2655				size = this._scope.settings.handleSize,
2656				version = this._updateVersion;
2657			for (var id in items)
2658				items[id]._drawSelection(ctx, matrix, size, items, version);
2659			ctx.restore();
2660		}
2661	}
2662});
2663
2664var Symbol = Base.extend({
2665	_class: 'Symbol',
2666
2667	initialize: function Symbol(item, dontCenter) {
2668		this._id = UID.get();
2669		this.project = paper.project;
2670		this.project.symbols.push(this);
2671		if (item)
2672			this.setDefinition(item, dontCenter);
2673	},
2674
2675	_serialize: function(options, dictionary) {
2676		return dictionary.add(this, function() {
2677			return Base.serialize([this._class, this._definition],
2678					options, false, dictionary);
2679		});
2680	},
2681
2682	_changed: function(flags) {
2683		if (flags & 8) {
2684			Item._clearBoundsCache(this);
2685		}
2686		if (flags & 1) {
2687			this.project._needsUpdate = true;
2688		}
2689	},
2690
2691	getDefinition: function() {
2692		return this._definition;
2693	},
2694
2695	setDefinition: function(item, _dontCenter) {
2696		if (item._parentSymbol)
2697			item = item.clone();
2698		if (this._definition)
2699			this._definition._parentSymbol = null;
2700		this._definition = item;
2701		item.remove();
2702		item.setSelected(false);
2703		if (!_dontCenter)
2704			item.setPosition(new Point());
2705		item._parentSymbol = this;
2706		this._changed(9);
2707	},
2708
2709	place: function(position) {
2710		return new PlacedSymbol(this, position);
2711	},
2712
2713	clone: function() {
2714		return new Symbol(this._definition.clone(false));
2715	},
2716
2717	equals: function(symbol) {
2718		return symbol === this
2719				|| symbol && this.definition.equals(symbol.definition)
2720				|| false;
2721	}
2722});
2723
2724var Item = Base.extend(Emitter, {
2725	statics: {
2726		extend: function extend(src) {
2727			if (src._serializeFields)
2728				src._serializeFields = new Base(
2729						this.prototype._serializeFields, src._serializeFields);
2730			return extend.base.apply(this, arguments);
2731		},
2732
2733		NO_INSERT: { insert: false }
2734	},
2735
2736	_class: 'Item',
2737	_applyMatrix: true,
2738	_canApplyMatrix: true,
2739	_boundsSelected: false,
2740	_selectChildren: false,
2741	_serializeFields: {
2742		name: null,
2743		applyMatrix: null,
2744		matrix: new Matrix(),
2745		pivot: null,