Struct skia_bindings::SkPath

#[repr(C)]
pub struct SkPath {
    pub fPathRef: sk_sp<SkPathRef>,
    pub fLastMoveToIndex: c_int,
    pub fConvexity: u8,
    pub fFirstDirection: u8,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1], u8>,
    pub __bindgen_padding_0: u8,
}

Fields

fPathRef: sk_sp<SkPathRef>

fLastMoveToIndex: c_int

fConvexity: u8

fFirstDirection: u8

_bitfield_1: __BindgenBitfieldUnit<[u8; 1], u8>

__bindgen_padding_0: u8

Methods

impl SkPath

pub fn fFillType(&self) -> u8

pub fn set_fFillType(&mut self, val: u8)

pub fn fIsVolatile(&self) -> u8

pub fn set_fIsVolatile(&mut self, val: u8)

pub fn new_bitfield_1(
    fFillType: u8,
    fIsVolatile: u8
) -> __BindgenBitfieldUnit<[u8; 1], u8>

pub unsafe fn isInterpolatable(&self, compare: *const SkPath) -> bool

pub unsafe fn interpolate(
    &self,
    ending: *const SkPath,
    weight: SkScalar,
    out: *mut SkPath
) -> bool

pub unsafe fn setConvexity(&mut self, convexity: SkPath_Convexity)

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

pub unsafe fn isRRect(&self, rrect: *mut SkRRect) -> bool

pub unsafe fn reset(&mut self) -> *mut SkPath

pub unsafe fn rewind(&mut self) -> *mut SkPath

pub unsafe fn isLastContourClosed(&self) -> bool

pub unsafe fn IsLineDegenerate(
    p1: *const SkPoint,
    p2: *const SkPoint,
    exact: bool
) -> bool

pub unsafe fn IsQuadDegenerate(
    p1: *const SkPoint,
    p2: *const SkPoint,
    p3: *const SkPoint,
    exact: bool
) -> bool

pub unsafe fn IsCubicDegenerate(
    p1: *const SkPoint,
    p2: *const SkPoint,
    p3: *const SkPoint,
    p4: *const SkPoint,
    exact: bool
) -> bool

pub unsafe fn isLine(&self, line: *mut SkPoint) -> bool

pub unsafe fn countPoints(&self) -> c_int

pub unsafe fn getPoint(&self, index: c_int) -> SkPoint

pub unsafe fn getPoints(&self, points: *mut SkPoint, max: c_int) -> c_int

pub unsafe fn countVerbs(&self) -> c_int

pub unsafe fn getVerbs(&self, verbs: *mut u8, max: c_int) -> c_int

pub unsafe fn approximateBytesUsed(&self) -> usize

pub unsafe fn swap(&mut self, other: *mut SkPath)

pub unsafe fn computeTightBounds(&self) -> SkRect

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

pub unsafe fn incReserve(&mut self, extraPtCount: c_int)

pub unsafe fn shrinkToFit(&mut self)

pub unsafe fn moveTo(&mut self, x: SkScalar, y: SkScalar) -> *mut SkPath

pub unsafe fn rMoveTo(&mut self, dx: SkScalar, dy: SkScalar) -> *mut SkPath

pub unsafe fn lineTo(&mut self, x: SkScalar, y: SkScalar) -> *mut SkPath

pub unsafe fn rLineTo(&mut self, dx: SkScalar, dy: SkScalar) -> *mut SkPath

pub unsafe fn quadTo(
    &mut self,
    x1: SkScalar,
    y1: SkScalar,
    x2: SkScalar,
    y2: SkScalar
) -> *mut SkPath

pub unsafe fn rQuadTo(
    &mut self,
    dx1: SkScalar,
    dy1: SkScalar,
    dx2: SkScalar,
    dy2: SkScalar
) -> *mut SkPath

pub unsafe fn conicTo(
    &mut self,
    x1: SkScalar,
    y1: SkScalar,
    x2: SkScalar,
    y2: SkScalar,
    w: SkScalar
) -> *mut SkPath

pub unsafe fn rConicTo(
    &mut self,
    dx1: SkScalar,
    dy1: SkScalar,
    dx2: SkScalar,
    dy2: SkScalar,
    w: SkScalar
) -> *mut SkPath

pub unsafe fn cubicTo(
    &mut self,
    x1: SkScalar,
    y1: SkScalar,
    x2: SkScalar,
    y2: SkScalar,
    x3: SkScalar,
    y3: SkScalar
) -> *mut SkPath

pub unsafe fn rCubicTo(
    &mut self,
    dx1: SkScalar,
    dy1: SkScalar,
    dx2: SkScalar,
    dy2: SkScalar,
    dx3: SkScalar,
    dy3: SkScalar
) -> *mut SkPath

pub unsafe fn arcTo(
    &mut self,
    oval: *const SkRect,
    startAngle: SkScalar,
    sweepAngle: SkScalar,
    forceMoveTo: bool
) -> *mut SkPath

pub unsafe fn arcTo1(
    &mut self,
    x1: SkScalar,
    y1: SkScalar,
    x2: SkScalar,
    y2: SkScalar,
    radius: SkScalar
) -> *mut SkPath

