Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/PresentationDataUtils/BUILD

@@ -0,0 +1,26 @@
+load("@build_bazel_rules_swift//swift:swift.bzl", "swift_library")
+
+swift_library(
+    name = "PresentationDataUtils",
+    module_name = "PresentationDataUtils",
+    srcs = glob([
+		"Sources/**/*.swift",
+    ]),
+    copts = [
+        "-warnings-as-errors",
+    ],
+    deps = [
+        "//submodules/Display:Display",
+        "//submodules/SSignalKit/SwiftSignalKit:SwiftSignalKit",
+        "//submodules/AccountContext:AccountContext",
+        "//submodules/TelegramPresentationData:TelegramPresentationData",
+        "//submodules/AlertUI:AlertUI",
+        "//submodules/ItemListUI:ItemListUI",
+        "//submodules/SolidRoundedButtonNode:SolidRoundedButtonNode",
+        "//submodules/OverlayStatusController:OverlayStatusController",
+        "//submodules/UrlWhitelist:UrlWhitelist",
+    ],
+    visibility = [
+        "//visibility:public",
+    ],
+)

submodules/PresentationDataUtils/Sources/AlertTheme.swift

@@ -0,0 +1,49 @@
+import Foundation
+import Display
+import AlertUI
+import AccountContext
+import SwiftSignalKit
+import TelegramPresentationData
+
+public func textAlertController(context: AccountContext, updatedPresentationData: (initial: PresentationData, signal: Signal<PresentationData, NoError>)? = nil, forceTheme: PresentationTheme? = nil, title: String?, text: String, actions: [TextAlertAction], actionLayout: TextAlertContentActionLayout = .horizontal, allowInputInset: Bool = true, parseMarkdown: Bool = false, dismissOnOutsideTap: Bool = true, linkAction: (([NSAttributedString.Key: Any], Int) -> Void)? = nil) -> AlertController {
+    return textAlertController(sharedContext: context.sharedContext, updatedPresentationData: updatedPresentationData, forceTheme: forceTheme, title: title, text: text, actions: actions, actionLayout: actionLayout, allowInputInset: allowInputInset, parseMarkdown: parseMarkdown, dismissOnOutsideTap: dismissOnOutsideTap, linkAction: linkAction)
+}
+
+public func textAlertController(sharedContext: SharedAccountContext, updatedPresentationData: (initial: PresentationData, signal: Signal<PresentationData, NoError>)? = nil, forceTheme: PresentationTheme? = nil, title: String?, text: String, actions: [TextAlertAction], actionLayout: TextAlertContentActionLayout = .horizontal, allowInputInset: Bool = true, parseMarkdown: Bool = false, dismissOnOutsideTap: Bool = true, linkAction: (([NSAttributedString.Key: Any], Int) -> Void)? = nil) -> AlertController {
+    var presentationData = updatedPresentationData?.initial ?? sharedContext.currentPresentationData.with { $0 }
+    if let forceTheme = forceTheme {
+        presentationData = presentationData.withUpdated(theme: forceTheme)
+    }
+    return textAlertController(alertContext: AlertControllerContext(theme: AlertControllerTheme(presentationData: presentationData), themeSignal: (updatedPresentationData?.signal ?? sharedContext.presentationData) |> map {
+        presentationData in
+        var presentationData = presentationData
+        if let forceTheme = forceTheme {
+            presentationData = presentationData.withUpdated(theme: forceTheme)
+        }
+        return AlertControllerTheme(presentationData: presentationData)
+    }), title: title, text: text, actions: actions, actionLayout: actionLayout, allowInputInset: allowInputInset, parseMarkdown: parseMarkdown, dismissOnOutsideTap: dismissOnOutsideTap, linkAction: linkAction)
+}
+
+public func textAlertController(sharedContext: SharedAccountContext, title: String?, text: String, actions: [TextAlertAction], actionLayout: TextAlertContentActionLayout = .horizontal, allowInputInset: Bool = true, dismissOnOutsideTap: Bool = true) -> AlertController {
+    return textAlertController(alertContext: AlertControllerContext(theme: AlertControllerTheme(presentationData: sharedContext.currentPresentationData.with { $0 }), themeSignal: sharedContext.presentationData |> map { presentationData in AlertControllerTheme(presentationData: presentationData) }), title: title, text: text, actions: actions, actionLayout: actionLayout, allowInputInset: allowInputInset, dismissOnOutsideTap: dismissOnOutsideTap)
+}
+
+public func richTextAlertController(context: AccountContext, title: NSAttributedString?, text: NSAttributedString, actions: [TextAlertAction], actionLayout: TextAlertContentActionLayout = .horizontal, allowInputInset: Bool = true, dismissAutomatically: Bool = true) -> AlertController {
+    return richTextAlertController(alertContext: AlertControllerContext(theme: AlertControllerTheme(presentationData: context.sharedContext.currentPresentationData.with { $0 }), themeSignal: context.sharedContext.presentationData |> map { presentationData in AlertControllerTheme(presentationData: presentationData) }), title: title, text: text, actions: actions, actionLayout: actionLayout, allowInputInset: allowInputInset, dismissAutomatically: dismissAutomatically)
+}
+
+public func textWithEntitiesAlertController(context: AccountContext, title: NSAttributedString?, text: NSAttributedString, actions: [TextAlertAction], actionLayout: TextAlertContentActionLayout = .horizontal, allowInputInset: Bool = true, dismissAutomatically: Bool = true) -> AlertController {
+    return textWithEntitiesAlertController(
+        alertContext: AlertControllerContext(
+            theme: AlertControllerTheme(presentationData: context.sharedContext.currentPresentationData.with { $0 }),
+            themeSignal: context.sharedContext.presentationData |> map { presentationData in AlertControllerTheme(presentationData: presentationData) }
+        ),
+        title: title,
+        text: text,
+        actions: actions,
+        actionLayout: actionLayout,
+        allowInputInset: allowInputInset,
+        dismissAutomatically: dismissAutomatically
+    )
+}
+

