Implement move_to and resize commands for window

glutin/src/application.rs

@@ -96,6 +96,7 @@ where
         &mut runtime,
         &mut clipboard,
         &mut proxy,
+        context.window(),
     );
     runtime.track(subscription);
 
@@ -225,6 +226,7 @@ async fn run_instance<A, E, C>(
                         &mut proxy,
                         &mut debug,
                         &mut messages,
+                        context.window(),
                     );
 
                     // Update window

glutin/src/lib.rs

@@ -18,6 +18,7 @@ pub mod application;
 
 pub use iced_winit::clipboard;
 pub use iced_winit::settings;
+pub use iced_winit::window;
 pub use iced_winit::{Error, Mode};
 
 #[doc(no_inline)]

src/window.rs

@@ -9,3 +9,6 @@ pub use icon::Icon;
 pub use mode::Mode;
 pub use position::Position;
 pub use settings::Settings;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use crate::runtime::window::{move_to, resize};

winit/src/application.rs

@@ -159,7 +159,13 @@ where
 
     let mut clipboard = Clipboard::connect(&window);
 
-    run_command(init_command, &mut runtime, &mut clipboard, &mut proxy);
+    run_command(
+        init_command,
+        &mut runtime,
+        &mut clipboard,
+        &mut proxy,
+        &window,
+    );
     runtime.track(subscription);
 
     let (compositor, renderer) = C::new(compositor_settings, Some(&window))?;
@@ -300,6 +306,7 @@ async fn run_instance<A, E, C>(
                         &mut proxy,
                         &mut debug,
                         &mut messages,
+                        &window,
                     );
 
                     // Update window
@@ -503,6 +510,7 @@ pub fn update<A: Application, E: Executor>(
     proxy: &mut winit::event_loop::EventLoopProxy<A::Message>,
     debug: &mut Debug,
     messages: &mut Vec<A::Message>,
+    window: &winit::window::Window,
 ) {
     for message in messages.drain(..) {
         debug.log_message(&message);
@@ -511,7 +519,7 @@ pub fn update<A: Application, E: Executor>(
         let command = runtime.enter(|| application.update(message));
         debug.update_finished();
 
-        run_command(command, runtime, clipboard, proxy);
+        run_command(command, runtime, clipboard, proxy, window);
     }
 
     let subscription = application.subscription();
@@ -524,8 +532,10 @@ pub fn run_command<Message: 'static + std::fmt::Debug + Send, E: Executor>(
     runtime: &mut Runtime<E, Proxy<Message>, Message>,
     clipboard: &mut Clipboard,
     proxy: &mut winit::event_loop::EventLoopProxy<Message>,
+    window: &winit::window::Window,
 ) {
     use iced_native::command;
+    use iced_native::window;
 
     for action in command.actions() {
         match action {
@@ -544,7 +554,20 @@ pub fn run_command<Message: 'static + std::fmt::Debug + Send, E: Executor>(
                     clipboard.write(contents);
                 }
             },
-            command::Action::Window(_action) => unimplemented! {},
+            command::Action::Window(action) => match action {
+                window::Action::Resize { width, height } => {
+                    window.set_inner_size(winit::dpi::LogicalSize {
+                        width,
+                        height,
+                    });
+                }
+                window::Action::Move { x, y } => {
+                    window.set_outer_position(winit::dpi::LogicalPosition {
+                        x,
+                        y,
+                    });
+                }
+            },
         }
     }
 }

winit/src/lib.rs

@@ -28,6 +28,7 @@ pub mod application;
 pub mod clipboard;
 pub mod conversion;
 pub mod settings;
+pub mod window;
 
 mod error;
 mod mode;

winit/src/window.rs

@@ -1,7 +1,18 @@
-pub use iced_native::window::*;
+//! Interact with the window of your application.
+use crate::command::{self, Command};
+use iced_native::window;
 
-/// The window of an [`Application`].
+pub use window::Event;
-///
+
-/// [`Application`]: crate::Application
+/// Resizes the window to the given logical dimensions.
-#[derive(Debug)]
+pub fn resize<Message>(width: u32, height: u32) -> Command<Message> {
-pub struct Window {}
+    Command::single(command::Action::Window(window::Action::Resize {
+        width,
+        height,
+    }))
+}
+
+/// Moves a window to the given logical coordinates.
+pub fn move_to<Message>(x: i32, y: i32) -> Command<Message> {
+    Command::single(command::Action::Window(window::Action::Move { x, y }))
+}