easy_imgui/

lib.rs

#![allow(clippy::needless_doctest_main)]

/*!
 * Crate for easy integration of the [Dear ImGui][dearimgui] library.
 *
 * This crate is a bind to the Dear ImGui library only. There is also a matching rendering
 * library, [`easy-imgui-renderer`](../easy_imgui_renderer/index.html), that renders the UI using OpenGl, and a matching
 * window-integrated library, [`easy-imgui-window`](../easy_imgui_window/index.html), that enables to build a full desktop
 * application in just a few lines.
 *
 * If you don't know where to start, then start with the latter. Take a look at the [examples].
 * The simplest `easy-imgui` program would be something like this:
 *
 * ## A note about labels and ids.
 *
 * In [Dear ImGui][1], many controls take a string argument as both a label and an identifier. You can
 * use `##` or a `###` as a separator between the label and the idenfifier if you want to make them
 * apart.
 *
 * In `easy_imgui`, since version 0.8, this is represented by the [`LblId`] type, not by a plain
 * string.
 *
 * If you want to keep on using the same type just write `lbl("foo")`, `lbl("foo##bar")` or
 * `"foo".into()` and it will behave the same as before. But if you want to use them
 * separately, you can write `lbl_id("Label", "id")` and it will join the two strings for you,
 * separated by `###`. This is particularly nice if you pretend to translate the UI: the labels change,
 * but the ids should remain constant.
 *
 * Some functions only take an id, no label. Those will take an argument of type [`Id`], that you
 * can construct with the function [`id`], that will prepend the `###` or [`raw_id`] to use the
 * string as-is. Like before, you can also write `"id".into()` to behave as previous versions of
 * this crate.
 *
 * [1]: https://github.com/ocornut/imgui/blob/master/docs/FAQ.md#q-about-the-id-stack-system
 *
 * ```rust, no_run
 * use easy_imgui_window::{
 *     easy_imgui as imgui,
 *     MainWindow,
 *     MainWindowWithRenderer,
 *     Application, AppHandler, Args, EventResult,
 *     winit,
 * };
 * use winit::{
 *     event_loop::{EventLoop, ActiveEventLoop},
 *     event::WindowEvent,
 * };
 *
 * // The App type, this will do the actual app. stuff.
 * struct App;
 *
 * // This trait handles the UI building.
 * impl imgui::UiBuilder for App {
 *     // There are other function in this trait, but this is the only one
 *     // mandatory and the most important: it build the UI.
 *     fn do_ui(&mut self, ui: &imgui::Ui<Self>) {
 *         ui.show_demo_window(None);
 *     }
 * }
 *
 * // This trait handles the application & event loop stuff.
 * impl Application for App {
 *     // The user event type, `()` if not needed.
 *     type UserEvent = ();
 *     // Custom data type, `()` if not needed.
 *     type Data = ();
 *
 *     // Create the app object.
 *     fn new(_: Args<()>) -> App {
 *         App
 *     }
 *     // Handle one window event.
 *     // There are a few other functions for other types of events.
 *     fn window_event(&mut self, args: Args<()>, _event: WindowEvent, res: EventResult) {
 *         if res.window_closed {
 *             args.event_loop.exit();
 *         }
 *     }
 * }
 *
 * fn main() {
 *     // Create a `winit` event loop.
 *     let event_loop = EventLoop::new().unwrap();
 *     // Create an application handler.
 *     let mut main = AppHandler::<App>::default();
 *     // Optionally set up the window attributes.
 *     main.attributes().title = String::from("Example");
 *     // Run the loop
 *     event_loop.run_app(&mut main);
 * }
 * ```
 *
 * # Alternatives
 * This `crate` is similar to [`imgui-rs`][imguirs], and it is inpired by it, but with a few key
 * differences:
 *  * It doesn't use any C++-to-C api generator, as `rust-bindgen` is able to import simple C++
 *    libraries directly.
 *  * It is lower level, there are fewer high-level abstractions over the ImGui API. This means
 *    that:
 *      * This API is less Rusty than imgui-rs's.
 *      * If you know how to use Dear ImGui, then you know how to use easy-imgui.
 *      * It is far easier to upgrade to new Dear ImGui versions.
 *
 * # Features
 * These are the available features for this crate:
 *  * `freetype`: Uses an external _freetype_ font loader for Dear ImGui, instead of the embedded
 *    `stb_truetype` library.
 *
 * # Usage
 * It is easier to use one of the higher level crates [`easy-imgui-window`](../easy_imgui_window/index.html) or [`easy-imgui-renderer`](../easy_imgui_renderer/index.html).
 * But if you intend to render the UI yourself, then you can use this directly.
 *
 * These are the main pieces of this crate:
 *  * [`Context`]: It represents the ImGui context. In DearImgui this is a global variable. Here it
 *    is a thread-local variable. Still, since it is implicit in most API calls, most uses of this
 *    type are unsafe. If you use `easy-imgui-window` or `easy-imgui-renderer` you will rarely
 *    need to touch this type directly.
 *  * [`Ui`]: A frame that is being built. Most ImGui functions are members of `Ui`.
 *  * [`UiBuilder`]: A trait that your application implements do build your user interface.
 *
 * If you want to use this library directly, just create a [`Context`], set up its properties, and
 * when you want to render a frame do [`Context::set_current`] and then [`CurrentContext::do_frame`].
 *
 * If you use one of the helper crates then you will just implement `UiBuilder` and get a `Ui` for
 * free.
 *
 * # Conventions
 * This crate follows a series of naming conventions to make the API more predictable,
 * particularly with the [`Ui`] member functions:
 *  * A [`Pushable`] is any value that can be made active by a _push_ function and inactive by a
 *    corresponding _pop_ function. Examples are styles, colors, fonts...
 *  * A [`Hashable`] is any value that can be used to build an ImGui hash id. Ideally there should
 *    be one of these everywhere, but the Dear ImGui API it not totally othogonal here...
 *  * A function without special prefix or suffix does the same thing as its Dear ImGui
 *    counterpart. For example [`Ui::button`] calls `ImGui_Button`.
 *  * A function name that contains the `with` word takes a function that is called immediately. It
 *    corresponds to a pair of `*Begin` and `*End` functions in Dear ImGui. The function is called
 *    between these two functions. The value returned will be that of the function.
 *      * If the function is called based on some condition, such as with `ImGui_BeginChild`, then there
 *        will be another function with prefix `with_always_` that takes a function with a bool
 *        argument `opened: bool`, that can be used if you need the function to be called even if the
 *        condition is not met.
 *  * A function name that ends as `_config` will create a builder object (with the `must_use`
 *    annotation). This object will have a few properties to be set and a `build` or a
 *    `with` function to create the actual UI element.
 *  * Most builder object have a `push_for_begin` function, that will set up the pushable to be
 *    used only for the `begin` part of the UI. This is useful for example to set up the style for a
 *    window but not for its contents.
 *
 * When a function takes a value of type `String` this crate will usually take a generic `impl IntoCStr`.
 * This is an optimization that allows you to pass either a `String`, a `&str`, a `CString` or a
 * `&CStr`, avoiding an extra allocation if it is not really necessary. If you pass a constant
 * string and have a recent Rust compiler you can pass a literal `CStr` with the new syntax `c"hello"`.
 *
 *
 *
 *
 * [dearimgui]: https://github.com/ocornut/imgui
 * [imguirs]: https://github.com/imgui-rs/imgui-rs
 * [examples]: ../../../easy-imgui/examples
 */

// Too many unsafes ahead
#![allow(clippy::missing_safety_doc, clippy::too_many_arguments)]

pub use cgmath;
use easy_imgui_sys::*;
pub use either::Either;
use std::borrow::Cow;
use std::cell::RefCell;
use std::ffi::{CStr, CString, OsString, c_char, c_void};
use std::marker::PhantomData;
use std::mem::MaybeUninit;
use std::ops::{Deref, DerefMut};
use std::ptr::{NonNull, null, null_mut};
use std::time::Duration;

// Adds `repr(transparent)` and basic conversions
macro_rules! transparent_options {
    ( $($options:ident)* ; $(#[$attr:meta])* $vis:vis struct $outer:ident ( $inner:ident); ) => {
        $(#[$attr])*
        #[repr(transparent)]
        $vis struct $outer($inner);

        $( transparent_options! { @OPTS $options $outer $inner } )*

        impl $outer {
            /// Converts a native reference into a wrapper reference.
            pub fn cast(r: &$inner) -> &$outer {
                unsafe { &*<*const $inner>::cast(r) }
            }

            /// Converts a native reference into a wrapper reference.
            ///
            /// It is safe because if you have a reference to the native reference, you already can change anything.
            pub fn cast_mut(r: &mut $inner) -> &mut $outer {
                unsafe { &mut *<*mut $inner>::cast(r) }
            }
        }
    };

    ( @OPTS Deref $outer:ident $inner:ident) => {
        impl std::ops::Deref for $outer {
            type Target = $inner;
            fn deref(&self) -> &Self::Target {
                &self.0
            }
        }

        impl $outer {
            /// Gets a reference to the native wrapper struct.
            pub fn get(&self) -> &$inner {
                &self.0
            }
        }
    };

    ( @OPTS DerefMut $outer:ident $inner:ident) => {
        impl std::ops::DerefMut for $outer {
            fn deref_mut(&mut self) -> &mut $inner {
                &mut self.0
            }
        }
        impl $outer {
            pub fn get_mut(&mut self) -> &mut $inner {
                &mut self.0
            }
        }

    };
}

// This adds a Defer<Target $inner>.
macro_rules! transparent {
    ( $($tt:tt)* ) => {
         transparent_options! { Deref ; $($tt)* }
    };
}

// This adds a DerefMut in addition to the Defer<Target $inner>.
macro_rules! transparent_mut {
    ( $($tt:tt)* ) => {
         transparent_options! { Deref DerefMut ; $($tt)* }
    };
}

/// A type alias of the `cgmath::Vector2<f32>`.
///
/// Used in this crate to describe a 2D position or size.
/// The equivalent type in Dear ImGui would be [`ImVec2`].
pub type Vector2 = cgmath::Vector2<f32>;

#[cfg(feature = "clipboard")]
pub mod clipboard;
mod enums;
mod fontloader;
#[cfg(feature = "future")]
pub mod future;
mod idler;
mod multisel;
pub mod style;

pub use easy_imgui_sys::{self, ImGuiID, ImGuiSelectionUserData};
pub use enums::*;
pub use fontloader::{GlyphBuildFlags, GlyphLoader, GlyphLoaderArg};
pub use idler::Idler;
pub use image;
pub use mint;
pub use multisel::*;

use image::GenericImage;

// Here we use a "generation value" to avoid calling stale callbacks. It shouldn't happen, but just
// in case, as it would cause undefined behavior.
// The generation value is taken from the ImGui frame number, that is increased every frame.
// The callback id itself is composed by combining the callback index with the generation value.
// When calling a callback, if the generation value does not match the callback is ignored.
const GEN_BITS: u32 = 8;
const GEN_ID_BITS: u32 = usize::BITS - GEN_BITS;
const GEN_MASK: usize = (1 << GEN_BITS) - 1;
const GEN_ID_MASK: usize = (1 << GEN_ID_BITS) - 1;

fn merge_generation(id: usize, gen_id: usize) -> usize {
    if (id & GEN_ID_MASK) != id {
        panic!("UI callback overflow")
    }
    (gen_id << GEN_ID_BITS) | id
}
fn remove_generation(id: usize, gen_id: usize) -> Option<usize> {
    if (id >> GEN_ID_BITS) != (gen_id & GEN_MASK) {
        None
    } else {
        Some(id & GEN_ID_MASK)
    }
}

/// Helper function to create a `Vector2`.
pub fn to_v2(v: impl Into<mint::Vector2<f32>>) -> Vector2 {
    let v = v.into();
    Vector2 { x: v.x, y: v.y }
}
/// Helper function to create a `Vector2`.
pub const fn vec2(x: f32, y: f32) -> Vector2 {
    Vector2 { x, y }
}
/// Helper function to create a `ImVec2`.
pub const fn im_vec2(x: f32, y: f32) -> ImVec2 {
    ImVec2 { x, y }
}
/// Helper function to create a `ImVec2`.
pub fn v2_to_im(v: impl Into<Vector2>) -> ImVec2 {
    let v = v.into();
    ImVec2 { x: v.x, y: v.y }
}
/// Helper function to create a `Vector2`.
pub fn im_to_v2(v: impl Into<ImVec2>) -> Vector2 {
    let v = v.into();
    Vector2 { x: v.x, y: v.y }
}

/// A zero Vector2.
pub const VEC2_ZERO: Vector2 = vec2(0.0, 0.0);

/// A color is stored as a `[r, g, b, a]`, each value between 0.0 and 1.0.
#[derive(Debug, Copy, Clone, PartialEq)]
#[repr(C)]
pub struct Color {
    /// Red component
    pub r: f32,
    /// Green component
    pub g: f32,
    /// Blue component
    pub b: f32,
    /// Alpha component
    pub a: f32,
}
impl Color {
    // Primary and secondary colors
    /// Transparent color: rgba(0, 0, 0, 0)
    pub const TRANSPARENT: Color = Color::new(0.0, 0.0, 0.0, 0.0);
    /// White color: rgba(255, 255, 255, 1)
    pub const WHITE: Color = Color::new(1.0, 1.0, 1.0, 1.0);
    /// Black color: rgba(0, 0, 0, 1)
    pub const BLACK: Color = Color::new(0.0, 0.0, 0.0, 1.0);
    /// Red color: rgba(255, 0, 0, 1)
    pub const RED: Color = Color::new(1.0, 0.0, 0.0, 1.0);
    /// Green color: rgba(0, 255, 0, 1)
    pub const GREEN: Color = Color::new(0.0, 1.0, 0.0, 1.0);
    /// Blue color: rgba(0, 0, 255, 1)
    pub const BLUE: Color = Color::new(0.0, 0.0, 1.0, 1.0);
    /// Yellow color: rgba(255, 255, 0, 1)
    pub const YELLOW: Color = Color::new(1.0, 1.0, 0.0, 1.0);
    /// Magenta color: rgba(255, 0, 255, 1)
    pub const MAGENTA: Color = Color::new(1.0, 0.0, 1.0, 1.0);
    /// Cyan color: rgba(0, 255, 255, 1)
    pub const CYAN: Color = Color::new(0.0, 1.0, 1.0, 1.0);

    /// Builds a new color from its components
    pub const fn new(r: f32, g: f32, b: f32, a: f32) -> Color {
        Color { r, g, b, a }
    }
    /// Converts a `Color` into a packed `u32` value, required by some Dear ImGui functions.
    pub fn as_u32(&self) -> u32 {
        unsafe { ImGui_ColorConvertFloat4ToU32(&(*self).into()) }
    }
}
impl AsRef<[f32; 4]> for Color {
    fn as_ref(&self) -> &[f32; 4] {
        // SAFETY: Self is repr(C) so layout compatible with an array
        unsafe { std::mem::transmute::<&Color, &[f32; 4]>(self) }
    }
}
impl AsMut<[f32; 4]> for Color {
    fn as_mut(&mut self) -> &mut [f32; 4] {
        // SAFETY: Self is repr(C) so layout compatible with an array
        unsafe { std::mem::transmute::<&mut Color, &mut [f32; 4]>(self) }
    }
}
impl From<ImVec4> for Color {
    #[inline]
    fn from(c: ImVec4) -> Color {
        Color::new(c.x, c.y, c.z, c.w)
    }
}
impl From<Color> for ImVec4 {
    #[inline]
    fn from(c: Color) -> ImVec4 {
        ImVec4 {
            x: c.r,
            y: c.g,
            z: c.b,
            w: c.a,
        }
    }
}

/// The result of processing an event in the ImGui loop.
///
/// This is a convenient type to be returned from the backend message processig.
#[derive(Debug, Default, Clone)]
pub struct EventResult {
    /// The user requested to close the window. You can break the loop or ignore it, at will.
    pub window_closed: bool,
    /// ImGui requests handling the mouse, your application should ignore mouse events.
    pub want_capture_mouse: bool,
    /// ImGui requests handling the keyboard, your application should ignore keyboard events.
    pub want_capture_keyboard: bool,
    /// ImGui requests handling text input, your application should ignore text events.
    pub want_text_input: bool,
}

impl EventResult {
    pub fn new(imgui: &RawContext, window_closed: bool) -> Self {
        let io = imgui.io();
        EventResult {
            window_closed,
            want_capture_mouse: io.want_capture_mouse(),
            want_capture_keyboard: io.want_capture_keyboard(),
            want_text_input: io.want_text_input(),
        }
    }
}

/// The main ImGui context.
pub struct Context {
    imgui: NonNull<RawContext>,
    ini_file_name: Option<CString>,
}

/// A context that we are sure is made current.
pub struct CurrentContext<'a> {
    ctx: &'a mut Context,
}

/// Builder for a `Context`.
///
/// Call `build()` to build the context.
#[derive(Debug)]
pub struct ContextBuilder {
    clipboard: bool,
    debug_highlight_id_conflicts: bool,
    ini_file_name: Option<String>,
}

impl Default for ContextBuilder {
    fn default() -> ContextBuilder {
        ContextBuilder::new()
    }
}

impl ContextBuilder {
    /// Creates a builder with default values.
    ///
    /// Defaults are:
    /// * hightlight ids only on debug builds
    /// * ini file name disabled
    pub fn new() -> ContextBuilder {
        ContextBuilder {
            clipboard: true,
            debug_highlight_id_conflicts: cfg!(debug_assertions),
            ini_file_name: None,
        }
    }
    /// Allows to disable the handling of the clipboard.
    ///
    /// Default is enabled. Note that the clipboard from this module will only work if the feature `clipboard` is selected.
    pub fn set_clipboard(&mut self, clipboard: bool) -> &mut Self {
        self.clipboard = clipboard;
        self
    }
    /// Sets the debug highlight id
    pub fn set_debug_highlight_id_conflicts(
        &mut self,
        debug_highlight_id_conflicts: bool,
    ) -> &mut Self {
        self.debug_highlight_id_conflicts = debug_highlight_id_conflicts;
        self
    }
    /// Sets the ini file name
    pub fn set_ini_file_name(&mut self, ini_file_name: Option<&str>) -> &mut Self {
        self.ini_file_name = ini_file_name.map(|s| s.to_string());
        self
    }
    /// Builds the ImGui context.
    ///
    /// SAFETY: read `Context::new()`.
    #[must_use]
    pub unsafe fn build(&self) -> Context {
        let imgui;
        // Probably not needed but just in case
        unsafe {
            imgui = ImGui_CreateContext(null_mut());
            ImGui_SetCurrentContext(imgui);
        }
        let imgui = NonNull::new(imgui).unwrap();
        let mut ctx = Context {
            imgui: imgui.cast(),
            ini_file_name: None,
        };
        ctx.set_ini_file_name(self.ini_file_name.as_deref());

        let io = ctx.io_mut();
        io.font_atlas_mut().0.TexPixelsUseColors = true;

        let io = unsafe { io.inner() };

        io.ConfigDpiScaleFonts = true;
        io.ConfigDebugHighlightIdConflicts = self.debug_highlight_id_conflicts;

        #[cfg(feature = "clipboard")]
        if self.clipboard {
            clipboard::setup(&mut ctx);
        }

        ctx
    }
}

impl Context {
    /// Creates a new ImGui context with default values.
    ///
    /// SAFETY: It is unsafe because it makes the context current, and that may brake the current context
    /// if called at the wrong time.
    pub unsafe fn new() -> Context {
        unsafe { ContextBuilder::new().build() }
    }

    /// Sets the size and scale of the context area.
    pub unsafe fn set_size(&mut self, size: Vector2, scale: f32) {
        unsafe {
            self.io_mut().inner().DisplaySize = v2_to_im(size);
            if self.io().display_scale() != scale {
                self.io_mut().inner().DisplayFramebufferScale = ImVec2 { x: scale, y: scale };
            }
        }
    }

    /// Makes this context the current one.
    ///
    /// SAFETY: Do not make two different contexts current at the same time
    /// in the same thread.
    pub unsafe fn set_current(&mut self) -> CurrentContext<'_> {
        unsafe {
            ImGui_SetCurrentContext(self.imgui.as_mut().inner());
            CurrentContext { ctx: self }
        }
    }

    /// Sets the ini file where ImGui persists its data.
    ///
    /// By default is None, that means no file is saved.
    pub fn set_ini_file_name(&mut self, ini_file_name: Option<&str>) {
        let Some(ini_file_name) = ini_file_name else {
            self.ini_file_name = None;
            unsafe {
                self.io_mut().inner().IniFilename = null();
            }
            return;
        };

        let Ok(ini) = CString::new(ini_file_name) else {
            // NUL in the file namem, ignored
            return;
        };

        let ini = self.ini_file_name.insert(ini);
        unsafe {
            self.io_mut().inner().IniFilename = ini.as_ptr();
        }
    }
    /// Gets the ini file set previously by `set_ini_file_name`.
    pub fn ini_file_name(&self) -> Option<&str> {
        let ini = self.ini_file_name.as_deref()?.to_str().unwrap_or_default();
        Some(ini)
    }
}

impl CurrentContext<'_> {
    /// Builds and renders a UI frame.
    ///
    /// * `app`: `UiBuilder` to be used to build the frame.
    /// * `re_render`: function to be called after `app.do_ui` but before rendering.
    /// * `render`: function to do the actual render.
    pub unsafe fn do_frame<A: UiBuilder>(
        &mut self,
        app: &mut A,
        pre_render: impl FnOnce(&mut Self),
        render: impl FnOnce(&ImDrawData),
    ) {
        unsafe {
            let mut ui = Ui {
                imgui: self.ctx.imgui,
                data: std::ptr::null_mut(),
                generation: ImGui_GetFrameCount() as usize % 1000 + 1, // avoid the 0
                callbacks: RefCell::new(Vec::new()),
            };

            self.io_mut().inner().BackendLanguageUserData =
                (&raw const ui).cast::<c_void>().cast_mut();
            struct UiPtrToNullGuard<'a, 'b>(&'a mut CurrentContext<'b>);
            impl Drop for UiPtrToNullGuard<'_, '_> {
                fn drop(&mut self) {
                    unsafe {
                        self.0.io_mut().inner().BackendLanguageUserData = null_mut();
                    }
                }
            }
            let ctx_guard = UiPtrToNullGuard(self);

            // This guards for panics during the frame.
            struct FrameGuard;
            impl Drop for FrameGuard {
                fn drop(&mut self) {
                    unsafe {
                        ImGui_EndFrame();
                    }
                }
            }

            ImGui_NewFrame();

            let end_frame_guard = FrameGuard;
            app.do_ui(&ui);
            std::mem::drop(end_frame_guard);

            pre_render(ctx_guard.0);
            app.pre_render(ctx_guard.0);

            ImGui_Render();

            ui.data = app;

            // This is the same pointer, but without it, there is something fishy about stacked borrows
            // and the mutable access to `ui` above.
            ctx_guard.0.io_mut().inner().BackendLanguageUserData =
                (&raw const ui).cast::<c_void>().cast_mut();

            let draw_data = ImGui_GetDrawData();
            render(&*draw_data);
        }
    }
}

impl Drop for Context {
    fn drop(&mut self) {
        unsafe {
            #[cfg(feature = "clipboard")]
            clipboard::release(self);

            ImGui_DestroyContext(self.imgui.as_mut().inner());
        }
    }
}

transparent! {
    /// Safe thin wrapper for ImGuiContext.
    ///
    /// This has common read-only functions.
    pub struct RawContext(ImGuiContext);
}

impl RawContext {
    /// Gets the current ImGui context.
    ///
    /// SAFETY: unsafe because the reference lifetime is not well defined.
    #[inline]
    pub unsafe fn current<'a>() -> &'a RawContext {
        unsafe { RawContext::cast(&*ImGui_GetCurrentContext()) }
    }
    /// Converts a raw DearImGui context pointer into a `&RawContext``.
    #[inline]
    pub unsafe fn from_ptr<'a>(ptr: *mut ImGuiContext) -> &'a RawContext {
        unsafe { RawContext::cast(&*ptr) }
    }
    /// Converts a raw DearImGui context pointer into a `&mut RawContext``.
    #[inline]
    pub unsafe fn from_ptr_mut<'a>(ptr: *mut ImGuiContext) -> &'a mut RawContext {
        unsafe { RawContext::cast_mut(&mut *ptr) }
    }
    /// Gets a reference to the actual DearImGui context struct.
    #[inline]
    pub unsafe fn inner(&mut self) -> &mut ImGuiContext {
        &mut self.0
    }
    /// Returns a safe wrapper for the `PlatformIo`.
    #[inline]
    pub fn platform_io(&self) -> &PlatformIo {
        PlatformIo::cast(&self.PlatformIO)
    }
    /// Returns an unsafe mutable wrapper for the `PlatformIo`.
    #[inline]
    pub unsafe fn platform_io_mut(&mut self) -> &mut PlatformIo {
        unsafe { PlatformIo::cast_mut(&mut self.inner().PlatformIO) }
    }

    /// Returns a safe wrapper for the IO.
    #[inline]
    pub fn io(&self) -> &Io {
        Io::cast(&self.IO)
    }
    /// Returns a safe mutable wrapper for the IO.
    ///
    /// Use `io_mut().inner()` to get the unsafe wrapper
    #[inline]
    pub fn io_mut(&mut self) -> &mut IoMut {
        unsafe { IoMut::cast_mut(&mut self.inner().IO) }
    }
    /// Returns a reference for the current style definition.
    #[inline]
    pub fn style(&self) -> &style::Style {
        style::Style::cast(&self.Style)
    }
    /// Gets a mutable reference to the style definition.
    #[inline]
    pub fn style_mut(&mut self) -> &mut style::Style {
        // SAFETY: Changing the style is only unsafe during the frame (use pushables there),
        // but during a frame the context is borrowed inside the `&Ui`, that is immutable.
        unsafe { style::Style::cast_mut(&mut self.inner().Style) }
    }

