Shin Yamamoto
303 lines
10 KiB
Swift
303 lines
10 KiB
Swift
// Copyright 2018 the FloatingPanel authors. All rights reserved. MIT license.
|
|
|
|
import UIKit
|
|
import FloatingPanel
|
|
|
|
class DebugTableViewController: InspectableViewController {
|
|
// MARK: - Views
|
|
|
|
lazy var tableView: UITableView = {
|
|
let tableView = UITableView(frame: .zero, style: .plain)
|
|
tableView.dataSource = self
|
|
tableView.delegate = self
|
|
tableView.register(UITableViewCell.self, forCellReuseIdentifier: "Cell")
|
|
return tableView
|
|
}()
|
|
lazy var buttonStackView: UIStackView = {
|
|
let stackView = UIStackView()
|
|
stackView.axis = .vertical
|
|
stackView.distribution = .fillEqually
|
|
stackView.alignment = .trailing
|
|
stackView.spacing = 4
|
|
return stackView
|
|
}()
|
|
private lazy var reorderButton: UIButton = {
|
|
let button = UIButton()
|
|
button.setTitle(Menu.reorder.rawValue, for: .normal)
|
|
button.setTitleColor(view.tintColor, for: .normal)
|
|
button.addTarget(self, action: #selector(reorderItems), for: .touchUpInside)
|
|
return button
|
|
}()
|
|
private lazy var trackingButton: UIButton = {
|
|
let button = UIButton()
|
|
button.setTitle(Menu.trackScrolling.rawValue, for: .normal)
|
|
button.setTitleColor(view.tintColor, for: .normal)
|
|
button.addTarget(self, action: #selector(toggleTrackingScroll), for: .touchUpInside)
|
|
return button
|
|
}()
|
|
private lazy var followingButton: UIButton = {
|
|
let button = UIButton()
|
|
button.setTitleColor(view.tintColor, for: .normal)
|
|
button.addTarget(self, action: #selector(toggleFollowingScroll), for: .touchUpInside)
|
|
return button
|
|
}()
|
|
|
|
// MARK: - Properties
|
|
|
|
var kvoObservers: [NSKeyValueObservation] = []
|
|
|
|
private var fpc: FloatingPanelController? { parent as? FloatingPanelController }
|
|
private lazy var items: [String] = {
|
|
let items = (0..<100).map { "Items \($0)" }
|
|
return Command.replace(items: items)
|
|
}()
|
|
private var itemHeight: CGFloat = 66.0
|
|
|
|
// MARK: Flags
|
|
private var tracksScrollView: Bool = false {
|
|
didSet {
|
|
let title = "\(Menu.trackScrolling.rawValue): \(tracksScrollView ? "on" : "off")"
|
|
trackingButton.setTitle(title, for: .normal)
|
|
}
|
|
}
|
|
private var followsScrollViewBouncing: Bool = false {
|
|
didSet {
|
|
let title = "\(Menu.followScrolling.rawValue): \(followsScrollViewBouncing ? "on" : "off")"
|
|
followingButton.setTitle(title, for: .normal)
|
|
}
|
|
}
|
|
|
|
enum Menu: String, CaseIterable {
|
|
case trackScrolling = "Tracking"
|
|
case followScrolling = "Following"
|
|
case reorder = "Reorder"
|
|
}
|
|
|
|
enum Command: Int, CaseIterable {
|
|
case animateScroll
|
|
case changeContentSize
|
|
case moveToFull
|
|
case moveToHalf
|
|
var text: String {
|
|
switch self {
|
|
case .animateScroll: return "Scroll in the middle"
|
|
case .changeContentSize: return "Change content size"
|
|
case .moveToFull: return "Move to Full"
|
|
case.moveToHalf: return "Move to Half"
|
|
}
|
|
}
|
|
|
|
static func replace(items: [String]) -> [String] {
|
|
return items.enumerated().map { (index, text) -> String in
|
|
if let action = Command(rawValue: index) {
|
|
return "\(index). \(action.text)"
|
|
}
|
|
return text
|
|
}
|
|
}
|
|
|
|
func execute(for vc: DebugTableViewController, sourceView: UIView) {
|
|
switch self {
|
|
case .animateScroll:
|
|
vc.animateScroll()
|
|
case .changeContentSize:
|
|
vc.changeContentSize(sourceView: sourceView)
|
|
case .moveToFull:
|
|
vc.moveToFull()
|
|
case .moveToHalf:
|
|
vc.moveToHalf()
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Lifecycle
|
|
|
|
override func viewDidLoad() {
|
|
super.viewDidLoad()
|
|
layoutTableView()
|
|
layoutMenuStackView()
|
|
setUpMenu()
|
|
}
|
|
|
|
private func layoutTableView() {
|
|
view.addSubview(tableView)
|
|
tableView.translatesAutoresizingMaskIntoConstraints = false
|
|
NSLayoutConstraint.activate([
|
|
tableView.topAnchor.constraint(equalTo: view.topAnchor),
|
|
tableView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
|
|
tableView.leftAnchor.constraint(equalTo: view.leftAnchor),
|
|
tableView.rightAnchor.constraint(equalTo: view.rightAnchor)
|
|
])
|
|
}
|
|
|
|
private func layoutMenuStackView() {
|
|
view.addSubview(buttonStackView)
|
|
buttonStackView.translatesAutoresizingMaskIntoConstraints = false
|
|
NSLayoutConstraint.activate([
|
|
buttonStackView.topAnchor.constraint(equalTo: view.topAnchor, constant: 22.0),
|
|
buttonStackView.rightAnchor.constraint(equalTo: view.rightAnchor, constant: -22.0),
|
|
])
|
|
}
|
|
|
|
private func setUpMenu() {
|
|
for menu in Menu.allCases {
|
|
switch menu {
|
|
case .reorder:
|
|
buttonStackView.addArrangedSubview(reorderButton)
|
|
case .trackScrolling:
|
|
buttonStackView.addArrangedSubview(trackingButton)
|
|
case .followScrolling:
|
|
buttonStackView.addArrangedSubview(followingButton)
|
|
}
|
|
}
|
|
// Set titles
|
|
tracksScrollView = true
|
|
followsScrollViewBouncing = false
|
|
}
|
|
|
|
// MARK: - Menu
|
|
|
|
@objc
|
|
private func reorderItems() {
|
|
if reorderButton.titleLabel?.text == Menu.reorder.rawValue {
|
|
tableView.isEditing = true
|
|
reorderButton.setTitle("Cancel", for: .normal)
|
|
} else {
|
|
tableView.isEditing = false
|
|
reorderButton.setTitle(Menu.reorder.rawValue, for: .normal)
|
|
}
|
|
}
|
|
|
|
@objc
|
|
private func toggleTrackingScroll() {
|
|
tracksScrollView.toggle()
|
|
guard let fpc = fpc else { return }
|
|
if tracksScrollView {
|
|
fpc.track(scrollView: tableView)
|
|
} else {
|
|
fpc.untrack(scrollView: tableView)
|
|
}
|
|
}
|
|
|
|
@objc
|
|
private func toggleFollowingScroll() {
|
|
followsScrollViewBouncing.toggle()
|
|
}
|
|
|
|
// MARK: - Actions
|
|
|
|
private func execute(command: Command, sourceView: UIView) {
|
|
command.execute(for: self, sourceView: sourceView)
|
|
}
|
|
|
|
@objc
|
|
private func animateScroll() {
|
|
tableView.scrollToRow(at: IndexPath(row: lround(Double(items.count) / 2.0),
|
|
section: 0),
|
|
at: .top, animated: true)
|
|
}
|
|
|
|
@objc
|
|
private func changeContentSize(sourceView: UIView) {
|
|
let actionSheet = UIAlertController(title: "Change content size", message: "", preferredStyle: .actionSheet)
|
|
actionSheet.addAction(UIAlertAction(title: "Large", style: .default, handler: { (_) in
|
|
self.itemHeight = 66.0
|
|
self.changeItems(100)
|
|
}))
|
|
actionSheet.addAction(UIAlertAction(title: "Match", style: .default, handler: { (_) in
|
|
switch self.tableView.bounds.height {
|
|
case 585: // iPhone 6,7,8
|
|
self.itemHeight = self.tableView.bounds.height / 13.0
|
|
self.changeItems(13)
|
|
case 656: // iPhone {6,7,8} Plus
|
|
self.itemHeight = self.tableView.bounds.height / 16.0
|
|
self.changeItems(16)
|
|
default: // iPhone X family
|
|
self.itemHeight = self.tableView.bounds.height / 12.0
|
|
self.changeItems(12)
|
|
}
|
|
}))
|
|
actionSheet.addAction(UIAlertAction(title: "Short", style: .default, handler: { (_) in
|
|
self.itemHeight = 66.0
|
|
self.changeItems(3)
|
|
}))
|
|
|
|
if let popoverController = actionSheet.popoverPresentationController {
|
|
popoverController.sourceView = sourceView
|
|
popoverController.sourceRect = sourceView.bounds
|
|
}
|
|
|
|
self.present(actionSheet, animated: true, completion: nil)
|
|
}
|
|
|
|
private func changeItems(_ count: Int) {
|
|
items = Command.replace(items: (0..<count).map{ "\($0). No action" })
|
|
tableView.reloadData()
|
|
}
|
|
|
|
@objc
|
|
private func moveToFull() {
|
|
(self.parent as! FloatingPanelController).move(to: .full, animated: true)
|
|
}
|
|
|
|
@objc
|
|
private func moveToHalf() {
|
|
(self.parent as! FloatingPanelController).move(to: .half, animated: true)
|
|
}
|
|
|
|
@objc
|
|
private func close(sender: UIButton) {
|
|
// Remove FloatingPanel from a view
|
|
(self.parent as! FloatingPanelController).removePanelFromParent(animated: true, completion: nil)
|
|
}
|
|
}
|
|
|
|
extension DebugTableViewController: UITableViewDataSource {
|
|
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
|
|
return items.count
|
|
}
|
|
|
|
func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
|
|
return itemHeight
|
|
}
|
|
|
|
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
|
|
let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)
|
|
cell.textLabel?.text = items[indexPath.row]
|
|
return cell
|
|
}
|
|
}
|
|
|
|
extension DebugTableViewController: UITableViewDelegate {
|
|
func scrollViewDidScroll(_ scrollView: UIScrollView) {
|
|
if followsScrollViewBouncing {
|
|
fpc?.followScrollViewBouncing()
|
|
}
|
|
print("TableView --- ", scrollView.contentOffset, scrollView.contentInset)
|
|
}
|
|
|
|
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
|
|
print("DebugTableViewController -- select row \(indexPath.row)")
|
|
guard let action = Command(rawValue: indexPath.row) else { return }
|
|
let cell = tableView.cellForRow(at: indexPath)
|
|
execute(command: action, sourceView: cell ?? tableView)
|
|
}
|
|
|
|
func tableView(_ tableView: UITableView, editActionsForRowAt indexPath: IndexPath) -> [UITableViewRowAction]? {
|
|
return [
|
|
UITableViewRowAction(style: .destructive, title: "Delete", handler: { (action, path) in
|
|
self.items.remove(at: path.row)
|
|
tableView.deleteRows(at: [path], with: .automatic)
|
|
}),
|
|
]
|
|
}
|
|
|
|
func tableView(_ tableView: UITableView, canMoveRowAt indexPath: IndexPath) -> Bool {
|
|
return true
|
|
}
|
|
|
|
func tableView(_ tableView: UITableView, moveRowAt sourceIndexPath: IndexPath, to destinationIndexPath: IndexPath) {
|
|
items.insert(items.remove(at: sourceIndexPath.row), at: destinationIndexPath.row)
|
|
}
|
|
}
|