me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge remote-tracking branch 'origin/master' into feat/multi-window-support

Browse source 
# Conflicts:
#	Cargo.toml
#	core/src/window/icon.rs
#	core/src/window/id.rs
#	core/src/window/position.rs
#	core/src/window/settings.rs
#	examples/integration/src/main.rs
#	examples/integration_opengl/src/main.rs
#	glutin/src/application.rs
#	native/src/subscription.rs
#	native/src/window.rs
#	runtime/src/window/action.rs
#	src/lib.rs
#	src/window.rs
#	winit/Cargo.toml
#	winit/src/application.rs
#	winit/src/icon.rs
#	winit/src/settings.rs
#	winit/src/window.rs
This commit is contained in:
Bingus 2023-07-12 12:23:18 -07:00
commit 633f405f3f
No known key found for this signature in database
GPG key ID: 5F84D2AA40A9F170
394 changed files with 17278 additions and 13290 deletions
Download patch file Download diff file Expand all files Collapse all files

206
winit/src/application.rs
View file

@ -3,25 +3,25 @@ mod state;
pub use state::State;
use crate::clipboard::{self, Clipboard};
use crate::conversion;
use crate::mouse;
use crate::renderer;
use crate::widget::operation;
use crate::{
Command, Debug, Error, Event, Executor, Proxy, Runtime, Settings, Size,
Subscription,
};
use crate::core;
use crate::core::mouse;
use crate::core::renderer;
use crate::core::time::Instant;
use crate::core::widget::operation;
use crate::core::window;
use crate::core::{Event, Size};
use crate::futures::futures;
use crate::futures::{Executor, Runtime, Subscription};
use crate::graphics::compositor::{self, Compositor};
use crate::runtime::clipboard;
use crate::runtime::program::Program;
use crate::runtime::user_interface::{self, UserInterface};
use crate::runtime::{Command, Debug};
use crate::style::application::{Appearance, StyleSheet};
use crate::{Clipboard, Error, Proxy, Settings};
use iced_futures::futures;
use iced_futures::futures::channel::mpsc;
use iced_graphics::compositor;
use iced_graphics::window;
use iced_native::program::Program;
use iced_native::time::Instant;
use iced_native::user_interface::{self, UserInterface};
pub use iced_native::application::{Appearance, StyleSheet};
use futures::channel::mpsc;
use std::mem::ManuallyDrop;
@ -43,7 +43,7 @@ use tracing::{info_span, instrument::Instrument};
/// can be toggled by pressing `F12`.
pub trait Application: Program
where
<Self::Renderer as crate::Renderer>::Theme: StyleSheet,
<Self::Renderer as core::Renderer>::Theme: StyleSheet,
{
/// The data needed to initialize your [`Application`].
type Flags;
@ -65,12 +65,12 @@ where
fn title(&self) -> String;
/// Returns the current `Theme` of the [`Application`].
fn theme(&self) -> <Self::Renderer as crate::Renderer>::Theme;
fn theme(&self) -> <Self::Renderer as core::Renderer>::Theme;
/// Returns the `Style` variation of the `Theme`.
fn style(
&self,
) -> <<Self::Renderer as crate::Renderer>::Theme as StyleSheet>::Style {
) -> <<Self::Renderer as core::Renderer>::Theme as StyleSheet>::Style {
Default::default()
}
@ -110,8 +110,8 @@ pub fn run<A, E, C>(
where
A: Application + 'static,
E: Executor + 'static,
C: window::Compositor<Renderer = A::Renderer> + 'static,
<A::Renderer as crate::Renderer>::Theme: StyleSheet,
C: Compositor<Renderer = A::Renderer> + 'static,
<A::Renderer as core::Renderer>::Theme: StyleSheet,
{
use futures::task;
use futures::Future;
@ -177,13 +177,17 @@ where
.unwrap_or(None)
});
let _ = match target {
Some(node) => node
.replace_child(&canvas, &node)
.expect(&format!("Could not replace #{}", node.id())),
None => body
.append_child(&canvas)
.expect("Append canvas to HTML body"),
match target {
Some(node) => {
let _ = node
.replace_with_with_node_1(&canvas)
.expect(&format!("Could not replace #{}", node.id()));
}
None => {
let _ = body
.append_child(&canvas)
.expect("Append canvas to HTML body");
}
};
}
@ -276,28 +280,25 @@ async fn run_instance<A, E, C>(
) where
A: Application + 'static,
E: Executor + 'static,
C: window::Compositor<Renderer = A::Renderer> + 'static,
<A::Renderer as crate::Renderer>::Theme: StyleSheet,
C: Compositor<Renderer = A::Renderer> + 'static,
<A::Renderer as core::Renderer>::Theme: StyleSheet,
{
use iced_futures::futures::stream::StreamExt;
use futures::stream::StreamExt;
use winit::event;
use winit::event_loop::ControlFlow;
let mut clipboard = Clipboard::connect(&window);
let mut cache = user_interface::Cache::default();
let mut surface = compositor.create_surface(&window);
let mut should_exit = false;
let mut state = State::new(&application, &window);
let mut viewport_version = state.viewport_version();
let physical_size = state.physical_size();
compositor.configure_surface(
&mut surface,
let mut clipboard = Clipboard::connect(&window);
let mut cache = user_interface::Cache::default();
let mut surface = compositor.create_surface(
&window,
physical_size.width,
physical_size.height,
);
let mut should_exit = false;
if should_be_visible {
window.set_visible(true);
@ -305,6 +306,8 @@ async fn run_instance<A, E, C>(
run_command(
&application,
&mut compositor,
&mut surface,
&mut cache,
&state,
&mut renderer,
@ -315,9 +318,8 @@ async fn run_instance<A, E, C>(
&mut proxy,
&mut debug,
&window,
|| compositor.fetch_information(),
);
runtime.track(application.subscription());
runtime.track(application.subscription().into_recipes());
let mut user_interface = ManuallyDrop::new(build_user_interface(
&application,
@ -353,7 +355,7 @@ async fn run_instance<A, E, C>(
let (interface_state, statuses) = user_interface.update(
&events,
state.cursor_position(),
state.cursor(),
&mut renderer,
&mut clipboard,
&mut messages,
@ -361,8 +363,10 @@ async fn run_instance<A, E, C>(
debug.event_processing_finished();
for event in events.drain(..).zip(statuses.into_iter()) {
runtime.broadcast(event);
for (event, status) in
events.drain(..).zip(statuses.into_iter())
{
runtime.broadcast(event, status);
}
if !messages.is_empty()
@ -377,6 +381,8 @@ async fn run_instance<A, E, C>(
// Update application
update(
&mut application,
&mut compositor,
&mut surface,
&mut cache,
&state,
&mut renderer,
@ -387,7 +393,6 @@ async fn run_instance<A, E, C>(
&mut debug,
&mut messages,
&window,
|| compositor.fetch_information(),
);
// Update window
@ -412,13 +417,13 @@ async fn run_instance<A, E, C>(
// Then, we can use the `interface_state` here to decide if a redraw
// is needed right away, or simply wait until a specific time.
let redraw_event = Event::Window(
crate::window::Id::MAIN,
crate::window::Event::RedrawRequested(Instant::now()),
window::Id::MAIN,
window::Event::RedrawRequested(Instant::now()),
);
let (interface_state, _) = user_interface.update(
&[redraw_event.clone()],
state.cursor_position(),
state.cursor(),
&mut renderer,
&mut clipboard,
&mut messages,
@ -431,7 +436,7 @@ async fn run_instance<A, E, C>(
&renderer::Style {
text_color: state.text_color(),
},
state.cursor_position(),
state.cursor(),
);
debug.draw_finished();
@ -444,17 +449,14 @@ async fn run_instance<A, E, C>(
}
window.request_redraw();
runtime
.broadcast((redraw_event, crate::event::Status::Ignored));
runtime.broadcast(redraw_event, core::event::Status::Ignored);
let _ = control_sender.start_send(match interface_state {
user_interface::State::Updated {
redraw_request: Some(redraw_request),
} => match redraw_request {
crate::window::RedrawRequest::NextFrame => {
ControlFlow::Poll
}
crate::window::RedrawRequest::At(at) => {
window::RedrawRequest::NextFrame => ControlFlow::Poll,
window::RedrawRequest::At(at) => {
ControlFlow::WaitUntil(at)
}
},
@ -466,9 +468,9 @@ async fn run_instance<A, E, C>(
event::Event::PlatformSpecific(event::PlatformSpecific::MacOS(
event::MacOS::ReceivedUrl(url),
)) => {
use iced_native::event;
use crate::core::event;
events.push(iced_native::Event::PlatformSpecific(
events.push(Event::PlatformSpecific(
event::PlatformSpecific::MacOS(event::MacOS::ReceivedUrl(
url,
)),
@ -507,7 +509,7 @@ async fn run_instance<A, E, C>(
&renderer::Style {
text_color: state.text_color(),
},
state.cursor_position(),
state.cursor(),
);
if new_mouse_interaction != mouse_interaction {
@ -568,7 +570,7 @@ async fn run_instance<A, E, C>(
state.update(&window, &window_event, &mut debug);
if let Some(event) = conversion::window_event(
crate::window::Id::MAIN,
window::Id::MAIN,
&window_event,
state.scale_factor(),
state.modifiers(),
@ -618,7 +620,7 @@ pub fn build_user_interface<'a, A: Application>(
debug: &mut Debug,
) -> UserInterface<'a, A::Message, A::Renderer>
where
<A::Renderer as crate::Renderer>::Theme: StyleSheet,
<A::Renderer as core::Renderer>::Theme: StyleSheet,
{
#[cfg(feature = "trace")]
let view_span = info_span!("Application", "VIEW").entered();
@ -645,8 +647,10 @@ where
/// Updates an [`Application`] by feeding it the provided messages, spawning any
/// resulting [`Command`], and tracking its [`Subscription`].
pub fn update<A: Application, E: Executor>(
pub fn update<A: Application, C, E: Executor>(
application: &mut A,
compositor: &mut C,
surface: &mut C::Surface,
cache: &mut user_interface::Cache,
state: &State<A>,
renderer: &mut A::Renderer,
@ -657,9 +661,9 @@ pub fn update<A: Application, E: Executor>(
debug: &mut Debug,
messages: &mut Vec<A::Message>,
window: &winit::window::Window,
graphics_info: impl FnOnce() -> compositor::Information + Copy,
) where
<A::Renderer as crate::Renderer>::Theme: StyleSheet,
C: Compositor<Renderer = A::Renderer> + 'static,
<A::Renderer as core::Renderer>::Theme: StyleSheet,
{
for message in messages.drain(..) {
#[cfg(feature = "trace")]
@ -676,6 +680,8 @@ pub fn update<A: Application, E: Executor>(
run_command(
application,
compositor,
surface,
cache,
state,
renderer,
@ -686,17 +692,18 @@ pub fn update<A: Application, E: Executor>(
proxy,
debug,
window,
graphics_info,
);
}
let subscription = application.subscription();
runtime.track(subscription);
runtime.track(subscription.into_recipes());
}
/// Runs the actions of a [`Command`].
pub fn run_command<A, E>(
pub fn run_command<A, C, E>(
application: &A,
compositor: &mut C,
surface: &mut C::Surface,
cache: &mut user_interface::Cache,
state: &State<A>,
renderer: &mut A::Renderer,
@ -707,15 +714,15 @@ pub fn run_command<A, E>(
proxy: &mut winit::event_loop::EventLoopProxy<A::Message>,
debug: &mut Debug,
window: &winit::window::Window,
_graphics_info: impl FnOnce() -> compositor::Information + Copy,
) where
A: Application,
E: Executor,
<A::Renderer as crate::Renderer>::Theme: StyleSheet,
C: Compositor<Renderer = A::Renderer> + 'static,
<A::Renderer as core::Renderer>::Theme: StyleSheet,
{
use iced_native::command;
use iced_native::system;
use iced_native::window;
use crate::runtime::command;
use crate::runtime::system;
use crate::runtime::window;
for action in command.actions() {
match action {
@ -746,12 +753,22 @@ pub fn run_command<A, E>(
"Spawning a window is only available with `multi_window::Application`s."
)
}
window::Action::Resize { width, height } => {
window::Action::Resize(size) => {
window.set_inner_size(winit::dpi::LogicalSize {
width,
height,
width: size.width,
height: size.height,
});
}
window::Action::FetchSize(callback) => {
let size = window.inner_size();
proxy
.send_event(callback(Size::new(
size.width,
size.height,
)))
.expect("Send message to event loop")
}
window::Action::Maximize(maximized) => {
window.set_maximized(maximized);
}
@ -771,11 +788,14 @@ pub fn run_command<A, E>(
mode,
));
}
window::Action::ChangeIcon(icon) => {
window.set_window_icon(conversion::icon(icon))
}
window::Action::FetchMode(tag) => {
let mode = if window.is_visible().unwrap_or(true) {
conversion::mode(window.fullscreen())
} else {
window::Mode::Hidden
core::window::Mode::Hidden
};
proxy
@ -796,20 +816,36 @@ pub fn run_command<A, E>(
window::Action::GainFocus => {
window.focus_window();
}
window::Action::ChangeAlwaysOnTop(on_top) => {
window.set_always_on_top(on_top);
window::Action::ChangeLevel(level) => {
window.set_window_level(conversion::window_level(level));
}
window::Action::FetchId(tag) => {
proxy
.send_event(tag(window.id().into()))
.expect("Send message to event loop");
}
window::Action::Screenshot(tag) => {
let bytes = compositor.screenshot(
renderer,
surface,
state.viewport(),
state.background_color(),
&debug.overlay(),
);
proxy
.send_event(tag(window::Screenshot::new(
bytes,
state.physical_size(),
)))
.expect("Send message to event loop.")
}
},
command::Action::System(action) => match action {
system::Action::QueryInformation(_tag) => {
#[cfg(feature = "system")]
{
let graphics_info = _graphics_info();
let graphics_info = compositor.fetch_information();
let proxy = proxy.clone();
let _ = std::thread::spawn(move || {
@ -827,7 +863,7 @@ pub fn run_command<A, E>(
},
command::Action::Widget(action) => {
let mut current_cache = std::mem::take(cache);
let mut current_operation = Some(action.into_operation());
let mut current_operation = Some(action);
let mut user_interface = build_user_interface(
application,
@ -856,6 +892,16 @@ pub fn run_command<A, E>(
current_cache = user_interface.into_cache();
*cache = current_cache;
}
command::Action::LoadFont { bytes, tagger } => {
use crate::core::text::Renderer;
// TODO: Error handling (?)
renderer.load_font(bytes);
proxy
.send_event(tagger(Ok(())))
.expect("Send message to event loop");
}
}
}
}

41
winit/src/application/state.rs
View file

@ -1,6 +1,11 @@
use crate::application::{self, StyleSheet as _};
use crate::conversion;
use crate::{Application, Color, Debug, Point, Size, Viewport};
use crate::core;
use crate::core::mouse;
use crate::core::{Color, Size};
use crate::graphics::Viewport;
use crate::runtime::Debug;
use crate::Application;
use std::marker::PhantomData;
use winit::event::{Touch, WindowEvent};
@ -10,22 +15,22 @@ use winit::window::Window;
#[allow(missing_debug_implementations)]
pub struct State<A: Application>
where
<A::Renderer as crate::Renderer>::Theme: application::StyleSheet,
<A::Renderer as core::Renderer>::Theme: application::StyleSheet,
{
title: String,
scale_factor: f64,
viewport: Viewport,
viewport_version: usize,
cursor_position: winit::dpi::PhysicalPosition<f64>,
cursor_position: Option<winit::dpi::PhysicalPosition<f64>>,
modifiers: winit::event::ModifiersState,
theme: <A::Renderer as crate::Renderer>::Theme,
theme: <A::Renderer as core::Renderer>::Theme,
appearance: application::Appearance,
application: PhantomData<A>,
}
impl<A: Application> State<A>
where
<A::Renderer as crate::Renderer>::Theme: application::StyleSheet,
<A::Renderer as core::Renderer>::Theme: application::StyleSheet,
{
/// Creates a new [`State`] for the provided [`Application`] and window.
pub fn new(application: &A, window: &Window) -> Self {
@ -48,8 +53,7 @@ where
scale_factor,
viewport,
viewport_version: 0,
// TODO: Encode cursor availability in the type-system
cursor_position: winit::dpi::PhysicalPosition::new(-1.0, -1.0),
cursor_position: None,
modifiers: winit::event::ModifiersState::default(),
theme,
appearance,
@ -85,11 +89,16 @@ where
}
/// Returns the current cursor position of the [`State`].
pub fn cursor_position(&self) -> Point {
conversion::cursor_position(
self.cursor_position,
self.viewport.scale_factor(),
)
pub fn cursor(&self) -> mouse::Cursor {
self.cursor_position
.map(|cursor_position| {
conversion::cursor_position(
cursor_position,
self.viewport.scale_factor(),
)
})
.map(mouse::Cursor::Available)
.unwrap_or(mouse::Cursor::Unavailable)
}
/// Returns the current keyboard modifiers of the [`State`].
@ -98,7 +107,7 @@ where
}
/// Returns the current theme of the [`State`].
pub fn theme(&self) -> &<A::Renderer as crate::Renderer>::Theme {
pub fn theme(&self) -> &<A::Renderer as core::Renderer>::Theme {
&self.theme
}
@ -149,12 +158,10 @@ where
| WindowEvent::Touch(Touch {
location: position, ..
}) => {
self.cursor_position = *position;
self.cursor_position = Some(*position);
}
WindowEvent::CursorLeft { .. } => {
// TODO: Encode cursor availability in the type-system
self.cursor_position =
winit::dpi::PhysicalPosition::new(-1.0, -1.0);
self.cursor_position = None;
}
WindowEvent::ModifiersChanged(new_modifiers) => {
self.modifiers = *new_modifiers;

17
winit/src/clipboard.rs
View file

@ -1,7 +1,4 @@
//! Access the clipboard.
pub use iced_native::clipboard::Action;
use crate::command::{self, Command};
/// A buffer for short-term storage and transfer within and between
/// applications.
@ -56,7 +53,7 @@ impl Clipboard {
}
}
impl iced_native::Clipboard for Clipboard {
impl crate::core::Clipboard for Clipboard {
fn read(&self) -> Option<String> {
self.read()
}
@ -65,15 +62,3 @@ impl iced_native::Clipboard for Clipboard {
self.write(contents)
}
}
/// Read the current contents of the clipboard.
pub fn read<Message>(
f: impl Fn(Option<String>) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Clipboard(Action::Read(Box::new(f))))
}
/// Write the given contents to the clipboard.
pub fn write<Message>(contents: String) -> Command<Message> {
Command::single(command::Action::Clipboard(Action::Write(contents)))
}

50
winit/src/conversion.rs
View file

@ -1,12 +1,13 @@
//! Convert [`winit`] types into [`iced_native`] types, and viceversa.
//!
//! [`winit`]: https://github.com/rust-windowing/winit
//! [`iced_native`]: https://github.com/iced-rs/iced/tree/0.8/native
use crate::keyboard;
use crate::mouse;
use crate::touch;
use crate::window;
use crate::{Event, Point, Position};
//! [`iced_native`]: https://github.com/iced-rs/iced/tree/0.9/native
use crate::core::keyboard;
use crate::core::mouse;
use crate::core::touch;
use crate::core::window;
use crate::core::{Event, Point};
use crate::Position;
/// Converts a winit window event into an iced event.
pub fn window_event(
@ -149,6 +150,19 @@ pub fn window_event(
}
}
/// Converts a [`window::Level`] to a [`winit`] window level.
///
/// [`winit`]: https://github.com/rust-windowing/winit
pub fn window_level(level: window::Level) -> winit::window::WindowLevel {
match level {
window::Level::Normal => winit::window::WindowLevel::Normal,
window::Level::AlwaysOnBottom => {
winit::window::WindowLevel::AlwaysOnBottom
}
window::Level::AlwaysOnTop => winit::window::WindowLevel::AlwaysOnTop,
}
}
/// Converts a [`Position`] to a [`winit`] logical position for a given monitor.
///
/// [`winit`]: https://github.com/rust-windowing/winit
@ -228,7 +242,7 @@ pub fn mode(mode: Option<winit::window::Fullscreen>) -> window::Mode {
/// Converts a `MouseCursor` from [`iced_native`] to a [`winit`] cursor icon.
///
/// [`winit`]: https://github.com/rust-windowing/winit
/// [`iced_native`]: https://github.com/iced-rs/iced/tree/0.8/native
/// [`iced_native`]: https://github.com/iced-rs/iced/tree/0.9/native
pub fn mouse_interaction(
interaction: mouse::Interaction,
) -> winit::window::CursorIcon {
@ -246,21 +260,20 @@ pub fn mouse_interaction(
winit::window::CursorIcon::EwResize
}
Interaction::ResizingVertically => winit::window::CursorIcon::NsResize,
Interaction::NotAllowed => winit::window::CursorIcon::NotAllowed,
}
}
/// Converts a `MouseButton` from [`winit`] to an [`iced_native`] mouse button.
///
/// [`winit`]: https://github.com/rust-windowing/winit
/// [`iced_native`]: https://github.com/iced-rs/iced/tree/0.8/native
/// [`iced_native`]: https://github.com/iced-rs/iced/tree/0.9/native
pub fn mouse_button(mouse_button: winit::event::MouseButton) -> mouse::Button {
match mouse_button {
winit::event::MouseButton::Left => mouse::Button::Left,
winit::event::MouseButton::Right => mouse::Button::Right,
winit::event::MouseButton::Middle => mouse::Button::Middle,
winit::event::MouseButton::Other(other) => {
mouse::Button::Other(other as u8)
}
winit::event::MouseButton::Other(other) => mouse::Button::Other(other),
}
}
@ -268,7 +281,7 @@ pub fn mouse_button(mouse_button: winit::event::MouseButton) -> mouse::Button {
/// modifiers state.
///
/// [`winit`]: https://github.com/rust-windowing/winit
/// [`iced_native`]: https://github.com/iced-rs/iced/tree/0.8/native
/// [`iced_native`]: https://github.com/iced-rs/iced/tree/0.9/native
pub fn modifiers(
modifiers: winit::event::ModifiersState,
) -> keyboard::Modifiers {
@ -295,7 +308,7 @@ pub fn cursor_position(
/// Converts a `Touch` from [`winit`] to an [`iced_native`] touch event.
///
/// [`winit`]: https://github.com/rust-windowing/winit
/// [`iced_native`]: https://github.com/iced-rs/iced/tree/0.8/native
/// [`iced_native`]: https://github.com/iced-rs/iced/tree/0.9/native
pub fn touch_event(
touch: winit::event::Touch,
scale_factor: f64,
@ -326,7 +339,7 @@ pub fn touch_event(
/// Converts a `VirtualKeyCode` from [`winit`] to an [`iced_native`] key code.
///
/// [`winit`]: https://github.com/rust-windowing/winit
/// [`iced_native`]: https://github.com/iced-rs/iced/tree/0.8/native
/// [`iced_native`]: https://github.com/iced-rs/iced/tree/0.9/native
pub fn key_code(
virtual_keycode: winit::event::VirtualKeyCode,
) -> keyboard::KeyCode {
@ -519,6 +532,15 @@ pub fn user_attention(
}
}
/// Converts some [`Icon`] into it's `winit` counterpart.
///
/// Returns `None` if there is an error during the conversion.
pub fn icon(icon: window::Icon) -> Option<winit::window::Icon> {
let (pixels, size) = icon.into_raw();
winit::window::Icon::from_rgba(pixels, size.width, size.height).ok()
}
// As defined in: http://www.unicode.org/faq/private_use.html
pub(crate) fn is_private_use_character(c: char) -> bool {
matches!(

7
winit/src/error.rs
View file

@ -1,4 +1,5 @@
use iced_futures::futures;
use crate::futures::futures;
use crate::graphics;
/// An error that occurred while running an application.
#[derive(Debug, thiserror::Error)]
@ -13,10 +14,10 @@ pub enum Error {
/// The application graphics context could not be created.
#[error("the application graphics context could not be created")]
GraphicsCreationFailed(iced_graphics::Error),
GraphicsCreationFailed(graphics::Error),
}
impl From<iced_graphics::Error> for Error {
impl From<graphics::Error> for Error {
fn from(error: iced_graphics::Error) -> Error {
Error::GraphicsCreationFailed(error)
}

211
winit/src/icon.rs
View file

@ -1,182 +1,63 @@
//! Attach an icon to the window of your application.
use std::fmt;
pub use crate::core::window::icon::*;
use crate::core::window::icon;
use std::io;
#[cfg(feature = "image_rs")]
#[cfg(feature = "image")]
use std::path::Path;
/// The icon of a window.
#[derive(Clone)]
pub struct Icon(winit::window::Icon);
/// Creates an icon from an image file.
///
/// This will return an error in case the file is missing at run-time. You may prefer [`Self::from_file_data`] instead.
#[cfg(feature = "image")]
pub fn from_file<P: AsRef<Path>>(icon_path: P) -> Result<Icon, Error> {
let icon = image_rs::io::Reader::open(icon_path)?.decode()?.to_rgba8();
impl fmt::Debug for Icon {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Icon").field(&format_args!("_")).finish()
}
Ok(icon::from_rgba(icon.to_vec(), icon.width(), icon.height())?)
}
impl Icon {
/// Creates an icon from 32bpp RGBA data.
pub fn from_rgba(
rgba: Vec<u8>,
width: u32,
height: u32,
) -> Result<Self, Error> {
let raw = winit::window::Icon::from_rgba(rgba, width, height)?;
/// Creates an icon from the content of an image file.
///
/// This content can be included in your application at compile-time, e.g. using the `include_bytes!` macro.
/// You can pass an explicit file format. Otherwise, the file format will be guessed at runtime.
#[cfg(feature = "image")]
pub fn from_file_data(
data: &[u8],
explicit_format: Option<image_rs::ImageFormat>,
) -> Result<Icon, Error> {
let mut icon = image_rs::io::Reader::new(std::io::Cursor::new(data));
let icon_with_format = match explicit_format {
Some(format) => {
icon.set_format(format);
icon
}
None => icon.with_guessed_format()?,
};
Ok(Icon(raw))
}
let pixels = icon_with_format.decode()?.to_rgba8();
/// Creates an icon from an image file.
///
/// This will return an error in case the file is missing at run-time. You may prefer [`Self::from_file_data`] instead.
#[cfg(feature = "image_rs")]
pub fn from_file<P: AsRef<Path>>(icon_path: P) -> Result<Self, Error> {
let icon = image_rs::io::Reader::open(icon_path)?.decode()?.to_rgba8();
Self::from_rgba(icon.to_vec(), icon.width(), icon.height())
}
/// Creates an icon from the content of an image file.
///
/// This content can be included in your application at compile-time, e.g. using the `include_bytes!` macro. \
/// You can pass an explicit file format. Otherwise, the file format will be guessed at runtime.
#[cfg(feature = "image_rs")]
pub fn from_file_data(
data: &[u8],
explicit_format: Option<image_rs::ImageFormat>,
) -> Result<Self, Error> {
let mut icon = image_rs::io::Reader::new(std::io::Cursor::new(data));
let icon_with_format = match explicit_format {
Some(format) => {
icon.set_format(format);
icon
}
None => icon.with_guessed_format()?,
};
let pixels = icon_with_format.decode()?.to_rgba8();
Self::from_rgba(pixels.to_vec(), pixels.width(), pixels.height())
}
Ok(icon::from_rgba(
pixels.to_vec(),
pixels.width(),
pixels.height(),
)?)
}
/// An error produced when using `Icon::from_rgba` with invalid arguments.
#[derive(Debug)]
/// An error produced when creating an [`Icon`].
#[derive(Debug, thiserror::Error)]
pub enum Error {
/// The provided RGBA data isn't divisble by 4.
///
/// Therefore, it cannot be safely interpreted as 32bpp RGBA pixels.
InvalidData {
/// The length of the provided RGBA data.
byte_count: usize,
},
/// The number of RGBA pixels does not match the provided dimensions.
DimensionsMismatch {
/// The provided width.
width: u32,
/// The provided height.
height: u32,
/// The amount of pixels of the provided RGBA data.
pixel_count: usize,
},
/// The [`Icon`] is not valid.
#[error("The icon is invalid: {0}")]
InvalidError(#[from] icon::Error),
/// The underlying OS failed to create the icon.
OsError(io::Error),
#[error("The underlying OS failted to create the window icon: {0}")]
OsError(#[from] io::Error),
/// The `image` crate reported an error
#[cfg(feature = "image_rs")]
ImageError(image_rs::error::ImageError),
}
impl From<std::io::Error> for Error {
fn from(os_error: std::io::Error) -> Self {
Error::OsError(os_error)
}
}
impl From<winit::window::BadIcon> for Error {
fn from(error: winit::window::BadIcon) -> Self {
use winit::window::BadIcon;
match error {
BadIcon::ByteCountNotDivisibleBy4 { byte_count } => {
Error::InvalidData { byte_count }
}
BadIcon::DimensionsVsPixelCount {
width,
height,
pixel_count,
..
} => Error::DimensionsMismatch {
width,
height,
pixel_count,
},
BadIcon::OsError(os_error) => Error::OsError(os_error),
}
}
}
impl From<Icon> for winit::window::Icon {
fn from(icon: Icon) -> Self {
icon.0
}
}
#[cfg(feature = "image_rs")]
impl From<image_rs::error::ImageError> for Error {
fn from(image_error: image_rs::error::ImageError) -> Self {
Self::ImageError(image_error)
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Error::InvalidData { byte_count } => {
write!(
f,
"The provided RGBA data (with length {byte_count:?}) isn't divisble by \
4. Therefore, it cannot be safely interpreted as 32bpp RGBA \
pixels."
)
}
Error::DimensionsMismatch {
width,
height,
pixel_count,
} => {
write!(
f,
"The number of RGBA pixels ({pixel_count:?}) does not match the provided \
dimensions ({width:?}x{height:?})."
)
}
Error::OsError(e) => write!(
f,
"The underlying OS failed to create the window \
icon: {e:?}"
),
#[cfg(feature = "image_rs")]
Error::ImageError(e) => {
write!(f, "Unable to create icon from a file: {e:?}")
}
}
}
}
impl std::error::Error for Error {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
Some(self)
}
}
impl TryFrom<iced_native::window::Icon> for Icon {
type Error = Error;
fn try_from(icon: iced_native::window::Icon) -> Result<Self, Self::Error> {
Icon::from_rgba(icon.rgba, icon.width, icon.height)
}
/// The `image` crate reported an error.
#[cfg(feature = "image")]
#[error("Unable to create icon from a file: {0}")]
ImageError(#[from] image_rs::error::ImageError),
}

18
winit/src/lib.rs
View file

@ -11,7 +11,7 @@
//! Additionally, a [`conversion`] module is available for users that decide to
//! implement a custom event loop.
//!
//! [`iced_native`]: https://github.com/iced-rs/iced/tree/0.8/native
//! [`iced_native`]: https://github.com/iced-rs/iced/tree/0.9/native
//! [`winit`]: https://github.com/rust-windowing/winit
//! [`conversion`]: crate::conversion
#![doc(
@ -25,14 +25,17 @@
clippy::from_over_into,
clippy::needless_borrow,
clippy::new_without_default,
clippy::useless_conversion
clippy::useless_conversion,
unsafe_code
)]
#![forbid(rust_2018_idioms, unsafe_code)]
#![forbid(rust_2018_idioms)]
#![allow(clippy::inherent_to_string, clippy::type_complexity)]
#![cfg_attr(docsrs, feature(doc_cfg))]
#[doc(no_inline)]
pub use iced_native::*;
#![cfg_attr(docsrs, feature(doc_auto_cfg))]
pub use iced_graphics as graphics;
pub use iced_runtime as runtime;
pub use iced_runtime::core;
pub use iced_runtime::futures;
pub use iced_style as style;
pub use winit;
#[cfg(feature = "multi-window")]
@ -43,7 +46,6 @@ pub mod application;
pub mod clipboard;
pub mod conversion;
pub mod settings;
pub mod window;
#[cfg(feature = "system")]
pub mod system;

2
winit/src/proxy.rs
View file

@ -1,4 +1,4 @@
use iced_native::futures::{
use crate::futures::futures::{
channel::mpsc,
task::{Context, Poll},
Sink,

61
winit/src/settings.rs
View file

@ -22,7 +22,7 @@ mod platform;
pub use platform::PlatformSpecific;
use crate::conversion;
use crate::Icon;
use crate::core::window::{Icon, Level};
use crate::Position;
use winit::monitor::MonitorHandle;
@ -50,20 +50,8 @@ pub struct Settings<Flags> {
/// Whether the [`Application`] should exit when the user requests the
/// window to close (e.g. the user presses the close button).
///
/// NOTE: This is not used for `multi-window`, instead check [`Application::close_requested`].
///
/// [`close_requested`]: crate::multi_window::Application::close_requested
///
/// [`Application`]: crate::Application
pub exit_on_close_request: bool,
/// Whether the [`Application`] should try to build the context
/// using OpenGL ES first then OpenGL.
///
/// NOTE: Only works for the `glow` backend.
///
/// [`Application`]: crate::Application
pub try_opengles_first: bool,
}
/// The window settings of an application.
@ -93,11 +81,11 @@ pub struct Window {
/// Whether the window should be transparent.
pub transparent: bool,
/// Whether the window will always be on top of other windows.
pub always_on_top: bool,
/// The window [`Level`].
pub level: Level,
/// The window icon, which is also usually used in the taskbar
pub icon: Option<winit::window::Icon>,
pub icon: Option<Icon>,
/// Platform specific settings.
pub platform_specific: platform::PlatformSpecific,
@ -114,7 +102,7 @@ impl fmt::Debug for Window {
.field("resizable", &self.resizable)
.field("decorations", &self.decorations)
.field("transparent", &self.transparent)
.field("always_on_top", &self.always_on_top)
.field("level", &self.level)
.field("icon", &self.icon.is_some())
.field("platform_specific", &self.platform_specific)
.finish()
@ -139,8 +127,9 @@ impl Window {
.with_resizable(self.resizable)
.with_decorations(self.decorations)
.with_transparent(self.transparent)
.with_window_icon(self.icon)
.with_always_on_top(self.always_on_top);
.with_window_icon(self.icon.and_then(conversion::icon))
.with_window_level(conversion::window_level(self.level))
.with_visible(self.visible);
if let Some(position) = conversion::position(
primary_monitor.as_ref(),
@ -168,7 +157,9 @@ impl Window {
target_os = "openbsd"
))]
{
use ::winit::platform::unix::WindowBuilderExtUnix;
// `with_name` is available on both `WindowBuilderExtWayland` and `WindowBuilderExtX11` and they do
// exactly the same thing. We arbitrarily choose `WindowBuilderExtWayland` here.
use ::winit::platform::wayland::WindowBuilderExtWayland;
if let Some(id) = _id {
window_builder = window_builder.with_name(id.clone(), id);
@ -178,11 +169,11 @@ impl Window {
#[cfg(target_os = "windows")]
{
use winit::platform::windows::WindowBuilderExtWindows;
if let Some(parent) = self.platform_specific.parent {
window_builder = window_builder.with_parent_window(parent);
#[allow(unsafe_code)]
unsafe {
window_builder = window_builder
.with_parent_window(self.platform_specific.parent);
}
window_builder = window_builder
.with_drag_and_drop(self.platform_specific.drag_and_drop);
}
@ -216,29 +207,9 @@ impl Default for Window {
resizable: true,
decorations: true,
transparent: false,
always_on_top: false,
level: Level::default(),
icon: None,
platform_specific: Default::default(),
}
}
}
impl From<iced_native::window::Settings> for Window {
fn from(settings: iced_native::window::Settings) -> Self {
Self {
size: settings.size,
position: settings.position,
min_size: settings.min_size,
max_size: settings.max_size,
visible: settings.visible,
resizable: settings.resizable,
decorations: settings.decorations,
transparent: settings.transparent,
always_on_top: settings.always_on_top,
icon: settings.icon.and_then(|icon| {
Icon::try_from(icon).map(winit::window::Icon::from).ok()
}),
platform_specific: Default::default(),
}
}
}

3
winit/src/settings/windows.rs
View file

@ -1,10 +1,11 @@
//! Platform specific settings for Windows.
use raw_window_handle::RawWindowHandle;
/// The platform specific window settings of an application.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PlatformSpecific {
/// Parent window
pub parent: Option<winit::platform::windows::HWND>,
pub parent: Option<RawWindowHandle>,
/// Drag and drop support
pub drag_and_drop: bool,

7
winit/src/system.rs
View file

@ -1,8 +1,7 @@
//! Access the native system.
use crate::command::{self, Command};
pub use iced_native::system::*;
use iced_graphics::compositor;
use crate::graphics::compositor;
use crate::runtime::command::{self, Command};
use crate::runtime::system::{Action, Information};
/// Query for available system information.
pub fn fetch_information<Message>(

128
winit/src/window.rs
View file

@ -1,128 +0,0 @@
//! Interact with the window of your application.
use crate::command::{self, Command};
use iced_native::window;
pub use window::{Event, Id, Mode, RedrawRequest, frames, UserAttention};
/// Closes the window.
pub fn close<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, window::Action::Close))
}
/// Begins dragging the window while the left mouse button is held.
pub fn drag<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, window::Action::Drag))
}
/// Spawns a new window.
pub fn spawn<Message>(
id: window::Id,
settings: window::Settings,
) -> Command<Message> {
Command::single(command::Action::Window(
id,
window::Action::Spawn { settings },
))
}
/// Resizes the window to the given logical dimensions.
pub fn resize<Message>(
id: window::Id,
width: u32,
height: u32,
) -> Command<Message> {
Command::single(command::Action::Window(
id,
window::Action::Resize { width, height },
))
}
/// Maximizes the window.
pub fn maximize<Message>(id: window::Id, maximized: bool) -> Command<Message> {
Command::single(command::Action::Window(
id,
window::Action::Maximize(maximized),
))
}
/// Minimes the window.
pub fn minimize<Message>(id: window::Id, minimized: bool) -> Command<Message> {
Command::single(command::Action::Window(
id,
window::Action::Minimize(minimized),
))
}
/// Moves a window to the given logical coordinates.
pub fn move_to<Message>(id: window::Id, x: i32, y: i32) -> Command<Message> {
Command::single(command::Action::Window(id, window::Action::Move { x, y }))
}
/// Changes the [`Mode`] of the window.
pub fn change_mode<Message>(id: window::Id, mode: Mode) -> Command<Message> {
Command::single(command::Action::Window(id, window::Action::ChangeMode(mode)))
}
/// Fetches the current [`Mode`] of the window.
pub fn fetch_mode<Message>(
id: window::Id,
f: impl FnOnce(Mode) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(
id,
window::Action::FetchMode(Box::new(f)),
))
}
/// Toggles the window to maximized or back.
pub fn toggle_maximize<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, window::Action::ToggleMaximize))
}
/// Toggles the window decorations.
pub fn toggle_decorations<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, window::Action::ToggleDecorations))
}
/// Request user attention to the window, this has no effect if the application
/// is already focused. How requesting for user attention manifests is platform dependent,
/// see [`UserAttention`] for details.
///
/// Providing `None` will unset the request for user attention. Unsetting the request for
/// user attention might not be done automatically by the WM when the window receives input.
pub fn request_user_attention<Message>(
id: window::Id,
user_attention: Option<UserAttention>,
) -> Command<Message> {
Command::single(command::Action::Window(
id,
window::Action::RequestUserAttention(user_attention),
))
}
/// Brings the window to the front and sets input focus. Has no effect if the window is
/// already in focus, minimized, or not visible.
///
/// This [`Command`] steals input focus from other applications. Do not use this method unless
/// you are certain that's what the user wants. Focus stealing can cause an extremely disruptive
/// user experience.
pub fn gain_focus<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, window::Action::GainFocus))
}
/// Changes whether or not the window will always be on top of other windows.
pub fn change_always_on_top<Message>(id: window::Id, on_top: bool) -> Command<Message> {
Command::single(command::Action::Window(id, window::Action::ChangeAlwaysOnTop(
on_top,
)))
}
/// Fetches an identifier unique to the window.
pub fn fetch_id<Message>(
id: window::Id,
f: impl FnOnce(u64) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(id, window::Action::FetchId(Box::new(
f,
))))
}