GLEGram 12.5 — Initial public release

Based on Swiftgram 12.5 (Telegram iOS 12.5).
All GLEGram features ported and organized in GLEGram/ folder.

Features: Ghost Mode, Saved Deleted Messages, Content Protection Bypass,
Font Replacement, Fake Profile, Chat Export, Plugin System, and more.

See CHANGELOG_12.5.md for full details.

submodules/TelegramUI/Components/GlassControls/Sources/GlassControlGroup.swift

@@ -0,0 +1,302 @@
+import Foundation
+import UIKit
+import Display
+import TelegramPresentationData
+import ComponentFlow
+import GlassBackgroundComponent
+import PlainButtonComponent
+import BundleIconComponent
+import MultilineTextComponent
+import LottieComponent
+
+public final class GlassControlGroupComponent: Component {
+    public final class Item: Equatable {
+        public enum Content: Equatable {
+            case icon(String)
+            case text(String)
+            case animation(String)
+            case customIcon(id: AnyHashable, component: AnyComponent<Empty>)
+            
+            enum Id: Hashable {
+                case icon(String)
+                case text(String)
+                case animation(String)
+                case customIcon(AnyHashable)
+            }
+            
+            var id: Id {
+                switch self {
+                case let .icon(icon):
+                    return .icon(icon)
+                case let .text(text):
+                    return .text(text)
+                case let .animation(animation):
+                    return .animation(animation)
+                case let .customIcon(id, _):
+                    return .customIcon(id)
+                }
+            }
+        }
+        
+        public let id: AnyHashable
+        public let content: Content
+        public let action: (() -> Void)?
+
+        public init(id: AnyHashable, content: Content, action: (() -> Void)?) {
+            self.id = id
+            self.content = content
+            self.action = action
+        }
+        
+        public static func ==(lhs: Item, rhs: Item) -> Bool {
+            if lhs.id != rhs.id {
+                return false
+            }
+            if lhs.content != rhs.content {
+                return false
+            }
+            if (lhs.action == nil) != (rhs.action == nil) {
+                return false
+            }
+            return true
+        }
+    }
+
+    public enum Background: Equatable {
+        case panel
+        case activeTint
+        case color(UIColor)
+    }
+
+    public let theme: PresentationTheme
+    public let preferClearGlass: Bool
+    public let background: Background
+    public let items: [Item]
+    public let minWidth: CGFloat
+
+    public init(
+        theme: PresentationTheme,
+        preferClearGlass: Bool,
+        background: Background,
+        items: [Item],
+        minWidth: CGFloat
+    ) {
+        self.theme = theme
+        self.preferClearGlass = preferClearGlass
+        self.background = background
+        self.items = items
+        self.minWidth = minWidth
+    }
+
+    public static func ==(lhs: GlassControlGroupComponent, rhs: GlassControlGroupComponent) -> Bool {
+        if lhs.theme !== rhs.theme {
+            return false
+        }
+        if lhs.preferClearGlass != rhs.preferClearGlass {
+            return false
+        }
+        if lhs.background != rhs.background {
+            return false
+        }
+        if lhs.items != rhs.items {
+            return false
+        }
+        if lhs.minWidth != rhs.minWidth {
+            return false
+        }
+        return true
+    }
+    
+    private struct ItemId: Hashable {
+        let id: AnyHashable
+        let contentId: AnyHashable
+        
+        init(id: AnyHashable, contentId: AnyHashable) {
+            self.id = id
+            self.contentId = contentId
+        }
+    }
+
+    public final class View: UIView {
+        private let backgroundView: GlassBackgroundView
+        private var itemViews: [ItemId: ComponentView<Empty>] = [:]
+        private var animations: [ItemId: ActionSlot<Void>] = [:]
+        
+        private var component: GlassControlGroupComponent?
+        private weak var state: EmptyComponentState?
+
+        override public init(frame: CGRect) {
+            self.backgroundView = GlassBackgroundView()
+            
+            super.init(frame: frame)
+            
+            self.addSubview(self.backgroundView)
+        }
+        
+        required public init(coder aDecoder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+
+        public func itemView(id: AnyHashable) -> UIView? {
+            for (itemId, itemView) in self.itemViews {
+                if itemId.id == id {
+                    return itemView.view
+                }
+            }
+            return nil
+        }
+        
+        func update(component: GlassControlGroupComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            let alphaTransition: ComponentTransition = transition.animation.isImmediate ? .immediate : .easeInOut(duration: 0.2)
+            
+            self.component = component
+            self.state = state
+            
+            let foregroundColor: UIColor
+            let tintColor: GlassBackgroundView.TintColor
+            switch component.background {
+            case .panel:
+                foregroundColor = component.theme.chat.inputPanel.panelControlColor
+                tintColor = .init(kind: component.preferClearGlass ? .clear : .panel)
+            case .activeTint:
+                foregroundColor = component.theme.list.itemCheckColors.foregroundColor
+                tintColor = .init(kind: component.preferClearGlass ? .clear : .panel, innerColor: component.theme.list.itemCheckColors.fillColor)
+            case let .color(color):
+                foregroundColor = .white
+                tintColor = .init(kind: .custom(style: component.preferClearGlass ? .clear : .default, color: color))
+            }
+            
+            var contentsWidth: CGFloat = 0.0
+            var validIds: [AnyHashable] = []
+            var isInteractive = false
+            for item in component.items {
+                let itemId = ItemId(id: item.id, contentId: item.content.id)
+                
+                validIds.append(itemId)
+                
+                let itemView: ComponentView<Empty>
+                var itemTransition = transition
+                if let current = self.itemViews[itemId] {
+                    itemView = current
+                } else {
+                    itemView = ComponentView()
+                    self.itemViews[itemId] = itemView
+                    itemTransition = itemTransition.withAnimation(.none)
+                }
+                
+                if item.action != nil {
+                    isInteractive = true
+                }
+                
+                let content: AnyComponent<Empty>
+                var itemInsets = UIEdgeInsets()
+                switch item.content {
+                case let .icon(name):
+                    content = AnyComponent(BundleIconComponent(
+                        name: name,
+                        tintColor: foregroundColor
+                    ))
+                case let .text(string):
+                    content = AnyComponent(MultilineTextComponent(
+                        text: .plain(NSAttributedString(string: string, font: Font.medium(17.0), textColor: foregroundColor))
+                    ))
+                    itemInsets.left = 10.0
+                    itemInsets.right = itemInsets.left
+                case let .animation(name):
+                    let playOnce: ActionSlot<Void>
+                    if let current = self.animations[itemId] {
+                        playOnce = current
+                    } else {
+                        playOnce = ActionSlot()
+                        self.animations[itemId] = playOnce
+                    }
+                    content = AnyComponent(LottieComponent(
+                        content: LottieComponent.AppBundleContent(name: name),
+                        color: foregroundColor,
+                        size: CGSize(width: 32.0, height: 32.0),
+                        playOnce: playOnce
+                    ))
+                case let .customIcon(_, customIcon):
+                    content = customIcon
+                }
+                
+                var minItemWidth: CGFloat = availableSize.height
+                if component.items.count == 1 {
+                    minItemWidth = max(minItemWidth, component.minWidth)
+                }
+                
+                let itemSize = itemView.update(
+                    transition: itemTransition,
+                    component: AnyComponent(PlainButtonComponent(
+                        content: content,
+                        minSize: CGSize(width: minItemWidth, height: availableSize.height),
+                        contentInsets: itemInsets,
+                        action: { [weak self] in
+                            item.action?()
+                            
+                            if case .animation = item.content {
+                                self?.animations[itemId]?.invoke(Void())
+                            }
+                        },
+                        isEnabled: item.action != nil,
+                        animateAlpha: false,
+                        animateScale: false,
+                        animateContents: false
+                    )),
+                    environment: {},
+                    containerSize: CGSize(width: availableSize.width, height: availableSize.height)
+                )
+                let itemFrame = CGRect(origin: CGPoint(x: contentsWidth, y: 0.0), size: itemSize)
+                
+                if let itemComponentView = itemView.view {
+                    var animateIn = false
+                    if itemComponentView.superview == nil {
+                        animateIn = true
+                        self.backgroundView.contentView.addSubview(itemComponentView)
+                        itemComponentView.alpha = 0.0
+                    }
+                    itemTransition.setFrame(view: itemComponentView, frame: itemFrame)
+                    alphaTransition.setAlpha(view: itemComponentView, alpha: item.action != nil ? 1.0 : 0.5)
+                    
+                    if animateIn {
+                        alphaTransition.animateBlur(layer: itemComponentView.layer, fromRadius: 8.0, toRadius: 0.0)
+                    }
+                }
+                
+                contentsWidth += itemSize.width
+            }
+            
+            var removeIds: [ItemId] = []
+            for (id, itemView) in self.itemViews {
+                if !validIds.contains(id) {
+                    removeIds.append(id)
+                    if let itemComponentView = itemView.view {
+                        alphaTransition.setAlpha(view: itemComponentView, alpha: 0.0, completion: { [weak itemComponentView] _ in
+                            itemComponentView?.removeFromSuperview()
+                        })
+                        alphaTransition.animateBlur(layer: itemComponentView.layer, fromRadius: 0.0, toRadius: 8.0, removeOnCompletion: false)
+                    }
+                    self.animations[id] = nil
+                }
+            }
+            for id in removeIds {
+                self.itemViews.removeValue(forKey: id)
+            }
+            
+            let size = CGSize(width: contentsWidth, height: availableSize.height)
+            transition.setFrame(view: self.backgroundView, frame: CGRect(origin: CGPoint(), size: size))
+            isInteractive = true
+            self.backgroundView.update(size: size, cornerRadius: size.height * 0.5, isDark: component.theme.overallDarkAppearance, tintColor: tintColor, isInteractive: isInteractive, transition: transition)
+            
+            return size
+        }
+    }
+
+    public func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    public func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
+    }
+}