pub unsafe fn arcTo2(
    &mut self,
    rx: SkScalar,
    ry: SkScalar,
    xAxisRotate: SkScalar,
    largeArc: SkPath_ArcSize,
    sweep: SkPath_Direction,
    x: SkScalar,
    y: SkScalar
) -> *mut SkPath

pub unsafe fn rArcTo(
    &mut self,
    rx: SkScalar,
    ry: SkScalar,
    xAxisRotate: SkScalar,
    largeArc: SkPath_ArcSize,
    sweep: SkPath_Direction,
    dx: SkScalar,
    dy: SkScalar
) -> *mut SkPath

pub unsafe fn close(&mut self) -> *mut SkPath

pub unsafe fn ConvertConicToQuads(
    p0: *const SkPoint,
    p1: *const SkPoint,
    p2: *const SkPoint,
    w: SkScalar,
    pts: *mut SkPoint,
    pow2: c_int
) -> c_int

pub unsafe fn isRect(
    &self,
    rect: *mut SkRect,
    isClosed: *mut bool,
    direction: *mut SkPath_Direction
) -> bool

pub unsafe fn isNestedFillRects(
    &self,
    rect: *mut SkRect,
    dirs: *mut SkPath_Direction
) -> bool

pub unsafe fn addRect(
    &mut self,
    rect: *const SkRect,
    dir: SkPath_Direction
) -> *mut SkPath

pub unsafe fn addRect1(
    &mut self,
    rect: *const SkRect,
    dir: SkPath_Direction,
    start: c_uint
) -> *mut SkPath

pub unsafe fn addRect2(
    &mut self,
    left: SkScalar,
    top: SkScalar,
    right: SkScalar,
    bottom: SkScalar,
    dir: SkPath_Direction
) -> *mut SkPath

pub unsafe fn addOval(
    &mut self,
    oval: *const SkRect,
    dir: SkPath_Direction
) -> *mut SkPath

pub unsafe fn addOval1(
    &mut self,
    oval: *const SkRect,
    dir: SkPath_Direction,
    start: c_uint
) -> *mut SkPath

pub unsafe fn addCircle(
    &mut self,
    x: SkScalar,
    y: SkScalar,
    radius: SkScalar,
    dir: SkPath_Direction
) -> *mut SkPath

pub unsafe fn addArc(
    &mut self,
    oval: *const SkRect,
    startAngle: SkScalar,
    sweepAngle: SkScalar
) -> *mut SkPath

pub unsafe fn addRoundRect(
    &mut self,
    rect: *const SkRect,
    rx: SkScalar,
    ry: SkScalar,
    dir: SkPath_Direction
) -> *mut SkPath

pub unsafe fn addRoundRect1(
    &mut self,
    rect: *const SkRect,
    radii: *const SkScalar,
    dir: SkPath_Direction
) -> *mut SkPath

pub unsafe fn addRRect(
    &mut self,
    rrect: *const SkRRect,
    dir: SkPath_Direction
) -> *mut SkPath

pub unsafe fn addRRect1(
    &mut self,
    rrect: *const SkRRect,
    dir: SkPath_Direction,
    start: c_uint
) -> *mut SkPath

pub unsafe fn addPoly(
    &mut self,
    pts: *const SkPoint,
    count: c_int,
    close: bool
) -> *mut SkPath

pub unsafe fn addPath(
    &mut self,
    src: *const SkPath,
    dx: SkScalar,
    dy: SkScalar,
    mode: SkPath_AddPathMode
) -> *mut SkPath

pub unsafe fn addPath1(
    &mut self,
    src: *const SkPath,
    matrix: *const SkMatrix,
    mode: SkPath_AddPathMode
) -> *mut SkPath

pub unsafe fn reverseAddPath(&mut self, src: *const SkPath) -> *mut SkPath

pub unsafe fn offset(&self, dx: SkScalar, dy: SkScalar, dst: *mut SkPath)

pub unsafe fn transform(&self, matrix: *const SkMatrix, dst: *mut SkPath)

pub unsafe fn getLastPt(&self, lastPt: *mut SkPoint) -> bool

pub unsafe fn setLastPt(&mut self, x: SkScalar, y: SkScalar)

pub unsafe fn contains(&self, x: SkScalar, y: SkScalar) -> bool

pub unsafe fn dump(
    &self,
    stream: *mut SkWStream,
    forceClose: bool,
    dumpAsHex: bool
)

pub unsafe fn dump1(&self)

pub unsafe fn dumpHex(&self)

pub unsafe fn writeToMemory(&self, buffer: *mut c_void) -> usize

pub unsafe fn serialize(&self) -> sk_sp<SkData>

pub unsafe fn readFromMemory(
    &mut self,
    buffer: *const c_void,
    length: usize
) -> usize

pub unsafe fn getGenerationID(&self) -> u32

pub unsafe fn new() -> Self

pub unsafe fn new1(path: *const SkPath) -> Self

pub unsafe fn destruct(&mut self)