we frikin did it bois

gui library works frrr

implementation:
- containers now store a Widget type.

- every widget has a unique id

- there is a data store that maps the id to the internally stored gui component.

- the compoenents can be fetched from the datastore using their Widget type
- the datastore uses a hashmap so fetching shouldnt have any real performance penalty.

- widgets can be fetched, inserted, updated and rendered from the datastore

- the render method can be called directly from the Widget type without having to know the underlying type that it references

src/user/lib/libgui/cg_core.rs

@@ -1,12 +1,17 @@
-use alloc::boxed::Box;
-use alloc::string::String;
-use alloc::vec;
-use alloc::vec::Vec;
-use core::slice::from_mut;
+use hashbrown::HashMap;
+use spin::{Mutex, MutexGuard};
 use crate::{printerr, serial_println};
 use crate::std::frame::{ColouredChar, Dimensions, Position, special_char, Frame, RenderError, ColorCode};
-use crate::user::lib::libgui::cg_inputs::CgLineEdit;
-use crate::user::lib::libgui::cg_widgets::{CgContainer, CgTextBox, CgIndicatorBar, CgIndicatorWidget, CgLabel, CgStatusBar};
+
+use alloc::{
+	boxed::Box,
+	sync::Arc,
+	vec::Vec,
+	vec,
+	string::String,
+};
+use core::any::Any;
+use lazy_static::lazy_static;
 
 /// implement this trait if you require the widget to be able to have an outline
 pub trait CgOutline: CgComponent {
@@ -15,10 +20,13 @@ pub trait CgOutline: CgComponent {
 
 /// generic components for the user interface that defined a render method. this should be implemented for all types
 /// that can be rendered to the screen.
-pub trait CgComponent {
+pub trait CgComponent: Any {
 	fn render(&self) -> Result<Frame, RenderError>;
+
+	fn as_any(&self) -> &dyn Any;
 }
 
+
 /// trait for components that can have editable text, such as search boxes, command palettes, terminals, text inputs etc.
 pub trait CgTextEdit: CgComponent {
 	fn write_char(&mut self, c: char); // this can also be implemented in a way that inserts characters
@@ -26,3 +34,108 @@ pub trait CgTextEdit: CgComponent {
 	fn move_cursor(&mut self, direction: bool); // true = right, false = left
 	fn clear(&mut self);
 }
+
+
+
+static ID_COUNTER: Mutex<usize> = Mutex::new(0);
+
+lazy_static!(
+	static ref GUITREE: Mutex<DataStore> = Mutex::new(DataStore::new());
+);
+
+
+
+#[derive(PartialEq, Eq, Debug, Clone)]
+pub struct Widget {
+	id: usize,
+}
+impl Widget {
+	fn new() -> Self {
+		let mut id_counter = ID_COUNTER.lock();
+		let id = Widget {
+			id: *id_counter
+		};
+		*id_counter += 1;
+		id
+	}
+
+	pub fn fetch<T: 'static + Send + Sync + Clone + CgComponent>(&self) -> Option<T> {
+		GUITREE.lock().fetch(self)
+	}
+
+	pub fn insert<T: 'static + Send + Sync + Clone + CgComponent>(item: T) -> Self {
+		let mut id_counter = ID_COUNTER.lock();
+		let id = Widget { id: *id_counter };
+		*id_counter += 1;
+		GUITREE.lock().insert(&id, item);
+		id
+	}
+
+	pub fn update<T: 'static + Send + Sync + Clone + CgComponent>(&self, item: T) {
+		GUITREE.lock().insert(self, item);
+	}
+
+	pub fn render(&self) -> Result<Frame, RenderError> {
+		if let Some(frame) = GUITREE.lock().frame(self) {
+			frame
+		} else {
+			panic!("CRITICAL: Widget not found in tree");
+		}
+	}
+}
+
+impl Drop for Widget {
+	fn drop(&mut self) {
+		GUITREE.lock().remove(self);
+	}
+}
+
+
+
+struct DataStore {
+	items: Mutex<HashMap<usize, Arc<Mutex<dyn CgComponent + Send + Sync>>>>,
+	id_counter: Mutex<usize>,
+}
+
+impl DataStore {
+	fn new() -> Self {
+		DataStore {
+			items: Mutex::new(HashMap::new()),
+			id_counter: Mutex::new(0),
+		}
+	}
+
+	fn insert<T: 'static + CgComponent + Send + Sync + Clone>(&self, id: &Widget, item: T) {
+		let mut items = self.items.lock();
+		items.insert(id.id, Arc::new(Mutex::new(item)));
+	}
+
+	fn fetch<T: 'static + Send + Sync + Clone>(&self, id: &Widget) -> Option<T> where T: Any + Send + Sync {
+		let id = id.id;
+
+		let items = self.items.lock();
+		items.get(&id).and_then(|arc| {
+			let any_mutex = arc.lock();
+			let any_ref = any_mutex.as_any();
+			any_ref.downcast_ref::<T>().cloned()
+		})
+	}
+
+	fn frame(&self, id: &Widget) -> Option<Result<Frame, RenderError>> {
+		let items = self.items.lock();
+		items.get(&id.id).and_then(|arc| {
+			let item = arc.lock();
+			Some(item.render())
+		})
+	}
+
+	fn remove(&self, id: &Widget) {
+		let mut items = self.items.lock();
+		items.remove(&id.id);
+	}
+}
+
+
+
+
+

