API Reference

imgui_version()::VersionNumber

Return the upstream ImGui version.

AcceptDragDropPayload(type) -> Ptr{CImGui.lib.ImGuiPayload}
AcceptDragDropPayload(
    type,
    flags::Union{CImGui.lib.ImGuiDragDropFlags_, Integer}
) -> Ptr{CImGui.lib.ImGuiPayload}

Accept contents of a given type. If ImGuiDragDropFlags_AcceptBeforeDelivery is set you can peek into the payload before the mouse button is released.

Upstream link.

ActivateItemByID(id::Integer)

Activate an item by ID (button, checkbox, tree node etc.). Activation is queued and processed on the next frame when the item is encountered again. Was called 'ActivateItem()' before 1.89.7.

Upstream link.

AddBezierCubic(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    thickness
)
AddBezierCubic(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    thickness,
    num_segments
)

Cubic Bezier (4 control points).

Upstream link.

AddBezierQuadratic(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    thickness
)
AddBezierQuadratic(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    thickness,
    num_segments
)

Quadratic Bezier (3 control points).

Upstream link.

AddCallback(
    self::Ptr{CImGui.lib.ImDrawList},
    callback::Union{Ptr{Nothing}, Base.CFunction}
)
AddCallback(
    self::Ptr{CImGui.lib.ImDrawList},
    callback::Union{Ptr{Nothing}, Base.CFunction},
    userdata
)
AddCallback(
    self::Ptr{CImGui.lib.ImDrawList},
    callback::Union{Ptr{Nothing}, Base.CFunction},
    userdata,
    userdata_size
)

Advanced: Draw Callbacks

• May be used to alter render state (change sampler, blending, current shader). May be used to emit custom rendering commands (difficult to do correctly, but possible).
• Use special GetPlatformIO().DrawCallback_ResetRenderState callback to instruct backend to reset its render state to the default.
• See other standard callbacks in GetPlatformIO(), which may or not be supported by your backend.
• Your rendering loop must check for 'UserCallback' in ImDrawCmd and call the function instead of rendering triangles. All standard backends are honoring this.
• For some backends, the callback may access selected render-states exposed by the backend in a ImGuiImplXXXXRenderState structure pointed to by platformio.RendererRenderState.
• IMPORTANT: please be mindful of the different level of indirection between using size==0 (copying argument) and using size>0 (copying pointed data into a buffer).
  • If userdata_size == 0: we copy/store the 'userdata' argument as-is. It will be available unmodified in ImDrawCmd::UserCallbackData during render.
  • If userdatasize > 0, we copy/store 'userdatasize' bytes pointed to by 'userdata'. We store them in a buffer stored inside the drawlist. ImDrawCmd::UserCallbackData will point inside that buffer so you have to retrieve data from there. Your callback may need to use ImDrawCmd::UserCallbackDataSize if you expect dynamically-sized data.
  • Support for userdata_size > 0 was added in v1.91.4, October 2024. So earlier code always only allowed to copy/store a simple void*.

Upstream link.

AddChar(
    self::Ptr{CImGui.lib.ImFontGlyphRangesBuilder},
    c::UInt16
)

Add character.

Upstream link.

AddCircle(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius,
    col::Integer
)
AddCircle(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius,
    col::Integer,
    num_segments
)
AddCircle(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius,
    col::Integer,
    num_segments,
    thickness
)

Upstream link.

AddCircleFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius,
    col::Integer
)
AddCircleFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius,
    col::Integer,
    num_segments
)

Upstream link.

AddConcavePolyFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    points::Union{Ptr{Nothing}, Ref{CImGui.lib.ImVec2}, Ref{Tuple{T, T} where T}},
    num_points,
    col::Integer
)

Upstream link.

AddContextHook(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}},
    hook::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContextHook}}
) -> UInt32

Upstream link.

AddConvexPolyFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    points::Union{Ptr{Nothing}, Ref{CImGui.lib.ImVec2}, Ref{Tuple{T, T} where T}},
    num_points,
    col::Integer
)

Upstream link.

AddCustomRect(
    self::Ptr{CImGui.lib.ImFontAtlas},
    width,
    height
) -> Int32
AddCustomRect(
    self::Ptr{CImGui.lib.ImFontAtlas},
    width,
    height,
    out_r::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontAtlasRect}}
) -> Int32

Register and retrieve custom rectangles

• You can request arbitrary rectangles to be packed into the atlas, for your own purpose.
• Since 1.92.0, packing is done immediately in the function call (previously packing was done during the Build call)
• You can render your pixels into the texture right after calling the AddCustomRect() functions.
• VERY IMPORTANT:
  • Texture may be created/resized at any time when calling ImGui or ImFontAtlas functions.
  • IT WILL INVALIDATE RECTANGLE DATA SUCH AS UV COORDINATES. Always use latest values from GetCustomRect().
  • UV coordinates are associated to the current texture identifier aka 'atlas->TexRef'. Both TexRef and UV coordinates are typically changed at the same time.
• If you render colored output into your custom rectangles: set 'atlas->TexPixelsUseColors = true' as this may help some backends decide of preferred texture format.
• Read docs/FONTS.md for more details about using colorful icons.
• Note: this API may be reworked further in order to facilitate supporting e.g. multi-monitor, varying DPI settings.
• (Pre-1.92 names) ––––––> (1.92 names)
  • GetCustomRectByIndex() –> Use GetCustomRect()
  • CalcCustomRectUV() –> Use GetCustomRect() and read uv0, uv1 fields.
  • AddCustomRectRegular() –> Renamed to AddCustomRect()
  • AddCustomRectFontGlyph() –> Prefer using custom ImFontLoader inside ImFontConfig
  • ImFontAtlasCustomRect –> Renamed to ImFontAtlasRect// Register a rectangle. Return -1 (ImFontAtlasRectId_Invalid) on error.

Upstream link.

AddDrawCmd(self::Ptr{CImGui.lib.ImDrawList})

Advanced: Miscellaneous// This is useful if you need to forcefully create a new draw call (to allow for dependent rendering / blending). Otherwise primitives are merged into the same draw-call as much as possible.

Upstream link.

AddDrawList(
    self::Ptr{CImGui.lib.ImDrawData},
    draw_list::Union{Ptr{Nothing}, Ref{CImGui.lib.ImDrawList}}
)

Helper to add an external draw list into an existing ImDrawData.

Upstream link.

AddDrawListToDrawDataEx(
    draw_data::Union{Ptr{Nothing}, Ref{CImGui.lib.ImDrawData}},
    out_list::Union{Ptr{Nothing}, Ref{CImGui.lib.ImVector_ImDrawListPtr}},
    draw_list::Union{Ptr{Nothing}, Ref{CImGui.lib.ImDrawList}}
)

Upstream link.

AddEllipse(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer
)
AddEllipse(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rot
)
AddEllipse(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rot,
    num_segments
)
AddEllipse(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rot,
    num_segments,
    thickness
)

Upstream link.

AddEllipseFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer
)
AddEllipseFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rot
)
AddEllipseFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rot,
    num_segments
)

Upstream link.

AddFocusEvent(self::Ptr{CImGui.lib.ImGuiIO}, focused)

Queue a gain/loss of focus for the application (generally based on OS/platform focus of your window).

Upstream link.

AddFont(
    self::Ptr{CImGui.lib.ImFontAtlas},
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}}
) -> Ptr{CImGui.lib.ImFont}

Upstream link.

AddFontDefault(
    self::Ptr{CImGui.lib.ImFontAtlas}
) -> Ptr{CImGui.lib.ImFont}
AddFontDefault(
    self::Ptr{CImGui.lib.ImFontAtlas},
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}}
) -> Ptr{CImGui.lib.ImFont}

Selects between AddFontDefaultVector() and AddFontDefaultBitmap().

Upstream link.

AddFontDefaultBitmap(
    self::Ptr{CImGui.lib.ImFontAtlas}
) -> Ptr{CImGui.lib.ImFont}
AddFontDefaultBitmap(
    self::Ptr{CImGui.lib.ImFontAtlas},
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}}
) -> Ptr{CImGui.lib.ImFont}

Embedded classic pixel-clean font. Recommended at Size 13px with no scaling.

Upstream link.

AddFontDefaultVector(
    self::Ptr{CImGui.lib.ImFontAtlas}
) -> Ptr{CImGui.lib.ImFont}
AddFontDefaultVector(
    self::Ptr{CImGui.lib.ImFontAtlas},
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}}
) -> Ptr{CImGui.lib.ImFont}

Embedded scalable font. Recommended at any higher size.

Upstream link.

AddFontFromFileTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    filename
) -> Ptr{CImGui.lib.ImFont}
AddFontFromFileTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    filename,
    size_pixels
) -> Ptr{CImGui.lib.ImFont}
AddFontFromFileTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    filename,
    size_pixels,
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}}
) -> Ptr{CImGui.lib.ImFont}
AddFontFromFileTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    filename,
    size_pixels,
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}},
    glyph_ranges::Union{Ptr{Nothing}, Ref{UInt16}}
) -> Ptr{CImGui.lib.ImFont}

Upstream link.

AddFontFromMemoryCompressedBase85TTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    compressed_font_data_base85
) -> Ptr{CImGui.lib.ImFont}
AddFontFromMemoryCompressedBase85TTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    compressed_font_data_base85,
    size_pixels
) -> Ptr{CImGui.lib.ImFont}
AddFontFromMemoryCompressedBase85TTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    compressed_font_data_base85,
    size_pixels,
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}}
) -> Ptr{CImGui.lib.ImFont}
AddFontFromMemoryCompressedBase85TTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    compressed_font_data_base85,
    size_pixels,
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}},
    glyph_ranges::Union{Ptr{Nothing}, Ref{UInt16}}
) -> Ptr{CImGui.lib.ImFont}

'compressedfontdatabase85' still owned by caller. Compress with binarytocompressedc.cpp with -base85 parameter.

Upstream link.

AddFontFromMemoryCompressedTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    compressed_font_data,
    compressed_font_data_size
) -> Ptr{CImGui.lib.ImFont}
AddFontFromMemoryCompressedTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    compressed_font_data,
    compressed_font_data_size,
    size_pixels
) -> Ptr{CImGui.lib.ImFont}
AddFontFromMemoryCompressedTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    compressed_font_data,
    compressed_font_data_size,
    size_pixels,
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}}
) -> Ptr{CImGui.lib.ImFont}
AddFontFromMemoryCompressedTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    compressed_font_data,
    compressed_font_data_size,
    size_pixels,
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}},
    glyph_ranges::Union{Ptr{Nothing}, Ref{UInt16}}
) -> Ptr{CImGui.lib.ImFont}

'compressedfontdata' still owned by caller. Compress with binarytocompressed_c.cpp.

Upstream link.

AddFontFromMemoryTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    font_data,
    font_data_size
) -> Ptr{CImGui.lib.ImFont}
AddFontFromMemoryTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    font_data,
    font_data_size,
    size_pixels
) -> Ptr{CImGui.lib.ImFont}
AddFontFromMemoryTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    font_data,
    font_data_size,
    size_pixels,
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}}
) -> Ptr{CImGui.lib.ImFont}
AddFontFromMemoryTTF(
    self::Ptr{CImGui.lib.ImFontAtlas},
    font_data,
    font_data_size,
    size_pixels,
    font_cfg::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontConfig}},
    glyph_ranges::Union{Ptr{Nothing}, Ref{UInt16}}
) -> Ptr{CImGui.lib.ImFont}

Note: Transfer ownership of 'ttfdata' to ImFontAtlas! Will be deleted after destruction of the atlas. Set fontcfg->FontDataOwnedByAtlas=false to keep ownership of your data and it won't be freed.

Upstream link.

AddImage(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
)
AddImage(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
)
AddImage(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
)
AddImage(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer
)

Image primitives

• Read FAQ to understand what ImTextureID/ImTextureRef are.
• "pmin" and "pmax" represent the upper-left and lower-right corners of the rectangle.
• "uvmin" and "uvmax" represent the normalized texture coordinates to use for those corners. Using (0,0)->(1,1) texture coordinates will generally display the entire texture.

Upstream link.

AddImageQuad(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
)
AddImageQuad(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
)
AddImageQuad(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
)
AddImageQuad(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
)
AddImageQuad(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
)
AddImageQuad(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer
)

Upstream link.

AddImageRounded(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rounding
)
AddImageRounded(
    self::Ptr{CImGui.lib.ImDrawList},
    tex_ref::CImGui.lib.ImTextureRef,
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    uv_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rounding,
    flags::Union{CImGui.lib.ImDrawFlags_, Integer}
)

Upstream link.

AddInputCharacter(self::Ptr{CImGui.lib.ImGuiIO}, c)

Queue a new character input.

Upstream link.

AddInputCharacterUTF16(
    self::Ptr{CImGui.lib.ImGuiIO},
    c::UInt16
)

Queue a new character input from a UTF-16 character, it can be a surrogate.

Upstream link.

AddInputCharactersUTF8(self::Ptr{CImGui.lib.ImGuiIO}, str)

Queue a new characters input from a UTF-8 string.

Upstream link.

