129 lines
3.9 KiB
Rust
129 lines
3.9 KiB
Rust
// Copyright 2017 The Servo Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
pub use sys::CGPathRef as SysCGPathRef;
|
|
|
|
use core_foundation::base::{CFRelease, CFRetain, CFTypeID};
|
|
use foreign_types::ForeignType;
|
|
use geometry::{CGAffineTransform, CGPoint, CGRect};
|
|
use libc::c_void;
|
|
use std::fmt::{self, Debug, Formatter};
|
|
use std::marker::PhantomData;
|
|
use std::ops::Deref;
|
|
use std::ptr;
|
|
use std::slice;
|
|
|
|
foreign_type! {
|
|
#[doc(hidden)]
|
|
type CType = ::sys::CGPath;
|
|
fn drop = |p| CFRelease(p as *mut _);
|
|
fn clone = |p| CFRetain(p as *const _) as *mut _;
|
|
pub struct CGPath;
|
|
pub struct CGPathRef;
|
|
}
|
|
|
|
impl CGPath {
|
|
pub fn from_rect(rect: CGRect, transform: Option<&CGAffineTransform>) -> CGPath {
|
|
unsafe {
|
|
let transform = match transform {
|
|
None => ptr::null(),
|
|
Some(transform) => transform as *const CGAffineTransform,
|
|
};
|
|
CGPath(CGPathCreateWithRect(rect, transform))
|
|
}
|
|
}
|
|
|
|
pub fn type_id() -> CFTypeID {
|
|
unsafe {
|
|
CGPathGetTypeID()
|
|
}
|
|
}
|
|
|
|
pub fn apply<'a, F>(&'a self, mut closure: &'a F) where F: FnMut(CGPathElementRef<'a>) {
|
|
unsafe {
|
|
CGPathApply(self.as_ptr(), &mut closure as *mut _ as *mut c_void, do_apply::<F>);
|
|
}
|
|
|
|
unsafe extern "C" fn do_apply<'a, F>(info: *mut c_void, element: *const CGPathElement)
|
|
where F: FnMut(CGPathElementRef<'a>) {
|
|
let closure = info as *mut *mut F;
|
|
(**closure)(CGPathElementRef::new(element))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[repr(i32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CGPathElementType {
|
|
MoveToPoint = 0,
|
|
AddLineToPoint = 1,
|
|
AddQuadCurveToPoint = 2,
|
|
AddCurveToPoint = 3,
|
|
CloseSubpath = 4,
|
|
}
|
|
|
|
pub struct CGPathElementRef<'a> {
|
|
element: *const CGPathElement,
|
|
phantom: PhantomData<&'a CGPathElement>,
|
|
}
|
|
|
|
impl<'a> CGPathElementRef<'a> {
|
|
fn new<'b>(element: *const CGPathElement) -> CGPathElementRef<'b> {
|
|
CGPathElementRef {
|
|
element: element,
|
|
phantom: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> Deref for CGPathElementRef<'a> {
|
|
type Target = CGPathElement;
|
|
fn deref(&self) -> &CGPathElement {
|
|
unsafe {
|
|
&*self.element
|
|
}
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct CGPathElement {
|
|
pub element_type: CGPathElementType,
|
|
points: *mut CGPoint,
|
|
}
|
|
|
|
impl Debug for CGPathElement {
|
|
fn fmt(&self, formatter: &mut Formatter) -> Result<(), fmt::Error> {
|
|
write!(formatter, "{:?}: {:?}", self.element_type, self.points())
|
|
}
|
|
}
|
|
|
|
impl CGPathElement {
|
|
pub fn points(&self) -> &[CGPoint] {
|
|
unsafe {
|
|
match self.element_type {
|
|
CGPathElementType::CloseSubpath => &[],
|
|
CGPathElementType::MoveToPoint | CGPathElementType::AddLineToPoint => {
|
|
slice::from_raw_parts(self.points, 1)
|
|
}
|
|
CGPathElementType::AddQuadCurveToPoint => slice::from_raw_parts(self.points, 2),
|
|
CGPathElementType::AddCurveToPoint => slice::from_raw_parts(self.points, 3),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
type CGPathApplierFunction = unsafe extern "C" fn(info: *mut c_void,
|
|
element: *const CGPathElement);
|
|
|
|
#[link(name = "CoreGraphics", kind = "framework")]
|
|
extern {
|
|
fn CGPathCreateWithRect(rect: CGRect, transform: *const CGAffineTransform) -> ::sys::CGPathRef;
|
|
fn CGPathApply(path: ::sys::CGPathRef, info: *mut c_void, function: CGPathApplierFunction);
|
|
fn CGPathGetTypeID() -> CFTypeID;
|
|
}
|