package canvas;

import java.awt.Color;


public class Context{

		public String toString() {
			return null;
		}
	
	
	/**
	 * Canvas to which context is associated (Read only)
	 */
	public final Object canvas = null;
	
	/**Path object used to perform path operations*/
	public Path2D tmp_path=new Path2D();
	

	/**
	 * Called whenever script is saved
	 */
	public void reset() {

	}

	//************************************CANVAS API COMMANDS*******************************//
	
	/**
	 * Save saves the current draw state to a stack
	 */
	public void save() {
		
	}

	/**
	 * Restore restores the last draw state from the stack if available
	 */
	public void restore() {
		
	}

	
	
	
	// ************************************Rendering Commands ***********************************

	
	/**
	 * Clears canvas and removes all render commands as well as resets transform
	 * to identity (Note that active animations are not cleared by this command	
 	 @see {@link #clearAnimations()}
	 */
	public void clear() {
		
	}

	/**
	 * Clears the specified pixels within a given rectangle. replaces the portion in this rectangle
	 * by background color (or image if any) 
	 * Note: Takes current transform in account
	 * @param x  {Number} The x-axis coordinate of the rectangle's starting point.
	 * @param y  {Number} The y-axis coordinate of the rectangle's starting point.
	 * @param width {Number} The rectangle's width. Positive values are to the right
	 * @param height {Number} The rectangle's height. Positive values are down
	 */
	public void clearRect(double x, double y, double width, double height) {
		
	}
	

	/**
	 * draws a filled oval whose center is at (x, y) and whose size is specified by width and height
	 * This method draws directly to the canvas without modifying the current path, so any subsequent fill() or stroke() calls will have no effect on it.
	 * The fill style is determined by the current fillStyle attribute.<br>
	 * Note: Takes current transform in account
	 * @param {number} x
	 *           centre x
	 * @param {number}y
	 *            center y
	 * @param {number}w
	 *            width of oval
	 * @param {number}h
	 *            height of oval
	 */
	public void fillOval(double cx, double cy, double w, double h) {
		
	}
	
	/**
	 * draws an oval that is stroked (outlined) according to the current strokeStyle and other context settings.
	 * This method draws directly to the canvas without modifying the current path, so any subsequent fill() or stroke() calls will have no effect on it.<br>
	 * Note: Takes current transform in account
	 * 
	 * @param cx {number} 
	 *           center x
	 * @param cy {number}
	 *            center y
	 * @param w {number}
	 *            width of oval
	 * @param h {number}
	 *            height of oval
	 */
	public void strokeOval(double cx, double cy, double w, double h) {
		
	}

	/**
	 * draws a filled rectangle whose starting point is at (x, y) and whose size is specified by width and height
	 * This method draws directly to the canvas without modifying the current path, so any subsequent fill() or stroke() calls will have no effect on it.
	 * The fill style is determined by the current fillStyle attribute.<br>
	 * Note: Takes current transform in account
	 * @param {number} x
	 *            top left x
	 * @param {number}y
	 *            top left y
	 * @param {number}w
	 *            width of rect
	 * @param {number}h
	 *            height of rect
	 */
	public void fillRect(double x, double y, double w, double h) {
		
	}

	/**
	 * draws a rectangle that is stroked (outlined) according to the current strokeStyle and other context settings.
	 * This method draws directly to the canvas without modifying the current path, so any subsequent fill() or stroke() calls will have no effect on it.<br>
	 * Note: Takes current transform in account
	 * 
	 * @param {number} x
	 *            top left x
	 * @param {number}y
	 *            top left y
	 * @param {number}w
	 *            width of rectangle
	 * @param {number}h
	 *            height of rectangle
	 */
	public void strokeRect(double x, double y, double w, double h) {
		
	}

	/**
	 * draws a line joining two points
	 * This method draws directly to the canvas without modifying the current path, so any subsequent fill() or stroke() calls will have no effect on it.
	 * The fill style is determined by the current fillStyle attribute.<br>
	 * Note: Takes current transform in account
	 * @param {number} x1
	 *           x coordinate of first point
	 * @param {number} y1
	 *           y coordinate of first point
	 * @param {number} x2
	 *            x coordinate of second point
	 * @param {number} y2
	 *            y coordinate of second point
	 */
	public void fillLine(double x1, double x2, double y1, double y2) {
		
	}

