398 lines
17 KiB
Swift
398 lines
17 KiB
Swift
//
|
|
// LargeImageViewController.swift
|
|
// Tusker
|
|
//
|
|
// Created by Shadowfacts on 8/31/18.
|
|
// Copyright © 2018 Shadowfacts. All rights reserved.
|
|
//
|
|
|
|
import UIKit
|
|
|
|
class LargeImageViewController: UIViewController, UIScrollViewDelegate, LargeImageAnimatableViewController {
|
|
|
|
weak var animationSourceView: UIImageView?
|
|
var largeImageController: LargeImageViewController? { self }
|
|
var animationImage: UIImage? { contentView.animationImage }
|
|
var dismissInteractionController: LargeImageInteractionController?
|
|
|
|
@IBOutlet weak var scrollView: UIScrollView!
|
|
@IBOutlet weak var topControlsView: UIView!
|
|
@IBOutlet weak var descriptionTextView: UITextView!
|
|
|
|
private var shareContainer: UIView!
|
|
private var closeContainer: UIView!
|
|
private var shareImage: UIImageView!
|
|
private var shareButtonTopConstraint: NSLayoutConstraint!
|
|
private var shareButtonLeadingConstraint: NSLayoutConstraint!
|
|
private var closeButtonTopConstraint: NSLayoutConstraint!
|
|
private var closeButtonTrailingConstraint: NSLayoutConstraint!
|
|
|
|
var contentView: LargeImageContentView {
|
|
didSet {
|
|
oldValue.removeFromSuperview()
|
|
setupContentView()
|
|
}
|
|
}
|
|
var contentViewLeadingConstraint: NSLayoutConstraint!
|
|
var contentViewTopConstraint: NSLayoutConstraint!
|
|
|
|
var imageDescription: String?
|
|
|
|
var initialControlsVisible = true
|
|
private(set) var controlsVisible = true {
|
|
didSet {
|
|
setNeedsUpdateOfHomeIndicatorAutoHidden()
|
|
}
|
|
}
|
|
var shrinkGestureEnabled = true
|
|
|
|
private var isInitialAppearance = true
|
|
private var skipUpdatingControlsWhileZooming = false
|
|
private var prevZoomScale: CGFloat?
|
|
private var isGrayscale = false
|
|
private var contentViewSizeObservation: NSKeyValueObservation?
|
|
|
|
var isInteractivelyAnimatingDismissal: Bool = false {
|
|
didSet {
|
|
#if !os(visionOS)
|
|
setNeedsStatusBarAppearanceUpdate()
|
|
#endif
|
|
}
|
|
}
|
|
|
|
override var prefersStatusBarHidden: Bool {
|
|
return !isInteractivelyAnimatingDismissal
|
|
}
|
|
override var preferredStatusBarUpdateAnimation: UIStatusBarAnimation {
|
|
return .none
|
|
}
|
|
|
|
override var prefersHomeIndicatorAutoHidden: Bool {
|
|
return !controlsVisible
|
|
}
|
|
|
|
init(contentView: LargeImageContentView, description: String?, sourceView: UIImageView?) {
|
|
self.imageDescription = description
|
|
self.animationSourceView = sourceView
|
|
|
|
self.contentView = contentView
|
|
|
|
super.init(nibName: "LargeImageViewController", bundle: nil)
|
|
|
|
modalPresentationStyle = .fullScreen
|
|
}
|
|
|
|
required init?(coder aDecoder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
override func viewDidLoad() {
|
|
super.viewDidLoad()
|
|
|
|
setupContentView()
|
|
setupControls()
|
|
|
|
setControlsVisible(initialControlsVisible, animated: false)
|
|
if contentView.activityItemsForSharing.isEmpty {
|
|
shareContainer.isUserInteractionEnabled = false
|
|
shareImage.tintColor = .systemGray
|
|
}
|
|
|
|
scrollView.delegate = self
|
|
|
|
if let imageDescription = imageDescription,
|
|
!imageDescription.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
|
|
descriptionTextView.text = imageDescription.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
descriptionTextView.textContainerInset = UIEdgeInsets(top: 8, left: 8, bottom: 8, right: 8)
|
|
// i'm not sure why .automatic doesn't work for this
|
|
descriptionTextView.contentInsetAdjustmentBehavior = .always
|
|
let height = min(150, descriptionTextView.contentSize.height)
|
|
descriptionTextView.topAnchor.constraint(equalTo: descriptionTextView.safeAreaLayoutGuide.bottomAnchor, constant: -(height + 16)).isActive = true
|
|
} else {
|
|
descriptionTextView.isHidden = true
|
|
}
|
|
|
|
if shrinkGestureEnabled {
|
|
dismissInteractionController = LargeImageInteractionController(viewController: self)
|
|
}
|
|
|
|
let singleTap = UITapGestureRecognizer(target: self, action: #selector(scrollViewPressed(_:)))
|
|
let doubleTap = UITapGestureRecognizer(target: self, action: #selector(scrollViewDoubleTapped(_:)))
|
|
doubleTap.numberOfTapsRequired = 2
|
|
// this requirement is needed to make sure the double tap is ever recognized
|
|
singleTap.require(toFail: doubleTap)
|
|
view.addGestureRecognizer(singleTap)
|
|
view.addGestureRecognizer(doubleTap)
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(preferencesChanged), name: .preferencesChanged, object: nil)
|
|
|
|
accessibilityElements = [
|
|
topControlsView!,
|
|
contentView,
|
|
descriptionTextView!,
|
|
]
|
|
}
|
|
|
|
private func setupContentView() {
|
|
contentView.owner = self
|
|
contentView.translatesAutoresizingMaskIntoConstraints = false
|
|
scrollView.addSubview(contentView)
|
|
contentViewLeadingConstraint = contentView.leadingAnchor.constraint(equalTo: scrollView.leadingAnchor)
|
|
contentViewTopConstraint = contentView.topAnchor.constraint(equalTo: scrollView.topAnchor)
|
|
NSLayoutConstraint.activate([
|
|
contentViewLeadingConstraint,
|
|
contentViewTopConstraint,
|
|
])
|
|
contentViewSizeObservation = (contentView as UIView).observe(\.bounds, changeHandler: { [unowned self] _, _ in
|
|
MainActor.runUnsafely {
|
|
self.centerImage()
|
|
}
|
|
})
|
|
}
|
|
|
|
private func setupControls() {
|
|
shareContainer = UIView()
|
|
shareContainer.isAccessibilityElement = true
|
|
shareContainer.accessibilityTraits = .button
|
|
shareContainer.accessibilityLabel = "Share"
|
|
shareContainer.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(sharePressed)))
|
|
shareContainer.translatesAutoresizingMaskIntoConstraints = false
|
|
topControlsView.addSubview(shareContainer)
|
|
shareImage = UIImageView(image: UIImage(systemName: "square.and.arrow.up"))
|
|
shareImage.tintColor = .white
|
|
shareImage.contentMode = .scaleAspectFit
|
|
shareImage.translatesAutoresizingMaskIntoConstraints = false
|
|
shareContainer.addSubview(shareImage)
|
|
shareButtonTopConstraint = shareImage.topAnchor.constraint(greaterThanOrEqualTo: shareContainer.topAnchor)
|
|
shareButtonLeadingConstraint = shareImage.leadingAnchor.constraint(greaterThanOrEqualTo: shareContainer.leadingAnchor)
|
|
NSLayoutConstraint.activate([
|
|
shareContainer.topAnchor.constraint(equalTo: topControlsView.topAnchor),
|
|
shareContainer.leadingAnchor.constraint(equalTo: topControlsView.leadingAnchor),
|
|
shareContainer.bottomAnchor.constraint(equalTo: topControlsView.bottomAnchor),
|
|
shareContainer.widthAnchor.constraint(greaterThanOrEqualToConstant: 50),
|
|
shareContainer.heightAnchor.constraint(greaterThanOrEqualToConstant: 50),
|
|
|
|
shareImage.centerXAnchor.constraint(equalTo: shareContainer.centerXAnchor),
|
|
shareImage.centerYAnchor.constraint(equalTo: shareContainer.centerYAnchor),
|
|
shareButtonTopConstraint,
|
|
shareButtonLeadingConstraint,
|
|
|
|
shareImage.widthAnchor.constraint(equalToConstant: 24),
|
|
shareImage.heightAnchor.constraint(equalToConstant: 24),
|
|
])
|
|
|
|
closeContainer = UIView()
|
|
closeContainer.isAccessibilityElement = true
|
|
closeContainer.accessibilityTraits = .button
|
|
closeContainer.accessibilityLabel = "Close"
|
|
closeContainer.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(closeButtonPressed)))
|
|
closeContainer.translatesAutoresizingMaskIntoConstraints = false
|
|
topControlsView.addSubview(closeContainer)
|
|
let closeImage = UIImageView(image: UIImage(systemName: "xmark"))
|
|
closeImage.tintColor = .white
|
|
closeImage.contentMode = .scaleAspectFit
|
|
closeImage.translatesAutoresizingMaskIntoConstraints = false
|
|
closeContainer.addSubview(closeImage)
|
|
closeButtonTopConstraint = closeImage.topAnchor.constraint(greaterThanOrEqualTo: closeContainer.topAnchor)
|
|
closeButtonTrailingConstraint = closeContainer.trailingAnchor.constraint(greaterThanOrEqualTo: closeImage.trailingAnchor)
|
|
NSLayoutConstraint.activate([
|
|
closeContainer.topAnchor.constraint(equalTo: topControlsView.topAnchor),
|
|
closeContainer.trailingAnchor.constraint(equalTo: topControlsView.trailingAnchor),
|
|
closeContainer.bottomAnchor.constraint(equalTo: closeContainer.bottomAnchor),
|
|
closeContainer.widthAnchor.constraint(greaterThanOrEqualToConstant: 50),
|
|
closeContainer.heightAnchor.constraint(greaterThanOrEqualToConstant: 50),
|
|
|
|
closeImage.centerXAnchor.constraint(equalTo: closeContainer.centerXAnchor),
|
|
closeImage.centerYAnchor.constraint(equalTo: closeContainer.centerYAnchor),
|
|
closeButtonTopConstraint,
|
|
closeButtonTrailingConstraint,
|
|
|
|
closeImage.widthAnchor.constraint(equalToConstant: 24),
|
|
closeImage.heightAnchor.constraint(equalToConstant: 24),
|
|
])
|
|
}
|
|
|
|
override func viewDidLayoutSubviews() {
|
|
super.viewDidLayoutSubviews()
|
|
|
|
// limit the image height to the safe area height, so the image doesn't overlap the top controls
|
|
// while zoomed all the way out
|
|
let maxHeight = view.bounds.height - view.safeAreaInsets.top - view.safeAreaInsets.bottom
|
|
let heightScale = maxHeight / contentView.intrinsicContentSize.height
|
|
let widthScale = view.bounds.width / contentView.intrinsicContentSize.width
|
|
let minScale = min(widthScale, heightScale)
|
|
skipUpdatingControlsWhileZooming = true
|
|
scrollView.minimumZoomScale = minScale
|
|
scrollView.zoomScale = minScale
|
|
scrollView.maximumZoomScale = minScale >= 1 ? minScale + 2 : 2
|
|
skipUpdatingControlsWhileZooming = false
|
|
|
|
centerImage()
|
|
|
|
let notchedDeviceTopInsets: [CGFloat] = [
|
|
44, // iPhone X, Xs, Xs Max, 11 Pro, 11 Pro Max
|
|
48, // iPhone XR, 11
|
|
47, // iPhone 12, 12 Pro, 12 Pro Max, 13, 13 Pro, 13 Pro Max, 14, 14 Plus
|
|
50, // iPhone 12 mini, 13 mini
|
|
]
|
|
let pillDeviceTopInsets: [CGFloat] = [
|
|
59, // iPhone 14 Pro, 14 Pro Max
|
|
]
|
|
if notchedDeviceTopInsets.contains(view.safeAreaInsets.top) {
|
|
// the notch width is not the same for the iPhones 13,
|
|
// but what we actually want is the same offset from the edges
|
|
// since the corner radius didn't change
|
|
let notchWidth: CGFloat = 210
|
|
let earWidth = (view.bounds.width - notchWidth) / 2
|
|
let offset = (earWidth - shareImage.bounds.width) / 2
|
|
shareButtonLeadingConstraint.constant = offset
|
|
closeButtonTrailingConstraint.constant = offset
|
|
} else if pillDeviceTopInsets.contains(view.safeAreaInsets.top) {
|
|
shareButtonLeadingConstraint.constant = 24
|
|
shareButtonTopConstraint.constant = 24
|
|
closeButtonTrailingConstraint.constant = 24
|
|
closeButtonTopConstraint.constant = 24
|
|
}
|
|
}
|
|
|
|
override func viewSafeAreaInsetsDidChange() {
|
|
super.viewSafeAreaInsetsDidChange()
|
|
// the controls view transforms take the safe area insets into account, so they need to be updated
|
|
updateControlsView()
|
|
}
|
|
|
|
override func viewDidAppear(_ animated: Bool) {
|
|
super.viewDidAppear(animated)
|
|
|
|
// on the first appearance, the text view flashes its own scroll indicators automatically
|
|
// so we only need to do it on subsequent appearances
|
|
if isInitialAppearance {
|
|
isInitialAppearance = false
|
|
} else {
|
|
if animated && controlsVisible && !descriptionTextView.isHidden {
|
|
descriptionTextView.flashScrollIndicators()
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc private func preferencesChanged() {
|
|
if isGrayscale != Preferences.shared.grayscaleImages {
|
|
isGrayscale = Preferences.shared.grayscaleImages
|
|
contentView.grayscaleStateChanged()
|
|
}
|
|
}
|
|
|
|
func setControlsVisible(_ controlsVisible: Bool, animated: Bool) {
|
|
self.controlsVisible = controlsVisible
|
|
if animated {
|
|
UIView.animate(withDuration: 0.2) {
|
|
// note: the value of animated: is passed to ImageAnalysisInteractino.setSupplementaryInterfaceHidden which (as of iOS 17.0.2 (21A350)):
|
|
// - does not animate with animated:false when wrapped in a UIView.animate block
|
|
// - does not animate with animated:true unless also wrapped in a UIView.animate block
|
|
self.contentView.setControlsVisible(controlsVisible, animated: true)
|
|
self.updateControlsView()
|
|
}
|
|
if controlsVisible && !descriptionTextView.isHidden {
|
|
descriptionTextView.flashScrollIndicators()
|
|
}
|
|
} else {
|
|
contentView.setControlsVisible(controlsVisible, animated: false)
|
|
updateControlsView()
|
|
}
|
|
}
|
|
|
|
func updateControlsView() {
|
|
let topOffset = self.controlsVisible ? 0 : -(self.topControlsView.bounds.height + self.view.safeAreaInsets.top)
|
|
self.topControlsView.transform = CGAffineTransform(translationX: 0, y: topOffset)
|
|
if self.imageDescription != nil {
|
|
let bottomOffset = self.controlsVisible ? 0 : self.descriptionTextView.bounds.height + self.view.safeAreaInsets.bottom
|
|
self.descriptionTextView.transform = CGAffineTransform(translationX: 0, y: bottomOffset)
|
|
}
|
|
}
|
|
|
|
func viewForZooming(in scrollView: UIScrollView) -> UIView? {
|
|
return contentView
|
|
}
|
|
|
|
func scrollViewDidZoom(_ scrollView: UIScrollView) {
|
|
let prevZoomScale = self.prevZoomScale ?? scrollView.minimumZoomScale
|
|
if !skipUpdatingControlsWhileZooming {
|
|
if scrollView.zoomScale <= scrollView.minimumZoomScale {
|
|
setControlsVisible(true, animated: true)
|
|
} else if scrollView.zoomScale > prevZoomScale {
|
|
setControlsVisible(false, animated: true)
|
|
}
|
|
}
|
|
self.prevZoomScale = scrollView.zoomScale
|
|
}
|
|
|
|
func centerImage() {
|
|
let yOffset = max(0, (view.bounds.size.height - contentView.frame.height) / 2)
|
|
contentViewTopConstraint.constant = yOffset
|
|
|
|
let xOffset = max(0, (view.bounds.size.width - contentView.frame.width) / 2)
|
|
contentViewLeadingConstraint.constant = xOffset
|
|
}
|
|
|
|
func zoomRectFor(scale: CGFloat, center: CGPoint) -> CGRect {
|
|
var zoomRect = CGRect.zero
|
|
zoomRect.size.width = contentView.frame.width / scale
|
|
zoomRect.size.height = contentView.frame.height / scale
|
|
let newCenter = scrollView.convert(center, to: contentView)
|
|
zoomRect.origin.x = newCenter.x - (zoomRect.width / 2)
|
|
zoomRect.origin.y = newCenter.y - (zoomRect.height / 2)
|
|
return zoomRect
|
|
}
|
|
|
|
// MARK: Interaction
|
|
|
|
func animateZoomOut() {
|
|
UIView.animate(withDuration: 0.3, animations: {
|
|
self.scrollView.zoomScale = self.scrollView.minimumZoomScale
|
|
self.view.layoutIfNeeded()
|
|
})
|
|
}
|
|
|
|
@objc func scrollViewPressed(_ sender: UITapGestureRecognizer) {
|
|
if scrollView.zoomScale > scrollView.minimumZoomScale {
|
|
animateZoomOut()
|
|
} else {
|
|
setControlsVisible(!controlsVisible, animated: true)
|
|
}
|
|
}
|
|
|
|
@objc func scrollViewDoubleTapped(_ recognizer: UITapGestureRecognizer) {
|
|
if scrollView.zoomScale <= scrollView.minimumZoomScale {
|
|
let point = recognizer.location(in: recognizer.view)
|
|
let scale: CGFloat
|
|
if scrollView.minimumZoomScale < 1 {
|
|
if 1 - scrollView.zoomScale <= 0.5 {
|
|
scale = scrollView.zoomScale + 1
|
|
} else {
|
|
scale = 1
|
|
}
|
|
} else {
|
|
scale = scrollView.maximumZoomScale
|
|
}
|
|
let rect = zoomRectFor(scale: scale, center: point)
|
|
UIView.animate(withDuration: 0.3) {
|
|
self.scrollView.zoom(to: rect, animated: false)
|
|
self.view.layoutIfNeeded()
|
|
}
|
|
} else {
|
|
animateZoomOut()
|
|
}
|
|
}
|
|
|
|
@IBAction func closeButtonPressed(_ sender: Any) {
|
|
dismiss(animated: true)
|
|
}
|
|
|
|
@IBAction func sharePressed(_ sender: Any) {
|
|
let activityVC = UIActivityViewController(activityItems: contentView.activityItemsForSharing, applicationActivities: [SaveToPhotosActivity()])
|
|
activityVC.popoverPresentationController?.sourceView = shareImage
|
|
present(activityVC, animated: true)
|
|
}
|
|
|
|
}
|