Constraints.swift

//
//  Constraints.swift
//  ConstraintsTest
//
//  Created by Joshua Weinberg on 6/6/14.
//  Copyright (c) 2014 Joshua Weinberg. All rights reserved.
//

import UIKit

operator prefix |- {}
operator postfix -| {}
operator infix ~ {}

func ~(left: Double, right: Int) -> LayoutMargin {
    return LayoutMargin(left, right)
}

@prefix func |-(view: UIView) -> LayoutContext {
    return (|-LayoutContext(view))
}

@prefix func |-(ctx: LayoutContext) -> LayoutContext {
    return (|-8-ctx)
}

@postfix func -|(view: UIView) -> LayoutContext {
    return (LayoutContext(view)-|)
}

@postfix func -|(ctx: LayoutContext) -> LayoutContext {
    return (ctx-8-|)
}

@postfix func -|(margin: Double) -> LayoutStub {
    return ((margin~1000)-|)
}

@prefix func |-(margin: Double) -> LayoutStub {
    return (|-(margin~1000))
}

@postfix func -|(margin: LayoutMargin) -> LayoutStub {
    return LayoutStub(margin, LayoutContext(nil))
}

@prefix func |-(margin: LayoutMargin) -> LayoutStub {
    return LayoutStub(margin, LayoutContext(nil))
}

func -(left: LayoutMargin, right: UIView) -> LayoutStub {
    return left - LayoutContext(right)
}

func -(left: UIView, right: LayoutMargin) -> LayoutStub {
    return LayoutContext(left) - right
}

func -(left: LayoutMargin, right: LayoutContext) -> LayoutStub {
    return LayoutStub(left, right)
}

func -(left: LayoutContext, right: LayoutMargin) -> LayoutStub {
    return LayoutStub(right, left)
}

func -(left: UIView, right: UIView) -> LayoutContext {
    return LayoutContext(left) - LayoutContext(right)
}

func -(left: UIView, right: LayoutContext) -> LayoutContext {
    return LayoutContext(left) - right
}

func -(left: LayoutContext, right: UIView) -> LayoutContext {
    return left - LayoutContext(right)
}

func -(left: Double, right: UIView) -> LayoutStub {
    return ((left~1000)-LayoutContext(right))
}

func -(left: UIView, right: Double) -> LayoutStub {
    return (LayoutContext(left)-(right~1000))
}

func -(left: Double, right: LayoutContext) -> LayoutStub {
    return ((left~UILayoutPriorityRequired) - right)
}

func -(left: LayoutContext, right: Double) -> LayoutStub {
    return (left - (right~UILayoutPriorityRequired))
}

func -(left: LayoutStub, right: UIView) -> LayoutContext {
    return (left - LayoutContext(right))
}

func -(left: UIView, right: LayoutStub) -> LayoutContext {
    return (LayoutContext(left) - right)
}

func -(left: LayoutContext, right: LayoutContext) -> LayoutContext {
    return left-8-right
}

func -(left: LayoutStub, right: LayoutContext) -> LayoutContext {
    var c = LayoutContext(left.context, right)
    
    var constraint: ConstraintDescriptor
    
    if let bindingView = left.context.rightView {
        constraint = ConstraintDescriptor(item: bindingView, attribute: .Right, relatedBy: .Equal, toItem:right.leftView, attribute: .Left, multiplier: 1.0, constant: -left.margin.margin)
    } else {
        constraint = ConstraintDescriptor(item: right.leftView, attribute: .Left, relatedBy: .Equal, toItem:right.leftView?.superview, attribute: .Left, multiplier: 1.0, constant: left.margin.margin)
    }
    
    constraint.priority = left.margin.priority
    
    c.constraints.append(constraint)
    return c
}

