1use crate::{
2 executor,
3 geometry::{
4 rect::RectF,
5 vector::{vec2f, Vector2F},
6 },
7 keymap::Keystroke,
8 platform::{self, Event, WindowBounds, WindowContext},
9 Scene,
10};
11use block::ConcreteBlock;
12use cocoa::{
13 appkit::{
14 CGPoint, NSApplication, NSBackingStoreBuffered, NSScreen, NSView, NSViewHeightSizable,
15 NSViewWidthSizable, NSWindow, NSWindowButton, NSWindowStyleMask,
16 },
17 base::{id, nil},
18 foundation::{NSAutoreleasePool, NSInteger, NSSize, NSString},
19 quartzcore::AutoresizingMask,
20};
21use core_graphics::display::CGRect;
22use ctor::ctor;
23use foreign_types::ForeignType as _;
24use objc::{
25 class,
26 declare::ClassDecl,
27 msg_send,
28 runtime::{Class, Object, Protocol, Sel, BOOL, NO, YES},
29 sel, sel_impl,
30};
31use postage::oneshot;
32use smol::Timer;
33use std::{
34 any::Any,
35 cell::{Cell, RefCell},
36 convert::TryInto,
37 ffi::c_void,
38 mem, ptr,
39 rc::{Rc, Weak},
40 sync::Arc,
41 time::Duration,
42};
43
44use super::{geometry::RectFExt, renderer::Renderer};
45
46const WINDOW_STATE_IVAR: &'static str = "windowState";
47
48static mut WINDOW_CLASS: *const Class = ptr::null();
49static mut VIEW_CLASS: *const Class = ptr::null();
50
51#[allow(non_upper_case_globals)]
52const NSViewLayerContentsRedrawDuringViewResize: NSInteger = 2;
53
54#[ctor]
55unsafe fn build_classes() {
56 WINDOW_CLASS = {
57 let mut decl = ClassDecl::new("GPUIWindow", class!(NSWindow)).unwrap();
58 decl.add_ivar::<*mut c_void>(WINDOW_STATE_IVAR);
59 decl.add_method(sel!(dealloc), dealloc_window as extern "C" fn(&Object, Sel));
60 decl.add_method(
61 sel!(canBecomeMainWindow),
62 yes as extern "C" fn(&Object, Sel) -> BOOL,
63 );
64 decl.add_method(
65 sel!(canBecomeKeyWindow),
66 yes as extern "C" fn(&Object, Sel) -> BOOL,
67 );
68 decl.add_method(
69 sel!(sendEvent:),
70 send_event as extern "C" fn(&Object, Sel, id),
71 );
72 decl.add_method(
73 sel!(windowDidResize:),
74 window_did_resize as extern "C" fn(&Object, Sel, id),
75 );
76 decl.add_method(sel!(close), close_window as extern "C" fn(&Object, Sel));
77 decl.register()
78 };
79
80 VIEW_CLASS = {
81 let mut decl = ClassDecl::new("GPUIView", class!(NSView)).unwrap();
82 decl.add_ivar::<*mut c_void>(WINDOW_STATE_IVAR);
83
84 decl.add_method(sel!(dealloc), dealloc_view as extern "C" fn(&Object, Sel));
85
86 decl.add_method(
87 sel!(keyDown:),
88 handle_view_event as extern "C" fn(&Object, Sel, id),
89 );
90 decl.add_method(
91 sel!(mouseDown:),
92 handle_view_event as extern "C" fn(&Object, Sel, id),
93 );
94 decl.add_method(
95 sel!(mouseUp:),
96 handle_view_event as extern "C" fn(&Object, Sel, id),
97 );
98 decl.add_method(
99 sel!(mouseMoved:),
100 handle_view_event as extern "C" fn(&Object, Sel, id),
101 );
102 decl.add_method(
103 sel!(mouseDragged:),
104 handle_view_event as extern "C" fn(&Object, Sel, id),
105 );
106 decl.add_method(
107 sel!(scrollWheel:),
108 handle_view_event as extern "C" fn(&Object, Sel, id),
109 );
110
111 decl.add_method(
112 sel!(makeBackingLayer),
113 make_backing_layer as extern "C" fn(&Object, Sel) -> id,
114 );
115
116 decl.add_protocol(Protocol::get("CALayerDelegate").unwrap());
117 decl.add_method(
118 sel!(viewDidChangeBackingProperties),
119 view_did_change_backing_properties as extern "C" fn(&Object, Sel),
120 );
121 decl.add_method(
122 sel!(setFrameSize:),
123 set_frame_size as extern "C" fn(&Object, Sel, NSSize),
124 );
125 decl.add_method(
126 sel!(displayLayer:),
127 display_layer as extern "C" fn(&Object, Sel, id),
128 );
129
130 decl.register()
131 };
132}
133
134pub struct Window(Rc<RefCell<WindowState>>);
135
136struct WindowState {
137 id: usize,
138 native_window: id,
139 event_callback: Option<Box<dyn FnMut(Event)>>,
140 resize_callback: Option<Box<dyn FnMut()>>,
141 close_callback: Option<Box<dyn FnOnce()>>,
142 synthetic_drag_counter: usize,
143 executor: Rc<executor::Foreground>,
144 scene_to_render: Option<Scene>,
145 renderer: Renderer,
146 command_queue: metal::CommandQueue,
147 last_fresh_keydown: Option<(Keystroke, String)>,
148 layer: id,
149 traffic_light_position: Option<Vector2F>,
150}
151
152impl Window {
153 pub fn open(
154 id: usize,
155 options: platform::WindowOptions,
156 executor: Rc<executor::Foreground>,
157 fonts: Arc<dyn platform::FontSystem>,
158 ) -> Self {
159 const PIXEL_FORMAT: metal::MTLPixelFormat = metal::MTLPixelFormat::BGRA8Unorm;
160
161 unsafe {
162 let pool = NSAutoreleasePool::new(nil);
163
164 let frame = match options.bounds {
165 WindowBounds::Maximized => RectF::new(Default::default(), vec2f(1024., 768.)),
166 WindowBounds::Fixed(rect) => rect,
167 }
168 .to_ns_rect();
169 let mut style_mask = NSWindowStyleMask::NSClosableWindowMask
170 | NSWindowStyleMask::NSMiniaturizableWindowMask
171 | NSWindowStyleMask::NSResizableWindowMask
172 | NSWindowStyleMask::NSTitledWindowMask;
173
174 if options.titlebar_appears_transparent {
175 style_mask |= NSWindowStyleMask::NSFullSizeContentViewWindowMask;
176 }
177
178 let native_window: id = msg_send![WINDOW_CLASS, alloc];
179 let native_window = native_window.initWithContentRect_styleMask_backing_defer_(
180 frame,
181 style_mask,
182 NSBackingStoreBuffered,
183 NO,
184 );
185 assert!(!native_window.is_null());
186
187 if matches!(options.bounds, WindowBounds::Maximized) {
188 let screen = native_window.screen();
189 native_window.setFrame_display_(screen.visibleFrame(), YES);
190 }
191
192 let device =
193 metal::Device::system_default().expect("could not find default metal device");
194
195 let layer: id = msg_send![class!(CAMetalLayer), layer];
196 let _: () = msg_send![layer, setDevice: device.as_ptr()];
197 let _: () = msg_send![layer, setPixelFormat: PIXEL_FORMAT];
198 let _: () = msg_send![layer, setAllowsNextDrawableTimeout: NO];
199 let _: () = msg_send![layer, setNeedsDisplayOnBoundsChange: YES];
200 let _: () = msg_send![layer, setPresentsWithTransaction: YES];
201 let _: () = msg_send![
202 layer,
203 setAutoresizingMask: AutoresizingMask::WIDTH_SIZABLE
204 | AutoresizingMask::HEIGHT_SIZABLE
205 ];
206
207 let native_view: id = msg_send![VIEW_CLASS, alloc];
208 let native_view = NSView::init(native_view);
209 assert!(!native_view.is_null());
210
211 let window = Self(Rc::new(RefCell::new(WindowState {
212 id,
213 native_window,
214 event_callback: None,
215 resize_callback: None,
216 close_callback: None,
217 synthetic_drag_counter: 0,
218 executor,
219 scene_to_render: Default::default(),
220 renderer: Renderer::new(
221 device.clone(),
222 PIXEL_FORMAT,
223 get_scale_factor(native_window),
224 fonts,
225 ),
226 command_queue: device.new_command_queue(),
227 last_fresh_keydown: None,
228 layer,
229 traffic_light_position: options.traffic_light_position,
230 })));
231
232 (*native_window).set_ivar(
233 WINDOW_STATE_IVAR,
234 Rc::into_raw(window.0.clone()) as *const c_void,
235 );
236 native_window.setDelegate_(native_window);
237 (*native_view).set_ivar(
238 WINDOW_STATE_IVAR,
239 Rc::into_raw(window.0.clone()) as *const c_void,
240 );
241
242 if let Some(title) = options.title.as_ref() {
243 native_window.setTitle_(NSString::alloc(nil).init_str(title));
244 }
245 if options.titlebar_appears_transparent {
246 native_window.setTitlebarAppearsTransparent_(YES);
247 }
248 native_window.setAcceptsMouseMovedEvents_(YES);
249
250 native_view.setAutoresizingMask_(NSViewWidthSizable | NSViewHeightSizable);
251 native_view.setWantsBestResolutionOpenGLSurface_(YES);
252
253 // From winit crate: On Mojave, views automatically become layer-backed shortly after
254 // being added to a native_window. Changing the layer-backedness of a view breaks the
255 // association between the view and its associated OpenGL context. To work around this,
256 // on we explicitly make the view layer-backed up front so that AppKit doesn't do it
257 // itself and break the association with its context.
258 native_view.setWantsLayer(YES);
259 let _: () = msg_send![
260 native_view,
261 setLayerContentsRedrawPolicy: NSViewLayerContentsRedrawDuringViewResize
262 ];
263
264 native_window.setContentView_(native_view.autorelease());
265 native_window.makeFirstResponder_(native_view);
266
267 native_window.center();
268 native_window.makeKeyAndOrderFront_(nil);
269
270 window.0.borrow().move_traffic_light();
271 pool.drain();
272
273 window
274 }
275 }
276
277 pub fn key_window_id() -> Option<usize> {
278 unsafe {
279 let app = NSApplication::sharedApplication(nil);
280 let key_window: id = msg_send![app, keyWindow];
281 if msg_send![key_window, isKindOfClass: WINDOW_CLASS] {
282 let id = get_window_state(&*key_window).borrow().id;
283 Some(id)
284 } else {
285 None
286 }
287 }
288 }
289}
290
291impl Drop for Window {
292 fn drop(&mut self) {
293 unsafe {
294 self.0.as_ref().borrow().native_window.close();
295 }
296 }
297}
298
299impl platform::Window for Window {
300 fn as_any_mut(&mut self) -> &mut dyn Any {
301 self
302 }
303
304 fn on_event(&mut self, callback: Box<dyn FnMut(Event)>) {
305 self.0.as_ref().borrow_mut().event_callback = Some(callback);
306 }
307
308 fn on_resize(&mut self, callback: Box<dyn FnMut()>) {
309 self.0.as_ref().borrow_mut().resize_callback = Some(callback);
310 }
311
312 fn on_close(&mut self, callback: Box<dyn FnOnce()>) {
313 self.0.as_ref().borrow_mut().close_callback = Some(callback);
314 }
315
316 fn prompt(
317 &self,
318 level: platform::PromptLevel,
319 msg: &str,
320 answers: &[&str],
321 ) -> oneshot::Receiver<usize> {
322 unsafe {
323 let alert: id = msg_send![class!(NSAlert), alloc];
324 let alert: id = msg_send![alert, init];
325 let alert_style = match level {
326 platform::PromptLevel::Info => 1,
327 platform::PromptLevel::Warning => 0,
328 platform::PromptLevel::Critical => 2,
329 };
330 let _: () = msg_send![alert, setAlertStyle: alert_style];
331 let _: () = msg_send![alert, setMessageText: ns_string(msg)];
332 for (ix, answer) in answers.into_iter().enumerate() {
333 let button: id = msg_send![alert, addButtonWithTitle: ns_string(answer)];
334 let _: () = msg_send![button, setTag: ix as NSInteger];
335 }
336 let (done_tx, done_rx) = oneshot::channel();
337 let done_tx = Cell::new(Some(done_tx));
338 let block = ConcreteBlock::new(move |answer: NSInteger| {
339 if let Some(mut done_tx) = done_tx.take() {
340 let _ = postage::sink::Sink::try_send(&mut done_tx, answer.try_into().unwrap());
341 }
342 });
343 let block = block.copy();
344 let _: () = msg_send![
345 alert,
346 beginSheetModalForWindow: self.0.borrow().native_window
347 completionHandler: block
348 ];
349 done_rx
350 }
351 }
352}
353
354impl platform::WindowContext for Window {
355 fn size(&self) -> Vector2F {
356 self.0.as_ref().borrow().size()
357 }
358
359 fn scale_factor(&self) -> f32 {
360 self.0.as_ref().borrow().scale_factor()
361 }
362
363 fn present_scene(&mut self, scene: Scene) {
364 self.0.as_ref().borrow_mut().present_scene(scene);
365 }
366
367 fn titlebar_height(&self) -> f32 {
368 self.0.as_ref().borrow().titlebar_height()
369 }
370}
371
372impl WindowState {
373 fn move_traffic_light(&self) {
374 if let Some(traffic_light_position) = self.traffic_light_position {
375 let titlebar_height = self.titlebar_height();
376
377 unsafe {
378 let close_button: id = msg_send![
379 self.native_window,
380 standardWindowButton: NSWindowButton::NSWindowCloseButton
381 ];
382 let min_button: id = msg_send![
383 self.native_window,
384 standardWindowButton: NSWindowButton::NSWindowMiniaturizeButton
385 ];
386 let zoom_button: id = msg_send![
387 self.native_window,
388 standardWindowButton: NSWindowButton::NSWindowZoomButton
389 ];
390
391 let mut close_button_frame: CGRect = msg_send![close_button, frame];
392 let mut min_button_frame: CGRect = msg_send![min_button, frame];
393 let mut zoom_button_frame: CGRect = msg_send![zoom_button, frame];
394 let mut origin = vec2f(
395 traffic_light_position.x(),
396 titlebar_height
397 - traffic_light_position.y()
398 - close_button_frame.size.height as f32,
399 );
400 let button_spacing =
401 (min_button_frame.origin.x - close_button_frame.origin.x) as f32;
402
403 close_button_frame.origin = CGPoint::new(origin.x() as f64, origin.y() as f64);
404 let _: () = msg_send![close_button, setFrame: close_button_frame];
405 origin.set_x(origin.x() + button_spacing);
406
407 min_button_frame.origin = CGPoint::new(origin.x() as f64, origin.y() as f64);
408 let _: () = msg_send![min_button, setFrame: min_button_frame];
409 origin.set_x(origin.x() + button_spacing);
410
411 zoom_button_frame.origin = CGPoint::new(origin.x() as f64, origin.y() as f64);
412 let _: () = msg_send![zoom_button, setFrame: zoom_button_frame];
413 }
414 }
415 }
416}
417
418impl platform::WindowContext for WindowState {
419 fn size(&self) -> Vector2F {
420 let NSSize { width, height, .. } =
421 unsafe { NSView::frame(self.native_window.contentView()) }.size;
422 vec2f(width as f32, height as f32)
423 }
424
425 fn scale_factor(&self) -> f32 {
426 get_scale_factor(self.native_window)
427 }
428
429 fn titlebar_height(&self) -> f32 {
430 unsafe {
431 let frame = NSWindow::frame(self.native_window);
432 let content_layout_rect: CGRect = msg_send![self.native_window, contentLayoutRect];
433 (frame.size.height - content_layout_rect.size.height) as f32
434 }
435 }
436
437 fn present_scene(&mut self, scene: Scene) {
438 self.scene_to_render = Some(scene);
439 unsafe {
440 let _: () = msg_send![self.native_window.contentView(), setNeedsDisplay: YES];
441 }
442 }
443}
444
445fn get_scale_factor(native_window: id) -> f32 {
446 unsafe {
447 let screen: id = msg_send![native_window, screen];
448 NSScreen::backingScaleFactor(screen) as f32
449 }
450}
451
452unsafe fn get_window_state(object: &Object) -> Rc<RefCell<WindowState>> {
453 let raw: *mut c_void = *object.get_ivar(WINDOW_STATE_IVAR);
454 let rc1 = Rc::from_raw(raw as *mut RefCell<WindowState>);
455 let rc2 = rc1.clone();
456 mem::forget(rc1);
457 rc2
458}
459
460unsafe fn drop_window_state(object: &Object) {
461 let raw: *mut c_void = *object.get_ivar(WINDOW_STATE_IVAR);
462 Rc::from_raw(raw as *mut RefCell<WindowState>);
463}
464
465extern "C" fn yes(_: &Object, _: Sel) -> BOOL {
466 YES
467}
468
469extern "C" fn dealloc_window(this: &Object, _: Sel) {
470 unsafe {
471 drop_window_state(this);
472 let () = msg_send![super(this, class!(NSWindow)), dealloc];
473 }
474}
475
476extern "C" fn dealloc_view(this: &Object, _: Sel) {
477 unsafe {
478 drop_window_state(this);
479 let () = msg_send![super(this, class!(NSView)), dealloc];
480 }
481}
482
483extern "C" fn handle_view_event(this: &Object, _: Sel, native_event: id) {
484 let window_state = unsafe { get_window_state(this) };
485 let weak_window_state = Rc::downgrade(&window_state);
486 let mut window_state_borrow = window_state.as_ref().borrow_mut();
487
488 let event = unsafe { Event::from_native(native_event, Some(window_state_borrow.size().y())) };
489
490 if let Some(event) = event {
491 match &event {
492 Event::LeftMouseDragged { position } => {
493 window_state_borrow.synthetic_drag_counter += 1;
494 window_state_borrow
495 .executor
496 .spawn(synthetic_drag(
497 weak_window_state,
498 window_state_borrow.synthetic_drag_counter,
499 *position,
500 ))
501 .detach();
502 }
503 Event::LeftMouseUp { .. } => {
504 window_state_borrow.synthetic_drag_counter += 1;
505 }
506
507 // Ignore events from held-down keys after some of the initially-pressed keys
508 // were released.
509 Event::KeyDown {
510 chars,
511 keystroke,
512 is_held,
513 } => {
514 let keydown = (keystroke.clone(), chars.clone());
515 if *is_held {
516 if window_state_borrow.last_fresh_keydown.as_ref() != Some(&keydown) {
517 return;
518 }
519 } else {
520 window_state_borrow.last_fresh_keydown = Some(keydown);
521 }
522 }
523
524 _ => {}
525 }
526
527 if let Some(mut callback) = window_state_borrow.event_callback.take() {
528 drop(window_state_borrow);
529 callback(event);
530 window_state.borrow_mut().event_callback = Some(callback);
531 }
532 }
533}
534
535extern "C" fn send_event(this: &Object, _: Sel, native_event: id) {
536 unsafe {
537 let () = msg_send![super(this, class!(NSWindow)), sendEvent: native_event];
538 }
539}
540
541extern "C" fn window_did_resize(this: &Object, _: Sel, _: id) {
542 let window_state = unsafe { get_window_state(this) };
543 window_state.as_ref().borrow().move_traffic_light();
544}
545
546extern "C" fn close_window(this: &Object, _: Sel) {
547 unsafe {
548 let close_callback = {
549 let window_state = get_window_state(this);
550 window_state
551 .as_ref()
552 .try_borrow_mut()
553 .ok()
554 .and_then(|mut window_state| window_state.close_callback.take())
555 };
556
557 if let Some(callback) = close_callback {
558 callback();
559 }
560
561 let () = msg_send![super(this, class!(NSWindow)), close];
562 }
563}
564
565extern "C" fn make_backing_layer(this: &Object, _: Sel) -> id {
566 let window_state = unsafe { get_window_state(this) };
567 let window_state = window_state.as_ref().borrow();
568 window_state.layer
569}
570
571extern "C" fn view_did_change_backing_properties(this: &Object, _: Sel) {
572 let window_state = unsafe { get_window_state(this) };
573 let mut window_state_borrow = window_state.as_ref().borrow_mut();
574
575 unsafe {
576 let _: () = msg_send![window_state_borrow.layer, setContentsScale: window_state_borrow.scale_factor() as f64];
577 }
578
579 if let Some(mut callback) = window_state_borrow.resize_callback.take() {
580 drop(window_state_borrow);
581 callback();
582 window_state.as_ref().borrow_mut().resize_callback = Some(callback);
583 };
584}
585
586extern "C" fn set_frame_size(this: &Object, _: Sel, size: NSSize) {
587 let window_state = unsafe { get_window_state(this) };
588 let mut window_state_borrow = window_state.as_ref().borrow_mut();
589
590 if window_state_borrow.size() == vec2f(size.width as f32, size.height as f32) {
591 return;
592 }
593
594 unsafe {
595 let _: () = msg_send![super(this, class!(NSView)), setFrameSize: size];
596 }
597
598 let scale_factor = window_state_borrow.scale_factor() as f64;
599 let drawable_size: NSSize = NSSize {
600 width: size.width * scale_factor,
601 height: size.height * scale_factor,
602 };
603
604 unsafe {
605 let _: () = msg_send![window_state_borrow.layer, setDrawableSize: drawable_size];
606 }
607
608 if let Some(mut callback) = window_state_borrow.resize_callback.take() {
609 drop(window_state_borrow);
610 callback();
611 window_state.borrow_mut().resize_callback = Some(callback);
612 };
613}
614
615extern "C" fn display_layer(this: &Object, _: Sel, _: id) {
616 unsafe {
617 let window_state = get_window_state(this);
618 let mut window_state = window_state.as_ref().borrow_mut();
619
620 if let Some(scene) = window_state.scene_to_render.take() {
621 let drawable: &metal::MetalDrawableRef = msg_send![window_state.layer, nextDrawable];
622 let command_queue = window_state.command_queue.clone();
623 let command_buffer = command_queue.new_command_buffer();
624
625 let size = window_state.size();
626 let scale_factor = window_state.scale_factor();
627
628 window_state.renderer.render(
629 &scene,
630 size * scale_factor,
631 command_buffer,
632 drawable.texture(),
633 );
634
635 command_buffer.commit();
636 command_buffer.wait_until_completed();
637 drawable.present();
638 };
639 }
640}
641
642async fn synthetic_drag(
643 window_state: Weak<RefCell<WindowState>>,
644 drag_id: usize,
645 position: Vector2F,
646) {
647 loop {
648 Timer::after(Duration::from_millis(16)).await;
649 if let Some(window_state) = window_state.upgrade() {
650 let mut window_state_borrow = window_state.borrow_mut();
651 if window_state_borrow.synthetic_drag_counter == drag_id {
652 if let Some(mut callback) = window_state_borrow.event_callback.take() {
653 drop(window_state_borrow);
654 callback(Event::LeftMouseDragged { position });
655 window_state.borrow_mut().event_callback = Some(callback);
656 }
657 } else {
658 break;
659 }
660 }
661 }
662}
663
664unsafe fn ns_string(string: &str) -> id {
665 NSString::alloc(nil).init_str(string).autorelease()
666}