Update Rust crate quick-xml to 0.37.0

Cargo.toml

@@ -20,4 +20,3 @@ ecs = { git = "https://gavania.de/hodasemi/ecs.git" }
 audio = { git = "https://gavania.de/hodasemi/audio.git", optional = true }
 
 [features]
-default = ["audio"]

src/builder/builder.rs

@@ -23,31 +23,31 @@ pub struct GuiBuilder {
 }
 
 impl GuiBuilder {
-    pub fn new(world: &mut World, path: &AssetPath) -> Result<Arc<Self>> {
+    pub fn new(gui_handler: &mut GuiHandler, path: &AssetPath) -> Result<Arc<Self>> {
         let validator = Validator::new(
             #[cfg(feature = "audio")]
-            world.resources.get::<GuiHandler>(),
+            gui_handler,
             path,
         )
         .with_context(|| format!("validator for {}", path.full_path()))?;
 
-        Ok(Arc::new(Self::_new(world, validator).with_context(
+        Ok(Arc::new(Self::_new(gui_handler, validator).with_context(
             || format!("for file {}", path.full_path()),
         )?))
     }
 
-    pub fn from_str(world: &mut World, s: &str) -> Result<Arc<Self>> {
+    pub fn from_str(gui_handler: &mut GuiHandler, s: &str) -> Result<Arc<Self>> {
         let validator = Validator::from_str(
             #[cfg(feature = "audio")]
-            world.resources.get::<GuiHandler>(),
+            gui_handler,
             s,
         )?;
 
-        Ok(Arc::new(Self::_new(world, validator)?))
+        Ok(Arc::new(Self::_new(gui_handler, validator)?))
     }
 
     pub fn merge<'a>(
-        world: &mut World,
+        gui_handler: &mut GuiHandler,
         pathes: impl IntoIterator<Item = &'a AssetPath>,
     ) -> Result<Arc<Self>> {
         let mut me = Self {
@@ -62,11 +62,11 @@ impl GuiBuilder {
         for path in pathes.into_iter() {
             let validator = Validator::new(
                 #[cfg(feature = "audio")]
-                world.resources.get::<GuiHandler>(),
+                gui_handler,
                 path,
             )?;
 
-            let builder = Self::_new(world, validator)
+            let builder = Self::_new(gui_handler, validator)
                 .with_context(|| format!("for file {}", path.full_path()))?;
 
             me.grids.extend(builder.grids);
@@ -86,7 +86,7 @@ impl GuiBuilder {
     }
 
     #[inline]
-    fn _new(world: &mut World, validator: Validator) -> Result<Self> {
+    fn _new(gui_handler: &mut GuiHandler, validator: Validator) -> Result<Self> {
         let root = validator.root();
 
         let mut ids = HashMap::new();
@@ -95,11 +95,8 @@ impl GuiBuilder {
 
         let mut grids = Vec::new();
 
-        let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
-
         for child in &root.children {
             let tree = Self::create_tree(
-                world,
                 gui_handler,
                 &mut ids,
                 child,
@@ -248,9 +245,9 @@ impl Visibility for GuiBuilder {
             .unwrap_or(false)
     }
 
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         for grid in &self.grids {
-            grid.set_visibility(world, visibility)?;
+            grid.set_visibility(gui_handler, visibility)?;
         }
 
         Ok(())
@@ -306,18 +303,18 @@ impl TopLevelGui for GuiBuilder {
         Some(self)
     }
 
-    fn enable(&self, world: &mut World) -> Result<()> {
+    fn enable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
-        self.set_visibility(world, true)?;
+        self.set_visibility(gui_handler, true)?;
 
         if let Some(button) = &self.default_select {
-            button.select(world.resources.get_mut::<GuiHandler>())?;
+            button.select(gui_handler)?;
         }
 
         Ok(())
     }
 
-    fn disable(&self, world: &mut World) -> Result<()> {
+    fn disable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
-        self.set_visibility(world, false)?;
+        self.set_visibility(gui_handler, false)?;
 
         Ok(())
     }
@@ -345,7 +342,6 @@ impl_element!(MultiLineTextField);
 // private
 impl GuiBuilder {
     fn create_tree(
-        world: &mut World,
         gui_handler: &mut GuiHandler,
         ids: &mut HashMap<String, UiElement>,
         root_grid_info: &Arc<GridInfo>,
@@ -398,7 +394,6 @@ impl GuiBuilder {
 
         for child in root_grid_info.children.read().unwrap().iter() {
             Self::create_child(
-                world,
                 gui_handler,
                 child,
                 &root_grid,
@@ -413,7 +408,6 @@ impl GuiBuilder {
     }
 
     fn create_child(
-        world: &mut World,
         gui_handler: &mut GuiHandler,
         child: &UiInfoElement,
         grid: &Grid,
@@ -429,7 +423,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &button_info.id, &button)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     button.clone(),
                     button_info
                         .x_slot
@@ -464,7 +458,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &label_info.id, &label)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     label.clone(),
                     label_info.x_slot.get().with_context(|| "x_slot of label")?,
                     label_info.y_slot.get().with_context(|| "y_slot of label")?,
@@ -476,12 +470,12 @@ impl GuiBuilder {
             }
             UiInfoElement::MultiLineLabel(multi_line_label_info) => {
                 let multi_line_label =
-                    MultiLineLabel::try_from(multi_line_label_info, world, gui_handler)?;
+                    MultiLineLabel::try_from(multi_line_label_info, gui_handler)?;
 
                 GuiBuilder::insert_id(ids, &multi_line_label_info.id, &multi_line_label)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     multi_line_label.clone(),
                     multi_line_label_info
                         .x_slot
@@ -499,12 +493,12 @@ impl GuiBuilder {
             }
             UiInfoElement::MultiLineTextField(multi_line_text_field_info) => {
                 let multi_line_text_field =
-                    MultiLineTextField::try_from(multi_line_text_field_info, world, gui_handler)?;
+                    MultiLineTextField::try_from(multi_line_text_field_info, gui_handler)?;
 
                 GuiBuilder::insert_id(ids, &multi_line_text_field_info.id, &multi_line_text_field)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     multi_line_text_field.clone(),
                     multi_line_text_field_info
                         .x_slot
@@ -526,7 +520,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &text_field_info.id, &text_field)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     text_field.clone(),
                     text_field_info
                         .x_slot
@@ -548,7 +542,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &icon_info.id, UiElement::Icon(Arc::downgrade(&icon)))?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     icon.clone(),
                     icon_info.x_slot.get().with_context(|| "x_slot of icon")?,
                     icon_info.y_slot.get().with_context(|| "y_slot of icon")?,
@@ -564,7 +558,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &progress_bar_info.id, &progress_bar)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     progress_bar.clone(),
                     progress_bar_info
                         .x_slot
@@ -586,7 +580,7 @@ impl GuiBuilder {
                 Self::insert_id(ids, &grid_info.id, &sub_grid)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     sub_grid.clone(),
                     grid_info.x_slot.get().with_context(|| "x_slot of grid")?,
                     grid_info.y_slot.get().with_context(|| "y_slot of grid")?,
@@ -599,7 +593,6 @@ impl GuiBuilder {
 
                 for child in grid_info.children.read().unwrap().iter() {
                     Self::create_child(
-                        world,
                         gui_handler,
                         child,
                         &sub_grid,

src/builder/snippet.rs

@@ -18,27 +18,27 @@ pub struct GuiSnippet {
 }
 
 impl GuiSnippet {
-    pub fn new(world: &mut World, path: &AssetPath) -> Result<Arc<Self>> {
+    pub fn new(gui_handler: &mut GuiHandler, path: &AssetPath) -> Result<Arc<Self>> {
         let validator = Validator::new(
             #[cfg(feature = "audio")]
-            world.resources.get::<GuiHandler>(),
+            gui_handler,
             path,
         )?;
 
-        Self::_new(world, validator)
+        Self::_new(gui_handler, validator)
     }
 
-    pub fn from_str(world: &mut World, s: &str) -> Result<Arc<Self>> {
+    pub fn from_str(gui_handler: &mut GuiHandler, s: &str) -> Result<Arc<Self>> {
         let validator = Validator::from_str(
             #[cfg(feature = "audio")]
-            world.resources.get::<GuiHandler>(),
+            gui_handler,
             s,
         )?;
 
-        Self::_new(world, validator)
+        Self::_new(gui_handler, validator)
     }
 
-    fn _new(world: &mut World, validator: Validator) -> Result<Arc<Self>> {
+    fn _new(gui_handler: &mut GuiHandler, validator: Validator) -> Result<Arc<Self>> {
         let root = validator.root();
 
         let mut ids = HashMap::new();
@@ -51,22 +51,13 @@ impl GuiSnippet {
             )));
         }
 
-        let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
-
         let grid_info = &root.children[0];
         let grid = Grid::try_from(gui_handler, grid_info, false)?;
 
         GuiBuilder::insert_id(&mut ids, &grid_info.id, &grid)?;
 
         for child in grid_info.children.read().unwrap().iter() {
-            Self::create_child(
+            Self::create_child(gui_handler, child, &grid, &mut ids, &mut custom_neighbours)?;
-                world,
-                gui_handler,
-                child,
-                &grid,
-                &mut ids,
-                &mut custom_neighbours,
-            )?;
         }
 
         GuiBuilder::connect_custom_neighbours(&ids, custom_neighbours)?;
@@ -103,8 +94,8 @@ impl Visibility for GuiSnippet {
         self.grid.visible()
     }
 
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
-        self.grid.set_visibility(world, visibility)
+        self.grid.set_visibility(gui_handler, visibility)
     }
 }
 
@@ -216,7 +207,6 @@ impl Functionality for GuiSnippet {
 
 impl GuiSnippet {
     fn create_child(
-        world: &mut World,
         gui_handler: &mut GuiHandler,
         child: &UiInfoElement,
         grid: &Grid,
@@ -230,7 +220,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &button_info.id, &button)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     button.clone(),
                     button_info.x_slot.get()?,
                     button_info.y_slot.get()?,
@@ -246,7 +236,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &label_info.id, &label)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     label,
                     label_info.x_slot.get()?,
                     label_info.y_slot.get()?,
@@ -256,12 +246,12 @@ impl GuiSnippet {
             }
             UiInfoElement::MultiLineLabel(multi_line_label_info) => {
                 let multi_line_label =
-                    MultiLineLabel::try_from(multi_line_label_info, world, gui_handler)?;
+                    MultiLineLabel::try_from(multi_line_label_info, gui_handler)?;
 
                 GuiBuilder::insert_id(ids, &multi_line_label_info.id, &multi_line_label)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     multi_line_label,
                     multi_line_label_info.x_slot.get()?,
                     multi_line_label_info.y_slot.get()?,
@@ -271,12 +261,12 @@ impl GuiSnippet {
             }
             UiInfoElement::MultiLineTextField(multi_line_text_field_info) => {
                 let multi_line_text_field =
-                    MultiLineTextField::try_from(multi_line_text_field_info, world, gui_handler)?;
+                    MultiLineTextField::try_from(multi_line_text_field_info, gui_handler)?;
 
                 GuiBuilder::insert_id(ids, &multi_line_text_field_info.id, &multi_line_text_field)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     multi_line_text_field,
                     multi_line_text_field_info.x_slot.get()?,
                     multi_line_text_field_info.y_slot.get()?,
@@ -290,7 +280,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &text_field_info.id, &text_field)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     text_field,
                     text_field_info.x_slot.get()?,
                     text_field_info.y_slot.get()?,
@@ -304,7 +294,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &icon_info.id, UiElement::Icon(Arc::downgrade(&icon)))?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     icon,
                     icon_info.x_slot.get()?,
                     icon_info.y_slot.get()?,
@@ -318,7 +308,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &progress_bar_info.id, &progress_bar)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     progress_bar,
                     progress_bar_info.x_slot.get()?,
                     progress_bar_info.y_slot.get()?,
@@ -332,7 +322,7 @@ impl GuiSnippet {
                 GuiBuilder::insert_id(ids, &grid_info.id, &sub_grid)?;
 
                 grid.attach(
-                    world,
+                    gui_handler,
                     sub_grid.clone(),
                     grid_info.x_slot.get()?,
                     grid_info.y_slot.get()?,
@@ -341,7 +331,7 @@ impl GuiSnippet {
                 )?;
 
                 for child in grid_info.children.read().unwrap().iter() {
-                    Self::create_child(world, gui_handler, child, &sub_grid, ids, neighbour_infos)?;
+                    Self::create_child(gui_handler, child, &sub_grid, ids, neighbour_infos)?;
                 }
             }
         }

src/elements/button.rs

@@ -448,10 +448,8 @@ impl Visibility for Button {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible.load(SeqCst) {
-            let gui_handler = world.resources.get_mut::<GuiHandler>();
-
             self.visible.store(visibility, SeqCst);
 
             if visibility {

src/elements/callback_builder.rs

@@ -4,6 +4,7 @@ use anyhow::Result;
 use ecs::World;
 
 use super::ControllerButton;
+use crate::prelude::*;
 
 macro_rules! callbacks {
     ($name:ident, $($cb:tt)*) => {
@@ -27,12 +28,12 @@ macro_rules! callbacks {
     };
 }
 
-callbacks!(ClickCallbacks, Fn(&mut World) -> Result<()> + Send + Sync);
+callbacks!(ClickCallbacks, Fn(&mut World, &mut GuiHandler) -> Result<()> + Send + Sync);
-callbacks!(SelectCallbacks, Fn(&mut World, bool) -> anyhow::Result<()> + Send + Sync);
+callbacks!(SelectCallbacks, Fn(&mut World, &mut GuiHandler, bool) -> anyhow::Result<()> + Send + Sync);
-callbacks!(CustomCallbacks, Fn(&mut World, ControllerButton) -> anyhow::Result<bool> + Send + Sync);
+callbacks!(CustomCallbacks, Fn(&mut World, &mut GuiHandler, ControllerButton) -> anyhow::Result<bool> + Send + Sync);
 callbacks!(
     VecCallbacks,
-    Fn(&mut World, &dyn Any) -> Result<()> + Send + Sync
+    Fn(&mut World, &mut GuiHandler, &dyn Any) -> Result<()> + Send + Sync
 );
 
 #[cfg(test)]
@@ -40,8 +41,8 @@ mod test {
     use super::*;
     use anyhow::Result;
 
-    fn normal_fn() -> impl Fn(&mut World) -> Result<()> + Send + Sync {
+    fn normal_fn() -> impl Fn(&mut World, &mut GuiHandler) -> Result<()> + Send + Sync {
-        |_| Ok(())
+        |_, _| Ok(())
     }
 
     #[test]
@@ -51,7 +52,10 @@ mod test {
         impl Test {
             fn set_click_callbacks(
                 &self,
-                _callbacks: Vec<(&str, Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>)>,
+                _callbacks: Vec<(
+                    &str,
+                    Box<dyn Fn(&mut World, &mut GuiHandler) -> Result<()> + Send + Sync>,
+                )>,
             ) -> Result<()> {
                 Ok(())
             }

src/elements/grid.rs

@@ -1,6 +1,5 @@
 use crate::prelude::*;
 use anyhow::Result;
-use ecs::World;
 
 use crate::builder::validator::gridinfo::GridInfo;
 
@@ -200,7 +199,7 @@ impl Grid {
 
     pub fn detach(
         &self,
-        world: &mut World,
+        gui_handler: &mut GuiHandler,
         pos_x: usize,
         pos_y: usize,
     ) -> Result<Option<Arc<dyn GuiElementTraits>>> {
@@ -232,7 +231,7 @@ impl Grid {
             Some((child, _x, _y)) => {
                 if self.visible() {
                     if let Some(child_visibility) = child.visibility() {
-                        child_visibility.set_visibility(world, false)?;
+                        child_visibility.set_visibility(gui_handler, false)?;
                     }
                 }
 
@@ -243,7 +242,11 @@ impl Grid {
     }
 
     /// Returns `true` if item got detached
-    pub fn detach_item(&self, world: &mut World, item: Arc<dyn GuiElementTraits>) -> Result<bool> {
+    pub fn detach_item(
+        &self,
+        gui_handler: &mut GuiHandler,
+        item: Arc<dyn GuiElementTraits>,
+    ) -> Result<bool> {
         let mut grid = self.children.write().unwrap();
         let mut removed = false;
 
@@ -262,7 +265,7 @@ impl Grid {
 
                         if self.visible() {
                             if let Some(child_visibility) = child.visibility() {
-                                child_visibility.set_visibility(world, false)?;
+                                child_visibility.set_visibility(gui_handler, false)?;
                             }
                         }
                     }
@@ -405,7 +408,7 @@ impl Grid {
 
     pub fn attach(
         &self,
-        world: &mut World,
+        gui_handler: &mut GuiHandler,
         child: Arc<dyn GuiElementTraits>,
         pos_x: usize,
         pos_y: usize,
@@ -444,14 +447,7 @@ impl Grid {
             }
 
             if self.framable.is_framed() {
-                self.child_position(
+                self.child_position(gui_handler, child_gridable, pos_x, pos_y, dim_x, dim_y)?;
-                    world.resources.get_mut::<GuiHandler>(),
-                    child_gridable,
-                    pos_x,
-                    pos_y,
-                    dim_x,
-                    dim_y,
-                )?;
             }
 
             child_gridable.set_layer(self.framable.ui_layer())?;
@@ -462,7 +458,7 @@ impl Grid {
             ChildState::Some { child, .. } => {
                 if self.visible() {
                     if let Some(child_visibility) = child.visibility() {
-                        child_visibility.set_visibility(world, false)?;
+                        child_visibility.set_visibility(gui_handler, false)?;
                     }
                 }
             }
@@ -472,7 +468,7 @@ impl Grid {
 
         if self.visible() {
             if let Some(child_visibility) = child.visibility() {
-                child_visibility.set_visibility(world, true)?;
+                child_visibility.set_visibility(gui_handler, true)?;
             }
         }
 
@@ -626,26 +622,26 @@ impl Grid {
         }
     }
 
-    fn disable_tree(&self, world: &mut World, gui_handler: &mut GuiHandler) -> Result<()> {
+    fn disable_tree(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.framable.delete(gui_handler)?;
 
         if let Some(background) = self.background.read().unwrap().as_ref() {
             background.disable(gui_handler)?;
         }
 
-        self.set_tree_visibility(world, false)?;
+        self.set_tree_visibility(gui_handler, false)?;
 
         Ok(())
     }
 
-    fn set_tree_visibility(&self, world: &mut World, visible: bool) -> Result<()> {
+    fn set_tree_visibility(&self, gui_handler: &mut GuiHandler, visible: bool) -> Result<()> {
         let tree = self.children.read().unwrap();
 
         for row in tree.deref() {
             for child_state in row {
                 if let Some((child, ..)) = child_state.get_some() {
                     if let Some(visibility) = child.visibility() {
-                        visibility.set_visibility(world, visible)?;
+                        visibility.set_visibility(gui_handler, visible)?;
                     }
                 }
             }
@@ -797,10 +793,8 @@ impl Visibility for Grid {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible.load(SeqCst) {
-            let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
-
             self.visible.store(visibility, SeqCst);
 
             if visibility {
@@ -810,9 +804,9 @@ impl Visibility for Grid {
                     background.enable(gui_handler)?;
                 }
 
-                self.set_tree_visibility(world, true)?;
+                self.set_tree_visibility(gui_handler, true)?;
             } else {
-                self.disable_tree(world, gui_handler)?;
+                self.disable_tree(gui_handler)?;
             }
         }
 

src/elements/icon.rs

@@ -4,7 +4,6 @@ use crate::{
 };
 use anyhow::Result;
 use assetpath::AssetPath;
-use ecs::World;
 use utilities::prelude::*;
 use vulkan_rs::prelude::*;
 
@@ -281,10 +280,8 @@ impl Visibility for Icon {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible.load(SeqCst) {
-            let gui_handler = world.resources.get_mut::<GuiHandler>();
-
             self.visible.store(visibility, SeqCst);
 
             if visibility {

src/elements/label.rs

@@ -8,7 +8,6 @@ use super::{
     wrapper::{IconizableWrapper, TextableWrapper},
 };
 
-use ecs::World;
 use vulkan_rs::prelude::*;
 
 use std::sync::{
@@ -230,10 +229,8 @@ impl Visibility for Label {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible() {
-            let gui_handler = world.resources.get_mut::<GuiHandler>();
-
             self.visible.store(visibility, SeqCst);
 
             if visibility {

src/elements/multi_line_label.rs

@@ -6,7 +6,6 @@ use std::sync::{
 };
 
 use anyhow::{Context, Result};
-use ecs::World;
 use utilities::prelude::*;
 
 pub struct MultiLineLabelBuilder {
@@ -57,11 +56,7 @@ impl MultiLineLabelBuilder {
         self
     }
 
-    pub fn build(
+    pub fn build(self, gui_handler: &mut GuiHandler) -> Result<Arc<MultiLineLabel>> {
-        self,
-        world: &mut World,
-        gui_handler: &mut GuiHandler,
-    ) -> Result<Arc<MultiLineLabel>> {
         let base_grid = Grid::new(gui_handler, 1, self.line_count as usize, false)?;
         base_grid.set_margin(0);
         base_grid.set_padding(0);
@@ -77,7 +72,7 @@ impl MultiLineLabelBuilder {
                 .set_text_alignment(self.text_alignment)
                 .build(gui_handler)?;
 
-            base_grid.attach(world, label, 0, i as usize, 1, 1)?;
+            base_grid.attach(gui_handler, label, 0, i as usize, 1, 1)?;
         }
 
         Ok(Arc::new(MultiLineLabel {
@@ -189,7 +184,6 @@ impl MultiLineLabel {
 
     pub fn try_from(
         multi_line_label_info: &MultiLineLabelInfo,
-        world: &mut World,
         gui_handler: &mut GuiHandler,
     ) -> Result<Arc<Self>> {
         let text = multi_line_label_info.text.read().unwrap().clone();
@@ -218,7 +212,7 @@ impl MultiLineLabel {
             multi_line_label_builder = multi_line_label_builder.set_text(text);
         }
 
-        multi_line_label_builder.build(world, gui_handler)
+        multi_line_label_builder.build(gui_handler)
     }
 
     fn iter_label<F>(&self, mut f: F) -> Result<()>
@@ -256,8 +250,8 @@ impl Visibility for MultiLineLabel {
         self.grid.visible()
     }
 
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
-        self.grid.set_visibility(world, visibility)
+        self.grid.set_visibility(gui_handler, visibility)
     }
 }
 

src/elements/multi_line_textfield.rs

@@ -63,11 +63,7 @@ impl MultiLineTextFieldBuilder {
         self
     }
 
-    pub fn build(
+    pub fn build(self, gui_handler: &mut GuiHandler) -> Result<Arc<MultiLineTextField>> {
-        self,
-        world: &mut World,
-        gui_handler: &mut GuiHandler,
-    ) -> Result<Arc<MultiLineTextField>> {
         let base_grid = Grid::new(gui_handler, 1, self.line_count as usize, false)?;
         base_grid.set_margin(0);
         base_grid.set_padding(0);
@@ -83,7 +79,7 @@ impl MultiLineTextFieldBuilder {
                 .set_text_alignment(self.text_alignment)
                 .build(gui_handler)?;
 
-            base_grid.attach(world, label, 0, i as usize, 1, 1)?;
+            base_grid.attach(gui_handler, label, 0, i as usize, 1, 1)?;
         }
 
         let text = Arc::new(SplittedText::new(self.text));
@@ -309,7 +305,6 @@ impl MultiLineTextField {
 
     pub fn try_from(
         multi_line_text_field_info: &MultiLineTextFieldInfo,
-        world: &mut World,
         gui_handler: &mut GuiHandler,
     ) -> Result<Arc<Self>> {
         let text = multi_line_text_field_info.text.read().unwrap().clone();
@@ -338,7 +333,7 @@ impl MultiLineTextField {
             multi_line_text_field_builder = multi_line_text_field_builder.set_text(text);
         }
 
-        multi_line_text_field_builder.build(world, gui_handler)
+        multi_line_text_field_builder.build(gui_handler)
     }
 
     fn iter_label<F>(&self, mut f: F) -> Result<()>
@@ -376,10 +371,8 @@ impl Visibility for MultiLineTextField {
         self.grid.visible()
     }
 
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible() {
-            let gui_handler = world.resources.get_mut::<GuiHandler>();
-
             if visibility {
                 self.writeable.add(gui_handler)?;
             } else {
@@ -387,7 +380,7 @@ impl Visibility for MultiLineTextField {
             }
         }
 
-        self.grid.set_visibility(world, visibility)
+        self.grid.set_visibility(gui_handler, visibility)
     }
 }
 

src/elements/progress_bar.rs

@@ -1,7 +1,6 @@
 use crate::{builder::validator::progressbar_info::ProgressBarInfo, prelude::*};
 
 use anyhow::Result;
-use ecs::World;
 use std::sync::{
     Arc, Mutex,
     atomic::{AtomicBool, Ordering::SeqCst},
@@ -279,10 +278,8 @@ impl Visibility for ProgressBar {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible() {
-            let gui_handler = world.resources.get_mut::<GuiHandler>();
-
             self.visible.store(visibility, SeqCst);
 
             if visibility {

src/elements/textfield.rs

@@ -311,10 +311,8 @@ impl Visibility for TextField {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible() {
-            let gui_handler = world.resources.get_mut::<GuiHandler>();
-
             self.visible.store(visibility, SeqCst);
 
             if visibility {

src/elements/traits.rs

@@ -10,8 +10,8 @@ pub trait TopLevelGui: Send + Sync {
     fn top_gui(&self) -> Option<&dyn TopGui>;
     fn elements(&self) -> Option<&HashMap<String, UiElement>>;
     fn functionality(&self) -> Option<&dyn Functionality>;
-    fn enable(&self, world: &mut World) -> Result<()>;
+    fn enable(&self, gui_handler: &mut GuiHandler) -> Result<()>;
-    fn disable(&self, world: &mut World) -> Result<()>;
+    fn disable(&self, gui_handler: &mut GuiHandler) -> Result<()>;
 }
 
 pub fn any_to<T>(any: &dyn Any) -> Result<&T>
@@ -84,7 +84,7 @@ pub trait Gridable {
 
 pub trait Visibility {
     fn visible(&self) -> bool;
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()>;
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()>;
 }
 
 pub enum GuiElement<'a> {

src/keyboard/mod.rs

@@ -34,9 +34,9 @@ pub struct Keyboard {
 }
 
 impl Keyboard {
-    pub fn new(world: &mut World) -> Result<Arc<Self>> {
+    pub fn new(gui_handler: &mut GuiHandler) -> Result<Arc<Self>> {
         let text_field_gui: Arc<GuiBuilder> =
-            GuiBuilder::from_str(world, include_str!("text_field.xml"))?;
+            GuiBuilder::from_str(gui_handler, include_str!("text_field.xml"))?;
 
         let text_field: Arc<TextField> = text_field_gui.element("field")?;
 
@@ -51,7 +51,7 @@ impl Keyboard {
         let mode = Arc::new(RwLock::new(KeyboardMode::UpperCase));
 
         let (lower_case, upper_case, specials) = Self::setup(
-            world,
+            gui_handler,
             text_field.clone(),
             &mode,
             decline_callback.clone(),
@@ -83,7 +83,7 @@ impl Keyboard {
     }
 
     fn setup(
-        world: &mut World,
+        gui_handler: &mut GuiHandler,
         textfield: Arc<TextField>,
         mode: &Arc<RwLock<KeyboardMode>>,
         decline_callback: Arc<RwLock<Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>>>,
@@ -91,9 +91,9 @@ impl Keyboard {
             RwLock<Option<Box<dyn Fn(&mut World, &dyn Any) -> Result<()> + Send + Sync>>>,
         >,
     ) -> Result<(Arc<GuiBuilder>, Arc<GuiBuilder>, Arc<GuiBuilder>)> {
-        let lower_case = GuiBuilder::from_str(world, include_str!("lower_case.xml"))?;
+        let lower_case = GuiBuilder::from_str(gui_handler, include_str!("lower_case.xml"))?;
-        let upper_case = GuiBuilder::from_str(world, include_str!("upper_case.xml"))?;
+        let upper_case = GuiBuilder::from_str(gui_handler, include_str!("upper_case.xml"))?;
-        let specials = GuiBuilder::from_str(world, include_str!("specials.xml"))?;
+        let specials = GuiBuilder::from_str(gui_handler, include_str!("specials.xml"))?;
 
         // first row
         Self::set_text_callback(&lower_case, "q", textfield.clone())?;
@@ -235,8 +235,10 @@ impl Keyboard {
                         if let KeyboardMode::LowerCase = mode.deref() {
                             *mode = KeyboardMode::UpperCase;
 
-                            lower.disable(world)?;
+                            let gui_handler = world.resources.get_mut::<GuiHandler>();
-                            upper.enable(world)?;
+
+                            lower.disable(gui_handler)?;
+                            upper.enable(gui_handler)?;
                         }
                     }
                 }
@@ -258,8 +260,10 @@ impl Keyboard {
                         if let KeyboardMode::UpperCase = mode.deref() {
                             *mode = KeyboardMode::Specials;
 
-                            upper.disable(world)?;
+                            let gui_handler = world.resources.get_mut::<GuiHandler>();
-                            specials.enable(world)?;
+
+                            upper.disable(gui_handler)?;
+                            specials.enable(gui_handler)?;
                         }
                     }
                 }
@@ -281,8 +285,10 @@ impl Keyboard {
                         if let KeyboardMode::Specials = mode.deref() {
                             *mode = KeyboardMode::LowerCase;
 
-                            specials.disable(world)?;
+                            let gui_handler = world.resources.get_mut::<GuiHandler>();
-                            lower.enable(world)?;
+
+                            specials.disable(gui_handler)?;
+                            lower.enable(gui_handler)?;
                         }
                     }
                 }
@@ -388,7 +394,7 @@ impl Visibility for Keyboard {
         }
     }
 
-    fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         let mode = self.mode.read().unwrap();
 
         let gui = match mode.deref() {
@@ -398,11 +404,11 @@ impl Visibility for Keyboard {
         };
 
         if visibility {
-            gui.enable(world)?;
+            gui.enable(gui_handler)?;
-            self.text_field_gui.enable(world)?;
+            self.text_field_gui.enable(gui_handler)?;
         } else {
-            gui.disable(world)?;
+            gui.disable(gui_handler)?;
-            self.text_field_gui.disable(world)?;
+            self.text_field_gui.disable(gui_handler)?;
         }
 
         Ok(())
@@ -440,16 +446,15 @@ impl TopLevelGui for Keyboard {
         Some(self)
     }
 
-    fn enable(&self, world: &mut World) -> Result<()> {
+    fn enable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
-        self.set_visibility(world, true)?;
+        self.set_visibility(gui_handler, true)?;
-        self.text_field
+        self.text_field.focus_input(gui_handler)?;
-            .focus_input(world.resources.get_mut::<GuiHandler>())?;
 
         Ok(())
     }
 
-    fn disable(&self, world: &mut World) -> Result<()> {
+    fn disable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
-        self.set_visibility(world, false)?;
+        self.set_visibility(gui_handler, false)?;
 
         Ok(())
     }

src/states.rs

@@ -261,12 +261,14 @@ impl States {
     /// Adds a single state
     pub fn add_state<'a>(
         &mut self,
-        world: &mut World,
+        gui_handler: &mut GuiHandler,
         id: &str,
         creation_type: impl Into<CreationType<'a>>,
     ) -> Result<()> {
-        self.states
+        self.states.insert(
-            .insert(id.to_string(), State::new(world, id, creation_type.into())?);
+            id.to_string(),
+            State::new(gui_handler, id, creation_type.into())?,
+        );
 
         Ok(())
     }
@@ -312,13 +314,13 @@ impl States {
             }
 
             // execute deactivate on old state
-            old_state.deactivate(world)?;
+            old_state.deactivate(world, gui_handler)?;
         }
 
         // set new state, either no state or requested state
         match state {
             Some(state) => {
-                state.activate(world)?;
+                state.activate(world, gui_handler)?;
                 gui_handler.set_top_gui(Some(state.clone()));
 
                 if logging {
@@ -385,12 +387,12 @@ impl States {
 
 impl State {
     fn new<'a>(
-        world: &mut World,
+        gui_handler: &mut GuiHandler,
         name: &str,
         creation_type: CreationType<'a>,
     ) -> Result<Arc<Self>> {
         let gui = match creation_type {
-            CreationType::File(path) => GuiBuilder::new(world, path)?,
+            CreationType::File(path) => GuiBuilder::new(gui_handler, path)?,
             CreationType::TopGui(top_gui) => top_gui,
         };
 
@@ -443,8 +445,8 @@ impl State {
         }
     }
 
-    fn activate(&self, world: &mut World) -> Result<()> {
+    fn activate(&self, world: &mut World, gui_handler: &mut GuiHandler) -> Result<()> {
-        self.top_level_gui.enable(world)?;
+        self.top_level_gui.enable(gui_handler)?;
 
         if let Some(activate) = self.on_activate.read().unwrap().as_ref() {
             (activate)(world)?;
@@ -453,8 +455,8 @@ impl State {
         Ok(())
     }
 
-    fn deactivate(&self, world: &mut World) -> Result<()> {
+    fn deactivate(&self, world: &mut World, gui_handler: &mut GuiHandler) -> Result<()> {
-        self.top_level_gui.disable(world)?;
+        self.top_level_gui.disable(gui_handler)?;
 
         if let Some(deactivate) = self.on_deactivate.read().unwrap().as_ref() {
             (deactivate)(world)?;