AddKeyAnalogEvent(
    self::Ptr{CImGui.lib.ImGuiIO},
    key::CImGui.lib.ImGuiKey,
    down,
    v
)

Queue a new key down/up event for analog values (e.g. ImGuiKeyGamepad values). Dead-zones should be handled by the backend.

Upstream link.

AddKeyEvent(
    self::Ptr{CImGui.lib.ImGuiIO},
    key::CImGui.lib.ImGuiKey,
    down
)

Input Functions// Queue a new key down/up event. Key should be "translated" (as in, generally ImGuiKey_A matches the key end-user would use to emit an 'A' character).

Upstream link.

AddLine(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer
)
AddLine(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    thickness
)

Primitives

• Filled shapes must always use clockwise winding order. The anti-aliasing fringe depends on it. Counter-clockwise shapes will have "inward" anti-aliasing.
• For rectangular primitives, "pmin" and "pmax" represent the upper-left and lower-right corners.
• For circle primitives, use "numsegments == 0" to automatically calculate tessellation (preferred). In older versions (until Dear ImGui 1.77) the AddCircle functions defaulted to numsegments == 12. In future versions we will use textures to provide cheaper and higher-quality circles. Use AddNgon() and AddNgonFilled() functions if you need to guarantee a specific number of sides.

Upstream link.

AddLineH(
    self::Ptr{CImGui.lib.ImDrawList},
    min_x,
    max_x,
    y,
    col::Integer
)
AddLineH(
    self::Ptr{CImGui.lib.ImDrawList},
    min_x,
    max_x,
    y,
    col::Integer,
    thickness
)

Upstream link.

AddLineV(
    self::Ptr{CImGui.lib.ImDrawList},
    x,
    min_y,
    max_y,
    col::Integer
)
AddLineV(
    self::Ptr{CImGui.lib.ImDrawList},
    x,
    min_y,
    max_y,
    col::Integer,
    thickness
)

Upstream link.

AddMouseButtonEvent(
    self::Ptr{CImGui.lib.ImGuiIO},
    button,
    down
)

Queue a mouse button change.

Upstream link.

AddMousePosEvent(self::Ptr{CImGui.lib.ImGuiIO}, x, y)

Queue a mouse position update. Use -FLTMAX,-FLTMAX to signify no mouse (e.g. app not focused and not hovered).

Upstream link.

AddMouseSourceEvent(
    self::Ptr{CImGui.lib.ImGuiIO},
    source::CImGui.lib.ImGuiMouseSource
)

Queue a mouse source change (Mouse/TouchScreen/Pen).

Upstream link.

AddMouseViewportEvent(
    self::Ptr{CImGui.lib.ImGuiIO},
    id::Integer
)

Queue a mouse hovered viewport. Requires backend to set ImGuiBackendFlags_HasMouseHoveredViewport to call this (for multi-viewport support).

Upstream link.

AddMouseWheelEvent(
    self::Ptr{CImGui.lib.ImGuiIO},
    wheel_x,
    wheel_y
)

Queue a mouse wheel update. wheely<0: scroll down, wheely>0: scroll up, wheelx<0: scroll right, wheelx>0: scroll left.

Upstream link.

AddNgon(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius,
    col::Integer,
    num_segments
)
AddNgon(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius,
    col::Integer,
    num_segments,
    thickness
)

Upstream link.

AddNgonFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    center::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    radius,
    col::Integer,
    num_segments
)

Upstream link.

AddPolyline(
    self::Ptr{CImGui.lib.ImDrawList},
    points::Union{Ptr{Nothing}, Ref{CImGui.lib.ImVec2}, Ref{Tuple{T, T} where T}},
    num_points,
    col::Integer,
    thickness
)
AddPolyline(
    self::Ptr{CImGui.lib.ImDrawList},
    points::Union{Ptr{Nothing}, Ref{CImGui.lib.ImVec2}, Ref{Tuple{T, T} where T}},
    num_points,
    col::Integer,
    thickness,
    flags::Union{CImGui.lib.ImDrawFlags_, Integer}
)

General polygon

• Only simple polygons are supported by filling functions (no self-intersections, no holes).
• Concave polygon fill is more expensive than convex one: it has O(N^2) complexity. Provided as a convenience for the user but not used by the main library.

Upstream link.

AddQuad(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer
)
AddQuad(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    thickness
)

Upstream link.

AddQuadFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p4::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer
)

Upstream link.

AddRanges(
    self::Ptr{CImGui.lib.ImFontGlyphRangesBuilder},
    ranges::Union{Ptr{Nothing}, Ref{UInt16}}
)

Add ranges, e.g. builder.AddRanges(ImFontAtlas::GetGlyphRangesDefault()) to force add all of ASCII/Latin+Ext.

Upstream link.

AddRect(
    self::Ptr{CImGui.lib.ImDrawList},
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer
)
AddRect(
    self::Ptr{CImGui.lib.ImDrawList},
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rounding
)
AddRect(
    self::Ptr{CImGui.lib.ImDrawList},
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rounding,
    thickness
)
AddRect(
    self::Ptr{CImGui.lib.ImDrawList},
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rounding,
    thickness,
    flags::Union{CImGui.lib.ImDrawFlags_, Integer}
)

A: upper-left, b: lower-right (== upper-left + size).

Upstream link.

AddRectFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer
)
AddRectFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rounding
)
AddRectFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    rounding,
    flags::Union{CImGui.lib.ImDrawFlags_, Integer}
)

A: upper-left, b: lower-right (== upper-left + size).

Upstream link.

AddRectFilledMultiColor(
    self::Ptr{CImGui.lib.ImDrawList},
    p_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col_upr_left::Integer,
    col_upr_right::Integer,
    col_bot_right::Integer,
    col_bot_left::Integer
)

Upstream link.

AddRemapChar(
    self::Ptr{CImGui.lib.ImFont},
    from_codepoint::UInt16,
    to_codepoint::UInt16
)

Makes 'fromcodepoint' character points to 'tocodepoint' glyph.

Upstream link.

AddSettingsHandler(
    handler::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiSettingsHandler}}
)

Upstream link.

AddText(
    self::Ptr{CImGui.lib.ImDrawList},
    pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    text_begin::Union{Ptr{Int8}, Ptr{Nothing}, String}
)
AddText(
    self::Ptr{CImGui.lib.ImDrawList},
    pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    text_begin::Union{Ptr{Int8}, Ptr{Nothing}, String},
    text_end::Union{Ptr{Int8}, Ptr{Nothing}, String}
)

Upstream link.

AddText(
    self::Ptr{CImGui.lib.ImDrawList},
    font::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFont}},
    font_size::Real,
    pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    text_begin::Union{Ptr{Int8}, Ptr{Nothing}, String}
)
AddText(
    self::Ptr{CImGui.lib.ImDrawList},
    font::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFont}},
    font_size::Real,
    pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    text_begin::Union{Ptr{Int8}, Ptr{Nothing}, String},
    text_end::Union{Ptr{Int8}, Ptr{Nothing}, String}
)
AddText(
    self::Ptr{CImGui.lib.ImDrawList},
    font::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFont}},
    font_size::Real,
    pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    text_begin::Union{Ptr{Int8}, Ptr{Nothing}, String},
    text_end::Union{Ptr{Int8}, Ptr{Nothing}, String},
    wrap_width::Real
)
AddText(
    self::Ptr{CImGui.lib.ImDrawList},
    font::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFont}},
    font_size::Real,
    pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    text_begin::Union{Ptr{Int8}, Ptr{Nothing}, String},
    text_end::Union{Ptr{Int8}, Ptr{Nothing}, String},
    wrap_width::Real,
    cpu_fine_clip_rect::Union{Ptr{Nothing}, Ref{CImGui.lib.ImVec4}, Ref{NTuple{4, T} where T}}
)

Upstream link.

AddText(
    self::Ptr{CImGui.lib.ImFontGlyphRangesBuilder},
    text
)
AddText(
    self::Ptr{CImGui.lib.ImFontGlyphRangesBuilder},
    text,
    text_end
)

Add string (each character of the UTF-8 string are added).

Upstream link.

AddTriangle(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer
)
AddTriangle(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer,
    thickness
)

Upstream link.

AddTriangleFilled(
    self::Ptr{CImGui.lib.ImDrawList},
    p1::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p2::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    p3::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    col::Integer
)

Upstream link.

AddX(self::Ptr{CImGui.lib.ImRect}, x)

Upstream link.

AddY(self::Ptr{CImGui.lib.ImRect}, y)

Upstream link.

AlignTextToFramePadding()

Vertically align upcoming text baseline to FramePadding.y so that it will align properly to regularly framed items (call if you have text on a line before a framed item).

Upstream link.

Append(self::Ptr{CImGui.lib.ImGuiTextBuffer}, str)
Append(self::Ptr{CImGui.lib.ImGuiTextBuffer}, str, str_end)

Upstream link.

Append(
    self::Ptr{CImGui.lib.ImGuiTextIndex},
    base,
    old_size,
    new_size
)

Upstream link.

Appendf(self::Ptr{CImGui.lib.ImGuiTextBuffer}, fmt)

Upstream link.

ApplyRequests(
    self::Ptr{CImGui.lib.ImGuiSelectionBasicStorage},
    ms_io::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiMultiSelectIO}}
)

Apply selection requests coming from BeginMultiSelect() and EndMultiSelect() functions. It uses 'items_count' passed to BeginMultiSelect().

Upstream link.

ApplyRequests(
    self::Ptr{CImGui.lib.ImGuiSelectionExternalStorage},
    ms_io::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiMultiSelectIO}}
)

Apply selection requests by using AdapterSetItemSelected() calls.

Upstream link.

ArrowButton(str_id, dir::CImGui.lib.ImGuiDir) -> Bool

Square button with an arrow shape.

Upstream link.

