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::GStringLike)
    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)
    reffed_instance = GLib.glib_ref(instance)
    ret = ccall(("gdk_content_formats_union", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormats}, Ptr{GdkContentFormats}), reffed_instance, _second)
    ret2 = convert(GdkContentFormats, ret, true)
    ret2
end
function union_deserialize_gtypes(instance::GdkContentFormats)
    reffed_instance = GLib.glib_ref(instance)
    ret = ccall(("gdk_content_formats_union_deserialize_gtypes", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormats},), reffed_instance)
    ret2 = convert(GdkContentFormats, ret, true)
    ret2
end
function union_deserialize_mime_types(instance::GdkContentFormats)
    reffed_instance = GLib.glib_ref(instance)
    ret = ccall(("gdk_content_formats_union_deserialize_mime_types", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormats},), reffed_instance)
    ret2 = convert(GdkContentFormats, ret, true)
    ret2
end
function union_serialize_gtypes(instance::GdkContentFormats)
    reffed_instance = GLib.glib_ref(instance)
    ret = ccall(("gdk_content_formats_union_serialize_gtypes", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormats},), reffed_instance)
    ret2 = convert(GdkContentFormats, ret, true)
    ret2
end
function union_serialize_mime_types(instance::GdkContentFormats)
    reffed_instance = GLib.glib_ref(instance)
    ret = ccall(("gdk_content_formats_union_serialize_mime_types", libgtk4), Ptr{GdkContentFormats}, (Ptr{GdkContentFormats},), reffed_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::GdkRectangleLike, _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(GdkRectangleLike, 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::GdkRectangleLike)
    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::GdkRGBALike)
    ret = ccall(("gdk_rgba_copy", libgtk4), Ptr{_GdkRGBA}, (Ptr{_GdkRGBA},), instance)
    ret2 = convert(GdkRGBALike, ret, true)
    ret2
end
function equal(instance::GdkRGBALike, _p2::GdkRGBALike)
    ret = ccall(("gdk_rgba_equal", libgtk4), Cint, (Ptr{_GdkRGBA}, Ptr{_GdkRGBA}), instance, _p2)
    ret2 = convert(Bool, ret)
    ret2
end
function free(instance::GdkRGBALike)
    ret = ccall(("gdk_rgba_free", libgtk4), Nothing, (Ptr{_GdkRGBA},), instance)
    nothing
end
function hash(instance::GdkRGBALike)
    ret = ccall(("gdk_rgba_hash", libgtk4), UInt32, (Ptr{_GdkRGBA},), instance)
    ret
end
function is_clear(instance::GdkRGBALike)
    ret = ccall(("gdk_rgba_is_clear", libgtk4), Cint, (Ptr{_GdkRGBA},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function is_opaque(instance::GdkRGBALike)
    ret = ccall(("gdk_rgba_is_opaque", libgtk4), Cint, (Ptr{_GdkRGBA},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function parse(instance::GdkRGBALike, _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::GdkRGBALike)
    ret = ccall(("gdk_rgba_to_string", libgtk4), Cstring, (Ptr{_GdkRGBA},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function contains_point(instance::GdkRectangleLike, _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::GdkRectangleLike, _rect2::GdkRectangleLike)
    ret = ccall(("gdk_rectangle_equal", libgtk4), Cint, (Ptr{_GdkRectangle}, Ptr{_GdkRectangle}), instance, _rect2)
    ret2 = convert(Bool, ret)
    ret2
end
function intersect(instance::GdkRectangleLike, _src2::GdkRectangleLike)
    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::GdkRectangleLike, _src2::GdkRectangleLike)
    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(GValueLike, 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::GValueLike)
    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(GValueLike, 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::GValueLike)
    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(GValueLike, 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::GValueLike)
    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(GValueLike, 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)
    reffed_instance = GLib.glib_ref(instance)
    ret = ccall(("gdk_event_unref", libgtk4), Nothing, (Ptr{GdkEvent},), reffed_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
