ontv 0.1.3

A rich desktop application for tracking tv shows
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use iced::widget::scrollable::RelativeOffset;
use serde::{Deserialize, Serialize};

use crate::assets::Assets;
use crate::page;

/// The current page.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub(crate) enum Page {
    Dashboard,
    WatchNext(page::watch_next::State),
    Search(page::search::State),
    SeriesList,
    Series(page::series::State),
    Movie(page::movie::State),
    Settings,
    Season(page::season::State),
    Queue,
    Errors,
}

#[derive(Default)]
pub(crate) struct HistoryMutations {
    relative: Option<isize>,
    push: Option<Page>,
}

impl HistoryMutations {
    /// Test if there are any recorded mutations.
    fn has_any(&self) -> bool {
        self.relative.is_some() || self.push.is_some()
    }

    /// Navigate history.
    pub(crate) fn navigate(&mut self, relative: isize) {
        self.relative = Some(relative);
    }

    /// Push a history entry.
    pub(crate) fn push_history(&mut self, assets: &mut Assets, page: Page) {
        assets.clear();
        self.push = Some(page);
    }
}

pub(crate) struct History {
    // History entries.
    history: Vec<(Page, RelativeOffset)>,
    // Current history entry.
    history_index: usize,
}

impl History {
    /// Construct a new empty history.
    pub(crate) fn new() -> Self {
        Self {
            history: vec![(Page::Dashboard, RelativeOffset::default())],
            history_index: 0,
        }
    }

    /// Get the current page.
    pub(crate) fn page(&self) -> Option<&Page> {
        Some(&self.history.get(self.history_index)?.0)
    }

    /// Get history mutably.
    pub(crate) fn page_mut(&mut self) -> Option<&mut Page> {
        Some(&mut self.history.get_mut(self.history_index)?.0)
    }

    /// Update scroll location in history.
    pub(crate) fn history_scroll(&mut self, scroll: RelativeOffset) {
        if let Some((_, s)) = self.history.get_mut(self.history_index) {
            *s = scroll;
        }
    }

    /// Apply an existing history mutation.
    pub(crate) fn apply_mutation(
        &mut self,
        mutation: &mut HistoryMutations,
    ) -> Option<&(Page, RelativeOffset)> {
        if !mutation.has_any() {
            return None;
        }

        if let Some(relative) = mutation.relative.take() {
            self.history_index = match relative.signum() {
                1 => self.history_index.saturating_add(relative as usize),
                -1 => self.history_index.saturating_sub(-relative as usize),
                _ => 0,
            }
            .min(self.history.len().saturating_sub(1));
        }

        if let Some(page) = mutation.push.take() {
            while self.history_index + 1 < self.history.len() {
                self.history.pop();
            }

            self.history.push((page, RelativeOffset::default()));
            self.history_index += 1;
        }

        self.history.get(self.history_index)
    }
}