func -(left: LayoutContext, right: LayoutStub) -> LayoutContext {
    var c = LayoutContext(left, right.context)
    
    var constraint: ConstraintDescriptor
    
    if let bindingView = right.context.leftView {
        constraint = ConstraintDescriptor(item: left.rightView, attribute: .Right, relatedBy: .Equal, toItem:bindingView, attribute: .Left, multiplier: 1.0, constant: -right.margin.margin)
    } else {
        constraint = ConstraintDescriptor(item: left.rightView, attribute: .Right, relatedBy: .Equal, toItem:left.rightView?.superview, attribute: .Right, multiplier: 1.0, constant: -right.margin.margin)
    }
    
    constraint.priority = right.margin.priority
    
    c.constraints.append(constraint)
    return c
}

func H(contex: LayoutContext) -> NSLayoutConstraint[] {
    var constraints = NSLayoutConstraint[]()
    for constraint in contex.constraints {
        constraints.append(constraint.toConstraint(.Horizontal))
    }
    return constraints
}

func V(contex: LayoutContext) -> NSLayoutConstraint[] {
    var constraints = NSLayoutConstraint[]()
    for constraint in contex.constraints {
        constraints.append(constraint.toConstraint(.Vertical))
    }
    return constraints
}

ConstraintTypes.swift

//
//  ConstraintTypes.swift
//  ConstraintsTest
//
//  Created by Joshua Weinberg on 6/8/14.
//  Copyright (c) 2014 Joshua Weinberg. All rights reserved.
//

import UIKit

struct ConstraintDescriptor {
    enum ConstraintSide {
        case Left
        case Right
        
        func toAttribute(axis: UILayoutConstraintAxis) -> NSLayoutAttribute {
            switch (axis) {
            case .Horizontal:
                switch (self) {
                case .Left:
                    return .Left
                case .Right:
                    return .Right
                }
            case .Vertical:
                switch (self) {
                case .Left:
                    return .Top
                case .Right:
                    return .Bottom
                }
                
            }
            
        }
    }
    
    let multiplier: Double
    let constant: Double
    let toView: UIView?
    let fromView: UIView?
    let relation: NSLayoutRelation
    let fromAttribute: ConstraintSide
    let toAttribute: ConstraintSide
    
    var priority: Int
    
    init(item: UIView?, attribute fromAttribute: ConstraintSide, relatedBy: NSLayoutRelation, toItem: UIView?, attribute toAttribute: ConstraintSide, multiplier: Double, constant: Double) {
        self.fromView = item
        self.toView = toItem
        self.toAttribute = toAttribute
        self.fromAttribute = fromAttribute
        self.relation = relatedBy
        self.multiplier = multiplier
        self.constant = constant
        
        self.priority = UILayoutPriorityRequired
    }
    
    func toConstraint(direction: UILayoutConstraintAxis) -> NSLayoutConstraint {
        var adjustedFromAttribute:NSLayoutAttribute = fromAttribute.toAttribute(direction)
        var adjustedToAttribute:NSLayoutAttribute = toAttribute.toAttribute(direction)
        
        var constraint = NSLayoutConstraint(item: fromView, attribute: adjustedFromAttribute, relatedBy:relation, toItem: toView, attribute: adjustedToAttribute, multiplier: CGFloat(multiplier), constant: CGFloat(constant))
        constraint.priority = UILayoutPriority(priority)
        return constraint
    }
}

struct LayoutContext {
    var leftView: UIView?
    var rightView: UIView?
    
    var constraints: ConstraintDescriptor[]
    
    init(_ left: LayoutContext, _ right: LayoutContext) {
        leftView = left.leftView
        rightView = right.rightView
        constraints = left.constraints + right.constraints
    }
    
    init(_ view: LayoutContext) {
        leftView = view.leftView
        rightView = view.rightView
        constraints = view.constraints
    }
    
    init(_ view: UIView?) {
        leftView = view
        rightView = view
        constraints = ConstraintDescriptor[]()
    }
}

struct LayoutStub {
    let margin: LayoutMargin
    let context: LayoutContext
    init(_ margin: LayoutMargin, _ context: LayoutContext) {
        self.margin = margin
        self.context = context
    }
}

struct LayoutMargin {
    let margin: Double
    let priority: Int
    
    init(_ margin: Double, _ priority: Int) {
        self.margin = margin
        self.priority = priority
    }
}