Struct skia_bindings::SkCanvas

#[repr(C)]
pub struct SkCanvas {
    pub vtable_: *const SkCanvas__bindgen_vtable,
    pub fMCStack: SkDeque,
    pub fMCRec: *mut SkCanvas_MCRec,
    pub fMCRecStorage: [isize; 512],
    pub fDeviceCMStorage: [isize; 28],
    pub fProps: SkSurfaceProps,
    pub fSaveCount: c_int,
    pub fAllocator: std_unique_ptr,
    pub fSurfaceBase: *mut SkSurface_Base,
    pub fClipRestrictionRect: SkIRect,
    pub fIsScaleTranslate: bool,
    pub fDeviceClipBounds: SkRect,
    pub fAllowSoftClip: bool,
    pub fAllowSimplifyClip: bool,
    pub fScratchGlyphRunBuilder: std_unique_ptr,
}

Fields

vtable_: *const SkCanvas__bindgen_vtable

fMCStack: SkDeque

fMCRec: *mut SkCanvas_MCRec

fMCRecStorage: [isize; 512]

fDeviceCMStorage: [isize; 28]

fProps: SkSurfaceProps

fSaveCount: c_int

fAllocator: std_unique_ptr

fSurfaceBase: *mut SkSurface_Base

fClipRestrictionRect: SkIRect

fIsScaleTranslate: bool

fDeviceClipBounds: SkRect

fAllowSoftClip: bool

fAllowSimplifyClip: bool

fScratchGlyphRunBuilder: std_unique_ptr

Methods

impl SkCanvas

pub unsafe fn MakeRasterDirect(
    info: *const SkImageInfo,
    pixels: *mut c_void,
    rowBytes: usize,
    props: *const SkSurfaceProps
) -> std_unique_ptr

pub unsafe fn MakeRasterDirectN32(
    width: c_int,
    height: c_int,
    pixels: *mut SkPMColor,
    rowBytes: usize
) -> std_unique_ptr

pub unsafe fn imageInfo(&self) -> SkImageInfo

pub unsafe fn getProps(&self, props: *mut SkSurfaceProps) -> bool

pub unsafe fn flush(&mut self)

pub unsafe fn makeSurface(
    &mut self,
    info: *const SkImageInfo,
    props: *const SkSurfaceProps
) -> sk_sp<SkSurface>

pub unsafe fn accessTopLayerPixels(
    &mut self,
    info: *mut SkImageInfo,
    rowBytes: *mut usize,
    origin: *mut SkIPoint
) -> *mut c_void

pub unsafe fn accessTopRasterHandle(&self) -> SkRasterHandleAllocator_Handle

pub unsafe fn peekPixels(&mut self, pixmap: *mut SkPixmap) -> bool

pub unsafe fn readPixels(
    &mut self,
    dstInfo: *const SkImageInfo,
    dstPixels: *mut c_void,
    dstRowBytes: usize,
    srcX: c_int,
    srcY: c_int
) -> bool

pub unsafe fn readPixels1(
    &mut self,
    pixmap: *const SkPixmap,
    srcX: c_int,
    srcY: c_int
) -> bool

pub unsafe fn readPixels2(
    &mut self,
    bitmap: *const SkBitmap,
    srcX: c_int,
    srcY: c_int
) -> bool

pub unsafe fn writePixels(
    &mut self,
    info: *const SkImageInfo,
    pixels: *const c_void,
    rowBytes: usize,
    x: c_int,
    y: c_int
) -> bool

pub unsafe fn writePixels1(
    &mut self,
    bitmap: *const SkBitmap,
    x: c_int,
    y: c_int
) -> bool

pub unsafe fn save(&mut self) -> c_int

pub unsafe fn saveLayer(
    &mut self,
    bounds: *const SkRect,
    paint: *const SkPaint
) -> c_int

pub unsafe fn saveLayer1(
    &mut self,
    bounds: *const SkRect,
    paint: *const SkPaint
) -> c_int

