juno.media.core Module

struct Color;

Represents an ARGB color.

static Color activeBorder();
static Color activeCaption();
static Color activeCaptionText();
static Color appWorkspace();
static Color control();
static Color controlDark();
static Color controlDarkDark();
static Color controlLight();
static Color controlLightLight();
static Color controlText();
static Color desktop();
static Color grayText();
static Color highlight();
static Color highlightText();
static Color hotTrack();
static Color inactiveBorder();
static Color inactiveCaption();
static Color inactiveCaptionText();
static Color info();
static Color infoText();
static Color menu();
static Color menuText();
static Color scrollBar();
static Color window();
static Color windowFrame();
static Color windowText();
static Color transparent();
static Color aliceBlue();
static Color antiqueWhite();
static Color aqua();
static Color aquamarine();
static Color azure();
static Color beige();
static Color bisque();
static Color black();
static Color blanchedAlmond();
static Color blue();
static Color blueViolet();
static Color brown();
static Color burlyWood();
static Color cadetBlue();
static Color chartreuse();
static Color chocolate();
static Color coral();
static Color cornflowerBlue();
static Color cornsilk();
static Color crimson();
static Color cyan();
static Color darkBlue();
static Color darkCyan();
static Color darkGoldenrod();
static Color darkGray();
static Color darkGreen();
static Color darkKhaki();
static Color darkMagenta();
static Color darkOliveGreen();
static Color darkOrange();
static Color darkOrchid();
static Color darkRed();
static Color darkSalmon();
static Color darkSeaGreen();
static Color darkSlateBlue();
static Color darkSlateGray();
static Color darkTurquoise();
static Color darkViolet();
static Color deepPink();
static Color deepSkyBlue();
static Color dimGray();
static Color dodgerBlue();
static Color firebrick();
static Color floralWhite();
static Color forestGreen();
static Color fuchsia();
static Color gainsboro();
static Color ghostWhite();
static Color gold();
static Color goldenrod();
static Color gray();
static Color green();
static Color greenYellow();
static Color honeydew();
static Color hotPink();
static Color indianRed();
static Color indigo();
static Color ivory();
static Color khaki();
static Color lavender();
static Color lavenderBlush();
static Color lawnGreen();
static Color lemonChiffon();
static Color lightBlue();
static Color lightCoral();
static Color lightCyan();
static Color lightGoldenrodYellow();
static Color lightGray();
static Color lightGreen();
static Color lightPink();
static Color lightSalmon();
static Color lightSeaGreen();
static Color lightSkyBlue();
static Color lightSlateGray();
static Color lightSteelBlue();
static Color lightYellow();
static Color lime();
static Color limeGreen();
static Color linen();
static Color magenta();
static Color maroon();
static Color mediumAquamarine();
static Color mediumBlue();
static Color mediumOrchid();
static Color mediumPurple();
static Color mediumSeaGreen();
static Color mediumSlateBlue();
static Color mediumSpringGreen();
static Color mediumTurquoise();
static Color mediumVioletRed();
static Color midnightBlue();
static Color mintCream();
static Color mistyRose();
static Color moccasin();
static Color navajoWhite();
static Color navy();
static Color oldLace();
static Color olive();
static Color oliveDrab();
static Color orange();
static Color orangeRed();
static Color orchid();
static Color paleGoldenrod();
static Color paleGreen();
static Color paleTurquoise();
static Color paleVioletRed();
static Color papayaWhip();
static Color peachPuff();
static Color peru();
static Color pink();
static Color plum();
static Color powderBlue();
static Color purple();
static Color red();
static Color rosyBrown();
static Color royalBlue();
static Color saddleBrown();
static Color salmon();
static Color sandyBrown();
static Color seaGreen();
static Color seaShell();
static Color sienna();
static Color silver();
static Color skyBlue();
static Color slateBlue();
static Color slateGray();
static Color snow();
static Color springGreen();
static Color steelBlue();
static Color tan();
static Color teal();
static Color thistle();
static Color tomato();
static Color turquoise();
static Color violet();
static Color wheat();
static Color white();
static Color whiteSmoke();
static Color yellow();
static Color yellowGreen();
static Color buttonFace();
static Color buttonHighlight();
static Color buttonShadow();
static Color gradientActiveCaption();
static Color gradientInactiveCaption();
static Color menuBar();
static Color menuHighlight();

Gets a system-defined color.

static Color empty;

Represents an uninitialized color.

static Color fromArgb(uint argb);
static Color fromArgb(ubyte alpha, ubyte red, ubyte green, ubyte blue);
static Color fromArgb(ubyte red, ubyte green, ubyte blue);
static Color fromArgb(ubyte alpha, Color baseColor);

Creates a Color structure from the ARGB component values.

static Color fromRgb(uint value);

Creates a GDI+ color structure from a Windows color value.

static Color fromKnownColor(KnownColor color);

Creates a Color structure from the specified predefined color.

static Color fromName(char[] name);

Creates a Color structure from the specified name of a predefined color.

ubyte a();

Gets the alpha component.

ubyte r();

Gets the red component.

ubyte g();

Gets the green component.

ubyte b();

Gets the blue component.

KnownColor toKnownColor();

Gets the KnownColor value.

uint toArgb();

Gets the ARGB value.

uint toRgb();

Converts the value to a Windows color value.

bool isEmpty();

Determines whether this Color structure is uninitialized.

bool isKnownColor();

Determines whether this Color structure is predefined.

bool isSystemColor();

Determines whether this Color structure is a system color.

bool equals(Color other);
bool opEquals(Color other);

Determines whether the specified instance equals this instance.

Returns
true if other is equivalent to the instance; otherwise, false.

Remarks:
To compare colors based solely on their ARGB values, use the toArgb method.

float getBrightness();

Gets the HSB brightness value.

float getSaturation();

Gets the HSB saturation value.

float getHue();

Gets the HSB hue value.

char[] name();

Gets the name.

char[] toString();

Converts this Color to a human-readable string.

class Matrix: juno.base.core.IDisposable;

Encapsulates a 3x3 affine matrix the represents a geometric transform.

this();
this(float m11, float m12, float m21, float m22, float dx, float dy);
this(Rect rect, Point[] plgpts);
this(RectF rect, PointF[] plgpts);