ArrowButtonEx(
    str_id,
    dir::CImGui.lib.ImGuiDir,
    size_arg::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Bool
ArrowButtonEx(
    str_id,
    dir::CImGui.lib.ImGuiDir,
    size_arg::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    flags::Union{CImGui.lib.ImGuiButtonFlags_, Integer}
) -> Bool

Upstream link.

AsVec4(
    self::Ptr{CImGui.lib.ImRect}
) -> Ptr{CImGui.lib.ImVec4}

Upstream link.

Begin(name::Union{Ptr{Int8}, Ptr{Nothing}, String}) -> Bool
Begin(
    name::Union{Ptr{Int8}, Ptr{Nothing}, String},
    p_open
) -> Bool
Begin(
    name::Union{Ptr{Int8}, Ptr{Nothing}, String},
    p_open,
    flags::Union{CImGui.lib.ImGuiWindowFlags_, Integer}
) -> Bool

Windows

• Begin() = push window to the stack and start appending to it. End() = pop window from the stack.
• Passing 'bool* p_open != NULL' shows a window-closing widget in the upper-right corner of the window, which clicking will set the boolean to false when clicked.
• You may append multiple times to the same window during the same frame by calling Begin()/End() pairs multiple times. Some information such as 'flags' or 'p_open' will only be considered by the first call to Begin().
• Begin() return false to indicate the window is collapsed or fully clipped, so you may early out and omit submitting anything to the window. Always call a matching End() for each Begin() call, regardless of its return value! [Important: due to legacy reason, Begin/End and BeginChild/EndChild are inconsistent with all other functions such as BeginMenu/EndMenu, BeginPopup/EndPopup, etc. where the EndXXX call should only be called if the corresponding BeginXXX function returned true. Begin and BeginChild are the only odd ones out. Will be fixed in a future update.]
• Note that the bottom of window stack always contains a window called "Debug".

Upstream link.

Begin(self::Ptr{CImGui.lib.ImGuiListClipper}, items_count)
Begin(
    self::Ptr{CImGui.lib.ImGuiListClipper},
    items_count,
    items_height
)

Upstream link.

Begin(self::Ptr{CImGui.lib.ImGuiTextBuffer}) -> Ptr{Int8}

Upstream link.

BeginBoxSelect(
    scope_rect::CImGui.lib.ImRect,
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    box_select_id::Integer,
    ms_flags::Union{CImGui.lib.ImGuiMultiSelectFlags_, Integer}
) -> Bool

Box-Select API.

Upstream link.

BeginChild(
    str_id::Union{Ptr{Int8}, Ptr{Nothing}, String}
) -> Bool
BeginChild(
    str_id::Union{Ptr{Int8}, Ptr{Nothing}, String},
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Bool
BeginChild(
    str_id::Union{Ptr{Int8}, Ptr{Nothing}, String},
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    child_flags::Union{CImGui.lib.ImGuiChildFlags_, Integer}
) -> Bool
BeginChild(
    str_id::Union{Ptr{Int8}, Ptr{Nothing}, String},
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    child_flags::Union{CImGui.lib.ImGuiChildFlags_, Integer},
    window_flags::Union{CImGui.lib.ImGuiWindowFlags_, Integer}
) -> Bool

Child Windows

• Use child windows to begin into a self-contained independent scrolling/clipping regions within a host window. Child windows can embed their own child.
• Before 1.90 (November 2023), the "ImGuiChildFlags childflags = 0" parameter was "bool border = false". This API is backward compatible with old code, as we guarantee that ImGuiChildFlagsBorders == true. Consider updating your old code: BeginChild("Name", size, false) -> Begin("Name", size, 0); or Begin("Name", size, ImGuiChildFlagsNone); BeginChild("Name", size, true) -> Begin("Name", size, ImGuiChildFlagsBorders);
• Manual sizing (each axis can use a different setting e.g. ImVec2(0.0f, 400.0f)): == 0.0f: use remaining parent window size for this axis.

  0.0f: use specified size for this axis.

  < 0.0f: right/bottom-align to specified distance from available content boundaries.
• Specifying ImGuiChildFlagsAutoResizeX or ImGuiChildFlagsAutoResizeY makes the sizing automatic based on child contents. Combining both ImGuiChildFlagsAutoResizeX _and ImGuiChildFlags_AutoResizeY defeats purpose of a scrolling region and is NOT recommended.
• BeginChild() returns false to indicate the window is collapsed or fully clipped, so you may early out and omit submitting anything to the window. Always call a matching EndChild() for each BeginChild() call, regardless of its return value. [Important: due to legacy reason, Begin/End and BeginChild/EndChild are inconsistent with all other functions such as BeginMenu/EndMenu, BeginPopup/EndPopup, etc. where the EndXXX call should only be called if the corresponding BeginXXX function returned true. Begin and BeginChild are the only odd ones out. Will be fixed in a future update.].

Upstream link.

BeginChild(id::Integer) -> Bool
BeginChild(
    id::Integer,
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Bool
BeginChild(
    id::Integer,
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    child_flags::Union{CImGui.lib.ImGuiChildFlags_, Integer}
) -> Bool
BeginChild(
    id::Integer,
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    child_flags::Union{CImGui.lib.ImGuiChildFlags_, Integer},
    window_flags::Union{CImGui.lib.ImGuiWindowFlags_, Integer}
) -> Bool

Upstream link.

BeginChildEx(
    name,
    id::Integer,
    size_arg::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    child_flags::Union{CImGui.lib.ImGuiChildFlags_, Integer},
    window_flags::Union{CImGui.lib.ImGuiWindowFlags_, Integer}
) -> Bool

Childs.

Upstream link.

BeginColumns(str_id, count)
BeginColumns(
    str_id,
    count,
    flags::Union{CImGui.lib.ImGuiOldColumnFlags_, Integer}
)

Setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns().

Upstream link.

BeginCombo(label, preview_value) -> Bool
BeginCombo(
    label,
    preview_value,
    flags::Union{CImGui.lib.ImGuiComboFlags_, Integer}
) -> Bool

Widgets: Combo Box (Dropdown)

• The BeginCombo()/EndCombo() api allows you to manage your contents and selection state however you want it, by creating e.g. Selectable() items.
• The old Combo() api are helpers over BeginCombo()/EndCombo() which are kept available for convenience purpose. This is analogous to how ListBox are created.

Upstream link.

BeginComboPopup(
    popup_id::Integer,
    bb::CImGui.lib.ImRect,
    flags::Union{CImGui.lib.ImGuiComboFlags_, Integer}
) -> Bool

Combos.

Upstream link.

BeginComboPreview() -> Bool

Upstream link.

BeginDisabled()
BeginDisabled(disabled)

Disabling [BETA API]

• Disable all user interactions and dim items visuals (applying style.DisabledAlpha over current colors)
• Those can be nested but it cannot be used to enable an already disabled section (a single BeginDisabled(true) in the stack is enough to keep everything disabled)
• Tooltips windows are automatically opted out of disabling. Note that IsItemHovered() by default returns false on disabled items, unless using ImGuiHoveredFlags_AllowWhenDisabled.
• BeginDisabled(false)/EndDisabled() essentially does nothing but is provided to facilitate use of boolean expressions (as a micro-optimization: if you have tens of thousands of BeginDisabled(false)/EndDisabled() pairs, you might want to reformulate your code to avoid making those calls).

Upstream link.

BeginDisabledOverrideReenable()

Upstream link.

BeginDockableDragDropSource(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
)

Upstream link.

BeginDockableDragDropTarget(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
)

Upstream link.

BeginDocked(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    p_open
)

Upstream link.

BeginDragDropSource() -> Bool
BeginDragDropSource(
    flags::Union{CImGui.lib.ImGuiDragDropFlags_, Integer}
) -> Bool

Drag and Drop

• On source items, call BeginDragDropSource(), if it returns true also call SetDragDropPayload() + EndDragDropSource().
• On target candidates, call BeginDragDropTarget(), if it returns true also call AcceptDragDropPayload() + EndDragDropTarget().
• If you stop calling BeginDragDropSource() the payload is preserved however it won't have a preview tooltip (we currently display a fallback "..." tooltip, see #1725)
• An item can be both drag source and drop target.// call after submitting an item which may be dragged. when this return true, you can call SetDragDropPayload() + EndDragDropSource().

Upstream link.

BeginDragDropTarget() -> Bool

Call after submitting an item that may receive a payload. If this returns true, you can call AcceptDragDropPayload() + EndDragDropTarget().

Upstream link.

BeginDragDropTargetCustom(
    bb::CImGui.lib.ImRect,
    id::Integer
) -> Bool

Upstream link.

BeginDragDropTargetViewport(
    viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewport}}
) -> Bool
BeginDragDropTargetViewport(
    viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewport}},
    p_bb::Union{Ptr{Nothing}, Ref{CImGui.lib.ImRect}}
) -> Bool

Upstream link.

BeginErrorTooltip() -> Bool

Upstream link.

BeginGroup()

Lock horizontal starting position.

Upstream link.

BeginItemTooltip() -> Bool

Tooltips: helpers for showing a tooltip when hovering an item

• BeginItemTooltip() is a shortcut for the 'if (IsItemHovered(ImGuiHoveredFlags_ForTooltip) && BeginTooltip())' idiom.
• SetItemTooltip() is a shortcut for the 'if (IsItemHovered(ImGuiHoveredFlags_ForTooltip)) SetTooltip(...); ' idiom.
• Where 'ImGuiHoveredFlagsForTooltip' itself is a shortcut to use 'style.HoverFlagsForTooltipMouse' or 'style.HoverFlagsForTooltipNav' depending on active input type. For mouse it defaults to 'ImGuiHoveredFlagsStationary | ImGuiHoveredFlags_DelayShort'.// begin/append a tooltip window if preceding item was hovered.

Upstream link.

BeginListBox(label) -> Bool
BeginListBox(
    label,
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Bool

Widgets: List Boxes

• This is essentially a thin wrapper to using BeginChild/EndChild with the ImGuiChildFlags_FrameStyle flag for stylistic changes + displaying a label.
• If you don't need a label you can probably simply use BeginChild() with the ImGuiChildFlags_FrameStyle flag for the same result.
• You can submit contents and manage your selection state however you want it, by creating e.g. Selectable() or any other items.
• The simplified/old ListBox() api are helpers over BeginListBox()/EndListBox() which are kept available for convenience purpose. This is analogous to how Combos are created.
• Choose frame width: size.x > 0.0f: custom / size.x < 0.0f or -FLT_MIN: right-align / size.x = 0.0f (default): use current ItemWidth
• Choose frame height: size.y > 0.0f: custom / size.y < 0.0f or -FLT_MIN: bottom-align / size.y = 0.0f (default): arbitrary default height which can fit ~7 items// open a framed scrolling region.

Upstream link.

BeginMainMenuBar() -> Bool

Create and append to a full screen menu-bar.

Upstream link.

BeginMenu(label) -> Bool
BeginMenu(label, enabled) -> Bool

Create a sub-menu entry. only call EndMenu() if this returns true!

Upstream link.

BeginMenuBar() -> Bool

Widgets: Menus

• Use BeginMenuBar() on a window ImGuiWindowFlags_MenuBar to append to its menu bar.
• Use BeginMainMenuBar() to create a menu bar at the top of the screen and append to it.
• Use BeginMenu() to create a menu. You can call BeginMenu() multiple time with the same identifier to append more items to it.
• Note that MenuItem() keyboard shortcuts are displayed as a convenience but not processed by Dear ImGui at the moment.// append to menu-bar of current window (requires ImGuiWindowFlags_MenuBar flag set on parent window).

Upstream link.

BeginMenuEx(label, icon) -> Bool
BeginMenuEx(label, icon, enabled) -> Bool

Upstream link.

BeginMultiSelect(
    flags::Union{CImGui.lib.ImGuiMultiSelectFlags_, Integer}
) -> Ptr{CImGui.lib.ImGuiMultiSelectIO}
BeginMultiSelect(
    flags::Union{CImGui.lib.ImGuiMultiSelectFlags_, Integer},
    selection_size
) -> Ptr{CImGui.lib.ImGuiMultiSelectIO}
BeginMultiSelect(
    flags::Union{CImGui.lib.ImGuiMultiSelectFlags_, Integer},
    selection_size,
    items_count
) -> Ptr{CImGui.lib.ImGuiMultiSelectIO}

Multi-selection system for Selectable(), Checkbox(), TreeNode() functions [BETA]

• This enables standard multi-selection/range-selection idioms (Ctrl+Mouse/Keyboard, Shift+Mouse/Keyboard, etc.) in a way that also allow a clipper to be used.
• ImGuiSelectionUserData is often used to store your item index within the current view (but may store something else).
• Read comments near ImGuiMultiSelectIO for instructions/details and see 'Demo->Widgets->Selection State & Multi-Select' for demo.
• TreeNode() is technically supported but... using this correctly is more complicated. You need some sort of linear/random access to your tree, which is suited to advanced trees setups already implementing filters and clipper. We will work simplifying the current demo.
• 'selectionsize' and 'itemscount' parameters are optional and used by a few features. If they are costly for you to compute, you may avoid them.

Upstream link.

BeginPopup(str_id) -> Bool
BeginPopup(
    str_id,
    flags::Union{CImGui.lib.ImGuiWindowFlags_, Integer}
) -> Bool

Popups, Modals

• They block normal mouse hovering detection (and therefore most mouse interactions) behind them.
• If not modal: they can be closed by clicking anywhere outside them, or by pressing Escape (call 'Shortcut(ImGuiKey_Escape)' to claim a higher-priority shortcut).
• Their visibility state (~bool) is held internally instead of being held by the programmer as we are used to with regular Begin*() calls.
• The 3 properties above are related: we need to retain popup visibility state in the library because popups may be closed as any time.
• You can bypass the hovering restriction by using ImGuiHoveredFlags_AllowWhenBlockedByPopup when calling IsItemHovered() or IsWindowHovered().
• IMPORTANT: Popup identifiers are relative to the current ID stack, so OpenPopup and BeginPopup generally needs to be at the same level of the stack. This is sometimes leading to confusing mistakes. May rework this in the future.
• BeginPopup(): query popup state, if open start appending into the window. Call EndPopup() afterwards if returned true. ImGuiWindowFlags are forwarded to the window.
• BeginPopupModal(): block every interaction behind the window, cannot be closed by user, add a dimming background, has a title bar.// return true if the popup is open, and you can start outputting to it.

Upstream link.

BeginPopupContextItem() -> Bool
BeginPopupContextItem(str_id) -> Bool
BeginPopupContextItem(
    str_id,
    popup_flags::Union{CImGui.lib.ImGuiPopupFlags_, Integer}
) -> Bool

Popups: Open+Begin popup combined functions helpers to create context menus.

• Helpers to do OpenPopup+BeginPopup where the Open action is triggered by e.g. hovering an item and right-clicking.
• IMPORTANT: Notice that BeginPopupContextXXX takes ImGuiPopupFlags just like OpenPopup() and unlike BeginPopup(). For full consistency, we may add ImGuiWindowFlags to the BeginPopupContextXXX functions in the future.
• IMPORTANT: If you ever used the left mouse button with BeginPopupContextXXX() helpers before 1.92.6:
  • Before this version, OpenPopupOnItemClick(), BeginPopupContextItem(), BeginPopupContextWindow(), BeginPopupContextVoid() had 'a ImGuiPopupFlags popup_flags = 1' default value in their function signature.
  • Before: Explicitly passing a literal 0 meant ImGuiPopupFlagsMouseButtonLeft. The default = 1 meant ImGuiPopupFlagsMouseButtonRight.
  • After: The default = 0 means ImGuiPopupFlagsMouseButtonRight. Explicitly passing a literal 1 also means ImGuiPopupFlagsMouseButtonRight (if legacy behavior are enabled) or will assert (if legacy behavior are disabled).
  • TL;DR: if you don't want to use right mouse button for popups, always specify it explicitly using a named ImGuiPopupFlags_MouseButtonXXXX value.
  • Read "API BREAKING CHANGES" 2026/01/07 (1.92.6) entry in imgui.cpp or GitHub topic #9157 for all details.// open+begin popup when clicked on last item. Use str_id==NULL to associate the popup to previous item. If you want to use that on a non-interactive item such as Text() you need to pass in an explicit ID here. read comments in .cpp!

Upstream link.

BeginPopupContextVoid() -> Bool
BeginPopupContextVoid(str_id) -> Bool
BeginPopupContextVoid(
    str_id,
    popup_flags::Union{CImGui.lib.ImGuiPopupFlags_, Integer}
) -> Bool

Open+begin popup when clicked in void (where there are no windows).

Upstream link.

BeginPopupContextWindow() -> Bool
BeginPopupContextWindow(str_id) -> Bool
BeginPopupContextWindow(
    str_id,
    popup_flags::Union{CImGui.lib.ImGuiPopupFlags_, Integer}
) -> Bool

Open+begin popup when clicked on current window.

Upstream link.

BeginPopupEx(
    id::Integer,
    extra_window_flags::Union{CImGui.lib.ImGuiWindowFlags_, Integer}
) -> Bool

Popups, Modals.

Upstream link.

BeginPopupMenuEx(
    id::Integer,
    label,
    extra_window_flags::Union{CImGui.lib.ImGuiWindowFlags_, Integer}
) -> Bool

Upstream link.

BeginPopupModal(name) -> Bool
BeginPopupModal(name, p_open) -> Bool
BeginPopupModal(
    name,
    p_open,
    flags::Union{CImGui.lib.ImGuiWindowFlags_, Integer}
) -> Bool

Return true if the modal is open, and you can start outputting to it.

Upstream link.

BeginTabBar(str_id) -> Bool
BeginTabBar(
    str_id,
    flags::Union{CImGui.lib.ImGuiTabBarFlags_, Integer}
) -> Bool

Tab Bars, Tabs

• Note: Tabs are automatically created by the docking system (when in 'docking' branch). Use this to create tab bars/tabs yourself.// create and append into a TabBar.

Upstream link.

BeginTabBarEx(
    tab_bar::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiTabBar}},
    bb::CImGui.lib.ImRect,
    flags::Union{CImGui.lib.ImGuiTabBarFlags_, Integer}
) -> Bool