	/**
	 * draws a line joining two points
	 * This method draws directly to the canvas without modifying the current path, so any subsequent fill() or stroke() calls will have no effect on it.
	 * The stroke style is determined by the current strokeStyle attribute.<br>
	 * Note: Takes current transform in account
	 * @param {number} x1
	 *           x coordinate of first point
	 * @param {number} y1
	 *           y coordinate of first point
	 * @param {number} x2
	 *            x coordinate of second point
	 * @param {number} y2
	 *            y coordinate of second point
	 */
	public void strokeLine(double x1, double x2, double y1, double y2) {
		
	}

	/**
	 * fills the current path with the current fillStyle.
	 * @param windingRule  The algorithm by which to determine if a point is inside or outside the filling region.
							Possible values:<br>
							"nonzero": The non-zero winding rule. Default rule.<br>
							"evenodd": The even-odd winding rule.
	 */
	public void fill(String windingRule) {
		
	}

	/**
	 * Draws the shape (current path) by stroking its outline with current strokeStyle.
	 */
	public void stroke() {
		
	}

	/**
	 * Draws the path by stroking its outline with current strokeStyle.
	 * Note: The path is transformed with current transform before rendering
	 * @param path {path2D} A path to stroke.
	 */
	public void stroke(Path2D path) {
		
	}

	/**
	 * fills the current path with the current fillStyle.
	 */
	public void fill() {

	}

	
	/**
	 * fills the current path with the current fillStyle.
	 * Note: The path is transformed with current transform before rendering
	 * @param path {path2D} A path to fill.
	 */
	public void fill(Path2D path) {

	}


	/***
	 * fills the given path with the current fillStyle.<br>
	 * Note: The path is transformed with current transform before rendering
	 * 
	 * @param path {path2D} A path to fill.
	 * @param windingRule  The algorithm by which to determine if a point is inside or outside the filling region.
							Possible values:<br>
							"nonzero": The non-zero winding rule. Default rule.<br>
							"evenodd": The even-odd winding rule.
	 */
	public void fill(Path2D path,String windingRule) {
		
	}

	/**
	 * draws a text string at the specified coordinates, filling the string's characters with the current fillStyle
	 * @param
	 * @param 
	 */
	public void fillText(String text, double x, double y) {
		
	}

	/**
	 * draws the outlines of — the characters of a text string at the specified coordinates.		 
		 * @param
	 * @param 
	 */
	public void strokeText(String text, double x, double y) {
		
	}

	
	/**
	 * Draws Image/Animation (unscaled)
	 * 
	 * @param img {Image | canvas} Image to be drawn (must already be loaded in resources)
	 * @param {number} x
	 *            top left x coordinate of destination rectangle
	 * @param {number}y
	 *            top left y coordinate of destination rectangle
	 */
	public void drawImage(Object img, double x, double y) throws Exception {
		
	}

	/**
	 * Draws Image/Animation (stretched if necessary) to fit inside the specified rectangle
	 * 
	 * @param img {Image | canvas} Image to be drawn (must already be loaded in resources)
	 * @param {number}x
	 *            top left x coordinate of destination rectangle
	 * @param {number}y
	 *            top left y coordinate of destination rectangle
	 * @param {number}w
	 *            width of destination rectangle 
	 * @param {number}h
	 *            height of destination rectangle
	 */
	public void drawImage(Object img, double x, double y, double w, double h) throws Exception {
		
	}


	/**
	 * Draws Portion of Image to fit inside the specified rectangle
	 * 
	 * @param img {Image | canvas} Image to be drawn (must already be loaded in resources)
	 * @param {number}sx
	 *            The x coordinate where to start clipping
	 * @param {number}sy
	 *            The y coordinate where to start clipping
	 * @param {number}sw
	 *           The width of the clipped image
	 * @param {number}sh
	 *           The height of the clipped image
	 * @param {number}x
	 *            top left x coordinate of destination rectangle
	 * @param {number}y
	 *            top left y coordinate of destination rectangle
	 * @param {number}w
	 *            width of destination rectangle 
	 * @param {number}h
	 *            height of destination rectangle
	 */
	public void drawImage(Object img, double sx, double sy, double sw, double sh,double x, double y, double w, double h) throws Exception {
		
		
	}
	
	/**
	 * Renders Animation (unscaled)
	 * 
	 * @param img {Image} Image to be drawn (must already be loaded in resources)
	 * @param {number} x
	 *            top left x coordinate of destination rectangle
	 * @param {number}y
	 *            top left y coordinate of destination rectangle
	 */
	public void drawAnimation(Image img, double x, double y) {
		
	}

