skiko/org.jetbrains.skia

Package-level declarations

Types

AnimationDisposalMethod

enum AnimationDisposalMethod : Enum<AnimationDisposalMethod>

This specifies how the next frame is based on this frame.

AnimationDisposalMode

enum AnimationDisposalMode : Enum<AnimationDisposalMode>

This specifies how the next frame is based on this frame.

AnimationFrameInfo

class AnimationFrameInfo(var requiredFrame: Int, var duration: Int, var isFullyReceived: Boolean, var alphaType: ColorAlphaType, var isHasAlphaWithinBounds: Boolean, var disposalMethod: AnimationDisposalMode, var blendMode: BlendMode, frameRect: IRect)

Information about individual frames in a multi-framed image.

ArrayDecoder

class ArrayDecoder(ptr: NativePointer, disposePtr: NativePointer)

BackendRenderTarget

class BackendRenderTarget : Managed

BackendTexture

class BackendTexture : Managed

BBHFactory

abstract class BBHFactory : Managed

Bitmap

class Bitmap : Managed, IHasImageInfo

Blender

class Blender : RefCnt

Blender represents a custom blend function in the Skia pipeline. A blender combines a source color (the result of our paint) and destination color (from the canvas) into a final color.

BlendMode

enum BlendMode : Enum<BlendMode>

Blends are operators that take in two colors (source, destination) and return a new color. Many of these operate the same on all 4 components: red, green, blue, alpha. For these, we just document what happens to one component, rather than naming each one separately.

BreakIterator

class BreakIterator : Managed

A class that locates boundaries in text. This class defines a protocol for objects that break up a piece of natural-language text according to a set of criteria. Instances or subclasses of BreakIterator can be provided, for example, to break a piece of text into words, sentences, or logical characters according to the conventions of some language or group of languages.

Canvas

open class Canvas : Managed

ClipMode

enum ClipMode : Enum<ClipMode>

Codec

class Codec : Managed, IHasImageInfo

Color

object Color

Color4f

class Color4f(val r: Float, val g: Float, val b: Float, val a: Float = 1.0f)

ColorAlphaType

enum ColorAlphaType : Enum<ColorAlphaType>

Describes how to interpret the alpha component of a pixel. A pixel may be opaque, or alpha, describing multiple levels of transparency.

ColorChannel

enum ColorChannel : Enum<ColorChannel>

ColorFilter

class ColorFilter : RefCnt

ColorFilters are optional objects in the drawing pipeline. When present in a paint, they are called with the "src" colors, and return new colors, which are then passed onto the next stage (either ImageFilter or Xfermode).

ColorInfo

class ColorInfo(val colorType: ColorType, val alphaType: ColorAlphaType, val colorSpace: ColorSpace?)

Describes pixel and encoding. ImageInfo can be created from ColorInfo by providing dimensions.

ColorMatrix

value class ColorMatrix(val mat: FloatArray)

ColorSpace

class ColorSpace : Managed

ColorType

enum ColorType : Enum<ColorType>

Describes how pixel bits encode color. A pixel may be an alpha mask, a grayscale, RGB, or ARGB.

ContentChangeMode

enum ContentChangeMode : Enum<ContentChangeMode>

CubicResampler

class CubicResampler(val b: Float, val c: Float) : SamplingMode

Specify B and C (each between 0...1) to create a shader that applies the corresponding cubic reconstruction filter to the image.

Data

class Data : Managed

Data holds an immutable data buffer.

DirectContext

class DirectContext : RefCnt

Drawable

abstract class Drawable : Managed

Base class for objects that draw into Canvas.

DynamicMemoryWStream

class DynamicMemoryWStream : WStream

EncodedImageFormat

enum EncodedImageFormat : Enum<EncodedImageFormat>

EncodedOrigin

enum EncodedOrigin : Enum<EncodedOrigin>

ExternalSymbolName

expect annotation class ExternalSymbolName(val name: String)

actual typealias ExternalSymbolName = WebImport

actual typealias ExternalSymbolName = <Error class: unknown class>

actual typealias ExternalSymbolName = WebImport

FilterBlurMode

enum FilterBlurMode : Enum<FilterBlurMode>

FilterMipmap

class FilterMipmap(filterMode: FilterMode, mipmapMode: MipmapMode = MipmapMode.NONE) : SamplingMode

