dear-imgui-rs 0.15.1

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

use crate::sys;
use std::marker::PhantomData;

use super::super::util::finite_vec2;
use super::DrawListMut;

/// Tracks a clip rectangle pushed onto a draw-list clip stack.
///
/// The clip rectangle is popped when the token is dropped or when [`Self::pop`]
/// is called.
#[must_use]
pub struct DrawListClipRectToken<'draw_list> {
    draw_list: *mut sys::ImDrawList,
    _phantom: PhantomData<&'draw_list ()>,
}

impl<'draw_list> DrawListClipRectToken<'draw_list> {
    fn new(draw_list: *mut sys::ImDrawList) -> Self {
        Self {
            draw_list,
            _phantom: PhantomData,
        }
    }

    /// Pop the clip rectangle immediately instead of waiting for drop.
    #[doc(alias = "PopClipRect")]
    pub fn pop(self) {}

    /// Pop the clip rectangle immediately instead of waiting for drop.
    #[doc(alias = "PopClipRect")]
    pub fn end(self) {}
}

impl Drop for DrawListClipRectToken<'_> {
    fn drop(&mut self) {
        unsafe { sys::ImDrawList_PopClipRect(self.draw_list) }
    }
}

impl<'ui> DrawListMut<'ui> {
    /// Push a clip rectangle, optionally intersecting with the current clip rect.
    #[doc(alias = "PushClipRect")]
    pub fn push_clip_rect(
        &self,
        clip_rect_min: impl Into<sys::ImVec2>,
        clip_rect_max: impl Into<sys::ImVec2>,
        intersect_with_current: bool,
    ) -> DrawListClipRectToken<'_> {
        let clip_rect_min = finite_vec2(
            "DrawListMut::push_clip_rect()",
            "clip_rect_min",
            clip_rect_min,
        );
        let clip_rect_max = finite_vec2(
            "DrawListMut::push_clip_rect()",
            "clip_rect_max",
            clip_rect_max,
        );

        unsafe {
            sys::ImDrawList_PushClipRect(
                self.draw_list,
                clip_rect_min,
                clip_rect_max,
                intersect_with_current,
            )
        };
        DrawListClipRectToken::new(self.draw_list)
    }

    /// Push a full-screen clip rectangle.
    #[doc(alias = "PushClipRectFullScreen")]
    pub fn push_clip_rect_full_screen(&self) -> DrawListClipRectToken<'_> {
        unsafe { sys::ImDrawList_PushClipRectFullScreen(self.draw_list) };
        DrawListClipRectToken::new(self.draw_list)
    }

    /// Get current minimum clip rectangle point.
    pub fn clip_rect_min(&self) -> [f32; 2] {
        let out = unsafe { sys::ImDrawList_GetClipRectMin(self.draw_list) };
        out.into()
    }

    /// Get current maximum clip rectangle point.
    pub fn clip_rect_max(&self) -> [f32; 2] {
        let out = unsafe { sys::ImDrawList_GetClipRectMax(self.draw_list) };
        out.into()
    }

    /// Convenience: push a clip rect, run f, pop.
    pub fn with_clip_rect<F, R>(
        &self,
        clip_rect_min: impl Into<sys::ImVec2>,
        clip_rect_max: impl Into<sys::ImVec2>,
        f: F,
    ) -> R
    where
        F: FnOnce() -> R,
    {
        let _clip_rect = self.push_clip_rect(clip_rect_min, clip_rect_max, false);
        f()
    }
}