From 2a77856cb8edb21a25cb54a3075044f2056f6d34 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michael=20H=C3=BCbner?= <michael.huebner@ptspaper.de>
Date: Tue, 4 Mar 2025 12:25:02 +0100
Subject: [PATCH] Revert from lifetimes

---
 src/elements/button.rs               |  76 +++++++---------
 src/elements/fill_type.rs            |  16 ++--
 src/elements/grid.rs                 | 126 +++++++++++++--------------
 src/elements/icon.rs                 |  44 +++++-----
 src/elements/label.rs                |  42 ++++-----
 src/elements/mod.rs                  |   2 +-
 src/elements/multi_line_label.rs     |  42 ++++-----
 src/elements/multi_line_textfield.rs |  59 ++++++-------
 src/elements/progress_bar.rs         |  34 ++++----
 src/elements/textfield.rs            |  38 ++++----
 src/elements/traits.rs               |  36 ++++----
 src/elements/ui_element.rs           |  32 +++----
 src/elements/wrapper.rs              |  28 +++---
 src/gui_handler/elements.rs          |  10 +--
 src/gui_handler/gui/clickable.rs     |  12 ++-
 src/gui_handler/gui/colorable.rs     |  10 +--
 src/gui_handler/gui/displayable.rs   |  10 +--
 src/gui_handler/gui/executable.rs    |  10 +--
 src/gui_handler/gui/framable.rs      |  24 ++---
 src/gui_handler/gui/hoverable.rs     |   6 +-
 src/gui_handler/gui/iconizable.rs    |  10 +--
 src/gui_handler/gui/selectable.rs    |  57 ++++++------
 src/gui_handler/gui/textable.rs      |  26 +++---
 src/gui_handler/gui/writeable.rs     |  38 ++++----
 src/gui_handler/gui_handler.rs       |  59 +++++++------
 src/keyboard/mod.rs                  |   2 +-
 26 files changed, 403 insertions(+), 446 deletions(-)

diff --git a/src/elements/button.rs b/src/elements/button.rs
index 4152020..539058c 100644
--- a/src/elements/button.rs
+++ b/src/elements/button.rs
@@ -116,7 +116,7 @@ impl ButtonBuilder {
         self
     }
 