FilterMode

enum FilterMode : Enum<FilterMode>

FilterQuality

enum FilterQuality : Enum<FilterQuality>

FilterTileMode

enum FilterTileMode : Enum<FilterTileMode>

Font

class Font : Managed

FontEdging

enum FontEdging : Enum<FontEdging>

Whether edge pixels draw opaque or with partial transparency.

FontExtents

class FontExtents(val ascender: Float, val descender: Float, val lineGap: Float)

FontFamilyName

class FontFamilyName(val name: String, val language: String)

FontFeature

class FontFeature(val _tag: Int, val value: Int, val start: <Error class: unknown class>, val end: <Error class: unknown class>)

FontHinting

enum FontHinting : Enum<FontHinting>

Level of glyph outline adjustment

FontMetrics

class FontMetrics(val top: Float, val ascent: Float, val descent: Float, val bottom: Float, val leading: Float, val avgCharWidth: Float, val maxCharWidth: Float, val xMin: Float, val xMax: Float, val xHeight: Float, val capHeight: Float, val underlineThickness: Float?, val underlinePosition: Float?, val strikeoutThickness: Float?, val strikeoutPosition: Float?)

FontMgr

open class FontMgr : RefCnt

FontMgrWithFallback

class FontMgrWithFallback(fallbackProvider: TypefaceFontProviderWithFallback) : FontMgr

Consider registering this FontMgr as a default one to let all other possibly registered Font managers to look for their fallbacks first: FontCollection.setDefaultFontManager(...)

FontSlant

enum FontSlant : Enum<FontSlant>

FontStyle

class FontStyle

FontStyleSet

class FontStyleSet : RefCnt

FontVariation

class FontVariation(val _tag: Int, val value: Float)

FontVariationAxis

class FontVariationAxis(val _tag: Int, val minValue: Float, val defaultValue: Float, val maxValue: Float, val isHidden: Boolean)

FontWeight

interface FontWeight

FontWidth

interface FontWidth

FourByteTag

interface FourByteTag

FramebufferFormat

interface FramebufferFormat

GLAssembledInterface

class GLAssembledInterface : RefCnt

GLBackendState

enum GLBackendState : Enum<GLBackendState>

Gradient

class Gradient(val colors: Gradient.Colors, val interpolation: Gradient.Interpolation = Interpolation())

Specification for the colors in a gradient.

Graphics

class Graphics

IHasImageInfo

interface IHasImageInfo

Image

class Image : RefCnt, IHasImageInfo

ImageFilter

class ImageFilter : RefCnt

Base class for image filters. If one is installed in the paint, then all drawing occurs as usual, but it is as if the drawing happened into an offscreen (before the xfermode is applied). This offscreen bitmap will then be handed to the imagefilter, who in turn creates a new bitmap which is what will finally be drawn to the device (using the original xfermode).

ImageInfo

class ImageInfo(val colorInfo: ColorInfo, val width: Int, val height: Int)

Describes pixel dimensions and encoding. Bitmap, Image, Pixmap, and Surface can be created from ImageInfo. ImageInfo can be retrieved from Bitmap and Pixmap, but not from Image and Surface. For example, Image and Surface implementations may defer pixel depth, so may not completely specify ImageInfo.

InversionMode

enum InversionMode : Enum<InversionMode>

IPoint

class IPoint(val x: Int, val y: Int)

IRange

class IRange(val start: Int, val end: Int)

IRect

class IRect

ISize

class ISize

ManagedString

class ManagedString : Managed

MaskFilter

class MaskFilter : RefCnt

MaskFilter is the base class for object that perform transformations on the mask before drawing it. An example subclass is Blur.

Matcher

expect class Matcher

actual typealias Matcher = <Error class: unknown class>

actual class Matcher

Matrix22

class Matrix22(mat: Float)

2x2 matrix.

Matrix33

class Matrix33(mat: Float)

Matrix holds a 3x3 matrix for transforming coordinates. This allows mapping Point and vectors with translation, scaling, skewing, rotation, and perspective.

Matrix44

class Matrix44(mat: Float)

4x4 matrix used by SkCanvas and other parts of Skia.

MipmapMode

enum MipmapMode : Enum<MipmapMode>

