/*
* Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
* http://paperjs.org/
*
* Copyright (c) 2011 - 2013, Juerg Lehni & Jonathan Puckey
* http://lehni.org/ & http://jonathanpuckey.com/
*
* Distributed under the MIT license. See LICENSE file for details.
*
* All rights reserved.
*/
/**
* @name Segment
*
* @class The Segment object represents the points of a path through which its
* {@link Curve} objects pass. The segments of a path can be accessed through
* its {@link Path#segments} array.
*
* Each segment consists of an anchor point ({@link Segment#point}) and
* optionaly an incoming and an outgoing handle ({@link Segment#handleIn} and
* {@link Segment#handleOut}), describing the tangents of the two {@link Curve}
* objects that are connected by this segment.
*/
var Segment = Base.extend(/** @lends Segment# */{
_class: 'Segment',
/**
* Creates a new Segment object.
*
* @name Segment#initialize
* @param {Point} [point={x: 0, y: 0}] the anchor point of the segment
* @param {Point} [handleIn={x: 0, y: 0}] the handle point relative to the
* anchor point of the segment that describes the in tangent of the
* segment.
* @param {Point} [handleOut={x: 0, y: 0}] the handle point relative to the
* anchor point of the segment that describes the out tangent of the
* segment.
*
* @example {@paperscript}
* var handleIn = new Point(-80, -100);
* var handleOut = new Point(80, 100);
*
* var firstPoint = new Point(100, 50);
* var firstSegment = new Segment(firstPoint, null, handleOut);
*
* var secondPoint = new Point(300, 50);
* var secondSegment = new Segment(secondPoint, handleIn, null);
*
* var path = new Path(firstSegment, secondSegment);
* path.strokeColor = 'black';
*/
/**
* Creates a new Segment object.
*
* @name Segment#initialize
* @param {Object} object An object literal containing properties to
* be set on the segment.
*
* @example {@paperscript}
* // Creating segments using object notation:
* var firstSegment = new Segment({
* point: [100, 50],
* handleOut: [80, 100]
* });
*
* var secondSegment = new Segment({
* point: [300, 50],
* handleIn: [-80, -100]
* });
*
* var path = new Path({
* segments: [firstSegment, secondSegment],
* strokeColor: 'black'
* });
*/
/**
* Creates a new Segment object.
*
* @param {Number} x the x coordinate of the segment point
* @param {Number} y the y coordinate of the segment point
* @param {Number} inX the x coordinate of the the handle point relative
* to the anchor point of the segment that describes the in tangent
* of the segment.
* @param {Number} inY the y coordinate of the the handle point relative
* to the anchor point of the segment that describes the in tangent
* of the segment.
* @param {Number} outX the x coordinate of the the handle point relative
* to the anchor point of the segment that describes the out tangent
* of the segment.
* @param {Number} outY the y coordinate of the the handle point relative
* to the anchor point of the segment that describes the out tangent
* of the segment.
*
* @example {@paperscript}
* var inX = -80;
* var inY = -100;
* var outX = 80;
* var outY = 100;
*
* var x = 100;
* var y = 50;
* var firstSegment = new Segment(x, y, inX, inY, outX, outY);
*
* var x2 = 300;
* var y2 = 50;
* var secondSegment = new Segment( x2, y2, inX, inY, outX, outY);
*
* var path = new Path(firstSegment, secondSegment);
* path.strokeColor = 'black';
* @ignore
*/
initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
var count = arguments.length,
point, handleIn, handleOut;
// TODO: Use Point.read or Point.readNamed to read these?
if (count === 0) {
// Nothing
} else if (count === 1) {
// Note: This copies from existing segments through bean getters
if (arg0.point) {
point = arg0.point;
handleIn = arg0.handleIn;
handleOut = arg0.handleOut;
} else {
point = arg0;
}
} else if (count < 6) {
if (count == 2 && arg1.x === undefined) {
point = [ arg0, arg1 ];
} else {
point = arg0;
// Doesn't matter if these arguments exist, SegmentPointcreate
// produces creates points with (0, 0) otherwise
handleIn = arg1;
handleOut = arg2;
}
} else if (count === 6) {
point = [ arg0, arg1 ];
handleIn = [ arg2, arg3 ];
handleOut = [ arg4, arg5 ];
}
this._point = new SegmentPoint(point, this);
this._handleIn = new SegmentPoint(handleIn, this);
this._handleOut = new SegmentPoint(handleOut, this);
},
_serialize: function(options) {
// If the Segment is linear, only serialize point, otherwise handles too
return Base.serialize(this.isLinear() ? this._point
: [this._point, this._handleIn, this._handleOut], options, true);
},
_changed: function(point) {
if (!this._path)
return;
// Delegate changes to affected curves if they exist. Check _curves
// first to make sure we're not creating it by calling this.getCurve().
var curve = this._path._curves && this.getCurve(),
other;
if (curve) {
curve._changed();
// Get the other affected curve, which is the previous one for
// _point or _handleIn changing when this segment is _segment1 of
// the curve, for all other cases it's the next (e.g. _handleOut
// when this segment is _segment2)
if (other = (curve[point == this._point
|| point == this._handleIn && curve._segment1 == this
? 'getPrevious' : 'getNext']())) {
other._changed();
}
}
this._path._changed(/*#=*/ Change.GEOMETRY);
},
/**
* The anchor point of the segment.
*
* @type Point
* @bean
*/
getPoint: function() {
return this._point;
},
setPoint: function(point) {
point = Point.read(arguments);
// Do not replace the internal object but update it instead, so
// references to it are kept alive.
this._point.set(point.x, point.y);
},
/**
* The handle point relative to the anchor point of the segment that
* describes the in tangent of the segment.
*
* @type Point
* @bean
*/
getHandleIn: function() {
return this._handleIn;
},
setHandleIn: function(point) {
point = Point.read(arguments);
// See #setPoint:
this._handleIn.set(point.x, point.y);
// Update corner accordingly
// this.corner = !this._handleIn.isColinear(this._handleOut);
},
/**
* The handle point relative to the anchor point of the segment that
* describes the out tangent of the segment.
*
* @type Point
* @bean
*/
getHandleOut: function() {
return this._handleOut;
},
setHandleOut: function(point) {
// We need to use point to avoid minification issues and prevent method
// from turning into a bean (by removal of the point argument).
point = Point.read(arguments);
// See #setPoint:
this._handleOut.set(point.x, point.y);
// Update corner accordingly
// this.corner = !this._handleIn.isColinear(this._handleOut);
},
/**
* Specifies whether the segment has no handles defined, meaning it connects
* two straight lines.
*
* @type Point
* @bean
*/
isLinear: function() {
return this._handleIn.isZero() && this._handleOut.isZero();
},
setLinear: function() {
this._handleIn.set(0, 0);
this._handleOut.set(0, 0);
},
_isSelected: function(point) {
var state = this._selectionState;
return point == this._point ? !!(state & /*#=*/ SelectionState.POINT)
: point == this._handleIn ? !!(state & /*#=*/ SelectionState.HANDLE_IN)
: point == this._handleOut ? !!(state & /*#=*/ SelectionState.HANDLE_OUT)
: false;
},
_setSelected: function(point, selected) {
var path = this._path,
selected = !!selected, // convert to boolean
state = this._selectionState || 0,
// For performance reasons use array indices to access the various
// selection states: 0 = point, 1 = handleIn, 2 = handleOut
selection = [
!!(state & /*#=*/ SelectionState.POINT),
!!(state & /*#=*/ SelectionState.HANDLE_IN),
!!(state & /*#=*/ SelectionState.HANDLE_OUT)
];
if (point == this._point) {
if (selected) {
// We're selecting point, deselect the handles
selection[1] = selection[2] = false;
} else {
var previous = this.getPrevious(),
next = this.getNext();
// When deselecting a point, the handles get selected instead
// depending on the selection state of their neighbors.
selection[1] = previous && (previous._point.isSelected()
|| previous._handleOut.isSelected());
selection[2] = next && (next._point.isSelected()
|| next._handleIn.isSelected());
}
selection[0] = selected;
} else {
var index = point == this._handleIn ? 1 : 2;
if (selection[index] != selected) {
// When selecting handles, the point get deselected.
if (selected)
selection[0] = false;
selection[index] = selected;
}
}
this._selectionState = (selection[0] ? /*#=*/ SelectionState.POINT : 0)
| (selection[1] ? /*#=*/ SelectionState.HANDLE_IN : 0)
| (selection[2] ? /*#=*/ SelectionState.HANDLE_OUT : 0);
// If the selection state of the segment has changed, we need to let
// it's path know and possibly add or remove it from
// project._selectedItems
if (path && state != this._selectionState) {
path._updateSelection(this, state, this._selectionState);
// Let path know that we changed something and the view should be
// redrawn
path._changed(/*#=*/ Change.ATTRIBUTE);
}
},
/**
* Specifies whether the {@link #point} of the segment is selected.
* @type Boolean
* @bean
* @example {@paperscript}
* var path = new Path.Circle({
* center: [80, 50],
* radius: 40
* });
*
* // Select the third segment point:
* path.segments[2].selected = true;
*/
isSelected: function() {
return this._isSelected(this._point);
},
setSelected: function(selected) {
this._setSelected(this._point, selected);
},
/**
* {@grouptitle Hierarchy}
*
* The index of the segment in the {@link Path#segments} array that the
* segment belongs to.
*
* @type Number
* @bean
*/
getIndex: function() {
return this._index !== undefined ? this._index : null;
},
/**
* The path that the segment belongs to.
*
* @type Path
* @bean
*/
getPath: function() {
return this._path || null;
},
/**
* The curve that the segment belongs to.
*
* @type Curve
* @bean
*/
getCurve: function() {
var path = this._path,
index = this._index;
if (path) {
// The last segment of an open path belongs to the last curve
if (!path._closed && index == path._segments.length - 1)
index--;
return path.getCurves()[index] || null;
}
return null;
},
/**
* The curve location that describes this segment's position ont the path.
*
* @type CurveLocation
* @bean
*/
getLocation: function() {
var curve = this.getCurve();
// Determine whether the parameter for this segment is 0 or 1 based on
// whether there is a next curve or not, as #getNext() takes closed into
// account and all.
return curve ? new CurveLocation(curve, curve.getNext() ? 0 : 1) : null;
},
/**
* {@grouptitle Sibling Segments}
*
* The next segment in the {@link Path#segments} array that the segment
* belongs to. If the segments belongs to a closed path, the first segment
* is returned for the last segment of the path.
*
* @type Segment
* @bean
*/
getNext: function() {
var segments = this._path && this._path._segments;
return segments && (segments[this._index + 1]
|| this._path._closed && segments[0]) || null;
},
/**
* The previous segment in the {@link Path#segments} array that the
* segment belongs to. If the segments belongs to a closed path, the last
* segment is returned for the first segment of the path.
*
* @type Segment
* @bean
*/
getPrevious: function() {
var segments = this._path && this._path._segments;
return segments && (segments[this._index - 1]
|| this._path._closed && segments[segments.length - 1]) || null;
},
/**
* Returns the reversed the segment, without modifying the segment itself.
* @return {Segment} the reversed segment
*/
reverse: function() {
return new Segment(this._point, this._handleOut, this._handleIn);
},
/**
* Removes the segment from the path that it belongs to.
*/
remove: function() {
return this._path ? !!this._path.removeSegment(this._index) : false;
},
clone: function() {
return new Segment(this._point, this._handleIn, this._handleOut);
},
equals: function(segment) {
return segment === this || segment
&& this._point.equals(segment._point)
&& this._handleIn.equals(segment._handleIn)
&& this._handleOut.equals(segment._handleOut)
|| false;
},
/**
* @return {String} a string representation of the segment
*/
toString: function() {
var parts = [ 'point: ' + this._point ];
if (!this._handleIn.isZero())
parts.push('handleIn: ' + this._handleIn);
if (!this._handleOut.isZero())
parts.push('handleOut: ' + this._handleOut);
return '{ ' + parts.join(', ') + ' }';
},
_transformCoordinates: function(matrix, coords, change) {
// Use matrix.transform version() that takes arrays of multiple
// points for largely improved performance, as no calls to
// Point.read() and Point constructors are necessary.
var point = this._point,
// If change is true, only transform handles if they are set, as
// _transformCoordinates is called only to change the segment, no
// to receive the coords.
// This saves some computation time. If change is false, always
// use the real handles, as we just want to receive a filled
// coords array for getBounds().
handleIn = !change || !this._handleIn.isZero()
? this._handleIn : null,
handleOut = !change || !this._handleOut.isZero()
? this._handleOut : null,
x = point._x,
y = point._y,
i = 2;
coords[0] = x;
coords[1] = y;
// We need to convert handles to absolute coordinates in order
// to transform them.
if (handleIn) {
coords[i++] = handleIn._x + x;
coords[i++] = handleIn._y + y;
}
if (handleOut) {
coords[i++] = handleOut._x + x;
coords[i++] = handleOut._y + y;
}
// If no matrix was previded, this was just called to get the coords and
// we are done now.
if (matrix) {
matrix._transformCoordinates(coords, 0, coords, 0, i / 2);
x = coords[0];
y = coords[1];
if (change) {
// If change is true, we need to set the new values back
point._x = x;
point._y = y;
i = 2;
if (handleIn) {
handleIn._x = coords[i++] - x;
handleIn._y = coords[i++] - y;
}
if (handleOut) {
handleOut._x = coords[i++] - x;
handleOut._y = coords[i++] - y;
}
} else {
// We want to receive the results in coords, so make sure
// handleIn and out are defined too, even if they're 0
if (!handleIn) {
coords[i++] = x;
coords[i++] = y;
}
if (!handleOut) {
coords[i++] = x;
coords[i++] = y;
}
}
}
return coords;
}
});