Initializes a new instance.

void dispose();

Releases all resources used by this instance.

Object clone();

Creates an exact copy of this object.

Returns
The object that this method creates.

void invert();

Inverts this object, if it is invertible.

void reset();

Resets this object to have the elements of the identity matrix.

void multiply(Matrix matrix, MatrixOrder order = cast(MatrixOrder)0);

Multiplies this object by the specified object in the specified order.

Parameters
Matrix matrix

The object by which this instance is to be multiplied.

MatrixOrder order

The order of the multiplication.

void scale(float scaleX, float scaleY, MatrixOrder order = cast(MatrixOrder)0);

Applies the specified scale vector to this oject in the specified order.

Parameters
float scaleX

The value by which to scale this object in the x-axis direction.

float scaleY

The value by which to scale this object in the y-axis direction.

MatrixOrder order

The order in which the scale vector is applied.

void shear(float shearX, float shearY, MatrixOrder order = cast(MatrixOrder)0);

Applies the specified shear vector to this oject in the specified order.

Parameters
scaleX

The horizontal shear.

scaleY

The vertical shear.

MatrixOrder order

The order in which the shear vector is applied.

void rotate(float angle, MatrixOrder order = cast(MatrixOrder)0);

Applies a clockwise rotation of the specified angle about the origin to this object.

Parameters
float angle

The angle of the rotation.

MatrixOrder order

The order in which the rotation is applied.

void translate(float offsetX, float offsetY, MatrixOrder order = cast(MatrixOrder)0);

Applies the specified translation vector to this object.

Parameters
float offsetX

The x value by which to translate this object.

float offsetY

The y value by which to translate this object.

MatrixOrder order

The order in which the translation is applied.

float[] elements();

Gets an array of floating-point values that represents the elements of this object.

float offsetX();

Gets the x translation value.

float offsetY();

Gets the y translation value.

bool isIdentity();

Gets a value indicating whether this object is the identity matrix.

Returns
true if this object is identity; otherwise, false.

bool isInvertible();

Gets a value indicating whether this object is invertible.

Returns
true if this matrix is invertible; otherwise, false.

class GraphicsState;

Represents the state of a Graphics object.

class GraphicsContainer;

Represents the internal data of a graphics container.

class Graphics: juno.base.core.IDisposable;

Encapsualtes a GDI+ drawing surface.

alias DrawImageAbort;

bool delegate(void* callbackData)

Provides a callback method for deciding when the drawImage method should prematurely cancel execution.

Parameters
callbackData

Pointer specifying data for the callback method.

Returns
true if the method decides that the drawImage method should prematurely cancel execution; otherwise, false.

final void dispose();

Releases all the resources used by this instance.

static Handle getHalftonePalette();

Gets a handle to the current Windows halftone palette.

static Graphics fromImage(Image image);

Creates a new instance from the specified Image object.

Parameters
Image image

The Image object on which to create the new instance.

static Graphics fromHwnd(Handle hwnd);

Creates a new instance from the specified handle to a window.

Parameters
Handle hwnd

Handle to a window.

static Graphics fromHdc(Handle hdc);

Creates a new instance from the specified handle to a device context.

Parameters
Handle hdc

Handle to a device context.

static Graphics fromHdc(Handle hdc, Handle hdevice);

Creates a new instance from the specified handle to a device context and handle to a device.

Parameters
Handle hdc

Handle to a device context.

Handle hdevice

Handle to a device.

Handle getHdc();

Gets the handle to the device context associated with this instance.

void releaseHdc(Handle hdc);
void releaseHdc();

Releases a device context handle obtained by a previous call to the getHdc method.

Parameters
Handle hdc

Handle to a device context obtained by a previous call to the getHdc method.

GraphicsState save();

Saves the current state of this instance and identifies the saved state with a GraphicsState object.

void restore(GraphicsState state);

Restores the state of this instance to the state represented by a GraphicsState object.

Parameters
GraphicsState state

The state to which to restore this instance.

GraphicsContainer beginContainer();

GraphicsContainer beginContainer(Rect dstrect, Rect srcrect, GraphicsUnit unit);

GraphicsContainer beginContainer(RectF dstrect, RectF srcrect, GraphicsUnit unit);

void endContainer(GraphicsContainer container);

void setClip(Graphics g, CombineMode combineMode = cast(CombineMode)0);

void setClip(Rect rect, CombineMode combineMode = cast(CombineMode)0);

void setClip(RectF rect, CombineMode combineMode = cast(CombineMode)0);

void setClip(Path path, CombineMode combineMode = cast(CombineMode)0);

void setClip(Region region, CombineMode combineMode);

void intersectClip(RectF rect);

void intersectClip(Rect rect);

void excludeClip(RectF rect);

void excludeClip(Rect rect);

void excludeClip(Region region);

void resetClip();

void translateClip(int dx, int dy);

void translateClip(float dx, float dy);

bool isVisible(int x, int y);

bool isVisible(Point point);

bool isVisible(int x, int y, int width, int height);

bool isVisible(Rect rect);

bool isVisible(float x, float y);

bool isVisible(PointF point);

bool isVisible(float x, float y, float width, float height);

bool isVisible(RectF rect);

void addMetafileComment(ubyte[] data);

void flush(FlushIntention intention = cast(FlushIntention)0);

void scaleTransform(float sx, float sy, MatrixOrder order = cast(MatrixOrder)0);

void rotateTransform(float angle, MatrixOrder order = cast(MatrixOrder)0);

void translateTransform(float dx, float dy, MatrixOrder order = cast(MatrixOrder)0);

void multiplyTransform(Matrix matrix, MatrixOrder order = cast(MatrixOrder)0);

void resetTransform();

void transformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF[] points);

void transformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, Point[] points);

Color getNearestColor(Color color);

void clear(Color color);

void drawLine(Pen pen, float x1, float y1, float x2, float y2);

void drawLine(Pen pen, PointF pt1, PointF pt2);

void drawLines(Pen pen, PointF[] points);

void drawLine(Pen pen, int x1, int y1, int x2, int y2);

void drawLine(Pen pen, Point pt1, Point pt2);

void drawLines(Pen pen, Point[] points);

