ferroui-base 0.3.0

The base library of FerroUI: the property system, layout, input, styling, media, text, animation, data binding and the compositor
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Port of `Rendering/SceneGraph/RenderDataResourcesTests.cs`.
//!
//! The table holds the typed resources of render data rather than any
//! object; the plain objects of upstream are custom draw operations, a
//! resource kind that has no value equality.

use super::scene_graph_test_support::TestCustomOperation;
use crate::rendering::composition::drawing::{RenderDataResource, RenderDataResources, NULL_HANDLE};
use crate::rendering::scene_graph::ICustomDrawOperation;
use crate::{Point, Rect};

fn new_object() -> std::sync::Arc<dyn ICustomDrawOperation> {
    TestCustomOperation::new()
}

fn resource(object: &std::sync::Arc<dyn ICustomDrawOperation>) -> Option<RenderDataResource> {
    Some(RenderDataResource::CustomDrawOperation(object.clone()))
}

fn is_same(resource: Option<&RenderDataResource>, object: &std::sync::Arc<dyn ICustomDrawOperation>) -> bool {
    matches!(resource, Some(RenderDataResource::CustomDrawOperation(stored)) if std::sync::Arc::ptr_eq(stored, object))
}

#[test]
fn intern_null_returns_null_handle() {
    let mut resources = RenderDataResources::default();
    assert_eq!(NULL_HANDLE, resources.intern(None));
    assert_eq!(0, resources.count());
}

#[test]
fn intern_same_reference_returns_same_handle() {
    let mut resources = RenderDataResources::default();
    let obj = new_object();

    let first = resources.intern(resource(&obj));
    let second = resources.intern(resource(&obj));

    assert_eq!(first, second);
    assert_eq!(1, resources.count());
}

#[test]
fn intern_distinct_references_return_distinct_handles() {
    let mut resources = RenderDataResources::default();
    let a = resources.intern(resource(&new_object()));
    let b = resources.intern(resource(&new_object()));

    assert_ne!(a, b);
    assert_eq!(2, resources.count());
}

#[test]
fn intern_equal_but_distinct_references_return_distinct_handles() {
    let mut resources = RenderDataResources::default();
    let a = resources.intern(resource(&equal_by_value()));
    let b = resources.intern(resource(&equal_by_value()));

    assert_ne!(a, b);
    assert_eq!(2, resources.count());
}

#[test]
fn indexer_returns_interned_resource() {
    let mut resources = RenderDataResources::default();
    let obj = new_object();

    let handle = resources.intern(resource(&obj));

    assert!(is_same(resources.get(handle), &obj));
}

#[test]
fn indexer_null_handle_returns_null() {
    let mut resources = RenderDataResources::default();
    resources.intern(resource(&new_object()));

    assert!(resources.get(NULL_HANDLE).is_none());
}

#[test]
fn append_deserialized_appends_without_deduplication() {
    let mut resources = RenderDataResources::default();
    let obj = new_object();

    let first = resources.append_deserialized(RenderDataResource::CustomDrawOperation(obj.clone()));
    let second = resources.append_deserialized(RenderDataResource::CustomDrawOperation(obj.clone()));

    assert_ne!(first, second);
    assert_eq!(2, resources.count());
    assert!(is_same(resources.get(first), &obj));
    assert!(is_same(resources.get(second), &obj));
}

#[test]
fn dispose_resets_the_table() {
    let mut resources = RenderDataResources::default();
    resources.intern(resource(&new_object()));

    resources.dispose();

    assert_eq!(0, resources.count());
}

/// `new EqualByValue()`: an object equal to every other object of its
/// kind. Custom draw operations compare with `equals`.
fn equal_by_value() -> std::sync::Arc<dyn ICustomDrawOperation> {
    struct EqualByValue;

    impl ICustomDrawOperation for EqualByValue {
        fn bounds(&self) -> Rect {
            Rect::default()
        }
        fn hit_test(&self, _p: Point) -> bool {
            false
        }
        fn render(&self, _context: &mut crate::media::ImmediateDrawingContext<'_>) {}
        // Equal to every operation: only `EqualByValue` instances are
        // compared in the test.
        fn equals(&self, _other: &dyn ICustomDrawOperation) -> bool {
            true
        }
        fn dispose(&self) {}
    }

    std::sync::Arc::new(EqualByValue)
}