mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2026-02-10 13:06:33 +00:00
433 lines
18 KiB
Swift
433 lines
18 KiB
Swift
import Foundation
|
|
import UIKit
|
|
import Display
|
|
import ComponentFlow
|
|
import MultilineTextComponent
|
|
import TelegramPresentationData
|
|
import GlassBackgroundComponent
|
|
import LiquidLens
|
|
import TabSelectionRecognizer
|
|
|
|
extension CameraMode {
|
|
func title(strings: PresentationStrings) -> String {
|
|
switch self {
|
|
case .photo:
|
|
return strings.Story_Camera_Photo
|
|
case .video:
|
|
return strings.Story_Camera_Video
|
|
case .live:
|
|
return strings.Story_Camera_Live
|
|
}
|
|
}
|
|
}
|
|
|
|
private let buttonSize = CGSize(width: 55.0, height: 48.0)
|
|
private let tabletButtonSize = CGSize(width: 55.0, height: 44.0)
|
|
|
|
final class ModeComponent: Component {
|
|
let isTablet: Bool
|
|
let strings: PresentationStrings
|
|
let tintColor: UIColor
|
|
let availableModes: [CameraMode]
|
|
let currentMode: CameraMode
|
|
let updatedMode: (CameraMode) -> Void
|
|
let tag: AnyObject?
|
|
|
|
init(
|
|
isTablet: Bool,
|
|
strings: PresentationStrings,
|
|
tintColor: UIColor,
|
|
availableModes: [CameraMode],
|
|
currentMode: CameraMode,
|
|
updatedMode: @escaping (CameraMode) -> Void,
|
|
tag: AnyObject?
|
|
) {
|
|
self.isTablet = isTablet
|
|
self.strings = strings
|
|
self.tintColor = tintColor
|
|
self.availableModes = availableModes
|
|
self.currentMode = currentMode
|
|
self.updatedMode = updatedMode
|
|
self.tag = tag
|
|
}
|
|
|
|
static func ==(lhs: ModeComponent, rhs: ModeComponent) -> Bool {
|
|
if lhs.isTablet != rhs.isTablet {
|
|
return false
|
|
}
|
|
if lhs.strings !== rhs.strings {
|
|
return false
|
|
}
|
|
if lhs.tintColor != rhs.tintColor {
|
|
return false
|
|
}
|
|
if lhs.availableModes != rhs.availableModes {
|
|
return false
|
|
}
|
|
if lhs.currentMode != rhs.currentMode {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
final class View: UIView, ComponentTaggedView {
|
|
private var component: ModeComponent?
|
|
private var state: EmptyComponentState?
|
|
|
|
final class ItemView: HighlightTrackingButton {
|
|
init() {
|
|
super.init(frame: .zero)
|
|
}
|
|
|
|
required init(coder: NSCoder) {
|
|
preconditionFailure()
|
|
}
|
|
|
|
func update(isTablet: Bool, value: String, selected: Bool, tintColor: UIColor) -> CGSize {
|
|
let accentColor: UIColor
|
|
let normalColor: UIColor
|
|
if tintColor.rgb == 0xffffff {
|
|
accentColor = UIColor(rgb: 0xffd300)
|
|
normalColor = .white
|
|
} else {
|
|
accentColor = tintColor
|
|
normalColor = tintColor.withAlphaComponent(0.5)
|
|
}
|
|
|
|
let title = NSMutableAttributedString(string: value.uppercased(), font: Font.with(size: 14.0, design: .regular, weight: .medium), textColor: selected ? accentColor : normalColor, paragraphAlignment: .center)
|
|
title.addAttribute(.kern, value: -0.5 as NSNumber, range: NSMakeRange(0, title.length))
|
|
self.setAttributedTitle(title, for: .normal)
|
|
self.sizeToFit()
|
|
|
|
return CGSize(width: self.titleLabel?.bounds.size.width ?? 0.0, height: isTablet ? tabletButtonSize.height : buttonSize.height)
|
|
}
|
|
}
|
|
|
|
private var backgroundView = UIView()
|
|
private var backgroundContainer = GlassBackgroundContainerView()
|
|
|
|
private let liquidLensView: LiquidLensView
|
|
|
|
private var itemViews: [AnyHashable: ItemView] = [:]
|
|
private var selectedItemViews: [AnyHashable: ItemView] = [:]
|
|
|
|
private var tabSelectionRecognizer: TabSelectionRecognizer?
|
|
private var selectionGestureState: (startX: CGFloat, currentX: CGFloat, itemId: AnyHashable)?
|
|
|
|
public func matches(tag: Any) -> Bool {
|
|
if let component = self.component, let componentTag = component.tag {
|
|
let tag = tag as AnyObject
|
|
if componentTag === tag {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
init() {
|
|
self.liquidLensView = LiquidLensView(kind: .externalContainer)
|
|
|
|
super.init(frame: CGRect())
|
|
|
|
self.backgroundView.backgroundColor = UIColor(rgb: 0xffffff, alpha: 0.11)
|
|
self.backgroundView.layer.cornerRadius = 24.0
|
|
|
|
self.layer.allowsGroupOpacity = true
|
|
|
|
self.addSubview(self.backgroundView)
|
|
self.backgroundView.addSubview(self.backgroundContainer)
|
|
|
|
self.backgroundContainer.contentView.addSubview(self.liquidLensView)
|
|
|
|
let tabSelectionRecognizer = TabSelectionRecognizer(target: self, action: #selector(self.onTabSelectionGesture(_:)))
|
|
self.tabSelectionRecognizer = tabSelectionRecognizer
|
|
self.liquidLensView.addGestureRecognizer(tabSelectionRecognizer)
|
|
}
|
|
|
|
required init?(coder aDecoder: NSCoder) {
|
|
preconditionFailure()
|
|
}
|
|
|
|
private var animatedOut = false
|
|
func animateOutToEditor(transition: ComponentTransition) {
|
|
self.animatedOut = true
|
|
|
|
transition.setAlpha(view: self.backgroundView, alpha: 0.0)
|
|
transition.setSublayerTransform(view: self, transform: CATransform3DMakeTranslation(0.0, -buttonSize.height, 0.0))
|
|
}
|
|
|
|
func animateInFromEditor(transition: ComponentTransition) {
|
|
self.animatedOut = false
|
|
|
|
transition.setAlpha(view: self.backgroundView, alpha: 1.0)
|
|
transition.setSublayerTransform(view: self, transform: CATransform3DIdentity)
|
|
}
|
|
|
|
override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
|
|
return self.backgroundView.frame.contains(point)
|
|
}
|
|
|
|
private func item(at point: CGPoint) -> AnyHashable? {
|
|
var closestItem: (AnyHashable, CGFloat)?
|
|
for (id, itemView) in self.itemViews {
|
|
if itemView.frame.contains(point) {
|
|
return id
|
|
} else {
|
|
let distance = abs(point.x - itemView.center.x)
|
|
if let closestItemValue = closestItem {
|
|
if closestItemValue.1 > distance {
|
|
closestItem = (id, distance)
|
|
}
|
|
} else {
|
|
closestItem = (id, distance)
|
|
}
|
|
}
|
|
}
|
|
return closestItem?.0
|
|
}
|
|
|
|
@objc private func onTabSelectionGesture(_ recognizer: TabSelectionRecognizer) {
|
|
guard let component = self.component else {
|
|
return
|
|
}
|
|
let location = recognizer.location(in: self.liquidLensView.contentView)
|
|
switch recognizer.state {
|
|
case .began:
|
|
if let itemId = self.item(at: location), let itemView = self.itemViews[itemId] {
|
|
let startX = itemView.frame.minX - 4.0
|
|
self.selectionGestureState = (startX, startX, itemId)
|
|
self.state?.updated(transition: .spring(duration: 0.4), isLocal: true)
|
|
}
|
|
case .changed:
|
|
if var selectionGestureState = self.selectionGestureState {
|
|
selectionGestureState.currentX = selectionGestureState.startX + recognizer.translation(in: self).x
|
|
if let itemId = self.item(at: location) {
|
|
selectionGestureState.itemId = itemId
|
|
}
|
|
self.selectionGestureState = selectionGestureState
|
|
self.state?.updated(transition: .immediate, isLocal: true)
|
|
}
|
|
case .ended, .cancelled:
|
|
if let selectionGestureState = self.selectionGestureState {
|
|
self.selectionGestureState = nil
|
|
if case .ended = recognizer.state {
|
|
guard let item = component.availableModes.first(where: { AnyHashable($0.rawValue) == selectionGestureState.itemId }) else {
|
|
return
|
|
}
|
|
component.updatedMode(item)
|
|
}
|
|
self.state?.updated(transition: .spring(duration: 0.4), isLocal: true)
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
func update(component: ModeComponent, availableSize: CGSize, state: EmptyComponentState, transition: ComponentTransition) -> CGSize {
|
|
self.component = component
|
|
self.state = state
|
|
|
|
let isTablet = component.isTablet
|
|
|
|
self.backgroundView.backgroundColor = component.isTablet ? .clear : UIColor(rgb: 0xffffff, alpha: 0.11)
|
|
|
|
let inset: CGFloat = 23.0
|
|
let spacing: CGFloat = isTablet ? 9.0 : 40.0
|
|
|
|
var i = 0
|
|
var itemFrame = CGRect(origin: isTablet ? .zero : CGPoint(x: inset, y: 0.0), size: buttonSize)
|
|
var selectedCenter = itemFrame.minX
|
|
var selectedFrame = itemFrame
|
|
|
|
var validKeys: Set<AnyHashable> = Set()
|
|
for mode in component.availableModes.reversed() {
|
|
let id = mode.rawValue
|
|
validKeys.insert(id)
|
|
|
|
let itemView: ItemView
|
|
let selectedItemView: ItemView
|
|
if let current = self.itemViews[id], let currentSelected = self.selectedItemViews[id] {
|
|
itemView = current
|
|
selectedItemView = currentSelected
|
|
} else {
|
|
itemView = ItemView()
|
|
itemView.isUserInteractionEnabled = false
|
|
self.itemViews[id] = itemView
|
|
self.liquidLensView.contentView.addSubview(itemView)
|
|
|
|
selectedItemView = ItemView()
|
|
selectedItemView.isUserInteractionEnabled = false
|
|
self.selectedItemViews[id] = selectedItemView
|
|
self.liquidLensView.selectedContentView.addSubview(selectedItemView)
|
|
}
|
|
|
|
let itemSize = itemView.update(isTablet: component.isTablet, value: mode.title(strings: component.strings), selected: false, tintColor: component.tintColor)
|
|
itemView.bounds = CGRect(origin: .zero, size: itemSize)
|
|
|
|
let _ = selectedItemView.update(isTablet: component.isTablet, value: mode.title(strings: component.strings), selected: true, tintColor: component.tintColor)
|
|
selectedItemView.bounds = CGRect(origin: .zero, size: itemSize)
|
|
|
|
itemFrame = CGRect(origin: itemFrame.origin, size: itemSize)
|
|
|
|
if mode == component.currentMode {
|
|
selectedFrame = itemFrame
|
|
}
|
|
|
|
if isTablet {
|
|
itemView.center = CGPoint(x: availableSize.width / 2.0, y: itemFrame.midY)
|
|
selectedItemView.center = itemView.center
|
|
if mode == component.currentMode {
|
|
selectedCenter = itemFrame.midY
|
|
}
|
|
itemFrame = itemFrame.offsetBy(dx: 0.0, dy: tabletButtonSize.height + spacing)
|
|
} else {
|
|
itemView.center = CGPoint(x: itemFrame.midX, y: itemFrame.midY)
|
|
selectedItemView.center = itemView.center
|
|
if mode == component.currentMode {
|
|
selectedCenter = itemFrame.midX
|
|
}
|
|
itemFrame = itemFrame.offsetBy(dx: itemFrame.width + spacing, dy: 0.0)
|
|
}
|
|
i += 1
|
|
}
|
|
|
|
var removeKeys: [AnyHashable] = []
|
|
for (id, itemView) in self.itemViews {
|
|
if !validKeys.contains(id) {
|
|
removeKeys.append(id)
|
|
|
|
transition.setAlpha(view: itemView, alpha: 0.0, completion: { _ in
|
|
itemView.removeFromSuperview()
|
|
})
|
|
}
|
|
}
|
|
for id in removeKeys {
|
|
self.itemViews.removeValue(forKey: id)
|
|
}
|
|
|
|
let totalSize: CGSize
|
|
let size: CGSize
|
|
if isTablet {
|
|
totalSize = CGSize(width: availableSize.width, height: tabletButtonSize.height * CGFloat(component.availableModes.count) + spacing * CGFloat(component.availableModes.count - 1))
|
|
size = CGSize(width: availableSize.width, height: availableSize.height)
|
|
transition.setFrame(view: self.backgroundView, frame: CGRect(origin: CGPoint(x: 0.0, y: availableSize.height / 2.0 - selectedCenter), size: totalSize))
|
|
} else {
|
|
size = CGSize(width: availableSize.width, height: buttonSize.height)
|
|
totalSize = CGSize(width: itemFrame.minX - spacing + inset, height: buttonSize.height)
|
|
transition.setFrame(view: self.backgroundView, frame: CGRect(origin: CGPoint(x: floorToScreenPixels((availableSize.width - totalSize.width) / 2.0), y: 0.0), size: totalSize))
|
|
}
|
|
|
|
let containerFrame = CGRect(origin: .zero, size: self.backgroundView.frame.size)
|
|
transition.setFrame(view: self.backgroundContainer, frame: containerFrame)
|
|
|
|
let selectionFrame = selectedFrame.insetBy(dx: -23.0, dy: 3.0)
|
|
let lensSelection: (x: CGFloat, width: CGFloat)
|
|
if let selectionGestureState = self.selectionGestureState {
|
|
lensSelection = (selectionGestureState.currentX, selectionFrame.width)
|
|
} else {
|
|
lensSelection = (selectionFrame.minX, selectionFrame.width)
|
|
}
|
|
|
|
transition.setFrame(view: self.liquidLensView, frame: CGRect(origin: CGPoint(x: 0.0, y: 0.0), size: containerFrame.size))
|
|
self.liquidLensView.update(size: containerFrame.size, selectionOrigin: CGPoint(x: lensSelection.x, y: 0.0), selectionSize: CGSize(width: lensSelection.width, height: selectionFrame.height), inset: 0.0, isDark: true, isLifted: self.selectionGestureState != nil, isCollapsed: false, transition: transition)
|
|
self.backgroundContainer.update(size: containerFrame.size, isDark: true, transition: .immediate)
|
|
|
|
return size
|
|
}
|
|
}
|
|
|
|
func makeView() -> View {
|
|
return View()
|
|
}
|
|
|
|
func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
|
|
return view.update(component: self, availableSize: availableSize, state: state, transition: transition)
|
|
}
|
|
}
|
|
|
|
final class HintLabelComponent: Component {
|
|
let text: String
|
|
let tintColor: UIColor
|
|
|
|
init(
|
|
text: String,
|
|
tintColor: UIColor
|
|
) {
|
|
self.text = text
|
|
self.tintColor = tintColor
|
|
}
|
|
|
|
static func ==(lhs: HintLabelComponent, rhs: HintLabelComponent) -> Bool {
|
|
if lhs.text != rhs.text {
|
|
return false
|
|
}
|
|
if lhs.tintColor != rhs.tintColor {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
final class View: UIView {
|
|
private var component: HintLabelComponent?
|
|
private var componentView = ComponentView<Empty>()
|
|
|
|
init() {
|
|
super.init(frame: CGRect())
|
|
}
|
|
|
|
required init?(coder aDecoder: NSCoder) {
|
|
preconditionFailure()
|
|
}
|
|
|
|
func update(component: HintLabelComponent, availableSize: CGSize, transition: ComponentTransition) -> CGSize {
|
|
let previousComponent = self.component
|
|
self.component = component
|
|
|
|
if let previousText = previousComponent?.text, !previousText.isEmpty && previousText != component.text {
|
|
if let componentView = self.componentView.view, let snapshotView = componentView.snapshotView(afterScreenUpdates: false) {
|
|
snapshotView.frame = componentView.frame
|
|
self.addSubview(snapshotView)
|
|
snapshotView.layer.animateScale(from: 1.0, to: 0.1, duration: 0.2, removeOnCompletion: false)
|
|
snapshotView.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, removeOnCompletion: false, completion: { [weak snapshotView] _ in
|
|
snapshotView?.removeFromSuperview()
|
|
})
|
|
}
|
|
|
|
self.componentView.view?.removeFromSuperview()
|
|
self.componentView = ComponentView<Empty>()
|
|
}
|
|
|
|
let textSize = self.componentView.update(
|
|
transition: .immediate,
|
|
component: AnyComponent(
|
|
MultilineTextComponent(
|
|
text: .plain(NSAttributedString(string: component.text.uppercased(), font: Font.with(size: 14.0, design: .camera, weight: .semibold), textColor: component.tintColor)),
|
|
horizontalAlignment: .center
|
|
)
|
|
),
|
|
environment: {},
|
|
containerSize: availableSize
|
|
)
|
|
if let view = self.componentView.view {
|
|
if view.superview == nil {
|
|
view.layer.animateScale(from: 0.1, to: 1.0, duration: 0.2)
|
|
view.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
|
|
self.addSubview(view)
|
|
}
|
|
|
|
view.frame = CGRect(origin: CGPoint(x: floorToScreenPixels((availableSize.width - textSize.width) / 2.0), y: 0.0), size: textSize)
|
|
}
|
|
|
|
return CGSize(width: availableSize.width, height: textSize.height)
|
|
}
|
|
}
|
|
|
|
func makeView() -> View {
|
|
return View()
|
|
}
|
|
|
|
func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
|
|
return view.update(component: self, availableSize: availableSize, transition: transition)
|
|
}
|
|
}
|