**Playground**
136 |
137 | To play with the 
**Class Reference Documentation**
143 |
144 | The [Reference Documentation](https://vhesener.github.io/Closures) has all of the detailed usage information including all the public methods, parameters, and convenience initializers.
145 |
146 | [](https://vhesener.github.io/Closures)
147 |
148 | ***
149 | ## [Installation](#installation)
150 |
151 | ### **Swift Package Manager**
152 |
153 | If using [Swift Package Manager](), in Xcode, go to `File > Swift Packages > Add Package Dependency...` and enter the following URL:
154 |
155 | ```
156 | https://github.com/vhesener/Closures
157 | ```
158 |
159 | ### **CocoaPods**
160 |
161 | If using [CocoaPods](https://cocoapods.org/), add the following to your Podfile:
162 |
163 | ```ruby
164 | pod 'Closures'
165 | ```
166 |
167 | ### **Carthage**
168 |
169 | If using [Carthage](https://github.com/Carthage/Carthage), add the following to your Cartfile:
170 |
171 | ```shell
172 | github "vhesener/Closures"
173 | ```
174 |
175 | ### **Manual**
176 |
177 | Download or clone the project files found in the [master branch](https://github.com/vhesener/Closures). Drag and drop
178 | all .swift files located in the 'Closures/Source' subdirectory into your Xcode project. Check the option *Copy items
179 | if needed*.
180 |
181 | ***
182 | ## [Background](#background)
183 |
184 | Inspired by [BlocksKit](https://github.com/BlocksKit/BlocksKit), there was a need for a more *Swifty* version
185 | of the same library. The goal of this library was to provide similar usefulness, but with the following
186 | constraints:
187 |
188 | * Use Swift's strong-typed system as much as possible in the API.
189 | * Not use the [Objective-C runtime](https://github.com/BlocksKit/BlocksKit/search?utf8=%E2%9C%93&q=objc_setAssociatedObject&type=).
190 | There are many reasons for this, but mostly because
191 | * It was arbitrarily challenging.
192 | * It was in the spirit of Swift.
193 | * Create a scalable mechanism to easily add additional closure wrappers in the future.
194 |
195 | It is our goal to become irrelevant via [sherlock](http://www.urbandictionary.com/define.php?term=sherlocked).
196 | In addition to not having to support this library anymore, it would actually be flattering
197 | to have been validated by the API folks at Apple.
198 |
199 | ***
200 | ## [Want more?](#want-more)
201 |
202 | If you were hoping to see an API converted using closures and came up empty handed, there's a
203 | chance all can be right. [Simply vote on a feature](https://github.com/vhesener/Closures/labels/Closure%20API%20Request) by adding a 👍 reaction.
204 |
205 | ***
206 | ## [License](#license)
207 |
208 | Closures is provided under the [MIT License](https://github.com/vhesener/Closures/blob/master/LICENSE).
209 |
210 | ```text
211 | The MIT License (MIT)
212 | Copyright (c) 2017 Vincent Hesener
213 |
214 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
215 | associated documentation files (the "Software"), to deal in the Software without restriction,
216 | including without limitation the rights to use, copy, modify, merge, publish, distribute,
217 | sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
218 | is furnished to do so, subject to the following conditions:
219 |
220 | The above copyright notice and this permission notice shall be included in all copies or
221 | substantial portions of the Software.
222 |
223 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
224 | NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
225 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
226 | DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
227 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
228 | ```
229 |
--------------------------------------------------------------------------------
/Supporting/cocoapods/.swift-version:
--------------------------------------------------------------------------------
1 | 5.1
2 |
--------------------------------------------------------------------------------
/Supporting/cocoapods/Closures.podspec.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "Closures",
3 | "version": "0.7",
4 | "summary": "Swifty closures for UIKit and Foundation",
5 | "homepage": "https://github.com/vhesener/Closures",
6 | "screenshots": [
7 | "https://raw.githubusercontent.com/vhesener/Closures/assets/assets/playground_general.gif",
8 | "https://raw.githubusercontent.com/vhesener/Closures/assets/assets/reference_large.png"
9 | ],
10 | "license": "MIT",
11 | "authors": "Vinnie Hesener",
12 | "platforms": {
13 | "ios": "9.0"
14 | },
15 | "source": {
16 | "git": "https://github.com/vhesener/Closures.git",
17 | "tag": "v0.7"
18 | },
19 | "source_files": "Xcode/Closures/Source",
20 | "documentation_url": "https://vhesener.github.io/Closures/",
21 | "description": "Closures is an iOS Framework that adds closure handlers to many of the popular\nUIKit and Foundation classes. Although this framework is a substitute for \nsome Cocoa Touch design patterns, such as Delegation and Data Sources, and \nTarget-Action, the authors make no claim regarding which is a better way to \naccomplish the same type of task. Most of the time it is a matter of style, \npreference, or convenience that will determine if any of these closure extensions \nare beneficial.\n\nWhether you’re a functional purist, dislike a particular API, or simply just \nwant to organize your code a little bit, you might enjoy using this library."
22 | }
23 |
--------------------------------------------------------------------------------
/Supporting/jazzy/abstracts/Controls.md:
--------------------------------------------------------------------------------
1 | `Closures` framework adds closures to many features of `UIControl` subclasses.
2 | Below are some common actions on some common controls.
3 |
4 | ## UIButton Tap
5 |
6 | A common target-action used is a button tap event. This one is
7 | really simple:
8 |
9 | ```swift
10 | button.onTap {
11 | log("Button tapped")
12 | }
13 | ```
14 | ## Value Changed Events
15 | Most other `UIControl` types are only interesting for their
16 | value changes. The following are examples of how to observe
17 | value changes on other popular `UIControl`s.
18 |
19 | ### UISlider
20 |
21 | ```swift
22 | slider.onChange { value in
23 | log("slider: \(value)")
24 | }
25 | ```
26 |
27 | * * * *
28 | ### UISegmentedControl
29 |
30 | ```swift
31 | segmentedControl.onChange { index in
32 | log("segment: \(index)")
33 | }
34 | ```
35 |
36 | * * * *
37 | ### UIStepper
38 |
39 | ```swift
40 | stepper.onChange { value in
41 | log("stepper: \(value)")
42 | }
43 | ```
44 |
45 | * * * *
46 | ### UIPageControl
47 |
48 | ```swift
49 | pageControl.onChange { index in
50 | log("page: \(index)")
51 | }
52 | ```
53 |
54 | * * * *
55 | ### UISwitch
56 |
57 | ```swift
58 | uiSwitch.onChange { isOn in
59 | log("swith is: \(isOn ? "on" : "off")")
60 | }
61 | ```
62 |
63 | * * * *
64 | ### UIDatePicker
65 |
66 | ```swift
67 | datePicker.onChange { date in
68 | log(date)
69 | }
70 | ```
71 |
72 | * * * *
73 | ### UITextField
74 |
75 | In addtion to text changes, `UITextField` has some other convenient wrappers
76 | around some commonly needed actions. Below are examples of some events that
77 | can you can observe. Notice the use of daisy chaining in order to keep it
78 | concise and organized.
79 |
80 | ```swift
81 | textfield
82 | .onChange { newText in
83 | log(newText)
84 | }.onEditingBegan {
85 | log("Editing began")
86 | }.onEditingEnded {
87 | log("Editing ended")
88 | }.onReturn {
89 | log("Return key tapped")
90 | }
91 | ```
92 |
93 | ## Delegation
94 | `UITextField` also employs delegation to help define its behavior. Below
95 | is how you would implement `UITextFieldDelegate` methods using closures.
96 |
97 | ```swift
98 | textfield
99 | .didBeginEditing {
100 | log("Did begin editing delegate")
101 | }.shouldClear {
102 | log("Text clearing")
103 | return true
104 | }.shouldChangeCharacters { range, string in
105 | return true
106 | }
107 | ```
108 |
109 | Although these convenience closures are not exhaustive, there is a way to
110 | use a closure for any `UIControlEvents`.
111 |
112 | ```swift
113 | button.on(.touchDragInside) { sender, event in
114 | log("Dragging inside button")
115 | }
116 | ```
--------------------------------------------------------------------------------
/Supporting/jazzy/abstracts/Gesture Recognizers.md:
--------------------------------------------------------------------------------
1 | The `UIGestureRecognizer` initializers and delegation wrappers
2 | make it easy to add gesture recognizers to views. It also uses
3 | closures instead of target-action and delegation.
4 |
5 | ## Target-Action Initializers
6 |
7 | The following is how you would add a double tap gesture
8 | recognizer to your view using one of the custom initializers.
9 | As always, we have a closure handler to respond to the gesture's
10 | double tap action.
11 |
12 | ```swift
13 | let doubleTapGesture = UITapGestureRecognizer(tapsRequired: 2) { _ in
14 | log("double tapped")
15 | }
16 | view.addGestureRecognizer(doubleTapGesture)
17 | ```
18 |
19 | These convenience initializers, delegate closures, and closure recognizers
20 | have been added to all of the existing concrete subclasses, including:
21 |
22 | * `UITapGestureRecognizer`
23 | * `UIPinchGestureRecognizer`
24 | * `UIRotationGestureRecognizer`
25 | * `UISwipeGestureRecognizer`
26 | * `UIPanGestureRecognizer`
27 | * `UIScreenEdgePanGestureRecognizer`
28 | * `UILongPressGestureRecognizer`
29 |
30 | There is also a method for you to configure a custom gesture recognizer
31 | to use closure handlers for recognition:
32 |
33 | ```swift
34 | let myCustomGesture = MyCustomGestureRecognizer()
35 | configure(gesture: myCustomGesture) { _ in
36 | /// a closure that's called when the gesture has ended
37 | }
38 | ```
39 |
40 | ## Delegation
41 | With convenient extension methods on `UIGestureRecognizer` and `UIView`,
42 | we can daisy chain an entire gesture cycle, including responding
43 | to `UIGestureRecognizerDelegate` methods.
44 |
45 | ```swift
46 | view
47 | .addPanGesture() { pan in
48 | guard pan.state == .ended else { return }
49 | log("view panned")
50 | }.shouldBegin() {
51 | true
52 | }.shouldRecognizeSimultaneouslyWith {
53 | $0 === doubleTapGesture
54 | }
55 | ```
56 |
57 |
58 |
--------------------------------------------------------------------------------
/Supporting/jazzy/abstracts/KVO.md:
--------------------------------------------------------------------------------
1 | The Foundation team at Apple has made great
2 | strides to become more closuresque, and Swift
3 | 4 has truly proved that with KVO updates.
4 |
5 | The API is almost perfect so there isn't too
6 | much to add. There is only one convenience
7 | method to improve some of the boiler plate
8 | code for a typical use case.
9 |
10 | The existing API requires you to save the observer
11 | and store it for the duration of the observation.
12 | Not bad, but with a little polish we can set and
13 | forget. Although it looks like more effort to
14 | provide a conditional remove handler, with the
15 | helper var `selfDeinits` on every NSObject,
16 | we don't have to hold onto distracting observer
17 | variables in our view controllers.
18 |
19 | In this example we'll observe the `text`
20 | property of a UITextField.
21 |
22 | ```swift
23 | let textField = UITextField()
24 | class MyClass: NSObject {
25 | override init() { super.init()
26 | textField.observe(\.text, until: selfDeinits) { obj,change in
27 | print("Observed the change to \"\(obj.text!)\"")
28 | }
29 | }
30 | }
31 |
32 | var myObject: MyClass? = MyClass()
33 | textField.text = "🐒" // this will be observed
34 | myObject = nil
35 | textField.text = "This will NOT be observed"
36 | ```
--------------------------------------------------------------------------------
/Supporting/jazzy/abstracts/UIBarButtonItem.md:
--------------------------------------------------------------------------------
1 | `Closures` framework adds closures for `UIBarButtonItem` tap events, usually
2 | found in a UINavigationBar.
3 |
4 | All initializers that support the target-action pattern now have an equivalent
5 | initialier that contains a `handler` parameter.
6 |
7 | ```swift
8 | navigationItem.leftBarButtonItem = UIBarButtonItem(title: "Left item", style: .plain) {
9 | // left bar button item tapped
10 | }
11 | ```
12 |
13 | To add the closure handler to an existing `UIBarButtonItem`, simply call the
14 | `onTap(handler:)` method. For instance, if you created your button
15 | in a storyboard, you could call the following in your `viewDidLoad` method.
16 |
17 | ```swift
18 | let myRightBarButton = navigationItem.rightBarButtonItem!
19 | myRightBarButton.onTap {
20 | // right bar button item tapped
21 | }
22 | ```
23 |
24 |
--------------------------------------------------------------------------------
/Supporting/jazzy/abstracts/UICollectionView.md:
--------------------------------------------------------------------------------
1 | ## Delegate and DataSource
2 |
3 | `UICollectionView` closures make it easy to implement `UICollectionViewDelegate` and
4 | `UICollectionViewDataSource` protocol methods in an organized way. The following
5 | is an example of a simple collection view that displays strings in a basic cell.
6 |
7 | ```swift
8 | func loadCollectionView() {
9 | collectionView.register(MyCustomCollectionViewCell.self, forCellWithReuseIdentifier: "Cell")
10 |
11 | collectionView
12 | .numberOfItemsInSection { _ in
13 | countries.count
14 | }.cellForItemAt { indexPath in
15 | let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "Cell", for: indexPath) as! MyCustomCollectionViewCell
16 | cell.textLabel.text = countries[indexPath.item]
17 | return cell
18 | }.didSelectItemAt {
19 | print("\(countries[$0.item]) selected")
20 | }.reloadData()
21 | }
22 | ```
23 |
24 | ## Arrays
25 | These operations are common. Usually, they involve populating the `UICollectionView`
26 | with the values from an array. `Closures` framework gives you a convenient
27 | way to pass your array to the collection view, so that it can perform the boilerplate
28 | operations for you, especially the ones that are required to make the collection
29 | view perform at a basic level.
30 |
31 | * Important:
32 | Please remember that Swift `Array`s are value types. This means that they
33 | are copied when mutated. When the values or sequence of your array changes, you will
34 | need to call `addFlowElements` again, just before you call reloadData().
35 |
36 | ```swift
37 | func loadCollectionView(countries: [String]) {
38 | collectionView
39 | .addFlowElements(countries, cell: MyCustomCollectionViewCell.self) { country, cell, index in
40 | cell.textLabel.text = country
41 | }.reloadData()
42 |
43 | /**
44 | This also allows you to override any default behavior so
45 | you aren't overly committed, even though you're initially binding everything
46 | to the `Array`.
47 | */
48 | collectionView.didSelectItemAt {
49 | print("\(countries[$0.item]) selected from array")
50 | }
51 | }
52 | ```
53 |
--------------------------------------------------------------------------------
/Supporting/jazzy/abstracts/UIImagePickerController.md:
--------------------------------------------------------------------------------
1 | The following is an example of using closures to
2 | select media from a `UIImagePickerController`.
3 | A simple picker is created which defaults to allowing
4 | images to be selected from the photos library. This
5 | initializer will call the handler when an image is selected.
6 | When preseting with the `present(from:)` method,
7 | the `UIImagePickerController` will dismiss itself on user cancel
8 | or after the picker has picked its content (after the closure
9 | is called).
10 |
11 | ```swift
12 | UIImagePickerController() { result,picker in
13 | myImageView.image = result.editedImage
14 | }.present(from: self)
15 | ```
16 |
17 | You can also customize the picker if you need more control, including
18 | setting your own initial values and delegate callbacks.
19 | The following is a verbose example using most of the possible
20 | customization points.
21 |
22 | ```swift
23 | UIImagePickerController(
24 | source: .camera,
25 | allow: [.image, .movie],
26 | cameraOverlay: nil,
27 | showsCameraControls: false) { result,picker in
28 | myImageView.image = result.originalImage
29 | }.didCancel { [weak self] in
30 | // some custom didCancel implementation
31 | self?.dismiss(animated: animation.animate)
32 | }.present(from: self)
33 | ```
--------------------------------------------------------------------------------
/Supporting/jazzy/abstracts/UIPickerView.md:
--------------------------------------------------------------------------------
1 | ## Delegate and DataSource
2 |
3 | `UIPickerView` closures make it easy to implement `UIPickerViewDelegate` and
4 | `UIPickerViewDataSource` protocol methods in an organized way. The following
5 | is an example of a simple collection view that displays strings in each row.
6 |
7 | ```swift
8 | func loadPickerView() {
9 | pickerView
10 | .numberOfRowsInComponent() { _ in
11 | countries.count
12 | }.titleForRow() { row, component in
13 | countries[row]
14 | }.didSelectRow { row, component in
15 | log("\(countries[row]) selected")
16 | }.reloadAllComponents()
17 | }
18 | ```
19 |
20 | ## Arrays
21 | These operations are common. Usually, they involve populating the `UIPickerView`
22 | with the values from an array. `Closures` framework gives you a convenient
23 | way to pass your collection to the table view, so that it can perform the boilerplate
24 | operations for you, especially the ones that are required to make the picker
25 | view perform at a basic level.
26 |
27 | * Important:
28 | Please remember that Swift `Array`s are value types. This means that they
29 | are copied when mutaded. When the values or sequence of your array changes, you will
30 | need to call one of the `add` methods again, just before you
31 | call reloadData().
32 |
33 | ```swift
34 | func loadPickerView(countries: [String]) {
35 | let reversed = Array(countries.reversed())
36 | pickerView
37 | .addStrings(reversed) { country,component,row in
38 | log("\(country) selected from array")
39 | }.reloadAllComponents()
40 | }
41 | ```
42 |
43 | * Note:
44 | Be sure to note that most of the closure callbacks in these array binding
45 | methods switch the order of the parameters of row and component. Most of the
46 | `UIPickerView` delegate/datasource method parameters pass `row,component`. The
47 | parameters on the `add` methods switch the order and send `component,row`
48 |
49 | ### Multiple Components
50 | And finally, you can just as easily show mutliple components by binding a
51 | 2-dimensional array. When using this method, the outer dimension of the array is the
52 | component (columns) and the inner dimension are the rows in that component.
53 |
54 | ```swift
55 | let anElement = myTwoDArray[component][row]
56 | ```
57 |
58 | In this example, the more verbose row handler is provided just to show the
59 | different variations. Adding multiple components has a convenient method to
60 | deal with string only arrays also.
61 |
62 | ```swift
63 | func loadPickerView(components: [[String]]) {
64 | pickerView.addComponents(
65 | components,
66 | rowTitle: { country,component,row in
67 | country},
68 | didSelect: { country,component,row in
69 | log("\(country) selected from 2D Array")
70 | })
71 |
72 | /**
73 | This also allows you to override any default behavior so
74 | you aren't overly committed, even though you're initially binding everything
75 | to the `Array`.
76 | */
77 | pickerView.widthForComponent { component in
78 | component == 0 ? 200 : 100
79 | }.reloadAllComponents()
80 | }
81 | ```
82 |
--------------------------------------------------------------------------------
/Supporting/jazzy/abstracts/UITableView.md:
--------------------------------------------------------------------------------
1 | ## Delegate and DataSource
2 |
3 | `UITableView` closures make it easy to implement `UITableViewDelegate` and
4 | `UITableViewDataSource` protocol methods in an organized way. The following
5 | is an example of a simple table view that displays strings in a basic cell.
6 |
7 | ```swift
8 | func loadTableView() {
9 | tableView.register(UITableViewCell.self, forCellReuseIdentifier: "Cell")
10 |
11 | tableView
12 | .numberOfRows { _ in
13 | countries.count
14 | }.cellForRow { indexPath in
15 | let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)
16 | cell.textLabel!.text = countries[indexPath.row]
17 | return cell
18 | }.didSelectRowAt {
19 | print("\(countries[$0.row]) selected")
20 | }.reloadData()
21 | }
22 | ```
23 |
24 | ## Arrays
25 | These operations are common. Usually, they involve populating the `UITableView`
26 | with the values from an array. `Closures` framework gives you a convenient
27 | way to pass your array to the table view, so that it can perform the boiler
28 | plate operations for you, especially the ones that are required to make the table
29 | view perform at a basic level.
30 |
31 | * Important:
32 | Please remember that Swift `Array`s are value types. This means that they
33 | are copied when mutated. When the values or sequence of your array changes, you will
34 | need to call `addElements` again, just before you call reloadData().
35 |
36 | ```swift
37 | func loadTableView(countries: [String]) {
38 | tableView
39 | .addElements(countries, cell: UITableViewCell.self) { country, cell, index in
40 | cell.textLabel!.text = country
41 | }.reloadData()
42 | }
43 | ```
44 |
45 | ### Multiple Sections
46 | * * * *
47 | And finally, you can just as easily have a grouped table view, by binding a
48 | 2-dimensional array. Before calling this method, we grouped the countries by their
49 | first letter.
50 |
51 | ```swift
52 | func loadTableView(countries: [[String]]) {
53 | tableView.addSections(
54 | countries,
55 | cell: UITableViewCell.self,
56 | headerTitle: { countryArray,index in
57 | String(countryArray.first!.first!)},
58 | row: { country, cell, index in
59 | cell.textLabel!.text = country
60 | })
61 |
62 | /**
63 | This also allows you to override any default behavior so
64 | you aren't overly committed, even though you're initially binding everything
65 | to the `Array`.
66 | */
67 | tableView
68 | .estimatedHeightForHeaderInSection { _ in
69 | 30
70 | }.heightForHeaderInSection { _ in
71 | 30
72 | }.reloadData()
73 | }
74 | ```
75 |
--------------------------------------------------------------------------------
/Supporting/jazzy/generate_docs.sh:
--------------------------------------------------------------------------------
1 | jazzy --config jazzy.yml;
2 |
3 | ## Have to create this exception in order to have underscores in a class name
4 | ## display in the github documentation generator
5 | echo "include:
6 | - \"_5FKeyValueCodingAndObserving.html\"
7 | " > ../../docs/_config.yml
--------------------------------------------------------------------------------
/Supporting/jazzy/jazzy.yml:
--------------------------------------------------------------------------------
1 | clean: true
2 | output: "../../docs/"
3 | min_acl: public
4 | author: Vinnie Hesener
5 | copyright: 2017 Vincent Hesener
6 | author_url: https://git.io/vQ6dA
7 | github_url: https://github.com/vhesener/Closures
8 | sdk: iphone
9 | skip_undocumented: true
10 | hide_documentation_coverage: true
11 | use_safe_filenames: true
12 | readme: "../../README.md"
13 | module: Closures
14 | abstract: "abstracts/*.md"
15 | source_directory: "../../Xcode"
16 | custom_categories:
17 | - name: Controls
18 | children:
19 | - UIButton
20 | - UISwitch
21 | - UITextField
22 | - UIDatePicker
23 | - UIPageControl
24 | - UISegmentedControl
25 | - UIStepper
26 | - UISlider
27 | - UIControl
28 | - UIBarButtonItem
29 | - name: Scrolling Views
30 | children:
31 | - UITableView
32 | - UICollectionView
33 | - UIPickerView
34 | - UIScrollView
35 | - name: Gesture Recognizers
36 | children:
37 | - UIGestureRecognizer
38 | - UITapGestureRecognizer
39 | - UILongPressGestureRecognizer
40 | - UIPinchGestureRecognizer
41 | - UIPanGestureRecognizer
42 | - UISwipeGestureRecognizer
43 | - UIRotationGestureRecognizer
44 | - UIScreenEdgePanGestureRecognizer
45 | - UIView
46 | - "configure(gesture:handler:)"
47 | - name: Controllers
48 | children:
49 | - UIImagePickerController
50 | - name: KVO
51 | children:
52 | - _KeyValueCodingAndObserving
53 |
--------------------------------------------------------------------------------
/Xcode/Closures.xcodeproj/project.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 |
2 | 
View on GitHub
25 | Controllers Reference
26 | Controllers
146 | 147 |
150 |
180 | -
151 |
-
152 | 153 |159 |
154 | 155 | 156 | UIImagePickerController 157 |158 |160 | 161 |177 |162 | 163 | 176 |164 | 165 | See more 166 |167 |168 |175 |Declaration
169 |170 |174 |Swift
171 |
172 | 173 |extension UIImagePickerController
178 |
View on GitHub
25 | UIPinchGestureRecognizer Extension Reference
26 |