void drawArc(Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle);

void drawArc(Pen pen, RectF rect, float startAngle, float sweepAngle);

void drawArc(Pen pen, int x, int y, int width, int height, float startAngle, float sweepAngle);

void drawArc(Pen pen, Rect rect, float startAngle, float sweepAngle);

void drawBezier(Pen pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4);

void drawBezier(Pen pen, PointF pt1, PointF pt2, PointF pt3, PointF pt4);

void drawBeziers(Pen pen, PointF[] points);

void drawBezier(Pen pen, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4);

void drawBezier(Pen pen, Point pt1, Point pt2, Point pt3, Point pt4);

void drawBeziers(Pen pen, Point[] points);

void drawRectangle(Pen pen, float x, float y, float width, float height);

void drawRectangle(Pen pen, RectF rect);

void drawRectangles(Pen pen, RectF[] rects);

void drawRectangle(Pen pen, int x, int y, int width, int height);

void drawRectangle(Pen pen, Rect rect);

void drawRectangles(Pen pen, Rect[] rects);

void drawEllipse(Pen pen, float x, float y, float width, float height);

void drawEllipse(Pen pen, RectF rect);

void drawEllipse(Pen pen, int x, int y, int width, int height);

void drawEllipse(Pen pen, Rect rect);

void drawPie(Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle);

void drawPie(Pen pen, RectF rect, float startAngle, float sweepAngle);

void drawPie(Pen pen, int x, int y, int width, int height, float startAngle, float sweepAngle);

void drawPie(Pen pen, Rect rect, float startAngle, float sweepAngle);

void drawPolygon(Pen pen, PointF[] points);

void drawPolygon(Pen pen, Point[] points);

void drawPath(Pen pen, Path path);

void drawCurve(Pen pen, PointF[] points);

void drawCurve(Pen pen, PointF[] points, float tension);

void drawCurve(Pen pen, PointF[] points, int offset, int numberOfSegments, float tension = 0.5F);

void drawCurve(Pen pen, Point[] points);

void drawCurve(Pen pen, Point[] points, float tension);

void drawCurve(Pen pen, Point[] points, int offset, int numberOfSegments, float tension = 0.5F);

void drawClosedCurve(Pen pen, PointF[] points);

void drawClosedCurve(Pen pen, PointF[] points, float tension);

void drawClosedCurve(Pen pen, Point[] points);

void drawClosedCurve(Pen pen, Point[] points, float tension);

void fillRectangle(Brush brush, float x, float y, float width, float height);

void fillRectangle(Brush brush, RectF rect);

void fillRectangles(Brush brush, RectF[] rects);

void fillRectangle(Brush brush, int x, int y, int width, int height);

void fillRectangles(Brush brush, Rect[] rects);

void fillRegion(Brush brush, Region region);

void fillPolygon(Brush brush, PointF[] points, FillMode fillMode = cast(FillMode)0);

void fillPolygon(Brush brush, Point[] points, FillMode fillMode = cast(FillMode)0);

void fillEllipse(Brush brush, float x, float y, float width, float height);

void fillEllipse(Brush brush, RectF rect);

void fillEllipse(Brush brush, int x, int y, int width, int height);

void fillEllipse(Brush brush, Rect rect);

void fillPie(Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle);

void fillPie(Brush brush, RectF rect, float startAngle, float sweepAngle);

void fillPie(Brush brush, int x, int y, int width, int height, float startAngle, float sweepAngle);

void fillPath(Brush brush, Path path);

void fillClosedCurve(Brush brush, PointF[] points);

void fillClosedCurve(Brush brush, PointF[] points, FillMode fillMode, float tension = 0.5F);

void fillClosedCurve(Brush brush, Point[] points);

void fillClosedCurve(Brush brush, Point[] points, FillMode fillMode, float tension = 0.5F);

void drawImage(Image image, PointF point);

void drawImage(Image image, float x, float y);

void drawImage(Image image, RectF rect);

Draws the specified Image at the specified location and with the specified size.

Parameters
Image image

The Image to draw.

RectF rect

The location and size of the drawn image.

void drawImage(Image image, float x, float y, float width, float height);

Draws the specified Image at the specified location and with the specified size.

Parameters
Image image

The Image to draw.

float x

The x-coordinate of the upper-left corner of the drawn image.

float y

The y-coordinate of the upper-left corner of the drawn image.

float width

The width of the drawn image.

float height

The height of the drawn image.

void drawImage(Image image, float x, float y, Rect srcRect, GraphicsUnit srcUnit);

Draws a portion of an image at a specified location.

Parameters
Image image

The Image to draw.

float x

The x-coordinate of the upper-left corner of the drawn image.

float y

The y-coordinate of the upper-left corner of the drawn image.

Rect srcRect

The portion of the image to draw.

GraphicsUnit srcUnit

A member of the GraphicsUnit enumeration that specifies the units of measure used by srcRect.

void drawImage(Image image, RectF destRect, RectF srcRect, GraphicsUnit srcUnit);

void drawImage(Image image, RectF destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs = cast(ImageAttributes)null, bool delegate(void* callbackData) callback = null, void* callbackData = null);

Draws the specified portion of the specified Image at the specified location and with the specified size.

Parameters
Image image

The Image to draw.

RectF destRect

The location and size of the drawn image. The image is scaled to fit the rectangle.

float srcX

The x-coordinate of the upper-left corner of the portion of the source image to draw.

float srcY

The y-coordinate of the upper-left corner of the portion of the source image to draw.

float srcWidth

The width of the portion of the source image to draw.

float srcHeight

The height of the portion of the source image to draw.

GraphicsUnit srcUnit

A member of the GraphicsUnit enumeration that specifies the units of measure used by srcRect.

ImageAttributes imageAttrs

Specifies recoloring and gamma information.

bool delegate(void* callbackData) callback

A delegate that specifies a method to call during the drawing of the image to check whether to stop execution of the method.

void* callbackData

Value specifying additional data for the callback to use when checking whether to stop execution of the method.

void drawImage(Image image, PointF[] destPoints);

void drawImage(Image image, PointF[] destPoints, RectF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttrs = cast(ImageAttributes)null, bool delegate(void* callbackData) callback = null, void* callbackData = null);