pub unsafe fn saveLayerAlpha(
    &mut self,
    bounds: *const SkRect,
    alpha: U8CPU
) -> c_int

pub unsafe fn saveLayer2(
    &mut self,
    layerRec: *const SkCanvas_SaveLayerRec
) -> c_int

pub unsafe fn restore(&mut self)

pub unsafe fn getSaveCount(&self) -> c_int

pub unsafe fn restoreToCount(&mut self, saveCount: c_int)

pub unsafe fn translate(&mut self, dx: SkScalar, dy: SkScalar)

pub unsafe fn scale(&mut self, sx: SkScalar, sy: SkScalar)

pub unsafe fn rotate(&mut self, degrees: SkScalar)

pub unsafe fn rotate1(&mut self, degrees: SkScalar, px: SkScalar, py: SkScalar)

pub unsafe fn skew(&mut self, sx: SkScalar, sy: SkScalar)

pub unsafe fn concat(&mut self, matrix: *const SkMatrix)

pub unsafe fn setMatrix(&mut self, matrix: *const SkMatrix)

pub unsafe fn resetMatrix(&mut self)

pub unsafe fn clipRect(
    &mut self,
    rect: *const SkRect,
    op: SkClipOp,
    doAntiAlias: bool
)

pub unsafe fn clipRect1(&mut self, rect: *const SkRect, op: SkClipOp)

pub unsafe fn clipRect2(&mut self, rect: *const SkRect, doAntiAlias: bool)

pub unsafe fn androidFramework_setDeviceClipRestriction(
    &mut self,
    rect: *const SkIRect
)

pub unsafe fn clipRRect(
    &mut self,
    rrect: *const SkRRect,
    op: SkClipOp,
    doAntiAlias: bool
)

pub unsafe fn clipRRect1(&mut self, rrect: *const SkRRect, op: SkClipOp)

pub unsafe fn clipRRect2(&mut self, rrect: *const SkRRect, doAntiAlias: bool)

pub unsafe fn clipPath(
    &mut self,
    path: *const SkPath,
    op: SkClipOp,
    doAntiAlias: bool
)

pub unsafe fn clipPath1(&mut self, path: *const SkPath, op: SkClipOp)

pub unsafe fn clipPath2(&mut self, path: *const SkPath, doAntiAlias: bool)

pub unsafe fn setAllowSimplifyClip(&mut self, allow: bool)

pub unsafe fn clipRegion(&mut self, deviceRgn: *const SkRegion, op: SkClipOp)

pub unsafe fn quickReject(&self, rect: *const SkRect) -> bool

pub unsafe fn quickReject1(&self, path: *const SkPath) -> bool

pub unsafe fn getLocalClipBounds(&self) -> SkRect

pub unsafe fn getLocalClipBounds1(&self, bounds: *mut SkRect) -> bool

pub unsafe fn getDeviceClipBounds(&self) -> SkIRect

pub unsafe fn getDeviceClipBounds1(&self, bounds: *mut SkIRect) -> bool

pub unsafe fn drawColor(&mut self, color: SkColor, mode: SkBlendMode)

pub unsafe fn clear(&mut self, color: SkColor)

pub unsafe fn discard(&mut self)

pub unsafe fn drawPaint(&mut self, paint: *const SkPaint)

pub unsafe fn drawPoints(
    &mut self,
    mode: SkCanvas_PointMode,
    count: usize,
    pts: *const SkPoint,
    paint: *const SkPaint
)

pub unsafe fn drawPoint(
    &mut self,
    x: SkScalar,
    y: SkScalar,
    paint: *const SkPaint
)

pub unsafe fn drawPoint1(&mut self, p: SkPoint, paint: *const SkPaint)

pub unsafe fn drawLine(
    &mut self,
    x0: SkScalar,
    y0: SkScalar,
    x1: SkScalar,
    y1: SkScalar,
    paint: *const SkPaint
)

pub unsafe fn drawLine1(
    &mut self,
    p0: SkPoint,
    p1: SkPoint,
    paint: *const SkPaint
)

