/*
 * Java
 *
 * Copyright 2021-2023 MicroEJ Corp. All rights reserved.
 * This library is provided in source code for use, modification and test, subject to license terms.
 * Any modification of the source code will break MicroEJ Corp. warranties on the whole library.
 *
 * This File is a derivative work. Subject to §4 of the applicable Apache License, MicroEJ provides the above different license terms and conditions for use.
 *
 * // Copyright (C) 2006 The Android Open Source Project
 * //
 * // Licensed under the Apache License, Version 2.0 (the "License");
 * // you may not use this file except in compliance with the License.
 * // You may obtain a copy of the License at
 * //
 * //      http://www.apache.org/licenses/LICENSE-2.0
 * //
 * // Unless required by applicable law or agreed to in writing, software
 * // distributed under the License is distributed on an "AS IS" BASIS,
 * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * // See the License for the specific language governing permissions and
 * // limitations under the License.
 */
package ej.microvg;

/**
 * Represents a geometric paths consisting of straight line segments, quadratic curves, and cubic curves.
 */
public class Path {

	/**
	 * Creates an empty path.
	 * <p>
	 * The origin is set to (0,0).
	 */
	public Path() {
		throw new VectorGraphicsException();
	}

	/**
	 * Resets the path to an empty one.
	 * <p>
	 * The origin is also reset to (0,0).
	 */
	public void reset() {
		throw new VectorGraphicsException();
	}

	/**
	 * Sets the beginning of the next contour to the point (x,y).
	 *
	 * @param x
	 *            the x-coordinate of the start of a new contour
	 * @param y
	 *            the y-coordinate of the start of a new contour
	 */
	public void moveTo(float x, float y) {
		throw new VectorGraphicsException();
	}

	/**
	 * Sets the beginning of the next contour relative to the last point on the previous contour. If there is no
	 * previous contour, this is treated the same as {@link #moveTo(float, float)}.
	 *
	 * @param dx
	 *            the amount to add to the x-coordinate of the end of the previous contour, to specify the start of a
	 *            new contour
	 * @param dy
	 *            the amount to add to the y-coordinate of the end of the previous contour, to specify the start of a
	 *            new contour
	 */
	public void moveToRelative(float dx, float dy) {
		throw new VectorGraphicsException();
	}

	/**
	 * Adds a line from the last point to the specified point (x,y). If no {@link #moveTo(float, float)} call has been
	 * made for this contour, the first point is automatically set to (0,0).
	 *
	 * @param x
	 *            the x-coordinate of the end of a line
	 * @param y
	 *            the y-coordinate of the end of a line
	 */
	public void lineTo(float x, float y) {
		throw new VectorGraphicsException();
	}

	/**
	 * Same as {@link #lineTo(float, float)}, but the coordinates are considered relative to the last point on this
	 * contour. If there is no previous point, then a <code>moveTo(0,0)</code> is inserted automatically.
	 *
	 * @param dx
	 *            the amount to add to the x-coordinate of the previous point on this contour, to specify a line
	 * @param dy
	 *            the amount to add to the y-coordinate of the previous point on this contour, to specify a line
	 */
	public void lineToRelative(float dx, float dy) {
		throw new VectorGraphicsException();
	}

	/**
	 * Adds a quadratic bezier from the last point, approaching control point (x1,y1), and ending at (x2,y2). If no
	 * {@link #moveTo(float, float)} call has been made for this contour, the first point is automatically set to (0,0).
	 *
	 * @param x1
	 *            the x-coordinate of the control point on a quadratic curve
	 * @param y1
	 *            the y-coordinate of the control point on a quadratic curve
	 * @param x2
	 *            the x-coordinate of the end point on a quadratic curve
	 * @param y2
	 *            the y-coordinate of the end point on a quadratic curve
	 */
	public void quadTo(float x1, float y1, float x2, float y2) {
		throw new VectorGraphicsException();
	}