	/**
	 * Renders Animation (stretched if necessary) to fit inside the specified rectangle
	 * 
	 * @param img {Image} Image to be drawn (must already be loaded in resources)
	 * @param {number}x
	 *            top left x coordinate of destination rectangle
	 * @param {number}y
	 *            top left y coordinate of destination rectangle
	 * @param {number}w
	 *            width of destination rectangle (if w==0 then image is not
	 *            stretched in X direction)
	 * @param {number}h
	 *            height of destination rectangle(if h==0 then image is not
	 *            stretched in Y direction)
	 */
	public void drawAnimation(Image img, double x, double y, double w, double h)  {
		
	}

	public void drawScene(Scene scene) {

	}
	
	public void drawArrays(String type, float[] params){
		
	}
	

	// ***************************************DrawStyle Methods***********************************
	/**
	 * turns the current path into the current clipping region. It replaces any previous clipping region.
	 */
	public void clip(){

	}

	/**
	 * turns the current path into the current clipping region. It replaces any previous clipping region.
	 * @param windingRule  The algorithm by which to determine if a point is inside or outside the filling region.
							Possible values:<br>
							"nonzero": The non-zero winding rule. Default rule.<br>
							"evenodd": The even-odd winding rule.
	*/
	public void clip(String windingRule){
		
	}
	
	/**
	 * turns the given path into the current clipping region. It replaces any previous clipping region.
	 * @param path {path2D} A path to clip.
	 */
	public void clip(Path2D path){

	}
	
	/**
	 * turns the given path into the current clipping region. It replaces any previous clipping region.
	 * @param path {path2D} A path to clip.
	 * @param windingRule  The algorithm by which to determine if a point is inside or outside the filling region.
							Possible values:<br>
							"nonzero": The non-zero winding rule. Default rule.<br>
							"evenodd": The even-odd winding rule.
	*/
	public void clip(Path2D path,String windingRule){
		
	}
	

/**
 * This sets the type of compositing operation to apply when drawing new
 * shapes, where type is a string identifying which of the twelve
 * compositing operations to use.
 *
 * @param type
 *            "source-over"|"source-in"|"destination-over" etc
 */
public void setGlobalCompositeOperation(String type)  {
	
}
	/**
	 * Sets the alpha or transparency value of the drawing.
	 * 
	 * @param alpha
	 *            {Number} must be a number between 0.0 (fully transparent) and
	 *            1.0 (no transparency)
	 */

	public void setGlobalAlpha(double alpha) {
		
	}

	/**
	 * returns current transparency value
	 * 
	 * @return
	 */
	public double getGlobalAlpha() {
		return 0;
	}
	
	/**
	 * Creates a linear gradient along the line connecting two given coordinates.<br>
	 * <b>Note:</b> Gradient coordinates are global, i.e., relative to the current coordinate space. 
	 * When applied to a shape, the coordinates are NOT relative to the shape's coordinates.
	 * @param x0 The x-axis coordinate of the start point.
	 * @param y0 The y-axis coordinate of the start point.
	 * @param x1 The x-axis coordinate of the end point.
	 * @param y1 The y-axis coordinate of the end point.
	 * @return a LinearGradient object. To be applied to a shape, the gradient must first be assigned to the {@link #setFillStyle(Object)} or {@link #setFillStyle(Object)} properties.<br>
	 * <br> Note: use {@link #Gradient.addColorStop(pos,col)} method of returning object to create gradient colors
	 */
	public Gradient createLinearGradient(double x0, double y0,double x1, double y1) {
		return null;

	}

	/**
	 * Creates a radial gradient using the size and coordinates of two circles.<br>
	 * <b>Note:</b> Gradient coordinates are global, i.e., relative to the current coordinate space. 
	 * When applied to a shape, the coordinates are NOT relative to the shape's coordinates.
	 * @param x0 The x-axis coordinate of the start circle.
	 * @param y0 The y-axis coordinate of the start circle.
	 * @param r0 The radius of the start circle. Must be non-negative and finite.
	 * @param x1 The x-axis coordinate of the end circle.
	 * @param y1 The y-axis coordinate of the end circle.
	 * @param r1 The radius of the end circle. Must be non-negative and finite.
	 * @return a RadialGradient object. To be applied to a shape, the gradient must first be assigned to the {@link #setFillStyle(Object)} or {@link #setFillStyle(Object)} properties.<br>
	 * <br> Note: use {@link #Gradient.addColorStop(pos,col)} method of returning object to create gradient colors
	 */
	public Gradient createRadialGradient(double x0, double y0,double r0,double x1, double y1,double r1){
		return null;

	}
	