void drawImage(Image image, Point point);

void drawImage(Image image, int x, int y);

void drawImage(Image image, Rect rect);

void drawImage(Image image, int x, int y, int width, int height);

void drawImage(Image image, int x, int y, Rect srcRect, GraphicsUnit srcUnit);

void drawImage(Image image, Rect destRect, Rect srcRect, GraphicsUnit srcUnit);

void drawImage(Image image, Rect destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs = cast(ImageAttributes)null, bool delegate(void* callbackData) callback = null, void* callbackData = null);

void drawImage(Image image, Point[] destPoints);

void drawImage(Image image, Point[] destPoints, Rect srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttrs = cast(ImageAttributes)null, bool delegate(void* callbackData) callback = null, void* callbackData = null);

void drawString(char[] s, Font font, Brush brush, float x, float y, StringFormat format = cast(StringFormat)null);

void drawString(char[] s, Font font, Brush brush, PointF point, StringFormat format = cast(StringFormat)null);

void drawString(char[] s, Font font, Brush brush, RectF layoutRect, StringFormat format = cast(StringFormat)null);

SizeF measureString(char[] s, Font font);

SizeF measureString(char[] s, Font font, PointF origin, StringFormat format = cast(StringFormat)null);

SizeF measureString(char[] s, Font font, SizeF layoutArea, StringFormat format = cast(StringFormat)null);

SizeF measureString(char[] s, Font font, SizeF layoutArea, StringFormat format, out int codepointsFitted, out int linesFilled);

Region[] measureCharacterRanges(char[] s, Font font, RectF layoutRect, StringFormat format);

float dpiX();

float dpiY();

void pageScale(float value);
float pageScale();

void pageUnit(GraphicsUnit value);
GraphicsUnit pageUnit();

void compositingMode(CompositingMode value);
CompositingMode compositingMode();

void compositingQuality(CompositingQuality value);
CompositingQuality compositingQuality();

InterpolationMode interpolationMode();
void interpolationMode(InterpolationMode value);

void smoothingMode(SmoothingMode value);
SmoothingMode smoothingMode();

void pixelOffsetMode(PixelOffsetMode value);
PixelOffsetMode pixelOffsetMode();

void textContrast(uint value);
uint textContrast();

void textRenderingHint(TextRenderingHint value);
TextRenderingHint textRenderingHint();

bool isClipEmpty();

bool isVisibleClipEmpty();

RectF clipBounds();

RectF visibleClipBounds();

void renderingOrigin(Point value);
Point renderingOrigin();

void transform(Matrix value);
Matrix transform();

struct CharacterRange;

int first;

int length;

static CharacterRange opCall(int first, int length);

class StringFormat: juno.base.core.IDisposable;

this(StringFormatFlags options = cast(StringFormatFlags)0, uint language = 0);

void dispose();

Object clone();

void setMeasurableCharacterRanges(CharacterRange[] ranges);

float[] getTabStops(out float firstTabOffset);

void setTabStops(float firstTabOffset, float[] tabStops);

static StringFormat genericDefault();

static StringFormat genericTypographic();

void formatFlags(StringFormatFlags value);
StringFormatFlags formatFlags();

void alignment(StringAlignment value);
StringAlignment alignment();

void lineAlignment(StringAlignment value);
StringAlignment lineAlignment();

void trimming(StringTrimming value);
StringTrimming trimming();

void hotkeyPrefix(HotkeyPrefix value);
HotkeyPrefix hotkeyPrefix();

abstract class Brush: juno.base.core.IDisposable;

Defines objects used to fill the interior of graphical shapes such as rectangles, ellipses, pies, polygons and paths.

this();

Initializes a new instance.

final void dispose();

Releases all resources used by the Brush.

protected void dispose(bool disposing);

static Brush activeBorder();
static Brush activeCaption();
static Brush activeCaptionText();
static Brush appWorkspace();
static Brush control();
static Brush controlDark();
static Brush controlDarkDark();
static Brush controlLight();
static Brush controlLightLight();
static Brush controlText();
static Brush desktop();
static Brush grayText();
static Brush highlight();
static Brush highlightText();
static Brush hotTrack();
static Brush inactiveBorder();
static Brush inactiveCaption();
static Brush inactiveCaptionText();
static Brush info();
static Brush infoText();
static Brush menu();
static Brush menuText();
static Brush scrollBar();
static Brush window();
static Brush windowFrame();
static Brush windowText();
static Brush transparent();
static Brush aliceBlue();
static Brush antiqueWhite();
static Brush aqua();
static Brush aquamarine();
static Brush azure();
static Brush beige();
static Brush bisque();
static Brush black();
static Brush blanchedAlmond();
static Brush blue();
static Brush blueViolet();
static Brush brown();
static Brush burlyWood();
static Brush cadetBlue();
static Brush chartreuse();
static Brush chocolate();
static Brush coral();
static Brush cornflowerBlue();
static Brush cornsilk();
static Brush crimson();
static Brush cyan();
static Brush darkBlue();
static Brush darkCyan();
static Brush darkGoldenrod();
static Brush darkGray();
static Brush darkGreen();
static Brush darkKhaki();
static Brush darkMagenta();
static Brush darkOliveGreen();
static Brush darkOrange();
static Brush darkOrchid();
static Brush darkRed();
static Brush darkSalmon();
static Brush darkSeaGreen();
static Brush darkSlateBlue();
static Brush darkSlateGray();
static Brush darkTurquoise();
static Brush darkViolet();
static Brush deepPink();
static Brush deepSkyBlue();
static Brush dimGray();
static Brush dodgerBlue();
static Brush firebrick();
static Brush floralWhite();
static Brush forestGreen();
static Brush fuchsia();
static Brush gainsboro();
static Brush ghostWhite();
static Brush gold();
static Brush goldenrod();
static Brush gray();
static Brush green();
static Brush greenYellow();
static Brush honeydew();
static Brush hotPink();
static Brush indianRed();
static Brush indigo();
static Brush ivory();
static Brush khaki();
static Brush lavender();
static Brush lavenderBlush();
static Brush lawnGreen();
static Brush lemonChiffon();
static Brush lightBlue();
static Brush lightCoral();
static Brush lightCyan();
static Brush lightGoldenrodYellow();
static Brush lightGray();
static Brush lightGreen();
static Brush lightPink();
static Brush lightSalmon();
static Brush lightSeaGreen();
static Brush lightSkyBlue();
static Brush lightSlateGray();
static Brush lightSteelBlue();
static Brush lightYellow();
static Brush lime();
static Brush limeGreen();
static Brush linen();
static Brush magenta();
static Brush maroon();
static Brush mediumAquamarine();
static Brush mediumBlue();
static Brush mediumOrchid();
static Brush mediumPurple();
static Brush mediumSeaGreen();
static Brush mediumSlateBlue();
static Brush mediumSpringGreen();
static Brush mediumTurquoise();
static Brush mediumVioletRed();
static Brush midnightBlue();
static Brush mintCream();
static Brush mistyRose();
static Brush moccasin();
static Brush navajoWhite();
static Brush navy();
static Brush oldLace();
static Brush olive();
static Brush oliveDrab();
static Brush orange();
static Brush orangeRed();
static Brush orchid();
static Brush paleGoldenrod();
static Brush paleGreen();
static Brush paleTurquoise();
static Brush paleVioletRed();
static Brush papayaWhip();
static Brush peachPuff();
static Brush peru();
static Brush pink();
static Brush plum();
static Brush powderBlue();
static Brush purple();
static Brush red();
static Brush rosyBrown();
static Brush royalBlue();
static Brush saddleBrown();
static Brush salmon();
static Brush sandyBrown();
static Brush seaGreen();
static Brush seaShell();
static Brush sienna();
static Brush silver();
static Brush skyBlue();
static Brush slateBlue();
static Brush slateGray();
static Brush snow();
static Brush springGreen();
static Brush steelBlue();
static Brush tan();
static Brush teal();
static Brush thistle();
static Brush tomato();
static Brush turquoise();
static Brush violet();
static Brush wheat();
static Brush white();
static Brush whiteSmoke();
static Brush yellow();
static Brush yellowGreen();
static Brush buttonFace();
static Brush buttonHighlight();
static Brush buttonShadow();
static Brush gradientActiveCaption();
static Brush gradientInactiveCaption();
static Brush menuBar();
static Brush menuHighlight();

