mirror of
https://github.com/storytold/winit.git
synced 2026-11-22 04:10:45 +01:00
326 lines
9.7 KiB
Rust
326 lines
9.7 KiB
Rust
use dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize};
|
|
use error::{ExternalError, NotSupportedError, OsError as RootOE};
|
|
use event::{Event, WindowEvent};
|
|
use icon::Icon;
|
|
use platform::stdweb::WindowExtStdweb;
|
|
use monitor::{MonitorHandle as RootMH};
|
|
use window::{CursorIcon, Window as RootWindow, WindowAttributes, WindowId as RootWI};
|
|
use super::{EventLoopWindowTarget, OsError, register};
|
|
use std::collections::VecDeque;
|
|
use std::collections::vec_deque::IntoIter as VecDequeIter;
|
|
use std::cell::RefCell;
|
|
use stdweb::{
|
|
traits::*,
|
|
unstable::TryInto
|
|
};
|
|
use stdweb::web::{
|
|
document, window,
|
|
html_element::CanvasElement,
|
|
};
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct MonitorHandle;
|
|
|
|
impl MonitorHandle {
|
|
pub fn hidpi_factor(&self) -> f64 {
|
|
1.0
|
|
}
|
|
|
|
pub fn position(&self) -> PhysicalPosition {
|
|
unimplemented!();
|
|
}
|
|
|
|
pub fn dimensions(&self) -> PhysicalSize {
|
|
unimplemented!();
|
|
}
|
|
|
|
pub fn name(&self) -> Option<String> {
|
|
unimplemented!();
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct WindowId;
|
|
|
|
#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct PlatformSpecificWindowBuilderAttributes;
|
|
|
|
impl WindowId {
|
|
pub unsafe fn dummy() -> WindowId {
|
|
WindowId
|
|
}
|
|
}
|
|
|
|
pub struct Window {
|
|
pub(crate) canvas: CanvasElement,
|
|
pub(crate) redraw: Box<dyn Fn()>,
|
|
previous_pointer: RefCell<&'static str>,
|
|
position: RefCell<LogicalPosition>,
|
|
}
|
|
|
|
impl Window {
|
|
pub fn new<T>(target: &EventLoopWindowTarget<T>, attr: WindowAttributes,
|
|
_: PlatformSpecificWindowBuilderAttributes) -> Result<Self, RootOE> {
|
|
let element = document()
|
|
.create_element("canvas")
|
|
.map_err(|_| os_error!(OsError("Failed to create canvas element".to_owned())))?;
|
|
let canvas: CanvasElement = element.try_into()
|
|
.map_err(|_| os_error!(OsError("Failed to create canvas element".to_owned())))?;
|
|
document().body()
|
|
.ok_or_else(|| os_error!(OsError("Failed to find body node".to_owned())))?
|
|
.append_child(&canvas);
|
|
|
|
register(&target.runner, &canvas);
|
|
|
|
let runner = target.runner.clone();
|
|
let redraw = Box::new(move || {
|
|
let runner = runner.clone();
|
|
window().request_animation_frame(move |_| runner.send_event(Event::WindowEvent {
|
|
window_id: RootWI(WindowId),
|
|
event: WindowEvent::RedrawRequested
|
|
}));
|
|
});
|
|
|
|
let window = Window {
|
|
canvas,
|
|
redraw,
|
|
previous_pointer: RefCell::new("auto"),
|
|
position: RefCell::new(LogicalPosition {
|
|
x: 0.0,
|
|
y: 0.0
|
|
})
|
|
};
|
|
|
|
if let Some(inner_size) = attr.inner_size {
|
|
window.set_inner_size(inner_size);
|
|
} else {
|
|
window.set_inner_size(LogicalSize {
|
|
width: 1024.0,
|
|
height: 768.0,
|
|
})
|
|
}
|
|
window.set_min_inner_size(attr.min_inner_size);
|
|
window.set_max_inner_size(attr.max_inner_size);
|
|
window.set_resizable(attr.resizable);
|
|
window.set_title(&attr.title);
|
|
window.set_maximized(attr.maximized);
|
|
window.set_visible(attr.visible);
|
|
//window.set_transparent(attr.transparent);
|
|
window.set_decorations(attr.decorations);
|
|
window.set_always_on_top(attr.always_on_top);
|
|
window.set_window_icon(attr.window_icon);
|
|
|
|
Ok(window)
|
|
}
|
|
|
|
pub fn set_title(&self, title: &str) {
|
|
document().set_title(title);
|
|
}
|
|
|
|
pub fn set_visible(&self, _visible: bool) {
|
|
// Intentionally a no-op
|
|
}
|
|
|
|
pub fn request_redraw(&self) {
|
|
(self.redraw)();
|
|
}
|
|
|
|
pub fn outer_position(&self) -> Result<LogicalPosition, NotSupportedError> {
|
|
let bounds = self.canvas.get_bounding_client_rect();
|
|
Ok(LogicalPosition {
|
|
x: bounds.get_x(),
|
|
y: bounds.get_y(),
|
|
})
|
|
}
|
|
|
|
pub fn inner_position(&self) -> Result<LogicalPosition, NotSupportedError> {
|
|
Ok(*self.position.borrow())
|
|
}
|
|
|
|
pub fn set_outer_position(&self, position: LogicalPosition) {
|
|
*self.position.borrow_mut() = position;
|
|
self.canvas.set_attribute("position", "fixed")
|
|
.expect("Setting the position for the canvas");
|
|
self.canvas.set_attribute("left", &position.x.to_string())
|
|
.expect("Setting the position for the canvas");
|
|
self.canvas.set_attribute("top", &position.y.to_string())
|
|
.expect("Setting the position for the canvas");
|
|
}
|
|
|
|
#[inline]
|
|
pub fn inner_size(&self) -> LogicalSize {
|
|
LogicalSize {
|
|
width: self.canvas.width() as f64,
|
|
height: self.canvas.height() as f64
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn outer_size(&self) -> LogicalSize {
|
|
LogicalSize {
|
|
width: self.canvas.width() as f64,
|
|
height: self.canvas.height() as f64
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_inner_size(&self, size: LogicalSize) {
|
|
self.canvas.set_width(size.width as u32);
|
|
self.canvas.set_height(size.height as u32);
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_min_inner_size(&self, _dimensions: Option<LogicalSize>) {
|
|
// Intentionally a no-op: users can't resize canvas elements
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_max_inner_size(&self, _dimensions: Option<LogicalSize>) {
|
|
// Intentionally a no-op: users can't resize canvas elements
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_resizable(&self, _resizable: bool) {
|
|
// Intentionally a no-op: users can't resize canvas elements
|
|
}
|
|
|
|
#[inline]
|
|
pub fn hidpi_factor(&self) -> f64 {
|
|
1.0
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_cursor_icon(&self, cursor: CursorIcon) {
|
|
let text = match cursor {
|
|
CursorIcon::Default => "auto",
|
|
CursorIcon::Crosshair => "crosshair",
|
|
CursorIcon::Hand => "pointer",
|
|
CursorIcon::Arrow => "default",
|
|
CursorIcon::Move => "move",
|
|
CursorIcon::Text => "text",
|
|
CursorIcon::Wait => "wait",
|
|
CursorIcon::Help => "help",
|
|
CursorIcon::Progress => "progress",
|
|
|
|
CursorIcon::NotAllowed => "not-allowed",
|
|
CursorIcon::ContextMenu => "context-menu",
|
|
CursorIcon::Cell => "cell",
|
|
CursorIcon::VerticalText => "vertical-text",
|
|
CursorIcon::Alias => "alias",
|
|
CursorIcon::Copy => "copy",
|
|
CursorIcon::NoDrop => "no-drop",
|
|
CursorIcon::Grab => "grab",
|
|
CursorIcon::Grabbing => "grabbing",
|
|
CursorIcon::AllScroll => "all-scroll",
|
|
CursorIcon::ZoomIn => "zoom-in",
|
|
CursorIcon::ZoomOut => "zoom-out",
|
|
|
|
CursorIcon::EResize => "e-resize",
|
|
CursorIcon::NResize => "n-resize",
|
|
CursorIcon::NeResize => "ne-resize",
|
|
CursorIcon::NwResize => "nw-resize",
|
|
CursorIcon::SResize => "s-resize",
|
|
CursorIcon::SeResize => "se-resize",
|
|
CursorIcon::SwResize => "sw-resize",
|
|
CursorIcon::WResize => "w-resize",
|
|
CursorIcon::EwResize => "ew-resize",
|
|
CursorIcon::NsResize => "ns-resize",
|
|
CursorIcon::NeswResize => "nesw-resize",
|
|
CursorIcon::NwseResize => "nwse-resize",
|
|
CursorIcon::ColResize => "col-resize",
|
|
CursorIcon::RowResize => "row-resize",
|
|
};
|
|
*self.previous_pointer.borrow_mut() = text;
|
|
self.canvas.set_attribute("cursor", text)
|
|
.expect("Setting the cursor on the canvas");
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_cursor_position(&self, _position: LogicalPosition) -> Result<(), ExternalError> {
|
|
// TODO: pointer capture
|
|
Ok(())
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_cursor_grab(&self, _grab: bool) -> Result<(), ExternalError> {
|
|
// TODO: pointer capture
|
|
Ok(())
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_cursor_visible(&self, visible: bool) {
|
|
if !visible {
|
|
self.canvas.set_attribute("cursor", "none")
|
|
.expect("Setting the cursor on the canvas");
|
|
} else {
|
|
self.canvas.set_attribute("cursor", *self.previous_pointer.borrow())
|
|
.expect("Setting the cursor on the canvas");
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_maximized(&self, _maximized: bool) {
|
|
// TODO: should there be a maximization / fullscreen API?
|
|
}
|
|
|
|
#[inline]
|
|
pub fn fullscreen(&self) -> Option<RootMH> {
|
|
// TODO: should there be a maximization / fullscreen API?
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_fullscreen(&self, _monitor: Option<RootMH>) {
|
|
// TODO: should there be a maximization / fullscreen API?
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_decorations(&self, _decorations: bool) {
|
|
// Intentionally a no-op, no canvas decorations
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_always_on_top(&self, _always_on_top: bool) {
|
|
// Intentionally a no-op, no window ordering
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_window_icon(&self, _window_icon: Option<Icon>) {
|
|
// Currently an intentional no-op
|
|
}
|
|
|
|
#[inline]
|
|
pub fn set_ime_position(&self, _position: LogicalPosition) {
|
|
// TODO: what is this?
|
|
}
|
|
|
|
#[inline]
|
|
pub fn current_monitor(&self) -> RootMH {
|
|
RootMH {
|
|
inner: MonitorHandle
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn available_monitors(&self) -> VecDequeIter<MonitorHandle> {
|
|
VecDeque::new().into_iter()
|
|
}
|
|
|
|
#[inline]
|
|
pub fn primary_monitor(&self) -> MonitorHandle {
|
|
MonitorHandle
|
|
}
|
|
|
|
#[inline]
|
|
pub fn id(&self) -> WindowId {
|
|
// TODO ?
|
|
unsafe { WindowId::dummy() }
|
|
}
|
|
}
|
|
|
|
impl WindowExtStdweb for RootWindow {
|
|
fn canvas(&self) -> CanvasElement {
|
|
self.window.canvas.clone()
|
|
}
|
|
}
|