Upstream link.

BeginTabItem(label) -> Bool
BeginTabItem(label, p_open) -> Bool
BeginTabItem(
    label,
    p_open,
    flags::Union{CImGui.lib.ImGuiTabItemFlags_, Integer}
) -> Bool

Create a Tab. Returns true if the Tab is selected.

Upstream link.

BeginTable(str_id, columns) -> Bool
BeginTable(
    str_id,
    columns,
    flags::Union{CImGui.lib.ImGuiTableFlags_, Integer}
) -> Bool
BeginTable(
    str_id,
    columns,
    flags::Union{CImGui.lib.ImGuiTableFlags_, Integer},
    outer_size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Bool
BeginTable(
    str_id,
    columns,
    flags::Union{CImGui.lib.ImGuiTableFlags_, Integer},
    outer_size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    inner_width
) -> Bool

Tables

• Full-featured replacement for old Columns API.
• See Demo->Tables for demo code. See top of imgui_tables.cpp for general commentary.
• See ImGuiTableFlags_ and ImGuiTableColumnFlags_ enums for a description of available flags.

The typical call flow is:

• 1. Call BeginTable(), early out if returning false.
• 1. Optionally call TableSetupColumn() to submit column name/flags/defaults.
• 1. Optionally call TableSetupScrollFreeze() to request scroll freezing of columns/rows.
• 1. Optionally call TableHeadersRow() to submit a header row. Names are pulled from TableSetupColumn() data.
• 1. Populate contents:
  • In most situations you can use TableNextRow() + TableSetColumnIndex(N) to start appending into a column.
  • If you are using tables as a sort of grid, where every column is holding the same type of contents, you may prefer using TableNextColumn() instead of TableNextRow() + TableSetColumnIndex(). TableNextColumn() will automatically wrap-around into the next row if needed.
  • IMPORTANT: Comparatively to the old Columns() API, we need to call TableNextColumn() for the first column!
  • Summary of possible call flow:
    • TableNextRow() -> TableSetColumnIndex(0) -> Text("Hello 0") -> TableSetColumnIndex(1) -> Text("Hello 1") // OK
    • TableNextRow() -> TableNextColumn() -> Text("Hello 0") -> TableNextColumn() -> Text("Hello 1") // OK

    •               TableNextColumn()      -> Text("Hello 0") -> TableNextColumn()      -> Text("Hello 1")  // OK: TableNextColumn() automatically gets to next row!

    • TableNextRow() -> Text("Hello 0") // Not OK! Missing TableSetColumnIndex() or TableNextColumn()! Text will not appear!
• 1. Call EndTable().

Upstream link.

BeginTableEx(name, id::Integer, columns_count) -> Bool
BeginTableEx(
    name,
    id::Integer,
    columns_count,
    flags::Union{CImGui.lib.ImGuiTableFlags_, Integer}
) -> Bool
BeginTableEx(
    name,
    id::Integer,
    columns_count,
    flags::Union{CImGui.lib.ImGuiTableFlags_, Integer},
    outer_size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Bool
BeginTableEx(
    name,
    id::Integer,
    columns_count,
    flags::Union{CImGui.lib.ImGuiTableFlags_, Integer},
    outer_size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    inner_width
) -> Bool

Upstream link.

BeginTooltip() -> Bool

Tooltips

• Tooltips are windows following the mouse. They do not take focus away.
• A tooltip window can contain items of any types.
• SetTooltip() is more or less a shortcut for the 'if (BeginTooltip()) Text(...); EndTooltip(); ' idiom (with a subtlety that it discard any previously submitted tooltip)// begin/append a tooltip window.

Upstream link.

BeginTooltipEx(
    tooltip_flags::Union{CImGui.lib.ImGuiTooltipFlags_, Integer},
    extra_window_flags::Union{CImGui.lib.ImGuiWindowFlags_, Integer}
) -> Bool

Tooltips.

Upstream link.

BeginTooltipHidden() -> Bool

Upstream link.

BeginViewportSideBar(
    name,
    viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewport}},
    dir::CImGui.lib.ImGuiDir,
    size,
    window_flags::Union{CImGui.lib.ImGuiWindowFlags_, Integer}
) -> Bool

Menus.

Upstream link.

BringWindowToDisplayBack(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
)

Upstream link.

BringWindowToDisplayBehind(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    above_window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
)

Upstream link.

BringWindowToDisplayFront(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
)

Upstream link.

BringWindowToFocusFront(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
)

Upstream link.

Build(self::Ptr{CImGui.lib.ImGuiTextFilter})

Upstream link.

BuildRanges(
    self::Ptr{CImGui.lib.ImFontGlyphRangesBuilder},
    out_ranges::Union{Ptr{Nothing}, Ref{CImGui.lib.ImVector_ImWchar}}
)

Output new ranges.

Upstream link.

BuildSortByKey(self::Ptr{CImGui.lib.ImGuiStorage})

Advanced: for quicker full rebuild of a storage (instead of an incremental one), you may add all your contents and then sort once.

Upstream link.

Bullet()

Draw a small circle + keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses.

Upstream link.

BulletText(fmt)

Shortcut for Bullet()+Text().

Upstream link.

Button(label) -> Bool
Button(
    label,
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Bool

Widgets: Main

• Most widgets return true when the value has been changed or when pressed/selected
• You may also use one of the many IsItemXXX functions (e.g. IsItemActive, IsItemHovered, etc.) to query widget state.// button.

Upstream link.

ButtonBehavior(
    bb::CImGui.lib.ImRect,
    id::Integer,
    out_hovered,
    out_held
) -> Bool
ButtonBehavior(
    bb::CImGui.lib.ImRect,
    id::Integer,
    out_hovered,
    out_held,
    flags::Union{CImGui.lib.ImGuiButtonFlags_, Integer}
) -> Bool

Widgets low-level behaviors.

Upstream link.

ButtonEx(label) -> Bool
ButtonEx(
    label,
    size_arg::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Bool
ButtonEx(
    label,
    size_arg::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    flags::Union{CImGui.lib.ImGuiButtonFlags_, Integer}
) -> Bool

Widgets.

Upstream link.

C_str(self::Ptr{CImGui.lib.ImGuiTextBuffer}) -> Ptr{Int8}

Upstream link.

CalcClipRectVisibleItemsY(
    clip_rect::CImGui.lib.ImRect,
    pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    items_height,
    out_visible_start,
    out_visible_end
)

Upstream link.

CalcItemSize(
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    default_w,
    default_h
) -> CImGui.lib.ImVec2

Upstream link.

CalcItemWidth() -> Float32

Width of item given pushed settings and current cursor position. NOT necessarily the width of last item unlike most 'Item' functions.

Upstream link.

CalcNextTotalWidth(
    self::Ptr{CImGui.lib.ImGuiMenuColumns},
    update_offsets
)

Upstream link.

CalcRoundingFlagsForRectInRect(
    r_in::CImGui.lib.ImRect,
    r_outer::CImGui.lib.ImRect,
    threshold
) -> Int32

Upstream link.

CalcTextSize(text) -> CImGui.lib.ImVec2
CalcTextSize(text, text_end) -> CImGui.lib.ImVec2
CalcTextSize(
    text,
    text_end,
    hide_text_after_double_hash
) -> CImGui.lib.ImVec2
CalcTextSize(
    text,
    text_end,
    hide_text_after_double_hash,
    wrap_width
) -> CImGui.lib.ImVec2

Text Utilities.

Upstream link.

CalcTextSizeA(
    self::Ptr{CImGui.lib.ImFont},
    size,
    max_width,
    wrap_width,
    text_begin
) -> CImGui.lib.ImVec2
CalcTextSizeA(
    self::Ptr{CImGui.lib.ImFont},
    size,
    max_width,
    wrap_width,
    text_begin,
    text_end
) -> CImGui.lib.ImVec2
CalcTextSizeA(
    self::Ptr{CImGui.lib.ImFont},
    size,
    max_width,
    wrap_width,
    text_begin,
    text_end,
    out_remaining
) -> CImGui.lib.ImVec2

Upstream link.

CalcTypematicRepeatAmount(
    t0,
    t1,
    repeat_delay,
    repeat_rate
) -> Int32

Upstream link.

CalcWindowNextAutoFitSize(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
) -> CImGui.lib.ImVec2

Upstream link.

CalcWordWrapPosition(
    self::Ptr{CImGui.lib.ImFont},
    size,
    text,
    text_end,
    wrap_width
) -> Ptr{Int8}

Upstream link.

CalcWorkRectPos(
    self::Ptr{CImGui.lib.ImGuiViewportP},
    inset_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> CImGui.lib.ImVec2

Calculate work rect pos/size given a set of offset (we have 1 pair of offset for rect locked from last frame data, and 1 pair for currently building rect).

Upstream link.

CalcWorkRectSize(
    self::Ptr{CImGui.lib.ImGuiViewportP},
    inset_min::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    inset_max::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> CImGui.lib.ImVec2

Upstream link.

CalcWrapWidthForPos(
    pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    wrap_pos_x
) -> Float32

Upstream link.

CallContextHooks(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}},
    type::CImGui.lib.ImGuiContextHookType
)

Upstream link.

ChannelsMerge(self::Ptr{CImGui.lib.ImDrawList})

Upstream link.

ChannelsSetCurrent(self::Ptr{CImGui.lib.ImDrawList}, n)

Upstream link.

ChannelsSplit(self::Ptr{CImGui.lib.ImDrawList}, count)

Advanced: Channels

• Use to split render into layers. By switching channels to can render out-of-order (e.g. submit FG primitives before BG primitives)
• Use to minimize draw calls (e.g. if going back-and-forth between multiple clipping rectangles, prefer to append into separate channels then merge at the end)
• This API shouldn't have been in ImDrawList in the first place! Prefer using your own persistent instance of ImDrawListSplitter as you can stack them. Using the ImDrawList::ChannelsXXXX you cannot stack a split over another.

Upstream link.

Checkbox(label, v) -> Bool

Upstream link.

CheckboxFlags(
    label::Union{Ptr{Int8}, Ptr{Nothing}, String},
    flags::Ref{Int32},
    flags_value
) -> Bool

Upstream link.

CheckboxFlags(
    label::Union{Ptr{Int8}, Ptr{Nothing}, String},
    flags::Ref{UInt32},
    flags_value
) -> Bool

Upstream link.

CleanupIniSettings(
    args::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiSettingsCleanupArgs}}
)

[BETA] Expected to turn into a public API. Please report if you are using this!

Upstream link.

Clear(self::Ptr{CImGui.lib.ImBitVector})

Upstream link.

Clear(self::Ptr{CImGui.lib.ImDrawData})

Upstream link.

Clear(self::Ptr{CImGui.lib.ImDrawListSplitter})

Do not clear Channels[] so our allocations are reused next frame.

Upstream link.

Clear(self::Ptr{CImGui.lib.ImFontAtlas})

Clearing the atlas/fonts has little use nowadays, unless you want to batch remove all fonts.

• Since 1.92, you can call ClearFonts() mid-frame, if you load new fonts afterwards.
• As we are transitioning toward our new font system the semantic for those functions gets increasingly misleading and are often a source of issues. TL;DR; most likely, don't use any of those functions. We expect to obsolete/rework them.// Clear everything (fonts + textures). Don't call mid-frame!

Upstream link.

Clear(self::Ptr{CImGui.lib.ImFontGlyphRangesBuilder})

Upstream link.

Clear(self::Ptr{CImGui.lib.ImGuiKeyRoutingTable})

