Help Needed with is_text_changed() and color_convert_float4_to_u32() Behaviors

[tingspain]

Hello,

I am encountering two issues while using ImGui Bundle and would appreciate any guidance or clarification.

System Details:

• Device: MacBook M1 Max
• macOS Version: 15.2 (24C101)

---

Question 1: is_text_changed() behavior

I am trying to use the is_text_changed() method from imgui_color_text_edit.TextEditor to detect text modifications. However, the return value does not seem to persist after the text has been modified. Is this a bug, or am I using the method incorrectly?

Here is a code snippet illustrating the issue:

...

if imgui.begin_menu_bar():
    imgui.text(f'Text Modified: {editor.is_text_changed()}')
    imgui.separator()
    imgui.text(f'Ln {cur_pos.m_line + 1}/{editor.get_total_lines()}, Col {cur_pos.m_column + 1}')
    imgui.end_menu_bar()

...

Question 2: color_convert_float4_to_u32() behavior

I am having trouble with the behavior of imgui.color_convert_float4_to_u32(). I expected it to take an ImVec4 in RGBA format, but it only seems to work as expected when I pass the colors in ABGR format. Am I missing something here?

Here is a code snippet demonstrating the behavior:

...

theme = ed.TextEditor.get_mariana_palette()
frame_color = ImVec4(0.0, 1.0, 0.0, 1.0 ) # GREEN - alpha @ 100% 
theme[ed.TextEditor.PaletteIndex.background] = imgui.color_convert_float4_to_u32(frame_color)
editor.set_palette(theme)

...

With RGBA inputs, the colors do not appear as expected. However, when I swap to ABGR inputs, the colors work correctly. Is this the intended behavior, or am I misunderstanding how this function works?

---

Working Example

I’ve created a minimal working example where the two questions are marked as QUESTION #1 and QUESTION #2:

import sys
import platform
import OpenGL.GL as GL  # type: ignore
from imgui_bundle import imgui, implot, implot3d, imgui_md, ImVec4, imgui_color_text_edit as ed
from imgui_bundle.immapp import static
from imgui_bundle import portable_file_dialogs as pfd

# Always import glfw *after* imgui_bundle
# (since imgui_bundle will set the correct path where to look for the correct 
# version of the glfw dynamic library)
import glfw  # type: ignore

TextEditor = ed.TextEditor



def glfw_error_callback(error: int, description: str) -> None:
    """
    Handle GLFW errors.
    """
    sys.stderr.write(f"Glfw Error {error}: {description}\n")



def notify_user_just_demo():
    pfd.message("Notification", "This is just a demo", pfd.choice.ok, pfd.icon.warning)



def create_main_menu():
    
    imgui.begin_main_menu_bar()
        
    if imgui.begin_menu("File"):
        
        clicked, _ = imgui.menu_item("New File", "", False)
        if clicked:
            notify_user_just_demo()
        
        clicked, _ = imgui.menu_item("Save File", "", False)
        if clicked:
            notify_user_just_demo()
            
        clicked, _ = imgui.menu_item("Close File", "", False)
        if clicked:
            notify_user_just_demo()
            
        imgui.separator()
        
        clicked, _ = imgui.menu_item("Exit", "", False)
        if clicked:
            exit(1)
        
        imgui.end_menu()
        
    if imgui.begin_menu("Edit"):
        clicked, _ = imgui.menu_item("Test me", "", False)
        if clicked:
            notify_user_just_demo()

        
        imgui.end_menu()
        
    imgui.end_main_menu_bar()



def create_status_bar(editor:TextEditor):
    
    viewport = imgui.get_main_viewport()        
    heightSideBar = imgui.get_frame_height()
    flags   = imgui.WindowFlags_.no_scrollbar | imgui.WindowFlags_.no_saved_settings | imgui.WindowFlags_.menu_bar
    
    cur_pos = editor.get_cursor_position()
    
    if imgui.internal.begin_viewport_side_bar("StatusBar", viewport,  imgui.Dir.down, heightSideBar, flags):
        if imgui.begin_menu_bar():
            
            # QUESTION #1 the return value is not persitance. is there a bug ? 
            # or am I doing something wrong? 
            imgui.text(f'Text Modified: {editor.is_text_changed()}' ) 
            
            imgui.separator()
            
            imgui.text(f'Ln {cur_pos.m_line + 1}/{editor.get_total_lines()}, Col {cur_pos.m_column + 1}')
            
            imgui.end_menu_bar()
            
    imgui.end()
    