pub unsafe fn drawRect(&mut self, rect: *const SkRect, paint: *const SkPaint)

pub unsafe fn drawIRect(&mut self, rect: *const SkIRect, paint: *const SkPaint)

pub unsafe fn drawRegion(
    &mut self,
    region: *const SkRegion,
    paint: *const SkPaint
)

pub unsafe fn drawOval(&mut self, oval: *const SkRect, paint: *const SkPaint)

pub unsafe fn drawRRect(&mut self, rrect: *const SkRRect, paint: *const SkPaint)

pub unsafe fn drawDRRect(
    &mut self,
    outer: *const SkRRect,
    inner: *const SkRRect,
    paint: *const SkPaint
)

pub unsafe fn drawCircle(
    &mut self,
    cx: SkScalar,
    cy: SkScalar,
    radius: SkScalar,
    paint: *const SkPaint
)

pub unsafe fn drawCircle1(
    &mut self,
    center: SkPoint,
    radius: SkScalar,
    paint: *const SkPaint
)

pub unsafe fn drawArc(
    &mut self,
    oval: *const SkRect,
    startAngle: SkScalar,
    sweepAngle: SkScalar,
    useCenter: bool,
    paint: *const SkPaint
)

pub unsafe fn drawRoundRect(
    &mut self,
    rect: *const SkRect,
    rx: SkScalar,
    ry: SkScalar,
    paint: *const SkPaint
)

pub unsafe fn drawPath(&mut self, path: *const SkPath, paint: *const SkPaint)

pub unsafe fn drawImage(
    &mut self,
    image: *const SkImage,
    left: SkScalar,
    top: SkScalar,
    paint: *const SkPaint
)

pub unsafe fn drawImage1(
    &mut self,
    image: *const sk_sp<SkImage>,
    left: SkScalar,
    top: SkScalar,
    paint: *const SkPaint
)

pub unsafe fn drawImageRect(
    &mut self,
    image: *const SkImage,
    src: *const SkRect,
    dst: *const SkRect,
    paint: *const SkPaint,
    constraint: SkCanvas_SrcRectConstraint
)

pub unsafe fn drawImageRect1(
    &mut self,
    image: *const SkImage,
    isrc: *const SkIRect,
    dst: *const SkRect,
    paint: *const SkPaint,
    constraint: SkCanvas_SrcRectConstraint
)

pub unsafe fn drawImageRect2(
    &mut self,
    image: *const SkImage,
    dst: *const SkRect,
    paint: *const SkPaint
)

pub unsafe fn drawImageRect3(
    &mut self,
    image: *const sk_sp<SkImage>,
    src: *const SkRect,
    dst: *const SkRect,
    paint: *const SkPaint,
    constraint: SkCanvas_SrcRectConstraint
)

pub unsafe fn drawImageRect4(
    &mut self,
    image: *const sk_sp<SkImage>,
    isrc: *const SkIRect,
    dst: *const SkRect,
    paint: *const SkPaint,
    constraint: SkCanvas_SrcRectConstraint
)

pub unsafe fn drawImageRect5(
    &mut self,
    image: *const sk_sp<SkImage>,
    dst: *const SkRect,
    paint: *const SkPaint
)

pub unsafe fn drawImageNine(
    &mut self,
    image: *const SkImage,
    center: *const SkIRect,
    dst: *const SkRect,
    paint: *const SkPaint
)

pub unsafe fn drawImageNine1(
    &mut self,
    image: *const sk_sp<SkImage>,
    center: *const SkIRect,
    dst: *const SkRect,
    paint: *const SkPaint
)

pub unsafe fn drawBitmap(
    &mut self,
    bitmap: *const SkBitmap,
    left: SkScalar,
    top: SkScalar,
    paint: *const SkPaint
)

pub unsafe fn drawBitmapRect(
    &mut self,
    bitmap: *const SkBitmap,
    src: *const SkRect,
    dst: *const SkRect,
    paint: *const SkPaint,
    constraint: SkCanvas_SrcRectConstraint
)