Upstream link.

Clear(self::Ptr{CImGui.lib.ImGuiMultiSelectTempData})

Zero-clear except IO as we preserve IO.Requests[] buffer allocation.

Upstream link.

Clear(self::Ptr{CImGui.lib.ImGuiNavItemData})

Upstream link.

Clear(self::Ptr{CImGui.lib.ImGuiPayload})

Upstream link.

Clear(self::Ptr{CImGui.lib.ImGuiSelectionBasicStorage})

Clear selection.

Upstream link.

Clear(self::Ptr{CImGui.lib.ImGuiStorage})

• Get***() functions find pair, never add/allocate. Pairs are sorted so a query is O(log N)
• Set***() functions find pair, insertion on demand if missing.
• Sorted insertion is costly, paid once. A typical frame shouldn't need to insert any new pair.

Upstream link.

Clear(self::Ptr{CImGui.lib.ImGuiTextBuffer})

Upstream link.

Clear(self::Ptr{CImGui.lib.ImGuiTextFilter})

Upstream link.

Clear(self::Ptr{CImGui.lib.ImGuiTextIndex})

Upstream link.

Clear(self::Ptr{CImGui.lib.ImGuiTypingSelectState})

We preserve remaining data for easier debugging.

Upstream link.

ClearActiveID()

Upstream link.

ClearBit(self::Ptr{CImGui.lib.ImBitVector}, n)

Upstream link.

ClearDragDrop()

Upstream link.

ClearEventsQueue(self::Ptr{CImGui.lib.ImGuiIO})

Clear all incoming events.

Upstream link.

ClearFlags(self::Ptr{CImGui.lib.ImGuiNextItemData})

Also cleared manually by ItemAdd()!

Upstream link.

ClearFlags(self::Ptr{CImGui.lib.ImGuiNextWindowData})

Upstream link.

ClearFonts(self::Ptr{CImGui.lib.ImFontAtlas})

Clear input+output font data/glyphs. New fonts and textures will be recreated afterwards.

Upstream link.

ClearFreeMemory(self::Ptr{CImGui.lib.ImDrawListSplitter})

Upstream link.

ClearFreeMemory(
    self::Ptr{CImGui.lib.ImGuiInputTextDeactivatedState}
)

Upstream link.

ClearFreeMemory(self::Ptr{CImGui.lib.ImGuiInputTextState})

Upstream link.

ClearIO(self::Ptr{CImGui.lib.ImGuiMultiSelectTempData})

Upstream link.

ClearIniSettings()

Upstream link.

ClearInputData(self::Ptr{CImGui.lib.ImFontAtlas})

[OBSOLETE] Clear input data (all ImFontConfig structures including sizes, TTF data, glyph ranges, etc.) = all the data used to build the texture and fonts.

Upstream link.

ClearInputKeys(self::Ptr{CImGui.lib.ImGuiIO})

Clear current keyboard/gamepad state + current frame text input buffer. Equivalent to releasing all keys/buttons.

Upstream link.

ClearInputMouse(self::Ptr{CImGui.lib.ImGuiIO})

Clear current mouse state.

Upstream link.

ClearOutputData(self::Ptr{CImGui.lib.ImFontBaked})

Upstream link.

ClearOutputData(self::Ptr{CImGui.lib.ImFont})

[Internal] Don't use!

Upstream link.

ClearPlatformHandlers(self::Ptr{CImGui.lib.ImGuiPlatformIO})

Clear all Platform_XXX fields. Typically called on Platform Backend shutdown.

Upstream link.

ClearRendererHandlers(self::Ptr{CImGui.lib.ImGuiPlatformIO})

Clear all Renderer_XXX fields. Typically called on Renderer Backend shutdown.

Upstream link.

ClearRequestFlags(self::Ptr{CImGui.lib.ImGuiViewportP})

Upstream link.

ClearSelection(
    self::Ptr{CImGui.lib.ImGuiInputTextCallbackData}
)

Upstream link.

ClearSelection(self::Ptr{CImGui.lib.ImGuiInputTextState})

Upstream link.

ClearTexData(self::Ptr{CImGui.lib.ImFontAtlas})

[OBSOLETE] Clear CPU-side copy of the texture data. Saves RAM once the texture has been copied to graphics memory.

Upstream link.

ClearText(self::Ptr{CImGui.lib.ImGuiInputTextState})

Upstream link.

ClearWindowSettings(name)

Upstream link.

ClipWith(self::Ptr{CImGui.lib.ImRect}, r::CImGui.lib.ImRect)

Simple version, may lead to an inverted rectangle, which is fine for Contains/Overlaps test but not for display.

Upstream link.

ClipWithFull(
    self::Ptr{CImGui.lib.ImRect},
    r::CImGui.lib.ImRect
)

Full version, ensure both points are fully clipped.

Upstream link.

CloneOutput(
    self::Ptr{CImGui.lib.ImDrawList}
) -> Ptr{CImGui.lib.ImDrawList}

Create a clone of the CmdBuffer/IdxBuffer/VtxBuffer. For multi-threaded rendering, consider using imgui_threaded_rendering from https://github.com/ocornut/imgui_club instead.

Upstream link.

CloseButton(
    id::Integer,
    pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Bool

Widgets: Window Decorations.

Upstream link.

CloseCurrentPopup()

Manually close the popup we have begin-ed into.

Upstream link.

ClosePopupToLevel(
    remaining,
    restore_focus_to_window_under_popup
)

Upstream link.

ClosePopupsExceptModals()

Upstream link.

ClosePopupsOverWindow(
    ref_window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    restore_focus_to_window_under_popup
)

Upstream link.

CollapseButton(
    id::Integer,
    pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    dock_node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}}
) -> Bool

Upstream link.

CollapsingHeader(
    label::Union{Ptr{Int8}, Ptr{Nothing}, String}
) -> Bool
CollapsingHeader(
    label::Union{Ptr{Int8}, Ptr{Nothing}, String},
    flags::Union{CImGui.lib.ImGuiTreeNodeFlags_, Integer}
) -> Bool

If returning 'true' the header is open. doesn't indent nor push on ID stack. user doesn't have to call TreePop().

Upstream link.

CollapsingHeader(
    label::Union{Ptr{Int8}, Ptr{Nothing}, String},
    p_visible::Union{Ptr{Nothing}, Ref{Bool}}
) -> Bool
CollapsingHeader(
    label::Union{Ptr{Int8}, Ptr{Nothing}, String},
    p_visible::Union{Ptr{Nothing}, Ref{Bool}},
    flags::Union{CImGui.lib.ImGuiTreeNodeFlags_, Integer}
) -> Bool

When 'pvisible != NULL': if '*pvisible==true' display an additional small close button on upper right of the header which will set the bool to false when clicked, if '*p_visible==false' don't display the header.

Upstream link.

ColorButton(
    desc_id,
    col::Union{CImGui.lib.ImVec4, NTuple{4, T} where T}
) -> Bool
ColorButton(
    desc_id,
    col::Union{CImGui.lib.ImVec4, NTuple{4, T} where T},
    flags::Union{CImGui.lib.ImGuiColorEditFlags_, Integer}
) -> Bool
ColorButton(
    desc_id,
    col::Union{CImGui.lib.ImVec4, NTuple{4, T} where T},
    flags::Union{CImGui.lib.ImGuiColorEditFlags_, Integer},
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Bool

Display a color square/button, hover for details, return true when pressed.

Upstream link.

ColorConvertFloat4ToU32(
    in::Union{CImGui.lib.ImVec4, NTuple{4, T} where T}
) -> UInt32

Upstream link.

ColorConvertHSVtoRGB(h, s, v, out_r, out_g, out_b)

Upstream link.

ColorConvertRGBtoHSV(r, g, b, out_h, out_s, out_v)

Upstream link.

ColorConvertU32ToFloat4(in::Integer) -> CImGui.lib.ImVec4

Color Utilities.

Upstream link.

ColorEdit3(label, col) -> Bool
ColorEdit3(
    label,
    col,
    flags::Union{CImGui.lib.ImGuiColorEditFlags_, Integer}
) -> Bool

Widgets: Color Editor/Picker (tip: the ColorEdit* functions have a little color square that can be left-clicked to open a picker, and right-clicked to open an option menu.)

• Note that in C++ a 'float v[X]' function argument is the same as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible.
• You can pass the address of a first float element out of a contiguous structure, e.g. &myvector.x.

Upstream link.

ColorEdit4(label, col) -> Bool
ColorEdit4(
    label,
    col,
    flags::Union{CImGui.lib.ImGuiColorEditFlags_, Integer}
) -> Bool

Upstream link.

ColorEditOptionsPopup(
    col,
    flags::Union{CImGui.lib.ImGuiColorEditFlags_, Integer}
)

Upstream link.

ColorPicker3(label, col) -> Bool
ColorPicker3(
    label,
    col,
    flags::Union{CImGui.lib.ImGuiColorEditFlags_, Integer}
) -> Bool

Upstream link.

ColorPicker4(label, col) -> Bool
ColorPicker4(
    label,
    col,
    flags::Union{CImGui.lib.ImGuiColorEditFlags_, Integer}
) -> Bool
ColorPicker4(
    label,
    col,
    flags::Union{CImGui.lib.ImGuiColorEditFlags_, Integer},
    ref_col
) -> Bool

Upstream link.

ColorPickerOptionsPopup(
    ref_col,
    flags::Union{CImGui.lib.ImGuiColorEditFlags_, Integer}
)

Upstream link.

ColorTooltip(
    text,
    col,
    flags::Union{CImGui.lib.ImGuiColorEditFlags_, Integer}
)

Color.

Upstream link.

Columns()
Columns(count)
Columns(count, id)
Columns(count, id, borders)

Legacy Columns API (prefer using Tables!)

• You can also use SameLine(pos_x) to mimic simplified columns.

Upstream link.

Combo(
    label::Union{Ptr{Int8}, Ptr{Nothing}, String},
    current_item::Union{Ptr{Nothing}, Ref{Int32}},
    items_separated_by_zeros::Union{Ptr{Int8}, String}
) -> Bool
Combo(
    label::Union{Ptr{Int8}, Ptr{Nothing}, String},
    current_item::Union{Ptr{Nothing}, Ref{Int32}},
    items_separated_by_zeros::Union{Ptr{Int8}, String},
    popup_max_height_in_items::Integer
) -> Bool

Separate items with \0 within a string, end item-list with \0\0. e.g. "One\0Two\0Three\0".

Upstream link.

Combo(
    label::Union{Ptr{Int8}, Ptr{Nothing}, String},
    current_item::Union{Ptr{Nothing}, Ref{Int32}},
    items::Vector{String}
) -> Bool
Combo(
    label::Union{Ptr{Int8}, Ptr{Nothing}, String},
    current_item::Union{Ptr{Nothing}, Ref{Int32}},
    items::Vector{String},
    popup_max_height_in_items::Integer
) -> Bool

Upstream link.

CompactCache(self::Ptr{CImGui.lib.ImFontAtlas})

Compact cached glyphs and texture.

Upstream link.

Contains(
    self::Ptr{CImGui.lib.ImGuiSelectionBasicStorage},
    id::Integer
) -> Bool

Query if an item id is in selection.

Upstream link.

ContainsWithPad(
    self::Ptr{CImGui.lib.ImRect},
    p::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    pad::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Bool

Upstream link.

ConvertSingleModFlagToKey(
    key::CImGui.lib.ImGuiKey
) -> CImGui.lib.ImGuiKey

Upstream link.

Create(self::Ptr{CImGui.lib.ImBitVector}, sz)

Upstream link.

Create(
    self::Ptr{CImGui.lib.ImTextureData},
    format::CImGui.lib.ImTextureFormat,
    w,
    h
)

Upstream link.

CreateContext() -> Ptr{CImGui.lib.ImGuiContext}
CreateContext(
    shared_font_atlas::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontAtlas}}
) -> Ptr{CImGui.lib.ImGuiContext}

Context creation and access

• Each context create its own ImFontAtlas by default. You may instance one yourself and pass it to CreateContext() to share a font atlas between contexts.
• DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions() for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for details.

Upstream link.

CreateNewWindowSettings(
    name
) -> Ptr{CImGui.lib.ImGuiWindowSettings}

Settings - Windows.

Upstream link.

CursorAnimReset(self::Ptr{CImGui.lib.ImGuiInputTextState})

Cursor & Selection.

Upstream link.

CursorClamp(self::Ptr{CImGui.lib.ImGuiInputTextState})

Upstream link.

DataTypeApplyFromText(
    buf,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    format
) -> Bool
DataTypeApplyFromText(
    buf,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    format,
    p_data_when_empty
) -> Bool

Upstream link.

DataTypeApplyOp(
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    op,
    output,
    arg_1,
    arg_2
)

Upstream link.

DataTypeClamp(
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    p_min,
    p_max
) -> Bool

Upstream link.

DataTypeCompare(
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    arg_1,
    arg_2
) -> Int32

Upstream link.

DataTypeFormatString(
    buf,
    buf_size,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    format
) -> Int32

Upstream link.

DataTypeGetInfo(
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer}
) -> Ptr{CImGui.lib.ImGuiDataTypeInfo}