    /// Gets a reference to the main viewport
    pub fn get_main_viewport(&self) -> &Viewport {
        unsafe {
            let ptr = (*self.Viewports)[0];
            Viewport::cast(&(*ptr)._base)
        }
    }
}

impl Deref for Context {
    type Target = RawContext;
    fn deref(&self) -> &RawContext {
        unsafe { self.imgui.as_ref() }
    }
}
impl DerefMut for Context {
    fn deref_mut(&mut self) -> &mut RawContext {
        unsafe { self.imgui.as_mut() }
    }
}

impl Deref for CurrentContext<'_> {
    type Target = RawContext;
    fn deref(&self) -> &RawContext {
        self.ctx
    }
}
impl DerefMut for CurrentContext<'_> {
    fn deref_mut(&mut self) -> &mut RawContext {
        self.ctx
    }
}

impl<A> Deref for Ui<A> {
    type Target = RawContext;
    fn deref(&self) -> &RawContext {
        unsafe { self.imgui.as_ref() }
    }
}

// No DerefMut for Ui, sorry.

/// The main trait that the user must implement to create a UI.
pub trait UiBuilder {
    /// This function is run after `do_ui` but before rendering.
    ///
    /// It can be used to clear the framebuffer, or prerender something.
    fn pre_render(&mut self, _ctx: &mut CurrentContext<'_>) {}
    /// User the `ui` value to create a UI frame.
    ///
    /// This is equivalent to the Dear ImGui code between `NewFrame` and `EndFrame`.
    fn do_ui(&mut self, ui: &Ui<Self>);
}

/// The type of default font selected.
pub enum DefaultFontSelector {
    /// Let ImGui decide the right font, based on size and scale.
    Auto,
    /// Select the pixel-clean classic default font.
    Bitmap,
    /// Select the new scalable font.
    Vector,
}

enum TtfData {
    Bytes(Cow<'static, [u8]>),
    DefaultFont(DefaultFontSelector),
    CustomLoader(fontloader::BoxGlyphLoader),
}

/// A font to be fed to the ImGui atlas.
pub struct FontInfo {
    ttf: TtfData,
    size: f32,
    name: String,
    flags: FontFlags,
}

impl FontInfo {
    /// Creates a new `FontInfo` from a TTF content and a font size.
    pub fn new(ttf: impl Into<Cow<'static, [u8]>>) -> FontInfo {
        FontInfo {
            ttf: TtfData::Bytes(ttf.into()),
            size: 0.0, // Default from DearImGui
            name: String::new(),
            flags: FontFlags::None,
        }
    }
    /// Sets the name of this font.
    ///
    /// It is used only for diagnostics and the "demo" window.
    pub fn set_name(mut self, name: impl Into<String>) -> Self {
        self.name = name.into();
        self
    }
    /// Sets the legacy size of this font.
    ///
    /// The size of the default font (the first one registered) is saved
    /// as the default font size. Any other font size is not actually used,
    /// although it is visible as `Font:.LegacySize`.
    pub fn set_size(mut self, size: f32) -> Self {
        self.size = size;
        self
    }
    /// Creates a `FontInfo` using the embedded default Dear ImGui font.
    pub fn default_font() -> FontInfo {
        Self::default_font_with(DefaultFontSelector::Auto)
    }
    /// Creates a `FontInfo` using the embedded default Dear ImGui font, either the bitmap or the vector one.
    pub fn default_font_with(sel: DefaultFontSelector) -> FontInfo {
        FontInfo {
            ttf: TtfData::DefaultFont(sel),
            size: 0.0,
            name: String::new(),
            flags: FontFlags::None,
        }
    }
    /// Registers a custom font loader.
    ///
    /// A custom font loader is any static type that implements the trait `GlyphLoader`.
    pub fn custom<GL: GlyphLoader + 'static>(glyph_loader: GL) -> FontInfo {
        let t = fontloader::BoxGlyphLoader::from(Box::new(glyph_loader));
        FontInfo {
            ttf: TtfData::CustomLoader(t),
            size: 0.0,
            name: String::new(),
            flags: FontFlags::None,
        }
    }
}

/// Represents any type that can be converted into something that can be deref'ed to a `&CStr`.
pub trait IntoCStr: Sized {
    /// The type that can actually be converted into a `CStr`.
    type Temp: Deref<Target = CStr>;
    /// Convert this value into a `Temp` that can be converted into a `CStr`.
    fn into(self) -> Self::Temp;
    /// Convert this value directly into a `CString`.
    fn into_cstring(self) -> CString;
    /// Length in bytes of the `CString` within.
    fn len(&self) -> usize;
    /// Checks whether the string is empty.
    fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Adds the bytes of the `CStr` within to the given `Vec`.
    ///
    /// SAFETY: Unsafe because we will not check there are no NULs.
    /// Reimplement this if `fn into()` does extra allocations.
    unsafe fn push_to_non_null_vec(self, bs: &mut Vec<u8>) {
        let c = IntoCStr::into(self);
        let c = c.to_bytes();
        bs.extend(c);
    }
}

impl IntoCStr for &str {
    type Temp = CString;

    fn into(self) -> Self::Temp {
        CString::new(self).unwrap()
    }
    fn into_cstring(self) -> CString {
        IntoCStr::into(self)
    }
    fn len(&self) -> usize {
        str::len(self)
    }
    unsafe fn push_to_non_null_vec(self, bs: &mut Vec<u8>) {
        let c = self.as_bytes();
        if c.contains(&0) {
            panic!("NUL error");
        }
        bs.extend(c);
    }
}
impl IntoCStr for &String {
    type Temp = CString;

    fn into(self) -> Self::Temp {
        CString::new(self.as_str()).unwrap()
    }
    fn into_cstring(self) -> CString {
        IntoCStr::into(self)
    }
    fn len(&self) -> usize {
        self.as_str().len()
    }
    unsafe fn push_to_non_null_vec(self, bs: &mut Vec<u8>) {
        unsafe {
            self.as_str().push_to_non_null_vec(bs);
        }
    }
}
impl IntoCStr for String {
    type Temp = CString;

    fn into(self) -> Self::Temp {
        CString::new(self).unwrap()
    }
    fn into_cstring(self) -> CString {
        IntoCStr::into(self)
    }
    fn len(&self) -> usize {
        self.len()
    }
}
impl IntoCStr for &CStr {
    type Temp = Self;
    fn into(self) -> Self {
        self
    }
    fn into_cstring(self) -> CString {
        self.to_owned()
    }
    fn len(&self) -> usize {
        self.to_bytes().len()
    }
}
impl IntoCStr for CString {
    type Temp = Self;

    fn into(self) -> Self {
        self
    }
    fn into_cstring(self) -> CString {
        self
    }
    fn len(&self) -> usize {
        self.as_bytes().len()
    }
}
impl<'a> IntoCStr for &'a CString {
    type Temp = &'a CStr;

    fn into(self) -> &'a CStr {
        self.as_c_str()
    }
    fn into_cstring(self) -> CString {
        self.clone()
    }
    fn len(&self) -> usize {
        self.as_c_str().len()
    }
}

impl<'a, B> IntoCStr for Cow<'a, B>
where
    B: 'a + ToOwned + ?Sized,
    &'a B: IntoCStr,
    B::Owned: IntoCStr,
    <&'a B as IntoCStr>::Temp: Into<Cow<'a, CStr>>,
{
    type Temp = Cow<'a, CStr>;

    fn into(self) -> Cow<'a, CStr> {
        match self {
            Cow::Owned(o) => Cow::Owned(IntoCStr::into_cstring(o)),
            Cow::Borrowed(b) => IntoCStr::into(b).into(),
        }
    }
    fn into_cstring(self) -> CString {
        match self {
            Cow::Owned(o) => o.into_cstring(),
            Cow::Borrowed(b) => b.into_cstring(),
        }
    }
    fn len(&self) -> usize {
        match self {
            Cow::Owned(o) => o.len(),
            Cow::Borrowed(b) => b.len(),
        }
    }
}

/// A string that works as a widget identifier.
///
/// Think of for example `"###ok"`.
///
/// Use the function `id()` to build it.
pub struct Id<C: IntoCStr>(C);

/// A string that works as both a label and identifier.
///
/// For example `"Enter the data###data1"`.
///
/// Prefer to use function `lbl_id()` function to construct it from two strings.
///
/// Or use function `lbl()` to build it from an old compatible `label###id`.
pub struct LblId<C: IntoCStr>(C);

impl<C: IntoCStr> Id<C> {
    /// Converts this `Id` into a value that can be converted to a `CStr`.
    pub fn into(self) -> C::Temp {
        self.0.into()
    }
    /// Converts this `Id` into a `IntoCStr`.
    pub fn into_inner(self) -> C {
        self.0
    }
}

impl<C: IntoCStr> LblId<C> {
    /// Converts this `LblId` into a value that can be converted to a `CStr`.
    pub fn into(self) -> C::Temp {
        self.0.into()
    }
    /// Converts this `LblId` into a `IntoCStr`.
    pub fn into_inner(self) -> C {
        self.0
    }
}

/// Uses the given string as an ImGui id.
///
/// It prepends `###`, for consistency with `lbl_id()`.
pub fn id<C: IntoCStr>(c: C) -> Id<CString> {
    let mut bs = Vec::with_capacity(c.len() + 4);
    bs.push(b'#');
    bs.push(b'#');
    bs.push(b'#');
    // SAFETY:
    // Converts one CString into another CString with the ### prefix.
    unsafe {
        IntoCStr::push_to_non_null_vec(c, &mut bs);
        Id(CString::from_vec_unchecked(bs))
    }
}

/// Uses the given string as an ImGui id, without prepending `###`.
pub fn raw_id<C: IntoCStr>(c: C) -> Id<C> {
    Id(c)
}

/// Same as the `raw_id()` function, but may be easier to use.
///
/// This will be recommended by the compiler if you do it wrong.
impl<C: IntoCStr> From<C> for Id<C> {
    fn from(c: C) -> Id<C> {
        Id(c)
    }
}

/// Uses the given string directly as an ImGui parameter that contains a label plus an id.
///
/// The usual Dear ImGui syntax applies:
///  * `"hello"`: is both a label and an id.
///  * `"hello##world"`: the label is `hello`, the id is the whole string`.
///  * `"hello###world"`: the label is `hello`, the id is `###world`.
pub fn lbl<C: IntoCStr>(c: C) -> LblId<C> {
    LblId(c)
}

/// Uses the first string as label, the second one as id.
///
/// The id has `###` prepended.
pub fn lbl_id<C1: IntoCStr, C2: IntoCStr>(lbl: C1, id: C2) -> LblId<CString> {
    let lbl = lbl.into_cstring();
    let both = if id.is_empty() {
        lbl
    } else {
        let mut bs = lbl.into_bytes();
        bs.extend(b"###");
        // SAFETY:
        // bs can't have NULs, and the `push_to_non_null_vec` safe requirements forbids extra NULs.
        // We add one NUL at the end, so all is good.
        unsafe {
            IntoCStr::push_to_non_null_vec(id, &mut bs);
            CString::from_vec_unchecked(bs)
        }
    };
    LblId(both)
}

/// Same as the `lbl()` function, but may be easier to use.
///
/// This will be recommended by the compiler if you do it wrong.
impl<C: IntoCStr> From<C> for LblId<C> {
    fn from(c: C) -> LblId<C> {
        LblId(c)
    }
}

// Helper functions

// Take care to not consume the argument before using the pointer
fn optional_str<S: Deref<Target = CStr>>(t: &Option<S>) -> *const c_char {
    t.as_ref().map(|s| s.as_ptr()).unwrap_or(null())
}

fn optional_mut_bool(b: &mut Option<&mut bool>) -> *mut bool {
    b.as_mut().map(|x| *x as *mut bool).unwrap_or(null_mut())
}

/// Helper function that, given a string, returns the start and end pointer.
unsafe fn text_ptrs(text: &str) -> (*const c_char, *const c_char) {
    let btxt = text.as_bytes();
    let start = btxt.as_ptr() as *const c_char;
    let end = unsafe { start.add(btxt.len()) };
    (start, end)
}

unsafe fn current_font_ptr(font: FontId) -> *mut ImFont {
    unsafe {
        let fonts = RawContext::current().io().font_atlas();
        fonts.font_ptr(font)
    }
}

// this is unsafe because it replaces a C binding function that does nothing, and adding `unsafe`
// avoids a warning
unsafe fn no_op() {}

/// `Ui` represents an ImGui frame that is being built.
///
/// Usually you will get a `&mut Ui` when you are expected to build a user interface,
/// as in [`UiBuilder::do_ui`].
pub struct Ui<A>
where
    A: ?Sized,
{
    imgui: NonNull<RawContext>,
    data: *mut A, // only for callbacks, after `do_ui` has finished, do not use directly
    generation: usize,
    callbacks: RefCell<Vec<UiCallback<A>>>,
}

/// Callbacks called during `A::do_ui()` will have the first argument as null, because the app value
/// is already `self`, no need for it.
/// Callbacks called during rendering will not have access to `Ui`, because the frame is finished,
/// but they will get a proper `&mut A` as a first argument.
/// The second is a generic pointer to the real function argument, beware of fat pointers!
/// The second parameter will be consumed by the callback, take care of calling the drop exactly
/// once.
type UiCallback<A> = Box<dyn FnMut(*mut A, *mut c_void)>;

