1//todo!(linux): remove
2#![allow(unused)]
3
4use crate::{
5 platform::blade::BladeRenderer, size, Bounds, GlobalPixels, Pixels, PlatformDisplay,
6 PlatformInput, PlatformInputHandler, PlatformWindow, Point, Size, WindowAppearance,
7 WindowBounds, WindowOptions, X11Display,
8};
9use blade_graphics as gpu;
10use parking_lot::Mutex;
11use raw_window_handle as rwh;
12
13use xcb::{
14 x::{self, StackMode},
15 Xid as _,
16};
17
18use std::{
19 ffi::c_void,
20 mem,
21 num::NonZeroU32,
22 ptr::NonNull,
23 rc::Rc,
24 sync::{self, Arc},
25};
26
27#[derive(Default)]
28struct Callbacks {
29 request_frame: Option<Box<dyn FnMut()>>,
30 input: Option<Box<dyn FnMut(crate::PlatformInput) -> bool>>,
31 active_status_change: Option<Box<dyn FnMut(bool)>>,
32 resize: Option<Box<dyn FnMut(Size<Pixels>, f32)>>,
33 fullscreen: Option<Box<dyn FnMut(bool)>>,
34 moved: Option<Box<dyn FnMut()>>,
35 should_close: Option<Box<dyn FnMut() -> bool>>,
36 close: Option<Box<dyn FnOnce()>>,
37 appearance_changed: Option<Box<dyn FnMut()>>,
38}
39
40xcb::atoms_struct! {
41 #[derive(Debug)]
42 pub(crate) struct XcbAtoms {
43 pub wm_protocols => b"WM_PROTOCOLS",
44 pub wm_del_window => b"WM_DELETE_WINDOW",
45 wm_state => b"_NET_WM_STATE",
46 wm_state_maxv => b"_NET_WM_STATE_MAXIMIZED_VERT",
47 wm_state_maxh => b"_NET_WM_STATE_MAXIMIZED_HORZ",
48 }
49}
50
51struct LinuxWindowInner {
52 bounds: Bounds<i32>,
53 scale_factor: f32,
54 renderer: BladeRenderer,
55 input_handler: Option<PlatformInputHandler>,
56}
57
58impl LinuxWindowInner {
59 fn content_size(&self) -> Size<Pixels> {
60 let size = self.renderer.viewport_size();
61 Size {
62 width: size.width.into(),
63 height: size.height.into(),
64 }
65 }
66}
67
68fn query_render_extent(xcb_connection: &xcb::Connection, x_window: x::Window) -> gpu::Extent {
69 let cookie = xcb_connection.send_request(&x::GetGeometry {
70 drawable: x::Drawable::Window(x_window),
71 });
72 let reply = xcb_connection.wait_for_reply(cookie).unwrap();
73 gpu::Extent {
74 width: reply.width() as u32,
75 height: reply.height() as u32,
76 depth: 1,
77 }
78}
79
80struct RawWindow {
81 connection: *mut c_void,
82 screen_id: i32,
83 window_id: u32,
84 visual_id: u32,
85}
86
87pub(crate) struct X11WindowState {
88 xcb_connection: Arc<xcb::Connection>,
89 display: Rc<dyn PlatformDisplay>,
90 raw: RawWindow,
91 x_window: x::Window,
92 callbacks: Mutex<Callbacks>,
93 inner: Mutex<LinuxWindowInner>,
94}
95
96#[derive(Clone)]
97pub(crate) struct X11Window(pub(crate) Rc<X11WindowState>);
98
99//todo!(linux): Remove other RawWindowHandle implementation
100unsafe impl blade_rwh::HasRawWindowHandle for RawWindow {
101 fn raw_window_handle(&self) -> blade_rwh::RawWindowHandle {
102 let mut wh = blade_rwh::XcbWindowHandle::empty();
103 wh.window = self.window_id;
104 wh.visual_id = self.visual_id;
105 wh.into()
106 }
107}
108unsafe impl blade_rwh::HasRawDisplayHandle for RawWindow {
109 fn raw_display_handle(&self) -> blade_rwh::RawDisplayHandle {
110 let mut dh = blade_rwh::XcbDisplayHandle::empty();
111 dh.connection = self.connection;
112 dh.screen = self.screen_id;
113 dh.into()
114 }
115}
116
117impl rwh::HasWindowHandle for X11Window {
118 fn window_handle(&self) -> Result<rwh::WindowHandle, rwh::HandleError> {
119 Ok(unsafe {
120 let non_zero = NonZeroU32::new(self.0.raw.window_id).unwrap();
121 let handle = rwh::XcbWindowHandle::new(non_zero);
122 rwh::WindowHandle::borrow_raw(handle.into())
123 })
124 }
125}
126impl rwh::HasDisplayHandle for X11Window {
127 fn display_handle(&self) -> Result<rwh::DisplayHandle, rwh::HandleError> {
128 Ok(unsafe {
129 let non_zero = NonNull::new(self.0.raw.connection).unwrap();
130 let handle = rwh::XcbDisplayHandle::new(Some(non_zero), self.0.raw.screen_id);
131 rwh::DisplayHandle::borrow_raw(handle.into())
132 })
133 }
134}
135
136impl X11WindowState {
137 pub fn new(
138 options: WindowOptions,
139 xcb_connection: &Arc<xcb::Connection>,
140 x_main_screen_index: i32,
141 x_window: x::Window,
142 atoms: &XcbAtoms,
143 ) -> Self {
144 let x_screen_index = options
145 .display_id
146 .map_or(x_main_screen_index, |did| did.0 as i32);
147 let screen = xcb_connection
148 .get_setup()
149 .roots()
150 .nth(x_screen_index as usize)
151 .unwrap();
152
153 let xcb_values = [
154 x::Cw::BackPixel(screen.white_pixel()),
155 x::Cw::EventMask(
156 x::EventMask::EXPOSURE
157 | x::EventMask::STRUCTURE_NOTIFY
158 | x::EventMask::KEY_PRESS
159 | x::EventMask::KEY_RELEASE
160 | x::EventMask::BUTTON_PRESS
161 | x::EventMask::BUTTON_RELEASE
162 | x::EventMask::POINTER_MOTION
163 | x::EventMask::BUTTON1_MOTION
164 | x::EventMask::BUTTON2_MOTION
165 | x::EventMask::BUTTON3_MOTION
166 | x::EventMask::BUTTON4_MOTION
167 | x::EventMask::BUTTON5_MOTION
168 | x::EventMask::BUTTON_MOTION,
169 ),
170 ];
171
172 let bounds = match options.bounds {
173 WindowBounds::Fullscreen | WindowBounds::Maximized => Bounds {
174 origin: Point::default(),
175 size: Size {
176 width: screen.width_in_pixels() as i32,
177 height: screen.height_in_pixels() as i32,
178 },
179 },
180 WindowBounds::Fixed(bounds) => bounds.map(|p| p.0 as i32),
181 };
182
183 xcb_connection.send_request(&x::CreateWindow {
184 depth: x::COPY_FROM_PARENT as u8,
185 wid: x_window,
186 parent: screen.root(),
187 x: bounds.origin.x as i16,
188 y: bounds.origin.y as i16,
189 width: bounds.size.width as u16,
190 height: bounds.size.height as u16,
191 border_width: 0,
192 class: x::WindowClass::InputOutput,
193 visual: screen.root_visual(),
194 value_list: &xcb_values,
195 });
196
197 if let Some(titlebar) = options.titlebar {
198 if let Some(title) = titlebar.title {
199 xcb_connection.send_request(&x::ChangeProperty {
200 mode: x::PropMode::Replace,
201 window: x_window,
202 property: x::ATOM_WM_NAME,
203 r#type: x::ATOM_STRING,
204 data: title.as_bytes(),
205 });
206 }
207 }
208 xcb_connection
209 .send_and_check_request(&x::ChangeProperty {
210 mode: x::PropMode::Replace,
211 window: x_window,
212 property: atoms.wm_protocols,
213 r#type: x::ATOM_ATOM,
214 data: &[atoms.wm_del_window],
215 })
216 .unwrap();
217
218 let fake_id = xcb_connection.generate_id();
219 xcb_connection
220 .send_and_check_request(&xcb::present::SelectInput {
221 eid: fake_id,
222 window: x_window,
223 //Note: also consider `IDLE_NOTIFY`
224 event_mask: xcb::present::EventMask::COMPLETE_NOTIFY,
225 })
226 .unwrap();
227
228 xcb_connection.send_request(&x::MapWindow { window: x_window });
229 xcb_connection.flush().unwrap();
230
231 let raw = RawWindow {
232 connection: as_raw_xcb_connection::AsRawXcbConnection::as_raw_xcb_connection(
233 xcb_connection,
234 ) as *mut _,
235 screen_id: x_screen_index,
236 window_id: x_window.resource_id(),
237 visual_id: screen.root_visual(),
238 };
239 let gpu = Arc::new(
240 unsafe {
241 gpu::Context::init_windowed(
242 &raw,
243 gpu::ContextDesc {
244 validation: cfg!(debug_assertions),
245 capture: false,
246 },
247 )
248 }
249 .unwrap(),
250 );
251
252 // Note: this has to be done after the GPU init, or otherwise
253 // the sizes are immediately invalidated.
254 let gpu_extent = query_render_extent(xcb_connection, x_window);
255
256 Self {
257 xcb_connection: Arc::clone(xcb_connection),
258 display: Rc::new(X11Display::new(xcb_connection, x_screen_index)),
259 raw,
260 x_window,
261 callbacks: Mutex::new(Callbacks::default()),
262 inner: Mutex::new(LinuxWindowInner {
263 bounds,
264 scale_factor: 1.0,
265 renderer: BladeRenderer::new(gpu, gpu_extent),
266 input_handler: None,
267 }),
268 }
269 }
270
271 pub fn destroy(&self) {
272 self.inner.lock().renderer.destroy();
273 self.xcb_connection.send_request(&x::UnmapWindow {
274 window: self.x_window,
275 });
276 self.xcb_connection.send_request(&x::DestroyWindow {
277 window: self.x_window,
278 });
279 if let Some(fun) = self.callbacks.lock().close.take() {
280 fun();
281 }
282 self.xcb_connection.flush().unwrap();
283 }
284
285 pub fn refresh(&self) {
286 let mut cb = self.callbacks.lock();
287 if let Some(ref mut fun) = cb.request_frame {
288 fun();
289 }
290 }
291
292 pub fn configure(&self, bounds: Bounds<i32>) {
293 let mut resize_args = None;
294 let do_move;
295 {
296 let mut inner = self.inner.lock();
297 let old_bounds = mem::replace(&mut inner.bounds, bounds);
298 do_move = old_bounds.origin != bounds.origin;
299 //todo!(linux): use normal GPUI types here, refactor out the double
300 // viewport check and extra casts ( )
301 let gpu_size = query_render_extent(&self.xcb_connection, self.x_window);
302 if inner.renderer.viewport_size() != gpu_size {
303 inner
304 .renderer
305 .update_drawable_size(size(gpu_size.width as f64, gpu_size.height as f64));
306 resize_args = Some((inner.content_size(), inner.scale_factor));
307 }
308 }
309
310 let mut callbacks = self.callbacks.lock();
311 if let Some((content_size, scale_factor)) = resize_args {
312 if let Some(ref mut fun) = callbacks.resize {
313 fun(content_size, scale_factor)
314 }
315 }
316 if do_move {
317 if let Some(ref mut fun) = callbacks.moved {
318 fun()
319 }
320 }
321 }
322
323 pub fn request_refresh(&self) {
324 self.xcb_connection
325 .send_and_check_request(&xcb::present::NotifyMsc {
326 window: self.x_window,
327 serial: 0,
328 target_msc: 0,
329 divisor: 1,
330 remainder: 0,
331 })
332 .unwrap();
333 }
334
335 pub fn handle_input(&self, input: PlatformInput) {
336 if let Some(ref mut fun) = self.callbacks.lock().input {
337 if fun(input.clone()) {
338 return;
339 }
340 }
341 if let PlatformInput::KeyDown(event) = input {
342 let mut inner = self.inner.lock();
343 if let Some(ref mut input_handler) = inner.input_handler {
344 input_handler.replace_text_in_range(None, &event.keystroke.key);
345 }
346 }
347 }
348}
349
350impl PlatformWindow for X11Window {
351 fn bounds(&self) -> WindowBounds {
352 WindowBounds::Fixed(self.0.inner.lock().bounds.map(|v| GlobalPixels(v as f32)))
353 }
354
355 fn content_size(&self) -> Size<Pixels> {
356 self.0.inner.lock().content_size()
357 }
358
359 fn scale_factor(&self) -> f32 {
360 self.0.inner.lock().scale_factor
361 }
362
363 //todo!(linux)
364 fn titlebar_height(&self) -> Pixels {
365 unimplemented!()
366 }
367
368 //todo!(linux)
369 fn appearance(&self) -> WindowAppearance {
370 WindowAppearance::Light
371 }
372
373 fn display(&self) -> Rc<dyn PlatformDisplay> {
374 Rc::clone(&self.0.display)
375 }
376
377 //todo!(linux)
378 fn mouse_position(&self) -> Point<Pixels> {
379 Point::default()
380 }
381
382 //todo!(linux)
383 fn modifiers(&self) -> crate::Modifiers {
384 crate::Modifiers::default()
385 }
386
387 fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
388 self
389 }
390
391 fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {
392 self.0.inner.lock().input_handler = Some(input_handler);
393 }
394
395 fn take_input_handler(&mut self) -> Option<PlatformInputHandler> {
396 self.0.inner.lock().input_handler.take()
397 }
398
399 //todo!(linux)
400 fn prompt(
401 &self,
402 _level: crate::PromptLevel,
403 _msg: &str,
404 _detail: Option<&str>,
405 _answers: &[&str],
406 ) -> futures::channel::oneshot::Receiver<usize> {
407 unimplemented!()
408 }
409
410 fn activate(&self) {
411 self.0.xcb_connection.send_request(&x::ConfigureWindow {
412 window: self.0.x_window,
413 value_list: &[x::ConfigWindow::StackMode(x::StackMode::Above)],
414 });
415 }
416
417 fn set_title(&mut self, title: &str) {
418 self.0.xcb_connection.send_request(&x::ChangeProperty {
419 mode: x::PropMode::Replace,
420 window: self.0.x_window,
421 property: x::ATOM_WM_NAME,
422 r#type: x::ATOM_STRING,
423 data: title.as_bytes(),
424 });
425 }
426
427 //todo!(linux)
428 fn set_edited(&mut self, edited: bool) {}
429
430 //todo!(linux), this corresponds to `orderFrontCharacterPalette` on macOS,
431 // but it looks like the equivalent for Linux is GTK specific:
432 //
433 // https://docs.gtk.org/gtk3/signal.Entry.insert-emoji.html
434 //
435 // This API might need to change, or we might need to build an emoji picker into GPUI
436 fn show_character_palette(&self) {
437 unimplemented!()
438 }
439
440 //todo!(linux)
441 fn minimize(&self) {
442 unimplemented!()
443 }
444
445 //todo!(linux)
446 fn zoom(&self) {
447 unimplemented!()
448 }
449
450 //todo!(linux)
451 fn toggle_full_screen(&self) {
452 unimplemented!()
453 }
454
455 fn on_request_frame(&self, callback: Box<dyn FnMut()>) {
456 self.0.callbacks.lock().request_frame = Some(callback);
457 }
458
459 fn on_input(&self, callback: Box<dyn FnMut(crate::PlatformInput) -> bool>) {
460 self.0.callbacks.lock().input = Some(callback);
461 }
462
463 fn on_active_status_change(&self, callback: Box<dyn FnMut(bool)>) {
464 self.0.callbacks.lock().active_status_change = Some(callback);
465 }
466
467 fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>) {
468 self.0.callbacks.lock().resize = Some(callback);
469 }
470
471 fn on_fullscreen(&self, callback: Box<dyn FnMut(bool)>) {
472 self.0.callbacks.lock().fullscreen = Some(callback);
473 }
474
475 fn on_moved(&self, callback: Box<dyn FnMut()>) {
476 self.0.callbacks.lock().moved = Some(callback);
477 }
478
479 fn on_should_close(&self, callback: Box<dyn FnMut() -> bool>) {
480 self.0.callbacks.lock().should_close = Some(callback);
481 }
482
483 fn on_close(&self, callback: Box<dyn FnOnce()>) {
484 self.0.callbacks.lock().close = Some(callback);
485 }
486
487 fn on_appearance_changed(&self, callback: Box<dyn FnMut()>) {
488 self.0.callbacks.lock().appearance_changed = Some(callback);
489 }
490
491 //todo!(linux)
492 fn is_topmost_for_position(&self, _position: crate::Point<Pixels>) -> bool {
493 unimplemented!()
494 }
495
496 fn draw(&self, scene: &crate::Scene) {
497 let mut inner = self.0.inner.lock();
498 inner.renderer.draw(scene);
499 }
500
501 fn sprite_atlas(&self) -> sync::Arc<dyn crate::PlatformAtlas> {
502 let inner = self.0.inner.lock();
503 inner.renderer.sprite_atlas().clone()
504 }
505
506 fn set_graphics_profiler_enabled(&self, enabled: bool) {
507 unimplemented!("linux")
508 }
509}