feat: Added iced-ui and updated typegen for docs

ui-gpui/src/lib.rs

@@ -1,14 +1,262 @@
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
+use ::tap::*;
+
+use std::{collections::BTreeMap, sync::Arc};
+
+use gpui::{
+    App, Application, Bounds, ClickEvent, Context, ImageId, ImageSource, RenderImage, Resource,
+    SharedString, Window, WindowBounds, WindowOptions, actions, div, prelude::*, px, rgb, size,
+};
+
+#[derive(Clone, Debug)]
+pub struct AppState {
+    pub title: SharedString,
+    pub items: BTreeMap<SharedString, Item>,
+    pub item_ids: BTreeMap<usize, SharedString>,
+    pub current_item: Option<SharedString>,
+    pub errors: Vec<String>,
+    pub jellyfin_client: api::JellyfinClient,
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+#[derive(Clone, Debug)]
+pub struct Item {
+    pub id: SharedString,
+    pub name: SharedString,
+    pub item_type: SharedString,
+    pub media_type: SharedString,
+}
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
+impl Render for AppState {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        div()
+            .flex()
+            .flex_col()
+            .size_full()
+            .justify_center()
+            .text_color(rgb(0xffffff))
+            .child(Self::header())
+            .child(Self::body(self, window, cx))
+            .child(Self::footer())
+    }
+}
+
+actions!(jello_actions, [OpenItem, OnLoadItem, MouseDownEvent]);
+
+impl AppState {
+    fn new(title: impl AsRef<str>, jellyfin_client: api::JellyfinClient) -> Self {
+        AppState {
+            title: SharedString::new(title.as_ref()),
+            items: BTreeMap::new(),
+            item_ids: BTreeMap::new(),
+            current_item: None,
+            errors: Vec::new(),
+            jellyfin_client,
+        }
+    }
+
+    // fn on_mouse_down(
+    //     &mut self,
+    //     event: &MouseDownEvent,
+    //     window: &mut Window,
+    //     cx: &mut Context<Self>,
+    // ) {
+    //     // Handle mouse down event
+    // }
+
+    fn load_item(id: usize) -> impl Fn(&mut Self, &ClickEvent, &mut Window, &mut Context<Self>) {
+        move |state: &mut Self, event: &ClickEvent, window: &mut Window, cx: &mut Context<Self>| {
+            let item_id = id;
+            cx.spawn(async move |entity, app| {
+                tracing::info!("Loading item with id: {}", item_id);
+            });
+        }
+    }
+
+    fn hover_item(id: usize) -> impl Fn(&mut Self, &bool, &mut Window, &mut Context<Self>) {
+        move |state: &mut Self, item: &bool, window: &mut Window, cx: &mut Context<Self>| {
+            dbg!("Hovering over item: {:?}", id);
+        }
+    }
+
+    fn header() -> impl IntoElement {
+        div()
+            .flex()
+            .flex_row()
+            .w_full()
+            .justify_end()
+            .h_20()
+            .border_10()
+            .bg(rgb(0x333333))
+            .child(Self::button("Refresh"))
+    }
+
+    fn footer() -> impl IntoElement {
+        div().flex().flex_row().w_full().h_20().bg(rgb(0x333333))
+    }
+
+    fn body(&mut self, window: &mut Window, cx: &mut Context<AppState>) -> impl IntoElement {
+        div()
+            .flex()
+            .flex_row()
+            .size_full()
+            .child(Self::content(self, window, cx))
+            .child(Self::sidebar(self, window, cx))
+    }
+
+    fn button(label: &str) -> impl IntoElement {
+        div()
+            .flex()
+            .justify_center()
+            .items_center()
+            .bg(rgb(0xff00ff))
+            .text_color(rgb(0xffffff))
+            .border_5()
+            .rounded_lg()
+            .child(label.to_string())
+    }
+
+    fn content(&mut self, window: &mut Window, cx: &mut Context<AppState>) -> impl IntoElement {
+        div()
+            .debug_below()
+            .w_3_4()
+            // .flex()
+            // .flex_wrap()
+            .bg(rgb(0x111111))
+            .justify_start()
+            .items_start()
+            .overflow_hidden()
+            .child(
+                div()
+                    .size_full()
+                    .flex()
+                    .flex_wrap()
+                    .justify_start()
+                    .items_start()
+                    .content_start()
+                    .gap_y_10()
+                    .gap_x_10()
+                    .border_t_10()
+                    .p_5()
+                    .child(Self::card(cx, 1))
+                    .child(Self::card(cx, 2))
+                    .child(Self::card(cx, 3))
+                    .child(Self::card(cx, 4))
+                    .child(Self::card(cx, 5))
+                    .child(Self::card(cx, 6))
+                    .child(Self::card(cx, 7))
+                    .child(Self::card(cx, 8))
+                    .child(Self::card(cx, 9)),
+            )
+    }
+
+    fn sidebar(&mut self, window: &mut Window, cx: &mut Context<AppState>) -> impl IntoElement {
+        div()
+            .flex()
+            .flex_col()
+            .w_1_4()
+            .min_w_1_6()
+            .bg(rgb(0x222222))
+            .child(div().size_full().bg(gpui::yellow()))
+    }
+
+    fn card(cx: &mut Context<AppState>, number: usize) -> impl IntoElement {
+        div()
+            .id(number)
+            .on_click(cx.listener(Self::load_item(number)))
+            .on_hover(cx.listener(Self::hover_item(number)))
+            .flex()
+            .flex_col()
+            .w_48()
+            .h_64()
+            .p_10()
+            .bg(rgb(0xff00ff))
+            .rounded_lg()
+    }
+}
+
+pub fn ui(jellyfin_client: api::JellyfinClient) {
+    Application::new().run(|cx: &mut App| {
+        let bounds = Bounds::centered(None, size(px(500.0), px(500.0)), cx);
+        cx.open_window(
+            WindowOptions {
+                window_bounds: Some(WindowBounds::Windowed(bounds)),
+                ..Default::default()
+            },
+            |_, cx| cx.new(|_| AppState::new("Jello Media Browser", jellyfin_client)),
+        )
+        .expect("Failed to open window");
+    })
+}
+
+#[derive(Clone, Debug)]
+pub struct Card {
+    pub id: usize,
+    pub title: SharedString,
+    pub description: SharedString,
+    pub image: SharedString,
+    pub image_blurhash: BlurHash,
+    pub media_type: SharedString,
+    pub loading: bool,
+}
+
+impl Render for Card {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        div()
+            .id(self.id)
+            .flex()
+            .flex_col()
+            .w_48()
+            .h_64()
+            .p_10()
+            .bg(rgb(0xff00ff))
+            .rounded_lg()
+            .pipe(|card| {
+                if self.loading {
+                    card.child(self.image_blurhash.clone())
+                } else {
+                    card.child(gpui::img(self.image.clone()))
+                }
+            })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct BlurHash {
+    pub id: ImageId,
+    pub data: Arc<RenderImage>,
+}
+
+impl BlurHash {
+    pub fn new(
+        data: impl AsRef<str>,
+        width: u32,
+        height: u32,
+        punch: f32,
+    ) -> Result<Self, error_stack::Report<crate::Error>> {
+        use error_stack::ResultExt;
+        let decoded =
+            blurhash::decode(data.as_ref(), width, height, punch).change_context(crate::Error)?;
+        let buffer = image::RgbaImage::from_raw(width, height, decoded)
+            .ok_or(crate::Error)
+            .attach("Failed to convert")?;
+        let frame = image::Frame::new(buffer);
+        let render_image = RenderImage::new([frame]);
+        Ok(Self {
+            id: render_image.id,
+            data: Arc::from(render_image),
+        })
+    }
+}
+
+impl Render for BlurHash {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        gpui::img(ImageSource::Render(self.data.clone()))
+    }
+}
+
+impl IntoElement for BlurHash {
+    type Element = gpui::Img;
+
+    fn into_element(self) -> Self::Element {
+        gpui::img(ImageSource::Render(self.data.clone()))
     }
 }