quote
$(Expr(:toplevel, quote
    function ContentFormatsBuilder_new()
        ret = ccall(("gdk_content_formats_builder_new", libgtk4), Ptr{GdkContentFormatsBuilder}, ())
        ret2 = convert(GdkContentFormatsBuilder, ret, true)
        ret2
    end
    function add_formats(instance::GdkContentFormatsBuilder, _formats::GdkContentFormats)
        ret = ccall(("gdk_content_formats_builder_add_formats", libgtk4), Nothing, (Ptr{GdkContentFormatsBuilder}, Ptr{GdkContentFormats}), instance, _formats)
        nothing
    end
    function add_gtype(instance::GdkContentFormatsBuilder, _type::Integer)
        ret = ccall(("gdk_content_formats_builder_add_gtype", libgtk4), Nothing, (Ptr{GdkContentFormatsBuilder}, UInt64), instance, _type)
        nothing
    end
    function add_mime_type(instance::GdkContentFormatsBuilder, _mime_type::Union{AbstractString, Symbol})
        ret = ccall(("gdk_content_formats_builder_add_mime_type", libgtk4), Nothing, (Ptr{GdkContentFormatsBuilder}, Cstring), instance, _mime_type)
        nothing
    end
    function ref(instance::GdkContentFormatsBuilder)
        ret = ccall(("gdk_content_formats_builder_ref", libgtk4), Ptr{GdkContentFormatsBuilder}, (Ptr{GdkContentFormatsBuilder},), instance)
        ret2 = convert(GdkContentFormatsBuilder, ret, false)
        ret2
    end
    function to_formats(instance::GdkContentFormatsBuilder)
        ret = ccall(("gdk_content_formats_builder_to_formats", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormatsBuilder},), instance)
        ret2 = convert(GdkContentFormats, ret, true)
        ret2
    end
    function unref(instance::GdkContentFormatsBuilder)
        ret = ccall(("gdk_content_formats_builder_unref", libgtk4), Nothing, (Ptr{GdkContentFormatsBuilder},), instance)
        nothing
    end
    function get_complete(instance::GdkFrameTimings)
        ret = ccall(("gdk_frame_timings_get_complete", libgtk4), Cint, (Ptr{GdkFrameTimings},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_frame_counter(instance::GdkFrameTimings)
        ret = ccall(("gdk_frame_timings_get_frame_counter", libgtk4), Int64, (Ptr{GdkFrameTimings},), instance)
        ret
    end
    function get_frame_time(instance::GdkFrameTimings)
        ret = ccall(("gdk_frame_timings_get_frame_time", libgtk4), Int64, (Ptr{GdkFrameTimings},), instance)
        ret
    end
    function get_predicted_presentation_time(instance::GdkFrameTimings)
        ret = ccall(("gdk_frame_timings_get_predicted_presentation_time", libgtk4), Int64, (Ptr{GdkFrameTimings},), instance)
        ret
    end
    function get_presentation_time(instance::GdkFrameTimings)
        ret = ccall(("gdk_frame_timings_get_presentation_time", libgtk4), Int64, (Ptr{GdkFrameTimings},), instance)
        ret
    end
    function get_refresh_interval(instance::GdkFrameTimings)
        ret = ccall(("gdk_frame_timings_get_refresh_interval", libgtk4), Int64, (Ptr{GdkFrameTimings},), instance)
        ret
    end
    function ref(instance::GdkFrameTimings)
        ret = ccall(("gdk_frame_timings_ref", libgtk4), Ptr{GdkFrameTimings}, (Ptr{GdkFrameTimings},), instance)
        ret2 = convert(GdkFrameTimings, ret, true)
        ret2
    end
    function unref(instance::GdkFrameTimings)
        ret = ccall(("gdk_frame_timings_unref", libgtk4), Nothing, (Ptr{GdkFrameTimings},), instance)
        nothing
    end
    function PopupLayout_new(_anchor_rect::Union{GdkRectangle, Ref{_GdkRectangle}}, _rect_anchor, _surface_anchor)
        ret = ccall(("gdk_popup_layout_new", libgtk4), Ptr{GdkPopupLayout}, (Ptr{_GdkRectangle}, UInt32, UInt32), _anchor_rect, _rect_anchor, _surface_anchor)
        ret2 = convert(GdkPopupLayout, ret, true)
        ret2
    end
    function copy(instance::GdkPopupLayout)
        ret = ccall(("gdk_popup_layout_copy", libgtk4), Ptr{GdkPopupLayout}, (Ptr{GdkPopupLayout},), instance)
        ret2 = convert(GdkPopupLayout, ret, true)
        ret2
    end
    function equal(instance::GdkPopupLayout, _other::GdkPopupLayout)
        ret = ccall(("gdk_popup_layout_equal", libgtk4), Cint, (Ptr{GdkPopupLayout}, Ptr{GdkPopupLayout}), instance, _other)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_anchor_hints(instance::GdkPopupLayout)
        ret = ccall(("gdk_popup_layout_get_anchor_hints", libgtk4), UInt32, (Ptr{GdkPopupLayout},), instance)
        ret2 = AnchorHints(ret)
        ret2
    end
    function get_anchor_rect(instance::GdkPopupLayout)
        ret = ccall(("gdk_popup_layout_get_anchor_rect", libgtk4), Ptr{_GdkRectangle}, (Ptr{GdkPopupLayout},), instance)
        ret2 = convert(Union{GdkRectangle, Ref{_GdkRectangle}}, ret, false)
        ret2
    end
    function get_offset(instance::GdkPopupLayout)
        m_dx = Ref{Int32}()
        m_dy = Ref{Int32}()
        ret = ccall(("gdk_popup_layout_get_offset", libgtk4), Nothing, (Ptr{GdkPopupLayout}, Ptr{Int32}, Ptr{Int32}), instance, m_dx, m_dy)
        _dx = m_dx[]
        _dy = m_dy[]
        (_dx, _dy)
    end
    function get_rect_anchor(instance::GdkPopupLayout)
        ret = ccall(("gdk_popup_layout_get_rect_anchor", libgtk4), UInt32, (Ptr{GdkPopupLayout},), instance)
        ret2 = Gravity(ret)
        ret2
    end
    function get_shadow_width(instance::GdkPopupLayout)
        m_left = Ref{Int32}()
        m_right = Ref{Int32}()
        m_top = Ref{Int32}()
        m_bottom = Ref{Int32}()
        ret = ccall(("gdk_popup_layout_get_shadow_width", libgtk4), Nothing, (Ptr{GdkPopupLayout}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}), instance, m_left, m_right, m_top, m_bottom)
        _left = m_left[]
        _right = m_right[]
        _top = m_top[]
        _bottom = m_bottom[]
        (_left, _right, _top, _bottom)
    end
    function get_surface_anchor(instance::GdkPopupLayout)
        ret = ccall(("gdk_popup_layout_get_surface_anchor", libgtk4), UInt32, (Ptr{GdkPopupLayout},), instance)
        ret2 = Gravity(ret)
        ret2
    end
    function ref(instance::GdkPopupLayout)
        ret = ccall(("gdk_popup_layout_ref", libgtk4), Ptr{GdkPopupLayout}, (Ptr{GdkPopupLayout},), instance)
        ret2 = convert(GdkPopupLayout, ret, true)
        ret2
    end
    function set_anchor_hints(instance::GdkPopupLayout, _anchor_hints)
        ret = ccall(("gdk_popup_layout_set_anchor_hints", libgtk4), Nothing, (Ptr{GdkPopupLayout}, UInt32), instance, _anchor_hints)
        nothing
    end
    function set_anchor_rect(instance::GdkPopupLayout, _anchor_rect::Union{GdkRectangle, Ref{_GdkRectangle}})
        ret = ccall(("gdk_popup_layout_set_anchor_rect", libgtk4), Nothing, (Ptr{GdkPopupLayout}, Ptr{_GdkRectangle}), instance, _anchor_rect)
        nothing
    end
    function set_offset(instance::GdkPopupLayout, _dx::Integer, _dy::Integer)
        ret = ccall(("gdk_popup_layout_set_offset", libgtk4), Nothing, (Ptr{GdkPopupLayout}, Int32, Int32), instance, _dx, _dy)
        nothing
    end
    function set_rect_anchor(instance::GdkPopupLayout, _anchor)
        ret = ccall(("gdk_popup_layout_set_rect_anchor", libgtk4), Nothing, (Ptr{GdkPopupLayout}, UInt32), instance, _anchor)
        nothing
    end
    function set_shadow_width(instance::GdkPopupLayout, _left::Integer, _right::Integer, _top::Integer, _bottom::Integer)
        ret = ccall(("gdk_popup_layout_set_shadow_width", libgtk4), Nothing, (Ptr{GdkPopupLayout}, Int32, Int32, Int32, Int32), instance, _left, _right, _top, _bottom)
        nothing
    end
    function set_surface_anchor(instance::GdkPopupLayout, _anchor)
        ret = ccall(("gdk_popup_layout_set_surface_anchor", libgtk4), Nothing, (Ptr{GdkPopupLayout}, UInt32), instance, _anchor)
        nothing
    end
    function unref(instance::GdkPopupLayout)
        ret = ccall(("gdk_popup_layout_unref", libgtk4), Nothing, (Ptr{GdkPopupLayout},), instance)
        nothing
    end
    function copy(instance::GdkRGBA)
        ret = ccall(("gdk_rgba_copy", libgtk4), Ptr{_GdkRGBA}, (Ptr{_GdkRGBA},), instance)
        ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, true)
        ret2
    end
    function equal(instance::GdkRGBA, _p2::Union{GdkRGBA, Ref{_GdkRGBA}})
        ret = ccall(("gdk_rgba_equal", libgtk4), Cint, (Ptr{_GdkRGBA}, Ptr{_GdkRGBA}), instance, _p2)
        ret2 = convert(Bool, ret)
        ret2
    end
    function free(instance::GdkRGBA)
        ret = ccall(("gdk_rgba_free", libgtk4), Nothing, (Ptr{_GdkRGBA},), instance)
        nothing
    end
    function hash(instance::GdkRGBA)
        ret = ccall(("gdk_rgba_hash", libgtk4), UInt32, (Ptr{_GdkRGBA},), instance)
        ret
    end
    function is_clear(instance::GdkRGBA)
        ret = ccall(("gdk_rgba_is_clear", libgtk4), Cint, (Ptr{_GdkRGBA},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_opaque(instance::GdkRGBA)
        ret = ccall(("gdk_rgba_is_opaque", libgtk4), Cint, (Ptr{_GdkRGBA},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function parse(instance::GdkRGBA, _spec::Union{AbstractString, Symbol})
        ret = ccall(("gdk_rgba_parse", libgtk4), Cint, (Ptr{_GdkRGBA}, Cstring), instance, _spec)
        ret2 = convert(Bool, ret)
        ret2
    end
    function to_string(instance::GdkRGBA)
        ret = ccall(("gdk_rgba_to_string", libgtk4), Cstring, (Ptr{_GdkRGBA},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, true)
            end
        ret2
    end
    function contains_point(instance::GdkRectangle, _x::Integer, _y::Integer)
        ret = ccall(("gdk_rectangle_contains_point", libgtk4), Cint, (Ptr{_GdkRectangle}, Int32, Int32), instance, _x, _y)
        ret2 = convert(Bool, ret)
        ret2
    end
    function equal(instance::GdkRectangle, _rect2::Union{GdkRectangle, Ref{_GdkRectangle}})
        ret = ccall(("gdk_rectangle_equal", libgtk4), Cint, (Ptr{_GdkRectangle}, Ptr{_GdkRectangle}), instance, _rect2)
        ret2 = convert(Bool, ret)
        ret2
    end
    function intersect(instance::GdkRectangle, _src2::Union{GdkRectangle, Ref{_GdkRectangle}})
        m_dest = Ref{_GdkRectangle}()
        ret = ccall(("gdk_rectangle_intersect", libgtk4), Cint, (Ptr{_GdkRectangle}, Ptr{_GdkRectangle}, Ptr{_GdkRectangle}), instance, _src2, m_dest)
        ret2 = convert(Bool, ret)
        _dest = m_dest[]
        (ret2, _dest)
    end
    function union(instance::GdkRectangle, _src2::Union{GdkRectangle, Ref{_GdkRectangle}})
        m_dest = Ref{_GdkRectangle}()
        ret = ccall(("gdk_rectangle_union", libgtk4), Nothing, (Ptr{_GdkRectangle}, Ptr{_GdkRectangle}, Ptr{_GdkRectangle}), instance, _src2, m_dest)
        _dest = m_dest[]
        _dest
    end
    function ToplevelLayout_new()
        ret = ccall(("gdk_toplevel_layout_new", libgtk4), Ptr{GdkToplevelLayout}, ())
        ret2 = convert(GdkToplevelLayout, ret, true)
        ret2
    end
    function copy(instance::GdkToplevelLayout)
        ret = ccall(("gdk_toplevel_layout_copy", libgtk4), Ptr{GdkToplevelLayout}, (Ptr{GdkToplevelLayout},), instance)
        ret2 = convert(GdkToplevelLayout, ret, true)
        ret2
    end
    function equal(instance::GdkToplevelLayout, _other::GdkToplevelLayout)
        ret = ccall(("gdk_toplevel_layout_equal", libgtk4), Cint, (Ptr{GdkToplevelLayout}, Ptr{GdkToplevelLayout}), instance, _other)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_fullscreen(instance::GdkToplevelLayout)
        m_fullscreen = Ref{Cint}()
        ret = ccall(("gdk_toplevel_layout_get_fullscreen", libgtk4), Cint, (Ptr{GdkToplevelLayout}, Ptr{Cint}), instance, m_fullscreen)
        ret2 = convert(Bool, ret)
        _fullscreen = m_fullscreen[]
        _fullscreen = convert(Bool, _fullscreen)
        (ret2, _fullscreen)
    end
    function get_fullscreen_monitor(instance::GdkToplevelLayout)
        ret = ccall(("gdk_toplevel_layout_get_fullscreen_monitor", libgtk4), Ptr{GObject}, (Ptr{GdkToplevelLayout},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkMonitor, ret, false)
            end
        ret2
    end
    function get_maximized(instance::GdkToplevelLayout)
        m_maximized = Ref{Cint}()
        ret = ccall(("gdk_toplevel_layout_get_maximized", libgtk4), Cint, (Ptr{GdkToplevelLayout}, Ptr{Cint}), instance, m_maximized)
        ret2 = convert(Bool, ret)
        _maximized = m_maximized[]
        _maximized = convert(Bool, _maximized)
        (ret2, _maximized)
    end
    function get_resizable(instance::GdkToplevelLayout)
        ret = ccall(("gdk_toplevel_layout_get_resizable", libgtk4), Cint, (Ptr{GdkToplevelLayout},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function ref(instance::GdkToplevelLayout)
        ret = ccall(("gdk_toplevel_layout_ref", libgtk4), Ptr{GdkToplevelLayout}, (Ptr{GdkToplevelLayout},), instance)
        ret2 = convert(GdkToplevelLayout, ret, true)
        ret2
    end
    function set_fullscreen(instance::GdkToplevelLayout, _fullscreen::Bool, _monitor::Maybe(GdkMonitor))
        _monitor = if _monitor == nothing
                C_NULL
            else
                _monitor
            end
        ret = ccall(("gdk_toplevel_layout_set_fullscreen", libgtk4), Nothing, (Ptr{GdkToplevelLayout}, Cint, Ptr{GObject}), instance, _fullscreen, _monitor)
        nothing
    end
    function set_maximized(instance::GdkToplevelLayout, _maximized::Bool)
        ret = ccall(("gdk_toplevel_layout_set_maximized", libgtk4), Nothing, (Ptr{GdkToplevelLayout}, Cint), instance, _maximized)
        nothing
    end
    function set_resizable(instance::GdkToplevelLayout, _resizable::Bool)
        ret = ccall(("gdk_toplevel_layout_set_resizable", libgtk4), Nothing, (Ptr{GdkToplevelLayout}, Cint), instance, _resizable)
        nothing
    end
    function unref(instance::GdkToplevelLayout)
        ret = ccall(("gdk_toplevel_layout_unref", libgtk4), Nothing, (Ptr{GdkToplevelLayout},), instance)
        nothing
    end
    function get_display(instance::GdkAppLaunchContext)
        ret = ccall(("gdk_app_launch_context_get_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDisplay, ret, false)
        ret2
    end
    function set_desktop(instance::GdkAppLaunchContext, _desktop::Integer)
        ret = ccall(("gdk_app_launch_context_set_desktop", libgtk4), Nothing, (Ptr{GObject}, Int32), instance, _desktop)
        nothing
    end
    function set_icon(instance::GdkAppLaunchContext, _icon::Maybe(GIcon))
        _icon = if _icon == nothing
                C_NULL
            else
                _icon
            end
        ret = ccall(("gdk_app_launch_context_set_icon", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _icon)
        nothing
    end
    function set_icon_name(instance::GdkAppLaunchContext, _icon_name::Maybe(Union{AbstractString, Symbol}))
        _icon_name = if _icon_name == nothing
                C_NULL
            else
                _icon_name
            end
        ret = ccall(("gdk_app_launch_context_set_icon_name", libgtk4), Nothing, (Ptr{GObject}, Cstring), instance, _icon_name)
        nothing
    end
    function set_timestamp(instance::GdkAppLaunchContext, _timestamp::Integer)
        ret = ccall(("gdk_app_launch_context_set_timestamp", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _timestamp)
        nothing
    end
    function get_button(instance::GdkButtonEvent)
        ret = ccall(("gdk_button_event_get_button", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret
    end
    function cairo_create(instance::GdkCairoContext)
        ret = ccall(("gdk_cairo_context_cairo_create", libgtk4), Ptr{cairoContext}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(cairoContext, ret, true)
            end
        ret2
    end
    function get_content(instance::GdkClipboard)
        ret = ccall(("gdk_clipboard_get_content", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkContentProvider, ret, false)
            end
        ret2
    end
    function get_display(instance::GdkClipboard)
        ret = ccall(("gdk_clipboard_get_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDisplay, ret, false)
        ret2
    end
    function get_formats(instance::GdkClipboard)
        ret = ccall(("gdk_clipboard_get_formats", libgtk4), Ptr{GdkContentFormats}, (Ptr{GObject},), instance)
        ret2 = convert(GdkContentFormats, ret, false)
        ret2
    end
    function is_local(instance::GdkClipboard)
        ret = ccall(("gdk_clipboard_is_local", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function read_async(instance::GdkClipboard, _mime_types, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function), _user_data::Maybe(Nothing))
        _cancellable = if _cancellable == nothing
                C_NULL
            else
                _cancellable
            end
        _callback = if _callback == nothing
                C_NULL
            else
                _callback
            end
        _user_data = if _user_data == nothing
                C_NULL
            else
                _user_data
            end
        ret = ccall(("gdk_clipboard_read_async", libgtk4), Nothing, (Ptr{GObject}, Ptr{Cstring}, Int32, Ptr{GObject}, Ptr{Nothing}, Ptr{Nothing}), instance, _mime_types, _io_priority, _cancellable, _callback, _user_data)
        nothing
    end
    function read_finish(instance::GdkClipboard, _result::GAsyncResult)
        m_out_mime_type = Ref{Cstring}()
        err = err_buf()
        ret = ccall(("gdk_clipboard_read_finish", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _result, m_out_mime_type, err)
        check_err(err)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GInputStream, ret, true)
            end
        _out_mime_type = m_out_mime_type[]
        _out_mime_type = if _out_mime_type == C_NULL
                nothing
            else
                bytestring(_out_mime_type, false)
            end
        (ret2, _out_mime_type)
    end
    function read_text_async(instance::GdkClipboard, _cancellable::Maybe(GCancellable), _callback::Maybe(Function), _user_data::Maybe(Nothing))
        _cancellable = if _cancellable == nothing
                C_NULL
            else
                _cancellable
            end
        _callback = if _callback == nothing
                C_NULL
            else
                _callback
            end
        _user_data = if _user_data == nothing
                C_NULL
            else
                _user_data
            end
        ret = ccall(("gdk_clipboard_read_text_async", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Nothing}, Ptr{Nothing}), instance, _cancellable, _callback, _user_data)
        nothing
    end
    function read_text_finish(instance::GdkClipboard, _result::GAsyncResult)
        err = err_buf()
        ret = ccall(("gdk_clipboard_read_text_finish", libgtk4), Cstring, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
        check_err(err)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, true)
            end
        ret2
    end
    function read_texture_async(instance::GdkClipboard, _cancellable::Maybe(GCancellable), _callback::Maybe(Function), _user_data::Maybe(Nothing))
        _cancellable = if _cancellable == nothing
                C_NULL
            else
                _cancellable
            end
        _callback = if _callback == nothing
                C_NULL
            else
                _callback
            end
        _user_data = if _user_data == nothing
                C_NULL
            else
                _user_data
            end
        ret = ccall(("gdk_clipboard_read_texture_async", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Nothing}, Ptr{Nothing}), instance, _cancellable, _callback, _user_data)
        nothing
    end
    function read_texture_finish(instance::GdkClipboard, _result::GAsyncResult)
        err = err_buf()
        ret = ccall(("gdk_clipboard_read_texture_finish", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
        check_err(err)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkTexture, ret, true)
            end
        ret2
    end
    function read_value_async(instance::GdkClipboard, _type::Integer, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function), _user_data::Maybe(Nothing))
        _cancellable = if _cancellable == nothing
                C_NULL
            else
                _cancellable
            end
        _callback = if _callback == nothing
                C_NULL
            else
                _callback
            end
        _user_data = if _user_data == nothing
                C_NULL
            else
                _user_data
            end
        ret = ccall(("gdk_clipboard_read_value_async", libgtk4), Nothing, (Ptr{GObject}, UInt64, Int32, Ptr{GObject}, Ptr{Nothing}, Ptr{Nothing}), instance, _type, _io_priority, _cancellable, _callback, _user_data)
        nothing
    end
    function read_value_finish(instance::GdkClipboard, _result::GAsyncResult)
        err = err_buf()
        ret = ccall(("gdk_clipboard_read_value_finish", libgtk4), Ptr{_GValue}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
        check_err(err)
        ret2 = convert(Union{GValue, Ref{_GValue}}, ret, false)
        ret2
    end
    function set_content(instance::GdkClipboard, _provider::Maybe(GdkContentProvider))
        _provider = if _provider == nothing
                C_NULL
            else
                _provider
            end
        ret = ccall(("gdk_clipboard_set_content", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _provider)
        ret2 = convert(Bool, ret)
        ret2
    end
    function set(instance::GdkClipboard, _value::Union{GValue, Ref{_GValue}})
        ret = ccall(("gdk_clipboard_set_value", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GValue}), instance, _value)
        nothing
    end
    function store_async(instance::GdkClipboard, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function), _user_data::Maybe(Nothing))
        _cancellable = if _cancellable == nothing
                C_NULL
            else
                _cancellable
            end
        _callback = if _callback == nothing
                C_NULL
            else
                _callback
            end
        _user_data = if _user_data == nothing
                C_NULL
            else
                _user_data
            end
        ret = ccall(("gdk_clipboard_store_async", libgtk4), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Nothing}, Ptr{Nothing}), instance, _io_priority, _cancellable, _callback, _user_data)
        nothing
    end
    function store_finish(instance::GdkClipboard, _result::GAsyncResult)
        err = err_buf()
        ret = ccall(("gdk_clipboard_store_finish", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_cancellable(instance::GdkContentDeserializer)
        ret = ccall(("gdk_content_deserializer_get_cancellable", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GCancellable, ret, false)
        ret2
    end
    function get_gtype(instance::GdkContentDeserializer)
        ret = ccall(("gdk_content_deserializer_get_gtype", libgtk4), UInt64, (Ptr{GObject},), instance)
        ret
    end
    function get_input_stream(instance::GdkContentDeserializer)
        ret = ccall(("gdk_content_deserializer_get_input_stream", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GInputStream, ret, false)
        ret2
    end
    function get_mime_type(instance::GdkContentDeserializer)
        ret = ccall(("gdk_content_deserializer_get_mime_type", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, false)
            end
        ret2
    end
    function get_priority(instance::GdkContentDeserializer)
        ret = ccall(("gdk_content_deserializer_get_priority", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_task_data(instance::GdkContentDeserializer)
        ret = ccall(("gdk_content_deserializer_get_task_data", libgtk4), Ptr{Nothing}, (Ptr{GObject},), instance)
        ret2 = convert(Nothing, ret)
        ret2
    end
    function get_user_data(instance::GdkContentDeserializer)
        ret = ccall(("gdk_content_deserializer_get_user_data", libgtk4), Ptr{Nothing}, (Ptr{GObject},), instance)
        ret2 = convert(Nothing, ret)
        ret2
    end
    function get_value(instance::GdkContentDeserializer)
        ret = ccall(("gdk_content_deserializer_get_value", libgtk4), Ptr{_GValue}, (Ptr{GObject},), instance)
        ret2 = convert(Union{GValue, Ref{_GValue}}, ret, false)
        ret2
    end
    function return_error(instance::GdkContentDeserializer, _error)
        ret = ccall(("gdk_content_deserializer_return_error", libgtk4), Nothing, (Ptr{GObject}, Ptr{GError}), instance, _error)
        nothing
    end
    function return_success(instance::GdkContentDeserializer)
        ret = ccall(("gdk_content_deserializer_return_success", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function ContentProvider_new_for_bytes(_mime_type::Union{AbstractString, Symbol}, _bytes::GBytes)
        ret = ccall(("gdk_content_provider_new_for_bytes", libgtk4), Ptr{GObject}, (Cstring, Ptr{GBytes}), _mime_type, _bytes)
        ret2 = convert(GdkContentProvider, ret, true)
        ret2
    end
    function ContentProvider_new_for_value(_value::Union{GValue, Ref{_GValue}})
        ret = ccall(("gdk_content_provider_new_for_value", libgtk4), Ptr{GObject}, (Ptr{_GValue},), _value)
        ret2 = convert(GdkContentProvider, ret, true)
        ret2
    end
    function ContentProvider_new_union(_providers)
        _providers = convert(Vector{Ptr{GObject}}, _providers)
        _n_providers = length(_providers)
        ret = ccall(("gdk_content_provider_new_union", libgtk4), Ptr{GObject}, (Ptr{Ptr{GObject}}, UInt64), _providers, _n_providers)
        ret2 = convert(GdkContentProvider, ret, true)
        ret2
    end
    function content_changed(instance::GdkContentProvider)
        ret = ccall(("gdk_content_provider_content_changed", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function get_value(instance::GdkContentProvider, _value::Union{GValue, Ref{_GValue}})
        err = err_buf()
        ret = ccall(("gdk_content_provider_get_value", libgtk4), Cint, (Ptr{GObject}, Ptr{_GValue}, Ptr{Ptr{GError}}), instance, _value, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function ref_formats(instance::GdkContentProvider)
        ret = ccall(("gdk_content_provider_ref_formats", libgtk4), Ptr{GdkContentFormats}, (Ptr{GObject},), instance)
        ret2 = convert(GdkContentFormats, ret, true)
        ret2
    end
    function ref_storable_formats(instance::GdkContentProvider)
        ret = ccall(("gdk_content_provider_ref_storable_formats", libgtk4), Ptr{GdkContentFormats}, (Ptr{GObject},), instance)
        ret2 = convert(GdkContentFormats, ret, true)
        ret2
    end
    function write_mime_type_async(instance::GdkContentProvider, _mime_type::Union{AbstractString, Symbol}, _stream::GOutputStream, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function), _user_data::Maybe(Nothing))
        _cancellable = if _cancellable == nothing
                C_NULL
            else
                _cancellable
            end
        _callback = if _callback == nothing
                C_NULL
            else
                _callback
            end
        _user_data = if _user_data == nothing
                C_NULL
            else
                _user_data
            end
        ret = ccall(("gdk_content_provider_write_mime_type_async", libgtk4), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Nothing}, Ptr{Nothing}), instance, _mime_type, _stream, _io_priority, _cancellable, _callback, _user_data)
        nothing
    end
    function write_mime_type_finish(instance::GdkContentProvider, _result::GAsyncResult)
        err = err_buf()
        ret = ccall(("gdk_content_provider_write_mime_type_finish", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_cancellable(instance::GdkContentSerializer)
        ret = ccall(("gdk_content_serializer_get_cancellable", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GCancellable, ret, false)
        ret2
    end
    function get_gtype(instance::GdkContentSerializer)
        ret = ccall(("gdk_content_serializer_get_gtype", libgtk4), UInt64, (Ptr{GObject},), instance)
        ret
    end
    function get_mime_type(instance::GdkContentSerializer)
        ret = ccall(("gdk_content_serializer_get_mime_type", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, false)
            end
        ret2
    end
    function get_output_stream(instance::GdkContentSerializer)
        ret = ccall(("gdk_content_serializer_get_output_stream", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GOutputStream, ret, false)
        ret2
    end
    function get_priority(instance::GdkContentSerializer)
        ret = ccall(("gdk_content_serializer_get_priority", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_task_data(instance::GdkContentSerializer)
        ret = ccall(("gdk_content_serializer_get_task_data", libgtk4), Ptr{Nothing}, (Ptr{GObject},), instance)
        ret2 = convert(Nothing, ret)
        ret2
    end
    function get_user_data(instance::GdkContentSerializer)
        ret = ccall(("gdk_content_serializer_get_user_data", libgtk4), Ptr{Nothing}, (Ptr{GObject},), instance)
        ret2 = convert(Nothing, ret)
        ret2
    end
    function get_value(instance::GdkContentSerializer)
        ret = ccall(("gdk_content_serializer_get_value", libgtk4), Ptr{_GValue}, (Ptr{GObject},), instance)
        ret2 = convert(Union{GValue, Ref{_GValue}}, ret, false)
        ret2
    end
    function return_error(instance::GdkContentSerializer, _error)
        ret = ccall(("gdk_content_serializer_return_error", libgtk4), Nothing, (Ptr{GObject}, Ptr{GError}), instance, _error)
        nothing
    end
    function return_success(instance::GdkContentSerializer)
        ret = ccall(("gdk_content_serializer_return_success", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function get_detail(instance::GdkCrossingEvent)
        ret = ccall(("gdk_crossing_event_get_detail", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret2 = NotifyType(ret)
        ret2
    end
    function get_focus(instance::GdkCrossingEvent)
        ret = ccall(("gdk_crossing_event_get_focus", libgtk4), Cint, (Ptr{GdkEvent},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_mode(instance::GdkCrossingEvent)
        ret = ccall(("gdk_crossing_event_get_mode", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret2 = CrossingMode(ret)
        ret2
    end
    function Cursor_new_from_name(_name::Union{AbstractString, Symbol}, _fallback::Maybe(GdkCursor))
        _fallback = if _fallback == nothing
                C_NULL
            else
                _fallback
            end
        ret = ccall(("gdk_cursor_new_from_name", libgtk4), Ptr{GObject}, (Cstring, Ptr{GObject}), _name, _fallback)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkCursor, ret, true)
            end
        ret2
    end
    function Cursor_new_from_texture(_texture::GdkTexture, _hotspot_x::Integer, _hotspot_y::Integer, _fallback::Maybe(GdkCursor))
        _fallback = if _fallback == nothing
                C_NULL
            else
                _fallback
            end
        ret = ccall(("gdk_cursor_new_from_texture", libgtk4), Ptr{GObject}, (Ptr{GObject}, Int32, Int32, Ptr{GObject}), _texture, _hotspot_x, _hotspot_y, _fallback)
        ret2 = convert(GdkCursor, ret, true)
        ret2
    end
    function get_fallback(instance::GdkCursor)
        ret = ccall(("gdk_cursor_get_fallback", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkCursor, ret, false)
            end
        ret2
    end
    function get_hotspot_x(instance::GdkCursor)
        ret = ccall(("gdk_cursor_get_hotspot_x", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_hotspot_y(instance::GdkCursor)
        ret = ccall(("gdk_cursor_get_hotspot_y", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_name(instance::GdkCursor)
        ret = ccall(("gdk_cursor_get_name", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, false)
            end
        ret2
    end
    function get_texture(instance::GdkCursor)
        ret = ccall(("gdk_cursor_get_texture", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkTexture, ret, false)
            end
        ret2
    end
    function get_drop(instance::GdkDNDEvent)
        ret = ccall(("gdk_dnd_event_get_drop", libgtk4), Ptr{GObject}, (Ptr{GdkEvent},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDrop, ret, false)
            end
        ret2
    end
    function get_caps_lock_state(instance::GdkDevice)
        ret = ccall(("gdk_device_get_caps_lock_state", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_device_tool(instance::GdkDevice)
        ret = ccall(("gdk_device_get_device_tool", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDeviceTool, ret, false)
        ret2
    end
    function get_direction(instance::GdkDevice)
        ret = ccall(("gdk_device_get_direction", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = Direction(ret)
        ret2
    end
    function get_display(instance::GdkDevice)
        ret = ccall(("gdk_device_get_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDisplay, ret, false)
        ret2
    end
    function get_has_cursor(instance::GdkDevice)
        ret = ccall(("gdk_device_get_has_cursor", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_modifier_state(instance::GdkDevice)
        ret = ccall(("gdk_device_get_modifier_state", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = ModifierType(ret)
        ret2
    end
    function get_name(instance::GdkDevice)
        ret = ccall(("gdk_device_get_name", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, false)
            end
        ret2
    end
    function get_num_lock_state(instance::GdkDevice)
        ret = ccall(("gdk_device_get_num_lock_state", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_num_touches(instance::GdkDevice)
        ret = ccall(("gdk_device_get_num_touches", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret
    end
    function get_product_id(instance::GdkDevice)
        ret = ccall(("gdk_device_get_product_id", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, false)
            end
        ret2
    end
    function get_scroll_lock_state(instance::GdkDevice)
        ret = ccall(("gdk_device_get_scroll_lock_state", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_seat(instance::GdkDevice)
        ret = ccall(("gdk_device_get_seat", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkSeat, ret, false)
        ret2
    end
    function get_source(instance::GdkDevice)
        ret = ccall(("gdk_device_get_source", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = InputSource(ret)
        ret2
    end
    function get_surface_at_position(instance::GdkDevice)
        m_win_x = Ref{Float64}()
        m_win_y = Ref{Float64}()
        ret = ccall(("gdk_device_get_surface_at_position", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{Float64}, Ptr{Float64}), instance, m_win_x, m_win_y)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkSurface, ret, false)
            end
        _win_x = m_win_x[]
        _win_y = m_win_y[]
        (ret2, _win_x, _win_y)
    end
    function get_timestamp(instance::GdkDevice)
        ret = ccall(("gdk_device_get_timestamp", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret
    end
    function get_vendor_id(instance::GdkDevice)
        ret = ccall(("gdk_device_get_vendor_id", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, false)
            end
        ret2
    end
    function has_bidi_layouts(instance::GdkDevice)
        ret = ccall(("gdk_device_has_bidi_layouts", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_axes(instance::GdkDeviceTool)
        ret = ccall(("gdk_device_tool_get_axes", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = AxisFlags(ret)
        ret2
    end
    function get_hardware_id(instance::GdkDeviceTool)
        ret = ccall(("gdk_device_tool_get_hardware_id", libgtk4), UInt64, (Ptr{GObject},), instance)
        ret
    end
    function get_serial(instance::GdkDeviceTool)
        ret = ccall(("gdk_device_tool_get_serial", libgtk4), UInt64, (Ptr{GObject},), instance)
        ret
    end
    function get_tool_type(instance::GdkDeviceTool)
        ret = ccall(("gdk_device_tool_get_tool_type", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = DeviceToolType(ret)
        ret2
    end
    function get_default()
        ret = ccall(("gdk_display_get_default", libgtk4), Ptr{GObject}, ())
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDisplay, ret, false)
            end
        ret2
    end
    function open(_display_name::Union{AbstractString, Symbol})
        ret = ccall(("gdk_display_open", libgtk4), Ptr{GObject}, (Cstring,), _display_name)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDisplay, ret, false)
            end
        ret2
    end
    function beep(instance::GdkDisplay)
        ret = ccall(("gdk_display_beep", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function close(instance::GdkDisplay)
        ret = ccall(("gdk_display_close", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function device_is_grabbed(instance::GdkDisplay, _device::GdkDevice)
        ret = ccall(("gdk_display_device_is_grabbed", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _device)
        ret2 = convert(Bool, ret)
        ret2
    end
    function flush(instance::GdkDisplay)
        ret = ccall(("gdk_display_flush", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function get_app_launch_context(instance::GdkDisplay)
        ret = ccall(("gdk_display_get_app_launch_context", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkAppLaunchContext, ret, true)
        ret2
    end
    function get_clipboard(instance::GdkDisplay)
        ret = ccall(("gdk_display_get_clipboard", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkClipboard, ret, false)
        ret2
    end
    function get_default_seat(instance::GdkDisplay)
        ret = ccall(("gdk_display_get_default_seat", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkSeat, ret, false)
            end
        ret2
    end
    function get_monitor_at_surface(instance::GdkDisplay, _surface::GdkSurface)
        ret = ccall(("gdk_display_get_monitor_at_surface", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}), instance, _surface)
        ret2 = convert(GdkMonitor, ret, false)
        ret2
    end
    function get_monitors(instance::GdkDisplay)
        ret = ccall(("gdk_display_get_monitors", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = begin
                leaftype = GLib.find_leaf_type(ret)
                convert(leaftype, ret, false)
            end
        ret2
    end
    function get_name(instance::GdkDisplay)
        ret = ccall(("gdk_display_get_name", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, false)
            end
        ret2
    end
    function get_primary_clipboard(instance::GdkDisplay)
        ret = ccall(("gdk_display_get_primary_clipboard", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkClipboard, ret, false)
        ret2
    end
    function get_setting(instance::GdkDisplay, _name::Union{AbstractString, Symbol}, _value::Union{GValue, Ref{_GValue}})
        ret = ccall(("gdk_display_get_setting", libgtk4), Cint, (Ptr{GObject}, Cstring, Ptr{_GValue}), instance, _name, _value)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_startup_notification_id(instance::GdkDisplay)
        ret = ccall(("gdk_display_get_startup_notification_id", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, false)
            end
        ret2
    end
    function is_closed(instance::GdkDisplay)
        ret = ccall(("gdk_display_is_closed", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_composited(instance::GdkDisplay)
        ret = ccall(("gdk_display_is_composited", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_rgba(instance::GdkDisplay)
        ret = ccall(("gdk_display_is_rgba", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function list_seats(instance::GdkDisplay)
        ret = ccall(("gdk_display_list_seats", libgtk4), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject},), instance)
        ret2 = GLib.GList(ret, false)
        ret2
    end
    function map_keycode(instance::GdkDisplay, _keycode::Integer)
        m_keys = Ref{Ptr{_GdkKeymapKey}}()
        m_keyvals = Ref{Ptr{UInt32}}()
        m_n_entries = Ref{Int32}()
        ret = ccall(("gdk_display_map_keycode", libgtk4), Cint, (Ptr{GObject}, UInt32, Ptr{Ptr{_GdkKeymapKey}}, Ptr{Ptr{UInt32}}, Ptr{Int32}), instance, _keycode, m_keys, m_keyvals, m_n_entries)
        ret2 = convert(Bool, ret)
        _keys = m_keys[]
        _keyvals = m_keyvals[]
        _n_entries = m_n_entries[]
        (ret2, _keys, _keyvals)
    end
    function map_keyval(instance::GdkDisplay, _keyval::Integer)
        m_keys = Ref{Ptr{_GdkKeymapKey}}()
        m_n_keys = Ref{Int32}()
        ret = ccall(("gdk_display_map_keyval", libgtk4), Cint, (Ptr{GObject}, UInt32, Ptr{Ptr{_GdkKeymapKey}}, Ptr{Int32}), instance, _keyval, m_keys, m_n_keys)
        ret2 = convert(Bool, ret)
        _keys = m_keys[]
        _n_keys = m_n_keys[]
        (ret2, _keys)
    end
    function notify_startup_complete(instance::GdkDisplay, _startup_id::Union{AbstractString, Symbol})
        ret = ccall(("gdk_display_notify_startup_complete", libgtk4), Nothing, (Ptr{GObject}, Cstring), instance, _startup_id)
        nothing
    end
    function prepare_gl(instance::GdkDisplay)
        err = err_buf()
        ret = ccall(("gdk_display_prepare_gl", libgtk4), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function supports_input_shapes(instance::GdkDisplay)
        ret = ccall(("gdk_display_supports_input_shapes", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function sync(instance::GdkDisplay)
        ret = ccall(("gdk_display_sync", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function translate_key(instance::GdkDisplay, _keycode::Integer, _state, _group::Integer)
        m_keyval = Ref{UInt32}()
        m_effective_group = Ref{Int32}()
        m_level = Ref{Int32}()
        m_consumed = Ref{UInt32}()
        ret = ccall(("gdk_display_translate_key", libgtk4), Cint, (Ptr{GObject}, UInt32, UInt32, Int32, Ptr{UInt32}, Ptr{Int32}, Ptr{Int32}, Ptr{UInt32}), instance, _keycode, _state, _group, m_keyval, m_effective_group, m_level, m_consumed)
        ret2 = convert(Bool, ret)
        _keyval = m_keyval[]
        _effective_group = m_effective_group[]
        _level = m_level[]
        _consumed = m_consumed[]
        _consumed = ModifierType(_consumed)
        (ret2, _keyval, _effective_group, _level, _consumed)
    end
    function get()
        ret = ccall(("gdk_display_manager_get", libgtk4), Ptr{GObject}, ())
        ret2 = convert(GdkDisplayManager, ret, false)
        ret2
    end
    function get_default_display(instance::GdkDisplayManager)
        ret = ccall(("gdk_display_manager_get_default_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDisplay, ret, false)
            end
        ret2
    end
    function list_displays(instance::GdkDisplayManager)
        ret = ccall(("gdk_display_manager_list_displays", libgtk4), Ptr{GLib._GSList{Ptr{GObject}}}, (Ptr{GObject},), instance)
        ret2 = GLib.GList(ret, false)
        ret2
    end
    function open_display(instance::GdkDisplayManager, _name::Union{AbstractString, Symbol})
        ret = ccall(("gdk_display_manager_open_display", libgtk4), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _name)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDisplay, ret, false)
            end
        ret2
    end
    function set_default_display(instance::GdkDisplayManager, _display::GdkDisplay)
        ret = ccall(("gdk_display_manager_set_default_display", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _display)
        nothing
    end
    function drop_done(instance::GdkDrag, _success::Bool)
        ret = ccall(("gdk_drag_drop_done", libgtk4), Nothing, (Ptr{GObject}, Cint), instance, _success)
        nothing
    end
    function get_actions(instance::GdkDrag)
        ret = ccall(("gdk_drag_get_actions", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = DragAction(ret)
        ret2
    end
    function get_content(instance::GdkDrag)
        ret = ccall(("gdk_drag_get_content", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkContentProvider, ret, false)
        ret2
    end
    function get_device(instance::GdkDrag)
        ret = ccall(("gdk_drag_get_device", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDevice, ret, false)
        ret2
    end
    function get_display(instance::GdkDrag)
        ret = ccall(("gdk_drag_get_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDisplay, ret, false)
        ret2
    end
    function get_drag_surface(instance::GdkDrag)
        ret = ccall(("gdk_drag_get_drag_surface", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkSurface, ret, false)
            end
        ret2
    end
    function get_formats(instance::GdkDrag)
        ret = ccall(("gdk_drag_get_formats", libgtk4), Ptr{GdkContentFormats}, (Ptr{GObject},), instance)
        ret2 = convert(GdkContentFormats, ret, false)
        ret2
    end
    function get_selected_action(instance::GdkDrag)
        ret = ccall(("gdk_drag_get_selected_action", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = DragAction(ret)
        ret2
    end
    function get_surface(instance::GdkDrag)
        ret = ccall(("gdk_drag_get_surface", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkSurface, ret, false)
        ret2
    end
    function set_hotspot(instance::GdkDrag, _hot_x::Integer, _hot_y::Integer)
        ret = ccall(("gdk_drag_set_hotspot", libgtk4), Nothing, (Ptr{GObject}, Int32, Int32), instance, _hot_x, _hot_y)
        nothing
    end
    function begin_frame(instance::GdkDrawContext, _region::cairoRegion)
        ret = ccall(("gdk_draw_context_begin_frame", libgtk4), Nothing, (Ptr{GObject}, Ptr{cairoRegion}), instance, _region)
        nothing
    end
    function end_frame(instance::GdkDrawContext)
        ret = ccall(("gdk_draw_context_end_frame", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function get_display(instance::GdkDrawContext)
        ret = ccall(("gdk_draw_context_get_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDisplay, ret, false)
            end
        ret2
    end
    function get_frame_region(instance::GdkDrawContext)
        ret = ccall(("gdk_draw_context_get_frame_region", libgtk4), Ptr{cairoRegion}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(cairoRegion, ret, false)
            end
        ret2
    end
    function get_surface(instance::GdkDrawContext)
        ret = ccall(("gdk_draw_context_get_surface", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkSurface, ret, false)
            end
        ret2
    end
    function is_in_frame(instance::GdkDrawContext)
        ret = ccall(("gdk_draw_context_is_in_frame", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function finish(instance::GdkDrop, _action)
        ret = ccall(("gdk_drop_finish", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _action)
        nothing
    end
    function get_actions(instance::GdkDrop)
        ret = ccall(("gdk_drop_get_actions", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = DragAction(ret)
        ret2
    end
    function get_device(instance::GdkDrop)
        ret = ccall(("gdk_drop_get_device", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDevice, ret, false)
        ret2
    end
    function get_display(instance::GdkDrop)
        ret = ccall(("gdk_drop_get_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDisplay, ret, false)
        ret2
    end
    function get_drag(instance::GdkDrop)
        ret = ccall(("gdk_drop_get_drag", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDrag, ret, false)
            end
        ret2
    end
    function get_formats(instance::GdkDrop)
        ret = ccall(("gdk_drop_get_formats", libgtk4), Ptr{GdkContentFormats}, (Ptr{GObject},), instance)
        ret2 = convert(GdkContentFormats, ret, false)
        ret2
    end
    function get_surface(instance::GdkDrop)
        ret = ccall(("gdk_drop_get_surface", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkSurface, ret, false)
        ret2
    end
    function read_async(instance::GdkDrop, _mime_types, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function), _user_data::Maybe(Nothing))
        _cancellable = if _cancellable == nothing
                C_NULL
            else
                _cancellable
            end
        _callback = if _callback == nothing
                C_NULL
            else
                _callback
            end
        _user_data = if _user_data == nothing
                C_NULL
            else
                _user_data
            end
        ret = ccall(("gdk_drop_read_async", libgtk4), Nothing, (Ptr{GObject}, Ptr{Cstring}, Int32, Ptr{GObject}, Ptr{Nothing}, Ptr{Nothing}), instance, _mime_types, _io_priority, _cancellable, _callback, _user_data)
        nothing
    end
    function read_finish(instance::GdkDrop, _result::GAsyncResult)
        m_out_mime_type = Ref{Cstring}()
        err = err_buf()
        ret = ccall(("gdk_drop_read_finish", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _result, m_out_mime_type, err)
        check_err(err)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GInputStream, ret, true)
            end
        _out_mime_type = m_out_mime_type[]
        _out_mime_type = if _out_mime_type == C_NULL
                nothing
            else
                bytestring(_out_mime_type, true)
            end
        (ret2, _out_mime_type)
    end
    function read_value_async(instance::GdkDrop, _type::Integer, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function), _user_data::Maybe(Nothing))
        _cancellable = if _cancellable == nothing
                C_NULL
            else
                _cancellable
            end
        _callback = if _callback == nothing
                C_NULL
            else
                _callback
            end
        _user_data = if _user_data == nothing
                C_NULL
            else
                _user_data
            end
        ret = ccall(("gdk_drop_read_value_async", libgtk4), Nothing, (Ptr{GObject}, UInt64, Int32, Ptr{GObject}, Ptr{Nothing}, Ptr{Nothing}), instance, _type, _io_priority, _cancellable, _callback, _user_data)
        nothing
    end
    function read_value_finish(instance::GdkDrop, _result::GAsyncResult)
        err = err_buf()
        ret = ccall(("gdk_drop_read_value_finish", libgtk4), Ptr{_GValue}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
        check_err(err)
        ret2 = convert(Union{GValue, Ref{_GValue}}, ret, false)
        ret2
    end
    function status(instance::GdkDrop, _actions, _preferred)
        ret = ccall(("gdk_drop_status", libgtk4), Nothing, (Ptr{GObject}, UInt32, UInt32), instance, _actions, _preferred)
        nothing
    end
    function _get_angle(instance::GdkEvent, _event2::GdkEvent)
        m_angle = Ref{Float64}()
        ret = ccall(("gdk_events_get_angle", libgtk4), Cint, (Ptr{GdkEvent}, Ptr{GdkEvent}, Ptr{Float64}), instance, _event2, m_angle)
        ret2 = convert(Bool, ret)
        _angle = m_angle[]
        (ret2, _angle)
    end
    function _get_center(instance::GdkEvent, _event2::GdkEvent)
        m_x = Ref{Float64}()
        m_y = Ref{Float64}()
        ret = ccall(("gdk_events_get_center", libgtk4), Cint, (Ptr{GdkEvent}, Ptr{GdkEvent}, Ptr{Float64}, Ptr{Float64}), instance, _event2, m_x, m_y)
        ret2 = convert(Bool, ret)
        _x = m_x[]
        _y = m_y[]
        (ret2, _x, _y)
    end
    function _get_distance(instance::GdkEvent, _event2::GdkEvent)
        m_distance = Ref{Float64}()
        ret = ccall(("gdk_events_get_distance", libgtk4), Cint, (Ptr{GdkEvent}, Ptr{GdkEvent}, Ptr{Float64}), instance, _event2, m_distance)
        ret2 = convert(Bool, ret)
        _distance = m_distance[]
        (ret2, _distance)
    end
    function get_axes(instance::GdkEvent)
        m_axes = Ref{Ptr{Float64}}()
        m_n_axes = Ref{UInt32}()
        ret = ccall(("gdk_event_get_axes", libgtk4), Cint, (Ptr{GdkEvent}, Ptr{Ptr{Float64}}, Ptr{UInt32}), instance, m_axes, m_n_axes)
        ret2 = convert(Bool, ret)
        _axes = m_axes[]
        _n_axes = m_n_axes[]
        (ret2, _axes)
    end
    function get_axis(instance::GdkEvent, _axis_use)
        m_value = Ref{Float64}()
        ret = ccall(("gdk_event_get_axis", libgtk4), Cint, (Ptr{GdkEvent}, UInt32, Ptr{Float64}), instance, _axis_use, m_value)
        ret2 = convert(Bool, ret)
        _value = m_value[]
        (ret2, _value)
    end
    function get_device(instance::GdkEvent)
        ret = ccall(("gdk_event_get_device", libgtk4), Ptr{GObject}, (Ptr{GdkEvent},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDevice, ret, false)
            end
        ret2
    end
    function get_device_tool(instance::GdkEvent)
        ret = ccall(("gdk_event_get_device_tool", libgtk4), Ptr{GObject}, (Ptr{GdkEvent},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDeviceTool, ret, false)
            end
        ret2
    end
    function get_display(instance::GdkEvent)
        ret = ccall(("gdk_event_get_display", libgtk4), Ptr{GObject}, (Ptr{GdkEvent},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDisplay, ret, false)
            end
        ret2
    end
    function get_event_sequence(instance::GdkEvent)
        ret = ccall(("gdk_event_get_event_sequence", libgtk4), Ptr{GdkEventSequence}, (Ptr{GdkEvent},), instance)
        ret2 = convert(GdkEventSequence, ret, false)
        ret2
    end
    function get_event_type(instance::GdkEvent)
        ret = ccall(("gdk_event_get_event_type", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret2 = EventType(ret)
        ret2
    end
    function get_history(instance::GdkEvent)
        m_out_n_coords = Ref{UInt32}()
        ret = ccall(("gdk_event_get_history", libgtk4), Ptr{_GdkTimeCoord}, (Ptr{GdkEvent}, Ptr{UInt32}), instance, m_out_n_coords)
        ret2 = begin
                ret2 = copy(unsafe_wrap(Vector{_GdkTimeCoord}, ret, m_out_n_coords[]))
                GLib.g_free(ret)
                ret2
            end
        _out_n_coords = m_out_n_coords[]
        ret2
    end
    function get_modifier_state(instance::GdkEvent)
        ret = ccall(("gdk_event_get_modifier_state", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret2 = ModifierType(ret)
        ret2
    end
    function get_pointer_emulated(instance::GdkEvent)
        ret = ccall(("gdk_event_get_pointer_emulated", libgtk4), Cint, (Ptr{GdkEvent},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_position(instance::GdkEvent)
        m_x = Ref{Float64}()
        m_y = Ref{Float64}()
        ret = ccall(("gdk_event_get_position", libgtk4), Cint, (Ptr{GdkEvent}, Ptr{Float64}, Ptr{Float64}), instance, m_x, m_y)
        ret2 = convert(Bool, ret)
        _x = m_x[]
        _y = m_y[]
        (ret2, _x, _y)
    end
    function get_seat(instance::GdkEvent)
        ret = ccall(("gdk_event_get_seat", libgtk4), Ptr{GObject}, (Ptr{GdkEvent},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkSeat, ret, false)
            end
        ret2
    end
    function get_surface(instance::GdkEvent)
        ret = ccall(("gdk_event_get_surface", libgtk4), Ptr{GObject}, (Ptr{GdkEvent},), instance)
        ret2 = convert(GdkSurface, ret, false)
        ret2
    end
    function get_time(instance::GdkEvent)
        ret = ccall(("gdk_event_get_time", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret
    end
    function ref(instance::GdkEvent)
        ret = ccall(("gdk_event_ref", libgtk4), Ptr{GdkEvent}, (Ptr{GdkEvent},), instance)
        ret2 = convert(GdkEvent, ret)
        ret2
    end
    function triggers_context_menu(instance::GdkEvent)
        ret = ccall(("gdk_event_triggers_context_menu", libgtk4), Cint, (Ptr{GdkEvent},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function unref(instance::GdkEvent)
        ret = ccall(("gdk_event_unref", libgtk4), Nothing, (Ptr{GdkEvent},), instance)
        nothing
    end
    function get_in(instance::GdkFocusEvent)
        ret = ccall(("gdk_focus_event_get_in", libgtk4), Cint, (Ptr{GdkEvent},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function begin_updating(instance::GdkFrameClock)
        ret = ccall(("gdk_frame_clock_begin_updating", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function end_updating(instance::GdkFrameClock)
        ret = ccall(("gdk_frame_clock_end_updating", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function get_current_timings(instance::GdkFrameClock)
        ret = ccall(("gdk_frame_clock_get_current_timings", libgtk4), Ptr{GdkFrameTimings}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkFrameTimings, ret, false)
            end
        ret2
    end
    function get_fps(instance::GdkFrameClock)
        ret = ccall(("gdk_frame_clock_get_fps", libgtk4), Float64, (Ptr{GObject},), instance)
        ret
    end
    function get_frame_counter(instance::GdkFrameClock)
        ret = ccall(("gdk_frame_clock_get_frame_counter", libgtk4), Int64, (Ptr{GObject},), instance)
        ret
    end
    function get_frame_time(instance::GdkFrameClock)
        ret = ccall(("gdk_frame_clock_get_frame_time", libgtk4), Int64, (Ptr{GObject},), instance)
        ret
    end
    function get_history_start(instance::GdkFrameClock)
        ret = ccall(("gdk_frame_clock_get_history_start", libgtk4), Int64, (Ptr{GObject},), instance)
        ret
    end
    function get_refresh_info(instance::GdkFrameClock, _base_time::Integer)
        m_refresh_interval_return = Ref{Int64}()
        m_presentation_time_return = Ref{Int64}()
        ret = ccall(("gdk_frame_clock_get_refresh_info", libgtk4), Nothing, (Ptr{GObject}, Int64, Ptr{Int64}, Ptr{Int64}), instance, _base_time, m_refresh_interval_return, m_presentation_time_return)
        _refresh_interval_return = m_refresh_interval_return[]
        _presentation_time_return = m_presentation_time_return[]
        (_refresh_interval_return, _presentation_time_return)
    end
    function get_timings(instance::GdkFrameClock, _frame_counter::Integer)
        ret = ccall(("gdk_frame_clock_get_timings", libgtk4), Ptr{GdkFrameTimings}, (Ptr{GObject}, Int64), instance, _frame_counter)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkFrameTimings, ret, false)
            end
        ret2
    end
    function request_phase(instance::GdkFrameClock, _phase)
        ret = ccall(("gdk_frame_clock_request_phase", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _phase)
        nothing
    end
    function clear_current()
        ret = ccall(("gdk_gl_context_clear_current", libgtk4), Nothing, ())
        nothing
    end
    function get_current()
        ret = ccall(("gdk_gl_context_get_current", libgtk4), Ptr{GObject}, ())
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkGLContext, ret, false)
            end
        ret2
    end
    function get_debug_enabled(instance::GdkGLContext)
        ret = ccall(("gdk_gl_context_get_debug_enabled", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_display(instance::GdkGLContext)
        ret = ccall(("gdk_gl_context_get_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDisplay, ret, false)
            end
        ret2
    end
    function get_forward_compatible(instance::GdkGLContext)
        ret = ccall(("gdk_gl_context_get_forward_compatible", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_required_version(instance::GdkGLContext)
        m_major = Ref{Int32}()
        m_minor = Ref{Int32}()
        ret = ccall(("gdk_gl_context_get_required_version", libgtk4), Nothing, (Ptr{GObject}, Ptr{Int32}, Ptr{Int32}), instance, m_major, m_minor)
        _major = m_major[]
        _major = convert(Maybe(Integer), _major)
        _minor = m_minor[]
        _minor = convert(Maybe(Integer), _minor)
        (_major, _minor)
    end
    function get_surface(instance::GdkGLContext)
        ret = ccall(("gdk_gl_context_get_surface", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkSurface, ret, false)
            end
        ret2
    end
    function get_use_es(instance::GdkGLContext)
        ret = ccall(("gdk_gl_context_get_use_es", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_version(instance::GdkGLContext)
        m_major = Ref{Int32}()
        m_minor = Ref{Int32}()
        ret = ccall(("gdk_gl_context_get_version", libgtk4), Nothing, (Ptr{GObject}, Ptr{Int32}, Ptr{Int32}), instance, m_major, m_minor)
        _major = m_major[]
        _minor = m_minor[]
        (_major, _minor)
    end
    function is_legacy(instance::GdkGLContext)
        ret = ccall(("gdk_gl_context_is_legacy", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_shared(instance::GdkGLContext, _other::GdkGLContext)
        ret = ccall(("gdk_gl_context_is_shared", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _other)
        ret2 = convert(Bool, ret)
        ret2
    end
    function make_current(instance::GdkGLContext)
        ret = ccall(("gdk_gl_context_make_current", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function realize(instance::GdkGLContext)
        err = err_buf()
        ret = ccall(("gdk_gl_context_realize", libgtk4), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function set_debug_enabled(instance::GdkGLContext, _enabled::Bool)
        ret = ccall(("gdk_gl_context_set_debug_enabled", libgtk4), Nothing, (Ptr{GObject}, Cint), instance, _enabled)
        nothing
    end
    function set_forward_compatible(instance::GdkGLContext, _compatible::Bool)
        ret = ccall(("gdk_gl_context_set_forward_compatible", libgtk4), Nothing, (Ptr{GObject}, Cint), instance, _compatible)
        nothing
    end
    function set_required_version(instance::GdkGLContext, _major::Integer, _minor::Integer)
        ret = ccall(("gdk_gl_context_set_required_version", libgtk4), Nothing, (Ptr{GObject}, Int32, Int32), instance, _major, _minor)
        nothing
    end
    function set_use_es(instance::GdkGLContext, _use_es::Integer)
        ret = ccall(("gdk_gl_context_set_use_es", libgtk4), Nothing, (Ptr{GObject}, Int32), instance, _use_es)
        nothing
    end
    function release(instance::GdkGLTexture)
        ret = ccall(("gdk_gl_texture_release", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function get_grab_surface(instance::GdkGrabBrokenEvent)
        ret = ccall(("gdk_grab_broken_event_get_grab_surface", libgtk4), Ptr{GObject}, (Ptr{GdkEvent},), instance)
        ret2 = convert(GdkSurface, ret, false)
        ret2
    end
    function get_implicit(instance::GdkGrabBrokenEvent)
        ret = ccall(("gdk_grab_broken_event_get_implicit", libgtk4), Cint, (Ptr{GdkEvent},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_consumed_modifiers(instance::GdkKeyEvent)
        ret = ccall(("gdk_key_event_get_consumed_modifiers", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret2 = ModifierType(ret)
        ret2
    end
    function get_keycode(instance::GdkKeyEvent)
        ret = ccall(("gdk_key_event_get_keycode", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret
    end
    function get_keyval(instance::GdkKeyEvent)
        ret = ccall(("gdk_key_event_get_keyval", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret
    end
    function get_layout(instance::GdkKeyEvent)
        ret = ccall(("gdk_key_event_get_layout", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret
    end
    function get_level(instance::GdkKeyEvent)
        ret = ccall(("gdk_key_event_get_level", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret
    end
    function get_match(instance::GdkKeyEvent)
        m_keyval = Ref{UInt32}()
        m_modifiers = Ref{UInt32}()
        ret = ccall(("gdk_key_event_get_match", libgtk4), Cint, (Ptr{GdkEvent}, Ptr{UInt32}, Ptr{UInt32}), instance, m_keyval, m_modifiers)
        ret2 = convert(Bool, ret)
        _keyval = m_keyval[]
        _modifiers = m_modifiers[]
        _modifiers = ModifierType(_modifiers)
        (ret2, _keyval, _modifiers)
    end
    function is_modifier(instance::GdkKeyEvent)
        ret = ccall(("gdk_key_event_is_modifier", libgtk4), Cint, (Ptr{GdkEvent},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function matches(instance::GdkKeyEvent, _keyval::Integer, _modifiers)
        ret = ccall(("gdk_key_event_matches", libgtk4), UInt32, (Ptr{GdkEvent}, UInt32, UInt32), instance, _keyval, _modifiers)
        ret2 = KeyMatch(ret)
        ret2
    end
    function MemoryTexture_new(_width::Integer, _height::Integer, _format, _bytes::GBytes, _stride::Integer)
        ret = ccall(("gdk_memory_texture_new", libgtk4), Ptr{GObject}, (Int32, Int32, UInt32, Ptr{GBytes}, UInt64), _width, _height, _format, _bytes, _stride)
        ret2 = convert(GdkTexture, ret, true)
        ret2
    end
    function get_connector(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_connector", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, false)
            end
        ret2
    end
    function get_display(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDisplay, ret, false)
        ret2
    end
    function get_geometry(instance::GdkMonitor)
        m_geometry = Ref{_GdkRectangle}()
        ret = ccall(("gdk_monitor_get_geometry", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GdkRectangle}), instance, m_geometry)
        _geometry = m_geometry[]
        _geometry
    end
    function get_height_mm(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_height_mm", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_manufacturer(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_manufacturer", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, false)
            end
        ret2
    end
    function get_model(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_model", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                bytestring(ret, false)
            end
        ret2
    end
    function get_refresh_rate(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_refresh_rate", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_scale_factor(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_scale_factor", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_subpixel_layout(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_subpixel_layout", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = SubpixelLayout(ret)
        ret2
    end
    function get_width_mm(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_width_mm", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function is_valid(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_is_valid", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_axis_value(instance::GdkPadEvent)
        m_index = Ref{UInt32}()
        m_value = Ref{Float64}()
        ret = ccall(("gdk_pad_event_get_axis_value", libgtk4), Nothing, (Ptr{GdkEvent}, Ptr{UInt32}, Ptr{Float64}), instance, m_index, m_value)
        _index = m_index[]
        _value = m_value[]
        (_index, _value)
    end
    function get_button(instance::GdkPadEvent)
        ret = ccall(("gdk_pad_event_get_button", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret
    end
    function get_group_mode(instance::GdkPadEvent)
        m_group = Ref{UInt32}()
        m_mode = Ref{UInt32}()
        ret = ccall(("gdk_pad_event_get_group_mode", libgtk4), Nothing, (Ptr{GdkEvent}, Ptr{UInt32}, Ptr{UInt32}), instance, m_group, m_mode)
        _group = m_group[]
        _mode = m_mode[]
        (_group, _mode)
    end
    function get_deltas(instance::GdkScrollEvent)
        m_delta_x = Ref{Float64}()
        m_delta_y = Ref{Float64}()
        ret = ccall(("gdk_scroll_event_get_deltas", libgtk4), Nothing, (Ptr{GdkEvent}, Ptr{Float64}, Ptr{Float64}), instance, m_delta_x, m_delta_y)
        _delta_x = m_delta_x[]
        _delta_y = m_delta_y[]
        (_delta_x, _delta_y)
    end
    function get_direction(instance::GdkScrollEvent)
        ret = ccall(("gdk_scroll_event_get_direction", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret2 = ScrollDirection(ret)
        ret2
    end
    function is_stop(instance::GdkScrollEvent)
        ret = ccall(("gdk_scroll_event_is_stop", libgtk4), Cint, (Ptr{GdkEvent},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_capabilities(instance::GdkSeat)
        ret = ccall(("gdk_seat_get_capabilities", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = SeatCapabilities(ret)
        ret2
    end
    function get_devices(instance::GdkSeat, _capabilities)
        ret = ccall(("gdk_seat_get_devices", libgtk4), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject}, UInt32), instance, _capabilities)
        ret2 = GLib.GList(ret, false)
        ret2
    end
    function get_display(instance::GdkSeat)
        ret = ccall(("gdk_seat_get_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDisplay, ret, false)
        ret2
    end
    function get_keyboard(instance::GdkSeat)
        ret = ccall(("gdk_seat_get_keyboard", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDevice, ret, false)
            end
        ret2
    end
    function get_pointer(instance::GdkSeat)
        ret = ccall(("gdk_seat_get_pointer", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkDevice, ret, false)
            end
        ret2
    end
    function get_tools(instance::GdkSeat)
        ret = ccall(("gdk_seat_get_tools", libgtk4), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject},), instance)
        ret2 = GLib.GList(ret, false)
        ret2
    end
    function Surface_new_popup(_parent::GdkSurface, _autohide::Bool)
        ret = ccall(("gdk_surface_new_popup", libgtk4), Ptr{GObject}, (Ptr{GObject}, Cint), _parent, _autohide)
        ret2 = convert(GdkSurface, ret, true)
        ret2
    end
    function Surface_new_toplevel(_display::GdkDisplay)
        ret = ccall(("gdk_surface_new_toplevel", libgtk4), Ptr{GObject}, (Ptr{GObject},), _display)
        ret2 = convert(GdkSurface, ret, true)
        ret2
    end
    function beep(instance::GdkSurface)
        ret = ccall(("gdk_surface_beep", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function create_cairo_context(instance::GdkSurface)
        ret = ccall(("gdk_surface_create_cairo_context", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkCairoContext, ret, true)
        ret2
    end
    function create_gl_context(instance::GdkSurface)
        err = err_buf()
        ret = ccall(("gdk_surface_create_gl_context", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
        check_err(err)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkGLContext, ret, true)
            end
        ret2
    end
    function create_similar_surface(instance::GdkSurface, _content, _width::Integer, _height::Integer)
        ret = ccall(("gdk_surface_create_similar_surface", libgtk4), Ptr{cairoSurface}, (Ptr{GObject}, UInt32, Int32, Int32), instance, _content, _width, _height)
        ret2 = convert(cairoSurface, ret, true)
        ret2
    end
    function create_vulkan_context(instance::GdkSurface)
        err = err_buf()
        ret = ccall(("gdk_surface_create_vulkan_context", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
        check_err(err)
        ret2 = convert(GdkVulkanContext, ret, true)
        ret2
    end
    function destroy(instance::GdkSurface)
        ret = ccall(("gdk_surface_destroy", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function get_cursor(instance::GdkSurface)
        ret = ccall(("gdk_surface_get_cursor", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkCursor, ret, false)
            end
        ret2
    end
    function get_device_cursor(instance::GdkSurface, _device::GdkDevice)
        ret = ccall(("gdk_surface_get_device_cursor", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}), instance, _device)
        ret2 = if ret == C_NULL
                nothing
            else
                convert(GdkCursor, ret, false)
            end
        ret2
    end
    function get_device_position(instance::GdkSurface, _device::GdkDevice)
        m_x = Ref{Float64}()
        m_y = Ref{Float64}()
        m_mask = Ref{UInt32}()
        ret = ccall(("gdk_surface_get_device_position", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Float64}, Ptr{Float64}, Ptr{UInt32}), instance, _device, m_x, m_y, m_mask)
        ret2 = convert(Bool, ret)
        _x = m_x[]
        _y = m_y[]
        _mask = m_mask[]
        _mask = ModifierType(_mask)
        (ret2, _x, _y, _mask)
    end
    function get_display(instance::GdkSurface)
        ret = ccall(("gdk_surface_get_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDisplay, ret, false)
        ret2
    end
    function get_frame_clock(instance::GdkSurface)
        ret = ccall(("gdk_surface_get_frame_clock", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkFrameClock, ret, false)
        ret2
    end
    function get_height(instance::GdkSurface)
        ret = ccall(("gdk_surface_get_height", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_mapped(instance::GdkSurface)
        ret = ccall(("gdk_surface_get_mapped", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_scale_factor(instance::GdkSurface)
        ret = ccall(("gdk_surface_get_scale_factor", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_width(instance::GdkSurface)
        ret = ccall(("gdk_surface_get_width", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function hide(instance::GdkSurface)
        ret = ccall(("gdk_surface_hide", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function is_destroyed(instance::GdkSurface)
        ret = ccall(("gdk_surface_is_destroyed", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function queue_render(instance::GdkSurface)
        ret = ccall(("gdk_surface_queue_render", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function request_layout(instance::GdkSurface)
        ret = ccall(("gdk_surface_request_layout", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function set_cursor(instance::GdkSurface, _cursor::Maybe(GdkCursor))
        _cursor = if _cursor == nothing
                C_NULL
            else
                _cursor
            end
        ret = ccall(("gdk_surface_set_cursor", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _cursor)
        nothing
    end
    function set_device_cursor(instance::GdkSurface, _device::GdkDevice, _cursor::GdkCursor)
        ret = ccall(("gdk_surface_set_device_cursor", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}), instance, _device, _cursor)
        nothing
    end
    function set_input_region(instance::GdkSurface, _region::cairoRegion)
        ret = ccall(("gdk_surface_set_input_region", libgtk4), Nothing, (Ptr{GObject}, Ptr{cairoRegion}), instance, _region)
        nothing
    end
    function set_opaque_region(instance::GdkSurface, _region::Maybe(cairoRegion))
        _region = if _region == nothing
                C_NULL
            else
                _region
            end
        ret = ccall(("gdk_surface_set_opaque_region", libgtk4), Nothing, (Ptr{GObject}, Ptr{cairoRegion}), instance, _region)
        nothing
    end
    function translate_coordinates(instance::GdkSurface, _to::GdkSurface, _x::Real, _y::Real)
        m_x = Ref{Float64}()
        m_x[] = Base.cconvert(Float64, _x)
        m_y = Ref{Float64}()
        m_y[] = Base.cconvert(Float64, _y)
        ret = ccall(("gdk_surface_translate_coordinates", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Float64}, Ptr{Float64}), instance, _to, m_x, m_y)
        ret2 = convert(Bool, ret)
        _x = m_x[]
        _y = m_y[]
        (ret2, _x, _y)
    end
    function Texture_new_for_pixbuf(_pixbuf::GdkPixbuf)
        ret = ccall(("gdk_texture_new_for_pixbuf", libgtk4), Ptr{GObject}, (Ptr{GObject},), _pixbuf)
        ret2 = convert(GdkTexture, ret, true)
        ret2
    end
    function Texture_new_from_file(_file::GFile)
        err = err_buf()
        ret = ccall(("gdk_texture_new_from_file", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), _file, err)
        check_err(err)
        ret2 = convert(GdkTexture, ret, true)
        ret2
    end
    function Texture_new_from_resource(_resource_path::Union{AbstractString, Symbol})
        ret = ccall(("gdk_texture_new_from_resource", libgtk4), Ptr{GObject}, (Cstring,), _resource_path)
        ret2 = convert(GdkTexture, ret, true)
        ret2
    end
    function download(instance::GdkTexture, _data, _stride::Integer)
        _data = convert(Vector{UInt8}, _data)
        ret = ccall(("gdk_texture_download", libgtk4), Nothing, (Ptr{GObject}, Ptr{UInt8}, UInt64), instance, _data, _stride)
        nothing
    end
    function get_height(instance::GdkTexture)
        ret = ccall(("gdk_texture_get_height", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_width(instance::GdkTexture)
        ret = ccall(("gdk_texture_get_width", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function save_to_png(instance::GdkTexture, _filename::Union{AbstractString, Symbol})
        ret = ccall(("gdk_texture_save_to_png", libgtk4), Cint, (Ptr{GObject}, Cstring), instance, _filename)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_emulating_pointer(instance::GdkTouchEvent)
        ret = ccall(("gdk_touch_event_get_emulating_pointer", libgtk4), Cint, (Ptr{GdkEvent},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_deltas(instance::GdkTouchpadEvent)
        m_dx = Ref{Float64}()
        m_dy = Ref{Float64}()
        ret = ccall(("gdk_touchpad_event_get_deltas", libgtk4), Nothing, (Ptr{GdkEvent}, Ptr{Float64}, Ptr{Float64}), instance, m_dx, m_dy)
        _dx = m_dx[]
        _dy = m_dy[]
        (_dx, _dy)
    end
    function get_gesture_phase(instance::GdkTouchpadEvent)
        ret = ccall(("gdk_touchpad_event_get_gesture_phase", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret2 = TouchpadGesturePhase(ret)
        ret2
    end
    function get_n_fingers(instance::GdkTouchpadEvent)
        ret = ccall(("gdk_touchpad_event_get_n_fingers", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret
    end
    function get_pinch_angle_delta(instance::GdkTouchpadEvent)
        ret = ccall(("gdk_touchpad_event_get_pinch_angle_delta", libgtk4), Float64, (Ptr{GdkEvent},), instance)
        ret
    end
    function get_pinch_scale(instance::GdkTouchpadEvent)
        ret = ccall(("gdk_touchpad_event_get_pinch_scale", libgtk4), Float64, (Ptr{GdkEvent},), instance)
        ret
    end
    function get_feature_group(instance::GdkDevicePad, _feature, _feature_idx::Integer)
        ret = ccall(("gdk_device_pad_get_feature_group", libgtk4), Int32, (Ptr{GObject}, UInt32, Int32), instance, _feature, _feature_idx)
        ret
    end
    function get_group_n_modes(instance::GdkDevicePad, _group_idx::Integer)
        ret = ccall(("gdk_device_pad_get_group_n_modes", libgtk4), Int32, (Ptr{GObject}, Int32), instance, _group_idx)
        ret
    end
    function get_n_features(instance::GdkDevicePad, _feature)
        ret = ccall(("gdk_device_pad_get_n_features", libgtk4), Int32, (Ptr{GObject}, UInt32), instance, _feature)
        ret
    end
    function get_n_groups(instance::GdkDevicePad)
        ret = ccall(("gdk_device_pad_get_n_groups", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function present(instance::GdkDragSurface, _width::Integer, _height::Integer)
        ret = ccall(("gdk_drag_surface_present", libgtk4), Cint, (Ptr{GObject}, Int32, Int32), instance, _width, _height)
        ret2 = convert(Bool, ret)
        ret2
    end
    function new_empty(_intrinsic_width::Integer, _intrinsic_height::Integer)
        ret = ccall(("gdk_paintable_new_empty", libgtk4), Ptr{GObject}, (Int32, Int32), _intrinsic_width, _intrinsic_height)
        ret2 = begin
                leaftype = GLib.find_leaf_type(ret)
                convert(leaftype, ret, true)
            end
        ret2
    end
    function compute_concrete_size(instance::GdkPaintable, _specified_width::Real, _specified_height::Real, _default_width::Real, _default_height::Real)
        m_concrete_width = Ref{Float64}()
        m_concrete_height = Ref{Float64}()
        ret = ccall(("gdk_paintable_compute_concrete_size", libgtk4), Nothing, (Ptr{GObject}, Float64, Float64, Float64, Float64, Ptr{Float64}, Ptr{Float64}), instance, _specified_width, _specified_height, _default_width, _default_height, m_concrete_width, m_concrete_height)
        _concrete_width = m_concrete_width[]
        _concrete_height = m_concrete_height[]
        (_concrete_width, _concrete_height)
    end
    function get_current_image(instance::GdkPaintable)
        ret = ccall(("gdk_paintable_get_current_image", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = begin
                leaftype = GLib.find_leaf_type(ret)
                convert(leaftype, ret, true)
            end
        ret2
    end
    function get_flags(instance::GdkPaintable)
        ret = ccall(("gdk_paintable_get_flags", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = PaintableFlags(ret)
        ret2
    end
    function get_intrinsic_aspect_ratio(instance::GdkPaintable)
        ret = ccall(("gdk_paintable_get_intrinsic_aspect_ratio", libgtk4), Float64, (Ptr{GObject},), instance)
        ret
    end
    function get_intrinsic_height(instance::GdkPaintable)
        ret = ccall(("gdk_paintable_get_intrinsic_height", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_intrinsic_width(instance::GdkPaintable)
        ret = ccall(("gdk_paintable_get_intrinsic_width", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function invalidate_contents(instance::GdkPaintable)
        ret = ccall(("gdk_paintable_invalidate_contents", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function invalidate_size(instance::GdkPaintable)
        ret = ccall(("gdk_paintable_invalidate_size", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function snapshot(instance::GdkPaintable, _snapshot::GdkSnapshot, _width::Real, _height::Real)
        ret = ccall(("gdk_paintable_snapshot", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Float64, Float64), instance, _snapshot, _width, _height)
        nothing
    end
    function get_autohide(instance::GdkPopup)
        ret = ccall(("gdk_popup_get_autohide", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_parent(instance::GdkPopup)
        ret = ccall(("gdk_popup_get_parent", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkSurface, ret, false)
        ret2
    end
    function get_position_x(instance::GdkPopup)
        ret = ccall(("gdk_popup_get_position_x", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_position_y(instance::GdkPopup)
        ret = ccall(("gdk_popup_get_position_y", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_rect_anchor(instance::GdkPopup)
        ret = ccall(("gdk_popup_get_rect_anchor", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = Gravity(ret)
        ret2
    end
    function get_surface_anchor(instance::GdkPopup)
        ret = ccall(("gdk_popup_get_surface_anchor", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = Gravity(ret)
        ret2
    end
    function present(instance::GdkPopup, _width::Integer, _height::Integer, _layout::GdkPopupLayout)
        ret = ccall(("gdk_popup_present", libgtk4), Cint, (Ptr{GObject}, Int32, Int32, Ptr{GdkPopupLayout}), instance, _width, _height, _layout)
        ret2 = convert(Bool, ret)
        ret2
    end
    function begin_move(instance::GdkToplevel, _device::GdkDevice, _button::Integer, _x::Real, _y::Real, _timestamp::Integer)
        ret = ccall(("gdk_toplevel_begin_move", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Int32, Float64, Float64, UInt32), instance, _device, _button, _x, _y, _timestamp)
        nothing
    end
    function begin_resize(instance::GdkToplevel, _edge, _device::Maybe(GdkDevice), _button::Integer, _x::Real, _y::Real, _timestamp::Integer)
        _device = if _device == nothing
                C_NULL
            else
                _device
            end
        ret = ccall(("gdk_toplevel_begin_resize", libgtk4), Nothing, (Ptr{GObject}, UInt32, Ptr{GObject}, Int32, Float64, Float64, UInt32), instance, _edge, _device, _button, _x, _y, _timestamp)
        nothing
    end
    function focus(instance::GdkToplevel, _timestamp::Integer)
        ret = ccall(("gdk_toplevel_focus", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _timestamp)
        nothing
    end
    function get_state(instance::GdkToplevel)
        ret = ccall(("gdk_toplevel_get_state", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = ToplevelState(ret)
        ret2
    end
    function lower(instance::GdkToplevel)
        ret = ccall(("gdk_toplevel_lower", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function minimize(instance::GdkToplevel)
        ret = ccall(("gdk_toplevel_minimize", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function present(instance::GdkToplevel, _layout::GdkToplevelLayout)
        ret = ccall(("gdk_toplevel_present", libgtk4), Nothing, (Ptr{GObject}, Ptr{GdkToplevelLayout}), instance, _layout)
        nothing
    end
    function restore_system_shortcuts(instance::GdkToplevel)
        ret = ccall(("gdk_toplevel_restore_system_shortcuts", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function set_decorated(instance::GdkToplevel, _decorated::Bool)
        ret = ccall(("gdk_toplevel_set_decorated", libgtk4), Nothing, (Ptr{GObject}, Cint), instance, _decorated)
        nothing
    end
    function set_deletable(instance::GdkToplevel, _deletable::Bool)
        ret = ccall(("gdk_toplevel_set_deletable", libgtk4), Nothing, (Ptr{GObject}, Cint), instance, _deletable)
        nothing
    end
    function set_icon_list(instance::GdkToplevel, _surfaces::GLib.LList{GLib._GList{Ptr{GObject}}})
        ret = ccall(("gdk_toplevel_set_icon_list", libgtk4), Nothing, (Ptr{GObject}, Ptr{GLib._GList{Ptr{GObject}}}), instance, _surfaces)
        nothing
    end
    function set_modal(instance::GdkToplevel, _modal::Bool)
        ret = ccall(("gdk_toplevel_set_modal", libgtk4), Nothing, (Ptr{GObject}, Cint), instance, _modal)
        nothing
    end
    function set_startup_id(instance::GdkToplevel, _startup_id::Union{AbstractString, Symbol})
        ret = ccall(("gdk_toplevel_set_startup_id", libgtk4), Nothing, (Ptr{GObject}, Cstring), instance, _startup_id)
        nothing
    end
    function set_title(instance::GdkToplevel, _title::Union{AbstractString, Symbol})
        ret = ccall(("gdk_toplevel_set_title", libgtk4), Nothing, (Ptr{GObject}, Cstring), instance, _title)
        nothing
    end
    function set_transient_for(instance::GdkToplevel, _parent::GdkSurface)
        ret = ccall(("gdk_toplevel_set_transient_for", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _parent)
        nothing
    end
    function supports_edge_constraints(instance::GdkToplevel)
        ret = ccall(("gdk_toplevel_supports_edge_constraints", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function titlebar_gesture(instance::GdkToplevel, _gesture)
        ret = ccall(("gdk_toplevel_titlebar_gesture", libgtk4), Cint, (Ptr{GObject}, UInt32), instance, _gesture)
        ret2 = convert(Bool, ret)
        ret2
    end
end))
end
