add search primitives: state field, message variant, filter functions

Cargo.lock

···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
 dependencies = [
- "toml_edit",
+ "toml_edit 0.23.7",
 ]
 
 [[package]]
···
  "reqwest",
  "serde",
  "serde_json",
+ "toml",
  "uuid",
 ]
 
···
 ]
 
 [[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+
+[[package]]
 name = "serde_urlencoded"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "toml"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime 0.6.11",
+ "toml_edit 0.22.27",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
+dependencies = [
+ "serde",
+]
+
+[[package]]
 name = "toml_datetime"
 version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "toml_edit"
+version = "0.22.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
+dependencies = [
+ "indexmap",
+ "serde",
+ "serde_spanned",
+ "toml_datetime 0.6.11",
+ "toml_write",
+ "winnow",
+]
+
+[[package]]
+name = "toml_edit"
 version = "0.23.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d"
 dependencies = [
  "indexmap",
- "toml_datetime",
+ "toml_datetime 0.7.3",
  "toml_parser",
  "winnow",
 ]
···
 dependencies = [
  "winnow",
 ]
+
+[[package]]
+name = "toml_write"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
 [[package]]
 name = "tower"

Cargo.toml

···
 iced = "0.13"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+toml = "0.8"
 reqwest = { version = "0.12", features = ["json", "blocking"] }
 uuid = { version = "1.0", features = ["v4", "v5"] }
 chrono = "0.4"

src/main.rs

···
 mod palette;
 mod panel;
 mod track;
+mod view;
 
-use iced::widget::{column, container, horizontal_rule, pane_grid, scrollable, text};
+use iced::widget::{button, column, container, horizontal_rule, pane_grid, row, scrollable, text};
 use iced::{Length, Theme};
 use palette::Palette;
 use panel::{PaneContent, PaneMessage, ViewType};
···
     selected_channel: Option<usize>,
     palette: Palette,
     search_query: String,
+    views: Vec<view::View>,
+    active_view_idx: usize,
 }
 
 impl Default for State {
···
             .and_then(|json| serde_json::from_str(&json).ok())
             .unwrap_or_default();
 
+        // Load views from config, fallback to builtins
+        let mut views = view::load_views().unwrap_or_default();
+        if views.is_empty() {
+            views = view::View::builtin_views();
+        }
+
         Self {
             panes,
             channels,
···
             selected_channel: None,
             palette: Palette::default(),
             search_query: String::new(),
+            views,
+            active_view_idx: 0,
         }
     }
 }
···
     ChannelSelected(usize),
     Pane(PaneMessage),
     SearchChanged(String),
+    ViewSelected(usize),
 }
 
 // Search/filter functions
···
         Message::SearchChanged(query) => {
             state.search_query = query;
         }