Gets a system-defined Brush object.

class SolidBrush: juno.media.core.Brush;

Defines a brush of a single color.

this(Color color);

Initializes a new SolidBrush object of the specified color.

Parameters
Color color

The color of this brush.

Object clone();

Creates an exact copy of this brush.

Returns
The SolidBrush object that this method creates.

void color(Color value);
Color color();

Gets or sets the color of this SolidBrush object.

Parameters
Color value

The color of this brush.

class TextureBrush: juno.media.core.Brush;

this(Image image, WrapMode wrapMode = (WrapMode).Tile);

this(Image image, WrapMode wrapMode, Rect rect);

this(Image image, WrapMode wrapMode, RectF rect);

this(Image image, Rect rect, ImageAttributes imageAttr);

this(Image image, RectF rect, ImageAttributes imageAttr);

Object clone();

Creates an exact copy of this brush.

Returns
The TextureBrush object that this method creates.

void translateTransform(float dx, float dy, MatrixOrder order = cast(MatrixOrder)0);

void rotateTransform(float angle, MatrixOrder order = cast(MatrixOrder)0);

void scaleTransform(float sx, float sy, MatrixOrder order = cast(MatrixOrder)0);

void multiplyTransform(Matrix matrix, MatrixOrder order = cast(MatrixOrder)0);

void resetTransform();

Image image();

void transform(Matrix value);
Matrix transform();

void wrapMode(WrapMode value);
WrapMode wrapMode();

class HatchBrush: juno.media.core.Brush;

this(HatchStyle hatchStyle, Color foreColor);

this(HatchStyle hatchStyle, Color foreColor, Color backColor);

HatchStyle hatchStyle();

Color foregroundColor();

Color backgroundColor();

class Blend;

float[] factors;

float[] positions;

this(int count = 1);

class ColorBlend;

Color[] colors;

float[] positions;

this(int count = 1);

class LinearGradientBrush: juno.media.core.Brush;

this(Point startPoint, Point endPoint, Color startColor, Color endColor);

this(PointF startPoint, PointF endPoint, Color startColor, Color endColor);

this(Rect rect, Color startColor, Color endColor, LinearGradientMode mode);

this(RectF rect, Color startColor, Color endColor, LinearGradientMode mode);

this(Rect rect, Color startColor, Color endColor, float angle, bool isAngleScalable = false);

this(RectF rect, Color startColor, Color endColor, float angle, bool isAngleScalable = false);

void setSigmaBellShape(float focus, float scale = 1F);

void setBlendTriangularShape(float focus, float scale = 1F);

void resetTransform();

void translateTransform(float dx, float dy, MatrixOrder order = cast(MatrixOrder)0);

void scaleTransform(float sx, float sy, MatrixOrder order = cast(MatrixOrder)0);

void rotateTransform(float angle, MatrixOrder order = cast(MatrixOrder)0);

void linearColors(Color[] value);
Color[] linearColors();

void gammaCorrection(bool value);
bool gammaCorrection();

void blend(Blend value);
Blend blend();

void interpolationColors(ColorBlend value);
ColorBlend interpolationColors();

RectF rectangle();

void wrapMode(WrapMode value);
WrapMode wrapMode();

class PathGradientBrush: juno.media.core.Brush;

this(PointF[] points, WrapMode wrapMode = (WrapMode).Clamp);

this(Point[] points, WrapMode wrapMode = (WrapMode).Clamp);

this(Path path);

Object clone();

class Pen: juno.base.core.IDisposable;

this(Color color, float width = 1F);

final void dispose();

void setLineCap(LineCap startCap, LineCap endCap, DashCap dashCap);

void resetTransform();

void translateTransform(float dx, float dy, MatrixOrder order = cast(MatrixOrder)0);

void scaleTransform(float sx, float sy, MatrixOrder order = cast(MatrixOrder)0);

void rotateTransform(float angle, MatrixOrder order = cast(MatrixOrder)0);

void width(float value);
float width();

void startCap(LineCap value);
LineCap startCap();

