Expressing object ownership for a global implicit context arg like in ImGui or OpenGL

[nurpax]

I've been developing ImGui bindings with Nanobind and I'm pretty happy with both my progress and results so far. However, there I have some untackled areas in expressing object ownership correctly and looking for help and ideas here.

Let me summarize some key ImGui APIs before continuing:

Most ImGui API calls use a hidden implicit "current ImGui context". Such a context is created using a call to ImGui::CreateContext, as below:

// Create and set the current context
IMGUI_API ImGuiContext* CreateContext(ImFontAtlas* shared_font_atlas = NULL);
IMGUI_API void          DestroyContext(ImGuiContext* ctx = NULL);   // NULL = destroy current context

All subsequent API calls to ImGui will use the implicit "global context". E.g.,

ImGui::CreateContext();
// get the "IO" part of the current context for modifying either directly through member 
// variables or calling methods on it
// the io reference will become invalid once the implicitly referenced ImGuiContext is destroyed    
ImGuiIO& io = ImGui::GetIO();
io.DeltaTime = 1.0f/60.0f;              // set the time elapsed since the previous frame (in seconds)
io.DisplaySize.x = 1920.0f;             // set the current display width
    
ImGui::NewFrame();
ImGui::Text("Hello, world!");

I have currently modeled ImGui::GetIO like this:

nb::class_<ImGuiContext>(m, "Context");
m.def("get_io", &ImGui::GetIO, nb::rv_policy::reference);

Quite obviously, this does not take into account the ImGui implicit "current context". Nanobind doesn't know that ImGui::GetIO refers to the currently set context. I just don't know how to model this relationship through nanobind.

I wonder if anyone has any ideas on how to express an implicit context like above?

So far I've been getting by using my bindings even with broken object relationship modeling but I suspect I will soon hit more serious bugs. For example, it's possible in ImGui to directly set ImGUI::GetIO() fields, e.g.,

// assign a raw C string pointer to IniFilename.  This string pointer needs to be valid
// through the lifetime of the current ImGui context's usage as ImGui does not take
// a copy of the string.
ImGui::GetIO().IniFilename = "foo.ini" (or NULL)

So if I model the above with something like below, I think I'll hit problems with Python object lifetimes:

nb::class_<ImGuiIO>(m, "IO")
    .def_prop_rw("ini_filename",
        [](ImGuiIO& io) { return io.IniFilename; },
        [](ImGuiIO& io, nb::handle filename) {
            // TODO what about the lifetime of io.IniFilename?
            const char* fname = !filename.is_none() ? nb::cast<const char *>(filename) : nullptr;
            io.IniFilename = fname;
        },
        "ini_filename"_a.none(),
    )

And using it like:

io = imgui.get_io()
some_val = 0
io.ini_filename = f"foo{some_val}" # presumably allocates a new str every frame

[wjakob]

Do these abstract handles need to be destructed when no longer needed? I think instead of binding the functions directly, the best strategy might be to create some kind of C++ wrapper (a struct with constructor and destructor calling the appropriate functions). Functions consuming these objects can then unwrap them to get the contained opaque pointer.