846 lines
30 KiB
TypeScript
846 lines
30 KiB
TypeScript
declare module 'cairo' {
|
|
// Cairo 1.0
|
|
import Cairo from 'gi://cairo?version=1.0';
|
|
import type GObject from 'gi://GObject?version=2.0';
|
|
|
|
namespace giCairo {
|
|
// Re-export enums directly from Cairo
|
|
export import Status = Cairo.Status;
|
|
export import Content = Cairo.Content;
|
|
export import Operator = Cairo.Operator;
|
|
export import Antialias = Cairo.Antialias;
|
|
export import FillRule = Cairo.FillRule;
|
|
export import LineCap = Cairo.LineCap;
|
|
export import LineJoin = Cairo.LineJoin;
|
|
export import TextClusterFlags = Cairo.TextClusterFlags;
|
|
export import FontSlant = Cairo.FontSlant;
|
|
export import FontWeight = Cairo.FontWeight;
|
|
export import SubpixelOrder = Cairo.SubpixelOrder;
|
|
export import HintStyle = Cairo.HintStyle;
|
|
export import HintMetrics = Cairo.HintMetrics;
|
|
export import FontType = Cairo.FontType;
|
|
export import PathDataType = Cairo.PathDataType;
|
|
export import DeviceType = Cairo.DeviceType;
|
|
export import SurfaceType = Cairo.SurfaceType;
|
|
export import Format = Cairo.Format;
|
|
export import PatternType = Cairo.PatternType;
|
|
export import Extend = Cairo.Extend;
|
|
export import Filter = Cairo.Filter;
|
|
export import RegionOverlap = Cairo.RegionOverlap;
|
|
|
|
/**
|
|
* Describes the metrics of a string of text
|
|
*/
|
|
export interface TextExtents {
|
|
/** The horizontal distance from the origin to the leftmost part of the text */
|
|
xBearing: number;
|
|
/** The vertical distance from the origin to the topmost part of the text */
|
|
yBearing: number;
|
|
/** The width of the text */
|
|
width: number;
|
|
/** The height of the text */
|
|
height: number;
|
|
/** The distance to advance horizontally after drawing the text */
|
|
xAdvance: number;
|
|
/** The distance to advance vertically after drawing the text */
|
|
yAdvance: number;
|
|
}
|
|
|
|
/**
|
|
* The main Cairo drawing context
|
|
*
|
|
* A Cairo context is used to draw to surfaces and perform drawing operations.
|
|
* When you're done with a context, you must call $dispose() to free memory.
|
|
*/
|
|
export class Context extends Cairo.Context {
|
|
/**
|
|
* Creates a new Cairo context for drawing to the given surface
|
|
* @param surface The surface to draw on
|
|
*/
|
|
constructor(surface: Surface);
|
|
|
|
/**
|
|
* Free a Cairo.Context and all associated memory
|
|
*
|
|
* Unlike other objects in GJS, Cairo contexts must be explicitly disposed
|
|
* to avoid memory leaks.
|
|
*/
|
|
$dispose(): void;
|
|
|
|
/**
|
|
* Adds a circular arc of the given radius to the current path
|
|
* @param xc X coordinate of the center of the arc
|
|
* @param yc Y coordinate of the center of the arc
|
|
* @param radius Radius of the arc
|
|
* @param angle1 Starting angle in radians
|
|
* @param angle2 End angle in radians
|
|
*/
|
|
arc(xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
|
|
|
|
/**
|
|
* Adds a circular arc of the given radius to the current path, but draws
|
|
* the arc in the opposite direction from arc()
|
|
* @param xc X coordinate of the center of the arc
|
|
* @param yc Y coordinate of the center of the arc
|
|
* @param radius Radius of the arc
|
|
* @param angle1 Starting angle in radians
|
|
* @param angle2 End angle in radians
|
|
*/
|
|
arcNegative(xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
|
|
|
|
/**
|
|
* Adds a cubic Bézier spline to the current path
|
|
* @param x1 X coordinate of the first control point
|
|
* @param y1 Y coordinate of the first control point
|
|
* @param x2 X coordinate of the second control point
|
|
* @param y2 Y coordinate of the second control point
|
|
* @param x3 X coordinate of the end point
|
|
* @param y3 Y coordinate of the end point
|
|
*/
|
|
curveTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
|
|
|
|
/**
|
|
* Establishes a new clip region by intersecting the current clip region
|
|
* with the current path, then clearing the current path
|
|
*/
|
|
clip(): void;
|
|
|
|
/**
|
|
* Like clip() but preserves the current path
|
|
*/
|
|
clipPreserve(): void;
|
|
|
|
/**
|
|
* Returns the current clip extents as [x1, y1, x2, y2]
|
|
* @returns An array with [x1, y1, x2, y2] clip extents
|
|
*/
|
|
clipExtents(): [number, number, number, number];
|
|
|
|
/**
|
|
* Closes the current path by drawing a line to the beginning of the current subpath
|
|
*/
|
|
closePath(): void;
|
|
|
|
/**
|
|
* Emits the current page, but doesn't clear it
|
|
*/
|
|
copyPage(): void;
|
|
|
|
/**
|
|
* Transforms a coordinate from device space to user space
|
|
* @param x X coordinate
|
|
* @param y Y coordinate
|
|
* @returns An array with [x, y] transformed coordinates
|
|
*/
|
|
deviceToUser(x: number, y: number): [number, number];
|
|
|
|
/**
|
|
* Transforms a distance vector from device space to user space
|
|
* @param x X component of the distance vector
|
|
* @param y Y component of the distance vector
|
|
* @returns An array with [x, y] transformed distance vector
|
|
*/
|
|
deviceToUserDistance(x: number, y: number): [number, number];
|
|
|
|
/**
|
|
* Fills the current path using the current fill rule, then clears the path
|
|
*/
|
|
fill(): void;
|
|
|
|
/**
|
|
* Fills the current path using the current fill rule, but doesn't clear the path
|
|
*/
|
|
fillPreserve(): void;
|
|
|
|
/**
|
|
* Returns the current fill extents as [x1, y1, x2, y2]
|
|
* @returns An array with [x1, y1, x2, y2] fill extents
|
|
*/
|
|
fillExtents(): [number, number, number, number];
|
|
|
|
/**
|
|
* Gets the current antialiasing mode
|
|
* @returns The current antialiasing mode
|
|
*/
|
|
getAntialias(): Antialias;
|
|
|
|
/**
|
|
* Gets the current point of the current path
|
|
* @returns An array with [x, y] coordinates of the current point
|
|
*/
|
|
getCurrentPoint(): [number, number];
|
|
|
|
/**
|
|
* Gets the current dash count
|
|
* @returns The number of elements in the current dash pattern
|
|
*/
|
|
getDashCount(): number;
|
|
|
|
/**
|
|
* Gets the current fill rule
|
|
* @returns The current fill rule
|
|
*/
|
|
getFillRule(): FillRule;
|
|
|
|
/**
|
|
* Gets the current line cap style
|
|
* @returns The current line cap style
|
|
*/
|
|
getLineCap(): LineCap;
|
|
|
|
/**
|
|
* Gets the current line join style
|
|
* @returns The current line join style
|
|
*/
|
|
getLineJoin(): LineJoin;
|
|
|
|
/**
|
|
* Gets the current line width
|
|
* @returns The current line width
|
|
*/
|
|
getLineWidth(): number;
|
|
|
|
/**
|
|
* Gets the current miter limit
|
|
* @returns The current miter limit
|
|
*/
|
|
getMiterLimit(): number;
|
|
|
|
/**
|
|
* Gets the current compositing operator
|
|
* @returns The current compositing operator
|
|
*/
|
|
getOperator(): Operator;
|
|
|
|
/**
|
|
* Gets the current source pattern
|
|
* @returns The current source pattern
|
|
*/
|
|
getSource(): Pattern;
|
|
|
|
/**
|
|
* Gets the surface the Cairo context is drawing on
|
|
* @returns The target surface
|
|
*/
|
|
getTarget(): Surface;
|
|
|
|
/**
|
|
* Gets the current tolerance value
|
|
* @returns The current tolerance value
|
|
*/
|
|
getTolerance(): number;
|
|
|
|
/**
|
|
* Checks if there is a current point defined
|
|
* @returns True if there is a current point
|
|
*/
|
|
hasCurrentPoint(): boolean;
|
|
|
|
/**
|
|
* Resets the current transformation matrix to the identity matrix
|
|
*/
|
|
identityMatrix(): void;
|
|
|
|
/**
|
|
* Tests whether the given point is inside the area filled by the current path
|
|
* @param x X coordinate of the point to test
|
|
* @param y Y coordinate of the point to test
|
|
* @returns True if the point is inside the path
|
|
*/
|
|
inFill(x: number, y: number): boolean;
|
|
|
|
/**
|
|
* Tests whether the given point is inside the area that would be inked
|
|
* by the current path with the current line width and stroke parameters
|
|
* @param x X coordinate of the point to test
|
|
* @param y Y coordinate of the point to test
|
|
* @returns True if the point would be inked
|
|
*/
|
|
inStroke(x: number, y: number): boolean;
|
|
|
|
/**
|
|
* Adds a line to the current path from the current point to the given point
|
|
* @param x X coordinate of the end point
|
|
* @param y Y coordinate of the end point
|
|
*/
|
|
lineTo(x: number, y: number): void;
|
|
|
|
/**
|
|
* Sets the current mask pattern used for painting operations
|
|
* @param pattern A pattern to use as mask
|
|
*/
|
|
mask(pattern: Pattern): void;
|
|
|
|
/**
|
|
* Sets the current mask to a surface
|
|
* @param surface A surface to use as mask
|
|
* @param x X coordinate at which to place the origin of the surface
|
|
* @param y Y coordinate at which to place the origin of the surface
|
|
*/
|
|
maskSurface(surface: Surface, x: number, y: number): void;
|
|
|
|
/**
|
|
* Begins a new subpath at the given point
|
|
* @param x X coordinate of the new position
|
|
* @param y Y coordinate of the new position
|
|
*/
|
|
moveTo(x: number, y: number): void;
|
|
|
|
/**
|
|
* Clears the current path and begins a new path
|
|
*/
|
|
newPath(): void;
|
|
|
|
/**
|
|
* Begins a new subpath without changing the current point
|
|
*/
|
|
newSubPath(): void;
|
|
|
|
/**
|
|
* Paints the current source everywhere within the current clip region
|
|
*/
|
|
paint(): void;
|
|
|
|
/**
|
|
* Paints the current source everywhere within the current clip region
|
|
* using the given alpha value
|
|
* @param alpha Alpha value to use, between 0 and 1
|
|
*/
|
|
paintWithAlpha(alpha: number): void;
|
|
|
|
/**
|
|
* Returns the current path extents as [x1, y1, x2, y2]
|
|
* @returns An array with [x1, y1, x2, y2] path extents
|
|
*/
|
|
pathExtents(): [number, number, number, number];
|
|
|
|
/**
|
|
* Terminates the current pattern group and returns a new pattern
|
|
* representing everything drawn to the group
|
|
* @returns A new pattern representing the group
|
|
*/
|
|
popGroup(): Pattern;
|
|
|
|
/**
|
|
* Terminates the current pattern group and makes it the current source pattern
|
|
*/
|
|
popGroupToSource(): void;
|
|
|
|
/**
|
|
* Temporarily redirects drawing to an intermediate surface
|
|
*/
|
|
pushGroup(): void;
|
|
|
|
/**
|
|
* Temporarily redirects drawing to an intermediate surface with the given content
|
|
* @param content The content type for the group
|
|
*/
|
|
pushGroupWithContent(content: Content): void;
|
|
|
|
/**
|
|
* Adds a rectangle to the current path
|
|
* @param x X coordinate of the top-left corner
|
|
* @param y Y coordinate of the top-left corner
|
|
* @param width Width of the rectangle
|
|
* @param height Height of the rectangle
|
|
*/
|
|
rectangle(x: number, y: number, width: number, height: number): void;
|
|
|
|
/**
|
|
* Adds a cubic Bézier spline to the current path using relative coordinates
|
|
* @param dx1 X offset to the first control point from current point
|
|
* @param dy1 Y offset to the first control point from current point
|
|
* @param dx2 X offset to the second control point from current point
|
|
* @param dy2 Y offset to the second control point from current point
|
|
* @param dx3 X offset to the end point from current point
|
|
* @param dy3 Y offset to the end point from current point
|
|
*/
|
|
relCurveTo(dx1: number, dy1: number, dx2: number, dy2: number, dx3: number, dy3: number): void;
|
|
|
|
/**
|
|
* Adds a line to the current path relative to the current point
|
|
* @param dx X offset from the current point
|
|
* @param dy Y offset from the current point
|
|
*/
|
|
relLineTo(dx: number, dy: number): void;
|
|
|
|
/**
|
|
* Begins a new subpath relative to the current point
|
|
* @param dx X offset from the current point
|
|
* @param dy Y offset from the current point
|
|
*/
|
|
relMoveTo(dx: number, dy: number): void;
|
|
|
|
/**
|
|
* Resets the current clip region to its original, unrestricted state
|
|
*/
|
|
resetClip(): void;
|
|
|
|
/**
|
|
* Restores the context state from the stack
|
|
*/
|
|
restore(): void;
|
|
|
|
/**
|
|
* Rotates the current transformation matrix
|
|
* @param angle Angle of rotation in radians
|
|
*/
|
|
rotate(angle: number): void;
|
|
|
|
/**
|
|
* Saves the current context state to the stack
|
|
*/
|
|
save(): void;
|
|
|
|
/**
|
|
* Scales the current transformation matrix
|
|
* @param sx Scale factor for the X dimension
|
|
* @param sy Scale factor for the Y dimension
|
|
*/
|
|
scale(sx: number, sy: number): void;
|
|
|
|
/**
|
|
* Selects a font face
|
|
* @param family A font family name
|
|
* @param slant A font slant
|
|
* @param weight A font weight
|
|
*/
|
|
selectFontFace(family: string, slant: number, weight: number): void;
|
|
|
|
/**
|
|
* Sets the antialiasing mode
|
|
* @param antialias The new antialiasing mode
|
|
*/
|
|
setAntialias(antialias: Antialias): void;
|
|
|
|
/**
|
|
* Sets the dash pattern to be used by stroke()
|
|
* @param dashes Array of dash lengths
|
|
* @param offset Offset into the dash pattern
|
|
*/
|
|
setDash(dashes: number[], offset: number): void;
|
|
|
|
/**
|
|
* Sets the current font size in user space units
|
|
* @param size Font size in user space units
|
|
*/
|
|
setFontSize(size: number): void;
|
|
|
|
/**
|
|
* Sets the current fill rule
|
|
* @param fillRule The new fill rule
|
|
*/
|
|
setFillRule(fillRule: FillRule): void;
|
|
|
|
/**
|
|
* Sets the current line cap style
|
|
* @param lineCap The new line cap style
|
|
*/
|
|
setLineCap(lineCap: LineCap): void;
|
|
|
|
/**
|
|
* Sets the current line join style
|
|
* @param lineJoin The new line join style
|
|
*/
|
|
setLineJoin(lineJoin: LineJoin): void;
|
|
|
|
/**
|
|
* Sets the current line width
|
|
* @param width The new line width
|
|
*/
|
|
setLineWidth(width: number): void;
|
|
|
|
/**
|
|
* Sets the current miter limit
|
|
* @param limit The new miter limit
|
|
*/
|
|
setMiterLimit(limit: number): void;
|
|
|
|
/**
|
|
* Sets the current compositing operator
|
|
* @param op The new compositing operator
|
|
*/
|
|
setOperator(op: Operator): void;
|
|
|
|
/**
|
|
* Sets the current source pattern
|
|
* @param pattern The new source pattern
|
|
*/
|
|
setSource(pattern: Pattern): void;
|
|
|
|
/**
|
|
* Sets the source pattern to an RGB opaque color
|
|
* @param red Red component, between 0 and 1
|
|
* @param green Green component, between 0 and 1
|
|
* @param blue Blue component, between 0 and 1
|
|
*/
|
|
setSourceRGB(red: number, green: number, blue: number): void;
|
|
|
|
/**
|
|
* Sets the source pattern to an RGBA color
|
|
* @param red Red component, between 0 and 1
|
|
* @param green Green component, between 0 and 1
|
|
* @param blue Blue component, between 0 and 1
|
|
* @param alpha Alpha component, between 0 and 1
|
|
*/
|
|
setSourceRGBA(red: number, green: number, blue: number, alpha: number): void;
|
|
|
|
/**
|
|
* Sets the source pattern to the given surface
|
|
* @param surface The new source surface
|
|
* @param x X coordinate where to place the surface origin
|
|
* @param y Y coordinate where to place the surface origin
|
|
*/
|
|
setSourceSurface(surface: Surface, x: number, y: number): void;
|
|
|
|
/**
|
|
* Sets the tolerance used when converting paths to trapezoids
|
|
* @param tolerance The new tolerance value
|
|
*/
|
|
setTolerance(tolerance: number): void;
|
|
|
|
/**
|
|
* Emits the current page and clears it
|
|
*/
|
|
showPage(): void;
|
|
|
|
/**
|
|
* Draws text at the current position
|
|
* @param utf8 A string of text encoded in UTF-8
|
|
*/
|
|
showText(utf8: string): void;
|
|
|
|
/**
|
|
* Strokes the current path using the current line width, line join,
|
|
* line cap, and dash settings, then clears the path
|
|
*/
|
|
stroke(): void;
|
|
|
|
/**
|
|
* Like stroke() but preserves the current path
|
|
*/
|
|
strokePreserve(): void;
|
|
|
|
/**
|
|
* Returns the current stroke extents as [x1, y1, x2, y2]
|
|
* @returns An array with [x1, y1, x2, y2] stroke extents
|
|
*/
|
|
strokeExtents(): [number, number, number, number];
|
|
|
|
/**
|
|
* Gets the extents of the given text if it were drawn at the current point
|
|
* @param utf8 A string of text encoded in UTF-8
|
|
* @returns Text extents information
|
|
*/
|
|
textExtents(utf8: string): TextExtents;
|
|
|
|
/**
|
|
* Translates the current transformation matrix
|
|
* @param tx Translation in the X direction
|
|
* @param ty Translation in the Y direction
|
|
*/
|
|
translate(tx: number, ty: number): void;
|
|
|
|
/**
|
|
* Transforms a coordinate from user space to device space
|
|
* @param x X coordinate
|
|
* @param y Y coordinate
|
|
* @returns An array with [x, y] transformed coordinates
|
|
*/
|
|
userToDevice(x: number, y: number): [number, number];
|
|
|
|
/**
|
|
* Transforms a distance vector from user space to device space
|
|
* @param x X component of the distance vector
|
|
* @param y Y component of the distance vector
|
|
* @returns An array with [x, y] transformed distance vector
|
|
*/
|
|
userToDeviceDistance(x: number, y: number): [number, number];
|
|
|
|
/**
|
|
* Creates a copy of the current path and returns it
|
|
* @returns A copy of the current path
|
|
*/
|
|
copyPath(): Path;
|
|
|
|
/**
|
|
* Appends a path to the current path
|
|
* @param path A path to append
|
|
*/
|
|
appendPath(path: Path): void;
|
|
}
|
|
|
|
/**
|
|
* Base class for all Cairo surfaces
|
|
*/
|
|
export abstract class Surface extends Cairo.Surface {
|
|
/**
|
|
* Gets the device scale of the surface
|
|
* @returns An array with [x, y] device scale
|
|
*/
|
|
getDeviceScale(): [number, number];
|
|
|
|
/**
|
|
* Sets the device scale of the surface
|
|
* @param x X scale factor
|
|
* @param y Y scale factor
|
|
*/
|
|
setDeviceScale(x: number, y: number): void;
|
|
|
|
/**
|
|
* Gets the device offset of the surface
|
|
* @returns An array with [x, y] device offset
|
|
*/
|
|
getDeviceOffset(): [number, number];
|
|
|
|
/**
|
|
* Sets the device offset of the surface
|
|
* @param x X offset
|
|
* @param y Y offset
|
|
*/
|
|
setDeviceOffset(x: number, y: number): void;
|
|
|
|
/**
|
|
* Performs all pending drawing operations
|
|
*/
|
|
flush(): void;
|
|
|
|
/**
|
|
* Finishes the surface and drops all references to external resources
|
|
*/
|
|
finish(): void;
|
|
}
|
|
|
|
/**
|
|
* A surface that uses in-memory image data buffers
|
|
*/
|
|
export class ImageSurface extends Surface {
|
|
/**
|
|
* Creates a new image surface
|
|
* @param format The format of pixels in the surface
|
|
* @param width Width of the surface in pixels
|
|
* @param height Height of the surface in pixels
|
|
*/
|
|
constructor(format: Format, width: number, height: number);
|
|
|
|
/**
|
|
* Creates a new image surface from a PNG file
|
|
* @param filename Path to a PNG file
|
|
* @returns A new image surface
|
|
*/
|
|
static createFromPNG(filename: string): ImageSurface;
|
|
|
|
/**
|
|
* Gets the format of the surface
|
|
* @returns The format of the surface
|
|
*/
|
|
getFormat(): Format;
|
|
|
|
/**
|
|
* Gets the width of the surface in pixels
|
|
* @returns The width of the surface
|
|
*/
|
|
getWidth(): number;
|
|
|
|
/**
|
|
* Gets the height of the surface in pixels
|
|
* @returns The height of the surface
|
|
*/
|
|
getHeight(): number;
|
|
|
|
/**
|
|
* Writes the contents of the surface to a PNG file
|
|
* @param filename Path to the PNG file to write
|
|
*/
|
|
writeToPNG(filename: string): void;
|
|
}
|
|
|
|
/**
|
|
* A surface that produces output in the PDF format
|
|
*/
|
|
export class PDFSurface extends Surface {
|
|
/**
|
|
* Creates a new PDF surface
|
|
* @param filename Path to the PDF file to write to
|
|
* @param width Width of the surface in points (1 point = 1/72 inch)
|
|
* @param height Height of the surface in points (1 point = 1/72 inch)
|
|
*/
|
|
constructor(filename: string, width: number, height: number);
|
|
}
|
|
|
|
/**
|
|
* A surface that produces output in the PostScript format
|
|
*/
|
|
export class PSSurface extends Surface {
|
|
/**
|
|
* Creates a new PostScript surface
|
|
* @param filename Path to the PostScript file to write to
|
|
* @param width Width of the surface in points (1 point = 1/72 inch)
|
|
* @param height Height of the surface in points (1 point = 1/72 inch)
|
|
*/
|
|
constructor(filename: string, width: number, height: number);
|
|
}
|
|
|
|
/**
|
|
* A surface that produces output in the SVG format
|
|
*/
|
|
export class SVGSurface extends Surface {
|
|
/**
|
|
* Creates a new SVG surface
|
|
* @param filename Path to the SVG file to write to
|
|
* @param width Width of the surface in points (1 point = 1/72 inch)
|
|
* @param height Height of the surface in points (1 point = 1/72 inch)
|
|
*/
|
|
constructor(filename: string, width: number, height: number);
|
|
}
|
|
|
|
/**
|
|
* Base class for all Cairo patterns
|
|
*/
|
|
export class Pattern extends Cairo.Pattern {}
|
|
|
|
/**
|
|
* Base class for all gradient patterns
|
|
*/
|
|
export class Gradient extends Pattern {
|
|
/**
|
|
* Adds a color stop to the gradient at the given offset
|
|
* @param offset Offset position of the stop, between 0 and 1
|
|
* @param red Red component, between 0 and 1
|
|
* @param green Green component, between 0 and 1
|
|
* @param blue Blue component, between 0 and 1
|
|
* @param alpha Alpha component, between 0 and 1
|
|
*/
|
|
addColorStopRGBA(offset: number, red: number, green: number, blue: number, alpha: number): void;
|
|
|
|
/**
|
|
* Adds an opaque color stop to the gradient at the given offset
|
|
* @param offset Offset position of the stop, between 0 and 1
|
|
* @param red Red component, between 0 and 1
|
|
* @param green Green component, between 0 and 1
|
|
* @param blue Blue component, between 0 and 1
|
|
*/
|
|
addColorStopRGB(offset: number, red: number, green: number, blue: number): void;
|
|
}
|
|
|
|
/**
|
|
* A pattern for linear gradients
|
|
*/
|
|
export class LinearGradient extends Gradient {
|
|
/**
|
|
* Creates a new linear gradient pattern
|
|
* @param x0 X coordinate of the start point
|
|
* @param y0 Y coordinate of the start point
|
|
* @param x1 X coordinate of the end point
|
|
* @param y1 Y coordinate of the end point
|
|
*/
|
|
constructor(x0: number, y0: number, x1: number, y1: number);
|
|
}
|
|
|
|
/**
|
|
* A pattern for radial gradients
|
|
*/
|
|
export class RadialGradient extends Gradient {
|
|
/**
|
|
* Creates a new radial gradient pattern
|
|
* @param cx0 X coordinate of the start circle
|
|
* @param cy0 Y coordinate of the start circle
|
|
* @param radius0 Radius of the start circle
|
|
* @param cx1 X coordinate of the end circle
|
|
* @param cy1 Y coordinate of the end circle
|
|
* @param radius1 Radius of the end circle
|
|
*/
|
|
constructor(cx0: number, cy0: number, radius0: number, cx1: number, cy1: number, radius1: number);
|
|
}
|
|
|
|
/**
|
|
* A pattern that uses a surface as its source
|
|
*/
|
|
export class SurfacePattern extends Pattern {
|
|
/**
|
|
* Creates a new pattern for the given surface
|
|
* @param surface The surface to use
|
|
*/
|
|
constructor(surface: Surface);
|
|
}
|
|
|
|
/**
|
|
* A pattern for solid colors
|
|
*/
|
|
export class SolidPattern extends Pattern {
|
|
/**
|
|
* Creates a new solid pattern with an opaque color
|
|
* @param red Red component, between 0 and 1
|
|
* @param green Green component, between 0 and 1
|
|
* @param blue Blue component, between 0 and 1
|
|
* @returns A new solid pattern
|
|
*/
|
|
static createRGB(red: number, green: number, blue: number): SolidPattern;
|
|
|
|
/**
|
|
* Creates a new solid pattern with a transparent color
|
|
* @param red Red component, between 0 and 1
|
|
* @param green Green component, between 0 and 1
|
|
* @param blue Blue component, between 0 and 1
|
|
* @param alpha Alpha component, between 0 and 1
|
|
* @returns A new solid pattern
|
|
*/
|
|
static createRGBA(red: number, green: number, blue: number, alpha: number): SolidPattern;
|
|
}
|
|
|
|
export class Path extends Cairo.Path {}
|
|
|
|
/**
|
|
* A rectangle
|
|
*/
|
|
export class Rectangle extends Cairo.Rectangle {}
|
|
|
|
/**
|
|
* A rectangle integer
|
|
*/
|
|
export class RectangleInt extends Cairo.RectangleInt {}
|
|
|
|
/**
|
|
* A region object used for representing a set of pixels
|
|
*/
|
|
export class Region extends Cairo.Region {}
|
|
|
|
/**
|
|
* A matrix object used for transforming coordinates
|
|
*/
|
|
export class Matrix extends Cairo.Matrix {}
|
|
|
|
/**
|
|
* A font face object used for storing and manipulating font faces
|
|
*/
|
|
export class FontFace extends Cairo.FontFace {}
|
|
|
|
/**
|
|
* A scaled font object used for storing and manipulating scaled fonts
|
|
*/
|
|
export class ScaledFont extends Cairo.ScaledFont {}
|
|
|
|
/**
|
|
* A glyph object used for storing and manipulating glyphs
|
|
*/
|
|
export class Glyph extends Cairo.Glyph {}
|
|
|
|
/**
|
|
* A text cluster object used for storing and manipulating text clusters
|
|
*/
|
|
export class TextCluster extends Cairo.TextCluster {}
|
|
|
|
/**
|
|
* A font options object used for storing and manipulating font options
|
|
*/
|
|
export class FontOptions extends Cairo.FontOptions {}
|
|
|
|
/**
|
|
* A device object used for storing and manipulating devices
|
|
*/
|
|
export class Device extends Cairo.Device {}
|
|
}
|
|
|
|
export default giCairo;
|
|
}
|