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 { 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, previous_pointer: RefCell<&'static str>, position: RefCell, } impl Window { pub fn new(target: &EventLoopWindowTarget, attr: WindowAttributes, _: PlatformSpecificWindowBuilderAttributes) -> Result { 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 { let bounds = self.canvas.get_bounding_client_rect(); Ok(LogicalPosition { x: bounds.get_x(), y: bounds.get_y(), }) } pub fn inner_position(&self) -> Result { 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) { // Intentionally a no-op: users can't resize canvas elements } #[inline] pub fn set_max_inner_size(&self, _dimensions: Option) { // 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 { // TODO: should there be a maximization / fullscreen API? None } #[inline] pub fn set_fullscreen(&self, _monitor: Option) { // 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) { // 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 { 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() } }