def create_editor(name, editor):
    
    imgui.begin(name)
    
    imgui.push_font(imgui_md.get_code_font())
    editor.render("Editor")
    imgui.pop_font()
    
    imgui.end()



def main() -> None:
    
    # Setup window
    glfw.set_error_callback(glfw_error_callback)
    if not glfw.init():
        sys.exit(1)

    # Decide GL+GLSL versions
    if platform.system() == "Darwin":
        glsl_version = "#version 150"
        glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
        glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 2)
        glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)  # // 3.2+ only
        glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL.GL_TRUE) 
    else:
        # GL 3.0 + GLSL 130
        glsl_version = "#version 130"
        glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
        glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 0)
        # glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) # // 3.2+ only
        # glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL.GL_TRUE)

    # Create window with graphics context
    window = glfw.create_window(1000, 800, "Text Editor Demo", None, None)
    if window is None:
        glfw.terminate()
        raise RuntimeError("Failed to create GLFW window")
        
    glfw.make_context_current(window)
    glfw.swap_interval(1)  # // Enable vsync

    # Setup Dear ImGui context
    # IMGUI_CHECKVERSION();
    imgui.create_context()
    io = imgui.get_io()
    io.config_flags |= (
        imgui.ConfigFlags_.nav_enable_keyboard.value
    )  # Enable Keyboard Controls
    
    io.config_flags |= imgui.ConfigFlags_.docking_enable   # Enable docking
    io.config_flags |= imgui.ConfigFlags_.viewports_enable # Enable Multi-Viewport / Platform Windows

    # Setup Dear ImGui style
    imgui.style_colors_dark()

    # When viewports are enabled we tweak WindowRounding/WindowBg so platform 
    # windows can look identical to regular ones.
    style = imgui.get_style()
    if io.config_flags & imgui.ConfigFlags_.viewports_enable.value:
        style.window_rounding = 4.0
        window_bg_color = style.color_(imgui.Col_.window_bg.value)
        window_bg_color.w = 1.0
        style.set_color_(imgui.Col_.window_bg.value, window_bg_color)

    # Setup Platform/Renderer backends
    import ctypes

    # You need to transfer the window address to imgui.backends.glfw_init_for_opengl
    # proceed as shown below to get it.
    window_address = ctypes.cast(window, ctypes.c_void_p).value
    assert window_address is not None
    imgui.backends.glfw_init_for_opengl(window_address, True)

    imgui.backends.opengl3_init(glsl_version)


    # Add Fonts
    # ------------------------------------------------
    
    # i. Load default font
    font_atlas  = imgui.get_io().fonts
    font_config = imgui.ImFontConfig()
    font_config.size_pixels = 16.0
    font_atlas.add_font_default(font_config)

    # Our state
    clear_color = [0.3, 0.3, 0.3, 1.00]
    
    implot.create_context()
    implot3d.create_context()
    
    imgui_md.initialize_markdown()
    font_loader = imgui_md.get_font_loader_function()
    font_loader()
        
    # Create the Editor --------------------------------------------------------
    with open(__file__, encoding="utf8") as f:
        this_file_code = f.read()
        
    editor = TextEditor()
    editor.set_text(this_file_code)
    editor.set_language_definition(TextEditor.LanguageDefinition.python())
    
    theme = ed.TextEditor.get_mariana_palette()
    imgui.get_style().color_(imgui.Col_.child_bg)
    frame_color = imgui.get_style().color_(imgui.Col_.frame_bg)
    
    # Color in RGBA format
    frame_color = ImVec4(1.0, 0.0, 0.0, 1.0 ) # RED   - alpha @ 100% 
    frame_color = ImVec4(1.0, 0.0, 0.0, 0.3 ) # RED   - alpha @ 30%    
    frame_color = ImVec4(0.0, 1.0, 0.0, 1.0 ) # GREEN - alpha @ 100% 
    frame_color = ImVec4(0.0, 1.0, 0.0, 0.3 ) # GREEN - alpha @ 30%    
    frame_color = ImVec4(0.0, 0.0, 1.0, 1.0 ) # BLUE  - alpha @ 100% 
    frame_color = ImVec4(0.0, 0.0, 1.0, 0.3 ) # BLUE  - alpha @ 30%    

    # Color in ABGR format
    frame_color = ImVec4(1.0, 0.0, 0.0, 1.0 ) # RED   - alpha @ 100% 
    frame_color = ImVec4(0.3, 0.0, 0.0, 1.0 ) # RED   - alpha @ 30%    
    frame_color = ImVec4(1.0, 0.0, 1.0, 0.0 ) # GREEN - alpha @ 100% 
    frame_color = ImVec4(0.3, 0.0, 1.0, 0.0 ) # GREEN - alpha @ 30%    
    frame_color = ImVec4(1.0, 1.0, 0.0, 0.0 ) # BLUE  - alpha @ 100% 
    frame_color = ImVec4(0.3, 1.0, 0.0, 0.0 ) # BLUE  - alpha @ 30%  
    
    # frame_color = ImVec4(0.3, 0.3, 0.3, 0.3 ) 

    # QUESTION #2 I am a little lost with the behaviour of imgui.color_convert_float4_to_u32(), 
    # I was expecting that the input has to be an ImVec4 with the format of RGBA, however it is 
    # not working as expected. However, if i pass in ABGR, it works as expected. Am I missing 
    # something here? 
    theme[ed.TextEditor.PaletteIndex.background] = imgui.color_convert_float4_to_u32( frame_color )
    
    editor.set_palette(theme)    
        
    first_time = True
    
    # ==========================================================================
    # Main loop 
    # ==========================================================================
    while not glfw.window_should_close(window):

        glfw.poll_events()

        # Start the Dear ImGui frame
        imgui.backends.opengl3_new_frame()
        imgui.backends.glfw_new_frame()
        imgui.new_frame()
        
        # Init the main menu
        create_main_menu()
            
        # Enable Docking Space in the Main Viewport
        dockspace_id = imgui.dock_space_over_viewport(dockspace_id=0, 
                                    viewport = imgui.get_main_viewport(),
                                    flags= imgui.DockNodeFlags_.passthru_central_node)
        
            
        if first_time:         
            first_time = False
            imgui.internal.dock_builder_dock_window("Editor", dockspace_id)
        
        create_editor("Editor", editor)
        
        # Add the Status bar at the bottom 
        create_status_bar(editor)
        
        # Rendering
        imgui.render()
        
        display_w, display_h = glfw.get_framebuffer_size(window)
        GL.glViewport(0, 0, display_w, display_h)
        GL.glClearColor(
            clear_color[0] * clear_color[3],
            clear_color[1] * clear_color[3],
            clear_color[2] * clear_color[3],
            clear_color[3],
        )
        GL.glClear(GL.GL_COLOR_BUFFER_BIT)
        
        
        imgui.backends.opengl3_render_draw_data(imgui.get_draw_data())

        # Update and Render additional Platform Windows
        # (Platform functions may change the current OpenGL context, so we 
        # save/restore it to make it easier to paste this code elsewhere.
        # For this specific demo app we could also call glfwMakeContextCurrent(window) directly)
        if io.config_flags & imgui.ConfigFlags_.viewports_enable.value > 0:
            backup_current_context = glfw.get_current_context()
            imgui.update_platform_windows()
            imgui.render_platform_windows_default()
            glfw.make_context_current(backup_current_context)
        
        glfw.swap_buffers(window)

    # Cleanup
    imgui.backends.opengl3_shutdown()
    imgui.backends.glfw_shutdown()
    
    imgui_md.de_initialize_markdown()
    implot3d.destroy_context()
    implot.destroy_context()
    imgui.destroy_context()

    glfw.destroy_window(window)
    glfw.terminate()