void endCap(LineCap value);
LineCap endCap();

void dashCap(DashCap value);
DashCap dashCap();

void lineJoin(LineJoin value);
LineJoin lineJoin();

void miterLimit(float value);
float miterLimit();

void alignment(PenAlignment value);
PenAlignment alignment();

PenType penType();

void dashStyle(DashStyle value);
DashStyle dashStyle();

void dashOffset(float value);
float dashOffset();

void dashPattern(float[] value);
float[] dashPattern();

void compoundArray(float[] value);
float[] compoundArray();

void color(Color value);
Color color();

static Pen activeBorder();
static Pen activeCaption();
static Pen activeCaptionText();
static Pen appWorkspace();
static Pen control();
static Pen controlDark();
static Pen controlDarkDark();
static Pen controlLight();
static Pen controlLightLight();
static Pen controlText();
static Pen desktop();
static Pen grayText();
static Pen highlight();
static Pen highlightText();
static Pen hotTrack();
static Pen inactiveBorder();
static Pen inactiveCaption();
static Pen inactiveCaptionText();
static Pen info();
static Pen infoText();
static Pen menu();
static Pen menuText();
static Pen scrollBar();
static Pen window();
static Pen windowFrame();
static Pen windowText();
static Pen transparent();
static Pen aliceBlue();
static Pen antiqueWhite();
static Pen aqua();
static Pen aquamarine();
static Pen azure();
static Pen beige();
static Pen bisque();
static Pen black();
static Pen blanchedAlmond();
static Pen blue();
static Pen blueViolet();
static Pen brown();
static Pen burlyWood();
static Pen cadetBlue();
static Pen chartreuse();
static Pen chocolate();
static Pen coral();
static Pen cornflowerBlue();
static Pen cornsilk();
static Pen crimson();
static Pen cyan();
static Pen darkBlue();
static Pen darkCyan();
static Pen darkGoldenrod();
static Pen darkGray();
static Pen darkGreen();
static Pen darkKhaki();
static Pen darkMagenta();
static Pen darkOliveGreen();
static Pen darkOrange();
static Pen darkOrchid();
static Pen darkRed();
static Pen darkSalmon();
static Pen darkSeaGreen();
static Pen darkSlateBlue();
static Pen darkSlateGray();
static Pen darkTurquoise();
static Pen darkViolet();
static Pen deepPink();
static Pen deepSkyBlue();
static Pen dimGray();
static Pen dodgerBlue();
static Pen firebrick();
static Pen floralWhite();
static Pen forestGreen();
static Pen fuchsia();
static Pen gainsboro();
static Pen ghostWhite();
static Pen gold();
static Pen goldenrod();
static Pen gray();
static Pen green();
static Pen greenYellow();
static Pen honeydew();
static Pen hotPink();
static Pen indianRed();
static Pen indigo();
static Pen ivory();
static Pen khaki();
static Pen lavender();
static Pen lavenderBlush();
static Pen lawnGreen();
static Pen lemonChiffon();
static Pen lightBlue();
static Pen lightCoral();
static Pen lightCyan();
static Pen lightGoldenrodYellow();
static Pen lightGray();
static Pen lightGreen();
static Pen lightPink();
static Pen lightSalmon();
static Pen lightSeaGreen();
static Pen lightSkyBlue();
static Pen lightSlateGray();
static Pen lightSteelBlue();
static Pen lightYellow();
static Pen lime();
static Pen limeGreen();
static Pen linen();
static Pen magenta();
static Pen maroon();
static Pen mediumAquamarine();
static Pen mediumBlue();
static Pen mediumOrchid();
static Pen mediumPurple();
static Pen mediumSeaGreen();
static Pen mediumSlateBlue();
static Pen mediumSpringGreen();
static Pen mediumTurquoise();
static Pen mediumVioletRed();
static Pen midnightBlue();
static Pen mintCream();
static Pen mistyRose();
static Pen moccasin();
static Pen navajoWhite();
static Pen navy();
static Pen oldLace();
static Pen olive();
static Pen oliveDrab();
static Pen orange();
static Pen orangeRed();
static Pen orchid();
static Pen paleGoldenrod();
static Pen paleGreen();
static Pen paleTurquoise();
static Pen paleVioletRed();
static Pen papayaWhip();
static Pen peachPuff();
static Pen peru();
static Pen pink();
static Pen plum();
static Pen powderBlue();
static Pen purple();
static Pen red();
static Pen rosyBrown();
static Pen royalBlue();
static Pen saddleBrown();
static Pen salmon();
static Pen sandyBrown();
static Pen seaGreen();
static Pen seaShell();
static Pen sienna();
static Pen silver();
static Pen skyBlue();
static Pen slateBlue();
static Pen slateGray();
static Pen snow();
static Pen springGreen();
static Pen steelBlue();
static Pen tan();
static Pen teal();
static Pen thistle();
static Pen tomato();
static Pen turquoise();
static Pen violet();
static Pen wheat();
static Pen white();
static Pen whiteSmoke();
static Pen yellow();
static Pen yellowGreen();
static Pen buttonFace();
static Pen buttonHighlight();
static Pen buttonShadow();
static Pen gradientActiveCaption();
static Pen gradientInactiveCaption();
static Pen menuBar();
static Pen menuHighlight();

Gets a system-defined Pen object.

class ImageAttributes;

this();

void dispose();

void setColorKey(Color colorLow, Color colorHigh, ColorAdjustType type = cast(ColorAdjustType)0);

void clearColorKey(ColorAdjustType type = cast(ColorAdjustType)0);

void setColorMatrix(ColorMatrix newColorMatrix, ColorMatrixFlag mode = cast(ColorMatrixFlag)0, ColorAdjustType type = cast(ColorAdjustType)0);

void clearColorMatrix(ColorAdjustType type = cast(ColorAdjustType)0);

abstract class Image: juno.base.core.IDisposable;

protected void dispose(bool disposing);

final Object clone();

static Image fromFile(char[] fileName, bool useEmbeddedColorManagement = false);

static Image fromStream(Stream stream, bool useEmbeddedColorManagement = false);

static Bitmap fromHbitmap(Handle hbitmap, Handle hpalette = null);

final void save(char[] fileName);