macro_rules! with_begin_end {
    ( $(#[$attr:meta])* $name:ident $begin:ident $end:ident ($($arg:ident ($($type:tt)*) ($pass:expr),)*) ) => {
        paste::paste! {
            $(#[$attr])*
            pub fn [< with_ $name >]<R>(&self, $($arg: $($type)*,)* f: impl FnOnce() -> R) -> R {
                unsafe { $begin( $( $pass, )* ) }
                struct EndGuard;
                impl Drop for EndGuard {
                    fn drop(&mut self) {
                        unsafe { $end() }
                    }
                }
                let _guard = EndGuard;
                f()
            }
        }
    };
}

macro_rules! with_begin_end_opt {
    ( $(#[$attr:meta])* $name:ident $begin:ident $end:ident ($($arg:ident ($($type:tt)*) ($pass:expr),)*) ) => {
        paste::paste! {
            $(#[$attr])*
            pub fn [< with_ $name >]<R>(&self, $($arg: $($type)*,)* f: impl FnOnce() -> R) -> Option<R> {
                self.[< with_always_ $name >]($($arg,)* move |opened| { opened.then(f) })
            }
            pub fn [< with_always_ $name >]<R>(&self, $($arg: $($type)*,)* f: impl FnOnce(bool) -> R) -> R {
                if !unsafe { $begin( $( $pass, )* ) } {
                    return f(false);
                }
                struct EndGuard;
                impl Drop for EndGuard {
                    fn drop(&mut self) {
                        unsafe { $end() }
                    }
                }
                let _guard = EndGuard;
                f(true)
            }
        }
    };
}

macro_rules! decl_builder {
    ( $(#[$attr:meta])* $sname:ident -> $tres:ty, $func:ident ($($life:lifetime),*) ( $( $gen_n:ident : $gen_d:tt ),* )
        (
            $(
                $arg:ident ($($ty:tt)*) ($pass:expr),
            )*
        )
        { $($extra:tt)* }
        { $($constructor:item)* }
    ) => {
        #[must_use]
        pub struct $sname<'s, $($life,)* $($gen_n : $gen_d, )* > {
            _pd: PhantomData<*const &'s ()>, // !Send + !Sync
            $(
                $arg: $($ty)*,
            )*
        }
        impl <'s, $($life,)* $($gen_n : $gen_d, )* > $sname<'s, $($life,)* $($gen_n, )* > {
            pub fn build(self) -> $tres {
                let $sname { _pd, $($arg, )* } = self;
                unsafe {
                    $func($($pass,)*)
                }
            }
            $($extra)*
        }

        impl<A> Ui<A> {
            decl_builder!{ @CONSTRUCTOR $(#[$attr])* ( $($constructor)* ) }
        }
    };
    ( @CONSTRUCTOR $(#[$attr:meta])* ( $constructor_0:item $($constructor:item)* ) ) => {
        $(#[$attr])* $constructor_0
        decl_builder!{ @CONSTRUCTOR $(#[$attr])* ( $($constructor)* ) }
    };
    ( @CONSTRUCTOR $(#[$attr:meta])* () ) => {
    };
}

macro_rules! decl_builder_setter_ex {
    ($name:ident: $ty:ty = $expr:expr) => {
        pub fn $name(mut self, $name: $ty) -> Self {
            self.$name = $expr;
            self
        }
    };
}

macro_rules! decl_builder_setter {
    ($name:ident: $ty:ty) => {
        decl_builder_setter_ex! { $name: $ty = $name.into() }
    };
}

macro_rules! decl_builder_setter_vector2 {
    ($name:ident: Vector2) => {
        decl_builder_setter_ex! { $name: Vector2 = v2_to_im($name) }
    };
}

macro_rules! decl_builder_with_maybe_opt {
    ( $always_run_end:literal
      $(#[$attr:meta])*
      $sname:ident, $func_beg:ident, $func_end:ident ($($life:lifetime),*) ( $( $gen_n:ident : $gen_d:tt ),* )
        (
            $(
                $arg:ident ($($ty:tt)*) ($pass:expr),
            )*
        )
        { $($extra:tt)* }
        { $($constructor:tt)* }
    ) => {
        #[must_use]
        pub struct $sname< $($life,)* $($gen_n : $gen_d, )* P: Pushable = () > {
            $(
                $arg: $($ty)*,
            )*
            push: P,
        }
        impl <$($life,)* $($gen_n : $gen_d, )* P: Pushable > $sname<$($life,)* $($gen_n,)* P > {
            /// Registers this `Pushable` to be called only for the `begin` part of this UI
            /// element.
            ///
            /// This is useful for example to modify the style of a window without changing the
            /// style of its content.
            pub fn push_for_begin<P2: Pushable>(self, push: P2) -> $sname< $($life,)* $($gen_n,)* (P, P2) > {
                $sname {
                    $(
                        $arg: self.$arg,
                    )*
                    push: (self.push, push),
                }
            }
            /// Calls `f` inside this UI element, but only if it is visible.
            pub fn with<R>(self, f: impl FnOnce() -> R) -> Option<R> {
                self.with_always(move |opened| { opened.then(f) })
            }
            /// Calls `f` inside this UI element, passing `true` if the elements visible, `false`
            /// if it is not.
            pub fn with_always<R>(self, f: impl FnOnce(bool) -> R) -> R {
                // Some uses will require `mut`, some will not`
                #[allow(unused_mut)]
                let $sname { $(mut $arg, )* push } = self;
                let bres = unsafe {
                    let _guard = push_guard(&push);
                    $func_beg($($pass,)*)
                };
                struct EndGuard(bool);
                impl Drop for EndGuard {
                    fn drop(&mut self) {
                        if self.0 {
                            unsafe { $func_end(); }
                        }
                    }
                }
                let _guard_2 = EndGuard($always_run_end || bres);
                f(bres)
            }
            $($extra)*
        }

        impl<A> Ui<A> {
            $(#[$attr])*
            $($constructor)*
        }
    };
}

macro_rules! decl_builder_with {
    ( $(#[$attr:meta])* $sname:ident, $($args:tt)* ) => {
        decl_builder_with_maybe_opt!{ true $(#[$attr])* $sname, $($args)* }
    };
}

macro_rules! decl_builder_with_opt {
    ( $(#[$attr:meta])* $sname:ident, $($args:tt)* ) => {
        decl_builder_with_maybe_opt!{ false $(#[$attr])* $sname, $($args)* }
    };
}

decl_builder_with! {Child, ImGui_BeginChild, ImGui_EndChild () (S: IntoCStr)
    (
        name (S::Temp) (name.as_ptr()),
        size (ImVec2) (&size),
        child_flags (ChildFlags) (child_flags.bits()),
        window_flags (WindowFlags) (window_flags.bits()),
    )
    {
        decl_builder_setter_vector2!{size: Vector2}
        decl_builder_setter!{child_flags: ChildFlags}
        decl_builder_setter!{window_flags: WindowFlags}
    }
    {
        pub fn child_config<S: IntoCStr>(&self, name: LblId<S>) -> Child<S> {
            Child {
                name: name.into(),
                size: im_vec2(0.0, 0.0),
                child_flags: ChildFlags::None,
                window_flags: WindowFlags::None,
                push: (),
            }
        }
    }
}

decl_builder_with! {
    /// Dear ImGui (`Begin`): push window to the stack and start appending to it. End() = pop window from the stack.
    Window, ImGui_Begin, ImGui_End ('v) (S: IntoCStr)
    (
        name (S::Temp) (name.as_ptr()),
        open (Option<&'v mut bool>) (optional_mut_bool(&mut open)),
        flags (WindowFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{open: &'v mut bool}
        decl_builder_setter!{flags: WindowFlags}
    }
    {
        pub fn window_config<S: IntoCStr>(&self, name: LblId<S>) -> Window<'_, S> {
            Window {
                name: name.into(),
                open: None,
                flags: WindowFlags::None,
                push: (),
            }
        }
    }
}

decl_builder! { MenuItem -> bool, ImGui_MenuItem () (S1: IntoCStr, S2: IntoCStr)
    (
        label (S1::Temp) (label.as_ptr()),
        shortcut (Option<S2::Temp>) (optional_str(&shortcut)),
        selected (bool) (selected),
        enabled (bool) (enabled),
    )
    {
        pub fn shortcut_opt<S3: IntoCStr>(self, shortcut: Option<S3>) -> MenuItem<'s, S1, S3> {
            MenuItem {
                _pd: PhantomData,
                label: self.label,
                shortcut: shortcut.map(|s| s.into()),
                selected: self.selected,
                enabled: self.enabled,
            }
        }
        pub fn shortcut<S3: IntoCStr>(self, shortcut: S3) -> MenuItem<'s, S1, S3> {
            self.shortcut_opt(Some(shortcut))
        }
        decl_builder_setter!{selected: bool}
        decl_builder_setter!{enabled: bool}
    }
    {
        pub fn menu_item_config<S: IntoCStr>(&self, label: LblId<S>) -> MenuItem<'_, S, &str> {
            MenuItem {
                _pd: PhantomData,
                label: label.into(),
                shortcut: None,
                selected: false,
                enabled: true,
            }
        }
    }
}

decl_builder! {
    Button -> bool, ImGui_Button () (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        size (ImVec2) (&size),
    )
    {
        decl_builder_setter_vector2!{size: Vector2}
    }
    {
        pub fn button_config<S: IntoCStr>(&self, label: LblId<S>) -> Button<'_, S> {
            Button {
                _pd: PhantomData,
                label: label.into(),
                size: im_vec2(0.0, 0.0),
            }
        }
        pub fn button<S: IntoCStr>(&self, label: LblId<S>) -> bool {
            self.button_config(label).build()
        }
    }
}

decl_builder! {
    /// Dear ImGui (`SmallButton`): button with (FramePadding.y == 0) to easily embed within text
    SmallButton -> bool, ImGui_SmallButton () (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
    )
    {}
    {
        pub fn small_button_config<S: IntoCStr>(&self, label: LblId<S>) -> SmallButton<'_, S> {
            SmallButton {
                _pd: PhantomData,
                label: label.into(),
            }
        }
        pub fn small_button<S: IntoCStr>(&self, label: LblId<S>) -> bool {
            self.small_button_config(label).build()
        }
    }
}

decl_builder! {
    /// Dear ImGui (`InvisibleButton`): flexible button behavior without the visuals, frequently useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.)
    InvisibleButton -> bool, ImGui_InvisibleButton () (S: IntoCStr)
    (
        id (S::Temp) (id.as_ptr()),
        size (ImVec2) (&size),
        flags (ButtonFlags) (flags.bits()),
    )
    {
        decl_builder_setter_vector2!{size: Vector2}
        decl_builder_setter!{flags: ButtonFlags}
    }
    {
        pub fn invisible_button_config<S: IntoCStr>(&self, id: S) -> InvisibleButton<'_, S> {
            InvisibleButton {
                _pd: PhantomData,
                id: id.into(),
                size: im_vec2(0.0, 0.0),
                flags: ButtonFlags::MouseButtonLeft,
            }
        }
    }
}

decl_builder! {
    /// Dear ImGui (`ArrowButton`): square button with an arrow shape
    ArrowButton -> bool, ImGui_ArrowButton () (S: IntoCStr)
    (
        id (S::Temp) (id.as_ptr()),
        dir (Dir) (dir.bits()),
    )
    {}
    {
        pub fn arrow_button_config<S: IntoCStr>(&self, id: S, dir: Dir) -> ArrowButton<'_, S> {
            ArrowButton {
                _pd: PhantomData,
                id: id.into(),
                dir,
            }
        }
        pub fn arrow_button<S: IntoCStr>(&self, id: S, dir: Dir) -> bool {
            self.arrow_button_config(id, dir).build()
        }
    }
}

decl_builder! {
    Checkbox -> bool, ImGui_Checkbox ('v) (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        value (&'v mut bool) (value),
    )
    {}
    {
        pub fn checkbox_config<'v, S: IntoCStr>(&self, label: LblId<S>, value: &'v mut bool) -> Checkbox<'_, 'v, S> {
            Checkbox {
                _pd: PhantomData,
                label: label.into(),
                value,
            }
        }
        pub fn checkbox<S: IntoCStr>(&self, label: LblId<S>, value: &mut bool) -> bool {
            self.checkbox_config(label, value).build()
        }
    }
}

decl_builder! { RadioButton -> bool, ImGui_RadioButton () (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        active (bool) (active),
    )
    {}
    {
        pub fn radio_button_config<S: IntoCStr>(&self, label: LblId<S>, active: bool) -> RadioButton<'_, S> {
            RadioButton {
                _pd: PhantomData,
                label: label.into(),
                active,
            }
        }
    }
}

decl_builder! { ProgressBar -> (), ImGui_ProgressBar () (S: IntoCStr)
    (
        fraction (f32) (fraction),
        size (ImVec2) (&size),
        overlay (Option<S::Temp>) (optional_str(&overlay)),
    )
    {
        decl_builder_setter_vector2!{size: Vector2}
        pub fn overlay<S2: IntoCStr>(self, overlay: S2) -> ProgressBar<'s, S2> {
            ProgressBar {
                _pd: PhantomData,
                fraction: self.fraction,
                size: self.size,
                overlay: Some(overlay.into()),
            }
        }
    }
    {
        pub fn progress_bar_config<'a>(&self, fraction: f32) -> ProgressBar<'_, &'a str> {
            ProgressBar {
                _pd: PhantomData,
                fraction,
                size: im_vec2(-f32::MIN_POSITIVE, 0.0),
                overlay: None,
            }
        }
    }
}

decl_builder! {
    Image -> (), ImGui_Image ('t) ()
    (
        texture_ref (TextureRef<'t>) (texture_ref.tex_ref()),
        size (ImVec2) (&size),
        uv0 (ImVec2) (&uv0),
        uv1 (ImVec2) (&uv1),
    )
    {
        decl_builder_setter_vector2!{uv0: Vector2}
        decl_builder_setter_vector2!{uv1: Vector2}
    }
    {
        pub fn image_config<'t>(&self, texture_ref: TextureRef<'t>, size: Vector2) -> Image<'_, 't> {
            Image {
                _pd: PhantomData,
                texture_ref,
                size: v2_to_im(size),
                uv0: im_vec2(0.0, 0.0),
                uv1: im_vec2(1.0, 1.0),
            }
        }
        pub fn image_with_custom_rect_config(&self, ridx: CustomRectIndex, scale: f32) -> Image<'_, '_> {
            let rr = self.get_custom_rect(ridx).unwrap();
            self.image_config(rr.tex_ref, vec2(scale * rr.rect.w as f32, scale * rr.rect.h as f32))
                .uv0(im_to_v2(rr.rect.uv0))
                .uv1(im_to_v2(rr.rect.uv1))
        }
    }
}

decl_builder! {
    /// Dear ImGui (`ImageWithBg`): display image with background
    ImageWithBg -> (), ImGui_ImageWithBg ('t) ()
    (
        texture_ref (TextureRef<'t>) (texture_ref.tex_ref()),
        size (ImVec2) (&size),
        uv0 (ImVec2) (&uv0),
        uv1 (ImVec2) (&uv1),
        bg_col (ImVec4) (&bg_col),
        tint_col (ImVec4) (&tint_col),
    )
    {
        decl_builder_setter_vector2!{uv0: Vector2}
        decl_builder_setter_vector2!{uv1: Vector2}
        decl_builder_setter!{bg_col: Color}
        decl_builder_setter!{tint_col: Color}
    }
    {
        pub fn image_with_bg_config<'t>(&self, texture_ref: TextureRef<'t>, size: Vector2) -> ImageWithBg<'_, 't> {
            ImageWithBg {
                _pd: PhantomData,
                texture_ref,
                size: v2_to_im(size),
                uv0: im_vec2(0.0, 0.0),
                uv1: im_vec2(1.0, 1.0),
                bg_col: Color::TRANSPARENT.into(),
                tint_col: Color::WHITE.into(),
            }
        }
        pub fn image_with_bg_with_custom_rect_config(&self, ridx: CustomRectIndex, scale: f32) -> ImageWithBg<'_, '_> {
            let rr = self.get_custom_rect(ridx).unwrap();
            self.image_with_bg_config(self.get_atlas_texture_ref(), vec2(scale * rr.rect.w as f32, scale * rr.rect.h as f32))
                .uv0(im_to_v2(rr.rect.uv0))
                .uv1(im_to_v2(rr.rect.uv1))
        }

    }
}

decl_builder! {
    ImageButton -> bool, ImGui_ImageButton ('t) (S: IntoCStr)
    (
        str_id (S::Temp) (str_id.as_ptr()),
        texture_ref (TextureRef<'t>) (texture_ref.tex_ref()),
        size (ImVec2) (&size),
        uv0 (ImVec2) (&uv0),
        uv1 (ImVec2) (&uv1),
        bg_col (ImVec4) (&bg_col),
        tint_col (ImVec4) (&tint_col),
    )
    {
        decl_builder_setter_vector2!{uv0: Vector2}
        decl_builder_setter_vector2!{uv1: Vector2}
        decl_builder_setter!{bg_col: Color}
        decl_builder_setter!{tint_col: Color}
    }
    {
        pub fn image_button_config<'t, S: IntoCStr>(&self, str_id: Id<S>, texture_ref: TextureRef<'t>, size: Vector2) -> ImageButton<'_, 't, S> {
            ImageButton {
                _pd: PhantomData,
                str_id: str_id.into(),
                texture_ref,
                size: v2_to_im(size),
                uv0: im_vec2(0.0, 0.0),
                uv1: im_vec2(1.0, 1.0),
                bg_col: Color::TRANSPARENT.into(),
                tint_col: Color::WHITE.into(),
            }
        }
        pub fn image_button_with_custom_rect_config<S: IntoCStr>(&self, str_id: Id<S>, ridx: CustomRectIndex, scale: f32) -> ImageButton<'_, '_, S> {
            let rr = self.get_custom_rect(ridx).unwrap();
            self.image_button_config(str_id, rr.tex_ref, vec2(scale * rr.rect.w as f32, scale * rr.rect.h as f32))
                .uv0(im_to_v2(rr.rect.uv0))
                .uv1(im_to_v2(rr.rect.uv1))
        }
    }
}

decl_builder! {
    Selectable -> bool, ImGui_Selectable () (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        selected (bool) (selected),
        flags (SelectableFlags) (flags.bits()),
        size (ImVec2) (&size),
    )
    {
        decl_builder_setter!{selected: bool}
        decl_builder_setter!{flags: SelectableFlags}
        decl_builder_setter_vector2!{size: Vector2}
    }
    {
        pub fn selectable_config<S: IntoCStr>(&self, label: LblId<S>) -> Selectable<'_, S> {
            Selectable {
                _pd: PhantomData,
                label: label.into(),
                selected: false,
                flags: SelectableFlags::None,
                size: im_vec2(0.0, 0.0),
            }
        }
        pub fn selectable<S: IntoCStr>(&self, label: LblId<S>) -> bool {
            self.selectable_config(label).build()
        }
    }
}

macro_rules! decl_builder_drag {
    ( $(#[$attr:meta])* $name:ident $func:ident $cfunc:ident $life:lifetime ($argty:ty) ($ty:ty) ($expr:expr)) => {
        decl_builder! {
            $(#[$attr])*
            $name -> bool, $cfunc ($life) (S: IntoCStr)
            (
                label (S::Temp) (label.as_ptr()),
                value ($ty) ($expr(value)),
                speed (f32) (speed),
                min ($argty) (min),
                max ($argty) (max),
                format (Cow<'static, CStr>) (format.as_ptr()),
                flags (SliderFlags) (flags.bits()),
            )
            {
                decl_builder_setter!{speed: f32}
                pub fn range(mut self, min: $argty, max: $argty) -> Self {
                    self.min = min;
                    self.max = max;
                    self
                }
                decl_builder_setter!{flags: SliderFlags}
            }
            {
                pub fn $func<$life, S: IntoCStr>(&self, label: LblId<S>, value: $ty) -> $name<'_, $life, S> {
                    $name {
                        _pd: PhantomData,
                        label: label.into(),
                        value,
                        speed: 1.0,
                        min: <$argty>::default(),
                        max: <$argty>::default(),
                        format: Cow::Borrowed(c"%.3f"),
                        flags: SliderFlags::None,
                    }
                }
            }
        }
    };
}

macro_rules! impl_float_format {
    ($name:ident) => {
        impl_float_format! {$name c"%g" c"%.0f" c"%.3f" "%.{}f"}
    };
    ($name:ident $g:literal $f0:literal $f3:literal $f_n:literal) => {
        impl<S: IntoCStr> $name<'_, '_, S> {
            pub fn display_format(mut self, format: FloatFormat) -> Self {
                self.format = match format {
                    FloatFormat::G => Cow::Borrowed($g),
                    FloatFormat::F(0) => Cow::Borrowed($f0),
                    FloatFormat::F(3) => Cow::Borrowed($f3),
                    FloatFormat::F(n) => Cow::Owned(CString::new(format!($f_n, n)).unwrap()),
                };
                self
            }
        }
    };
}

decl_builder_drag! {
DragFloat drag_float_config ImGui_DragFloat 'v (f32) (&'v mut f32) (std::convert::identity)}
decl_builder_drag! {
DragFloat2 drag_float_2_config ImGui_DragFloat2 'v (f32) (&'v mut [f32; 2]) (<[f32]>::as_mut_ptr)}
decl_builder_drag! {
DragFloat3 drag_float_3_config ImGui_DragFloat3 'v (f32) (&'v mut [f32; 3]) (<[f32]>::as_mut_ptr)}
decl_builder_drag! {
DragFloat4 drag_float_4_config ImGui_DragFloat4 'v (f32) (&'v mut [f32; 4]) (<[f32]>::as_mut_ptr)}

impl_float_format! { DragFloat }
impl_float_format! { DragFloat2 }
impl_float_format! { DragFloat3 }
impl_float_format! { DragFloat4 }

decl_builder_drag! { DragInt drag_int_config ImGui_DragInt 'v (i32) (&'v mut i32) (std::convert::identity)}
decl_builder_drag! { DragInt2 drag_int_2_config ImGui_DragInt2 'v (i32) (&'v mut [i32; 2]) (<[i32]>::as_mut_ptr)}
decl_builder_drag! { DragInt3 drag_int_3_config ImGui_DragInt3 'v (i32) (&'v mut [i32; 3]) (<[i32]>::as_mut_ptr)}
decl_builder_drag! { DragInt4 drag_int_4_config ImGui_DragInt4 'v (i32) (&'v mut [i32; 4]) (<[i32]>::as_mut_ptr)}

macro_rules! decl_builder_slider {
    ( $(#[$attr:meta])* $name:ident $func:ident $cfunc:ident $life:lifetime ($argty:ty) ($ty:ty) ($expr:expr)) => {
        decl_builder! {
            $(#[$attr])*
            $name -> bool, $cfunc ($life) (S: IntoCStr)
            (
                label (S::Temp) (label.as_ptr()),
                value ($ty) ($expr(value)),
                min ($argty) (min),
                max ($argty) (max),
                format (Cow<'static, CStr>) (format.as_ptr()),
                flags (SliderFlags) (flags.bits()),
            )
            {
                pub fn range(mut self, min: $argty, max: $argty) -> Self {
                    self.min = min;
                    self.max = max;
                    self
                }
                decl_builder_setter!{flags: SliderFlags}
            }
            {
                pub fn $func<$life, S: IntoCStr>(&self, label: LblId<S>, value: $ty) -> $name<'_, $life, S> {
                    $name {
                        _pd: PhantomData,
                        label: label.into(),
                        value,
                        min: <$argty>::default(),
                        max: <$argty>::default(),
                        format: Cow::Borrowed(c"%.3f"),
                        flags: SliderFlags::None,
                    }
                }
            }
        }
    };
}

decl_builder_slider! {
SliderFloat slider_float_config ImGui_SliderFloat 'v (f32) (&'v mut f32) (std::convert::identity)}
decl_builder_slider! {
SliderFloat2 slider_float_2_config ImGui_SliderFloat2 'v (f32) (&'v mut [f32; 2]) (<[f32]>::as_mut_ptr)}
decl_builder_slider! {
SliderFloat3 slider_float_3_config ImGui_SliderFloat3 'v (f32) (&'v mut [f32; 3]) (<[f32]>::as_mut_ptr)}
decl_builder_slider! {
SliderFloat4 slider_float_4_config ImGui_SliderFloat4 'v (f32) (&'v mut [f32; 4]) (<[f32]>::as_mut_ptr)}

impl_float_format! { SliderFloat }
impl_float_format! { SliderFloat2 }
impl_float_format! { SliderFloat3 }
impl_float_format! { SliderFloat4 }

decl_builder_slider! {
SliderInt slider_int_config ImGui_SliderInt 'v (i32) (&'v mut i32) (std::convert::identity)}
decl_builder_slider! {
SliderInt2 slider_int_2_config ImGui_SliderInt2 'v (i32) (&'v mut [i32; 2]) (<[i32]>::as_mut_ptr)}
decl_builder_slider! {
SliderInt3 slider_int_3_config ImGui_SliderInt3 'v (i32) (&'v mut [i32; 3]) (<[i32]>::as_mut_ptr)}
decl_builder_slider! {
SliderInt4 slider_int_4_config ImGui_SliderInt4 'v (i32) (&'v mut [i32; 4]) (<[i32]>::as_mut_ptr)}

decl_builder! {
    /// Dear ImGui (`SliderAngle`): slider angle
    SliderAngle -> bool, ImGui_SliderAngle ('v) (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        v_rad (&'v mut f32) (v_rad),
        v_degrees_min (f32) (v_degrees_min),
        v_degrees_max (f32) (v_degrees_max),
        format (Cow<'static, CStr>) (format.as_ptr()),
        flags (SliderFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{v_degrees_max: f32}
        decl_builder_setter!{v_degrees_min: f32}
        decl_builder_setter!{flags: SliderFlags}
    }
    {
        pub fn slider_angle_config<'v, S: IntoCStr>(&self, label: LblId<S>, v_rad: &'v mut f32) -> SliderAngle<'_, 'v, S> {
            SliderAngle {
                _pd: PhantomData,
                label: label.into(),
                v_rad,
                v_degrees_min: -360.0,
                v_degrees_max: 360.0,
                format: Cow::Borrowed(c"%.0f deg"),
                flags: SliderFlags::None,
            }
        }
    }
}

impl_float_format! { SliderAngle c"%g deg" c"%.0f deg" c"%.3f deg" "%.{}f deg"}

decl_builder! {
    ColorEdit3 -> bool, ImGui_ColorEdit3 ('v) (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        color (&'v mut [f32; 3]) (color.as_mut_ptr()),
        flags (ColorEditFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{flags: ColorEditFlags}
    }
    {
        pub fn color_edit_3_config<'v, S: IntoCStr>(&self, label: LblId<S>, color: &'v mut [f32; 3]) -> ColorEdit3<'_, 'v, S> {
            ColorEdit3 {
                _pd: PhantomData,
                label: label.into(),
                color,
                flags: ColorEditFlags::None,
            }
        }
    }
}

decl_builder! {
    ColorEdit4 -> bool, ImGui_ColorEdit4 ('v) (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        color (&'v mut [f32; 4]) (color.as_mut_ptr()),
        flags (ColorEditFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{flags: ColorEditFlags}
    }
    {
        pub fn color_edit_4_config<'v, S: IntoCStr>(&self, label: LblId<S>, color: &'v mut Color) -> ColorEdit4<'_, 'v, S> {
            ColorEdit4 {
                _pd: PhantomData,
                label: label.into(),
                color: color.as_mut(),
                flags: ColorEditFlags::None,
            }
        }
    }
}

decl_builder! {
    ColorPicker3 -> bool, ImGui_ColorPicker3 ('v) (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        color (&'v mut [f32; 3]) (color.as_mut_ptr()),
        flags (ColorEditFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{flags: ColorEditFlags}
    }
    {
        pub fn color_picker_3_config<'v, S: IntoCStr>(&self, label: LblId<S>, color: &'v mut [f32; 3]) -> ColorPicker3<'_, 'v, S> {
            ColorPicker3 {
                _pd: PhantomData,
                label: label.into(),
                color,
                flags: ColorEditFlags::None,
            }
        }
    }
}

decl_builder! {
    ColorPicker4 -> bool, ImGui_ColorPicker4 ('v) (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        color (&'v mut [f32; 4]) (color.as_mut_ptr()),
        flags (ColorEditFlags) (flags.bits()),
        ref_col (Option<Color>) (ref_col.as_ref().map(|x| x.as_ref().as_ptr()).unwrap_or(null())),
    )
    {
        decl_builder_setter!{flags: ColorEditFlags}
        pub fn ref_color(mut self, ref_color: Color) -> Self {
            self.ref_col = Some(ref_color);
            self
        }
    }
    {
        pub fn color_picker_4_config<'v, S: IntoCStr>(&self, label: LblId<S>, color: &'v mut Color) -> ColorPicker4<'_, 'v, S> {
            ColorPicker4 {
                _pd: PhantomData,
                label: label.into(),
                color: color.as_mut(),
                flags: ColorEditFlags::None,
                ref_col: None,
            }
        }
    }
}

unsafe extern "C" fn input_text_callback(data: *mut ImGuiInputTextCallbackData) -> i32 {
    unsafe {
        let data = &mut *data;
        if data.EventFlag == InputTextFlags::CallbackResize.bits() {
            let this = &mut *(data.UserData as *mut String);
            let extra = (data.BufSize as usize).saturating_sub(this.len());
            this.reserve(extra);
            data.Buf = this.as_mut_ptr() as *mut c_char;
        }
        0
    }
}

#[inline]
fn text_pre_edit(text: &mut String) {
    // Ensure a NUL at the end
    text.push('\0');
}

#[inline]
unsafe fn text_post_edit(text: &mut String) {
    unsafe {
        let buf = text.as_mut_vec();
        // Look for the ending NUL that must be there, instead of memchr or iter::position, leverage the standard CStr
        let len = CStr::from_ptr(buf.as_ptr() as *const c_char)
            .to_bytes()
            .len();
        buf.set_len(len);
    }
}

unsafe fn input_text_wrapper(
    label: *const c_char,
    text: &mut String,
    flags: InputTextFlags,
) -> bool {
    unsafe {
        let flags = flags | InputTextFlags::CallbackResize;

        text_pre_edit(text);
        let r = ImGui_InputText(
            label,
            text.as_mut_ptr() as *mut c_char,
            text.capacity(),
            flags.bits(),
            Some(input_text_callback),
            text as *mut String as *mut c_void,
        );
        text_post_edit(text);
        r
    }
}

decl_builder! {
    InputText -> bool, input_text_wrapper ('v) (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        text (&'v mut String) (text),
        flags (InputTextFlags) (flags),
    )
    {
        decl_builder_setter!{flags: InputTextFlags}
    }
    {
        pub fn input_text_config<'v, S: IntoCStr>(&self, label: LblId<S>, text: &'v mut String) -> InputText<'_, 'v, S> {
            InputText {
                _pd: PhantomData,
                label: label.into(),
                text,
                flags: InputTextFlags::None,
            }
        }
    }
}

unsafe fn input_os_string_wrapper(
    label: *const c_char,
    os_string: &mut OsString,
    flags: InputTextFlags,
) -> bool {
    unsafe {
        let s = std::mem::take(os_string).into_string();
        let mut s = match s {
            Ok(s) => s,
            Err(os) => os.to_string_lossy().into_owned(),
        };
        let res = input_text_wrapper(label, &mut s, flags);
        *os_string = OsString::from(s);
        res
    }
}

decl_builder! {
    InputOsString -> bool, input_os_string_wrapper ('v) (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        text (&'v mut OsString) (text),
        flags (InputTextFlags) (flags),
    )
    {
        decl_builder_setter!{flags: InputTextFlags}
    }
    {
        pub fn input_os_string_config<'v, S: IntoCStr>(&self, label: LblId<S>, text: &'v mut OsString) -> InputOsString<'_, 'v, S> {
            InputOsString {
                _pd: PhantomData,
                label: label.into(),
                text,
                flags: InputTextFlags::None,
            }
        }
    }
}

unsafe fn input_text_multiline_wrapper(
    label: *const c_char,
    text: &mut String,
    size: &ImVec2,
    flags: InputTextFlags,
) -> bool {
    unsafe {
        let flags = flags | InputTextFlags::CallbackResize;
        text_pre_edit(text);
        let r = ImGui_InputTextMultiline(
            label,
            text.as_mut_ptr() as *mut c_char,
            text.capacity(),
            size,
            flags.bits(),
            Some(input_text_callback),
            text as *mut String as *mut c_void,
        );
        text_post_edit(text);
        r
    }
}

decl_builder! {
    InputTextMultiline -> bool, input_text_multiline_wrapper ('v) (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        text (&'v mut String) (text),
        size (ImVec2) (&size),
        flags (InputTextFlags) (flags),
    )
    {
        decl_builder_setter!{flags: InputTextFlags}
        decl_builder_setter_vector2!{size: Vector2}
    }
    {
        pub fn input_text_multiline_config<'v, S: IntoCStr>(&self, label: LblId<S>, text: &'v mut String) -> InputTextMultiline<'_, 'v, S> {
            InputTextMultiline {
                _pd: PhantomData,
                label:label.into(),
                text,
                flags: InputTextFlags::None,
                size: im_vec2(0.0, 0.0),
            }
        }
    }
}

unsafe fn input_text_hint_wrapper(
    label: *const c_char,
    hint: *const c_char,
    text: &mut String,
    flags: InputTextFlags,
) -> bool {
    unsafe {
        let flags = flags | InputTextFlags::CallbackResize;
        text_pre_edit(text);
        let r = ImGui_InputTextWithHint(
            label,
            hint,
            text.as_mut_ptr() as *mut c_char,
            text.capacity(),
            flags.bits(),
            Some(input_text_callback),
            text as *mut String as *mut c_void,
        );
        text_post_edit(text);
        r
    }
}