if __name__ == "__main__":
    main()

---

Thank you in advance for your help! Any insights or guidance would be greatly appreciated.

[pthom]

Question 1: is_text_changed()

is_text_changed() will return True only in the frame where the text is modified.
If you want to keep track of a global modification vs an original state of the text, it is up to you to implement it

[tingspain]

Thank you for clarifying that is_text_changed() only returns True during the frame in which the text is modified. I initially misunderstood its behavior, expecting it to return a persistent value.

Thanks to your explanation, I implemented a mechanism to track the state of the text across frames, and it works perfectly! Here's a draft of my solution, which handles tracking the modification state while allowing for save, restore, and reset operations:

class EditorState:
    def __init__(self, editor):
        """Initialize the editor state with the original text."""
        self.editor: TextEditor = editor
        self.original_text: str = editor.get_text()
        self.text_modified: bool = False

    def update(self):
        """Check if the text has been modified in the current frame and update the state."""
        if self.editor.is_text_changed():
            self.text_modified = True

    def save(self):
        """Save the current text to disk and reset the modification state."""
        # TODO: Implement file-saving logic here
        self.original_text = self.editor.get_text()
        self.text_modified = False

    def restore(self):
        """Restore the text to its original state."""
        self.editor.set_text(self.original_text)
        self.text_modified = False

    def reset(self):
        """Reset the state by treating the current text as the new original."""
        self.original_text = self.editor.get_text()
        self.text_modified = False

    def is_text_modified(self):
        """Check if the text has been modified since the original state."""
        return self.text_modified

