bigmountainstudio

1. The Layer Tree

Core Animation's original name is Layer Kit

Core Animation is a compositing engine; its job is to compose different pieces of visual content on the screen, and to do so as fast as possible. The content in question is divided into individual layers stored in a hierarchy known as the layer tree. This tree forms the underpinning for all of UIKit, and for everything that you see on the screen in an iOS application.

In UIView, tasks such as rendering, layout and animation are all managed by a Core Animation class called CALayer. The only major feature of UIView that isn’t handled by CALayer is user interaction.

There are four hierarchies, each performing a different role:

• view hierarchy
• layer tree

kevyworks

"use strict";

/**
 * @param {typeof import("./commander").Command} program Commander Instance
 */
module.exports = function(program) {
	return program
		.command("greet [name]")
		.description("A greet command.")
		.action((name) => {

jeromecoupe

"use strict";

// Load plugins
const autoprefixer = require("autoprefixer");
const browsersync = require("browser-sync").create();
const cp = require("child_process");
const cssnano = require("cssnano");
const del = require("del");
const eslint = require("gulp-eslint");
const gulp = require("gulp");

joshbernfeld

extension CMTime: Codable {
    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        
        self.value = try container.decode(CMTimeValue.self, forKey: .value)
        self.timescale = try container.decode(CMTimeScale.self, forKey: .timescale)
        self.flags = CMTimeFlags(rawValue: try container.decode(UInt32.self, forKey: .flags))
        self.epoch = try container.decode(CMTimeEpoch.self, forKey: .epoch)
    }

mminer

import AppKit

extension NSImage {

    /// Copies this image to a new one with a circular mask.
    func oval() -> NSImage {
        let image = NSImage(size: size)
        image.lockFocus()

        NSGraphicsContext.current?.imageInterpolation = .high

brennanMKE

func processSampleBuffer(scale: Float, sampleBuffer: CMSampleBuffer, writerInput: AVAssetWriterInput) -> Bool {
    guard let blockBuffer = CMSampleBufferGetDataBuffer(sampleBuffer) else {
        return false
    }
    let length = CMBlockBufferGetDataLength(blockBuffer)
    var sampleBytes = UnsafeMutablePointer<Int16>.allocate(capacity: length)
    defer { sampleBytes.deallocate(capacity: length) }
    
    guard checkStatus(CMBlockBufferCopyDataBytes(blockBuffer, 0, length, sampleBytes), message: "Copying block buffer") else {
        return false

lattner

Async/Await for Swift

• Proposal: SE-XXXX
• Authors: Chris Lattner, Joe Groff

Introduction

Modern Cocoa development involves a lot of asynchronous programming using closures and completion handlers, but these APIs are hard to use. This gets particularly problematic when many asynchronous operations are used, error handling is required, or control flow between asynchronous calls gets complicated. This proposal describes a language extension to make this a lot more natural and less error prone.

This paper introduces a first class Coroutine model to Swift. Functions can opt into to being async, allowing the programmer to compose complex logic involving asynchronous operations, leaving the compiler in charge of producing the necessary closures and state machines to implement that logic.

k06a

#import <AVFoundation/AVFoundation.h>

@interface MLWAsyncAVPlayer : AVPlayer

@end

basememara

import Foundation
import PlaygroundSupport

/// A thread-safe array.
public class SynchronizedArray<Element> {
    private let queue = DispatchQueue(label: "io.zamzam.ZamzamKit.SynchronizedArray", attributes: .concurrent)
    private var array = [Element]()
    
    public init() { }
    

Sorix

//  Created by Vasily Ulianov on 09.02.17, updated in 2019.
//  License: MIT

import Foundation

/// Subclass of `Operation` that adds support of asynchronous operations.
/// 1. Call `super.main()` when override `main` method.
/// 2. When operation is finished or cancelled set `state = .finished` or `finish()`
open class AsynchronousOperation: Operation {
    public override var isAsynchronous: Bool {