Vendor things

third-party/vendor/core-graphics/src/path.rs

@@ -0,0 +1,129 @@
+// 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;
+}