Data type helpers.

Upstream link.

DataTypeIsZero(
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data
) -> Bool

Upstream link.

DeIndexAllBuffers(self::Ptr{CImGui.lib.ImDrawData})

Helper to convert all buffers from indexed to non-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering!

Upstream link.

DebugAllocHook(
    info::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDebugAllocInfo}},
    frame_count,
    ptr,
    size
)

Debug Tools// size >= 0 : alloc, size = -1 : free.

Upstream link.

DebugBreakButton(label, description_of_location) -> Bool

Upstream link.

DebugBreakButtonTooltip(
    keyboard_only,
    description_of_location
)

Upstream link.

DebugBreakClearData()

Upstream link.

DebugCheckVersionAndDataLayout(
    version_str,
    sz_io,
    sz_style,
    sz_vec2,
    sz_vec4,
    sz_drawvert,
    sz_drawidx
) -> Bool

This is called by IMGUI_CHECKVERSION() macro.

Upstream link.

DebugDrawCursorPos()
DebugDrawCursorPos(col::Integer)

Upstream link.

DebugDrawItemRect()
DebugDrawItemRect(col::Integer)

Upstream link.

DebugDrawLineExtents()
DebugDrawLineExtents(col::Integer)

Upstream link.

DebugFlashStyleColor(
    idx::Union{CImGui.lib.ImGuiCol_, Integer}
)

Upstream link.

DebugHookIdInfo(
    id::Integer,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    data_id,
    data_id_end
)

Upstream link.

DebugLocateItem(target_id::Integer)

Call sparingly: only 1 at the same time!

Upstream link.

DebugLocateItemOnHover(target_id::Integer)

Only call on reaction to a mouse Hover: because only 1 at the same time!

Upstream link.

DebugLocateItemResolveWithLastItem()

Upstream link.

DebugLog(fmt)

Call via IMGUIDEBUGLOG() for maximum stripping in caller code!

Upstream link.

DebugNodeColumns(
    columns::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiOldColumns}}
)

Upstream link.

DebugNodeDockNode(
    node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}},
    label
)

Upstream link.

DebugNodeDrawCmdShowMeshAndBoundingBox(
    out_draw_list::Union{Ptr{Nothing}, Ref{CImGui.lib.ImDrawList}},
    draw_list::Union{Ptr{Nothing}, Ref{CImGui.lib.ImDrawList}},
    draw_cmd::Union{Ptr{Nothing}, Ref{CImGui.lib.ImDrawCmd}},
    show_mesh,
    show_aabb
)

Upstream link.

DebugNodeDrawList(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewportP}},
    draw_list::Union{Ptr{Nothing}, Ref{CImGui.lib.ImDrawList}},
    label
)

Upstream link.

DebugNodeFont(
    font::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFont}}
)

Upstream link.

DebugNodeFontGlyph(
    font::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFont}},
    glyph::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontGlyph}}
)

Upstream link.

DebugNodeFontGlyphsForSrcMask(
    font::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFont}},
    baked::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontBaked}},
    src_mask
)

Upstream link.

DebugNodeInputTextState(
    state::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiInputTextState}}
)

Upstream link.

DebugNodeMultiSelectState(
    state::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiMultiSelectState}}
)

Upstream link.

DebugNodePlatformMonitor(
    monitor::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiPlatformMonitor}},
    label,
    idx
)

Upstream link.

DebugNodeStorage(
    storage::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiStorage}},
    label
)

Upstream link.

DebugNodeTabBar(
    tab_bar::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiTabBar}},
    label
)

Upstream link.

DebugNodeTable(
    table::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiTable}}
)

Upstream link.

DebugNodeTableSettings(
    settings::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiTableSettings}},
    table::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiTable}}
)

Upstream link.

DebugNodeTexture(
    tex::Union{Ptr{Nothing}, Ref{CImGui.lib.ImTextureData}},
    int_id
)
DebugNodeTexture(
    tex::Union{Ptr{Nothing}, Ref{CImGui.lib.ImTextureData}},
    int_id,
    highlight_rect::Union{Ptr{Nothing}, Ref{CImGui.lib.ImFontAtlasRect}}
)

ID used to facilitate persisting the "current" texture.

Upstream link.

DebugNodeTypingSelectState(
    state::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiTypingSelectState}}
)

Upstream link.

DebugNodeViewport(
    viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewportP}}
)

Upstream link.

DebugNodeWindow(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    label
)

Upstream link.

DebugNodeWindowSettings(
    settings::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindowSettings}}
)

Upstream link.

DebugNodeWindowsList(
    windows::Union{Ptr{Nothing}, Ref{CImGui.lib.ImVector_ImGuiWindowPtr}},
    label
)

Upstream link.

DebugRenderKeyboardPreview(
    draw_list::Union{Ptr{Nothing}, Ref{CImGui.lib.ImDrawList}}
)

Upstream link.

DebugRenderViewportThumbnail(
    draw_list::Union{Ptr{Nothing}, Ref{CImGui.lib.ImDrawList}},
    viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewportP}},
    bb::CImGui.lib.ImRect
)

Upstream link.

DebugStartItemPicker()

Upstream link.

DebugTextEncoding(text)

Debug Utilities

• Your main debugging friend is the ShowMetricsWindow() function.
• Interactive tools are all accessible from the 'Dear ImGui Demo->Tools' menu.
• Read https://github.com/ocornut/imgui/wiki/Debug-Tools for a description of all available debug tools.

Upstream link.

DebugTextUnformattedWithLocateItem(line_begin, line_end)

Upstream link.

DebugTextureIDToU64(tex_id::UInt64) -> UInt64

Upstream link.

DeclColumns(
    self::Ptr{CImGui.lib.ImGuiMenuColumns},
    w_icon,
    w_label,
    w_shortcut,
    w_mark
) -> Float32

Upstream link.

DeleteChars(
    self::Ptr{CImGui.lib.ImGuiInputTextCallbackData},
    pos,
    bytes_count
)

Upstream link.

DemoMarker(file, line, section)

Demo Doc Marker for e.g. imgui_explorer.

Upstream link.

Destructor for ImColor

Destructor for ImDrawCmd

Destructor for ImDrawDataBuilder

Destructor for ImDrawData

Destructor for ImDrawListSharedData

Destructor for ImDrawListSplitter

Destructor for ImDrawList

Destructor for ImFontAtlasBuilder

Destructor for ImFontAtlasRect

Destructor for ImFontAtlas

Destructor for ImFontBaked

Destructor for ImFontConfig

Destructor for ImFontGlyphRangesBuilder

Destructor for ImFontGlyph

Destructor for ImFontLoader

Destructor for ImFont

Destructor for ImGuiBoxSelectState

Destructor for ImGuiComboPreviewData

Destructor for ImGuiContextHook

Destructor for ImGuiContext

Destructor for ImGuiDebugAllocInfo

Destructor for ImGuiDebugItemPathQuery

Destructor for ImGuiDockContext

Destructor for ImGuiDockNode

Destructor for ImGuiErrorRecoveryState

Destructor for ImGuiIDStackTool

Destructor for ImGuiIO

Destructor for ImGuiInputEvent

Destructor for ImGuiInputTextCallbackData

Destructor for ImGuiInputTextDeactivatedState

Destructor for ImGuiInputTextState

Destructor for ImGuiKeyOwnerData

Destructor for ImGuiKeyRoutingData

Destructor for ImGuiKeyRoutingTable

Destructor for ImGuiLastItemData

Destructor for ImGuiListClipperData

Destructor for ImGuiListClipper

Destructor for ImGuiMenuColumns

Destructor for ImGuiMultiSelectState

Destructor for ImGuiMultiSelectTempData

Destructor for ImGuiNavItemData

Destructor for ImGuiNextItemData

Destructor for ImGuiNextWindowData

Destructor for ImGuiOldColumnData

Destructor for ImGuiOldColumns

Destructor for ImGuiOnceUponAFrame

Destructor for ImGuiPackedDate

Destructor for ImGuiPayload

Destructor for ImGuiPlatformIO

Destructor for ImGuiPlatformImeData

Destructor for ImGuiPlatformMonitor

Destructor for ImGuiPopupData

Destructor for ImGuiPtrOrIndex

Destructor for ImGuiSelectionBasicStorage

Destructor for ImGuiSelectionExternalStorage

Destructor for ImGuiSettingsHandler

Destructor for ImGuiStackLevelInfo

Destructor for ImGuiStoragePair

Destructor for ImGuiStyleMod

Destructor for ImGuiStyle

Destructor for ImGuiTabBar

Destructor for ImGuiTabItem

Destructor for ImGuiTableColumnSettings

Destructor for ImGuiTableColumnSortSpecs

Destructor for ImGuiTableColumn

Destructor for ImGuiTableInstanceData

Destructor for ImGuiTableSettings

Destructor for ImGuiTableSortSpecs

Destructor for ImGuiTableTempData

Destructor for ImGuiTable

Destructor for ImGuiTextBuffer

Destructor for ImGuiTextFilter

Destructor for ImGuiTextRange

Destructor for ImGuiTypingSelectState

Destructor for ImGuiViewportP

Destructor for ImGuiViewport

Destructor for ImGuiWindowClass

Destructor for ImGuiWindowSettings

Destructor for ImGuiWindow

Destructor for ImRect

Destructor for ImTextureData

Destructor for ImTextureRef

Destructor for ImVec1

Destructor for ImVec2ih

Destructor for ImVec2i

Destructor for ImVec2

Destructor for ImVec4

DestroyContext()
DestroyContext(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}}
)

NULL = destroy current context.

Upstream link.

DestroyPixels(self::Ptr{CImGui.lib.ImTextureData})

Upstream link.

DestroyPlatformWindow(
    viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewportP}}
)

Upstream link.

DestroyPlatformWindows()

Call DestroyWindow platform functions for all viewports. call from backend Shutdown() if you need to close platform windows before imgui shutdown. otherwise will be called by DestroyContext().

Upstream link.

DockBuilderAddNode() -> UInt32
DockBuilderAddNode(node_id::Integer) -> UInt32
DockBuilderAddNode(
    node_id::Integer,
    flags::Union{CImGui.lib.ImGuiDockNodeFlags_, Integer}
) -> UInt32

Upstream link.

DockBuilderCopyDockSpace(
    src_dockspace_id::Integer,
    dst_dockspace_id::Integer,
    in_window_remap_pairs::Union{Ptr{Nothing}, Ref{CImGui.lib.ImVector_const_charPtr}}
)

Upstream link.

DockBuilderCopyNode(
    src_node_id::Integer,
    dst_node_id::Integer,
    out_node_remap_pairs::Union{Ptr{Nothing}, Ref{CImGui.lib.ImVector_ImGuiID}}
)

Upstream link.

DockBuilderCopyWindowSettings(src_name, dst_name)

Upstream link.

DockBuilderDockWindow(window_name, node_id::Integer)

Docking - Builder function needs to be generally called before the node is used/submitted.

• The DockBuilderXXX functions are designed to eventually become a public API, but it is too early to expose it and guarantee stability.
• Do not hold on ImGuiDockNode* pointers! They may be invalidated by any split/merge/remove operation and every frame.
• To create a DockSpace() node, make sure to set the ImGuiDockNodeFlagsDockSpace flag when calling DockBuilderAddNode(). You can create dockspace nodes (attached to a window) _or floating nodes (carry its own window) with this API.
• DockBuilderSplitNode() create 2 child nodes within 1 node. The initial node becomes a parent node.
• If you intend to split the node immediately after creation using DockBuilderSplitNode(), make sure to call DockBuilderSetNodeSize() beforehand. If you don't, the resulting split sizes may not be reliable.
• Call DockBuilderFinish() after you are done.

Upstream link.

DockBuilderFinish(node_id::Integer)

Upstream link.

DockBuilderGetCentralNode(
    node_id::Integer
) -> Ptr{CImGui.lib.ImGuiDockNode}

Upstream link.

DockBuilderGetNode(
    node_id::Integer
) -> Ptr{CImGui.lib.ImGuiDockNode}

Upstream link.

DockBuilderRemoveNode(node_id::Integer)

Remove node and all its child, undock all windows.

Upstream link.

DockBuilderRemoveNodeChildNodes(node_id::Integer)

Remove all split/hierarchy. All remaining docked windows will be re-docked to the remaining root node (node_id).

Upstream link.

DockBuilderRemoveNodeDockedWindows(node_id::Integer)
DockBuilderRemoveNodeDockedWindows(
    node_id::Integer,
    clear_settings_refs
)

Upstream link.

DockBuilderSetNodePos(
    node_id::Integer,
    pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
)

Upstream link.

DockBuilderSetNodeSize(
    node_id::Integer,
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
)

Upstream link.

DockBuilderSplitNode(
    node_id::Integer,
    split_dir::CImGui.lib.ImGuiDir,
    size_ratio_for_node_at_dir,
    out_id_at_dir::Union{Ptr{Nothing}, Ref{Integer}, Ref{UInt32}},
    out_id_at_opposite_dir::Union{Ptr{Nothing}, Ref{Integer}, Ref{UInt32}}
) -> UInt32

Create 2 child nodes in this parent node.