	/**
	 * Same as {@link #quadTo(float, float, float, float)}, but the coordinates are considered relative to the last
	 * point on this contour. If there is no previous point, then a moveTo(0,0) is inserted automatically.
	 *
	 * @param dx1
	 *            the amount to add to the x-coordinate of the last point on this contour, for the control point of a
	 *            quadratic curve
	 * @param dy1
	 *            the amount to add to the y-coordinate of the last point on this contour, for the control point of a
	 *            quadratic curve
	 * @param dx2
	 *            the amount to add to the x-coordinate of the last point on this contour, for the end point of a
	 *            quadratic curve
	 * @param dy2
	 *            the amount to add to the y-coordinate of the last point on this contour, for the end point of a
	 *            quadratic curve
	 */
	public void quadToRelative(float dx1, float dy1, float dx2, float dy2) {
		throw new VectorGraphicsException();
	}

	/**
	 * Adds a cubic bezier from the last point, approaching control points (x1,y1) and (x2,y2), and ending at (x3,y3).
	 * If no {@link #moveTo(float, float)} call has been made for this contour, the first point is automatically set to
	 * (0,0).
	 *
	 * @param x1
	 *            the x-coordinate of the 1st control point on a cubic curve
	 * @param y1
	 *            the y-coordinate of the 1st control point on a cubic curve
	 * @param x2
	 *            the x-coordinate of the 2nd control point on a cubic curve
	 * @param y2
	 *            the y-coordinate of the 2nd control point on a cubic curve
	 * @param x3
	 *            the x-coordinate of the end point on a cubic curve
	 * @param y3
	 *            the y-coordinate of the end point on a cubic curve
	 */
	public void cubicTo(float x1, float y1, float x2, float y2, float x3, float y3) {
		throw new VectorGraphicsException();
	}

	/**
	 * Same as {@link #cubicTo(float, float, float, float, float, float)}, but the coordinates are considered relative
	 * to the current point on this contour. If there is no previous point, then a moveTo(0,0) is inserted
	 * automatically.
	 *
	 * @param dx1
	 *            the x-coordinate of the 1st control point on a cubic curve
	 * @param dy1
	 *            the y-coordinate of the 1st control point on a cubic curve
	 * @param dx2
	 *            the x-coordinate of the 2nd control point on a cubic curve
	 * @param dy2
	 *            the y-coordinate of the 2nd control point on a cubic curve
	 * @param dx3
	 *            the x-coordinate of the end point on a cubic curve
	 * @param dy3
	 *            the y-coordinate of the end point on a cubic curve
	 */
	public void cubicToRelative(float dx1, float dy1, float dx2, float dy2, float dx3, float dy3) {
		throw new VectorGraphicsException();
	}

	/**
	 * Closes the current contour. If the current point is not equal to the first point of the contour, a line segment
	 * is automatically added.
	 */
	public void close() {
		throw new VectorGraphicsException();
	}

	/**
	 * Sets the offset that will be applied to all the subsequent absolute points of the contour.
	 *
	 * @param dx
	 *            the amount in the x direction to offset the subsequent points
	 * @param dy
	 *            the amount in the y direction to offset the subsequent points
	 */
	public void setOrigin(float dx, float dy) {
		throw new VectorGraphicsException();
	}

	/**
	 * Gets the left bound of this path.
	 * <p>
	 * If this path does not contain any point, all bounds are equal to 0.
	 *
	 * @return the left bound of this path
	 */
	public float getLeftBound() {
		throw new VectorGraphicsException();
	}

	/**
	 * Gets the right bound of this path.
	 * <p>
	 * If this path does not contain any point, all bounds are equal to 0.
	 *
	 * @return the right bound of this path
	 */
	public float getRightBound() {
		throw new VectorGraphicsException();
	}

	/**
	 * Gets the top bound of this path.
	 * <p>
	 * If this path does not contain any point, all bounds are equal to 0.
	 *
	 * @return the top bound of this path
	 */
	public float getTopBound() {
		throw new VectorGraphicsException();
	}

	/**
	 * Gets the bottom bound of this path.
	 * <p>
	 * If this path does not contain any point, all bounds are equal to 0.
	 *
	 * @return the bottom bound of this path
	 */
	public float getBottomBound() {
		throw new VectorGraphicsException();
	}
}