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 fn activate(&self) {
354 unsafe {
355 let _: () = msg_send![self.0.borrow().native_window, makeKeyAndOrderFront: nil];
356 }
357 }
358}
359
360impl platform::WindowContext for Window {
361 fn size(&self) -> Vector2F {
362 self.0.as_ref().borrow().size()
363 }
364
365 fn scale_factor(&self) -> f32 {
366 self.0.as_ref().borrow().scale_factor()
367 }
368
369 fn present_scene(&mut self, scene: Scene) {
370 self.0.as_ref().borrow_mut().present_scene(scene);
371 }
372
373 fn titlebar_height(&self) -> f32 {
374 self.0.as_ref().borrow().titlebar_height()
375 }
376}
377
378impl WindowState {
379 fn move_traffic_light(&self) {
380 if let Some(traffic_light_position) = self.traffic_light_position {
381 let titlebar_height = self.titlebar_height();
382
383 unsafe {
384 let close_button: id = msg_send![
385 self.native_window,
386 standardWindowButton: NSWindowButton::NSWindowCloseButton
387 ];
388 let min_button: id = msg_send![
389 self.native_window,
390 standardWindowButton: NSWindowButton::NSWindowMiniaturizeButton
391 ];
392 let zoom_button: id = msg_send![
393 self.native_window,
394 standardWindowButton: NSWindowButton::NSWindowZoomButton
395 ];
396
397 let mut close_button_frame: CGRect = msg_send![close_button, frame];
398 let mut min_button_frame: CGRect = msg_send![min_button, frame];
399 let mut zoom_button_frame: CGRect = msg_send![zoom_button, frame];
400 let mut origin = vec2f(
401 traffic_light_position.x(),
402 titlebar_height
403 - traffic_light_position.y()
404 - close_button_frame.size.height as f32,
405 );
406 let button_spacing =
407 (min_button_frame.origin.x - close_button_frame.origin.x) as f32;
408
409 close_button_frame.origin = CGPoint::new(origin.x() as f64, origin.y() as f64);
410 let _: () = msg_send![close_button, setFrame: close_button_frame];
411 origin.set_x(origin.x() + button_spacing);
412
413 min_button_frame.origin = CGPoint::new(origin.x() as f64, origin.y() as f64);
414 let _: () = msg_send![min_button, setFrame: min_button_frame];
415 origin.set_x(origin.x() + button_spacing);
416
417 zoom_button_frame.origin = CGPoint::new(origin.x() as f64, origin.y() as f64);
418 let _: () = msg_send![zoom_button, setFrame: zoom_button_frame];
419 }
420 }
421 }
422}
423
424impl platform::WindowContext for WindowState {
425 fn size(&self) -> Vector2F {
426 let NSSize { width, height, .. } =
427 unsafe { NSView::frame(self.native_window.contentView()) }.size;
428 vec2f(width as f32, height as f32)
429 }
430
431 fn scale_factor(&self) -> f32 {
432 get_scale_factor(self.native_window)
433 }
434
435 fn titlebar_height(&self) -> f32 {
436 unsafe {
437 let frame = NSWindow::frame(self.native_window);
438 let content_layout_rect: CGRect = msg_send![self.native_window, contentLayoutRect];
439 (frame.size.height - content_layout_rect.size.height) as f32
440 }
441 }
442
443 fn present_scene(&mut self, scene: Scene) {
444 self.scene_to_render = Some(scene);
445 unsafe {
446 let _: () = msg_send![self.native_window.contentView(), setNeedsDisplay: YES];
447 }
448 }
449}
450
451fn get_scale_factor(native_window: id) -> f32 {
452 unsafe {
453 let screen: id = msg_send![native_window, screen];
454 NSScreen::backingScaleFactor(screen) as f32
455 }
456}
457
458unsafe fn get_window_state(object: &Object) -> Rc<RefCell<WindowState>> {
459 let raw: *mut c_void = *object.get_ivar(WINDOW_STATE_IVAR);
460 let rc1 = Rc::from_raw(raw as *mut RefCell<WindowState>);
461 let rc2 = rc1.clone();
462 mem::forget(rc1);
463 rc2
464}
465
466unsafe fn drop_window_state(object: &Object) {
467 let raw: *mut c_void = *object.get_ivar(WINDOW_STATE_IVAR);
468 Rc::from_raw(raw as *mut RefCell<WindowState>);
469}
470
471extern "C" fn yes(_: &Object, _: Sel) -> BOOL {
472 YES
473}
474
475extern "C" fn dealloc_window(this: &Object, _: Sel) {
476 unsafe {
477 drop_window_state(this);
478 let () = msg_send![super(this, class!(NSWindow)), dealloc];
479 }
480}
481
482extern "C" fn dealloc_view(this: &Object, _: Sel) {
483 unsafe {
484 drop_window_state(this);
485 let () = msg_send![super(this, class!(NSView)), dealloc];
486 }
487}
488
489extern "C" fn handle_view_event(this: &Object, _: Sel, native_event: id) {
490 let window_state = unsafe { get_window_state(this) };
491 let weak_window_state = Rc::downgrade(&window_state);
492 let mut window_state_borrow = window_state.as_ref().borrow_mut();
493
494 let event = unsafe { Event::from_native(native_event, Some(window_state_borrow.size().y())) };
495
496 if let Some(event) = event {
497 match &event {
498 Event::LeftMouseDragged { position } => {
499 window_state_borrow.synthetic_drag_counter += 1;
500 window_state_borrow
501 .executor
502 .spawn(synthetic_drag(
503 weak_window_state,
504 window_state_borrow.synthetic_drag_counter,
505 *position,
506 ))
507 .detach();
508 }
509 Event::LeftMouseUp { .. } => {
510 window_state_borrow.synthetic_drag_counter += 1;
511 }
512
513 // Ignore events from held-down keys after some of the initially-pressed keys
514 // were released.
515 Event::KeyDown {
516 chars,
517 keystroke,
518 is_held,
519 } => {
520 let keydown = (keystroke.clone(), chars.clone());
521 if *is_held {
522 if window_state_borrow.last_fresh_keydown.as_ref() != Some(&keydown) {
523 return;
524 }
525 } else {
526 window_state_borrow.last_fresh_keydown = Some(keydown);
527 }
528 }
529
530 _ => {}
531 }
532
533 if let Some(mut callback) = window_state_borrow.event_callback.take() {
534 drop(window_state_borrow);
535 callback(event);
536 window_state.borrow_mut().event_callback = Some(callback);
537 }
538 }
539}
540
541extern "C" fn send_event(this: &Object, _: Sel, native_event: id) {
542 unsafe {
543 let () = msg_send![super(this, class!(NSWindow)), sendEvent: native_event];
544 }
545}
546
547extern "C" fn window_did_resize(this: &Object, _: Sel, _: id) {
548 let window_state = unsafe { get_window_state(this) };
549 window_state.as_ref().borrow().move_traffic_light();
550}
551
552extern "C" fn close_window(this: &Object, _: Sel) {
553 unsafe {
554 let close_callback = {
555 let window_state = get_window_state(this);
556 window_state
557 .as_ref()
558 .try_borrow_mut()
559 .ok()
560 .and_then(|mut window_state| window_state.close_callback.take())
561 };
562
563 if let Some(callback) = close_callback {
564 callback();
565 }
566
567 let () = msg_send![super(this, class!(NSWindow)), close];
568 }
569}
570
571extern "C" fn make_backing_layer(this: &Object, _: Sel) -> id {
572 let window_state = unsafe { get_window_state(this) };
573 let window_state = window_state.as_ref().borrow();
574 window_state.layer
575}
576
577extern "C" fn view_did_change_backing_properties(this: &Object, _: Sel) {
578 let window_state = unsafe { get_window_state(this) };
579 let mut window_state_borrow = window_state.as_ref().borrow_mut();
580
581 unsafe {
582 let _: () = msg_send![window_state_borrow.layer, setContentsScale: window_state_borrow.scale_factor() as f64];
583 }
584
585 if let Some(mut callback) = window_state_borrow.resize_callback.take() {
586 drop(window_state_borrow);
587 callback();
588 window_state.as_ref().borrow_mut().resize_callback = Some(callback);
589 };
590}
591
592extern "C" fn set_frame_size(this: &Object, _: Sel, size: NSSize) {
593 let window_state = unsafe { get_window_state(this) };
594 let mut window_state_borrow = window_state.as_ref().borrow_mut();
595
596 if window_state_borrow.size() == vec2f(size.width as f32, size.height as f32) {
597 return;
598 }
599
600 unsafe {
601 let _: () = msg_send![super(this, class!(NSView)), setFrameSize: size];
602 }
603
604 let scale_factor = window_state_borrow.scale_factor() as f64;
605 let drawable_size: NSSize = NSSize {
606 width: size.width * scale_factor,
607 height: size.height * scale_factor,
608 };
609
610 unsafe {
611 let _: () = msg_send![window_state_borrow.layer, setDrawableSize: drawable_size];
612 }
613
614 if let Some(mut callback) = window_state_borrow.resize_callback.take() {
615 drop(window_state_borrow);
616 callback();
617 window_state.borrow_mut().resize_callback = Some(callback);
618 };
619}
620
621extern "C" fn display_layer(this: &Object, _: Sel, _: id) {
622 unsafe {
623 let window_state = get_window_state(this);
624 let mut window_state = window_state.as_ref().borrow_mut();
625
626 if let Some(scene) = window_state.scene_to_render.take() {
627 let drawable: &metal::MetalDrawableRef = msg_send![window_state.layer, nextDrawable];
628 let command_queue = window_state.command_queue.clone();
629 let command_buffer = command_queue.new_command_buffer();
630
631 let size = window_state.size();
632 let scale_factor = window_state.scale_factor();
633
634 window_state.renderer.render(
635 &scene,
636 size * scale_factor,
637 command_buffer,
638 drawable.texture(),
639 );
640
641 command_buffer.commit();
642 command_buffer.wait_until_completed();
643 drawable.present();
644 };
645 }
646}
647
648async fn synthetic_drag(
649 window_state: Weak<RefCell<WindowState>>,
650 drag_id: usize,
651 position: Vector2F,
652) {
653 loop {
654 Timer::after(Duration::from_millis(16)).await;
655 if let Some(window_state) = window_state.upgrade() {
656 let mut window_state_borrow = window_state.borrow_mut();
657 if window_state_borrow.synthetic_drag_counter == drag_id {
658 if let Some(mut callback) = window_state_borrow.event_callback.take() {
659 drop(window_state_borrow);
660 callback(Event::LeftMouseDragged { position });
661 window_state.borrow_mut().event_callback = Some(callback);
662 }
663 } else {
664 break;
665 }
666 }
667 }
668}
669
670unsafe fn ns_string(string: &str) -> id {
671 NSString::alloc(nil).init_str(string).autorelease()
672}