Mads Marquart
1701 lines
48 KiB
Rust
1701 lines
48 KiB
Rust
// Copyright 2018 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.
|
|
|
|
#![deprecated = "use the objc2-quartz-core crate instead"]
|
|
#![allow(non_upper_case_globals)]
|
|
|
|
use bitflags::bitflags;
|
|
use core_foundation::array::{CFArray, CFArrayRef};
|
|
use core_foundation::base::{CFType, CFTypeRef, TCFType};
|
|
use core_foundation::date::CFTimeInterval;
|
|
use core_foundation::dictionary::{CFDictionary, CFDictionaryRef};
|
|
use core_foundation::string::{CFString, CFStringRef};
|
|
use core_graphics::base::CGFloat;
|
|
use core_graphics::color::{CGColor, SysCGColorRef};
|
|
use core_graphics::color_space::CGColorSpace;
|
|
use core_graphics::context::CGContext;
|
|
use core_graphics::geometry::{CGAffineTransform, CGPoint, CGRect, CGSize};
|
|
use core_graphics::path::{CGPath, SysCGPathRef};
|
|
use foreign_types::ForeignType;
|
|
use objc::{class, msg_send, sel, sel_impl};
|
|
use std::ops::Mul;
|
|
use std::ptr;
|
|
|
|
use crate::appkit::CGLContextObj;
|
|
use crate::base::{id, nil, BOOL, YES};
|
|
use crate::foundation::NSUInteger;
|
|
|
|
// CABase.h
|
|
|
|
pub fn current_media_time() -> CFTimeInterval {
|
|
unsafe { CACurrentMediaTime() }
|
|
}
|
|
|
|
// CALayer.h
|
|
|
|
pub struct CALayer(id);
|
|
|
|
unsafe impl Send for CALayer {}
|
|
unsafe impl Sync for CALayer {}
|
|
|
|
impl Clone for CALayer {
|
|
#[inline]
|
|
fn clone(&self) -> CALayer {
|
|
unsafe { CALayer(msg_send![self.id(), retain]) }
|
|
}
|
|
}
|
|
|
|
impl Drop for CALayer {
|
|
#[inline]
|
|
fn drop(&mut self) {
|
|
unsafe { msg_send![self.id(), release] }
|
|
}
|
|
}
|
|
|
|
impl CALayer {
|
|
#[inline]
|
|
pub fn id(&self) -> id {
|
|
self.0
|
|
}
|
|
|
|
#[inline]
|
|
pub fn new() -> CALayer {
|
|
unsafe {
|
|
let id: id = msg_send![class!(CALayer), layer];
|
|
let _: id = msg_send![id, retain];
|
|
CALayer(id)
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn from_layer(other: &CALayer) -> CALayer {
|
|
unsafe {
|
|
let layer: id = msg_send![class!(CALayer), alloc];
|
|
CALayer(msg_send![layer, initWithLayer:other.id()])
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn presentation_layer(&self) -> CALayer {
|
|
unsafe { CALayer(msg_send![self.id(), presentationLayer]) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn model_layer(&self) -> CALayer {
|
|
unsafe { CALayer(msg_send![self.id(), modelLayer]) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn default_value_for_key(key: &CFString) -> id {
|
|
unsafe { msg_send![class!(CALayer), defaultValueForKey:(key.as_CFTypeRef())] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn needs_display_for_key(key: &CFString) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![class!(CALayer), needsDisplayForKey:(key.as_CFTypeRef())];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn should_archive_value_for_key(key: &CFString) -> bool {
|
|
unsafe {
|
|
let flag: BOOL =
|
|
msg_send![class!(CALayer), shouldArchiveValueForKey:(key.as_CFTypeRef())];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn bounds(&self) -> CGRect {
|
|
unsafe { msg_send![self.id(), bounds] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_bounds(&self, bounds: &CGRect) {
|
|
unsafe { msg_send![self.id(), setBounds:*bounds] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn position(&self) -> CGPoint {
|
|
unsafe { msg_send![self.id(), position] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_position(&self, position: &CGPoint) {
|
|
unsafe { msg_send![self.id(), setPosition:*position] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn z_position(&self) -> CGFloat {
|
|
unsafe { msg_send![self.id(), zPosition] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_z_position(&self, z_position: CGFloat) {
|
|
unsafe { msg_send![self.id(), setZPosition: z_position] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn anchor_point(&self) -> CGPoint {
|
|
unsafe { msg_send![self.id(), anchorPoint] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_anchor_point(&self, anchor_point: &CGPoint) {
|
|
unsafe { msg_send![self.id(), setAnchorPoint:*anchor_point] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn anchor_point_z(&self) -> CGFloat {
|
|
unsafe { msg_send![self.id(), anchorPointZ] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_anchor_point_z(&self, anchor_point_z: CGFloat) {
|
|
unsafe { msg_send![self.id(), setAnchorPointZ: anchor_point_z] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn transform(&self) -> CATransform3D {
|
|
unsafe { msg_send![self.id(), transform] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_transform(&self, transform: &CATransform3D) {
|
|
unsafe { msg_send![self.id(), setTransform:*transform] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn affine_transform(&self) -> CGAffineTransform {
|
|
unsafe { msg_send![self.id(), affineTransform] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_affine_transform(&self, affine_transform: &CGAffineTransform) {
|
|
unsafe { msg_send![self.id(), setAffineTransform:*affine_transform] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn frame(&self) -> CGRect {
|
|
unsafe { msg_send![self.id(), frame] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_frame(&self, frame: &CGRect) {
|
|
unsafe { msg_send![self.id(), setFrame:*frame] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn is_hidden(&self) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![self.id(), isHidden];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_hidden(&self, hidden: bool) {
|
|
unsafe { msg_send![self.id(), setHidden: hidden as BOOL] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn is_double_sided(&self) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![self.id(), isDoubleSided];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_double_sided(&self, double_sided: bool) {
|
|
unsafe { msg_send![self.id(), setDoubleSided: double_sided as BOOL] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn is_geometry_flipped(&self) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![self.id(), isGeometryFlipped];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_geometry_flipped(&self, geometry_flipped: bool) {
|
|
unsafe { msg_send![self.id(), setGeometryFlipped: geometry_flipped as BOOL] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn contents_are_flipped(&self) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![self.id(), contentsAreFlipped];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn superlayer(&self) -> Option<CALayer> {
|
|
unsafe {
|
|
let superlayer: id = msg_send![self.id(), superlayer];
|
|
if superlayer.is_null() {
|
|
None
|
|
} else {
|
|
Some(CALayer(superlayer))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn remove_from_superlayer(&self) {
|
|
unsafe { msg_send![self.id(), removeFromSuperlayer] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn sublayers(&self) -> CFArray<CALayer> {
|
|
unsafe {
|
|
let sublayers: CFArrayRef = msg_send![self.id(), sublayers];
|
|
TCFType::wrap_under_create_rule(sublayers)
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn add_sublayer(&self, sublayer: &CALayer) {
|
|
unsafe { msg_send![self.id(), addSublayer:sublayer.id()] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn insert_sublayer_at_index(&self, sublayer: &CALayer, index: u32) {
|
|
unsafe { msg_send![self.id(), insertSublayer:sublayer.id() atIndex:index] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn insert_sublayer_below(&self, sublayer: &CALayer, sibling: &CALayer) {
|
|
unsafe { msg_send![self.id(), insertSublayer:sublayer.id() below:sibling.id()] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn insert_sublayer_above(&self, sublayer: &CALayer, sibling: &CALayer) {
|
|
unsafe { msg_send![self.id(), insertSublayer:sublayer.id() above:sibling.id()] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn replace_sublayer_with(&self, old_layer: &CALayer, new_layer: &CALayer) {
|
|
unsafe { msg_send![self.id(), replaceSublayer:old_layer.id() with:new_layer.id()] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn sublayer_transform(&self) -> CATransform3D {
|
|
unsafe { msg_send![self.id(), sublayerTransform] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_sublayer_transform(&self, sublayer_transform: CATransform3D) {
|
|
unsafe { msg_send![self.id(), setSublayerTransform: sublayer_transform] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn mask(&self) -> Option<CALayer> {
|
|
unsafe {
|
|
let mask: id = msg_send![self.id(), mask];
|
|
if mask.is_null() {
|
|
None
|
|
} else {
|
|
Some(CALayer(mask))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_mask(&self, mask: Option<CALayer>) {
|
|
unsafe {
|
|
match mask {
|
|
None => msg_send![self.id(), setMask: nil],
|
|
Some(mask) => msg_send![self.id(), setMask:(mask.id())],
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn masks_to_bounds(&self) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![self.id(), masksToBounds];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_masks_to_bounds(&self, flag: bool) {
|
|
unsafe { msg_send![self.id(), setMasksToBounds: flag as BOOL] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn convert_point_from_layer(&self, point: &CGPoint, layer: Option<CALayer>) -> CGPoint {
|
|
unsafe {
|
|
let layer = match layer {
|
|
None => nil,
|
|
Some(ref layer) => layer.id(),
|
|
};
|
|
msg_send![self.id(), convertPoint:*point fromLayer:layer]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn convert_point_to_layer(&self, point: &CGPoint, layer: Option<CALayer>) -> CGPoint {
|
|
unsafe {
|
|
let layer = match layer {
|
|
None => nil,
|
|
Some(ref layer) => layer.id(),
|
|
};
|
|
msg_send![self.id(), convertPoint:*point toLayer:layer]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn convert_rect_from_layer(&self, rect: &CGRect, layer: Option<CALayer>) -> CGRect {
|
|
unsafe {
|
|
let layer = match layer {
|
|
None => nil,
|
|
Some(ref layer) => layer.id(),
|
|
};
|
|
msg_send![self.id(), convertRect:*rect fromLayer:layer]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn convert_rect_to_layer(&self, rect: &CGRect, layer: Option<CALayer>) -> CGRect {
|
|
unsafe {
|
|
let layer = match layer {
|
|
None => nil,
|
|
Some(ref layer) => layer.id(),
|
|
};
|
|
msg_send![self.id(), convertRect:*rect toLayer:layer]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn convert_time_from_layer(
|
|
&self,
|
|
time: CFTimeInterval,
|
|
layer: Option<CALayer>,
|
|
) -> CFTimeInterval {
|
|
unsafe {
|
|
let layer = match layer {
|
|
None => nil,
|
|
Some(ref layer) => layer.id(),
|
|
};
|
|
msg_send![self.id(), convertTime:time fromLayer:layer]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn convert_time_to_layer(
|
|
&self,
|
|
time: CFTimeInterval,
|
|
layer: Option<CALayer>,
|
|
) -> CFTimeInterval {
|
|
unsafe {
|
|
let layer = match layer {
|
|
None => nil,
|
|
Some(ref layer) => layer.id(),
|
|
};
|
|
msg_send![self.id(), convertTime:time toLayer:layer]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn hit_test(&self, point: &CGPoint) -> Option<CALayer> {
|
|
unsafe {
|
|
let layer: id = msg_send![self.id(), hitTest:*point];
|
|
if layer == nil {
|
|
None
|
|
} else {
|
|
Some(CALayer(layer))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn contains_point(&self, point: &CGPoint) -> bool {
|
|
unsafe {
|
|
let result: BOOL = msg_send![self.id(), containsPoint:*point];
|
|
result == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn contents(&self) -> id {
|
|
unsafe { msg_send![self.id(), contents] }
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn set_contents(&self, contents: id) {
|
|
msg_send![self.id(), setContents: contents]
|
|
}
|
|
|
|
#[inline]
|
|
pub fn contents_rect(&self) -> CGRect {
|
|
unsafe { msg_send![self.id(), contentsRect] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_contents_rect(&self, contents_rect: &CGRect) {
|
|
unsafe { msg_send![self.id(), setContentsRect:*contents_rect] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn contents_gravity(&self) -> ContentsGravity {
|
|
unsafe {
|
|
let string: CFStringRef = msg_send![self.id(), contentsGravity];
|
|
ContentsGravity::from_CFString(TCFType::wrap_under_create_rule(string))
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_contents_gravity(&self, new_contents_gravity: ContentsGravity) {
|
|
unsafe {
|
|
let contents_gravity: CFString = new_contents_gravity.into_CFString();
|
|
msg_send![self.id(), setContentsGravity:contents_gravity.as_CFTypeRef()]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn contents_scale(&self) -> CGFloat {
|
|
unsafe { msg_send![self.id(), contentsScale] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_contents_scale(&self, new_contents_scale: CGFloat) {
|
|
unsafe { msg_send![self.id(), setContentsScale: new_contents_scale] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn contents_center(&self) -> CGRect {
|
|
unsafe { msg_send![self.id(), contentsCenter] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_contents_center(&self, new_rect: &CGRect) {
|
|
unsafe { msg_send![self.id(), setContentsCenter:*new_rect] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn contents_format(&self) -> ContentsFormat {
|
|
unsafe {
|
|
let string: CFStringRef = msg_send![self.id(), contentsFormat];
|
|
ContentsFormat::from_CFString(TCFType::wrap_under_create_rule(string))
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_contents_format(&self, new_contents_format: ContentsFormat) {
|
|
unsafe {
|
|
let contents_format: CFString = new_contents_format.into_CFString();
|
|
msg_send![self.id(), setContentsFormat:contents_format.as_CFTypeRef()]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn minification_filter(&self) -> Filter {
|
|
unsafe {
|
|
let string: CFStringRef = msg_send![self.id(), minificationFilter];
|
|
Filter::from_CFString(TCFType::wrap_under_create_rule(string))
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_minification_filter(&self, new_filter: Filter) {
|
|
unsafe {
|
|
let filter: CFString = new_filter.into_CFString();
|
|
msg_send![self.id(), setMinificationFilter:filter.as_CFTypeRef()]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn magnification_filter(&self) -> Filter {
|
|
unsafe {
|
|
let string: CFStringRef = msg_send![self.id(), magnificationFilter];
|
|
Filter::from_CFString(TCFType::wrap_under_create_rule(string))
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_magnification_filter(&self, new_filter: Filter) {
|
|
unsafe {
|
|
let filter: CFString = new_filter.into_CFString();
|
|
msg_send![self.id(), setMagnificationFilter:filter.as_CFTypeRef()]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn minification_filter_bias(&self) -> f32 {
|
|
unsafe { msg_send![self.id(), minificationFilterBias] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_minification_filter_bias(&self, new_filter_bias: f32) {
|
|
unsafe { msg_send![self.id(), setMinificationFilterBias: new_filter_bias] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn is_opaque(&self) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![self.id(), isOpaque];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_opaque(&self, opaque: bool) {
|
|
unsafe { msg_send![self.id(), setOpaque: opaque as BOOL] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn display(&self) {
|
|
unsafe { msg_send![self.id(), display] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_needs_display(&self) {
|
|
unsafe { msg_send![self.id(), setNeedsDisplay] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_needs_display_in_rect(&self, rect: &CGRect) {
|
|
unsafe { msg_send![self.id(), setNeedsDisplayInRect:*rect] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn needs_display(&self) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![self.id(), needsDisplay];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn display_if_needed(&self) {
|
|
unsafe { msg_send![self.id(), displayIfNeeded] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn needs_display_on_bounds_change(&self) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![self.id(), needsDisplayOnBoundsChange];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_needs_display_on_bounds_change(&self, flag: bool) {
|
|
unsafe { msg_send![self.id(), setNeedsDisplayOnBoundsChange: flag as BOOL] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn draws_asynchronously(&self) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![self.id(), drawsAsynchronously];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_draws_asynchronously(&self, flag: bool) {
|
|
unsafe { msg_send![self.id(), setDrawsAsynchronously: flag as BOOL] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn draw_in_context(&self, context: &CGContext) {
|
|
unsafe { msg_send![self.id(), drawInContext:(*context).as_ptr()] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn render_in_context(&self, context: &CGContext) {
|
|
unsafe { msg_send![self.id(), renderInContext:(*context).as_ptr()] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn edge_antialiasing_mask(&self) -> EdgeAntialiasingMask {
|
|
unsafe {
|
|
EdgeAntialiasingMask::from_bits_truncate(msg_send![self.id(), edgeAntialiasingMask])
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_edge_antialiasing_mask(&self, mask: EdgeAntialiasingMask) {
|
|
unsafe { msg_send![self.id(), setEdgeAntialiasingMask:mask.bits()] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn background_color(&self) -> Option<CGColor> {
|
|
unsafe {
|
|
let color: SysCGColorRef = msg_send![self.id(), backgroundColor];
|
|
if color.is_null() {
|
|
None
|
|
} else {
|
|
Some(CGColor::wrap_under_get_rule(color))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_background_color(&self, color: Option<CGColor>) {
|
|
unsafe {
|
|
let color = match color {
|
|
None => ptr::null(),
|
|
Some(color) => color.as_CFTypeRef(),
|
|
};
|
|
msg_send![self.id(), setBackgroundColor: color]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn corner_radius(&self) -> CGFloat {
|
|
unsafe { msg_send![self.id(), cornerRadius] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_corner_radius(&self, radius: CGFloat) {
|
|
unsafe { msg_send![self.id(), setCornerRadius: radius] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn masked_corners(&self) -> CornerMask {
|
|
unsafe { CornerMask::from_bits_truncate(msg_send![self.id(), maskedCorners]) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_masked_corners(&self, mask: CornerMask) {
|
|
unsafe { msg_send![self.id(), setCornerMask:mask.bits()] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn border_width(&self) -> CGFloat {
|
|
unsafe { msg_send![self.id(), borderWidth] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_border_width(&self, border_width: CGFloat) {
|
|
unsafe { msg_send![self.id(), setBorderWidth: border_width] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn border_color(&self) -> Option<CGColor> {
|
|
unsafe {
|
|
let color: SysCGColorRef = msg_send![self.id(), borderColor];
|
|
if color.is_null() {
|
|
None
|
|
} else {
|
|
Some(CGColor::wrap_under_get_rule(color))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_border_color(&self, color: Option<CGColor>) {
|
|
unsafe {
|
|
let color = match color {
|
|
None => ptr::null(),
|
|
Some(color) => color.as_CFTypeRef(),
|
|
};
|
|
msg_send![self.id(), setBorderColor: color]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn opacity(&self) -> f32 {
|
|
unsafe { msg_send![self.id(), opacity] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_opacity(&self, opacity: f32) {
|
|
unsafe { msg_send![self.id(), setOpacity: opacity] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn compositing_filter(&self) -> id {
|
|
unsafe { msg_send![self.id(), compositingFilter] }
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn set_compositing_filter(&self, filter: id) {
|
|
msg_send![self.id(), setCompositingFilter: filter]
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn filters(&self) -> Option<CFArray> {
|
|
let filters: CFArrayRef = msg_send![self.id(), filters];
|
|
if filters.is_null() {
|
|
None
|
|
} else {
|
|
Some(CFArray::wrap_under_get_rule(filters))
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn set_filters(&self, filters: Option<CFArray>) {
|
|
let filters: CFTypeRef = match filters {
|
|
Some(ref filters) => filters.as_CFTypeRef(),
|
|
None => ptr::null(),
|
|
};
|
|
msg_send![self.id(), setFilters: filters]
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn background_filters(&self) -> Option<CFArray> {
|
|
let filters: CFArrayRef = msg_send![self.id(), backgroundFilters];
|
|
if filters.is_null() {
|
|
None
|
|
} else {
|
|
Some(CFArray::wrap_under_get_rule(filters))
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn set_background_filters(&self, filters: Option<CFArray>) {
|
|
let filters: CFTypeRef = match filters {
|
|
Some(ref filters) => filters.as_CFTypeRef(),
|
|
None => ptr::null(),
|
|
};
|
|
msg_send![self.id(), setBackgroundFilters: filters]
|
|
}
|
|
|
|
#[inline]
|
|
pub fn should_rasterize(&self) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![self.id(), shouldRasterize];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_should_rasterize(&self, flag: bool) {
|
|
unsafe { msg_send![self.id(), setShouldRasterize:(flag as BOOL)] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn rasterization_scale(&self) -> CGFloat {
|
|
unsafe { msg_send![self.id(), rasterizationScale] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_rasterization_scale(&self, scale: CGFloat) {
|
|
unsafe { msg_send![self.id(), setRasterizationScale: scale] }
|
|
}
|
|
|
|
// Shadow properties
|
|
|
|
#[inline]
|
|
pub fn shadow_color(&self) -> Option<CGColor> {
|
|
unsafe {
|
|
let color: SysCGColorRef = msg_send![self.id(), shadowColor];
|
|
if color.is_null() {
|
|
None
|
|
} else {
|
|
Some(CGColor::wrap_under_get_rule(color))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_shadow_color(&self, color: Option<CGColor>) {
|
|
unsafe {
|
|
let color = match color {
|
|
None => ptr::null(),
|
|
Some(color) => color.as_CFTypeRef(),
|
|
};
|
|
msg_send![self.id(), setShadowColor: color]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn shadow_opacity(&self) -> f32 {
|
|
unsafe { msg_send![self.id(), shadowOpacity] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_shadow_opacity(&self, opacity: f32) {
|
|
unsafe { msg_send![self.id(), setShadowOpacity: opacity] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn shadow_offset(&self) -> CGSize {
|
|
unsafe { msg_send![self.id(), shadowOffset] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_shadow_offset(&self, offset: &CGSize) {
|
|
unsafe { msg_send![self.id(), setShadowOffset:*offset] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn shadow_radius(&self) -> CGFloat {
|
|
unsafe { msg_send![self.id(), shadowRadius] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_shadow_radius(&self, radius: CGFloat) {
|
|
unsafe { msg_send![self.id(), setShadowRadius: radius] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn shadow_path(&self) -> Option<CGPath> {
|
|
unsafe {
|
|
let path: SysCGPathRef = msg_send![self.id(), shadowPath];
|
|
if path.is_null() {
|
|
None
|
|
} else {
|
|
Some(CGPath::from_ptr(path))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_shadow_path(&self, path: Option<CGPath>) {
|
|
unsafe {
|
|
let sys_path_ref = match path {
|
|
None => ptr::null(),
|
|
Some(path) => path.as_ptr(),
|
|
};
|
|
msg_send![self.id(), setShadowPath: sys_path_ref]
|
|
}
|
|
}
|
|
|
|
// Layout methods
|
|
|
|
#[inline]
|
|
pub fn autoresizing_mask(&self) -> AutoresizingMask {
|
|
unsafe { AutoresizingMask::from_bits_truncate(msg_send![self.id(), autoresizingMask]) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_autoresizing_mask(&self, mask: AutoresizingMask) {
|
|
unsafe { msg_send![self.id(), setAutoresizingMask:mask.bits()] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn layout_manager(&self) -> id {
|
|
unsafe { msg_send![self.id(), layoutManager] }
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn set_layout_manager(&self, manager: id) {
|
|
msg_send![self.id(), setLayoutManager: manager]
|
|
}
|
|
|
|
#[inline]
|
|
pub fn preferred_frame_size(&self) -> CGSize {
|
|
unsafe { msg_send![self.id(), preferredFrameSize] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_needs_layout(&self) {
|
|
unsafe { msg_send![self.id(), setNeedsLayout] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn needs_layout(&self) -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![self.id(), needsLayout];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn layout_if_needed(&self) {
|
|
unsafe { msg_send![self.id(), layoutIfNeeded] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn layout_sublayers(&self) {
|
|
unsafe { msg_send![self.id(), layoutSublayers] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn resize_sublayers_with_old_size(&self, size: &CGSize) {
|
|
unsafe { msg_send![self.id(), resizeSublayersWithOldSize:*size] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn resize_with_old_superlayer_size(&self, size: &CGSize) {
|
|
unsafe { msg_send![self.id(), resizeWithOldSuperlayerSize:*size] }
|
|
}
|
|
|
|
// Action methods
|
|
|
|
#[inline]
|
|
pub fn default_action_for_key(event: &str) -> id {
|
|
unsafe {
|
|
let event: CFString = CFString::from(event);
|
|
msg_send![class!(CALayer), defaultActionForKey:event.as_CFTypeRef()]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn action_for_key(&self, event: &str) -> id {
|
|
unsafe {
|
|
let event: CFString = CFString::from(event);
|
|
msg_send![self.id(), actionForKey:event.as_CFTypeRef()]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn actions(&self) -> CFDictionary<CFStringRef, CFTypeRef> {
|
|
unsafe { CFDictionary::wrap_under_get_rule(msg_send![self.id(), actions]) }
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn set_actions(&self, actions: CFDictionary<CFStringRef, CFTypeRef>) {
|
|
msg_send![self.id(), setActions: actions.as_concrete_TypeRef()]
|
|
}
|
|
|
|
// TODO(pcwalton): Wrap `CAAnimation`.
|
|
#[inline]
|
|
pub unsafe fn add_animation_for_key(&self, animation: id, for_key: Option<&str>) {
|
|
let for_key: Option<CFString> = for_key.map(CFString::from);
|
|
let for_key: CFTypeRef = match for_key {
|
|
Some(ref for_key) => for_key.as_CFTypeRef(),
|
|
None => ptr::null(),
|
|
};
|
|
msg_send![self.id(), addAnimation:animation forKey:for_key]
|
|
}
|
|
|
|
#[inline]
|
|
pub fn remove_all_animation(&self) {
|
|
unsafe { msg_send![self.id(), removeAllAnimations] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn remove_animation_for_key(&self, key: &str) {
|
|
unsafe {
|
|
let key = CFString::from(key);
|
|
msg_send![self.id(), removeAnimationForKey:key.as_CFTypeRef()]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn animation_keys(&self) -> Vec<String> {
|
|
unsafe {
|
|
let keys: CFArrayRef = msg_send![self.id(), animationKeys];
|
|
let keys: CFArray = TCFType::wrap_under_create_rule(keys);
|
|
keys.into_iter()
|
|
.map(|string| CFString::wrap_under_get_rule(*string as CFStringRef).to_string())
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn animation_for_key(&self, key: &str) -> id {
|
|
unsafe {
|
|
let key = CFString::from(key);
|
|
msg_send![self.id(), animationForKey:key.as_CFTypeRef()]
|
|
}
|
|
}
|
|
|
|
// Miscellaneous properties
|
|
|
|
#[inline]
|
|
pub fn name(&self) -> String {
|
|
unsafe {
|
|
let name: CFStringRef = msg_send![self.id(), name];
|
|
CFString::wrap_under_get_rule(name).to_string()
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_name(&self, name: &str) {
|
|
unsafe {
|
|
let name = CFString::from(name);
|
|
msg_send![self.id(), setName:name.as_CFTypeRef()]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn delegate(&self) -> id {
|
|
unsafe { msg_send![self.id(), delegate] }
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn set_delegate(&self, delegate: id) {
|
|
msg_send![self.id(), setDelegate: delegate]
|
|
}
|
|
|
|
#[inline]
|
|
pub fn style(&self) -> Option<CFDictionary> {
|
|
unsafe {
|
|
let dictionary: CFDictionaryRef = msg_send![self.id(), style];
|
|
if dictionary.is_null() {
|
|
None
|
|
} else {
|
|
Some(CFDictionary::wrap_under_get_rule(dictionary))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_style(&self, dictionary: Option<CFDictionary>) {
|
|
unsafe {
|
|
let dictionary = match dictionary {
|
|
None => ptr::null(),
|
|
Some(ref dictionary) => dictionary.as_CFTypeRef(),
|
|
};
|
|
msg_send![self.id(), setStyle: dictionary]
|
|
}
|
|
}
|
|
|
|
// Private methods
|
|
|
|
#[inline]
|
|
pub fn reload_value_for_key_path(&self, key: &str) {
|
|
unsafe {
|
|
let key = CFString::from(key);
|
|
msg_send![self.id(), reloadValueForKeyPath:key.as_CFTypeRef()]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_contents_opaque(&self, opaque: bool) {
|
|
unsafe { msg_send![self.id(), setContentsOpaque: opaque as BOOL] }
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum ContentsGravity {
|
|
Center,
|
|
Top,
|
|
Bottom,
|
|
Left,
|
|
Right,
|
|
TopLeft,
|
|
TopRight,
|
|
BottomLeft,
|
|
BottomRight,
|
|
Resize,
|
|
ResizeAspect,
|
|
ResizeAspectFill,
|
|
Other(CFString),
|
|
}
|
|
|
|
impl ContentsGravity {
|
|
fn into_CFString(self) -> CFString {
|
|
let string = match self {
|
|
ContentsGravity::Center => "center",
|
|
ContentsGravity::Top => "top",
|
|
ContentsGravity::Bottom => "bottom",
|
|
ContentsGravity::Left => "left",
|
|
ContentsGravity::Right => "right",
|
|
ContentsGravity::TopLeft => "topLeft",
|
|
ContentsGravity::TopRight => "topRight",
|
|
ContentsGravity::BottomLeft => "bottomLeft",
|
|
ContentsGravity::BottomRight => "bottomRight",
|
|
ContentsGravity::Resize => "resize",
|
|
ContentsGravity::ResizeAspect => "resizeAspect",
|
|
ContentsGravity::ResizeAspectFill => "resizeAspectFill",
|
|
ContentsGravity::Other(other) => return other,
|
|
};
|
|
CFString::from(string)
|
|
}
|
|
|
|
// FIXME(pcwalton): Inefficient.
|
|
fn from_CFString(string: CFString) -> ContentsGravity {
|
|
match string.to_string() {
|
|
ref s if s == "center" => ContentsGravity::Center,
|
|
ref s if s == "top" => ContentsGravity::Top,
|
|
ref s if s == "bottom" => ContentsGravity::Bottom,
|
|
ref s if s == "left" => ContentsGravity::Left,
|
|
ref s if s == "right" => ContentsGravity::Right,
|
|
ref s if s == "topLeft" => ContentsGravity::TopLeft,
|
|
ref s if s == "topRight" => ContentsGravity::TopRight,
|
|
ref s if s == "bottomLeft" => ContentsGravity::BottomLeft,
|
|
ref s if s == "bottomRight" => ContentsGravity::BottomRight,
|
|
ref s if s == "resize" => ContentsGravity::Resize,
|
|
ref s if s == "resizeAspect" => ContentsGravity::ResizeAspect,
|
|
ref s if s == "resizeAspectFill" => ContentsGravity::ResizeAspectFill,
|
|
_ => ContentsGravity::Other(string),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum ContentsFormat {
|
|
RGBA8Uint, // kCAContentsFormatRGBA8Uint, "RGBA"
|
|
RGBA16Float, // kCAContentsFormatRGBA16Float, "RGBAh"
|
|
Gray8Uint, // kCAContentsFormatGray8Uint, "Gray8"
|
|
Other(CFString),
|
|
}
|
|
|
|
impl ContentsFormat {
|
|
fn into_CFString(self) -> CFString {
|
|
let string = match self {
|
|
ContentsFormat::RGBA8Uint => "RGBA8",
|
|
ContentsFormat::RGBA16Float => "RGBAh",
|
|
ContentsFormat::Gray8Uint => "Gray8",
|
|
ContentsFormat::Other(other) => return other,
|
|
};
|
|
CFString::from(string)
|
|
}
|
|
|
|
// FIXME(pcwalton): Inefficient.
|
|
fn from_CFString(string: CFString) -> ContentsFormat {
|
|
match string.to_string() {
|
|
ref s if s == "RGBA8" => ContentsFormat::RGBA8Uint,
|
|
ref s if s == "RGBAh" => ContentsFormat::RGBA16Float,
|
|
ref s if s == "Gray8" => ContentsFormat::Gray8Uint,
|
|
_ => ContentsFormat::Other(string),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum Filter {
|
|
Nearest,
|
|
Linear,
|
|
Trilinear,
|
|
Other(CFString),
|
|
}
|
|
|
|
impl Filter {
|
|
fn into_CFString(self) -> CFString {
|
|
let string = match self {
|
|
Filter::Nearest => "nearest",
|
|
Filter::Linear => "linear",
|
|
Filter::Trilinear => "trilinear",
|
|
Filter::Other(other) => return other,
|
|
};
|
|
CFString::from(string)
|
|
}
|
|
|
|
// FIXME(pcwalton): Inefficient.
|
|
fn from_CFString(string: CFString) -> Filter {
|
|
match string.to_string() {
|
|
ref s if s == "nearest" => Filter::Nearest,
|
|
ref s if s == "linear" => Filter::Linear,
|
|
ref s if s == "trilinear" => Filter::Trilinear,
|
|
_ => Filter::Other(string),
|
|
}
|
|
}
|
|
}
|
|
|
|
bitflags! {
|
|
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
|
pub struct EdgeAntialiasingMask: u32 {
|
|
const LEFT_EDGE = 1 << 0; // kCALayerLeftEdge
|
|
const RIGHT_EDGE = 1 << 1; // kCALayerRightEdge
|
|
const BOTTOM_EDGE = 1 << 2; // kCALayerBottomEdge
|
|
const TOP_EDGE = 1 << 3; // kCALayerTopEdge
|
|
}
|
|
}
|
|
|
|
bitflags! {
|
|
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
|
pub struct CornerMask: NSUInteger {
|
|
const MIN_X_MIN_Y_CORNER = 1 << 0; // kCALayerMinXMinYCorner
|
|
const MAX_X_MIN_Y_CORNER = 1 << 1; // kCALayerMaxXMinYCorner
|
|
const MIN_X_MAX_Y_CORNER = 1 << 2; // kCALayerMinXMaxYCorner
|
|
const MAX_X_MAX_Y_CORNER = 1 << 3; // kCALayerMaxXMaxYCorner
|
|
}
|
|
}
|
|
|
|
bitflags! {
|
|
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
|
pub struct AutoresizingMask: u32 {
|
|
const NOT_SIZABLE = 0; // kCALayerNotSizable
|
|
const MIN_X_MARGIN = 1 << 0; // kCALayerMinXMargin
|
|
const WIDTH_SIZABLE = 1 << 1; // kCALayerWidthSizable
|
|
const MAX_X_MARGIN = 1 << 2; // kCALayerMaxXMargin
|
|
const MIN_Y_MARGIN = 1 << 3; // kCALayerMinYMargin
|
|
const HEIGHT_SIZABLE = 1 << 4; // kCALayerHeightSizable
|
|
const MAX_Y_MARGIN = 1 << 5; // kCALayerMaxYMargin
|
|
}
|
|
}
|
|
|
|
// CARenderer.h
|
|
|
|
pub struct CARenderer(id);
|
|
|
|
unsafe impl Send for CARenderer {}
|
|
unsafe impl Sync for CARenderer {}
|
|
|
|
impl Clone for CARenderer {
|
|
#[inline]
|
|
fn clone(&self) -> CARenderer {
|
|
unsafe { CARenderer(msg_send![self.id(), retain]) }
|
|
}
|
|
}
|
|
|
|
impl Drop for CARenderer {
|
|
#[inline]
|
|
fn drop(&mut self) {
|
|
unsafe { msg_send![self.id(), release] }
|
|
}
|
|
}
|
|
|
|
impl CARenderer {
|
|
#[inline]
|
|
pub fn id(&self) -> id {
|
|
self.0
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn from_cgl_context(
|
|
context: CGLContextObj,
|
|
color_space: Option<CGColorSpace>,
|
|
) -> CARenderer {
|
|
let mut pairs: Vec<(CFString, CFType)> = vec![];
|
|
if let Some(color_space) = color_space {
|
|
pairs.push((
|
|
CFString::wrap_under_get_rule(kCARendererColorSpace),
|
|
CFType::wrap_under_get_rule(color_space.as_ptr() as *const _ as *const _),
|
|
))
|
|
}
|
|
|
|
let options: CFDictionary<CFString, CFType> = CFDictionary::from_CFType_pairs(&pairs);
|
|
|
|
let renderer: id = msg_send![class!(CARenderer), rendererWithCGLContext:context
|
|
options:options.as_CFTypeRef()];
|
|
debug_assert!(renderer != nil);
|
|
CARenderer(renderer)
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn from_metal_texture(
|
|
metal_texture: id,
|
|
metal_command_queue: id,
|
|
color_space: Option<CGColorSpace>,
|
|
) -> CARenderer {
|
|
let mut pairs: Vec<(CFString, CFType)> = vec![(
|
|
CFString::wrap_under_get_rule(kCARendererMetalCommandQueue),
|
|
CFType::wrap_under_get_rule(metal_command_queue as *const _ as *const _),
|
|
)];
|
|
if let Some(color_space) = color_space {
|
|
pairs.push((
|
|
CFString::wrap_under_get_rule(kCARendererColorSpace),
|
|
CFType::wrap_under_get_rule(color_space.as_ptr() as *const _ as *const _),
|
|
))
|
|
}
|
|
|
|
let options: CFDictionary<CFString, CFType> = CFDictionary::from_CFType_pairs(&pairs);
|
|
|
|
let renderer: id = msg_send![class!(CARenderer), rendererWithMTLTexture:metal_texture
|
|
options:options.as_CFTypeRef()];
|
|
debug_assert!(renderer != nil);
|
|
CARenderer(renderer)
|
|
}
|
|
|
|
#[inline]
|
|
pub fn layer(&self) -> Option<CALayer> {
|
|
unsafe {
|
|
let layer: id = msg_send![self.id(), layer];
|
|
if layer.is_null() {
|
|
None
|
|
} else {
|
|
Some(CALayer(layer))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_layer(&self, layer: Option<CALayer>) {
|
|
unsafe {
|
|
let layer = match layer {
|
|
Some(ref layer) => layer.id(),
|
|
None => nil,
|
|
};
|
|
msg_send![self.id(), setLayer: layer]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn bounds(&self) -> CGRect {
|
|
unsafe { msg_send![self.id(), bounds] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_bounds(&self, bounds: CGRect) {
|
|
unsafe { msg_send![self.id(), setBounds: bounds] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn begin_frame_at(&self, time: CFTimeInterval, timestamp: Option<&CVTimeStamp>) {
|
|
unsafe { msg_send![self.id(), beginFrameAtTime:time timeStamp:timestamp] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn update_bounds(&self) -> CGRect {
|
|
unsafe { msg_send![self.id(), updateBounds] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn add_update_rect(&self, rect: CGRect) {
|
|
unsafe { msg_send![self.id(), addUpdateRect: rect] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn render(&self) {
|
|
unsafe { msg_send![self.id(), render] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn next_frame_time(&self) -> CFTimeInterval {
|
|
unsafe { msg_send![self.id(), nextFrameTime] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn end_frame(&self) {
|
|
unsafe { msg_send![self.id(), endFrame] }
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn set_destination(&self, metal_texture: id) {
|
|
msg_send![self.id(), setDestination: metal_texture]
|
|
}
|
|
}
|
|
|
|
// CATransaction.h
|
|
|
|
// You can't actually construct any `CATransaction` objects, so that class is
|
|
// really just a module.
|
|
pub mod transaction {
|
|
use block::{Block, ConcreteBlock, IntoConcreteBlock, RcBlock};
|
|
use core_foundation::base::TCFType;
|
|
use core_foundation::date::CFTimeInterval;
|
|
use core_foundation::string::CFString;
|
|
use objc::{class, msg_send, sel, sel_impl};
|
|
|
|
use crate::base::{id, BOOL, YES};
|
|
|
|
#[inline]
|
|
pub fn begin() {
|
|
unsafe { msg_send![class!(CATransaction), begin] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn commit() {
|
|
unsafe { msg_send![class!(CATransaction), commit] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn flush() {
|
|
unsafe { msg_send![class!(CATransaction), flush] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn lock() {
|
|
unsafe { msg_send![class!(CATransaction), lock] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn unlock() {
|
|
unsafe { msg_send![class!(CATransaction), unlock] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn animation_duration() -> CFTimeInterval {
|
|
unsafe { msg_send![class!(CATransaction), animationDuration] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_animation_duration(duration: CFTimeInterval) {
|
|
unsafe { msg_send![class!(CATransaction), setAnimationDuration: duration] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn animation_timing_function() -> id {
|
|
unsafe { msg_send![class!(CATransaction), animationTimingFunction] }
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn set_animation_timing_function(function: id) {
|
|
msg_send![class!(CATransaction), setAnimationTimingFunction: function]
|
|
}
|
|
|
|
#[inline]
|
|
pub fn disable_actions() -> bool {
|
|
unsafe {
|
|
let flag: BOOL = msg_send![class!(CATransaction), disableActions];
|
|
flag == YES
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_disable_actions(flag: bool) {
|
|
unsafe { msg_send![class!(CATransaction), setDisableActions: flag as BOOL] }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn completion_block() -> Option<RcBlock<(), ()>> {
|
|
unsafe {
|
|
let completion_block: *mut Block<(), ()> =
|
|
msg_send![class!(CATransaction), completionBlock];
|
|
if completion_block.is_null() {
|
|
None
|
|
} else {
|
|
Some(RcBlock::new(completion_block))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_completion_block<F>(block: ConcreteBlock<(), (), F>)
|
|
where
|
|
F: 'static + IntoConcreteBlock<(), Ret = ()>,
|
|
{
|
|
unsafe {
|
|
let block = block.copy();
|
|
msg_send![class!(CATransaction), setCompletionBlock:&*block]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn value_for_key(key: &str) -> id {
|
|
unsafe {
|
|
let key: CFString = CFString::from(key);
|
|
msg_send![class!(CATransaction), valueForKey: key.as_concrete_TypeRef()]
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_value_for_key(value: id, key: &str) {
|
|
unsafe {
|
|
let key: CFString = CFString::from(key);
|
|
msg_send![class!(CATransaction), setValue: value forKey: key.as_concrete_TypeRef()]
|
|
}
|
|
}
|
|
}
|
|
|
|
// CATransform3D.h
|
|
|
|
#[repr(C)]
|
|
#[derive(Clone, Copy)]
|
|
pub struct CATransform3D {
|
|
pub m11: CGFloat,
|
|
pub m12: CGFloat,
|
|
pub m13: CGFloat,
|
|
pub m14: CGFloat,
|
|
pub m21: CGFloat,
|
|
pub m22: CGFloat,
|
|
pub m23: CGFloat,
|
|
pub m24: CGFloat,
|
|
pub m31: CGFloat,
|
|
pub m32: CGFloat,
|
|
pub m33: CGFloat,
|
|
pub m34: CGFloat,
|
|
pub m41: CGFloat,
|
|
pub m42: CGFloat,
|
|
pub m43: CGFloat,
|
|
pub m44: CGFloat,
|
|
}
|
|
|
|
impl PartialEq for CATransform3D {
|
|
#[inline]
|
|
fn eq(&self, other: &CATransform3D) -> bool {
|
|
unsafe { CATransform3DEqualToTransform(*self, *other) }
|
|
}
|
|
}
|
|
|
|
impl Mul<CATransform3D> for CATransform3D {
|
|
type Output = CATransform3D;
|
|
|
|
#[inline]
|
|
fn mul(self, other: CATransform3D) -> CATransform3D {
|
|
unsafe { CATransform3DConcat(self, other) }
|
|
}
|
|
}
|
|
|
|
impl CATransform3D {
|
|
pub const IDENTITY: CATransform3D = CATransform3D {
|
|
m11: 1.0,
|
|
m12: 0.0,
|
|
m13: 0.0,
|
|
m14: 0.0,
|
|
m21: 0.0,
|
|
m22: 1.0,
|
|
m23: 0.0,
|
|
m24: 0.0,
|
|
m31: 0.0,
|
|
m32: 0.0,
|
|
m33: 1.0,
|
|
m34: 0.0,
|
|
m41: 0.0,
|
|
m42: 0.0,
|
|
m43: 0.0,
|
|
m44: 1.0,
|
|
};
|
|
|
|
#[inline]
|
|
pub fn from_translation(tx: CGFloat, ty: CGFloat, tz: CGFloat) -> CATransform3D {
|
|
unsafe { CATransform3DMakeTranslation(tx, ty, tz) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn from_scale(sx: CGFloat, sy: CGFloat, sz: CGFloat) -> CATransform3D {
|
|
unsafe { CATransform3DMakeScale(sx, sy, sz) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn from_rotation(angle: CGFloat, x: CGFloat, y: CGFloat, z: CGFloat) -> CATransform3D {
|
|
unsafe { CATransform3DMakeRotation(angle, x, y, z) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn affine(affine_transform: CGAffineTransform) -> CATransform3D {
|
|
unsafe { CATransform3DMakeAffineTransform(affine_transform) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn is_identity(&self) -> bool {
|
|
unsafe { CATransform3DIsIdentity(*self) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn translate(&self, tx: CGFloat, ty: CGFloat, tz: CGFloat) -> CATransform3D {
|
|
unsafe { CATransform3DTranslate(*self, tx, ty, tz) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn scale(&self, sx: CGFloat, sy: CGFloat, sz: CGFloat) -> CATransform3D {
|
|
unsafe { CATransform3DScale(*self, sx, sy, sz) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn rotate(&self, angle: CGFloat, x: CGFloat, y: CGFloat, z: CGFloat) -> CATransform3D {
|
|
unsafe { CATransform3DRotate(*self, angle, x, y, z) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn invert(&self) -> CATransform3D {
|
|
unsafe { CATransform3DInvert(*self) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn is_affine(&self) -> bool {
|
|
unsafe { CATransform3DIsAffine(*self) }
|
|
}
|
|
|
|
#[inline]
|
|
pub fn to_affine(&self) -> CGAffineTransform {
|
|
unsafe { CATransform3DGetAffineTransform(*self) }
|
|
}
|
|
}
|
|
|
|
#[cfg_attr(feature = "link", link(name = "QuartzCore", kind = "framework"))]
|
|
extern "C" {
|
|
static kCARendererColorSpace: CFStringRef;
|
|
static kCARendererMetalCommandQueue: CFStringRef;
|
|
|
|
fn CACurrentMediaTime() -> CFTimeInterval;
|
|
|
|
fn CATransform3DIsIdentity(t: CATransform3D) -> bool;
|
|
fn CATransform3DEqualToTransform(a: CATransform3D, b: CATransform3D) -> bool;
|
|
fn CATransform3DMakeTranslation(tx: CGFloat, ty: CGFloat, tz: CGFloat) -> CATransform3D;
|
|
fn CATransform3DMakeScale(sx: CGFloat, sy: CGFloat, sz: CGFloat) -> CATransform3D;
|
|
fn CATransform3DMakeRotation(
|
|
angle: CGFloat,
|
|
x: CGFloat,
|
|
y: CGFloat,
|
|
z: CGFloat,
|
|
) -> CATransform3D;
|
|
fn CATransform3DTranslate(
|
|
t: CATransform3D,
|
|
tx: CGFloat,
|
|
ty: CGFloat,
|
|
tz: CGFloat,
|
|
) -> CATransform3D;
|
|
fn CATransform3DScale(t: CATransform3D, sx: CGFloat, sy: CGFloat, sz: CGFloat)
|
|
-> CATransform3D;
|
|
fn CATransform3DRotate(
|
|
t: CATransform3D,
|
|
angle: CGFloat,
|
|
x: CGFloat,
|
|
y: CGFloat,
|
|
z: CGFloat,
|
|
) -> CATransform3D;
|
|
fn CATransform3DConcat(a: CATransform3D, b: CATransform3D) -> CATransform3D;
|
|
fn CATransform3DInvert(t: CATransform3D) -> CATransform3D;
|
|
fn CATransform3DMakeAffineTransform(m: CGAffineTransform) -> CATransform3D;
|
|
fn CATransform3DIsAffine(t: CATransform3D) -> bool;
|
|
fn CATransform3DGetAffineTransform(t: CATransform3D) -> CGAffineTransform;
|
|
}
|
|
|
|
// Miscellaneous structures in other frameworks.
|
|
//
|
|
// These should be moved elsewhere eventually.
|
|
|
|
// CoreVideo/CVBase.h
|
|
|
|
#[repr(C)]
|
|
#[derive(Clone, Copy)]
|
|
pub struct CVTimeStamp {
|
|
pub version: u32,
|
|
pub videoTimeScale: i32,
|
|
pub videoTime: i64,
|
|
pub hostTime: u64,
|
|
pub rateScalar: f64,
|
|
pub videoRefreshPeriod: i64,
|
|
pub smpteTime: CVSMPTETime,
|
|
pub flags: u64,
|
|
pub reserved: u64,
|
|
}
|
|
|
|
pub type CVTimeStampFlags = u64;
|
|
|
|
pub const kCVTimeStampVideoTimeValid: CVTimeStampFlags = 1 << 0;
|
|
pub const kCVTimeStampHostTimeValid: CVTimeStampFlags = 1 << 1;
|
|
pub const kCVTimeStampSMPTETimeValid: CVTimeStampFlags = 1 << 2;
|
|
pub const kCVTimeStampVideoRefreshPeriodValid: CVTimeStampFlags = 1 << 3;
|
|
pub const kCVTimeStampRateScalarValid: CVTimeStampFlags = 1 << 4;
|
|
pub const kCVTimeStampTopField: CVTimeStampFlags = 1 << 16;
|
|
pub const kCVTimeStampBottomField: CVTimeStampFlags = 1 << 17;
|
|
pub const kCVTimeStampVideoHostTimeValid: CVTimeStampFlags =
|
|
kCVTimeStampVideoTimeValid | kCVTimeStampHostTimeValid;
|
|
pub const kCVTimeStampIsInterlaced: CVTimeStampFlags =
|
|
kCVTimeStampTopField | kCVTimeStampBottomField;
|
|
|
|
#[repr(C)]
|
|
#[derive(Clone, Copy)]
|
|
pub struct CVSMPTETime {
|
|
pub subframes: i16,
|
|
pub subframeDivisor: i16,
|
|
pub counter: u32,
|
|
pub time_type: u32,
|
|
pub flags: u32,
|
|
pub hours: i16,
|
|
pub minutes: i16,
|
|
pub seconds: i16,
|
|
pub frames: i16,
|
|
}
|
|
|
|
pub type CVSMPTETimeType = u32;
|
|
|
|
pub const kCVSMPTETimeType24: CVSMPTETimeType = 0;
|
|
pub const kCVSMPTETimeType25: CVSMPTETimeType = 1;
|
|
pub const kCVSMPTETimeType30Drop: CVSMPTETimeType = 2;
|
|
pub const kCVSMPTETimeType30: CVSMPTETimeType = 3;
|
|
pub const kCVSMPTETimeType2997: CVSMPTETimeType = 4;
|
|
pub const kCVSMPTETimeType2997Drop: CVSMPTETimeType = 5;
|
|
pub const kCVSMPTETimeType60: CVSMPTETimeType = 6;
|
|
pub const kCVSMPTETimeType5994: CVSMPTETimeType = 7;
|
|
|
|
pub type CVSMPTETimeFlags = u32;
|
|
|
|
pub const kCVSMPTETimeValid: CVSMPTETimeFlags = 1 << 0;
|
|
pub const kCVSMPTETimeRunning: CVSMPTETimeFlags = 1 << 1;
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::CALayer;
|
|
|
|
#[test]
|
|
fn create_calayer() {
|
|
objc::rc::autoreleasepool(|| {
|
|
let _ = CALayer::new();
|
|
});
|
|
}
|
|
}
|