mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-16 05:55:20 +00:00
625 lines
28 KiB
Swift
625 lines
28 KiB
Swift
import Foundation
|
|
import UIKit
|
|
import Display
|
|
import ComponentFlow
|
|
import TelegramCore
|
|
import TelegramPresentationData
|
|
import AccountContext
|
|
import SwiftSignalKit
|
|
|
|
public final class EmojiSearchHeaderView: UIView, UITextFieldDelegate {
|
|
private final class EmojiSearchTextField: UITextField {
|
|
override func textRect(forBounds bounds: CGRect) -> CGRect {
|
|
return bounds.integral
|
|
}
|
|
}
|
|
|
|
private struct Params: Equatable {
|
|
var context: AccountContext
|
|
var theme: PresentationTheme
|
|
var forceNeedsVibrancy: Bool
|
|
var strings: PresentationStrings
|
|
var text: String
|
|
var useOpaqueTheme: Bool
|
|
var isActive: Bool
|
|
var hasPresetSearch: Bool
|
|
var textInputState: EmojiSearchSearchBarComponent.TextInputState
|
|
var searchState: EmojiPagerContentComponent.SearchState
|
|
var size: CGSize
|
|
var canFocus: Bool
|
|
var searchCategories: EmojiSearchCategories?
|
|
|
|
static func ==(lhs: Params, rhs: Params) -> Bool {
|
|
if lhs.context !== rhs.context {
|
|
return false
|
|
}
|
|
if lhs.theme !== rhs.theme {
|
|
return false
|
|
}
|
|
if lhs.forceNeedsVibrancy != rhs.forceNeedsVibrancy {
|
|
return false
|
|
}
|
|
if lhs.strings !== rhs.strings {
|
|
return false
|
|
}
|
|
if lhs.text != rhs.text {
|
|
return false
|
|
}
|
|
if lhs.useOpaqueTheme != rhs.useOpaqueTheme {
|
|
return false
|
|
}
|
|
if lhs.isActive != rhs.isActive {
|
|
return false
|
|
}
|
|
if lhs.hasPresetSearch != rhs.hasPresetSearch {
|
|
return false
|
|
}
|
|
if lhs.textInputState != rhs.textInputState {
|
|
return false
|
|
}
|
|
if lhs.searchState != rhs.searchState {
|
|
return false
|
|
}
|
|
if lhs.size != rhs.size {
|
|
return false
|
|
}
|
|
if lhs.canFocus != rhs.canFocus {
|
|
return false
|
|
}
|
|
if lhs.searchCategories != rhs.searchCategories {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
|
|
override public static var layerClass: AnyClass {
|
|
return PassthroughLayer.self
|
|
}
|
|
|
|
private let activated: (Bool) -> Void
|
|
private let deactivated: (Bool) -> Void
|
|
private let updateQuery: (EmojiPagerContentComponent.SearchQuery?) -> Void
|
|
|
|
let tintContainerView: UIView
|
|
|
|
private let backgroundLayer: SimpleLayer
|
|
private let tintBackgroundLayer: SimpleLayer
|
|
|
|
private let statusIcon = ComponentView<Empty>()
|
|
|
|
private let clearIconView: UIImageView
|
|
private let clearIconTintView: UIImageView
|
|
private let clearIconButton: HighlightTrackingButton
|
|
|
|
private let cancelButtonTintTitle: ComponentView<Empty>
|
|
private let cancelButtonTitle: ComponentView<Empty>
|
|
private let cancelButton: HighlightTrackingButton
|
|
|
|
private var placeholderContent = ComponentView<Empty>()
|
|
|
|
private var textFrame: CGRect?
|
|
private var textField: EmojiSearchTextField?
|
|
|
|
private var tapRecognizer: UITapGestureRecognizer?
|
|
private(set) var currentPresetSearchTerm: EmojiSearchCategories.Group?
|
|
|
|
private var params: Params?
|
|
|
|
public var wantsDisplayBelowKeyboard: Bool {
|
|
return self.textField != nil
|
|
}
|
|
|
|
init(activated: @escaping (Bool) -> Void, deactivated: @escaping (Bool) -> Void, updateQuery: @escaping (EmojiPagerContentComponent.SearchQuery?) -> Void) {
|
|
self.activated = activated
|
|
self.deactivated = deactivated
|
|
self.updateQuery = updateQuery
|
|
|
|
self.tintContainerView = UIView()
|
|
|
|
self.backgroundLayer = SimpleLayer()
|
|
self.tintBackgroundLayer = SimpleLayer()
|
|
|
|
self.clearIconView = UIImageView()
|
|
self.clearIconTintView = UIImageView()
|
|
self.clearIconButton = HighlightableButton()
|
|
self.clearIconView.isHidden = true
|
|
self.clearIconTintView.isHidden = true
|
|
self.clearIconButton.isHidden = true
|
|
|
|
self.cancelButtonTintTitle = ComponentView()
|
|
self.cancelButtonTitle = ComponentView()
|
|
self.cancelButton = HighlightTrackingButton()
|
|
|
|
super.init(frame: CGRect())
|
|
|
|
self.layer.addSublayer(self.backgroundLayer)
|
|
self.tintContainerView.layer.addSublayer(self.tintBackgroundLayer)
|
|
|
|
self.addSubview(self.clearIconView)
|
|
self.tintContainerView.addSubview(self.clearIconTintView)
|
|
self.addSubview(self.clearIconButton)
|
|
|
|
self.addSubview(self.cancelButton)
|
|
self.clipsToBounds = true
|
|
|
|
(self.layer as? PassthroughLayer)?.mirrorLayer = self.tintContainerView.layer
|
|
|
|
let tapRecognizer = UITapGestureRecognizer(target: self, action: #selector(self.tapGesture(_:)))
|
|
self.tapRecognizer = tapRecognizer
|
|
self.addGestureRecognizer(tapRecognizer)
|
|
|
|
self.cancelButton.highligthedChanged = { [weak self] highlighted in
|
|
if let strongSelf = self {
|
|
if highlighted {
|
|
if let cancelButtonTitleView = strongSelf.cancelButtonTitle.view {
|
|
cancelButtonTitleView.layer.removeAnimation(forKey: "opacity")
|
|
cancelButtonTitleView.alpha = 0.4
|
|
}
|
|
if let cancelButtonTintTitleView = strongSelf.cancelButtonTintTitle.view {
|
|
cancelButtonTintTitleView.layer.removeAnimation(forKey: "opacity")
|
|
cancelButtonTintTitleView.alpha = 0.4
|
|
}
|
|
} else {
|
|
if let cancelButtonTitleView = strongSelf.cancelButtonTitle.view {
|
|
cancelButtonTitleView.alpha = 1.0
|
|
cancelButtonTitleView.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
|
|
}
|
|
if let cancelButtonTintTitleView = strongSelf.cancelButtonTintTitle.view {
|
|
cancelButtonTintTitleView.alpha = 1.0
|
|
cancelButtonTintTitleView.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
self.cancelButton.addTarget(self, action: #selector(self.cancelPressed), for: .touchUpInside)
|
|
|
|
self.clearIconButton.highligthedChanged = { [weak self] highlighted in
|
|
if let strongSelf = self {
|
|
if highlighted {
|
|
strongSelf.clearIconView.layer.removeAnimation(forKey: "opacity")
|
|
strongSelf.clearIconView.alpha = 0.4
|
|
strongSelf.clearIconTintView.layer.removeAnimation(forKey: "opacity")
|
|
strongSelf.clearIconTintView.alpha = 0.4
|
|
} else {
|
|
strongSelf.clearIconView.alpha = 1.0
|
|
strongSelf.clearIconView.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
|
|
strongSelf.clearIconTintView.alpha = 1.0
|
|
strongSelf.clearIconTintView.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
|
|
}
|
|
}
|
|
}
|
|
self.clearIconButton.addTarget(self, action: #selector(self.clearPressed), for: .touchUpInside)
|
|
}
|
|
|
|
required public init?(coder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
@objc private func tapGesture(_ recognizer: UITapGestureRecognizer) {
|
|
if case .ended = recognizer.state {
|
|
let location = recognizer.location(in: self)
|
|
if let view = self.statusIcon.view, view.frame.contains(location), self.currentPresetSearchTerm != nil {
|
|
self.clearCategorySearch()
|
|
} else {
|
|
self.activateTextInput()
|
|
}
|
|
}
|
|
}
|
|
|
|
func clearCategorySearch() {
|
|
if let placeholderContentView = self.placeholderContent.view as? EmojiSearchSearchBarComponent.View {
|
|
placeholderContentView.clearSelection(dispatchEvent : true)
|
|
}
|
|
}
|
|
|
|
override public func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
|
|
if let textField = self.textField, let text = textField.text, text.isEmpty {
|
|
if self.bounds.contains(point), let placeholderContentView = self.placeholderContent.view as? EmojiSearchSearchBarComponent.View {
|
|
let leftTextPosition = placeholderContentView.leftTextPosition()
|
|
if point.x >= 0.0 && point.x <= placeholderContentView.frame.minX + leftTextPosition {
|
|
if let result = placeholderContentView.hitTest(self.convert(point, to: placeholderContentView), with: event) {
|
|
return result
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return super.hitTest(point, with: event)
|
|
}
|
|
|
|
private func activateTextInput() {
|
|
guard let params = self.params else {
|
|
return
|
|
}
|
|
if self.textField == nil, let textFrame = self.textFrame, params.canFocus == true {
|
|
let backgroundFrame = self.backgroundLayer.frame
|
|
let textFieldFrame = CGRect(origin: CGPoint(x: textFrame.minX, y: backgroundFrame.minY), size: CGSize(width: backgroundFrame.maxX - textFrame.minX, height: backgroundFrame.height))
|
|
|
|
let textField = EmojiSearchTextField(frame: textFieldFrame)
|
|
textField.keyboardAppearance = params.theme.rootController.keyboardColor.keyboardAppearance
|
|
textField.autocorrectionType = .no
|
|
textField.returnKeyType = .search
|
|
self.textField = textField
|
|
if let placeholderContentView = self.placeholderContent.view {
|
|
self.insertSubview(textField, belowSubview: placeholderContentView)
|
|
} else {
|
|
self.insertSubview(textField, belowSubview: self.clearIconView)
|
|
}
|
|
textField.delegate = self
|
|
textField.addTarget(self, action: #selector(self.textFieldChanged(_:)), for: .editingChanged)
|
|
}
|
|
|
|
if params.canFocus {
|
|
self.currentPresetSearchTerm = nil
|
|
if let placeholderContentView = self.placeholderContent.view as? EmojiSearchSearchBarComponent.View {
|
|
placeholderContentView.clearSelection(dispatchEvent: false)
|
|
}
|
|
}
|
|
|
|
self.activated(true)
|
|
|
|
self.textField?.becomeFirstResponder()
|
|
}
|
|
|
|
@objc private func cancelPressed() {
|
|
let textField = self.textField
|
|
self.textField = nil
|
|
|
|
self.currentPresetSearchTerm = nil
|
|
self.updateQuery(nil)
|
|
|
|
self.clearIconView.isHidden = true
|
|
self.clearIconTintView.isHidden = true
|
|
self.clearIconButton.isHidden = true
|
|
|
|
self.deactivated(textField?.isFirstResponder ?? false)
|
|
|
|
if let textField {
|
|
textField.resignFirstResponder()
|
|
textField.removeFromSuperview()
|
|
}
|
|
|
|
/*self.tintTextView.view?.isHidden = false
|
|
self.textView.view?.isHidden = false*/
|
|
}
|
|
|
|
@objc private func clearPressed() {
|
|
self.currentPresetSearchTerm = nil
|
|
self.updateQuery(nil)
|
|
self.textField?.text = ""
|
|
|
|
self.clearIconView.isHidden = true
|
|
self.clearIconTintView.isHidden = true
|
|
self.clearIconButton.isHidden = true
|
|
|
|
/*self.tintTextView.view?.isHidden = false
|
|
self.textView.view?.isHidden = false*/
|
|
}
|
|
|
|
var isActive: Bool {
|
|
return self.textField?.isFirstResponder ?? false
|
|
}
|
|
|
|
func deactivate() {
|
|
if let text = self.textField?.text, !text.isEmpty {
|
|
self.textField?.endEditing(true)
|
|
} else {
|
|
self.cancelPressed()
|
|
}
|
|
}
|
|
|
|
public func textFieldDidBeginEditing(_ textField: UITextField) {
|
|
}
|
|
|
|
public func textFieldDidEndEditing(_ textField: UITextField) {
|
|
}
|
|
|
|
public func textFieldShouldReturn(_ textField: UITextField) -> Bool {
|
|
textField.endEditing(true)
|
|
return false
|
|
}
|
|
|
|
@objc private func textFieldChanged(_ textField: UITextField) {
|
|
self.update(transition: .immediate)
|
|
|
|
let text = textField.text ?? ""
|
|
|
|
var inputLanguage = textField.textInputMode?.primaryLanguage ?? "en"
|
|
if let range = inputLanguage.range(of: "-") {
|
|
inputLanguage = String(inputLanguage[inputLanguage.startIndex ..< range.lowerBound])
|
|
}
|
|
if let range = inputLanguage.range(of: "_") {
|
|
inputLanguage = String(inputLanguage[inputLanguage.startIndex ..< range.lowerBound])
|
|
}
|
|
|
|
self.clearIconView.isHidden = text.isEmpty
|
|
self.clearIconTintView.isHidden = text.isEmpty
|
|
self.clearIconButton.isHidden = text.isEmpty
|
|
|
|
self.currentPresetSearchTerm = nil
|
|
self.updateQuery(.text(value: text, language: inputLanguage))
|
|
}
|
|
|
|
private func update(transition: Transition) {
|
|
guard let params = self.params else {
|
|
return
|
|
}
|
|
self.params = nil
|
|
self.update(context: params.context, theme: params.theme, forceNeedsVibrancy: params.forceNeedsVibrancy, strings: params.strings, text: params.text, useOpaqueTheme: params.useOpaqueTheme, isActive: params.isActive, size: params.size, canFocus: params.canFocus, searchCategories: params.searchCategories, searchState: params.searchState, transition: transition)
|
|
}
|
|
|
|
public func update(context: AccountContext, theme: PresentationTheme, forceNeedsVibrancy: Bool, strings: PresentationStrings, text: String, useOpaqueTheme: Bool, isActive: Bool, size: CGSize, canFocus: Bool, searchCategories: EmojiSearchCategories?, searchState: EmojiPagerContentComponent.SearchState, transition: Transition) {
|
|
let textInputState: EmojiSearchSearchBarComponent.TextInputState
|
|
if let textField = self.textField {
|
|
textInputState = .active(hasText: !(textField.text ?? "").isEmpty)
|
|
} else {
|
|
textInputState = .inactive
|
|
}
|
|
|
|
let params = Params(
|
|
context: context,
|
|
theme: theme,
|
|
forceNeedsVibrancy: forceNeedsVibrancy,
|
|
strings: strings,
|
|
text: text,
|
|
useOpaqueTheme: useOpaqueTheme,
|
|
isActive: isActive,
|
|
hasPresetSearch: self.currentPresetSearchTerm == nil,
|
|
textInputState: textInputState,
|
|
searchState: searchState,
|
|
size: size,
|
|
canFocus: canFocus,
|
|
searchCategories: searchCategories
|
|
)
|
|
|
|
if self.params == params {
|
|
return
|
|
}
|
|
|
|
let isActiveWithText = isActive && self.currentPresetSearchTerm == nil
|
|
|
|
if self.params?.theme !== theme {
|
|
/*self.searchIconView.image = generateTintedImage(image: UIImage(bundleImageName: "Components/Search Bar/Loupe"), color: .white)?.withRenderingMode(.alwaysTemplate)
|
|
self.searchIconView.tintColor = useOpaqueTheme ? theme.chat.inputMediaPanel.panelContentOpaqueSearchOverlayColor : theme.chat.inputMediaPanel.panelContentVibrantSearchOverlayColor
|
|
|
|
self.searchIconTintView.image = generateTintedImage(image: UIImage(bundleImageName: "Components/Search Bar/Loupe"), color: .white)
|
|
|
|
self.backIconView.image = generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Back"), color: .white)?.withRenderingMode(.alwaysTemplate)
|
|
self.backIconView.tintColor = useOpaqueTheme ? theme.chat.inputMediaPanel.panelContentOpaqueSearchOverlayColor : theme.chat.inputMediaPanel.panelContentVibrantSearchOverlayColor
|
|
|
|
self.backIconTintView.image = generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Back"), color: .white)*/
|
|
|
|
self.clearIconView.image = generateTintedImage(image: UIImage(bundleImageName: "Components/Search Bar/Clear"), color: .white)?.withRenderingMode(.alwaysTemplate)
|
|
self.clearIconView.tintColor = useOpaqueTheme ? theme.chat.inputMediaPanel.panelContentOpaqueSearchOverlayColor : theme.chat.inputMediaPanel.panelContentVibrantSearchOverlayColor
|
|
|
|
self.clearIconTintView.image = generateTintedImage(image: UIImage(bundleImageName: "Components/Search Bar/Clear"), color: .white)
|
|
}
|
|
|
|
self.params = params
|
|
|
|
let sideInset: CGFloat = 12.0
|
|
let topInset: CGFloat = 8.0
|
|
let inputHeight: CGFloat = 36.0
|
|
|
|
let sideTextInset: CGFloat = sideInset + 4.0 + 24.0
|
|
|
|
if theme.overallDarkAppearance && forceNeedsVibrancy {
|
|
self.backgroundLayer.backgroundColor = theme.chat.inputMediaPanel.panelContentControlVibrantSelectionColor.withMultipliedAlpha(0.3).cgColor
|
|
self.tintBackgroundLayer.backgroundColor = UIColor(white: 1.0, alpha: 0.2).cgColor
|
|
} else if useOpaqueTheme {
|
|
self.backgroundLayer.backgroundColor = theme.chat.inputMediaPanel.panelContentControlOpaqueSelectionColor.cgColor
|
|
self.tintBackgroundLayer.backgroundColor = UIColor.white.cgColor
|
|
} else {
|
|
self.backgroundLayer.backgroundColor = theme.chat.inputMediaPanel.panelContentControlVibrantSelectionColor.cgColor
|
|
self.tintBackgroundLayer.backgroundColor = UIColor(white: 1.0, alpha: 0.2).cgColor
|
|
}
|
|
|
|
self.backgroundLayer.cornerRadius = inputHeight * 0.5
|
|
self.tintBackgroundLayer.cornerRadius = inputHeight * 0.5
|
|
|
|
let cancelColor: UIColor
|
|
if theme.overallDarkAppearance && forceNeedsVibrancy {
|
|
cancelColor = theme.chat.inputMediaPanel.panelContentVibrantSearchOverlayColor.withMultipliedAlpha(0.3)
|
|
} else {
|
|
cancelColor = useOpaqueTheme ? theme.list.itemAccentColor : theme.chat.inputMediaPanel.panelContentVibrantSearchOverlayColor
|
|
}
|
|
|
|
let cancelTextSize = self.cancelButtonTitle.update(
|
|
transition: .immediate,
|
|
component: AnyComponent(Text(
|
|
text: strings.Common_Cancel,
|
|
font: Font.regular(17.0),
|
|
color: cancelColor
|
|
)),
|
|
environment: {},
|
|
containerSize: CGSize(width: size.width - 32.0, height: 100.0)
|
|
)
|
|
let _ = self.cancelButtonTintTitle.update(
|
|
transition: .immediate,
|
|
component: AnyComponent(Text(
|
|
text: strings.Common_Cancel,
|
|
font: Font.regular(17.0),
|
|
color: .white
|
|
)),
|
|
environment: {},
|
|
containerSize: CGSize(width: size.width - 32.0, height: 100.0)
|
|
)
|
|
|
|
let cancelButtonSpacing: CGFloat = 8.0
|
|
|
|
var backgroundFrame = CGRect(origin: CGPoint(x: sideInset, y: topInset), size: CGSize(width: size.width - sideInset * 2.0, height: inputHeight))
|
|
if isActiveWithText {
|
|
backgroundFrame.size.width -= cancelTextSize.width + cancelButtonSpacing
|
|
}
|
|
transition.setFrame(layer: self.backgroundLayer, frame: backgroundFrame)
|
|
transition.setFrame(layer: self.tintBackgroundLayer, frame: backgroundFrame)
|
|
|
|
transition.setFrame(view: self.cancelButton, frame: CGRect(origin: CGPoint(x: backgroundFrame.maxX, y: 0.0), size: CGSize(width: cancelButtonSpacing + cancelTextSize.width, height: size.height)))
|
|
|
|
let textX: CGFloat = backgroundFrame.minX + sideTextInset
|
|
let textFrame = CGRect(origin: CGPoint(x: textX, y: backgroundFrame.minY), size: CGSize(width: backgroundFrame.maxX - textX, height: backgroundFrame.height))
|
|
self.textFrame = textFrame
|
|
|
|
let statusContent: EmojiSearchStatusComponent.Content
|
|
switch searchState {
|
|
case .empty:
|
|
statusContent = .search
|
|
case .searching:
|
|
statusContent = .progress
|
|
case .active:
|
|
statusContent = .results
|
|
}
|
|
|
|
let statusSize = CGSize(width: 24.0, height: 24.0)
|
|
let _ = self.statusIcon.update(
|
|
transition: transition,
|
|
component: AnyComponent(EmojiSearchStatusComponent(
|
|
theme: theme,
|
|
forceNeedsVibrancy: forceNeedsVibrancy,
|
|
strings: strings,
|
|
useOpaqueTheme: useOpaqueTheme,
|
|
content: statusContent
|
|
)),
|
|
environment: {},
|
|
containerSize: statusSize
|
|
)
|
|
let iconFrame = CGRect(origin: CGPoint(x: textFrame.minX - statusSize.width - 4.0, y: backgroundFrame.minY + floor((backgroundFrame.height - statusSize.height) / 2.0)), size: statusSize)
|
|
if let statusIconView = self.statusIcon.view as? EmojiSearchStatusComponent.View {
|
|
if statusIconView.superview == nil {
|
|
self.addSubview(statusIconView)
|
|
self.tintContainerView.addSubview(statusIconView.tintContainerView)
|
|
}
|
|
|
|
transition.setFrame(view: statusIconView, frame: iconFrame)
|
|
transition.setFrame(view: statusIconView.tintContainerView, frame: iconFrame)
|
|
}
|
|
|
|
let placeholderContentFrame = CGRect(origin: CGPoint(x: textFrame.minX - 6.0, y: backgroundFrame.minY), size: CGSize(width: backgroundFrame.maxX - (textFrame.minX - 6.0), height: backgroundFrame.height))
|
|
let _ = self.placeholderContent.update(
|
|
transition: transition,
|
|
component: AnyComponent(EmojiSearchSearchBarComponent(
|
|
context: context,
|
|
theme: theme,
|
|
forceNeedsVibrancy: forceNeedsVibrancy,
|
|
strings: strings,
|
|
useOpaqueTheme: useOpaqueTheme,
|
|
textInputState: textInputState,
|
|
categories: searchCategories,
|
|
searchTermUpdated: { [weak self] term in
|
|
guard let self else {
|
|
return
|
|
}
|
|
var shouldChangeActivation = false
|
|
if (self.currentPresetSearchTerm == nil) != (term == nil) {
|
|
shouldChangeActivation = true
|
|
}
|
|
self.currentPresetSearchTerm = term
|
|
|
|
if shouldChangeActivation {
|
|
if let term {
|
|
self.update(transition: Transition(animation: .curve(duration: 0.4, curve: .spring)))
|
|
|
|
self.updateQuery(.category(value: term))
|
|
self.activated(false)
|
|
} else {
|
|
self.deactivated(self.textField?.isFirstResponder ?? false)
|
|
self.updateQuery(nil)
|
|
}
|
|
} else {
|
|
if let term {
|
|
self.updateQuery(.category(value: term))
|
|
} else {
|
|
self.updateQuery(nil)
|
|
}
|
|
}
|
|
},
|
|
activateTextInput: { [weak self] in
|
|
guard let self else {
|
|
return
|
|
}
|
|
self.activateTextInput()
|
|
}
|
|
)),
|
|
environment: {},
|
|
containerSize: placeholderContentFrame.size
|
|
)
|
|
if let placeholderContentView = self.placeholderContent.view as? EmojiSearchSearchBarComponent.View {
|
|
if placeholderContentView.superview == nil {
|
|
self.addSubview(placeholderContentView)
|
|
self.tintContainerView.addSubview(placeholderContentView.tintContainerView)
|
|
}
|
|
transition.setFrame(view: placeholderContentView, frame: placeholderContentFrame)
|
|
transition.setFrame(view: placeholderContentView.tintContainerView, frame: placeholderContentFrame)
|
|
}
|
|
|
|
/*if let searchCategories {
|
|
let suggestedItemsView: ComponentView<Empty>
|
|
var suggestedItemsTransition = transition
|
|
if let current = self.suggestedItemsView {
|
|
suggestedItemsView = current
|
|
} else {
|
|
suggestedItemsTransition = .immediate
|
|
suggestedItemsView = ComponentView()
|
|
self.suggestedItemsView = suggestedItemsView
|
|
}
|
|
|
|
let itemsX: CGFloat = textFrame.maxX + 8.0
|
|
let suggestedItemsFrame = CGRect(origin: CGPoint(x: itemsX, y: backgroundFrame.minY), size: CGSize(width: backgroundFrame.maxX - itemsX, height: backgroundFrame.height))
|
|
|
|
if let suggestedItemsComponentView = suggestedItemsView.view {
|
|
if suggestedItemsComponentView.superview == nil {
|
|
self.addSubview(suggestedItemsComponentView)
|
|
}
|
|
suggestedItemsTransition.setFrame(view: suggestedItemsComponentView, frame: suggestedItemsFrame)
|
|
suggestedItemsTransition.setAlpha(view: suggestedItemsComponentView, alpha: isActiveWithText ? 0.0 : 1.0)
|
|
}
|
|
} else {
|
|
if let suggestedItemsView = self.suggestedItemsView {
|
|
self.suggestedItemsView = nil
|
|
if let suggestedItemsComponentView = suggestedItemsView.view {
|
|
transition.setAlpha(view: suggestedItemsComponentView, alpha: 0.0, completion: { [weak suggestedItemsComponentView] _ in
|
|
suggestedItemsComponentView?.removeFromSuperview()
|
|
})
|
|
}
|
|
}
|
|
}*/
|
|
|
|
if let image = self.clearIconView.image {
|
|
let iconFrame = CGRect(origin: CGPoint(x: backgroundFrame.maxX - image.size.width - 4.0, y: backgroundFrame.minY + floor((backgroundFrame.height - image.size.height) / 2.0)), size: image.size)
|
|
transition.setFrame(view: self.clearIconView, frame: iconFrame)
|
|
transition.setFrame(view: self.clearIconTintView, frame: iconFrame)
|
|
transition.setFrame(view: self.clearIconButton, frame: iconFrame.insetBy(dx: -8.0, dy: -10.0))
|
|
}
|
|
|
|
if let cancelButtonTitleComponentView = self.cancelButtonTitle.view {
|
|
if cancelButtonTitleComponentView.superview == nil {
|
|
self.addSubview(cancelButtonTitleComponentView)
|
|
cancelButtonTitleComponentView.isUserInteractionEnabled = false
|
|
}
|
|
transition.setFrame(view: cancelButtonTitleComponentView, frame: CGRect(origin: CGPoint(x: backgroundFrame.maxX + cancelButtonSpacing, y: floor((size.height - cancelTextSize.height) / 2.0)), size: cancelTextSize))
|
|
transition.setAlpha(view: cancelButtonTitleComponentView, alpha: isActiveWithText ? 1.0 : 0.0)
|
|
}
|
|
if let cancelButtonTintTitleComponentView = self.cancelButtonTintTitle.view {
|
|
if cancelButtonTintTitleComponentView.superview == nil {
|
|
self.tintContainerView.addSubview(cancelButtonTintTitleComponentView)
|
|
cancelButtonTintTitleComponentView.isUserInteractionEnabled = false
|
|
}
|
|
transition.setFrame(view: cancelButtonTintTitleComponentView, frame: CGRect(origin: CGPoint(x: backgroundFrame.maxX + cancelButtonSpacing, y: floor((size.height - cancelTextSize.height) / 2.0)), size: cancelTextSize))
|
|
transition.setAlpha(view: cancelButtonTintTitleComponentView, alpha: isActiveWithText ? 1.0 : 0.0)
|
|
}
|
|
|
|
var hasText = false
|
|
if let textField = self.textField {
|
|
textField.textColor = theme.contextMenu.primaryColor
|
|
transition.setFrame(view: textField, frame: CGRect(origin: CGPoint(x: backgroundFrame.minX + sideTextInset, y: backgroundFrame.minY), size: CGSize(width: backgroundFrame.width - sideTextInset - 32.0, height: backgroundFrame.height)))
|
|
|
|
if let text = textField.text, !text.isEmpty {
|
|
hasText = true
|
|
}
|
|
}
|
|
let _ = hasText
|
|
|
|
|
|
}
|
|
}
|