submodules/PresentationDataUtils/Sources/ItemListController.swift

@@ -0,0 +1,17 @@
+import Foundation
+import Display
+import AlertUI
+import AccountContext
+import SwiftSignalKit
+import ItemListUI
+
+public extension ItemListController {
+    convenience init<ItemGenerationArguments>(context: AccountContext, state: Signal<(ItemListControllerState, (ItemListNodeState, ItemGenerationArguments)), NoError>, tabBarItem: Signal<ItemListControllerTabBarItem, NoError>? = nil, hideNavigationBarBackground: Bool = false) {
+        self.init(sharedContext: context.sharedContext, state: state, tabBarItem: tabBarItem, hideNavigationBarBackground: hideNavigationBarBackground)
+    }
+    
+    convenience init<ItemGenerationArguments>(sharedContext: SharedAccountContext, state: Signal<(ItemListControllerState, (ItemListNodeState, ItemGenerationArguments)), NoError>, tabBarItem: Signal<ItemListControllerTabBarItem, NoError>? = nil, hideNavigationBarBackground: Bool = false) {
+        let presentationData = sharedContext.currentPresentationData.with { $0 }
+        self.init(presentationData: ItemListPresentationData(presentationData), updatedPresentationData: sharedContext.presentationData |> map(ItemListPresentationData.init(_:)), state: state, tabBarItem: tabBarItem, hideNavigationBarBackground: hideNavigationBarBackground)
+    }
+}

submodules/PresentationDataUtils/Sources/OpenUrl.swift

