`gdk_x11_surface_get_xid` Segmentation Fault when initializing Mousetrap about mousetrap.jl HOT 19 OPEN

(process:185604): mousetrap-CRITICAL **: 14:32:36.464: In RenderArea(): trying to instantiate RenderArea, but the OpenGL component is disabled.

I am now using gdk_x11_surface_get_xid(gtk_native_get_surface(GTK_NATIVE(window))) to get an XID from a GTK window widget. – 
[Ank i zle](https://stackoverflow.com/users/10696946/ank-i-zle)
[Mar 15, 2022 at 2:10](https://stackoverflow.com/questions/71461608/gtk-window-to-gdk-surface-in-gtk4#comment126333979_71461608)

julia> import libadwaita_jll, mousetrap_linux_jll

julia> ccall((:adw_init, libadwaita_jll.libadwaita), Cvoid, ())

julia> ccall((:_ZN9mousetrap6detail17initialize_openglEv, mousetrap_linux_jll.mousetrap_julia_binding), Cvoid, ())

[19474] signal (11.1): Segmentation fault
in expression starting at REPL[3]:1
gdk_x11_surface_get_xid at /home/ufechner/.julia/artifacts/5498f875c31a1b3422ce1b64ef770407109eff30/lib/libgtk-4.so (unknown line)
Allocations: 2998 (Pool: 2986; Big: 12); GC: 0
Segmentation fault (core dumped)

julia> ENV["MOUSETRAP_DISABLE_OPENGL_COMPONENT"] = "TRUE"
"TRUE"

julia> import Pkg; Pkg.update("mousetrap_linux_jll")
    Updating registry at `~/.julia/registries/General.toml`
    Updating git-repo `https://github.com/Clemapfel/mousetrap_linux_jll`
  No Changes to `~/repos/Mouse/Project.toml`
  No Changes to `~/repos/Mouse/Manifest.toml`

julia> using Mousetrap

julia> 

  [5deeb4b9] Mousetrap v0.3.0 `https://github.com/clemapfel/mousetrap.jl#main`

ENV["MOUSETRAP_DISABLE_OPENGL_COMPONENT"] = "TRUE"

module MousetrapMakie

    export GLMakieArea, create_glmakie_screen

    using Mousetrap
    using ModernGL, GLMakie, Colors, GeometryBasics, ShaderAbstractions
    using GLMakie: empty_postprocessor, fxaa_postprocessor, OIT_postprocessor, to_screen_postprocessor
    using GLMakie.GLAbstraction
    using GLMakie.Makie

    """
    ## GLMakieArea <: Widget
    `GLArea` wrapper that automatically connects all necessary callbacks in order for it to be used as a GLMakie render target. 

    Use `create_glmakie_screen` to initialize a screen you can render to using Makie from this widget. Note that `create_glmakie_screen` needs to be 
    called **after** `GLMakieArea` has been realized, as only then will the internal OpenGL context be available. See the example below.

    ## Constructors
    `GLMakieArea()`

    ## Signals
    (no unique signals)

    ## Fields
    (no public fields)

    ## Example
    ```
    using Mousetrap, MousetrapMakie
    main() do app::Application
        window = Window(app)
        canvas = GLMakieArea()
        set_size_request!(canvas, Vector2f(200, 200))
        set_child!(window, canvas)
    
        # use optional ref to delay screen allocation after `realize`
        screen = Ref{Union{Nothing, GLMakie.Screen{GLMakieArea}}}(nothing)
        connect_signal_realize!(canvas) do self
            screen[] = create_glmakie_screen(canvas)
            display(screen[], scatter(1:4))
            return nothing
        end
        present!(window)
    end
    ```
    """
    mutable struct GLMakieArea <: Widget

        glarea::GLArea              # wrapped native widget
        framebuffer_id::Ref{Int}    # set by render callback, used in MousetrapMakie.create_glmakie_screen
        framebuffer_size::Vector2i  # set by resize callback, used in GLMakie.framebuffer_size

        function GLMakieArea()
            glarea = GLArea()
            set_auto_render!(glarea, false) # should `render` be emitted everytime the widget is drawn
            connect_signal_render!(on_makie_area_render, glarea)
            connect_signal_resize!(on_makie_area_resize, glarea)
            return new(glarea, Ref{Int}(0), Vector2i(0, 0))
        end
    end
    Mousetrap.get_top_level_widget(x::GLMakieArea) = x.glarea

    # maps hash(GLMakieArea) to GLMakie.Screen
    const screens = Dict{UInt64, GLMakie.Screen}()

    # maps hash(GLMakieArea) to Scene, used in `on_makie_area_resize`
    const scenes = Dict{UInt64, GLMakie.Scene}()

    # render callback: if screen is open, render frame to `GLMakieArea`s OpenGL context
    function on_makie_area_render(self, context)
        key = Base.hash(self)
        if haskey(screens, key)
            screen = screens[key]
            if !isopen(screen) return false end
            screen.render_tick[] = nothing
            glarea = screen.glscreen
            glarea.framebuffer_id[] = glGetIntegerv(GL_FRAMEBUFFER_BINDING)
            GLMakie.render_frame(screen) 
        end
        return true
    end

    # resize callback: update framebuffer size, necessary for `GLMakie.framebuffer_size`
    function on_makie_area_resize(self, w, h)
        key = Base.hash(self)
        if haskey(screens, key)
            screen = screens[key]
            glarea = screen.glscreen
            glarea.framebuffer_size.x = w
            glarea.framebuffer_size.y = h
            queue_render(glarea.glarea)
        end

        if haskey(scenes, key)
            scene = scenes[key]
            scene.events.window_area[] = Recti(0, 0, glarea.framebuffer_size.x, glarea.framebuffer_size.y)
            scene.events.window_dpi[] = Mousetrap.calculate_monitor_dpi(glarea)
        end
        return nothing
    end

    # resolution of `GLMakieArea` OpenGL framebuffer
    GLMakie.framebuffer_size(self::GLMakieArea) = (self.framebuffer_size.x, self.framebuffer_size.y)

    # forward retina scale factor from GTK4 back-end
    GLMakie.retina_scaling_factor(w::GLMakieArea) = Mousetrap.get_scale_factor(w)

    # resolution of `GLMakieArea` widget itself`
    function GLMakie.window_size(w::GLMakieArea)
        size = get_natural_size(w)
        size.x = size.x * GLMakie.retina_scaling_factor(w)
        size.y = size.y * GLMakie.retina_scaling_factor(w)
        return (size.x, size.y)
    end

    # calculate screen size and dpi
    function Makie.window_area(scene::Scene, screen::GLMakie.Screen{GLMakieArea})
        glarea = screen.glscreen
        scenes[hash(glarea)] = scene
    end

    # resize request by makie will be ignored
    function GLMakie.resize_native!(native::GLMakieArea, resolution...)
        # noop
    end

    # bind `GLMakieArea` OpenGL context
    ShaderAbstractions.native_switch_context!(a::GLMakieArea) = make_current(a.glarea)

    # check if `GLMakieArea` OpenGL context is still valid, it is while `GLMakieArea` widget stays realized
    ShaderAbstractions.native_context_alive(x::GLMakieArea) = get_is_realized(x)

    # destruction callback ignored, lifetime is managed by mousetrap instead
    function GLMakie.destroy!(w::GLMakieArea)
        # noop
    end

    # check if canvas is still realized
    GLMakie.was_destroyed(window::GLMakieArea) = !get_is_realized(window)

    # check if canvas should signal it is open
    Base.isopen(w::GLMakieArea) = !GLMakie.was_destroyed(w)

    # react to makie screen visibility request
    GLMakie.set_screen_visibility!(screen::GLMakieArea, bool) = bool ? show(screen.glarea) : hide!(screen.glarea)

    # apply glmakie config
    function GLMakie.apply_config!(screen::GLMakie.Screen{GLMakieArea}, config::GLMakie.ScreenConfig; start_renderloop=true) 
        @warn "In MousetrapMakie: GLMakie.apply_config!: This feature is not yet implemented, ignoring config"
        # cf https://github.com/JuliaGtk/Gtk4Makie.jl/blob/main/src/screen.jl#L111
        return screen
    end

    # screenshot framebuffer
    function Makie.colorbuffer(screen::GLMakie.Screen{GLMakieArea}, format::Makie.ImageStorageFormat = Makie.JuliaNative)
        @warn "In MousetrapMakie: GLMakie.colorbuffer: This feature is not yet implemented, returning framecache"
        # cf https://github.com/JuliaGtk/Gtk4Makie.jl/blob/main/src/screen.jl#L147
        return screen.framecache
    end

    # ignore makie event model, use the mousetrap event controllers instead
    Makie.window_open(::Scene, ::GLMakieArea) = nothing
    Makie.disconnect!(::GLMakieArea, f) = nothing
    GLMakie.pollevents(::GLMakie.Screen{GLMakieArea}) = nothing
    Makie.mouse_buttons(::Scene, ::GLMakieArea) = nothing
    Makie.keyboard_buttons(::Scene, ::GLMakieArea) = nothing
    Makie.dropped_files(::Scene, ::GLMakieArea) = nothing
    Makie.unicode_input(::Scene, ::GLMakieArea) = nothing
    Makie.mouse_position(::Scene, ::GLMakie.Screen{GLMakieArea}) = nothing
    Makie.scroll(::Scene, ::GLMakieArea) = nothing
    Makie.hasfocus(::Scene, ::GLMakieArea) = nothing
    Makie.entered_window(::Scene, ::GLMakieArea) = nothing

    """
    ```
    create_gl_makie_screen(::GLMakieArea; screen_config...) -> GLMakie.Screen{GLMakieArea}
    ```
    For a `GLMakieArea`, create a `GLMakie.Screen` that can be used to display makie graphics
    """
    function create_glmakie_screen(area::GLMakieArea; screen_config...)

        if !get_is_realized(area) 
            log_critical("MousetrapMakie", "In MousetrapMakie.create_glmakie_screen: GLMakieArea is not yet realized, it's internal OpenGL context cannot yet be accessed")
        end

        config = Makie.merge_screen_config(GLMakie.ScreenConfig, screen_config)

        set_is_visible!(area, config.visible)
        set_expand!(area, true)

        # quote from https://github.com/JuliaGtk/Gtk4Makie.jl/blob/main/src/screen.jl#L342
        shader_cache = GLAbstraction.ShaderCache(area)
        ShaderAbstractions.switch_context!(area)
        fb = GLMakie.GLFramebuffer((1, 1)) # resized on GLMakieArea realization later

        postprocessors = [
            config.ssao ? ssao_postprocessor(fb, shader_cache) : empty_postprocessor(),
            OIT_postprocessor(fb, shader_cache),
            config.fxaa ? fxaa_postprocessor(fb, shader_cache) : empty_postprocessor(),
            to_screen_postprocessor(fb, shader_cache, area.framebuffer_id)
        ]

        screen = GLMakie.Screen(
            area, shader_cache, fb,
            config, false,
            nothing,
            Dict{WeakRef, GLMakie.ScreenID}(),
            GLMakie.ScreenArea[],
            Tuple{GLMakie.ZIndex, GLMakie.ScreenID, GLMakie.RenderObject}[],
            postprocessors,
            Dict{UInt64, GLMakie.RenderObject}(),
            Dict{UInt32, Makie.AbstractPlot}(),
            false,
        )
        # end quote

        hash = Base.hash(area.glarea)
        screens[hash] = screen
        
        set_tick_callback!(area.glarea) do clock::FrameClock
            if GLMakie.requires_update(screen)
                queue_render(area.glarea)
            end

            if GLMakie.was_destroyed(area)
                return TICK_CALLBACK_RESULT_DISCONTINUE
            else
                return TICK_CALLBACK_RESULT_CONTINUE
            end
        end
        return screen
    end
end

# test
using Mousetrap, .MousetrapMakie, GLMakie
main() do app::Application
    window = Window(app)
    set_title!(window, "Mousetrap x Makie")
    canvas = GLMakieArea()
    set_size_request!(canvas, Vector2f(200, 200))
    set_child!(window, canvas)

    # use optional ref to delay screen allocation after `realize`
    screen = Ref{Union{Nothing, GLMakie.Screen{GLMakieArea}}}(nothing)
    connect_signal_realize!(canvas) do self
        screen[] = create_glmakie_screen(canvas)
        display(screen[], scatter(rand(123)))
        return nothing
    end
    present!(window)
end