use std::{
ffi::c_void,
ptr::NonNull,
sync::{
Mutex,
atomic::{AtomicBool, AtomicPtr, Ordering},
},
};
use objc2::{
class,
encode::{Encode, Encoding},
msg_send,
rc::Retained,
runtime::{AnyClass, AnyObject, Bool, ClassBuilder, Sel},
sel,
};
static FRAME_DUE: AtomicBool = AtomicBool::new(false);
static STATUS_BAR_TAPPED: AtomicBool = AtomicBool::new(false);
static KEYBOARD_MOVES: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
static KEYBOARD_MOVES_UNTIL: Mutex<Option<std::time::Instant>> = Mutex::new(None);
#[repr(C)]
#[derive(Clone, Copy)]
struct CAFrameRateRange {
minimum: f32,
maximum: f32,
preferred: f32,
}
unsafe impl Encode for CAFrameRateRange {
const ENCODING: Encoding = Encoding::Struct("CAFrameRateRange", &[f32::ENCODING, f32::ENCODING, f32::ENCODING]);
}
#[repr(C)]
#[derive(Clone, Copy)]
pub(super) struct CGPoint {
pub(super) x: f64,
pub(super) y: f64,
}
unsafe impl Encode for CGPoint {
const ENCODING: Encoding = Encoding::Struct("CGPoint", &[f64::ENCODING, f64::ENCODING]);
}
#[repr(C)]
#[derive(Clone, Copy)]
pub(super) struct CGSize {
pub(super) width: f64,
pub(super) height: f64,
}
unsafe impl Encode for CGSize {
const ENCODING: Encoding = Encoding::Struct("CGSize", &[f64::ENCODING, f64::ENCODING]);
}
#[repr(C)]
#[derive(Clone, Copy)]
pub(super) struct CGRect {
pub(super) origin: CGPoint,
pub(super) size: CGSize,
}
unsafe impl Encode for CGRect {
const ENCODING: Encoding = Encoding::Struct("CGRect", &[CGPoint::ENCODING, CGSize::ENCODING]);
}
#[link(name = "Foundation", kind = "framework")]
unsafe extern "C" {
static NSRunLoopCommonModes: *const AnyObject;
}
#[link(name = "UIKit", kind = "framework")]
unsafe extern "C" {
static UIKeyboardWillChangeFrameNotification: *const AnyObject;
static UIKeyboardFrameEndUserInfoKey: *const AnyObject;
static UIKeyboardAnimationDurationUserInfoKey: *const AnyObject;
}
extern "C-unwind" fn keyboard_frame_changes(_this: &AnyObject, _cmd: Sel, notification: *mut AnyObject) {
let Some(notification) = (unsafe { notification.as_ref() }) else {
return;
};
unsafe {
let info: Option<Retained<AnyObject>> = msg_send![notification, userInfo];
let Some(info) = info else {
return;
};
let duration: Option<Retained<AnyObject>> = msg_send![&*info, objectForKey: UIKeyboardAnimationDurationUserInfoKey];
let duration: f64 = match duration {
Some(duration) => msg_send![&*duration, doubleValue],
None => 0.0,
};
let until = std::time::Instant::now() + std::time::Duration::from_secs_f64(duration.clamp(0.0, 2.0) + 0.1);
*KEYBOARD_MOVES_UNTIL.lock().unwrap() = Some(until);
KEYBOARD_MOVES.fetch_add(1, Ordering::AcqRel);
}
}
pub(super) fn keyboard_move() -> u64 {
KEYBOARD_MOVES.load(Ordering::Acquire)
}
pub(super) fn keyboard_moving() -> bool {
KEYBOARD_MOVES_UNTIL
.lock()
.unwrap()
.is_some_and(|until| std::time::Instant::now() < until)
}
pub(super) struct KeyboardProbe {
probe: Retained<AnyObject>,
}
impl KeyboardProbe {
pub(super) fn new(parent: NonNull<c_void>) -> Self {
let parent: &AnyObject = unsafe { parent.cast::<AnyObject>().as_ref() };
unsafe {
let probe: Retained<AnyObject> = msg_send![class!(UIView), new];
let _: () = msg_send![&*probe, setUserInteractionEnabled: false];
let _: () = msg_send![&*probe, setTranslatesAutoresizingMaskIntoConstraints: false];
let _: () = msg_send![parent, addSubview: &*probe];
let guide: Retained<AnyObject> = msg_send![parent, keyboardLayoutGuide];
let pin = |anchor: Retained<AnyObject>, to: Retained<AnyObject>| {
let constraint: Retained<AnyObject> = msg_send![&*anchor, constraintEqualToAnchor: &*to];
let _: () = msg_send![&*constraint, setActive: true];
};
pin(msg_send![&*probe, topAnchor], msg_send![&*guide, topAnchor]);
pin(msg_send![&*probe, leadingAnchor], msg_send![parent, leadingAnchor]);
for dimension in [sel!(widthAnchor), sel!(heightAnchor)] {
let anchor: Retained<AnyObject> = msg_send![&*probe, performSelector: dimension];
let constraint: Retained<AnyObject> = msg_send![&*anchor, constraintEqualToConstant: 1.0f64];
let _: () = msg_send![&*constraint, setActive: true];
}
Self { probe }
}
}
pub(super) fn overlap(&self, height: f64) -> f64 {
unsafe {
let layer: Retained<AnyObject> = msg_send![&*self.probe, layer];
let shown: Option<Retained<AnyObject>> = msg_send![&*layer, presentationLayer];
let frame: CGRect = match &shown {
Some(shown) => msg_send![&**shown, frame],
None => msg_send![&*layer, frame],
};
if frame.origin.y < 1.0 {
return 0.0;
}
let covered = (height - frame.origin.y).clamp(0.0, height);
let parent: Option<Retained<AnyObject>> = msg_send![&*self.probe, superview];
let rests = match &parent {
Some(parent) => {
let insets: UIEdgeInsets = msg_send![&**parent, safeAreaInsets];
insets.bottom
}
None => 0.0,
};
if covered <= rests + 0.5 { 0.0 } else { covered }
}
}
}
pub(super) fn watch_keyboard() {
unsafe {
let receiver: Retained<AnyObject> = msg_send![receiver_class(), new];
let center: Retained<AnyObject> = msg_send![class!(NSNotificationCenter), defaultCenter];
let _: () = msg_send![
&*center,
addObserver: &*receiver,
selector: sel!(lurqKeyboardFrameChanges:),
name: UIKeyboardWillChangeFrameNotification,
object: std::ptr::null::<AnyObject>()
];
std::mem::forget(receiver);
}
}
extern "C-unwind" fn frame_due(_this: &AnyObject, _cmd: Sel, _link: *mut AnyObject) {
FRAME_DUE.store(true, Ordering::Release);
}
extern "C-unwind" fn should_scroll_to_top(_this: &AnyObject, _cmd: Sel, _scroll_view: *mut AnyObject) -> Bool {
STATUS_BAR_TAPPED.store(true, Ordering::Release);
Bool::NO
}
fn receiver_class() -> &'static AnyClass {
if let Some(class) = AnyClass::get(c"LurqShellReceiver") {
return class;
}
let mut builder = ClassBuilder::new(c"LurqShellReceiver", class!(NSObject)).expect("a class name of its own");
unsafe {
builder.add_method(sel!(lurqFrameDue:), frame_due as extern "C-unwind" fn(_, _, _));
builder.add_method(
sel!(lurqKeyboardFrameChanges:),
keyboard_frame_changes as extern "C-unwind" fn(_, _, _),
);
builder.add_method(
sel!(scrollViewShouldScrollToTop:),
should_scroll_to_top as extern "C-unwind" fn(_, _, _) -> _,
);
builder.add_method(sel!(lurqPencilHover:), pencil_hover as extern "C-unwind" fn(_, _, _));
}
builder.register()
}
static PENCIL_HOVER: Mutex<Vec<(bool, f64, f64)>> = Mutex::new(Vec::new());
extern "C-unwind" fn pencil_hover(_this: &AnyObject, _cmd: Sel, recognizer: *mut AnyObject) {
let Some(recognizer) = (unsafe { recognizer.as_ref() }) else {
return;
};
let (state, point): (isize, CGPoint) = unsafe {
let view: *mut AnyObject = msg_send![recognizer, view];
(
msg_send![recognizer, state],
msg_send![recognizer, locationInView: view],
)
};
let over = matches!(state, 1 | 2);
if let Ok(mut hovers) = PENCIL_HOVER.lock() {
hovers.push((over, point.x, point.y));
}
}
pub(super) fn take_pencil_hovers() -> Vec<(bool, f64, f64)> {
PENCIL_HOVER
.lock()
.map(|mut hovers| std::mem::take(&mut *hovers))
.unwrap_or_default()
}
pub(super) struct PencilHover {
_recognizer: Retained<AnyObject>,
_receiver: Retained<AnyObject>,
}
impl PencilHover {
pub(super) fn new(view: NonNull<c_void>) -> Option<Self> {
let class = AnyClass::get(c"UIHoverGestureRecognizer")?;
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
unsafe {
let receiver: Retained<AnyObject> = msg_send![receiver_class(), new];
let recognizer: objc2::rc::Allocated<AnyObject> = msg_send![class, alloc];
let recognizer: Retained<AnyObject> =
msg_send![recognizer, initWithTarget: &*receiver, action: sel!(lurqPencilHover:)];
let pencil: Retained<AnyObject> = msg_send![class!(NSNumber), numberWithInteger: 2isize];
let types: Retained<AnyObject> = msg_send![class!(NSArray), arrayWithObject: &*pencil];
let _: () = msg_send![&*recognizer, setAllowedTouchTypes: &*types];
let _: () = msg_send![&*recognizer, setCancelsTouchesInView: false];
let _: () = msg_send![view, addGestureRecognizer: &*recognizer];
Some(Self {
_recognizer: recognizer,
_receiver: receiver,
})
}
}
}
pub(super) struct FrameLink {
link: Retained<AnyObject>,
running: bool,
}
impl FrameLink {
pub(super) fn new() -> Self {
let link: Retained<AnyObject> = unsafe {
let receiver: Retained<AnyObject> = msg_send![receiver_class(), new];
let link: Retained<AnyObject> = msg_send![
class!(CADisplayLink),
displayLinkWithTarget: &*receiver,
selector: sel!(lurqFrameDue:)
];
let range = CAFrameRateRange {
minimum: 60.0,
maximum: 120.0,
preferred: 120.0,
};
let _: () = msg_send![&*link, setPreferredFrameRateRange: range];
let _: () = msg_send![&*link, setPaused: true];
let run_loop: Retained<AnyObject> = msg_send![class!(NSRunLoop), mainRunLoop];
let _: () = msg_send![&*link, addToRunLoop: &*run_loop, forMode: NSRunLoopCommonModes];
link
};
Self { link, running: false }
}
pub(super) fn set_running(&mut self, running: bool) {
if self.running == running {
return;
}
self.running = running;
if !running {
FRAME_DUE.store(false, Ordering::Release);
}
let _: () = unsafe { msg_send![&*self.link, setPaused: !running] };
}
pub(super) fn take_due(&mut self) -> bool {
FRAME_DUE.swap(false, Ordering::AcqRel)
}
}
impl Drop for FrameLink {
fn drop(&mut self) {
let _: () = unsafe { msg_send![&*self.link, invalidate] };
}
}
pub(super) struct KeyboardDrag {
scroll_view: Retained<AnyObject>,
interactive: bool,
}
impl KeyboardDrag {
pub(super) fn new(view: NonNull<c_void>) -> Self {
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
unsafe {
let scroll_view: Retained<AnyObject> = msg_send![class!(UIScrollView), new];
let bounds: CGRect = msg_send![view, bounds];
let _: () = msg_send![&*scroll_view, setFrame: bounds];
let _: () = msg_send![&*scroll_view, setAutoresizingMask: 18usize];
let _: () = msg_send![&*scroll_view, setUserInteractionEnabled: false];
let _: () = msg_send![&*scroll_view, setHidden: false];
let _: () = msg_send![&*scroll_view, setAlpha: 0.0f64];
let _: () = msg_send![&*scroll_view, setScrollsToTop: false];
let _: () = msg_send![&*scroll_view, setAlwaysBounceVertical: true];
let _: () = msg_send![&*scroll_view, setShowsVerticalScrollIndicator: false];
let _: () = msg_send![&*scroll_view, setShowsHorizontalScrollIndicator: false];
let _: () = msg_send![&*scroll_view, setContentSize: CGSize { width: bounds.size.width, height: 100_000.0 }];
let _: () = msg_send![&*scroll_view, setContentOffset: CGPoint { x: 0.0, y: 50_000.0 }];
let _: () = msg_send![view, insertSubview: &*scroll_view, atIndex: 0isize];
let pan: Retained<AnyObject> = msg_send![&*scroll_view, panGestureRecognizer];
let _: () = msg_send![&*pan, setCancelsTouchesInView: false];
let _: () = msg_send![&*pan, setDelaysTouchesBegan: false];
let _: () = msg_send![&*pan, setDelaysTouchesEnded: false];
let _: () = msg_send![&*pan, setEnabled: false];
let _: () = msg_send![view, addGestureRecognizer: &*pan];
Self {
scroll_view,
interactive: false,
}
}
}
pub(super) fn set_interactive(&mut self, interactive: bool) {
unsafe {
let _: () = msg_send![&*self.scroll_view, setContentOffset: CGPoint { x: 0.0, y: 50_000.0 }];
if self.interactive == interactive {
return;
}
self.interactive = interactive;
let mode: isize = if interactive { 2 } else { 0 };
let _: () = msg_send![&*self.scroll_view, setKeyboardDismissMode: mode];
let pan: Retained<AnyObject> = msg_send![&*self.scroll_view, panGestureRecognizer];
let _: () = msg_send![&*pan, setEnabled: interactive];
}
}
}
pub(super) struct StatusBarTap {
scroll_view: Retained<AnyObject>,
_receiver: Retained<AnyObject>,
height: f64,
}
impl StatusBarTap {
pub(super) fn new(view: NonNull<c_void>) -> Self {
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
unsafe {
let receiver: Retained<AnyObject> = msg_send![receiver_class(), new];
let scroll_view: Retained<AnyObject> = msg_send![class!(UIScrollView), new];
let bounds: CGRect = msg_send![view, bounds];
let frame = CGRect {
origin: CGPoint { x: 0.0, y: 0.0 },
size: CGSize {
width: bounds.size.width,
height: 0.0,
},
};
let _: () = msg_send![&*scroll_view, setFrame: frame];
let _: () = msg_send![&*scroll_view, setAutoresizingMask: 2usize];
let _: () = msg_send![&*scroll_view, setContentSize: CGSize { width: 1.0, height: 10_000.0 }];
let _: () = msg_send![&*scroll_view, setContentOffset: CGPoint { x: 0.0, y: 1.0 }];
let _: () = msg_send![&*scroll_view, setScrollsToTop: true];
let _: () = msg_send![&*scroll_view, setShowsVerticalScrollIndicator: false];
let _: () = msg_send![&*scroll_view, setShowsHorizontalScrollIndicator: false];
let pan: Retained<AnyObject> = msg_send![&*scroll_view, panGestureRecognizer];
let _: () = msg_send![&*pan, setEnabled: false];
let _: () = msg_send![&*scroll_view, setDelegate: &*receiver];
let _: () = msg_send![view, addSubview: &*scroll_view];
Self {
scroll_view,
_receiver: receiver,
height: 0.0,
}
}
}
pub(super) fn set_height(&mut self, height: f64) {
if self.height == height {
return;
}
self.height = height;
unsafe {
let mut frame: CGRect = msg_send![&*self.scroll_view, frame];
frame.size.height = height;
let _: () = msg_send![&*self.scroll_view, setFrame: frame];
let _: () = msg_send![&*self.scroll_view, setContentOffset: CGPoint { x: 0.0, y: 1.0 }];
}
}
pub(super) fn take_tapped(&mut self) -> bool {
STATUS_BAR_TAPPED.swap(false, Ordering::AcqRel)
}
}
pub(super) fn play_haptic(haptic: crate::app::window::Haptic) {
use crate::app::window::Haptic;
unsafe {
match haptic {
Haptic::Light | Haptic::Medium | Haptic::Heavy => {
let style: isize = match haptic {
Haptic::Light => 0,
Haptic::Medium => 1,
_ => 2,
};
let generator: objc2::rc::Allocated<AnyObject> = msg_send![class!(UIImpactFeedbackGenerator), alloc];
let generator: Retained<AnyObject> = msg_send![generator, initWithStyle: style];
let _: () = msg_send![&*generator, impactOccurred];
}
Haptic::Selection => {
let generator: Retained<AnyObject> = msg_send![class!(UISelectionFeedbackGenerator), new];
let _: () = msg_send![&*generator, selectionChanged];
}
Haptic::Success | Haptic::Warning | Haptic::Error => {
let kind: isize = match haptic {
Haptic::Success => 0,
Haptic::Warning => 1,
_ => 2,
};
let generator: Retained<AnyObject> = msg_send![class!(UINotificationFeedbackGenerator), new];
let _: () = msg_send![&*generator, notificationOccurred: kind];
}
}
}
}
static SCENE: AtomicPtr<AnyObject> = AtomicPtr::new(std::ptr::null_mut());
static SAFE_AREA_PROBE: AtomicPtr<AnyObject> = AtomicPtr::new(std::ptr::null_mut());
static SCENE_WINDOW: AtomicPtr<AnyObject> = AtomicPtr::new(std::ptr::null_mut());
pub(super) fn register_scene_delegate() {
if AnyClass::get(c"LurqSceneDelegate").is_some() {
return;
}
extern "C-unwind" fn will_connect(
_this: &AnyObject,
_cmd: Sel,
scene: *mut AnyObject,
session: *mut AnyObject,
options: *mut AnyObject,
) {
let Some(scene) = (unsafe { Retained::retain(scene) }) else {
return;
};
let is_window_scene: bool = unsafe { msg_send![&*scene, isKindOfClass: class!(UIWindowScene)] };
if !is_window_scene {
return;
}
let external = unsafe { session.as_ref() }.is_some_and(|session| {
let role: *mut AnyObject = unsafe { msg_send![session, role] };
unsafe { role.as_ref() }
.and_then(string_of)
.is_some_and(|role| role.contains("External"))
});
if external || !SCENE.load(Ordering::Acquire).is_null() {
other_scene_connected(scene, external);
return;
}
if let Some(options) = unsafe { options.as_ref() } {
let contexts: *mut AnyObject = unsafe { msg_send![options, URLContexts] };
push_opened_urls(contexts);
let shortcut: *mut AnyObject = unsafe { msg_send![options, shortcutItem] };
push_shortcut(shortcut);
}
let previous = SCENE.swap(Retained::into_raw(scene), Ordering::AcqRel);
if !previous.is_null() {
drop(unsafe { Retained::from_raw(previous) });
}
show_window_in_scene();
}
extern "C-unwind" fn did_disconnect(_this: &AnyObject, _cmd: Sel, scene: *mut AnyObject) {
if SCENE
.compare_exchange(scene, std::ptr::null_mut(), Ordering::AcqRel, Ordering::Acquire)
.is_ok()
{
drop(unsafe { Retained::from_raw(scene) });
} else {
other_scene_disconnected(scene);
}
}
fn first(scene: *mut AnyObject) -> bool {
std::ptr::eq(SCENE.load(Ordering::Acquire), scene)
}
extern "C-unwind" fn did_become_active(_this: &AnyObject, _cmd: Sel, scene: *mut AnyObject) {
if first(scene) {
push_app_event(AppEvent::Active);
}
}
extern "C-unwind" fn will_resign_active(_this: &AnyObject, _cmd: Sel, scene: *mut AnyObject) {
if first(scene) {
push_app_event(AppEvent::Inactive);
}
}
extern "C-unwind" fn did_enter_background(_this: &AnyObject, _cmd: Sel, scene: *mut AnyObject) {
if first(scene) {
push_app_event(AppEvent::Background);
}
}
extern "C-unwind" fn will_enter_foreground(_this: &AnyObject, _cmd: Sel, scene: *mut AnyObject) {
if first(scene) {
push_app_event(AppEvent::Foreground);
}
}
extern "C-unwind" fn open_urls(_this: &AnyObject, _cmd: Sel, _scene: *mut AnyObject, contexts: *mut AnyObject) {
push_opened_urls(contexts);
}
extern "C-unwind" fn perform_shortcut(
_this: &AnyObject,
_cmd: Sel,
_scene: *mut AnyObject,
shortcut: *mut AnyObject,
completion: *mut c_void,
) {
push_shortcut(shortcut);
#[repr(C)]
struct Block {
isa: *const c_void,
flags: i32,
reserved: i32,
invoke: unsafe extern "C" fn(*mut c_void, Bool),
}
if let Some(block) = unsafe { completion.cast::<Block>().as_ref() } {
unsafe { (block.invoke)(completion, Bool::YES) };
}
}
extern "C-unwind" fn window(_this: &AnyObject, _cmd: Sel) -> *mut AnyObject {
SCENE_WINDOW.load(Ordering::Acquire)
}
extern "C-unwind" fn set_window(_this: &AnyObject, _cmd: Sel, _window: *mut AnyObject) {}
let mut builder = ClassBuilder::new(c"LurqSceneDelegate", class!(UIResponder)).expect("a class name of its own");
if let Some(protocol) = objc2::runtime::AnyProtocol::get(c"UIWindowSceneDelegate") {
builder.add_protocol(protocol);
}
unsafe {
builder.add_method(
sel!(scene:willConnectToSession:options:),
will_connect as extern "C-unwind" fn(_, _, _, _, _),
);
builder.add_method(
sel!(sceneDidDisconnect:),
did_disconnect as extern "C-unwind" fn(_, _, _),
);
builder.add_method(
sel!(sceneDidBecomeActive:),
did_become_active as extern "C-unwind" fn(_, _, _),
);
builder.add_method(
sel!(sceneWillResignActive:),
will_resign_active as extern "C-unwind" fn(_, _, _),
);
builder.add_method(
sel!(sceneDidEnterBackground:),
did_enter_background as extern "C-unwind" fn(_, _, _),
);
builder.add_method(
sel!(sceneWillEnterForeground:),
will_enter_foreground as extern "C-unwind" fn(_, _, _),
);
builder.add_method(
sel!(scene:openURLContexts:),
open_urls as extern "C-unwind" fn(_, _, _, _),
);
builder.add_method(
sel!(windowScene:performActionForShortcutItem:completionHandler:),
perform_shortcut as extern "C-unwind" fn(_, _, _, _, _),
);
builder.add_method(sel!(window), window as extern "C-unwind" fn(_, _) -> _);
builder.add_method(sel!(setWindow:), set_window as extern "C-unwind" fn(_, _, _));
}
builder.register();
}
pub(super) fn join_scene(view: NonNull<c_void>) {
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
let window: Option<Retained<AnyObject>> = unsafe { msg_send![view, window] };
let Some(window) = window else {
return;
};
SCENE_WINDOW.store(Retained::as_ptr(&window).cast_mut(), Ordering::Release);
if SCENE.load(Ordering::Acquire).is_null() {
let scene = unsafe {
let app: Retained<AnyObject> = msg_send![class!(UIApplication), sharedApplication];
let scenes: Retained<AnyObject> = msg_send![&*app, connectedScenes];
let scenes: Retained<AnyObject> = msg_send![&*scenes, allObjects];
let count: usize = msg_send![&*scenes, count];
(0..count)
.map(|index| -> Retained<AnyObject> { msg_send![&*scenes, objectAtIndex: index] })
.find(|scene| msg_send![&**scene, isKindOfClass: class!(UIWindowScene)])
};
if let Some(scene) = scene {
SCENE.store(Retained::into_raw(scene), Ordering::Release);
}
}
show_window_in_scene();
}
fn show_window_in_scene() {
let (scene, window) = (SCENE.load(Ordering::Acquire), SCENE_WINDOW.load(Ordering::Acquire));
let (Some(scene), Some(window)) = (unsafe { scene.as_ref() }, unsafe { window.as_ref() }) else {
return;
};
if SAFE_AREA_PROBE.load(Ordering::Acquire).is_null() {
unsafe {
let probe: objc2::rc::Allocated<AnyObject> = msg_send![class!(UIWindow), alloc];
let probe: Retained<AnyObject> = msg_send![probe, initWithWindowScene: scene];
let controller: Retained<AnyObject> = msg_send![class!(UIViewController), new];
let _: () = msg_send![&*probe, setRootViewController: &*controller];
let _: () = msg_send![&*probe, setUserInteractionEnabled: false];
let _: () = msg_send![&*probe, setAlpha: 0.0f64];
let _: () = msg_send![&*probe, setWindowLevel: -1.0f64];
let _: () = msg_send![&*probe, setHidden: false];
SAFE_AREA_PROBE.store(Retained::into_raw(probe), Ordering::Release);
}
}
unsafe {
let current: Option<Retained<AnyObject>> = msg_send![window, windowScene];
if current.is_some() {
return;
}
let _: () = msg_send![window, setWindowScene: scene];
let _: () = msg_send![window, makeKeyAndVisible];
let controller: Option<Retained<AnyObject>> = msg_send![window, rootViewController];
if let Some(controller) = controller {
let _: () = msg_send![window, setRootViewController: std::ptr::null::<AnyObject>()];
let _: () = msg_send![window, setRootViewController: &*controller];
}
}
}
struct OtherScene {
scene: usize,
external: bool,
window: usize,
}
static OTHER_SCENES: Mutex<Vec<OtherScene>> = Mutex::new(Vec::new());
static WAITING_WINDOWS: Mutex<Vec<usize>> = Mutex::new(Vec::new());
static CLOSED_WINDOWS: Mutex<Vec<usize>> = Mutex::new(Vec::new());
fn show_window_in(scene: usize, window: usize) {
let (scene, window) = (scene as *mut AnyObject, window as *mut AnyObject);
let (Some(scene), Some(window)) = (unsafe { scene.as_ref() }, unsafe { window.as_ref() }) else {
return;
};
unsafe {
let _: () = msg_send![window, setWindowScene: scene];
let space: Retained<AnyObject> = msg_send![scene, coordinateSpace];
let bounds: CGRect = msg_send![&*space, bounds];
let _: () = msg_send![window, setFrame: bounds];
let _: () = msg_send![window, setHidden: false];
}
}
fn other_scene_connected(scene: Retained<AnyObject>, external: bool) {
let window = if external {
None
} else {
let mut waiting = WAITING_WINDOWS.lock().unwrap();
(!waiting.is_empty()).then(|| waiting.remove(0))
};
let scene = Retained::into_raw(scene) as usize;
OTHER_SCENES.lock().unwrap().push(OtherScene {
scene,
external,
window: window.unwrap_or(0),
});
match window {
Some(window) => show_window_in(scene, window),
None => push_app_event(AppEvent::WindowAsked { external }),
}
}
fn other_scene_disconnected(scene: *mut AnyObject) {
let gone = {
let mut scenes = OTHER_SCENES.lock().unwrap();
scenes
.iter()
.position(|other| other.scene == scene as usize)
.map(|index| scenes.remove(index))
};
let Some(gone) = gone else {
return;
};
drop(unsafe { Retained::from_raw(gone.scene as *mut AnyObject) });
if gone.window != 0 {
CLOSED_WINDOWS.lock().unwrap().push(gone.window);
}
}
pub(super) fn join_other_scene(view: NonNull<c_void>) {
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
let window: Option<Retained<AnyObject>> = unsafe { msg_send![view, window] };
let Some(window) = window else {
return;
};
let window = Retained::as_ptr(&window) as usize;
let free = OTHER_SCENES
.lock()
.unwrap()
.iter_mut()
.find(|other| other.window == 0)
.map(|other| {
other.window = window;
other.scene
});
if let Some(scene) = free {
show_window_in(scene, window);
return;
}
WAITING_WINDOWS.lock().unwrap().push(window);
unsafe {
let app: Retained<AnyObject> = msg_send![class!(UIApplication), sharedApplication];
let several: bool = msg_send![&*app, supportsMultipleScenes];
if several {
let none = std::ptr::null_mut::<AnyObject>();
let _: () = msg_send![
&*app,
requestSceneSessionActivation: none,
userActivity: none,
options: none,
errorHandler: std::ptr::null_mut::<c_void>()
];
}
}
}
pub(super) fn leave_other_scene(view: NonNull<c_void>) {
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
let window: Option<Retained<AnyObject>> = unsafe { msg_send![view, window] };
let Some(window) = window else {
return;
};
let window = Retained::as_ptr(&window) as usize;
WAITING_WINDOWS.lock().unwrap().retain(|waiting| *waiting != window);
let scene = OTHER_SCENES
.lock()
.unwrap()
.iter_mut()
.find(|other| other.window == window)
.map(|other| {
other.window = 0;
(other.scene, other.external)
});
if let Some((scene, false)) = scene
&& let Some(scene) = unsafe { (scene as *mut AnyObject).as_ref() }
{
unsafe {
let app: Retained<AnyObject> = msg_send![class!(UIApplication), sharedApplication];
let session: Retained<AnyObject> = msg_send![scene, session];
let _: () = msg_send![
&*app,
requestSceneSessionDestruction: &*session,
options: std::ptr::null_mut::<AnyObject>(),
errorHandler: std::ptr::null_mut::<c_void>()
];
if let Some(first) = SCENE.load(Ordering::Acquire).as_ref() {
let session: Retained<AnyObject> = msg_send![first, session];
let none = std::ptr::null_mut::<AnyObject>();
let _: () = msg_send![
&*app,
requestSceneSessionActivation: &*session,
userActivity: none,
options: none,
errorHandler: std::ptr::null_mut::<c_void>()
];
}
}
}
}
pub(super) fn other_scene_closed(view: NonNull<c_void>) -> bool {
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
let window: Option<Retained<AnyObject>> = unsafe { msg_send![view, window] };
let Some(window) = window else {
return false;
};
let window = Retained::as_ptr(&window) as usize;
let mut closed = CLOSED_WINDOWS.lock().unwrap();
let before = closed.len();
closed.retain(|closed| *closed != window);
closed.len() != before
}
#[repr(C)]
#[derive(Clone, Copy)]
struct UIEdgeInsets {
top: f64,
left: f64,
bottom: f64,
right: f64,
}
unsafe impl Encode for UIEdgeInsets {
const ENCODING: Encoding = Encoding::Struct(
"UIEdgeInsets",
&[f64::ENCODING, f64::ENCODING, f64::ENCODING, f64::ENCODING],
);
}
pub(super) fn safe_area(view: NonNull<c_void>) -> (f32, f32, f32, f32) {
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
let insets: UIEdgeInsets = unsafe { msg_send![view, safeAreaInsets] };
let probe = SAFE_AREA_PROBE.load(Ordering::Acquire);
let insets = match unsafe { probe.as_ref() } {
Some(probe) => unsafe { msg_send![probe, safeAreaInsets] },
None => insets,
};
(
insets.top as f32,
insets.right as f32,
insets.bottom as f32,
insets.left as f32,
)
}
pub(super) fn own_safe_area(view: NonNull<c_void>) -> (f32, f32, f32, f32) {
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
let insets: UIEdgeInsets = unsafe { msg_send![view, safeAreaInsets] };
(
insets.top as f32,
insets.right as f32,
insets.bottom as f32,
insets.left as f32,
)
}
use crate::app::window::AppEvent;
static APP_EVENTS: Mutex<Vec<AppEvent>> = Mutex::new(Vec::new());
fn push_app_event(event: AppEvent) {
APP_EVENTS.lock().unwrap().push(event);
}
fn push_opened_urls(contexts: *mut AnyObject) {
let Some(contexts) = (unsafe { contexts.as_ref() }) else {
return;
};
unsafe {
let contexts: Retained<AnyObject> = msg_send![contexts, allObjects];
let count: usize = msg_send![&*contexts, count];
for index in 0..count {
let context: Retained<AnyObject> = msg_send![&*contexts, objectAtIndex: index];
let url: Retained<AnyObject> = msg_send![&*context, URL];
let text: Option<Retained<AnyObject>> = msg_send![&*url, absoluteString];
if let Some(text) = text.and_then(|text| string_of(&text)) {
push_app_event(AppEvent::OpenUrl(text));
}
}
}
}
fn push_shortcut(shortcut: *mut AnyObject) {
let Some(shortcut) = (unsafe { shortcut.as_ref() }) else {
return;
};
let kind: Option<Retained<AnyObject>> = unsafe { msg_send![shortcut, type] };
if let Some(kind) = kind.and_then(|kind| string_of(&kind)) {
push_app_event(AppEvent::Shortcut(kind));
}
}
fn string_of(string: &AnyObject) -> Option<String> {
let utf8: *const std::ffi::c_char = unsafe { msg_send![string, UTF8String] };
if utf8.is_null() {
return None;
}
Some(unsafe { std::ffi::CStr::from_ptr(utf8) }.to_string_lossy().into_owned())
}
pub(super) fn take_app_events() -> Vec<AppEvent> {
std::mem::take(&mut *APP_EVENTS.lock().unwrap())
}
pub(super) struct HardwareKey {
pub(super) key: String,
pub(super) code: String,
pub(super) shift: bool,
pub(super) ctrl: bool,
pub(super) alt: bool,
pub(super) meta: bool,
pub(super) down: bool,
}
static HARDWARE_KEYS: Mutex<Vec<HardwareKey>> = Mutex::new(Vec::new());
pub(super) fn take_hardware_keys() -> Vec<HardwareKey> {
std::mem::take(&mut *HARDWARE_KEYS.lock().unwrap())
}
fn key_names(usage: isize, typed: &str) -> Option<(String, String)> {
let named = |name: &str| Some((name.to_owned(), name.to_owned()));
match usage {
0x04..=0x1D => {
let letter = (b'A' + (usage - 0x04) as u8) as char;
let key = if typed.chars().count() == 1 {
typed.to_owned()
} else {
letter.to_ascii_lowercase().to_string()
};
Some((key, format!("Key{letter}")))
}
0x1E..=0x27 => {
let digit = (usage - 0x1E + 1) % 10;
let key = if typed.chars().count() == 1 {
typed.to_owned()
} else {
digit.to_string()
};
Some((key, format!("Digit{digit}")))
}
0x28 => named("Enter"),
0x29 => named("Escape"),
0x2A => named("Backspace"),
0x2B => named("Tab"),
0x2C => Some((" ".to_owned(), "Space".to_owned())),
0x4A => named("Home"),
0x4B => named("PageUp"),
0x4C => named("Delete"),
0x4D => named("End"),
0x4E => named("PageDown"),
0x4F => named("ArrowRight"),
0x50 => named("ArrowLeft"),
0x51 => named("ArrowDown"),
0x52 => named("ArrowUp"),
_ if typed.chars().count() == 1 => Some((typed.to_owned(), String::new())),
_ => None,
}
}
pub(super) fn take_presses(presses: *mut AnyObject, down: bool, only: Option<&[&str]>) -> bool {
let Some(presses) = (unsafe { presses.as_ref() }) else {
return true;
};
let mut all = true;
unsafe {
let presses: Retained<AnyObject> = msg_send![presses, allObjects];
let count: usize = msg_send![&*presses, count];
for index in 0..count {
let press: Retained<AnyObject> = msg_send![&*presses, objectAtIndex: index];
let key: Option<Retained<AnyObject>> = msg_send![&*press, key];
let Some(key) = key else {
all = false;
continue;
};
let usage: isize = msg_send![&*key, keyCode];
let typed: Option<Retained<AnyObject>> = msg_send![&*key, charactersIgnoringModifiers];
let typed = typed.and_then(|typed| string_of(&typed)).unwrap_or_default();
let flags: isize = msg_send![&*key, modifierFlags];
let Some((name, code)) = key_names(usage, &typed) else {
all = false;
continue;
};
if only.is_some_and(|only| !only.contains(&name.as_str())) {
all = false;
continue;
}
HARDWARE_KEYS.lock().unwrap().push(HardwareKey {
key: name,
code,
shift: flags & (1 << 17) != 0,
ctrl: flags & (1 << 18) != 0,
alt: flags & (1 << 19) != 0,
meta: flags & (1 << 20) != 0,
down,
});
}
}
all
}
pub(super) fn hear_hardware_keys(view: NonNull<c_void>) {
extern "C-unwind" fn began(_this: &AnyObject, _cmd: Sel, presses: *mut AnyObject, _event: *mut AnyObject) {
take_presses(presses, true, None);
}
extern "C-unwind" fn ended(_this: &AnyObject, _cmd: Sel, presses: *mut AnyObject, _event: *mut AnyObject) {
take_presses(presses, false, None);
}
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
let class = view.class();
if class
.instance_method(sel!(pressesBegan:withEvent:))
.is_some_and(|method| {
class!(UIResponder)
.instance_method(sel!(pressesBegan:withEvent:))
.is_none_or(|inherited| !std::ptr::eq(method, inherited))
})
{
return;
}
let types = c"v@:@@";
unsafe {
let class = std::ptr::from_ref(class).cast_mut();
objc2::ffi::class_addMethod(
class.cast(),
sel!(pressesBegan:withEvent:),
std::mem::transmute::<
extern "C-unwind" fn(&AnyObject, Sel, *mut AnyObject, *mut AnyObject),
unsafe extern "C-unwind" fn(),
>(began),
types.as_ptr(),
);
objc2::ffi::class_addMethod(
class.cast(),
sel!(pressesEnded:withEvent:),
std::mem::transmute::<
extern "C-unwind" fn(&AnyObject, Sel, *mut AnyObject, *mut AnyObject),
unsafe extern "C-unwind" fn(),
>(ended),
types.as_ptr(),
);
}
}
use crate::app::window::{Orientation, Orientations};
const ORIENTATIONS: [(Orientation, usize); 4] = [
(Orientation::Portrait, 1),
(Orientation::PortraitUpsideDown, 2),
(Orientation::LandscapeLeft, 3),
(Orientation::LandscapeRight, 4),
];
static ALLOWED_ORIENTATIONS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
static TOLD_ORIENTATION: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
pub(super) fn allow_orientations(allowed: Orientations) {
let mask = ORIENTATIONS
.iter()
.filter(|(orientation, _)| allowed.contains(*orientation))
.fold(0, |mask, (_, number)| mask | (1 << number));
ALLOWED_ORIENTATIONS.store(mask, Ordering::Release);
}
pub(super) fn apply_orientations(view: NonNull<c_void>) {
extern "C-unwind" fn supported(_this: &AnyObject, _cmd: Sel) -> usize {
ALLOWED_ORIENTATIONS.load(Ordering::Acquire)
}
if ALLOWED_ORIENTATIONS.load(Ordering::Acquire) == 0 {
return;
}
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
unsafe {
let window: Option<Retained<AnyObject>> = msg_send![view, window];
let controller: Option<Retained<AnyObject>> = match &window {
Some(window) => msg_send![&**window, rootViewController],
None => None,
};
let Some(controller) = controller else {
return;
};
let class = std::ptr::from_ref(controller.class()).cast_mut();
objc2::ffi::class_replaceMethod(
class.cast(),
sel!(supportedInterfaceOrientations),
std::mem::transmute::<extern "C-unwind" fn(&AnyObject, Sel) -> usize, unsafe extern "C-unwind" fn()>(supported),
c"Q@:".as_ptr(),
);
let _: () = msg_send![&*controller, setNeedsUpdateOfSupportedInterfaceOrientations];
}
}
pub(super) fn watch_orientation() {
let scene = SCENE.load(Ordering::Acquire);
let Some(scene) = (unsafe { scene.as_ref() }) else {
return;
};
let number: isize = unsafe { msg_send![scene, interfaceOrientation] };
let Some((orientation, number)) = ORIENTATIONS
.iter()
.find(|(_, known)| *known as isize == number)
.copied()
else {
return;
};
if TOLD_ORIENTATION.swap(number, Ordering::AcqRel) != number {
push_app_event(AppEvent::Rotated(orientation));
}
}
use crate::app::window::{Appearance, SystemSettings};
#[link(name = "UIKit", kind = "framework")]
unsafe extern "C" {
fn UIAccessibilityIsBoldTextEnabled() -> bool;
fn UIAccessibilityIsReduceMotionEnabled() -> bool;
fn UIAccessibilityDarkerSystemColorsEnabled() -> bool;
fn UIAccessibilityIsReduceTransparencyEnabled() -> bool;
fn UIAccessibilityShouldDifferentiateWithoutColor() -> bool;
fn UIAccessibilityButtonShapesEnabled() -> bool;
fn UIAccessibilityIsOnOffSwitchLabelsEnabled() -> bool;
}
pub(super) fn system_settings(view: NonNull<c_void>) -> SystemSettings {
let view: &AnyObject = unsafe { view.cast::<AnyObject>().as_ref() };
unsafe {
let probe = SAFE_AREA_PROBE.load(Ordering::Acquire);
let traits: Retained<AnyObject> = match probe.as_ref() {
Some(probe) => msg_send![probe, traitCollection],
None => msg_send![view, traitCollection],
};
let style: isize = msg_send![&*traits, userInterfaceStyle];
let metrics: Retained<AnyObject> = msg_send![class!(UIFontMetrics), defaultMetrics];
let scaled: f64 = msg_send![&*metrics, scaledValueForValue: 100.0f64, compatibleWithTraitCollection: &*traits];
SystemSettings {
appearance: if style == 2 {
Appearance::Dark
} else {
Appearance::Light
},
text_scale: (scaled / 100.0) as f32,
bold_text: UIAccessibilityIsBoldTextEnabled(),
reduce_motion: UIAccessibilityIsReduceMotionEnabled(),
increase_contrast: UIAccessibilityDarkerSystemColorsEnabled(),
reduce_transparency: UIAccessibilityIsReduceTransparencyEnabled(),
differentiate_without_color: UIAccessibilityShouldDifferentiateWithoutColor(),
button_shapes: UIAccessibilityButtonShapesEnabled(),
on_off_labels: UIAccessibilityIsOnOffSwitchLabelsEnabled(),
}
}
}