@@ -0,0 +1,107 @@
+import Foundation
+import Display
+import SwiftSignalKit
+import Postbox
+import AccountContext
+import OverlayStatusController
+import UrlWhitelist
+import TelegramPresentationData
+
+public func openUserGeneratedUrl(context: AccountContext, peerId: PeerId?, url: String, concealed: Bool, skipUrlAuth: Bool = false, skipConcealedAlert: Bool = false, forceDark: Bool = false, present: @escaping (ViewController) -> Void, openResolved: @escaping (ResolvedUrl) -> Void, progress: Promise<Bool>? = nil, alertDisplayUpdated: ((ViewController?) -> Void)? = nil) -> Disposable {
+    var concealed = concealed
+    
+    var presentationData = context.sharedContext.currentPresentationData.with { $0 }
+    if forceDark {
+        presentationData = presentationData.withUpdated(theme: defaultDarkColorPresentationTheme)
+    }
+    
+    let openImpl: () -> Disposable = {
+        let disposable = MetaDisposable()
+        var cancelImpl: (() -> Void)?
+        let progressSignal: Signal<Never, NoError>
+        
+        if let progress {
+            progressSignal = Signal<Never, NoError> { subscriber in
+                progress.set(.single(true))
+                return ActionDisposable {
+                    progress.set(.single(false))
+                }
+            }
+            |> runOn(Queue.mainQueue())
+        } else {
+            progressSignal = Signal<Never, NoError> { subscriber in
+                let controller = OverlayStatusController(theme: presentationData.theme,  type: .loading(cancelled: {
+                    cancelImpl?()
+                }))
+                present(controller)
+                return ActionDisposable { [weak controller] in
+                    Queue.mainQueue().async() {
+                        controller?.dismiss()
+                    }
+                }
+            }
+            |> runOn(Queue.mainQueue())
+        }
+        let progressDisposable = MetaDisposable()
+        var didStartProgress = false
+        
+        cancelImpl = {
+            disposable.dispose()
+        }
+        
+        var resolveSignal: Signal<ResolveUrlResult, NoError>
+        resolveSignal = context.sharedContext.resolveUrlWithProgress(context: context, peerId: peerId, url: url, skipUrlAuth: skipUrlAuth)
+        #if DEBUG
+        //resolveSignal = .single(.progress) |> then(resolveSignal |> delay(2.0, queue: .mainQueue()))
+        #endif
+        
+        disposable.set((resolveSignal
+        |> afterDisposed {
+            Queue.mainQueue().async {
+                progressDisposable.dispose()
+            }
+        }
+        |> deliverOnMainQueue).start(next: { result in
+            switch result {
+            case .progress:
+                if !didStartProgress {
+                    didStartProgress = true
+                    progressDisposable.set(progressSignal.start())
+                }
+            case let .result(result):
+                progressDisposable.dispose()
+                openResolved(result)
+            }
+        }))
+        
+        return ActionDisposable {
+            cancelImpl?()
+        }
+    }
+    
+    let (parsedString, parsedConcealed) = parseUrl(url: url, wasConcealed: concealed)
+    concealed = parsedConcealed
+    
+    if concealed && !skipConcealedAlert {
+        var rawDisplayUrl: String = parsedString
+        let maxLength = 180
+        if rawDisplayUrl.count > maxLength {
+            rawDisplayUrl = String(rawDisplayUrl[..<rawDisplayUrl.index(rawDisplayUrl.startIndex, offsetBy: maxLength - 2)]) + "..."
+        }
+        var displayUrl = rawDisplayUrl
+        displayUrl = displayUrl.replacingOccurrences(of: "\u{202e}", with: "")
+        let disposable = MetaDisposable()
+        
+        let alertController = textAlertController(context: context, forceTheme: forceDark ? presentationData.theme : nil, title: nil, text: presentationData.strings.Generic_OpenHiddenLinkAlert(displayUrl).string, actions: [TextAlertAction(type: .genericAction, title: presentationData.strings.Common_No, action: {}), TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_Yes, action: {
+            disposable.set(openImpl())
+        })])
+        alertController.dismissed = {  _ in
+            alertDisplayUpdated?(nil)
+        }
+        present(alertController)
+        alertDisplayUpdated?(alertController)
+        return disposable
+    } else {
+        return openImpl()
+    }
+}

submodules/PresentationDataUtils/Sources/OverlayStatusController.swift

@@ -0,0 +1,9 @@
+import Foundation
+import UIKit
+import OverlayStatusController
+import TelegramPresentationData
+import Display
+
+public func OverlayStatusController(theme: PresentationTheme, type: OverlayStatusControllerType) -> ViewController {
+    return OverlayStatusController(style: theme.actionSheet.backgroundType == .light ? .light : .dark, type: type)
+}

submodules/PresentationDataUtils/Sources/SolidRoundedButtonNode.swift

@@ -0,0 +1,10 @@
+import Foundation
+import UIKit
+import SolidRoundedButtonNode
+import TelegramPresentationData
+
+public extension SolidRoundedButtonTheme {
+    convenience init(theme: PresentationTheme) {
+        self.init(backgroundColor: theme.list.itemCheckColors.fillColor, backgroundColors: [], foregroundColor: theme.list.itemCheckColors.foregroundColor, disabledBackgroundColor: theme.list.plainBackgroundColor.mixedWith(theme.list.itemDisabledTextColor, alpha: 0.15), disabledForegroundColor: theme.list.itemDisabledTextColor)
+    }
+}

submodules/PresentationDataUtils/Sources/SpecialTabBarIcons.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+public func useSpecialTabBarIcons() -> Bool {
+    return (Date(timeIntervalSince1970: 1608800400)...Date(timeIntervalSince1970: 1609545600)).contains(Date())
+}