submodules/TelegramUI/Components/GlassControls/Sources/GlassControlPanel.swift

@@ -0,0 +1,329 @@
+import Foundation
+import UIKit
+import Display
+import TelegramPresentationData
+import ComponentFlow
+import GlassBackgroundComponent
+
+public final class GlassControlPanelComponent: Component {
+    public final class Item: Equatable {
+        public let items: [GlassControlGroupComponent.Item]
+        public let background: GlassControlGroupComponent.Background
+        public let keepWide: Bool
+
+        public init(items: [GlassControlGroupComponent.Item], background: GlassControlGroupComponent.Background, keepWide: Bool = false) {
+            self.items = items
+            self.background = background
+            self.keepWide = keepWide
+        }
+        
+        public static func ==(lhs: Item, rhs: Item) -> Bool {
+            if lhs.items != rhs.items {
+                return false
+            }
+            if lhs.background != rhs.background {
+                return false
+            }
+            if lhs.keepWide != rhs.keepWide {
+                return false
+            }
+            return true
+        }
+    }
+
+    public let theme: PresentationTheme
+    public let preferClearGlass: Bool
+    public let leftItem: Item?
+    public let rightItem: Item?
+    public let centralItem: Item?
+    public let centerAlignmentIfPossible: Bool
+    public let isDark: Bool?
+    public let tag: AnyObject?
+
+    public init(
+        theme: PresentationTheme,
+        preferClearGlass: Bool = false,
+        leftItem: Item?,
+        centralItem: Item?,
+        rightItem: Item?,
+        centerAlignmentIfPossible: Bool = false,
+        isDark: Bool? = nil,
+        tag: AnyObject? = nil
+    ) {
+        self.theme = theme
+        self.preferClearGlass = preferClearGlass
+        self.leftItem = leftItem
+        self.centralItem = centralItem
+        self.rightItem = rightItem
+        self.centerAlignmentIfPossible = centerAlignmentIfPossible
+        self.isDark = isDark
+        self.tag = tag
+    }
+
+    public static func ==(lhs: GlassControlPanelComponent, rhs: GlassControlPanelComponent) -> Bool {
+        if lhs.theme !== rhs.theme {
+            return false
+        }
+        if lhs.preferClearGlass != rhs.preferClearGlass {
+            return false
+        }
+        if lhs.leftItem != rhs.leftItem {
+            return false
+        }
+        if lhs.centralItem != rhs.centralItem {
+            return false
+        }
+        if lhs.rightItem != rhs.rightItem {
+            return false
+        }
+        if lhs.centerAlignmentIfPossible != rhs.centerAlignmentIfPossible {
+            return false
+        }
+        if lhs.isDark != rhs.isDark {
+            return false
+        }
+        if lhs.tag !== rhs.tag {
+            return false
+        }
+        return true
+    }
+
+    public final class View: UIView, 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 glassContainerView: GlassBackgroundContainerView
+        
+        private var leftItemComponent: ComponentView<Empty>?
+        private var centralItemComponent: ComponentView<Empty>?
+        private var rightItemComponent: ComponentView<Empty>?
+        
+        private var component: GlassControlPanelComponent?
+        private weak var state: EmptyComponentState?
+
+        public var leftItemView: GlassControlGroupComponent.View? {
+            return self.leftItemComponent?.view as? GlassControlGroupComponent.View
+        }
+
+        public var centerItemView: GlassControlGroupComponent.View? {
+            return self.centralItemComponent?.view as? GlassControlGroupComponent.View
+        }
+
+        public var rightItemView: GlassControlGroupComponent.View? {
+            return self.rightItemComponent?.view as? GlassControlGroupComponent.View
+        }
+
+        override public init(frame: CGRect) {
+            self.glassContainerView = GlassBackgroundContainerView()
+            
+            super.init(frame: frame)
+            
+            self.addSubview(self.glassContainerView)
+        }
+        
+        required public init(coder aDecoder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        func update(component: GlassControlPanelComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            self.component = component
+            self.state = state
+            
+            let alphaTransition: ComponentTransition = transition.animation.isImmediate ? .immediate : .easeInOut(duration: 0.2)
+            let minSpacing: CGFloat = 8.0
+            
+            var leftItemFrame: CGRect?
+            if let leftItem = component.leftItem {
+                let leftItemComponent: ComponentView<Empty>
+                var leftItemTransition = transition
+                if let current = self.leftItemComponent {
+                    leftItemComponent = current
+                } else {
+                    leftItemComponent = ComponentView()
+                    self.leftItemComponent = leftItemComponent
+                    leftItemTransition = transition.withAnimation(.none)
+                }
+                
+                let leftItemSize = leftItemComponent.update(
+                    transition: leftItemTransition,
+                    component: AnyComponent(GlassControlGroupComponent(
+                        theme: component.theme,
+                        preferClearGlass: component.preferClearGlass,
+                        background: leftItem.background,
+                        items: leftItem.items,
+                        minWidth: availableSize.height
+                    )),
+                    environment: {},
+                    containerSize: CGSize(width: availableSize.width, height: availableSize.height)
+                )
+                let leftItemFrameValue = CGRect(origin: CGPoint(x: 0.0, y: 0.0), size: leftItemSize)
+                leftItemFrame = leftItemFrameValue
+                if let leftItemComponentView = leftItemComponent.view {
+                    var animateIn = false
+                    if leftItemComponentView.superview == nil {
+                        animateIn = true
+                        self.glassContainerView.contentView.addSubview(leftItemComponentView)
+                        ComponentTransition.immediate.setScale(view: leftItemComponentView, scale: 0.001)
+                    }
+                    leftItemTransition.setPosition(view: leftItemComponentView, position: leftItemFrameValue.center)
+                    leftItemTransition.setBounds(view: leftItemComponentView, bounds: CGRect(origin: CGPoint(), size: leftItemFrameValue.size))
+                    if animateIn {
+                        alphaTransition.animateAlpha(view: leftItemComponentView, from: 0.0, to: 1.0)
+                        transition.setScale(view: leftItemComponentView, scale: 1.0)
+                    }
+                }
+            } else if let leftItemComponent = self.leftItemComponent {
+                self.leftItemComponent = nil
+                if let leftItemComponentView = leftItemComponent.view {
+                    transition.setScale(view: leftItemComponentView, scale: 0.001)
+                    alphaTransition.setAlpha(view: leftItemComponentView, alpha: 0.0, completion: { [weak leftItemComponentView] _ in
+                        leftItemComponentView?.removeFromSuperview()
+                    })
+                }
+            }
+            
+            var rightItemFrame: CGRect?
+            if let rightItem = component.rightItem {
+                let rightItemComponent: ComponentView<Empty>
+                var rightItemTransition = transition
+                if let current = self.rightItemComponent {
+                    rightItemComponent = current
+                } else {
+                    rightItemComponent = ComponentView()
+                    self.rightItemComponent = rightItemComponent
+                    rightItemTransition = transition.withAnimation(.none)
+                }
+                
+                let rightItemSize = rightItemComponent.update(
+                    transition: rightItemTransition,
+                    component: AnyComponent(GlassControlGroupComponent(
+                        theme: component.theme,
+                        preferClearGlass: component.preferClearGlass,
+                        background: rightItem.background,
+                        items: rightItem.items,
+                        minWidth: availableSize.height
+                    )),
+                    environment: {},
+                    containerSize: CGSize(width: availableSize.width, height: availableSize.height)
+                )
+                let rightItemFrameValue = CGRect(origin: CGPoint(x: availableSize.width - rightItemSize.width, y: 0.0), size: rightItemSize)
+                rightItemFrame = rightItemFrameValue
+                if let rightItemComponentView = rightItemComponent.view {
+                    var animateIn = false
+                    if rightItemComponentView.superview == nil {
+                        animateIn = true
+                        self.glassContainerView.contentView.addSubview(rightItemComponentView)
+                        ComponentTransition.immediate.setScale(view: rightItemComponentView, scale: 0.001)
+                    }
+                    rightItemTransition.setPosition(view: rightItemComponentView, position: rightItemFrameValue.center)
+                    rightItemTransition.setBounds(view: rightItemComponentView, bounds: CGRect(origin: CGPoint(), size: rightItemFrameValue.size))
+                    if animateIn {
+                        alphaTransition.animateAlpha(view: rightItemComponentView, from: 0.0, to: 1.0)
+                        transition.setScale(view: rightItemComponentView, scale: 1.0)
+                    }
+                }
+            } else if let rightItemComponent = self.rightItemComponent {
+                self.rightItemComponent = nil
+                if let rightItemComponentView = rightItemComponent.view {
+                    transition.setScale(view: rightItemComponentView, scale: 0.001)
+                    alphaTransition.setAlpha(view: rightItemComponentView, alpha: 0.0, completion: { [weak rightItemComponentView] _ in
+                        rightItemComponentView?.removeFromSuperview()
+                    })
+                }
+            }
+            
+            if let centralItem = component.centralItem {
+                let centralItemComponent: ComponentView<Empty>
+                var centralItemTransition = transition
+                if let current = self.centralItemComponent {
+                    centralItemComponent = current
+                } else {
+                    centralItemComponent = ComponentView()
+                    self.centralItemComponent = centralItemComponent
+                    centralItemTransition = transition.withAnimation(.none)
+                }
+                
+                var maxCentralItemSize = CGSize(width: availableSize.width, height: availableSize.height)
+                var centralRightInset: CGFloat = 0.0
+                if let rightItemFrame {
+                    centralRightInset = availableSize.width - rightItemFrame.minX + minSpacing
+                }
+                var centralLeftInset: CGFloat = 0.0
+                if let leftItemFrame {
+                    centralLeftInset = leftItemFrame.maxX + minSpacing
+                }
+                
+                if centralRightInset <= 48.0 && centralLeftInset <= 48.0 {
+                    let maxInset = max(centralRightInset, centralLeftInset)
+                    centralLeftInset = maxInset
+                    centralRightInset = maxInset
+                }
+                
+                maxCentralItemSize.width = max(1.0, availableSize.width - centralLeftInset - centralRightInset)
+                
+                let centralItemSize = centralItemComponent.update(
+                    transition: centralItemTransition,
+                    component: AnyComponent(GlassControlGroupComponent(
+                        theme: component.theme,
+                        preferClearGlass: component.preferClearGlass,
+                        background: centralItem.background,
+                        items: centralItem.items,
+                        minWidth: centralItem.keepWide ? 165.0 : availableSize.height
+                    )),
+                    environment: {},
+                    containerSize: maxCentralItemSize
+                )
+                var centralItemFrameValue = CGRect(origin: CGPoint(x: centralLeftInset + floor((availableSize.width - centralLeftInset - centralRightInset - centralItemSize.width) * 0.5), y: 0.0), size: centralItemSize)
+                if component.centerAlignmentIfPossible {
+                    let maxInset = max(centralLeftInset, centralRightInset)
+                    if availableSize.width - maxInset * 2.0 > centralItemSize.width {
+                        centralItemFrameValue.origin.x = maxInset + floor((availableSize.width - maxInset * 2.0 - centralItemSize.width) * 0.5)
+                    }
+                }
+                
+                if let centralItemComponentView = centralItemComponent.view {
+                    var animateIn = false
+                    if centralItemComponentView.superview == nil {
+                        animateIn = true
+                        self.glassContainerView.contentView.addSubview(centralItemComponentView)
+                        ComponentTransition.immediate.setScale(view: centralItemComponentView, scale: 0.001)
+                    }
+                    centralItemTransition.setPosition(view: centralItemComponentView, position: centralItemFrameValue.center)
+                    centralItemTransition.setBounds(view: centralItemComponentView, bounds: CGRect(origin: CGPoint(), size: centralItemFrameValue.size))
+                    if animateIn {
+                        alphaTransition.animateAlpha(view: centralItemComponentView, from: 0.0, to: 1.0)
+                        transition.setScale(view: centralItemComponentView, scale: 1.0)
+                    }
+                }
+            } else if let centralItemComponent = self.centralItemComponent {
+                self.centralItemComponent = nil
+                if let centralItemComponentView = centralItemComponent.view {
+                    transition.setScale(view: centralItemComponentView, scale: 0.001)
+                    alphaTransition.setAlpha(view: centralItemComponentView, alpha: 0.0, completion: { [weak centralItemComponentView] _ in
+                        centralItemComponentView?.removeFromSuperview()
+                    })
+                }
+            }
+            
+            transition.setFrame(view: self.glassContainerView, frame: CGRect(origin: CGPoint(), size: availableSize))
+            self.glassContainerView.update(size: availableSize, isDark: component.isDark ?? component.theme.overallDarkAppearance, transition: transition)
+            
+            return availableSize
+        }
+    }
+
+    public func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    public func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
+    }
+}