Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 790 insertions, 0 deletions

diff --git a/third_party/rust/core-graphics/src/context.rs b/third_party/rust/core-graphics/src/context.rs
new file mode 100644
index 0000000000..aca5fb74d5
--- /dev/null
+++ b/third_party/rust/core-graphics/src/context.rs
@@ -0,0 +1,790 @@
+// Copyright 2015 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.
+
+use base::CGFloat;
+use color_space::CGColorSpace;
+use core_foundation::base::{CFTypeID, TCFType};
+use font::{CGFont, CGGlyph};
+use geometry::{CGPoint, CGSize};
+use gradient::{CGGradient, CGGradientDrawingOptions};
+use color::CGColor;
+use path::CGPathRef;
+use libc::{c_int, size_t};
+use std::os::raw::c_void;
+
+use std::cmp;
+use std::ptr;
+use std::slice;
+use geometry::{CGAffineTransform, CGRect};
+use image::CGImage;
+use foreign_types::{ForeignType, ForeignTypeRef};
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub enum CGBlendMode {
+    Normal = 0,
+    Multiply,
+    Screen,
+    Overlay,
+    Darken,
+    Lighten,
+    ColorDodge,
+    ColorBurn,
+    SoftLight,
+    HardLight,
+    Difference,
+    Exclusion,
+    Hue,
+    Saturation,
+    Color,
+    Luminosity,
+    // 10.5 and up:
+    Clear,
+    Copy,
+    SourceIn,
+    SourceOut,
+    SourceAtop,
+    DestinationOver,
+    DestinationIn,
+    DestinationOut,
+    DestinationAtop,
+    Xor,
+    PlusDarker,
+    PlusLighter,
+}
+
+#[repr(C)]
+pub enum CGTextDrawingMode {
+    CGTextFill,
+    CGTextStroke,
+    CGTextFillStroke,
+    CGTextInvisible,
+    CGTextFillClip,
+    CGTextStrokeClip,
+    CGTextFillStrokeClip,
+    CGTextClip
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub enum CGLineCap {
+    CGLineCapButt,
+    CGLineCapRound,
+    CGLineCapSquare,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub enum CGLineJoin {
+    CGLineJoinMiter,
+    CGLineJoinRound,
+    CGLineJoinBevel,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub enum CGPathDrawingMode {
+    CGPathFill,
+    CGPathEOFill,
+    CGPathStroke,
+    CGPathFillStroke,
+    CGPathEOFillStroke,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub enum CGInterpolationQuality {
+    CGInterpolationQualityDefault,
+    CGInterpolationQualityNone,
+    CGInterpolationQualityLow,
+    CGInterpolationQualityMedium,
+    CGInterpolationQualityHigh,
+}
+
+foreign_type! {
+    #[doc(hidden)]
+    pub unsafe type CGContext {
+        type CType = ::sys::CGContext;
+        fn drop = |cs| CGContextRelease(cs);
+        fn clone = |p| CGContextRetain(p);
+    }
+}
+
+impl CGContext {
+    pub fn type_id() -> CFTypeID {
+        unsafe {
+            CGContextGetTypeID()
+        }
+    }
+
+    /// Creates a `CGContext` instance from an existing [`CGContextRef`] pointer. 
+    /// 
+    /// This funtion will internally call [`CGRetain`] and hence there is no need to call it explicitly.
+    /// 
+    /// This function is particularly useful for cases when the context is not instantiated/managed
+    /// by the caller, but it's retrieve via other means (e.g., by calling the method [`NSGraphicsContext::CGContext`]
+    /// in a cocoa application).
+    /// 
+    /// [`CGContextRef`]: https://developer.apple.com/documentation/coregraphics/cgcontextref
+    /// [`CGRetain`]: https://developer.apple.com/documentation/coregraphics/1586506-cgcontextretain
+    /// [`NSGraphicsContext::CGContext`]: https://developer.apple.com/documentation/appkit/nsgraphicscontext/1535352-currentcontext
+    pub unsafe fn from_existing_context_ptr(ctx: *mut ::sys::CGContext) -> CGContext {
+        CGContextRetain(ctx);
+        Self::from_ptr(ctx)
+    }
+
+    pub fn create_bitmap_context(data: Option<*mut c_void>,
+                                 width: size_t,
+                                 height: size_t,
+                                 bits_per_component: size_t,
+                                 bytes_per_row: size_t,
+                                 space: &CGColorSpace,
+                                 bitmap_info: u32)
+                                 -> CGContext {
+        unsafe {
+            let result = CGBitmapContextCreate(data.unwrap_or(ptr::null_mut()),
+                                               width,
+                                               height,
+                                               bits_per_component,
+                                               bytes_per_row,
+                                               space.as_ptr(),
+                                               bitmap_info);
+            assert!(!result.is_null());
+            Self::from_ptr(result)
+        }
+    }
+
+    pub fn data(&mut self) -> &mut [u8] {
+        unsafe {
+            slice::from_raw_parts_mut(
+                    CGBitmapContextGetData(self.as_ptr()) as *mut u8,
+                    (self.height() * self.bytes_per_row()) as usize)
+        }
+    }
+}
+
+impl CGContextRef {
+    pub fn flush(&self) {
+        unsafe {
+            CGContextFlush(self.as_ptr())
+        }
+    }
+
+    pub fn width(&self) -> size_t {
+        unsafe {
+            CGBitmapContextGetWidth(self.as_ptr())
+        }
+    }
+
+    pub fn height(&self) -> size_t {
+        unsafe {
+            CGBitmapContextGetHeight(self.as_ptr())
+        }
+    }
+
+    pub fn bytes_per_row(&self) -> size_t {
+        unsafe {
+            CGBitmapContextGetBytesPerRow(self.as_ptr())
+        }
+    }
+
+    pub fn clip_bounding_box(&self) -> CGRect {
+        unsafe {
+            CGContextGetClipBoundingBox(self.as_ptr())
+        }
+    }
+
+    pub fn set_fill_color(&self, color: &CGColor) {
+        unsafe {
+            CGContextSetFillColorWithColor(self.as_ptr(), color.as_concrete_TypeRef());
+        }
+    }
+
+    pub fn set_rgb_fill_color(&self, red: CGFloat, green: CGFloat, blue: CGFloat, alpha: CGFloat) {
+        unsafe {
+            CGContextSetRGBFillColor(self.as_ptr(), red, green, blue, alpha)
+        }
+    }
+
+    pub fn set_rgb_stroke_color(&self, red: CGFloat, green: CGFloat, blue: CGFloat, alpha: CGFloat) {
+        unsafe {
+            CGContextSetRGBStrokeColor(self.as_ptr(), red, green, blue, alpha)
+        }
+    }
+
+    pub fn set_gray_fill_color(&self, gray: CGFloat, alpha: CGFloat) {
+        unsafe {
+            CGContextSetGrayFillColor(self.as_ptr(), gray, alpha)
+        }
+    }
+
+    pub fn set_blend_mode(&self, blend_mode: CGBlendMode) {
+        unsafe {
+            CGContextSetBlendMode(self.as_ptr(), blend_mode)
+        }
+    }
+
+    pub fn set_allows_font_smoothing(&self, allows_font_smoothing: bool) {
+        unsafe {
+            CGContextSetAllowsFontSmoothing(self.as_ptr(), allows_font_smoothing)
+        }
+    }
+
+    pub fn set_font_smoothing_style(&self, style: i32) {
+        unsafe {
+            CGContextSetFontSmoothingStyle(self.as_ptr(), style as _);
+        }
+    }
+
+    pub fn set_should_smooth_fonts(&self, should_smooth_fonts: bool) {
+        unsafe {
+            CGContextSetShouldSmoothFonts(self.as_ptr(), should_smooth_fonts)
+        }
+    }
+
+    pub fn set_allows_antialiasing(&self, allows_antialiasing: bool) {
+        unsafe {
+            CGContextSetAllowsAntialiasing(self.as_ptr(), allows_antialiasing)
+        }
+    }
+
+    pub fn set_should_antialias(&self, should_antialias: bool) {
+        unsafe {
+            CGContextSetShouldAntialias(self.as_ptr(), should_antialias)
+        }
+    }
+
+    pub fn set_allows_font_subpixel_quantization(&self, allows_font_subpixel_quantization: bool) {
+        unsafe {
+            CGContextSetAllowsFontSubpixelQuantization(self.as_ptr(), allows_font_subpixel_quantization)
+        }
+    }
+
+    pub fn set_should_subpixel_quantize_fonts(&self, should_subpixel_quantize_fonts: bool) {
+        unsafe {
+            CGContextSetShouldSubpixelQuantizeFonts(self.as_ptr(), should_subpixel_quantize_fonts)
+        }
+    }
+
+    pub fn set_allows_font_subpixel_positioning(&self, allows_font_subpixel_positioning: bool) {
+        unsafe {
+            CGContextSetAllowsFontSubpixelPositioning(self.as_ptr(), allows_font_subpixel_positioning)
+        }
+    }
+
+    pub fn set_should_subpixel_position_fonts(&self, should_subpixel_position_fonts: bool) {
+        unsafe {
+            CGContextSetShouldSubpixelPositionFonts(self.as_ptr(), should_subpixel_position_fonts)
+        }
+    }
+
+    pub fn set_text_drawing_mode(&self, mode: CGTextDrawingMode) {
+        unsafe {
+            CGContextSetTextDrawingMode(self.as_ptr(), mode)
+        }
+    }
+
+    pub fn set_line_cap(&self, cap: CGLineCap) {
+        unsafe {
+            CGContextSetLineCap(self.as_ptr(), cap)
+        }
+    }
+
+    pub fn set_line_dash(&self, phase: CGFloat, lengths: &[CGFloat]) {
+        unsafe {
+            CGContextSetLineDash(self.as_ptr(), phase, lengths.as_ptr(), lengths.len())
+        }
+    }
+
+    pub fn set_line_join(&self, join: CGLineJoin) {
+        unsafe {
+            CGContextSetLineJoin(self.as_ptr(), join)
+        }
+    }
+
+    pub fn set_line_width(&self, width: CGFloat) {
+        unsafe {
+            CGContextSetLineWidth(self.as_ptr(), width)
+        }
+    }
+
+    pub fn set_miter_limit(&self, limit: CGFloat) {
+        unsafe {
+            CGContextSetMiterLimit(self.as_ptr(), limit)
+        }
+    }
+
+    pub fn add_path(&self, path: &CGPathRef) {
+        unsafe {
+            CGContextAddPath(self.as_ptr(), path.as_ptr());
+        }
+    }
+
+    pub fn add_curve_to_point(&self,
+                              cp1x: CGFloat,
+                              cp1y: CGFloat,
+                              cp2x: CGFloat,
+                              cp2y: CGFloat,
+                              x: CGFloat,
+                              y: CGFloat) {
+        unsafe {
+            CGContextAddCurveToPoint(self.as_ptr(),
+                                     cp1x, cp1y,
+                                     cp2x, cp2y,
+                                     x, y);
+        }
+    }
+
+    pub fn add_quad_curve_to_point(&self,
+                                   cpx: CGFloat,
+                                   cpy: CGFloat,
+                                   x: CGFloat,
+                                   y: CGFloat) {
+        unsafe {
+            CGContextAddQuadCurveToPoint(self.as_ptr(),
+                                         cpx, cpy,
+                                         x, y);
+        }
+    }
+
+    pub fn add_line_to_point(&self, x: CGFloat, y: CGFloat) {
+        unsafe {
+            CGContextAddLineToPoint(self.as_ptr(), x, y);
+        }
+    }
+
+    pub fn begin_path(&self) {
+         unsafe {
+            CGContextBeginPath(self.as_ptr());
+        }
+    }
+
+    pub fn close_path(&self) {
+        unsafe {
+            CGContextClosePath(self.as_ptr());
+        }
+    }
+
+    pub fn move_to_point(&self, x: CGFloat, y: CGFloat) {
+        unsafe {
+            CGContextMoveToPoint(self.as_ptr(), x, y);
+        }
+    }
+
+    pub fn clip(&self) {
+        unsafe {
+            CGContextClip(self.as_ptr());
+        }
+    }
+
+    pub fn eo_clip(&self) {
+        unsafe {
+            CGContextEOClip(self.as_ptr());
+        }
+    }
+
+    pub fn reset_clip(&self) {
+        unsafe {
+            CGContextResetClip(self.as_ptr());
+        }
+    }
+
+    pub fn draw_path(&self, mode: CGPathDrawingMode) {
+        unsafe {
+            CGContextDrawPath(self.as_ptr(), mode);
+        }
+    }
+
+    pub fn fill_path(&self) {
+        unsafe {
+            CGContextFillPath(self.as_ptr());
+        }
+    }
+
+    pub fn eo_fill_path(&self) {
+        unsafe {
+            CGContextEOFillPath(self.as_ptr());
+        }
+    }
+
+    pub fn stroke_path(&self) {
+        unsafe {
+            CGContextStrokePath(self.as_ptr());
+        }
+    }
+
+    pub fn fill_rect(&self, rect: CGRect) {
+        unsafe {
+            CGContextFillRect(self.as_ptr(), rect)
+        }
+    }
+
+    pub fn fill_rects(&self, rects: &[CGRect]) {
+        unsafe {
+            CGContextFillRects(self.as_ptr(), rects.as_ptr(), rects.len())
+        }
+    }
+
+    pub fn clear_rect(&self, rect: CGRect) {
+        unsafe {
+            CGContextClearRect(self.as_ptr(), rect)
+        }
+    }
+
+    pub fn stroke_rect(&self, rect: CGRect) {
+        unsafe {
+            CGContextStrokeRect(self.as_ptr(), rect)
+        }
+    }
+
+    pub fn stroke_rect_with_width(&self, rect: CGRect, width: CGFloat) {
+        unsafe {
+            CGContextStrokeRectWithWidth(self.as_ptr(), rect, width)
+        }
+    }
+
+    pub fn clip_to_rect(&self, rect: CGRect) {
+        unsafe {
+            CGContextClipToRect(self.as_ptr(), rect)
+        }
+    }
+
+    pub fn clip_to_rects(&self, rects: &[CGRect]) {
+        unsafe {
+            CGContextClipToRects(self.as_ptr(), rects.as_ptr(), rects.len())
+        }
+    }
+
+    pub fn clip_to_mask(&self, rect: CGRect, image: &CGImage) {
+        unsafe {
+            CGContextClipToMask(self.as_ptr(), rect, image.as_ptr())
+        }
+    }
+
+    pub fn replace_path_with_stroked_path(&self) {
+        unsafe {
+            CGContextReplacePathWithStrokedPath(self.as_ptr())
+        }
+    }
+
+    pub fn fill_ellipse_in_rect(&self, rect: CGRect) {
+        unsafe {
+            CGContextFillEllipseInRect(self.as_ptr(), rect)
+        }
+    }
+
+    pub fn stroke_ellipse_in_rect(&self, rect: CGRect) {
+        unsafe {
+            CGContextStrokeEllipseInRect(self.as_ptr(), rect)
+        }
+    }
+
+    pub fn stroke_line_segments(&self, points: &[CGPoint]) {
+        unsafe {
+            CGContextStrokeLineSegments(self.as_ptr(), points.as_ptr(), points.len())
+        }
+    }
+
+    pub fn set_interpolation_quality(&self, quality: CGInterpolationQuality) {
+        unsafe {
+            CGContextSetInterpolationQuality(self.as_ptr(), quality);
+        }
+    }
+
+    pub fn get_interpolation_quality(&self) -> CGInterpolationQuality {
+        unsafe {
+            CGContextGetInterpolationQuality(self.as_ptr())
+
+        }
+    }
+
+    pub fn draw_image(&self, rect: CGRect, image: &CGImage) {
+        unsafe {
+            CGContextDrawImage(self.as_ptr(), rect, image.as_ptr());
+        }
+    }
+
+    pub fn create_image(&self) -> Option<CGImage> {
+        let image = unsafe { CGBitmapContextCreateImage(self.as_ptr()) };
+        if !image.is_null() {
+            Some(unsafe { CGImage::from_ptr(image) })
+        } else {
+            None
+        }
+    }
+
+    pub fn set_font(&self, font: &CGFont) {
+        unsafe {
+            CGContextSetFont(self.as_ptr(), font.as_ptr())
+        }
+    }
+
+    pub fn set_font_size(&self, size: CGFloat) {
+        unsafe {
+            CGContextSetFontSize(self.as_ptr(), size)
+        }
+    }
+
+    pub fn set_text_matrix(&self, t: &CGAffineTransform) {
+        unsafe {
+            CGContextSetTextMatrix(self.as_ptr(), *t)
+        }
+    }
+
+    pub fn set_text_position(&self, x: CGFloat, y: CGFloat) {
+        unsafe {
+            CGContextSetTextPosition(self.as_ptr(), x, y)
+        }
+    }
+
+    pub fn show_glyphs_at_positions(&self, glyphs: &[CGGlyph], positions: &[CGPoint]) {
+        unsafe {
+            let count = cmp::min(glyphs.len(), positions.len());
+            CGContextShowGlyphsAtPositions(self.as_ptr(),
+                                           glyphs.as_ptr(),
+                                           positions.as_ptr(),
+                                           count)
+        }
+    }
+
+    pub fn save(&self) {
+        unsafe {
+            CGContextSaveGState(self.as_ptr());
+        }
+    }
+
+    pub fn restore(&self) {
+        unsafe {
+            CGContextRestoreGState(self.as_ptr());
+        }
+    }
+
+    pub fn translate(&self, tx: CGFloat, ty: CGFloat) {
+        unsafe {
+            CGContextTranslateCTM(self.as_ptr(), tx, ty);
+        }
+    }
+
+    pub fn scale(&self, sx: CGFloat, sy: CGFloat) {
+        unsafe {
+            CGContextScaleCTM(self.as_ptr(), sx, sy);
+        }
+    }
+
+    pub fn rotate(&self, angle: CGFloat) {
+        unsafe {
+            CGContextRotateCTM(self.as_ptr(), angle);
+        }
+    }
+
+    pub fn get_ctm(&self) -> CGAffineTransform {
+        unsafe {
+            CGContextGetCTM(self.as_ptr())
+        }
+    }
+
+    pub fn concat_ctm(&self, transform: CGAffineTransform) {
+        unsafe {
+            CGContextConcatCTM(self.as_ptr(), transform)
+        }
+    }
+
+    pub fn draw_linear_gradient(&self, gradient: &CGGradient, start_point: CGPoint, end_point: CGPoint, options: CGGradientDrawingOptions) {
+        unsafe {
+            CGContextDrawLinearGradient(self.as_ptr(), gradient.as_ptr(), start_point, end_point, options);
+        }
+    }
+
+    pub fn draw_radial_gradient(&self, gradient: &CGGradient, start_center: CGPoint, start_radius: CGFloat, end_center: CGPoint, end_radius: CGFloat, options: CGGradientDrawingOptions) {
+        unsafe {
+            CGContextDrawRadialGradient(self.as_ptr(), gradient.as_ptr(), start_center, start_radius, end_center, end_radius, options);
+        }
+    }
+
+    pub fn set_shadow(&self, offset: CGSize, blur: CGFloat) {
+        unsafe {
+            CGContextSetShadow(self.as_ptr(), offset, blur);
+        }
+    }
+
+    pub fn set_shadow_with_color(&self, offset: CGSize, blur: CGFloat, color: &CGColor) {
+        unsafe {
+            CGContextSetShadowWithColor(self.as_ptr(), offset, blur, color.as_concrete_TypeRef());
+        }
+    }
+
+    pub fn set_alpha(&self, alpha: CGFloat) {
+        unsafe {
+            CGContextSetAlpha(self.as_ptr(), alpha);
+        }
+    }
+}
+
+#[test]
+fn create_bitmap_context_test() {
+    use geometry::*;
+
+    let cs = CGColorSpace::create_device_rgb();
+    let ctx = CGContext::create_bitmap_context(None,
+                                16, 8,
+                                8, 0,
+                                &cs,
+                                ::base::kCGImageAlphaPremultipliedLast);
+    ctx.set_rgb_fill_color(1.,0.,1.,1.);
+    ctx.set_miter_limit(4.);
+    ctx.fill_rect(CGRect::new(&CGPoint::new(0.,0.), &CGSize::new(8.,8.)));
+    let img = ctx.create_image().unwrap();
+    assert_eq!(16, img.width());
+    assert_eq!(8, img.height());
+    assert_eq!(8, img.bits_per_component());
+    assert_eq!(32, img.bits_per_pixel());
+    let data = img.data();
+    assert_eq!(255, data.bytes()[0]);
+    assert_eq!(0, data.bytes()[1]);
+    assert_eq!(255, data.bytes()[2]);
+    assert_eq!(255, data.bytes()[3]);
+}
+
+#[link(name = "CoreGraphics", kind = "framework")]
+extern {
+    fn CGContextRetain(c: ::sys::CGContextRef) -> ::sys::CGContextRef;
+    fn CGContextRelease(c: ::sys::CGContextRef);
+
+    fn CGBitmapContextCreate(data: *mut c_void,
+                             width: size_t,
+                             height: size_t,
+                             bitsPerComponent: size_t,
+                             bytesPerRow: size_t,
+                             space: ::sys::CGColorSpaceRef,
+                             bitmapInfo: u32)
+                             -> ::sys::CGContextRef;
+    fn CGBitmapContextGetData(context: ::sys::CGContextRef) -> *mut c_void;
+    fn CGBitmapContextGetWidth(context: ::sys::CGContextRef) -> size_t;
+    fn CGBitmapContextGetHeight(context: ::sys::CGContextRef) -> size_t;
+    fn CGBitmapContextGetBytesPerRow(context: ::sys::CGContextRef) -> size_t;
+    fn CGBitmapContextCreateImage(context: ::sys::CGContextRef) -> ::sys::CGImageRef;
+    fn CGContextGetTypeID() -> CFTypeID;
+    fn CGContextGetClipBoundingBox(c: ::sys::CGContextRef) -> CGRect;
+    fn CGContextFlush(c: ::sys::CGContextRef);
+    fn CGContextSetBlendMode(c: ::sys::CGContextRef, blendMode: CGBlendMode);
+    fn CGContextSetAllowsFontSmoothing(c: ::sys::CGContextRef, allowsFontSmoothing: bool);
+    fn CGContextSetShouldSmoothFonts(c: ::sys::CGContextRef, shouldSmoothFonts: bool);
+    fn CGContextSetFontSmoothingStyle(c: ::sys::CGContextRef, style: c_int);
+    fn CGContextSetAllowsAntialiasing(c: ::sys::CGContextRef, allowsAntialiasing: bool);
+    fn CGContextSetShouldAntialias(c: ::sys::CGContextRef, shouldAntialias: bool);
+    fn CGContextSetAllowsFontSubpixelQuantization(c: ::sys::CGContextRef,
+                                                  allowsFontSubpixelQuantization: bool);
+    fn CGContextSetShouldSubpixelQuantizeFonts(c: ::sys::CGContextRef,
+                                               shouldSubpixelQuantizeFonts: bool);
+    fn CGContextSetAllowsFontSubpixelPositioning(c: ::sys::CGContextRef,
+                                                 allowsFontSubpixelPositioning: bool);
+    fn CGContextSetShouldSubpixelPositionFonts(c: ::sys::CGContextRef,
+                                               shouldSubpixelPositionFonts: bool);
+    fn CGContextSetTextDrawingMode(c: ::sys::CGContextRef, mode: CGTextDrawingMode);
+    fn CGContextSetFillColorWithColor(c: ::sys::CGContextRef, color: ::sys::CGColorRef);
+    fn CGContextSetLineCap(c: ::sys::CGContextRef, cap: CGLineCap);
+    fn CGContextSetLineDash(c: ::sys::CGContextRef, phase: CGFloat, lengths: *const CGFloat, count: size_t);
+    fn CGContextSetLineJoin(c: ::sys::CGContextRef, join: CGLineJoin);
+    fn CGContextSetLineWidth(c: ::sys::CGContextRef, width: CGFloat);
+    fn CGContextSetMiterLimit(c: ::sys::CGContextRef, limit: CGFloat);
+
+    fn CGContextAddPath(c: ::sys::CGContextRef, path: ::sys::CGPathRef);
+    fn CGContextAddCurveToPoint(c: ::sys::CGContextRef,
+                                cp1x: CGFloat,
+                                cp1y: CGFloat,
+                                cp2x: CGFloat,
+                                cp2y: CGFloat,
+                                x: CGFloat,
+                                y: CGFloat);
+    fn CGContextAddQuadCurveToPoint(c: ::sys::CGContextRef,
+                                    cpx: CGFloat,
+                                    cpy: CGFloat,
+                                    x: CGFloat,
+                                    y: CGFloat);
+    fn CGContextAddLineToPoint(c: ::sys::CGContextRef,
+                               x: CGFloat,
+                               y: CGFloat);
+    fn CGContextBeginPath(c: ::sys::CGContextRef);
+    fn CGContextClosePath(c: ::sys::CGContextRef);
+    fn CGContextMoveToPoint(c: ::sys::CGContextRef,
+                            x: CGFloat,
+                            y: CGFloat);
+    fn CGContextDrawPath(c: ::sys::CGContextRef, mode: CGPathDrawingMode);
+    fn CGContextFillPath(c: ::sys::CGContextRef);
+    fn CGContextEOFillPath(c: ::sys::CGContextRef);
+    fn CGContextClip(c: ::sys::CGContextRef);
+    fn CGContextEOClip(c: ::sys::CGContextRef);
+    fn CGContextResetClip(c: ::sys::CGContextRef);
+    fn CGContextStrokePath(c: ::sys::CGContextRef);
+    fn CGContextSetRGBFillColor(context: ::sys::CGContextRef,
+                                red: CGFloat,
+                                green: CGFloat,
+                                blue: CGFloat,
+                                alpha: CGFloat);
+    fn CGContextSetRGBStrokeColor(context: ::sys::CGContextRef,
+                                  red: CGFloat,
+                                  green: CGFloat,
+                                  blue: CGFloat,
+                                  alpha: CGFloat);
+    fn CGContextSetGrayFillColor(context: ::sys::CGContextRef, gray: CGFloat, alpha: CGFloat);
+    fn CGContextClearRect(context: ::sys::CGContextRef,
+                          rect: CGRect);
+    fn CGContextFillRect(context: ::sys::CGContextRef,
+                         rect: CGRect);
+    fn CGContextFillRects(context: ::sys::CGContextRef,
+                          rects: *const CGRect,
+                          count: size_t);
+    fn CGContextStrokeRect(context: ::sys::CGContextRef,
+                           rect: CGRect);
+    fn CGContextStrokeRectWithWidth(context: ::sys::CGContextRef,
+                                    rect: CGRect,
+                                    width: CGFloat);
+    fn CGContextClipToRect(context: ::sys::CGContextRef,
+                           rect: CGRect);
+    fn CGContextClipToRects(context: ::sys::CGContextRef,
+                            rects: *const CGRect,
+                            count: size_t);
+    fn CGContextClipToMask(ctx: ::sys::CGContextRef, rect: CGRect, mask: ::sys::CGImageRef);
+    fn CGContextReplacePathWithStrokedPath(context: ::sys::CGContextRef);
+    fn CGContextFillEllipseInRect(context: ::sys::CGContextRef,
+                                  rect: CGRect);
+    fn CGContextStrokeEllipseInRect(context: ::sys::CGContextRef,
+                                    rect: CGRect);
+    fn CGContextStrokeLineSegments(context: ::sys::CGContextRef,
+                                    points: *const CGPoint,
+                                    count: size_t);
+    fn CGContextDrawImage(c: ::sys::CGContextRef, rect: CGRect, image: ::sys::CGImageRef);
+    fn CGContextSetInterpolationQuality(c: ::sys::CGContextRef, quality: CGInterpolationQuality);
+    fn CGContextGetInterpolationQuality(c: ::sys::CGContextRef) -> CGInterpolationQuality;
+    fn CGContextSetFont(c: ::sys::CGContextRef, font: ::sys::CGFontRef);
+    fn CGContextSetFontSize(c: ::sys::CGContextRef, size: CGFloat);
+    fn CGContextSetTextMatrix(c: ::sys::CGContextRef, t: CGAffineTransform);
+    fn CGContextSetTextPosition(c: ::sys::CGContextRef, x: CGFloat, y: CGFloat);
+    fn CGContextShowGlyphsAtPositions(c: ::sys::CGContextRef,
+                                      glyphs: *const CGGlyph,
+                                      positions: *const CGPoint,
+                                      count: size_t);
+
+    fn CGContextSaveGState(c: ::sys::CGContextRef);
+    fn CGContextRestoreGState(c: ::sys::CGContextRef);
+    fn CGContextTranslateCTM(c: ::sys::CGContextRef, tx: CGFloat, ty: CGFloat);
+    fn CGContextScaleCTM(c: ::sys::CGContextRef, sx: CGFloat, sy: CGFloat);
+    fn CGContextRotateCTM(c: ::sys::CGContextRef, angle: CGFloat);
+    fn CGContextGetCTM(c: ::sys::CGContextRef) -> CGAffineTransform;
+    fn CGContextConcatCTM(c: ::sys::CGContextRef, transform: CGAffineTransform);
+
+    fn CGContextDrawLinearGradient(c: ::sys::CGContextRef, gradient: ::sys::CGGradientRef, startPoint: CGPoint, endPoint: CGPoint, options: CGGradientDrawingOptions);
+    fn CGContextDrawRadialGradient(c: ::sys::CGContextRef, gradient: ::sys::CGGradientRef,  startCenter: CGPoint, startRadius: CGFloat, endCenter:CGPoint, endRadius:CGFloat, options: CGGradientDrawingOptions);
+
+    fn CGContextSetShadow(c: ::sys::CGContextRef, offset: CGSize, blur: CGFloat);
+    fn CGContextSetShadowWithColor(c: ::sys::CGContextRef, offset: CGSize, blur: CGFloat, color: ::sys::CGColorRef);
+
+    fn CGContextSetAlpha(c: ::sys::CGContextRef, alpha: CGFloat);
+}
+