quote
$(Expr(:toplevel, quote
    function ContentFormats_new(_mime_types)
        _mime_types_maybe = nothing_to_null(_mime_types)
        _n_mime_types = length(_mime_types)
        ret = ccall(("gdk_content_formats_new", libgtk4), Ptr{GdkContentFormats}, (Ptr{Cstring}, UInt32), _mime_types_maybe, _n_mime_types)
        ret2 = convert(GdkContentFormats, ret, true)
        ret2
    end
    function ContentFormats_new_for_gtype(_type::Integer)
        ret = ccall(("gdk_content_formats_new_for_gtype", libgtk4), Ptr{GdkContentFormats}, (UInt64,), _type)
        ret2 = convert(GdkContentFormats, ret, true)
        ret2
    end
    function contain_gtype(instance::GdkContentFormats, _type::Integer)
        ret = ccall(("gdk_content_formats_contain_gtype", libgtk4), Cint, (Ptr{GdkContentFormats}, UInt64), instance, _type)
        ret2 = convert(Bool, ret)
        ret2
    end
    function contain_mime_type(instance::GdkContentFormats, _mime_type::Union{AbstractString, Symbol})
        ret = ccall(("gdk_content_formats_contain_mime_type", libgtk4), Cint, (Ptr{GdkContentFormats}, Cstring), instance, _mime_type)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_gtypes(instance::GdkContentFormats)
        m_n_gtypes = Ref{UInt64}()
        ret = ccall(("gdk_content_formats_get_gtypes", libgtk4), Ptr{UInt64}, (Ptr{GdkContentFormats}, Ptr{UInt64}), instance, m_n_gtypes)
        ret2 = collect(unsafe_wrap(Vector{UInt64}, ret, m_n_gtypes[]))
        _n_gtypes = m_n_gtypes[]
        ret2
    end
    function get_mime_types(instance::GdkContentFormats)
        m_n_mime_types = Ref{UInt64}()
        ret = ccall(("gdk_content_formats_get_mime_types", libgtk4), Ptr{Cstring}, (Ptr{GdkContentFormats}, Ptr{UInt64}), instance, m_n_mime_types)
        ret2 = bytestring.(unsafe_wrap(Vector{Cstring}, ret, m_n_mime_types[]))
        _n_mime_types = m_n_mime_types[]
        ret2
    end
    function match(instance::GdkContentFormats, _second::GdkContentFormats)
        ret = ccall(("gdk_content_formats_match", libgtk4), Cint, (Ptr{GdkContentFormats}, Ptr{GdkContentFormats}), instance, _second)
        ret2 = convert(Bool, ret)
        ret2
    end
    function match_gtype(instance::GdkContentFormats, _second::GdkContentFormats)
        ret = ccall(("gdk_content_formats_match_gtype", libgtk4), UInt64, (Ptr{GdkContentFormats}, Ptr{GdkContentFormats}), instance, _second)
        ret
    end
    function match_mime_type(instance::GdkContentFormats, _second::GdkContentFormats)
        ret = ccall(("gdk_content_formats_match_mime_type", libgtk4), Cstring, (Ptr{GdkContentFormats}, Ptr{GdkContentFormats}), instance, _second)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function print(instance::GdkContentFormats, _string::Union{GString, Ref{_GString}})
        ret = ccall(("gdk_content_formats_print", libgtk4), Nothing, (Ptr{GdkContentFormats}, Ptr{_GString}), instance, _string)
        nothing
    end
    function ref(instance::GdkContentFormats)
        ret = ccall(("gdk_content_formats_ref", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormats},), instance)
        ret2 = convert(GdkContentFormats, ret, true)
        ret2
    end
    function to_string(instance::GdkContentFormats)
        ret = ccall(("gdk_content_formats_to_string", libgtk4), Cstring, (Ptr{GdkContentFormats},), instance)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function union(instance::GdkContentFormats, _second::GdkContentFormats)
        ret = ccall(("gdk_content_formats_union", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormats}, Ptr{GdkContentFormats}), instance, _second)
        ret2 = convert(GdkContentFormats, ret, true)
        ret2
    end
    function union_deserialize_gtypes(instance::GdkContentFormats)
        ret = ccall(("gdk_content_formats_union_deserialize_gtypes", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormats},), instance)
        ret2 = convert(GdkContentFormats, ret, true)
        ret2
    end
    function union_deserialize_mime_types(instance::GdkContentFormats)
        ret = ccall(("gdk_content_formats_union_deserialize_mime_types", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormats},), instance)
        ret2 = convert(GdkContentFormats, ret, true)
        ret2
    end
    function union_serialize_gtypes(instance::GdkContentFormats)
        ret = ccall(("gdk_content_formats_union_serialize_gtypes", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormats},), instance)
        ret2 = convert(GdkContentFormats, ret, true)
        ret2
    end
    function union_serialize_mime_types(instance::GdkContentFormats)
        ret = ccall(("gdk_content_formats_union_serialize_mime_types", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormats},), instance)
        ret2 = convert(GdkContentFormats, ret, true)
        ret2
    end
    function unref(instance::GdkContentFormats)
        ret = ccall(("gdk_content_formats_unref", libgtk4), Nothing, (Ptr{GdkContentFormats},), instance)
        nothing
    end
    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 contains(instance::GdkDmabufFormats, _fourcc::Integer, _modifier::Integer)
        ret = ccall(("gdk_dmabuf_formats_contains", libgtk4), Cint, (Ptr{GdkDmabufFormats}, UInt32, UInt64), instance, _fourcc, _modifier)
        ret2 = convert(Bool, ret)
        ret2
    end
    function equal(instance::GdkDmabufFormats, _formats2::Maybe(GdkDmabufFormats))
        _formats2_maybe = nothing_to_null(_formats2)
        ret = ccall(("gdk_dmabuf_formats_equal", libgtk4), Cint, (Ptr{GdkDmabufFormats}, Ptr{GdkDmabufFormats}), instance, _formats2_maybe)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_format(instance::GdkDmabufFormats, _idx::Integer)
        m_fourcc = Ref{UInt32}()
        m_modifier = Ref{UInt64}()
        ret = ccall(("gdk_dmabuf_formats_get_format", libgtk4), Nothing, (Ptr{GdkDmabufFormats}, UInt64, Ptr{UInt32}, Ptr{UInt64}), instance, _idx, m_fourcc, m_modifier)
        _fourcc = m_fourcc[]
        _modifier = m_modifier[]
        (_fourcc, _modifier)
    end
    function get_n_formats(instance::GdkDmabufFormats)
        ret = ccall(("gdk_dmabuf_formats_get_n_formats", libgtk4), UInt64, (Ptr{GdkDmabufFormats},), instance)
        ret
    end
    function ref(instance::GdkDmabufFormats)
        ret = ccall(("gdk_dmabuf_formats_ref", libgtk4), Ptr{GdkDmabufFormats}, (Ptr{GdkDmabufFormats},), instance)
        ret2 = convert(GdkDmabufFormats, ret, true)
        ret2
    end
    function unref(instance::GdkDmabufFormats)
        ret = ccall(("gdk_dmabuf_formats_unref", libgtk4), Nothing, (Ptr{GdkDmabufFormats},), instance)
        nothing
    end
    function set_size(instance::GdkDragSurfaceSize, _width::Integer, _height::Integer)
        ret = ccall(("gdk_drag_surface_size_set_size", libgtk4), Nothing, (Ptr{GdkDragSurfaceSize}, Int32, Int32), instance, _width, _height)
        nothing
    end
    function FileList_new_from_array(_files)
        _files_arr = convert(Vector{Ptr{GObject}}, _files)
        _n_files = length(_files)
        ret = ccall(("gdk_file_list_new_from_array", libgtk4), Ptr{GdkFileList}, (Ptr{Ptr{GObject}}, UInt64), _files_arr, _n_files)
        ret2 = convert(GdkFileList, ret, true)
        ret2
    end
    function FileList_new_from_list(_files::GLib.LList{GLib._GSList{Ptr{GObject}}})
        ret = ccall(("gdk_file_list_new_from_list", libgtk4), Ptr{GdkFileList}, (Ptr{GLib._GSList{Ptr{GObject}}},), _files)
        ret2 = convert(GdkFileList, ret, true)
        ret2
    end
    function get_files(instance::GdkFileList)
        ret = ccall(("gdk_file_list_get_files", libgtk4), Ptr{GLib._GSList{Ptr{GObject}}}, (Ptr{GdkFileList},), instance)
        ret2 = GLib.GList(ret, false)
        ret2
    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::Union{GdkRGBA, Ref{_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::Union{GdkRGBA, Ref{_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::Union{GdkRGBA, Ref{_GdkRGBA}})
        ret = ccall(("gdk_rgba_free", libgtk4), Nothing, (Ptr{_GdkRGBA},), instance)
        nothing
    end
    function hash(instance::Union{GdkRGBA, Ref{_GdkRGBA}})
        ret = ccall(("gdk_rgba_hash", libgtk4), UInt32, (Ptr{_GdkRGBA},), instance)
        ret
    end
    function is_clear(instance::Union{GdkRGBA, Ref{_GdkRGBA}})
        ret = ccall(("gdk_rgba_is_clear", libgtk4), Cint, (Ptr{_GdkRGBA},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_opaque(instance::Union{GdkRGBA, Ref{_GdkRGBA}})
        ret = ccall(("gdk_rgba_is_opaque", libgtk4), Cint, (Ptr{_GdkRGBA},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function parse(instance::Union{GdkRGBA, Ref{_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::Union{GdkRGBA, Ref{_GdkRGBA}})
        ret = ccall(("gdk_rgba_to_string", libgtk4), Cstring, (Ptr{_GdkRGBA},), instance)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function contains_point(instance::Union{GdkRectangle, Ref{_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::Union{GdkRectangle, Ref{_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::Union{GdkRectangle, Ref{_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::Union{GdkRectangle, Ref{_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 TextureDownloader_new(_texture::GdkTexture)
        ret = ccall(("gdk_texture_downloader_new", libgtk4), Ptr{GdkTextureDownloader}, (Ptr{GObject},), _texture)
        ret2 = convert(GdkTextureDownloader, ret, true)
        ret2
    end
    function copy(instance::GdkTextureDownloader)
        ret = ccall(("gdk_texture_downloader_copy", libgtk4), Ptr{GdkTextureDownloader}, (Ptr{GdkTextureDownloader},), instance)
        ret2 = convert(GdkTextureDownloader, ret, true)
        ret2
    end
    function download_bytes(instance::GdkTextureDownloader)
        m_out_stride = Ref{UInt64}()
        ret = ccall(("gdk_texture_downloader_download_bytes", libgtk4), Ptr{GBytes}, (Ptr{GdkTextureDownloader}, Ptr{UInt64}), instance, m_out_stride)
        ret2 = convert(GBytes, ret, true)
        _out_stride = m_out_stride[]
        (ret2, _out_stride)
    end
    function download_into(instance::GdkTextureDownloader, _data, _stride::Integer)
        _data_arr = convert(Vector{UInt8}, _data)
        ret = ccall(("gdk_texture_downloader_download_into", libgtk4), Nothing, (Ptr{GdkTextureDownloader}, Ptr{UInt8}, UInt64), instance, _data_arr, _stride)
        nothing
    end
    function free(instance::GdkTextureDownloader)
        ret = ccall(("gdk_texture_downloader_free", libgtk4), Nothing, (Ptr{GdkTextureDownloader},), instance)
        nothing
    end
    function get_format(instance::GdkTextureDownloader)
        ret = ccall(("gdk_texture_downloader_get_format", libgtk4), UInt32, (Ptr{GdkTextureDownloader},), instance)
        ret2 = MemoryFormat(ret)
        ret2
    end
    function get_texture(instance::GdkTextureDownloader)
        ret = ccall(("gdk_texture_downloader_get_texture", libgtk4), Ptr{GObject}, (Ptr{GdkTextureDownloader},), instance)
        ret2 = convert(GdkTexture, ret, false)
        ret2
    end
    function set_format(instance::GdkTextureDownloader, _format)
        ret = ccall(("gdk_texture_downloader_set_format", libgtk4), Nothing, (Ptr{GdkTextureDownloader}, UInt32), instance, _format)
        nothing
    end
    function set_texture(instance::GdkTextureDownloader, _texture::GdkTexture)
        ret = ccall(("gdk_texture_downloader_set_texture", libgtk4), Nothing, (Ptr{GdkTextureDownloader}, Ptr{GObject}), instance, _texture)
        nothing
    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 = convert_if_not_null(GdkMonitor, ret, false)
        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_maybe = nothing_to_null(_monitor)
        ret = ccall(("gdk_toplevel_layout_set_fullscreen", libgtk4), Nothing, (Ptr{GdkToplevelLayout}, Cint, Ptr{GObject}), instance, _fullscreen, _monitor_maybe)
        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_maybe = nothing_to_null(_icon)
        ret = ccall(("gdk_app_launch_context_set_icon", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _icon_maybe)
        nothing
    end
    function set_icon_name(instance::GdkAppLaunchContext, _icon_name::Maybe(Union{AbstractString, Symbol}))
        _icon_name_maybe = nothing_to_null(_icon_name)
        ret = ccall(("gdk_app_launch_context_set_icon_name", libgtk4), Nothing, (Ptr{GObject}, Cstring), instance, _icon_name_maybe)
        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 = convert_if_not_null(cairoContext, ret, true)
        ret2
    end
    function get_content(instance::GdkClipboard)
        ret = ccall(("gdk_clipboard_get_content", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(GdkContentProvider, ret, false)
        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))
        _cancellable_maybe = nothing_to_null(_cancellable)
        if _callback === nothing
            _callback_cfunc = C_NULL
            _callback_closure = C_NULL
        else
            _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
            _callback_closure = GLib.gc_ref(_callback)
        end
        ret = ccall(("gdk_clipboard_read_async", libgtk4), Nothing, (Ptr{GObject}, Ptr{Cstring}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _mime_types, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
        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 = convert_if_not_null(GInputStream, ret, true)
        _out_mime_type = m_out_mime_type[]
        _out_mime_type = string_or_nothing(_out_mime_type, false)
        (ret2, _out_mime_type)
    end
    function read_text_async(instance::GdkClipboard, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
        _cancellable_maybe = nothing_to_null(_cancellable)
        if _callback === nothing
            _callback_cfunc = C_NULL
            _callback_closure = C_NULL
        else
            _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
            _callback_closure = GLib.gc_ref(_callback)
        end
        ret = ccall(("gdk_clipboard_read_text_async", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
        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 = string_or_nothing(ret, true)
        ret2
    end
    function read_texture_async(instance::GdkClipboard, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
        _cancellable_maybe = nothing_to_null(_cancellable)
        if _callback === nothing
            _callback_cfunc = C_NULL
            _callback_closure = C_NULL
        else
            _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
            _callback_closure = GLib.gc_ref(_callback)
        end
        ret = ccall(("gdk_clipboard_read_texture_async", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
        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 = convert_if_not_null(GdkTexture, ret, true)
        ret2
    end
    function read_value_async(instance::GdkClipboard, _type::Integer, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
        _cancellable_maybe = nothing_to_null(_cancellable)
        if _callback === nothing
            _callback_cfunc = C_NULL
            _callback_closure = C_NULL
        else
            _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
            _callback_closure = GLib.gc_ref(_callback)
        end
        ret = ccall(("gdk_clipboard_read_value_async", libgtk4), Nothing, (Ptr{GObject}, UInt64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _type, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
        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_maybe = nothing_to_null(_provider)
        ret = ccall(("gdk_clipboard_set_content", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _provider_maybe)
        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))
        _cancellable_maybe = nothing_to_null(_cancellable)
        if _callback === nothing
            _callback_cfunc = C_NULL
            _callback_closure = C_NULL
        else
            _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
            _callback_closure = GLib.gc_ref(_callback)
        end
        ret = ccall(("gdk_clipboard_store_async", libgtk4), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
        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_if_not_null(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 = string_or_nothing(ret, false)
        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 get_source_object(instance::GdkContentDeserializer)
        get_source_object(GAsyncResult(instance))
    end
    function is_tagged(instance::GdkContentDeserializer, _source_tag::Maybe(Nothing))
        is_tagged(GAsyncResult(instance), _source_tag)
    end
    function legacy_propagate_error(instance::GdkContentDeserializer)
        legacy_propagate_error(GAsyncResult(instance))
    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 = GdkContentProviderLeaf(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 = GdkContentProviderLeaf(ret, true)
        ret2
    end
    function ContentProvider_new_union(_providers)
        _providers_arr = convert(Vector{Ptr{GObject}}, _providers)
        _n_providers = length(_providers)
        ret = ccall(("gdk_content_provider_new_union", libgtk4), Ptr{GObject}, (Ptr{Ptr{GObject}}, UInt64), _providers_arr, _n_providers)
        ret2 = GdkContentProviderLeaf(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)
        m_value = Ref{_GValue}()
        err = err_buf()
        ret = ccall(("gdk_content_provider_get_value", libgtk4), Cint, (Ptr{GObject}, Ptr{_GValue}, Ptr{Ptr{GError}}), instance, m_value, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        _value = m_value[]
        (ret2, _value)
    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))
        _cancellable_maybe = nothing_to_null(_cancellable)
        if _callback === nothing
            _callback_cfunc = C_NULL
            _callback_closure = C_NULL
        else
            _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
            _callback_closure = GLib.gc_ref(_callback)
        end
        ret = ccall(("gdk_content_provider_write_mime_type_async", libgtk4), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _mime_type, _stream, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
        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_if_not_null(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 = string_or_nothing(ret, false)
        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_source_object(instance::GdkContentSerializer)
        get_source_object(GAsyncResult(instance))
    end
    function is_tagged(instance::GdkContentSerializer, _source_tag::Maybe(Nothing))
        is_tagged(GAsyncResult(instance), _source_tag)
    end
    function legacy_propagate_error(instance::GdkContentSerializer)
        legacy_propagate_error(GAsyncResult(instance))
    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_maybe = nothing_to_null(_fallback)
        ret = ccall(("gdk_cursor_new_from_name", libgtk4), Ptr{GObject}, (Cstring, Ptr{GObject}), _name, _fallback_maybe)
        ret2 = convert_if_not_null(GdkCursor, ret, true)
        ret2
    end
    function Cursor_new_from_texture(_texture::GdkTexture, _hotspot_x::Integer, _hotspot_y::Integer, _fallback::Maybe(GdkCursor))
        _fallback_maybe = nothing_to_null(_fallback)
        ret = ccall(("gdk_cursor_new_from_texture", libgtk4), Ptr{GObject}, (Ptr{GObject}, Int32, Int32, Ptr{GObject}), _texture, _hotspot_x, _hotspot_y, _fallback_maybe)
        ret2 = GdkCursorLeaf(ret, true)
        ret2
    end
    function get_fallback(instance::GdkCursor)
        ret = ccall(("gdk_cursor_get_fallback", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(GdkCursor, ret, false)
        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 = string_or_nothing(ret, false)
        ret2
    end
    function get_texture(instance::GdkCursor)
        ret = ccall(("gdk_cursor_get_texture", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(GdkTexture, ret, false)
        ret2
    end
    function get_drop(instance::GdkDNDEvent)
        ret = ccall(("gdk_dnd_event_get_drop", libgtk4), Ptr{GObject}, (Ptr{GdkEvent},), instance)
        ret2 = convert_if_not_null(GdkDrop, ret, false)
        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_if_not_null(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 = string_or_nothing(ret, false)
        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 = string_or_nothing(ret, false)
        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 = convert_if_not_null(GdkSurface, ret, false)
        _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 = string_or_nothing(ret, false)
        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 = convert_if_not_null(GdkDisplay, ret, false)
        ret2
    end
    function open(_display_name::Maybe(Union{AbstractString, Symbol}))
        _display_name_maybe = nothing_to_null(_display_name)
        ret = ccall(("gdk_display_open", libgtk4), Ptr{GObject}, (Cstring,), _display_name_maybe)
        ret2 = convert_if_not_null(GdkDisplay, ret, false)
        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 create_gl_context(instance::GdkDisplay)
        err = err_buf()
        ret = ccall(("gdk_display_create_gl_context", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
        check_err(err)
        ret2 = convert(GdkGLContext, ret, true)
        ret2
    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 = convert_if_not_null(GdkSeat, ret, false)
        ret2
    end
    function get_dmabuf_formats(instance::GdkDisplay)
        ret = ccall(("gdk_display_get_dmabuf_formats", libgtk4), Ptr{GdkDmabufFormats}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDmabufFormats, ret, false)
        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_if_not_null(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 = string_or_nothing(ret, false)
        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 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[]
        _keys = begin
                arrtemp = copy(unsafe_wrap(Vector{_GdkKeymapKey}, _keys, m_n_entries[]))
                GLib.g_free(_keys)
                arrtemp
            end
        _keyvals = m_keyvals[]
        _keyvals = begin
                arrtemp = copy(unsafe_wrap(Vector{UInt32}, _keyvals, m_n_entries[]))
                GLib.g_free(_keyvals)
                arrtemp
            end
        _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[]
        _keys = begin
                arrtemp = copy(unsafe_wrap(Vector{_GdkKeymapKey}, _keys, m_n_keys[]))
                GLib.g_free(_keys)
                arrtemp
            end
        _n_keys = m_n_keys[]
        (ret2, _keys)
    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 supports_shadow_width(instance::GdkDisplay)
        ret = ccall(("gdk_display_supports_shadow_width", 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 = convert_if_not_null(GdkDisplay, ret, false)
        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::Maybe(Union{AbstractString, Symbol}))
        _name_maybe = nothing_to_null(_name)
        ret = ccall(("gdk_display_manager_open_display", libgtk4), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _name_maybe)
        ret2 = convert_if_not_null(GdkDisplay, ret, false)
        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 compute_concrete_size(instance::GdkDmabufTexture, _specified_width::Real, _specified_height::Real, _default_width::Real, _default_height::Real)
        compute_concrete_size(GdkPaintable(instance), _specified_width, _specified_height, _default_width, _default_height)
    end
    function get_current_image(instance::GdkDmabufTexture)
        get_current_image(GdkPaintable(instance))
    end
    function get_flags(instance::GdkDmabufTexture)
        get_flags(GdkPaintable(instance))
    end
    function get_intrinsic_aspect_ratio(instance::GdkDmabufTexture)
        get_intrinsic_aspect_ratio(GdkPaintable(instance))
    end
    function get_intrinsic_height(instance::GdkDmabufTexture)
        get_intrinsic_height(GdkPaintable(instance))
    end
    function get_intrinsic_width(instance::GdkDmabufTexture)
        get_intrinsic_width(GdkPaintable(instance))
    end
    function invalidate_contents(instance::GdkDmabufTexture)
        invalidate_contents(GdkPaintable(instance))
    end
    function invalidate_size(instance::GdkDmabufTexture)
        invalidate_size(GdkPaintable(instance))
    end
    function snapshot(instance::GdkDmabufTexture, _snapshot::GdkSnapshot, _width::Real, _height::Real)
        snapshot(GdkPaintable(instance), _snapshot, _width, _height)
    end
    function equal(instance::GdkDmabufTexture, _icon2::Maybe(GIcon))
        equal(GIcon(instance), _icon2)
    end
    function hash(instance::GdkDmabufTexture)
        hash(GIcon(instance))
    end
    function serialize(instance::GdkDmabufTexture)
        serialize(GIcon(instance))
    end
    function to_string(instance::GdkDmabufTexture)
        to_string(GIcon(instance))
    end
    function load(instance::GdkDmabufTexture, _size::Integer, _cancellable::Maybe(GCancellable))
        load(GLoadableIcon(instance), _size, _cancellable)
    end
    function load_async(instance::GdkDmabufTexture, _size::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
        load_async(GLoadableIcon(instance), _size, _cancellable, _callback)
    end
    function load_finish(instance::GdkDmabufTexture, _res::GAsyncResult)
        load_finish(GLoadableIcon(instance), _res)
    end
    function DmabufTextureBuilder_new()
        ret = ccall(("gdk_dmabuf_texture_builder_new", libgtk4), Ptr{GObject}, ())
        ret2 = GdkDmabufTextureBuilderLeaf(ret, true)
        ret2
    end
    function get_display(instance::GdkDmabufTextureBuilder)
        ret = ccall(("gdk_dmabuf_texture_builder_get_display", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert(GdkDisplay, ret, false)
        ret2
    end
    function get_fd(instance::GdkDmabufTextureBuilder, _plane::Integer)
        ret = ccall(("gdk_dmabuf_texture_builder_get_fd", libgtk4), Int32, (Ptr{GObject}, UInt32), instance, _plane)
        ret
    end
    function get_fourcc(instance::GdkDmabufTextureBuilder)
        ret = ccall(("gdk_dmabuf_texture_builder_get_fourcc", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret
    end
    function get_height(instance::GdkDmabufTextureBuilder)
        ret = ccall(("gdk_dmabuf_texture_builder_get_height", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret
    end
    function get_modifier(instance::GdkDmabufTextureBuilder)
        ret = ccall(("gdk_dmabuf_texture_builder_get_modifier", libgtk4), UInt64, (Ptr{GObject},), instance)
        ret
    end
    function get_n_planes(instance::GdkDmabufTextureBuilder)
        ret = ccall(("gdk_dmabuf_texture_builder_get_n_planes", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret
    end
    function get_offset(instance::GdkDmabufTextureBuilder, _plane::Integer)
        ret = ccall(("gdk_dmabuf_texture_builder_get_offset", libgtk4), UInt32, (Ptr{GObject}, UInt32), instance, _plane)
        ret
    end
    function get_premultiplied(instance::GdkDmabufTextureBuilder)
        ret = ccall(("gdk_dmabuf_texture_builder_get_premultiplied", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_stride(instance::GdkDmabufTextureBuilder, _plane::Integer)
        ret = ccall(("gdk_dmabuf_texture_builder_get_stride", libgtk4), UInt32, (Ptr{GObject}, UInt32), instance, _plane)
        ret
    end
    function get_update_region(instance::GdkDmabufTextureBuilder)
        ret = ccall(("gdk_dmabuf_texture_builder_get_update_region", libgtk4), Ptr{cairoRegion}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(cairoRegion, ret, false)
        ret2
    end
    function get_update_texture(instance::GdkDmabufTextureBuilder)
        ret = ccall(("gdk_dmabuf_texture_builder_get_update_texture", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(GdkTexture, ret, false)
        ret2
    end
    function get_width(instance::GdkDmabufTextureBuilder)
        ret = ccall(("gdk_dmabuf_texture_builder_get_width", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret
    end
    function set_display(instance::GdkDmabufTextureBuilder, _display::GdkDisplay)
        ret = ccall(("gdk_dmabuf_texture_builder_set_display", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _display)
        nothing
    end
    function set_fd(instance::GdkDmabufTextureBuilder, _plane::Integer, _fd::Integer)
        ret = ccall(("gdk_dmabuf_texture_builder_set_fd", libgtk4), Nothing, (Ptr{GObject}, UInt32, Int32), instance, _plane, _fd)
        nothing
    end
    function set_fourcc(instance::GdkDmabufTextureBuilder, _fourcc::Integer)
        ret = ccall(("gdk_dmabuf_texture_builder_set_fourcc", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _fourcc)
        nothing
    end
    function set_height(instance::GdkDmabufTextureBuilder, _height::Integer)
        ret = ccall(("gdk_dmabuf_texture_builder_set_height", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _height)
        nothing
    end
    function set_modifier(instance::GdkDmabufTextureBuilder, _modifier::Integer)
        ret = ccall(("gdk_dmabuf_texture_builder_set_modifier", libgtk4), Nothing, (Ptr{GObject}, UInt64), instance, _modifier)
        nothing
    end
    function set_n_planes(instance::GdkDmabufTextureBuilder, _n_planes::Integer)
        ret = ccall(("gdk_dmabuf_texture_builder_set_n_planes", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _n_planes)
        nothing
    end
    function set_offset(instance::GdkDmabufTextureBuilder, _plane::Integer, _offset::Integer)
        ret = ccall(("gdk_dmabuf_texture_builder_set_offset", libgtk4), Nothing, (Ptr{GObject}, UInt32, UInt32), instance, _plane, _offset)
        nothing
    end
    function set_premultiplied(instance::GdkDmabufTextureBuilder, _premultiplied::Bool)
        ret = ccall(("gdk_dmabuf_texture_builder_set_premultiplied", libgtk4), Nothing, (Ptr{GObject}, Cint), instance, _premultiplied)
        nothing
    end
    function set_stride(instance::GdkDmabufTextureBuilder, _plane::Integer, _stride::Integer)
        ret = ccall(("gdk_dmabuf_texture_builder_set_stride", libgtk4), Nothing, (Ptr{GObject}, UInt32, UInt32), instance, _plane, _stride)
        nothing
    end
    function set_update_region(instance::GdkDmabufTextureBuilder, _region::Maybe(cairoRegion))
        _region_maybe = nothing_to_null(_region)
        ret = ccall(("gdk_dmabuf_texture_builder_set_update_region", libgtk4), Nothing, (Ptr{GObject}, Ptr{cairoRegion}), instance, _region_maybe)
        nothing
    end
    function set_update_texture(instance::GdkDmabufTextureBuilder, _texture::Maybe(GdkTexture))
        _texture_maybe = nothing_to_null(_texture)
        ret = ccall(("gdk_dmabuf_texture_builder_set_update_texture", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _texture_maybe)
        nothing
    end
    function set_width(instance::GdkDmabufTextureBuilder, _width::Integer)
        ret = ccall(("gdk_dmabuf_texture_builder_set_width", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _width)
        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 = convert_if_not_null(GdkSurface, ret, false)
        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 = convert_if_not_null(GdkDisplay, ret, false)
        ret2
    end
    function get_frame_region(instance::GdkDrawContext)
        ret = ccall(("gdk_draw_context_get_frame_region", libgtk4), Ptr{cairoRegion}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(cairoRegion, ret, false)
        ret2
    end
    function get_surface(instance::GdkDrawContext)
        ret = ccall(("gdk_draw_context_get_surface", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(GdkSurface, ret, false)
        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 = convert_if_not_null(GdkDrag, ret, false)
        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))
        _cancellable_maybe = nothing_to_null(_cancellable)
        if _callback === nothing
            _callback_cfunc = C_NULL
            _callback_closure = C_NULL
        else
            _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
            _callback_closure = GLib.gc_ref(_callback)
        end
        ret = ccall(("gdk_drop_read_async", libgtk4), Nothing, (Ptr{GObject}, Ptr{Cstring}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _mime_types, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
        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 = convert_if_not_null(GInputStream, ret, true)
        _out_mime_type = m_out_mime_type[]
        _out_mime_type = string_or_nothing(_out_mime_type, false)
        (ret2, _out_mime_type)
    end
    function read_value_async(instance::GdkDrop, _type::Integer, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
        _cancellable_maybe = nothing_to_null(_cancellable)
        if _callback === nothing
            _callback_cfunc = C_NULL
            _callback_closure = C_NULL
        else
            _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
            _callback_closure = GLib.gc_ref(_callback)
        end
        ret = ccall(("gdk_drop_read_value_async", libgtk4), Nothing, (Ptr{GObject}, UInt64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _type, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
        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[]
        _axes = collect(unsafe_wrap(Vector{Float64}, _axes, m_n_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 = convert_if_not_null(GdkDevice, ret, false)
        ret2
    end
    function get_device_tool(instance::GdkEvent)
        ret = ccall(("gdk_event_get_device_tool", libgtk4), Ptr{GObject}, (Ptr{GdkEvent},), instance)
        ret2 = convert_if_not_null(GdkDeviceTool, ret, false)
        ret2
    end
    function get_display(instance::GdkEvent)
        ret = ccall(("gdk_event_get_display", libgtk4), Ptr{GObject}, (Ptr{GdkEvent},), instance)
        ret2 = convert_if_not_null(GdkDisplay, ret, false)
        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
                arrtemp = collect(unsafe_wrap(Vector{_GdkTimeCoord}, ret, m_out_n_coords[]))
                GLib.g_free(ret)
                arrtemp
            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 = convert_if_not_null(GdkSeat, ret, false)
        ret2
    end
    function get_surface(instance::GdkEvent)
        ret = ccall(("gdk_event_get_surface", libgtk4), Ptr{GObject}, (Ptr{GdkEvent},), instance)
        ret2 = convert_if_not_null(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 = convert_if_not_null(GdkFrameTimings, ret, false)
        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 = convert_if_not_null(GdkFrameTimings, ret, false)
        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 = convert_if_not_null(GdkGLContext, ret, false)
        ret2
    end
    function get_allowed_apis(instance::GdkGLContext)
        ret = ccall(("gdk_gl_context_get_allowed_apis", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = GLAPI(ret)
        ret2
    end
    function get_api(instance::GdkGLContext)
        ret = ccall(("gdk_gl_context_get_api", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = GLAPI(ret)
        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 = convert_if_not_null(GdkDisplay, ret, false)
        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 = convert_if_not_null(GdkSurface, ret, false)
        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_allowed_apis(instance::GdkGLContext, _apis)
        ret = ccall(("gdk_gl_context_set_allowed_apis", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _apis)
        nothing
    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 compute_concrete_size(instance::GdkGLTexture, _specified_width::Real, _specified_height::Real, _default_width::Real, _default_height::Real)
        compute_concrete_size(GdkPaintable(instance), _specified_width, _specified_height, _default_width, _default_height)
    end
    function get_current_image(instance::GdkGLTexture)
        get_current_image(GdkPaintable(instance))
    end
    function get_flags(instance::GdkGLTexture)
        get_flags(GdkPaintable(instance))
    end
    function get_intrinsic_aspect_ratio(instance::GdkGLTexture)
        get_intrinsic_aspect_ratio(GdkPaintable(instance))
    end
    function get_intrinsic_height(instance::GdkGLTexture)
        get_intrinsic_height(GdkPaintable(instance))
    end
    function get_intrinsic_width(instance::GdkGLTexture)
        get_intrinsic_width(GdkPaintable(instance))
    end
    function invalidate_contents(instance::GdkGLTexture)
        invalidate_contents(GdkPaintable(instance))
    end
    function invalidate_size(instance::GdkGLTexture)
        invalidate_size(GdkPaintable(instance))
    end
    function snapshot(instance::GdkGLTexture, _snapshot::GdkSnapshot, _width::Real, _height::Real)
        snapshot(GdkPaintable(instance), _snapshot, _width, _height)
    end
    function equal(instance::GdkGLTexture, _icon2::Maybe(GIcon))
        equal(GIcon(instance), _icon2)
    end
    function hash(instance::GdkGLTexture)
        hash(GIcon(instance))
    end
    function serialize(instance::GdkGLTexture)
        serialize(GIcon(instance))
    end
    function to_string(instance::GdkGLTexture)
        to_string(GIcon(instance))
    end
    function load(instance::GdkGLTexture, _size::Integer, _cancellable::Maybe(GCancellable))
        load(GLoadableIcon(instance), _size, _cancellable)
    end
    function load_async(instance::GdkGLTexture, _size::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
        load_async(GLoadableIcon(instance), _size, _cancellable, _callback)
    end
    function load_finish(instance::GdkGLTexture, _res::GAsyncResult)
        load_finish(GLoadableIcon(instance), _res)
    end
    function GLTextureBuilder_new()
        ret = ccall(("gdk_gl_texture_builder_new", libgtk4), Ptr{GObject}, ())
        ret2 = GdkGLTextureBuilderLeaf(ret, true)
        ret2
    end
    function get_context(instance::GdkGLTextureBuilder)
        ret = ccall(("gdk_gl_texture_builder_get_context", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(GdkGLContext, ret, false)
        ret2
    end
    function get_format(instance::GdkGLTextureBuilder)
        ret = ccall(("gdk_gl_texture_builder_get_format", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = MemoryFormat(ret)
        ret2
    end
    function get_has_mipmap(instance::GdkGLTextureBuilder)
        ret = ccall(("gdk_gl_texture_builder_get_has_mipmap", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_height(instance::GdkGLTextureBuilder)
        ret = ccall(("gdk_gl_texture_builder_get_height", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_id(instance::GdkGLTextureBuilder)
        ret = ccall(("gdk_gl_texture_builder_get_id", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret
    end
    function get_sync(instance::GdkGLTextureBuilder)
        ret = ccall(("gdk_gl_texture_builder_get_sync", libgtk4), Ptr{Nothing}, (Ptr{GObject},), instance)
        ret2 = convert(Nothing, ret)
        ret2
    end
    function get_update_region(instance::GdkGLTextureBuilder)
        ret = ccall(("gdk_gl_texture_builder_get_update_region", libgtk4), Ptr{cairoRegion}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(cairoRegion, ret, false)
        ret2
    end
    function get_update_texture(instance::GdkGLTextureBuilder)
        ret = ccall(("gdk_gl_texture_builder_get_update_texture", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(GdkTexture, ret, false)
        ret2
    end
    function get_width(instance::GdkGLTextureBuilder)
        ret = ccall(("gdk_gl_texture_builder_get_width", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function set_context(instance::GdkGLTextureBuilder, _context::Maybe(GdkGLContext))
        _context_maybe = nothing_to_null(_context)
        ret = ccall(("gdk_gl_texture_builder_set_context", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _context_maybe)
        nothing
    end
    function set_format(instance::GdkGLTextureBuilder, _format)
        ret = ccall(("gdk_gl_texture_builder_set_format", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _format)
        nothing
    end
    function set_has_mipmap(instance::GdkGLTextureBuilder, _has_mipmap::Bool)
        ret = ccall(("gdk_gl_texture_builder_set_has_mipmap", libgtk4), Nothing, (Ptr{GObject}, Cint), instance, _has_mipmap)
        nothing
    end
    function set_height(instance::GdkGLTextureBuilder, _height::Integer)
        ret = ccall(("gdk_gl_texture_builder_set_height", libgtk4), Nothing, (Ptr{GObject}, Int32), instance, _height)
        nothing
    end
    function set_id(instance::GdkGLTextureBuilder, _id::Integer)
        ret = ccall(("gdk_gl_texture_builder_set_id", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _id)
        nothing
    end
    function set_sync(instance::GdkGLTextureBuilder, _sync::Maybe(Nothing))
        _sync_maybe = nothing_to_null(_sync)
        ret = ccall(("gdk_gl_texture_builder_set_sync", libgtk4), Nothing, (Ptr{GObject}, Ptr{Nothing}), instance, _sync_maybe)
        nothing
    end
    function set_update_region(instance::GdkGLTextureBuilder, _region::Maybe(cairoRegion))
        _region_maybe = nothing_to_null(_region)
        ret = ccall(("gdk_gl_texture_builder_set_update_region", libgtk4), Nothing, (Ptr{GObject}, Ptr{cairoRegion}), instance, _region_maybe)
        nothing
    end
    function set_update_texture(instance::GdkGLTextureBuilder, _texture::Maybe(GdkTexture))
        _texture_maybe = nothing_to_null(_texture)
        ret = ccall(("gdk_gl_texture_builder_set_update_texture", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _texture_maybe)
        nothing
    end
    function set_width(instance::GdkGLTextureBuilder, _width::Integer)
        ret = ccall(("gdk_gl_texture_builder_set_width", libgtk4), Nothing, (Ptr{GObject}, Int32), instance, _width)
        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 = GdkMemoryTextureLeaf(ret, true)
        ret2
    end
    function compute_concrete_size(instance::GdkMemoryTexture, _specified_width::Real, _specified_height::Real, _default_width::Real, _default_height::Real)
        compute_concrete_size(GdkPaintable(instance), _specified_width, _specified_height, _default_width, _default_height)
    end
    function get_current_image(instance::GdkMemoryTexture)
        get_current_image(GdkPaintable(instance))
    end
    function get_flags(instance::GdkMemoryTexture)
        get_flags(GdkPaintable(instance))
    end
    function get_intrinsic_aspect_ratio(instance::GdkMemoryTexture)
        get_intrinsic_aspect_ratio(GdkPaintable(instance))
    end
    function get_intrinsic_height(instance::GdkMemoryTexture)
        get_intrinsic_height(GdkPaintable(instance))
    end
    function get_intrinsic_width(instance::GdkMemoryTexture)
        get_intrinsic_width(GdkPaintable(instance))
    end
    function invalidate_contents(instance::GdkMemoryTexture)
        invalidate_contents(GdkPaintable(instance))
    end
    function invalidate_size(instance::GdkMemoryTexture)
        invalidate_size(GdkPaintable(instance))
    end
    function snapshot(instance::GdkMemoryTexture, _snapshot::GdkSnapshot, _width::Real, _height::Real)
        snapshot(GdkPaintable(instance), _snapshot, _width, _height)
    end
    function equal(instance::GdkMemoryTexture, _icon2::Maybe(GIcon))
        equal(GIcon(instance), _icon2)
    end
    function hash(instance::GdkMemoryTexture)
        hash(GIcon(instance))
    end
    function serialize(instance::GdkMemoryTexture)
        serialize(GIcon(instance))
    end
    function to_string(instance::GdkMemoryTexture)
        to_string(GIcon(instance))
    end
    function load(instance::GdkMemoryTexture, _size::Integer, _cancellable::Maybe(GCancellable))
        load(GLoadableIcon(instance), _size, _cancellable)
    end
    function load_async(instance::GdkMemoryTexture, _size::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
        load_async(GLoadableIcon(instance), _size, _cancellable, _callback)
    end
    function load_finish(instance::GdkMemoryTexture, _res::GAsyncResult)
        load_finish(GLoadableIcon(instance), _res)
    end
    function get_connector(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_connector", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_description(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_description", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = string_or_nothing(ret, false)
        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 = string_or_nothing(ret, false)
        ret2
    end
    function get_model(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_model", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = string_or_nothing(ret, false)
        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(instance::GdkMonitor)
        ret = ccall(("gdk_monitor_get_scale", libgtk4), Float64, (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 get_unit(instance::GdkScrollEvent)
        ret = ccall(("gdk_scroll_event_get_unit", libgtk4), UInt32, (Ptr{GdkEvent},), instance)
        ret2 = ScrollUnit(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 = convert_if_not_null(GdkDevice, ret, false)
        ret2
    end
    function get_pointer(instance::GdkSeat)
        ret = ccall(("gdk_seat_get_pointer", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(GdkDevice, ret, false)
        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 = convert(GdkGLContext, 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 = convert_if_not_null(GdkCursor, ret, false)
        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 = convert_if_not_null(GdkCursor, ret, false)
        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(instance::GdkSurface)
        ret = ccall(("gdk_surface_get_scale", libgtk4), Float64, (Ptr{GObject},), instance)
        ret
    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_maybe = nothing_to_null(_cursor)
        ret = ccall(("gdk_surface_set_cursor", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _cursor_maybe)
        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_maybe = nothing_to_null(_region)
        ret = ccall(("gdk_surface_set_opaque_region", libgtk4), Nothing, (Ptr{GObject}, Ptr{cairoRegion}), instance, _region_maybe)
        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_bytes(_bytes::GBytes)
        err = err_buf()
        ret = ccall(("gdk_texture_new_from_bytes", libgtk4), Ptr{GObject}, (Ptr{GBytes}, Ptr{Ptr{GError}}), _bytes, err)
        check_err(err)
        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_filename(_path::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("gdk_texture_new_from_filename", libgtk4), Ptr{GObject}, (Cstring, Ptr{Ptr{GError}}), _path, 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 get_format(instance::GdkTexture)
        ret = ccall(("gdk_texture_get_format", libgtk4), UInt32, (Ptr{GObject},), instance)
        ret2 = MemoryFormat(ret)
        ret2
    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 save_to_png_bytes(instance::GdkTexture)
        ret = ccall(("gdk_texture_save_to_png_bytes", libgtk4), Ptr{GBytes}, (Ptr{GObject},), instance)
        ret2 = convert(GBytes, ret, true)
        ret2
    end
    function save_to_tiff(instance::GdkTexture, _filename::Union{AbstractString, Symbol})
        ret = ccall(("gdk_texture_save_to_tiff", libgtk4), Cint, (Ptr{GObject}, Cstring), instance, _filename)
        ret2 = convert(Bool, ret)
        ret2
    end
    function save_to_tiff_bytes(instance::GdkTexture)
        ret = ccall(("gdk_texture_save_to_tiff_bytes", libgtk4), Ptr{GBytes}, (Ptr{GObject},), instance)
        ret2 = convert(GBytes, ret, true)
        ret2
    end
    function compute_concrete_size(instance::GdkTexture, _specified_width::Real, _specified_height::Real, _default_width::Real, _default_height::Real)
        compute_concrete_size(GdkPaintable(instance), _specified_width, _specified_height, _default_width, _default_height)
    end
    function get_current_image(instance::GdkTexture)
        get_current_image(GdkPaintable(instance))
    end
    function get_flags(instance::GdkTexture)
        get_flags(GdkPaintable(instance))
    end
    function get_intrinsic_aspect_ratio(instance::GdkTexture)
        get_intrinsic_aspect_ratio(GdkPaintable(instance))
    end
    function get_intrinsic_height(instance::GdkTexture)
        get_intrinsic_height(GdkPaintable(instance))
    end
    function get_intrinsic_width(instance::GdkTexture)
        get_intrinsic_width(GdkPaintable(instance))
    end
    function invalidate_contents(instance::GdkTexture)
        invalidate_contents(GdkPaintable(instance))
    end
    function invalidate_size(instance::GdkTexture)
        invalidate_size(GdkPaintable(instance))
    end
    function snapshot(instance::GdkTexture, _snapshot::GdkSnapshot, _width::Real, _height::Real)
        snapshot(GdkPaintable(instance), _snapshot, _width, _height)
    end
    function equal(instance::GdkTexture, _icon2::Maybe(GIcon))
        equal(GIcon(instance), _icon2)
    end
    function hash(instance::GdkTexture)
        hash(GIcon(instance))
    end
    function serialize(instance::GdkTexture)
        serialize(GIcon(instance))
    end
    function to_string(instance::GdkTexture)
        to_string(GIcon(instance))
    end
    function load(instance::GdkTexture, _size::Integer, _cancellable::Maybe(GCancellable))
        load(GLoadableIcon(instance), _size, _cancellable)
    end
    function load_async(instance::GdkTexture, _size::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
        load_async(GLoadableIcon(instance), _size, _cancellable, _callback)
    end
    function load_finish(instance::GdkTexture, _res::GAsyncResult)
        load_finish(GLoadableIcon(instance), _res)
    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 init(instance::GdkVulkanContext, _cancellable::Maybe(GCancellable))
        init(GInitable(instance), _cancellable)
    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_if_not_null(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_maybe = nothing_to_null(_device)
        ret = ccall(("gdk_toplevel_begin_resize", libgtk4), Nothing, (Ptr{GObject}, UInt32, Ptr{GObject}, Int32, Float64, Float64, UInt32), instance, _edge, _device_maybe, _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