final void save(char[] fileName, ImageFormat format);

final void save(char[] fileName, ImageCodecInfo encoder, EncoderParameters encoderParams);

final void save(Stream stream, ImageFormat format);

final void save(Stream stream, ImageCodecInfo encoder, EncoderParameters encoderParams);

final Image getThumbnailImage(int thumbWidth, int thumbHeight, bool delegate(void* callbackData) callback, void* callbackData);

final RectF getBounds(ref GraphicsUnit pageUnit);

final void rotateFlip(RotateFlipType rotateFlipType);

final SizeF physicalDimension();

final int width();

final int height();

final Size size();

final float horizontalResolution();

final float verticalResolution();

final ImageFormat rawFormat();

final PixelFormat pixelFormat();

final GUID[] frameDimensionsList();

final uint getFrameCount(FrameDimension dimension);

final void selectActiveFrame(FrameDimension dimension, uint frameIndex);

final PropertyItem getPropertyItem(int propId);

class Bitmap: juno.media.core.Image;

this(string fileName, bool useEmbeddedColorManagement = false);

this(Stream stream);

this(Image original);

this(Image original, int width, int height);

this(Image original, Size size);

this(int width, int height, PixelFormat format = (PixelFormat).Format32bppArgb);

this(int width, int height, int stride, PixelFormat format, ubyte* scan0);

this(int width, int height, Graphics g);

static Bitmap fromResource(Handle hinstance, char[] bitmapName);

static Bitmap fromHicon(Handle hicon);

Handle getHbitmap(Color background = lightGray());

Handle getHicon();

BitmapData lockBits(Rect rect, ImageLockMode flags, PixelFormat format, BitmapData bitmapData = cast(BitmapData)null);

void unlockBits(BitmapData bitmapData);

Color getPixel(int x, int y);

void setPixel(int x, int y, Color color);

void setResolution(float xdpi, float ydpi);

void makeTransparent();

void makeTransparent(Color transparentColor);

class WmfPlaceableFileHeader;

class Metafile: juno.media.core.Image;

this(Handle hmetafile, WmfPlaceableFileHeader wmfHeader, bool deleteEmf = false);

this(Handle henhmetafile, bool deleteEmf);

this(string fileName);

this(string fileName, WmfPlaceableFileHeader wmfHeader);

this(Stream stream);

this(Handle referenceHdc, EmfType emfType, string description = null);

this(Handle referenceHdc, RectF frameRect, MetafileFrameUnit frameUnit = (MetafileFrameUnit).GdiCompatible, EmfType emfType = (EmfType).EmfPlusDual, string description = null);

this(Handle referenceHdc, Rect frameRect, MetafileFrameUnit frameUnit = (MetafileFrameUnit).GdiCompatible, EmfType emfType = (EmfType).EmfPlusDual, string description = null);

this(string fileName, Handle referenceHdc, EmfType emfType = (EmfType).EmfPlusDual, string description = null);

this(string fileName, Handle referenceHdc, RectF frameRect, MetafileFrameUnit frameUnit = (MetafileFrameUnit).GdiCompatible, EmfType emfType = (EmfType).EmfPlusDual, string description = null);

this(string fileName, Handle referenceHdc, Rect frameRect, MetafileFrameUnit frameUnit = (MetafileFrameUnit).GdiCompatible, EmfType emfType = (EmfType).EmfPlusDual, string description = null);

this(Stream stream, Handle referenceHdc, EmfType emfType = (EmfType).EmfPlusDual, string description = null);

this(Stream stream, Handle referenceHdc, RectF frameRect, MetafileFrameUnit frameUnit = (MetafileFrameUnit).GdiCompatible, EmfType emfType = (EmfType).EmfPlusDual, string description = null);

Handle getHenhmetafile();

class Path;

this(FillMode fillMode = (FillMode).Alternate);

this(PointF[] points, ubyte[] types, FillMode fillMode = (FillMode).Alternate);

this(Point[] points, ubyte[] types, FillMode fillMode = (FillMode).Alternate);

void dispose();

void reset();

void startFigure();

void closeFigure();

void closeAllFigures();

void setMarkers();

void clearMarkers();

void reverse();

PointF getLastPoint();

void addLine(PointF pt1, PointF pt2);

void addLine(float x1, float y1, float x2, float y2);

void addLines(PointF[] points);

void addLine(Point pt1, Point pt2);

void addLine(int x1, int y1, int x2, int y2);

void addLines(Point[] points);

void addArc(RectF rect, float startAngle, float sweepAngle);

void addArc(float x, float y, float width, float height, float startAngle, float sweepAngle);

void addArc(Rect rect, float startAngle, float sweepAngle);

void addArc(int x, int y, int width, int height, float startAngle, float sweepAngle);

void addBezier(PointF pt1, PointF pt2, PointF pt3, PointF pt4);

void addBezier(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4);

void addBeziers(PointF[] points);

void addBezier(Point pt1, Point pt2, Point pt3, Point pt4);

void addBezier(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4);

void addBeziers(Point[] points);

void addCurve(PointF[] points);

void addCurve(PointF[] points, float tension);

void addCurve(PointF[] points, int offset, int numberOfSegments, float tension);

void addCurve(Point[] points);

void addCurve(Point[] points, float tension);

void addCurve(Point[] points, int offset, int numberOfSegments, float tension);

void addClosedCurve(PointF[] points);

void addClosedCurve(PointF[] points, float tension);

void addClosedCurve(Point[] points);

void addClosedCurve(Point[] points, float tension);

void addRectangle(RectF rect);

void addRectangles(RectF[] rects);

void addRectangle(Rect rect);

void addRectangles(Rect[] rects);

void addEllipse(RectF rect);

void addEllipse(float x, float y, float width, float height);

void addEllipse(Rect rect);

void addEllipse(int x, int y, int width, int height);

void addPie(RectF rect, float startAngle, float sweepAngle);

void addPie(float x, float y, float width, float height, float startAngle, float sweepAngle);

void addPie(Rect rect, float startAngle, float sweepAngle);

void addPie(int x, int y, int width, int height, float startAngle, float sweepAngle);

void addPolygon(PointF[] points);

void addPolygon(Point[] points);

void addPath(Path addingPath, bool connect);

