fix: Ensure the software keyboard doesn't cover focused text boxes (#447)

There's quite a bit more work to do here, but this is is a first-cut of
the plumbing required to respond to the on-screen text field and cursor.

Author: jbmorley

OpoLua/Model/Program.swift

@@ -40,6 +40,7 @@ protocol ProgramDelegate: AnyObject {
     func programDidRequestBackground(_ program: Program)
     func programDidRequestTaskList(_ program: Program)
     func program(_ program: Program, runApplication applicationIdentifier: ApplicationIdentifier, url: URL) -> Int32?
+    func program(_ program: Program, didSetCursorPosition cursorPosition: CGPoint?)
 
 }
 
@@ -124,8 +125,8 @@ class Program {
     private var observers: [ProgramLifecycleObserver] = []
     weak var delegate: ProgramDelegate?
 
-    var title: String
-    var icon: Icon
+    var title: String  // main
+    var icon: Icon  // main  TODO: let?
 
     var rootView: UIView {
         return windowServer.rootView
@@ -219,6 +220,7 @@ class Program {
     }
 
     func toggleOnScreenKeyboard() {
+        dispatchPrecondition(condition: .onQueue(.main))
         if windowServer.rootView.isFirstResponder {
             windowServer.rootView.resignFirstResponder()
         } else {
@@ -470,9 +472,21 @@ extension Program: OpoIoHandler {
     func printValue(_ val: String) {
         print(val)
     }
-
+        
     func textEditor(_ info: TextFieldInfo?) {
-        // print("textEditor: \(String(describing: info))")
+        if let textFieldInfo = info {
+            delegate?.program(self,
+                              didSetCursorPosition: CGPoint(x: CGFloat(textFieldInfo.cursorRect.midX),
+                                                            y: CGFloat(textFieldInfo.cursorRect.midY)))
+            DispatchQueue.main.sync {
+                _ = windowServer.rootView.becomeFirstResponder()
+            }
+        } else {
+            delegate?.program(self, didSetCursorPosition: nil)
+            DispatchQueue.main.sync {
+                _ = windowServer.rootView.resignFirstResponder()
+            }
+        }
     }
 
     func beep(frequency: Double, duration: Double) -> Error? {

OpoLua/View Controllers/ProgramViewController.swift

@@ -243,6 +243,8 @@ class ProgramViewController: UIViewController {
 
         return scaleView
     }()
+    
+    var bottomConstraint: NSLayoutConstraint!
 
     init(settings: Settings, taskManager: TaskManager, program: Program) {
         self.settings = settings
@@ -251,17 +253,21 @@ class ProgramViewController: UIViewController {
         super.init(nibName: nil, bundle: nil)
         program.delegate = self
         navigationItem.largeTitleDisplayMode = .never
+        navigationItem.compactAppearance?.configureWithOpaqueBackground()
+        navigationItem.standardAppearance?.configureWithOpaqueBackground()
         view.backgroundColor = UIColor(named: "ProgramBackground")
 
         title = program.title
         view.clipsToBounds = true
+        
+        bottomConstraint = scaleView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
 
         view.addSubview(scaleView)
         NSLayoutConstraint.activate([
             scaleView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
             scaleView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
             scaleView.topAnchor.constraint(equalTo: view.topAnchor),
-            scaleView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
+            bottomConstraint,
         ])
 
         if traitCollection.horizontalSizeClass == .compact {
@@ -277,6 +283,7 @@ class ProgramViewController: UIViewController {
         }
 
         observeGameControllers()
+        observeKeyboard()
     }
 
     required init?(coder: NSCoder) {
@@ -359,10 +366,34 @@ class ProgramViewController: UIViewController {
         notificationCenter.addObserver(forName: NSNotification.Name.GCControllerDidConnect,
                                        object: nil,
                                        queue: .main) { [weak self] notification in
-            guard let self = self else {
-                return
-            }
-            self.configureControllers()
+            self?.configureControllers()
+        }
+    }
+    
+    func observeKeyboard() {
+        dispatchPrecondition(condition: .onQueue(.main))
+        let notificationCenter = NotificationCenter.default
+        notificationCenter.addObserver(forName: UIResponder.keyboardWillShowNotification,
+                                       object: nil,
+                                       queue: .main) { [weak self] notification in
+            self?.adjustForKeyboard(notification: notification, keyboardShowing: true)
+        }
+        notificationCenter.addObserver(forName: UIResponder.keyboardWillHideNotification,
+                                       object: nil,
+                                       queue: .main) { [weak self] notification in
+            self?.adjustForKeyboard(notification: notification, keyboardShowing: false)
+        }
+    }
+    
+    func adjustForKeyboard(notification: Notification, keyboardShowing: Bool) {
+        guard let userInfo = notification.userInfo,
+              let keyboardFrame = userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else {
+            return
+        }
+        UIView.animate(withDuration: 0.3) {
+            self.scaleView.isShowingKeyboard = keyboardShowing
+            self.bottomConstraint.constant = -(keyboardShowing ? keyboardFrame.height : 0)
+            self.view.layoutIfNeeded()
         }
     }
 
@@ -565,7 +596,19 @@ extension ProgramViewController: ProgramDelegate {
             return AppDelegate.shared.runApplication(applicationIdentifier, url: url)
         }
     }
-
+    
+    func program(_ program: Program, didSetCursorPosition cursorPosition: CGPoint?) {
+        DispatchQueue.main.async {
+            UIView.animate(withDuration: 0.3) {
+                if let cursorPosition {
+                    self.scaleView.focus = CGPoint(x: 0, y: cursorPosition.y)
+                } else {
+                    self.scaleView.focus = nil
+                }
+            }
+        }
+    }
+    
 }
 
 extension ProgramViewController: ProgramLifecycleObserver {

OpoLua/Views/AutoOrientView.swift

@@ -21,6 +21,18 @@
 import UIKit
 
 class AutoOrientView: UIView {
+        
+    var focus: CGPoint? {
+        didSet {
+            layoutSubviews()
+        }
+    }
+    
+    var isShowingKeyboard: Bool = false {
+        didSet {
+            layoutSubviews()
+        }
+    }
 
     private var contentView: UIView
 
@@ -62,20 +74,32 @@ class AutoOrientView: UIView {
 #else
         var transform = CGAffineTransform.identity
         var screenSize = contentView.systemLayoutSizeFitting(.zero)
-
+        let center = CGPoint(x: screenSize.width / 2, y: screenSize.height / 2)
+        let focus =  focus ?? center
+        
+        if isShowingKeyboard {
+            // If the keyboard is visible, never scale the view but instead prioritise the cursor position / focus.
+            // TODO: Pick sensible scales and defaults based on the focus.
+            transform = transform.concatenating(CGAffineTransform(translationX: 0, y: -(focus.y - center.y)))
+            return transform
+        }
+            
         if size.contains(size: screenSize) {
             // The screen fits and there's nothing to do.
             return transform
         }
-
-        if size.isPortrait {
+        
+        // Only rotate the screen on the iPhone.
+        if (UIDevice.current.userInterfaceIdiom == .phone &&
+            UIDevice.current.orientation == .portrait &&
+            !isShowingKeyboard) {
             // If our screen size is portrait, then we first apply rotation if the device screen doesn't fit.
             // We construct the transform, and then apply that effective transform to the screen size for further
             // layout operations.
             transform = transform.concatenating(CGAffineTransform(rotationAngle:  -.pi / 2))
             screenSize = CGSize(width: screenSize.height, height: screenSize.width)
         }
-
+        
         if !size.contains(size: screenSize) {
             // If the screen still doesn't fit then we need to scale it.
             let scale = screenSize.scaleThatFits(in: size)

swift/OpoIoHandler.swift

@@ -60,10 +60,30 @@ public struct Graphics {
 
         public let origin: Point
         public let size: Size
-        public var minX: Int { return origin.x }
-        public var minY: Int { return origin.y }
-        public var width: Int { return size.width }
-        public var height: Int { return size.height }
+        
+        public var minX: Int {
+            return origin.x
+        }
+        
+        public var minY: Int {
+            return origin.y
+        }
+        
+        public var midX: Float {
+            return Float(origin.x) + Float(width) / 2
+        }
+        
+        public var midY: Float {
+            return Float(origin.y) + Float(height) / 2
+        }
+        
+        public var width: Int {
+            return size.width
+        }
+        
+        public var height: Int {
+            return size.height
+        }
 
         public init(origin: Point, size: Size) {
             self.origin = origin