src/user/lib/libgui/cg_inputs.rs

@@ -1,5 +1,6 @@
 use alloc::string::String;
 use alloc::vec::Vec;
+use core::any::Any;
 use crate::std::frame::{ColouredChar, Dimensions, Frame, Position, RenderError};
 use crate::user::lib::libgui::cg_core::{CgComponent, CgTextEdit};
 
@@ -56,6 +57,9 @@ impl CgComponent for CgLineEdit {
 
         Ok(frame)
     }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 impl CgTextEdit for CgLineEdit {

src/user/lib/libgui/cg_widgets.rs

@@ -1,36 +1,37 @@
 use alloc::{boxed::Box, format, string::String, vec, vec::Vec};
 use alloc::fmt::format;
 use alloc::string::ToString;
+use core::any::Any;
 use core::cmp::{max, min};
+use hashbrown::HashMap;
 use crate::serial_println;
-use super::cg_core::{
-    CgComponent, CgOutline
-};
+use super::cg_core::{CgComponent, CgOutline, Widget};
 use crate::std::frame::{ColouredChar, Dimensions, Position, Frame, RenderError, ColorCode};
 use crate::std::io::Color;
 
-pub struct CgContainer<'a> {
-    pub elements: Vec<Box<&'a dyn CgComponent>>,
+#[derive(Debug, Clone)]
+pub struct CgContainer {
+    pub elements: HashMap<&'static str, Widget>,
     pub position: Position,
     pub dimensions: Dimensions,
     pub outlined: bool,
 }
 
-impl<'a> CgContainer<'a> {
-    pub fn new(position: Position, dimensions: Dimensions, outlined: bool) -> CgContainer<'a> {
+impl CgContainer {
+    pub fn new(position: Position, dimensions: Dimensions, outlined: bool) -> CgContainer {
         CgContainer {
-            elements: Vec::new(),
+            elements: HashMap::new(),
             position,
             dimensions,
             outlined,
         }
     }
-    pub fn insert(&mut self, element: Box<&'a dyn CgComponent>) {
-        self.elements.push(element);
+    pub fn insert(&mut self, name: &'static str, element: Widget) {
+        self.elements.insert(name,element);
     }
 }
 
-impl CgOutline for CgContainer<'_> {
+impl CgOutline for CgContainer {
     fn render_outline(&self, frame: &mut Frame) {
         // draws the sides of the container
         for i in 0..frame.dimensions.x {
@@ -52,12 +53,12 @@ impl CgOutline for CgContainer<'_> {
     }
 }
 
-impl CgComponent for CgContainer<'_> {
+impl CgComponent for CgContainer {
     fn render(&self) -> Result<Frame, RenderError> {
         let mut result = Frame::new(self.position, self.dimensions)?;
 
         for widget in &self.elements {
-            let frame = widget.render()?;
+            let frame = widget.1.render()?;
             match result.render_bounds_check(&frame, true) { // TODO: this needs to be set to false for production
                 Ok(()) => result.place_child_element(&frame),
                 Err(e) => return Err(e),
@@ -70,6 +71,9 @@ impl CgComponent for CgContainer<'_> {
 
         Ok(result)
     }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -150,7 +154,9 @@ impl CgComponent for CgTextBox {
 
         Ok(result)
     }
-
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 
@@ -210,6 +216,9 @@ impl CgComponent for CgLabel {
         };
         Ok(result)
     }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -259,6 +268,9 @@ impl CgComponent for CgIndicatorWidget {
 
         Ok(result)
     }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -301,6 +313,9 @@ impl CgComponent for CgIndicatorBar {
 
         Ok(result)
     }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -333,6 +348,9 @@ impl CgComponent for CgStatusBar {
 
         Ok(frame)
     }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 impl CgStatusBar {