void addString(char[] s, FontFamily family, FontStyle style, float emSize, PointF origin, StringFormat format);

void addString(char[] s, FontFamily family, FontStyle style, float emSize, RectF layoutRect, StringFormat format);

void addString(char[] s, FontFamily family, FontStyle style, float emSize, Point origin, StringFormat format);

void addString(char[] s, FontFamily family, FontStyle style, float emSize, Rect layoutRect, StringFormat format);

void transform(Matrix matrix);

RectF getBounds(Matrix matrix = cast(Matrix)null, Pen pen = cast(Pen)null);

void flatten(Matrix matrix = cast(Matrix)null, float flatness = 1F / 4F);

void widen(Pen pen, Matrix matrix = cast(Matrix)null, float flatness = 1F / 4F);

void outline(Matrix matrix = cast(Matrix)null, float flatness = 1F / 4F);

void warp(PointF[] destPoints, RectF srcRect, Matrix matrix = cast(Matrix)null, WarpMode warpMode = cast(WarpMode)0, float flatness = 1F / 4F);

bool isVisible(PointF pt, Graphics graphics = cast(Graphics)null);

bool isVisible(float x, float y, Graphics graphics = cast(Graphics)null);

bool isVisible(Point pt, Graphics graphics = cast(Graphics)null);

bool isVisible(int x, int y, Graphics graphics = cast(Graphics)null);

bool isOutlineVisible(PointF pt, Pen pen, Graphics graphics = cast(Graphics)null);

bool isOutlineVisible(float x, float y, Pen pen, Graphics graphics = cast(Graphics)null);

bool isOutlineVisible(Point pt, Pen pen, Graphics graphics = cast(Graphics)null);

bool isOutlineVisible(int x, int y, Pen pen, Graphics graphics = cast(Graphics)null);

void fillMode(FillMode value);
FillMode fillMode();

int pointCount();

ubyte[] pathTypes();
PointF[] pathPoints();

class PathIterator;

this(Path path);

void dispose();

int nextSubpath(out int startIndex, out int endIndex, out bool isClosed);

int nextSubpath(Path path, out bool isClosed);

int nextPathType(out ubyte pathType, out int startIndex, out int endIndex);

int nextMarker(out int startIndex, out int endIndex);

int nextMarker(Path path);

void rewind();

int enumerate(ref PointF[] points, ref ubyte[] types);

int copyData(ref PointF[] points, ref ubyte[] types, int startIndex, int endIndex);

int count();

int subpathCount();

bool hasCurve();

class Region;

this();

this(RectF rect);

this(Rect rect);

this(Path path);

void dispose();

static Region fromHrgn(Handle hrgn);

void makeInfinite();

void makeEmpty();

void intersect(RectF rect);

void intersect(Rect rect);

void intersect(Path path);

void intersect(Region region);

void unionWith(RectF rect);

void unionWith(Rect rect);

void unionWith(Path path);

void unionWith(Region region);

void xor(RectF rect);

void xor(Rect rect);

void xor(Path path);

void xor(Region region);

void exclude(RectF rect);

void exclude(Rect rect);

void exclude(Path path);

void exclude(Region region);

void complement(RectF rect);

void complement(Rect rect);

void complement(Path path);

void complement(Region region);

void translate(float dx, float dy);

void translate(int dx, int dy);

void transform(Matrix matrix);

RectF getBounds(Graphics g);

Handle getHrgn(Graphics g);

bool isEmpty(Graphics g);

bool isInfinite(Graphics g);

bool equals(Region region, Graphics g);

bool isVisible(PointF point, Graphics g = cast(Graphics)null);

bool isVisible(float x, float y, Graphics g = cast(Graphics)null);

bool isVisible(RectF rect, Graphics g = cast(Graphics)null);

bool isVisible(float x, float y, float width, float height, Graphics g = cast(Graphics)null);

bool isVisible(Point point, Graphics g = cast(Graphics)null);

bool isVisible(int x, int y, Graphics g = cast(Graphics)null);

bool isVisible(Rect rect, Graphics g = cast(Graphics)null);

bool isVisible(int x, int y, int width, int height, Graphics g = cast(Graphics)null);

RectF[] getRegionScans(Matrix matrix);

abstract class FontCollection: juno.base.core.IDisposable;

final void dispose();

protected void dispose(bool disposing);

final FontFamily[] families();

class InstalledFontCollection: juno.media.core.FontCollection;

class PrivateFontCollection: juno.media.core.FontCollection;

void addFontFile(char[] fileName);

void addMemoryFont(Handle memory, int length);

class FontFamily: juno.base.core.IDisposable;

this(GenericFontFamilies genericFamily);

this(string name, FontCollection fontCollection = null);

final void dispose();

bool isStyleAvailable(FontStyle style);

short getEmHeight(FontStyle style);

short getCellAscent(FontStyle style);

short getCellDescent(FontStyle style);

short getLineSpacing(FontStyle style);

char[] getName(int language);

char[] name();

static FontFamily genericSerif();

static FontFamily genericSansSerif();

static FontFamily genericMonospace();

class Font: juno.base.core.IDisposable;

this(Font prototype, FontStyle newStyle);

this(string familyName, float emSize, GraphicsUnit unit);

this(FontFamily family, float emSize, GraphicsUnit unit);

this(string familyName, float emSize, FontStyle style = (FontStyle).Regular, GraphicsUnit unit = (GraphicsUnit).Point);

this(FontFamily family, float emSize, FontStyle style = (FontStyle).Regular, GraphicsUnit unit = (GraphicsUnit).Point);

final void dispose();

float getHeight();

float getHeight(Graphics graphics);

static Font fromHdc(Handle hdc);

static Font fromHfont(Handle hfont);

static Font fromLogFont(ref LOGFONTW logFont);

static Font fromLogFont(ref LOGFONTW logFont, Handle hdc);

Handle toHfont();

void toLogFont(out LOGFONTW logFont);

void toLogFont(out LOGFONTW logFont, Graphics graphics);

FontFamily fontFamily();

float size();

float sizeInPoints();

FontStyle style();

GraphicsUnit unit();

int height();

char[] name();

bool bold();

bool italic();

bool underline();

bool strikeout();