Upstream link.

DockContextCalcDropPosForDocking(
    target::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    target_node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}},
    payload_window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    payload_node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}},
    split_dir::CImGui.lib.ImGuiDir,
    split_outer,
    out_pos::Union{Ptr{Nothing}, Ref{CImGui.lib.ImVec2}, Ref{Tuple{T, T} where T}}
) -> Bool

Upstream link.

DockContextClearNodes(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}},
    root_id::Integer,
    clear_settings_refs
)

Use root_id==0 to clear all.

Upstream link.

DockContextEndFrame(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}}
)

Upstream link.

DockContextFindNodeByID(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}},
    id::Integer
) -> Ptr{CImGui.lib.ImGuiDockNode}

Upstream link.

DockContextGenNodeID(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}}
) -> UInt32

Upstream link.

DockContextInitialize(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}}
)

Docking (some functions are only declared in imgui.cpp, see Docking section).

Upstream link.

DockContextNewFrameUpdateDocking(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}}
)

Upstream link.

DockContextNewFrameUpdateUndocking(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}}
)

Upstream link.

DockContextProcessUndockNode(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}},
    node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}}
)

Upstream link.

DockContextProcessUndockWindow(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}},
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
)
DockContextProcessUndockWindow(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}},
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    clear_persistent_docking_ref
)

Upstream link.

DockContextQueueDock(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}},
    target::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    target_node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}},
    payload::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    split_dir::CImGui.lib.ImGuiDir,
    split_ratio,
    split_outer
)

Upstream link.

DockContextQueueUndockNode(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}},
    node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}}
)

Upstream link.

DockContextQueueUndockWindow(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}},
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
)

Upstream link.

DockContextRebuildNodes(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}}
)

Upstream link.

DockContextShutdown(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}}
)

Upstream link.

DockNodeBeginAmendTabBar(
    node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}}
) -> Bool

Upstream link.

DockNodeEndAmendTabBar()

Upstream link.

DockNodeGetDepth(
    node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}}
) -> Int32

Upstream link.

DockNodeGetRootNode(
    node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}}
) -> Ptr{CImGui.lib.ImGuiDockNode}

Upstream link.

DockNodeGetWindowMenuButtonId(
    node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}}
) -> UInt32

Upstream link.

DockNodeIsInHierarchyOf(
    node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}},
    parent::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}}
) -> Bool

Upstream link.

DockNodeWindowMenuHandler_Default(
    ctx::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiContext}},
    node::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDockNode}},
    tab_bar::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiTabBar}}
)

Upstream link.

DockSpace(dockspace_id::Integer) -> UInt32
DockSpace(
    dockspace_id::Integer,
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> UInt32
DockSpace(
    dockspace_id::Integer,
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    flags::Union{CImGui.lib.ImGuiDockNodeFlags_, Integer}
) -> UInt32
DockSpace(
    dockspace_id::Integer,
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    flags::Union{CImGui.lib.ImGuiDockNodeFlags_, Integer},
    window_class::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindowClass}}
) -> UInt32

Docking

• Read https://github.com/ocornut/imgui/wiki/Docking for details.
• Enable with io.ConfigFlags |= ImGuiConfigFlags_DockingEnable.
• You can use many Docking facilities without calling any API.
  • Drag from window title bar or their tab to dock/undock. Hold SHIFT to disable docking.
  • Drag from window menu button (upper-left button) to undock an entire node (all windows).
  • When io.ConfigDockingWithShift == true, you instead need to hold SHIFT to enable docking.
• DockSpaceOverViewport:
  • This is a helper to create an invisible window covering a viewport, then submit a DockSpace() into it.
  • Most applications can simply call DockSpaceOverViewport() once to allow docking windows into e.g. the edge of your screen. e.g. ImGui::NewFrame(); ImGui::DockSpaceOverViewport(); // Create a dockspace in main viewport. or: ImGui::NewFrame(); ImGui::DockSpaceOverViewport(0, nullptr, ImGuiDockNodeFlags_PassthruCentralNode); // Create a dockspace in main viewport, central node is transparent.
• Dockspaces:
  • A dockspace is an explicit dock node within an existing window.
  • IMPORTANT: Dockspaces need to be submitted before any window they can host. Submit them early in your frame!
  • IMPORTANT: Dockspaces need to be kept alive if hidden, otherwise windows docked into it will be undocked. If you have e.g. multiple tabs with a dockspace inside each tab: submit the non-visible dockspaces with ImGuiDockNodeFlags_KeepAliveOnly.
  • See 'Demo->Examples->Dockspace' or 'Demo->Examples->Documents' for more detailed demos.
• Programmatic docking:
  • There is no public API yet other than the very limited SetNextWindowDockID() function. Sorry for that!
  • Read https://github.com/ocornut/imgui/wiki/Docking for examples of how to use current internal API.

Upstream link.

DockSpaceOverViewport() -> UInt32
DockSpaceOverViewport(dockspace_id::Integer) -> UInt32
DockSpaceOverViewport(
    dockspace_id::Integer,
    viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewport}}
) -> UInt32
DockSpaceOverViewport(
    dockspace_id::Integer,
    viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewport}},
    flags::Union{CImGui.lib.ImGuiDockNodeFlags_, Integer}
) -> UInt32
DockSpaceOverViewport(
    dockspace_id::Integer,
    viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewport}},
    flags::Union{CImGui.lib.ImGuiDockNodeFlags_, Integer},
    window_class::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindowClass}}
) -> UInt32

Upstream link.

DragBehavior(
    id::Integer,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_v,
    v_speed,
    p_min,
    p_max,
    format,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Upstream link.

DragFloat(label, v) -> Bool
DragFloat(label, v, v_speed) -> Bool
DragFloat(label, v, v_speed, v_min) -> Bool
DragFloat(label, v, v_speed, v_min, v_max) -> Bool
DragFloat(label, v, v_speed, v_min, v_max, format) -> Bool
DragFloat(
    label,
    v,
    v_speed,
    v_min,
    v_max,
    format,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Widgets: Drag Sliders

• Ctrl+Click on any drag box to turn them into an input box. Manually input values aren't clamped by default and can go off-bounds. Use ImGuiSliderFlags_AlwaysClamp to always clamp.
• For all the Float2/Float3/Float4/Int2/Int3/Int4 versions of every function, note that a 'float v[X]' function argument is the same as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible. You can pass address of your first element out of a contiguous set, e.g. &myvector.x
• Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc.
• Format string may also be set to NULL or use the default format ("%f" or "%d").
• Speed are per-pixel of mouse movement (vspeed=0.2f: mouse needs to move by 5 pixels to increase value by 1). For keyboard/gamepad navigation, minimum speed is Max(vspeed, minimumstepatgivenprecision).
• Use vmin < vmax to clamp edits to given limits. Note that Ctrl+Click manual input can override those limits if ImGuiSliderFlags_AlwaysClamp is not used.
• Use vmax = FLTMAX / INTMAX etc to avoid clamping to a maximum, same with vmin = -FLTMAX / INTMIN to avoid clamping to a minimum.
• We use the same sets of flags for DragXXX() and SliderXXX() functions as the features are the same and it makes it easier to swap them.
• Legacy: Pre-1.78 there are DragXXX() function signatures that take a final float power=1.0f' argument instead of theImGuiSliderFlags flags=0' argument. If you get a warning converting a float to ImGuiSliderFlags, read https://github.com/ocornut/imgui/issues/3361// If vmin >= vmax we have no bound.

Upstream link.

DragFloat2(label, v) -> Bool
DragFloat2(label, v, v_speed) -> Bool
DragFloat2(label, v, v_speed, v_min) -> Bool
DragFloat2(label, v, v_speed, v_min, v_max) -> Bool
DragFloat2(label, v, v_speed, v_min, v_max, format) -> Bool
DragFloat2(
    label,
    v,
    v_speed,
    v_min,
    v_max,
    format,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Upstream link.

DragFloat3(label, v) -> Bool
DragFloat3(label, v, v_speed) -> Bool
DragFloat3(label, v, v_speed, v_min) -> Bool
DragFloat3(label, v, v_speed, v_min, v_max) -> Bool
DragFloat3(label, v, v_speed, v_min, v_max, format) -> Bool
DragFloat3(
    label,
    v,
    v_speed,
    v_min,
    v_max,
    format,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Upstream link.

DragFloat4(label, v) -> Bool
DragFloat4(label, v, v_speed) -> Bool
DragFloat4(label, v, v_speed, v_min) -> Bool
DragFloat4(label, v, v_speed, v_min, v_max) -> Bool
DragFloat4(label, v, v_speed, v_min, v_max, format) -> Bool
DragFloat4(
    label,
    v,
    v_speed,
    v_min,
    v_max,
    format,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Upstream link.

DragFloatRange2(label, v_current_min, v_current_max) -> Bool
DragFloatRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed
) -> Bool
DragFloatRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed,
    v_min
) -> Bool
DragFloatRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed,
    v_min,
    v_max
) -> Bool
DragFloatRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed,
    v_min,
    v_max,
    format
) -> Bool
DragFloatRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed,
    v_min,
    v_max,
    format,
    format_max
) -> Bool
DragFloatRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed,
    v_min,
    v_max,
    format,
    format_max,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Upstream link.

DragInt(label, v) -> Bool
DragInt(label, v, v_speed) -> Bool
DragInt(label, v, v_speed, v_min) -> Bool
DragInt(label, v, v_speed, v_min, v_max) -> Bool
DragInt(label, v, v_speed, v_min, v_max, format) -> Bool
DragInt(
    label,
    v,
    v_speed,
    v_min,
    v_max,
    format,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

If vmin >= vmax we have no bound.

Upstream link.

DragInt2(label, v) -> Bool
DragInt2(label, v, v_speed) -> Bool
DragInt2(label, v, v_speed, v_min) -> Bool
DragInt2(label, v, v_speed, v_min, v_max) -> Bool
DragInt2(label, v, v_speed, v_min, v_max, format) -> Bool
DragInt2(
    label,
    v,
    v_speed,
    v_min,
    v_max,
    format,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Upstream link.

DragInt3(label, v) -> Bool
DragInt3(label, v, v_speed) -> Bool
DragInt3(label, v, v_speed, v_min) -> Bool
DragInt3(label, v, v_speed, v_min, v_max) -> Bool
DragInt3(label, v, v_speed, v_min, v_max, format) -> Bool
DragInt3(
    label,
    v,
    v_speed,
    v_min,
    v_max,
    format,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Upstream link.

DragInt4(label, v) -> Bool
DragInt4(label, v, v_speed) -> Bool
DragInt4(label, v, v_speed, v_min) -> Bool
DragInt4(label, v, v_speed, v_min, v_max) -> Bool
DragInt4(label, v, v_speed, v_min, v_max, format) -> Bool
DragInt4(
    label,
    v,
    v_speed,
    v_min,
    v_max,
    format,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Upstream link.

DragIntRange2(label, v_current_min, v_current_max) -> Bool
DragIntRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed
) -> Bool
DragIntRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed,
    v_min
) -> Bool
DragIntRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed,
    v_min,
    v_max
) -> Bool
DragIntRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed,
    v_min,
    v_max,
    format
) -> Bool
DragIntRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed,
    v_min,
    v_max,
    format,
    format_max
) -> Bool
DragIntRange2(
    label,
    v_current_min,
    v_current_max,
    v_speed,
    v_min,
    v_max,
    format,
    format_max,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Upstream link.

DragScalar(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data
) -> Bool
DragScalar(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    v_speed
) -> Bool
DragScalar(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    v_speed,
    p_min
) -> Bool
DragScalar(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    v_speed,
    p_min,
    p_max
) -> Bool
DragScalar(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    v_speed,
    p_min,
    p_max,
    format
) -> Bool
DragScalar(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    v_speed,
    p_min,
    p_max,
    format,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Upstream link.

DragScalarN(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    components
) -> Bool
DragScalarN(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    components,
    v_speed
) -> Bool
DragScalarN(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    components,
    v_speed,
    p_min
) -> Bool
DragScalarN(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    components,
    v_speed,
    p_min,
    p_max
) -> Bool
DragScalarN(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    components,
    v_speed,
    p_min,
    p_max,
    format
) -> Bool
DragScalarN(
    label,
    data_type::Union{CImGui.lib.ImGuiDataType_, Integer},
    p_data,
    components,
    v_speed,
    p_min,
    p_max,
    format,
    flags::Union{CImGui.lib.ImGuiSliderFlags_, Integer}
) -> Bool

Upstream link.

Draw(self::Ptr{CImGui.lib.ImGuiTextFilter}) -> Bool
Draw(self::Ptr{CImGui.lib.ImGuiTextFilter}, label) -> Bool
Draw(
    self::Ptr{CImGui.lib.ImGuiTextFilter},
    label,
    width
) -> Bool

Helper calling InputText+Build.

Upstream link.

Dummy(width, height)

Convenience wrapper for Dummy().

Dummy(size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T})

Add a dummy item of given size. unlike InvisibleButton(), Dummy() won't take the mouse click or be navigable into.

Upstream link.

Empty(self::Ptr{CImGui.lib.ImGuiTextBuffer}) -> Bool

Upstream link.

Empty(self::Ptr{CImGui.lib.ImGuiTextRange}) -> Bool

Upstream link.

End(self::Ptr{CImGui.lib.ImGuiListClipper})

Automatically called on the last call of Step() that returns false.

Upstream link.

End(self::Ptr{CImGui.lib.ImGuiTextBuffer}) -> Ptr{Int8}

Buf is zero-terminated, so end() will point on the zero-terminator.

Upstream link.

End()

Upstream link.

EndBoxSelect(
    scope_rect::CImGui.lib.ImRect,
    ms_flags::Union{CImGui.lib.ImGuiMultiSelectFlags_, Integer}
)

Upstream link.

EndChild()

Upstream link.

EndColumns()

Close columns.

Upstream link.

EndCombo()

Only call EndCombo() if BeginCombo() returns true!

Upstream link.

EndComboPreview()

Upstream link.

EndDisabled()

Upstream link.

EndDisabledOverrideReenable()

Upstream link.

EndDragDropSource()

Only call EndDragDropSource() if BeginDragDropSource() returns true!

Upstream link.

EndDragDropTarget()

Only call EndDragDropTarget() if BeginDragDropTarget() returns true!

Upstream link.

EndErrorTooltip()

Upstream link.

EndFrame()

Ends the Dear ImGui frame. automatically called by Render(). If you don't need to render data (skipping rendering) you may call EndFrame() without Render()... but you'll have wasted CPU already! If you don't need to render, better to not create any windows and not call NewFrame() at all!

Upstream link.

EndGroup()

Unlock horizontal starting position + capture the whole group bounding box into one "item" (so you can use IsItemHovered() or layout primitives such as SameLine() on whole group, etc.).

Upstream link.

EndListBox()

Only call EndListBox() if BeginListBox() returned true!

Upstream link.

EndMainMenuBar()

Only call EndMainMenuBar() if BeginMainMenuBar() returns true!

Upstream link.

EndMenu()

Only call EndMenu() if BeginMenu() returns true!

Upstream link.

EndMenuBar()

Only call EndMenuBar() if BeginMenuBar() returns true!

Upstream link.

EndMultiSelect() -> Ptr{CImGui.lib.ImGuiMultiSelectIO}

Upstream link.

EndPopup()

Only call EndPopup() if BeginPopupXXX() returns true!

Upstream link.

EndTabBar()

Only call EndTabBar() if BeginTabBar() returns true!

Upstream link.

EndTabItem()

Only call EndTabItem() if BeginTabItem() returns true!

Upstream link.

EndTable()

Only call EndTable() if BeginTable() returns true!

Upstream link.

EndTooltip()

Only call EndTooltip() if BeginTooltip()/BeginItemTooltip() returns true!

Upstream link.

ErrorCheckEndFrameFinalizeErrorTooltip()

Upstream link.

ErrorCheckUsingSetCursorPosToExtendParentBoundaries()

Upstream link.

ErrorLog(msg) -> Bool

Error handling, State Recovery.

Upstream link.

ErrorRecoveryStoreState(
    state_out::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiErrorRecoveryState}}
)

