frui_core 0.0.1

Core functionality of Frui UI framework
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

use std::any::{Any, TypeId};

use crate::prelude::{BuildContext, SingleChildWidget};

use super::{implementors::WidgetDerive, Widget, WidgetKind};

/// LocalKey is a widget that allows you to annotate the key for a `child`
/// widget.
pub struct LocalKey<K: 'static + PartialEq, W: Widget> {
    pub key: K,
    pub child: W,
}

impl<K: 'static + PartialEq, W: Widget> LocalKey<K, W> {
    pub fn new(key: K, child: W) -> Self {
        Self { key, child }
    }
}

//
// Widget implementation.

#[doc(hidden)]
pub enum LocalKeyUniqueTypeId {}

impl<K: 'static + PartialEq, W: Widget> Widget for LocalKey<K, W> {
    fn unique_type(&self) -> TypeId {
        TypeId::of::<LocalKeyUniqueTypeId>()
    }

    fn kind(&self) -> WidgetKind {
        WidgetKind::SingleChild(self)
    }
}

impl<K: 'static + PartialEq, W: Widget> WidgetDerive for LocalKey<K, W> {
    type Widget<'a> = &'a W where Self: 'a;

    type UniqueTypeId = LocalKeyUniqueTypeId;
}

impl<K: 'static + PartialEq, W: Widget> SingleChildWidget for LocalKey<K, W> {
    fn build<'w>(&'w self, _: BuildContext<'w, Self>) -> Self::Widget<'w> {
        &self.child
    }
}

//
// LocalKeyAny

pub struct LocalKeyAny<'a> {
    key: &'a dyn PartialEqAny,
}

impl PartialEq for LocalKeyAny<'_> {
    fn eq(&self, other: &Self) -> bool {
        self.key.eq(other.key)
    }
}

pub trait WidgetLocalKey {
    fn local_key(&self) -> Option<LocalKeyAny>;
}

impl<T> WidgetLocalKey for T {
    default fn local_key(&self) -> Option<LocalKeyAny> {
        None
    }
}

impl<K: 'static + PartialEq, W: Widget> WidgetLocalKey for LocalKey<K, W> {
    fn local_key(&self) -> Option<LocalKeyAny> {
        Some(LocalKeyAny { key: &self.key })
    }
}

//
// Helpers

trait PartialEqAny: Any {
    fn type_id(&self) -> TypeId;
    fn eq(&self, other: &dyn PartialEqAny) -> bool;
}

impl<T: 'static + PartialEq> PartialEqAny for T {
    fn type_id(&self) -> TypeId {
        TypeId::of::<T>()
    }

    fn eq(&self, other: &dyn PartialEqAny) -> bool {
        if TypeId::of::<T>() == PartialEqAny::type_id(other) {
            unsafe { return self.eq(&*(other as *const _ as *const T)) }
        } else {
            false
        }
    }
}