adams3 / PureLayout

The ultimate API for iOS & OS X Auto Layout — impressively simple, immensely powerful. Objective-C and Swift compatible.

The ultimate API for iOS & OS X Auto Layout — impressively simple, immensely powerful. PureLayout extends UIView/NSView, NSArray, and NSLayoutConstraint with a comprehensive Auto Layout API that is modeled after Apple's own frameworks. PureLayout is an Objective-C library that also works (and looks!) great with Swift using a bridging header.

Writing Auto Layout code from scratch isn't easy. PureLayout provides a fully capable and developer-friendly interface for Auto Layout. It is designed for clarity and simplicity, and takes inspiration from the AutoLayout UI options available in Interface Builder while delivering far more flexibility. The API is also highly efficient, as it adds only a thin layer of third party code and is engineered for maximum performance.

API Cheat Sheet

This is just a handy overview of the core API methods. Explore the header files for the full API, and find the complete documentation above the implementation of each method in the corresponding .m file. A couple of notes:

• All of the public API methods are namespaced with the prefix auto..., which also makes it easy for Xcode to autocomplete as you type.
• Methods that create constraints also automatically install (activate) the constraint(s), then return the new constraint(s) for you to optionally store for later adjustment or removal.
• Many methods below also have a variant which includes a relation: parameter to make the constraint an inequality.

Attributes

PureLayout defines view attributes that are used to create auto layout constraints. Here is an illustration of the most common attributes.

There are 5 specific attribute types, which are used throughout most of the API:

• ALEdge
• ALDimension
• ALAxis
• ALMargin available in iOS 8.0 and higher only
• ALMarginAxis available in iOS 8.0 and higher only

Additionally, there is one generic attribute type, ALAttribute, which is effectively a union of all the specific types. You can think of this as the "supertype" of all of the specific attribute types, which means that it is always safe to cast a specific type to the generic ALAttribute type. (Note that the reverse is not true -- casting a generic ALAttribute to a specific attribute type is unsafe!)

UIView/NSView

+ autoCreateConstraintsWithoutInstalling:
+ autoSetPriority:forConstraints:
+ autoSetIdentifier:forConstraints: // iOS 7.0+, OS X 10.9+ only
- autoSetContent(CompressionResistance|Hugging)PriorityForAxis:
- autoCenterInSuperview:
- autoAlignAxisToSuperviewAxis:
- autoCenterInSuperviewMargins: // iOS 8.0+ only
- autoAlignAxisToSuperviewMarginAxis: // iOS 8.0+ only
- autoPinEdgeToSuperviewEdge:(withInset:)
- autoPinEdgesToSuperviewEdgesWithInsets:(excludingEdge:)
- autoPinEdgeToSuperviewMargin: // iOS 8.0+ only
- autoPinEdgesToSuperviewMargins(ExcludingEdge:) // iOS 8.0+ only
- autoPinEdge:toEdge:ofView:(withOffset:)
- autoAlignAxis:toSameAxisOfView:(withOffset:|withMultiplier:)
- autoMatchDimension:toDimension:ofView:(withOffset:|withMultiplier:)
- autoSetDimension(s)ToSize:
- autoConstrainAttribute:toAttribute:ofView:(withOffset:|withMultiplier:)
- autoPinTo(Top|Bottom)LayoutGuideOfViewController:withInset: // iOS only

NSArray

// Arrays of Constraints
- autoInstallConstraints
- autoRemoveConstraints
- autoIdentifyConstraints: // iOS 7.0+, OS X 10.9+ only

// Arrays of Views
- autoAlignViewsToEdge:
- autoAlignViewsToAxis:
- autoMatchViewsDimension:
- autoSetViewsDimension:toSize:
- autoSetViewsDimensionsToSize:
- autoDistributeViewsAlongAxis:alignedTo:withFixedSpacing:(insetSpacing:)(matchedSizes:)
- autoDistributeViewsAlongAxis:alignedTo:withFixedSize:(insetSpacing:)

