dear-imgui-rs 0.14.0

High-level Rust bindings to Dear ImGui v1.92.7 with docking, WGPU/GL backends, and extensions (ImPlot/ImPlot3D, ImNodes, ImGuizmo, file browser, reflection-based UI)
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 std::marker::PhantomData;
use std::rc::Rc;

use crate::fonts::Font;
use crate::sys;

use super::state::{current_context_font_atlas, font_atlas_contains_font, font_atlas_state};

/// A persistent, atlas-validated font handle.
///
/// `FontId` can be stored in application style state and later passed to
/// [`Ui::push_font`](crate::Ui::push_font), but it is not just a raw `ImFont*`.
/// The handle records the originating atlas and atlas generation. Safe push
/// APIs validate that the handle still belongs to the current context's atlas
/// and has not been invalidated by [`FontAtlas::clear`],
/// [`FontAtlas::clear_fonts`], or [`FontAtlas::remove_font`] before calling
/// Dear ImGui.
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct FontId {
    pub(crate) raw: *mut sys::ImFont,
    atlas: *mut sys::ImFontAtlas,
    atlas_stamp: u64,
    generation: u64,
    _not_send_sync: PhantomData<Rc<()>>,
}

impl FontId {
    pub(crate) fn from_raw_parts(font: *mut sys::ImFont, atlas: *mut sys::ImFontAtlas) -> Self {
        assert!(!font.is_null(), "FontId requires a non-null ImFont pointer");
        assert!(
            !atlas.is_null(),
            "FontId requires a non-null ImFontAtlas pointer"
        );
        let state = font_atlas_state(atlas);
        Self {
            raw: font,
            atlas,
            atlas_stamp: state.stamp,
            generation: state.generation,
            _not_send_sync: PhantomData,
        }
    }

    pub(crate) unsafe fn from_font(font: *mut sys::ImFont, caller: &str) -> Self {
        assert!(!font.is_null(), "{caller} requires a non-null font");
        let atlas = unsafe { (*font).OwnerAtlas };
        assert!(
            !atlas.is_null(),
            "{caller} requires the font to have an owning atlas"
        );
        Self::from_raw_parts(font, atlas)
    }
}

pub(crate) fn validate_font_id_for_current_context(id: FontId, caller: &str) -> *mut sys::ImFont {
    let atlas = current_context_font_atlas(caller);
    validate_font_id_for_atlas(id, atlas, caller)
}

pub(crate) fn validate_font_for_current_context(font: &Font, caller: &str) -> *mut sys::ImFont {
    let atlas = current_context_font_atlas(caller);
    validate_font_for_atlas(font, atlas, caller)
}

pub(crate) fn validate_font_id_for_atlas(
    id: FontId,
    atlas: *mut sys::ImFontAtlas,
    caller: &str,
) -> *mut sys::ImFont {
    assert!(!id.raw.is_null(), "{caller} received a null FontId");
    assert!(
        std::ptr::addr_eq(id.atlas.cast_const(), atlas.cast_const()),
        "{caller} received a FontId from a different font atlas"
    );
    let state = font_atlas_state(atlas);
    assert!(
        state.stamp == id.atlas_stamp,
        "{caller} received a FontId from a destroyed or reused font atlas"
    );
    assert!(
        state.generation == id.generation,
        "{caller} received a stale FontId invalidated by font atlas mutation"
    );
    assert!(
        font_atlas_contains_font(atlas, id.raw),
        "{caller} received a FontId that is not present in the current font atlas"
    );
    id.raw
}

pub(crate) fn validate_font_for_atlas(
    font: &Font,
    atlas: *mut sys::ImFontAtlas,
    caller: &str,
) -> *mut sys::ImFont {
    let raw = font.raw();
    assert!(!raw.is_null(), "{caller} received a null font");
    unsafe {
        let owner = (*raw).OwnerAtlas;
        assert!(
            std::ptr::addr_eq(owner.cast_const(), atlas.cast_const()),
            "{caller} received a font from a different font atlas"
        );
    }
    assert!(
        font_atlas_contains_font(atlas, raw),
        "{caller} received a font that is not present in the current font atlas"
    );
    raw
}