294 lines
12 KiB
Swift
294 lines
12 KiB
Swift
//
|
|
// MainTextView.swift
|
|
// ComposeUI
|
|
//
|
|
// Created by Shadowfacts on 3/6/23.
|
|
//
|
|
|
|
import SwiftUI
|
|
|
|
struct MainTextView: View {
|
|
@EnvironmentObject private var controller: ComposeController
|
|
@EnvironmentObject private var draft: Draft
|
|
@Environment(\.colorScheme) private var colorScheme
|
|
@ScaledMetric private var fontSize = 20
|
|
|
|
@State private var hasFirstAppeared = false
|
|
@State private var height: CGFloat?
|
|
private let minHeight: CGFloat = 150
|
|
private var effectiveHeight: CGFloat { height ?? minHeight }
|
|
|
|
var config: ComposeUIConfig {
|
|
controller.config
|
|
}
|
|
|
|
var body: some View {
|
|
ZStack(alignment: .topLeading) {
|
|
colorScheme == .dark ? config.fillColor : Color(uiColor: .secondarySystemBackground)
|
|
|
|
if draft.text.isEmpty {
|
|
ControllerView(controller: { PlaceholderController() })
|
|
.font(.system(size: fontSize))
|
|
.foregroundColor(.secondary)
|
|
.offset(x: 4, y: 8)
|
|
.accessibilityHidden(true)
|
|
}
|
|
|
|
MainWrappedTextViewRepresentable(text: $draft.text, becomeFirstResponder: $controller.mainComposeTextViewBecomeFirstResponder, textDidChange: textDidChange)
|
|
}
|
|
.frame(height: effectiveHeight)
|
|
.onAppear(perform: becomeFirstResponderOnFirstAppearance)
|
|
}
|
|
|
|
private func becomeFirstResponderOnFirstAppearance() {
|
|
if !hasFirstAppeared {
|
|
hasFirstAppeared = true
|
|
controller.mainComposeTextViewBecomeFirstResponder = true
|
|
}
|
|
}
|
|
|
|
private func textDidChange(textView: UITextView) {
|
|
height = max(textView.contentSize.height, minHeight)
|
|
}
|
|
}
|
|
|
|
fileprivate struct MainWrappedTextViewRepresentable: UIViewRepresentable {
|
|
typealias UIViewType = UITextView
|
|
|
|
@Binding var text: String
|
|
@Binding var becomeFirstResponder: Bool
|
|
let textDidChange: (UITextView) -> Void
|
|
|
|
@EnvironmentObject private var controller: ComposeController
|
|
@Environment(\.isEnabled) private var isEnabled: Bool
|
|
|
|
func makeUIView(context: Context) -> UITextView {
|
|
let textView = WrappedTextView(composeController: controller)
|
|
context.coordinator.textView = textView
|
|
textView.delegate = context.coordinator
|
|
textView.isEditable = true
|
|
textView.backgroundColor = .clear
|
|
textView.font = UIFontMetrics.default.scaledFont(for: .systemFont(ofSize: 20))
|
|
textView.adjustsFontForContentSizeCategory = true
|
|
textView.textContainer.lineBreakMode = .byWordWrapping
|
|
return textView
|
|
}
|
|
|
|
func updateUIView(_ uiView: UITextView, context: Context) {
|
|
if text != uiView.text {
|
|
context.coordinator.skipNextSelectionChangedAutocompleteUpdate = true
|
|
uiView.text = text
|
|
}
|
|
|
|
uiView.isEditable = isEnabled
|
|
uiView.keyboardType = controller.config.useTwitterKeyboard ? .twitter : .default
|
|
|
|
context.coordinator.text = $text
|
|
|
|
// wait until the next runloop iteration so that SwiftUI view updates have finished and
|
|
// the text view knows its new content size
|
|
DispatchQueue.main.async {
|
|
textDidChange(uiView)
|
|
|
|
if becomeFirstResponder {
|
|
// calling becomeFirstResponder during the SwiftUI update causes a crash on iOS 13
|
|
uiView.becomeFirstResponder()
|
|
// can't update @State vars during the SwiftUI update
|
|
becomeFirstResponder = false
|
|
}
|
|
}
|
|
}
|
|
|
|
func makeCoordinator() -> Coordinator {
|
|
Coordinator(controller: controller, text: $text, textDidChange: textDidChange)
|
|
}
|
|
|
|
class WrappedTextView: UITextView {
|
|
private let formattingActions = [#selector(toggleBoldface(_:)), #selector(toggleItalics(_:))]
|
|
private let composeController: ComposeController
|
|
|
|
init(composeController: ComposeController) {
|
|
self.composeController = composeController
|
|
super.init(frame: .zero, textContainer: nil)
|
|
}
|
|
|
|
required init?(coder: NSCoder) {
|
|
fatalError()
|
|
}
|
|
|
|
override func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {
|
|
if formattingActions.contains(action) {
|
|
return composeController.config.contentType != .plain
|
|
}
|
|
return super.canPerformAction(action, withSender: sender)
|
|
}
|
|
|
|
override func toggleBoldface(_ sender: Any?) {
|
|
(delegate as! Coordinator).applyFormat(.bold)
|
|
}
|
|
|
|
override func toggleItalics(_ sender: Any?) {
|
|
(delegate as! Coordinator).applyFormat(.italics)
|
|
}
|
|
|
|
override func validate(_ command: UICommand) {
|
|
super.validate(command)
|
|
|
|
if formattingActions.contains(command.action),
|
|
composeController.config.contentType != .plain {
|
|
command.attributes.remove(.disabled)
|
|
}
|
|
}
|
|
|
|
override func paste(_ sender: Any?) {
|
|
// we deliberately exclude the other CompositionAttachment readable type identifiers, because that's too overzealous with the conversion
|
|
// and things like URLs end up pasting as attachments
|
|
if UIPasteboard.general.contains(pasteboardTypes: UIImage.readableTypeIdentifiersForItemProvider) {
|
|
composeController.paste(itemProviders: UIPasteboard.general.itemProviders)
|
|
} else {
|
|
super.paste(sender)
|
|
}
|
|
}
|
|
}
|
|
|
|
class Coordinator: NSObject, UITextViewDelegate, ComposeInput, TextViewCaretScrolling {
|
|
weak var textView: UITextView?
|
|
|
|
let controller: ComposeController
|
|
var text: Binding<String>
|
|
let textDidChange: (UITextView) -> Void
|
|
|
|
var caretScrollPositionAnimator: UIViewPropertyAnimator?
|
|
|
|
@Published var autocompleteState: AutocompleteState?
|
|
var autocompleteStatePublisher: Published<AutocompleteState?>.Publisher { $autocompleteState }
|
|
var skipNextSelectionChangedAutocompleteUpdate = false
|
|
|
|
init(controller: ComposeController, text: Binding<String>, textDidChange: @escaping (UITextView) -> Void) {
|
|
self.controller = controller
|
|
self.text = text
|
|
self.textDidChange = textDidChange
|
|
|
|
super.init()
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(keyboardDidShow), name: UIResponder.keyboardDidShowNotification, object: nil)
|
|
}
|
|
|
|
@objc private func keyboardDidShow() {
|
|
guard let textView,
|
|
textView.isFirstResponder else {
|
|
return
|
|
}
|
|
ensureCursorVisible(textView: textView)
|
|
}
|
|
|
|
// MARK: UITextViewDelegate
|
|
|
|
func textViewDidChange(_ textView: UITextView) {
|
|
text.wrappedValue = textView.text
|
|
textDidChange(textView)
|
|
|
|
ensureCursorVisible(textView: textView)
|
|
}
|
|
|
|
func textViewDidBeginEditing(_ textView: UITextView) {
|
|
controller.currentInput = self
|
|
updateAutocompleteState()
|
|
}
|
|
|
|
func textViewDidEndEditing(_ textView: UITextView) {
|
|
controller.currentInput = nil
|
|
updateAutocompleteState()
|
|
}
|
|
|
|
func textViewDidChangeSelection(_ textView: UITextView) {
|
|
if skipNextSelectionChangedAutocompleteUpdate {
|
|
skipNextSelectionChangedAutocompleteUpdate = false
|
|
} else {
|
|
updateAutocompleteState()
|
|
}
|
|
}
|
|
|
|
func textView(_ textView: UITextView, editMenuForTextIn range: NSRange, suggestedActions: [UIMenuElement]) -> UIMenu? {
|
|
var actions = suggestedActions
|
|
if controller.config.contentType != .plain,
|
|
let index = suggestedActions.firstIndex(where: { ($0 as? UIMenu)?.identifier.rawValue == "com.apple.menu.format" }) {
|
|
if range.length > 0 {
|
|
let formatMenu = suggestedActions[index] as! UIMenu
|
|
let newFormatMenu = formatMenu.replacingChildren(StatusFormat.allCases.map { fmt in
|
|
var image: UIImage?
|
|
if let imageName = fmt.imageName {
|
|
image = UIImage(systemName: imageName)
|
|
}
|
|
return UIAction(title: fmt.accessibilityLabel, image: image) { [weak self] _ in
|
|
self?.applyFormat(fmt)
|
|
}
|
|
})
|
|
actions[index] = newFormatMenu
|
|
} else {
|
|
actions.remove(at: index)
|
|
}
|
|
}
|
|
if range.length == 0 {
|
|
actions.append(UIAction(title: "Insert Emoji", image: UIImage(systemName: "face.smiling"), handler: { [weak self] _ in
|
|
self?.controller.shouldEmojiAutocompletionBeginExpanded = true
|
|
self?.beginAutocompletingEmoji()
|
|
}))
|
|
}
|
|
return UIMenu(children: actions)
|
|
}
|
|
|
|
// MARK: ComposeInput
|
|
|
|
var toolbarElements: [ToolbarElement] {
|
|
[.emojiPicker, .formattingButtons]
|
|
}
|
|
|
|
func autocomplete(with string: String) {
|
|
textView?.autocomplete(with: string, permittedModes: .all, autocompleteState: &autocompleteState)
|
|
}
|
|
|
|
func applyFormat(_ format: StatusFormat) {
|
|
guard let textView,
|
|
textView.isFirstResponder,
|
|
let insertionResult = format.insertionResult(for: controller.config.contentType) else {
|
|
return
|
|
}
|
|
|
|
let currentSelectedRange = textView.selectedRange
|
|
if currentSelectedRange.length == 0 {
|
|
textView.insertText(insertionResult.prefix + insertionResult.suffix)
|
|
textView.selectedRange = NSRange(location: currentSelectedRange.location + insertionResult.insertionPoint, length: 0)
|
|
} else {
|
|
let start = textView.text.utf16.index(textView.text.utf16.startIndex, offsetBy: currentSelectedRange.lowerBound)
|
|
let end = textView.text.utf16.index(textView.text.utf16.startIndex, offsetBy: currentSelectedRange.upperBound)
|
|
let selectedText = textView.text.utf16[start..<end]
|
|
textView.insertText(insertionResult.prefix + String(Substring(selectedText)) + insertionResult.suffix)
|
|
textView.selectedRange = NSRange(location: currentSelectedRange.location + insertionResult.insertionPoint, length: currentSelectedRange.length)
|
|
}
|
|
}
|
|
|
|
func beginAutocompletingEmoji() {
|
|
guard let textView else {
|
|
return
|
|
}
|
|
var insertSpace = false
|
|
if let text = textView.text,
|
|
textView.selectedRange.upperBound > 0 {
|
|
let characterBeforeCursorIndex = text.utf16.index(before: text.utf16.index(text.startIndex, offsetBy: textView.selectedRange.upperBound))
|
|
insertSpace = !text[characterBeforeCursorIndex].isWhitespace
|
|
}
|
|
textView.insertText((insertSpace ? " " : "") + ":")
|
|
}
|
|
|
|
private func updateAutocompleteState() {
|
|
guard let textView else {
|
|
autocompleteState = nil
|
|
return
|
|
}
|
|
autocompleteState = textView.updateAutocompleteState(permittedModes: .all)
|
|
}
|
|
|
|
}
|
|
}
|