-    pub fn build<'a>(self, gui_handler: &mut GuiHandler<'_>) -> Result<Arc<Button<'a>>> {
+    pub fn build(self, gui_handler: &mut GuiHandler) -> Result<Arc<Button>> {
         let framable = Framable::new(gui_handler.width(), gui_handler.height(), false)?;
 
         let normal = FillType::new(
@@ -256,10 +256,10 @@ pub enum ButtonSelectMode {
     Bigger,
 }
 
-pub struct Button<'a> {
+pub struct Button {
     clickable: Arc<Clickable>,
     hoverable: Arc<Hoverable>,
-    selectable: Arc<Selectable<'a>>,
+    selectable: Arc<Selectable>,
     framable: Arc<Framable>,
     iconizable: IconizableWrapper,
     textable: TextableWrapper,
@@ -271,7 +271,7 @@ pub struct Button<'a> {
     _hover_sound: Option<Arc<Audible>>,
 
     click_executable: Arc<Executable<()>>,
-    select_executable: Arc<Executable<(&'a mut GuiHandler<'a>, bool)>>,
+    select_executable: Arc<Executable<bool>>,
     on_select_executable: Arc<Executable<bool>>,
 
     normal: FillType,
@@ -283,7 +283,7 @@ pub struct Button<'a> {
     visible: AtomicBool,
 }
 
-impl<'a> Button<'a> {
+impl Button {
     pub fn builder() -> ButtonBuilder {
         ButtonBuilder {
             icon: None,
@@ -308,7 +308,7 @@ impl<'a> Button<'a> {
         }
     }
 
-    pub fn select(&self, gui_handler: &mut GuiHandler<'a>) -> Result<()> {
+    pub fn select(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.selectable.select(gui_handler)
     }
 
@@ -316,14 +316,15 @@ impl<'a> Button<'a> {
     where
         F: Fn() -> Result<()> + Send + Sync + 'static,
     {
-        self.click_executable.set_callback(move |_| callback());
+        self.click_executable.set_callback(move |_, _| callback());
     }
 
     pub fn set_select_callback<F>(&self, callback: F)
     where
         F: Fn(bool) -> Result<()> + Send + Sync + 'static,
     {
-        self.on_select_executable.set_callback(callback);
+        self.on_select_executable
+            .set_callback(|_m, select| callback(select));
     }
 
     pub fn set_custom_callback<F>(&self, callback: F)
@@ -333,19 +334,19 @@ impl<'a> Button<'a> {
         self.selectable.set_custom_callback(callback);
     }
 
-    pub fn set_text(&self, gui_handler: &mut GuiHandler<'_>, text: impl ToString) -> Result<()> {
+    pub fn set_text(&self, gui_handler: &mut GuiHandler, text: impl ToString) -> Result<()> {
         self.textable.set_text(gui_handler, text, self.visible())
     }
 
-    pub fn set_icon(&self, gui_handler: &mut GuiHandler<'_>, icon: &Arc<Image>) -> Result<()> {
+    pub fn set_icon(&self, gui_handler: &mut GuiHandler, icon: &Arc<Image>) -> Result<()> {
         self.iconizable.set_icon(gui_handler, icon, self.visible())
     }
 
-    pub fn set_icon_margon(&self, gui_handler: &mut GuiHandler<'_>, margin: u32) -> Result<()> {
+    pub fn set_icon_margon(&self, gui_handler: &mut GuiHandler, margin: u32) -> Result<()> {
         self.iconizable.set_margin(gui_handler, margin)
     }
 
-    pub fn clear_icon(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn clear_icon(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.iconizable.clear_icon(gui_handler, self.visible())
     }
 
@@ -353,15 +354,11 @@ impl<'a> Button<'a> {
         self.iconizable.icon()
     }
 
-    pub fn set_info_icon(
-        &self,
-        gui_handler: &mut GuiHandler<'_>,
-        button: &Arc<Image>,
-    ) -> Result<()> {
+    pub fn set_info_icon(&self, gui_handler: &mut GuiHandler, button: &Arc<Image>) -> Result<()> {
         self.info_icon.set_icon(gui_handler, button, self.visible())
     }
 
-    pub fn clear_info_icon(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn clear_info_icon(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.info_icon.clear_icon(gui_handler, self.visible())
     }
 
@@ -369,18 +366,11 @@ impl<'a> Button<'a> {
         self.textable.text()
     }
 
-    pub fn set_text_color(
-        &self,
-        gui_handler: &mut GuiHandler<'_>,
-        text_color: Color,
-    ) -> Result<()> {
+    pub fn set_text_color(&self, gui_handler: &mut GuiHandler, text_color: Color) -> Result<()> {
         self.textable.set_text_color(gui_handler, text_color)
     }
 
-    pub fn try_from(
-        gui_handler: &mut GuiHandler<'_>,
-        button_info: &ButtonInfo,
-    ) -> Result<Arc<Self>> {
+    pub fn try_from(gui_handler: &mut GuiHandler, button_info: &ButtonInfo) -> Result<Arc<Self>> {
         let mut button_builder = Button::builder()
             .set_select_mode(button_info.select_mode)
             .set_isolate(button_info.isolate);
@@ -437,8 +427,8 @@ impl<'a> Button<'a> {
     }
 }
 
-impl<'a> GuiElementTraits<'a> for Button<'a> {
-    fn gridable(&self) -> Option<&dyn Gridable<'a>> {
+impl GuiElementTraits for Button {
+    fn gridable(&self) -> Option<&dyn Gridable> {
         Some(self)
     }
 
@@ -446,17 +436,17 @@ impl<'a> GuiElementTraits<'a> for Button<'a> {
         Some(self)
     }
 
-    fn downcast(&'a self) -> Option<GuiElement<'a>> {
+    fn downcast<'a>(&'a self) -> Option<GuiElement<'a>> {
         Some(GuiElement::Button(self))
     }
 }
 
-impl<'a> Visibility for Button<'a> {
+impl Visibility for Button {
     fn visible(&self) -> bool {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, gui_handler: &mut GuiHandler<'_>, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible.load(SeqCst) {
             self.visible.store(visibility, SeqCst);
 
@@ -483,10 +473,10 @@ impl<'a> Visibility for Button<'a> {
     }
 }
 
-impl<'a> Gridable<'a> for Button<'a> {
+impl Gridable for Button {
     fn set_frame(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x: i32,
         y: i32,
         w: u32,
@@ -510,7 +500,7 @@ impl<'a> Gridable<'a> for Button<'a> {
         Ok(())
     }
 
-    fn selectable(&self) -> Option<&Arc<Selectable<'a>>> {
+    fn selectable(&self) -> Option<&Arc<Selectable>> {
         Some(&self.selectable)
     }
 
@@ -539,7 +529,7 @@ impl<'a> Gridable<'a> for Button<'a> {
 }
 
 // private
-impl<'a> Button<'a> {
+impl Button {
     // fn create_hovered_changed_callback(button: Arc<Button>) -> Result<()> {
     //     let button_weak = Arc::downgrade(&button);
 
@@ -562,7 +552,7 @@ impl<'a> Button<'a> {
     //         .set_hovered_changed_callback(Some(hovered_changed))
     // }
 
-    fn create_clicked_changed_callback(button: Arc<Button<'a>>) {
+    fn create_clicked_changed_callback(button: Arc<Button>) {
         let button_weak = Arc::downgrade(&button);
 
         let clicked_changed = Box::new(move |gui_handler| {
@@ -584,7 +574,7 @@ impl<'a> Button<'a> {
             .set_clicked_changed_callback(Some(clicked_changed));
     }
 
-    fn create_selected_changed_callback(button: Arc<Button<'a>>) {
+    fn create_selected_changed_callback(button: Arc<Button>) {
         let button_weak = Arc::downgrade(&button);
 
         let selected_changed = move |(gui_handler, selected)| {
@@ -602,7 +592,7 @@ impl<'a> Button<'a> {
         button.select_executable.set_callback(selected_changed);
     }
 
-    fn modify_hovered_vbo(&self, gui_handler: &GuiHandler<'_>) -> Result<()> {
+    fn modify_hovered_vbo(&self, gui_handler: &GuiHandler) -> Result<()> {
         assert!(
             self.framable.is_framed(),
             "button frame needs to be defined before hovering can be calculated"
@@ -657,7 +647,7 @@ impl<'a> Button<'a> {
         Ok(())
     }
 
-    fn disable_base(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    fn disable_base(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.framable.delete(gui_handler)?;
 
         self.selectable.delete(gui_handler)?;
@@ -677,7 +667,7 @@ impl<'a> Button<'a> {
     #[inline]
     fn set_button_state(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         button_state: ButtonState,
     ) -> Result<()> {
         let mut current_button_state = self.button_state.lock().unwrap();
@@ -709,8 +699,8 @@ impl<'a> Button<'a> {
     }
 }
 
-impl<'a> Deref for Button<'a> {
-    type Target = Arc<Selectable<'a>>;
+impl Deref for Button {
+    type Target = Arc<Selectable>;
 
     fn deref(&self) -> &Self::Target {
         &self.selectable
diff --git a/src/elements/fill_type.rs b/src/elements/fill_type.rs
index 018bb16..3bbc4f7 100644
--- a/src/elements/fill_type.rs
+++ b/src/elements/fill_type.rs
@@ -61,7 +61,7 @@ pub(crate) enum InnerFillType {
 
 impl InnerFillType {
     pub(crate) fn new(
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         framable: Arc<Framable>,
         fill_type_info: FillTypeInfo,
     ) -> Result<Self> {
@@ -84,7 +84,7 @@ impl InnerFillType {
         }
     }
 
-    pub(crate) fn enable(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn enable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         match self {
             Self::Image(displayable) => displayable.add(gui_handler)?,
             Self::Color(colorable) => colorable.add(gui_handler)?,
@@ -93,7 +93,7 @@ impl InnerFillType {
         Ok(())
     }
 
-    pub(crate) fn disable(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn disable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         match self {
             Self::Image(displayable) => displayable.delete(gui_handler)?,
             Self::Color(colorable) => colorable.delete(gui_handler)?,
@@ -102,7 +102,7 @@ impl InnerFillType {
         Ok(())
     }
 
-    pub(crate) fn update_frame(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn update_frame(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         match self {
             Self::Image(displayable) => displayable.update_frame(gui_handler)?,
             Self::Color(colorable) => colorable.update_frame(gui_handler)?,
@@ -128,7 +128,7 @@ pub(crate) struct FillType {
 
 impl FillType {
     pub(crate) fn new(
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         framable: Arc<Framable>,
         fill_type_info: FillTypeInfo,
     ) -> Result<Self> {
@@ -142,7 +142,7 @@ impl FillType {
         Ok(me)
     }
 
-    pub(crate) fn enable(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn enable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         if !self.visible.load(SeqCst) {
             self.visible.store(true, SeqCst);
             self.inner.enable(gui_handler)?;
@@ -151,7 +151,7 @@ impl FillType {
         Ok(())
     }
 
-    pub(crate) fn disable(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn disable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         if self.visible.load(SeqCst) {
             self.visible.store(false, SeqCst);
             self.inner.disable(gui_handler)?;
@@ -160,7 +160,7 @@ impl FillType {
         Ok(())
     }
 
-    pub(crate) fn update_frame(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn update_frame(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.inner.update_frame(gui_handler)
     }
 
diff --git a/src/elements/grid.rs b/src/elements/grid.rs
index d205f67..16d1992 100644
--- a/src/elements/grid.rs
+++ b/src/elements/grid.rs
@@ -19,21 +19,21 @@ pub enum ConnectDirection {
 }
 
 #[derive(Clone)]
-enum ChildState<'a> {
+enum ChildState {
     Some {
-        child: Arc<dyn GuiElementTraits<'a>>,
+        child: Arc<dyn GuiElementTraits>,
         x: u32,
         y: u32,
     },
     Extend {
-        weak_child: Weak<dyn GuiElementTraits<'a>>,
+        weak_child: Weak<dyn GuiElementTraits>,
         x: u32,
         y: u32,
     },
     None,
 }
 
-impl<'a> ChildState<'a> {
+impl ChildState {
     fn downgrade(&self) -> Self {
         match self {
             Self::Some { child, x, y } => Self::Extend {
@@ -62,7 +62,7 @@ impl<'a> ChildState<'a> {
         }
     }
 
-    fn get_some(&self) -> Option<(&Arc<dyn GuiElementTraits<'a>>, u32, u32)> {
+    fn get_some(&self) -> Option<(&Arc<dyn GuiElementTraits>, u32, u32)> {
         match self {
             ChildState::Some { child, x, y } => Some((child, *x, *y)),
             ChildState::Extend { .. } => None,
@@ -70,7 +70,7 @@ impl<'a> ChildState<'a> {
         }
     }
 
-    fn get(&self) -> Option<(Arc<dyn GuiElementTraits<'a>>, u32, u32)> {
+    fn get(&self) -> Option<(Arc<dyn GuiElementTraits>, u32, u32)> {
         match self {
             ChildState::Some { child, x, y } => Some((child.clone(), *x, *y)),
             ChildState::Extend { weak_child, x, y } => {
@@ -82,7 +82,7 @@ impl<'a> ChildState<'a> {
 
     fn map<C, R>(&self, f: C) -> Option<R>
     where
-        C: FnOnce(&Arc<dyn GuiElementTraits<'a>>) -> R,
+        C: FnOnce(&Arc<dyn GuiElementTraits>) -> R,
     {
         match self {
             ChildState::Some { child, .. } => Some(f(child)),
@@ -92,11 +92,11 @@ impl<'a> ChildState<'a> {
     }
 }
 
-pub struct Grid<'a> {
+pub struct Grid {
     pub(crate) framable: Arc<Framable>,
     background: RwLock<Option<FillType>>,
 
-    children: RwLock<Vec<Vec<ChildState<'a>>>>,
+    children: RwLock<Vec<Vec<ChildState>>>,
 
     dim_x: usize,
     dim_y: usize,
@@ -107,9 +107,9 @@ pub struct Grid<'a> {
     visible: AtomicBool,
 }
 
-impl<'a> Grid<'a> {
+impl Grid {
     pub fn new(
-        gui_handler: &GuiHandler<'a>,
+        gui_handler: &GuiHandler,
         dim_x: usize,
         dim_y: usize,
         top_level: bool,
@@ -129,20 +129,20 @@ impl<'a> Grid<'a> {
             visible: AtomicBool::new(false),
         });
 
-        if top_level {
-            let weak_grid = Arc::downgrade(&grid);
+        // if top_level {
+        //     let weak_grid = Arc::downgrade(&grid);
 
-            grid.framable.add_callback(
-                weak_grid.clone(),
-                Box::new(move |gui_handler| {
-                    if let Some(grid) = weak_grid.upgrade() {
-                        grid.calculate_child_positions(gui_handler)?;
-                    }
+        //     grid.framable.add_callback(
+        //         weak_grid.clone(),
+        //         Box::new(move |gui_handler| {
+        //             if let Some(grid) = weak_grid.upgrade() {
+        //                 grid.calculate_child_positions(gui_handler)?;
+        //             }
 
-                    Ok(())
-                }),
-            );
-        }
+        //             Ok(())
+        //         }),
+        //     );
+        // }
 
         Ok(grid)
     }
@@ -153,7 +153,7 @@ impl<'a> Grid<'a> {
 
     pub fn set_background(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         background: impl Into<FillTypeInfo>,
     ) -> Result<()> {
         super::set_background(
@@ -177,7 +177,7 @@ impl<'a> Grid<'a> {
         self.padding.store(padding, SeqCst);
     }
 
-    pub fn child_at(&self, x: usize, y: usize) -> Result<Option<Arc<dyn GuiElementTraits<'a>>>> {
+    pub fn child_at(&self, x: usize, y: usize) -> Result<Option<Arc<dyn GuiElementTraits>>> {
         if x >= self.dim_x {
             return Err(anyhow::anyhow!(
                 "Tried to access Grid at {} while only being {} wide",
@@ -199,10 +199,10 @@ impl<'a> Grid<'a> {
 
     pub fn detach(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         pos_x: usize,
         pos_y: usize,
-    ) -> Result<Option<Arc<dyn GuiElementTraits<'a>>>> {
+    ) -> Result<Option<Arc<dyn GuiElementTraits>>> {
         if cfg!(debug_assertions) {
             if pos_x >= self.dim_x as usize {
                 panic!(
@@ -244,8 +244,8 @@ impl<'a> Grid<'a> {
     /// Returns `true` if item got detached
     pub fn detach_item(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
-        item: Arc<dyn GuiElementTraits<'a>>,
+        gui_handler: &mut GuiHandler,
+        item: Arc<dyn GuiElementTraits>,
     ) -> Result<bool> {
         let mut grid = self.children.write().unwrap();
         let mut removed = false;
@@ -288,7 +288,7 @@ impl<'a> Grid<'a> {
         Ok(removed)
     }
 
-    pub fn set_position(&self, gui_handler: &mut GuiHandler<'_>, x: i32, y: i32) -> Result<()> {
+    pub fn set_position(&self, gui_handler: &mut GuiHandler, x: i32, y: i32) -> Result<()> {
         // update own position
         self.framable.change_position(gui_handler, x, y)?;
 
@@ -301,7 +301,7 @@ impl<'a> Grid<'a> {
         Ok(())
     }
 
-    fn calculate_child_positions(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    fn calculate_child_positions(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         // recalculate positions of the children
         let children = self.children.read().unwrap();
 
@@ -329,18 +329,18 @@ impl<'a> Grid<'a> {
         (width, height)
     }
 
-    pub fn disallow_position_scale(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn disallow_position_scale(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.framable.allow_position_scale(gui_handler, false)
     }
 
-    pub fn disallow_size_scale(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn disallow_size_scale(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.framable.allow_size_scale(gui_handler, false)
     }
 
     pub fn connect(
         &self,
         direction: ConnectDirection,
-        elements: impl IntoIterator<Item = (usize, &'a Arc<Selectable<'a>>)>,
+        elements: impl IntoIterator<Item = (usize, &Arc<Selectable>)>,
     ) -> Result<()> {
         for (index, selectable) in elements {
             match direction {
@@ -408,8 +408,8 @@ impl<'a> Grid<'a> {
 
     pub fn attach(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
-        child: Arc<dyn GuiElementTraits<'a>>,
+        gui_handler: &mut GuiHandler,
+        child: Arc<dyn GuiElementTraits>,
         pos_x: usize,
         pos_y: usize,
         dim_x: u32,
@@ -500,7 +500,7 @@ impl<'a> Grid<'a> {
 
     pub fn try_from(
         grid_info: &GridInfo,
-        gui_handler: &mut GuiHandler<'a>,
+        gui_handler: &mut GuiHandler,
         top_level: bool,
     ) -> Result<Arc<Self>> {
         let grid = Grid::new(
@@ -522,7 +522,7 @@ impl<'a> Grid<'a> {
 
     pub fn change_position_unscaled(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x: i32,
         y: i32,
     ) -> Result<()> {
@@ -539,8 +539,8 @@ impl<'a> Grid<'a> {
 
     fn child_position(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
-        child: &dyn Gridable<'_>,
+        gui_handler: &mut GuiHandler,
+        child: &dyn Gridable,
         pos_x: usize,
         pos_y: usize,
         dim_x: u32,
@@ -605,7 +605,7 @@ impl<'a> Grid<'a> {
         Ok(())
     }
 
-    pub fn select(&self, gui_handler: &mut GuiHandler<'_>, x: u32, y: u32) -> Result<()> {
+    pub fn select(&self, gui_handler: &mut GuiHandler, x: u32, y: u32) -> Result<()> {
         match self.children.read().unwrap()[x as usize][y as usize].get_some() {
             Some((child, ..)) => match child.gridable() {
                 Some(gridable) => match gridable.selectable() {
@@ -622,7 +622,7 @@ impl<'a> Grid<'a> {
         }
     }
 
-    fn disable_tree(&self, 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() {
@@ -634,7 +634,7 @@ impl<'a> Grid<'a> {
         Ok(())
     }
 
-    fn set_tree_visibility(&self, gui_handler: &mut GuiHandler<'_>, 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() {
@@ -652,8 +652,8 @@ impl<'a> Grid<'a> {
 
     #[inline]
     fn set_neighbours(
-        grid: &Vec<Vec<ChildState<'_>>>,
-        current_child: &Arc<Selectable<'a>>,
+        grid: &Vec<Vec<ChildState>>,
+        current_child: &Arc<Selectable>,
         pos: (usize, usize),
         dim: (usize, usize),
     ) -> Result<()> {
@@ -674,8 +674,8 @@ impl<'a> Grid<'a> {
 
     #[inline]
     fn set_north_neighbour(
-        grid: &Vec<Vec<ChildState<'_>>>,
-        current_child: &Arc<Selectable<'a>>,
+        grid: &Vec<Vec<ChildState>>,
+        current_child: &Arc<Selectable>,
         pos: (usize, usize),
         dim: (usize, usize),
     ) -> Result<bool> {
@@ -692,8 +692,8 @@ impl<'a> Grid<'a> {
 
     #[inline]
     fn set_south_neighbour(
-        grid: &Vec<Vec<ChildState<'_>>>,
-        current_child: &Arc<Selectable<'a>>,
+        grid: &Vec<Vec<ChildState>>,
+        current_child: &Arc<Selectable>,
         pos: (usize, usize),
         dim: (usize, usize),
     ) -> Result<bool> {
@@ -710,8 +710,8 @@ impl<'a> Grid<'a> {
 
     #[inline]
     fn set_east_neighbour(
-        grid: &Vec<Vec<ChildState<'_>>>,
-        current_child: &Arc<Selectable<'a>>,
+        grid: &Vec<Vec<ChildState>>,
+        current_child: &Arc<Selectable>,
         pos: (usize, usize),
         dim: (usize, usize),
     ) -> Result<bool> {
@@ -728,8 +728,8 @@ impl<'a> Grid<'a> {
 
     #[inline]
     fn set_west_neighbour(
-        grid: &Vec<Vec<ChildState<'_>>>,
-        current_child: &Arc<Selectable<'a>>,
+        grid: &Vec<Vec<ChildState>>,
+        current_child: &Arc<Selectable>,
         pos: (usize, usize),
         dim: (usize, usize),
     ) -> Result<bool> {
@@ -746,11 +746,11 @@ impl<'a> Grid<'a> {
 
     #[inline]
     fn search_neighbour_in_direction(
-        grid: &Vec<Vec<ChildState<'_>>>,
+        grid: &Vec<Vec<ChildState>>,
         pos: (usize, usize),
         dir: (i32, i32),
         dim: (usize, usize),
-    ) -> Option<Arc<Selectable<'a>>> {
+    ) -> Option<Arc<Selectable>> {
         let (mut x, mut y) = pos;
         let (x_step, y_step) = dir;
         let (dim_x, dim_y) = dim;
@@ -774,8 +774,8 @@ impl<'a> Grid<'a> {
     }
 }
 
-impl<'a> GuiElementTraits<'a> for Grid<'a> {
-    fn gridable(&self) -> Option<&dyn Gridable<'a>> {
+impl GuiElementTraits for Grid {
+    fn gridable(&self) -> Option<&dyn Gridable> {
         Some(self)
     }
 
@@ -783,17 +783,17 @@ impl<'a> GuiElementTraits<'a> for Grid<'a> {
         Some(self)
     }
 
-    fn downcast(&'a self) -> Option<GuiElement<'a>> {
+    fn downcast<'a>(&'a self) -> Option<GuiElement<'a>> {
         Some(GuiElement::Grid(self))
     }
 }
 
-impl<'a> Visibility for Grid<'a> {
+impl Visibility for Grid {
     fn visible(&self) -> bool {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, gui_handler: &mut GuiHandler<'_>, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible.load(SeqCst) {
             self.visible.store(visibility, SeqCst);
 
@@ -814,10 +814,10 @@ impl<'a> Visibility for Grid<'a> {
     }
 }
 
-impl<'a> Gridable<'a> for Grid<'a> {
+impl Gridable for Grid {
     fn set_frame(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x: i32,
         y: i32,
         w: u32,
@@ -837,7 +837,7 @@ impl<'a> Gridable<'a> for Grid<'a> {
         Ok(())
     }
 
-    fn selectable(&self) -> Option<&Arc<Selectable<'a>>> {
+    fn selectable(&self) -> Option<&Arc<Selectable>> {
         None
     }
 
diff --git a/src/elements/icon.rs b/src/elements/icon.rs
index b8c0da4..76abc50 100644
--- a/src/elements/icon.rs
+++ b/src/elements/icon.rs
@@ -65,7 +65,7 @@ impl IconBuilder {
         self
     }
 
-    pub fn build(self, gui_handler: &mut GuiHandler<'_>) -> Result<Arc<Icon>> {
+    pub fn build(self, gui_handler: &mut GuiHandler) -> Result<Arc<Icon>> {
         let framable = Framable::new(gui_handler.width(), gui_handler.height(), false)?;
 
         let iconizable_wrapper = IconizableWrapper::new(
@@ -141,32 +141,32 @@ impl Icon {
         }
     }
 
-    pub fn clear_icon(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn clear_icon(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.iconizable_wrapper
             .clear_icon(gui_handler, self.visible())
     }
 
-    pub fn set_icon(&self, gui_handler: &mut GuiHandler<'_>, icon: &Arc<Image>) -> Result<()> {
+    pub fn set_icon(&self, gui_handler: &mut GuiHandler, icon: &Arc<Image>) -> Result<()> {
         self.iconizable_wrapper
             .set_icon(gui_handler, icon, self.visible())
     }
 
     pub fn set_icon_from_path(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         asset_path: AssetPath,
     ) -> Result<()> {
         self.iconizable_wrapper
             .set_icon(gui_handler, asset_path, self.visible())
     }
 
-    pub fn set_margin(&self, gui_handler: &mut GuiHandler<'_>, margin: u32) -> Result<()> {
+    pub fn set_margin(&self, gui_handler: &mut GuiHandler, margin: u32) -> Result<()> {
         self.iconizable_wrapper.set_margin(gui_handler, margin)
     }
 
     pub fn set_background(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         background: impl Into<FillTypeInfo>,
     ) -> Result<()> {
         super::set_background(
@@ -182,33 +182,29 @@ impl Icon {
         *self.background.write().unwrap() = None;
     }
 
-    pub fn set_text(&self, gui_handler: &mut GuiHandler<'_>, text: impl ToString) -> Result<()> {
+    pub fn set_text(&self, gui_handler: &mut GuiHandler, text: impl ToString) -> Result<()> {
         self.textable_wrapper
             .set_text(gui_handler, text, self.visible())
     }
 
-    pub fn clear_text(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn clear_text(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.textable_wrapper
             .set_text(gui_handler, "", self.visible())
     }
 
-    pub fn set_text_color(&self, gui_handler: &mut GuiHandler<'_>, color: Color) -> Result<()> {
+    pub fn set_text_color(&self, gui_handler: &mut GuiHandler, color: Color) -> Result<()> {
         self.textable_wrapper.set_text_color(gui_handler, color)
     }
 
-    pub fn set_info_icon(
-        &self,
-        gui_handler: &mut GuiHandler<'_>,
-        button: &Arc<Image>,
-    ) -> Result<()> {
+    pub fn set_info_icon(&self, gui_handler: &mut GuiHandler, button: &Arc<Image>) -> Result<()> {
         self.info_icon.set_icon(gui_handler, button, self.visible())
     }
 
-    pub fn clear_info_icon(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn clear_info_icon(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.info_icon.clear_icon(gui_handler, self.visible())
     }
 
-    pub fn try_from(icon_info: &IconInfo, gui_handler: &mut GuiHandler<'_>) -> Result<Arc<Self>> {
+    pub fn try_from(icon_info: &IconInfo, gui_handler: &mut GuiHandler) -> Result<Arc<Self>> {
         let mut icon_builder = Icon::builder().set_text_color(icon_info.text_color);
 
         if let Some(text_ratio) = icon_info.text_ratio {
@@ -250,7 +246,7 @@ impl Icon {
         )
     }
 
-    fn disable_base(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    fn disable_base(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.framable.delete(gui_handler)?;
 
         self.iconizable_wrapper.disable(gui_handler)?;
@@ -265,8 +261,8 @@ impl Icon {
     }
 }
 
-impl<'a> GuiElementTraits<'a> for Icon {
-    fn gridable(&self) -> Option<&dyn Gridable<'a>> {
+impl GuiElementTraits for Icon {
+    fn gridable(&self) -> Option<&dyn Gridable> {
         Some(self)
     }
 
@@ -274,7 +270,7 @@ impl<'a> GuiElementTraits<'a> for Icon {
         Some(self)
     }
 
-    fn downcast(&'a self) -> Option<GuiElement<'a>> {
+    fn downcast<'a>(&'a self) -> Option<GuiElement<'a>> {
         Some(GuiElement::Icon(self))
     }
 }
@@ -284,7 +280,7 @@ impl Visibility for Icon {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, gui_handler: &mut GuiHandler<'_>, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible.load(SeqCst) {
             self.visible.store(visibility, SeqCst);
 
@@ -307,10 +303,10 @@ impl Visibility for Icon {
     }
 }
 
-impl<'a> Gridable<'a> for Icon {
+impl Gridable for Icon {
     fn set_frame(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x: i32,
         y: i32,
         w: u32,
@@ -332,7 +328,7 @@ impl<'a> Gridable<'a> for Icon {
         Ok(())
     }
 
-    fn selectable(&self) -> Option<&Arc<Selectable<'a>>> {
+    fn selectable(&self) -> Option<&Arc<Selectable>> {
         None
     }
 
diff --git a/src/elements/label.rs b/src/elements/label.rs
index 3660d16..6c5a4b3 100644
--- a/src/elements/label.rs
+++ b/src/elements/label.rs
@@ -57,7 +57,7 @@ impl LabelBuilder {
         self
     }
 
-    pub fn build(self, gui_handler: &mut GuiHandler<'_>) -> Result<Arc<Label>> {
+    pub fn build(self, gui_handler: &mut GuiHandler) -> Result<Arc<Label>> {
         let framable = Framable::new(gui_handler.width(), gui_handler.height(), false)?;
 
         let textable_wrapper = TextableWrapper::new(
@@ -121,7 +121,7 @@ impl Label {
         }
     }
 
-    pub fn set_text(&self, gui_handler: &mut GuiHandler<'_>, text: impl ToString) -> Result<()> {
+    pub fn set_text(&self, gui_handler: &mut GuiHandler, text: impl ToString) -> Result<()> {
         self.textable_wrapper
             .set_text(gui_handler, text, self.visible())
     }
@@ -130,24 +130,20 @@ impl Label {
         self.textable_wrapper.text()
     }
 
-    pub fn set_text_color(
-        &self,
-        gui_handler: &mut GuiHandler<'_>,
-        text_color: Color,
-    ) -> Result<()> {
+    pub fn set_text_color(&self, gui_handler: &mut GuiHandler, text_color: Color) -> Result<()> {
         self.textable_wrapper
             .set_text_color(gui_handler, text_color)
     }
 
     pub fn set_alignment(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         alignment: TextAlignment,
     ) -> Result<()> {
         self.textable_wrapper.set_alignment(gui_handler, alignment)
     }
 
-    pub fn set_text_ratio(&self, gui_handler: &mut GuiHandler<'_>, ratio: f32) -> Result<()> {
+    pub fn set_text_ratio(&self, gui_handler: &mut GuiHandler, ratio: f32) -> Result<()> {
         self.textable_wrapper.set_height_ratio(gui_handler, ratio)
     }
 
@@ -155,21 +151,17 @@ impl Label {
         self.textable_wrapper.height_ratio()
     }
 
-    pub fn set_info_icon(
-        &self,
-        gui_handler: &mut GuiHandler<'_>,
-        button: &Arc<Image>,
-    ) -> Result<()> {
+    pub fn set_info_icon(&self, gui_handler: &mut GuiHandler, button: &Arc<Image>) -> Result<()> {
         self.info_icon.set_icon(gui_handler, button, self.visible())
     }
 
-    pub fn clear_info_icon(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn clear_info_icon(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.info_icon.clear_icon(gui_handler, self.visible())
     }
 
     pub fn set_background(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         background: impl Into<FillTypeInfo>,
     ) -> Result<()> {
         super::set_background(
@@ -181,7 +173,7 @@ impl Label {
         )
     }
 
-    pub fn try_from(label_info: &LabelInfo, gui_handler: &mut GuiHandler<'_>) -> Result<Arc<Self>> {
+    pub fn try_from(label_info: &LabelInfo, gui_handler: &mut GuiHandler) -> Result<Arc<Self>> {
         let text = label_info.text.read().unwrap().clone();
         let color = label_info.text_color;
 
@@ -204,7 +196,7 @@ impl Label {
         label_builder.build(gui_handler)
     }
 
-    fn disable_base(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    fn disable_base(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.framable.delete(gui_handler)?;
 
         self.textable_wrapper.disable(gui_handler)?;
@@ -218,8 +210,8 @@ impl Label {
     }
 }
 
-impl<'a> GuiElementTraits<'a> for Label {
-    fn gridable(&self) -> Option<&dyn Gridable<'a>> {
+impl GuiElementTraits for Label {
+    fn gridable(&self) -> Option<&dyn Gridable> {
         Some(self)
     }
 
@@ -227,7 +219,7 @@ impl<'a> GuiElementTraits<'a> for Label {
         Some(self)
     }
 
-    fn downcast(&'a self) -> Option<GuiElement<'a>> {
+    fn downcast<'a>(&'a self) -> Option<GuiElement<'a>> {
         Some(GuiElement::Label(self))
     }
 }
@@ -237,7 +229,7 @@ impl Visibility for Label {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, gui_handler: &mut GuiHandler<'_>, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible() {
             self.visible.store(visibility, SeqCst);
 
@@ -259,10 +251,10 @@ impl Visibility for Label {
     }
 }
 
-impl<'a> Gridable<'a> for Label {
+impl Gridable for Label {
     fn set_frame(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x: i32,
         y: i32,
         w: u32,
@@ -283,7 +275,7 @@ impl<'a> Gridable<'a> for Label {
         Ok(())
     }
 
-    fn selectable(&self) -> Option<&Arc<Selectable<'a>>> {
+    fn selectable(&self) -> Option<&Arc<Selectable>> {
         None
     }
 
diff --git a/src/elements/mod.rs b/src/elements/mod.rs
index f562948..4393d69 100644
--- a/src/elements/mod.rs
+++ b/src/elements/mod.rs
@@ -22,7 +22,7 @@ pub mod prelude;
 mod wrapper;
 
 pub(crate) fn set_background(
-    gui_handler: &mut GuiHandler<'_>,
+    gui_handler: &mut GuiHandler,
     visible: bool,
     framable: &Arc<Framable>,
     current: &RwLock<Option<FillType>>,
diff --git a/src/elements/multi_line_label.rs b/src/elements/multi_line_label.rs
index 9d5a5f6..b93e1ce 100644
--- a/src/elements/multi_line_label.rs
+++ b/src/elements/multi_line_label.rs
@@ -56,7 +56,7 @@ impl MultiLineLabelBuilder {
         self
     }
 
-    pub fn build<'a>(self, gui_handler: &mut GuiHandler<'a>) -> Result<Arc<MultiLineLabel<'a>>> {
+    pub fn build(self, 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);
@@ -85,15 +85,15 @@ impl MultiLineLabelBuilder {
     }
 }
 
-pub struct MultiLineLabel<'a> {
-    grid: Arc<Grid<'a>>,
+pub struct MultiLineLabel {
+    grid: Arc<Grid>,
 
     characters_per_line: AtomicU32,
     text: Mutex<String>,
     splits: Mutex<Vec<String>>,
 }
 
-impl<'a> MultiLineLabel<'a> {
+impl MultiLineLabel {
     pub fn builder() -> MultiLineLabelBuilder {
         MultiLineLabelBuilder {
             text_alignment: TextAlignment::Center,
@@ -107,13 +107,13 @@ impl<'a> MultiLineLabel<'a> {
         }
     }
 
-    pub fn set_text(&self, gui_handler: &mut GuiHandler<'_>, text: impl ToString) -> Result<()> {
+    pub fn set_text(&self, gui_handler: &mut GuiHandler, text: impl ToString) -> Result<()> {
         *self.text.lock().unwrap() = text.to_string();
 
         self.update_text(gui_handler)
     }
 
-    fn update_text(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    fn update_text(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         let text = self.text.lock().unwrap();
         let splits = text.split(' ');
         let character_count = self.characters_per_line.load(SeqCst) as usize;
@@ -158,29 +158,25 @@ impl<'a> MultiLineLabel<'a> {
         self.text.lock().unwrap().clone()
     }
 
-    pub fn set_text_color(
-        &self,
-        gui_handler: &mut GuiHandler<'_>,
-        text_color: Color,
-    ) -> Result<()> {
+    pub fn set_text_color(&self, gui_handler: &mut GuiHandler, text_color: Color) -> Result<()> {
         self.iter_label(|label, _| label.set_text_color(gui_handler, text_color))
     }
 
     pub fn set_alignment(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         alignment: TextAlignment,
     ) -> Result<()> {
         self.iter_label(|label, _| label.set_alignment(gui_handler, alignment))
     }
 
-    pub fn set_text_ratio(&self, gui_handler: &mut GuiHandler<'_>, ratio: f32) -> Result<()> {
+    pub fn set_text_ratio(&self, gui_handler: &mut GuiHandler, ratio: f32) -> Result<()> {
         self.iter_label(|label, _| label.set_text_ratio(gui_handler, ratio))
     }
 
     pub fn set_background(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         background: impl Into<FillTypeInfo>,
     ) -> Result<()> {
         self.grid.set_background(gui_handler, background)
@@ -188,7 +184,7 @@ impl<'a> MultiLineLabel<'a> {
 
     pub fn try_from(
         multi_line_label_info: &MultiLineLabelInfo,
-        gui_handler: &mut GuiHandler<'a>,
+        gui_handler: &mut GuiHandler,
     ) -> Result<Arc<Self>> {
         let text = multi_line_label_info.text.read().unwrap().clone();
         let color = multi_line_label_info.text_color;
@@ -235,8 +231,8 @@ impl<'a> MultiLineLabel<'a> {
     }
 }
 
-impl<'a> GuiElementTraits<'a> for MultiLineLabel<'a> {
-    fn gridable(&self) -> Option<&dyn Gridable<'a>> {
+impl GuiElementTraits for MultiLineLabel {
+    fn gridable(&self) -> Option<&dyn Gridable> {
         Some(self)
     }
 
@@ -244,25 +240,25 @@ impl<'a> GuiElementTraits<'a> for MultiLineLabel<'a> {
         Some(self)
     }
 
-    fn downcast(&'a self) -> Option<GuiElement<'a>> {
+    fn downcast<'a>(&'a self) -> Option<GuiElement<'a>> {
         Some(GuiElement::MultiLineLabel(self))
     }
 }
 
-impl<'a> Visibility for MultiLineLabel<'a> {
+impl Visibility for MultiLineLabel {
     fn visible(&self) -> bool {
         self.grid.visible()
     }
 
-    fn set_visibility(&self, gui_handler: &mut GuiHandler<'_>, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         self.grid.set_visibility(gui_handler, visibility)
     }
 }
 
-impl<'a> Gridable<'a> for MultiLineLabel<'a> {
+impl Gridable for MultiLineLabel {
     fn set_frame(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x: i32,
         y: i32,
         w: u32,
@@ -299,7 +295,7 @@ impl<'a> Gridable<'a> for MultiLineLabel<'a> {
         Ok(())
     }
 
-    fn selectable(&self) -> Option<&Arc<Selectable<'a>>> {
+    fn selectable(&self) -> Option<&Arc<Selectable>> {
         None
     }
 
diff --git a/src/elements/multi_line_textfield.rs b/src/elements/multi_line_textfield.rs
index 7b67a58..86cbc92 100644
--- a/src/elements/multi_line_textfield.rs
+++ b/src/elements/multi_line_textfield.rs
@@ -62,10 +62,7 @@ impl MultiLineTextFieldBuilder {
         self
     }
 
-    pub fn build<'a>(
-        self,
-        gui_handler: &mut GuiHandler<'a>,
-    ) -> Result<Arc<MultiLineTextField<'a>>> {
+    pub fn build(self, 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);
@@ -99,7 +96,7 @@ impl MultiLineTextFieldBuilder {
         multi_line_text_field.text_changed_exec.set_callback({
             let weak_tf = Arc::downgrade(&multi_line_text_field);
 
-            move |(gui_handler, _text)| {
+            move |gui_handler: &mut GuiHandler, _text| {
                 if let Some(tf) = weak_tf.upgrade() {
                     tf.update_text(gui_handler)?;
                 }
@@ -176,13 +173,13 @@ impl SplittedText {
 }
 
 impl ModifyText for SplittedText {
-    fn set_text(&self, _gui_handler: &mut GuiHandler<'_>, text: String) -> Result<()> {
+    fn set_text(&self, _gui_handler: &mut GuiHandler, text: String) -> Result<()> {
         *self.text.lock().unwrap() = text;
 
         self.update_text()
     }
 
-    fn add_letter(&self, _gui_handler: &mut GuiHandler<'_>, letter: char) -> Result<String> {
+    fn add_letter(&self, _gui_handler: &mut GuiHandler, letter: char) -> Result<String> {
         *self.text.lock().unwrap() += &format!("{}", letter);
 
         self.update_text()?;
@@ -190,7 +187,7 @@ impl ModifyText for SplittedText {
         Ok(self.text.lock().unwrap().clone())
     }
 
-    fn remove_last(&self, _gui_handler: &mut GuiHandler<'_>) -> Result<Option<String>> {
+    fn remove_last(&self, _gui_handler: &mut GuiHandler) -> Result<Option<String>> {
         self.text.lock().unwrap().pop();
 
         self.update_text()?;
@@ -200,15 +197,15 @@ impl ModifyText for SplittedText {
     }
 }
 
-pub struct MultiLineTextField<'a> {
-    grid: Arc<Grid<'a>>,
+pub struct MultiLineTextField {
+    grid: Arc<Grid>,
 
     text: Arc<SplittedText>,
-    text_changed_exec: Arc<Executable<(&'a mut GuiHandler<'a>, Option<String>)>>,
+    text_changed_exec: Arc<Executable<Option<String>>>,
     writeable: Arc<Writeable>,
 }
 
-impl<'a> MultiLineTextField<'a> {
+impl MultiLineTextField {
     pub fn builder() -> MultiLineTextFieldBuilder {
         MultiLineTextFieldBuilder {
             text_alignment: TextAlignment::Center,
@@ -222,11 +219,11 @@ impl<'a> MultiLineTextField<'a> {
         }
     }
 
-    pub fn set_text(&self, gui_handler: &mut GuiHandler<'_>, text: impl ToString) -> Result<()> {
+    pub fn set_text(&self, gui_handler: &mut GuiHandler, text: impl ToString) -> Result<()> {
         self.text.set_text(gui_handler, text.to_string())
     }
 
-    fn update_text(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    fn update_text(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         let lines = self.text.lines();
 
         self.iter_label(|label, y| {
@@ -240,7 +237,7 @@ impl<'a> MultiLineTextField<'a> {
         })
     }
 
-    fn update_color_change(self: &Arc<Self>) {
+    fn update_color_change(self: &Arc<MultiLineTextField>) {
         if let Some(background) = &*self.grid.background() {
             if let InnerFillType::Color(colorable) = &background.inner {
                 let normal_color = colorable.color();
@@ -274,29 +271,25 @@ impl<'a> MultiLineTextField<'a> {
         self.text.text()
     }
 
-    pub fn set_text_color(
-        &self,
-        gui_handler: &mut GuiHandler<'_>,
-        text_color: Color,
-    ) -> Result<()> {
+    pub fn set_text_color(&self, gui_handler: &mut GuiHandler, text_color: Color) -> Result<()> {
         self.iter_label(|label, _| label.set_text_color(gui_handler, text_color))
     }
 
     pub fn set_alignment(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         alignment: TextAlignment,
     ) -> Result<()> {
         self.iter_label(|label, _| label.set_alignment(gui_handler, alignment))
     }
 
-    pub fn set_text_ratio(&self, gui_handler: &mut GuiHandler<'_>, ratio: f32) -> Result<()> {
+    pub fn set_text_ratio(&self, gui_handler: &mut GuiHandler, ratio: f32) -> Result<()> {
         self.iter_label(|label, _| label.set_text_ratio(gui_handler, ratio))
     }
 
     pub fn set_background(
         self: &Arc<Self>,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         background: impl Into<FillTypeInfo>,
     ) -> Result<()> {
         self.grid.set_background(gui_handler, background)?;
@@ -305,13 +298,13 @@ impl<'a> MultiLineTextField<'a> {
         Ok(())
     }
 
-    pub fn focus_input(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn focus_input(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.writeable.set_active(gui_handler)
     }
 
     pub fn try_from(
         multi_line_text_field_info: &MultiLineTextFieldInfo,
-        gui_handler: &mut GuiHandler<'a>,
+        gui_handler: &mut GuiHandler,
     ) -> Result<Arc<Self>> {
         let text = multi_line_text_field_info.text.read().unwrap().clone();
         let color = multi_line_text_field_info.text_color;
@@ -358,8 +351,8 @@ impl<'a> MultiLineTextField<'a> {
     }
 }
 
-impl<'a> GuiElementTraits<'a> for MultiLineTextField<'a> {
-    fn gridable(&self) -> Option<&dyn Gridable<'a>> {
+impl GuiElementTraits for MultiLineTextField {
+    fn gridable(&self) -> Option<&dyn Gridable> {
         Some(self)
     }
 
@@ -367,17 +360,17 @@ impl<'a> GuiElementTraits<'a> for MultiLineTextField<'a> {
         Some(self)
     }
 
-    fn downcast(&'a self) -> Option<GuiElement<'a>> {
+    fn downcast<'a>(&'a self) -> Option<GuiElement<'a>> {
         Some(GuiElement::MultiLineTextField(self))
     }
 }
 
-impl<'a> Visibility for MultiLineTextField<'a> {
+impl Visibility for MultiLineTextField {
     fn visible(&self) -> bool {
         self.grid.visible()
     }
 
-    fn set_visibility(&self, gui_handler: &mut GuiHandler<'_>, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible() {
             if visibility {
                 self.writeable.add(gui_handler)?;
@@ -390,10 +383,10 @@ impl<'a> Visibility for MultiLineTextField<'a> {
     }
 }
 
-impl<'a> Gridable<'a> for MultiLineTextField<'a> {
+impl Gridable for MultiLineTextField {
     fn set_frame(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x: i32,
         y: i32,
         w: u32,
@@ -429,7 +422,7 @@ impl<'a> Gridable<'a> for MultiLineTextField<'a> {
         Ok(())
     }
 
-    fn selectable(&self) -> Option<&Arc<Selectable<'a>>> {
+    fn selectable(&self) -> Option<&Arc<Selectable>> {
         None
     }
 
diff --git a/src/elements/progress_bar.rs b/src/elements/progress_bar.rs
index 76af164..b361715 100644
--- a/src/elements/progress_bar.rs
+++ b/src/elements/progress_bar.rs
@@ -74,7 +74,7 @@ impl ProgressBarBuilder {
         self
     }
 
-    pub fn build(self, gui_handler: &mut GuiHandler<'_>) -> Result<Arc<ProgressBar>> {
+    pub fn build(self, gui_handler: &mut GuiHandler) -> Result<Arc<ProgressBar>> {
         let framable = Framable::new(gui_handler.width(), gui_handler.height(), false)?;
 
         let background = self
@@ -140,7 +140,7 @@ impl ProgressBar {
         }
     }
 
-    pub fn set_progress(&self, gui_handler: &mut GuiHandler<'_>, mut progress: f32) -> Result<()> {
+    pub fn set_progress(&self, gui_handler: &mut GuiHandler, mut progress: f32) -> Result<()> {
         if progress < 0.0 {
             progress = 0.0;
         } else if progress > 1.0 {
@@ -181,27 +181,23 @@ impl ProgressBar {
         Ok(())
     }
 
-    pub fn set_text(&self, gui_handler: &mut GuiHandler<'_>, text: impl ToString) -> Result<()> {
+    pub fn set_text(&self, gui_handler: &mut GuiHandler, text: impl ToString) -> Result<()> {
         self.textable_wrapper
             .set_text(gui_handler, text, self.visible())
     }
 
-    pub fn set_text_color(
-        &self,
-        gui_handler: &mut GuiHandler<'_>,
-        text_color: Color,
-    ) -> Result<()> {
+    pub fn set_text_color(&self, gui_handler: &mut GuiHandler, text_color: Color) -> Result<()> {
         self.textable_wrapper
             .set_text_color(gui_handler, text_color)
     }
 
-    pub fn set_text_ratio(&self, gui_handler: &mut GuiHandler<'_>, ratio: f32) -> Result<()> {
+    pub fn set_text_ratio(&self, gui_handler: &mut GuiHandler, ratio: f32) -> Result<()> {
         self.textable_wrapper.set_height_ratio(gui_handler, ratio)
     }
 
     pub fn set_text_alignment(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         text_alignment: TextAlignment,
     ) -> Result<()> {
         self.textable_wrapper
@@ -210,7 +206,7 @@ impl ProgressBar {
 
     pub fn try_from(
         progress_bar_info: &ProgressBarInfo,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
     ) -> Result<Arc<Self>> {
         let mut progress_bar_builder = ProgressBar::builder()
             .set_text_alignment(progress_bar_info.text_alignment)
@@ -246,7 +242,7 @@ impl ProgressBar {
         *self.progress.lock().unwrap()
     }
 
-    fn disable_base(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    fn disable_base(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.framable.delete(gui_handler)?;
 
         if let Some(background) = &self.background {
@@ -263,8 +259,8 @@ impl ProgressBar {
     }
 }
 
-impl<'a> GuiElementTraits<'a> for ProgressBar {
-    fn gridable(&self) -> Option<&dyn Gridable<'a>> {
+impl GuiElementTraits for ProgressBar {
+    fn gridable(&self) -> Option<&dyn Gridable> {
         Some(self)
     }
 
@@ -272,7 +268,7 @@ impl<'a> GuiElementTraits<'a> for ProgressBar {
         Some(self)
     }
 
-    fn downcast(&'a self) -> Option<GuiElement<'a>> {
+    fn downcast<'a>(&'a self) -> Option<GuiElement<'a>> {
         Some(GuiElement::ProgressBar(self))
     }
 }
@@ -282,7 +278,7 @@ impl Visibility for ProgressBar {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, gui_handler: &mut GuiHandler<'_>, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible() {
             self.visible.store(visibility, SeqCst);
 
@@ -307,10 +303,10 @@ impl Visibility for ProgressBar {
     }
 }
 
-impl<'a> Gridable<'a> for ProgressBar {
+impl Gridable for ProgressBar {
     fn set_frame(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x: i32,
         y: i32,
         w: u32,
@@ -334,7 +330,7 @@ impl<'a> Gridable<'a> for ProgressBar {
         Ok(())
     }
 
-    fn selectable(&self) -> Option<&Arc<Selectable<'a>>> {
+    fn selectable(&self) -> Option<&Arc<Selectable>> {
         None
     }
 
diff --git a/src/elements/textfield.rs b/src/elements/textfield.rs
index 9ddb5cf..283c685 100644
--- a/src/elements/textfield.rs
+++ b/src/elements/textfield.rs
@@ -48,7 +48,7 @@ impl TextFieldBuilder {
         self
     }
 
-    pub fn build(self, gui_handler: &mut GuiHandler<'_>) -> Result<Arc<TextField>> {
+    pub fn build(self, gui_handler: &mut GuiHandler) -> Result<Arc<TextField>> {
         let framable = Framable::new(gui_handler.width(), gui_handler.height(), false)?;
 
         let background = RwLock::new(
@@ -114,7 +114,7 @@ impl TextField {
         }
     }
 
-    pub fn try_from(info: &TextFieldInfo, gui_handler: &mut GuiHandler<'_>) -> Result<Arc<Self>> {
+    pub fn try_from(info: &TextFieldInfo, gui_handler: &mut GuiHandler) -> Result<Arc<Self>> {
         let text = info.text.read().unwrap().clone();
         let color = info.text_color;
 
@@ -169,20 +169,16 @@ impl TextField {
 
     pub fn set_text_changed_callback<F>(&self, f: F)
     where
-        F: Fn(Option<String>) -> Result<()> + Send + Sync + 'static,
+        F: Fn(&mut GuiHandler, Option<String>) -> Result<()> + Send + Sync + 'static,
     {
         self.text_changed_executable.set_callback(f);
     }
 
-    pub fn set_text_color(
-        &self,
-        gui_handler: &mut GuiHandler<'_>,
-        text_color: Color,
-    ) -> Result<()> {
+    pub fn set_text_color(&self, gui_handler: &mut GuiHandler, text_color: Color) -> Result<()> {
         self.textable.set_text_color(gui_handler, text_color)
     }
 
-    pub fn set_text(&self, gui_handler: &mut GuiHandler<'_>, text: impl ToString) -> Result<()> {
+    pub fn set_text(&self, gui_handler: &mut GuiHandler, text: impl ToString) -> Result<()> {
         self.textable.set_text(gui_handler, text)
     }
 
@@ -194,7 +190,7 @@ impl TextField {
 
     pub fn set_background(
         self: &Arc<Self>,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         background: impl Into<FillTypeInfo>,
     ) -> Result<()> {
         super::set_background(
@@ -220,19 +216,19 @@ impl TextField {
         None
     }
 
-    pub fn add_letter(&self, gui_handler: &mut GuiHandler<'_>, letter: char) -> Result<()> {
+    pub fn add_letter(&self, gui_handler: &mut GuiHandler, letter: char) -> Result<()> {
         self.writeable.add_letter(gui_handler, letter)
     }
 
-    pub fn remove_last(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn remove_last(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.writeable.remove_last(gui_handler)
     }
 
-    pub fn focus_input(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn focus_input(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.writeable.set_active(gui_handler)
     }
 
-    fn disable_base(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    fn disable_base(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.framable.delete(gui_handler)?;
         self.textable.delete(gui_handler)?;
         self.writeable.delete(gui_handler)?;
@@ -245,8 +241,8 @@ impl TextField {
     }
 }
 
-impl<'a> GuiElementTraits<'a> for TextField {
-    fn gridable(&self) -> Option<&dyn Gridable<'a>> {
+impl GuiElementTraits for TextField {
+    fn gridable(&self) -> Option<&dyn Gridable> {
         Some(self)
     }
 
@@ -254,15 +250,15 @@ impl<'a> GuiElementTraits<'a> for TextField {
         Some(self)
     }
 
-    fn downcast(&'a self) -> Option<GuiElement<'a>> {
+    fn downcast<'a>(&'a self) -> Option<GuiElement<'a>> {
         Some(GuiElement::TextField(self))
     }
 }
 
-impl<'a> Gridable<'a> for TextField {
+impl Gridable for TextField {
     fn set_frame(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x: i32,
         y: i32,
         w: u32,
@@ -282,7 +278,7 @@ impl<'a> Gridable<'a> for TextField {
         Ok(())
     }
 
-    fn selectable(&self) -> Option<&Arc<Selectable<'a>>> {
+    fn selectable(&self) -> Option<&Arc<Selectable>> {
         None
     }
 
@@ -314,7 +310,7 @@ impl Visibility for TextField {
         self.visible.load(SeqCst)
     }
 
-    fn set_visibility(&self, gui_handler: &mut GuiHandler<'_>, visibility: bool) -> Result<()> {
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
         if visibility != self.visible() {
             self.visible.store(visibility, SeqCst);
 
diff --git a/src/elements/traits.rs b/src/elements/traits.rs
index b939a7b..600b358 100644
--- a/src/elements/traits.rs
+++ b/src/elements/traits.rs
@@ -4,10 +4,10 @@ use anyhow::Result;
 use std::{any::Any, collections::HashMap, sync::Arc};
 
 // simulate trait upcasting
-pub trait TopLevelGui<'a>: Send + Sync {
-    fn gui_traits(&self) -> &dyn GuiElementTraits<'a>;
+pub trait TopLevelGui: Send + Sync {
+    fn gui_traits(&self) -> &dyn GuiElementTraits;
     fn top_gui(&self) -> Option<&dyn TopGui>;
-    fn elements(&self) -> Option<&HashMap<String, UiElement<'a>>>;
+    fn elements(&self) -> Option<&HashMap<String, UiElement>>;
     fn functionality(&self) -> Option<&dyn Functionality>;
     fn enable(&self) -> Result<()>;
     fn disable(&self) -> Result<()>;
@@ -45,16 +45,16 @@ pub trait Functionality {
     ) -> Result<()>;
 }
 
-pub trait GuiElementTraits<'a>: Send + Sync {
-    fn gridable(&self) -> Option<&dyn Gridable<'a>>;
+pub trait GuiElementTraits: Send + Sync {
+    fn gridable(&self) -> Option<&dyn Gridable>;
     fn visibility(&self) -> Option<&dyn Visibility>;
-    fn downcast(&'a self) -> Option<GuiElement<'a>>;
+    fn downcast<'a>(&'a self) -> Option<GuiElement<'a>>;
 }
 
-pub trait Gridable<'a> {
+pub trait Gridable {
     fn set_frame(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x: i32,
         y: i32,
         w: u32,
@@ -63,7 +63,7 @@ pub trait Gridable<'a> {
         hori_align: HorizontalAlign,
     ) -> Result<()>;
 
-    fn selectable(&self) -> Option<&Arc<Selectable<'a>>>;
+    fn selectable(&self) -> Option<&Arc<Selectable>>;
 
     fn type_name(&self) -> &str;
 
@@ -74,15 +74,15 @@ pub trait Gridable<'a> {
 
 pub trait Visibility {
     fn visible(&self) -> bool;
-    fn set_visibility(&self, gui_handler: &mut GuiHandler<'_>, visibility: bool) -> Result<()>;
+    fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()>;
 }
 
 pub enum GuiElement<'a> {
-    Button(&'a Button<'a>),
-    Grid(&'a Grid<'a>),
+    Button(&'a Button),
+    Grid(&'a Grid),
     Label(&'a Label),
-    MultiLineLabel(&'a MultiLineLabel<'a>),
-    MultiLineTextField(&'a MultiLineTextField<'a>),
+    MultiLineLabel(&'a MultiLineLabel),
+    MultiLineTextField(&'a MultiLineTextField),
     TextField(&'a TextField),
     Icon(&'a Icon),
     ProgressBar(&'a ProgressBar),
@@ -92,14 +92,14 @@ pub enum GuiElement<'a> {
 }
 
 impl<'a> GuiElement<'a> {
-    pub fn button(&self) -> Option<&Button<'a>> {
+    pub fn button(&self) -> Option<&Button> {
         match self {
             Self::Button(button) => Some(button),
             _ => None,
         }
     }
 
-    pub fn grid(&self) -> Option<&Grid<'a>> {
+    pub fn grid(&self) -> Option<&Grid> {
         match self {
             Self::Grid(grid) => Some(grid),
             _ => None,
@@ -113,14 +113,14 @@ impl<'a> GuiElement<'a> {
         }
     }
 
-    pub fn multi_line_label(&self) -> Option<&MultiLineLabel<'a>> {
+    pub fn multi_line_label(&self) -> Option<&MultiLineLabel> {
         match self {
             Self::MultiLineLabel(multi_line_label) => Some(multi_line_label),
             _ => None,
         }
     }
 
-    pub fn multi_line_text_field(&self) -> Option<&MultiLineTextField<'a>> {
+    pub fn multi_line_text_field(&self) -> Option<&MultiLineTextField> {
         match self {
             Self::MultiLineTextField(multi_line_text_field) => Some(multi_line_text_field),
             _ => None,
diff --git a/src/elements/ui_element.rs b/src/elements/ui_element.rs
index 06b2858..25fe671 100644
--- a/src/elements/ui_element.rs
+++ b/src/elements/ui_element.rs
@@ -5,19 +5,19 @@ use std::collections::HashMap;
 use std::fmt::{Debug, Formatter};
 use std::sync::{Arc, Weak};
 
-pub enum UiElement<'a> {
-    Button(Weak<Button<'a>>),
-    Grid(Weak<Grid<'a>>),
+pub enum UiElement {
+    Button(Weak<Button>),
+    Grid(Weak<Grid>),
     Label(Weak<Label>),
-    MultiLineLabel(Weak<MultiLineLabel<'a>>),
-    MultiLineTextField(Weak<MultiLineTextField<'a>>),
+    MultiLineLabel(Weak<MultiLineLabel>),
+    MultiLineTextField(Weak<MultiLineTextField>),
     TextField(Weak<TextField>),
     Icon(Weak<Icon>),
     ProgressBar(Weak<ProgressBar>),
     GuiSnippet(Weak<GuiSnippet>),
 }
 
-impl<'a> Debug for UiElement<'a> {
+impl Debug for UiElement {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             UiElement::Button(_) => write!(f, "Button"),
@@ -35,7 +35,7 @@ impl<'a> Debug for UiElement<'a> {
 
 macro_rules! impl_from {
     ($data_type:ident $(< $($lt:lifetime),+ >)? ) => {
-        impl<'a> From<&Arc<$data_type$(<$($lt,)+>)?>> for UiElement<'a> {
+        impl<'a> From<&Arc<$data_type$(<$($lt,)+>)?>> for UiElement {
             fn from(v: &Arc<$data_type$(<$($lt,)+>)?>) -> Self {
                 UiElement::$data_type(Arc::downgrade(v))
             }
@@ -43,11 +43,11 @@ macro_rules! impl_from {
     };
 }
 
-impl_from!(Button<'a>);
-impl_from!(Grid<'a>);
+impl_from!(Button);
+impl_from!(Grid);
 impl_from!(Label);
-impl_from!(MultiLineLabel<'a>);
-impl_from!(MultiLineTextField<'a>);
+impl_from!(MultiLineLabel);
+impl_from!(MultiLineTextField);
 impl_from!(TextField);
 impl_from!(Icon);
 impl_from!(ProgressBar);
@@ -59,7 +59,7 @@ pub trait GetElement<T> {
 
 macro_rules! impl_element {
     ($data_type:ident $(< $($lt:lifetime),+ >)? ) => {
-        impl<'a> GetElement<$data_type$(<$($lt,)+>)?> for HashMap<String, UiElement<'a>> {
+        impl<'a> GetElement<$data_type$(<$($lt,)+>)?> for HashMap<String, UiElement> {
             fn element(&self, id: &str) -> Result<Arc<$data_type$(<$($lt,)+>)?>> {
                 match self.get(id) {
                     Some(element) => match element {
@@ -83,11 +83,11 @@ macro_rules! impl_element {
     };
 }
 
-impl_element!(Button<'a>);
-impl_element!(Grid<'a>);
+impl_element!(Button);
+impl_element!(Grid);
 impl_element!(Label);
-impl_element!(MultiLineLabel<'a>);
-impl_element!(MultiLineTextField<'a>);
+impl_element!(MultiLineLabel);
+impl_element!(MultiLineTextField);
 impl_element!(TextField);
 impl_element!(Icon);
 impl_element!(ProgressBar);
diff --git a/src/elements/wrapper.rs b/src/elements/wrapper.rs
index 4f5d127..4ab57b6 100644
--- a/src/elements/wrapper.rs
+++ b/src/elements/wrapper.rs
@@ -50,7 +50,7 @@ impl TextableWrapper {
 
     pub(crate) fn set_text_color(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         text_color: Color,
     ) -> Result<()> {
         *self.color.lock().unwrap() = text_color;
@@ -64,7 +64,7 @@ impl TextableWrapper {
 
     pub(crate) fn set_text(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         text: impl ToString,
         is_visible: bool,
     ) -> Result<()> {
@@ -125,7 +125,7 @@ impl TextableWrapper {
 
     pub(crate) fn set_height_ratio(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         height_ratio: f32,
     ) -> Result<()> {
         *self.ratio.lock().unwrap() = height_ratio;
@@ -143,7 +143,7 @@ impl TextableWrapper {
 
     pub(crate) fn set_alignment(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         alignment: TextAlignment,
     ) -> Result<()> {
         *self.alignment.lock().unwrap() = alignment;
@@ -155,7 +155,7 @@ impl TextableWrapper {
         Ok(())
     }
 
-    pub(crate) fn update(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn update(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         if let Some(textable) = self.textable.lock().unwrap().as_ref() {
             textable.update_text(gui_handler)?;
         }
@@ -163,7 +163,7 @@ impl TextableWrapper {
         Ok(())
     }
 
-    pub(crate) fn enable(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn enable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         if let Some(textable) = self.textable.lock().unwrap().as_ref() {
             textable.add(gui_handler)?;
         }
@@ -171,7 +171,7 @@ impl TextableWrapper {
         Ok(())
     }
 
-    pub(crate) fn disable(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn disable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         if let Some(textable) = self.textable.lock().unwrap().as_ref() {
             textable.delete(gui_handler)?;
         }
@@ -198,7 +198,7 @@ pub(crate) struct IconizableWrapper {
 
 impl IconizableWrapper {
     pub(crate) fn new(
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         framable: Arc<Framable>,
         builder: Option<IconBuilderType>,
         positioning: Option<IconizablePositioning>,
@@ -236,7 +236,7 @@ impl IconizableWrapper {
 
     pub(crate) fn clear_icon(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         is_visible: bool,
     ) -> Result<()> {
         let mut iconizable = self.iconizable.lock().unwrap();
@@ -256,7 +256,7 @@ impl IconizableWrapper {
 
     pub(crate) fn set_icon(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         icon_builder: impl Into<IconBuilderType>,
         is_visible: bool,
     ) -> Result<()> {
@@ -291,7 +291,7 @@ impl IconizableWrapper {
         Ok(())
     }
 
-    pub(crate) fn set_margin(&self, gui_handler: &mut GuiHandler<'_>, margin: u32) -> Result<()> {
+    pub(crate) fn set_margin(&self, gui_handler: &mut GuiHandler, margin: u32) -> Result<()> {
         if self.framable.is_framed() {
             if let Some(iconizable) = self.iconizable.lock().unwrap().as_ref() {
                 iconizable.set_margin(margin)?;
@@ -311,7 +311,7 @@ impl IconizableWrapper {
         }
     }
 
-    pub(crate) fn enable(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn enable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         if let Some(iconizable) = self.iconizable.lock().unwrap().as_ref() {
             iconizable.add(gui_handler)?;
         }
@@ -319,7 +319,7 @@ impl IconizableWrapper {
         Ok(())
     }
 
-    pub(crate) fn disable(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn disable(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         if let Some(iconizable) = self.iconizable.lock().unwrap().as_ref() {
             iconizable.delete(gui_handler)?;
         }
@@ -327,7 +327,7 @@ impl IconizableWrapper {
         Ok(())
     }
 
-    pub(crate) fn update_frame(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn update_frame(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         if let Some(iconizable) = self.iconizable.lock().unwrap().as_ref() {
             iconizable.update_frame(gui_handler)?;
         }
diff --git a/src/gui_handler/elements.rs b/src/gui_handler/elements.rs
index b364d12..cad954e 100644
--- a/src/gui_handler/elements.rs
+++ b/src/gui_handler/elements.rs
@@ -3,19 +3,19 @@ use std::{slice::Iter, sync::Arc};
 use crate::prelude::*;
 
 #[derive(Default)]
-pub struct Elements<'a> {
+pub struct Elements {
     framables: Vec<Arc<Framable>>,
     hoverables: Vec<Arc<Hoverable>>,
     clickables: Vec<Arc<Clickable>>,
     displayables: Vec<Arc<Displayable>>,
-    selectables: Vec<Arc<Selectable<'a>>>,
+    selectables: Vec<Arc<Selectable>>,
     textables: Vec<Arc<Textable>>,
     writeables: Vec<Arc<Writeable>>,
     iconizables: Vec<Arc<Iconizable>>,
     colorables: Vec<Arc<Colorable>>,
 }
 
-impl<'a> Elements<'a> {
+impl Elements {
     #[inline]
     fn push_element<T>(vector: &mut Vec<Arc<T>>, element: Arc<T>) {
         if cfg!(debug_assertions) && vector.iter().any(|e| Arc::ptr_eq(e, &element)) {
@@ -75,11 +75,11 @@ impl<'a> Elements<'a> {
     }
 
     // selectable
-    pub fn add_selectable(&mut self, selectable: Arc<Selectable<'a>>) {
+    pub fn add_selectable(&mut self, selectable: Arc<Selectable>) {
         Self::push_element(&mut self.selectables, selectable);
     }
 
-    pub fn delete_selectable(&mut self, selectable: &Arc<Selectable<'a>>) -> bool {
+    pub fn delete_selectable(&mut self, selectable: &Arc<Selectable>) -> bool {
         Self::erase_element(&mut self.selectables, selectable)
     }
 
diff --git a/src/gui_handler/gui/clickable.rs b/src/gui_handler/gui/clickable.rs
index 942f770..b89b0b9 100644
--- a/src/gui_handler/gui/clickable.rs
+++ b/src/gui_handler/gui/clickable.rs
@@ -26,7 +26,7 @@ pub struct Clickable {
 
     executable: Arc<Executable<()>>,
     clicked_changed_callback:
-        RwLock<Option<Box<dyn Fn(&mut GuiHandler<'_>) -> Result<()> + Send + Sync>>>,
+        RwLock<Option<Box<dyn Fn(&mut GuiHandler) -> Result<()> + Send + Sync>>>,
 }
 
 impl Clickable {
@@ -56,7 +56,7 @@ impl Clickable {
     /// # Arguments
     ///
     /// * `clickable` is a `&Arc<Clickable>` instance that is going to be added
-    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.add_clickable(self.ui_layer.load(SeqCst), self.clone())
     }
 
@@ -65,7 +65,7 @@ impl Clickable {
     /// # Arguments
     ///
     /// * `clickable` is a `&Arc<Clickable>` instance that is going to be deleted
-    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.delete_clickable(self.ui_layer.load(SeqCst), self)?;
         self.set_clicked(gui_handler, false)?;
 
@@ -90,9 +90,7 @@ impl Clickable {
     /// * `clicked_changed_callback` is a `Option<Box<Callback>>`
     pub fn set_clicked_changed_callback(
         &self,
-        clicked_changed_callback: Option<
-            Box<dyn Fn(&mut GuiHandler<'_>) -> Result<()> + Send + Sync>,
-        >,
+        clicked_changed_callback: Option<Box<dyn Fn(&mut GuiHandler) -> Result<()> + Send + Sync>>,
     ) {
         *self.clicked_changed_callback.write().unwrap() = clicked_changed_callback;
     }
@@ -102,7 +100,7 @@ impl Clickable {
         *self.audible.write().unwrap() = audible;
     }
 
-    pub fn set_clicked(&self, gui_handler: &mut GuiHandler<'_>, clicked: bool) -> Result<bool> {
+    pub fn set_clicked(&self, gui_handler: &mut GuiHandler, clicked: bool) -> Result<bool> {
         if self.clicked() != clicked {
             self.clicked.store(clicked, SeqCst);
 
diff --git a/src/gui_handler/gui/colorable.rs b/src/gui_handler/gui/colorable.rs
index 28fd6fb..6eeecdb 100644
--- a/src/gui_handler/gui/colorable.rs
+++ b/src/gui_handler/gui/colorable.rs
@@ -34,7 +34,7 @@ pub struct Colorable {
 impl Colorable {
     /// Factory method for `Colorable`, returns `Arc<Colorable>`.
     pub fn new(
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         framable: Arc<Framable>,
         color: Color,
         fill_type: DisplayableFillType,
@@ -80,7 +80,7 @@ impl Colorable {
     /// # Arguments
     ///
     /// * `colorable` is a `&Arc<Colorable>` instance that is going to be added
-    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.add_colorable(self.ui_layer.load(SeqCst), self.clone())
     }
 
@@ -89,7 +89,7 @@ impl Colorable {
     /// # Arguments
     ///
     /// * `colorable` is a `&Arc<Colorable>` instance that is going to be deleted
-    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.delete_colorable(self.ui_layer.load(SeqCst), self)
     }
 
@@ -107,7 +107,7 @@ impl Colorable {
     /// # Arguments
     ///
     /// * `color` defines the color
-    pub fn set_color(&self, gui_handler: &mut GuiHandler<'_>, color: Color) -> Result<()> {
+    pub fn set_color(&self, gui_handler: &mut GuiHandler, color: Color) -> Result<()> {
         let set = gui_handler.color_descriptor(color)?;
 
         *self.color.write().unwrap() = color;
@@ -147,7 +147,7 @@ impl Colorable {
     }
 
     /// Update frame method if the original frame is invalidated
-    pub fn update_frame(&self, gui_handler: &GuiHandler<'_>) -> Result<()> {
+    pub fn update_frame(&self, gui_handler: &GuiHandler) -> Result<()> {
         let mut frame = self.buffer.map_complete()?;
 
         let mut x_start = self.framable.left() as f32;
diff --git a/src/gui_handler/gui/displayable.rs b/src/gui_handler/gui/displayable.rs
index 4204e09..9eec9f2 100644
--- a/src/gui_handler/gui/displayable.rs
+++ b/src/gui_handler/gui/displayable.rs
@@ -71,7 +71,7 @@ impl Displayable {
     /// * `framable` is a `Arc<Framable>` instance
     /// * `name` is the name for a png
     pub fn new(
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         framable: Arc<Framable>,
         displayable_type: impl Into<DisplayableType>,
         fill_type: DisplayableFillType,
@@ -128,7 +128,7 @@ impl Displayable {
     /// # Arguments
     ///
     /// * `displayable` is a `&Arc<Displayable>` instance that is going to be added
-    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.add_displayable(self.ui_layer.load(SeqCst), self.clone())
     }
 
@@ -137,7 +137,7 @@ impl Displayable {
     /// # Arguments
     ///
     /// * `displayable` is a `&Arc<Displayable>` instance that is going to be deleted
-    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.delete_displayable(self.ui_layer.load(SeqCst), self)
     }
 
@@ -161,7 +161,7 @@ impl Displayable {
     /// * `name` is the name of the texture in `gui/` without `.png` suffix
     pub fn set_image(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         displayable_type: impl Into<DisplayableType>,
     ) -> Result<()> {
         let displayable_type = displayable_type.into();
@@ -233,7 +233,7 @@ impl Displayable {
     }
 
     /// Update frame method if the original frame is invalidated
-    pub fn update_frame(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn update_frame(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         let mut frame = self.buffer.map_complete()?;
 
         let mut x_start = self.framable.left() as f32;
diff --git a/src/gui_handler/gui/executable.rs b/src/gui_handler/gui/executable.rs
index dc169bf..ad8f231 100644
--- a/src/gui_handler/gui/executable.rs
+++ b/src/gui_handler/gui/executable.rs
@@ -7,8 +7,8 @@ use std::sync::{Arc, RwLock};
 use crate::prelude::*;
 
 /// `Executable` holds a closure which can be executed
-pub struct Executable<I: Send + Sync + 'static> {
-    callback: RwLock<Option<Arc<dyn Fn(I) -> Result<()> + Send + Sync>>>,
+pub struct Executable<I: Send + Sync> {
+    callback: RwLock<Option<Arc<dyn Fn(&mut GuiHandler, I) -> Result<()> + Send + Sync>>>,
 }
 
 impl<I: Send + Sync + 'static> Executable<I> {
@@ -26,7 +26,7 @@ impl<I: Send + Sync + 'static> Executable<I> {
     /// * `callback` is a `Option<Callback>` closure
     pub fn set_callback<F>(&self, callback: impl Into<Option<F>>)
     where
-        F: Fn(I) -> Result<()> + Send + Sync + 'static,
+        F: Fn(&mut GuiHandler, I) -> Result<()> + Send + Sync + 'static,
     {
         let mut function = self.callback.write().unwrap();
 
@@ -37,11 +37,11 @@ impl<I: Send + Sync + 'static> Executable<I> {
     }
 
     /// Execute the callback closure if possible
-    pub fn execute(&self, gui_handler: &mut GuiHandler<'_>, input: I) -> Result<()> {
+    pub fn execute(&self, gui_handler: &mut GuiHandler, input: I) -> Result<()> {
         if let Some(callback) = self.callback.read().unwrap().as_ref() {
             let callback = callback.clone();
 
-            gui_handler.add_callback(move || (callback)(input));
+            gui_handler.add_callback(move |gui_handler| (callback)(gui_handler, input));
         }
 
         Ok(())
diff --git a/src/gui_handler/gui/framable.rs b/src/gui_handler/gui/framable.rs
index d52609f..e262590 100644
--- a/src/gui_handler/gui/framable.rs
+++ b/src/gui_handler/gui/framable.rs
@@ -86,7 +86,7 @@ pub struct Framable {
     resize_callbacks: RwLock<
         Vec<(
             Handle,
-            Box<dyn Fn(&mut GuiHandler<'_>) -> Result<()> + Send + Sync>,
+            Box<dyn Fn(&mut GuiHandler) -> Result<()> + Send + Sync>,
         )>,
     >,
 
@@ -149,7 +149,7 @@ impl Framable {
     /// # Arguments
     ///
     /// * `framable` - is a `&Arc<Framable>` instance that is going to be added
-    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         // check if window size is the same as last time
         if gui_handler.width() != self.window_width.load(SeqCst)
             || gui_handler.height() != self.window_height.load(SeqCst)
@@ -174,7 +174,7 @@ impl Framable {
     /// # Arguments
     ///
     /// * `framable` - is a `&Arc<Framable>` instance that is going to be deleted
-    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         if self.resize_allowed() {
             gui_handler.delete_framable(self.ui_layer.load(SeqCst), self)?;
         }
@@ -192,7 +192,7 @@ impl Framable {
 
     pub(crate) fn set_reference_size(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         width: u32,
         height: u32,
     ) -> Result<()> {
@@ -209,7 +209,7 @@ impl Framable {
 
     pub(crate) fn allow_position_scale(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         allowed: bool,
     ) -> Result<()> {
         if allowed != self.reference_scale_position.load(SeqCst) {
@@ -225,7 +225,7 @@ impl Framable {
 
     pub(crate) fn allow_size_scale(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         allowed: bool,
     ) -> Result<()> {
         if allowed != self.reference_scale_size.load(SeqCst) {
@@ -247,7 +247,7 @@ impl Framable {
     /// width and a certain alignment
     pub fn set_frame(
         &self,
-        gui_handler: &GuiHandler<'_>,
+        gui_handler: &GuiHandler,
         x_off: i32,
         y_off: i32,
         w: u32,
@@ -311,7 +311,7 @@ impl Framable {
     pub fn add_callback(
         &self,
         handle: impl Into<Handle>,
-        callback: Box<dyn Fn(&mut GuiHandler<'_>) -> Result<()> + Send + Sync>,
+        callback: Box<dyn Fn(&mut GuiHandler) -> Result<()> + Send + Sync>,
     ) {
         let handle = handle.into();
 
@@ -354,7 +354,7 @@ impl Framable {
         *self.horizontal_alignment.read().unwrap()
     }
 
-    fn calculate_frame(&self, gui_handler: &GuiHandler<'_>) {
+    fn calculate_frame(&self, gui_handler: &GuiHandler) {
         let width = gui_handler.width();
         let height = gui_handler.height();
 
@@ -428,7 +428,7 @@ impl Framable {
 
     pub fn change_position(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x_offset: i32,
         y_offset: i32,
     ) -> Result<()> {
@@ -443,7 +443,7 @@ impl Framable {
     }
     pub fn change_position_unscaled(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         x: i32,
         y: i32,
     ) -> Result<()> {
@@ -469,7 +469,7 @@ impl Framable {
         Ok(())
     }
 
-    pub fn resize(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn resize(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.calculate_frame(gui_handler);
 
         for (_, callback) in self.resize_callbacks.read().unwrap().iter() {
diff --git a/src/gui_handler/gui/hoverable.rs b/src/gui_handler/gui/hoverable.rs
index 40274b9..72b3d52 100644
--- a/src/gui_handler/gui/hoverable.rs
+++ b/src/gui_handler/gui/hoverable.rs
@@ -56,7 +56,7 @@ impl Hoverable {
     /// # Arguments
     ///
     /// * `hoverable` is a `&Arc<Hoverable>` instance that is going to be added
-    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.add_hoverable(self.ui_layer.load(SeqCst), self.clone())?;
 
         Ok(())
@@ -67,7 +67,7 @@ impl Hoverable {
     /// # Arguments
     ///
     /// * `hoverable` is a `&Arc<Hoverable>` instance that is going to be deleted
-    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.delete_hoverable(self.ui_layer.load(SeqCst), self)?;
         self.set_hovered(gui_handler, false)?;
 
@@ -103,7 +103,7 @@ impl Hoverable {
     /// # Arguments
     ///
     /// * `hovered` is the new hovered state
-    pub fn set_hovered(&self, gui_handler: &mut GuiHandler<'_>, hovered: bool) -> Result<()> {
+    pub fn set_hovered(&self, gui_handler: &mut GuiHandler, hovered: bool) -> Result<()> {
         if self.hovered() != hovered {
             self.hovered.store(hovered, SeqCst);
 
diff --git a/src/gui_handler/gui/iconizable.rs b/src/gui_handler/gui/iconizable.rs
index b464e25..0f64b24 100644
--- a/src/gui_handler/gui/iconizable.rs
+++ b/src/gui_handler/gui/iconizable.rs
@@ -85,7 +85,7 @@ impl Iconizable {
     /// * `framable` is a `Arc<Framable>` instance
     /// * `icon` is a reference to an `Arc<Image>`
     pub fn new(
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         framable: Arc<Framable>,
         icon_builder: impl Into<IconBuilderType>,
         positioning: impl Into<Option<IconizablePositioning>>,
@@ -137,7 +137,7 @@ impl Iconizable {
     /// # Arguments
     ///
     /// * `iconizable` is a `&Arc<Iconizable>` instance that is going to be added
-    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.add_iconizable(self.ui_layer.load(SeqCst), self.clone())
     }
 
@@ -146,7 +146,7 @@ impl Iconizable {
     /// # Arguments
     ///
     /// * `iconizable` is a `&Arc<Iconizable>` instance that is going to be deleted
-    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.delete_iconizable(self.ui_layer.load(SeqCst), self)
     }
 
@@ -172,7 +172,7 @@ impl Iconizable {
     }
 
     /// Updates the frame
-    pub fn update_frame(&self, gui_handler: &GuiHandler<'_>) -> Result<()> {
+    pub fn update_frame(&self, gui_handler: &GuiHandler) -> Result<()> {
         assert!(self.framable.is_framed(), "framable is not framed yet");
 
         // frame parameter
@@ -269,7 +269,7 @@ impl Iconizable {
     /// * `icon` the new icon
     pub fn set_icon(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         icon_builder: impl Into<IconBuilderType>,
     ) -> Result<()> {
         let icon = gui_handler.request_icon(icon_builder)?;
diff --git a/src/gui_handler/gui/selectable.rs b/src/gui_handler/gui/selectable.rs
index 1522637..a4bfa80 100644
--- a/src/gui_handler/gui/selectable.rs
+++ b/src/gui_handler/gui/selectable.rs
@@ -12,13 +12,13 @@ use std::sync::{
 /// `Selectable` gives the ability to navigate per button or controller to
 /// optionally adjacent neighbour Selectables and to execute a closure
 /// when the current Selectable is pressed
-pub struct Selectable<'a> {
+pub struct Selectable {
     selected: AtomicBool,
 
-    east_neighbour: RwLock<Option<Weak<Selectable<'a>>>>,
-    west_neighbour: RwLock<Option<Weak<Selectable<'a>>>>,
-    north_neighbour: RwLock<Option<Weak<Selectable<'a>>>>,
-    south_neighbour: RwLock<Option<Weak<Selectable<'a>>>>,
+    east_neighbour: RwLock<Option<Weak<Selectable>>>,
+    west_neighbour: RwLock<Option<Weak<Selectable>>>,
+    north_neighbour: RwLock<Option<Weak<Selectable>>>,
+    south_neighbour: RwLock<Option<Weak<Selectable>>>,
 
     #[cfg(feature = "audio")]
     select_audible: RwLock<Option<Arc<Audible>>>,
@@ -30,29 +30,28 @@ pub struct Selectable<'a> {
     isolate: bool,
 
     // used when clicked
-    executable: Arc<Executable<&'a mut World>>,
+    executable: Arc<Executable<()>>,
 
     // used internally by button
-    selected_changed_executable: Arc<Executable<(&'a mut World, bool)>>,
+    selected_changed_executable: Arc<Executable<bool>>,
 
     // exposed externally for event
-    on_select_executable: Arc<Executable<(&'a mut World, bool)>>,
+    on_select_executable: Arc<Executable<bool>>,
 
     // used for custom buttons
-    custom_callback:
-        RwLock<Option<Box<dyn Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync>>>,
+    custom_callback: RwLock<Option<Box<dyn Fn(ControllerButton) -> Result<bool> + Send + Sync>>>,
 }
 
-impl<'a> Selectable<'a> {
+impl Selectable {
     /// Factory method for `Selectable`, returns `Arc<Selectable>`.
     ///
     /// # Arguments
     ///
     /// * `executable` is a `Arc<Executable>` instance
     pub fn new(
-        executable: Arc<Executable<&'a mut World>>,
-        selected_changed_executable: Arc<Executable<(&'a mut World, bool)>>,
-        on_select_executable: Arc<Executable<(&'a mut World, bool)>>,
+        executable: Arc<Executable<()>>,
+        selected_changed_executable: Arc<Executable<bool>>,
+        on_select_executable: Arc<Executable<bool>>,
         isolate: bool,
     ) -> Arc<Self> {
         Arc::new(Selectable {
@@ -85,7 +84,7 @@ impl<'a> Selectable<'a> {
     /// # Arguments
     ///
     /// * `selectable` is a `&Arc<Selectable>` instance that is going to be added
-    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.add_selectable(self.ui_layer.load(SeqCst), self.clone())
     }
 
@@ -94,7 +93,7 @@ impl<'a> Selectable<'a> {
     /// # Arguments
     ///
     /// * `selectable` is a `&Arc<Selectable>` instance that is going to be deleted
-    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.delete_selectable(self.ui_layer.load(SeqCst), self)?;
         self.set_selected(gui_handler, false)?;
 
@@ -110,7 +109,7 @@ impl<'a> Selectable<'a> {
     /// # Argument
     ///
     /// * `selectable` is a `Arc<Selectable>` instance
-    pub fn select(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn select(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.set_selectable(Some(self.clone()))
     }
 
@@ -137,7 +136,7 @@ impl<'a> Selectable<'a> {
     /// # Arguments
     ///
     /// * `selected` is the new selected state
-    pub fn set_selected(&self, gui_handler: &mut GuiHandler<'_>, selected: bool) -> Result<()> {
+    pub fn set_selected(&self, gui_handler: &mut GuiHandler, selected: bool) -> Result<()> {
         if self.selected() != selected {
             self.selected.store(selected, SeqCst);
 
@@ -164,7 +163,7 @@ impl<'a> Selectable<'a> {
     }
 
     /// Executes the `Executable`'s callback
-    pub(crate) fn click_event(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub(crate) fn click_event(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         #[cfg(feature = "audio")]
         {
             if let Some(audible) = self.click_audible.read().unwrap().as_ref() {
@@ -195,7 +194,7 @@ impl<'a> Selectable<'a> {
     }
 
     /// Returns the current east neighbour, if possible
-    pub fn east_neighbour(&self) -> Option<Arc<Selectable<'a>>> {
+    pub fn east_neighbour(&self) -> Option<Arc<Selectable>> {
         if let Some(weak_neighbour) = self.east_neighbour.read().unwrap().as_ref() {
             if let Some(neighbour) = weak_neighbour.upgrade() {
                 return Some(neighbour);
@@ -210,7 +209,7 @@ impl<'a> Selectable<'a> {
     /// # Arguments
     ///
     /// * `selectable` the new east neighbour
-    pub fn set_east_neighbour(&self, selectable: Option<&Arc<Selectable<'a>>>) {
+    pub fn set_east_neighbour(&self, selectable: Option<&Arc<Selectable>>) {
         if self.isolate {
             return;
         }
@@ -224,7 +223,7 @@ impl<'a> Selectable<'a> {
     }
 
     /// Returns the current west neighbour, if possible
-    pub fn west_neighbour(&self) -> Option<Arc<Selectable<'a>>> {
+    pub fn west_neighbour(&self) -> Option<Arc<Selectable>> {
         if let Some(weak_neighbour) = self.west_neighbour.read().unwrap().as_ref() {
             if let Some(neighbour) = weak_neighbour.upgrade() {
                 return Some(neighbour);
@@ -239,7 +238,7 @@ impl<'a> Selectable<'a> {
     /// # Arguments
     ///
     /// * `selectable` the new west neighbour
-    pub fn set_west_neighbour(&self, selectable: Option<&Arc<Selectable<'a>>>) {
+    pub fn set_west_neighbour(&self, selectable: Option<&Arc<Selectable>>) {
         if self.isolate {
             return;
         }
@@ -253,7 +252,7 @@ impl<'a> Selectable<'a> {
     }
 
     /// Returns the current north neighbour, if possible
-    pub fn north_neighbour(&self) -> Option<Arc<Selectable<'a>>> {
+    pub fn north_neighbour(&self) -> Option<Arc<Selectable>> {
         if let Some(weak_neighbour) = self.north_neighbour.read().unwrap().as_ref() {
             if let Some(neighbour) = weak_neighbour.upgrade() {
                 return Some(neighbour);
@@ -268,7 +267,7 @@ impl<'a> Selectable<'a> {
     /// # Argumnents
     ///
     /// * `selectable` the new north neighbour
-    pub fn set_north_neighbour(&self, selectable: Option<&Arc<Selectable<'a>>>) {
+    pub fn set_north_neighbour(&self, selectable: Option<&Arc<Selectable>>) {
         if self.isolate {
             return;
         }
@@ -282,7 +281,7 @@ impl<'a> Selectable<'a> {
     }
 
     /// Returns the current south neighbour, if possible
-    pub fn south_neighbour(&self) -> Option<Arc<Selectable<'a>>> {
+    pub fn south_neighbour(&self) -> Option<Arc<Selectable>> {
         if let Some(weak_neighbour) = self.south_neighbour.read().unwrap().as_ref() {
             if let Some(neighbour) = weak_neighbour.upgrade() {
                 return Some(neighbour);
@@ -297,7 +296,7 @@ impl<'a> Selectable<'a> {
     /// # Arguments
     ///
     /// * `selectable` the new south neighbour
-    pub fn set_south_neighbour(&self, selectable: Option<&Arc<Selectable<'a>>>) {
+    pub fn set_south_neighbour(&self, selectable: Option<&Arc<Selectable>>) {
         if self.isolate {
             return;
         }
@@ -310,7 +309,7 @@ impl<'a> Selectable<'a> {
         }
     }
 
-    pub fn connect_vertically<'c>(upper: &Arc<Selectable<'c>>, lower: &Arc<Selectable<'c>>) {
+    pub fn connect_vertically<'c>(upper: &Arc<Selectable>, lower: &Arc<Selectable>) {
         if upper.isolate || lower.isolate {
             return;
         }
@@ -319,7 +318,7 @@ impl<'a> Selectable<'a> {
         *lower.north_neighbour.write().unwrap() = Some(Arc::downgrade(upper));
     }
 
-    pub fn connect_horizontally<'c>(left: &Arc<Selectable<'c>>, right: &Arc<Selectable<'c>>) {
+    pub fn connect_horizontally<'c>(left: &Arc<Selectable>, right: &Arc<Selectable>) {
         if left.isolate || right.isolate {
             return;
         }
diff --git a/src/gui_handler/gui/textable.rs b/src/gui_handler/gui/textable.rs
index ead8e94..d388ad0 100644
--- a/src/gui_handler/gui/textable.rs
+++ b/src/gui_handler/gui/textable.rs
@@ -80,7 +80,7 @@ impl Textable {
     /// * `height_ratio` the ratio of the height in respect to the framable height
     /// * `text_alignment` where the text is aligned to
     pub fn new(
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         framable: Arc<Framable>,
         text: String,
         height_ratio: f32,
@@ -143,7 +143,7 @@ impl Textable {
     /// # Arguments
     ///
     /// * `textable` is a `&Arc<Textable>` instance that is going to be added
-    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.add_textable(self.ui_layer.load(SeqCst), self.clone())
     }
 
@@ -152,7 +152,7 @@ impl Textable {
     /// # Arguments
     ///
     /// * `textable` is a `&Arc<Textable>` instance that is going to be deleted
-    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.delete_textable(self.ui_layer.load(SeqCst), self)
     }
 
@@ -172,7 +172,7 @@ impl Textable {
     /// * `text_color` defines the color of the text
     pub fn set_text_color(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         text_color: Color,
     ) -> Result<()> {
         let set = gui_handler.color_descriptor(text_color)?;
@@ -189,7 +189,7 @@ impl Textable {
     /// * `text_alignment` where the text is aligned to
     pub fn set_text_alignment(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         text_alignment: TextAlignment,
     ) -> Result<()> {
         *self.text_alignment.write().unwrap() = text_alignment;
@@ -219,7 +219,7 @@ impl Textable {
     ///
     /// * `text` the text to be displayed
     /// * `height_ratio` the ratio of the height in respect to the framable height
-    pub fn set_text(&self, gui_handler: &mut GuiHandler<'_>, text: impl ToString) -> Result<()> {
+    pub fn set_text(&self, gui_handler: &mut GuiHandler, text: impl ToString) -> Result<()> {
         let text = text.to_string();
 
         if text.is_empty() {
@@ -250,7 +250,7 @@ impl Textable {
     /// # Arguments
     ///
     /// * `height_ratio` the ratio of the height in respect to the framable height
-    pub fn set_size(&self, gui_handler: &mut GuiHandler<'_>, height_ratio: f32) -> Result<()> {
+    pub fn set_size(&self, gui_handler: &mut GuiHandler, height_ratio: f32) -> Result<()> {
         *self.height_ratio.write().unwrap() = height_ratio;
         self.update_text(gui_handler)?;
 
@@ -284,7 +284,7 @@ impl Textable {
     }
 
     /// Updates the texts buffer
-    pub fn update_text(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn update_text(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.calculate_text_size();
 
         let (x, y) = self.calc_pos_from_alignment();
@@ -327,7 +327,7 @@ impl Textable {
 
     fn create_buffer(
         &self,
-        gui_handler: &mut GuiHandler<'_>,
+        gui_handler: &mut GuiHandler,
         win_x: f32,
         win_y: f32,
     ) -> Result<()> {
@@ -499,7 +499,7 @@ impl Textable {
         Ok(())
     }
 
-    fn text_changed_through_write(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    fn text_changed_through_write(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         self.vertex_count
             .store(self.text.read().unwrap().len() as u32 * 6, SeqCst);
         self.character_size.store(
@@ -515,19 +515,19 @@ impl Textable {
 }
 
 impl ModifyText for Textable {
-    fn set_text(&self, gui_handler: &mut GuiHandler<'_>, text: String) -> Result<()> {
+    fn set_text(&self, gui_handler: &mut GuiHandler, text: String) -> Result<()> {
         *self.text.write().unwrap() = text;
         self.text_changed_through_write(gui_handler)
     }
 
-    fn add_letter(&self, gui_handler: &mut GuiHandler<'_>, letter: char) -> Result<String> {
+    fn add_letter(&self, gui_handler: &mut GuiHandler, letter: char) -> Result<String> {
         self.text.write().unwrap().push(letter);
         self.text_changed_through_write(gui_handler)?;
 
         Ok(self.text.read().unwrap().clone())
     }
 
-    fn remove_last(&self, gui_handler: &mut GuiHandler<'_>) -> Result<Option<String>> {
+    fn remove_last(&self, gui_handler: &mut GuiHandler) -> Result<Option<String>> {
         self.text.write().unwrap().pop();
         self.text_changed_through_write(gui_handler)?;
 
diff --git a/src/gui_handler/gui/writeable.rs b/src/gui_handler/gui/writeable.rs
index ff4e813..c6d0259 100644
--- a/src/gui_handler/gui/writeable.rs
+++ b/src/gui_handler/gui/writeable.rs
@@ -9,9 +9,9 @@ use std::sync::{
 };
 
 pub trait ModifyText: Send + Sync {
-    fn set_text(&self, gui_handler: &mut GuiHandler<'_>, text: String) -> Result<()>;
-    fn add_letter(&self, gui_handler: &mut GuiHandler<'_>, letter: char) -> Result<String>;
-    fn remove_last(&self, gui_handler: &mut GuiHandler<'_>) -> Result<Option<String>>;
+    fn set_text(&self, gui_handler: &mut GuiHandler, text: String) -> Result<()>;
+    fn add_letter(&self, gui_handler: &mut GuiHandler, letter: char) -> Result<String>;
+    fn remove_last(&self, gui_handler: &mut GuiHandler) -> Result<Option<String>>;
 }
 
 /// `Writeable` gives the ability to modify the text inside an `Textable`
@@ -20,7 +20,7 @@ pub struct Writeable {
     text_change_executable: Arc<Executable<Option<String>>>,
 
     activation_changed_executable:
-        RwLock<Option<Box<dyn Fn(&mut GuiHandler<'_>, bool) -> Result<()> + Send + Sync>>>,
+        RwLock<Option<Box<dyn Fn(&mut GuiHandler, bool) -> Result<()> + Send + Sync>>>,
 
     ui_layer: AtomicI32,
 }
@@ -41,19 +41,19 @@ impl Writeable {
         }))
     }
 
-    pub fn set_active(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn set_active(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         if gui_handler.set_active_writeable(self.clone())? {
             if let Some(exec) = &*self.activation_changed_executable.read().unwrap() {
-                exec(true)?;
+                exec(gui_handler, true)?;
             }
         }
 
         Ok(())
     }
 
-    pub(crate) fn inactivation_event(&self) -> Result<()> {
+    pub(crate) fn inactivation_event(&self, gui_handler: &mut GuiHandler) -> Result<()> {
         if let Some(exec) = &*self.activation_changed_executable.read().unwrap() {
-            exec(false)?;
+            exec(gui_handler, false)?;
         }
 
         Ok(())
@@ -61,7 +61,7 @@ impl Writeable {
 
     pub fn set_activation_changed<F>(&self, f: F)
     where
-        F: Fn(&mut GuiHandler<'_>, bool) -> Result<()> + Send + Sync + 'static,
+        F: Fn(&mut GuiHandler, bool) -> Result<()> + Send + Sync + 'static,
     {
         *self.activation_changed_executable.write().unwrap() = Some(Box::new(f));
     }
@@ -71,7 +71,7 @@ impl Writeable {
     /// # Arguments
     ///
     /// * `writeable` is a `&Arc<Writeable>` instance that is going to be added
-    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn add(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.add_writeable(self.ui_layer.load(SeqCst), self.clone())
     }
 
@@ -80,7 +80,7 @@ impl Writeable {
     /// # Arguments
     ///
     /// * `writeable` is a `&Arc<Writeable>` instance that is going to be deleted
-    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
+    pub fn delete(self: &Arc<Self>, gui_handler: &mut GuiHandler) -> Result<()> {
         gui_handler.delete_writeable(self.ui_layer.load(SeqCst), self)
     }
 
@@ -93,7 +93,7 @@ impl Writeable {
     /// # Arguments
     ///
     /// * `text` that replaces the current text
-    pub fn set_text(&self, gui_handler: &mut GuiHandler<'_>, text: String) -> Result<()> {
+    pub fn set_text(&self, gui_handler: &mut GuiHandler, text: String) -> Result<()> {
         self.modifyable.set_text(gui_handler, text.clone())?;
 
         self.text_change_executable
@@ -107,19 +107,17 @@ impl Writeable {
     /// # Arguments
     ///
     /// * `letter` the letter thats going to be added
-    pub fn add_letter(&self, gui_handler: &mut GuiHandler<'_>, letter: char) -> Result<()> {
-        self.text_change_executable.execute(
-            gui_handler,
-            Some(self.modifyable.add_letter(gui_handler, letter)?),
-        )?;
+    pub fn add_letter(&self, gui_handler: &mut GuiHandler, letter: char) -> Result<()> {
+        let s = self.modifyable.add_letter(gui_handler, letter)?;
+        self.text_change_executable.execute(gui_handler, Some(s))?;
 
         Ok(())
     }
 
     /// Removes the last letter
-    pub fn remove_last(&self, gui_handler: &mut GuiHandler<'_>) -> Result<()> {
-        self.text_change_executable
-            .execute(gui_handler, self.modifyable.remove_last(gui_handler)?)?;
+    pub fn remove_last(&self, gui_handler: &mut GuiHandler) -> Result<()> {
+        let s = self.modifyable.remove_last(gui_handler)?;
+        self.text_change_executable.execute(gui_handler, s)?;
 
         Ok(())
     }
diff --git a/src/gui_handler/gui_handler.rs b/src/gui_handler/gui_handler.rs
index 9ff5c40..70b9751 100644
--- a/src/gui_handler/gui_handler.rs
+++ b/src/gui_handler/gui_handler.rs
@@ -180,7 +180,7 @@ impl TextToScreen {
     }
 }
 
-pub struct GuiHandler<'a> {
+pub struct GuiHandler {
     device: Arc<Device>,
     queue: Arc<Mutex<Queue>>,
 
@@ -229,7 +229,7 @@ pub struct GuiHandler<'a> {
     hover_sound: Option<AssetPath>,
 
     // ----- gui handling -----
-    layers: Vec<(i32, Elements<'a>)>,
+    layers: Vec<(i32, Elements)>,
 
     mouse_x: u32,
     mouse_y: u32,
@@ -239,14 +239,14 @@ pub struct GuiHandler<'a> {
     current_writeable: Option<Arc<Writeable>>,
     current_hoverable: Option<Arc<Hoverable>>,
     current_clickable: Option<Arc<Clickable>>,
-    current_selectable: Option<Arc<Selectable<'a>>>,
+    current_selectable: Option<Arc<Selectable>>,
 
     text_sample_count: VkSampleCountFlags,
 
-    callback_list: Vec<Box<dyn FnOnce() -> Result<()> + Send + Sync>>,
+    callback_list: Vec<Box<dyn FnOnce(&mut Self) -> Result<()> + Send + Sync>>,
 }
 
-impl<'a> GuiHandler<'a> {
+impl GuiHandler {
     pub fn new(
         gui_handler_create_info: GuiHandlerCreateInfo<'_>,
         context: &impl ContextInterface,
@@ -710,7 +710,7 @@ impl<'a> GuiHandler<'a> {
         Ok(false)
     }
 
-    pub fn current_selectable(&self) -> Option<Arc<Selectable<'a>>> {
+    pub fn current_selectable(&self) -> Option<Arc<Selectable>> {
         self.current_selectable.clone()
     }
 
@@ -860,14 +860,19 @@ impl<'a> GuiHandler<'a> {
         self.tooltip_ui = tooltip.into();
     }
 
-    pub(crate) fn add_callback<F: FnOnce() -> Result<()> + Send + Sync + 'static>(&mut self, f: F) {
+    pub(crate) fn add_callback<F: FnOnce(&mut Self) -> Result<()> + Send + Sync + 'static>(
+        &mut self,
+        f: F,
+    ) {
         self.callback_list.push(Box::new(f));
     }
 
     pub fn process_callbacks(&mut self) -> Result<()> {
         let callbacks = mem::take(&mut self.callback_list);
 
-        callbacks.into_iter().try_for_each(|callback| callback())
+        callbacks
+            .into_iter()
+            .try_for_each(|callback| callback(self))
     }
 
     fn render(
@@ -1045,7 +1050,7 @@ macro_rules! remove_element {
 }
 
 // object handling
-impl<'a> GuiHandler<'a> {
+impl<'a> GuiHandler {
     // framable
     pub(crate) fn add_framable(&mut self, layer: i32, framable: Arc<Framable>) -> Result<()> {
         add_element!(self.layers, layer, framable);
@@ -1084,11 +1089,7 @@ impl<'a> GuiHandler<'a> {
     }
 
     // selectable
-    pub(crate) fn add_selectable(
-        &mut self,
-        layer: i32,
-        selectable: Arc<Selectable<'a>>,
-    ) -> Result<()> {
+    pub(crate) fn add_selectable(&mut self, layer: i32, selectable: Arc<Selectable>) -> Result<()> {
         add_element!(self.layers, layer, selectable);
 
         Ok(())
@@ -1097,7 +1098,7 @@ impl<'a> GuiHandler<'a> {
     pub(crate) fn delete_selectable(
         &mut self,
         layer: i32,
-        selectable: &Arc<Selectable<'a>>,
+        selectable: &Arc<Selectable>,
     ) -> Result<()> {
         if self.current_selectable.is_some() {
             // unwrap is safe, just tested for `is_some`
@@ -1181,13 +1182,15 @@ impl<'a> GuiHandler<'a> {
     }
 
     pub(crate) fn set_active_writeable(&mut self, writeable: Arc<Writeable>) -> Result<bool> {
+        let callback_self = unsafe { remove_life_time_mut(self) };
+
         if let Some(current) = self.current_writeable.as_ref() {
             // change nothing if both are the same
             if Arc::ptr_eq(current, &writeable) {
                 return Ok(false);
             }
 
-            current.inactivation_event()?;
+            current.inactivation_event(callback_self)?;
         }
 
         self.current_writeable = Some(writeable);
@@ -1200,12 +1203,12 @@ impl<'a> GuiHandler<'a> {
         layer: i32,
         writeable: &Arc<Writeable>,
     ) -> Result<()> {
-        {
-            if let Some(w) = &self.current_writeable {
-                if Arc::ptr_eq(w, writeable) {
-                    w.inactivation_event()?;
-                    self.current_writeable = None;
-                }
+        let callback_self = unsafe { remove_life_time_mut(self) };
+
+        if let Some(w) = &self.current_writeable {
+            if Arc::ptr_eq(w, writeable) {
+                w.inactivation_event(callback_self)?;
+                self.current_writeable = None;
             }
         }
 
@@ -1233,7 +1236,7 @@ impl<'a> GuiHandler<'a> {
         Ok(())
     }
 
-    pub(crate) fn set_selectable(&mut self, selectable: Option<Arc<Selectable<'a>>>) -> Result<()> {
+    pub(crate) fn set_selectable(&mut self, selectable: Option<Arc<Selectable>>) -> Result<()> {
         let callback_self = unsafe { remove_life_time_mut(self) };
 
         if let Some(selectable) = &self.current_selectable {
@@ -1273,7 +1276,7 @@ impl<'a> GuiHandler<'a> {
 }
 
 // private - create rendering stuff
-impl<'a> GuiHandler<'a> {
+impl<'a> GuiHandler {
     fn create_render_targets(
         device: &Arc<Device>,
         target_images: &TargetMode<Vec<Arc<Image>>>,
@@ -1587,7 +1590,7 @@ impl<'a> GuiHandler<'a> {
     }
 }
 
-impl<'a> GuiHandler<'a> {
+impl<'a> GuiHandler {
     pub fn process(
         &mut self,
         buffer_recorder: &mut CommandBufferRecorder<'_>,
@@ -1691,8 +1694,8 @@ impl<'a> GuiHandler<'a> {
     }
 }
 
-impl<'a> From<&'a ecs::World> for &'a GuiHandler<'_> {
-    fn from(world: &'a ecs::World) -> Self {
-        world.resources.get::<GuiHandler<'_>>()
+impl<'a> From<&'a ecs::World> for &'a GuiHandler {
+    fn from(world: &'a ecs::World) -> &'a GuiHandler {
+        world.resources.get::<GuiHandler>()
     }
 }
diff --git a/src/keyboard/mod.rs b/src/keyboard/mod.rs
index 80ecce4..3046494 100644
--- a/src/keyboard/mod.rs
+++ b/src/keyboard/mod.rs
@@ -32,7 +32,7 @@ pub struct Keyboard {
 }
 
 impl Keyboard {
-    pub fn new(gui_handler: &GuiHandler<'a>) -> Result<Arc<Self>> {
+    pub fn new(gui_handler: &GuiHandler) -> Result<Arc<Self>> {
         let text_field_gui: Arc<GuiBuilder> =
             GuiBuilder::from_str(gui_handler, include_str!("text_field.xml"))?;