decl_builder! {
    InputTextHint -> bool, input_text_hint_wrapper ('v) (S1: IntoCStr, S2: IntoCStr)
    (
        label (S1::Temp) (label.as_ptr()),
        hint (S2::Temp) (hint.as_ptr()),
        text (&'v mut String) (text),
        flags (InputTextFlags) (flags),
    )
    {
        decl_builder_setter!{flags: InputTextFlags}
    }
    {
        pub fn input_text_hint_config<'v, S1: IntoCStr, S2: IntoCStr>(&self, label: LblId<S1>, hint: S2, text: &'v mut String) -> InputTextHint<'_, 'v, S1, S2> {
            InputTextHint {
                _pd: PhantomData,
                label:label.into(),
                hint: hint.into(),
                text,
                flags: InputTextFlags::None,
            }
        }
    }
}

/// How to convert a float value to a string.
///
/// It maps to the inner ImGui `sprintf` format parameter.
pub enum FloatFormat {
    /// `F(x)` is like `sprintf("%xf")`
    F(u32),
    /// `G` is like `sprintf("%g")`
    G,
}

decl_builder! {
    /// Dear ImGui (`InputFloat`): input float
    InputFloat -> bool, ImGui_InputFloat ('v) (S: IntoCStr)
    (
        label (S::Temp)  (label.as_ptr()),
        value (&'v mut f32) (value),
        step (f32) (step),
        step_fast (f32) (step_fast),
        format (Cow<'static, CStr>) (format.as_ptr()),
        flags (InputTextFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{flags: InputTextFlags}
        decl_builder_setter!{step: f32}
        decl_builder_setter!{step_fast: f32}
    }
    {
        pub fn input_float_config<'v, S: IntoCStr>(&self, label: LblId<S>, value: &'v mut f32) -> InputFloat<'_, 'v, S> {
            InputFloat {
                _pd: PhantomData,
                label:label.into(),
                value,
                step: 0.0,
                step_fast: 0.0,
                format: Cow::Borrowed(c"%.3f"),
                flags: InputTextFlags::None,
            }
        }
    }
}

decl_builder! {
    InputInt -> bool, ImGui_InputInt ('v) (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        value (&'v mut i32) (value),
        step (i32) (step),
        step_fast (i32) (step_fast),
        flags (InputTextFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{flags: InputTextFlags}
        decl_builder_setter!{step: i32}
        decl_builder_setter!{step_fast: i32}
    }
    {
        /// Dear ImGui (`InputInt`): input int
        pub fn input_int_config<'v, S: IntoCStr>(&self, label: LblId<S>, value: &'v mut i32) -> InputInt<'_, 'v, S> {
            InputInt {
                _pd: PhantomData,
                label:label.into(),
                value,
                step: 1,
                step_fast: 100,
                flags: InputTextFlags::None,
            }
        }
    }
}

macro_rules! decl_builder_input_f {
    ( $(#[$attr:meta])* $name:ident $func:ident $cfunc:ident $len:literal) => {
        decl_builder! {
            $(#[$attr])*
            $name -> bool, $cfunc ('v) (S: IntoCStr)
            (
                label (S::Temp) (label.as_ptr()),
                value (&'v mut [f32; $len]) (value.as_mut_ptr()),
                format (Cow<'static, CStr>) (format.as_ptr()),
                flags (InputTextFlags) (flags.bits()),
            )
            {
                decl_builder_setter!{flags: InputTextFlags}
            }
            {
                pub fn $func<'v, S: IntoCStr>(&self, label: LblId<S>, value: &'v mut [f32; $len]) -> $name<'_, 'v, S> {
                    $name {
                        _pd: PhantomData,
                        label: label.into(),
                        value,
                        format: Cow::Borrowed(c"%.3f"),
                        flags: InputTextFlags::None,
                    }
                }
            }
        }
    };
}

decl_builder_input_f! {
/// Dear ImGui (`InputFloat2`): input float 2
InputFloat2 input_float_2_config ImGui_InputFloat2 2}
decl_builder_input_f! {
/// Dear ImGui (`InputFloat3`): input float 3
InputFloat3 input_float_3_config ImGui_InputFloat3 3}
decl_builder_input_f! {
/// Dear ImGui (`InputFloat4`): input float 4
InputFloat4 input_float_4_config ImGui_InputFloat4 4}

impl_float_format! { InputFloat }
impl_float_format! { InputFloat2 }
impl_float_format! { InputFloat3 }
impl_float_format! { InputFloat4 }

macro_rules! decl_builder_input_i {
    ( $(#[$attr:meta])* $name:ident $func:ident $cfunc:ident $len:literal) => {
        decl_builder! {
            $(#[$attr])*
            $name -> bool, $cfunc ('v) (S: IntoCStr)
            (
                label (S::Temp) (label.as_ptr()),
                value (&'v mut [i32; $len]) (value.as_mut_ptr()),
                flags (InputTextFlags) (flags.bits()),
            )
            {
                decl_builder_setter!{flags: InputTextFlags}
            }
            {
                pub fn $func<'v, S: IntoCStr>(&self, label: LblId<S>, value: &'v mut [i32; $len]) -> $name<'_, 'v, S> {
                    $name {
                        _pd: PhantomData,
                        label: label.into(),
                        value,
                        flags: InputTextFlags::None,
                    }
                }
            }
        }
    };
}

decl_builder_input_i! {
/// Dear ImGui (`InputInt2`): input int 2
InputInt2 input_int_2_config ImGui_InputInt2 2}
decl_builder_input_i! {
/// Dear ImGui (`InputInt3`): input int 3
InputInt3 input_int_3_config ImGui_InputInt3 3}
decl_builder_input_i! {
/// Dear ImGui (`InputInt4`): input int 4
InputInt4 input_int_4_config ImGui_InputInt4 4}

decl_builder_with_opt! {
    Menu, ImGui_BeginMenu, ImGui_EndMenu () (S: IntoCStr)
    (
        name (S::Temp) (name.as_ptr()),
        enabled (bool) (enabled),
    )
    {
        decl_builder_setter!{enabled: bool}
    }
    {
        pub fn menu_config<S: IntoCStr>(&self, name: LblId<S>) -> Menu<S> {
            Menu {
                name: name.into(),
                enabled: true,
                push: (),
            }
        }
    }
}

decl_builder_with_opt! {
    CollapsingHeader, ImGui_CollapsingHeader, no_op () (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        flags (TreeNodeFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{flags: TreeNodeFlags}
    }
    {
        pub fn collapsing_header_config<S: IntoCStr>(&self, label: LblId<S>) -> CollapsingHeader<S> {
            CollapsingHeader {
                label: label.into(),
                flags: TreeNodeFlags::None,
                push: (),
            }
        }
    }
}

enum LabelId<'a, S: IntoCStr, H: Hashable> {
    LblId(LblId<S>),
    LabelId(&'a str, H),
}

unsafe fn tree_node_ex_helper<S: IntoCStr, H: Hashable>(
    label_id: LabelId<'_, S, H>,
    flags: TreeNodeFlags,
) -> bool {
    unsafe {
        match label_id {
            LabelId::LblId(lbl) => ImGui_TreeNodeEx(lbl.into().as_ptr(), flags.bits()),
            LabelId::LabelId(lbl, id) => {
                let (start, end) = text_ptrs(lbl);
                // Warning! internal imgui API ahead, the alterative would be to call all the TreeNodeEx* functions without the Hashable generics
                ImGui_TreeNodeBehavior(id.get_id(), flags.bits(), start, end)
            }
        }
    }
}

decl_builder_with_opt! {
    TreeNode, tree_node_ex_helper, ImGui_TreePop ('a) (S: IntoCStr, H: Hashable)
    (
        label (LabelId<'a, S, H>) (label),
        flags (TreeNodeFlags) (flags),
    )
    {
        decl_builder_setter!{flags: TreeNodeFlags}
    }
    {
        pub fn tree_node_config<S: IntoCStr>(&self, label: LblId<S>) -> TreeNode<'static, S, usize> {
            TreeNode {
                label: LabelId::LblId(label),
                flags: TreeNodeFlags::None,
                push: (),
            }
        }
        pub fn tree_node_ex_config<'a, H: Hashable>(&self, id: H, label: &'a str) -> TreeNode<'a, &'a str, H> {
            TreeNode {
                label: LabelId::LabelId(label, id),
                flags: TreeNodeFlags::None,
                push: (),
            }
        }
    }
}

decl_builder_with_opt! {
    Popup, ImGui_BeginPopup, ImGui_EndPopup () (S: IntoCStr)
    (
        str_id (S::Temp) (str_id.as_ptr()),
        flags (WindowFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{flags: WindowFlags}
    }
    {
        pub fn popup_config<S: IntoCStr>(&self, str_id: Id<S>) -> Popup<S> {
            Popup {
                str_id: str_id.into(),
                flags: WindowFlags::None,
                push: (),
            }
        }
    }
}

enum PopupOpened<'a> {
    Literal(bool),
    Reference(&'a mut bool),
    None,
}

impl PopupOpened<'_> {
    unsafe fn pointer(&mut self) -> *mut bool {
        match self {
            PopupOpened::Literal(x) => x,
            PopupOpened::Reference(r) => *r,
            PopupOpened::None => std::ptr::null_mut(),
        }
    }
}

decl_builder_with_opt! {
    /// Dear ImGui (`BeginPopupModal`): begin popup modal
    PopupModal, ImGui_BeginPopupModal, ImGui_EndPopup ('a) (S: IntoCStr)
    (
        name (S::Temp) (name.as_ptr()),
        opened (PopupOpened<'a>) (opened.pointer()),
        flags (WindowFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{flags: WindowFlags}

        pub fn close_button(mut self, close_button: bool) -> Self {
            self.opened = if close_button { PopupOpened::Literal(true) } else { PopupOpened::None };
            self
        }

        pub fn opened(self, opened: Option<&'a mut bool>) -> PopupModal<'a, S, P> {
            let opened = match opened {
                Some(b) => PopupOpened::Reference(b),
                None => PopupOpened::None,
            };
            PopupModal {
                opened,
                .. self
            }
        }
    }
    {
        pub fn popup_modal_config<S: IntoCStr>(&self, name: LblId<S>) -> PopupModal<'static, S> {
            PopupModal {
                name: name.into(),
                opened: PopupOpened::None,
                flags: WindowFlags::None,
                push: (),
            }
        }
    }
}

macro_rules! decl_builder_popup_context {
    ($struct:ident $begin:ident $do_function:ident) => {
        decl_builder_with_opt! {
            /// Dear ImGui (`BeginPopupContext`...): begin popup context
            $struct, $begin, ImGui_EndPopup () (S: IntoCStr)
            (
                str_id (Option<S::Temp>) (optional_str(&str_id)),
                flags (PopupFlags) (flags.bits()),
            )
            {
                decl_builder_setter!{flags: PopupFlags}
                pub fn str_id<S2: IntoCStr>(self, str_id: LblId<S2>) -> $struct<S2, P> {
                    $struct {
                        str_id: Some(str_id.into()),
                        flags: self.flags,
                        push: self.push,
                    }
                }

            }
            {
                pub fn $do_function<'a>(&self) -> $struct<&'a str> {
                    // Default flags in imgui.h used to be 1, that was `MouseButtonRight`
                    // while 0 was `MouseButtonLeft`.
                    // Now the default is 0, that is `PopupFlags::None`, while
                    // 1 and 2 are reserved for legacy compatibility.
                    // Setting the flags to `None` is semantically equivalent to `MouseButtonRight`,
                    // and that is what imgui.h does, so we do the same.
                    $struct {
                        str_id: None,
                        flags: PopupFlags::None,
                        push: (),
                    }
                }
            }
        }
    };
}

decl_builder_popup_context! {PopupContextItem ImGui_BeginPopupContextItem popup_context_item_config}
decl_builder_popup_context! {PopupContextWindow ImGui_BeginPopupContextWindow popup_context_window_config}
decl_builder_popup_context! {PopupContextVoid ImGui_BeginPopupContextVoid popup_context_void_config}

decl_builder_with_opt! {
    /// Dear ImGui (`BeginCombo`): begin combo box
    Combo, ImGui_BeginCombo, ImGui_EndCombo () (S1: IntoCStr, S2: IntoCStr)
    (
        label (S1::Temp) (label.as_ptr()),
        preview_value (Option<S2::Temp>) (optional_str(&preview_value)),
        flags (ComboFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{flags: ComboFlags}
        pub fn preview_value_opt<S3: IntoCStr>(self, preview_value: Option<S3>) -> Combo<S1, S3> {
            Combo {
                label: self.label,
                preview_value: preview_value.map(|x| x.into()),
                flags: ComboFlags::None,
                push: (),
            }
        }
        pub fn preview_value<S3: IntoCStr>(self, preview_value: S3) -> Combo<S1, S3> {
            self.preview_value_opt(Some(preview_value))
        }
    }
    {
        pub fn combo_config<'a, S: IntoCStr>(&self, label: LblId<S>) -> Combo<S, &'a str> {
            Combo {
                label: label.into(),
                preview_value: None,
                flags: ComboFlags::None,
                push: (),
            }
        }
        // Helper function for simple use cases
        pub fn combo<V: Copy + PartialEq, S1: IntoCStr, S2: IntoCStr>(
            &self,
            label: LblId<S1>,
            values: impl IntoIterator<Item=V>,
            f_name: impl Fn(V) -> S2,
            current: &mut V
        ) -> bool
        {
            let mut changed = false;
            self.combo_config(label)
                .preview_value(f_name(*current))
                .with(|| {
                    for (i, val) in values.into_iter().enumerate() {
                        if self.selectable_config(lbl_id(f_name(val), i.to_string()))
                            .selected(*current == val)
                            .build()
                        {
                            *current = val;
                            changed = true;
                        }
                    }
                });
            changed
        }
    }
}

decl_builder_with_opt! {
    /// Dear ImGui (`BeginListBox`): begin list box
    ListBox, ImGui_BeginListBox, ImGui_EndListBox () (S: IntoCStr)
    (
        label (S::Temp) (label.as_ptr()),
        size (ImVec2) (&size),
    )
    {
        decl_builder_setter_vector2!{size: Vector2}
    }
    {
        pub fn list_box_config<S: IntoCStr>(&self, label: LblId<S>) -> ListBox<S> {
            ListBox {
                label: label.into(),
                size: im_vec2(0.0, 0.0),
                push: (),
            }
        }
        // Helper function for simple use cases
        pub fn list_box<V: Copy + PartialEq, S1: IntoCStr, S2: IntoCStr>(
            &self,
            label: LblId<S1>,
            mut height_in_items: i32,
            values: impl IntoIterator<Item=V>,
            f_name: impl Fn(V) -> S2,
            current: &mut V
        ) -> bool
        {
            // Calculate size from "height_in_items"
            if height_in_items < 0 {
                // this should be values.len().min(7) but IntoIterator is lazy evaluated
                height_in_items = 7;
            }
            let height_in_items_f = height_in_items as f32 + 0.25;
            let height_in_pixels = self.get_text_line_height_with_spacing() * height_in_items_f + self.style().FramePadding.y * 2.0;

            let mut changed = false;
            self.list_box_config(label)
                .size(vec2(0.0, height_in_pixels.floor()))
                .with(|| {
                    for (i, val) in values.into_iter().enumerate() {
                        if self.selectable_config(lbl_id(f_name(val), i.to_string()))
                            .selected(*current == val)
                            .build()
                        {
                            *current = val;
                            changed = true;
                        }
                    }
                });
            changed
        }
    }
}

decl_builder_with_opt! {
    /// Dear ImGui (`BeginTabBar`): begin tab bar
    TabBar, ImGui_BeginTabBar, ImGui_EndTabBar () (S: IntoCStr)
    (
        str_id (S::Temp) (str_id.as_ptr()),
        flags (TabBarFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{flags: TabBarFlags}
    }
    {
        pub fn tab_bar_config<S: IntoCStr>(&self, str_id: LblId<S>) -> TabBar<S> {
            TabBar {
                str_id: str_id.into(),
                flags: TabBarFlags::None,
                push: (),
            }
        }
    }
}

decl_builder_with_opt! {
    /// Dear ImGui (`BeginTabItem`): begin tab item
    TabItem, ImGui_BeginTabItem, ImGui_EndTabItem ('o) (S: IntoCStr)
    (
        str_id (S::Temp) (str_id.as_ptr()),
        opened (Option<&'o mut bool>) (optional_mut_bool(&mut opened)),
        flags (TabItemFlags) (flags.bits()),
    )
    {
        decl_builder_setter!{flags: TabItemFlags}
        decl_builder_setter!{opened: &'o mut bool}
    }
    {
        pub fn tab_item_config<S: IntoCStr>(&self, str_id: LblId<S>) -> TabItem<'_, S> {
            TabItem {
                str_id: str_id.into(),
                opened: None,
                flags: TabItemFlags::None,
                push: (),
            }
        }
        pub fn tab_item_button(label: LblId<impl IntoCStr>, flags: TabItemFlags) -> bool {
            unsafe {
                ImGui_TabItemButton(label.into().as_ptr(), flags.bits())
            }
        }
        pub fn set_tab_item_closed(tab_or_docked_window_label: LblId<impl IntoCStr>) {
            unsafe {
                ImGui_SetTabItemClosed(tab_or_docked_window_label.into().as_ptr());
            }
        }
    }
}

/// Argument for `Ui::same_line_ex()`.
#[derive(Copy, Clone, Default, Debug)]
pub enum SameLine {
    /// Default separation, that will be from Style.ItemSpacing
    #[default]
    Default,
    /// Offset from the very start of the line.
    ///
    /// It can be positive, 0, or negative.
    OffsetFromStart(f32),
    /// Separation from the previous element.
    ///
    /// Must be >= 0.0 or will fallback to `Default`.
    Spacing(f32),
}

impl<A> Ui<A> {
    // The callback will be callable until the next call to do_frame()
    unsafe fn push_callback<X>(&self, mut cb: impl FnMut(*mut A, X) + 'static) -> usize {
        let cb = Box::new(move |data: *mut A, ptr: *mut c_void| {
            let x = ptr as *mut X;
            cb(data, unsafe { std::ptr::read(x) });
        });
        let mut callbacks = self.callbacks.borrow_mut();
        let id = callbacks.len();

        callbacks.push(cb);
        merge_generation(id, self.generation)
    }
    unsafe fn run_callback<X>(id: usize, x: X) {
        unsafe {
            let user_data = RawContext::current().io().BackendLanguageUserData;
            if user_data.is_null() {
                return;
            }
            // The lifetime of ui has been erased, but at least the types of A and X should be correct
            let ui = &*(user_data as *const Self);
            let Some(id) = remove_generation(id, ui.generation) else {
                eprintln!("lost generation callback");
                return;
            };

            let mut callbacks = ui.callbacks.borrow_mut();
            let cb = &mut callbacks[id];
            // disable the destructor of x, it will be run inside the callback
            let mut x = MaybeUninit::new(x);
            cb(ui.data, x.as_mut_ptr() as *mut c_void);
        }
    }

    pub fn get_clipboard_text(&self) -> String {
        unsafe {
            CStr::from_ptr(ImGui_GetClipboardText())
                .to_string_lossy()
                .into_owned()
        }
    }
    pub fn set_clipboard_text(&self, text: impl IntoCStr) {
        let text = text.into();
        unsafe { ImGui_SetClipboardText(text.as_ptr()) }
    }
    pub fn set_next_window_size_constraints_callback(
        &self,
        size_min: Vector2,
        size_max: Vector2,
        mut cb: impl FnMut(SizeCallbackData<'_>) + 'static,
    ) {
        unsafe {
            // Beware! This callback is called while the `do_ui()` is still running, so the argument for the
            // first callback is null!
            let id = self.push_callback(move |_, scd| cb(scd));
            ImGui_SetNextWindowSizeConstraints(
                &v2_to_im(size_min),
                &v2_to_im(size_max),
                Some(call_size_callback::<A>),
                id as *mut c_void,
            );
        }
    }
    /// Dear ImGui (`SetNextWindowSizeConstraints`): set next window size limits. use 0.0f or FLT_MAX if you don't want limits.
    /// Use -1 for both min and max of same axis to preserve current size (which itself is a constraint).
    pub fn set_next_window_size_constraints(&self, size_min: Vector2, size_max: Vector2) {
        unsafe {
            ImGui_SetNextWindowSizeConstraints(
                &v2_to_im(size_min),
                &v2_to_im(size_max),
                None,
                null_mut(),
            );
        }
    }
    /// Dear ImGui (`SetNextItemWidth`): set width of the _next_ common large "item+label" widget.
    /// >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -FLT_MIN always align width to the right side).
    pub fn set_next_item_width(&self, item_width: f32) {
        unsafe {
            ImGui_SetNextItemWidth(item_width);
        }
    }
    /// Dear ImGui (`SetNextItemOpen`): set next TreeNode/CollapsingHeader open state.
    pub fn set_next_item_open(&self, is_open: bool, cond: Cond) {
        unsafe {
            ImGui_SetNextItemOpen(is_open, cond.bits());
        }
    }
    /// Dear ImGui (`SetNextItemStorageID`): set id to use for open/close storage (default to same as item id).
    pub fn set_next_item_storage_id(&self, id: ImGuiID) {
        unsafe { ImGui_SetNextItemStorageID(id) }
    }
    /// Dear ImGui (`GetTreeNodeToLabelSpacing`): horizontal distance preceding label when using TreeNode*() or Bullet()
    /// == (g.FontSize + style.FramePadding.x*2) for a regular unframed TreeNode.
    pub fn tree_node_to_label_spacing(&self) -> f32 {
        unsafe { ImGui_GetTreeNodeToLabelSpacing() }
    }
    /// Dear ImGui (`TreeNodeGetOpen`): retrieve tree node open/close state.
    pub fn tree_node_get_open(&self, id: ImGuiID) -> bool {
        unsafe { ImGui_TreeNodeGetOpen(id) }
    }
    /// Dear ImGui (`SetKeyboardFocusHere`): focus keyboard on the next widget.
    /// Use positive `offset` to access sub components of a multiple component widget. Use -1 to access previous widget.
    pub fn set_keyboard_focus_here(&self, offset: i32) {
        unsafe { ImGui_SetKeyboardFocusHere(offset) }
    }

    with_begin_end! {
        /// See `BeginGroup`, `EndGroup`.
        group ImGui_BeginGroup ImGui_EndGroup ()
    }
    with_begin_end! {
        /// See `BeginDisabled`, `EndDisabled`.
        disabled ImGui_BeginDisabled ImGui_EndDisabled (
            disabled (bool) (disabled),
        )
    }
    with_begin_end! {
        /// See `PushClipRect`, `PopClipRect`.
        clip_rect ImGui_PushClipRect ImGui_PopClipRect (
            clip_rect_min (Vector2) (&v2_to_im(clip_rect_min)),
            clip_rect_max (Vector2) (&v2_to_im(clip_rect_max)),
            intersect_with_current_clip_rect (bool) (intersect_with_current_clip_rect),
        )
    }

    with_begin_end_opt! {
        /// See `BeginMainMenuBar`, `EndMainMenuBar`.
        main_menu_bar ImGui_BeginMainMenuBar ImGui_EndMainMenuBar ()
    }
    with_begin_end_opt! {
        /// See `BeginMenuBar`, `EndMenuBar`.
        menu_bar ImGui_BeginMenuBar ImGui_EndMenuBar ()
    }
    with_begin_end_opt! {
        /// See `BeginTooltip`, `EndTooltip`.
        tooltip ImGui_BeginTooltip ImGui_EndTooltip ()
    }
    with_begin_end_opt! {
        /// See `BeginItemTooltip`, `EndTooltip`. There is not `EndItemTooltip`.
        item_tooltip ImGui_BeginItemTooltip ImGui_EndTooltip ()
    }

    /// Calls the `f` functions with the given `push`
    pub fn with_push<R>(&self, push: impl Pushable, f: impl FnOnce() -> R) -> R {
        unsafe {
            let _guard = push_guard(&push);
            f()
        }
    }
    /// Dear ImGui (`ShowDemoWindow`): create Demo window. demonstrate most ImGui features.
    /// call this to learn about the library! try to make it always available in your application!
    pub fn show_demo_window(&self, mut show: Option<&mut bool>) {
        unsafe {
            ImGui_ShowDemoWindow(optional_mut_bool(&mut show));
        }
    }
    /// Dear ImGui (`SetNextWindowPos`): set next window position. call before `Begin()`. use pivot=(0.5f,0.5f) to center on given point, etc.
    pub fn set_next_window_pos(&self, pos: Vector2, cond: Cond, pivot: Vector2) {
        unsafe {
            ImGui_SetNextWindowPos(&v2_to_im(pos), cond.bits(), &v2_to_im(pivot));
        }
    }
    /// Dear ImGui (`SetNextWindowSize`): set next window size. set axis to 0.0f to force an auto-fit on this axis. call before `Begin()`
    pub fn set_next_window_size(&self, size: Vector2, cond: Cond) {
        unsafe {
            ImGui_SetNextWindowSize(&v2_to_im(size), cond.bits());
        }
    }
    /// Dear ImGui (`SetNextWindowContentSize`): set next window content size (~ scrollable client area, which enforce the range of scrollbars). Not including window decorations (title bar, menu bar, etc.) nor WindowPadding. set an axis to 0.0f to leave it automatic. call before `Begin()`
    pub fn set_next_window_content_size(&self, size: Vector2) {
        unsafe {
            ImGui_SetNextWindowContentSize(&v2_to_im(size));
        }
    }

    /// Dear ImGui (`SetNextWindowCollapsed`): set next window collapsed state. call before `Begin()`
    pub fn set_next_window_collapsed(&self, collapsed: bool, cond: Cond) {
        unsafe {
            ImGui_SetNextWindowCollapsed(collapsed, cond.bits());
        }
    }

    /// Dear ImGui (`SetNextWindowFocus`): set next window to be focused / top-most. call before `Begin()`
    pub fn set_next_window_focus(&self) {
        unsafe {
            ImGui_SetNextWindowFocus();
        }
    }

    /// Dear ImGui (`SetNextWindowScroll`): set next window scrolling value (use < 0.0f to not affect a given axis).
    pub fn set_next_window_scroll(&self, scroll: Vector2) {
        unsafe {
            ImGui_SetNextWindowScroll(&v2_to_im(scroll));
        }
    }

    /// Dear ImGui (`SetNextWindowBgAlpha`): set next window background color alpha. helper to easily override the Alpha component of `ImGuiCol_WindowBg`/`ChildBg`/`PopupBg`. you may also use `ImGuiWindowFlags_NoBackground`.
    pub fn set_next_window_bg_alpha(&self, alpha: f32) {
        unsafe {
            ImGui_SetNextWindowBgAlpha(alpha);
        }
    }
    /// Dear ImGui (`GetWindowDrawList`): get draw list associated to the current window, to append your own drawing primitives.
    pub fn window_draw_list(&self) -> WindowDrawList<'_, A> {
        unsafe {
            let ptr = ImGui_GetWindowDrawList();
            WindowDrawList { ui: self, ptr }
        }
    }
    /// Dear ImGui (`GetWindowDpiScale`): get DPI scale currently associated to the current window's viewport.
    pub fn window_dpi_scale(&self) -> f32 {
        unsafe { ImGui_GetWindowDpiScale() }
    }
    /// Dear ImGui (`GetForegroundDrawList`): get foreground draw list for the given viewport.
    /// this draw list will be the top-most rendered one. Useful to quickly draw shapes/text over dear imgui contents.
    pub fn foreground_draw_list(&self) -> WindowDrawList<'_, A> {
        unsafe {
            let ptr = ImGui_GetForegroundDrawList(std::ptr::null_mut());
            WindowDrawList { ui: self, ptr }
        }
    }
    /// Dear ImGui (`GetBackgroundDrawList`): get background draw list for the given viewport.
    /// this draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents.
    pub fn background_draw_list(&self) -> WindowDrawList<'_, A> {
        unsafe {
            let ptr = ImGui_GetBackgroundDrawList(std::ptr::null_mut());
            WindowDrawList { ui: self, ptr }
        }
    }
    /// Dear ImGui (`TextUnformatted`): raw text display
    pub fn text(&self, text: &str) {
        unsafe {
            let (start, end) = text_ptrs(text);
            ImGui_TextUnformatted(start, end);
        }
    }
    /// Dear ImGui (`TextColored`): colored text display
    pub fn text_colored(&self, color: Color, text: impl IntoCStr) {
        let text = text.into();
        unsafe { ImGui_TextColored(&color.into(), c"%s".as_ptr(), text.as_ptr()) }
    }
    /// Dear ImGui (`TextDisabled`): disabled text display
    pub fn text_disabled(&self, text: impl IntoCStr) {
        let text = text.into();
        unsafe { ImGui_TextDisabled(c"%s".as_ptr(), text.as_ptr()) }
    }
    /// Dear ImGui (`TextWrapped`): wrapped text display
    pub fn text_wrapped(&self, text: impl IntoCStr) {
        let text = text.into();
        unsafe { ImGui_TextWrapped(c"%s".as_ptr(), text.as_ptr()) }
    }
    /// Dear ImGui (`TextLink`): hyperlink text button, return true when clicked
    pub fn text_link(&self, label: LblId<impl IntoCStr>) -> bool {
        let label = label.into();
        unsafe { ImGui_TextLink(label.as_ptr()) }
    }
    /// Dear ImGui (`TextLinkOpenURL`): hyperlink text button, automatically open file/url when clicked
    pub fn text_link_open_url(&self, label: LblId<impl IntoCStr>, url: impl IntoCStr) -> bool {
        let label = label.into();
        let url = url.into();
        unsafe { ImGui_TextLinkOpenURL(label.as_ptr(), url.as_ptr()) }
    }
    /// Dear ImGui (`LabelText`): display text+label aligned the same way as value+label widgets
    pub fn label_text(&self, label: impl IntoCStr, text: impl IntoCStr) {
        let label = label.into();
        let text = text.into();
        unsafe { ImGui_LabelText(label.as_ptr(), c"%s".as_ptr(), text.as_ptr()) }
    }
    /// Dear ImGui (`BulletText`): shortcut for `Bullet()`+`Text()`
    pub fn bullet_text(&self, text: impl IntoCStr) {
        let text = text.into();
        unsafe { ImGui_BulletText(c"%s".as_ptr(), text.as_ptr()) }
    }
    /// Dear ImGui (`Bullet`): draw a small circle + keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses
    pub fn bullet(&self) {
        unsafe {
            ImGui_Bullet();
        }
    }
    /// Dear ImGui (`SeparatorText`): currently: formatted text with a horizontal line
    pub fn separator_text(&self, text: impl IntoCStr) {
        let text = text.into();
        unsafe {
            ImGui_SeparatorText(text.as_ptr());
        }
    }
    /// Dear ImGui (`Separator`): separator
    pub fn separator(&self) {
        unsafe {
            ImGui_Separator();
        }
    }

    /// Dear ImGui (`SetItemDefaultFocus`): set item default focus
    pub fn set_item_default_focus(&self) {
        unsafe {
            ImGui_SetItemDefaultFocus();
        }
    }
    /// Dear ImGui (`IsItemHovered`): is the last item hovered?
    pub fn is_item_hovered(&self) -> bool {
        self.is_item_hovered_ex(HoveredFlags::None)
    }
    /// Dear ImGui (`IsItemHovered`): is the last item hovered?
    pub fn is_item_hovered_ex(&self, flags: HoveredFlags) -> bool {
        unsafe { ImGui_IsItemHovered(flags.bits()) }
    }
    /// Dear ImGui (`IsItemActive`): is the last item active?
    pub fn is_item_active(&self) -> bool {
        unsafe { ImGui_IsItemActive() }
    }
    /// Dear ImGui (`IsItemFocused`): is the last item focused?
    pub fn is_item_focused(&self) -> bool {
        unsafe { ImGui_IsItemFocused() }
    }
    /// Dear ImGui (`IsItemClicked`): is the last item hovered and mouse clicked on?
    pub fn is_item_clicked(&self, flags: MouseButton) -> bool {
        unsafe { ImGui_IsItemClicked(flags.bits()) }
    }
    /// Dear ImGui (`IsItemVisible`): is the last item visible?
    pub fn is_item_visible(&self) -> bool {
        unsafe { ImGui_IsItemVisible() }
    }
    /// Dear ImGui (`IsItemEdited`): is the last item edited?
    pub fn is_item_edited(&self) -> bool {
        unsafe { ImGui_IsItemEdited() }
    }
    /// Dear ImGui (`IsItemActivated`): was the last item just activated?
    pub fn is_item_activated(&self) -> bool {
        unsafe { ImGui_IsItemActivated() }
    }
    /// Dear ImGui (`IsItemDeactivated`): was the last item just deactivated?
    pub fn is_item_deactivated(&self) -> bool {
        unsafe { ImGui_IsItemDeactivated() }
    }
    /// Dear ImGui (`IsItemDeactivatedAfterEdit`): was the last item just deactivated after edit?
    pub fn is_item_deactivated_after_edit(&self) -> bool {
        unsafe { ImGui_IsItemDeactivatedAfterEdit() }
    }
    /// Dear ImGui (`IsItemToggledOpen`): was the last item just toggled open?
    pub fn is_item_toggled_open(&self) -> bool {
        unsafe { ImGui_IsItemToggledOpen() }
    }
    /// Dear ImGui (`IsAnyItemHovered`): is any item hovered?
    pub fn is_any_item_hovered(&self) -> bool {
        unsafe { ImGui_IsAnyItemHovered() }
    }
    /// Dear ImGui (`IsAnyItemActive`): is any item active?
    pub fn is_any_item_active(&self) -> bool {
        unsafe { ImGui_IsAnyItemActive() }
    }
    /// Dear ImGui (`IsAnyItemFocused`): is any item focused?
    pub fn is_any_item_focused(&self) -> bool {
        unsafe { ImGui_IsAnyItemFocused() }
    }
    /// Dear ImGui (`IsWindowCollapsed`): is the current window collapsed?
    pub fn is_window_collapsed(&self) -> bool {
        unsafe { ImGui_IsWindowCollapsed() }
    }
    /// Dear ImGui (`IsWindowFocused`): is current window focused?
    pub fn is_window_focused(&self, flags: FocusedFlags) -> bool {
        unsafe { ImGui_IsWindowFocused(flags.bits()) }
    }
    /// Dear ImGui (`IsWindowHovered`): is current window hovered?
    pub fn is_window_hovered(&self, flags: FocusedFlags) -> bool {
        unsafe { ImGui_IsWindowHovered(flags.bits()) }
    }
    /// Dear ImGui (`GetItemID`): get ID of last item
    pub fn get_item_id(&self) -> ImGuiID {
        unsafe { ImGui_GetItemID() }
    }
    /// Dear ImGui (`GetID`): get ID of given hashable
    pub fn get_id(&self, id: impl Hashable) -> ImGuiID {
        unsafe { id.get_id() }
    }
    /// Dear ImGui (`GetItemRectMin`): get item rect min
    pub fn get_item_rect_min(&self) -> Vector2 {
        unsafe { im_to_v2(ImGui_GetItemRectMin()) }
    }
    /// Dear ImGui (`GetItemRectMax`): get item rect max
    pub fn get_item_rect_max(&self) -> Vector2 {
        unsafe { im_to_v2(ImGui_GetItemRectMax()) }
    }
    /// Dear ImGui (`GetItemRectSize`): get item rect size
    pub fn get_item_rect_size(&self) -> Vector2 {
        unsafe { im_to_v2(ImGui_GetItemRectSize()) }
    }
    /// Dear ImGui (`GetItemFlags`): get item flags
    pub fn get_item_flags(&self) -> ItemFlags {
        unsafe { ItemFlags::from_bits_truncate(ImGui_GetItemFlags()) }
    }
    /// Available space from current position. This is your best friend!
    /// Dear ImGui (`GetContentRegionAvail`): available space from current position. This is your best friend!
    pub fn get_content_region_avail(&self) -> Vector2 {
        unsafe { im_to_v2(ImGui_GetContentRegionAvail()) }
    }
    /// Dear ImGui (`GetWindowPos`): get current window position in screen space
    pub fn get_window_pos(&self) -> Vector2 {
        unsafe { im_to_v2(ImGui_GetWindowPos()) }
    }
    /// Dear ImGui (`GetWindowWidth`): get current window width
    pub fn get_window_width(&self) -> f32 {
        unsafe { ImGui_GetWindowWidth() }
    }
    /// Dear ImGui (`GetWindowHeight`): get current window height
    pub fn get_window_height(&self) -> f32 {
        unsafe { ImGui_GetWindowHeight() }
    }
    /// Dear ImGui (`GetScrollX`): get scrolling amount
    pub fn get_scroll_x(&self) -> f32 {
        unsafe { ImGui_GetScrollX() }
    }
    /// Dear ImGui (`GetScrollY`): get scrolling amount
    pub fn get_scroll_y(&self) -> f32 {
        unsafe { ImGui_GetScrollY() }
    }
    /// Dear ImGui (`SetScrollX`): set scrolling amount
    pub fn set_scroll_x(&self, scroll_x: f32) {
        unsafe {
            ImGui_SetScrollX(scroll_x);
        }
    }
    /// Dear ImGui (`SetScrollY`): set scrolling amount
    pub fn set_scroll_y(&self, scroll_y: f32) {
        unsafe {
            ImGui_SetScrollY(scroll_y);
        }
    }
    /// Dear ImGui (`GetScrollMaxX`): get maximum scrolling amount
    pub fn get_scroll_max_x(&self) -> f32 {
        unsafe { ImGui_GetScrollMaxX() }
    }
    /// Dear ImGui (`GetScrollMaxY`): get maximum scrolling amount
    pub fn get_scroll_max_y(&self) -> f32 {
        unsafe { ImGui_GetScrollMaxY() }
    }
    /// Dear ImGui (`SetScrollHereX`): adjust scrolling amount to make current cursor position visible.
    pub fn set_scroll_here_x(&self, center_x_ratio: f32) {
        unsafe {
            ImGui_SetScrollHereX(center_x_ratio);
        }
    }
    /// Dear ImGui (`SetScrollHereY`): adjust scrolling amount to make current cursor position visible.
    pub fn set_scroll_here_y(&self, center_y_ratio: f32) {
        unsafe {
            ImGui_SetScrollHereY(center_y_ratio);
        }
    }
    /// Dear ImGui (`SetScrollFromPosX`): adjust scrolling amount to make given position visible.
    pub fn set_scroll_from_pos_x(&self, local_x: f32, center_x_ratio: f32) {
        unsafe {
            ImGui_SetScrollFromPosX(local_x, center_x_ratio);
        }
    }
    /// Dear ImGui (`SetScrollFromPosY`): adjust scrolling amount to make given position visible.
    pub fn set_scroll_from_pos_y(&self, local_y: f32, center_y_ratio: f32) {
        unsafe {
            ImGui_SetScrollFromPosY(local_y, center_y_ratio);
        }
    }
    /// Dear ImGui (`SetWindowPos`): (not recommended) set current window position - call within `Begin()`/`End()`. prefer using `SetNextWindowPos()`, as this may incur tearing and side-effects.
    pub fn set_window_pos(&self, pos: Vector2, cond: Cond) {
        unsafe {
            ImGui_SetWindowPos(&v2_to_im(pos), cond.bits());
        }
    }
    /// Dear ImGui (`SetWindowSize`): (not recommended) set current window size - call within `Begin()`/`End()`. set to ImVec2(0, 0) to force an auto-fit. prefer using `SetNextWindowSize()`, as this may incur tearing and minor side-effects.
    pub fn set_window_size(&self, size: Vector2, cond: Cond) {
        unsafe {
            ImGui_SetWindowSize(&v2_to_im(size), cond.bits());
        }
    }
    /// Dear ImGui (`SetWindowCollapsed`): (not recommended) set current window collapsed state. prefer using `SetNextWindowCollapsed()`.
    pub fn set_window_collapsed(&self, collapsed: bool, cond: Cond) {
        unsafe {
            ImGui_SetWindowCollapsed(collapsed, cond.bits());
        }
    }
    /// Dear ImGui (`SetWindowFocus`): (not recommended) set current window to be focused / top-most. prefer using `SetNextWindowFocus()`.
    pub fn set_window_focus(&self) {
        unsafe {
            ImGui_SetWindowFocus();
        }
    }
    /// Forces the next control to be in the same line.
    ///
    /// Dear ImGui (`SameLine`): forces the next control to be in the same line.
    pub fn same_line(&self) {
        self.same_line_ex(SameLine::Default);
    }
    /// Forces the next control to be in the same line, with custom spacing.
    ///
    /// Dear ImGui (`SameLine`): forces the next control to be in the same line, with custom spacing.
    pub fn same_line_ex(&self, same_line: SameLine) {
        let (offset_from_start_x, spacing) = match same_line {
            SameLine::Default => (0.0, -1.0),
            // The user asked for offset=0.0, but if we use (0.0, 0.0) then ImGui
            // will do as if Spacing(0.0). Move it just a little and compensate with spc.
            SameLine::OffsetFromStart(offs) => {
                if offs != 0.0 {
                    (offs, 0.0)
                } else {
                    (-f32::MIN_POSITIVE, f32::MIN_POSITIVE)
                }
            }
            // If spc were negative it would switch to default.
            SameLine::Spacing(spc) => (0.0, spc.max(0.0)),
        };
        unsafe {
            ImGui_SameLine(offset_from_start_x, spacing);
        }
    }
    /// Dear ImGui (`NewLine`): force new line
    pub fn new_line(&self) {
        unsafe {
            ImGui_NewLine();
        }
    }
    /// Dear ImGui (`Spacing`): add vertical spacing
    pub fn spacing(&self) {
        unsafe {
            ImGui_Spacing();
        }
    }
    /// Dear ImGui (`Dummy`): add a dummy item of given size. unlike `InvisibleButton()`, `Dummy()` won't take the mouse click or be navigable into.
    pub fn dummy(&self, size: Vector2) {
        unsafe {
            ImGui_Dummy(&v2_to_im(size));
        }
    }
    /// Dear ImGui (`Indent`): add indentation
    pub fn indent(&self, indent_w: f32) {
        unsafe {
            ImGui_Indent(indent_w);
        }
    }
    /// Dear ImGui (`Unindent`): remove indentation
    pub fn unindent(&self, indent_w: f32) {
        unsafe {
            ImGui_Unindent(indent_w);
        }
    }
    /// Prefer `get_cursor_screen_pos` over this.
    pub fn get_cursor_pos(&self) -> Vector2 {
        unsafe { im_to_v2(ImGui_GetCursorPos()) }
    }
    /// Prefer `get_cursor_screen_pos` over this.
    pub fn get_cursor_pos_x(&self) -> f32 {
        unsafe { ImGui_GetCursorPosX() }
    }
    /// Prefer `get_cursor_screen_pos` over this.
    pub fn get_cursor_pos_y(&self) -> f32 {
        unsafe { ImGui_GetCursorPosY() }
    }
    /// Prefer `set_cursor_screen_pos` over this.
    pub fn set_cursor_pos(&self, local_pos: Vector2) {
        unsafe {
            ImGui_SetCursorPos(&v2_to_im(local_pos));
        }
    }
    /// Prefer `set_cursor_screen_pos` over this.
    pub fn set_cursor_pos_x(&self, local_x: f32) {
        unsafe {
            ImGui_SetCursorPosX(local_x);
        }
    }
    /// Prefer `set_cursor_screen_pos` over this.
    pub fn set_cursor_pos_y(&self, local_y: f32) {
        unsafe {
            ImGui_SetCursorPosY(local_y);
        }
    }
    /// Prefer `get_cursor_screen_pos` over this.
    pub fn get_cursor_start_pos(&self) -> Vector2 {
        unsafe { im_to_v2(ImGui_GetCursorStartPos()) }
    }
    /// Get cursor position in absolute coordinates. This is your best friend!
    pub fn get_cursor_screen_pos(&self) -> Vector2 {
        unsafe { im_to_v2(ImGui_GetCursorScreenPos()) }
    }
    /// Set cursor position in absolute coordinates. This is your best friend!
    pub fn set_cursor_screen_pos(&self, pos: Vector2) {
        unsafe {
            ImGui_SetCursorScreenPos(&v2_to_im(pos));
        }
    }
    /// Dear ImGui (`AlignTextToFramePadding`): vertically align upcoming text baseline to FramePadding.y
    /// so that it will align properly to regularly framed items (call if you have text on a line before a framed item).
    pub fn align_text_to_frame_padding(&self) {
        unsafe {
            ImGui_AlignTextToFramePadding();
        }
    }
    /// Dear ImGui (`GetTextLineHeight`): ~ FontSize.
    pub fn get_text_line_height(&self) -> f32 {
        unsafe { ImGui_GetTextLineHeight() }
    }
    /// Dear ImGui (`GetTextLineHeightWithSpacing`): ~ FontSize + style.ItemSpacing.y
    /// (distance in pixels between 2 consecutive lines of text).
    pub fn get_text_line_height_with_spacing(&self) -> f32 {
        unsafe { ImGui_GetTextLineHeightWithSpacing() }
    }
    /// Dear ImGui (`GetFrameHeight`): ~ FontSize + style.FramePadding.y * 2.
    pub fn get_frame_height(&self) -> f32 {
        unsafe { ImGui_GetFrameHeight() }
    }
    /// Dear ImGui (`GetFrameHeightWithSpacing`): ~ FontSize + style.FramePadding.y * 2 + style.ItemSpacing.y
    /// (distance in pixels between 2 consecutive lines of framed widgets).
    pub fn get_frame_height_with_spacing(&self) -> f32 {
        unsafe { ImGui_GetFrameHeightWithSpacing() }
    }
    /// Dear ImGui (`CalcItemWidth`): width of item given pushed settings and current cursor position.
    /// NOT necessarily the width of last item unlike most 'Item' functions.
    pub fn calc_item_width(&self) -> f32 {
        unsafe { ImGui_CalcItemWidth() }
    }
    pub fn calc_text_size(&self, text: &str) -> Vector2 {
        self.calc_text_size_ex(text, false, -1.0)
    }
    pub fn calc_text_size_ex(
        &self,
        text: &str,
        hide_text_after_double_hash: bool,
        wrap_width: f32,
    ) -> Vector2 {
        unsafe {
            let (start, end) = text_ptrs(text);
            im_to_v2(ImGui_CalcTextSize(
                start,
                end,
                hide_text_after_double_hash,
                wrap_width,
            ))
        }
    }
    pub fn key_mods(&self) -> KeyMod {
        let mods = self.io().KeyMods;
        KeyMod::from_bits_truncate(mods & ImGuiKey::ImGuiMod_Mask_.0)
    }
    /// Dear ImGui (`IsKeyDown`): is key being held.
    pub fn is_key_down(&self, key: Key) -> bool {
        unsafe { ImGui_IsKeyDown(key.bits()) }
    }
    /// Dear ImGui (`IsKeyPressed`): was key pressed (went from !Down to Down)?
    /// Repeat rate uses io.KeyRepeatDelay / KeyRepeatRate.
    pub fn is_key_pressed(&self, key: Key) -> bool {
        unsafe {
            ImGui_IsKeyPressed(key.bits(), /*repeat*/ true)
        }
    }
    /// Dear ImGui (`IsKeyPressed`): was key pressed (went from !Down to Down)?
    /// Same as [`is_key_pressed`](Self::is_key_pressed) but with repeat disabled.
    pub fn is_key_pressed_no_repeat(&self, key: Key) -> bool {
        unsafe {
            ImGui_IsKeyPressed(key.bits(), /*repeat*/ false)
        }
    }
    /// Dear ImGui (`IsKeyReleased`): was key released (went from Down to !Down)?
    pub fn is_key_released(&self, key: Key) -> bool {
        unsafe { ImGui_IsKeyReleased(key.bits()) }
    }
    /// Dear ImGui (`GetKeyPressedAmount`): uses provided repeat rate/delay. return a count, most often 0 or 1
    /// but might be >1 if RepeatRate is small enough that DeltaTime > RepeatRate.
    pub fn get_key_pressed_amount(&self, key: Key, repeat_delay: Duration, rate: f32) -> i32 {
        unsafe { ImGui_GetKeyPressedAmount(key.bits(), repeat_delay.as_secs_f32(), rate) }
    }
    /// Dear ImGui (`GetFontTexUvWhitePixel`): get UV coordinate for a white pixel, useful to draw
    /// custom shapes via the ImDrawList API.
    pub fn get_font_tex_uv_white_pixel(&self) -> Vector2 {
        unsafe { im_to_v2(ImGui_GetFontTexUvWhitePixel()) }
    }
    //GetKeyName
    //SetNextFrameWantCaptureKeyboard
    /// Dear ImGui (`GetFontSize`): get current scaled font size (= height in pixels).
    /// AFTER global scale factors applied.
    ///
    /// *IMPORTANT* DO NOT PASS THIS VALUE TO PushFont()! Use the style's FontSizeBase to get
    /// the value before global scale factors.
    pub fn get_font_size(&self) -> f32 {
        unsafe { ImGui_GetFontSize() }
    }
    /// Dear ImGui (`IsMouseDown`): is mouse button held?
    pub fn is_mouse_down(&self, button: MouseButton) -> bool {
        unsafe { ImGui_IsMouseDown(button.bits()) }
    }
    /// Dear ImGui (`IsMouseClicked`): did mouse button clicked? (went from !Down to Down).
    /// Same as GetMouseClickedCount() == 1.
    pub fn is_mouse_clicked(&self, button: MouseButton) -> bool {
        unsafe {
            ImGui_IsMouseClicked(button.bits(), /*repeat*/ false)
        }
    }
    /// Dear ImGui (`IsMouseClicked`): did mouse button clicked? (went from !Down to Down).
    /// Same as [`is_mouse_clicked`](Self::is_mouse_clicked) but with repeat enabled.
    pub fn is_mouse_clicked_repeat(&self, button: MouseButton) -> bool {
        unsafe {
            ImGui_IsMouseClicked(button.bits(), /*repeat*/ true)
        }
    }
    /// Dear ImGui (`IsMouseReleased`): did mouse button released? (went from Down to !Down).
    pub fn is_mouse_released(&self, button: MouseButton) -> bool {
        unsafe { ImGui_IsMouseReleased(button.bits()) }
    }
    /// Dear ImGui (`IsMouseDoubleClicked`): did mouse button double-clicked? Same as GetMouseClickedCount() == 2.
    /// (note that a double-click will also report IsMouseClicked() == true).
    pub fn is_mouse_double_clicked(&self, button: MouseButton) -> bool {
        unsafe { ImGui_IsMouseDoubleClicked(button.bits()) }
    }
    /// Dear ImGui (`GetMouseClickedCount`): return the number of successive mouse-clicks at the time
    /// where a click happen (otherwise 0).
    pub fn get_mouse_clicked_count(&self, button: MouseButton) -> i32 {
        unsafe { ImGui_GetMouseClickedCount(button.bits()) }
    }
    /// Dear ImGui (`GetItemClickedCountWithSingleClickDelay`): [BETA] Building block for disambiguation between single-click and double-click.
    ///
    /// Returns 1 on single-click but delayed by `io.MouseSingleClickDelay` after mouse release.
    /// Returns 2+ on double-click or repeated clicks.
    pub fn get_item_clicked_count_with_single_click_delay(
        &self,
        button: MouseButton,
        delay: Duration,
    ) -> i32 {
        unsafe { ImGui_GetItemClickedCountWithSingleClickDelay(button.bits(), delay.as_secs_f32()) }
    }
    /// Dear ImGui (`IsMouseReleasedWithDelay`): Delayed mouse release. Use sparingly. Prefer higher-level helper
    /// `get_item_clicked_count_with_single_click_delay()`.
    ///
    /// Generally used with `delay >= io.MouseDoubleClickTime` combined with a
    /// `io.MouseClickedLastCount == 1` test.
    pub fn is_mouse_released_with_delay(&self, button: MouseButton, delay: Duration) -> bool {
        unsafe { ImGui_IsMouseReleasedWithDelay(button.bits(), delay.as_secs_f32()) }
    }
    /// Dear ImGui (`IsRectVisible`): test if rectangle (of given size, starting from cursor position)
    /// is visible / not clipped.
    pub fn is_rect_visible_size(&self, size: Vector2) -> bool {
        unsafe { ImGui_IsRectVisible(&v2_to_im(size)) }
    }
    /// Dear ImGui (`IsRectVisible`): test if rectangle (in screen space) is visible / not clipped.
    /// to perform coarse clipping on user's side.
    pub fn is_rect_visible(&self, rect_min: Vector2, rect_max: Vector2) -> bool {
        unsafe { ImGui_IsRectVisible1(&v2_to_im(rect_min), &v2_to_im(rect_max)) }
    }
    /*
    pub fn is_mouse_hovering_rect(&self) -> bool {
        unsafe {
            ImGui_IsMouseHoveringRect(const ImVec2& r_min, const ImVec2& r_max, bool clip = true);
        }
    }
    pub fn is_mouse_pos_valid(&self) -> bool {
        unsafe {
            ImGui_IsMousePosValid(const ImVec2* mouse_pos = NULL);
        }
    }*/
    /// Dear ImGui (`IsAnyMouseDown`): is any mouse button held?
    ///
    /// **[WILL OBSOLETE]** This was designed for backends, but prefer having backend maintain a mask
    /// of held mouse buttons, because upcoming input queue system will make this invalid.
    pub fn is_any_mouse_down(&self) -> bool {
        unsafe { ImGui_IsAnyMouseDown() }
    }
    /// Dear ImGui (`GetMousePos`): shortcut to ImGui::GetIO().MousePos provided by user,
    /// to be consistent with other calls.
    pub fn get_mouse_pos(&self) -> Vector2 {
        unsafe { im_to_v2(ImGui_GetMousePos()) }
    }
    /// Dear ImGui (`GetMousePosOnOpeningCurrentPopup`): retrieve mouse position at the time of opening
    /// popup we have BeginPopup() into (helper to avoid user backing that value themselves).
    pub fn get_mouse_pos_on_opening_current_popup(&self) -> Vector2 {
        unsafe { im_to_v2(ImGui_GetMousePosOnOpeningCurrentPopup()) }
    }
    /// Dear ImGui (`IsMouseDragging`): is mouse dragging? (uses io.MouseDraggingThreshold if lock_threshold < 0.0f).
    pub fn is_mouse_dragging(&self, button: MouseButton) -> bool {
        unsafe {
            ImGui_IsMouseDragging(button.bits(), /*lock_threshold*/ -1.0)
        }
    }
    /// Dear ImGui (`GetMouseDragDelta`): return the delta from the initial clicking position while
    /// the mouse button is pressed or was just released. This is locked and return 0.0f until the
    /// mouse moves past a distance threshold at least once (uses io.MouseDraggingThreshold if lock_threshold < 0.0f).
    pub fn get_mouse_drag_delta(&self, button: MouseButton) -> Vector2 {
        unsafe {
            im_to_v2(ImGui_GetMouseDragDelta(
                button.bits(),
                /*lock_threshold*/ -1.0,
            ))
        }
    }
    /// Dear ImGui (`ResetMouseDragDelta`): reset mouse drag delta.
    pub fn reset_mouse_drag_delta(&self, button: MouseButton) {
        unsafe {
            ImGui_ResetMouseDragDelta(button.bits());
        }
    }
    /// Dear ImGui (`GetMouseCursor`): get desired mouse cursor shape. Important: reset in ImGui::NewFrame(),
    /// this is updated during the frame. valid before Render(). If you use software rendering by setting
    /// io.MouseDrawCursor ImGui will render those for you.
    pub fn get_mouse_cursor(&self) -> MouseCursor {
        unsafe { MouseCursor::from_bits(ImGui_GetMouseCursor()).unwrap_or(MouseCursor::None) }
    }
    /// Dear ImGui (`SetMouseCursor`): set desired mouse cursor shape.
    pub fn set_mouse_cursor(&self, cursor_type: MouseCursor) {
        unsafe {
            ImGui_SetMouseCursor(cursor_type.bits());
        }
    }
    /// Dear ImGui (`GetTime`): get global imgui time. incremented by io.DeltaTime every frame.
    pub fn get_time(&self) -> f64 {
        unsafe { ImGui_GetTime() }
    }
    /// Dear ImGui (`GetFrameCount`): get global imgui frame count. incremented by 1 every frame.
    pub fn get_frame_count(&self) -> i32 {
        unsafe { ImGui_GetFrameCount() }
    }
    /// Dear ImGui (`IsPopupOpen`): return true if the popup is open.
    pub fn is_popup_open(&self, str_id: Option<Id<impl IntoCStr>>) -> bool {
        self.is_popup_open_ex(str_id, PopupFlags::None)
    }
    /// Dear ImGui (`IsPopupOpen`): return true if the popup is open.
    pub fn is_popup_open_ex(&self, str_id: Option<Id<impl IntoCStr>>, flags: PopupFlags) -> bool {
        let temp;
        let str_id = match str_id {
            Some(s) => {
                temp = IntoCStr::into(s.0);
                temp.as_ptr()
            }
            None => null(),
        };
        unsafe { ImGui_IsPopupOpen(str_id, flags.bits()) }
    }
    /// Returns true if the current window is below a modal pop-up.
    pub fn is_below_blocking_modal(&self) -> bool {
        // Beware: internal API
        unsafe {
            let modal = ImGui_FindBlockingModal(self.CurrentWindow);
            !modal.is_null()
        }
    }
    /// Return true if there is any modal window opened
    pub fn is_blocking_modal(&self) -> bool {
        // Beware: internal API
        unsafe {
            let modal = ImGui_FindBlockingModal(std::ptr::null_mut());
            !modal.is_null()
        }
    }
    /// Dear ImGui (`OpenPopup`): Call to mark popup as open (don't call every frame!).
    ///
    /// Returns `true` when the popup was just opened.
    pub fn open_popup(&self, str_id: Id<impl IntoCStr>) -> bool {
        self.open_popup_ex(str_id, PopupFlags::None)
    }
    /// Dear ImGui (`OpenPopup`): Call to mark popup as open (don't call every frame!).
    ///
    /// Returns `true` when the popup was just opened.
    pub fn open_popup_ex(&self, str_id: Id<impl IntoCStr>, flags: PopupFlags) -> bool {
        let str_id = str_id.into();
        unsafe { ImGui_OpenPopup(str_id.as_ptr(), flags.bits()) }
    }
    /// Dear ImGui (`CloseCurrentPopup`): manually close the popup we have begin-ed into.
    pub fn close_current_popup(&self) {
        unsafe {
            ImGui_CloseCurrentPopup();
        }
    }
    /// Dear ImGui (`OpenPopupOnItemClick`): Helper to open popup when clicked on last item. Default to `ImGuiPopupFlags_MouseButtonRight` == 1.
    ///
    /// Note: actually triggers on the mouse _released_ event to be consistent with popup behaviors.
    /// Returns `true` when the popup was just opened.
    pub fn open_popup_on_item_click(
        &self,
        str_id: Option<Id<impl IntoCStr>>,
        flags: PopupFlags,
    ) -> bool {
        let temp;
        let str_id = match str_id {
            Some(s) => {
                temp = IntoCStr::into(s.0);
                temp.as_ptr()
            }
            None => null(),
        };
        unsafe { ImGui_OpenPopupOnItemClick(str_id, flags.bits()) }
    }
    pub fn is_window_appearing(&self) -> bool {
        unsafe { ImGui_IsWindowAppearing() }
    }
    /// Dear ImGui (`BeginDragDropSource`): call after submitting an item which may be dragged.
    /// when this returns true, you can call SetDragDropPayload() + EndDragDropSource().
    pub fn with_always_drag_drop_source<R>(
        &self,
        flags: DragDropSourceFlags,
        f: impl FnOnce(Option<DragDropPayloadSetter<'_>>) -> R,
    ) -> R {
        if !unsafe { ImGui_BeginDragDropSource(flags.bits()) } {
            return f(None);
        }
        let payload = DragDropPayloadSetter {
            _dummy: PhantomData,
        };
        let r = f(Some(payload));
        unsafe { ImGui_EndDragDropSource() }
        r
    }
    /// Dear ImGui (`BeginDragDropSource`): call after submitting an item which may be dragged.
    /// when this returns true, you can call SetDragDropPayload() + EndDragDropSource().
    pub fn with_drag_drop_source<R>(
        &self,
        flags: DragDropSourceFlags,
        f: impl FnOnce(DragDropPayloadSetter<'_>) -> R,
    ) -> Option<R> {
        self.with_always_drag_drop_source(flags, move |r| r.map(f))
    }
    /// Dear ImGui (`BeginDragDropTarget`): call after submitting an item that may receive a payload.
    /// If this returns true, you can call AcceptDragDropPayload() + EndDragDropTarget().
    pub fn with_always_drag_drop_target<R>(
        &self,
        f: impl FnOnce(Option<DragDropPayloadGetter<'_>>) -> R,
    ) -> R {
        if !unsafe { ImGui_BeginDragDropTarget() } {
            return f(None);
        }
        let payload = DragDropPayloadGetter {
            _dummy: PhantomData,
        };
        let r = f(Some(payload));
        unsafe { ImGui_EndDragDropTarget() }
        r
    }
    /// Dear ImGui (`BeginDragDropTarget`): call after submitting an item that may receive a payload.
    /// If this returns true, you can call AcceptDragDropPayload() + EndDragDropTarget().
    pub fn with_drag_drop_target<R>(
        &self,
        f: impl FnOnce(DragDropPayloadGetter<'_>) -> R,
    ) -> Option<R> {
        self.with_always_drag_drop_target(move |r| r.map(f))
    }

    #[must_use]
    pub fn list_clipper(&self, items_count: usize) -> ListClipper {
        ListClipper {
            items_count,
            items_height: -1.0,
            included_ranges: Vec::new(),
        }
    }

    pub fn shortcut(&self, key_chord: impl Into<KeyChord>) -> bool {
        unsafe { ImGui_Shortcut(key_chord.into().bits(), 0) }
    }
    pub fn shortcut_ex(&self, key_chord: impl Into<KeyChord>, flags: InputFlags) -> bool {
        unsafe { ImGui_Shortcut(key_chord.into().bits(), flags.bits()) }
    }
    pub fn set_next_item_shortcut(&self, key_chord: impl Into<KeyChord>) {
        unsafe {
            ImGui_SetNextItemShortcut(key_chord.into().bits(), 0);
        }
    }
    pub fn set_next_item_shortcut_ex(&self, key_chord: impl Into<KeyChord>, flags: InputFlags) {
        unsafe {
            ImGui_SetNextItemShortcut(key_chord.into().bits(), flags.bits());
        }
    }
    /// Dear ImGui (`IsKeyChordPressed`): was key chord (mods + key) pressed, e.g. you can pass
    /// 'ImGuiMod_Ctrl | ImGuiKey_S' as a key-chord. This doesn't do any routing or focus check,
    /// please consider using Shortcut() function instead.
    pub fn is_keychord_pressed(&self, key_chord: impl Into<KeyChord>) -> bool {
        unsafe { ImGui_IsKeyChordPressed(key_chord.into().bits()) }
    }

    /// Gets the font details for a `FontId`.
    pub fn get_font(&self, font_id: FontId) -> &Font {
        unsafe {
            let font = self.io().font_atlas().font_ptr(font_id);
            Font::cast(&*font)
        }
    }

    /// Gets more information about a font.
    ///
    /// This is a member of `Ui` instead of `FontAtlas` because it requires the atlas to be fully
    /// built and that is only ensured during the frame, that is when there is a `&Ui`.
    pub fn get_font_baked(
        &self,
        font_id: FontId,
        font_size: f32,
        font_density: Option<f32>,
    ) -> &FontBaked {
        unsafe {
            let font = self.io().font_atlas().font_ptr(font_id);
            let baked = (*font).GetFontBaked(font_size, font_density.unwrap_or(-1.0));
            FontBaked::cast(&*baked)
        }
    }

    pub fn get_atlas_texture_ref(&self) -> TextureRef<'_> {
        let tex_data = self.io().font_atlas().TexData;
        let tex_data = unsafe { &*tex_data };
        TextureRef::Ref(tex_data)
    }

    pub fn get_custom_rect(&self, index: CustomRectIndex) -> Option<TextureRect<'_>> {
        let atlas = self.io().font_atlas();
        let rect = unsafe {
            let mut rect = MaybeUninit::zeroed();
            let ok = atlas.GetCustomRect(index.0, rect.as_mut_ptr());
            if !ok {
                return None;
            }
            rect.assume_init()
        };

        let tex_ref = self.get_atlas_texture_ref();
        Some(TextureRect { rect, tex_ref })
    }

    pub fn dock_space(
        &self,
        id: ImGuiID,
        size: Vector2,
        flags: DockNodeFlags,
        window_class: Option<&WindowClass>,
    ) -> ImGuiID {
        unsafe {
            ImGui_DockSpace(
                id,
                &v2_to_im(size),
                flags.bits(),
                window_class
                    .as_ref()
                    .map(|e| &raw const e.0)
                    .unwrap_or_default(),
            )
        }
    }
    pub fn dock_space_over_viewport(
        &self,
        dockspace_id: ImGuiID,
        viewport: &Viewport,
        flags: DockNodeFlags,
        window_class: Option<&WindowClass>,
    ) -> ImGuiID {
        unsafe {
            ImGui_DockSpaceOverViewport(
                dockspace_id,
                viewport.get(),
                flags.bits(),
                window_class
                    .as_ref()
                    .map(|e| &raw const e.0)
                    .unwrap_or_default(),
            )
        }
    }
    /// Dear ImGui (`SetNextWindowDockID`): set next window dock id.
    pub fn set_next_window_dock_id(&self, dock_id: ImGuiID, cond: Cond) {
        unsafe {
            ImGui_SetNextWindowDockID(dock_id, cond.bits());
        }
    }
    /// Dear ImGui (`SetNextWindowClass`): set next window class (control docking compatibility +
    /// provide hints to platform backend via custom viewport flags and platform parent/child relationship).
    pub fn set_next_window_class(&self, window_class: &WindowClass) {
        unsafe {
            ImGui_SetNextWindowClass(&window_class.0);
        }
    }
    /// Dear ImGui (`GetWindowDockID`): get dock id of current window, or 0 if not associated to any docking node.
    pub fn get_window_dock_id(&self) -> ImGuiID {
        unsafe { ImGui_GetWindowDockID() }
    }
    /// Dear ImGui (`IsWindowDocked`): is current window docked into another window?
    pub fn is_window_docked(&self) -> bool {
        unsafe { ImGui_IsWindowDocked() }
    }

    /// This allows to build your own docking, and dock your windows.
    ///
    /// WARNING: Experimental DearImGui feature and experimental binding.
    ///
    /// You must follow these rules:
    /// * Call this function when you want to dock your windows, usually in the very first frame.
    ///   or in the "reset views" menu option. Do NOT call it on every frame!
    /// * Call after creating the dockings but before creating the windows.
    pub fn dock_builder(
        &self,
        id: Option<ImGuiID>,
        flags: DockNodeFlags,
        fn_build: impl FnOnce(ImGuiID, &mut DockBuilder),
    ) {
        struct DockBuilderFinishGuard(ImGuiID);
        impl Drop for DockBuilderFinishGuard {
            fn drop(&mut self) {
                unsafe {
                    ImGui_DockBuilderFinish(self.0);
                }
            }
        }

        unsafe {
            let id = ImGui_DockBuilderAddNode(id.unwrap_or(0), flags.bits());
            let _guard = DockBuilderFinishGuard(id);
            let mut db = DockBuilder { _dummy: () };
            fn_build(id, &mut db);
        }
    }

    /// Dear ImGui (`GetWindowViewport`): get viewport currently associated to the current window.
    pub fn get_window_viewport(&self) -> &Viewport {
        unsafe { Viewport::cast(&*ImGui_GetWindowViewport()) }
    }
    /// Dear ImGui (`SetNextWindowViewport`): set next window viewport.
    pub fn set_next_window_viewport(&self, id: ImGuiID) {
        unsafe { ImGui_SetNextWindowViewport(id) }
    }
    /// Dear ImGui (`GetForegroundDrawList`): get foreground draw list for the given viewport.
    /// this draw list will be the top-most rendered one. Useful to quickly draw shapes/text over dear imgui contents.
    pub fn viewport_foreground_draw_list(&self, viewport: &Viewport) -> WindowDrawList<'_, A> {
        unsafe {
            let ptr = ImGui_GetForegroundDrawList((&raw const *viewport.get()).cast_mut());
            WindowDrawList { ui: self, ptr }
        }
    }
    /// Dear ImGui (`GetBackgroundDrawList`): get background draw list for the given viewport.
    /// this draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents.
    pub fn viewport_background_draw_list(&self, viewport: &Viewport) -> WindowDrawList<'_, A> {
        unsafe {
            let ptr = ImGui_GetBackgroundDrawList((&raw const *viewport.get()).cast_mut());
            WindowDrawList { ui: self, ptr }
        }
    }
}

#[derive(Debug, Copy, Clone)]
pub struct TextureRect<'ui> {
    pub rect: ImFontAtlasRect,
    pub tex_ref: TextureRef<'ui>,
}

pub struct ListClipper {
    items_count: usize,
    items_height: f32,
    included_ranges: Vec<std::ops::Range<usize>>,
}

impl ListClipper {
    decl_builder_setter! {items_height: f32}

    pub fn add_included_range(&mut self, range: std::ops::Range<usize>) {
        self.included_ranges.push(range);
    }

    pub fn with(self, mut f: impl FnMut(usize)) {
        unsafe {
            let mut clip = ImGuiListClipper::new();
            clip.Begin(self.items_count as i32, self.items_height);
            for r in self.included_ranges {
                clip.IncludeItemsByIndex(r.start as i32, r.end as i32);
            }
            while clip.Step() {
                for i in clip.DisplayStart..clip.DisplayEnd {
                    f(i as usize);
                }
            }
        }
    }
}

transparent! {
    // TODO: do a proper impl Font?
    pub struct Font(ImFont);
}

transparent! {
    pub struct FontGlyph(ImFontGlyph);
}

impl FontGlyph {
    pub fn p0(&self) -> Vector2 {
        Vector2::new(self.0.X0, self.0.Y0)
    }
    pub fn p1(&self) -> Vector2 {
        Vector2::new(self.0.X1, self.0.Y1)
    }
    pub fn uv0(&self) -> Vector2 {
        Vector2::new(self.0.U0, self.0.V0)
    }
    pub fn uv1(&self) -> Vector2 {
        Vector2::new(self.0.U1, self.0.V1)
    }
    pub fn advance_x(&self) -> f32 {
        self.0.AdvanceX
    }
    pub fn visible(&self) -> bool {
        self.0.Visible() != 0
    }
    pub fn colored(&self) -> bool {
        self.0.Colored() != 0
    }
    pub fn codepoint(&self) -> char {
        char::try_from(self.0.Codepoint()).unwrap()
    }
}

impl std::fmt::Debug for FontGlyph {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        fmt.debug_struct("FontGlyph")
            .field("p0", &self.p0())
            .field("p1", &self.p1())
            .field("uv0", &self.uv0())
            .field("uv1", &self.uv1())
            .field("advance_x", &self.advance_x())
            .field("visible", &self.visible())
            .field("colored", &self.colored())
            .field("codepoint", &self.codepoint())
            .finish()
    }
}

transparent! {
    #[derive(Debug)]
    pub struct FontBaked(ImFontBaked);
}

impl FontBaked {
    /// Gets information about a glyph for a font.
    pub fn find_glyph(&self, c: char) -> &FontGlyph {
        unsafe {
            FontGlyph::cast(&*ImFontBaked_FindGlyph(
                (&raw const self.0).cast_mut(),
                ImWchar::from(c),
            ))
        }
    }

    /// Just like `find_glyph` but doesn't use the fallback character for unavailable glyphs.
    pub fn find_glyph_no_fallback(&self, c: char) -> Option<&FontGlyph> {
        unsafe {
            let p =
                ImFontBaked_FindGlyphNoFallback((&raw const self.0).cast_mut(), ImWchar::from(c));
            p.as_ref().map(FontGlyph::cast)
        }
    }

    pub unsafe fn inner(&mut self) -> &mut ImFontBaked {
        &mut self.0
    }

    // The only safe values for a loader to set are these
    pub fn set_ascent(&mut self, ascent: f32) {
        self.0.Ascent = ascent;
    }
    pub fn set_descent(&mut self, descent: f32) {
        self.0.Descent = descent;
    }
}

/// Identifier of a registered font.
///
/// `FontId::default()` will be the default font.
#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct FontId(u32);

/// Identifier for a registered custom rectangle.
///
/// The `CustomRectIndex::default()` is provided as a convenience, but it is always invalid, and
/// will panic if used.
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CustomRectIndex(i32);

impl Default for CustomRectIndex {
    fn default() -> Self {
        // Always invalid, do not use!
        CustomRectIndex(-1)
    }
}

transparent! {
    #[derive(Debug)]
    pub struct FontAtlas(ImFontAtlas);
}

type PixelImage<'a> = image::ImageBuffer<image::Rgba<u8>, &'a mut [u8]>;
type SubPixelImage<'a, 'b> = image::SubImage<&'a mut PixelImage<'b>>;

impl FontAtlas {
    pub unsafe fn texture_ref(&self) -> ImTextureRef {
        self.TexRef
    }
    pub unsafe fn inner(&mut self) -> &mut ImFontAtlas {
        &mut self.0
    }

    pub fn current_texture_unique_id(&self) -> TextureUniqueId {
        unsafe {
            let id = (*self.TexRef._TexData).UniqueID;
            TextureUniqueId(id)
        }
    }

    fn texture_unique_id(&self, uid: TextureUniqueId) -> Option<&ImTextureData> {
        unsafe {
            self.TexList
                .iter()
                .find(|x| (***x).UniqueID == uid.0)
                .map(|p| &**p)
        }
    }

    unsafe fn font_ptr(&self, font: FontId) -> *mut ImFont {
        unsafe {
            // fonts.Fonts is never empty, at least there is the default font
            *self
                .Fonts
                .iter()
                .find(|f| f.as_ref().map(|f| f.FontId) == Some(font.0))
                .unwrap_or(&self.Fonts[0])
        }
    }

    pub fn check_texture_unique_id(&self, uid: TextureUniqueId) -> bool {
        self.texture_unique_id(uid).is_some_and(|x| {
            !matches!(
                x.Status,
                ImTextureStatus::ImTextureStatus_WantDestroy
                    | ImTextureStatus::ImTextureStatus_Destroyed
            )
        })
    }

    pub fn get_texture_by_unique_id(&self, uid: TextureUniqueId) -> Option<TextureId> {
        let p = self.texture_unique_id(uid)?;
        // Allows for ImTextureStatus_WantDestroy, because the TexID may still be valid
        if p.Status == ImTextureStatus::ImTextureStatus_Destroyed || p.TexID == 0 {
            None
        } else {
            unsafe { Some(TextureId::from_id(p.TexID)) }
        }
    }

    /// Adds the given font to the atlas.
    ///
    /// It returns the id to use this font. `FontId` implements `Pushable` so you can use it with
    /// [`Ui::with_push`].
    pub fn add_font(&mut self, font: FontInfo) -> FontId {
        self.add_font_priv(font, false)
    }

    pub fn remove_font(&mut self, font_id: FontId) {
        unsafe {
            let f = self.font_ptr(font_id);
            // Do not delete the default font!
            /*if std::ptr::eq(f, self.Fonts[0]) {
                return;
            }*/
            self.0.RemoveFont(f);
        }
    }

    /// Adds several fonts with as a single ImGui font.
    ///
    /// This is useful mainly if different TTF files have different charset coverage but you want
    /// to use them all as a unit.
    pub fn add_font_collection(&mut self, fonts: impl IntoIterator<Item = FontInfo>) -> FontId {
        let mut fonts = fonts.into_iter();
        let first = fonts.next().expect("empty font collection");
        let id = self.add_font_priv(first, false);
        for font in fonts {
            self.add_font_priv(font, true);
        }
        id
    }
    fn add_font_priv(&mut self, font: FontInfo, merge: bool) -> FontId {
        unsafe {
            let mut fc = ImFontConfig::new();
            // This is ours, do not free()
            fc.FontDataOwnedByAtlas = false;
            fc.MergeMode = merge;
            if !font.name.is_empty() {
                let cname = font.name.as_bytes();
                let name_len = cname.len().min(fc.Name.len() - 1);
                fc.Name[..name_len]
                    .copy_from_slice(std::mem::transmute::<&[u8], &[c_char]>(&cname[..name_len]));
                fc.Name[name_len] = 0;
            }
            fc.Flags = font.flags.bits();
            fc.SizePixels = font.size;

            let font_ptr = match font.ttf {
                TtfData::Bytes(bytes) => {
                    self.0.AddFontFromMemoryTTF(
                        bytes.as_ptr() as *mut _,
                        bytes.len() as i32,
                        /* size_pixels */ 0.0,
                        &fc,
                        std::ptr::null(),
                    )
                }
                TtfData::DefaultFont(DefaultFontSelector::Auto) => self.0.AddFontDefault(&fc),
                TtfData::DefaultFont(DefaultFontSelector::Bitmap) => {
                    self.0.AddFontDefaultBitmap(&fc)
                }
                TtfData::DefaultFont(DefaultFontSelector::Vector) => {
                    self.0.AddFontDefaultVector(&fc)
                }
                TtfData::CustomLoader(glyph_loader) => {
                    let ptr = Box::into_raw(Box::new(glyph_loader));
                    fc.FontLoader = &fontloader::FONT_LOADER.0;
                    fc.FontData = ptr as *mut c_void;
                    fc.FontDataOwnedByAtlas = true;
                    self.0.AddFont(&fc)
                }
            };
            let Some(font) = font_ptr.as_ref() else {
                log::error!("Error loading font!");
                return FontId::default();
            };
            FontId(font.FontId)
        }
    }

    /// Adds an arbitrary image to the font atlas.
    ///
    /// The returned `CustomRectIndex` can be used later to draw the image.
    pub fn add_custom_rect(
        &mut self,
        size: impl Into<mint::Vector2<u32>>,
        draw: impl FnOnce(&mut SubPixelImage<'_, '_>),
    ) -> CustomRectIndex {
        let size = size.into();
        unsafe {
            let mut rect = MaybeUninit::zeroed();
            let idx = self.0.AddCustomRect(
                i32::try_from(size.x).unwrap(),
                i32::try_from(size.y).unwrap(),
                rect.as_mut_ptr(),
            );
            let idx = CustomRectIndex(idx);
            let rect = rect.assume_init();
            let tex_data = &(*self.TexData);

            let mut pixel_image = PixelImage::from_raw(
                tex_data.Width as u32,
                tex_data.Height as u32,
                std::slice::from_raw_parts_mut(
                    tex_data.Pixels,
                    tex_data.Width as usize
                        * tex_data.Height as usize
                        * tex_data.BytesPerPixel as usize,
                ),
            )
            .unwrap();

            let mut sub_image =
                pixel_image.sub_image(rect.x as u32, rect.y as u32, rect.w as u32, rect.h as u32);
            draw(&mut sub_image);

            idx
        }
    }

    pub fn remove_custom_rect(&mut self, idx: CustomRectIndex) {
        if idx.0 < 0 {
            return;
        }
        unsafe {
            self.0.RemoveCustomRect(idx.0);
        }
    }
}

transparent_mut! {
    #[derive(Debug)]
    pub struct Io(ImGuiIO);
}

transparent! {
    /// Safe wrapper for `&mut Io`.
    ///
    /// Notably it doesn't implement DerefMut
    #[derive(Debug)]
    pub struct IoMut(ImGuiIO);
}

impl Io {
    pub fn font_atlas(&self) -> &FontAtlas {
        unsafe { FontAtlas::cast(&*self.Fonts) }
    }

    pub fn want_capture_mouse(&self) -> bool {
        self.WantCaptureMouse
    }
    pub fn want_capture_keyboard(&self) -> bool {
        self.WantCaptureKeyboard
    }
    pub fn want_text_input(&self) -> bool {
        self.WantTextInput
    }
    pub fn display_size(&self) -> Vector2 {
        im_to_v2(self.DisplaySize)
    }
    pub fn display_scale(&self) -> f32 {
        self.DisplayFramebufferScale.x
    }

    /// Dear ImGui (`io.ConfigColorEditFlags`): Current settings for ColorEdit/ColorPicker widgets.
    pub fn config_color_edit_flags(&self) -> ColorEditFlags {
        ColorEditFlags::from_bits_truncate(self.ConfigColorEditFlags)
    }
    /// Dear ImGui (`io.MouseSingleClickDelay`): Time for a delayed click when using
    /// `get_item_clicked_count_with_single_click_delay()` or `is_mouse_released_with_delay()`, in
    /// seconds. Must be > `io.MouseDoubleClickTime`.
    pub fn mouse_single_click_delay(&self) -> Duration {
        Duration::from_secs_f32(self.MouseSingleClickDelay)
    }
    /// Dear ImGui (`io.ConfigIniSettingsSaveLastUsedDate`): Enable loading/saving last used day
    /// (YYYYMMDD) in some .ini struct, making things easier to audit and allowing custom tools to
    /// cleanup old data.
    pub fn config_ini_settings_save_last_used_date(&self) -> bool {
        self.ConfigIniSettingsSaveLastUsedDate
    }
    /// Dear ImGui (`io.ConfigIniSettingsAutoDiscardMonths`): [BETA] Set number of months after
    /// which unused .ini entries are discarded on load. Require
    /// `PlatformIo::Platform_SessionDate` to be set.
    pub fn config_ini_settings_auto_discard_months(&self) -> i32 {
        self.ConfigIniSettingsAutoDiscardMonths
    }

    // The following are not unsafe because if you have a `&mut Io` you alreay can do anything.
    pub fn add_config_flags(&mut self, flags: ConfigFlags) {
        self.ConfigFlags |= flags.bits();
    }
    pub fn remove_config_flags(&mut self, flags: ConfigFlags) {
        self.ConfigFlags &= !flags.bits();
    }
    pub fn add_backend_flags(&mut self, flags: BackendFlags) {
        self.BackendFlags |= flags.bits();
    }
    pub fn remove_backend_flags(&mut self, flags: BackendFlags) {
        self.BackendFlags &= !flags.bits();
    }
    pub fn delta_time(&mut self) -> Duration {
        Duration::from_secs_f32(self.DeltaTime)
    }
    pub fn set_delta_time(&mut self, d: Duration) {
        self.DeltaTime = d.as_secs_f32()
    }
}

impl IoMut {
    pub unsafe fn inner(&mut self) -> &mut Io {
        Io::cast_mut(&mut self.0)
    }
    pub fn set_allow_user_scaling(&mut self, val: bool) {
        self.0.FontAllowUserScaling = val;
    }
    pub fn nav_enable_keyboard(&mut self, enable: bool) {
        unsafe {
            if enable {
                self.inner()
                    .add_config_flags(ConfigFlags::NavEnableKeyboard);
            } else {
                self.inner()
                    .remove_config_flags(ConfigFlags::NavEnableKeyboard);
            }
        }
    }
    pub fn nav_enable_gamepad(&mut self, enable: bool) {
        unsafe {
            if enable {
                self.inner().add_config_flags(ConfigFlags::NavEnableGamepad);
            } else {
                self.inner()
                    .remove_config_flags(ConfigFlags::NavEnableGamepad);
            }
        }
    }
    /// Enables the docking feature.
    pub fn enable_docking(&mut self, enable: bool) {
        unsafe {
            if enable {
                self.inner().add_config_flags(ConfigFlags::DockingEnable);
            } else {
                self.inner().remove_config_flags(ConfigFlags::DockingEnable);
            }
        }
    }
    /// Enables the viewport feature.
    ///
    /// Note that this will only work if your used backend supports viewports, which easy-imgui-window does not.
    pub fn enable_viewports(&mut self, enable: bool) {
        unsafe {
            if enable {
                self.inner().add_config_flags(ConfigFlags::ViewportsEnable);
            } else {
                self.inner()
                    .remove_config_flags(ConfigFlags::ViewportsEnable);
            }
        }
    }
    pub fn font_atlas_mut(&mut self) -> &mut FontAtlas {
        unsafe { FontAtlas::cast_mut(&mut *self.Fonts) }
    }
    /// Dear ImGui (`io.ConfigColorEditFlags`): Set current options for ColorEdit/ColorPicker widgets.
    pub fn set_config_color_edit_flags(&mut self, flags: ColorEditFlags) {
        self.0.ConfigColorEditFlags = flags.bits();
    }
    /// Dear ImGui (`io.MouseSingleClickDelay`): Set the delayed single click time, in seconds.
    /// Must be > `io.MouseDoubleClickTime`.
    pub fn set_mouse_single_click_delay(&mut self, delay: Duration) {
        self.0.MouseSingleClickDelay = delay.as_secs_f32();
    }
    /// Dear ImGui (`io.ConfigIniSettingsSaveLastUsedDate`): Enable loading/saving last used day in .ini settings.
    pub fn set_config_ini_settings_save_last_used_date(&mut self, save: bool) {
        self.0.ConfigIniSettingsSaveLastUsedDate = save;
    }
    /// Dear ImGui (`io.ConfigIniSettingsAutoDiscardMonths`): [BETA] Set number of months after which unused .ini entries are discarded on load.
    pub fn set_config_ini_settings_auto_discard_months(&mut self, months: i32) {
        self.0.ConfigIniSettingsAutoDiscardMonths = months;
    }
}

transparent_mut! {
    #[derive(Debug)]
    pub struct PlatformIo(ImGuiPlatformIO);
}

impl PlatformIo {
    pub unsafe fn textures_mut(&mut self) -> impl Iterator<Item = &mut ImTextureData> {
        self.Textures.iter_mut().map(|t| unsafe { &mut **t })
    }
}

#[derive(Debug)]
pub struct SizeCallbackData<'a> {
    ptr: &'a mut ImGuiSizeCallbackData,
}

impl SizeCallbackData<'_> {
    pub fn pos(&self) -> Vector2 {
        im_to_v2(self.ptr.Pos)
    }
    pub fn current_size(&self) -> Vector2 {
        im_to_v2(self.ptr.CurrentSize)
    }
    pub fn desired_size(&self) -> Vector2 {
        im_to_v2(self.ptr.DesiredSize)
    }
    pub fn set_desired_size(&mut self, sz: Vector2) {
        self.ptr.DesiredSize = v2_to_im(sz);
    }
}

unsafe extern "C" fn call_size_callback<A>(ptr: *mut ImGuiSizeCallbackData) {
    unsafe {
        let ptr = &mut *ptr;
        let id = ptr.UserData as usize;
        let data = SizeCallbackData { ptr };
        Ui::<A>::run_callback(id, data);
    }
}

pub struct WindowDrawList<'ui, A> {
    ui: &'ui Ui<A>,
    ptr: *mut ImDrawList,
}

impl<A> WindowDrawList<'_, A> {
    pub fn add_line(&self, p1: Vector2, p2: Vector2, color: Color, thickness: f32) {
        unsafe {
            ImDrawList_AddLine(
                self.ptr,
                &v2_to_im(p1),
                &v2_to_im(p2),
                color.as_u32(),
                thickness,
            );
        }
    }
    pub fn add_line_h(&self, min_x: f32, max_x: f32, y: f32, color: Color, thickness: f32) {
        unsafe {
            ImDrawList_AddLineH(self.ptr, min_x, max_x, y, color.as_u32(), thickness);
        }
    }
    pub fn add_line_v(&self, x: f32, min_y: f32, max_y: f32, color: Color, thickness: f32) {
        unsafe {
            ImDrawList_AddLineV(self.ptr, x, min_y, max_y, color.as_u32(), thickness);
        }
    }
    /// Dear ImGui (`AddRect`): p_min: upper-left, p_max: lower-right (== upper-left + size).
    pub fn add_rect(
        &self,
        p_min: Vector2,
        p_max: Vector2,
        color: Color,
        rounding: f32,
        thickness: f32,
        flags: DrawFlags,
    ) {
        unsafe {
            ImDrawList_AddRect(
                self.ptr,
                &v2_to_im(p_min),
                &v2_to_im(p_max),
                color.as_u32(),
                rounding,
                thickness,
                flags.bits(),
            );
        }
    }
    /// Dear ImGui (`AddRectFilled`): p_min: upper-left, p_max: lower-right (== upper-left + size).
    pub fn add_rect_filled(
        &self,
        p_min: Vector2,
        p_max: Vector2,
        color: Color,
        rounding: f32,
        flags: DrawFlags,
    ) {
        unsafe {
            ImDrawList_AddRectFilled(
                self.ptr,
                &v2_to_im(p_min),
                &v2_to_im(p_max),
                color.as_u32(),
                rounding,
                flags.bits(),
            );
        }
    }
    pub fn add_rect_filled_multicolor(
        &self,
        p_min: Vector2,
        p_max: Vector2,
        col_upr_left: Color,
        col_upr_right: Color,
        col_bot_right: Color,
        col_bot_left: Color,
    ) {
        unsafe {
            ImDrawList_AddRectFilledMultiColor(
                self.ptr,
                &v2_to_im(p_min),
                &v2_to_im(p_max),
                col_upr_left.as_u32(),
                col_upr_right.as_u32(),
                col_bot_right.as_u32(),
                col_bot_left.as_u32(),
            );
        }
    }
    pub fn add_quad(
        &self,
        p1: Vector2,
        p2: Vector2,
        p3: Vector2,
        p4: Vector2,
        color: Color,
        thickness: f32,
    ) {
        unsafe {
            ImDrawList_AddQuad(
                self.ptr,
                &v2_to_im(p1),
                &v2_to_im(p2),
                &v2_to_im(p3),
                &v2_to_im(p4),
                color.as_u32(),
                thickness,
            );
        }
    }
    pub fn add_quad_filled(
        &self,
        p1: Vector2,
        p2: Vector2,
        p3: Vector2,
        p4: Vector2,
        color: Color,
    ) {
        unsafe {
            ImDrawList_AddQuadFilled(
                self.ptr,
                &v2_to_im(p1),
                &v2_to_im(p2),
                &v2_to_im(p3),
                &v2_to_im(p4),
                color.as_u32(),
            );
        }
    }
    pub fn add_triangle(
        &self,
        p1: Vector2,
        p2: Vector2,
        p3: Vector2,
        color: Color,
        thickness: f32,
    ) {
        unsafe {
            ImDrawList_AddTriangle(
                self.ptr,
                &v2_to_im(p1),
                &v2_to_im(p2),
                &v2_to_im(p3),
                color.as_u32(),
                thickness,
            );
        }
    }
    pub fn add_triangle_filled(&self, p1: Vector2, p2: Vector2, p3: Vector2, color: Color) {
        unsafe {
            ImDrawList_AddTriangleFilled(
                self.ptr,
                &v2_to_im(p1),
                &v2_to_im(p2),
                &v2_to_im(p3),
                color.as_u32(),
            );
        }
    }
    pub fn add_circle(
        &self,
        center: Vector2,
        radius: f32,
        color: Color,
        num_segments: i32,
        thickness: f32,
    ) {
        unsafe {
            ImDrawList_AddCircle(
                self.ptr,
                &v2_to_im(center),
                radius,
                color.as_u32(),
                num_segments,
                thickness,
            );
        }
    }
    pub fn add_circle_filled(&self, center: Vector2, radius: f32, color: Color, num_segments: i32) {
        unsafe {
            ImDrawList_AddCircleFilled(
                self.ptr,
                &v2_to_im(center),
                radius,
                color.as_u32(),
                num_segments,
            );
        }
    }
    pub fn add_ngon(
        &self,
        center: Vector2,
        radius: f32,
        color: Color,
        num_segments: i32,
        thickness: f32,
    ) {
        unsafe {
            ImDrawList_AddNgon(
                self.ptr,
                &v2_to_im(center),
                radius,
                color.as_u32(),
                num_segments,
                thickness,
            );
        }
    }
    pub fn add_ngon_filled(&self, center: Vector2, radius: f32, color: Color, num_segments: i32) {
        unsafe {
            ImDrawList_AddNgonFilled(
                self.ptr,
                &v2_to_im(center),
                radius,
                color.as_u32(),
                num_segments,
            );
        }
    }
    pub fn add_ellipse(
        &self,
        center: Vector2,
        radius: Vector2,
        color: Color,
        rot: f32,
        num_segments: i32,
        thickness: f32,
    ) {
        unsafe {
            ImDrawList_AddEllipse(
                self.ptr,
                &v2_to_im(center),
                &v2_to_im(radius),
                color.as_u32(),
                rot,
                num_segments,
                thickness,
            );
        }
    }
    pub fn add_ellipse_filled(
        &self,
        center: Vector2,
        radius: Vector2,
        color: Color,
        rot: f32,
        num_segments: i32,
    ) {
        unsafe {
            ImDrawList_AddEllipseFilled(
                self.ptr,
                &v2_to_im(center),
                &v2_to_im(radius),
                color.as_u32(),
                rot,
                num_segments,
            );
        }
    }
    pub fn add_text(&self, pos: Vector2, color: Color, text: &str) {
        unsafe {
            let (start, end) = text_ptrs(text);
            ImDrawList_AddText(self.ptr, &v2_to_im(pos), color.as_u32(), start, end);
        }
    }
    pub fn add_text_ex(
        &self,
        font: FontId,
        font_size: f32,
        pos: Vector2,
        color: Color,
        text: &str,
        wrap_width: f32,
        cpu_fine_clip_rect: Option<ImVec4>,
    ) {
        unsafe {
            let (start, end) = text_ptrs(text);
            ImDrawList_AddText1(
                self.ptr,
                self.ui.io().font_atlas().font_ptr(font),
                font_size,
                &v2_to_im(pos),
                color.as_u32(),
                start,
                end,
                wrap_width,
                cpu_fine_clip_rect
                    .as_ref()
                    .map(|x| x as *const _)
                    .unwrap_or(null()),
            );
        }
    }
    pub fn add_polyline(&self, points: &[ImVec2], color: Color, thickness: f32, flags: DrawFlags) {
        unsafe {
            ImDrawList_AddPolyline(
                self.ptr,
                points.as_ptr(),
                points.len() as i32,
                color.as_u32(),
                thickness,
                flags.bits(),
            );
        }
    }
    pub fn add_convex_poly_filled(&self, points: &[ImVec2], color: Color) {
        unsafe {
            ImDrawList_AddConvexPolyFilled(
                self.ptr,
                points.as_ptr(),
                points.len() as i32,
                color.as_u32(),
            );
        }
    }
    pub fn add_concave_poly_filled(&self, points: &[ImVec2], color: Color) {
        unsafe {
            ImDrawList_AddConcavePolyFilled(
                self.ptr,
                points.as_ptr(),
                points.len() as i32,
                color.as_u32(),
            );
        }
    }
    /// Dear ImGui (`AddBezierCubic`): Cubic Bezier (4 control points).
    pub fn add_bezier_cubic(
        &self,
        p1: Vector2,
        p2: Vector2,
        p3: Vector2,
        p4: Vector2,
        color: Color,
        thickness: f32,
        num_segments: i32,
    ) {
        unsafe {
            ImDrawList_AddBezierCubic(
                self.ptr,
                &v2_to_im(p1),
                &v2_to_im(p2),
                &v2_to_im(p3),
                &v2_to_im(p4),
                color.as_u32(),
                thickness,
                num_segments,
            );
        }
    }
    /// Dear ImGui (`AddBezierQuadratic`): Quadratic Bezier (3 control points).
    pub fn add_bezier_quadratic(
        &self,
        p1: Vector2,
        p2: Vector2,
        p3: Vector2,
        color: Color,
        thickness: f32,
        num_segments: i32,
    ) {
        unsafe {
            ImDrawList_AddBezierQuadratic(
                self.ptr,
                &v2_to_im(p1),
                &v2_to_im(p2),
                &v2_to_im(p3),
                color.as_u32(),
                thickness,
                num_segments,
            );
        }
    }
    pub fn add_image(
        &self,
        texture_ref: TextureRef,
        p_min: Vector2,
        p_max: Vector2,
        uv_min: Vector2,
        uv_max: Vector2,
        color: Color,
    ) {
        unsafe {
            ImDrawList_AddImage(
                self.ptr,
                texture_ref.tex_ref(),
                &v2_to_im(p_min),
                &v2_to_im(p_max),
                &v2_to_im(uv_min),
                &v2_to_im(uv_max),
                color.as_u32(),
            );
        }
    }
    pub fn add_image_quad(
        &self,
        texture_ref: TextureRef,
        p1: Vector2,
        p2: Vector2,
        p3: Vector2,
        p4: Vector2,
        uv1: Vector2,
        uv2: Vector2,
        uv3: Vector2,
        uv4: Vector2,
        color: Color,
    ) {
        unsafe {
            ImDrawList_AddImageQuad(
                self.ptr,
                texture_ref.tex_ref(),
                &v2_to_im(p1),
                &v2_to_im(p2),
                &v2_to_im(p3),
                &v2_to_im(p4),
                &v2_to_im(uv1),
                &v2_to_im(uv2),
                &v2_to_im(uv3),
                &v2_to_im(uv4),
                color.as_u32(),
            );
        }
    }
    pub fn add_image_rounded(
        &self,
        texture_ref: TextureRef,
        p_min: Vector2,
        p_max: Vector2,
        uv_min: Vector2,
        uv_max: Vector2,
        color: Color,
        rounding: f32,
        flags: DrawFlags,
    ) {
        unsafe {
            ImDrawList_AddImageRounded(
                self.ptr,
                texture_ref.tex_ref(),
                &v2_to_im(p_min),
                &v2_to_im(p_max),
                &v2_to_im(uv_min),
                &v2_to_im(uv_max),
                color.as_u32(),
                rounding,
                flags.bits(),
            );
        }
    }

    // Warning! Some path function are inline, reimplemented here.
    pub fn path_clear(&self) {
        unsafe {
            let path = &mut (&mut *self.ptr)._Path;
            path.Size = 0;
        }
    }
    pub fn path_line_to(&self, v: Vector2) {
        unsafe {
            let path = &mut (&mut *self.ptr)._Path;
            ImGui_ImVector_vec2_push_back(path, &v2_to_im(v));
        }
    }
    pub fn path_line_to_merge_duplicate(&self, v: Vector2) {
        unsafe {
            let path = &mut (&mut *self.ptr)._Path;
            if path.last().is_none_or(|d| d.x != v.x || d.y != v.y) {
                ImGui_ImVector_vec2_push_back(path, &v2_to_im(v));
            }
        }
    }
    pub fn path_fill_convex(&self, color: Color) {
        unsafe {
            let path = &mut (&mut *self.ptr)._Path;
            ImDrawList_AddConvexPolyFilled(self.ptr, path.Data, path.Size, color.as_u32());
            path.Size = 0;
        }
    }
    pub fn path_fill_concave(&self, color: Color) {
        unsafe {
            let path = &mut (&mut *self.ptr)._Path;
            ImDrawList_AddConcavePolyFilled(self.ptr, path.Data, path.Size, color.as_u32());
            path.Size = 0;
        }
    }
    pub fn path_stroke(&self, color: Color, thickness: f32, flags: DrawFlags) {
        unsafe {
            let path = &mut (&mut *self.ptr)._Path;
            ImDrawList_AddPolyline(
                self.ptr,
                path.Data,
                path.Size,
                color.as_u32(),
                thickness,
                flags.bits(),
            );
            path.Size = 0;
        }
    }
    pub fn path_arc_to(
        &self,
        center: Vector2,
        radius: f32,
        a_min: f32,
        a_max: f32,
        num_segments: i32,
    ) {
        unsafe {
            ImDrawList_PathArcTo(
                self.ptr,
                &v2_to_im(center),
                radius,
                a_min,
                a_max,
                num_segments,
            );
        }
    }
    /// Dear ImGui (`PathArcToFast`): use precomputed angles for a 12 steps circle.
    pub fn path_arc_to_fast(
        &self,
        center: Vector2,
        radius: f32,
        a_min_of_12: i32,
        a_max_of_12: i32,
    ) {
        unsafe {
            ImDrawList_PathArcToFast(
                self.ptr,
                &v2_to_im(center),
                radius,
                a_min_of_12,
                a_max_of_12,
            );
        }
    }
    /// Dear ImGui (`PathEllipticalArcTo`): elliptical arc.
    pub fn path_elliptical_arc_to(
        &self,
        center: Vector2,
        radius: Vector2,
        rot: f32,
        a_min: f32,
        a_max: f32,
        num_segments: i32,
    ) {
        unsafe {
            ImDrawList_PathEllipticalArcTo(
                self.ptr,
                &v2_to_im(center),
                &v2_to_im(radius),
                rot,
                a_min,
                a_max,
                num_segments,
            );
        }
    }
    pub fn path_bezier_cubic_curve_to(
        &self,
        p2: Vector2,
        p3: Vector2,
        p4: Vector2,
        num_segments: i32,
    ) {
        unsafe {
            ImDrawList_PathBezierCubicCurveTo(
                self.ptr,
                &v2_to_im(p2),
                &v2_to_im(p3),
                &v2_to_im(p4),
                num_segments,
            );
        }
    }
    pub fn path_bezier_quadratic_curve_to(&self, p2: Vector2, p3: Vector2, num_segments: i32) {
        unsafe {
            ImDrawList_PathBezierQuadraticCurveTo(
                self.ptr,
                &v2_to_im(p2),
                &v2_to_im(p3),
                num_segments,
            );
        }
    }
    pub fn path_rect(&self, rect_min: Vector2, rect_max: Vector2, rounding: f32, flags: DrawFlags) {
        unsafe {
            ImDrawList_PathRect(
                self.ptr,
                &v2_to_im(rect_min),
                &v2_to_im(rect_max),
                rounding,
                flags.bits(),
            );
        }
    }

    pub fn add_callback(&self, cb: impl FnOnce(&mut A) + 'static) {
        // Callbacks are only called once, convert the FnOnce into an FnMut to register
        // They are called after `do_ui` so first argument pointer is valid.
        // The second argument is not used, set to `()``.
        let mut cb = Some(cb);
        unsafe {
            let id = self.ui.push_callback(move |a, _: ()| {
                if let Some(cb) = cb.take() {
                    cb(&mut *a);
                }
            });
            ImDrawList_AddCallback(
                self.ptr,
                Some(call_drawlist_callback::<A>),
                id as *mut c_void,
                0,
            );
        }
    }
    /// Dear ImGui (`AddDrawCmd`): this is useful if you need to forcefully create a new draw call
    /// (to allow for dependent rendering / blending). Otherwise primitives are merged into the same
    /// draw-call as much as possible.
    pub fn add_draw_cmd(&self) {
        unsafe {
            ImDrawList_AddDrawCmd(self.ptr);
        }
    }
}

unsafe extern "C" fn call_drawlist_callback<A>(
    _parent_list: *const ImDrawList,
    cmd: *const ImDrawCmd,
) {
    unsafe {
        let id = (*cmd).UserCallbackData as usize;
        Ui::<A>::run_callback(id, ());
    }
}

/// Represents any type that can be converted to a Dear ImGui hash id.
pub trait Hashable {
    // These are unsafe because they should be called only inside a frame (holding a &mut Ui)
    unsafe fn get_id(&self) -> ImGuiID;
    unsafe fn push(&self);
}

impl Hashable for &str {
    unsafe fn get_id(&self) -> ImGuiID {
        unsafe {
            let (start, end) = text_ptrs(self);
            ImGui_GetID1(start, end)
        }
    }
    unsafe fn push(&self) {
        unsafe {
            let (start, end) = text_ptrs(self);
            ImGui_PushID1(start, end);
        }
    }
}

impl Hashable for usize {
    unsafe fn get_id(&self) -> ImGuiID {
        unsafe { ImGui_GetID2(*self as *const c_void) }
    }
    unsafe fn push(&self) {
        unsafe {
            ImGui_PushID2(*self as *const c_void);
        }
    }
}

/// Any value that can be applied with a _push_ function and unapplied with a _pop_ function.
///
/// Apply to the current frame using [`Ui::with_push`]. If you want to apply several values at the
/// same time use a tuple or an array.
/// Only tuples up to 4 values are supported, but you can apply arbitrarily many pushables by
/// creating tuples of tuples: `(A, B, C, (D, E, F, (G, H, I, J)))`.
pub trait Pushable {
    unsafe fn push(&self);
    unsafe fn pop(&self);
}

struct PushableGuard<'a, P: Pushable + ?Sized>(&'a P);

impl<P: Pushable + ?Sized> Drop for PushableGuard<'_, P> {
    fn drop(&mut self) {
        unsafe {
            self.0.pop();
        }
    }
}

#[allow(clippy::needless_lifetimes)]
unsafe fn push_guard<'a, P: Pushable>(p: &'a P) -> PushableGuard<'a, P> {
    unsafe {
        p.push();
        PushableGuard(p)
    }
}

/// A [`Pushable`] that does nothing.
impl Pushable for () {
    unsafe fn push(&self) {}
    unsafe fn pop(&self) {}
}

impl<A: Pushable, B: Pushable> Pushable for Either<A, B> {
    unsafe fn push(&self) {
        unsafe {
            match self {
                Either::Left(a) => A::push(a),
                Either::Right(b) => B::push(b),
            }
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            match self {
                Either::Left(a) => A::pop(a),
                Either::Right(b) => B::pop(b),
            }
        }
    }
}

impl<A: Pushable> Pushable for (A,) {
    unsafe fn push(&self) {
        unsafe {
            self.0.push();
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            self.0.pop();
        }
    }
}

impl<P: Pushable + ?Sized> Pushable for &P {
    unsafe fn push(&self) {
        unsafe {
            P::push(self);
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            P::pop(self);
        }
    }
}

impl<A: Pushable, B: Pushable> Pushable for (A, B) {
    unsafe fn push(&self) {
        unsafe {
            self.0.push();
            self.1.push();
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            self.1.pop();
            self.0.pop();
        }
    }
}

impl<A: Pushable, B: Pushable, C: Pushable> Pushable for (A, B, C) {
    unsafe fn push(&self) {
        unsafe {
            self.0.push();
            self.1.push();
            self.2.push();
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            self.2.pop();
            self.1.pop();
            self.0.pop();
        }
    }
}

impl<A: Pushable, B: Pushable, C: Pushable, D: Pushable> Pushable for (A, B, C, D) {
    unsafe fn push(&self) {
        unsafe {
            self.0.push();
            self.1.push();
            self.2.push();
            self.3.push();
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            self.3.pop();
            self.2.pop();
            self.1.pop();
            self.0.pop();
        }
    }
}

impl Pushable for &[&dyn Pushable] {
    unsafe fn push(&self) {
        unsafe {
            for st in *self {
                st.push();
            }
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            for st in self.iter().rev() {
                st.pop();
            }
        }
    }
}

/// A [`Pushable`] that is applied optionally.
impl<T: Pushable> Pushable for Option<T> {
    unsafe fn push(&self) {
        unsafe {
            if let Some(s) = self {
                s.push();
            }
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            if let Some(s) = self {
                s.pop();
            }
        }
    }
}

//TODO rework the font pushables
impl Pushable for FontId {
    unsafe fn push(&self) {
        unsafe {
            let font = current_font_ptr(*self);
            ImGui_PushFont(font, 0.0);
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopFont();
        }
    }
}

pub struct FontSize(pub f32);

impl Pushable for FontSize {
    unsafe fn push(&self) {
        unsafe {
            // maybe this should get ui and do ui.scale()
            ImGui_PushFont(std::ptr::null_mut(), self.0);
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopFont();
        }
    }
}

pub struct FontAndSize(pub FontId, pub f32);

impl Pushable for FontAndSize {
    unsafe fn push(&self) {
        unsafe {
            ImGui_PushFont(current_font_ptr(self.0), self.1);
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopFont();
        }
    }
}

pub type StyleColor = (ColorId, Color);

#[derive(Copy, Clone, Debug)]
pub enum TextureRef<'a> {
    Id(TextureId),
    Ref(&'a ImTextureData),
}

impl TextureRef<'_> {
    pub unsafe fn tex_ref(&self) -> ImTextureRef {
        match self {
            TextureRef::Id(TextureId(id)) => ImTextureRef {
                _TexData: null_mut(),
                _TexID: *id,
            },
            TextureRef::Ref(tex_data) => ImTextureRef {
                _TexData: (&raw const **tex_data).cast_mut(),
                _TexID: 0,
            },
        }
    }

    pub unsafe fn tex_id(&self) -> TextureId {
        unsafe {
            match self {
                TextureRef::Id(tex_id) => *tex_id,
                TextureRef::Ref(tex_data) => {
                    let id = tex_data.TexID;
                    TextureId::from_id(id)
                }
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct TextureId(ImTextureID);

impl TextureId {
    pub fn id(&self) -> ImTextureID {
        self.0
    }
    pub unsafe fn from_id(id: ImTextureID) -> Self {
        Self(id)
    }
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct TextureUniqueId(i32);

impl Pushable for StyleColor {
    unsafe fn push(&self) {
        unsafe {
            ImGui_PushStyleColor1(self.0.bits(), &self.1.into());
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopStyleColor(1);
        }
    }
}

impl Pushable for [StyleColor] {
    unsafe fn push(&self) {
        unsafe {
            for sc in self {
                sc.push();
            }
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopStyleColor(self.len() as i32);
        }
    }
}

impl<const N: usize> Pushable for [StyleColor; N] {
    unsafe fn push(&self) {
        unsafe {
            self.as_slice().push();
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            self.as_slice().pop();
        }
    }
}

pub type StyleColorF = (ColorId, ImVec4);

impl Pushable for StyleColorF {
    unsafe fn push(&self) {
        unsafe {
            ImGui_PushStyleColor1(self.0.bits(), &self.1);
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopStyleColor(1);
        }
    }
}

impl Pushable for [StyleColorF] {
    unsafe fn push(&self) {
        unsafe {
            for sc in self {
                sc.push();
            }
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopStyleColor(self.len() as i32);
        }
    }
}

impl<const N: usize> Pushable for [StyleColorF; N] {
    unsafe fn push(&self) {
        unsafe {
            self.as_slice().push();
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            self.as_slice().pop();
        }
    }
}

#[derive(Debug, Copy, Clone)]
pub enum StyleValue {
    F32(f32),
    Vec2(Vector2),
    X(f32),
    Y(f32),
}

pub type Style = (StyleVar, StyleValue);

impl Pushable for Style {
    unsafe fn push(&self) {
        unsafe {
            match self.1 {
                StyleValue::F32(f) => ImGui_PushStyleVar(self.0.bits(), f),
                StyleValue::Vec2(v) => ImGui_PushStyleVar1(self.0.bits(), &v2_to_im(v)),
                StyleValue::X(x) => ImGui_PushStyleVarX(self.0.bits(), x),
                StyleValue::Y(y) => ImGui_PushStyleVarX(self.0.bits(), y),
            }
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopStyleVar(1);
        }
    }
}

impl Pushable for [Style] {
    unsafe fn push(&self) {
        unsafe {
            for sc in self {
                sc.push();
            }
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopStyleVar(self.len() as i32);
        }
    }
}

impl<const N: usize> Pushable for [Style; N] {
    unsafe fn push(&self) {
        unsafe {
            self.as_slice().push();
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            self.as_slice().pop();
        }
    }
}

#[derive(Debug, Copy, Clone)]
pub struct ItemWidth(pub f32);

impl Pushable for ItemWidth {
    unsafe fn push(&self) {
        unsafe {
            ImGui_PushItemWidth(self.0);
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopItemWidth();
        }
    }
}

#[derive(Debug, Copy, Clone)]
pub struct Indent(pub f32);

impl Pushable for Indent {
    unsafe fn push(&self) {
        unsafe {
            ImGui_Indent(self.0);
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_Unindent(self.0);
        }
    }
}

#[derive(Debug, Copy, Clone)]
pub struct TextWrapPos(pub f32);

impl Pushable for TextWrapPos {
    unsafe fn push(&self) {
        unsafe {
            ImGui_PushTextWrapPos(self.0);
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopTextWrapPos();
        }
    }
}

impl Pushable for (ItemFlags, bool) {
    unsafe fn push(&self) {
        unsafe {
            ImGui_PushItemFlag(self.0.bits(), self.1);
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopItemFlag();
        }
    }
}

#[derive(Debug, Copy, Clone)]
pub struct ItemId<H: Hashable>(pub H);

impl<H: Hashable> Pushable for ItemId<H> {
    unsafe fn push(&self) {
        unsafe {
            self.0.push();
        }
    }
    unsafe fn pop(&self) {
        unsafe {
            ImGui_PopID();
        }
    }
}

transparent! {
    #[derive(Debug)]
    pub struct Viewport(ImGuiViewport);
}

impl Viewport {
    pub fn id(&self) -> ImGuiID {
        self.ID
    }
    pub fn flags(&self) -> ViewportFlags {
        ViewportFlags::from_bits_truncate(self.Flags)
    }
    pub fn pos(&self) -> Vector2 {
        im_to_v2(self.Pos)
    }
    pub fn size(&self) -> Vector2 {
        im_to_v2(self.Size)
    }
    pub fn work_pos(&self) -> Vector2 {
        im_to_v2(self.WorkPos)
    }
    pub fn work_size(&self) -> Vector2 {
        im_to_v2(self.WorkSize)
    }
    pub fn center(&self) -> Vector2 {
        self.pos() + self.size() / 2.0
    }
    pub fn work_center(&self) -> Vector2 {
        self.work_pos() + self.work_size() / 2.0
    }
}

decl_builder_with_opt! { TableConfig, ImGui_BeginTable, ImGui_EndTable () (S: IntoCStr)
    (
        str_id (S::Temp) (str_id.as_ptr()),
        column (i32) (column),
        flags (TableFlags) (flags.bits()),
        outer_size (ImVec2) (&outer_size),
        inner_width (f32) (inner_width),
    )
    {
        decl_builder_setter!{flags: TableFlags}
        decl_builder_setter_vector2!{outer_size: Vector2}
        decl_builder_setter!{inner_width: f32}
    }
    {
        pub fn table_config<S: IntoCStr>(&self, str_id: LblId<S>, column: i32) -> TableConfig<S> {
            TableConfig {
                str_id: str_id.into(),
                column,
                flags: TableFlags::None,
                outer_size: im_vec2(0.0, 0.0),
                inner_width: 0.0,
                push: (),
            }
        }
        /// Dear ImGui (`TableNextRow`): append into the first cell of a new row.
        /// `min_row_height` includes the minimum top and bottom padding aka CellPadding.y * 2.0f.
        pub fn table_next_row(&self, flags: TableRowFlags, min_row_height: f32) {
            unsafe {
                ImGui_TableNextRow(flags.bits(), min_row_height);
            }
        }
        /// Dear ImGui (`TableNextColumn`): append into the next column (or first column of next row
        /// if currently in last column). Return true when column is visible.
        pub fn table_next_column(&self) -> bool {
            unsafe {
                ImGui_TableNextColumn()
            }
        }
        /// Dear ImGui (`TableSetColumnIndex`): append into the specified column.
        /// Return true when column is visible.
        pub fn table_set_column_index(&self, column_n: i32) -> bool {
            unsafe {
                ImGui_TableSetColumnIndex(column_n)
            }
        }
        pub fn table_setup_column(&self, label: impl IntoCStr, flags: TableColumnFlags, init_width_or_weight: f32, user_id: ImGuiID) {
            unsafe {
                ImGui_TableSetupColumn(label.into().as_ptr(), flags.bits(), init_width_or_weight, user_id);
            }
        }
        /// Dear ImGui (`TableSetupScrollFreeze`): lock columns/rows so they stay visible when scrolled.
        pub fn table_setup_scroll_freeze(&self, cols: i32, rows: i32) {
            unsafe {
                ImGui_TableSetupScrollFreeze(cols, rows);
            }
        }
        /// Dear ImGui (`TableHeadersRow`): submit a row with headers cells based on data provided
        /// to TableSetupColumn() + submit context menu.
        pub fn table_headers_row(&self) {
            unsafe {
                ImGui_TableHeadersRow();
            }
        }
        /// Dear ImGui (`TableAngledHeadersRow`): submit a row with angled headers for every column
        /// with the ImGuiTableColumnFlags_AngledHeader flag. MUST BE FIRST ROW.
        pub fn table_angle_headers_row(&self) {
            unsafe {
                ImGui_TableAngledHeadersRow();
            }
        }
        /// Dear ImGui (`TableGetColumnCount`): return number of columns (value passed to BeginTable).
        pub fn table_get_columns_count(&self) -> i32 {
            unsafe {
                ImGui_TableGetColumnCount()
            }
        }
        /// Dear ImGui (`TableGetColumnIndex`): return current column index.
        pub fn table_get_column_index(&self) -> i32 {
            unsafe {
                ImGui_TableGetColumnIndex()
            }
        }
        /// Can return one-pass the last column if hovering the empty space
        pub fn table_get_hovered_column(&self) -> Option<i32> {
            unsafe {
                let res = ImGui_TableGetHoveredColumn();
                if res < 0 {
                    None
                } else {
                    Some(res)
                }
            }
        }
        /// Dear ImGui (`TableGetRowIndex`): return current row index (header rows are accounted for).
        pub fn table_get_row_index(&self) -> i32 {
            unsafe {
                ImGui_TableGetRowIndex()
            }
        }
        pub fn table_get_column_flags(&self, column_n: Option<i32>) -> TableColumnFlags {
            let bits = unsafe {
                ImGui_TableGetColumnFlags(column_n.unwrap_or(-1))
            };
            TableColumnFlags::from_bits_truncate(bits)
        }
        /// Dear ImGui (`TableGetColumnName`): return "" if column didn't have a name declared by
        /// TableSetupColumn(). Pass None to use current column.
        pub fn table_get_column_name(&self, column_n: Option<i32>) -> String {
            unsafe {
                let c_str = ImGui_TableGetColumnName(column_n.unwrap_or(-1));
                CStr::from_ptr(c_str).to_string_lossy().into_owned()
            }
        }
        /// Dear ImGui (`TableSetColumnEnabled`): change user accessible enabled/disabled state of a column.
        /// Set to false to hide the column. User can use the context menu to change this themselves
        /// (right-click in headers, or right-click in columns body with ImGuiTableFlags_ContextMenuInBody).
        pub fn table_set_column_enabled(&self, column_n: Option<i32>, enabled: bool) {
            unsafe {
                ImGui_TableSetColumnEnabled(column_n.unwrap_or(-1), enabled);
            };
        }
        /// Dear ImGui (`TableSetBgColor`): change the color of a cell, row, or column.
        /// See ImGuiTableBgTarget_ flags for details.
        pub fn table_set_bg_color(&self, target: TableBgTarget, color: Color, column_n: Option<i32>) {
            unsafe {
                ImGui_TableSetBgColor(target.bits(), color.as_u32(), column_n.unwrap_or(-1));
            };
        }
        /// Dear ImGui (`TableGetSortSpecs`): get latest sort specs for the table (NULL if not sorting).
        /// Lifetime: don't hold on this pointer over multiple frames or past any subsequent call to BeginTable().
        pub fn table_with_sort_specs(&self, sort_fn: impl FnOnce(&[TableColumnSortSpec])) {
            self.table_with_sort_specs_always(|dirty, spec| {
                if dirty {
                    sort_fn(spec);
                }
                false
            })
        }
        /// The `sort_fn` takes the old `dirty` and returns the new `dirty`.
        pub fn table_with_sort_specs_always(&self, sort_fn: impl FnOnce(bool, &[TableColumnSortSpec]) -> bool) {
            unsafe {
                let specs = ImGui_TableGetSortSpecs();
                if specs.is_null() {
                    return;
                }
                // SAFETY: TableColumnSortSpec is a repr(transparent), so this pointer cast should be ok
                let slice = {
                    let len = (*specs).SpecsCount as usize;
                    if len == 0 {
                        &[]
                    } else {
                        let ptr = std::mem::transmute::<*const ImGuiTableColumnSortSpecs, *const TableColumnSortSpec>((*specs).Specs);
                        std::slice::from_raw_parts(ptr, len)
                    }
                };
                (*specs).SpecsDirty = sort_fn((*specs).SpecsDirty, slice);
            }
        }
    }
}

/// Helper token class that allows to set the drag&drop payload, once.
pub struct DragDropPayloadSetter<'a> {
    _dummy: PhantomData<&'a ()>,
}

/// This is a sub-set of [`Cond`], only for drag&drop payloads.
pub enum DragDropPayloadCond {
    Always,
    Once,
}

impl DragDropPayloadSetter<'_> {
    pub fn set(self, type_: impl IntoCStr, data: &[u8], cond: DragDropPayloadCond) -> bool {
        // For some reason ImGui does not accept a non-null pointer with length 0.
        let ptr = if data.is_empty() {
            null()
        } else {
            data.as_ptr() as *const c_void
        };
        let len = data.len();
        let cond = match cond {
            DragDropPayloadCond::Always => Cond::Always,
            DragDropPayloadCond::Once => Cond::Once,
        };
        unsafe { ImGui_SetDragDropPayload(type_.into().as_ptr(), ptr, len, cond.bits()) }
    }
}

/// Helpar class to get the drag&drop payload.
pub struct DragDropPayloadGetter<'a> {
    _dummy: PhantomData<&'a ()>,
}

/// The payload of a drag&drop operation.
///
/// It contains a "type", and a byte array.
pub struct DragDropPayload<'a> {
    pay: &'a ImGuiPayload,
}

impl<'a> DragDropPayloadGetter<'a> {
    pub fn any(&self, flags: DragDropAcceptFlags) -> Option<DragDropPayload<'a>> {
        unsafe {
            let pay = ImGui_AcceptDragDropPayload(null(), flags.bits());
            if pay.is_null() {
                None
            } else {
                Some(DragDropPayload { pay: &*pay })
            }
        }
    }
    pub fn by_type(
        &self,
        type_: impl IntoCStr,
        flags: DragDropAcceptFlags,
    ) -> Option<DragDropPayload<'a>> {
        unsafe {
            let pay = ImGui_AcceptDragDropPayload(type_.into().as_ptr(), flags.bits());
            if pay.is_null() {
                None
            } else {
                Some(DragDropPayload { pay: &*pay })
            }
        }
    }
    pub fn peek(&self) -> Option<DragDropPayload<'a>> {
        unsafe {
            let pay = ImGui_GetDragDropPayload();
            if pay.is_null() {
                None
            } else {
                Some(DragDropPayload { pay: &*pay })
            }
        }
    }
}

impl DragDropPayload<'_> {
    //WARNING: inline functions
    pub fn is_data_type(&self, type_: impl IntoCStr) -> bool {
        if self.pay.DataFrameCount == -1 {
            return false;
        }
        let data_type = unsafe { std::mem::transmute::<&[c_char], &[u8]>(&self.pay.DataType) };
        let data_type = CStr::from_bytes_until_nul(data_type).unwrap();
        data_type == type_.into().as_ref()
    }
    pub fn type_(&self) -> Cow<'_, str> {
        let data_type = unsafe { std::mem::transmute::<&[c_char], &[u8]>(&self.pay.DataType) };
        let data_type = CStr::from_bytes_until_nul(data_type).unwrap();
        data_type.to_string_lossy()
    }
    pub fn is_preview(&self) -> bool {
        self.pay.Preview
    }
    pub fn is_delivery(&self) -> bool {
        self.pay.Delivery
    }
    pub fn data(&self) -> &[u8] {
        if self.pay.Data.is_null() {
            &[]
        } else {
            unsafe {
                std::slice::from_raw_parts(self.pay.Data as *const u8, self.pay.DataSize as usize)
            }
        }
    }
}

pub const PAYLOAD_TYPE_COLOR_3F: &CStr =
    unsafe { CStr::from_bytes_with_nul_unchecked(IMGUI_PAYLOAD_TYPE_COLOR_3F) };
pub const PAYLOAD_TYPE_COLOR_4F: &CStr =
    unsafe { CStr::from_bytes_with_nul_unchecked(IMGUI_PAYLOAD_TYPE_COLOR_4F) };

/// This is an ImGuiKey plus several ImGuiMods.
///
/// Functions that use a `KeyChord` usually get a `impl Into<KeyChord>`. That is
/// implemented also for `Key` and `(KeyMod, Key)`.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct KeyChord(ImGuiKey);

impl KeyChord {
    pub fn new(mods: KeyMod, key: Key) -> KeyChord {
        KeyChord(ImGuiKey(mods.bits() | key.bits().0))
    }
    pub fn bits(&self) -> i32 {
        self.0.0
    }
    pub fn from_bits(bits: i32) -> Option<KeyChord> {
        // Validate that the bits are valid when building self
        let key = bits & !ImGuiKey::ImGuiMod_Mask_.0;
        let mods = bits & ImGuiKey::ImGuiMod_Mask_.0;
        match (Key::from_bits(ImGuiKey(key)), KeyMod::from_bits(mods)) {
            (Some(_), Some(_)) => Some(KeyChord(ImGuiKey(bits))),
            _ => None,
        }
    }
    pub fn key(&self) -> Key {
        let key = self.bits() & !ImGuiKey::ImGuiMod_Mask_.0;
        Key::from_bits(ImGuiKey(key)).unwrap_or(Key::None)
    }
    pub fn mods(&self) -> KeyMod {
        let mods = self.bits() & ImGuiKey::ImGuiMod_Mask_.0;
        KeyMod::from_bits_truncate(mods)
    }
}

impl From<Key> for KeyChord {
    fn from(value: Key) -> Self {
        KeyChord::new(KeyMod::None, value)
    }
}

impl From<(KeyMod, Key)> for KeyChord {
    fn from(value: (KeyMod, Key)) -> Self {
        KeyChord::new(value.0, value.1)
    }
}

/// Return type for `Ui::table_get_sort_specs`.
#[repr(transparent)]
pub struct TableColumnSortSpec(ImGuiTableColumnSortSpecs);

impl std::fmt::Debug for TableColumnSortSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TableColumnSortSpec")
            .field("id", &self.id())
            .field("index", &self.index())
            .field("sort_order", &self.sort_order())
            .field("sort_direction", &self.sort_direction())
            .finish()
    }
}

