import * as core from '../../core';
const Graphics = core.Graphics;
/**
* Mixins for the PIXI.Graphics class.
* @memberof PIXI
* @class Graphics
*/
const p = Graphics.prototype;
/**
* Shortcut for `drawCommands`.
* @method PIXI.Graphics#d
* @param {Array} commands The commands and parameters to draw
* @return {PIXI.Graphics}
*/
/**
* Execute a series of commands, this is the name of the short function
* followed by the parameters, e.g., `["f", "#ff0000", "r", 0, 0, 100, 200]`
* @method PIXI.Graphics#drawCommands
* @param {Array} commands The commands and parameters to draw
* @return {PIXI.Graphics}
*/
p.drawCommands = p.d = function(commands) {
var currentCommand, params = [],
i = 0;
while (i <= commands.length) {
var item = commands[i++];
if (item === undefined || this[item]) {
if (currentCommand) {
this[currentCommand].apply(this, params);
params.length = 0;
}
currentCommand = item;
} else {
params.push(item);
}
}
return this;
};
/**
* Closes the current path, effectively drawing a line from the current drawing point to the first drawing point specified
* since the fill or stroke was last set.
* @method PIXI.Graphics#c
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.c = p.closePath;
/**
* Alias for `addHole`
* @method PIXI.Graphics#h
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.h = p.addHole;
/**
* Shortcut to `moveTo`.
* @method PIXI.Graphics#m
* @param {Number} x The x coordinate the drawing point should move to.
* @param {Number} y The y coordinate the drawing point should move to.
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls).
**/
p.m = p.moveTo;
/**
* Shortcut to `lineTo`.
* @method PIXI.Graphics#l
* @param {Number} x The x coordinate the drawing point should draw to.
* @param {Number} y The y coordinate the drawing point should draw to.
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.l = p.lineTo;
/**
* Draws a quadratic curve from the current drawing point to (x, y) using the control point (cpx, cpy). For detailed
* information, read the <a href="http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#dom-context-2d-quadraticcurveto">
* whatwg spec</a>. A tiny API method "qt" also exists.
* @method PIXI.Graphics#q
* @param {Number} cpx
* @param {Number} cpy
* @param {Number} x
* @param {Number} y
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.q = p.quadraticCurveTo;
/**
* Shortcut to `bezierCurveTo`.
* @method PIXI.Graphics#b
* @param {Number} cp1x
* @param {Number} cp1y
* @param {Number} cp2x
* @param {Number} cp2y
* @param {Number} x
* @param {Number} y
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.b = p.bezierCurveTo;
/**
* Shortcut to `beginFill`.
* @method PIXI.Graphics#f
* @param {Uint} color The hex color value (e.g. 0xFFFFFF)
* null will result in no fill.
* @param {Number} [alpha=1] The alpha value of fill
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.f = p.beginFill;
/**
* Shortcut to `lineStyle`.
* @method PIXI.Graphics#s
* @param {String} color A CSS compatible color value (ex. "#FF0000", "red", or "rgba(255,0,0,0.5)"). Setting to
* null will result in no stroke.
* @param {Number} [thickness=1] The thickness of the stroke
* @param {Number} [alpha=1] The alpha value from 0 (invisibile) to 1 (visible)
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.s = p.lineStyle;
/**
* Shortcut to `drawRect`.
* @method PIXI.Graphics#dr
* @param {Number} x
* @param {Number} y
* @param {Number} w Width of the rectangle
* @param {Number} h Height of the rectangle
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
/**
* Shortcut to `drawRect`.
* @method PIXI.Graphics#r
* @param {Number} x
* @param {Number} y
* @param {Number} w Width of the rectangle
* @param {Number} h Height of the rectangle
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.dr = p.drawRect;
/**
* Shortcut to `drawRoundedRect`.
* @method PIXI.Graphics#rr
* @param {Number} x
* @param {Number} y
* @param {Number} w Width of the rectangle
* @param {Number} h Height of the rectangle
* @param {Number} radius The corner radius
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.rr = p.drawRoundedRect;
/**
* Shortcut to `drawRoundedRect`.
* @method PIXI.Graphics#rc
* @param {Number} x
* @param {Number} y
* @param {Number} w Width of the rectangle
* @param {Number} h Height of the rectangle
* @param {Number} radiusTL The top left corner radius
* @param {Number} radiusTR The top right corner radius
* @param {Number} radiusBR The bottom right corner radius
* @param {Number} radiusBL The bottom left corner radius
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.rc = p.drawRoundedRect;
/**
* Shortcut to `drawCircle`.
* @method PIXI.Graphics#dc
* @param {Number} x x coordinate center point of circle.
* @param {Number} y y coordinate center point of circle.
* @param {Number} radius Radius of circle.
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.dc = p.drawCircle;
/**
* Shortcut to `arc`.
* @method PIXI.Graphics#ac
* @param {Number} x
* @param {Number} y
* @param {Number} radius
* @param {Number} startAngle Measured in radians.
* @param {Number} endAngle Measured in radians.
* @param {Boolean} anticlockwise
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.ar = p.arc;
/**
* Shortcut to `arcTo`.
* @method PIXI.Graphics#at
* @param {Number} x1
* @param {Number} y1
* @param {Number} x2
* @param {Number} y2
* @param {Number} radius
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.at = p.arcTo;
/**
* Shortcut to `drawEllipse`.
* @method PIXI.Graphics#de
* @param {Number} x [description]
* @param {Number} y [description]
* @param {Number} width [description]
* @param {Number} height [description]
*/
p.de = p.drawEllipse;
/**
* Placeholder method for a linear fill. Pixi does not support linear fills,
* so we just pick the first color in colorArray
* @method PIXI.Graphics#lf
* @param {Array} colorArray An array of CSS compatible color values @see `f`
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.lf = function(colorArray) {
// @if DEBUG
console.warn("Linear gradient fills are not supported");
// @endif
return this.f(colorArray[0]);
};
/**
* Placeholder method for a radial fill. Pixi does not support radial fills,
* so we just pick the first color in colorArray
* @method PIXI.Graphics#rf
* @param {Array} colorArray An array of CSS compatible color values @see `f`
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.rf = function(colorArray) {
// @if DEBUG
console.warn("Radial gradient fills are not supported");
// @endif
return this.f(colorArray[0]);
};
/**
* Placeholder method for a `beginBitmapFill`. Pixi does not support bitmap fills.
* @method PIXI.Graphics#bf
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.bf = function() {
// @if DEBUG
console.warn("Bitmap fills are not supported");
// @endif
return this.f(0x0);
};
/**
* Placeholder method for a `setStrokeDash`. Pixi does not support dashed strokes.
* @method PIXI.Graphics#sd
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.sd = function() {
// @if DEBUG
console.warn("Dashed strokes are not supported");
// @endif
return this;
};
/**
* Placeholder method for a `beginBitmapStroke`. Pixi does not support bitmap strokes.
* @method PIXI.Graphics#bs
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.bs = function() {
// @if DEBUG
console.warn("Bitmap strokes are not supported");
// @endif
return this;
};
/**
* Placeholder method for a `beginLinearGradientStroke`. Pixi does not support gradient strokes.
* @method PIXI.Graphics#ls
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.ls = function() {
// @if DEBUG
console.warn("Linear gradient strokes are not supported");
// @endif
return this;
};
/**
* Placeholder method for a `beginRadialGradientStroke`. Pixi does not support gradient strokes.
* @method PIXI.Graphics#rs
* @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
**/
p.rs = function() {
// @if DEBUG
console.warn("Radial gradient strokes are not supported");
// @endif
return this;
};