305 lines
8.6 KiB
Rust
305 lines
8.6 KiB
Rust
#![allow(unused)]
|
|
|
|
use crate::{
|
|
Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DisplayId,
|
|
ForegroundExecutor, Keymap, LinuxDispatcher, LinuxDisplay, LinuxTextSystem, LinuxWindow,
|
|
LinuxWindowState, LinuxWindowStatePtr, Menu, PathPromptOptions, Platform, PlatformDisplay,
|
|
PlatformInput, PlatformTextSystem, PlatformWindow, Result, SemanticVersion, Task,
|
|
WindowOptions,
|
|
};
|
|
|
|
use collections::{HashMap, HashSet};
|
|
use futures::channel::oneshot;
|
|
use parking_lot::Mutex;
|
|
|
|
use std::{
|
|
path::{Path, PathBuf},
|
|
rc::Rc,
|
|
sync::Arc,
|
|
time::Duration,
|
|
};
|
|
use time::UtcOffset;
|
|
use xcb::{x, Xid as _};
|
|
|
|
xcb::atoms_struct! {
|
|
#[derive(Debug)]
|
|
pub(crate) struct XcbAtoms {
|
|
pub wm_protocols => b"WM_PROTOCOLS",
|
|
pub wm_del_window => b"WM_DELETE_WINDOW",
|
|
wm_state => b"_NET_WM_STATE",
|
|
wm_state_maxv => b"_NET_WM_STATE_MAXIMIZED_VERT",
|
|
wm_state_maxh => b"_NET_WM_STATE_MAXIMIZED_HORZ",
|
|
}
|
|
}
|
|
|
|
pub(crate) struct LinuxPlatform(Mutex<LinuxPlatformState>);
|
|
|
|
pub(crate) struct LinuxPlatformState {
|
|
xcb_connection: xcb::Connection,
|
|
x_root_index: i32,
|
|
atoms: XcbAtoms,
|
|
background_executor: BackgroundExecutor,
|
|
foreground_executor: ForegroundExecutor,
|
|
windows: HashMap<x::Window, LinuxWindowStatePtr>,
|
|
text_system: Arc<LinuxTextSystem>,
|
|
}
|
|
|
|
impl Default for LinuxPlatform {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl LinuxPlatform {
|
|
pub(crate) fn new() -> Self {
|
|
let (xcb_connection, x_root_index) = xcb::Connection::connect(None).unwrap();
|
|
let atoms = XcbAtoms::intern_all(&xcb_connection).unwrap();
|
|
|
|
let dispatcher = Arc::new(LinuxDispatcher::new());
|
|
|
|
Self(Mutex::new(LinuxPlatformState {
|
|
xcb_connection,
|
|
x_root_index,
|
|
atoms,
|
|
background_executor: BackgroundExecutor::new(dispatcher.clone()),
|
|
foreground_executor: ForegroundExecutor::new(dispatcher),
|
|
windows: HashMap::default(),
|
|
text_system: Arc::new(LinuxTextSystem::new()),
|
|
}))
|
|
}
|
|
}
|
|
|
|
impl Platform for LinuxPlatform {
|
|
fn background_executor(&self) -> BackgroundExecutor {
|
|
self.0.lock().background_executor.clone()
|
|
}
|
|
|
|
fn foreground_executor(&self) -> crate::ForegroundExecutor {
|
|
self.0.lock().foreground_executor.clone()
|
|
}
|
|
|
|
fn text_system(&self) -> Arc<dyn PlatformTextSystem> {
|
|
self.0.lock().text_system.clone()
|
|
}
|
|
|
|
fn run(&self, on_finish_launching: Box<dyn FnOnce()>) {
|
|
on_finish_launching();
|
|
|
|
while !self.0.lock().windows.is_empty() {
|
|
let event = self.0.lock().xcb_connection.wait_for_event().unwrap();
|
|
let mut repaint_x_window = None;
|
|
match event {
|
|
xcb::Event::X(x::Event::ClientMessage(ev)) => {
|
|
if let x::ClientMessageData::Data32([atom, ..]) = ev.data() {
|
|
let mut this = self.0.lock();
|
|
if atom == this.atoms.wm_del_window.resource_id() {
|
|
// window "x" button clicked by user, we gracefully exit
|
|
{
|
|
let mut window = this.windows[&ev.window()].lock();
|
|
window.destroy();
|
|
}
|
|
this.xcb_connection.send_request(&x::UnmapWindow {
|
|
window: ev.window(),
|
|
});
|
|
this.xcb_connection.send_request(&x::DestroyWindow {
|
|
window: ev.window(),
|
|
});
|
|
this.windows.remove(&ev.window());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
xcb::Event::X(x::Event::Expose(ev)) => {
|
|
repaint_x_window = Some(ev.window());
|
|
}
|
|
xcb::Event::X(x::Event::ResizeRequest(ev)) => {
|
|
let this = self.0.lock();
|
|
LinuxWindowState::resize(&this.windows[&ev.window()], ev.width(), ev.height());
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
if let Some(x_window) = repaint_x_window {
|
|
let this = self.0.lock();
|
|
LinuxWindowState::request_frame(&this.windows[&x_window]);
|
|
this.xcb_connection.flush();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn quit(&self) {}
|
|
|
|
fn restart(&self) {}
|
|
|
|
fn activate(&self, ignoring_other_apps: bool) {}
|
|
|
|
fn hide(&self) {}
|
|
|
|
fn hide_other_apps(&self) {}
|
|
|
|
fn unhide_other_apps(&self) {}
|
|
|
|
fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>> {
|
|
let this = self.0.lock();
|
|
let setup = this.xcb_connection.get_setup();
|
|
setup
|
|
.roots()
|
|
.enumerate()
|
|
.map(|(root_id, _)| {
|
|
Rc::new(LinuxDisplay::new(&this.xcb_connection, root_id as i32))
|
|
as Rc<dyn PlatformDisplay>
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn display(&self, id: DisplayId) -> Option<Rc<dyn PlatformDisplay>> {
|
|
let this = self.0.lock();
|
|
Some(Rc::new(LinuxDisplay::new(
|
|
&this.xcb_connection,
|
|
id.0 as i32,
|
|
)))
|
|
}
|
|
|
|
fn active_window(&self) -> Option<AnyWindowHandle> {
|
|
None
|
|
}
|
|
|
|
fn open_window(
|
|
&self,
|
|
handle: AnyWindowHandle,
|
|
options: WindowOptions,
|
|
) -> Box<dyn PlatformWindow> {
|
|
let mut this = self.0.lock();
|
|
let x_window = this.xcb_connection.generate_id();
|
|
|
|
let window_ptr = LinuxWindowState::new_ptr(
|
|
options,
|
|
handle,
|
|
&this.xcb_connection,
|
|
this.x_root_index,
|
|
x_window,
|
|
&this.atoms,
|
|
);
|
|
this.windows.insert(x_window, window_ptr.clone());
|
|
Box::new(LinuxWindow(window_ptr))
|
|
}
|
|
|
|
fn set_display_link_output_callback(
|
|
&self,
|
|
display_id: DisplayId,
|
|
callback: Box<dyn FnMut() + Send>,
|
|
) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn start_display_link(&self, display_id: DisplayId) {}
|
|
|
|
fn stop_display_link(&self, display_id: DisplayId) {}
|
|
|
|
fn open_url(&self, url: &str) {}
|
|
|
|
fn on_open_urls(&self, callback: Box<dyn FnMut(Vec<String>)>) {}
|
|
|
|
fn prompt_for_paths(
|
|
&self,
|
|
options: PathPromptOptions,
|
|
) -> oneshot::Receiver<Option<Vec<PathBuf>>> {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn prompt_for_new_path(&self, directory: &Path) -> oneshot::Receiver<Option<PathBuf>> {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn reveal_path(&self, path: &Path) {}
|
|
|
|
fn on_become_active(&self, callback: Box<dyn FnMut()>) {}
|
|
|
|
fn on_resign_active(&self, callback: Box<dyn FnMut()>) {}
|
|
|
|
fn on_quit(&self, callback: Box<dyn FnMut()>) {}
|
|
|
|
fn on_reopen(&self, callback: Box<dyn FnMut()>) {}
|
|
|
|
fn on_event(&self, callback: Box<dyn FnMut(PlatformInput) -> bool>) {}
|
|
|
|
fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>) {}
|
|
|
|
fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>) {}
|
|
|
|
fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>) {}
|
|
|
|
fn os_name(&self) -> &'static str {
|
|
"Linux"
|
|
}
|
|
|
|
fn double_click_interval(&self) -> Duration {
|
|
Duration::default()
|
|
}
|
|
|
|
fn os_version(&self) -> Result<SemanticVersion> {
|
|
Ok(SemanticVersion {
|
|
major: 1,
|
|
minor: 0,
|
|
patch: 0,
|
|
})
|
|
}
|
|
|
|
fn app_version(&self) -> Result<SemanticVersion> {
|
|
Ok(SemanticVersion {
|
|
major: 1,
|
|
minor: 0,
|
|
patch: 0,
|
|
})
|
|
}
|
|
|
|
fn app_path(&self) -> Result<PathBuf> {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn set_menus(&self, menus: Vec<Menu>, keymap: &Keymap) {}
|
|
|
|
fn local_timezone(&self) -> UtcOffset {
|
|
UtcOffset::UTC
|
|
}
|
|
|
|
fn path_for_auxiliary_executable(&self, name: &str) -> Result<PathBuf> {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn set_cursor_style(&self, style: CursorStyle) {}
|
|
|
|
fn should_auto_hide_scrollbars(&self) -> bool {
|
|
false
|
|
}
|
|
|
|
fn write_to_clipboard(&self, item: ClipboardItem) {}
|
|
|
|
fn read_from_clipboard(&self) -> Option<ClipboardItem> {
|
|
None
|
|
}
|
|
|
|
fn write_credentials(&self, url: &str, username: &str, password: &[u8]) -> Task<Result<()>> {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn read_credentials(&self, url: &str) -> Task<Result<Option<(String, Vec<u8>)>>> {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn delete_credentials(&self, url: &str) -> Task<Result<()>> {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::ClipboardItem;
|
|
|
|
use super::*;
|
|
|
|
fn build_platform() -> LinuxPlatform {
|
|
let platform = LinuxPlatform::new();
|
|
platform
|
|
}
|
|
}
|