/** * Writes the value expressed as a {@code cartesian2}, which is the number of grid lines along each axis. * @param x The X component. * @param y The Y component. */ public final void writeCartesian2(double x, double y) { writeCartesian2(new Rectangular(x, y)); }
/** * Adds a specified set of {@link Rectangular} coordinates to another specified set of {@link Cartesian} coordinates. * @param left The augend, or value to which {@code right} is to be added. * @param right The addend, or value which is to be added to {@code left}. * @return A set of {@link Rectangular} coordinates that represents the result of the addition. */ @CS2JInfo("This method implements the functionality of the overloaded operator: 'Rectangular +(Rectangular,Rectangular)'") @Nonnull public static Rectangular add(@Nonnull Rectangular left, @Nonnull Rectangular right) { return left.add(right); }
/** * Divides a specified set of {@link Rectangular} coordinates by a scalar. * @param left The dividend, or value which is to be divided by {@code right}. * @param right The divisor, or value which is to divide {@code left}. * @return A set of {@link Rectangular} coordinates that represents the result of the division. */ @CS2JInfo("This method implements the functionality of the overloaded operator: 'Rectangular /(Rectangular,System.Double)'") @Nonnull public static Rectangular divide(@Nonnull Rectangular left, double right) { return left.divide(right); }
/** * Writes a {@link Rectangular} value as an array in X, Y order. * @param output The stream to which to write the value. * @param value The value to write. */ public static void writeCartesian2(CesiumOutputStream output, @Nonnull Rectangular value) { output.writeStartSequence(); output.writeValue(value.getX()); output.writeValue(value.getY()); output.writeEndSequence(); }
/** * Indicates whether another object is exactly equal to this instance. * @param obj The object to compare to this instance. * @return {@code true} if {@code obj} is an instance of this type and represents the same value as this instance; otherwise, {@code false}. */ @Override public boolean equals(Object obj) { return obj instanceof Rectangular && equalsType((Rectangular) obj); }
/** * Multiplies a specified set of {@link Rectangular} coordinates by a scalar. * @param left The multiplicand, or value which is to be multiplied by {@code right}. * @param right The multiplier, or value which is to multiply {@code left}. * @return A set of {@link Rectangular} coordinates that represents the result of the multiplication. */ @CS2JInfo("This method implements the functionality of the overloaded operator: 'Rectangular *(Rectangular,System.Double)'") @Nonnull public static Rectangular multiply(@Nonnull Rectangular left, double right) { return left.multiply(right); }
/** * Subtracts a specified set of {@link Rectangular} coordinates from another specified set of {@link Rectangular} coordinates. * @param left The minuend, or value from which {@code right} is to be subtracted. * @param right The subtrahend, or value which is to be subtracted from {@code left}. * @return A set of {@link Rectangular} coordinates that represents the result of the subtraction. */ @CS2JInfo("This method implements the functionality of the overloaded operator: 'Rectangular -(Rectangular,Rectangular)'") @Nonnull public static Rectangular subtract(@Nonnull Rectangular left, @Nonnull Rectangular right) { return left.subtract(right); }
/** * Returns {@code true} if the two instances are exactly equal. * @param left The instance to compare to {@code right}. * @param right The instance to compare to {@code left}. * @return {@code true} if {@code left} represents the same value as {@code right}; otherwise, {@code false}. */ @CS2JInfo("This method implements the functionality of the overloaded operator: 'System.Boolean ==(Rectangular,Rectangular)'") public static boolean equals(@Nonnull Rectangular left, @Nonnull Rectangular right) { return left.equalsType(right); }
/** * Multiplies a scalar by a specified set of set of {@link Rectangular} coordinates. * @param left The multiplicand, or value which is to be multiplied by {@code right}. * @param right The multiplier, or value which is to multiply {@code left}. * @return A set of {@link Rectangular} coordinates that represents the result of the multiplication. */ @CS2JInfo("This method implements the functionality of the overloaded operator: 'Rectangular *(System.Double,Rectangular)'") @Nonnull public static Rectangular multiply(double left, @Nonnull Rectangular right) { return right.multiply(left); }
/** * Writes the value expressed as a {@code cartesian2}, which is the pixel offset specified as a two-dimensional Cartesian value {@code [X, Y]}, in viewport coordinates in pixels, where X is pixels to the right and Y is pixels up. * @param x The X component. * @param y The Y component. */ public final void writeCartesian2(double x, double y) { writeCartesian2(new Rectangular(x, y)); }
/** * Returns {@code true} if the two instances are not exactly equal. * @param left The instance to compare to {@code right}. * @param right The instance to compare to {@code left}. * @return {@code true} if {@code left} does not represent the same value as {@code right}; otherwise, {@code false}. */ @CS2JInfo("This method implements the functionality of the overloaded operator: 'System.Boolean !=(Rectangular,Rectangular)'") public static boolean notEquals(@Nonnull Rectangular left, @Nonnull Rectangular right) { return !left.equalsType(right); }
/** * Divides this instance by a scalar. * @param scalar The divisor, or value which is to divide this instance. * @return A set of {@link Rectangular} coordinates that represents the result of the division. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final Rectangular divide(double scalar) { return new Rectangular(m_x / scalar, m_y / scalar); }
/** * Writes the value expressed as a {@code cartesian2}, which is the property specified as a two-dimensional Cartesian value {@code [X, Y]}. * @param x The X component. * @param y The Y component. */ public final void writeCartesian2(double x, double y) { writeCartesian2(new Rectangular(x, y)); }
/** * Writes the value expressed as a {@code cartesian2}, which is the thickness specified as a two-dimensional Cartesian value {@code [X, Y]}, in pixels. * @param x The X component. * @param y The Y component. */ public final void writeCartesian2(double x, double y) { writeCartesian2(new Rectangular(x, y)); }
/** * Writes the value expressed as a {@code cartesian2}, which is the number of times the image repeats along each axis. * @param x The X component. * @param y The Y component. */ public final void writeCartesian2(double x, double y) { writeCartesian2(new Rectangular(x, y)); }
/** * Inverts this instance. * @return A set of {@link Rectangular} coordinates that represents the inverse of this instance. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final Rectangular invert() { return new Rectangular(-m_x, -m_y); }
/** * Multiplies this instance by a scalar. * @param scalar The multiplier, or value which is to multiply this instance. * @return A set of {@link Rectangular} coordinates that represents the result of the multiplication. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final Rectangular multiply(double scalar) { return new Rectangular(m_x * scalar, m_y * scalar); }
/** * Adds the specified set of {@link Rectangular} coordinates to this instance. * @param other The addend, or value which is to be added to this instance. * @return A set of {@link Rectangular} coordinates that represents the result of the addition. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final Rectangular add(@Nonnull Rectangular other) { return new Rectangular(m_x + other.m_x, m_y + other.m_y); }
/** * Writes the value expressed as a {@code cartesian2}, which is the background padding specified as a two-dimensional Cartesian value {@code [X, Y]}, in pixels, where X is the horizontal padding, and Y is the vertical padding. * @param x The X component. * @param y The Y component. */ public final void writeCartesian2(double x, double y) { writeCartesian2(new Rectangular(x, y)); }