	/**
	 * Creates a pattern using the specified image and repetition.<br>
	 * <b>Note:</b> Gradient coordinates are global, i.e., relative to the current coordinate space. 
	 * When applied to a shape, the coordinates are NOT relative to the shape's coordinates.
	 * @param image {Image} An Image to be used as the pattern's image.
	 * @param repeat {String} indicating how to repeat the pattern's image. Possible values are: "repeat"|"repeat-x"|"repeat-y"|"no-repeat"
	 * @return a FillPattern object. To be applied to a shape, the pattern must first be assigned to the {@link #setFillStyle(Object)} or {@link #setFillStyle(Object)} properties.<br>
	 */
	public FillPattern createPattern(Image img, String repeat) {
		return null;

	}

	/**
	 * Sets current Fill Color,all subsequent Shapes are filled using this color
	 * 
	 * @param {Number}r red component between 0 and 1 inclusive
	 * @param {Number}g green component between 0 and 1 inclusive
	 * @param {Number}b blue component between 0 and 1 inclusive
	 * @param {Number}a alpha component between 0 and 1 inclusive
	 */
	public void setFillStyle(double r, double g, double b, double a) {

	}

	/**
	 * Sets current FillStyle,all subsequent Shapes are filled using this style
	 * 
	 * @param style {Object} Can be one of following<br>
	 * <ul>
	 * <li><b>Color :</b> Color Object or a String parsed as CSS color value. 
	 * <li><b>Gradient :</b> A Gradient object (a linear or radial gradient).
	 * <li><b>Pattern :</b> A FillPattern object (a repeating image).
	 * <li><b>String :</b> Css color string , for example<br>
	 *            <ol>
	 *            <li>Common color name "red", "green"</li>
	 *            <li>Hexadecimal representation of color such as #FF0096 or
	 *            0xFF0096</li>
	 *            <li>Color functions
	 *            "rgb(255,0,0)","hsl(180, 50%, 50%)","rgba(255,255,120,1)"</li>
	 * @throws IllegalArgumentException
	 *             if style is null or invalid
	 */
	public void setFillStyle(Object style) throws IllegalArgumentException {
		
	}

	/**
	 * returns the style used for filling shapes
	 * 
	 * @return {Object} fillStyle used to fill shapes
	 */
	public Object getFillStyle() {
		return null;

	}

	/**
	 * Sets current Draw Color,all subsequent outlines for Shapes are drawn
	 * using this color
	 * 
	 * @param {Number}r red component between 0 and 1 inclusive
	 * @param {Number}g green component between 0 and 1 inclusive
	 * @param {Number}b blue component between 0 and 1 inclusive
	 * @param {Number}a alpha component between 0 and 1 inclusive
	 */
	public void setStrokeStyle(double r, double g, double b, double a) {
		
	}

	/**
	 * Sets current StrokeStyle,all subsequent Shapes are outlines using this style
	 * 
	 * @param style {Object} Can be one of following<br>
	 * <ul>
	 * <li><b>Color :</b> Color Object or a String parsed as CSS color value. 
	 * <li><b>Gradient :</b> A Gradient object (a linear or radial gradient).
	 * <li><b>Pattern :</b> A FillPattern object (a repeating image).
	 * <li><b>String :</b> Css color string , for example<br>
	 *            <ol>
	 *            <li>Common color name "red", "green"</li>
	 *            <li>Hexadecimal representation of color such as #FF0096 or
	 *            0xFF0096</li>
	 *            <li>Color functions
	 *            "rgb(255,0,0)","hsl(180, 50%, 50%)","rgba(255,255,120,1)"</li>
	 * @throws IllegalArgumentException
	 *             if style is null or invalid
	 */
	public void setStrokeStyle(Object style) throws IllegalArgumentException {
		
	}

	/**
	 * returns the color used for lines
	 * 
	 * @return {Object} style used for stroke
	 */
	public Object getStrokeStyle() {
		return null;

	}

	/**
	 * Sets current stroke width
	 * 
	 * @param {Number} width of canvas in pixel (must be >0 and can be non
	 *        integral,the value is 1.0 by default.}
	 */
	public void setLineWidth(double lw) {
		
	}

	/** The width of stroked lines */
	public double getLineWidth() {
		return 0;
	}

	
	/**
	 * Sets the horizontal distance the shadow should extend from the object. 
	 * This value isn't affected by the transformation matrix. The default is 0.
	 * @param shadowOffsetX
	 */
	public void setShadowOffsetX(double shadowOffsetX){
		
	}
	
	/**
	 * Returns the horizontal distance the shadow should extend from the object. 
	 */
	public double getShadowOffsetX(){
		return 0;

	}
	
