mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-16 05:55:20 +00:00
722 lines
29 KiB
Swift
722 lines
29 KiB
Swift
import Foundation
|
|
import UIKit
|
|
import Display
|
|
import ComponentFlow
|
|
import SwiftSignalKit
|
|
import TelegramCore
|
|
import Markdown
|
|
import TextFormat
|
|
import TelegramPresentationData
|
|
import ViewControllerComponent
|
|
import SheetComponent
|
|
import BalancedTextComponent
|
|
import MultilineTextComponent
|
|
import ListSectionComponent
|
|
import ListActionItemComponent
|
|
import ItemListUI
|
|
import UndoUI
|
|
import AccountContext
|
|
|
|
private final class SheetPageContent: CombinedComponent {
|
|
struct Item: Equatable {
|
|
let title: String
|
|
let subItems: [Item]
|
|
}
|
|
|
|
let context: AccountContext
|
|
let title: String?
|
|
let items: [Item]
|
|
let action: (Item) -> Void
|
|
let pop: () -> Void
|
|
|
|
init(
|
|
context: AccountContext,
|
|
title: String?,
|
|
items: [Item],
|
|
action: @escaping (Item) -> Void,
|
|
pop: @escaping () -> Void
|
|
) {
|
|
self.context = context
|
|
self.title = title
|
|
self.items = items
|
|
self.action = action
|
|
self.pop = pop
|
|
}
|
|
|
|
static func ==(lhs: SheetPageContent, rhs: SheetPageContent) -> Bool {
|
|
if lhs.context !== rhs.context {
|
|
return false
|
|
}
|
|
if lhs.title != rhs.title {
|
|
return false
|
|
}
|
|
if lhs.items != rhs.items {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
static var body: Body {
|
|
let background = Child(RoundedRectangle.self)
|
|
let back = Child(Button.self)
|
|
let title = Child(Text.self)
|
|
let subtitle = Child(Text.self)
|
|
let section = Child(ListSectionComponent.self)
|
|
|
|
return { context in
|
|
let component = context.component
|
|
|
|
let presentationData = component.context.sharedContext.currentPresentationData.with { $0 }
|
|
let theme = presentationData.theme
|
|
// let strings = environment.strings
|
|
|
|
let sideInset: CGFloat = 16.0
|
|
|
|
var contentSize = CGSize(width: context.availableSize.width, height: 18.0)
|
|
|
|
let background = background.update(
|
|
component: RoundedRectangle(color: theme.list.modalBlocksBackgroundColor, cornerRadius: 8.0),
|
|
availableSize: CGSize(width: context.availableSize.width, height: 1000.0),
|
|
transition: .immediate
|
|
)
|
|
context.add(background
|
|
.position(CGPoint(x: context.availableSize.width / 2.0, y: background.size.height / 2.0))
|
|
)
|
|
|
|
let back = back.update(
|
|
component: Button(
|
|
content: AnyComponent(
|
|
Text(text: "Cancel", font: Font.regular(17.0), color: theme.list.itemAccentColor)
|
|
),
|
|
action: {
|
|
component.pop()
|
|
}
|
|
),
|
|
availableSize: CGSize(width: context.availableSize.width, height: context.availableSize.height),
|
|
transition: .immediate
|
|
)
|
|
context.add(back
|
|
.position(CGPoint(x: sideInset + back.size.width / 2.0, y: contentSize.height + back.size.height / 2.0))
|
|
)
|
|
|
|
let title = title.update(
|
|
component: Text(text: "Report Ad", font: Font.semibold(17.0), color: theme.list.itemPrimaryTextColor),
|
|
availableSize: CGSize(width: context.availableSize.width, height: context.availableSize.height),
|
|
transition: .immediate
|
|
)
|
|
if let subtitleText = component.title {
|
|
let subtitle = subtitle.update(
|
|
component: Text(text: subtitleText, font: Font.regular(13.0), color: theme.list.itemSecondaryTextColor),
|
|
availableSize: CGSize(width: context.availableSize.width, height: context.availableSize.height),
|
|
transition: .immediate
|
|
)
|
|
context.add(title
|
|
.position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + title.size.height / 2.0 - 8.0))
|
|
)
|
|
contentSize.height += title.size.height
|
|
context.add(subtitle
|
|
.position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + subtitle.size.height / 2.0 - 9.0))
|
|
)
|
|
contentSize.height += subtitle.size.height
|
|
contentSize.height += 24.0
|
|
} else {
|
|
context.add(title
|
|
.position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + title.size.height / 2.0))
|
|
)
|
|
contentSize.height += title.size.height
|
|
contentSize.height += 24.0
|
|
}
|
|
|
|
var items: [AnyComponentWithIdentity<Empty>] = []
|
|
for item in component.items {
|
|
items.append(AnyComponentWithIdentity(id: item.title, component: AnyComponent(ListActionItemComponent(
|
|
theme: theme,
|
|
title: AnyComponent(VStack([
|
|
AnyComponentWithIdentity(id: AnyHashable(0), component: AnyComponent(MultilineTextComponent(
|
|
text: .plain(NSAttributedString(
|
|
string: item.title,
|
|
font: Font.regular(presentationData.listsFontSize.baseDisplaySize),
|
|
textColor: theme.list.itemPrimaryTextColor
|
|
)),
|
|
maximumNumberOfLines: 1
|
|
))),
|
|
], alignment: .left, spacing: 2.0)),
|
|
accessory: !item.subItems.isEmpty ? .arrow : nil,
|
|
action: { _ in
|
|
component.action(item)
|
|
}
|
|
))))
|
|
}
|
|
|
|
let section = section.update(
|
|
component: ListSectionComponent(
|
|
theme: theme,
|
|
header: AnyComponent(MultilineTextComponent(
|
|
text: .plain(NSAttributedString(
|
|
string: "WHAT IS WRONG WITH THIS AD?".uppercased(),
|
|
font: Font.regular(presentationData.listsFontSize.itemListBaseHeaderFontSize),
|
|
textColor: theme.list.freeTextColor
|
|
)),
|
|
maximumNumberOfLines: 0
|
|
)),
|
|
footer: AnyComponent(MultilineTextComponent(
|
|
text: .markdown(
|
|
text: "Learn more about [Telegram Ad Policies and Guidelines]().",
|
|
attributes: MarkdownAttributes(
|
|
body: MarkdownAttributeSet(font: Font.regular(presentationData.listsFontSize.itemListBaseHeaderFontSize), textColor: theme.list.freeTextColor),
|
|
bold: MarkdownAttributeSet(font: Font.semibold(presentationData.listsFontSize.itemListBaseHeaderFontSize), textColor: theme.list.freeTextColor),
|
|
link: MarkdownAttributeSet(font: Font.regular(presentationData.listsFontSize.itemListBaseHeaderFontSize), textColor: theme.list.itemAccentColor),
|
|
linkAttribute: { _ in
|
|
return nil
|
|
}
|
|
)
|
|
),
|
|
maximumNumberOfLines: 0
|
|
)),
|
|
items: items
|
|
),
|
|
environment: {},
|
|
availableSize: CGSize(width: context.availableSize.width - sideInset * 2.0, height: .greatestFiniteMagnitude),
|
|
transition: context.transition
|
|
)
|
|
context.add(section
|
|
.position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + section.size.height / 2.0))
|
|
)
|
|
contentSize.height += section.size.height
|
|
contentSize.height += 54.0
|
|
|
|
return contentSize
|
|
}
|
|
}
|
|
}
|
|
|
|
private final class SheetContent: CombinedComponent {
|
|
typealias EnvironmentType = ViewControllerComponentContainer.Environment
|
|
|
|
let context: AccountContext
|
|
let pts: Int
|
|
let openMore: () -> Void
|
|
let complete: () -> Void
|
|
let dismiss: () -> Void
|
|
let update: (Transition) -> Void
|
|
|
|
init(
|
|
context: AccountContext,
|
|
pts: Int,
|
|
openMore: @escaping () -> Void,
|
|
complete: @escaping () -> Void,
|
|
dismiss: @escaping () -> Void,
|
|
update: @escaping (Transition) -> Void
|
|
) {
|
|
self.context = context
|
|
self.pts = pts
|
|
self.openMore = openMore
|
|
self.complete = complete
|
|
self.dismiss = dismiss
|
|
self.update = update
|
|
}
|
|
|
|
static func ==(lhs: SheetContent, rhs: SheetContent) -> Bool {
|
|
if lhs.context !== rhs.context {
|
|
return false
|
|
}
|
|
if lhs.pts != rhs.pts {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
final class State: ComponentState {
|
|
var pushedItem: SheetPageContent.Item?
|
|
}
|
|
|
|
func makeState() -> State {
|
|
return State()
|
|
}
|
|
|
|
static var body: Body {
|
|
// let title = Child(BalancedTextComponent.self)
|
|
let navigation = Child(NavigationStackComponent.self)
|
|
|
|
return { context in
|
|
let component = context.component
|
|
let state = context.state
|
|
let update = component.update
|
|
|
|
var items: [AnyComponentWithIdentity<Empty>] = []
|
|
items.append(AnyComponentWithIdentity(id: 0, component: AnyComponent(
|
|
SheetPageContent(
|
|
context: component.context,
|
|
title: nil,
|
|
items: [
|
|
SheetPageContent.Item(title: "I don't like it", subItems: []),
|
|
SheetPageContent.Item(title: "I don't want to see ads", subItems: []),
|
|
SheetPageContent.Item(title: "Destination doesn't match the ad", subItems: []),
|
|
SheetPageContent.Item(title: "Word choice or style", subItems: []),
|
|
SheetPageContent.Item(title: "Shocking or sexual content", subItems: []),
|
|
SheetPageContent.Item(title: "Hate speech or threats", subItems: []),
|
|
SheetPageContent.Item(title: "Scam or misleading", subItems: []),
|
|
SheetPageContent.Item(title: "Illegal or questionable products", subItems: [
|
|
SheetPageContent.Item(title: "Drugs, alcohol or tobacco", subItems: []),
|
|
SheetPageContent.Item(title: "Uncertified medicine or supplements", subItems: []),
|
|
SheetPageContent.Item(title: "Weapons or firearms", subItems: []),
|
|
SheetPageContent.Item(title: "Fake money", subItems: []),
|
|
SheetPageContent.Item(title: "Fake documents", subItems: []),
|
|
SheetPageContent.Item(title: "Malware, phishing, hacked accounts", subItems: []),
|
|
SheetPageContent.Item(title: "Human trafficking or exploitation", subItems: []),
|
|
SheetPageContent.Item(title: "Wild or restricted animals", subItems: []),
|
|
SheetPageContent.Item(title: "Gambling", subItems: [])
|
|
]),
|
|
SheetPageContent.Item(title: "Copyright infringement", subItems: []),
|
|
SheetPageContent.Item(title: "Politics or religion", subItems: []),
|
|
SheetPageContent.Item(title: "Spam", subItems: [])
|
|
],
|
|
action: { [weak state] item in
|
|
if !item.subItems.isEmpty {
|
|
state?.pushedItem = item
|
|
update(.spring(duration: 0.45))
|
|
} else {
|
|
component.complete()
|
|
}
|
|
},
|
|
pop: {
|
|
component.dismiss()
|
|
}
|
|
)
|
|
)))
|
|
if let pushedItem = context.state.pushedItem {
|
|
items.append(AnyComponentWithIdentity(id: 1, component: AnyComponent(
|
|
SheetPageContent(
|
|
context: component.context,
|
|
title: pushedItem.title,
|
|
items: pushedItem.subItems.map {
|
|
SheetPageContent.Item(title: $0.title, subItems: [])
|
|
},
|
|
action: { item in
|
|
component.complete()
|
|
},
|
|
pop: { [weak state] in
|
|
state?.pushedItem = nil
|
|
update(.spring(duration: 0.45))
|
|
}
|
|
)
|
|
)))
|
|
}
|
|
|
|
var contentSize = CGSize(width: context.availableSize.width, height: 0.0)
|
|
let navigation = navigation.update(
|
|
component: NavigationStackComponent(items: items),
|
|
availableSize: CGSize(width: context.availableSize.width, height: context.availableSize.height),
|
|
transition: context.transition
|
|
)
|
|
context.add(navigation
|
|
.position(CGPoint(x: context.availableSize.width / 2.0, y: navigation.size.height / 2.0))
|
|
.clipsToBounds(true)
|
|
)
|
|
contentSize.height += navigation.size.height
|
|
|
|
return contentSize
|
|
}
|
|
}
|
|
}
|
|
|
|
private final class SheetContainerComponent: CombinedComponent {
|
|
typealias EnvironmentType = ViewControllerComponentContainer.Environment
|
|
|
|
let context: AccountContext
|
|
let openMore: () -> Void
|
|
let complete: () -> Void
|
|
|
|
init(
|
|
context: AccountContext,
|
|
openMore: @escaping () -> Void,
|
|
complete: @escaping () -> Void
|
|
) {
|
|
self.context = context
|
|
self.openMore = openMore
|
|
self.complete = complete
|
|
}
|
|
|
|
static func ==(lhs: SheetContainerComponent, rhs: SheetContainerComponent) -> Bool {
|
|
if lhs.context !== rhs.context {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
final class State: ComponentState {
|
|
var pts: Int = 0
|
|
}
|
|
|
|
func makeState() -> State {
|
|
return State()
|
|
}
|
|
|
|
static var body: Body {
|
|
let sheet = Child(SheetComponent<EnvironmentType>.self)
|
|
let animateOut = StoredActionSlot(Action<Void>.self)
|
|
|
|
let sheetExternalState = SheetComponent<EnvironmentType>.ExternalState()
|
|
|
|
return { context in
|
|
let environment = context.environment[EnvironmentType.self]
|
|
let state = context.state
|
|
let controller = environment.controller
|
|
|
|
let sheet = sheet.update(
|
|
component: SheetComponent<EnvironmentType>(
|
|
content: AnyComponent<EnvironmentType>(SheetContent(
|
|
context: context.component.context,
|
|
pts: state.pts,
|
|
openMore: context.component.openMore,
|
|
complete: context.component.complete,
|
|
dismiss: {
|
|
animateOut.invoke(Action { _ in
|
|
if let controller = controller() {
|
|
controller.dismiss(completion: nil)
|
|
}
|
|
})
|
|
},
|
|
update: { [weak state] transition in
|
|
state?.pts += 1
|
|
state?.updated(transition: transition)
|
|
}
|
|
)),
|
|
backgroundColor: .color(environment.theme.list.modalBlocksBackgroundColor),
|
|
followContentSizeChanges: true,
|
|
externalState: sheetExternalState,
|
|
animateOut: animateOut
|
|
),
|
|
environment: {
|
|
environment
|
|
SheetComponentEnvironment(
|
|
isDisplaying: environment.value.isVisible,
|
|
isCentered: environment.metrics.widthClass == .regular,
|
|
hasInputHeight: !environment.inputHeight.isZero,
|
|
regularMetricsSize: CGSize(width: 430.0, height: 900.0),
|
|
dismiss: { animated in
|
|
if animated {
|
|
animateOut.invoke(Action { _ in
|
|
if let controller = controller() {
|
|
controller.dismiss(completion: nil)
|
|
}
|
|
})
|
|
} else {
|
|
if let controller = controller() {
|
|
controller.dismiss(completion: nil)
|
|
}
|
|
}
|
|
}
|
|
)
|
|
},
|
|
availableSize: context.availableSize,
|
|
transition: context.transition
|
|
)
|
|
|
|
context.add(sheet
|
|
.position(CGPoint(x: context.availableSize.width / 2.0, y: context.availableSize.height / 2.0))
|
|
)
|
|
|
|
if let controller = controller(), !controller.automaticallyControlPresentationContextLayout {
|
|
let layout = ContainerViewLayout(
|
|
size: context.availableSize,
|
|
metrics: environment.metrics,
|
|
deviceMetrics: environment.deviceMetrics,
|
|
intrinsicInsets: UIEdgeInsets(top: 0.0, left: 0.0, bottom: max(environment.safeInsets.bottom, sheetExternalState.contentHeight), right: 0.0),
|
|
safeInsets: UIEdgeInsets(top: 0.0, left: environment.safeInsets.left, bottom: 0.0, right: environment.safeInsets.right),
|
|
additionalInsets: .zero,
|
|
statusBarHeight: environment.statusBarHeight,
|
|
inputHeight: nil,
|
|
inputHeightIsInteractivellyChanging: false,
|
|
inVoiceOver: false
|
|
)
|
|
controller.presentationContext.containerLayoutUpdated(layout, transition: context.transition.containedViewLayoutTransition)
|
|
}
|
|
|
|
return context.availableSize
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public final class AdsReportScreen: ViewControllerComponentContainer {
|
|
private let context: AccountContext
|
|
|
|
public init(
|
|
context: AccountContext
|
|
) {
|
|
self.context = context
|
|
|
|
var completeImpl: (() -> Void)?
|
|
super.init(
|
|
context: context,
|
|
component: SheetContainerComponent(
|
|
context: context,
|
|
openMore: {},
|
|
complete: {
|
|
completeImpl?()
|
|
}
|
|
),
|
|
navigationBarAppearance: .none,
|
|
statusBarStyle: .ignore,
|
|
theme: .default
|
|
)
|
|
|
|
self.navigationPresentation = .flatModal
|
|
|
|
completeImpl = { [weak self] in
|
|
guard let self else {
|
|
return
|
|
}
|
|
let navigationController = self.navigationController
|
|
self.dismissAnimated()
|
|
|
|
Queue.mainQueue().after(0.4, {
|
|
//TODO:localize
|
|
let presentationData = context.sharedContext.currentPresentationData.with { $0 }
|
|
(navigationController?.viewControllers.last as? ViewController)?.present(UndoOverlayController(presentationData: presentationData, content: .actionSucceeded(title: nil, text: "We will review this ad to ensure it matches our [Ad Policies and Guidelines]().", cancel: nil, destructive: false), elevatedLayout: false, action: { _ in
|
|
return true
|
|
}), in: .current)
|
|
})
|
|
}
|
|
}
|
|
|
|
required public init(coder aDecoder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
public override func viewDidLoad() {
|
|
super.viewDidLoad()
|
|
|
|
self.view.disablesInteractiveModalDismiss = true
|
|
}
|
|
|
|
public func dismissAnimated() {
|
|
if let view = self.node.hostView.findTaggedView(tag: SheetComponent<ViewControllerComponentContainer.Environment>.View.Tag()) as? SheetComponent<ViewControllerComponentContainer.Environment>.View {
|
|
view.dismissAnimated()
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//private final class NavigationContainer: UIView, UIGestureRecognizerDelegate {
|
|
// var requestUpdate: ((Transition) -> Void)?
|
|
// var requestPop: (() -> Void)?
|
|
// var transitionFraction: CGFloat = 0.0
|
|
//
|
|
// private var panRecognizer: InteractiveTransitionGestureRecognizer?
|
|
//
|
|
// var isNavigationEnabled: Bool = false {
|
|
// didSet {
|
|
// self.panRecognizer?.isEnabled = self.isNavigationEnabled
|
|
// }
|
|
// }
|
|
//
|
|
// override init() {
|
|
// super.init()
|
|
//
|
|
// self.clipsToBounds = true
|
|
//
|
|
// let panRecognizer = InteractiveTransitionGestureRecognizer(target: self, action: #selector(self.panGesture(_:)), allowedDirections: { [weak self] point in
|
|
// guard let strongSelf = self else {
|
|
// return []
|
|
// }
|
|
// let _ = strongSelf
|
|
// return [.right]
|
|
// })
|
|
// panRecognizer.delegate = self
|
|
// self.view.addGestureRecognizer(panRecognizer)
|
|
// self.panRecognizer = panRecognizer
|
|
// }
|
|
//
|
|
// func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
|
|
// return false
|
|
// }
|
|
//
|
|
// func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldBeRequiredToFailBy otherGestureRecognizer: UIGestureRecognizer) -> Bool {
|
|
// if let _ = otherGestureRecognizer as? InteractiveTransitionGestureRecognizer {
|
|
// return false
|
|
// }
|
|
// if let _ = otherGestureRecognizer as? UIPanGestureRecognizer {
|
|
// return true
|
|
// }
|
|
// return false
|
|
// }
|
|
//
|
|
// @objc private func panGesture(_ recognizer: UIPanGestureRecognizer) {
|
|
// switch recognizer.state {
|
|
// case .began:
|
|
// self.transitionFraction = 0.0
|
|
// case .changed:
|
|
// let distanceFactor: CGFloat = recognizer.translation(in: self.view).x / self.bounds.width
|
|
// let transitionFraction = max(0.0, min(1.0, distanceFactor))
|
|
// if self.transitionFraction != transitionFraction {
|
|
// self.transitionFraction = transitionFraction
|
|
// self.requestUpdate?(.immediate)
|
|
// }
|
|
// case .ended, .cancelled:
|
|
// let distanceFactor: CGFloat = recognizer.translation(in: self.view).x / self.bounds.width
|
|
// let transitionFraction = max(0.0, min(1.0, distanceFactor))
|
|
// if transitionFraction > 0.2 {
|
|
// self.transitionFraction = 0.0
|
|
// self.requestPop?()
|
|
// } else {
|
|
// self.transitionFraction = 0.0
|
|
// self.requestUpdate?(.spring(duration: 0.45))
|
|
// }
|
|
// default:
|
|
// break
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
final class NavigationStackComponent: Component {
|
|
public let items: [AnyComponentWithIdentity<Empty>]
|
|
|
|
public init(
|
|
items: [AnyComponentWithIdentity<Empty>]
|
|
) {
|
|
self.items = items
|
|
}
|
|
|
|
public static func ==(lhs: NavigationStackComponent, rhs: NavigationStackComponent) -> Bool {
|
|
if lhs.items != rhs.items {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
private final class ItemView: UIView {
|
|
let contents = ComponentView<Empty>()
|
|
|
|
override init(frame: CGRect) {
|
|
super.init(frame: frame)
|
|
}
|
|
|
|
required init?(coder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
}
|
|
|
|
public final class View: UIView {
|
|
private var itemViews: [AnyHashable: ItemView] = [:]
|
|
|
|
private var component: NavigationStackComponent?
|
|
|
|
public override init(frame: CGRect) {
|
|
super.init(frame: CGRect())
|
|
}
|
|
|
|
required public init?(coder: NSCoder) {
|
|
preconditionFailure()
|
|
}
|
|
|
|
func update(component: NavigationStackComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: Transition) -> CGSize {
|
|
self.component = component
|
|
|
|
var contentHeight: CGFloat = 0.0
|
|
|
|
var validItemIds: [AnyHashable] = []
|
|
struct ReadyItem {
|
|
var index: Int
|
|
var itemId: AnyHashable
|
|
var itemView: ItemView
|
|
var itemTransition: Transition
|
|
var itemSize: CGSize
|
|
|
|
init(index: Int, itemId: AnyHashable, itemView: ItemView, itemTransition: Transition, itemSize: CGSize) {
|
|
self.index = index
|
|
self.itemId = itemId
|
|
self.itemView = itemView
|
|
self.itemTransition = itemTransition
|
|
self.itemSize = itemSize
|
|
}
|
|
}
|
|
|
|
var readyItems: [ReadyItem] = []
|
|
for i in 0 ..< component.items.count {
|
|
let item = component.items[i]
|
|
let itemId = item.id
|
|
validItemIds.append(itemId)
|
|
|
|
let itemView: ItemView
|
|
var itemTransition = transition
|
|
if let current = self.itemViews[itemId] {
|
|
itemView = current
|
|
} else {
|
|
itemTransition = itemTransition.withAnimation(.none)
|
|
itemView = ItemView()
|
|
itemView.clipsToBounds = true
|
|
self.itemViews[itemId] = itemView
|
|
itemView.contents.parentState = state
|
|
}
|
|
|
|
let itemSize = itemView.contents.update(
|
|
transition: itemTransition,
|
|
component: item.component,
|
|
environment: {},
|
|
containerSize: CGSize(width: availableSize.width, height: availableSize.height)
|
|
)
|
|
|
|
readyItems.append(ReadyItem(
|
|
index: i,
|
|
itemId: itemId,
|
|
itemView: itemView,
|
|
itemTransition: itemTransition,
|
|
itemSize: itemSize
|
|
))
|
|
|
|
if i == component.items.count - 1 {
|
|
contentHeight = itemSize.height
|
|
}
|
|
}
|
|
|
|
for readyItem in readyItems.sorted(by: { $0.index < $1.index }) {
|
|
let itemFrame = CGRect(origin: CGPoint(x: 0.0, y: 0.0), size: readyItem.itemSize)
|
|
if let itemComponentView = readyItem.itemView.contents.view {
|
|
var isAdded = false
|
|
if itemComponentView.superview == nil {
|
|
isAdded = true
|
|
self.addSubview(itemComponentView)
|
|
}
|
|
readyItem.itemTransition.setFrame(view: readyItem.itemView, frame: itemFrame)
|
|
readyItem.itemTransition.setFrame(view: itemComponentView, frame: CGRect(origin: CGPoint(), size: itemFrame.size))
|
|
|
|
if readyItem.index > 0 && isAdded {
|
|
transition.animatePosition(view: itemComponentView, from: CGPoint(x: itemFrame.width, y: 0.0), to: .zero, additive: true, completion: nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
var removedItemIds: [AnyHashable] = []
|
|
for (id, _) in self.itemViews {
|
|
if !validItemIds.contains(id) {
|
|
removedItemIds.append(id)
|
|
}
|
|
}
|
|
for id in removedItemIds {
|
|
guard let itemView = self.itemViews[id] else {
|
|
continue
|
|
}
|
|
var position = itemView.center
|
|
position.x += itemView.bounds.width / 2.0
|
|
transition.setPosition(view: itemView, position: position, completion: { _ in
|
|
itemView.removeFromSuperview()
|
|
self.itemViews.removeValue(forKey: id)
|
|
})
|
|
}
|
|
|
|
return CGSize(width: availableSize.width, height: contentHeight)
|
|
}
|
|
}
|
|
|
|
public func makeView() -> View {
|
|
return View(frame: CGRect())
|
|
}
|
|
|
|
public func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: Transition) -> CGSize {
|
|
return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
|
|
}
|
|
}
|