NSLayoutConstraint

- autoInstall
- autoRemove
- autoIdentify: // iOS 7.0+, OS X 10.9+ only

Setup

Note: PureLayout requires a minimum deployment target of iOS 6.0 or OS X 10.7

Using CocoaPods

1. Add the pod PureLayout to your Podfile.

   pod 'PureLayout'
   

2. Run pod install from Terminal, then open your app's .xcworkspace file to launch Xcode.

3. Import the PureLayout.h header. Typically, this should be written as #import <PureLayout/PureLayout.h>

That's it - now go write some beautiful Auto Layout code!

Using Carthage

1. Add the smileyborg/PureLayout project to your Cartfile.

   github "smileyborg/PureLayout"
   

2. Run carthage update, then follow the additional steps required to add the iOS and/or Mac frameworks into your project.

3. Import the PureLayout framework/module (with the appropriate name for the platform you're using it on).

   • Using Modules: @import PureLayout_iOS or @import PureLayout_Mac
   • Without Modules: #import <PureLayout_iOS/PureLayout_iOS.h> or #import <PureLayout_Mac/PureLayout_Mac.h>

That's it - now go write some beautiful Auto Layout code!

Manually from GitHub

1. Download the source files in the PureLayout subdirectory.
2. Add the source files to your Xcode project.
3. Import the PureLayout.h header.

That's it - now go write some beautiful Auto Layout code!

App Extensions

To use PureLayout in an App Extension, you need to do a bit of extra configuration to prevent usage of unavailable APIs. Click here for more info.

Releases

Releases are tagged in the git commit history using semantic versioning. Check out the releases and release notes for each version.

Usage

Example Project

Open the project included in the repository (requires Xcode 6 or higher). It contains iOS (Example-iOS scheme) and OS X (Example-Mac scheme) demos of the library being used in various scenarios.

On iOS, you can use different device simulators and rotate the device to see the constraints in action (as well as toggle the taller in-call status bar in the iOS Simulator).

On OS X, while running the app, press any key to cycle through the demos. You can resize the window to see the constraints in action.

Tips and Tricks

Check out some Tips and Tricks to keep in mind when using the API.

PureLayout vs. the rest

An overview of the Auto Layout options available, ordered from the lowest- to highest-level of abstraction.

• Apple NSLayoutConstraint SDK API
  • Pros: Raw power
  • Cons: Extremely verbose, tedious to write, difficult to read
• Apple Visual Format Language
  • Pros: Concise, convenient
  • Cons: Doesn't support some use cases, incomplete compile-time checks, must learn syntax, hard to debug
• Apple Interface Builder
  • Pros: Visual, simple
  • Cons: Difficult for complex layouts, cannot dynamically set constraints at runtime, encourages hardcoded magic numbers, not always WYSIWYG
• PureLayout
  • Pros: Simple, efficient, minimal third party code, consistent with Cocoa API style, compatible with Objective-C and Swift codebases
  • Cons: Not the most concise expression of layout code
• High-level Auto Layout Libraries/DSLs (Cartography, SnapKit, KeepLayout)
  • Pros: Very clean, concise, and convenient
  • Cons: Unique API style is foreign to Cocoa APIs, mixed compatibility with Objective-C & Swift, greater dependency on third party code

PureLayout takes a balanced approach to Auto Layout that makes it well suited for any project.

Problems, Suggestions, Pull Requests?

Please open a new Issue here if you run into an issue, have a feature request, or want to share a comment. Note that general Auto Layout questions should be asked on Stack Overflow.

If you're considering taking on significant changes or additions to the project, please communicate in advance by opening a new Issue. This allows everyone to get onboard with upcoming changes, ensures that changes align with the project's design philosophy, and avoids duplicated work.

Meta

Designed & maintained by Tyler Fox (@smileyborg). Distributed with the MIT license.