	/**
	 * Sets the vertical distance the shadow should extend from the object. 
	 * This value isn't affected by the transformation matrix. The default is 0.
	 * @param shadowOffsetY
	 */
	public void setShadowOffsetY(double shadowOffsetY){
		
	}
	
	/**
	 * Returns the vertical distance the shadow should extend from the object. 
	 */
	public double getShadowOffsetY(){
		return 0;

	}
	
	/**
	 * Sets the size of the blurring effect; 
	 * this value doesn't correspond to a number of pixels and is not affected by the current transformation matrix. The default value is 0.
	 * @param shadowBlur
	 */
	public void setShadowBlur(double shadowBlur){
		
	}
	
	/**
	 * Returns the size of the blurring effect; 
	 */
	public double getShadowBlur(){
		return 0;

	}

	/**
	 * Sets the color of the shadow effect; by default, it is fully-transparent black.
	 * 
	 * @param style {Object} Can be one of following<br>
	 * <ul>
	 * <li><b>Color :</b> Color Object or a String parsed as CSS color value. 
	 * <li><b>String :</b> Css color string , for example<br>
	 *            <ol>
	 *            <li>Common color name "red", "green"</li>
	 *            <li>Hexadecimal representation of color such as #FF0096 or
	 *            0xFF0096</li>
	 *            <li>Color functions
	 *            "rgb(255,0,0)","hsl(180, 50%, 50%)","rgba(255,255,120,1)"</li>
	 * @throws IllegalArgumentException
	 *             if style is null or invalid
	 */
	public void setShadowColor(Object color) throws IllegalArgumentException {
		
	}

	/**
	 * returns the color of the shadow effect
	 * @return {Color} color used for shadow
	 */
	public Color getShadowColor() {
		return null;
	}
	
	/**
	 * Sets horizontal alignment of text
	 * 
	 * @param align
	 *            {String}The value can be "Left"(default), "Center", "Right",
	 *            "Start", or "End"
	 */
	public void setTextAlign(String alignX) {
		
	}

	/**
	 * Returns horizontal alignment of text
	 */
	public String getTextAlign() {
		return null;

	}

	/**
	 * Sets vertical alignment of text
	 * 
	 * @param align
	 *            {String} The value can be "Alphabetic" (default), "Top",
	 *            "Hanging", "Middle","Ideographic", or "Bottom"
	 */
	public void setTextBaseline(String alignY) {
		
	}

	/**
	 * Sets current font, all subsequent text are drawn using this font
	 * 
	 * @param cssFont {String} case insensitive case CSS-font string indicating fontName, fontStyle and fotnSize separated by space in any order. 
	 * Few valid examples are: <br>
	 * <pre>"32px bold Arial", "Arial italic" ,"bold dialog 32px", "Dialog 12"</pre>
	 */
	public void setFont(String cssFont)  {
		
	}

	
	/**
	 * Returns current font
	 */
	public String getFont() {
		return null;

	}

	/**
	 * Returns a TextMetrics object containing the width, in pixels, that the specified text will be when drawn in the current text style.
	 * @param text {String} text to be measured
	 * @return TextMetric Object {width, height, actualBoundingboxAscent,actualBoundingboxDescent)
	 */
	public TextMetrics measureText(String text){
		return null;

	}
	
	
	/**
	 * SetLineJoin sets the style of line joints for rendering a path with
	 * Stroke.
	 * 
	 * @param lineJoin
	 *            {String} The value can be "Miter", "Bevel"(default), or
	 *            "Round"
	 */
	public void setLineJoin(String lineJoin) {
		
	}

	/**
	 * returns the style of line joints for rendering a path with Stroke.
	 * 
	 * @return {String}
	 */
	public String getLineJoin() {
		return null;

	}

	/**
	 * SetLineCap sets the style of line endings for rendering a path with
	 * Stroke
	 * 
	 * @param lineCap
	 *            {String} The value can be "Butt"(default), "Square", or
	 *            "Round"
	 */
	public void setLineCap(String lineCap){
		
	}

	/**
	 * returns the style of line endings for rendering a path with Stroke
	 * 
	 * @return {String}
	 */
	public String getLineCap() {
		return null;
	}

	/**
	 * SetMiterLimit sets the limit (default==10) for how far a miter line join
	 * can be extend.
	 * 
	 * @param limit
	 *            {number}
	 */
	public void setMiterLimit(double limit)  {
		
	}

	/**
	 * Return the limit for how far a miter line join can be extend.
	 * 
	 * @return {number}
	 */
	public double getMiterLimit() {
		return 0;

	}

