From 9c39d097efb47d38ac1fc83bd78870a42da703a5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thibault=20de=20Vill=C3=A8le?= Date: Tue, 19 Nov 2024 14:29:25 +0100 Subject: [PATCH 1/4] [ci-skip] add Table* bindings to imgui --- src/cpp/imgui.cpp | 86 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+) diff --git a/src/cpp/imgui.cpp b/src/cpp/imgui.cpp index 92309ad..77817e2 100644 --- a/src/cpp/imgui.cpp +++ b/src/cpp/imgui.cpp @@ -1379,6 +1379,92 @@ void bind_imgui_methods(py::module& m) { py::arg("flags") = 0); m.def("CloseCurrentPopup", []() { ImGui::CloseCurrentPopup(); }); + // Tables + m.def( + "BeginTable", + [](const char*str_id, int columns, ImGuiTableFlags flags, Vec2T size, float innerwidth) -> bool { + return ImGui::BeginTable(str_id, columns, flags, to_vec2(size), innerwidth); + }, + py::arg("str"), + py::arg("columns"), + py::arg("flags") = 0, + py::arg("size") = std::make_tuple(0.f, 0.f), + py::arg("inner_width") = 0.f + ); + m.def( "EndTable", []() { ImGui::EndTable(); } ); + m.def( + "TableNextRow", + [](float min_row_height, ImGuiTableRowFlags flags) { + ImGui::TableNextRow(flags, min_row_height); + }, + py::arg("min_row_height") = 0.f, + py::arg("flags") = 0 + ); + m.def( + "TableNextColumn", + []() -> bool { + return ImGui::TableNextColumn(); + } + ); + m.def( + "TableSetColumnIndex", + [](int column_n) -> bool { + return ImGui::TableSetColumnIndex(column_n); + }, + py::arg("column_n") + ); + + m.def( + "TableSetupColumn", + [](const char* label, ImGuiTableColumnFlags flags, float init_width_or_height, unsigned int user_id) { + ImGui::TableSetupColumn(label, flags, init_width_or_height, user_id); + }, + py::arg("label"), + py::arg("flags") = 0, + py::arg("init_width_or_height") = 0.f, + py::arg("user_id") = 0u + ); + m.def( + "TableSetupScrollFreeze", + [](int cols, int rows) { + ImGui::TableSetupScrollFreeze(cols, rows); + }, + py::arg("cols"), + py::arg("rows") + ); + m.def( + "TableHeader", + [](const char* label) { + ImGui::TableHeader(label); + }, + py::arg("label") + ); + m.def("TableHeadersRow", []() { ImGui::TableHeadersRow(); }); + + m.def("TableGetColumnCount", []() { return ImGui::TableGetColumnCount(); }); + m.def("TableGetColumnIndex", []() { return ImGui::TableGetColumnIndex(); }); + m.def("TableGetRowIndex", []() { return ImGui::TableGetRowIndex(); }); + m.def( + "TableGetColumnName", + [](int column_n) { return py::str(ImGui::TableGetColumnName(column_n)); }, + py::arg("column_n") = -1 + ); + m.def( + "TableSetColumnEnabled", + [](int column_n, bool enable) { return ImGui::TableSetColumnEnabled(column_n, enable); }, + py::arg("column_n"), + py::arg("v") + ); + m.def( + "TableSetBackgroundColor", + [](ImGuiTableBgTarget target, ImU32 color, int column_n) { + return ImGui::TableSetBgColor(target, color, column_n); + }, + py::arg("target"), + py::arg("color"), + py::arg("column_n") = -1 + ); + // Columns m.def( "Columns", From dcd83f7f89c0b85cf9f30e8417ab020f549510ea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thibault=20de=20Vill=C3=A8le?= <25150288+Thibaulltt@users.noreply.github.com> Date: Tue, 2 Dec 2025 11:59:39 +0100 Subject: [PATCH 2/4] Tables*: add bindings + some forgotten functions --- src/cpp/imgui.cpp | 55 +++++++++++++++++++++++++++----- src/polyscope_bindings/imgui.pyi | 32 +++++++++++++++++++ 2 files changed, 79 insertions(+), 8 deletions(-) diff --git a/src/cpp/imgui.cpp b/src/cpp/imgui.cpp index 77817e2..aa4eccb 100644 --- a/src/cpp/imgui.cpp +++ b/src/cpp/imgui.cpp @@ -1394,11 +1394,11 @@ void bind_imgui_methods(py::module& m) { m.def( "EndTable", []() { ImGui::EndTable(); } ); m.def( "TableNextRow", - [](float min_row_height, ImGuiTableRowFlags flags) { + [](ImGuiTableRowFlags flags, float min_row_height) { ImGui::TableNextRow(flags, min_row_height); }, - py::arg("min_row_height") = 0.f, - py::arg("flags") = 0 + py::arg("flags") = 0, + py::arg("min_row_height") = 0.f ); m.def( "TableNextColumn", @@ -1414,9 +1414,10 @@ void bind_imgui_methods(py::module& m) { py::arg("column_n") ); + // Table headers and columns m.def( "TableSetupColumn", - [](const char* label, ImGuiTableColumnFlags flags, float init_width_or_height, unsigned int user_id) { + [](const char* label, ImGuiTableColumnFlags flags, float init_width_or_height, ImGuiID user_id) { ImGui::TableSetupColumn(label, flags, init_width_or_height, user_id); }, py::arg("label"), @@ -1440,23 +1441,28 @@ void bind_imgui_methods(py::module& m) { py::arg("label") ); m.def("TableHeadersRow", []() { ImGui::TableHeadersRow(); }); + m.def("TableAngledHeadersRow", []() { ImGui::TableAngledHeadersRow(); }); - m.def("TableGetColumnCount", []() { return ImGui::TableGetColumnCount(); }); - m.def("TableGetColumnIndex", []() { return ImGui::TableGetColumnIndex(); }); - m.def("TableGetRowIndex", []() { return ImGui::TableGetRowIndex(); }); + // Table miscellaneous functions + /* TableSortSpecs not included: structure using pointers. */ + m.def("TableGetColumnCount", []() -> int { return ImGui::TableGetColumnCount(); }); + m.def("TableGetColumnIndex", []() -> int { return ImGui::TableGetColumnIndex(); }); + m.def("TableGetRowIndex", []() -> int { return ImGui::TableGetRowIndex(); }); m.def( "TableGetColumnName", [](int column_n) { return py::str(ImGui::TableGetColumnName(column_n)); }, py::arg("column_n") = -1 ); + /* TableGetColumnFlags not included for the same reasons. */ m.def( "TableSetColumnEnabled", [](int column_n, bool enable) { return ImGui::TableSetColumnEnabled(column_n, enable); }, py::arg("column_n"), py::arg("v") ); + m.def("TableGetHoveredColumn", []() -> int { return ImGui::TableGetHoveredColumn(); }); m.def( - "TableSetBackgroundColor", + "TableSetBgColor", [](ImGuiTableBgTarget target, ImU32 color, int column_n) { return ImGui::TableSetBgColor(target, color, column_n); }, @@ -2122,6 +2128,39 @@ void bind_imgui_enums(py::module& m) { static_cast(ImGuiTabItemFlags_NoCloseWithMiddleMouseButton); m.attr("ImGuiTabItemFlags_NoPushId") = static_cast(ImGuiTabItemFlags_NoPushId); + m.attr("ImGuiTableBgTarget_None") = static_cast(ImGuiTableBgTarget_None); + m.attr("ImGuiTableBgTarget_RowBg0") = static_cast(ImGuiTableBgTarget_RowBg0); + m.attr("ImGuiTableBgTarget_RowBg1") = static_cast(ImGuiTableBgTarget_RowBg1); + m.attr("ImGuiTableBgTarget_CellBg") = static_cast(ImGuiTableBgTarget_CellBg); + + m.attr("ImGuiTableRowFlags_None") = static_cast(ImGuiTableRowFlags_None); + m.attr("ImGuiTableRowFlags_Headers") = static_cast(ImGuiTableRowFlags_Headers); + + m.attr("ImGuiTableColumnFlags_None") = static_cast(ImGuiTableColumnFlags_None); + m.attr("ImGuiTableColumnFlags_Disabled") = static_cast(ImGuiTableColumnFlags_Disabled); + m.attr("ImGuiTableColumnFlags_DefaultHide") = static_cast(ImGuiTableColumnFlags_DefaultHide); + m.attr("ImGuiTableColumnFlags_DefaultSort") = static_cast(ImGuiTableColumnFlags_DefaultSort); + m.attr("ImGuiTableColumnFlags_WidthStretch") = static_cast(ImGuiTableColumnFlags_WidthStretch); + m.attr("ImGuiTableColumnFlags_WidthFixed") = static_cast(ImGuiTableColumnFlags_WidthFixed); + m.attr("ImGuiTableColumnFlags_NoResize") = static_cast(ImGuiTableColumnFlags_NoResize); + m.attr("ImGuiTableColumnFlags_NoReorder") = static_cast(ImGuiTableColumnFlags_NoReorder); + m.attr("ImGuiTableColumnFlags_NoHide") = static_cast(ImGuiTableColumnFlags_NoHide); + m.attr("ImGuiTableColumnFlags_NoClip") = static_cast(ImGuiTableColumnFlags_NoClip); + m.attr("ImGuiTableColumnFlags_NoSort") = static_cast(ImGuiTableColumnFlags_NoSort); + m.attr("ImGuiTableColumnFlags_NoSortAscending") = static_cast(ImGuiTableColumnFlags_NoSortAscending); + m.attr("ImGuiTableColumnFlags_NoSortDescending") = static_cast(ImGuiTableColumnFlags_NoSortDescending); + m.attr("ImGuiTableColumnFlags_NoHeaderLabel") = static_cast(ImGuiTableColumnFlags_NoHeaderLabel); + m.attr("ImGuiTableColumnFlags_NoHeaderWidth") = static_cast(ImGuiTableColumnFlags_NoHeaderWidth); + m.attr("ImGuiTableColumnFlags_PreferSortAscending") = static_cast(ImGuiTableColumnFlags_PreferSortAscending); + m.attr("ImGuiTableColumnFlags_PreferSortDescending") = static_cast(ImGuiTableColumnFlags_PreferSortDescending); + m.attr("ImGuiTableColumnFlags_IndentEnable") = static_cast(ImGuiTableColumnFlags_IndentEnable); + m.attr("ImGuiTableColumnFlags_IndentDisable") = static_cast(ImGuiTableColumnFlags_IndentDisable); + m.attr("ImGuiTableColumnFlags_AngledHeader") = static_cast(ImGuiTableColumnFlags_AngledHeader); + m.attr("ImGuiTableColumnFlags_IsEnabled") = static_cast(ImGuiTableColumnFlags_IsEnabled); + m.attr("ImGuiTableColumnFlags_IsVisible") = static_cast(ImGuiTableColumnFlags_IsVisible); + m.attr("ImGuiTableColumnFlags_IsSorted") = static_cast(ImGuiTableColumnFlags_IsSorted); + m.attr("ImGuiTableColumnFlags_IsHovered") = static_cast(ImGuiTableColumnFlags_IsHovered); + m.attr("ImGuiFocusedFlags_None") = static_cast(ImGuiFocusedFlags_None); m.attr("ImGuiFocusedFlags_ChildWindows") = static_cast(ImGuiFocusedFlags_ChildWindows); m.attr("ImGuiFocusedFlags_RootWindow") = static_cast(ImGuiFocusedFlags_RootWindow); diff --git a/src/polyscope_bindings/imgui.pyi b/src/polyscope_bindings/imgui.pyi index e582eed..b574241 100644 --- a/src/polyscope_bindings/imgui.pyi +++ b/src/polyscope_bindings/imgui.pyi @@ -24,6 +24,9 @@ ImGuiSelectableFlags = NewType("ImGuiSelectableFlags", int) ImGuiStyleVar = NewType("ImGuiStyleVar", int) ImGuiTabBarFlags = NewType("ImGuiTabBarFlags", int) ImGuiTabItemFlags = NewType("ImGuiTabItemFlags", int) +ImGuiTableBgTarget = NewType("ImGuiTableBgTarget", int) +ImGuiTableColumnFlags = NewType("ImGuiTableColumnFlags", int) +ImGuiTableRowFlags = NewType("ImGuiTableRowFlags", int) ImGuiTreeNodeFlags = NewType("ImGuiTreeNodeFlags", int) ImGuiWindowFlags = NewType("ImGuiWindowFlags", int) @@ -721,6 +724,35 @@ def OpenPopupOnItemClick( def IsPopupOpen(str_id: str) -> bool: ... def CloseCurrentPopup() -> None: ... + +# Tables + +def BeginTable(str_id: str, columns: int, flags: int + = 0, size: ImVec2 = (0,0), + innerwidth: float = 0.) -> bool: ... +def EndTable() -> None: ... +def TableNextRow(flags: ImGuiTableRowFlags = 0, + min_row_height: float = 0) -> None:... +def TableNextColumn() -> bool: ... +def TableSetColumnIndex(column_n: int) -> None:... + +def TableSetupColumn(label: str, flags: ImGuiTableColumnFlags + = 0, init_width_or_height: float = 0, + user_id: ImGuiID = 0) -> None: +def TableSetupScrollFreeze(cols: int, rows: int) -> None:... +def TableHeader(label: str) -> None:... +def TableHeadersRow() -> None:... +def TableAngledHeadersRow() -> None:... + +def TableGetColumnCount() -> int:... +def TableGetColumnIndex() -> int:... +def TableGetRowIndex() -> int:... +def TableGetColumnName() -> str:... +def TableSetColumnEnabled(column_n: int, v: bool) -> None:... +def TableGetHoveredColumn() -> int:... +def TableSetBgColor(target: ImGuiTableBgTarget, color: ImU32, + column_n: int = -1) -> None:... + # Columns From b808762e819c2fa9873d55e9158d056b99985aaf Mon Sep 17 00:00:00 2001 From: Nicholas Sharp Date: Wed, 10 Dec 2025 23:20:15 -0800 Subject: [PATCH 3/4] add bindings to a few missing enums etc --- src/cpp/imgui.cpp | 58 +++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 51 insertions(+), 7 deletions(-) diff --git a/src/cpp/imgui.cpp b/src/cpp/imgui.cpp index aa4eccb..4ea1ded 100644 --- a/src/cpp/imgui.cpp +++ b/src/cpp/imgui.cpp @@ -2020,7 +2020,10 @@ void bind_imgui_methods(py::module& m) { void bind_imgui_enums(py::module& m) { + py::enum_(m, "ImGuiDir"); py::enum_(m, "ImGuiKey"); + py::enum_(m, "ImGuiMouseSource"); + py::enum_(m, "ImGuiSortDirection"); m.attr("ImGuiWindowFlags_None") = static_cast(ImGuiWindowFlags_None); m.attr("ImGuiWindowFlags_NoTitleBar") = static_cast(ImGuiWindowFlags_NoTitleBar); @@ -2128,13 +2131,42 @@ void bind_imgui_enums(py::module& m) { static_cast(ImGuiTabItemFlags_NoCloseWithMiddleMouseButton); m.attr("ImGuiTabItemFlags_NoPushId") = static_cast(ImGuiTabItemFlags_NoPushId); - m.attr("ImGuiTableBgTarget_None") = static_cast(ImGuiTableBgTarget_None); - m.attr("ImGuiTableBgTarget_RowBg0") = static_cast(ImGuiTableBgTarget_RowBg0); - m.attr("ImGuiTableBgTarget_RowBg1") = static_cast(ImGuiTableBgTarget_RowBg1); - m.attr("ImGuiTableBgTarget_CellBg") = static_cast(ImGuiTableBgTarget_CellBg); - - m.attr("ImGuiTableRowFlags_None") = static_cast(ImGuiTableRowFlags_None); - m.attr("ImGuiTableRowFlags_Headers") = static_cast(ImGuiTableRowFlags_Headers); + m.attr("ImGuiTableFlags_None") = static_cast(ImGuiTableFlags_None); + m.attr("ImGuiTableFlags_Resizable") = static_cast(ImGuiTableFlags_Resizable); + m.attr("ImGuiTableFlags_Reorderable") = static_cast(ImGuiTableFlags_Reorderable); + m.attr("ImGuiTableFlags_Hideable") = static_cast(ImGuiTableFlags_Hideable); + m.attr("ImGuiTableFlags_Sortable") = static_cast(ImGuiTableFlags_Sortable); + m.attr("ImGuiTableFlags_NoSavedSettings") = static_cast(ImGuiTableFlags_NoSavedSettings); + m.attr("ImGuiTableFlags_ContextMenuInBody") = static_cast(ImGuiTableFlags_ContextMenuInBody); + m.attr("ImGuiTableFlags_RowBg") = static_cast(ImGuiTableFlags_RowBg); + m.attr("ImGuiTableFlags_BordersInnerH") = static_cast(ImGuiTableFlags_BordersInnerH); + m.attr("ImGuiTableFlags_BordersOuterH") = static_cast(ImGuiTableFlags_BordersOuterH); + m.attr("ImGuiTableFlags_BordersInnerV") = static_cast(ImGuiTableFlags_BordersInnerV); + m.attr("ImGuiTableFlags_BordersOuterV") = static_cast(ImGuiTableFlags_BordersOuterV); + m.attr("ImGuiTableFlags_BordersH") = static_cast(ImGuiTableFlags_BordersH); + m.attr("ImGuiTableFlags_BordersV") = static_cast(ImGuiTableFlags_BordersV); + m.attr("ImGuiTableFlags_BordersInner") = static_cast(ImGuiTableFlags_BordersInner); + m.attr("ImGuiTableFlags_BordersOuter") = static_cast(ImGuiTableFlags_BordersOuter); + m.attr("ImGuiTableFlags_Borders") = static_cast(ImGuiTableFlags_Borders); + m.attr("ImGuiTableFlags_NoBordersInBody") = static_cast(ImGuiTableFlags_NoBordersInBody); + m.attr("ImGuiTableFlags_NoBordersInBodyUntilResize") = static_cast(ImGuiTableFlags_NoBordersInBodyUntilResize); + m.attr("ImGuiTableFlags_SizingFixedFit") = static_cast(ImGuiTableFlags_SizingFixedFit); + m.attr("ImGuiTableFlags_SizingFixedSame") = static_cast(ImGuiTableFlags_SizingFixedSame); + m.attr("ImGuiTableFlags_SizingStretchProp") = static_cast(ImGuiTableFlags_SizingStretchProp); + m.attr("ImGuiTableFlags_SizingStretchSame") = static_cast(ImGuiTableFlags_SizingStretchSame); + m.attr("ImGuiTableFlags_NoHostExtendX") = static_cast(ImGuiTableFlags_NoHostExtendX); + m.attr("ImGuiTableFlags_NoHostExtendY") = static_cast(ImGuiTableFlags_NoHostExtendY); + m.attr("ImGuiTableFlags_NoKeepColumnsVisible") = static_cast(ImGuiTableFlags_NoKeepColumnsVisible); + m.attr("ImGuiTableFlags_PreciseWidths") = static_cast(ImGuiTableFlags_PreciseWidths); + m.attr("ImGuiTableFlags_NoClip") = static_cast(ImGuiTableFlags_NoClip); + m.attr("ImGuiTableFlags_PadOuterX") = static_cast(ImGuiTableFlags_PadOuterX); + m.attr("ImGuiTableFlags_NoPadOuterX") = static_cast(ImGuiTableFlags_NoPadOuterX); + m.attr("ImGuiTableFlags_NoPadInnerX") = static_cast(ImGuiTableFlags_NoPadInnerX); + m.attr("ImGuiTableFlags_ScrollX") = static_cast(ImGuiTableFlags_ScrollX); + m.attr("ImGuiTableFlags_ScrollY") = static_cast(ImGuiTableFlags_ScrollY); + m.attr("ImGuiTableFlags_SortMulti") = static_cast(ImGuiTableFlags_SortMulti); + m.attr("ImGuiTableFlags_SortTristate") = static_cast(ImGuiTableFlags_SortTristate); + m.attr("ImGuiTableFlags_HighlightHoveredColumn") = static_cast(ImGuiTableFlags_HighlightHoveredColumn); m.attr("ImGuiTableColumnFlags_None") = static_cast(ImGuiTableColumnFlags_None); m.attr("ImGuiTableColumnFlags_Disabled") = static_cast(ImGuiTableColumnFlags_Disabled); @@ -2160,6 +2192,14 @@ void bind_imgui_enums(py::module& m) { m.attr("ImGuiTableColumnFlags_IsVisible") = static_cast(ImGuiTableColumnFlags_IsVisible); m.attr("ImGuiTableColumnFlags_IsSorted") = static_cast(ImGuiTableColumnFlags_IsSorted); m.attr("ImGuiTableColumnFlags_IsHovered") = static_cast(ImGuiTableColumnFlags_IsHovered); + + m.attr("ImGuiTableRowFlags_None") = static_cast(ImGuiTableRowFlags_None); + m.attr("ImGuiTableRowFlags_Headers") = static_cast(ImGuiTableRowFlags_Headers); + + m.attr("ImGuiTableBgTarget_None") = static_cast(ImGuiTableBgTarget_None); + m.attr("ImGuiTableBgTarget_RowBg0") = static_cast(ImGuiTableBgTarget_RowBg0); + m.attr("ImGuiTableBgTarget_RowBg1") = static_cast(ImGuiTableBgTarget_RowBg1); + m.attr("ImGuiTableBgTarget_CellBg") = static_cast(ImGuiTableBgTarget_CellBg); m.attr("ImGuiFocusedFlags_None") = static_cast(ImGuiFocusedFlags_None); m.attr("ImGuiFocusedFlags_ChildWindows") = static_cast(ImGuiFocusedFlags_ChildWindows); @@ -2210,6 +2250,10 @@ void bind_imgui_enums(py::module& m) { m.attr("ImGuiDir_Down") = static_cast(ImGuiDir_Down); m.attr("ImGuiDir_COUNT") = static_cast(ImGuiDir_COUNT); + m.attr("ImGuiSortDirection_None") = static_cast(ImGuiSortDirection_None); + m.attr("ImGuiSortDirection_Ascending") = static_cast(ImGuiSortDirection_Ascending); + m.attr("ImGuiSortDirection_Descending") = static_cast(ImGuiSortDirection_Descending); + m.attr("ImGuiKey_Tab") = static_cast(ImGuiKey_Tab); m.attr("ImGuiKey_None") = static_cast(ImGuiKey_None); m.attr("ImGuiKey_Tab") = static_cast(ImGuiKey_Tab); From 985d2bb1bf005a1682854f90ec79aeec0100b07e Mon Sep 17 00:00:00 2001 From: Nicholas Sharp Date: Wed, 10 Dec 2025 23:20:35 -0800 Subject: [PATCH 4/4] bind a the table sort related functions --- src/cpp/imgui.cpp | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/src/cpp/imgui.cpp b/src/cpp/imgui.cpp index 4ea1ded..24d1f14 100644 --- a/src/cpp/imgui.cpp +++ b/src/cpp/imgui.cpp @@ -135,6 +135,28 @@ void bind_imgui_structs(py::module& m) { ; + + // Table sorting + py::class_(m, "ImGuiTableSortSpecs") + .def("Specs", [](py::object& ob) { + ImGuiTableSortSpecs& o = ob.cast(); + std::vector specs; + for (int i = 0; i < o.SpecsCount; i++) { + specs.push_back(o.Specs[i]); + } + return specs;} + ) + .def_readonly("SpecsCount", &ImGuiTableSortSpecs::SpecsCount) + .def_readwrite("SpecsDirty", &ImGuiTableSortSpecs::SpecsDirty) + ; + + py::class_(m, "ImGuiTableColumnSortSpecs") + .def_readonly("ColumnUserID", &ImGuiTableColumnSortSpecs::ColumnUserID) + .def_readonly("ColumnIndex", &ImGuiTableColumnSortSpecs::ColumnIndex) + .def_readonly("SortOrder", &ImGuiTableColumnSortSpecs::SortOrder) + .def_readonly("SortDirection", &ImGuiTableColumnSortSpecs::SortDirection) + ; + } void bind_imgui_methods(py::module& m) { @@ -1444,7 +1466,10 @@ void bind_imgui_methods(py::module& m) { m.def("TableAngledHeadersRow", []() { ImGui::TableAngledHeadersRow(); }); // Table miscellaneous functions - /* TableSortSpecs not included: structure using pointers. */ + + // warning! this function returns a pointer which is only valid for a short time, within the same frame and before next call to BeginTable() (see imgui docs) + // you will get undefined behavior if you try to use it later + m.def("TableGetSortSpecs", []() -> ImGuiTableSortSpecs* { return ImGui::TableGetSortSpecs(); }, py::return_value_policy::reference); m.def("TableGetColumnCount", []() -> int { return ImGui::TableGetColumnCount(); }); m.def("TableGetColumnIndex", []() -> int { return ImGui::TableGetColumnIndex(); }); m.def("TableGetRowIndex", []() -> int { return ImGui::TableGetRowIndex(); });