pub unsafe fn drawBitmapRect1(
    &mut self,
    bitmap: *const SkBitmap,
    isrc: *const SkIRect,
    dst: *const SkRect,
    paint: *const SkPaint,
    constraint: SkCanvas_SrcRectConstraint
)

pub unsafe fn drawBitmapRect2(
    &mut self,
    bitmap: *const SkBitmap,
    dst: *const SkRect,
    paint: *const SkPaint,
    constraint: SkCanvas_SrcRectConstraint
)

pub unsafe fn drawBitmapNine(
    &mut self,
    bitmap: *const SkBitmap,
    center: *const SkIRect,
    dst: *const SkRect,
    paint: *const SkPaint
)

pub unsafe fn drawBitmapLattice(
    &mut self,
    bitmap: *const SkBitmap,
    lattice: *const SkCanvas_Lattice,
    dst: *const SkRect,
    paint: *const SkPaint
)

pub unsafe fn drawImageLattice(
    &mut self,
    image: *const SkImage,
    lattice: *const SkCanvas_Lattice,
    dst: *const SkRect,
    paint: *const SkPaint
)

pub unsafe fn experimental_DrawEdgeAAQuad(
    &mut self,
    rect: *const SkRect,
    clip: *const SkPoint,
    aaFlags: SkCanvas_QuadAAFlags,
    color: SkColor,
    mode: SkBlendMode
)

pub unsafe fn experimental_DrawEdgeAAImageSet(
    &mut self,
    imageSet: *const SkCanvas_ImageSetEntry,
    cnt: c_int,
    dstClips: *const SkPoint,
    preViewMatrices: *const SkMatrix,
    paint: *const SkPaint,
    constraint: SkCanvas_SrcRectConstraint
)

pub unsafe fn drawSimpleText(
    &mut self,
    text: *const c_void,
    byteLength: usize,
    encoding: SkTextEncoding,
    x: SkScalar,
    y: SkScalar,
    font: *const SkFont,
    paint: *const SkPaint
)

pub unsafe fn drawString(
    &mut self,
    str: *const c_char,
    x: SkScalar,
    y: SkScalar,
    font: *const SkFont,
    paint: *const SkPaint
)

pub unsafe fn drawString1(
    &mut self,
    str: *const SkString,
    x: SkScalar,
    y: SkScalar,
    font: *const SkFont,
    paint: *const SkPaint
)

pub unsafe fn drawTextBlob(
    &mut self,
    blob: *const SkTextBlob,
    x: SkScalar,
    y: SkScalar,
    paint: *const SkPaint
)

pub unsafe fn drawTextBlob1(
    &mut self,
    blob: *const sk_sp<SkTextBlob>,
    x: SkScalar,
    y: SkScalar,
    paint: *const SkPaint
)

pub unsafe fn drawPicture(&mut self, picture: *const SkPicture)

pub unsafe fn drawPicture1(&mut self, picture: *const sk_sp<SkPicture>)

pub unsafe fn drawPicture2(
    &mut self,
    picture: *const SkPicture,
    matrix: *const SkMatrix,
    paint: *const SkPaint
)

pub unsafe fn drawPicture3(
    &mut self,
    picture: *const sk_sp<SkPicture>,
    matrix: *const SkMatrix,
    paint: *const SkPaint
)

pub unsafe fn drawVertices(
    &mut self,
    vertices: *const SkVertices,
    mode: SkBlendMode,
    paint: *const SkPaint
)

pub unsafe fn drawVertices1(
    &mut self,
    vertices: *const sk_sp<SkVertices>,
    mode: SkBlendMode,
    paint: *const SkPaint
)

pub unsafe fn drawVertices2(
    &mut self,
    vertices: *const SkVertices,
    bones: *const SkVertices_Bone,
    boneCount: c_int,
    mode: SkBlendMode,
    paint: *const SkPaint
)

pub unsafe fn drawVertices3(
    &mut self,
    vertices: *const sk_sp<SkVertices>,
    bones: *const SkVertices_Bone,
    boneCount: c_int,
    mode: SkBlendMode,
    paint: *const SkPaint
)