	/**
	 * SetLineDash sets the line dash style
	 * 
	 * @param dash
	 */
	public void setLineDash(float[] dash){
		
	}

	/**
	 * returns the current line dash pattern.
	 * 
	 * @return {Array}
	 */
	public float[] getLineDash() {
		return null;
	}

	/**
	 * Sets the line dash offset, or "phase."
	 * 
	 * @param offset
	 *            {Number} A double specifying the amount of the line dash
	 *            offset. The default value is 0.0.
	 */
	public void setLineDashOffset(double offset) {
		
	}

	/**
	 * returns the line dash offset, or "phase."
	 * 
	 * @return{Number
	 */
	public double getLineDashOffset() {
		return 0;
	}

	// ***************************************Transform Methods***********************************
	/**
	 * updates the current transformation with a scaling by the given values
	 * 
	 * @param {Number} sx
	 * @param {Number} sy
	 */
	public void scale(double scaleX, double scaleY) {
		
	}

	/**
	 * updates the current transformation with a translation by the given values
	 * 
	 * @param {Number} tx
	 * @param {Number} ty
	 */
	public void translate(double tx, double ty) {
		
	}

	/**
	 * updates the current transformation with a rotation by the given angle
	 * 
	 * @param {Number}th The rotation angle in radians. (Clockwise as positive)
	 */
	public void rotate(double th) {
		
	}

	/**
	 * Resets the current transform to the identity matrix, and then runs
	 * {@link #transform(float, float, float, float, float)} with the same
	 * arguments.
	 * 
	 * @param a
	 *            {Number} Horizontal scaling. A value of 1 results in no
	 *            scaling.
	 * @param b
	 *            {Number} Vertical skewing. (0 means o skewing)
	 * @param c
	 *            {Number} Horizontal skewing. (0 means o skewing)
	 * @param d
	 *            {Number} Vertical scaling. A value of 1 results in no scaling.
	 * @param e
	 *            {Number} Horizontal translation (moving).
	 * @param f
	 *            {Number} Vertical translation (moving).
	 * @see #setTransform(float, float, float, float, float)
	 * @see #resetTransform()
	 */
	public void setTransform(double a, double b, double c, double d, double e, double f){
		
	}

	/**
	 * Resets the current transform to the identity matrix, and then runs
	 * {@link #transform(Transform)} with the same
	 * arguments.
	 * @param transform
	 * @param f
	 */
	public void setTransform(Transform transform) {
		
	}
	
	/**
	 * Multiplies the current transformation with the matrix described by the
	 * arguments of this method.Transforms point (x,y) to (x'y') as below
	 * <pre>
	 * x'=ax+cy+e
	 * y'=by+dx+f
	 * </pre>
	 * 
	 * @param a
	 *            {Number} Horizontal scaling. A value of 1 results in no
	 *            scaling.
	 * @param b
	 *            {Number} Vertical skewing. (0 means o skewing)
	 * @param c
	 *            {Number} Horizontal skewing. (0 means o skewing)
	 * @param d
	 *            {Number} Vertical scaling. A value of 1 results in no scaling.
	 * @param e
	 *            {Number} Horizontal translation (moving).
	 * @param f
	 *            {Number} Vertical translation (moving).
	 * @see #setTransform(float, float, float, float, float)
	 * @see #resetTransform()
	 */
	public void transform(double a, double b, double c, double d, double e, double f) {
		
	}

	/**
	 * Multiplies the current transformation with the transform described by the
	 * arguments of this method.
	 * @param transform
	 */
	public void transform(Transform transform) {
		
	}

	
	/**
	 * Resets transform to identity call to this function brings origin at top
	 * left position and scales in both direction as unity (1 pixel per unit)
	 * 
	 * @see {@link #scale(float, float)}
	 * @see {@link #translate(float, float)}
	 */
	public void resetTransform() {
		
	}

	/**
	 * returns current transform of context
	 * @return
	 */
	public Transform getTransform() {
		return null;
	}
	
	// /**************************************Path Methods ******************************************************

	/**
	 * Resets the path to empty. The append position is set back to the
	 * beginning of the path and all coordinates and point types are forgotten
	 */
	public void beginPath() {

	}

	/**
	 * Adds a point to the path by moving to the specified coordinates, without
	 * creating a line
	 * 
	 * @param x
	 *            {Number} x coordinate
	 * @param y
	 *            {Number} y coordinate
	 * @throws SimphyScriptException 
	 */
	public void moveTo(double x, double y) {
		
	}

