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
110

use crate::prelude::*;
use crate::queue::{TaskKind, TaskRef, TaskStatus};

#[derive(Debug, Clone)]
pub(crate) enum Message {
    Untrack,
    Track,
    RefreshSeries(RemoteSeriesId),
    RemoveSeries,
}

#[derive(Debug, Clone)]
pub(crate) struct SeriesActions {
    series_id: SeriesId,
    confirm: bool,
}

impl Component<SeriesId> for SeriesActions {
    #[inline]
    fn new(series_id: SeriesId) -> Self {
        Self {
            series_id,
            confirm: false,
        }
    }

    #[inline]
    fn changed(&mut self, series_id: SeriesId) {
        if self.series_id != series_id {
            self.series_id = series_id;
            self.confirm = false;
        }
    }
}

impl SeriesActions {
    pub(crate) fn update(&mut self, cx: &mut Ctxt<'_>, message: Message) {
        match message {
            Message::Untrack => {
                cx.service.untrack(&self.series_id);
            }
            Message::Track => {
                cx.service.track(&self.series_id);
            }
            Message::RefreshSeries(remote_id) => {
                cx.service
                    .push_task_without_delay(TaskKind::DownloadSeries {
                        series_id: self.series_id,
                        remote_id,
                        last_modified: None,
                        force: true,
                    });
            }
            Message::RemoveSeries => {
                cx.remove_series(&self.series_id);
            }
        }
    }

    pub(crate) fn view(&self, cx: &CtxtRef<'_>, series: &Series) -> Element<'static, Message> {
        let mut row = w::Row::new();

        if series.tracked {
            row = row.push(
                w::button(w::text("Untrack").size(SMALL))
                    .style(theme::Button::Destructive)
                    .on_press(Message::Untrack),
            );
        } else {
            row = row.push(
                w::button(w::text("Track").size(SMALL))
                    .style(theme::Button::Positive)
                    .on_press(Message::Track),
            );
        }

        let status = cx.service.task_status(TaskRef::Series {
            series_id: series.id,
        });

        match status {
            Some(TaskStatus::Pending) => {
                row = row
                    .push(w::button(w::text("Refresh").size(SMALL)).style(theme::Button::Positive));
            }
            Some(TaskStatus::Running) => {
                row = row.push(
                    w::button(w::text("Downloading...").size(SMALL)).style(theme::Button::Primary),
                );
            }
            None => {
                if let Some(remote_id) = series.remote_id {
                    row = row.push(
                        w::button(w::text("Refresh").size(SMALL))
                            .style(theme::Button::Positive)
                            .on_press(Message::RefreshSeries(remote_id)),
                    );
                }
            }
        }

        row = row.push(
            w::button(w::text("Remove").size(SMALL))
                .style(theme::Button::Destructive)
                .on_press(Message::RemoveSeries),
        );

        row.spacing(SPACE).into()
    }
}