[pthom]

Question 2: color_convert_float4_to_u32
I expected it to take an ImVec4 in RGBA format, but it only seems to work as expected when I pass the colors in ABGR format. Am I missing something here?

The code below

color_floats = [
    ImVec4(1.0, 0.0, 0.0, 0.0),
    ImVec4(0.0, 1.0, 0.0, 0.0),
    ImVec4(0.0, 0.0, 1.0, 0.0),
    ImVec4(0.0, 0.0, 0.0, 1.0),

    ImVec4(1.0, 0.0, 0.0, 1.0),

]

for color_float in color_floats:
    color_int = imgui.color_convert_float4_to_u32(color_float)
    print(f"color_float: {color_float}   color_int(binary): {color_int:b}")

prints

color_float: ImVec4(1.000000, 0.000000, 0.000000, 0.000000)   color_int(binary): 11111111
color_float: ImVec4(0.000000, 1.000000, 0.000000, 0.000000)   color_int(binary): 1111111100000000
color_float: ImVec4(0.000000, 0.000000, 1.000000, 0.000000)   color_int(binary): 111111110000000000000000
color_float: ImVec4(0.000000, 0.000000, 0.000000, 1.000000)   color_int(binary): 11111111000000000000000000000000
color_float: ImVec4(1.000000, 0.000000, 0.000000, 1.000000)   color_int(binary): 11111111000000000000000011111111

So, this seems to prove that color_convert_float4_to_u32 behaves correctly.

Your issue is perhaps related to a small issue in the Text Editor itself.

[tingspain]

Indeed, it does seem like the issue lies within ImGuiColorTextEdit. Thank you for confirming that color_convert_float4_to_u32 behaves as expected.

Given this, I was wondering if there are any plans to transition from the ImGuiColorTextEdit library by BalazsJako to the version maintained by Santaclose. The latter appears to be actively maintained (last commit 4 months ago versus 6 years for BalazsJako's version) and offers additional functionality that could enhance the user experience.

Here’s a short video showcasing the bug for reference:

ImGuiColorTextEdit2.mp4

[pthom]

Hi,

ImGuiColorTextEdit is already using the version maintained by Santaclose.
I recently updated my fork to integrate the latest changes in santaclose version. I also pushed a recent accepted PR to santaclose version.

[tingspain]

Hi @pthom,

Thank you for the clarification and for keeping the library up to date! I really appreciate your efforts in integrating the latest changes and contributing to the Santaclose version.

I’m looking forward to the next release of imgui_bundle and excited to see the improvements it brings.

Thanks again for your hard work!

[tingspain]

I believe my questions have been satisfactorily answered, so we can consider this matter resolved ^___^
Thanks, @pthom!