	/**
	 * Adds a point to the path by drawing a straight line from the current
	 * coordinates to the new specified coordinates
	 * 
	 * @param x
	 *            {Number} x coordinate
	 * @param y
	 *            {Number} y coordinate
	 */
	public void lineTo(double x, double y) {
		
	}

	/**
	 * creates a rectangular path whose starting point is at (x, y) and whose
	 * size is specified by width and height
	 * 
	 * @param x
	 *            {Number} x coordinate of the rectangle's starting point.
	 * @param y
	 *            {Number} y coordinate of the rectangle's starting point.
	 * @param width
	 *            {Number} The rectangle's width. Positive values are to the
	 *            right, and negative to the left.
	 * @param height
	 *            {Number} The rectangle's height. Positive values are down, and
	 *            negative are up.
	 */
	public void rect(double x, double y, double width, double height) {
		
	}

	/**
	 * creates an arc (used to create circles, or parts of circles)
	 * 
	 * @param x
	 *            {Number} The x-coordinate of the center of the circle
	 * @param y
	 *            {Number} The y-coordinate of the center of the circle
	 * @param r
	 *            {Number} The radius of the circle
	 * @param sa
	 *            {Number} The starting angle, measured clockwise from the
	 *            positive x-axis and expressed in radians.
	 * @param ea
	 *            {Number} The ending angle, measured clockwise from the
	 *            positive x-axis and expressed in radians.
	 */
	public void arc(double x, double y, double r, double sa, double ea) {
		
	}

	/**
	 * creates an arc/curve (used to create circles, or parts of circles)
	 * 
	 * @param x
	 *            {Number} The x-coordinate of the center of the circle
	 * @param y
	 *            {Number} The y-coordinate of the center of the circle
	 * @param r
	 *            {Number} The radius of the circle
	 * @param sa
	 *            {Number} The starting angle, measured clockwise from the
	 *            positive x-axis and expressed in radians.
	 * @param ea
	 *            {Number} The ending angle, measured clockwise from the
	 *            positive x-axis and expressed in radians.
	 * @param ccw
	 *            {Boolean} if true drawing is done counterclockwise else
	 *            clockwise
	 */
	public void arc(double x, double y, double r, double sa, double ea, boolean acw) {
		
	}

	/**
	 * creates a circular arc passing through currentPoint(current moveTo),
	 * (x1,y1) and (x2,y2)
	 * 
	 * @param x1
	 *            {Number} The x-coordinate of the first point
	 * @param y1
	 *            {Number} The y-coordinate of the first point
	 * @param x2
	 *            {Number} The x-coordinate of the second point
	 * @param y2
	 *            {Number} The x-coordinate of the second point
	 * @param r
	 *            {Number} The arc's radius. Must be non-negative.
	 */
	public void arcTo(double x1, double y1, double x2, double y2, double r) {
		
	}

	/**
	 * Adds a curved segment, defined by two new points, to the path by drawing
	 * a Quadratic curve that intersects both the current coordinates(moveTo)
	 * and the specified coordinates (x,y)
	 * 
	 * @param cpx
	 *            {Number} The x-coordinate of the quadratic control point
	 * @param cpy
	 *            {Number} The y-coordinate of the quadratic control point
	 * @param x
	 *            {Number} The x-coordinate of the ending point
	 * @param y
	 *            {Number} The y-coordinate of the ending point
	 */
	public void quadraticCurveTo(double cpx, double cpy, double x, double y) {
		
	}

	/**
	 * Adds a curved segment, defined by three new points, to the path by
	 * drawing a Bezier curve that intersects both the current coordinates and
	 * the specified coordinates (x,y), using the specified points (cpx1,cpy1)
	 * and (cpx2,cpy2) as Bezier control points.
	 * 
	 * @param cpx1
	 *            {Number} The x-coordinate of the first Bezier control point
	 * @param cpy1
	 *            {Number} The y-coordinate of the first Bezier control point
	 * @param cpx2
	 *            {Number} The x-coordinate of the second Bezier control point
	 * @param cpy2
	 *            {Number} The x-coordinate of the second Bezier control point
	 * @param x
	 *            {Number} The x-coordinate of the ending point
	 * @param y
	 *            {Number} The y-coordinate of the ending point
	 */
	public void bezierCurveTo(double cpx1, double cpy1, double cpx2, double cpy2, double x, double y) {
		
	}

	/**
	 * Creates an ellipse centered at (x,y)  with the radii radiusX and radiusY. 
	 * @param  x, y -- The center of the ellipse offset from the last call.
	 * @param xRadius -- The radius of the ellipse in the x axis.
	 * @param yRadius -- The radius of the ellipse in the y axis.
	 * @param rotation -- The rotation angle of the ellipse in radians, counterclockwise from the positive X axis
	 */
	public void ellipse (double x,double y,double xRadius,double yRadius,double aRotation) {

	}

