prism 0.1.0

An experimental chart library for iced.
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

use iced::Rectangle;
use ordered_float::OrderedFloat;

use std::collections::BTreeMap;

type BTreeMapFloat<V> = BTreeMap<OrderedFloat<f32>, V>;

pub struct Entry<Id> {
    id: Id,
    location: iced::Point,
}

impl<Id> Entry<Id>
where
    Id: Clone,
{
    pub fn new(id: Id, location: iced::Point) -> Self {
        Self { id, location }
    }
}

pub struct Items<SeriesId, ItemId>(BTreeMapFloat<BTreeMapFloat<(SeriesId, ItemId)>>);

impl<SeriesId, ItemId> Items<SeriesId, ItemId>
where
    SeriesId: Clone,
    ItemId: Clone + std::fmt::Debug,
{
    pub fn add_series(&mut self, id: SeriesId, series: &[Entry<ItemId>]) {
        for entry in series.iter() {
            let point = entry.location;

            self.0
                .entry(OrderedFloat(point.x))
                .or_default()
                .insert(OrderedFloat(point.y), (id.clone(), entry.id.clone()));
        }
    }

    pub fn collision(&self, rect: Rectangle) -> Vec<(SeriesId, ItemId)> {
        let range = OrderedFloat(rect.x)..OrderedFloat(rect.x + rect.width);

        let mut items = vec![];
        for (_, bucket) in self.0.range(range) {
            let range = OrderedFloat(rect.y)..OrderedFloat(rect.y + rect.height);

            let item_list = bucket
                .range(range)
                .map(|(_key, (series_id, item_id))| (series_id.clone(), item_id.clone()));

            items.extend(item_list);
        }

        items
    }
}

impl<SeriesId, ItemId> Default for Items<SeriesId, ItemId> {
    fn default() -> Self {
        Self(BTreeMapFloat::new())
    }
}