+        Message::ViewSelected(idx) => {
+            if idx < state.views.len() {
+                state.active_view_idx = idx;
+            }
+        }
         Message::Pane(pane_msg) => match pane_msg {
             PaneMessage::Resized(resize_event) => {
                 state.panes.resize(resize_event.split, resize_event.ratio);
···
 }
 
 fn view(state: &State) -> iced::Element<Message> {
+    let palette = &state.palette;
+
+    // View tabs
+    let tabs = row(
+        state
+            .views
+            .iter()
+            .enumerate()
+            .map(|(idx, view)| {
+                let is_active = idx == state.active_view_idx;
+                button(text(&view.name).size(14))
+                    .on_press(Message::ViewSelected(idx))
+                    .padding(12)
+                    .style(move |theme: &Theme, status| {
+                        let mut style = button::Style::default();
+                        style.background = if is_active {
+                            Some(iced::Background::Color(palette.bg2))
+                        } else {
+                            Some(iced::Background::Color(palette.bg1))
+                        };
+                        style.text_color = if is_active {
+                            palette.red
+                        } else {
+                            theme.palette().text
+                        };
+                        style
+                    })
+                    .into()
+            })
+            .collect::<Vec<_>>(),
+    )
+    .spacing(2);
+
+    let tab_bar = container(tabs)
+        .padding(4)
+        .style(move |_theme: &Theme| container::Style {
+            background: Some(iced::Background::Color(palette.gray1)),
+            ..Default::default()
+        });
+
     let pane_grid = pane_grid::PaneGrid::new(&state.panes, |_pane, content, _is_maximized| {
         pane_grid::Content::new(render_pane_content(&content.view_type, state))
     })
···
     .width(Length::Fill)
     .height(Length::Fill);
 
-    container(pane_grid)
+    column![tab_bar, pane_grid]
         .width(Length::Fill)
         .height(Length::Fill)
         .into()

src/view.rs

···
+/// View system for user-configurable data presentation
+///
+/// Views are persistent, user-defined configurations that determine
+/// what data to show and how to sort it.
+///
+/// Stored in ~/.config/radio4000-desktop/views/
+
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct View {
+    pub id: String,
+    pub name: String,
+    pub source: DataSource,
+    pub sort: Sort,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub enum DataSource {
+    Channels,
+    Tracks,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct Sort {
+    pub field: SortField,
+    pub direction: SortDirection,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub enum SortField {
+    Name,
+    CreatedAt,
+    TrackCount,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub enum SortDirection {
+    Asc,
+    Desc,
+}
+
+impl View {
+    pub fn builtin_all_channels() -> Self {
+        Self {
+            id: "all-channels".into(),
+            name: "All Channels".into(),
+            source: DataSource::Channels,
+            sort: Sort {
+                field: SortField::Name,
+                direction: SortDirection::Asc,
+            },
+        }
+    }
+
+    pub fn builtin_all_tracks() -> Self {
+        Self {
+            id: "all-tracks".into(),
+            name: "All Tracks".into(),
+            source: DataSource::Tracks,
+            sort: Sort {
+                field: SortField::CreatedAt,
+                direction: SortDirection::Desc,
+            },
+        }
+    }
+
+    pub fn builtin_views() -> Vec<Self> {
+        vec![Self::builtin_all_channels(), Self::builtin_all_tracks()]
+    }
+}
+
+/// Get config directory path
+pub fn config_dir() -> PathBuf {
+    let home = std::env::var("HOME").expect("HOME not set");
+    Path::new(&home)
+        .join(".config")
+        .join("r4")
+}
+
+/// Get views directory path
+pub fn views_dir() -> PathBuf {
+    config_dir().join("views")
+}
+
+/// Load all views from disk
+pub fn load_views() -> Result<Vec<View>, std::io::Error> {
+    let views_path = views_dir();
+
+    // Create directory if it doesn't exist
+    std::fs::create_dir_all(&views_path)?;
+
+    let mut views = Vec::new();
+
+    // Read all .toml files in views directory
+    for entry in std::fs::read_dir(&views_path)? {
+        let entry = entry?;
+        let path = entry.path();
+
+        if path.extension().and_then(|s| s.to_str()) == Some("toml") {
+            if let Ok(contents) = std::fs::read_to_string(&path) {
+                if let Ok(view) = toml::from_str::<View>(&contents) {
+                    views.push(view);
+                }
+            }
+        }
+    }
+
+    Ok(views)
+}
+
+/// Save a view to disk
+pub fn save_view(view: &View) -> Result<(), std::io::Error> {
+    let views_path = views_dir();
+    std::fs::create_dir_all(&views_path)?;
+
+    let file_path = views_path.join(format!("{}.toml", view.id));
+    let contents = toml::to_string_pretty(view).map_err(|e| {
+        std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string())
+    })?;
+
+    std::fs::write(&file_path, contents)?;
+    Ok(())
+}
+
+/// Delete a view from disk
+pub fn delete_view(id: &str) -> Result<(), std::io::Error> {
+    let file_path = views_dir().join(format!("{}.toml", id));
+    std::fs::remove_file(file_path)
+}