import Foundation import Display import UIKit import AsyncDisplayKit import TelegramPresentationData import TelegramStringFormatting import SegmentedControlNode import DirectionalPanGesture public final class DatePickerTheme: Equatable { public let backgroundColor: UIColor public let textColor: UIColor public let secondaryTextColor: UIColor public let accentColor: UIColor public let disabledColor: UIColor public let selectionColor: UIColor public let selectionTextColor: UIColor public let separatorColor: UIColor public let segmentedControlTheme: SegmentedControlTheme public let overallDarkAppearance: Bool public init(backgroundColor: UIColor, textColor: UIColor, secondaryTextColor: UIColor, accentColor: UIColor, disabledColor: UIColor, selectionColor: UIColor, selectionTextColor: UIColor, separatorColor: UIColor, segmentedControlTheme: SegmentedControlTheme, overallDarkAppearance: Bool) { self.backgroundColor = backgroundColor self.textColor = textColor self.secondaryTextColor = secondaryTextColor self.accentColor = accentColor self.disabledColor = disabledColor self.selectionColor = selectionColor self.selectionTextColor = selectionTextColor self.separatorColor = separatorColor self.segmentedControlTheme = segmentedControlTheme self.overallDarkAppearance = overallDarkAppearance } public static func ==(lhs: DatePickerTheme, rhs: DatePickerTheme) -> Bool { if lhs.backgroundColor != rhs.backgroundColor { return false } if lhs.textColor != rhs.textColor { return false } if lhs.secondaryTextColor != rhs.secondaryTextColor { return false } if lhs.accentColor != rhs.accentColor { return false } if lhs.selectionColor != rhs.selectionColor { return false } if lhs.selectionTextColor != rhs.selectionTextColor { return false } if lhs.separatorColor != rhs.separatorColor { return false } if lhs.overallDarkAppearance != rhs.overallDarkAppearance { return false } return true } } public extension DatePickerTheme { convenience init(theme: PresentationTheme) { self.init(backgroundColor: theme.list.itemBlocksBackgroundColor, textColor: theme.list.itemPrimaryTextColor, secondaryTextColor: theme.list.itemSecondaryTextColor, accentColor: theme.list.itemAccentColor, disabledColor: theme.list.itemDisabledTextColor, selectionColor: theme.list.itemCheckColors.fillColor, selectionTextColor: theme.list.itemCheckColors.foregroundColor, separatorColor: theme.list.itemBlocksSeparatorColor, segmentedControlTheme: SegmentedControlTheme(theme: theme), overallDarkAppearance: theme.overallDarkAppearance) } } private let telegramReleaseDate = Date(timeIntervalSince1970: 1376438400.0) private let upperLimitDate = Date(timeIntervalSince1970: Double(Int32.max - 1)) private let controlFont = Font.regular(17.0) private let dayFont = Font.regular(13.0) private let dateFont = Font.with(size: 17.0, design: .regular, traits: .monospacedNumbers) private let selectedDateFont = Font.with(size: 17.0, design: .regular, weight: .bold, traits: .monospacedNumbers) private var calendar: Calendar = { var calendar = Calendar(identifier: .gregorian) calendar.locale = Locale.current return calendar }() private func monthForDate(_ date: Date) -> Date { var components = calendar.dateComponents([.year, .month], from: date) components.hour = 0 components.minute = 0 components.second = 0 return calendar.date(from: components)! } private func generateSmallArrowImage(color: UIColor) -> UIImage? { return generateImage(CGSize(width: 7.0, height: 12.0), rotatedContext: { size, context in context.clear(CGRect(origin: CGPoint(), size: size)) context.setStrokeColor(color.cgColor) context.setLineWidth(2.0) context.setLineCap(.round) context.beginPath() context.move(to: CGPoint(x: 1.0, y: 1.0)) context.addLine(to: CGPoint(x: size.width - 1.0, y: size.height / 2.0)) context.addLine(to: CGPoint(x: 1.0, y: size.height - 1.0)) context.strokePath() }) } private func generateNavigationArrowImage(color: UIColor, mirror: Bool) -> UIImage? { return generateImage(CGSize(width: 10.0, height: 17.0), rotatedContext: { size, context in context.clear(CGRect(origin: CGPoint(), size: size)) context.setStrokeColor(color.cgColor) context.setLineWidth(2.0) context.setLineCap(.round) context.beginPath() if mirror { context.translateBy(x: 5.0, y: 8.5) context.scaleBy(x: -1.0, y: 1.0) context.translateBy(x: -5.0, y: -8.5) } context.move(to: CGPoint(x: 1.0, y: 1.0)) context.addLine(to: CGPoint(x: size.width - 1.0, y: size.height / 2.0)) context.addLine(to: CGPoint(x: 1.0, y: size.height - 1.0)) context.strokePath() }) } private func yearRange(for state: DatePickerNode.State) -> Range { let minYear = calendar.component(.year, from: state.minDate) let maxYear = calendar.component(.year, from: state.maxDate) return minYear ..< maxYear + 1 } public final class DatePickerNode: ASDisplayNode { class MonthNode: ASDisplayNode { let month: Date var theme: DatePickerTheme { didSet { self.selectionNode.image = generateStretchableFilledCircleImage(diameter: 44.0, color: self.theme.selectionColor) if let size = self.validSize { self.updateLayout(size: size) } } } var maximumDate: Date? var minimumDate: Date? var date: Date? private var validSize: CGSize? private let selectionNode: ASImageNode private let dateNodes: [ImmediateTextNode] private let firstWeekday: Int private let startWeekday: Int private let numberOfDays: Int init(theme: DatePickerTheme, month: Date, minimumDate: Date?, maximumDate: Date?, date: Date?) { self.theme = theme self.month = month self.minimumDate = minimumDate self.maximumDate = maximumDate self.date = date self.selectionNode = ASImageNode() self.selectionNode.displaysAsynchronously = false self.selectionNode.displayWithoutProcessing = true self.selectionNode.image = generateStretchableFilledCircleImage(diameter: 44.0, color: theme.selectionColor) self.dateNodes = (0..<42).map { _ in ImmediateTextNode() } let components = calendar.dateComponents([.year, .month], from: month) let startDayDate = calendar.date(from: components)! self.firstWeekday = calendar.firstWeekday self.startWeekday = calendar.dateComponents([.weekday], from: startDayDate).weekday! self.numberOfDays = calendar.range(of: .day, in: .month, for: month)!.count super.init() self.addSubnode(self.selectionNode) self.dateNodes.forEach { self.addSubnode($0) } } func dateAtPoint(_ point: CGPoint) -> Int32? { var day: Int32 = 0 for node in self.dateNodes { if node.isHidden { continue } day += 1 if node.frame.insetBy(dx: -15.0, dy: -15.0).contains(point) { return day } } return nil } func updateLayout(size: CGSize) { var weekday = self.firstWeekday var started = false var ended = false var count = 0 let sideInset: CGFloat = 12.0 let cellSize: CGFloat = floor((size.width - sideInset * 2.0) / 7.0) self.selectionNode.isHidden = true for i in 0 ..< 42 { let row: Int = Int(floor(Float(i) / 7.0)) let col: Int = i % 7 if !started && weekday == self.startWeekday { started = true } weekday += 1 if weekday > 7 { weekday = 1 } let textNode = self.dateNodes[i] if started && !ended { textNode.isHidden = false count += 1 var isAvailableDate = true var components = calendar.dateComponents([.year, .month], from: self.month) components.day = count components.hour = 0 components.minute = 0 let date = calendar.date(from: components)! if let minimumDate = self.minimumDate { if date < minimumDate { isAvailableDate = false } } if let maximumDate = self.maximumDate { if date > maximumDate { isAvailableDate = false } } let isToday = calendar.isDateInToday(date) let isSelected = self.date.flatMap { calendar.isDate(date, equalTo: $0, toGranularity: .day) } ?? false let color: UIColor if isSelected { color = self.theme.selectionTextColor } else if isToday { color = self.theme.accentColor } else if !isAvailableDate { color = self.theme.disabledColor } else { color = self.theme.textColor } textNode.attributedText = NSAttributedString(string: "\(count)", font: isSelected ? selectedDateFont : dateFont, textColor: color) let textSize = textNode.updateLayout(size) let cellFrame = CGRect(x: sideInset + CGFloat(col) * cellSize, y: 0.0 + CGFloat(row) * cellSize, width: cellSize, height: cellSize) let textFrame = CGRect(origin: CGPoint(x: cellFrame.minX + floor((cellFrame.width - textSize.width) / 2.0), y: cellFrame.minY + floor((cellFrame.height - textSize.height) / 2.0)), size: textSize) textNode.frame = textFrame if isSelected { self.selectionNode.isHidden = false let selectionSize = CGSize(width: 44.0, height: 44.0) self.selectionNode.frame = CGRect(origin: CGPoint(x: cellFrame.minX + floor((cellFrame.width - selectionSize.width) / 2.0), y: cellFrame.minY + floor((cellFrame.height - selectionSize.height) / 2.0)), size: selectionSize) } if count == self.numberOfDays { ended = true } } else { textNode.isHidden = true } } } } struct State { let minDate: Date let maxDate: Date let date: Date? let displayingMonthSelection: Bool let displayingDateSelection: Bool let displayingTimeSelection: Bool let selectedMonth: Date } private var state: State private var theme: DatePickerTheme private let strings: PresentationStrings private let dateTimeFormat: PresentationDateTimeFormat private let title: String private let timeTitleNode: ImmediateTextNode private let dayNodes: [ImmediateTextNode] private var currentIndex = 0 private var months: [Date] = [] private var monthNodes: [Date: MonthNode] = [:] private let contentNode: ASDisplayNode private let datePickerBackgroundNode: ASDisplayNode private let monthPickerBackgroundNode: ASDisplayNode private var monthPickerNode: MonthPickerNode private let timePickerBackgroundNode: ASDisplayNode private var timePickerNode: TimePickerNode private let dateButtonNode: HighlightableButtonNode private let timeButtonNode: HighlightableButtonNode private let monthButtonNode: HighlightTrackingButtonNode private let monthTextNode: ImmediateTextNode private let monthArrowNode: ASImageNode private let previousButtonNode: HighlightableButtonNode private let nextButtonNode: HighlightableButtonNode private var transitionFraction: CGFloat = 0.0 private var validLayout: CGSize? public var valueUpdated: ((Date) -> Void)? public var minimumDate: Date { get { return self.state.minDate } set { guard newValue != self.minimumDate else { return } let updatedState = State(minDate: newValue, maxDate: self.state.maxDate, date: self.state.date, displayingMonthSelection: self.state.displayingMonthSelection, displayingDateSelection: self.state.displayingDateSelection, displayingTimeSelection: self.state.displayingTimeSelection, selectedMonth: self.state.selectedMonth) self.updateState(updatedState, animated: false) self.monthPickerNode.minimumDate = newValue self.timePickerNode.minimumDate = newValue if let size = self.validLayout { let _ = self.updateLayout(size: size, transition: .immediate) } } } public var maximumDate: Date { get { return self.state.maxDate } set { guard newValue != self.maximumDate else { return } let updatedState = State(minDate: self.state.minDate, maxDate: newValue, date: self.state.date, displayingMonthSelection: self.state.displayingMonthSelection, displayingDateSelection: self.state.displayingDateSelection, displayingTimeSelection: self.state.displayingTimeSelection, selectedMonth: self.state.selectedMonth) self.updateState(updatedState, animated: false) self.monthPickerNode.maximumDate = newValue self.timePickerNode.maximumDate = newValue if let size = self.validLayout { let _ = self.updateLayout(size: size, transition: .immediate) } } } public var date: Date? { get { return self.state.date } set { guard newValue != self.date else { return } let updatedState = State(minDate: self.state.minDate, maxDate: self.state.maxDate, date: newValue, displayingMonthSelection: self.state.displayingMonthSelection, displayingDateSelection: self.state.displayingDateSelection, displayingTimeSelection: self.state.displayingTimeSelection, selectedMonth: newValue.flatMap { monthForDate($0) } ?? self.state.selectedMonth) self.updateState(updatedState, animated: false) if let size = self.validLayout { let _ = self.updateLayout(size: size, transition: .immediate) } } } public init(theme: DatePickerTheme, strings: PresentationStrings, dateTimeFormat: PresentationDateTimeFormat, title: String) { self.theme = theme self.strings = strings self.dateTimeFormat = dateTimeFormat self.state = State(minDate: telegramReleaseDate, maxDate: upperLimitDate, date: nil, displayingMonthSelection: false, displayingDateSelection: false, displayingTimeSelection: false, selectedMonth: monthForDate(Date())) self.title = title let initialDate: Date if let date = calendar.date(byAdding: .hour, value: 11, to: monthForDate(Date())) { initialDate = date } else { initialDate = monthForDate(Date()) } self.timeTitleNode = ImmediateTextNode() self.timeTitleNode.attributedText = NSAttributedString(string: title, font: Font.regular(17.0), textColor: theme.textColor) var timeChangedImpl: ((Date) -> Void)? self.timePickerNode = TimePickerNode(theme: theme, date: self.state.date ?? initialDate, valueChanged: { date in timeChangedImpl?(date) }) self.dayNodes = (0..<7).map { _ in ImmediateTextNode() } self.datePickerBackgroundNode = ASDisplayNode() self.datePickerBackgroundNode.alpha = 0.0 self.datePickerBackgroundNode.backgroundColor = theme.backgroundColor self.datePickerBackgroundNode.isUserInteractionEnabled = false self.contentNode = ASDisplayNode() self.monthPickerBackgroundNode = ASDisplayNode() self.monthPickerBackgroundNode.alpha = 0.0 self.monthPickerBackgroundNode.backgroundColor = theme.backgroundColor self.monthPickerBackgroundNode.isUserInteractionEnabled = false self.timePickerBackgroundNode = ASDisplayNode() self.timePickerBackgroundNode.alpha = 0.0 self.timePickerBackgroundNode.backgroundColor = theme.backgroundColor self.timePickerBackgroundNode.isUserInteractionEnabled = false var monthChangedImpl: ((Date) -> Void)? self.monthPickerNode = MonthPickerNode(theme: theme, strings: strings, date: self.state.date ?? initialDate, yearRange: yearRange(for: self.state), valueChanged: { date in monthChangedImpl?(date) }) self.monthPickerNode.minimumDate = self.state.minDate self.monthPickerNode.maximumDate = self.state.maxDate self.timePickerNode.minimumDate = self.state.minDate self.timePickerNode.maximumDate = self.state.maxDate self.monthButtonNode = HighlightTrackingButtonNode() self.monthTextNode = ImmediateTextNode() self.monthArrowNode = ASImageNode() self.monthArrowNode.displaysAsynchronously = false self.monthArrowNode.displayWithoutProcessing = true self.previousButtonNode = HighlightableButtonNode() self.previousButtonNode.hitTestSlop = UIEdgeInsets(top: -6.0, left: -10.0, bottom: -6.0, right: -10.0) self.nextButtonNode = HighlightableButtonNode() self.nextButtonNode.hitTestSlop = UIEdgeInsets(top: -6.0, left: -10.0, bottom: -6.0, right: -10.0) self.dateButtonNode = HighlightableButtonNode() self.dateButtonNode.clipsToBounds = true self.dateButtonNode.backgroundColor = theme.segmentedControlTheme.backgroundColor self.dateButtonNode.cornerRadius = 9.0 self.timeButtonNode = HighlightableButtonNode() self.timeButtonNode.clipsToBounds = true self.timeButtonNode.backgroundColor = theme.segmentedControlTheme.backgroundColor self.timeButtonNode.cornerRadius = 9.0 super.init() self.clipsToBounds = true self.backgroundColor = theme.backgroundColor self.addSubnode(self.datePickerBackgroundNode) self.datePickerBackgroundNode.addSubnode(self.contentNode) self.dayNodes.forEach { self.datePickerBackgroundNode.addSubnode($0) } self.datePickerBackgroundNode.addSubnode(self.previousButtonNode) self.datePickerBackgroundNode.addSubnode(self.nextButtonNode) self.addSubnode(self.monthPickerBackgroundNode) self.monthPickerBackgroundNode.addSubnode(self.monthPickerNode) self.datePickerBackgroundNode.addSubnode(self.monthTextNode) self.datePickerBackgroundNode.addSubnode(self.monthArrowNode) self.datePickerBackgroundNode.addSubnode(self.monthButtonNode) self.addSubnode(self.timePickerBackgroundNode) self.timePickerBackgroundNode.addSubnode(self.timePickerNode) self.addSubnode(self.timeTitleNode) self.addSubnode(self.dateButtonNode) self.addSubnode(self.timeButtonNode) self.monthArrowNode.image = generateSmallArrowImage(color: theme.accentColor) self.previousButtonNode.setImage(generateNavigationArrowImage(color: theme.accentColor, mirror: true), for: .normal) self.previousButtonNode.setImage(generateNavigationArrowImage(color: theme.disabledColor, mirror: true), for: .disabled) self.nextButtonNode.setImage(generateNavigationArrowImage(color: theme.accentColor, mirror: false), for: .normal) self.nextButtonNode.setImage(generateNavigationArrowImage(color: theme.disabledColor, mirror: false), for: .disabled) self.setupItems() self.monthButtonNode.addTarget(self, action: #selector(self.monthButtonPressed), forControlEvents: .touchUpInside) self.monthButtonNode.highligthedChanged = { [weak self] highlighted in if let strongSelf = self { if highlighted { strongSelf.monthTextNode.layer.removeAnimation(forKey: "opacity") strongSelf.monthTextNode.alpha = 0.4 strongSelf.monthArrowNode.layer.removeAnimation(forKey: "opacity") strongSelf.monthArrowNode.alpha = 0.4 } else { strongSelf.monthTextNode.alpha = 1.0 strongSelf.monthTextNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2) strongSelf.monthArrowNode.alpha = 1.0 strongSelf.monthArrowNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2) } } } self.previousButtonNode.addTarget(self, action: #selector(self.previousButtonPressed), forControlEvents: .touchUpInside) self.nextButtonNode.addTarget(self, action: #selector(self.nextButtonPressed), forControlEvents: .touchUpInside) self.dateButtonNode.addTarget(self, action: #selector(self.dateButtonPressed), forControlEvents: .touchUpInside) self.timeButtonNode.addTarget(self, action: #selector(self.timeButtonPressed), forControlEvents: .touchUpInside) timeChangedImpl = { [weak self] date in if let strongSelf = self { let updatedState = State(minDate: strongSelf.state.minDate, maxDate: strongSelf.state.maxDate, date: date, displayingMonthSelection: strongSelf.state.displayingMonthSelection, displayingDateSelection: strongSelf.state.displayingDateSelection, displayingTimeSelection: strongSelf.state.displayingTimeSelection, selectedMonth: strongSelf.state.selectedMonth) strongSelf.updateState(updatedState, animated: false) strongSelf.valueUpdated?(date) } } monthChangedImpl = { [weak self] date in if let strongSelf = self { let updatedState = State(minDate: strongSelf.state.minDate, maxDate: strongSelf.state.maxDate, date: date, displayingMonthSelection: strongSelf.state.displayingMonthSelection, displayingDateSelection: strongSelf.state.displayingDateSelection, displayingTimeSelection: strongSelf.state.displayingTimeSelection, selectedMonth: monthForDate(date)) strongSelf.updateState(updatedState, animated: false) strongSelf.valueUpdated?(date) } } } override public func didLoad() { super.didLoad() self.view.disablesInteractiveTransitionGestureRecognizer = true let panGesture = DirectionalPanGestureRecognizer(target: self, action: #selector(self.panGesture(_:))) panGesture.direction = .horizontal self.contentNode.view.addGestureRecognizer(panGesture) self.contentNode.view.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.tapGesture(_:)))) } private func updateState(_ state: State, animated: Bool) { let previousState = self.state self.state = state if previousState.minDate != state.minDate || previousState.maxDate != state.maxDate || previousState.date == nil && state.date != nil { self.monthPickerNode.yearRange = yearRange(for: state) self.setupItems() } else if previousState.selectedMonth != state.selectedMonth { for i in 0 ..< self.months.count { if self.months[i].timeIntervalSince1970 >= state.selectedMonth.timeIntervalSince1970 { self.currentIndex = max(0, min(self.months.count - 1, i)) break } } } let initialDate: Date if let date = calendar.date(byAdding: .hour, value: 11, to: self.state.selectedMonth) { initialDate = date } else { initialDate = self.state.selectedMonth } self.monthPickerNode.date = self.state.date ?? initialDate self.timePickerNode.date = self.state.date ?? initialDate if let size = self.validLayout { self.updateLayout(size: size, transition: animated ? .animated(duration: 0.3, curve: .spring) : .immediate) } } private func setupItems() { let startMonth = monthForDate(self.state.minDate) let endMonth = monthForDate(self.state.maxDate) let selectedMonth = monthForDate(self.state.date ?? self.state.selectedMonth) var currentIndex = 0 var months: [Date] = [startMonth] var index = 1 var nextMonth = startMonth while true { if let month = calendar.date(byAdding: .month, value: 1, to: nextMonth) { nextMonth = month if nextMonth == selectedMonth { currentIndex = index } if nextMonth > endMonth { break } else { months.append(nextMonth) } index += 1 } else { break } } self.months = months self.currentIndex = currentIndex } public func updateTheme(_ theme: DatePickerTheme) { guard theme != self.theme else { return } self.theme = theme self.backgroundColor = self.theme.backgroundColor self.monthArrowNode.image = generateSmallArrowImage(color: theme.accentColor) self.previousButtonNode.setImage(generateNavigationArrowImage(color: theme.accentColor, mirror: true), for: .normal) self.nextButtonNode.setImage(generateNavigationArrowImage(color: theme.accentColor, mirror: false), for: .normal) self.dateButtonNode.backgroundColor = theme.segmentedControlTheme.backgroundColor self.timeButtonNode.backgroundColor = theme.segmentedControlTheme.backgroundColor for (_, monthNode) in self.monthNodes { monthNode.theme = theme } if let size = self.validLayout { self.updateLayout(size: size, transition: .immediate) } } @objc private func tapGesture(_ recognizer: UITapGestureRecognizer) { guard let monthNode = self.monthNodes[self.months[self.currentIndex]] else { return } let location = recognizer.location(in: monthNode.view) if let day = monthNode.dateAtPoint(location) { let monthComponents = calendar.dateComponents([.month, .year], from: monthNode.month) var dateComponents: DateComponents if let date = self.date { dateComponents = calendar.dateComponents([.hour, .minute, .day, .month, .year], from: date) dateComponents.year = monthComponents.year dateComponents.month = monthComponents.month dateComponents.day = Int(day) } else { dateComponents = DateComponents() dateComponents.year = monthComponents.year dateComponents.month = monthComponents.month dateComponents.day = Int(day) dateComponents.hour = 11 dateComponents.minute = 0 } if let date = calendar.date(from: dateComponents), date <= self.minimumDate { let minimumDateComponents = calendar.dateComponents([.hour, .minute, .day, .month, .year], from: self.minimumDate) if let hour = minimumDateComponents.hour { dateComponents.hour = hour + 3 } } if let date = calendar.date(from: dateComponents), date >= self.minimumDate && date < self.maximumDate { let updatedState = State(minDate: self.state.minDate, maxDate: self.state.maxDate, date: date, displayingMonthSelection: self.state.displayingMonthSelection, displayingDateSelection: self.state.displayingDateSelection, displayingTimeSelection: self.state.displayingTimeSelection, selectedMonth: monthNode.month) self.updateState(updatedState, animated: false) self.valueUpdated?(date) } } } @objc private func panGesture(_ recognizer: UIPanGestureRecognizer) { switch recognizer.state { case .began: self.view.window?.endEditing(true) case .changed: let translation = recognizer.translation(in: self.view) var transitionFraction = translation.x / self.bounds.width if self.currentIndex <= 0 { transitionFraction = min(0.0, transitionFraction) } if self.currentIndex >= self.months.count - 1 { transitionFraction = max(0.0, transitionFraction) } self.transitionFraction = transitionFraction if let size = self.validLayout { let topInset: CGFloat = 78.0 + 44.0 let containerSize = CGSize(width: size.width, height: size.height - topInset) self.updateItems(size: containerSize, transition: .animated(duration: 0.3, curve: .spring)) } case .cancelled, .ended: let velocity = recognizer.velocity(in: self.view) var directionIsToRight: Bool? if abs(velocity.x) > 10.0 { directionIsToRight = velocity.x < 0.0 } else if abs(self.transitionFraction) > 0.5 { directionIsToRight = self.transitionFraction < 0.0 } var updatedIndex = self.currentIndex if let directionIsToRight = directionIsToRight { if directionIsToRight { updatedIndex = min(updatedIndex + 1, self.months.count - 1) } else { updatedIndex = max(updatedIndex - 1, 0) } } self.currentIndex = updatedIndex self.transitionFraction = 0.0 let updatedState = State(minDate: self.state.minDate, maxDate: self.state.maxDate, date: self.state.date, displayingMonthSelection: self.state.displayingMonthSelection, displayingDateSelection: self.state.displayingDateSelection, displayingTimeSelection: self.state.displayingTimeSelection, selectedMonth: self.months[updatedIndex]) self.updateState(updatedState, animated: true) default: break } } private func updateItems(size: CGSize, update: Bool = false, transition: ContainedViewLayoutTransition) { var validIds: [Date] = [] if self.currentIndex >= 0 && self.currentIndex < self.months.count { let preloadSpan: Int = 1 for i in max(0, self.currentIndex - preloadSpan) ... min(self.currentIndex + preloadSpan, self.months.count - 1) { validIds.append(self.months[i]) var itemNode: MonthNode? var wasAdded = false if let current = self.monthNodes[self.months[i]] { itemNode = current current.minimumDate = self.state.minDate current.maximumDate = self.state.maxDate current.date = self.state.date current.updateLayout(size: size) } else { wasAdded = true let addedItemNode = MonthNode(theme: self.theme, month: self.months[i], minimumDate: self.state.minDate, maximumDate: self.state.maxDate, date: self.state.date) itemNode = addedItemNode self.monthNodes[self.months[i]] = addedItemNode self.contentNode.addSubnode(addedItemNode) } if let itemNode = itemNode { let indexOffset = CGFloat(i - self.currentIndex) let itemFrame = CGRect(origin: CGPoint(x: indexOffset * size.width + self.transitionFraction * size.width, y: 0.0), size: size) if wasAdded { itemNode.frame = itemFrame itemNode.updateLayout(size: size) } else { transition.updateFrame(node: itemNode, frame: itemFrame) itemNode.updateLayout(size: size) } } } } var removeIds: [Date] = [] for (id, _) in self.monthNodes { if !validIds.contains(id) { removeIds.append(id) } } for id in removeIds { if let itemNode = self.monthNodes.removeValue(forKey: id) { itemNode.removeFromSupernode() } } } public func updateLayout(size: CGSize, transition: ContainedViewLayoutTransition) { self.validLayout = size let constrainedSize = CGSize(width: min(390.0, size.width), height: size.height) let timeHeight: CGFloat = 50.0 let topInset: CGFloat = 78.0 + timeHeight let sideInset: CGFloat = 16.0 let month = monthForDate(self.state.selectedMonth) let components = calendar.dateComponents([.month, .year], from: month) let timeTitleSize = self.timeTitleNode.updateLayout(size) self.timeTitleNode.frame = CGRect(origin: CGPoint(x: 16.0, y: 12.0), size: timeTitleSize) let timePickerSize = CGSize(width: constrainedSize.width, height: 180.0) self.timePickerNode.frame = CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - constrainedSize.width) / 2.0), y: timeHeight + 11.0), size: timePickerSize) self.monthTextNode.attributedText = NSAttributedString(string: stringForMonth(strings: self.strings, month: components.month.flatMap { Int32($0) - 1 } ?? 0, ofYear: components.year.flatMap { Int32($0) - 1900 } ?? 100), font: controlFont, textColor: self.state.displayingMonthSelection ? self.theme.accentColor : self.theme.textColor) let monthSize = self.monthTextNode.updateLayout(size) let monthTextFrame = CGRect(x: sideInset, y: 11.0 + timeHeight, width: monthSize.width, height: monthSize.height) self.monthTextNode.frame = monthTextFrame let monthArrowFrame = CGRect(x: monthTextFrame.maxX + 10.0, y: monthTextFrame.minY + 4.0, width: 7.0, height: 12.0) self.monthArrowNode.position = CGPoint(x: monthArrowFrame.midX, y: monthArrowFrame.midY) self.monthArrowNode.bounds = CGRect(origin: CGPoint(), size: monthArrowFrame.size) transition.updateTransformRotation(node: self.monthArrowNode, angle: self.state.displayingMonthSelection ? CGFloat.pi / 2.0 : 0.0) self.monthButtonNode.frame = monthTextFrame.inset(by: UIEdgeInsets(top: -6.0, left: -6.0, bottom: -6.0, right: -30.0)) self.previousButtonNode.isEnabled = self.currentIndex > 0 self.previousButtonNode.frame = CGRect(x: size.width - sideInset - 54.0, y: monthTextFrame.minY + 1.0, width: 10.0, height: 17.0) self.nextButtonNode.isEnabled = self.currentIndex < self.months.count - 1 self.nextButtonNode.frame = CGRect(x: size.width - sideInset - 13.0, y: monthTextFrame.minY + 1.0, width: 10.0, height: 17.0) let date = self.date ?? Date() var t: time_t = Int(date.timeIntervalSince1970) var timeinfo = tm() localtime_r(&t, &timeinfo); let timeString = stringForShortTimestamp(hours: Int32(timeinfo.tm_hour), minutes: Int32(timeinfo.tm_min), dateTimeFormat: self.dateTimeFormat) self.timeButtonNode.setTitle(timeString, with: Font.with(size: 17.0, traits: .monospacedNumbers), with: self.state.displayingTimeSelection ? self.theme.accentColor : self.theme.textColor, for: .normal) var timeSize = self.timeButtonNode.measure(size) timeSize.width += 24.0 timeSize.height = 36.0 self.timeButtonNode.frame = CGRect(x: size.width - timeSize.width - 4.0, y: 4.0, width: timeSize.width, height: timeSize.height) let dateString = stringForMediumDate(timestamp: Int32(date.timeIntervalSince1970), strings: self.strings, dateTimeFormat: self.dateTimeFormat, withTime: false) self.dateButtonNode.setTitle(dateString, with: Font.with(size: 17.0, traits: .monospacedNumbers), with: self.state.displayingDateSelection ? self.theme.accentColor : self.theme.textColor, for: .normal) var dateSize = self.dateButtonNode.measure(size) dateSize.width += 24.0 dateSize.height = 36.0 self.dateButtonNode.frame = CGRect(x: size.width - timeSize.width - 4.0 - 4.0 - dateSize.width, y: 4.0, width: dateSize.width, height: dateSize.height) let daysSideInset: CGFloat = 12.0 let cellSize: CGFloat = floor((constrainedSize.width - daysSideInset * 2.0) / 7.0) var dayIndex: Int32 = Int32(calendar.firstWeekday) - 1 for i in 0 ..< self.dayNodes.count { let dayNode = self.dayNodes[i] dayNode.attributedText = NSAttributedString(string: shortStringForDayOfWeek(strings: self.strings, day: dayIndex % 7).uppercased(), font: dayFont, textColor: theme.secondaryTextColor) let textSize = dayNode.updateLayout(constrainedSize) let cellFrame = CGRect(x: floorToScreenPixels((size.width - constrainedSize.width) / 2.0) + daysSideInset + CGFloat(i) * cellSize, y: topInset - 38.0, width: cellSize, height: cellSize) let textFrame = CGRect(origin: CGPoint(x: cellFrame.minX + floor((cellFrame.width - textSize.width) / 2.0), y: cellFrame.minY + floor((cellFrame.height - textSize.height) / 2.0)), size: textSize) dayNode.frame = textFrame dayIndex += 1 } let containerSize = CGSize(width: constrainedSize.width, height: size.height - topInset) self.contentNode.frame = CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - constrainedSize.width) / 2.0), y: topInset), size: containerSize) self.updateItems(size: containerSize, transition: transition) let monthInset: CGFloat = timeHeight + 30.0 self.monthPickerBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: monthInset), size: size) self.monthPickerBackgroundNode.isUserInteractionEnabled = self.state.displayingMonthSelection transition.updateAlpha(node: self.monthPickerBackgroundNode, alpha: self.state.displayingMonthSelection ? 1.0 : 0.0) transition.updateAlpha(node: self.previousButtonNode, alpha: self.state.displayingMonthSelection ? 0.0 : 1.0) transition.updateAlpha(node: self.nextButtonNode, alpha: self.state.displayingMonthSelection ? 0.0 : 1.0) self.timePickerBackgroundNode.frame = CGRect(origin: CGPoint(), size: size) self.timePickerBackgroundNode.isUserInteractionEnabled = self.state.displayingTimeSelection transition.updateAlpha(node: self.timePickerBackgroundNode, alpha: self.state.displayingTimeSelection ? 1.0 : 0.0) self.datePickerBackgroundNode.frame = CGRect(origin: CGPoint(), size: size) self.datePickerBackgroundNode.isUserInteractionEnabled = self.state.displayingDateSelection transition.updateAlpha(node: self.datePickerBackgroundNode, alpha: self.state.displayingDateSelection ? 1.0 : 0.0) self.monthPickerNode.frame = CGRect(x: sideInset, y: topInset - monthInset, width: size.width - sideInset * 2.0, height: 180.0) } public var toggleDateSelection: () -> Void = {} public var toggleTimeSelection: () -> Void = {} @objc private func dateButtonPressed() { self.toggleDateSelection() } public var displayDateSelection = false { didSet { if self.displayDateSelection != oldValue { let updatedState = State(minDate: self.state.minDate, maxDate: self.state.maxDate, date: self.state.date, displayingMonthSelection: self.state.displayingMonthSelection, displayingDateSelection: self.displayDateSelection, displayingTimeSelection: self.state.displayingTimeSelection, selectedMonth: self.state.selectedMonth) self.updateState(updatedState, animated: true) } } } @objc private func timeButtonPressed() { self.toggleTimeSelection() } public var displayTimeSelection = false { didSet { if self.displayTimeSelection != oldValue { let updatedState = State(minDate: self.state.minDate, maxDate: self.state.maxDate, date: self.state.date, displayingMonthSelection: self.state.displayingMonthSelection, displayingDateSelection: self.state.displayingDateSelection, displayingTimeSelection: self.displayTimeSelection, selectedMonth: self.state.selectedMonth) self.updateState(updatedState, animated: true) } } } @objc private func monthButtonPressed() { let updatedState = State(minDate: self.state.minDate, maxDate: self.state.maxDate, date: self.state.date, displayingMonthSelection: !self.state.displayingMonthSelection, displayingDateSelection: self.state.displayingDateSelection, displayingTimeSelection: self.state.displayingTimeSelection, selectedMonth: self.state.selectedMonth) self.updateState(updatedState, animated: true) } @objc private func previousButtonPressed() { guard let month = calendar.date(byAdding: .month, value: -1, to: self.state.selectedMonth), let size = self.validLayout else { return } let updatedState = State(minDate: self.state.minDate, maxDate: self.state.maxDate, date: self.state.date, displayingMonthSelection: self.state.displayingMonthSelection, displayingDateSelection: self.state.displayingDateSelection, displayingTimeSelection: self.state.displayingTimeSelection, selectedMonth: month) self.updateState(updatedState, animated: false) self.contentNode.layer.animatePosition(from: CGPoint(x: -size.width, y: 0.0), to: CGPoint(), duration: 0.3, additive: true) } @objc private func nextButtonPressed() { guard let month = calendar.date(byAdding: .month, value: 1, to: self.state.selectedMonth), let size = self.validLayout else { return } let updatedState = State(minDate: self.state.minDate, maxDate: self.state.maxDate, date: self.state.date, displayingMonthSelection: self.state.displayingMonthSelection, displayingDateSelection: self.state.displayingDateSelection, displayingTimeSelection: self.state.displayingTimeSelection, selectedMonth: month) self.updateState(updatedState, animated: false) self.contentNode.layer.animatePosition(from: CGPoint(x: size.width, y: 0.0), to: CGPoint(), duration: 0.3, additive: true) } } private final class MonthPickerNode: ASDisplayNode, UIPickerViewDelegate, UIPickerViewDataSource { private let theme: DatePickerTheme private let strings: PresentationStrings var date: Date { didSet { self.updateSelection() } } var yearRange: Range { didSet { self.reload() } } var minimumDate: Date? var maximumDate: Date? private let valueChanged: (Date) -> Void private let pickerView: UIPickerView init(theme: DatePickerTheme, strings: PresentationStrings, date: Date, yearRange: Range, valueChanged: @escaping (Date) -> Void) { self.theme = theme self.strings = strings self.date = date self.yearRange = yearRange self.valueChanged = valueChanged self.pickerView = UIPickerView() super.init() self.pickerView.delegate = self self.pickerView.dataSource = self self.view.addSubview(self.pickerView) self.reload() } private func reload() { self.pickerView.reloadAllComponents() self.updateSelection() } private func updateSelection() { let month = calendar.component(.month, from: self.date) let year = calendar.component(.year, from: self.date) let monthIndex = month - 1 if self.pickerView.selectedRow(inComponent: 0) != monthIndex { self.pickerView.selectRow(monthIndex, inComponent: 0, animated: false) } let yearIndex = year - self.yearRange.startIndex if self.pickerView.selectedRow(inComponent: 1) != yearIndex { self.pickerView.selectRow(yearIndex, inComponent: 1, animated: false) } } override func calculateSizeThatFits(_ constrainedSize: CGSize) -> CGSize { return CGSize(width: constrainedSize.width, height: 180.0) } func numberOfComponents(in pickerView: UIPickerView) -> Int { return 2 } func pickerView(_ pickerView: UIPickerView, numberOfRowsInComponent component: Int) -> Int { if component == 1 { return self.yearRange.count } else { return 12 } } func pickerView(_ pickerView: UIPickerView, rowHeightForComponent component: Int) -> CGFloat { return 40.0 } func pickerView(_ pickerView: UIPickerView, attributedTitleForRow row: Int, forComponent component: Int) -> NSAttributedString? { let string: String if component == 1 { string = "\(self.yearRange.startIndex + row)" } else { string = stringForMonth(strings: self.strings, month: Int32(row)) } return NSAttributedString(string: string, font: Font.medium(15.0), textColor: self.theme.textColor) } func pickerView(_ pickerView: UIPickerView, didSelectRow row: Int, inComponent component: Int) { let month = pickerView.selectedRow(inComponent: 0) + 1 let year = self.yearRange.startIndex + pickerView.selectedRow(inComponent: 1) var components = calendar.dateComponents([.year, .month, .day, .hour, .minute, .second], from: self.date) let day = components.day ?? 1 components.day = 1 components.month = month components.year = year let tempDate = calendar.date(from: components)! let numberOfDays = calendar.range(of: .day, in: .month, for: tempDate)!.count components.day = min(day, numberOfDays) var date = calendar.date(from: components)! // var invalid = false if let minimumDate = self.minimumDate, let maximumDate = self.maximumDate { let minimumMonthDate = monthForDate(minimumDate) var fixDate: Date? if date < minimumDate { fixDate = minimumMonthDate date = minimumDate } if date > maximumDate { fixDate = maximumDate date = maximumDate } if let fixDate { let month = calendar.component(.month, from: fixDate) let year = calendar.component(.year, from: fixDate) self.pickerView.selectRow(month - 1, inComponent: 0, animated: true) self.pickerView.selectRow(year - yearRange.startIndex, inComponent: 1, animated: true) } } // if !invalid { self.date = date self.valueChanged(date) // } } override func layout() { super.layout() self.pickerView.frame = CGRect(origin: CGPoint(), size: CGSize(width: self.bounds.size.width, height: 180.0)) } } private final class TimePickerNode: ASDisplayNode { private let theme: DatePickerTheme var date: Date { get { return self.pickerView.date } set { self.pickerView.date = newValue } } var minimumDate: Date? var maximumDate: Date? private let valueChanged: (Date) -> Void private let pickerView: UIDatePicker init(theme: DatePickerTheme, date: Date, valueChanged: @escaping (Date) -> Void) { self.theme = theme UILabel.setDateLabel(theme.textColor) self.valueChanged = valueChanged self.pickerView = UIDatePicker() if #available(iOS 13.4, *) { self.pickerView.preferredDatePickerStyle = .wheels } super.init() self.pickerView.datePickerMode = .time self.view.addSubview(self.pickerView) self.pickerView.addTarget(self, action: #selector(self.datePickerUpdated), for: .valueChanged) self.date = date } @objc private func datePickerUpdated() { var newDate = self.date if let minDate = self.minimumDate, newDate <= minDate { if let nextDate = calendar.date(byAdding: .day, value: 1, to: newDate) { newDate = nextDate } } self.date = newDate self.valueChanged(newDate) } private func reload() { self.pickerView.date = self.date } override func calculateSizeThatFits(_ constrainedSize: CGSize) -> CGSize { return CGSize(width: constrainedSize.width, height: 180.0) } override func layout() { super.layout() self.pickerView.frame = CGRect(origin: CGPoint(), size: CGSize(width: self.bounds.size.width, height: 180.0)) } }