	/**
	 * creates an elliptical arc centered at (x, y) with the radii radiusX and radiusY. 
	 * The path starts at startAngle and ends at endAngle, and travels in the clockwise direction 
	 * @param  x, y -- The center of the ellipse offset from the last call.
	 * @param xRadius -- The radius of the ellipse in the x axis.
	 * @param yRadius -- The radius of the ellipse in the y axis.
	 * @param rotation -- The rotation angle of the ellipse in radians, counterclockwise from the positive X axis
	 * @param startAngle -- The angle at which the ellipse starts, measured clockwise from the positive x-axis and expressed in radians.
	 * @param endAngle -- The angle at which the ellipse ends, measured clockwise from the positive x-axis and expressed in radians.
	 */
	public void ellipse (double x,double y,double xRadius,double yRadius,double aRotation, double aStartAngle,double aEndAngle) {

	}

	/**
	 * creates an elliptical arc centered at (x, y) with the radii radiusX and radiusY. 
	 * The path starts at startAngle and ends at endAngle, and travels in the direction given by parameter acw
	 * @param  x, y -- The center of the ellipse offset from the last call.
	 * @param xRadius -- The radius of the ellipse in the x axis.
	 * @param yRadius -- The radius of the ellipse in the y axis.
	 * @param rotation -- The rotation angle of the ellipse in radians, counterclockwise from the positive X axis
	 * @param startAngle -- The angle at which the ellipse starts, measured clockwise from the positive x-axis and expressed in radians.
	 * @param endAngle -- The angle at which the ellipse ends, measured clockwise from the positive x-axis and expressed in radians.
	 * @param acw --A Boolean which, if true, draws the ellipse anticlockwise (counter-clockwise)
	 */
	public void ellipse (double x,double y,double xRadius,double yRadius,double aRotation, double aStartAngle,double aEndAngle,boolean acw) {
		
	}
	
	/**
	 * creates a path from the current point back to the starting point.
	 */
	public void closePath() {

	}

	/**
	 * returns true if a certain point is in the current path 
	 * @param x x-coordinate in canvas space (top left as origin)
	 * @return y y-coordinate in canvas space (top left as origin)
	 */
	public boolean isPointInPath(double x, double y){
		return true;

	}
	
	/**
	 * returns true if a certain point is in the specified path 
	 * @param x x-coordinate in canvas space (top left as origin)
	 * @return y y-coordinate in canvas space (top left as origin)
	 */
	public boolean isPointInPath(Path2D path,double x, double y){
		return true;

	}
	
	//************************Pixel Manipulations***************************************
	/**
	 * Returns an ImageData object containing a copy of the pixel data for area of canvas context, whose corners are represented by the points (left,top), (left+width, top), (left, top+height), and (left+width, top+height).<br>
	 * Note 1:The coordinates are specified in canvas coordinate space units.
	 * Note 2:The Pixel data is not immediately available, actually The data is filled in next render call, so use {@link ImageData#isFilled()} to check if data is actually available
	 * @param left
	 * @param top
	 * @param width
	 * @param height
	 * @return {ImageData} pixel data can be retrieved using {@link ImageData#getData()} method of returned object
	 */
	public ImageData createImageData(int width, int height) {
		return null;
	}

	/**
	 * Returns an ImageData object containing a copy of the pixel data for area of canvas context, whose corners are represented by the points (left,top), (left+width, top), (left, top+height), and (left+width, top+height).<br>
	 * Note 1:The coordinates are specified in canvas coordinate space units.
	 * Note 2:The Pixel data is not immediately available, actually The data is filled in next render call, so use {@link ImageData#isFilled()} to check if data is actually available
	 * @param left
	 * @param top
	 * @param width
	 * @param height
	 * @return {ImageData} pixel data can be retrieved using {@link ImageData#getData()} method of returned object
	 */
	public ImageData getImageData(int left, int top, int width, int height)  {
		return null;
	}
	
	/**
	 * Paints pixel data in content, the The destX and destY parameters indicate the device coordinates within the context at which to paint the top left corner of the pixel data you wish to draw.
	 * @param data
	 * @param destX
	 * @param destY
	 */
	public void putImageData(ImageData data, int destX, int destY){
		
	}
	
	
	//*************************Processing Commands / Actual Rendering ********************************
	
	

	public void resize(int width, int height) {
		
		}

}