impl TableColumnSortSpec {
    pub fn id(&self) -> ImGuiID {
        self.0.ColumnUserID
    }
    pub fn index(&self) -> usize {
        self.0.ColumnIndex as usize
    }
    pub fn sort_order(&self) -> usize {
        self.0.SortOrder as usize
    }
    pub fn sort_direction(&self) -> SortDirection {
        SortDirection::from_bits(self.0.SortDirection).unwrap_or(SortDirection::None)
    }
}

pub struct DockBuilder {
    _dummy: (),
}

impl DockBuilder {
    pub fn set_node_size(&self, node_id: ImGuiID, size: Vector2) {
        unsafe {
            ImGui_DockBuilderSetNodeSize(node_id, v2_to_im(size));
        }
    }
    pub fn set_node_pos(&self, node_id: ImGuiID, pos: Vector2) {
        unsafe {
            ImGui_DockBuilderSetNodePos(node_id, v2_to_im(pos));
        }
    }
    pub fn split_node(&self, node_id: ImGuiID, dir: Dir, size_ratio: f32) -> (ImGuiID, ImGuiID) {
        unsafe {
            let mut id2 = 0;
            let id1 = ImGui_DockBuilderSplitNode(
                node_id,
                dir.bits(),
                size_ratio,
                std::ptr::null_mut(),
                &mut id2,
            );
            (id1, id2)
        }
    }
    pub fn dock_window(&self, window_name: Id<impl IntoCStr>, node_id: ImGuiID) {
        unsafe {
            ImGui_DockBuilderDockWindow(window_name.into().as_ptr(), node_id);
        }
    }
    pub fn get_node(&self, node_id: ImGuiID) -> Option<&DockNode> {
        unsafe {
            let ptr = ImGui_DockBuilderGetNode(node_id);
            ptr.as_ref().map(DockNode::cast)
        }
    }
    pub fn get_node_mut(&mut self, node_id: ImGuiID) -> Option<&mut DockNode> {
        unsafe {
            let ptr = ImGui_DockBuilderGetNode(node_id);
            ptr.as_mut().map(DockNode::cast_mut)
        }
    }
}

