mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-16 05:55:20 +00:00
623 lines
25 KiB
Swift
623 lines
25 KiB
Swift
import Foundation
|
|
import UIKit
|
|
import AsyncDisplayKit
|
|
import Display
|
|
import ComponentFlow
|
|
import TelegramPresentationData
|
|
import AccountContext
|
|
|
|
let panelButtonSize = CGSize(width: 80.0, height: 72.0)
|
|
let smallPanelButtonSize = CGSize(width: 54.0, height: 46.0)
|
|
|
|
private let iconSize = CGSize(width: 54.0, height: 42.0)
|
|
private let sideInset: CGFloat = 3.0
|
|
private let smallSideInset: CGFloat = 0.0
|
|
|
|
private enum AttachmentButtonTransition {
|
|
case transitionIn
|
|
case selection
|
|
}
|
|
|
|
private func generateShadowImage() -> UIImage? {
|
|
return generateImage(CGSize(width: 90.0, height: 90.0), rotatedContext: { size, context in
|
|
let bounds = CGRect(origin: CGPoint(), size: size)
|
|
context.clear(bounds)
|
|
|
|
// let rect = bounds.insetBy(dx: 12.0, dy: 24.0)
|
|
// let path = UIBezierPath(roundedRect: CGRect(origin: rect.origin, size: CGSize(width: rect.width, height: rect.height + 33.0)), cornerRadius: 24.0).cgPath
|
|
// context.addRect(bounds)
|
|
// context.addPath(path)
|
|
// context.clip(using: .evenOdd)
|
|
//
|
|
// context.addPath(path)
|
|
// context.setShadow(offset: CGSize(width: 0.0, height: 0.0), blur: 40.0, color: UIColor(rgb: 0x000000, alpha: 0.06).cgColor)
|
|
// context.setFillColor(UIColor.white.cgColor)
|
|
// context.setBlendMode(.multiply)
|
|
// context.fillPath()
|
|
//
|
|
// context.resetClip()
|
|
// context.setBlendMode(.normal)
|
|
|
|
var locations: [CGFloat] = [0.0, 1.0]
|
|
let colors: [CGColor] = [UIColor(rgb: 0x000000, alpha: 0.0).cgColor, UIColor(rgb: 0x000000, alpha: 0.2).cgColor]
|
|
let colorSpace = CGColorSpaceCreateDeviceRGB()
|
|
let gradient = CGGradient(colorsSpace: colorSpace, colors: colors as CFArray, locations: &locations)!
|
|
context.drawLinearGradient(gradient, start: CGPoint(x: 0.0, y: 0.0), end: CGPoint(x: 0.0, y: size.height), options: [])
|
|
})?.stretchableImage(withLeftCapWidth: 45, topCapHeight: 70)
|
|
}
|
|
|
|
private func generateBackgroundImage(colors: [UIColor]) -> UIImage? {
|
|
return generateImage(iconSize, rotatedContext: { size, context in
|
|
var locations: [CGFloat]
|
|
if colors.count == 3 {
|
|
locations = [1.0, 0.5, 0.0]
|
|
} else {
|
|
locations = [1.0, 0.0]
|
|
}
|
|
let colors: [CGColor] = colors.map { $0.cgColor }
|
|
let colorSpace = CGColorSpaceCreateDeviceRGB()
|
|
let gradient = CGGradient(colorsSpace: colorSpace, colors: colors as CFArray, locations: &locations)!
|
|
|
|
if colors.count == 2 {
|
|
context.drawLinearGradient(gradient, start: CGPoint(), end: CGPoint(x: 0.0, y: size.height), options: .drawsAfterEndLocation)
|
|
} else if colors.count == 3 {
|
|
context.drawLinearGradient(gradient, start: CGPoint(x: 0.0, y: size.height), end: CGPoint(x: size.width, y: 0.0), options: .drawsAfterEndLocation)
|
|
}
|
|
// let center = CGPoint(x: 10.0, y: 10.0)
|
|
// context.drawRadialGradient(gradient, startCenter: center, startRadius: 0.0, endCenter: center, endRadius: size.width, options: .drawsAfterEndLocation)
|
|
})
|
|
}
|
|
|
|
private let buttonGlowImage: UIImage? = {
|
|
let inset: CGFloat = 6.0
|
|
return generateImage(CGSize(width: iconSize.width + inset * 2.0, height: iconSize.height + inset * 2.0), rotatedContext: { size, context in
|
|
let bounds = CGRect(origin: CGPoint(), size: size)
|
|
context.clear(bounds)
|
|
|
|
let rect = bounds.insetBy(dx: inset, dy: inset)
|
|
let path = UIBezierPath(roundedRect: rect, cornerRadius: 21.0).cgPath
|
|
context.addRect(bounds)
|
|
context.addPath(path)
|
|
context.clip(using: .evenOdd)
|
|
|
|
context.addPath(path)
|
|
context.setShadow(offset: CGSize(), blur: 14.0, color: UIColor(rgb: 0xffffff, alpha: 0.8).cgColor)
|
|
context.setFillColor(UIColor.white.cgColor)
|
|
context.fillPath()
|
|
})?.withRenderingMode(.alwaysTemplate)
|
|
}()
|
|
|
|
private let buttonSelectionMaskImage: UIImage? = {
|
|
let inset: CGFloat = 3.0
|
|
return generateImage(CGSize(width: iconSize.width + inset * 2.0, height: iconSize.height + inset * 2.0), rotatedContext: { size, context in
|
|
let bounds = CGRect(origin: CGPoint(), size: size)
|
|
context.clear(bounds)
|
|
|
|
let path = UIBezierPath(roundedRect: bounds, cornerRadius: 23.0).cgPath
|
|
context.addPath(path)
|
|
context.setFillColor(UIColor(rgb: 0xffffff).cgColor)
|
|
context.fillPath()
|
|
})?.withRenderingMode(.alwaysTemplate)
|
|
}()
|
|
|
|
private let ringImage: UIImage? = {
|
|
return generateFilledCircleImage(diameter: iconSize.width, color: nil, strokeColor: .white, strokeWidth: 2.0, backgroundColor: nil)
|
|
}()
|
|
|
|
private final class AttachButtonComponent: CombinedComponent {
|
|
let context: AccountContext
|
|
let type: AttachmentButtonType
|
|
let isSelected: Bool
|
|
let isCollapsed: Bool
|
|
let transitionFraction: CGFloat
|
|
let strings: PresentationStrings
|
|
let theme: PresentationTheme
|
|
let action: () -> Void
|
|
|
|
init(
|
|
context: AccountContext,
|
|
type: AttachmentButtonType,
|
|
isSelected: Bool,
|
|
isCollapsed: Bool,
|
|
transitionFraction: CGFloat,
|
|
strings: PresentationStrings,
|
|
theme: PresentationTheme,
|
|
action: @escaping () -> Void
|
|
) {
|
|
self.context = context
|
|
self.type = type
|
|
self.isSelected = isSelected
|
|
self.isCollapsed = isCollapsed
|
|
self.transitionFraction = transitionFraction
|
|
self.strings = strings
|
|
self.theme = theme
|
|
self.action = action
|
|
}
|
|
|
|
static func ==(lhs: AttachButtonComponent, rhs: AttachButtonComponent) -> Bool {
|
|
if lhs.context !== rhs.context {
|
|
return false
|
|
}
|
|
if lhs.type != rhs.type {
|
|
return false
|
|
}
|
|
if lhs.isSelected != rhs.isSelected {
|
|
return false
|
|
}
|
|
if lhs.isCollapsed != rhs.isCollapsed {
|
|
return false
|
|
}
|
|
if lhs.transitionFraction != rhs.transitionFraction {
|
|
return false
|
|
}
|
|
if lhs.strings !== rhs.strings {
|
|
return false
|
|
}
|
|
if lhs.theme !== rhs.theme {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
static var body: Body {
|
|
let icon = Child(AttachButtonIconComponent.self)
|
|
let title = Child(Text.self)
|
|
|
|
return { context in
|
|
let name: String
|
|
let animationName: String?
|
|
let imageName: String?
|
|
let backgroundColors: [UIColor]
|
|
let foregroundColor: UIColor = .white
|
|
|
|
let isCollapsed = context.component.isCollapsed
|
|
|
|
switch context.component.type {
|
|
case .camera:
|
|
name = context.component.strings.Attachment_Camera
|
|
animationName = "anim_camera"
|
|
imageName = "Chat/Attach Menu/Camera"
|
|
backgroundColors = [UIColor(rgb: 0xba4aae), UIColor(rgb: 0xdd4e6f), UIColor(rgb: 0xf3b76c)]
|
|
case .gallery:
|
|
name = context.component.strings.Attachment_Gallery
|
|
animationName = "anim_gallery"
|
|
imageName = "Chat/Attach Menu/Gallery"
|
|
backgroundColors = [UIColor(rgb: 0x2071f1), UIColor(rgb: 0x1bc9fa)]
|
|
case .file:
|
|
name = context.component.strings.Attachment_File
|
|
animationName = "anim_file"
|
|
imageName = "Chat/Attach Menu/File"
|
|
backgroundColors = [UIColor(rgb: 0xed705d), UIColor(rgb: 0xffa14c)]
|
|
case .location:
|
|
name = context.component.strings.Attachment_Location
|
|
animationName = "anim_location"
|
|
imageName = "Chat/Attach Menu/Location"
|
|
backgroundColors = [UIColor(rgb: 0x5fb84f), UIColor(rgb: 0x99de6f)]
|
|
case .contact:
|
|
name = context.component.strings.Attachment_Contact
|
|
animationName = "anim_contact"
|
|
imageName = "Chat/Attach Menu/Contact"
|
|
backgroundColors = [UIColor(rgb: 0xaa47d6), UIColor(rgb: 0xd67cf4)]
|
|
case .poll:
|
|
name = context.component.strings.Attachment_Poll
|
|
animationName = "anim_poll"
|
|
imageName = "Chat/Attach Menu/Poll"
|
|
backgroundColors = [UIColor(rgb: 0xe9484f), UIColor(rgb: 0xee707e)]
|
|
case let .app(appName):
|
|
name = appName
|
|
animationName = nil
|
|
imageName = nil
|
|
backgroundColors = [UIColor(rgb: 0x000000), UIColor(rgb: 0x000000)]
|
|
}
|
|
|
|
let icon = icon.update(
|
|
component: AttachButtonIconComponent(
|
|
animationName: animationName,
|
|
imageName: imageName,
|
|
isSelected: context.component.isSelected,
|
|
backgroundColors: backgroundColors,
|
|
foregroundColor: foregroundColor,
|
|
theme: context.component.theme,
|
|
context: context.component.context,
|
|
action: context.component.action
|
|
),
|
|
availableSize: iconSize,
|
|
transition: context.transition
|
|
)
|
|
|
|
let title = title.update(
|
|
component: Text(
|
|
text: name,
|
|
font: Font.regular(11.0),
|
|
color: context.component.theme.actionSheet.primaryTextColor
|
|
),
|
|
availableSize: context.availableSize,
|
|
transition: .immediate
|
|
)
|
|
|
|
let topInset: CGFloat = 8.0
|
|
let spacing: CGFloat = 3.0 + UIScreenPixel
|
|
|
|
let normalIconScale = isCollapsed ? 0.7 : 1.0
|
|
let smallIconScale = isCollapsed ? 0.5 : 0.6
|
|
|
|
let iconScale = normalIconScale - (normalIconScale - smallIconScale) * abs(context.component.transitionFraction)
|
|
let iconOffset: CGFloat = (isCollapsed ? 10.0 : 20.0) * context.component.transitionFraction
|
|
let iconFrame = CGRect(origin: CGPoint(x: floor((context.availableSize.width - icon.size.width) / 2.0) + iconOffset, y: isCollapsed ? 3.0 : topInset), size: icon.size)
|
|
var titleFrame = CGRect(origin: CGPoint(x: floor((context.availableSize.width - title.size.width) / 2.0) + iconOffset, y: iconFrame.midY + (iconFrame.height * 0.5 * iconScale) + spacing), size: title.size)
|
|
if isCollapsed {
|
|
titleFrame.origin.y = floor(iconFrame.midY - title.size.height / 2.0)
|
|
}
|
|
|
|
context.add(title
|
|
.position(CGPoint(x: titleFrame.midX, y: titleFrame.midY))
|
|
.opacity(isCollapsed ? 0.0 : 1.0 - abs(context.component.transitionFraction))
|
|
)
|
|
|
|
context.add(icon
|
|
.position(CGPoint(x: iconFrame.midX, y: iconFrame.midY))
|
|
.scale(iconScale)
|
|
)
|
|
|
|
return context.availableSize
|
|
}
|
|
}
|
|
}
|
|
|
|
private final class AttachButtonIconComponent: Component {
|
|
let animationName: String?
|
|
let imageName: String?
|
|
let isSelected: Bool
|
|
let backgroundColors: [UIColor]
|
|
let foregroundColor: UIColor
|
|
let theme: PresentationTheme
|
|
let context: AccountContext
|
|
|
|
let action: () -> Void
|
|
|
|
init(
|
|
animationName: String?,
|
|
imageName: String?,
|
|
isSelected: Bool,
|
|
backgroundColors: [UIColor],
|
|
foregroundColor: UIColor,
|
|
theme: PresentationTheme,
|
|
context: AccountContext,
|
|
action: @escaping () -> Void
|
|
) {
|
|
self.animationName = animationName
|
|
self.imageName = imageName
|
|
self.isSelected = isSelected
|
|
self.backgroundColors = backgroundColors
|
|
self.foregroundColor = foregroundColor
|
|
self.theme = theme
|
|
self.context = context
|
|
self.action = action
|
|
}
|
|
|
|
static func ==(lhs: AttachButtonIconComponent, rhs: AttachButtonIconComponent) -> Bool {
|
|
if lhs.animationName != rhs.animationName {
|
|
return false
|
|
}
|
|
if lhs.imageName != rhs.imageName {
|
|
return false
|
|
}
|
|
if lhs.isSelected != rhs.isSelected {
|
|
return false
|
|
}
|
|
if lhs.backgroundColors != rhs.backgroundColors {
|
|
return false
|
|
}
|
|
if lhs.foregroundColor != rhs.foregroundColor {
|
|
return false
|
|
}
|
|
if lhs.theme !== rhs.theme {
|
|
return false
|
|
}
|
|
if lhs.context !== rhs.context {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
final class View: HighlightTrackingButton {
|
|
private let glowView: UIImageView
|
|
private let selectionView: UIImageView
|
|
private let backgroundView: UIView
|
|
private let iconView: UIImageView
|
|
|
|
private var action: (() -> Void)?
|
|
|
|
private var currentColors: [UIColor] = []
|
|
private var currentImageName: String?
|
|
private var currentIsSelected: Bool?
|
|
|
|
init() {
|
|
self.glowView = UIImageView()
|
|
self.glowView.image = buttonGlowImage
|
|
self.glowView.isUserInteractionEnabled = false
|
|
|
|
self.selectionView = UIImageView()
|
|
self.selectionView.image = buttonSelectionMaskImage
|
|
self.selectionView.isUserInteractionEnabled = false
|
|
|
|
self.backgroundView = UIView()
|
|
self.backgroundView.clipsToBounds = true
|
|
self.backgroundView.isUserInteractionEnabled = false
|
|
self.backgroundView.layer.cornerRadius = 21.0
|
|
|
|
self.iconView = UIImageView()
|
|
|
|
super.init(frame: CGRect())
|
|
|
|
self.addSubview(self.glowView)
|
|
self.addSubview(self.selectionView)
|
|
self.addSubview(self.backgroundView)
|
|
self.addSubview(self.iconView)
|
|
|
|
self.addTarget(self, action: #selector(self.pressed), for: .touchUpInside)
|
|
self.highligthedChanged = { _ in
|
|
|
|
}
|
|
}
|
|
|
|
required init?(coder aDecoder: NSCoder) {
|
|
preconditionFailure()
|
|
}
|
|
|
|
@objc private func pressed() {
|
|
self.action?()
|
|
}
|
|
|
|
func update(component: AttachButtonIconComponent, availableSize: CGSize, transition: Transition) -> CGSize {
|
|
self.action = component.action
|
|
|
|
if self.currentColors != component.backgroundColors {
|
|
self.currentColors = component.backgroundColors
|
|
self.backgroundView.layer.contents = generateBackgroundImage(colors: component.backgroundColors)?.cgImage
|
|
|
|
if let color = component.backgroundColors.last {
|
|
self.glowView.tintColor = color
|
|
self.selectionView.tintColor = color.withAlphaComponent(0.2)
|
|
}
|
|
}
|
|
|
|
if self.currentImageName != component.imageName {
|
|
self.currentImageName = component.imageName
|
|
if let imageName = component.imageName, let image = UIImage(bundleImageName: imageName) {
|
|
self.iconView.image = image
|
|
|
|
let scale: CGFloat = 0.875
|
|
let iconSize = CGSize(width: floorToScreenPixels(image.size.width * scale), height: floorToScreenPixels(image.size.height * scale))
|
|
self.iconView.frame = CGRect(origin: CGPoint(x: floorToScreenPixels((availableSize.width - iconSize.width) / 2.0), y: floorToScreenPixels((availableSize.height - iconSize.height) / 2.0)), size: iconSize)
|
|
}
|
|
}
|
|
|
|
if self.currentIsSelected != component.isSelected {
|
|
self.currentIsSelected = component.isSelected
|
|
|
|
transition.setScale(view: self.selectionView, scale: component.isSelected ? 1.0 : 0.8)
|
|
}
|
|
|
|
let contentFrame = CGRect(origin: CGPoint(), size: availableSize)
|
|
self.backgroundView.frame = contentFrame
|
|
|
|
self.glowView.bounds = CGRect(origin: CGPoint(), size: CGSize(width: contentFrame.width + 12.0, height: contentFrame.height + 12.0))
|
|
self.glowView.center = CGPoint(x: contentFrame.midX, y: contentFrame.midY)
|
|
|
|
self.selectionView.bounds = CGRect(origin: CGPoint(), size: CGSize(width: contentFrame.width + 6.0, height: contentFrame.height + 6.0))
|
|
self.selectionView.center = CGPoint(x: contentFrame.midX, y: contentFrame.midY)
|
|
|
|
return availableSize
|
|
}
|
|
}
|
|
|
|
func makeView() -> View {
|
|
return View()
|
|
}
|
|
|
|
func update(view: View, availableSize: CGSize, environment: Environment<Empty>, transition: Transition) -> CGSize {
|
|
return view.update(component: self, availableSize: availableSize, transition: transition)
|
|
}
|
|
}
|
|
|
|
final class AttachmentPanel: ASDisplayNode, UIScrollViewDelegate {
|
|
private let context: AccountContext
|
|
private var presentationData: PresentationData
|
|
|
|
private let shadowNode: ASImageNode
|
|
private let containerNode: ASDisplayNode
|
|
private var effectView: UIVisualEffectView?
|
|
private let scrollNode: ASScrollNode
|
|
private let backgroundNode: ASDisplayNode
|
|
private var buttonViews: [Int: ComponentHostView<Empty>] = [:]
|
|
|
|
private var buttons: [AttachmentButtonType] = []
|
|
private var selectedIndex: Int = 1
|
|
private var isCollapsed: Bool = false
|
|
|
|
private var validLayout: CGSize?
|
|
private var scrollLayout: (width: CGFloat, contentSize: CGSize)?
|
|
|
|
var selectionChanged: (AttachmentButtonType, Bool) -> Void = { _, _ in }
|
|
|
|
init(context: AccountContext) {
|
|
self.context = context
|
|
self.presentationData = context.sharedContext.currentPresentationData.with { $0 }
|
|
|
|
self.shadowNode = ASImageNode()
|
|
self.shadowNode.contentMode = .scaleToFill
|
|
self.shadowNode.displaysAsynchronously = false
|
|
self.shadowNode.image = generateShadowImage()
|
|
|
|
self.containerNode = ASDisplayNode()
|
|
self.containerNode.clipsToBounds = true
|
|
|
|
self.scrollNode = ASScrollNode()
|
|
self.backgroundNode = ASDisplayNode()
|
|
self.backgroundNode.backgroundColor = self.presentationData.theme.actionSheet.itemBackgroundColor
|
|
|
|
super.init()
|
|
|
|
self.addSubnode(self.shadowNode)
|
|
self.addSubnode(self.containerNode)
|
|
self.containerNode.addSubnode(self.backgroundNode)
|
|
self.containerNode.addSubnode(self.scrollNode)
|
|
}
|
|
|
|
override func didLoad() {
|
|
super.didLoad()
|
|
if #available(iOS 13.0, *) {
|
|
self.containerNode.layer.cornerCurve = .continuous
|
|
}
|
|
self.containerNode.layer.cornerRadius = 23.0
|
|
|
|
self.scrollNode.view.delegate = self
|
|
self.scrollNode.view.showsHorizontalScrollIndicator = false
|
|
self.scrollNode.view.showsVerticalScrollIndicator = false
|
|
|
|
let effect: UIVisualEffect
|
|
switch self.presentationData.theme.actionSheet.backgroundType {
|
|
case .light:
|
|
effect = UIBlurEffect(style: .light)
|
|
case .dark:
|
|
effect = UIBlurEffect(style: .dark)
|
|
}
|
|
let effectView = UIVisualEffectView(effect: effect)
|
|
self.effectView = effectView
|
|
self.containerNode.view.insertSubview(effectView, at: 0)
|
|
}
|
|
|
|
func updateViews(transition: Transition) {
|
|
guard let _ = self.validLayout else {
|
|
return
|
|
}
|
|
|
|
let visibleRect = self.scrollNode.bounds.insetBy(dx: -180.0, dy: 0.0)
|
|
let actualVisibleRect = self.scrollNode.bounds
|
|
var validButtons = Set<Int>()
|
|
|
|
let buttonSize = self.isCollapsed ? smallPanelButtonSize : panelButtonSize
|
|
|
|
for i in 0 ..< self.buttons.count {
|
|
let buttonFrame = CGRect(origin: CGPoint(x: (self.isCollapsed ? smallSideInset : sideInset) + buttonSize.width * CGFloat(i), y: 0.0), size: buttonSize)
|
|
if !visibleRect.intersects(buttonFrame) {
|
|
continue
|
|
}
|
|
validButtons.insert(i)
|
|
|
|
let edge = buttonSize.width * 0.75
|
|
let leftEdge = max(-edge, min(0.0, buttonFrame.minX - actualVisibleRect.minX)) / -edge
|
|
let rightEdge = min(edge, max(0.0, buttonFrame.maxX - actualVisibleRect.maxX)) / edge
|
|
|
|
let transitionFraction: CGFloat
|
|
if leftEdge > rightEdge {
|
|
transitionFraction = leftEdge
|
|
} else {
|
|
transitionFraction = -rightEdge
|
|
}
|
|
|
|
var buttonTransition = transition
|
|
let buttonView: ComponentHostView<Empty>
|
|
if let current = self.buttonViews[i] {
|
|
buttonView = current
|
|
} else {
|
|
buttonTransition = .immediate
|
|
buttonView = ComponentHostView<Empty>()
|
|
self.buttonViews[i] = buttonView
|
|
self.scrollNode.view.addSubview(buttonView)
|
|
}
|
|
|
|
let type = self.buttons[i]
|
|
let _ = buttonView.update(
|
|
transition: buttonTransition,
|
|
component: AnyComponent(AttachButtonComponent(
|
|
context: self.context,
|
|
type: type,
|
|
isSelected: i == self.selectedIndex,
|
|
isCollapsed: self.isCollapsed,
|
|
transitionFraction: transitionFraction,
|
|
strings: self.presentationData.strings,
|
|
theme: self.presentationData.theme,
|
|
action: { [weak self] in
|
|
if let strongSelf = self {
|
|
let ascending = i > strongSelf.selectedIndex
|
|
strongSelf.selectedIndex = i
|
|
strongSelf.selectionChanged(type, ascending)
|
|
strongSelf.updateViews(transition: .init(animation: .curve(duration: 0.2, curve: .spring)))
|
|
}
|
|
})
|
|
),
|
|
environment: {},
|
|
containerSize: buttonSize
|
|
)
|
|
buttonTransition.setFrame(view: buttonView, frame: buttonFrame)
|
|
}
|
|
}
|
|
|
|
private func updateScrollLayoutIfNeeded(force: Bool, transition: ContainedViewLayoutTransition) -> Bool {
|
|
guard let size = self.validLayout else {
|
|
return false
|
|
}
|
|
if self.scrollLayout?.width == size.width && !force {
|
|
return false
|
|
}
|
|
|
|
let buttonSize = self.isCollapsed ? smallPanelButtonSize : panelButtonSize
|
|
let contentSize = CGSize(width: (self.isCollapsed ? smallSideInset : sideInset) * 2.0 + CGFloat(self.buttons.count) * buttonSize.width, height: buttonSize.height)
|
|
self.scrollLayout = (size.width, contentSize)
|
|
|
|
transition.updateFrame(node: self.scrollNode, frame: CGRect(origin: CGPoint(), size: size))
|
|
self.scrollNode.view.contentSize = contentSize
|
|
|
|
return true
|
|
}
|
|
|
|
func update(buttons: [AttachmentButtonType], isCollapsed: Bool, size: CGSize, transition: ContainedViewLayoutTransition) {
|
|
self.validLayout = size
|
|
self.buttons = buttons
|
|
|
|
let isCollapsedUpdated = self.isCollapsed != isCollapsed
|
|
self.isCollapsed = isCollapsed
|
|
|
|
let bounds = CGRect(origin: CGPoint(), size: size)
|
|
|
|
let containerTransition: ContainedViewLayoutTransition
|
|
let containerFrame: CGRect
|
|
if isCollapsed {
|
|
containerFrame = CGRect(origin: CGPoint(x: 0.0, y: bounds.height - smallPanelButtonSize.height), size: CGSize(width: bounds.width, height: smallPanelButtonSize.height))
|
|
} else {
|
|
containerFrame = bounds
|
|
}
|
|
let containerBounds = CGRect(origin: CGPoint(), size: containerFrame.size)
|
|
if isCollapsedUpdated {
|
|
containerTransition = .animated(duration: 0.25, curve: .easeInOut)
|
|
} else {
|
|
containerTransition = transition
|
|
}
|
|
|
|
containerTransition.updateFrame(node: self.containerNode, frame: containerFrame)
|
|
if let effectView = self.effectView {
|
|
containerTransition.updateFrame(view: effectView, frame: bounds)
|
|
}
|
|
containerTransition.updateFrame(node: self.backgroundNode, frame: containerBounds)
|
|
|
|
var shadowFrame = bounds.insetBy(dx: -16.0, dy: -24.0)
|
|
shadowFrame.size.height += 44.0
|
|
transition.updateFrame(node: self.shadowNode, frame: shadowFrame)
|
|
|
|
let _ = self.updateScrollLayoutIfNeeded(force: isCollapsedUpdated, transition: containerTransition)
|
|
|
|
var buttonTransition: Transition = .immediate
|
|
if isCollapsedUpdated {
|
|
buttonTransition = .easeInOut(duration: 0.25)
|
|
}
|
|
|
|
self.updateViews(transition: buttonTransition)
|
|
}
|
|
|
|
func scrollViewDidScroll(_ scrollView: UIScrollView) {
|
|
self.updateViews(transition: .immediate)
|
|
}
|
|
}
|