Upstream link.

ErrorRecoveryTryToRecoverState(
    state_in::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiErrorRecoveryState}}
)

Upstream link.

ErrorRecoveryTryToRecoverWindowState(
    state_in::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiErrorRecoveryState}}
)

Upstream link.

ExtendHitBoxWhenNearViewportEdge(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    bb::Union{Ptr{Nothing}, Ref{CImGui.lib.ImRect}},
    threshold,
    axis::CImGui.lib.ImGuiAxis
)

Upstream link.

FindBestWindowPosForPopup(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
) -> CImGui.lib.ImVec2

Upstream link.

FindBestWindowPosForPopupEx(
    ref_pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    size::Union{CImGui.lib.ImVec2, Tuple{T, T} where T},
    last_dir::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiDir}},
    r_outer::CImGui.lib.ImRect,
    r_avoid::CImGui.lib.ImRect,
    policy::CImGui.lib.ImGuiPopupPositionPolicy
) -> CImGui.lib.ImVec2

Upstream link.

FindBlockingModal(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
) -> Ptr{CImGui.lib.ImGuiWindow}

Upstream link.

FindBottomMostVisibleWindowWithinBeginStack(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
) -> Ptr{CImGui.lib.ImGuiWindow}

Upstream link.

FindFrontMostVisibleChildWindow(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
) -> Ptr{CImGui.lib.ImGuiWindow}

Upstream link.

FindGlyph(
    self::Ptr{CImGui.lib.ImFontBaked},
    c::UInt16
) -> Ptr{CImGui.lib.ImFontGlyph}

Return U+FFFD glyph if requested glyph doesn't exists.

Upstream link.

FindGlyphNoFallback(
    self::Ptr{CImGui.lib.ImFontBaked},
    c::UInt16
) -> Ptr{CImGui.lib.ImFontGlyph}

Return NULL if glyph doesn't exist.

Upstream link.

FindHoveredViewportFromPlatformWindowStack(
    mouse_platform_pos::Union{CImGui.lib.ImVec2, Tuple{T, T} where T}
) -> Ptr{CImGui.lib.ImGuiViewportP}

Upstream link.

FindOrCreateColumns(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    id::Integer
) -> Ptr{CImGui.lib.ImGuiOldColumns}

Upstream link.

FindRenderedTextEnd(text) -> Ptr{Int8}
FindRenderedTextEnd(text, text_end) -> Ptr{Int8}

Find the optional ## from which we stop displaying text.

Upstream link.

FindSettingsHandler(
    type_name
) -> Ptr{CImGui.lib.ImGuiSettingsHandler}

Upstream link.

FindViewportByID(
    viewport_id::Integer
) -> Ptr{CImGui.lib.ImGuiViewport}

This is a helper for backends.

Upstream link.

FindViewportByPlatformHandle(
    platform_handle
) -> Ptr{CImGui.lib.ImGuiViewport}

This is a helper for backends. the type platform_handle is decided by the backend (e.g. HWND, MyWindow, GLFWwindow etc.).

Upstream link.

FindWindowByID(id::Integer) -> Ptr{CImGui.lib.ImGuiWindow}

Upstream link.

FindWindowByName(name) -> Ptr{CImGui.lib.ImGuiWindow}

Upstream link.

FindWindowDisplayIndex(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
) -> Int32

Upstream link.

FindWindowSettingsByID(
    id::Integer
) -> Ptr{CImGui.lib.ImGuiWindowSettings}

Upstream link.

FindWindowSettingsByWindow(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
) -> Ptr{CImGui.lib.ImGuiWindowSettings}

Upstream link.

FixupKeyChord(key_chord::Integer) -> Int32

Upstream link.

FocusItem()

Focus/Activation This should be part of a larger set of API: FocusItem(offset = -1), FocusItemByID(id), ActivateItem(offset = -1), ActivateItemByID(id) etc. which are Much harder to design and implement than expected. I have a couple of private branches on this matter but it's not simple. For now implementing the easy ones.// Focus last item (no selection/activation).

Upstream link.

FocusTopMostWindowUnderOne(
    under_this_window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    ignore_window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    filter_viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewport}},
    flags::Union{CImGui.lib.ImGuiFocusRequestFlags_, Integer}
)

Upstream link.

FocusWindow(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
)
FocusWindow(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}},
    flags::Union{CImGui.lib.ImGuiFocusRequestFlags_, Integer}
)

Windows: Display Order and Focus Order.

Upstream link.

FromIndices(min, max) -> CImGui.lib.ImGuiListClipperRange

Upstream link.

FromPositions(
    y1,
    y2,
    off_min,
    off_max
) -> CImGui.lib.ImGuiListClipperRange

Upstream link.

GcAwakeTransientWindowBuffers(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
)

Upstream link.

GcCompactTransientMiscBuffers()

Garbage collection.

Upstream link.

GcCompactTransientWindowBuffers(
    window::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiWindow}}
)

Upstream link.

GetActiveID() -> UInt32

Upstream link.

GetAllocatorFunctions(
    p_alloc_func::Union{Ptr{Nothing}, Ref{Ptr{Nothing}}},
    p_free_func::Union{Ptr{Nothing}, Ref{Ptr{Nothing}}},
    p_user_data
)

Upstream link.

GetArea(self::Ptr{CImGui.lib.ImRect}) -> Float32

Upstream link.

GetBL(self::Ptr{CImGui.lib.ImRect}) -> CImGui.lib.ImVec2

Bottom-left.

Upstream link.

GetBR(self::Ptr{CImGui.lib.ImRect}) -> CImGui.lib.ImVec2

Bottom-right.

Upstream link.

GetBackgroundDrawList() -> Ptr{CImGui.lib.ImDrawList}
GetBackgroundDrawList(
    viewport::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiViewport}}
) -> Ptr{CImGui.lib.ImDrawList}

Background/Foreground Draw Lists// get background draw list for the given viewport or viewport associated to the current window. this draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents.

Upstream link.

GetBit(
    self::Ptr{CImGui.lib.ImFontGlyphRangesBuilder},
    n
) -> Bool

Get bit n in the array.

Upstream link.

GetBool(
    self::Ptr{CImGui.lib.ImGuiStorage},
    key::Integer
) -> Bool
GetBool(
    self::Ptr{CImGui.lib.ImGuiStorage},
    key::Integer,
    default_val
) -> Bool

Upstream link.

GetBoolRef(
    self::Ptr{CImGui.lib.ImGuiStorage},
    key::Integer
) -> Ptr{Bool}
GetBoolRef(
    self::Ptr{CImGui.lib.ImGuiStorage},
    key::Integer,
    default_val
) -> Ptr{Bool}

Upstream link.

GetBoxSelectState(
    id::Integer
) -> Ptr{CImGui.lib.ImGuiBoxSelectState}

Upstream link.

GetBuildWorkRect(
    self::Ptr{CImGui.lib.ImGuiViewportP}
) -> CImGui.lib.ImRect

Upstream link.

GetCenter(
    self::Ptr{CImGui.lib.ImGuiViewport}
) -> CImGui.lib.ImVec2

Helpers.

Upstream link.

GetCenter(self::Ptr{CImGui.lib.ImRect}) -> CImGui.lib.ImVec2

Upstream link.

GetCharAdvance(
    self::Ptr{CImGui.lib.ImFontBaked},
    c::UInt16
) -> Float32

Upstream link.

GetClipRectMax(
    self::Ptr{CImGui.lib.ImDrawList}
) -> CImGui.lib.ImVec2

Upstream link.

GetClipRectMin(
    self::Ptr{CImGui.lib.ImDrawList}
) -> CImGui.lib.ImVec2

Upstream link.

GetClipboardText() -> Ptr{Int8}

Clipboard Utilities

• Also see the LogToClipboard() function to capture GUI into clipboard, or easily output text data to the clipboard.

Upstream link.

GetColorU32(
    idx::Union{CImGui.lib.ImGuiCol_, Integer}
) -> UInt32
GetColorU32(
    idx::Union{CImGui.lib.ImGuiCol_, Integer},
    alpha_mul::Real
) -> UInt32

Retrieve given style color with style alpha applied and optional extra alpha multiplier, packed as a 32-bit value suitable for ImDrawList.

Upstream link.

GetColorU32(col::Integer) -> UInt32
GetColorU32(col::Integer, alpha_mul::Real) -> UInt32

Retrieve given color with style alpha applied, packed as a 32-bit value suitable for ImDrawList.

Upstream link.

GetColorU32(
    col::Union{CImGui.lib.ImVec4, NTuple{4, T} where T}
) -> UInt32

Retrieve given color with style alpha applied, packed as a 32-bit value suitable for ImDrawList.

Upstream link.

GetColumnIndex() -> Int32

Get current column index.

Upstream link.

GetColumnNormFromOffset(
    columns::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiOldColumns}},
    offset
) -> Float32

Upstream link.

GetColumnOffset() -> Float32
GetColumnOffset(column_index) -> Float32

Get position of column line (in pixels, from the left side of the contents region). pass -1 to use current column, otherwise 0..GetColumnsCount() inclusive. column 0 is typically 0.0f.

Upstream link.

GetColumnOffsetFromNorm(
    columns::Union{Ptr{Nothing}, Ref{CImGui.lib.ImGuiOldColumns}},
    offset_norm
) -> Float32

Upstream link.

GetColumnSettings(
    self::Ptr{CImGui.lib.ImGuiTableSettings}
) -> Ptr{CImGui.lib.ImGuiTableColumnSettings}

Upstream link.

GetColumnWidth() -> Float32
GetColumnWidth(column_index) -> Float32

Get column width (in pixels). pass -1 to use current column.

Upstream link.

GetColumnsCount() -> Int32

Upstream link.

GetColumnsID(str_id, count) -> UInt32

Upstream link.

GetContentRegionAvail() -> CImGui.lib.ImVec2

Available space from current position. THIS IS YOUR BEST FRIEND.

Upstream link.

GetCurrentContext() -> Ptr{CImGui.lib.ImGuiContext}

Upstream link.

GetCurrentFocusScope() -> UInt32

Focus scope we are outputting into, set by PushFocusScope().