transparent! {
    pub struct DockNode(ImGuiDockNode);
}

impl DockNode {
    pub fn local_flags(&self) -> DockNodeFlags {
        DockNodeFlags::from_bits_truncate(self.LocalFlags)
    }

    pub fn set_local_flags(&mut self, flags: DockNodeFlags) {
        // inline function
        self.0.LocalFlags = flags.bits();
        self.0.MergedFlags = self.0.SharedFlags | self.0.LocalFlags | self.0.LocalFlagsInWindows;
    }
}

transparent_mut! {
    #[derive(Debug, Copy, Clone)]
    pub struct WindowClass(ImGuiWindowClass);
}

impl Default for WindowClass {
    fn default() -> Self {
        // Warning: inline C++ function
        WindowClass(ImGuiWindowClass {
            ClassId: 0,
            ParentViewportId: u32::MAX,
            FocusRouteParentWindowId: 0,
            ViewportFlagsOverrideSet: 0,
            ViewportFlagsOverrideClear: 0,
            TabItemFlagsOverrideSet: 0,
            DockNodeFlagsOverrideSet: 0,
            DockingAlwaysTabBar: false,
            DockingAllowUnclassed: true,
            PlatformIconData: std::ptr::null_mut(),
        })
    }
}

impl WindowClass {
    pub fn new() -> Self {
        Self::default()
    }
    pub fn class_id(mut self, id: ImGuiID) -> Self {
        self.ClassId = id;
        self
    }
    pub fn parent_viewport_id(mut self, id: Option<ImGuiID>) -> Self {
        self.ParentViewportId = id.unwrap_or(u32::MAX);
        self
    }
    pub fn focus_route_parent_window_id(mut self, id: ImGuiID) -> Self {
        self.FocusRouteParentWindowId = id;
        self
    }
    pub fn dock_node_flags(mut self, set_flags: DockNodeFlags) -> Self {
        self.DockNodeFlagsOverrideSet = set_flags.bits();
        self
    }
    pub fn tab_item_flags(mut self, set_flags: TabItemFlags) -> Self {
        self.TabItemFlagsOverrideSet = set_flags.bits();
        self
    }
    pub fn viewport_flags(mut self, set_flags: ViewportFlags, clear_flags: ViewportFlags) -> Self {
        self.ViewportFlagsOverrideSet = set_flags.bits();
        self.ViewportFlagsOverrideClear = clear_flags.bits();
        self
    }
    pub fn docking_always_tab_bar(mut self, value: bool) -> Self {
        self.DockingAlwaysTabBar = value;
        self
    }
    pub fn docking_allow_unclassed(mut self, value: bool) -> Self {
        self.DockingAllowUnclassed = value;
        self
    }
}