OutputWStream

class OutputWStream(out: <Error class: unknown class>?) : WStream

Paint

class Paint : Managed

PaintFilterCanvas

abstract class PaintFilterCanvas(canvas: Canvas, unrollDrawable: Boolean) : Canvas

A utility proxy base class for implementing draw/paint filters.

PaintMode

enum PaintMode : Enum<PaintMode>

PaintStrokeCap

enum PaintStrokeCap : Enum<PaintStrokeCap>

Cap draws at the beginning and end of an open path contour.

PaintStrokeJoin

enum PaintStrokeJoin : Enum<PaintStrokeJoin>

Join specifies how corners are drawn when a shape is stroked. Join affects the four corners of a stroked rectangle, and the connected segments in a stroked path.

Path

class Path : Managed, Iterable<PathSegment?>

Path contain geometry. Path may be empty, or contain one or more verbs that outline a figure. Path always starts with a move verb to a Cartesian coordinate, and may be followed by additional verbs that add lines or curves.

PathAddMode

enum PathAddMode : Enum<PathAddMode>

PathAddMode chooses how addPath() appends paths. Adding one Path to another can extend the last contour or start a new contour.

PathArcSize

enum PathArcSize : Enum<PathArcSize>

Enum for choosing smaller or larger arc when adding arcs to paths.

PathBuilder

class PathBuilder : Managed

PathBuilder is used to create immutable Path objects.

PathDirection

enum PathDirection : Enum<PathDirection>

PathEffect

class PathEffect : RefCnt

PathEllipseArc

enum PathEllipseArc : Enum<PathEllipseArc>

PathFillMode

enum PathFillMode : Enum<PathFillMode>

PathMeasure

class PathMeasure : Managed

PathOp

enum PathOp : Enum<PathOp>

The logical operations that can be performed when combining two paths.

PathSegment

class PathSegment(val verb: PathVerb = PathVerb.DONE, val p0: Point? = null, val p1: Point? = null, val p2: Point? = null, val p3: Point? = null, val conicWeight: Float = 0.0f, val isCloseLine: Boolean = false, val isClosedContour: Boolean = false)

PathSegmentIterator

class PathSegmentIterator : Managed, MutableIterator<PathSegment?>

PathSegmentMask

interface PathSegmentMask

PathUtils

object PathUtils

PathVerb

enum PathVerb : Enum<PathVerb>

Verb instructs Path how to interpret one or more Point and optional conic weight; manage contour, and terminate Path.

Pattern

expect class Pattern

actual typealias Pattern = <Error class: unknown class>

actual class Pattern

Picture

class Picture : RefCnt

PictureRecorder

class PictureRecorder : Managed

PixelGeometry

enum PixelGeometry : Enum<PixelGeometry>

PixelRef

class PixelRef : RefCnt

Pixmap

class Pixmap : Managed

Point

class Point(val x: Float, val y: Float)

Point3

class Point3(val x: Float, val y: Float, val z: Float)

Rect

open class Rect(val left: Float, val top: Float, val right: Float, val bottom: Float)

Region

class Region : Managed

Describes a set of pixels as either one integer rectangle or a run-length encoded set of rectangles.

RRect

class RRect : Rect

RSXform

class RSXform(scos: Float, ssin: Float, tx: Float, ty: Float)

A compressed form of a rotation+scale matrix.

RTreeFactory

class RTreeFactory : BBHFactory

RuntimeEffect

class RuntimeEffect : RefCnt

RuntimeShaderBuilder

class RuntimeShaderBuilder : Managed

SamplingMode

interface SamplingMode

Shader

class Shader : RefCnt

Shaders specify the source color(s) for what is being drawn. If a paint has no shader, then the paint's color is used. If the paint has a shader, then the shader's color(s) are use instead, but they are modulated by the paint's alpha. This makes it easy to create a shader once (e.g. bitmap tiling or gradient) and then change its transparency w/o having to modify the original shader... only the paint's alpha needs to be modified.

ShadowUtils

object ShadowUtils

Surface

class Surface : RefCnt

SurfaceColorFormat

enum SurfaceColorFormat : Enum<SurfaceColorFormat>

SurfaceOrigin

enum SurfaceOrigin : Enum<SurfaceOrigin>

SurfaceProps