Skip to content

armgit / BUI

Public Imported from GitHub
0

Blender's GPU Accelerated UI, Decoupled from it's original codebase. Supports Rust, Python, JS, React, C & C++. Twice as good as GPUI

211 KB
Raw Blame
//! The safe layer over sys.rs: snake_case functions taking &str, &mut for in/out
//! values, slices for (pointer, count) pairs; methods on the imgui structs.
//! `button(label)` takes the required arguments, `button_ex(label, size)` all of them.
//! Generated by bindings/imgui/gen/gen.py from imgui.h: do not edit (py -3 -I bindings/imgui/gen/gen.py).
#![allow(clippy::all, unused_mut, unused_variables)]

use crate::sys::{self, *};
use core::ffi::{c_char, c_int, c_uint, c_void};
use std::ffi::CString;

/// `ImGui::CreateContext`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn create_context() -> Option<&'static mut ImGuiContext> {
    unsafe { sys::ImGui_CreateContext().as_mut() }
}
/// `ImGui::CreateContext`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn create_context_ex(shared_font_atlas: Option<&mut ImFontAtlas>) -> Option<&'static mut ImGuiContext> {
    unsafe { sys::ImGui_CreateContextEx(shared_font_atlas.map_or(core::ptr::null_mut(), |r| r as *mut ImFontAtlas)).as_mut() }
}
/// `ImGui::DestroyContext`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn destroy_context() {
    unsafe { sys::ImGui_DestroyContext() }
}
/// `ImGui::DestroyContext`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn destroy_context_ex(ctx: Option<&mut ImGuiContext>) {
    unsafe { sys::ImGui_DestroyContextEx(ctx.map_or(core::ptr::null_mut(), |r| r as *mut ImGuiContext)) }
}
/// `ImGui::GetCurrentContext`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_current_context() -> Option<&'static mut ImGuiContext> {
    unsafe { sys::ImGui_GetCurrentContext().as_mut() }
}
/// `ImGui::SetCurrentContext`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_current_context(ctx: &mut ImGuiContext) {
    unsafe { sys::ImGui_SetCurrentContext(ctx as *mut ImGuiContext) }
}
/// `ImGui::GetIO`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_io() -> &'static mut ImGuiIO {
    unsafe { &mut *sys::ImGui_GetIO() }
}
/// `ImGui::GetPlatformIO`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_platform_io() -> &'static mut ImGuiPlatformIO {
    unsafe { &mut *sys::ImGui_GetPlatformIO() }
}
/// `ImGui::GetStyle`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_style() -> &'static mut ImGuiStyle {
    unsafe { &mut *sys::ImGui_GetStyle() }
}
/// `ImGui::NewFrame`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn new_frame() {
    unsafe { sys::ImGui_NewFrame() }
}
/// `ImGui::EndFrame`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_frame() {
    unsafe { sys::ImGui_EndFrame() }
}
/// `ImGui::Render`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn render() {
    unsafe { sys::ImGui_Render() }
}
/// `ImGui::GetDrawData`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_draw_data() -> Option<&'static mut ImDrawData> {
    unsafe { sys::ImGui_GetDrawData().as_mut() }
}
/// `ImGui::ShowDemoWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_demo_window() {
    unsafe { sys::ImGui_ShowDemoWindow() }
}
/// `ImGui::ShowDemoWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_demo_window_ex(p_open: Option<&mut bool>) {
    unsafe { sys::ImGui_ShowDemoWindowEx(p_open.map_or(core::ptr::null_mut(), |r| r as *mut bool)) }
}
/// `ImGui::ShowMetricsWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_metrics_window() {
    unsafe { sys::ImGui_ShowMetricsWindow() }
}
/// `ImGui::ShowMetricsWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_metrics_window_ex(p_open: Option<&mut bool>) {
    unsafe { sys::ImGui_ShowMetricsWindowEx(p_open.map_or(core::ptr::null_mut(), |r| r as *mut bool)) }
}
/// `ImGui::ShowDebugLogWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_debug_log_window() {
    unsafe { sys::ImGui_ShowDebugLogWindow() }
}
/// `ImGui::ShowDebugLogWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_debug_log_window_ex(p_open: Option<&mut bool>) {
    unsafe { sys::ImGui_ShowDebugLogWindowEx(p_open.map_or(core::ptr::null_mut(), |r| r as *mut bool)) }
}
/// `ImGui::ShowIDStackToolWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_id_stack_tool_window() {
    unsafe { sys::ImGui_ShowIDStackToolWindow() }
}
/// `ImGui::ShowIDStackToolWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_id_stack_tool_window_ex(p_open: Option<&mut bool>) {
    unsafe { sys::ImGui_ShowIDStackToolWindowEx(p_open.map_or(core::ptr::null_mut(), |r| r as *mut bool)) }
}
/// `ImGui::ShowAboutWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_about_window() {
    unsafe { sys::ImGui_ShowAboutWindow() }
}
/// `ImGui::ShowAboutWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_about_window_ex(p_open: Option<&mut bool>) {
    unsafe { sys::ImGui_ShowAboutWindowEx(p_open.map_or(core::ptr::null_mut(), |r| r as *mut bool)) }
}
/// `ImGui::ShowStyleEditor`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_style_editor() {
    unsafe { sys::ImGui_ShowStyleEditor() }
}
/// `ImGui::ShowStyleEditor`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_style_editor_ex(r#ref: Option<&mut ImGuiStyle>) {
    unsafe { sys::ImGui_ShowStyleEditorEx(r#ref.map_or(core::ptr::null_mut(), |r| r as *mut ImGuiStyle)) }
}
/// `ImGui::ShowStyleSelector`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_style_selector(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_ShowStyleSelector(__label.as_ptr()) }
}
/// `ImGui::ShowFontSelector`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_font_selector(label: &str) {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_ShowFontSelector(__label.as_ptr()) }
}
/// `ImGui::ShowUserGuide`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn show_user_guide() {
    unsafe { sys::ImGui_ShowUserGuide() }
}
/// `ImGui::GetVersion`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_version() -> &'static str {
    unsafe { crate::from_cstr(sys::ImGui_GetVersion()) }
}
/// `ImGui::StyleColorsDark`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn style_colors_dark() {
    unsafe { sys::ImGui_StyleColorsDark() }
}
/// `ImGui::StyleColorsDark`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn style_colors_dark_ex(dst: Option<&mut ImGuiStyle>) {
    unsafe { sys::ImGui_StyleColorsDarkEx(dst.map_or(core::ptr::null_mut(), |r| r as *mut ImGuiStyle)) }
}
/// `ImGui::StyleColorsLight`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn style_colors_light() {
    unsafe { sys::ImGui_StyleColorsLight() }
}
/// `ImGui::StyleColorsLight`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn style_colors_light_ex(dst: Option<&mut ImGuiStyle>) {
    unsafe { sys::ImGui_StyleColorsLightEx(dst.map_or(core::ptr::null_mut(), |r| r as *mut ImGuiStyle)) }
}
/// `ImGui::StyleColorsClassic`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn style_colors_classic() {
    unsafe { sys::ImGui_StyleColorsClassic() }
}
/// `ImGui::StyleColorsClassic`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn style_colors_classic_ex(dst: Option<&mut ImGuiStyle>) {
    unsafe { sys::ImGui_StyleColorsClassicEx(dst.map_or(core::ptr::null_mut(), |r| r as *mut ImGuiStyle)) }
}
/// `ImGui::Begin`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin(name: &str) -> bool {
    let __name = crate::cs(name);
    unsafe { sys::ImGui_Begin(__name.as_ptr()) }
}
/// `ImGui::Begin`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_ex(name: &str, p_open: Option<&mut bool>, flags: ImGuiWindowFlags) -> bool {
    let __name = crate::cs(name);
    unsafe { sys::ImGui_BeginEx(__name.as_ptr(), p_open.map_or(core::ptr::null_mut(), |r| r as *mut bool), flags) }
}
/// `ImGui::End`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end() {
    unsafe { sys::ImGui_End() }
}
/// `ImGui::BeginChild`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_child(str_id: &str) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_BeginChild(__str_id.as_ptr()) }
}
/// `ImGui::BeginChild`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_child_ex(str_id: &str, size: impl Into<ImVec2>, child_flags: ImGuiChildFlags, window_flags: ImGuiWindowFlags) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_BeginChildEx(__str_id.as_ptr(), size.into(), child_flags, window_flags) }
}
/// `ImGui::BeginChild`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_child_id(id: ImGuiID) -> bool {
    unsafe { sys::ImGui_BeginChildID(id) }
}
/// `ImGui::BeginChild`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_child_id_ex(id: ImGuiID, size: impl Into<ImVec2>, child_flags: ImGuiChildFlags, window_flags: ImGuiWindowFlags) -> bool {
    unsafe { sys::ImGui_BeginChildIDEx(id, size.into(), child_flags, window_flags) }
}
/// `ImGui::EndChild`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_child() {
    unsafe { sys::ImGui_EndChild() }
}
/// `ImGui::IsWindowAppearing`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_window_appearing() -> bool {
    unsafe { sys::ImGui_IsWindowAppearing() }
}
/// `ImGui::IsWindowCollapsed`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_window_collapsed() -> bool {
    unsafe { sys::ImGui_IsWindowCollapsed() }
}
/// `ImGui::IsWindowFocused`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_window_focused() -> bool {
    unsafe { sys::ImGui_IsWindowFocused() }
}
/// `ImGui::IsWindowFocused`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_window_focused_ex(flags: ImGuiFocusedFlags) -> bool {
    unsafe { sys::ImGui_IsWindowFocusedEx(flags) }
}
/// `ImGui::IsWindowHovered`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_window_hovered() -> bool {
    unsafe { sys::ImGui_IsWindowHovered() }
}
/// `ImGui::IsWindowHovered`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_window_hovered_ex(flags: ImGuiHoveredFlags) -> bool {
    unsafe { sys::ImGui_IsWindowHoveredEx(flags) }
}
/// `ImGui::GetWindowDrawList`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_window_draw_list() -> Option<&'static mut ImDrawList> {
    unsafe { sys::ImGui_GetWindowDrawList().as_mut() }
}
/// `ImGui::GetWindowPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_window_pos() -> ImVec2 {
    unsafe { sys::ImGui_GetWindowPos() }
}
/// `ImGui::GetWindowSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_window_size() -> ImVec2 {
    unsafe { sys::ImGui_GetWindowSize() }
}
/// `ImGui::GetWindowWidth`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_window_width() -> f32 {
    unsafe { sys::ImGui_GetWindowWidth() }
}
/// `ImGui::GetWindowHeight`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_window_height() -> f32 {
    unsafe { sys::ImGui_GetWindowHeight() }
}
/// `ImGui::SetNextWindowPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_pos(pos: impl Into<ImVec2>) {
    unsafe { sys::ImGui_SetNextWindowPos(pos.into()) }
}
/// `ImGui::SetNextWindowPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_pos_ex(pos: impl Into<ImVec2>, cond: ImGuiCond, pivot: impl Into<ImVec2>) {
    unsafe { sys::ImGui_SetNextWindowPosEx(pos.into(), cond, pivot.into()) }
}
/// `ImGui::SetNextWindowSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_size(size: impl Into<ImVec2>) {
    unsafe { sys::ImGui_SetNextWindowSize(size.into()) }
}
/// `ImGui::SetNextWindowSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_size_ex(size: impl Into<ImVec2>, cond: ImGuiCond) {
    unsafe { sys::ImGui_SetNextWindowSizeEx(size.into(), cond) }
}
/// `ImGui::SetNextWindowSizeConstraints`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_size_constraints(size_min: impl Into<ImVec2>, size_max: impl Into<ImVec2>) {
    unsafe { sys::ImGui_SetNextWindowSizeConstraints(size_min.into(), size_max.into()) }
}
/// `ImGui::SetNextWindowSizeConstraints`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_size_constraints_ex(size_min: impl Into<ImVec2>, size_max: impl Into<ImVec2>) {
    unsafe { sys::ImGui_SetNextWindowSizeConstraintsEx(size_min.into(), size_max.into(), None, core::ptr::null_mut()) }
}
/// `ImGui::SetNextWindowContentSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_content_size(size: impl Into<ImVec2>) {
    unsafe { sys::ImGui_SetNextWindowContentSize(size.into()) }
}
/// `ImGui::SetNextWindowCollapsed`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_collapsed(collapsed: bool) {
    unsafe { sys::ImGui_SetNextWindowCollapsed(collapsed) }
}
/// `ImGui::SetNextWindowCollapsed`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_collapsed_ex(collapsed: bool, cond: ImGuiCond) {
    unsafe { sys::ImGui_SetNextWindowCollapsedEx(collapsed, cond) }
}
/// `ImGui::SetNextWindowFocus`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_focus() {
    unsafe { sys::ImGui_SetNextWindowFocus() }
}
/// `ImGui::SetNextWindowScroll`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_scroll(scroll: impl Into<ImVec2>) {
    unsafe { sys::ImGui_SetNextWindowScroll(scroll.into()) }
}
/// `ImGui::SetNextWindowBgAlpha`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_window_bg_alpha(alpha: f32) {
    unsafe { sys::ImGui_SetNextWindowBgAlpha(alpha) }
}
/// `ImGui::SetWindowPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_pos(pos: impl Into<ImVec2>) {
    unsafe { sys::ImGui_SetWindowPos(pos.into()) }
}
/// `ImGui::SetWindowPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_pos_ex(pos: impl Into<ImVec2>, cond: ImGuiCond) {
    unsafe { sys::ImGui_SetWindowPosEx(pos.into(), cond) }
}
/// `ImGui::SetWindowSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_size(size: impl Into<ImVec2>) {
    unsafe { sys::ImGui_SetWindowSize(size.into()) }
}
/// `ImGui::SetWindowSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_size_ex(size: impl Into<ImVec2>, cond: ImGuiCond) {
    unsafe { sys::ImGui_SetWindowSizeEx(size.into(), cond) }
}
/// `ImGui::SetWindowCollapsed`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_collapsed(collapsed: bool) {
    unsafe { sys::ImGui_SetWindowCollapsed(collapsed) }
}
/// `ImGui::SetWindowCollapsed`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_collapsed_ex(collapsed: bool, cond: ImGuiCond) {
    unsafe { sys::ImGui_SetWindowCollapsedEx(collapsed, cond) }
}
/// `ImGui::SetWindowFocus`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_focus() {
    unsafe { sys::ImGui_SetWindowFocus() }
}
/// `ImGui::SetWindowPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_pos_str(name: &str, pos: impl Into<ImVec2>) {
    let __name = crate::cs(name);
    unsafe { sys::ImGui_SetWindowPosStr(__name.as_ptr(), pos.into()) }
}
/// `ImGui::SetWindowPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_pos_str_ex(name: &str, pos: impl Into<ImVec2>, cond: ImGuiCond) {
    let __name = crate::cs(name);
    unsafe { sys::ImGui_SetWindowPosStrEx(__name.as_ptr(), pos.into(), cond) }
}
/// `ImGui::SetWindowSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_size_str(name: &str, size: impl Into<ImVec2>) {
    let __name = crate::cs(name);
    unsafe { sys::ImGui_SetWindowSizeStr(__name.as_ptr(), size.into()) }
}
/// `ImGui::SetWindowSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_size_str_ex(name: &str, size: impl Into<ImVec2>, cond: ImGuiCond) {
    let __name = crate::cs(name);
    unsafe { sys::ImGui_SetWindowSizeStrEx(__name.as_ptr(), size.into(), cond) }
}
/// `ImGui::SetWindowCollapsed`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_collapsed_str(name: &str, collapsed: bool) {
    let __name = crate::cs(name);
    unsafe { sys::ImGui_SetWindowCollapsedStr(__name.as_ptr(), collapsed) }
}
/// `ImGui::SetWindowCollapsed`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_collapsed_str_ex(name: &str, collapsed: bool, cond: ImGuiCond) {
    let __name = crate::cs(name);
    unsafe { sys::ImGui_SetWindowCollapsedStrEx(__name.as_ptr(), collapsed, cond) }
}
/// `ImGui::SetWindowFocus`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_window_focus_str(name: &str) {
    let __name = crate::cs(name);
    unsafe { sys::ImGui_SetWindowFocusStr(__name.as_ptr()) }
}
/// `ImGui::GetScrollX`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_scroll_x() -> f32 {
    unsafe { sys::ImGui_GetScrollX() }
}
/// `ImGui::GetScrollY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_scroll_y() -> f32 {
    unsafe { sys::ImGui_GetScrollY() }
}
/// `ImGui::SetScrollX`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_scroll_x(scroll_x: f32) {
    unsafe { sys::ImGui_SetScrollX(scroll_x) }
}
/// `ImGui::SetScrollY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_scroll_y(scroll_y: f32) {
    unsafe { sys::ImGui_SetScrollY(scroll_y) }
}
/// `ImGui::GetScrollMaxX`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_scroll_max_x() -> f32 {
    unsafe { sys::ImGui_GetScrollMaxX() }
}
/// `ImGui::GetScrollMaxY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_scroll_max_y() -> f32 {
    unsafe { sys::ImGui_GetScrollMaxY() }
}
/// `ImGui::SetScrollHereX`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_scroll_here_x() {
    unsafe { sys::ImGui_SetScrollHereX() }
}
/// `ImGui::SetScrollHereX`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_scroll_here_x_ex(center_x_ratio: f32) {
    unsafe { sys::ImGui_SetScrollHereXEx(center_x_ratio) }
}
/// `ImGui::SetScrollHereY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_scroll_here_y() {
    unsafe { sys::ImGui_SetScrollHereY() }
}
/// `ImGui::SetScrollHereY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_scroll_here_y_ex(center_y_ratio: f32) {
    unsafe { sys::ImGui_SetScrollHereYEx(center_y_ratio) }
}
/// `ImGui::SetScrollFromPosX`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_scroll_from_pos_x(local_x: f32) {
    unsafe { sys::ImGui_SetScrollFromPosX(local_x) }
}
/// `ImGui::SetScrollFromPosX`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_scroll_from_pos_x_ex(local_x: f32, center_x_ratio: f32) {
    unsafe { sys::ImGui_SetScrollFromPosXEx(local_x, center_x_ratio) }
}
/// `ImGui::SetScrollFromPosY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_scroll_from_pos_y(local_y: f32) {
    unsafe { sys::ImGui_SetScrollFromPosY(local_y) }
}
/// `ImGui::SetScrollFromPosY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_scroll_from_pos_y_ex(local_y: f32, center_y_ratio: f32) {
    unsafe { sys::ImGui_SetScrollFromPosYEx(local_y, center_y_ratio) }
}
/// `ImGui::PushFont`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_font(font: &mut ImFont, font_size_base_unscaled: f32) {
    unsafe { sys::ImGui_PushFont(font as *mut ImFont, font_size_base_unscaled) }
}
/// `ImGui::PopFont`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn pop_font() {
    unsafe { sys::ImGui_PopFont() }
}
/// `ImGui::GetFont`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_font() -> Option<&'static mut ImFont> {
    unsafe { sys::ImGui_GetFont().as_mut() }
}
/// `ImGui::GetFontSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_font_size() -> f32 {
    unsafe { sys::ImGui_GetFontSize() }
}
/// `ImGui::GetFontBaked`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_font_baked() -> Option<&'static mut ImFontBaked> {
    unsafe { sys::ImGui_GetFontBaked().as_mut() }
}
/// `ImGui::PushStyleColor`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_style_color(idx: ImGuiCol, col: ImU32) {
    unsafe { sys::ImGui_PushStyleColor(idx, col) }
}
/// `ImGui::PushStyleColor`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_style_color_vec4(idx: ImGuiCol, col: impl Into<ImVec4>) {
    unsafe { sys::ImGui_PushStyleColorVec4(idx, col.into()) }
}
/// `ImGui::PopStyleColor`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn pop_style_color() {
    unsafe { sys::ImGui_PopStyleColor() }
}
/// `ImGui::PopStyleColor`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn pop_style_color_ex(count: c_int) {
    unsafe { sys::ImGui_PopStyleColorEx(count) }
}
/// `ImGui::PushStyleVar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_style_var(idx: ImGuiStyleVar, val: f32) {
    unsafe { sys::ImGui_PushStyleVar(idx, val) }
}
/// `ImGui::PushStyleVar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_style_var_vec2(idx: ImGuiStyleVar, val: impl Into<ImVec2>) {
    unsafe { sys::ImGui_PushStyleVarVec2(idx, val.into()) }
}
/// `ImGui::PushStyleVarX`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_style_var_x(idx: ImGuiStyleVar, val_x: f32) {
    unsafe { sys::ImGui_PushStyleVarX(idx, val_x) }
}
/// `ImGui::PushStyleVarY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_style_var_y(idx: ImGuiStyleVar, val_y: f32) {
    unsafe { sys::ImGui_PushStyleVarY(idx, val_y) }
}
/// `ImGui::PopStyleVar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn pop_style_var() {
    unsafe { sys::ImGui_PopStyleVar() }
}
/// `ImGui::PopStyleVar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn pop_style_var_ex(count: c_int) {
    unsafe { sys::ImGui_PopStyleVarEx(count) }
}
/// `ImGui::PushItemFlag`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_item_flag(option: ImGuiItemFlags, enabled: bool) {
    unsafe { sys::ImGui_PushItemFlag(option, enabled) }
}
/// `ImGui::PopItemFlag`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn pop_item_flag() {
    unsafe { sys::ImGui_PopItemFlag() }
}
/// `ImGui::PushItemWidth`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_item_width(item_width: f32) {
    unsafe { sys::ImGui_PushItemWidth(item_width) }
}
/// `ImGui::PopItemWidth`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn pop_item_width() {
    unsafe { sys::ImGui_PopItemWidth() }
}
/// `ImGui::SetNextItemWidth`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_item_width(item_width: f32) {
    unsafe { sys::ImGui_SetNextItemWidth(item_width) }
}
/// `ImGui::CalcItemWidth`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn calc_item_width() -> f32 {
    unsafe { sys::ImGui_CalcItemWidth() }
}
/// `ImGui::PushTextWrapPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_text_wrap_pos() {
    unsafe { sys::ImGui_PushTextWrapPos() }
}
/// `ImGui::PushTextWrapPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_text_wrap_pos_ex(wrap_local_pos_x: f32) {
    unsafe { sys::ImGui_PushTextWrapPosEx(wrap_local_pos_x) }
}
/// `ImGui::PopTextWrapPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn pop_text_wrap_pos() {
    unsafe { sys::ImGui_PopTextWrapPos() }
}
/// `ImGui::GetFontTexUvWhitePixel`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_font_tex_uv_white_pixel() -> ImVec2 {
    unsafe { sys::ImGui_GetFontTexUvWhitePixel() }
}
/// `ImGui::GetColorU32`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_color_u32(idx: ImGuiCol) -> ImU32 {
    unsafe { sys::ImGui_GetColorU32(idx) }
}
/// `ImGui::GetColorU32`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_color_u32_ex(idx: ImGuiCol, alpha_mul: f32) -> ImU32 {
    unsafe { sys::ImGui_GetColorU32Ex(idx, alpha_mul) }
}
/// `ImGui::GetColorU32`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_color_u32_vec4(col: impl Into<ImVec4>) -> ImU32 {
    unsafe { sys::ImGui_GetColorU32Vec4(col.into()) }
}
/// `ImGui::GetColorU32`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_color_u32_u32(col: ImU32) -> ImU32 {
    unsafe { sys::ImGui_GetColorU32U32(col) }
}
/// `ImGui::GetColorU32`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_color_u32_u32_ex(col: ImU32, alpha_mul: f32) -> ImU32 {
    unsafe { sys::ImGui_GetColorU32U32Ex(col, alpha_mul) }
}
/// `ImGui::GetStyleColorVec4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_style_color_vec4(idx: ImGuiCol) -> &'static ImVec4 {
    unsafe { &*sys::ImGui_GetStyleColorVec4(idx) }
}
/// `ImGui::GetCursorScreenPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_cursor_screen_pos() -> ImVec2 {
    unsafe { sys::ImGui_GetCursorScreenPos() }
}
/// `ImGui::SetCursorScreenPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_cursor_screen_pos(pos: impl Into<ImVec2>) {
    unsafe { sys::ImGui_SetCursorScreenPos(pos.into()) }
}
/// `ImGui::GetContentRegionAvail`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_content_region_avail() -> ImVec2 {
    unsafe { sys::ImGui_GetContentRegionAvail() }
}
/// `ImGui::GetCursorPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_cursor_pos() -> ImVec2 {
    unsafe { sys::ImGui_GetCursorPos() }
}
/// `ImGui::GetCursorPosX`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_cursor_pos_x() -> f32 {
    unsafe { sys::ImGui_GetCursorPosX() }
}
/// `ImGui::GetCursorPosY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_cursor_pos_y() -> f32 {
    unsafe { sys::ImGui_GetCursorPosY() }
}
/// `ImGui::SetCursorPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_cursor_pos(local_pos: impl Into<ImVec2>) {
    unsafe { sys::ImGui_SetCursorPos(local_pos.into()) }
}
/// `ImGui::SetCursorPosX`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_cursor_pos_x(local_x: f32) {
    unsafe { sys::ImGui_SetCursorPosX(local_x) }
}
/// `ImGui::SetCursorPosY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_cursor_pos_y(local_y: f32) {
    unsafe { sys::ImGui_SetCursorPosY(local_y) }
}
/// `ImGui::GetCursorStartPos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_cursor_start_pos() -> ImVec2 {
    unsafe { sys::ImGui_GetCursorStartPos() }
}
/// `ImGui::Separator`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn separator() {
    unsafe { sys::ImGui_Separator() }
}
/// `ImGui::SameLine`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn same_line() {
    unsafe { sys::ImGui_SameLine() }
}
/// `ImGui::SameLine`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn same_line_ex(offset_from_start_x: f32, spacing: f32) {
    unsafe { sys::ImGui_SameLineEx(offset_from_start_x, spacing) }
}
/// `ImGui::NewLine`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn new_line() {
    unsafe { sys::ImGui_NewLine() }
}
/// `ImGui::Spacing`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn spacing() {
    unsafe { sys::ImGui_Spacing() }
}
/// `ImGui::Dummy`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn dummy(size: impl Into<ImVec2>) {
    unsafe { sys::ImGui_Dummy(size.into()) }
}
/// `ImGui::Indent`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn indent() {
    unsafe { sys::ImGui_Indent() }
}
/// `ImGui::Indent`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn indent_ex(indent_w: f32) {
    unsafe { sys::ImGui_IndentEx(indent_w) }
}
/// `ImGui::Unindent`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn unindent() {
    unsafe { sys::ImGui_Unindent() }
}
/// `ImGui::Unindent`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn unindent_ex(indent_w: f32) {
    unsafe { sys::ImGui_UnindentEx(indent_w) }
}
/// `ImGui::BeginGroup`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_group() {
    unsafe { sys::ImGui_BeginGroup() }
}
/// `ImGui::EndGroup`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_group() {
    unsafe { sys::ImGui_EndGroup() }
}
/// `ImGui::AlignTextToFramePadding`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn align_text_to_frame_padding() {
    unsafe { sys::ImGui_AlignTextToFramePadding() }
}
/// `ImGui::GetTextLineHeight`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_text_line_height() -> f32 {
    unsafe { sys::ImGui_GetTextLineHeight() }
}
/// `ImGui::GetTextLineHeightWithSpacing`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_text_line_height_with_spacing() -> f32 {
    unsafe { sys::ImGui_GetTextLineHeightWithSpacing() }
}
/// `ImGui::GetFrameHeight`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_frame_height() -> f32 {
    unsafe { sys::ImGui_GetFrameHeight() }
}
/// `ImGui::GetFrameHeightWithSpacing`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_frame_height_with_spacing() -> f32 {
    unsafe { sys::ImGui_GetFrameHeightWithSpacing() }
}
/// `ImGui::PushID`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_id(str_id: &str) {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_PushID(__str_id.as_ptr()) }
}
/// `ImGui::PushID`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_id_str(str_id_begin: &str, str_id_end: &str) {
    let __str_id_begin = crate::cs(str_id_begin);
    let __str_id_end = crate::cs(str_id_end);
    unsafe { sys::ImGui_PushIDStr(__str_id_begin.as_ptr(), __str_id_end.as_ptr()) }
}
/// `ImGui::PushID`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_id_int(int_id: c_int) {
    unsafe { sys::ImGui_PushIDInt(int_id) }
}
/// `ImGui::PopID`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn pop_id() {
    unsafe { sys::ImGui_PopID() }
}
/// `ImGui::GetID`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_id(str_id: &str) -> ImGuiID {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_GetID(__str_id.as_ptr()) }
}
/// `ImGui::GetID`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_id_str(str_id_begin: &str, str_id_end: &str) -> ImGuiID {
    let __str_id_begin = crate::cs(str_id_begin);
    let __str_id_end = crate::cs(str_id_end);
    unsafe { sys::ImGui_GetIDStr(__str_id_begin.as_ptr(), __str_id_end.as_ptr()) }
}
/// `ImGui::GetID`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_id_int(int_id: c_int) -> ImGuiID {
    unsafe { sys::ImGui_GetIDInt(int_id) }
}
/// `ImGui::TextUnformatted`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn text_unformatted(text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_TextUnformatted(__text.as_ptr()) }
}
/// `ImGui::TextUnformatted`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn text_unformatted_ex(text: &str, text_end: Option<&str>) {
    let __text = crate::cs(text);
    let __text_end = text_end.map(crate::cs);
    unsafe { sys::ImGui_TextUnformattedEx(__text.as_ptr(), __text_end.as_ref().map_or(core::ptr::null(), |s| s.as_ptr())) }
}
/// `ImGui::Text`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn text(text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_Text(c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::TextColored`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn text_colored(col: impl Into<ImVec4>, text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_TextColored(col.into(), c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::TextDisabled`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn text_disabled(text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_TextDisabled(c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::TextWrapped`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn text_wrapped(text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_TextWrapped(c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::LabelText`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn label_text(label: &str, text: &str) {
    let __label = crate::cs(label);
    let __text = crate::cs(text);
    unsafe { sys::ImGui_LabelText(__label.as_ptr(), c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::BulletText`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn bullet_text(text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_BulletText(c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::SeparatorText`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn separator_text(label: &str) {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SeparatorText(__label.as_ptr()) }
}
/// `ImGui::Button`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn button(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_Button(__label.as_ptr()) }
}
/// `ImGui::Button`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn button_ex(label: &str, size: impl Into<ImVec2>) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_ButtonEx(__label.as_ptr(), size.into()) }
}
/// `ImGui::SmallButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn small_button(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SmallButton(__label.as_ptr()) }
}
/// `ImGui::InvisibleButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn invisible_button(str_id: &str, size: impl Into<ImVec2>) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_InvisibleButton(__str_id.as_ptr(), size.into()) }
}
/// `ImGui::InvisibleButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn invisible_button_ex(str_id: &str, size: impl Into<ImVec2>, flags: ImGuiButtonFlags) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_InvisibleButtonEx(__str_id.as_ptr(), size.into(), flags) }
}
/// `ImGui::ArrowButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn arrow_button(str_id: &str, dir: ImGuiDir) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_ArrowButton(__str_id.as_ptr(), dir) }
}
/// `ImGui::Checkbox`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn checkbox(label: &str, v: &mut bool) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_Checkbox(__label.as_ptr(), v) }
}
/// `ImGui::CheckboxFlags`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn checkbox_flags(label: &str, flags: &mut c_int, flags_value: c_int) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_CheckboxFlags(__label.as_ptr(), flags, flags_value) }
}
/// `ImGui::CheckboxFlags`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn checkbox_flags_u_int_ptr(label: &str, flags: &mut c_uint, flags_value: c_uint) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_CheckboxFlagsUIntPtr(__label.as_ptr(), flags, flags_value) }
}
/// `ImGui::RadioButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn radio_button(label: &str, active: bool) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_RadioButton(__label.as_ptr(), active) }
}
/// `ImGui::RadioButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn radio_button_int_ptr(label: &str, v: &mut c_int, v_button: c_int) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_RadioButtonIntPtr(__label.as_ptr(), v, v_button) }
}
/// `ImGui::ProgressBar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn progress_bar(fraction: f32) {
    unsafe { sys::ImGui_ProgressBar(fraction) }
}
/// `ImGui::ProgressBar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn progress_bar_ex(fraction: f32, size_arg: impl Into<ImVec2>, overlay: Option<&str>) {
    let __overlay = overlay.map(crate::cs);
    unsafe { sys::ImGui_ProgressBarEx(fraction, size_arg.into(), __overlay.as_ref().map_or(core::ptr::null(), |s| s.as_ptr())) }
}
/// `ImGui::Bullet`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn bullet() {
    unsafe { sys::ImGui_Bullet() }
}
/// `ImGui::TextLink`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn text_link(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_TextLink(__label.as_ptr()) }
}
/// `ImGui::TextLinkOpenURL`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn text_link_open_url(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_TextLinkOpenURL(__label.as_ptr()) }
}
/// `ImGui::TextLinkOpenURL`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn text_link_open_url_ex(label: &str, url: Option<&str>) -> bool {
    let __label = crate::cs(label);
    let __url = url.map(crate::cs);
    unsafe { sys::ImGui_TextLinkOpenURLEx(__label.as_ptr(), __url.as_ref().map_or(core::ptr::null(), |s| s.as_ptr())) }
}
/// `ImGui::Image`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn image(tex_ref: impl Into<ImTextureRef>, image_size: impl Into<ImVec2>) {
    unsafe { sys::ImGui_Image(tex_ref.into(), image_size.into()) }
}
/// `ImGui::Image`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn image_ex(tex_ref: impl Into<ImTextureRef>, image_size: impl Into<ImVec2>, uv0: impl Into<ImVec2>, uv1: impl Into<ImVec2>) {
    unsafe { sys::ImGui_ImageEx(tex_ref.into(), image_size.into(), uv0.into(), uv1.into()) }
}
/// `ImGui::ImageWithBg`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn image_with_bg(tex_ref: impl Into<ImTextureRef>, image_size: impl Into<ImVec2>) {
    unsafe { sys::ImGui_ImageWithBg(tex_ref.into(), image_size.into()) }
}
/// `ImGui::ImageWithBg`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn image_with_bg_ex(tex_ref: impl Into<ImTextureRef>, image_size: impl Into<ImVec2>, uv0: impl Into<ImVec2>, uv1: impl Into<ImVec2>, bg_col: impl Into<ImVec4>, tint_col: impl Into<ImVec4>) {
    unsafe { sys::ImGui_ImageWithBgEx(tex_ref.into(), image_size.into(), uv0.into(), uv1.into(), bg_col.into(), tint_col.into()) }
}
/// `ImGui::ImageButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn image_button(str_id: &str, tex_ref: impl Into<ImTextureRef>, image_size: impl Into<ImVec2>) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_ImageButton(__str_id.as_ptr(), tex_ref.into(), image_size.into()) }
}
/// `ImGui::ImageButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn image_button_ex(str_id: &str, tex_ref: impl Into<ImTextureRef>, image_size: impl Into<ImVec2>, uv0: impl Into<ImVec2>, uv1: impl Into<ImVec2>, bg_col: impl Into<ImVec4>, tint_col: impl Into<ImVec4>) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_ImageButtonEx(__str_id.as_ptr(), tex_ref.into(), image_size.into(), uv0.into(), uv1.into(), bg_col.into(), tint_col.into()) }
}
/// `ImGui::BeginCombo`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_combo(label: &str, preview_value: &str) -> bool {
    let __label = crate::cs(label);
    let __preview_value = crate::cs(preview_value);
    unsafe { sys::ImGui_BeginCombo(__label.as_ptr(), __preview_value.as_ptr()) }
}
/// `ImGui::BeginCombo`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_combo_ex(label: &str, preview_value: &str, flags: ImGuiComboFlags) -> bool {
    let __label = crate::cs(label);
    let __preview_value = crate::cs(preview_value);
    unsafe { sys::ImGui_BeginComboEx(__label.as_ptr(), __preview_value.as_ptr(), flags) }
}
/// `ImGui::EndCombo`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_combo() {
    unsafe { sys::ImGui_EndCombo() }
}
/// `ImGui::Combo`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn combo(label: &str, current_item: &mut c_int, items: &[&str]) -> bool {
    let __label = crate::cs(label);
    let __items_c: Vec<CString> = items.iter().map(|s| crate::cs(s)).collect();
    let __items_p: Vec<*const c_char> = __items_c.iter().map(|s| s.as_ptr()).collect();
    unsafe { sys::ImGui_Combo(__label.as_ptr(), current_item, __items_p.as_ptr(), __items_p.len() as c_int) }
}
/// `ImGui::Combo`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn combo_ex(label: &str, current_item: &mut c_int, items: &[&str], popup_max_height_in_items: c_int) -> bool {
    let __label = crate::cs(label);
    let __items_c: Vec<CString> = items.iter().map(|s| crate::cs(s)).collect();
    let __items_p: Vec<*const c_char> = __items_c.iter().map(|s| s.as_ptr()).collect();
    unsafe { sys::ImGui_ComboEx(__label.as_ptr(), current_item, __items_p.as_ptr(), __items_p.len() as c_int, popup_max_height_in_items) }
}
/// `ImGui::Combo`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn combo_str(label: &str, current_item: &mut c_int, items_separated_by_zeros: &str) -> bool {
    let __label = crate::cs(label);
    let __items_separated_by_zeros = crate::cs(items_separated_by_zeros);
    unsafe { sys::ImGui_ComboStr(__label.as_ptr(), current_item, __items_separated_by_zeros.as_ptr()) }
}
/// `ImGui::Combo`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn combo_str_ex(label: &str, current_item: &mut c_int, items_separated_by_zeros: &str, popup_max_height_in_items: c_int) -> bool {
    let __label = crate::cs(label);
    let __items_separated_by_zeros = crate::cs(items_separated_by_zeros);
    unsafe { sys::ImGui_ComboStrEx(__label.as_ptr(), current_item, __items_separated_by_zeros.as_ptr(), popup_max_height_in_items) }
}
/// `ImGui::DragFloat`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_float(label: &str, v: &mut f32) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_DragFloat(__label.as_ptr(), v) }
}
/// `ImGui::DragFloat`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_float_ex(label: &str, v: &mut f32, v_speed: f32, v_min: f32, v_max: f32, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_DragFloatEx(__label.as_ptr(), v, v_speed, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::DragFloat2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_float2(label: &str, v: &mut [f32; 2]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_DragFloat2(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::DragFloat2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_float2_ex(label: &str, v: &mut [f32; 2], v_speed: f32, v_min: f32, v_max: f32, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_DragFloat2Ex(__label.as_ptr(), v.as_mut_ptr(), v_speed, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::DragFloat3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_float3(label: &str, v: &mut [f32; 3]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_DragFloat3(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::DragFloat3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_float3_ex(label: &str, v: &mut [f32; 3], v_speed: f32, v_min: f32, v_max: f32, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_DragFloat3Ex(__label.as_ptr(), v.as_mut_ptr(), v_speed, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::DragFloat4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_float4(label: &str, v: &mut [f32; 4]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_DragFloat4(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::DragFloat4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_float4_ex(label: &str, v: &mut [f32; 4], v_speed: f32, v_min: f32, v_max: f32, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_DragFloat4Ex(__label.as_ptr(), v.as_mut_ptr(), v_speed, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::DragFloatRange2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_float_range2(label: &str, v_current_min: &mut f32, v_current_max: &mut f32) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_DragFloatRange2(__label.as_ptr(), v_current_min, v_current_max) }
}
/// `ImGui::DragFloatRange2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_float_range2_ex(label: &str, v_current_min: &mut f32, v_current_max: &mut f32, v_speed: f32, v_min: f32, v_max: f32, format: &str, format_max: Option<&str>, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    let __format_max = format_max.map(crate::cs);
    unsafe { sys::ImGui_DragFloatRange2Ex(__label.as_ptr(), v_current_min, v_current_max, v_speed, v_min, v_max, __format.as_ptr(), __format_max.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), flags) }
}
/// `ImGui::DragInt`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_int(label: &str, v: &mut c_int) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_DragInt(__label.as_ptr(), v) }
}
/// `ImGui::DragInt`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_int_ex(label: &str, v: &mut c_int, v_speed: f32, v_min: c_int, v_max: c_int, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_DragIntEx(__label.as_ptr(), v, v_speed, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::DragInt2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_int2(label: &str, v: &mut [c_int; 2]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_DragInt2(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::DragInt2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_int2_ex(label: &str, v: &mut [c_int; 2], v_speed: f32, v_min: c_int, v_max: c_int, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_DragInt2Ex(__label.as_ptr(), v.as_mut_ptr(), v_speed, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::DragInt3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_int3(label: &str, v: &mut [c_int; 3]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_DragInt3(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::DragInt3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_int3_ex(label: &str, v: &mut [c_int; 3], v_speed: f32, v_min: c_int, v_max: c_int, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_DragInt3Ex(__label.as_ptr(), v.as_mut_ptr(), v_speed, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::DragInt4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_int4(label: &str, v: &mut [c_int; 4]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_DragInt4(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::DragInt4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_int4_ex(label: &str, v: &mut [c_int; 4], v_speed: f32, v_min: c_int, v_max: c_int, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_DragInt4Ex(__label.as_ptr(), v.as_mut_ptr(), v_speed, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::DragIntRange2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_int_range2(label: &str, v_current_min: &mut c_int, v_current_max: &mut c_int) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_DragIntRange2(__label.as_ptr(), v_current_min, v_current_max) }
}
/// `ImGui::DragIntRange2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn drag_int_range2_ex(label: &str, v_current_min: &mut c_int, v_current_max: &mut c_int, v_speed: f32, v_min: c_int, v_max: c_int, format: &str, format_max: Option<&str>, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    let __format_max = format_max.map(crate::cs);
    unsafe { sys::ImGui_DragIntRange2Ex(__label.as_ptr(), v_current_min, v_current_max, v_speed, v_min, v_max, __format.as_ptr(), __format_max.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), flags) }
}
/// `ImGui::SliderFloat`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_float(label: &str, v: &mut f32, v_min: f32, v_max: f32) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SliderFloat(__label.as_ptr(), v, v_min, v_max) }
}
/// `ImGui::SliderFloat`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_float_ex(label: &str, v: &mut f32, v_min: f32, v_max: f32, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_SliderFloatEx(__label.as_ptr(), v, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::SliderFloat2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_float2(label: &str, v: &mut [f32; 2], v_min: f32, v_max: f32) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SliderFloat2(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max) }
}
/// `ImGui::SliderFloat2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_float2_ex(label: &str, v: &mut [f32; 2], v_min: f32, v_max: f32, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_SliderFloat2Ex(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::SliderFloat3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_float3(label: &str, v: &mut [f32; 3], v_min: f32, v_max: f32) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SliderFloat3(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max) }
}
/// `ImGui::SliderFloat3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_float3_ex(label: &str, v: &mut [f32; 3], v_min: f32, v_max: f32, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_SliderFloat3Ex(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::SliderFloat4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_float4(label: &str, v: &mut [f32; 4], v_min: f32, v_max: f32) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SliderFloat4(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max) }
}
/// `ImGui::SliderFloat4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_float4_ex(label: &str, v: &mut [f32; 4], v_min: f32, v_max: f32, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_SliderFloat4Ex(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::SliderAngle`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_angle(label: &str, v_rad: &mut f32) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SliderAngle(__label.as_ptr(), v_rad) }
}
/// `ImGui::SliderAngle`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_angle_ex(label: &str, v_rad: &mut f32, v_degrees_min: f32, v_degrees_max: f32, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_SliderAngleEx(__label.as_ptr(), v_rad, v_degrees_min, v_degrees_max, __format.as_ptr(), flags) }
}
/// `ImGui::SliderInt`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_int(label: &str, v: &mut c_int, v_min: c_int, v_max: c_int) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SliderInt(__label.as_ptr(), v, v_min, v_max) }
}
/// `ImGui::SliderInt`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_int_ex(label: &str, v: &mut c_int, v_min: c_int, v_max: c_int, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_SliderIntEx(__label.as_ptr(), v, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::SliderInt2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_int2(label: &str, v: &mut [c_int; 2], v_min: c_int, v_max: c_int) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SliderInt2(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max) }
}
/// `ImGui::SliderInt2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_int2_ex(label: &str, v: &mut [c_int; 2], v_min: c_int, v_max: c_int, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_SliderInt2Ex(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::SliderInt3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_int3(label: &str, v: &mut [c_int; 3], v_min: c_int, v_max: c_int) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SliderInt3(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max) }
}
/// `ImGui::SliderInt3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_int3_ex(label: &str, v: &mut [c_int; 3], v_min: c_int, v_max: c_int, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_SliderInt3Ex(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::SliderInt4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_int4(label: &str, v: &mut [c_int; 4], v_min: c_int, v_max: c_int) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SliderInt4(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max) }
}
/// `ImGui::SliderInt4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn slider_int4_ex(label: &str, v: &mut [c_int; 4], v_min: c_int, v_max: c_int, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_SliderInt4Ex(__label.as_ptr(), v.as_mut_ptr(), v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::VSliderFloat`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn v_slider_float(label: &str, size: impl Into<ImVec2>, v: &mut f32, v_min: f32, v_max: f32) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_VSliderFloat(__label.as_ptr(), size.into(), v, v_min, v_max) }
}
/// `ImGui::VSliderFloat`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn v_slider_float_ex(label: &str, size: impl Into<ImVec2>, v: &mut f32, v_min: f32, v_max: f32, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_VSliderFloatEx(__label.as_ptr(), size.into(), v, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::VSliderInt`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn v_slider_int(label: &str, size: impl Into<ImVec2>, v: &mut c_int, v_min: c_int, v_max: c_int) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_VSliderInt(__label.as_ptr(), size.into(), v, v_min, v_max) }
}
/// `ImGui::VSliderInt`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn v_slider_int_ex(label: &str, size: impl Into<ImVec2>, v: &mut c_int, v_min: c_int, v_max: c_int, format: &str, flags: ImGuiSliderFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_VSliderIntEx(__label.as_ptr(), size.into(), v, v_min, v_max, __format.as_ptr(), flags) }
}
/// `ImGui::InputText`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_text(label: &str, buf: &mut String) -> bool {
    let __label = crate::cs(label);
    let mut __buf = crate::InputBuf::new(buf);
    let __r = unsafe { sys::ImGui_InputTextEx(__label.as_ptr(), __buf.ptr(), __buf.capacity(), sys::ImGuiInputTextFlags_CallbackResize, Some(crate::input_text_resize), (&mut __buf) as *mut crate::InputBuf as *mut c_void) };
    __buf.finish(buf);
    __r
}
/// `ImGui::InputText`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_text_ex(label: &str, buf: &mut String, flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    let mut __buf = crate::InputBuf::new(buf);
    let __r = unsafe { sys::ImGui_InputTextEx(__label.as_ptr(), __buf.ptr(), __buf.capacity(), flags | sys::ImGuiInputTextFlags_CallbackResize, Some(crate::input_text_resize), (&mut __buf) as *mut crate::InputBuf as *mut c_void) };
    __buf.finish(buf);
    __r
}
/// `ImGui::InputTextMultiline`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_text_multiline(label: &str, buf: &mut String) -> bool {
    let __label = crate::cs(label);
    let mut __buf = crate::InputBuf::new(buf);
    let __r = unsafe { sys::ImGui_InputTextMultilineEx(__label.as_ptr(), __buf.ptr(), __buf.capacity(), ImVec2 { x: 0.0, y: 0.0 }, sys::ImGuiInputTextFlags_CallbackResize, Some(crate::input_text_resize), (&mut __buf) as *mut crate::InputBuf as *mut c_void) };
    __buf.finish(buf);
    __r
}
/// `ImGui::InputTextMultiline`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_text_multiline_ex(label: &str, buf: &mut String, size: impl Into<ImVec2>, flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    let mut __buf = crate::InputBuf::new(buf);
    let __r = unsafe { sys::ImGui_InputTextMultilineEx(__label.as_ptr(), __buf.ptr(), __buf.capacity(), size.into(), flags | sys::ImGuiInputTextFlags_CallbackResize, Some(crate::input_text_resize), (&mut __buf) as *mut crate::InputBuf as *mut c_void) };
    __buf.finish(buf);
    __r
}
/// `ImGui::InputTextWithHint`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_text_with_hint(label: &str, hint: &str, buf: &mut String) -> bool {
    let __label = crate::cs(label);
    let __hint = crate::cs(hint);
    let mut __buf = crate::InputBuf::new(buf);
    let __r = unsafe { sys::ImGui_InputTextWithHintEx(__label.as_ptr(), __hint.as_ptr(), __buf.ptr(), __buf.capacity(), sys::ImGuiInputTextFlags_CallbackResize, Some(crate::input_text_resize), (&mut __buf) as *mut crate::InputBuf as *mut c_void) };
    __buf.finish(buf);
    __r
}
/// `ImGui::InputTextWithHint`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_text_with_hint_ex(label: &str, hint: &str, buf: &mut String, flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    let __hint = crate::cs(hint);
    let mut __buf = crate::InputBuf::new(buf);
    let __r = unsafe { sys::ImGui_InputTextWithHintEx(__label.as_ptr(), __hint.as_ptr(), __buf.ptr(), __buf.capacity(), flags | sys::ImGuiInputTextFlags_CallbackResize, Some(crate::input_text_resize), (&mut __buf) as *mut crate::InputBuf as *mut c_void) };
    __buf.finish(buf);
    __r
}
/// `ImGui::InputFloat`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_float(label: &str, v: &mut f32) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputFloat(__label.as_ptr(), v) }
}
/// `ImGui::InputFloat`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_float_ex(label: &str, v: &mut f32, step: f32, step_fast: f32, format: &str, flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_InputFloatEx(__label.as_ptr(), v, step, step_fast, __format.as_ptr(), flags) }
}
/// `ImGui::InputFloat2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_float2(label: &str, v: &mut [f32; 2]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputFloat2(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::InputFloat2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_float2_ex(label: &str, v: &mut [f32; 2], format: &str, flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_InputFloat2Ex(__label.as_ptr(), v.as_mut_ptr(), __format.as_ptr(), flags) }
}
/// `ImGui::InputFloat3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_float3(label: &str, v: &mut [f32; 3]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputFloat3(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::InputFloat3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_float3_ex(label: &str, v: &mut [f32; 3], format: &str, flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_InputFloat3Ex(__label.as_ptr(), v.as_mut_ptr(), __format.as_ptr(), flags) }
}
/// `ImGui::InputFloat4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_float4(label: &str, v: &mut [f32; 4]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputFloat4(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::InputFloat4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_float4_ex(label: &str, v: &mut [f32; 4], format: &str, flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_InputFloat4Ex(__label.as_ptr(), v.as_mut_ptr(), __format.as_ptr(), flags) }
}
/// `ImGui::InputInt`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_int(label: &str, v: &mut c_int) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputInt(__label.as_ptr(), v) }
}
/// `ImGui::InputInt`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_int_ex(label: &str, v: &mut c_int, step: c_int, step_fast: c_int, flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputIntEx(__label.as_ptr(), v, step, step_fast, flags) }
}
/// `ImGui::InputInt2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_int2(label: &str, v: &mut [c_int; 2]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputInt2(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::InputInt2`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_int2_ex(label: &str, v: &mut [c_int; 2], flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputInt2Ex(__label.as_ptr(), v.as_mut_ptr(), flags) }
}
/// `ImGui::InputInt3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_int3(label: &str, v: &mut [c_int; 3]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputInt3(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::InputInt3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_int3_ex(label: &str, v: &mut [c_int; 3], flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputInt3Ex(__label.as_ptr(), v.as_mut_ptr(), flags) }
}
/// `ImGui::InputInt4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_int4(label: &str, v: &mut [c_int; 4]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputInt4(__label.as_ptr(), v.as_mut_ptr()) }
}
/// `ImGui::InputInt4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_int4_ex(label: &str, v: &mut [c_int; 4], flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputInt4Ex(__label.as_ptr(), v.as_mut_ptr(), flags) }
}
/// `ImGui::InputDouble`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_double(label: &str, v: &mut f64) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_InputDouble(__label.as_ptr(), v) }
}
/// `ImGui::InputDouble`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn input_double_ex(label: &str, v: &mut f64, step: f64, step_fast: f64, format: &str, flags: ImGuiInputTextFlags) -> bool {
    let __label = crate::cs(label);
    let __format = crate::cs(format);
    unsafe { sys::ImGui_InputDoubleEx(__label.as_ptr(), v, step, step_fast, __format.as_ptr(), flags) }
}
/// `ImGui::ColorEdit3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_edit3(label: &str, col: &mut [f32; 3]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_ColorEdit3(__label.as_ptr(), col.as_mut_ptr()) }
}
/// `ImGui::ColorEdit3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_edit3_ex(label: &str, col: &mut [f32; 3], flags: ImGuiColorEditFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_ColorEdit3Ex(__label.as_ptr(), col.as_mut_ptr(), flags) }
}
/// `ImGui::ColorEdit4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_edit4(label: &str, col: &mut [f32; 4]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_ColorEdit4(__label.as_ptr(), col.as_mut_ptr()) }
}
/// `ImGui::ColorEdit4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_edit4_ex(label: &str, col: &mut [f32; 4], flags: ImGuiColorEditFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_ColorEdit4Ex(__label.as_ptr(), col.as_mut_ptr(), flags) }
}
/// `ImGui::ColorPicker3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_picker3(label: &str, col: &mut [f32; 3]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_ColorPicker3(__label.as_ptr(), col.as_mut_ptr()) }
}
/// `ImGui::ColorPicker3`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_picker3_ex(label: &str, col: &mut [f32; 3], flags: ImGuiColorEditFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_ColorPicker3Ex(__label.as_ptr(), col.as_mut_ptr(), flags) }
}
/// `ImGui::ColorPicker4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_picker4(label: &str, col: &mut [f32; 4]) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_ColorPicker4(__label.as_ptr(), col.as_mut_ptr()) }
}
/// `ImGui::ColorPicker4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_picker4_ex(label: &str, col: &mut [f32; 4], flags: ImGuiColorEditFlags, ref_col: Option<&f32>) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_ColorPicker4Ex(__label.as_ptr(), col.as_mut_ptr(), flags, ref_col.map_or(core::ptr::null(), |r| r as *const f32)) }
}
/// `ImGui::ColorButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_button(desc_id: &str, col: impl Into<ImVec4>) -> bool {
    let __desc_id = crate::cs(desc_id);
    unsafe { sys::ImGui_ColorButton(__desc_id.as_ptr(), col.into()) }
}
/// `ImGui::ColorButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_button_ex(desc_id: &str, col: impl Into<ImVec4>, flags: ImGuiColorEditFlags, size: impl Into<ImVec2>) -> bool {
    let __desc_id = crate::cs(desc_id);
    unsafe { sys::ImGui_ColorButtonEx(__desc_id.as_ptr(), col.into(), flags, size.into()) }
}
/// `ImGui::TreeNode`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn tree_node(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_TreeNode(__label.as_ptr()) }
}
/// `ImGui::TreeNode`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn tree_node_str(str_id: &str, text: &str) -> bool {
    let __str_id = crate::cs(str_id);
    let __text = crate::cs(text);
    unsafe { sys::ImGui_TreeNodeStr(__str_id.as_ptr(), c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::TreeNodeEx`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn tree_node_ex(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_TreeNodeEx(__label.as_ptr()) }
}
/// `ImGui::TreeNodeEx`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn tree_node_ex_ex(label: &str, flags: ImGuiTreeNodeFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_TreeNodeExEx(__label.as_ptr(), flags) }
}
/// `ImGui::TreeNodeEx`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn tree_node_ex_str(str_id: &str, flags: ImGuiTreeNodeFlags, text: &str) -> bool {
    let __str_id = crate::cs(str_id);
    let __text = crate::cs(text);
    unsafe { sys::ImGui_TreeNodeExStr(__str_id.as_ptr(), flags, c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::TreePush`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn tree_push(str_id: &str) {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_TreePush(__str_id.as_ptr()) }
}
/// `ImGui::TreePop`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn tree_pop() {
    unsafe { sys::ImGui_TreePop() }
}
/// `ImGui::GetTreeNodeToLabelSpacing`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_tree_node_to_label_spacing() -> f32 {
    unsafe { sys::ImGui_GetTreeNodeToLabelSpacing() }
}
/// `ImGui::CollapsingHeader`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn collapsing_header(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_CollapsingHeader(__label.as_ptr()) }
}
/// `ImGui::CollapsingHeader`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn collapsing_header_ex(label: &str, flags: ImGuiTreeNodeFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_CollapsingHeaderEx(__label.as_ptr(), flags) }
}
/// `ImGui::CollapsingHeader`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn collapsing_header_bool_ptr(label: &str, p_visible: &mut bool) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_CollapsingHeaderBoolPtr(__label.as_ptr(), p_visible) }
}
/// `ImGui::CollapsingHeader`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn collapsing_header_bool_ptr_ex(label: &str, p_visible: &mut bool, flags: ImGuiTreeNodeFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_CollapsingHeaderBoolPtrEx(__label.as_ptr(), p_visible, flags) }
}
/// `ImGui::SetNextItemOpen`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_item_open(is_open: bool) {
    unsafe { sys::ImGui_SetNextItemOpen(is_open) }
}
/// `ImGui::SetNextItemOpen`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_item_open_ex(is_open: bool, cond: ImGuiCond) {
    unsafe { sys::ImGui_SetNextItemOpenEx(is_open, cond) }
}
/// `ImGui::SetNextItemStorageID`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_item_storage_id(storage_id: ImGuiID) {
    unsafe { sys::ImGui_SetNextItemStorageID(storage_id) }
}
/// `ImGui::TreeNodeGetOpen`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn tree_node_get_open(storage_id: ImGuiID) -> bool {
    unsafe { sys::ImGui_TreeNodeGetOpen(storage_id) }
}
/// `ImGui::TreeNodeGetOpen`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn tree_node_get_open_ex(storage_id: ImGuiID, flags: ImGuiTreeNodeFlags) -> bool {
    unsafe { sys::ImGui_TreeNodeGetOpenEx(storage_id, flags) }
}
/// `ImGui::Selectable`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn selectable(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_Selectable(__label.as_ptr()) }
}
/// `ImGui::Selectable`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn selectable_ex(label: &str, selected: bool, flags: ImGuiSelectableFlags, size: impl Into<ImVec2>) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SelectableEx(__label.as_ptr(), selected, flags, size.into()) }
}
/// `ImGui::Selectable`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn selectable_bool_ptr(label: &str, p_selected: &mut bool) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SelectableBoolPtr(__label.as_ptr(), p_selected) }
}
/// `ImGui::Selectable`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn selectable_bool_ptr_ex(label: &str, p_selected: &mut bool, flags: ImGuiSelectableFlags, size: impl Into<ImVec2>) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_SelectableBoolPtrEx(__label.as_ptr(), p_selected, flags, size.into()) }
}
/// `ImGui::BeginMultiSelect`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_multi_select(flags: ImGuiMultiSelectFlags) -> Option<&'static mut ImGuiMultiSelectIO> {
    unsafe { sys::ImGui_BeginMultiSelect(flags).as_mut() }
}
/// `ImGui::BeginMultiSelect`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_multi_select_ex(flags: ImGuiMultiSelectFlags, selection_size: c_int, items_count: c_int) -> Option<&'static mut ImGuiMultiSelectIO> {
    unsafe { sys::ImGui_BeginMultiSelectEx(flags, selection_size, items_count).as_mut() }
}
/// `ImGui::EndMultiSelect`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_multi_select() -> Option<&'static mut ImGuiMultiSelectIO> {
    unsafe { sys::ImGui_EndMultiSelect().as_mut() }
}
/// `ImGui::SetNextItemSelectionUserData`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_item_selection_user_data(selection_user_data: ImGuiSelectionUserData) {
    unsafe { sys::ImGui_SetNextItemSelectionUserData(selection_user_data) }
}
/// `ImGui::IsItemToggledSelection`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_toggled_selection() -> bool {
    unsafe { sys::ImGui_IsItemToggledSelection() }
}
/// `ImGui::BeginListBox`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_list_box(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_BeginListBox(__label.as_ptr()) }
}
/// `ImGui::BeginListBox`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_list_box_ex(label: &str, size: impl Into<ImVec2>) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_BeginListBoxEx(__label.as_ptr(), size.into()) }
}
/// `ImGui::EndListBox`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_list_box() {
    unsafe { sys::ImGui_EndListBox() }
}
/// `ImGui::ListBox`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn list_box(label: &str, current_item: &mut c_int, items: &[&str]) -> bool {
    let __label = crate::cs(label);
    let __items_c: Vec<CString> = items.iter().map(|s| crate::cs(s)).collect();
    let __items_p: Vec<*const c_char> = __items_c.iter().map(|s| s.as_ptr()).collect();
    unsafe { sys::ImGui_ListBox(__label.as_ptr(), current_item, __items_p.as_ptr(), __items_p.len() as c_int) }
}
/// `ImGui::ListBox`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn list_box_ex(label: &str, current_item: &mut c_int, items: &[&str], height_in_items: c_int) -> bool {
    let __label = crate::cs(label);
    let __items_c: Vec<CString> = items.iter().map(|s| crate::cs(s)).collect();
    let __items_p: Vec<*const c_char> = __items_c.iter().map(|s| s.as_ptr()).collect();
    unsafe { sys::ImGui_ListBoxEx(__label.as_ptr(), current_item, __items_p.as_ptr(), __items_p.len() as c_int, height_in_items) }
}
/// `ImGui::PlotLines`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn plot_lines(label: &str, values: &[f32]) {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_PlotLines(__label.as_ptr(), values.as_ptr(), values.len() as c_int) }
}
/// `ImGui::PlotLines`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn plot_lines_ex(label: &str, values: &[f32], values_offset: c_int, overlay_text: Option<&str>, scale_min: f32, scale_max: f32, graph_size: impl Into<ImVec2>, stride: c_int) {
    let __label = crate::cs(label);
    let __overlay_text = overlay_text.map(crate::cs);
    unsafe { sys::ImGui_PlotLinesEx(__label.as_ptr(), values.as_ptr(), values.len() as c_int, values_offset, __overlay_text.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), scale_min, scale_max, graph_size.into(), stride) }
}
/// `ImGui::PlotHistogram`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn plot_histogram(label: &str, values: &[f32]) {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_PlotHistogram(__label.as_ptr(), values.as_ptr(), values.len() as c_int) }
}
/// `ImGui::PlotHistogram`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn plot_histogram_ex(label: &str, values: &[f32], values_offset: c_int, overlay_text: Option<&str>, scale_min: f32, scale_max: f32, graph_size: impl Into<ImVec2>, stride: c_int) {
    let __label = crate::cs(label);
    let __overlay_text = overlay_text.map(crate::cs);
    unsafe { sys::ImGui_PlotHistogramEx(__label.as_ptr(), values.as_ptr(), values.len() as c_int, values_offset, __overlay_text.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), scale_min, scale_max, graph_size.into(), stride) }
}
/// `ImGui::Value`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn value(prefix: &str, b: bool) {
    let __prefix = crate::cs(prefix);
    unsafe { sys::ImGui_Value(__prefix.as_ptr(), b) }
}
/// `ImGui::Value`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn value_int(prefix: &str, v: c_int) {
    let __prefix = crate::cs(prefix);
    unsafe { sys::ImGui_ValueInt(__prefix.as_ptr(), v) }
}
/// `ImGui::Value`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn value_u_int(prefix: &str, v: c_uint) {
    let __prefix = crate::cs(prefix);
    unsafe { sys::ImGui_ValueUInt(__prefix.as_ptr(), v) }
}
/// `ImGui::Value`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn value_float(prefix: &str, v: f32) {
    let __prefix = crate::cs(prefix);
    unsafe { sys::ImGui_ValueFloat(__prefix.as_ptr(), v) }
}
/// `ImGui::Value`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn value_float_ex(prefix: &str, v: f32, float_format: Option<&str>) {
    let __prefix = crate::cs(prefix);
    let __float_format = float_format.map(crate::cs);
    unsafe { sys::ImGui_ValueFloatEx(__prefix.as_ptr(), v, __float_format.as_ref().map_or(core::ptr::null(), |s| s.as_ptr())) }
}
/// `ImGui::BeginMenuBar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_menu_bar() -> bool {
    unsafe { sys::ImGui_BeginMenuBar() }
}
/// `ImGui::EndMenuBar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_menu_bar() {
    unsafe { sys::ImGui_EndMenuBar() }
}
/// `ImGui::BeginMainMenuBar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_main_menu_bar() -> bool {
    unsafe { sys::ImGui_BeginMainMenuBar() }
}
/// `ImGui::EndMainMenuBar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_main_menu_bar() {
    unsafe { sys::ImGui_EndMainMenuBar() }
}
/// `ImGui::BeginMenu`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_menu(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_BeginMenu(__label.as_ptr()) }
}
/// `ImGui::BeginMenu`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_menu_ex(label: &str, enabled: bool) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_BeginMenuEx(__label.as_ptr(), enabled) }
}
/// `ImGui::EndMenu`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_menu() {
    unsafe { sys::ImGui_EndMenu() }
}
/// `ImGui::MenuItem`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn menu_item(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_MenuItem(__label.as_ptr()) }
}
/// `ImGui::MenuItem`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn menu_item_ex(label: &str, shortcut: Option<&str>, selected: bool, enabled: bool) -> bool {
    let __label = crate::cs(label);
    let __shortcut = shortcut.map(crate::cs);
    unsafe { sys::ImGui_MenuItemEx(__label.as_ptr(), __shortcut.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), selected, enabled) }
}
/// `ImGui::MenuItem`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn menu_item_bool_ptr(label: &str, shortcut: &str, p_selected: &mut bool) -> bool {
    let __label = crate::cs(label);
    let __shortcut = crate::cs(shortcut);
    unsafe { sys::ImGui_MenuItemBoolPtr(__label.as_ptr(), __shortcut.as_ptr(), p_selected) }
}
/// `ImGui::MenuItem`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn menu_item_bool_ptr_ex(label: &str, shortcut: &str, p_selected: &mut bool, enabled: bool) -> bool {
    let __label = crate::cs(label);
    let __shortcut = crate::cs(shortcut);
    unsafe { sys::ImGui_MenuItemBoolPtrEx(__label.as_ptr(), __shortcut.as_ptr(), p_selected, enabled) }
}
/// `ImGui::BeginTooltip`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_tooltip() -> bool {
    unsafe { sys::ImGui_BeginTooltip() }
}
/// `ImGui::EndTooltip`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_tooltip() {
    unsafe { sys::ImGui_EndTooltip() }
}
/// `ImGui::SetTooltip`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_tooltip(text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_SetTooltip(c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::BeginItemTooltip`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_item_tooltip() -> bool {
    unsafe { sys::ImGui_BeginItemTooltip() }
}
/// `ImGui::SetItemTooltip`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_item_tooltip(text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_SetItemTooltip(c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::BeginPopup`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_popup(str_id: &str) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_BeginPopup(__str_id.as_ptr()) }
}
/// `ImGui::BeginPopup`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_popup_ex(str_id: &str, flags: ImGuiWindowFlags) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_BeginPopupEx(__str_id.as_ptr(), flags) }
}
/// `ImGui::BeginPopupModal`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_popup_modal(name: &str) -> bool {
    let __name = crate::cs(name);
    unsafe { sys::ImGui_BeginPopupModal(__name.as_ptr()) }
}
/// `ImGui::BeginPopupModal`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_popup_modal_ex(name: &str, p_open: Option<&mut bool>, flags: ImGuiWindowFlags) -> bool {
    let __name = crate::cs(name);
    unsafe { sys::ImGui_BeginPopupModalEx(__name.as_ptr(), p_open.map_or(core::ptr::null_mut(), |r| r as *mut bool), flags) }
}
/// `ImGui::EndPopup`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_popup() {
    unsafe { sys::ImGui_EndPopup() }
}
/// `ImGui::OpenPopup`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn open_popup(str_id: &str) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_OpenPopup(__str_id.as_ptr()) }
}
/// `ImGui::OpenPopup`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn open_popup_ex(str_id: &str, popup_flags: ImGuiPopupFlags) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_OpenPopupEx(__str_id.as_ptr(), popup_flags) }
}
/// `ImGui::OpenPopup`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn open_popup_id(id: ImGuiID) -> bool {
    unsafe { sys::ImGui_OpenPopupID(id) }
}
/// `ImGui::OpenPopup`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn open_popup_id_ex(id: ImGuiID, popup_flags: ImGuiPopupFlags) -> bool {
    unsafe { sys::ImGui_OpenPopupIDEx(id, popup_flags) }
}
/// `ImGui::OpenPopupOnItemClick`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn open_popup_on_item_click() -> bool {
    unsafe { sys::ImGui_OpenPopupOnItemClick() }
}
/// `ImGui::OpenPopupOnItemClick`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn open_popup_on_item_click_ex(str_id: Option<&str>, popup_flags: ImGuiPopupFlags) -> bool {
    let __str_id = str_id.map(crate::cs);
    unsafe { sys::ImGui_OpenPopupOnItemClickEx(__str_id.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), popup_flags) }
}
/// `ImGui::CloseCurrentPopup`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn close_current_popup() {
    unsafe { sys::ImGui_CloseCurrentPopup() }
}
/// `ImGui::BeginPopupContextItem`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_popup_context_item() -> bool {
    unsafe { sys::ImGui_BeginPopupContextItem() }
}
/// `ImGui::BeginPopupContextItem`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_popup_context_item_ex(str_id: Option<&str>, popup_flags: ImGuiPopupFlags) -> bool {
    let __str_id = str_id.map(crate::cs);
    unsafe { sys::ImGui_BeginPopupContextItemEx(__str_id.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), popup_flags) }
}
/// `ImGui::BeginPopupContextWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_popup_context_window() -> bool {
    unsafe { sys::ImGui_BeginPopupContextWindow() }
}
/// `ImGui::BeginPopupContextWindow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_popup_context_window_ex(str_id: Option<&str>, popup_flags: ImGuiPopupFlags) -> bool {
    let __str_id = str_id.map(crate::cs);
    unsafe { sys::ImGui_BeginPopupContextWindowEx(__str_id.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), popup_flags) }
}
/// `ImGui::BeginPopupContextVoid`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_popup_context_void() -> bool {
    unsafe { sys::ImGui_BeginPopupContextVoid() }
}
/// `ImGui::BeginPopupContextVoid`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_popup_context_void_ex(str_id: Option<&str>, popup_flags: ImGuiPopupFlags) -> bool {
    let __str_id = str_id.map(crate::cs);
    unsafe { sys::ImGui_BeginPopupContextVoidEx(__str_id.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), popup_flags) }
}
/// `ImGui::IsPopupOpen`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_popup_open(str_id: &str) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_IsPopupOpen(__str_id.as_ptr()) }
}
/// `ImGui::IsPopupOpen`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_popup_open_ex(str_id: &str, flags: ImGuiPopupFlags) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_IsPopupOpenEx(__str_id.as_ptr(), flags) }
}
/// `ImGui::BeginTable`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_table(str_id: &str, columns: c_int) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_BeginTable(__str_id.as_ptr(), columns) }
}
/// `ImGui::BeginTable`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_table_ex(str_id: &str, columns: c_int, flags: ImGuiTableFlags, outer_size: impl Into<ImVec2>, inner_width: f32) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_BeginTableEx(__str_id.as_ptr(), columns, flags, outer_size.into(), inner_width) }
}
/// `ImGui::EndTable`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_table() {
    unsafe { sys::ImGui_EndTable() }
}
/// `ImGui::TableNextRow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_next_row() {
    unsafe { sys::ImGui_TableNextRow() }
}
/// `ImGui::TableNextRow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_next_row_ex(row_flags: ImGuiTableRowFlags, min_row_height: f32) {
    unsafe { sys::ImGui_TableNextRowEx(row_flags, min_row_height) }
}
/// `ImGui::TableNextColumn`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_next_column() -> bool {
    unsafe { sys::ImGui_TableNextColumn() }
}
/// `ImGui::TableSetColumnIndex`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_set_column_index(column_n: c_int) -> bool {
    unsafe { sys::ImGui_TableSetColumnIndex(column_n) }
}
/// `ImGui::TableSetupColumn`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_setup_column(label: &str) {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_TableSetupColumn(__label.as_ptr()) }
}
/// `ImGui::TableSetupColumn`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_setup_column_ex(label: &str, flags: ImGuiTableColumnFlags, init_width_or_weight: f32, user_data: ImGuiID) {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_TableSetupColumnEx(__label.as_ptr(), flags, init_width_or_weight, user_data) }
}
/// `ImGui::TableSetupScrollFreeze`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_setup_scroll_freeze(cols: c_int, rows: c_int) {
    unsafe { sys::ImGui_TableSetupScrollFreeze(cols, rows) }
}
/// `ImGui::TableHeader`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_header(label: &str) {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_TableHeader(__label.as_ptr()) }
}
/// `ImGui::TableHeadersRow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_headers_row() {
    unsafe { sys::ImGui_TableHeadersRow() }
}
/// `ImGui::TableAngledHeadersRow`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_angled_headers_row() {
    unsafe { sys::ImGui_TableAngledHeadersRow() }
}
/// `ImGui::TableGetSortSpecs`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_get_sort_specs() -> Option<&'static mut ImGuiTableSortSpecs> {
    unsafe { sys::ImGui_TableGetSortSpecs().as_mut() }
}
/// `ImGui::TableGetColumnCount`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_get_column_count() -> c_int {
    unsafe { sys::ImGui_TableGetColumnCount() }
}
/// `ImGui::TableGetColumnIndex`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_get_column_index() -> c_int {
    unsafe { sys::ImGui_TableGetColumnIndex() }
}
/// `ImGui::TableGetRowIndex`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_get_row_index() -> c_int {
    unsafe { sys::ImGui_TableGetRowIndex() }
}
/// `ImGui::TableGetColumnName`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_get_column_name() -> &'static str {
    unsafe { crate::from_cstr(sys::ImGui_TableGetColumnName()) }
}
/// `ImGui::TableGetColumnName`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_get_column_name_ex(column_n: c_int) -> &'static str {
    unsafe { crate::from_cstr(sys::ImGui_TableGetColumnNameEx(column_n)) }
}
/// `ImGui::TableGetColumnFlags`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_get_column_flags() -> ImGuiTableColumnFlags {
    unsafe { sys::ImGui_TableGetColumnFlags() }
}
/// `ImGui::TableGetColumnFlags`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_get_column_flags_ex(column_n: c_int) -> ImGuiTableColumnFlags {
    unsafe { sys::ImGui_TableGetColumnFlagsEx(column_n) }
}
/// `ImGui::TableSetColumnEnabled`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_set_column_enabled(column_n: c_int, v: bool) {
    unsafe { sys::ImGui_TableSetColumnEnabled(column_n, v) }
}
/// `ImGui::TableGetHoveredColumn`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_get_hovered_column() -> c_int {
    unsafe { sys::ImGui_TableGetHoveredColumn() }
}
/// `ImGui::TableSetBgColor`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_set_bg_color(target: ImGuiTableBgTarget, color: ImU32) {
    unsafe { sys::ImGui_TableSetBgColor(target, color) }
}
/// `ImGui::TableSetBgColor`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn table_set_bg_color_ex(target: ImGuiTableBgTarget, color: ImU32, column_n: c_int) {
    unsafe { sys::ImGui_TableSetBgColorEx(target, color, column_n) }
}
/// `ImGui::Columns`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn columns() {
    unsafe { sys::ImGui_Columns() }
}
/// `ImGui::Columns`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn columns_ex(count: c_int, id: Option<&str>, borders: bool) {
    let __id = id.map(crate::cs);
    unsafe { sys::ImGui_ColumnsEx(count, __id.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), borders) }
}
/// `ImGui::NextColumn`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn next_column() {
    unsafe { sys::ImGui_NextColumn() }
}
/// `ImGui::GetColumnIndex`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_column_index() -> c_int {
    unsafe { sys::ImGui_GetColumnIndex() }
}
/// `ImGui::GetColumnWidth`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_column_width() -> f32 {
    unsafe { sys::ImGui_GetColumnWidth() }
}
/// `ImGui::GetColumnWidth`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_column_width_ex(column_index: c_int) -> f32 {
    unsafe { sys::ImGui_GetColumnWidthEx(column_index) }
}
/// `ImGui::SetColumnWidth`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_column_width(column_index: c_int, width: f32) {
    unsafe { sys::ImGui_SetColumnWidth(column_index, width) }
}
/// `ImGui::GetColumnOffset`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_column_offset() -> f32 {
    unsafe { sys::ImGui_GetColumnOffset() }
}
/// `ImGui::GetColumnOffset`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_column_offset_ex(column_index: c_int) -> f32 {
    unsafe { sys::ImGui_GetColumnOffsetEx(column_index) }
}
/// `ImGui::SetColumnOffset`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_column_offset(column_index: c_int, offset_x: f32) {
    unsafe { sys::ImGui_SetColumnOffset(column_index, offset_x) }
}
/// `ImGui::GetColumnsCount`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_columns_count() -> c_int {
    unsafe { sys::ImGui_GetColumnsCount() }
}
/// `ImGui::BeginTabBar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_tab_bar(str_id: &str) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_BeginTabBar(__str_id.as_ptr()) }
}
/// `ImGui::BeginTabBar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_tab_bar_ex(str_id: &str, flags: ImGuiTabBarFlags) -> bool {
    let __str_id = crate::cs(str_id);
    unsafe { sys::ImGui_BeginTabBarEx(__str_id.as_ptr(), flags) }
}
/// `ImGui::EndTabBar`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_tab_bar() {
    unsafe { sys::ImGui_EndTabBar() }
}
/// `ImGui::BeginTabItem`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_tab_item(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_BeginTabItem(__label.as_ptr()) }
}
/// `ImGui::BeginTabItem`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_tab_item_ex(label: &str, p_open: Option<&mut bool>, flags: ImGuiTabItemFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_BeginTabItemEx(__label.as_ptr(), p_open.map_or(core::ptr::null_mut(), |r| r as *mut bool), flags) }
}
/// `ImGui::EndTabItem`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_tab_item() {
    unsafe { sys::ImGui_EndTabItem() }
}
/// `ImGui::TabItemButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn tab_item_button(label: &str) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_TabItemButton(__label.as_ptr()) }
}
/// `ImGui::TabItemButton`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn tab_item_button_ex(label: &str, flags: ImGuiTabItemFlags) -> bool {
    let __label = crate::cs(label);
    unsafe { sys::ImGui_TabItemButtonEx(__label.as_ptr(), flags) }
}
/// `ImGui::SetTabItemClosed`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_tab_item_closed(tab_or_docked_window_label: &str) {
    let __tab_or_docked_window_label = crate::cs(tab_or_docked_window_label);
    unsafe { sys::ImGui_SetTabItemClosed(__tab_or_docked_window_label.as_ptr()) }
}
/// `ImGui::LogToTTY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn log_to_tty() {
    unsafe { sys::ImGui_LogToTTY() }
}
/// `ImGui::LogToTTY`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn log_to_tty_ex(auto_open_depth: c_int) {
    unsafe { sys::ImGui_LogToTTYEx(auto_open_depth) }
}
/// `ImGui::LogToFile`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn log_to_file() {
    unsafe { sys::ImGui_LogToFile() }
}
/// `ImGui::LogToFile`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn log_to_file_ex(auto_open_depth: c_int, filename: Option<&str>) {
    let __filename = filename.map(crate::cs);
    unsafe { sys::ImGui_LogToFileEx(auto_open_depth, __filename.as_ref().map_or(core::ptr::null(), |s| s.as_ptr())) }
}
/// `ImGui::LogToClipboard`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn log_to_clipboard() {
    unsafe { sys::ImGui_LogToClipboard() }
}
/// `ImGui::LogToClipboard`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn log_to_clipboard_ex(auto_open_depth: c_int) {
    unsafe { sys::ImGui_LogToClipboardEx(auto_open_depth) }
}
/// `ImGui::LogFinish`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn log_finish() {
    unsafe { sys::ImGui_LogFinish() }
}
/// `ImGui::LogButtons`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn log_buttons() {
    unsafe { sys::ImGui_LogButtons() }
}
/// `ImGui::LogText`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn log_text(text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_LogText(c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::BeginDragDropSource`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_drag_drop_source() -> bool {
    unsafe { sys::ImGui_BeginDragDropSource() }
}
/// `ImGui::BeginDragDropSource`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_drag_drop_source_ex(flags: ImGuiDragDropFlags) -> bool {
    unsafe { sys::ImGui_BeginDragDropSourceEx(flags) }
}
/// `ImGui::SetDragDropPayload`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_drag_drop_payload(r#type: &str, data: &[u8]) -> bool {
    let __type = crate::cs(r#type);
    unsafe { sys::ImGui_SetDragDropPayload(__type.as_ptr(), data.as_ptr() as *const c_void, data.len()) }
}
/// `ImGui::SetDragDropPayload`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_drag_drop_payload_ex(r#type: &str, data: &[u8], cond: ImGuiCond) -> bool {
    let __type = crate::cs(r#type);
    unsafe { sys::ImGui_SetDragDropPayloadEx(__type.as_ptr(), data.as_ptr() as *const c_void, data.len(), cond) }
}
/// `ImGui::EndDragDropSource`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_drag_drop_source() {
    unsafe { sys::ImGui_EndDragDropSource() }
}
/// `ImGui::BeginDragDropTarget`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_drag_drop_target() -> bool {
    unsafe { sys::ImGui_BeginDragDropTarget() }
}
/// `ImGui::AcceptDragDropPayload`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn accept_drag_drop_payload(r#type: &str) -> Option<&'static ImGuiPayload> {
    let __type = crate::cs(r#type);
    unsafe { sys::ImGui_AcceptDragDropPayload(__type.as_ptr()).as_ref() }
}
/// `ImGui::AcceptDragDropPayload`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn accept_drag_drop_payload_ex(r#type: &str, flags: ImGuiDragDropFlags) -> Option<&'static ImGuiPayload> {
    let __type = crate::cs(r#type);
    unsafe { sys::ImGui_AcceptDragDropPayloadEx(__type.as_ptr(), flags).as_ref() }
}
/// `ImGui::EndDragDropTarget`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_drag_drop_target() {
    unsafe { sys::ImGui_EndDragDropTarget() }
}
/// `ImGui::GetDragDropPayload`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_drag_drop_payload() -> Option<&'static ImGuiPayload> {
    unsafe { sys::ImGui_GetDragDropPayload().as_ref() }
}
/// `ImGui::BeginDisabled`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_disabled() {
    unsafe { sys::ImGui_BeginDisabled() }
}
/// `ImGui::BeginDisabled`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn begin_disabled_ex(disabled: bool) {
    unsafe { sys::ImGui_BeginDisabledEx(disabled) }
}
/// `ImGui::EndDisabled`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn end_disabled() {
    unsafe { sys::ImGui_EndDisabled() }
}
/// `ImGui::PushClipRect`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn push_clip_rect(clip_rect_min: impl Into<ImVec2>, clip_rect_max: impl Into<ImVec2>, intersect_with_current_clip_rect: bool) {
    unsafe { sys::ImGui_PushClipRect(clip_rect_min.into(), clip_rect_max.into(), intersect_with_current_clip_rect) }
}
/// `ImGui::PopClipRect`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn pop_clip_rect() {
    unsafe { sys::ImGui_PopClipRect() }
}
/// `ImGui::SetItemDefaultFocus`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_item_default_focus() {
    unsafe { sys::ImGui_SetItemDefaultFocus() }
}
/// `ImGui::SetKeyboardFocusHere`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_keyboard_focus_here() {
    unsafe { sys::ImGui_SetKeyboardFocusHere() }
}
/// `ImGui::SetKeyboardFocusHere`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_keyboard_focus_here_ex(offset: c_int) {
    unsafe { sys::ImGui_SetKeyboardFocusHereEx(offset) }
}
/// `ImGui::SetNavCursorVisible`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_nav_cursor_visible(visible: bool) {
    unsafe { sys::ImGui_SetNavCursorVisible(visible) }
}
/// `ImGui::SetNextItemAllowOverlap`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_item_allow_overlap() {
    unsafe { sys::ImGui_SetNextItemAllowOverlap() }
}
/// `ImGui::IsItemHovered`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_hovered() -> bool {
    unsafe { sys::ImGui_IsItemHovered() }
}
/// `ImGui::IsItemHovered`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_hovered_ex(flags: ImGuiHoveredFlags) -> bool {
    unsafe { sys::ImGui_IsItemHoveredEx(flags) }
}
/// `ImGui::IsItemActive`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_active() -> bool {
    unsafe { sys::ImGui_IsItemActive() }
}
/// `ImGui::IsItemFocused`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_focused() -> bool {
    unsafe { sys::ImGui_IsItemFocused() }
}
/// `ImGui::IsItemClicked`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_clicked() -> bool {
    unsafe { sys::ImGui_IsItemClicked() }
}
/// `ImGui::IsItemClicked`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_clicked_ex(mouse_button: ImGuiMouseButton) -> bool {
    unsafe { sys::ImGui_IsItemClickedEx(mouse_button) }
}
/// `ImGui::IsItemVisible`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_visible() -> bool {
    unsafe { sys::ImGui_IsItemVisible() }
}
/// `ImGui::IsItemEdited`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_edited() -> bool {
    unsafe { sys::ImGui_IsItemEdited() }
}
/// `ImGui::IsItemActivated`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_activated() -> bool {
    unsafe { sys::ImGui_IsItemActivated() }
}
/// `ImGui::IsItemDeactivated`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_deactivated() -> bool {
    unsafe { sys::ImGui_IsItemDeactivated() }
}
/// `ImGui::IsItemDeactivatedAfterEdit`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_deactivated_after_edit() -> bool {
    unsafe { sys::ImGui_IsItemDeactivatedAfterEdit() }
}
/// `ImGui::IsItemToggledOpen`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_item_toggled_open() -> bool {
    unsafe { sys::ImGui_IsItemToggledOpen() }
}
/// `ImGui::IsAnyItemHovered`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_any_item_hovered() -> bool {
    unsafe { sys::ImGui_IsAnyItemHovered() }
}
/// `ImGui::IsAnyItemActive`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_any_item_active() -> bool {
    unsafe { sys::ImGui_IsAnyItemActive() }
}
/// `ImGui::IsAnyItemFocused`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_any_item_focused() -> bool {
    unsafe { sys::ImGui_IsAnyItemFocused() }
}
/// `ImGui::GetItemID`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_item_id() -> ImGuiID {
    unsafe { sys::ImGui_GetItemID() }
}
/// `ImGui::GetItemRectMin`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_item_rect_min() -> ImVec2 {
    unsafe { sys::ImGui_GetItemRectMin() }
}
/// `ImGui::GetItemRectMax`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_item_rect_max() -> ImVec2 {
    unsafe { sys::ImGui_GetItemRectMax() }
}
/// `ImGui::GetItemRectSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_item_rect_size() -> ImVec2 {
    unsafe { sys::ImGui_GetItemRectSize() }
}
/// `ImGui::GetItemFlags`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_item_flags() -> ImGuiItemFlags {
    unsafe { sys::ImGui_GetItemFlags() }
}
/// `ImGui::GetItemClickedCountWithSingleClickDelay`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_item_clicked_count_with_single_click_delay() -> c_int {
    unsafe { sys::ImGui_GetItemClickedCountWithSingleClickDelay() }
}
/// `ImGui::GetItemClickedCountWithSingleClickDelay`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_item_clicked_count_with_single_click_delay_ex(mouse_button: ImGuiMouseButton, delay: f32) -> c_int {
    unsafe { sys::ImGui_GetItemClickedCountWithSingleClickDelayEx(mouse_button, delay) }
}
/// `ImGui::GetMainViewport`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_main_viewport() -> Option<&'static mut ImGuiViewport> {
    unsafe { sys::ImGui_GetMainViewport().as_mut() }
}
/// `ImGui::GetBackgroundDrawList`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_background_draw_list() -> Option<&'static mut ImDrawList> {
    unsafe { sys::ImGui_GetBackgroundDrawList().as_mut() }
}
/// `ImGui::GetForegroundDrawList`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_foreground_draw_list() -> Option<&'static mut ImDrawList> {
    unsafe { sys::ImGui_GetForegroundDrawList().as_mut() }
}
/// `ImGui::IsRectVisible`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_rect_visible(size: impl Into<ImVec2>) -> bool {
    unsafe { sys::ImGui_IsRectVisible(size.into()) }
}
/// `ImGui::IsRectVisible`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_rect_visible_vec2(rect_min: impl Into<ImVec2>, rect_max: impl Into<ImVec2>) -> bool {
    unsafe { sys::ImGui_IsRectVisibleVec2(rect_min.into(), rect_max.into()) }
}
/// `ImGui::GetTime`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_time() -> f64 {
    unsafe { sys::ImGui_GetTime() }
}
/// `ImGui::GetFrameCount`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_frame_count() -> c_int {
    unsafe { sys::ImGui_GetFrameCount() }
}
/// `ImGui::GetDrawListSharedData`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_draw_list_shared_data() -> Option<&'static mut ImDrawListSharedData> {
    unsafe { sys::ImGui_GetDrawListSharedData().as_mut() }
}
/// `ImGui::GetStyleColorName`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_style_color_name(idx: ImGuiCol) -> &'static str {
    unsafe { crate::from_cstr(sys::ImGui_GetStyleColorName(idx)) }
}
/// `ImGui::SetStateStorage`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_state_storage(storage: &mut ImGuiStorage) {
    unsafe { sys::ImGui_SetStateStorage(storage as *mut ImGuiStorage) }
}
/// `ImGui::GetStateStorage`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_state_storage() -> Option<&'static mut ImGuiStorage> {
    unsafe { sys::ImGui_GetStateStorage().as_mut() }
}
/// `ImGui::CalcTextSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn calc_text_size(text: &str) -> ImVec2 {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_CalcTextSize(__text.as_ptr()) }
}
/// `ImGui::CalcTextSize`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn calc_text_size_ex(text: &str, text_end: Option<&str>, hide_text_after_double_hash: bool, wrap_width: f32) -> ImVec2 {
    let __text = crate::cs(text);
    let __text_end = text_end.map(crate::cs);
    unsafe { sys::ImGui_CalcTextSizeEx(__text.as_ptr(), __text_end.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), hide_text_after_double_hash, wrap_width) }
}
/// `ImGui::ColorConvertU32ToFloat4`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_convert_u32_to_float4(r#in: ImU32) -> ImVec4 {
    unsafe { sys::ImGui_ColorConvertU32ToFloat4(r#in) }
}
/// `ImGui::ColorConvertFloat4ToU32`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_convert_float4_to_u32(r#in: impl Into<ImVec4>) -> ImU32 {
    unsafe { sys::ImGui_ColorConvertFloat4ToU32(r#in.into()) }
}
/// `ImGui::ColorConvertRGBtoHSV`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_convert_rgb_to_hsv(r: f32, g: f32, b: f32, out_h: &mut f32, out_s: &mut f32, out_v: &mut f32) {
    unsafe { sys::ImGui_ColorConvertRGBtoHSV(r, g, b, out_h, out_s, out_v) }
}
/// `ImGui::ColorConvertHSVtoRGB`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn color_convert_hsv_to_rgb(h: f32, s: f32, v: f32, out_r: &mut f32, out_g: &mut f32, out_b: &mut f32) {
    unsafe { sys::ImGui_ColorConvertHSVtoRGB(h, s, v, out_r, out_g, out_b) }
}
/// `ImGui::IsKeyDown`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_key_down(key: ImGuiKey) -> bool {
    unsafe { sys::ImGui_IsKeyDown(key) }
}
/// `ImGui::IsKeyPressed`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_key_pressed(key: ImGuiKey) -> bool {
    unsafe { sys::ImGui_IsKeyPressed(key) }
}
/// `ImGui::IsKeyPressed`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_key_pressed_ex(key: ImGuiKey, repeat: bool) -> bool {
    unsafe { sys::ImGui_IsKeyPressedEx(key, repeat) }
}
/// `ImGui::IsKeyReleased`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_key_released(key: ImGuiKey) -> bool {
    unsafe { sys::ImGui_IsKeyReleased(key) }
}
/// `ImGui::IsKeyChordPressed`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_key_chord_pressed(key_chord: ImGuiKeyChord) -> bool {
    unsafe { sys::ImGui_IsKeyChordPressed(key_chord) }
}
/// `ImGui::GetKeyPressedAmount`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_key_pressed_amount(key: ImGuiKey, repeat_delay: f32, rate: f32) -> c_int {
    unsafe { sys::ImGui_GetKeyPressedAmount(key, repeat_delay, rate) }
}
/// `ImGui::GetKeyName`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_key_name(key: ImGuiKey) -> &'static str {
    unsafe { crate::from_cstr(sys::ImGui_GetKeyName(key)) }
}
/// `ImGui::SetNextFrameWantCaptureKeyboard`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_frame_want_capture_keyboard(want_capture_keyboard: bool) {
    unsafe { sys::ImGui_SetNextFrameWantCaptureKeyboard(want_capture_keyboard) }
}
/// `ImGui::Shortcut`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn shortcut(key_chord: ImGuiKeyChord) -> bool {
    unsafe { sys::ImGui_Shortcut(key_chord) }
}
/// `ImGui::Shortcut`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn shortcut_ex(key_chord: ImGuiKeyChord, flags: ImGuiInputFlags) -> bool {
    unsafe { sys::ImGui_ShortcutEx(key_chord, flags) }
}
/// `ImGui::SetNextItemShortcut`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_item_shortcut(key_chord: ImGuiKeyChord) {
    unsafe { sys::ImGui_SetNextItemShortcut(key_chord) }
}
/// `ImGui::SetNextItemShortcut`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_item_shortcut_ex(key_chord: ImGuiKeyChord, flags: ImGuiInputFlags) {
    unsafe { sys::ImGui_SetNextItemShortcutEx(key_chord, flags) }
}
/// `ImGui::SetItemKeyOwner`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_item_key_owner(key: ImGuiKey) -> bool {
    unsafe { sys::ImGui_SetItemKeyOwner(key) }
}
/// `ImGui::IsMouseDown`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_down(button: ImGuiMouseButton) -> bool {
    unsafe { sys::ImGui_IsMouseDown(button) }
}
/// `ImGui::IsMouseClicked`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_clicked(button: ImGuiMouseButton) -> bool {
    unsafe { sys::ImGui_IsMouseClicked(button) }
}
/// `ImGui::IsMouseClicked`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_clicked_ex(button: ImGuiMouseButton, repeat: bool) -> bool {
    unsafe { sys::ImGui_IsMouseClickedEx(button, repeat) }
}
/// `ImGui::IsMouseReleased`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_released(button: ImGuiMouseButton) -> bool {
    unsafe { sys::ImGui_IsMouseReleased(button) }
}
/// `ImGui::IsMouseDoubleClicked`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_double_clicked(button: ImGuiMouseButton) -> bool {
    unsafe { sys::ImGui_IsMouseDoubleClicked(button) }
}
/// `ImGui::IsMouseReleasedWithDelay`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_released_with_delay(button: ImGuiMouseButton) -> bool {
    unsafe { sys::ImGui_IsMouseReleasedWithDelay(button) }
}
/// `ImGui::IsMouseReleasedWithDelay`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_released_with_delay_ex(button: ImGuiMouseButton, delay: f32) -> bool {
    unsafe { sys::ImGui_IsMouseReleasedWithDelayEx(button, delay) }
}
/// `ImGui::GetMouseClickedCount`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_mouse_clicked_count(button: ImGuiMouseButton) -> c_int {
    unsafe { sys::ImGui_GetMouseClickedCount(button) }
}
/// `ImGui::IsMouseHoveringRect`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_hovering_rect(r_min: impl Into<ImVec2>, r_max: impl Into<ImVec2>) -> bool {
    unsafe { sys::ImGui_IsMouseHoveringRect(r_min.into(), r_max.into()) }
}
/// `ImGui::IsMouseHoveringRect`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_hovering_rect_ex(r_min: impl Into<ImVec2>, r_max: impl Into<ImVec2>, clip: bool) -> bool {
    unsafe { sys::ImGui_IsMouseHoveringRectEx(r_min.into(), r_max.into(), clip) }
}
/// `ImGui::IsMousePosValid`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_pos_valid() -> bool {
    unsafe { sys::ImGui_IsMousePosValid() }
}
/// `ImGui::IsMousePosValid`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_pos_valid_ex(mouse_pos: Option<&ImVec2>) -> bool {
    unsafe { sys::ImGui_IsMousePosValidEx(mouse_pos.map_or(core::ptr::null(), |r| r as *const ImVec2)) }
}
/// `ImGui::IsAnyMouseDown`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_any_mouse_down() -> bool {
    unsafe { sys::ImGui_IsAnyMouseDown() }
}
/// `ImGui::GetMousePos`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_mouse_pos() -> ImVec2 {
    unsafe { sys::ImGui_GetMousePos() }
}
/// `ImGui::GetMousePosOnOpeningCurrentPopup`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_mouse_pos_on_opening_current_popup() -> ImVec2 {
    unsafe { sys::ImGui_GetMousePosOnOpeningCurrentPopup() }
}
/// `ImGui::IsMouseDragging`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_dragging(button: ImGuiMouseButton) -> bool {
    unsafe { sys::ImGui_IsMouseDragging(button) }
}
/// `ImGui::IsMouseDragging`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn is_mouse_dragging_ex(button: ImGuiMouseButton, lock_threshold: f32) -> bool {
    unsafe { sys::ImGui_IsMouseDraggingEx(button, lock_threshold) }
}
/// `ImGui::GetMouseDragDelta`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_mouse_drag_delta() -> ImVec2 {
    unsafe { sys::ImGui_GetMouseDragDelta() }
}
/// `ImGui::GetMouseDragDelta`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_mouse_drag_delta_ex(button: ImGuiMouseButton, lock_threshold: f32) -> ImVec2 {
    unsafe { sys::ImGui_GetMouseDragDeltaEx(button, lock_threshold) }
}
/// `ImGui::ResetMouseDragDelta`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn reset_mouse_drag_delta() {
    unsafe { sys::ImGui_ResetMouseDragDelta() }
}
/// `ImGui::ResetMouseDragDelta`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn reset_mouse_drag_delta_ex(button: ImGuiMouseButton) {
    unsafe { sys::ImGui_ResetMouseDragDeltaEx(button) }
}
/// `ImGui::GetMouseCursor`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_mouse_cursor() -> ImGuiMouseCursor {
    unsafe { sys::ImGui_GetMouseCursor() }
}
/// `ImGui::SetMouseCursor`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_mouse_cursor(cursor_type: ImGuiMouseCursor) {
    unsafe { sys::ImGui_SetMouseCursor(cursor_type) }
}
/// `ImGui::SetNextFrameWantCaptureMouse`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_next_frame_want_capture_mouse(want_capture_mouse: bool) {
    unsafe { sys::ImGui_SetNextFrameWantCaptureMouse(want_capture_mouse) }
}
/// `ImGui::GetClipboardText`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn get_clipboard_text() -> &'static str {
    unsafe { crate::from_cstr(sys::ImGui_GetClipboardText()) }
}
/// `ImGui::SetClipboardText`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn set_clipboard_text(text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_SetClipboardText(__text.as_ptr()) }
}
/// `ImGui::LoadIniSettingsFromDisk`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn load_ini_settings_from_disk(ini_filename: &str) {
    let __ini_filename = crate::cs(ini_filename);
    unsafe { sys::ImGui_LoadIniSettingsFromDisk(__ini_filename.as_ptr()) }
}
/// `ImGui::LoadIniSettingsFromMemory`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn load_ini_settings_from_memory(ini_data: &str) {
    let __ini_data = crate::cs(ini_data);
    unsafe { sys::ImGui_LoadIniSettingsFromMemory(__ini_data.as_ptr()) }
}
/// `ImGui::LoadIniSettingsFromMemory`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn load_ini_settings_from_memory_ex(ini_data: &str, ini_size: usize) {
    let __ini_data = crate::cs(ini_data);
    unsafe { sys::ImGui_LoadIniSettingsFromMemoryEx(__ini_data.as_ptr(), ini_size) }
}
/// `ImGui::SaveIniSettingsToDisk`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn save_ini_settings_to_disk(ini_filename: &str) {
    let __ini_filename = crate::cs(ini_filename);
    unsafe { sys::ImGui_SaveIniSettingsToDisk(__ini_filename.as_ptr()) }
}
/// `ImGui::SaveIniSettingsToMemory`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn save_ini_settings_to_memory() -> &'static str {
    unsafe { crate::from_cstr(sys::ImGui_SaveIniSettingsToMemory()) }
}
/// `ImGui::SaveIniSettingsToMemory`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn save_ini_settings_to_memory_ex(out_ini_size: Option<&mut usize>) -> &'static str {
    unsafe { crate::from_cstr(sys::ImGui_SaveIniSettingsToMemoryEx(out_ini_size.map_or(core::ptr::null_mut(), |r| r as *mut usize))) }
}
/// `ImGui::DebugTextEncoding`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn debug_text_encoding(text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_DebugTextEncoding(__text.as_ptr()) }
}
/// `ImGui::DebugFlashStyleColor`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn debug_flash_style_color(idx: ImGuiCol) {
    unsafe { sys::ImGui_DebugFlashStyleColor(idx) }
}
/// `ImGui::DebugStartItemPicker`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn debug_start_item_picker() {
    unsafe { sys::ImGui_DebugStartItemPicker() }
}
/// `ImGui::DebugCheckVersionAndDataLayout`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn debug_check_version_and_data_layout(version_str: &str, sz_io: usize, sz_style: usize, sz_vec2: usize, sz_vec4: usize, sz_drawvert: usize, sz_drawidx: usize) -> bool {
    let __version_str = crate::cs(version_str);
    unsafe { sys::ImGui_DebugCheckVersionAndDataLayout(__version_str.as_ptr(), sz_io, sz_style, sz_vec2, sz_vec4, sz_drawvert, sz_drawidx) }
}
/// `ImGui::DebugLog`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn debug_log(text: &str) {
    let __text = crate::cs(text);
    unsafe { sys::ImGui_DebugLog(c"%s".as_ptr(), __text.as_ptr()) }
}
/// `ImGui::MemAlloc`
#[allow(clippy::too_many_arguments, unused_unsafe)]
pub fn mem_alloc(size: usize) -> *mut c_void {
    unsafe { sys::ImGui_MemAlloc(size) }
}
impl ImVec2 {
    /// `ImVec2::ImVec2`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImVec2> {
        unsafe { crate::Owned::from_raw(sys::ImVec2_New()) }
    }
    /// `ImVec2::ImVec2`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new_float(_x: f32, _y: f32) -> crate::Owned<ImVec2> {
        unsafe { crate::Owned::from_raw(sys::ImVec2_NewFloat(_x, _y)) }
    }
}
impl crate::Delete for ImVec2 {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImVec2_Delete(p) } }
}
impl ImVec4 {
    /// `ImVec4::ImVec4`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImVec4> {
        unsafe { crate::Owned::from_raw(sys::ImVec4_New()) }
    }
    /// `ImVec4::ImVec4`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new_float(_x: f32, _y: f32, _z: f32, _w: f32) -> crate::Owned<ImVec4> {
        unsafe { crate::Owned::from_raw(sys::ImVec4_NewFloat(_x, _y, _z, _w)) }
    }
}
impl crate::Delete for ImVec4 {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImVec4_Delete(p) } }
}
impl ImTextureRef {
    /// `ImTextureRef::ImTextureRef`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImTextureRef> {
        unsafe { crate::Owned::from_raw(sys::ImTextureRef_New()) }
    }
    /// `ImTextureRef::ImTextureRef`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new_texture_id(tex_id: ImTextureID) -> crate::Owned<ImTextureRef> {
        unsafe { crate::Owned::from_raw(sys::ImTextureRef_NewTextureID(tex_id)) }
    }
    /// `ImTextureRef::GetTexID`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_tex_id(&self) -> ImTextureID {
        unsafe { sys::ImTextureRef_GetTexID(self as *const Self) }
    }
}
impl crate::Delete for ImTextureRef {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImTextureRef_Delete(p) } }
}
impl ImGuiTableSortSpecs {
    /// `ImGuiTableSortSpecs::ImGuiTableSortSpecs`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiTableSortSpecs> {
        unsafe { crate::Owned::from_raw(sys::ImGuiTableSortSpecs_New()) }
    }
}
impl crate::Delete for ImGuiTableSortSpecs {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiTableSortSpecs_Delete(p) } }
}
impl ImGuiTableColumnSortSpecs {
    /// `ImGuiTableColumnSortSpecs::ImGuiTableColumnSortSpecs`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiTableColumnSortSpecs> {
        unsafe { crate::Owned::from_raw(sys::ImGuiTableColumnSortSpecs_New()) }
    }
}
impl crate::Delete for ImGuiTableColumnSortSpecs {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiTableColumnSortSpecs_Delete(p) } }
}
impl ImGuiStyle {
    /// `ImGuiStyle::ImGuiStyle`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiStyle> {
        unsafe { crate::Owned::from_raw(sys::ImGuiStyle_New()) }
    }
    /// `ImGuiStyle::ScaleAllSizes`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn scale_all_sizes(&mut self, scale_factor: f32) {
        unsafe { sys::ImGuiStyle_ScaleAllSizes(self as *mut Self, scale_factor) }
    }
}
impl crate::Delete for ImGuiStyle {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiStyle_Delete(p) } }
}
impl ImGuiKeyData {
    /// `ImGuiKeyData::ImGuiKeyData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiKeyData> {
        unsafe { crate::Owned::from_raw(sys::ImGuiKeyData_New()) }
    }
}
impl crate::Delete for ImGuiKeyData {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiKeyData_Delete(p) } }
}
impl ImGuiIO {
    /// `ImGuiIO::ImGuiIO`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiIO> {
        unsafe { crate::Owned::from_raw(sys::ImGuiIO_New()) }
    }
    /// `ImGuiIO::AddKeyEvent`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_key_event(&mut self, key: ImGuiKey, down: bool) {
        unsafe { sys::ImGuiIO_AddKeyEvent(self as *mut Self, key, down) }
    }
    /// `ImGuiIO::AddKeyAnalogEvent`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_key_analog_event(&mut self, key: ImGuiKey, down: bool, v: f32) {
        unsafe { sys::ImGuiIO_AddKeyAnalogEvent(self as *mut Self, key, down, v) }
    }
    /// `ImGuiIO::AddMousePosEvent`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_mouse_pos_event(&mut self, x: f32, y: f32) {
        unsafe { sys::ImGuiIO_AddMousePosEvent(self as *mut Self, x, y) }
    }
    /// `ImGuiIO::AddMouseButtonEvent`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_mouse_button_event(&mut self, button: c_int, down: bool) {
        unsafe { sys::ImGuiIO_AddMouseButtonEvent(self as *mut Self, button, down) }
    }
    /// `ImGuiIO::AddMouseWheelEvent`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_mouse_wheel_event(&mut self, wheel_x: f32, wheel_y: f32) {
        unsafe { sys::ImGuiIO_AddMouseWheelEvent(self as *mut Self, wheel_x, wheel_y) }
    }
    /// `ImGuiIO::AddMouseSourceEvent`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_mouse_source_event(&mut self, source: ImGuiMouseSource) {
        unsafe { sys::ImGuiIO_AddMouseSourceEvent(self as *mut Self, source) }
    }
    /// `ImGuiIO::AddFocusEvent`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_focus_event(&mut self, focused: bool) {
        unsafe { sys::ImGuiIO_AddFocusEvent(self as *mut Self, focused) }
    }
    /// `ImGuiIO::AddInputCharacter`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_input_character(&mut self, c: c_uint) {
        unsafe { sys::ImGuiIO_AddInputCharacter(self as *mut Self, c) }
    }
    /// `ImGuiIO::AddInputCharacterUTF16`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_input_character_utf16(&mut self, c: ImWchar16) {
        unsafe { sys::ImGuiIO_AddInputCharacterUTF16(self as *mut Self, c) }
    }
    /// `ImGuiIO::AddInputCharactersUTF8`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_input_characters_utf8(&mut self, str: &str) {
        let __str = crate::cs(str);
        unsafe { sys::ImGuiIO_AddInputCharactersUTF8(self as *mut Self, __str.as_ptr()) }
    }
    /// `ImGuiIO::SetKeyEventNativeData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_key_event_native_data(&mut self, key: ImGuiKey, native_keycode: c_int, native_scancode: c_int) {
        unsafe { sys::ImGuiIO_SetKeyEventNativeData(self as *mut Self, key, native_keycode, native_scancode) }
    }
    /// `ImGuiIO::SetKeyEventNativeData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_key_event_native_data_ex(&mut self, key: ImGuiKey, native_keycode: c_int, native_scancode: c_int, native_legacy_index: c_int) {
        unsafe { sys::ImGuiIO_SetKeyEventNativeDataEx(self as *mut Self, key, native_keycode, native_scancode, native_legacy_index) }
    }
    /// `ImGuiIO::SetAppAcceptingEvents`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_app_accepting_events(&mut self, accepting_events: bool) {
        unsafe { sys::ImGuiIO_SetAppAcceptingEvents(self as *mut Self, accepting_events) }
    }
    /// `ImGuiIO::ClearEventsQueue`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_events_queue(&mut self) {
        unsafe { sys::ImGuiIO_ClearEventsQueue(self as *mut Self) }
    }
    /// `ImGuiIO::ClearInputKeys`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_input_keys(&mut self) {
        unsafe { sys::ImGuiIO_ClearInputKeys(self as *mut Self) }
    }
    /// `ImGuiIO::ClearInputMouse`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_input_mouse(&mut self) {
        unsafe { sys::ImGuiIO_ClearInputMouse(self as *mut Self) }
    }
}
impl crate::Delete for ImGuiIO {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiIO_Delete(p) } }
}
impl ImGuiInputTextCallbackData {
    /// `ImGuiInputTextCallbackData::ImGuiInputTextCallbackData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiInputTextCallbackData> {
        unsafe { crate::Owned::from_raw(sys::ImGuiInputTextCallbackData_New()) }
    }
    /// `ImGuiInputTextCallbackData::DeleteChars`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn delete_chars(&mut self, pos: c_int, bytes_count: c_int) {
        unsafe { sys::ImGuiInputTextCallbackData_DeleteChars(self as *mut Self, pos, bytes_count) }
    }
    /// `ImGuiInputTextCallbackData::InsertChars`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn insert_chars(&mut self, pos: c_int, text: &str) {
        let __text = crate::cs(text);
        unsafe { sys::ImGuiInputTextCallbackData_InsertChars(self as *mut Self, pos, __text.as_ptr()) }
    }
    /// `ImGuiInputTextCallbackData::InsertChars`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn insert_chars_ex(&mut self, pos: c_int, text: &str, text_end: Option<&str>) {
        let __text = crate::cs(text);
        let __text_end = text_end.map(crate::cs);
        unsafe { sys::ImGuiInputTextCallbackData_InsertCharsEx(self as *mut Self, pos, __text.as_ptr(), __text_end.as_ref().map_or(core::ptr::null(), |s| s.as_ptr())) }
    }
    /// `ImGuiInputTextCallbackData::SelectAll`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn select_all(&mut self) {
        unsafe { sys::ImGuiInputTextCallbackData_SelectAll(self as *mut Self) }
    }
    /// `ImGuiInputTextCallbackData::SetSelection`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_selection(&mut self, s: c_int, e: c_int) {
        unsafe { sys::ImGuiInputTextCallbackData_SetSelection(self as *mut Self, s, e) }
    }
    /// `ImGuiInputTextCallbackData::ClearSelection`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_selection(&mut self) {
        unsafe { sys::ImGuiInputTextCallbackData_ClearSelection(self as *mut Self) }
    }
    /// `ImGuiInputTextCallbackData::HasSelection`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn has_selection(&self) -> bool {
        unsafe { sys::ImGuiInputTextCallbackData_HasSelection(self as *const Self) }
    }
}
impl crate::Delete for ImGuiInputTextCallbackData {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiInputTextCallbackData_Delete(p) } }
}
impl ImGuiSizeCallbackData {
    /// `ImGuiSizeCallbackData::ImGuiSizeCallbackData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiSizeCallbackData> {
        unsafe { crate::Owned::from_raw(sys::ImGuiSizeCallbackData_New()) }
    }
}
impl crate::Delete for ImGuiSizeCallbackData {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiSizeCallbackData_Delete(p) } }
}
impl ImGuiPayload {
    /// `ImGuiPayload::ImGuiPayload`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiPayload> {
        unsafe { crate::Owned::from_raw(sys::ImGuiPayload_New()) }
    }
    /// `ImGuiPayload::Clear`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear(&mut self) {
        unsafe { sys::ImGuiPayload_Clear(self as *mut Self) }
    }
    /// `ImGuiPayload::IsDataType`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn is_data_type(&self, r#type: &str) -> bool {
        let __type = crate::cs(r#type);
        unsafe { sys::ImGuiPayload_IsDataType(self as *const Self, __type.as_ptr()) }
    }
    /// `ImGuiPayload::IsPreview`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn is_preview(&self) -> bool {
        unsafe { sys::ImGuiPayload_IsPreview(self as *const Self) }
    }
    /// `ImGuiPayload::IsDelivery`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn is_delivery(&self) -> bool {
        unsafe { sys::ImGuiPayload_IsDelivery(self as *const Self) }
    }
}
impl crate::Delete for ImGuiPayload {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiPayload_Delete(p) } }
}
impl ImGuiOnceUponAFrame {
    /// `ImGuiOnceUponAFrame::ImGuiOnceUponAFrame`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiOnceUponAFrame> {
        unsafe { crate::Owned::from_raw(sys::ImGuiOnceUponAFrame_New()) }
    }
}
impl crate::Delete for ImGuiOnceUponAFrame {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiOnceUponAFrame_Delete(p) } }
}
impl ImGuiTextFilter {
    /// `ImGuiTextFilter::ImGuiTextFilter`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiTextFilter> {
        unsafe { crate::Owned::from_raw(sys::ImGuiTextFilter_New()) }
    }
    /// `ImGuiTextFilter::ImGuiTextFilter`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new_ex(default_filter: &str) -> crate::Owned<ImGuiTextFilter> {
        let __default_filter = crate::cs(default_filter);
        unsafe { crate::Owned::from_raw(sys::ImGuiTextFilter_NewEx(__default_filter.as_ptr())) }
    }
    /// `ImGuiTextFilter::PassFilter`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn pass_filter(&self, text: &str) -> bool {
        let __text = crate::cs(text);
        unsafe { sys::ImGuiTextFilter_PassFilter(self as *const Self, __text.as_ptr()) }
    }
    /// `ImGuiTextFilter::PassFilter`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn pass_filter_ex(&self, text: &str, text_end: Option<&str>) -> bool {
        let __text = crate::cs(text);
        let __text_end = text_end.map(crate::cs);
        unsafe { sys::ImGuiTextFilter_PassFilterEx(self as *const Self, __text.as_ptr(), __text_end.as_ref().map_or(core::ptr::null(), |s| s.as_ptr())) }
    }
    /// `ImGuiTextFilter::Build`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn build(&mut self) {
        unsafe { sys::ImGuiTextFilter_Build(self as *mut Self) }
    }
    /// `ImGuiTextFilter::Clear`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear(&mut self) {
        unsafe { sys::ImGuiTextFilter_Clear(self as *mut Self) }
    }
    /// `ImGuiTextFilter::IsActive`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn is_active(&self) -> bool {
        unsafe { sys::ImGuiTextFilter_IsActive(self as *const Self) }
    }
    /// `ImGuiTextFilter::Draw`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn draw(&mut self) -> bool {
        unsafe { sys::ImGuiTextFilter_Draw(self as *mut Self) }
    }
    /// `ImGuiTextFilter::Draw`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn draw_ex(&mut self, label: &str) -> bool {
        let __label = crate::cs(label);
        unsafe { sys::ImGuiTextFilter_DrawEx(self as *mut Self, __label.as_ptr()) }
    }
    /// `ImGuiTextFilter::DrawWithHint`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn draw_with_hint(&mut self) -> bool {
        unsafe { sys::ImGuiTextFilter_DrawWithHint(self as *mut Self) }
    }
    /// `ImGuiTextFilter::DrawWithHint`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn draw_with_hint_ex(&mut self, label: &str, hint: &str) -> bool {
        let __label = crate::cs(label);
        let __hint = crate::cs(hint);
        unsafe { sys::ImGuiTextFilter_DrawWithHintEx(self as *mut Self, __label.as_ptr(), __hint.as_ptr()) }
    }
}
impl crate::Delete for ImGuiTextFilter {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiTextFilter_Delete(p) } }
}
impl ImGuiTextBuffer {
    /// `ImGuiTextBuffer::ImGuiTextBuffer`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiTextBuffer> {
        unsafe { crate::Owned::from_raw(sys::ImGuiTextBuffer_New()) }
    }
    /// `ImGuiTextBuffer::begin`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn begin(&self) -> &'static str {
        unsafe { crate::from_cstr(sys::ImGuiTextBuffer_begin(self as *const Self)) }
    }
    /// `ImGuiTextBuffer::end`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn end(&self) -> &'static str {
        unsafe { crate::from_cstr(sys::ImGuiTextBuffer_end(self as *const Self)) }
    }
    /// `ImGuiTextBuffer::size`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn size(&self) -> c_int {
        unsafe { sys::ImGuiTextBuffer_size(self as *const Self) }
    }
    /// `ImGuiTextBuffer::empty`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn empty(&self) -> bool {
        unsafe { sys::ImGuiTextBuffer_empty(self as *const Self) }
    }
    /// `ImGuiTextBuffer::clear`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear(&mut self) {
        unsafe { sys::ImGuiTextBuffer_clear(self as *mut Self) }
    }
    /// `ImGuiTextBuffer::resize`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn resize(&mut self, size: c_int) {
        unsafe { sys::ImGuiTextBuffer_resize(self as *mut Self, size) }
    }
    /// `ImGuiTextBuffer::reserve`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn reserve(&mut self, capacity: c_int) {
        unsafe { sys::ImGuiTextBuffer_reserve(self as *mut Self, capacity) }
    }
    /// `ImGuiTextBuffer::c_str`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn c_str(&self) -> &'static str {
        unsafe { crate::from_cstr(sys::ImGuiTextBuffer_c_str(self as *const Self)) }
    }
    /// `ImGuiTextBuffer::append`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn append(&mut self, str: &str) {
        let __str = crate::cs(str);
        unsafe { sys::ImGuiTextBuffer_append(self as *mut Self, __str.as_ptr()) }
    }
    /// `ImGuiTextBuffer::append`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn append_ex(&mut self, str: &str, str_end: Option<&str>) {
        let __str = crate::cs(str);
        let __str_end = str_end.map(crate::cs);
        unsafe { sys::ImGuiTextBuffer_appendEx(self as *mut Self, __str.as_ptr(), __str_end.as_ref().map_or(core::ptr::null(), |s| s.as_ptr())) }
    }
    /// `ImGuiTextBuffer::appendf`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn appendf(&mut self, text: &str) {
        let __text = crate::cs(text);
        unsafe { sys::ImGuiTextBuffer_appendf(self as *mut Self, c"%s".as_ptr(), __text.as_ptr()) }
    }
}
impl crate::Delete for ImGuiTextBuffer {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiTextBuffer_Delete(p) } }
}
impl ImGuiStoragePair {
    /// `ImGuiStoragePair::ImGuiStoragePair`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new(_key: ImGuiID, _val: c_int) -> crate::Owned<ImGuiStoragePair> {
        unsafe { crate::Owned::from_raw(sys::ImGuiStoragePair_New(_key, _val)) }
    }
    /// `ImGuiStoragePair::ImGuiStoragePair`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new_float(_key: ImGuiID, _val: f32) -> crate::Owned<ImGuiStoragePair> {
        unsafe { crate::Owned::from_raw(sys::ImGuiStoragePair_NewFloat(_key, _val)) }
    }
}
impl crate::Delete for ImGuiStoragePair {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiStoragePair_Delete(p) } }
}
impl ImGuiStorage {
    /// `ImGuiStorage::ImGuiStorage`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiStorage> {
        unsafe { crate::Owned::from_raw(sys::ImGuiStorage_New()) }
    }
    /// `ImGuiStorage::Clear`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear(&mut self) {
        unsafe { sys::ImGuiStorage_Clear(self as *mut Self) }
    }
    /// `ImGuiStorage::GetInt`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_int(&self, key: ImGuiID) -> c_int {
        unsafe { sys::ImGuiStorage_GetInt(self as *const Self, key) }
    }
    /// `ImGuiStorage::GetInt`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_int_ex(&self, key: ImGuiID, default_val: c_int) -> c_int {
        unsafe { sys::ImGuiStorage_GetIntEx(self as *const Self, key, default_val) }
    }
    /// `ImGuiStorage::SetInt`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_int(&mut self, key: ImGuiID, val: c_int) {
        unsafe { sys::ImGuiStorage_SetInt(self as *mut Self, key, val) }
    }
    /// `ImGuiStorage::GetBool`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_bool(&self, key: ImGuiID) -> bool {
        unsafe { sys::ImGuiStorage_GetBool(self as *const Self, key) }
    }
    /// `ImGuiStorage::GetBool`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_bool_ex(&self, key: ImGuiID, default_val: bool) -> bool {
        unsafe { sys::ImGuiStorage_GetBoolEx(self as *const Self, key, default_val) }
    }
    /// `ImGuiStorage::SetBool`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_bool(&mut self, key: ImGuiID, val: bool) {
        unsafe { sys::ImGuiStorage_SetBool(self as *mut Self, key, val) }
    }
    /// `ImGuiStorage::GetFloat`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_float(&self, key: ImGuiID) -> f32 {
        unsafe { sys::ImGuiStorage_GetFloat(self as *const Self, key) }
    }
    /// `ImGuiStorage::GetFloat`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_float_ex(&self, key: ImGuiID, default_val: f32) -> f32 {
        unsafe { sys::ImGuiStorage_GetFloatEx(self as *const Self, key, default_val) }
    }
    /// `ImGuiStorage::SetFloat`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_float(&mut self, key: ImGuiID, val: f32) {
        unsafe { sys::ImGuiStorage_SetFloat(self as *mut Self, key, val) }
    }
    /// `ImGuiStorage::GetVoidPtr`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_void_ptr(&self, key: ImGuiID) -> *mut c_void {
        unsafe { sys::ImGuiStorage_GetVoidPtr(self as *const Self, key) }
    }
    /// `ImGuiStorage::GetIntRef`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_int_ref(&mut self, key: ImGuiID) -> *mut c_int {
        unsafe { sys::ImGuiStorage_GetIntRef(self as *mut Self, key) }
    }
    /// `ImGuiStorage::GetIntRef`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_int_ref_ex(&mut self, key: ImGuiID, default_val: c_int) -> *mut c_int {
        unsafe { sys::ImGuiStorage_GetIntRefEx(self as *mut Self, key, default_val) }
    }
    /// `ImGuiStorage::GetBoolRef`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_bool_ref(&mut self, key: ImGuiID) -> *mut bool {
        unsafe { sys::ImGuiStorage_GetBoolRef(self as *mut Self, key) }
    }
    /// `ImGuiStorage::GetBoolRef`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_bool_ref_ex(&mut self, key: ImGuiID, default_val: bool) -> *mut bool {
        unsafe { sys::ImGuiStorage_GetBoolRefEx(self as *mut Self, key, default_val) }
    }
    /// `ImGuiStorage::GetFloatRef`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_float_ref(&mut self, key: ImGuiID) -> *mut f32 {
        unsafe { sys::ImGuiStorage_GetFloatRef(self as *mut Self, key) }
    }
    /// `ImGuiStorage::GetFloatRef`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_float_ref_ex(&mut self, key: ImGuiID, default_val: f32) -> *mut f32 {
        unsafe { sys::ImGuiStorage_GetFloatRefEx(self as *mut Self, key, default_val) }
    }
    /// `ImGuiStorage::GetVoidPtrRef`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_void_ptr_ref(&mut self, key: ImGuiID) -> *mut *mut c_void {
        unsafe { sys::ImGuiStorage_GetVoidPtrRef(self as *mut Self, key) }
    }
    /// `ImGuiStorage::GetVoidPtrRef`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_void_ptr_ref_ex(&mut self, key: ImGuiID) -> *mut *mut c_void {
        unsafe { sys::ImGuiStorage_GetVoidPtrRefEx(self as *mut Self, key, core::ptr::null_mut()) }
    }
    /// `ImGuiStorage::BuildSortByKey`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn build_sort_by_key(&mut self) {
        unsafe { sys::ImGuiStorage_BuildSortByKey(self as *mut Self) }
    }
    /// `ImGuiStorage::SetAllInt`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_all_int(&mut self, val: c_int) {
        unsafe { sys::ImGuiStorage_SetAllInt(self as *mut Self, val) }
    }
}
impl crate::Delete for ImGuiStorage {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiStorage_Delete(p) } }
}
impl ImGuiListClipper {
    /// `ImGuiListClipper::ImGuiListClipper`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiListClipper> {
        unsafe { crate::Owned::from_raw(sys::ImGuiListClipper_New()) }
    }
    /// `ImGuiListClipper::Begin`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn begin(&mut self, items_count: c_int) {
        unsafe { sys::ImGuiListClipper_Begin(self as *mut Self, items_count) }
    }
    /// `ImGuiListClipper::Begin`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn begin_ex(&mut self, items_count: c_int, items_height: f32) {
        unsafe { sys::ImGuiListClipper_BeginEx(self as *mut Self, items_count, items_height) }
    }
    /// `ImGuiListClipper::End`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn end(&mut self) {
        unsafe { sys::ImGuiListClipper_End(self as *mut Self) }
    }
    /// `ImGuiListClipper::Step`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn step(&mut self) -> bool {
        unsafe { sys::ImGuiListClipper_Step(self as *mut Self) }
    }
    /// `ImGuiListClipper::IncludeItemByIndex`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn include_item_by_index(&mut self, item_index: c_int) {
        unsafe { sys::ImGuiListClipper_IncludeItemByIndex(self as *mut Self, item_index) }
    }
    /// `ImGuiListClipper::IncludeItemsByIndex`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn include_items_by_index(&mut self, item_begin: c_int, item_end: c_int) {
        unsafe { sys::ImGuiListClipper_IncludeItemsByIndex(self as *mut Self, item_begin, item_end) }
    }
    /// `ImGuiListClipper::SeekCursorForItem`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn seek_cursor_for_item(&mut self, item_index: c_int) {
        unsafe { sys::ImGuiListClipper_SeekCursorForItem(self as *mut Self, item_index) }
    }
}
impl crate::Delete for ImGuiListClipper {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiListClipper_Delete(p) } }
}
impl ImColor {
    /// `ImColor::ImColor`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImColor> {
        unsafe { crate::Owned::from_raw(sys::ImColor_New()) }
    }
    /// `ImColor::ImColor`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new_float(r: f32, g: f32, b: f32) -> crate::Owned<ImColor> {
        unsafe { crate::Owned::from_raw(sys::ImColor_NewFloat(r, g, b)) }
    }
    /// `ImColor::ImColor`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new_float_ex(r: f32, g: f32, b: f32, a: f32) -> crate::Owned<ImColor> {
        unsafe { crate::Owned::from_raw(sys::ImColor_NewFloatEx(r, g, b, a)) }
    }
    /// `ImColor::ImColor`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new_vec4(col: impl Into<ImVec4>) -> crate::Owned<ImColor> {
        unsafe { crate::Owned::from_raw(sys::ImColor_NewVec4(col.into())) }
    }
    /// `ImColor::ImColor`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new_int(r: c_int, g: c_int, b: c_int) -> crate::Owned<ImColor> {
        unsafe { crate::Owned::from_raw(sys::ImColor_NewInt(r, g, b)) }
    }
    /// `ImColor::ImColor`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new_int_ex(r: c_int, g: c_int, b: c_int, a: c_int) -> crate::Owned<ImColor> {
        unsafe { crate::Owned::from_raw(sys::ImColor_NewIntEx(r, g, b, a)) }
    }
    /// `ImColor::ImColor`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new_u32(rgba: ImU32) -> crate::Owned<ImColor> {
        unsafe { crate::Owned::from_raw(sys::ImColor_NewU32(rgba)) }
    }
    /// `ImColor::SetHSV`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_hsv(&mut self, h: f32, s: f32, v: f32) {
        unsafe { sys::ImColor_SetHSV(self as *mut Self, h, s, v) }
    }
    /// `ImColor::SetHSV`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_hsv_ex(&mut self, h: f32, s: f32, v: f32, a: f32) {
        unsafe { sys::ImColor_SetHSVEx(self as *mut Self, h, s, v, a) }
    }
    /// `ImColor::HSV`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn hsv(h: f32, s: f32, v: f32) -> ImColor {
        unsafe { sys::ImColor_HSV(h, s, v) }
    }
    /// `ImColor::HSV`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn hsv_ex(h: f32, s: f32, v: f32, a: f32) -> ImColor {
        unsafe { sys::ImColor_HSVEx(h, s, v, a) }
    }
}
impl crate::Delete for ImColor {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImColor_Delete(p) } }
}
impl ImGuiMultiSelectIO {
    /// `ImGuiMultiSelectIO::ImGuiMultiSelectIO`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiMultiSelectIO> {
        unsafe { crate::Owned::from_raw(sys::ImGuiMultiSelectIO_New()) }
    }
}
impl crate::Delete for ImGuiMultiSelectIO {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiMultiSelectIO_Delete(p) } }
}
impl ImGuiSelectionRequest {
    /// `ImGuiSelectionRequest::ImGuiSelectionRequest`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiSelectionRequest> {
        unsafe { crate::Owned::from_raw(sys::ImGuiSelectionRequest_New()) }
    }
}
impl crate::Delete for ImGuiSelectionRequest {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiSelectionRequest_Delete(p) } }
}
impl ImGuiSelectionBasicStorage {
    /// `ImGuiSelectionBasicStorage::ImGuiSelectionBasicStorage`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiSelectionBasicStorage> {
        unsafe { crate::Owned::from_raw(sys::ImGuiSelectionBasicStorage_New()) }
    }
    /// `ImGuiSelectionBasicStorage::ApplyRequests`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn apply_requests(&mut self, ms_io: &mut ImGuiMultiSelectIO) {
        unsafe { sys::ImGuiSelectionBasicStorage_ApplyRequests(self as *mut Self, ms_io as *mut ImGuiMultiSelectIO) }
    }
    /// `ImGuiSelectionBasicStorage::Contains`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn contains(&self, id: ImGuiID) -> bool {
        unsafe { sys::ImGuiSelectionBasicStorage_Contains(self as *const Self, id) }
    }
    /// `ImGuiSelectionBasicStorage::Clear`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear(&mut self) {
        unsafe { sys::ImGuiSelectionBasicStorage_Clear(self as *mut Self) }
    }
    /// `ImGuiSelectionBasicStorage::Swap`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn swap(&mut self, r: &mut ImGuiSelectionBasicStorage) {
        unsafe { sys::ImGuiSelectionBasicStorage_Swap(self as *mut Self, r as *mut ImGuiSelectionBasicStorage) }
    }
    /// `ImGuiSelectionBasicStorage::SetItemSelected`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_item_selected(&mut self, id: ImGuiID, selected: bool) {
        unsafe { sys::ImGuiSelectionBasicStorage_SetItemSelected(self as *mut Self, id, selected) }
    }
    /// `ImGuiSelectionBasicStorage::GetStorageIdFromIndex`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_storage_id_from_index(&mut self, idx: c_int) -> ImGuiID {
        unsafe { sys::ImGuiSelectionBasicStorage_GetStorageIdFromIndex(self as *mut Self, idx) }
    }
}
impl crate::Delete for ImGuiSelectionBasicStorage {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiSelectionBasicStorage_Delete(p) } }
}
impl ImGuiSelectionExternalStorage {
    /// `ImGuiSelectionExternalStorage::ImGuiSelectionExternalStorage`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiSelectionExternalStorage> {
        unsafe { crate::Owned::from_raw(sys::ImGuiSelectionExternalStorage_New()) }
    }
    /// `ImGuiSelectionExternalStorage::ApplyRequests`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn apply_requests(&mut self, ms_io: &mut ImGuiMultiSelectIO) {
        unsafe { sys::ImGuiSelectionExternalStorage_ApplyRequests(self as *mut Self, ms_io as *mut ImGuiMultiSelectIO) }
    }
}
impl crate::Delete for ImGuiSelectionExternalStorage {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiSelectionExternalStorage_Delete(p) } }
}
impl ImDrawCmd {
    /// `ImDrawCmd::ImDrawCmd`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImDrawCmd> {
        unsafe { crate::Owned::from_raw(sys::ImDrawCmd_New()) }
    }
    /// `ImDrawCmd::GetTexID`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_tex_id(&self) -> ImTextureID {
        unsafe { sys::ImDrawCmd_GetTexID(self as *const Self) }
    }
}
impl crate::Delete for ImDrawCmd {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImDrawCmd_Delete(p) } }
}
impl ImDrawVert {
    /// `ImDrawVert::ImDrawVert`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImDrawVert> {
        unsafe { crate::Owned::from_raw(sys::ImDrawVert_New()) }
    }
}
impl crate::Delete for ImDrawVert {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImDrawVert_Delete(p) } }
}
impl ImDrawCmdHeader {
    /// `ImDrawCmdHeader::ImDrawCmdHeader`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImDrawCmdHeader> {
        unsafe { crate::Owned::from_raw(sys::ImDrawCmdHeader_New()) }
    }
}
impl crate::Delete for ImDrawCmdHeader {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImDrawCmdHeader_Delete(p) } }
}
impl ImDrawChannel {
    /// `ImDrawChannel::ImDrawChannel`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImDrawChannel> {
        unsafe { crate::Owned::from_raw(sys::ImDrawChannel_New()) }
    }
}
impl crate::Delete for ImDrawChannel {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImDrawChannel_Delete(p) } }
}
impl ImDrawListSplitter {
    /// `ImDrawListSplitter::ImDrawListSplitter`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImDrawListSplitter> {
        unsafe { crate::Owned::from_raw(sys::ImDrawListSplitter_New()) }
    }
    /// `ImDrawListSplitter::Clear`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear(&mut self) {
        unsafe { sys::ImDrawListSplitter_Clear(self as *mut Self) }
    }
    /// `ImDrawListSplitter::ClearFreeMemory`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_free_memory(&mut self) {
        unsafe { sys::ImDrawListSplitter_ClearFreeMemory(self as *mut Self) }
    }
    /// `ImDrawListSplitter::Split`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn split(&mut self, draw_list: &mut ImDrawList, count: c_int) {
        unsafe { sys::ImDrawListSplitter_Split(self as *mut Self, draw_list as *mut ImDrawList, count) }
    }
    /// `ImDrawListSplitter::Merge`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn merge(&mut self, draw_list: &mut ImDrawList) {
        unsafe { sys::ImDrawListSplitter_Merge(self as *mut Self, draw_list as *mut ImDrawList) }
    }
    /// `ImDrawListSplitter::SetCurrentChannel`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_current_channel(&mut self, draw_list: &mut ImDrawList, channel_idx: c_int) {
        unsafe { sys::ImDrawListSplitter_SetCurrentChannel(self as *mut Self, draw_list as *mut ImDrawList, channel_idx) }
    }
}
impl crate::Delete for ImDrawListSplitter {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImDrawListSplitter_Delete(p) } }
}
impl ImDrawList {
    /// `ImDrawList::ImDrawList`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new(shared_data: &mut ImDrawListSharedData) -> crate::Owned<ImDrawList> {
        unsafe { crate::Owned::from_raw(sys::ImDrawList_New(shared_data as *mut ImDrawListSharedData)) }
    }
    /// `ImDrawList::PushClipRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn push_clip_rect(&mut self, clip_rect_min: impl Into<ImVec2>, clip_rect_max: impl Into<ImVec2>) {
        unsafe { sys::ImDrawList_PushClipRect(self as *mut Self, clip_rect_min.into(), clip_rect_max.into()) }
    }
    /// `ImDrawList::PushClipRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn push_clip_rect_ex(&mut self, clip_rect_min: impl Into<ImVec2>, clip_rect_max: impl Into<ImVec2>, intersect_with_current_clip_rect: bool) {
        unsafe { sys::ImDrawList_PushClipRectEx(self as *mut Self, clip_rect_min.into(), clip_rect_max.into(), intersect_with_current_clip_rect) }
    }
    /// `ImDrawList::PushClipRectFullScreen`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn push_clip_rect_full_screen(&mut self) {
        unsafe { sys::ImDrawList_PushClipRectFullScreen(self as *mut Self) }
    }
    /// `ImDrawList::PopClipRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn pop_clip_rect(&mut self) {
        unsafe { sys::ImDrawList_PopClipRect(self as *mut Self) }
    }
    /// `ImDrawList::PushTexture`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn push_texture(&mut self, tex_ref: impl Into<ImTextureRef>) {
        unsafe { sys::ImDrawList_PushTexture(self as *mut Self, tex_ref.into()) }
    }
    /// `ImDrawList::PopTexture`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn pop_texture(&mut self) {
        unsafe { sys::ImDrawList_PopTexture(self as *mut Self) }
    }
    /// `ImDrawList::PushDrawFlag`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn push_draw_flag(&mut self, flags: ImDrawFlags, enabled: bool) {
        unsafe { sys::ImDrawList_PushDrawFlag(self as *mut Self, flags, enabled) }
    }
    /// `ImDrawList::PopDrawFlag`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn pop_draw_flag(&mut self) {
        unsafe { sys::ImDrawList_PopDrawFlag(self as *mut Self) }
    }
    /// `ImDrawList::GetClipRectMin`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_clip_rect_min(&self) -> ImVec2 {
        unsafe { sys::ImDrawList_GetClipRectMin(self as *const Self) }
    }
    /// `ImDrawList::GetClipRectMax`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_clip_rect_max(&self) -> ImVec2 {
        unsafe { sys::ImDrawList_GetClipRectMax(self as *const Self) }
    }
    /// `ImDrawList::AddLine`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_line(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_AddLine(self as *mut Self, p1.into(), p2.into(), col) }
    }
    /// `ImDrawList::AddLine`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_line_ex(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, col: ImU32, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddLineEx(self as *mut Self, p1.into(), p2.into(), col, thickness, flags) }
    }
    /// `ImDrawList::AddLineH`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_line_h(&mut self, min_x: f32, max_x: f32, y: f32, col: ImU32) {
        unsafe { sys::ImDrawList_AddLineH(self as *mut Self, min_x, max_x, y, col) }
    }
    /// `ImDrawList::AddLineH`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_line_h_ex(&mut self, min_x: f32, max_x: f32, y: f32, col: ImU32, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddLineHEx(self as *mut Self, min_x, max_x, y, col, thickness, flags) }
    }
    /// `ImDrawList::AddLineV`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_line_v(&mut self, x: f32, min_y: f32, max_y: f32, col: ImU32) {
        unsafe { sys::ImDrawList_AddLineV(self as *mut Self, x, min_y, max_y, col) }
    }
    /// `ImDrawList::AddLineV`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_line_v_ex(&mut self, x: f32, min_y: f32, max_y: f32, col: ImU32, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddLineVEx(self as *mut Self, x, min_y, max_y, col, thickness, flags) }
    }
    /// `ImDrawList::AddRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_rect(&mut self, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_AddRect(self as *mut Self, p_min.into(), p_max.into(), col) }
    }
    /// `ImDrawList::AddRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_rect_ex(&mut self, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>, col: ImU32, rounding: f32, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddRectEx(self as *mut Self, p_min.into(), p_max.into(), col, rounding, thickness, flags) }
    }
    /// `ImDrawList::AddRectFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_rect_filled(&mut self, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_AddRectFilled(self as *mut Self, p_min.into(), p_max.into(), col) }
    }
    /// `ImDrawList::AddRectFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_rect_filled_ex(&mut self, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>, col: ImU32, rounding: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddRectFilledEx(self as *mut Self, p_min.into(), p_max.into(), col, rounding, flags) }
    }
    /// `ImDrawList::AddRectFilledMultiColor`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_rect_filled_multi_color(&mut self, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>, col_upr_left: ImU32, col_upr_right: ImU32, col_bot_right: ImU32, col_bot_left: ImU32) {
        unsafe { sys::ImDrawList_AddRectFilledMultiColor(self as *mut Self, p_min.into(), p_max.into(), col_upr_left, col_upr_right, col_bot_right, col_bot_left) }
    }
    /// `ImDrawList::AddQuad`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_quad(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, p4: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_AddQuad(self as *mut Self, p1.into(), p2.into(), p3.into(), p4.into(), col) }
    }
    /// `ImDrawList::AddQuad`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_quad_ex(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, p4: impl Into<ImVec2>, col: ImU32, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddQuadEx(self as *mut Self, p1.into(), p2.into(), p3.into(), p4.into(), col, thickness, flags) }
    }
    /// `ImDrawList::AddQuadFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_quad_filled(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, p4: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_AddQuadFilled(self as *mut Self, p1.into(), p2.into(), p3.into(), p4.into(), col) }
    }
    /// `ImDrawList::AddTriangle`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_triangle(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_AddTriangle(self as *mut Self, p1.into(), p2.into(), p3.into(), col) }
    }
    /// `ImDrawList::AddTriangle`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_triangle_ex(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, col: ImU32, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddTriangleEx(self as *mut Self, p1.into(), p2.into(), p3.into(), col, thickness, flags) }
    }
    /// `ImDrawList::AddTriangleFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_triangle_filled(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_AddTriangleFilled(self as *mut Self, p1.into(), p2.into(), p3.into(), col) }
    }
    /// `ImDrawList::AddCircle`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_circle(&mut self, center: impl Into<ImVec2>, radius: f32, col: ImU32) {
        unsafe { sys::ImDrawList_AddCircle(self as *mut Self, center.into(), radius, col) }
    }
    /// `ImDrawList::AddCircle`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_circle_ex(&mut self, center: impl Into<ImVec2>, radius: f32, col: ImU32, num_segments: c_int, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddCircleEx(self as *mut Self, center.into(), radius, col, num_segments, thickness, flags) }
    }
    /// `ImDrawList::AddCircleFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_circle_filled(&mut self, center: impl Into<ImVec2>, radius: f32, col: ImU32) {
        unsafe { sys::ImDrawList_AddCircleFilled(self as *mut Self, center.into(), radius, col) }
    }
    /// `ImDrawList::AddCircleFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_circle_filled_ex(&mut self, center: impl Into<ImVec2>, radius: f32, col: ImU32, num_segments: c_int) {
        unsafe { sys::ImDrawList_AddCircleFilledEx(self as *mut Self, center.into(), radius, col, num_segments) }
    }
    /// `ImDrawList::AddNgon`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_ngon(&mut self, center: impl Into<ImVec2>, radius: f32, col: ImU32, num_segments: c_int) {
        unsafe { sys::ImDrawList_AddNgon(self as *mut Self, center.into(), radius, col, num_segments) }
    }
    /// `ImDrawList::AddNgon`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_ngon_ex(&mut self, center: impl Into<ImVec2>, radius: f32, col: ImU32, num_segments: c_int, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddNgonEx(self as *mut Self, center.into(), radius, col, num_segments, thickness, flags) }
    }
    /// `ImDrawList::AddNgonFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_ngon_filled(&mut self, center: impl Into<ImVec2>, radius: f32, col: ImU32, num_segments: c_int) {
        unsafe { sys::ImDrawList_AddNgonFilled(self as *mut Self, center.into(), radius, col, num_segments) }
    }
    /// `ImDrawList::AddEllipse`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_ellipse(&mut self, center: impl Into<ImVec2>, radius: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_AddEllipse(self as *mut Self, center.into(), radius.into(), col) }
    }
    /// `ImDrawList::AddEllipse`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_ellipse_ex(&mut self, center: impl Into<ImVec2>, radius: impl Into<ImVec2>, col: ImU32, rot: f32, num_segments: c_int, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddEllipseEx(self as *mut Self, center.into(), radius.into(), col, rot, num_segments, thickness, flags) }
    }
    /// `ImDrawList::AddEllipseFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_ellipse_filled(&mut self, center: impl Into<ImVec2>, radius: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_AddEllipseFilled(self as *mut Self, center.into(), radius.into(), col) }
    }
    /// `ImDrawList::AddEllipseFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_ellipse_filled_ex(&mut self, center: impl Into<ImVec2>, radius: impl Into<ImVec2>, col: ImU32, rot: f32, num_segments: c_int) {
        unsafe { sys::ImDrawList_AddEllipseFilledEx(self as *mut Self, center.into(), radius.into(), col, rot, num_segments) }
    }
    /// `ImDrawList::AddText`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_text(&mut self, pos: impl Into<ImVec2>, col: ImU32, text_begin: &str) {
        let __text_begin = crate::cs(text_begin);
        unsafe { sys::ImDrawList_AddText(self as *mut Self, pos.into(), col, __text_begin.as_ptr()) }
    }
    /// `ImDrawList::AddText`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_text_ex(&mut self, pos: impl Into<ImVec2>, col: ImU32, text_begin: &str, text_end: Option<&str>) {
        let __text_begin = crate::cs(text_begin);
        let __text_end = text_end.map(crate::cs);
        unsafe { sys::ImDrawList_AddTextEx(self as *mut Self, pos.into(), col, __text_begin.as_ptr(), __text_end.as_ref().map_or(core::ptr::null(), |s| s.as_ptr())) }
    }
    /// `ImDrawList::AddText`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_text_font_ptr(&mut self, font: &mut ImFont, font_size: f32, pos: impl Into<ImVec2>, col: ImU32, text_begin: &str) {
        let __text_begin = crate::cs(text_begin);
        unsafe { sys::ImDrawList_AddTextFontPtr(self as *mut Self, font as *mut ImFont, font_size, pos.into(), col, __text_begin.as_ptr()) }
    }
    /// `ImDrawList::AddText`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_text_font_ptr_ex(&mut self, font: &mut ImFont, font_size: f32, pos: impl Into<ImVec2>, col: ImU32, text_begin: &str, text_end: Option<&str>, wrap_width: f32, cpu_fine_clip_rect: Option<&ImVec4>) {
        let __text_begin = crate::cs(text_begin);
        let __text_end = text_end.map(crate::cs);
        unsafe { sys::ImDrawList_AddTextFontPtrEx(self as *mut Self, font as *mut ImFont, font_size, pos.into(), col, __text_begin.as_ptr(), __text_end.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), wrap_width, cpu_fine_clip_rect.map_or(core::ptr::null(), |r| r as *const ImVec4)) }
    }
    /// `ImDrawList::AddBezierCubic`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_bezier_cubic(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, p4: impl Into<ImVec2>, col: ImU32, thickness: f32) {
        unsafe { sys::ImDrawList_AddBezierCubic(self as *mut Self, p1.into(), p2.into(), p3.into(), p4.into(), col, thickness) }
    }
    /// `ImDrawList::AddBezierCubic`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_bezier_cubic_ex(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, p4: impl Into<ImVec2>, col: ImU32, thickness: f32, num_segments: c_int, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddBezierCubicEx(self as *mut Self, p1.into(), p2.into(), p3.into(), p4.into(), col, thickness, num_segments, flags) }
    }
    /// `ImDrawList::AddBezierQuadratic`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_bezier_quadratic(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, col: ImU32, thickness: f32) {
        unsafe { sys::ImDrawList_AddBezierQuadratic(self as *mut Self, p1.into(), p2.into(), p3.into(), col, thickness) }
    }
    /// `ImDrawList::AddBezierQuadratic`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_bezier_quadratic_ex(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, col: ImU32, thickness: f32, num_segments: c_int, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddBezierQuadraticEx(self as *mut Self, p1.into(), p2.into(), p3.into(), col, thickness, num_segments, flags) }
    }
    /// `ImDrawList::AddPolyline`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_polyline(&mut self, points: &[ImVec2], col: ImU32, thickness: f32) {
        unsafe { sys::ImDrawList_AddPolyline(self as *mut Self, points.as_ptr(), points.len() as c_int, col, thickness) }
    }
    /// `ImDrawList::AddPolyline`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_polyline_ex(&mut self, points: &[ImVec2], col: ImU32, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddPolylineEx(self as *mut Self, points.as_ptr(), points.len() as c_int, col, thickness, flags) }
    }
    /// `ImDrawList::AddConvexPolyFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_convex_poly_filled(&mut self, points: &[ImVec2], col: ImU32) {
        unsafe { sys::ImDrawList_AddConvexPolyFilled(self as *mut Self, points.as_ptr(), points.len() as c_int, col) }
    }
    /// `ImDrawList::AddConvexPolyFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_convex_poly_filled_ex(&mut self, points: &[ImVec2], col: ImU32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddConvexPolyFilledEx(self as *mut Self, points.as_ptr(), points.len() as c_int, col, flags) }
    }
    /// `ImDrawList::AddConcavePolyFilled`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_concave_poly_filled(&mut self, points: &[ImVec2], col: ImU32) {
        unsafe { sys::ImDrawList_AddConcavePolyFilled(self as *mut Self, points.as_ptr(), points.len() as c_int, col) }
    }
    /// `ImDrawList::AddImage`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_image(&mut self, tex_ref: impl Into<ImTextureRef>, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>) {
        unsafe { sys::ImDrawList_AddImage(self as *mut Self, tex_ref.into(), p_min.into(), p_max.into()) }
    }
    /// `ImDrawList::AddImage`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_image_ex(&mut self, tex_ref: impl Into<ImTextureRef>, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>, uv_min: impl Into<ImVec2>, uv_max: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_AddImageEx(self as *mut Self, tex_ref.into(), p_min.into(), p_max.into(), uv_min.into(), uv_max.into(), col) }
    }
    /// `ImDrawList::AddImageQuad`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_image_quad(&mut self, tex_ref: impl Into<ImTextureRef>, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, p4: impl Into<ImVec2>) {
        unsafe { sys::ImDrawList_AddImageQuad(self as *mut Self, tex_ref.into(), p1.into(), p2.into(), p3.into(), p4.into()) }
    }
    /// `ImDrawList::AddImageQuad`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_image_quad_ex(&mut self, tex_ref: impl Into<ImTextureRef>, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, p4: impl Into<ImVec2>, uv1: impl Into<ImVec2>, uv2: impl Into<ImVec2>, uv3: impl Into<ImVec2>, uv4: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_AddImageQuadEx(self as *mut Self, tex_ref.into(), p1.into(), p2.into(), p3.into(), p4.into(), uv1.into(), uv2.into(), uv3.into(), uv4.into(), col) }
    }
    /// `ImDrawList::AddImageRounded`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_image_rounded(&mut self, tex_ref: impl Into<ImTextureRef>, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>, uv_min: impl Into<ImVec2>, uv_max: impl Into<ImVec2>, col: ImU32, rounding: f32) {
        unsafe { sys::ImDrawList_AddImageRounded(self as *mut Self, tex_ref.into(), p_min.into(), p_max.into(), uv_min.into(), uv_max.into(), col, rounding) }
    }
    /// `ImDrawList::AddImageRounded`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_image_rounded_ex(&mut self, tex_ref: impl Into<ImTextureRef>, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>, uv_min: impl Into<ImVec2>, uv_max: impl Into<ImVec2>, col: ImU32, rounding: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_AddImageRoundedEx(self as *mut Self, tex_ref.into(), p_min.into(), p_max.into(), uv_min.into(), uv_max.into(), col, rounding, flags) }
    }
    /// `ImDrawList::PathClear`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_clear(&mut self) {
        unsafe { sys::ImDrawList_PathClear(self as *mut Self) }
    }
    /// `ImDrawList::PathLineTo`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_line_to(&mut self, pos: impl Into<ImVec2>) {
        unsafe { sys::ImDrawList_PathLineTo(self as *mut Self, pos.into()) }
    }
    /// `ImDrawList::PathLineToMergeDuplicate`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_line_to_merge_duplicate(&mut self, pos: impl Into<ImVec2>) {
        unsafe { sys::ImDrawList_PathLineToMergeDuplicate(self as *mut Self, pos.into()) }
    }
    /// `ImDrawList::PathFillConvex`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_fill_convex(&mut self, col: ImU32) {
        unsafe { sys::ImDrawList_PathFillConvex(self as *mut Self, col) }
    }
    /// `ImDrawList::PathFillConvex`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_fill_convex_ex(&mut self, col: ImU32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_PathFillConvexEx(self as *mut Self, col, flags) }
    }
    /// `ImDrawList::PathFillConcave`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_fill_concave(&mut self, col: ImU32) {
        unsafe { sys::ImDrawList_PathFillConcave(self as *mut Self, col) }
    }
    /// `ImDrawList::PathStroke`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_stroke(&mut self, col: ImU32) {
        unsafe { sys::ImDrawList_PathStroke(self as *mut Self, col) }
    }
    /// `ImDrawList::PathStroke`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_stroke_ex(&mut self, col: ImU32, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_PathStrokeEx(self as *mut Self, col, thickness, flags) }
    }
    /// `ImDrawList::PathArcTo`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_arc_to(&mut self, center: impl Into<ImVec2>, radius: f32, a_min: f32, a_max: f32) {
        unsafe { sys::ImDrawList_PathArcTo(self as *mut Self, center.into(), radius, a_min, a_max) }
    }
    /// `ImDrawList::PathArcTo`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_arc_to_ex(&mut self, center: impl Into<ImVec2>, radius: f32, a_min: f32, a_max: f32, num_segments: c_int) {
        unsafe { sys::ImDrawList_PathArcToEx(self as *mut Self, center.into(), radius, a_min, a_max, num_segments) }
    }
    /// `ImDrawList::PathArcToFast`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_arc_to_fast(&mut self, center: impl Into<ImVec2>, radius: f32, a_min_of_12: c_int, a_max_of_12: c_int) {
        unsafe { sys::ImDrawList_PathArcToFast(self as *mut Self, center.into(), radius, a_min_of_12, a_max_of_12) }
    }
    /// `ImDrawList::PathEllipticalArcTo`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_elliptical_arc_to(&mut self, center: impl Into<ImVec2>, radius: impl Into<ImVec2>, rot: f32, a_min: f32, a_max: f32) {
        unsafe { sys::ImDrawList_PathEllipticalArcTo(self as *mut Self, center.into(), radius.into(), rot, a_min, a_max) }
    }
    /// `ImDrawList::PathEllipticalArcTo`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_elliptical_arc_to_ex(&mut self, center: impl Into<ImVec2>, radius: impl Into<ImVec2>, rot: f32, a_min: f32, a_max: f32, num_segments: c_int) {
        unsafe { sys::ImDrawList_PathEllipticalArcToEx(self as *mut Self, center.into(), radius.into(), rot, a_min, a_max, num_segments) }
    }
    /// `ImDrawList::PathBezierCubicCurveTo`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_bezier_cubic_curve_to(&mut self, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, p4: impl Into<ImVec2>) {
        unsafe { sys::ImDrawList_PathBezierCubicCurveTo(self as *mut Self, p2.into(), p3.into(), p4.into()) }
    }
    /// `ImDrawList::PathBezierCubicCurveTo`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_bezier_cubic_curve_to_ex(&mut self, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, p4: impl Into<ImVec2>, num_segments: c_int) {
        unsafe { sys::ImDrawList_PathBezierCubicCurveToEx(self as *mut Self, p2.into(), p3.into(), p4.into(), num_segments) }
    }
    /// `ImDrawList::PathBezierQuadraticCurveTo`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_bezier_quadratic_curve_to(&mut self, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>) {
        unsafe { sys::ImDrawList_PathBezierQuadraticCurveTo(self as *mut Self, p2.into(), p3.into()) }
    }
    /// `ImDrawList::PathBezierQuadraticCurveTo`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_bezier_quadratic_curve_to_ex(&mut self, p2: impl Into<ImVec2>, p3: impl Into<ImVec2>, num_segments: c_int) {
        unsafe { sys::ImDrawList_PathBezierQuadraticCurveToEx(self as *mut Self, p2.into(), p3.into(), num_segments) }
    }
    /// `ImDrawList::PathRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_rect(&mut self, rect_min: impl Into<ImVec2>, rect_max: impl Into<ImVec2>) {
        unsafe { sys::ImDrawList_PathRect(self as *mut Self, rect_min.into(), rect_max.into()) }
    }
    /// `ImDrawList::PathRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn path_rect_ex(&mut self, rect_min: impl Into<ImVec2>, rect_max: impl Into<ImVec2>, rounding: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList_PathRectEx(self as *mut Self, rect_min.into(), rect_max.into(), rounding, flags) }
    }
    /// `ImDrawList::AddDrawCmd`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_draw_cmd(&mut self) {
        unsafe { sys::ImDrawList_AddDrawCmd(self as *mut Self) }
    }
    /// `ImDrawList::CloneOutput`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clone_output(&self) -> Option<&'static mut ImDrawList> {
        unsafe { sys::ImDrawList_CloneOutput(self as *const Self).as_mut() }
    }
    /// `ImDrawList::ChannelsSplit`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn channels_split(&mut self, count: c_int) {
        unsafe { sys::ImDrawList_ChannelsSplit(self as *mut Self, count) }
    }
    /// `ImDrawList::ChannelsMerge`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn channels_merge(&mut self) {
        unsafe { sys::ImDrawList_ChannelsMerge(self as *mut Self) }
    }
    /// `ImDrawList::ChannelsSetCurrent`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn channels_set_current(&mut self, n: c_int) {
        unsafe { sys::ImDrawList_ChannelsSetCurrent(self as *mut Self, n) }
    }
    /// `ImDrawList::PrimReserve`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn prim_reserve(&mut self, idx_count: c_int, vtx_count: c_int) {
        unsafe { sys::ImDrawList_PrimReserve(self as *mut Self, idx_count, vtx_count) }
    }
    /// `ImDrawList::PrimUnreserve`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn prim_unreserve(&mut self, idx_count: c_int, vtx_count: c_int) {
        unsafe { sys::ImDrawList_PrimUnreserve(self as *mut Self, idx_count, vtx_count) }
    }
    /// `ImDrawList::PrimRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn prim_rect(&mut self, a: impl Into<ImVec2>, b: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_PrimRect(self as *mut Self, a.into(), b.into(), col) }
    }
    /// `ImDrawList::PrimRectUV`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn prim_rect_uv(&mut self, a: impl Into<ImVec2>, b: impl Into<ImVec2>, uv_a: impl Into<ImVec2>, uv_b: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_PrimRectUV(self as *mut Self, a.into(), b.into(), uv_a.into(), uv_b.into(), col) }
    }
    /// `ImDrawList::PrimQuadUV`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn prim_quad_uv(&mut self, a: impl Into<ImVec2>, b: impl Into<ImVec2>, c: impl Into<ImVec2>, d: impl Into<ImVec2>, uv_a: impl Into<ImVec2>, uv_b: impl Into<ImVec2>, uv_c: impl Into<ImVec2>, uv_d: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_PrimQuadUV(self as *mut Self, a.into(), b.into(), c.into(), d.into(), uv_a.into(), uv_b.into(), uv_c.into(), uv_d.into(), col) }
    }
    /// `ImDrawList::PrimWriteVtx`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn prim_write_vtx(&mut self, pos: impl Into<ImVec2>, uv: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_PrimWriteVtx(self as *mut Self, pos.into(), uv.into(), col) }
    }
    /// `ImDrawList::PrimWriteIdx`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn prim_write_idx(&mut self, idx: ImDrawIdx) {
        unsafe { sys::ImDrawList_PrimWriteIdx(self as *mut Self, idx) }
    }
    /// `ImDrawList::PrimVtx`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn prim_vtx(&mut self, pos: impl Into<ImVec2>, uv: impl Into<ImVec2>, col: ImU32) {
        unsafe { sys::ImDrawList_PrimVtx(self as *mut Self, pos.into(), uv.into(), col) }
    }
    /// `ImDrawList::_SetDrawListSharedData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _set_draw_list_shared_data(&mut self, data: &mut ImDrawListSharedData) {
        unsafe { sys::ImDrawList__SetDrawListSharedData(self as *mut Self, data as *mut ImDrawListSharedData) }
    }
    /// `ImDrawList::_ResetForNewFrame`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _reset_for_new_frame(&mut self) {
        unsafe { sys::ImDrawList__ResetForNewFrame(self as *mut Self) }
    }
    /// `ImDrawList::_SetPixelDensity`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _set_pixel_density(&mut self, pixel_density: f32) {
        unsafe { sys::ImDrawList__SetPixelDensity(self as *mut Self, pixel_density) }
    }
    /// `ImDrawList::_ClearFreeMemory`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _clear_free_memory(&mut self) {
        unsafe { sys::ImDrawList__ClearFreeMemory(self as *mut Self) }
    }
    /// `ImDrawList::_PopUnusedDrawCmd`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _pop_unused_draw_cmd(&mut self) {
        unsafe { sys::ImDrawList__PopUnusedDrawCmd(self as *mut Self) }
    }
    /// `ImDrawList::_TryMergeDrawCmds`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _try_merge_draw_cmds(&mut self) {
        unsafe { sys::ImDrawList__TryMergeDrawCmds(self as *mut Self) }
    }
    /// `ImDrawList::_OnChangedClipRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _on_changed_clip_rect(&mut self) {
        unsafe { sys::ImDrawList__OnChangedClipRect(self as *mut Self) }
    }
    /// `ImDrawList::_OnChangedTexture`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _on_changed_texture(&mut self) {
        unsafe { sys::ImDrawList__OnChangedTexture(self as *mut Self) }
    }
    /// `ImDrawList::_OnChangedVtxOffset`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _on_changed_vtx_offset(&mut self) {
        unsafe { sys::ImDrawList__OnChangedVtxOffset(self as *mut Self) }
    }
    /// `ImDrawList::_SetTexture`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _set_texture(&mut self, tex_ref: impl Into<ImTextureRef>) {
        unsafe { sys::ImDrawList__SetTexture(self as *mut Self, tex_ref.into()) }
    }
    /// `ImDrawList::_CalcCircleAutoSegmentCount`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _calc_circle_auto_segment_count(&self, radius: f32) -> c_int {
        unsafe { sys::ImDrawList__CalcCircleAutoSegmentCount(self as *const Self, radius) }
    }
    /// `ImDrawList::_PathArcToFastEx`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _path_arc_to_fast_ex(&mut self, center: impl Into<ImVec2>, radius: f32, a_min_sample: c_int, a_max_sample: c_int, a_step: c_int) {
        unsafe { sys::ImDrawList__PathArcToFastEx(self as *mut Self, center.into(), radius, a_min_sample, a_max_sample, a_step) }
    }
    /// `ImDrawList::_PathArcToN`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _path_arc_to_n(&mut self, center: impl Into<ImVec2>, radius: f32, a_min: f32, a_max: f32, num_segments: c_int) {
        unsafe { sys::ImDrawList__PathArcToN(self as *mut Self, center.into(), radius, a_min, a_max, num_segments) }
    }
    /// `ImDrawList::_AddRectFilledBaked`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _add_rect_filled_baked(&mut self, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>, col: ImU32, r: f32, tex_uvs: impl Into<ImVec4>, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList__AddRectFilledBaked(self as *mut Self, p_min.into(), p_max.into(), col, r, tex_uvs.into(), flags) }
    }
    /// `ImDrawList::_AddRectBaked`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _add_rect_baked(&mut self, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>, col: ImU32, r: f32, t: f32, tex_uvs: impl Into<ImVec4>, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList__AddRectBaked(self as *mut Self, p_min.into(), p_max.into(), col, r, t, tex_uvs.into(), flags) }
    }
    /// `ImDrawList::_AddLine`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _add_line(&mut self, p1: impl Into<ImVec2>, p2: impl Into<ImVec2>, col: ImU32, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList__AddLine(self as *mut Self, p1.into(), p2.into(), col, thickness, flags) }
    }
    /// `ImDrawList::_AddRectTinyRounding`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _add_rect_tiny_rounding(&mut self, p_min: impl Into<ImVec2>, p_max: impl Into<ImVec2>, col: ImU32, rounding: f32, thickness: f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList__AddRectTinyRounding(self as *mut Self, p_min.into(), p_max.into(), col, rounding, thickness, flags) }
    }
    /// `ImDrawList::_SelectLineTexture`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _select_line_texture(&mut self, screen_thickness: f32, out_uv0: &mut ImVec2, out_uv1: &mut ImVec2, out_fringe: &mut f32, flags: ImDrawFlags) {
        unsafe { sys::ImDrawList__SelectLineTexture(self as *mut Self, screen_thickness, out_uv0, out_uv1, out_fringe, flags) }
    }
    /// `ImDrawList::_CalculateCenterBiasedOffset`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _calculate_center_biased_offset(&mut self, thickness: f32) -> f32 {
        unsafe { sys::ImDrawList__CalculateCenterBiasedOffset(self as *mut Self, thickness) }
    }
    /// `ImDrawList::_AddPolyline`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn _add_polyline(&mut self, points: &[ImVec2], col: ImU32, thickness: f32, flags: ImDrawFlags, max_inner_offset: f32) {
        unsafe { sys::ImDrawList__AddPolyline(self as *mut Self, points.as_ptr(), points.len() as c_int, col, thickness, flags, max_inner_offset) }
    }
}
impl crate::Delete for ImDrawList {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImDrawList_Delete(p) } }
}
impl ImDrawData {
    /// `ImDrawData::ImDrawData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImDrawData> {
        unsafe { crate::Owned::from_raw(sys::ImDrawData_New()) }
    }
    /// `ImDrawData::Clear`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear(&mut self) {
        unsafe { sys::ImDrawData_Clear(self as *mut Self) }
    }
    /// `ImDrawData::AddDrawList`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_draw_list(&mut self, draw_list: &mut ImDrawList) {
        unsafe { sys::ImDrawData_AddDrawList(self as *mut Self, draw_list as *mut ImDrawList) }
    }
    /// `ImDrawData::DeIndexAllBuffers`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn de_index_all_buffers(&mut self) {
        unsafe { sys::ImDrawData_DeIndexAllBuffers(self as *mut Self) }
    }
    /// `ImDrawData::ScaleClipRects`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn scale_clip_rects(&mut self, fb_scale: impl Into<ImVec2>) {
        unsafe { sys::ImDrawData_ScaleClipRects(self as *mut Self, fb_scale.into()) }
    }
}
impl crate::Delete for ImDrawData {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImDrawData_Delete(p) } }
}
impl ImTextureRect {
    /// `ImTextureRect::ImTextureRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImTextureRect> {
        unsafe { crate::Owned::from_raw(sys::ImTextureRect_New()) }
    }
}
impl crate::Delete for ImTextureRect {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImTextureRect_Delete(p) } }
}
impl ImTextureData {
    /// `ImTextureData::ImTextureData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImTextureData> {
        unsafe { crate::Owned::from_raw(sys::ImTextureData_New()) }
    }
    /// `ImTextureData::Create`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn create(&mut self, format: ImTextureFormat, w: c_int, h: c_int) {
        unsafe { sys::ImTextureData_Create(self as *mut Self, format, w, h) }
    }
    /// `ImTextureData::DestroyPixels`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn destroy_pixels(&mut self) {
        unsafe { sys::ImTextureData_DestroyPixels(self as *mut Self) }
    }
    /// `ImTextureData::GetPixels`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_pixels(&mut self) -> *mut c_void {
        unsafe { sys::ImTextureData_GetPixels(self as *mut Self) }
    }
    /// `ImTextureData::GetPixelsAt`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_pixels_at(&mut self, x: c_int, y: c_int) -> *mut c_void {
        unsafe { sys::ImTextureData_GetPixelsAt(self as *mut Self, x, y) }
    }
    /// `ImTextureData::GetSizeInBytes`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_size_in_bytes(&self) -> c_int {
        unsafe { sys::ImTextureData_GetSizeInBytes(self as *const Self) }
    }
    /// `ImTextureData::GetPitch`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_pitch(&self) -> c_int {
        unsafe { sys::ImTextureData_GetPitch(self as *const Self) }
    }
    /// `ImTextureData::GetTexRef`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_tex_ref(&mut self) -> ImTextureRef {
        unsafe { sys::ImTextureData_GetTexRef(self as *mut Self) }
    }
    /// `ImTextureData::GetTexID`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_tex_id(&self) -> ImTextureID {
        unsafe { sys::ImTextureData_GetTexID(self as *const Self) }
    }
    /// `ImTextureData::SetTexID`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_tex_id(&mut self, tex_id: ImTextureID) {
        unsafe { sys::ImTextureData_SetTexID(self as *mut Self, tex_id) }
    }
    /// `ImTextureData::SetStatus`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_status(&mut self, status: ImTextureStatus) {
        unsafe { sys::ImTextureData_SetStatus(self as *mut Self, status) }
    }
}
impl crate::Delete for ImTextureData {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImTextureData_Delete(p) } }
}
impl ImFontConfig {
    /// `ImFontConfig::ImFontConfig`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImFontConfig> {
        unsafe { crate::Owned::from_raw(sys::ImFontConfig_New()) }
    }
}
impl crate::Delete for ImFontConfig {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImFontConfig_Delete(p) } }
}
impl ImFontGlyph {
    /// `ImFontGlyph::ImFontGlyph`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImFontGlyph> {
        unsafe { crate::Owned::from_raw(sys::ImFontGlyph_New()) }
    }
}
impl crate::Delete for ImFontGlyph {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImFontGlyph_Delete(p) } }
}
impl ImFontGlyphRangesBuilder {
    /// `ImFontGlyphRangesBuilder::ImFontGlyphRangesBuilder`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImFontGlyphRangesBuilder> {
        unsafe { crate::Owned::from_raw(sys::ImFontGlyphRangesBuilder_New()) }
    }
    /// `ImFontGlyphRangesBuilder::Clear`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear(&mut self) {
        unsafe { sys::ImFontGlyphRangesBuilder_Clear(self as *mut Self) }
    }
    /// `ImFontGlyphRangesBuilder::GetBit`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_bit(&self, n: usize) -> bool {
        unsafe { sys::ImFontGlyphRangesBuilder_GetBit(self as *const Self, n) }
    }
    /// `ImFontGlyphRangesBuilder::SetBit`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_bit(&mut self, n: usize) {
        unsafe { sys::ImFontGlyphRangesBuilder_SetBit(self as *mut Self, n) }
    }
    /// `ImFontGlyphRangesBuilder::AddChar`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_char(&mut self, c: ImWchar) {
        unsafe { sys::ImFontGlyphRangesBuilder_AddChar(self as *mut Self, c) }
    }
    /// `ImFontGlyphRangesBuilder::AddText`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_text(&mut self, text: &str) {
        let __text = crate::cs(text);
        unsafe { sys::ImFontGlyphRangesBuilder_AddText(self as *mut Self, __text.as_ptr()) }
    }
    /// `ImFontGlyphRangesBuilder::AddText`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_text_ex(&mut self, text: &str, text_end: Option<&str>) {
        let __text = crate::cs(text);
        let __text_end = text_end.map(crate::cs);
        unsafe { sys::ImFontGlyphRangesBuilder_AddTextEx(self as *mut Self, __text.as_ptr(), __text_end.as_ref().map_or(core::ptr::null(), |s| s.as_ptr())) }
    }
}
impl crate::Delete for ImFontGlyphRangesBuilder {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImFontGlyphRangesBuilder_Delete(p) } }
}
impl ImFontAtlasRect {
    /// `ImFontAtlasRect::ImFontAtlasRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImFontAtlasRect> {
        unsafe { crate::Owned::from_raw(sys::ImFontAtlasRect_New()) }
    }
}
impl crate::Delete for ImFontAtlasRect {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImFontAtlasRect_Delete(p) } }
}
impl ImFontAtlas {
    /// `ImFontAtlas::ImFontAtlas`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImFontAtlas> {
        unsafe { crate::Owned::from_raw(sys::ImFontAtlas_New()) }
    }
    /// `ImFontAtlas::AddFont`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_font(&mut self, font_cfg: &ImFontConfig) -> Option<&'static mut ImFont> {
        unsafe { sys::ImFontAtlas_AddFont(self as *mut Self, font_cfg as *const ImFontConfig).as_mut() }
    }
    /// `ImFontAtlas::AddFontDefault`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_font_default(&mut self) -> Option<&'static mut ImFont> {
        unsafe { sys::ImFontAtlas_AddFontDefault(self as *mut Self).as_mut() }
    }
    /// `ImFontAtlas::AddFontDefault`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_font_default_ex(&mut self, font_cfg: Option<&ImFontConfig>) -> Option<&'static mut ImFont> {
        unsafe { sys::ImFontAtlas_AddFontDefaultEx(self as *mut Self, font_cfg.map_or(core::ptr::null(), |r| r as *const ImFontConfig)).as_mut() }
    }
    /// `ImFontAtlas::AddFontDefaultVector`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_font_default_vector(&mut self) -> Option<&'static mut ImFont> {
        unsafe { sys::ImFontAtlas_AddFontDefaultVector(self as *mut Self).as_mut() }
    }
    /// `ImFontAtlas::AddFontDefaultVector`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_font_default_vector_ex(&mut self, font_cfg: Option<&ImFontConfig>) -> Option<&'static mut ImFont> {
        unsafe { sys::ImFontAtlas_AddFontDefaultVectorEx(self as *mut Self, font_cfg.map_or(core::ptr::null(), |r| r as *const ImFontConfig)).as_mut() }
    }
    /// `ImFontAtlas::AddFontDefaultBitmap`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_font_default_bitmap(&mut self) -> Option<&'static mut ImFont> {
        unsafe { sys::ImFontAtlas_AddFontDefaultBitmap(self as *mut Self).as_mut() }
    }
    /// `ImFontAtlas::AddFontDefaultBitmap`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_font_default_bitmap_ex(&mut self, font_cfg: Option<&ImFontConfig>) -> Option<&'static mut ImFont> {
        unsafe { sys::ImFontAtlas_AddFontDefaultBitmapEx(self as *mut Self, font_cfg.map_or(core::ptr::null(), |r| r as *const ImFontConfig)).as_mut() }
    }
    /// `ImFontAtlas::AddFontFromFileTTF`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_font_from_file_ttf(&mut self, filename: &str) -> Option<&'static mut ImFont> {
        let __filename = crate::cs(filename);
        unsafe { sys::ImFontAtlas_AddFontFromFileTTF(self as *mut Self, __filename.as_ptr()).as_mut() }
    }
    /// `ImFontAtlas::AddFontFromFileTTF`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_font_from_file_ttf_ex(&mut self, filename: &str, size_pixels: f32, font_cfg: Option<&ImFontConfig>, glyph_ranges: Option<&ImWchar>) -> Option<&'static mut ImFont> {
        let __filename = crate::cs(filename);
        unsafe { sys::ImFontAtlas_AddFontFromFileTTFEx(self as *mut Self, __filename.as_ptr(), size_pixels, font_cfg.map_or(core::ptr::null(), |r| r as *const ImFontConfig), glyph_ranges.map_or(core::ptr::null(), |r| r as *const ImWchar)).as_mut() }
    }
    /// `ImFontAtlas::AddFontFromMemoryCompressedBase85TTF`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_font_from_memory_compressed_base85_ttf(&mut self, compressed_font_data_base85: &str) -> Option<&'static mut ImFont> {
        let __compressed_font_data_base85 = crate::cs(compressed_font_data_base85);
        unsafe { sys::ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(self as *mut Self, __compressed_font_data_base85.as_ptr()).as_mut() }
    }
    /// `ImFontAtlas::AddFontFromMemoryCompressedBase85TTF`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_font_from_memory_compressed_base85_ttf_ex(&mut self, compressed_font_data_base85: &str, size_pixels: f32, font_cfg: Option<&ImFontConfig>, glyph_ranges: Option<&ImWchar>) -> Option<&'static mut ImFont> {
        let __compressed_font_data_base85 = crate::cs(compressed_font_data_base85);
        unsafe { sys::ImFontAtlas_AddFontFromMemoryCompressedBase85TTFEx(self as *mut Self, __compressed_font_data_base85.as_ptr(), size_pixels, font_cfg.map_or(core::ptr::null(), |r| r as *const ImFontConfig), glyph_ranges.map_or(core::ptr::null(), |r| r as *const ImWchar)).as_mut() }
    }
    /// `ImFontAtlas::RemoveFont`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn remove_font(&mut self, font: &mut ImFont) {
        unsafe { sys::ImFontAtlas_RemoveFont(self as *mut Self, font as *mut ImFont) }
    }
    /// `ImFontAtlas::CompactCache`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn compact_cache(&mut self) {
        unsafe { sys::ImFontAtlas_CompactCache(self as *mut Self) }
    }
    /// `ImFontAtlas::SetFontLoader`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn set_font_loader(&mut self, font_loader: &ImFontLoader) {
        unsafe { sys::ImFontAtlas_SetFontLoader(self as *mut Self, font_loader as *const ImFontLoader) }
    }
    /// `ImFontAtlas::Clear`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear(&mut self) {
        unsafe { sys::ImFontAtlas_Clear(self as *mut Self) }
    }
    /// `ImFontAtlas::ClearFonts`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_fonts(&mut self) {
        unsafe { sys::ImFontAtlas_ClearFonts(self as *mut Self) }
    }
    /// `ImFontAtlas::ClearInputData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_input_data(&mut self) {
        unsafe { sys::ImFontAtlas_ClearInputData(self as *mut Self) }
    }
    /// `ImFontAtlas::ClearTexData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_tex_data(&mut self) {
        unsafe { sys::ImFontAtlas_ClearTexData(self as *mut Self) }
    }
    /// `ImFontAtlas::GetGlyphRangesDefault`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_glyph_ranges_default(&mut self) -> *const ImWchar {
        unsafe { sys::ImFontAtlas_GetGlyphRangesDefault(self as *mut Self) }
    }
    /// `ImFontAtlas::AddCustomRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_custom_rect(&mut self, width: c_int, height: c_int) -> ImFontAtlasRectId {
        unsafe { sys::ImFontAtlas_AddCustomRect(self as *mut Self, width, height) }
    }
    /// `ImFontAtlas::AddCustomRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_custom_rect_ex(&mut self, width: c_int, height: c_int, out_r: Option<&mut ImFontAtlasRect>) -> ImFontAtlasRectId {
        unsafe { sys::ImFontAtlas_AddCustomRectEx(self as *mut Self, width, height, out_r.map_or(core::ptr::null_mut(), |r| r as *mut ImFontAtlasRect)) }
    }
    /// `ImFontAtlas::RemoveCustomRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn remove_custom_rect(&mut self, id: ImFontAtlasRectId) {
        unsafe { sys::ImFontAtlas_RemoveCustomRect(self as *mut Self, id) }
    }
    /// `ImFontAtlas::GetCustomRect`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_custom_rect(&self, id: ImFontAtlasRectId, out_r: &mut ImFontAtlasRect) -> bool {
        unsafe { sys::ImFontAtlas_GetCustomRect(self as *const Self, id, out_r as *mut ImFontAtlasRect) }
    }
}
impl crate::Delete for ImFontAtlas {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImFontAtlas_Delete(p) } }
}
impl ImFontBaked {
    /// `ImFontBaked::ImFontBaked`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImFontBaked> {
        unsafe { crate::Owned::from_raw(sys::ImFontBaked_New()) }
    }
    /// `ImFontBaked::ClearOutputData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_output_data(&mut self) {
        unsafe { sys::ImFontBaked_ClearOutputData(self as *mut Self) }
    }
    /// `ImFontBaked::FindGlyph`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn find_glyph(&mut self, c: ImWchar) -> Option<&'static mut ImFontGlyph> {
        unsafe { sys::ImFontBaked_FindGlyph(self as *mut Self, c).as_mut() }
    }
    /// `ImFontBaked::FindGlyphNoFallback`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn find_glyph_no_fallback(&mut self, c: ImWchar) -> Option<&'static mut ImFontGlyph> {
        unsafe { sys::ImFontBaked_FindGlyphNoFallback(self as *mut Self, c).as_mut() }
    }
    /// `ImFontBaked::GetCharAdvance`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_char_advance(&mut self, c: ImWchar) -> f32 {
        unsafe { sys::ImFontBaked_GetCharAdvance(self as *mut Self, c) }
    }
    /// `ImFontBaked::IsGlyphLoaded`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn is_glyph_loaded(&mut self, c: ImWchar) -> bool {
        unsafe { sys::ImFontBaked_IsGlyphLoaded(self as *mut Self, c) }
    }
}
impl crate::Delete for ImFontBaked {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImFontBaked_Delete(p) } }
}
impl ImFont {
    /// `ImFont::ImFont`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImFont> {
        unsafe { crate::Owned::from_raw(sys::ImFont_New()) }
    }
    /// `ImFont::IsGlyphInFont`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn is_glyph_in_font(&mut self, c: ImWchar) -> bool {
        unsafe { sys::ImFont_IsGlyphInFont(self as *mut Self, c) }
    }
    /// `ImFont::IsLoaded`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn is_loaded(&self) -> bool {
        unsafe { sys::ImFont_IsLoaded(self as *const Self) }
    }
    /// `ImFont::GetDebugName`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_debug_name(&self) -> &'static str {
        unsafe { crate::from_cstr(sys::ImFont_GetDebugName(self as *const Self)) }
    }
    /// `ImFont::GetFontBaked`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_font_baked(&mut self, font_size: f32) -> Option<&'static mut ImFontBaked> {
        unsafe { sys::ImFont_GetFontBaked(self as *mut Self, font_size).as_mut() }
    }
    /// `ImFont::GetFontBaked`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_font_baked_ex(&mut self, font_size: f32, density: f32) -> Option<&'static mut ImFontBaked> {
        unsafe { sys::ImFont_GetFontBakedEx(self as *mut Self, font_size, density).as_mut() }
    }
    /// `ImFont::CalcTextSizeA`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn calc_text_size_a(&mut self, size: f32, max_width: f32, wrap_width: f32, text_begin: &str) -> ImVec2 {
        let __text_begin = crate::cs(text_begin);
        unsafe { sys::ImFont_CalcTextSizeA(self as *mut Self, size, max_width, wrap_width, __text_begin.as_ptr()) }
    }
    /// `ImFont::CalcTextSizeA`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn calc_text_size_a_ex(&mut self, size: f32, max_width: f32, wrap_width: f32, text_begin: &str, text_end: Option<&str>) -> ImVec2 {
        let __text_begin = crate::cs(text_begin);
        let __text_end = text_end.map(crate::cs);
        unsafe { sys::ImFont_CalcTextSizeAEx(self as *mut Self, size, max_width, wrap_width, __text_begin.as_ptr(), __text_end.as_ref().map_or(core::ptr::null(), |s| s.as_ptr()), core::ptr::null_mut()) }
    }
    /// `ImFont::CalcWordWrapPosition`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn calc_word_wrap_position(&mut self, size: f32, text: &str, text_end: &str, wrap_width: f32) -> &'static str {
        let __text = crate::cs(text);
        let __text_end = crate::cs(text_end);
        unsafe { crate::from_cstr(sys::ImFont_CalcWordWrapPosition(self as *mut Self, size, __text.as_ptr(), __text_end.as_ptr(), wrap_width)) }
    }
    /// `ImFont::RenderChar`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn render_char(&mut self, draw_list: &mut ImDrawList, size: f32, pos: impl Into<ImVec2>, col: ImU32, c: ImWchar) {
        unsafe { sys::ImFont_RenderChar(self as *mut Self, draw_list as *mut ImDrawList, size, pos.into(), col, c) }
    }
    /// `ImFont::RenderChar`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn render_char_ex(&mut self, draw_list: &mut ImDrawList, size: f32, pos: impl Into<ImVec2>, col: ImU32, c: ImWchar, cpu_fine_clip: Option<&ImVec4>) {
        unsafe { sys::ImFont_RenderCharEx(self as *mut Self, draw_list as *mut ImDrawList, size, pos.into(), col, c, cpu_fine_clip.map_or(core::ptr::null(), |r| r as *const ImVec4)) }
    }
    /// `ImFont::RenderText`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn render_text(&mut self, draw_list: &mut ImDrawList, size: f32, pos: impl Into<ImVec2>, col: ImU32, clip_rect: impl Into<ImVec4>, text_begin: &str, text_end: &str) {
        let __text_begin = crate::cs(text_begin);
        let __text_end = crate::cs(text_end);
        unsafe { sys::ImFont_RenderText(self as *mut Self, draw_list as *mut ImDrawList, size, pos.into(), col, clip_rect.into(), __text_begin.as_ptr(), __text_end.as_ptr()) }
    }
    /// `ImFont::RenderText`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn render_text_ex(&mut self, draw_list: &mut ImDrawList, size: f32, pos: impl Into<ImVec2>, col: ImU32, clip_rect: impl Into<ImVec4>, text_begin: &str, text_end: &str, wrap_width: f32, flags: ImDrawTextFlags) {
        let __text_begin = crate::cs(text_begin);
        let __text_end = crate::cs(text_end);
        unsafe { sys::ImFont_RenderTextEx(self as *mut Self, draw_list as *mut ImDrawList, size, pos.into(), col, clip_rect.into(), __text_begin.as_ptr(), __text_end.as_ptr(), wrap_width, flags) }
    }
    /// `ImFont::ClearOutputData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_output_data(&mut self) {
        unsafe { sys::ImFont_ClearOutputData(self as *mut Self) }
    }
    /// `ImFont::AddRemapCodepoint`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_remap_codepoint(&mut self, from_codepoint: ImWchar, to_codepoint: ImWchar) {
        unsafe { sys::ImFont_AddRemapCodepoint(self as *mut Self, from_codepoint, to_codepoint) }
    }
    /// `ImFont::AddRemapCodepointToGlyphIndex`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn add_remap_codepoint_to_glyph_index(&mut self, from_codepoint: ImWchar, font_src_idx: c_int, glyph_idx: c_int) {
        unsafe { sys::ImFont_AddRemapCodepointToGlyphIndex(self as *mut Self, from_codepoint, font_src_idx, glyph_idx) }
    }
    /// `ImFont::IsGlyphRangeUnused`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn is_glyph_range_unused(&mut self, c_begin: c_uint, c_last: c_uint) -> bool {
        unsafe { sys::ImFont_IsGlyphRangeUnused(self as *mut Self, c_begin, c_last) }
    }
}
impl crate::Delete for ImFont {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImFont_Delete(p) } }
}
impl ImGuiViewport {
    /// `ImGuiViewport::ImGuiViewport`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiViewport> {
        unsafe { crate::Owned::from_raw(sys::ImGuiViewport_New()) }
    }
    /// `ImGuiViewport::GetCenter`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_center(&self) -> ImVec2 {
        unsafe { sys::ImGuiViewport_GetCenter(self as *const Self) }
    }
    /// `ImGuiViewport::GetWorkCenter`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn get_work_center(&self) -> ImVec2 {
        unsafe { sys::ImGuiViewport_GetWorkCenter(self as *const Self) }
    }
}
impl crate::Delete for ImGuiViewport {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiViewport_Delete(p) } }
}
impl ImGuiPlatformIO {
    /// `ImGuiPlatformIO::ImGuiPlatformIO`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiPlatformIO> {
        unsafe { crate::Owned::from_raw(sys::ImGuiPlatformIO_New()) }
    }
    /// `ImGuiPlatformIO::ClearPlatformHandlers`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_platform_handlers(&mut self) {
        unsafe { sys::ImGuiPlatformIO_ClearPlatformHandlers(self as *mut Self) }
    }
    /// `ImGuiPlatformIO::ClearRendererHandlers`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn clear_renderer_handlers(&mut self) {
        unsafe { sys::ImGuiPlatformIO_ClearRendererHandlers(self as *mut Self) }
    }
}
impl crate::Delete for ImGuiPlatformIO {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiPlatformIO_Delete(p) } }
}
impl ImGuiPlatformImeData {
    /// `ImGuiPlatformImeData::ImGuiPlatformImeData`
    #[allow(clippy::too_many_arguments, unused_unsafe)]
    pub fn new() -> crate::Owned<ImGuiPlatformImeData> {
        unsafe { crate::Owned::from_raw(sys::ImGuiPlatformImeData_New()) }
    }
}
impl crate::Delete for ImGuiPlatformImeData {
    unsafe fn delete(p: *mut Self) { unsafe { sys::ImGuiPlatformImeData_Delete(p) } }
}