mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-15 21:45:19 +00:00
963 lines
39 KiB
Swift
963 lines
39 KiB
Swift
import Foundation
|
|
import UIKit
|
|
import AsyncDisplayKit
|
|
import Display
|
|
import ComponentFlow
|
|
import SwiftSignalKit
|
|
import Postbox
|
|
import TelegramCore
|
|
import Markdown
|
|
import TextFormat
|
|
import TelegramPresentationData
|
|
import ViewControllerComponent
|
|
import SheetComponent
|
|
import BalancedTextComponent
|
|
import MultilineTextComponent
|
|
import BundleIconComponent
|
|
import ItemListUI
|
|
import AccountContext
|
|
import PresentationDataUtils
|
|
import ListSectionComponent
|
|
import TelegramStringFormatting
|
|
import MediaEditor
|
|
import UrlEscaping
|
|
|
|
private let linkTag = GenericComponentViewTag()
|
|
|
|
private final class SheetContent: CombinedComponent {
|
|
typealias EnvironmentType = ViewControllerComponentContainer.Environment
|
|
|
|
let context: AccountContext
|
|
let isEdit: Bool
|
|
let link: String
|
|
let webpage: TelegramMediaWebpage?
|
|
let state: CreateLinkSheetComponent.State
|
|
let dismiss: () -> Void
|
|
|
|
init(
|
|
context: AccountContext,
|
|
isEdit: Bool,
|
|
link: String,
|
|
webpage: TelegramMediaWebpage?,
|
|
state: CreateLinkSheetComponent.State,
|
|
dismiss: @escaping () -> Void
|
|
) {
|
|
self.context = context
|
|
self.isEdit = isEdit
|
|
self.link = link
|
|
self.webpage = webpage
|
|
self.state = state
|
|
self.dismiss = dismiss
|
|
}
|
|
|
|
static func ==(lhs: SheetContent, rhs: SheetContent) -> Bool {
|
|
if lhs.context !== rhs.context {
|
|
return false
|
|
}
|
|
if lhs.isEdit != rhs.isEdit {
|
|
return false
|
|
}
|
|
if lhs.link != rhs.link {
|
|
return false
|
|
}
|
|
if lhs.webpage != rhs.webpage {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
static var body: Body {
|
|
let background = Child(RoundedRectangle.self)
|
|
let cancelButton = Child(Button.self)
|
|
let doneButton = Child(Button.self)
|
|
let title = Child(Text.self)
|
|
let urlSection = Child(ListSectionComponent.self)
|
|
let nameSection = Child(ListSectionComponent.self)
|
|
|
|
return { context in
|
|
let environment = context.environment[EnvironmentType.self]
|
|
let component = context.component
|
|
let state = component.state
|
|
|
|
let theme = environment.theme.withModalBlocksBackground()
|
|
let strings = environment.strings
|
|
let presentationData = component.context.sharedContext.currentPresentationData.with { $0 }
|
|
|
|
let sideInset: CGFloat = 16.0
|
|
var contentSize = CGSize(width: context.availableSize.width, height: 18.0)
|
|
|
|
let background = background.update(
|
|
component: RoundedRectangle(color: theme.list.blocksBackgroundColor, 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 constrainedTitleWidth = context.availableSize.width - 16.0 * 2.0
|
|
|
|
let cancelButton = cancelButton.update(
|
|
component: Button(
|
|
content: AnyComponent(
|
|
Text(
|
|
text: strings.Common_Cancel,
|
|
font: Font.regular(17.0),
|
|
color: theme.actionSheet.controlAccentColor
|
|
)
|
|
),
|
|
action: {
|
|
component.dismiss()
|
|
}
|
|
),
|
|
availableSize: context.availableSize,
|
|
transition: .immediate
|
|
)
|
|
context.add(cancelButton
|
|
.position(CGPoint(x: sideInset + cancelButton.size.width / 2.0, y: contentSize.height + cancelButton.size.height / 2.0))
|
|
)
|
|
|
|
let explicitLink = explicitUrl(context.component.link)
|
|
var isValidLink = false
|
|
if isValidUrl(explicitLink) {
|
|
isValidLink = true
|
|
}
|
|
|
|
let controller = environment.controller
|
|
let doneButton = doneButton.update(
|
|
component: Button(
|
|
content: AnyComponent(
|
|
Text(
|
|
text: strings.Common_Done,
|
|
font: Font.bold(17.0),
|
|
color: state.link.isEmpty ? theme.actionSheet.secondaryTextColor : theme.actionSheet.controlAccentColor
|
|
)
|
|
),
|
|
isEnabled: isValidLink,
|
|
action: { [weak state] in
|
|
if let controller = controller() as? CreateLinkScreen {
|
|
state?.complete(controller: controller)
|
|
}
|
|
component.dismiss()
|
|
}
|
|
),
|
|
availableSize: context.availableSize,
|
|
transition: .immediate
|
|
)
|
|
context.add(doneButton
|
|
.position(CGPoint(x: context.availableSize.width - sideInset - doneButton.size.width / 2.0, y: contentSize.height + doneButton.size.height / 2.0))
|
|
)
|
|
|
|
|
|
let title = title.update(
|
|
component: Text(text: component.isEdit ? strings.MediaEditor_Link_EditTitle : strings.MediaEditor_Link_CreateTitle, font: Font.bold(17.0), color: theme.list.itemPrimaryTextColor),
|
|
availableSize: CGSize(width: constrainedTitleWidth, 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))
|
|
)
|
|
contentSize.height += title.size.height
|
|
contentSize.height += 40.0
|
|
|
|
var urlItems: [AnyComponentWithIdentity<Empty>] = []
|
|
if let webpage = state.webpage, case .Loaded = webpage.content, !state.dismissed {
|
|
urlItems.append(
|
|
AnyComponentWithIdentity(
|
|
id: "webpage",
|
|
component: AnyComponent(
|
|
LinkPreviewComponent(
|
|
webpage: webpage,
|
|
theme: theme,
|
|
strings: strings,
|
|
presentLinkOptions: { [weak state] sourceNode in
|
|
if let controller = controller() as? CreateLinkScreen {
|
|
state?.presentLinkOptions(controller: controller, sourceNode: sourceNode)
|
|
}
|
|
},
|
|
dismiss: { [weak state] in
|
|
state?.dismissed = true
|
|
state?.updated(transition: .easeInOut(duration: 0.25))
|
|
}
|
|
)
|
|
)
|
|
)
|
|
)
|
|
}
|
|
urlItems.append(
|
|
AnyComponentWithIdentity(
|
|
id: "url",
|
|
component: AnyComponent(
|
|
LinkFieldComponent(
|
|
textColor: theme.list.itemPrimaryTextColor,
|
|
placeholderColor: theme.list.itemPlaceholderTextColor,
|
|
text: state.link,
|
|
link: true,
|
|
placeholderText: strings.MediaEditor_Link_LinkTo_Placeholder,
|
|
textUpdated: { [weak state] text in
|
|
state?.link = text
|
|
state?.updated()
|
|
},
|
|
tag: linkTag
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
let urlSection = urlSection.update(
|
|
component: ListSectionComponent(
|
|
theme: theme,
|
|
header: AnyComponent(MultilineTextComponent(
|
|
text: .plain(NSAttributedString(
|
|
string: strings.MediaEditor_Link_LinkTo_Title.uppercased(),
|
|
font: Font.regular(presentationData.listsFontSize.itemListBaseHeaderFontSize),
|
|
textColor: theme.list.freeTextColor
|
|
)),
|
|
maximumNumberOfLines: 0
|
|
)),
|
|
footer: nil,
|
|
items: urlItems,
|
|
displaySeparators: false
|
|
),
|
|
environment: {},
|
|
availableSize: CGSize(width: context.availableSize.width - sideInset * 2.0, height: .greatestFiniteMagnitude),
|
|
transition: context.transition
|
|
)
|
|
context.add(urlSection
|
|
.position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + urlSection.size.height / 2.0))
|
|
.clipsToBounds(true)
|
|
.cornerRadius(10.0)
|
|
)
|
|
contentSize.height += urlSection.size.height
|
|
contentSize.height += 30.0
|
|
|
|
let nameSection = nameSection.update(
|
|
component: ListSectionComponent(
|
|
theme: theme,
|
|
header: AnyComponent(MultilineTextComponent(
|
|
text: .plain(NSAttributedString(
|
|
string: strings.MediaEditor_Link_LinkName_Title.uppercased(),
|
|
font: Font.regular(presentationData.listsFontSize.itemListBaseHeaderFontSize),
|
|
textColor: theme.list.freeTextColor
|
|
)),
|
|
maximumNumberOfLines: 0
|
|
)),
|
|
footer: nil,
|
|
items: [
|
|
AnyComponentWithIdentity(
|
|
id: "name",
|
|
component: AnyComponent(
|
|
LinkFieldComponent(
|
|
textColor: theme.list.itemPrimaryTextColor,
|
|
placeholderColor: theme.list.itemPlaceholderTextColor,
|
|
text: state.name,
|
|
link: false,
|
|
placeholderText: strings.MediaEditor_Link_LinkTo_Placeholder,
|
|
textUpdated: { [weak state] text in
|
|
state?.name = text
|
|
}
|
|
)
|
|
)
|
|
)
|
|
]
|
|
),
|
|
environment: {},
|
|
availableSize: CGSize(width: context.availableSize.width - sideInset * 2.0, height: .greatestFiniteMagnitude),
|
|
transition: context.transition
|
|
)
|
|
context.add(nameSection
|
|
.position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + nameSection.size.height / 2.0))
|
|
.clipsToBounds(true)
|
|
.cornerRadius(10.0)
|
|
)
|
|
contentSize.height += nameSection.size.height
|
|
contentSize.height += 32.0
|
|
|
|
contentSize.height += max(environment.inputHeight, environment.safeInsets.bottom)
|
|
|
|
return contentSize
|
|
}
|
|
}
|
|
}
|
|
|
|
private final class CreateLinkSheetComponent: CombinedComponent {
|
|
typealias EnvironmentType = ViewControllerComponentContainer.Environment
|
|
|
|
private let context: AccountContext
|
|
private let link: CreateLinkScreen.Link?
|
|
|
|
init(
|
|
context: AccountContext,
|
|
link: CreateLinkScreen.Link?
|
|
) {
|
|
self.context = context
|
|
self.link = link
|
|
}
|
|
|
|
static func ==(lhs: CreateLinkSheetComponent, rhs: CreateLinkSheetComponent) -> Bool {
|
|
if lhs.context !== rhs.context {
|
|
return false
|
|
}
|
|
if lhs.link != rhs.link {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
final class State: ComponentState {
|
|
private let context: AccountContext
|
|
|
|
fileprivate var link: String = "" {
|
|
didSet {
|
|
self.linkPromise.set(self.link)
|
|
}
|
|
}
|
|
fileprivate var name: String = ""
|
|
fileprivate var webpage: TelegramMediaWebpage?
|
|
fileprivate var isDark = false
|
|
fileprivate var dismissed = false
|
|
|
|
private var positionBelowText = true
|
|
private var largeMedia: Bool? = nil
|
|
|
|
private let previewDisposable = MetaDisposable()
|
|
|
|
private let linkDisposable = MetaDisposable()
|
|
private let linkPromise = ValuePromise<String>()
|
|
|
|
init(
|
|
context: AccountContext,
|
|
link: CreateLinkScreen.Link?
|
|
) {
|
|
self.context = context
|
|
|
|
self.link = link?.url ?? ""
|
|
self.name = link?.name ?? ""
|
|
self.webpage = link?.webpage
|
|
self.isDark = link?.isDark ?? false
|
|
self.positionBelowText = link?.positionBelowText ?? true
|
|
self.largeMedia = link?.largeMedia
|
|
|
|
super.init()
|
|
|
|
self.linkDisposable.set((self.linkPromise.get()
|
|
|> delay(1.5, queue: Queue.mainQueue())
|
|
|> deliverOnMainQueue).startStrict(next: { [weak self] link in
|
|
guard let self else {
|
|
return
|
|
}
|
|
|
|
guard !link.isEmpty else {
|
|
self.dismissed = false
|
|
self.previewDisposable.set(nil)
|
|
self.webpage = nil
|
|
self.updated(transition: .easeInOut(duration: 0.25))
|
|
return
|
|
}
|
|
|
|
let link = explicitUrl(link)
|
|
|
|
if self.dismissed {
|
|
self.dismissed = false
|
|
self.webpage = nil
|
|
}
|
|
self.previewDisposable.set(
|
|
(webpagePreview(account: context.account, urls: [link])
|
|
|> deliverOnMainQueue).startStrict(next: { [weak self] result in
|
|
guard let self else {
|
|
return
|
|
}
|
|
switch result {
|
|
case let .result(result):
|
|
self.webpage = result?.webpage
|
|
case .progress:
|
|
self.webpage = nil
|
|
}
|
|
self.updated(transition: .easeInOut(duration: 0.25))
|
|
})
|
|
)
|
|
}))
|
|
}
|
|
|
|
deinit {
|
|
self.previewDisposable.dispose()
|
|
self.linkDisposable.dispose()
|
|
}
|
|
|
|
func presentLinkOptions(controller: CreateLinkScreen, sourceNode: ASDisplayNode) {
|
|
guard let webpage = self.webpage else {
|
|
return
|
|
}
|
|
let link = explicitUrl(self.link)
|
|
var name: String = self.name
|
|
if name.isEmpty {
|
|
name = self.link
|
|
}
|
|
|
|
presentLinkOptionsController(context: self.context, selfController: controller, snapshotImage: controller.snapshotImage, isDark: self.isDark, sourceNode: sourceNode, url: link, name: name, positionBelowText: self.positionBelowText, largeMedia: self.largeMedia, webPage: webpage, completion: { [weak self] positionBelowText, largeMedia in
|
|
guard let self else {
|
|
return
|
|
}
|
|
self.positionBelowText = positionBelowText
|
|
self.largeMedia = largeMedia
|
|
}, remove: { [weak self] in
|
|
guard let self else {
|
|
return
|
|
}
|
|
self.dismissed = true
|
|
self.updated(transition: .easeInOut(duration: 0.25))
|
|
})
|
|
}
|
|
|
|
func complete(controller: CreateLinkScreen) {
|
|
let text = !self.name.isEmpty ? self.name : self.link
|
|
|
|
var effectiveMedia: TelegramMediaWebpage?
|
|
if let webpage = self.webpage, case .Loaded = webpage.content, !self.dismissed {
|
|
effectiveMedia = webpage
|
|
}
|
|
|
|
var attributes: [MessageAttribute] = []
|
|
attributes.append(TextEntitiesMessageAttribute(entities: [.init(range: 0 ..< (text as NSString).length, type: .Url)]))
|
|
if !self.dismissed {
|
|
attributes.append(WebpagePreviewMessageAttribute(leadingPreview: !self.positionBelowText, forceLargeMedia: self.largeMedia, isManuallyAdded: false, isSafe: true))
|
|
}
|
|
|
|
let peerId = PeerId(namespace: Namespaces.Peer.CloudUser, id: PeerId.Id._internalFromInt64Value(1))
|
|
let message = Message(stableId: 1, stableVersion: 0, id: MessageId(peerId: peerId, namespace: 0, id: 1), globallyUniqueId: nil, groupingKey: nil, groupInfo: nil, threadId: nil, timestamp: 0, flags: [.Incoming], tags: [], globalTags: [], localTags: [], customTags: [], forwardInfo: nil, author: nil, text: text, attributes: attributes, media: effectiveMedia.flatMap { [$0] } ?? [], peers: SimpleDictionary(), associatedMessages: SimpleDictionary(), associatedMessageIds: [], associatedMedia: [:], associatedThreadInfo: nil, associatedStories: [:])
|
|
|
|
|
|
let completion = controller.completion
|
|
let renderer = DrawingMessageRenderer(context: self.context, messages: [message], parentView: controller.view, isLink: true)
|
|
renderer.render(completion: { result in
|
|
completion(
|
|
CreateLinkScreen.Result(
|
|
url: self.link,
|
|
name: self.name,
|
|
webpage: effectiveMedia,
|
|
positionBelowText: self.positionBelowText,
|
|
largeMedia: self.largeMedia,
|
|
image: effectiveMedia != nil ? result.dayImage : nil,
|
|
nightImage: effectiveMedia != nil ? result.nightImage : nil
|
|
)
|
|
)
|
|
})
|
|
}
|
|
}
|
|
|
|
func makeState() -> State {
|
|
return State(context: self.context, link: self.link)
|
|
}
|
|
|
|
static var body: Body {
|
|
let sheet = Child(SheetComponent<(EnvironmentType)>.self)
|
|
let animateOut = StoredActionSlot(Action<Void>.self)
|
|
|
|
return { context in
|
|
let environment = context.environment[EnvironmentType.self]
|
|
|
|
let controller = environment.controller
|
|
|
|
var webpage = context.state.webpage
|
|
if context.state.dismissed {
|
|
webpage = nil
|
|
}
|
|
|
|
let link = context.state.link
|
|
|
|
let sheet = sheet.update(
|
|
component: SheetComponent<EnvironmentType>(
|
|
content: AnyComponent<EnvironmentType>(SheetContent(
|
|
context: context.component.context,
|
|
isEdit: context.component.link != nil,
|
|
link: link,
|
|
webpage: webpage,
|
|
state: context.state,
|
|
dismiss: {
|
|
animateOut.invoke(Action { _ in
|
|
if let controller = controller() {
|
|
controller.dismiss(completion: nil)
|
|
}
|
|
})
|
|
}
|
|
)),
|
|
backgroundColor: .blur(.dark),
|
|
followContentSizeChanges: true,
|
|
clipsContent: true,
|
|
isScrollEnabled: false,
|
|
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))
|
|
)
|
|
|
|
return context.availableSize
|
|
}
|
|
}
|
|
}
|
|
|
|
public final class CreateLinkScreen: ViewControllerComponentContainer {
|
|
public struct Link: Equatable {
|
|
let url: String
|
|
let name: String?
|
|
let webpage: TelegramMediaWebpage?
|
|
let positionBelowText: Bool
|
|
let largeMedia: Bool?
|
|
let isDark: Bool
|
|
|
|
init(
|
|
url: String,
|
|
name: String?,
|
|
webpage: TelegramMediaWebpage?,
|
|
positionBelowText: Bool,
|
|
largeMedia: Bool?,
|
|
isDark: Bool
|
|
) {
|
|
self.url = url
|
|
self.name = name
|
|
self.webpage = webpage
|
|
self.positionBelowText = positionBelowText
|
|
self.largeMedia = largeMedia
|
|
self.isDark = isDark
|
|
}
|
|
}
|
|
|
|
public struct Result {
|
|
let url: String
|
|
let name: String
|
|
let webpage: TelegramMediaWebpage?
|
|
let positionBelowText: Bool
|
|
let largeMedia: Bool?
|
|
let image: UIImage?
|
|
let nightImage: UIImage?
|
|
}
|
|
|
|
private let context: AccountContext
|
|
fileprivate let snapshotImage: UIImage?
|
|
fileprivate let completion: (CreateLinkScreen.Result) -> Void
|
|
|
|
public init(
|
|
context: AccountContext,
|
|
link: CreateLinkScreen.Link?,
|
|
snapshotImage: UIImage?,
|
|
completion: @escaping (CreateLinkScreen.Result) -> Void
|
|
) {
|
|
self.context = context
|
|
self.snapshotImage = snapshotImage
|
|
self.completion = completion
|
|
|
|
super.init(
|
|
context: context,
|
|
component: CreateLinkSheetComponent(
|
|
context: context,
|
|
link: link
|
|
),
|
|
navigationBarAppearance: .none,
|
|
statusBarStyle: .ignore,
|
|
theme: .dark
|
|
)
|
|
|
|
self.navigationPresentation = .flatModal
|
|
}
|
|
|
|
required public init(coder aDecoder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
public override func viewDidAppear(_ animated: Bool) {
|
|
super.viewDidAppear(animated)
|
|
|
|
if let view = self.node.hostView.findTaggedView(tag: linkTag) as? LinkFieldComponent.View {
|
|
view.activateInput()
|
|
}
|
|
}
|
|
|
|
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 LinkFieldComponent: Component {
|
|
typealias EnvironmentType = Empty
|
|
|
|
let textColor: UIColor
|
|
let placeholderColor: UIColor
|
|
let text: String
|
|
let link: Bool
|
|
let placeholderText: String
|
|
let textUpdated: (String) -> Void
|
|
let tag: AnyObject?
|
|
|
|
init(
|
|
textColor: UIColor,
|
|
placeholderColor: UIColor,
|
|
text: String,
|
|
link: Bool,
|
|
placeholderText: String,
|
|
textUpdated: @escaping (String) -> Void,
|
|
tag: AnyObject? = nil
|
|
) {
|
|
self.textColor = textColor
|
|
self.placeholderColor = placeholderColor
|
|
self.text = text
|
|
self.link = link
|
|
self.placeholderText = placeholderText
|
|
self.textUpdated = textUpdated
|
|
self.tag = tag
|
|
}
|
|
|
|
static func ==(lhs: LinkFieldComponent, rhs: LinkFieldComponent) -> Bool {
|
|
if lhs.textColor != rhs.textColor {
|
|
return false
|
|
}
|
|
if lhs.placeholderColor != rhs.placeholderColor {
|
|
return false
|
|
}
|
|
if lhs.text != rhs.text {
|
|
return false
|
|
}
|
|
if lhs.placeholderText != rhs.placeholderText {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
final class View: UIView, UITextFieldDelegate, ComponentTaggedView {
|
|
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
|
|
}
|
|
|
|
private let placeholderView: ComponentView<Empty>
|
|
private let textField: TextFieldNodeView
|
|
|
|
private var component: LinkFieldComponent?
|
|
private weak var state: EmptyComponentState?
|
|
|
|
override init(frame: CGRect) {
|
|
self.placeholderView = ComponentView<Empty>()
|
|
self.textField = TextFieldNodeView(frame: .zero)
|
|
|
|
super.init(frame: frame)
|
|
|
|
self.textField.delegate = self
|
|
self.textField.addTarget(self, action: #selector(self.textChanged(_:)), for: .editingChanged)
|
|
|
|
self.addSubview(self.textField)
|
|
}
|
|
|
|
required init?(coder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
@objc func textChanged(_ sender: Any) {
|
|
let text = self.textField.text ?? ""
|
|
self.component?.textUpdated(text)
|
|
self.placeholderView.view?.isHidden = !text.isEmpty
|
|
}
|
|
|
|
func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
|
|
let newText = ((textField.text ?? "") as NSString).replacingCharacters(in: range, with: string)
|
|
if let component = self.component, !component.link && newText.count > 48 {
|
|
textField.layer.addShakeAnimation()
|
|
let hapticFeedback = HapticFeedback()
|
|
hapticFeedback.error()
|
|
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 1.0, execute: {
|
|
let _ = hapticFeedback
|
|
})
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func activateInput() {
|
|
self.textField.becomeFirstResponder()
|
|
}
|
|
|
|
func update(component: LinkFieldComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<EnvironmentType>, transition: ComponentTransition) -> CGSize {
|
|
self.textField.textColor = component.textColor
|
|
self.textField.text = component.text
|
|
self.textField.font = Font.regular(17.0)
|
|
self.textField.keyboardAppearance = .dark
|
|
|
|
if component.link {
|
|
self.textField.keyboardType = .default
|
|
self.textField.returnKeyType = .next
|
|
self.textField.autocorrectionType = .no
|
|
self.textField.autocapitalizationType = .none
|
|
self.textField.textContentType = .URL
|
|
}
|
|
|
|
self.component = component
|
|
self.state = state
|
|
|
|
let placeholderSize = self.placeholderView.update(
|
|
transition: .easeInOut(duration: 0.2),
|
|
component: AnyComponent(
|
|
Text(
|
|
text: component.placeholderText,
|
|
font: Font.regular(17.0),
|
|
color: component.placeholderColor
|
|
)
|
|
),
|
|
environment: {},
|
|
containerSize: availableSize
|
|
)
|
|
|
|
let size = CGSize(width: availableSize.width, height: 44.0)
|
|
if let placeholderComponentView = self.placeholderView.view {
|
|
if placeholderComponentView.superview == nil {
|
|
self.insertSubview(placeholderComponentView, at: 0)
|
|
}
|
|
|
|
placeholderComponentView.frame = CGRect(origin: CGPoint(x: 15.0, y: floorToScreenPixels((size.height - placeholderSize.height) / 2.0) + 1.0 - UIScreenPixel), size: placeholderSize)
|
|
|
|
placeholderComponentView.isHidden = !component.text.isEmpty
|
|
}
|
|
|
|
self.textField.frame = CGRect(x: 15.0, y: 0.0, width: size.width - 30.0, height: 44.0)
|
|
|
|
return size
|
|
}
|
|
}
|
|
|
|
public func makeView() -> View {
|
|
return View(frame: CGRect())
|
|
}
|
|
|
|
public func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<EnvironmentType>, transition: ComponentTransition) -> CGSize {
|
|
return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
|
|
}
|
|
}
|
|
|
|
private final class LinkPreviewComponent: Component {
|
|
typealias EnvironmentType = Empty
|
|
|
|
let webpage: TelegramMediaWebpage
|
|
let theme: PresentationTheme
|
|
let strings: PresentationStrings
|
|
let presentLinkOptions: (ASDisplayNode) -> Void
|
|
let dismiss: () -> Void
|
|
|
|
init(
|
|
webpage: TelegramMediaWebpage,
|
|
theme: PresentationTheme,
|
|
strings: PresentationStrings,
|
|
presentLinkOptions: @escaping (ASDisplayNode) -> Void,
|
|
dismiss: @escaping () -> Void
|
|
) {
|
|
self.webpage = webpage
|
|
self.theme = theme
|
|
self.strings = strings
|
|
self.presentLinkOptions = presentLinkOptions
|
|
self.dismiss = dismiss
|
|
}
|
|
|
|
static func ==(lhs: LinkPreviewComponent, rhs: LinkPreviewComponent) -> Bool {
|
|
if lhs.webpage != rhs.webpage {
|
|
return false
|
|
}
|
|
if lhs.theme !== rhs.theme {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
final class View: UIView, UITextFieldDelegate {
|
|
let closeButton: HighlightableButtonNode
|
|
let lineNode: ASImageNode
|
|
let iconView: UIImageView
|
|
let titleNode: TextNode
|
|
private var titleString: NSAttributedString?
|
|
|
|
let textNode: TextNode
|
|
private var textString: NSAttributedString?
|
|
|
|
private var component: LinkPreviewComponent?
|
|
private weak var state: EmptyComponentState?
|
|
|
|
override init(frame: CGRect) {
|
|
self.closeButton = HighlightableButtonNode()
|
|
|
|
self.closeButton.hitTestSlop = UIEdgeInsets(top: -8.0, left: -8.0, bottom: -8.0, right: -8.0)
|
|
self.closeButton.displaysAsynchronously = false
|
|
|
|
self.lineNode = ASImageNode()
|
|
self.lineNode.displayWithoutProcessing = true
|
|
self.lineNode.displaysAsynchronously = false
|
|
|
|
self.iconView = UIImageView()
|
|
self.iconView.image = UIImage(bundleImageName: "Chat/Input/Accessory Panels/LinkSettingsIcon")?.withRenderingMode(.alwaysTemplate)
|
|
|
|
self.titleNode = TextNode()
|
|
self.titleNode.displaysAsynchronously = false
|
|
|
|
self.textNode = TextNode()
|
|
self.textNode.displaysAsynchronously = false
|
|
|
|
super.init(frame: frame)
|
|
|
|
self.closeButton.addTarget(self, action: #selector(self.closePressed), forControlEvents: [.touchUpInside])
|
|
self.addSubnode(self.closeButton)
|
|
|
|
self.addSubnode(self.lineNode)
|
|
self.addSubview(self.iconView)
|
|
self.addSubnode(self.titleNode)
|
|
self.addSubnode(self.textNode)
|
|
|
|
self.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.tapGesture(_:))))
|
|
}
|
|
|
|
required init?(coder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
@objc private func closePressed() {
|
|
guard let component = self.component else {
|
|
return
|
|
}
|
|
component.dismiss()
|
|
}
|
|
|
|
private var previousTapTimestamp: Double?
|
|
@objc private func tapGesture(_ recognizer: UITapGestureRecognizer) {
|
|
if case .ended = recognizer.state, let component = self.component {
|
|
let timestamp = CFAbsoluteTimeGetCurrent()
|
|
if let previousTapTimestamp = self.previousTapTimestamp, previousTapTimestamp + 1.0 > timestamp {
|
|
return
|
|
}
|
|
self.previousTapTimestamp = CFAbsoluteTimeGetCurrent()
|
|
component.presentLinkOptions(self.textNode)
|
|
}
|
|
}
|
|
|
|
func update(component: LinkPreviewComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<EnvironmentType>, transition: ComponentTransition) -> CGSize {
|
|
let themeUpdated = self.component?.theme !== component.theme
|
|
self.component = component
|
|
self.state = state
|
|
|
|
if themeUpdated {
|
|
self.closeButton.setImage(PresentationResourcesChat.chatInputPanelCloseIconImage(component.theme), for: [])
|
|
self.lineNode.image = PresentationResourcesChat.chatInputPanelVerticalSeparatorLineImage(component.theme)
|
|
self.iconView.tintColor = component.theme.chat.inputPanel.panelControlAccentColor
|
|
}
|
|
|
|
let bounds = CGRect(origin: CGPoint(), size: CGSize(width: availableSize.width, height: 45.0))
|
|
|
|
var authorName = ""
|
|
var text = ""
|
|
switch component.webpage.content {
|
|
case .Pending:
|
|
authorName = component.strings.Channel_NotificationLoading
|
|
text = ""//component.url
|
|
case let .Loaded(content):
|
|
if let contentText = content.text {
|
|
text = contentText
|
|
} else {
|
|
if let file = content.file, let mediaKind = mediaContentKind(EngineMedia(file)) {
|
|
if content.type == "telegram_background" {
|
|
text = component.strings.Message_Wallpaper
|
|
} else if content.type == "telegram_theme" {
|
|
text = component.strings.Message_Theme
|
|
} else {
|
|
text = stringForMediaKind(mediaKind, strings: component.strings).0.string
|
|
}
|
|
} else if content.type == "telegram_theme" {
|
|
text = component.strings.Message_Theme
|
|
} else if content.type == "video" {
|
|
text = stringForMediaKind(.video, strings: component.strings).0.string
|
|
} else if content.type == "telegram_story" {
|
|
text = stringForMediaKind(.story, strings: component.strings).0.string
|
|
} else if let _ = content.image {
|
|
text = stringForMediaKind(.image, strings: component.strings).0.string
|
|
}
|
|
}
|
|
|
|
if let title = content.title {
|
|
authorName = title
|
|
} else if let websiteName = content.websiteName {
|
|
authorName = websiteName
|
|
} else {
|
|
authorName = content.displayUrl
|
|
}
|
|
|
|
}
|
|
|
|
self.titleString = NSAttributedString(string: authorName, font: Font.medium(15.0), textColor: component.theme.chat.inputPanel.panelControlAccentColor)
|
|
self.textString = NSAttributedString(string: text, font: Font.regular(15.0), textColor: component.theme.chat.inputPanel.primaryTextColor)
|
|
|
|
let inset: CGFloat = 0.0
|
|
let leftInset: CGFloat = 55.0
|
|
let textLineInset: CGFloat = 10.0
|
|
let rightInset: CGFloat = 55.0
|
|
let textRightInset: CGFloat = 20.0
|
|
|
|
let closeButtonSize = CGSize(width: 44.0, height: bounds.height)
|
|
self.closeButton.frame = CGRect(origin: CGPoint(x: bounds.size.width - closeButtonSize.width - inset, y: 2.0), size: closeButtonSize)
|
|
|
|
self.lineNode.frame = CGRect(origin: CGPoint(x: leftInset, y: 8.0), size: CGSize(width: 2.0, height: bounds.size.height - 10.0))
|
|
|
|
if let icon = self.iconView.image {
|
|
self.iconView.frame = CGRect(origin: CGPoint(x: 7.0 + inset, y: 10.0), size: icon.size)
|
|
}
|
|
|
|
let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
|
|
let makeTextLayout = TextNode.asyncLayout(self.textNode)
|
|
|
|
let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: self.titleString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: bounds.size.width - leftInset - textLineInset - rightInset - textRightInset, height: bounds.size.height), alignment: .natural, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
|
|
|
|
let (textLayout, textApply) = makeTextLayout(TextNodeLayoutArguments(attributedString: self.textString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: bounds.size.width - leftInset - textLineInset - rightInset - textRightInset, height: bounds.size.height), alignment: .natural, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
|
|
|
|
self.titleNode.frame = CGRect(origin: CGPoint(x: leftInset + textLineInset, y: 7.0), size: titleLayout.size)
|
|
|
|
self.textNode.frame = CGRect(origin: CGPoint(x: leftInset + textLineInset, y: 25.0), size: textLayout.size)
|
|
|
|
let _ = titleApply()
|
|
let _ = textApply()
|
|
|
|
return bounds.size
|
|
}
|
|
}
|
|
|
|
public func makeView() -> View {
|
|
return View(frame: CGRect())
|
|
}
|
|
|
|
public func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<EnvironmentType>, transition: ComponentTransition) -> CGSize {
|
|
return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
|
|
}
|
|
}
|