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_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1]>,
    pub __bindgen_padding_0: u8,
}

Fields

fPathRef: sk_sp<SkPathRef>

fLastMoveToIndex: c_int

fConvexity: u8

fFirstDirection: u8

_bitfield_align_1: [u8; 0]

_bitfield_1: __BindgenBitfieldUnit<[u8; 1]>

__bindgen_padding_0: u8

Implementations

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]>

pub unsafe fn Make( arg1: *const SkPoint, pointCount: c_int, arg2: *const u8, verbCount: c_int, arg3: *const SkScalar, conicWeightCount: c_int, arg4: SkPathFillType, isVolatile: bool ) -> SkPath

pub unsafe fn Rect( arg1: *const SkRect, arg2: SkPathDirection, startIndex: c_uint ) -> SkPath

pub unsafe fn Oval(arg1: *const SkRect, arg2: SkPathDirection) -> SkPath

pub unsafe fn Oval1( arg1: *const SkRect, arg2: SkPathDirection, startIndex: c_uint ) -> SkPath

pub unsafe fn Circle( center_x: SkScalar, center_y: SkScalar, radius: SkScalar, dir: SkPathDirection ) -> SkPath

pub unsafe fn RRect(arg1: *const SkRRect, dir: SkPathDirection) -> SkPath

pub unsafe fn RRect1( arg1: *const SkRRect, arg2: SkPathDirection, startIndex: c_uint ) -> SkPath

pub unsafe fn RRect2( bounds: *const SkRect, rx: SkScalar, ry: SkScalar, dir: SkPathDirection ) -> SkPath

pub unsafe fn Polygon( pts: *const SkPoint, count: c_int, isClosed: bool, arg1: SkPathFillType, isVolatile: bool ) -> SkPath

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 isConvex(&self) -> bool

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 isEmpty(&self) -> bool

pub unsafe fn isLastContourClosed(&self) -> bool

pub unsafe fn isFinite(&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 getBounds(&self) -> *const SkRect

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 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: SkPathDirection, x: SkScalar, y: SkScalar ) -> *mut SkPath

pub unsafe fn rArcTo( &mut self, rx: SkScalar, ry: SkScalar, xAxisRotate: SkScalar, largeArc: SkPath_ArcSize, sweep: SkPathDirection, 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 SkPathDirection ) -> bool

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

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

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

pub unsafe fn addCircle( &mut self, x: SkScalar, y: SkScalar, radius: SkScalar, dir: SkPathDirection ) -> *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: SkPathDirection ) -> *mut SkPath

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

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

pub unsafe fn addRRect1( &mut self, rrect: *const SkRRect, dir: SkPathDirection, 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, pc: SkApplyPerspectiveClip )

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

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

pub unsafe fn getSegmentMasks(&self) -> u32

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

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

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

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 isValid(&self) -> bool

pub unsafe fn new() -> Self

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

pub unsafe fn destruct(&mut self)

Trait Implementations

impl Debug for SkPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.