pub unsafe fn drawPatch(
    &mut self,
    cubics: *const SkPoint,
    colors: *const SkColor,
    texCoords: *const SkPoint,
    mode: SkBlendMode,
    paint: *const SkPaint
)

pub unsafe fn drawPatch1(
    &mut self,
    cubics: *const SkPoint,
    colors: *const SkColor,
    texCoords: *const SkPoint,
    paint: *const SkPaint
)

pub unsafe fn drawAtlas(
    &mut self,
    atlas: *const SkImage,
    xform: *const SkRSXform,
    tex: *const SkRect,
    colors: *const SkColor,
    count: c_int,
    mode: SkBlendMode,
    cullRect: *const SkRect,
    paint: *const SkPaint
)

pub unsafe fn drawAtlas1(
    &mut self,
    atlas: *const sk_sp<SkImage>,
    xform: *const SkRSXform,
    tex: *const SkRect,
    colors: *const SkColor,
    count: c_int,
    mode: SkBlendMode,
    cullRect: *const SkRect,
    paint: *const SkPaint
)

pub unsafe fn drawAtlas2(
    &mut self,
    atlas: *const SkImage,
    xform: *const SkRSXform,
    tex: *const SkRect,
    count: c_int,
    cullRect: *const SkRect,
    paint: *const SkPaint
)

pub unsafe fn drawAtlas3(
    &mut self,
    atlas: *const sk_sp<SkImage>,
    xform: *const SkRSXform,
    tex: *const SkRect,
    count: c_int,
    cullRect: *const SkRect,
    paint: *const SkPaint
)

pub unsafe fn drawDrawable(
    &mut self,
    drawable: *mut SkDrawable,
    matrix: *const SkMatrix
)

pub unsafe fn drawDrawable1(
    &mut self,
    drawable: *mut SkDrawable,
    x: SkScalar,
    y: SkScalar
)

pub unsafe fn drawAnnotation(
    &mut self,
    rect: *const SkRect,
    key: *const c_char,
    value: *mut SkData
)

pub unsafe fn drawAnnotation1(
    &mut self,
    rect: *const SkRect,
    key: *const c_char,
    value: *const sk_sp<SkData>
)

pub unsafe fn getTotalMatrix(&self) -> *const SkMatrix

pub unsafe fn internal_private_getTopLayerBounds(&self) -> SkIRect

pub unsafe fn legacy_drawImageRect(
    &mut self,
    image: *const SkImage,
    src: *const SkRect,
    dst: *const SkRect,
    paint: *const SkPaint,
    constraint: SkCanvas_SrcRectConstraint
)

pub unsafe fn legacy_drawBitmapRect(
    &mut self,
    bitmap: *const SkBitmap,
    src: *const SkRect,
    dst: *const SkRect,
    paint: *const SkPaint,
    constraint: SkCanvas_SrcRectConstraint
)

pub unsafe fn temporary_internal_getRgnClip(&mut self, region: *mut SkRegion)

pub unsafe fn private_draw_shadow_rec(
    &mut self,
    arg1: *const SkPath,
    arg2: *const SkDrawShadowRec
)

pub unsafe fn clipRectBounds(
    &mut self,
    bounds: *const SkRect,
    flags: SkCanvas_SaveLayerFlags,
    intersection: *mut SkIRect,
    imageFilter: *const SkImageFilter
) -> bool

pub unsafe fn getTopDevice(&self) -> *mut SkBaseDevice

pub unsafe fn new() -> Self

pub unsafe fn new1(
    width: c_int,
    height: c_int,
    props: *const SkSurfaceProps
) -> Self

pub unsafe fn new2(device: sk_sp<SkBaseDevice>) -> Self

pub unsafe fn new3(bitmap: *const SkBitmap) -> Self

pub unsafe fn new4(
    bitmap: *const SkBitmap,
    props: *const SkSurfaceProps
) -> Self

pub unsafe fn new5(bounds: *const SkIRect) -> Self