Patch Style and updates version 0.5

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_iced"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2021"
 description = "Iced integration for Bevy"
 authors = ["tasgon <[email protected]>"]

README.md

@@ -36,8 +36,9 @@ See the [examples](https://github.com/tasgon/bevy_iced/tree/master/examples) and
 
 |Bevy Version  |Crate Version  |
 |--------------|---------------|
-|`0.11`        |`0.4`, `master`|
-|`0.10`        |`0.3`,         |
+|`0.13`        |`0.5`, `master`|
+|`0.11`        |`0.4`          |
+|`0.10`        |`0.3`          |
 |`0.9`         |`0.2`          |
 |`0.7`         |`0.1`          |
 

examples/fonts.rs

@@ -7,7 +7,7 @@ use bevy_iced::iced::{
 use bevy_iced::{iced, IcedContext, IcedPlugin};
 
 const ALPHAPROTA_FONT: Font = Font::with_name("Alpha Prota");
-const ALPHAPROTA_FONT_BYTES: &'static [u8] = include_bytes!("../assets/fonts/AlphaProta.ttf");
+const ALPHAPROTA_FONT_BYTES: &[u8] = include_bytes!("../assets/fonts/AlphaProta.ttf");
 
 #[derive(Event)]
 pub enum UiMessage {}
@@ -30,7 +30,7 @@ pub fn main() {
 
 fn ui_system(mut ctx: IcedContext<UiMessage>) {
     ctx.display(column!(
-        text(format!("I am the default font")).font(font::Font::DEFAULT),
-        text(format!("I am another font"))
+        text("I am the default font".to_string()).font(font::Font::DEFAULT),
+        text("I am another font".to_string())
     ));
 }

examples/interactive.rs

@@ -38,7 +38,7 @@ pub fn main() {
         }))
         .add_plugins((
             IcedPlugin::default(),
-            FrameTimeDiagnosticsPlugin::default(),
+            FrameTimeDiagnosticsPlugin,
             LogDiagnosticsPlugin::default(),
         ))
         .add_event::<UiMessage>()
@@ -53,7 +53,6 @@ pub fn main() {
             style: Style {
                 text_color: iced::Color::from_rgb(0.0, 1.0, 1.0),
             },
-            ..Default::default()
         })
         .add_systems(Startup, build_program)
         .add_systems(
@@ -98,7 +97,7 @@ fn box_system(
                 data.scale = *new_scale;
             }
             UiMessage::Text(s) => {
-                data.text = s.clone();
+                data.text.clone_from(s);
                 for mut i in &mut sprites.iter_mut() {
                     i.color = Color::rgba_u8(rng(), rng(), rng(), rng());
                 }

src/conversions.rs

@@ -12,8 +12,6 @@ pub fn key_code(virtual_keycode: &BevyKey) -> IcedKey {
     use iced_core::keyboard::key::Named;
     match virtual_keycode {
         BevyKey::Character(s) => IcedKey::Character(s.clone()),
-        BevyKey::Unidentified(_) => IcedKey::Unidentified,
-        BevyKey::Dead(_) => IcedKey::Unidentified,
         BevyKey::Alt => IcedKey::Named(Named::Alt),
         BevyKey::AltGraph => IcedKey::Named(Named::AltGraph),
         BevyKey::CapsLock => IcedKey::Named(Named::CapsLock),
@@ -320,11 +318,12 @@ pub fn key_code(virtual_keycode: &BevyKey) -> IcedKey {
         BevyKey::F33 => IcedKey::Named(Named::F33),
         BevyKey::F34 => IcedKey::Named(Named::F34),
         BevyKey::F35 => IcedKey::Named(Named::F35),
+        BevyKey::Unidentified(_) | BevyKey::Dead(_) => IcedKey::Unidentified,
         _ => IcedKey::Unidentified,
     }
 }
 
-pub fn mouse_button(button: MouseButton) -> iced_core::mouse::Button {
+pub const fn mouse_button(button: MouseButton) -> iced_core::mouse::Button {
     use iced_core::mouse::Button;
     match button {
         MouseButton::Left => Button::Left,
@@ -336,7 +335,7 @@ pub fn mouse_button(button: MouseButton) -> iced_core::mouse::Button {
     }
 }
 
-pub fn touch_event(bevy_touch_input: &TouchInput) -> touch::Event {
+pub const fn touch_event(bevy_touch_input: &TouchInput) -> touch::Event {
     match *bevy_touch_input {
         TouchInput {
             phase: TouchPhase::Started,

src/lib.rs

@@ -247,14 +247,12 @@ impl<'w, 's, M: bevy_ecs::event::Event> IcedContext<'w, 's, M> {
 
         let cursor = {
             let window = self.windows.single();
-            match window.cursor_position() {
-                Some(position) => {
+            window.cursor_position().map_or_else(
+                || utils::process_touch_input(self).map_or(Cursor::Unavailable, Cursor::Available),
+                |position| {
                     Cursor::Available(utils::process_cursor_position(position, bounds, window))
-                }
-                None => utils::process_touch_input(self)
-                    .map(Cursor::Available)
-                    .unwrap_or(Cursor::Unavailable),
-            }
+                },
+            )
         };
 
         let mut messages = Vec::<M>::new();

src/render.rs

@@ -32,15 +32,15 @@ pub const TEXTURE_FMT: TextureFormat = TextureFormat::Bgra8UnormSrgb;
 #[derive(Resource, Deref, DerefMut, Clone)]
 pub struct ViewportResource(pub Viewport);
 
-pub(crate) fn update_viewport(
+pub fn update_viewport(
     windows: Query<&Window>,
     iced_settings: Res<IcedSettings>,
     mut commands: Commands,
 ) {
     let window = windows.single();
     let scale_factor = iced_settings
         .scale_factor
-        .unwrap_or(window.scale_factor().into());
+        .unwrap_or_else(|| window.scale_factor().into());
     let viewport = Viewport::with_physical_size(
         Size::new(window.physical_width(), window.physical_height()),
         scale_factor,
@@ -52,7 +52,7 @@ pub(crate) fn update_viewport(
 #[derive(Resource, Deref, DerefMut)]
 struct DidDrawBasic(bool);
 
-pub(crate) fn extract_iced_data(
+pub fn extract_iced_data(
     mut commands: Commands,
     viewport: Extract<Res<ViewportResource>>,
     did_draw: Extract<Res<DidDraw>>,
@@ -77,7 +77,7 @@ impl IcedNode {
 
 impl Node for IcedNode {
     fn update(&mut self, _world: &mut World) {
-        self.staging_belt.lock().unwrap().recall()
+        self.staging_belt.lock().unwrap().recall();
     }
 
     fn run(
@@ -106,11 +106,7 @@ impl Node for IcedNode {
         let render_queue = world.resource::<RenderQueue>();
         let viewport = world.resource::<ViewportResource>();
 
-        if !world
-            .get_resource::<DidDrawBasic>()
-            .map(|x| x.0)
-            .unwrap_or(false)
-        {
+        if !world.get_resource::<DidDrawBasic>().is_some_and(|x| x.0) {
             return Ok(());
         }
         let view = extracted_window.swap_chain_texture_view.as_ref().unwrap();

src/systems.rs

@@ -65,7 +65,7 @@ pub fn process_input(
         event_queue.push(IcedEvent::Mouse(match ev.state {
             ButtonState::Pressed => iced_core::mouse::Event::ButtonPressed(button),
             ButtonState::Released => iced_core::mouse::Event::ButtonReleased(button),
-        }))
+        }));
     }
 
     for _ev in events.cursor_entered.read() {

src/utils.rs

@@ -3,7 +3,7 @@ use crate::IcedContext;
 use bevy_math::Vec2;
 use bevy_window::Window;
 
-pub(crate) fn process_cursor_position(
+pub fn process_cursor_position(
     position: Vec2,
     bounds: iced_core::Size,
     window: &Window,
@@ -15,34 +15,37 @@ pub(crate) fn process_cursor_position(
 }
 
 /// To correctly process input as last resort events are used
-pub(crate) fn process_touch_input<M: bevy_ecs::event::Event>(
+pub fn process_touch_input<M: bevy_ecs::event::Event>(
     context: &IcedContext<M>,
 ) -> Option<iced::Point> {
     context
         .touches
         .first_pressed_position()
-        .or(context
-            .touches
-            .iter_just_released()
-            .map(|touch| touch.position())
-            .next())
+        .or_else(|| {
+            context
+                .touches
+                .iter_just_released()
+                .map(bevy_input::touch::Touch::position)
+                .next()
+        })
         .map(|Vec2 { x, y }| iced::Point { x, y })
-        .or(context
-            .events
-            .iter()
-            .filter_map(|ev| {
-                if let iced::Event::Touch(
-                    iced::touch::Event::FingerLifted { position, .. }
-                    | iced::touch::Event::FingerLost { position, .. }
-                    | iced::touch::Event::FingerMoved { position, .. }
-                    | iced::touch::Event::FingerPressed { position, .. },
-                ) = ev
-                {
-                    Some(position)
-                } else {
-                    None
-                }
-            })
-            .next()
-            .copied())
+        .or_else(|| {
+            context
+                .events
+                .iter()
+                .find_map(|ev| {
+                    if let iced::Event::Touch(
+                        iced::touch::Event::FingerLifted { position, .. }
+                        | iced::touch::Event::FingerLost { position, .. }
+                        | iced::touch::Event::FingerMoved { position, .. }
+                        | iced::touch::Event::FingerPressed { position, .. },
+                    ) = ev
+                    {
+                        Some(position)
+                    } else {
+                        None
+                    }
+                })
+                .copied()
+        })
 }